leds-lp5523.c 20.1 KB
Newer Older
1 2 3 4
/*
 * lp5523.c - LP5523 LED Driver
 *
 * 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 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 */

#include <linux/delay.h>
26 27 28
#include <linux/firmware.h>
#include <linux/i2c.h>
#include <linux/init.h>
29
#include <linux/leds.h>
30 31
#include <linux/module.h>
#include <linux/mutex.h>
32
#include <linux/platform_data/leds-lp55xx.h>
33
#include <linux/slab.h>
34 35

#include "leds-lp55xx-common.h"
36

37 38 39 40
#define LP5523_PROGRAM_LENGTH		32
#define LP5523_MAX_LEDS			9

/* Registers */
41 42 43 44 45 46 47
#define LP5523_REG_ENABLE		0x00
#define LP5523_REG_OP_MODE		0x01
#define LP5523_REG_ENABLE_LEDS_MSB	0x04
#define LP5523_REG_ENABLE_LEDS_LSB	0x05
#define LP5523_REG_LED_PWM_BASE		0x16
#define LP5523_REG_LED_CURRENT_BASE	0x26
#define LP5523_REG_CONFIG		0x36
48 49
#define LP5523_REG_STATUS		0x3A
#define LP5523_REG_RESET		0x3D
50 51
#define LP5523_REG_LED_TEST_CTRL	0x41
#define LP5523_REG_LED_TEST_ADC		0x42
52 53 54
#define LP5523_REG_CH1_PROG_START	0x4C
#define LP5523_REG_CH2_PROG_START	0x4D
#define LP5523_REG_CH3_PROG_START	0x4E
55
#define LP5523_REG_PROG_PAGE_SEL	0x4F
56 57
#define LP5523_REG_PROG_MEM		0x50

58
/* Bit description in registers */
59 60 61 62 63 64
#define LP5523_ENABLE			0x40
#define LP5523_AUTO_INC			0x40
#define LP5523_PWR_SAVE			0x20
#define LP5523_PWM_PWR_SAVE		0x04
#define LP5523_CP_AUTO			0x18
#define LP5523_AUTO_CLK			0x02
65

66 67
#define LP5523_EN_LEDTEST		0x80
#define LP5523_LEDTEST_DONE		0x80
68
#define LP5523_RESET			0xFF
69 70
#define LP5523_ADC_SHORTCIRC_LIM	80
#define LP5523_EXT_CLK_USED		0x08
71
#define LP5523_ENG_STATUS_MASK		0x07
72

73 74 75 76
/* Memory Page Selection */
#define LP5523_PAGE_ENG1		0
#define LP5523_PAGE_ENG2		1
#define LP5523_PAGE_ENG3		2
77 78 79
#define LP5523_PAGE_MUX1		3
#define LP5523_PAGE_MUX2		4
#define LP5523_PAGE_MUX3		5
80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103

/* Program Memory Operations */
#define LP5523_MODE_ENG1_M		0x30	/* Operation Mode Register */
#define LP5523_MODE_ENG2_M		0x0C
#define LP5523_MODE_ENG3_M		0x03
#define LP5523_LOAD_ENG1		0x10
#define LP5523_LOAD_ENG2		0x04
#define LP5523_LOAD_ENG3		0x01

#define LP5523_ENG1_IS_LOADING(mode)	\
	((mode & LP5523_MODE_ENG1_M) == LP5523_LOAD_ENG1)
#define LP5523_ENG2_IS_LOADING(mode)	\
	((mode & LP5523_MODE_ENG2_M) == LP5523_LOAD_ENG2)
#define LP5523_ENG3_IS_LOADING(mode)	\
	((mode & LP5523_MODE_ENG3_M) == LP5523_LOAD_ENG3)

#define LP5523_EXEC_ENG1_M		0x30	/* Enable Register */
#define LP5523_EXEC_ENG2_M		0x0C
#define LP5523_EXEC_ENG3_M		0x03
#define LP5523_EXEC_M			0x3F
#define LP5523_RUN_ENG1			0x20
#define LP5523_RUN_ENG2			0x08
#define LP5523_RUN_ENG3			0x02

104 105
#define LED_ACTIVE(mux, led)		(!!(mux & (0x0001 << led)))

106 107 108 109 110
enum lp5523_chip_id {
	LP5523,
	LP55231,
};

