SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/video/macfb.c

   1 /*
   2  * macfb.c: Generic framebuffer for Macs whose colourmaps/modes we
   3  * don't know how to set.
   4  *
   5  * (c) 1999 David Huggins-Daines <dhd@debian.org>
   6  *
   7  * Primarily based on vesafb.c, by Gerd Knorr
   8  * (c) 1998 Gerd Knorr <kraxel@cs.tu-berlin.de>
   9  *
  10  * Also uses information and code from:
  11  *
  12  * The original macfb.c from Linux/mac68k 2.0, by Alan Cox, Juergen
  13  * Mellinger, Mikael Forselius, Michael Schmitz, and others.
  14  *
  15  * valkyriefb.c, by Martin Costabel, Kevin Schoedel, Barry Nathan, Dan
  16  * Jacobowitz, Paul Mackerras, Fabio Riccardi, and Geert Uytterhoeven.
  17  *
  18  * The VideoToolbox "Bugs" web page at
  19  * http://rajsky.psych.nyu.edu/Tips/VideoBugs.html
  20  *
  21  * This code is free software.  You may copy, modify, and distribute
  22  * it subject to the terms and conditions of the GNU General Public
  23  * License, version 2, or any later version, at your convenience.
  24  */
  25
  26 #include <linux/module.h>
  27 #include <linux/kernel.h>
  28 #include <linux/errno.h>
  29 #include <linux/string.h>
  30 #include <linux/mm.h>
  31 #include <linux/delay.h>
  32 #include <linux/nubus.h>
  33 #include <linux/init.h>
  34 #include <linux/fb.h>
  35
  36 #include <asm/setup.h>
  37 #include <asm/bootinfo.h>
  38 #include <asm/macintosh.h>
  39 #include <asm/io.h>
  40
  41 /* Common DAC base address for the LC, RBV, Valkyrie, and IIvx */
  42 #define DAC_BASE 0x50f24000
  43
  44 /* Some addresses for the DAFB */
  45 #define DAFB_BASE 0xf9800200
  46
  47 /* Address for the built-in Civic framebuffer in Quadra AVs */
  48 #define CIVIC_BASE 0x50f30800
  49
  50 /* GSC (Gray Scale Controller) base address */
  51 #define GSC_BASE 0x50F20000
  52
  53 /* CSC (Color Screen Controller) base address */
  54 #define CSC_BASE 0x50F20000
  55
  56 static int (*macfb_setpalette)(unsigned int regno, unsigned int red,
  57                                unsigned int green, unsigned int blue,
  58                                struct fb_info *info);
  59
  60 static struct {
  61         unsigned char addr;
  62         unsigned char lut;
  63 } __iomem *v8_brazil_cmap_regs;
  64
  65 static struct {
  66         unsigned char addr;
  67         char pad1[3]; /* word aligned */
  68         unsigned char lut;
  69         char pad2[3]; /* word aligned */
  70         unsigned char cntl; /* a guess as to purpose */
  71 } __iomem *rbv_cmap_regs;
  72
  73 static struct {
  74         unsigned long reset;
  75         unsigned long pad1[3];
  76         unsigned char pad2[3];
  77         unsigned char lut;
  78 } __iomem *dafb_cmap_regs;
  79
  80 static struct {
  81         unsigned char addr;     /* OFFSET: 0x00 */
  82         unsigned char pad1[15];
  83         unsigned char lut;      /* OFFSET: 0x10 */
  84         unsigned char pad2[15];
  85         unsigned char status;   /* OFFSET: 0x20 */
  86         unsigned char pad3[7];
  87         unsigned long vbl_addr; /* OFFSET: 0x28 */
  88         unsigned int  status2;  /* OFFSET: 0x2C */
  89 } __iomem *civic_cmap_regs;
  90
  91 static struct {
  92         char pad1[0x40];
  93         unsigned char clut_waddr;       /* 0x40 */
  94         char pad2;
  95         unsigned char clut_data;        /* 0x42 */
  96         char pad3[0x3];
  97         unsigned char clut_raddr;       /* 0x46 */
  98 } __iomem *csc_cmap_regs;
  99
 100 /* The registers in these structs are in NuBus slot space */
 101 struct mdc_cmap_regs {
 102         char pad1[0x200200];
 103         unsigned char addr;
 104         char pad2[6];
 105         unsigned char lut;
 106 };
 107
 108 struct toby_cmap_regs {
 109         char pad1[0x90018];
 110         unsigned char lut; /* TFBClutWDataReg, offset 0x90018 */
 111         char pad2[3];
 112         unsigned char addr; /* TFBClutAddrReg, offset 0x9001C */
 113 };
 114
 115 struct jet_cmap_regs {
 116         char pad1[0xe0e000];
 117         unsigned char addr;
 118         unsigned char lut;
 119 };
 120
 121 #define PIXEL_TO_MM(a)  (((a)*10)/28)   /* width in mm at 72 dpi */
 122
 123 static int  video_slot = 0;
 124
 125 static struct fb_var_screeninfo macfb_defined = {
 126         .bits_per_pixel = 8,
 127         .activate       = FB_ACTIVATE_NOW,
 128         .width          = -1,
 129         .height         = -1,
 130         .right_margin   = 32,
 131         .upper_margin   = 16,
 132         .lower_margin   = 4,
 133         .vsync_len      = 4,
 134         .vmode          = FB_VMODE_NONINTERLACED,
 135 };
 136
 137 static struct fb_fix_screeninfo macfb_fix = {
 138         .type   = FB_TYPE_PACKED_PIXELS,
 139         .accel  = FB_ACCEL_NONE,
 140 };
 141
 142 static struct fb_info fb_info;
 143 static u32 pseudo_palette[16];
 144 static int inverse;
 145 static int vidtest;
 146
 147 /*
 148  * Unlike the Valkyrie, the DAFB cannot set individual colormap
 149  * registers.  Therefore, we do what the MacOS driver does (no
 150  * kidding!) and simply set them one by one until we hit the one we
 151  * want.
 152  */
 153 static int dafb_setpalette(unsigned int regno, unsigned int red,
 154                            unsigned int green, unsigned int blue,
 155                            struct fb_info *info)
 156 {
 157         static int lastreg = -1;
 158         unsigned long flags;
 159
 160         red >>= 8;
 161         green >>= 8;
 162         blue >>= 8;
 163
 164         local_irq_save(flags);
 165
 166         /*
 167          * fbdev will set an entire colourmap, but X won't.  Hopefully
 168          * this should accommodate both of them
 169          */
 170         if (regno != lastreg + 1) {
 171                 int i;
 172
 173                 /* Stab in the dark trying to reset the CLUT pointer */
 174                 nubus_writel(0, &dafb_cmap_regs->reset);
 175                 nop();
 176
 177                 /* Loop until we get to the register we want */
 178                 for (i = 0; i < regno; i++) {
 179                         nubus_writeb(info->cmap.red[i] >> 8,
 180                                      &dafb_cmap_regs->lut);
 181                         nop();
 182                         nubus_writeb(info->cmap.green[i] >> 8,
 183                                      &dafb_cmap_regs->lut);
 184                         nop();
 185                         nubus_writeb(info->cmap.blue[i] >> 8,
 186                                      &dafb_cmap_regs->lut);
 187                         nop();
 188                 }
 189         }
 190
 191         nubus_writeb(red, &dafb_cmap_regs->lut);
 192         nop();
 193         nubus_writeb(green, &dafb_cmap_regs->lut);
 194         nop();
 195         nubus_writeb(blue, &dafb_cmap_regs->lut);
 196
 197         local_irq_restore(flags);
 198         lastreg = regno;
 199         return 0;
 200 }
 201
 202 /* V8 and Brazil seem to use the same DAC.  Sonora does as well. */
 203 static int v8_brazil_setpalette(unsigned int regno, unsigned int red,
 204                                 unsigned int green, unsigned int blue,
 205                                 struct fb_info *info)
 206 {
 207         unsigned int bpp = info->var.bits_per_pixel;
 208         unsigned char _red  =red>>8;
 209         unsigned char _green=green>>8;
 210         unsigned char _blue =blue>>8;
 211         unsigned char _regno;
 212         unsigned long flags;
 213
 214         if (bpp > 8)
 215                 return 1; /* failsafe */
 216
 217         local_irq_save(flags);
 218
 219         /* On these chips, the CLUT register numbers are spread out
 220          * across the register space.  Thus:
 221          * In 8bpp, all regnos are valid.
 222          * In 4bpp, the regnos are 0x0f, 0x1f, 0x2f, etc, etc
 223          * In 2bpp, the regnos are 0x3f, 0x7f, 0xbf, 0xff
 224          */
 225         _regno = (regno << (8 - bpp)) | (0xFF >> bpp);
 226         nubus_writeb(_regno, &v8_brazil_cmap_regs->addr);
 227         nop();
 228
 229         /* send one color channel at a time */
 230         nubus_writeb(_red, &v8_brazil_cmap_regs->lut);
 231         nop();
 232         nubus_writeb(_green, &v8_brazil_cmap_regs->lut);
 233         nop();
 234         nubus_writeb(_blue, &v8_brazil_cmap_regs->lut);
 235
 236         local_irq_restore(flags);
 237         return 0;
 238 }
 239
 240 /* RAM-Based Video */
 241 static int rbv_setpalette(unsigned int regno, unsigned int red,
 242                           unsigned int green, unsigned int blue,
 243                           struct fb_info *info)
 244 {
 245         /* use MSBs */
 246         unsigned char _red  =red>>8;
 247         unsigned char _green=green>>8;
 248         unsigned char _blue =blue>>8;
 249         unsigned char _regno;
 250         unsigned long flags;
 251
 252         if (info->var.bits_per_pixel > 8)
 253                 return 1; /* failsafe */
 254
 255         local_irq_save(flags);
 256
 257         /* From the VideoToolbox driver.  Seems to be saying that
 258          * regno #254 and #255 are the important ones for 1-bit color,
 259          * regno #252-255 are the important ones for 2-bit color, etc.
 260          */
 261         _regno = regno + (256-(1 << info->var.bits_per_pixel));
 262
 263         /* reset clut? (VideoToolbox sez "not necessary") */
 264         nubus_writeb(0xFF, &rbv_cmap_regs->cntl);
 265         nop();
 266
 267         /* tell clut which address to use. */
 268         nubus_writeb(_regno, &rbv_cmap_regs->addr);
 269         nop();
 270
 271         /* send one color channel at a time. */
 272         nubus_writeb(_red, &rbv_cmap_regs->lut);
 273         nop();
 274         nubus_writeb(_green, &rbv_cmap_regs->lut);
 275         nop();
 276         nubus_writeb(_blue, &rbv_cmap_regs->lut);
 277
 278         local_irq_restore(flags);
 279         return 0;
 280 }
 281
 282 /* Macintosh Display Card (8*24) */
 283 static int mdc_setpalette(unsigned int regno, unsigned int red,
 284                           unsigned int green, unsigned int blue,
 285                           struct fb_info *info)
 286 {
 287         volatile struct mdc_cmap_regs *cmap_regs =
 288                 nubus_slot_addr(video_slot);
 289         /* use MSBs */
 290         unsigned char _red  =red>>8;
 291         unsigned char _green=green>>8;
 292         unsigned char _blue =blue>>8;
 293         unsigned char _regno=regno;
 294         unsigned long flags;
 295
 296         local_irq_save(flags);
 297
 298         /* the nop's are there to order writes. */
 299         nubus_writeb(_regno, &cmap_regs->addr);
 300         nop();
 301         nubus_writeb(_red, &cmap_regs->lut);
 302         nop();
 303         nubus_writeb(_green, &cmap_regs->lut);
 304         nop();
 305         nubus_writeb(_blue, &cmap_regs->lut);
 306
 307         local_irq_restore(flags);
 308         return 0;
 309 }
 310
 311 /* Toby frame buffer */
 312 static int toby_setpalette(unsigned int regno, unsigned int red,
 313                            unsigned int green, unsigned int blue,
 314                            struct fb_info *info)
 315 {
 316         volatile struct toby_cmap_regs *cmap_regs =
 317                 nubus_slot_addr(video_slot);
 318         unsigned int bpp = info->var.bits_per_pixel;
 319         /* use MSBs */
 320         unsigned char _red  =~(red>>8);
 321         unsigned char _green=~(green>>8);
 322         unsigned char _blue =~(blue>>8);
 323         unsigned char _regno = (regno << (8 - bpp)) | (0xFF >> bpp);
 324         unsigned long flags;
 325
 326         local_irq_save(flags);
 327
 328         nubus_writeb(_regno, &cmap_regs->addr);
 329         nop();
 330         nubus_writeb(_red, &cmap_regs->lut);
 331         nop();
 332         nubus_writeb(_green, &cmap_regs->lut);
 333         nop();
 334         nubus_writeb(_blue, &cmap_regs->lut);
 335
 336         local_irq_restore(flags);
 337         return 0;
 338 }
 339
 340 /* Jet frame buffer */
 341 static int jet_setpalette(unsigned int regno, unsigned int red,
 342                           unsigned int green, unsigned int blue,
 343                           struct fb_info *info)
 344 {
 345         volatile struct jet_cmap_regs *cmap_regs =
 346                 nubus_slot_addr(video_slot);
 347         /* use MSBs */
 348         unsigned char _red   = (red>>8);
 349         unsigned char _green = (green>>8);
 350         unsigned char _blue  = (blue>>8);
 351         unsigned long flags;
 352
 353         local_irq_save(flags);
 354
 355         nubus_writeb(regno, &cmap_regs->addr);
 356         nop();
 357         nubus_writeb(_red, &cmap_regs->lut);
 358         nop();
 359         nubus_writeb(_green, &cmap_regs->lut);
 360         nop();
 361         nubus_writeb(_blue, &cmap_regs->lut);
 362
 363         local_irq_restore(flags);
 364         return 0;
 365 }
 366
 367 /*
 368  * Civic framebuffer -- Quadra AV built-in video.  A chip
 369  * called Sebastian holds the actual color palettes, and
 370  * apparently, there are two different banks of 512K RAM
 371  * which can act as separate framebuffers for doing video
 372  * input and viewing the screen at the same time!  The 840AV
 373  * Can add another 1MB RAM to give the two framebuffers
 374  * 1MB RAM apiece.
 375  */
 376 static int civic_setpalette(unsigned int regno, unsigned int red,
 377                             unsigned int green, unsigned int blue,
 378                             struct fb_info *info)
 379 {
 380         unsigned long flags;
 381         int clut_status;
 382
 383         if (info->var.bits_per_pixel > 8)
 384                 return 1; /* failsafe */
 385
 386         red   >>= 8;
 387         green >>= 8;
 388         blue  >>= 8;
 389
 390         local_irq_save(flags);
 391
 392         /* Set the register address */
 393         nubus_writeb(regno, &civic_cmap_regs->addr);
 394         nop();
 395
 396         /*
 397          * Grab a status word and do some checking;
 398          * Then finally write the clut!
 399          */
 400         clut_status =  nubus_readb(&civic_cmap_regs->status2);
 401
 402         if ((clut_status & 0x0008) == 0)
 403         {
 404 #if 0
 405                 if ((clut_status & 0x000D) != 0)
 406                 {
 407                         nubus_writeb(0x00, &civic_cmap_regs->lut);
 408                         nop();
 409                         nubus_writeb(0x00, &civic_cmap_regs->lut);
 410                         nop();
 411                 }
 412 #endif
 413
 414                 nubus_writeb(red, &civic_cmap_regs->lut);
 415                 nop();
 416                 nubus_writeb(green, &civic_cmap_regs->lut);
 417                 nop();
 418                 nubus_writeb(blue, &civic_cmap_regs->lut);
 419                 nop();
 420                 nubus_writeb(0x00, &civic_cmap_regs->lut);
 421         }
 422         else
 423         {
 424                 unsigned char junk;
 425
 426                 junk = nubus_readb(&civic_cmap_regs->lut);
 427                 nop();
 428                 junk = nubus_readb(&civic_cmap_regs->lut);
 429                 nop();
 430                 junk = nubus_readb(&civic_cmap_regs->lut);
 431                 nop();
 432                 junk = nubus_readb(&civic_cmap_regs->lut);
 433                 nop();
 434
 435                 if ((clut_status & 0x000D) != 0)
 436                 {
 437                         nubus_writeb(0x00, &civic_cmap_regs->lut);
 438                         nop();
 439                         nubus_writeb(0x00, &civic_cmap_regs->lut);
 440                         nop();
 441                 }
 442
 443                 nubus_writeb(red, &civic_cmap_regs->lut);
 444                 nop();
 445                 nubus_writeb(green, &civic_cmap_regs->lut);
 446                 nop();
 447                 nubus_writeb(blue, &civic_cmap_regs->lut);
 448                 nop();
 449                 nubus_writeb(junk, &civic_cmap_regs->lut);
 450         }
 451
 452         local_irq_restore(flags);
 453         return 0;
 454 }
 455
 456 /*
 457  * The CSC is the framebuffer on the PowerBook 190 series
 458  * (and the 5300 too, but that's a PowerMac). This function
 459  * brought to you in part by the ECSC driver for MkLinux.
 460  */
 461 static int csc_setpalette(unsigned int regno, unsigned int red,
 462                           unsigned int green, unsigned int blue,
 463                           struct fb_info *info)
 464 {
 465         mdelay(1);
 466         nubus_writeb(regno, &csc_cmap_regs->clut_waddr);
 467         nubus_writeb(red,   &csc_cmap_regs->clut_data);
 468         nubus_writeb(green, &csc_cmap_regs->clut_data);
 469         nubus_writeb(blue,  &csc_cmap_regs->clut_data);
 470         return 0;
 471 }
 472
 473 static int macfb_setcolreg(unsigned regno, unsigned red, unsigned green,
 474                            unsigned blue, unsigned transp,
 475                            struct fb_info *fb_info)
 476 {
 477         /*
 478          * Set a single color register. The values supplied are
 479          * already rounded down to the hardware's capabilities
 480          * (according to the entries in the `var' structure).
 481          * Return non-zero for invalid regno.
 482          */
 483
 484         if (regno >= fb_info->cmap.len)
 485                 return 1;
 486
 487         if (fb_info->var.bits_per_pixel <= 8) {
 488                 switch (fb_info->var.bits_per_pixel) {
 489                 case 1:
 490                         /* We shouldn't get here */
 491                         break;
 492                 case 2:
 493                 case 4:
 494                 case 8:
 495                         if (macfb_setpalette)
 496                                 macfb_setpalette(regno, red, green, blue,
 497                                                  fb_info);
 498                         else
 499                                 return 1;
 500                         break;
 501                 }
 502         } else if (regno < 16) {
 503                 switch (fb_info->var.bits_per_pixel) {
 504                 case 16:
 505                         if (fb_info->var.red.offset == 10) {
 506                                 /* 1:5:5:5 */
 507                                 ((u32*) (fb_info->pseudo_palette))[regno] =
 508                                         ((red   & 0xf800) >>  1) |
 509                                         ((green & 0xf800) >>  6) |
 510                                         ((blue  & 0xf800) >> 11) |
 511                                         ((transp != 0) << 15);
 512                         } else {
 513                                 /* 0:5:6:5 */
 514                                 ((u32*) (fb_info->pseudo_palette))[regno] =
 515                                         ((red   & 0xf800) >>  0) |
 516                                         ((green & 0xfc00) >>  5) |
 517                                         ((blue  & 0xf800) >> 11);
 518                         }
 519                         break;
 520                 /*
 521                  * 24-bit colour almost doesn't exist on 68k Macs --
 522                  * http://support.apple.com/kb/TA28634 (Old Article: 10992)
 523                  */
 524                 case 24:
 525                 case 32:
 526                         red   >>= 8;
 527                         green >>= 8;
 528                         blue  >>= 8;
 529                         ((u32 *)(fb_info->pseudo_palette))[regno] =
 530                                 (red   << fb_info->var.red.offset) |
 531                                 (green << fb_info->var.green.offset) |
 532                                 (blue  << fb_info->var.blue.offset);
 533                         break;
 534                 }
 535         }
 536
 537         return 0;
 538 }
 539
 540 static struct fb_ops macfb_ops = {
 541         .owner          = THIS_MODULE,
 542         .fb_setcolreg   = macfb_setcolreg,
 543         .fb_fillrect    = cfb_fillrect,
 544         .fb_copyarea    = cfb_copyarea,
 545         .fb_imageblit   = cfb_imageblit,
 546 };
 547
 548 static void __init macfb_setup(char *options)
 549 {
 550         char *this_opt;
 551
 552         if (!options || !*options)
 553                 return;
 554
 555         while ((this_opt = strsep(&options, ",")) != NULL) {
 556                 if (!*this_opt)
 557                         continue;
 558
 559                 if (!strcmp(this_opt, "inverse"))
 560                         inverse = 1;
 561                 else
 562                         if (!strcmp(this_opt, "vidtest"))
 563                                 vidtest = 1; /* enable experimental CLUT code */
 564         }
 565 }
 566
 567 static void __init iounmap_macfb(void)
 568 {
 569         if (dafb_cmap_regs)
 570                 iounmap(dafb_cmap_regs);
 571         if (v8_brazil_cmap_regs)
 572                 iounmap(v8_brazil_cmap_regs);
 573         if (rbv_cmap_regs)
 574                 iounmap(rbv_cmap_regs);
 575         if (civic_cmap_regs)
 576                 iounmap(civic_cmap_regs);
 577         if (csc_cmap_regs)
 578                 iounmap(csc_cmap_regs);
 579 }
 580
 581 static int __init macfb_init(void)
 582 {
 583         int video_cmap_len, video_is_nubus = 0;
 584         struct nubus_dev* ndev = NULL;
 585         char *option = NULL;
 586         int err;
 587
 588         if (fb_get_options("macfb", &option))
 589                 return -ENODEV;
 590         macfb_setup(option);
 591
 592         if (!MACH_IS_MAC)
 593                 return -ENODEV;
 594
 595         if (mac_bi_data.id == MAC_MODEL_Q630 ||
 596             mac_bi_data.id == MAC_MODEL_P588)
 597                 return -ENODEV; /* See valkyriefb.c */
 598
 599         macfb_defined.xres = mac_bi_data.dimensions & 0xFFFF;
 600         macfb_defined.yres = mac_bi_data.dimensions >> 16;
 601         macfb_defined.bits_per_pixel = mac_bi_data.videodepth;
 602
 603         macfb_fix.line_length = mac_bi_data.videorow;
 604         macfb_fix.smem_len    = macfb_fix.line_length * macfb_defined.yres;
 605         /* Note: physical address (since 2.1.127) */
 606         macfb_fix.smem_start  = mac_bi_data.videoaddr;
 607
 608         /*
 609          * This is actually redundant with the initial mappings.
 610          * However, there are some non-obvious aspects to the way
 611          * those mappings are set up, so this is in fact the safest
 612          * way to ensure that this driver will work on every possible Mac
 613          */
 614         fb_info.screen_base = ioremap(mac_bi_data.videoaddr, macfb_fix.smem_len);
 615
 616         printk("macfb: framebuffer at 0x%08lx, mapped to 0x%p, size %dk\n",
 617                macfb_fix.smem_start, fb_info.screen_base,
 618                macfb_fix.smem_len / 1024);
 619         printk("macfb: mode is %dx%dx%d, linelength=%d\n",
 620                macfb_defined.xres, macfb_defined.yres,
 621                macfb_defined.bits_per_pixel, macfb_fix.line_length);
 622
 623         /*
 624          * Fill in the available video resolution
 625          */
 626         macfb_defined.xres_virtual = macfb_defined.xres;
 627         macfb_defined.yres_virtual = macfb_defined.yres;
 628         macfb_defined.height       = PIXEL_TO_MM(macfb_defined.yres);
 629         macfb_defined.width        = PIXEL_TO_MM(macfb_defined.xres);
 630
 631         printk("macfb: scrolling: redraw\n");
 632
 633         /* some dummy values for timing to make fbset happy */
 634         macfb_defined.pixclock     = 10000000 / macfb_defined.xres *
 635                                      1000 / macfb_defined.yres;
 636         macfb_defined.left_margin  = (macfb_defined.xres / 8) & 0xf8;
 637         macfb_defined.hsync_len    = (macfb_defined.xres / 8) & 0xf8;
 638
 639         switch (macfb_defined.bits_per_pixel) {
 640         case 1:
 641                 /*
 642                  * XXX: I think this will catch any program that tries
 643                  * to do FBIO_PUTCMAP when the visual is monochrome.
 644                  */
 645                 macfb_defined.red.length = macfb_defined.bits_per_pixel;
 646                 macfb_defined.green.length = macfb_defined.bits_per_pixel;
 647                 macfb_defined.blue.length = macfb_defined.bits_per_pixel;
 648                 video_cmap_len = 0;
 649                 macfb_fix.visual = FB_VISUAL_MONO01;
 650                 break;
 651         case 2:
 652         case 4:
 653         case 8:
 654                 macfb_defined.red.length = macfb_defined.bits_per_pixel;
 655                 macfb_defined.green.length = macfb_defined.bits_per_pixel;
 656                 macfb_defined.blue.length = macfb_defined.bits_per_pixel;
 657                 video_cmap_len = 1 << macfb_defined.bits_per_pixel;
 658                 macfb_fix.visual = FB_VISUAL_PSEUDOCOLOR;
 659                 break;
 660         case 16:
 661                 macfb_defined.transp.offset = 15;
 662                 macfb_defined.transp.length = 1;
 663                 macfb_defined.red.offset = 10;
 664                 macfb_defined.red.length = 5;
 665                 macfb_defined.green.offset = 5;
 666                 macfb_defined.green.length = 5;
 667                 macfb_defined.blue.offset = 0;
 668                 macfb_defined.blue.length = 5;
 669                 printk("macfb: directcolor: "
 670                        "size=1:5:5:5, shift=15:10:5:0\n");
 671                 video_cmap_len = 16;
 672                 /*
 673                  * Should actually be FB_VISUAL_DIRECTCOLOR, but this
 674                  * works too
 675                  */
 676                 macfb_fix.visual = FB_VISUAL_TRUECOLOR;
 677                 break;
 678         case 24:
 679         case 32:
 680                 macfb_defined.red.offset = 16;
 681                 macfb_defined.red.length = 8;
 682                 macfb_defined.green.offset = 8;
 683                 macfb_defined.green.length = 8;
 684                 macfb_defined.blue.offset = 0;
 685                 macfb_defined.blue.length = 8;
 686                 printk("macfb: truecolor: "
 687                        "size=0:8:8:8, shift=0:16:8:0\n");
 688                 video_cmap_len = 16;
 689                 macfb_fix.visual = FB_VISUAL_TRUECOLOR;
 690         default:
 691                 video_cmap_len = 0;
 692                 macfb_fix.visual = FB_VISUAL_MONO01;
 693                 printk("macfb: unknown or unsupported bit depth: %d\n",
 694                        macfb_defined.bits_per_pixel);
 695                 break;
 696         }
 697
 698         /*
 699          * We take a wild guess that if the video physical address is
 700          * in nubus slot space, that the nubus card is driving video.
 701          * Penguin really ought to tell us whether we are using internal
 702          * video or not.
 703          * Hopefully we only find one of them.  Otherwise our NuBus
 704          * code is really broken :-)
 705          */
 706
 707         while ((ndev = nubus_find_type(NUBUS_CAT_DISPLAY, NUBUS_TYPE_VIDEO, ndev))
 708                 != NULL)
 709         {
 710                 if (!(mac_bi_data.videoaddr >= ndev->board->slot_addr
 711                       && (mac_bi_data.videoaddr <
 712                           (unsigned long)nubus_slot_addr(ndev->board->slot+1))))
 713                         continue;
 714                 video_is_nubus = 1;
 715                 /* We should probably just use the slot address... */
 716                 video_slot = ndev->board->slot;
 717
 718                 switch(ndev->dr_hw) {
 719                 case NUBUS_DRHW_APPLE_MDC:
 720                         strcpy(macfb_fix.id, "Mac Disp. Card");
 721                         macfb_setpalette = mdc_setpalette;
 722                         macfb_defined.activate = FB_ACTIVATE_NOW;
 723                         break;
 724                 case NUBUS_DRHW_APPLE_TFB:
 725                         strcpy(macfb_fix.id, "Toby");
 726                         macfb_setpalette = toby_setpalette;
 727                         macfb_defined.activate = FB_ACTIVATE_NOW;
 728                         break;
 729                 case NUBUS_DRHW_APPLE_JET:
 730                         strcpy(macfb_fix.id, "Jet");
 731                         macfb_setpalette = jet_setpalette;
 732                         macfb_defined.activate = FB_ACTIVATE_NOW;
 733                         break;
 734                 default:
 735                         strcpy(macfb_fix.id, "Generic NuBus");
 736                         break;
 737                 }
 738         }
 739
 740         /* If it's not a NuBus card, it must be internal video */
 741         if (!video_is_nubus)
 742                 switch (mac_bi_data.id) {
 743                 /*
 744                  * DAFB Quadras
 745                  * Note: these first four have the v7 DAFB, which is
 746                  * known to be rather unlike the ones used in the
 747                  * other models
 748                  */
 749                 case MAC_MODEL_P475:
 750                 case MAC_MODEL_P475F:
 751                 case MAC_MODEL_P575:
 752                 case MAC_MODEL_Q605:
 753
 754                 case MAC_MODEL_Q800:
 755                 case MAC_MODEL_Q650:
 756                 case MAC_MODEL_Q610:
 757                 case MAC_MODEL_C650:
 758                 case MAC_MODEL_C610:
 759                 case MAC_MODEL_Q700:
 760                 case MAC_MODEL_Q900:
 761                 case MAC_MODEL_Q950:
 762                         strcpy(macfb_fix.id, "DAFB");
 763                         macfb_setpalette = dafb_setpalette;
 764                         macfb_defined.activate = FB_ACTIVATE_NOW;
 765                         dafb_cmap_regs = ioremap(DAFB_BASE, 0x1000);
 766                         break;
 767
 768                 /*
 769                  * LC II uses the V8 framebuffer
 770                  */
 771                 case MAC_MODEL_LCII:
 772                         strcpy(macfb_fix.id, "V8");
 773                         macfb_setpalette = v8_brazil_setpalette;
 774                         macfb_defined.activate = FB_ACTIVATE_NOW;
 775                         v8_brazil_cmap_regs = ioremap(DAC_BASE, 0x1000);
 776                         break;
 777
 778                 /*
 779                  * IIvi, IIvx use the "Brazil" framebuffer (which is
 780                  * very much like the V8, it seems, and probably uses
 781                  * the same DAC)
 782                  */
 783                 case MAC_MODEL_IIVI:
 784                 case MAC_MODEL_IIVX:
 785                 case MAC_MODEL_P600:
 786                         strcpy(macfb_fix.id, "Brazil");
 787                         macfb_setpalette = v8_brazil_setpalette;
 788                         macfb_defined.activate = FB_ACTIVATE_NOW;
 789                         v8_brazil_cmap_regs = ioremap(DAC_BASE, 0x1000);
 790                         break;
 791
 792                 /*
 793                  * LC III (and friends) use the Sonora framebuffer
 794                  * Incidentally this is also used in the non-AV models
 795                  * of the x100 PowerMacs
 796                  * These do in fact seem to use the same DAC interface
 797                  * as the LC II.
 798                  */
 799                 case MAC_MODEL_LCIII:
 800                 case MAC_MODEL_P520:
 801                 case MAC_MODEL_P550:
 802                 case MAC_MODEL_P460:
 803                         macfb_setpalette = v8_brazil_setpalette;
 804                         macfb_defined.activate = FB_ACTIVATE_NOW;
 805                         strcpy(macfb_fix.id, "Sonora");
 806                         v8_brazil_cmap_regs = ioremap(DAC_BASE, 0x1000);
 807                         break;
 808
 809                 /*
 810                  * IIci and IIsi use the infamous RBV chip
 811                  * (the IIsi is just a rebadged and crippled
 812                  * IIci in a different case, BTW)
 813                  */
 814                 case MAC_MODEL_IICI:
 815                 case MAC_MODEL_IISI:
 816                         macfb_setpalette = rbv_setpalette;
 817                         macfb_defined.activate = FB_ACTIVATE_NOW;
 818                         strcpy(macfb_fix.id, "RBV");
 819                         rbv_cmap_regs = ioremap(DAC_BASE, 0x1000);
 820                         break;
 821
 822                 /*
 823                  * AVs use the Civic framebuffer
 824                  */
 825                 case MAC_MODEL_Q840:
 826                 case MAC_MODEL_C660:
 827                         macfb_setpalette = civic_setpalette;
 828                         macfb_defined.activate = FB_ACTIVATE_NOW;
 829                         strcpy(macfb_fix.id, "Civic");
 830                         civic_cmap_regs = ioremap(CIVIC_BASE, 0x1000);
 831                         break;
 832
 833
 834                 /*
 835                  * Assorted weirdos
 836                  * We think this may be like the LC II
 837                  */
 838                 case MAC_MODEL_LC:
 839                         if (vidtest) {
 840                                 macfb_setpalette = v8_brazil_setpalette;
 841                                 macfb_defined.activate = FB_ACTIVATE_NOW;
 842                                 v8_brazil_cmap_regs =
 843                                         ioremap(DAC_BASE, 0x1000);
 844                         }
 845                         strcpy(macfb_fix.id, "LC");
 846                         break;
 847
 848                 /*
 849                  * We think this may be like the LC II
 850                  */
 851                 case MAC_MODEL_CCL:
 852                         if (vidtest) {
 853                                 macfb_setpalette = v8_brazil_setpalette;
 854                                 macfb_defined.activate = FB_ACTIVATE_NOW;
 855                                 v8_brazil_cmap_regs =
 856                                         ioremap(DAC_BASE, 0x1000);
 857                         }
 858                         strcpy(macfb_fix.id, "Color Classic");
 859                         break;
 860
 861                 /*
 862                  * And we *do* mean "weirdos"
 863                  */
 864                 case MAC_MODEL_TV:
 865                         strcpy(macfb_fix.id, "Mac TV");
 866                         break;
 867
 868                 /*
 869                  * These don't have colour, so no need to worry
 870                  */
 871                 case MAC_MODEL_SE30:
 872                 case MAC_MODEL_CLII:
 873                         strcpy(macfb_fix.id, "Monochrome");
 874                         break;
 875
 876                 /*
 877                  * Powerbooks are particularly difficult.  Many of
 878                  * them have separate framebuffers for external and
 879                  * internal video, which is admittedly pretty cool,
 880                  * but will be a bit of a headache to support here.
 881                  * Also, many of them are grayscale, and we don't
 882                  * really support that.
 883                  */
 884
 885                 case MAC_MODEL_PB140:
 886                 case MAC_MODEL_PB145:
 887                 case MAC_MODEL_PB170:
 888                         strcpy(macfb_fix.id, "DDC");
 889                         break;
 890
 891                 /*
 892                  * Internal is GSC, External (if present) is ViSC
 893                  */
 894                 case MAC_MODEL_PB150:   /* no external video */
 895                 case MAC_MODEL_PB160:
 896                 case MAC_MODEL_PB165:
 897                 case MAC_MODEL_PB180:
 898                 case MAC_MODEL_PB210:
 899                 case MAC_MODEL_PB230:
 900                         strcpy(macfb_fix.id, "GSC");
 901                         break;
 902
 903                 /*
 904                  * Internal is TIM, External is ViSC
 905                  */
 906                 case MAC_MODEL_PB165C:
 907                 case MAC_MODEL_PB180C:
 908                         strcpy(macfb_fix.id, "TIM");
 909                         break;
 910
 911                 /*
 912                  * Internal is CSC, External is Keystone+Ariel.
 913                  */
 914                 case MAC_MODEL_PB190:   /* external video is optional */
 915                 case MAC_MODEL_PB520:
 916                 case MAC_MODEL_PB250:
 917                 case MAC_MODEL_PB270C:
 918                 case MAC_MODEL_PB280:
 919                 case MAC_MODEL_PB280C:
 920                         macfb_setpalette = csc_setpalette;
 921                         macfb_defined.activate = FB_ACTIVATE_NOW;
 922                         strcpy(macfb_fix.id, "CSC");
 923                         csc_cmap_regs = ioremap(CSC_BASE, 0x1000);
 924                         break;
 925
 926                 default:
 927                         strcpy(macfb_fix.id, "Unknown");
 928                         break;
 929                 }
 930
 931         fb_info.fbops           = &macfb_ops;
 932         fb_info.var             = macfb_defined;
 933         fb_info.fix             = macfb_fix;
 934         fb_info.pseudo_palette  = pseudo_palette;
 935         fb_info.flags           = FBINFO_DEFAULT;
 936
 937         err = fb_alloc_cmap(&fb_info.cmap, video_cmap_len, 0);
 938         if (err)
 939                 goto fail_unmap;
 940
 941         err = register_framebuffer(&fb_info);
 942         if (err)
 943                 goto fail_dealloc;
 944
 945         printk("fb%d: %s frame buffer device\n",
 946                fb_info.node, fb_info.fix.id);
 947         return 0;
 948
 949 fail_dealloc:
 950         fb_dealloc_cmap(&fb_info.cmap);
 951 fail_unmap:
 952         iounmap(fb_info.screen_base);
 953         iounmap_macfb();
 954         return err;
 955 }
 956
 957 module_init(macfb_init);
 958 MODULE_LICENSE("GPL");