leds-lm355x.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Simple driver for Texas Instruments LM355x LED Flash driver chip
  4. * Copyright (C) 2012 Texas Instruments
  5. */
  6. #include <linux/module.h>
  7. #include <linux/delay.h>
  8. #include <linux/i2c.h>
  9. #include <linux/leds.h>
  10. #include <linux/slab.h>
  11. #include <linux/platform_device.h>
  12. #include <linux/fs.h>
  13. #include <linux/regmap.h>
  14. #include <linux/platform_data/leds-lm355x.h>
  15. enum lm355x_type {
  16. CHIP_LM3554 = 0,
  17. CHIP_LM3556,
  18. };
  19. enum lm355x_regs {
  20. REG_FLAG = 0,
  21. REG_TORCH_CFG,
  22. REG_TORCH_CTRL,
  23. REG_STROBE_CFG,
  24. REG_FLASH_CTRL,
  25. REG_INDI_CFG,
  26. REG_INDI_CTRL,
  27. REG_OPMODE,
  28. REG_MAX,
  29. };
  30. /* operation mode */
  31. enum lm355x_mode {
  32. MODE_SHDN = 0,
  33. MODE_INDIC,
  34. MODE_TORCH,
  35. MODE_FLASH
  36. };
  37. /* register map info. */
  38. struct lm355x_reg_data {
  39. u8 regno;
  40. u8 mask;
  41. u8 shift;
  42. };
  43. struct lm355x_chip_data {
  44. struct device *dev;
  45. enum lm355x_type type;
  46. struct led_classdev cdev_flash;
  47. struct led_classdev cdev_torch;
  48. struct led_classdev cdev_indicator;
  49. struct lm355x_platform_data *pdata;
  50. struct regmap *regmap;
  51. struct mutex lock;
  52. unsigned int last_flag;
  53. struct lm355x_reg_data *regs;
  54. };
  55. /* specific indicator function for lm3556 */
  56. enum lm3556_indic_pulse_time {
  57. PULSE_TIME_0_MS = 0,
  58. PULSE_TIME_32_MS,
  59. PULSE_TIME_64_MS,
  60. PULSE_TIME_92_MS,
  61. PULSE_TIME_128_MS,
  62. PULSE_TIME_160_MS,
  63. PULSE_TIME_196_MS,
  64. PULSE_TIME_224_MS,
  65. PULSE_TIME_256_MS,
  66. PULSE_TIME_288_MS,
  67. PULSE_TIME_320_MS,
  68. PULSE_TIME_352_MS,
  69. PULSE_TIME_384_MS,
  70. PULSE_TIME_416_MS,
  71. PULSE_TIME_448_MS,
  72. PULSE_TIME_480_MS,
  73. };
  74. enum lm3556_indic_n_blank {
  75. INDIC_N_BLANK_0 = 0,
  76. INDIC_N_BLANK_1,
  77. INDIC_N_BLANK_2,
  78. INDIC_N_BLANK_3,
  79. INDIC_N_BLANK_4,
  80. INDIC_N_BLANK_5,
  81. INDIC_N_BLANK_6,
  82. INDIC_N_BLANK_7,
  83. INDIC_N_BLANK_8,
  84. INDIC_N_BLANK_9,
  85. INDIC_N_BLANK_10,
  86. INDIC_N_BLANK_11,
  87. INDIC_N_BLANK_12,
  88. INDIC_N_BLANK_13,
  89. INDIC_N_BLANK_14,
  90. INDIC_N_BLANK_15,
  91. };
  92. enum lm3556_indic_period {
  93. INDIC_PERIOD_0 = 0,
  94. INDIC_PERIOD_1,
  95. INDIC_PERIOD_2,
  96. INDIC_PERIOD_3,
  97. INDIC_PERIOD_4,
  98. INDIC_PERIOD_5,
  99. INDIC_PERIOD_6,
  100. INDIC_PERIOD_7,
  101. };
  102. #define INDIC_PATTERN_SIZE 4
  103. struct indicator {
  104. u8 blinking;
  105. u8 period_cnt;
  106. };
  107. /* indicator pattern data only for lm3556 */
  108. static struct indicator indicator_pattern[INDIC_PATTERN_SIZE] = {
  109. [0] = {(INDIC_N_BLANK_1 << 4) | PULSE_TIME_32_MS, INDIC_PERIOD_1},
  110. [1] = {(INDIC_N_BLANK_15 << 4) | PULSE_TIME_32_MS, INDIC_PERIOD_2},
  111. [2] = {(INDIC_N_BLANK_10 << 4) | PULSE_TIME_32_MS, INDIC_PERIOD_4},
  112. [3] = {(INDIC_N_BLANK_5 << 4) | PULSE_TIME_32_MS, INDIC_PERIOD_7},
  113. };
  114. static struct lm355x_reg_data lm3554_regs[REG_MAX] = {
  115. [REG_FLAG] = {0xD0, 0xBF, 0},
  116. [REG_TORCH_CFG] = {0xE0, 0x80, 7},
  117. [REG_TORCH_CTRL] = {0xA0, 0x38, 3},
  118. [REG_STROBE_CFG] = {0xE0, 0x04, 2},
  119. [REG_FLASH_CTRL] = {0xB0, 0x78, 3},
  120. [REG_INDI_CFG] = {0xE0, 0x08, 3},
  121. [REG_INDI_CTRL] = {0xA0, 0xC0, 6},
  122. [REG_OPMODE] = {0xA0, 0x03, 0},
  123. };
  124. static struct lm355x_reg_data lm3556_regs[REG_MAX] = {
  125. [REG_FLAG] = {0x0B, 0xFF, 0},
  126. [REG_TORCH_CFG] = {0x0A, 0x10, 4},
  127. [REG_TORCH_CTRL] = {0x09, 0x70, 4},
  128. [REG_STROBE_CFG] = {0x0A, 0x20, 5},
  129. [REG_FLASH_CTRL] = {0x09, 0x0F, 0},
  130. [REG_INDI_CFG] = {0xFF, 0xFF, 0},
  131. [REG_INDI_CTRL] = {0x09, 0x70, 4},
  132. [REG_OPMODE] = {0x0A, 0x03, 0},
  133. };
  134. static char lm355x_name[][I2C_NAME_SIZE] = {
  135. [CHIP_LM3554] = LM3554_NAME,
  136. [CHIP_LM3556] = LM3556_NAME,
  137. };
  138. /* chip initialize */
  139. static int lm355x_chip_init(struct lm355x_chip_data *chip)
  140. {
  141. int ret;
  142. unsigned int reg_val;
  143. struct lm355x_platform_data *pdata = chip->pdata;
  144. /* input and output pins configuration */
  145. switch (chip->type) {
  146. case CHIP_LM3554:
  147. reg_val = (u32)pdata->pin_tx2 | (u32)pdata->ntc_pin;
  148. ret = regmap_update_bits(chip->regmap, 0xE0, 0x28, reg_val);
  149. if (ret < 0)
  150. goto out;
  151. reg_val = (u32)pdata->pass_mode;
  152. ret = regmap_update_bits(chip->regmap, 0xA0, 0x04, reg_val);
  153. if (ret < 0)
  154. goto out;
  155. break;
  156. case CHIP_LM3556:
  157. reg_val = (u32)pdata->pin_tx2 | (u32)pdata->ntc_pin |
  158. (u32)pdata->pass_mode;
  159. ret = regmap_update_bits(chip->regmap, 0x0A, 0xC4, reg_val);
  160. if (ret < 0)
  161. goto out;
  162. break;
  163. default:
  164. return -ENODATA;
  165. }
  166. return ret;
  167. out:
  168. dev_err(chip->dev, "%s:i2c access fail to register\n", __func__);
  169. return ret;
  170. }
  171. /* chip control */
  172. static int lm355x_control(struct lm355x_chip_data *chip,
  173. u8 brightness, enum lm355x_mode opmode)
  174. {
  175. int ret;
  176. unsigned int reg_val;
  177. struct lm355x_platform_data *pdata = chip->pdata;
  178. struct lm355x_reg_data *preg = chip->regs;
  179. ret = regmap_read(chip->regmap, preg[REG_FLAG].regno, &chip->last_flag);
  180. if (ret < 0)
  181. goto out;
  182. if (chip->last_flag & preg[REG_FLAG].mask)
  183. dev_info(chip->dev, "%s Last FLAG is 0x%x\n",
  184. lm355x_name[chip->type],
  185. chip->last_flag & preg[REG_FLAG].mask);
  186. /* brightness 0 means shutdown */
  187. if (!brightness)
  188. opmode = MODE_SHDN;
  189. switch (opmode) {
  190. case MODE_TORCH:
  191. ret =
  192. regmap_update_bits(chip->regmap, preg[REG_TORCH_CTRL].regno,
  193. preg[REG_TORCH_CTRL].mask,
  194. (brightness - 1)
  195. << preg[REG_TORCH_CTRL].shift);
  196. if (ret < 0)
  197. goto out;
  198. if (pdata->pin_tx1 != LM355x_PIN_TORCH_DISABLE) {
  199. ret =
  200. regmap_update_bits(chip->regmap,
  201. preg[REG_TORCH_CFG].regno,
  202. preg[REG_TORCH_CFG].mask,
  203. 0x01 <<
  204. preg[REG_TORCH_CFG].shift);
  205. if (ret < 0)
  206. goto out;
  207. opmode = MODE_SHDN;
  208. dev_info(chip->dev,
  209. "torch brt is set - ext. torch pin mode\n");
  210. }
  211. break;
  212. case MODE_FLASH:
  213. ret =
  214. regmap_update_bits(chip->regmap, preg[REG_FLASH_CTRL].regno,
  215. preg[REG_FLASH_CTRL].mask,
  216. (brightness - 1)
  217. << preg[REG_FLASH_CTRL].shift);
  218. if (ret < 0)
  219. goto out;
  220. if (pdata->pin_strobe != LM355x_PIN_STROBE_DISABLE) {
  221. if (chip->type == CHIP_LM3554)
  222. reg_val = 0x00;
  223. else
  224. reg_val = 0x01;
  225. ret =
  226. regmap_update_bits(chip->regmap,
  227. preg[REG_STROBE_CFG].regno,
  228. preg[REG_STROBE_CFG].mask,
  229. reg_val <<
  230. preg[REG_STROBE_CFG].shift);
  231. if (ret < 0)
  232. goto out;
  233. opmode = MODE_SHDN;
  234. dev_info(chip->dev,
  235. "flash brt is set - ext. strobe pin mode\n");
  236. }
  237. break;
  238. case MODE_INDIC:
  239. ret =
  240. regmap_update_bits(chip->regmap, preg[REG_INDI_CTRL].regno,
  241. preg[REG_INDI_CTRL].mask,
  242. (brightness - 1)
  243. << preg[REG_INDI_CTRL].shift);
  244. if (ret < 0)
  245. goto out;
  246. if (pdata->pin_tx2 != LM355x_PIN_TX_DISABLE) {
  247. ret =
  248. regmap_update_bits(chip->regmap,
  249. preg[REG_INDI_CFG].regno,
  250. preg[REG_INDI_CFG].mask,
  251. 0x01 <<
  252. preg[REG_INDI_CFG].shift);
  253. if (ret < 0)
  254. goto out;
  255. opmode = MODE_SHDN;
  256. }
  257. break;
  258. case MODE_SHDN:
  259. break;
  260. default:
  261. return -EINVAL;
  262. }
  263. /* operation mode control */
  264. ret = regmap_update_bits(chip->regmap, preg[REG_OPMODE].regno,
  265. preg[REG_OPMODE].mask,
  266. opmode << preg[REG_OPMODE].shift);
  267. if (ret < 0)
  268. goto out;
  269. return ret;
  270. out:
  271. dev_err(chip->dev, "%s:i2c access fail to register\n", __func__);
  272. return ret;
  273. }
  274. /* torch */
  275. static int lm355x_torch_brightness_set(struct led_classdev *cdev,
  276. enum led_brightness brightness)
  277. {
  278. struct lm355x_chip_data *chip =
  279. container_of(cdev, struct lm355x_chip_data, cdev_torch);
  280. int ret;
  281. mutex_lock(&chip->lock);
  282. ret = lm355x_control(chip, brightness, MODE_TORCH);
  283. mutex_unlock(&chip->lock);
  284. return ret;
  285. }
  286. /* flash */
  287. static int lm355x_strobe_brightness_set(struct led_classdev *cdev,
  288. enum led_brightness brightness)
  289. {
  290. struct lm355x_chip_data *chip =
  291. container_of(cdev, struct lm355x_chip_data, cdev_flash);
  292. int ret;
  293. mutex_lock(&chip->lock);
  294. ret = lm355x_control(chip, brightness, MODE_FLASH);
  295. mutex_unlock(&chip->lock);
  296. return ret;
  297. }
  298. /* indicator */
  299. static int lm355x_indicator_brightness_set(struct led_classdev *cdev,
  300. enum led_brightness brightness)
  301. {
  302. struct lm355x_chip_data *chip =
  303. container_of(cdev, struct lm355x_chip_data, cdev_indicator);
  304. int ret;
  305. mutex_lock(&chip->lock);
  306. ret = lm355x_control(chip, brightness, MODE_INDIC);
  307. mutex_unlock(&chip->lock);
  308. return ret;
  309. }
  310. /* indicator pattern only for lm3556*/
  311. static ssize_t lm3556_indicator_pattern_store(struct device *dev,
  312. struct device_attribute *attr,
  313. const char *buf, size_t size)
  314. {
  315. ssize_t ret;
  316. struct led_classdev *led_cdev = dev_get_drvdata(dev);
  317. struct lm355x_chip_data *chip =
  318. container_of(led_cdev, struct lm355x_chip_data, cdev_indicator);
  319. unsigned int state;
  320. ret = kstrtouint(buf, 10, &state);
  321. if (ret)
  322. goto out;
  323. if (state > INDIC_PATTERN_SIZE - 1)
  324. state = INDIC_PATTERN_SIZE - 1;
  325. ret = regmap_write(chip->regmap, 0x04,
  326. indicator_pattern[state].blinking);
  327. if (ret < 0)
  328. goto out;
  329. ret = regmap_write(chip->regmap, 0x05,
  330. indicator_pattern[state].period_cnt);
  331. if (ret < 0)
  332. goto out;
  333. return size;
  334. out:
  335. dev_err(chip->dev, "%s:i2c access fail to register\n", __func__);
  336. return ret;
  337. }
  338. static DEVICE_ATTR(pattern, S_IWUSR, NULL, lm3556_indicator_pattern_store);
  339. static struct attribute *lm355x_indicator_attrs[] = {
  340. &dev_attr_pattern.attr,
  341. NULL
  342. };
  343. ATTRIBUTE_GROUPS(lm355x_indicator);
  344. static const struct regmap_config lm355x_regmap = {
  345. .reg_bits = 8,
  346. .val_bits = 8,
  347. .max_register = 0xFF,
  348. };
  349. /* module initialize */
  350. static int lm355x_probe(struct i2c_client *client,
  351. const struct i2c_device_id *id)
  352. {
  353. struct lm355x_platform_data *pdata = dev_get_platdata(&client->dev);
  354. struct lm355x_chip_data *chip;
  355. int err;
  356. if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
  357. dev_err(&client->dev, "i2c functionality check fail.\n");
  358. return -EOPNOTSUPP;
  359. }
  360. if (pdata == NULL) {
  361. dev_err(&client->dev, "needs Platform Data.\n");
  362. return -ENODATA;
  363. }
  364. chip = devm_kzalloc(&client->dev,
  365. sizeof(struct lm355x_chip_data), GFP_KERNEL);
  366. if (!chip)
  367. return -ENOMEM;
  368. chip->dev = &client->dev;
  369. chip->type = id->driver_data;
  370. switch (id->driver_data) {
  371. case CHIP_LM3554:
  372. chip->regs = lm3554_regs;
  373. break;
  374. case CHIP_LM3556:
  375. chip->regs = lm3556_regs;
  376. break;
  377. default:
  378. return -ENOSYS;
  379. }
  380. chip->pdata = pdata;
  381. chip->regmap = devm_regmap_init_i2c(client, &lm355x_regmap);
  382. if (IS_ERR(chip->regmap)) {
  383. err = PTR_ERR(chip->regmap);
  384. dev_err(&client->dev,
  385. "Failed to allocate register map: %d\n", err);
  386. return err;
  387. }
  388. mutex_init(&chip->lock);
  389. i2c_set_clientdata(client, chip);
  390. err = lm355x_chip_init(chip);
  391. if (err < 0)
  392. goto err_out;
  393. /* flash */
  394. chip->cdev_flash.name = "flash";
  395. chip->cdev_flash.max_brightness = 16;
  396. chip->cdev_flash.brightness_set_blocking = lm355x_strobe_brightness_set;
  397. chip->cdev_flash.default_trigger = "flash";
  398. err = led_classdev_register(&client->dev, &chip->cdev_flash);
  399. if (err < 0)
  400. goto err_out;
  401. /* torch */
  402. chip->cdev_torch.name = "torch";
  403. chip->cdev_torch.max_brightness = 8;
  404. chip->cdev_torch.brightness_set_blocking = lm355x_torch_brightness_set;
  405. chip->cdev_torch.default_trigger = "torch";
  406. err = led_classdev_register(&client->dev, &chip->cdev_torch);
  407. if (err < 0)
  408. goto err_create_torch_file;
  409. /* indicator */
  410. chip->cdev_indicator.name = "indicator";
  411. if (id->driver_data == CHIP_LM3554)
  412. chip->cdev_indicator.max_brightness = 4;
  413. else
  414. chip->cdev_indicator.max_brightness = 8;
  415. chip->cdev_indicator.brightness_set_blocking =
  416. lm355x_indicator_brightness_set;
  417. /* indicator pattern control only for LM3556 */
  418. if (id->driver_data == CHIP_LM3556)
  419. chip->cdev_indicator.groups = lm355x_indicator_groups;
  420. err = led_classdev_register(&client->dev, &chip->cdev_indicator);
  421. if (err < 0)
  422. goto err_create_indicator_file;
  423. dev_info(&client->dev, "%s is initialized\n",
  424. lm355x_name[id->driver_data]);
  425. return 0;
  426. err_create_indicator_file:
  427. led_classdev_unregister(&chip->cdev_torch);
  428. err_create_torch_file:
  429. led_classdev_unregister(&chip->cdev_flash);
  430. err_out:
  431. return err;
  432. }
  433. static int lm355x_remove(struct i2c_client *client)
  434. {
  435. struct lm355x_chip_data *chip = i2c_get_clientdata(client);
  436. struct lm355x_reg_data *preg = chip->regs;
  437. regmap_write(chip->regmap, preg[REG_OPMODE].regno, 0);
  438. led_classdev_unregister(&chip->cdev_indicator);
  439. led_classdev_unregister(&chip->cdev_torch);
  440. led_classdev_unregister(&chip->cdev_flash);
  441. dev_info(&client->dev, "%s is removed\n", lm355x_name[chip->type]);
  442. return 0;
  443. }
  444. static const struct i2c_device_id lm355x_id[] = {
  445. {LM3554_NAME, CHIP_LM3554},
  446. {LM3556_NAME, CHIP_LM3556},
  447. {}
  448. };
  449. MODULE_DEVICE_TABLE(i2c, lm355x_id);
  450. static struct i2c_driver lm355x_i2c_driver = {
  451. .driver = {
  452. .name = LM355x_NAME,
  453. .pm = NULL,
  454. },
  455. .probe = lm355x_probe,
  456. .remove = lm355x_remove,
  457. .id_table = lm355x_id,
  458. };
  459. module_i2c_driver(lm355x_i2c_driver);
  460. MODULE_DESCRIPTION("Texas Instruments Flash Lighting driver for LM355x");
  461. MODULE_AUTHOR("Daniel Jeong <daniel.jeong@ti.com>");
  462. MODULE_AUTHOR("G.Shark Jeong <gshark.jeong@gmail.com>");
  463. MODULE_LICENSE("GPL v2");