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