xref: /openbmc/linux/drivers/leds/leds-lm3533.c (revision 791d3ef2)
1 /*
2  * leds-lm3533.c -- LM3533 LED driver
3  *
4  * Copyright (C) 2011-2012 Texas Instruments
5  *
6  * Author: Johan Hovold <jhovold@gmail.com>
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under  the terms of the GNU General  Public License as published by the
10  * Free Software Foundation;  either version 2 of the License, or (at your
11  * option) any later version.
12  */
13 
14 #include <linux/module.h>
15 #include <linux/leds.h>
16 #include <linux/mfd/core.h>
17 #include <linux/mutex.h>
18 #include <linux/platform_device.h>
19 #include <linux/slab.h>
20 
21 #include <linux/mfd/lm3533.h>
22 
23 
24 #define LM3533_LVCTRLBANK_MIN		2
25 #define LM3533_LVCTRLBANK_MAX		5
26 #define LM3533_LVCTRLBANK_COUNT		4
27 #define LM3533_RISEFALLTIME_MAX		7
28 #define LM3533_ALS_CHANNEL_LV_MIN	1
29 #define LM3533_ALS_CHANNEL_LV_MAX	2
30 
31 #define LM3533_REG_CTRLBANK_BCONF_BASE		0x1b
32 #define LM3533_REG_PATTERN_ENABLE		0x28
33 #define LM3533_REG_PATTERN_LOW_TIME_BASE	0x71
34 #define LM3533_REG_PATTERN_HIGH_TIME_BASE	0x72
35 #define LM3533_REG_PATTERN_RISETIME_BASE	0x74
36 #define LM3533_REG_PATTERN_FALLTIME_BASE	0x75
37 
38 #define LM3533_REG_PATTERN_STEP			0x10
39 
40 #define LM3533_REG_CTRLBANK_BCONF_MAPPING_MASK		0x04
41 #define LM3533_REG_CTRLBANK_BCONF_ALS_EN_MASK		0x02
42 #define LM3533_REG_CTRLBANK_BCONF_ALS_CHANNEL_MASK	0x01
43 
44 #define LM3533_LED_FLAG_PATTERN_ENABLE		1
45 
46 
47 struct lm3533_led {
48 	struct lm3533 *lm3533;
49 	struct lm3533_ctrlbank cb;
50 	struct led_classdev cdev;
51 	int id;
52 
53 	struct mutex mutex;
54 	unsigned long flags;
55 };
56 
57 
58 static inline struct lm3533_led *to_lm3533_led(struct led_classdev *cdev)
59 {
60 	return container_of(cdev, struct lm3533_led, cdev);
61 }
62 
63 static inline int lm3533_led_get_ctrlbank_id(struct lm3533_led *led)
64 {
65 	return led->id + 2;
66 }
67 
68 static inline u8 lm3533_led_get_lv_reg(struct lm3533_led *led, u8 base)
69 {
70 	return base + led->id;
71 }
72 
73 static inline u8 lm3533_led_get_pattern(struct lm3533_led *led)
74 {
75 	return led->id;
76 }
77 
78 static inline u8 lm3533_led_get_pattern_reg(struct lm3533_led *led,
79 								u8 base)
80 {
81 	return base + lm3533_led_get_pattern(led) * LM3533_REG_PATTERN_STEP;
82 }
83 
84 static int lm3533_led_pattern_enable(struct lm3533_led *led, int enable)
85 {
86 	u8 mask;
87 	u8 val;
88 	int pattern;
89 	int state;
90 	int ret = 0;
91 
92 	dev_dbg(led->cdev.dev, "%s - %d\n", __func__, enable);
93 
94 	mutex_lock(&led->mutex);
95 
96 	state = test_bit(LM3533_LED_FLAG_PATTERN_ENABLE, &led->flags);
97 	if ((enable && state) || (!enable && !state))
98 		goto out;
99 
100 	pattern = lm3533_led_get_pattern(led);
101 	mask = 1 << (2 * pattern);
102 
103 	if (enable)
104 		val = mask;
105 	else
106 		val = 0;
107 
108 	ret = lm3533_update(led->lm3533, LM3533_REG_PATTERN_ENABLE, val, mask);
109 	if (ret) {
110 		dev_err(led->cdev.dev, "failed to enable pattern %d (%d)\n",
111 							pattern, enable);
112 		goto out;
113 	}
114 
115 	__change_bit(LM3533_LED_FLAG_PATTERN_ENABLE, &led->flags);
116 out:
117 	mutex_unlock(&led->mutex);
118 
119 	return ret;
120 }
121 
122 static int lm3533_led_set(struct led_classdev *cdev,
123 						enum led_brightness value)
124 {
125 	struct lm3533_led *led = to_lm3533_led(cdev);
126 
127 	dev_dbg(led->cdev.dev, "%s - %d\n", __func__, value);
128 
129 	if (value == 0)
130 		lm3533_led_pattern_enable(led, 0);	/* disable blink */
131 
132 	return lm3533_ctrlbank_set_brightness(&led->cb, value);
133 }
134 
135 static enum led_brightness lm3533_led_get(struct led_classdev *cdev)
136 {
137 	struct lm3533_led *led = to_lm3533_led(cdev);
138 	u8 val;
139 	int ret;
140 
141 	ret = lm3533_ctrlbank_get_brightness(&led->cb, &val);
142 	if (ret)
143 		return ret;
144 
145 	dev_dbg(led->cdev.dev, "%s - %u\n", __func__, val);
146 
147 	return val;
148 }
149 
150 /* Pattern generator defines (delays in us). */
151 #define LM3533_LED_DELAY1_VMIN	0x00
152 #define LM3533_LED_DELAY2_VMIN	0x3d
153 #define LM3533_LED_DELAY3_VMIN	0x80
154 
155 #define LM3533_LED_DELAY1_VMAX	(LM3533_LED_DELAY2_VMIN - 1)
156 #define LM3533_LED_DELAY2_VMAX	(LM3533_LED_DELAY3_VMIN - 1)
157 #define LM3533_LED_DELAY3_VMAX	0xff
158 
159 #define LM3533_LED_DELAY1_TMIN	16384U
160 #define LM3533_LED_DELAY2_TMIN	1130496U
161 #define LM3533_LED_DELAY3_TMIN	10305536U
162 
163 #define LM3533_LED_DELAY1_TMAX	999424U
164 #define LM3533_LED_DELAY2_TMAX	9781248U
165 #define LM3533_LED_DELAY3_TMAX	76890112U
166 
167 /* t_step = (t_max - t_min) / (v_max - v_min) */
168 #define LM3533_LED_DELAY1_TSTEP	16384
169 #define LM3533_LED_DELAY2_TSTEP	131072
170 #define LM3533_LED_DELAY3_TSTEP	524288
171 
172 /* Delay limits for hardware accelerated blinking (in ms). */
173 #define LM3533_LED_DELAY_ON_MAX \
174 	((LM3533_LED_DELAY2_TMAX + LM3533_LED_DELAY2_TSTEP / 2) / 1000)
175 #define LM3533_LED_DELAY_OFF_MAX \
176 	((LM3533_LED_DELAY3_TMAX + LM3533_LED_DELAY3_TSTEP / 2) / 1000)
177 
178 /*
179  * Returns linear map of *t from [t_min,t_max] to [v_min,v_max] with a step
180  * size of t_step, where
181  *
182  *	t_step = (t_max - t_min) / (v_max - v_min)
183  *
184  * and updates *t to reflect the mapped value.
185  */
186 static u8 time_to_val(unsigned *t, unsigned t_min, unsigned t_step,
187 							u8 v_min, u8 v_max)
188 {
189 	unsigned val;
190 
191 	val = (*t + t_step / 2 - t_min) / t_step + v_min;
192 
193 	*t = t_step * (val - v_min) + t_min;
194 
195 	return (u8)val;
196 }
197 
198 /*
199  * Returns time code corresponding to *delay (in ms) and updates *delay to
200  * reflect actual hardware delay.
201  *
202  * Hardware supports 256 discrete delay times, divided into three groups with
203  * the following ranges and step-sizes:
204  *
205  *	[   16,   999]	[0x00, 0x3e]	step  16 ms
206  *	[ 1130,  9781]	[0x3d, 0x7f]	step 131 ms
207  *	[10306, 76890]	[0x80, 0xff]	step 524 ms
208  *
209  * Note that delay group 3 is only available for delay_off.
210  */
211 static u8 lm3533_led_get_hw_delay(unsigned *delay)
212 {
213 	unsigned t;
214 	u8 val;
215 
216 	t = *delay * 1000;
217 
218 	if (t >= (LM3533_LED_DELAY2_TMAX + LM3533_LED_DELAY3_TMIN) / 2) {
219 		t = clamp(t, LM3533_LED_DELAY3_TMIN, LM3533_LED_DELAY3_TMAX);
220 		val = time_to_val(&t,	LM3533_LED_DELAY3_TMIN,
221 					LM3533_LED_DELAY3_TSTEP,
222 					LM3533_LED_DELAY3_VMIN,
223 					LM3533_LED_DELAY3_VMAX);
224 	} else if (t >= (LM3533_LED_DELAY1_TMAX + LM3533_LED_DELAY2_TMIN) / 2) {
225 		t = clamp(t, LM3533_LED_DELAY2_TMIN, LM3533_LED_DELAY2_TMAX);
226 		val = time_to_val(&t,	LM3533_LED_DELAY2_TMIN,
227 					LM3533_LED_DELAY2_TSTEP,
228 					LM3533_LED_DELAY2_VMIN,
229 					LM3533_LED_DELAY2_VMAX);
230 	} else {
231 		t = clamp(t, LM3533_LED_DELAY1_TMIN, LM3533_LED_DELAY1_TMAX);
232 		val = time_to_val(&t,	LM3533_LED_DELAY1_TMIN,
233 					LM3533_LED_DELAY1_TSTEP,
234 					LM3533_LED_DELAY1_VMIN,
235 					LM3533_LED_DELAY1_VMAX);
236 	}
237 
238 	*delay = (t + 500) / 1000;
239 
240 	return val;
241 }
242 
243 /*
244  * Set delay register base to *delay (in ms) and update *delay to reflect
245  * actual hardware delay used.
246  */
247 static u8 lm3533_led_delay_set(struct lm3533_led *led, u8 base,
248 							unsigned long *delay)
249 {
250 	unsigned t;
251 	u8 val;
252 	u8 reg;
253 	int ret;
254 
255 	t = (unsigned)*delay;
256 
257 	/* Delay group 3 is only available for low time (delay off). */
258 	if (base != LM3533_REG_PATTERN_LOW_TIME_BASE)
259 		t = min(t, LM3533_LED_DELAY2_TMAX / 1000);
260 
261 	val = lm3533_led_get_hw_delay(&t);
262 
263 	dev_dbg(led->cdev.dev, "%s - %lu: %u (0x%02x)\n", __func__,
264 							*delay, t, val);
265 	reg = lm3533_led_get_pattern_reg(led, base);
266 	ret = lm3533_write(led->lm3533, reg, val);
267 	if (ret)
268 		dev_err(led->cdev.dev, "failed to set delay (%02x)\n", reg);
269 
270 	*delay = t;
271 
272 	return ret;
273 }
274 
275 static int lm3533_led_delay_on_set(struct lm3533_led *led, unsigned long *t)
276 {
277 	return lm3533_led_delay_set(led, LM3533_REG_PATTERN_HIGH_TIME_BASE, t);
278 }
279 
280 static int lm3533_led_delay_off_set(struct lm3533_led *led, unsigned long *t)
281 {
282 	return lm3533_led_delay_set(led, LM3533_REG_PATTERN_LOW_TIME_BASE, t);
283 }
284 
285 static int lm3533_led_blink_set(struct led_classdev *cdev,
286 				unsigned long *delay_on,
287 				unsigned long *delay_off)
288 {
289 	struct lm3533_led *led = to_lm3533_led(cdev);
290 	int ret;
291 
292 	dev_dbg(led->cdev.dev, "%s - on = %lu, off = %lu\n", __func__,
293 							*delay_on, *delay_off);
294 
295 	if (*delay_on > LM3533_LED_DELAY_ON_MAX ||
296 					*delay_off > LM3533_LED_DELAY_OFF_MAX)
297 		return -EINVAL;
298 
299 	if (*delay_on == 0 && *delay_off == 0) {
300 		*delay_on = 500;
301 		*delay_off = 500;
302 	}
303 
304 	ret = lm3533_led_delay_on_set(led, delay_on);
305 	if (ret)
306 		return ret;
307 
308 	ret = lm3533_led_delay_off_set(led, delay_off);
309 	if (ret)
310 		return ret;
311 
312 	return lm3533_led_pattern_enable(led, 1);
313 }
314 
315 static ssize_t show_id(struct device *dev,
316 				struct device_attribute *attr, char *buf)
317 {
318 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
319 	struct lm3533_led *led = to_lm3533_led(led_cdev);
320 
321 	return scnprintf(buf, PAGE_SIZE, "%d\n", led->id);
322 }
323 
324 /*
325  * Pattern generator rise/fall times:
326  *
327  *   0 - 2048 us (default)
328  *   1 - 262 ms
329  *   2 - 524 ms
330  *   3 - 1.049 s
331  *   4 - 2.097 s
332  *   5 - 4.194 s
333  *   6 - 8.389 s
334  *   7 - 16.78 s
335  */
336 static ssize_t show_risefalltime(struct device *dev,
337 					struct device_attribute *attr,
338 					char *buf, u8 base)
339 {
340 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
341 	struct lm3533_led *led = to_lm3533_led(led_cdev);
342 	ssize_t ret;
343 	u8 reg;
344 	u8 val;
345 
346 	reg = lm3533_led_get_pattern_reg(led, base);
347 	ret = lm3533_read(led->lm3533, reg, &val);
348 	if (ret)
349 		return ret;
350 
351 	return scnprintf(buf, PAGE_SIZE, "%x\n", val);
352 }
353 
354 static ssize_t show_risetime(struct device *dev,
355 				struct device_attribute *attr, char *buf)
356 {
357 	return show_risefalltime(dev, attr, buf,
358 					LM3533_REG_PATTERN_RISETIME_BASE);
359 }
360 
361 static ssize_t show_falltime(struct device *dev,
362 				struct device_attribute *attr, char *buf)
363 {
364 	return show_risefalltime(dev, attr, buf,
365 					LM3533_REG_PATTERN_FALLTIME_BASE);
366 }
367 
368 static ssize_t store_risefalltime(struct device *dev,
369 					struct device_attribute *attr,
370 					const char *buf, size_t len, u8 base)
371 {
372 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
373 	struct lm3533_led *led = to_lm3533_led(led_cdev);
374 	u8 val;
375 	u8 reg;
376 	int ret;
377 
378 	if (kstrtou8(buf, 0, &val) || val > LM3533_RISEFALLTIME_MAX)
379 		return -EINVAL;
380 
381 	reg = lm3533_led_get_pattern_reg(led, base);
382 	ret = lm3533_write(led->lm3533, reg, val);
383 	if (ret)
384 		return ret;
385 
386 	return len;
387 }
388 
389 static ssize_t store_risetime(struct device *dev,
390 					struct device_attribute *attr,
391 					const char *buf, size_t len)
392 {
393 	return store_risefalltime(dev, attr, buf, len,
394 					LM3533_REG_PATTERN_RISETIME_BASE);
395 }
396 
397 static ssize_t store_falltime(struct device *dev,
398 					struct device_attribute *attr,
399 					const char *buf, size_t len)
400 {
401 	return store_risefalltime(dev, attr, buf, len,
402 					LM3533_REG_PATTERN_FALLTIME_BASE);
403 }
404 
405 static ssize_t show_als_channel(struct device *dev,
406 				struct device_attribute *attr, char *buf)
407 {
408 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
409 	struct lm3533_led *led = to_lm3533_led(led_cdev);
410 	unsigned channel;
411 	u8 reg;
412 	u8 val;
413 	int ret;
414 
415 	reg = lm3533_led_get_lv_reg(led, LM3533_REG_CTRLBANK_BCONF_BASE);
416 	ret = lm3533_read(led->lm3533, reg, &val);
417 	if (ret)
418 		return ret;
419 
420 	channel = (val & LM3533_REG_CTRLBANK_BCONF_ALS_CHANNEL_MASK) + 1;
421 
422 	return scnprintf(buf, PAGE_SIZE, "%u\n", channel);
423 }
424 
425 static ssize_t store_als_channel(struct device *dev,
426 					struct device_attribute *attr,
427 					const char *buf, size_t len)
428 {
429 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
430 	struct lm3533_led *led = to_lm3533_led(led_cdev);
431 	unsigned channel;
432 	u8 reg;
433 	u8 val;
434 	u8 mask;
435 	int ret;
436 
437 	if (kstrtouint(buf, 0, &channel))
438 		return -EINVAL;
439 
440 	if (channel < LM3533_ALS_CHANNEL_LV_MIN ||
441 					channel > LM3533_ALS_CHANNEL_LV_MAX)
442 		return -EINVAL;
443 
444 	reg = lm3533_led_get_lv_reg(led, LM3533_REG_CTRLBANK_BCONF_BASE);
445 	mask = LM3533_REG_CTRLBANK_BCONF_ALS_CHANNEL_MASK;
446 	val = channel - 1;
447 
448 	ret = lm3533_update(led->lm3533, reg, val, mask);
449 	if (ret)
450 		return ret;
451 
452 	return len;
453 }
454 
455 static ssize_t show_als_en(struct device *dev,
456 				struct device_attribute *attr, char *buf)
457 {
458 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
459 	struct lm3533_led *led = to_lm3533_led(led_cdev);
460 	bool enable;
461 	u8 reg;
462 	u8 val;
463 	int ret;
464 
465 	reg = lm3533_led_get_lv_reg(led, LM3533_REG_CTRLBANK_BCONF_BASE);
466 	ret = lm3533_read(led->lm3533, reg, &val);
467 	if (ret)
468 		return ret;
469 
470 	enable = val & LM3533_REG_CTRLBANK_BCONF_ALS_EN_MASK;
471 
472 	return scnprintf(buf, PAGE_SIZE, "%d\n", enable);
473 }
474 
475 static ssize_t store_als_en(struct device *dev,
476 					struct device_attribute *attr,
477 					const char *buf, size_t len)
478 {
479 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
480 	struct lm3533_led *led = to_lm3533_led(led_cdev);
481 	unsigned enable;
482 	u8 reg;
483 	u8 mask;
484 	u8 val;
485 	int ret;
486 
487 	if (kstrtouint(buf, 0, &enable))
488 		return -EINVAL;
489 
490 	reg = lm3533_led_get_lv_reg(led, LM3533_REG_CTRLBANK_BCONF_BASE);
491 	mask = LM3533_REG_CTRLBANK_BCONF_ALS_EN_MASK;
492 
493 	if (enable)
494 		val = mask;
495 	else
496 		val = 0;
497 
498 	ret = lm3533_update(led->lm3533, reg, val, mask);
499 	if (ret)
500 		return ret;
501 
502 	return len;
503 }
504 
505 static ssize_t show_linear(struct device *dev,
506 				struct device_attribute *attr, char *buf)
507 {
508 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
509 	struct lm3533_led *led = to_lm3533_led(led_cdev);
510 	u8 reg;
511 	u8 val;
512 	int linear;
513 	int ret;
514 
515 	reg = lm3533_led_get_lv_reg(led, LM3533_REG_CTRLBANK_BCONF_BASE);
516 	ret = lm3533_read(led->lm3533, reg, &val);
517 	if (ret)
518 		return ret;
519 
520 	if (val & LM3533_REG_CTRLBANK_BCONF_MAPPING_MASK)
521 		linear = 1;
522 	else
523 		linear = 0;
524 
525 	return scnprintf(buf, PAGE_SIZE, "%x\n", linear);
526 }
527 
528 static ssize_t store_linear(struct device *dev,
529 					struct device_attribute *attr,
530 					const char *buf, size_t len)
531 {
532 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
533 	struct lm3533_led *led = to_lm3533_led(led_cdev);
534 	unsigned long linear;
535 	u8 reg;
536 	u8 mask;
537 	u8 val;
538 	int ret;
539 
540 	if (kstrtoul(buf, 0, &linear))
541 		return -EINVAL;
542 
543 	reg = lm3533_led_get_lv_reg(led, LM3533_REG_CTRLBANK_BCONF_BASE);
544 	mask = LM3533_REG_CTRLBANK_BCONF_MAPPING_MASK;
545 
546 	if (linear)
547 		val = mask;
548 	else
549 		val = 0;
550 
551 	ret = lm3533_update(led->lm3533, reg, val, mask);
552 	if (ret)
553 		return ret;
554 
555 	return len;
556 }
557 
558 static ssize_t show_pwm(struct device *dev,
559 					struct device_attribute *attr,
560 					char *buf)
561 {
562 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
563 	struct lm3533_led *led = to_lm3533_led(led_cdev);
564 	u8 val;
565 	int ret;
566 
567 	ret = lm3533_ctrlbank_get_pwm(&led->cb, &val);
568 	if (ret)
569 		return ret;
570 
571 	return scnprintf(buf, PAGE_SIZE, "%u\n", val);
572 }
573 
574 static ssize_t store_pwm(struct device *dev,
575 					struct device_attribute *attr,
576 					const char *buf, size_t len)
577 {
578 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
579 	struct lm3533_led *led = to_lm3533_led(led_cdev);
580 	u8 val;
581 	int ret;
582 
583 	if (kstrtou8(buf, 0, &val))
584 		return -EINVAL;
585 
586 	ret = lm3533_ctrlbank_set_pwm(&led->cb, val);
587 	if (ret)
588 		return ret;
589 
590 	return len;
591 }
592 
593 static LM3533_ATTR_RW(als_channel);
594 static LM3533_ATTR_RW(als_en);
595 static LM3533_ATTR_RW(falltime);
596 static LM3533_ATTR_RO(id);
597 static LM3533_ATTR_RW(linear);
598 static LM3533_ATTR_RW(pwm);
599 static LM3533_ATTR_RW(risetime);
600 
601 static struct attribute *lm3533_led_attributes[] = {
602 	&dev_attr_als_channel.attr,
603 	&dev_attr_als_en.attr,
604 	&dev_attr_falltime.attr,
605 	&dev_attr_id.attr,
606 	&dev_attr_linear.attr,
607 	&dev_attr_pwm.attr,
608 	&dev_attr_risetime.attr,
609 	NULL,
610 };
611 
612 static umode_t lm3533_led_attr_is_visible(struct kobject *kobj,
613 					     struct attribute *attr, int n)
614 {
615 	struct device *dev = container_of(kobj, struct device, kobj);
616 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
617 	struct lm3533_led *led = to_lm3533_led(led_cdev);
618 	umode_t mode = attr->mode;
619 
620 	if (attr == &dev_attr_als_channel.attr ||
621 					attr == &dev_attr_als_en.attr) {
622 		if (!led->lm3533->have_als)
623 			mode = 0;
624 	}
625 
626 	return mode;
627 };
628 
629 static const struct attribute_group lm3533_led_attribute_group = {
630 	.is_visible	= lm3533_led_attr_is_visible,
631 	.attrs		= lm3533_led_attributes
632 };
633 
634 static const struct attribute_group *lm3533_led_attribute_groups[] = {
635 	&lm3533_led_attribute_group,
636 	NULL
637 };
638 
639 static int lm3533_led_setup(struct lm3533_led *led,
640 					struct lm3533_led_platform_data *pdata)
641 {
642 	int ret;
643 
644 	ret = lm3533_ctrlbank_set_max_current(&led->cb, pdata->max_current);
645 	if (ret)
646 		return ret;
647 
648 	return lm3533_ctrlbank_set_pwm(&led->cb, pdata->pwm);
649 }
650 
651 static int lm3533_led_probe(struct platform_device *pdev)
652 {
653 	struct lm3533 *lm3533;
654 	struct lm3533_led_platform_data *pdata;
655 	struct lm3533_led *led;
656 	int ret;
657 
658 	dev_dbg(&pdev->dev, "%s\n", __func__);
659 
660 	lm3533 = dev_get_drvdata(pdev->dev.parent);
661 	if (!lm3533)
662 		return -EINVAL;
663 
664 	pdata = dev_get_platdata(&pdev->dev);
665 	if (!pdata) {
666 		dev_err(&pdev->dev, "no platform data\n");
667 		return -EINVAL;
668 	}
669 
670 	if (pdev->id < 0 || pdev->id >= LM3533_LVCTRLBANK_COUNT) {
671 		dev_err(&pdev->dev, "illegal LED id %d\n", pdev->id);
672 		return -EINVAL;
673 	}
674 
675 	led = devm_kzalloc(&pdev->dev, sizeof(*led), GFP_KERNEL);
676 	if (!led)
677 		return -ENOMEM;
678 
679 	led->lm3533 = lm3533;
680 	led->cdev.name = pdata->name;
681 	led->cdev.default_trigger = pdata->default_trigger;
682 	led->cdev.brightness_set_blocking = lm3533_led_set;
683 	led->cdev.brightness_get = lm3533_led_get;
684 	led->cdev.blink_set = lm3533_led_blink_set;
685 	led->cdev.brightness = LED_OFF;
686 	led->cdev.groups = lm3533_led_attribute_groups,
687 	led->id = pdev->id;
688 
689 	mutex_init(&led->mutex);
690 
691 	/* The class framework makes a callback to get brightness during
692 	 * registration so use parent device (for error reporting) until
693 	 * registered.
694 	 */
695 	led->cb.lm3533 = lm3533;
696 	led->cb.id = lm3533_led_get_ctrlbank_id(led);
697 	led->cb.dev = lm3533->dev;
698 
699 	platform_set_drvdata(pdev, led);
700 
701 	ret = devm_led_classdev_register(pdev->dev.parent, &led->cdev);
702 	if (ret) {
703 		dev_err(&pdev->dev, "failed to register LED %d\n", pdev->id);
704 		return ret;
705 	}
706 
707 	led->cb.dev = led->cdev.dev;
708 
709 	ret = lm3533_led_setup(led, pdata);
710 	if (ret)
711 		return ret;
712 
713 	ret = lm3533_ctrlbank_enable(&led->cb);
714 	if (ret)
715 		return ret;
716 
717 	return 0;
718 }
719 
720 static int lm3533_led_remove(struct platform_device *pdev)
721 {
722 	struct lm3533_led *led = platform_get_drvdata(pdev);
723 
724 	dev_dbg(&pdev->dev, "%s\n", __func__);
725 
726 	lm3533_ctrlbank_disable(&led->cb);
727 
728 	return 0;
729 }
730 
731 static void lm3533_led_shutdown(struct platform_device *pdev)
732 {
733 
734 	struct lm3533_led *led = platform_get_drvdata(pdev);
735 
736 	dev_dbg(&pdev->dev, "%s\n", __func__);
737 
738 	lm3533_ctrlbank_disable(&led->cb);
739 	lm3533_led_set(&led->cdev, LED_OFF);		/* disable blink */
740 }
741 
742 static struct platform_driver lm3533_led_driver = {
743 	.driver = {
744 		.name = "lm3533-leds",
745 	},
746 	.probe		= lm3533_led_probe,
747 	.remove		= lm3533_led_remove,
748 	.shutdown	= lm3533_led_shutdown,
749 };
750 module_platform_driver(lm3533_led_driver);
751 
752 MODULE_AUTHOR("Johan Hovold <jhovold@gmail.com>");
753 MODULE_DESCRIPTION("LM3533 LED driver");
754 MODULE_LICENSE("GPL");
755 MODULE_ALIAS("platform:lm3533-leds");
756