111 112
static int lp5523_init_program_engine(struct lp55xx_chip *chip);

113 114 115 116 117
static inline void lp5523_wait_opmode_done(void)
{
	usleep_range(1000, 2000);
}

118 119 120 121 122 123 124
static void lp5523_set_led_current(struct lp55xx_led *led, u8 led_current)
{
	led->led_current = led_current;
	lp55xx_write(led->chip, LP5523_REG_LED_CURRENT_BASE + led->chan_nr,
		led_current);
}

125
static int lp5523_post_init_device(struct lp55xx_chip *chip)
126
{
127
	int ret;
128

129
	ret = lp55xx_write(chip, LP5523_REG_ENABLE, LP5523_ENABLE);
130 131
	if (ret)
		return ret;
132

133 134
	/* Chip startup time is 500 us, 1 - 2 ms gives some margin */
	usleep_range(1000, 2000);
135

136
	ret = lp55xx_write(chip, LP5523_REG_CONFIG,
137 138 139
			    LP5523_AUTO_INC | LP5523_PWR_SAVE |
			    LP5523_CP_AUTO | LP5523_AUTO_CLK |
			    LP5523_PWM_PWR_SAVE);
140 141
	if (ret)
		return ret;
142 143

	/* turn on all leds */
144
	ret = lp55xx_write(chip, LP5523_REG_ENABLE_LEDS_MSB, 0x01);
145
	if (ret)
146 147
		return ret;

148 149 150 151 152
	ret = lp55xx_write(chip, LP5523_REG_ENABLE_LEDS_LSB, 0xff);
	if (ret)
		return ret;

	return lp5523_init_program_engine(chip);
153 154
}

155
static void lp5523_load_engine(struct lp55xx_chip *chip)
156
{
157 158 159 160 161 162 163 164 165 166 167 168 169
	enum lp55xx_engine_index idx = chip->engine_idx;
	u8 mask[] = {
		[LP55XX_ENGINE_1] = LP5523_MODE_ENG1_M,
		[LP55XX_ENGINE_2] = LP5523_MODE_ENG2_M,
		[LP55XX_ENGINE_3] = LP5523_MODE_ENG3_M,
	};

	u8 val[] = {
		[LP55XX_ENGINE_1] = LP5523_LOAD_ENG1,
		[LP55XX_ENGINE_2] = LP5523_LOAD_ENG2,
		[LP55XX_ENGINE_3] = LP5523_LOAD_ENG3,
	};

170 171 172 173 174 175 176 177
	lp55xx_update_bits(chip, LP5523_REG_OP_MODE, mask[idx], val[idx]);

	lp5523_wait_opmode_done();
}

static void lp5523_load_engine_and_select_page(struct lp55xx_chip *chip)
{
	enum lp55xx_engine_index idx = chip->engine_idx;
178 179 180 181 182 183
	u8 page_sel[] = {
		[LP55XX_ENGINE_1] = LP5523_PAGE_ENG1,
		[LP55XX_ENGINE_2] = LP5523_PAGE_ENG2,
		[LP55XX_ENGINE_3] = LP5523_PAGE_ENG3,
	};

184
	lp5523_load_engine(chip);
185 186

	lp55xx_write(chip, LP5523_REG_PROG_PAGE_SEL, page_sel[idx]);
187 188
}

189
static void lp5523_stop_engine(struct lp55xx_chip *chip)
190
{
191 192 193
	lp55xx_write(chip, LP5523_REG_OP_MODE, 0);
	lp5523_wait_opmode_done();
}
194

195 196 197
static void lp5523_turn_off_channels(struct lp55xx_chip *chip)
{
	int i;
198

199 200
	for (i = 0; i < LP5523_MAX_LEDS; i++)
		lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + i, 0);
201 202
}

