panel-sharp-ls043t1le01.c 7.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (C) 2015 Red Hat
  4. * Copyright (C) 2015 Sony Mobile Communications Inc.
  5. * Author: Werner Johansson <werner.johansson@sonymobile.com>
  6. *
  7. * Based on AUO panel driver by Rob Clark <robdclark@gmail.com>
  8. */
  9. #include <linux/delay.h>
  10. #include <linux/gpio/consumer.h>
  11. #include <linux/module.h>
  12. #include <linux/of.h>
  13. #include <linux/regulator/consumer.h>
  14. #include <video/mipi_display.h>
  15. #include <drm/drm_crtc.h>
  16. #include <drm/drm_device.h>
  17. #include <drm/drm_mipi_dsi.h>
  18. #include <drm/drm_panel.h>
  19. struct sharp_nt_panel {
  20. struct drm_panel base;
  21. struct mipi_dsi_device *dsi;
  22. struct regulator *supply;
  23. struct gpio_desc *reset_gpio;
  24. bool prepared;
  25. bool enabled;
  26. const struct drm_display_mode *mode;
  27. };
  28. static inline struct sharp_nt_panel *to_sharp_nt_panel(struct drm_panel *panel)
  29. {
  30. return container_of(panel, struct sharp_nt_panel, base);
  31. }
  32. static int sharp_nt_panel_init(struct sharp_nt_panel *sharp_nt)
  33. {
  34. struct mipi_dsi_device *dsi = sharp_nt->dsi;
  35. int ret;
  36. dsi->mode_flags |= MIPI_DSI_MODE_LPM;
  37. ret = mipi_dsi_dcs_exit_sleep_mode(dsi);
  38. if (ret < 0)
  39. return ret;
  40. msleep(120);
  41. /* Novatek two-lane operation */
  42. ret = mipi_dsi_dcs_write(dsi, 0xae, (u8[]){ 0x03 }, 1);
  43. if (ret < 0)
  44. return ret;
  45. /* Set both MCU and RGB I/F to 24bpp */
  46. ret = mipi_dsi_dcs_set_pixel_format(dsi, MIPI_DCS_PIXEL_FMT_24BIT |
  47. (MIPI_DCS_PIXEL_FMT_24BIT << 4));
  48. if (ret < 0)
  49. return ret;
  50. return 0;
  51. }
  52. static int sharp_nt_panel_on(struct sharp_nt_panel *sharp_nt)
  53. {
  54. struct mipi_dsi_device *dsi = sharp_nt->dsi;
  55. int ret;
  56. dsi->mode_flags |= MIPI_DSI_MODE_LPM;
  57. ret = mipi_dsi_dcs_set_display_on(dsi);
  58. if (ret < 0)
  59. return ret;
  60. return 0;
  61. }
  62. static int sharp_nt_panel_off(struct sharp_nt_panel *sharp_nt)
  63. {
  64. struct mipi_dsi_device *dsi = sharp_nt->dsi;
  65. int ret;
  66. dsi->mode_flags &= ~MIPI_DSI_MODE_LPM;
  67. ret = mipi_dsi_dcs_set_display_off(dsi);
  68. if (ret < 0)
  69. return ret;
  70. ret = mipi_dsi_dcs_enter_sleep_mode(dsi);
  71. if (ret < 0)
  72. return ret;
  73. return 0;
  74. }
  75. static int sharp_nt_panel_disable(struct drm_panel *panel)
  76. {
  77. struct sharp_nt_panel *sharp_nt = to_sharp_nt_panel(panel);
  78. if (!sharp_nt->enabled)
  79. return 0;
  80. sharp_nt->enabled = false;
  81. return 0;
  82. }
  83. static int sharp_nt_panel_unprepare(struct drm_panel *panel)
  84. {
  85. struct sharp_nt_panel *sharp_nt = to_sharp_nt_panel(panel);
  86. int ret;
  87. if (!sharp_nt->prepared)
  88. return 0;
  89. ret = sharp_nt_panel_off(sharp_nt);
  90. if (ret < 0) {
  91. dev_err(panel->dev, "failed to set panel off: %d\n", ret);
  92. return ret;
  93. }
  94. regulator_disable(sharp_nt->supply);
  95. if (sharp_nt->reset_gpio)
  96. gpiod_set_value(sharp_nt->reset_gpio, 0);
  97. sharp_nt->prepared = false;
  98. return 0;
  99. }
  100. static int sharp_nt_panel_prepare(struct drm_panel *panel)
  101. {
  102. struct sharp_nt_panel *sharp_nt = to_sharp_nt_panel(panel);
  103. int ret;
  104. if (sharp_nt->prepared)
  105. return 0;
  106. ret = regulator_enable(sharp_nt->supply);
  107. if (ret < 0)
  108. return ret;
  109. msleep(20);
  110. if (sharp_nt->reset_gpio) {
  111. gpiod_set_value(sharp_nt->reset_gpio, 1);
  112. msleep(1);
  113. gpiod_set_value(sharp_nt->reset_gpio, 0);
  114. msleep(1);
  115. gpiod_set_value(sharp_nt->reset_gpio, 1);
  116. msleep(10);
  117. }
  118. ret = sharp_nt_panel_init(sharp_nt);
  119. if (ret < 0) {
  120. dev_err(panel->dev, "failed to init panel: %d\n", ret);
  121. goto poweroff;
  122. }
  123. ret = sharp_nt_panel_on(sharp_nt);
  124. if (ret < 0) {
  125. dev_err(panel->dev, "failed to set panel on: %d\n", ret);
  126. goto poweroff;
  127. }
  128. sharp_nt->prepared = true;
  129. return 0;
  130. poweroff:
  131. regulator_disable(sharp_nt->supply);
  132. if (sharp_nt->reset_gpio)
  133. gpiod_set_value(sharp_nt->reset_gpio, 0);
  134. return ret;
  135. }
  136. static int sharp_nt_panel_enable(struct drm_panel *panel)
  137. {
  138. struct sharp_nt_panel *sharp_nt = to_sharp_nt_panel(panel);
  139. if (sharp_nt->enabled)
  140. return 0;
  141. sharp_nt->enabled = true;
  142. return 0;
  143. }
  144. static const struct drm_display_mode default_mode = {
  145. .clock = 41118,
  146. .hdisplay = 540,
  147. .hsync_start = 540 + 48,
  148. .hsync_end = 540 + 48 + 80,
  149. .htotal = 540 + 48 + 80 + 32,
  150. .vdisplay = 960,
  151. .vsync_start = 960 + 3,
  152. .vsync_end = 960 + 3 + 15,
  153. .vtotal = 960 + 3 + 15 + 1,
  154. };
  155. static int sharp_nt_panel_get_modes(struct drm_panel *panel,
  156. struct drm_connector *connector)
  157. {
  158. struct drm_display_mode *mode;
  159. mode = drm_mode_duplicate(connector->dev, &default_mode);
  160. if (!mode) {
  161. dev_err(panel->dev, "failed to add mode %ux%u@%u\n",
  162. default_mode.hdisplay, default_mode.vdisplay,
  163. drm_mode_vrefresh(&default_mode));
  164. return -ENOMEM;
  165. }
  166. drm_mode_set_name(mode);
  167. drm_mode_probed_add(connector, mode);
  168. connector->display_info.width_mm = 54;
  169. connector->display_info.height_mm = 95;
  170. return 1;
  171. }
  172. static const struct drm_panel_funcs sharp_nt_panel_funcs = {
  173. .disable = sharp_nt_panel_disable,
  174. .unprepare = sharp_nt_panel_unprepare,
  175. .prepare = sharp_nt_panel_prepare,
  176. .enable = sharp_nt_panel_enable,
  177. .get_modes = sharp_nt_panel_get_modes,
  178. };
  179. static int sharp_nt_panel_add(struct sharp_nt_panel *sharp_nt)
  180. {
  181. struct device *dev = &sharp_nt->dsi->dev;
  182. int ret;
  183. sharp_nt->mode = &default_mode;
  184. sharp_nt->supply = devm_regulator_get(dev, "avdd");
  185. if (IS_ERR(sharp_nt->supply))
  186. return PTR_ERR(sharp_nt->supply);
  187. sharp_nt->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_LOW);
  188. if (IS_ERR(sharp_nt->reset_gpio)) {
  189. dev_err(dev, "cannot get reset-gpios %ld\n",
  190. PTR_ERR(sharp_nt->reset_gpio));
  191. sharp_nt->reset_gpio = NULL;
  192. } else {
  193. gpiod_set_value(sharp_nt->reset_gpio, 0);
  194. }
  195. drm_panel_init(&sharp_nt->base, &sharp_nt->dsi->dev,
  196. &sharp_nt_panel_funcs, DRM_MODE_CONNECTOR_DSI);
  197. ret = drm_panel_of_backlight(&sharp_nt->base);
  198. if (ret)
  199. return ret;
  200. drm_panel_add(&sharp_nt->base);
  201. return 0;
  202. }
  203. static void sharp_nt_panel_del(struct sharp_nt_panel *sharp_nt)
  204. {
  205. if (sharp_nt->base.dev)
  206. drm_panel_remove(&sharp_nt->base);
  207. }
  208. static int sharp_nt_panel_probe(struct mipi_dsi_device *dsi)
  209. {
  210. struct sharp_nt_panel *sharp_nt;
  211. int ret;
  212. dsi->lanes = 2;
  213. dsi->format = MIPI_DSI_FMT_RGB888;
  214. dsi->mode_flags = MIPI_DSI_MODE_VIDEO |
  215. MIPI_DSI_MODE_VIDEO_HSE |
  216. MIPI_DSI_CLOCK_NON_CONTINUOUS |
  217. MIPI_DSI_MODE_EOT_PACKET;
  218. sharp_nt = devm_kzalloc(&dsi->dev, sizeof(*sharp_nt), GFP_KERNEL);
  219. if (!sharp_nt)
  220. return -ENOMEM;
  221. mipi_dsi_set_drvdata(dsi, sharp_nt);
  222. sharp_nt->dsi = dsi;
  223. ret = sharp_nt_panel_add(sharp_nt);
  224. if (ret < 0)
  225. return ret;
  226. return mipi_dsi_attach(dsi);
  227. }
  228. static int sharp_nt_panel_remove(struct mipi_dsi_device *dsi)
  229. {
  230. struct sharp_nt_panel *sharp_nt = mipi_dsi_get_drvdata(dsi);
  231. int ret;
  232. ret = drm_panel_disable(&sharp_nt->base);
  233. if (ret < 0)
  234. dev_err(&dsi->dev, "failed to disable panel: %d\n", ret);
  235. ret = mipi_dsi_detach(dsi);
  236. if (ret < 0)
  237. dev_err(&dsi->dev, "failed to detach from DSI host: %d\n", ret);
  238. sharp_nt_panel_del(sharp_nt);
  239. return 0;
  240. }
  241. static void sharp_nt_panel_shutdown(struct mipi_dsi_device *dsi)
  242. {
  243. struct sharp_nt_panel *sharp_nt = mipi_dsi_get_drvdata(dsi);
  244. drm_panel_disable(&sharp_nt->base);
  245. }
  246. static const struct of_device_id sharp_nt_of_match[] = {
  247. { .compatible = "sharp,ls043t1le01-qhd", },
  248. { }
  249. };
  250. MODULE_DEVICE_TABLE(of, sharp_nt_of_match);
  251. static struct mipi_dsi_driver sharp_nt_panel_driver = {
  252. .driver = {
  253. .name = "panel-sharp-ls043t1le01-qhd",
  254. .of_match_table = sharp_nt_of_match,
  255. },
  256. .probe = sharp_nt_panel_probe,
  257. .remove = sharp_nt_panel_remove,
  258. .shutdown = sharp_nt_panel_shutdown,
  259. };
  260. module_mipi_dsi_driver(sharp_nt_panel_driver);
  261. MODULE_AUTHOR("Werner Johansson <werner.johansson@sonymobile.com>");
  262. MODULE_DESCRIPTION("Sharp LS043T1LE01 NT35565-based qHD (540x960) video mode panel driver");
  263. MODULE_LICENSE("GPL v2");