include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[linux-2.6.git] / drivers / leds / leds-88pm860x.c
1 /*
2  * LED driver for Marvell 88PM860x
3  *
4  * Copyright (C) 2009 Marvell International Ltd.
5  *      Haojian Zhuang <haojian.zhuang@marvell.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  *
11  */
12
13 #include <linux/kernel.h>
14 #include <linux/init.h>
15 #include <linux/platform_device.h>
16 #include <linux/i2c.h>
17 #include <linux/leds.h>
18 #include <linux/slab.h>
19 #include <linux/workqueue.h>
20 #include <linux/mfd/88pm860x.h>
21
22 #define LED_PWM_SHIFT           (3)
23 #define LED_PWM_MASK            (0x1F)
24 #define LED_CURRENT_MASK        (0x07 << 5)
25
26 #define LED_BLINK_ON_MASK       (0x07)
27 #define LED_BLINK_PERIOD_MASK   (0x0F << 3)
28 #define LED_BLINK_MASK          (0x7F)
29
30 #define LED_BLINK_ON(x)         ((x & 0x7) * 66 + 66)
31 #define LED_BLINK_PERIOD(x)     ((x & 0xF) * 530 + 930)
32 #define LED_BLINK_ON_MIN        LED_BLINK_ON(0)
33 #define LED_BLINK_ON_MAX        LED_BLINK_ON(0x7)
34 #define LED_BLINK_PERIOD_MIN    LED_BLINK_PERIOD(0)
35 #define LED_BLINK_PERIOD_MAX    LED_BLINK_PERIOD(0xE)
36 #define LED_TO_ON(x)            ((x - 66) / 66)
37 #define LED_TO_PERIOD(x)        ((x - 930) / 530)
38
39 #define LED1_BLINK_EN           (1 << 1)
40 #define LED2_BLINK_EN           (1 << 2)
41
42 enum {
43         SET_BRIGHTNESS,
44         SET_BLINK,
45 };
46
47 struct pm860x_led {
48         struct led_classdev cdev;
49         struct i2c_client *i2c;
50         struct work_struct work;
51         struct pm860x_chip *chip;
52         struct mutex lock;
53         char name[MFD_NAME_SIZE];
54
55         int port;
56         int iset;
57         int command;
58         int offset;
59         unsigned char brightness;
60         unsigned char current_brightness;
61
62         int blink_data;
63         int blink_time;
64         int blink_on;
65         int blink_off;
66 };
67
68 /* return offset of color register */
69 static inline int __led_off(int port)
70 {
71         int ret = -EINVAL;
72
73         switch (port) {
74         case PM8606_LED1_RED:
75         case PM8606_LED1_GREEN:
76         case PM8606_LED1_BLUE:
77                 ret = port - PM8606_LED1_RED + PM8606_RGB1B;
78                 break;
79         case PM8606_LED2_RED:
80         case PM8606_LED2_GREEN:
81         case PM8606_LED2_BLUE:
82                 ret = port - PM8606_LED2_RED + PM8606_RGB2B;
83                 break;
84         }
85         return ret;
86 }
87
88 /* return offset of blink register */
89 static inline int __blink_off(int port)
90 {
91         int ret = -EINVAL;
92
93         switch (port) {
94         case PM8606_LED1_RED:
95         case PM8606_LED1_GREEN:
96         case PM8606_LED1_BLUE:
97                 ret = PM8606_RGB1A;
98         case PM8606_LED2_RED:
99         case PM8606_LED2_GREEN:
100         case PM8606_LED2_BLUE:
101                 ret = PM8606_RGB2A;
102         }
103         return ret;
104 }
105
106 static inline int __blink_ctl_mask(int port)
107 {
108         int ret = -EINVAL;
109
110         switch (port) {
111         case PM8606_LED1_RED:
112         case PM8606_LED1_GREEN:
113         case PM8606_LED1_BLUE:
114                 ret = LED1_BLINK_EN;
115                 break;
116         case PM8606_LED2_RED:
117         case PM8606_LED2_GREEN:
118         case PM8606_LED2_BLUE:
119                 ret = LED2_BLINK_EN;
120                 break;
121         }
122         return ret;
123 }
124
125 static int __led_set(struct pm860x_led *led, int command)
126 {
127         struct pm860x_chip *chip = led->chip;
128         int mask, ret;
129
130         mutex_lock(&led->lock);
131         switch (command) {
132         case SET_BRIGHTNESS:
133                 if ((led->current_brightness == 0) && led->brightness) {
134                         if (led->iset) {
135                                 ret = pm860x_set_bits(led->i2c, led->offset,
136                                                 LED_CURRENT_MASK, led->iset);
137                                 if (ret < 0)
138                                         goto out;
139                         }
140                 } else if (led->brightness == 0) {
141                         ret = pm860x_set_bits(led->i2c, led->offset,
142                                                 LED_CURRENT_MASK, 0);
143                         if (ret < 0)
144                                 goto out;
145                 }
146                 ret = pm860x_set_bits(led->i2c, led->offset, LED_PWM_MASK,
147                                         led->brightness);
148                 if (ret < 0)
149                         goto out;
150                 led->current_brightness = led->brightness;
151                 dev_dbg(chip->dev, "Update LED. (reg:%d, brightness:%d)\n",
152                         led->offset, led->brightness);
153                 break;
154         case SET_BLINK:
155                 ret = pm860x_set_bits(led->i2c, led->offset,
156                                 LED_BLINK_MASK, led->blink_data);
157                 if (ret < 0)
158                         goto out;
159
160                 mask = __blink_ctl_mask(led->port);
161                 ret = pm860x_set_bits(led->i2c, PM8606_WLED3B, mask, mask);
162                 if (ret < 0)
163                         goto out;
164                 dev_dbg(chip->dev, "LED blink delay on:%dms, delay off:%dms\n",
165                         led->blink_on, led->blink_off);
166                 break;
167         }
168 out:
169         mutex_unlock(&led->lock);
170         return 0;
171 }
172
173 static void pm860x_led_work(struct work_struct *work)
174 {
175         struct pm860x_led *led;
176
177         led = container_of(work, struct pm860x_led, work);
178         __led_set(led, led->command);
179 }
180
181 static void pm860x_led_set(struct led_classdev *cdev,
182                            enum led_brightness value)
183 {
184         struct pm860x_led *data = container_of(cdev, struct pm860x_led, cdev);
185
186         data->offset = __led_off(data->port);
187         data->brightness = value >> 3;
188         data->command = SET_BRIGHTNESS;
189         schedule_work(&data->work);
190 }
191
192 static int pm860x_led_blink(struct led_classdev *cdev,
193                             unsigned long *delay_on,
194                             unsigned long *delay_off)
195 {
196         struct pm860x_led *data = container_of(cdev, struct pm860x_led, cdev);
197         int period, on;
198
199         on = *delay_on;
200         if ((on < LED_BLINK_ON_MIN) || (on > LED_BLINK_ON_MAX))
201                 return -EINVAL;
202
203         on = LED_TO_ON(on);
204         on = LED_BLINK_ON(on);
205
206         period = on + *delay_off;
207         if ((period < LED_BLINK_PERIOD_MIN) || (period > LED_BLINK_PERIOD_MAX))
208                 return -EINVAL;
209         period = LED_TO_PERIOD(period);
210         period = LED_BLINK_PERIOD(period);
211
212         data->offset = __blink_off(data->port);
213         data->blink_on = on;
214         data->blink_off = period - data->blink_on;
215         data->blink_data = (period << 3) | data->blink_on;
216         data->command = SET_BLINK;
217         schedule_work(&data->work);
218
219         return 0;
220 }
221
222 static int __check_device(struct pm860x_led_pdata *pdata, char *name)
223 {
224         struct pm860x_led_pdata *p = pdata;
225         int ret = -EINVAL;
226
227         while (p && p->id) {
228                 if ((p->id != PM8606_ID_LED) || (p->flags < 0))
229                         break;
230
231                 if (!strncmp(name, pm860x_led_name[p->flags],
232                         MFD_NAME_SIZE)) {
233                         ret = (int)p->flags;
234                         break;
235                 }
236                 p++;
237         }
238         return ret;
239 }
240
241 static int pm860x_led_probe(struct platform_device *pdev)
242 {
243         struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent);
244         struct pm860x_platform_data *pm860x_pdata;
245         struct pm860x_led_pdata *pdata;
246         struct pm860x_led *data;
247         struct resource *res;
248         int ret;
249
250         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
251         if (res == NULL) {
252                 dev_err(&pdev->dev, "No I/O resource!\n");
253                 return -EINVAL;
254         }
255
256         if (pdev->dev.parent->platform_data) {
257                 pm860x_pdata = pdev->dev.parent->platform_data;
258                 pdata = pm860x_pdata->led;
259         } else
260                 pdata = NULL;
261
262         data = kzalloc(sizeof(struct pm860x_led), GFP_KERNEL);
263         if (data == NULL)
264                 return -ENOMEM;
265         strncpy(data->name, res->name, MFD_NAME_SIZE);
266         dev_set_drvdata(&pdev->dev, data);
267         data->chip = chip;
268         data->i2c = (chip->id == CHIP_PM8606) ? chip->client : chip->companion;
269         data->iset = pdata->iset;
270         data->port = __check_device(pdata, data->name);
271         if (data->port < 0)
272                 return -EINVAL;
273
274         data->current_brightness = 0;
275         data->cdev.name = data->name;
276         data->cdev.brightness_set = pm860x_led_set;
277         data->cdev.blink_set = pm860x_led_blink;
278         mutex_init(&data->lock);
279         INIT_WORK(&data->work, pm860x_led_work);
280
281         ret = led_classdev_register(chip->dev, &data->cdev);
282         if (ret < 0) {
283                 dev_err(&pdev->dev, "Failed to register LED: %d\n", ret);
284                 goto out;
285         }
286         return 0;
287 out:
288         kfree(data);
289         return ret;
290 }
291
292 static int pm860x_led_remove(struct platform_device *pdev)
293 {
294         struct pm860x_led *data = platform_get_drvdata(pdev);
295
296         led_classdev_unregister(&data->cdev);
297         kfree(data);
298
299         return 0;
300 }
301
302 static struct platform_driver pm860x_led_driver = {
303         .driver = {
304                 .name   = "88pm860x-led",
305                 .owner  = THIS_MODULE,
306         },
307         .probe  = pm860x_led_probe,
308         .remove = pm860x_led_remove,
309 };
310
311 static int __devinit pm860x_led_init(void)
312 {
313         return platform_driver_register(&pm860x_led_driver);
314 }
315 module_init(pm860x_led_init);
316
317 static void __devexit pm860x_led_exit(void)
318 {
319         platform_driver_unregister(&pm860x_led_driver);
320 }
321 module_exit(pm860x_led_exit);
322
323 MODULE_DESCRIPTION("LED driver for Marvell PM860x");
324 MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
325 MODULE_LICENSE("GPL");
326 MODULE_ALIAS("platform:88pm860x-led");