Merge tag 'leds_for_4.6' of git://git.kernel.org/pub/scm/linux/kernel/git/j.anaszewski/linux-leds

Pull LED updates from Jacek Anaszewski:
 "LED core improvements:
   - Fix misleading comment after workqueue removal from drivers
   - Avoid error message when a USB LED device is unplugged
   - Add helpers for calling brightness_set(_blocking)

  LED triggers:
   - Simplify led_trigger_store by using sysfs_streq()

  LED class drivers improvements:
   - Improve wording and formatting in a comment: lp3944
   - Fix return value check in create_gpio_led(): leds-gpio
   - Use GPIOF_OUT_INIT_LOW instead of hardcoded zero: leds-gpio
   - Use devm_led_classdev_register(): leds-lm3533, leds-lm3533,
     leds-lp8788, leds-wm831x-status, leds-s3c24xx, leds-s3c24xx,
     leds-max8997.

  New LED class driver:
   - Add driver for the ISSI IS31FL32xx family of LED controllers.

  Device Tree documentation:
   - of: Add vendor prefixes for Integrated Silicon Solutions Inc.
     (issi) and Si-En Technology (si-en).
   - DT: Add common bindings for Si-En Technology SN3216/18 and
     IS31FL32xx family of LED controllers, since they seem to be the
     same hardware, just rebranded"

* tag 'leds_for_4.6' of git://git.kernel.org/pub/scm/linux/kernel/git/j.anaszewski/linux-leds:
  leds: triggers: simplify led_trigger_store
  leds: max8997: Use devm_led_classdev_register
  leds: da903x: Use devm_led_classdev_register
  leds: s3c24xx: Use devm_led_classdev_register
  leds: wm831x-status: Use devm_led_classdev_register
  leds: lp8788: Use devm_led_classdev_register
  leds: 88pm860x: Use devm_led_classdev_register
  leds: Add SN3218 and SN3216 support to the IS31FL32XX driver
  of: Add vendor prefix for Si-En Technology
  leds: Add driver for the ISSI IS31FL32xx family of LED controllers
  DT: leds: Add binding for the ISSI IS31FL32xx family of LED controllers
  DT: Add vendor prefix for Integrated Silicon Solutions Inc.
  leds: lm3533: Use devm_led_classdev_register
  leds: gpio: Use GPIOF_OUT_INIT_LOW instead of hardcoded zero
  leds: core: add helpers for calling brightness_set(_blocking)
  leds: leds-gpio: Fix return value check in create_gpio_led()
  leds: lp3944: improve wording and formatting in a comment
  leds: core: avoid error message when a USB LED device is unplugged
  leds: core: fix misleading comment after workqueue removal from drivers

18 files changed, 628 insertions, 120 deletions

diff --git a/Documentation/devicetree/bindings/leds/leds-is31fl32xx.txt b/Documentation/devicetree/bindings/leds/leds-is31fl32xx.txt
new file mode 100644
index 000000000000..926c2117942c
--- /dev/null
+++ b/Documentation/devicetree/bindings/leds/leds-is31fl32xx.txt
@@ -0,0 +1,52 @@
+Binding for ISSI IS31FL32xx and Si-En SN32xx LED Drivers
+
+The IS31FL32xx/SN32xx family of LED drivers are I2C devices with multiple
+constant-current channels, each with independent 256-level PWM control.
+Each LED is represented as a sub-node of the device.
+
+Required properties:
+- compatible: one of
+        issi,is31fl3236
+        issi,is31fl3235
+        issi,is31fl3218
+        issi,is31fl3216
+        si-en,sn3218
+        si-en,sn3216
+- reg: I2C slave address
+- address-cells : must be 1
+- size-cells : must be 0
+
+LED sub-node properties:
+- reg : LED channel number (1..N)
+- label :  (optional)
+  see Documentation/devicetree/bindings/leds/common.txt
+- linux,default-trigger :  (optional)
+  see Documentation/devicetree/bindings/leds/common.txt
+
+
+Example:
+
+is31fl3236: led-controller@3c {
+        compatible = "issi,is31fl3236";
+        reg = <0x3c>;
+        #address-cells = <1>;
+        #size-cells = <0>;
+
+        led@1 {
+                reg = <1>;
+                label = "EB:blue:usr0";
+        };
+        led@2 {
+                reg = <2>;
+                label = "EB:blue:usr1";
+        };
+        ...
+        led@36 {
+                reg = <36>;
+                label = "EB:blue:usr35";
+        };
+};
+
+For more product information please see the links below:
+http://www.issi.com/US/product-analog-fxled-driver.shtml
+http://www.si-en.com/product.asp?parentid=890
diff --git a/Documentation/devicetree/bindings/vendor-prefixes.txt b/Documentation/devicetree/bindings/vendor-prefixes.txt
index 72e2c5a2b327..dd72e0541e83 100644
--- a/Documentation/devicetree/bindings/vendor-prefixes.txt
+++ b/Documentation/devicetree/bindings/vendor-prefixes.txt
@@ -120,6 +120,7 @@ intercontrol	Inter Control Group
 invensense      InvenSense Inc.
 isee    ISEE 2007 S.L.
 isil    Intersil
+issi    Integrated Silicon Solutions Inc.
 jedec   JEDEC Solid State Technology Association
 karo    Ka-Ro electronics GmbH
 keymile Keymile GmbH
@@ -204,6 +205,7 @@ seagate	Seagate Technology PLC
 semtech Semtech Corporation
 sgx     SGX Sensortech
 sharp   Sharp Corporation
+si-en   Si-En Technology Ltd.
 sigma   Sigma Designs, Inc.
 sil     Silicon Image
 silabs  Silicon Laboratories
