1 /* 2 * LP5521 LED chip 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-lp5521.h> 35 #include <linux/workqueue.h> 36 #include <linux/slab.h> 37 38 #define LP5521_PROGRAM_LENGTH 32 /* in bytes */ 39 40 #define LP5521_MAX_LEDS 3 /* Maximum number of LEDs */ 41 #define LP5521_MAX_ENGINES 3 /* Maximum number of engines */ 42 43 #define LP5521_ENG_MASK_BASE 0x30 /* 00110000 */ 44 #define LP5521_ENG_STATUS_MASK 0x07 /* 00000111 */ 45 46 #define LP5521_CMD_LOAD 0x15 /* 00010101 */ 47 #define LP5521_CMD_RUN 0x2a /* 00101010 */ 48 #define LP5521_CMD_DIRECT 0x3f /* 00111111 */ 49 #define LP5521_CMD_DISABLED 0x00 /* 00000000 */ 50 51 /* Registers */ 52 #define LP5521_REG_ENABLE 0x00 53 #define LP5521_REG_OP_MODE 0x01 54 #define LP5521_REG_R_PWM 0x02 55 #define LP5521_REG_G_PWM 0x03 56 #define LP5521_REG_B_PWM 0x04 57 #define LP5521_REG_R_CURRENT 0x05 58 #define LP5521_REG_G_CURRENT 0x06 59 #define LP5521_REG_B_CURRENT 0x07 60 #define LP5521_REG_CONFIG 0x08 61 #define LP5521_REG_R_CHANNEL_PC 0x09 62 #define LP5521_REG_G_CHANNEL_PC 0x0A 63 #define LP5521_REG_B_CHANNEL_PC 0x0B 64 #define LP5521_REG_STATUS 0x0C 65 #define LP5521_REG_RESET 0x0D 66 #define LP5521_REG_GPO 0x0E 67 #define LP5521_REG_R_PROG_MEM 0x10 68 #define LP5521_REG_G_PROG_MEM 0x30 69 #define LP5521_REG_B_PROG_MEM 0x50 70 71 #define LP5521_PROG_MEM_BASE LP5521_REG_R_PROG_MEM 72 #define LP5521_PROG_MEM_SIZE 0x20 73 74 /* Base register to set LED current */ 75 #define LP5521_REG_LED_CURRENT_BASE LP5521_REG_R_CURRENT 76 77 /* Base register to set the brightness */ 78 #define LP5521_REG_LED_PWM_BASE LP5521_REG_R_PWM 79 80 /* Bits in ENABLE register */ 81 #define LP5521_MASTER_ENABLE 0x40 /* Chip master enable */ 82 #define LP5521_LOGARITHMIC_PWM 0x80 /* Logarithmic PWM adjustment */ 83 #define LP5521_EXEC_RUN 0x2A 84 #define LP5521_ENABLE_DEFAULT \ 85 (LP5521_MASTER_ENABLE | LP5521_LOGARITHMIC_PWM) 86 #define LP5521_ENABLE_RUN_PROGRAM \ 87 (LP5521_ENABLE_DEFAULT | LP5521_EXEC_RUN) 88 89 /* Status */ 90 #define LP5521_EXT_CLK_USED 0x08 91 92 /* default R channel current register value */ 93 #define LP5521_REG_R_CURR_DEFAULT 0xAF 94 95 /* Pattern Mode */ 96 #define PATTERN_OFF 0 97 98 struct lp5521_engine { 99 int id; 100 u8 mode; 101 u8 prog_page; 102 u8 engine_mask; 103 }; 104 105 struct lp5521_led { 106 int id; 107 u8 chan_nr; 108 u8 led_current; 109 u8 max_current; 110 struct led_classdev cdev; 111 struct work_struct brightness_work; 112 u8 brightness; 113 }; 114 115 struct lp5521_chip { 116 struct lp5521_platform_data *pdata; 117 struct mutex lock; /* Serialize control */ 118 struct i2c_client *client; 119 struct lp5521_engine engines[LP5521_MAX_ENGINES]; 120 struct lp5521_led leds[LP5521_MAX_LEDS]; 121 u8 num_channels; 122 u8 num_leds; 123 }; 124 125 static inline struct lp5521_led *cdev_to_led(struct led_classdev *cdev) 126 { 127 return container_of(cdev, struct lp5521_led, cdev); 128 } 129 130 static inline struct lp5521_chip *engine_to_lp5521(struct lp5521_engine *engine) 131 { 132 return container_of(engine, struct lp5521_chip, 133 engines[engine->id - 1]); 134 } 135 136 static inline struct lp5521_chip *led_to_lp5521(struct lp5521_led *led) 137 { 138 return container_of(led, struct lp5521_chip, 139 leds[led->id]); 140 } 141 142 static void lp5521_led_brightness_work(struct work_struct *work); 143 144 static inline int lp5521_write(struct i2c_client *client, u8 reg, u8 value) 145 { 146 return i2c_smbus_write_byte_data(client, reg, value); 147 } 148 149 static int lp5521_read(struct i2c_client *client, u8 reg, u8 *buf) 150 { 151 s32 ret; 152 153 ret = i2c_smbus_read_byte_data(client, reg); 154 if (ret < 0) 155 return -EIO; 156 157 *buf = ret; 158 return 0; 159 } 160 161 static int lp5521_set_engine_mode(struct lp5521_engine *engine, u8 mode) 162 { 163 struct lp5521_chip *chip = engine_to_lp5521(engine); 164 struct i2c_client *client = chip->client; 165 int ret; 166 u8 engine_state; 167 168 /* Only transition between RUN and DIRECT mode are handled here */ 169 if (mode == LP5521_CMD_LOAD) 170 return 0; 171 172 if (mode == LP5521_CMD_DISABLED) 173 mode = LP5521_CMD_DIRECT; 174 175 ret = lp5521_read(client, LP5521_REG_OP_MODE, &engine_state); 176 if (ret < 0) 177 return ret; 178 179 /* set mode only for this engine */ 180 engine_state &= ~(engine->engine_mask); 181 mode &= engine->engine_mask; 182 engine_state |= mode; 183 return lp5521_write(client, LP5521_REG_OP_MODE, engine_state); 184 } 185 186 static int lp5521_load_program(struct lp5521_engine *eng, const u8 *pattern) 187 { 188 struct lp5521_chip *chip = engine_to_lp5521(eng); 189 struct i2c_client *client = chip->client; 190 int ret; 191 int addr; 192 u8 mode; 193 194 /* move current engine to direct mode and remember the state */ 195 ret = lp5521_set_engine_mode(eng, LP5521_CMD_DIRECT); 196 /* Mode change requires min 500 us delay. 1 - 2 ms with margin */ 197 usleep_range(1000, 2000); 198 ret |= lp5521_read(client, LP5521_REG_OP_MODE, &mode); 199 200 /* For loading, all the engines to load mode */ 201 lp5521_write(client, LP5521_REG_OP_MODE, LP5521_CMD_DIRECT); 202 /* Mode change requires min 500 us delay. 1 - 2 ms with margin */ 203 usleep_range(1000, 2000); 204 lp5521_write(client, LP5521_REG_OP_MODE, LP5521_CMD_LOAD); 205 /* Mode change requires min 500 us delay. 1 - 2 ms with margin */ 206 usleep_range(1000, 2000); 207 208 addr = LP5521_PROG_MEM_BASE + eng->prog_page * LP5521_PROG_MEM_SIZE; 209 i2c_smbus_write_i2c_block_data(client, 210 addr, 211 LP5521_PROG_MEM_SIZE, 212 pattern); 213 214 ret |= lp5521_write(client, LP5521_REG_OP_MODE, mode); 215 return ret; 216 } 217 218 static int lp5521_set_led_current(struct lp5521_chip *chip, int led, u8 curr) 219 { 220 return lp5521_write(chip->client, 221 LP5521_REG_LED_CURRENT_BASE + chip->leds[led].chan_nr, 222 curr); 223 } 224 225 static void lp5521_init_engine(struct lp5521_chip *chip) 226 { 227 int i; 228 for (i = 0; i < ARRAY_SIZE(chip->engines); i++) { 229 chip->engines[i].id = i + 1; 230 chip->engines[i].engine_mask = LP5521_ENG_MASK_BASE >> (i * 2); 231 chip->engines[i].prog_page = i; 232 } 233 } 234 235 static int lp5521_configure(struct i2c_client *client) 236 { 237 struct lp5521_chip *chip = i2c_get_clientdata(client); 238 int ret; 239 u8 cfg; 240 241 lp5521_init_engine(chip); 242 243 /* Set all PWMs to direct control mode */ 244 ret = lp5521_write(client, LP5521_REG_OP_MODE, LP5521_CMD_DIRECT); 245 246 cfg = chip->pdata->update_config ? 247 : (LP5521_PWRSAVE_EN | LP5521_CP_MODE_AUTO | LP5521_R_TO_BATT); 248 ret |= lp5521_write(client, LP5521_REG_CONFIG, cfg); 249 250 /* Initialize all channels PWM to zero -> leds off */ 251 ret |= lp5521_write(client, LP5521_REG_R_PWM, 0); 252 ret |= lp5521_write(client, LP5521_REG_G_PWM, 0); 253 ret |= lp5521_write(client, LP5521_REG_B_PWM, 0); 254 255 /* Set engines are set to run state when OP_MODE enables engines */ 256 ret |= lp5521_write(client, LP5521_REG_ENABLE, 257 LP5521_ENABLE_RUN_PROGRAM); 258 /* enable takes 500us. 1 - 2 ms leaves some margin */ 259 usleep_range(1000, 2000); 260 261 return ret; 262 } 263 264 static int lp5521_run_selftest(struct lp5521_chip *chip, char *buf) 265 { 266 int ret; 267 u8 status; 268 269 ret = lp5521_read(chip->client, LP5521_REG_STATUS, &status); 270 if (ret < 0) 271 return ret; 272 273 /* Check that ext clock is really in use if requested */ 274 if (chip->pdata && chip->pdata->clock_mode == LP5521_CLOCK_EXT) 275 if ((status & LP5521_EXT_CLK_USED) == 0) 276 return -EIO; 277 return 0; 278 } 279 280 static void lp5521_set_brightness(struct led_classdev *cdev, 281 enum led_brightness brightness) 282 { 283 struct lp5521_led *led = cdev_to_led(cdev); 284 led->brightness = (u8)brightness; 285 schedule_work(&led->brightness_work); 286 } 287 288 static void lp5521_led_brightness_work(struct work_struct *work) 289 { 290 struct lp5521_led *led = container_of(work, 291 struct lp5521_led, 292 brightness_work); 293 struct lp5521_chip *chip = led_to_lp5521(led); 294 struct i2c_client *client = chip->client; 295 296 mutex_lock(&chip->lock); 297 lp5521_write(client, LP5521_REG_LED_PWM_BASE + led->chan_nr, 298 led->brightness); 299 mutex_unlock(&chip->lock); 300 } 301 302 /* Detect the chip by setting its ENABLE register and reading it back. */ 303 static int lp5521_detect(struct i2c_client *client) 304 { 305 int ret; 306 u8 buf; 307 308 ret = lp5521_write(client, LP5521_REG_ENABLE, LP5521_ENABLE_DEFAULT); 309 if (ret) 310 return ret; 311 /* enable takes 500us. 1 - 2 ms leaves some margin */ 312 usleep_range(1000, 2000); 313 ret = lp5521_read(client, LP5521_REG_ENABLE, &buf); 314 if (ret) 315 return ret; 316 if (buf != LP5521_ENABLE_DEFAULT) 317 return -ENODEV; 318 319 return 0; 320 } 321 322 /* Set engine mode and create appropriate sysfs attributes, if required. */ 323 static int lp5521_set_mode(struct lp5521_engine *engine, u8 mode) 324 { 325 int ret = 0; 326 327 /* if in that mode already do nothing, except for run */ 328 if (mode == engine->mode && mode != LP5521_CMD_RUN) 329 return 0; 330 331 if (mode == LP5521_CMD_RUN) { 332 ret = lp5521_set_engine_mode(engine, LP5521_CMD_RUN); 333 } else if (mode == LP5521_CMD_LOAD) { 334 lp5521_set_engine_mode(engine, LP5521_CMD_DISABLED); 335 lp5521_set_engine_mode(engine, LP5521_CMD_LOAD); 336 } else if (mode == LP5521_CMD_DISABLED) { 337 lp5521_set_engine_mode(engine, LP5521_CMD_DISABLED); 338 } 339 340 engine->mode = mode; 341 342 return ret; 343 } 344 345 static int lp5521_do_store_load(struct lp5521_engine *engine, 346 const char *buf, size_t len) 347 { 348 struct lp5521_chip *chip = engine_to_lp5521(engine); 349 struct i2c_client *client = chip->client; 350 int ret, nrchars, offset = 0, i = 0; 351 char c[3]; 352 unsigned cmd; 353 u8 pattern[LP5521_PROGRAM_LENGTH] = {0}; 354 355 while ((offset < len - 1) && (i < LP5521_PROGRAM_LENGTH)) { 356 /* separate sscanfs because length is working only for %s */ 357 ret = sscanf(buf + offset, "%2s%n ", c, &nrchars); 358 if (ret != 2) 359 goto fail; 360 ret = sscanf(c, "%2x", &cmd); 361 if (ret != 1) 362 goto fail; 363 pattern[i] = (u8)cmd; 364 365 offset += nrchars; 366 i++; 367 } 368 369 /* Each instruction is 16bit long. Check that length is even */ 370 if (i % 2) 371 goto fail; 372 373 mutex_lock(&chip->lock); 374 if (engine->mode == LP5521_CMD_LOAD) 375 ret = lp5521_load_program(engine, pattern); 376 else 377 ret = -EINVAL; 378 mutex_unlock(&chip->lock); 379 380 if (ret) { 381 dev_err(&client->dev, "failed loading pattern\n"); 382 return ret; 383 } 384 385 return len; 386 fail: 387 dev_err(&client->dev, "wrong pattern format\n"); 388 return -EINVAL; 389 } 390 391 static ssize_t store_engine_load(struct device *dev, 392 struct device_attribute *attr, 393 const char *buf, size_t len, int nr) 394 { 395 struct i2c_client *client = to_i2c_client(dev); 396 struct lp5521_chip *chip = i2c_get_clientdata(client); 397 return lp5521_do_store_load(&chip->engines[nr - 1], buf, len); 398 } 399 400 #define store_load(nr) \ 401 static ssize_t store_engine##nr##_load(struct device *dev, \ 402 struct device_attribute *attr, \ 403 const char *buf, size_t len) \ 404 { \ 405 return store_engine_load(dev, attr, buf, len, nr); \ 406 } 407 store_load(1) 408 store_load(2) 409 store_load(3) 410 411 static ssize_t show_engine_mode(struct device *dev, 412 struct device_attribute *attr, 413 char *buf, int nr) 414 { 415 struct i2c_client *client = to_i2c_client(dev); 416 struct lp5521_chip *chip = i2c_get_clientdata(client); 417 switch (chip->engines[nr - 1].mode) { 418 case LP5521_CMD_RUN: 419 return sprintf(buf, "run\n"); 420 case LP5521_CMD_LOAD: 421 return sprintf(buf, "load\n"); 422 case LP5521_CMD_DISABLED: 423 return sprintf(buf, "disabled\n"); 424 default: 425 return sprintf(buf, "disabled\n"); 426 } 427 } 428 429 #define show_mode(nr) \ 430 static ssize_t show_engine##nr##_mode(struct device *dev, \ 431 struct device_attribute *attr, \ 432 char *buf) \ 433 { \ 434 return show_engine_mode(dev, attr, buf, nr); \ 435 } 436 show_mode(1) 437 show_mode(2) 438 show_mode(3) 439 440 static ssize_t store_engine_mode(struct device *dev, 441 struct device_attribute *attr, 442 const char *buf, size_t len, int nr) 443 { 444 struct i2c_client *client = to_i2c_client(dev); 445 struct lp5521_chip *chip = i2c_get_clientdata(client); 446 struct lp5521_engine *engine = &chip->engines[nr - 1]; 447 mutex_lock(&chip->lock); 448 449 if (!strncmp(buf, "run", 3)) 450 lp5521_set_mode(engine, LP5521_CMD_RUN); 451 else if (!strncmp(buf, "load", 4)) 452 lp5521_set_mode(engine, LP5521_CMD_LOAD); 453 else if (!strncmp(buf, "disabled", 8)) 454 lp5521_set_mode(engine, LP5521_CMD_DISABLED); 455 456 mutex_unlock(&chip->lock); 457 return len; 458 } 459 460 #define store_mode(nr) \ 461 static ssize_t store_engine##nr##_mode(struct device *dev, \ 462 struct device_attribute *attr, \ 463 const char *buf, size_t len) \ 464 { \ 465 return store_engine_mode(dev, attr, buf, len, nr); \ 466 } 467 store_mode(1) 468 store_mode(2) 469 store_mode(3) 470 471 static ssize_t show_max_current(struct device *dev, 472 struct device_attribute *attr, 473 char *buf) 474 { 475 struct led_classdev *led_cdev = dev_get_drvdata(dev); 476 struct lp5521_led *led = cdev_to_led(led_cdev); 477 478 return sprintf(buf, "%d\n", led->max_current); 479 } 480 481 static ssize_t show_current(struct device *dev, 482 struct device_attribute *attr, 483 char *buf) 484 { 485 struct led_classdev *led_cdev = dev_get_drvdata(dev); 486 struct lp5521_led *led = cdev_to_led(led_cdev); 487 488 return sprintf(buf, "%d\n", led->led_current); 489 } 490 491 static ssize_t store_current(struct device *dev, 492 struct device_attribute *attr, 493 const char *buf, size_t len) 494 { 495 struct led_classdev *led_cdev = dev_get_drvdata(dev); 496 struct lp5521_led *led = cdev_to_led(led_cdev); 497 struct lp5521_chip *chip = led_to_lp5521(led); 498 ssize_t ret; 499 unsigned long curr; 500 501 if (kstrtoul(buf, 0, &curr)) 502 return -EINVAL; 503 504 if (curr > led->max_current) 505 return -EINVAL; 506 507 mutex_lock(&chip->lock); 508 ret = lp5521_set_led_current(chip, led->id, curr); 509 mutex_unlock(&chip->lock); 510 511 if (ret < 0) 512 return ret; 513 514 led->led_current = (u8)curr; 515 516 return len; 517 } 518 519 static ssize_t lp5521_selftest(struct device *dev, 520 struct device_attribute *attr, 521 char *buf) 522 { 523 struct i2c_client *client = to_i2c_client(dev); 524 struct lp5521_chip *chip = i2c_get_clientdata(client); 525 int ret; 526 527 mutex_lock(&chip->lock); 528 ret = lp5521_run_selftest(chip, buf); 529 mutex_unlock(&chip->lock); 530 return sprintf(buf, "%s\n", ret ? "FAIL" : "OK"); 531 } 532 533 static void lp5521_clear_program_memory(struct i2c_client *cl) 534 { 535 int i; 536 u8 rgb_mem[] = { 537 LP5521_REG_R_PROG_MEM, 538 LP5521_REG_G_PROG_MEM, 539 LP5521_REG_B_PROG_MEM, 540 }; 541 542 for (i = 0; i < ARRAY_SIZE(rgb_mem); i++) { 543 lp5521_write(cl, rgb_mem[i], 0); 544 lp5521_write(cl, rgb_mem[i] + 1, 0); 545 } 546 } 547 548 static void lp5521_write_program_memory(struct i2c_client *cl, 549 u8 base, u8 *rgb, int size) 550 { 551 int i; 552 553 if (!rgb || size <= 0) 554 return; 555 556 for (i = 0; i < size; i++) 557 lp5521_write(cl, base + i, *(rgb + i)); 558 559 lp5521_write(cl, base + i, 0); 560 lp5521_write(cl, base + i + 1, 0); 561 } 562 563 static inline struct lp5521_led_pattern *lp5521_get_pattern 564 (struct lp5521_chip *chip, u8 offset) 565 { 566 struct lp5521_led_pattern *ptn; 567 ptn = chip->pdata->patterns + (offset - 1); 568 return ptn; 569 } 570 571 static void lp5521_run_led_pattern(int mode, struct lp5521_chip *chip) 572 { 573 struct lp5521_led_pattern *ptn; 574 struct i2c_client *cl = chip->client; 575 int num_patterns = chip->pdata->num_patterns; 576 577 if (mode > num_patterns || !(chip->pdata->patterns)) 578 return; 579 580 if (mode == PATTERN_OFF) { 581 lp5521_write(cl, LP5521_REG_ENABLE, LP5521_ENABLE_DEFAULT); 582 usleep_range(1000, 2000); 583 lp5521_write(cl, LP5521_REG_OP_MODE, LP5521_CMD_DIRECT); 584 } else { 585 ptn = lp5521_get_pattern(chip, mode); 586 if (!ptn) 587 return; 588 589 lp5521_write(cl, LP5521_REG_OP_MODE, LP5521_CMD_LOAD); 590 usleep_range(1000, 2000); 591 592 lp5521_clear_program_memory(cl); 593 594 lp5521_write_program_memory(cl, LP5521_REG_R_PROG_MEM, 595 ptn->r, ptn->size_r); 596 lp5521_write_program_memory(cl, LP5521_REG_G_PROG_MEM, 597 ptn->g, ptn->size_g); 598 lp5521_write_program_memory(cl, LP5521_REG_B_PROG_MEM, 599 ptn->b, ptn->size_b); 600 601 lp5521_write(cl, LP5521_REG_OP_MODE, LP5521_CMD_RUN); 602 usleep_range(1000, 2000); 603 lp5521_write(cl, LP5521_REG_ENABLE, LP5521_ENABLE_RUN_PROGRAM); 604 } 605 } 606 607 static ssize_t store_led_pattern(struct device *dev, 608 struct device_attribute *attr, 609 const char *buf, size_t len) 610 { 611 struct lp5521_chip *chip = i2c_get_clientdata(to_i2c_client(dev)); 612 unsigned long val; 613 int ret; 614 615 ret = strict_strtoul(buf, 16, &val); 616 if (ret) 617 return ret; 618 619 lp5521_run_led_pattern(val, chip); 620 621 return len; 622 } 623 624 /* led class device attributes */ 625 static DEVICE_ATTR(led_current, S_IRUGO | S_IWUSR, show_current, store_current); 626 static DEVICE_ATTR(max_current, S_IRUGO , show_max_current, NULL); 627 628 static struct attribute *lp5521_led_attributes[] = { 629 &dev_attr_led_current.attr, 630 &dev_attr_max_current.attr, 631 NULL, 632 }; 633 634 static struct attribute_group lp5521_led_attribute_group = { 635 .attrs = lp5521_led_attributes 636 }; 637 638 /* device attributes */ 639 static DEVICE_ATTR(engine1_mode, S_IRUGO | S_IWUSR, 640 show_engine1_mode, store_engine1_mode); 641 static DEVICE_ATTR(engine2_mode, S_IRUGO | S_IWUSR, 642 show_engine2_mode, store_engine2_mode); 643 static DEVICE_ATTR(engine3_mode, S_IRUGO | S_IWUSR, 644 show_engine3_mode, store_engine3_mode); 645 static DEVICE_ATTR(engine1_load, S_IWUSR, NULL, store_engine1_load); 646 static DEVICE_ATTR(engine2_load, S_IWUSR, NULL, store_engine2_load); 647 static DEVICE_ATTR(engine3_load, S_IWUSR, NULL, store_engine3_load); 648 static DEVICE_ATTR(selftest, S_IRUGO, lp5521_selftest, NULL); 649 static DEVICE_ATTR(led_pattern, S_IWUSR, NULL, store_led_pattern); 650 651 static struct attribute *lp5521_attributes[] = { 652 &dev_attr_engine1_mode.attr, 653 &dev_attr_engine2_mode.attr, 654 &dev_attr_engine3_mode.attr, 655 &dev_attr_selftest.attr, 656 &dev_attr_engine1_load.attr, 657 &dev_attr_engine2_load.attr, 658 &dev_attr_engine3_load.attr, 659 &dev_attr_led_pattern.attr, 660 NULL 661 }; 662 663 static const struct attribute_group lp5521_group = { 664 .attrs = lp5521_attributes, 665 }; 666 667 static int lp5521_register_sysfs(struct i2c_client *client) 668 { 669 struct device *dev = &client->dev; 670 return sysfs_create_group(&dev->kobj, &lp5521_group); 671 } 672 673 static void lp5521_unregister_sysfs(struct i2c_client *client) 674 { 675 struct lp5521_chip *chip = i2c_get_clientdata(client); 676 struct device *dev = &client->dev; 677 int i; 678 679 sysfs_remove_group(&dev->kobj, &lp5521_group); 680 681 for (i = 0; i < chip->num_leds; i++) 682 sysfs_remove_group(&chip->leds[i].cdev.dev->kobj, 683 &lp5521_led_attribute_group); 684 } 685 686 static int __devinit lp5521_init_led(struct lp5521_led *led, 687 struct i2c_client *client, 688 int chan, struct lp5521_platform_data *pdata) 689 { 690 struct device *dev = &client->dev; 691 char name[32]; 692 int res; 693 694 if (chan >= LP5521_MAX_LEDS) 695 return -EINVAL; 696 697 if (pdata->led_config[chan].led_current == 0) 698 return 0; 699 700 led->led_current = pdata->led_config[chan].led_current; 701 led->max_current = pdata->led_config[chan].max_current; 702 led->chan_nr = pdata->led_config[chan].chan_nr; 703 704 if (led->chan_nr >= LP5521_MAX_LEDS) { 705 dev_err(dev, "Use channel numbers between 0 and %d\n", 706 LP5521_MAX_LEDS - 1); 707 return -EINVAL; 708 } 709 710 led->cdev.brightness_set = lp5521_set_brightness; 711 if (pdata->led_config[chan].name) { 712 led->cdev.name = pdata->led_config[chan].name; 713 } else { 714 snprintf(name, sizeof(name), "%s:channel%d", 715 pdata->label ?: client->name, chan); 716 led->cdev.name = name; 717 } 718 719 res = led_classdev_register(dev, &led->cdev); 720 if (res < 0) { 721 dev_err(dev, "couldn't register led on channel %d\n", chan); 722 return res; 723 } 724 725 res = sysfs_create_group(&led->cdev.dev->kobj, 726 &lp5521_led_attribute_group); 727 if (res < 0) { 728 dev_err(dev, "couldn't register current attribute\n"); 729 led_classdev_unregister(&led->cdev); 730 return res; 731 } 732 return 0; 733 } 734 735 static int __devinit lp5521_probe(struct i2c_client *client, 736 const struct i2c_device_id *id) 737 { 738 struct lp5521_chip *chip; 739 struct lp5521_platform_data *pdata; 740 int ret, i, led; 741 u8 buf; 742 743 chip = kzalloc(sizeof(*chip), GFP_KERNEL); 744 if (!chip) 745 return -ENOMEM; 746 747 i2c_set_clientdata(client, chip); 748 chip->client = client; 749 750 pdata = client->dev.platform_data; 751 752 if (!pdata) { 753 dev_err(&client->dev, "no platform data\n"); 754 ret = -EINVAL; 755 goto fail1; 756 } 757 758 mutex_init(&chip->lock); 759 760 chip->pdata = pdata; 761 762 if (pdata->setup_resources) { 763 ret = pdata->setup_resources(); 764 if (ret < 0) 765 goto fail1; 766 } 767 768 if (pdata->enable) { 769 pdata->enable(0); 770 usleep_range(1000, 2000); /* Keep enable down at least 1ms */ 771 pdata->enable(1); 772 usleep_range(1000, 2000); /* 500us abs min. */ 773 } 774 775 lp5521_write(client, LP5521_REG_RESET, 0xff); 776 usleep_range(10000, 20000); /* 777 * Exact value is not available. 10 - 20ms 778 * appears to be enough for reset. 779 */ 780 781 /* 782 * Make sure that the chip is reset by reading back the r channel 783 * current reg. This is dummy read is required on some platforms - 784 * otherwise further access to the R G B channels in the 785 * LP5521_REG_ENABLE register will not have any effect - strange! 786 */ 787 ret = lp5521_read(client, LP5521_REG_R_CURRENT, &buf); 788 if (buf != LP5521_REG_R_CURR_DEFAULT) { 789 dev_err(&client->dev, "error in resetting chip\n"); 790 goto fail2; 791 } 792 usleep_range(10000, 20000); 793 794 ret = lp5521_detect(client); 795 796 if (ret) { 797 dev_err(&client->dev, "Chip not found\n"); 798 goto fail2; 799 } 800 801 dev_info(&client->dev, "%s programmable led chip found\n", id->name); 802 803 ret = lp5521_configure(client); 804 if (ret < 0) { 805 dev_err(&client->dev, "error configuring chip\n"); 806 goto fail2; 807 } 808 809 /* Initialize leds */ 810 chip->num_channels = pdata->num_channels; 811 chip->num_leds = 0; 812 led = 0; 813 for (i = 0; i < pdata->num_channels; i++) { 814 /* Do not initialize channels that are not connected */ 815 if (pdata->led_config[i].led_current == 0) 816 continue; 817 818 ret = lp5521_init_led(&chip->leds[led], client, i, pdata); 819 if (ret) { 820 dev_err(&client->dev, "error initializing leds\n"); 821 goto fail3; 822 } 823 chip->num_leds++; 824 825 chip->leds[led].id = led; 826 /* Set initial LED current */ 827 lp5521_set_led_current(chip, led, 828 chip->leds[led].led_current); 829 830 INIT_WORK(&(chip->leds[led].brightness_work), 831 lp5521_led_brightness_work); 832 833 led++; 834 } 835 836 ret = lp5521_register_sysfs(client); 837 if (ret) { 838 dev_err(&client->dev, "registering sysfs failed\n"); 839 goto fail3; 840 } 841 return ret; 842 fail3: 843 for (i = 0; i < chip->num_leds; i++) { 844 led_classdev_unregister(&chip->leds[i].cdev); 845 cancel_work_sync(&chip->leds[i].brightness_work); 846 } 847 fail2: 848 if (pdata->enable) 849 pdata->enable(0); 850 if (pdata->release_resources) 851 pdata->release_resources(); 852 fail1: 853 kfree(chip); 854 return ret; 855 } 856 857 static int __devexit lp5521_remove(struct i2c_client *client) 858 { 859 struct lp5521_chip *chip = i2c_get_clientdata(client); 860 int i; 861 862 lp5521_run_led_pattern(PATTERN_OFF, chip); 863 lp5521_unregister_sysfs(client); 864 865 for (i = 0; i < chip->num_leds; i++) { 866 led_classdev_unregister(&chip->leds[i].cdev); 867 cancel_work_sync(&chip->leds[i].brightness_work); 868 } 869 870 if (chip->pdata->enable) 871 chip->pdata->enable(0); 872 if (chip->pdata->release_resources) 873 chip->pdata->release_resources(); 874 kfree(chip); 875 return 0; 876 } 877 878 static const struct i2c_device_id lp5521_id[] = { 879 { "lp5521", 0 }, /* Three channel chip */ 880 { } 881 }; 882 MODULE_DEVICE_TABLE(i2c, lp5521_id); 883 884 static struct i2c_driver lp5521_driver = { 885 .driver = { 886 .name = "lp5521", 887 }, 888 .probe = lp5521_probe, 889 .remove = __devexit_p(lp5521_remove), 890 .id_table = lp5521_id, 891 }; 892 893 module_i2c_driver(lp5521_driver); 894 895 MODULE_AUTHOR("Mathias Nyman, Yuri Zaporozhets, Samu Onkalo"); 896 MODULE_DESCRIPTION("LP5521 LED engine"); 897 MODULE_LICENSE("GPL v2"); 898