leds: Add suuport for MAX8997-LED driver
[linux-3.10.git] / drivers / leds / leds-max8997.c
1 /*
2  * leds-max8997.c - LED class driver for MAX8997 LEDs.
3  *
4  * Copyright (C) 2011 Samsung Electronics
5  * Donggeun Kim <dg77.kim@samsung.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/module.h>
14 #include <linux/err.h>
15 #include <linux/slab.h>
16 #include <linux/workqueue.h>
17 #include <linux/leds.h>
18 #include <linux/mfd/max8997.h>
19 #include <linux/mfd/max8997-private.h>
20 #include <linux/platform_device.h>
21
22 #define MAX8997_LED_FLASH_SHIFT                 3
23 #define MAX8997_LED_FLASH_CUR_MASK              0xf8
24 #define MAX8997_LED_MOVIE_SHIFT                 4
25 #define MAX8997_LED_MOVIE_CUR_MASK              0xf0
26
27 #define MAX8997_LED_FLASH_MAX_BRIGHTNESS        0x1f
28 #define MAX8997_LED_MOVIE_MAX_BRIGHTNESS        0xf
29 #define MAX8997_LED_NONE_MAX_BRIGHTNESS         0
30
31 #define MAX8997_LED0_FLASH_MASK                 0x1
32 #define MAX8997_LED0_FLASH_PIN_MASK             0x5
33 #define MAX8997_LED0_MOVIE_MASK                 0x8
34 #define MAX8997_LED0_MOVIE_PIN_MASK             0x28
35
36 #define MAX8997_LED1_FLASH_MASK                 0x2
37 #define MAX8997_LED1_FLASH_PIN_MASK             0x6
38 #define MAX8997_LED1_MOVIE_MASK                 0x10
39 #define MAX8997_LED1_MOVIE_PIN_MASK             0x30
40
41 #define MAX8997_LED_BOOST_ENABLE_MASK           (1 << 6)
42
43 struct max8997_led {
44         struct max8997_dev *iodev;
45         struct led_classdev cdev;
46         bool enabled;
47         int id;
48         enum max8997_led_mode led_mode;
49         struct mutex mutex;
50 };
51
52 static void max8997_led_clear_mode(struct max8997_led *led,
53                         enum max8997_led_mode mode)
54 {
55         struct i2c_client *client = led->iodev->i2c;
56         u8 val = 0, mask = 0;
57         int ret;
58
59         switch (mode) {
60         case MAX8997_FLASH_MODE:
61                 mask = led->id ?
62                       MAX8997_LED1_FLASH_MASK : MAX8997_LED0_FLASH_MASK;
63                 break;
64         case MAX8997_MOVIE_MODE:
65                 mask = led->id ?
66                       MAX8997_LED1_MOVIE_MASK : MAX8997_LED0_MOVIE_MASK;
67                 break;
68         case MAX8997_FLASH_PIN_CONTROL_MODE:
69                 mask = led->id ?
70                       MAX8997_LED1_FLASH_PIN_MASK : MAX8997_LED0_FLASH_PIN_MASK;
71                 break;
72         case MAX8997_MOVIE_PIN_CONTROL_MODE:
73                 mask = led->id ?
74                       MAX8997_LED1_MOVIE_PIN_MASK : MAX8997_LED0_MOVIE_PIN_MASK;
75                 break;
76         default:
77                 break;
78         }
79
80         if (mask) {
81                 ret = max8997_update_reg(client,
82                                 MAX8997_REG_LEN_CNTL, val, mask);
83                 if (ret)
84                         dev_err(led->iodev->dev,
85                                 "failed to update register(%d)\n", ret);
86         }
87 }
88
89 static void max8997_led_set_mode(struct max8997_led *led,
90                         enum max8997_led_mode mode)
91 {
92         int ret;
93         struct i2c_client *client = led->iodev->i2c;
94         u8 mask = 0;
95
96         /* First, clear the previous mode */
97         max8997_led_clear_mode(led, led->led_mode);
98
99         switch (mode) {
100         case MAX8997_FLASH_MODE:
101                 mask = led->id ?
102                       MAX8997_LED1_FLASH_MASK : MAX8997_LED0_FLASH_MASK;
103                 led->cdev.max_brightness = MAX8997_LED_FLASH_MAX_BRIGHTNESS;
104                 break;
105         case MAX8997_MOVIE_MODE:
106                 mask = led->id ?
107                       MAX8997_LED1_MOVIE_MASK : MAX8997_LED0_MOVIE_MASK;
108                 led->cdev.max_brightness = MAX8997_LED_MOVIE_MAX_BRIGHTNESS;
109                 break;
110         case MAX8997_FLASH_PIN_CONTROL_MODE:
111                 mask = led->id ?
112                       MAX8997_LED1_FLASH_PIN_MASK : MAX8997_LED0_FLASH_PIN_MASK;
113                 led->cdev.max_brightness = MAX8997_LED_FLASH_MAX_BRIGHTNESS;
114                 break;
115         case MAX8997_MOVIE_PIN_CONTROL_MODE:
116                 mask = led->id ?
117                       MAX8997_LED1_MOVIE_PIN_MASK : MAX8997_LED0_MOVIE_PIN_MASK;
118                 led->cdev.max_brightness = MAX8997_LED_MOVIE_MAX_BRIGHTNESS;
119                 break;
120         default:
121                 led->cdev.max_brightness = MAX8997_LED_NONE_MAX_BRIGHTNESS;
122                 break;
123         }
124
125         if (mask) {
126                 ret = max8997_update_reg(client,
127                                 MAX8997_REG_LEN_CNTL, mask, mask);
128                 if (ret)
129                         dev_err(led->iodev->dev,
130                                 "failed to update register(%d)\n", ret);
131         }
132
133         led->led_mode = mode;
134 }
135
136 static void max8997_led_enable(struct max8997_led *led, bool enable)
137 {
138         int ret;
139         struct i2c_client *client = led->iodev->i2c;
140         u8 val = 0, mask = MAX8997_LED_BOOST_ENABLE_MASK;
141
142         if (led->enabled == enable)
143                 return;
144
145         val = enable ? MAX8997_LED_BOOST_ENABLE_MASK : 0;
146
147         ret = max8997_update_reg(client, MAX8997_REG_BOOST_CNTL, val, mask);
148         if (ret)
149                 dev_err(led->iodev->dev,
150                         "failed to update register(%d)\n", ret);
151
152         led->enabled = enable;
153 }
154
155 static void max8997_led_set_current(struct max8997_led *led,
156                                 enum led_brightness value)
157 {
158         int ret;
159         struct i2c_client *client = led->iodev->i2c;
160         u8 val = 0, mask = 0, reg = 0;
161
162         switch (led->led_mode) {
163         case MAX8997_FLASH_MODE:
164         case MAX8997_FLASH_PIN_CONTROL_MODE:
165                 val = value << MAX8997_LED_FLASH_SHIFT;
166                 mask = MAX8997_LED_FLASH_CUR_MASK;
167                 reg = led->id ? MAX8997_REG_FLASH2_CUR : MAX8997_REG_FLASH1_CUR;
168                 break;
169         case MAX8997_MOVIE_MODE:
170         case MAX8997_MOVIE_PIN_CONTROL_MODE:
171                 val = value << MAX8997_LED_MOVIE_SHIFT;
172                 mask = MAX8997_LED_MOVIE_CUR_MASK;
173                 reg = MAX8997_REG_MOVIE_CUR;
174                 break;
175         default:
176                 break;
177         }
178
179         if (mask) {
180                 ret = max8997_update_reg(client, reg, val, mask);
181                 if (ret)
182                         dev_err(led->iodev->dev,
183                                 "failed to update register(%d)\n", ret);
184         }
185 }
186
187 static void max8997_led_brightness_set(struct led_classdev *led_cdev,
188                                 enum led_brightness value)
189 {
190         struct max8997_led *led =
191                         container_of(led_cdev, struct max8997_led, cdev);
192
193         if (value) {
194                 max8997_led_set_current(led, value);
195                 max8997_led_enable(led, true);
196         } else {
197                 max8997_led_set_current(led, value);
198                 max8997_led_enable(led, false);
199         }
200 }
201
202 static ssize_t max8997_led_show_mode(struct device *dev,
203                                 struct device_attribute *attr, char *buf)
204 {
205         struct led_classdev *led_cdev = dev_get_drvdata(dev);
206         struct max8997_led *led =
207                         container_of(led_cdev, struct max8997_led, cdev);
208         ssize_t ret = 0;
209
210         mutex_lock(&led->mutex);
211
212         switch (led->led_mode) {
213         case MAX8997_FLASH_MODE:
214                 ret += sprintf(buf, "FLASH\n");
215                 break;
216         case MAX8997_MOVIE_MODE:
217                 ret += sprintf(buf, "MOVIE\n");
218                 break;
219         case MAX8997_FLASH_PIN_CONTROL_MODE:
220                 ret += sprintf(buf, "FLASH_PIN_CONTROL\n");
221                 break;
222         case MAX8997_MOVIE_PIN_CONTROL_MODE:
223                 ret += sprintf(buf, "MOVIE_PIN_CONTROL\n");
224                 break;
225         default:
226                 ret += sprintf(buf, "NONE\n");
227                 break;
228         }
229
230         mutex_unlock(&led->mutex);
231
232         return ret;
233 }
234
235 static ssize_t max8997_led_store_mode(struct device *dev,
236                                 struct device_attribute *attr,
237                                 const char *buf, size_t size)
238 {
239         struct led_classdev *led_cdev = dev_get_drvdata(dev);
240         struct max8997_led *led =
241                         container_of(led_cdev, struct max8997_led, cdev);
242         enum max8997_led_mode mode;
243
244         mutex_lock(&led->mutex);
245
246         if (!strncmp(buf, "FLASH_PIN_CONTROL", 17))
247                 mode = MAX8997_FLASH_PIN_CONTROL_MODE;
248         else if (!strncmp(buf, "MOVIE_PIN_CONTROL", 17))
249                 mode = MAX8997_MOVIE_PIN_CONTROL_MODE;
250         else if (!strncmp(buf, "FLASH", 5))
251                 mode = MAX8997_FLASH_MODE;
252         else if (!strncmp(buf, "MOVIE", 5))
253                 mode = MAX8997_MOVIE_MODE;
254         else
255                 mode = MAX8997_NONE;
256
257         max8997_led_set_mode(led, mode);
258
259         mutex_unlock(&led->mutex);
260
261         return size;
262 }
263
264 static DEVICE_ATTR(mode, 0644, max8997_led_show_mode, max8997_led_store_mode);
265
266 static int __devinit max8997_led_probe(struct platform_device *pdev)
267 {
268         struct max8997_dev *iodev = dev_get_drvdata(pdev->dev.parent);
269         struct max8997_platform_data *pdata = dev_get_platdata(iodev->dev);
270         struct max8997_led *led;
271         char name[20];
272         int ret = 0;
273
274         if (pdata == NULL) {
275                 dev_err(&pdev->dev, "no platform data\n");
276                 return -ENODEV;
277         }
278
279         led = kzalloc(sizeof(*led), GFP_KERNEL);
280         if (led == NULL) {
281                 ret = -ENOMEM;
282                 goto err_mem;
283         }
284
285         led->id = pdev->id;
286         snprintf(name, sizeof(name), "max8997-led%d", pdev->id);
287
288         led->cdev.name = name;
289         led->cdev.brightness_set = max8997_led_brightness_set;
290         led->cdev.flags |= LED_CORE_SUSPENDRESUME;
291         led->cdev.brightness = 0;
292         led->iodev = iodev;
293
294         /* initialize mode and brightness according to platform_data */
295         if (pdata->led_pdata) {
296                 u8 mode = 0, brightness = 0;
297
298                 mode = pdata->led_pdata->mode[led->id];
299                 brightness = pdata->led_pdata->brightness[led->id];
300
301                 max8997_led_set_mode(led, pdata->led_pdata->mode[led->id]);
302
303                 if (brightness > led->cdev.max_brightness)
304                         brightness = led->cdev.max_brightness;
305                 max8997_led_set_current(led, brightness);
306                 led->cdev.brightness = brightness;
307         } else {
308                 max8997_led_set_mode(led, MAX8997_NONE);
309                 max8997_led_set_current(led, 0);
310         }
311
312         mutex_init(&led->mutex);
313
314         platform_set_drvdata(pdev, led);
315
316         ret = led_classdev_register(&pdev->dev, &led->cdev);
317         if (ret < 0)
318                 goto err_led;
319
320         ret = device_create_file(led->cdev.dev, &dev_attr_mode);
321         if (ret != 0) {
322                 dev_err(&pdev->dev,
323                         "failed to create file: %d\n", ret);
324                 goto err_file;
325         }
326
327         return 0;
328
329 err_file:
330         led_classdev_unregister(&led->cdev);
331 err_led:
332         kfree(led);
333 err_mem:
334         return ret;
335 }
336
337 static int __devexit max8997_led_remove(struct platform_device *pdev)
338 {
339         struct max8997_led *led = platform_get_drvdata(pdev);
340
341         device_remove_file(led->cdev.dev, &dev_attr_mode);
342         led_classdev_unregister(&led->cdev);
343         kfree(led);
344
345         return 0;
346 }
347
348 static struct platform_driver max8997_led_driver = {
349         .driver = {
350                 .name  = "max8997-led",
351                 .owner = THIS_MODULE,
352         },
353         .probe  = max8997_led_probe,
354         .remove = __devexit_p(max8997_led_remove),
355 };
356
357 static int __init max8997_led_init(void)
358 {
359         return platform_driver_register(&max8997_led_driver);
360 }
361 module_init(max8997_led_init);
362
363 static void __exit max8997_led_exit(void)
364 {
365         platform_driver_unregister(&max8997_led_driver);
366 }
367 module_exit(max8997_led_exit);
368
369 MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>");
370 MODULE_DESCRIPTION("MAX8997 LED driver");
371 MODULE_LICENSE("GPL");
372 MODULE_ALIAS("platform:max8997-led");