macfb.c
上传用户:lgb322
上传日期:2013-02-24
资源大小:30529k
文件大小:32k
源码类别:

嵌入式Linux

开发平台:

Unix_Linux

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