| /* |
| * lp5523.c - LP5523 LED Driver |
| * |
| * Copyright (C) 2010 Nokia Corporation |
| * Copyright (C) 2012 Texas Instruments |
| * |
| * Contact: Samu Onkalo <samu.p.onkalo@nokia.com> |
| * Milo(Woogyom) Kim <milo.kim@ti.com> |
| * |
| * 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. |
| * |
| * This program is distributed in the hope that it will be useful, but |
| * WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA |
| * 02110-1301 USA |
| */ |
| |
| #include <linux/delay.h> |
| #include <linux/firmware.h> |
| #include <linux/i2c.h> |
| #include <linux/init.h> |
| #include <linux/leds.h> |
| #include <linux/module.h> |
| #include <linux/mutex.h> |
| #include <linux/platform_data/leds-lp55xx.h> |
| #include <linux/slab.h> |
| |
| #include "leds-lp55xx-common.h" |
| |
| #define LP5523_PROGRAM_LENGTH 32 |
| #define LP5523_MAX_LEDS 9 |
| |
| /* Registers */ |
| #define LP5523_REG_ENABLE 0x00 |
| #define LP5523_REG_OP_MODE 0x01 |
| #define LP5523_REG_ENABLE_LEDS_MSB 0x04 |
| #define LP5523_REG_ENABLE_LEDS_LSB 0x05 |
| #define LP5523_REG_LED_PWM_BASE 0x16 |
| #define LP5523_REG_LED_CURRENT_BASE 0x26 |
| #define LP5523_REG_CONFIG 0x36 |
| #define LP5523_REG_STATUS 0x3A |
| #define LP5523_REG_VARIABLE 0x3C |
| #define LP5523_REG_RESET 0x3D |
| #define LP5523_REG_LED_TEST_CTRL 0x41 |
| #define LP5523_REG_LED_TEST_ADC 0x42 |
| #define LP5523_REG_CH1_PROG_START 0x4C |
| #define LP5523_REG_CH2_PROG_START 0x4D |
| #define LP5523_REG_CH3_PROG_START 0x4E |
| #define LP5523_REG_PROG_PAGE_SEL 0x4F |
| #define LP5523_REG_PROG_MEM 0x50 |
| |
| /* Bit description in registers */ |
| #define LP5523_ENABLE 0x40 |
| #define LP5523_AUTO_INC 0x40 |
| #define LP5523_PWR_SAVE 0x20 |
| #define LP5523_PWM_PWR_SAVE 0x04 |
| #define LP5523_CP_AUTO 0x18 |
| #define LP5523_AUTO_CLK 0x02 |
| |
| #define LP5523_EN_LEDTEST 0x80 |
| #define LP5523_LEDTEST_DONE 0x80 |
| #define LP5523_RESET 0xFF |
| #define LP5523_ADC_SHORTCIRC_LIM 80 |
| #define LP5523_EXT_CLK_USED 0x08 |
| #define LP5523_ENG_STATUS_MASK 0x07 |
| |
| /* Memory Page Selection */ |
| #define LP5523_PAGE_ENG1 0 |
| #define LP5523_PAGE_ENG2 1 |
| #define LP5523_PAGE_ENG3 2 |
| #define LP5523_PAGE_MUX1 3 |
| #define LP5523_PAGE_MUX2 4 |
| #define LP5523_PAGE_MUX3 5 |
| |
| #define LP5523_PAGE_SEL_START 0 |
| #define LP5523_PAGE_SEL_END 5 |
| #define LP5523_NUM_ENGINES 3 |
| #define LP5523_NUM_PAGES 6 |
| #define LP5523_MAX_FW_LEN (LP5523_NUM_PAGES*LP5523_PROGRAM_LENGTH) |
| |
| /* Program Memory Operations */ |
| #define LP5523_MODE_ENG1_M 0x30 /* Operation Mode Register */ |
| #define LP5523_MODE_ENG2_M 0x0C |
| #define LP5523_MODE_ENG3_M 0x03 |
| #define LP5523_LOAD_ENG1 0x10 |
| #define LP5523_LOAD_ENG2 0x04 |
| #define LP5523_LOAD_ENG3 0x01 |
| |
| #define LP5523_ENG1_IS_LOADING(mode) \ |
| ((mode & LP5523_MODE_ENG1_M) == LP5523_LOAD_ENG1) |
| #define LP5523_ENG2_IS_LOADING(mode) \ |
| ((mode & LP5523_MODE_ENG2_M) == LP5523_LOAD_ENG2) |
| #define LP5523_ENG3_IS_LOADING(mode) \ |
| ((mode & LP5523_MODE_ENG3_M) == LP5523_LOAD_ENG3) |
| |
| #define LP5523_EXEC_ENG1_M 0x30 /* Enable Register */ |
| #define LP5523_EXEC_ENG2_M 0x0C |
| #define LP5523_EXEC_ENG3_M 0x03 |
| #define LP5523_EXEC_M 0x3F |
| #define LP5523_RUN_ENG1 0x20 |
| #define LP5523_RUN_ENG2 0x08 |
| #define LP5523_RUN_ENG3 0x02 |
| |
| enum lp5523_chip_id { |
| LP5523, |
| LP55231, |
| }; |
| |
| static inline void lp5523_wait_opmode_done(void) |
| { |
| usleep_range(1000, 2000); |
| } |
| |
| static void lp5523_set_led_current(struct lp55xx_led *led, u8 led_current) |
| { |
| led->led_current = led_current; |
| lp55xx_write(led->chip, LP5523_REG_LED_CURRENT_BASE + led->chan_nr, |
| led_current); |
| } |
| |
| static int lp5523_post_init_device(struct lp55xx_chip *chip) |
| { |
| int ret; |
| |
| ret = lp55xx_write(chip, LP5523_REG_ENABLE, LP5523_ENABLE); |
| if (ret) |
| return ret; |
| |
| /* Chip startup time is 500 us, 1 - 2 ms gives some margin */ |
| usleep_range(1000, 2000); |
| |
| ret = lp55xx_write(chip, LP5523_REG_CONFIG, |
| LP5523_AUTO_INC | LP5523_PWR_SAVE | |
| LP5523_CP_AUTO | LP5523_AUTO_CLK | |
| LP5523_PWM_PWR_SAVE); |
| if (ret) |
| return ret; |
| |
| /* turn on all leds */ |
| ret = lp55xx_write(chip, LP5523_REG_ENABLE_LEDS_MSB, 0x01); |
| if (ret) |
| return ret; |
| |
| ret = lp55xx_write(chip, LP5523_REG_ENABLE_LEDS_LSB, 0xff); |
| if (ret) |
| return ret; |
| |
| return 0; |
| } |
| |
| static void lp5523_load_engine(struct lp55xx_chip *chip) |
| { |
| enum lp55xx_engine_index idx = chip->engine_idx; |
| u8 mask[] = { |
| [LP55XX_ENGINE_1] = LP5523_MODE_ENG1_M, |
| [LP55XX_ENGINE_2] = LP5523_MODE_ENG2_M, |
| [LP55XX_ENGINE_3] = LP5523_MODE_ENG3_M, |
| }; |
| |
| u8 val[] = { |
| [LP55XX_ENGINE_1] = LP5523_LOAD_ENG1, |
| [LP55XX_ENGINE_2] = LP5523_LOAD_ENG2, |
| [LP55XX_ENGINE_3] = LP5523_LOAD_ENG3, |
| }; |
| |
| lp55xx_update_bits(chip, LP5523_REG_OP_MODE, mask[idx], val[idx]); |
| |
| lp5523_wait_opmode_done(); |
| } |
| |
| static void lp5523_stop_engine(struct lp55xx_chip *chip) |
| { |
| lp55xx_write(chip, LP5523_REG_OP_MODE, 0); |
| lp5523_wait_opmode_done(); |
| } |
| |
| static void lp5523_turn_off_channels(struct lp55xx_chip *chip) |
| { |
| int i; |
| |
| for (i = 0; i < LP5523_MAX_LEDS; i++) |
| lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + i, 0); |
| } |
| |
| static void lp5523_run_engine(struct lp55xx_chip *chip, bool start) |
| { |
| int ret; |
| u8 mode; |
| u8 exec; |
| |
| /* stop engine */ |
| if (!start) { |
| lp5523_stop_engine(chip); |
| lp5523_turn_off_channels(chip); |
| return; |
| } |
| |
| /* |
| * To run the engine, |
| * operation mode and enable register should updated at the same time |
| */ |
| |
| ret = lp55xx_read(chip, LP5523_REG_OP_MODE, &mode); |
| if (ret) |
| return; |
| |
| ret = lp55xx_read(chip, LP5523_REG_ENABLE, &exec); |
| if (ret) |
| return; |
| |
| /* change operation mode to RUN only when each engine is loading */ |
| if (LP5523_ENG1_IS_LOADING(mode)) { |
| mode = (mode & ~LP5523_MODE_ENG1_M) | LP5523_RUN_ENG1; |
| exec = (exec & ~LP5523_EXEC_ENG1_M) | LP5523_RUN_ENG1; |
| } |
| |
| if (LP5523_ENG2_IS_LOADING(mode)) { |
| mode = (mode & ~LP5523_MODE_ENG2_M) | LP5523_RUN_ENG2; |
| exec = (exec & ~LP5523_EXEC_ENG2_M) | LP5523_RUN_ENG2; |
| } |
| |
| if (LP5523_ENG3_IS_LOADING(mode)) { |
| mode = (mode & ~LP5523_MODE_ENG3_M) | LP5523_RUN_ENG3; |
| exec = (exec & ~LP5523_EXEC_ENG3_M) | LP5523_RUN_ENG3; |
| } |
| |
| lp55xx_write(chip, LP5523_REG_OP_MODE, mode); |
| lp5523_wait_opmode_done(); |
| |
| lp55xx_update_bits(chip, LP5523_REG_ENABLE, LP5523_EXEC_M, exec); |
| } |
| |
| static ssize_t lp5523_start_addr3(struct device *dev, |
| struct device_attribute *attr, const char *buf, size_t len) |
| { |
| struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev)); |
| struct lp55xx_chip *chip = led->chip; |
| int ret; |
| unsigned data = 0; |
| char c[3]; |
| int nrchars; |
| int offset = 0; |
| int i = 0; |
| u8 start_addr[LP5523_NUM_ENGINES]; |
| int start_offset[] = { |
| LP5523_REG_CH1_PROG_START, |
| LP5523_REG_CH2_PROG_START, |
| LP5523_REG_CH3_PROG_START,}; |
| /* Read start addresses */ |
| for (i = 0, offset = 0; |
| (offset < len - 1); |
| i++, offset += nrchars) { |
| if (i >= LP5523_NUM_ENGINES) { |
| dev_dbg(dev, "input bytes too long (max = 3 bytes)\n"); |
| return -EINVAL; |
| } |
| |
| ret = sscanf(buf + offset, "%2s%n ", c, &nrchars); |
| if (ret != 1) { |
| dev_dbg(dev, "failed sscanf (offset=%d)\n", offset); |
| return -EINVAL; |
| } |
| |
| ret = sscanf(c, "%02x", &data); |
| if (ret != 1) { |
| dev_dbg(dev, "failed sscanf (offset=%d)\n", offset); |
| return -EINVAL; |
| } |
| start_addr[i] = (u8) data; |
| } |
| |
| /* program start addresses to the controller */ |
| mutex_lock(&chip->lock); |
| for (i = 0; i < LP5523_NUM_ENGINES; i++) { |
| ret = lp55xx_write(chip, start_offset[i], start_addr[i]); |
| if (ret) { |
| dev_dbg(dev, "lp55xx_write() failed!\n"); |
| ret = -EIO; |
| goto leave; |
| } |
| } |
| ret = len; |
| |
| leave: |
| mutex_unlock(&chip->lock); |
| return ret; |
| } |
| |
| |
| static ssize_t lp5523_leds_run(struct device *dev, |
| struct device_attribute *attr, const char *buf, size_t len) |
| { |
| struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev)); |
| struct lp55xx_chip *chip = led->chip; |
| int ret; |
| u8 run = 0; |
| |
| /* read input */ |
| ret = kstrtou8(buf, 0, &run); |
| if (ret) { |
| dev_dbg(dev, "kstrou8() failed\n"); |
| return -EINVAL; |
| } |
| |
| if (run != 0 && run != 1) { |
| dev_dbg(dev, "leds_run, valid values: 0/1\n"); |
| return -EINVAL; |
| } |
| |
| mutex_lock(&chip->lock); |
| if (run == 0) |
| lp5523_run_engine(chip, false); |
| else |
| lp5523_run_engine(chip, true); |
| mutex_unlock(&chip->lock); |
| |
| return len; |
| } |
| |
| |
| static void lp5523_load_all_engines(struct lp55xx_chip *chip) |
| { |
| /* put all three engines in load mode */ |
| int i; |
| for (i = LP55XX_ENGINE_1; i <= LP55XX_ENGINE_3; i++) { |
| chip->engine_idx = i; |
| lp5523_load_engine(chip); |
| } |
| } |
| |
| static ssize_t lp5523_firmware_load(struct device *dev, |
| struct device_attribute *attr, const char *buf, size_t len) |
| { |
| struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev)); |
| struct lp55xx_chip *chip = led->chip; |
| int page_num = LP5523_PAGE_SEL_START; |
| u8 fw_bytes[LP5523_MAX_FW_LEN] = {0}; |
| int ret, offset, nrchars; |
| unsigned data; |
| int fw_len = 0, i = 0; |
| char c[3]; |
| |
| /* Read i/p firmware bytes */ |
| for (i = 0, offset = 0; |
| (offset < len - 1); |
| i++, offset += nrchars) { |
| |
| if (i >= LP5523_MAX_FW_LEN) { |
| dev_dbg(dev, "Firmware length %d bytes, too big (max = %d bytes)\n", |
| i, LP5523_MAX_FW_LEN); |
| return -EINVAL; |
| } |
| |
| ret = sscanf(buf + offset, "%2s%n ", c, &nrchars); |
| if (ret != 1) { |
| dev_dbg(dev, "failed sscanf (offset=%d)\n", |
| offset); |
| return -EINVAL; |
| } |
| |
| ret = sscanf(c, "%02x", &data); |
| if (ret != 1) { |
| dev_dbg(dev, "failed sscanf (offset=%d)\n", |
| offset); |
| return -EINVAL; |
| } |
| fw_bytes[i] = (u8) data; |
| fw_len++; |
| } |
| |
| /* Start writing f/w to LED controller mem */ |
| mutex_lock(&chip->lock); |
| |
| /* put all engines in load mode */ |
| lp5523_load_all_engines(chip); |
| |
| for (i = 0; i < fw_len; i++) { |
| if (i % LP5523_PROGRAM_LENGTH == 0) { |
| /* start of a new page */ |
| ret = lp55xx_write(chip, |
| LP5523_REG_PROG_PAGE_SEL, page_num); |
| if (ret) { |
| dev_dbg(dev, "lp55xx_write(PAGE_SEL) failed!\n"); |
| goto leave; |
| } |
| page_num++; |
| } |
| |
| ret = lp55xx_write(chip, |
| LP5523_REG_PROG_MEM + (i % LP5523_PROGRAM_LENGTH), |
| fw_bytes[i]); |
| if (ret) { |
| dev_dbg(dev, "lp55xx_write(PROG_MEM) failed!\n"); |
| ret = -EINVAL; |
| goto leave; |
| } |
| } |
| |
| ret = len; |
| |
| leave: |
| mutex_unlock(&chip->lock); |
| return ret; |
| } |
| |
| |
| static ssize_t show_variable(struct device *dev, |
| struct device_attribute *attr, |
| char *buf) |
| { |
| struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev)); |
| struct lp55xx_chip *chip = led->chip; |
| u8 variable; |
| int ret; |
| |
| ret = lp55xx_read(chip, LP5523_REG_VARIABLE, &variable); |
| if (ret < 0) |
| return ret; |
| |
| return sprintf(buf, "%d\n", variable); |
| } |
| |
| static ssize_t store_variable(struct device *dev, |
| struct device_attribute *attr, |
| const char *buf, size_t len) |
| { |
| struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev)); |
| struct lp55xx_chip *chip = led->chip; |
| u8 variable; |
| int ret; |
| |
| ret = kstrtou8(buf, 0, &variable); |
| if (ret) |
| return ret; |
| |
| dev_dbg(dev, "Writing down %d\n", variable); |
| |
| ret = lp55xx_write(chip, LP5523_REG_VARIABLE, variable); |
| if (ret) |
| return ret; |
| |
| return len; |
| } |
| static ssize_t lp5523_selftest(struct device *dev, |
| struct device_attribute *attr, |
| char *buf) |
| { |
| struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev)); |
| struct lp55xx_chip *chip = led->chip; |
| struct lp55xx_platform_data *pdata = chip->pdata; |
| int i, ret, pos = 0; |
| u8 status, adc, vdd; |
| |
| mutex_lock(&chip->lock); |
| |
| ret = lp55xx_read(chip, LP5523_REG_STATUS, &status); |
| if (ret < 0) |
| goto fail; |
| |
| /* Check that ext clock is really in use if requested */ |
| if (pdata->clock_mode == LP55XX_CLOCK_EXT) { |
| if ((status & LP5523_EXT_CLK_USED) == 0) |
| goto fail; |
| } |
| |
| /* Measure VDD (i.e. VBAT) first (channel 16 corresponds to VDD) */ |
| lp55xx_write(chip, LP5523_REG_LED_TEST_CTRL, LP5523_EN_LEDTEST | 16); |
| usleep_range(3000, 6000); /* ADC conversion time is typically 2.7 ms */ |
| ret = lp55xx_read(chip, LP5523_REG_STATUS, &status); |
| if (ret < 0) |
| goto fail; |
| |
| if (!(status & LP5523_LEDTEST_DONE)) |
| usleep_range(3000, 6000); /* Was not ready. Wait little bit */ |
| |
| ret = lp55xx_read(chip, LP5523_REG_LED_TEST_ADC, &vdd); |
| if (ret < 0) |
| goto fail; |
| |
| vdd--; /* There may be some fluctuation in measurement */ |
| |
| for (i = 0; i < LP5523_MAX_LEDS; i++) { |
| /* Skip non-existing channels */ |
| if (pdata->led_config[i].led_current == 0) |
| continue; |
| |
| /* Set default current */ |
| lp55xx_write(chip, LP5523_REG_LED_CURRENT_BASE + i, |
| pdata->led_config[i].led_current); |
| |
| lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + i, 0xff); |
| /* let current stabilize 2 - 4ms before measurements start */ |
| usleep_range(2000, 4000); |
| lp55xx_write(chip, LP5523_REG_LED_TEST_CTRL, |
| LP5523_EN_LEDTEST | i); |
| /* ADC conversion time is 2.7 ms typically */ |
| usleep_range(3000, 6000); |
| ret = lp55xx_read(chip, LP5523_REG_STATUS, &status); |
| if (ret < 0) |
| goto fail; |
| |
| if (!(status & LP5523_LEDTEST_DONE)) |
| usleep_range(3000, 6000);/* Was not ready. Wait. */ |
| |
| ret = lp55xx_read(chip, LP5523_REG_LED_TEST_ADC, &adc); |
| if (ret < 0) |
| goto fail; |
| |
| if (adc >= vdd || adc < LP5523_ADC_SHORTCIRC_LIM) |
| pos += sprintf(buf + pos, "LED %d FAIL\n", i); |
| |
| lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + i, 0x00); |
| |
| /* Restore current */ |
| lp55xx_write(chip, LP5523_REG_LED_CURRENT_BASE + i, |
| led->led_current); |
| led++; |
| } |
| if (pos == 0) |
| pos = sprintf(buf, "OK\n"); |
| goto release_lock; |
| fail: |
| pos = sprintf(buf, "FAIL\n"); |
| |
| release_lock: |
| mutex_unlock(&chip->lock); |
| |
| return pos; |
| } |
| |
| static void lp5523_led_brightness_work(struct work_struct *work) |
| { |
| struct lp55xx_led *led = container_of(work, struct lp55xx_led, |
| brightness_work); |
| struct lp55xx_chip *chip = led->chip; |
| |
| mutex_lock(&chip->lock); |
| lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + led->chan_nr, |
| led->brightness); |
| mutex_unlock(&chip->lock); |
| } |
| |
| static LP55XX_DEV_ATTR_WO(firmware_load, lp5523_firmware_load); |
| static LP55XX_DEV_ATTR_WO(start_addr3, lp5523_start_addr3); |
| static LP55XX_DEV_ATTR_WO(leds_run, lp5523_leds_run); |
| static LP55XX_DEV_ATTR_RO(selftest, lp5523_selftest); |
| static LP55XX_DEV_ATTR_RW(variable, show_variable, store_variable); |
| |
| static struct attribute *lp5523_attributes[] = { |
| &dev_attr_firmware_load.attr, |
| &dev_attr_start_addr3.attr, |
| &dev_attr_leds_run.attr, |
| &dev_attr_selftest.attr, |
| &dev_attr_variable.attr, |
| NULL, |
| }; |
| |
| static const struct attribute_group lp5523_group = { |
| .attrs = lp5523_attributes, |
| }; |
| |
| /* Chip specific configurations */ |
| static struct lp55xx_device_config lp5523_cfg = { |
| .reset = { |
| .addr = LP5523_REG_RESET, |
| .val = LP5523_RESET, |
| }, |
| .enable = { |
| .addr = LP5523_REG_ENABLE, |
| .val = LP5523_ENABLE, |
| }, |
| .max_channel = LP5523_MAX_LEDS, |
| .post_init_device = lp5523_post_init_device, |
| .brightness_work_fn = lp5523_led_brightness_work, |
| .set_led_current = lp5523_set_led_current, |
| .dev_attr_group = &lp5523_group, |
| }; |
| |
| static int lp5523_probe(struct i2c_client *client, |
| const struct i2c_device_id *id) |
| { |
| int ret; |
| struct lp55xx_chip *chip; |
| struct lp55xx_led *led; |
| struct lp55xx_platform_data *pdata; |
| struct device_node *np = client->dev.of_node; |
| |
| if (!dev_get_platdata(&client->dev)) { |
| if (np) { |
| ret = lp55xx_of_populate_pdata(&client->dev, np); |
| if (ret < 0) |
| return ret; |
| } else { |
| dev_err(&client->dev, "no platform data\n"); |
| return -EINVAL; |
| } |
| } |
| pdata = dev_get_platdata(&client->dev); |
| |
| chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL); |
| if (!chip) |
| return -ENOMEM; |
| |
| led = devm_kzalloc(&client->dev, |
| sizeof(*led) * pdata->num_channels, GFP_KERNEL); |
| if (!led) |
| return -ENOMEM; |
| |
| chip->cl = client; |
| chip->pdata = pdata; |
| chip->cfg = &lp5523_cfg; |
| |
| mutex_init(&chip->lock); |
| |
| i2c_set_clientdata(client, led); |
| |
| ret = lp55xx_init_device(chip); |
| if (ret) |
| goto err_init; |
| |
| dev_info(&client->dev, "%s Programmable led chip found\n", id->name); |
| |
| ret = lp55xx_register_leds(led, chip); |
| if (ret) |
| goto err_register_leds; |
| |
| ret = lp55xx_register_sysfs(chip); |
| if (ret) { |
| dev_err(&client->dev, "registering sysfs failed\n"); |
| goto err_register_sysfs; |
| } |
| |
| return 0; |
| |
| err_register_sysfs: |
| lp55xx_unregister_leds(led, chip); |
| err_register_leds: |
| lp55xx_deinit_device(chip); |
| err_init: |
| return ret; |
| } |
| |
| static int lp5523_remove(struct i2c_client *client) |
| { |
| struct lp55xx_led *led = i2c_get_clientdata(client); |
| struct lp55xx_chip *chip = led->chip; |
| |
| lp5523_stop_engine(chip); |
| lp55xx_unregister_sysfs(chip); |
| lp55xx_unregister_leds(led, chip); |
| lp55xx_deinit_device(chip); |
| |
| return 0; |
| } |
| |
| static const struct i2c_device_id lp5523_id[] = { |
| { "lp5523", LP5523 }, |
| { "lp55231", LP55231 }, |
| { } |
| }; |
| |
| MODULE_DEVICE_TABLE(i2c, lp5523_id); |
| |
| #ifdef CONFIG_OF |
| static const struct of_device_id of_lp5523_leds_match[] = { |
| { .compatible = "national,lp5523", }, |
| {}, |
| }; |
| |
| MODULE_DEVICE_TABLE(of, of_lp5523_leds_match); |
| #endif |
| |
| static struct i2c_driver lp5523_driver = { |
| .driver = { |
| .name = "lp5523x", |
| .of_match_table = of_match_ptr(of_lp5523_leds_match), |
| }, |
| .probe = lp5523_probe, |
| .remove = lp5523_remove, |
| .id_table = lp5523_id, |
| }; |
| |
| module_i2c_driver(lp5523_driver); |
| |
| MODULE_AUTHOR("Mathias Nyman <mathias.nyman@nokia.com>"); |
| MODULE_AUTHOR("Milo Kim <milo.kim@ti.com>"); |
| MODULE_DESCRIPTION("LP5523 LED engine"); |
| MODULE_LICENSE("GPL"); |