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