203
static void lp5523_run_engine(struct lp55xx_chip *chip, bool start)
204
{
205 206 207
	int ret;
	u8 mode;
	u8 exec;
208

209 210 211 212 213 214
	/* stop engine */
	if (!start) {
		lp5523_stop_engine(chip);
		lp5523_turn_off_channels(chip);
		return;
	}
215

216 217 218 219
	/*
	 * To run the engine,
	 * operation mode and enable register should updated at the same time
	 */
220

221 222 223
	ret = lp55xx_read(chip, LP5523_REG_OP_MODE, &mode);
	if (ret)
		return;
224

225 226 227
	ret = lp55xx_read(chip, LP5523_REG_ENABLE, &exec);
	if (ret)
		return;
228

229 230 231 232 233
	/* change operation mode to RUN only when each engine is loading */
	if (LP5523_ENG1_IS_LOADING(mode)) {
		mode = (mode & ~LP5523_MODE_ENG1_M) | LP5523_RUN_ENG1;
		exec = (exec & ~LP5523_EXEC_ENG1_M) | LP5523_RUN_ENG1;
	}
234

235 236 237 238
	if (LP5523_ENG2_IS_LOADING(mode)) {
		mode = (mode & ~LP5523_MODE_ENG2_M) | LP5523_RUN_ENG2;
		exec = (exec & ~LP5523_EXEC_ENG2_M) | LP5523_RUN_ENG2;
	}
239

240 241 242 243 244 245 246 247 248
	if (LP5523_ENG3_IS_LOADING(mode)) {
		mode = (mode & ~LP5523_MODE_ENG3_M) | LP5523_RUN_ENG3;
		exec = (exec & ~LP5523_EXEC_ENG3_M) | LP5523_RUN_ENG3;
	}

	lp55xx_write(chip, LP5523_REG_OP_MODE, mode);
	lp5523_wait_opmode_done();

	lp55xx_update_bits(chip, LP5523_REG_ENABLE, LP5523_EXEC_M, exec);
249 250
}

251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308
static int lp5523_init_program_engine(struct lp55xx_chip *chip)
{
	int i;
	int j;
	int ret;
	u8 status;
	/* one pattern per engine setting LED MUX start and stop addresses */
	static const u8 pattern[][LP5523_PROGRAM_LENGTH] =  {
		{ 0x9c, 0x30, 0x9c, 0xb0, 0x9d, 0x80, 0xd8, 0x00, 0},
		{ 0x9c, 0x40, 0x9c, 0xc0, 0x9d, 0x80, 0xd8, 0x00, 0},
		{ 0x9c, 0x50, 0x9c, 0xd0, 0x9d, 0x80, 0xd8, 0x00, 0},
	};

	/* hardcode 32 bytes of memory for each engine from program memory */
	ret = lp55xx_write(chip, LP5523_REG_CH1_PROG_START, 0x00);
	if (ret)
		return ret;

	ret = lp55xx_write(chip, LP5523_REG_CH2_PROG_START, 0x10);
	if (ret)
		return ret;

	ret = lp55xx_write(chip, LP5523_REG_CH3_PROG_START, 0x20);
	if (ret)
		return ret;

	/* write LED MUX address space for each engine */
	for (i = LP55XX_ENGINE_1; i <= LP55XX_ENGINE_3; i++) {
		chip->engine_idx = i;
		lp5523_load_engine_and_select_page(chip);

		for (j = 0; j < LP5523_PROGRAM_LENGTH; j++) {
			ret = lp55xx_write(chip, LP5523_REG_PROG_MEM + j,
					pattern[i - 1][j]);
			if (ret)
				goto out;
		}
	}

	lp5523_run_engine(chip, true);

	/* Let the programs run for couple of ms and check the engine status */
	usleep_range(3000, 6000);
	lp55xx_read(chip, LP5523_REG_STATUS, &status);
	status &= LP5523_ENG_STATUS_MASK;

	if (status != LP5523_ENG_STATUS_MASK) {
		dev_err(&chip->cl->dev,
			"cound not configure LED engine, status = 0x%.2x\n",
			status);
		ret = -1;
	}

out:
	lp5523_stop_engine(chip);
	return ret;
}

309 310
static int lp5523_update_program_memory(struct lp55xx_chip *chip,
					const u8 *data, size_t size)
