leds-lp8860.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * TI LP8860 4-Channel LED Driver
  4. *
  5. * Copyright (C) 2014 Texas Instruments
  6. *
  7. * Author: Dan Murphy <dmurphy@ti.com>
  8. */
  9. #include <linux/i2c.h>
  10. #include <linux/init.h>
  11. #include <linux/leds.h>
  12. #include <linux/regmap.h>
  13. #include <linux/regulator/consumer.h>
  14. #include <linux/module.h>
  15. #include <linux/mutex.h>
  16. #include <linux/of.h>
  17. #include <linux/of_gpio.h>
  18. #include <linux/gpio/consumer.h>
  19. #include <linux/slab.h>
  20. #define LP8860_DISP_CL1_BRT_MSB 0x00
  21. #define LP8860_DISP_CL1_BRT_LSB 0x01
  22. #define LP8860_DISP_CL1_CURR_MSB 0x02
  23. #define LP8860_DISP_CL1_CURR_LSB 0x03
  24. #define LP8860_CL2_BRT_MSB 0x04
  25. #define LP8860_CL2_BRT_LSB 0x05
  26. #define LP8860_CL2_CURRENT 0x06
  27. #define LP8860_CL3_BRT_MSB 0x07
  28. #define LP8860_CL3_BRT_LSB 0x08
  29. #define LP8860_CL3_CURRENT 0x09
  30. #define LP8860_CL4_BRT_MSB 0x0a
  31. #define LP8860_CL4_BRT_LSB 0x0b
  32. #define LP8860_CL4_CURRENT 0x0c
  33. #define LP8860_CONFIG 0x0d
  34. #define LP8860_STATUS 0x0e
  35. #define LP8860_FAULT 0x0f
  36. #define LP8860_LED_FAULT 0x10
  37. #define LP8860_FAULT_CLEAR 0x11
  38. #define LP8860_ID 0x12
  39. #define LP8860_TEMP_MSB 0x13
  40. #define LP8860_TEMP_LSB 0x14
  41. #define LP8860_DISP_LED_CURR_MSB 0x15
  42. #define LP8860_DISP_LED_CURR_LSB 0x16
  43. #define LP8860_DISP_LED_PWM_MSB 0x17
  44. #define LP8860_DISP_LED_PWM_LSB 0x18
  45. #define LP8860_EEPROM_CNTRL 0x19
  46. #define LP8860_EEPROM_UNLOCK 0x1a
  47. #define LP8860_EEPROM_REG_0 0x60
  48. #define LP8860_EEPROM_REG_1 0x61
  49. #define LP8860_EEPROM_REG_2 0x62
  50. #define LP8860_EEPROM_REG_3 0x63
  51. #define LP8860_EEPROM_REG_4 0x64
  52. #define LP8860_EEPROM_REG_5 0x65
  53. #define LP8860_EEPROM_REG_6 0x66
  54. #define LP8860_EEPROM_REG_7 0x67
  55. #define LP8860_EEPROM_REG_8 0x68
  56. #define LP8860_EEPROM_REG_9 0x69
  57. #define LP8860_EEPROM_REG_10 0x6a
  58. #define LP8860_EEPROM_REG_11 0x6b
  59. #define LP8860_EEPROM_REG_12 0x6c
  60. #define LP8860_EEPROM_REG_13 0x6d
  61. #define LP8860_EEPROM_REG_14 0x6e
  62. #define LP8860_EEPROM_REG_15 0x6f
  63. #define LP8860_EEPROM_REG_16 0x70
  64. #define LP8860_EEPROM_REG_17 0x71
  65. #define LP8860_EEPROM_REG_18 0x72
  66. #define LP8860_EEPROM_REG_19 0x73
  67. #define LP8860_EEPROM_REG_20 0x74
  68. #define LP8860_EEPROM_REG_21 0x75
  69. #define LP8860_EEPROM_REG_22 0x76
  70. #define LP8860_EEPROM_REG_23 0x77
  71. #define LP8860_EEPROM_REG_24 0x78
  72. #define LP8860_LOCK_EEPROM 0x00
  73. #define LP8860_UNLOCK_EEPROM 0x01
  74. #define LP8860_PROGRAM_EEPROM 0x02
  75. #define LP8860_EEPROM_CODE_1 0x08
  76. #define LP8860_EEPROM_CODE_2 0xba
  77. #define LP8860_EEPROM_CODE_3 0xef
  78. #define LP8860_CLEAR_FAULTS 0x01
  79. #define LP8860_NAME "lp8860"
  80. /**
  81. * struct lp8860_led -
  82. * @lock - Lock for reading/writing the device
  83. * @client - Pointer to the I2C client
  84. * @led_dev - led class device pointer
  85. * @regmap - Devices register map
  86. * @eeprom_regmap - EEPROM register map
  87. * @enable_gpio - VDDIO/EN gpio to enable communication interface
  88. * @regulator - LED supply regulator pointer
  89. */
  90. struct lp8860_led {
  91. struct mutex lock;
  92. struct i2c_client *client;
  93. struct led_classdev led_dev;
  94. struct regmap *regmap;
  95. struct regmap *eeprom_regmap;
  96. struct gpio_desc *enable_gpio;
  97. struct regulator *regulator;
  98. };
  99. struct lp8860_eeprom_reg {
  100. uint8_t reg;
  101. uint8_t value;
  102. };
  103. static struct lp8860_eeprom_reg lp8860_eeprom_disp_regs[] = {
  104. { LP8860_EEPROM_REG_0, 0xed },
  105. { LP8860_EEPROM_REG_1, 0xdf },
  106. { LP8860_EEPROM_REG_2, 0xdc },
  107. { LP8860_EEPROM_REG_3, 0xf0 },
  108. { LP8860_EEPROM_REG_4, 0xdf },
  109. { LP8860_EEPROM_REG_5, 0xe5 },
  110. { LP8860_EEPROM_REG_6, 0xf2 },
  111. { LP8860_EEPROM_REG_7, 0x77 },
  112. { LP8860_EEPROM_REG_8, 0x77 },
  113. { LP8860_EEPROM_REG_9, 0x71 },
  114. { LP8860_EEPROM_REG_10, 0x3f },
  115. { LP8860_EEPROM_REG_11, 0xb7 },
  116. { LP8860_EEPROM_REG_12, 0x17 },
  117. { LP8860_EEPROM_REG_13, 0xef },
  118. { LP8860_EEPROM_REG_14, 0xb0 },
  119. { LP8860_EEPROM_REG_15, 0x87 },
  120. { LP8860_EEPROM_REG_16, 0xce },
  121. { LP8860_EEPROM_REG_17, 0x72 },
  122. { LP8860_EEPROM_REG_18, 0xe5 },
  123. { LP8860_EEPROM_REG_19, 0xdf },
  124. { LP8860_EEPROM_REG_20, 0x35 },
  125. { LP8860_EEPROM_REG_21, 0x06 },
  126. { LP8860_EEPROM_REG_22, 0xdc },
  127. { LP8860_EEPROM_REG_23, 0x88 },
  128. { LP8860_EEPROM_REG_24, 0x3E },
  129. };
  130. static int lp8860_unlock_eeprom(struct lp8860_led *led, int lock)
  131. {
  132. int ret;
  133. mutex_lock(&led->lock);
  134. if (lock == LP8860_UNLOCK_EEPROM) {
  135. ret = regmap_write(led->regmap,
  136. LP8860_EEPROM_UNLOCK,
  137. LP8860_EEPROM_CODE_1);
  138. if (ret) {
  139. dev_err(&led->client->dev, "EEPROM Unlock failed\n");
  140. goto out;
  141. }
  142. ret = regmap_write(led->regmap,
  143. LP8860_EEPROM_UNLOCK,
  144. LP8860_EEPROM_CODE_2);
  145. if (ret) {
  146. dev_err(&led->client->dev, "EEPROM Unlock failed\n");
  147. goto out;
  148. }
  149. ret = regmap_write(led->regmap,
  150. LP8860_EEPROM_UNLOCK,
  151. LP8860_EEPROM_CODE_3);
  152. if (ret) {
  153. dev_err(&led->client->dev, "EEPROM Unlock failed\n");
  154. goto out;
  155. }
  156. } else {
  157. ret = regmap_write(led->regmap,
  158. LP8860_EEPROM_UNLOCK,
  159. LP8860_LOCK_EEPROM);
  160. }
  161. out:
  162. mutex_unlock(&led->lock);
  163. return ret;
  164. }
  165. static int lp8860_fault_check(struct lp8860_led *led)
  166. {
  167. int ret, fault;
  168. unsigned int read_buf;
  169. ret = regmap_read(led->regmap, LP8860_LED_FAULT, &read_buf);
  170. if (ret)
  171. goto out;
  172. fault = read_buf;
  173. ret = regmap_read(led->regmap, LP8860_FAULT, &read_buf);
  174. if (ret)
  175. goto out;
  176. fault |= read_buf;
  177. /* Attempt to clear any faults */
  178. if (fault)
  179. ret = regmap_write(led->regmap, LP8860_FAULT_CLEAR,
  180. LP8860_CLEAR_FAULTS);
  181. out:
  182. return ret;
  183. }
  184. static int lp8860_brightness_set(struct led_classdev *led_cdev,
  185. enum led_brightness brt_val)
  186. {
  187. struct lp8860_led *led =
  188. container_of(led_cdev, struct lp8860_led, led_dev);
  189. int disp_brightness = brt_val * 255;
  190. int ret;
  191. mutex_lock(&led->lock);
  192. ret = lp8860_fault_check(led);
  193. if (ret) {
  194. dev_err(&led->client->dev, "Cannot read/clear faults\n");
  195. goto out;
  196. }
  197. ret = regmap_write(led->regmap, LP8860_DISP_CL1_BRT_MSB,
  198. (disp_brightness & 0xff00) >> 8);
  199. if (ret) {
  200. dev_err(&led->client->dev, "Cannot write CL1 MSB\n");
  201. goto out;
  202. }
  203. ret = regmap_write(led->regmap, LP8860_DISP_CL1_BRT_LSB,
  204. disp_brightness & 0xff);
  205. if (ret) {
  206. dev_err(&led->client->dev, "Cannot write CL1 LSB\n");
  207. goto out;
  208. }
  209. out:
  210. mutex_unlock(&led->lock);
  211. return ret;
  212. }
  213. static int lp8860_init(struct lp8860_led *led)
  214. {
  215. unsigned int read_buf;
  216. int ret, i, reg_count;
  217. if (led->regulator) {
  218. ret = regulator_enable(led->regulator);
  219. if (ret) {
  220. dev_err(&led->client->dev,
  221. "Failed to enable regulator\n");
  222. return ret;
  223. }
  224. }
  225. if (led->enable_gpio)
  226. gpiod_direction_output(led->enable_gpio, 1);
  227. ret = lp8860_fault_check(led);
  228. if (ret)
  229. goto out;
  230. ret = regmap_read(led->regmap, LP8860_STATUS, &read_buf);
  231. if (ret)
  232. goto out;
  233. ret = lp8860_unlock_eeprom(led, LP8860_UNLOCK_EEPROM);
  234. if (ret) {
  235. dev_err(&led->client->dev, "Failed unlocking EEPROM\n");
  236. goto out;
  237. }
  238. reg_count = ARRAY_SIZE(lp8860_eeprom_disp_regs) / sizeof(lp8860_eeprom_disp_regs[0]);
  239. for (i = 0; i < reg_count; i++) {
  240. ret = regmap_write(led->eeprom_regmap,
  241. lp8860_eeprom_disp_regs[i].reg,
  242. lp8860_eeprom_disp_regs[i].value);
  243. if (ret) {
  244. dev_err(&led->client->dev, "Failed writing EEPROM\n");
  245. goto out;
  246. }
  247. }
  248. ret = lp8860_unlock_eeprom(led, LP8860_LOCK_EEPROM);
  249. if (ret)
  250. goto out;
  251. ret = regmap_write(led->regmap,
  252. LP8860_EEPROM_CNTRL,
  253. LP8860_PROGRAM_EEPROM);
  254. if (ret) {
  255. dev_err(&led->client->dev, "Failed programming EEPROM\n");
  256. goto out;
  257. }
  258. return ret;
  259. out:
  260. if (ret)
  261. if (led->enable_gpio)
  262. gpiod_direction_output(led->enable_gpio, 0);
  263. if (led->regulator) {
  264. ret = regulator_disable(led->regulator);
  265. if (ret)
  266. dev_err(&led->client->dev,
  267. "Failed to disable regulator\n");
  268. }
  269. return ret;
  270. }
  271. static const struct reg_default lp8860_reg_defs[] = {
  272. { LP8860_DISP_CL1_BRT_MSB, 0x00},
  273. { LP8860_DISP_CL1_BRT_LSB, 0x00},
  274. { LP8860_DISP_CL1_CURR_MSB, 0x00},
  275. { LP8860_DISP_CL1_CURR_LSB, 0x00},
  276. { LP8860_CL2_BRT_MSB, 0x00},
  277. { LP8860_CL2_BRT_LSB, 0x00},
  278. { LP8860_CL2_CURRENT, 0x00},
  279. { LP8860_CL3_BRT_MSB, 0x00},
  280. { LP8860_CL3_BRT_LSB, 0x00},
  281. { LP8860_CL3_CURRENT, 0x00},
  282. { LP8860_CL4_BRT_MSB, 0x00},
  283. { LP8860_CL4_BRT_LSB, 0x00},
  284. { LP8860_CL4_CURRENT, 0x00},
  285. { LP8860_CONFIG, 0x00},
  286. { LP8860_FAULT_CLEAR, 0x00},
  287. { LP8860_EEPROM_CNTRL, 0x80},
  288. { LP8860_EEPROM_UNLOCK, 0x00},
  289. };
  290. static const struct regmap_config lp8860_regmap_config = {
  291. .reg_bits = 8,
  292. .val_bits = 8,
  293. .max_register = LP8860_EEPROM_UNLOCK,
  294. .reg_defaults = lp8860_reg_defs,
  295. .num_reg_defaults = ARRAY_SIZE(lp8860_reg_defs),
  296. .cache_type = REGCACHE_NONE,
  297. };
  298. static const struct reg_default lp8860_eeprom_defs[] = {
  299. { LP8860_EEPROM_REG_0, 0x00 },
  300. { LP8860_EEPROM_REG_1, 0x00 },
  301. { LP8860_EEPROM_REG_2, 0x00 },
  302. { LP8860_EEPROM_REG_3, 0x00 },
  303. { LP8860_EEPROM_REG_4, 0x00 },
  304. { LP8860_EEPROM_REG_5, 0x00 },
  305. { LP8860_EEPROM_REG_6, 0x00 },
  306. { LP8860_EEPROM_REG_7, 0x00 },
  307. { LP8860_EEPROM_REG_8, 0x00 },
  308. { LP8860_EEPROM_REG_9, 0x00 },
  309. { LP8860_EEPROM_REG_10, 0x00 },
  310. { LP8860_EEPROM_REG_11, 0x00 },
  311. { LP8860_EEPROM_REG_12, 0x00 },
  312. { LP8860_EEPROM_REG_13, 0x00 },
  313. { LP8860_EEPROM_REG_14, 0x00 },
  314. { LP8860_EEPROM_REG_15, 0x00 },
  315. { LP8860_EEPROM_REG_16, 0x00 },
  316. { LP8860_EEPROM_REG_17, 0x00 },
  317. { LP8860_EEPROM_REG_18, 0x00 },
  318. { LP8860_EEPROM_REG_19, 0x00 },
  319. { LP8860_EEPROM_REG_20, 0x00 },
  320. { LP8860_EEPROM_REG_21, 0x00 },
  321. { LP8860_EEPROM_REG_22, 0x00 },
  322. { LP8860_EEPROM_REG_23, 0x00 },
  323. { LP8860_EEPROM_REG_24, 0x00 },
  324. };
  325. static const struct regmap_config lp8860_eeprom_regmap_config = {
  326. .reg_bits = 8,
  327. .val_bits = 8,
  328. .max_register = LP8860_EEPROM_REG_24,
  329. .reg_defaults = lp8860_eeprom_defs,
  330. .num_reg_defaults = ARRAY_SIZE(lp8860_eeprom_defs),
  331. .cache_type = REGCACHE_NONE,
  332. };
  333. static int lp8860_probe(struct i2c_client *client,
  334. const struct i2c_device_id *id)
  335. {
  336. int ret;
  337. struct lp8860_led *led;
  338. struct device_node *np = dev_of_node(&client->dev);
  339. struct device_node *child_node;
  340. struct led_init_data init_data = {};
  341. led = devm_kzalloc(&client->dev, sizeof(*led), GFP_KERNEL);
  342. if (!led)
  343. return -ENOMEM;
  344. child_node = of_get_next_available_child(np, NULL);
  345. if (!child_node)
  346. return -EINVAL;
  347. led->enable_gpio = devm_gpiod_get_optional(&client->dev,
  348. "enable", GPIOD_OUT_LOW);
  349. if (IS_ERR(led->enable_gpio)) {
  350. ret = PTR_ERR(led->enable_gpio);
  351. dev_err(&client->dev, "Failed to get enable gpio: %d\n", ret);
  352. return ret;
  353. }
  354. led->regulator = devm_regulator_get(&client->dev, "vled");
  355. if (IS_ERR(led->regulator))
  356. led->regulator = NULL;
  357. led->client = client;
  358. led->led_dev.brightness_set_blocking = lp8860_brightness_set;
  359. mutex_init(&led->lock);
  360. i2c_set_clientdata(client, led);
  361. led->regmap = devm_regmap_init_i2c(client, &lp8860_regmap_config);
  362. if (IS_ERR(led->regmap)) {
  363. ret = PTR_ERR(led->regmap);
  364. dev_err(&client->dev, "Failed to allocate register map: %d\n",
  365. ret);
  366. return ret;
  367. }
  368. led->eeprom_regmap = devm_regmap_init_i2c(client, &lp8860_eeprom_regmap_config);
  369. if (IS_ERR(led->eeprom_regmap)) {
  370. ret = PTR_ERR(led->eeprom_regmap);
  371. dev_err(&client->dev, "Failed to allocate register map: %d\n",
  372. ret);
  373. return ret;
  374. }
  375. ret = lp8860_init(led);
  376. if (ret)
  377. return ret;
  378. init_data.fwnode = of_fwnode_handle(child_node);
  379. init_data.devicename = LP8860_NAME;
  380. init_data.default_label = ":display_cluster";
  381. ret = devm_led_classdev_register_ext(&client->dev, &led->led_dev,
  382. &init_data);
  383. if (ret) {
  384. dev_err(&client->dev, "led register err: %d\n", ret);
  385. return ret;
  386. }
  387. return 0;
  388. }
  389. static int lp8860_remove(struct i2c_client *client)
  390. {
  391. struct lp8860_led *led = i2c_get_clientdata(client);
  392. int ret;
  393. if (led->enable_gpio)
  394. gpiod_direction_output(led->enable_gpio, 0);
  395. if (led->regulator) {
  396. ret = regulator_disable(led->regulator);
  397. if (ret)
  398. dev_err(&led->client->dev,
  399. "Failed to disable regulator\n");
  400. }
  401. mutex_destroy(&led->lock);
  402. return 0;
  403. }
  404. static const struct i2c_device_id lp8860_id[] = {
  405. { "lp8860", 0 },
  406. { }
  407. };
  408. MODULE_DEVICE_TABLE(i2c, lp8860_id);
  409. static const struct of_device_id of_lp8860_leds_match[] = {
  410. { .compatible = "ti,lp8860", },
  411. {},
  412. };
  413. MODULE_DEVICE_TABLE(of, of_lp8860_leds_match);
  414. static struct i2c_driver lp8860_driver = {
  415. .driver = {
  416. .name = "lp8860",
  417. .of_match_table = of_lp8860_leds_match,
  418. },
  419. .probe = lp8860_probe,
  420. .remove = lp8860_remove,
  421. .id_table = lp8860_id,
  422. };
  423. module_i2c_driver(lp8860_driver);
  424. MODULE_DESCRIPTION("Texas Instruments LP8860 LED driver");
  425. MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");
  426. MODULE_LICENSE("GPL v2");