| /* |
| * TI LP855x Backlight Driver |
| * |
| * Copyright (C) 2011 Texas Instruments |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 as |
| * published by the Free Software Foundation. |
| * |
| */ |
| |
| #include <linux/module.h> |
| #include <linux/slab.h> |
| #include <linux/i2c.h> |
| #include <linux/io.h> |
| #include <linux/backlight.h> |
| #include <linux/delay.h> |
| #include <linux/err.h> |
| #include <linux/of.h> |
| #include <linux/platform_data/lp855x.h> |
| #include <linux/pwm.h> |
| #include <linux/regulator/consumer.h> |
| |
| /* LP8550/1/2/3/6 Registers */ |
| #define LP855X_BRIGHTNESS_CTRL 0x00 |
| #define LP855X_DEVICE_CTRL 0x01 |
| #define LP8556_FULLBRIGHT_LSB 0x10 |
| #define LP855X_EEPROM_START 0xA0 |
| #define LP855X_EEPROM_END 0xA7 |
| #define LP8556_EPROM_START 0xA0 |
| #define LP8556_CURRENT_LSB 0xA0 |
| #define LP8556_CURRENT_MSB 0xA1 |
| #define LP8556_EPROM_END 0xAF |
| |
| /* LP8556 Masks */ |
| #define LP8556_BRIGHTNESS_MASK 0x0FFF |
| #define LP8556_CURRENT_SCALE_MASK 0x0FFF |
| #define LP8556_MAX_CURRENT_MASK 0x70 |
| |
| /* LP8555/7 Registers */ |
| #define LP8557_BL_CMD 0x00 |
| #define LP8557_BL_MASK 0x01 |
| #define LP8557_BL_ON 0x01 |
| #define LP8557_BL_OFF 0x00 |
| #define LP8557_BRIGHTNESS_CTRL 0x04 |
| #define LP8557_CONFIG 0x10 |
| #define LP8555_EPROM_START 0x10 |
| #define LP8555_EPROM_END 0x7A |
| #define LP8557_EPROM_START 0x10 |
| #define LP8557_EPROM_END 0x1E |
| |
| #define DEFAULT_BL_NAME "lcd-backlight" |
| #define MAX_BRIGHTNESS 255 |
| #define MAX_BRIGHTNESS_12 4095 |
| |
| enum lp855x_brightness_ctrl_mode { |
| PWM_BASED = 1, |
| REGISTER_BASED, |
| }; |
| |
| struct lp855x; |
| |
| /* |
| * struct lp855x_device_config |
| * @pre_init_device: init device function call before updating the brightness |
| * @reg_brightness: register address for brigthenss control |
| * @reg_devicectrl: register address for device control |
| * @post_init_device: late init device function call |
| */ |
| struct lp855x_device_config { |
| int (*pre_init_device)(struct lp855x *); |
| u8 reg_brightness; |
| u8 reg_devicectrl; |
| int (*post_init_device)(struct lp855x *); |
| }; |
| |
| struct lp855x { |
| const char *chipname; |
| enum lp855x_chip_id chip_id; |
| enum lp855x_brightness_ctrl_mode mode; |
| struct lp855x_device_config *cfg; |
| struct i2c_client *client; |
| struct backlight_device *bl; |
| struct device *dev; |
| struct lp855x_platform_data *pdata; |
| struct pwm_device *pwm; |
| struct regulator *supply; /* regulator for VDD input */ |
| struct regulator *enable; /* regulator for EN/VDDIO input */ |
| }; |
| |
| static int lp855x_write_byte(struct lp855x *lp, u8 reg, u8 data) |
| { |
| return i2c_smbus_write_byte_data(lp->client, reg, data); |
| } |
| |
| static int lp855x_update_bit(struct lp855x *lp, u8 reg, u8 mask, u8 data) |
| { |
| int ret; |
| u8 tmp; |
| |
| ret = i2c_smbus_read_byte_data(lp->client, reg); |
| if (ret < 0) { |
| dev_err(lp->dev, "failed to read 0x%.2x\n", reg); |
| return ret; |
| } |
| |
| tmp = (u8)ret; |
| tmp &= ~mask; |
| tmp |= data & mask; |
| |
| return lp855x_write_byte(lp, reg, tmp); |
| } |
| |
| static bool lp855x_is_valid_rom_area(struct lp855x *lp, u8 addr) |
| { |
| u8 start, end; |
| |
| switch (lp->chip_id) { |
| case LP8550: |
| case LP8551: |
| case LP8552: |
| case LP8553: |
| start = LP855X_EEPROM_START; |
| end = LP855X_EEPROM_END; |
| break; |
| case LP8556: |
| start = LP8556_EPROM_START; |
| end = LP8556_EPROM_END; |
| break; |
| case LP8555: |
| start = LP8555_EPROM_START; |
| end = LP8555_EPROM_END; |
| break; |
| case LP8557: |
| start = LP8557_EPROM_START; |
| end = LP8557_EPROM_END; |
| break; |
| default: |
| return false; |
| } |
| |
| return addr >= start && addr <= end; |
| } |
| |
| static int lp8556_get_initial_current_settings(struct lp855x *lp) |
| { |
| int ret; |
| struct lp855x_platform_data *pd = lp->pdata; |
| |
| if (lp->chip_id != LP8556) |
| return 0; |
| |
| ret = i2c_smbus_read_word_data(lp->client, LP8556_CURRENT_LSB); |
| if (ret < 0) { |
| dev_err(lp->dev, "%s: Couldn't read current registers: %d", |
| __func__, ret); |
| return ret; |
| } |
| |
| mutex_lock(&pd->current_lock); |
| pd->current_scale = ret & LP8556_CURRENT_SCALE_MASK; |
| pd->max_current = (ret & (LP8556_MAX_CURRENT_MASK << 8)) >> 12; |
| mutex_unlock(&pd->current_lock); |
| |
| return 0; |
| } |
| |
| static int lp8557_bl_off(struct lp855x *lp) |
| { |
| /* BL_ON = 0 before updating EPROM settings */ |
| return lp855x_update_bit(lp, LP8557_BL_CMD, LP8557_BL_MASK, |
| LP8557_BL_OFF); |
| } |
| |
| static int lp8557_bl_on(struct lp855x *lp) |
| { |
| /* BL_ON = 1 after updating EPROM settings */ |
| return lp855x_update_bit(lp, LP8557_BL_CMD, LP8557_BL_MASK, |
| LP8557_BL_ON); |
| } |
| |
| // NOTE(afergs): Modified this to use the undocumented, higher resolution |
| // FULLBRIGHT setting instead of the regular 8-bit brightness |
| // register. FULLBRIGHT works for the LP8556. |
| // This setting MAY exist on other LP855X parts, but I don't know |
| // and can't test it. |
| #define AO_RTI_STICKY_REG2 (0xff800000 + (0x04e << 2)) |
| static int lp855x_set_brightness(struct lp855x *lp, u16 brightness) |
| { |
| int ret; |
| void *map = NULL; |
| |
| if (lp->cfg->reg_brightness == LP8556_FULLBRIGHT_LSB) { |
| // 12 bit brightness |
| ret = lp855x_write_byte(lp, lp->cfg->reg_brightness, |
| (u8)(brightness & 0x0ff)); |
| ret |= lp855x_update_bit(lp, lp->cfg->reg_brightness + 1, 0x0f, |
| (u8)((brightness & 0xf00) >> 8)); |
| |
| /* Write to 4 byte sticky register to persist brightness */ |
| map = (void *)ioremap(AO_RTI_STICKY_REG2, 4); |
| if (!map) { |
| dev_err(lp->dev, "%s: Couldn't get map", __func__); |
| return ret; |
| } |
| /* Write non-zero value outside of mask so the register |
| * isn't clear even when the value is zero. |
| */ |
| writel((LP8556_BRIGHTNESS_MASK + 1) | |
| (brightness & LP8556_BRIGHTNESS_MASK), map); |
| iounmap(map); |
| } else { |
| // 8 bit brightness |
| ret = lp855x_write_byte(lp, lp->cfg->reg_brightness, |
| brightness); |
| } |
| |
| return ret; |
| } |
| |
| static int lp855x_get_brightness(struct lp855x *lp) |
| { |
| const int retries = 3; |
| int ret, attempt; |
| |
| for (attempt = 0; attempt < retries; ++attempt) { |
| if (lp->cfg->reg_brightness == LP8556_FULLBRIGHT_LSB) { |
| // 12 bit brightness |
| ret = i2c_smbus_read_word_data( |
| lp->client, lp->cfg->reg_brightness); |
| if (ret >= 0) { |
| ret &= LP8556_BRIGHTNESS_MASK; |
| break; |
| } |
| } else { |
| // 8 bit brightness |
| ret = i2c_smbus_read_byte_data( |
| lp->client, lp->cfg->reg_brightness); |
| if (ret >= 0) |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| static int lp855x_set_current_scale(struct lp855x *lp, u16 current_scale) |
| { |
| int ret; |
| u16 val; |
| |
| if (lp->chip_id != LP8556) |
| return -ENOSYS; |
| |
| if (current_scale > 4095) |
| return -EINVAL; |
| |
| ret = i2c_smbus_read_word_data(lp->client, LP8556_CURRENT_LSB); |
| if (ret < 0) { |
| dev_err(lp->dev, "%s: Couldn't read current registers: %d", |
| __func__, ret); |
| return ret; |
| } |
| |
| val = (ret & ~LP8556_CURRENT_SCALE_MASK) | current_scale; |
| |
| ret = i2c_smbus_write_word_data(lp->client, LP8556_CURRENT_LSB, val); |
| if (ret < 0) { |
| dev_err(lp->dev, "%s: Couldn't write current registers: %d", |
| __func__, ret); |
| return ret; |
| } |
| |
| mutex_lock(&lp->pdata->current_lock); |
| lp->pdata->current_scale = current_scale; |
| mutex_unlock(&lp->pdata->current_lock); |
| |
| /* TODO(afergs): Generate event? (See struct backlight_device) */ |
| |
| return 0; |
| } |
| |
| static int lp855x_set_max_current(struct lp855x *lp, u8 max_current) |
| { |
| int ret; |
| |
| if (lp->chip_id != LP8556) |
| return -ENOSYS; |
| |
| if (max_current > 7) |
| return -EINVAL; |
| |
| ret = lp855x_update_bit(lp, LP8556_CURRENT_MSB, |
| LP8556_MAX_CURRENT_MASK, max_current << 4); |
| if (ret < 0) { |
| dev_err(lp->dev, "%s: Couldn't write current msb: %d", |
| __func__, ret); |
| return ret; |
| } |
| |
| mutex_lock(&lp->pdata->current_lock); |
| lp->pdata->max_current = max_current; |
| mutex_unlock(&lp->pdata->current_lock); |
| |
| return 0; |
| } |
| |
| /* TODO(afergs): Make a separate struct for the LP8556 */ |
| static struct lp855x_device_config lp855x_dev_cfg = { |
| // NOTE(afergs): Use 12-bit FULLBRIGHT. |
| .reg_brightness = LP8556_FULLBRIGHT_LSB, |
| .reg_devicectrl = LP855X_DEVICE_CTRL, |
| .post_init_device = lp8556_get_initial_current_settings, |
| }; |
| |
| static struct lp855x_device_config lp8557_dev_cfg = { |
| .reg_brightness = LP8557_BRIGHTNESS_CTRL, |
| .reg_devicectrl = LP8557_CONFIG, |
| .pre_init_device = lp8557_bl_off, |
| .post_init_device = lp8557_bl_on, |
| }; |
| |
| /* |
| * Device specific configuration flow |
| * |
| * a) pre_init_device(optional) |
| * b) update the brightness register |
| * c) update device control register |
| * d) update ROM area(optional) |
| * e) post_init_device(optional) |
| * |
| */ |
| static int lp855x_configure(struct lp855x *lp) |
| { |
| int val; |
| u8 addr; |
| int i, ret; |
| struct lp855x_platform_data *pd = lp->pdata; |
| |
| switch (lp->chip_id) { |
| case LP8550: |
| case LP8551: |
| case LP8552: |
| case LP8553: |
| case LP8556: |
| lp->cfg = &lp855x_dev_cfg; |
| break; |
| case LP8555: |
| case LP8557: |
| lp->cfg = &lp8557_dev_cfg; |
| break; |
| default: |
| return -EINVAL; |
| } |
| |
| if (lp->cfg->pre_init_device) { |
| ret = lp->cfg->pre_init_device(lp); |
| if (ret) { |
| dev_err(lp->dev, "pre init device err: %d\n", ret); |
| goto err; |
| } |
| } |
| |
| val = pd->initial_brightness; |
| if (val >= 0) { |
| ret = lp855x_set_brightness(lp, val); |
| if (ret) |
| goto err; |
| } else { |
| ret = lp855x_get_brightness(lp); |
| if (ret < 0) |
| goto err; |
| pd->initial_brightness = ret; |
| } |
| |
| val = pd->device_control; |
| ret = lp855x_write_byte(lp, lp->cfg->reg_devicectrl, val); |
| if (ret) |
| goto err; |
| |
| if (pd->size_program > 0) { |
| for (i = 0; i < pd->size_program; i++) { |
| addr = pd->rom_data[i].addr; |
| val = pd->rom_data[i].val; |
| if (!lp855x_is_valid_rom_area(lp, addr)) |
| continue; |
| |
| ret = lp855x_write_byte(lp, addr, val); |
| if (ret) |
| goto err; |
| } |
| } |
| |
| if (lp->cfg->post_init_device) { |
| ret = lp->cfg->post_init_device(lp); |
| /* TODO(afergs): I think this should be "if (ret < 0) ..." */ |
| if (ret) { |
| dev_err(lp->dev, "post init device err: %d\n", ret); |
| goto err; |
| } |
| } |
| |
| return 0; |
| |
| err: |
| return ret; |
| } |
| |
| static void lp855x_pwm_ctrl(struct lp855x *lp, int br, int max_br) |
| { |
| unsigned int period = lp->pdata->period_ns; |
| unsigned int duty = br * period / max_br; |
| struct pwm_device *pwm; |
| |
| /* request pwm device with the consumer name */ |
| if (!lp->pwm) { |
| pwm = devm_pwm_get(lp->dev, lp->chipname); |
| if (IS_ERR(pwm)) |
| return; |
| |
| lp->pwm = pwm; |
| |
| /* |
| * FIXME: pwm_apply_args() should be removed when switching to |
| * the atomic PWM API. |
| */ |
| pwm_apply_args(pwm); |
| } |
| |
| pwm_config(lp->pwm, duty, period); |
| if (duty) |
| pwm_enable(lp->pwm); |
| else |
| pwm_disable(lp->pwm); |
| } |
| |
| static int lp855x_bl_update_status(struct backlight_device *bl) |
| { |
| struct lp855x *lp = bl_get_data(bl); |
| int brightness = bl->props.brightness; |
| |
| if (bl->props.state & (BL_CORE_SUSPENDED | BL_CORE_FBBLANK)) |
| brightness = 0; |
| |
| if (lp->mode == PWM_BASED) |
| lp855x_pwm_ctrl(lp, brightness, bl->props.max_brightness); |
| else if (lp->mode == REGISTER_BASED) |
| lp855x_set_brightness(lp, brightness); |
| |
| return 0; |
| } |
| |
| static const struct backlight_ops lp855x_bl_ops = { |
| .options = BL_CORE_SUSPENDRESUME, |
| .update_status = lp855x_bl_update_status, |
| }; |
| |
| static int lp855x_backlight_register(struct lp855x *lp) |
| { |
| struct backlight_device *bl; |
| struct backlight_properties props; |
| struct lp855x_platform_data *pdata = lp->pdata; |
| const char *name = pdata->name ? : DEFAULT_BL_NAME; |
| |
| memset(&props, 0, sizeof(props)); |
| props.type = BACKLIGHT_PLATFORM; |
| if (lp->cfg->reg_brightness == LP8556_FULLBRIGHT_LSB) |
| props.max_brightness = MAX_BRIGHTNESS_12; |
| else |
| props.max_brightness = MAX_BRIGHTNESS; |
| |
| if (pdata->initial_brightness > props.max_brightness) |
| pdata->initial_brightness = props.max_brightness; |
| |
| props.brightness = pdata->initial_brightness; |
| |
| bl = devm_backlight_device_register(lp->dev, name, lp->dev, lp, |
| &lp855x_bl_ops, &props); |
| if (IS_ERR(bl)) |
| return PTR_ERR(bl); |
| |
| lp->bl = bl; |
| |
| return 0; |
| } |
| |
| static ssize_t lp855x_get_chip_id(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| struct lp855x *lp = dev_get_drvdata(dev); |
| |
| return scnprintf(buf, PAGE_SIZE, "%s\n", lp->chipname); |
| } |
| |
| static ssize_t lp855x_get_bl_ctl_mode(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| struct lp855x *lp = dev_get_drvdata(dev); |
| char *strmode = NULL; |
| |
| if (lp->mode == PWM_BASED) |
| strmode = "pwm based"; |
| else if (lp->mode == REGISTER_BASED) |
| strmode = "register based"; |
| |
| return scnprintf(buf, PAGE_SIZE, "%s\n", strmode); |
| } |
| |
| static DEVICE_ATTR(chip_id, S_IRUGO, lp855x_get_chip_id, NULL); |
| static DEVICE_ATTR(bl_ctl_mode, S_IRUGO, lp855x_get_bl_ctl_mode, NULL); |
| |
| static ssize_t current_scale_show(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| const struct lp855x *lp = dev_get_drvdata(dev); |
| |
| if (lp->chip_id != LP8556) |
| return -ENOSYS; |
| |
| return scnprintf(buf, PAGE_SIZE, "%d\n", lp->pdata->current_scale); |
| } |
| |
| static ssize_t current_scale_store(struct device *dev, |
| struct device_attribute *attr, |
| const char *buf, size_t count) |
| { |
| int ret; |
| struct lp855x *lp = dev_get_drvdata(dev); |
| unsigned int current_scale; |
| |
| ret = kstrtouint(buf, 0, ¤t_scale); |
| if (ret < 0) |
| return ret; |
| |
| if (current_scale > 4095) |
| return -EINVAL; |
| |
| ret = lp855x_set_current_scale(lp, current_scale); |
| |
| return (ret < 0) ? ret : count; |
| } |
| |
| static DEVICE_ATTR_RW(current_scale); |
| |
| static ssize_t max_current_show(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| struct lp855x *lp = dev_get_drvdata(dev); |
| |
| if (lp->chip_id != LP8556) |
| return -ENOSYS; |
| |
| return scnprintf(buf, PAGE_SIZE, "%d\n", lp->pdata->max_current); |
| } |
| |
| static ssize_t max_current_store(struct device *dev, |
| struct device_attribute *attr, |
| const char *buf, size_t count) |
| { |
| int ret; |
| struct lp855x *lp = dev_get_drvdata(dev); |
| unsigned int max_current; |
| |
| ret = kstrtouint(buf, 0, &max_current); |
| if (ret) |
| return ret; |
| |
| if (max_current > 7) |
| return -EINVAL; |
| |
| ret = lp855x_set_max_current(lp, max_current); |
| |
| return (ret < 0) ? ret : count; |
| } |
| |
| static DEVICE_ATTR_RW(max_current); |
| |
| static struct attribute *lp855x_attributes[] = { |
| &dev_attr_chip_id.attr, |
| &dev_attr_bl_ctl_mode.attr, |
| &dev_attr_current_scale.attr, |
| &dev_attr_max_current.attr, |
| NULL, |
| }; |
| |
| static const struct attribute_group lp855x_attr_group = { |
| .attrs = lp855x_attributes, |
| }; |
| |
| #ifdef CONFIG_OF |
| static int lp855x_parse_dt(struct lp855x *lp) |
| { |
| struct device *dev = lp->dev; |
| struct device_node *node = dev->of_node; |
| struct lp855x_platform_data *pdata; |
| int rom_length; |
| u16 initial_brightness; |
| int ret; |
| |
| if (!node) { |
| dev_err(dev, "no platform data\n"); |
| return -EINVAL; |
| } |
| |
| pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); |
| if (!pdata) |
| return -ENOMEM; |
| |
| of_property_read_string(node, "bl-name", &pdata->name); |
| of_property_read_u8(node, "dev-ctrl", &pdata->device_control); |
| ret = of_property_read_u16(node, "init-brt", &initial_brightness); |
| if (ret < 0) |
| pdata->initial_brightness = -1; |
| else |
| pdata->initial_brightness = initial_brightness; |
| of_property_read_u32(node, "pwm-period", &pdata->period_ns); |
| |
| /* Fill ROM platform data if defined */ |
| rom_length = of_get_child_count(node); |
| if (rom_length > 0) { |
| struct lp855x_rom_data *rom; |
| struct device_node *child; |
| int i = 0; |
| |
| rom = devm_kzalloc(dev, sizeof(*rom) * rom_length, GFP_KERNEL); |
| if (!rom) |
| return -ENOMEM; |
| |
| for_each_child_of_node(node, child) { |
| of_property_read_u8(child, "rom-addr", &rom[i].addr); |
| of_property_read_u8(child, "rom-val", &rom[i].val); |
| i++; |
| } |
| |
| pdata->size_program = rom_length; |
| pdata->rom_data = &rom[0]; |
| } |
| |
| lp->pdata = pdata; |
| |
| return 0; |
| } |
| #else |
| static int lp855x_parse_dt(struct lp855x *lp) |
| { |
| return -EINVAL; |
| } |
| #endif |
| |
| static int lp855x_probe(struct i2c_client *cl, const struct i2c_device_id *id) |
| { |
| struct lp855x *lp; |
| int ret; |
| |
| if (!i2c_check_functionality(cl->adapter, I2C_FUNC_SMBUS_I2C_BLOCK)) |
| return -EIO; |
| |
| lp = devm_kzalloc(&cl->dev, sizeof(struct lp855x), GFP_KERNEL); |
| if (!lp) |
| return -ENOMEM; |
| |
| lp->client = cl; |
| lp->dev = &cl->dev; |
| lp->chipname = id->name; |
| lp->chip_id = id->driver_data; |
| lp->pdata = dev_get_platdata(&cl->dev); |
| |
| if (!lp->pdata) { |
| ret = lp855x_parse_dt(lp); |
| if (ret < 0) |
| return ret; |
| } |
| |
| mutex_init(&lp->pdata->current_lock); |
| |
| if (lp->pdata->period_ns > 0) |
| lp->mode = PWM_BASED; |
| else |
| lp->mode = REGISTER_BASED; |
| |
| lp->supply = devm_regulator_get(lp->dev, "power"); |
| if (IS_ERR(lp->supply)) { |
| if (PTR_ERR(lp->supply) == -EPROBE_DEFER) |
| return -EPROBE_DEFER; |
| lp->supply = NULL; |
| } |
| |
| lp->enable = devm_regulator_get_optional(lp->dev, "enable"); |
| if (IS_ERR(lp->enable)) { |
| ret = PTR_ERR(lp->enable); |
| if (ret == -ENODEV) { |
| lp->enable = NULL; |
| } else { |
| if (ret != -EPROBE_DEFER) |
| dev_err(lp->dev, "error getting enable regulator: %d\n", |
| ret); |
| return ret; |
| } |
| } |
| |
| if (lp->supply) { |
| ret = regulator_enable(lp->supply); |
| if (ret < 0) { |
| dev_err(&cl->dev, "failed to enable supply: %d\n", ret); |
| return ret; |
| } |
| } |
| |
| if (lp->enable) { |
| ret = regulator_enable(lp->enable); |
| if (ret < 0) { |
| dev_err(lp->dev, "failed to enable vddio: %d\n", ret); |
| return ret; |
| } |
| |
| /* |
| * LP8555 datasheet says t_RESPONSE (time between VDDIO and |
| * I2C) is 1ms. |
| */ |
| usleep_range(1000, 2000); |
| } |
| |
| i2c_set_clientdata(cl, lp); |
| |
| ret = lp855x_configure(lp); |
| if (ret) { |
| dev_err(lp->dev, "device config err: %d", ret); |
| return ret; |
| } |
| |
| ret = lp855x_backlight_register(lp); |
| if (ret) { |
| dev_err(lp->dev, |
| "failed to register backlight. err: %d\n", ret); |
| return ret; |
| } |
| |
| ret = sysfs_create_group(&lp->dev->kobj, &lp855x_attr_group); |
| if (ret) { |
| dev_err(lp->dev, "failed to register sysfs. err: %d\n", ret); |
| return ret; |
| } |
| |
| return 0; |
| } |
| |
| static int lp855x_remove(struct i2c_client *cl) |
| { |
| struct lp855x *lp = i2c_get_clientdata(cl); |
| |
| lp->bl->props.brightness = 0; |
| backlight_update_status(lp->bl); |
| if (lp->supply) |
| regulator_disable(lp->supply); |
| sysfs_remove_group(&lp->dev->kobj, &lp855x_attr_group); |
| |
| return 0; |
| } |
| |
| static const struct of_device_id lp855x_dt_ids[] = { |
| { .compatible = "ti,lp8550", }, |
| { .compatible = "ti,lp8551", }, |
| { .compatible = "ti,lp8552", }, |
| { .compatible = "ti,lp8553", }, |
| { .compatible = "ti,lp8555", }, |
| { .compatible = "ti,lp8556", }, |
| { .compatible = "ti,lp8557", }, |
| { } |
| }; |
| MODULE_DEVICE_TABLE(of, lp855x_dt_ids); |
| |
| static const struct i2c_device_id lp855x_ids[] = { |
| {"lp8550", LP8550}, |
| {"lp8551", LP8551}, |
| {"lp8552", LP8552}, |
| {"lp8553", LP8553}, |
| {"lp8555", LP8555}, |
| {"lp8556", LP8556}, |
| {"lp8557", LP8557}, |
| { } |
| }; |
| MODULE_DEVICE_TABLE(i2c, lp855x_ids); |
| |
| static struct i2c_driver lp855x_driver = { |
| .driver = { |
| .name = "lp855x", |
| .of_match_table = of_match_ptr(lp855x_dt_ids), |
| }, |
| .probe = lp855x_probe, |
| .remove = lp855x_remove, |
| .id_table = lp855x_ids, |
| }; |
| |
| module_i2c_driver(lp855x_driver); |
| |
| MODULE_DESCRIPTION("Texas Instruments LP855x Backlight driver"); |
| MODULE_AUTHOR("Milo Kim <milo.kim@ti.com>"); |
| MODULE_LICENSE("GPL"); |