311
{
312 313 314 315 316 317 318
	u8 pattern[LP5523_PROGRAM_LENGTH] = {0};
	unsigned cmd;
	char c[3];
	int update_size;
	int nrchars;
	int offset = 0;
	int ret;
319 320
	int i;

321 322 323
	/* clear program memory before updating */
	for (i = 0; i < LP5523_PROGRAM_LENGTH; i++)
		lp55xx_write(chip, LP5523_REG_PROG_MEM + i, 0);
324

325 326 327 328 329 330
	i = 0;
	while ((offset < size - 1) && (i < LP5523_PROGRAM_LENGTH)) {
		/* separate sscanfs because length is working only for %s */
		ret = sscanf(data + offset, "%2s%n ", c, &nrchars);
		if (ret != 1)
			goto err;
331

332 333 334
		ret = sscanf(c, "%2x", &cmd);
		if (ret != 1)
			goto err;
335

336 337 338 339
		pattern[i] = (u8)cmd;
		offset += nrchars;
		i++;
	}
340

341 342 343
	/* Each instruction is 16bit long. Check that length is even */
	if (i % 2)
		goto err;
344

345
	update_size = i;
346

347 348 349 350 351 352 353 354 355 356 357 358 359
	mutex_lock(&chip->lock);

	for (i = 0; i < update_size; i++) {
		ret = lp55xx_write(chip, LP5523_REG_PROG_MEM + i, pattern[i]);
		if (ret) {
			mutex_unlock(&chip->lock);
			return -EINVAL;
		}
	}

	mutex_unlock(&chip->lock);

	return size;
360

361 362 363
err:
	dev_err(&chip->cl->dev, "wrong pattern format\n");
	return -EINVAL;
364 365
}

366
static void lp5523_firmware_loaded(struct lp55xx_chip *chip)
367
{
368
	const struct firmware *fw = chip->fw;
369

370 371 372 373 374
	if (fw->size > LP5523_PROGRAM_LENGTH) {
		dev_err(&chip->cl->dev, "firmware data size overflow: %zu\n",
			fw->size);
		return;
	}
375

376 377 378 379 380
	/*
	 * Program momery sequence
	 *  1) set engine mode to "LOAD"
	 *  2) write firmware data into program memory
	 */
381

382
	lp5523_load_engine_and_select_page(chip);
383
	lp5523_update_program_memory(chip, fw->data, fw->size);
384 385
}

386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571
static ssize_t show_engine_mode(struct device *dev,
				struct device_attribute *attr,
				char *buf, int nr)
{
	struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
	struct lp55xx_chip *chip = led->chip;
	enum lp55xx_engine_mode mode = chip->engines[nr - 1].mode;

	switch (mode) {
	case LP55XX_ENGINE_RUN:
		return sprintf(buf, "run\n");
	case LP55XX_ENGINE_LOAD:
		return sprintf(buf, "load\n");
	case LP55XX_ENGINE_DISABLED:
	default:
		return sprintf(buf, "disabled\n");
	}
}
show_mode(1)
show_mode(2)
show_mode(3)

static ssize_t store_engine_mode(struct device *dev,
				 struct device_attribute *attr,
				 const char *buf, size_t len, int nr)
{
	struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
	struct lp55xx_chip *chip = led->chip;
	struct lp55xx_engine *engine = &chip->engines[nr - 1];

	mutex_lock(&chip->lock);

	chip->engine_idx = nr;

	if (!strncmp(buf, "run", 3)) {
		lp5523_run_engine(chip, true);
		engine->mode = LP55XX_ENGINE_RUN;
	} else if (!strncmp(buf, "load", 4)) {
		lp5523_stop_engine(chip);
		lp5523_load_engine(chip);
		engine->mode = LP55XX_ENGINE_LOAD;
	} else if (!strncmp(buf, "disabled", 8)) {
		lp5523_stop_engine(chip);
		engine->mode = LP55XX_ENGINE_DISABLED;
	}

	mutex_unlock(&chip->lock);

	return len;
}
store_mode(1)
store_mode(2)
store_mode(3)

static int lp5523_mux_parse(const char *buf, u16 *mux, size_t len)
{
	u16 tmp_mux = 0;
	int i;

	len = min_t(int, len, LP5523_MAX_LEDS);

	for (i = 0; i < len; i++) {
		switch (buf[i]) {
		case '1':
			tmp_mux |= (1 << i);
			break;
		case '0':
			break;
		case '\n':
			i = len;
			break;
		default:
			return -1;
		}
	}
	*mux = tmp_mux;

	return 0;
}

static void lp5523_mux_to_array(u16 led_mux, char *array)
{
	int i, pos = 0;
	for (i = 0; i < LP5523_MAX_LEDS; i++)
		pos += sprintf(array + pos, "%x", LED_ACTIVE(led_mux, i));

	array[pos] = '\0';
}

