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