drivers/leds/leds-lm3532.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // TI LM3532 LED driver
   3 // Copyright (C) 2019 Texas Instruments Incorporated - http://www.ti.com/
   4 // http://www.ti.com/lit/ds/symlink/lm3532.pdf
   5
   6 #include <linux/i2c.h>
   7 #include <linux/leds.h>
   8 #include <linux/slab.h>
   9 #include <linux/regmap.h>
  10 #include <linux/types.h>
  11 #include <linux/regulator/consumer.h>
  12 #include <linux/module.h>
  13 #include <uapi/linux/uleds.h>
  14 #include <linux/gpio/consumer.h>
  15
  16 #define LM3532_NAME "lm3532-led"
  17 #define LM3532_BL_MODE_MANUAL   0x00
  18 #define LM3532_BL_MODE_ALS      0x01
  19
  20 #define LM3532_REG_OUTPUT_CFG   0x10
  21 #define LM3532_REG_STARTSHUT_RAMP       0x11
  22 #define LM3532_REG_RT_RAMP      0x12
  23 #define LM3532_REG_PWM_A_CFG    0x13
  24 #define LM3532_REG_PWM_B_CFG    0x14
  25 #define LM3532_REG_PWM_C_CFG    0x15
  26 #define LM3532_REG_ZONE_CFG_A   0x16
  27 #define LM3532_REG_CTRL_A_FS_CURR       0x17
  28 #define LM3532_REG_ZONE_CFG_B   0x18
  29 #define LM3532_REG_CTRL_B_FS_CURR       0x19
  30 #define LM3532_REG_ZONE_CFG_C   0x1a
  31 #define LM3532_REG_CTRL_C_FS_CURR       0x1b
  32 #define LM3532_REG_ENABLE       0x1d
  33 #define LM3532_ALS_CONFIG       0x23
  34 #define LM3532_REG_ZN_0_HI      0x60
  35 #define LM3532_REG_ZN_0_LO      0x61
  36 #define LM3532_REG_ZN_1_HI      0x62
  37 #define LM3532_REG_ZN_1_LO      0x63
  38 #define LM3532_REG_ZN_2_HI      0x64
  39 #define LM3532_REG_ZN_2_LO      0x65
  40 #define LM3532_REG_ZN_3_HI      0x66
  41 #define LM3532_REG_ZN_3_LO      0x67
  42 #define LM3532_REG_ZONE_TRGT_A  0x70
  43 #define LM3532_REG_ZONE_TRGT_B  0x75
  44 #define LM3532_REG_ZONE_TRGT_C  0x7a
  45 #define LM3532_REG_MAX          0x7e
  46
  47 /* Control Enable */
  48 #define LM3532_CTRL_A_ENABLE    BIT(0)
  49 #define LM3532_CTRL_B_ENABLE    BIT(1)
  50 #define LM3532_CTRL_C_ENABLE    BIT(2)
  51
  52 /* PWM Zone Control */
  53 #define LM3532_PWM_ZONE_MASK    0x7c
  54 #define LM3532_PWM_ZONE_0_EN    BIT(2)
  55 #define LM3532_PWM_ZONE_1_EN    BIT(3)
  56 #define LM3532_PWM_ZONE_2_EN    BIT(4)
  57 #define LM3532_PWM_ZONE_3_EN    BIT(5)
  58 #define LM3532_PWM_ZONE_4_EN    BIT(6)
  59
  60 /* Brightness Configuration */
  61 #define LM3532_I2C_CTRL         BIT(0)
  62 #define LM3532_ALS_CTRL         0
  63 #define LM3532_LINEAR_MAP       BIT(1)
  64 #define LM3532_ZONE_MASK        (BIT(2) | BIT(3) | BIT(4))
  65 #define LM3532_ZONE_0           0
  66 #define LM3532_ZONE_1           BIT(2)
  67 #define LM3532_ZONE_2           BIT(3)
  68 #define LM3532_ZONE_3           (BIT(2) | BIT(3))
  69 #define LM3532_ZONE_4           BIT(4)
  70
  71 #define LM3532_ENABLE_ALS       BIT(3)
  72 #define LM3532_ALS_SEL_SHIFT    6
  73
  74 /* Zone Boundary Register */
  75 #define LM3532_ALS_WINDOW_mV    2000
  76 #define LM3532_ALS_ZB_MAX       4
  77 #define LM3532_ALS_OFFSET_mV    2
  78
  79 #define LM3532_CONTROL_A        0
  80 #define LM3532_CONTROL_B        1
  81 #define LM3532_CONTROL_C        2
  82 #define LM3532_MAX_CONTROL_BANKS 3
  83 #define LM3532_MAX_LED_STRINGS  3
  84
  85 #define LM3532_OUTPUT_CFG_MASK  0x3
  86 #define LM3532_BRT_VAL_ADJUST   8
  87 #define LM3532_RAMP_DOWN_SHIFT  3
  88
  89 #define LM3532_NUM_RAMP_VALS    8
  90 #define LM3532_NUM_AVG_VALS     8
  91 #define LM3532_NUM_IMP_VALS     32
  92
  93 #define LM3532_FS_CURR_MIN      5000
  94 #define LM3532_FS_CURR_MAX      29800
  95 #define LM3532_FS_CURR_STEP     800
  96
  97 /*
  98  * struct lm3532_als_data
  99  * @config - value of ALS configuration register
 100  * @als1_imp_sel - value of ALS1 resistor select register
 101  * @als2_imp_sel - value of ALS2 resistor select register
 102  * @als_avrg_time - ALS averaging time
 103  * @als_input_mode - ALS input mode for brightness control
 104  * @als_vmin - Minimum ALS voltage
 105  * @als_vmax - Maximum ALS voltage
 106  * @zone_lo - values of ALS lo ZB(Zone Boundary) registers
 107  * @zone_hi - values of ALS hi ZB(Zone Boundary) registers
 108  */
 109 struct lm3532_als_data {
 110         u8 config;
 111         u8 als1_imp_sel;
 112         u8 als2_imp_sel;
 113         u8 als_avrg_time;
 114         u8 als_input_mode;
 115         u32 als_vmin;
 116         u32 als_vmax;
 117         u8 zones_lo[LM3532_ALS_ZB_MAX];
 118         u8 zones_hi[LM3532_ALS_ZB_MAX];
 119 };
 120
 121 /**
 122  * struct lm3532_led
 123  * @led_dev: led class device
 124  * @priv - Pointer the device data structure
 125  * @control_bank - Control bank the LED is associated to
 126  * @mode - Mode of the LED string
 127  * @ctrl_brt_pointer - Zone target register that controls the sink
 128  * @num_leds - Number of LED strings are supported in this array
 129  * @full_scale_current - The full-scale current setting for the current sink.
 130  * @led_strings - The LED strings supported in this array
 131  * @enabled - Enabled status
 132  * @label - LED label
 133  */
 134 struct lm3532_led {
 135         struct led_classdev led_dev;
 136         struct lm3532_data *priv;
 137
 138         int control_bank;
 139         int mode;
 140         int ctrl_brt_pointer;
 141         int num_leds;
 142         int full_scale_current;
 143         unsigned int enabled:1;
 144         u32 led_strings[LM3532_MAX_CONTROL_BANKS];
 145         char label[LED_MAX_NAME_SIZE];
 146 };
 147
 148 /**
 149  * struct lm3532_data
 150  * @enable_gpio - Hardware enable gpio
 151  * @regulator: regulator
 152  * @client: i2c client
 153  * @regmap - Devices register map
 154  * @dev - Pointer to the devices device struct
 155  * @lock - Lock for reading/writing the device
 156  * @als_data - Pointer to the als data struct
 157  * @runtime_ramp_up - Runtime ramp up setting
 158  * @runtime_ramp_down - Runtime ramp down setting
 159  * @leds - Array of LED strings
 160  */
 161 struct lm3532_data {
 162         struct gpio_desc *enable_gpio;
 163         struct regulator *regulator;
 164         struct i2c_client *client;
 165         struct regmap *regmap;
 166         struct device *dev;
 167         struct mutex lock;
 168
 169         struct lm3532_als_data *als_data;
 170
 171         u32 runtime_ramp_up;
 172         u32 runtime_ramp_down;
 173
 174         struct lm3532_led leds[];
 175 };
 176
 177 static const struct reg_default lm3532_reg_defs[] = {
 178         {LM3532_REG_OUTPUT_CFG, 0xe4},
 179         {LM3532_REG_STARTSHUT_RAMP, 0xc0},
 180         {LM3532_REG_RT_RAMP, 0xc0},
 181         {LM3532_REG_PWM_A_CFG, 0x82},
 182         {LM3532_REG_PWM_B_CFG, 0x82},
 183         {LM3532_REG_PWM_C_CFG, 0x82},
 184         {LM3532_REG_ZONE_CFG_A, 0xf1},
 185         {LM3532_REG_CTRL_A_FS_CURR, 0xf3},
 186         {LM3532_REG_ZONE_CFG_B, 0xf1},
 187         {LM3532_REG_CTRL_B_FS_CURR, 0xf3},
 188         {LM3532_REG_ZONE_CFG_C, 0xf1},
 189         {LM3532_REG_CTRL_C_FS_CURR, 0xf3},
 190         {LM3532_REG_ENABLE, 0xf8},
 191         {LM3532_ALS_CONFIG, 0x44},
 192         {LM3532_REG_ZN_0_HI, 0x35},
 193         {LM3532_REG_ZN_0_LO, 0x33},
 194         {LM3532_REG_ZN_1_HI, 0x6a},
 195         {LM3532_REG_ZN_1_LO, 0x66},
 196         {LM3532_REG_ZN_2_HI, 0xa1},
 197         {LM3532_REG_ZN_2_LO, 0x99},
 198         {LM3532_REG_ZN_3_HI, 0xdc},
 199         {LM3532_REG_ZN_3_LO, 0xcc},
 200 };
 201
 202 static const struct regmap_config lm3532_regmap_config = {
 203         .reg_bits = 8,
 204         .val_bits = 8,
 205
 206         .max_register = LM3532_REG_MAX,
 207         .reg_defaults = lm3532_reg_defs,
 208         .num_reg_defaults = ARRAY_SIZE(lm3532_reg_defs),
 209         .cache_type = REGCACHE_FLAT,
 210 };
 211
 212 static const int als_imp_table[LM3532_NUM_IMP_VALS] = {37000, 18500, 12330,
 213                                                        92500, 7400, 6170, 5290,
 214                                                        4630, 4110, 3700, 3360,
 215                                                        3080, 2850, 2640, 2440,
 216                                                        2310, 2180, 2060, 1950,
 217                                                        1850, 1760, 1680, 1610,
 218                                                        1540, 1480, 1420, 1370,
 219                                                        1320, 1280, 1230, 1190};
 220 static int lm3532_get_als_imp_index(int als_imped)
 221 {
 222         int i;
 223
 224         if (als_imped > als_imp_table[1])
 225                 return 0;
 226
 227         if (als_imped < als_imp_table[LM3532_NUM_IMP_VALS - 1])
 228                 return LM3532_NUM_IMP_VALS - 1;
 229
 230         for (i = 1; i < LM3532_NUM_IMP_VALS; i++) {
 231                 if (als_imped == als_imp_table[i])
 232                         return i;
 233
 234                 /* Find an approximate index by looking up the table */
 235                 if (als_imped < als_imp_table[i - 1] &&
 236                     als_imped > als_imp_table[i]) {
 237                         if (als_imped - als_imp_table[i - 1] <
 238                             als_imp_table[i] - als_imped)
 239                                 return i + 1;
 240                         else
 241                                 return i;
 242                 }
 243         }
 244
 245         return -EINVAL;
 246 }
 247
 248 static int lm3532_get_index(const int table[], int size, int value)
 249 {
 250         int i;
 251
 252         for (i = 1; i < size; i++) {
 253                 if (value == table[i])
 254                         return i;
 255
 256                 /* Find an approximate index by looking up the table */
 257                 if (value > table[i - 1] &&
 258                     value < table[i]) {
 259                         if (value - table[i - 1] < table[i] - value)
 260                                 return i - 1;
 261                         else
 262                                 return i;
 263                 }
 264         }
 265
 266         return -EINVAL;
 267 }
 268
 269 static const int als_avrg_table[LM3532_NUM_AVG_VALS] = {17920, 35840, 71680,
 270                                                         1433360, 286720, 573440,
 271                                                         1146880, 2293760};
 272 static int lm3532_get_als_avg_index(int avg_time)
 273 {
 274         if (avg_time <= als_avrg_table[0])
 275                 return 0;
 276
 277         if (avg_time > als_avrg_table[LM3532_NUM_AVG_VALS - 1])
 278                 return LM3532_NUM_AVG_VALS - 1;
 279
 280         return lm3532_get_index(&als_avrg_table[0], LM3532_NUM_AVG_VALS,
 281                                 avg_time);
 282 }
 283
 284 static const int ramp_table[LM3532_NUM_RAMP_VALS] = { 8, 1024, 2048, 4096, 8192,
 285                                                      16384, 32768, 65536};
 286 static int lm3532_get_ramp_index(int ramp_time)
 287 {
 288         if (ramp_time <= ramp_table[0])
 289                 return 0;
 290
 291         if (ramp_time > ramp_table[LM3532_NUM_RAMP_VALS - 1])
 292                 return LM3532_NUM_RAMP_VALS - 1;
 293
 294         return lm3532_get_index(&ramp_table[0], LM3532_NUM_RAMP_VALS,
 295                                 ramp_time);
 296 }
 297
 298 /* Caller must take care of locking */
 299 static int lm3532_led_enable(struct lm3532_led *led_data)
 300 {
 301         int ctrl_en_val = BIT(led_data->control_bank);
 302         int ret;
 303
 304         if (led_data->enabled)
 305                 return 0;
 306
 307         ret = regmap_update_bits(led_data->priv->regmap, LM3532_REG_ENABLE,
 308                                          ctrl_en_val, ctrl_en_val);
 309         if (ret) {
 310                 dev_err(led_data->priv->dev, "Failed to set ctrl:%d\n", ret);
 311                 return ret;
 312         }
 313
 314         ret = regulator_enable(led_data->priv->regulator);
 315         if (ret < 0)
 316                 return ret;
 317
 318         led_data->enabled = 1;
 319
 320         return 0;
 321 }
 322
 323 /* Caller must take care of locking */
 324 static int lm3532_led_disable(struct lm3532_led *led_data)
 325 {
 326         int ctrl_en_val = BIT(led_data->control_bank);
 327         int ret;
 328
 329         if (!led_data->enabled)
 330                 return 0;
 331
 332         ret = regmap_update_bits(led_data->priv->regmap, LM3532_REG_ENABLE,
 333                                          ctrl_en_val, 0);
 334         if (ret) {
 335                 dev_err(led_data->priv->dev, "Failed to set ctrl:%d\n", ret);
 336                 return ret;
 337         }
 338
 339         ret = regulator_disable(led_data->priv->regulator);
 340         if (ret < 0)
 341                 return ret;
 342
 343         led_data->enabled = 0;
 344
 345         return 0;
 346 }
 347
 348 static int lm3532_brightness_set(struct led_classdev *led_cdev,
 349                                  enum led_brightness brt_val)
 350 {
 351         struct lm3532_led *led =
 352                         container_of(led_cdev, struct lm3532_led, led_dev);
 353         u8 brightness_reg;
 354         int ret;
 355
 356         mutex_lock(&led->priv->lock);
 357
 358         if (led->mode == LM3532_ALS_CTRL) {
 359                 if (brt_val > LED_OFF)
 360                         ret = lm3532_led_enable(led);
 361                 else
 362                         ret = lm3532_led_disable(led);
 363
 364                 goto unlock;
 365         }
 366
 367         if (brt_val == LED_OFF) {
 368                 ret = lm3532_led_disable(led);
 369                 goto unlock;
 370         }
 371
 372         ret = lm3532_led_enable(led);
 373         if (ret)
 374                 goto unlock;
 375
 376         brightness_reg = LM3532_REG_ZONE_TRGT_A + led->control_bank * 5 +
 377                          (led->ctrl_brt_pointer >> 2);
 378
 379         ret = regmap_write(led->priv->regmap, brightness_reg, brt_val);
 380
 381 unlock:
 382         mutex_unlock(&led->priv->lock);
 383         return ret;
 384 }
 385
 386 static int lm3532_init_registers(struct lm3532_led *led)
 387 {
 388         struct lm3532_data *drvdata = led->priv;
 389         unsigned int runtime_ramp_val;
 390         unsigned int output_cfg_val = 0;
 391         unsigned int output_cfg_shift = 0;
 392         unsigned int output_cfg_mask = 0;
 393         unsigned int brightness_config_reg;
 394         unsigned int brightness_config_val;
 395         int fs_current_reg;
 396         int fs_current_val;
 397         int ret, i;
 398
 399         if (drvdata->enable_gpio)
 400                 gpiod_direction_output(drvdata->enable_gpio, 1);
 401
 402         brightness_config_reg = LM3532_REG_ZONE_CFG_A + led->control_bank * 2;
 403         /*
 404          * This could be hard coded to the default value but the control
 405          * brightness register may have changed during boot.
 406          */
 407         ret = regmap_read(drvdata->regmap, brightness_config_reg,
 408                           &led->ctrl_brt_pointer);
 409         if (ret)
 410                 return ret;
 411
 412         led->ctrl_brt_pointer &= LM3532_ZONE_MASK;
 413         brightness_config_val = led->ctrl_brt_pointer | led->mode;
 414         ret = regmap_write(drvdata->regmap, brightness_config_reg,
 415                            brightness_config_val);
 416         if (ret)
 417                 return ret;
 418
 419         if (led->full_scale_current) {
 420                 fs_current_reg = LM3532_REG_CTRL_A_FS_CURR + led->control_bank * 2;
 421                 fs_current_val = (led->full_scale_current - LM3532_FS_CURR_MIN) /
 422                                  LM3532_FS_CURR_STEP;
 423
 424                 ret = regmap_write(drvdata->regmap, fs_current_reg,
 425                                    fs_current_val);
 426                 if (ret)
 427                         return ret;
 428         }
 429
 430         for (i = 0; i < led->num_leds; i++) {
 431                 output_cfg_shift = led->led_strings[i] * 2;
 432                 output_cfg_val |= (led->control_bank << output_cfg_shift);
 433                 output_cfg_mask |= LM3532_OUTPUT_CFG_MASK << output_cfg_shift;
 434         }
 435
 436         ret = regmap_update_bits(drvdata->regmap, LM3532_REG_OUTPUT_CFG,
 437                                  output_cfg_mask, output_cfg_val);
 438         if (ret)
 439                 return ret;
 440
 441         runtime_ramp_val = drvdata->runtime_ramp_up |
 442                          (drvdata->runtime_ramp_down << LM3532_RAMP_DOWN_SHIFT);
 443
 444         return regmap_write(drvdata->regmap, LM3532_REG_RT_RAMP,
 445                             runtime_ramp_val);
 446 }
 447
 448 static int lm3532_als_configure(struct lm3532_data *priv,
 449                                 struct lm3532_led *led)
 450 {
 451         struct lm3532_als_data *als = priv->als_data;
 452         u32 als_vmin, als_vmax, als_vstep;
 453         int zone_reg = LM3532_REG_ZN_0_HI;
 454         int ret;
 455         int i;
 456
 457         als_vmin = als->als_vmin;
 458         als_vmax = als->als_vmax;
 459
 460         als_vstep = (als_vmax - als_vmin) / ((LM3532_ALS_ZB_MAX + 1) * 2);
 461
 462         for (i = 0; i < LM3532_ALS_ZB_MAX; i++) {
 463                 als->zones_lo[i] = ((als_vmin + als_vstep + (i * als_vstep)) *
 464                                 LED_FULL) / 1000;
 465                 als->zones_hi[i] = ((als_vmin + LM3532_ALS_OFFSET_mV +
 466                                 als_vstep + (i * als_vstep)) * LED_FULL) / 1000;
 467
 468                 zone_reg = LM3532_REG_ZN_0_HI + i * 2;
 469                 ret = regmap_write(priv->regmap, zone_reg, als->zones_lo[i]);
 470                 if (ret)
 471                         return ret;
 472
 473                 zone_reg += 1;
 474                 ret = regmap_write(priv->regmap, zone_reg, als->zones_hi[i]);
 475                 if (ret)
 476                         return ret;
 477         }
 478
 479         als->config = (als->als_avrg_time | (LM3532_ENABLE_ALS) |
 480                 (als->als_input_mode << LM3532_ALS_SEL_SHIFT));
 481
 482         return regmap_write(priv->regmap, LM3532_ALS_CONFIG, als->config);
 483 }
 484
 485 static int lm3532_parse_als(struct lm3532_data *priv)
 486 {
 487         struct lm3532_als_data *als;
 488         int als_avg_time;
 489         int als_impedance;
 490         int ret;
 491
 492         als = devm_kzalloc(priv->dev, sizeof(*als), GFP_KERNEL);
 493         if (als == NULL)
 494                 return -ENOMEM;
 495
 496         ret = device_property_read_u32(&priv->client->dev, "ti,als-vmin",
 497                                        &als->als_vmin);
 498         if (ret)
 499                 als->als_vmin = 0;
 500
 501         ret = device_property_read_u32(&priv->client->dev, "ti,als-vmax",
 502                                        &als->als_vmax);
 503         if (ret)
 504                 als->als_vmax = LM3532_ALS_WINDOW_mV;
 505
 506         if (als->als_vmax > LM3532_ALS_WINDOW_mV) {
 507                 ret = -EINVAL;
 508                 return ret;
 509         }
 510
 511         ret = device_property_read_u32(&priv->client->dev, "ti,als1-imp-sel",
 512                                       &als_impedance);
 513         if (ret)
 514                 als->als1_imp_sel = 0;
 515         else
 516                 als->als1_imp_sel = lm3532_get_als_imp_index(als_impedance);
 517
 518         ret = device_property_read_u32(&priv->client->dev, "ti,als2-imp-sel",
 519                                       &als_impedance);
 520         if (ret)
 521                 als->als2_imp_sel = 0;
 522         else
 523                 als->als2_imp_sel = lm3532_get_als_imp_index(als_impedance);
 524
 525         ret = device_property_read_u32(&priv->client->dev, "ti,als-avrg-time-us",
 526                                       &als_avg_time);
 527         if (ret)
 528                 als->als_avrg_time = 0;
 529         else
 530                 als->als_avrg_time = lm3532_get_als_avg_index(als_avg_time);
 531
 532         ret = device_property_read_u8(&priv->client->dev, "ti,als-input-mode",
 533                                       &als->als_input_mode);
 534         if (ret)
 535                 als->als_input_mode = 0;
 536
 537         if (als->als_input_mode > LM3532_BL_MODE_ALS) {
 538                 ret = -EINVAL;
 539                 return ret;
 540         }
 541
 542         priv->als_data = als;
 543
 544         return ret;
 545 }
 546
 547 static int lm3532_parse_node(struct lm3532_data *priv)
 548 {
 549         struct fwnode_handle *child = NULL;
 550         struct lm3532_led *led;
 551         const char *name;
 552         int control_bank;
 553         u32 ramp_time;
 554         size_t i = 0;
 555         int ret;
 556
 557         priv->enable_gpio = devm_gpiod_get_optional(&priv->client->dev,
 558                                                    "enable", GPIOD_OUT_LOW);
 559         if (IS_ERR(priv->enable_gpio))
 560                 priv->enable_gpio = NULL;
 561
 562         priv->regulator = devm_regulator_get(&priv->client->dev, "vin");
 563         if (IS_ERR(priv->regulator))
 564                 priv->regulator = NULL;
 565
 566         ret = device_property_read_u32(&priv->client->dev, "ramp-up-us",
 567                                        &ramp_time);
 568         if (ret)
 569                 dev_info(&priv->client->dev, "ramp-up-ms property missing\n");
 570         else
 571                 priv->runtime_ramp_up = lm3532_get_ramp_index(ramp_time);
 572
 573         ret = device_property_read_u32(&priv->client->dev, "ramp-down-us",
 574                                        &ramp_time);
 575         if (ret)
 576                 dev_info(&priv->client->dev, "ramp-down-ms property missing\n");
 577         else
 578                 priv->runtime_ramp_down = lm3532_get_ramp_index(ramp_time);
 579
 580         device_for_each_child_node(priv->dev, child) {
 581                 struct led_init_data idata = {
 582                         .fwnode = child,
 583                         .default_label = ":",
 584                         .devicename = priv->client->name,
 585                 };
 586
 587                 led = &priv->leds[i];
 588
 589                 ret = fwnode_property_read_u32(child, "reg", &control_bank);
 590                 if (ret) {
 591                         dev_err(&priv->client->dev, "reg property missing\n");
 592                         fwnode_handle_put(child);
 593                         goto child_out;
 594                 }
 595
 596                 if (control_bank > LM3532_CONTROL_C) {
 597                         dev_err(&priv->client->dev, "Control bank invalid\n");
 598                         continue;
 599                 }
 600
 601                 led->control_bank = control_bank;
 602
 603                 ret = fwnode_property_read_u32(child, "ti,led-mode",
 604                                                &led->mode);
 605                 if (ret) {
 606                         dev_err(&priv->client->dev, "ti,led-mode property missing\n");
 607                         fwnode_handle_put(child);
 608                         goto child_out;
 609                 }
 610
 611                 if (fwnode_property_present(child, "led-max-microamp") &&
 612                     fwnode_property_read_u32(child, "led-max-microamp",
 613                                              &led->full_scale_current))
 614                         dev_err(&priv->client->dev,
 615                                 "Failed getting led-max-microamp\n");
 616                 else
 617                         led->full_scale_current = min(led->full_scale_current,
 618                                                       LM3532_FS_CURR_MAX);
 619
 620                 if (led->mode == LM3532_BL_MODE_ALS) {
 621                         led->mode = LM3532_ALS_CTRL;
 622                         ret = lm3532_parse_als(priv);
 623                         if (ret)
 624                                 dev_err(&priv->client->dev, "Failed to parse als\n");
 625                         else
 626                                 lm3532_als_configure(priv, led);
 627                 } else {
 628                         led->mode = LM3532_I2C_CTRL;
 629                 }
 630
 631                 led->num_leds = fwnode_property_count_u32(child, "led-sources");
 632                 if (led->num_leds > LM3532_MAX_LED_STRINGS) {
 633                         dev_err(&priv->client->dev, "Too many LED string defined\n");
 634                         continue;
 635                 }
 636
 637                 ret = fwnode_property_read_u32_array(child, "led-sources",
 638                                                     led->led_strings,
 639                                                     led->num_leds);
 640                 if (ret) {
 641                         dev_err(&priv->client->dev, "led-sources property missing\n");
 642                         fwnode_handle_put(child);
 643                         goto child_out;
 644                 }
 645
 646                 fwnode_property_read_string(child, "linux,default-trigger",
 647                                             &led->led_dev.default_trigger);
 648
 649                 ret = fwnode_property_read_string(child, "label", &name);
 650                 if (ret)
 651                         snprintf(led->label, sizeof(led->label),
 652                                 "%s::", priv->client->name);
 653                 else
 654                         snprintf(led->label, sizeof(led->label),
 655                                  "%s:%s", priv->client->name, name);
 656
 657                 led->priv = priv;
 658                 led->led_dev.name = led->label;
 659                 led->led_dev.brightness_set_blocking = lm3532_brightness_set;
 660
 661                 ret = devm_led_classdev_register_ext(priv->dev, &led->led_dev, &idata);
 662                 if (ret) {
 663                         dev_err(&priv->client->dev, "led register err: %d\n",
 664                                 ret);
 665                         fwnode_handle_put(child);
 666                         goto child_out;
 667                 }
 668
 669                 ret = lm3532_init_registers(led);
 670                 if (ret) {
 671                         dev_err(&priv->client->dev, "register init err: %d\n",
 672                                 ret);
 673                         fwnode_handle_put(child);
 674                         goto child_out;
 675                 }
 676
 677                 i++;
 678         }
 679
 680 child_out:
 681         return ret;
 682 }
 683
 684 static int lm3532_probe(struct i2c_client *client,
 685                            const struct i2c_device_id *id)
 686 {
 687         struct lm3532_data *drvdata;
 688         int ret = 0;
 689         int count;
 690
 691         count = device_get_child_node_count(&client->dev);
 692         if (!count) {
 693                 dev_err(&client->dev, "LEDs are not defined in device tree!");
 694                 return -ENODEV;
 695         }
 696
 697         drvdata = devm_kzalloc(&client->dev, struct_size(drvdata, leds, count),
 698                            GFP_KERNEL);
 699         if (drvdata == NULL)
 700                 return -ENOMEM;
 701
 702         drvdata->client = client;
 703         drvdata->dev = &client->dev;
 704
 705         drvdata->regmap = devm_regmap_init_i2c(client, &lm3532_regmap_config);
 706         if (IS_ERR(drvdata->regmap)) {
 707                 ret = PTR_ERR(drvdata->regmap);
 708                 dev_err(&client->dev, "Failed to allocate register map: %d\n",
 709                         ret);
 710                 return ret;
 711         }
 712
 713         mutex_init(&drvdata->lock);
 714         i2c_set_clientdata(client, drvdata);
 715
 716         ret = lm3532_parse_node(drvdata);
 717         if (ret) {
 718                 dev_err(&client->dev, "Failed to parse node\n");
 719                 return ret;
 720         }
 721
 722         return ret;
 723 }
 724
 725 static int lm3532_remove(struct i2c_client *client)
 726 {
 727         struct lm3532_data *drvdata = i2c_get_clientdata(client);
 728
 729         mutex_destroy(&drvdata->lock);
 730
 731         if (drvdata->enable_gpio)
 732                 gpiod_direction_output(drvdata->enable_gpio, 0);
 733
 734         return 0;
 735 }
 736
 737 static const struct of_device_id of_lm3532_leds_match[] = {
 738         { .compatible = "ti,lm3532", },
 739         {},
 740 };
 741 MODULE_DEVICE_TABLE(of, of_lm3532_leds_match);
 742
 743 static const struct i2c_device_id lm3532_id[] = {
 744         {LM3532_NAME, 0},
 745         {}
 746 };
 747 MODULE_DEVICE_TABLE(i2c, lm3532_id);
 748
 749 static struct i2c_driver lm3532_i2c_driver = {
 750         .probe = lm3532_probe,
 751         .remove = lm3532_remove,
 752         .id_table = lm3532_id,
 753         .driver = {
 754                 .name = LM3532_NAME,
 755                 .of_match_table = of_lm3532_leds_match,
 756         },
 757 };
 758 module_i2c_driver(lm3532_i2c_driver);
 759
 760 MODULE_DESCRIPTION("Back Light driver for LM3532");
 761 MODULE_LICENSE("GPL v2");
 762 MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");