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_PWM_HF 0x40 /* PWM: 0 = 256Hz, 1 = 558Hz */
73 #define LP5521_PWRSAVE_EN 0x20 /* 1 = Power save mode */
74 #define LP5521_CP_MODE_OFF 0 /* Charge pump (CP) off */
75 #define LP5521_CP_MODE_BYPASS 8 /* CP forced to bypass mode */
76 #define LP5521_CP_MODE_1X5 0x10 /* CP forced to 1.5x mode */
77 #define LP5521_CP_MODE_AUTO 0x18 /* Automatic mode selection */
78 #define LP5521_R_TO_BATT 0x04 /* R out: 0 = CP, 1 = Vbat */
79 #define LP5521_CLK_INT 0x01 /* Internal clock */
80 #define LP5521_DEFAULT_CFG \
81 (LP5521_PWM_HF | LP5521_PWRSAVE_EN | LP5521_CP_MODE_AUTO)
84 #define LP5521_EXT_CLK_USED 0x08
86 /* default R channel current register value */
87 #define LP5521_REG_R_CURR_DEFAULT 0xAF
89 /* Reset register value */
90 #define LP5521_RESET 0xFF
92 /* Program Memory Operations */
93 #define LP5521_MODE_R_M 0x30 /* Operation Mode Register */
94 #define LP5521_MODE_G_M 0x0C
95 #define LP5521_MODE_B_M 0x03
96 #define LP5521_LOAD_R 0x10
97 #define LP5521_LOAD_G 0x04
98 #define LP5521_LOAD_B 0x01
100 #define LP5521_R_IS_LOADING(mode) \
101 ((mode & LP5521_MODE_R_M) == LP5521_LOAD_R)
102 #define LP5521_G_IS_LOADING(mode) \
103 ((mode & LP5521_MODE_G_M) == LP5521_LOAD_G)
104 #define LP5521_B_IS_LOADING(mode) \
105 ((mode & LP5521_MODE_B_M) == LP5521_LOAD_B)
107 #define LP5521_EXEC_R_M 0x30 /* Enable Register */
108 #define LP5521_EXEC_G_M 0x0C
109 #define LP5521_EXEC_B_M 0x03
110 #define LP5521_EXEC_M 0x3F
111 #define LP5521_RUN_R 0x20
112 #define LP5521_RUN_G 0x08
113 #define LP5521_RUN_B 0x02
115 static inline void lp5521_wait_opmode_done(void)
117 /* operation mode change needs to be longer than 153 us */
118 usleep_range(200, 300);
121 static inline void lp5521_wait_enable_done(void)
123 /* it takes more 488 us to update ENABLE register */
124 usleep_range(500, 600);
127 static void lp5521_set_led_current(struct lp55xx_led
*led
, u8 led_current
)
129 led
->led_current
= led_current
;
130 lp55xx_write(led
->chip
, LP5521_REG_LED_CURRENT_BASE
+ led
->chan_nr
,
134 static void lp5521_load_engine(struct lp55xx_chip
*chip
)
136 enum lp55xx_engine_index idx
= chip
->engine_idx
;
138 [LP55XX_ENGINE_1
] = LP5521_MODE_R_M
,
139 [LP55XX_ENGINE_2
] = LP5521_MODE_G_M
,
140 [LP55XX_ENGINE_3
] = LP5521_MODE_B_M
,
144 [LP55XX_ENGINE_1
] = LP5521_LOAD_R
,
145 [LP55XX_ENGINE_2
] = LP5521_LOAD_G
,
146 [LP55XX_ENGINE_3
] = LP5521_LOAD_B
,
149 lp55xx_update_bits(chip
, LP5521_REG_OP_MODE
, mask
[idx
], val
[idx
]);
151 lp5521_wait_opmode_done();
154 static void lp5521_stop_engine(struct lp55xx_chip
*chip
)
156 lp55xx_write(chip
, LP5521_REG_OP_MODE
, 0);
157 lp5521_wait_opmode_done();
160 static void lp5521_run_engine(struct lp55xx_chip
*chip
, bool start
)
168 lp5521_stop_engine(chip
);
169 lp55xx_write(chip
, LP5521_REG_OP_MODE
, LP5521_CMD_DIRECT
);
170 lp5521_wait_opmode_done();
176 * operation mode and enable register should updated at the same time
179 ret
= lp55xx_read(chip
, LP5521_REG_OP_MODE
, &mode
);
183 ret
= lp55xx_read(chip
, LP5521_REG_ENABLE
, &exec
);
187 /* change operation mode to RUN only when each engine is loading */
188 if (LP5521_R_IS_LOADING(mode
)) {
189 mode
= (mode
& ~LP5521_MODE_R_M
) | LP5521_RUN_R
;
190 exec
= (exec
& ~LP5521_EXEC_R_M
) | LP5521_RUN_R
;
193 if (LP5521_G_IS_LOADING(mode
)) {
194 mode
= (mode
& ~LP5521_MODE_G_M
) | LP5521_RUN_G
;
195 exec
= (exec
& ~LP5521_EXEC_G_M
) | LP5521_RUN_G
;
198 if (LP5521_B_IS_LOADING(mode
)) {
199 mode
= (mode
& ~LP5521_MODE_B_M
) | LP5521_RUN_B
;
200 exec
= (exec
& ~LP5521_EXEC_B_M
) | LP5521_RUN_B
;
203 lp55xx_write(chip
, LP5521_REG_OP_MODE
, mode
);
204 lp5521_wait_opmode_done();
206 lp55xx_update_bits(chip
, LP5521_REG_ENABLE
, LP5521_EXEC_M
, exec
);
207 lp5521_wait_enable_done();
210 static int lp5521_update_program_memory(struct lp55xx_chip
*chip
,
211 const u8
*data
, size_t size
)
213 enum lp55xx_engine_index idx
= chip
->engine_idx
;
214 u8 pattern
[LP5521_PROGRAM_LENGTH
] = {0};
216 [LP55XX_ENGINE_1
] = LP5521_REG_R_PROG_MEM
,
217 [LP55XX_ENGINE_2
] = LP5521_REG_G_PROG_MEM
,
218 [LP55XX_ENGINE_3
] = LP5521_REG_B_PROG_MEM
,
228 /* clear program memory before updating */
229 for (i
= 0; i
< LP5521_PROGRAM_LENGTH
; i
++)
230 lp55xx_write(chip
, addr
[idx
] + i
, 0);
233 while ((offset
< size
- 1) && (i
< LP5521_PROGRAM_LENGTH
)) {
234 /* separate sscanfs because length is working only for %s */
235 ret
= sscanf(data
+ offset
, "%2s%n ", c
, &nrchars
);
239 ret
= sscanf(c
, "%2x", &cmd
);
243 pattern
[i
] = (u8
)cmd
;
248 /* Each instruction is 16bit long. Check that length is even */
253 for (i
= 0; i
< program_size
; i
++)
254 lp55xx_write(chip
, addr
[idx
] + i
, pattern
[i
]);
259 dev_err(&chip
->cl
->dev
, "wrong pattern format\n");
263 static void lp5521_firmware_loaded(struct lp55xx_chip
*chip
)
265 const struct firmware
*fw
= chip
->fw
;
267 if (fw
->size
> LP5521_PROGRAM_LENGTH
) {
268 dev_err(&chip
->cl
->dev
, "firmware data size overflow: %zu\n",
274 * Program momery sequence
275 * 1) set engine mode to "LOAD"
276 * 2) write firmware data into program memory
279 lp5521_load_engine(chip
);
280 lp5521_update_program_memory(chip
, fw
->data
, fw
->size
);
283 static int lp5521_post_init_device(struct lp55xx_chip
*chip
)
289 * Make sure that the chip is reset by reading back the r channel
290 * current reg. This is dummy read is required on some platforms -
291 * otherwise further access to the R G B channels in the
292 * LP5521_REG_ENABLE register will not have any effect - strange!
294 ret
= lp55xx_read(chip
, LP5521_REG_R_CURRENT
, &val
);
296 dev_err(&chip
->cl
->dev
, "error in resetting chip\n");
299 if (val
!= LP5521_REG_R_CURR_DEFAULT
) {
300 dev_err(&chip
->cl
->dev
,
301 "unexpected data in register (expected 0x%x got 0x%x)\n",
302 LP5521_REG_R_CURR_DEFAULT
, val
);
306 usleep_range(10000, 20000);
308 /* Set all PWMs to direct control mode */
309 ret
= lp55xx_write(chip
, LP5521_REG_OP_MODE
, LP5521_CMD_DIRECT
);
311 /* Update configuration for the clock setting */
312 val
= LP5521_DEFAULT_CFG
;
313 if (!lp55xx_is_extclk_used(chip
))
314 val
|= LP5521_CLK_INT
;
316 ret
= lp55xx_write(chip
, LP5521_REG_CONFIG
, val
);
320 /* Initialize all channels PWM to zero -> leds off */
321 lp55xx_write(chip
, LP5521_REG_R_PWM
, 0);
322 lp55xx_write(chip
, LP5521_REG_G_PWM
, 0);
323 lp55xx_write(chip
, LP5521_REG_B_PWM
, 0);
325 /* Set engines are set to run state when OP_MODE enables engines */
326 ret
= lp55xx_write(chip
, LP5521_REG_ENABLE
, LP5521_ENABLE_RUN_PROGRAM
);
330 lp5521_wait_enable_done();
335 static int lp5521_run_selftest(struct lp55xx_chip
*chip
, char *buf
)
337 struct lp55xx_platform_data
*pdata
= chip
->pdata
;
341 ret
= lp55xx_read(chip
, LP5521_REG_STATUS
, &status
);
345 if (pdata
->clock_mode
!= LP55XX_CLOCK_EXT
)
348 /* Check that ext clock is really in use if requested */
349 if ((status
& LP5521_EXT_CLK_USED
) == 0)
355 static void lp5521_led_brightness_work(struct work_struct
*work
)
357 struct lp55xx_led
*led
= container_of(work
, struct lp55xx_led
,
359 struct lp55xx_chip
*chip
= led
->chip
;
361 mutex_lock(&chip
->lock
);
362 lp55xx_write(chip
, LP5521_REG_LED_PWM_BASE
+ led
->chan_nr
,
364 mutex_unlock(&chip
->lock
);
367 static ssize_t
lp5521_selftest(struct device
*dev
,
368 struct device_attribute
*attr
,
371 struct lp55xx_led
*led
= i2c_get_clientdata(to_i2c_client(dev
));
372 struct lp55xx_chip
*chip
= led
->chip
;
375 mutex_lock(&chip
->lock
);
376 ret
= lp5521_run_selftest(chip
, buf
);
377 mutex_unlock(&chip
->lock
);
379 return scnprintf(buf
, PAGE_SIZE
, "%s\n", ret
? "FAIL" : "OK");
382 /* device attributes */
383 static DEVICE_ATTR(selftest
, S_IRUGO
, lp5521_selftest
, NULL
);
385 static struct attribute
*lp5521_attributes
[] = {
386 &dev_attr_selftest
.attr
,
390 static const struct attribute_group lp5521_group
= {
391 .attrs
= lp5521_attributes
,
394 /* Chip specific configurations */
395 static struct lp55xx_device_config lp5521_cfg
= {
397 .addr
= LP5521_REG_RESET
,
401 .addr
= LP5521_REG_ENABLE
,
402 .val
= LP5521_ENABLE_DEFAULT
,
404 .max_channel
= LP5521_MAX_LEDS
,
405 .post_init_device
= lp5521_post_init_device
,
406 .brightness_work_fn
= lp5521_led_brightness_work
,
407 .set_led_current
= lp5521_set_led_current
,
408 .firmware_cb
= lp5521_firmware_loaded
,
409 .run_engine
= lp5521_run_engine
,
410 .dev_attr_group
= &lp5521_group
,
413 static int lp5521_probe(struct i2c_client
*client
,
414 const struct i2c_device_id
*id
)
417 struct lp55xx_chip
*chip
;
418 struct lp55xx_led
*led
;
419 struct lp55xx_platform_data
*pdata
= client
->dev
.platform_data
;
422 dev_err(&client
->dev
, "no platform data\n");
426 chip
= devm_kzalloc(&client
->dev
, sizeof(*chip
), GFP_KERNEL
);
430 led
= devm_kzalloc(&client
->dev
,
431 sizeof(*led
) * pdata
->num_channels
, GFP_KERNEL
);
437 chip
->cfg
= &lp5521_cfg
;
439 mutex_init(&chip
->lock
);
441 i2c_set_clientdata(client
, led
);
443 ret
= lp55xx_init_device(chip
);
447 dev_info(&client
->dev
, "%s programmable led chip found\n", id
->name
);
449 ret
= lp55xx_register_leds(led
, chip
);
451 goto err_register_leds
;
453 ret
= lp55xx_register_sysfs(chip
);
455 dev_err(&client
->dev
, "registering sysfs failed\n");
456 goto err_register_sysfs
;
462 lp55xx_unregister_leds(led
, chip
);
464 lp55xx_deinit_device(chip
);
469 static int lp5521_remove(struct i2c_client
*client
)
471 struct lp55xx_led
*led
= i2c_get_clientdata(client
);
472 struct lp55xx_chip
*chip
= led
->chip
;
474 lp5521_stop_engine(chip
);
475 lp55xx_unregister_sysfs(chip
);
476 lp55xx_unregister_leds(led
, chip
);
477 lp55xx_deinit_device(chip
);
482 static const struct i2c_device_id lp5521_id
[] = {
483 { "lp5521", 0 }, /* Three channel chip */
486 MODULE_DEVICE_TABLE(i2c
, lp5521_id
);
488 static struct i2c_driver lp5521_driver
= {
492 .probe
= lp5521_probe
,
493 .remove
= lp5521_remove
,
494 .id_table
= lp5521_id
,
497 module_i2c_driver(lp5521_driver
);
499 MODULE_AUTHOR("Mathias Nyman, Yuri Zaporozhets, Samu Onkalo");
500 MODULE_AUTHOR("Milo Kim <milo.kim@ti.com>");
501 MODULE_DESCRIPTION("LP5521 LED engine");
502 MODULE_LICENSE("GPL v2");