leds-lm3601x.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481
  1. // SPDX-License-Identifier: GPL-2.0
  2. // Flash and torch driver for Texas Instruments LM3601X LED
  3. // Flash driver chip family
  4. // Copyright (C) 2018 Texas Instruments Incorporated - https://www.ti.com/
  5. #include <linux/delay.h>
  6. #include <linux/i2c.h>
  7. #include <linux/leds.h>
  8. #include <linux/led-class-flash.h>
  9. #include <linux/module.h>
  10. #include <linux/regmap.h>
  11. #include <linux/slab.h>
  12. #define LM3601X_LED_IR 0x0
  13. #define LM3601X_LED_TORCH 0x1
  14. /* Registers */
  15. #define LM3601X_ENABLE_REG 0x01
  16. #define LM3601X_CFG_REG 0x02
  17. #define LM3601X_LED_FLASH_REG 0x03
  18. #define LM3601X_LED_TORCH_REG 0x04
  19. #define LM3601X_FLAGS_REG 0x05
  20. #define LM3601X_DEV_ID_REG 0x06
  21. #define LM3601X_SW_RESET BIT(7)
  22. /* Enable Mode bits */
  23. #define LM3601X_MODE_STANDBY 0x00
  24. #define LM3601X_MODE_IR_DRV BIT(0)
  25. #define LM3601X_MODE_TORCH BIT(1)
  26. #define LM3601X_MODE_STROBE (BIT(0) | BIT(1))
  27. #define LM3601X_STRB_EN BIT(2)
  28. #define LM3601X_STRB_EDGE_TRIG BIT(3)
  29. #define LM3601X_IVFM_EN BIT(4)
  30. #define LM36010_BOOST_LIMIT_28 BIT(5)
  31. #define LM36010_BOOST_FREQ_4MHZ BIT(6)
  32. #define LM36010_BOOST_MODE_PASS BIT(7)
  33. /* Flag Mask */
  34. #define LM3601X_FLASH_TIME_OUT BIT(0)
  35. #define LM3601X_UVLO_FAULT BIT(1)
  36. #define LM3601X_THERM_SHUTDOWN BIT(2)
  37. #define LM3601X_THERM_CURR BIT(3)
  38. #define LM36010_CURR_LIMIT BIT(4)
  39. #define LM3601X_SHORT_FAULT BIT(5)
  40. #define LM3601X_IVFM_TRIP BIT(6)
  41. #define LM36010_OVP_FAULT BIT(7)
  42. #define LM3601X_MAX_TORCH_I_UA 376000
  43. #define LM3601X_MIN_TORCH_I_UA 2400
  44. #define LM3601X_TORCH_REG_DIV 2965
  45. #define LM3601X_MAX_STROBE_I_UA 1500000
  46. #define LM3601X_MIN_STROBE_I_UA 11000
  47. #define LM3601X_STROBE_REG_DIV 11800
  48. #define LM3601X_TIMEOUT_MASK 0x1e
  49. #define LM3601X_ENABLE_MASK (LM3601X_MODE_IR_DRV | LM3601X_MODE_TORCH)
  50. #define LM3601X_LOWER_STEP_US 40000
  51. #define LM3601X_UPPER_STEP_US 200000
  52. #define LM3601X_MIN_TIMEOUT_US 40000
  53. #define LM3601X_MAX_TIMEOUT_US 1600000
  54. #define LM3601X_TIMEOUT_XOVER_US 400000
  55. enum lm3601x_type {
  56. CHIP_LM36010 = 0,
  57. CHIP_LM36011,
  58. };
  59. /**
  60. * struct lm3601x_led -
  61. * @fled_cdev: flash LED class device pointer
  62. * @client: Pointer to the I2C client
  63. * @regmap: Devices register map
  64. * @lock: Lock for reading/writing the device
  65. * @led_name: LED label for the Torch or IR LED
  66. * @flash_timeout: the timeout for the flash
  67. * @last_flag: last known flags register value
  68. * @torch_current_max: maximum current for the torch
  69. * @flash_current_max: maximum current for the flash
  70. * @max_flash_timeout: maximum timeout for the flash
  71. * @led_mode: The mode to enable either IR or Torch
  72. */
  73. struct lm3601x_led {
  74. struct led_classdev_flash fled_cdev;
  75. struct i2c_client *client;
  76. struct regmap *regmap;
  77. struct mutex lock;
  78. unsigned int flash_timeout;
  79. unsigned int last_flag;
  80. u32 torch_current_max;
  81. u32 flash_current_max;
  82. u32 max_flash_timeout;
  83. u32 led_mode;
  84. };
  85. static const struct reg_default lm3601x_regmap_defs[] = {
  86. { LM3601X_ENABLE_REG, 0x20 },
  87. { LM3601X_CFG_REG, 0x15 },
  88. { LM3601X_LED_FLASH_REG, 0x00 },
  89. { LM3601X_LED_TORCH_REG, 0x00 },
  90. };
  91. static bool lm3601x_volatile_reg(struct device *dev, unsigned int reg)
  92. {
  93. switch (reg) {
  94. case LM3601X_FLAGS_REG:
  95. return true;
  96. default:
  97. return false;
  98. }
  99. }
  100. static const struct regmap_config lm3601x_regmap = {
  101. .reg_bits = 8,
  102. .val_bits = 8,
  103. .max_register = LM3601X_DEV_ID_REG,
  104. .reg_defaults = lm3601x_regmap_defs,
  105. .num_reg_defaults = ARRAY_SIZE(lm3601x_regmap_defs),
  106. .cache_type = REGCACHE_RBTREE,
  107. .volatile_reg = lm3601x_volatile_reg,
  108. };
  109. static struct lm3601x_led *fled_cdev_to_led(struct led_classdev_flash *fled_cdev)
  110. {
  111. return container_of(fled_cdev, struct lm3601x_led, fled_cdev);
  112. }
  113. static int lm3601x_read_faults(struct lm3601x_led *led)
  114. {
  115. int flags_val;
  116. int ret;
  117. ret = regmap_read(led->regmap, LM3601X_FLAGS_REG, &flags_val);
  118. if (ret < 0)
  119. return -EIO;
  120. led->last_flag = 0;
  121. if (flags_val & LM36010_OVP_FAULT)
  122. led->last_flag |= LED_FAULT_OVER_VOLTAGE;
  123. if (flags_val & (LM3601X_THERM_SHUTDOWN | LM3601X_THERM_CURR))
  124. led->last_flag |= LED_FAULT_OVER_TEMPERATURE;
  125. if (flags_val & LM3601X_SHORT_FAULT)
  126. led->last_flag |= LED_FAULT_SHORT_CIRCUIT;
  127. if (flags_val & LM36010_CURR_LIMIT)
  128. led->last_flag |= LED_FAULT_OVER_CURRENT;
  129. if (flags_val & LM3601X_UVLO_FAULT)
  130. led->last_flag |= LED_FAULT_UNDER_VOLTAGE;
  131. if (flags_val & LM3601X_IVFM_TRIP)
  132. led->last_flag |= LED_FAULT_INPUT_VOLTAGE;
  133. if (flags_val & LM3601X_THERM_SHUTDOWN)
  134. led->last_flag |= LED_FAULT_LED_OVER_TEMPERATURE;
  135. return led->last_flag;
  136. }
  137. static int lm3601x_brightness_set(struct led_classdev *cdev,
  138. enum led_brightness brightness)
  139. {
  140. struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(cdev);
  141. struct lm3601x_led *led = fled_cdev_to_led(fled_cdev);
  142. int ret, led_mode_val;
  143. mutex_lock(&led->lock);
  144. ret = lm3601x_read_faults(led);
  145. if (ret < 0)
  146. goto out;
  147. if (led->led_mode == LM3601X_LED_TORCH)
  148. led_mode_val = LM3601X_MODE_TORCH;
  149. else
  150. led_mode_val = LM3601X_MODE_IR_DRV;
  151. if (brightness == LED_OFF) {
  152. ret = regmap_update_bits(led->regmap, LM3601X_ENABLE_REG,
  153. led_mode_val, LED_OFF);
  154. goto out;
  155. }
  156. ret = regmap_write(led->regmap, LM3601X_LED_TORCH_REG, brightness);
  157. if (ret < 0)
  158. goto out;
  159. ret = regmap_update_bits(led->regmap, LM3601X_ENABLE_REG,
  160. LM3601X_MODE_TORCH | LM3601X_MODE_IR_DRV,
  161. led_mode_val);
  162. out:
  163. mutex_unlock(&led->lock);
  164. return ret;
  165. }
  166. static int lm3601x_strobe_set(struct led_classdev_flash *fled_cdev,
  167. bool state)
  168. {
  169. struct lm3601x_led *led = fled_cdev_to_led(fled_cdev);
  170. int timeout_reg_val;
  171. int current_timeout;
  172. int ret;
  173. mutex_lock(&led->lock);
  174. ret = regmap_read(led->regmap, LM3601X_CFG_REG, &current_timeout);
  175. if (ret < 0)
  176. goto out;
  177. if (led->flash_timeout >= LM3601X_TIMEOUT_XOVER_US)
  178. timeout_reg_val = led->flash_timeout / LM3601X_UPPER_STEP_US + 0x07;
  179. else
  180. timeout_reg_val = led->flash_timeout / LM3601X_LOWER_STEP_US - 0x01;
  181. if (led->flash_timeout != current_timeout)
  182. ret = regmap_update_bits(led->regmap, LM3601X_CFG_REG,
  183. LM3601X_TIMEOUT_MASK, timeout_reg_val);
  184. if (state)
  185. ret = regmap_update_bits(led->regmap, LM3601X_ENABLE_REG,
  186. LM3601X_MODE_TORCH | LM3601X_MODE_IR_DRV,
  187. LM3601X_MODE_STROBE);
  188. else
  189. ret = regmap_update_bits(led->regmap, LM3601X_ENABLE_REG,
  190. LM3601X_MODE_STROBE, LED_OFF);
  191. ret = lm3601x_read_faults(led);
  192. out:
  193. mutex_unlock(&led->lock);
  194. return ret;
  195. }
  196. static int lm3601x_flash_brightness_set(struct led_classdev_flash *fled_cdev,
  197. u32 brightness)
  198. {
  199. struct lm3601x_led *led = fled_cdev_to_led(fled_cdev);
  200. u8 brightness_val;
  201. int ret;
  202. mutex_lock(&led->lock);
  203. ret = lm3601x_read_faults(led);
  204. if (ret < 0)
  205. goto out;
  206. if (brightness == LED_OFF) {
  207. ret = regmap_update_bits(led->regmap, LM3601X_ENABLE_REG,
  208. LM3601X_MODE_STROBE, LED_OFF);
  209. goto out;
  210. }
  211. brightness_val = brightness / LM3601X_STROBE_REG_DIV;
  212. ret = regmap_write(led->regmap, LM3601X_LED_FLASH_REG, brightness_val);
  213. out:
  214. mutex_unlock(&led->lock);
  215. return ret;
  216. }
  217. static int lm3601x_flash_timeout_set(struct led_classdev_flash *fled_cdev,
  218. u32 timeout)
  219. {
  220. struct lm3601x_led *led = fled_cdev_to_led(fled_cdev);
  221. mutex_lock(&led->lock);
  222. led->flash_timeout = timeout;
  223. mutex_unlock(&led->lock);
  224. return 0;
  225. }
  226. static int lm3601x_strobe_get(struct led_classdev_flash *fled_cdev, bool *state)
  227. {
  228. struct lm3601x_led *led = fled_cdev_to_led(fled_cdev);
  229. int strobe_state;
  230. int ret;
  231. mutex_lock(&led->lock);
  232. ret = regmap_read(led->regmap, LM3601X_ENABLE_REG, &strobe_state);
  233. if (ret < 0)
  234. goto out;
  235. *state = strobe_state & LM3601X_MODE_STROBE;
  236. out:
  237. mutex_unlock(&led->lock);
  238. return ret;
  239. }
  240. static int lm3601x_flash_fault_get(struct led_classdev_flash *fled_cdev,
  241. u32 *fault)
  242. {
  243. struct lm3601x_led *led = fled_cdev_to_led(fled_cdev);
  244. lm3601x_read_faults(led);
  245. *fault = led->last_flag;
  246. return 0;
  247. }
  248. static const struct led_flash_ops flash_ops = {
  249. .flash_brightness_set = lm3601x_flash_brightness_set,
  250. .strobe_set = lm3601x_strobe_set,
  251. .strobe_get = lm3601x_strobe_get,
  252. .timeout_set = lm3601x_flash_timeout_set,
  253. .fault_get = lm3601x_flash_fault_get,
  254. };
  255. static int lm3601x_register_leds(struct lm3601x_led *led,
  256. struct fwnode_handle *fwnode)
  257. {
  258. struct led_classdev *led_cdev;
  259. struct led_flash_setting *setting;
  260. struct led_init_data init_data = {};
  261. led->fled_cdev.ops = &flash_ops;
  262. setting = &led->fled_cdev.timeout;
  263. setting->min = LM3601X_MIN_TIMEOUT_US;
  264. setting->max = led->max_flash_timeout;
  265. setting->step = LM3601X_LOWER_STEP_US;
  266. setting->val = led->max_flash_timeout;
  267. setting = &led->fled_cdev.brightness;
  268. setting->min = LM3601X_MIN_STROBE_I_UA;
  269. setting->max = led->flash_current_max;
  270. setting->step = LM3601X_TORCH_REG_DIV;
  271. setting->val = led->flash_current_max;
  272. led_cdev = &led->fled_cdev.led_cdev;
  273. led_cdev->brightness_set_blocking = lm3601x_brightness_set;
  274. led_cdev->max_brightness = DIV_ROUND_UP(led->torch_current_max,
  275. LM3601X_TORCH_REG_DIV);
  276. led_cdev->flags |= LED_DEV_CAP_FLASH;
  277. init_data.fwnode = fwnode;
  278. init_data.devicename = led->client->name;
  279. init_data.default_label = (led->led_mode == LM3601X_LED_TORCH) ?
  280. "torch" : "infrared";
  281. return devm_led_classdev_flash_register_ext(&led->client->dev,
  282. &led->fled_cdev, &init_data);
  283. }
  284. static int lm3601x_parse_node(struct lm3601x_led *led,
  285. struct fwnode_handle **fwnode)
  286. {
  287. struct fwnode_handle *child = NULL;
  288. int ret = -ENODEV;
  289. child = device_get_next_child_node(&led->client->dev, child);
  290. if (!child) {
  291. dev_err(&led->client->dev, "No LED Child node\n");
  292. return ret;
  293. }
  294. ret = fwnode_property_read_u32(child, "reg", &led->led_mode);
  295. if (ret) {
  296. dev_err(&led->client->dev, "reg DT property missing\n");
  297. goto out_err;
  298. }
  299. if (led->led_mode > LM3601X_LED_TORCH ||
  300. led->led_mode < LM3601X_LED_IR) {
  301. dev_warn(&led->client->dev, "Invalid led mode requested\n");
  302. ret = -EINVAL;
  303. goto out_err;
  304. }
  305. ret = fwnode_property_read_u32(child, "led-max-microamp",
  306. &led->torch_current_max);
  307. if (ret) {
  308. dev_warn(&led->client->dev,
  309. "led-max-microamp DT property missing\n");
  310. goto out_err;
  311. }
  312. ret = fwnode_property_read_u32(child, "flash-max-microamp",
  313. &led->flash_current_max);
  314. if (ret) {
  315. dev_warn(&led->client->dev,
  316. "flash-max-microamp DT property missing\n");
  317. goto out_err;
  318. }
  319. ret = fwnode_property_read_u32(child, "flash-max-timeout-us",
  320. &led->max_flash_timeout);
  321. if (ret) {
  322. dev_warn(&led->client->dev,
  323. "flash-max-timeout-us DT property missing\n");
  324. goto out_err;
  325. }
  326. *fwnode = child;
  327. out_err:
  328. fwnode_handle_put(child);
  329. return ret;
  330. }
  331. static int lm3601x_probe(struct i2c_client *client)
  332. {
  333. struct lm3601x_led *led;
  334. struct fwnode_handle *fwnode;
  335. int ret;
  336. led = devm_kzalloc(&client->dev, sizeof(*led), GFP_KERNEL);
  337. if (!led)
  338. return -ENOMEM;
  339. led->client = client;
  340. i2c_set_clientdata(client, led);
  341. ret = lm3601x_parse_node(led, &fwnode);
  342. if (ret)
  343. return -ENODEV;
  344. led->regmap = devm_regmap_init_i2c(client, &lm3601x_regmap);
  345. if (IS_ERR(led->regmap)) {
  346. ret = PTR_ERR(led->regmap);
  347. dev_err(&client->dev,
  348. "Failed to allocate register map: %d\n", ret);
  349. return ret;
  350. }
  351. mutex_init(&led->lock);
  352. return lm3601x_register_leds(led, fwnode);
  353. }
  354. static int lm3601x_remove(struct i2c_client *client)
  355. {
  356. struct lm3601x_led *led = i2c_get_clientdata(client);
  357. mutex_destroy(&led->lock);
  358. return regmap_update_bits(led->regmap, LM3601X_ENABLE_REG,
  359. LM3601X_ENABLE_MASK,
  360. LM3601X_MODE_STANDBY);
  361. }
  362. static const struct i2c_device_id lm3601x_id[] = {
  363. { "LM36010", CHIP_LM36010 },
  364. { "LM36011", CHIP_LM36011 },
  365. { }
  366. };
  367. MODULE_DEVICE_TABLE(i2c, lm3601x_id);
  368. static const struct of_device_id of_lm3601x_leds_match[] = {
  369. { .compatible = "ti,lm36010", },
  370. { .compatible = "ti,lm36011", },
  371. { }
  372. };
  373. MODULE_DEVICE_TABLE(of, of_lm3601x_leds_match);
  374. static struct i2c_driver lm3601x_i2c_driver = {
  375. .driver = {
  376. .name = "lm3601x",
  377. .of_match_table = of_lm3601x_leds_match,
  378. },
  379. .probe_new = lm3601x_probe,
  380. .remove = lm3601x_remove,
  381. .id_table = lm3601x_id,
  382. };
  383. module_i2c_driver(lm3601x_i2c_driver);
  384. MODULE_DESCRIPTION("Texas Instruments Flash Lighting driver for LM3601X");
  385. MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");
  386. MODULE_LICENSE("GPL v2");