leds-mt6323.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * LED driver for Mediatek MT6323 PMIC
  4. *
  5. * Copyright (C) 2017 Sean Wang <sean.wang@mediatek.com>
  6. */
  7. #include <linux/kernel.h>
  8. #include <linux/leds.h>
  9. #include <linux/mfd/mt6323/registers.h>
  10. #include <linux/mfd/mt6397/core.h>
  11. #include <linux/module.h>
  12. #include <linux/of.h>
  13. #include <linux/platform_device.h>
  14. #include <linux/regmap.h>
  15. /*
  16. * Register field for MT6323_TOP_CKPDN0 to enable
  17. * 32K clock common for LED device.
  18. */
  19. #define MT6323_RG_DRV_32K_CK_PDN BIT(11)
  20. #define MT6323_RG_DRV_32K_CK_PDN_MASK BIT(11)
  21. /*
  22. * Register field for MT6323_TOP_CKPDN2 to enable
  23. * individual clock for LED device.
  24. */
  25. #define MT6323_RG_ISINK_CK_PDN(i) BIT(i)
  26. #define MT6323_RG_ISINK_CK_PDN_MASK(i) BIT(i)
  27. /*
  28. * Register field for MT6323_TOP_CKCON1 to select
  29. * clock source.
  30. */
  31. #define MT6323_RG_ISINK_CK_SEL_MASK(i) (BIT(10) << (i))
  32. /*
  33. * Register for MT6323_ISINK_CON0 to setup the
  34. * duty cycle of the blink.
  35. */
  36. #define MT6323_ISINK_CON0(i) (MT6323_ISINK0_CON0 + 0x8 * (i))
  37. #define MT6323_ISINK_DIM_DUTY_MASK (0x1f << 8)
  38. #define MT6323_ISINK_DIM_DUTY(i) (((i) << 8) & \
  39. MT6323_ISINK_DIM_DUTY_MASK)
  40. /* Register to setup the period of the blink. */
  41. #define MT6323_ISINK_CON1(i) (MT6323_ISINK0_CON1 + 0x8 * (i))
  42. #define MT6323_ISINK_DIM_FSEL_MASK (0xffff)
  43. #define MT6323_ISINK_DIM_FSEL(i) ((i) & MT6323_ISINK_DIM_FSEL_MASK)
  44. /* Register to control the brightness. */
  45. #define MT6323_ISINK_CON2(i) (MT6323_ISINK0_CON2 + 0x8 * (i))
  46. #define MT6323_ISINK_CH_STEP_SHIFT 12
  47. #define MT6323_ISINK_CH_STEP_MASK (0x7 << 12)
  48. #define MT6323_ISINK_CH_STEP(i) (((i) << 12) & \
  49. MT6323_ISINK_CH_STEP_MASK)
  50. #define MT6323_ISINK_SFSTR0_TC_MASK (0x3 << 1)
  51. #define MT6323_ISINK_SFSTR0_TC(i) (((i) << 1) & \
  52. MT6323_ISINK_SFSTR0_TC_MASK)
  53. #define MT6323_ISINK_SFSTR0_EN_MASK BIT(0)
  54. #define MT6323_ISINK_SFSTR0_EN BIT(0)
  55. /* Register to LED channel enablement. */
  56. #define MT6323_ISINK_CH_EN_MASK(i) BIT(i)
  57. #define MT6323_ISINK_CH_EN(i) BIT(i)
  58. #define MT6323_MAX_PERIOD 10000
  59. #define MT6323_MAX_LEDS 4
  60. #define MT6323_MAX_BRIGHTNESS 6
  61. #define MT6323_UNIT_DUTY 3125
  62. #define MT6323_CAL_HW_DUTY(o, p) DIV_ROUND_CLOSEST((o) * 100000ul,\
  63. (p) * MT6323_UNIT_DUTY)
  64. struct mt6323_leds;
  65. /**
  66. * struct mt6323_led - state container for the LED device
  67. * @id: the identifier in MT6323 LED device
  68. * @parent: the pointer to MT6323 LED controller
  69. * @cdev: LED class device for this LED device
  70. * @current_brightness: current state of the LED device
  71. */
  72. struct mt6323_led {
  73. int id;
  74. struct mt6323_leds *parent;
  75. struct led_classdev cdev;
  76. enum led_brightness current_brightness;
  77. };
  78. /**
  79. * struct mt6323_leds - state container for holding LED controller
  80. * of the driver
  81. * @dev: the device pointer
  82. * @hw: the underlying hardware providing shared
  83. * bus for the register operations
  84. * @lock: the lock among process context
  85. * @led: the array that contains the state of individual
  86. * LED device
  87. */
  88. struct mt6323_leds {
  89. struct device *dev;
  90. struct mt6397_chip *hw;
  91. /* protect among process context */
  92. struct mutex lock;
  93. struct mt6323_led *led[MT6323_MAX_LEDS];
  94. };
  95. static int mt6323_led_hw_brightness(struct led_classdev *cdev,
  96. enum led_brightness brightness)
  97. {
  98. struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
  99. struct mt6323_leds *leds = led->parent;
  100. struct regmap *regmap = leds->hw->regmap;
  101. u32 con2_mask = 0, con2_val = 0;
  102. int ret;
  103. /*
  104. * Setup current output for the corresponding
  105. * brightness level.
  106. */
  107. con2_mask |= MT6323_ISINK_CH_STEP_MASK |
  108. MT6323_ISINK_SFSTR0_TC_MASK |
  109. MT6323_ISINK_SFSTR0_EN_MASK;
  110. con2_val |= MT6323_ISINK_CH_STEP(brightness - 1) |
  111. MT6323_ISINK_SFSTR0_TC(2) |
  112. MT6323_ISINK_SFSTR0_EN;
  113. ret = regmap_update_bits(regmap, MT6323_ISINK_CON2(led->id),
  114. con2_mask, con2_val);
  115. return ret;
  116. }
  117. static int mt6323_led_hw_off(struct led_classdev *cdev)
  118. {
  119. struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
  120. struct mt6323_leds *leds = led->parent;
  121. struct regmap *regmap = leds->hw->regmap;
  122. unsigned int status;
  123. int ret;
  124. status = MT6323_ISINK_CH_EN(led->id);
  125. ret = regmap_update_bits(regmap, MT6323_ISINK_EN_CTRL,
  126. MT6323_ISINK_CH_EN_MASK(led->id), ~status);
  127. if (ret < 0)
  128. return ret;
  129. usleep_range(100, 300);
  130. ret = regmap_update_bits(regmap, MT6323_TOP_CKPDN2,
  131. MT6323_RG_ISINK_CK_PDN_MASK(led->id),
  132. MT6323_RG_ISINK_CK_PDN(led->id));
  133. if (ret < 0)
  134. return ret;
  135. return 0;
  136. }
  137. static enum led_brightness
  138. mt6323_get_led_hw_brightness(struct led_classdev *cdev)
  139. {
  140. struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
  141. struct mt6323_leds *leds = led->parent;
  142. struct regmap *regmap = leds->hw->regmap;
  143. unsigned int status;
  144. int ret;
  145. ret = regmap_read(regmap, MT6323_TOP_CKPDN2, &status);
  146. if (ret < 0)
  147. return ret;
  148. if (status & MT6323_RG_ISINK_CK_PDN_MASK(led->id))
  149. return 0;
  150. ret = regmap_read(regmap, MT6323_ISINK_EN_CTRL, &status);
  151. if (ret < 0)
  152. return ret;
  153. if (!(status & MT6323_ISINK_CH_EN(led->id)))
  154. return 0;
  155. ret = regmap_read(regmap, MT6323_ISINK_CON2(led->id), &status);
  156. if (ret < 0)
  157. return ret;
  158. return ((status & MT6323_ISINK_CH_STEP_MASK)
  159. >> MT6323_ISINK_CH_STEP_SHIFT) + 1;
  160. }
  161. static int mt6323_led_hw_on(struct led_classdev *cdev,
  162. enum led_brightness brightness)
  163. {
  164. struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
  165. struct mt6323_leds *leds = led->parent;
  166. struct regmap *regmap = leds->hw->regmap;
  167. unsigned int status;
  168. int ret;
  169. /*
  170. * Setup required clock source, enable the corresponding
  171. * clock and channel and let work with continuous blink as
  172. * the default.
  173. */
  174. ret = regmap_update_bits(regmap, MT6323_TOP_CKCON1,
  175. MT6323_RG_ISINK_CK_SEL_MASK(led->id), 0);
  176. if (ret < 0)
  177. return ret;
  178. status = MT6323_RG_ISINK_CK_PDN(led->id);
  179. ret = regmap_update_bits(regmap, MT6323_TOP_CKPDN2,
  180. MT6323_RG_ISINK_CK_PDN_MASK(led->id),
  181. ~status);
  182. if (ret < 0)
  183. return ret;
  184. usleep_range(100, 300);
  185. ret = regmap_update_bits(regmap, MT6323_ISINK_EN_CTRL,
  186. MT6323_ISINK_CH_EN_MASK(led->id),
  187. MT6323_ISINK_CH_EN(led->id));
  188. if (ret < 0)
  189. return ret;
  190. ret = mt6323_led_hw_brightness(cdev, brightness);
  191. if (ret < 0)
  192. return ret;
  193. ret = regmap_update_bits(regmap, MT6323_ISINK_CON0(led->id),
  194. MT6323_ISINK_DIM_DUTY_MASK,
  195. MT6323_ISINK_DIM_DUTY(31));
  196. if (ret < 0)
  197. return ret;
  198. ret = regmap_update_bits(regmap, MT6323_ISINK_CON1(led->id),
  199. MT6323_ISINK_DIM_FSEL_MASK,
  200. MT6323_ISINK_DIM_FSEL(1000));
  201. if (ret < 0)
  202. return ret;
  203. return 0;
  204. }
  205. static int mt6323_led_set_blink(struct led_classdev *cdev,
  206. unsigned long *delay_on,
  207. unsigned long *delay_off)
  208. {
  209. struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
  210. struct mt6323_leds *leds = led->parent;
  211. struct regmap *regmap = leds->hw->regmap;
  212. unsigned long period;
  213. u8 duty_hw;
  214. int ret;
  215. /*
  216. * LED subsystem requires a default user
  217. * friendly blink pattern for the LED so using
  218. * 1Hz duty cycle 50% here if without specific
  219. * value delay_on and delay off being assigned.
  220. */
  221. if (!*delay_on && !*delay_off) {
  222. *delay_on = 500;
  223. *delay_off = 500;
  224. }
  225. /*
  226. * Units are in ms, if over the hardware able
  227. * to support, fallback into software blink
  228. */
  229. period = *delay_on + *delay_off;
  230. if (period > MT6323_MAX_PERIOD)
  231. return -EINVAL;
  232. /*
  233. * Calculate duty_hw based on the percentage of period during
  234. * which the led is ON.
  235. */
  236. duty_hw = MT6323_CAL_HW_DUTY(*delay_on, period);
  237. /* hardware doesn't support zero duty cycle. */
  238. if (!duty_hw)
  239. return -EINVAL;
  240. mutex_lock(&leds->lock);
  241. /*
  242. * Set max_brightness as the software blink behavior
  243. * when no blink brightness.
  244. */
  245. if (!led->current_brightness) {
  246. ret = mt6323_led_hw_on(cdev, cdev->max_brightness);
  247. if (ret < 0)
  248. goto out;
  249. led->current_brightness = cdev->max_brightness;
  250. }
  251. ret = regmap_update_bits(regmap, MT6323_ISINK_CON0(led->id),
  252. MT6323_ISINK_DIM_DUTY_MASK,
  253. MT6323_ISINK_DIM_DUTY(duty_hw - 1));
  254. if (ret < 0)
  255. goto out;
  256. ret = regmap_update_bits(regmap, MT6323_ISINK_CON1(led->id),
  257. MT6323_ISINK_DIM_FSEL_MASK,
  258. MT6323_ISINK_DIM_FSEL(period - 1));
  259. out:
  260. mutex_unlock(&leds->lock);
  261. return ret;
  262. }
  263. static int mt6323_led_set_brightness(struct led_classdev *cdev,
  264. enum led_brightness brightness)
  265. {
  266. struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
  267. struct mt6323_leds *leds = led->parent;
  268. int ret;
  269. mutex_lock(&leds->lock);
  270. if (!led->current_brightness && brightness) {
  271. ret = mt6323_led_hw_on(cdev, brightness);
  272. if (ret < 0)
  273. goto out;
  274. } else if (brightness) {
  275. ret = mt6323_led_hw_brightness(cdev, brightness);
  276. if (ret < 0)
  277. goto out;
  278. } else {
  279. ret = mt6323_led_hw_off(cdev);
  280. if (ret < 0)
  281. goto out;
  282. }
  283. led->current_brightness = brightness;
  284. out:
  285. mutex_unlock(&leds->lock);
  286. return ret;
  287. }
  288. static int mt6323_led_set_dt_default(struct led_classdev *cdev,
  289. struct device_node *np)
  290. {
  291. struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
  292. const char *state;
  293. int ret = 0;
  294. state = of_get_property(np, "default-state", NULL);
  295. if (state) {
  296. if (!strcmp(state, "keep")) {
  297. ret = mt6323_get_led_hw_brightness(cdev);
  298. if (ret < 0)
  299. return ret;
  300. led->current_brightness = ret;
  301. ret = 0;
  302. } else if (!strcmp(state, "on")) {
  303. ret =
  304. mt6323_led_set_brightness(cdev, cdev->max_brightness);
  305. } else {
  306. ret = mt6323_led_set_brightness(cdev, LED_OFF);
  307. }
  308. }
  309. return ret;
  310. }
  311. static int mt6323_led_probe(struct platform_device *pdev)
  312. {
  313. struct device *dev = &pdev->dev;
  314. struct device_node *np = dev_of_node(dev);
  315. struct device_node *child;
  316. struct mt6397_chip *hw = dev_get_drvdata(dev->parent);
  317. struct mt6323_leds *leds;
  318. struct mt6323_led *led;
  319. int ret;
  320. unsigned int status;
  321. u32 reg;
  322. leds = devm_kzalloc(dev, sizeof(*leds), GFP_KERNEL);
  323. if (!leds)
  324. return -ENOMEM;
  325. platform_set_drvdata(pdev, leds);
  326. leds->dev = dev;
  327. /*
  328. * leds->hw points to the underlying bus for the register
  329. * controlled.
  330. */
  331. leds->hw = hw;
  332. mutex_init(&leds->lock);
  333. status = MT6323_RG_DRV_32K_CK_PDN;
  334. ret = regmap_update_bits(leds->hw->regmap, MT6323_TOP_CKPDN0,
  335. MT6323_RG_DRV_32K_CK_PDN_MASK, ~status);
  336. if (ret < 0) {
  337. dev_err(leds->dev,
  338. "Failed to update MT6323_TOP_CKPDN0 Register\n");
  339. return ret;
  340. }
  341. for_each_available_child_of_node(np, child) {
  342. struct led_init_data init_data = {};
  343. ret = of_property_read_u32(child, "reg", &reg);
  344. if (ret) {
  345. dev_err(dev, "Failed to read led 'reg' property\n");
  346. goto put_child_node;
  347. }
  348. if (reg >= MT6323_MAX_LEDS || leds->led[reg]) {
  349. dev_err(dev, "Invalid led reg %u\n", reg);
  350. ret = -EINVAL;
  351. goto put_child_node;
  352. }
  353. led = devm_kzalloc(dev, sizeof(*led), GFP_KERNEL);
  354. if (!led) {
  355. ret = -ENOMEM;
  356. goto put_child_node;
  357. }
  358. leds->led[reg] = led;
  359. leds->led[reg]->id = reg;
  360. leds->led[reg]->cdev.max_brightness = MT6323_MAX_BRIGHTNESS;
  361. leds->led[reg]->cdev.brightness_set_blocking =
  362. mt6323_led_set_brightness;
  363. leds->led[reg]->cdev.blink_set = mt6323_led_set_blink;
  364. leds->led[reg]->cdev.brightness_get =
  365. mt6323_get_led_hw_brightness;
  366. leds->led[reg]->parent = leds;
  367. ret = mt6323_led_set_dt_default(&leds->led[reg]->cdev, child);
  368. if (ret < 0) {
  369. dev_err(leds->dev,
  370. "Failed to LED set default from devicetree\n");
  371. goto put_child_node;
  372. }
  373. init_data.fwnode = of_fwnode_handle(child);
  374. ret = devm_led_classdev_register_ext(dev, &leds->led[reg]->cdev,
  375. &init_data);
  376. if (ret) {
  377. dev_err(dev, "Failed to register LED: %d\n", ret);
  378. goto put_child_node;
  379. }
  380. }
  381. return 0;
  382. put_child_node:
  383. of_node_put(child);
  384. return ret;
  385. }
  386. static int mt6323_led_remove(struct platform_device *pdev)
  387. {
  388. struct mt6323_leds *leds = platform_get_drvdata(pdev);
  389. int i;
  390. /* Turn the LEDs off on driver removal. */
  391. for (i = 0 ; leds->led[i] ; i++)
  392. mt6323_led_hw_off(&leds->led[i]->cdev);
  393. regmap_update_bits(leds->hw->regmap, MT6323_TOP_CKPDN0,
  394. MT6323_RG_DRV_32K_CK_PDN_MASK,
  395. MT6323_RG_DRV_32K_CK_PDN);
  396. mutex_destroy(&leds->lock);
  397. return 0;
  398. }
  399. static const struct of_device_id mt6323_led_dt_match[] = {
  400. { .compatible = "mediatek,mt6323-led" },
  401. {},
  402. };
  403. MODULE_DEVICE_TABLE(of, mt6323_led_dt_match);
  404. static struct platform_driver mt6323_led_driver = {
  405. .probe = mt6323_led_probe,
  406. .remove = mt6323_led_remove,
  407. .driver = {
  408. .name = "mt6323-led",
  409. .of_match_table = mt6323_led_dt_match,
  410. },
  411. };
  412. module_platform_driver(mt6323_led_driver);
  413. MODULE_DESCRIPTION("LED driver for Mediatek MT6323 PMIC");
  414. MODULE_AUTHOR("Sean Wang <sean.wang@mediatek.com>");
  415. MODULE_LICENSE("GPL");