l4f00242t03.c 6.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * l4f00242t03.c -- support for Epson L4F00242T03 LCD
  4. *
  5. * Copyright 2007-2009 Freescale Semiconductor, Inc. All Rights Reserved.
  6. *
  7. * Copyright (c) 2009 Alberto Panizzo <maramaopercheseimorto@gmail.com>
  8. * Inspired by Marek Vasut work in l4f00242t03.c
  9. */
  10. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  11. #include <linux/device.h>
  12. #include <linux/kernel.h>
  13. #include <linux/delay.h>
  14. #include <linux/module.h>
  15. #include <linux/gpio/consumer.h>
  16. #include <linux/lcd.h>
  17. #include <linux/slab.h>
  18. #include <linux/regulator/consumer.h>
  19. #include <linux/spi/spi.h>
  20. struct l4f00242t03_priv {
  21. struct spi_device *spi;
  22. struct lcd_device *ld;
  23. int lcd_state;
  24. struct regulator *io_reg;
  25. struct regulator *core_reg;
  26. struct gpio_desc *reset;
  27. struct gpio_desc *enable;
  28. };
  29. static void l4f00242t03_reset(struct gpio_desc *gpiod)
  30. {
  31. pr_debug("l4f00242t03_reset.\n");
  32. gpiod_set_value(gpiod, 1);
  33. mdelay(100);
  34. gpiod_set_value(gpiod, 0);
  35. mdelay(10); /* tRES >= 100us */
  36. gpiod_set_value(gpiod, 1);
  37. mdelay(20);
  38. }
  39. #define param(x) ((x) | 0x100)
  40. static void l4f00242t03_lcd_init(struct spi_device *spi)
  41. {
  42. struct l4f00242t03_priv *priv = spi_get_drvdata(spi);
  43. const u16 cmd[] = { 0x36, param(0), 0x3A, param(0x60) };
  44. int ret;
  45. dev_dbg(&spi->dev, "initializing LCD\n");
  46. ret = regulator_set_voltage(priv->io_reg, 1800000, 1800000);
  47. if (ret) {
  48. dev_err(&spi->dev, "failed to set the IO regulator voltage.\n");
  49. return;
  50. }
  51. ret = regulator_enable(priv->io_reg);
  52. if (ret) {
  53. dev_err(&spi->dev, "failed to enable the IO regulator.\n");
  54. return;
  55. }
  56. ret = regulator_set_voltage(priv->core_reg, 2800000, 2800000);
  57. if (ret) {
  58. dev_err(&spi->dev, "failed to set the core regulator voltage.\n");
  59. regulator_disable(priv->io_reg);
  60. return;
  61. }
  62. ret = regulator_enable(priv->core_reg);
  63. if (ret) {
  64. dev_err(&spi->dev, "failed to enable the core regulator.\n");
  65. regulator_disable(priv->io_reg);
  66. return;
  67. }
  68. l4f00242t03_reset(priv->reset);
  69. gpiod_set_value(priv->enable, 1);
  70. msleep(60);
  71. spi_write(spi, (const u8 *)cmd, ARRAY_SIZE(cmd) * sizeof(u16));
  72. }
  73. static void l4f00242t03_lcd_powerdown(struct spi_device *spi)
  74. {
  75. struct l4f00242t03_priv *priv = spi_get_drvdata(spi);
  76. dev_dbg(&spi->dev, "Powering down LCD\n");
  77. gpiod_set_value(priv->enable, 0);
  78. regulator_disable(priv->io_reg);
  79. regulator_disable(priv->core_reg);
  80. }
  81. static int l4f00242t03_lcd_power_get(struct lcd_device *ld)
  82. {
  83. struct l4f00242t03_priv *priv = lcd_get_data(ld);
  84. return priv->lcd_state;
  85. }
  86. static int l4f00242t03_lcd_power_set(struct lcd_device *ld, int power)
  87. {
  88. struct l4f00242t03_priv *priv = lcd_get_data(ld);
  89. struct spi_device *spi = priv->spi;
  90. const u16 slpout = 0x11;
  91. const u16 dison = 0x29;
  92. const u16 slpin = 0x10;
  93. const u16 disoff = 0x28;
  94. if (power <= FB_BLANK_NORMAL) {
  95. if (priv->lcd_state <= FB_BLANK_NORMAL) {
  96. /* Do nothing, the LCD is running */
  97. } else if (priv->lcd_state < FB_BLANK_POWERDOWN) {
  98. dev_dbg(&spi->dev, "Resuming LCD\n");
  99. spi_write(spi, (const u8 *)&slpout, sizeof(u16));
  100. msleep(60);
  101. spi_write(spi, (const u8 *)&dison, sizeof(u16));
  102. } else {
  103. /* priv->lcd_state == FB_BLANK_POWERDOWN */
  104. l4f00242t03_lcd_init(spi);
  105. priv->lcd_state = FB_BLANK_VSYNC_SUSPEND;
  106. l4f00242t03_lcd_power_set(priv->ld, power);
  107. }
  108. } else if (power < FB_BLANK_POWERDOWN) {
  109. if (priv->lcd_state <= FB_BLANK_NORMAL) {
  110. /* Send the display in standby */
  111. dev_dbg(&spi->dev, "Standby the LCD\n");
  112. spi_write(spi, (const u8 *)&disoff, sizeof(u16));
  113. msleep(60);
  114. spi_write(spi, (const u8 *)&slpin, sizeof(u16));
  115. } else if (priv->lcd_state < FB_BLANK_POWERDOWN) {
  116. /* Do nothing, the LCD is already in standby */
  117. } else {
  118. /* priv->lcd_state == FB_BLANK_POWERDOWN */
  119. l4f00242t03_lcd_init(spi);
  120. priv->lcd_state = FB_BLANK_UNBLANK;
  121. l4f00242t03_lcd_power_set(ld, power);
  122. }
  123. } else {
  124. /* power == FB_BLANK_POWERDOWN */
  125. if (priv->lcd_state != FB_BLANK_POWERDOWN) {
  126. /* Clear the screen before shutting down */
  127. spi_write(spi, (const u8 *)&disoff, sizeof(u16));
  128. msleep(60);
  129. l4f00242t03_lcd_powerdown(spi);
  130. }
  131. }
  132. priv->lcd_state = power;
  133. return 0;
  134. }
  135. static struct lcd_ops l4f_ops = {
  136. .set_power = l4f00242t03_lcd_power_set,
  137. .get_power = l4f00242t03_lcd_power_get,
  138. };
  139. static int l4f00242t03_probe(struct spi_device *spi)
  140. {
  141. struct l4f00242t03_priv *priv;
  142. priv = devm_kzalloc(&spi->dev, sizeof(struct l4f00242t03_priv),
  143. GFP_KERNEL);
  144. if (priv == NULL)
  145. return -ENOMEM;
  146. spi_set_drvdata(spi, priv);
  147. spi->bits_per_word = 9;
  148. spi_setup(spi);
  149. priv->spi = spi;
  150. priv->reset = devm_gpiod_get(&spi->dev, "reset", GPIOD_OUT_HIGH);
  151. if (IS_ERR(priv->reset)) {
  152. dev_err(&spi->dev,
  153. "Unable to get the lcd l4f00242t03 reset gpio.\n");
  154. return PTR_ERR(priv->reset);
  155. }
  156. gpiod_set_consumer_name(priv->reset, "lcd l4f00242t03 reset");
  157. priv->enable = devm_gpiod_get(&spi->dev, "enable", GPIOD_OUT_LOW);
  158. if (IS_ERR(priv->enable)) {
  159. dev_err(&spi->dev,
  160. "Unable to get the lcd l4f00242t03 data en gpio.\n");
  161. return PTR_ERR(priv->enable);
  162. }
  163. gpiod_set_consumer_name(priv->enable, "lcd l4f00242t03 data enable");
  164. priv->io_reg = devm_regulator_get(&spi->dev, "vdd");
  165. if (IS_ERR(priv->io_reg)) {
  166. dev_err(&spi->dev, "%s: Unable to get the IO regulator\n",
  167. __func__);
  168. return PTR_ERR(priv->io_reg);
  169. }
  170. priv->core_reg = devm_regulator_get(&spi->dev, "vcore");
  171. if (IS_ERR(priv->core_reg)) {
  172. dev_err(&spi->dev, "%s: Unable to get the core regulator\n",
  173. __func__);
  174. return PTR_ERR(priv->core_reg);
  175. }
  176. priv->ld = devm_lcd_device_register(&spi->dev, "l4f00242t03", &spi->dev,
  177. priv, &l4f_ops);
  178. if (IS_ERR(priv->ld))
  179. return PTR_ERR(priv->ld);
  180. /* Init the LCD */
  181. l4f00242t03_lcd_init(spi);
  182. priv->lcd_state = FB_BLANK_VSYNC_SUSPEND;
  183. l4f00242t03_lcd_power_set(priv->ld, FB_BLANK_UNBLANK);
  184. dev_info(&spi->dev, "Epson l4f00242t03 lcd probed.\n");
  185. return 0;
  186. }
  187. static int l4f00242t03_remove(struct spi_device *spi)
  188. {
  189. struct l4f00242t03_priv *priv = spi_get_drvdata(spi);
  190. l4f00242t03_lcd_power_set(priv->ld, FB_BLANK_POWERDOWN);
  191. return 0;
  192. }
  193. static void l4f00242t03_shutdown(struct spi_device *spi)
  194. {
  195. struct l4f00242t03_priv *priv = spi_get_drvdata(spi);
  196. if (priv)
  197. l4f00242t03_lcd_power_set(priv->ld, FB_BLANK_POWERDOWN);
  198. }
  199. static struct spi_driver l4f00242t03_driver = {
  200. .driver = {
  201. .name = "l4f00242t03",
  202. },
  203. .probe = l4f00242t03_probe,
  204. .remove = l4f00242t03_remove,
  205. .shutdown = l4f00242t03_shutdown,
  206. };
  207. module_spi_driver(l4f00242t03_driver);
  208. MODULE_AUTHOR("Alberto Panizzo <maramaopercheseimorto@gmail.com>");
  209. MODULE_DESCRIPTION("EPSON L4F00242T03 LCD");
  210. MODULE_LICENSE("GPL v2");