2 * lp5523.c - LP5523 LED 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-lp5523.h>
35 #include <linux/workqueue.h>
36 #include <linux/slab.h>
37 #include <linux/platform_data/leds-lp55xx.h>
38 #include <linux/firmware.h>
40 #include "leds-lp55xx-common.h"
42 #define LP5523_REG_ENABLE 0x00
43 #define LP5523_REG_OP_MODE 0x01
44 #define LP5523_REG_RATIOMETRIC_MSB 0x02
45 #define LP5523_REG_RATIOMETRIC_LSB 0x03
46 #define LP5523_REG_ENABLE_LEDS_MSB 0x04
47 #define LP5523_REG_ENABLE_LEDS_LSB 0x05
48 #define LP5523_REG_LED_CNTRL_BASE 0x06
49 #define LP5523_REG_LED_PWM_BASE 0x16
50 #define LP5523_REG_LED_CURRENT_BASE 0x26
51 #define LP5523_REG_CONFIG 0x36
52 #define LP5523_REG_CHANNEL1_PC 0x37
53 #define LP5523_REG_CHANNEL2_PC 0x38
54 #define LP5523_REG_CHANNEL3_PC 0x39
55 #define LP5523_REG_STATUS 0x3a
56 #define LP5523_REG_GPO 0x3b
57 #define LP5523_REG_VARIABLE 0x3c
58 #define LP5523_REG_RESET 0x3d
59 #define LP5523_REG_TEMP_CTRL 0x3e
60 #define LP5523_REG_TEMP_READ 0x3f
61 #define LP5523_REG_TEMP_WRITE 0x40
62 #define LP5523_REG_LED_TEST_CTRL 0x41
63 #define LP5523_REG_LED_TEST_ADC 0x42
64 #define LP5523_REG_ENG1_VARIABLE 0x45
65 #define LP5523_REG_ENG2_VARIABLE 0x46
66 #define LP5523_REG_ENG3_VARIABLE 0x47
67 #define LP5523_REG_MASTER_FADER1 0x48
68 #define LP5523_REG_MASTER_FADER2 0x49
69 #define LP5523_REG_MASTER_FADER3 0x4a
70 #define LP5523_REG_CH1_PROG_START 0x4c
71 #define LP5523_REG_CH2_PROG_START 0x4d
72 #define LP5523_REG_CH3_PROG_START 0x4e
73 #define LP5523_REG_PROG_PAGE_SEL 0x4f
74 #define LP5523_REG_PROG_MEM 0x50
76 #define LP5523_CMD_LOAD 0x15 /* 00010101 */
77 #define LP5523_CMD_RUN 0x2a /* 00101010 */
78 #define LP5523_CMD_DISABLED 0x00 /* 00000000 */
80 #define LP5523_ENABLE 0x40
81 #define LP5523_AUTO_INC 0x40
82 #define LP5523_PWR_SAVE 0x20
83 #define LP5523_PWM_PWR_SAVE 0x04
84 #define LP5523_CP_1 0x08
85 #define LP5523_CP_1_5 0x10
86 #define LP5523_CP_AUTO 0x18
87 #define LP5523_INT_CLK 0x01
88 #define LP5523_AUTO_CLK 0x02
89 #define LP5523_EN_LEDTEST 0x80
90 #define LP5523_LEDTEST_DONE 0x80
91 #define LP5523_RESET 0xFF
93 #define LP5523_DEFAULT_CURRENT 50 /* microAmps */
94 #define LP5523_PROGRAM_LENGTH 32 /* in bytes */
95 #define LP5523_PROGRAM_PAGES 6
96 #define LP5523_ADC_SHORTCIRC_LIM 80
98 #define LP5523_MAX_LEDS 9
99 #define LP5523_ENGINES 3
101 #define LP5523_ENG_MASK_BASE 0x30 /* 00110000 */
103 #define LP5523_ENG_STATUS_MASK 0x07 /* 00000111 */
105 #define LP5523_IRQ_FLAGS IRQF_TRIGGER_FALLING
107 #define LP5523_EXT_CLK_USED 0x08
109 #define LED_ACTIVE(mux, led) (!!(mux & (0x0001 << led)))
110 #define SHIFT_MASK(id) (((id) - 1) * 2)
112 /* Memory Page Selection */
113 #define LP5523_PAGE_ENG1 0
114 #define LP5523_PAGE_ENG2 1
115 #define LP5523_PAGE_ENG3 2
117 /* Program Memory Operations */
118 #define LP5523_MODE_ENG1_M 0x30 /* Operation Mode Register */
119 #define LP5523_MODE_ENG2_M 0x0C
120 #define LP5523_MODE_ENG3_M 0x03
121 #define LP5523_LOAD_ENG1 0x10
122 #define LP5523_LOAD_ENG2 0x04
123 #define LP5523_LOAD_ENG3 0x01
125 #define LP5523_ENG1_IS_LOADING(mode) \
126 ((mode & LP5523_MODE_ENG1_M) == LP5523_LOAD_ENG1)
127 #define LP5523_ENG2_IS_LOADING(mode) \
128 ((mode & LP5523_MODE_ENG2_M) == LP5523_LOAD_ENG2)
129 #define LP5523_ENG3_IS_LOADING(mode) \
130 ((mode & LP5523_MODE_ENG3_M) == LP5523_LOAD_ENG3)
132 #define LP5523_EXEC_ENG1_M 0x30 /* Enable Register */
133 #define LP5523_EXEC_ENG2_M 0x0C
134 #define LP5523_EXEC_ENG3_M 0x03
135 #define LP5523_EXEC_M 0x3F
136 #define LP5523_RUN_ENG1 0x20
137 #define LP5523_RUN_ENG2 0x08
138 #define LP5523_RUN_ENG3 0x02
140 enum lp5523_chip_id {
150 struct led_classdev cdev;
151 struct work_struct brightness_work;
156 struct mutex lock; /* Serialize control */
157 struct i2c_client *client;
158 struct lp5523_led leds[LP5523_MAX_LEDS];
159 struct lp5523_platform_data *pdata;
164 static inline void lp5523_wait_opmode_done(void)
166 usleep_range(1000, 2000);
169 static void lp5523_set_led_current(struct lp55xx_led *led, u8 led_current)
171 led->led_current = led_current;
172 lp55xx_write(led->chip, LP5523_REG_LED_CURRENT_BASE + led->chan_nr,
176 static int lp5523_post_init_device(struct lp55xx_chip *chip)
180 ret = lp55xx_write(chip, LP5523_REG_ENABLE, LP5523_ENABLE);
184 /* Chip startup time is 500 us, 1 - 2 ms gives some margin */
185 usleep_range(1000, 2000);
187 ret = lp55xx_write(chip, LP5523_REG_CONFIG,
188 LP5523_AUTO_INC | LP5523_PWR_SAVE |
189 LP5523_CP_AUTO | LP5523_AUTO_CLK |
190 LP5523_PWM_PWR_SAVE);
194 /* turn on all leds */
195 ret = lp55xx_write(chip, LP5523_REG_ENABLE_LEDS_MSB, 0x01);
199 return lp55xx_write(chip, LP5523_REG_ENABLE_LEDS_LSB, 0xff);
202 static void lp5523_load_engine(struct lp55xx_chip *chip)
204 enum lp55xx_engine_index idx = chip->engine_idx;
206 [LP55XX_ENGINE_1] = LP5523_MODE_ENG1_M,
207 [LP55XX_ENGINE_2] = LP5523_MODE_ENG2_M,
208 [LP55XX_ENGINE_3] = LP5523_MODE_ENG3_M,
212 [LP55XX_ENGINE_1] = LP5523_LOAD_ENG1,
213 [LP55XX_ENGINE_2] = LP5523_LOAD_ENG2,
214 [LP55XX_ENGINE_3] = LP5523_LOAD_ENG3,
218 [LP55XX_ENGINE_1] = LP5523_PAGE_ENG1,
219 [LP55XX_ENGINE_2] = LP5523_PAGE_ENG2,
220 [LP55XX_ENGINE_3] = LP5523_PAGE_ENG3,
223 lp55xx_update_bits(chip, LP5523_REG_OP_MODE, mask[idx], val[idx]);
225 lp5523_wait_opmode_done();
227 lp55xx_write(chip, LP5523_REG_PROG_PAGE_SEL, page_sel[idx]);
230 static void lp5523_stop_engine(struct lp55xx_chip *chip)
232 lp55xx_write(chip, LP5523_REG_OP_MODE, 0);
233 lp5523_wait_opmode_done();
236 static void lp5523_turn_off_channels(struct lp55xx_chip *chip)
240 for (i = 0; i < LP5523_MAX_LEDS; i++)
241 lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + i, 0);
244 static void lp5523_run_engine(struct lp55xx_chip *chip, bool start)
252 lp5523_stop_engine(chip);
253 lp5523_turn_off_channels(chip);
259 * operation mode and enable register should updated at the same time
262 ret = lp55xx_read(chip, LP5523_REG_OP_MODE, &mode);
266 ret = lp55xx_read(chip, LP5523_REG_ENABLE, &exec);
270 /* change operation mode to RUN only when each engine is loading */
271 if (LP5523_ENG1_IS_LOADING(mode)) {
272 mode = (mode & ~LP5523_MODE_ENG1_M) | LP5523_RUN_ENG1;
273 exec = (exec & ~LP5523_EXEC_ENG1_M) | LP5523_RUN_ENG1;
276 if (LP5523_ENG2_IS_LOADING(mode)) {
277 mode = (mode & ~LP5523_MODE_ENG2_M) | LP5523_RUN_ENG2;
278 exec = (exec & ~LP5523_EXEC_ENG2_M) | LP5523_RUN_ENG2;
281 if (LP5523_ENG3_IS_LOADING(mode)) {
282 mode = (mode & ~LP5523_MODE_ENG3_M) | LP5523_RUN_ENG3;
283 exec = (exec & ~LP5523_EXEC_ENG3_M) | LP5523_RUN_ENG3;
286 lp55xx_write(chip, LP5523_REG_OP_MODE, mode);
287 lp5523_wait_opmode_done();
289 lp55xx_update_bits(chip, LP5523_REG_ENABLE, LP5523_EXEC_M, exec);
292 static int lp5523_update_program_memory(struct lp55xx_chip *chip,
293 const u8 *data, size_t size)
295 u8 pattern[LP5523_PROGRAM_LENGTH] = {0};
304 /* clear program memory before updating */
305 for (i = 0; i < LP5523_PROGRAM_LENGTH; i++)
306 lp55xx_write(chip, LP5523_REG_PROG_MEM + i, 0);
309 while ((offset < size - 1) && (i < LP5523_PROGRAM_LENGTH)) {
310 /* separate sscanfs because length is working only for %s */
311 ret = sscanf(data + offset, "%2s%n ", c, &nrchars);
315 ret = sscanf(c, "%2x", &cmd);
319 pattern[i] = (u8)cmd;
324 /* Each instruction is 16bit long. Check that length is even */
329 for (i = 0; i < update_size; i++)
330 lp55xx_write(chip, LP5523_REG_PROG_MEM + i, pattern[i]);
335 dev_err(&chip->cl->dev, "wrong pattern format\n");
339 static void lp5523_firmware_loaded(struct lp55xx_chip *chip)
341 const struct firmware *fw = chip->fw;
343 if (fw->size > LP5523_PROGRAM_LENGTH) {
344 dev_err(&chip->cl->dev, "firmware data size overflow: %zu\n",
350 * Program momery sequence
351 * 1) set engine mode to "LOAD"
352 * 2) write firmware data into program memory
355 lp5523_load_engine(chip);
356 lp5523_update_program_memory(chip, fw->data, fw->size);
359 static ssize_t lp5523_selftest(struct device *dev,
360 struct device_attribute *attr,
363 struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
364 struct lp55xx_chip *chip = led->chip;
365 struct lp55xx_platform_data *pdata = chip->pdata;
369 mutex_lock(&chip->lock);
371 ret = lp55xx_read(chip, LP5523_REG_STATUS, &status);
375 /* Check that ext clock is really in use if requested */
376 if (pdata->clock_mode == LP55XX_CLOCK_EXT) {
377 if ((status & LP5523_EXT_CLK_USED) == 0)
381 /* Measure VDD (i.e. VBAT) first (channel 16 corresponds to VDD) */
382 lp55xx_write(chip, LP5523_REG_LED_TEST_CTRL, LP5523_EN_LEDTEST | 16);
383 usleep_range(3000, 6000); /* ADC conversion time is typically 2.7 ms */
384 ret = lp55xx_read(chip, LP5523_REG_STATUS, &status);
388 if (!(status & LP5523_LEDTEST_DONE))
389 usleep_range(3000, 6000); /* Was not ready. Wait little bit */
391 ret = lp55xx_read(chip, LP5523_REG_LED_TEST_ADC, &vdd);
395 vdd--; /* There may be some fluctuation in measurement */
397 for (i = 0; i < LP5523_MAX_LEDS; i++) {
398 /* Skip non-existing channels */
399 if (pdata->led_config[i].led_current == 0)
402 /* Set default current */
403 lp55xx_write(chip, LP5523_REG_LED_CURRENT_BASE + i,
404 pdata->led_config[i].led_current);
406 lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + i, 0xff);
407 /* let current stabilize 2 - 4ms before measurements start */
408 usleep_range(2000, 4000);
409 lp55xx_write(chip, LP5523_REG_LED_TEST_CTRL,
410 LP5523_EN_LEDTEST | i);
411 /* ADC conversion time is 2.7 ms typically */
412 usleep_range(3000, 6000);
413 ret = lp55xx_read(chip, LP5523_REG_STATUS, &status);
417 if (!(status & LP5523_LEDTEST_DONE))
418 usleep_range(3000, 6000);/* Was not ready. Wait. */
420 ret = lp55xx_read(chip, LP5523_REG_LED_TEST_ADC, &adc);
424 if (adc >= vdd || adc < LP5523_ADC_SHORTCIRC_LIM)
425 pos += sprintf(buf + pos, "LED %d FAIL\n", i);
427 lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + i, 0x00);
429 /* Restore current */
430 lp55xx_write(chip, LP5523_REG_LED_CURRENT_BASE + i,
435 pos = sprintf(buf, "OK\n");
438 pos = sprintf(buf, "FAIL\n");
441 mutex_unlock(&chip->lock);
446 static void lp5523_led_brightness_work(struct work_struct *work)
448 struct lp55xx_led *led = container_of(work, struct lp55xx_led,
450 struct lp55xx_chip *chip = led->chip;
452 mutex_lock(&chip->lock);
453 lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + led->chan_nr,
455 mutex_unlock(&chip->lock);
458 static DEVICE_ATTR(selftest, S_IRUGO, lp5523_selftest, NULL);
460 static struct attribute *lp5523_attributes[] = {
461 &dev_attr_selftest.attr,
465 static const struct attribute_group lp5523_group = {
466 .attrs = lp5523_attributes,
469 /* Chip specific configurations */
470 static struct lp55xx_device_config lp5523_cfg = {
472 .addr = LP5523_REG_RESET,
476 .addr = LP5523_REG_ENABLE,
477 .val = LP5523_ENABLE,
479 .max_channel = LP5523_MAX_LEDS,
480 .post_init_device = lp5523_post_init_device,
481 .brightness_work_fn = lp5523_led_brightness_work,
482 .set_led_current = lp5523_set_led_current,
483 .firmware_cb = lp5523_firmware_loaded,
484 .run_engine = lp5523_run_engine,
485 .dev_attr_group = &lp5523_group,
488 static int lp5523_probe(struct i2c_client *client,
489 const struct i2c_device_id *id)
492 struct lp55xx_chip *chip;
493 struct lp55xx_led *led;
494 struct lp55xx_platform_data *pdata = client->dev.platform_data;
497 dev_err(&client->dev, "no platform data\n");
501 chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
505 led = devm_kzalloc(&client->dev,
506 sizeof(*led) * pdata->num_channels, GFP_KERNEL);
512 chip->cfg = &lp5523_cfg;
514 mutex_init(&chip->lock);
516 i2c_set_clientdata(client, led);
518 ret = lp55xx_init_device(chip);
522 dev_info(&client->dev, "%s Programmable led chip found\n", id->name);
524 ret = lp55xx_register_leds(led, chip);
526 goto err_register_leds;
528 ret = lp55xx_register_sysfs(chip);
530 dev_err(&client->dev, "registering sysfs failed\n");
531 goto err_register_sysfs;
537 lp55xx_unregister_leds(led, chip);
539 lp55xx_deinit_device(chip);
544 static int lp5523_remove(struct i2c_client *client)
546 struct lp55xx_led *led = i2c_get_clientdata(client);
547 struct lp55xx_chip *chip = led->chip;
549 lp5523_stop_engine(chip);
550 lp55xx_unregister_sysfs(chip);
551 lp55xx_unregister_leds(led, chip);
552 lp55xx_deinit_device(chip);
557 static const struct i2c_device_id lp5523_id[] = {
558 { "lp5523", LP5523 },
559 { "lp55231", LP55231 },
563 MODULE_DEVICE_TABLE(i2c, lp5523_id);
565 static struct i2c_driver lp5523_driver = {
569 .probe = lp5523_probe,
570 .remove = lp5523_remove,
571 .id_table = lp5523_id,
574 module_i2c_driver(lp5523_driver);
576 MODULE_AUTHOR("Mathias Nyman <mathias.nyman@nokia.com>");
577 MODULE_DESCRIPTION("LP5523 LED engine");
578 MODULE_LICENSE("GPL");