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 /* default R channel current register value */ 101 #define LP5521_REG_R_CURR_DEFAULT 0xAF 102 103 struct lp5521_engine { 104 int id; 105 u8 mode; 106 u8 prog_page; 107 u8 engine_mask; 108 }; 109 110 struct lp5521_led { 111 int id; 112 u8 chan_nr; 113 u8 led_current; 114 u8 max_current; 115 struct led_classdev cdev; 116 struct work_struct brightness_work; 117 u8 brightness; 118 }; 119 120 struct lp5521_chip { 121 struct lp5521_platform_data *pdata; 122 struct mutex lock; /* Serialize control */ 123 struct i2c_client *client; 124 struct lp5521_engine engines[LP5521_MAX_ENGINES]; 125 struct lp5521_led leds[LP5521_MAX_LEDS]; 126 u8 num_channels; 127 u8 num_leds; 128 }; 129 130 static inline struct lp5521_led *cdev_to_led(struct led_classdev *cdev) 131 { 132 return container_of(cdev, struct lp5521_led, cdev); 133 } 134 135 static inline struct lp5521_chip *engine_to_lp5521(struct lp5521_engine *engine) 136 { 137 return container_of(engine, struct lp5521_chip, 138 engines[engine->id - 1]); 139 } 140 141 static inline struct lp5521_chip *led_to_lp5521(struct lp5521_led *led) 142 { 143 return container_of(led, struct lp5521_chip, 144 leds[led->id]); 145 } 146 147 static void lp5521_led_brightness_work(struct work_struct *work); 148 149 static inline int lp5521_write(struct i2c_client *client, u8 reg, u8 value) 150 { 151 return i2c_smbus_write_byte_data(client, reg, value); 152 } 153 154 static int lp5521_read(struct i2c_client *client, u8 reg, u8 *buf) 155 { 156 s32 ret; 157 158 ret = i2c_smbus_read_byte_data(client, reg); 159 if (ret < 0) 160 return -EIO; 161 162 *buf = ret; 163 return 0; 164 } 165 166 static int lp5521_set_engine_mode(struct lp5521_engine *engine, u8 mode) 167 { 168 struct lp5521_chip *chip = engine_to_lp5521(engine); 169 struct i2c_client *client = chip->client; 170 int ret; 171 u8 engine_state; 172 173 /* Only transition between RUN and DIRECT mode are handled here */ 174 if (mode == LP5521_CMD_LOAD) 175 return 0; 176 177 if (mode == LP5521_CMD_DISABLED) 178 mode = LP5521_CMD_DIRECT; 179 180 ret = lp5521_read(client, LP5521_REG_OP_MODE, &engine_state); 181 if (ret < 0) 182 return ret; 183 184 /* set mode only for this engine */ 185 engine_state &= ~(engine->engine_mask); 186 mode &= engine->engine_mask; 187 engine_state |= mode; 188 return lp5521_write(client, LP5521_REG_OP_MODE, engine_state); 189 } 190 191 static int lp5521_load_program(struct lp5521_engine *eng, const u8 *pattern) 192 { 193 struct lp5521_chip *chip = engine_to_lp5521(eng); 194 struct i2c_client *client = chip->client; 195 int ret; 196 int addr; 197 u8 mode; 198 199 /* move current engine to direct mode and remember the state */ 200 ret = lp5521_set_engine_mode(eng, LP5521_CMD_DIRECT); 201 /* Mode change requires min 500 us delay. 1 - 2 ms with margin */ 202 usleep_range(1000, 2000); 203 ret |= lp5521_read(client, LP5521_REG_OP_MODE, &mode); 204 205 /* For loading, all the engines to load mode */ 206 lp5521_write(client, LP5521_REG_OP_MODE, LP5521_CMD_DIRECT); 207 /* Mode change requires min 500 us delay. 1 - 2 ms with margin */ 208 usleep_range(1000, 2000); 209 lp5521_write(client, LP5521_REG_OP_MODE, LP5521_CMD_LOAD); 210 /* Mode change requires min 500 us delay. 1 - 2 ms with margin */ 211 usleep_range(1000, 2000); 212 213 addr = LP5521_PROG_MEM_BASE + eng->prog_page * LP5521_PROG_MEM_SIZE; 214 i2c_smbus_write_i2c_block_data(client, 215 addr, 216 LP5521_PROG_MEM_SIZE, 217 pattern); 218 219 ret |= lp5521_write(client, LP5521_REG_OP_MODE, mode); 220 return ret; 221 } 222 223 static int lp5521_set_led_current(struct lp5521_chip *chip, int led, u8 curr) 224 { 225 return lp5521_write(chip->client, 226 LP5521_REG_LED_CURRENT_BASE + chip->leds[led].chan_nr, 227 curr); 228 } 229 230 static void lp5521_init_engine(struct lp5521_chip *chip) 231 { 232 int i; 233 for (i = 0; i < ARRAY_SIZE(chip->engines); i++) { 234 chip->engines[i].id = i + 1; 235 chip->engines[i].engine_mask = LP5521_ENG_MASK_BASE >> (i * 2); 236 chip->engines[i].prog_page = i; 237 } 238 } 239 240 static int lp5521_configure(struct i2c_client *client) 241 { 242 struct lp5521_chip *chip = i2c_get_clientdata(client); 243 int ret; 244 245 lp5521_init_engine(chip); 246 247 /* Set all PWMs to direct control mode */ 248 ret = lp5521_write(client, LP5521_REG_OP_MODE, 0x3F); 249 250 /* Enable auto-powersave, set charge pump to auto, red to battery */ 251 ret |= lp5521_write(client, LP5521_REG_CONFIG, 252 LP5521_PWRSAVE_EN | LP5521_CP_MODE_AUTO | LP5521_R_TO_BATT); 253 254 /* Initialize all channels PWM to zero -> leds off */ 255 ret |= lp5521_write(client, LP5521_REG_R_PWM, 0); 256 ret |= lp5521_write(client, LP5521_REG_G_PWM, 0); 257 ret |= lp5521_write(client, LP5521_REG_B_PWM, 0); 258 259 /* Set engines are set to run state when OP_MODE enables engines */ 260 ret |= lp5521_write(client, LP5521_REG_ENABLE, 261 LP5521_MASTER_ENABLE | LP5521_LOGARITHMIC_PWM | 262 LP5521_EXEC_RUN); 263 /* enable takes 500us. 1 - 2 ms leaves some margin */ 264 usleep_range(1000, 2000); 265 266 return ret; 267 } 268 269 static int lp5521_run_selftest(struct lp5521_chip *chip, char *buf) 270 { 271 int ret; 272 u8 status; 273 274 ret = lp5521_read(chip->client, LP5521_REG_STATUS, &status); 275 if (ret < 0) 276 return ret; 277 278 /* Check that ext clock is really in use if requested */ 279 if (chip->pdata && chip->pdata->clock_mode == LP5521_CLOCK_EXT) 280 if ((status & LP5521_EXT_CLK_USED) == 0) 281 return -EIO; 282 return 0; 283 } 284 285 static void lp5521_set_brightness(struct led_classdev *cdev, 286 enum led_brightness brightness) 287 { 288 struct lp5521_led *led = cdev_to_led(cdev); 289 led->brightness = (u8)brightness; 290 schedule_work(&led->brightness_work); 291 } 292 293 static void lp5521_led_brightness_work(struct work_struct *work) 294 { 295 struct lp5521_led *led = container_of(work, 296 struct lp5521_led, 297 brightness_work); 298 struct lp5521_chip *chip = led_to_lp5521(led); 299 struct i2c_client *client = chip->client; 300 301 mutex_lock(&chip->lock); 302 lp5521_write(client, LP5521_REG_LED_PWM_BASE + led->chan_nr, 303 led->brightness); 304 mutex_unlock(&chip->lock); 305 } 306 307 /* Detect the chip by setting its ENABLE register and reading it back. */ 308 static int lp5521_detect(struct i2c_client *client) 309 { 310 int ret; 311 u8 buf; 312 313 ret = lp5521_write(client, LP5521_REG_ENABLE, 314 LP5521_MASTER_ENABLE | LP5521_LOGARITHMIC_PWM); 315 if (ret) 316 return ret; 317 /* enable takes 500us. 1 - 2 ms leaves some margin */ 318 usleep_range(1000, 2000); 319 ret = lp5521_read(client, LP5521_REG_ENABLE, &buf); 320 if (ret) 321 return ret; 322 if (buf != (LP5521_MASTER_ENABLE | LP5521_LOGARITHMIC_PWM)) 323 return -ENODEV; 324 325 return 0; 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 (strict_strtoul(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 /* led class device attributes */ 540 static DEVICE_ATTR(led_current, S_IRUGO | S_IWUSR, show_current, store_current); 541 static DEVICE_ATTR(max_current, S_IRUGO , show_max_current, NULL); 542 543 static struct attribute *lp5521_led_attributes[] = { 544 &dev_attr_led_current.attr, 545 &dev_attr_max_current.attr, 546 NULL, 547 }; 548 549 static struct attribute_group lp5521_led_attribute_group = { 550 .attrs = lp5521_led_attributes 551 }; 552 553 /* device attributes */ 554 static DEVICE_ATTR(engine1_mode, S_IRUGO | S_IWUSR, 555 show_engine1_mode, store_engine1_mode); 556 static DEVICE_ATTR(engine2_mode, S_IRUGO | S_IWUSR, 557 show_engine2_mode, store_engine2_mode); 558 static DEVICE_ATTR(engine3_mode, S_IRUGO | S_IWUSR, 559 show_engine3_mode, store_engine3_mode); 560 static DEVICE_ATTR(engine1_load, S_IWUSR, NULL, store_engine1_load); 561 static DEVICE_ATTR(engine2_load, S_IWUSR, NULL, store_engine2_load); 562 static DEVICE_ATTR(engine3_load, S_IWUSR, NULL, store_engine3_load); 563 static DEVICE_ATTR(selftest, S_IRUGO, lp5521_selftest, NULL); 564 565 static struct attribute *lp5521_attributes[] = { 566 &dev_attr_engine1_mode.attr, 567 &dev_attr_engine2_mode.attr, 568 &dev_attr_engine3_mode.attr, 569 &dev_attr_selftest.attr, 570 &dev_attr_engine1_load.attr, 571 &dev_attr_engine2_load.attr, 572 &dev_attr_engine3_load.attr, 573 NULL 574 }; 575 576 static const struct attribute_group lp5521_group = { 577 .attrs = lp5521_attributes, 578 }; 579 580 static int lp5521_register_sysfs(struct i2c_client *client) 581 { 582 struct device *dev = &client->dev; 583 return sysfs_create_group(&dev->kobj, &lp5521_group); 584 } 585 586 static void lp5521_unregister_sysfs(struct i2c_client *client) 587 { 588 struct lp5521_chip *chip = i2c_get_clientdata(client); 589 struct device *dev = &client->dev; 590 int i; 591 592 sysfs_remove_group(&dev->kobj, &lp5521_group); 593 594 for (i = 0; i < chip->num_leds; i++) 595 sysfs_remove_group(&chip->leds[i].cdev.dev->kobj, 596 &lp5521_led_attribute_group); 597 } 598 599 static int __devinit lp5521_init_led(struct lp5521_led *led, 600 struct i2c_client *client, 601 int chan, struct lp5521_platform_data *pdata) 602 { 603 struct device *dev = &client->dev; 604 char name[32]; 605 int res; 606 607 if (chan >= LP5521_MAX_LEDS) 608 return -EINVAL; 609 610 if (pdata->led_config[chan].led_current == 0) 611 return 0; 612 613 led->led_current = pdata->led_config[chan].led_current; 614 led->max_current = pdata->led_config[chan].max_current; 615 led->chan_nr = pdata->led_config[chan].chan_nr; 616 617 if (led->chan_nr >= LP5521_MAX_LEDS) { 618 dev_err(dev, "Use channel numbers between 0 and %d\n", 619 LP5521_MAX_LEDS - 1); 620 return -EINVAL; 621 } 622 623 snprintf(name, sizeof(name), "%s:channel%d", 624 pdata->label ?: client->name, chan); 625 led->cdev.brightness_set = lp5521_set_brightness; 626 led->cdev.name = name; 627 res = led_classdev_register(dev, &led->cdev); 628 if (res < 0) { 629 dev_err(dev, "couldn't register led on channel %d\n", chan); 630 return res; 631 } 632 633 res = sysfs_create_group(&led->cdev.dev->kobj, 634 &lp5521_led_attribute_group); 635 if (res < 0) { 636 dev_err(dev, "couldn't register current attribute\n"); 637 led_classdev_unregister(&led->cdev); 638 return res; 639 } 640 return 0; 641 } 642 643 static int __devinit lp5521_probe(struct i2c_client *client, 644 const struct i2c_device_id *id) 645 { 646 struct lp5521_chip *chip; 647 struct lp5521_platform_data *pdata; 648 int ret, i, led; 649 u8 buf; 650 651 chip = kzalloc(sizeof(*chip), GFP_KERNEL); 652 if (!chip) 653 return -ENOMEM; 654 655 i2c_set_clientdata(client, chip); 656 chip->client = client; 657 658 pdata = client->dev.platform_data; 659 660 if (!pdata) { 661 dev_err(&client->dev, "no platform data\n"); 662 ret = -EINVAL; 663 goto fail1; 664 } 665 666 mutex_init(&chip->lock); 667 668 chip->pdata = pdata; 669 670 if (pdata->setup_resources) { 671 ret = pdata->setup_resources(); 672 if (ret < 0) 673 goto fail1; 674 } 675 676 if (pdata->enable) { 677 pdata->enable(0); 678 usleep_range(1000, 2000); /* Keep enable down at least 1ms */ 679 pdata->enable(1); 680 usleep_range(1000, 2000); /* 500us abs min. */ 681 } 682 683 lp5521_write(client, LP5521_REG_RESET, 0xff); 684 usleep_range(10000, 20000); /* 685 * Exact value is not available. 10 - 20ms 686 * appears to be enough for reset. 687 */ 688 689 /* 690 * Make sure that the chip is reset by reading back the r channel 691 * current reg. This is dummy read is required on some platforms - 692 * otherwise further access to the R G B channels in the 693 * LP5521_REG_ENABLE register will not have any effect - strange! 694 */ 695 lp5521_read(client, LP5521_REG_R_CURRENT, &buf); 696 if (buf != LP5521_REG_R_CURR_DEFAULT) { 697 dev_err(&client->dev, "error in reseting chip\n"); 698 goto fail2; 699 } 700 usleep_range(10000, 20000); 701 702 ret = lp5521_detect(client); 703 704 if (ret) { 705 dev_err(&client->dev, "Chip not found\n"); 706 goto fail2; 707 } 708 709 dev_info(&client->dev, "%s programmable led chip found\n", id->name); 710 711 ret = lp5521_configure(client); 712 if (ret < 0) { 713 dev_err(&client->dev, "error configuring chip\n"); 714 goto fail2; 715 } 716 717 /* Initialize leds */ 718 chip->num_channels = pdata->num_channels; 719 chip->num_leds = 0; 720 led = 0; 721 for (i = 0; i < pdata->num_channels; i++) { 722 /* Do not initialize channels that are not connected */ 723 if (pdata->led_config[i].led_current == 0) 724 continue; 725 726 ret = lp5521_init_led(&chip->leds[led], client, i, pdata); 727 if (ret) { 728 dev_err(&client->dev, "error initializing leds\n"); 729 goto fail3; 730 } 731 chip->num_leds++; 732 733 chip->leds[led].id = led; 734 /* Set initial LED current */ 735 lp5521_set_led_current(chip, led, 736 chip->leds[led].led_current); 737 738 INIT_WORK(&(chip->leds[led].brightness_work), 739 lp5521_led_brightness_work); 740 741 led++; 742 } 743 744 ret = lp5521_register_sysfs(client); 745 if (ret) { 746 dev_err(&client->dev, "registering sysfs failed\n"); 747 goto fail3; 748 } 749 return ret; 750 fail3: 751 for (i = 0; i < chip->num_leds; i++) { 752 led_classdev_unregister(&chip->leds[i].cdev); 753 cancel_work_sync(&chip->leds[i].brightness_work); 754 } 755 fail2: 756 if (pdata->enable) 757 pdata->enable(0); 758 if (pdata->release_resources) 759 pdata->release_resources(); 760 fail1: 761 kfree(chip); 762 return ret; 763 } 764 765 static int __devexit lp5521_remove(struct i2c_client *client) 766 { 767 struct lp5521_chip *chip = i2c_get_clientdata(client); 768 int i; 769 770 lp5521_unregister_sysfs(client); 771 772 for (i = 0; i < chip->num_leds; i++) { 773 led_classdev_unregister(&chip->leds[i].cdev); 774 cancel_work_sync(&chip->leds[i].brightness_work); 775 } 776 777 if (chip->pdata->enable) 778 chip->pdata->enable(0); 779 if (chip->pdata->release_resources) 780 chip->pdata->release_resources(); 781 kfree(chip); 782 return 0; 783 } 784 785 static const struct i2c_device_id lp5521_id[] = { 786 { "lp5521", 0 }, /* Three channel chip */ 787 { } 788 }; 789 MODULE_DEVICE_TABLE(i2c, lp5521_id); 790 791 static struct i2c_driver lp5521_driver = { 792 .driver = { 793 .name = "lp5521", 794 }, 795 .probe = lp5521_probe, 796 .remove = __devexit_p(lp5521_remove), 797 .id_table = lp5521_id, 798 }; 799 800 static int __init lp5521_init(void) 801 { 802 int ret; 803 804 ret = i2c_add_driver(&lp5521_driver); 805 806 if (ret < 0) 807 printk(KERN_ALERT "Adding lp5521 driver failed\n"); 808 809 return ret; 810 } 811 812 static void __exit lp5521_exit(void) 813 { 814 i2c_del_driver(&lp5521_driver); 815 } 816 817 module_init(lp5521_init); 818 module_exit(lp5521_exit); 819 820 MODULE_AUTHOR("Mathias Nyman, Yuri Zaporozhets, Samu Onkalo"); 821 MODULE_DESCRIPTION("LP5521 LED engine"); 822 MODULE_LICENSE("GPL v2"); 823