diff --git a/drivers/leds/Kconfig b/drivers/leds/Kconfig
index 7f940c24a16b..1f6415168998 100644
--- a/drivers/leds/Kconfig
+++ b/drivers/leds/Kconfig
@@ -568,6 +568,14 @@ config LEDS_SEAD3
           This driver can also be built as a module. If so the module
           will be called leds-sead3.
 
+config LEDS_IS31FL32XX
+        tristate "LED support for ISSI IS31FL32XX I2C LED controller family"
+        depends on LEDS_CLASS && I2C && OF
+        help
+          Say Y here to include support for ISSI IS31FL32XX and Si-En SN32xx
+          LED controllers. They are I2C devices with multiple constant-current
+          channels, each with independent 256-level PWM control.
+
 comment "LED driver for blink(1) USB RGB LED is under Special HID drivers (HID_THINGM)"
 
 config LEDS_BLINKM
diff --git a/drivers/leds/Makefile b/drivers/leds/Makefile
index e9d53092765d..cb2013df52d9 100644
--- a/drivers/leds/Makefile
+++ b/drivers/leds/Makefile
@@ -66,6 +66,7 @@ obj-$(CONFIG_LEDS_MENF21BMC)		+= leds-menf21bmc.o
 obj-$(CONFIG_LEDS_KTD2692)              += leds-ktd2692.o
 obj-$(CONFIG_LEDS_POWERNV)              += leds-powernv.o
 obj-$(CONFIG_LEDS_SEAD3)                += leds-sead3.o
+obj-$(CONFIG_LEDS_IS31FL32XX)           += leds-is31fl32xx.o
 
 # LED SPI Drivers
 obj-$(CONFIG_LEDS_DAC124S085)           += leds-dac124s085.o
diff --git a/drivers/leds/led-class.c b/drivers/leds/led-class.c
index 14139c337312..aa84e5b37593 100644
--- a/drivers/leds/led-class.c
+++ b/drivers/leds/led-class.c
@@ -245,6 +245,8 @@ void led_classdev_unregister(struct led_classdev *led_cdev)
         up_write(&led_cdev->trigger_lock);
 #endif
 
+        led_cdev->flags |= LED_UNREGISTERING;
+
         /* Stop blinking */
         led_stop_software_blink(led_cdev);
 
diff --git a/drivers/leds/led-core.c b/drivers/leds/led-core.c
index 19e1e60dfaa3..3495d5d6547f 100644
--- a/drivers/leds/led-core.c
+++ b/drivers/leds/led-core.c
@@ -25,6 +25,26 @@ EXPORT_SYMBOL_GPL(leds_list_lock);
 LIST_HEAD(leds_list);
 EXPORT_SYMBOL_GPL(leds_list);
 
+static int __led_set_brightness(struct led_classdev *led_cdev,
+                                enum led_brightness value)
+{
+        if (!led_cdev->brightness_set)
+                return -ENOTSUPP;
+
+        led_cdev->brightness_set(led_cdev, value);
+
+        return 0;
+}
+
+static int __led_set_brightness_blocking(struct led_classdev *led_cdev,
+                                         enum led_brightness value)
+{
+        if (!led_cdev->brightness_set_blocking)
+                return -ENOTSUPP;
+
+        return led_cdev->brightness_set_blocking(led_cdev, value);
+}
+
 static void led_timer_function(unsigned long data)
 {
         struct led_classdev *led_cdev = (void *)data;
@@ -91,14 +111,14 @@ static void set_brightness_delayed(struct work_struct *ws)
                 led_cdev->flags &= ~LED_BLINK_DISABLE;
         }
 
-        if (led_cdev->brightness_set)
-                led_cdev->brightness_set(led_cdev, led_cdev->delayed_set_value);
-        else if (led_cdev->brightness_set_blocking)
-                ret = led_cdev->brightness_set_blocking(led_cdev,
-                                                led_cdev->delayed_set_value);
-        else
-                ret = -ENOTSUPP;
-        if (ret < 0)
+        ret = __led_set_brightness(led_cdev, led_cdev->delayed_set_value);
+        if (ret == -ENOTSUPP)
+                ret = __led_set_brightness_blocking(led_cdev,
+                                        led_cdev->delayed_set_value);
+        if (ret < 0 &&
+            /* LED HW might have been unplugged, therefore don't warn */
+            !(ret == -ENODEV && (led_cdev->flags & LED_UNREGISTERING) &&
+            (led_cdev->flags & LED_HW_PLUGGABLE)))
                 dev_err(led_cdev->dev,
                         "Setting an LED's brightness failed (%d)\n", ret);
 }
