2 * LP5521 LED chip driver.
4 * Copyright (C) 2010 Nokia Corporation
6 * Contact: Samu Onkalo <samu.p.onkalo@nokia.com>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
23 #include <linux/module.h>
24 #include <linux/init.h>
25 #include <linux/i2c.h>
26 #include <linux/mutex.h>
27 #include <linux/gpio.h>
28 #include <linux/interrupt.h>
29 #include <linux/delay.h>
30 #include <linux/ctype.h>
31 #include <linux/spinlock.h>
32 #include <linux/wait.h>
33 #include <linux/leds.h>
34 #include <linux/leds-lp5521.h>
35 #include <linux/workqueue.h>
36 #include <linux/slab.h>
38 #define LP5521_PROGRAM_LENGTH 32 /* in bytes */
40 #define LP5521_MAX_LEDS 3 /* Maximum number of LEDs */
41 #define LP5521_MAX_ENGINES 3 /* Maximum number of engines */
43 #define LP5521_ENG_MASK_BASE 0x30 /* 00110000 */
44 #define LP5521_ENG_STATUS_MASK 0x07 /* 00000111 */
46 #define LP5521_CMD_LOAD 0x15 /* 00010101 */
47 #define LP5521_CMD_RUN 0x2a /* 00101010 */
48 #define LP5521_CMD_DIRECT 0x3f /* 00111111 */
49 #define LP5521_CMD_DISABLED 0x00 /* 00000000 */
52 #define LP5521_REG_ENABLE 0x00
53 #define LP5521_REG_OP_MODE 0x01
54 #define LP5521_REG_R_PWM 0x02
55 #define LP5521_REG_G_PWM 0x03
56 #define LP5521_REG_B_PWM 0x04
57 #define LP5521_REG_R_CURRENT 0x05
58 #define LP5521_REG_G_CURRENT 0x06
59 #define LP5521_REG_B_CURRENT 0x07
60 #define LP5521_REG_CONFIG 0x08
61 #define LP5521_REG_R_CHANNEL_PC 0x09
62 #define LP5521_REG_G_CHANNEL_PC 0x0A
63 #define LP5521_REG_B_CHANNEL_PC 0x0B
64 #define LP5521_REG_STATUS 0x0C
65 #define LP5521_REG_RESET 0x0D
66 #define LP5521_REG_GPO 0x0E
67 #define LP5521_REG_R_PROG_MEM 0x10
68 #define LP5521_REG_G_PROG_MEM 0x30
69 #define LP5521_REG_B_PROG_MEM 0x50
71 #define LP5521_PROG_MEM_BASE LP5521_REG_R_PROG_MEM
72 #define LP5521_PROG_MEM_SIZE 0x20
74 /* Base register to set LED current */
75 #define LP5521_REG_LED_CURRENT_BASE LP5521_REG_R_CURRENT
77 /* Base register to set the brightness */
78 #define LP5521_REG_LED_PWM_BASE LP5521_REG_R_PWM
80 /* Bits in ENABLE register */
81 #define LP5521_MASTER_ENABLE 0x40 /* Chip master enable */
82 #define LP5521_LOGARITHMIC_PWM 0x80 /* Logarithmic PWM adjustment */
83 #define LP5521_EXEC_RUN 0x2A
85 /* Bits in CONFIG register */
86 #define LP5521_PWM_HF 0x40 /* PWM: 0 = 256Hz, 1 = 558Hz */
87 #define LP5521_PWRSAVE_EN 0x20 /* 1 = Power save mode */
88 #define LP5521_CP_MODE_OFF 0 /* Charge pump (CP) off */
89 #define LP5521_CP_MODE_BYPASS 8 /* CP forced to bypass mode */
90 #define LP5521_CP_MODE_1X5 0x10 /* CP forced to 1.5x mode */
91 #define LP5521_CP_MODE_AUTO 0x18 /* Automatic mode selection */
92 #define LP5521_R_TO_BATT 4 /* R out: 0 = CP, 1 = Vbat */
93 #define LP5521_CLK_SRC_EXT 0 /* Ext-clk source (CLK_32K) */
94 #define LP5521_CLK_INT 1 /* Internal clock */
95 #define LP5521_CLK_AUTO 2 /* Automatic clock selection */
98 #define LP5521_EXT_CLK_USED 0x08
100 struct lp5521_engine
{
101 const struct attribute_group
*attributes
;
113 struct led_classdev cdev
;
114 struct work_struct brightness_work
;
119 struct lp5521_platform_data
*pdata
;
120 struct mutex lock
; /* Serialize control */
121 struct i2c_client
*client
;
122 struct lp5521_engine engines
[LP5521_MAX_ENGINES
];
123 struct lp5521_led leds
[LP5521_MAX_LEDS
];
128 #define cdev_to_led(c) container_of(c, struct lp5521_led, cdev)
129 #define engine_to_lp5521(eng) container_of((eng), struct lp5521_chip, \
130 engines[(eng)->id - 1])
131 #define led_to_lp5521(led) container_of((led), struct lp5521_chip, \
134 static void lp5521_led_brightness_work(struct work_struct
*work
);
136 static inline int lp5521_write(struct i2c_client
*client
, u8 reg
, u8 value
)
138 return i2c_smbus_write_byte_data(client
, reg
, value
);
141 static int lp5521_read(struct i2c_client
*client
, u8 reg
, u8
*buf
)
145 ret
= i2c_smbus_read_byte_data(client
, reg
);
153 static int lp5521_set_engine_mode(struct lp5521_engine
*engine
, u8 mode
)
155 struct lp5521_chip
*chip
= engine_to_lp5521(engine
);
156 struct i2c_client
*client
= chip
->client
;
160 /* Only transition between RUN and DIRECT mode are handled here */
161 if (mode
== LP5521_CMD_LOAD
)
164 if (mode
== LP5521_CMD_DISABLED
)
165 mode
= LP5521_CMD_DIRECT
;
167 ret
= lp5521_read(client
, LP5521_REG_OP_MODE
, &engine_state
);
169 /* set mode only for this engine */
170 engine_state
&= ~(engine
->engine_mask
);
171 mode
&= engine
->engine_mask
;
172 engine_state
|= mode
;
173 ret
|= lp5521_write(client
, LP5521_REG_OP_MODE
, engine_state
);
178 static int lp5521_load_program(struct lp5521_engine
*eng
, const u8
*pattern
)
180 struct lp5521_chip
*chip
= engine_to_lp5521(eng
);
181 struct i2c_client
*client
= chip
->client
;
186 /* move current engine to direct mode and remember the state */
187 ret
= lp5521_set_engine_mode(eng
, LP5521_CMD_DIRECT
);
188 usleep_range(1000, 10000);
189 ret
|= lp5521_read(client
, LP5521_REG_OP_MODE
, &mode
);
191 /* For loading, all the engines to load mode */
192 lp5521_write(client
, LP5521_REG_OP_MODE
, LP5521_CMD_DIRECT
);
193 usleep_range(1000, 10000);
194 lp5521_write(client
, LP5521_REG_OP_MODE
, LP5521_CMD_LOAD
);
195 usleep_range(1000, 10000);
197 addr
= LP5521_PROG_MEM_BASE
+ eng
->prog_page
* LP5521_PROG_MEM_SIZE
;
198 i2c_smbus_write_i2c_block_data(client
,
200 LP5521_PROG_MEM_SIZE
,
203 ret
|= lp5521_write(client
, LP5521_REG_OP_MODE
, mode
);
207 static int lp5521_set_led_current(struct lp5521_chip
*chip
, int led
, u8 curr
)
209 return lp5521_write(chip
->client
,
210 LP5521_REG_LED_CURRENT_BASE
+ chip
->leds
[led
].chan_nr
,
214 static void lp5521_init_engine(struct lp5521_chip
*chip
,
215 const struct attribute_group
*attr_group
)
218 for (i
= 0; i
< ARRAY_SIZE(chip
->engines
); i
++) {
219 chip
->engines
[i
].id
= i
+ 1;
220 chip
->engines
[i
].engine_mask
= LP5521_ENG_MASK_BASE
>> (i
* 2);
221 chip
->engines
[i
].prog_page
= i
;
222 chip
->engines
[i
].attributes
= &attr_group
[i
];
226 static int lp5521_configure(struct i2c_client
*client
,
227 const struct attribute_group
*attr_group
)
229 struct lp5521_chip
*chip
= i2c_get_clientdata(client
);
232 lp5521_init_engine(chip
, attr_group
);
234 lp5521_write(client
, LP5521_REG_RESET
, 0xff);
236 usleep_range(10000, 20000);
238 /* Set all PWMs to direct control mode */
239 ret
= lp5521_write(client
, LP5521_REG_OP_MODE
, 0x3F);
241 /* Enable auto-powersave, set charge pump to auto, red to battery */
242 ret
|= lp5521_write(client
, LP5521_REG_CONFIG
,
243 LP5521_PWRSAVE_EN
| LP5521_CP_MODE_AUTO
| LP5521_R_TO_BATT
);
245 /* Initialize all channels PWM to zero -> leds off */
246 ret
|= lp5521_write(client
, LP5521_REG_R_PWM
, 0);
247 ret
|= lp5521_write(client
, LP5521_REG_G_PWM
, 0);
248 ret
|= lp5521_write(client
, LP5521_REG_B_PWM
, 0);
250 /* Set engines are set to run state when OP_MODE enables engines */
251 ret
|= lp5521_write(client
, LP5521_REG_ENABLE
,
252 LP5521_MASTER_ENABLE
| LP5521_LOGARITHMIC_PWM
|
254 /* enable takes 500us */
255 usleep_range(500, 20000);
260 static int lp5521_run_selftest(struct lp5521_chip
*chip
, char *buf
)
265 ret
= lp5521_read(chip
->client
, LP5521_REG_STATUS
, &status
);
269 /* Check that ext clock is really in use if requested */
270 if (chip
->pdata
&& chip
->pdata
->clock_mode
== LP5521_CLOCK_EXT
)
271 if ((status
& LP5521_EXT_CLK_USED
) == 0)
276 static void lp5521_set_brightness(struct led_classdev
*cdev
,
277 enum led_brightness brightness
)
279 struct lp5521_led
*led
= cdev_to_led(cdev
);
280 led
->brightness
= (u8
)brightness
;
281 schedule_work(&led
->brightness_work
);
284 static void lp5521_led_brightness_work(struct work_struct
*work
)
286 struct lp5521_led
*led
= container_of(work
,
289 struct lp5521_chip
*chip
= led_to_lp5521(led
);
290 struct i2c_client
*client
= chip
->client
;
292 mutex_lock(&chip
->lock
);
293 lp5521_write(client
, LP5521_REG_LED_PWM_BASE
+ led
->chan_nr
,
295 mutex_unlock(&chip
->lock
);
298 /* Detect the chip by setting its ENABLE register and reading it back. */
299 static int lp5521_detect(struct i2c_client
*client
)
304 ret
= lp5521_write(client
, LP5521_REG_ENABLE
,
305 LP5521_MASTER_ENABLE
| LP5521_LOGARITHMIC_PWM
);
308 usleep_range(1000, 10000);
309 ret
= lp5521_read(client
, LP5521_REG_ENABLE
, &buf
);
312 if (buf
!= (LP5521_MASTER_ENABLE
| LP5521_LOGARITHMIC_PWM
))
318 /* Set engine mode and create appropriate sysfs attributes, if required. */
319 static int lp5521_set_mode(struct lp5521_engine
*engine
, u8 mode
)
321 struct lp5521_chip
*chip
= engine_to_lp5521(engine
);
322 struct i2c_client
*client
= chip
->client
;
323 struct device
*dev
= &client
->dev
;
326 /* if in that mode already do nothing, except for run */
327 if (mode
== engine
->mode
&& mode
!= LP5521_CMD_RUN
)
330 if (mode
== LP5521_CMD_RUN
) {
331 ret
= lp5521_set_engine_mode(engine
, LP5521_CMD_RUN
);
332 } else if (mode
== LP5521_CMD_LOAD
) {
333 lp5521_set_engine_mode(engine
, LP5521_CMD_DISABLED
);
334 lp5521_set_engine_mode(engine
, LP5521_CMD_LOAD
);
336 ret
= sysfs_create_group(&dev
->kobj
, engine
->attributes
);
339 } else if (mode
== LP5521_CMD_DISABLED
) {
340 lp5521_set_engine_mode(engine
, LP5521_CMD_DISABLED
);
343 /* remove load attribute from sysfs if not in load mode */
344 if (engine
->mode
== LP5521_CMD_LOAD
&& mode
!= LP5521_CMD_LOAD
)
345 sysfs_remove_group(&dev
->kobj
, engine
->attributes
);
352 static int lp5521_do_store_load(struct lp5521_engine
*engine
,
353 const char *buf
, size_t len
)
355 struct lp5521_chip
*chip
= engine_to_lp5521(engine
);
356 struct i2c_client
*client
= chip
->client
;
357 int ret
, nrchars
, offset
= 0, i
= 0;
360 u8 pattern
[LP5521_PROGRAM_LENGTH
] = {0};
362 while ((offset
< len
- 1) && (i
< LP5521_PROGRAM_LENGTH
)) {
363 /* separate sscanfs because length is working only for %s */
364 ret
= sscanf(buf
+ offset
, "%2s%n ", c
, &nrchars
);
365 ret
= sscanf(c
, "%2x", &cmd
);
368 pattern
[i
] = (u8
)cmd
;
374 /* Each instruction is 16bit long. Check that length is even */
378 mutex_lock(&chip
->lock
);
379 ret
= lp5521_load_program(engine
, pattern
);
380 mutex_unlock(&chip
->lock
);
383 dev_err(&client
->dev
, "failed loading pattern\n");
389 dev_err(&client
->dev
, "wrong pattern format\n");
393 static ssize_t
store_engine_load(struct device
*dev
,
394 struct device_attribute
*attr
,
395 const char *buf
, size_t len
, int nr
)
397 struct i2c_client
*client
= to_i2c_client(dev
);
398 struct lp5521_chip
*chip
= i2c_get_clientdata(client
);
399 return lp5521_do_store_load(&chip
->engines
[nr
- 1], buf
, len
);
402 #define store_load(nr) \
403 static ssize_t store_engine##nr##_load(struct device *dev, \
404 struct device_attribute *attr, \
405 const char *buf, size_t len) \
407 return store_engine_load(dev, attr, buf, len, nr); \
413 static ssize_t
show_engine_mode(struct device
*dev
,
414 struct device_attribute
*attr
,
417 struct i2c_client
*client
= to_i2c_client(dev
);
418 struct lp5521_chip
*chip
= i2c_get_clientdata(client
);
419 switch (chip
->engines
[nr
- 1].mode
) {
421 return sprintf(buf
, "run\n");
422 case LP5521_CMD_LOAD
:
423 return sprintf(buf
, "load\n");
424 case LP5521_CMD_DISABLED
:
425 return sprintf(buf
, "disabled\n");
427 return sprintf(buf
, "disabled\n");
431 #define show_mode(nr) \
432 static ssize_t show_engine##nr##_mode(struct device *dev, \
433 struct device_attribute *attr, \
436 return show_engine_mode(dev, attr, buf, nr); \
442 static ssize_t
store_engine_mode(struct device
*dev
,
443 struct device_attribute
*attr
,
444 const char *buf
, size_t len
, int nr
)
446 struct i2c_client
*client
= to_i2c_client(dev
);
447 struct lp5521_chip
*chip
= i2c_get_clientdata(client
);
448 struct lp5521_engine
*engine
= &chip
->engines
[nr
- 1];
449 mutex_lock(&chip
->lock
);
451 if (!strncmp(buf
, "run", 3))
452 lp5521_set_mode(engine
, LP5521_CMD_RUN
);
453 else if (!strncmp(buf
, "load", 4))
454 lp5521_set_mode(engine
, LP5521_CMD_LOAD
);
455 else if (!strncmp(buf
, "disabled", 8))
456 lp5521_set_mode(engine
, LP5521_CMD_DISABLED
);
458 mutex_unlock(&chip
->lock
);
462 #define store_mode(nr) \
463 static ssize_t store_engine##nr##_mode(struct device *dev, \
464 struct device_attribute *attr, \
465 const char *buf, size_t len) \
467 return store_engine_mode(dev, attr, buf, len, nr); \
473 static ssize_t
show_max_current(struct device
*dev
,
474 struct device_attribute
*attr
,
477 struct led_classdev
*led_cdev
= dev_get_drvdata(dev
);
478 struct lp5521_led
*led
= cdev_to_led(led_cdev
);
480 return sprintf(buf
, "%d\n", led
->max_current
);
483 static ssize_t
show_current(struct device
*dev
,
484 struct device_attribute
*attr
,
487 struct led_classdev
*led_cdev
= dev_get_drvdata(dev
);
488 struct lp5521_led
*led
= cdev_to_led(led_cdev
);
490 return sprintf(buf
, "%d\n", led
->led_current
);
493 static ssize_t
store_current(struct device
*dev
,
494 struct device_attribute
*attr
,
495 const char *buf
, size_t len
)
497 struct led_classdev
*led_cdev
= dev_get_drvdata(dev
);
498 struct lp5521_led
*led
= cdev_to_led(led_cdev
);
499 struct lp5521_chip
*chip
= led_to_lp5521(led
);
503 if (strict_strtoul(buf
, 0, &curr
))
506 if (curr
> led
->max_current
)
509 mutex_lock(&chip
->lock
);
510 ret
= lp5521_set_led_current(chip
, led
->id
, curr
);
511 mutex_unlock(&chip
->lock
);
516 led
->led_current
= (u8
)curr
;
521 static ssize_t
lp5521_selftest(struct device
*dev
,
522 struct device_attribute
*attr
,
525 struct i2c_client
*client
= to_i2c_client(dev
);
526 struct lp5521_chip
*chip
= i2c_get_clientdata(client
);
529 mutex_lock(&chip
->lock
);
530 ret
= lp5521_run_selftest(chip
, buf
);
531 mutex_unlock(&chip
->lock
);
532 return sprintf(buf
, "%s\n", ret
? "FAIL" : "OK");
535 /* led class device attributes */
536 static DEVICE_ATTR(led_current
, S_IRUGO
| S_IWUGO
, show_current
, store_current
);
537 static DEVICE_ATTR(max_current
, S_IRUGO
, show_max_current
, NULL
);
539 static struct attribute
*lp5521_led_attributes
[] = {
540 &dev_attr_led_current
.attr
,
541 &dev_attr_max_current
.attr
,
545 static struct attribute_group lp5521_led_attribute_group
= {
546 .attrs
= lp5521_led_attributes
549 /* device attributes */
550 static DEVICE_ATTR(engine1_mode
, S_IRUGO
| S_IWUGO
,
551 show_engine1_mode
, store_engine1_mode
);
552 static DEVICE_ATTR(engine2_mode
, S_IRUGO
| S_IWUGO
,
553 show_engine2_mode
, store_engine2_mode
);
554 static DEVICE_ATTR(engine3_mode
, S_IRUGO
| S_IWUGO
,
555 show_engine3_mode
, store_engine3_mode
);
556 static DEVICE_ATTR(engine1_load
, S_IWUGO
, NULL
, store_engine1_load
);
557 static DEVICE_ATTR(engine2_load
, S_IWUGO
, NULL
, store_engine2_load
);
558 static DEVICE_ATTR(engine3_load
, S_IWUGO
, NULL
, store_engine3_load
);
559 static DEVICE_ATTR(selftest
, S_IRUGO
, lp5521_selftest
, NULL
);
561 static struct attribute
*lp5521_attributes
[] = {
562 &dev_attr_engine1_mode
.attr
,
563 &dev_attr_engine2_mode
.attr
,
564 &dev_attr_engine3_mode
.attr
,
565 &dev_attr_selftest
.attr
,
569 static struct attribute
*lp5521_engine1_attributes
[] = {
570 &dev_attr_engine1_load
.attr
,
574 static struct attribute
*lp5521_engine2_attributes
[] = {
575 &dev_attr_engine2_load
.attr
,
579 static struct attribute
*lp5521_engine3_attributes
[] = {
580 &dev_attr_engine3_load
.attr
,
584 static const struct attribute_group lp5521_group
= {
585 .attrs
= lp5521_attributes
,
588 static const struct attribute_group lp5521_engine_group
[] = {
589 {.attrs
= lp5521_engine1_attributes
},
590 {.attrs
= lp5521_engine2_attributes
},
591 {.attrs
= lp5521_engine3_attributes
},
594 static int lp5521_register_sysfs(struct i2c_client
*client
)
596 struct device
*dev
= &client
->dev
;
597 return sysfs_create_group(&dev
->kobj
, &lp5521_group
);
600 static void lp5521_unregister_sysfs(struct i2c_client
*client
)
602 struct lp5521_chip
*chip
= i2c_get_clientdata(client
);
603 struct device
*dev
= &client
->dev
;
606 sysfs_remove_group(&dev
->kobj
, &lp5521_group
);
608 for (i
= 0; i
< ARRAY_SIZE(chip
->engines
); i
++) {
609 if (chip
->engines
[i
].mode
== LP5521_CMD_LOAD
)
610 sysfs_remove_group(&dev
->kobj
,
611 chip
->engines
[i
].attributes
);
614 for (i
= 0; i
< chip
->num_leds
; i
++)
615 sysfs_remove_group(&chip
->leds
[i
].cdev
.dev
->kobj
,
616 &lp5521_led_attribute_group
);
619 static int __init
lp5521_init_led(struct lp5521_led
*led
,
620 struct i2c_client
*client
,
621 int chan
, struct lp5521_platform_data
*pdata
)
623 struct device
*dev
= &client
->dev
;
627 if (chan
>= LP5521_MAX_LEDS
)
630 if (pdata
->led_config
[chan
].led_current
== 0)
633 led
->led_current
= pdata
->led_config
[chan
].led_current
;
634 led
->max_current
= pdata
->led_config
[chan
].max_current
;
635 led
->chan_nr
= pdata
->led_config
[chan
].chan_nr
;
637 if (led
->chan_nr
>= LP5521_MAX_LEDS
) {
638 dev_err(dev
, "Use channel numbers between 0 and %d\n",
639 LP5521_MAX_LEDS
- 1);
643 snprintf(name
, sizeof(name
), "%s:channel%d", client
->name
, chan
);
644 led
->cdev
.brightness_set
= lp5521_set_brightness
;
645 led
->cdev
.name
= name
;
646 res
= led_classdev_register(dev
, &led
->cdev
);
648 dev_err(dev
, "couldn't register led on channel %d\n", chan
);
652 res
= sysfs_create_group(&led
->cdev
.dev
->kobj
,
653 &lp5521_led_attribute_group
);
655 dev_err(dev
, "couldn't register current attribute\n");
656 led_classdev_unregister(&led
->cdev
);
662 static int lp5521_probe(struct i2c_client
*client
,
663 const struct i2c_device_id
*id
)
665 struct lp5521_chip
*chip
;
666 struct lp5521_platform_data
*pdata
;
669 chip
= kzalloc(sizeof(*chip
), GFP_KERNEL
);
673 i2c_set_clientdata(client
, chip
);
674 chip
->client
= client
;
676 pdata
= client
->dev
.platform_data
;
679 dev_err(&client
->dev
, "no platform data\n");
684 mutex_init(&chip
->lock
);
688 if (pdata
->setup_resources
) {
689 ret
= pdata
->setup_resources();
696 usleep_range(1000, 10000);
698 usleep_range(1000, 10000); /* Spec says min 500us */
701 ret
= lp5521_detect(client
);
704 dev_err(&client
->dev
, "Chip not found\n");
708 dev_info(&client
->dev
, "%s programmable led chip found\n", id
->name
);
710 ret
= lp5521_configure(client
, lp5521_engine_group
);
712 dev_err(&client
->dev
, "error configuring chip\n");
716 /* Initialize leds */
717 chip
->num_channels
= pdata
->num_channels
;
720 for (i
= 0; i
< pdata
->num_channels
; i
++) {
721 /* Do not initialize channels that are not connected */
722 if (pdata
->led_config
[i
].led_current
== 0)
725 ret
= lp5521_init_led(&chip
->leds
[led
], client
, i
, pdata
);
727 dev_err(&client
->dev
, "error initializing leds\n");
732 chip
->leds
[led
].id
= led
;
733 /* Set initial LED current */
734 lp5521_set_led_current(chip
, led
,
735 chip
->leds
[led
].led_current
);
737 INIT_WORK(&(chip
->leds
[led
].brightness_work
),
738 lp5521_led_brightness_work
);
743 ret
= lp5521_register_sysfs(client
);
745 dev_err(&client
->dev
, "registering sysfs failed\n");
750 for (i
= 0; i
< chip
->num_leds
; i
++) {
751 led_classdev_unregister(&chip
->leds
[i
].cdev
);
752 cancel_work_sync(&chip
->leds
[i
].brightness_work
);
757 if (pdata
->release_resources
)
758 pdata
->release_resources();
764 static int lp5521_remove(struct i2c_client
*client
)
766 struct lp5521_chip
*chip
= i2c_get_clientdata(client
);
769 lp5521_unregister_sysfs(client
);
771 for (i
= 0; i
< chip
->num_leds
; i
++) {
772 led_classdev_unregister(&chip
->leds
[i
].cdev
);
773 cancel_work_sync(&chip
->leds
[i
].brightness_work
);
776 if (chip
->pdata
->enable
)
777 chip
->pdata
->enable(0);
778 if (chip
->pdata
->release_resources
)
779 chip
->pdata
->release_resources();
784 static const struct i2c_device_id lp5521_id
[] = {
785 { "lp5521", 0 }, /* Three channel chip */
788 MODULE_DEVICE_TABLE(i2c
, lp5521_id
);
790 static struct i2c_driver lp5521_driver
= {
794 .probe
= lp5521_probe
,
795 .remove
= lp5521_remove
,
796 .id_table
= lp5521_id
,
799 static int __init
lp5521_init(void)
803 ret
= i2c_add_driver(&lp5521_driver
);
806 printk(KERN_ALERT
"Adding lp5521 driver failed\n");
811 static void __exit
lp5521_exit(void)
813 i2c_del_driver(&lp5521_driver
);
816 module_init(lp5521_init
);
817 module_exit(lp5521_exit
);
819 MODULE_AUTHOR("Mathias Nyman, Yuri Zaporozhets, Samu Onkalo");
820 MODULE_DESCRIPTION("LP5521 LED engine");
821 MODULE_LICENSE("GPL v2");