Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
leds-regulator.c
Go to the documentation of this file.
1 /*
2  * leds-regulator.c - LED class driver for regulator driven LEDs.
3  *
4  * Copyright (C) 2009 Antonio Ospite <[email protected]>
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>
22 
23 #define to_regulator_led(led_cdev) \
24  container_of(led_cdev, struct regulator_led, cdev)
25 
26 struct regulator_led {
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,
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 = devm_kzalloc(&pdev->dev, 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_vcc;
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  /* to handle correctly an already enabled regulator */
182  if (regulator_is_enabled(led->vcc))
183  led->enabled = 1;
184 
185  mutex_init(&led->mutex);
186  INIT_WORK(&led->work, led_work);
187 
188  platform_set_drvdata(pdev, led);
189 
190  ret = led_classdev_register(&pdev->dev, &led->cdev);
191  if (ret < 0) {
192  cancel_work_sync(&led->work);
193  goto err_vcc;
194  }
195 
196  /* to expose the default value to userspace */
197  led->cdev.brightness = led->value;
198 
199  /* Set the default led status */
200  regulator_led_set_value(led);
201 
202  return 0;
203 
204 err_vcc:
205  regulator_put(vcc);
206  return ret;
207 }
208 
209 static int __devexit regulator_led_remove(struct platform_device *pdev)
210 {
211  struct regulator_led *led = platform_get_drvdata(pdev);
212 
214  cancel_work_sync(&led->work);
215  regulator_led_disable(led);
216  regulator_put(led->vcc);
217  return 0;
218 }
219 
220 static struct platform_driver regulator_led_driver = {
221  .driver = {
222  .name = "leds-regulator",
223  .owner = THIS_MODULE,
224  },
225  .probe = regulator_led_probe,
226  .remove = __devexit_p(regulator_led_remove),
227 };
228 
229 module_platform_driver(regulator_led_driver);
230 
231 MODULE_AUTHOR("Antonio Ospite <[email protected]>");
232 MODULE_DESCRIPTION("Regulator driven LED driver");
233 MODULE_LICENSE("GPL");
234 MODULE_ALIAS("platform:leds-regulator");