leds-lm3642.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Simple driver for Texas Instruments LM3642 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-lm3642.h>
  15. #define REG_FILT_TIME (0x0)
  16. #define REG_IVFM_MODE (0x1)
  17. #define REG_TORCH_TIME (0x6)
  18. #define REG_FLASH (0x8)
  19. #define REG_I_CTRL (0x9)
  20. #define REG_ENABLE (0xA)
  21. #define REG_FLAG (0xB)
  22. #define REG_MAX (0xB)
  23. #define UVLO_EN_SHIFT (7)
  24. #define IVM_D_TH_SHIFT (2)
  25. #define TORCH_RAMP_UP_TIME_SHIFT (3)
  26. #define TORCH_RAMP_DN_TIME_SHIFT (0)
  27. #define INDUCTOR_I_LIMIT_SHIFT (6)
  28. #define FLASH_RAMP_TIME_SHIFT (3)
  29. #define FLASH_TOUT_TIME_SHIFT (0)
  30. #define TORCH_I_SHIFT (4)
  31. #define FLASH_I_SHIFT (0)
  32. #define IVFM_SHIFT (7)
  33. #define TX_PIN_EN_SHIFT (6)
  34. #define STROBE_PIN_EN_SHIFT (5)
  35. #define TORCH_PIN_EN_SHIFT (4)
  36. #define MODE_BITS_SHIFT (0)
  37. #define UVLO_EN_MASK (0x1)
  38. #define IVM_D_TH_MASK (0x7)
  39. #define TORCH_RAMP_UP_TIME_MASK (0x7)
  40. #define TORCH_RAMP_DN_TIME_MASK (0x7)
  41. #define INDUCTOR_I_LIMIT_MASK (0x1)
  42. #define FLASH_RAMP_TIME_MASK (0x7)
  43. #define FLASH_TOUT_TIME_MASK (0x7)
  44. #define TORCH_I_MASK (0x7)
  45. #define FLASH_I_MASK (0xF)
  46. #define IVFM_MASK (0x1)
  47. #define TX_PIN_EN_MASK (0x1)
  48. #define STROBE_PIN_EN_MASK (0x1)
  49. #define TORCH_PIN_EN_MASK (0x1)
  50. #define MODE_BITS_MASK (0x73)
  51. #define EX_PIN_CONTROL_MASK (0x71)
  52. #define EX_PIN_ENABLE_MASK (0x70)
  53. enum lm3642_mode {
  54. MODES_STASNDBY = 0,
  55. MODES_INDIC,
  56. MODES_TORCH,
  57. MODES_FLASH
  58. };
  59. struct lm3642_chip_data {
  60. struct device *dev;
  61. struct led_classdev cdev_flash;
  62. struct led_classdev cdev_torch;
  63. struct led_classdev cdev_indicator;
  64. u8 br_flash;
  65. u8 br_torch;
  66. u8 br_indicator;
  67. enum lm3642_torch_pin_enable torch_pin;
  68. enum lm3642_strobe_pin_enable strobe_pin;
  69. enum lm3642_tx_pin_enable tx_pin;
  70. struct lm3642_platform_data *pdata;
  71. struct regmap *regmap;
  72. struct mutex lock;
  73. unsigned int last_flag;
  74. };
  75. /* chip initialize */
  76. static int lm3642_chip_init(struct lm3642_chip_data *chip)
  77. {
  78. int ret;
  79. struct lm3642_platform_data *pdata = chip->pdata;
  80. /* set enable register */
  81. ret = regmap_update_bits(chip->regmap, REG_ENABLE, EX_PIN_ENABLE_MASK,
  82. pdata->tx_pin);
  83. if (ret < 0)
  84. dev_err(chip->dev, "Failed to update REG_ENABLE Register\n");
  85. return ret;
  86. }
  87. /* chip control */
  88. static int lm3642_control(struct lm3642_chip_data *chip,
  89. u8 brightness, enum lm3642_mode opmode)
  90. {
  91. int ret;
  92. ret = regmap_read(chip->regmap, REG_FLAG, &chip->last_flag);
  93. if (ret < 0) {
  94. dev_err(chip->dev, "Failed to read REG_FLAG Register\n");
  95. return ret;
  96. }
  97. if (chip->last_flag)
  98. dev_info(chip->dev, "Last FLAG is 0x%x\n", chip->last_flag);
  99. /* brightness 0 means off-state */
  100. if (!brightness)
  101. opmode = MODES_STASNDBY;
  102. switch (opmode) {
  103. case MODES_TORCH:
  104. ret = regmap_update_bits(chip->regmap, REG_I_CTRL,
  105. TORCH_I_MASK << TORCH_I_SHIFT,
  106. (brightness - 1) << TORCH_I_SHIFT);
  107. if (chip->torch_pin)
  108. opmode |= (TORCH_PIN_EN_MASK << TORCH_PIN_EN_SHIFT);
  109. break;
  110. case MODES_FLASH:
  111. ret = regmap_update_bits(chip->regmap, REG_I_CTRL,
  112. FLASH_I_MASK << FLASH_I_SHIFT,
  113. (brightness - 1) << FLASH_I_SHIFT);
  114. if (chip->strobe_pin)
  115. opmode |= (STROBE_PIN_EN_MASK << STROBE_PIN_EN_SHIFT);
  116. break;
  117. case MODES_INDIC:
  118. ret = regmap_update_bits(chip->regmap, REG_I_CTRL,
  119. TORCH_I_MASK << TORCH_I_SHIFT,
  120. (brightness - 1) << TORCH_I_SHIFT);
  121. break;
  122. case MODES_STASNDBY:
  123. break;
  124. default:
  125. return -EINVAL;
  126. }
  127. if (ret < 0) {
  128. dev_err(chip->dev, "Failed to write REG_I_CTRL Register\n");
  129. return ret;
  130. }
  131. if (chip->tx_pin)
  132. opmode |= (TX_PIN_EN_MASK << TX_PIN_EN_SHIFT);
  133. ret = regmap_update_bits(chip->regmap, REG_ENABLE,
  134. MODE_BITS_MASK << MODE_BITS_SHIFT,
  135. opmode << MODE_BITS_SHIFT);
  136. return ret;
  137. }
  138. /* torch */
  139. /* torch pin config for lm3642 */
  140. static ssize_t lm3642_torch_pin_store(struct device *dev,
  141. struct device_attribute *attr,
  142. const char *buf, size_t size)
  143. {
  144. ssize_t ret;
  145. struct led_classdev *led_cdev = dev_get_drvdata(dev);
  146. struct lm3642_chip_data *chip =
  147. container_of(led_cdev, struct lm3642_chip_data, cdev_indicator);
  148. unsigned int state;
  149. ret = kstrtouint(buf, 10, &state);
  150. if (ret)
  151. return ret;
  152. if (state != 0)
  153. state = 0x01 << TORCH_PIN_EN_SHIFT;
  154. chip->torch_pin = state;
  155. ret = regmap_update_bits(chip->regmap, REG_ENABLE,
  156. TORCH_PIN_EN_MASK << TORCH_PIN_EN_SHIFT,
  157. state);
  158. if (ret < 0) {
  159. dev_err(chip->dev, "%s:i2c access fail to register\n", __func__);
  160. return ret;
  161. }
  162. return size;
  163. }
  164. static DEVICE_ATTR(torch_pin, S_IWUSR, NULL, lm3642_torch_pin_store);
  165. static int lm3642_torch_brightness_set(struct led_classdev *cdev,
  166. enum led_brightness brightness)
  167. {
  168. struct lm3642_chip_data *chip =
  169. container_of(cdev, struct lm3642_chip_data, cdev_torch);
  170. int ret;
  171. mutex_lock(&chip->lock);
  172. chip->br_torch = brightness;
  173. ret = lm3642_control(chip, chip->br_torch, MODES_TORCH);
  174. mutex_unlock(&chip->lock);
  175. return ret;
  176. }
  177. /* flash */
  178. /* strobe pin config for lm3642*/
  179. static ssize_t lm3642_strobe_pin_store(struct device *dev,
  180. struct device_attribute *attr,
  181. const char *buf, size_t size)
  182. {
  183. ssize_t ret;
  184. struct led_classdev *led_cdev = dev_get_drvdata(dev);
  185. struct lm3642_chip_data *chip =
  186. container_of(led_cdev, struct lm3642_chip_data, cdev_indicator);
  187. unsigned int state;
  188. ret = kstrtouint(buf, 10, &state);
  189. if (ret)
  190. return ret;
  191. if (state != 0)
  192. state = 0x01 << STROBE_PIN_EN_SHIFT;
  193. chip->strobe_pin = state;
  194. ret = regmap_update_bits(chip->regmap, REG_ENABLE,
  195. STROBE_PIN_EN_MASK << STROBE_PIN_EN_SHIFT,
  196. state);
  197. if (ret < 0) {
  198. dev_err(chip->dev, "%s:i2c access fail to register\n", __func__);
  199. return ret;
  200. }
  201. return size;
  202. }
  203. static DEVICE_ATTR(strobe_pin, S_IWUSR, NULL, lm3642_strobe_pin_store);
  204. static int lm3642_strobe_brightness_set(struct led_classdev *cdev,
  205. enum led_brightness brightness)
  206. {
  207. struct lm3642_chip_data *chip =
  208. container_of(cdev, struct lm3642_chip_data, cdev_flash);
  209. int ret;
  210. mutex_lock(&chip->lock);
  211. chip->br_flash = brightness;
  212. ret = lm3642_control(chip, chip->br_flash, MODES_FLASH);
  213. mutex_unlock(&chip->lock);
  214. return ret;
  215. }
  216. /* indicator */
  217. static int lm3642_indicator_brightness_set(struct led_classdev *cdev,
  218. enum led_brightness brightness)
  219. {
  220. struct lm3642_chip_data *chip =
  221. container_of(cdev, struct lm3642_chip_data, cdev_indicator);
  222. int ret;
  223. mutex_lock(&chip->lock);
  224. chip->br_indicator = brightness;
  225. ret = lm3642_control(chip, chip->br_indicator, MODES_INDIC);
  226. mutex_unlock(&chip->lock);
  227. return ret;
  228. }
  229. static const struct regmap_config lm3642_regmap = {
  230. .reg_bits = 8,
  231. .val_bits = 8,
  232. .max_register = REG_MAX,
  233. };
  234. static struct attribute *lm3642_flash_attrs[] = {
  235. &dev_attr_strobe_pin.attr,
  236. NULL
  237. };
  238. ATTRIBUTE_GROUPS(lm3642_flash);
  239. static struct attribute *lm3642_torch_attrs[] = {
  240. &dev_attr_torch_pin.attr,
  241. NULL
  242. };
  243. ATTRIBUTE_GROUPS(lm3642_torch);
  244. static int lm3642_probe(struct i2c_client *client,
  245. const struct i2c_device_id *id)
  246. {
  247. struct lm3642_platform_data *pdata = dev_get_platdata(&client->dev);
  248. struct lm3642_chip_data *chip;
  249. int err;
  250. if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
  251. dev_err(&client->dev, "i2c functionality check fail.\n");
  252. return -EOPNOTSUPP;
  253. }
  254. if (pdata == NULL) {
  255. dev_err(&client->dev, "needs Platform Data.\n");
  256. return -ENODATA;
  257. }
  258. chip = devm_kzalloc(&client->dev,
  259. sizeof(struct lm3642_chip_data), GFP_KERNEL);
  260. if (!chip)
  261. return -ENOMEM;
  262. chip->dev = &client->dev;
  263. chip->pdata = pdata;
  264. chip->tx_pin = pdata->tx_pin;
  265. chip->torch_pin = pdata->torch_pin;
  266. chip->strobe_pin = pdata->strobe_pin;
  267. chip->regmap = devm_regmap_init_i2c(client, &lm3642_regmap);
  268. if (IS_ERR(chip->regmap)) {
  269. err = PTR_ERR(chip->regmap);
  270. dev_err(&client->dev, "Failed to allocate register map: %d\n",
  271. err);
  272. return err;
  273. }
  274. mutex_init(&chip->lock);
  275. i2c_set_clientdata(client, chip);
  276. err = lm3642_chip_init(chip);
  277. if (err < 0)
  278. goto err_out;
  279. /* flash */
  280. chip->cdev_flash.name = "flash";
  281. chip->cdev_flash.max_brightness = 16;
  282. chip->cdev_flash.brightness_set_blocking = lm3642_strobe_brightness_set;
  283. chip->cdev_flash.default_trigger = "flash";
  284. chip->cdev_flash.groups = lm3642_flash_groups,
  285. err = led_classdev_register(&client->dev, &chip->cdev_flash);
  286. if (err < 0) {
  287. dev_err(chip->dev, "failed to register flash\n");
  288. goto err_out;
  289. }
  290. /* torch */
  291. chip->cdev_torch.name = "torch";
  292. chip->cdev_torch.max_brightness = 8;
  293. chip->cdev_torch.brightness_set_blocking = lm3642_torch_brightness_set;
  294. chip->cdev_torch.default_trigger = "torch";
  295. chip->cdev_torch.groups = lm3642_torch_groups,
  296. err = led_classdev_register(&client->dev, &chip->cdev_torch);
  297. if (err < 0) {
  298. dev_err(chip->dev, "failed to register torch\n");
  299. goto err_create_torch_file;
  300. }
  301. /* indicator */
  302. chip->cdev_indicator.name = "indicator";
  303. chip->cdev_indicator.max_brightness = 8;
  304. chip->cdev_indicator.brightness_set_blocking =
  305. lm3642_indicator_brightness_set;
  306. err = led_classdev_register(&client->dev, &chip->cdev_indicator);
  307. if (err < 0) {
  308. dev_err(chip->dev, "failed to register indicator\n");
  309. goto err_create_indicator_file;
  310. }
  311. dev_info(&client->dev, "LM3642 is initialized\n");
  312. return 0;
  313. err_create_indicator_file:
  314. led_classdev_unregister(&chip->cdev_torch);
  315. err_create_torch_file:
  316. led_classdev_unregister(&chip->cdev_flash);
  317. err_out:
  318. return err;
  319. }
  320. static int lm3642_remove(struct i2c_client *client)
  321. {
  322. struct lm3642_chip_data *chip = i2c_get_clientdata(client);
  323. led_classdev_unregister(&chip->cdev_indicator);
  324. led_classdev_unregister(&chip->cdev_torch);
  325. led_classdev_unregister(&chip->cdev_flash);
  326. regmap_write(chip->regmap, REG_ENABLE, 0);
  327. return 0;
  328. }
  329. static const struct i2c_device_id lm3642_id[] = {
  330. {LM3642_NAME, 0},
  331. {}
  332. };
  333. MODULE_DEVICE_TABLE(i2c, lm3642_id);
  334. static struct i2c_driver lm3642_i2c_driver = {
  335. .driver = {
  336. .name = LM3642_NAME,
  337. .pm = NULL,
  338. },
  339. .probe = lm3642_probe,
  340. .remove = lm3642_remove,
  341. .id_table = lm3642_id,
  342. };
  343. module_i2c_driver(lm3642_i2c_driver);
  344. MODULE_DESCRIPTION("Texas Instruments Flash Lighting driver for LM3642");
  345. MODULE_AUTHOR("Daniel Jeong <daniel.jeong@ti.com>");
  346. MODULE_AUTHOR("G.Shark Jeong <gshark.jeong@gmail.com>");
  347. MODULE_LICENSE("GPL v2");