1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Simple driver for Texas Instruments LM3630A Backlight driver chip 4 * Copyright (C) 2012 Texas Instruments 5 */ 6 #include <linux/module.h> 7 #include <linux/slab.h> 8 #include <linux/i2c.h> 9 #include <linux/backlight.h> 10 #include <linux/err.h> 11 #include <linux/delay.h> 12 #include <linux/uaccess.h> 13 #include <linux/interrupt.h> 14 #include <linux/regmap.h> 15 #include <linux/gpio/consumer.h> 16 #include <linux/pwm.h> 17 #include <linux/platform_data/lm3630a_bl.h> 18 19 #define REG_CTRL 0x00 20 #define REG_BOOST 0x02 21 #define REG_CONFIG 0x01 22 #define REG_BRT_A 0x03 23 #define REG_BRT_B 0x04 24 #define REG_I_A 0x05 25 #define REG_I_B 0x06 26 #define REG_INT_STATUS 0x09 27 #define REG_INT_EN 0x0A 28 #define REG_FAULT 0x0B 29 #define REG_PWM_OUTLOW 0x12 30 #define REG_PWM_OUTHIGH 0x13 31 #define REG_FILTER_STRENGTH 0x50 32 #define REG_MAX 0x50 33 34 #define INT_DEBOUNCE_MSEC 10 35 36 #define LM3630A_BANK_0 0 37 #define LM3630A_BANK_1 1 38 39 #define LM3630A_NUM_SINKS 2 40 #define LM3630A_SINK_0 0 41 #define LM3630A_SINK_1 1 42 43 struct lm3630a_chip { 44 struct device *dev; 45 struct delayed_work work; 46 47 int irq; 48 struct workqueue_struct *irqthread; 49 struct lm3630a_platform_data *pdata; 50 struct backlight_device *bleda; 51 struct backlight_device *bledb; 52 struct gpio_desc *enable_gpio; 53 struct regmap *regmap; 54 struct pwm_device *pwmd; 55 struct pwm_state pwmd_state; 56 }; 57 58 /* i2c access */ 59 static int lm3630a_read(struct lm3630a_chip *pchip, unsigned int reg) 60 { 61 int rval; 62 unsigned int reg_val; 63 64 rval = regmap_read(pchip->regmap, reg, ®_val); 65 if (rval < 0) 66 return rval; 67 return reg_val & 0xFF; 68 } 69 70 static int lm3630a_write(struct lm3630a_chip *pchip, 71 unsigned int reg, unsigned int data) 72 { 73 return regmap_write(pchip->regmap, reg, data); 74 } 75 76 static int lm3630a_update(struct lm3630a_chip *pchip, 77 unsigned int reg, unsigned int mask, 78 unsigned int data) 79 { 80 return regmap_update_bits(pchip->regmap, reg, mask, data); 81 } 82 83 /* initialize chip */ 84 static int lm3630a_chip_init(struct lm3630a_chip *pchip) 85 { 86 int rval; 87 struct lm3630a_platform_data *pdata = pchip->pdata; 88 89 usleep_range(1000, 2000); 90 /* set Filter Strength Register */ 91 rval = lm3630a_write(pchip, REG_FILTER_STRENGTH, 0x03); 92 /* set Cofig. register */ 93 rval |= lm3630a_update(pchip, REG_CONFIG, 0x07, pdata->pwm_ctrl); 94 /* set boost control */ 95 rval |= lm3630a_write(pchip, REG_BOOST, 0x38); 96 /* set current A */ 97 rval |= lm3630a_update(pchip, REG_I_A, 0x1F, 0x1F); 98 /* set current B */ 99 rval |= lm3630a_write(pchip, REG_I_B, 0x1F); 100 /* set control */ 101 rval |= lm3630a_update(pchip, REG_CTRL, 0x14, pdata->leda_ctrl); 102 rval |= lm3630a_update(pchip, REG_CTRL, 0x0B, pdata->ledb_ctrl); 103 usleep_range(1000, 2000); 104 /* set brightness A and B */ 105 rval |= lm3630a_write(pchip, REG_BRT_A, pdata->leda_init_brt); 106 rval |= lm3630a_write(pchip, REG_BRT_B, pdata->ledb_init_brt); 107 108 if (rval < 0) 109 dev_err(pchip->dev, "i2c failed to access register\n"); 110 return rval; 111 } 112 113 /* interrupt handling */ 114 static void lm3630a_delayed_func(struct work_struct *work) 115 { 116 int rval; 117 struct lm3630a_chip *pchip; 118 119 pchip = container_of(work, struct lm3630a_chip, work.work); 120 121 rval = lm3630a_read(pchip, REG_INT_STATUS); 122 if (rval < 0) { 123 dev_err(pchip->dev, 124 "i2c failed to access REG_INT_STATUS Register\n"); 125 return; 126 } 127 128 dev_info(pchip->dev, "REG_INT_STATUS Register is 0x%x\n", rval); 129 } 130 131 static irqreturn_t lm3630a_isr_func(int irq, void *chip) 132 { 133 int rval; 134 struct lm3630a_chip *pchip = chip; 135 unsigned long delay = msecs_to_jiffies(INT_DEBOUNCE_MSEC); 136 137 queue_delayed_work(pchip->irqthread, &pchip->work, delay); 138 139 rval = lm3630a_update(pchip, REG_CTRL, 0x80, 0x00); 140 if (rval < 0) { 141 dev_err(pchip->dev, "i2c failed to access register\n"); 142 return IRQ_NONE; 143 } 144 return IRQ_HANDLED; 145 } 146 147 static int lm3630a_intr_config(struct lm3630a_chip *pchip) 148 { 149 int rval; 150 151 rval = lm3630a_write(pchip, REG_INT_EN, 0x87); 152 if (rval < 0) 153 return rval; 154 155 INIT_DELAYED_WORK(&pchip->work, lm3630a_delayed_func); 156 pchip->irqthread = create_singlethread_workqueue("lm3630a-irqthd"); 157 if (!pchip->irqthread) { 158 dev_err(pchip->dev, "create irq thread fail\n"); 159 return -ENOMEM; 160 } 161 if (request_threaded_irq 162 (pchip->irq, NULL, lm3630a_isr_func, 163 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "lm3630a_irq", pchip)) { 164 dev_err(pchip->dev, "request threaded irq fail\n"); 165 destroy_workqueue(pchip->irqthread); 166 return -ENOMEM; 167 } 168 return rval; 169 } 170 171 static int lm3630a_pwm_ctrl(struct lm3630a_chip *pchip, int br, int br_max) 172 { 173 int err; 174 175 pchip->pwmd_state.period = pchip->pdata->pwm_period; 176 177 err = pwm_set_relative_duty_cycle(&pchip->pwmd_state, br, br_max); 178 if (err) 179 return err; 180 181 pchip->pwmd_state.enabled = pchip->pwmd_state.duty_cycle ? true : false; 182 183 return pwm_apply_might_sleep(pchip->pwmd, &pchip->pwmd_state); 184 } 185 186 /* update and get brightness */ 187 static int lm3630a_bank_a_update_status(struct backlight_device *bl) 188 { 189 int ret; 190 struct lm3630a_chip *pchip = bl_get_data(bl); 191 enum lm3630a_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl; 192 193 /* pwm control */ 194 if ((pwm_ctrl & LM3630A_PWM_BANK_A) != 0) 195 return lm3630a_pwm_ctrl(pchip, bl->props.brightness, 196 bl->props.max_brightness); 197 198 /* disable sleep */ 199 ret = lm3630a_update(pchip, REG_CTRL, 0x80, 0x00); 200 if (ret < 0) 201 goto out_i2c_err; 202 usleep_range(1000, 2000); 203 /* minimum brightness is 0x04 */ 204 ret = lm3630a_write(pchip, REG_BRT_A, bl->props.brightness); 205 206 if (backlight_is_blank(bl) || (backlight_get_brightness(bl) < 0x4)) 207 /* turn the string off */ 208 ret |= lm3630a_update(pchip, REG_CTRL, LM3630A_LEDA_ENABLE, 0); 209 else 210 ret |= lm3630a_update(pchip, REG_CTRL, 211 LM3630A_LEDA_ENABLE, LM3630A_LEDA_ENABLE); 212 if (ret < 0) 213 goto out_i2c_err; 214 return 0; 215 216 out_i2c_err: 217 dev_err(pchip->dev, "i2c failed to access (%pe)\n", ERR_PTR(ret)); 218 return ret; 219 } 220 221 static int lm3630a_bank_a_get_brightness(struct backlight_device *bl) 222 { 223 int brightness, rval; 224 struct lm3630a_chip *pchip = bl_get_data(bl); 225 enum lm3630a_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl; 226 227 if ((pwm_ctrl & LM3630A_PWM_BANK_A) != 0) { 228 rval = lm3630a_read(pchip, REG_PWM_OUTHIGH); 229 if (rval < 0) 230 goto out_i2c_err; 231 brightness = (rval & 0x01) << 8; 232 rval = lm3630a_read(pchip, REG_PWM_OUTLOW); 233 if (rval < 0) 234 goto out_i2c_err; 235 brightness |= rval; 236 goto out; 237 } 238 239 /* disable sleep */ 240 rval = lm3630a_update(pchip, REG_CTRL, 0x80, 0x00); 241 if (rval < 0) 242 goto out_i2c_err; 243 usleep_range(1000, 2000); 244 rval = lm3630a_read(pchip, REG_BRT_A); 245 if (rval < 0) 246 goto out_i2c_err; 247 brightness = rval; 248 249 out: 250 bl->props.brightness = brightness; 251 return bl->props.brightness; 252 out_i2c_err: 253 dev_err(pchip->dev, "i2c failed to access register\n"); 254 return 0; 255 } 256 257 static const struct backlight_ops lm3630a_bank_a_ops = { 258 .options = BL_CORE_SUSPENDRESUME, 259 .update_status = lm3630a_bank_a_update_status, 260 .get_brightness = lm3630a_bank_a_get_brightness, 261 }; 262 263 /* update and get brightness */ 264 static int lm3630a_bank_b_update_status(struct backlight_device *bl) 265 { 266 int ret; 267 struct lm3630a_chip *pchip = bl_get_data(bl); 268 enum lm3630a_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl; 269 270 /* pwm control */ 271 if ((pwm_ctrl & LM3630A_PWM_BANK_B) != 0) 272 return lm3630a_pwm_ctrl(pchip, bl->props.brightness, 273 bl->props.max_brightness); 274 275 /* disable sleep */ 276 ret = lm3630a_update(pchip, REG_CTRL, 0x80, 0x00); 277 if (ret < 0) 278 goto out_i2c_err; 279 usleep_range(1000, 2000); 280 /* minimum brightness is 0x04 */ 281 ret = lm3630a_write(pchip, REG_BRT_B, bl->props.brightness); 282 283 if (backlight_is_blank(bl) || (backlight_get_brightness(bl) < 0x4)) 284 /* turn the string off */ 285 ret |= lm3630a_update(pchip, REG_CTRL, LM3630A_LEDB_ENABLE, 0); 286 else 287 ret |= lm3630a_update(pchip, REG_CTRL, 288 LM3630A_LEDB_ENABLE, LM3630A_LEDB_ENABLE); 289 if (ret < 0) 290 goto out_i2c_err; 291 return 0; 292 293 out_i2c_err: 294 dev_err(pchip->dev, "i2c failed to access (%pe)\n", ERR_PTR(ret)); 295 return ret; 296 } 297 298 static int lm3630a_bank_b_get_brightness(struct backlight_device *bl) 299 { 300 int brightness, rval; 301 struct lm3630a_chip *pchip = bl_get_data(bl); 302 enum lm3630a_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl; 303 304 if ((pwm_ctrl & LM3630A_PWM_BANK_B) != 0) { 305 rval = lm3630a_read(pchip, REG_PWM_OUTHIGH); 306 if (rval < 0) 307 goto out_i2c_err; 308 brightness = (rval & 0x01) << 8; 309 rval = lm3630a_read(pchip, REG_PWM_OUTLOW); 310 if (rval < 0) 311 goto out_i2c_err; 312 brightness |= rval; 313 goto out; 314 } 315 316 /* disable sleep */ 317 rval = lm3630a_update(pchip, REG_CTRL, 0x80, 0x00); 318 if (rval < 0) 319 goto out_i2c_err; 320 usleep_range(1000, 2000); 321 rval = lm3630a_read(pchip, REG_BRT_B); 322 if (rval < 0) 323 goto out_i2c_err; 324 brightness = rval; 325 326 out: 327 bl->props.brightness = brightness; 328 return bl->props.brightness; 329 out_i2c_err: 330 dev_err(pchip->dev, "i2c failed to access register\n"); 331 return 0; 332 } 333 334 static const struct backlight_ops lm3630a_bank_b_ops = { 335 .options = BL_CORE_SUSPENDRESUME, 336 .update_status = lm3630a_bank_b_update_status, 337 .get_brightness = lm3630a_bank_b_get_brightness, 338 }; 339 340 static int lm3630a_backlight_register(struct lm3630a_chip *pchip) 341 { 342 struct lm3630a_platform_data *pdata = pchip->pdata; 343 struct backlight_properties props; 344 const char *label; 345 346 props.type = BACKLIGHT_RAW; 347 if (pdata->leda_ctrl != LM3630A_LEDA_DISABLE) { 348 props.brightness = pdata->leda_init_brt; 349 props.max_brightness = pdata->leda_max_brt; 350 label = pdata->leda_label ? pdata->leda_label : "lm3630a_leda"; 351 pchip->bleda = 352 devm_backlight_device_register(pchip->dev, label, 353 pchip->dev, pchip, 354 &lm3630a_bank_a_ops, &props); 355 if (IS_ERR(pchip->bleda)) 356 return PTR_ERR(pchip->bleda); 357 } 358 359 if ((pdata->ledb_ctrl != LM3630A_LEDB_DISABLE) && 360 (pdata->ledb_ctrl != LM3630A_LEDB_ON_A)) { 361 props.brightness = pdata->ledb_init_brt; 362 props.max_brightness = pdata->ledb_max_brt; 363 label = pdata->ledb_label ? pdata->ledb_label : "lm3630a_ledb"; 364 pchip->bledb = 365 devm_backlight_device_register(pchip->dev, label, 366 pchip->dev, pchip, 367 &lm3630a_bank_b_ops, &props); 368 if (IS_ERR(pchip->bledb)) 369 return PTR_ERR(pchip->bledb); 370 } 371 return 0; 372 } 373 374 static const struct regmap_config lm3630a_regmap = { 375 .reg_bits = 8, 376 .val_bits = 8, 377 .max_register = REG_MAX, 378 }; 379 380 static int lm3630a_parse_led_sources(struct fwnode_handle *node, 381 int default_led_sources) 382 { 383 u32 sources[LM3630A_NUM_SINKS]; 384 int ret, num_sources, i; 385 386 num_sources = fwnode_property_count_u32(node, "led-sources"); 387 if (num_sources < 0) 388 return default_led_sources; 389 else if (num_sources > ARRAY_SIZE(sources)) 390 return -EINVAL; 391 392 ret = fwnode_property_read_u32_array(node, "led-sources", sources, 393 num_sources); 394 if (ret) 395 return ret; 396 397 for (i = 0; i < num_sources; i++) { 398 if (sources[i] != LM3630A_SINK_0 && sources[i] != LM3630A_SINK_1) 399 return -EINVAL; 400 401 ret |= BIT(sources[i]); 402 } 403 404 return ret; 405 } 406 407 static int lm3630a_parse_bank(struct lm3630a_platform_data *pdata, 408 struct fwnode_handle *node, int *seen_led_sources) 409 { 410 int led_sources, ret; 411 const char *label; 412 u32 bank, val; 413 bool linear; 414 415 ret = fwnode_property_read_u32(node, "reg", &bank); 416 if (ret) 417 return ret; 418 419 if (bank != LM3630A_BANK_0 && bank != LM3630A_BANK_1) 420 return -EINVAL; 421 422 led_sources = lm3630a_parse_led_sources(node, BIT(bank)); 423 if (led_sources < 0) 424 return led_sources; 425 426 if (*seen_led_sources & led_sources) 427 return -EINVAL; 428 429 *seen_led_sources |= led_sources; 430 431 linear = fwnode_property_read_bool(node, 432 "ti,linear-mapping-mode"); 433 if (bank) { 434 if (led_sources & BIT(LM3630A_SINK_0) || 435 !(led_sources & BIT(LM3630A_SINK_1))) 436 return -EINVAL; 437 438 pdata->ledb_ctrl = linear ? 439 LM3630A_LEDB_ENABLE_LINEAR : 440 LM3630A_LEDB_ENABLE; 441 } else { 442 if (!(led_sources & BIT(LM3630A_SINK_0))) 443 return -EINVAL; 444 445 pdata->leda_ctrl = linear ? 446 LM3630A_LEDA_ENABLE_LINEAR : 447 LM3630A_LEDA_ENABLE; 448 449 if (led_sources & BIT(LM3630A_SINK_1)) 450 pdata->ledb_ctrl = LM3630A_LEDB_ON_A; 451 } 452 453 ret = fwnode_property_read_string(node, "label", &label); 454 if (!ret) { 455 if (bank) 456 pdata->ledb_label = label; 457 else 458 pdata->leda_label = label; 459 } 460 461 ret = fwnode_property_read_u32(node, "default-brightness", 462 &val); 463 if (!ret) { 464 if (bank) 465 pdata->ledb_init_brt = val; 466 else 467 pdata->leda_init_brt = val; 468 } 469 470 ret = fwnode_property_read_u32(node, "max-brightness", &val); 471 if (!ret) { 472 if (bank) 473 pdata->ledb_max_brt = val; 474 else 475 pdata->leda_max_brt = val; 476 } 477 478 return 0; 479 } 480 481 static int lm3630a_parse_node(struct lm3630a_chip *pchip, 482 struct lm3630a_platform_data *pdata) 483 { 484 int ret = -ENODEV, seen_led_sources = 0; 485 struct fwnode_handle *node; 486 487 device_for_each_child_node(pchip->dev, node) { 488 ret = lm3630a_parse_bank(pdata, node, &seen_led_sources); 489 if (ret) { 490 fwnode_handle_put(node); 491 return ret; 492 } 493 } 494 495 return ret; 496 } 497 498 static int lm3630a_probe(struct i2c_client *client) 499 { 500 struct lm3630a_platform_data *pdata = dev_get_platdata(&client->dev); 501 struct lm3630a_chip *pchip; 502 int rval; 503 504 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 505 dev_err(&client->dev, "fail : i2c functionality check\n"); 506 return -EOPNOTSUPP; 507 } 508 509 pchip = devm_kzalloc(&client->dev, sizeof(struct lm3630a_chip), 510 GFP_KERNEL); 511 if (!pchip) 512 return -ENOMEM; 513 pchip->dev = &client->dev; 514 515 pchip->regmap = devm_regmap_init_i2c(client, &lm3630a_regmap); 516 if (IS_ERR(pchip->regmap)) { 517 rval = PTR_ERR(pchip->regmap); 518 dev_err(&client->dev, "fail : allocate reg. map: %d\n", rval); 519 return rval; 520 } 521 522 i2c_set_clientdata(client, pchip); 523 if (pdata == NULL) { 524 pdata = devm_kzalloc(pchip->dev, 525 sizeof(struct lm3630a_platform_data), 526 GFP_KERNEL); 527 if (pdata == NULL) 528 return -ENOMEM; 529 530 /* default values */ 531 pdata->leda_max_brt = LM3630A_MAX_BRIGHTNESS; 532 pdata->ledb_max_brt = LM3630A_MAX_BRIGHTNESS; 533 pdata->leda_init_brt = LM3630A_MAX_BRIGHTNESS; 534 pdata->ledb_init_brt = LM3630A_MAX_BRIGHTNESS; 535 536 rval = lm3630a_parse_node(pchip, pdata); 537 if (rval) { 538 dev_err(&client->dev, "fail : parse node\n"); 539 return rval; 540 } 541 } 542 pchip->pdata = pdata; 543 544 pchip->enable_gpio = devm_gpiod_get_optional(&client->dev, "enable", 545 GPIOD_OUT_HIGH); 546 if (IS_ERR(pchip->enable_gpio)) { 547 rval = PTR_ERR(pchip->enable_gpio); 548 return rval; 549 } 550 551 /* chip initialize */ 552 rval = lm3630a_chip_init(pchip); 553 if (rval < 0) { 554 dev_err(&client->dev, "fail : init chip\n"); 555 return rval; 556 } 557 /* backlight register */ 558 rval = lm3630a_backlight_register(pchip); 559 if (rval < 0) { 560 dev_err(&client->dev, "fail : backlight register.\n"); 561 return rval; 562 } 563 /* pwm */ 564 if (pdata->pwm_ctrl != LM3630A_PWM_DISABLE) { 565 pchip->pwmd = devm_pwm_get(pchip->dev, "lm3630a-pwm"); 566 if (IS_ERR(pchip->pwmd)) { 567 dev_err(&client->dev, "fail : get pwm device\n"); 568 return PTR_ERR(pchip->pwmd); 569 } 570 571 pwm_init_state(pchip->pwmd, &pchip->pwmd_state); 572 } 573 574 /* interrupt enable : irq 0 is not allowed */ 575 pchip->irq = client->irq; 576 if (pchip->irq) { 577 rval = lm3630a_intr_config(pchip); 578 if (rval < 0) 579 return rval; 580 } 581 dev_info(&client->dev, "LM3630A backlight register OK.\n"); 582 return 0; 583 } 584 585 static void lm3630a_remove(struct i2c_client *client) 586 { 587 int rval; 588 struct lm3630a_chip *pchip = i2c_get_clientdata(client); 589 590 rval = lm3630a_write(pchip, REG_BRT_A, 0); 591 if (rval < 0) 592 dev_err(pchip->dev, "i2c failed to access register\n"); 593 594 rval = lm3630a_write(pchip, REG_BRT_B, 0); 595 if (rval < 0) 596 dev_err(pchip->dev, "i2c failed to access register\n"); 597 598 if (pchip->irq) { 599 free_irq(pchip->irq, pchip); 600 destroy_workqueue(pchip->irqthread); 601 } 602 } 603 604 static const struct i2c_device_id lm3630a_id[] = { 605 {LM3630A_NAME, 0}, 606 {} 607 }; 608 609 MODULE_DEVICE_TABLE(i2c, lm3630a_id); 610 611 static const struct of_device_id lm3630a_match_table[] = { 612 { .compatible = "ti,lm3630a", }, 613 { }, 614 }; 615 616 MODULE_DEVICE_TABLE(of, lm3630a_match_table); 617 618 static struct i2c_driver lm3630a_i2c_driver = { 619 .driver = { 620 .name = LM3630A_NAME, 621 .of_match_table = lm3630a_match_table, 622 }, 623 .probe = lm3630a_probe, 624 .remove = lm3630a_remove, 625 .id_table = lm3630a_id, 626 }; 627 628 module_i2c_driver(lm3630a_i2c_driver); 629 630 MODULE_DESCRIPTION("Texas Instruments Backlight driver for LM3630A"); 631 MODULE_AUTHOR("Daniel Jeong <gshark.jeong@gmail.com>"); 632 MODULE_AUTHOR("LDD MLP <ldd-mlp@list.ti.com>"); 633 MODULE_LICENSE("GPL v2"); 634