Blame view
drivers/leds/leds-lp5523.c
23.8 KB
0efba16cc
|
1 |
/* |
9ef8c877e
|
2 |
* lp5523.c - LP5523, LP55231 LED Driver |
0efba16cc
|
3 4 |
* * Copyright (C) 2010 Nokia Corporation |
a2387cb9f
|
5 |
* Copyright (C) 2012 Texas Instruments |
0efba16cc
|
6 7 |
* * Contact: Samu Onkalo <samu.p.onkalo@nokia.com> |
a2387cb9f
|
8 |
* Milo(Woogyom) Kim <milo.kim@ti.com> |
0efba16cc
|
9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
* * 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 */ |
0efba16cc
|
24 |
#include <linux/delay.h> |
79bcc10b8
|
25 26 |
#include <linux/firmware.h> #include <linux/i2c.h> |
0efba16cc
|
27 |
#include <linux/leds.h> |
79bcc10b8
|
28 29 |
#include <linux/module.h> #include <linux/mutex.h> |
c68f46dd6
|
30 |
#include <linux/of.h> |
6a0c9a479
|
31 |
#include <linux/platform_data/leds-lp55xx.h> |
79bcc10b8
|
32 |
#include <linux/slab.h> |
6a0c9a479
|
33 34 |
#include "leds-lp55xx-common.h" |
0efba16cc
|
35 |
|
bfb18d824
|
36 37 38 39 40 41 42 43 44 |
#define LP5523_PROGRAM_LENGTH 32 /* bytes */ /* Memory is used like this: 0x00 engine 1 program 0x10 engine 2 program 0x20 engine 3 program 0x30 engine 1 muxing info 0x40 engine 2 muxing info 0x50 engine 3 muxing info */ |
12f022d27
|
45 46 47 |
#define LP5523_MAX_LEDS 9 /* Registers */ |
0efba16cc
|
48 49 |
#define LP5523_REG_ENABLE 0x00 #define LP5523_REG_OP_MODE 0x01 |
0efba16cc
|
50 51 |
#define LP5523_REG_ENABLE_LEDS_MSB 0x04 #define LP5523_REG_ENABLE_LEDS_LSB 0x05 |
52da81eaf
|
52 |
#define LP5523_REG_LED_CTRL_BASE 0x06 |
0efba16cc
|
53 54 55 |
#define LP5523_REG_LED_PWM_BASE 0x16 #define LP5523_REG_LED_CURRENT_BASE 0x26 #define LP5523_REG_CONFIG 0x36 |
12f022d27
|
56 57 |
#define LP5523_REG_STATUS 0x3A #define LP5523_REG_RESET 0x3D |
0efba16cc
|
58 59 |
#define LP5523_REG_LED_TEST_CTRL 0x41 #define LP5523_REG_LED_TEST_ADC 0x42 |
52da81eaf
|
60 |
#define LP5523_REG_MASTER_FADER_BASE 0x48 |
224604389
|
61 62 63 |
#define LP5523_REG_CH1_PROG_START 0x4C #define LP5523_REG_CH2_PROG_START 0x4D #define LP5523_REG_CH3_PROG_START 0x4E |
12f022d27
|
64 |
#define LP5523_REG_PROG_PAGE_SEL 0x4F |
0efba16cc
|
65 |
#define LP5523_REG_PROG_MEM 0x50 |
12f022d27
|
66 |
/* Bit description in registers */ |
0efba16cc
|
67 68 69 70 |
#define LP5523_ENABLE 0x40 #define LP5523_AUTO_INC 0x40 #define LP5523_PWR_SAVE 0x20 #define LP5523_PWM_PWR_SAVE 0x04 |
0efba16cc
|
71 |
#define LP5523_CP_AUTO 0x18 |
0efba16cc
|
72 |
#define LP5523_AUTO_CLK 0x02 |
12f022d27
|
73 |
|
0efba16cc
|
74 75 |
#define LP5523_EN_LEDTEST 0x80 #define LP5523_LEDTEST_DONE 0x80 |
48068d5de
|
76 |
#define LP5523_RESET 0xFF |
0efba16cc
|
77 |
#define LP5523_ADC_SHORTCIRC_LIM 80 |
0efba16cc
|
78 |
#define LP5523_EXT_CLK_USED 0x08 |
224604389
|
79 |
#define LP5523_ENG_STATUS_MASK 0x07 |
0efba16cc
|
80 |
|
52da81eaf
|
81 82 |
#define LP5523_FADER_MAPPING_MASK 0xC0 #define LP5523_FADER_MAPPING_SHIFT 6 |
db6eaf838
|
83 84 85 86 |
/* Memory Page Selection */ #define LP5523_PAGE_ENG1 0 #define LP5523_PAGE_ENG2 1 #define LP5523_PAGE_ENG3 2 |
45e611bfb
|
87 88 89 |
#define LP5523_PAGE_MUX1 3 #define LP5523_PAGE_MUX2 4 #define LP5523_PAGE_MUX3 5 |
db6eaf838
|
90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 |
/* 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 |
45e611bfb
|
113 |
#define LED_ACTIVE(mux, led) (!!(mux & (0x0001 << led))) |
27d7704e5
|
114 115 116 117 |
enum lp5523_chip_id { LP5523, LP55231, }; |
224604389
|
118 |
static int lp5523_init_program_engine(struct lp55xx_chip *chip); |
db6eaf838
|
119 120 121 122 |
static inline void lp5523_wait_opmode_done(void) { usleep_range(1000, 2000); } |
a96bfa135
|
123 124 125 126 127 128 |
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); } |
ffbdccdbb
|
129 |
static int lp5523_post_init_device(struct lp55xx_chip *chip) |
0efba16cc
|
130 |
{ |
ffbdccdbb
|
131 |
int ret; |
0efba16cc
|
132 |
|
ffbdccdbb
|
133 |
ret = lp55xx_write(chip, LP5523_REG_ENABLE, LP5523_ENABLE); |
632418bf6
|
134 135 |
if (ret) return ret; |
0efba16cc
|
136 |
|
2e4840edb
|
137 138 |
/* Chip startup time is 500 us, 1 - 2 ms gives some margin */ usleep_range(1000, 2000); |
0efba16cc
|
139 |
|
ffbdccdbb
|
140 |
ret = lp55xx_write(chip, LP5523_REG_CONFIG, |
0efba16cc
|
141 142 143 |
LP5523_AUTO_INC | LP5523_PWR_SAVE | LP5523_CP_AUTO | LP5523_AUTO_CLK | LP5523_PWM_PWR_SAVE); |
632418bf6
|
144 145 |
if (ret) return ret; |
0efba16cc
|
146 147 |
/* turn on all leds */ |
ffbdccdbb
|
148 |
ret = lp55xx_write(chip, LP5523_REG_ENABLE_LEDS_MSB, 0x01); |
632418bf6
|
149 |
if (ret) |
1b21ec5a2
|
150 |
return ret; |
224604389
|
151 152 153 154 155 |
ret = lp55xx_write(chip, LP5523_REG_ENABLE_LEDS_LSB, 0xff); if (ret) return ret; return lp5523_init_program_engine(chip); |
0efba16cc
|
156 |
} |
db6eaf838
|
157 |
static void lp5523_load_engine(struct lp55xx_chip *chip) |
0efba16cc
|
158 |
{ |
db6eaf838
|
159 |
enum lp55xx_engine_index idx = chip->engine_idx; |
4d1707c1c
|
160 |
static const u8 mask[] = { |
db6eaf838
|
161 162 163 164 |
[LP55XX_ENGINE_1] = LP5523_MODE_ENG1_M, [LP55XX_ENGINE_2] = LP5523_MODE_ENG2_M, [LP55XX_ENGINE_3] = LP5523_MODE_ENG3_M, }; |
4d1707c1c
|
165 |
static const u8 val[] = { |
db6eaf838
|
166 167 168 169 |
[LP55XX_ENGINE_1] = LP5523_LOAD_ENG1, [LP55XX_ENGINE_2] = LP5523_LOAD_ENG2, [LP55XX_ENGINE_3] = LP5523_LOAD_ENG3, }; |
b9e1730b2
|
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; |
4d1707c1c
|
178 |
static const u8 page_sel[] = { |
db6eaf838
|
179 180 181 182 |
[LP55XX_ENGINE_1] = LP5523_PAGE_ENG1, [LP55XX_ENGINE_2] = LP5523_PAGE_ENG2, [LP55XX_ENGINE_3] = LP5523_PAGE_ENG3, }; |
b9e1730b2
|
183 |
lp5523_load_engine(chip); |
db6eaf838
|
184 185 |
lp55xx_write(chip, LP5523_REG_PROG_PAGE_SEL, page_sel[idx]); |
0efba16cc
|
186 |
} |
28c9266b3
|
187 |
static void lp5523_stop_all_engines(struct lp55xx_chip *chip) |
0efba16cc
|
188 |
{ |
db6eaf838
|
189 190 191 |
lp55xx_write(chip, LP5523_REG_OP_MODE, 0); lp5523_wait_opmode_done(); } |
0efba16cc
|
192 |
|
28c9266b3
|
193 194 195 |
static void lp5523_stop_engine(struct lp55xx_chip *chip) { enum lp55xx_engine_index idx = chip->engine_idx; |
4d1707c1c
|
196 |
static const u8 mask[] = { |
28c9266b3
|
197 198 199 200 201 202 203 204 205 |
[LP55XX_ENGINE_1] = LP5523_MODE_ENG1_M, [LP55XX_ENGINE_2] = LP5523_MODE_ENG2_M, [LP55XX_ENGINE_3] = LP5523_MODE_ENG3_M, }; lp55xx_update_bits(chip, LP5523_REG_OP_MODE, mask[idx], 0); lp5523_wait_opmode_done(); } |
db6eaf838
|
206 207 208 |
static void lp5523_turn_off_channels(struct lp55xx_chip *chip) { int i; |
0efba16cc
|
209 |
|
db6eaf838
|
210 211 |
for (i = 0; i < LP5523_MAX_LEDS; i++) lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + i, 0); |
0efba16cc
|
212 |
} |
db6eaf838
|
213 |
static void lp5523_run_engine(struct lp55xx_chip *chip, bool start) |
0efba16cc
|
214 |
{ |
db6eaf838
|
215 216 217 |
int ret; u8 mode; u8 exec; |
0efba16cc
|
218 |
|
db6eaf838
|
219 220 221 222 223 224 |
/* stop engine */ if (!start) { lp5523_stop_engine(chip); lp5523_turn_off_channels(chip); return; } |
0efba16cc
|
225 |
|
db6eaf838
|
226 227 228 229 |
/* * To run the engine, * operation mode and enable register should updated at the same time */ |
0efba16cc
|
230 |
|
db6eaf838
|
231 232 233 |
ret = lp55xx_read(chip, LP5523_REG_OP_MODE, &mode); if (ret) return; |
0efba16cc
|
234 |
|
db6eaf838
|
235 236 237 |
ret = lp55xx_read(chip, LP5523_REG_ENABLE, &exec); if (ret) return; |
0efba16cc
|
238 |
|
db6eaf838
|
239 240 241 242 243 |
/* 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; } |
0efba16cc
|
244 |
|
db6eaf838
|
245 246 247 248 |
if (LP5523_ENG2_IS_LOADING(mode)) { mode = (mode & ~LP5523_MODE_ENG2_M) | LP5523_RUN_ENG2; exec = (exec & ~LP5523_EXEC_ENG2_M) | LP5523_RUN_ENG2; } |
0efba16cc
|
249 |
|
db6eaf838
|
250 251 252 253 254 255 256 257 258 |
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); |
0efba16cc
|
259 |
} |
224604389
|
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 |
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, |
f2ea85d76
|
308 309 |
"could not configure LED engine, status = 0x%.2x ", |
224604389
|
310 311 312 313 314 |
status); ret = -1; } out: |
28c9266b3
|
315 |
lp5523_stop_all_engines(chip); |
224604389
|
316 317 |
return ret; } |
db6eaf838
|
318 319 |
static int lp5523_update_program_memory(struct lp55xx_chip *chip, const u8 *data, size_t size) |
0efba16cc
|
320 |
{ |
db6eaf838
|
321 322 323 |
u8 pattern[LP5523_PROGRAM_LENGTH] = {0}; unsigned cmd; char c[3]; |
db6eaf838
|
324 |
int nrchars; |
db6eaf838
|
325 |
int ret; |
2f733cad3
|
326 327 |
int offset = 0; int i = 0; |
0efba16cc
|
328 |
|
db6eaf838
|
329 330 331 332 333 |
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; |
0efba16cc
|
334 |
|
db6eaf838
|
335 336 337 |
ret = sscanf(c, "%2x", &cmd); if (ret != 1) goto err; |
0efba16cc
|
338 |
|
db6eaf838
|
339 340 341 342 |
pattern[i] = (u8)cmd; offset += nrchars; i++; } |
0efba16cc
|
343 |
|
db6eaf838
|
344 345 346 |
/* Each instruction is 16bit long. Check that length is even */ if (i % 2) goto err; |
0efba16cc
|
347 |
|
2f733cad3
|
348 |
for (i = 0; i < LP5523_PROGRAM_LENGTH; i++) { |
45e611bfb
|
349 |
ret = lp55xx_write(chip, LP5523_REG_PROG_MEM + i, pattern[i]); |
e70988d1a
|
350 |
if (ret) |
45e611bfb
|
351 |
return -EINVAL; |
45e611bfb
|
352 |
} |
45e611bfb
|
353 |
return size; |
0efba16cc
|
354 |
|
db6eaf838
|
355 356 357 358 |
err: dev_err(&chip->cl->dev, "wrong pattern format "); return -EINVAL; |
0efba16cc
|
359 |
} |
0efba16cc
|
360 |
|
db6eaf838
|
361 |
static void lp5523_firmware_loaded(struct lp55xx_chip *chip) |
0efba16cc
|
362 |
{ |
db6eaf838
|
363 |
const struct firmware *fw = chip->fw; |
fbac0812d
|
364 |
|
db6eaf838
|
365 366 367 368 369 370 |
if (fw->size > LP5523_PROGRAM_LENGTH) { dev_err(&chip->cl->dev, "firmware data size overflow: %zu ", fw->size); return; } |
0efba16cc
|
371 |
|
db6eaf838
|
372 |
/* |
d1b7c9344
|
373 |
* Program memory sequence |
db6eaf838
|
374 375 376 |
* 1) set engine mode to "LOAD" * 2) write firmware data into program memory */ |
0efba16cc
|
377 |
|
b9e1730b2
|
378 |
lp5523_load_engine_and_select_page(chip); |
db6eaf838
|
379 |
lp5523_update_program_memory(chip, fw->data, fw->size); |
0efba16cc
|
380 |
} |
0efba16cc
|
381 |
|
45e611bfb
|
382 383 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 |
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 "); case LP55XX_ENGINE_LOAD: return sprintf(buf, "load "); case LP55XX_ENGINE_DISABLED: default: return sprintf(buf, "disabled "); } } 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 ' ': 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 ", 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; |
4d1707c1c
|
496 |
static const u8 mux_page[] = { |
45e611bfb
|
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 |
[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; |
e70988d1a
|
559 |
int ret; |
45e611bfb
|
560 561 562 563 564 |
mutex_lock(&chip->lock); chip->engine_idx = nr; lp5523_load_engine_and_select_page(chip); |
e70988d1a
|
565 |
ret = lp5523_update_program_memory(chip, buf, len); |
45e611bfb
|
566 567 |
mutex_unlock(&chip->lock); |
e70988d1a
|
568 |
return ret; |
45e611bfb
|
569 570 571 572 |
} store_load(1) store_load(2) store_load(3) |
0efba16cc
|
573 574 575 576 |
static ssize_t lp5523_selftest(struct device *dev, struct device_attribute *attr, char *buf) { |
9ca3bd802
|
577 578 579 |
struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev)); struct lp55xx_chip *chip = led->chip; struct lp55xx_platform_data *pdata = chip->pdata; |
0efba16cc
|
580 |
int i, ret, pos = 0; |
0efba16cc
|
581 582 583 |
u8 status, adc, vdd; mutex_lock(&chip->lock); |
9ca3bd802
|
584 |
ret = lp55xx_read(chip, LP5523_REG_STATUS, &status); |
0efba16cc
|
585 586 587 588 |
if (ret < 0) goto fail; /* Check that ext clock is really in use if requested */ |
9ca3bd802
|
589 |
if (pdata->clock_mode == LP55XX_CLOCK_EXT) { |
0efba16cc
|
590 591 |
if ((status & LP5523_EXT_CLK_USED) == 0) goto fail; |
9ca3bd802
|
592 |
} |
0efba16cc
|
593 594 |
/* Measure VDD (i.e. VBAT) first (channel 16 corresponds to VDD) */ |
9ca3bd802
|
595 |
lp55xx_write(chip, LP5523_REG_LED_TEST_CTRL, LP5523_EN_LEDTEST | 16); |
2e4840edb
|
596 |
usleep_range(3000, 6000); /* ADC conversion time is typically 2.7 ms */ |
9ca3bd802
|
597 |
ret = lp55xx_read(chip, LP5523_REG_STATUS, &status); |
1b21ec5a2
|
598 599 |
if (ret < 0) goto fail; |
0efba16cc
|
600 |
if (!(status & LP5523_LEDTEST_DONE)) |
2e4840edb
|
601 |
usleep_range(3000, 6000); /* Was not ready. Wait little bit */ |
0efba16cc
|
602 |
|
9ca3bd802
|
603 |
ret = lp55xx_read(chip, LP5523_REG_LED_TEST_ADC, &vdd); |
1b21ec5a2
|
604 605 |
if (ret < 0) goto fail; |
0efba16cc
|
606 |
vdd--; /* There may be some fluctuation in measurement */ |
0e2023463
|
607 |
for (i = 0; i < LP5523_MAX_LEDS; i++) { |
0efba16cc
|
608 |
/* Skip non-existing channels */ |
9ca3bd802
|
609 |
if (pdata->led_config[i].led_current == 0) |
0efba16cc
|
610 611 612 |
continue; /* Set default current */ |
9ca3bd802
|
613 614 |
lp55xx_write(chip, LP5523_REG_LED_CURRENT_BASE + i, pdata->led_config[i].led_current); |
0efba16cc
|
615 |
|
9ca3bd802
|
616 |
lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + i, 0xff); |
2e4840edb
|
617 618 |
/* let current stabilize 2 - 4ms before measurements start */ usleep_range(2000, 4000); |
9ca3bd802
|
619 |
lp55xx_write(chip, LP5523_REG_LED_TEST_CTRL, |
0efba16cc
|
620 |
LP5523_EN_LEDTEST | i); |
2e4840edb
|
621 622 |
/* ADC conversion time is 2.7 ms typically */ usleep_range(3000, 6000); |
9ca3bd802
|
623 |
ret = lp55xx_read(chip, LP5523_REG_STATUS, &status); |
1b21ec5a2
|
624 625 |
if (ret < 0) goto fail; |
0efba16cc
|
626 |
if (!(status & LP5523_LEDTEST_DONE)) |
2e4840edb
|
627 |
usleep_range(3000, 6000);/* Was not ready. Wait. */ |
9ca3bd802
|
628 629 |
ret = lp55xx_read(chip, LP5523_REG_LED_TEST_ADC, &adc); |
1b21ec5a2
|
630 631 |
if (ret < 0) goto fail; |
0efba16cc
|
632 633 634 635 |
if (adc >= vdd || adc < LP5523_ADC_SHORTCIRC_LIM) pos += sprintf(buf + pos, "LED %d FAIL ", i); |
9ca3bd802
|
636 |
lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + i, 0x00); |
0efba16cc
|
637 638 |
/* Restore current */ |
9ca3bd802
|
639 640 |
lp55xx_write(chip, LP5523_REG_LED_CURRENT_BASE + i, led->led_current); |
0efba16cc
|
641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 |
led++; } if (pos == 0) pos = sprintf(buf, "OK "); goto release_lock; fail: pos = sprintf(buf, "FAIL "); release_lock: mutex_unlock(&chip->lock); return pos; } |
52da81eaf
|
656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 |
#define show_fader(nr) \ static ssize_t show_master_fader##nr(struct device *dev, \ struct device_attribute *attr, \ char *buf) \ { \ return show_master_fader(dev, attr, buf, nr); \ } #define store_fader(nr) \ static ssize_t store_master_fader##nr(struct device *dev, \ struct device_attribute *attr, \ const char *buf, size_t len) \ { \ return store_master_fader(dev, attr, buf, len, nr); \ } static ssize_t show_master_fader(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; int ret; u8 val; mutex_lock(&chip->lock); ret = lp55xx_read(chip, LP5523_REG_MASTER_FADER_BASE + nr - 1, &val); mutex_unlock(&chip->lock); if (ret == 0) ret = sprintf(buf, "%u ", val); return ret; } show_fader(1) show_fader(2) show_fader(3) static ssize_t store_master_fader(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; int ret; unsigned long val; if (kstrtoul(buf, 0, &val)) return -EINVAL; if (val > 0xff) return -EINVAL; mutex_lock(&chip->lock); ret = lp55xx_write(chip, LP5523_REG_MASTER_FADER_BASE + nr - 1, (u8)val); mutex_unlock(&chip->lock); if (ret == 0) ret = len; return ret; } store_fader(1) store_fader(2) store_fader(3) static ssize_t show_master_fader_leds(struct device *dev, struct device_attribute *attr, char *buf) { struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev)); struct lp55xx_chip *chip = led->chip; int i, ret, pos = 0; u8 val; mutex_lock(&chip->lock); for (i = 0; i < LP5523_MAX_LEDS; i++) { ret = lp55xx_read(chip, LP5523_REG_LED_CTRL_BASE + i, &val); if (ret) goto leave; val = (val & LP5523_FADER_MAPPING_MASK) >> LP5523_FADER_MAPPING_SHIFT; if (val > 3) { ret = -EINVAL; goto leave; } buf[pos++] = val + '0'; } buf[pos++] = ' '; ret = pos; leave: mutex_unlock(&chip->lock); return ret; } static ssize_t store_master_fader_leds(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev)); struct lp55xx_chip *chip = led->chip; int i, n, ret; u8 val; n = min_t(int, len, LP5523_MAX_LEDS); mutex_lock(&chip->lock); for (i = 0; i < n; i++) { if (buf[i] >= '0' && buf[i] <= '3') { val = (buf[i] - '0') << LP5523_FADER_MAPPING_SHIFT; ret = lp55xx_update_bits(chip, LP5523_REG_LED_CTRL_BASE + i, LP5523_FADER_MAPPING_MASK, val); if (ret) goto leave; } else { ret = -EINVAL; goto leave; } } ret = len; leave: mutex_unlock(&chip->lock); return ret; } |
95b2af637
|
788 |
static int lp5523_led_brightness(struct lp55xx_led *led) |
0efba16cc
|
789 |
{ |
a6e4679a0
|
790 |
struct lp55xx_chip *chip = led->chip; |
95b2af637
|
791 |
int ret; |
0efba16cc
|
792 793 |
mutex_lock(&chip->lock); |
95b2af637
|
794 |
ret = lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + led->chan_nr, |
0efba16cc
|
795 |
led->brightness); |
0efba16cc
|
796 |
mutex_unlock(&chip->lock); |
95b2af637
|
797 |
return ret; |
0efba16cc
|
798 |
} |
45e611bfb
|
799 800 801 802 803 804 805 806 807 808 |
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); |
52da81eaf
|
809 810 811 812 813 814 815 816 |
static LP55XX_DEV_ATTR_RW(master_fader1, show_master_fader1, store_master_fader1); static LP55XX_DEV_ATTR_RW(master_fader2, show_master_fader2, store_master_fader2); static LP55XX_DEV_ATTR_RW(master_fader3, show_master_fader3, store_master_fader3); static LP55XX_DEV_ATTR_RW(master_fader_leds, show_master_fader_leds, store_master_fader_leds); |
0efba16cc
|
817 818 |
static struct attribute *lp5523_attributes[] = { |
45e611bfb
|
819 820 821 822 823 824 825 826 827 |
&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, |
0efba16cc
|
828 |
&dev_attr_selftest.attr, |
52da81eaf
|
829 830 831 832 |
&dev_attr_master_fader1.attr, &dev_attr_master_fader2.attr, &dev_attr_master_fader3.attr, &dev_attr_master_fader_leds.attr, |
f16258423
|
833 |
NULL, |
0efba16cc
|
834 835 836 837 838 |
}; static const struct attribute_group lp5523_group = { .attrs = lp5523_attributes, }; |
48068d5de
|
839 840 841 842 843 844 |
/* Chip specific configurations */ static struct lp55xx_device_config lp5523_cfg = { .reset = { .addr = LP5523_REG_RESET, .val = LP5523_RESET, }, |
e3a700d8a
|
845 846 847 848 |
.enable = { .addr = LP5523_REG_ENABLE, .val = LP5523_ENABLE, }, |
0e2023463
|
849 |
.max_channel = LP5523_MAX_LEDS, |
ffbdccdbb
|
850 |
.post_init_device = lp5523_post_init_device, |
95b2af637
|
851 |
.brightness_fn = lp5523_led_brightness, |
a96bfa135
|
852 |
.set_led_current = lp5523_set_led_current, |
db6eaf838
|
853 854 |
.firmware_cb = lp5523_firmware_loaded, .run_engine = lp5523_run_engine, |
e73c0ce6b
|
855 |
.dev_attr_group = &lp5523_group, |
48068d5de
|
856 |
}; |
98ea1ea20
|
857 |
static int lp5523_probe(struct i2c_client *client, |
0efba16cc
|
858 859 |
const struct i2c_device_id *id) { |
22ebeb488
|
860 |
int ret; |
6a0c9a479
|
861 862 |
struct lp55xx_chip *chip; struct lp55xx_led *led; |
ed1333520
|
863 |
struct lp55xx_platform_data *pdata = dev_get_platdata(&client->dev); |
7542a04b1
|
864 |
struct device_node *np = client->dev.of_node; |
ed1333520
|
865 |
if (!pdata) { |
7542a04b1
|
866 |
if (np) { |
ed1333520
|
867 868 869 |
pdata = lp55xx_of_populate_pdata(&client->dev, np); if (IS_ERR(pdata)) return PTR_ERR(pdata); |
7542a04b1
|
870 871 872 873 874 |
} else { dev_err(&client->dev, "no platform data "); return -EINVAL; } |
0efba16cc
|
875 |
} |
6a0c9a479
|
876 877 878 |
chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL); if (!chip) return -ENOMEM; |
a86854d0c
|
879 880 |
led = devm_kcalloc(&client->dev, pdata->num_channels, sizeof(*led), GFP_KERNEL); |
6a0c9a479
|
881 882 883 884 885 |
if (!led) return -ENOMEM; chip->cl = client; chip->pdata = pdata; |
48068d5de
|
886 |
chip->cfg = &lp5523_cfg; |
6a0c9a479
|
887 888 |
mutex_init(&chip->lock); |
0efba16cc
|
889 |
|
6a0c9a479
|
890 |
i2c_set_clientdata(client, led); |
0efba16cc
|
891 |
|
22ebeb488
|
892 |
ret = lp55xx_init_device(chip); |
0efba16cc
|
893 |
if (ret) |
f6c64c6fc
|
894 |
goto err_init; |
0efba16cc
|
895 |
|
56a1e9adc
|
896 897 |
dev_info(&client->dev, "%s Programmable led chip found ", id->name); |
0efba16cc
|
898 |
|
9e9b3db1b
|
899 |
ret = lp55xx_register_leds(led, chip); |
f65248080
|
900 |
if (ret) |
9e9b3db1b
|
901 |
goto err_register_leds; |
0efba16cc
|
902 |
|
e73c0ce6b
|
903 |
ret = lp55xx_register_sysfs(chip); |
0efba16cc
|
904 905 906 |
if (ret) { dev_err(&client->dev, "registering sysfs failed "); |
e73c0ce6b
|
907 |
goto err_register_sysfs; |
0efba16cc
|
908 |
} |
e73c0ce6b
|
909 910 911 912 |
return 0; err_register_sysfs: |
c3a68ebfc
|
913 |
lp55xx_unregister_leds(led, chip); |
9e9b3db1b
|
914 |
err_register_leds: |
6ce617626
|
915 |
lp55xx_deinit_device(chip); |
f6c64c6fc
|
916 |
err_init: |
0efba16cc
|
917 918 919 920 921 |
return ret; } static int lp5523_remove(struct i2c_client *client) { |
6ce617626
|
922 923 |
struct lp55xx_led *led = i2c_get_clientdata(client); struct lp55xx_chip *chip = led->chip; |
0efba16cc
|
924 |
|
28c9266b3
|
925 |
lp5523_stop_all_engines(chip); |
87cc4bde2
|
926 |
lp55xx_unregister_sysfs(chip); |
c3a68ebfc
|
927 |
lp55xx_unregister_leds(led, chip); |
6ce617626
|
928 |
lp55xx_deinit_device(chip); |
0efba16cc
|
929 |
|
0efba16cc
|
930 931 932 933 |
return 0; } static const struct i2c_device_id lp5523_id[] = { |
27d7704e5
|
934 935 |
{ "lp5523", LP5523 }, { "lp55231", LP55231 }, |
0efba16cc
|
936 937 938 939 |
{ } }; MODULE_DEVICE_TABLE(i2c, lp5523_id); |
33c88b67f
|
940 941 942 |
#ifdef CONFIG_OF static const struct of_device_id of_lp5523_leds_match[] = { { .compatible = "national,lp5523", }, |
9ef8c877e
|
943 |
{ .compatible = "ti,lp55231", }, |
33c88b67f
|
944 945 946 947 948 |
{}, }; MODULE_DEVICE_TABLE(of, of_lp5523_leds_match); #endif |
0efba16cc
|
949 950 |
static struct i2c_driver lp5523_driver = { .driver = { |
27d7704e5
|
951 |
.name = "lp5523x", |
33c88b67f
|
952 |
.of_match_table = of_match_ptr(of_lp5523_leds_match), |
0efba16cc
|
953 954 955 956 957 |
}, .probe = lp5523_probe, .remove = lp5523_remove, .id_table = lp5523_id, }; |
09a0d183e
|
958 |
module_i2c_driver(lp5523_driver); |
0efba16cc
|
959 960 |
MODULE_AUTHOR("Mathias Nyman <mathias.nyman@nokia.com>"); |
a2387cb9f
|
961 |
MODULE_AUTHOR("Milo Kim <milo.kim@ti.com>"); |
0efba16cc
|
962 963 |
MODULE_DESCRIPTION("LP5523 LED engine"); MODULE_LICENSE("GPL"); |