macfb: cleanup
[linux-2.6.git] / 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");