leds-ktd2692.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * LED driver : leds-ktd2692.c
  4. *
  5. * Copyright (C) 2015 Samsung Electronics
  6. * Ingi Kim <ingi2.kim@samsung.com>
  7. */
  8. #include <linux/delay.h>
  9. #include <linux/err.h>
  10. #include <linux/gpio/consumer.h>
  11. #include <linux/led-class-flash.h>
  12. #include <linux/module.h>
  13. #include <linux/mutex.h>
  14. #include <linux/of.h>
  15. #include <linux/platform_device.h>
  16. #include <linux/regulator/consumer.h>
  17. /* Value related the movie mode */
  18. #define KTD2692_MOVIE_MODE_CURRENT_LEVELS 16
  19. #define KTD2692_MM_TO_FL_RATIO(x) ((x) / 3)
  20. #define KTD2692_MM_MIN_CURR_THRESHOLD_SCALE 8
  21. /* Value related the flash mode */
  22. #define KTD2692_FLASH_MODE_TIMEOUT_LEVELS 8
  23. #define KTD2692_FLASH_MODE_TIMEOUT_DISABLE 0
  24. #define KTD2692_FLASH_MODE_CURR_PERCENT(x) (((x) * 16) / 100)
  25. /* Macro for getting offset of flash timeout */
  26. #define GET_TIMEOUT_OFFSET(timeout, step) ((timeout) / (step))
  27. /* Base register address */
  28. #define KTD2692_REG_LVP_BASE 0x00
  29. #define KTD2692_REG_FLASH_TIMEOUT_BASE 0x20
  30. #define KTD2692_REG_MM_MIN_CURR_THRESHOLD_BASE 0x40
  31. #define KTD2692_REG_MOVIE_CURRENT_BASE 0x60
  32. #define KTD2692_REG_FLASH_CURRENT_BASE 0x80
  33. #define KTD2692_REG_MODE_BASE 0xA0
  34. /* Set bit coding time for expresswire interface */
  35. #define KTD2692_TIME_RESET_US 700
  36. #define KTD2692_TIME_DATA_START_TIME_US 10
  37. #define KTD2692_TIME_HIGH_END_OF_DATA_US 350
  38. #define KTD2692_TIME_LOW_END_OF_DATA_US 10
  39. #define KTD2692_TIME_SHORT_BITSET_US 4
  40. #define KTD2692_TIME_LONG_BITSET_US 12
  41. /* KTD2692 default length of name */
  42. #define KTD2692_NAME_LENGTH 20
  43. enum ktd2692_bitset {
  44. KTD2692_LOW = 0,
  45. KTD2692_HIGH,
  46. };
  47. /* Movie / Flash Mode Control */
  48. enum ktd2692_led_mode {
  49. KTD2692_MODE_DISABLE = 0, /* default */
  50. KTD2692_MODE_MOVIE,
  51. KTD2692_MODE_FLASH,
  52. };
  53. struct ktd2692_led_config_data {
  54. /* maximum LED current in movie mode */
  55. u32 movie_max_microamp;
  56. /* maximum LED current in flash mode */
  57. u32 flash_max_microamp;
  58. /* maximum flash timeout */
  59. u32 flash_max_timeout;
  60. /* max LED brightness level */
  61. enum led_brightness max_brightness;
  62. };
  63. struct ktd2692_context {
  64. /* Related LED Flash class device */
  65. struct led_classdev_flash fled_cdev;
  66. /* secures access to the device */
  67. struct mutex lock;
  68. struct regulator *regulator;
  69. struct gpio_desc *aux_gpio;
  70. struct gpio_desc *ctrl_gpio;
  71. enum ktd2692_led_mode mode;
  72. enum led_brightness torch_brightness;
  73. };
  74. static struct ktd2692_context *fled_cdev_to_led(
  75. struct led_classdev_flash *fled_cdev)
  76. {
  77. return container_of(fled_cdev, struct ktd2692_context, fled_cdev);
  78. }
  79. static void ktd2692_expresswire_start(struct ktd2692_context *led)
  80. {
  81. gpiod_direction_output(led->ctrl_gpio, KTD2692_HIGH);
  82. udelay(KTD2692_TIME_DATA_START_TIME_US);
  83. }
  84. static void ktd2692_expresswire_reset(struct ktd2692_context *led)
  85. {
  86. gpiod_direction_output(led->ctrl_gpio, KTD2692_LOW);
  87. udelay(KTD2692_TIME_RESET_US);
  88. }
  89. static void ktd2692_expresswire_end(struct ktd2692_context *led)
  90. {
  91. gpiod_direction_output(led->ctrl_gpio, KTD2692_LOW);
  92. udelay(KTD2692_TIME_LOW_END_OF_DATA_US);
  93. gpiod_direction_output(led->ctrl_gpio, KTD2692_HIGH);
  94. udelay(KTD2692_TIME_HIGH_END_OF_DATA_US);
  95. }
  96. static void ktd2692_expresswire_set_bit(struct ktd2692_context *led, bool bit)
  97. {
  98. /*
  99. * The Low Bit(0) and High Bit(1) is based on a time detection
  100. * algorithm between time low and time high
  101. * Time_(L_LB) : Low time of the Low Bit(0)
  102. * Time_(H_LB) : High time of the LOW Bit(0)
  103. * Time_(L_HB) : Low time of the High Bit(1)
  104. * Time_(H_HB) : High time of the High Bit(1)
  105. *
  106. * It can be simplified to:
  107. * Low Bit(0) : 2 * Time_(H_LB) < Time_(L_LB)
  108. * High Bit(1) : 2 * Time_(L_HB) < Time_(H_HB)
  109. * HIGH ___ ____ _.. _________ ___
  110. * |_________| |_.. |____| |__|
  111. * LOW <L_LB> <H_LB> <L_HB> <H_HB>
  112. * [ Low Bit (0) ] [ High Bit(1) ]
  113. */
  114. if (bit) {
  115. gpiod_direction_output(led->ctrl_gpio, KTD2692_LOW);
  116. udelay(KTD2692_TIME_SHORT_BITSET_US);
  117. gpiod_direction_output(led->ctrl_gpio, KTD2692_HIGH);
  118. udelay(KTD2692_TIME_LONG_BITSET_US);
  119. } else {
  120. gpiod_direction_output(led->ctrl_gpio, KTD2692_LOW);
  121. udelay(KTD2692_TIME_LONG_BITSET_US);
  122. gpiod_direction_output(led->ctrl_gpio, KTD2692_HIGH);
  123. udelay(KTD2692_TIME_SHORT_BITSET_US);
  124. }
  125. }
  126. static void ktd2692_expresswire_write(struct ktd2692_context *led, u8 value)
  127. {
  128. int i;
  129. ktd2692_expresswire_start(led);
  130. for (i = 7; i >= 0; i--)
  131. ktd2692_expresswire_set_bit(led, value & BIT(i));
  132. ktd2692_expresswire_end(led);
  133. }
  134. static int ktd2692_led_brightness_set(struct led_classdev *led_cdev,
  135. enum led_brightness brightness)
  136. {
  137. struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev);
  138. struct ktd2692_context *led = fled_cdev_to_led(fled_cdev);
  139. mutex_lock(&led->lock);
  140. if (brightness == LED_OFF) {
  141. led->mode = KTD2692_MODE_DISABLE;
  142. gpiod_direction_output(led->aux_gpio, KTD2692_LOW);
  143. } else {
  144. ktd2692_expresswire_write(led, brightness |
  145. KTD2692_REG_MOVIE_CURRENT_BASE);
  146. led->mode = KTD2692_MODE_MOVIE;
  147. }
  148. ktd2692_expresswire_write(led, led->mode | KTD2692_REG_MODE_BASE);
  149. mutex_unlock(&led->lock);
  150. return 0;
  151. }
  152. static int ktd2692_led_flash_strobe_set(struct led_classdev_flash *fled_cdev,
  153. bool state)
  154. {
  155. struct ktd2692_context *led = fled_cdev_to_led(fled_cdev);
  156. struct led_flash_setting *timeout = &fled_cdev->timeout;
  157. u32 flash_tm_reg;
  158. mutex_lock(&led->lock);
  159. if (state) {
  160. flash_tm_reg = GET_TIMEOUT_OFFSET(timeout->val, timeout->step);
  161. ktd2692_expresswire_write(led, flash_tm_reg
  162. | KTD2692_REG_FLASH_TIMEOUT_BASE);
  163. led->mode = KTD2692_MODE_FLASH;
  164. gpiod_direction_output(led->aux_gpio, KTD2692_HIGH);
  165. } else {
  166. led->mode = KTD2692_MODE_DISABLE;
  167. gpiod_direction_output(led->aux_gpio, KTD2692_LOW);
  168. }
  169. ktd2692_expresswire_write(led, led->mode | KTD2692_REG_MODE_BASE);
  170. fled_cdev->led_cdev.brightness = LED_OFF;
  171. led->mode = KTD2692_MODE_DISABLE;
  172. mutex_unlock(&led->lock);
  173. return 0;
  174. }
  175. static int ktd2692_led_flash_timeout_set(struct led_classdev_flash *fled_cdev,
  176. u32 timeout)
  177. {
  178. return 0;
  179. }
  180. static void ktd2692_init_movie_current_max(struct ktd2692_led_config_data *cfg)
  181. {
  182. u32 offset, step;
  183. u32 movie_current_microamp;
  184. offset = KTD2692_MOVIE_MODE_CURRENT_LEVELS;
  185. step = KTD2692_MM_TO_FL_RATIO(cfg->flash_max_microamp)
  186. / KTD2692_MOVIE_MODE_CURRENT_LEVELS;
  187. do {
  188. movie_current_microamp = step * offset;
  189. offset--;
  190. } while ((movie_current_microamp > cfg->movie_max_microamp) &&
  191. (offset > 0));
  192. cfg->max_brightness = offset;
  193. }
  194. static void ktd2692_init_flash_timeout(struct led_classdev_flash *fled_cdev,
  195. struct ktd2692_led_config_data *cfg)
  196. {
  197. struct led_flash_setting *setting;
  198. setting = &fled_cdev->timeout;
  199. setting->min = KTD2692_FLASH_MODE_TIMEOUT_DISABLE;
  200. setting->max = cfg->flash_max_timeout;
  201. setting->step = cfg->flash_max_timeout
  202. / (KTD2692_FLASH_MODE_TIMEOUT_LEVELS - 1);
  203. setting->val = cfg->flash_max_timeout;
  204. }
  205. static void ktd2692_setup(struct ktd2692_context *led)
  206. {
  207. led->mode = KTD2692_MODE_DISABLE;
  208. ktd2692_expresswire_reset(led);
  209. gpiod_direction_output(led->aux_gpio, KTD2692_LOW);
  210. ktd2692_expresswire_write(led, (KTD2692_MM_MIN_CURR_THRESHOLD_SCALE - 1)
  211. | KTD2692_REG_MM_MIN_CURR_THRESHOLD_BASE);
  212. ktd2692_expresswire_write(led, KTD2692_FLASH_MODE_CURR_PERCENT(45)
  213. | KTD2692_REG_FLASH_CURRENT_BASE);
  214. }
  215. static void regulator_disable_action(void *_data)
  216. {
  217. struct device *dev = _data;
  218. struct ktd2692_context *led = dev_get_drvdata(dev);
  219. int ret;
  220. ret = regulator_disable(led->regulator);
  221. if (ret)
  222. dev_err(dev, "Failed to disable supply: %d\n", ret);
  223. }
  224. static int ktd2692_parse_dt(struct ktd2692_context *led, struct device *dev,
  225. struct ktd2692_led_config_data *cfg)
  226. {
  227. struct device_node *np = dev_of_node(dev);
  228. struct device_node *child_node;
  229. int ret;
  230. if (!dev_of_node(dev))
  231. return -ENXIO;
  232. led->ctrl_gpio = devm_gpiod_get(dev, "ctrl", GPIOD_ASIS);
  233. ret = PTR_ERR_OR_ZERO(led->ctrl_gpio);
  234. if (ret) {
  235. dev_err(dev, "cannot get ctrl-gpios %d\n", ret);
  236. return ret;
  237. }
  238. led->aux_gpio = devm_gpiod_get(dev, "aux", GPIOD_ASIS);
  239. ret = PTR_ERR_OR_ZERO(led->aux_gpio);
  240. if (ret) {
  241. dev_err(dev, "cannot get aux-gpios %d\n", ret);
  242. return ret;
  243. }
  244. led->regulator = devm_regulator_get(dev, "vin");
  245. if (IS_ERR(led->regulator))
  246. led->regulator = NULL;
  247. if (led->regulator) {
  248. ret = regulator_enable(led->regulator);
  249. if (ret) {
  250. dev_err(dev, "Failed to enable supply: %d\n", ret);
  251. } else {
  252. ret = devm_add_action_or_reset(dev,
  253. regulator_disable_action, dev);
  254. if (ret)
  255. return ret;
  256. }
  257. }
  258. child_node = of_get_next_available_child(np, NULL);
  259. if (!child_node) {
  260. dev_err(dev, "No DT child node found for connected LED.\n");
  261. return -EINVAL;
  262. }
  263. led->fled_cdev.led_cdev.name =
  264. of_get_property(child_node, "label", NULL) ? : child_node->name;
  265. ret = of_property_read_u32(child_node, "led-max-microamp",
  266. &cfg->movie_max_microamp);
  267. if (ret) {
  268. dev_err(dev, "failed to parse led-max-microamp\n");
  269. goto err_parse_dt;
  270. }
  271. ret = of_property_read_u32(child_node, "flash-max-microamp",
  272. &cfg->flash_max_microamp);
  273. if (ret) {
  274. dev_err(dev, "failed to parse flash-max-microamp\n");
  275. goto err_parse_dt;
  276. }
  277. ret = of_property_read_u32(child_node, "flash-max-timeout-us",
  278. &cfg->flash_max_timeout);
  279. if (ret) {
  280. dev_err(dev, "failed to parse flash-max-timeout-us\n");
  281. goto err_parse_dt;
  282. }
  283. err_parse_dt:
  284. of_node_put(child_node);
  285. return ret;
  286. }
  287. static const struct led_flash_ops flash_ops = {
  288. .strobe_set = ktd2692_led_flash_strobe_set,
  289. .timeout_set = ktd2692_led_flash_timeout_set,
  290. };
  291. static int ktd2692_probe(struct platform_device *pdev)
  292. {
  293. struct ktd2692_context *led;
  294. struct led_classdev *led_cdev;
  295. struct led_classdev_flash *fled_cdev;
  296. struct ktd2692_led_config_data led_cfg;
  297. int ret;
  298. led = devm_kzalloc(&pdev->dev, sizeof(*led), GFP_KERNEL);
  299. if (!led)
  300. return -ENOMEM;
  301. fled_cdev = &led->fled_cdev;
  302. led_cdev = &fled_cdev->led_cdev;
  303. ret = ktd2692_parse_dt(led, &pdev->dev, &led_cfg);
  304. if (ret)
  305. return ret;
  306. ktd2692_init_flash_timeout(fled_cdev, &led_cfg);
  307. ktd2692_init_movie_current_max(&led_cfg);
  308. fled_cdev->ops = &flash_ops;
  309. led_cdev->max_brightness = led_cfg.max_brightness;
  310. led_cdev->brightness_set_blocking = ktd2692_led_brightness_set;
  311. led_cdev->flags |= LED_CORE_SUSPENDRESUME | LED_DEV_CAP_FLASH;
  312. mutex_init(&led->lock);
  313. platform_set_drvdata(pdev, led);
  314. ret = led_classdev_flash_register(&pdev->dev, fled_cdev);
  315. if (ret) {
  316. dev_err(&pdev->dev, "can't register LED %s\n", led_cdev->name);
  317. mutex_destroy(&led->lock);
  318. return ret;
  319. }
  320. ktd2692_setup(led);
  321. return 0;
  322. }
  323. static int ktd2692_remove(struct platform_device *pdev)
  324. {
  325. struct ktd2692_context *led = platform_get_drvdata(pdev);
  326. led_classdev_flash_unregister(&led->fled_cdev);
  327. mutex_destroy(&led->lock);
  328. return 0;
  329. }
  330. static const struct of_device_id ktd2692_match[] = {
  331. { .compatible = "kinetic,ktd2692", },
  332. { /* sentinel */ },
  333. };
  334. MODULE_DEVICE_TABLE(of, ktd2692_match);
  335. static struct platform_driver ktd2692_driver = {
  336. .driver = {
  337. .name = "ktd2692",
  338. .of_match_table = ktd2692_match,
  339. },
  340. .probe = ktd2692_probe,
  341. .remove = ktd2692_remove,
  342. };
  343. module_platform_driver(ktd2692_driver);
  344. MODULE_AUTHOR("Ingi Kim <ingi2.kim@samsung.com>");
  345. MODULE_DESCRIPTION("Kinetic KTD2692 LED driver");
  346. MODULE_LICENSE("GPL v2");