drivers/leds/leds-lm3692x.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // TI LM3692x LED chip family driver
   3 // Copyright (C) 2017-18 Texas Instruments Incorporated - http://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/module.h>
  10 #include <linux/mutex.h>
  11 #include <linux/of.h>
  12 #include <linux/of_gpio.h>
  13 #include <linux/regmap.h>
  14 #include <linux/regulator/consumer.h>
  15 #include <linux/slab.h>
  16 #include <uapi/linux/uleds.h>
  17
  18 #define LM36922_MODEL   0
  19 #define LM36923_MODEL   1
  20
  21 #define LM3692X_REV             0x0
  22 #define LM3692X_RESET           0x1
  23 #define LM3692X_EN              0x10
  24 #define LM3692X_BRT_CTRL        0x11
  25 #define LM3692X_PWM_CTRL        0x12
  26 #define LM3692X_BOOST_CTRL      0x13
  27 #define LM3692X_AUTO_FREQ_HI    0x15
  28 #define LM3692X_AUTO_FREQ_LO    0x16
  29 #define LM3692X_BL_ADJ_THRESH   0x17
  30 #define LM3692X_BRT_LSB         0x18
  31 #define LM3692X_BRT_MSB         0x19
  32 #define LM3692X_FAULT_CTRL      0x1e
  33 #define LM3692X_FAULT_FLAGS     0x1f
  34
  35 #define LM3692X_SW_RESET        BIT(0)
  36 #define LM3692X_DEVICE_EN       BIT(0)
  37 #define LM3692X_LED1_EN         BIT(1)
  38 #define LM3692X_LED2_EN         BIT(2)
  39 #define LM36923_LED3_EN         BIT(3)
  40 #define LM3692X_ENABLE_MASK     (LM3692X_DEVICE_EN | LM3692X_LED1_EN | \
  41                                  LM3692X_LED2_EN | LM36923_LED3_EN)
  42
  43 /* Brightness Control Bits */
  44 #define LM3692X_BL_ADJ_POL      BIT(0)
  45 #define LM3692X_RAMP_RATE_125us 0x00
  46 #define LM3692X_RAMP_RATE_250us BIT(1)
  47 #define LM3692X_RAMP_RATE_500us BIT(2)
  48 #define LM3692X_RAMP_RATE_1ms   (BIT(1) | BIT(2))
  49 #define LM3692X_RAMP_RATE_2ms   BIT(3)
  50 #define LM3692X_RAMP_RATE_4ms   (BIT(3) | BIT(1))
  51 #define LM3692X_RAMP_RATE_8ms   (BIT(2) | BIT(3))
  52 #define LM3692X_RAMP_RATE_16ms  (BIT(1) | BIT(2) | BIT(3))
  53 #define LM3692X_RAMP_EN         BIT(4)
  54 #define LM3692X_BRHT_MODE_REG   0x00
  55 #define LM3692X_BRHT_MODE_PWM   BIT(5)
  56 #define LM3692X_BRHT_MODE_MULTI_RAMP BIT(6)
  57 #define LM3692X_BRHT_MODE_RAMP_MULTI (BIT(5) | BIT(6))
  58 #define LM3692X_MAP_MODE_EXP    BIT(7)
  59
  60 /* PWM Register Bits */
  61 #define LM3692X_PWM_FILTER_100  BIT(0)
  62 #define LM3692X_PWM_FILTER_150  BIT(1)
  63 #define LM3692X_PWM_FILTER_200  (BIT(0) | BIT(1))
  64 #define LM3692X_PWM_HYSTER_1LSB BIT(2)
  65 #define LM3692X_PWM_HYSTER_2LSB BIT(3)
  66 #define LM3692X_PWM_HYSTER_3LSB (BIT(3) | BIT(2))
  67 #define LM3692X_PWM_HYSTER_4LSB BIT(4)
  68 #define LM3692X_PWM_HYSTER_5LSB (BIT(4) | BIT(2))
  69 #define LM3692X_PWM_HYSTER_6LSB (BIT(4) | BIT(3))
  70 #define LM3692X_PWM_POLARITY    BIT(5)
  71 #define LM3692X_PWM_SAMP_4MHZ   BIT(6)
  72 #define LM3692X_PWM_SAMP_24MHZ  BIT(7)
  73
  74 /* Boost Control Bits */
  75 #define LM3692X_OCP_PROT_1A     BIT(0)
  76 #define LM3692X_OCP_PROT_1_25A  BIT(1)
  77 #define LM3692X_OCP_PROT_1_5A   (BIT(0) | BIT(1))
  78 #define LM3692X_OVP_21V         BIT(2)
  79 #define LM3692X_OVP_25V         BIT(3)
  80 #define LM3692X_OVP_29V         (BIT(2) | BIT(3))
  81 #define LM3692X_MIN_IND_22UH    BIT(4)
  82 #define LM3692X_BOOST_SW_1MHZ   BIT(5)
  83 #define LM3692X_BOOST_SW_NO_SHIFT       BIT(6)
  84
  85 /* Fault Control Bits */
  86 #define LM3692X_FAULT_CTRL_OVP BIT(0)
  87 #define LM3692X_FAULT_CTRL_OCP BIT(1)
  88 #define LM3692X_FAULT_CTRL_TSD BIT(2)
  89 #define LM3692X_FAULT_CTRL_OPEN BIT(3)
  90
  91 /* Fault Flag Bits */
  92 #define LM3692X_FAULT_FLAG_OVP BIT(0)
  93 #define LM3692X_FAULT_FLAG_OCP BIT(1)
  94 #define LM3692X_FAULT_FLAG_TSD BIT(2)
  95 #define LM3692X_FAULT_FLAG_SHRT BIT(3)
  96 #define LM3692X_FAULT_FLAG_OPEN BIT(4)
  97
  98 /**
  99  * struct lm3692x_led -
 100  * @lock - Lock for reading/writing the device
 101  * @client - Pointer to the I2C client
 102  * @led_dev - LED class device pointer
 103  * @regmap - Devices register map
 104  * @enable_gpio - VDDIO/EN gpio to enable communication interface
 105  * @regulator - LED supply regulator pointer
 106  * @label - LED label
 107  * @led_enable - LED sync to be enabled
 108  * @model_id - Current device model ID enumerated
 109  */
 110 struct lm3692x_led {
 111         struct mutex lock;
 112         struct i2c_client *client;
 113         struct led_classdev led_dev;
 114         struct regmap *regmap;
 115         struct gpio_desc *enable_gpio;
 116         struct regulator *regulator;
 117         char label[LED_MAX_NAME_SIZE];
 118         int led_enable;
 119         int model_id;
 120 };
 121
 122 static const struct reg_default lm3692x_reg_defs[] = {
 123         {LM3692X_EN, 0xf},
 124         {LM3692X_BRT_CTRL, 0x61},
 125         {LM3692X_PWM_CTRL, 0x73},
 126         {LM3692X_BOOST_CTRL, 0x6f},
 127         {LM3692X_AUTO_FREQ_HI, 0x0},
 128         {LM3692X_AUTO_FREQ_LO, 0x0},
 129         {LM3692X_BL_ADJ_THRESH, 0x0},
 130         {LM3692X_BRT_LSB, 0x7},
 131         {LM3692X_BRT_MSB, 0xff},
 132         {LM3692X_FAULT_CTRL, 0x7},
 133 };
 134
 135 static const struct regmap_config lm3692x_regmap_config = {
 136         .reg_bits = 8,
 137         .val_bits = 8,
 138
 139         .max_register = LM3692X_FAULT_FLAGS,
 140         .reg_defaults = lm3692x_reg_defs,
 141         .num_reg_defaults = ARRAY_SIZE(lm3692x_reg_defs),
 142         .cache_type = REGCACHE_RBTREE,
 143 };
 144
 145 static int lm3692x_fault_check(struct lm3692x_led *led)
 146 {
 147         int ret;
 148         unsigned int read_buf;
 149
 150         ret = regmap_read(led->regmap, LM3692X_FAULT_FLAGS, &read_buf);
 151         if (ret)
 152                 return ret;
 153
 154         if (read_buf)
 155                 dev_err(&led->client->dev, "Detected a fault 0x%X\n", read_buf);
 156
 157         /* The first read may clear the fault.  Check again to see if the fault
 158          * still exits and return that value.
 159          */
 160         regmap_read(led->regmap, LM3692X_FAULT_FLAGS, &read_buf);
 161         if (read_buf)
 162                 dev_err(&led->client->dev, "Second read of fault flags 0x%X\n",
 163                         read_buf);
 164
 165         return read_buf;
 166 }
 167
 168 static int lm3692x_brightness_set(struct led_classdev *led_cdev,
 169                                 enum led_brightness brt_val)
 170 {
 171         struct lm3692x_led *led =
 172                         container_of(led_cdev, struct lm3692x_led, led_dev);
 173         int ret;
 174         int led_brightness_lsb = (brt_val >> 5);
 175
 176         mutex_lock(&led->lock);
 177
 178         ret = lm3692x_fault_check(led);
 179         if (ret) {
 180                 dev_err(&led->client->dev, "Cannot read/clear faults\n");
 181                 goto out;
 182         }
 183
 184         ret = regmap_write(led->regmap, LM3692X_BRT_MSB, brt_val);
 185         if (ret) {
 186                 dev_err(&led->client->dev, "Cannot write MSB\n");
 187                 goto out;
 188         }
 189
 190         ret = regmap_write(led->regmap, LM3692X_BRT_LSB, led_brightness_lsb);
 191         if (ret) {
 192                 dev_err(&led->client->dev, "Cannot write LSB\n");
 193                 goto out;
 194         }
 195 out:
 196         mutex_unlock(&led->lock);
 197         return ret;
 198 }
 199
 200 static int lm3692x_init(struct lm3692x_led *led)
 201 {
 202         int enable_state;
 203         int ret;
 204
 205         if (led->regulator) {
 206                 ret = regulator_enable(led->regulator);
 207                 if (ret) {
 208                         dev_err(&led->client->dev,
 209                                 "Failed to enable regulator\n");
 210                         return ret;
 211                 }
 212         }
 213
 214         if (led->enable_gpio)
 215                 gpiod_direction_output(led->enable_gpio, 1);
 216
 217         ret = lm3692x_fault_check(led);
 218         if (ret) {
 219                 dev_err(&led->client->dev, "Cannot read/clear faults\n");
 220                 goto out;
 221         }
 222
 223         ret = regmap_write(led->regmap, LM3692X_BRT_CTRL, 0x00);
 224         if (ret)
 225                 goto out;
 226
 227         /*
 228          * For glitch free operation, the following data should
 229          * only be written while LEDx enable bits are 0 and the device enable
 230          * bit is set to 1.
 231          * per Section 7.5.14 of the data sheet
 232          */
 233         ret = regmap_write(led->regmap, LM3692X_EN, LM3692X_DEVICE_EN);
 234         if (ret)
 235                 goto out;
 236
 237         /* Set the brightness to 0 so when enabled the LEDs do not come
 238          * on with full brightness.
 239          */
 240         ret = regmap_write(led->regmap, LM3692X_BRT_MSB, 0);
 241         if (ret)
 242                 goto out;
 243
 244         ret = regmap_write(led->regmap, LM3692X_BRT_LSB, 0);
 245         if (ret)
 246                 goto out;
 247
 248         ret = regmap_write(led->regmap, LM3692X_PWM_CTRL,
 249                 LM3692X_PWM_FILTER_100 | LM3692X_PWM_SAMP_24MHZ);
 250         if (ret)
 251                 goto out;
 252
 253         ret = regmap_write(led->regmap, LM3692X_BOOST_CTRL,
 254                         LM3692X_BRHT_MODE_RAMP_MULTI |
 255                         LM3692X_BL_ADJ_POL |
 256                         LM3692X_RAMP_RATE_250us);
 257         if (ret)
 258                 goto out;
 259
 260         ret = regmap_write(led->regmap, LM3692X_AUTO_FREQ_HI, 0x00);
 261         if (ret)
 262                 goto out;
 263
 264         ret = regmap_write(led->regmap, LM3692X_AUTO_FREQ_LO, 0x00);
 265         if (ret)
 266                 goto out;
 267
 268         ret = regmap_write(led->regmap, LM3692X_BL_ADJ_THRESH, 0x00);
 269         if (ret)
 270                 goto out;
 271
 272         ret = regmap_write(led->regmap, LM3692X_BRT_CTRL,
 273                         LM3692X_BL_ADJ_POL | LM3692X_PWM_HYSTER_4LSB);
 274         if (ret)
 275                 goto out;
 276
 277         switch (led->led_enable) {
 278         case 0:
 279         default:
 280                 if (led->model_id == LM36923_MODEL)
 281                         enable_state = LM3692X_LED1_EN | LM3692X_LED2_EN |
 282                                LM36923_LED3_EN;
 283                 else
 284                         enable_state = LM3692X_LED1_EN | LM3692X_LED2_EN;
 285
 286                 break;
 287         case 1:
 288                 enable_state = LM3692X_LED1_EN;
 289                 break;
 290         case 2:
 291                 enable_state = LM3692X_LED2_EN;
 292                 break;
 293
 294         case 3:
 295                 if (led->model_id == LM36923_MODEL) {
 296                         enable_state = LM36923_LED3_EN;
 297                         break;
 298                 }
 299
 300                 ret = -EINVAL;
 301                 dev_err(&led->client->dev,
 302                         "LED3 sync not available on this device\n");
 303                 goto out;
 304         }
 305
 306         ret = regmap_update_bits(led->regmap, LM3692X_EN, LM3692X_ENABLE_MASK,
 307                                  enable_state | LM3692X_DEVICE_EN);
 308
 309         return ret;
 310 out:
 311         dev_err(&led->client->dev, "Fail writing initialization values\n");
 312
 313         if (led->enable_gpio)
 314                 gpiod_direction_output(led->enable_gpio, 0);
 315
 316         if (led->regulator) {
 317                 ret = regulator_disable(led->regulator);
 318                 if (ret)
 319                         dev_err(&led->client->dev,
 320                                 "Failed to disable regulator\n");
 321         }
 322
 323         return ret;
 324 }
 325 static int lm3692x_probe_dt(struct lm3692x_led *led)
 326 {
 327         struct fwnode_handle *child = NULL;
 328         const char *name;
 329         int ret;
 330
 331         led->enable_gpio = devm_gpiod_get_optional(&led->client->dev,
 332                                                    "enable", GPIOD_OUT_LOW);
 333         if (IS_ERR(led->enable_gpio)) {
 334                 ret = PTR_ERR(led->enable_gpio);
 335                 dev_err(&led->client->dev, "Failed to get enable gpio: %d\n",
 336                         ret);
 337                 return ret;
 338         }
 339
 340         led->regulator = devm_regulator_get_optional(&led->client->dev, "vled");
 341         if (IS_ERR(led->regulator)) {
 342                 ret = PTR_ERR(led->regulator);
 343                 if (ret != -ENODEV) {
 344                         if (ret != -EPROBE_DEFER)
 345                                 dev_err(&led->client->dev,
 346                                         "Failed to get vled regulator: %d\n",
 347                                         ret);
 348                         return ret;
 349                 }
 350                 led->regulator = NULL;
 351         }
 352
 353         child = device_get_next_child_node(&led->client->dev, child);
 354         if (!child) {
 355                 dev_err(&led->client->dev, "No LED Child node\n");
 356                 return -ENODEV;
 357         }
 358
 359         fwnode_property_read_string(child, "linux,default-trigger",
 360                                     &led->led_dev.default_trigger);
 361
 362         ret = fwnode_property_read_string(child, "label", &name);
 363         if (ret)
 364                 snprintf(led->label, sizeof(led->label),
 365                         "%s::", led->client->name);
 366         else
 367                 snprintf(led->label, sizeof(led->label),
 368                          "%s:%s", led->client->name, name);
 369
 370         ret = fwnode_property_read_u32(child, "reg", &led->led_enable);
 371         if (ret) {
 372                 dev_err(&led->client->dev, "reg DT property missing\n");
 373                 return ret;
 374         }
 375
 376         led->led_dev.name = led->label;
 377
 378         ret = devm_led_classdev_register(&led->client->dev, &led->led_dev);
 379         if (ret) {
 380                 dev_err(&led->client->dev, "led register err: %d\n", ret);
 381                 return ret;
 382         }
 383
 384         led->led_dev.dev->of_node = to_of_node(child);
 385
 386         return 0;
 387 }
 388
 389 static int lm3692x_probe(struct i2c_client *client,
 390                         const struct i2c_device_id *id)
 391 {
 392         struct lm3692x_led *led;
 393         int ret;
 394
 395         led = devm_kzalloc(&client->dev, sizeof(*led), GFP_KERNEL);
 396         if (!led)
 397                 return -ENOMEM;
 398
 399         mutex_init(&led->lock);
 400         led->client = client;
 401         led->led_dev.brightness_set_blocking = lm3692x_brightness_set;
 402         led->model_id = id->driver_data;
 403         i2c_set_clientdata(client, led);
 404
 405         led->regmap = devm_regmap_init_i2c(client, &lm3692x_regmap_config);
 406         if (IS_ERR(led->regmap)) {
 407                 ret = PTR_ERR(led->regmap);
 408                 dev_err(&client->dev, "Failed to allocate register map: %d\n",
 409                         ret);
 410                 return ret;
 411         }
 412
 413         ret = lm3692x_probe_dt(led);
 414         if (ret)
 415                 return ret;
 416
 417         ret = lm3692x_init(led);
 418         if (ret)
 419                 return ret;
 420
 421         return 0;
 422 }
 423
 424 static int lm3692x_remove(struct i2c_client *client)
 425 {
 426         struct lm3692x_led *led = i2c_get_clientdata(client);
 427         int ret;
 428
 429         ret = regmap_update_bits(led->regmap, LM3692X_EN, LM3692X_DEVICE_EN, 0);
 430         if (ret) {
 431                 dev_err(&led->client->dev, "Failed to disable regulator\n");
 432                 return ret;
 433         }
 434
 435         if (led->enable_gpio)
 436                 gpiod_direction_output(led->enable_gpio, 0);
 437
 438         if (led->regulator) {
 439                 ret = regulator_disable(led->regulator);
 440                 if (ret)
 441                         dev_err(&led->client->dev,
 442                                 "Failed to disable regulator\n");
 443         }
 444
 445         mutex_destroy(&led->lock);
 446
 447         return 0;
 448 }
 449
 450 static const struct i2c_device_id lm3692x_id[] = {
 451         { "lm36922", LM36922_MODEL },
 452         { "lm36923", LM36923_MODEL },
 453         { }
 454 };
 455 MODULE_DEVICE_TABLE(i2c, lm3692x_id);
 456
 457 static const struct of_device_id of_lm3692x_leds_match[] = {
 458         { .compatible = "ti,lm36922", },
 459         { .compatible = "ti,lm36923", },
 460         {},
 461 };
 462 MODULE_DEVICE_TABLE(of, of_lm3692x_leds_match);
 463
 464 static struct i2c_driver lm3692x_driver = {
 465         .driver = {
 466                 .name   = "lm3692x",
 467                 .of_match_table = of_lm3692x_leds_match,
 468         },
 469         .probe          = lm3692x_probe,
 470         .remove         = lm3692x_remove,
 471         .id_table       = lm3692x_id,
 472 };
 473 module_i2c_driver(lm3692x_driver);
 474
 475 MODULE_DESCRIPTION("Texas Instruments LM3692X LED driver");
 476 MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");
 477 MODULE_LICENSE("GPL v2");