1 /* 2 * LP5521 LED chip 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 LP5521_PROGRAM_LENGTH 32 38 #define LP5521_MAX_LEDS 3 39 #define LP5521_CMD_DIRECT 0x3F 40 41 /* Registers */ 42 #define LP5521_REG_ENABLE 0x00 43 #define LP5521_REG_OP_MODE 0x01 44 #define LP5521_REG_R_PWM 0x02 45 #define LP5521_REG_G_PWM 0x03 46 #define LP5521_REG_B_PWM 0x04 47 #define LP5521_REG_R_CURRENT 0x05 48 #define LP5521_REG_G_CURRENT 0x06 49 #define LP5521_REG_B_CURRENT 0x07 50 #define LP5521_REG_CONFIG 0x08 51 #define LP5521_REG_STATUS 0x0C 52 #define LP5521_REG_RESET 0x0D 53 #define LP5521_REG_R_PROG_MEM 0x10 54 #define LP5521_REG_G_PROG_MEM 0x30 55 #define LP5521_REG_B_PROG_MEM 0x50 56 57 /* Base register to set LED current */ 58 #define LP5521_REG_LED_CURRENT_BASE LP5521_REG_R_CURRENT 59 /* Base register to set the brightness */ 60 #define LP5521_REG_LED_PWM_BASE LP5521_REG_R_PWM 61 62 /* Bits in ENABLE register */ 63 #define LP5521_MASTER_ENABLE 0x40 /* Chip master enable */ 64 #define LP5521_LOGARITHMIC_PWM 0x80 /* Logarithmic PWM adjustment */ 65 #define LP5521_EXEC_RUN 0x2A 66 #define LP5521_ENABLE_DEFAULT \ 67 (LP5521_MASTER_ENABLE | LP5521_LOGARITHMIC_PWM) 68 #define LP5521_ENABLE_RUN_PROGRAM \ 69 (LP5521_ENABLE_DEFAULT | LP5521_EXEC_RUN) 70 71 /* Status */ 72 #define LP5521_EXT_CLK_USED 0x08 73 74 /* default R channel current register value */ 75 #define LP5521_REG_R_CURR_DEFAULT 0xAF 76 77 /* Reset register value */ 78 #define LP5521_RESET 0xFF 79 80 /* Program Memory Operations */ 81 #define LP5521_MODE_R_M 0x30 /* Operation Mode Register */ 82 #define LP5521_MODE_G_M 0x0C 83 #define LP5521_MODE_B_M 0x03 84 #define LP5521_LOAD_R 0x10 85 #define LP5521_LOAD_G 0x04 86 #define LP5521_LOAD_B 0x01 87 88 #define LP5521_R_IS_LOADING(mode) \ 89 ((mode & LP5521_MODE_R_M) == LP5521_LOAD_R) 90 #define LP5521_G_IS_LOADING(mode) \ 91 ((mode & LP5521_MODE_G_M) == LP5521_LOAD_G) 92 #define LP5521_B_IS_LOADING(mode) \ 93 ((mode & LP5521_MODE_B_M) == LP5521_LOAD_B) 94 95 #define LP5521_EXEC_R_M 0x30 /* Enable Register */ 96 #define LP5521_EXEC_G_M 0x0C 97 #define LP5521_EXEC_B_M 0x03 98 #define LP5521_EXEC_M 0x3F 99 #define LP5521_RUN_R 0x20 100 #define LP5521_RUN_G 0x08 101 #define LP5521_RUN_B 0x02 102 103 static inline void lp5521_wait_opmode_done(void) 104 { 105 /* operation mode change needs to be longer than 153 us */ 106 usleep_range(200, 300); 107 } 108 109 static inline void lp5521_wait_enable_done(void) 110 { 111 /* it takes more 488 us to update ENABLE register */ 112 usleep_range(500, 600); 113 } 114 115 static void lp5521_set_led_current(struct lp55xx_led *led, u8 led_current) 116 { 117 led->led_current = led_current; 118 lp55xx_write(led->chip, LP5521_REG_LED_CURRENT_BASE + led->chan_nr, 119 led_current); 120 } 121 122 static void lp5521_load_engine(struct lp55xx_chip *chip) 123 { 124 enum lp55xx_engine_index idx = chip->engine_idx; 125 u8 mask[] = { 126 [LP55XX_ENGINE_1] = LP5521_MODE_R_M, 127 [LP55XX_ENGINE_2] = LP5521_MODE_G_M, 128 [LP55XX_ENGINE_3] = LP5521_MODE_B_M, 129 }; 130 131 u8 val[] = { 132 [LP55XX_ENGINE_1] = LP5521_LOAD_R, 133 [LP55XX_ENGINE_2] = LP5521_LOAD_G, 134 [LP55XX_ENGINE_3] = LP5521_LOAD_B, 135 }; 136 137 lp55xx_update_bits(chip, LP5521_REG_OP_MODE, mask[idx], val[idx]); 138 139 lp5521_wait_opmode_done(); 140 } 141 142 static void lp5521_stop_engine(struct lp55xx_chip *chip) 143 { 144 lp55xx_write(chip, LP5521_REG_OP_MODE, 0); 145 lp5521_wait_opmode_done(); 146 } 147 148 static void lp5521_run_engine(struct lp55xx_chip *chip, bool start) 149 { 150 int ret; 151 u8 mode; 152 u8 exec; 153 154 /* stop engine */ 155 if (!start) { 156 lp5521_stop_engine(chip); 157 lp55xx_write(chip, LP5521_REG_OP_MODE, LP5521_CMD_DIRECT); 158 lp5521_wait_opmode_done(); 159 return; 160 } 161 162 /* 163 * To run the engine, 164 * operation mode and enable register should updated at the same time 165 */ 166 167 ret = lp55xx_read(chip, LP5521_REG_OP_MODE, &mode); 168 if (ret) 169 return; 170 171 ret = lp55xx_read(chip, LP5521_REG_ENABLE, &exec); 172 if (ret) 173 return; 174 175 /* change operation mode to RUN only when each engine is loading */ 176 if (LP5521_R_IS_LOADING(mode)) { 177 mode = (mode & ~LP5521_MODE_R_M) | LP5521_RUN_R; 178 exec = (exec & ~LP5521_EXEC_R_M) | LP5521_RUN_R; 179 } 180 181 if (LP5521_G_IS_LOADING(mode)) { 182 mode = (mode & ~LP5521_MODE_G_M) | LP5521_RUN_G; 183 exec = (exec & ~LP5521_EXEC_G_M) | LP5521_RUN_G; 184 } 185 186 if (LP5521_B_IS_LOADING(mode)) { 187 mode = (mode & ~LP5521_MODE_B_M) | LP5521_RUN_B; 188 exec = (exec & ~LP5521_EXEC_B_M) | LP5521_RUN_B; 189 } 190 191 lp55xx_write(chip, LP5521_REG_OP_MODE, mode); 192 lp5521_wait_opmode_done(); 193 194 lp55xx_update_bits(chip, LP5521_REG_ENABLE, LP5521_EXEC_M, exec); 195 lp5521_wait_enable_done(); 196 } 197 198 static int lp5521_update_program_memory(struct lp55xx_chip *chip, 199 const u8 *data, size_t size) 200 { 201 enum lp55xx_engine_index idx = chip->engine_idx; 202 u8 pattern[LP5521_PROGRAM_LENGTH] = {0}; 203 u8 addr[] = { 204 [LP55XX_ENGINE_1] = LP5521_REG_R_PROG_MEM, 205 [LP55XX_ENGINE_2] = LP5521_REG_G_PROG_MEM, 206 [LP55XX_ENGINE_3] = LP5521_REG_B_PROG_MEM, 207 }; 208 unsigned cmd; 209 char c[3]; 210 int program_size; 211 int nrchars; 212 int offset = 0; 213 int ret; 214 int i; 215 216 /* clear program memory before updating */ 217 for (i = 0; i < LP5521_PROGRAM_LENGTH; i++) 218 lp55xx_write(chip, addr[idx] + i, 0); 219 220 i = 0; 221 while ((offset < size - 1) && (i < LP5521_PROGRAM_LENGTH)) { 222 /* separate sscanfs because length is working only for %s */ 223 ret = sscanf(data + offset, "%2s%n ", c, &nrchars); 224 if (ret != 1) 225 goto err; 226 227 ret = sscanf(c, "%2x", &cmd); 228 if (ret != 1) 229 goto err; 230 231 pattern[i] = (u8)cmd; 232 offset += nrchars; 233 i++; 234 } 235 236 /* Each instruction is 16bit long. Check that length is even */ 237 if (i % 2) 238 goto err; 239 240 program_size = i; 241 for (i = 0; i < program_size; i++) 242 lp55xx_write(chip, addr[idx] + i, pattern[i]); 243 244 return 0; 245 246 err: 247 dev_err(&chip->cl->dev, "wrong pattern format\n"); 248 return -EINVAL; 249 } 250 251 static void lp5521_firmware_loaded(struct lp55xx_chip *chip) 252 { 253 const struct firmware *fw = chip->fw; 254 255 if (fw->size > LP5521_PROGRAM_LENGTH) { 256 dev_err(&chip->cl->dev, "firmware data size overflow: %zu\n", 257 fw->size); 258 return; 259 } 260 261 /* 262 * Program momery sequence 263 * 1) set engine mode to "LOAD" 264 * 2) write firmware data into program memory 265 */ 266 267 lp5521_load_engine(chip); 268 lp5521_update_program_memory(chip, fw->data, fw->size); 269 } 270 271 static int lp5521_post_init_device(struct lp55xx_chip *chip) 272 { 273 int ret; 274 u8 val; 275 276 /* 277 * Make sure that the chip is reset by reading back the r channel 278 * current reg. This is dummy read is required on some platforms - 279 * otherwise further access to the R G B channels in the 280 * LP5521_REG_ENABLE register will not have any effect - strange! 281 */ 282 ret = lp55xx_read(chip, LP5521_REG_R_CURRENT, &val); 283 if (ret) { 284 dev_err(&chip->cl->dev, "error in resetting chip\n"); 285 return ret; 286 } 287 if (val != LP5521_REG_R_CURR_DEFAULT) { 288 dev_err(&chip->cl->dev, 289 "unexpected data in register (expected 0x%x got 0x%x)\n", 290 LP5521_REG_R_CURR_DEFAULT, val); 291 ret = -EINVAL; 292 return ret; 293 } 294 usleep_range(10000, 20000); 295 296 /* Set all PWMs to direct control mode */ 297 ret = lp55xx_write(chip, LP5521_REG_OP_MODE, LP5521_CMD_DIRECT); 298 299 val = chip->pdata->update_config ? 300 : (LP5521_PWRSAVE_EN | LP5521_CP_MODE_AUTO | LP5521_R_TO_BATT); 301 ret = lp55xx_write(chip, LP5521_REG_CONFIG, val); 302 if (ret) 303 return ret; 304 305 /* Initialize all channels PWM to zero -> leds off */ 306 lp55xx_write(chip, LP5521_REG_R_PWM, 0); 307 lp55xx_write(chip, LP5521_REG_G_PWM, 0); 308 lp55xx_write(chip, LP5521_REG_B_PWM, 0); 309 310 /* Set engines are set to run state when OP_MODE enables engines */ 311 ret = lp55xx_write(chip, LP5521_REG_ENABLE, LP5521_ENABLE_RUN_PROGRAM); 312 if (ret) 313 return ret; 314 315 lp5521_wait_enable_done(); 316 317 return 0; 318 } 319 320 static int lp5521_run_selftest(struct lp55xx_chip *chip, char *buf) 321 { 322 struct lp55xx_platform_data *pdata = chip->pdata; 323 int ret; 324 u8 status; 325 326 ret = lp55xx_read(chip, LP5521_REG_STATUS, &status); 327 if (ret < 0) 328 return ret; 329 330 if (pdata->clock_mode != LP55XX_CLOCK_EXT) 331 return 0; 332 333 /* Check that ext clock is really in use if requested */ 334 if ((status & LP5521_EXT_CLK_USED) == 0) 335 return -EIO; 336 337 return 0; 338 } 339 340 static void lp5521_led_brightness_work(struct work_struct *work) 341 { 342 struct lp55xx_led *led = container_of(work, struct lp55xx_led, 343 brightness_work); 344 struct lp55xx_chip *chip = led->chip; 345 346 mutex_lock(&chip->lock); 347 lp55xx_write(chip, LP5521_REG_LED_PWM_BASE + led->chan_nr, 348 led->brightness); 349 mutex_unlock(&chip->lock); 350 } 351 352 static ssize_t lp5521_selftest(struct device *dev, 353 struct device_attribute *attr, 354 char *buf) 355 { 356 struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev)); 357 struct lp55xx_chip *chip = led->chip; 358 int ret; 359 360 mutex_lock(&chip->lock); 361 ret = lp5521_run_selftest(chip, buf); 362 mutex_unlock(&chip->lock); 363 return sprintf(buf, "%s\n", ret ? "FAIL" : "OK"); 364 } 365 366 /* device attributes */ 367 static DEVICE_ATTR(selftest, S_IRUGO, lp5521_selftest, NULL); 368 369 static struct attribute *lp5521_attributes[] = { 370 &dev_attr_selftest.attr, 371 NULL 372 }; 373 374 static const struct attribute_group lp5521_group = { 375 .attrs = lp5521_attributes, 376 }; 377 378 /* Chip specific configurations */ 379 static struct lp55xx_device_config lp5521_cfg = { 380 .reset = { 381 .addr = LP5521_REG_RESET, 382 .val = LP5521_RESET, 383 }, 384 .enable = { 385 .addr = LP5521_REG_ENABLE, 386 .val = LP5521_ENABLE_DEFAULT, 387 }, 388 .max_channel = LP5521_MAX_LEDS, 389 .post_init_device = lp5521_post_init_device, 390 .brightness_work_fn = lp5521_led_brightness_work, 391 .set_led_current = lp5521_set_led_current, 392 .firmware_cb = lp5521_firmware_loaded, 393 .run_engine = lp5521_run_engine, 394 .dev_attr_group = &lp5521_group, 395 }; 396 397 static int lp5521_probe(struct i2c_client *client, 398 const struct i2c_device_id *id) 399 { 400 int ret; 401 struct lp55xx_chip *chip; 402 struct lp55xx_led *led; 403 struct lp55xx_platform_data *pdata = client->dev.platform_data; 404 405 if (!pdata) { 406 dev_err(&client->dev, "no platform data\n"); 407 return -EINVAL; 408 } 409 410 chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL); 411 if (!chip) 412 return -ENOMEM; 413 414 led = devm_kzalloc(&client->dev, 415 sizeof(*led) * pdata->num_channels, GFP_KERNEL); 416 if (!led) 417 return -ENOMEM; 418 419 chip->cl = client; 420 chip->pdata = pdata; 421 chip->cfg = &lp5521_cfg; 422 423 mutex_init(&chip->lock); 424 425 i2c_set_clientdata(client, led); 426 427 ret = lp55xx_init_device(chip); 428 if (ret) 429 goto err_init; 430 431 dev_info(&client->dev, "%s programmable led chip found\n", id->name); 432 433 ret = lp55xx_register_leds(led, chip); 434 if (ret) 435 goto err_register_leds; 436 437 ret = lp55xx_register_sysfs(chip); 438 if (ret) { 439 dev_err(&client->dev, "registering sysfs failed\n"); 440 goto err_register_sysfs; 441 } 442 443 return 0; 444 445 err_register_sysfs: 446 lp55xx_unregister_leds(led, chip); 447 err_register_leds: 448 lp55xx_deinit_device(chip); 449 err_init: 450 return ret; 451 } 452 453 static int lp5521_remove(struct i2c_client *client) 454 { 455 struct lp55xx_led *led = i2c_get_clientdata(client); 456 struct lp55xx_chip *chip = led->chip; 457 458 lp5521_stop_engine(chip); 459 lp55xx_unregister_sysfs(chip); 460 lp55xx_unregister_leds(led, chip); 461 lp55xx_deinit_device(chip); 462 463 return 0; 464 } 465 466 static const struct i2c_device_id lp5521_id[] = { 467 { "lp5521", 0 }, /* Three channel chip */ 468 { } 469 }; 470 MODULE_DEVICE_TABLE(i2c, lp5521_id); 471 472 static struct i2c_driver lp5521_driver = { 473 .driver = { 474 .name = "lp5521", 475 }, 476 .probe = lp5521_probe, 477 .remove = lp5521_remove, 478 .id_table = lp5521_id, 479 }; 480 481 module_i2c_driver(lp5521_driver); 482 483 MODULE_AUTHOR("Mathias Nyman, Yuri Zaporozhets, Samu Onkalo"); 484 MODULE_AUTHOR("Milo Kim <milo.kim@ti.com>"); 485 MODULE_DESCRIPTION("LP5521 LED engine"); 486 MODULE_LICENSE("GPL v2"); 487