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>
37 #include <linux/platform_data/leds-lp55xx.h>
39 #include "leds-lp55xx-common.h"
41 #define LP5521_PROGRAM_LENGTH 32 /* in bytes */
43 #define LP5521_MAX_LEDS 3 /* Maximum number of LEDs */
44 #define LP5521_MAX_ENGINES 3 /* Maximum number of engines */
46 #define LP5521_ENG_MASK_BASE 0x30 /* 00110000 */
47 #define LP5521_ENG_STATUS_MASK 0x07 /* 00000111 */
49 #define LP5521_CMD_LOAD 0x15 /* 00010101 */
50 #define LP5521_CMD_RUN 0x2a /* 00101010 */
51 #define LP5521_CMD_DIRECT 0x3f /* 00111111 */
52 #define LP5521_CMD_DISABLED 0x00 /* 00000000 */
55 #define LP5521_REG_ENABLE 0x00
56 #define LP5521_REG_OP_MODE 0x01
57 #define LP5521_REG_R_PWM 0x02
58 #define LP5521_REG_G_PWM 0x03
59 #define LP5521_REG_B_PWM 0x04
60 #define LP5521_REG_R_CURRENT 0x05
61 #define LP5521_REG_G_CURRENT 0x06
62 #define LP5521_REG_B_CURRENT 0x07
63 #define LP5521_REG_CONFIG 0x08
64 #define LP5521_REG_R_CHANNEL_PC 0x09
65 #define LP5521_REG_G_CHANNEL_PC 0x0A
66 #define LP5521_REG_B_CHANNEL_PC 0x0B
67 #define LP5521_REG_STATUS 0x0C
68 #define LP5521_REG_RESET 0x0D
69 #define LP5521_REG_GPO 0x0E
70 #define LP5521_REG_R_PROG_MEM 0x10
71 #define LP5521_REG_G_PROG_MEM 0x30
72 #define LP5521_REG_B_PROG_MEM 0x50
74 #define LP5521_PROG_MEM_BASE LP5521_REG_R_PROG_MEM
75 #define LP5521_PROG_MEM_SIZE 0x20
77 /* Base register to set LED current */
78 #define LP5521_REG_LED_CURRENT_BASE LP5521_REG_R_CURRENT
80 /* Base register to set the brightness */
81 #define LP5521_REG_LED_PWM_BASE LP5521_REG_R_PWM
83 /* Bits in ENABLE register */
84 #define LP5521_MASTER_ENABLE 0x40 /* Chip master enable */
85 #define LP5521_LOGARITHMIC_PWM 0x80 /* Logarithmic PWM adjustment */
86 #define LP5521_EXEC_RUN 0x2A
87 #define LP5521_ENABLE_DEFAULT \
88 (LP5521_MASTER_ENABLE | LP5521_LOGARITHMIC_PWM)
89 #define LP5521_ENABLE_RUN_PROGRAM \
90 (LP5521_ENABLE_DEFAULT | LP5521_EXEC_RUN)
93 #define LP5521_EXT_CLK_USED 0x08
95 /* default R channel current register value */
96 #define LP5521_REG_R_CURR_DEFAULT 0xAF
101 /* Reset register value */
102 #define LP5521_RESET 0xFF
104 struct lp5521_engine
{
116 struct led_classdev cdev
;
117 struct work_struct brightness_work
;
122 struct lp5521_platform_data
*pdata
;
123 struct mutex lock
; /* Serialize control */
124 struct i2c_client
*client
;
125 struct lp5521_engine engines
[LP5521_MAX_ENGINES
];
126 struct lp5521_led leds
[LP5521_MAX_LEDS
];
131 static inline void lp5521_wait_enable_done(void)
133 /* it takes more 488 us to update ENABLE register */
134 usleep_range(500, 600);
137 static inline struct lp5521_led
*cdev_to_led(struct led_classdev
*cdev
)
139 return container_of(cdev
, struct lp5521_led
, cdev
);
142 static inline struct lp5521_chip
*engine_to_lp5521(struct lp5521_engine
*engine
)
144 return container_of(engine
, struct lp5521_chip
,
145 engines
[engine
->id
- 1]);
148 static inline struct lp5521_chip
*led_to_lp5521(struct lp5521_led
*led
)
150 return container_of(led
, struct lp5521_chip
,
154 static void lp5521_led_brightness_work(struct work_struct
*work
);
156 static inline int lp5521_write(struct i2c_client
*client
, u8 reg
, u8 value
)
158 return i2c_smbus_write_byte_data(client
, reg
, value
);
161 static int lp5521_read(struct i2c_client
*client
, u8 reg
, u8
*buf
)
165 ret
= i2c_smbus_read_byte_data(client
, reg
);
173 static int lp5521_set_engine_mode(struct lp5521_engine
*engine
, u8 mode
)
175 struct lp5521_chip
*chip
= engine_to_lp5521(engine
);
176 struct i2c_client
*client
= chip
->client
;
180 /* Only transition between RUN and DIRECT mode are handled here */
181 if (mode
== LP5521_CMD_LOAD
)
184 if (mode
== LP5521_CMD_DISABLED
)
185 mode
= LP5521_CMD_DIRECT
;
187 ret
= lp5521_read(client
, LP5521_REG_OP_MODE
, &engine_state
);
191 /* set mode only for this engine */
192 engine_state
&= ~(engine
->engine_mask
);
193 mode
&= engine
->engine_mask
;
194 engine_state
|= mode
;
195 return lp5521_write(client
, LP5521_REG_OP_MODE
, engine_state
);
198 static int lp5521_load_program(struct lp5521_engine
*eng
, const u8
*pattern
)
200 struct lp5521_chip
*chip
= engine_to_lp5521(eng
);
201 struct i2c_client
*client
= chip
->client
;
206 /* move current engine to direct mode and remember the state */
207 ret
= lp5521_set_engine_mode(eng
, LP5521_CMD_DIRECT
);
211 /* Mode change requires min 500 us delay. 1 - 2 ms with margin */
212 usleep_range(1000, 2000);
213 ret
= lp5521_read(client
, LP5521_REG_OP_MODE
, &mode
);
217 /* For loading, all the engines to load mode */
218 lp5521_write(client
, LP5521_REG_OP_MODE
, LP5521_CMD_DIRECT
);
219 /* Mode change requires min 500 us delay. 1 - 2 ms with margin */
220 usleep_range(1000, 2000);
221 lp5521_write(client
, LP5521_REG_OP_MODE
, LP5521_CMD_LOAD
);
222 /* Mode change requires min 500 us delay. 1 - 2 ms with margin */
223 usleep_range(1000, 2000);
225 addr
= LP5521_PROG_MEM_BASE
+ eng
->prog_page
* LP5521_PROG_MEM_SIZE
;
226 i2c_smbus_write_i2c_block_data(client
,
228 LP5521_PROG_MEM_SIZE
,
231 return lp5521_write(client
, LP5521_REG_OP_MODE
, mode
);
234 static int lp5521_set_led_current(struct lp5521_chip
*chip
, int led
, u8 curr
)
236 return lp5521_write(chip
->client
,
237 LP5521_REG_LED_CURRENT_BASE
+ chip
->leds
[led
].chan_nr
,
241 static int lp5521_post_init_device(struct lp55xx_chip
*chip
)
247 * Make sure that the chip is reset by reading back the r channel
248 * current reg. This is dummy read is required on some platforms -
249 * otherwise further access to the R G B channels in the
250 * LP5521_REG_ENABLE register will not have any effect - strange!
252 ret
= lp55xx_read(chip
, LP5521_REG_R_CURRENT
, &val
);
254 dev_err(&chip
->cl
->dev
, "error in resetting chip\n");
257 if (val
!= LP5521_REG_R_CURR_DEFAULT
) {
258 dev_err(&chip
->cl
->dev
,
259 "unexpected data in register (expected 0x%x got 0x%x)\n",
260 LP5521_REG_R_CURR_DEFAULT
, val
);
264 usleep_range(10000, 20000);
266 /* Set all PWMs to direct control mode */
267 ret
= lp55xx_write(chip
, LP5521_REG_OP_MODE
, LP5521_CMD_DIRECT
);
269 val
= chip
->pdata
->update_config
?
270 : (LP5521_PWRSAVE_EN
| LP5521_CP_MODE_AUTO
| LP5521_R_TO_BATT
);
271 ret
= lp55xx_write(chip
, LP5521_REG_CONFIG
, val
);
275 /* Initialize all channels PWM to zero -> leds off */
276 lp55xx_write(chip
, LP5521_REG_R_PWM
, 0);
277 lp55xx_write(chip
, LP5521_REG_G_PWM
, 0);
278 lp55xx_write(chip
, LP5521_REG_B_PWM
, 0);
280 /* Set engines are set to run state when OP_MODE enables engines */
281 ret
= lp55xx_write(chip
, LP5521_REG_ENABLE
, LP5521_ENABLE_RUN_PROGRAM
);
285 lp5521_wait_enable_done();
290 static int lp5521_run_selftest(struct lp5521_chip
*chip
, char *buf
)
295 ret
= lp5521_read(chip
->client
, LP5521_REG_STATUS
, &status
);
299 /* Check that ext clock is really in use if requested */
300 if (chip
->pdata
&& chip
->pdata
->clock_mode
== LP5521_CLOCK_EXT
)
301 if ((status
& LP5521_EXT_CLK_USED
) == 0)
306 static void lp5521_set_brightness(struct led_classdev
*cdev
,
307 enum led_brightness brightness
)
309 struct lp5521_led
*led
= cdev_to_led(cdev
);
310 led
->brightness
= (u8
)brightness
;
311 schedule_work(&led
->brightness_work
);
314 static void lp5521_led_brightness_work(struct work_struct
*work
)
316 struct lp5521_led
*led
= container_of(work
,
319 struct lp5521_chip
*chip
= led_to_lp5521(led
);
320 struct i2c_client
*client
= chip
->client
;
322 mutex_lock(&chip
->lock
);
323 lp5521_write(client
, LP5521_REG_LED_PWM_BASE
+ led
->chan_nr
,
325 mutex_unlock(&chip
->lock
);
328 /* Set engine mode and create appropriate sysfs attributes, if required. */
329 static int lp5521_set_mode(struct lp5521_engine
*engine
, u8 mode
)
333 /* if in that mode already do nothing, except for run */
334 if (mode
== engine
->mode
&& mode
!= LP5521_CMD_RUN
)
337 if (mode
== LP5521_CMD_RUN
) {
338 ret
= lp5521_set_engine_mode(engine
, LP5521_CMD_RUN
);
339 } else if (mode
== LP5521_CMD_LOAD
) {
340 lp5521_set_engine_mode(engine
, LP5521_CMD_DISABLED
);
341 lp5521_set_engine_mode(engine
, LP5521_CMD_LOAD
);
342 } else if (mode
== LP5521_CMD_DISABLED
) {
343 lp5521_set_engine_mode(engine
, LP5521_CMD_DISABLED
);
351 static int lp5521_do_store_load(struct lp5521_engine
*engine
,
352 const char *buf
, size_t len
)
354 struct lp5521_chip
*chip
= engine_to_lp5521(engine
);
355 struct i2c_client
*client
= chip
->client
;
356 int ret
, nrchars
, offset
= 0, i
= 0;
359 u8 pattern
[LP5521_PROGRAM_LENGTH
] = {0};
361 while ((offset
< len
- 1) && (i
< LP5521_PROGRAM_LENGTH
)) {
362 /* separate sscanfs because length is working only for %s */
363 ret
= sscanf(buf
+ offset
, "%2s%n ", c
, &nrchars
);
366 ret
= sscanf(c
, "%2x", &cmd
);
369 pattern
[i
] = (u8
)cmd
;
375 /* Each instruction is 16bit long. Check that length is even */
379 mutex_lock(&chip
->lock
);
380 if (engine
->mode
== LP5521_CMD_LOAD
)
381 ret
= lp5521_load_program(engine
, pattern
);
384 mutex_unlock(&chip
->lock
);
387 dev_err(&client
->dev
, "failed loading pattern\n");
393 dev_err(&client
->dev
, "wrong pattern format\n");
397 static ssize_t
store_engine_load(struct device
*dev
,
398 struct device_attribute
*attr
,
399 const char *buf
, size_t len
, int nr
)
401 struct i2c_client
*client
= to_i2c_client(dev
);
402 struct lp5521_chip
*chip
= i2c_get_clientdata(client
);
403 return lp5521_do_store_load(&chip
->engines
[nr
- 1], buf
, len
);
406 #define store_load(nr) \
407 static ssize_t store_engine##nr##_load(struct device *dev, \
408 struct device_attribute *attr, \
409 const char *buf, size_t len) \
411 return store_engine_load(dev, attr, buf, len, nr); \
417 static ssize_t
show_engine_mode(struct device
*dev
,
418 struct device_attribute
*attr
,
421 struct i2c_client
*client
= to_i2c_client(dev
);
422 struct lp5521_chip
*chip
= i2c_get_clientdata(client
);
423 switch (chip
->engines
[nr
- 1].mode
) {
425 return sprintf(buf
, "run\n");
426 case LP5521_CMD_LOAD
:
427 return sprintf(buf
, "load\n");
428 case LP5521_CMD_DISABLED
:
429 return sprintf(buf
, "disabled\n");
431 return sprintf(buf
, "disabled\n");
435 #define show_mode(nr) \
436 static ssize_t show_engine##nr##_mode(struct device *dev, \
437 struct device_attribute *attr, \
440 return show_engine_mode(dev, attr, buf, nr); \
446 static ssize_t
store_engine_mode(struct device
*dev
,
447 struct device_attribute
*attr
,
448 const char *buf
, size_t len
, int nr
)
450 struct i2c_client
*client
= to_i2c_client(dev
);
451 struct lp5521_chip
*chip
= i2c_get_clientdata(client
);
452 struct lp5521_engine
*engine
= &chip
->engines
[nr
- 1];
453 mutex_lock(&chip
->lock
);
455 if (!strncmp(buf
, "run", 3))
456 lp5521_set_mode(engine
, LP5521_CMD_RUN
);
457 else if (!strncmp(buf
, "load", 4))
458 lp5521_set_mode(engine
, LP5521_CMD_LOAD
);
459 else if (!strncmp(buf
, "disabled", 8))
460 lp5521_set_mode(engine
, LP5521_CMD_DISABLED
);
462 mutex_unlock(&chip
->lock
);
466 #define store_mode(nr) \
467 static ssize_t store_engine##nr##_mode(struct device *dev, \
468 struct device_attribute *attr, \
469 const char *buf, size_t len) \
471 return store_engine_mode(dev, attr, buf, len, nr); \
477 static ssize_t
show_max_current(struct device
*dev
,
478 struct device_attribute
*attr
,
481 struct led_classdev
*led_cdev
= dev_get_drvdata(dev
);
482 struct lp5521_led
*led
= cdev_to_led(led_cdev
);
484 return sprintf(buf
, "%d\n", led
->max_current
);
487 static ssize_t
show_current(struct device
*dev
,
488 struct device_attribute
*attr
,
491 struct led_classdev
*led_cdev
= dev_get_drvdata(dev
);
492 struct lp5521_led
*led
= cdev_to_led(led_cdev
);
494 return sprintf(buf
, "%d\n", led
->led_current
);
497 static ssize_t
store_current(struct device
*dev
,
498 struct device_attribute
*attr
,
499 const char *buf
, size_t len
)
501 struct led_classdev
*led_cdev
= dev_get_drvdata(dev
);
502 struct lp5521_led
*led
= cdev_to_led(led_cdev
);
503 struct lp5521_chip
*chip
= led_to_lp5521(led
);
507 if (kstrtoul(buf
, 0, &curr
))
510 if (curr
> led
->max_current
)
513 mutex_lock(&chip
->lock
);
514 ret
= lp5521_set_led_current(chip
, led
->id
, curr
);
515 mutex_unlock(&chip
->lock
);
520 led
->led_current
= (u8
)curr
;
525 static ssize_t
lp5521_selftest(struct device
*dev
,
526 struct device_attribute
*attr
,
529 struct i2c_client
*client
= to_i2c_client(dev
);
530 struct lp5521_chip
*chip
= i2c_get_clientdata(client
);
533 mutex_lock(&chip
->lock
);
534 ret
= lp5521_run_selftest(chip
, buf
);
535 mutex_unlock(&chip
->lock
);
536 return sprintf(buf
, "%s\n", ret
? "FAIL" : "OK");
539 static void lp5521_clear_program_memory(struct i2c_client
*cl
)
543 LP5521_REG_R_PROG_MEM
,
544 LP5521_REG_G_PROG_MEM
,
545 LP5521_REG_B_PROG_MEM
,
548 for (i
= 0; i
< ARRAY_SIZE(rgb_mem
); i
++) {
549 lp5521_write(cl
, rgb_mem
[i
], 0);
550 lp5521_write(cl
, rgb_mem
[i
] + 1, 0);
554 static void lp5521_write_program_memory(struct i2c_client
*cl
,
555 u8 base
, u8
*rgb
, int size
)
559 if (!rgb
|| size
<= 0)
562 for (i
= 0; i
< size
; i
++)
563 lp5521_write(cl
, base
+ i
, *(rgb
+ i
));
565 lp5521_write(cl
, base
+ i
, 0);
566 lp5521_write(cl
, base
+ i
+ 1, 0);
569 static inline struct lp5521_led_pattern
*lp5521_get_pattern
570 (struct lp5521_chip
*chip
, u8 offset
)
572 struct lp5521_led_pattern
*ptn
;
573 ptn
= chip
->pdata
->patterns
+ (offset
- 1);
577 static void lp5521_run_led_pattern(int mode
, struct lp5521_chip
*chip
)
579 struct lp5521_led_pattern
*ptn
;
580 struct i2c_client
*cl
= chip
->client
;
581 int num_patterns
= chip
->pdata
->num_patterns
;
583 if (mode
> num_patterns
|| !(chip
->pdata
->patterns
))
586 if (mode
== PATTERN_OFF
) {
587 lp5521_write(cl
, LP5521_REG_ENABLE
, LP5521_ENABLE_DEFAULT
);
588 usleep_range(1000, 2000);
589 lp5521_write(cl
, LP5521_REG_OP_MODE
, LP5521_CMD_DIRECT
);
591 ptn
= lp5521_get_pattern(chip
, mode
);
595 lp5521_write(cl
, LP5521_REG_OP_MODE
, LP5521_CMD_LOAD
);
596 usleep_range(1000, 2000);
598 lp5521_clear_program_memory(cl
);
600 lp5521_write_program_memory(cl
, LP5521_REG_R_PROG_MEM
,
601 ptn
->r
, ptn
->size_r
);
602 lp5521_write_program_memory(cl
, LP5521_REG_G_PROG_MEM
,
603 ptn
->g
, ptn
->size_g
);
604 lp5521_write_program_memory(cl
, LP5521_REG_B_PROG_MEM
,
605 ptn
->b
, ptn
->size_b
);
607 lp5521_write(cl
, LP5521_REG_OP_MODE
, LP5521_CMD_RUN
);
608 usleep_range(1000, 2000);
609 lp5521_write(cl
, LP5521_REG_ENABLE
, LP5521_ENABLE_RUN_PROGRAM
);
613 static ssize_t
store_led_pattern(struct device
*dev
,
614 struct device_attribute
*attr
,
615 const char *buf
, size_t len
)
617 struct lp5521_chip
*chip
= i2c_get_clientdata(to_i2c_client(dev
));
621 ret
= kstrtoul(buf
, 16, &val
);
625 lp5521_run_led_pattern(val
, chip
);
630 /* led class device attributes */
631 static DEVICE_ATTR(led_current
, S_IRUGO
| S_IWUSR
, show_current
, store_current
);
632 static DEVICE_ATTR(max_current
, S_IRUGO
, show_max_current
, NULL
);
634 static struct attribute
*lp5521_led_attributes
[] = {
635 &dev_attr_led_current
.attr
,
636 &dev_attr_max_current
.attr
,
640 static struct attribute_group lp5521_led_attribute_group
= {
641 .attrs
= lp5521_led_attributes
644 /* device attributes */
645 static DEVICE_ATTR(engine1_mode
, S_IRUGO
| S_IWUSR
,
646 show_engine1_mode
, store_engine1_mode
);
647 static DEVICE_ATTR(engine2_mode
, S_IRUGO
| S_IWUSR
,
648 show_engine2_mode
, store_engine2_mode
);
649 static DEVICE_ATTR(engine3_mode
, S_IRUGO
| S_IWUSR
,
650 show_engine3_mode
, store_engine3_mode
);
651 static DEVICE_ATTR(engine1_load
, S_IWUSR
, NULL
, store_engine1_load
);
652 static DEVICE_ATTR(engine2_load
, S_IWUSR
, NULL
, store_engine2_load
);
653 static DEVICE_ATTR(engine3_load
, S_IWUSR
, NULL
, store_engine3_load
);
654 static DEVICE_ATTR(selftest
, S_IRUGO
, lp5521_selftest
, NULL
);
655 static DEVICE_ATTR(led_pattern
, S_IWUSR
, NULL
, store_led_pattern
);
657 static struct attribute
*lp5521_attributes
[] = {
658 &dev_attr_engine1_mode
.attr
,
659 &dev_attr_engine2_mode
.attr
,
660 &dev_attr_engine3_mode
.attr
,
661 &dev_attr_selftest
.attr
,
662 &dev_attr_engine1_load
.attr
,
663 &dev_attr_engine2_load
.attr
,
664 &dev_attr_engine3_load
.attr
,
665 &dev_attr_led_pattern
.attr
,
669 static const struct attribute_group lp5521_group
= {
670 .attrs
= lp5521_attributes
,
673 static int lp5521_register_sysfs(struct i2c_client
*client
)
675 struct device
*dev
= &client
->dev
;
676 return sysfs_create_group(&dev
->kobj
, &lp5521_group
);
679 static void lp5521_unregister_sysfs(struct i2c_client
*client
)
681 struct lp5521_chip
*chip
= i2c_get_clientdata(client
);
682 struct device
*dev
= &client
->dev
;
685 sysfs_remove_group(&dev
->kobj
, &lp5521_group
);
687 for (i
= 0; i
< chip
->num_leds
; i
++)
688 sysfs_remove_group(&chip
->leds
[i
].cdev
.dev
->kobj
,
689 &lp5521_led_attribute_group
);
692 static void lp5521_deinit_device(struct lp5521_chip
*chip
)
694 struct lp5521_platform_data
*pdata
= chip
->pdata
;
698 if (pdata
->release_resources
)
699 pdata
->release_resources();
702 static int lp5521_init_led(struct lp5521_led
*led
,
703 struct i2c_client
*client
,
704 int chan
, struct lp5521_platform_data
*pdata
)
706 struct device
*dev
= &client
->dev
;
710 if (chan
>= LP5521_MAX_LEDS
)
713 if (pdata
->led_config
[chan
].led_current
== 0)
716 led
->led_current
= pdata
->led_config
[chan
].led_current
;
717 led
->max_current
= pdata
->led_config
[chan
].max_current
;
718 led
->chan_nr
= pdata
->led_config
[chan
].chan_nr
;
720 if (led
->chan_nr
>= LP5521_MAX_LEDS
) {
721 dev_err(dev
, "Use channel numbers between 0 and %d\n",
722 LP5521_MAX_LEDS
- 1);
726 led
->cdev
.brightness_set
= lp5521_set_brightness
;
727 if (pdata
->led_config
[chan
].name
) {
728 led
->cdev
.name
= pdata
->led_config
[chan
].name
;
730 snprintf(name
, sizeof(name
), "%s:channel%d",
731 pdata
->label
?: client
->name
, chan
);
732 led
->cdev
.name
= name
;
735 res
= led_classdev_register(dev
, &led
->cdev
);
737 dev_err(dev
, "couldn't register led on channel %d\n", chan
);
741 res
= sysfs_create_group(&led
->cdev
.dev
->kobj
,
742 &lp5521_led_attribute_group
);
744 dev_err(dev
, "couldn't register current attribute\n");
745 led_classdev_unregister(&led
->cdev
);
751 static int lp5521_register_leds(struct lp5521_chip
*chip
)
753 struct lp5521_platform_data
*pdata
= chip
->pdata
;
754 struct i2c_client
*client
= chip
->client
;
759 /* Initialize leds */
760 chip
->num_channels
= pdata
->num_channels
;
763 for (i
= 0; i
< pdata
->num_channels
; i
++) {
764 /* Do not initialize channels that are not connected */
765 if (pdata
->led_config
[i
].led_current
== 0)
768 ret
= lp5521_init_led(&chip
->leds
[led
], client
, i
, pdata
);
770 dev_err(&client
->dev
, "error initializing leds\n");
775 chip
->leds
[led
].id
= led
;
776 /* Set initial LED current */
777 lp5521_set_led_current(chip
, led
,
778 chip
->leds
[led
].led_current
);
780 INIT_WORK(&(chip
->leds
[led
].brightness_work
),
781 lp5521_led_brightness_work
);
789 static void lp5521_unregister_leds(struct lp5521_chip
*chip
)
793 for (i
= 0; i
< chip
->num_leds
; i
++) {
794 led_classdev_unregister(&chip
->leds
[i
].cdev
);
795 cancel_work_sync(&chip
->leds
[i
].brightness_work
);
799 /* Chip specific configurations */
800 static struct lp55xx_device_config lp5521_cfg
= {
802 .addr
= LP5521_REG_RESET
,
806 .addr
= LP5521_REG_ENABLE
,
807 .val
= LP5521_ENABLE_DEFAULT
,
809 .post_init_device
= lp5521_post_init_device
,
812 static int lp5521_probe(struct i2c_client
*client
,
813 const struct i2c_device_id
*id
)
815 struct lp5521_chip
*old_chip
= NULL
;
817 struct lp55xx_chip
*chip
;
818 struct lp55xx_led
*led
;
819 struct lp55xx_platform_data
*pdata
= client
->dev
.platform_data
;
822 dev_err(&client
->dev
, "no platform data\n");
826 chip
= devm_kzalloc(&client
->dev
, sizeof(*chip
), GFP_KERNEL
);
830 led
= devm_kzalloc(&client
->dev
,
831 sizeof(*led
) * pdata
->num_channels
, GFP_KERNEL
);
837 chip
->cfg
= &lp5521_cfg
;
839 mutex_init(&chip
->lock
);
841 i2c_set_clientdata(client
, led
);
843 ret
= lp55xx_init_device(chip
);
847 dev_info(&client
->dev
, "%s programmable led chip found\n", id
->name
);
849 ret
= lp5521_register_leds(old_chip
);
853 ret
= lp5521_register_sysfs(client
);
855 dev_err(&client
->dev
, "registering sysfs failed\n");
860 lp5521_unregister_leds(old_chip
);
861 lp5521_deinit_device(old_chip
);
866 static int lp5521_remove(struct i2c_client
*client
)
868 struct lp5521_chip
*old_chip
= i2c_get_clientdata(client
);
870 lp5521_run_led_pattern(PATTERN_OFF
, old_chip
);
871 lp5521_unregister_sysfs(client
);
873 lp5521_unregister_leds(old_chip
);
875 lp5521_deinit_device(old_chip
);
879 static const struct i2c_device_id lp5521_id
[] = {
880 { "lp5521", 0 }, /* Three channel chip */
883 MODULE_DEVICE_TABLE(i2c
, lp5521_id
);
885 static struct i2c_driver lp5521_driver
= {
889 .probe
= lp5521_probe
,
890 .remove
= lp5521_remove
,
891 .id_table
= lp5521_id
,
894 module_i2c_driver(lp5521_driver
);
896 MODULE_AUTHOR("Mathias Nyman, Yuri Zaporozhets, Samu Onkalo");
897 MODULE_DESCRIPTION("LP5521 LED engine");
898 MODULE_LICENSE("GPL v2");