leds-lp50xx.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633
  1. // SPDX-License-Identifier: GPL-2.0
  2. // TI LP50XX LED chip family driver
  3. // Copyright (C) 2018-20 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/module.h>
  9. #include <linux/mutex.h>
  10. #include <linux/of.h>
  11. #include <linux/of_gpio.h>
  12. #include <linux/regmap.h>
  13. #include <linux/regulator/consumer.h>
  14. #include <linux/slab.h>
  15. #include <uapi/linux/uleds.h>
  16. #include <linux/led-class-multicolor.h>
  17. #include "leds.h"
  18. #define LP50XX_DEV_CFG0 0x00
  19. #define LP50XX_DEV_CFG1 0x01
  20. #define LP50XX_LED_CFG0 0x02
  21. /* LP5009 and LP5012 registers */
  22. #define LP5012_BNK_BRT 0x03
  23. #define LP5012_BNKA_CLR 0x04
  24. #define LP5012_BNKB_CLR 0x05
  25. #define LP5012_BNKC_CLR 0x06
  26. #define LP5012_LED0_BRT 0x07
  27. #define LP5012_OUT0_CLR 0x0b
  28. #define LP5012_RESET 0x17
  29. /* LP5018 and LP5024 registers */
  30. #define LP5024_BNK_BRT 0x03
  31. #define LP5024_BNKA_CLR 0x04
  32. #define LP5024_BNKB_CLR 0x05
  33. #define LP5024_BNKC_CLR 0x06
  34. #define LP5024_LED0_BRT 0x07
  35. #define LP5024_OUT0_CLR 0x0f
  36. #define LP5024_RESET 0x27
  37. /* LP5030 and LP5036 registers */
  38. #define LP5036_LED_CFG1 0x03
  39. #define LP5036_BNK_BRT 0x04
  40. #define LP5036_BNKA_CLR 0x05
  41. #define LP5036_BNKB_CLR 0x06
  42. #define LP5036_BNKC_CLR 0x07
  43. #define LP5036_LED0_BRT 0x08
  44. #define LP5036_OUT0_CLR 0x14
  45. #define LP5036_RESET 0x38
  46. #define LP50XX_SW_RESET 0xff
  47. #define LP50XX_CHIP_EN BIT(6)
  48. /* There are 3 LED outputs per bank */
  49. #define LP50XX_LEDS_PER_MODULE 3
  50. #define LP5009_MAX_LED_MODULES 2
  51. #define LP5012_MAX_LED_MODULES 4
  52. #define LP5018_MAX_LED_MODULES 6
  53. #define LP5024_MAX_LED_MODULES 8
  54. #define LP5030_MAX_LED_MODULES 10
  55. #define LP5036_MAX_LED_MODULES 12
  56. static const struct reg_default lp5012_reg_defs[] = {
  57. {LP50XX_DEV_CFG0, 0x0},
  58. {LP50XX_DEV_CFG1, 0x3c},
  59. {LP50XX_LED_CFG0, 0x0},
  60. {LP5012_BNK_BRT, 0xff},
  61. {LP5012_BNKA_CLR, 0x0f},
  62. {LP5012_BNKB_CLR, 0x0f},
  63. {LP5012_BNKC_CLR, 0x0f},
  64. {LP5012_LED0_BRT, 0x0f},
  65. /* LEDX_BRT registers are all 0xff for defaults */
  66. {0x08, 0xff}, {0x09, 0xff}, {0x0a, 0xff},
  67. {LP5012_OUT0_CLR, 0x0f},
  68. /* OUTX_CLR registers are all 0x0 for defaults */
  69. {0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00}, {0x10, 0x00},
  70. {0x11, 0x00}, {0x12, 0x00}, {0x13, 0x00}, {0x14, 0x00}, {0x15, 0x00},
  71. {0x16, 0x00},
  72. {LP5012_RESET, 0x00}
  73. };
  74. static const struct reg_default lp5024_reg_defs[] = {
  75. {LP50XX_DEV_CFG0, 0x0},
  76. {LP50XX_DEV_CFG1, 0x3c},
  77. {LP50XX_LED_CFG0, 0x0},
  78. {LP5024_BNK_BRT, 0xff},
  79. {LP5024_BNKA_CLR, 0x0f},
  80. {LP5024_BNKB_CLR, 0x0f},
  81. {LP5024_BNKC_CLR, 0x0f},
  82. {LP5024_LED0_BRT, 0x0f},
  83. /* LEDX_BRT registers are all 0xff for defaults */
  84. {0x08, 0xff}, {0x09, 0xff}, {0x0a, 0xff}, {0x0b, 0xff}, {0x0c, 0xff},
  85. {0x0d, 0xff}, {0x0e, 0xff},
  86. {LP5024_OUT0_CLR, 0x0f},
  87. /* OUTX_CLR registers are all 0x0 for defaults */
  88. {0x10, 0x00}, {0x11, 0x00}, {0x12, 0x00}, {0x13, 0x00}, {0x14, 0x00},
  89. {0x15, 0x00}, {0x16, 0x00}, {0x17, 0x00}, {0x18, 0x00}, {0x19, 0x00},
  90. {0x1a, 0x00}, {0x1b, 0x00}, {0x1c, 0x00}, {0x1d, 0x00}, {0x1e, 0x00},
  91. {0x1f, 0x00}, {0x20, 0x00}, {0x21, 0x00}, {0x22, 0x00}, {0x23, 0x00},
  92. {0x24, 0x00}, {0x25, 0x00}, {0x26, 0x00},
  93. {LP5024_RESET, 0x00}
  94. };
  95. static const struct reg_default lp5036_reg_defs[] = {
  96. {LP50XX_DEV_CFG0, 0x0},
  97. {LP50XX_DEV_CFG1, 0x3c},
  98. {LP50XX_LED_CFG0, 0x0},
  99. {LP5036_LED_CFG1, 0x0},
  100. {LP5036_BNK_BRT, 0xff},
  101. {LP5036_BNKA_CLR, 0x0f},
  102. {LP5036_BNKB_CLR, 0x0f},
  103. {LP5036_BNKC_CLR, 0x0f},
  104. {LP5036_LED0_BRT, 0x0f},
  105. /* LEDX_BRT registers are all 0xff for defaults */
  106. {0x08, 0xff}, {0x09, 0xff}, {0x0a, 0xff}, {0x0b, 0xff}, {0x0c, 0xff},
  107. {0x0d, 0xff}, {0x0e, 0xff}, {0x0f, 0xff}, {0x10, 0xff}, {0x11, 0xff},
  108. {0x12, 0xff}, {0x13, 0xff},
  109. {LP5036_OUT0_CLR, 0x0f},
  110. /* OUTX_CLR registers are all 0x0 for defaults */
  111. {0x15, 0x00}, {0x16, 0x00}, {0x17, 0x00}, {0x18, 0x00}, {0x19, 0x00},
  112. {0x1a, 0x00}, {0x1b, 0x00}, {0x1c, 0x00}, {0x1d, 0x00}, {0x1e, 0x00},
  113. {0x1f, 0x00}, {0x20, 0x00}, {0x21, 0x00}, {0x22, 0x00}, {0x23, 0x00},
  114. {0x24, 0x00}, {0x25, 0x00}, {0x26, 0x00}, {0x27, 0x00}, {0x28, 0x00},
  115. {0x29, 0x00}, {0x2a, 0x00}, {0x2b, 0x00}, {0x2c, 0x00}, {0x2d, 0x00},
  116. {0x2e, 0x00}, {0x2f, 0x00}, {0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00},
  117. {0x33, 0x00}, {0x34, 0x00}, {0x35, 0x00}, {0x36, 0x00}, {0x37, 0x00},
  118. {LP5036_RESET, 0x00}
  119. };
  120. static const struct regmap_config lp5012_regmap_config = {
  121. .reg_bits = 8,
  122. .val_bits = 8,
  123. .max_register = LP5012_RESET,
  124. .reg_defaults = lp5012_reg_defs,
  125. .num_reg_defaults = ARRAY_SIZE(lp5012_reg_defs),
  126. .cache_type = REGCACHE_FLAT,
  127. };
  128. static const struct regmap_config lp5024_regmap_config = {
  129. .reg_bits = 8,
  130. .val_bits = 8,
  131. .max_register = LP5024_RESET,
  132. .reg_defaults = lp5024_reg_defs,
  133. .num_reg_defaults = ARRAY_SIZE(lp5024_reg_defs),
  134. .cache_type = REGCACHE_FLAT,
  135. };
  136. static const struct regmap_config lp5036_regmap_config = {
  137. .reg_bits = 8,
  138. .val_bits = 8,
  139. .max_register = LP5036_RESET,
  140. .reg_defaults = lp5036_reg_defs,
  141. .num_reg_defaults = ARRAY_SIZE(lp5036_reg_defs),
  142. .cache_type = REGCACHE_FLAT,
  143. };
  144. enum lp50xx_model {
  145. LP5009,
  146. LP5012,
  147. LP5018,
  148. LP5024,
  149. LP5030,
  150. LP5036,
  151. };
  152. /**
  153. * struct lp50xx_chip_info -
  154. * @lp50xx_regmap_config: regmap register configuration
  155. * @model_id: LED device model
  156. * @max_modules: total number of supported LED modules
  157. * @num_leds: number of LED outputs available on the device
  158. * @led_brightness0_reg: first brightness register of the device
  159. * @mix_out0_reg: first color mix register of the device
  160. * @bank_brt_reg: bank brightness register
  161. * @bank_mix_reg: color mix register
  162. * @reset_reg: device reset register
  163. */
  164. struct lp50xx_chip_info {
  165. const struct regmap_config *lp50xx_regmap_config;
  166. int model_id;
  167. u8 max_modules;
  168. u8 num_leds;
  169. u8 led_brightness0_reg;
  170. u8 mix_out0_reg;
  171. u8 bank_brt_reg;
  172. u8 bank_mix_reg;
  173. u8 reset_reg;
  174. };
  175. static const struct lp50xx_chip_info lp50xx_chip_info_tbl[] = {
  176. [LP5009] = {
  177. .model_id = LP5009,
  178. .max_modules = LP5009_MAX_LED_MODULES,
  179. .num_leds = LP5009_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
  180. .led_brightness0_reg = LP5012_LED0_BRT,
  181. .mix_out0_reg = LP5012_OUT0_CLR,
  182. .bank_brt_reg = LP5012_BNK_BRT,
  183. .bank_mix_reg = LP5012_BNKA_CLR,
  184. .reset_reg = LP5012_RESET,
  185. .lp50xx_regmap_config = &lp5012_regmap_config,
  186. },
  187. [LP5012] = {
  188. .model_id = LP5012,
  189. .max_modules = LP5012_MAX_LED_MODULES,
  190. .num_leds = LP5012_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
  191. .led_brightness0_reg = LP5012_LED0_BRT,
  192. .mix_out0_reg = LP5012_OUT0_CLR,
  193. .bank_brt_reg = LP5012_BNK_BRT,
  194. .bank_mix_reg = LP5012_BNKA_CLR,
  195. .reset_reg = LP5012_RESET,
  196. .lp50xx_regmap_config = &lp5012_regmap_config,
  197. },
  198. [LP5018] = {
  199. .model_id = LP5018,
  200. .max_modules = LP5018_MAX_LED_MODULES,
  201. .num_leds = LP5018_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
  202. .led_brightness0_reg = LP5024_LED0_BRT,
  203. .mix_out0_reg = LP5024_OUT0_CLR,
  204. .bank_brt_reg = LP5024_BNK_BRT,
  205. .bank_mix_reg = LP5024_BNKA_CLR,
  206. .reset_reg = LP5024_RESET,
  207. .lp50xx_regmap_config = &lp5024_regmap_config,
  208. },
  209. [LP5024] = {
  210. .model_id = LP5024,
  211. .max_modules = LP5024_MAX_LED_MODULES,
  212. .num_leds = LP5024_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
  213. .led_brightness0_reg = LP5024_LED0_BRT,
  214. .mix_out0_reg = LP5024_OUT0_CLR,
  215. .bank_brt_reg = LP5024_BNK_BRT,
  216. .bank_mix_reg = LP5024_BNKA_CLR,
  217. .reset_reg = LP5024_RESET,
  218. .lp50xx_regmap_config = &lp5024_regmap_config,
  219. },
  220. [LP5030] = {
  221. .model_id = LP5030,
  222. .max_modules = LP5030_MAX_LED_MODULES,
  223. .num_leds = LP5030_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
  224. .led_brightness0_reg = LP5036_LED0_BRT,
  225. .mix_out0_reg = LP5036_OUT0_CLR,
  226. .bank_brt_reg = LP5036_BNK_BRT,
  227. .bank_mix_reg = LP5036_BNKA_CLR,
  228. .reset_reg = LP5036_RESET,
  229. .lp50xx_regmap_config = &lp5036_regmap_config,
  230. },
  231. [LP5036] = {
  232. .model_id = LP5036,
  233. .max_modules = LP5036_MAX_LED_MODULES,
  234. .num_leds = LP5036_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
  235. .led_brightness0_reg = LP5036_LED0_BRT,
  236. .mix_out0_reg = LP5036_OUT0_CLR,
  237. .bank_brt_reg = LP5036_BNK_BRT,
  238. .bank_mix_reg = LP5036_BNKA_CLR,
  239. .reset_reg = LP5036_RESET,
  240. .lp50xx_regmap_config = &lp5036_regmap_config,
  241. },
  242. };
  243. struct lp50xx_led {
  244. struct led_classdev_mc mc_cdev;
  245. struct lp50xx *priv;
  246. unsigned long bank_modules;
  247. int led_intensity[LP50XX_LEDS_PER_MODULE];
  248. u8 ctrl_bank_enabled;
  249. int led_number;
  250. };
  251. /**
  252. * struct lp50xx -
  253. * @enable_gpio: hardware enable gpio
  254. * @regulator: LED supply regulator pointer
  255. * @client: pointer to the I2C client
  256. * @regmap: device register map
  257. * @dev: pointer to the devices device struct
  258. * @lock: lock for reading/writing the device
  259. * @chip_info: chip specific information (ie num_leds)
  260. * @num_of_banked_leds: holds the number of banked LEDs
  261. * @leds: array of LED strings
  262. */
  263. struct lp50xx {
  264. struct gpio_desc *enable_gpio;
  265. struct regulator *regulator;
  266. struct i2c_client *client;
  267. struct regmap *regmap;
  268. struct device *dev;
  269. struct mutex lock;
  270. const struct lp50xx_chip_info *chip_info;
  271. int num_of_banked_leds;
  272. /* This needs to be at the end of the struct */
  273. struct lp50xx_led leds[];
  274. };
  275. static struct lp50xx_led *mcled_cdev_to_led(struct led_classdev_mc *mc_cdev)
  276. {
  277. return container_of(mc_cdev, struct lp50xx_led, mc_cdev);
  278. }
  279. static int lp50xx_brightness_set(struct led_classdev *cdev,
  280. enum led_brightness brightness)
  281. {
  282. struct led_classdev_mc *mc_dev = lcdev_to_mccdev(cdev);
  283. struct lp50xx_led *led = mcled_cdev_to_led(mc_dev);
  284. const struct lp50xx_chip_info *led_chip = led->priv->chip_info;
  285. u8 led_offset, reg_val;
  286. int ret = 0;
  287. int i;
  288. mutex_lock(&led->priv->lock);
  289. if (led->ctrl_bank_enabled)
  290. reg_val = led_chip->bank_brt_reg;
  291. else
  292. reg_val = led_chip->led_brightness0_reg +
  293. led->led_number;
  294. ret = regmap_write(led->priv->regmap, reg_val, brightness);
  295. if (ret) {
  296. dev_err(&led->priv->client->dev,
  297. "Cannot write brightness value %d\n", ret);
  298. goto out;
  299. }
  300. for (i = 0; i < led->mc_cdev.num_colors; i++) {
  301. if (led->ctrl_bank_enabled) {
  302. reg_val = led_chip->bank_mix_reg + i;
  303. } else {
  304. led_offset = (led->led_number * 3) + i;
  305. reg_val = led_chip->mix_out0_reg + led_offset;
  306. }
  307. ret = regmap_write(led->priv->regmap, reg_val,
  308. mc_dev->subled_info[i].intensity);
  309. if (ret) {
  310. dev_err(&led->priv->client->dev,
  311. "Cannot write intensity value %d\n", ret);
  312. goto out;
  313. }
  314. }
  315. out:
  316. mutex_unlock(&led->priv->lock);
  317. return ret;
  318. }
  319. static int lp50xx_set_banks(struct lp50xx *priv, u32 led_banks[])
  320. {
  321. u8 led_config_lo, led_config_hi;
  322. u32 bank_enable_mask = 0;
  323. int ret;
  324. int i;
  325. for (i = 0; i < priv->chip_info->max_modules; i++) {
  326. if (led_banks[i])
  327. bank_enable_mask |= (1 << led_banks[i]);
  328. }
  329. led_config_lo = (u8)(bank_enable_mask & 0xff);
  330. led_config_hi = (u8)(bank_enable_mask >> 8) & 0xff;
  331. ret = regmap_write(priv->regmap, LP50XX_LED_CFG0, led_config_lo);
  332. if (ret)
  333. return ret;
  334. if (priv->chip_info->model_id >= LP5030)
  335. ret = regmap_write(priv->regmap, LP5036_LED_CFG1, led_config_hi);
  336. return ret;
  337. }
  338. static int lp50xx_reset(struct lp50xx *priv)
  339. {
  340. return regmap_write(priv->regmap, priv->chip_info->reset_reg, LP50XX_SW_RESET);
  341. }
  342. static int lp50xx_enable_disable(struct lp50xx *priv, int enable_disable)
  343. {
  344. int ret;
  345. if (priv->enable_gpio) {
  346. ret = gpiod_direction_output(priv->enable_gpio, enable_disable);
  347. if (ret)
  348. return ret;
  349. }
  350. if (enable_disable)
  351. return regmap_write(priv->regmap, LP50XX_DEV_CFG0, LP50XX_CHIP_EN);
  352. else
  353. return regmap_write(priv->regmap, LP50XX_DEV_CFG0, 0);
  354. }
  355. static int lp50xx_probe_leds(struct fwnode_handle *child, struct lp50xx *priv,
  356. struct lp50xx_led *led, int num_leds)
  357. {
  358. u32 led_banks[LP5036_MAX_LED_MODULES] = {0};
  359. int led_number;
  360. int ret;
  361. if (num_leds > 1) {
  362. if (num_leds > priv->chip_info->max_modules) {
  363. dev_err(&priv->client->dev, "reg property is invalid\n");
  364. return -EINVAL;
  365. }
  366. priv->num_of_banked_leds = num_leds;
  367. ret = fwnode_property_read_u32_array(child, "reg", led_banks, num_leds);
  368. if (ret) {
  369. dev_err(&priv->client->dev, "reg property is missing\n");
  370. return ret;
  371. }
  372. ret = lp50xx_set_banks(priv, led_banks);
  373. if (ret) {
  374. dev_err(&priv->client->dev, "Cannot setup banked LEDs\n");
  375. return ret;
  376. }
  377. led->ctrl_bank_enabled = 1;
  378. } else {
  379. ret = fwnode_property_read_u32(child, "reg", &led_number);
  380. if (ret) {
  381. dev_err(&priv->client->dev, "led reg property missing\n");
  382. return ret;
  383. }
  384. if (led_number > priv->chip_info->num_leds) {
  385. dev_err(&priv->client->dev, "led-sources property is invalid\n");
  386. return -EINVAL;
  387. }
  388. led->led_number = led_number;
  389. }
  390. return 0;
  391. }
  392. static int lp50xx_probe_dt(struct lp50xx *priv)
  393. {
  394. struct fwnode_handle *child = NULL;
  395. struct fwnode_handle *led_node = NULL;
  396. struct led_init_data init_data = {};
  397. struct led_classdev *led_cdev;
  398. struct mc_subled *mc_led_info;
  399. struct lp50xx_led *led;
  400. int ret = -EINVAL;
  401. int num_colors;
  402. u32 color_id;
  403. int i = 0;
  404. priv->enable_gpio = devm_gpiod_get_optional(priv->dev, "enable", GPIOD_OUT_LOW);
  405. if (IS_ERR(priv->enable_gpio)) {
  406. ret = PTR_ERR(priv->enable_gpio);
  407. dev_err(&priv->client->dev, "Failed to get enable gpio: %d\n",
  408. ret);
  409. return ret;
  410. }
  411. priv->regulator = devm_regulator_get(priv->dev, "vled");
  412. if (IS_ERR(priv->regulator))
  413. priv->regulator = NULL;
  414. device_for_each_child_node(priv->dev, child) {
  415. led = &priv->leds[i];
  416. ret = fwnode_property_count_u32(child, "reg");
  417. if (ret < 0) {
  418. dev_err(&priv->client->dev, "reg property is invalid\n");
  419. goto child_out;
  420. }
  421. ret = lp50xx_probe_leds(child, priv, led, ret);
  422. if (ret)
  423. goto child_out;
  424. init_data.fwnode = child;
  425. num_colors = 0;
  426. /*
  427. * There are only 3 LEDs per module otherwise they should be
  428. * banked which also is presented as 3 LEDs.
  429. */
  430. mc_led_info = devm_kcalloc(priv->dev, LP50XX_LEDS_PER_MODULE,
  431. sizeof(*mc_led_info), GFP_KERNEL);
  432. if (!mc_led_info) {
  433. ret = -ENOMEM;
  434. goto child_out;
  435. }
  436. fwnode_for_each_child_node(child, led_node) {
  437. ret = fwnode_property_read_u32(led_node, "color",
  438. &color_id);
  439. if (ret) {
  440. fwnode_handle_put(led_node);
  441. dev_err(priv->dev, "Cannot read color\n");
  442. goto child_out;
  443. }
  444. mc_led_info[num_colors].color_index = color_id;
  445. num_colors++;
  446. }
  447. led->priv = priv;
  448. led->mc_cdev.num_colors = num_colors;
  449. led->mc_cdev.subled_info = mc_led_info;
  450. led_cdev = &led->mc_cdev.led_cdev;
  451. led_cdev->brightness_set_blocking = lp50xx_brightness_set;
  452. ret = devm_led_classdev_multicolor_register_ext(&priv->client->dev,
  453. &led->mc_cdev,
  454. &init_data);
  455. if (ret) {
  456. dev_err(&priv->client->dev, "led register err: %d\n",
  457. ret);
  458. goto child_out;
  459. }
  460. i++;
  461. }
  462. return 0;
  463. child_out:
  464. fwnode_handle_put(child);
  465. return ret;
  466. }
  467. static int lp50xx_probe(struct i2c_client *client,
  468. const struct i2c_device_id *id)
  469. {
  470. struct lp50xx *led;
  471. int count;
  472. int ret;
  473. count = device_get_child_node_count(&client->dev);
  474. if (!count) {
  475. dev_err(&client->dev, "LEDs are not defined in device tree!");
  476. return -ENODEV;
  477. }
  478. led = devm_kzalloc(&client->dev, struct_size(led, leds, count),
  479. GFP_KERNEL);
  480. if (!led)
  481. return -ENOMEM;
  482. mutex_init(&led->lock);
  483. led->client = client;
  484. led->dev = &client->dev;
  485. led->chip_info = &lp50xx_chip_info_tbl[id->driver_data];
  486. i2c_set_clientdata(client, led);
  487. led->regmap = devm_regmap_init_i2c(client,
  488. led->chip_info->lp50xx_regmap_config);
  489. if (IS_ERR(led->regmap)) {
  490. ret = PTR_ERR(led->regmap);
  491. dev_err(&client->dev, "Failed to allocate register map: %d\n",
  492. ret);
  493. return ret;
  494. }
  495. ret = lp50xx_reset(led);
  496. if (ret)
  497. return ret;
  498. ret = lp50xx_enable_disable(led, 1);
  499. if (ret)
  500. return ret;
  501. return lp50xx_probe_dt(led);
  502. }
  503. static int lp50xx_remove(struct i2c_client *client)
  504. {
  505. struct lp50xx *led = i2c_get_clientdata(client);
  506. int ret;
  507. ret = lp50xx_enable_disable(led, 0);
  508. if (ret) {
  509. dev_err(&led->client->dev, "Failed to disable chip\n");
  510. return ret;
  511. }
  512. if (led->regulator) {
  513. ret = regulator_disable(led->regulator);
  514. if (ret)
  515. dev_err(&led->client->dev,
  516. "Failed to disable regulator\n");
  517. }
  518. mutex_destroy(&led->lock);
  519. return 0;
  520. }
  521. static const struct i2c_device_id lp50xx_id[] = {
  522. { "lp5009", LP5009 },
  523. { "lp5012", LP5012 },
  524. { "lp5018", LP5018 },
  525. { "lp5024", LP5024 },
  526. { "lp5030", LP5030 },
  527. { "lp5036", LP5036 },
  528. { }
  529. };
  530. MODULE_DEVICE_TABLE(i2c, lp50xx_id);
  531. static const struct of_device_id of_lp50xx_leds_match[] = {
  532. { .compatible = "ti,lp5009", .data = (void *)LP5009 },
  533. { .compatible = "ti,lp5012", .data = (void *)LP5012 },
  534. { .compatible = "ti,lp5018", .data = (void *)LP5018 },
  535. { .compatible = "ti,lp5024", .data = (void *)LP5024 },
  536. { .compatible = "ti,lp5030", .data = (void *)LP5030 },
  537. { .compatible = "ti,lp5036", .data = (void *)LP5036 },
  538. {},
  539. };
  540. MODULE_DEVICE_TABLE(of, of_lp50xx_leds_match);
  541. static struct i2c_driver lp50xx_driver = {
  542. .driver = {
  543. .name = "lp50xx",
  544. .of_match_table = of_lp50xx_leds_match,
  545. },
  546. .probe = lp50xx_probe,
  547. .remove = lp50xx_remove,
  548. .id_table = lp50xx_id,
  549. };
  550. module_i2c_driver(lp50xx_driver);
  551. MODULE_DESCRIPTION("Texas Instruments LP50XX LED driver");
  552. MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");
  553. MODULE_LICENSE("GPL v2");