Version:  2.0.40 2.2.26 2.4.37 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6

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

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