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