leds-sgm3140.c 7.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311
  1. // SPDX-License-Identifier: GPL-2.0
  2. // Copyright (C) 2020 Luca Weiss <luca@z3ntu.xyz>
  3. #include <linux/gpio/consumer.h>
  4. #include <linux/led-class-flash.h>
  5. #include <linux/module.h>
  6. #include <linux/regulator/consumer.h>
  7. #include <linux/platform_device.h>
  8. #include <media/v4l2-flash-led-class.h>
  9. #define FLASH_TIMEOUT_DEFAULT 250000U /* 250ms */
  10. #define FLASH_MAX_TIMEOUT_DEFAULT 300000U /* 300ms */
  11. struct sgm3140 {
  12. struct led_classdev_flash fled_cdev;
  13. struct v4l2_flash *v4l2_flash;
  14. struct timer_list powerdown_timer;
  15. struct gpio_desc *flash_gpio;
  16. struct gpio_desc *enable_gpio;
  17. struct regulator *vin_regulator;
  18. bool enabled;
  19. /* current timeout in us */
  20. u32 timeout;
  21. /* maximum timeout in us */
  22. u32 max_timeout;
  23. };
  24. static struct sgm3140 *flcdev_to_sgm3140(struct led_classdev_flash *flcdev)
  25. {
  26. return container_of(flcdev, struct sgm3140, fled_cdev);
  27. }
  28. static int sgm3140_strobe_set(struct led_classdev_flash *fled_cdev, bool state)
  29. {
  30. struct sgm3140 *priv = flcdev_to_sgm3140(fled_cdev);
  31. int ret;
  32. if (priv->enabled == state)
  33. return 0;
  34. if (state) {
  35. ret = regulator_enable(priv->vin_regulator);
  36. if (ret) {
  37. dev_err(fled_cdev->led_cdev.dev,
  38. "failed to enable regulator: %d\n", ret);
  39. return ret;
  40. }
  41. gpiod_set_value_cansleep(priv->flash_gpio, 1);
  42. gpiod_set_value_cansleep(priv->enable_gpio, 1);
  43. mod_timer(&priv->powerdown_timer,
  44. jiffies + usecs_to_jiffies(priv->timeout));
  45. } else {
  46. del_timer_sync(&priv->powerdown_timer);
  47. gpiod_set_value_cansleep(priv->enable_gpio, 0);
  48. gpiod_set_value_cansleep(priv->flash_gpio, 0);
  49. ret = regulator_disable(priv->vin_regulator);
  50. if (ret) {
  51. dev_err(fled_cdev->led_cdev.dev,
  52. "failed to disable regulator: %d\n", ret);
  53. return ret;
  54. }
  55. }
  56. priv->enabled = state;
  57. return 0;
  58. }
  59. static int sgm3140_strobe_get(struct led_classdev_flash *fled_cdev, bool *state)
  60. {
  61. struct sgm3140 *priv = flcdev_to_sgm3140(fled_cdev);
  62. *state = timer_pending(&priv->powerdown_timer);
  63. return 0;
  64. }
  65. static int sgm3140_timeout_set(struct led_classdev_flash *fled_cdev,
  66. u32 timeout)
  67. {
  68. struct sgm3140 *priv = flcdev_to_sgm3140(fled_cdev);
  69. priv->timeout = timeout;
  70. return 0;
  71. }
  72. static const struct led_flash_ops sgm3140_flash_ops = {
  73. .strobe_set = sgm3140_strobe_set,
  74. .strobe_get = sgm3140_strobe_get,
  75. .timeout_set = sgm3140_timeout_set,
  76. };
  77. static int sgm3140_brightness_set(struct led_classdev *led_cdev,
  78. enum led_brightness brightness)
  79. {
  80. struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev);
  81. struct sgm3140 *priv = flcdev_to_sgm3140(fled_cdev);
  82. bool enable = brightness == LED_ON;
  83. int ret;
  84. if (priv->enabled == enable)
  85. return 0;
  86. if (enable) {
  87. ret = regulator_enable(priv->vin_regulator);
  88. if (ret) {
  89. dev_err(led_cdev->dev,
  90. "failed to enable regulator: %d\n", ret);
  91. return ret;
  92. }
  93. gpiod_set_value_cansleep(priv->enable_gpio, 1);
  94. } else {
  95. gpiod_set_value_cansleep(priv->enable_gpio, 0);
  96. ret = regulator_disable(priv->vin_regulator);
  97. if (ret) {
  98. dev_err(led_cdev->dev,
  99. "failed to disable regulator: %d\n", ret);
  100. return ret;
  101. }
  102. }
  103. priv->enabled = enable;
  104. return 0;
  105. }
  106. static void sgm3140_powerdown_timer(struct timer_list *t)
  107. {
  108. struct sgm3140 *priv = from_timer(priv, t, powerdown_timer);
  109. gpiod_set_value(priv->enable_gpio, 0);
  110. gpiod_set_value(priv->flash_gpio, 0);
  111. regulator_disable(priv->vin_regulator);
  112. priv->enabled = false;
  113. }
  114. static void sgm3140_init_flash_timeout(struct sgm3140 *priv)
  115. {
  116. struct led_classdev_flash *fled_cdev = &priv->fled_cdev;
  117. struct led_flash_setting *s;
  118. /* Init flash timeout setting */
  119. s = &fled_cdev->timeout;
  120. s->min = 1;
  121. s->max = priv->max_timeout;
  122. s->step = 1;
  123. s->val = FLASH_TIMEOUT_DEFAULT;
  124. }
  125. #if IS_ENABLED(CONFIG_V4L2_FLASH_LED_CLASS)
  126. static void sgm3140_init_v4l2_flash_config(struct sgm3140 *priv,
  127. struct v4l2_flash_config *v4l2_sd_cfg)
  128. {
  129. struct led_classdev *led_cdev = &priv->fled_cdev.led_cdev;
  130. struct led_flash_setting *s;
  131. strscpy(v4l2_sd_cfg->dev_name, led_cdev->dev->kobj.name,
  132. sizeof(v4l2_sd_cfg->dev_name));
  133. /* Init flash intensity setting */
  134. s = &v4l2_sd_cfg->intensity;
  135. s->min = 0;
  136. s->max = 1;
  137. s->step = 1;
  138. s->val = 1;
  139. }
  140. #else
  141. static void sgm3140_init_v4l2_flash_config(struct sgm3140 *priv,
  142. struct v4l2_flash_config *v4l2_sd_cfg)
  143. {
  144. }
  145. #endif
  146. static int sgm3140_probe(struct platform_device *pdev)
  147. {
  148. struct sgm3140 *priv;
  149. struct led_classdev *led_cdev;
  150. struct led_classdev_flash *fled_cdev;
  151. struct led_init_data init_data = {};
  152. struct fwnode_handle *child_node;
  153. struct v4l2_flash_config v4l2_sd_cfg = {};
  154. int ret;
  155. priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
  156. if (!priv)
  157. return -ENOMEM;
  158. priv->flash_gpio = devm_gpiod_get(&pdev->dev, "flash", GPIOD_OUT_LOW);
  159. ret = PTR_ERR_OR_ZERO(priv->flash_gpio);
  160. if (ret)
  161. return dev_err_probe(&pdev->dev, ret,
  162. "Failed to request flash gpio\n");
  163. priv->enable_gpio = devm_gpiod_get(&pdev->dev, "enable", GPIOD_OUT_LOW);
  164. ret = PTR_ERR_OR_ZERO(priv->enable_gpio);
  165. if (ret)
  166. return dev_err_probe(&pdev->dev, ret,
  167. "Failed to request enable gpio\n");
  168. priv->vin_regulator = devm_regulator_get(&pdev->dev, "vin");
  169. ret = PTR_ERR_OR_ZERO(priv->vin_regulator);
  170. if (ret)
  171. return dev_err_probe(&pdev->dev, ret,
  172. "Failed to request regulator\n");
  173. child_node = fwnode_get_next_available_child_node(pdev->dev.fwnode,
  174. NULL);
  175. if (!child_node) {
  176. dev_err(&pdev->dev,
  177. "No fwnode child node found for connected LED.\n");
  178. return -EINVAL;
  179. }
  180. ret = fwnode_property_read_u32(child_node, "flash-max-timeout-us",
  181. &priv->max_timeout);
  182. if (ret) {
  183. priv->max_timeout = FLASH_MAX_TIMEOUT_DEFAULT;
  184. dev_warn(&pdev->dev,
  185. "flash-max-timeout-us property missing\n");
  186. }
  187. /*
  188. * Set default timeout to FLASH_DEFAULT_TIMEOUT except if max_timeout
  189. * from DT is lower.
  190. */
  191. priv->timeout = min(priv->max_timeout, FLASH_TIMEOUT_DEFAULT);
  192. timer_setup(&priv->powerdown_timer, sgm3140_powerdown_timer, 0);
  193. fled_cdev = &priv->fled_cdev;
  194. led_cdev = &fled_cdev->led_cdev;
  195. fled_cdev->ops = &sgm3140_flash_ops;
  196. led_cdev->brightness_set_blocking = sgm3140_brightness_set;
  197. led_cdev->max_brightness = LED_ON;
  198. led_cdev->flags |= LED_DEV_CAP_FLASH;
  199. sgm3140_init_flash_timeout(priv);
  200. init_data.fwnode = child_node;
  201. platform_set_drvdata(pdev, priv);
  202. /* Register in the LED subsystem */
  203. ret = devm_led_classdev_flash_register_ext(&pdev->dev,
  204. fled_cdev, &init_data);
  205. if (ret) {
  206. dev_err(&pdev->dev, "Failed to register flash device: %d\n",
  207. ret);
  208. goto err;
  209. }
  210. sgm3140_init_v4l2_flash_config(priv, &v4l2_sd_cfg);
  211. /* Create V4L2 Flash subdev */
  212. priv->v4l2_flash = v4l2_flash_init(&pdev->dev,
  213. child_node,
  214. fled_cdev, NULL,
  215. &v4l2_sd_cfg);
  216. if (IS_ERR(priv->v4l2_flash)) {
  217. ret = PTR_ERR(priv->v4l2_flash);
  218. goto err;
  219. }
  220. return ret;
  221. err:
  222. fwnode_handle_put(child_node);
  223. return ret;
  224. }
  225. static int sgm3140_remove(struct platform_device *pdev)
  226. {
  227. struct sgm3140 *priv = platform_get_drvdata(pdev);
  228. del_timer_sync(&priv->powerdown_timer);
  229. v4l2_flash_release(priv->v4l2_flash);
  230. return 0;
  231. }
  232. static const struct of_device_id sgm3140_dt_match[] = {
  233. { .compatible = "sgmicro,sgm3140" },
  234. { /* sentinel */ }
  235. };
  236. MODULE_DEVICE_TABLE(of, sgm3140_dt_match);
  237. static struct platform_driver sgm3140_driver = {
  238. .probe = sgm3140_probe,
  239. .remove = sgm3140_remove,
  240. .driver = {
  241. .name = "sgm3140",
  242. .of_match_table = sgm3140_dt_match,
  243. },
  244. };
  245. module_platform_driver(sgm3140_driver);
  246. MODULE_AUTHOR("Luca Weiss <luca@z3ntu.xyz>");
  247. MODULE_DESCRIPTION("SG Micro SGM3140 charge pump LED driver");
  248. MODULE_LICENSE("GPL v2");