1 /* 2 * lp5523.c - LP5523 LED Driver 3 * 4 * Copyright (C) 2010 Nokia Corporation 5 * 6 * Contact: Samu Onkalo <samu.p.onkalo@nokia.com> 7 * 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. 11 * 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. 16 * 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 20 * 02110-1301 USA 21 */ 22 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 38 #define LP5523_REG_ENABLE 0x00 39 #define LP5523_REG_OP_MODE 0x01 40 #define LP5523_REG_RATIOMETRIC_MSB 0x02 41 #define LP5523_REG_RATIOMETRIC_LSB 0x03 42 #define LP5523_REG_ENABLE_LEDS_MSB 0x04 43 #define LP5523_REG_ENABLE_LEDS_LSB 0x05 44 #define LP5523_REG_LED_CNTRL_BASE 0x06 45 #define LP5523_REG_LED_PWM_BASE 0x16 46 #define LP5523_REG_LED_CURRENT_BASE 0x26 47 #define LP5523_REG_CONFIG 0x36 48 #define LP5523_REG_CHANNEL1_PC 0x37 49 #define LP5523_REG_CHANNEL2_PC 0x38 50 #define LP5523_REG_CHANNEL3_PC 0x39 51 #define LP5523_REG_STATUS 0x3a 52 #define LP5523_REG_GPO 0x3b 53 #define LP5523_REG_VARIABLE 0x3c 54 #define LP5523_REG_RESET 0x3d 55 #define LP5523_REG_TEMP_CTRL 0x3e 56 #define LP5523_REG_TEMP_READ 0x3f 57 #define LP5523_REG_TEMP_WRITE 0x40 58 #define LP5523_REG_LED_TEST_CTRL 0x41 59 #define LP5523_REG_LED_TEST_ADC 0x42 60 #define LP5523_REG_ENG1_VARIABLE 0x45 61 #define LP5523_REG_ENG2_VARIABLE 0x46 62 #define LP5523_REG_ENG3_VARIABLE 0x47 63 #define LP5523_REG_MASTER_FADER1 0x48 64 #define LP5523_REG_MASTER_FADER2 0x49 65 #define LP5523_REG_MASTER_FADER3 0x4a 66 #define LP5523_REG_CH1_PROG_START 0x4c 67 #define LP5523_REG_CH2_PROG_START 0x4d 68 #define LP5523_REG_CH3_PROG_START 0x4e 69 #define LP5523_REG_PROG_PAGE_SEL 0x4f 70 #define LP5523_REG_PROG_MEM 0x50 71 72 #define LP5523_CMD_LOAD 0x15 /* 00010101 */ 73 #define LP5523_CMD_RUN 0x2a /* 00101010 */ 74 #define LP5523_CMD_DISABLED 0x00 /* 00000000 */ 75 76 #define LP5523_ENABLE 0x40 77 #define LP5523_AUTO_INC 0x40 78 #define LP5523_PWR_SAVE 0x20 79 #define LP5523_PWM_PWR_SAVE 0x04 80 #define LP5523_CP_1 0x08 81 #define LP5523_CP_1_5 0x10 82 #define LP5523_CP_AUTO 0x18 83 #define LP5523_INT_CLK 0x01 84 #define LP5523_AUTO_CLK 0x02 85 #define LP5523_EN_LEDTEST 0x80 86 #define LP5523_LEDTEST_DONE 0x80 87 88 #define LP5523_DEFAULT_CURRENT 50 /* microAmps */ 89 #define LP5523_PROGRAM_LENGTH 32 /* in bytes */ 90 #define LP5523_PROGRAM_PAGES 6 91 #define LP5523_ADC_SHORTCIRC_LIM 80 92 93 #define LP5523_LEDS 9 94 #define LP5523_ENGINES 3 95 96 #define LP5523_ENG_MASK_BASE 0x30 /* 00110000 */ 97 98 #define LP5523_ENG_STATUS_MASK 0x07 /* 00000111 */ 99 100 #define LP5523_IRQ_FLAGS IRQF_TRIGGER_FALLING 101 102 #define LP5523_EXT_CLK_USED 0x08 103 104 #define LED_ACTIVE(mux, led) (!!(mux & (0x0001 << led))) 105 #define SHIFT_MASK(id) (((id) - 1) * 2) 106 107 struct lp5523_engine { 108 const struct attribute_group *attributes; 109 int id; 110 u8 mode; 111 u8 prog_page; 112 u8 mux_page; 113 u16 led_mux; 114 u8 engine_mask; 115 }; 116 117 struct lp5523_led { 118 int id; 119 u8 chan_nr; 120 u8 led_current; 121 u8 max_current; 122 struct led_classdev cdev; 123 struct work_struct brightness_work; 124 u8 brightness; 125 }; 126 127 struct lp5523_chip { 128 struct mutex lock; /* Serialize control */ 129 struct i2c_client *client; 130 struct lp5523_engine engines[LP5523_ENGINES]; 131 struct lp5523_led leds[LP5523_LEDS]; 132 struct lp5523_platform_data *pdata; 133 u8 num_channels; 134 u8 num_leds; 135 }; 136 137 static inline struct lp5523_led *cdev_to_led(struct led_classdev *cdev) 138 { 139 return container_of(cdev, struct lp5523_led, cdev); 140 } 141 142 static inline struct lp5523_chip *engine_to_lp5523(struct lp5523_engine *engine) 143 { 144 return container_of(engine, struct lp5523_chip, 145 engines[engine->id - 1]); 146 } 147 148 static inline struct lp5523_chip *led_to_lp5523(struct lp5523_led *led) 149 { 150 return container_of(led, struct lp5523_chip, 151 leds[led->id]); 152 } 153 154 static int lp5523_set_mode(struct lp5523_engine *engine, u8 mode); 155 static int lp5523_set_engine_mode(struct lp5523_engine *engine, u8 mode); 156 static int lp5523_load_program(struct lp5523_engine *engine, u8 *pattern); 157 158 static void lp5523_led_brightness_work(struct work_struct *work); 159 160 static int lp5523_write(struct i2c_client *client, u8 reg, u8 value) 161 { 162 return i2c_smbus_write_byte_data(client, reg, value); 163 } 164 165 static int lp5523_read(struct i2c_client *client, u8 reg, u8 *buf) 166 { 167 s32 ret = i2c_smbus_read_byte_data(client, reg); 168 169 if (ret < 0) 170 return -EIO; 171 172 *buf = ret; 173 return 0; 174 } 175 176 static int lp5523_detect(struct i2c_client *client) 177 { 178 int ret; 179 u8 buf; 180 181 ret = lp5523_write(client, LP5523_REG_ENABLE, 0x40); 182 if (ret) 183 return ret; 184 ret = lp5523_read(client, LP5523_REG_ENABLE, &buf); 185 if (ret) 186 return ret; 187 if (buf == 0x40) 188 return 0; 189 else 190 return -ENODEV; 191 } 192 193 static int lp5523_configure(struct i2c_client *client) 194 { 195 struct lp5523_chip *chip = i2c_get_clientdata(client); 196 int ret = 0; 197 u8 status; 198 199 /* one pattern per engine setting led mux start and stop addresses */ 200 u8 pattern[][LP5523_PROGRAM_LENGTH] = { 201 { 0x9c, 0x30, 0x9c, 0xb0, 0x9d, 0x80, 0xd8, 0x00, 0}, 202 { 0x9c, 0x40, 0x9c, 0xc0, 0x9d, 0x80, 0xd8, 0x00, 0}, 203 { 0x9c, 0x50, 0x9c, 0xd0, 0x9d, 0x80, 0xd8, 0x00, 0}, 204 }; 205 206 ret |= lp5523_write(client, LP5523_REG_ENABLE, LP5523_ENABLE); 207 /* Chip startup time is 500 us, 1 - 2 ms gives some margin */ 208 usleep_range(1000, 2000); 209 210 ret |= lp5523_write(client, LP5523_REG_CONFIG, 211 LP5523_AUTO_INC | LP5523_PWR_SAVE | 212 LP5523_CP_AUTO | LP5523_AUTO_CLK | 213 LP5523_PWM_PWR_SAVE); 214 215 /* turn on all leds */ 216 ret |= lp5523_write(client, LP5523_REG_ENABLE_LEDS_MSB, 0x01); 217 ret |= lp5523_write(client, LP5523_REG_ENABLE_LEDS_LSB, 0xff); 218 219 /* hardcode 32 bytes of memory for each engine from program memory */ 220 ret |= lp5523_write(client, LP5523_REG_CH1_PROG_START, 0x00); 221 ret |= lp5523_write(client, LP5523_REG_CH2_PROG_START, 0x10); 222 ret |= lp5523_write(client, LP5523_REG_CH3_PROG_START, 0x20); 223 224 /* write led mux address space for each channel */ 225 ret |= lp5523_load_program(&chip->engines[0], pattern[0]); 226 ret |= lp5523_load_program(&chip->engines[1], pattern[1]); 227 ret |= lp5523_load_program(&chip->engines[2], pattern[2]); 228 229 if (ret) { 230 dev_err(&client->dev, "could not load mux programs\n"); 231 return -1; 232 } 233 234 /* set all engines exec state and mode to run 00101010 */ 235 ret |= lp5523_write(client, LP5523_REG_ENABLE, 236 (LP5523_CMD_RUN | LP5523_ENABLE)); 237 238 ret |= lp5523_write(client, LP5523_REG_OP_MODE, LP5523_CMD_RUN); 239 240 if (ret) { 241 dev_err(&client->dev, "could not start mux programs\n"); 242 return -1; 243 } 244 245 /* Let the programs run for couple of ms and check the engine status */ 246 usleep_range(3000, 6000); 247 lp5523_read(client, LP5523_REG_STATUS, &status); 248 status &= LP5523_ENG_STATUS_MASK; 249 250 if (status == LP5523_ENG_STATUS_MASK) { 251 dev_dbg(&client->dev, "all engines configured\n"); 252 } else { 253 dev_info(&client->dev, "status == %x\n", status); 254 dev_err(&client->dev, "cound not configure LED engine\n"); 255 return -1; 256 } 257 258 dev_info(&client->dev, "disabling engines\n"); 259 260 ret |= lp5523_write(client, LP5523_REG_OP_MODE, LP5523_CMD_DISABLED); 261 262 return ret; 263 } 264 265 static int lp5523_set_engine_mode(struct lp5523_engine *engine, u8 mode) 266 { 267 struct lp5523_chip *chip = engine_to_lp5523(engine); 268 struct i2c_client *client = chip->client; 269 int ret; 270 u8 engine_state; 271 272 ret = lp5523_read(client, LP5523_REG_OP_MODE, &engine_state); 273 if (ret) 274 goto fail; 275 276 engine_state &= ~(engine->engine_mask); 277 278 /* set mode only for this engine */ 279 mode &= engine->engine_mask; 280 281 engine_state |= mode; 282 283 ret |= lp5523_write(client, LP5523_REG_OP_MODE, engine_state); 284 fail: 285 return ret; 286 } 287 288 static int lp5523_load_mux(struct lp5523_engine *engine, u16 mux) 289 { 290 struct lp5523_chip *chip = engine_to_lp5523(engine); 291 struct i2c_client *client = chip->client; 292 int ret = 0; 293 294 ret |= lp5523_set_engine_mode(engine, LP5523_CMD_LOAD); 295 296 ret |= lp5523_write(client, LP5523_REG_PROG_PAGE_SEL, engine->mux_page); 297 ret |= lp5523_write(client, LP5523_REG_PROG_MEM, 298 (u8)(mux >> 8)); 299 ret |= lp5523_write(client, LP5523_REG_PROG_MEM + 1, (u8)(mux)); 300 engine->led_mux = mux; 301 302 return ret; 303 } 304 305 static int lp5523_load_program(struct lp5523_engine *engine, u8 *pattern) 306 { 307 struct lp5523_chip *chip = engine_to_lp5523(engine); 308 struct i2c_client *client = chip->client; 309 310 int ret = 0; 311 312 ret |= lp5523_set_engine_mode(engine, LP5523_CMD_LOAD); 313 314 ret |= lp5523_write(client, LP5523_REG_PROG_PAGE_SEL, 315 engine->prog_page); 316 ret |= i2c_smbus_write_i2c_block_data(client, LP5523_REG_PROG_MEM, 317 LP5523_PROGRAM_LENGTH, pattern); 318 319 return ret; 320 } 321 322 static int lp5523_run_program(struct lp5523_engine *engine) 323 { 324 struct lp5523_chip *chip = engine_to_lp5523(engine); 325 struct i2c_client *client = chip->client; 326 int ret; 327 328 ret = lp5523_write(client, LP5523_REG_ENABLE, 329 LP5523_CMD_RUN | LP5523_ENABLE); 330 if (ret) 331 goto fail; 332 333 ret = lp5523_set_engine_mode(engine, LP5523_CMD_RUN); 334 fail: 335 return ret; 336 } 337 338 static int lp5523_mux_parse(const char *buf, u16 *mux, size_t len) 339 { 340 int i; 341 u16 tmp_mux = 0; 342 len = len < LP5523_LEDS ? len : LP5523_LEDS; 343 for (i = 0; i < len; i++) { 344 switch (buf[i]) { 345 case '1': 346 tmp_mux |= (1 << i); 347 break; 348 case '0': 349 break; 350 case '\n': 351 i = len; 352 break; 353 default: 354 return -1; 355 } 356 } 357 *mux = tmp_mux; 358 359 return 0; 360 } 361 362 static void lp5523_mux_to_array(u16 led_mux, char *array) 363 { 364 int i, pos = 0; 365 for (i = 0; i < LP5523_LEDS; i++) 366 pos += sprintf(array + pos, "%x", LED_ACTIVE(led_mux, i)); 367 368 array[pos] = '\0'; 369 } 370 371 /*--------------------------------------------------------------*/ 372 /* Sysfs interface */ 373 /*--------------------------------------------------------------*/ 374 375 static ssize_t show_engine_leds(struct device *dev, 376 struct device_attribute *attr, 377 char *buf, int nr) 378 { 379 struct i2c_client *client = to_i2c_client(dev); 380 struct lp5523_chip *chip = i2c_get_clientdata(client); 381 char mux[LP5523_LEDS + 1]; 382 383 lp5523_mux_to_array(chip->engines[nr - 1].led_mux, mux); 384 385 return sprintf(buf, "%s\n", mux); 386 } 387 388 #define show_leds(nr) \ 389 static ssize_t show_engine##nr##_leds(struct device *dev, \ 390 struct device_attribute *attr, \ 391 char *buf) \ 392 { \ 393 return show_engine_leds(dev, attr, buf, nr); \ 394 } 395 show_leds(1) 396 show_leds(2) 397 show_leds(3) 398 399 static ssize_t store_engine_leds(struct device *dev, 400 struct device_attribute *attr, 401 const char *buf, size_t len, int nr) 402 { 403 struct i2c_client *client = to_i2c_client(dev); 404 struct lp5523_chip *chip = i2c_get_clientdata(client); 405 u16 mux = 0; 406 407 if (lp5523_mux_parse(buf, &mux, len)) 408 return -EINVAL; 409 410 if (lp5523_load_mux(&chip->engines[nr - 1], mux)) 411 return -EINVAL; 412 413 return len; 414 } 415 416 #define store_leds(nr) \ 417 static ssize_t store_engine##nr##_leds(struct device *dev, \ 418 struct device_attribute *attr, \ 419 const char *buf, size_t len) \ 420 { \ 421 return store_engine_leds(dev, attr, buf, len, nr); \ 422 } 423 store_leds(1) 424 store_leds(2) 425 store_leds(3) 426 427 static ssize_t lp5523_selftest(struct device *dev, 428 struct device_attribute *attr, 429 char *buf) 430 { 431 struct i2c_client *client = to_i2c_client(dev); 432 struct lp5523_chip *chip = i2c_get_clientdata(client); 433 int i, ret, pos = 0; 434 int led = 0; 435 u8 status, adc, vdd; 436 437 mutex_lock(&chip->lock); 438 439 ret = lp5523_read(chip->client, LP5523_REG_STATUS, &status); 440 if (ret < 0) 441 goto fail; 442 443 /* Check that ext clock is really in use if requested */ 444 if ((chip->pdata) && (chip->pdata->clock_mode == LP5523_CLOCK_EXT)) 445 if ((status & LP5523_EXT_CLK_USED) == 0) 446 goto fail; 447 448 /* Measure VDD (i.e. VBAT) first (channel 16 corresponds to VDD) */ 449 lp5523_write(chip->client, LP5523_REG_LED_TEST_CTRL, 450 LP5523_EN_LEDTEST | 16); 451 usleep_range(3000, 6000); /* ADC conversion time is typically 2.7 ms */ 452 ret = lp5523_read(chip->client, LP5523_REG_STATUS, &status); 453 if (!(status & LP5523_LEDTEST_DONE)) 454 usleep_range(3000, 6000); /* Was not ready. Wait little bit */ 455 456 ret |= lp5523_read(chip->client, LP5523_REG_LED_TEST_ADC, &vdd); 457 vdd--; /* There may be some fluctuation in measurement */ 458 459 for (i = 0; i < LP5523_LEDS; i++) { 460 /* Skip non-existing channels */ 461 if (chip->pdata->led_config[i].led_current == 0) 462 continue; 463 464 /* Set default current */ 465 lp5523_write(chip->client, 466 LP5523_REG_LED_CURRENT_BASE + i, 467 chip->pdata->led_config[i].led_current); 468 469 lp5523_write(chip->client, LP5523_REG_LED_PWM_BASE + i, 0xff); 470 /* let current stabilize 2 - 4ms before measurements start */ 471 usleep_range(2000, 4000); 472 lp5523_write(chip->client, 473 LP5523_REG_LED_TEST_CTRL, 474 LP5523_EN_LEDTEST | i); 475 /* ADC conversion time is 2.7 ms typically */ 476 usleep_range(3000, 6000); 477 ret = lp5523_read(chip->client, LP5523_REG_STATUS, &status); 478 if (!(status & LP5523_LEDTEST_DONE)) 479 usleep_range(3000, 6000);/* Was not ready. Wait. */ 480 ret |= lp5523_read(chip->client, LP5523_REG_LED_TEST_ADC, &adc); 481 482 if (adc >= vdd || adc < LP5523_ADC_SHORTCIRC_LIM) 483 pos += sprintf(buf + pos, "LED %d FAIL\n", i); 484 485 lp5523_write(chip->client, LP5523_REG_LED_PWM_BASE + i, 0x00); 486 487 /* Restore current */ 488 lp5523_write(chip->client, 489 LP5523_REG_LED_CURRENT_BASE + i, 490 chip->leds[led].led_current); 491 led++; 492 } 493 if (pos == 0) 494 pos = sprintf(buf, "OK\n"); 495 goto release_lock; 496 fail: 497 pos = sprintf(buf, "FAIL\n"); 498 499 release_lock: 500 mutex_unlock(&chip->lock); 501 502 return pos; 503 } 504 505 static void lp5523_set_brightness(struct led_classdev *cdev, 506 enum led_brightness brightness) 507 { 508 struct lp5523_led *led = cdev_to_led(cdev); 509 510 led->brightness = (u8)brightness; 511 512 schedule_work(&led->brightness_work); 513 } 514 515 static void lp5523_led_brightness_work(struct work_struct *work) 516 { 517 struct lp5523_led *led = container_of(work, 518 struct lp5523_led, 519 brightness_work); 520 struct lp5523_chip *chip = led_to_lp5523(led); 521 struct i2c_client *client = chip->client; 522 523 mutex_lock(&chip->lock); 524 525 lp5523_write(client, LP5523_REG_LED_PWM_BASE + led->chan_nr, 526 led->brightness); 527 528 mutex_unlock(&chip->lock); 529 } 530 531 static int lp5523_do_store_load(struct lp5523_engine *engine, 532 const char *buf, size_t len) 533 { 534 struct lp5523_chip *chip = engine_to_lp5523(engine); 535 struct i2c_client *client = chip->client; 536 int ret, nrchars, offset = 0, i = 0; 537 char c[3]; 538 unsigned cmd; 539 u8 pattern[LP5523_PROGRAM_LENGTH] = {0}; 540 541 while ((offset < len - 1) && (i < LP5523_PROGRAM_LENGTH)) { 542 /* separate sscanfs because length is working only for %s */ 543 ret = sscanf(buf + offset, "%2s%n ", c, &nrchars); 544 ret = sscanf(c, "%2x", &cmd); 545 if (ret != 1) 546 goto fail; 547 pattern[i] = (u8)cmd; 548 549 offset += nrchars; 550 i++; 551 } 552 553 /* Each instruction is 16bit long. Check that length is even */ 554 if (i % 2) 555 goto fail; 556 557 mutex_lock(&chip->lock); 558 559 ret = lp5523_load_program(engine, pattern); 560 mutex_unlock(&chip->lock); 561 562 if (ret) { 563 dev_err(&client->dev, "failed loading pattern\n"); 564 return ret; 565 } 566 567 return len; 568 fail: 569 dev_err(&client->dev, "wrong pattern format\n"); 570 return -EINVAL; 571 } 572 573 static ssize_t store_engine_load(struct device *dev, 574 struct device_attribute *attr, 575 const char *buf, size_t len, int nr) 576 { 577 struct i2c_client *client = to_i2c_client(dev); 578 struct lp5523_chip *chip = i2c_get_clientdata(client); 579 return lp5523_do_store_load(&chip->engines[nr - 1], buf, len); 580 } 581 582 #define store_load(nr) \ 583 static ssize_t store_engine##nr##_load(struct device *dev, \ 584 struct device_attribute *attr, \ 585 const char *buf, size_t len) \ 586 { \ 587 return store_engine_load(dev, attr, buf, len, nr); \ 588 } 589 store_load(1) 590 store_load(2) 591 store_load(3) 592 593 static ssize_t show_engine_mode(struct device *dev, 594 struct device_attribute *attr, 595 char *buf, int nr) 596 { 597 struct i2c_client *client = to_i2c_client(dev); 598 struct lp5523_chip *chip = i2c_get_clientdata(client); 599 switch (chip->engines[nr - 1].mode) { 600 case LP5523_CMD_RUN: 601 return sprintf(buf, "run\n"); 602 case LP5523_CMD_LOAD: 603 return sprintf(buf, "load\n"); 604 case LP5523_CMD_DISABLED: 605 return sprintf(buf, "disabled\n"); 606 default: 607 return sprintf(buf, "disabled\n"); 608 } 609 } 610 611 #define show_mode(nr) \ 612 static ssize_t show_engine##nr##_mode(struct device *dev, \ 613 struct device_attribute *attr, \ 614 char *buf) \ 615 { \ 616 return show_engine_mode(dev, attr, buf, nr); \ 617 } 618 show_mode(1) 619 show_mode(2) 620 show_mode(3) 621 622 static ssize_t store_engine_mode(struct device *dev, 623 struct device_attribute *attr, 624 const char *buf, size_t len, int nr) 625 { 626 struct i2c_client *client = to_i2c_client(dev); 627 struct lp5523_chip *chip = i2c_get_clientdata(client); 628 struct lp5523_engine *engine = &chip->engines[nr - 1]; 629 mutex_lock(&chip->lock); 630 631 if (!strncmp(buf, "run", 3)) 632 lp5523_set_mode(engine, LP5523_CMD_RUN); 633 else if (!strncmp(buf, "load", 4)) 634 lp5523_set_mode(engine, LP5523_CMD_LOAD); 635 else if (!strncmp(buf, "disabled", 8)) 636 lp5523_set_mode(engine, LP5523_CMD_DISABLED); 637 638 mutex_unlock(&chip->lock); 639 return len; 640 } 641 642 #define store_mode(nr) \ 643 static ssize_t store_engine##nr##_mode(struct device *dev, \ 644 struct device_attribute *attr, \ 645 const char *buf, size_t len) \ 646 { \ 647 return store_engine_mode(dev, attr, buf, len, nr); \ 648 } 649 store_mode(1) 650 store_mode(2) 651 store_mode(3) 652 653 static ssize_t show_max_current(struct device *dev, 654 struct device_attribute *attr, 655 char *buf) 656 { 657 struct led_classdev *led_cdev = dev_get_drvdata(dev); 658 struct lp5523_led *led = cdev_to_led(led_cdev); 659 660 return sprintf(buf, "%d\n", led->max_current); 661 } 662 663 static ssize_t show_current(struct device *dev, 664 struct device_attribute *attr, 665 char *buf) 666 { 667 struct led_classdev *led_cdev = dev_get_drvdata(dev); 668 struct lp5523_led *led = cdev_to_led(led_cdev); 669 670 return sprintf(buf, "%d\n", led->led_current); 671 } 672 673 static ssize_t store_current(struct device *dev, 674 struct device_attribute *attr, 675 const char *buf, size_t len) 676 { 677 struct led_classdev *led_cdev = dev_get_drvdata(dev); 678 struct lp5523_led *led = cdev_to_led(led_cdev); 679 struct lp5523_chip *chip = led_to_lp5523(led); 680 ssize_t ret; 681 unsigned long curr; 682 683 if (strict_strtoul(buf, 0, &curr)) 684 return -EINVAL; 685 686 if (curr > led->max_current) 687 return -EINVAL; 688 689 mutex_lock(&chip->lock); 690 ret = lp5523_write(chip->client, 691 LP5523_REG_LED_CURRENT_BASE + led->chan_nr, 692 (u8)curr); 693 mutex_unlock(&chip->lock); 694 695 if (ret < 0) 696 return ret; 697 698 led->led_current = (u8)curr; 699 700 return len; 701 } 702 703 /* led class device attributes */ 704 static DEVICE_ATTR(led_current, S_IRUGO | S_IWUGO, show_current, store_current); 705 static DEVICE_ATTR(max_current, S_IRUGO , show_max_current, NULL); 706 707 static struct attribute *lp5523_led_attributes[] = { 708 &dev_attr_led_current.attr, 709 &dev_attr_max_current.attr, 710 NULL, 711 }; 712 713 static struct attribute_group lp5523_led_attribute_group = { 714 .attrs = lp5523_led_attributes 715 }; 716 717 /* device attributes */ 718 static DEVICE_ATTR(engine1_mode, S_IRUGO | S_IWUGO, 719 show_engine1_mode, store_engine1_mode); 720 static DEVICE_ATTR(engine2_mode, S_IRUGO | S_IWUGO, 721 show_engine2_mode, store_engine2_mode); 722 static DEVICE_ATTR(engine3_mode, S_IRUGO | S_IWUGO, 723 show_engine3_mode, store_engine3_mode); 724 static DEVICE_ATTR(engine1_leds, S_IRUGO | S_IWUGO, 725 show_engine1_leds, store_engine1_leds); 726 static DEVICE_ATTR(engine2_leds, S_IRUGO | S_IWUGO, 727 show_engine2_leds, store_engine2_leds); 728 static DEVICE_ATTR(engine3_leds, S_IRUGO | S_IWUGO, 729 show_engine3_leds, store_engine3_leds); 730 static DEVICE_ATTR(engine1_load, S_IWUGO, NULL, store_engine1_load); 731 static DEVICE_ATTR(engine2_load, S_IWUGO, NULL, store_engine2_load); 732 static DEVICE_ATTR(engine3_load, S_IWUGO, NULL, store_engine3_load); 733 static DEVICE_ATTR(selftest, S_IRUGO, lp5523_selftest, NULL); 734 735 static struct attribute *lp5523_attributes[] = { 736 &dev_attr_engine1_mode.attr, 737 &dev_attr_engine2_mode.attr, 738 &dev_attr_engine3_mode.attr, 739 &dev_attr_selftest.attr, 740 NULL 741 }; 742 743 static struct attribute *lp5523_engine1_attributes[] = { 744 &dev_attr_engine1_load.attr, 745 &dev_attr_engine1_leds.attr, 746 NULL 747 }; 748 749 static struct attribute *lp5523_engine2_attributes[] = { 750 &dev_attr_engine2_load.attr, 751 &dev_attr_engine2_leds.attr, 752 NULL 753 }; 754 755 static struct attribute *lp5523_engine3_attributes[] = { 756 &dev_attr_engine3_load.attr, 757 &dev_attr_engine3_leds.attr, 758 NULL 759 }; 760 761 static const struct attribute_group lp5523_group = { 762 .attrs = lp5523_attributes, 763 }; 764 765 static const struct attribute_group lp5523_engine_group[] = { 766 {.attrs = lp5523_engine1_attributes }, 767 {.attrs = lp5523_engine2_attributes }, 768 {.attrs = lp5523_engine3_attributes }, 769 }; 770 771 static int lp5523_register_sysfs(struct i2c_client *client) 772 { 773 struct device *dev = &client->dev; 774 int ret; 775 776 ret = sysfs_create_group(&dev->kobj, &lp5523_group); 777 if (ret < 0) 778 return ret; 779 780 return 0; 781 } 782 783 static void lp5523_unregister_sysfs(struct i2c_client *client) 784 { 785 struct lp5523_chip *chip = i2c_get_clientdata(client); 786 struct device *dev = &client->dev; 787 int i; 788 789 sysfs_remove_group(&dev->kobj, &lp5523_group); 790 791 for (i = 0; i < ARRAY_SIZE(chip->engines); i++) 792 if (chip->engines[i].mode == LP5523_CMD_LOAD) 793 sysfs_remove_group(&dev->kobj, &lp5523_engine_group[i]); 794 795 for (i = 0; i < chip->num_leds; i++) 796 sysfs_remove_group(&chip->leds[i].cdev.dev->kobj, 797 &lp5523_led_attribute_group); 798 } 799 800 /*--------------------------------------------------------------*/ 801 /* Set chip operating mode */ 802 /*--------------------------------------------------------------*/ 803 static int lp5523_set_mode(struct lp5523_engine *engine, u8 mode) 804 { 805 /* engine to chip */ 806 struct lp5523_chip *chip = engine_to_lp5523(engine); 807 struct i2c_client *client = chip->client; 808 struct device *dev = &client->dev; 809 int ret = 0; 810 811 /* if in that mode already do nothing, except for run */ 812 if (mode == engine->mode && mode != LP5523_CMD_RUN) 813 return 0; 814 815 if (mode == LP5523_CMD_RUN) { 816 ret = lp5523_run_program(engine); 817 } else if (mode == LP5523_CMD_LOAD) { 818 lp5523_set_engine_mode(engine, LP5523_CMD_DISABLED); 819 lp5523_set_engine_mode(engine, LP5523_CMD_LOAD); 820 821 ret = sysfs_create_group(&dev->kobj, engine->attributes); 822 if (ret) 823 return ret; 824 } else if (mode == LP5523_CMD_DISABLED) { 825 lp5523_set_engine_mode(engine, LP5523_CMD_DISABLED); 826 } 827 828 /* remove load attribute from sysfs if not in load mode */ 829 if (engine->mode == LP5523_CMD_LOAD && mode != LP5523_CMD_LOAD) 830 sysfs_remove_group(&dev->kobj, engine->attributes); 831 832 engine->mode = mode; 833 834 return ret; 835 } 836 837 /*--------------------------------------------------------------*/ 838 /* Probe, Attach, Remove */ 839 /*--------------------------------------------------------------*/ 840 static int __init lp5523_init_engine(struct lp5523_engine *engine, int id) 841 { 842 if (id < 1 || id > LP5523_ENGINES) 843 return -1; 844 engine->id = id; 845 engine->engine_mask = LP5523_ENG_MASK_BASE >> SHIFT_MASK(id); 846 engine->prog_page = id - 1; 847 engine->mux_page = id + 2; 848 engine->attributes = &lp5523_engine_group[id - 1]; 849 850 return 0; 851 } 852 853 static int __init lp5523_init_led(struct lp5523_led *led, struct device *dev, 854 int chan, struct lp5523_platform_data *pdata) 855 { 856 char name[32]; 857 int res; 858 859 if (chan >= LP5523_LEDS) 860 return -EINVAL; 861 862 if (pdata->led_config[chan].led_current) { 863 led->led_current = pdata->led_config[chan].led_current; 864 led->max_current = pdata->led_config[chan].max_current; 865 led->chan_nr = pdata->led_config[chan].chan_nr; 866 867 if (led->chan_nr >= LP5523_LEDS) { 868 dev_err(dev, "Use channel numbers between 0 and %d\n", 869 LP5523_LEDS - 1); 870 return -EINVAL; 871 } 872 873 snprintf(name, 32, "lp5523:channel%d", chan); 874 875 led->cdev.name = name; 876 led->cdev.brightness_set = lp5523_set_brightness; 877 res = led_classdev_register(dev, &led->cdev); 878 if (res < 0) { 879 dev_err(dev, "couldn't register led on channel %d\n", 880 chan); 881 return res; 882 } 883 res = sysfs_create_group(&led->cdev.dev->kobj, 884 &lp5523_led_attribute_group); 885 if (res < 0) { 886 dev_err(dev, "couldn't register current attribute\n"); 887 led_classdev_unregister(&led->cdev); 888 return res; 889 } 890 } else { 891 led->led_current = 0; 892 } 893 return 0; 894 } 895 896 static struct i2c_driver lp5523_driver; 897 898 static int lp5523_probe(struct i2c_client *client, 899 const struct i2c_device_id *id) 900 { 901 struct lp5523_chip *chip; 902 struct lp5523_platform_data *pdata; 903 int ret, i, led; 904 905 chip = kzalloc(sizeof(*chip), GFP_KERNEL); 906 if (!chip) 907 return -ENOMEM; 908 909 i2c_set_clientdata(client, chip); 910 chip->client = client; 911 912 pdata = client->dev.platform_data; 913 914 if (!pdata) { 915 dev_err(&client->dev, "no platform data\n"); 916 ret = -EINVAL; 917 goto fail1; 918 } 919 920 mutex_init(&chip->lock); 921 922 chip->pdata = pdata; 923 924 if (pdata->setup_resources) { 925 ret = pdata->setup_resources(); 926 if (ret < 0) 927 goto fail1; 928 } 929 930 if (pdata->enable) { 931 pdata->enable(0); 932 usleep_range(1000, 2000); /* Keep enable down at least 1ms */ 933 pdata->enable(1); 934 usleep_range(1000, 2000); /* 500us abs min. */ 935 } 936 937 lp5523_write(client, LP5523_REG_RESET, 0xff); 938 usleep_range(10000, 20000); /* 939 * Exact value is not available. 10 - 20ms 940 * appears to be enough for reset. 941 */ 942 ret = lp5523_detect(client); 943 if (ret) 944 goto fail2; 945 946 dev_info(&client->dev, "LP5523 Programmable led chip found\n"); 947 948 /* Initialize engines */ 949 for (i = 0; i < ARRAY_SIZE(chip->engines); i++) { 950 ret = lp5523_init_engine(&chip->engines[i], i + 1); 951 if (ret) { 952 dev_err(&client->dev, "error initializing engine\n"); 953 goto fail2; 954 } 955 } 956 ret = lp5523_configure(client); 957 if (ret < 0) { 958 dev_err(&client->dev, "error configuring chip\n"); 959 goto fail2; 960 } 961 962 /* Initialize leds */ 963 chip->num_channels = pdata->num_channels; 964 chip->num_leds = 0; 965 led = 0; 966 for (i = 0; i < pdata->num_channels; i++) { 967 /* Do not initialize channels that are not connected */ 968 if (pdata->led_config[i].led_current == 0) 969 continue; 970 971 ret = lp5523_init_led(&chip->leds[led], &client->dev, i, pdata); 972 if (ret) { 973 dev_err(&client->dev, "error initializing leds\n"); 974 goto fail3; 975 } 976 chip->num_leds++; 977 978 chip->leds[led].id = led; 979 /* Set LED current */ 980 lp5523_write(client, 981 LP5523_REG_LED_CURRENT_BASE + chip->leds[led].chan_nr, 982 chip->leds[led].led_current); 983 984 INIT_WORK(&(chip->leds[led].brightness_work), 985 lp5523_led_brightness_work); 986 987 led++; 988 } 989 990 ret = lp5523_register_sysfs(client); 991 if (ret) { 992 dev_err(&client->dev, "registering sysfs failed\n"); 993 goto fail3; 994 } 995 return ret; 996 fail3: 997 for (i = 0; i < chip->num_leds; i++) { 998 led_classdev_unregister(&chip->leds[i].cdev); 999 cancel_work_sync(&chip->leds[i].brightness_work); 1000 } 1001 fail2: 1002 if (pdata->enable) 1003 pdata->enable(0); 1004 if (pdata->release_resources) 1005 pdata->release_resources(); 1006 fail1: 1007 kfree(chip); 1008 return ret; 1009 } 1010 1011 static int lp5523_remove(struct i2c_client *client) 1012 { 1013 struct lp5523_chip *chip = i2c_get_clientdata(client); 1014 int i; 1015 1016 lp5523_unregister_sysfs(client); 1017 1018 for (i = 0; i < chip->num_leds; i++) { 1019 led_classdev_unregister(&chip->leds[i].cdev); 1020 cancel_work_sync(&chip->leds[i].brightness_work); 1021 } 1022 1023 if (chip->pdata->enable) 1024 chip->pdata->enable(0); 1025 if (chip->pdata->release_resources) 1026 chip->pdata->release_resources(); 1027 kfree(chip); 1028 return 0; 1029 } 1030 1031 static const struct i2c_device_id lp5523_id[] = { 1032 { "lp5523", 0 }, 1033 { } 1034 }; 1035 1036 MODULE_DEVICE_TABLE(i2c, lp5523_id); 1037 1038 static struct i2c_driver lp5523_driver = { 1039 .driver = { 1040 .name = "lp5523", 1041 }, 1042 .probe = lp5523_probe, 1043 .remove = lp5523_remove, 1044 .id_table = lp5523_id, 1045 }; 1046 1047 static int __init lp5523_init(void) 1048 { 1049 int ret; 1050 1051 ret = i2c_add_driver(&lp5523_driver); 1052 1053 if (ret < 0) 1054 printk(KERN_ALERT "Adding lp5523 driver failed\n"); 1055 1056 return ret; 1057 } 1058 1059 static void __exit lp5523_exit(void) 1060 { 1061 i2c_del_driver(&lp5523_driver); 1062 } 1063 1064 module_init(lp5523_init); 1065 module_exit(lp5523_exit); 1066 1067 MODULE_AUTHOR("Mathias Nyman <mathias.nyman@nokia.com>"); 1068 MODULE_DESCRIPTION("LP5523 LED engine"); 1069 MODULE_LICENSE("GPL"); 1070