simplefb.c 5.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234
  1. /*
  2. * Simplest possible simple frame-buffer driver, as a platform device
  3. *
  4. * Copyright (c) 2013, Stephen Warren
  5. *
  6. * Based on q40fb.c, which was:
  7. * Copyright (C) 2001 Richard Zidlicky <rz@linux-m68k.org>
  8. *
  9. * Also based on offb.c, which was:
  10. * Copyright (C) 1997 Geert Uytterhoeven
  11. * Copyright (C) 1996 Paul Mackerras
  12. *
  13. * This program is free software; you can redistribute it and/or modify it
  14. * under the terms and conditions of the GNU General Public License,
  15. * version 2, as published by the Free Software Foundation.
  16. *
  17. * This program is distributed in the hope it will be useful, but WITHOUT
  18. * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  19. * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  20. * more details.
  21. */
  22. #include <linux/errno.h>
  23. #include <linux/fb.h>
  24. #include <linux/io.h>
  25. #include <linux/module.h>
  26. #include <linux/platform_device.h>
  27. static struct fb_fix_screeninfo simplefb_fix = {
  28. .id = "simple",
  29. .type = FB_TYPE_PACKED_PIXELS,
  30. .visual = FB_VISUAL_TRUECOLOR,
  31. .accel = FB_ACCEL_NONE,
  32. };
  33. static struct fb_var_screeninfo simplefb_var = {
  34. .height = -1,
  35. .width = -1,
  36. .activate = FB_ACTIVATE_NOW,
  37. .vmode = FB_VMODE_NONINTERLACED,
  38. };
  39. static int simplefb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
  40. u_int transp, struct fb_info *info)
  41. {
  42. u32 *pal = info->pseudo_palette;
  43. u32 cr = red >> (16 - info->var.red.length);
  44. u32 cg = green >> (16 - info->var.green.length);
  45. u32 cb = blue >> (16 - info->var.blue.length);
  46. u32 value;
  47. if (regno >= 16)
  48. return -EINVAL;
  49. value = (cr << info->var.red.offset) |
  50. (cg << info->var.green.offset) |
  51. (cb << info->var.blue.offset);
  52. if (info->var.transp.length > 0) {
  53. u32 mask = (1 << info->var.transp.length) - 1;
  54. mask <<= info->var.transp.offset;
  55. value |= mask;
  56. }
  57. pal[regno] = value;
  58. return 0;
  59. }
  60. static struct fb_ops simplefb_ops = {
  61. .owner = THIS_MODULE,
  62. .fb_setcolreg = simplefb_setcolreg,
  63. .fb_fillrect = cfb_fillrect,
  64. .fb_copyarea = cfb_copyarea,
  65. .fb_imageblit = cfb_imageblit,
  66. };
  67. struct simplefb_format {
  68. const char *name;
  69. u32 bits_per_pixel;
  70. struct fb_bitfield red;
  71. struct fb_bitfield green;
  72. struct fb_bitfield blue;
  73. struct fb_bitfield transp;
  74. };
  75. static struct simplefb_format simplefb_formats[] = {
  76. { "r5g6b5", 16, {11, 5}, {5, 6}, {0, 5}, {0, 0} },
  77. };
  78. struct simplefb_params {
  79. u32 width;
  80. u32 height;
  81. u32 stride;
  82. struct simplefb_format *format;
  83. };
  84. static int simplefb_parse_dt(struct platform_device *pdev,
  85. struct simplefb_params *params)
  86. {
  87. struct device_node *np = pdev->dev.of_node;
  88. int ret;
  89. const char *format;
  90. int i;
  91. ret = of_property_read_u32(np, "width", &params->width);
  92. if (ret) {
  93. dev_err(&pdev->dev, "Can't parse width property\n");
  94. return ret;
  95. }
  96. ret = of_property_read_u32(np, "height", &params->height);
  97. if (ret) {
  98. dev_err(&pdev->dev, "Can't parse height property\n");
  99. return ret;
  100. }
  101. ret = of_property_read_u32(np, "stride", &params->stride);
  102. if (ret) {
  103. dev_err(&pdev->dev, "Can't parse stride property\n");
  104. return ret;
  105. }
  106. ret = of_property_read_string(np, "format", &format);
  107. if (ret) {
  108. dev_err(&pdev->dev, "Can't parse format property\n");
  109. return ret;
  110. }
  111. params->format = NULL;
  112. for (i = 0; i < ARRAY_SIZE(simplefb_formats); i++) {
  113. if (strcmp(format, simplefb_formats[i].name))
  114. continue;
  115. params->format = &simplefb_formats[i];
  116. break;
  117. }
  118. if (!params->format) {
  119. dev_err(&pdev->dev, "Invalid format value\n");
  120. return -EINVAL;
  121. }
  122. return 0;
  123. }
  124. static int simplefb_probe(struct platform_device *pdev)
  125. {
  126. int ret;
  127. struct simplefb_params params;
  128. struct fb_info *info;
  129. struct resource *mem;
  130. if (fb_get_options("simplefb", NULL))
  131. return -ENODEV;
  132. ret = simplefb_parse_dt(pdev, &params);
  133. if (ret)
  134. return ret;
  135. mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  136. if (!mem) {
  137. dev_err(&pdev->dev, "No memory resource\n");
  138. return -EINVAL;
  139. }
  140. info = framebuffer_alloc(sizeof(u32) * 16, &pdev->dev);
  141. if (!info)
  142. return -ENOMEM;
  143. platform_set_drvdata(pdev, info);
  144. info->fix = simplefb_fix;
  145. info->fix.smem_start = mem->start;
  146. info->fix.smem_len = resource_size(mem);
  147. info->fix.line_length = params.stride;
  148. info->var = simplefb_var;
  149. info->var.xres = params.width;
  150. info->var.yres = params.height;
  151. info->var.xres_virtual = params.width;
  152. info->var.yres_virtual = params.height;
  153. info->var.bits_per_pixel = params.format->bits_per_pixel;
  154. info->var.red = params.format->red;
  155. info->var.green = params.format->green;
  156. info->var.blue = params.format->blue;
  157. info->var.transp = params.format->transp;
  158. info->fbops = &simplefb_ops;
  159. info->flags = FBINFO_DEFAULT;
  160. info->screen_base = devm_ioremap(&pdev->dev, info->fix.smem_start,
  161. info->fix.smem_len);
  162. if (!info->screen_base) {
  163. framebuffer_release(info);
  164. return -ENODEV;
  165. }
  166. info->pseudo_palette = (void *)(info + 1);
  167. ret = register_framebuffer(info);
  168. if (ret < 0) {
  169. dev_err(&pdev->dev, "Unable to register simplefb: %d\n", ret);
  170. framebuffer_release(info);
  171. return ret;
  172. }
  173. dev_info(&pdev->dev, "fb%d: simplefb registered!\n", info->node);
  174. return 0;
  175. }
  176. static int simplefb_remove(struct platform_device *pdev)
  177. {
  178. struct fb_info *info = platform_get_drvdata(pdev);
  179. unregister_framebuffer(info);
  180. framebuffer_release(info);
  181. return 0;
  182. }
  183. static const struct of_device_id simplefb_of_match[] = {
  184. { .compatible = "simple-framebuffer", },
  185. { },
  186. };
  187. MODULE_DEVICE_TABLE(of, simplefb_of_match);
  188. static struct platform_driver simplefb_driver = {
  189. .driver = {
  190. .name = "simple-framebuffer",
  191. .owner = THIS_MODULE,
  192. .of_match_table = simplefb_of_match,
  193. },
  194. .probe = simplefb_probe,
  195. .remove = simplefb_remove,
  196. };
  197. module_platform_driver(simplefb_driver);
  198. MODULE_AUTHOR("Stephen Warren <swarren@wwwdotorg.org>");
  199. MODULE_DESCRIPTION("Simple framebuffer driver");
  200. MODULE_LICENSE("GPL v2");