drivers/leds/leds-lp50xx.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // TI LP50XX LED chip family driver
   3 // Copyright (C) 2018-20 Texas Instruments Incorporated - https://www.ti.com/
   4
   5 #include <linux/gpio/consumer.h>
   6 #include <linux/i2c.h>
   7 #include <linux/init.h>
   8 #include <linux/leds.h>
   9 #include <linux/mod_devicetable.h>
  10 #include <linux/module.h>
  11 #include <linux/mutex.h>
  12 #include <linux/regmap.h>
  13 #include <linux/regulator/consumer.h>
  14 #include <linux/slab.h>
  15 #include <uapi/linux/uleds.h>
  16
  17 #include <linux/led-class-multicolor.h>
  18
  19 #define LP50XX_DEV_CFG0         0x00
  20 #define LP50XX_DEV_CFG1         0x01
  21 #define LP50XX_LED_CFG0         0x02
  22
  23 /* LP5009 and LP5012 registers */
  24 #define LP5012_BNK_BRT          0x03
  25 #define LP5012_BNKA_CLR         0x04
  26 #define LP5012_BNKB_CLR         0x05
  27 #define LP5012_BNKC_CLR         0x06
  28 #define LP5012_LED0_BRT         0x07
  29 #define LP5012_OUT0_CLR         0x0b
  30 #define LP5012_RESET            0x17
  31
  32 /* LP5018 and LP5024 registers */
  33 #define LP5024_BNK_BRT          0x03
  34 #define LP5024_BNKA_CLR         0x04
  35 #define LP5024_BNKB_CLR         0x05
  36 #define LP5024_BNKC_CLR         0x06
  37 #define LP5024_LED0_BRT         0x07
  38 #define LP5024_OUT0_CLR         0x0f
  39 #define LP5024_RESET            0x27
  40
  41 /* LP5030 and LP5036 registers */
  42 #define LP5036_LED_CFG1         0x03
  43 #define LP5036_BNK_BRT          0x04
  44 #define LP5036_BNKA_CLR         0x05
  45 #define LP5036_BNKB_CLR         0x06
  46 #define LP5036_BNKC_CLR         0x07
  47 #define LP5036_LED0_BRT         0x08
  48 #define LP5036_OUT0_CLR         0x14
  49 #define LP5036_RESET            0x38
  50
  51 #define LP50XX_SW_RESET         0xff
  52 #define LP50XX_CHIP_EN          BIT(6)
  53
  54 /* There are 3 LED outputs per bank */
  55 #define LP50XX_LEDS_PER_MODULE  3
  56
  57 #define LP5009_MAX_LED_MODULES  2
  58 #define LP5012_MAX_LED_MODULES  4
  59 #define LP5018_MAX_LED_MODULES  6
  60 #define LP5024_MAX_LED_MODULES  8
  61 #define LP5030_MAX_LED_MODULES  10
  62 #define LP5036_MAX_LED_MODULES  12
  63
  64 static const struct reg_default lp5012_reg_defs[] = {
  65         {LP50XX_DEV_CFG0, 0x0},
  66         {LP50XX_DEV_CFG1, 0x3c},
  67         {LP50XX_LED_CFG0, 0x0},
  68         {LP5012_BNK_BRT, 0xff},
  69         {LP5012_BNKA_CLR, 0x0f},
  70         {LP5012_BNKB_CLR, 0x0f},
  71         {LP5012_BNKC_CLR, 0x0f},
  72         {LP5012_LED0_BRT, 0x0f},
  73         /* LEDX_BRT registers are all 0xff for defaults */
  74         {0x08, 0xff}, {0x09, 0xff}, {0x0a, 0xff},
  75         {LP5012_OUT0_CLR, 0x0f},
  76         /* OUTX_CLR registers are all 0x0 for defaults */
  77         {0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00}, {0x10, 0x00},
  78         {0x11, 0x00}, {0x12, 0x00}, {0x13, 0x00}, {0x14, 0x00}, {0x15, 0x00},
  79         {0x16, 0x00},
  80         {LP5012_RESET, 0x00}
  81 };
  82
  83 static const struct reg_default lp5024_reg_defs[] = {
  84         {LP50XX_DEV_CFG0, 0x0},
  85         {LP50XX_DEV_CFG1, 0x3c},
  86         {LP50XX_LED_CFG0, 0x0},
  87         {LP5024_BNK_BRT, 0xff},
  88         {LP5024_BNKA_CLR, 0x0f},
  89         {LP5024_BNKB_CLR, 0x0f},
  90         {LP5024_BNKC_CLR, 0x0f},
  91         {LP5024_LED0_BRT, 0x0f},
  92         /* LEDX_BRT registers are all 0xff for defaults */
  93         {0x08, 0xff}, {0x09, 0xff}, {0x0a, 0xff}, {0x0b, 0xff}, {0x0c, 0xff},
  94         {0x0d, 0xff}, {0x0e, 0xff},
  95         {LP5024_OUT0_CLR, 0x0f},
  96         /* OUTX_CLR registers are all 0x0 for defaults */
  97         {0x10, 0x00}, {0x11, 0x00}, {0x12, 0x00}, {0x13, 0x00}, {0x14, 0x00},
  98         {0x15, 0x00}, {0x16, 0x00}, {0x17, 0x00}, {0x18, 0x00}, {0x19, 0x00},
  99         {0x1a, 0x00}, {0x1b, 0x00}, {0x1c, 0x00}, {0x1d, 0x00}, {0x1e, 0x00},
 100         {0x1f, 0x00}, {0x20, 0x00}, {0x21, 0x00}, {0x22, 0x00}, {0x23, 0x00},
 101         {0x24, 0x00}, {0x25, 0x00}, {0x26, 0x00},
 102         {LP5024_RESET, 0x00}
 103 };
 104
 105 static const struct reg_default lp5036_reg_defs[] = {
 106         {LP50XX_DEV_CFG0, 0x0},
 107         {LP50XX_DEV_CFG1, 0x3c},
 108         {LP50XX_LED_CFG0, 0x0},
 109         {LP5036_LED_CFG1, 0x0},
 110         {LP5036_BNK_BRT, 0xff},
 111         {LP5036_BNKA_CLR, 0x0f},
 112         {LP5036_BNKB_CLR, 0x0f},
 113         {LP5036_BNKC_CLR, 0x0f},
 114         {LP5036_LED0_BRT, 0x0f},
 115         /* LEDX_BRT registers are all 0xff for defaults */
 116         {0x08, 0xff}, {0x09, 0xff}, {0x0a, 0xff}, {0x0b, 0xff}, {0x0c, 0xff},
 117         {0x0d, 0xff}, {0x0e, 0xff}, {0x0f, 0xff}, {0x10, 0xff}, {0x11, 0xff},
 118         {0x12, 0xff}, {0x13, 0xff},
 119         {LP5036_OUT0_CLR, 0x0f},
 120         /* OUTX_CLR registers are all 0x0 for defaults */
 121         {0x15, 0x00}, {0x16, 0x00}, {0x17, 0x00}, {0x18, 0x00}, {0x19, 0x00},
 122         {0x1a, 0x00}, {0x1b, 0x00}, {0x1c, 0x00}, {0x1d, 0x00}, {0x1e, 0x00},
 123         {0x1f, 0x00}, {0x20, 0x00}, {0x21, 0x00}, {0x22, 0x00}, {0x23, 0x00},
 124         {0x24, 0x00}, {0x25, 0x00}, {0x26, 0x00}, {0x27, 0x00}, {0x28, 0x00},
 125         {0x29, 0x00}, {0x2a, 0x00}, {0x2b, 0x00}, {0x2c, 0x00}, {0x2d, 0x00},
 126         {0x2e, 0x00}, {0x2f, 0x00}, {0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00},
 127         {0x33, 0x00}, {0x34, 0x00}, {0x35, 0x00}, {0x36, 0x00}, {0x37, 0x00},
 128         {LP5036_RESET, 0x00}
 129 };
 130
 131 static const struct regmap_config lp5012_regmap_config = {
 132         .reg_bits = 8,
 133         .val_bits = 8,
 134
 135         .max_register = LP5012_RESET,
 136         .reg_defaults = lp5012_reg_defs,
 137         .num_reg_defaults = ARRAY_SIZE(lp5012_reg_defs),
 138         .cache_type = REGCACHE_FLAT,
 139 };
 140
 141 static const struct regmap_config lp5024_regmap_config = {
 142         .reg_bits = 8,
 143         .val_bits = 8,
 144
 145         .max_register = LP5024_RESET,
 146         .reg_defaults = lp5024_reg_defs,
 147         .num_reg_defaults = ARRAY_SIZE(lp5024_reg_defs),
 148         .cache_type = REGCACHE_FLAT,
 149 };
 150
 151 static const struct regmap_config lp5036_regmap_config = {
 152         .reg_bits = 8,
 153         .val_bits = 8,
 154
 155         .max_register = LP5036_RESET,
 156         .reg_defaults = lp5036_reg_defs,
 157         .num_reg_defaults = ARRAY_SIZE(lp5036_reg_defs),
 158         .cache_type = REGCACHE_FLAT,
 159 };
 160
 161 enum lp50xx_model {
 162         LP5009,
 163         LP5012,
 164         LP5018,
 165         LP5024,
 166         LP5030,
 167         LP5036,
 168 };
 169
 170 /**
 171  * struct lp50xx_chip_info -
 172  * @lp50xx_regmap_config: regmap register configuration
 173  * @model_id: LED device model
 174  * @max_modules: total number of supported LED modules
 175  * @num_leds: number of LED outputs available on the device
 176  * @led_brightness0_reg: first brightness register of the device
 177  * @mix_out0_reg: first color mix register of the device
 178  * @bank_brt_reg: bank brightness register
 179  * @bank_mix_reg: color mix register
 180  * @reset_reg: device reset register
 181  */
 182 struct lp50xx_chip_info {
 183         const struct regmap_config *lp50xx_regmap_config;
 184         int model_id;
 185         u8 max_modules;
 186         u8 num_leds;
 187         u8 led_brightness0_reg;
 188         u8 mix_out0_reg;
 189         u8 bank_brt_reg;
 190         u8 bank_mix_reg;
 191         u8 reset_reg;
 192 };
 193
 194 static const struct lp50xx_chip_info lp50xx_chip_info_tbl[] = {
 195         [LP5009] = {
 196                 .model_id = LP5009,
 197                 .max_modules = LP5009_MAX_LED_MODULES,
 198                 .num_leds = LP5009_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
 199                 .led_brightness0_reg = LP5012_LED0_BRT,
 200                 .mix_out0_reg = LP5012_OUT0_CLR,
 201                 .bank_brt_reg = LP5012_BNK_BRT,
 202                 .bank_mix_reg = LP5012_BNKA_CLR,
 203                 .reset_reg = LP5012_RESET,
 204                 .lp50xx_regmap_config = &lp5012_regmap_config,
 205         },
 206         [LP5012] = {
 207                 .model_id = LP5012,
 208                 .max_modules = LP5012_MAX_LED_MODULES,
 209                 .num_leds = LP5012_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
 210                 .led_brightness0_reg = LP5012_LED0_BRT,
 211                 .mix_out0_reg = LP5012_OUT0_CLR,
 212                 .bank_brt_reg = LP5012_BNK_BRT,
 213                 .bank_mix_reg = LP5012_BNKA_CLR,
 214                 .reset_reg = LP5012_RESET,
 215                 .lp50xx_regmap_config = &lp5012_regmap_config,
 216         },
 217         [LP5018] = {
 218                 .model_id = LP5018,
 219                 .max_modules = LP5018_MAX_LED_MODULES,
 220                 .num_leds = LP5018_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
 221                 .led_brightness0_reg = LP5024_LED0_BRT,
 222                 .mix_out0_reg = LP5024_OUT0_CLR,
 223                 .bank_brt_reg = LP5024_BNK_BRT,
 224                 .bank_mix_reg = LP5024_BNKA_CLR,
 225                 .reset_reg = LP5024_RESET,
 226                 .lp50xx_regmap_config = &lp5024_regmap_config,
 227         },
 228         [LP5024] = {
 229                 .model_id = LP5024,
 230                 .max_modules = LP5024_MAX_LED_MODULES,
 231                 .num_leds = LP5024_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
 232                 .led_brightness0_reg = LP5024_LED0_BRT,
 233                 .mix_out0_reg = LP5024_OUT0_CLR,
 234                 .bank_brt_reg = LP5024_BNK_BRT,
 235                 .bank_mix_reg = LP5024_BNKA_CLR,
 236                 .reset_reg = LP5024_RESET,
 237                 .lp50xx_regmap_config = &lp5024_regmap_config,
 238         },
 239         [LP5030] = {
 240                 .model_id = LP5030,
 241                 .max_modules = LP5030_MAX_LED_MODULES,
 242                 .num_leds = LP5030_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
 243                 .led_brightness0_reg = LP5036_LED0_BRT,
 244                 .mix_out0_reg = LP5036_OUT0_CLR,
 245                 .bank_brt_reg = LP5036_BNK_BRT,
 246                 .bank_mix_reg = LP5036_BNKA_CLR,
 247                 .reset_reg = LP5036_RESET,
 248                 .lp50xx_regmap_config = &lp5036_regmap_config,
 249         },
 250         [LP5036] = {
 251                 .model_id = LP5036,
 252                 .max_modules = LP5036_MAX_LED_MODULES,
 253                 .num_leds = LP5036_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
 254                 .led_brightness0_reg = LP5036_LED0_BRT,
 255                 .mix_out0_reg = LP5036_OUT0_CLR,
 256                 .bank_brt_reg = LP5036_BNK_BRT,
 257                 .bank_mix_reg = LP5036_BNKA_CLR,
 258                 .reset_reg = LP5036_RESET,
 259                 .lp50xx_regmap_config = &lp5036_regmap_config,
 260         },
 261 };
 262
 263 struct lp50xx_led {
 264         struct led_classdev_mc mc_cdev;
 265         struct lp50xx *priv;
 266         u8 ctrl_bank_enabled;
 267         int led_number;
 268 };
 269
 270 /**
 271  * struct lp50xx -
 272  * @enable_gpio: hardware enable gpio
 273  * @regulator: LED supply regulator pointer
 274  * @client: pointer to the I2C client
 275  * @regmap: device register map
 276  * @dev: pointer to the devices device struct
 277  * @lock: lock for reading/writing the device
 278  * @chip_info: chip specific information (ie num_leds)
 279  * @leds: array of LED strings
 280  */
 281 struct lp50xx {
 282         struct gpio_desc *enable_gpio;
 283         struct regulator *regulator;
 284         struct i2c_client *client;
 285         struct regmap *regmap;
 286         struct device *dev;
 287         struct mutex lock;
 288         const struct lp50xx_chip_info *chip_info;
 289
 290         /* This needs to be at the end of the struct */
 291         struct lp50xx_led leds[];
 292 };
 293
 294 static struct lp50xx_led *mcled_cdev_to_led(struct led_classdev_mc *mc_cdev)
 295 {
 296         return container_of(mc_cdev, struct lp50xx_led, mc_cdev);
 297 }
 298
 299 static int lp50xx_brightness_set(struct led_classdev *cdev,
 300                              enum led_brightness brightness)
 301 {
 302         struct led_classdev_mc *mc_dev = lcdev_to_mccdev(cdev);
 303         struct lp50xx_led *led = mcled_cdev_to_led(mc_dev);
 304         const struct lp50xx_chip_info *led_chip = led->priv->chip_info;
 305         u8 led_offset, reg_val;
 306         int ret = 0;
 307         int i;
 308
 309         mutex_lock(&led->priv->lock);
 310         if (led->ctrl_bank_enabled)
 311                 reg_val = led_chip->bank_brt_reg;
 312         else
 313                 reg_val = led_chip->led_brightness0_reg +
 314                           led->led_number;
 315
 316         ret = regmap_write(led->priv->regmap, reg_val, brightness);
 317         if (ret) {
 318                 dev_err(led->priv->dev,
 319                         "Cannot write brightness value %d\n", ret);
 320                 goto out;
 321         }
 322
 323         for (i = 0; i < led->mc_cdev.num_colors; i++) {
 324                 if (led->ctrl_bank_enabled) {
 325                         reg_val = led_chip->bank_mix_reg + i;
 326                 } else {
 327                         led_offset = (led->led_number * 3) + i;
 328                         reg_val = led_chip->mix_out0_reg + led_offset;
 329                 }
 330
 331                 ret = regmap_write(led->priv->regmap, reg_val,
 332                                    mc_dev->subled_info[i].intensity);
 333                 if (ret) {
 334                         dev_err(led->priv->dev,
 335                                 "Cannot write intensity value %d\n", ret);
 336                         goto out;
 337                 }
 338         }
 339 out:
 340         mutex_unlock(&led->priv->lock);
 341         return ret;
 342 }
 343
 344 static int lp50xx_set_banks(struct lp50xx *priv, u32 led_banks[])
 345 {
 346         u8 led_config_lo, led_config_hi;
 347         u32 bank_enable_mask = 0;
 348         int ret;
 349         int i;
 350
 351         for (i = 0; i < priv->chip_info->max_modules; i++) {
 352                 if (led_banks[i])
 353                         bank_enable_mask |= (1 << led_banks[i]);
 354         }
 355
 356         led_config_lo = bank_enable_mask;
 357         led_config_hi = bank_enable_mask >> 8;
 358
 359         ret = regmap_write(priv->regmap, LP50XX_LED_CFG0, led_config_lo);
 360         if (ret)
 361                 return ret;
 362
 363         if (priv->chip_info->model_id >= LP5030)
 364                 ret = regmap_write(priv->regmap, LP5036_LED_CFG1, led_config_hi);
 365
 366         return ret;
 367 }
 368
 369 static int lp50xx_reset(struct lp50xx *priv)
 370 {
 371         return regmap_write(priv->regmap, priv->chip_info->reset_reg, LP50XX_SW_RESET);
 372 }
 373
 374 static int lp50xx_enable_disable(struct lp50xx *priv, int enable_disable)
 375 {
 376         int ret;
 377
 378         ret = gpiod_direction_output(priv->enable_gpio, enable_disable);
 379         if (ret)
 380                 return ret;
 381
 382         if (enable_disable)
 383                 return regmap_write(priv->regmap, LP50XX_DEV_CFG0, LP50XX_CHIP_EN);
 384         else
 385                 return regmap_write(priv->regmap, LP50XX_DEV_CFG0, 0);
 386
 387 }
 388
 389 static int lp50xx_probe_leds(struct fwnode_handle *child, struct lp50xx *priv,
 390                              struct lp50xx_led *led, int num_leds)
 391 {
 392         u32 led_banks[LP5036_MAX_LED_MODULES] = {0};
 393         int led_number;
 394         int ret;
 395
 396         if (num_leds > 1) {
 397                 if (num_leds > priv->chip_info->max_modules) {
 398                         dev_err(priv->dev, "reg property is invalid\n");
 399                         return -EINVAL;
 400                 }
 401
 402                 ret = fwnode_property_read_u32_array(child, "reg", led_banks, num_leds);
 403                 if (ret) {
 404                         dev_err(priv->dev, "reg property is missing\n");
 405                         return ret;
 406                 }
 407
 408                 ret = lp50xx_set_banks(priv, led_banks);
 409                 if (ret) {
 410                         dev_err(priv->dev, "Cannot setup banked LEDs\n");
 411                         return ret;
 412                 }
 413
 414                 led->ctrl_bank_enabled = 1;
 415         } else {
 416                 ret = fwnode_property_read_u32(child, "reg", &led_number);
 417                 if (ret) {
 418                         dev_err(priv->dev, "led reg property missing\n");
 419                         return ret;
 420                 }
 421
 422                 if (led_number > priv->chip_info->num_leds) {
 423                         dev_err(priv->dev, "led-sources property is invalid\n");
 424                         return -EINVAL;
 425                 }
 426
 427                 led->led_number = led_number;
 428         }
 429
 430         return 0;
 431 }
 432
 433 static int lp50xx_probe_dt(struct lp50xx *priv)
 434 {
 435         struct fwnode_handle *led_node = NULL;
 436         struct led_init_data init_data = {};
 437         struct led_classdev *led_cdev;
 438         struct mc_subled *mc_led_info;
 439         struct lp50xx_led *led;
 440         int ret = -EINVAL;
 441         int num_colors;
 442         u32 color_id;
 443         int i = 0;
 444
 445         priv->enable_gpio = devm_gpiod_get_optional(priv->dev, "enable", GPIOD_OUT_LOW);
 446         if (IS_ERR(priv->enable_gpio))
 447                 return dev_err_probe(priv->dev, PTR_ERR(priv->enable_gpio),
 448                                      "Failed to get enable GPIO\n");
 449
 450         priv->regulator = devm_regulator_get(priv->dev, "vled");
 451         if (IS_ERR(priv->regulator))
 452                 priv->regulator = NULL;
 453
 454         device_for_each_child_node_scoped(priv->dev, child) {
 455                 led = &priv->leds[i];
 456                 ret = fwnode_property_count_u32(child, "reg");
 457                 if (ret < 0) {
 458                         dev_err(priv->dev, "reg property is invalid\n");
 459                         return ret;
 460                 }
 461
 462                 ret = lp50xx_probe_leds(child, priv, led, ret);
 463                 if (ret)
 464                         return ret;
 465
 466                 init_data.fwnode = child;
 467                 num_colors = 0;
 468
 469                 /*
 470                  * There are only 3 LEDs per module otherwise they should be
 471                  * banked which also is presented as 3 LEDs.
 472                  */
 473                 mc_led_info = devm_kcalloc(priv->dev, LP50XX_LEDS_PER_MODULE,
 474                                            sizeof(*mc_led_info), GFP_KERNEL);
 475                 if (!mc_led_info)
 476                         return -ENOMEM;
 477
 478                 fwnode_for_each_child_node(child, led_node) {
 479                         ret = fwnode_property_read_u32(led_node, "color",
 480                                                        &color_id);
 481                         if (ret) {
 482                                 fwnode_handle_put(led_node);
 483                                 dev_err(priv->dev, "Cannot read color\n");
 484                                 return ret;
 485                         }
 486
 487                         mc_led_info[num_colors].color_index = color_id;
 488                         num_colors++;
 489                 }
 490
 491                 led->priv = priv;
 492                 led->mc_cdev.num_colors = num_colors;
 493                 led->mc_cdev.subled_info = mc_led_info;
 494                 led_cdev = &led->mc_cdev.led_cdev;
 495                 led_cdev->brightness_set_blocking = lp50xx_brightness_set;
 496
 497                 ret = devm_led_classdev_multicolor_register_ext(priv->dev,
 498                                                        &led->mc_cdev,
 499                                                        &init_data);
 500                 if (ret) {
 501                         dev_err(priv->dev, "led register err: %d\n", ret);
 502                         return ret;
 503                 }
 504                 i++;
 505         }
 506
 507         return 0;
 508 }
 509
 510 static int lp50xx_probe(struct i2c_client *client)
 511 {
 512         struct lp50xx *led;
 513         int count;
 514         int ret;
 515
 516         count = device_get_child_node_count(&client->dev);
 517         if (!count) {
 518                 dev_err(&client->dev, "LEDs are not defined in device tree!");
 519                 return -ENODEV;
 520         }
 521
 522         led = devm_kzalloc(&client->dev, struct_size(led, leds, count),
 523                            GFP_KERNEL);
 524         if (!led)
 525                 return -ENOMEM;
 526
 527         mutex_init(&led->lock);
 528         led->client = client;
 529         led->dev = &client->dev;
 530         led->chip_info = device_get_match_data(&client->dev);
 531         i2c_set_clientdata(client, led);
 532         led->regmap = devm_regmap_init_i2c(client,
 533                                         led->chip_info->lp50xx_regmap_config);
 534         if (IS_ERR(led->regmap)) {
 535                 ret = PTR_ERR(led->regmap);
 536                 dev_err(&client->dev, "Failed to allocate register map: %d\n",
 537                         ret);
 538                 return ret;
 539         }
 540
 541         ret = lp50xx_reset(led);
 542         if (ret)
 543                 return ret;
 544
 545         ret = lp50xx_enable_disable(led, 1);
 546         if (ret)
 547                 return ret;
 548
 549         return lp50xx_probe_dt(led);
 550 }
 551
 552 static void lp50xx_remove(struct i2c_client *client)
 553 {
 554         struct lp50xx *led = i2c_get_clientdata(client);
 555         int ret;
 556
 557         ret = lp50xx_enable_disable(led, 0);
 558         if (ret)
 559                 dev_err(led->dev, "Failed to disable chip\n");
 560
 561         if (led->regulator) {
 562                 ret = regulator_disable(led->regulator);
 563                 if (ret)
 564                         dev_err(led->dev, "Failed to disable regulator\n");
 565         }
 566
 567         mutex_destroy(&led->lock);
 568 }
 569
 570 static const struct i2c_device_id lp50xx_id[] = {
 571         { "lp5009", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5009] },
 572         { "lp5012", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5012] },
 573         { "lp5018", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5018] },
 574         { "lp5024", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5024] },
 575         { "lp5030", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5030] },
 576         { "lp5036", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5036] },
 577         { }
 578 };
 579 MODULE_DEVICE_TABLE(i2c, lp50xx_id);
 580
 581 static const struct of_device_id of_lp50xx_leds_match[] = {
 582         { .compatible = "ti,lp5009", .data = &lp50xx_chip_info_tbl[LP5009] },
 583         { .compatible = "ti,lp5012", .data = &lp50xx_chip_info_tbl[LP5012] },
 584         { .compatible = "ti,lp5018", .data = &lp50xx_chip_info_tbl[LP5018] },
 585         { .compatible = "ti,lp5024", .data = &lp50xx_chip_info_tbl[LP5024] },
 586         { .compatible = "ti,lp5030", .data = &lp50xx_chip_info_tbl[LP5030] },
 587         { .compatible = "ti,lp5036", .data = &lp50xx_chip_info_tbl[LP5036] },
 588         {}
 589 };
 590 MODULE_DEVICE_TABLE(of, of_lp50xx_leds_match);
 591
 592 static struct i2c_driver lp50xx_driver = {
 593         .driver = {
 594                 .name   = "lp50xx",
 595                 .of_match_table = of_lp50xx_leds_match,
 596         },
 597         .probe          = lp50xx_probe,
 598         .remove         = lp50xx_remove,
 599         .id_table       = lp50xx_id,
 600 };
 601 module_i2c_driver(lp50xx_driver);
 602
 603 MODULE_DESCRIPTION("Texas Instruments LP50XX LED driver");
 604 MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");
 605 MODULE_LICENSE("GPL v2");