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_state(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 return brightness; 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 return rval; 248 249 out_i2c_err: 250 dev_err(pchip->dev, "i2c failed to access register\n"); 251 return 0; 252 } 253 254 static const struct backlight_ops lm3630a_bank_a_ops = { 255 .options = BL_CORE_SUSPENDRESUME, 256 .update_status = lm3630a_bank_a_update_status, 257 .get_brightness = lm3630a_bank_a_get_brightness, 258 }; 259 260 /* update and get brightness */ 261 static int lm3630a_bank_b_update_status(struct backlight_device *bl) 262 { 263 int ret; 264 struct lm3630a_chip *pchip = bl_get_data(bl); 265 enum lm3630a_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl; 266 267 /* pwm control */ 268 if ((pwm_ctrl & LM3630A_PWM_BANK_B) != 0) 269 return lm3630a_pwm_ctrl(pchip, bl->props.brightness, 270 bl->props.max_brightness); 271 272 /* disable sleep */ 273 ret = lm3630a_update(pchip, REG_CTRL, 0x80, 0x00); 274 if (ret < 0) 275 goto out_i2c_err; 276 usleep_range(1000, 2000); 277 /* minimum brightness is 0x04 */ 278 ret = lm3630a_write(pchip, REG_BRT_B, bl->props.brightness); 279 280 if (backlight_is_blank(bl) || (backlight_get_brightness(bl) < 0x4)) 281 /* turn the string off */ 282 ret |= lm3630a_update(pchip, REG_CTRL, LM3630A_LEDB_ENABLE, 0); 283 else 284 ret |= lm3630a_update(pchip, REG_CTRL, 285 LM3630A_LEDB_ENABLE, LM3630A_LEDB_ENABLE); 286 if (ret < 0) 287 goto out_i2c_err; 288 return 0; 289 290 out_i2c_err: 291 dev_err(pchip->dev, "i2c failed to access (%pe)\n", ERR_PTR(ret)); 292 return ret; 293 } 294 295 static int lm3630a_bank_b_get_brightness(struct backlight_device *bl) 296 { 297 int brightness, rval; 298 struct lm3630a_chip *pchip = bl_get_data(bl); 299 enum lm3630a_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl; 300 301 if ((pwm_ctrl & LM3630A_PWM_BANK_B) != 0) { 302 rval = lm3630a_read(pchip, REG_PWM_OUTHIGH); 303 if (rval < 0) 304 goto out_i2c_err; 305 brightness = (rval & 0x01) << 8; 306 rval = lm3630a_read(pchip, REG_PWM_OUTLOW); 307 if (rval < 0) 308 goto out_i2c_err; 309 brightness |= rval; 310 return brightness; 311 } 312 313 /* disable sleep */ 314 rval = lm3630a_update(pchip, REG_CTRL, 0x80, 0x00); 315 if (rval < 0) 316 goto out_i2c_err; 317 usleep_range(1000, 2000); 318 rval = lm3630a_read(pchip, REG_BRT_B); 319 if (rval < 0) 320 goto out_i2c_err; 321 return rval; 322 323 out_i2c_err: 324 dev_err(pchip->dev, "i2c failed to access register\n"); 325 return 0; 326 } 327 328 static const struct backlight_ops lm3630a_bank_b_ops = { 329 .options = BL_CORE_SUSPENDRESUME, 330 .update_status = lm3630a_bank_b_update_status, 331 .get_brightness = lm3630a_bank_b_get_brightness, 332 }; 333 334 static int lm3630a_backlight_register(struct lm3630a_chip *pchip) 335 { 336 struct lm3630a_platform_data *pdata = pchip->pdata; 337 struct backlight_properties props; 338 const char *label; 339 340 memset(&props, 0, sizeof(struct backlight_properties)); 341 props.type = BACKLIGHT_RAW; 342 if (pdata->leda_ctrl != LM3630A_LEDA_DISABLE) { 343 props.brightness = pdata->leda_init_brt; 344 props.max_brightness = pdata->leda_max_brt; 345 label = pdata->leda_label ? pdata->leda_label : "lm3630a_leda"; 346 pchip->bleda = 347 devm_backlight_device_register(pchip->dev, label, 348 pchip->dev, pchip, 349 &lm3630a_bank_a_ops, &props); 350 if (IS_ERR(pchip->bleda)) 351 return PTR_ERR(pchip->bleda); 352 } 353 354 if ((pdata->ledb_ctrl != LM3630A_LEDB_DISABLE) && 355 (pdata->ledb_ctrl != LM3630A_LEDB_ON_A)) { 356 props.brightness = pdata->ledb_init_brt; 357 props.max_brightness = pdata->ledb_max_brt; 358 label = pdata->ledb_label ? pdata->ledb_label : "lm3630a_ledb"; 359 pchip->bledb = 360 devm_backlight_device_register(pchip->dev, label, 361 pchip->dev, pchip, 362 &lm3630a_bank_b_ops, &props); 363 if (IS_ERR(pchip->bledb)) 364 return PTR_ERR(pchip->bledb); 365 } 366 return 0; 367 } 368 369 static const struct regmap_config lm3630a_regmap = { 370 .reg_bits = 8, 371 .val_bits = 8, 372 .max_register = REG_MAX, 373 }; 374 375 static int lm3630a_parse_led_sources(struct fwnode_handle *node, 376 int default_led_sources) 377 { 378 u32 sources[LM3630A_NUM_SINKS]; 379 int ret, num_sources, i; 380 381 num_sources = fwnode_property_count_u32(node, "led-sources"); 382 if (num_sources < 0) 383 return default_led_sources; 384 else if (num_sources > ARRAY_SIZE(sources)) 385 return -EINVAL; 386 387 ret = fwnode_property_read_u32_array(node, "led-sources", sources, 388 num_sources); 389 if (ret) 390 return ret; 391 392 for (i = 0; i < num_sources; i++) { 393 if (sources[i] != LM3630A_SINK_0 && sources[i] != LM3630A_SINK_1) 394 return -EINVAL; 395 396 ret |= BIT(sources[i]); 397 } 398 399 return ret; 400 } 401 402 static int lm3630a_parse_bank(struct lm3630a_platform_data *pdata, 403 struct fwnode_handle *node, int *seen_led_sources) 404 { 405 int led_sources, ret; 406 const char *label; 407 u32 bank, val; 408 bool linear; 409 410 ret = fwnode_property_read_u32(node, "reg", &bank); 411 if (ret) 412 return ret; 413 414 if (bank != LM3630A_BANK_0 && bank != LM3630A_BANK_1) 415 return -EINVAL; 416 417 led_sources = lm3630a_parse_led_sources(node, BIT(bank)); 418 if (led_sources < 0) 419 return led_sources; 420 421 if (*seen_led_sources & led_sources) 422 return -EINVAL; 423 424 *seen_led_sources |= led_sources; 425 426 linear = fwnode_property_read_bool(node, 427 "ti,linear-mapping-mode"); 428 if (bank) { 429 if (led_sources & BIT(LM3630A_SINK_0) || 430 !(led_sources & BIT(LM3630A_SINK_1))) 431 return -EINVAL; 432 433 pdata->ledb_ctrl = linear ? 434 LM3630A_LEDB_ENABLE_LINEAR : 435 LM3630A_LEDB_ENABLE; 436 } else { 437 if (!(led_sources & BIT(LM3630A_SINK_0))) 438 return -EINVAL; 439 440 pdata->leda_ctrl = linear ? 441 LM3630A_LEDA_ENABLE_LINEAR : 442 LM3630A_LEDA_ENABLE; 443 444 if (led_sources & BIT(LM3630A_SINK_1)) 445 pdata->ledb_ctrl = LM3630A_LEDB_ON_A; 446 } 447 448 ret = fwnode_property_read_string(node, "label", &label); 449 if (!ret) { 450 if (bank) 451 pdata->ledb_label = label; 452 else 453 pdata->leda_label = label; 454 } 455 456 ret = fwnode_property_read_u32(node, "default-brightness", 457 &val); 458 if (!ret) { 459 if (bank) 460 pdata->ledb_init_brt = val; 461 else 462 pdata->leda_init_brt = val; 463 } 464 465 ret = fwnode_property_read_u32(node, "max-brightness", &val); 466 if (!ret) { 467 if (bank) 468 pdata->ledb_max_brt = val; 469 else 470 pdata->leda_max_brt = val; 471 } 472 473 return 0; 474 } 475 476 static int lm3630a_parse_node(struct lm3630a_chip *pchip, 477 struct lm3630a_platform_data *pdata) 478 { 479 int ret = -ENODEV, seen_led_sources = 0; 480 struct fwnode_handle *node; 481 482 device_for_each_child_node(pchip->dev, node) { 483 ret = lm3630a_parse_bank(pdata, node, &seen_led_sources); 484 if (ret) { 485 fwnode_handle_put(node); 486 return ret; 487 } 488 } 489 490 return ret; 491 } 492 493 static int lm3630a_probe(struct i2c_client *client) 494 { 495 struct lm3630a_platform_data *pdata = dev_get_platdata(&client->dev); 496 struct lm3630a_chip *pchip; 497 int rval; 498 499 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 500 dev_err(&client->dev, "fail : i2c functionality check\n"); 501 return -EOPNOTSUPP; 502 } 503 504 pchip = devm_kzalloc(&client->dev, sizeof(struct lm3630a_chip), 505 GFP_KERNEL); 506 if (!pchip) 507 return -ENOMEM; 508 pchip->dev = &client->dev; 509 510 pchip->regmap = devm_regmap_init_i2c(client, &lm3630a_regmap); 511 if (IS_ERR(pchip->regmap)) { 512 rval = PTR_ERR(pchip->regmap); 513 dev_err(&client->dev, "fail : allocate reg. map: %d\n", rval); 514 return rval; 515 } 516 517 i2c_set_clientdata(client, pchip); 518 if (pdata == NULL) { 519 pdata = devm_kzalloc(pchip->dev, 520 sizeof(struct lm3630a_platform_data), 521 GFP_KERNEL); 522 if (pdata == NULL) 523 return -ENOMEM; 524 525 /* default values */ 526 pdata->leda_max_brt = LM3630A_MAX_BRIGHTNESS; 527 pdata->ledb_max_brt = LM3630A_MAX_BRIGHTNESS; 528 pdata->leda_init_brt = LM3630A_MAX_BRIGHTNESS; 529 pdata->ledb_init_brt = LM3630A_MAX_BRIGHTNESS; 530 531 rval = lm3630a_parse_node(pchip, pdata); 532 if (rval) { 533 dev_err(&client->dev, "fail : parse node\n"); 534 return rval; 535 } 536 } 537 pchip->pdata = pdata; 538 539 pchip->enable_gpio = devm_gpiod_get_optional(&client->dev, "enable", 540 GPIOD_OUT_HIGH); 541 if (IS_ERR(pchip->enable_gpio)) { 542 rval = PTR_ERR(pchip->enable_gpio); 543 return rval; 544 } 545 546 /* chip initialize */ 547 rval = lm3630a_chip_init(pchip); 548 if (rval < 0) { 549 dev_err(&client->dev, "fail : init chip\n"); 550 return rval; 551 } 552 /* backlight register */ 553 rval = lm3630a_backlight_register(pchip); 554 if (rval < 0) { 555 dev_err(&client->dev, "fail : backlight register.\n"); 556 return rval; 557 } 558 /* pwm */ 559 if (pdata->pwm_ctrl != LM3630A_PWM_DISABLE) { 560 pchip->pwmd = devm_pwm_get(pchip->dev, "lm3630a-pwm"); 561 if (IS_ERR(pchip->pwmd)) { 562 dev_err(&client->dev, "fail : get pwm device\n"); 563 return PTR_ERR(pchip->pwmd); 564 } 565 566 pwm_init_state(pchip->pwmd, &pchip->pwmd_state); 567 } 568 569 /* interrupt enable : irq 0 is not allowed */ 570 pchip->irq = client->irq; 571 if (pchip->irq) { 572 rval = lm3630a_intr_config(pchip); 573 if (rval < 0) 574 return rval; 575 } 576 dev_info(&client->dev, "LM3630A backlight register OK.\n"); 577 return 0; 578 } 579 580 static void lm3630a_remove(struct i2c_client *client) 581 { 582 int rval; 583 struct lm3630a_chip *pchip = i2c_get_clientdata(client); 584 585 rval = lm3630a_write(pchip, REG_BRT_A, 0); 586 if (rval < 0) 587 dev_err(pchip->dev, "i2c failed to access register\n"); 588 589 rval = lm3630a_write(pchip, REG_BRT_B, 0); 590 if (rval < 0) 591 dev_err(pchip->dev, "i2c failed to access register\n"); 592 593 if (pchip->irq) { 594 free_irq(pchip->irq, pchip); 595 destroy_workqueue(pchip->irqthread); 596 } 597 } 598 599 static const struct i2c_device_id lm3630a_id[] = { 600 {LM3630A_NAME, 0}, 601 {} 602 }; 603 604 MODULE_DEVICE_TABLE(i2c, lm3630a_id); 605 606 static const struct of_device_id lm3630a_match_table[] = { 607 { .compatible = "ti,lm3630a", }, 608 { }, 609 }; 610 611 MODULE_DEVICE_TABLE(of, lm3630a_match_table); 612 613 static struct i2c_driver lm3630a_i2c_driver = { 614 .driver = { 615 .name = LM3630A_NAME, 616 .of_match_table = lm3630a_match_table, 617 }, 618 .probe = lm3630a_probe, 619 .remove = lm3630a_remove, 620 .id_table = lm3630a_id, 621 }; 622 623 module_i2c_driver(lm3630a_i2c_driver); 624 625 MODULE_DESCRIPTION("Texas Instruments Backlight driver for LM3630A"); 626 MODULE_AUTHOR("Daniel Jeong <gshark.jeong@gmail.com>"); 627 MODULE_AUTHOR("LDD MLP <ldd-mlp@list.ti.com>"); 628 MODULE_LICENSE("GPL v2"); 629