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