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