Loading...
1/*
2 * LED driver for WM8350 driven LEDS.
3 *
4 * Copyright(C) 2007, 2008 Wolfson Microelectronics PLC.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 *
10 */
11
12#include <linux/kernel.h>
13#include <linux/init.h>
14#include <linux/platform_device.h>
15#include <linux/leds.h>
16#include <linux/err.h>
17#include <linux/mfd/wm8350/pmic.h>
18#include <linux/regulator/consumer.h>
19#include <linux/slab.h>
20#include <linux/module.h>
21
22/* Microamps */
23static const int isink_cur[] = {
24 4,
25 5,
26 6,
27 7,
28 8,
29 10,
30 11,
31 14,
32 16,
33 19,
34 23,
35 27,
36 32,
37 39,
38 46,
39 54,
40 65,
41 77,
42 92,
43 109,
44 130,
45 154,
46 183,
47 218,
48 259,
49 308,
50 367,
51 436,
52 518,
53 616,
54 733,
55 872,
56 1037,
57 1233,
58 1466,
59 1744,
60 2073,
61 2466,
62 2933,
63 3487,
64 4147,
65 4932,
66 5865,
67 6975,
68 8294,
69 9864,
70 11730,
71 13949,
72 16589,
73 19728,
74 23460,
75 27899,
76 33178,
77 39455,
78 46920,
79 55798,
80 66355,
81 78910,
82 93840,
83 111596,
84 132710,
85 157820,
86 187681,
87 223191
88};
89
90#define to_wm8350_led(led_cdev) \
91 container_of(led_cdev, struct wm8350_led, cdev)
92
93static void wm8350_led_enable(struct wm8350_led *led)
94{
95 int ret;
96
97 if (led->enabled)
98 return;
99
100 ret = regulator_enable(led->isink);
101 if (ret != 0) {
102 dev_err(led->cdev.dev, "Failed to enable ISINK: %d\n", ret);
103 return;
104 }
105
106 ret = regulator_enable(led->dcdc);
107 if (ret != 0) {
108 dev_err(led->cdev.dev, "Failed to enable DCDC: %d\n", ret);
109 regulator_disable(led->isink);
110 return;
111 }
112
113 led->enabled = 1;
114}
115
116static void wm8350_led_disable(struct wm8350_led *led)
117{
118 int ret;
119
120 if (!led->enabled)
121 return;
122
123 ret = regulator_disable(led->dcdc);
124 if (ret != 0) {
125 dev_err(led->cdev.dev, "Failed to disable DCDC: %d\n", ret);
126 return;
127 }
128
129 ret = regulator_disable(led->isink);
130 if (ret != 0) {
131 dev_err(led->cdev.dev, "Failed to disable ISINK: %d\n", ret);
132 regulator_enable(led->dcdc);
133 return;
134 }
135
136 led->enabled = 0;
137}
138
139static void led_work(struct work_struct *work)
140{
141 struct wm8350_led *led = container_of(work, struct wm8350_led, work);
142 int ret;
143 int uA;
144 unsigned long flags;
145
146 mutex_lock(&led->mutex);
147
148 spin_lock_irqsave(&led->value_lock, flags);
149
150 if (led->value == LED_OFF) {
151 spin_unlock_irqrestore(&led->value_lock, flags);
152 wm8350_led_disable(led);
153 goto out;
154 }
155
156 /* This scales linearly into the index of valid current
157 * settings which results in a linear scaling of perceived
158 * brightness due to the non-linear current settings provided
159 * by the hardware.
160 */
161 uA = (led->max_uA_index * led->value) / LED_FULL;
162 spin_unlock_irqrestore(&led->value_lock, flags);
163 BUG_ON(uA >= ARRAY_SIZE(isink_cur));
164
165 ret = regulator_set_current_limit(led->isink, isink_cur[uA],
166 isink_cur[uA]);
167 if (ret != 0)
168 dev_err(led->cdev.dev, "Failed to set %duA: %d\n",
169 isink_cur[uA], ret);
170
171 wm8350_led_enable(led);
172
173out:
174 mutex_unlock(&led->mutex);
175}
176
177static void wm8350_led_set(struct led_classdev *led_cdev,
178 enum led_brightness value)
179{
180 struct wm8350_led *led = to_wm8350_led(led_cdev);
181 unsigned long flags;
182
183 spin_lock_irqsave(&led->value_lock, flags);
184 led->value = value;
185 schedule_work(&led->work);
186 spin_unlock_irqrestore(&led->value_lock, flags);
187}
188
189static void wm8350_led_shutdown(struct platform_device *pdev)
190{
191 struct wm8350_led *led = platform_get_drvdata(pdev);
192
193 mutex_lock(&led->mutex);
194 led->value = LED_OFF;
195 wm8350_led_disable(led);
196 mutex_unlock(&led->mutex);
197}
198
199static int wm8350_led_probe(struct platform_device *pdev)
200{
201 struct regulator *isink, *dcdc;
202 struct wm8350_led *led;
203 struct wm8350_led_platform_data *pdata = pdev->dev.platform_data;
204 int ret, i;
205
206 if (pdata == NULL) {
207 dev_err(&pdev->dev, "no platform data\n");
208 return -ENODEV;
209 }
210
211 if (pdata->max_uA < isink_cur[0]) {
212 dev_err(&pdev->dev, "Invalid maximum current %duA\n",
213 pdata->max_uA);
214 return -EINVAL;
215 }
216
217 isink = regulator_get(&pdev->dev, "led_isink");
218 if (IS_ERR(isink)) {
219 printk(KERN_ERR "%s: can't get ISINK\n", __func__);
220 return PTR_ERR(isink);
221 }
222
223 dcdc = regulator_get(&pdev->dev, "led_vcc");
224 if (IS_ERR(dcdc)) {
225 printk(KERN_ERR "%s: can't get DCDC\n", __func__);
226 ret = PTR_ERR(dcdc);
227 goto err_isink;
228 }
229
230 led = devm_kzalloc(&pdev->dev, sizeof(*led), GFP_KERNEL);
231 if (led == NULL) {
232 ret = -ENOMEM;
233 goto err_dcdc;
234 }
235
236 led->cdev.brightness_set = wm8350_led_set;
237 led->cdev.default_trigger = pdata->default_trigger;
238 led->cdev.name = pdata->name;
239 led->cdev.flags |= LED_CORE_SUSPENDRESUME;
240 led->enabled = regulator_is_enabled(isink);
241 led->isink = isink;
242 led->dcdc = dcdc;
243
244 for (i = 0; i < ARRAY_SIZE(isink_cur) - 1; i++)
245 if (isink_cur[i] >= pdata->max_uA)
246 break;
247 led->max_uA_index = i;
248 if (pdata->max_uA != isink_cur[i])
249 dev_warn(&pdev->dev,
250 "Maximum current %duA is not directly supported,"
251 " check platform data\n",
252 pdata->max_uA);
253
254 spin_lock_init(&led->value_lock);
255 mutex_init(&led->mutex);
256 INIT_WORK(&led->work, led_work);
257 led->value = LED_OFF;
258 platform_set_drvdata(pdev, led);
259
260 ret = led_classdev_register(&pdev->dev, &led->cdev);
261 if (ret < 0)
262 goto err_dcdc;
263
264 return 0;
265
266 err_dcdc:
267 regulator_put(dcdc);
268 err_isink:
269 regulator_put(isink);
270 return ret;
271}
272
273static int wm8350_led_remove(struct platform_device *pdev)
274{
275 struct wm8350_led *led = platform_get_drvdata(pdev);
276
277 led_classdev_unregister(&led->cdev);
278 flush_work_sync(&led->work);
279 wm8350_led_disable(led);
280 regulator_put(led->dcdc);
281 regulator_put(led->isink);
282 return 0;
283}
284
285static struct platform_driver wm8350_led_driver = {
286 .driver = {
287 .name = "wm8350-led",
288 .owner = THIS_MODULE,
289 },
290 .probe = wm8350_led_probe,
291 .remove = wm8350_led_remove,
292 .shutdown = wm8350_led_shutdown,
293};
294
295module_platform_driver(wm8350_led_driver);
296
297MODULE_AUTHOR("Mark Brown");
298MODULE_DESCRIPTION("WM8350 LED driver");
299MODULE_LICENSE("GPL");
300MODULE_ALIAS("platform:wm8350-led");
1/*
2 * LED driver for WM8350 driven LEDS.
3 *
4 * Copyright(C) 2007, 2008 Wolfson Microelectronics PLC.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 *
10 */
11
12#include <linux/kernel.h>
13#include <linux/platform_device.h>
14#include <linux/leds.h>
15#include <linux/err.h>
16#include <linux/mfd/wm8350/pmic.h>
17#include <linux/regulator/consumer.h>
18#include <linux/slab.h>
19#include <linux/module.h>
20
21/* Microamps */
22static const int isink_cur[] = {
23 4,
24 5,
25 6,
26 7,
27 8,
28 10,
29 11,
30 14,
31 16,
32 19,
33 23,
34 27,
35 32,
36 39,
37 46,
38 54,
39 65,
40 77,
41 92,
42 109,
43 130,
44 154,
45 183,
46 218,
47 259,
48 308,
49 367,
50 436,
51 518,
52 616,
53 733,
54 872,
55 1037,
56 1233,
57 1466,
58 1744,
59 2073,
60 2466,
61 2933,
62 3487,
63 4147,
64 4932,
65 5865,
66 6975,
67 8294,
68 9864,
69 11730,
70 13949,
71 16589,
72 19728,
73 23460,
74 27899,
75 33178,
76 39455,
77 46920,
78 55798,
79 66355,
80 78910,
81 93840,
82 111596,
83 132710,
84 157820,
85 187681,
86 223191
87};
88
89#define to_wm8350_led(led_cdev) \
90 container_of(led_cdev, struct wm8350_led, cdev)
91
92static int wm8350_led_enable(struct wm8350_led *led)
93{
94 int ret = 0;
95
96 if (led->enabled)
97 return ret;
98
99 ret = regulator_enable(led->isink);
100 if (ret != 0) {
101 dev_err(led->cdev.dev, "Failed to enable ISINK: %d\n", ret);
102 return ret;
103 }
104
105 ret = regulator_enable(led->dcdc);
106 if (ret != 0) {
107 dev_err(led->cdev.dev, "Failed to enable DCDC: %d\n", ret);
108 regulator_disable(led->isink);
109 return ret;
110 }
111
112 led->enabled = 1;
113
114 return ret;
115}
116
117static int wm8350_led_disable(struct wm8350_led *led)
118{
119 int ret = 0;
120
121 if (!led->enabled)
122 return ret;
123
124 ret = regulator_disable(led->dcdc);
125 if (ret != 0) {
126 dev_err(led->cdev.dev, "Failed to disable DCDC: %d\n", ret);
127 return ret;
128 }
129
130 ret = regulator_disable(led->isink);
131 if (ret != 0) {
132 dev_err(led->cdev.dev, "Failed to disable ISINK: %d\n", ret);
133 ret = regulator_enable(led->dcdc);
134 if (ret != 0)
135 dev_err(led->cdev.dev, "Failed to reenable DCDC: %d\n",
136 ret);
137 return ret;
138 }
139
140 led->enabled = 0;
141
142 return ret;
143}
144
145static int wm8350_led_set(struct led_classdev *led_cdev,
146 enum led_brightness value)
147{
148 struct wm8350_led *led = to_wm8350_led(led_cdev);
149 unsigned long flags;
150 int ret;
151 int uA;
152
153 led->value = value;
154
155 spin_lock_irqsave(&led->value_lock, flags);
156
157 if (led->value == LED_OFF) {
158 spin_unlock_irqrestore(&led->value_lock, flags);
159 return wm8350_led_disable(led);
160 }
161
162 /* This scales linearly into the index of valid current
163 * settings which results in a linear scaling of perceived
164 * brightness due to the non-linear current settings provided
165 * by the hardware.
166 */
167 uA = (led->max_uA_index * led->value) / LED_FULL;
168 spin_unlock_irqrestore(&led->value_lock, flags);
169 BUG_ON(uA >= ARRAY_SIZE(isink_cur));
170
171 ret = regulator_set_current_limit(led->isink, isink_cur[uA],
172 isink_cur[uA]);
173 if (ret != 0) {
174 dev_err(led->cdev.dev, "Failed to set %duA: %d\n",
175 isink_cur[uA], ret);
176 return ret;
177 }
178
179 return wm8350_led_enable(led);
180}
181
182static void wm8350_led_shutdown(struct platform_device *pdev)
183{
184 struct wm8350_led *led = platform_get_drvdata(pdev);
185
186 led->value = LED_OFF;
187 wm8350_led_disable(led);
188}
189
190static int wm8350_led_probe(struct platform_device *pdev)
191{
192 struct regulator *isink, *dcdc;
193 struct wm8350_led *led;
194 struct wm8350_led_platform_data *pdata = dev_get_platdata(&pdev->dev);
195 int i;
196
197 if (pdata == NULL) {
198 dev_err(&pdev->dev, "no platform data\n");
199 return -ENODEV;
200 }
201
202 if (pdata->max_uA < isink_cur[0]) {
203 dev_err(&pdev->dev, "Invalid maximum current %duA\n",
204 pdata->max_uA);
205 return -EINVAL;
206 }
207
208 isink = devm_regulator_get(&pdev->dev, "led_isink");
209 if (IS_ERR(isink)) {
210 dev_err(&pdev->dev, "%s: can't get ISINK\n", __func__);
211 return PTR_ERR(isink);
212 }
213
214 dcdc = devm_regulator_get(&pdev->dev, "led_vcc");
215 if (IS_ERR(dcdc)) {
216 dev_err(&pdev->dev, "%s: can't get DCDC\n", __func__);
217 return PTR_ERR(dcdc);
218 }
219
220 led = devm_kzalloc(&pdev->dev, sizeof(*led), GFP_KERNEL);
221 if (led == NULL)
222 return -ENOMEM;
223
224 led->cdev.brightness_set_blocking = wm8350_led_set;
225 led->cdev.default_trigger = pdata->default_trigger;
226 led->cdev.name = pdata->name;
227 led->cdev.flags |= LED_CORE_SUSPENDRESUME;
228 led->enabled = regulator_is_enabled(isink);
229 led->isink = isink;
230 led->dcdc = dcdc;
231
232 for (i = 0; i < ARRAY_SIZE(isink_cur) - 1; i++)
233 if (isink_cur[i] >= pdata->max_uA)
234 break;
235 led->max_uA_index = i;
236 if (pdata->max_uA != isink_cur[i])
237 dev_warn(&pdev->dev,
238 "Maximum current %duA is not directly supported,"
239 " check platform data\n",
240 pdata->max_uA);
241
242 spin_lock_init(&led->value_lock);
243 led->value = LED_OFF;
244 platform_set_drvdata(pdev, led);
245
246 return led_classdev_register(&pdev->dev, &led->cdev);
247}
248
249static int wm8350_led_remove(struct platform_device *pdev)
250{
251 struct wm8350_led *led = platform_get_drvdata(pdev);
252
253 led_classdev_unregister(&led->cdev);
254 wm8350_led_disable(led);
255 return 0;
256}
257
258static struct platform_driver wm8350_led_driver = {
259 .driver = {
260 .name = "wm8350-led",
261 },
262 .probe = wm8350_led_probe,
263 .remove = wm8350_led_remove,
264 .shutdown = wm8350_led_shutdown,
265};
266
267module_platform_driver(wm8350_led_driver);
268
269MODULE_AUTHOR("Mark Brown");
270MODULE_DESCRIPTION("WM8350 LED driver");
271MODULE_LICENSE("GPL");
272MODULE_ALIAS("platform:wm8350-led");