leds-wm831x-status.c 6.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * LED driver for WM831x status LEDs
  4. *
  5. * Copyright(C) 2009 Wolfson Microelectronics PLC.
  6. */
  7. #include <linux/kernel.h>
  8. #include <linux/platform_device.h>
  9. #include <linux/slab.h>
  10. #include <linux/leds.h>
  11. #include <linux/err.h>
  12. #include <linux/mfd/wm831x/core.h>
  13. #include <linux/mfd/wm831x/pdata.h>
  14. #include <linux/mfd/wm831x/status.h>
  15. #include <linux/module.h>
  16. struct wm831x_status {
  17. struct led_classdev cdev;
  18. struct wm831x *wm831x;
  19. struct mutex mutex;
  20. spinlock_t value_lock;
  21. int reg; /* Control register */
  22. int reg_val; /* Control register value */
  23. int blink;
  24. int blink_time;
  25. int blink_cyc;
  26. int src;
  27. enum led_brightness brightness;
  28. };
  29. #define to_wm831x_status(led_cdev) \
  30. container_of(led_cdev, struct wm831x_status, cdev)
  31. static void wm831x_status_set(struct wm831x_status *led)
  32. {
  33. unsigned long flags;
  34. mutex_lock(&led->mutex);
  35. led->reg_val &= ~(WM831X_LED_SRC_MASK | WM831X_LED_MODE_MASK |
  36. WM831X_LED_DUTY_CYC_MASK | WM831X_LED_DUR_MASK);
  37. spin_lock_irqsave(&led->value_lock, flags);
  38. led->reg_val |= led->src << WM831X_LED_SRC_SHIFT;
  39. if (led->blink) {
  40. led->reg_val |= 2 << WM831X_LED_MODE_SHIFT;
  41. led->reg_val |= led->blink_time << WM831X_LED_DUR_SHIFT;
  42. led->reg_val |= led->blink_cyc;
  43. } else {
  44. if (led->brightness != LED_OFF)
  45. led->reg_val |= 1 << WM831X_LED_MODE_SHIFT;
  46. }
  47. spin_unlock_irqrestore(&led->value_lock, flags);
  48. wm831x_reg_write(led->wm831x, led->reg, led->reg_val);
  49. mutex_unlock(&led->mutex);
  50. }
  51. static int wm831x_status_brightness_set(struct led_classdev *led_cdev,
  52. enum led_brightness value)
  53. {
  54. struct wm831x_status *led = to_wm831x_status(led_cdev);
  55. unsigned long flags;
  56. spin_lock_irqsave(&led->value_lock, flags);
  57. led->brightness = value;
  58. if (value == LED_OFF)
  59. led->blink = 0;
  60. spin_unlock_irqrestore(&led->value_lock, flags);
  61. wm831x_status_set(led);
  62. return 0;
  63. }
  64. static int wm831x_status_blink_set(struct led_classdev *led_cdev,
  65. unsigned long *delay_on,
  66. unsigned long *delay_off)
  67. {
  68. struct wm831x_status *led = to_wm831x_status(led_cdev);
  69. unsigned long flags;
  70. int ret = 0;
  71. /* Pick some defaults if we've not been given times */
  72. if (*delay_on == 0 && *delay_off == 0) {
  73. *delay_on = 250;
  74. *delay_off = 250;
  75. }
  76. spin_lock_irqsave(&led->value_lock, flags);
  77. /* We only have a limited selection of settings, see if we can
  78. * support the configuration we're being given */
  79. switch (*delay_on) {
  80. case 1000:
  81. led->blink_time = 0;
  82. break;
  83. case 250:
  84. led->blink_time = 1;
  85. break;
  86. case 125:
  87. led->blink_time = 2;
  88. break;
  89. case 62:
  90. case 63:
  91. /* Actually 62.5ms */
  92. led->blink_time = 3;
  93. break;
  94. default:
  95. ret = -EINVAL;
  96. break;
  97. }
  98. if (ret == 0) {
  99. switch (*delay_off / *delay_on) {
  100. case 1:
  101. led->blink_cyc = 0;
  102. break;
  103. case 3:
  104. led->blink_cyc = 1;
  105. break;
  106. case 4:
  107. led->blink_cyc = 2;
  108. break;
  109. case 8:
  110. led->blink_cyc = 3;
  111. break;
  112. default:
  113. ret = -EINVAL;
  114. break;
  115. }
  116. }
  117. if (ret == 0)
  118. led->blink = 1;
  119. else
  120. led->blink = 0;
  121. spin_unlock_irqrestore(&led->value_lock, flags);
  122. wm831x_status_set(led);
  123. return ret;
  124. }
  125. static const char * const led_src_texts[] = {
  126. "otp",
  127. "power",
  128. "charger",
  129. "soft",
  130. };
  131. static ssize_t wm831x_status_src_show(struct device *dev,
  132. struct device_attribute *attr, char *buf)
  133. {
  134. struct led_classdev *led_cdev = dev_get_drvdata(dev);
  135. struct wm831x_status *led = to_wm831x_status(led_cdev);
  136. int i;
  137. ssize_t ret = 0;
  138. mutex_lock(&led->mutex);
  139. for (i = 0; i < ARRAY_SIZE(led_src_texts); i++)
  140. if (i == led->src)
  141. ret += sprintf(&buf[ret], "[%s] ", led_src_texts[i]);
  142. else
  143. ret += sprintf(&buf[ret], "%s ", led_src_texts[i]);
  144. mutex_unlock(&led->mutex);
  145. ret += sprintf(&buf[ret], "\n");
  146. return ret;
  147. }
  148. static ssize_t wm831x_status_src_store(struct device *dev,
  149. struct device_attribute *attr,
  150. const char *buf, size_t size)
  151. {
  152. struct led_classdev *led_cdev = dev_get_drvdata(dev);
  153. struct wm831x_status *led = to_wm831x_status(led_cdev);
  154. int i;
  155. i = sysfs_match_string(led_src_texts, buf);
  156. if (i >= 0) {
  157. mutex_lock(&led->mutex);
  158. led->src = i;
  159. mutex_unlock(&led->mutex);
  160. wm831x_status_set(led);
  161. }
  162. return size;
  163. }
  164. static DEVICE_ATTR(src, 0644, wm831x_status_src_show, wm831x_status_src_store);
  165. static struct attribute *wm831x_status_attrs[] = {
  166. &dev_attr_src.attr,
  167. NULL
  168. };
  169. ATTRIBUTE_GROUPS(wm831x_status);
  170. static int wm831x_status_probe(struct platform_device *pdev)
  171. {
  172. struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
  173. struct wm831x_pdata *chip_pdata;
  174. struct wm831x_status_pdata pdata;
  175. struct wm831x_status *drvdata;
  176. struct resource *res;
  177. int id = pdev->id % ARRAY_SIZE(chip_pdata->status);
  178. int ret;
  179. res = platform_get_resource(pdev, IORESOURCE_REG, 0);
  180. if (res == NULL) {
  181. dev_err(&pdev->dev, "No register resource\n");
  182. return -EINVAL;
  183. }
  184. drvdata = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_status),
  185. GFP_KERNEL);
  186. if (!drvdata)
  187. return -ENOMEM;
  188. drvdata->wm831x = wm831x;
  189. drvdata->reg = res->start;
  190. if (dev_get_platdata(wm831x->dev))
  191. chip_pdata = dev_get_platdata(wm831x->dev);
  192. else
  193. chip_pdata = NULL;
  194. memset(&pdata, 0, sizeof(pdata));
  195. if (chip_pdata && chip_pdata->status[id])
  196. memcpy(&pdata, chip_pdata->status[id], sizeof(pdata));
  197. else
  198. pdata.name = dev_name(&pdev->dev);
  199. mutex_init(&drvdata->mutex);
  200. spin_lock_init(&drvdata->value_lock);
  201. /* We cache the configuration register and read startup values
  202. * from it. */
  203. drvdata->reg_val = wm831x_reg_read(wm831x, drvdata->reg);
  204. if (drvdata->reg_val & WM831X_LED_MODE_MASK)
  205. drvdata->brightness = LED_FULL;
  206. else
  207. drvdata->brightness = LED_OFF;
  208. /* Set a default source if configured, otherwise leave the
  209. * current hardware setting.
  210. */
  211. if (pdata.default_src == WM831X_STATUS_PRESERVE) {
  212. drvdata->src = drvdata->reg_val;
  213. drvdata->src &= WM831X_LED_SRC_MASK;
  214. drvdata->src >>= WM831X_LED_SRC_SHIFT;
  215. } else {
  216. drvdata->src = pdata.default_src - 1;
  217. }
  218. drvdata->cdev.name = pdata.name;
  219. drvdata->cdev.default_trigger = pdata.default_trigger;
  220. drvdata->cdev.brightness_set_blocking = wm831x_status_brightness_set;
  221. drvdata->cdev.blink_set = wm831x_status_blink_set;
  222. drvdata->cdev.groups = wm831x_status_groups;
  223. ret = led_classdev_register(wm831x->dev, &drvdata->cdev);
  224. if (ret < 0) {
  225. dev_err(&pdev->dev, "Failed to register LED: %d\n", ret);
  226. return ret;
  227. }
  228. platform_set_drvdata(pdev, drvdata);
  229. return 0;
  230. }
  231. static int wm831x_status_remove(struct platform_device *pdev)
  232. {
  233. struct wm831x_status *drvdata = platform_get_drvdata(pdev);
  234. led_classdev_unregister(&drvdata->cdev);
  235. return 0;
  236. }
  237. static struct platform_driver wm831x_status_driver = {
  238. .driver = {
  239. .name = "wm831x-status",
  240. },
  241. .probe = wm831x_status_probe,
  242. .remove = wm831x_status_remove,
  243. };
  244. module_platform_driver(wm831x_status_driver);
  245. MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
  246. MODULE_DESCRIPTION("WM831x status LED driver");
  247. MODULE_LICENSE("GPL");
  248. MODULE_ALIAS("platform:wm831x-status");