panel-tpo-td043mtea1.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Toppoly TD043MTEA1 Panel Driver
  4. *
  5. * Copyright (C) 2019 Texas Instruments Incorporated
  6. *
  7. * Based on the omapdrm-specific panel-tpo-td043mtea1 driver
  8. *
  9. * Author: Gražvydas Ignotas <notasas@gmail.com>
  10. */
  11. #include <linux/delay.h>
  12. #include <linux/module.h>
  13. #include <linux/regulator/consumer.h>
  14. #include <linux/spi/spi.h>
  15. #include <drm/drm_connector.h>
  16. #include <drm/drm_modes.h>
  17. #include <drm/drm_panel.h>
  18. #define TPO_R02_MODE(x) ((x) & 7)
  19. #define TPO_R02_MODE_800x480 7
  20. #define TPO_R02_NCLK_RISING BIT(3)
  21. #define TPO_R02_HSYNC_HIGH BIT(4)
  22. #define TPO_R02_VSYNC_HIGH BIT(5)
  23. #define TPO_R03_NSTANDBY BIT(0)
  24. #define TPO_R03_EN_CP_CLK BIT(1)
  25. #define TPO_R03_EN_VGL_PUMP BIT(2)
  26. #define TPO_R03_EN_PWM BIT(3)
  27. #define TPO_R03_DRIVING_CAP_100 BIT(4)
  28. #define TPO_R03_EN_PRE_CHARGE BIT(6)
  29. #define TPO_R03_SOFTWARE_CTL BIT(7)
  30. #define TPO_R04_NFLIP_H BIT(0)
  31. #define TPO_R04_NFLIP_V BIT(1)
  32. #define TPO_R04_CP_CLK_FREQ_1H BIT(2)
  33. #define TPO_R04_VGL_FREQ_1H BIT(4)
  34. #define TPO_R03_VAL_NORMAL \
  35. (TPO_R03_NSTANDBY | TPO_R03_EN_CP_CLK | TPO_R03_EN_VGL_PUMP | \
  36. TPO_R03_EN_PWM | TPO_R03_DRIVING_CAP_100 | TPO_R03_EN_PRE_CHARGE | \
  37. TPO_R03_SOFTWARE_CTL)
  38. #define TPO_R03_VAL_STANDBY \
  39. (TPO_R03_DRIVING_CAP_100 | TPO_R03_EN_PRE_CHARGE | \
  40. TPO_R03_SOFTWARE_CTL)
  41. static const u16 td043mtea1_def_gamma[12] = {
  42. 105, 315, 381, 431, 490, 537, 579, 686, 780, 837, 880, 1023
  43. };
  44. struct td043mtea1_panel {
  45. struct drm_panel panel;
  46. struct spi_device *spi;
  47. struct regulator *vcc_reg;
  48. struct gpio_desc *reset_gpio;
  49. unsigned int mode;
  50. u16 gamma[12];
  51. bool vmirror;
  52. bool powered_on;
  53. bool spi_suspended;
  54. bool power_on_resume;
  55. };
  56. #define to_td043mtea1_device(p) container_of(p, struct td043mtea1_panel, panel)
  57. /* -----------------------------------------------------------------------------
  58. * Hardware Access
  59. */
  60. static int td043mtea1_write(struct td043mtea1_panel *lcd, u8 addr, u8 value)
  61. {
  62. struct spi_message msg;
  63. struct spi_transfer xfer;
  64. u16 data;
  65. int ret;
  66. spi_message_init(&msg);
  67. memset(&xfer, 0, sizeof(xfer));
  68. data = ((u16)addr << 10) | (1 << 8) | value;
  69. xfer.tx_buf = &data;
  70. xfer.bits_per_word = 16;
  71. xfer.len = 2;
  72. spi_message_add_tail(&xfer, &msg);
  73. ret = spi_sync(lcd->spi, &msg);
  74. if (ret < 0)
  75. dev_warn(&lcd->spi->dev, "failed to write to LCD reg (%d)\n",
  76. ret);
  77. return ret;
  78. }
  79. static void td043mtea1_write_gamma(struct td043mtea1_panel *lcd)
  80. {
  81. const u16 *gamma = lcd->gamma;
  82. unsigned int i;
  83. u8 val;
  84. /* gamma bits [9:8] */
  85. for (val = i = 0; i < 4; i++)
  86. val |= (gamma[i] & 0x300) >> ((i + 1) * 2);
  87. td043mtea1_write(lcd, 0x11, val);
  88. for (val = i = 0; i < 4; i++)
  89. val |= (gamma[i + 4] & 0x300) >> ((i + 1) * 2);
  90. td043mtea1_write(lcd, 0x12, val);
  91. for (val = i = 0; i < 4; i++)
  92. val |= (gamma[i + 8] & 0x300) >> ((i + 1) * 2);
  93. td043mtea1_write(lcd, 0x13, val);
  94. /* gamma bits [7:0] */
  95. for (i = 0; i < 12; i++)
  96. td043mtea1_write(lcd, 0x14 + i, gamma[i] & 0xff);
  97. }
  98. static int td043mtea1_write_mirror(struct td043mtea1_panel *lcd)
  99. {
  100. u8 reg4 = TPO_R04_NFLIP_H | TPO_R04_NFLIP_V |
  101. TPO_R04_CP_CLK_FREQ_1H | TPO_R04_VGL_FREQ_1H;
  102. if (lcd->vmirror)
  103. reg4 &= ~TPO_R04_NFLIP_V;
  104. return td043mtea1_write(lcd, 4, reg4);
  105. }
  106. static int td043mtea1_power_on(struct td043mtea1_panel *lcd)
  107. {
  108. int ret;
  109. if (lcd->powered_on)
  110. return 0;
  111. ret = regulator_enable(lcd->vcc_reg);
  112. if (ret < 0)
  113. return ret;
  114. /* Wait for the panel to stabilize. */
  115. msleep(160);
  116. gpiod_set_value(lcd->reset_gpio, 0);
  117. td043mtea1_write(lcd, 2, TPO_R02_MODE(lcd->mode) | TPO_R02_NCLK_RISING);
  118. td043mtea1_write(lcd, 3, TPO_R03_VAL_NORMAL);
  119. td043mtea1_write(lcd, 0x20, 0xf0);
  120. td043mtea1_write(lcd, 0x21, 0xf0);
  121. td043mtea1_write_mirror(lcd);
  122. td043mtea1_write_gamma(lcd);
  123. lcd->powered_on = true;
  124. return 0;
  125. }
  126. static void td043mtea1_power_off(struct td043mtea1_panel *lcd)
  127. {
  128. if (!lcd->powered_on)
  129. return;
  130. td043mtea1_write(lcd, 3, TPO_R03_VAL_STANDBY | TPO_R03_EN_PWM);
  131. gpiod_set_value(lcd->reset_gpio, 1);
  132. /* wait for at least 2 vsyncs before cutting off power */
  133. msleep(50);
  134. td043mtea1_write(lcd, 3, TPO_R03_VAL_STANDBY);
  135. regulator_disable(lcd->vcc_reg);
  136. lcd->powered_on = false;
  137. }
  138. /* -----------------------------------------------------------------------------
  139. * sysfs
  140. */
  141. static ssize_t vmirror_show(struct device *dev, struct device_attribute *attr,
  142. char *buf)
  143. {
  144. struct td043mtea1_panel *lcd = dev_get_drvdata(dev);
  145. return snprintf(buf, PAGE_SIZE, "%d\n", lcd->vmirror);
  146. }
  147. static ssize_t vmirror_store(struct device *dev, struct device_attribute *attr,
  148. const char *buf, size_t count)
  149. {
  150. struct td043mtea1_panel *lcd = dev_get_drvdata(dev);
  151. int val;
  152. int ret;
  153. ret = kstrtoint(buf, 0, &val);
  154. if (ret < 0)
  155. return ret;
  156. lcd->vmirror = !!val;
  157. ret = td043mtea1_write_mirror(lcd);
  158. if (ret < 0)
  159. return ret;
  160. return count;
  161. }
  162. static ssize_t mode_show(struct device *dev, struct device_attribute *attr,
  163. char *buf)
  164. {
  165. struct td043mtea1_panel *lcd = dev_get_drvdata(dev);
  166. return snprintf(buf, PAGE_SIZE, "%d\n", lcd->mode);
  167. }
  168. static ssize_t mode_store(struct device *dev, struct device_attribute *attr,
  169. const char *buf, size_t count)
  170. {
  171. struct td043mtea1_panel *lcd = dev_get_drvdata(dev);
  172. long val;
  173. int ret;
  174. ret = kstrtol(buf, 0, &val);
  175. if (ret != 0 || val & ~7)
  176. return -EINVAL;
  177. lcd->mode = val;
  178. val |= TPO_R02_NCLK_RISING;
  179. td043mtea1_write(lcd, 2, val);
  180. return count;
  181. }
  182. static ssize_t gamma_show(struct device *dev, struct device_attribute *attr,
  183. char *buf)
  184. {
  185. struct td043mtea1_panel *lcd = dev_get_drvdata(dev);
  186. ssize_t len = 0;
  187. unsigned int i;
  188. int ret;
  189. for (i = 0; i < ARRAY_SIZE(lcd->gamma); i++) {
  190. ret = snprintf(buf + len, PAGE_SIZE - len, "%u ",
  191. lcd->gamma[i]);
  192. if (ret < 0)
  193. return ret;
  194. len += ret;
  195. }
  196. buf[len - 1] = '\n';
  197. return len;
  198. }
  199. static ssize_t gamma_store(struct device *dev, struct device_attribute *attr,
  200. const char *buf, size_t count)
  201. {
  202. struct td043mtea1_panel *lcd = dev_get_drvdata(dev);
  203. unsigned int g[12];
  204. unsigned int i;
  205. int ret;
  206. ret = sscanf(buf, "%u %u %u %u %u %u %u %u %u %u %u %u",
  207. &g[0], &g[1], &g[2], &g[3], &g[4], &g[5],
  208. &g[6], &g[7], &g[8], &g[9], &g[10], &g[11]);
  209. if (ret != 12)
  210. return -EINVAL;
  211. for (i = 0; i < 12; i++)
  212. lcd->gamma[i] = g[i];
  213. td043mtea1_write_gamma(lcd);
  214. return count;
  215. }
  216. static DEVICE_ATTR_RW(vmirror);
  217. static DEVICE_ATTR_RW(mode);
  218. static DEVICE_ATTR_RW(gamma);
  219. static struct attribute *td043mtea1_attrs[] = {
  220. &dev_attr_vmirror.attr,
  221. &dev_attr_mode.attr,
  222. &dev_attr_gamma.attr,
  223. NULL,
  224. };
  225. static const struct attribute_group td043mtea1_attr_group = {
  226. .attrs = td043mtea1_attrs,
  227. };
  228. /* -----------------------------------------------------------------------------
  229. * Panel Operations
  230. */
  231. static int td043mtea1_unprepare(struct drm_panel *panel)
  232. {
  233. struct td043mtea1_panel *lcd = to_td043mtea1_device(panel);
  234. if (!lcd->spi_suspended)
  235. td043mtea1_power_off(lcd);
  236. return 0;
  237. }
  238. static int td043mtea1_prepare(struct drm_panel *panel)
  239. {
  240. struct td043mtea1_panel *lcd = to_td043mtea1_device(panel);
  241. int ret;
  242. /*
  243. * If we are resuming from system suspend, SPI might not be enabled
  244. * yet, so we'll program the LCD from SPI PM resume callback.
  245. */
  246. if (lcd->spi_suspended)
  247. return 0;
  248. ret = td043mtea1_power_on(lcd);
  249. if (ret) {
  250. dev_err(&lcd->spi->dev, "%s: power on failed (%d)\n",
  251. __func__, ret);
  252. return ret;
  253. }
  254. return 0;
  255. }
  256. static const struct drm_display_mode td043mtea1_mode = {
  257. .clock = 36000,
  258. .hdisplay = 800,
  259. .hsync_start = 800 + 68,
  260. .hsync_end = 800 + 68 + 1,
  261. .htotal = 800 + 68 + 1 + 214,
  262. .vdisplay = 480,
  263. .vsync_start = 480 + 39,
  264. .vsync_end = 480 + 39 + 1,
  265. .vtotal = 480 + 39 + 1 + 34,
  266. .type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED,
  267. .flags = DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC,
  268. .width_mm = 94,
  269. .height_mm = 56,
  270. };
  271. static int td043mtea1_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, &td043mtea1_mode);
  276. if (!mode)
  277. return -ENOMEM;
  278. drm_mode_set_name(mode);
  279. drm_mode_probed_add(connector, mode);
  280. connector->display_info.width_mm = td043mtea1_mode.width_mm;
  281. connector->display_info.height_mm = td043mtea1_mode.height_mm;
  282. /*
  283. * FIXME: According to the datasheet sync signals are sampled on the
  284. * rising edge of the clock, but the code running on the OMAP3 Pandora
  285. * indicates sampling on the falling edge. This should be tested on a
  286. * real device.
  287. */
  288. connector->display_info.bus_flags = DRM_BUS_FLAG_DE_HIGH
  289. | DRM_BUS_FLAG_SYNC_SAMPLE_NEGEDGE
  290. | DRM_BUS_FLAG_PIXDATA_SAMPLE_POSEDGE;
  291. return 1;
  292. }
  293. static const struct drm_panel_funcs td043mtea1_funcs = {
  294. .unprepare = td043mtea1_unprepare,
  295. .prepare = td043mtea1_prepare,
  296. .get_modes = td043mtea1_get_modes,
  297. };
  298. /* -----------------------------------------------------------------------------
  299. * Power Management, Probe and Remove
  300. */
  301. static int __maybe_unused td043mtea1_suspend(struct device *dev)
  302. {
  303. struct td043mtea1_panel *lcd = dev_get_drvdata(dev);
  304. if (lcd->powered_on) {
  305. td043mtea1_power_off(lcd);
  306. lcd->powered_on = true;
  307. }
  308. lcd->spi_suspended = true;
  309. return 0;
  310. }
  311. static int __maybe_unused td043mtea1_resume(struct device *dev)
  312. {
  313. struct td043mtea1_panel *lcd = dev_get_drvdata(dev);
  314. int ret;
  315. lcd->spi_suspended = false;
  316. if (lcd->powered_on) {
  317. lcd->powered_on = false;
  318. ret = td043mtea1_power_on(lcd);
  319. if (ret)
  320. return ret;
  321. }
  322. return 0;
  323. }
  324. static SIMPLE_DEV_PM_OPS(td043mtea1_pm_ops, td043mtea1_suspend,
  325. td043mtea1_resume);
  326. static int td043mtea1_probe(struct spi_device *spi)
  327. {
  328. struct td043mtea1_panel *lcd;
  329. int ret;
  330. lcd = devm_kzalloc(&spi->dev, sizeof(*lcd), GFP_KERNEL);
  331. if (lcd == NULL)
  332. return -ENOMEM;
  333. spi_set_drvdata(spi, lcd);
  334. lcd->spi = spi;
  335. lcd->mode = TPO_R02_MODE_800x480;
  336. memcpy(lcd->gamma, td043mtea1_def_gamma, sizeof(lcd->gamma));
  337. lcd->vcc_reg = devm_regulator_get(&spi->dev, "vcc");
  338. if (IS_ERR(lcd->vcc_reg)) {
  339. dev_err(&spi->dev, "failed to get VCC regulator\n");
  340. return PTR_ERR(lcd->vcc_reg);
  341. }
  342. lcd->reset_gpio = devm_gpiod_get(&spi->dev, "reset", GPIOD_OUT_HIGH);
  343. if (IS_ERR(lcd->reset_gpio)) {
  344. dev_err(&spi->dev, "failed to get reset GPIO\n");
  345. return PTR_ERR(lcd->reset_gpio);
  346. }
  347. spi->bits_per_word = 16;
  348. spi->mode = SPI_MODE_0;
  349. ret = spi_setup(spi);
  350. if (ret < 0) {
  351. dev_err(&spi->dev, "failed to setup SPI: %d\n", ret);
  352. return ret;
  353. }
  354. ret = sysfs_create_group(&spi->dev.kobj, &td043mtea1_attr_group);
  355. if (ret < 0) {
  356. dev_err(&spi->dev, "failed to create sysfs files\n");
  357. return ret;
  358. }
  359. drm_panel_init(&lcd->panel, &lcd->spi->dev, &td043mtea1_funcs,
  360. DRM_MODE_CONNECTOR_DPI);
  361. drm_panel_add(&lcd->panel);
  362. return 0;
  363. }
  364. static int td043mtea1_remove(struct spi_device *spi)
  365. {
  366. struct td043mtea1_panel *lcd = spi_get_drvdata(spi);
  367. drm_panel_remove(&lcd->panel);
  368. drm_panel_disable(&lcd->panel);
  369. drm_panel_unprepare(&lcd->panel);
  370. sysfs_remove_group(&spi->dev.kobj, &td043mtea1_attr_group);
  371. return 0;
  372. }
  373. static const struct of_device_id td043mtea1_of_match[] = {
  374. { .compatible = "tpo,td043mtea1", },
  375. { /* sentinel */ },
  376. };
  377. MODULE_DEVICE_TABLE(of, td043mtea1_of_match);
  378. static const struct spi_device_id td043mtea1_ids[] = {
  379. { "td043mtea1", 0 },
  380. { /* sentinel */ }
  381. };
  382. MODULE_DEVICE_TABLE(spi, td043mtea1_ids);
  383. static struct spi_driver td043mtea1_driver = {
  384. .probe = td043mtea1_probe,
  385. .remove = td043mtea1_remove,
  386. .id_table = td043mtea1_ids,
  387. .driver = {
  388. .name = "panel-tpo-td043mtea1",
  389. .pm = &td043mtea1_pm_ops,
  390. .of_match_table = td043mtea1_of_match,
  391. },
  392. };
  393. module_spi_driver(td043mtea1_driver);
  394. MODULE_AUTHOR("Gražvydas Ignotas <notasas@gmail.com>");
  395. MODULE_DESCRIPTION("TPO TD043MTEA1 Panel Driver");
  396. MODULE_LICENSE("GPL");