drivers/leds/leds-lp3952.c

   1 /*
   2  *      LED driver for TI lp3952 controller
   3  *
   4  *      Copyright (C) 2016, DAQRI, LLC.
   5  *      Author: Tony Makkiel <tony.makkiel@daqri.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  *
  11  */
  12
  13 #include <linux/acpi.h>
  14 #include <linux/delay.h>
  15 #include <linux/gpio.h>
  16 #include <linux/i2c.h>
  17 #include <linux/io.h>
  18 #include <linux/kernel.h>
  19 #include <linux/leds.h>
  20 #include <linux/leds-lp3952.h>
  21 #include <linux/module.h>
  22 #include <linux/notifier.h>
  23 #include <linux/platform_device.h>
  24 #include <linux/pm.h>
  25 #include <linux/reboot.h>
  26 #include <linux/regmap.h>
  27
  28 static int lp3952_register_write(struct i2c_client *client, u8 reg, u8 val)
  29 {
  30         int ret;
  31         struct lp3952_led_array *priv = i2c_get_clientdata(client);
  32
  33         ret = regmap_write(priv->regmap, reg, val);
  34
  35         if (ret)
  36                 dev_err(&client->dev, "%s: reg 0x%x, val 0x%x, err %d\n",
  37                         __func__, reg, val, ret);
  38         return ret;
  39 }
  40
  41 static void lp3952_on_off(struct lp3952_led_array *priv,
  42                           enum lp3952_leds led_id, bool on)
  43 {
  44         int ret, val;
  45
  46         dev_dbg(&priv->client->dev, "%s LED %d to %d\n", __func__, led_id, on);
  47
  48         val = 1 << led_id;
  49         if (led_id == LP3952_LED_ALL)
  50                 val = LP3952_LED_MASK_ALL;
  51
  52         ret = regmap_update_bits(priv->regmap, LP3952_REG_LED_CTRL, val,
  53                                  on ? val : 0);
  54         if (ret)
  55                 dev_err(&priv->client->dev, "%s, Error %d\n", __func__, ret);
  56 }
  57
  58 /*
  59  * Using Imax to control brightness. There are 4 possible
  60  * setting 25, 50, 75 and 100 % of Imax. Possible values are
  61  * values 0-4. 0 meaning turn off.
  62  */
  63 static int lp3952_set_brightness(struct led_classdev *cdev,
  64                                  enum led_brightness value)
  65 {
  66         unsigned int reg, shift_val;
  67         struct lp3952_ctrl_hdl *led = container_of(cdev,
  68                                                    struct lp3952_ctrl_hdl,
  69                                                    cdev);
  70         struct lp3952_led_array *priv = (struct lp3952_led_array *)led->priv;
  71
  72         dev_dbg(cdev->dev, "Brightness request: %d on %d\n", value,
  73                 led->channel);
  74
  75         if (value == LED_OFF) {
  76                 lp3952_on_off(priv, led->channel, false);
  77                 return 0;
  78         }
  79
  80         if (led->channel > LP3952_RED_1) {
  81                 dev_err(cdev->dev, " %s Invalid LED requested", __func__);
  82                 return -EINVAL;
  83         }
  84
  85         if (led->channel >= LP3952_BLUE_1) {
  86                 reg = LP3952_REG_RGB1_MAX_I_CTRL;
  87                 shift_val = (led->channel - LP3952_BLUE_1) * 2;
  88         } else {
  89                 reg = LP3952_REG_RGB2_MAX_I_CTRL;
  90                 shift_val = led->channel * 2;
  91         }
  92
  93         /* Enable the LED in case it is not enabled already */
  94         lp3952_on_off(priv, led->channel, true);
  95
  96         return regmap_update_bits(priv->regmap, reg, 3 << shift_val,
  97                                   --value << shift_val);
  98 }
  99
 100 static int lp3952_get_label(struct device *dev, const char *label, char *dest)
 101 {
 102         int ret;
 103         const char *str;
 104
 105         ret = device_property_read_string(dev, label, &str);
 106         if (!ret)
 107                 strncpy(dest, str, LP3952_LABEL_MAX_LEN);
 108
 109         return ret;
 110 }
 111
 112 static int lp3952_register_led_classdev(struct lp3952_led_array *priv)
 113 {
 114         int i, acpi_ret, ret = -ENODEV;
 115         static const char *led_name_hdl[LP3952_LED_ALL] = {
 116                 "blue2",
 117                 "green2",
 118                 "red2",
 119                 "blue1",
 120                 "green1",
 121                 "red1"
 122         };
 123
 124         for (i = 0; i < LP3952_LED_ALL; i++) {
 125                 acpi_ret = lp3952_get_label(&priv->client->dev, led_name_hdl[i],
 126                                             priv->leds[i].name);
 127                 if (acpi_ret)
 128                         continue;
 129
 130                 priv->leds[i].cdev.name = priv->leds[i].name;
 131                 priv->leds[i].cdev.brightness = LED_OFF;
 132                 priv->leds[i].cdev.max_brightness = LP3952_BRIGHT_MAX;
 133                 priv->leds[i].cdev.brightness_set_blocking =
 134                                 lp3952_set_brightness;
 135                 priv->leds[i].channel = i;
 136                 priv->leds[i].priv = priv;
 137
 138                 ret = devm_led_classdev_register(&priv->client->dev,
 139                                                  &priv->leds[i].cdev);
 140                 if (ret < 0) {
 141                         dev_err(&priv->client->dev,
 142                                 "couldn't register LED %s\n",
 143                                 priv->leds[i].cdev.name);
 144                         break;
 145                 }
 146         }
 147         return ret;
 148 }
 149
 150 static int lp3952_set_pattern_gen_cmd(struct lp3952_led_array *priv,
 151                                       u8 cmd_index, u8 r, u8 g, u8 b,
 152                                       enum lp3952_tt tt, enum lp3952_cet cet)
 153 {
 154         int ret;
 155         struct ptrn_gen_cmd line = {
 156                 {
 157                         {
 158                                 .r = r,
 159                                 .g = g,
 160                                 .b = b,
 161                                 .cet = cet,
 162                                 .tt = tt
 163                         }
 164                 }
 165         };
 166
 167         if (cmd_index >= LP3952_CMD_REG_COUNT)
 168                 return -EINVAL;
 169
 170         ret = lp3952_register_write(priv->client,
 171                                     LP3952_REG_CMD_0 + cmd_index * 2,
 172                                     line.bytes.msb);
 173         if (ret)
 174                 return ret;
 175
 176         return lp3952_register_write(priv->client,
 177                                       LP3952_REG_CMD_0 + cmd_index * 2 + 1,
 178                                       line.bytes.lsb);
 179 }
 180
 181 static int lp3952_configure(struct lp3952_led_array *priv)
 182 {
 183         int ret;
 184
 185         /* Disable any LEDs on from any previous conf. */
 186         ret = lp3952_register_write(priv->client, LP3952_REG_LED_CTRL, 0);
 187         if (ret)
 188                 return ret;
 189
 190         /* enable rgb patter, loop */
 191         ret = lp3952_register_write(priv->client, LP3952_REG_PAT_GEN_CTRL,
 192                                     LP3952_PATRN_LOOP | LP3952_PATRN_GEN_EN);
 193         if (ret)
 194                 return ret;
 195
 196         /* Update Bit 6 (Active mode), Select both Led sets, Bit [1:0] */
 197         ret = lp3952_register_write(priv->client, LP3952_REG_ENABLES,
 198                                     LP3952_ACTIVE_MODE | LP3952_INT_B00ST_LDR);
 199         if (ret)
 200                 return ret;
 201
 202         /* Set Cmd1 for RGB intensity,cmd and transition time */
 203         return lp3952_set_pattern_gen_cmd(priv, 0, I46, I71, I100, TT0,
 204                                            CET197);
 205 }
 206
 207 static const struct regmap_config lp3952_regmap = {
 208         .reg_bits = 8,
 209         .val_bits = 8,
 210         .max_register = REG_MAX,
 211         .cache_type = REGCACHE_RBTREE,
 212 };
 213
 214 static int lp3952_probe(struct i2c_client *client,
 215                         const struct i2c_device_id *id)
 216 {
 217         int status;
 218         struct lp3952_led_array *priv;
 219
 220         priv = devm_kzalloc(&client->dev, sizeof(*priv), GFP_KERNEL);
 221         if (!priv)
 222                 return -ENOMEM;
 223
 224         priv->client = client;
 225
 226         priv->enable_gpio = devm_gpiod_get(&client->dev, "nrst",
 227                                            GPIOD_OUT_HIGH);
 228         if (IS_ERR(priv->enable_gpio)) {
 229                 status = PTR_ERR(priv->enable_gpio);
 230                 dev_err(&client->dev, "Failed to enable gpio: %d\n", status);
 231                 return status;
 232         }
 233
 234         priv->regmap = devm_regmap_init_i2c(client, &lp3952_regmap);
 235         if (IS_ERR(priv->regmap)) {
 236                 int err = PTR_ERR(priv->regmap);
 237
 238                 dev_err(&client->dev, "Failed to allocate register map: %d\n",
 239                         err);
 240                 return err;
 241         }
 242
 243         i2c_set_clientdata(client, priv);
 244
 245         status = lp3952_configure(priv);
 246         if (status) {
 247                 dev_err(&client->dev, "Probe failed. Device not found (%d)\n",
 248                         status);
 249                 return status;
 250         }
 251
 252         status = lp3952_register_led_classdev(priv);
 253         if (status) {
 254                 dev_err(&client->dev, "Unable to register led_classdev: %d\n",
 255                         status);
 256                 return status;
 257         }
 258
 259         return 0;
 260 }
 261
 262 static int lp3952_remove(struct i2c_client *client)
 263 {
 264         struct lp3952_led_array *priv;
 265
 266         priv = i2c_get_clientdata(client);
 267         lp3952_on_off(priv, LP3952_LED_ALL, false);
 268         gpiod_set_value(priv->enable_gpio, 0);
 269
 270         return 0;
 271 }
 272
 273 static const struct i2c_device_id lp3952_id[] = {
 274         {LP3952_NAME, 0},
 275         {}
 276 };
 277
 278 #ifdef CONFIG_ACPI
 279 static const struct acpi_device_id lp3952_acpi_match[] = {
 280         {"TXNW3952", 0},
 281         {}
 282 };
 283
 284 MODULE_DEVICE_TABLE(acpi, lp3952_acpi_match);
 285 #endif
 286
 287 static struct i2c_driver lp3952_i2c_driver = {
 288         .driver = {
 289                         .name = LP3952_NAME,
 290                         .acpi_match_table = ACPI_PTR(lp3952_acpi_match),
 291         },
 292         .probe = lp3952_probe,
 293         .remove = lp3952_remove,
 294         .id_table = lp3952_id,
 295 };
 296
 297 module_i2c_driver(lp3952_i2c_driver);
 298
 299 MODULE_AUTHOR("Tony Makkiel <tony.makkiel@daqri.com>");
 300 MODULE_DESCRIPTION("lp3952 I2C LED controller driver");
 301 MODULE_LICENSE("GPL v2");