/* * linux/drivers/video/cyberfb.c -- CyberVision64 frame buffer device * * Copyright (C) 1996 Martin Apel * Geert Uytterhoeven * * * This file is based on the Amiga frame buffer device (amifb.c): * * Copyright (C) 1995 Geert Uytterhoeven * * * History: * - 22 Dec 95: Original version by Martin Apel * - 05 Jan 96: Geert: integration into the current source tree * * * This file is subject to the terms and conditions of the GNU General Public * License. See the file COPYING in the main directory of this archive * for more details. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "s3blit.h" #define arraysize(x) (sizeof(x)/sizeof(*(x))) struct Cyber_fb_par { int xres; int yres; int bpp; }; static struct Cyber_fb_par current_par; static int current_par_valid = 0; static int currcon = 0; static struct display disp; static struct fb_info fb_info; /* * Switch for Chipset Independency */ static struct fb_hwswitch { /* Initialisation */ int (*init)(void); /* Display Control */ int (*encode_fix)(struct fb_fix_screeninfo *fix, struct Cyber_fb_par *par); int (*decode_var)(struct fb_var_screeninfo *var, struct Cyber_fb_par *par); int (*encode_var)(struct fb_var_screeninfo *var, struct Cyber_fb_par *par); int (*getcolreg)(u_int regno, u_int *red, u_int *green, u_int *blue, u_int *transp); int (*setcolreg)(u_int regno, u_int red, u_int green, u_int blue, u_int transp); void (*blank)(int blank); } *fbhw; /* * Frame Buffer Name */ static char Cyber_fb_name[16] = "Cybervision"; /* * Cybervision Graphics Board */ #define CYBER8_WIDTH 1152 #define CYBER8_HEIGHT 886 #define CYBER8_PIXCLOCK 12500 /* ++Geert: Just a guess */ #if 0 #define CYBER16_WIDTH 800 #define CYBER16_HEIGHT 600 #endif #define CYBER16_PIXCLOCK 25000 /* ++Geert: Just a guess */ static unsigned int CyberKey = 0; static unsigned char Cyber_colour_table [256][4]; static unsigned long CyberMem; static unsigned long CyberSize; static volatile char *CyberRegs; /* * Predefined Video Mode Names */ static char *Cyber_fb_modenames[] = { /* * Autodetect (Default) Video Mode */ "default", /* * Predefined Video Modes */ "cyber8", /* Cybervision 8 bpp */ "cyber16", /* Cybervision 16 bpp */ "800x600x8", "640x480x8", /* * Dummy Video Modes */ "dummy", "dummy", "dummy", "dummy", "dummy", "dummy", "dummy", "dummy", "dummy", "dummy", "dummy", "dummy", "dummy", "dummy", "dummy", "dummy", "dummy", "dummy", /* * User Defined Video Modes * * This doesn't work yet!! */ "user0", "user1", "user2", "user3", "user4", "user5", "user6", "user7" }; /* * Predefined Video Mode Definitions */ static struct fb_var_screeninfo cyber_fb_predefined[] = { /* * Autodetect (Default) Video Mode */ { 0, }, /* * Predefined Video Modes */ { /* Cybervision 8 bpp */ CYBER8_WIDTH, CYBER8_HEIGHT, CYBER8_WIDTH, CYBER8_HEIGHT, 0, 0, 8, 0, {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0}, 0, 0, -1, -1, FB_ACCEL_NONE, CYBER8_PIXCLOCK, 64, 96, 35, 12, 112, 2, FB_SYNC_COMP_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED }, { /* Cybervision 16 bpp */ 800, 600, 800, 600, 0, 0, 16, 0, {11, 5, 0}, {5, 6, 0}, {0, 5, 0}, {0, 0, 0}, 0, 0, -1, -1, FB_ACCEL_NONE, CYBER16_PIXCLOCK, 64, 96, 35, 12, 112, 2, FB_SYNC_COMP_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED }, { /* Cybervision 8 bpp */ 800, 600, 800, 600, 0, 0, 8, 0, {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0}, 0, 0, -1, -1, FB_ACCEL_NONE, CYBER8_PIXCLOCK, 64, 96, 35, 12, 112, 2, FB_SYNC_COMP_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED }, { /* Cybervision 8 bpp */ 640, 480, 640, 480, 0, 0, 8, 0, {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0}, 0, 0, -1, -1, FB_ACCEL_NONE, CYBER8_PIXCLOCK, 64, 96, 35, 12, 112, 2, FB_SYNC_COMP_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED }, /* * Dummy Video Modes */ { 0, }, { 0, }, { 0, }, { 0, }, { 0, }, { 0, }, { 0, }, { 0, }, { 0, }, { 0, }, { 0, }, { 0, }, { 0, }, { 0, }, { 0, }, { 0, }, { 0, }, { 0, }, /* * User Defined Video Modes */ { 0, }, { 0, }, { 0, }, { 0, }, { 0, }, { 0, }, { 0, }, { 0, } }; #define NUM_TOTAL_MODES arraysize(cyber_fb_predefined) #define NUM_PREDEF_MODES (5) static int Cyberfb_inverse = 0; #if 0 static int Cyberfb_Cyber8 = 0; /* Use Cybervision board */ static int Cyberfb_Cyber16 = 0; /* Use Cybervision board */ #endif static int Cyberfb_mode = 0; /* * Some default modes */ #define CYBER8_DEFMODE (1) #define CYBER16_DEFMODE (2) /* * Interface used by the world */ void Cyber_video_setup(char *options, int *ints); static int Cyber_fb_open(int fbidx); static int Cyber_fb_release(int fbidx); static int Cyber_fb_get_fix(struct fb_fix_screeninfo *fix, int con); static int Cyber_fb_get_var(struct fb_var_screeninfo *var, int con); static int Cyber_fb_set_var(struct fb_var_screeninfo *var, int con); static int Cyber_fb_get_cmap(struct fb_cmap *cmap, int kspc, int con); static int Cyber_fb_set_cmap(struct fb_cmap *cmap, int kspc, int con); static int Cyber_fb_pan_display(struct fb_var_screeninfo *var, int con); static int Cyber_fb_ioctl(struct inode *inode, struct file *file, u_int cmd, u_long arg, int con); /* * Interface to the low level console driver */ unsigned long Cyber_fb_init(unsigned long mem_start); static int Cyberfb_switch(int con); static int Cyberfb_updatevar(int con); static void Cyberfb_blank(int blank); static int Cyberfb_setcmap(struct fb_cmap *cmap, int con); /* * Accelerated Functions used by the low level console driver */ void Cyber_WaitQueue(u_short fifo); void Cyber_WaitBlit(void); void Cyber_BitBLT(u_short curx, u_short cury, u_short destx, u_short desty, u_short width, u_short height, u_short mode); void Cyber_RectFill(u_short x, u_short y, u_short width, u_short height, u_short mode, u_short color); void Cyber_MoveCursor(u_short x, u_short y); /* * Hardware Specific Routines */ static int Cyber_init(void); static int Cyber_encode_fix(struct fb_fix_screeninfo *fix, struct Cyber_fb_par *par); static int Cyber_decode_var(struct fb_var_screeninfo *var, struct Cyber_fb_par *par); static int Cyber_encode_var(struct fb_var_screeninfo *var, struct Cyber_fb_par *par); static int Cyber_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue, u_int *transp); static int Cyber_setcolreg(u_int regno, u_int red, u_int green, u_int blue, u_int transp); static void Cyber_blank(int blank); /* * Internal routines */ static void Cyber_fb_get_par(struct Cyber_fb_par *par); static void Cyber_fb_set_par(struct Cyber_fb_par *par); static int do_fb_set_var(struct fb_var_screeninfo *var, int isactive); static void do_install_cmap(int con); static void Cyber_fb_set_disp(int con); static int get_video_mode(const char *name); /* -------------------- Hardware specific routines ------------------------- */ /* * Initialization * * Set the default video mode for this chipset. If a video mode was * specified on the command line, it will override the default mode. */ static int Cyber_init(void) { int i; char size; volatile u_long *CursorBase; #if 0 if (Cyberfb_mode == -1) { if (Cyberfb_Cyber8) Cyberfb_mode = CYBER8_DEFMODE; else Cyberfb_mode = CYBER16_DEFMODE; } #endif for (i = 0; i < 256; i++) for (i = 0; i < 256; i++) { Cyber_colour_table [i][0] = i; Cyber_colour_table [i][1] = i; Cyber_colour_table [i][2] = i; Cyber_colour_table [i][3] = 0; } /* * Just clear the thing for the biggest mode. */ memset ((char*)CyberMem, 0, CYBER8_WIDTH * CYBER8_HEIGHT); /* Disable hardware cursor */ *(CyberRegs + S3_CRTC_ADR) = S3_REG_LOCK2; *(CyberRegs + S3_CRTC_DATA) = 0xa0; *(CyberRegs + S3_CRTC_ADR) = S3_HGC_MODE; *(CyberRegs + S3_CRTC_DATA) = 0x00; *(CyberRegs + S3_CRTC_ADR) = S3_HWGC_DX; *(CyberRegs + S3_CRTC_DATA) = 0x00; *(CyberRegs + S3_CRTC_ADR) = S3_HWGC_DY; *(CyberRegs + S3_CRTC_DATA) = 0x00; /* Get memory size (if not 2MB it is 4MB) */ *(CyberRegs + S3_CRTC_ADR) = S3_LAW_CTL; size = *(CyberRegs + S3_CRTC_DATA); if ((size & 0x03) == 0x02) CyberSize = 0x00200000; /* 2 MB */ else CyberSize = 0x00400000; /* 4 MB */ /* Initialize hardware cursor */ CursorBase = (u_long *)((char *)(CyberMem) + CyberSize - 0x400); for (i=0; i < 8; i++) { *(CursorBase +(i*4)) = 0xffffff00; *(CursorBase+1+(i*4)) = 0xffff0000; *(CursorBase+2+(i*4)) = 0xffff0000; *(CursorBase+3+(i*4)) = 0xffff0000; } for (i=8; i < 64; i++) { *(CursorBase +(i*4)) = 0xffff0000; *(CursorBase+1+(i*4)) = 0xffff0000; *(CursorBase+2+(i*4)) = 0xffff0000; *(CursorBase+3+(i*4)) = 0xffff0000; } Cyber_setcolreg (255, 56, 100, 160, 0); Cyber_setcolreg (254, 0, 0, 0, 0); return 0; } /* * This function should fill in the `fix' structure based on the * values in the `par' structure. */ static int Cyber_encode_fix(struct fb_fix_screeninfo *fix, struct Cyber_fb_par *par) { int i; strcpy(fix->id, Cyber_fb_name); fix->smem_start = (caddr_t)CyberMem; fix->smem_len = CyberSize; fix->mmio_start = (unsigned char *)CyberRegs; fix->mmio_len = 0x10000; fix->type = FB_TYPE_PACKED_PIXELS; fix->type_aux = 0; if (par->bpp == 8) fix->visual = FB_VISUAL_PSEUDOCOLOR; else fix->visual = FB_VISUAL_DIRECTCOLOR; fix->xpanstep = 0; fix->ypanstep = 0; fix->ywrapstep = 0; fix->line_length = 0; for (i = 0; i < arraysize(fix->reserved); i++) fix->reserved[i] = 0; return(0); } /* * Get the video params out of `var'. If a value doesn't fit, round * it up, if it's too big, return -EINVAL. */ static int Cyber_decode_var(struct fb_var_screeninfo *var, struct Cyber_fb_par *par) { #if 1 par->xres = var->xres; par->yres = var->yres; par->bpp = var->bits_per_pixel; #else if (Cyberfb_Cyber8) { par->xres = CYBER8_WIDTH; par->yres = CYBER8_HEIGHT; par->bpp = 8; } else { par->xres = CYBER16_WIDTH; par->yres = CYBER16_HEIGHT; par->bpp = 16; } #endif return(0); } /* * Fill the `var' structure based on the values in `par' and maybe * other values read out of the hardware. */ static int Cyber_encode_var(struct fb_var_screeninfo *var, struct Cyber_fb_par *par) { int i; var->xres = par->xres; var->yres = par->yres; var->xres_virtual = par->xres; var->yres_virtual = par->yres; var->xoffset = 0; var->yoffset = 0; var->bits_per_pixel = par->bpp; var->grayscale = 0; if (par->bpp == 8) { var->red.offset = 0; var->red.length = 8; var->red.msb_right = 0; var->blue = var->green = var->red; } else { var->red.offset = 11; var->red.length = 5; var->red.msb_right = 0; var->green.offset = 5; var->green.length = 6; var->green.msb_right = 0; var->blue.offset = 0; var->blue.length = 5; var->blue.msb_right = 0; } var->transp.offset = 0; var->transp.length = 0; var->transp.msb_right = 0; var->nonstd = 0; var->activate = 0; var->height = -1; var->width = -1; var->accel = FB_ACCEL_CYBERVISION; var->vmode = FB_VMODE_NONINTERLACED; /* Dummy values */ if (par->bpp == 8) var->pixclock = CYBER8_PIXCLOCK; else var->pixclock = CYBER16_PIXCLOCK; var->sync = 0; var->left_margin = 64; var->right_margin = 96; var->upper_margin = 35; var->lower_margin = 12; var->hsync_len = 112; var->vsync_len = 2; for (i = 0; i < arraysize(var->reserved); i++) var->reserved[i] = 0; return(0); } /* * Set a single color register. The values supplied are already * rounded down to the hardware's capabilities (according to the * entries in the var structure). Return != 0 for invalid regno. */ static int Cyber_setcolreg(u_int regno, u_int red, u_int green, u_int blue, u_int transp) { if (regno > 255) return (1); *(CyberRegs + 0x3c8) = (char)regno; Cyber_colour_table [regno][0] = red & 0xff; Cyber_colour_table [regno][1] = green & 0xff; Cyber_colour_table [regno][2] = blue & 0xff; Cyber_colour_table [regno][3] = transp; *(CyberRegs + 0x3c9) = (red & 0xff) >> 2; *(CyberRegs + 0x3c9) = (green & 0xff) >> 2; *(CyberRegs + 0x3c9) = (blue & 0xff) >> 2; return (0); } /* * Read a single color register and split it into * colors/transparent. Return != 0 for invalid regno. */ static int Cyber_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue, u_int *transp) { if (regno >= 256) return (1); *red = Cyber_colour_table [regno][0]; *green = Cyber_colour_table [regno][1]; *blue = Cyber_colour_table [regno][2]; *transp = Cyber_colour_table [regno][3]; return (0); } /* * (Un)Blank the screen */ void Cyber_blank(int blank) { int i; if (blank) for (i = 0; i < 256; i++) { *(CyberRegs + 0x3c8) = i; *(CyberRegs + 0x3c9) = 0; *(CyberRegs + 0x3c9) = 0; *(CyberRegs + 0x3c9) = 0; } else for (i = 0; i < 256; i++) { *(CyberRegs + 0x3c8) = i; *(CyberRegs + 0x3c9) = Cyber_colour_table [i][0] >> 2; *(CyberRegs + 0x3c9) = Cyber_colour_table [i][1] >> 2; *(CyberRegs + 0x3c9) = Cyber_colour_table [i][2] >> 2; } } /************************************************************** * We are waiting for "fifo" FIFO-slots empty */ void Cyber_WaitQueue (u_short fifo) { u_short status; do { status = *((u_short volatile *)(CyberRegs + S3_GP_STAT)); } while (status & fifo); } /************************************************************** * We are waiting for Hardware (Graphics Engine) not busy */ void Cyber_WaitBlit (void) { u_short status; do { status = *((u_short volatile *)(CyberRegs + S3_GP_STAT)); } while (status & S3_HDW_BUSY); } /************************************************************** * BitBLT - Through the Plane */ void Cyber_BitBLT (u_short curx, u_short cury, u_short destx, u_short desty, u_short width, u_short height, u_short mode) { u_short blitcmd = S3_BITBLT; /* Set drawing direction */ /* -Y, X maj, -X (default) */ if (curx > destx) blitcmd |= 0x0020; /* Drawing direction +X */ else { curx += (width - 1); destx += (width - 1); } if (cury > desty) blitcmd |= 0x0080; /* Drawing direction +Y */ else { cury += (height - 1); desty += (height - 1); } Cyber_WaitQueue (0x8000); *((u_short volatile *)(CyberRegs + S3_PIXEL_CNTL)) = 0xa000; *((u_short volatile *)(CyberRegs + S3_FRGD_MIX)) = (0x0060 | mode); *((u_short volatile *)(CyberRegs + S3_CUR_X)) = curx; *((u_short volatile *)(CyberRegs + S3_CUR_Y)) = cury; *((u_short volatile *)(CyberRegs + S3_DESTX_DIASTP)) = destx; *((u_short volatile *)(CyberRegs + S3_DESTY_AXSTP)) = desty; *((u_short volatile *)(CyberRegs + S3_MIN_AXIS_PCNT)) = height - 1; *((u_short volatile *)(CyberRegs + S3_MAJ_AXIS_PCNT)) = width - 1; *((u_short volatile *)(CyberRegs + S3_CMD)) = blitcmd; } /************************************************************** * Rectangle Fill Solid */ void Cyber_RectFill (u_short x, u_short y, u_short width, u_short height, u_short mode, u_short color) { u_short blitcmd = S3_FILLEDRECT; Cyber_WaitQueue (0x8000); *((u_short volatile *)(CyberRegs + S3_PIXEL_CNTL)) = 0xa000; *((u_short volatile *)(CyberRegs + S3_FRGD_MIX)) = (0x0020 | mode); *((u_short volatile *)(CyberRegs + S3_MULT_MISC)) = 0xe000; *((u_short volatile *)(CyberRegs + S3_FRGD_COLOR)) = color; *((u_short volatile *)(CyberRegs + S3_CUR_X)) = x; *((u_short volatile *)(CyberRegs + S3_CUR_Y)) = y; *((u_short volatile *)(CyberRegs + S3_MIN_AXIS_PCNT)) = height - 1; *((u_short volatile *)(CyberRegs + S3_MAJ_AXIS_PCNT)) = width - 1; *((u_short volatile *)(CyberRegs + S3_CMD)) = blitcmd; } /************************************************************** * Move cursor to x, y */ void Cyber_MoveCursor (u_short x, u_short y) { *(CyberRegs + S3_CRTC_ADR) = 0x39; *(CyberRegs + S3_CRTC_DATA) = 0xa0; *(CyberRegs + S3_CRTC_ADR) = S3_HWGC_ORGX_H; *(CyberRegs + S3_CRTC_DATA) = (char)((x & 0x0700) >> 8); *(CyberRegs + S3_CRTC_ADR) = S3_HWGC_ORGX_L; *(CyberRegs + S3_CRTC_DATA) = (char)(x & 0x00ff); *(CyberRegs + S3_CRTC_ADR) = S3_HWGC_ORGY_H; *(CyberRegs + S3_CRTC_DATA) = (char)((y & 0x0700) >> 8); *(CyberRegs + S3_CRTC_ADR) = S3_HWGC_ORGY_L; *(CyberRegs + S3_CRTC_DATA) = (char)(y & 0x00ff); } /* -------------------- Interfaces to hardware functions -------------------- */ static struct fb_hwswitch Cyber_switch = { Cyber_init, Cyber_encode_fix, Cyber_decode_var, Cyber_encode_var, Cyber_getcolreg, Cyber_setcolreg, Cyber_blank }; /* -------------------- Generic routines ------------------------------------ */ /* * Fill the hardware's `par' structure. */ static void Cyber_fb_get_par(struct Cyber_fb_par *par) { if (current_par_valid) *par = current_par; else fbhw->decode_var(&cyber_fb_predefined[Cyberfb_mode], par); } static void Cyber_fb_set_par(struct Cyber_fb_par *par) { current_par = *par; current_par_valid = 1; } static void cyber_set_video(struct fb_var_screeninfo *var) { /* Set clipping rectangle to current screen size */ *((u_short volatile *)(CyberRegs + 0xbee8)) = 0x1000; *((u_short volatile *)(CyberRegs + 0xbee8)) = 0x2000; *((u_short volatile *)(CyberRegs + 0xbee8)) = 0x3000 | (var->yres - 1); *((u_short volatile *)(CyberRegs + 0xbee8)) = 0x4000 | (var->xres - 1); } static int do_fb_set_var(struct fb_var_screeninfo *var, int isactive) { int err, activate; struct Cyber_fb_par par; if ((err = fbhw->decode_var(var, &par))) return(err); activate = var->activate; if ((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW && isactive) Cyber_fb_set_par(&par); fbhw->encode_var(var, &par); var->activate = activate; cyber_set_video(var); return 0; } static void do_install_cmap(int con) { if (con != currcon) return; if (fb_display[con].cmap.len) fb_set_cmap(&fb_display[con].cmap, &fb_display[con].var, 1, fbhw->setcolreg); else fb_set_cmap(fb_default_cmap(fb_display[con].var.bits_per_pixel), &fb_display[con].var, 1, fbhw->setcolreg); } /* * Open/Release the frame buffer device */ static int Cyber_fb_open(int fbidx) { /* * Nothing, only a usage count for the moment */ MOD_INC_USE_COUNT; return(0); } static int Cyber_fb_release(int fbidx) { MOD_DEC_USE_COUNT; return(0); } /* * Get the Fixed Part of the Display */ static int Cyber_fb_get_fix(struct fb_fix_screeninfo *fix, int con) { struct Cyber_fb_par par; int error = 0; if (con == -1) Cyber_fb_get_par(&par); else error = fbhw->decode_var(&fb_display[con].var, &par); return(error ? error : fbhw->encode_fix(fix, &par)); } /* * Get the User Defined Part of the Display */ static int Cyber_fb_get_var(struct fb_var_screeninfo *var, int con) { struct Cyber_fb_par par; int error = 0; if (con == -1) { Cyber_fb_get_par(&par); error = fbhw->encode_var(var, &par); } else *var = fb_display[con].var; return(error); } static void Cyber_fb_set_disp(int con) { struct fb_fix_screeninfo fix; struct display *display; if (con >= 0) display = &fb_display[con]; else display = &disp; /* used during initialization */ Cyber_fb_get_fix(&fix, con); if (con == -1) con = 0; display->screen_base = (u_char *)fix.smem_start; display->visual = fix.visual; display->type = fix.type; display->type_aux = fix.type_aux; display->ypanstep = fix.ypanstep; display->ywrapstep = fix.ywrapstep; display->can_soft_blank = 1; display->inverse = Cyberfb_inverse; } /* * Set the User Defined Part of the Display */ static int Cyber_fb_set_var(struct fb_var_screeninfo *var, int con) { int err, oldxres, oldyres, oldvxres, oldvyres, oldbpp; if ((err = do_fb_set_var(var, con == currcon))) return(err); if ((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW) { oldxres = fb_display[con].var.xres; oldyres = fb_display[con].var.yres; oldvxres = fb_display[con].var.xres_virtual; oldvyres = fb_display[con].var.yres_virtual; oldbpp = fb_display[con].var.bits_per_pixel; fb_display[con].var = *var; if (oldxres != var->xres || oldyres != var->yres || oldvxres != var->xres_virtual || oldvyres != var->yres_virtual || oldbpp != var->bits_per_pixel) { Cyber_fb_set_disp(con); (*fb_info.changevar)(con); fb_alloc_cmap(&fb_display[con].cmap, 0, 0); do_install_cmap(con); } } var->activate = 0; return(0); } /* * Get the Colormap */ static int Cyber_fb_get_cmap(struct fb_cmap *cmap, int kspc, int con) { if (con == currcon) /* current console? */ return(fb_get_cmap(cmap, &fb_display[con].var, kspc, fbhw->getcolreg)); else if (fb_display[con].cmap.len) /* non default colormap? */ fb_copy_cmap(&fb_display[con].cmap, cmap, kspc ? 0 : 2); else fb_copy_cmap(fb_default_cmap(fb_display[con].var.bits_per_pixel), cmap, kspc ? 0 : 2); return(0); } /* * Set the Colormap */ static int Cyber_fb_set_cmap(struct fb_cmap *cmap, int kspc, int con) { int err; if (!fb_display[con].cmap.len) { /* no colormap allocated? */ if ((err = fb_alloc_cmap(&fb_display[con].cmap, 1<setcolreg)); else fb_copy_cmap(cmap, &fb_display[con].cmap, kspc ? 0 : 1); return(0); } /* * Pan or Wrap the Display * * This call looks only at xoffset, yoffset and the FB_VMODE_YWRAP flag */ static int Cyber_fb_pan_display(struct fb_var_screeninfo *var, int con) { return(-EINVAL); } /* * Cybervision Frame Buffer Specific ioctls */ static int Cyber_fb_ioctl(struct inode *inode, struct file *file, u_int cmd, u_long arg, int con) { return(-EINVAL); } static struct fb_ops Cyber_fb_ops = { Cyber_fb_open, Cyber_fb_release, Cyber_fb_get_fix, Cyber_fb_get_var, Cyber_fb_set_var, Cyber_fb_get_cmap, Cyber_fb_set_cmap, Cyber_fb_pan_display, Cyber_fb_ioctl }; __initfunc(void Cyber_video_setup(char *options, int *ints)) { char *this_opt; fb_info.fontname[0] = '\0'; if (!options || !*options) return; for (this_opt = strtok(options, ","); this_opt; this_opt = strtok(NULL, ",")) if (!strcmp(this_opt, "inverse")) { Cyberfb_inverse = 1; fb_invert_cmaps(); } else if (!strncmp(this_opt, "font:", 5)) strcpy(fb_info.fontname, this_opt+5); #if 0 else if (!strcmp (this_opt, "cyber8")) Cyberfb_Cyber8 = 1; else if (!strcmp (this_opt, "cyber16")) Cyberfb_Cyber16 = 1; #endif else Cyberfb_mode = get_video_mode(this_opt); } /* * Initialization */ __initfunc(unsigned long Cyber_fb_init(unsigned long mem_start)) { int err; struct Cyber_fb_par par; unsigned long board_addr; const struct ConfigDev *cd; if (!(CyberKey = zorro_find(ZORRO_PROD_PHASE5_CYBERVISION64, 0, 0))) return mem_start; cd = zorro_get_board (CyberKey); zorro_config_board (CyberKey, 0); board_addr = (unsigned long)cd->cd_BoardAddr; /* This includes the video memory as well as the S3 register set */ CyberMem = kernel_map (board_addr + 0x01400000, 0x01000000, KERNELMAP_NOCACHE_SER, &mem_start); CyberRegs = (char*) (CyberMem + 0x00c00000); fbhw = &Cyber_switch; strcpy(fb_info.modename, Cyber_fb_name); fb_info.changevar = NULL; fb_info.node = -1; fb_info.fbops = &Cyber_fb_ops; fb_info.fbvar_num = NUM_TOTAL_MODES; fb_info.fbvar = cyber_fb_predefined; fb_info.disp = &disp; fb_info.switch_con = &Cyberfb_switch; fb_info.updatevar = &Cyberfb_updatevar; fb_info.blank = &Cyberfb_blank; fb_info.setcmap = &Cyberfb_setcmap; err = register_framebuffer(&fb_info); if (err < 0) return mem_start; fbhw->init(); fbhw->decode_var(&cyber_fb_predefined[Cyberfb_mode], &par); fbhw->encode_var(&cyber_fb_predefined[0], &par); do_fb_set_var(&cyber_fb_predefined[0], 1); Cyber_fb_get_var(&fb_display[0].var, -1); Cyber_fb_set_disp(-1); do_install_cmap(0); printk("%s frame buffer device, using %ldK of video memory\n", fb_info.modename, CyberSize>>10); /* TODO: This driver cannot be unloaded yet */ MOD_INC_USE_COUNT; return mem_start; } static int Cyberfb_switch(int con) { /* Do we have to save the colormap? */ if (fb_display[currcon].cmap.len) fb_get_cmap(&fb_display[currcon].cmap, &fb_display[currcon].var, 1, fbhw->getcolreg); do_fb_set_var(&fb_display[con].var, 1); currcon = con; /* Install new colormap */ do_install_cmap(con); return(0); } /* * Update the `var' structure (called by fbcon.c) * * This call looks only at yoffset and the FB_VMODE_YWRAP flag in `var'. * Since it's called by a kernel driver, no range checking is done. */ static int Cyberfb_updatevar(int con) { return(0); } /* * Blank the display. */ static void Cyberfb_blank(int blank) { fbhw->blank(blank); } /* * Set the colormap */ static int Cyberfb_setcmap(struct fb_cmap *cmap, int con) { return(Cyber_fb_set_cmap(cmap, 1, con)); } /* * Get a Video Mode */ static int get_video_mode(const char *name) { int i; for (i = 1; i < NUM_PREDEF_MODES; i++) if (!strcmp(name, Cyber_fb_modenames[i])) cyber_fb_predefined[0] = cyber_fb_predefined[i]; return(i); return(0); } #ifdef MODULE int init_module(void) { return(Cyber_fb_init(NULL)); } void cleanup_module(void) { /* Not reached because the usecount will never be decremented to zero */ unregister_framebuffer(&fb_info); /* TODO: clean up ... */ } #endif /* MODULE */ /* * Visible symbols for modules */ EXPORT_SYMBOL(Cyber_BitBLT); EXPORT_SYMBOL(Cyber_RectFill); EXPORT_SYMBOL(Cyber_WaitBlit);