git.oblomov.eu Git - linux-2.6/blob - drivers/video/sun3fb.c

   1 /*
   2  *  linux/drivers/video/sun3fb.c -- Frame buffer driver for Sun3
   3  *
   4  * (C) 1998 Thomas Bogendoerfer
   5  *
   6  * This driver is bases on sbusfb.c, which is
   7  *
   8  *      Copyright (C) 1998 Jakub Jelinek
   9  *
  10  *  This driver is partly based on the Open Firmware console driver
  11  *
  12  *      Copyright (C) 1997 Geert Uytterhoeven
  13  *
  14  *  and SPARC console subsystem
  15  *
  16  *      Copyright (C) 1995 Peter Zaitcev (zaitcev@yahoo.com)
  17  *      Copyright (C) 1995-1997 David S. Miller (davem@caip.rutgers.edu)
  18  *      Copyright (C) 1995-1996 Miguel de Icaza (miguel@nuclecu.unam.mx)
  19  *      Copyright (C) 1996 Dave Redman (djhr@tadpole.co.uk)
  20  *      Copyright (C) 1996-1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
  21  *      Copyright (C) 1996 Eddie C. Dost (ecd@skynet.be)
  22  *
  23  *  This file is subject to the terms and conditions of the GNU General Public
  24  *  License. See the file COPYING in the main directory of this archive for
  25  *  more details.
  26  */
  27
  28 #include <linux/module.h>
  29 #include <linux/kernel.h>
  30 #include <linux/errno.h>
  31 #include <linux/string.h>
  32 #include <linux/mm.h>
  33 #include <linux/slab.h>
  34 #include <linux/vmalloc.h>
  35 #include <linux/delay.h>
  36 #include <linux/interrupt.h>
  37 #include <linux/fb.h>
  38 #include <linux/selection.h>
  39 #include <linux/init.h>
  40 #include <linux/console.h>
  41 #include <linux/kd.h>
  42 #include <linux/vt_kern.h>
  43
  44 #include <asm/uaccess.h>
  45 #include <asm/pgtable.h>        /* io_remap_page_range() */
  46
  47 #ifdef CONFIG_SUN3
  48 #include <asm/oplib.h>
  49 #include <asm/machines.h>
  50 #include <asm/idprom.h>
  51
  52 #define CGFOUR_OBMEM_ADDR 0x1f300000
  53 #define BWTWO_OBMEM_ADDR 0x1f000000
  54 #define BWTWO_OBMEM50_ADDR 0x00100000
  55
  56 #endif
  57 #ifdef CONFIG_SUN3X
  58 #include <asm/sun3x.h>
  59 #endif
  60 #include <video/sbusfb.h>
  61
  62 #define DEFAULT_CURSOR_BLINK_RATE       (2*HZ/5)
  63
  64 #define CURSOR_SHAPE                    1
  65 #define CURSOR_BLINK                    2
  66
  67 #define mymemset(x,y) memset(x,0,y)
  68
  69     /*
  70      *  Interface used by the world
  71      */
  72
  73 int sun3fb_init(void);
  74 void sun3fb_setup(char *options);
  75
  76 static char fontname[40] __initdata = { 0 };
  77 static int curblink __initdata = 1;
  78
  79 static int sun3fb_get_fix(struct fb_fix_screeninfo *fix, int con,
  80                         struct fb_info *info);
  81 static int sun3fb_get_var(struct fb_var_screeninfo *var, int con,
  82                         struct fb_info *info);
  83 static int sun3fb_set_var(struct fb_var_screeninfo *var, int con,
  84                         struct fb_info *info);
  85 static int sun3fb_get_cmap(struct fb_cmap *cmap, int kspc, int con,
  86                         struct fb_info *info);
  87 static int sun3fb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
  88                         struct fb_info *info);
  89 static int sun3fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
  90                             u_int transp, struct fb_info *info);
  91 static int sun3fb_blank(int blank, struct fb_info *info);
  92 static void sun3fb_cursor(struct display *p, int mode, int x, int y);
  93 static void sun3fb_clear_margin(struct display *p, int s);
  94
  95     /*
  96      *  Interface to the low level console driver
  97      */
  98
  99 static int sun3fbcon_switch(int con, struct fb_info *info);
 100 static int sun3fbcon_updatevar(int con, struct fb_info *info);
 101
 102     /*
 103      *  Internal routines
 104      */
 105
 106 static int sun3fb_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue,
 107                             u_int *transp, struct fb_info *info);
 108
 109 static struct fb_ops sun3fb_ops = {
 110         .owner =        THIS_MODULE,
 111         .fb_get_fix =   sun3fb_get_fix,
 112         .fb_get_var =   sun3fb_get_var,
 113         .fb_set_var =   sun3fb_set_var,
 114         .fb_get_cmap =  sun3fb_get_cmap,
 115         .fb_set_cmap =  sun3fb_set_cmap,
 116         .fb_setcolreg = sun3fb_setcolreg,
 117         .fb_blank =     sun3fb_blank,
 118 };
 119
 120 static void sun3fb_clear_margin(struct display *p, int s)
 121 {
 122         struct fb_info_sbusfb *fb = sbusfbinfod(p);
 123
 124         return;
 125
 126         if (fb->switch_from_graph)
 127                 (*fb->switch_from_graph)(fb);
 128         if (fb->fill) {
 129                 unsigned short rects [16];
 130
 131                 rects [0] = 0;
 132                 rects [1] = 0;
 133                 rects [2] = fb->var.xres_virtual;
 134                 rects [3] = fb->y_margin;
 135                 rects [4] = 0;
 136                 rects [5] = fb->y_margin;
 137                 rects [6] = fb->x_margin;
 138                 rects [7] = fb->var.yres_virtual;
 139                 rects [8] = fb->var.xres_virtual - fb->x_margin;
 140                 rects [9] = fb->y_margin;
 141                 rects [10] = fb->var.xres_virtual;
 142                 rects [11] = fb->var.yres_virtual;
 143                 rects [12] = fb->x_margin;
 144                 rects [13] = fb->var.yres_virtual - fb->y_margin;
 145                 rects [14] = fb->var.xres_virtual - fb->x_margin;
 146                 rects [15] = fb->var.yres_virtual;
 147                 (*fb->fill)(fb, p, s, 4, rects);
 148         } else {
 149                 unsigned char *fb_base = fb->info.screen_base, *q;
 150                 int skip_bytes = fb->y_margin * fb->var.xres_virtual;
 151                 int scr_size = fb->var.xres_virtual * fb->var.yres_virtual;
 152                 int h, he, incr, size;
 153
 154                 he = fb->var.yres;
 155                 if (fb->var.bits_per_pixel == 1) {
 156                         fb_base -= (skip_bytes + fb->x_margin) / 8;
 157                         skip_bytes /= 8;
 158                         scr_size /= 8;
 159                         mymemset (fb_base, skip_bytes - fb->x_margin / 8);
 160                         mymemset (fb_base + scr_size - skip_bytes + fb->x_margin / 8, skip_bytes - fb->x_margin / 8);
 161                         incr = fb->var.xres_virtual / 8;
 162                         size = fb->x_margin / 8 * 2;
 163                         for (q = fb_base + skip_bytes - fb->x_margin / 8, h = 0;
 164                              h <= he; q += incr, h++)
 165                                 mymemset (q, size);
 166                 } else {
 167                         fb_base -= (skip_bytes + fb->x_margin);
 168                         memset (fb_base, attr_bgcol(p,s), skip_bytes - fb->x_margin);
 169                         memset (fb_base + scr_size - skip_bytes + fb->x_margin, attr_bgcol(p,s), skip_bytes - fb->x_margin);
 170                         incr = fb->var.xres_virtual;
 171                         size = fb->x_margin * 2;
 172                         for (q = fb_base + skip_bytes - fb->x_margin, h = 0;
 173                              h <= he; q += incr, h++)
 174                                 memset (q, attr_bgcol(p,s), size);
 175                 }
 176         }
 177 }
 178
 179 static void sun3fb_disp_setup(struct display *p)
 180 {
 181         struct fb_info_sbusfb *fb = sbusfbinfod(p);
 182
 183         if (fb->setup)
 184                 fb->setup(p);
 185         sun3fb_clear_margin(p, 0);
 186 }
 187
 188     /*
 189      *  Get the Fixed Part of the Display
 190      */
 191
 192 static int sun3fb_get_fix(struct fb_fix_screeninfo *fix, int con,
 193                           struct fb_info *info)
 194 {
 195         struct fb_info_sbusfb *fb = sbusfbinfo(info);
 196
 197         memcpy(fix, &fb->fix, sizeof(struct fb_fix_screeninfo));
 198         return 0;
 199 }
 200
 201     /*
 202      *  Get the User Defined Part of the Display
 203      */
 204
 205 static int sun3fb_get_var(struct fb_var_screeninfo *var, int con,
 206                           struct fb_info *info)
 207 {
 208         struct fb_info_sbusfb *fb = sbusfbinfo(info);
 209
 210         memcpy(var, &fb->var, sizeof(struct fb_var_screeninfo));
 211         return 0;
 212 }
 213
 214     /*
 215      *  Set the User Defined Part of the Display
 216      */
 217
 218 static int sun3fb_set_var(struct fb_var_screeninfo *var, int con,
 219                         struct fb_info *info)
 220 {
 221         struct fb_info_sbusfb *fb = sbusfbinfo(info);
 222
 223         if (var->xres > fb->var.xres || var->yres > fb->var.yres ||
 224             var->xres_virtual > fb->var.xres_virtual ||
 225             var->yres_virtual > fb->var.yres_virtual ||
 226             var->bits_per_pixel != fb->var.bits_per_pixel ||
 227             var->nonstd ||
 228             (var->vmode & FB_VMODE_MASK) != FB_VMODE_NONINTERLACED)
 229                 return -EINVAL;
 230         memcpy(var, &fb->var, sizeof(struct fb_var_screeninfo));
 231         return 0;
 232 }
 233
 234     /*
 235      *  Hardware cursor
 236      */
 237
 238 static unsigned char hw_cursor_cmap[2] = { 0, 0xff };
 239
 240 static void
 241 sun3fb_cursor_timer_handler(unsigned long dev_addr)
 242 {
 243         struct fb_info_sbusfb *fb = (struct fb_info_sbusfb *)dev_addr;
 244
 245         if (!fb->setcursor) return;
 246
 247         if (fb->cursor.mode & CURSOR_BLINK) {
 248                 fb->cursor.enable ^= 1;
 249                 fb->setcursor(fb);
 250         }
 251
 252         fb->cursor.timer.expires = jiffies + fb->cursor.blink_rate;
 253         add_timer(&fb->cursor.timer);
 254 }
 255
 256 static void sun3fb_cursor(struct display *p, int mode, int x, int y)
 257 {
 258         struct fb_info_sbusfb *fb = sbusfbinfod(p);
 259
 260         switch (mode) {
 261         case CM_ERASE:
 262                 fb->cursor.mode &= ~CURSOR_BLINK;
 263                 fb->cursor.enable = 0;
 264                 (*fb->setcursor)(fb);
 265                 break;
 266
 267         case CM_MOVE:
 268         case CM_DRAW:
 269                 if (fb->cursor.mode & CURSOR_SHAPE) {
 270                         fb->cursor.size.fbx = fontwidth(p);
 271                         fb->cursor.size.fby = fontheight(p);
 272                         fb->cursor.chot.fbx = 0;
 273                         fb->cursor.chot.fby = 0;
 274                         fb->cursor.enable = 1;
 275                         memset (fb->cursor.bits, 0, sizeof (fb->cursor.bits));
 276                         fb->cursor.bits[0][fontheight(p) - 2] = (0xffffffff << (32 - fontwidth(p)));
 277                         fb->cursor.bits[1][fontheight(p) - 2] = (0xffffffff << (32 - fontwidth(p)));
 278                         fb->cursor.bits[0][fontheight(p) - 1] = (0xffffffff << (32 - fontwidth(p)));
 279                         fb->cursor.bits[1][fontheight(p) - 1] = (0xffffffff << (32 - fontwidth(p)));
 280                         (*fb->setcursormap) (fb, hw_cursor_cmap, hw_cursor_cmap, hw_cursor_cmap);
 281                         (*fb->setcurshape) (fb);
 282                 }
 283                 fb->cursor.mode = CURSOR_BLINK;
 284                 if (fontwidthlog(p))
 285                         fb->cursor.cpos.fbx = (x << fontwidthlog(p)) + fb->x_margin;
 286                 else
 287                         fb->cursor.cpos.fbx = (x * fontwidth(p)) + fb->x_margin;
 288                 if (fontheightlog(p))
 289                         fb->cursor.cpos.fby = (y << fontheightlog(p)) + fb->y_margin;
 290                 else
 291                         fb->cursor.cpos.fby = (y * fontheight(p)) + fb->y_margin;
 292                 (*fb->setcursor)(fb);
 293                 break;
 294         }
 295 }
 296
 297     /*
 298      *  Get the Colormap
 299      */
 300
 301 static int sun3fb_get_cmap(struct fb_cmap *cmap, int kspc, int con,
 302                          struct fb_info *info)
 303 {
 304         if (con == info->currcon) /* current console? */
 305                 return fb_get_cmap(cmap, kspc, sun3fb_getcolreg, info);
 306         else if (fb_display[con].cmap.len) /* non default colormap? */
 307                 fb_copy_cmap(&fb_display[con].cmap, cmap, kspc ? 0 : 2);
 308         else
 309                 fb_copy_cmap(fb_default_cmap(1<<fb_display[con].var.bits_per_pixel), cmap, kspc ? 0 : 2);
 310         return 0;
 311 }
 312
 313     /*
 314      *  Set the Colormap
 315      */
 316
 317 static int sun3fb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
 318                          struct fb_info *info)
 319 {
 320         int err;
 321
 322         if (!fb_display[con].cmap.len) {        /* no colormap allocated? */
 323                 if ((err = fb_alloc_cmap(&fb_display[con].cmap, 1<<fb_display[con].var.bits_per_pixel, 0)))
 324                         return err;
 325         }
 326         if (con == info->currcon) {                     /* current console? */
 327                 err = fb_set_cmap(cmap, kspc, info);
 328                 if (!err) {
 329                         struct fb_info_sbusfb *fb = sbusfbinfo(info);
 330
 331                         if (fb->loadcmap)
 332                                 (*fb->loadcmap)(fb, &fb_display[con], cmap->start, cmap->len);
 333                 }
 334                 return err;
 335         } else
 336                 fb_copy_cmap(cmap, &fb_display[con].cmap, kspc ? 0 : 1);
 337         return 0;
 338 }
 339
 340     /*
 341      *  Setup: parse used options
 342      */
 343
 344 void __init sun3fb_setup(char *options)
 345 {
 346         char *p;
 347
 348         for (p = options;;) {
 349                 if (!strncmp(p, "font=", 5)) {
 350                         int i;
 351
 352                         for (i = 0; i < sizeof(fontname) - 1; i++)
 353                                 if (p[i+5] == ' ' || !p[i+5])
 354                                         break;
 355                         memcpy(fontname, p+5, i);
 356                         fontname[i] = 0;
 357                 } else if (!strncmp(p, "noblink", 7))
 358                         curblink = 0;
 359                 while (*p && *p != ' ' && *p != ',') p++;
 360                 if (*p != ',') break;
 361                 p++;
 362         }
 363
 364         return;
 365 }
 366
 367 static int sun3fbcon_switch(int con, struct fb_info *info)
 368 {
 369         int x_margin, y_margin;
 370         struct fb_info_sbusfb *fb = sbusfbinfo(info);
 371         int lastconsole;
 372
 373         /* Do we have to save the colormap? */
 374         if (fb_display[info->currcon].cmap.len)
 375                 fb_get_cmap(&fb_display[info->currcon].cmap, 1, sun3fb_getcolreg, info);
 376
 377         if (info->display_fg) {
 378                 lastconsole = info->display_fg->vc_num;
 379                 if (lastconsole != con &&
 380                     (fontwidth(&fb_display[lastconsole]) != fontwidth(&fb_display[con]) ||
 381                      fontheight(&fb_display[lastconsole]) != fontheight(&fb_display[con])))
 382                         fb->cursor.mode |= CURSOR_SHAPE;
 383         }
 384         x_margin = (fb_display[con].var.xres_virtual - fb_display[con].var.xres) / 2;
 385         y_margin = (fb_display[con].var.yres_virtual - fb_display[con].var.yres) / 2;
 386         if (fb->margins)
 387                 fb->margins(fb, &fb_display[con], x_margin, y_margin);
 388         if (fb->graphmode || fb->x_margin != x_margin || fb->y_margin != y_margin) {
 389                 fb->x_margin = x_margin; fb->y_margin = y_margin;
 390                 sun3fb_clear_margin(&fb_display[con], 0);
 391         }
 392         info->currcon = con;
 393         /* Install new colormap */
 394         do_install_cmap(con, info);
 395         return 0;
 396 }
 397
 398     /*
 399      *  Update the `var' structure (called by fbcon.c)
 400      */
 401
 402 static int sun3fbcon_updatevar(int con, struct fb_info *info)
 403 {
 404         /* Nothing */
 405         return 0;
 406 }
 407
 408     /*
 409      *  Blank the display.
 410      */
 411
 412 static int sun3fb_blank(int blank, struct fb_info *info)
 413 {
 414     struct fb_info_sbusfb *fb = sbusfbinfo(info);
 415
 416     if (blank && fb->blank)
 417         return fb->blank(fb);
 418     else if (!blank && fb->unblank)
 419         return fb->unblank(fb);
 420     return 0;
 421 }
 422
 423     /*
 424      *  Read a single color register and split it into
 425      *  colors/transparent. Return != 0 for invalid regno.
 426      */
 427
 428 static int sun3fb_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue,
 429                           u_int *transp, struct fb_info *info)
 430 {
 431         struct fb_info_sbusfb *fb = sbusfbinfo(info);
 432
 433         if (!fb->color_map || regno > 255)
 434                 return 1;
 435         *red = (fb->color_map CM(regno, 0)<<8) | fb->color_map CM(regno, 0);
 436         *green = (fb->color_map CM(regno, 1)<<8) | fb->color_map CM(regno, 1);
 437         *blue = (fb->color_map CM(regno, 2)<<8) | fb->color_map CM(regno, 2);
 438         *transp = 0;
 439         return 0;
 440 }
 441
 442
 443     /*
 444      *  Set a single color register. The values supplied are already
 445      *  rounded down to the hardware's capabilities (according to the
 446      *  entries in the var structure). Return != 0 for invalid regno.
 447      */
 448
 449 static int sun3fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
 450                             u_int transp, struct fb_info *info)
 451 {
 452         struct fb_info_sbusfb *fb = sbusfbinfo(info);
 453
 454         if (!fb->color_map || regno > 255)
 455                 return 1;
 456         red >>= 8;
 457         green >>= 8;
 458         blue >>= 8;
 459         fb->color_map CM(regno, 0) = red;
 460         fb->color_map CM(regno, 1) = green;
 461         fb->color_map CM(regno, 2) = blue;
 462         return 0;
 463 }
 464
 465 static int sun3fb_set_font(struct display *p, int width, int height)
 466 {
 467         int w = p->var.xres_virtual, h = p->var.yres_virtual;
 468         int depth = p->var.bits_per_pixel;
 469         struct fb_info_sbusfb *fb = sbusfbinfod(p);
 470         int x_margin, y_margin;
 471
 472         if (depth > 8) depth = 8;
 473         x_margin = (w % width) / 2;
 474         y_margin = (h % height) / 2;
 475
 476         p->var.xres = w - 2*x_margin;
 477         p->var.yres = h - 2*y_margin;
 478
 479         fb->cursor.mode |= CURSOR_SHAPE;
 480
 481         if (fb->margins)
 482                 fb->margins(fb, p, x_margin, y_margin);
 483         if (fb->x_margin != x_margin || fb->y_margin != y_margin) {
 484                 fb->x_margin = x_margin; fb->y_margin = y_margin;
 485                 sun3fb_clear_margin(p, 0);
 486         }
 487
 488         return 1;
 489 }
 490
 491 void sun3fb_palette(int enter)
 492 {
 493         int i;
 494         struct display *p;
 495
 496         for (i = 0; i < MAX_NR_CONSOLES; i++) {
 497                 p = &fb_display[i];
 498                 if (p->dispsw && p->dispsw->setup == sun3fb_disp_setup &&
 499                     p->fb_info->display_fg &&
 500                     p->fb_info->display_fg->vc_num == i) {
 501                         struct fb_info_sbusfb *fb = sbusfbinfod(p);
 502
 503                         if (fb->restore_palette) {
 504                                 if (enter)
 505                                         fb->restore_palette(fb);
 506                                 else if (vc_cons[i].d->vc_mode != KD_GRAPHICS)
 507                                          vc_cons[i].d->vc_sw->con_set_palette(vc_cons[i].d, color_table);
 508                         }
 509                 }
 510         }
 511 }
 512
 513     /*
 514      *  Initialisation
 515      */
 516 static int __init sun3fb_init_fb(int fbtype, unsigned long addr)
 517 {
 518         static struct sbus_dev sdb;
 519         struct fb_fix_screeninfo *fix;
 520         struct fb_var_screeninfo *var;
 521         struct display *disp;
 522         struct fb_info_sbusfb *fb;
 523         struct fbtype *type;
 524         int linebytes, w, h, depth;
 525         char *p = NULL;
 526
 527         fb = kmalloc(sizeof(struct fb_info_sbusfb), GFP_ATOMIC);
 528         if (!fb)
 529                 return -ENOMEM;
 530
 531         memset(fb, 0, sizeof(struct fb_info_sbusfb));
 532         fix = &fb->fix;
 533         var = &fb->var;
 534         disp = &fb->disp;
 535         type = &fb->type;
 536
 537         sdb.reg_addrs[0].phys_addr = addr;
 538         fb->sbdp = &sdb;
 539
 540         type->fb_type = fbtype;
 541
 542         type->fb_height = h = 900;
 543         type->fb_width  = w = 1152;
 544 sizechange:
 545         type->fb_depth  = depth = (fbtype == FBTYPE_SUN2BW) ? 1 : 8;
 546         linebytes = w * depth / 8;
 547         type->fb_size   = PAGE_ALIGN((linebytes) * h);
 548 /*
 549         fb->x_margin = (w & 7) / 2;
 550         fb->y_margin = (h & 15) / 2;
 551 */
 552         fb->x_margin = fb->y_margin = 0;
 553
 554         var->xres_virtual = w;
 555         var->yres_virtual = h;
 556         var->xres = w - 2*fb->x_margin;
 557         var->yres = h - 2*fb->y_margin;
 558
 559         var->bits_per_pixel = depth;
 560         var->height = var->width = -1;
 561         var->pixclock = 10000;
 562         var->vmode = FB_VMODE_NONINTERLACED;
 563         var->red.length = var->green.length = var->blue.length = 8;
 564
 565         fix->line_length = linebytes;
 566         fix->smem_len = type->fb_size;
 567         fix->type = FB_TYPE_PACKED_PIXELS;
 568         fix->visual = FB_VISUAL_PSEUDOCOLOR;
 569
 570         fb->info.fbops = &sun3fb_ops;
 571         fb->info.disp = disp;
 572         fb->info.currcon = -1;
 573         strcpy(fb->info.fontname, fontname);
 574         fb->info.changevar = NULL;
 575         fb->info.switch_con = &sun3fbcon_switch;
 576         fb->info.updatevar = &sun3fbcon_updatevar;
 577         fb->info.flags = FBINFO_FLAG_DEFAULT;
 578
 579         fb->cursor.hwsize.fbx = 32;
 580         fb->cursor.hwsize.fby = 32;
 581
 582         if (depth > 1 && !fb->color_map) {
 583                 if((fb->color_map = kmalloc(256 * 3, GFP_ATOMIC))==NULL)
 584                         return -ENOMEM;
 585         }
 586
 587         switch(fbtype) {
 588 #ifdef CONFIG_FB_CGSIX
 589         case FBTYPE_SUNFAST_COLOR:
 590                 p = cgsixfb_init(fb); break;
 591 #endif
 592 #ifdef CONFIG_FB_BWTWO
 593         case FBTYPE_SUN2BW:
 594                 p = bwtwofb_init(fb); break;
 595 #endif
 596 #ifdef CONFIG_FB_CGTHREE
 597         case FBTYPE_SUN4COLOR:
 598         case FBTYPE_SUN3COLOR:
 599                 type->fb_size = 0x100000;
 600                 p = cgthreefb_init(fb); break;
 601 #endif
 602         }
 603         fix->smem_start = (unsigned long)fb->info.screen_base;  // FIXME
 604
 605         if (!p) {
 606                 kfree(fb);
 607                 return -ENODEV;
 608         }
 609
 610         if (p == SBUSFBINIT_SIZECHANGE)
 611                 goto sizechange;
 612
 613         disp->dispsw = &fb->dispsw;
 614         if (fb->setcursor) {
 615                 fb->dispsw.cursor = sun3fb_cursor;
 616                 if (curblink) {
 617                         fb->cursor.blink_rate = DEFAULT_CURSOR_BLINK_RATE;
 618                         init_timer(&fb->cursor.timer);
 619                         fb->cursor.timer.expires = jiffies + fb->cursor.blink_rate;
 620                         fb->cursor.timer.data = (unsigned long)fb;
 621                         fb->cursor.timer.function = sun3fb_cursor_timer_handler;
 622                         add_timer(&fb->cursor.timer);
 623                 }
 624         }
 625         fb->cursor.mode = CURSOR_SHAPE;
 626         fb->dispsw.set_font = sun3fb_set_font;
 627         fb->setup = fb->dispsw.setup;
 628         fb->dispsw.setup = sun3fb_disp_setup;
 629         fb->dispsw.clear_margins = NULL;
 630
 631         disp->var = *var;
 632         disp->visual = fix->visual;
 633         disp->type = fix->type;
 634         disp->type_aux = fix->type_aux;
 635         disp->line_length = fix->line_length;
 636
 637         if (fb->blank)
 638                 disp->can_soft_blank = 1;
 639
 640         sun3fb_set_var(var, -1, &fb->info);
 641
 642         if (register_framebuffer(&fb->info) < 0) {
 643                 kfree(fb);
 644                 return -EINVAL;
 645         }
 646         printk("fb%d: %s\n", fb->info.node, p);
 647
 648         return 0;
 649 }
 650
 651
 652 int __init sun3fb_init(void)
 653 {
 654         extern int con_is_present(void);
 655         unsigned long addr;
 656         char p4id;
 657
 658         if (!con_is_present()) return -ENODEV;
 659 #ifdef CONFIG_SUN3
 660         switch(*(romvec->pv_fbtype))
 661         {
 662         case FBTYPE_SUN2BW:
 663                 addr = 0xfe20000;
 664                 return sun3fb_init_fb(FBTYPE_SUN2BW, addr);
 665         case FBTYPE_SUN3COLOR:
 666         case FBTYPE_SUN4COLOR:
 667                 if(idprom->id_machtype != (SM_SUN3|SM_3_60)) {
 668                         printk("sun3fb: cgthree/four only supported on 3/60\n");
 669                         return -ENODEV;
 670                 }
 671
 672                 addr = CGFOUR_OBMEM_ADDR;
 673                 return sun3fb_init_fb(*(romvec->pv_fbtype), addr);
 674         default:
 675                 printk("sun3fb: unsupported framebuffer\n");
 676                 return -ENODEV;
 677         }
 678 #else
 679         addr = SUN3X_VIDEO_BASE;
 680         p4id = *(char *)SUN3X_VIDEO_P4ID;
 681
 682         p4id = (p4id == 0x45) ? p4id : (p4id & 0xf0);
 683         switch (p4id) {
 684                 case 0x00:
 685                         return sun3fb_init_fb(FBTYPE_SUN2BW, addr);
 686 #if 0 /* not yet */
 687                 case 0x40:
 688                         return sun3fb_init_fb(FBTYPE_SUN4COLOR, addr);
 689                         break;
 690                 case 0x45:
 691                         return sun3fb_init_fb(FBTYPE_SUN8COLOR, addr);
 692                         break;
 693 #endif
 694                 case 0x60:
 695                         return sun3fb_init_fb(FBTYPE_SUNFAST_COLOR, addr);
 696         }
 697 #endif
 698
 699         return -ENODEV;
 700 }
 701
 702 MODULE_LICENSE("GPL");