p9100.c 8.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /* p9100.c: P9100 frame buffer driver
  3. *
  4. * Copyright (C) 2003, 2006 David S. Miller (davem@davemloft.net)
  5. * Copyright 1999 Derrick J Brashear (shadow@dementia.org)
  6. *
  7. * Driver layout based loosely on tgafb.c, see that file for credits.
  8. */
  9. #include <linux/module.h>
  10. #include <linux/kernel.h>
  11. #include <linux/errno.h>
  12. #include <linux/string.h>
  13. #include <linux/delay.h>
  14. #include <linux/init.h>
  15. #include <linux/fb.h>
  16. #include <linux/mm.h>
  17. #include <linux/of_device.h>
  18. #include <asm/io.h>
  19. #include <asm/fbio.h>
  20. #include "sbuslib.h"
  21. /*
  22. * Local functions.
  23. */
  24. static int p9100_setcolreg(unsigned, unsigned, unsigned, unsigned,
  25. unsigned, struct fb_info *);
  26. static int p9100_blank(int, struct fb_info *);
  27. static int p9100_mmap(struct fb_info *, struct vm_area_struct *);
  28. static int p9100_ioctl(struct fb_info *, unsigned int, unsigned long);
  29. /*
  30. * Frame buffer operations
  31. */
  32. static const struct fb_ops p9100_ops = {
  33. .owner = THIS_MODULE,
  34. .fb_setcolreg = p9100_setcolreg,
  35. .fb_blank = p9100_blank,
  36. .fb_fillrect = cfb_fillrect,
  37. .fb_copyarea = cfb_copyarea,
  38. .fb_imageblit = cfb_imageblit,
  39. .fb_mmap = p9100_mmap,
  40. .fb_ioctl = p9100_ioctl,
  41. #ifdef CONFIG_COMPAT
  42. .fb_compat_ioctl = sbusfb_compat_ioctl,
  43. #endif
  44. };
  45. /* P9100 control registers */
  46. #define P9100_SYSCTL_OFF 0x0UL
  47. #define P9100_VIDEOCTL_OFF 0x100UL
  48. #define P9100_VRAMCTL_OFF 0x180UL
  49. #define P9100_RAMDAC_OFF 0x200UL
  50. #define P9100_VIDEOCOPROC_OFF 0x400UL
  51. /* P9100 command registers */
  52. #define P9100_CMD_OFF 0x0UL
  53. /* P9100 framebuffer memory */
  54. #define P9100_FB_OFF 0x0UL
  55. /* 3 bits: 2=8bpp 3=16bpp 5=32bpp 7=24bpp */
  56. #define SYS_CONFIG_PIXELSIZE_SHIFT 26
  57. #define SCREENPAINT_TIMECTL1_ENABLE_VIDEO 0x20 /* 0 = off, 1 = on */
  58. struct p9100_regs {
  59. /* Registers for the system control */
  60. u32 sys_base;
  61. u32 sys_config;
  62. u32 sys_intr;
  63. u32 sys_int_ena;
  64. u32 sys_alt_rd;
  65. u32 sys_alt_wr;
  66. u32 sys_xxx[58];
  67. /* Registers for the video control */
  68. u32 vid_base;
  69. u32 vid_hcnt;
  70. u32 vid_htotal;
  71. u32 vid_hsync_rise;
  72. u32 vid_hblank_rise;
  73. u32 vid_hblank_fall;
  74. u32 vid_hcnt_preload;
  75. u32 vid_vcnt;
  76. u32 vid_vlen;
  77. u32 vid_vsync_rise;
  78. u32 vid_vblank_rise;
  79. u32 vid_vblank_fall;
  80. u32 vid_vcnt_preload;
  81. u32 vid_screenpaint_addr;
  82. u32 vid_screenpaint_timectl1;
  83. u32 vid_screenpaint_qsfcnt;
  84. u32 vid_screenpaint_timectl2;
  85. u32 vid_xxx[15];
  86. /* Registers for the video control */
  87. u32 vram_base;
  88. u32 vram_memcfg;
  89. u32 vram_refresh_pd;
  90. u32 vram_refresh_cnt;
  91. u32 vram_raslo_max;
  92. u32 vram_raslo_cur;
  93. u32 pwrup_cfg;
  94. u32 vram_xxx[25];
  95. /* Registers for IBM RGB528 Palette */
  96. u32 ramdac_cmap_wridx;
  97. u32 ramdac_palette_data;
  98. u32 ramdac_pixel_mask;
  99. u32 ramdac_palette_rdaddr;
  100. u32 ramdac_idx_lo;
  101. u32 ramdac_idx_hi;
  102. u32 ramdac_idx_data;
  103. u32 ramdac_idx_ctl;
  104. u32 ramdac_xxx[1784];
  105. };
  106. struct p9100_cmd_parameng {
  107. u32 parameng_status;
  108. u32 parameng_bltcmd;
  109. u32 parameng_quadcmd;
  110. };
  111. struct p9100_par {
  112. spinlock_t lock;
  113. struct p9100_regs __iomem *regs;
  114. u32 flags;
  115. #define P9100_FLAG_BLANKED 0x00000001
  116. unsigned long which_io;
  117. };
  118. /**
  119. * p9100_setcolreg - Optional function. Sets a color register.
  120. * @regno: boolean, 0 copy local, 1 get_user() function
  121. * @red: frame buffer colormap structure
  122. * @green: The green value which can be up to 16 bits wide
  123. * @blue: The blue value which can be up to 16 bits wide.
  124. * @transp: If supported the alpha value which can be up to 16 bits wide.
  125. * @info: frame buffer info structure
  126. */
  127. static int p9100_setcolreg(unsigned regno,
  128. unsigned red, unsigned green, unsigned blue,
  129. unsigned transp, struct fb_info *info)
  130. {
  131. struct p9100_par *par = (struct p9100_par *) info->par;
  132. struct p9100_regs __iomem *regs = par->regs;
  133. unsigned long flags;
  134. if (regno >= 256)
  135. return 1;
  136. red >>= 8;
  137. green >>= 8;
  138. blue >>= 8;
  139. spin_lock_irqsave(&par->lock, flags);
  140. sbus_writel((regno << 16), &regs->ramdac_cmap_wridx);
  141. sbus_writel((red << 16), &regs->ramdac_palette_data);
  142. sbus_writel((green << 16), &regs->ramdac_palette_data);
  143. sbus_writel((blue << 16), &regs->ramdac_palette_data);
  144. spin_unlock_irqrestore(&par->lock, flags);
  145. return 0;
  146. }
  147. /**
  148. * p9100_blank - Optional function. Blanks the display.
  149. * @blank_mode: the blank mode we want.
  150. * @info: frame buffer structure that represents a single frame buffer
  151. */
  152. static int
  153. p9100_blank(int blank, struct fb_info *info)
  154. {
  155. struct p9100_par *par = (struct p9100_par *) info->par;
  156. struct p9100_regs __iomem *regs = par->regs;
  157. unsigned long flags;
  158. u32 val;
  159. spin_lock_irqsave(&par->lock, flags);
  160. switch (blank) {
  161. case FB_BLANK_UNBLANK: /* Unblanking */
  162. val = sbus_readl(&regs->vid_screenpaint_timectl1);
  163. val |= SCREENPAINT_TIMECTL1_ENABLE_VIDEO;
  164. sbus_writel(val, &regs->vid_screenpaint_timectl1);
  165. par->flags &= ~P9100_FLAG_BLANKED;
  166. break;
  167. case FB_BLANK_NORMAL: /* Normal blanking */
  168. case FB_BLANK_VSYNC_SUSPEND: /* VESA blank (vsync off) */
  169. case FB_BLANK_HSYNC_SUSPEND: /* VESA blank (hsync off) */
  170. case FB_BLANK_POWERDOWN: /* Poweroff */
  171. val = sbus_readl(&regs->vid_screenpaint_timectl1);
  172. val &= ~SCREENPAINT_TIMECTL1_ENABLE_VIDEO;
  173. sbus_writel(val, &regs->vid_screenpaint_timectl1);
  174. par->flags |= P9100_FLAG_BLANKED;
  175. break;
  176. }
  177. spin_unlock_irqrestore(&par->lock, flags);
  178. return 0;
  179. }
  180. static struct sbus_mmap_map p9100_mmap_map[] = {
  181. { CG3_MMAP_OFFSET, 0, SBUS_MMAP_FBSIZE(1) },
  182. { 0, 0, 0 }
  183. };
  184. static int p9100_mmap(struct fb_info *info, struct vm_area_struct *vma)
  185. {
  186. struct p9100_par *par = (struct p9100_par *)info->par;
  187. return sbusfb_mmap_helper(p9100_mmap_map,
  188. info->fix.smem_start, info->fix.smem_len,
  189. par->which_io, vma);
  190. }
  191. static int p9100_ioctl(struct fb_info *info, unsigned int cmd,
  192. unsigned long arg)
  193. {
  194. /* Make it look like a cg3. */
  195. return sbusfb_ioctl_helper(cmd, arg, info,
  196. FBTYPE_SUN3COLOR, 8, info->fix.smem_len);
  197. }
  198. /*
  199. * Initialisation
  200. */
  201. static void p9100_init_fix(struct fb_info *info, int linebytes, struct device_node *dp)
  202. {
  203. snprintf(info->fix.id, sizeof(info->fix.id), "%pOFn", dp);
  204. info->fix.type = FB_TYPE_PACKED_PIXELS;
  205. info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
  206. info->fix.line_length = linebytes;
  207. info->fix.accel = FB_ACCEL_SUN_CGTHREE;
  208. }
  209. static int p9100_probe(struct platform_device *op)
  210. {
  211. struct device_node *dp = op->dev.of_node;
  212. struct fb_info *info;
  213. struct p9100_par *par;
  214. int linebytes, err;
  215. info = framebuffer_alloc(sizeof(struct p9100_par), &op->dev);
  216. err = -ENOMEM;
  217. if (!info)
  218. goto out_err;
  219. par = info->par;
  220. spin_lock_init(&par->lock);
  221. /* This is the framebuffer and the only resource apps can mmap. */
  222. info->fix.smem_start = op->resource[2].start;
  223. par->which_io = op->resource[2].flags & IORESOURCE_BITS;
  224. sbusfb_fill_var(&info->var, dp, 8);
  225. info->var.red.length = 8;
  226. info->var.green.length = 8;
  227. info->var.blue.length = 8;
  228. linebytes = of_getintprop_default(dp, "linebytes", info->var.xres);
  229. info->fix.smem_len = PAGE_ALIGN(linebytes * info->var.yres);
  230. par->regs = of_ioremap(&op->resource[0], 0,
  231. sizeof(struct p9100_regs), "p9100 regs");
  232. if (!par->regs)
  233. goto out_release_fb;
  234. info->flags = FBINFO_DEFAULT;
  235. info->fbops = &p9100_ops;
  236. info->screen_base = of_ioremap(&op->resource[2], 0,
  237. info->fix.smem_len, "p9100 ram");
  238. if (!info->screen_base)
  239. goto out_unmap_regs;
  240. p9100_blank(FB_BLANK_UNBLANK, info);
  241. if (fb_alloc_cmap(&info->cmap, 256, 0))
  242. goto out_unmap_screen;
  243. p9100_init_fix(info, linebytes, dp);
  244. err = register_framebuffer(info);
  245. if (err < 0)
  246. goto out_dealloc_cmap;
  247. fb_set_cmap(&info->cmap, info);
  248. dev_set_drvdata(&op->dev, info);
  249. printk(KERN_INFO "%pOF: p9100 at %lx:%lx\n",
  250. dp,
  251. par->which_io, info->fix.smem_start);
  252. return 0;
  253. out_dealloc_cmap:
  254. fb_dealloc_cmap(&info->cmap);
  255. out_unmap_screen:
  256. of_iounmap(&op->resource[2], info->screen_base, info->fix.smem_len);
  257. out_unmap_regs:
  258. of_iounmap(&op->resource[0], par->regs, sizeof(struct p9100_regs));
  259. out_release_fb:
  260. framebuffer_release(info);
  261. out_err:
  262. return err;
  263. }
  264. static int p9100_remove(struct platform_device *op)
  265. {
  266. struct fb_info *info = dev_get_drvdata(&op->dev);
  267. struct p9100_par *par = info->par;
  268. unregister_framebuffer(info);
  269. fb_dealloc_cmap(&info->cmap);
  270. of_iounmap(&op->resource[0], par->regs, sizeof(struct p9100_regs));
  271. of_iounmap(&op->resource[2], info->screen_base, info->fix.smem_len);
  272. framebuffer_release(info);
  273. return 0;
  274. }
  275. static const struct of_device_id p9100_match[] = {
  276. {
  277. .name = "p9100",
  278. },
  279. {},
  280. };
  281. MODULE_DEVICE_TABLE(of, p9100_match);
  282. static struct platform_driver p9100_driver = {
  283. .driver = {
  284. .name = "p9100",
  285. .of_match_table = p9100_match,
  286. },
  287. .probe = p9100_probe,
  288. .remove = p9100_remove,
  289. };
  290. static int __init p9100_init(void)
  291. {
  292. if (fb_get_options("p9100fb", NULL))
  293. return -ENODEV;
  294. return platform_driver_register(&p9100_driver);
  295. }
  296. static void __exit p9100_exit(void)
  297. {
  298. platform_driver_unregister(&p9100_driver);
  299. }
  300. module_init(p9100_init);
  301. module_exit(p9100_exit);
  302. MODULE_DESCRIPTION("framebuffer driver for P9100 chipsets");
  303. MODULE_AUTHOR("David S. Miller <davem@davemloft.net>");
  304. MODULE_VERSION("2.0");
  305. MODULE_LICENSE("GPL");