@@ -233,10 +253,8 @@ void led_set_brightness_nopm(struct led_classdev *led_cdev,
                               enum led_brightness value)
 {
         /* Use brightness_set op if available, it is guaranteed not to sleep */
-        if (led_cdev->brightness_set) {
-                led_cdev->brightness_set(led_cdev, value);
+        if (!__led_set_brightness(led_cdev, value))
                 return;
-        }
 
         /* If brightness setting can sleep, delegate it to a work queue task */
         led_cdev->delayed_set_value = value;
@@ -267,10 +285,7 @@ int led_set_brightness_sync(struct led_classdev *led_cdev,
         if (led_cdev->flags & LED_SUSPENDED)
                 return 0;
 
-        if (led_cdev->brightness_set_blocking)
-                return led_cdev->brightness_set_blocking(led_cdev,
-                                                         led_cdev->brightness);
-        return -ENOTSUPP;
+        return __led_set_brightness_blocking(led_cdev, led_cdev->brightness);
 }
 EXPORT_SYMBOL_GPL(led_set_brightness_sync);
 
diff --git a/drivers/leds/led-triggers.c b/drivers/leds/led-triggers.c
index e1e933424ac9..2181581795d3 100644
--- a/drivers/leds/led-triggers.c
+++ b/drivers/leds/led-triggers.c
@@ -34,9 +34,7 @@ ssize_t led_trigger_store(struct device *dev, struct device_attribute *attr,
                 const char *buf, size_t count)
 {
         struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        char trigger_name[TRIG_NAME_MAX];
         struct led_trigger *trig;
-        size_t len;
         int ret = count;
 
         mutex_lock(&led_cdev->led_access);
@@ -46,21 +44,14 @@ ssize_t led_trigger_store(struct device *dev, struct device_attribute *attr,
                 goto unlock;
         }
 
-        trigger_name[sizeof(trigger_name) - 1] = '\0';
-        strncpy(trigger_name, buf, sizeof(trigger_name) - 1);
-        len = strlen(trigger_name);
-
-        if (len && trigger_name[len - 1] == '\n')
-                trigger_name[len - 1] = '\0';
-
-        if (!strcmp(trigger_name, "none")) {
+        if (sysfs_streq(buf, "none")) {
                 led_trigger_remove(led_cdev);
                 goto unlock;
         }
 
         down_read(&triggers_list_lock);
         list_for_each_entry(trig, &trigger_list, next_trig) {
-                if (!strcmp(trigger_name, trig->name)) {
+                if (sysfs_streq(buf, trig->name)) {
                         down_write(&led_cdev->trigger_lock);
                         led_trigger_set(led_cdev, trig);
                         up_write(&led_cdev->trigger_lock);
diff --git a/drivers/leds/leds-88pm860x.c b/drivers/leds/leds-88pm860x.c
index 1ad4d03a0a3c..77a104d2b124 100644
--- a/drivers/leds/leds-88pm860x.c
+++ b/drivers/leds/leds-88pm860x.c
@@ -195,7 +195,6 @@ static int pm860x_led_probe(struct platform_device *pdev)
                 sprintf(data->name, "led1-blue");
                 break;
         }
-        platform_set_drvdata(pdev, data);
         data->chip = chip;
         data->i2c = (chip->id == CHIP_PM8606) ? chip->client : chip->companion;
         data->port = pdev->id;
@@ -208,7 +207,7 @@ static int pm860x_led_probe(struct platform_device *pdev)
         data->cdev.brightness_set_blocking = pm860x_led_set;
         mutex_init(&data->lock);
 
-        ret = led_classdev_register(chip->dev, &data->cdev);
+        ret = devm_led_classdev_register(chip->dev, &data->cdev);
         if (ret < 0) {
                 dev_err(&pdev->dev, "Failed to register LED: %d\n", ret);
                 return ret;
@@ -217,21 +216,12 @@ static int pm860x_led_probe(struct platform_device *pdev)
         return 0;
 }
 
-static int pm860x_led_remove(struct platform_device *pdev)
-{
-        struct pm860x_led *data = platform_get_drvdata(pdev);
-
-        led_classdev_unregister(&data->cdev);
-
-        return 0;
-}
 
 static struct platform_driver pm860x_led_driver = {
         .driver = {
                 .name   = "88pm860x-led",
         },
         .probe  = pm860x_led_probe,
-        .remove = pm860x_led_remove,
 };
 
 module_platform_driver(pm860x_led_driver);
diff --git a/drivers/leds/leds-da903x.c b/drivers/leds/leds-da903x.c
index 4752a2b6ba2b..5ff7d72f73aa 100644
--- a/drivers/leds/leds-da903x.c
+++ b/drivers/leds/leds-da903x.c
@@ -113,21 +113,12 @@ static int da903x_led_probe(struct platform_device *pdev)
         led->flags = pdata->flags;
         led->master = pdev->dev.parent;
 
-        ret = led_classdev_register(led->master, &led->cdev);
+        ret = devm_led_classdev_register(led->master, &led->cdev);
         if (ret) {
                 dev_err(&pdev->dev, "failed to register LED %d\n", id);
                 return ret;
         }
 
-        platform_set_drvdata(pdev, led);
-        return 0;
-}
-
-static int da903x_led_remove(struct platform_device *pdev)
-{
-        struct da903x_led *led = platform_get_drvdata(pdev);
-
-        led_classdev_unregister(&led->cdev);
         return 0;
 }
 
@@ -136,7 +127,6 @@ static struct platform_driver da903x_led_driver = {
                 .name   = "da903x-led",
         },
         .probe          = da903x_led_probe,
-        .remove         = da903x_led_remove,
 };
 
 module_platform_driver(da903x_led_driver);
diff --git a/drivers/leds/leds-gpio.c b/drivers/leds/leds-gpio.c
index 7bc53280dbfd..61143f55597e 100644
--- a/drivers/leds/leds-gpio.c
+++ b/drivers/leds/leds-gpio.c
@@ -86,7 +86,7 @@ static int create_gpio_led(const struct gpio_led *template,
                  * still uses GPIO numbers. Ultimately we would like to get
                  * rid of this block completely.
                  */
-                unsigned long flags = 0;
+                unsigned long flags = GPIOF_OUT_INIT_LOW;
 
                 /* skip leds that aren't available */
                 if (!gpio_is_valid(template->gpio)) {
@@ -104,8 +104,8 @@ static int create_gpio_led(const struct gpio_led *template,
                         return ret;
 
                 led_dat->gpiod = gpio_to_desc(template->gpio);
-                if (IS_ERR(led_dat->gpiod))
-                        return PTR_ERR(led_dat->gpiod);
+                if (!led_dat->gpiod)
+                        return -EINVAL;
         }
 
         led_dat->cdev.name = template->name;
diff --git a/drivers/leds/leds-is31fl32xx.c b/drivers/leds/leds-is31fl32xx.c
new file mode 100644
index 000000000000..c901d132d80c
--- /dev/null
+++ b/drivers/leds/leds-is31fl32xx.c
@@ -0,0 +1,508 @@
+/*
+ * Driver for ISSI IS31FL32xx family of I2C LED controllers
+ *
+ * Copyright 2015 Allworx Corp.
+ *
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Datasheets:
+ *   http://www.issi.com/US/product-analog-fxled-driver.shtml
+ *   http://www.si-en.com/product.asp?parentid=890
+ */
+
+#include <linux/device.h>
+#include <linux/i2c.h>
+#include <linux/kernel.h>
+#include <linux/leds.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+
+/* Used to indicate a device has no such register */
+#define IS31FL32XX_REG_NONE 0xFF
+
+/* Software Shutdown bit in Shutdown Register */
+#define IS31FL32XX_SHUTDOWN_SSD_ENABLE  0
+#define IS31FL32XX_SHUTDOWN_SSD_DISABLE BIT(0)
+
+/* IS31FL3216 has a number of unique registers */
+#define IS31FL3216_CONFIG_REG 0x00
+#define IS31FL3216_LIGHTING_EFFECT_REG 0x03
+#define IS31FL3216_CHANNEL_CONFIG_REG 0x04
+
+/* Software Shutdown bit in 3216 Config Register */
+#define IS31FL3216_CONFIG_SSD_ENABLE  BIT(7)
+#define IS31FL3216_CONFIG_SSD_DISABLE 0
+
+struct is31fl32xx_priv;
+struct is31fl32xx_led_data {
+        struct led_classdev cdev;
+        u8 channel; /* 1-based, max priv->cdef->channels */
+        struct is31fl32xx_priv *priv;
+};
+
+struct is31fl32xx_priv {
+        const struct is31fl32xx_chipdef *cdef;
+        struct i2c_client *client;
+        unsigned int num_leds;
+        struct is31fl32xx_led_data leds[0];
+};
+
+/**
+ * struct is31fl32xx_chipdef - chip-specific attributes
+ * @channels            : Number of LED channels
+ * @shutdown_reg        : address of Shutdown register (optional)
+ * @pwm_update_reg      : address of PWM Update register
+ * @global_control_reg  : address of Global Control register (optional)
+ * @reset_reg           : address of Reset register (optional)
+ * @pwm_register_base   : address of first PWM register
+ * @pwm_registers_reversed: : true if PWM registers count down instead of up
+ * @led_control_register_base : address of first LED control register (optional)
+ * @enable_bits_per_led_control_register: number of LEDs enable bits in each
+ * @reset_func:         : pointer to reset function
+ *
+ * For all optional register addresses, the sentinel value %IS31FL32XX_REG_NONE
+ * indicates that this chip has no such register.
+ *
+ * If non-NULL, @reset_func will be called during probing to set all
+ * necessary registers to a known initialization state. This is needed
+ * for chips that do not have a @reset_reg.
+ *
+ * @enable_bits_per_led_control_register must be >=1 if
+ * @led_control_register_base != %IS31FL32XX_REG_NONE.
+ */
+struct is31fl32xx_chipdef {
+        u8      channels;
+        u8      shutdown_reg;
+        u8      pwm_update_reg;
+        u8      global_control_reg;
+        u8      reset_reg;
+        u8      pwm_register_base;
+        bool    pwm_registers_reversed;
+        u8      led_control_register_base;
+        u8      enable_bits_per_led_control_register;
+        int (*reset_func)(struct is31fl32xx_priv *priv);
+        int (*sw_shutdown_func)(struct is31fl32xx_priv *priv, bool enable);
+};
+
+static const struct is31fl32xx_chipdef is31fl3236_cdef = {
+        .channels                               = 36,
+        .shutdown_reg                           = 0x00,
+        .pwm_update_reg                         = 0x25,
+        .global_control_reg                     = 0x4a,
+        .reset_reg                              = 0x4f,
+        .pwm_register_base                      = 0x01,
+        .led_control_register_base              = 0x26,
+        .enable_bits_per_led_control_register   = 1,
+};
+
+static const struct is31fl32xx_chipdef is31fl3235_cdef = {
+        .channels                               = 28,
+        .shutdown_reg                           = 0x00,
+        .pwm_update_reg                         = 0x25,
+        .global_control_reg                     = 0x4a,
+        .reset_reg                              = 0x4f,
+        .pwm_register_base                      = 0x05,
+        .led_control_register_base              = 0x2a,
+        .enable_bits_per_led_control_register   = 1,
+};
+
+static const struct is31fl32xx_chipdef is31fl3218_cdef = {
+        .channels                               = 18,
+        .shutdown_reg                           = 0x00,
+        .pwm_update_reg                         = 0x16,
+        .global_control_reg                     = IS31FL32XX_REG_NONE,
+        .reset_reg                              = 0x17,
+        .pwm_register_base                      = 0x01,
+        .led_control_register_base              = 0x13,
+        .enable_bits_per_led_control_register   = 6,
+};
+
+static int is31fl3216_reset(struct is31fl32xx_priv *priv);
+static int is31fl3216_software_shutdown(struct is31fl32xx_priv *priv,
+                                        bool enable);
+static const struct is31fl32xx_chipdef is31fl3216_cdef = {
+        .channels                               = 16,
+        .shutdown_reg                           = IS31FL32XX_REG_NONE,
+        .pwm_update_reg                         = 0xB0,
+        .global_control_reg                     = IS31FL32XX_REG_NONE,
+        .reset_reg                              = IS31FL32XX_REG_NONE,
+        .pwm_register_base                      = 0x10,
+        .pwm_registers_reversed                 = true,
+        .led_control_register_base              = 0x01,
+        .enable_bits_per_led_control_register   = 8,
+        .reset_func                             = is31fl3216_reset,
+        .sw_shutdown_func                       = is31fl3216_software_shutdown,
+};
+
+static int is31fl32xx_write(struct is31fl32xx_priv *priv, u8 reg, u8 val)
+{
+        int ret;
+
+        dev_dbg(&priv->client->dev, "writing register 0x%02X=0x%02X", reg, val);
+
+        ret =  i2c_smbus_write_byte_data(priv->client, reg, val);
+        if (ret) {
+                dev_err(&priv->client->dev,
+                        "register write to 0x%02X failed (error %d)",
+                        reg, ret);
+        }
+        return ret;
+}
+
+/*
+ * Custom reset function for IS31FL3216 because it does not have a RESET
+ * register the way that the other IS31FL32xx chips do. We don't bother
+ * writing the GPIO and animation registers, because the registers we
+ * do write ensure those will have no effect.
+ */
+static int is31fl3216_reset(struct is31fl32xx_priv *priv)
+{
+        unsigned int i;
+        int ret;
+
+        ret = is31fl32xx_write(priv, IS31FL3216_CONFIG_REG,
+                               IS31FL3216_CONFIG_SSD_ENABLE);
+        if (ret)
+                return ret;
+        for (i = 0; i < priv->cdef->channels; i++) {
+                ret = is31fl32xx_write(priv, priv->cdef->pwm_register_base+i,
+                                       0x00);
+                if (ret)
+                        return ret;
+        }
+        ret = is31fl32xx_write(priv, priv->cdef->pwm_update_reg, 0);
+        if (ret)
+                return ret;
+        ret = is31fl32xx_write(priv, IS31FL3216_LIGHTING_EFFECT_REG, 0x00);
+        if (ret)
+                return ret;
+        ret = is31fl32xx_write(priv, IS31FL3216_CHANNEL_CONFIG_REG, 0x00);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+/*
+ * Custom Software-Shutdown function for IS31FL3216 because it does not have
+ * a SHUTDOWN register the way that the other IS31FL32xx chips do.
+ * We don't bother doing a read/modify/write on the CONFIG register because
+ * we only ever use a value of '0' for the other fields in that register.
+ */
+static int is31fl3216_software_shutdown(struct is31fl32xx_priv *priv,
+                                        bool enable)
+{
+        u8 value = enable ? IS31FL3216_CONFIG_SSD_ENABLE :
+                            IS31FL3216_CONFIG_SSD_DISABLE;
+
+        return is31fl32xx_write(priv, IS31FL3216_CONFIG_REG, value);
+}
+
+/*
+ * NOTE: A mutex is not needed in this function because:
+ * - All referenced data is read-only after probe()
+ * - The I2C core has a mutex on to protect the bus
+ * - There are no read/modify/write operations
+ * - Intervening operations between the write of the PWM register
+ *   and the Update register are harmless.
+ *
+ * Example:
+ *      PWM_REG_1 write 16
+ *      UPDATE_REG write 0
+ *      PWM_REG_2 write 128
+ *      UPDATE_REG write 0
+ *   vs:
+ *      PWM_REG_1 write 16
+ *      PWM_REG_2 write 128
+ *      UPDATE_REG write 0
+ *      UPDATE_REG write 0
+ * are equivalent. Poking the Update register merely applies all PWM
+ * register writes up to that point.
+ */
+static int is31fl32xx_brightness_set(struct led_classdev *led_cdev,
+                                     enum led_brightness brightness)
+{
+        const struct is31fl32xx_led_data *led_data =
+                container_of(led_cdev, struct is31fl32xx_led_data, cdev);
+        const struct is31fl32xx_chipdef *cdef = led_data->priv->cdef;
+        u8 pwm_register_offset;
+        int ret;
+
+        dev_dbg(led_cdev->dev, "%s: %d\n", __func__, brightness);
+
+        /* NOTE: led_data->channel is 1-based */
+        if (cdef->pwm_registers_reversed)
+                pwm_register_offset = cdef->channels - led_data->channel;
+        else
+                pwm_register_offset = led_data->channel - 1;
+
+        ret = is31fl32xx_write(led_data->priv,
+                               cdef->pwm_register_base + pwm_register_offset,
+                               brightness);
+        if (ret)
+                return ret;
+
+        return is31fl32xx_write(led_data->priv, cdef->pwm_update_reg, 0);
+}
+
+static int is31fl32xx_reset_regs(struct is31fl32xx_priv *priv)
+{
+        const struct is31fl32xx_chipdef *cdef = priv->cdef;
+        int ret;
+
+        if (cdef->reset_reg != IS31FL32XX_REG_NONE) {
+                ret = is31fl32xx_write(priv, cdef->reset_reg, 0);
+                if (ret)
+                        return ret;
+        }
+
+        if (cdef->reset_func)
+                return cdef->reset_func(priv);
+
+        return 0;
+}
+
+static int is31fl32xx_software_shutdown(struct is31fl32xx_priv *priv,
+                                        bool enable)
+{
+        const struct is31fl32xx_chipdef *cdef = priv->cdef;
+        int ret;
+
+        if (cdef->shutdown_reg != IS31FL32XX_REG_NONE) {
+                u8 value = enable ? IS31FL32XX_SHUTDOWN_SSD_ENABLE :
+                                    IS31FL32XX_SHUTDOWN_SSD_DISABLE;
+                ret = is31fl32xx_write(priv, cdef->shutdown_reg, value);
+                if (ret)
+                        return ret;
+        }
+
+        if (cdef->sw_shutdown_func)
+                return cdef->sw_shutdown_func(priv, enable);
+
+        return 0;
+}
+
+static int is31fl32xx_init_regs(struct is31fl32xx_priv *priv)
+{
+        const struct is31fl32xx_chipdef *cdef = priv->cdef;
+        int ret;
+
+        ret = is31fl32xx_reset_regs(priv);
+        if (ret)
+                return ret;
+
+        /*
+         * Set enable bit for all channels.
+         * We will control state with PWM registers alone.
+         */
+        if (cdef->led_control_register_base != IS31FL32XX_REG_NONE) {
+                u8 value =
+                    GENMASK(cdef->enable_bits_per_led_control_register-1, 0);
+                u8 num_regs = cdef->channels /
+                                cdef->enable_bits_per_led_control_register;
+                int i;
+
+                for (i = 0; i < num_regs; i++) {
+                        ret = is31fl32xx_write(priv,
+                                               cdef->led_control_register_base+i,
+                                               value);
+                        if (ret)
+                                return ret;
+                }
+        }
+
+        ret = is31fl32xx_software_shutdown(priv, false);
+        if (ret)
+                return ret;
+
+        if (cdef->global_control_reg != IS31FL32XX_REG_NONE) {
+                ret = is31fl32xx_write(priv, cdef->global_control_reg, 0x00);
+                if (ret)
+                        return ret;
+        }
+
+        return 0;
+}
+
+static inline size_t sizeof_is31fl32xx_priv(int num_leds)
+{
+        return sizeof(struct is31fl32xx_priv) +
+                      (sizeof(struct is31fl32xx_led_data) * num_leds);
+}
+
+static int is31fl32xx_parse_child_dt(const struct device *dev,
+                                     const struct device_node *child,
+                                     struct is31fl32xx_led_data *led_data)
+{
+        struct led_classdev *cdev = &led_data->cdev;
+        int ret = 0;
+        u32 reg;
+
+        if (of_property_read_string(child, "label", &cdev->name))
+                cdev->name = child->name;
+
+        ret = of_property_read_u32(child, "reg", &reg);
+        if (ret || reg < 1 || reg > led_data->priv->cdef->channels) {
+                dev_err(dev,
+                        "Child node %s does not have a valid reg property\n",
+                        child->full_name);
+                return -EINVAL;
+        }
+        led_data->channel = reg;
+
+        of_property_read_string(child, "linux,default-trigger",
+                                &cdev->default_trigger);
+
+        cdev->brightness_set_blocking = is31fl32xx_brightness_set;
+
+        return 0;
+}
+
+static struct is31fl32xx_led_data *is31fl32xx_find_led_data(
+                                        struct is31fl32xx_priv *priv,
+                                        u8 channel)
+{
+        size_t i;
+
+        for (i = 0; i < priv->num_leds; i++) {
+                if (priv->leds[i].channel == channel)
+                        return &priv->leds[i];
+        }
+
+        return NULL;
+}
+
+static int is31fl32xx_parse_dt(struct device *dev,
+                               struct is31fl32xx_priv *priv)
+{
+        struct device_node *child;
+        int ret = 0;
+
+        for_each_child_of_node(dev->of_node, child) {
+                struct is31fl32xx_led_data *led_data =
+                        &priv->leds[priv->num_leds];
+                const struct is31fl32xx_led_data *other_led_data;
+
+                led_data->priv = priv;
+
+                ret = is31fl32xx_parse_child_dt(dev, child, led_data);
+                if (ret)
+                        goto err;
+
+                /* Detect if channel is already in use by another child */
+                other_led_data = is31fl32xx_find_led_data(priv,
+                                                          led_data->channel);
+                if (other_led_data) {
+                        dev_err(dev,
+                                "%s and %s both attempting to use channel %d\n",
+                                led_data->cdev.name,
+                                other_led_data->cdev.name,
+                                led_data->channel);
+                        goto err;
+                }
+
+                ret = devm_led_classdev_register(dev, &led_data->cdev);
+                if (ret) {
+                        dev_err(dev, "failed to register PWM led for %s: %d\n",
+                                led_data->cdev.name, ret);
+                        goto err;
+                }
+
+                priv->num_leds++;
+        }
+
+        return 0;
+
+err:
+        of_node_put(child);
+        return ret;
+}
+
+static const struct of_device_id of_is31fl31xx_match[] = {
+        { .compatible = "issi,is31fl3236", .data = &is31fl3236_cdef, },
+        { .compatible = "issi,is31fl3235", .data = &is31fl3235_cdef, },
+        { .compatible = "issi,is31fl3218", .data = &is31fl3218_cdef, },
+        { .compatible = "si-en,sn3218",    .data = &is31fl3218_cdef, },
+        { .compatible = "issi,is31fl3216", .data = &is31fl3216_cdef, },
+        { .compatible = "si-en,sn3216",    .data = &is31fl3216_cdef, },
+        {},
+};
+
+MODULE_DEVICE_TABLE(of, of_is31fl31xx_match);
+
+static int is31fl32xx_probe(struct i2c_client *client,
+                            const struct i2c_device_id *id)
+{
+        const struct is31fl32xx_chipdef *cdef;
+        const struct of_device_id *of_dev_id;
+        struct device *dev = &client->dev;
+        struct is31fl32xx_priv *priv;
+        int count;
+        int ret = 0;
+
+        of_dev_id = of_match_device(of_is31fl31xx_match, dev);
+        if (!of_dev_id)
+                return -EINVAL;
+
+        cdef = of_dev_id->data;
+
+        count = of_get_child_count(dev->of_node);
+        if (!count)
+                return -EINVAL;
+
+        priv = devm_kzalloc(dev, sizeof_is31fl32xx_priv(count),
+                            GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+
+        priv->client = client;
+        priv->cdef = cdef;
+        i2c_set_clientdata(client, priv);
+
+        ret = is31fl32xx_init_regs(priv);
+        if (ret)
+                return ret;
+
+        ret = is31fl32xx_parse_dt(dev, priv);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static int is31fl32xx_remove(struct i2c_client *client)
+{
+        struct is31fl32xx_priv *priv = i2c_get_clientdata(client);
+
+        return is31fl32xx_reset_regs(priv);
+}
+
+/*
+ * i2c-core requires that id_table be non-NULL, even though
+ * it is not used for DeviceTree based instantiation.
+ */
+static const struct i2c_device_id is31fl31xx_id[] = {
+        {},
+};
+
+MODULE_DEVICE_TABLE(i2c, is31fl31xx_id);
+
+static struct i2c_driver is31fl32xx_driver = {
+        .driver = {
+                .name   = "is31fl32xx",
+                .of_match_table = of_is31fl31xx_match,
+        },
+        .probe          = is31fl32xx_probe,
+        .remove         = is31fl32xx_remove,
+        .id_table       = is31fl31xx_id,
+};
+
+module_i2c_driver(is31fl32xx_driver);
+
+MODULE_AUTHOR("David Rivshin <drivshin@allworx.com>");
+MODULE_DESCRIPTION("ISSI IS31FL32xx LED driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/leds/leds-lm3533.c b/drivers/leds/leds-lm3533.c
index 196dcb5e6004..5b529dc013d2 100644
--- a/drivers/leds/leds-lm3533.c
+++ b/drivers/leds/leds-lm3533.c
@@ -698,7 +698,7 @@ static int lm3533_led_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, led);
 
-        ret = led_classdev_register(pdev->dev.parent, &led->cdev);
+        ret = devm_led_classdev_register(pdev->dev.parent, &led->cdev);
         if (ret) {
                 dev_err(&pdev->dev, "failed to register LED %d\n", pdev->id);
                 return ret;
@@ -708,18 +708,13 @@ static int lm3533_led_probe(struct platform_device *pdev)
 
         ret = lm3533_led_setup(led, pdata);
         if (ret)
-                goto err_unregister;
+                return ret;
 
         ret = lm3533_ctrlbank_enable(&led->cb);
         if (ret)
-                goto err_unregister;
+                return ret;
 
         return 0;
-
-err_unregister:
-        led_classdev_unregister(&led->cdev);
-
-        return ret;
 }
 
 static int lm3533_led_remove(struct platform_device *pdev)
@@ -729,7 +724,6 @@ static int lm3533_led_remove(struct platform_device *pdev)
         dev_dbg(&pdev->dev, "%s\n", __func__);
 
         lm3533_ctrlbank_disable(&led->cb);
-        led_classdev_unregister(&led->cdev);
 
         return 0;
 }
diff --git a/drivers/leds/leds-lp3944.c b/drivers/leds/leds-lp3944.c
index 6c758aea1bbd..be60c181222a 100644
--- a/drivers/leds/leds-lp3944.c
+++ b/drivers/leds/leds-lp3944.c
@@ -199,8 +199,11 @@ static int lp3944_led_set(struct lp3944_led_data *led, u8 status)
         if (status > LP3944_LED_STATUS_DIM1)
                 return -EINVAL;
 
-        /* invert only 0 and 1, leave unchanged the other values,
-         * remember we are abusing status to set blink patterns
+        /*
+         * Invert status only when it's < 2 (i.e. 0 or 1) which means it's
+         * controlling the on/off state directly.
+         * When, instead, status is >= 2 don't invert it because it would mean
+         * to mess with the hardware blinking mode.
          */
         if (led->type == LP3944_LED_TYPE_LED_INVERTED && status < 2)
                 status = 1 - status;
diff --git a/drivers/leds/leds-lp8788.c b/drivers/leds/leds-lp8788.c
index 0eee38fc0565..38c253a43700 100644
--- a/drivers/leds/leds-lp8788.c
+++ b/drivers/leds/leds-lp8788.c
@@ -146,15 +146,13 @@ static int lp8788_led_probe(struct platform_device *pdev)
 
         mutex_init(&led->lock);
 
-        platform_set_drvdata(pdev, led);
-
         ret = lp8788_led_init_device(led, led_pdata);
         if (ret) {
                 dev_err(dev, "led init device err: %d\n", ret);
                 return ret;
         }
 
-        ret = led_classdev_register(dev, &led->led_dev);
+        ret = devm_led_classdev_register(dev, &led->led_dev);
         if (ret) {
                 dev_err(dev, "led register err: %d\n", ret);
                 return ret;
@@ -163,18 +161,8 @@ static int lp8788_led_probe(struct platform_device *pdev)
         return 0;
 }
 
-static int lp8788_led_remove(struct platform_device *pdev)
-{
-        struct lp8788_led *led = platform_get_drvdata(pdev);
-
-        led_classdev_unregister(&led->led_dev);
-
-        return 0;
-}
-
 static struct platform_driver lp8788_led_driver = {
         .probe = lp8788_led_probe,
-        .remove = lp8788_led_remove,
         .driver = {
                 .name = LP8788_DEV_KEYLED,
         },
diff --git a/drivers/leds/leds-max8997.c b/drivers/leds/leds-max8997.c
index 01b459069358..4edf74f1d6d4 100644
--- a/drivers/leds/leds-max8997.c
+++ b/drivers/leds/leds-max8997.c
@@ -281,30 +281,18 @@ static int max8997_led_probe(struct platform_device *pdev)
 
         mutex_init(&led->mutex);
 
-        platform_set_drvdata(pdev, led);
-
-        ret = led_classdev_register(&pdev->dev, &led->cdev);
+        ret = devm_led_classdev_register(&pdev->dev, &led->cdev);
         if (ret < 0)
                 return ret;
 
         return 0;
 }
 
-static int max8997_led_remove(struct platform_device *pdev)
-{
-        struct max8997_led *led = platform_get_drvdata(pdev);
-
-        led_classdev_unregister(&led->cdev);
-
-        return 0;
-}
-
 static struct platform_driver max8997_led_driver = {
         .driver = {
                 .name  = "max8997-led",
         },
         .probe  = max8997_led_probe,
-        .remove = max8997_led_remove,
 };
 
 module_platform_driver(max8997_led_driver);
diff --git a/drivers/leds/leds-s3c24xx.c b/drivers/leds/leds-s3c24xx.c
index 83641a7b299a..404da451cb88 100644
--- a/drivers/leds/leds-s3c24xx.c
+++ b/drivers/leds/leds-s3c24xx.c
@@ -29,11 +29,6 @@ struct s3c24xx_gpio_led {
         struct s3c24xx_led_platdata     *pdata;
 };
 
-static inline struct s3c24xx_gpio_led *pdev_to_gpio(struct platform_device *dev)
-{
-        return platform_get_drvdata(dev);
-}
-
 static inline struct s3c24xx_gpio_led *to_gpio(struct led_classdev *led_cdev)
 {
         return container_of(led_cdev, struct s3c24xx_gpio_led, cdev);
@@ -59,15 +54,6 @@ static void s3c24xx_led_set(struct led_classdev *led_cdev,
         }
 }
 
-static int s3c24xx_led_remove(struct platform_device *dev)
-{
-        struct s3c24xx_gpio_led *led = pdev_to_gpio(dev);
-
-        led_classdev_unregister(&led->cdev);
-
-        return 0;
-}
-
 static int s3c24xx_led_probe(struct platform_device *dev)
 {
         struct s3c24xx_led_platdata *pdata = dev_get_platdata(&dev->dev);
@@ -79,8 +65,6 @@ static int s3c24xx_led_probe(struct platform_device *dev)
         if (!led)
                 return -ENOMEM;
 
-        platform_set_drvdata(dev, led);
-
         led->cdev.brightness_set = s3c24xx_led_set;
         led->cdev.default_trigger = pdata->def_trigger;
         led->cdev.name = pdata->name;
@@ -104,7 +88,7 @@ static int s3c24xx_led_probe(struct platform_device *dev)
 
         /* register our new led device */
 
-        ret = led_classdev_register(&dev->dev, &led->cdev);
+        ret = devm_led_classdev_register(&dev->dev, &led->cdev);
         if (ret < 0)
                 dev_err(&dev->dev, "led_classdev_register failed\n");
 
@@ -113,7 +97,6 @@ static int s3c24xx_led_probe(struct platform_device *dev)
 
 static struct platform_driver s3c24xx_led_driver = {
         .probe          = s3c24xx_led_probe,
-        .remove         = s3c24xx_led_remove,
         .driver         = {
                 .name           = "s3c24xx_led",
         },
diff --git a/drivers/leds/leds-wm831x-status.c b/drivers/leds/leds-wm831x-status.c
index 64a22263e7fc..be93b20e792a 100644
--- a/drivers/leds/leds-wm831x-status.c
+++ b/drivers/leds/leds-wm831x-status.c
@@ -239,7 +239,6 @@ static int wm831x_status_probe(struct platform_device *pdev)
                                GFP_KERNEL);
         if (!drvdata)
                 return -ENOMEM;
-        platform_set_drvdata(pdev, drvdata);
 
         drvdata->wm831x = wm831x;
         drvdata->reg = res->start;
@@ -284,7 +283,7 @@ static int wm831x_status_probe(struct platform_device *pdev)
         drvdata->cdev.blink_set = wm831x_status_blink_set;
         drvdata->cdev.groups = wm831x_status_groups;
 
-        ret = led_classdev_register(wm831x->dev, &drvdata->cdev);
+        ret = devm_led_classdev_register(wm831x->dev, &drvdata->cdev);
         if (ret < 0) {
                 dev_err(&pdev->dev, "Failed to register LED: %d\n", ret);
                 return ret;
@@ -293,21 +292,11 @@ static int wm831x_status_probe(struct platform_device *pdev)
         return 0;
 }
 
-static int wm831x_status_remove(struct platform_device *pdev)
-{
-        struct wm831x_status *drvdata = platform_get_drvdata(pdev);
-
-        led_classdev_unregister(&drvdata->cdev);
-
-        return 0;
-}
-
 static struct platform_driver wm831x_status_driver = {
         .driver = {
                    .name = "wm831x-status",
                    },
         .probe = wm831x_status_probe,
-        .remove = wm831x_status_remove,
 };
 
 module_platform_driver(wm831x_status_driver);
diff --git a/include/linux/leds.h b/include/linux/leds.h
index bc1476fda96e..f203a8f89d30 100644
--- a/include/linux/leds.h
+++ b/include/linux/leds.h
@@ -39,6 +39,7 @@ struct led_classdev {
 
         /* Lower 16 bits reflect status */
 #define LED_SUSPENDED           (1 << 0)
+#define LED_UNREGISTERING       (1 << 1)
         /* Upper 16 bits reflect control information */
 #define LED_CORE_SUSPENDRESUME  (1 << 16)
 #define LED_BLINK_ONESHOT       (1 << 17)
@@ -48,9 +49,12 @@ struct led_classdev {
 #define LED_BLINK_DISABLE       (1 << 21)
 #define LED_SYSFS_DISABLE       (1 << 22)
 #define LED_DEV_CAP_FLASH       (1 << 23)
+#define LED_HW_PLUGGABLE        (1 << 24)
 
-        /* Set LED brightness level */
-        /* Must not sleep, use a workqueue if needed */
+        /* Set LED brightness level
+         * Must not sleep. Use brightness_set_blocking for drivers
+         * that can sleep while setting brightness.
+         */
         void            (*brightness_set)(struct led_classdev *led_cdev,
                                           enum led_brightness brightness);
         /*