xref: /openbmc/linux/drivers/leds/leds-lp5523.c (revision 151f4e2b)
1 /*
2  * lp5523.c - LP5523, LP55231 LED Driver
3  *
4  * Copyright (C) 2010 Nokia Corporation
5  * Copyright (C) 2012 Texas Instruments
6  *
7  * Contact: Samu Onkalo <samu.p.onkalo@nokia.com>
8  *          Milo(Woogyom) Kim <milo.kim@ti.com>
9  *
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.
13  *
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.
18  *
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
22  * 02110-1301 USA
23  */
24 
25 #include <linux/delay.h>
26 #include <linux/firmware.h>
27 #include <linux/i2c.h>
28 #include <linux/leds.h>
29 #include <linux/module.h>
30 #include <linux/mutex.h>
31 #include <linux/of.h>
32 #include <linux/platform_data/leds-lp55xx.h>
33 #include <linux/slab.h>
34 
35 #include "leds-lp55xx-common.h"
36 
37 #define LP5523_PROGRAM_LENGTH		32	/* bytes */
38 /* Memory is used like this:
39    0x00 engine 1 program
40    0x10 engine 2 program
41    0x20 engine 3 program
42    0x30 engine 1 muxing info
43    0x40 engine 2 muxing info
44    0x50 engine 3 muxing info
45 */
46 #define LP5523_MAX_LEDS			9
47 
48 /* Registers */
49 #define LP5523_REG_ENABLE		0x00
50 #define LP5523_REG_OP_MODE		0x01
51 #define LP5523_REG_ENABLE_LEDS_MSB	0x04
52 #define LP5523_REG_ENABLE_LEDS_LSB	0x05
53 #define LP5523_REG_LED_CTRL_BASE	0x06
54 #define LP5523_REG_LED_PWM_BASE		0x16
55 #define LP5523_REG_LED_CURRENT_BASE	0x26
56 #define LP5523_REG_CONFIG		0x36
57 #define LP5523_REG_STATUS		0x3A
58 #define LP5523_REG_RESET		0x3D
59 #define LP5523_REG_LED_TEST_CTRL	0x41
60 #define LP5523_REG_LED_TEST_ADC		0x42
61 #define LP5523_REG_MASTER_FADER_BASE	0x48
62 #define LP5523_REG_CH1_PROG_START	0x4C
63 #define LP5523_REG_CH2_PROG_START	0x4D
64 #define LP5523_REG_CH3_PROG_START	0x4E
65 #define LP5523_REG_PROG_PAGE_SEL	0x4F
66 #define LP5523_REG_PROG_MEM		0x50
67 
68 /* Bit description in registers */
69 #define LP5523_ENABLE			0x40
70 #define LP5523_AUTO_INC			0x40
71 #define LP5523_PWR_SAVE			0x20
72 #define LP5523_PWM_PWR_SAVE		0x04
73 #define LP5523_CP_AUTO			0x18
74 #define LP5523_AUTO_CLK			0x02
75 
76 #define LP5523_EN_LEDTEST		0x80
77 #define LP5523_LEDTEST_DONE		0x80
78 #define LP5523_RESET			0xFF
79 #define LP5523_ADC_SHORTCIRC_LIM	80
80 #define LP5523_EXT_CLK_USED		0x08
81 #define LP5523_ENG_STATUS_MASK		0x07
82 
83 #define LP5523_FADER_MAPPING_MASK	0xC0
84 #define LP5523_FADER_MAPPING_SHIFT	6
85 
86 /* Memory Page Selection */
87 #define LP5523_PAGE_ENG1		0
88 #define LP5523_PAGE_ENG2		1
89 #define LP5523_PAGE_ENG3		2
90 #define LP5523_PAGE_MUX1		3
91 #define LP5523_PAGE_MUX2		4
92 #define LP5523_PAGE_MUX3		5
93 
94 /* Program Memory Operations */
95 #define LP5523_MODE_ENG1_M		0x30	/* Operation Mode Register */
96 #define LP5523_MODE_ENG2_M		0x0C
97 #define LP5523_MODE_ENG3_M		0x03
98 #define LP5523_LOAD_ENG1		0x10
99 #define LP5523_LOAD_ENG2		0x04
100 #define LP5523_LOAD_ENG3		0x01
101 
102 #define LP5523_ENG1_IS_LOADING(mode)	\
103 	((mode & LP5523_MODE_ENG1_M) == LP5523_LOAD_ENG1)
104 #define LP5523_ENG2_IS_LOADING(mode)	\
105 	((mode & LP5523_MODE_ENG2_M) == LP5523_LOAD_ENG2)
106 #define LP5523_ENG3_IS_LOADING(mode)	\
107 	((mode & LP5523_MODE_ENG3_M) == LP5523_LOAD_ENG3)
108 
109 #define LP5523_EXEC_ENG1_M		0x30	/* Enable Register */
110 #define LP5523_EXEC_ENG2_M		0x0C
111 #define LP5523_EXEC_ENG3_M		0x03
112 #define LP5523_EXEC_M			0x3F
113 #define LP5523_RUN_ENG1			0x20
114 #define LP5523_RUN_ENG2			0x08
115 #define LP5523_RUN_ENG3			0x02
116 
117 #define LED_ACTIVE(mux, led)		(!!(mux & (0x0001 << led)))
118 
119 enum lp5523_chip_id {
120 	LP5523,
121 	LP55231,
122 };
123 
124 static int lp5523_init_program_engine(struct lp55xx_chip *chip);
125 
126 static inline void lp5523_wait_opmode_done(void)
127 {
128 	usleep_range(1000, 2000);
129 }
130 
131 static void lp5523_set_led_current(struct lp55xx_led *led, u8 led_current)
132 {
133 	led->led_current = led_current;
134 	lp55xx_write(led->chip, LP5523_REG_LED_CURRENT_BASE + led->chan_nr,
135 		led_current);
136 }
137 
138 static int lp5523_post_init_device(struct lp55xx_chip *chip)
139 {
140 	int ret;
141 
142 	ret = lp55xx_write(chip, LP5523_REG_ENABLE, LP5523_ENABLE);
143 	if (ret)
144 		return ret;
145 
146 	/* Chip startup time is 500 us, 1 - 2 ms gives some margin */
147 	usleep_range(1000, 2000);
148 
149 	ret = lp55xx_write(chip, LP5523_REG_CONFIG,
150 			    LP5523_AUTO_INC | LP5523_PWR_SAVE |
151 			    LP5523_CP_AUTO | LP5523_AUTO_CLK |
152 			    LP5523_PWM_PWR_SAVE);
153 	if (ret)
154 		return ret;
155 
156 	/* turn on all leds */
157 	ret = lp55xx_write(chip, LP5523_REG_ENABLE_LEDS_MSB, 0x01);
158 	if (ret)
159 		return ret;
160 
161 	ret = lp55xx_write(chip, LP5523_REG_ENABLE_LEDS_LSB, 0xff);
162 	if (ret)
163 		return ret;
164 
165 	return lp5523_init_program_engine(chip);
166 }
167 
168 static void lp5523_load_engine(struct lp55xx_chip *chip)
169 {
170 	enum lp55xx_engine_index idx = chip->engine_idx;
171 	static const u8 mask[] = {
172 		[LP55XX_ENGINE_1] = LP5523_MODE_ENG1_M,
173 		[LP55XX_ENGINE_2] = LP5523_MODE_ENG2_M,
174 		[LP55XX_ENGINE_3] = LP5523_MODE_ENG3_M,
175 	};
176 
177 	static const u8 val[] = {
178 		[LP55XX_ENGINE_1] = LP5523_LOAD_ENG1,
179 		[LP55XX_ENGINE_2] = LP5523_LOAD_ENG2,
180 		[LP55XX_ENGINE_3] = LP5523_LOAD_ENG3,
181 	};
182 
183 	lp55xx_update_bits(chip, LP5523_REG_OP_MODE, mask[idx], val[idx]);
184 
185 	lp5523_wait_opmode_done();
186 }
187 
188 static void lp5523_load_engine_and_select_page(struct lp55xx_chip *chip)
189 {
190 	enum lp55xx_engine_index idx = chip->engine_idx;
191 	static const u8 page_sel[] = {
192 		[LP55XX_ENGINE_1] = LP5523_PAGE_ENG1,
193 		[LP55XX_ENGINE_2] = LP5523_PAGE_ENG2,
194 		[LP55XX_ENGINE_3] = LP5523_PAGE_ENG3,
195 	};
196 
197 	lp5523_load_engine(chip);
198 
199 	lp55xx_write(chip, LP5523_REG_PROG_PAGE_SEL, page_sel[idx]);
200 }
201 
202 static void lp5523_stop_all_engines(struct lp55xx_chip *chip)
203 {
204 	lp55xx_write(chip, LP5523_REG_OP_MODE, 0);
205 	lp5523_wait_opmode_done();
206 }
207 
208 static void lp5523_stop_engine(struct lp55xx_chip *chip)
209 {
210 	enum lp55xx_engine_index idx = chip->engine_idx;
211 	static const u8 mask[] = {
212 		[LP55XX_ENGINE_1] = LP5523_MODE_ENG1_M,
213 		[LP55XX_ENGINE_2] = LP5523_MODE_ENG2_M,
214 		[LP55XX_ENGINE_3] = LP5523_MODE_ENG3_M,
215 	};
216 
217 	lp55xx_update_bits(chip, LP5523_REG_OP_MODE, mask[idx], 0);
218 
219 	lp5523_wait_opmode_done();
220 }
221 
222 static void lp5523_turn_off_channels(struct lp55xx_chip *chip)
223 {
224 	int i;
225 
226 	for (i = 0; i < LP5523_MAX_LEDS; i++)
227 		lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + i, 0);
228 }
229 
230 static void lp5523_run_engine(struct lp55xx_chip *chip, bool start)
231 {
232 	int ret;
233 	u8 mode;
234 	u8 exec;
235 
236 	/* stop engine */
237 	if (!start) {
238 		lp5523_stop_engine(chip);
239 		lp5523_turn_off_channels(chip);
240 		return;
241 	}
242 
243 	/*
244 	 * To run the engine,
245 	 * operation mode and enable register should updated at the same time
246 	 */
247 
248 	ret = lp55xx_read(chip, LP5523_REG_OP_MODE, &mode);
249 	if (ret)
250 		return;
251 
252 	ret = lp55xx_read(chip, LP5523_REG_ENABLE, &exec);
253 	if (ret)
254 		return;
255 
256 	/* change operation mode to RUN only when each engine is loading */
257 	if (LP5523_ENG1_IS_LOADING(mode)) {
258 		mode = (mode & ~LP5523_MODE_ENG1_M) | LP5523_RUN_ENG1;
259 		exec = (exec & ~LP5523_EXEC_ENG1_M) | LP5523_RUN_ENG1;
260 	}
261 
262 	if (LP5523_ENG2_IS_LOADING(mode)) {
263 		mode = (mode & ~LP5523_MODE_ENG2_M) | LP5523_RUN_ENG2;
264 		exec = (exec & ~LP5523_EXEC_ENG2_M) | LP5523_RUN_ENG2;
265 	}
266 
267 	if (LP5523_ENG3_IS_LOADING(mode)) {
268 		mode = (mode & ~LP5523_MODE_ENG3_M) | LP5523_RUN_ENG3;
269 		exec = (exec & ~LP5523_EXEC_ENG3_M) | LP5523_RUN_ENG3;
270 	}
271 
272 	lp55xx_write(chip, LP5523_REG_OP_MODE, mode);
273 	lp5523_wait_opmode_done();
274 
275 	lp55xx_update_bits(chip, LP5523_REG_ENABLE, LP5523_EXEC_M, exec);
276 }
277 
278 static int lp5523_init_program_engine(struct lp55xx_chip *chip)
279 {
280 	int i;
281 	int j;
282 	int ret;
283 	u8 status;
284 	/* one pattern per engine setting LED MUX start and stop addresses */
285 	static const u8 pattern[][LP5523_PROGRAM_LENGTH] =  {
286 		{ 0x9c, 0x30, 0x9c, 0xb0, 0x9d, 0x80, 0xd8, 0x00, 0},
287 		{ 0x9c, 0x40, 0x9c, 0xc0, 0x9d, 0x80, 0xd8, 0x00, 0},
288 		{ 0x9c, 0x50, 0x9c, 0xd0, 0x9d, 0x80, 0xd8, 0x00, 0},
289 	};
290 
291 	/* hardcode 32 bytes of memory for each engine from program memory */
292 	ret = lp55xx_write(chip, LP5523_REG_CH1_PROG_START, 0x00);
293 	if (ret)
294 		return ret;
295 
296 	ret = lp55xx_write(chip, LP5523_REG_CH2_PROG_START, 0x10);
297 	if (ret)
298 		return ret;
299 
300 	ret = lp55xx_write(chip, LP5523_REG_CH3_PROG_START, 0x20);
301 	if (ret)
302 		return ret;
303 
304 	/* write LED MUX address space for each engine */
305 	for (i = LP55XX_ENGINE_1; i <= LP55XX_ENGINE_3; i++) {
306 		chip->engine_idx = i;
307 		lp5523_load_engine_and_select_page(chip);
308 
309 		for (j = 0; j < LP5523_PROGRAM_LENGTH; j++) {
310 			ret = lp55xx_write(chip, LP5523_REG_PROG_MEM + j,
311 					pattern[i - 1][j]);
312 			if (ret)
313 				goto out;
314 		}
315 	}
316 
317 	lp5523_run_engine(chip, true);
318 
319 	/* Let the programs run for couple of ms and check the engine status */
320 	usleep_range(3000, 6000);
321 	ret = lp55xx_read(chip, LP5523_REG_STATUS, &status);
322 	if (ret)
323 		return ret;
324 	status &= LP5523_ENG_STATUS_MASK;
325 
326 	if (status != LP5523_ENG_STATUS_MASK) {
327 		dev_err(&chip->cl->dev,
328 			"could not configure LED engine, status = 0x%.2x\n",
329 			status);
330 		ret = -1;
331 	}
332 
333 out:
334 	lp5523_stop_all_engines(chip);
335 	return ret;
336 }
337 
338 static int lp5523_update_program_memory(struct lp55xx_chip *chip,
339 					const u8 *data, size_t size)
340 {
341 	u8 pattern[LP5523_PROGRAM_LENGTH] = {0};
342 	unsigned cmd;
343 	char c[3];
344 	int nrchars;
345 	int ret;
346 	int offset = 0;
347 	int i = 0;
348 
349 	while ((offset < size - 1) && (i < LP5523_PROGRAM_LENGTH)) {
350 		/* separate sscanfs because length is working only for %s */
351 		ret = sscanf(data + offset, "%2s%n ", c, &nrchars);
352 		if (ret != 1)
353 			goto err;
354 
355 		ret = sscanf(c, "%2x", &cmd);
356 		if (ret != 1)
357 			goto err;
358 
359 		pattern[i] = (u8)cmd;
360 		offset += nrchars;
361 		i++;
362 	}
363 
364 	/* Each instruction is 16bit long. Check that length is even */
365 	if (i % 2)
366 		goto err;
367 
368 	for (i = 0; i < LP5523_PROGRAM_LENGTH; i++) {
369 		ret = lp55xx_write(chip, LP5523_REG_PROG_MEM + i, pattern[i]);
370 		if (ret)
371 			return -EINVAL;
372 	}
373 
374 	return size;
375 
376 err:
377 	dev_err(&chip->cl->dev, "wrong pattern format\n");
378 	return -EINVAL;
379 }
380 
381 static void lp5523_firmware_loaded(struct lp55xx_chip *chip)
382 {
383 	const struct firmware *fw = chip->fw;
384 
385 	if (fw->size > LP5523_PROGRAM_LENGTH) {
386 		dev_err(&chip->cl->dev, "firmware data size overflow: %zu\n",
387 			fw->size);
388 		return;
389 	}
390 
391 	/*
392 	 * Program memory sequence
393 	 *  1) set engine mode to "LOAD"
394 	 *  2) write firmware data into program memory
395 	 */
396 
397 	lp5523_load_engine_and_select_page(chip);
398 	lp5523_update_program_memory(chip, fw->data, fw->size);
399 }
400 
401 static ssize_t show_engine_mode(struct device *dev,
402 				struct device_attribute *attr,
403 				char *buf, int nr)
404 {
405 	struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
406 	struct lp55xx_chip *chip = led->chip;
407 	enum lp55xx_engine_mode mode = chip->engines[nr - 1].mode;
408 
409 	switch (mode) {
410 	case LP55XX_ENGINE_RUN:
411 		return sprintf(buf, "run\n");
412 	case LP55XX_ENGINE_LOAD:
413 		return sprintf(buf, "load\n");
414 	case LP55XX_ENGINE_DISABLED:
415 	default:
416 		return sprintf(buf, "disabled\n");
417 	}
418 }
419 show_mode(1)
420 show_mode(2)
421 show_mode(3)
422 
423 static ssize_t store_engine_mode(struct device *dev,
424 				 struct device_attribute *attr,
425 				 const char *buf, size_t len, int nr)
426 {
427 	struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
428 	struct lp55xx_chip *chip = led->chip;
429 	struct lp55xx_engine *engine = &chip->engines[nr - 1];
430 
431 	mutex_lock(&chip->lock);
432 
433 	chip->engine_idx = nr;
434 
435 	if (!strncmp(buf, "run", 3)) {
436 		lp5523_run_engine(chip, true);
437 		engine->mode = LP55XX_ENGINE_RUN;
438 	} else if (!strncmp(buf, "load", 4)) {
439 		lp5523_stop_engine(chip);
440 		lp5523_load_engine(chip);
441 		engine->mode = LP55XX_ENGINE_LOAD;
442 	} else if (!strncmp(buf, "disabled", 8)) {
443 		lp5523_stop_engine(chip);
444 		engine->mode = LP55XX_ENGINE_DISABLED;
445 	}
446 
447 	mutex_unlock(&chip->lock);
448 
449 	return len;
450 }
451 store_mode(1)
452 store_mode(2)
453 store_mode(3)
454 
455 static int lp5523_mux_parse(const char *buf, u16 *mux, size_t len)
456 {
457 	u16 tmp_mux = 0;
458 	int i;
459 
460 	len = min_t(int, len, LP5523_MAX_LEDS);
461 
462 	for (i = 0; i < len; i++) {
463 		switch (buf[i]) {
464 		case '1':
465 			tmp_mux |= (1 << i);
466 			break;
467 		case '0':
468 			break;
469 		case '\n':
470 			i = len;
471 			break;
472 		default:
473 			return -1;
474 		}
475 	}
476 	*mux = tmp_mux;
477 
478 	return 0;
479 }
480 
481 static void lp5523_mux_to_array(u16 led_mux, char *array)
482 {
483 	int i, pos = 0;
484 	for (i = 0; i < LP5523_MAX_LEDS; i++)
485 		pos += sprintf(array + pos, "%x", LED_ACTIVE(led_mux, i));
486 
487 	array[pos] = '\0';
488 }
489 
490 static ssize_t show_engine_leds(struct device *dev,
491 			    struct device_attribute *attr,
492 			    char *buf, int nr)
493 {
494 	struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
495 	struct lp55xx_chip *chip = led->chip;
496 	char mux[LP5523_MAX_LEDS + 1];
497 
498 	lp5523_mux_to_array(chip->engines[nr - 1].led_mux, mux);
499 
500 	return sprintf(buf, "%s\n", mux);
501 }
502 show_leds(1)
503 show_leds(2)
504 show_leds(3)
505 
506 static int lp5523_load_mux(struct lp55xx_chip *chip, u16 mux, int nr)
507 {
508 	struct lp55xx_engine *engine = &chip->engines[nr - 1];
509 	int ret;
510 	static const u8 mux_page[] = {
511 		[LP55XX_ENGINE_1] = LP5523_PAGE_MUX1,
512 		[LP55XX_ENGINE_2] = LP5523_PAGE_MUX2,
513 		[LP55XX_ENGINE_3] = LP5523_PAGE_MUX3,
514 	};
515 
516 	lp5523_load_engine(chip);
517 
518 	ret = lp55xx_write(chip, LP5523_REG_PROG_PAGE_SEL, mux_page[nr]);
519 	if (ret)
520 		return ret;
521 
522 	ret = lp55xx_write(chip, LP5523_REG_PROG_MEM , (u8)(mux >> 8));
523 	if (ret)
524 		return ret;
525 
526 	ret = lp55xx_write(chip, LP5523_REG_PROG_MEM + 1, (u8)(mux));
527 	if (ret)
528 		return ret;
529 
530 	engine->led_mux = mux;
531 	return 0;
532 }
533 
534 static ssize_t store_engine_leds(struct device *dev,
535 			     struct device_attribute *attr,
536 			     const char *buf, size_t len, int nr)
537 {
538 	struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
539 	struct lp55xx_chip *chip = led->chip;
540 	struct lp55xx_engine *engine = &chip->engines[nr - 1];
541 	u16 mux = 0;
542 	ssize_t ret;
543 
544 	if (lp5523_mux_parse(buf, &mux, len))
545 		return -EINVAL;
546 
547 	mutex_lock(&chip->lock);
548 
549 	chip->engine_idx = nr;
550 	ret = -EINVAL;
551 
552 	if (engine->mode != LP55XX_ENGINE_LOAD)
553 		goto leave;
554 
555 	if (lp5523_load_mux(chip, mux, nr))
556 		goto leave;
557 
558 	ret = len;
559 leave:
560 	mutex_unlock(&chip->lock);
561 	return ret;
562 }
563 store_leds(1)
564 store_leds(2)
565 store_leds(3)
566 
567 static ssize_t store_engine_load(struct device *dev,
568 			     struct device_attribute *attr,
569 			     const char *buf, size_t len, int nr)
570 {
571 	struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
572 	struct lp55xx_chip *chip = led->chip;
573 	int ret;
574 
575 	mutex_lock(&chip->lock);
576 
577 	chip->engine_idx = nr;
578 	lp5523_load_engine_and_select_page(chip);
579 	ret = lp5523_update_program_memory(chip, buf, len);
580 
581 	mutex_unlock(&chip->lock);
582 
583 	return ret;
584 }
585 store_load(1)
586 store_load(2)
587 store_load(3)
588 
589 static ssize_t lp5523_selftest(struct device *dev,
590 			       struct device_attribute *attr,
591 			       char *buf)
592 {
593 	struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
594 	struct lp55xx_chip *chip = led->chip;
595 	struct lp55xx_platform_data *pdata = chip->pdata;
596 	int i, ret, pos = 0;
597 	u8 status, adc, vdd;
598 
599 	mutex_lock(&chip->lock);
600 
601 	ret = lp55xx_read(chip, LP5523_REG_STATUS, &status);
602 	if (ret < 0)
603 		goto fail;
604 
605 	/* Check that ext clock is really in use if requested */
606 	if (pdata->clock_mode == LP55XX_CLOCK_EXT) {
607 		if  ((status & LP5523_EXT_CLK_USED) == 0)
608 			goto fail;
609 	}
610 
611 	/* Measure VDD (i.e. VBAT) first (channel 16 corresponds to VDD) */
612 	lp55xx_write(chip, LP5523_REG_LED_TEST_CTRL, LP5523_EN_LEDTEST | 16);
613 	usleep_range(3000, 6000); /* ADC conversion time is typically 2.7 ms */
614 	ret = lp55xx_read(chip, LP5523_REG_STATUS, &status);
615 	if (ret < 0)
616 		goto fail;
617 
618 	if (!(status & LP5523_LEDTEST_DONE))
619 		usleep_range(3000, 6000); /* Was not ready. Wait little bit */
620 
621 	ret = lp55xx_read(chip, LP5523_REG_LED_TEST_ADC, &vdd);
622 	if (ret < 0)
623 		goto fail;
624 
625 	vdd--;	/* There may be some fluctuation in measurement */
626 
627 	for (i = 0; i < LP5523_MAX_LEDS; i++) {
628 		/* Skip non-existing channels */
629 		if (pdata->led_config[i].led_current == 0)
630 			continue;
631 
632 		/* Set default current */
633 		lp55xx_write(chip, LP5523_REG_LED_CURRENT_BASE + i,
634 			pdata->led_config[i].led_current);
635 
636 		lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + i, 0xff);
637 		/* let current stabilize 2 - 4ms before measurements start */
638 		usleep_range(2000, 4000);
639 		lp55xx_write(chip, LP5523_REG_LED_TEST_CTRL,
640 			     LP5523_EN_LEDTEST | i);
641 		/* ADC conversion time is 2.7 ms typically */
642 		usleep_range(3000, 6000);
643 		ret = lp55xx_read(chip, LP5523_REG_STATUS, &status);
644 		if (ret < 0)
645 			goto fail;
646 
647 		if (!(status & LP5523_LEDTEST_DONE))
648 			usleep_range(3000, 6000);/* Was not ready. Wait. */
649 
650 		ret = lp55xx_read(chip, LP5523_REG_LED_TEST_ADC, &adc);
651 		if (ret < 0)
652 			goto fail;
653 
654 		if (adc >= vdd || adc < LP5523_ADC_SHORTCIRC_LIM)
655 			pos += sprintf(buf + pos, "LED %d FAIL\n", i);
656 
657 		lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + i, 0x00);
658 
659 		/* Restore current */
660 		lp55xx_write(chip, LP5523_REG_LED_CURRENT_BASE + i,
661 			led->led_current);
662 		led++;
663 	}
664 	if (pos == 0)
665 		pos = sprintf(buf, "OK\n");
666 	goto release_lock;
667 fail:
668 	pos = sprintf(buf, "FAIL\n");
669 
670 release_lock:
671 	mutex_unlock(&chip->lock);
672 
673 	return pos;
674 }
675 
676 #define show_fader(nr)						\
677 static ssize_t show_master_fader##nr(struct device *dev,	\
678 			    struct device_attribute *attr,	\
679 			    char *buf)				\
680 {								\
681 	return show_master_fader(dev, attr, buf, nr);		\
682 }
683 
684 #define store_fader(nr)						\
685 static ssize_t store_master_fader##nr(struct device *dev,	\
686 			     struct device_attribute *attr,	\
687 			     const char *buf, size_t len)	\
688 {								\
689 	return store_master_fader(dev, attr, buf, len, nr);	\
690 }
691 
692 static ssize_t show_master_fader(struct device *dev,
693 				 struct device_attribute *attr,
694 				 char *buf, int nr)
695 {
696 	struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
697 	struct lp55xx_chip *chip = led->chip;
698 	int ret;
699 	u8 val;
700 
701 	mutex_lock(&chip->lock);
702 	ret = lp55xx_read(chip, LP5523_REG_MASTER_FADER_BASE + nr - 1, &val);
703 	mutex_unlock(&chip->lock);
704 
705 	if (ret == 0)
706 		ret = sprintf(buf, "%u\n", val);
707 
708 	return ret;
709 }
710 show_fader(1)
711 show_fader(2)
712 show_fader(3)
713 
714 static ssize_t store_master_fader(struct device *dev,
715 				  struct device_attribute *attr,
716 				  const char *buf, size_t len, int nr)
717 {
718 	struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
719 	struct lp55xx_chip *chip = led->chip;
720 	int ret;
721 	unsigned long val;
722 
723 	if (kstrtoul(buf, 0, &val))
724 		return -EINVAL;
725 
726 	if (val > 0xff)
727 		return -EINVAL;
728 
729 	mutex_lock(&chip->lock);
730 	ret = lp55xx_write(chip, LP5523_REG_MASTER_FADER_BASE + nr - 1,
731 			   (u8)val);
732 	mutex_unlock(&chip->lock);
733 
734 	if (ret == 0)
735 		ret = len;
736 
737 	return ret;
738 }
739 store_fader(1)
740 store_fader(2)
741 store_fader(3)
742 
743 static ssize_t show_master_fader_leds(struct device *dev,
744 				      struct device_attribute *attr,
745 				      char *buf)
746 {
747 	struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
748 	struct lp55xx_chip *chip = led->chip;
749 	int i, ret, pos = 0;
750 	u8 val;
751 
752 	mutex_lock(&chip->lock);
753 
754 	for (i = 0; i < LP5523_MAX_LEDS; i++) {
755 		ret = lp55xx_read(chip, LP5523_REG_LED_CTRL_BASE + i, &val);
756 		if (ret)
757 			goto leave;
758 
759 		val = (val & LP5523_FADER_MAPPING_MASK)
760 			>> LP5523_FADER_MAPPING_SHIFT;
761 		if (val > 3) {
762 			ret = -EINVAL;
763 			goto leave;
764 		}
765 		buf[pos++] = val + '0';
766 	}
767 	buf[pos++] = '\n';
768 	ret = pos;
769 leave:
770 	mutex_unlock(&chip->lock);
771 	return ret;
772 }
773 
774 static ssize_t store_master_fader_leds(struct device *dev,
775 				       struct device_attribute *attr,
776 				       const char *buf, size_t len)
777 {
778 	struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
779 	struct lp55xx_chip *chip = led->chip;
780 	int i, n, ret;
781 	u8 val;
782 
783 	n = min_t(int, len, LP5523_MAX_LEDS);
784 
785 	mutex_lock(&chip->lock);
786 
787 	for (i = 0; i < n; i++) {
788 		if (buf[i] >= '0' && buf[i] <= '3') {
789 			val = (buf[i] - '0') << LP5523_FADER_MAPPING_SHIFT;
790 			ret = lp55xx_update_bits(chip,
791 						 LP5523_REG_LED_CTRL_BASE + i,
792 						 LP5523_FADER_MAPPING_MASK,
793 						 val);
794 			if (ret)
795 				goto leave;
796 		} else {
797 			ret = -EINVAL;
798 			goto leave;
799 		}
800 	}
801 	ret = len;
802 leave:
803 	mutex_unlock(&chip->lock);
804 	return ret;
805 }
806 
807 static int lp5523_led_brightness(struct lp55xx_led *led)
808 {
809 	struct lp55xx_chip *chip = led->chip;
810 	int ret;
811 
812 	mutex_lock(&chip->lock);
813 	ret = lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + led->chan_nr,
814 		     led->brightness);
815 	mutex_unlock(&chip->lock);
816 	return ret;
817 }
818 
819 static LP55XX_DEV_ATTR_RW(engine1_mode, show_engine1_mode, store_engine1_mode);
820 static LP55XX_DEV_ATTR_RW(engine2_mode, show_engine2_mode, store_engine2_mode);
821 static LP55XX_DEV_ATTR_RW(engine3_mode, show_engine3_mode, store_engine3_mode);
822 static LP55XX_DEV_ATTR_RW(engine1_leds, show_engine1_leds, store_engine1_leds);
823 static LP55XX_DEV_ATTR_RW(engine2_leds, show_engine2_leds, store_engine2_leds);
824 static LP55XX_DEV_ATTR_RW(engine3_leds, show_engine3_leds, store_engine3_leds);
825 static LP55XX_DEV_ATTR_WO(engine1_load, store_engine1_load);
826 static LP55XX_DEV_ATTR_WO(engine2_load, store_engine2_load);
827 static LP55XX_DEV_ATTR_WO(engine3_load, store_engine3_load);
828 static LP55XX_DEV_ATTR_RO(selftest, lp5523_selftest);
829 static LP55XX_DEV_ATTR_RW(master_fader1, show_master_fader1,
830 			  store_master_fader1);
831 static LP55XX_DEV_ATTR_RW(master_fader2, show_master_fader2,
832 			  store_master_fader2);
833 static LP55XX_DEV_ATTR_RW(master_fader3, show_master_fader3,
834 			  store_master_fader3);
835 static LP55XX_DEV_ATTR_RW(master_fader_leds, show_master_fader_leds,
836 			  store_master_fader_leds);
837 
838 static struct attribute *lp5523_attributes[] = {
839 	&dev_attr_engine1_mode.attr,
840 	&dev_attr_engine2_mode.attr,
841 	&dev_attr_engine3_mode.attr,
842 	&dev_attr_engine1_load.attr,
843 	&dev_attr_engine2_load.attr,
844 	&dev_attr_engine3_load.attr,
845 	&dev_attr_engine1_leds.attr,
846 	&dev_attr_engine2_leds.attr,
847 	&dev_attr_engine3_leds.attr,
848 	&dev_attr_selftest.attr,
849 	&dev_attr_master_fader1.attr,
850 	&dev_attr_master_fader2.attr,
851 	&dev_attr_master_fader3.attr,
852 	&dev_attr_master_fader_leds.attr,
853 	NULL,
854 };
855 
856 static const struct attribute_group lp5523_group = {
857 	.attrs = lp5523_attributes,
858 };
859 
860 /* Chip specific configurations */
861 static struct lp55xx_device_config lp5523_cfg = {
862 	.reset = {
863 		.addr = LP5523_REG_RESET,
864 		.val  = LP5523_RESET,
865 	},
866 	.enable = {
867 		.addr = LP5523_REG_ENABLE,
868 		.val  = LP5523_ENABLE,
869 	},
870 	.max_channel  = LP5523_MAX_LEDS,
871 	.post_init_device   = lp5523_post_init_device,
872 	.brightness_fn      = lp5523_led_brightness,
873 	.set_led_current    = lp5523_set_led_current,
874 	.firmware_cb        = lp5523_firmware_loaded,
875 	.run_engine         = lp5523_run_engine,
876 	.dev_attr_group     = &lp5523_group,
877 };
878 
879 static int lp5523_probe(struct i2c_client *client,
880 			const struct i2c_device_id *id)
881 {
882 	int ret;
883 	struct lp55xx_chip *chip;
884 	struct lp55xx_led *led;
885 	struct lp55xx_platform_data *pdata = dev_get_platdata(&client->dev);
886 	struct device_node *np = client->dev.of_node;
887 
888 	if (!pdata) {
889 		if (np) {
890 			pdata = lp55xx_of_populate_pdata(&client->dev, np);
891 			if (IS_ERR(pdata))
892 				return PTR_ERR(pdata);
893 		} else {
894 			dev_err(&client->dev, "no platform data\n");
895 			return -EINVAL;
896 		}
897 	}
898 
899 	chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
900 	if (!chip)
901 		return -ENOMEM;
902 
903 	led = devm_kcalloc(&client->dev,
904 			pdata->num_channels, sizeof(*led), GFP_KERNEL);
905 	if (!led)
906 		return -ENOMEM;
907 
908 	chip->cl = client;
909 	chip->pdata = pdata;
910 	chip->cfg = &lp5523_cfg;
911 
912 	mutex_init(&chip->lock);
913 
914 	i2c_set_clientdata(client, led);
915 
916 	ret = lp55xx_init_device(chip);
917 	if (ret)
918 		goto err_init;
919 
920 	dev_info(&client->dev, "%s Programmable led chip found\n", id->name);
921 
922 	ret = lp55xx_register_leds(led, chip);
923 	if (ret)
924 		goto err_register_leds;
925 
926 	ret = lp55xx_register_sysfs(chip);
927 	if (ret) {
928 		dev_err(&client->dev, "registering sysfs failed\n");
929 		goto err_register_sysfs;
930 	}
931 
932 	return 0;
933 
934 err_register_sysfs:
935 	lp55xx_unregister_leds(led, chip);
936 err_register_leds:
937 	lp55xx_deinit_device(chip);
938 err_init:
939 	return ret;
940 }
941 
942 static int lp5523_remove(struct i2c_client *client)
943 {
944 	struct lp55xx_led *led = i2c_get_clientdata(client);
945 	struct lp55xx_chip *chip = led->chip;
946 
947 	lp5523_stop_all_engines(chip);
948 	lp55xx_unregister_sysfs(chip);
949 	lp55xx_unregister_leds(led, chip);
950 	lp55xx_deinit_device(chip);
951 
952 	return 0;
953 }
954 
955 static const struct i2c_device_id lp5523_id[] = {
956 	{ "lp5523",  LP5523 },
957 	{ "lp55231", LP55231 },
958 	{ }
959 };
960 
961 MODULE_DEVICE_TABLE(i2c, lp5523_id);
962 
963 #ifdef CONFIG_OF
964 static const struct of_device_id of_lp5523_leds_match[] = {
965 	{ .compatible = "national,lp5523", },
966 	{ .compatible = "ti,lp55231", },
967 	{},
968 };
969 
970 MODULE_DEVICE_TABLE(of, of_lp5523_leds_match);
971 #endif
972 
973 static struct i2c_driver lp5523_driver = {
974 	.driver = {
975 		.name	= "lp5523x",
976 		.of_match_table = of_match_ptr(of_lp5523_leds_match),
977 	},
978 	.probe		= lp5523_probe,
979 	.remove		= lp5523_remove,
980 	.id_table	= lp5523_id,
981 };
982 
983 module_i2c_driver(lp5523_driver);
984 
985 MODULE_AUTHOR("Mathias Nyman <mathias.nyman@nokia.com>");
986 MODULE_AUTHOR("Milo Kim <milo.kim@ti.com>");
987 MODULE_DESCRIPTION("LP5523 LED engine");
988 MODULE_LICENSE("GPL");
989