leds-lm3692x.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535
  1. // SPDX-License-Identifier: GPL-2.0
  2. // TI LM3692x LED chip family driver
  3. // Copyright (C) 2017-18 Texas Instruments Incorporated - https://www.ti.com/
  4. #include <linux/gpio/consumer.h>
  5. #include <linux/i2c.h>
  6. #include <linux/init.h>
  7. #include <linux/leds.h>
  8. #include <linux/log2.h>
  9. #include <linux/module.h>
  10. #include <linux/mutex.h>
  11. #include <linux/of.h>
  12. #include <linux/of_gpio.h>
  13. #include <linux/regmap.h>
  14. #include <linux/regulator/consumer.h>
  15. #include <linux/slab.h>
  16. #define LM36922_MODEL 0
  17. #define LM36923_MODEL 1
  18. #define LM3692X_REV 0x0
  19. #define LM3692X_RESET 0x1
  20. #define LM3692X_EN 0x10
  21. #define LM3692X_BRT_CTRL 0x11
  22. #define LM3692X_PWM_CTRL 0x12
  23. #define LM3692X_BOOST_CTRL 0x13
  24. #define LM3692X_AUTO_FREQ_HI 0x15
  25. #define LM3692X_AUTO_FREQ_LO 0x16
  26. #define LM3692X_BL_ADJ_THRESH 0x17
  27. #define LM3692X_BRT_LSB 0x18
  28. #define LM3692X_BRT_MSB 0x19
  29. #define LM3692X_FAULT_CTRL 0x1e
  30. #define LM3692X_FAULT_FLAGS 0x1f
  31. #define LM3692X_SW_RESET BIT(0)
  32. #define LM3692X_DEVICE_EN BIT(0)
  33. #define LM3692X_LED1_EN BIT(1)
  34. #define LM3692X_LED2_EN BIT(2)
  35. #define LM36923_LED3_EN BIT(3)
  36. #define LM3692X_ENABLE_MASK (LM3692X_DEVICE_EN | LM3692X_LED1_EN | \
  37. LM3692X_LED2_EN | LM36923_LED3_EN)
  38. /* Brightness Control Bits */
  39. #define LM3692X_BL_ADJ_POL BIT(0)
  40. #define LM3692X_RAMP_RATE_125us 0x00
  41. #define LM3692X_RAMP_RATE_250us BIT(1)
  42. #define LM3692X_RAMP_RATE_500us BIT(2)
  43. #define LM3692X_RAMP_RATE_1ms (BIT(1) | BIT(2))
  44. #define LM3692X_RAMP_RATE_2ms BIT(3)
  45. #define LM3692X_RAMP_RATE_4ms (BIT(3) | BIT(1))
  46. #define LM3692X_RAMP_RATE_8ms (BIT(2) | BIT(3))
  47. #define LM3692X_RAMP_RATE_16ms (BIT(1) | BIT(2) | BIT(3))
  48. #define LM3692X_RAMP_EN BIT(4)
  49. #define LM3692X_BRHT_MODE_REG 0x00
  50. #define LM3692X_BRHT_MODE_PWM BIT(5)
  51. #define LM3692X_BRHT_MODE_MULTI_RAMP BIT(6)
  52. #define LM3692X_BRHT_MODE_RAMP_MULTI (BIT(5) | BIT(6))
  53. #define LM3692X_MAP_MODE_EXP BIT(7)
  54. /* PWM Register Bits */
  55. #define LM3692X_PWM_FILTER_100 BIT(0)
  56. #define LM3692X_PWM_FILTER_150 BIT(1)
  57. #define LM3692X_PWM_FILTER_200 (BIT(0) | BIT(1))
  58. #define LM3692X_PWM_HYSTER_1LSB BIT(2)
  59. #define LM3692X_PWM_HYSTER_2LSB BIT(3)
  60. #define LM3692X_PWM_HYSTER_3LSB (BIT(3) | BIT(2))
  61. #define LM3692X_PWM_HYSTER_4LSB BIT(4)
  62. #define LM3692X_PWM_HYSTER_5LSB (BIT(4) | BIT(2))
  63. #define LM3692X_PWM_HYSTER_6LSB (BIT(4) | BIT(3))
  64. #define LM3692X_PWM_POLARITY BIT(5)
  65. #define LM3692X_PWM_SAMP_4MHZ BIT(6)
  66. #define LM3692X_PWM_SAMP_24MHZ BIT(7)
  67. /* Boost Control Bits */
  68. #define LM3692X_OCP_PROT_1A BIT(0)
  69. #define LM3692X_OCP_PROT_1_25A BIT(1)
  70. #define LM3692X_OCP_PROT_1_5A (BIT(0) | BIT(1))
  71. #define LM3692X_OVP_21V BIT(2)
  72. #define LM3692X_OVP_25V BIT(3)
  73. #define LM3692X_OVP_29V (BIT(2) | BIT(3))
  74. #define LM3692X_MIN_IND_22UH BIT(4)
  75. #define LM3692X_BOOST_SW_1MHZ BIT(5)
  76. #define LM3692X_BOOST_SW_NO_SHIFT BIT(6)
  77. /* Fault Control Bits */
  78. #define LM3692X_FAULT_CTRL_OVP BIT(0)
  79. #define LM3692X_FAULT_CTRL_OCP BIT(1)
  80. #define LM3692X_FAULT_CTRL_TSD BIT(2)
  81. #define LM3692X_FAULT_CTRL_OPEN BIT(3)
  82. /* Fault Flag Bits */
  83. #define LM3692X_FAULT_FLAG_OVP BIT(0)
  84. #define LM3692X_FAULT_FLAG_OCP BIT(1)
  85. #define LM3692X_FAULT_FLAG_TSD BIT(2)
  86. #define LM3692X_FAULT_FLAG_SHRT BIT(3)
  87. #define LM3692X_FAULT_FLAG_OPEN BIT(4)
  88. /**
  89. * struct lm3692x_led -
  90. * @lock - Lock for reading/writing the device
  91. * @client - Pointer to the I2C client
  92. * @led_dev - LED class device pointer
  93. * @regmap - Devices register map
  94. * @enable_gpio - VDDIO/EN gpio to enable communication interface
  95. * @regulator - LED supply regulator pointer
  96. * @led_enable - LED sync to be enabled
  97. * @model_id - Current device model ID enumerated
  98. */
  99. struct lm3692x_led {
  100. struct mutex lock;
  101. struct i2c_client *client;
  102. struct led_classdev led_dev;
  103. struct regmap *regmap;
  104. struct gpio_desc *enable_gpio;
  105. struct regulator *regulator;
  106. int led_enable;
  107. int model_id;
  108. u8 boost_ctrl, brightness_ctrl;
  109. bool enabled;
  110. };
  111. static const struct reg_default lm3692x_reg_defs[] = {
  112. {LM3692X_EN, 0xf},
  113. {LM3692X_BRT_CTRL, 0x61},
  114. {LM3692X_PWM_CTRL, 0x73},
  115. {LM3692X_BOOST_CTRL, 0x6f},
  116. {LM3692X_AUTO_FREQ_HI, 0x0},
  117. {LM3692X_AUTO_FREQ_LO, 0x0},
  118. {LM3692X_BL_ADJ_THRESH, 0x0},
  119. {LM3692X_BRT_LSB, 0x7},
  120. {LM3692X_BRT_MSB, 0xff},
  121. {LM3692X_FAULT_CTRL, 0x7},
  122. };
  123. static const struct regmap_config lm3692x_regmap_config = {
  124. .reg_bits = 8,
  125. .val_bits = 8,
  126. .max_register = LM3692X_FAULT_FLAGS,
  127. .reg_defaults = lm3692x_reg_defs,
  128. .num_reg_defaults = ARRAY_SIZE(lm3692x_reg_defs),
  129. .cache_type = REGCACHE_RBTREE,
  130. };
  131. static int lm3692x_fault_check(struct lm3692x_led *led)
  132. {
  133. int ret;
  134. unsigned int read_buf;
  135. ret = regmap_read(led->regmap, LM3692X_FAULT_FLAGS, &read_buf);
  136. if (ret)
  137. return ret;
  138. if (read_buf)
  139. dev_err(&led->client->dev, "Detected a fault 0x%X\n", read_buf);
  140. /* The first read may clear the fault. Check again to see if the fault
  141. * still exits and return that value.
  142. */
  143. regmap_read(led->regmap, LM3692X_FAULT_FLAGS, &read_buf);
  144. if (read_buf)
  145. dev_err(&led->client->dev, "Second read of fault flags 0x%X\n",
  146. read_buf);
  147. return read_buf;
  148. }
  149. static int lm3692x_leds_enable(struct lm3692x_led *led)
  150. {
  151. int enable_state;
  152. int ret, reg_ret;
  153. if (led->enabled)
  154. return 0;
  155. if (led->regulator) {
  156. ret = regulator_enable(led->regulator);
  157. if (ret) {
  158. dev_err(&led->client->dev,
  159. "Failed to enable regulator: %d\n", ret);
  160. return ret;
  161. }
  162. }
  163. if (led->enable_gpio)
  164. gpiod_direction_output(led->enable_gpio, 1);
  165. ret = lm3692x_fault_check(led);
  166. if (ret) {
  167. dev_err(&led->client->dev, "Cannot read/clear faults: %d\n",
  168. ret);
  169. goto out;
  170. }
  171. ret = regmap_write(led->regmap, LM3692X_BRT_CTRL, 0x00);
  172. if (ret)
  173. goto out;
  174. /*
  175. * For glitch free operation, the following data should
  176. * only be written while LEDx enable bits are 0 and the device enable
  177. * bit is set to 1.
  178. * per Section 7.5.14 of the data sheet
  179. */
  180. ret = regmap_write(led->regmap, LM3692X_EN, LM3692X_DEVICE_EN);
  181. if (ret)
  182. goto out;
  183. /* Set the brightness to 0 so when enabled the LEDs do not come
  184. * on with full brightness.
  185. */
  186. ret = regmap_write(led->regmap, LM3692X_BRT_MSB, 0);
  187. if (ret)
  188. goto out;
  189. ret = regmap_write(led->regmap, LM3692X_BRT_LSB, 0);
  190. if (ret)
  191. goto out;
  192. ret = regmap_write(led->regmap, LM3692X_PWM_CTRL,
  193. LM3692X_PWM_FILTER_100 | LM3692X_PWM_SAMP_24MHZ);
  194. if (ret)
  195. goto out;
  196. ret = regmap_write(led->regmap, LM3692X_BOOST_CTRL, led->boost_ctrl);
  197. if (ret)
  198. goto out;
  199. ret = regmap_write(led->regmap, LM3692X_AUTO_FREQ_HI, 0x00);
  200. if (ret)
  201. goto out;
  202. ret = regmap_write(led->regmap, LM3692X_AUTO_FREQ_LO, 0x00);
  203. if (ret)
  204. goto out;
  205. ret = regmap_write(led->regmap, LM3692X_BL_ADJ_THRESH, 0x00);
  206. if (ret)
  207. goto out;
  208. ret = regmap_write(led->regmap, LM3692X_BRT_CTRL,
  209. LM3692X_BL_ADJ_POL | LM3692X_RAMP_EN);
  210. if (ret)
  211. goto out;
  212. switch (led->led_enable) {
  213. case 0:
  214. default:
  215. if (led->model_id == LM36923_MODEL)
  216. enable_state = LM3692X_LED1_EN | LM3692X_LED2_EN |
  217. LM36923_LED3_EN;
  218. else
  219. enable_state = LM3692X_LED1_EN | LM3692X_LED2_EN;
  220. break;
  221. case 1:
  222. enable_state = LM3692X_LED1_EN;
  223. break;
  224. case 2:
  225. enable_state = LM3692X_LED2_EN;
  226. break;
  227. case 3:
  228. if (led->model_id == LM36923_MODEL) {
  229. enable_state = LM36923_LED3_EN;
  230. break;
  231. }
  232. ret = -EINVAL;
  233. dev_err(&led->client->dev,
  234. "LED3 sync not available on this device\n");
  235. goto out;
  236. }
  237. ret = regmap_update_bits(led->regmap, LM3692X_EN, LM3692X_ENABLE_MASK,
  238. enable_state | LM3692X_DEVICE_EN);
  239. led->enabled = true;
  240. return ret;
  241. out:
  242. dev_err(&led->client->dev, "Fail writing initialization values\n");
  243. if (led->enable_gpio)
  244. gpiod_direction_output(led->enable_gpio, 0);
  245. if (led->regulator) {
  246. reg_ret = regulator_disable(led->regulator);
  247. if (reg_ret)
  248. dev_err(&led->client->dev,
  249. "Failed to disable regulator: %d\n", reg_ret);
  250. }
  251. return ret;
  252. }
  253. static int lm3692x_leds_disable(struct lm3692x_led *led)
  254. {
  255. int ret;
  256. if (!led->enabled)
  257. return 0;
  258. ret = regmap_update_bits(led->regmap, LM3692X_EN, LM3692X_DEVICE_EN, 0);
  259. if (ret) {
  260. dev_err(&led->client->dev, "Failed to disable regulator: %d\n",
  261. ret);
  262. return ret;
  263. }
  264. if (led->enable_gpio)
  265. gpiod_direction_output(led->enable_gpio, 0);
  266. if (led->regulator) {
  267. ret = regulator_disable(led->regulator);
  268. if (ret)
  269. dev_err(&led->client->dev,
  270. "Failed to disable regulator: %d\n", ret);
  271. }
  272. led->enabled = false;
  273. return ret;
  274. }
  275. static int lm3692x_brightness_set(struct led_classdev *led_cdev,
  276. enum led_brightness brt_val)
  277. {
  278. struct lm3692x_led *led =
  279. container_of(led_cdev, struct lm3692x_led, led_dev);
  280. int ret;
  281. int led_brightness_lsb = (brt_val >> 5);
  282. mutex_lock(&led->lock);
  283. if (brt_val == 0) {
  284. ret = lm3692x_leds_disable(led);
  285. goto out;
  286. } else {
  287. lm3692x_leds_enable(led);
  288. }
  289. ret = lm3692x_fault_check(led);
  290. if (ret) {
  291. dev_err(&led->client->dev, "Cannot read/clear faults: %d\n",
  292. ret);
  293. goto out;
  294. }
  295. ret = regmap_write(led->regmap, LM3692X_BRT_MSB, brt_val);
  296. if (ret) {
  297. dev_err(&led->client->dev, "Cannot write MSB: %d\n", ret);
  298. goto out;
  299. }
  300. ret = regmap_write(led->regmap, LM3692X_BRT_LSB, led_brightness_lsb);
  301. if (ret) {
  302. dev_err(&led->client->dev, "Cannot write LSB: %d\n", ret);
  303. goto out;
  304. }
  305. out:
  306. mutex_unlock(&led->lock);
  307. return ret;
  308. }
  309. static enum led_brightness lm3692x_max_brightness(struct lm3692x_led *led,
  310. u32 max_cur)
  311. {
  312. u32 max_code;
  313. /* see p.12 of LM36922 data sheet for brightness formula */
  314. max_code = ((max_cur * 1000) - 37806) / 12195;
  315. if (max_code > 0x7FF)
  316. max_code = 0x7FF;
  317. return max_code >> 3;
  318. }
  319. static int lm3692x_probe_dt(struct lm3692x_led *led)
  320. {
  321. struct fwnode_handle *child = NULL;
  322. struct led_init_data init_data = {};
  323. u32 ovp, max_cur;
  324. int ret;
  325. led->enable_gpio = devm_gpiod_get_optional(&led->client->dev,
  326. "enable", GPIOD_OUT_LOW);
  327. if (IS_ERR(led->enable_gpio)) {
  328. ret = PTR_ERR(led->enable_gpio);
  329. dev_err(&led->client->dev, "Failed to get enable gpio: %d\n",
  330. ret);
  331. return ret;
  332. }
  333. led->regulator = devm_regulator_get_optional(&led->client->dev, "vled");
  334. if (IS_ERR(led->regulator)) {
  335. ret = PTR_ERR(led->regulator);
  336. if (ret != -ENODEV)
  337. return dev_err_probe(&led->client->dev, ret,
  338. "Failed to get vled regulator\n");
  339. led->regulator = NULL;
  340. }
  341. led->boost_ctrl = LM3692X_BOOST_SW_1MHZ |
  342. LM3692X_BOOST_SW_NO_SHIFT |
  343. LM3692X_OCP_PROT_1_5A;
  344. ret = device_property_read_u32(&led->client->dev,
  345. "ti,ovp-microvolt", &ovp);
  346. if (ret) {
  347. led->boost_ctrl |= LM3692X_OVP_29V;
  348. } else {
  349. switch (ovp) {
  350. case 17000000:
  351. break;
  352. case 21000000:
  353. led->boost_ctrl |= LM3692X_OVP_21V;
  354. break;
  355. case 25000000:
  356. led->boost_ctrl |= LM3692X_OVP_25V;
  357. break;
  358. case 29000000:
  359. led->boost_ctrl |= LM3692X_OVP_29V;
  360. break;
  361. default:
  362. dev_err(&led->client->dev, "Invalid OVP %d\n", ovp);
  363. return -EINVAL;
  364. }
  365. }
  366. child = device_get_next_child_node(&led->client->dev, child);
  367. if (!child) {
  368. dev_err(&led->client->dev, "No LED Child node\n");
  369. return -ENODEV;
  370. }
  371. ret = fwnode_property_read_u32(child, "reg", &led->led_enable);
  372. if (ret) {
  373. fwnode_handle_put(child);
  374. dev_err(&led->client->dev, "reg DT property missing\n");
  375. return ret;
  376. }
  377. ret = fwnode_property_read_u32(child, "led-max-microamp", &max_cur);
  378. led->led_dev.max_brightness = ret ? LED_FULL :
  379. lm3692x_max_brightness(led, max_cur);
  380. init_data.fwnode = child;
  381. init_data.devicename = led->client->name;
  382. init_data.default_label = ":";
  383. ret = devm_led_classdev_register_ext(&led->client->dev, &led->led_dev,
  384. &init_data);
  385. if (ret)
  386. dev_err(&led->client->dev, "led register err: %d\n", ret);
  387. fwnode_handle_put(init_data.fwnode);
  388. return ret;
  389. }
  390. static int lm3692x_probe(struct i2c_client *client,
  391. const struct i2c_device_id *id)
  392. {
  393. struct lm3692x_led *led;
  394. int ret;
  395. led = devm_kzalloc(&client->dev, sizeof(*led), GFP_KERNEL);
  396. if (!led)
  397. return -ENOMEM;
  398. mutex_init(&led->lock);
  399. led->client = client;
  400. led->led_dev.brightness_set_blocking = lm3692x_brightness_set;
  401. led->model_id = id->driver_data;
  402. i2c_set_clientdata(client, led);
  403. led->regmap = devm_regmap_init_i2c(client, &lm3692x_regmap_config);
  404. if (IS_ERR(led->regmap)) {
  405. ret = PTR_ERR(led->regmap);
  406. dev_err(&client->dev, "Failed to allocate register map: %d\n",
  407. ret);
  408. return ret;
  409. }
  410. ret = lm3692x_probe_dt(led);
  411. if (ret)
  412. return ret;
  413. ret = lm3692x_leds_enable(led);
  414. if (ret)
  415. return ret;
  416. return 0;
  417. }
  418. static int lm3692x_remove(struct i2c_client *client)
  419. {
  420. struct lm3692x_led *led = i2c_get_clientdata(client);
  421. int ret;
  422. ret = lm3692x_leds_disable(led);
  423. if (ret)
  424. return ret;
  425. mutex_destroy(&led->lock);
  426. return 0;
  427. }
  428. static const struct i2c_device_id lm3692x_id[] = {
  429. { "lm36922", LM36922_MODEL },
  430. { "lm36923", LM36923_MODEL },
  431. { }
  432. };
  433. MODULE_DEVICE_TABLE(i2c, lm3692x_id);
  434. static const struct of_device_id of_lm3692x_leds_match[] = {
  435. { .compatible = "ti,lm36922", },
  436. { .compatible = "ti,lm36923", },
  437. {},
  438. };
  439. MODULE_DEVICE_TABLE(of, of_lm3692x_leds_match);
  440. static struct i2c_driver lm3692x_driver = {
  441. .driver = {
  442. .name = "lm3692x",
  443. .of_match_table = of_lm3692x_leds_match,
  444. },
  445. .probe = lm3692x_probe,
  446. .remove = lm3692x_remove,
  447. .id_table = lm3692x_id,
  448. };
  449. module_i2c_driver(lm3692x_driver);
  450. MODULE_DESCRIPTION("Texas Instruments LM3692X LED driver");
  451. MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");
  452. MODULE_LICENSE("GPL v2");