platinumfb.c 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705
  1. /*
  2. * platinumfb.c -- frame buffer device for the PowerMac 'platinum' display
  3. *
  4. * Copyright (C) 1998 Franz Sirl
  5. *
  6. * Frame buffer structure from:
  7. * drivers/video/controlfb.c -- frame buffer device for
  8. * Apple 'control' display chip.
  9. * Copyright (C) 1998 Dan Jacobowitz
  10. *
  11. * Hardware information from:
  12. * platinum.c: Console support for PowerMac "platinum" display adaptor.
  13. * Copyright (C) 1996 Paul Mackerras and Mark Abene
  14. *
  15. * This file is subject to the terms and conditions of the GNU General Public
  16. * License. See the file COPYING in the main directory of this archive for
  17. * more details.
  18. */
  19. #include <linux/module.h>
  20. #include <linux/kernel.h>
  21. #include <linux/errno.h>
  22. #include <linux/string.h>
  23. #include <linux/mm.h>
  24. #include <linux/slab.h>
  25. #include <linux/vmalloc.h>
  26. #include <linux/delay.h>
  27. #include <linux/interrupt.h>
  28. #include <linux/fb.h>
  29. #include <linux/init.h>
  30. #include <linux/pci.h>
  31. #include <linux/nvram.h>
  32. #include <asm/io.h>
  33. #include <asm/prom.h>
  34. #include <asm/pgtable.h>
  35. #include <asm/of_device.h>
  36. #include <asm/of_platform.h>
  37. #include "macmodes.h"
  38. #include "platinumfb.h"
  39. static int default_vmode = VMODE_NVRAM;
  40. static int default_cmode = CMODE_NVRAM;
  41. struct fb_info_platinum {
  42. struct fb_info *info;
  43. int vmode, cmode;
  44. int xres, yres;
  45. int vxres, vyres;
  46. int xoffset, yoffset;
  47. struct {
  48. __u8 red, green, blue;
  49. } palette[256];
  50. u32 pseudo_palette[17];
  51. volatile struct cmap_regs __iomem *cmap_regs;
  52. unsigned long cmap_regs_phys;
  53. volatile struct platinum_regs __iomem *platinum_regs;
  54. unsigned long platinum_regs_phys;
  55. __u8 __iomem *frame_buffer;
  56. volatile __u8 __iomem *base_frame_buffer;
  57. unsigned long frame_buffer_phys;
  58. unsigned long total_vram;
  59. int clktype;
  60. int dactype;
  61. struct resource rsrc_fb, rsrc_reg;
  62. };
  63. /*
  64. * Frame buffer device API
  65. */
  66. static int platinumfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
  67. u_int transp, struct fb_info *info);
  68. static int platinumfb_blank(int blank_mode, struct fb_info *info);
  69. static int platinumfb_set_par (struct fb_info *info);
  70. static int platinumfb_check_var (struct fb_var_screeninfo *var, struct fb_info *info);
  71. /*
  72. * internal functions
  73. */
  74. static inline int platinum_vram_reqd(int video_mode, int color_mode);
  75. static int read_platinum_sense(struct fb_info_platinum *pinfo);
  76. static void set_platinum_clock(struct fb_info_platinum *pinfo);
  77. static void platinum_set_hardware(struct fb_info_platinum *pinfo);
  78. static int platinum_var_to_par(struct fb_var_screeninfo *var,
  79. struct fb_info_platinum *pinfo,
  80. int check_only);
  81. /*
  82. * Interface used by the world
  83. */
  84. static struct fb_ops platinumfb_ops = {
  85. .owner = THIS_MODULE,
  86. .fb_check_var = platinumfb_check_var,
  87. .fb_set_par = platinumfb_set_par,
  88. .fb_setcolreg = platinumfb_setcolreg,
  89. .fb_blank = platinumfb_blank,
  90. .fb_fillrect = cfb_fillrect,
  91. .fb_copyarea = cfb_copyarea,
  92. .fb_imageblit = cfb_imageblit,
  93. };
  94. /*
  95. * Checks a var structure
  96. */
  97. static int platinumfb_check_var (struct fb_var_screeninfo *var, struct fb_info *info)
  98. {
  99. return platinum_var_to_par(var, info->par, 1);
  100. }
  101. /*
  102. * Applies current var to display
  103. */
  104. static int platinumfb_set_par (struct fb_info *info)
  105. {
  106. struct fb_info_platinum *pinfo = info->par;
  107. struct platinum_regvals *init;
  108. int err, offset = 0x20;
  109. if((err = platinum_var_to_par(&info->var, pinfo, 0))) {
  110. printk (KERN_ERR "platinumfb_set_par: error calling"
  111. " platinum_var_to_par: %d.\n", err);
  112. return err;
  113. }
  114. platinum_set_hardware(pinfo);
  115. init = platinum_reg_init[pinfo->vmode-1];
  116. if ((pinfo->vmode == VMODE_832_624_75) && (pinfo->cmode > CMODE_8))
  117. offset = 0x10;
  118. info->screen_base = pinfo->frame_buffer + init->fb_offset + offset;
  119. info->fix.smem_start = (pinfo->frame_buffer_phys) + init->fb_offset + offset;
  120. info->fix.visual = (pinfo->cmode == CMODE_8) ?
  121. FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_DIRECTCOLOR;
  122. info->fix.line_length = vmode_attrs[pinfo->vmode-1].hres * (1<<pinfo->cmode)
  123. + offset;
  124. printk("line_length: %x\n", info->fix.line_length);
  125. return 0;
  126. }
  127. static int platinumfb_blank(int blank, struct fb_info *fb)
  128. {
  129. /*
  130. * Blank the screen if blank_mode != 0, else unblank. If blank == NULL
  131. * then the caller blanks by setting the CLUT (Color Look Up Table) to all
  132. * black. Return 0 if blanking succeeded, != 0 if un-/blanking failed due
  133. * to e.g. a video mode which doesn't support it. Implements VESA suspend
  134. * and powerdown modes on hardware that supports disabling hsync/vsync:
  135. * blank_mode == 2: suspend vsync
  136. * blank_mode == 3: suspend hsync
  137. * blank_mode == 4: powerdown
  138. */
  139. /* [danj] I think there's something fishy about those constants... */
  140. /*
  141. struct fb_info_platinum *info = (struct fb_info_platinum *) fb;
  142. int ctrl;
  143. ctrl = ld_le32(&info->platinum_regs->ctrl.r) | 0x33;
  144. if (blank)
  145. --blank_mode;
  146. if (blank & VESA_VSYNC_SUSPEND)
  147. ctrl &= ~3;
  148. if (blank & VESA_HSYNC_SUSPEND)
  149. ctrl &= ~0x30;
  150. out_le32(&info->platinum_regs->ctrl.r, ctrl);
  151. */
  152. /* TODO: Figure out how the heck to powerdown this thing! */
  153. return 0;
  154. }
  155. static int platinumfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
  156. u_int transp, struct fb_info *info)
  157. {
  158. struct fb_info_platinum *pinfo = info->par;
  159. volatile struct cmap_regs __iomem *cmap_regs = pinfo->cmap_regs;
  160. if (regno > 255)
  161. return 1;
  162. red >>= 8;
  163. green >>= 8;
  164. blue >>= 8;
  165. pinfo->palette[regno].red = red;
  166. pinfo->palette[regno].green = green;
  167. pinfo->palette[regno].blue = blue;
  168. out_8(&cmap_regs->addr, regno); /* tell clut what addr to fill */
  169. out_8(&cmap_regs->lut, red); /* send one color channel at */
  170. out_8(&cmap_regs->lut, green); /* a time... */
  171. out_8(&cmap_regs->lut, blue);
  172. if (regno < 16) {
  173. int i;
  174. u32 *pal = info->pseudo_palette;
  175. switch (pinfo->cmode) {
  176. case CMODE_16:
  177. pal[regno] = (regno << 10) | (regno << 5) | regno;
  178. break;
  179. case CMODE_32:
  180. i = (regno << 8) | regno;
  181. pal[regno] = (i << 16) | i;
  182. break;
  183. }
  184. }
  185. return 0;
  186. }
  187. static inline int platinum_vram_reqd(int video_mode, int color_mode)
  188. {
  189. return vmode_attrs[video_mode-1].vres *
  190. (vmode_attrs[video_mode-1].hres * (1<<color_mode) +
  191. ((video_mode == VMODE_832_624_75) &&
  192. (color_mode > CMODE_8)) ? 0x10 : 0x20) + 0x1000;
  193. }
  194. #define STORE_D2(a, d) { \
  195. out_8(&cmap_regs->addr, (a+32)); \
  196. out_8(&cmap_regs->d2, (d)); \
  197. }
  198. static void set_platinum_clock(struct fb_info_platinum *pinfo)
  199. {
  200. volatile struct cmap_regs __iomem *cmap_regs = pinfo->cmap_regs;
  201. struct platinum_regvals *init;
  202. init = platinum_reg_init[pinfo->vmode-1];
  203. STORE_D2(6, 0xc6);
  204. out_8(&cmap_regs->addr,3+32);
  205. if (in_8(&cmap_regs->d2) == 2) {
  206. STORE_D2(7, init->clock_params[pinfo->clktype][0]);
  207. STORE_D2(8, init->clock_params[pinfo->clktype][1]);
  208. STORE_D2(3, 3);
  209. } else {
  210. STORE_D2(4, init->clock_params[pinfo->clktype][0]);
  211. STORE_D2(5, init->clock_params[pinfo->clktype][1]);
  212. STORE_D2(3, 2);
  213. }
  214. __delay(5000);
  215. STORE_D2(9, 0xa6);
  216. }
  217. /* Now how about actually saying, Make it so! */
  218. /* Some things in here probably don't need to be done each time. */
  219. static void platinum_set_hardware(struct fb_info_platinum *pinfo)
  220. {
  221. volatile struct platinum_regs __iomem *platinum_regs = pinfo->platinum_regs;
  222. volatile struct cmap_regs __iomem *cmap_regs = pinfo->cmap_regs;
  223. struct platinum_regvals *init;
  224. int i;
  225. int vmode, cmode;
  226. vmode = pinfo->vmode;
  227. cmode = pinfo->cmode;
  228. init = platinum_reg_init[vmode - 1];
  229. /* Initialize display timing registers */
  230. out_be32(&platinum_regs->reg[24].r, 7); /* turn display off */
  231. for (i = 0; i < 26; ++i)
  232. out_be32(&platinum_regs->reg[i+32].r, init->regs[i]);
  233. out_be32(&platinum_regs->reg[26+32].r, (pinfo->total_vram == 0x100000 ?
  234. init->offset[cmode] + 4 - cmode :
  235. init->offset[cmode]));
  236. out_be32(&platinum_regs->reg[16].r, (unsigned) pinfo->frame_buffer_phys+init->fb_offset+0x10);
  237. out_be32(&platinum_regs->reg[18].r, init->pitch[cmode]);
  238. out_be32(&platinum_regs->reg[19].r, (pinfo->total_vram == 0x100000 ?
  239. init->mode[cmode+1] :
  240. init->mode[cmode]));
  241. out_be32(&platinum_regs->reg[20].r, (pinfo->total_vram == 0x100000 ? 0x11 : 0x1011));
  242. out_be32(&platinum_regs->reg[21].r, 0x100);
  243. out_be32(&platinum_regs->reg[22].r, 1);
  244. out_be32(&platinum_regs->reg[23].r, 1);
  245. out_be32(&platinum_regs->reg[26].r, 0xc00);
  246. out_be32(&platinum_regs->reg[27].r, 0x235);
  247. /* out_be32(&platinum_regs->reg[27].r, 0x2aa); */
  248. STORE_D2(0, (pinfo->total_vram == 0x100000 ?
  249. init->dacula_ctrl[cmode] & 0xf :
  250. init->dacula_ctrl[cmode]));
  251. STORE_D2(1, 4);
  252. STORE_D2(2, 0);
  253. set_platinum_clock(pinfo);
  254. out_be32(&platinum_regs->reg[24].r, 0); /* turn display on */
  255. }
  256. /*
  257. * Set misc info vars for this driver
  258. */
  259. static void __devinit platinum_init_info(struct fb_info *info, struct fb_info_platinum *pinfo)
  260. {
  261. /* Fill fb_info */
  262. info->fbops = &platinumfb_ops;
  263. info->pseudo_palette = pinfo->pseudo_palette;
  264. info->flags = FBINFO_DEFAULT;
  265. info->screen_base = pinfo->frame_buffer + 0x20;
  266. fb_alloc_cmap(&info->cmap, 256, 0);
  267. /* Fill fix common fields */
  268. strcpy(info->fix.id, "platinum");
  269. info->fix.mmio_start = pinfo->platinum_regs_phys;
  270. info->fix.mmio_len = 0x1000;
  271. info->fix.type = FB_TYPE_PACKED_PIXELS;
  272. info->fix.smem_start = pinfo->frame_buffer_phys + 0x20; /* will be updated later */
  273. info->fix.smem_len = pinfo->total_vram - 0x20;
  274. info->fix.ywrapstep = 0;
  275. info->fix.xpanstep = 0;
  276. info->fix.ypanstep = 0;
  277. info->fix.type_aux = 0;
  278. info->fix.accel = FB_ACCEL_NONE;
  279. }
  280. static int __devinit platinum_init_fb(struct fb_info *info)
  281. {
  282. struct fb_info_platinum *pinfo = info->par;
  283. struct fb_var_screeninfo var;
  284. int sense, rc;
  285. sense = read_platinum_sense(pinfo);
  286. printk(KERN_INFO "platinumfb: Monitor sense value = 0x%x, ", sense);
  287. if (default_vmode == VMODE_NVRAM) {
  288. #ifdef CONFIG_NVRAM
  289. default_vmode = nvram_read_byte(NV_VMODE);
  290. if (default_vmode <= 0 || default_vmode > VMODE_MAX ||
  291. !platinum_reg_init[default_vmode-1])
  292. #endif
  293. default_vmode = VMODE_CHOOSE;
  294. }
  295. if (default_vmode == VMODE_CHOOSE) {
  296. default_vmode = mac_map_monitor_sense(sense);
  297. }
  298. if (default_vmode <= 0 || default_vmode > VMODE_MAX)
  299. default_vmode = VMODE_640_480_60;
  300. #ifdef CONFIG_NVRAM
  301. if (default_cmode == CMODE_NVRAM)
  302. default_cmode = nvram_read_byte(NV_CMODE);
  303. #endif
  304. if (default_cmode < CMODE_8 || default_cmode > CMODE_32)
  305. default_cmode = CMODE_8;
  306. /*
  307. * Reduce the pixel size if we don't have enough VRAM.
  308. */
  309. while(default_cmode > CMODE_8 &&
  310. platinum_vram_reqd(default_vmode, default_cmode) > pinfo->total_vram)
  311. default_cmode--;
  312. printk("platinumfb: Using video mode %d and color mode %d.\n", default_vmode, default_cmode);
  313. /* Setup default var */
  314. if (mac_vmode_to_var(default_vmode, default_cmode, &var) < 0) {
  315. /* This shouldn't happen! */
  316. printk("mac_vmode_to_var(%d, %d,) failed\n", default_vmode, default_cmode);
  317. try_again:
  318. default_vmode = VMODE_640_480_60;
  319. default_cmode = CMODE_8;
  320. if (mac_vmode_to_var(default_vmode, default_cmode, &var) < 0) {
  321. printk(KERN_ERR "platinumfb: mac_vmode_to_var() failed\n");
  322. return -ENXIO;
  323. }
  324. }
  325. /* Initialize info structure */
  326. platinum_init_info(info, pinfo);
  327. /* Apply default var */
  328. info->var = var;
  329. var.activate = FB_ACTIVATE_NOW;
  330. rc = fb_set_var(info, &var);
  331. if (rc && (default_vmode != VMODE_640_480_60 || default_cmode != CMODE_8))
  332. goto try_again;
  333. /* Register with fbdev layer */
  334. rc = register_framebuffer(info);
  335. if (rc < 0)
  336. return rc;
  337. printk(KERN_INFO "fb%d: Apple Platinum frame buffer device\n", info->node);
  338. return 0;
  339. }
  340. /*
  341. * Get the monitor sense value.
  342. * Note that this can be called before calibrate_delay,
  343. * so we can't use udelay.
  344. */
  345. static int read_platinum_sense(struct fb_info_platinum *info)
  346. {
  347. volatile struct platinum_regs __iomem *platinum_regs = info->platinum_regs;
  348. int sense;
  349. out_be32(&platinum_regs->reg[23].r, 7); /* turn off drivers */
  350. __delay(2000);
  351. sense = (~in_be32(&platinum_regs->reg[23].r) & 7) << 8;
  352. /* drive each sense line low in turn and collect the other 2 */
  353. out_be32(&platinum_regs->reg[23].r, 3); /* drive A low */
  354. __delay(2000);
  355. sense |= (~in_be32(&platinum_regs->reg[23].r) & 3) << 4;
  356. out_be32(&platinum_regs->reg[23].r, 5); /* drive B low */
  357. __delay(2000);
  358. sense |= (~in_be32(&platinum_regs->reg[23].r) & 4) << 1;
  359. sense |= (~in_be32(&platinum_regs->reg[23].r) & 1) << 2;
  360. out_be32(&platinum_regs->reg[23].r, 6); /* drive C low */
  361. __delay(2000);
  362. sense |= (~in_be32(&platinum_regs->reg[23].r) & 6) >> 1;
  363. out_be32(&platinum_regs->reg[23].r, 7); /* turn off drivers */
  364. return sense;
  365. }
  366. /*
  367. * This routine takes a user-supplied var, and picks the best vmode/cmode from it.
  368. * It also updates the var structure to the actual mode data obtained
  369. */
  370. static int platinum_var_to_par(struct fb_var_screeninfo *var,
  371. struct fb_info_platinum *pinfo,
  372. int check_only)
  373. {
  374. int vmode, cmode;
  375. if (mac_var_to_vmode(var, &vmode, &cmode) != 0) {
  376. printk(KERN_ERR "platinum_var_to_par: mac_var_to_vmode unsuccessful.\n");
  377. printk(KERN_ERR "platinum_var_to_par: var->xres = %d\n", var->xres);
  378. printk(KERN_ERR "platinum_var_to_par: var->yres = %d\n", var->yres);
  379. printk(KERN_ERR "platinum_var_to_par: var->xres_virtual = %d\n", var->xres_virtual);
  380. printk(KERN_ERR "platinum_var_to_par: var->yres_virtual = %d\n", var->yres_virtual);
  381. printk(KERN_ERR "platinum_var_to_par: var->bits_per_pixel = %d\n", var->bits_per_pixel);
  382. printk(KERN_ERR "platinum_var_to_par: var->pixclock = %d\n", var->pixclock);
  383. printk(KERN_ERR "platinum_var_to_par: var->vmode = %d\n", var->vmode);
  384. return -EINVAL;
  385. }
  386. if (!platinum_reg_init[vmode-1]) {
  387. printk(KERN_ERR "platinum_var_to_par, vmode %d not valid.\n", vmode);
  388. return -EINVAL;
  389. }
  390. if (platinum_vram_reqd(vmode, cmode) > pinfo->total_vram) {
  391. printk(KERN_ERR "platinum_var_to_par, not enough ram for vmode %d, cmode %d.\n", vmode, cmode);
  392. return -EINVAL;
  393. }
  394. if (mac_vmode_to_var(vmode, cmode, var))
  395. return -EINVAL;
  396. if (check_only)
  397. return 0;
  398. pinfo->vmode = vmode;
  399. pinfo->cmode = cmode;
  400. pinfo->xres = vmode_attrs[vmode-1].hres;
  401. pinfo->yres = vmode_attrs[vmode-1].vres;
  402. pinfo->xoffset = 0;
  403. pinfo->yoffset = 0;
  404. pinfo->vxres = pinfo->xres;
  405. pinfo->vyres = pinfo->yres;
  406. return 0;
  407. }
  408. /*
  409. * Parse user speficied options (`video=platinumfb:')
  410. */
  411. static int __init platinumfb_setup(char *options)
  412. {
  413. char *this_opt;
  414. if (!options || !*options)
  415. return 0;
  416. while ((this_opt = strsep(&options, ",")) != NULL) {
  417. if (!strncmp(this_opt, "vmode:", 6)) {
  418. int vmode = simple_strtoul(this_opt+6, NULL, 0);
  419. if (vmode > 0 && vmode <= VMODE_MAX)
  420. default_vmode = vmode;
  421. } else if (!strncmp(this_opt, "cmode:", 6)) {
  422. int depth = simple_strtoul(this_opt+6, NULL, 0);
  423. switch (depth) {
  424. case 0:
  425. case 8:
  426. default_cmode = CMODE_8;
  427. break;
  428. case 15:
  429. case 16:
  430. default_cmode = CMODE_16;
  431. break;
  432. case 24:
  433. case 32:
  434. default_cmode = CMODE_32;
  435. break;
  436. }
  437. }
  438. }
  439. return 0;
  440. }
  441. #ifdef __powerpc__
  442. #define invalidate_cache(addr) \
  443. asm volatile("eieio; dcbf 0,%1" \
  444. : "=m" (*(addr)) : "r" (addr) : "memory");
  445. #else
  446. #define invalidate_cache(addr)
  447. #endif
  448. static int __devinit platinumfb_probe(struct of_device* odev,
  449. const struct of_device_id *match)
  450. {
  451. struct device_node *dp = odev->node;
  452. struct fb_info *info;
  453. struct fb_info_platinum *pinfo;
  454. volatile __u8 *fbuffer;
  455. int bank0, bank1, bank2, bank3, rc;
  456. printk(KERN_INFO "platinumfb: Found Apple Platinum video hardware\n");
  457. info = framebuffer_alloc(sizeof(*pinfo), &odev->dev);
  458. if (info == NULL)
  459. return -ENOMEM;
  460. pinfo = info->par;
  461. if (of_address_to_resource(dp, 0, &pinfo->rsrc_reg) ||
  462. of_address_to_resource(dp, 1, &pinfo->rsrc_fb)) {
  463. printk(KERN_ERR "platinumfb: Can't get resources\n");
  464. framebuffer_release(info);
  465. return -ENXIO;
  466. }
  467. if (!request_mem_region(pinfo->rsrc_reg.start,
  468. pinfo->rsrc_reg.start -
  469. pinfo->rsrc_reg.end + 1,
  470. "platinumfb registers")) {
  471. framebuffer_release(info);
  472. return -ENXIO;
  473. }
  474. if (!request_mem_region(pinfo->rsrc_fb.start,
  475. pinfo->rsrc_fb.start
  476. - pinfo->rsrc_fb.end + 1,
  477. "platinumfb framebuffer")) {
  478. release_mem_region(pinfo->rsrc_reg.start,
  479. pinfo->rsrc_reg.end -
  480. pinfo->rsrc_reg.start + 1);
  481. framebuffer_release(info);
  482. return -ENXIO;
  483. }
  484. /* frame buffer - map only 4MB */
  485. pinfo->frame_buffer_phys = pinfo->rsrc_fb.start;
  486. pinfo->frame_buffer = __ioremap(pinfo->rsrc_fb.start, 0x400000,
  487. _PAGE_WRITETHRU);
  488. pinfo->base_frame_buffer = pinfo->frame_buffer;
  489. /* registers */
  490. pinfo->platinum_regs_phys = pinfo->rsrc_reg.start;
  491. pinfo->platinum_regs = ioremap(pinfo->rsrc_reg.start, 0x1000);
  492. pinfo->cmap_regs_phys = 0xf301b000; /* XXX not in prom? */
  493. request_mem_region(pinfo->cmap_regs_phys, 0x1000, "platinumfb cmap");
  494. pinfo->cmap_regs = ioremap(pinfo->cmap_regs_phys, 0x1000);
  495. /* Grok total video ram */
  496. out_be32(&pinfo->platinum_regs->reg[16].r, (unsigned)pinfo->frame_buffer_phys);
  497. out_be32(&pinfo->platinum_regs->reg[20].r, 0x1011); /* select max vram */
  498. out_be32(&pinfo->platinum_regs->reg[24].r, 0); /* switch in vram */
  499. fbuffer = pinfo->base_frame_buffer;
  500. fbuffer[0x100000] = 0x34;
  501. fbuffer[0x100008] = 0x0;
  502. invalidate_cache(&fbuffer[0x100000]);
  503. fbuffer[0x200000] = 0x56;
  504. fbuffer[0x200008] = 0x0;
  505. invalidate_cache(&fbuffer[0x200000]);
  506. fbuffer[0x300000] = 0x78;
  507. fbuffer[0x300008] = 0x0;
  508. invalidate_cache(&fbuffer[0x300000]);
  509. bank0 = 1; /* builtin 1MB vram, always there */
  510. bank1 = fbuffer[0x100000] == 0x34;
  511. bank2 = fbuffer[0x200000] == 0x56;
  512. bank3 = fbuffer[0x300000] == 0x78;
  513. pinfo->total_vram = (bank0 + bank1 + bank2 + bank3) * 0x100000;
  514. printk(KERN_INFO "platinumfb: Total VRAM = %dMB (%d%d%d%d)\n", (int) (pinfo->total_vram / 1024 / 1024),
  515. bank3, bank2, bank1, bank0);
  516. /*
  517. * Try to determine whether we have an old or a new DACula.
  518. */
  519. out_8(&pinfo->cmap_regs->addr, 0x40);
  520. pinfo->dactype = in_8(&pinfo->cmap_regs->d2);
  521. switch (pinfo->dactype) {
  522. case 0x3c:
  523. pinfo->clktype = 1;
  524. printk(KERN_INFO "platinumfb: DACula type 0x3c\n");
  525. break;
  526. case 0x84:
  527. pinfo->clktype = 0;
  528. printk(KERN_INFO "platinumfb: DACula type 0x84\n");
  529. break;
  530. default:
  531. pinfo->clktype = 0;
  532. printk(KERN_INFO "platinumfb: Unknown DACula type: %x\n", pinfo->dactype);
  533. break;
  534. }
  535. dev_set_drvdata(&odev->dev, info);
  536. rc = platinum_init_fb(info);
  537. if (rc != 0) {
  538. iounmap(pinfo->frame_buffer);
  539. iounmap(pinfo->platinum_regs);
  540. iounmap(pinfo->cmap_regs);
  541. dev_set_drvdata(&odev->dev, NULL);
  542. framebuffer_release(info);
  543. }
  544. return rc;
  545. }
  546. static int __devexit platinumfb_remove(struct of_device* odev)
  547. {
  548. struct fb_info *info = dev_get_drvdata(&odev->dev);
  549. struct fb_info_platinum *pinfo = info->par;
  550. unregister_framebuffer (info);
  551. /* Unmap frame buffer and registers */
  552. release_mem_region(pinfo->rsrc_fb.start,
  553. pinfo->rsrc_fb.end -
  554. pinfo->rsrc_fb.start + 1);
  555. release_mem_region(pinfo->rsrc_reg.start,
  556. pinfo->rsrc_reg.end -
  557. pinfo->rsrc_reg.start + 1);
  558. iounmap(pinfo->frame_buffer);
  559. iounmap(pinfo->platinum_regs);
  560. release_mem_region(pinfo->cmap_regs_phys, 0x1000);
  561. iounmap(pinfo->cmap_regs);
  562. framebuffer_release(info);
  563. return 0;
  564. }
  565. static struct of_device_id platinumfb_match[] =
  566. {
  567. {
  568. .name = "platinum",
  569. },
  570. {},
  571. };
  572. static struct of_platform_driver platinum_driver =
  573. {
  574. .name = "platinumfb",
  575. .match_table = platinumfb_match,
  576. .probe = platinumfb_probe,
  577. .remove = platinumfb_remove,
  578. };
  579. static int __init platinumfb_init(void)
  580. {
  581. #ifndef MODULE
  582. char *option = NULL;
  583. if (fb_get_options("platinumfb", &option))
  584. return -ENODEV;
  585. platinumfb_setup(option);
  586. #endif
  587. of_register_platform_driver(&platinum_driver);
  588. return 0;
  589. }
  590. static void __exit platinumfb_exit(void)
  591. {
  592. of_unregister_platform_driver(&platinum_driver);
  593. }
  594. MODULE_LICENSE("GPL");
  595. MODULE_DESCRIPTION("framebuffer driver for Apple Platinum video");
  596. module_init(platinumfb_init);
  597. #ifdef MODULE
  598. module_exit(platinumfb_exit);
  599. #endif