drivers/leds/leds-is31fl319x.c

   1 /*
   2  * Copyright 2015-16 Golden Delicious Computers
   3  *
   4  * Author: Nikolaus Schaller <hns@goldelico.com>
   5  *
   6  * This file is subject to the terms and conditions of version 2 of
   7  * the GNU General Public License.  See the file COPYING in the main
   8  * directory of this archive for more details.
   9  *
  10  * LED driver for the IS31FL319{0,1,3,6,9} to drive 1, 3, 6 or 9 light
  11  * effect LEDs.
  12  *
  13  */
  14
  15 #include <linux/err.h>
  16 #include <linux/i2c.h>
  17 #include <linux/leds.h>
  18 #include <linux/module.h>
  19 #include <linux/of.h>
  20 #include <linux/of_device.h>
  21 #include <linux/regmap.h>
  22 #include <linux/slab.h>
  23
  24 /* register numbers */
  25 #define IS31FL319X_SHUTDOWN             0x00
  26 #define IS31FL319X_CTRL1                0x01
  27 #define IS31FL319X_CTRL2                0x02
  28 #define IS31FL319X_CONFIG1              0x03
  29 #define IS31FL319X_CONFIG2              0x04
  30 #define IS31FL319X_RAMP_MODE            0x05
  31 #define IS31FL319X_BREATH_MASK          0x06
  32 #define IS31FL319X_PWM(channel)         (0x07 + channel)
  33 #define IS31FL319X_DATA_UPDATE          0x10
  34 #define IS31FL319X_T0(channel)          (0x11 + channel)
  35 #define IS31FL319X_T123_1               0x1a
  36 #define IS31FL319X_T123_2               0x1b
  37 #define IS31FL319X_T123_3               0x1c
  38 #define IS31FL319X_T4(channel)          (0x1d + channel)
  39 #define IS31FL319X_TIME_UPDATE          0x26
  40 #define IS31FL319X_RESET                0xff
  41
  42 #define IS31FL319X_REG_CNT              (IS31FL319X_RESET + 1)
  43
  44 #define IS31FL319X_MAX_LEDS             9
  45
  46 /* CS (Current Setting) in CONFIG2 register */
  47 #define IS31FL319X_CONFIG2_CS_SHIFT     4
  48 #define IS31FL319X_CONFIG2_CS_MASK      0x7
  49 #define IS31FL319X_CONFIG2_CS_STEP_REF  12
  50
  51 #define IS31FL319X_CURRENT_MIN          ((u32)5000)
  52 #define IS31FL319X_CURRENT_MAX          ((u32)40000)
  53 #define IS31FL319X_CURRENT_STEP         ((u32)5000)
  54 #define IS31FL319X_CURRENT_DEFAULT      ((u32)20000)
  55
  56 /* Audio gain in CONFIG2 register */
  57 #define IS31FL319X_AUDIO_GAIN_DB_MAX    ((u32)21)
  58 #define IS31FL319X_AUDIO_GAIN_DB_STEP   ((u32)3)
  59
  60 /*
  61  * regmap is used as a cache of chip's register space,
  62  * to avoid reading back brightness values from chip,
  63  * which is known to hang.
  64  */
  65 struct is31fl319x_chip {
  66         const struct is31fl319x_chipdef *cdef;
  67         struct i2c_client               *client;
  68         struct regmap                   *regmap;
  69         struct mutex                    lock;
  70         u32                             audio_gain_db;
  71
  72         struct is31fl319x_led {
  73                 struct is31fl319x_chip  *chip;
  74                 struct led_classdev     cdev;
  75                 u32                     max_microamp;
  76                 bool                    configured;
  77         } leds[IS31FL319X_MAX_LEDS];
  78 };
  79
  80 struct is31fl319x_chipdef {
  81         int num_leds;
  82 };
  83
  84 static const struct is31fl319x_chipdef is31fl3190_cdef = {
  85         .num_leds = 1,
  86 };
  87
  88 static const struct is31fl319x_chipdef is31fl3193_cdef = {
  89         .num_leds = 3,
  90 };
  91
  92 static const struct is31fl319x_chipdef is31fl3196_cdef = {
  93         .num_leds = 6,
  94 };
  95
  96 static const struct is31fl319x_chipdef is31fl3199_cdef = {
  97         .num_leds = 9,
  98 };
  99
 100 static const struct of_device_id of_is31fl319x_match[] = {
 101         { .compatible = "issi,is31fl3190", .data = &is31fl3190_cdef, },
 102         { .compatible = "issi,is31fl3191", .data = &is31fl3190_cdef, },
 103         { .compatible = "issi,is31fl3193", .data = &is31fl3193_cdef, },
 104         { .compatible = "issi,is31fl3196", .data = &is31fl3196_cdef, },
 105         { .compatible = "issi,is31fl3199", .data = &is31fl3199_cdef, },
 106         { .compatible = "si-en,sn3199",    .data = &is31fl3199_cdef, },
 107         { }
 108 };
 109 MODULE_DEVICE_TABLE(of, of_is31fl319x_match);
 110
 111 static int is31fl319x_brightness_set(struct led_classdev *cdev,
 112                                      enum led_brightness brightness)
 113 {
 114         struct is31fl319x_led *led = container_of(cdev, struct is31fl319x_led,
 115                                                   cdev);
 116         struct is31fl319x_chip *is31 = led->chip;
 117         int chan = led - is31->leds;
 118         int ret;
 119         int i;
 120         u8 ctrl1 = 0, ctrl2 = 0;
 121
 122         dev_dbg(&is31->client->dev, "%s %d: %d\n", __func__, chan, brightness);
 123
 124         mutex_lock(&is31->lock);
 125
 126         /* update PWM register */
 127         ret = regmap_write(is31->regmap, IS31FL319X_PWM(chan), brightness);
 128         if (ret < 0)
 129                 goto out;
 130
 131         /* read current brightness of all PWM channels */
 132         for (i = 0; i < is31->cdef->num_leds; i++) {
 133                 unsigned int pwm_value;
 134                 bool on;
 135
 136                 /*
 137                  * since neither cdev nor the chip can provide
 138                  * the current setting, we read from the regmap cache
 139                  */
 140
 141                 ret = regmap_read(is31->regmap, IS31FL319X_PWM(i), &pwm_value);
 142                 dev_dbg(&is31->client->dev, "%s read %d: ret=%d: %d\n",
 143                         __func__, i, ret, pwm_value);
 144                 on = ret >= 0 && pwm_value > LED_OFF;
 145
 146                 if (i < 3)
 147                         ctrl1 |= on << i;       /* 0..2 => bit 0..2 */
 148                 else if (i < 6)
 149                         ctrl1 |= on << (i + 1); /* 3..5 => bit 4..6 */
 150                 else
 151                         ctrl2 |= on << (i - 6); /* 6..8 => bit 0..2 */
 152         }
 153
 154         if (ctrl1 > 0 || ctrl2 > 0) {
 155                 dev_dbg(&is31->client->dev, "power up %02x %02x\n",
 156                         ctrl1, ctrl2);
 157                 regmap_write(is31->regmap, IS31FL319X_CTRL1, ctrl1);
 158                 regmap_write(is31->regmap, IS31FL319X_CTRL2, ctrl2);
 159                 /* update PWMs */
 160                 regmap_write(is31->regmap, IS31FL319X_DATA_UPDATE, 0x00);
 161                 /* enable chip from shut down */
 162                 ret = regmap_write(is31->regmap, IS31FL319X_SHUTDOWN, 0x01);
 163         } else {
 164                 dev_dbg(&is31->client->dev, "power down\n");
 165                 /* shut down (no need to clear CTRL1/2) */
 166                 ret = regmap_write(is31->regmap, IS31FL319X_SHUTDOWN, 0x00);
 167         }
 168
 169 out:
 170         mutex_unlock(&is31->lock);
 171
 172         return ret;
 173 }
 174
 175 static int is31fl319x_parse_child_dt(const struct device *dev,
 176                                      const struct device_node *child,
 177                                      struct is31fl319x_led *led)
 178 {
 179         struct led_classdev *cdev = &led->cdev;
 180         int ret;
 181
 182         if (of_property_read_string(child, "label", &cdev->name))
 183                 cdev->name = child->name;
 184
 185         ret = of_property_read_string(child, "linux,default-trigger",
 186                                       &cdev->default_trigger);
 187         if (ret < 0 && ret != -EINVAL) /* is optional */
 188                 return ret;
 189
 190         led->max_microamp = IS31FL319X_CURRENT_DEFAULT;
 191         ret = of_property_read_u32(child, "led-max-microamp",
 192                                    &led->max_microamp);
 193         if (!ret) {
 194                 if (led->max_microamp < IS31FL319X_CURRENT_MIN)
 195                         return -EINVAL; /* not supported */
 196                 led->max_microamp = min(led->max_microamp,
 197                                           IS31FL319X_CURRENT_MAX);
 198         }
 199
 200         return 0;
 201 }
 202
 203 static int is31fl319x_parse_dt(struct device *dev,
 204                                struct is31fl319x_chip *is31)
 205 {
 206         struct device_node *np = dev->of_node, *child;
 207         const struct of_device_id *of_dev_id;
 208         int count;
 209         int ret;
 210
 211         if (!np)
 212                 return -ENODEV;
 213
 214         of_dev_id = of_match_device(of_is31fl319x_match, dev);
 215         if (!of_dev_id) {
 216                 dev_err(dev, "Failed to match device with supported chips\n");
 217                 return -EINVAL;
 218         }
 219
 220         is31->cdef = of_dev_id->data;
 221
 222         count = of_get_child_count(np);
 223
 224         dev_dbg(dev, "probe %s with %d leds defined in DT\n",
 225                 of_dev_id->compatible, count);
 226
 227         if (!count || count > is31->cdef->num_leds) {
 228                 dev_err(dev, "Number of leds defined must be between 1 and %u\n",
 229                         is31->cdef->num_leds);
 230                 return -ENODEV;
 231         }
 232
 233         for_each_child_of_node(np, child) {
 234                 struct is31fl319x_led *led;
 235                 u32 reg;
 236
 237                 ret = of_property_read_u32(child, "reg", &reg);
 238                 if (ret) {
 239                         dev_err(dev, "Failed to read led 'reg' property\n");
 240                         goto put_child_node;
 241                 }
 242
 243                 if (reg < 1 || reg > is31->cdef->num_leds) {
 244                         dev_err(dev, "invalid led reg %u\n", reg);
 245                         ret = -EINVAL;
 246                         goto put_child_node;
 247                 }
 248
 249                 led = &is31->leds[reg - 1];
 250
 251                 if (led->configured) {
 252                         dev_err(dev, "led %u is already configured\n", reg);
 253                         ret = -EINVAL;
 254                         goto put_child_node;
 255                 }
 256
 257                 ret = is31fl319x_parse_child_dt(dev, child, led);
 258                 if (ret) {
 259                         dev_err(dev, "led %u DT parsing failed\n", reg);
 260                         goto put_child_node;
 261                 }
 262
 263                 led->configured = true;
 264         }
 265
 266         is31->audio_gain_db = 0;
 267         ret = of_property_read_u32(np, "audio-gain-db", &is31->audio_gain_db);
 268         if (!ret)
 269                 is31->audio_gain_db = min(is31->audio_gain_db,
 270                                           IS31FL319X_AUDIO_GAIN_DB_MAX);
 271
 272         return 0;
 273
 274 put_child_node:
 275         of_node_put(child);
 276         return ret;
 277 }
 278
 279 static bool is31fl319x_readable_reg(struct device *dev, unsigned int reg)
 280 { /* we have no readable registers */
 281         return false;
 282 }
 283
 284 static bool is31fl319x_volatile_reg(struct device *dev, unsigned int reg)
 285 { /* volatile registers are not cached */
 286         switch (reg) {
 287         case IS31FL319X_DATA_UPDATE:
 288         case IS31FL319X_TIME_UPDATE:
 289         case IS31FL319X_RESET:
 290                 return true; /* always write-through */
 291         default:
 292                 return false;
 293         }
 294 }
 295
 296 static const struct reg_default is31fl319x_reg_defaults[] = {
 297         { IS31FL319X_CONFIG1, 0x00},
 298         { IS31FL319X_CONFIG2, 0x00},
 299         { IS31FL319X_PWM(0), 0x00},
 300         { IS31FL319X_PWM(1), 0x00},
 301         { IS31FL319X_PWM(2), 0x00},
 302         { IS31FL319X_PWM(3), 0x00},
 303         { IS31FL319X_PWM(4), 0x00},
 304         { IS31FL319X_PWM(5), 0x00},
 305         { IS31FL319X_PWM(6), 0x00},
 306         { IS31FL319X_PWM(7), 0x00},
 307         { IS31FL319X_PWM(8), 0x00},
 308 };
 309
 310 static struct regmap_config regmap_config = {
 311         .reg_bits = 8,
 312         .val_bits = 8,
 313         .max_register = IS31FL319X_REG_CNT,
 314         .cache_type = REGCACHE_FLAT,
 315         .readable_reg = is31fl319x_readable_reg,
 316         .volatile_reg = is31fl319x_volatile_reg,
 317         .reg_defaults = is31fl319x_reg_defaults,
 318         .num_reg_defaults = ARRAY_SIZE(is31fl319x_reg_defaults),
 319 };
 320
 321 static inline int is31fl319x_microamp_to_cs(struct device *dev, u32 microamp)
 322 { /* round down to nearest supported value (range check done by caller) */
 323         u32 step = microamp / IS31FL319X_CURRENT_STEP;
 324
 325         return ((IS31FL319X_CONFIG2_CS_STEP_REF - step) &
 326                 IS31FL319X_CONFIG2_CS_MASK) <<
 327                 IS31FL319X_CONFIG2_CS_SHIFT; /* CS encoding */
 328 }
 329
 330 static inline int is31fl319x_db_to_gain(u32 dezibel)
 331 { /* round down to nearest supported value (range check done by caller) */
 332         return dezibel / IS31FL319X_AUDIO_GAIN_DB_STEP;
 333 }
 334
 335 static int is31fl319x_probe(struct i2c_client *client,
 336                             const struct i2c_device_id *id)
 337 {
 338         struct is31fl319x_chip *is31;
 339         struct device *dev = &client->dev;
 340         struct i2c_adapter *adapter = to_i2c_adapter(dev->parent);
 341         int err;
 342         int i = 0;
 343         u32 aggregated_led_microamp = IS31FL319X_CURRENT_MAX;
 344
 345         if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))
 346                 return -EIO;
 347
 348         is31 = devm_kzalloc(&client->dev, sizeof(*is31), GFP_KERNEL);
 349         if (!is31)
 350                 return -ENOMEM;
 351
 352         mutex_init(&is31->lock);
 353
 354         err = is31fl319x_parse_dt(&client->dev, is31);
 355         if (err)
 356                 goto free_mutex;
 357
 358         is31->client = client;
 359         is31->regmap = devm_regmap_init_i2c(client, &regmap_config);
 360         if (IS_ERR(is31->regmap)) {
 361                 dev_err(&client->dev, "failed to allocate register map\n");
 362                 err = PTR_ERR(is31->regmap);
 363                 goto free_mutex;
 364         }
 365
 366         i2c_set_clientdata(client, is31);
 367
 368         /* check for write-reply from chip (we can't read any registers) */
 369         err = regmap_write(is31->regmap, IS31FL319X_RESET, 0x00);
 370         if (err < 0) {
 371                 dev_err(&client->dev, "no response from chip write: err = %d\n",
 372                         err);
 373                 err = -EIO; /* does not answer */
 374                 goto free_mutex;
 375         }
 376
 377         /*
 378          * Kernel conventions require per-LED led-max-microamp property.
 379          * But the chip does not allow to limit individual LEDs.
 380          * So we take minimum from all subnodes for safety of hardware.
 381          */
 382         for (i = 0; i < is31->cdef->num_leds; i++)
 383                 if (is31->leds[i].configured &&
 384                     is31->leds[i].max_microamp < aggregated_led_microamp)
 385                         aggregated_led_microamp = is31->leds[i].max_microamp;
 386
 387         regmap_write(is31->regmap, IS31FL319X_CONFIG2,
 388                      is31fl319x_microamp_to_cs(dev, aggregated_led_microamp) |
 389                      is31fl319x_db_to_gain(is31->audio_gain_db));
 390
 391         for (i = 0; i < is31->cdef->num_leds; i++) {
 392                 struct is31fl319x_led *led = &is31->leds[i];
 393
 394                 if (!led->configured)
 395                         continue;
 396
 397                 led->chip = is31;
 398                 led->cdev.brightness_set_blocking = is31fl319x_brightness_set;
 399
 400                 err = devm_led_classdev_register(&client->dev, &led->cdev);
 401                 if (err < 0)
 402                         goto free_mutex;
 403         }
 404
 405         return 0;
 406
 407 free_mutex:
 408         mutex_destroy(&is31->lock);
 409         return err;
 410 }
 411
 412 static int is31fl319x_remove(struct i2c_client *client)
 413 {
 414         struct is31fl319x_chip *is31 = i2c_get_clientdata(client);
 415
 416         mutex_destroy(&is31->lock);
 417         return 0;
 418 }
 419
 420 /*
 421  * i2c-core (and modalias) requires that id_table be properly filled,
 422  * even though it is not used for DeviceTree based instantiation.
 423  */
 424 static const struct i2c_device_id is31fl319x_id[] = {
 425         { "is31fl3190" },
 426         { "is31fl3191" },
 427         { "is31fl3193" },
 428         { "is31fl3196" },
 429         { "is31fl3199" },
 430         { "sn3199" },
 431         {},
 432 };
 433 MODULE_DEVICE_TABLE(i2c, is31fl319x_id);
 434
 435 static struct i2c_driver is31fl319x_driver = {
 436         .driver   = {
 437                 .name           = "leds-is31fl319x",
 438                 .of_match_table = of_match_ptr(of_is31fl319x_match),
 439         },
 440         .probe    = is31fl319x_probe,
 441         .remove   = is31fl319x_remove,
 442         .id_table = is31fl319x_id,
 443 };
 444
 445 module_i2c_driver(is31fl319x_driver);
 446
 447 MODULE_AUTHOR("H. Nikolaus Schaller <hns@goldelico.com>");
 448 MODULE_AUTHOR("Andrey Utkin <andrey_utkin@fastmail.com>");
 449 MODULE_DESCRIPTION("IS31FL319X LED driver");
 450 MODULE_LICENSE("GPL v2");