CRED: Wrap task credential accesses in the JFS filesystem
[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 #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[16];
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         if (fb_info->var.bits_per_pixel <= 8) {
533                 switch (fb_info->var.bits_per_pixel) {
534                 case 1:
535                         /* We shouldn't get here */
536                         break;
537                 case 2:
538                 case 4:
539                 case 8:
540                         if (macfb_setpalette)
541                                 macfb_setpalette(regno, red, green, blue,
542                                                  fb_info);
543                         else
544                                 return 1;
545                         break;
546                 }
547         } else if (regno < 16) {
548                 switch (fb_info->var.bits_per_pixel) {
549                 case 16:
550                         if (fb_info->var.red.offset == 10) {
551                                 /* 1:5:5:5 */
552                                 ((u32*) (fb_info->pseudo_palette))[regno] =
553                                         ((red   & 0xf800) >>  1) |
554                                         ((green & 0xf800) >>  6) |
555                                         ((blue  & 0xf800) >> 11) |
556                                         ((transp != 0) << 15);
557                         } else {
558                                 /* 0:5:6:5 */
559                                 ((u32*) (fb_info->pseudo_palette))[regno] =
560                                         ((red   & 0xf800)      ) |
561                                         ((green & 0xfc00) >>  5) |
562                                         ((blue  & 0xf800) >> 11);
563                         }
564                         break;
565                         /* I'm pretty sure that one or the other of these
566                            doesn't exist on 68k Macs */
567                 case 24:
568                         red   >>= 8;
569                         green >>= 8;
570                         blue  >>= 8;
571                         ((u32 *)(fb_info->pseudo_palette))[regno] =
572                                 (red   << fb_info->var.red.offset)   |
573                                 (green << fb_info->var.green.offset) |
574                                 (blue  << fb_info->var.blue.offset);
575                         break;
576                 case 32:
577                         red   >>= 8;
578                         green >>= 8;
579                         blue  >>= 8;
580                         ((u32 *)(fb_info->pseudo_palette))[regno] =
581                                 (red   << fb_info->var.red.offset)   |
582                                 (green << fb_info->var.green.offset) |
583                                 (blue  << fb_info->var.blue.offset);
584                         break;
585                 }
586         }
587
588         return 0;
589 }
590
591 static struct fb_ops macfb_ops = {
592         .owner          = THIS_MODULE,
593         .fb_setcolreg   = macfb_setcolreg,
594         .fb_fillrect    = cfb_fillrect,
595         .fb_copyarea    = cfb_copyarea,
596         .fb_imageblit   = cfb_imageblit,
597 };
598
599 static void __init macfb_setup(char *options)
600 {
601         char *this_opt;
602         
603         if (!options || !*options)
604                 return;
605         
606         while ((this_opt = strsep(&options, ",")) != NULL) {
607                 if (!*this_opt) continue;
608                 
609                 if (! strcmp(this_opt, "inverse"))
610                         inverse=1;
611                 /* This means "turn on experimental CLUT code" */
612                 else if (!strcmp(this_opt, "vidtest"))
613                         vidtest=1;
614         }
615 }
616
617 static void __init iounmap_macfb(void)
618 {
619         if (valkyrie_cmap_regs)
620                 iounmap(valkyrie_cmap_regs);
621         if (dafb_cmap_regs)
622                 iounmap(dafb_cmap_regs);
623         if (v8_brazil_cmap_regs)
624                 iounmap(v8_brazil_cmap_regs);
625         if (rbv_cmap_regs)
626                 iounmap(rbv_cmap_regs);
627         if (civic_cmap_regs)
628                 iounmap(civic_cmap_regs);
629         if (csc_cmap_regs)
630                 iounmap(csc_cmap_regs);
631 }
632
633 static int __init macfb_init(void)
634 {
635         int video_cmap_len, video_is_nubus = 0;
636         struct nubus_dev* ndev = NULL;
637         char *option = NULL;
638         int err;
639
640         if (fb_get_options("macfb", &option))
641                 return -ENODEV;
642         macfb_setup(option);
643
644         if (!MACH_IS_MAC) 
645                 return -ENODEV;
646
647         /* There can only be one internal video controller anyway so
648            we're not too worried about this */
649         macfb_defined.xres = mac_bi_data.dimensions & 0xFFFF;
650         macfb_defined.yres = mac_bi_data.dimensions >> 16;
651         macfb_defined.bits_per_pixel = mac_bi_data.videodepth;
652         macfb_fix.line_length = mac_bi_data.videorow;
653         macfb_fix.smem_len = macfb_fix.line_length * macfb_defined.yres;
654         /* Note: physical address (since 2.1.127) */
655         macfb_fix.smem_start = mac_bi_data.videoaddr;
656         /* This is actually redundant with the initial mappings.
657            However, there are some non-obvious aspects to the way
658            those mappings are set up, so this is in fact the safest
659            way to ensure that this driver will work on every possible
660            Mac */
661         fb_info.screen_base = ioremap(mac_bi_data.videoaddr, macfb_fix.smem_len);
662         
663         printk("macfb: framebuffer at 0x%08lx, mapped to 0x%p, size %dk\n",
664                macfb_fix.smem_start, fb_info.screen_base, macfb_fix.smem_len/1024);
665         printk("macfb: mode is %dx%dx%d, linelength=%d\n",
666                macfb_defined.xres, macfb_defined.yres, macfb_defined.bits_per_pixel, macfb_fix.line_length);
667         
668         /*
669          *      Fill in the available video resolution
670          */
671          
672         macfb_defined.xres_virtual   = macfb_defined.xres;
673         macfb_defined.yres_virtual   = macfb_defined.yres;
674         macfb_defined.height = PIXEL_TO_MM(macfb_defined.yres);
675         macfb_defined.width  = PIXEL_TO_MM(macfb_defined.xres);  
676
677         printk("macfb: scrolling: redraw\n");
678         macfb_defined.yres_virtual = macfb_defined.yres;
679
680         /* some dummy values for timing to make fbset happy */
681         macfb_defined.pixclock     = 10000000 / macfb_defined.xres * 1000 / macfb_defined.yres;
682         macfb_defined.left_margin  = (macfb_defined.xres / 8) & 0xf8;
683         macfb_defined.hsync_len    = (macfb_defined.xres / 8) & 0xf8;
684
685         switch (macfb_defined.bits_per_pixel) {
686         case 1:
687                 /* XXX: I think this will catch any program that tries
688                    to do FBIO_PUTCMAP when the visual is monochrome */
689                 macfb_defined.red.length = macfb_defined.bits_per_pixel;
690                 macfb_defined.green.length = macfb_defined.bits_per_pixel;
691                 macfb_defined.blue.length = macfb_defined.bits_per_pixel;
692                 video_cmap_len = 0;
693                 macfb_fix.visual = FB_VISUAL_MONO01;
694                 break;
695         case 2:
696         case 4:
697         case 8:
698                 macfb_defined.red.length = macfb_defined.bits_per_pixel;
699                 macfb_defined.green.length = macfb_defined.bits_per_pixel;
700                 macfb_defined.blue.length = macfb_defined.bits_per_pixel;
701                 video_cmap_len = 1 << macfb_defined.bits_per_pixel;
702                 macfb_fix.visual = FB_VISUAL_PSEUDOCOLOR;
703                 break;
704         case 16:
705                 macfb_defined.transp.offset = 15;
706                 macfb_defined.transp.length = 1;
707                 macfb_defined.red.offset = 10;
708                 macfb_defined.red.length = 5;
709                 macfb_defined.green.offset = 5;
710                 macfb_defined.green.length = 5;
711                 macfb_defined.blue.offset = 0;
712                 macfb_defined.blue.length = 5;
713                 printk("macfb: directcolor: "
714                        "size=1:5:5:5, shift=15:10:5:0\n");
715                 video_cmap_len = 16;
716                 /* Should actually be FB_VISUAL_DIRECTCOLOR, but this
717                    works too */
718                 macfb_fix.visual = FB_VISUAL_TRUECOLOR;
719                 break;
720         case 24:
721         case 32:
722                 /* XXX: have to test these... can any 68k Macs
723                    actually do this on internal video? */
724                 macfb_defined.red.offset = 16;
725                 macfb_defined.red.length = 8;
726                 macfb_defined.green.offset = 8;
727                 macfb_defined.green.length = 8;
728                 macfb_defined.blue.offset = 0;
729                 macfb_defined.blue.length = 8;
730                 printk("macfb: truecolor: "
731                        "size=0:8:8:8, shift=0:16:8:0\n");
732                 video_cmap_len = 16;
733                 macfb_fix.visual = FB_VISUAL_TRUECOLOR;
734         default:
735                 video_cmap_len = 0;
736                 macfb_fix.visual = FB_VISUAL_MONO01;
737                 printk("macfb: unknown or unsupported bit depth: %d\n", macfb_defined.bits_per_pixel);
738                 break;
739         }
740         
741         /* Hardware dependent stuff */
742         /*  We take a wild guess that if the video physical address is
743          *  in nubus slot space, that the nubus card is driving video.
744          *  Penguin really ought to tell us whether we are using internal
745          *  video or not.
746          */
747         /* Hopefully we only find one of them.  Otherwise our NuBus
748            code is really broken :-) */
749
750         while ((ndev = nubus_find_type(NUBUS_CAT_DISPLAY, NUBUS_TYPE_VIDEO, ndev))
751                 != NULL)
752         {
753                 if (!(mac_bi_data.videoaddr >= ndev->board->slot_addr
754                       && (mac_bi_data.videoaddr <
755                           (unsigned long)nubus_slot_addr(ndev->board->slot+1))))
756                         continue;
757                 video_is_nubus = 1;
758                 /* We should probably just use the slot address... */
759                 video_slot = ndev->board->slot;
760
761                 switch(ndev->dr_hw) {
762                 case NUBUS_DRHW_APPLE_MDC:
763                         strcat( macfb_fix.id, "Display Card" );
764                         macfb_setpalette = mdc_setpalette;
765                         macfb_defined.activate = FB_ACTIVATE_NOW;
766                         break;
767                 case NUBUS_DRHW_APPLE_TFB:
768                         strcat( macfb_fix.id, "Toby" );
769                         macfb_setpalette = toby_setpalette;
770                         macfb_defined.activate = FB_ACTIVATE_NOW;
771                         break;
772                 case NUBUS_DRHW_APPLE_JET:
773                         strcat( macfb_fix.id, "Jet");
774                         macfb_setpalette = jet_setpalette;
775                         macfb_defined.activate = FB_ACTIVATE_NOW;
776                         break;                  
777                 default:
778                         strcat( macfb_fix.id, "Generic NuBus" );
779                         break;
780                 }
781         }
782
783         /* If it's not a NuBus card, it must be internal video */
784         /* FIXME: this function is getting way too big.  (this driver
785            is too...) */
786         if (!video_is_nubus)
787                 switch( mac_bi_data.id )
788                 {
789                         /* These don't have onboard video.  Eventually, we may
790                            be able to write separate framebuffer drivers for
791                            them (tobyfb.c, hiresfb.c, etc, etc) */
792                 case MAC_MODEL_II:
793                 case MAC_MODEL_IIX:
794                 case MAC_MODEL_IICX:
795                 case MAC_MODEL_IIFX:
796                         strcat( macfb_fix.id, "Generic NuBus" );
797                         break;
798
799                         /* Valkyrie Quadras */
800                 case MAC_MODEL_Q630:
801                         /* I'm not sure about this one */
802                 case MAC_MODEL_P588:
803                         strcat( macfb_fix.id, "Valkyrie built-in" );
804                         macfb_setpalette = valkyrie_setpalette;
805                         macfb_defined.activate = FB_ACTIVATE_NOW;
806                         valkyrie_cmap_regs = ioremap(DAC_BASE, 0x1000);
807                         break;
808
809                         /* DAFB Quadras */
810                         /* Note: these first four have the v7 DAFB, which is
811                            known to be rather unlike the ones used in the
812                            other models */
813                 case MAC_MODEL_P475:
814                 case MAC_MODEL_P475F:
815                 case MAC_MODEL_P575:
816                 case MAC_MODEL_Q605:
817         
818                 case MAC_MODEL_Q800:
819                 case MAC_MODEL_Q650:
820                 case MAC_MODEL_Q610:
821                 case MAC_MODEL_C650:
822                 case MAC_MODEL_C610:
823                 case MAC_MODEL_Q700:
824                 case MAC_MODEL_Q900:
825                 case MAC_MODEL_Q950:
826                         strcat( macfb_fix.id, "DAFB built-in" );
827                         macfb_setpalette = dafb_setpalette;
828                         macfb_defined.activate = FB_ACTIVATE_NOW;
829                         dafb_cmap_regs = ioremap(DAFB_BASE, 0x1000);
830                         break;
831
832                         /* LC II uses the V8 framebuffer */
833                 case MAC_MODEL_LCII:
834                         strcat( macfb_fix.id, "V8 built-in" );
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                         /* IIvi, IIvx use the "Brazil" framebuffer (which is
841                            very much like the V8, it seems, and probably uses
842                            the same DAC) */
843                 case MAC_MODEL_IIVI:
844                 case MAC_MODEL_IIVX:
845                 case MAC_MODEL_P600:
846                         strcat( macfb_fix.id, "Brazil built-in" );
847                         macfb_setpalette = v8_brazil_setpalette;
848                         macfb_defined.activate = FB_ACTIVATE_NOW;
849                         v8_brazil_cmap_regs = ioremap(DAC_BASE, 0x1000);
850                         break;
851                 
852                         /* LC III (and friends) use the Sonora framebuffer */
853                         /* Incidentally this is also used in the non-AV models
854                            of the x100 PowerMacs */
855                         /* These do in fact seem to use the same DAC interface
856                            as the LC II. */
857                 case MAC_MODEL_LCIII:
858                 case MAC_MODEL_P520:
859                 case MAC_MODEL_P550:
860                 case MAC_MODEL_P460:
861                         macfb_setpalette = v8_brazil_setpalette;
862                         macfb_defined.activate = FB_ACTIVATE_NOW;
863                         strcat( macfb_fix.id, "Sonora built-in" );
864                         v8_brazil_cmap_regs = ioremap(DAC_BASE, 0x1000);
865                         break;
866
867                         /* IIci and IIsi use the infamous RBV chip
868                            (the IIsi is just a rebadged and crippled
869                            IIci in a different case, BTW) */
870                 case MAC_MODEL_IICI:
871                 case MAC_MODEL_IISI:
872                         macfb_setpalette = rbv_setpalette;
873                         macfb_defined.activate = FB_ACTIVATE_NOW;
874                         strcat( macfb_fix.id, "RBV built-in" );
875                         rbv_cmap_regs = ioremap(DAC_BASE, 0x1000);
876                         break;
877
878                         /* AVs use the Civic framebuffer */
879                 case MAC_MODEL_Q840:
880                 case MAC_MODEL_C660:
881                         macfb_setpalette = civic_setpalette;
882                         macfb_defined.activate = FB_ACTIVATE_NOW;
883                         strcat( macfb_fix.id, "Civic built-in" );
884                         civic_cmap_regs = ioremap(CIVIC_BASE, 0x1000);
885                         break;
886
887                 
888                         /* Write a setpalette function for your machine, then
889                            you can add something similar here.  These are
890                            grouped by classes of video chipsets.  Some of this
891                            information is from the VideoToolbox "Bugs" web
892                            page at
893                            http://rajsky.psych.nyu.edu/Tips/VideoBugs.html */
894
895                         /* Assorted weirdos */
896                         /* We think this may be like the LC II */
897                 case MAC_MODEL_LC:
898                         if (vidtest) {
899                                 macfb_setpalette = v8_brazil_setpalette;
900                                 macfb_defined.activate = FB_ACTIVATE_NOW;
901                                 v8_brazil_cmap_regs =
902                                         ioremap(DAC_BASE, 0x1000);
903                         }
904                         strcat( macfb_fix.id, "LC built-in" );
905                         break;
906                         /* We think this may be like the LC II */
907                 case MAC_MODEL_CCL:
908                         if (vidtest) {
909                                 macfb_setpalette = v8_brazil_setpalette;
910                                 macfb_defined.activate = FB_ACTIVATE_NOW;
911                                 v8_brazil_cmap_regs =
912                                         ioremap(DAC_BASE, 0x1000);
913                         }
914                         strcat( macfb_fix.id, "Color Classic built-in" );
915                         break;
916
917                         /* And we *do* mean "weirdos" */
918                 case MAC_MODEL_TV:
919                         strcat( macfb_fix.id, "Mac TV built-in" );
920                         break;
921
922                         /* These don't have colour, so no need to worry */
923                 case MAC_MODEL_SE30:
924                 case MAC_MODEL_CLII:
925                         strcat( macfb_fix.id, "Monochrome built-in" );
926                         break;
927
928                         /* Powerbooks are particularly difficult.  Many of
929                            them have separate framebuffers for external and
930                            internal video, which is admittedly pretty cool,
931                            but will be a bit of a headache to support here.
932                            Also, many of them are grayscale, and we don't
933                            really support that. */
934
935                 case MAC_MODEL_PB140:
936                 case MAC_MODEL_PB145:
937                 case MAC_MODEL_PB170:
938                         strcat( macfb_fix.id, "DDC built-in" );
939                         break;
940
941                         /* Internal is GSC, External (if present) is ViSC */
942                 case MAC_MODEL_PB150:   /* no external video */
943                 case MAC_MODEL_PB160:
944                 case MAC_MODEL_PB165:
945                 case MAC_MODEL_PB180:
946                 case MAC_MODEL_PB210:
947                 case MAC_MODEL_PB230:
948                         strcat( macfb_fix.id, "GSC built-in" );
949                         break;
950
951                         /* Internal is TIM, External is ViSC */
952                 case MAC_MODEL_PB165C:
953                 case MAC_MODEL_PB180C:
954                         strcat( macfb_fix.id, "TIM built-in" );
955                         break;
956
957                         /* Internal is CSC, External is Keystone+Ariel. */
958                 case MAC_MODEL_PB190:   /* external video is optional */
959                 case MAC_MODEL_PB520:
960                 case MAC_MODEL_PB250:
961                 case MAC_MODEL_PB270C:
962                 case MAC_MODEL_PB280:
963                 case MAC_MODEL_PB280C:
964                         macfb_setpalette = csc_setpalette;
965                         macfb_defined.activate = FB_ACTIVATE_NOW;
966                         strcat( macfb_fix.id, "CSC built-in" );
967                         csc_cmap_regs = ioremap(CSC_BASE, 0x1000);
968                         break;
969                 
970                 default:
971                         strcat( macfb_fix.id, "Unknown/Unsupported built-in" );
972                         break;
973                 }
974
975         fb_info.fbops           = &macfb_ops;
976         fb_info.var             = macfb_defined;
977         fb_info.fix             = macfb_fix;
978         fb_info.pseudo_palette  = pseudo_palette;
979         fb_info.flags           = FBINFO_DEFAULT;
980
981         fb_alloc_cmap(&fb_info.cmap, video_cmap_len, 0);
982         
983         err = register_framebuffer(&fb_info);
984         if (!err)
985                 printk("fb%d: %s frame buffer device\n",
986                        fb_info.node, fb_info.fix.id);
987         else {
988                 iounmap(fb_info.screen_base);
989                 iounmap_macfb();
990         }
991         return err;
992 }
993
994 module_init(macfb_init);
995 MODULE_LICENSE("GPL");