static ssize_t show_engine_leds(struct device *dev,
			    struct device_attribute *attr,
			    char *buf, int nr)
{
	struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
	struct lp55xx_chip *chip = led->chip;
	char mux[LP5523_MAX_LEDS + 1];

	lp5523_mux_to_array(chip->engines[nr - 1].led_mux, mux);

	return sprintf(buf, "%s\n", mux);
}
show_leds(1)
show_leds(2)
show_leds(3)

static int lp5523_load_mux(struct lp55xx_chip *chip, u16 mux, int nr)
{
	struct lp55xx_engine *engine = &chip->engines[nr - 1];
	int ret;
	u8 mux_page[] = {
		[LP55XX_ENGINE_1] = LP5523_PAGE_MUX1,
		[LP55XX_ENGINE_2] = LP5523_PAGE_MUX2,
		[LP55XX_ENGINE_3] = LP5523_PAGE_MUX3,
	};

	lp5523_load_engine(chip);

	ret = lp55xx_write(chip, LP5523_REG_PROG_PAGE_SEL, mux_page[nr]);
	if (ret)
		return ret;

	ret = lp55xx_write(chip, LP5523_REG_PROG_MEM , (u8)(mux >> 8));
	if (ret)
		return ret;

	ret = lp55xx_write(chip, LP5523_REG_PROG_MEM + 1, (u8)(mux));
	if (ret)
		return ret;

	engine->led_mux = mux;
	return 0;
}

static ssize_t store_engine_leds(struct device *dev,
			     struct device_attribute *attr,
			     const char *buf, size_t len, int nr)
{
	struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
	struct lp55xx_chip *chip = led->chip;
	struct lp55xx_engine *engine = &chip->engines[nr - 1];
	u16 mux = 0;
	ssize_t ret;

	if (lp5523_mux_parse(buf, &mux, len))
		return -EINVAL;

	mutex_lock(&chip->lock);

	chip->engine_idx = nr;
	ret = -EINVAL;

	if (engine->mode != LP55XX_ENGINE_LOAD)
		goto leave;

	if (lp5523_load_mux(chip, mux, nr))
		goto leave;

	ret = len;
leave:
	mutex_unlock(&chip->lock);
	return ret;
}
store_leds(1)
store_leds(2)
store_leds(3)

static ssize_t store_engine_load(struct device *dev,
			     struct device_attribute *attr,
			     const char *buf, size_t len, int nr)
{
	struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
	struct lp55xx_chip *chip = led->chip;

	mutex_lock(&chip->lock);

	chip->engine_idx = nr;
	lp5523_load_engine_and_select_page(chip);

	mutex_unlock(&chip->lock);

	return lp5523_update_program_memory(chip, buf, len);
}
store_load(1)
store_load(2)
store_load(3)

572 573 574 575
static ssize_t lp5523_selftest(struct device *dev,
			       struct device_attribute *attr,
			       char *buf)
{
576 577 578
	struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
	struct lp55xx_chip *chip = led->chip;
	struct lp55xx_platform_data *pdata = chip->pdata;
579 580 581 582 583
	int i, ret, pos = 0;
	u8 status, adc, vdd;

	mutex_lock(&chip->lock);

584
	ret = lp55xx_read(chip, LP5523_REG_STATUS, &status);
585 586 587 588
	if (ret < 0)
		goto fail;

	/* Check that ext clock is really in use if requested */
589
	if (pdata->clock_mode == LP55XX_CLOCK_EXT) {
590 591
		if  ((status & LP5523_EXT_CLK_USED) == 0)
			goto fail;
592
	}
593 594

	/* Measure VDD (i.e. VBAT) first (channel 16 corresponds to VDD) */
595
	lp55xx_write(chip, LP5523_REG_LED_TEST_CTRL, LP5523_EN_LEDTEST | 16);
596
	usleep_range(3000, 6000); /* ADC conversion time is typically 2.7 ms */
597
	ret = lp55xx_read(chip, LP5523_REG_STATUS, &status);
598 599 600
	if (ret < 0)
		goto fail;

601
	if (!(status & LP5523_LEDTEST_DONE))
602
		usleep_range(3000, 6000); /* Was not ready. Wait little bit */
603

604
	ret = lp55xx_read(chip, LP5523_REG_LED_TEST_ADC, &vdd);
605 606 607
	if (ret < 0)
		goto fail;

608 609
	vdd--;	/* There may be some fluctuation in measurement */

610
	for (i = 0; i < LP5523_MAX_LEDS; i++) {
611
		/* Skip non-existing channels */
612
		if (pdata->led_config[i].led_current == 0)
613 614 615
			continue;

		/* Set default current */
616 617
		lp55xx_write(chip, LP5523_REG_LED_CURRENT_BASE + i,
			pdata->led_config[i].led_current);
618

619
		lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + i, 0xff);
620 621
		/* let current stabilize 2 - 4ms before measurements start */
		usleep_range(2000, 4000);
622
		lp55xx_write(chip, LP5523_REG_LED_TEST_CTRL,
623
			     LP5523_EN_LEDTEST | i);
624 625
		/* ADC conversion time is 2.7 ms typically */
		usleep_range(3000, 6000);
626
		ret = lp55xx_read(chip, LP5523_REG_STATUS, &status);
627 628 629
		if (ret < 0)
			goto fail;

630
		if (!(status & LP5523_LEDTEST_DONE))
631
			usleep_range(3000, 6000);/* Was not ready. Wait. */
632 633

		ret = lp55xx_read(chip, LP5523_REG_LED_TEST_ADC, &adc);
634 635
		if (ret < 0)
			goto fail;
636 637 638 639

		if (adc >= vdd || adc < LP5523_ADC_SHORTCIRC_LIM)
			pos += sprintf(buf + pos, "LED %d FAIL\n", i);

640
		lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + i, 0x00);
