drivers/leds/leds-is31fl32xx.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Driver for ISSI IS31FL32xx family of I2C LED controllers
   4  *
   5  * Copyright 2015 Allworx Corp.
   6  *
   7  * Datasheets:
   8  *   http://www.issi.com/US/product-analog-fxled-driver.shtml
   9  *   http://www.si-en.com/product.asp?parentid=890
  10  */
  11
  12 #include <linux/device.h>
  13 #include <linux/i2c.h>
  14 #include <linux/kernel.h>
  15 #include <linux/leds.h>
  16 #include <linux/module.h>
  17 #include <linux/of.h>
  18 #include <linux/of_device.h>
  19
  20 /* Used to indicate a device has no such register */
  21 #define IS31FL32XX_REG_NONE 0xFF
  22
  23 /* Software Shutdown bit in Shutdown Register */
  24 #define IS31FL32XX_SHUTDOWN_SSD_ENABLE  0
  25 #define IS31FL32XX_SHUTDOWN_SSD_DISABLE BIT(0)
  26
  27 /* IS31FL3216 has a number of unique registers */
  28 #define IS31FL3216_CONFIG_REG 0x00
  29 #define IS31FL3216_LIGHTING_EFFECT_REG 0x03
  30 #define IS31FL3216_CHANNEL_CONFIG_REG 0x04
  31
  32 /* Software Shutdown bit in 3216 Config Register */
  33 #define IS31FL3216_CONFIG_SSD_ENABLE  BIT(7)
  34 #define IS31FL3216_CONFIG_SSD_DISABLE 0
  35
  36 struct is31fl32xx_priv;
  37 struct is31fl32xx_led_data {
  38         struct led_classdev cdev;
  39         u8 channel; /* 1-based, max priv->cdef->channels */
  40         struct is31fl32xx_priv *priv;
  41 };
  42
  43 struct is31fl32xx_priv {
  44         const struct is31fl32xx_chipdef *cdef;
  45         struct i2c_client *client;
  46         unsigned int num_leds;
  47         struct is31fl32xx_led_data leds[0];
  48 };
  49
  50 /**
  51  * struct is31fl32xx_chipdef - chip-specific attributes
  52  * @channels            : Number of LED channels
  53  * @shutdown_reg        : address of Shutdown register (optional)
  54  * @pwm_update_reg      : address of PWM Update register
  55  * @global_control_reg  : address of Global Control register (optional)
  56  * @reset_reg           : address of Reset register (optional)
  57  * @pwm_register_base   : address of first PWM register
  58  * @pwm_registers_reversed: : true if PWM registers count down instead of up
  59  * @led_control_register_base : address of first LED control register (optional)
  60  * @enable_bits_per_led_control_register: number of LEDs enable bits in each
  61  * @reset_func:         : pointer to reset function
  62  *
  63  * For all optional register addresses, the sentinel value %IS31FL32XX_REG_NONE
  64  * indicates that this chip has no such register.
  65  *
  66  * If non-NULL, @reset_func will be called during probing to set all
  67  * necessary registers to a known initialization state. This is needed
  68  * for chips that do not have a @reset_reg.
  69  *
  70  * @enable_bits_per_led_control_register must be >=1 if
  71  * @led_control_register_base != %IS31FL32XX_REG_NONE.
  72  */
  73 struct is31fl32xx_chipdef {
  74         u8      channels;
  75         u8      shutdown_reg;
  76         u8      pwm_update_reg;
  77         u8      global_control_reg;
  78         u8      reset_reg;
  79         u8      pwm_register_base;
  80         bool    pwm_registers_reversed;
  81         u8      led_control_register_base;
  82         u8      enable_bits_per_led_control_register;
  83         int (*reset_func)(struct is31fl32xx_priv *priv);
  84         int (*sw_shutdown_func)(struct is31fl32xx_priv *priv, bool enable);
  85 };
  86
  87 static const struct is31fl32xx_chipdef is31fl3236_cdef = {
  88         .channels                               = 36,
  89         .shutdown_reg                           = 0x00,
  90         .pwm_update_reg                         = 0x25,
  91         .global_control_reg                     = 0x4a,
  92         .reset_reg                              = 0x4f,
  93         .pwm_register_base                      = 0x01,
  94         .led_control_register_base              = 0x26,
  95         .enable_bits_per_led_control_register   = 1,
  96 };
  97
  98 static const struct is31fl32xx_chipdef is31fl3235_cdef = {
  99         .channels                               = 28,
 100         .shutdown_reg                           = 0x00,
 101         .pwm_update_reg                         = 0x25,
 102         .global_control_reg                     = 0x4a,
 103         .reset_reg                              = 0x4f,
 104         .pwm_register_base                      = 0x05,
 105         .led_control_register_base              = 0x2a,
 106         .enable_bits_per_led_control_register   = 1,
 107 };
 108
 109 static const struct is31fl32xx_chipdef is31fl3218_cdef = {
 110         .channels                               = 18,
 111         .shutdown_reg                           = 0x00,
 112         .pwm_update_reg                         = 0x16,
 113         .global_control_reg                     = IS31FL32XX_REG_NONE,
 114         .reset_reg                              = 0x17,
 115         .pwm_register_base                      = 0x01,
 116         .led_control_register_base              = 0x13,
 117         .enable_bits_per_led_control_register   = 6,
 118 };
 119
 120 static int is31fl3216_reset(struct is31fl32xx_priv *priv);
 121 static int is31fl3216_software_shutdown(struct is31fl32xx_priv *priv,
 122                                         bool enable);
 123 static const struct is31fl32xx_chipdef is31fl3216_cdef = {
 124         .channels                               = 16,
 125         .shutdown_reg                           = IS31FL32XX_REG_NONE,
 126         .pwm_update_reg                         = 0xB0,
 127         .global_control_reg                     = IS31FL32XX_REG_NONE,
 128         .reset_reg                              = IS31FL32XX_REG_NONE,
 129         .pwm_register_base                      = 0x10,
 130         .pwm_registers_reversed                 = true,
 131         .led_control_register_base              = 0x01,
 132         .enable_bits_per_led_control_register   = 8,
 133         .reset_func                             = is31fl3216_reset,
 134         .sw_shutdown_func                       = is31fl3216_software_shutdown,
 135 };
 136
 137 static int is31fl32xx_write(struct is31fl32xx_priv *priv, u8 reg, u8 val)
 138 {
 139         int ret;
 140
 141         dev_dbg(&priv->client->dev, "writing register 0x%02X=0x%02X", reg, val);
 142
 143         ret =  i2c_smbus_write_byte_data(priv->client, reg, val);
 144         if (ret) {
 145                 dev_err(&priv->client->dev,
 146                         "register write to 0x%02X failed (error %d)",
 147                         reg, ret);
 148         }
 149         return ret;
 150 }
 151
 152 /*
 153  * Custom reset function for IS31FL3216 because it does not have a RESET
 154  * register the way that the other IS31FL32xx chips do. We don't bother
 155  * writing the GPIO and animation registers, because the registers we
 156  * do write ensure those will have no effect.
 157  */
 158 static int is31fl3216_reset(struct is31fl32xx_priv *priv)
 159 {
 160         unsigned int i;
 161         int ret;
 162
 163         ret = is31fl32xx_write(priv, IS31FL3216_CONFIG_REG,
 164                                IS31FL3216_CONFIG_SSD_ENABLE);
 165         if (ret)
 166                 return ret;
 167         for (i = 0; i < priv->cdef->channels; i++) {
 168                 ret = is31fl32xx_write(priv, priv->cdef->pwm_register_base+i,
 169                                        0x00);
 170                 if (ret)
 171                         return ret;
 172         }
 173         ret = is31fl32xx_write(priv, priv->cdef->pwm_update_reg, 0);
 174         if (ret)
 175                 return ret;
 176         ret = is31fl32xx_write(priv, IS31FL3216_LIGHTING_EFFECT_REG, 0x00);
 177         if (ret)
 178                 return ret;
 179         ret = is31fl32xx_write(priv, IS31FL3216_CHANNEL_CONFIG_REG, 0x00);
 180         if (ret)
 181                 return ret;
 182
 183         return 0;
 184 }
 185
 186 /*
 187  * Custom Software-Shutdown function for IS31FL3216 because it does not have
 188  * a SHUTDOWN register the way that the other IS31FL32xx chips do.
 189  * We don't bother doing a read/modify/write on the CONFIG register because
 190  * we only ever use a value of '0' for the other fields in that register.
 191  */
 192 static int is31fl3216_software_shutdown(struct is31fl32xx_priv *priv,
 193                                         bool enable)
 194 {
 195         u8 value = enable ? IS31FL3216_CONFIG_SSD_ENABLE :
 196                             IS31FL3216_CONFIG_SSD_DISABLE;
 197
 198         return is31fl32xx_write(priv, IS31FL3216_CONFIG_REG, value);
 199 }
 200
 201 /*
 202  * NOTE: A mutex is not needed in this function because:
 203  * - All referenced data is read-only after probe()
 204  * - The I2C core has a mutex on to protect the bus
 205  * - There are no read/modify/write operations
 206  * - Intervening operations between the write of the PWM register
 207  *   and the Update register are harmless.
 208  *
 209  * Example:
 210  *      PWM_REG_1 write 16
 211  *      UPDATE_REG write 0
 212  *      PWM_REG_2 write 128
 213  *      UPDATE_REG write 0
 214  *   vs:
 215  *      PWM_REG_1 write 16
 216  *      PWM_REG_2 write 128
 217  *      UPDATE_REG write 0
 218  *      UPDATE_REG write 0
 219  * are equivalent. Poking the Update register merely applies all PWM
 220  * register writes up to that point.
 221  */
 222 static int is31fl32xx_brightness_set(struct led_classdev *led_cdev,
 223                                      enum led_brightness brightness)
 224 {
 225         const struct is31fl32xx_led_data *led_data =
 226                 container_of(led_cdev, struct is31fl32xx_led_data, cdev);
 227         const struct is31fl32xx_chipdef *cdef = led_data->priv->cdef;
 228         u8 pwm_register_offset;
 229         int ret;
 230
 231         dev_dbg(led_cdev->dev, "%s: %d\n", __func__, brightness);
 232
 233         /* NOTE: led_data->channel is 1-based */
 234         if (cdef->pwm_registers_reversed)
 235                 pwm_register_offset = cdef->channels - led_data->channel;
 236         else
 237                 pwm_register_offset = led_data->channel - 1;
 238
 239         ret = is31fl32xx_write(led_data->priv,
 240                                cdef->pwm_register_base + pwm_register_offset,
 241                                brightness);
 242         if (ret)
 243                 return ret;
 244
 245         return is31fl32xx_write(led_data->priv, cdef->pwm_update_reg, 0);
 246 }
 247
 248 static int is31fl32xx_reset_regs(struct is31fl32xx_priv *priv)
 249 {
 250         const struct is31fl32xx_chipdef *cdef = priv->cdef;
 251         int ret;
 252
 253         if (cdef->reset_reg != IS31FL32XX_REG_NONE) {
 254                 ret = is31fl32xx_write(priv, cdef->reset_reg, 0);
 255                 if (ret)
 256                         return ret;
 257         }
 258
 259         if (cdef->reset_func)
 260                 return cdef->reset_func(priv);
 261
 262         return 0;
 263 }
 264
 265 static int is31fl32xx_software_shutdown(struct is31fl32xx_priv *priv,
 266                                         bool enable)
 267 {
 268         const struct is31fl32xx_chipdef *cdef = priv->cdef;
 269         int ret;
 270
 271         if (cdef->shutdown_reg != IS31FL32XX_REG_NONE) {
 272                 u8 value = enable ? IS31FL32XX_SHUTDOWN_SSD_ENABLE :
 273                                     IS31FL32XX_SHUTDOWN_SSD_DISABLE;
 274                 ret = is31fl32xx_write(priv, cdef->shutdown_reg, value);
 275                 if (ret)
 276                         return ret;
 277         }
 278
 279         if (cdef->sw_shutdown_func)
 280                 return cdef->sw_shutdown_func(priv, enable);
 281
 282         return 0;
 283 }
 284
 285 static int is31fl32xx_init_regs(struct is31fl32xx_priv *priv)
 286 {
 287         const struct is31fl32xx_chipdef *cdef = priv->cdef;
 288         int ret;
 289
 290         ret = is31fl32xx_reset_regs(priv);
 291         if (ret)
 292                 return ret;
 293
 294         /*
 295          * Set enable bit for all channels.
 296          * We will control state with PWM registers alone.
 297          */
 298         if (cdef->led_control_register_base != IS31FL32XX_REG_NONE) {
 299                 u8 value =
 300                     GENMASK(cdef->enable_bits_per_led_control_register-1, 0);
 301                 u8 num_regs = cdef->channels /
 302                                 cdef->enable_bits_per_led_control_register;
 303                 int i;
 304
 305                 for (i = 0; i < num_regs; i++) {
 306                         ret = is31fl32xx_write(priv,
 307                                                cdef->led_control_register_base+i,
 308                                                value);
 309                         if (ret)
 310                                 return ret;
 311                 }
 312         }
 313
 314         ret = is31fl32xx_software_shutdown(priv, false);
 315         if (ret)
 316                 return ret;
 317
 318         if (cdef->global_control_reg != IS31FL32XX_REG_NONE) {
 319                 ret = is31fl32xx_write(priv, cdef->global_control_reg, 0x00);
 320                 if (ret)
 321                         return ret;
 322         }
 323
 324         return 0;
 325 }
 326
 327 static inline size_t sizeof_is31fl32xx_priv(int num_leds)
 328 {
 329         return sizeof(struct is31fl32xx_priv) +
 330                       (sizeof(struct is31fl32xx_led_data) * num_leds);
 331 }
 332
 333 static int is31fl32xx_parse_child_dt(const struct device *dev,
 334                                      const struct device_node *child,
 335                                      struct is31fl32xx_led_data *led_data)
 336 {
 337         struct led_classdev *cdev = &led_data->cdev;
 338         int ret = 0;
 339         u32 reg;
 340
 341         if (of_property_read_string(child, "label", &cdev->name))
 342                 cdev->name = child->name;
 343
 344         ret = of_property_read_u32(child, "reg", &reg);
 345         if (ret || reg < 1 || reg > led_data->priv->cdef->channels) {
 346                 dev_err(dev,
 347                         "Child node %pOF does not have a valid reg property\n",
 348                         child);
 349                 return -EINVAL;
 350         }
 351         led_data->channel = reg;
 352
 353         of_property_read_string(child, "linux,default-trigger",
 354                                 &cdev->default_trigger);
 355
 356         cdev->brightness_set_blocking = is31fl32xx_brightness_set;
 357
 358         return 0;
 359 }
 360
 361 static struct is31fl32xx_led_data *is31fl32xx_find_led_data(
 362                                         struct is31fl32xx_priv *priv,
 363                                         u8 channel)
 364 {
 365         size_t i;
 366
 367         for (i = 0; i < priv->num_leds; i++) {
 368                 if (priv->leds[i].channel == channel)
 369                         return &priv->leds[i];
 370         }
 371
 372         return NULL;
 373 }
 374
 375 static int is31fl32xx_parse_dt(struct device *dev,
 376                                struct is31fl32xx_priv *priv)
 377 {
 378         struct device_node *child;
 379         int ret = 0;
 380
 381         for_each_child_of_node(dev->of_node, child) {
 382                 struct is31fl32xx_led_data *led_data =
 383                         &priv->leds[priv->num_leds];
 384                 const struct is31fl32xx_led_data *other_led_data;
 385
 386                 led_data->priv = priv;
 387
 388                 ret = is31fl32xx_parse_child_dt(dev, child, led_data);
 389                 if (ret)
 390                         goto err;
 391
 392                 /* Detect if channel is already in use by another child */
 393                 other_led_data = is31fl32xx_find_led_data(priv,
 394                                                           led_data->channel);
 395                 if (other_led_data) {
 396                         dev_err(dev,
 397                                 "%s and %s both attempting to use channel %d\n",
 398                                 led_data->cdev.name,
 399                                 other_led_data->cdev.name,
 400                                 led_data->channel);
 401                         goto err;
 402                 }
 403
 404                 ret = devm_led_classdev_register(dev, &led_data->cdev);
 405                 if (ret) {
 406                         dev_err(dev, "failed to register PWM led for %s: %d\n",
 407                                 led_data->cdev.name, ret);
 408                         goto err;
 409                 }
 410
 411                 priv->num_leds++;
 412         }
 413
 414         return 0;
 415
 416 err:
 417         of_node_put(child);
 418         return ret;
 419 }
 420
 421 static const struct of_device_id of_is31fl32xx_match[] = {
 422         { .compatible = "issi,is31fl3236", .data = &is31fl3236_cdef, },
 423         { .compatible = "issi,is31fl3235", .data = &is31fl3235_cdef, },
 424         { .compatible = "issi,is31fl3218", .data = &is31fl3218_cdef, },
 425         { .compatible = "si-en,sn3218",    .data = &is31fl3218_cdef, },
 426         { .compatible = "issi,is31fl3216", .data = &is31fl3216_cdef, },
 427         { .compatible = "si-en,sn3216",    .data = &is31fl3216_cdef, },
 428         {},
 429 };
 430
 431 MODULE_DEVICE_TABLE(of, of_is31fl32xx_match);
 432
 433 static int is31fl32xx_probe(struct i2c_client *client,
 434                             const struct i2c_device_id *id)
 435 {
 436         const struct is31fl32xx_chipdef *cdef;
 437         const struct of_device_id *of_dev_id;
 438         struct device *dev = &client->dev;
 439         struct is31fl32xx_priv *priv;
 440         int count;
 441         int ret = 0;
 442
 443         of_dev_id = of_match_device(of_is31fl32xx_match, dev);
 444         if (!of_dev_id)
 445                 return -EINVAL;
 446
 447         cdef = of_dev_id->data;
 448
 449         count = of_get_child_count(dev->of_node);
 450         if (!count)
 451                 return -EINVAL;
 452
 453         priv = devm_kzalloc(dev, sizeof_is31fl32xx_priv(count),
 454                             GFP_KERNEL);
 455         if (!priv)
 456                 return -ENOMEM;
 457
 458         priv->client = client;
 459         priv->cdef = cdef;
 460         i2c_set_clientdata(client, priv);
 461
 462         ret = is31fl32xx_init_regs(priv);
 463         if (ret)
 464                 return ret;
 465
 466         ret = is31fl32xx_parse_dt(dev, priv);
 467         if (ret)
 468                 return ret;
 469
 470         return 0;
 471 }
 472
 473 static int is31fl32xx_remove(struct i2c_client *client)
 474 {
 475         struct is31fl32xx_priv *priv = i2c_get_clientdata(client);
 476
 477         return is31fl32xx_reset_regs(priv);
 478 }
 479
 480 /*
 481  * i2c-core (and modalias) requires that id_table be properly filled,
 482  * even though it is not used for DeviceTree based instantiation.
 483  */
 484 static const struct i2c_device_id is31fl32xx_id[] = {
 485         { "is31fl3236" },
 486         { "is31fl3235" },
 487         { "is31fl3218" },
 488         { "sn3218" },
 489         { "is31fl3216" },
 490         { "sn3216" },
 491         {},
 492 };
 493
 494 MODULE_DEVICE_TABLE(i2c, is31fl32xx_id);
 495
 496 static struct i2c_driver is31fl32xx_driver = {
 497         .driver = {
 498                 .name   = "is31fl32xx",
 499                 .of_match_table = of_is31fl32xx_match,
 500         },
 501         .probe          = is31fl32xx_probe,
 502         .remove         = is31fl32xx_remove,
 503         .id_table       = is31fl32xx_id,
 504 };
 505
 506 module_i2c_driver(is31fl32xx_driver);
 507
 508 MODULE_AUTHOR("David Rivshin <drivshin@allworx.com>");
 509 MODULE_DESCRIPTION("ISSI IS31FL32xx LED driver");
 510 MODULE_LICENSE("GPL v2");