rpi-panel-attiny-regulator.c 5.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright (C) 2020 Marek Vasut <marex@denx.de>
  4. *
  5. * Based on rpi_touchscreen.c by Eric Anholt <eric@anholt.net>
  6. */
  7. #include <linux/backlight.h>
  8. #include <linux/err.h>
  9. #include <linux/gpio.h>
  10. #include <linux/i2c.h>
  11. #include <linux/init.h>
  12. #include <linux/interrupt.h>
  13. #include <linux/module.h>
  14. #include <linux/regmap.h>
  15. #include <linux/regulator/driver.h>
  16. #include <linux/regulator/machine.h>
  17. #include <linux/regulator/of_regulator.h>
  18. #include <linux/slab.h>
  19. /* I2C registers of the Atmel microcontroller. */
  20. #define REG_ID 0x80
  21. #define REG_PORTA 0x81
  22. #define REG_PORTA_HF BIT(2)
  23. #define REG_PORTA_VF BIT(3)
  24. #define REG_PORTB 0x82
  25. #define REG_POWERON 0x85
  26. #define REG_PWM 0x86
  27. static const struct regmap_config attiny_regmap_config = {
  28. .reg_bits = 8,
  29. .val_bits = 8,
  30. .max_register = REG_PWM,
  31. .cache_type = REGCACHE_NONE,
  32. };
  33. static int attiny_lcd_power_enable(struct regulator_dev *rdev)
  34. {
  35. unsigned int data;
  36. int ret, i;
  37. regmap_write(rdev->regmap, REG_POWERON, 1);
  38. msleep(80);
  39. /* Wait for nPWRDWN to go low to indicate poweron is done. */
  40. for (i = 0; i < 20; i++) {
  41. ret = regmap_read(rdev->regmap, REG_PORTB, &data);
  42. if (!ret) {
  43. if (data & BIT(0))
  44. break;
  45. }
  46. usleep_range(10000, 12000);
  47. }
  48. usleep_range(10000, 12000);
  49. if (ret)
  50. pr_err("%s: regmap_read_poll_timeout failed %d\n", __func__, ret);
  51. /* Default to the same orientation as the closed source
  52. * firmware used for the panel. Runtime rotation
  53. * configuration will be supported using VC4's plane
  54. * orientation bits.
  55. */
  56. regmap_write(rdev->regmap, REG_PORTA, BIT(2));
  57. return 0;
  58. }
  59. static int attiny_lcd_power_disable(struct regulator_dev *rdev)
  60. {
  61. regmap_write(rdev->regmap, REG_PWM, 0);
  62. regmap_write(rdev->regmap, REG_POWERON, 0);
  63. msleep(30);
  64. return 0;
  65. }
  66. static int attiny_lcd_power_is_enabled(struct regulator_dev *rdev)
  67. {
  68. unsigned int data;
  69. int ret, i;
  70. for (i = 0; i < 10; i++) {
  71. ret = regmap_read(rdev->regmap, REG_POWERON, &data);
  72. if (!ret)
  73. break;
  74. usleep_range(10000, 12000);
  75. }
  76. if (ret < 0)
  77. return ret;
  78. if (!(data & BIT(0)))
  79. return 0;
  80. for (i = 0; i < 10; i++) {
  81. ret = regmap_read(rdev->regmap, REG_PORTB, &data);
  82. if (!ret)
  83. break;
  84. usleep_range(10000, 12000);
  85. }
  86. if (ret < 0)
  87. return ret;
  88. return data & BIT(0);
  89. }
  90. static const struct regulator_init_data attiny_regulator_default = {
  91. .constraints = {
  92. .valid_ops_mask = REGULATOR_CHANGE_STATUS,
  93. },
  94. };
  95. static const struct regulator_ops attiny_regulator_ops = {
  96. .enable = attiny_lcd_power_enable,
  97. .disable = attiny_lcd_power_disable,
  98. .is_enabled = attiny_lcd_power_is_enabled,
  99. };
  100. static const struct regulator_desc attiny_regulator = {
  101. .name = "tc358762-power",
  102. .ops = &attiny_regulator_ops,
  103. .type = REGULATOR_VOLTAGE,
  104. .owner = THIS_MODULE,
  105. };
  106. static int attiny_update_status(struct backlight_device *bl)
  107. {
  108. struct regmap *regmap = bl_get_data(bl);
  109. int brightness = bl->props.brightness;
  110. int ret, i;
  111. if (bl->props.power != FB_BLANK_UNBLANK ||
  112. bl->props.fb_blank != FB_BLANK_UNBLANK)
  113. brightness = 0;
  114. for (i = 0; i < 10; i++) {
  115. ret = regmap_write(regmap, REG_PWM, brightness);
  116. if (!ret)
  117. break;
  118. }
  119. return ret;
  120. }
  121. static int attiny_get_brightness(struct backlight_device *bl)
  122. {
  123. struct regmap *regmap = bl_get_data(bl);
  124. int ret, brightness, i;
  125. for (i = 0; i < 10; i++) {
  126. ret = regmap_read(regmap, REG_PWM, &brightness);
  127. if (!ret)
  128. break;
  129. }
  130. if (ret)
  131. return ret;
  132. return brightness;
  133. }
  134. static const struct backlight_ops attiny_bl = {
  135. .update_status = attiny_update_status,
  136. .get_brightness = attiny_get_brightness,
  137. };
  138. /*
  139. * I2C driver interface functions
  140. */
  141. static int attiny_i2c_probe(struct i2c_client *i2c,
  142. const struct i2c_device_id *id)
  143. {
  144. struct backlight_properties props = { };
  145. struct regulator_config config = { };
  146. struct backlight_device *bl;
  147. struct regulator_dev *rdev;
  148. struct regmap *regmap;
  149. unsigned int data;
  150. int ret;
  151. regmap = devm_regmap_init_i2c(i2c, &attiny_regmap_config);
  152. if (IS_ERR(regmap)) {
  153. ret = PTR_ERR(regmap);
  154. dev_err(&i2c->dev, "Failed to allocate register map: %d\n",
  155. ret);
  156. return ret;
  157. }
  158. ret = regmap_read(regmap, REG_ID, &data);
  159. if (ret < 0) {
  160. dev_err(&i2c->dev, "Failed to read REG_ID reg: %d\n", ret);
  161. return ret;
  162. }
  163. switch (data) {
  164. case 0xde: /* ver 1 */
  165. case 0xc3: /* ver 2 */
  166. break;
  167. default:
  168. dev_err(&i2c->dev, "Unknown Atmel firmware revision: 0x%02x\n", data);
  169. return -ENODEV;
  170. }
  171. regmap_write(regmap, REG_POWERON, 0);
  172. msleep(30);
  173. config.dev = &i2c->dev;
  174. config.regmap = regmap;
  175. config.of_node = i2c->dev.of_node;
  176. config.init_data = &attiny_regulator_default;
  177. rdev = devm_regulator_register(&i2c->dev, &attiny_regulator, &config);
  178. if (IS_ERR(rdev)) {
  179. dev_err(&i2c->dev, "Failed to register ATTINY regulator\n");
  180. return PTR_ERR(rdev);
  181. }
  182. props.type = BACKLIGHT_RAW;
  183. props.max_brightness = 0xff;
  184. bl = devm_backlight_device_register(&i2c->dev,
  185. "7inch-touchscreen-panel-bl",
  186. &i2c->dev, regmap, &attiny_bl,
  187. &props);
  188. if (IS_ERR(bl))
  189. return PTR_ERR(bl);
  190. bl->props.brightness = 0xff;
  191. return 0;
  192. }
  193. static const struct of_device_id attiny_dt_ids[] = {
  194. { .compatible = "raspberrypi,7inch-touchscreen-panel-regulator" },
  195. {},
  196. };
  197. MODULE_DEVICE_TABLE(of, attiny_dt_ids);
  198. static struct i2c_driver attiny_regulator_driver = {
  199. .driver = {
  200. .name = "rpi_touchscreen_attiny",
  201. .of_match_table = of_match_ptr(attiny_dt_ids),
  202. },
  203. .probe = attiny_i2c_probe,
  204. };
  205. module_i2c_driver(attiny_regulator_driver);
  206. MODULE_AUTHOR("Marek Vasut <marex@denx.de>");
  207. MODULE_DESCRIPTION("Regulator device driver for Raspberry Pi 7-inch touchscreen");
  208. MODULE_LICENSE("GPL v2");