Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

Linux/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_set_mode(struct max8997_led *led,
 53                         enum max8997_led_mode mode)
 54 {
 55         int ret;
 56         struct i2c_client *client = led->iodev->i2c;
 57         u8 mask = 0, val;
 58 
 59         switch (mode) {
 60         case MAX8997_FLASH_MODE:
 61                 mask = MAX8997_LED1_FLASH_MASK | MAX8997_LED0_FLASH_MASK;
 62                 val = led->id ?
 63                       MAX8997_LED1_FLASH_MASK : MAX8997_LED0_FLASH_MASK;
 64                 led->cdev.max_brightness = MAX8997_LED_FLASH_MAX_BRIGHTNESS;
 65                 break;
 66         case MAX8997_MOVIE_MODE:
 67                 mask = MAX8997_LED1_MOVIE_MASK | MAX8997_LED0_MOVIE_MASK;
 68                 val = led->id ?
 69                       MAX8997_LED1_MOVIE_MASK : MAX8997_LED0_MOVIE_MASK;
 70                 led->cdev.max_brightness = MAX8997_LED_MOVIE_MAX_BRIGHTNESS;
 71                 break;
 72         case MAX8997_FLASH_PIN_CONTROL_MODE:
 73                 mask = MAX8997_LED1_FLASH_PIN_MASK |
 74                        MAX8997_LED0_FLASH_PIN_MASK;
 75                 val = led->id ?
 76                       MAX8997_LED1_FLASH_PIN_MASK : MAX8997_LED0_FLASH_PIN_MASK;
 77                 led->cdev.max_brightness = MAX8997_LED_FLASH_MAX_BRIGHTNESS;
 78                 break;
 79         case MAX8997_MOVIE_PIN_CONTROL_MODE:
 80                 mask = MAX8997_LED1_MOVIE_PIN_MASK |
 81                        MAX8997_LED0_MOVIE_PIN_MASK;
 82                 val = led->id ?
 83                       MAX8997_LED1_MOVIE_PIN_MASK : MAX8997_LED0_MOVIE_PIN_MASK;
 84                 led->cdev.max_brightness = MAX8997_LED_MOVIE_MAX_BRIGHTNESS;
 85                 break;
 86         default:
 87                 led->cdev.max_brightness = MAX8997_LED_NONE_MAX_BRIGHTNESS;
 88                 break;
 89         }
 90 
 91         if (mask) {
 92                 ret = max8997_update_reg(client, MAX8997_REG_LEN_CNTL, val,
 93                                          mask);
 94                 if (ret)
 95                         dev_err(led->iodev->dev,
 96                                 "failed to update register(%d)\n", ret);
 97         }
 98 
 99         led->led_mode = mode;
100 }
101 
102 static void max8997_led_enable(struct max8997_led *led, bool enable)
103 {
104         int ret;
105         struct i2c_client *client = led->iodev->i2c;
106         u8 val = 0, mask = MAX8997_LED_BOOST_ENABLE_MASK;
107 
108         if (led->enabled == enable)
109                 return;
110 
111         val = enable ? MAX8997_LED_BOOST_ENABLE_MASK : 0;
112 
113         ret = max8997_update_reg(client, MAX8997_REG_BOOST_CNTL, val, mask);
114         if (ret)
115                 dev_err(led->iodev->dev,
116                         "failed to update register(%d)\n", ret);
117 
118         led->enabled = enable;
119 }
120 
121 static void max8997_led_set_current(struct max8997_led *led,
122                                 enum led_brightness value)
123 {
124         int ret;
125         struct i2c_client *client = led->iodev->i2c;
126         u8 val = 0, mask = 0, reg = 0;
127 
128         switch (led->led_mode) {
129         case MAX8997_FLASH_MODE:
130         case MAX8997_FLASH_PIN_CONTROL_MODE:
131                 val = value << MAX8997_LED_FLASH_SHIFT;
132                 mask = MAX8997_LED_FLASH_CUR_MASK;
133                 reg = led->id ? MAX8997_REG_FLASH2_CUR : MAX8997_REG_FLASH1_CUR;
134                 break;
135         case MAX8997_MOVIE_MODE:
136         case MAX8997_MOVIE_PIN_CONTROL_MODE:
137                 val = value << MAX8997_LED_MOVIE_SHIFT;
138                 mask = MAX8997_LED_MOVIE_CUR_MASK;
139                 reg = MAX8997_REG_MOVIE_CUR;
140                 break;
141         default:
142                 break;
143         }
144 
145         if (mask) {
146                 ret = max8997_update_reg(client, reg, val, mask);
147                 if (ret)
148                         dev_err(led->iodev->dev,
149                                 "failed to update register(%d)\n", ret);
150         }
151 }
152 
153 static void max8997_led_brightness_set(struct led_classdev *led_cdev,
154                                 enum led_brightness value)
155 {
156         struct max8997_led *led =
157                         container_of(led_cdev, struct max8997_led, cdev);
158 
159         if (value) {
160                 max8997_led_set_current(led, value);
161                 max8997_led_enable(led, true);
162         } else {
163                 max8997_led_set_current(led, value);
164                 max8997_led_enable(led, false);
165         }
166 }
167 
168 static ssize_t max8997_led_show_mode(struct device *dev,
169                                 struct device_attribute *attr, char *buf)
170 {
171         struct led_classdev *led_cdev = dev_get_drvdata(dev);
172         struct max8997_led *led =
173                         container_of(led_cdev, struct max8997_led, cdev);
174         ssize_t ret = 0;
175 
176         mutex_lock(&led->mutex);
177 
178         switch (led->led_mode) {
179         case MAX8997_FLASH_MODE:
180                 ret += sprintf(buf, "FLASH\n");
181                 break;
182         case MAX8997_MOVIE_MODE:
183                 ret += sprintf(buf, "MOVIE\n");
184                 break;
185         case MAX8997_FLASH_PIN_CONTROL_MODE:
186                 ret += sprintf(buf, "FLASH_PIN_CONTROL\n");
187                 break;
188         case MAX8997_MOVIE_PIN_CONTROL_MODE:
189                 ret += sprintf(buf, "MOVIE_PIN_CONTROL\n");
190                 break;
191         default:
192                 ret += sprintf(buf, "NONE\n");
193                 break;
194         }
195 
196         mutex_unlock(&led->mutex);
197 
198         return ret;
199 }
200 
201 static ssize_t max8997_led_store_mode(struct device *dev,
202                                 struct device_attribute *attr,
203                                 const char *buf, size_t size)
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         enum max8997_led_mode mode;
209 
210         mutex_lock(&led->mutex);
211 
212         if (!strncmp(buf, "FLASH_PIN_CONTROL", 17))
213                 mode = MAX8997_FLASH_PIN_CONTROL_MODE;
214         else if (!strncmp(buf, "MOVIE_PIN_CONTROL", 17))
215                 mode = MAX8997_MOVIE_PIN_CONTROL_MODE;
216         else if (!strncmp(buf, "FLASH", 5))
217                 mode = MAX8997_FLASH_MODE;
218         else if (!strncmp(buf, "MOVIE", 5))
219                 mode = MAX8997_MOVIE_MODE;
220         else
221                 mode = MAX8997_NONE;
222 
223         max8997_led_set_mode(led, mode);
224 
225         mutex_unlock(&led->mutex);
226 
227         return size;
228 }
229 
230 static DEVICE_ATTR(mode, 0644, max8997_led_show_mode, max8997_led_store_mode);
231 
232 static struct attribute *max8997_attrs[] = {
233         &dev_attr_mode.attr,
234         NULL
235 };
236 ATTRIBUTE_GROUPS(max8997);
237 
238 static int max8997_led_probe(struct platform_device *pdev)
239 {
240         struct max8997_dev *iodev = dev_get_drvdata(pdev->dev.parent);
241         struct max8997_platform_data *pdata = dev_get_platdata(iodev->dev);
242         struct max8997_led *led;
243         char name[20];
244         int ret = 0;
245 
246         if (pdata == NULL) {
247                 dev_err(&pdev->dev, "no platform data\n");
248                 return -ENODEV;
249         }
250 
251         led = devm_kzalloc(&pdev->dev, sizeof(*led), GFP_KERNEL);
252         if (led == NULL)
253                 return -ENOMEM;
254 
255         led->id = pdev->id;
256         snprintf(name, sizeof(name), "max8997-led%d", pdev->id);
257 
258         led->cdev.name = name;
259         led->cdev.brightness_set = max8997_led_brightness_set;
260         led->cdev.flags |= LED_CORE_SUSPENDRESUME;
261         led->cdev.brightness = 0;
262         led->cdev.groups = max8997_groups;
263         led->iodev = iodev;
264 
265         /* initialize mode and brightness according to platform_data */
266         if (pdata->led_pdata) {
267                 u8 mode = 0, brightness = 0;
268 
269                 mode = pdata->led_pdata->mode[led->id];
270                 brightness = pdata->led_pdata->brightness[led->id];
271 
272                 max8997_led_set_mode(led, pdata->led_pdata->mode[led->id]);
273 
274                 if (brightness > led->cdev.max_brightness)
275                         brightness = led->cdev.max_brightness;
276                 max8997_led_set_current(led, brightness);
277                 led->cdev.brightness = brightness;
278         } else {
279                 max8997_led_set_mode(led, MAX8997_NONE);
280                 max8997_led_set_current(led, 0);
281         }
282 
283         mutex_init(&led->mutex);
284 
285         platform_set_drvdata(pdev, led);
286 
287         ret = led_classdev_register(&pdev->dev, &led->cdev);
288         if (ret < 0)
289                 return ret;
290 
291         return 0;
292 }
293 
294 static int max8997_led_remove(struct platform_device *pdev)
295 {
296         struct max8997_led *led = platform_get_drvdata(pdev);
297 
298         led_classdev_unregister(&led->cdev);
299 
300         return 0;
301 }
302 
303 static struct platform_driver max8997_led_driver = {
304         .driver = {
305                 .name  = "max8997-led",
306                 .owner = THIS_MODULE,
307         },
308         .probe  = max8997_led_probe,
309         .remove = max8997_led_remove,
310 };
311 
312 module_platform_driver(max8997_led_driver);
313 
314 MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>");
315 MODULE_DESCRIPTION("MAX8997 LED driver");
316 MODULE_LICENSE("GPL");
317 MODULE_ALIAS("platform:max8997-led");
318 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us