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