1 /* 2 * lp5523.c - LP5523 LED Driver 3 * 4 * Copyright (C) 2010 Nokia Corporation 5 * Copyright (C) 2012 Texas Instruments 6 * 7 * Contact: Samu Onkalo <samu.p.onkalo@nokia.com> 8 * Milo(Woogyom) Kim <milo.kim@ti.com> 9 * 10 * This program is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU General Public License 12 * version 2 as published by the Free Software Foundation. 13 * 14 * This program is distributed in the hope that it will be useful, but 15 * WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 22 * 02110-1301 USA 23 */ 24 25 #include <linux/delay.h> 26 #include <linux/firmware.h> 27 #include <linux/i2c.h> 28 #include <linux/init.h> 29 #include <linux/leds.h> 30 #include <linux/module.h> 31 #include <linux/mutex.h> 32 #include <linux/platform_data/leds-lp55xx.h> 33 #include <linux/slab.h> 34 35 #include "leds-lp55xx-common.h" 36 37 #define LP5523_PROGRAM_LENGTH 32 38 #define LP5523_MAX_LEDS 9 39 40 /* Registers */ 41 #define LP5523_REG_ENABLE 0x00 42 #define LP5523_REG_OP_MODE 0x01 43 #define LP5523_REG_ENABLE_LEDS_MSB 0x04 44 #define LP5523_REG_ENABLE_LEDS_LSB 0x05 45 #define LP5523_REG_LED_PWM_BASE 0x16 46 #define LP5523_REG_LED_CURRENT_BASE 0x26 47 #define LP5523_REG_CONFIG 0x36 48 #define LP5523_REG_STATUS 0x3A 49 #define LP5523_REG_RESET 0x3D 50 #define LP5523_REG_LED_TEST_CTRL 0x41 51 #define LP5523_REG_LED_TEST_ADC 0x42 52 #define LP5523_REG_PROG_PAGE_SEL 0x4F 53 #define LP5523_REG_PROG_MEM 0x50 54 55 /* Bit description in registers */ 56 #define LP5523_ENABLE 0x40 57 #define LP5523_AUTO_INC 0x40 58 #define LP5523_PWR_SAVE 0x20 59 #define LP5523_PWM_PWR_SAVE 0x04 60 #define LP5523_CP_AUTO 0x18 61 #define LP5523_AUTO_CLK 0x02 62 63 #define LP5523_EN_LEDTEST 0x80 64 #define LP5523_LEDTEST_DONE 0x80 65 #define LP5523_RESET 0xFF 66 #define LP5523_ADC_SHORTCIRC_LIM 80 67 #define LP5523_EXT_CLK_USED 0x08 68 69 /* Memory Page Selection */ 70 #define LP5523_PAGE_ENG1 0 71 #define LP5523_PAGE_ENG2 1 72 #define LP5523_PAGE_ENG3 2 73 74 /* Program Memory Operations */ 75 #define LP5523_MODE_ENG1_M 0x30 /* Operation Mode Register */ 76 #define LP5523_MODE_ENG2_M 0x0C 77 #define LP5523_MODE_ENG3_M 0x03 78 #define LP5523_LOAD_ENG1 0x10 79 #define LP5523_LOAD_ENG2 0x04 80 #define LP5523_LOAD_ENG3 0x01 81 82 #define LP5523_ENG1_IS_LOADING(mode) \ 83 ((mode & LP5523_MODE_ENG1_M) == LP5523_LOAD_ENG1) 84 #define LP5523_ENG2_IS_LOADING(mode) \ 85 ((mode & LP5523_MODE_ENG2_M) == LP5523_LOAD_ENG2) 86 #define LP5523_ENG3_IS_LOADING(mode) \ 87 ((mode & LP5523_MODE_ENG3_M) == LP5523_LOAD_ENG3) 88 89 #define LP5523_EXEC_ENG1_M 0x30 /* Enable Register */ 90 #define LP5523_EXEC_ENG2_M 0x0C 91 #define LP5523_EXEC_ENG3_M 0x03 92 #define LP5523_EXEC_M 0x3F 93 #define LP5523_RUN_ENG1 0x20 94 #define LP5523_RUN_ENG2 0x08 95 #define LP5523_RUN_ENG3 0x02 96 97 enum lp5523_chip_id { 98 LP5523, 99 LP55231, 100 }; 101 102 static inline void lp5523_wait_opmode_done(void) 103 { 104 usleep_range(1000, 2000); 105 } 106 107 static void lp5523_set_led_current(struct lp55xx_led *led, u8 led_current) 108 { 109 led->led_current = led_current; 110 lp55xx_write(led->chip, LP5523_REG_LED_CURRENT_BASE + led->chan_nr, 111 led_current); 112 } 113 114 static int lp5523_post_init_device(struct lp55xx_chip *chip) 115 { 116 int ret; 117 118 ret = lp55xx_write(chip, LP5523_REG_ENABLE, LP5523_ENABLE); 119 if (ret) 120 return ret; 121 122 /* Chip startup time is 500 us, 1 - 2 ms gives some margin */ 123 usleep_range(1000, 2000); 124 125 ret = lp55xx_write(chip, LP5523_REG_CONFIG, 126 LP5523_AUTO_INC | LP5523_PWR_SAVE | 127 LP5523_CP_AUTO | LP5523_AUTO_CLK | 128 LP5523_PWM_PWR_SAVE); 129 if (ret) 130 return ret; 131 132 /* turn on all leds */ 133 ret = lp55xx_write(chip, LP5523_REG_ENABLE_LEDS_MSB, 0x01); 134 if (ret) 135 return ret; 136 137 return lp55xx_write(chip, LP5523_REG_ENABLE_LEDS_LSB, 0xff); 138 } 139 140 static void lp5523_load_engine(struct lp55xx_chip *chip) 141 { 142 enum lp55xx_engine_index idx = chip->engine_idx; 143 u8 mask[] = { 144 [LP55XX_ENGINE_1] = LP5523_MODE_ENG1_M, 145 [LP55XX_ENGINE_2] = LP5523_MODE_ENG2_M, 146 [LP55XX_ENGINE_3] = LP5523_MODE_ENG3_M, 147 }; 148 149 u8 val[] = { 150 [LP55XX_ENGINE_1] = LP5523_LOAD_ENG1, 151 [LP55XX_ENGINE_2] = LP5523_LOAD_ENG2, 152 [LP55XX_ENGINE_3] = LP5523_LOAD_ENG3, 153 }; 154 155 u8 page_sel[] = { 156 [LP55XX_ENGINE_1] = LP5523_PAGE_ENG1, 157 [LP55XX_ENGINE_2] = LP5523_PAGE_ENG2, 158 [LP55XX_ENGINE_3] = LP5523_PAGE_ENG3, 159 }; 160 161 lp55xx_update_bits(chip, LP5523_REG_OP_MODE, mask[idx], val[idx]); 162 163 lp5523_wait_opmode_done(); 164 165 lp55xx_write(chip, LP5523_REG_PROG_PAGE_SEL, page_sel[idx]); 166 } 167 168 static void lp5523_stop_engine(struct lp55xx_chip *chip) 169 { 170 lp55xx_write(chip, LP5523_REG_OP_MODE, 0); 171 lp5523_wait_opmode_done(); 172 } 173 174 static void lp5523_turn_off_channels(struct lp55xx_chip *chip) 175 { 176 int i; 177 178 for (i = 0; i < LP5523_MAX_LEDS; i++) 179 lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + i, 0); 180 } 181 182 static void lp5523_run_engine(struct lp55xx_chip *chip, bool start) 183 { 184 int ret; 185 u8 mode; 186 u8 exec; 187 188 /* stop engine */ 189 if (!start) { 190 lp5523_stop_engine(chip); 191 lp5523_turn_off_channels(chip); 192 return; 193 } 194 195 /* 196 * To run the engine, 197 * operation mode and enable register should updated at the same time 198 */ 199 200 ret = lp55xx_read(chip, LP5523_REG_OP_MODE, &mode); 201 if (ret) 202 return; 203 204 ret = lp55xx_read(chip, LP5523_REG_ENABLE, &exec); 205 if (ret) 206 return; 207 208 /* change operation mode to RUN only when each engine is loading */ 209 if (LP5523_ENG1_IS_LOADING(mode)) { 210 mode = (mode & ~LP5523_MODE_ENG1_M) | LP5523_RUN_ENG1; 211 exec = (exec & ~LP5523_EXEC_ENG1_M) | LP5523_RUN_ENG1; 212 } 213 214 if (LP5523_ENG2_IS_LOADING(mode)) { 215 mode = (mode & ~LP5523_MODE_ENG2_M) | LP5523_RUN_ENG2; 216 exec = (exec & ~LP5523_EXEC_ENG2_M) | LP5523_RUN_ENG2; 217 } 218 219 if (LP5523_ENG3_IS_LOADING(mode)) { 220 mode = (mode & ~LP5523_MODE_ENG3_M) | LP5523_RUN_ENG3; 221 exec = (exec & ~LP5523_EXEC_ENG3_M) | LP5523_RUN_ENG3; 222 } 223 224 lp55xx_write(chip, LP5523_REG_OP_MODE, mode); 225 lp5523_wait_opmode_done(); 226 227 lp55xx_update_bits(chip, LP5523_REG_ENABLE, LP5523_EXEC_M, exec); 228 } 229 230 static int lp5523_update_program_memory(struct lp55xx_chip *chip, 231 const u8 *data, size_t size) 232 { 233 u8 pattern[LP5523_PROGRAM_LENGTH] = {0}; 234 unsigned cmd; 235 char c[3]; 236 int update_size; 237 int nrchars; 238 int offset = 0; 239 int ret; 240 int i; 241 242 /* clear program memory before updating */ 243 for (i = 0; i < LP5523_PROGRAM_LENGTH; i++) 244 lp55xx_write(chip, LP5523_REG_PROG_MEM + i, 0); 245 246 i = 0; 247 while ((offset < size - 1) && (i < LP5523_PROGRAM_LENGTH)) { 248 /* separate sscanfs because length is working only for %s */ 249 ret = sscanf(data + offset, "%2s%n ", c, &nrchars); 250 if (ret != 1) 251 goto err; 252 253 ret = sscanf(c, "%2x", &cmd); 254 if (ret != 1) 255 goto err; 256 257 pattern[i] = (u8)cmd; 258 offset += nrchars; 259 i++; 260 } 261 262 /* Each instruction is 16bit long. Check that length is even */ 263 if (i % 2) 264 goto err; 265 266 update_size = i; 267 for (i = 0; i < update_size; i++) 268 lp55xx_write(chip, LP5523_REG_PROG_MEM + i, pattern[i]); 269 270 return 0; 271 272 err: 273 dev_err(&chip->cl->dev, "wrong pattern format\n"); 274 return -EINVAL; 275 } 276 277 static void lp5523_firmware_loaded(struct lp55xx_chip *chip) 278 { 279 const struct firmware *fw = chip->fw; 280 281 if (fw->size > LP5523_PROGRAM_LENGTH) { 282 dev_err(&chip->cl->dev, "firmware data size overflow: %zu\n", 283 fw->size); 284 return; 285 } 286 287 /* 288 * Program momery sequence 289 * 1) set engine mode to "LOAD" 290 * 2) write firmware data into program memory 291 */ 292 293 lp5523_load_engine(chip); 294 lp5523_update_program_memory(chip, fw->data, fw->size); 295 } 296 297 static ssize_t lp5523_selftest(struct device *dev, 298 struct device_attribute *attr, 299 char *buf) 300 { 301 struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev)); 302 struct lp55xx_chip *chip = led->chip; 303 struct lp55xx_platform_data *pdata = chip->pdata; 304 int i, ret, pos = 0; 305 u8 status, adc, vdd; 306 307 mutex_lock(&chip->lock); 308 309 ret = lp55xx_read(chip, LP5523_REG_STATUS, &status); 310 if (ret < 0) 311 goto fail; 312 313 /* Check that ext clock is really in use if requested */ 314 if (pdata->clock_mode == LP55XX_CLOCK_EXT) { 315 if ((status & LP5523_EXT_CLK_USED) == 0) 316 goto fail; 317 } 318 319 /* Measure VDD (i.e. VBAT) first (channel 16 corresponds to VDD) */ 320 lp55xx_write(chip, LP5523_REG_LED_TEST_CTRL, LP5523_EN_LEDTEST | 16); 321 usleep_range(3000, 6000); /* ADC conversion time is typically 2.7 ms */ 322 ret = lp55xx_read(chip, LP5523_REG_STATUS, &status); 323 if (ret < 0) 324 goto fail; 325 326 if (!(status & LP5523_LEDTEST_DONE)) 327 usleep_range(3000, 6000); /* Was not ready. Wait little bit */ 328 329 ret = lp55xx_read(chip, LP5523_REG_LED_TEST_ADC, &vdd); 330 if (ret < 0) 331 goto fail; 332 333 vdd--; /* There may be some fluctuation in measurement */ 334 335 for (i = 0; i < LP5523_MAX_LEDS; i++) { 336 /* Skip non-existing channels */ 337 if (pdata->led_config[i].led_current == 0) 338 continue; 339 340 /* Set default current */ 341 lp55xx_write(chip, LP5523_REG_LED_CURRENT_BASE + i, 342 pdata->led_config[i].led_current); 343 344 lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + i, 0xff); 345 /* let current stabilize 2 - 4ms before measurements start */ 346 usleep_range(2000, 4000); 347 lp55xx_write(chip, LP5523_REG_LED_TEST_CTRL, 348 LP5523_EN_LEDTEST | i); 349 /* ADC conversion time is 2.7 ms typically */ 350 usleep_range(3000, 6000); 351 ret = lp55xx_read(chip, LP5523_REG_STATUS, &status); 352 if (ret < 0) 353 goto fail; 354 355 if (!(status & LP5523_LEDTEST_DONE)) 356 usleep_range(3000, 6000);/* Was not ready. Wait. */ 357 358 ret = lp55xx_read(chip, LP5523_REG_LED_TEST_ADC, &adc); 359 if (ret < 0) 360 goto fail; 361 362 if (adc >= vdd || adc < LP5523_ADC_SHORTCIRC_LIM) 363 pos += sprintf(buf + pos, "LED %d FAIL\n", i); 364 365 lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + i, 0x00); 366 367 /* Restore current */ 368 lp55xx_write(chip, LP5523_REG_LED_CURRENT_BASE + i, 369 led->led_current); 370 led++; 371 } 372 if (pos == 0) 373 pos = sprintf(buf, "OK\n"); 374 goto release_lock; 375 fail: 376 pos = sprintf(buf, "FAIL\n"); 377 378 release_lock: 379 mutex_unlock(&chip->lock); 380 381 return pos; 382 } 383 384 static void lp5523_led_brightness_work(struct work_struct *work) 385 { 386 struct lp55xx_led *led = container_of(work, struct lp55xx_led, 387 brightness_work); 388 struct lp55xx_chip *chip = led->chip; 389 390 mutex_lock(&chip->lock); 391 lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + led->chan_nr, 392 led->brightness); 393 mutex_unlock(&chip->lock); 394 } 395 396 static DEVICE_ATTR(selftest, S_IRUGO, lp5523_selftest, NULL); 397 398 static struct attribute *lp5523_attributes[] = { 399 &dev_attr_selftest.attr, 400 NULL, 401 }; 402 403 static const struct attribute_group lp5523_group = { 404 .attrs = lp5523_attributes, 405 }; 406 407 /* Chip specific configurations */ 408 static struct lp55xx_device_config lp5523_cfg = { 409 .reset = { 410 .addr = LP5523_REG_RESET, 411 .val = LP5523_RESET, 412 }, 413 .enable = { 414 .addr = LP5523_REG_ENABLE, 415 .val = LP5523_ENABLE, 416 }, 417 .max_channel = LP5523_MAX_LEDS, 418 .post_init_device = lp5523_post_init_device, 419 .brightness_work_fn = lp5523_led_brightness_work, 420 .set_led_current = lp5523_set_led_current, 421 .firmware_cb = lp5523_firmware_loaded, 422 .run_engine = lp5523_run_engine, 423 .dev_attr_group = &lp5523_group, 424 }; 425 426 static int lp5523_probe(struct i2c_client *client, 427 const struct i2c_device_id *id) 428 { 429 int ret; 430 struct lp55xx_chip *chip; 431 struct lp55xx_led *led; 432 struct lp55xx_platform_data *pdata = client->dev.platform_data; 433 434 if (!pdata) { 435 dev_err(&client->dev, "no platform data\n"); 436 return -EINVAL; 437 } 438 439 chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL); 440 if (!chip) 441 return -ENOMEM; 442 443 led = devm_kzalloc(&client->dev, 444 sizeof(*led) * pdata->num_channels, GFP_KERNEL); 445 if (!led) 446 return -ENOMEM; 447 448 chip->cl = client; 449 chip->pdata = pdata; 450 chip->cfg = &lp5523_cfg; 451 452 mutex_init(&chip->lock); 453 454 i2c_set_clientdata(client, led); 455 456 ret = lp55xx_init_device(chip); 457 if (ret) 458 goto err_init; 459 460 dev_info(&client->dev, "%s Programmable led chip found\n", id->name); 461 462 ret = lp55xx_register_leds(led, chip); 463 if (ret) 464 goto err_register_leds; 465 466 ret = lp55xx_register_sysfs(chip); 467 if (ret) { 468 dev_err(&client->dev, "registering sysfs failed\n"); 469 goto err_register_sysfs; 470 } 471 472 return 0; 473 474 err_register_sysfs: 475 lp55xx_unregister_leds(led, chip); 476 err_register_leds: 477 lp55xx_deinit_device(chip); 478 err_init: 479 return ret; 480 } 481 482 static int lp5523_remove(struct i2c_client *client) 483 { 484 struct lp55xx_led *led = i2c_get_clientdata(client); 485 struct lp55xx_chip *chip = led->chip; 486 487 lp5523_stop_engine(chip); 488 lp55xx_unregister_sysfs(chip); 489 lp55xx_unregister_leds(led, chip); 490 lp55xx_deinit_device(chip); 491 492 return 0; 493 } 494 495 static const struct i2c_device_id lp5523_id[] = { 496 { "lp5523", LP5523 }, 497 { "lp55231", LP55231 }, 498 { } 499 }; 500 501 MODULE_DEVICE_TABLE(i2c, lp5523_id); 502 503 static struct i2c_driver lp5523_driver = { 504 .driver = { 505 .name = "lp5523x", 506 }, 507 .probe = lp5523_probe, 508 .remove = lp5523_remove, 509 .id_table = lp5523_id, 510 }; 511 512 module_i2c_driver(lp5523_driver); 513 514 MODULE_AUTHOR("Mathias Nyman <mathias.nyman@nokia.com>"); 515 MODULE_AUTHOR("Milo Kim <milo.kim@ti.com>"); 516 MODULE_DESCRIPTION("LP5523 LED engine"); 517 MODULE_LICENSE("GPL"); 518