panel-seiko-43wvf1g.c 7.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright (C) 2017 NXP Semiconductors.
  4. * Author: Marco Franchi <marco.franchi@nxp.com>
  5. *
  6. * Based on Panel Simple driver by Thierry Reding <treding@nvidia.com>
  7. */
  8. #include <linux/delay.h>
  9. #include <linux/module.h>
  10. #include <linux/of.h>
  11. #include <linux/platform_device.h>
  12. #include <linux/regulator/consumer.h>
  13. #include <video/display_timing.h>
  14. #include <video/videomode.h>
  15. #include <drm/drm_crtc.h>
  16. #include <drm/drm_device.h>
  17. #include <drm/drm_panel.h>
  18. struct seiko_panel_desc {
  19. const struct drm_display_mode *modes;
  20. unsigned int num_modes;
  21. const struct display_timing *timings;
  22. unsigned int num_timings;
  23. unsigned int bpc;
  24. /**
  25. * @width: width (in millimeters) of the panel's active display area
  26. * @height: height (in millimeters) of the panel's active display area
  27. */
  28. struct {
  29. unsigned int width;
  30. unsigned int height;
  31. } size;
  32. u32 bus_format;
  33. u32 bus_flags;
  34. };
  35. struct seiko_panel {
  36. struct drm_panel base;
  37. bool prepared;
  38. bool enabled;
  39. const struct seiko_panel_desc *desc;
  40. struct regulator *dvdd;
  41. struct regulator *avdd;
  42. };
  43. static inline struct seiko_panel *to_seiko_panel(struct drm_panel *panel)
  44. {
  45. return container_of(panel, struct seiko_panel, base);
  46. }
  47. static int seiko_panel_get_fixed_modes(struct seiko_panel *panel,
  48. struct drm_connector *connector)
  49. {
  50. struct drm_display_mode *mode;
  51. unsigned int i, num = 0;
  52. if (!panel->desc)
  53. return 0;
  54. for (i = 0; i < panel->desc->num_timings; i++) {
  55. const struct display_timing *dt = &panel->desc->timings[i];
  56. struct videomode vm;
  57. videomode_from_timing(dt, &vm);
  58. mode = drm_mode_create(connector->dev);
  59. if (!mode) {
  60. dev_err(panel->base.dev, "failed to add mode %ux%u\n",
  61. dt->hactive.typ, dt->vactive.typ);
  62. continue;
  63. }
  64. drm_display_mode_from_videomode(&vm, mode);
  65. mode->type |= DRM_MODE_TYPE_DRIVER;
  66. if (panel->desc->num_timings == 1)
  67. mode->type |= DRM_MODE_TYPE_PREFERRED;
  68. drm_mode_probed_add(connector, mode);
  69. num++;
  70. }
  71. for (i = 0; i < panel->desc->num_modes; i++) {
  72. const struct drm_display_mode *m = &panel->desc->modes[i];
  73. mode = drm_mode_duplicate(connector->dev, m);
  74. if (!mode) {
  75. dev_err(panel->base.dev, "failed to add mode %ux%u@%u\n",
  76. m->hdisplay, m->vdisplay,
  77. drm_mode_vrefresh(m));
  78. continue;
  79. }
  80. mode->type |= DRM_MODE_TYPE_DRIVER;
  81. if (panel->desc->num_modes == 1)
  82. mode->type |= DRM_MODE_TYPE_PREFERRED;
  83. drm_mode_set_name(mode);
  84. drm_mode_probed_add(connector, mode);
  85. num++;
  86. }
  87. connector->display_info.bpc = panel->desc->bpc;
  88. connector->display_info.width_mm = panel->desc->size.width;
  89. connector->display_info.height_mm = panel->desc->size.height;
  90. if (panel->desc->bus_format)
  91. drm_display_info_set_bus_formats(&connector->display_info,
  92. &panel->desc->bus_format, 1);
  93. connector->display_info.bus_flags = panel->desc->bus_flags;
  94. return num;
  95. }
  96. static int seiko_panel_disable(struct drm_panel *panel)
  97. {
  98. struct seiko_panel *p = to_seiko_panel(panel);
  99. if (!p->enabled)
  100. return 0;
  101. p->enabled = false;
  102. return 0;
  103. }
  104. static int seiko_panel_unprepare(struct drm_panel *panel)
  105. {
  106. struct seiko_panel *p = to_seiko_panel(panel);
  107. if (!p->prepared)
  108. return 0;
  109. regulator_disable(p->avdd);
  110. /* Add a 100ms delay as per the panel datasheet */
  111. msleep(100);
  112. regulator_disable(p->dvdd);
  113. p->prepared = false;
  114. return 0;
  115. }
  116. static int seiko_panel_prepare(struct drm_panel *panel)
  117. {
  118. struct seiko_panel *p = to_seiko_panel(panel);
  119. int err;
  120. if (p->prepared)
  121. return 0;
  122. err = regulator_enable(p->dvdd);
  123. if (err < 0) {
  124. dev_err(panel->dev, "failed to enable dvdd: %d\n", err);
  125. return err;
  126. }
  127. /* Add a 100ms delay as per the panel datasheet */
  128. msleep(100);
  129. err = regulator_enable(p->avdd);
  130. if (err < 0) {
  131. dev_err(panel->dev, "failed to enable avdd: %d\n", err);
  132. goto disable_dvdd;
  133. }
  134. p->prepared = true;
  135. return 0;
  136. disable_dvdd:
  137. regulator_disable(p->dvdd);
  138. return err;
  139. }
  140. static int seiko_panel_enable(struct drm_panel *panel)
  141. {
  142. struct seiko_panel *p = to_seiko_panel(panel);
  143. if (p->enabled)
  144. return 0;
  145. p->enabled = true;
  146. return 0;
  147. }
  148. static int seiko_panel_get_modes(struct drm_panel *panel,
  149. struct drm_connector *connector)
  150. {
  151. struct seiko_panel *p = to_seiko_panel(panel);
  152. /* add hard-coded panel modes */
  153. return seiko_panel_get_fixed_modes(p, connector);
  154. }
  155. static int seiko_panel_get_timings(struct drm_panel *panel,
  156. unsigned int num_timings,
  157. struct display_timing *timings)
  158. {
  159. struct seiko_panel *p = to_seiko_panel(panel);
  160. unsigned int i;
  161. if (p->desc->num_timings < num_timings)
  162. num_timings = p->desc->num_timings;
  163. if (timings)
  164. for (i = 0; i < num_timings; i++)
  165. timings[i] = p->desc->timings[i];
  166. return p->desc->num_timings;
  167. }
  168. static const struct drm_panel_funcs seiko_panel_funcs = {
  169. .disable = seiko_panel_disable,
  170. .unprepare = seiko_panel_unprepare,
  171. .prepare = seiko_panel_prepare,
  172. .enable = seiko_panel_enable,
  173. .get_modes = seiko_panel_get_modes,
  174. .get_timings = seiko_panel_get_timings,
  175. };
  176. static int seiko_panel_probe(struct device *dev,
  177. const struct seiko_panel_desc *desc)
  178. {
  179. struct seiko_panel *panel;
  180. int err;
  181. panel = devm_kzalloc(dev, sizeof(*panel), GFP_KERNEL);
  182. if (!panel)
  183. return -ENOMEM;
  184. panel->enabled = false;
  185. panel->prepared = false;
  186. panel->desc = desc;
  187. panel->dvdd = devm_regulator_get(dev, "dvdd");
  188. if (IS_ERR(panel->dvdd))
  189. return PTR_ERR(panel->dvdd);
  190. panel->avdd = devm_regulator_get(dev, "avdd");
  191. if (IS_ERR(panel->avdd))
  192. return PTR_ERR(panel->avdd);
  193. drm_panel_init(&panel->base, dev, &seiko_panel_funcs,
  194. DRM_MODE_CONNECTOR_DPI);
  195. err = drm_panel_of_backlight(&panel->base);
  196. if (err)
  197. return err;
  198. drm_panel_add(&panel->base);
  199. dev_set_drvdata(dev, panel);
  200. return 0;
  201. }
  202. static int seiko_panel_remove(struct platform_device *pdev)
  203. {
  204. struct seiko_panel *panel = dev_get_drvdata(&pdev->dev);
  205. drm_panel_remove(&panel->base);
  206. drm_panel_disable(&panel->base);
  207. return 0;
  208. }
  209. static void seiko_panel_shutdown(struct platform_device *pdev)
  210. {
  211. struct seiko_panel *panel = dev_get_drvdata(&pdev->dev);
  212. drm_panel_disable(&panel->base);
  213. }
  214. static const struct display_timing seiko_43wvf1g_timing = {
  215. .pixelclock = { 33500000, 33500000, 33500000 },
  216. .hactive = { 800, 800, 800 },
  217. .hfront_porch = { 164, 164, 164 },
  218. .hback_porch = { 89, 89, 89 },
  219. .hsync_len = { 10, 10, 10 },
  220. .vactive = { 480, 480, 480 },
  221. .vfront_porch = { 10, 10, 10 },
  222. .vback_porch = { 23, 23, 23 },
  223. .vsync_len = { 10, 10, 10 },
  224. .flags = DISPLAY_FLAGS_DE_LOW,
  225. };
  226. static const struct seiko_panel_desc seiko_43wvf1g = {
  227. .timings = &seiko_43wvf1g_timing,
  228. .num_timings = 1,
  229. .bpc = 8,
  230. .size = {
  231. .width = 93,
  232. .height = 57,
  233. },
  234. .bus_format = MEDIA_BUS_FMT_RGB888_1X24,
  235. .bus_flags = DRM_BUS_FLAG_DE_HIGH | DRM_BUS_FLAG_PIXDATA_DRIVE_NEGEDGE,
  236. };
  237. static const struct of_device_id platform_of_match[] = {
  238. {
  239. .compatible = "sii,43wvf1g",
  240. .data = &seiko_43wvf1g,
  241. }, {
  242. /* sentinel */
  243. }
  244. };
  245. MODULE_DEVICE_TABLE(of, platform_of_match);
  246. static int seiko_panel_platform_probe(struct platform_device *pdev)
  247. {
  248. const struct of_device_id *id;
  249. id = of_match_node(platform_of_match, pdev->dev.of_node);
  250. if (!id)
  251. return -ENODEV;
  252. return seiko_panel_probe(&pdev->dev, id->data);
  253. }
  254. static struct platform_driver seiko_panel_platform_driver = {
  255. .driver = {
  256. .name = "seiko_panel",
  257. .of_match_table = platform_of_match,
  258. },
  259. .probe = seiko_panel_platform_probe,
  260. .remove = seiko_panel_remove,
  261. .shutdown = seiko_panel_shutdown,
  262. };
  263. module_platform_driver(seiko_panel_platform_driver);
  264. MODULE_AUTHOR("Marco Franchi <marco.franchi@nxp.com>");
  265. MODULE_DESCRIPTION("Seiko 43WVF1G panel driver");
  266. MODULE_LICENSE("GPL v2");