panel-kingdisplay-kd097d04.c 9.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (c) 2017, Fuzhou Rockchip Electronics Co., Ltd
  4. */
  5. #include <linux/delay.h>
  6. #include <linux/gpio/consumer.h>
  7. #include <linux/module.h>
  8. #include <linux/of.h>
  9. #include <linux/regulator/consumer.h>
  10. #include <video/mipi_display.h>
  11. #include <drm/drm_crtc.h>
  12. #include <drm/drm_device.h>
  13. #include <drm/drm_mipi_dsi.h>
  14. #include <drm/drm_modes.h>
  15. #include <drm/drm_panel.h>
  16. struct kingdisplay_panel {
  17. struct drm_panel base;
  18. struct mipi_dsi_device *link;
  19. struct regulator *supply;
  20. struct gpio_desc *enable_gpio;
  21. bool prepared;
  22. bool enabled;
  23. };
  24. struct kingdisplay_panel_cmd {
  25. char cmd;
  26. char data;
  27. };
  28. /*
  29. * According to the discussion on
  30. * https://review.coreboot.org/#/c/coreboot/+/22472/
  31. * the panel init array is not part of the panels datasheet but instead
  32. * just came in this form from the panel vendor.
  33. */
  34. static const struct kingdisplay_panel_cmd init_code[] = {
  35. /* voltage setting */
  36. { 0xB0, 0x00 },
  37. { 0xB2, 0x02 },
  38. { 0xB3, 0x11 },
  39. { 0xB4, 0x00 },
  40. { 0xB6, 0x80 },
  41. /* VCOM disable */
  42. { 0xB7, 0x02 },
  43. { 0xB8, 0x80 },
  44. { 0xBA, 0x43 },
  45. /* VCOM setting */
  46. { 0xBB, 0x53 },
  47. /* VSP setting */
  48. { 0xBC, 0x0A },
  49. /* VSN setting */
  50. { 0xBD, 0x4A },
  51. /* VGH setting */
  52. { 0xBE, 0x2F },
  53. /* VGL setting */
  54. { 0xBF, 0x1A },
  55. { 0xF0, 0x39 },
  56. { 0xF1, 0x22 },
  57. /* Gamma setting */
  58. { 0xB0, 0x02 },
  59. { 0xC0, 0x00 },
  60. { 0xC1, 0x01 },
  61. { 0xC2, 0x0B },
  62. { 0xC3, 0x15 },
  63. { 0xC4, 0x22 },
  64. { 0xC5, 0x11 },
  65. { 0xC6, 0x15 },
  66. { 0xC7, 0x19 },
  67. { 0xC8, 0x1A },
  68. { 0xC9, 0x16 },
  69. { 0xCA, 0x18 },
  70. { 0xCB, 0x13 },
  71. { 0xCC, 0x18 },
  72. { 0xCD, 0x13 },
  73. { 0xCE, 0x1C },
  74. { 0xCF, 0x19 },
  75. { 0xD0, 0x21 },
  76. { 0xD1, 0x2C },
  77. { 0xD2, 0x2F },
  78. { 0xD3, 0x30 },
  79. { 0xD4, 0x19 },
  80. { 0xD5, 0x1F },
  81. { 0xD6, 0x00 },
  82. { 0xD7, 0x01 },
  83. { 0xD8, 0x0B },
  84. { 0xD9, 0x15 },
  85. { 0xDA, 0x22 },
  86. { 0xDB, 0x11 },
  87. { 0xDC, 0x15 },
  88. { 0xDD, 0x19 },
  89. { 0xDE, 0x1A },
  90. { 0xDF, 0x16 },
  91. { 0xE0, 0x18 },
  92. { 0xE1, 0x13 },
  93. { 0xE2, 0x18 },
  94. { 0xE3, 0x13 },
  95. { 0xE4, 0x1C },
  96. { 0xE5, 0x19 },
  97. { 0xE6, 0x21 },
  98. { 0xE7, 0x2C },
  99. { 0xE8, 0x2F },
  100. { 0xE9, 0x30 },
  101. { 0xEA, 0x19 },
  102. { 0xEB, 0x1F },
  103. /* GOA MUX setting */
  104. { 0xB0, 0x01 },
  105. { 0xC0, 0x10 },
  106. { 0xC1, 0x0F },
  107. { 0xC2, 0x0E },
  108. { 0xC3, 0x0D },
  109. { 0xC4, 0x0C },
  110. { 0xC5, 0x0B },
  111. { 0xC6, 0x0A },
  112. { 0xC7, 0x09 },
  113. { 0xC8, 0x08 },
  114. { 0xC9, 0x07 },
  115. { 0xCA, 0x06 },
  116. { 0xCB, 0x05 },
  117. { 0xCC, 0x00 },
  118. { 0xCD, 0x01 },
  119. { 0xCE, 0x02 },
  120. { 0xCF, 0x03 },
  121. { 0xD0, 0x04 },
  122. { 0xD6, 0x10 },
  123. { 0xD7, 0x0F },
  124. { 0xD8, 0x0E },
  125. { 0xD9, 0x0D },
  126. { 0xDA, 0x0C },
  127. { 0xDB, 0x0B },
  128. { 0xDC, 0x0A },
  129. { 0xDD, 0x09 },
  130. { 0xDE, 0x08 },
  131. { 0xDF, 0x07 },
  132. { 0xE0, 0x06 },
  133. { 0xE1, 0x05 },
  134. { 0xE2, 0x00 },
  135. { 0xE3, 0x01 },
  136. { 0xE4, 0x02 },
  137. { 0xE5, 0x03 },
  138. { 0xE6, 0x04 },
  139. { 0xE7, 0x00 },
  140. { 0xEC, 0xC0 },
  141. /* GOA timing setting */
  142. { 0xB0, 0x03 },
  143. { 0xC0, 0x01 },
  144. { 0xC2, 0x6F },
  145. { 0xC3, 0x6F },
  146. { 0xC5, 0x36 },
  147. { 0xC8, 0x08 },
  148. { 0xC9, 0x04 },
  149. { 0xCA, 0x41 },
  150. { 0xCC, 0x43 },
  151. { 0xCF, 0x60 },
  152. { 0xD2, 0x04 },
  153. { 0xD3, 0x04 },
  154. { 0xD4, 0x03 },
  155. { 0xD5, 0x02 },
  156. { 0xD6, 0x01 },
  157. { 0xD7, 0x00 },
  158. { 0xDB, 0x01 },
  159. { 0xDE, 0x36 },
  160. { 0xE6, 0x6F },
  161. { 0xE7, 0x6F },
  162. /* GOE setting */
  163. { 0xB0, 0x06 },
  164. { 0xB8, 0xA5 },
  165. { 0xC0, 0xA5 },
  166. { 0xD5, 0x3F },
  167. };
  168. static inline
  169. struct kingdisplay_panel *to_kingdisplay_panel(struct drm_panel *panel)
  170. {
  171. return container_of(panel, struct kingdisplay_panel, base);
  172. }
  173. static int kingdisplay_panel_disable(struct drm_panel *panel)
  174. {
  175. struct kingdisplay_panel *kingdisplay = to_kingdisplay_panel(panel);
  176. int err;
  177. if (!kingdisplay->enabled)
  178. return 0;
  179. err = mipi_dsi_dcs_set_display_off(kingdisplay->link);
  180. if (err < 0)
  181. dev_err(panel->dev, "failed to set display off: %d\n", err);
  182. kingdisplay->enabled = false;
  183. return 0;
  184. }
  185. static int kingdisplay_panel_unprepare(struct drm_panel *panel)
  186. {
  187. struct kingdisplay_panel *kingdisplay = to_kingdisplay_panel(panel);
  188. int err;
  189. if (!kingdisplay->prepared)
  190. return 0;
  191. err = mipi_dsi_dcs_enter_sleep_mode(kingdisplay->link);
  192. if (err < 0) {
  193. dev_err(panel->dev, "failed to enter sleep mode: %d\n", err);
  194. return err;
  195. }
  196. /* T15: 120ms */
  197. msleep(120);
  198. gpiod_set_value_cansleep(kingdisplay->enable_gpio, 0);
  199. err = regulator_disable(kingdisplay->supply);
  200. if (err < 0)
  201. return err;
  202. kingdisplay->prepared = false;
  203. return 0;
  204. }
  205. static int kingdisplay_panel_prepare(struct drm_panel *panel)
  206. {
  207. struct kingdisplay_panel *kingdisplay = to_kingdisplay_panel(panel);
  208. int err, regulator_err;
  209. unsigned int i;
  210. if (kingdisplay->prepared)
  211. return 0;
  212. gpiod_set_value_cansleep(kingdisplay->enable_gpio, 0);
  213. err = regulator_enable(kingdisplay->supply);
  214. if (err < 0)
  215. return err;
  216. /* T2: 15ms */
  217. usleep_range(15000, 16000);
  218. gpiod_set_value_cansleep(kingdisplay->enable_gpio, 1);
  219. /* T4: 15ms */
  220. usleep_range(15000, 16000);
  221. for (i = 0; i < ARRAY_SIZE(init_code); i++) {
  222. err = mipi_dsi_generic_write(kingdisplay->link, &init_code[i],
  223. sizeof(struct kingdisplay_panel_cmd));
  224. if (err < 0) {
  225. dev_err(panel->dev, "failed write init cmds: %d\n", err);
  226. goto poweroff;
  227. }
  228. }
  229. err = mipi_dsi_dcs_exit_sleep_mode(kingdisplay->link);
  230. if (err < 0) {
  231. dev_err(panel->dev, "failed to exit sleep mode: %d\n", err);
  232. goto poweroff;
  233. }
  234. /* T6: 120ms */
  235. msleep(120);
  236. err = mipi_dsi_dcs_set_display_on(kingdisplay->link);
  237. if (err < 0) {
  238. dev_err(panel->dev, "failed to set display on: %d\n", err);
  239. goto poweroff;
  240. }
  241. /* T7: 10ms */
  242. usleep_range(10000, 11000);
  243. kingdisplay->prepared = true;
  244. return 0;
  245. poweroff:
  246. gpiod_set_value_cansleep(kingdisplay->enable_gpio, 0);
  247. regulator_err = regulator_disable(kingdisplay->supply);
  248. if (regulator_err)
  249. dev_err(panel->dev, "failed to disable regulator: %d\n", regulator_err);
  250. return err;
  251. }
  252. static int kingdisplay_panel_enable(struct drm_panel *panel)
  253. {
  254. struct kingdisplay_panel *kingdisplay = to_kingdisplay_panel(panel);
  255. if (kingdisplay->enabled)
  256. return 0;
  257. kingdisplay->enabled = true;
  258. return 0;
  259. }
  260. static const struct drm_display_mode default_mode = {
  261. .clock = 229000,
  262. .hdisplay = 1536,
  263. .hsync_start = 1536 + 100,
  264. .hsync_end = 1536 + 100 + 24,
  265. .htotal = 1536 + 100 + 24 + 100,
  266. .vdisplay = 2048,
  267. .vsync_start = 2048 + 95,
  268. .vsync_end = 2048 + 95 + 2,
  269. .vtotal = 2048 + 95 + 2 + 23,
  270. };
  271. static int kingdisplay_panel_get_modes(struct drm_panel *panel,
  272. struct drm_connector *connector)
  273. {
  274. struct drm_display_mode *mode;
  275. mode = drm_mode_duplicate(connector->dev, &default_mode);
  276. if (!mode) {
  277. dev_err(panel->dev, "failed to add mode %ux%u@%u\n",
  278. default_mode.hdisplay, default_mode.vdisplay,
  279. drm_mode_vrefresh(&default_mode));
  280. return -ENOMEM;
  281. }
  282. drm_mode_set_name(mode);
  283. drm_mode_probed_add(connector, mode);
  284. connector->display_info.width_mm = 147;
  285. connector->display_info.height_mm = 196;
  286. connector->display_info.bpc = 8;
  287. return 1;
  288. }
  289. static const struct drm_panel_funcs kingdisplay_panel_funcs = {
  290. .disable = kingdisplay_panel_disable,
  291. .unprepare = kingdisplay_panel_unprepare,
  292. .prepare = kingdisplay_panel_prepare,
  293. .enable = kingdisplay_panel_enable,
  294. .get_modes = kingdisplay_panel_get_modes,
  295. };
  296. static const struct of_device_id kingdisplay_of_match[] = {
  297. { .compatible = "kingdisplay,kd097d04", },
  298. { }
  299. };
  300. MODULE_DEVICE_TABLE(of, kingdisplay_of_match);
  301. static int kingdisplay_panel_add(struct kingdisplay_panel *kingdisplay)
  302. {
  303. struct device *dev = &kingdisplay->link->dev;
  304. int err;
  305. kingdisplay->supply = devm_regulator_get(dev, "power");
  306. if (IS_ERR(kingdisplay->supply))
  307. return PTR_ERR(kingdisplay->supply);
  308. kingdisplay->enable_gpio = devm_gpiod_get_optional(dev, "enable",
  309. GPIOD_OUT_HIGH);
  310. if (IS_ERR(kingdisplay->enable_gpio)) {
  311. err = PTR_ERR(kingdisplay->enable_gpio);
  312. dev_dbg(dev, "failed to get enable gpio: %d\n", err);
  313. kingdisplay->enable_gpio = NULL;
  314. }
  315. drm_panel_init(&kingdisplay->base, &kingdisplay->link->dev,
  316. &kingdisplay_panel_funcs, DRM_MODE_CONNECTOR_DSI);
  317. err = drm_panel_of_backlight(&kingdisplay->base);
  318. if (err)
  319. return err;
  320. drm_panel_add(&kingdisplay->base);
  321. return 0;
  322. }
  323. static void kingdisplay_panel_del(struct kingdisplay_panel *kingdisplay)
  324. {
  325. drm_panel_remove(&kingdisplay->base);
  326. }
  327. static int kingdisplay_panel_probe(struct mipi_dsi_device *dsi)
  328. {
  329. struct kingdisplay_panel *kingdisplay;
  330. int err;
  331. dsi->lanes = 4;
  332. dsi->format = MIPI_DSI_FMT_RGB888;
  333. dsi->mode_flags = MIPI_DSI_MODE_VIDEO | MIPI_DSI_MODE_VIDEO_BURST |
  334. MIPI_DSI_MODE_LPM;
  335. kingdisplay = devm_kzalloc(&dsi->dev, sizeof(*kingdisplay), GFP_KERNEL);
  336. if (!kingdisplay)
  337. return -ENOMEM;
  338. mipi_dsi_set_drvdata(dsi, kingdisplay);
  339. kingdisplay->link = dsi;
  340. err = kingdisplay_panel_add(kingdisplay);
  341. if (err < 0)
  342. return err;
  343. err = mipi_dsi_attach(dsi);
  344. if (err < 0) {
  345. kingdisplay_panel_del(kingdisplay);
  346. return err;
  347. }
  348. return 0;
  349. }
  350. static int kingdisplay_panel_remove(struct mipi_dsi_device *dsi)
  351. {
  352. struct kingdisplay_panel *kingdisplay = mipi_dsi_get_drvdata(dsi);
  353. int err;
  354. err = drm_panel_unprepare(&kingdisplay->base);
  355. if (err < 0)
  356. dev_err(&dsi->dev, "failed to unprepare panel: %d\n", err);
  357. err = drm_panel_disable(&kingdisplay->base);
  358. if (err < 0)
  359. dev_err(&dsi->dev, "failed to disable panel: %d\n", err);
  360. err = mipi_dsi_detach(dsi);
  361. if (err < 0)
  362. dev_err(&dsi->dev, "failed to detach from DSI host: %d\n", err);
  363. kingdisplay_panel_del(kingdisplay);
  364. return 0;
  365. }
  366. static void kingdisplay_panel_shutdown(struct mipi_dsi_device *dsi)
  367. {
  368. struct kingdisplay_panel *kingdisplay = mipi_dsi_get_drvdata(dsi);
  369. drm_panel_unprepare(&kingdisplay->base);
  370. drm_panel_disable(&kingdisplay->base);
  371. }
  372. static struct mipi_dsi_driver kingdisplay_panel_driver = {
  373. .driver = {
  374. .name = "panel-kingdisplay-kd097d04",
  375. .of_match_table = kingdisplay_of_match,
  376. },
  377. .probe = kingdisplay_panel_probe,
  378. .remove = kingdisplay_panel_remove,
  379. .shutdown = kingdisplay_panel_shutdown,
  380. };
  381. module_mipi_dsi_driver(kingdisplay_panel_driver);
  382. MODULE_AUTHOR("Chris Zhong <zyw@rock-chips.com>");
  383. MODULE_AUTHOR("Nickey Yang <nickey.yang@rock-chips.com>");
  384. MODULE_DESCRIPTION("kingdisplay KD097D04 panel driver");
  385. MODULE_LICENSE("GPL v2");