Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 // TI LP50XX LED chip family driver
0003 // Copyright (C) 2018-20 Texas Instruments Incorporated - https://www.ti.com/
0004 
0005 #include <linux/gpio/consumer.h>
0006 #include <linux/i2c.h>
0007 #include <linux/init.h>
0008 #include <linux/leds.h>
0009 #include <linux/mod_devicetable.h>
0010 #include <linux/module.h>
0011 #include <linux/mutex.h>
0012 #include <linux/regmap.h>
0013 #include <linux/regulator/consumer.h>
0014 #include <linux/slab.h>
0015 #include <uapi/linux/uleds.h>
0016 
0017 #include <linux/led-class-multicolor.h>
0018 
0019 #include "leds.h"
0020 
0021 #define LP50XX_DEV_CFG0     0x00
0022 #define LP50XX_DEV_CFG1     0x01
0023 #define LP50XX_LED_CFG0     0x02
0024 
0025 /* LP5009 and LP5012 registers */
0026 #define LP5012_BNK_BRT      0x03
0027 #define LP5012_BNKA_CLR     0x04
0028 #define LP5012_BNKB_CLR     0x05
0029 #define LP5012_BNKC_CLR     0x06
0030 #define LP5012_LED0_BRT     0x07
0031 #define LP5012_OUT0_CLR     0x0b
0032 #define LP5012_RESET        0x17
0033 
0034 /* LP5018 and LP5024 registers */
0035 #define LP5024_BNK_BRT      0x03
0036 #define LP5024_BNKA_CLR     0x04
0037 #define LP5024_BNKB_CLR     0x05
0038 #define LP5024_BNKC_CLR     0x06
0039 #define LP5024_LED0_BRT     0x07
0040 #define LP5024_OUT0_CLR     0x0f
0041 #define LP5024_RESET        0x27
0042 
0043 /* LP5030 and LP5036 registers */
0044 #define LP5036_LED_CFG1     0x03
0045 #define LP5036_BNK_BRT      0x04
0046 #define LP5036_BNKA_CLR     0x05
0047 #define LP5036_BNKB_CLR     0x06
0048 #define LP5036_BNKC_CLR     0x07
0049 #define LP5036_LED0_BRT     0x08
0050 #define LP5036_OUT0_CLR     0x14
0051 #define LP5036_RESET        0x38
0052 
0053 #define LP50XX_SW_RESET     0xff
0054 #define LP50XX_CHIP_EN      BIT(6)
0055 
0056 /* There are 3 LED outputs per bank */
0057 #define LP50XX_LEDS_PER_MODULE  3
0058 
0059 #define LP5009_MAX_LED_MODULES  2
0060 #define LP5012_MAX_LED_MODULES  4
0061 #define LP5018_MAX_LED_MODULES  6
0062 #define LP5024_MAX_LED_MODULES  8
0063 #define LP5030_MAX_LED_MODULES  10
0064 #define LP5036_MAX_LED_MODULES  12
0065 
0066 static const struct reg_default lp5012_reg_defs[] = {
0067     {LP50XX_DEV_CFG0, 0x0},
0068     {LP50XX_DEV_CFG1, 0x3c},
0069     {LP50XX_LED_CFG0, 0x0},
0070     {LP5012_BNK_BRT, 0xff},
0071     {LP5012_BNKA_CLR, 0x0f},
0072     {LP5012_BNKB_CLR, 0x0f},
0073     {LP5012_BNKC_CLR, 0x0f},
0074     {LP5012_LED0_BRT, 0x0f},
0075     /* LEDX_BRT registers are all 0xff for defaults */
0076     {0x08, 0xff}, {0x09, 0xff}, {0x0a, 0xff},
0077     {LP5012_OUT0_CLR, 0x0f},
0078     /* OUTX_CLR registers are all 0x0 for defaults */
0079     {0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00}, {0x10, 0x00},
0080     {0x11, 0x00}, {0x12, 0x00}, {0x13, 0x00}, {0x14, 0x00}, {0x15, 0x00},
0081     {0x16, 0x00},
0082     {LP5012_RESET, 0x00}
0083 };
0084 
0085 static const struct reg_default lp5024_reg_defs[] = {
0086     {LP50XX_DEV_CFG0, 0x0},
0087     {LP50XX_DEV_CFG1, 0x3c},
0088     {LP50XX_LED_CFG0, 0x0},
0089     {LP5024_BNK_BRT, 0xff},
0090     {LP5024_BNKA_CLR, 0x0f},
0091     {LP5024_BNKB_CLR, 0x0f},
0092     {LP5024_BNKC_CLR, 0x0f},
0093     {LP5024_LED0_BRT, 0x0f},
0094     /* LEDX_BRT registers are all 0xff for defaults */
0095     {0x08, 0xff}, {0x09, 0xff}, {0x0a, 0xff}, {0x0b, 0xff}, {0x0c, 0xff},
0096     {0x0d, 0xff}, {0x0e, 0xff},
0097     {LP5024_OUT0_CLR, 0x0f},
0098     /* OUTX_CLR registers are all 0x0 for defaults */
0099     {0x10, 0x00}, {0x11, 0x00}, {0x12, 0x00}, {0x13, 0x00}, {0x14, 0x00},
0100     {0x15, 0x00}, {0x16, 0x00}, {0x17, 0x00}, {0x18, 0x00}, {0x19, 0x00},
0101     {0x1a, 0x00}, {0x1b, 0x00}, {0x1c, 0x00}, {0x1d, 0x00}, {0x1e, 0x00},
0102     {0x1f, 0x00}, {0x20, 0x00}, {0x21, 0x00}, {0x22, 0x00}, {0x23, 0x00},
0103     {0x24, 0x00}, {0x25, 0x00}, {0x26, 0x00},
0104     {LP5024_RESET, 0x00}
0105 };
0106 
0107 static const struct reg_default lp5036_reg_defs[] = {
0108     {LP50XX_DEV_CFG0, 0x0},
0109     {LP50XX_DEV_CFG1, 0x3c},
0110     {LP50XX_LED_CFG0, 0x0},
0111     {LP5036_LED_CFG1, 0x0},
0112     {LP5036_BNK_BRT, 0xff},
0113     {LP5036_BNKA_CLR, 0x0f},
0114     {LP5036_BNKB_CLR, 0x0f},
0115     {LP5036_BNKC_CLR, 0x0f},
0116     {LP5036_LED0_BRT, 0x0f},
0117     /* LEDX_BRT registers are all 0xff for defaults */
0118     {0x08, 0xff}, {0x09, 0xff}, {0x0a, 0xff}, {0x0b, 0xff}, {0x0c, 0xff},
0119     {0x0d, 0xff}, {0x0e, 0xff}, {0x0f, 0xff}, {0x10, 0xff}, {0x11, 0xff},
0120     {0x12, 0xff}, {0x13, 0xff},
0121     {LP5036_OUT0_CLR, 0x0f},
0122     /* OUTX_CLR registers are all 0x0 for defaults */
0123     {0x15, 0x00}, {0x16, 0x00}, {0x17, 0x00}, {0x18, 0x00}, {0x19, 0x00},
0124     {0x1a, 0x00}, {0x1b, 0x00}, {0x1c, 0x00}, {0x1d, 0x00}, {0x1e, 0x00},
0125     {0x1f, 0x00}, {0x20, 0x00}, {0x21, 0x00}, {0x22, 0x00}, {0x23, 0x00},
0126     {0x24, 0x00}, {0x25, 0x00}, {0x26, 0x00}, {0x27, 0x00}, {0x28, 0x00},
0127     {0x29, 0x00}, {0x2a, 0x00}, {0x2b, 0x00}, {0x2c, 0x00}, {0x2d, 0x00},
0128     {0x2e, 0x00}, {0x2f, 0x00}, {0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00},
0129     {0x33, 0x00}, {0x34, 0x00}, {0x35, 0x00}, {0x36, 0x00}, {0x37, 0x00},
0130     {LP5036_RESET, 0x00}
0131 };
0132 
0133 static const struct regmap_config lp5012_regmap_config = {
0134     .reg_bits = 8,
0135     .val_bits = 8,
0136 
0137     .max_register = LP5012_RESET,
0138     .reg_defaults = lp5012_reg_defs,
0139     .num_reg_defaults = ARRAY_SIZE(lp5012_reg_defs),
0140     .cache_type = REGCACHE_FLAT,
0141 };
0142 
0143 static const struct regmap_config lp5024_regmap_config = {
0144     .reg_bits = 8,
0145     .val_bits = 8,
0146 
0147     .max_register = LP5024_RESET,
0148     .reg_defaults = lp5024_reg_defs,
0149     .num_reg_defaults = ARRAY_SIZE(lp5024_reg_defs),
0150     .cache_type = REGCACHE_FLAT,
0151 };
0152 
0153 static const struct regmap_config lp5036_regmap_config = {
0154     .reg_bits = 8,
0155     .val_bits = 8,
0156 
0157     .max_register = LP5036_RESET,
0158     .reg_defaults = lp5036_reg_defs,
0159     .num_reg_defaults = ARRAY_SIZE(lp5036_reg_defs),
0160     .cache_type = REGCACHE_FLAT,
0161 };
0162 
0163 enum lp50xx_model {
0164     LP5009,
0165     LP5012,
0166     LP5018,
0167     LP5024,
0168     LP5030,
0169     LP5036,
0170 };
0171 
0172 /**
0173  * struct lp50xx_chip_info -
0174  * @lp50xx_regmap_config: regmap register configuration
0175  * @model_id: LED device model
0176  * @max_modules: total number of supported LED modules
0177  * @num_leds: number of LED outputs available on the device
0178  * @led_brightness0_reg: first brightness register of the device
0179  * @mix_out0_reg: first color mix register of the device
0180  * @bank_brt_reg: bank brightness register
0181  * @bank_mix_reg: color mix register
0182  * @reset_reg: device reset register
0183  */
0184 struct lp50xx_chip_info {
0185     const struct regmap_config *lp50xx_regmap_config;
0186     int model_id;
0187     u8 max_modules;
0188     u8 num_leds;
0189     u8 led_brightness0_reg;
0190     u8 mix_out0_reg;
0191     u8 bank_brt_reg;
0192     u8 bank_mix_reg;
0193     u8 reset_reg;
0194 };
0195 
0196 static const struct lp50xx_chip_info lp50xx_chip_info_tbl[] = {
0197     [LP5009] = {
0198         .model_id = LP5009,
0199         .max_modules = LP5009_MAX_LED_MODULES,
0200         .num_leds = LP5009_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
0201         .led_brightness0_reg = LP5012_LED0_BRT,
0202         .mix_out0_reg = LP5012_OUT0_CLR,
0203         .bank_brt_reg = LP5012_BNK_BRT,
0204         .bank_mix_reg = LP5012_BNKA_CLR,
0205         .reset_reg = LP5012_RESET,
0206         .lp50xx_regmap_config = &lp5012_regmap_config,
0207     },
0208     [LP5012] = {
0209         .model_id = LP5012,
0210         .max_modules = LP5012_MAX_LED_MODULES,
0211         .num_leds = LP5012_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
0212         .led_brightness0_reg = LP5012_LED0_BRT,
0213         .mix_out0_reg = LP5012_OUT0_CLR,
0214         .bank_brt_reg = LP5012_BNK_BRT,
0215         .bank_mix_reg = LP5012_BNKA_CLR,
0216         .reset_reg = LP5012_RESET,
0217         .lp50xx_regmap_config = &lp5012_regmap_config,
0218     },
0219     [LP5018] = {
0220         .model_id = LP5018,
0221         .max_modules = LP5018_MAX_LED_MODULES,
0222         .num_leds = LP5018_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
0223         .led_brightness0_reg = LP5024_LED0_BRT,
0224         .mix_out0_reg = LP5024_OUT0_CLR,
0225         .bank_brt_reg = LP5024_BNK_BRT,
0226         .bank_mix_reg = LP5024_BNKA_CLR,
0227         .reset_reg = LP5024_RESET,
0228         .lp50xx_regmap_config = &lp5024_regmap_config,
0229     },
0230     [LP5024] = {
0231         .model_id = LP5024,
0232         .max_modules = LP5024_MAX_LED_MODULES,
0233         .num_leds = LP5024_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
0234         .led_brightness0_reg = LP5024_LED0_BRT,
0235         .mix_out0_reg = LP5024_OUT0_CLR,
0236         .bank_brt_reg = LP5024_BNK_BRT,
0237         .bank_mix_reg = LP5024_BNKA_CLR,
0238         .reset_reg = LP5024_RESET,
0239         .lp50xx_regmap_config = &lp5024_regmap_config,
0240     },
0241     [LP5030] = {
0242         .model_id = LP5030,
0243         .max_modules = LP5030_MAX_LED_MODULES,
0244         .num_leds = LP5030_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
0245         .led_brightness0_reg = LP5036_LED0_BRT,
0246         .mix_out0_reg = LP5036_OUT0_CLR,
0247         .bank_brt_reg = LP5036_BNK_BRT,
0248         .bank_mix_reg = LP5036_BNKA_CLR,
0249         .reset_reg = LP5036_RESET,
0250         .lp50xx_regmap_config = &lp5036_regmap_config,
0251     },
0252     [LP5036] = {
0253         .model_id = LP5036,
0254         .max_modules = LP5036_MAX_LED_MODULES,
0255         .num_leds = LP5036_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
0256         .led_brightness0_reg = LP5036_LED0_BRT,
0257         .mix_out0_reg = LP5036_OUT0_CLR,
0258         .bank_brt_reg = LP5036_BNK_BRT,
0259         .bank_mix_reg = LP5036_BNKA_CLR,
0260         .reset_reg = LP5036_RESET,
0261         .lp50xx_regmap_config = &lp5036_regmap_config,
0262     },
0263 };
0264 
0265 struct lp50xx_led {
0266     struct led_classdev_mc mc_cdev;
0267     struct lp50xx *priv;
0268     unsigned long bank_modules;
0269     u8 ctrl_bank_enabled;
0270     int led_number;
0271 };
0272 
0273 /**
0274  * struct lp50xx -
0275  * @enable_gpio: hardware enable gpio
0276  * @regulator: LED supply regulator pointer
0277  * @client: pointer to the I2C client
0278  * @regmap: device register map
0279  * @dev: pointer to the devices device struct
0280  * @lock: lock for reading/writing the device
0281  * @chip_info: chip specific information (ie num_leds)
0282  * @num_of_banked_leds: holds the number of banked LEDs
0283  * @leds: array of LED strings
0284  */
0285 struct lp50xx {
0286     struct gpio_desc *enable_gpio;
0287     struct regulator *regulator;
0288     struct i2c_client *client;
0289     struct regmap *regmap;
0290     struct device *dev;
0291     struct mutex lock;
0292     const struct lp50xx_chip_info *chip_info;
0293     int num_of_banked_leds;
0294 
0295     /* This needs to be at the end of the struct */
0296     struct lp50xx_led leds[];
0297 };
0298 
0299 static struct lp50xx_led *mcled_cdev_to_led(struct led_classdev_mc *mc_cdev)
0300 {
0301     return container_of(mc_cdev, struct lp50xx_led, mc_cdev);
0302 }
0303 
0304 static int lp50xx_brightness_set(struct led_classdev *cdev,
0305                  enum led_brightness brightness)
0306 {
0307     struct led_classdev_mc *mc_dev = lcdev_to_mccdev(cdev);
0308     struct lp50xx_led *led = mcled_cdev_to_led(mc_dev);
0309     const struct lp50xx_chip_info *led_chip = led->priv->chip_info;
0310     u8 led_offset, reg_val;
0311     int ret = 0;
0312     int i;
0313 
0314     mutex_lock(&led->priv->lock);
0315     if (led->ctrl_bank_enabled)
0316         reg_val = led_chip->bank_brt_reg;
0317     else
0318         reg_val = led_chip->led_brightness0_reg +
0319               led->led_number;
0320 
0321     ret = regmap_write(led->priv->regmap, reg_val, brightness);
0322     if (ret) {
0323         dev_err(led->priv->dev,
0324             "Cannot write brightness value %d\n", ret);
0325         goto out;
0326     }
0327 
0328     for (i = 0; i < led->mc_cdev.num_colors; i++) {
0329         if (led->ctrl_bank_enabled) {
0330             reg_val = led_chip->bank_mix_reg + i;
0331         } else {
0332             led_offset = (led->led_number * 3) + i;
0333             reg_val = led_chip->mix_out0_reg + led_offset;
0334         }
0335 
0336         ret = regmap_write(led->priv->regmap, reg_val,
0337                    mc_dev->subled_info[i].intensity);
0338         if (ret) {
0339             dev_err(led->priv->dev,
0340                 "Cannot write intensity value %d\n", ret);
0341             goto out;
0342         }
0343     }
0344 out:
0345     mutex_unlock(&led->priv->lock);
0346     return ret;
0347 }
0348 
0349 static int lp50xx_set_banks(struct lp50xx *priv, u32 led_banks[])
0350 {
0351     u8 led_config_lo, led_config_hi;
0352     u32 bank_enable_mask = 0;
0353     int ret;
0354     int i;
0355 
0356     for (i = 0; i < priv->chip_info->max_modules; i++) {
0357         if (led_banks[i])
0358             bank_enable_mask |= (1 << led_banks[i]);
0359     }
0360 
0361     led_config_lo = bank_enable_mask;
0362     led_config_hi = bank_enable_mask >> 8;
0363 
0364     ret = regmap_write(priv->regmap, LP50XX_LED_CFG0, led_config_lo);
0365     if (ret)
0366         return ret;
0367 
0368     if (priv->chip_info->model_id >= LP5030)
0369         ret = regmap_write(priv->regmap, LP5036_LED_CFG1, led_config_hi);
0370 
0371     return ret;
0372 }
0373 
0374 static int lp50xx_reset(struct lp50xx *priv)
0375 {
0376     return regmap_write(priv->regmap, priv->chip_info->reset_reg, LP50XX_SW_RESET);
0377 }
0378 
0379 static int lp50xx_enable_disable(struct lp50xx *priv, int enable_disable)
0380 {
0381     int ret;
0382 
0383     ret = gpiod_direction_output(priv->enable_gpio, enable_disable);
0384     if (ret)
0385         return ret;
0386 
0387     if (enable_disable)
0388         return regmap_write(priv->regmap, LP50XX_DEV_CFG0, LP50XX_CHIP_EN);
0389     else
0390         return regmap_write(priv->regmap, LP50XX_DEV_CFG0, 0);
0391 
0392 }
0393 
0394 static int lp50xx_probe_leds(struct fwnode_handle *child, struct lp50xx *priv,
0395                  struct lp50xx_led *led, int num_leds)
0396 {
0397     u32 led_banks[LP5036_MAX_LED_MODULES] = {0};
0398     int led_number;
0399     int ret;
0400 
0401     if (num_leds > 1) {
0402         if (num_leds > priv->chip_info->max_modules) {
0403             dev_err(priv->dev, "reg property is invalid\n");
0404             return -EINVAL;
0405         }
0406 
0407         priv->num_of_banked_leds = num_leds;
0408 
0409         ret = fwnode_property_read_u32_array(child, "reg", led_banks, num_leds);
0410         if (ret) {
0411             dev_err(priv->dev, "reg property is missing\n");
0412             return ret;
0413         }
0414 
0415         ret = lp50xx_set_banks(priv, led_banks);
0416         if (ret) {
0417             dev_err(priv->dev, "Cannot setup banked LEDs\n");
0418             return ret;
0419         }
0420 
0421         led->ctrl_bank_enabled = 1;
0422     } else {
0423         ret = fwnode_property_read_u32(child, "reg", &led_number);
0424         if (ret) {
0425             dev_err(priv->dev, "led reg property missing\n");
0426             return ret;
0427         }
0428 
0429         if (led_number > priv->chip_info->num_leds) {
0430             dev_err(priv->dev, "led-sources property is invalid\n");
0431             return -EINVAL;
0432         }
0433 
0434         led->led_number = led_number;
0435     }
0436 
0437     return 0;
0438 }
0439 
0440 static int lp50xx_probe_dt(struct lp50xx *priv)
0441 {
0442     struct fwnode_handle *child = NULL;
0443     struct fwnode_handle *led_node = NULL;
0444     struct led_init_data init_data = {};
0445     struct led_classdev *led_cdev;
0446     struct mc_subled *mc_led_info;
0447     struct lp50xx_led *led;
0448     int ret = -EINVAL;
0449     int num_colors;
0450     u32 color_id;
0451     int i = 0;
0452 
0453     priv->enable_gpio = devm_gpiod_get_optional(priv->dev, "enable", GPIOD_OUT_LOW);
0454     if (IS_ERR(priv->enable_gpio))
0455         return dev_err_probe(priv->dev, PTR_ERR(priv->enable_gpio),
0456                      "Failed to get enable GPIO\n");
0457 
0458     priv->regulator = devm_regulator_get(priv->dev, "vled");
0459     if (IS_ERR(priv->regulator))
0460         priv->regulator = NULL;
0461 
0462     device_for_each_child_node(priv->dev, child) {
0463         led = &priv->leds[i];
0464         ret = fwnode_property_count_u32(child, "reg");
0465         if (ret < 0) {
0466             dev_err(priv->dev, "reg property is invalid\n");
0467             goto child_out;
0468         }
0469 
0470         ret = lp50xx_probe_leds(child, priv, led, ret);
0471         if (ret)
0472             goto child_out;
0473 
0474         init_data.fwnode = child;
0475         num_colors = 0;
0476 
0477         /*
0478          * There are only 3 LEDs per module otherwise they should be
0479          * banked which also is presented as 3 LEDs.
0480          */
0481         mc_led_info = devm_kcalloc(priv->dev, LP50XX_LEDS_PER_MODULE,
0482                        sizeof(*mc_led_info), GFP_KERNEL);
0483         if (!mc_led_info) {
0484             ret = -ENOMEM;
0485             goto child_out;
0486         }
0487 
0488         fwnode_for_each_child_node(child, led_node) {
0489             ret = fwnode_property_read_u32(led_node, "color",
0490                                &color_id);
0491             if (ret) {
0492                 fwnode_handle_put(led_node);
0493                 dev_err(priv->dev, "Cannot read color\n");
0494                 goto child_out;
0495             }
0496 
0497             mc_led_info[num_colors].color_index = color_id;
0498             num_colors++;
0499         }
0500 
0501         led->priv = priv;
0502         led->mc_cdev.num_colors = num_colors;
0503         led->mc_cdev.subled_info = mc_led_info;
0504         led_cdev = &led->mc_cdev.led_cdev;
0505         led_cdev->brightness_set_blocking = lp50xx_brightness_set;
0506 
0507         ret = devm_led_classdev_multicolor_register_ext(priv->dev,
0508                                &led->mc_cdev,
0509                                &init_data);
0510         if (ret) {
0511             dev_err(priv->dev, "led register err: %d\n", ret);
0512             goto child_out;
0513         }
0514         i++;
0515     }
0516 
0517     return 0;
0518 
0519 child_out:
0520     fwnode_handle_put(child);
0521     return ret;
0522 }
0523 
0524 static int lp50xx_probe(struct i2c_client *client)
0525 {
0526     struct lp50xx *led;
0527     int count;
0528     int ret;
0529 
0530     count = device_get_child_node_count(&client->dev);
0531     if (!count) {
0532         dev_err(&client->dev, "LEDs are not defined in device tree!");
0533         return -ENODEV;
0534     }
0535 
0536     led = devm_kzalloc(&client->dev, struct_size(led, leds, count),
0537                GFP_KERNEL);
0538     if (!led)
0539         return -ENOMEM;
0540 
0541     mutex_init(&led->lock);
0542     led->client = client;
0543     led->dev = &client->dev;
0544     led->chip_info = device_get_match_data(&client->dev);
0545     i2c_set_clientdata(client, led);
0546     led->regmap = devm_regmap_init_i2c(client,
0547                     led->chip_info->lp50xx_regmap_config);
0548     if (IS_ERR(led->regmap)) {
0549         ret = PTR_ERR(led->regmap);
0550         dev_err(&client->dev, "Failed to allocate register map: %d\n",
0551             ret);
0552         return ret;
0553     }
0554 
0555     ret = lp50xx_reset(led);
0556     if (ret)
0557         return ret;
0558 
0559     ret = lp50xx_enable_disable(led, 1);
0560     if (ret)
0561         return ret;
0562 
0563     return lp50xx_probe_dt(led);
0564 }
0565 
0566 static int lp50xx_remove(struct i2c_client *client)
0567 {
0568     struct lp50xx *led = i2c_get_clientdata(client);
0569     int ret;
0570 
0571     ret = lp50xx_enable_disable(led, 0);
0572     if (ret)
0573         dev_err(led->dev, "Failed to disable chip\n");
0574 
0575     if (led->regulator) {
0576         ret = regulator_disable(led->regulator);
0577         if (ret)
0578             dev_err(led->dev, "Failed to disable regulator\n");
0579     }
0580 
0581     mutex_destroy(&led->lock);
0582 
0583     return 0;
0584 }
0585 
0586 static const struct i2c_device_id lp50xx_id[] = {
0587     { "lp5009", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5009] },
0588     { "lp5012", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5012] },
0589     { "lp5018", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5018] },
0590     { "lp5024", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5024] },
0591     { "lp5030", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5030] },
0592     { "lp5036", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5036] },
0593     { }
0594 };
0595 MODULE_DEVICE_TABLE(i2c, lp50xx_id);
0596 
0597 static const struct of_device_id of_lp50xx_leds_match[] = {
0598     { .compatible = "ti,lp5009", .data = &lp50xx_chip_info_tbl[LP5009] },
0599     { .compatible = "ti,lp5012", .data = &lp50xx_chip_info_tbl[LP5012] },
0600     { .compatible = "ti,lp5018", .data = &lp50xx_chip_info_tbl[LP5018] },
0601     { .compatible = "ti,lp5024", .data = &lp50xx_chip_info_tbl[LP5024] },
0602     { .compatible = "ti,lp5030", .data = &lp50xx_chip_info_tbl[LP5030] },
0603     { .compatible = "ti,lp5036", .data = &lp50xx_chip_info_tbl[LP5036] },
0604     {}
0605 };
0606 MODULE_DEVICE_TABLE(of, of_lp50xx_leds_match);
0607 
0608 static struct i2c_driver lp50xx_driver = {
0609     .driver = {
0610         .name   = "lp50xx",
0611         .of_match_table = of_lp50xx_leds_match,
0612     },
0613     .probe_new  = lp50xx_probe,
0614     .remove     = lp50xx_remove,
0615     .id_table   = lp50xx_id,
0616 };
0617 module_i2c_driver(lp50xx_driver);
0618 
0619 MODULE_DESCRIPTION("Texas Instruments LP50XX LED driver");
0620 MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");
0621 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!