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