*
*/
-#include <linux/config.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/mm.h>
-#include <linux/tty.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/fb.h>
static int libretto;
static int nostretch;
static int nopciburst;
-
+static char *mode_option __devinitdata = NULL;
#ifdef MODULE
MODULE_AUTHOR("(c) 2001-2002 Denis Oliver Kropp <dok@convergence.de>");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("FBDev driver for NeoMagic PCI Chips");
-MODULE_PARM(internal, "i");
+module_param(internal, bool, 0);
MODULE_PARM_DESC(internal, "Enable output on internal LCD Display.");
-MODULE_PARM(external, "i");
+module_param(external, bool, 0);
MODULE_PARM_DESC(external, "Enable output on external CRT.");
-MODULE_PARM(libretto, "i");
+module_param(libretto, bool, 0);
MODULE_PARM_DESC(libretto, "Force Libretto 100/110 800x480 LCD.");
-MODULE_PARM(nostretch, "i");
+module_param(nostretch, bool, 0);
MODULE_PARM_DESC(nostretch,
"Disable stretching of modes smaller than LCD.");
-MODULE_PARM(nopciburst, "i");
+module_param(nopciburst, bool, 0);
MODULE_PARM_DESC(nopciburst, "Disable PCI burst mode.");
+module_param(mode_option, charp, 0);
+MODULE_PARM_DESC(mode_option, "Preferred video mode ('640x480-8@60', etc)");
#endif
};
#endif
-static inline u32 read_le32(int regindex, const struct neofb_par *par)
-{
- return readl(par->neo2200 + par->cursorOff + regindex);
-}
-
static inline void write_le32(int regindex, u32 val, const struct neofb_par *par)
{
writel(val, par->neo2200 + par->cursorOff + regindex);
switch (depth) {
case 8:
- size = sizeof(bios8) / sizeof(biosMode);
+ size = ARRAY_SIZE(bios8);
mode = bios8;
break;
case 16:
- size = sizeof(bios16) / sizeof(biosMode);
+ size = ARRAY_SIZE(bios16);
mode = bios16;
break;
case 24:
- size = sizeof(bios24) / sizeof(biosMode);
+ size = ARRAY_SIZE(bios24);
mode = bios24;
break;
#ifdef NO_32BIT_SUPPORT_YET
case 32:
- size = sizeof(bios32) / sizeof(biosMode);
+ size = ARRAY_SIZE(bios32);
mode = bios32;
break;
#endif
*/
static int paletteEnabled = 0;
-inline void VGAenablePalette(void)
+static inline void VGAenablePalette(void)
{
vga_r(NULL, VGA_IS1_RC);
vga_w(NULL, VGA_ATT_W, 0x00);
paletteEnabled = 1;
}
-inline void VGAdisablePalette(void)
+static inline void VGAdisablePalette(void)
{
vga_r(NULL, VGA_IS1_RC);
vga_w(NULL, VGA_ATT_W, 0x20);
paletteEnabled = 0;
}
-inline void VGAwATTR(u8 index, u8 value)
+static inline void VGAwATTR(u8 index, u8 value)
{
if (paletteEnabled)
index &= ~0x20;
vga_wattr(NULL, index, value);
}
-void vgaHWProtect(int on)
+static void vgaHWProtect(int on)
{
unsigned char tmp;
*/
static inline int neo2200_sync(struct fb_info *info)
{
- struct neofb_par *par = (struct neofb_par *) info->par;
- int waitcycles;
+ struct neofb_par *par = info->par;
- while (par->neo2200->bltStat & 1)
- waitcycles++;
+ while (readl(&par->neo2200->bltStat) & 1);
return 0;
}
static inline void neo2200_accel_init(struct fb_info *info,
struct fb_var_screeninfo *var)
{
- struct neofb_par *par = (struct neofb_par *) info->par;
- Neo2200 *neo2200 = par->neo2200;
+ struct neofb_par *par = info->par;
+ Neo2200 __iomem *neo2200 = par->neo2200;
u32 bltMod, pitch;
neo2200_sync(info);
bltMod = NEO_MODE1_DEPTH16;
pitch = var->xres_virtual * 2;
break;
+ case 24:
+ bltMod = NEO_MODE1_DEPTH24;
+ pitch = var->xres_virtual * 3;
+ break;
default:
printk(KERN_ERR
"neofb: neo2200_accel_init: unexpected bits per pixel!\n");
return;
}
- neo2200->bltStat = bltMod << 16;
- neo2200->pitch = (pitch << 16) | pitch;
+ writel(bltMod << 16, &neo2200->bltStat);
+ writel((pitch << 16) | pitch, &neo2200->pitch);
}
/* --------------------------------------------------------------------- */
static int
neofb_open(struct fb_info *info, int user)
{
- struct neofb_par *par = (struct neofb_par *) info->par;
+ struct neofb_par *par = info->par;
int cnt = atomic_read(&par->ref_count);
- if (cnt) {
+ if (!cnt) {
memset(&par->state, 0, sizeof(struct vgastate));
par->state.flags = VGA_SAVE_MODE | VGA_SAVE_FONTS;
save_vga(&par->state);
static int
neofb_release(struct fb_info *info, int user)
{
- struct neofb_par *par = (struct neofb_par *) info->par;
+ struct neofb_par *par = info->par;
int cnt = atomic_read(&par->ref_count);
if (!cnt)
static int
neofb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
{
- struct neofb_par *par = (struct neofb_par *) info->par;
+ struct neofb_par *par = info->par;
unsigned int pixclock = var->pixclock;
struct xtimings timings;
int memlen, vramlen;
var->green.offset = 8;
var->green.length = 8;
var->blue.offset = 0;
+ var->blue.length = 8;
break;
#ifdef NO_32BIT_SUPPORT_YET
static int neofb_set_par(struct fb_info *info)
{
- struct neofb_par *par = (struct neofb_par *) info->par;
+ struct neofb_par *par = info->par;
struct xtimings timings;
unsigned char temp;
int i, clock_hi = 0;
par->SysIfaceCntl2 = 0xc0; /* VESA Bios sets this to 0x80! */
+ /* Initialize: by default, we want display config register to be read */
+ par->PanelDispCntlRegRead = 1;
+
/* Enable any user specified display devices. */
par->PanelDispCntlReg1 = 0x00;
if (par->internal_display)
/* If the user did not specify any display devices, then... */
if (par->PanelDispCntlReg1 == 0x00) {
/* Default to internal (i.e., LCD) only. */
- par->PanelDispCntlReg1 |= 0x02;
+ par->PanelDispCntlReg1 = vga_rgfx(NULL, 0x20) & 0x03;
}
/* If we are using a fixed mode, then tell the chip we are. */
/* Since we program the clocks ourselves, always use VCLK3. */
par->MiscOutReg |= 0x0C;
- /* linear colormap for non palettized modes */
- switch (info->var.bits_per_pixel) {
- case 8:
- /* PseudoColor, 256 */
- info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
- break;
- case 16:
- /* DirectColor, 64k */
- info->fix.visual = FB_VISUAL_DIRECTCOLOR;
-
- for (i = 0; i < 64; i++) {
- outb(i, 0x3c8);
-
- outb(i << 1, 0x3c9);
- outb(i, 0x3c9);
- outb(i << 1, 0x3c9);
- }
- break;
- case 24:
-#ifdef NO_32BIT_SUPPORT_YET
- case 32:
-#endif
- /* TrueColor, 16m */
- info->fix.visual = FB_VISUAL_TRUECOLOR;
-
- for (i = 0; i < 256; i++) {
- outb(i, 0x3c8);
-
- outb(i, 0x3c9);
- outb(i, 0x3c9);
- outb(i, 0x3c9);
- }
- break;
- }
-
/* alread unlocked above */
/* BOGUS vga_wgfx(NULL, 0x09, 0x26); */
* This function handles restoring the generic VGA registers. */
vgaHWRestore(info, par);
+ /* linear colormap for non palettized modes */
+ switch (info->var.bits_per_pixel) {
+ case 8:
+ /* PseudoColor, 256 */
+ info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
+ break;
+ case 16:
+ /* TrueColor, 64k */
+ info->fix.visual = FB_VISUAL_TRUECOLOR;
+
+ for (i = 0; i < 64; i++) {
+ outb(i, 0x3c8);
+
+ outb(i << 1, 0x3c9);
+ outb(i, 0x3c9);
+ outb(i << 1, 0x3c9);
+ }
+ break;
+ case 24:
+#ifdef NO_32BIT_SUPPORT_YET
+ case 32:
+#endif
+ /* TrueColor, 16m */
+ info->fix.visual = FB_VISUAL_TRUECOLOR;
+
+ for (i = 0; i < 256; i++) {
+ outb(i, 0x3c8);
+
+ outb(i, 0x3c9);
+ outb(i, 0x3c9);
+ outb(i, 0x3c9);
+ }
+ break;
+ }
+
vga_wgfx(NULL, 0x0E, par->ExtCRTDispAddr);
vga_wgfx(NULL, 0x0F, par->ExtCRTOffset);
temp = vga_rgfx(NULL, 0x10);
static void neofb_update_start(struct fb_info *info,
struct fb_var_screeninfo *var)
{
- struct neofb_par *par = (struct neofb_par *) info->par;
+ struct neofb_par *par = info->par;
struct vgastate *state = &par->state;
int oldExtCRTDispAddr;
int Base;
static int neofb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
u_int transp, struct fb_info *fb)
{
- if (regno >= 255)
+ if (regno >= fb->cmap.len || regno > 255)
return -EINVAL;
switch (fb->var.bits_per_pixel) {
outb(blue >> 10, 0x3c9);
break;
case 16:
- if (regno < 16)
- ((u16 *) fb->pseudo_palette)[regno] =
- ((red & 0xf800)) | ((green & 0xfc00) >> 5) |
- ((blue & 0xf800) >> 11);
+ ((u32 *) fb->pseudo_palette)[regno] =
+ ((red & 0xf800)) | ((green & 0xfc00) >> 5) |
+ ((blue & 0xf800) >> 11);
break;
case 24:
- if (regno < 16)
- ((u32 *) fb->pseudo_palette)[regno] =
- ((red & 0xff00) << 8) | ((green & 0xff00)) |
- ((blue & 0xff00) >> 8);
+ ((u32 *) fb->pseudo_palette)[regno] =
+ ((red & 0xff00) << 8) | ((green & 0xff00)) |
+ ((blue & 0xff00) >> 8);
break;
#ifdef NO_32BIT_SUPPORT_YET
case 32:
- if (regno < 16)
- ((u32 *) fb->pseudo_palette)[regno] =
- ((transp & 0xff00) << 16) | ((red & 0xff00) <<
- 8) | ((green &
- 0xff00)) |
- ((blue & 0xff00) >> 8);
+ ((u32 *) fb->pseudo_palette)[regno] =
+ ((transp & 0xff00) << 16) | ((red & 0xff00) << 8) |
+ ((green & 0xff00)) | ((blue & 0xff00) >> 8);
break;
#endif
default:
/*
* (Un)Blank the display.
*/
-static int neofb_blank(int blank, struct fb_info *info)
+static int neofb_blank(int blank_mode, struct fb_info *info)
{
/*
- * Blank the screen if blank_mode != 0, else unblank. If
- * blank == NULL then the caller blanks by setting the CLUT
- * (Color Look Up Table) to all black. Return 0 if blanking
- * succeeded, != 0 if un-/blanking failed due to e.g. a
- * video mode which doesn't support it. Implements VESA
- * suspend and powerdown modes on hardware that supports
- * disabling hsync/vsync:
- * blank_mode == 2: suspend vsync
- * blank_mode == 3: suspend hsync
- * blank_mode == 4: powerdown
+ * Blank the screen if blank_mode != 0, else unblank.
+ * Return 0 if blanking succeeded, != 0 if un-/blanking failed due to
+ * e.g. a video mode which doesn't support it. Implements VESA suspend
+ * and powerdown modes for monitors, and backlight control on LCDs.
+ * blank_mode == 0: unblanked (backlight on)
+ * blank_mode == 1: blank (backlight on)
+ * blank_mode == 2: suspend vsync (backlight off)
+ * blank_mode == 3: suspend hsync (backlight off)
+ * blank_mode == 4: powerdown (backlight off)
*
- * wms...Enable VESA DMPS compatible powerdown mode
+ * wms...Enable VESA DPMS compatible powerdown mode
* run "setterm -powersave powerdown" to take advantage
*/
+ struct neofb_par *par = info->par;
+ int seqflags, lcdflags, dpmsflags, reg, tmpdisp;
- switch (blank) {
- case 4: /* powerdown - both sync lines down */
+ /*
+ * Read back the register bits related to display configuration. They might
+ * have been changed underneath the driver via Fn key stroke.
+ */
+ neoUnlock();
+ tmpdisp = vga_rgfx(NULL, 0x20) & 0x03;
+ neoLock(&par->state);
+
+ /* In case we blank the screen, we want to store the possibly new
+ * configuration in the driver. During un-blank, we re-apply this setting,
+ * since the LCD bit will be cleared in order to switch off the backlight.
+ */
+ if (par->PanelDispCntlRegRead) {
+ par->PanelDispCntlReg1 = tmpdisp;
+ }
+ par->PanelDispCntlRegRead = !blank_mode;
+
+ switch (blank_mode) {
+ case FB_BLANK_POWERDOWN: /* powerdown - both sync lines down */
+ seqflags = VGA_SR01_SCREEN_OFF; /* Disable sequencer */
+ lcdflags = 0; /* LCD off */
+ dpmsflags = NEO_GR01_SUPPRESS_HSYNC |
+ NEO_GR01_SUPPRESS_VSYNC;
#ifdef CONFIG_TOSHIBA
+ /* Do we still need this ? */
/* attempt to turn off backlight on toshiba; also turns off external */
{
SMMRegisters regs;
}
#endif
break;
- case 3: /* hsync off */
+ case FB_BLANK_HSYNC_SUSPEND: /* hsync off */
+ seqflags = VGA_SR01_SCREEN_OFF; /* Disable sequencer */
+ lcdflags = 0; /* LCD off */
+ dpmsflags = NEO_GR01_SUPPRESS_HSYNC;
break;
- case 2: /* vsync off */
+ case FB_BLANK_VSYNC_SUSPEND: /* vsync off */
+ seqflags = VGA_SR01_SCREEN_OFF; /* Disable sequencer */
+ lcdflags = 0; /* LCD off */
+ dpmsflags = NEO_GR01_SUPPRESS_VSYNC;
break;
- case 1: /* just software blanking of screen */
+ case FB_BLANK_NORMAL: /* just blank screen (backlight stays on) */
+ seqflags = VGA_SR01_SCREEN_OFF; /* Disable sequencer */
+ /*
+ * During a blank operation with the LID shut, we might store "LCD off"
+ * by mistake. Due to timing issues, the BIOS may switch the lights
+ * back on, and we turn it back off once we "unblank".
+ *
+ * So here is an attempt to implement ">=" - if we are in the process
+ * of unblanking, and the LCD bit is unset in the driver but set in the
+ * register, we must keep it.
+ */
+ lcdflags = ((par->PanelDispCntlReg1 | tmpdisp) & 0x02); /* LCD normal */
+ dpmsflags = 0x00; /* no hsync/vsync suppression */
break;
- default: /* case 0, or anything else: unblank */
+ case FB_BLANK_UNBLANK: /* unblank */
+ seqflags = 0; /* Enable sequencer */
+ lcdflags = ((par->PanelDispCntlReg1 | tmpdisp) & 0x02); /* LCD normal */
+ dpmsflags = 0x00; /* no hsync/vsync suppression */
#ifdef CONFIG_TOSHIBA
+ /* Do we still need this ? */
/* attempt to re-enable backlight/external on toshiba */
{
SMMRegisters regs;
}
#endif
break;
+ default: /* Anything else we don't understand; return 1 to tell
+ * fb_blank we didn't aactually do anything */
+ return 1;
}
+
+ neoUnlock();
+ reg = (vga_rseq(NULL, 0x01) & ~0x20) | seqflags;
+ vga_wseq(NULL, 0x01, reg);
+ reg = (vga_rgfx(NULL, 0x20) & ~0x02) | lcdflags;
+ vga_wgfx(NULL, 0x20, reg);
+ reg = (vga_rgfx(NULL, 0x01) & ~0xF0) | 0x80 | dpmsflags;
+ vga_wgfx(NULL, 0x01, reg);
+ neoLock(&par->state);
return 0;
}
static void
neo2200_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
{
- struct neofb_par *par = (struct neofb_par *) info->par;
+ struct neofb_par *par = info->par;
u_long dst, rop;
dst = rect->dx + rect->dy * info->var.xres_virtual;
neo2200_wait_fifo(info, 4);
/* set blt control */
- par->neo2200->bltCntl = NEO_BC3_FIFO_EN |
- NEO_BC0_SRC_IS_FG | NEO_BC3_SKIP_MAPPING |
- // NEO_BC3_DST_XY_ADDR |
- // NEO_BC3_SRC_XY_ADDR |
- rop;
+ writel(NEO_BC3_FIFO_EN |
+ NEO_BC0_SRC_IS_FG | NEO_BC3_SKIP_MAPPING |
+ // NEO_BC3_DST_XY_ADDR |
+ // NEO_BC3_SRC_XY_ADDR |
+ rop, &par->neo2200->bltCntl);
switch (info->var.bits_per_pixel) {
case 8:
- par->neo2200->fgColor = rect->color;
+ writel(rect->color, &par->neo2200->fgColor);
break;
case 16:
- par->neo2200->fgColor =
- ((u16 *) (info->pseudo_palette))[rect->color];
+ case 24:
+ writel(((u32 *) (info->pseudo_palette))[rect->color],
+ &par->neo2200->fgColor);
break;
}
- par->neo2200->dstStart =
- dst * ((info->var.bits_per_pixel + 7) >> 3);
- par->neo2200->xyExt =
- (rect->height << 16) | (rect->width & 0xffff);
+ writel(dst * ((info->var.bits_per_pixel + 7) >> 3),
+ &par->neo2200->dstStart);
+ writel((rect->height << 16) | (rect->width & 0xffff),
+ &par->neo2200->xyExt);
}
static void
neo2200_copyarea(struct fb_info *info, const struct fb_copyarea *area)
{
u32 sx = area->sx, sy = area->sy, dx = area->dx, dy = area->dy;
- struct neofb_par *par = (struct neofb_par *) info->par;
+ struct neofb_par *par = info->par;
u_long src, dst, bltCntl;
bltCntl = NEO_BC3_FIFO_EN | NEO_BC3_SKIP_MAPPING | 0x0C0000;
neo2200_wait_fifo(info, 4);
/* set blt control */
- par->neo2200->bltCntl = bltCntl;
+ writel(bltCntl, &par->neo2200->bltCntl);
- par->neo2200->srcStart = src;
- par->neo2200->dstStart = dst;
- par->neo2200->xyExt =
- (area->height << 16) | (area->width & 0xffff);
+ writel(src, &par->neo2200->srcStart);
+ writel(dst, &par->neo2200->dstStart);
+ writel((area->height << 16) | (area->width & 0xffff),
+ &par->neo2200->xyExt);
}
-/*
static void
neo2200_imageblit(struct fb_info *info, const struct fb_image *image)
{
- struct neofb_par *par = (struct neofb_par *) info->par;
+ struct neofb_par *par = info->par;
+ int s_pitch = (image->width * image->depth + 7) >> 3;
+ int scan_align = info->pixmap.scan_align - 1;
+ int buf_align = info->pixmap.buf_align - 1;
+ int bltCntl_flags, d_pitch, data_len;
+
+ // The data is padded for the hardware
+ d_pitch = (s_pitch + scan_align) & ~scan_align;
+ data_len = ((d_pitch * image->height) + buf_align) & ~buf_align;
neo2200_sync(info);
+ if (image->depth == 1) {
+ if (info->var.bits_per_pixel == 24 && image->width < 16) {
+ /* FIXME. There is a bug with accelerated color-expanded
+ * transfers in 24 bit mode if the image being transferred
+ * is less than 16 bits wide. This is due to insufficient
+ * padding when writing the image. We need to adjust
+ * struct fb_pixmap. Not yet done. */
+ return cfb_imageblit(info, image);
+ }
+ bltCntl_flags = NEO_BC0_SRC_MONO;
+ } else if (image->depth == info->var.bits_per_pixel) {
+ bltCntl_flags = 0;
+ } else {
+ /* We don't currently support hardware acceleration if image
+ * depth is different from display */
+ return cfb_imageblit(info, image);
+ }
+
switch (info->var.bits_per_pixel) {
case 8:
- par->neo2200->fgColor = image->fg_color;
- par->neo2200->bgColor = image->bg_color;
+ writel(image->fg_color, &par->neo2200->fgColor);
+ writel(image->bg_color, &par->neo2200->bgColor);
break;
case 16:
- par->neo2200->fgColor =
- ((u16 *) (info->pseudo_palette))[image->fg_color];
- par->neo2200->bgColor =
- ((u16 *) (info->pseudo_palette))[image->bg_color];
+ case 24:
+ writel(((u32 *) (info->pseudo_palette))[image->fg_color],
+ &par->neo2200->fgColor);
+ writel(((u32 *) (info->pseudo_palette))[image->bg_color],
+ &par->neo2200->bgColor);
break;
}
- par->neo2200->bltCntl = NEO_BC0_SYS_TO_VID |
- NEO_BC0_SRC_MONO | NEO_BC3_SKIP_MAPPING |
- // NEO_BC3_DST_XY_ADDR |
- 0x0c0000;
+ writel(NEO_BC0_SYS_TO_VID |
+ NEO_BC3_SKIP_MAPPING | bltCntl_flags |
+ // NEO_BC3_DST_XY_ADDR |
+ 0x0c0000, &par->neo2200->bltCntl);
- par->neo2200->srcStart = 0;
+ writel(0, &par->neo2200->srcStart);
// par->neo2200->dstStart = (image->dy << 16) | (image->dx & 0xffff);
- par->neo2200->dstStart =
- ((image->dx & 0xffff) * (info->var.bits_per_pixel >> 3) +
- image->dy * info->fix.line_length);
- par->neo2200->xyExt =
- (image->height << 16) | (image->width & 0xffff);
-
- memcpy(par->mmio_vbase + 0x100000, image->data,
- (image->width * image->height) >> 3);
+ writel(((image->dx & 0xffff) * (info->var.bits_per_pixel >> 3) +
+ image->dy * info->fix.line_length), &par->neo2200->dstStart);
+ writel((image->height << 16) | (image->width & 0xffff),
+ &par->neo2200->xyExt);
+
+ memcpy_toio(par->mmio_vbase + 0x100000, image->data, data_len);
}
-*/
static void
neofb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
static void
neofb_imageblit(struct fb_info *info, const struct fb_image *image)
{
-/*
- if (image->depth == 1) {
- switch (info->fix.accel) {
- case FB_ACCEL_NEOMAGIC_NM2200:
- case FB_ACCEL_NEOMAGIC_NM2230:
- case FB_ACCEL_NEOMAGIC_NM2360:
- case FB_ACCEL_NEOMAGIC_NM2380:
- neo2200_imageblit(info, image);
- break;
- default:
- cfb_imageblit(info, image);
- break;
- }
- } else
-*/
- cfb_imageblit(info, image);
-}
+ switch (info->fix.accel) {
+ case FB_ACCEL_NEOMAGIC_NM2200:
+ case FB_ACCEL_NEOMAGIC_NM2230:
+ case FB_ACCEL_NEOMAGIC_NM2360:
+ case FB_ACCEL_NEOMAGIC_NM2380:
+ neo2200_imageblit(info, image);
+ break;
+ default:
+ cfb_imageblit(info, image);
+ break;
+ }
+}
static int
neofb_sync(struct fb_info *info)
.fb_fillrect = neofb_fillrect,
.fb_copyarea = neofb_copyarea,
.fb_imageblit = neofb_imageblit,
- .fb_cursor = soft_cursor,
};
/* --------------------------------------------------------------------- */
-static struct fb_var_screeninfo __devinitdata neofb_var640x480x8 = {
- .accel_flags = FB_ACCELF_TEXT,
- .xres = 640,
- .yres = 480,
- .xres_virtual = 640,
- .yres_virtual = 30000,
- .bits_per_pixel = 8,
- .pixclock = 39722,
- .left_margin = 48,
- .right_margin = 16,
- .upper_margin = 33,
- .lower_margin = 10,
- .hsync_len = 96,
- .vsync_len = 2,
- .vmode = FB_VMODE_NONINTERLACED
-};
-
-static struct fb_var_screeninfo __devinitdata neofb_var800x600x8 = {
- .accel_flags = FB_ACCELF_TEXT,
- .xres = 800,
- .yres = 600,
- .xres_virtual = 800,
- .yres_virtual = 30000,
- .bits_per_pixel = 8,
- .pixclock = 25000,
- .left_margin = 88,
- .right_margin = 40,
- .upper_margin = 23,
- .lower_margin = 1,
- .hsync_len = 128,
- .vsync_len = 4,
- .sync = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
- .vmode = FB_VMODE_NONINTERLACED
-};
-
-static struct fb_var_screeninfo __devinitdata neofb_var800x480x8 = {
- .accel_flags = FB_ACCELF_TEXT,
+static struct fb_videomode __devinitdata mode800x480 = {
.xres = 800,
.yres = 480,
- .xres_virtual = 800,
- .yres_virtual = 30000,
- .bits_per_pixel = 8,
.pixclock = 25000,
.left_margin = 88,
.right_margin = 40,
.vmode = FB_VMODE_NONINTERLACED
};
-static struct fb_var_screeninfo __devinitdata neofb_var1024x768x8 = {
- .accel_flags = FB_ACCELF_TEXT,
- .xres = 1024,
- .yres = 768,
- .xres_virtual = 1024,
- .yres_virtual = 30000,
- .bits_per_pixel = 8,
- .pixclock = 15385,
- .left_margin = 160,
- .right_margin = 24,
- .upper_margin = 29,
- .lower_margin = 3,
- .hsync_len = 136,
- .vsync_len = 6,
- .sync = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
- .vmode = FB_VMODE_NONINTERLACED
-};
-
-#ifdef NOT_DONE
-static struct fb_var_screeninfo __devinitdata neofb_var1280x1024x8 = {
- .accel_flags = FB_ACCELF_TEXT,
- .xres = 1280,
- .yres = 1024,
- .xres_virtual = 1280,
- .yres_virtual = 30000,
- .bits_per_pixel = 8,
- .pixclock = 9260,
- .left_margin = 248,
- .right_margin = 48,
- .upper_margin = 38,
- .lower_margin = 1,
- .hsync_len = 112,
- .vsync_len = 3,
- .sync = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
- .vmode = FB_VMODE_NONINTERLACED
-};
-#endif
-
static int __devinit neo_map_mmio(struct fb_info *info,
struct pci_dev *dev)
{
- struct neofb_par *par = (struct neofb_par *) info->par;
+ struct neofb_par *par = info->par;
DBG("neo_map_mmio");
- info->fix.mmio_start = pci_resource_start(dev, 1);
+ switch (info->fix.accel) {
+ case FB_ACCEL_NEOMAGIC_NM2070:
+ info->fix.mmio_start = pci_resource_start(dev, 0)+
+ 0x100000;
+ break;
+ case FB_ACCEL_NEOMAGIC_NM2090:
+ case FB_ACCEL_NEOMAGIC_NM2093:
+ info->fix.mmio_start = pci_resource_start(dev, 0)+
+ 0x200000;
+ break;
+ case FB_ACCEL_NEOMAGIC_NM2160:
+ case FB_ACCEL_NEOMAGIC_NM2097:
+ case FB_ACCEL_NEOMAGIC_NM2200:
+ case FB_ACCEL_NEOMAGIC_NM2230:
+ case FB_ACCEL_NEOMAGIC_NM2360:
+ case FB_ACCEL_NEOMAGIC_NM2380:
+ info->fix.mmio_start = pci_resource_start(dev, 1);
+ break;
+ default:
+ info->fix.mmio_start = pci_resource_start(dev, 0);
+ }
info->fix.mmio_len = MMIO_SIZE;
if (!request_mem_region
static void neo_unmap_mmio(struct fb_info *info)
{
- struct neofb_par *par = (struct neofb_par *) info->par;
+ struct neofb_par *par = info->par;
DBG("neo_unmap_mmio");
#endif
/* Clear framebuffer, it's all white in memory after boot */
- memset(info->screen_base, 0, info->fix.smem_len);
+ memset_io(info->screen_base, 0, info->fix.smem_len);
/* Allocate Cursor drawing pad.
info->fix.smem_len -= PAGE_SIZE;
static void neo_unmap_video(struct fb_info *info)
{
+ DBG("neo_unmap_video");
+
#ifdef CONFIG_MTRR
- struct neofb_par *par = (struct neofb_par *) info->par;
+ {
+ struct neofb_par *par = info->par;
- mtrr_del(par->mtrr, info->fix.smem_start,
- info->fix.smem_len);
+ mtrr_del(par->mtrr, info->fix.smem_start,
+ info->fix.smem_len);
+ }
#endif
iounmap(info->screen_base);
info->screen_base = NULL;
info->fix.smem_len);
}
-static int __devinit neo_init_hw(struct fb_info *info)
+static int __devinit neo_scan_monitor(struct fb_info *info)
{
- struct neofb_par *par = (struct neofb_par *) info->par;
+ struct neofb_par *par = info->par;
unsigned char type, display;
- int videoRam = 896;
- int maxClock = 65000;
- int CursorMem = 1024;
- int CursorOff = 0x100;
- int linearSize = 1024;
- int maxWidth = 1024;
- int maxHeight = 1024;
int w;
- DBG("neo_init_hw");
-
- neoUnlock();
-
-#if 0
- printk(KERN_DEBUG "--- Neo extended register dump ---\n");
- for (w = 0; w < 0x85; w++)
- printk(KERN_DEBUG "CR %p: %p\n", (void *) w,
- (void *) vga_rcrt(NULL, w);
- for (w = 0; w < 0xC7; w++)
- printk(KERN_DEBUG "GR %p: %p\n", (void *) w,
- (void *) vga_rgfx(NULL, w));
-#endif
+ // Eventually we will have i2c support.
+ info->monspecs.modedb = kmalloc(sizeof(struct fb_videomode), GFP_KERNEL);
+ if (!info->monspecs.modedb)
+ return -ENOMEM;
+ info->monspecs.modedb_len = 1;
/* Determine the panel type */
vga_wgfx(NULL, 0x09, 0x26);
vga_wgfx(NULL, 0x09, 0x00);
switch ((w & 0x18) >> 3) {
case 0x00:
+ // 640x480@60
par->NeoPanelWidth = 640;
par->NeoPanelHeight = 480;
- info->var = neofb_var640x480x8;
+ memcpy(info->monspecs.modedb, &vesa_modes[3], sizeof(struct fb_videomode));
break;
case 0x01:
par->NeoPanelWidth = 800;
- par->NeoPanelHeight = par->libretto ? 480 : 600;
- info->var = par->libretto ? neofb_var800x480x8 : neofb_var800x600x8;
+ if (par->libretto) {
+ par->NeoPanelHeight = 480;
+ memcpy(info->monspecs.modedb, &mode800x480, sizeof(struct fb_videomode));
+ } else {
+ // 800x600@60
+ par->NeoPanelHeight = 600;
+ memcpy(info->monspecs.modedb, &vesa_modes[8], sizeof(struct fb_videomode));
+ }
break;
case 0x02:
+ // 1024x768@60
par->NeoPanelWidth = 1024;
par->NeoPanelHeight = 768;
- info->var = neofb_var1024x768x8;
+ memcpy(info->monspecs.modedb, &vesa_modes[13], sizeof(struct fb_videomode));
break;
case 0x03:
- /* 1280x1024 panel support needs to be added */
+ /* 1280x1024@60 panel support needs to be added */
#ifdef NOT_DONE
par->NeoPanelWidth = 1280;
par->NeoPanelHeight = 1024;
- info->var = neofb_var1280x1024x8;
+ memcpy(info->monspecs.modedb, &vesa_modes[20], sizeof(struct fb_videomode));
break;
#else
printk(KERN_ERR
return -1;
#endif
default:
+ // 640x480@60
par->NeoPanelWidth = 640;
par->NeoPanelHeight = 480;
- info->var = neofb_var640x480x8;
+ memcpy(info->monspecs.modedb, &vesa_modes[3], sizeof(struct fb_videomode));
break;
}
par->NeoPanelHeight,
(type & 0x02) ? "color" : "monochrome",
(type & 0x10) ? "TFT" : "dual scan");
+ return 0;
+}
+static int __devinit neo_init_hw(struct fb_info *info)
+{
+ struct neofb_par *par = info->par;
+ int videoRam = 896;
+ int maxClock = 65000;
+ int CursorMem = 1024;
+ int CursorOff = 0x100;
+ int linearSize = 1024;
+ int maxWidth = 1024;
+ int maxHeight = 1024;
+
+ DBG("neo_init_hw");
+
+ neoUnlock();
+
+#if 0
+ printk(KERN_DEBUG "--- Neo extended register dump ---\n");
+ for (int w = 0; w < 0x85; w++)
+ printk(KERN_DEBUG "CR %p: %p\n", (void *) w,
+ (void *) vga_rcrt(NULL, w);
+ for (int w = 0; w < 0xC7; w++)
+ printk(KERN_DEBUG "GR %p: %p\n", (void *) w,
+ (void *) vga_rgfx(NULL, w));
+#endif
switch (info->fix.accel) {
case FB_ACCEL_NEOMAGIC_NM2070:
videoRam = 896;
maxWidth = 1280;
maxHeight = 1024; /* ???? */
- par->neo2200 = (Neo2200 *) par->mmio_vbase;
+ par->neo2200 = (Neo2200 __iomem *) par->mmio_vbase;
break;
case FB_ACCEL_NEOMAGIC_NM2230:
videoRam = 3008;
maxWidth = 1280;
maxHeight = 1024; /* ???? */
- par->neo2200 = (Neo2200 *) par->mmio_vbase;
+ par->neo2200 = (Neo2200 __iomem *) par->mmio_vbase;
break;
case FB_ACCEL_NEOMAGIC_NM2360:
videoRam = 4096;
maxWidth = 1280;
maxHeight = 1024; /* ???? */
- par->neo2200 = (Neo2200 *) par->mmio_vbase;
+ par->neo2200 = (Neo2200 __iomem *) par->mmio_vbase;
break;
case FB_ACCEL_NEOMAGIC_NM2380:
videoRam = 6144;
maxWidth = 1280;
maxHeight = 1024; /* ???? */
- par->neo2200 = (Neo2200 *) par->mmio_vbase;
+ par->neo2200 = (Neo2200 __iomem *) par->mmio_vbase;
break;
}
/*
struct fb_info *info;
struct neofb_par *par;
- info = framebuffer_alloc(sizeof(struct neofb_par) + sizeof(u32) * 256, &dev->dev);
+ info = framebuffer_alloc(sizeof(struct neofb_par), &dev->dev);
if (!info)
return NULL;
par->internal_display = internal;
par->external_display = external;
+ info->flags = FBINFO_DEFAULT | FBINFO_HWACCEL_YPAN;
switch (info->fix.accel) {
case FB_ACCEL_NEOMAGIC_NM2070:
break;
case FB_ACCEL_NEOMAGIC_NM2200:
sprintf(info->fix.id, "MagicGraph 256AV");
+ info->flags |= FBINFO_HWACCEL_IMAGEBLIT |
+ FBINFO_HWACCEL_COPYAREA |
+ FBINFO_HWACCEL_FILLRECT;
break;
case FB_ACCEL_NEOMAGIC_NM2230:
sprintf(info->fix.id, "MagicGraph 256AV+");
+ info->flags |= FBINFO_HWACCEL_IMAGEBLIT |
+ FBINFO_HWACCEL_COPYAREA |
+ FBINFO_HWACCEL_FILLRECT;
break;
case FB_ACCEL_NEOMAGIC_NM2360:
sprintf(info->fix.id, "MagicGraph 256ZX");
+ info->flags |= FBINFO_HWACCEL_IMAGEBLIT |
+ FBINFO_HWACCEL_COPYAREA |
+ FBINFO_HWACCEL_FILLRECT;
break;
case FB_ACCEL_NEOMAGIC_NM2380:
sprintf(info->fix.id, "MagicGraph 256XL+");
+ info->flags |= FBINFO_HWACCEL_IMAGEBLIT |
+ FBINFO_HWACCEL_COPYAREA |
+ FBINFO_HWACCEL_FILLRECT;
break;
}
info->fix.accel = id->driver_data;
info->fbops = &neofb_ops;
- info->flags = FBINFO_FLAG_DEFAULT;
- info->pseudo_palette = (void *) (par + 1);
+ info->pseudo_palette = par->palette;
return info;
}
{
struct fb_info *info;
u_int h_sync, v_sync;
- int err;
- int video_len;
+ int video_len, err;
DBG("neofb_probe");
if (err)
goto err_map_mmio;
+ err = neo_scan_monitor(info);
+ if (err)
+ goto err_scan_monitor;
+
video_len = neo_init_hw(info);
if (video_len < 0) {
err = video_len;
if (err)
goto err_init_hw;
- if (neofb_check_var(&info->var, info))
+ if (!fb_find_mode(&info->var, info, mode_option, NULL, 0,
+ info->monspecs.modedb, 16)) {
+ printk(KERN_ERR "neofb: Unable to find usable video mode.\n");
goto err_map_video;
+ }
/*
* Calculate the hsync and vsync frequencies. Note that
err_map_video:
neo_unmap_video(info);
err_init_hw:
+ fb_destroy_modedb(info->monspecs.modedb);
+err_scan_monitor:
neo_unmap_mmio(info);
err_map_mmio:
neo_free_fb_info(info);
"neofb: danger danger! Oopsen imminent!\n");
neo_unmap_video(info);
+ fb_destroy_modedb(info->monspecs.modedb);
neo_unmap_mmio(info);
neo_free_fb_info(info);
/* ************************* init in-kernel code ************************** */
-int __init neofb_setup(char *options)
+#ifndef MODULE
+static int __init neofb_setup(char *options)
{
char *this_opt;
if (!strncmp(this_opt, "internal", 8))
internal = 1;
- if (!strncmp(this_opt, "external", 8))
+ else if (!strncmp(this_opt, "external", 8))
external = 1;
- if (!strncmp(this_opt, "nostretch", 9))
+ else if (!strncmp(this_opt, "nostretch", 9))
nostretch = 1;
- if (!strncmp(this_opt, "nopciburst", 10))
+ else if (!strncmp(this_opt, "nopciburst", 10))
nopciburst = 1;
- if (!strncmp(this_opt, "libretto", 8))
+ else if (!strncmp(this_opt, "libretto", 8))
libretto = 1;
+ else
+ mode_option = this_opt;
}
-
return 0;
}
+#endif /* MODULE */
-int __init neofb_init(void)
+static int __init neofb_init(void)
{
+#ifndef MODULE
+ char *option = NULL;
+
+ if (fb_get_options("neofb", &option))
+ return -ENODEV;
+ neofb_setup(option);
+#endif
return pci_register_driver(&neofb_driver);
}
-#ifdef MODULE
+module_init(neofb_init);
+#ifdef MODULE
static void __exit neofb_exit(void)
{
pci_unregister_driver(&neofb_driver);
}
-module_init(neofb_init);
module_exit(neofb_exit);
#endif /* MODULE */
git://git.onelab.eu / linux-2.6.git / blobdiff