exynos_mipi_dsi.c 7.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (C) 2012 Samsung Electronics
  4. *
  5. * Author: InKi Dae <inki.dae@samsung.com>
  6. * Author: Donghwa Lee <dh09.lee@samsung.com>
  7. */
  8. #include <common.h>
  9. #include <log.h>
  10. #include <malloc.h>
  11. #include <fdtdec.h>
  12. #include <dm/devres.h>
  13. #include <linux/libfdt.h>
  14. #include <linux/compat.h>
  15. #include <linux/err.h>
  16. #include <asm/arch/dsim.h>
  17. #include <asm/arch/mipi_dsim.h>
  18. #include <asm/arch/power.h>
  19. #include <asm/arch/cpu.h>
  20. #include <asm/arch/clk.h>
  21. #include "exynos_mipi_dsi_lowlevel.h"
  22. #include "exynos_mipi_dsi_common.h"
  23. #define master_to_driver(a) (a->dsim_lcd_drv)
  24. #define master_to_device(a) (a->dsim_lcd_dev)
  25. DECLARE_GLOBAL_DATA_PTR;
  26. struct mipi_dsim_ddi {
  27. int bus_id;
  28. struct list_head list;
  29. struct mipi_dsim_lcd_device *dsim_lcd_dev;
  30. struct mipi_dsim_lcd_driver *dsim_lcd_drv;
  31. };
  32. static LIST_HEAD(dsim_ddi_list);
  33. static LIST_HEAD(dsim_lcd_dev_list);
  34. int exynos_mipi_dsi_register_lcd_device(struct mipi_dsim_lcd_device *lcd_dev)
  35. {
  36. struct mipi_dsim_ddi *dsim_ddi;
  37. if (!lcd_dev) {
  38. debug("mipi_dsim_lcd_device is NULL.\n");
  39. return -EFAULT;
  40. }
  41. if (!lcd_dev->name) {
  42. debug("dsim_lcd_device name is NULL.\n");
  43. return -EFAULT;
  44. }
  45. dsim_ddi = kzalloc(sizeof(struct mipi_dsim_ddi), GFP_KERNEL);
  46. if (!dsim_ddi) {
  47. debug("failed to allocate dsim_ddi object.\n");
  48. return -EFAULT;
  49. }
  50. dsim_ddi->dsim_lcd_dev = lcd_dev;
  51. list_add_tail(&dsim_ddi->list, &dsim_ddi_list);
  52. return 0;
  53. }
  54. struct mipi_dsim_ddi
  55. *exynos_mipi_dsi_find_lcd_device(struct mipi_dsim_lcd_driver *lcd_drv)
  56. {
  57. struct mipi_dsim_ddi *dsim_ddi;
  58. struct mipi_dsim_lcd_device *lcd_dev;
  59. list_for_each_entry(dsim_ddi, &dsim_ddi_list, list) {
  60. lcd_dev = dsim_ddi->dsim_lcd_dev;
  61. if (!lcd_dev)
  62. continue;
  63. if (lcd_drv->id >= 0) {
  64. if ((strcmp(lcd_drv->name, lcd_dev->name)) == 0 &&
  65. lcd_drv->id == lcd_dev->id) {
  66. /**
  67. * bus_id would be used to identify
  68. * connected bus.
  69. */
  70. dsim_ddi->bus_id = lcd_dev->bus_id;
  71. return dsim_ddi;
  72. }
  73. } else {
  74. if ((strcmp(lcd_drv->name, lcd_dev->name)) == 0) {
  75. /**
  76. * bus_id would be used to identify
  77. * connected bus.
  78. */
  79. dsim_ddi->bus_id = lcd_dev->bus_id;
  80. return dsim_ddi;
  81. }
  82. }
  83. kfree(dsim_ddi);
  84. list_del(&dsim_ddi_list);
  85. }
  86. return NULL;
  87. }
  88. int exynos_mipi_dsi_register_lcd_driver(struct mipi_dsim_lcd_driver *lcd_drv)
  89. {
  90. struct mipi_dsim_ddi *dsim_ddi;
  91. if (!lcd_drv) {
  92. debug("mipi_dsim_lcd_driver is NULL.\n");
  93. return -EFAULT;
  94. }
  95. if (!lcd_drv->name) {
  96. debug("dsim_lcd_driver name is NULL.\n");
  97. return -EFAULT;
  98. }
  99. dsim_ddi = exynos_mipi_dsi_find_lcd_device(lcd_drv);
  100. if (!dsim_ddi) {
  101. debug("mipi_dsim_ddi object not found.\n");
  102. return -EFAULT;
  103. }
  104. dsim_ddi->dsim_lcd_drv = lcd_drv;
  105. debug("registered panel driver(%s) to mipi-dsi driver.\n",
  106. lcd_drv->name);
  107. return 0;
  108. }
  109. struct mipi_dsim_ddi
  110. *exynos_mipi_dsi_bind_lcd_ddi(struct mipi_dsim_device *dsim,
  111. const char *name)
  112. {
  113. struct mipi_dsim_ddi *dsim_ddi;
  114. struct mipi_dsim_lcd_driver *lcd_drv;
  115. struct mipi_dsim_lcd_device *lcd_dev;
  116. list_for_each_entry(dsim_ddi, &dsim_ddi_list, list) {
  117. lcd_drv = dsim_ddi->dsim_lcd_drv;
  118. lcd_dev = dsim_ddi->dsim_lcd_dev;
  119. if (!lcd_drv || !lcd_dev)
  120. continue;
  121. debug("lcd_drv->id = %d, lcd_dev->id = %d\n",
  122. lcd_drv->id, lcd_dev->id);
  123. if ((strcmp(lcd_drv->name, name) == 0)) {
  124. lcd_dev->master = dsim;
  125. dsim->dsim_lcd_dev = lcd_dev;
  126. dsim->dsim_lcd_drv = lcd_drv;
  127. return dsim_ddi;
  128. }
  129. }
  130. return NULL;
  131. }
  132. /* define MIPI-DSI Master operations. */
  133. static struct mipi_dsim_master_ops master_ops = {
  134. .cmd_write = exynos_mipi_dsi_wr_data,
  135. .get_dsim_frame_done = exynos_mipi_dsi_get_frame_done_status,
  136. .clear_dsim_frame_done = exynos_mipi_dsi_clear_frame_done,
  137. };
  138. int exynos_mipi_dsi_init(struct exynos_platform_mipi_dsim *dsim_pd)
  139. {
  140. struct mipi_dsim_device *dsim;
  141. struct mipi_dsim_config *dsim_config;
  142. struct mipi_dsim_ddi *dsim_ddi;
  143. dsim = kzalloc(sizeof(struct mipi_dsim_device), GFP_KERNEL);
  144. if (!dsim) {
  145. debug("failed to allocate dsim object.\n");
  146. return -EFAULT;
  147. }
  148. /* get mipi_dsim_config. */
  149. dsim_config = dsim_pd->dsim_config;
  150. if (dsim_config == NULL) {
  151. debug("failed to get dsim config data.\n");
  152. return -EFAULT;
  153. }
  154. dsim->pd = dsim_pd;
  155. dsim->dsim_config = dsim_config;
  156. dsim->master_ops = &master_ops;
  157. /* bind lcd ddi matched with panel name. */
  158. dsim_ddi = exynos_mipi_dsi_bind_lcd_ddi(dsim, dsim_pd->lcd_panel_name);
  159. if (!dsim_ddi) {
  160. debug("mipi_dsim_ddi object not found.\n");
  161. return -ENOSYS;
  162. }
  163. if (dsim_pd->lcd_power)
  164. dsim_pd->lcd_power();
  165. if (dsim_pd->mipi_power)
  166. dsim_pd->mipi_power();
  167. /* phy_enable(unsigned int dev_index, unsigned int enable) */
  168. if (dsim_pd->phy_enable)
  169. dsim_pd->phy_enable(0, 1);
  170. set_mipi_clk();
  171. exynos_mipi_dsi_init_dsim(dsim);
  172. exynos_mipi_dsi_init_link(dsim);
  173. exynos_mipi_dsi_set_hs_enable(dsim);
  174. /* set display timing. */
  175. exynos_mipi_dsi_set_display_mode(dsim, dsim->dsim_config);
  176. /* initialize mipi-dsi client(lcd panel). */
  177. if (dsim_ddi->dsim_lcd_drv && dsim_ddi->dsim_lcd_drv->mipi_panel_init) {
  178. dsim_ddi->dsim_lcd_drv->mipi_panel_init(dsim);
  179. dsim_ddi->dsim_lcd_drv->mipi_display_on(dsim);
  180. }
  181. debug("mipi-dsi driver(%s mode) has been probed.\n",
  182. (dsim_config->e_interface == DSIM_COMMAND) ?
  183. "CPU" : "RGB");
  184. return 0;
  185. }
  186. int exynos_dsim_config_parse_dt(const void *blob, struct mipi_dsim_config *dt,
  187. struct mipi_dsim_lcd_device *lcd_dt)
  188. {
  189. int node;
  190. node = fdtdec_next_compatible(blob, 0, COMPAT_SAMSUNG_EXYNOS_MIPI_DSI);
  191. if (node <= 0) {
  192. printf("exynos_mipi_dsi: Can't get device node for mipi dsi\n");
  193. return -ENODEV;
  194. }
  195. dt->e_interface = fdtdec_get_int(blob, node,
  196. "samsung,dsim-config-e-interface", 0);
  197. dt->e_virtual_ch = fdtdec_get_int(blob, node,
  198. "samsung,dsim-config-e-virtual-ch", 0);
  199. dt->e_pixel_format = fdtdec_get_int(blob, node,
  200. "samsung,dsim-config-e-pixel-format", 0);
  201. dt->e_burst_mode = fdtdec_get_int(blob, node,
  202. "samsung,dsim-config-e-burst-mode", 0);
  203. dt->e_no_data_lane = fdtdec_get_int(blob, node,
  204. "samsung,dsim-config-e-no-data-lane", 0);
  205. dt->e_byte_clk = fdtdec_get_int(blob, node,
  206. "samsung,dsim-config-e-byte-clk", 0);
  207. dt->hfp = fdtdec_get_int(blob, node,
  208. "samsung,dsim-config-hfp", 0);
  209. dt->p = fdtdec_get_int(blob, node,
  210. "samsung,dsim-config-p", 0);
  211. dt->m = fdtdec_get_int(blob, node,
  212. "samsung,dsim-config-m", 0);
  213. dt->s = fdtdec_get_int(blob, node,
  214. "samsung,dsim-config-s", 0);
  215. dt->pll_stable_time = fdtdec_get_int(blob, node,
  216. "samsung,dsim-config-pll-stable-time", 0);
  217. dt->esc_clk = fdtdec_get_int(blob, node,
  218. "samsung,dsim-config-esc-clk", 0);
  219. dt->stop_holding_cnt = fdtdec_get_int(blob, node,
  220. "samsung,dsim-config-stop-holding-cnt", 0);
  221. dt->bta_timeout = fdtdec_get_int(blob, node,
  222. "samsung,dsim-config-bta-timeout", 0);
  223. dt->rx_timeout = fdtdec_get_int(blob, node,
  224. "samsung,dsim-config-rx-timeout", 0);
  225. lcd_dt->name = fdtdec_get_config_string(blob,
  226. "samsung,dsim-device-name");
  227. lcd_dt->id = fdtdec_get_int(blob, node,
  228. "samsung,dsim-device-id", 0);
  229. lcd_dt->bus_id = fdtdec_get_int(blob, node,
  230. "samsung,dsim-device-bus_id", 0);
  231. lcd_dt->reverse_panel = fdtdec_get_int(blob, node,
  232. "samsung,dsim-device-reverse-panel", 0);
  233. return 0;
  234. }
  235. void exynos_init_dsim_platform_data(vidinfo_t *vid)
  236. {
  237. static struct mipi_dsim_config dsim_config_dt;
  238. static struct exynos_platform_mipi_dsim dsim_platform_data_dt;
  239. static struct mipi_dsim_lcd_device mipi_lcd_device_dt;
  240. if (exynos_dsim_config_parse_dt(gd->fdt_blob, &dsim_config_dt,
  241. &mipi_lcd_device_dt))
  242. debug("Can't get proper dsim config.\n");
  243. strcpy(dsim_platform_data_dt.lcd_panel_name, mipi_lcd_device_dt.name);
  244. dsim_platform_data_dt.dsim_config = &dsim_config_dt;
  245. dsim_platform_data_dt.mipi_power = mipi_power;
  246. dsim_platform_data_dt.phy_enable = set_mipi_phy_ctrl;
  247. dsim_platform_data_dt.lcd_panel_info = (void *)vid;
  248. mipi_lcd_device_dt.platform_data = (void *)&dsim_platform_data_dt;
  249. exynos_mipi_dsi_register_lcd_device(&mipi_lcd_device_dt);
  250. vid->dsim_platform_data_dt = &dsim_platform_data_dt;
  251. }