641 642

		/* Restore current */
643 644
		lp55xx_write(chip, LP5523_REG_LED_CURRENT_BASE + i,
			led->led_current);
645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660
		led++;
	}
	if (pos == 0)
		pos = sprintf(buf, "OK\n");
	goto release_lock;
fail:
	pos = sprintf(buf, "FAIL\n");

release_lock:
	mutex_unlock(&chip->lock);

	return pos;
}

static void lp5523_led_brightness_work(struct work_struct *work)
{
661
	struct lp55xx_led *led = container_of(work, struct lp55xx_led,
662
					      brightness_work);
663
	struct lp55xx_chip *chip = led->chip;
664 665

	mutex_lock(&chip->lock);
666
	lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + led->chan_nr,
667 668 669 670
		     led->brightness);
	mutex_unlock(&chip->lock);
}

671 672 673 674 675 676 677 678 679 680
static LP55XX_DEV_ATTR_RW(engine1_mode, show_engine1_mode, store_engine1_mode);
static LP55XX_DEV_ATTR_RW(engine2_mode, show_engine2_mode, store_engine2_mode);
static LP55XX_DEV_ATTR_RW(engine3_mode, show_engine3_mode, store_engine3_mode);
static LP55XX_DEV_ATTR_RW(engine1_leds, show_engine1_leds, store_engine1_leds);
static LP55XX_DEV_ATTR_RW(engine2_leds, show_engine2_leds, store_engine2_leds);
static LP55XX_DEV_ATTR_RW(engine3_leds, show_engine3_leds, store_engine3_leds);
static LP55XX_DEV_ATTR_WO(engine1_load, store_engine1_load);
static LP55XX_DEV_ATTR_WO(engine2_load, store_engine2_load);
static LP55XX_DEV_ATTR_WO(engine3_load, store_engine3_load);
static LP55XX_DEV_ATTR_RO(selftest, lp5523_selftest);
681 682

static struct attribute *lp5523_attributes[] = {
683 684 685 686 687 688 689 690 691
	&dev_attr_engine1_mode.attr,
	&dev_attr_engine2_mode.attr,
	&dev_attr_engine3_mode.attr,
	&dev_attr_engine1_load.attr,
	&dev_attr_engine2_load.attr,
	&dev_attr_engine3_load.attr,
	&dev_attr_engine1_leds.attr,
	&dev_attr_engine2_leds.attr,
	&dev_attr_engine3_leds.attr,
692
	&dev_attr_selftest.attr,
693
	NULL,
694 695 696 697 698 699
};

static const struct attribute_group lp5523_group = {
	.attrs = lp5523_attributes,
};

