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