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