2 * LP5521 LED chip driver.
4 * Copyright (C) 2010 Nokia Corporation
5 * Copyright (C) 2012 Texas Instruments
7 * Contact: Samu Onkalo <samu.p.onkalo@nokia.com>
8 * Milo(Woogyom) Kim <milo.kim@ti.com>
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * version 2 as published by the Free Software Foundation.
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
25 #include <linux/delay.h>
26 #include <linux/firmware.h>
27 #include <linux/i2c.h>
28 #include <linux/init.h>
29 #include <linux/leds.h>
30 #include <linux/module.h>
31 #include <linux/mutex.h>
32 #include <linux/platform_data/leds-lp55xx.h>
33 #include <linux/slab.h>
35 #include "leds-lp55xx-common.h"
37 #define LP5521_PROGRAM_LENGTH 32
38 #define LP5521_MAX_LEDS 3
39 #define LP5521_CMD_DIRECT 0x3F
42 #define LP5521_REG_ENABLE 0x00
43 #define LP5521_REG_OP_MODE 0x01
44 #define LP5521_REG_R_PWM 0x02
45 #define LP5521_REG_G_PWM 0x03
46 #define LP5521_REG_B_PWM 0x04
47 #define LP5521_REG_R_CURRENT 0x05
48 #define LP5521_REG_G_CURRENT 0x06
49 #define LP5521_REG_B_CURRENT 0x07
50 #define LP5521_REG_CONFIG 0x08
51 #define LP5521_REG_STATUS 0x0C
52 #define LP5521_REG_RESET 0x0D
53 #define LP5521_REG_R_PROG_MEM 0x10
54 #define LP5521_REG_G_PROG_MEM 0x30
55 #define LP5521_REG_B_PROG_MEM 0x50
57 /* Base register to set LED current */
58 #define LP5521_REG_LED_CURRENT_BASE LP5521_REG_R_CURRENT
59 /* Base register to set the brightness */
60 #define LP5521_REG_LED_PWM_BASE LP5521_REG_R_PWM
62 /* Bits in ENABLE register */
63 #define LP5521_MASTER_ENABLE 0x40 /* Chip master enable */
64 #define LP5521_LOGARITHMIC_PWM 0x80 /* Logarithmic PWM adjustment */
65 #define LP5521_EXEC_RUN 0x2A
66 #define LP5521_ENABLE_DEFAULT \
67 (LP5521_MASTER_ENABLE | LP5521_LOGARITHMIC_PWM)
68 #define LP5521_ENABLE_RUN_PROGRAM \
69 (LP5521_ENABLE_DEFAULT | LP5521_EXEC_RUN)
72 #define LP5521_EXT_CLK_USED 0x08
74 /* default R channel current register value */
75 #define LP5521_REG_R_CURR_DEFAULT 0xAF
77 /* Reset register value */
78 #define LP5521_RESET 0xFF
80 /* Program Memory Operations */
81 #define LP5521_MODE_R_M 0x30 /* Operation Mode Register */
82 #define LP5521_MODE_G_M 0x0C
83 #define LP5521_MODE_B_M 0x03
84 #define LP5521_LOAD_R 0x10
85 #define LP5521_LOAD_G 0x04
86 #define LP5521_LOAD_B 0x01
88 #define LP5521_R_IS_LOADING(mode) \
89 ((mode & LP5521_MODE_R_M) == LP5521_LOAD_R)
90 #define LP5521_G_IS_LOADING(mode) \
91 ((mode & LP5521_MODE_G_M) == LP5521_LOAD_G)
92 #define LP5521_B_IS_LOADING(mode) \
93 ((mode & LP5521_MODE_B_M) == LP5521_LOAD_B)
95 #define LP5521_EXEC_R_M 0x30 /* Enable Register */
96 #define LP5521_EXEC_G_M 0x0C
97 #define LP5521_EXEC_B_M 0x03
98 #define LP5521_EXEC_M 0x3F
99 #define LP5521_RUN_R 0x20
100 #define LP5521_RUN_G 0x08
101 #define LP5521_RUN_B 0x02
103 static inline void lp5521_wait_opmode_done(void)
105 /* operation mode change needs to be longer than 153 us */
106 usleep_range(200, 300);
109 static inline void lp5521_wait_enable_done(void)
111 /* it takes more 488 us to update ENABLE register */
112 usleep_range(500, 600);
115 static void lp5521_set_led_current(struct lp55xx_led
*led
, u8 led_current
)
117 led
->led_current
= led_current
;
118 lp55xx_write(led
->chip
, LP5521_REG_LED_CURRENT_BASE
+ led
->chan_nr
,
122 static void lp5521_load_engine(struct lp55xx_chip
*chip
)
124 enum lp55xx_engine_index idx
= chip
->engine_idx
;
126 [LP55XX_ENGINE_1
] = LP5521_MODE_R_M
,
127 [LP55XX_ENGINE_2
] = LP5521_MODE_G_M
,
128 [LP55XX_ENGINE_3
] = LP5521_MODE_B_M
,
132 [LP55XX_ENGINE_1
] = LP5521_LOAD_R
,
133 [LP55XX_ENGINE_2
] = LP5521_LOAD_G
,
134 [LP55XX_ENGINE_3
] = LP5521_LOAD_B
,
137 lp55xx_update_bits(chip
, LP5521_REG_OP_MODE
, mask
[idx
], val
[idx
]);
139 lp5521_wait_opmode_done();
142 static void lp5521_stop_engine(struct lp55xx_chip
*chip
)
144 lp55xx_write(chip
, LP5521_REG_OP_MODE
, 0);
145 lp5521_wait_opmode_done();
148 static void lp5521_run_engine(struct lp55xx_chip
*chip
, bool start
)
156 lp5521_stop_engine(chip
);
157 lp55xx_write(chip
, LP5521_REG_OP_MODE
, LP5521_CMD_DIRECT
);
158 lp5521_wait_opmode_done();
164 * operation mode and enable register should updated at the same time
167 ret
= lp55xx_read(chip
, LP5521_REG_OP_MODE
, &mode
);
171 ret
= lp55xx_read(chip
, LP5521_REG_ENABLE
, &exec
);
175 /* change operation mode to RUN only when each engine is loading */
176 if (LP5521_R_IS_LOADING(mode
)) {
177 mode
= (mode
& ~LP5521_MODE_R_M
) | LP5521_RUN_R
;
178 exec
= (exec
& ~LP5521_EXEC_R_M
) | LP5521_RUN_R
;
181 if (LP5521_G_IS_LOADING(mode
)) {
182 mode
= (mode
& ~LP5521_MODE_G_M
) | LP5521_RUN_G
;
183 exec
= (exec
& ~LP5521_EXEC_G_M
) | LP5521_RUN_G
;
186 if (LP5521_B_IS_LOADING(mode
)) {
187 mode
= (mode
& ~LP5521_MODE_B_M
) | LP5521_RUN_B
;
188 exec
= (exec
& ~LP5521_EXEC_B_M
) | LP5521_RUN_B
;
191 lp55xx_write(chip
, LP5521_REG_OP_MODE
, mode
);
192 lp5521_wait_opmode_done();
194 lp55xx_update_bits(chip
, LP5521_REG_ENABLE
, LP5521_EXEC_M
, exec
);
195 lp5521_wait_enable_done();
198 static int lp5521_update_program_memory(struct lp55xx_chip
*chip
,
199 const u8
*data
, size_t size
)
201 enum lp55xx_engine_index idx
= chip
->engine_idx
;
202 u8 pattern
[LP5521_PROGRAM_LENGTH
] = {0};
204 [LP55XX_ENGINE_1
] = LP5521_REG_R_PROG_MEM
,
205 [LP55XX_ENGINE_2
] = LP5521_REG_G_PROG_MEM
,
206 [LP55XX_ENGINE_3
] = LP5521_REG_B_PROG_MEM
,
216 /* clear program memory before updating */
217 for (i
= 0; i
< LP5521_PROGRAM_LENGTH
; i
++)
218 lp55xx_write(chip
, addr
[idx
] + i
, 0);
221 while ((offset
< size
- 1) && (i
< LP5521_PROGRAM_LENGTH
)) {
222 /* separate sscanfs because length is working only for %s */
223 ret
= sscanf(data
+ offset
, "%2s%n ", c
, &nrchars
);
227 ret
= sscanf(c
, "%2x", &cmd
);
231 pattern
[i
] = (u8
)cmd
;
236 /* Each instruction is 16bit long. Check that length is even */
241 for (i
= 0; i
< program_size
; i
++)
242 lp55xx_write(chip
, addr
[idx
] + i
, pattern
[i
]);
247 dev_err(&chip
->cl
->dev
, "wrong pattern format\n");
251 static void lp5521_firmware_loaded(struct lp55xx_chip
*chip
)
253 const struct firmware
*fw
= chip
->fw
;
255 if (fw
->size
> LP5521_PROGRAM_LENGTH
) {
256 dev_err(&chip
->cl
->dev
, "firmware data size overflow: %zu\n",
262 * Program momery sequence
263 * 1) set engine mode to "LOAD"
264 * 2) write firmware data into program memory
267 lp5521_load_engine(chip
);
268 lp5521_update_program_memory(chip
, fw
->data
, fw
->size
);
271 static int lp5521_post_init_device(struct lp55xx_chip
*chip
)
277 * Make sure that the chip is reset by reading back the r channel
278 * current reg. This is dummy read is required on some platforms -
279 * otherwise further access to the R G B channels in the
280 * LP5521_REG_ENABLE register will not have any effect - strange!
282 ret
= lp55xx_read(chip
, LP5521_REG_R_CURRENT
, &val
);
284 dev_err(&chip
->cl
->dev
, "error in resetting chip\n");
287 if (val
!= LP5521_REG_R_CURR_DEFAULT
) {
288 dev_err(&chip
->cl
->dev
,
289 "unexpected data in register (expected 0x%x got 0x%x)\n",
290 LP5521_REG_R_CURR_DEFAULT
, val
);
294 usleep_range(10000, 20000);
296 /* Set all PWMs to direct control mode */
297 ret
= lp55xx_write(chip
, LP5521_REG_OP_MODE
, LP5521_CMD_DIRECT
);
299 val
= chip
->pdata
->update_config
?
300 : (LP5521_PWRSAVE_EN
| LP5521_CP_MODE_AUTO
| LP5521_R_TO_BATT
);
301 ret
= lp55xx_write(chip
, LP5521_REG_CONFIG
, val
);
305 /* Initialize all channels PWM to zero -> leds off */
306 lp55xx_write(chip
, LP5521_REG_R_PWM
, 0);
307 lp55xx_write(chip
, LP5521_REG_G_PWM
, 0);
308 lp55xx_write(chip
, LP5521_REG_B_PWM
, 0);
310 /* Set engines are set to run state when OP_MODE enables engines */
311 ret
= lp55xx_write(chip
, LP5521_REG_ENABLE
, LP5521_ENABLE_RUN_PROGRAM
);
315 lp5521_wait_enable_done();
320 static int lp5521_run_selftest(struct lp55xx_chip
*chip
, char *buf
)
322 struct lp55xx_platform_data
*pdata
= chip
->pdata
;
326 ret
= lp55xx_read(chip
, LP5521_REG_STATUS
, &status
);
330 if (pdata
->clock_mode
!= LP55XX_CLOCK_EXT
)
333 /* Check that ext clock is really in use if requested */
334 if ((status
& LP5521_EXT_CLK_USED
) == 0)
340 static void lp5521_led_brightness_work(struct work_struct
*work
)
342 struct lp55xx_led
*led
= container_of(work
, struct lp55xx_led
,
344 struct lp55xx_chip
*chip
= led
->chip
;
346 mutex_lock(&chip
->lock
);
347 lp55xx_write(chip
, LP5521_REG_LED_PWM_BASE
+ led
->chan_nr
,
349 mutex_unlock(&chip
->lock
);
352 static ssize_t
lp5521_selftest(struct device
*dev
,
353 struct device_attribute
*attr
,
356 struct lp55xx_led
*led
= i2c_get_clientdata(to_i2c_client(dev
));
357 struct lp55xx_chip
*chip
= led
->chip
;
360 mutex_lock(&chip
->lock
);
361 ret
= lp5521_run_selftest(chip
, buf
);
362 mutex_unlock(&chip
->lock
);
363 return sprintf(buf
, "%s\n", ret
? "FAIL" : "OK");
366 /* device attributes */
367 static DEVICE_ATTR(selftest
, S_IRUGO
, lp5521_selftest
, NULL
);
369 static struct attribute
*lp5521_attributes
[] = {
370 &dev_attr_selftest
.attr
,
374 static const struct attribute_group lp5521_group
= {
375 .attrs
= lp5521_attributes
,
378 /* Chip specific configurations */
379 static struct lp55xx_device_config lp5521_cfg
= {
381 .addr
= LP5521_REG_RESET
,
385 .addr
= LP5521_REG_ENABLE
,
386 .val
= LP5521_ENABLE_DEFAULT
,
388 .max_channel
= LP5521_MAX_LEDS
,
389 .post_init_device
= lp5521_post_init_device
,
390 .brightness_work_fn
= lp5521_led_brightness_work
,
391 .set_led_current
= lp5521_set_led_current
,
392 .firmware_cb
= lp5521_firmware_loaded
,
393 .run_engine
= lp5521_run_engine
,
394 .dev_attr_group
= &lp5521_group
,
397 static int lp5521_probe(struct i2c_client
*client
,
398 const struct i2c_device_id
*id
)
401 struct lp55xx_chip
*chip
;
402 struct lp55xx_led
*led
;
403 struct lp55xx_platform_data
*pdata
= client
->dev
.platform_data
;
406 dev_err(&client
->dev
, "no platform data\n");
410 chip
= devm_kzalloc(&client
->dev
, sizeof(*chip
), GFP_KERNEL
);
414 led
= devm_kzalloc(&client
->dev
,
415 sizeof(*led
) * pdata
->num_channels
, GFP_KERNEL
);
421 chip
->cfg
= &lp5521_cfg
;
423 mutex_init(&chip
->lock
);
425 i2c_set_clientdata(client
, led
);
427 ret
= lp55xx_init_device(chip
);
431 dev_info(&client
->dev
, "%s programmable led chip found\n", id
->name
);
433 ret
= lp55xx_register_leds(led
, chip
);
435 goto err_register_leds
;
437 ret
= lp55xx_register_sysfs(chip
);
439 dev_err(&client
->dev
, "registering sysfs failed\n");
440 goto err_register_sysfs
;
446 lp55xx_unregister_leds(led
, chip
);
448 lp55xx_deinit_device(chip
);
453 static int lp5521_remove(struct i2c_client
*client
)
455 struct lp55xx_led
*led
= i2c_get_clientdata(client
);
456 struct lp55xx_chip
*chip
= led
->chip
;
458 lp5521_stop_engine(chip
);
459 lp55xx_unregister_sysfs(chip
);
460 lp55xx_unregister_leds(led
, chip
);
461 lp55xx_deinit_device(chip
);
466 static const struct i2c_device_id lp5521_id
[] = {
467 { "lp5521", 0 }, /* Three channel chip */
470 MODULE_DEVICE_TABLE(i2c
, lp5521_id
);
472 static struct i2c_driver lp5521_driver
= {
476 .probe
= lp5521_probe
,
477 .remove
= lp5521_remove
,
478 .id_table
= lp5521_id
,
481 module_i2c_driver(lp5521_driver
);
483 MODULE_AUTHOR("Mathias Nyman, Yuri Zaporozhets, Samu Onkalo");
484 MODULE_AUTHOR("Milo Kim <milo.kim@ti.com>");
485 MODULE_DESCRIPTION("LP5521 LED engine");
486 MODULE_LICENSE("GPL v2");