xref: /openbmc/linux/drivers/leds/leds-regulator.c (revision 25985edc)
1 /*
2  * leds-regulator.c - LED class driver for regulator driven LEDs.
3  *
4  * Copyright (C) 2009 Antonio Ospite <ospite@studenti.unina.it>
5  *
6  * Inspired by leds-wm8350 driver.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  *
12  */
13 
14 #include <linux/module.h>
15 #include <linux/err.h>
16 #include <linux/slab.h>
17 #include <linux/workqueue.h>
18 #include <linux/leds.h>
19 #include <linux/leds-regulator.h>
20 #include <linux/platform_device.h>
21 #include <linux/regulator/consumer.h>
22 
23 #define to_regulator_led(led_cdev) \
24 	container_of(led_cdev, struct regulator_led, cdev)
25 
26 struct regulator_led {
27 	struct led_classdev cdev;
28 	enum led_brightness value;
29 	int enabled;
30 	struct mutex mutex;
31 	struct work_struct work;
32 
33 	struct regulator *vcc;
34 };
35 
36 static inline int led_regulator_get_max_brightness(struct regulator *supply)
37 {
38 	int ret;
39 	int voltage = regulator_list_voltage(supply, 0);
40 
41 	if (voltage <= 0)
42 		return 1;
43 
44 	/* even if regulator can't change voltages,
45 	 * we still assume it can change status
46 	 * and the LED can be turned on and off.
47 	 */
48 	ret = regulator_set_voltage(supply, voltage, voltage);
49 	if (ret < 0)
50 		return 1;
51 
52 	return regulator_count_voltages(supply);
53 }
54 
55 static int led_regulator_get_voltage(struct regulator *supply,
56 		enum led_brightness brightness)
57 {
58 	if (brightness == 0)
59 		return -EINVAL;
60 
61 	return regulator_list_voltage(supply, brightness - 1);
62 }
63 
64 
65 static void regulator_led_enable(struct regulator_led *led)
66 {
67 	int ret;
68 
69 	if (led->enabled)
70 		return;
71 
72 	ret = regulator_enable(led->vcc);
73 	if (ret != 0) {
74 		dev_err(led->cdev.dev, "Failed to enable vcc: %d\n", ret);
75 		return;
76 	}
77 
78 	led->enabled = 1;
79 }
80 
81 static void regulator_led_disable(struct regulator_led *led)
82 {
83 	int ret;
84 
85 	if (!led->enabled)
86 		return;
87 
88 	ret = regulator_disable(led->vcc);
89 	if (ret != 0) {
90 		dev_err(led->cdev.dev, "Failed to disable vcc: %d\n", ret);
91 		return;
92 	}
93 
94 	led->enabled = 0;
95 }
96 
97 static void regulator_led_set_value(struct regulator_led *led)
98 {
99 	int voltage;
100 	int ret;
101 
102 	mutex_lock(&led->mutex);
103 
104 	if (led->value == LED_OFF) {
105 		regulator_led_disable(led);
106 		goto out;
107 	}
108 
109 	if (led->cdev.max_brightness > 1) {
110 		voltage = led_regulator_get_voltage(led->vcc, led->value);
111 		dev_dbg(led->cdev.dev, "brightness: %d voltage: %d\n",
112 				led->value, voltage);
113 
114 		ret = regulator_set_voltage(led->vcc, voltage, voltage);
115 		if (ret != 0)
116 			dev_err(led->cdev.dev, "Failed to set voltage %d: %d\n",
117 				voltage, ret);
118 	}
119 
120 	regulator_led_enable(led);
121 
122 out:
123 	mutex_unlock(&led->mutex);
124 }
125 
126 static void led_work(struct work_struct *work)
127 {
128 	struct regulator_led *led;
129 
130 	led = container_of(work, struct regulator_led, work);
131 	regulator_led_set_value(led);
132 }
133 
134 static void regulator_led_brightness_set(struct led_classdev *led_cdev,
135 			   enum led_brightness value)
136 {
137 	struct regulator_led *led = to_regulator_led(led_cdev);
138 
139 	led->value = value;
140 	schedule_work(&led->work);
141 }
142 
143 static int __devinit regulator_led_probe(struct platform_device *pdev)
144 {
145 	struct led_regulator_platform_data *pdata = pdev->dev.platform_data;
146 	struct regulator_led *led;
147 	struct regulator *vcc;
148 	int ret = 0;
149 
150 	if (pdata == NULL) {
151 		dev_err(&pdev->dev, "no platform data\n");
152 		return -ENODEV;
153 	}
154 
155 	vcc = regulator_get_exclusive(&pdev->dev, "vled");
156 	if (IS_ERR(vcc)) {
157 		dev_err(&pdev->dev, "Cannot get vcc for %s\n", pdata->name);
158 		return PTR_ERR(vcc);
159 	}
160 
161 	led = kzalloc(sizeof(*led), GFP_KERNEL);
162 	if (led == NULL) {
163 		ret = -ENOMEM;
164 		goto err_vcc;
165 	}
166 
167 	led->cdev.max_brightness = led_regulator_get_max_brightness(vcc);
168 	if (pdata->brightness > led->cdev.max_brightness) {
169 		dev_err(&pdev->dev, "Invalid default brightness %d\n",
170 				pdata->brightness);
171 		ret = -EINVAL;
172 		goto err_led;
173 	}
174 	led->value = pdata->brightness;
175 
176 	led->cdev.brightness_set = regulator_led_brightness_set;
177 	led->cdev.name = pdata->name;
178 	led->cdev.flags |= LED_CORE_SUSPENDRESUME;
179 	led->vcc = vcc;
180 
181 	mutex_init(&led->mutex);
182 	INIT_WORK(&led->work, led_work);
183 
184 	platform_set_drvdata(pdev, led);
185 
186 	ret = led_classdev_register(&pdev->dev, &led->cdev);
187 	if (ret < 0) {
188 		cancel_work_sync(&led->work);
189 		goto err_led;
190 	}
191 
192 	/* to expose the default value to userspace */
193 	led->cdev.brightness = led->value;
194 
195 	/* Set the default led status */
196 	regulator_led_set_value(led);
197 
198 	return 0;
199 
200 err_led:
201 	kfree(led);
202 err_vcc:
203 	regulator_put(vcc);
204 	return ret;
205 }
206 
207 static int __devexit regulator_led_remove(struct platform_device *pdev)
208 {
209 	struct regulator_led *led = platform_get_drvdata(pdev);
210 
211 	led_classdev_unregister(&led->cdev);
212 	cancel_work_sync(&led->work);
213 	regulator_led_disable(led);
214 	regulator_put(led->vcc);
215 	kfree(led);
216 	return 0;
217 }
218 
219 static struct platform_driver regulator_led_driver = {
220 	.driver = {
221 		   .name  = "leds-regulator",
222 		   .owner = THIS_MODULE,
223 		   },
224 	.probe  = regulator_led_probe,
225 	.remove = __devexit_p(regulator_led_remove),
226 };
227 
228 static int __init regulator_led_init(void)
229 {
230 	return platform_driver_register(&regulator_led_driver);
231 }
232 module_init(regulator_led_init);
233 
234 static void __exit regulator_led_exit(void)
235 {
236 	platform_driver_unregister(&regulator_led_driver);
237 }
238 module_exit(regulator_led_exit);
239 
240 MODULE_AUTHOR("Antonio Ospite <ospite@studenti.unina.it>");
241 MODULE_DESCRIPTION("Regulator driven LED driver");
242 MODULE_LICENSE("GPL");
243 MODULE_ALIAS("platform:leds-regulator");
244