700 701 702 703 704 705
/* Chip specific configurations */
static struct lp55xx_device_config lp5523_cfg = {
	.reset = {
		.addr = LP5523_REG_RESET,
		.val  = LP5523_RESET,
	},
706 707 708 709
	.enable = {
		.addr = LP5523_REG_ENABLE,
		.val  = LP5523_ENABLE,
	},
710
	.max_channel  = LP5523_MAX_LEDS,
711
	.post_init_device   = lp5523_post_init_device,
712
	.brightness_work_fn = lp5523_led_brightness_work,
713
	.set_led_current    = lp5523_set_led_current,
714 715
	.firmware_cb        = lp5523_firmware_loaded,
	.run_engine         = lp5523_run_engine,
716
	.dev_attr_group     = &lp5523_group,
717 718
};

719
static int lp5523_probe(struct i2c_client *client,
720 721
			const struct i2c_device_id *id)
{
722
	int ret;
723 724
	struct lp55xx_chip *chip;
	struct lp55xx_led *led;
725 726 727
	struct lp55xx_platform_data *pdata;
	struct device_node *np = client->dev.of_node;

J
Jingoo Han 已提交
728
	if (!dev_get_platdata(&client->dev)) {
729 730 731 732 733 734 735 736
		if (np) {
			ret = lp55xx_of_populate_pdata(&client->dev, np);
			if (ret < 0)
				return ret;
		} else {
			dev_err(&client->dev, "no platform data\n");
			return -EINVAL;
		}
737
	}
J
Jingoo Han 已提交
738
	pdata = dev_get_platdata(&client->dev);
739

740 741 742 743 744 745 746 747 748 749 750
	chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
	if (!chip)
		return -ENOMEM;

	led = devm_kzalloc(&client->dev,
			sizeof(*led) * pdata->num_channels, GFP_KERNEL);
	if (!led)
		return -ENOMEM;

	chip->cl = client;
	chip->pdata = pdata;
751
	chip->cfg = &lp5523_cfg;
752 753

	mutex_init(&chip->lock);
754

755
	i2c_set_clientdata(client, led);
756

757
	ret = lp55xx_init_device(chip);
758
	if (ret)
759
		goto err_init;
760

761
	dev_info(&client->dev, "%s Programmable led chip found\n", id->name);
762

763
	ret = lp55xx_register_leds(led, chip);
764
	if (ret)
765
		goto err_register_leds;
766

767
	ret = lp55xx_register_sysfs(chip);
768 769
	if (ret) {
		dev_err(&client->dev, "registering sysfs failed\n");
770
		goto err_register_sysfs;
771
	}
772 773 774 775

	return 0;

err_register_sysfs:
776
	lp55xx_unregister_leds(led, chip);
777
err_register_leds:
778
	lp55xx_deinit_device(chip);
779
err_init:
780 781 782 783 784
	return ret;
}

static int lp5523_remove(struct i2c_client *client)
{
785 786
	struct lp55xx_led *led = i2c_get_clientdata(client);
	struct lp55xx_chip *chip = led->chip;
787

788 789
	lp5523_stop_engine(chip);
	lp55xx_unregister_sysfs(chip);
790
	lp55xx_unregister_leds(led, chip);
791
	lp55xx_deinit_device(chip);
792 793 794 795 796

	return 0;
}

static const struct i2c_device_id lp5523_id[] = {
797 798
	{ "lp5523",  LP5523 },
	{ "lp55231", LP55231 },
799 800 801 802 803
	{ }
};

MODULE_DEVICE_TABLE(i2c, lp5523_id);

804 805 806 807 808 809 810 811 812
#ifdef CONFIG_OF
static const struct of_device_id of_lp5523_leds_match[] = {
	{ .compatible = "national,lp5523", },
	{},
};

MODULE_DEVICE_TABLE(of, of_lp5523_leds_match);
#endif

813 814
static struct i2c_driver lp5523_driver = {
	.driver = {
815
		.name	= "lp5523x",
816
		.of_match_table = of_match_ptr(of_lp5523_leds_match),
817 818 819 820 821 822
	},
	.probe		= lp5523_probe,
	.remove		= lp5523_remove,
	.id_table	= lp5523_id,
};

823
module_i2c_driver(lp5523_driver);
824 825

MODULE_AUTHOR("Mathias Nyman <mathias.nyman@nokia.com>");
826
MODULE_AUTHOR("Milo Kim <milo.kim@ti.com>");
827 828
MODULE_DESCRIPTION("LP5523 LED engine");
MODULE_LICENSE("GPL");
新手
引导
客服 返回
顶部