1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * TI LP855x Backlight Driver 4 * 5 * Copyright (C) 2011 Texas Instruments 6 */ 7 8 #include <linux/acpi.h> 9 #include <linux/module.h> 10 #include <linux/slab.h> 11 #include <linux/i2c.h> 12 #include <linux/backlight.h> 13 #include <linux/delay.h> 14 #include <linux/err.h> 15 #include <linux/of.h> 16 #include <linux/platform_data/lp855x.h> 17 #include <linux/pwm.h> 18 #include <linux/regulator/consumer.h> 19 20 /* LP8550/1/2/3/6 Registers */ 21 #define LP855X_BRIGHTNESS_CTRL 0x00 22 #define LP855X_DEVICE_CTRL 0x01 23 #define LP855X_EEPROM_START 0xA0 24 #define LP855X_EEPROM_END 0xA7 25 #define LP8556_EPROM_START 0xA0 26 #define LP8556_EPROM_END 0xAF 27 28 /* LP8555/7 Registers */ 29 #define LP8557_BL_CMD 0x00 30 #define LP8557_BL_MASK 0x01 31 #define LP8557_BL_ON 0x01 32 #define LP8557_BL_OFF 0x00 33 #define LP8557_BRIGHTNESS_CTRL 0x04 34 #define LP8557_CONFIG 0x10 35 #define LP8555_EPROM_START 0x10 36 #define LP8555_EPROM_END 0x7A 37 #define LP8557_EPROM_START 0x10 38 #define LP8557_EPROM_END 0x1E 39 40 #define DEFAULT_BL_NAME "lcd-backlight" 41 #define MAX_BRIGHTNESS 255 42 43 enum lp855x_brightness_ctrl_mode { 44 PWM_BASED = 1, 45 REGISTER_BASED, 46 }; 47 48 struct lp855x; 49 50 /* 51 * struct lp855x_device_config 52 * @pre_init_device: init device function call before updating the brightness 53 * @reg_brightness: register address for brigthenss control 54 * @reg_devicectrl: register address for device control 55 * @post_init_device: late init device function call 56 */ 57 struct lp855x_device_config { 58 int (*pre_init_device)(struct lp855x *); 59 u8 reg_brightness; 60 u8 reg_devicectrl; 61 int (*post_init_device)(struct lp855x *); 62 }; 63 64 struct lp855x { 65 const char *chipname; 66 enum lp855x_chip_id chip_id; 67 enum lp855x_brightness_ctrl_mode mode; 68 struct lp855x_device_config *cfg; 69 struct i2c_client *client; 70 struct backlight_device *bl; 71 struct device *dev; 72 struct lp855x_platform_data *pdata; 73 struct pwm_device *pwm; 74 struct regulator *supply; /* regulator for VDD input */ 75 struct regulator *enable; /* regulator for EN/VDDIO input */ 76 }; 77 78 static int lp855x_write_byte(struct lp855x *lp, u8 reg, u8 data) 79 { 80 return i2c_smbus_write_byte_data(lp->client, reg, data); 81 } 82 83 static int lp855x_update_bit(struct lp855x *lp, u8 reg, u8 mask, u8 data) 84 { 85 int ret; 86 u8 tmp; 87 88 ret = i2c_smbus_read_byte_data(lp->client, reg); 89 if (ret < 0) { 90 dev_err(lp->dev, "failed to read 0x%.2x\n", reg); 91 return ret; 92 } 93 94 tmp = (u8)ret; 95 tmp &= ~mask; 96 tmp |= data & mask; 97 98 return lp855x_write_byte(lp, reg, tmp); 99 } 100 101 static bool lp855x_is_valid_rom_area(struct lp855x *lp, u8 addr) 102 { 103 u8 start, end; 104 105 switch (lp->chip_id) { 106 case LP8550: 107 case LP8551: 108 case LP8552: 109 case LP8553: 110 start = LP855X_EEPROM_START; 111 end = LP855X_EEPROM_END; 112 break; 113 case LP8556: 114 start = LP8556_EPROM_START; 115 end = LP8556_EPROM_END; 116 break; 117 case LP8555: 118 start = LP8555_EPROM_START; 119 end = LP8555_EPROM_END; 120 break; 121 case LP8557: 122 start = LP8557_EPROM_START; 123 end = LP8557_EPROM_END; 124 break; 125 default: 126 return false; 127 } 128 129 return addr >= start && addr <= end; 130 } 131 132 static int lp8557_bl_off(struct lp855x *lp) 133 { 134 /* BL_ON = 0 before updating EPROM settings */ 135 return lp855x_update_bit(lp, LP8557_BL_CMD, LP8557_BL_MASK, 136 LP8557_BL_OFF); 137 } 138 139 static int lp8557_bl_on(struct lp855x *lp) 140 { 141 /* BL_ON = 1 after updating EPROM settings */ 142 return lp855x_update_bit(lp, LP8557_BL_CMD, LP8557_BL_MASK, 143 LP8557_BL_ON); 144 } 145 146 static struct lp855x_device_config lp855x_dev_cfg = { 147 .reg_brightness = LP855X_BRIGHTNESS_CTRL, 148 .reg_devicectrl = LP855X_DEVICE_CTRL, 149 }; 150 151 static struct lp855x_device_config lp8557_dev_cfg = { 152 .reg_brightness = LP8557_BRIGHTNESS_CTRL, 153 .reg_devicectrl = LP8557_CONFIG, 154 .pre_init_device = lp8557_bl_off, 155 .post_init_device = lp8557_bl_on, 156 }; 157 158 /* 159 * Device specific configuration flow 160 * 161 * a) pre_init_device(optional) 162 * b) update the brightness register 163 * c) update device control register 164 * d) update ROM area(optional) 165 * e) post_init_device(optional) 166 * 167 */ 168 static int lp855x_configure(struct lp855x *lp) 169 { 170 u8 val, addr; 171 int i, ret; 172 struct lp855x_platform_data *pd = lp->pdata; 173 174 if (lp->cfg->pre_init_device) { 175 ret = lp->cfg->pre_init_device(lp); 176 if (ret) { 177 dev_err(lp->dev, "pre init device err: %d\n", ret); 178 goto err; 179 } 180 } 181 182 val = pd->initial_brightness; 183 ret = lp855x_write_byte(lp, lp->cfg->reg_brightness, val); 184 if (ret) 185 goto err; 186 187 val = pd->device_control; 188 ret = lp855x_write_byte(lp, lp->cfg->reg_devicectrl, val); 189 if (ret) 190 goto err; 191 192 if (pd->size_program > 0) { 193 for (i = 0; i < pd->size_program; i++) { 194 addr = pd->rom_data[i].addr; 195 val = pd->rom_data[i].val; 196 if (!lp855x_is_valid_rom_area(lp, addr)) 197 continue; 198 199 ret = lp855x_write_byte(lp, addr, val); 200 if (ret) 201 goto err; 202 } 203 } 204 205 if (lp->cfg->post_init_device) { 206 ret = lp->cfg->post_init_device(lp); 207 if (ret) { 208 dev_err(lp->dev, "post init device err: %d\n", ret); 209 goto err; 210 } 211 } 212 213 return 0; 214 215 err: 216 return ret; 217 } 218 219 static void lp855x_pwm_ctrl(struct lp855x *lp, int br, int max_br) 220 { 221 struct pwm_device *pwm; 222 struct pwm_state state; 223 224 /* request pwm device with the consumer name */ 225 if (!lp->pwm) { 226 pwm = devm_pwm_get(lp->dev, lp->chipname); 227 if (IS_ERR(pwm)) 228 return; 229 230 lp->pwm = pwm; 231 232 pwm_init_state(lp->pwm, &state); 233 } else { 234 pwm_get_state(lp->pwm, &state); 235 } 236 237 state.period = lp->pdata->period_ns; 238 state.duty_cycle = div_u64(br * state.period, max_br); 239 state.enabled = state.duty_cycle; 240 241 pwm_apply_state(lp->pwm, &state); 242 } 243 244 static int lp855x_bl_update_status(struct backlight_device *bl) 245 { 246 struct lp855x *lp = bl_get_data(bl); 247 int brightness = bl->props.brightness; 248 249 if (bl->props.state & (BL_CORE_SUSPENDED | BL_CORE_FBBLANK)) 250 brightness = 0; 251 252 if (lp->mode == PWM_BASED) 253 lp855x_pwm_ctrl(lp, brightness, bl->props.max_brightness); 254 else if (lp->mode == REGISTER_BASED) 255 lp855x_write_byte(lp, lp->cfg->reg_brightness, (u8)brightness); 256 257 return 0; 258 } 259 260 static const struct backlight_ops lp855x_bl_ops = { 261 .options = BL_CORE_SUSPENDRESUME, 262 .update_status = lp855x_bl_update_status, 263 }; 264 265 static int lp855x_backlight_register(struct lp855x *lp) 266 { 267 struct backlight_device *bl; 268 struct backlight_properties props; 269 struct lp855x_platform_data *pdata = lp->pdata; 270 const char *name = pdata->name ? : DEFAULT_BL_NAME; 271 272 memset(&props, 0, sizeof(props)); 273 props.type = BACKLIGHT_PLATFORM; 274 props.max_brightness = MAX_BRIGHTNESS; 275 276 if (pdata->initial_brightness > props.max_brightness) 277 pdata->initial_brightness = props.max_brightness; 278 279 props.brightness = pdata->initial_brightness; 280 281 bl = devm_backlight_device_register(lp->dev, name, lp->dev, lp, 282 &lp855x_bl_ops, &props); 283 if (IS_ERR(bl)) 284 return PTR_ERR(bl); 285 286 lp->bl = bl; 287 288 return 0; 289 } 290 291 static ssize_t lp855x_get_chip_id(struct device *dev, 292 struct device_attribute *attr, char *buf) 293 { 294 struct lp855x *lp = dev_get_drvdata(dev); 295 296 return scnprintf(buf, PAGE_SIZE, "%s\n", lp->chipname); 297 } 298 299 static ssize_t lp855x_get_bl_ctl_mode(struct device *dev, 300 struct device_attribute *attr, char *buf) 301 { 302 struct lp855x *lp = dev_get_drvdata(dev); 303 char *strmode = NULL; 304 305 if (lp->mode == PWM_BASED) 306 strmode = "pwm based"; 307 else if (lp->mode == REGISTER_BASED) 308 strmode = "register based"; 309 310 return scnprintf(buf, PAGE_SIZE, "%s\n", strmode); 311 } 312 313 static DEVICE_ATTR(chip_id, S_IRUGO, lp855x_get_chip_id, NULL); 314 static DEVICE_ATTR(bl_ctl_mode, S_IRUGO, lp855x_get_bl_ctl_mode, NULL); 315 316 static struct attribute *lp855x_attributes[] = { 317 &dev_attr_chip_id.attr, 318 &dev_attr_bl_ctl_mode.attr, 319 NULL, 320 }; 321 322 static const struct attribute_group lp855x_attr_group = { 323 .attrs = lp855x_attributes, 324 }; 325 326 #ifdef CONFIG_OF 327 static int lp855x_parse_dt(struct lp855x *lp) 328 { 329 struct device *dev = lp->dev; 330 struct device_node *node = dev->of_node; 331 struct lp855x_platform_data *pdata = lp->pdata; 332 int rom_length; 333 334 if (!node) { 335 dev_err(dev, "no platform data\n"); 336 return -EINVAL; 337 } 338 339 of_property_read_string(node, "bl-name", &pdata->name); 340 of_property_read_u8(node, "dev-ctrl", &pdata->device_control); 341 of_property_read_u8(node, "init-brt", &pdata->initial_brightness); 342 of_property_read_u32(node, "pwm-period", &pdata->period_ns); 343 344 /* Fill ROM platform data if defined */ 345 rom_length = of_get_child_count(node); 346 if (rom_length > 0) { 347 struct lp855x_rom_data *rom; 348 struct device_node *child; 349 int i = 0; 350 351 rom = devm_kcalloc(dev, rom_length, sizeof(*rom), GFP_KERNEL); 352 if (!rom) 353 return -ENOMEM; 354 355 for_each_child_of_node(node, child) { 356 of_property_read_u8(child, "rom-addr", &rom[i].addr); 357 of_property_read_u8(child, "rom-val", &rom[i].val); 358 i++; 359 } 360 361 pdata->size_program = rom_length; 362 pdata->rom_data = &rom[0]; 363 } 364 365 return 0; 366 } 367 #else 368 static int lp855x_parse_dt(struct lp855x *lp) 369 { 370 return -EINVAL; 371 } 372 #endif 373 374 static int lp855x_parse_acpi(struct lp855x *lp) 375 { 376 int ret; 377 378 /* 379 * On ACPI the device has already been initialized by the firmware 380 * and is in register mode, so we can read back the settings from 381 * the registers. 382 */ 383 ret = i2c_smbus_read_byte_data(lp->client, lp->cfg->reg_brightness); 384 if (ret < 0) 385 return ret; 386 387 lp->pdata->initial_brightness = ret; 388 389 ret = i2c_smbus_read_byte_data(lp->client, lp->cfg->reg_devicectrl); 390 if (ret < 0) 391 return ret; 392 393 lp->pdata->device_control = ret; 394 return 0; 395 } 396 397 static int lp855x_probe(struct i2c_client *cl, const struct i2c_device_id *id) 398 { 399 const struct acpi_device_id *acpi_id = NULL; 400 struct device *dev = &cl->dev; 401 struct lp855x *lp; 402 int ret; 403 404 if (!i2c_check_functionality(cl->adapter, I2C_FUNC_SMBUS_I2C_BLOCK)) 405 return -EIO; 406 407 lp = devm_kzalloc(dev, sizeof(struct lp855x), GFP_KERNEL); 408 if (!lp) 409 return -ENOMEM; 410 411 lp->client = cl; 412 lp->dev = dev; 413 lp->pdata = dev_get_platdata(dev); 414 415 if (id) { 416 lp->chipname = id->name; 417 lp->chip_id = id->driver_data; 418 } else { 419 acpi_id = acpi_match_device(dev->driver->acpi_match_table, dev); 420 if (!acpi_id) 421 return -ENODEV; 422 423 lp->chipname = acpi_id->id; 424 lp->chip_id = acpi_id->driver_data; 425 } 426 427 switch (lp->chip_id) { 428 case LP8550: 429 case LP8551: 430 case LP8552: 431 case LP8553: 432 case LP8556: 433 lp->cfg = &lp855x_dev_cfg; 434 break; 435 case LP8555: 436 case LP8557: 437 lp->cfg = &lp8557_dev_cfg; 438 break; 439 default: 440 return -EINVAL; 441 } 442 443 if (!lp->pdata) { 444 lp->pdata = devm_kzalloc(dev, sizeof(*lp->pdata), GFP_KERNEL); 445 if (!lp->pdata) 446 return -ENOMEM; 447 448 if (id) { 449 ret = lp855x_parse_dt(lp); 450 if (ret < 0) 451 return ret; 452 } else { 453 ret = lp855x_parse_acpi(lp); 454 if (ret < 0) 455 return ret; 456 } 457 } 458 459 if (lp->pdata->period_ns > 0) 460 lp->mode = PWM_BASED; 461 else 462 lp->mode = REGISTER_BASED; 463 464 lp->supply = devm_regulator_get(dev, "power"); 465 if (IS_ERR(lp->supply)) { 466 if (PTR_ERR(lp->supply) == -EPROBE_DEFER) 467 return -EPROBE_DEFER; 468 lp->supply = NULL; 469 } 470 471 lp->enable = devm_regulator_get_optional(dev, "enable"); 472 if (IS_ERR(lp->enable)) { 473 ret = PTR_ERR(lp->enable); 474 if (ret == -ENODEV) { 475 lp->enable = NULL; 476 } else { 477 return dev_err_probe(dev, ret, "getting enable regulator\n"); 478 } 479 } 480 481 if (lp->supply) { 482 ret = regulator_enable(lp->supply); 483 if (ret < 0) { 484 dev_err(dev, "failed to enable supply: %d\n", ret); 485 return ret; 486 } 487 } 488 489 if (lp->enable) { 490 ret = regulator_enable(lp->enable); 491 if (ret < 0) { 492 dev_err(dev, "failed to enable vddio: %d\n", ret); 493 goto disable_supply; 494 } 495 496 /* 497 * LP8555 datasheet says t_RESPONSE (time between VDDIO and 498 * I2C) is 1ms. 499 */ 500 usleep_range(1000, 2000); 501 } 502 503 i2c_set_clientdata(cl, lp); 504 505 ret = lp855x_configure(lp); 506 if (ret) { 507 dev_err(dev, "device config err: %d", ret); 508 goto disable_vddio; 509 } 510 511 ret = lp855x_backlight_register(lp); 512 if (ret) { 513 dev_err(dev, "failed to register backlight. err: %d\n", ret); 514 goto disable_vddio; 515 } 516 517 ret = sysfs_create_group(&dev->kobj, &lp855x_attr_group); 518 if (ret) { 519 dev_err(dev, "failed to register sysfs. err: %d\n", ret); 520 goto disable_vddio; 521 } 522 523 backlight_update_status(lp->bl); 524 525 return 0; 526 527 disable_vddio: 528 if (lp->enable) 529 regulator_disable(lp->enable); 530 disable_supply: 531 if (lp->supply) 532 regulator_disable(lp->supply); 533 534 return ret; 535 } 536 537 static void lp855x_remove(struct i2c_client *cl) 538 { 539 struct lp855x *lp = i2c_get_clientdata(cl); 540 541 lp->bl->props.brightness = 0; 542 backlight_update_status(lp->bl); 543 if (lp->enable) 544 regulator_disable(lp->enable); 545 if (lp->supply) 546 regulator_disable(lp->supply); 547 sysfs_remove_group(&lp->dev->kobj, &lp855x_attr_group); 548 } 549 550 static const struct of_device_id lp855x_dt_ids[] = { 551 { .compatible = "ti,lp8550", }, 552 { .compatible = "ti,lp8551", }, 553 { .compatible = "ti,lp8552", }, 554 { .compatible = "ti,lp8553", }, 555 { .compatible = "ti,lp8555", }, 556 { .compatible = "ti,lp8556", }, 557 { .compatible = "ti,lp8557", }, 558 { } 559 }; 560 MODULE_DEVICE_TABLE(of, lp855x_dt_ids); 561 562 static const struct i2c_device_id lp855x_ids[] = { 563 {"lp8550", LP8550}, 564 {"lp8551", LP8551}, 565 {"lp8552", LP8552}, 566 {"lp8553", LP8553}, 567 {"lp8555", LP8555}, 568 {"lp8556", LP8556}, 569 {"lp8557", LP8557}, 570 { } 571 }; 572 MODULE_DEVICE_TABLE(i2c, lp855x_ids); 573 574 #ifdef CONFIG_ACPI 575 static const struct acpi_device_id lp855x_acpi_match[] = { 576 /* Xiaomi specific HID used for the LP8556 on the Mi Pad 2 */ 577 { "XMCC0001", LP8556 }, 578 { } 579 }; 580 MODULE_DEVICE_TABLE(acpi, lp855x_acpi_match); 581 #endif 582 583 static struct i2c_driver lp855x_driver = { 584 .driver = { 585 .name = "lp855x", 586 .of_match_table = of_match_ptr(lp855x_dt_ids), 587 .acpi_match_table = ACPI_PTR(lp855x_acpi_match), 588 }, 589 .probe = lp855x_probe, 590 .remove = lp855x_remove, 591 .id_table = lp855x_ids, 592 }; 593 594 module_i2c_driver(lp855x_driver); 595 596 MODULE_DESCRIPTION("Texas Instruments LP855x Backlight driver"); 597 MODULE_AUTHOR("Milo Kim <milo.kim@ti.com>"); 598 MODULE_LICENSE("GPL"); 599