Patched in Tegra support.

61 files changed, 1369 insertions, 6895 deletions

diff --git a/drivers/leds/Kconfig b/drivers/leds/Kconfig
index b58bc8a14b9..7f9bed7697a 100644
--- a/drivers/leds/Kconfig
+++ b/drivers/leds/Kconfig
@@ -17,7 +17,7 @@ menuconfig NEW_LEDS
 if NEW_LEDS
 
 config LEDS_CLASS
-        tristate "LED Class Support"
+        bool "LED Class Support"
         help
           This option enables the led sysfs class in /sys/class/leds.  You'll
           need this to do anything useful with LEDs.  If unsure, say N.
@@ -50,30 +50,6 @@ config LEDS_LM3530
           controlled manually or using PWM input or using ambient
           light automatically.
 
-config LEDS_LM3533
-        tristate "LED support for LM3533"
-        depends on LEDS_CLASS
-        depends on MFD_LM3533
-        help
-          This option enables support for the LEDs on National Semiconductor /
-          TI LM3533 Lighting Power chips.
-
-          The LEDs can be controlled directly, through PWM input, or by the
-          ambient-light-sensor interface. The chip supports
-          hardware-accelerated blinking with maximum on and off periods of 9.8
-          and 77 seconds respectively.
-
-config LEDS_LM3642
-        tristate "LED support for LM3642 Chip"
-        depends on LEDS_CLASS && I2C
-        select REGMAP_I2C
-        help
-          This option enables support for LEDs connected to LM3642.
-          The LM3642 is a 4MHz fixed-frequency synchronous boost
-          converter plus 1.5A constant current driver for a high-current
-          white LED.
-
-
 config LEDS_LOCOMO
         tristate "LED Support for Locomo device"
         depends on LEDS_CLASS
@@ -93,11 +69,18 @@ config LEDS_MIKROTIK_RB532
 config LEDS_S3C24XX
         tristate "LED Support for Samsung S3C24XX GPIO LEDs"
         depends on LEDS_CLASS
-        depends on ARCH_S3C24XX
+        depends on ARCH_S3C2410
         help
           This option enables support for LEDs connected to GPIO lines
           on Samsung S3C24XX series CPUs, such as the S3C2410 and S3C2440.
 
+config LEDS_AMS_DELTA
+        tristate "LED Support for the Amstrad Delta (E3)"
+        depends on LEDS_CLASS
+        depends on MACH_AMS_DELTA
+        help
+          This option enables support for the LEDs on Amstrad Delta (E3).
+
 config LEDS_NET48XX
         tristate "LED Support for Soekris net48xx series Error LED"
         depends on LEDS_CLASS
@@ -106,6 +89,16 @@ config LEDS_NET48XX
           This option enables support for the Soekris net4801 and net4826 error
           LED.
 
+config LEDS_NET5501
+        tristate "LED Support for Soekris net5501 series Error LED"
+        depends on LEDS_TRIGGERS
+        depends on X86 && GPIO_CS5535
+        select LEDS_TRIGGER_DEFAULT_ON
+        default n
+        help
+          Add support for the Soekris net5501 board (detection, error led
+          and GPIO).
+
 config LEDS_FSG
         tristate "LED Support for the Freecom FSG-3"
         depends on LEDS_CLASS
@@ -120,6 +113,14 @@ config LEDS_WRAP
         help
           This option enables support for the PCEngines WRAP programmable LEDs.
 
+config LEDS_ALIX2
+        tristate "LED Support for ALIX.2 and ALIX.3 series"
+        depends on LEDS_CLASS
+        depends on X86 && !GPIO_CS5535 && !CS5535_GPIO
+        help
+          This option enables support for the PCEngines ALIX.2 and ALIX.3 LEDs.
+          You have to set leds-alix2.force=1 for boards with Award BIOS.
+
 config LEDS_COBALT_QUBE
         tristate "LED Support for the Cobalt Qube series front LED"
         depends on LEDS_CLASS
@@ -203,22 +204,14 @@ config LEDS_LP5521
           programming the engines.
 
 config LEDS_LP5523
-        tristate "LED Support for TI/National LP5523/55231 LED driver chip"
+        tristate "LED Support for N.S. LP5523 LED driver chip"
         depends on LEDS_CLASS && I2C
         help
-          If you say yes here you get support for TI/National Semiconductor
-          LP5523/55231 LED driver.
-          It is 9 channel chip with programmable engines.
+          If you say yes here you get support for the National Semiconductor
+          LP5523 LED driver. It is 9 channel chip with programmable engines.
           Driver provides direct control via LED class and interface for
           programming the engines.
 
-config LEDS_LP8788
-        tristate "LED support for the TI LP8788 PMIC"
-        depends on LEDS_CLASS
-        depends on MFD_LP8788
-        help
-          This option enables support for the Keyboard LEDs on the LP8788 PMIC.
-
 config LEDS_CLEVO_MAIL
         tristate "Mail LED on Clevo notebook"
         depends on LEDS_CLASS
@@ -259,14 +252,6 @@ config LEDS_PCA955X
           LED driver chips accessed via the I2C bus.  Supported
           devices include PCA9550, PCA9551, PCA9552, and PCA9553.
 
-config LEDS_PCA9633
-        tristate "LED support for PCA9633 I2C chip"
-        depends on LEDS_CLASS
-        depends on I2C
-        help
-          This option enables support for LEDs connected to the PCA9633
-          LED driver chip accessed via the I2C bus.
-
 config LEDS_WM831X_STATUS
         tristate "LED support for status LEDs on WM831x PMICs"
         depends on LEDS_CLASS
@@ -291,14 +276,6 @@ config LEDS_DA903X
           This option enables support for on-chip LED drivers found
           on Dialog Semiconductor DA9030/DA9034 PMICs.
 
-config LEDS_DA9052
-        tristate "Dialog DA9052/DA9053 LEDS"
-        depends on LEDS_CLASS
-        depends on PMIC_DA9052
-        help
-          This option enables support for on-chip LED drivers found
-          on Dialog Semiconductor DA9052-BC and DA9053-AA/Bx PMICs.
-
 config LEDS_DAC124S085
         tristate "LED Support for DAC124S085 SPI DAC"
         depends on LEDS_CLASS
@@ -378,10 +355,7 @@ config LEDS_MC13783
 config LEDS_NS2
         tristate "LED support for Network Space v2 GPIO LEDs"
         depends on LEDS_CLASS
-        depends on MACH_NETSPACE_V2 || MACH_INETSPACE_V2 || \
-                   MACH_NETSPACE_MAX_V2 || MACH_D2NET_V2 || \
-                   MACH_NETSPACE_V2_DT || MACH_INETSPACE_V2_DT || \
-                   MACH_NETSPACE_MAX_V2_DT || MACH_NETSPACE_MINI_V2_DT
+        depends on MACH_NETSPACE_V2 || MACH_INETSPACE_V2 || MACH_NETSPACE_MAX_V2 || D2NET_V2
         default y
         help
           This option enable support for the dual-GPIO LED found on the
@@ -400,7 +374,7 @@ config LEDS_NETXBIG
 
 config LEDS_ASIC3
         bool "LED support for the HTC ASIC3"
-        depends on LEDS_CLASS=y
+        depends on LEDS_CLASS
         depends on MFD_ASIC3
         default y
         help
@@ -409,56 +383,6 @@ config LEDS_ASIC3
           cannot be used. This driver supports hardware blinking with an on+off
           period from 62ms to 125s. Say Y to enable LEDs on the HP iPAQ hx4700.
 
-config LEDS_RENESAS_TPU
-        bool "LED support for Renesas TPU"
-        depends on LEDS_CLASS=y && HAVE_CLK && GENERIC_GPIO
-        help
-          This option enables build of the LED TPU platform driver,
-          suitable to drive any TPU channel on newer Renesas SoCs.
-          The driver controls the GPIO pin connected to the LED via
-          the GPIO framework and expects the LED to be connected to
-          a pin that can be driven in both GPIO mode and using TPU
-          pin function. The latter to support brightness control.
-          Brightness control is supported but hardware blinking is not.
-
-config LEDS_TCA6507
-        tristate "LED Support for TCA6507 I2C chip"
-        depends on LEDS_CLASS && I2C
-        help
-          This option enables support for LEDs connected to TC6507
-          LED driver chips accessed via the I2C bus.
-          Driver support brightness control and hardware-assisted blinking.
-
-config LEDS_MAX8997
-        tristate "LED support for MAX8997 PMIC"
-        depends on LEDS_CLASS && MFD_MAX8997
-        help
-          This option enables support for on-chip LED drivers on
-          MAXIM MAX8997 PMIC.
-
-config LEDS_LM355x
-        tristate "LED support for LM355x Chips, LM3554 and LM3556"
-        depends on LEDS_CLASS && I2C
-        select REGMAP_I2C
-        help
-          This option enables support for LEDs connected to LM355x.
-          LM355x includes Torch, Flash and Indicator functions.
-
-config LEDS_OT200
-        tristate "LED support for the Bachmann OT200"
-        depends on LEDS_CLASS && HAS_IOMEM
-        help
-          This option enables support for the LEDs on the Bachmann OT200.
-          Say Y to enable LEDs on the Bachmann OT200.
-
-config LEDS_BLINKM
-        tristate "LED support for the BlinkM I2C RGB LED"
-        depends on LEDS_CLASS
-        depends on I2C
-        help
-          This option enables support for the BlinkM RGB LED connected
-          through I2C. Say Y to enable support for the BlinkM LED.
-
 config LEDS_TRIGGERS
         bool "LED Trigger support"
         depends on LEDS_CLASS
@@ -476,21 +400,7 @@ config LEDS_TRIGGER_TIMER
           This allows LEDs to be controlled by a programmable timer
           via sysfs. Some LED hardware can be programmed to start
           blinking the LED without any further software interaction.
-          For more details read Documentation/leds/leds-class.txt.
-
-          If unsure, say Y.
-
-config LEDS_TRIGGER_ONESHOT
-        tristate "LED One-shot Trigger"
-        depends on LEDS_TRIGGERS
-        help
-          This allows LEDs to blink in one-shot pulses with parameters
-          controlled via sysfs.  It's useful to notify the user on
-          sporadic events, when there are no clear begin and end trap points,
-          or on dense events, where this blinks the LED at constant rate if
-          rearmed continuously.
-
-          It also shows how to use the led_blink_set_oneshot() function.
+          For more details read Documentation/leds-class.txt.
 
           If unsure, say Y.
 
@@ -520,16 +430,6 @@ config LEDS_TRIGGER_BACKLIGHT
 
           If unsure, say N.
 
-config LEDS_TRIGGER_CPU
-        bool "LED CPU Trigger"
-        depends on LEDS_TRIGGERS
-        help
-          This allows LEDs to be controlled by active CPUs. This shows
-          the active CPUs across an array of LEDs so you can see which
-          CPUs are active on the system at any given moment.
-
-          If unsure, say N.
-
 config LEDS_TRIGGER_GPIO
         tristate "LED GPIO Trigger"
         depends on LEDS_TRIGGERS
@@ -550,15 +450,13 @@ config LEDS_TRIGGER_DEFAULT_ON
           This allows LEDs to be initialised in the ON state.
           If unsure, say Y.
 
-comment "iptables trigger is under Netfilter config (LED target)"
-        depends on LEDS_TRIGGERS
+config LEDS_TRIGGER_SLEEP
+        tristate "LED Sleep Mode Trigger"
+        depends on LEDS_TRIGGERS && HAS_EARLYSUSPEND
+        help
+          This turns LEDs on when the screen is off but the cpu still running.
 
-config LEDS_TRIGGER_TRANSIENT
-        tristate "LED Transient Trigger"
+comment "iptables trigger is under Netfilter config (LED target)"
         depends on LEDS_TRIGGERS
-        help
-          This allows one time activation of a transient state on
-          GPIO/PWM based hardware.
-          If unsure, say Y.
 
 endif # NEW_LEDS
diff --git a/drivers/leds/Makefile b/drivers/leds/Makefile
index 3fb9641b619..cb77b9bb2f9 100644
--- a/drivers/leds/Makefile
+++ b/drivers/leds/Makefile
@@ -10,12 +10,13 @@ obj-$(CONFIG_LEDS_ATMEL_PWM)		+= leds-atmel-pwm.o
 obj-$(CONFIG_LEDS_BD2802)               += leds-bd2802.o
 obj-$(CONFIG_LEDS_LOCOMO)               += leds-locomo.o
 obj-$(CONFIG_LEDS_LM3530)               += leds-lm3530.o
-obj-$(CONFIG_LEDS_LM3533)               += leds-lm3533.o
-obj-$(CONFIG_LEDS_LM3642)               += leds-lm3642.o
 obj-$(CONFIG_LEDS_MIKROTIK_RB532)       += leds-rb532.o
 obj-$(CONFIG_LEDS_S3C24XX)              += leds-s3c24xx.o
+obj-$(CONFIG_LEDS_AMS_DELTA)            += leds-ams-delta.o
 obj-$(CONFIG_LEDS_NET48XX)              += leds-net48xx.o
+obj-$(CONFIG_LEDS_NET5501)              += leds-net5501.o
 obj-$(CONFIG_LEDS_WRAP)                 += leds-wrap.o
+obj-$(CONFIG_LEDS_ALIX2)                += leds-alix2.o
 obj-$(CONFIG_LEDS_COBALT_QUBE)          += leds-cobalt-qube.o
 obj-$(CONFIG_LEDS_COBALT_RAQ)           += leds-cobalt-raq.o
 obj-$(CONFIG_LEDS_SUNFIRE)              += leds-sunfire.o
@@ -25,16 +26,11 @@ obj-$(CONFIG_LEDS_GPIO)			+= leds-gpio.o
 obj-$(CONFIG_LEDS_LP3944)               += leds-lp3944.o
 obj-$(CONFIG_LEDS_LP5521)               += leds-lp5521.o
 obj-$(CONFIG_LEDS_LP5523)               += leds-lp5523.o
-obj-$(CONFIG_LEDS_LP8788)               += leds-lp8788.o
-obj-$(CONFIG_LEDS_TCA6507)              += leds-tca6507.o
 obj-$(CONFIG_LEDS_CLEVO_MAIL)           += leds-clevo-mail.o
 obj-$(CONFIG_LEDS_HP6XX)                += leds-hp6xx.o
-obj-$(CONFIG_LEDS_OT200)                += leds-ot200.o
 obj-$(CONFIG_LEDS_FSG)                  += leds-fsg.o
 obj-$(CONFIG_LEDS_PCA955X)              += leds-pca955x.o
-obj-$(CONFIG_LEDS_PCA9633)              += leds-pca9633.o
 obj-$(CONFIG_LEDS_DA903X)               += leds-da903x.o
-obj-$(CONFIG_LEDS_DA9052)               += leds-da9052.o
 obj-$(CONFIG_LEDS_WM831X_STATUS)        += leds-wm831x-status.o
 obj-$(CONFIG_LEDS_WM8350)               += leds-wm8350.o
 obj-$(CONFIG_LEDS_PWM)                  += leds-pwm.o
@@ -47,21 +43,15 @@ obj-$(CONFIG_LEDS_MC13783)		+= leds-mc13783.o
 obj-$(CONFIG_LEDS_NS2)                  += leds-ns2.o
 obj-$(CONFIG_LEDS_NETXBIG)              += leds-netxbig.o
 obj-$(CONFIG_LEDS_ASIC3)                += leds-asic3.o
-obj-$(CONFIG_LEDS_RENESAS_TPU)          += leds-renesas-tpu.o
-obj-$(CONFIG_LEDS_MAX8997)              += leds-max8997.o
-obj-$(CONFIG_LEDS_LM355x)               += leds-lm355x.o
-obj-$(CONFIG_LEDS_BLINKM)               += leds-blinkm.o
 
 # LED SPI Drivers
 obj-$(CONFIG_LEDS_DAC124S085)           += leds-dac124s085.o
 
 # LED Triggers
 obj-$(CONFIG_LEDS_TRIGGER_TIMER)        += ledtrig-timer.o
-obj-$(CONFIG_LEDS_TRIGGER_ONESHOT)      += ledtrig-oneshot.o
 obj-$(CONFIG_LEDS_TRIGGER_IDE_DISK)     += ledtrig-ide-disk.o
 obj-$(CONFIG_LEDS_TRIGGER_HEARTBEAT)    += ledtrig-heartbeat.o
 obj-$(CONFIG_LEDS_TRIGGER_BACKLIGHT)    += ledtrig-backlight.o
 obj-$(CONFIG_LEDS_TRIGGER_GPIO)         += ledtrig-gpio.o
-obj-$(CONFIG_LEDS_TRIGGER_CPU)          += ledtrig-cpu.o
 obj-$(CONFIG_LEDS_TRIGGER_DEFAULT_ON)   += ledtrig-default-on.o
-obj-$(CONFIG_LEDS_TRIGGER_TRANSIENT)    += ledtrig-transient.o
+obj-$(CONFIG_LEDS_TRIGGER_SLEEP)        += ledtrig-sleep.o
diff --git a/drivers/leds/dell-led.c b/drivers/leds/dell-led.c
index e5c57389efd..52590296af3 100644
--- a/drivers/leds/dell-led.c
+++ b/drivers/leds/dell-led.c
@@ -14,7 +14,6 @@
 #include <linux/acpi.h>
 #include <linux/leds.h>
 #include <linux/slab.h>
-#include <linux/module.h>
 
 MODULE_AUTHOR("Louis Davis/Jim Dailey");
 MODULE_DESCRIPTION("Dell LED Control Driver");
diff --git a/drivers/leds/led-class.c b/drivers/leds/led-class.c
index a20752f562b..6d5628bb060 100644
--- a/drivers/leds/led-class.c
+++ b/drivers/leds/led-class.c
@@ -15,6 +15,7 @@
 #include <linux/list.h>
 #include <linux/spinlock.h>
 #include <linux/device.h>
+#include <linux/sysdev.h>
 #include <linux/timer.h>
 #include <linux/err.h>
 #include <linux/ctype.h>
@@ -29,7 +30,7 @@ static void led_update_brightness(struct led_classdev *led_cdev)
                 led_cdev->brightness = led_cdev->brightness_get(led_cdev);
 }
 
-static ssize_t led_brightness_show(struct device *dev,
+static ssize_t led_brightness_show(struct device *dev, 
                 struct device_attribute *attr, char *buf)
 {
         struct led_classdev *led_cdev = dev_get_drvdata(dev);
@@ -44,18 +45,23 @@ static ssize_t led_brightness_store(struct device *dev,
                 struct device_attribute *attr, const char *buf, size_t size)
 {
         struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        unsigned long state;
         ssize_t ret = -EINVAL;
+        char *after;
+        unsigned long state = simple_strtoul(buf, &after, 10);
+        size_t count = after - buf;
 
-        ret = kstrtoul(buf, 10, &state);
-        if (ret)
-                return ret;
+        if (isspace(*after))
+                count++;
 
-        if (state == LED_OFF)
-                led_trigger_remove(led_cdev);
-        __led_set_brightness(led_cdev, state);
+        if (count == size) {
+                ret = count;
 
-        return size;
+                if (state == LED_OFF)
+                        led_trigger_remove(led_cdev);
+                led_set_brightness(led_cdev, state);
+        }
+
+        return ret;
 }
 
 static ssize_t led_max_brightness_show(struct device *dev,
@@ -82,12 +88,7 @@ static void led_timer_function(unsigned long data)
         unsigned long delay;
 
         if (!led_cdev->blink_delay_on || !led_cdev->blink_delay_off) {
-                __led_set_brightness(led_cdev, LED_OFF);
-                return;
-        }
-
-        if (led_cdev->flags & LED_BLINK_ONESHOT_STOP) {
-                led_cdev->flags &= ~LED_BLINK_ONESHOT_STOP;
+                led_set_brightness(led_cdev, LED_OFF);
                 return;
         }
 
@@ -105,35 +106,55 @@ static void led_timer_function(unsigned long data)
                 delay = led_cdev->blink_delay_off;
         }
 
-        __led_set_brightness(led_cdev, brightness);
-
-        /* Return in next iteration if led is in one-shot mode and we are in
-         * the final blink state so that the led is toggled each delay_on +
-         * delay_off milliseconds in worst case.
-         */
-        if (led_cdev->flags & LED_BLINK_ONESHOT) {
-                if (led_cdev->flags & LED_BLINK_INVERT) {
-                        if (brightness)
-                                led_cdev->flags |= LED_BLINK_ONESHOT_STOP;
-                } else {
-                        if (!brightness)
-                                led_cdev->flags |= LED_BLINK_ONESHOT_STOP;
-                }
-        }
+        led_set_brightness(led_cdev, brightness);
 
         mod_timer(&led_cdev->blink_timer, jiffies + msecs_to_jiffies(delay));
 }
 
-static void set_brightness_delayed(struct work_struct *ws)
+static void led_stop_software_blink(struct led_classdev *led_cdev)
+{
+        /* deactivate previous settings */
+        del_timer_sync(&led_cdev->blink_timer);
+        led_cdev->blink_delay_on = 0;
+        led_cdev->blink_delay_off = 0;
+}
+
+static void led_set_software_blink(struct led_classdev *led_cdev,
+                                   unsigned long delay_on,
+                                   unsigned long delay_off)
 {
-        struct led_classdev *led_cdev =
-                container_of(ws, struct led_classdev, set_brightness_work);
+        int current_brightness;
+
+        current_brightness = led_get_brightness(led_cdev);
+        if (current_brightness)
+                led_cdev->blink_brightness = current_brightness;
+        if (!led_cdev->blink_brightness)
+                led_cdev->blink_brightness = led_cdev->max_brightness;
+
+        if (led_get_trigger_data(led_cdev) &&
+            delay_on == led_cdev->blink_delay_on &&
+            delay_off == led_cdev->blink_delay_off)
+                return;
 
         led_stop_software_blink(led_cdev);
 
-        __led_set_brightness(led_cdev, led_cdev->delayed_set_value);
+        led_cdev->blink_delay_on = delay_on;
+        led_cdev->blink_delay_off = delay_off;
+
+        /* never on - don't blink */
+        if (!delay_on)
+                return;
+
+        /* never off - just set to brightness */
+        if (!delay_off) {
+                led_set_brightness(led_cdev, led_cdev->blink_brightness);
+                return;
+        }
+
+        mod_timer(&led_cdev->blink_timer, jiffies + 1);
 }
 
+
 /**
  * led_classdev_suspend - suspend an led_classdev.
  * @led_cdev: the led_classdev to suspend.
@@ -201,8 +222,6 @@ int led_classdev_register(struct device *parent, struct led_classdev *led_cdev)
 
         led_update_brightness(led_cdev);
 
-        INIT_WORK(&led_cdev->set_brightness_work, set_brightness_delayed);
-
         init_timer(&led_cdev->blink_timer);
         led_cdev->blink_timer.function = led_timer_function;
         led_cdev->blink_timer.data = (unsigned long)led_cdev;
@@ -211,7 +230,7 @@ int led_classdev_register(struct device *parent, struct led_classdev *led_cdev)
         led_trigger_set_default(led_cdev);
 #endif
 
-        dev_dbg(parent, "Registered led device: %s\n",
+        printk(KERN_DEBUG "Registered led device: %s\n",
                         led_cdev->name);
 
         return 0;
@@ -233,11 +252,8 @@ void led_classdev_unregister(struct led_classdev *led_cdev)
         up_write(&led_cdev->trigger_lock);
 #endif
 
-        cancel_work_sync(&led_cdev->set_brightness_work);
-
         /* Stop blinking */
-        led_stop_software_blink(led_cdev);
-        led_set_brightness(led_cdev, LED_OFF);
+        led_brightness_set(led_cdev, LED_OFF);
 
         device_unregister(led_cdev->dev);
 
@@ -247,6 +263,32 @@ void led_classdev_unregister(struct led_classdev *led_cdev)
 }
 EXPORT_SYMBOL_GPL(led_classdev_unregister);
 
+void led_blink_set(struct led_classdev *led_cdev,
+                   unsigned long *delay_on,
+                   unsigned long *delay_off)
+{
+        del_timer_sync(&led_cdev->blink_timer);
+
+        if (led_cdev->blink_set &&
+            !led_cdev->blink_set(led_cdev, delay_on, delay_off))
+                return;
+
+        /* blink with 1 Hz as default if nothing specified */
+        if (!*delay_on && !*delay_off)
+                *delay_on = *delay_off = 500;
+
+        led_set_software_blink(led_cdev, *delay_on, *delay_off);
+}
+EXPORT_SYMBOL(led_blink_set);
+
+void led_brightness_set(struct led_classdev *led_cdev,
+                        enum led_brightness brightness)
+{
+        led_stop_software_blink(led_cdev);
+        led_cdev->brightness_set(led_cdev, brightness);
+}
+EXPORT_SYMBOL(led_brightness_set);
+
 static int __init leds_init(void)
 {
         leds_class = class_create(THIS_MODULE, "leds");
diff --git a/drivers/leds/led-core.c b/drivers/leds/led-core.c
index ce8921a753a..016d19f5486 100644
--- a/drivers/leds/led-core.c
+++ b/drivers/leds/led-core.c
@@ -23,104 +23,3 @@ EXPORT_SYMBOL_GPL(leds_list_lock);
 
 LIST_HEAD(leds_list);
 EXPORT_SYMBOL_GPL(leds_list);
-
-static void led_set_software_blink(struct led_classdev *led_cdev,
-                                   unsigned long delay_on,
-                                   unsigned long delay_off)
-{
-        int current_brightness;
-
-        current_brightness = led_get_brightness(led_cdev);
-        if (current_brightness)
-                led_cdev->blink_brightness = current_brightness;
-        if (!led_cdev->blink_brightness)
-                led_cdev->blink_brightness = led_cdev->max_brightness;
-
-        led_cdev->blink_delay_on = delay_on;
-        led_cdev->blink_delay_off = delay_off;
-
-        /* never on - don't blink */
-        if (!delay_on)
-                return;
-
-        /* never off - just set to brightness */
-        if (!delay_off) {
-                __led_set_brightness(led_cdev, led_cdev->blink_brightness);
-                return;
-        }
-
-        mod_timer(&led_cdev->blink_timer, jiffies + 1);
-}
-
-
-static void led_blink_setup(struct led_classdev *led_cdev,
-                     unsigned long *delay_on,
-                     unsigned long *delay_off)
-{
-        if (!(led_cdev->flags & LED_BLINK_ONESHOT) &&
-            led_cdev->blink_set &&
-            !led_cdev->blink_set(led_cdev, delay_on, delay_off))
-                return;
-
-        /* blink with 1 Hz as default if nothing specified */
-        if (!*delay_on && !*delay_off)
-                *delay_on = *delay_off = 500;
-
-        led_set_software_blink(led_cdev, *delay_on, *delay_off);
-}
-
-void led_blink_set(struct led_classdev *led_cdev,
-                   unsigned long *delay_on,
-                   unsigned long *delay_off)
-{
-        del_timer_sync(&led_cdev->blink_timer);
-
-        led_cdev->flags &= ~LED_BLINK_ONESHOT;
-        led_cdev->flags &= ~LED_BLINK_ONESHOT_STOP;
-
-        led_blink_setup(led_cdev, delay_on, delay_off);
-}
-EXPORT_SYMBOL(led_blink_set);
-
-void led_blink_set_oneshot(struct led_classdev *led_cdev,
-                           unsigned long *delay_on,
-                           unsigned long *delay_off,
-                           int invert)
-{
-        if ((led_cdev->flags & LED_BLINK_ONESHOT) &&
-             timer_pending(&led_cdev->blink_timer))
-                return;
-
-        led_cdev->flags |= LED_BLINK_ONESHOT;
-        led_cdev->flags &= ~LED_BLINK_ONESHOT_STOP;
-
-        if (invert)
-                led_cdev->flags |= LED_BLINK_INVERT;
-        else
-                led_cdev->flags &= ~LED_BLINK_INVERT;
-
-        led_blink_setup(led_cdev, delay_on, delay_off);
-}
-EXPORT_SYMBOL(led_blink_set_oneshot);
-
-void led_stop_software_blink(struct led_classdev *led_cdev)
-{
-        del_timer_sync(&led_cdev->blink_timer);
-        led_cdev->blink_delay_on = 0;
-        led_cdev->blink_delay_off = 0;
-}
-EXPORT_SYMBOL_GPL(led_stop_software_blink);
-
-void led_set_brightness(struct led_classdev *led_cdev,
-                        enum led_brightness brightness)
-{
-        /* delay brightness setting if need to stop soft-blink timer */
-        if (led_cdev->blink_delay_on || led_cdev->blink_delay_off) {
-                led_cdev->delayed_set_value = brightness;
-                schedule_work(&led_cdev->set_brightness_work);
-                return;
-        }
-
-        __led_set_brightness(led_cdev, brightness);
-}
-EXPORT_SYMBOL(led_set_brightness);
diff --git a/drivers/leds/led-triggers.c b/drivers/leds/led-triggers.c
index 3c972b2f989..4bebae73334 100644
--- a/drivers/leds/led-triggers.c
+++ b/drivers/leds/led-triggers.c
@@ -17,6 +17,7 @@
 #include <linux/list.h>
 #include <linux/spinlock.h>
 #include <linux/device.h>
+#include <linux/sysdev.h>
 #include <linux/timer.h>
 #include <linux/rwsem.h>
 #include <linux/leds.h>
@@ -99,15 +100,9 @@ ssize_t led_trigger_show(struct device *dev, struct device_attribute *attr,
 EXPORT_SYMBOL_GPL(led_trigger_show);
 
 /* Caller must ensure led_cdev->trigger_lock held */
-void led_trigger_set(struct led_classdev *led_cdev, struct led_trigger *trig)
+void led_trigger_set(struct led_classdev *led_cdev, struct led_trigger *trigger)
 {
         unsigned long flags;
-        char *event = NULL;
-        char *envp[2];
-        const char *name;
-
-        name = trig ? trig->name : "none";
-        event = kasprintf(GFP_KERNEL, "TRIGGER=%s", name);
 
         /* Remove any existing trigger */
         if (led_cdev->trigger) {
@@ -115,27 +110,18 @@ void led_trigger_set(struct led_classdev *led_cdev, struct led_trigger *trig)
                 list_del(&led_cdev->trig_list);
                 write_unlock_irqrestore(&led_cdev->trigger->leddev_list_lock,
                         flags);
-                cancel_work_sync(&led_cdev->set_brightness_work);
-                led_stop_software_blink(led_cdev);
                 if (led_cdev->trigger->deactivate)
                         led_cdev->trigger->deactivate(led_cdev);
                 led_cdev->trigger = NULL;
-                led_set_brightness(led_cdev, LED_OFF);
-        }
-        if (trig) {
-                write_lock_irqsave(&trig->leddev_list_lock, flags);
-                list_add_tail(&led_cdev->trig_list, &trig->led_cdevs);
-                write_unlock_irqrestore(&trig->leddev_list_lock, flags);
-                led_cdev->trigger = trig;
-                if (trig->activate)
-                        trig->activate(led_cdev);
+                led_brightness_set(led_cdev, LED_OFF);
         }
-
-        if (event) {
-                envp[0] = event;
-                envp[1] = NULL;
-                kobject_uevent_env(&led_cdev->dev->kobj, KOBJ_CHANGE, envp);
-                kfree(event);
+        if (trigger) {
+                write_lock_irqsave(&trigger->leddev_list_lock, flags);
+                list_add_tail(&led_cdev->trig_list, &trigger->led_cdevs);
+                write_unlock_irqrestore(&trigger->leddev_list_lock, flags);
+                led_cdev->trigger = trigger;
+                if (trigger->activate)
+                        trigger->activate(led_cdev);
         }
 }
 EXPORT_SYMBOL_GPL(led_trigger_set);
@@ -166,39 +152,26 @@ void led_trigger_set_default(struct led_classdev *led_cdev)
 }
 EXPORT_SYMBOL_GPL(led_trigger_set_default);
 
-void led_trigger_rename_static(const char *name, struct led_trigger *trig)
-{
-        /* new name must be on a temporary string to prevent races */
-        BUG_ON(name == trig->name);
-
-        down_write(&triggers_list_lock);
-        /* this assumes that trig->name was originaly allocated to
-         * non constant storage */
-        strcpy((char *)trig->name, name);
-        up_write(&triggers_list_lock);
-}
-EXPORT_SYMBOL_GPL(led_trigger_rename_static);
-
 /* LED Trigger Interface */
 
-int led_trigger_register(struct led_trigger *trig)
+int led_trigger_register(struct led_trigger *trigger)
 {
         struct led_classdev *led_cdev;
-        struct led_trigger *_trig;
+        struct led_trigger *trig;
 
-        rwlock_init(&trig->leddev_list_lock);
-        INIT_LIST_HEAD(&trig->led_cdevs);
+        rwlock_init(&trigger->leddev_list_lock);
+        INIT_LIST_HEAD(&trigger->led_cdevs);
 
         down_write(&triggers_list_lock);
         /* Make sure the trigger's name isn't already in use */
-        list_for_each_entry(_trig, &trigger_list, next_trig) {
-                if (!strcmp(_trig->name, trig->name)) {
+        list_for_each_entry(trig, &trigger_list, next_trig) {
+                if (!strcmp(trig->name, trigger->name)) {
                         up_write(&triggers_list_lock);
                         return -EEXIST;
                 }
         }
         /* Add to the list of led triggers */
-        list_add_tail(&trig->next_trig, &trigger_list);
+        list_add_tail(&trigger->next_trig, &trigger_list);
         up_write(&triggers_list_lock);
 
         /* Register with any LEDs that have this as a default trigger */
@@ -206,8 +179,8 @@ int led_trigger_register(struct led_trigger *trig)
         list_for_each_entry(led_cdev, &leds_list, node) {
                 down_write(&led_cdev->trigger_lock);
                 if (!led_cdev->trigger && led_cdev->default_trigger &&
-                            !strcmp(led_cdev->default_trigger, trig->name))
-                        led_trigger_set(led_cdev, trig);
+                            !strcmp(led_cdev->default_trigger, trigger->name))
+                        led_trigger_set(led_cdev, trigger);
                 up_write(&led_cdev->trigger_lock);
         }
         up_read(&leds_list_lock);
@@ -216,20 +189,20 @@ int led_trigger_register(struct led_trigger *trig)
 }
 EXPORT_SYMBOL_GPL(led_trigger_register);
 
-void led_trigger_unregister(struct led_trigger *trig)
+void led_trigger_unregister(struct led_trigger *trigger)
 {
         struct led_classdev *led_cdev;
 
         /* Remove from the list of led triggers */
         down_write(&triggers_list_lock);
-        list_del(&trig->next_trig);
+        list_del(&trigger->next_trig);
         up_write(&triggers_list_lock);
 
         /* Remove anyone actively using this trigger */
         down_read(&leds_list_lock);
         list_for_each_entry(led_cdev, &leds_list, node) {
                 down_write(&led_cdev->trigger_lock);
-                if (led_cdev->trigger == trig)
+                if (led_cdev->trigger == trigger)
                         led_trigger_set(led_cdev, NULL);
                 up_write(&led_cdev->trigger_lock);
         }
@@ -239,96 +212,71 @@ EXPORT_SYMBOL_GPL(led_trigger_unregister);
 
 /* Simple LED Tigger Interface */
 
-void led_trigger_event(struct led_trigger *trig,
+void led_trigger_event(struct led_trigger *trigger,
                         enum led_brightness brightness)
 {
         struct list_head *entry;
 
-        if (!trig)
+        if (!trigger)
                 return;
 
-        read_lock(&trig->leddev_list_lock);
-        list_for_each(entry, &trig->led_cdevs) {
+        read_lock(&trigger->leddev_list_lock);
+        list_for_each(entry, &trigger->led_cdevs) {
                 struct led_classdev *led_cdev;
 
                 led_cdev = list_entry(entry, struct led_classdev, trig_list);
                 led_set_brightness(led_cdev, brightness);
         }
-        read_unlock(&trig->leddev_list_lock);
+        read_unlock(&trigger->leddev_list_lock);
 }
 EXPORT_SYMBOL_GPL(led_trigger_event);
 
-static void led_trigger_blink_setup(struct led_trigger *trig,
-                             unsigned long *delay_on,
-                             unsigned long *delay_off,
-                             int oneshot,
-                             int invert)
+void led_trigger_blink(struct led_trigger *trigger,
+                       unsigned long *delay_on,
+                       unsigned long *delay_off)
 {
         struct list_head *entry;
 
-        if (!trig)
+        if (!trigger)
                 return;
 
-        read_lock(&trig->leddev_list_lock);
-        list_for_each(entry, &trig->led_cdevs) {
+        read_lock(&trigger->leddev_list_lock);
+        list_for_each(entry, &trigger->led_cdevs) {
                 struct led_classdev *led_cdev;
 
                 led_cdev = list_entry(entry, struct led_classdev, trig_list);
-                if (oneshot)
-                        led_blink_set_oneshot(led_cdev, delay_on, delay_off,
-                                              invert);
-                else
-                        led_blink_set(led_cdev, delay_on, delay_off);
+                led_blink_set(led_cdev, delay_on, delay_off);
         }
-        read_unlock(&trig->leddev_list_lock);
-}
-
-void led_trigger_blink(struct led_trigger *trig,
-                       unsigned long *delay_on,
-                       unsigned long *delay_off)
-{
-        led_trigger_blink_setup(trig, delay_on, delay_off, 0, 0);
+        read_unlock(&trigger->leddev_list_lock);
 }
 EXPORT_SYMBOL_GPL(led_trigger_blink);
 
-void led_trigger_blink_oneshot(struct led_trigger *trig,
-                               unsigned long *delay_on,
-                               unsigned long *delay_off,
-                               int invert)
-{
-        led_trigger_blink_setup(trig, delay_on, delay_off, 1, invert);
-}
-EXPORT_SYMBOL_GPL(led_trigger_blink_oneshot);
-
 void led_trigger_register_simple(const char *name, struct led_trigger **tp)
 {
-        struct led_trigger *trig;
+        struct led_trigger *trigger;
         int err;
 
-        trig = kzalloc(sizeof(struct led_trigger), GFP_KERNEL);
+        trigger = kzalloc(sizeof(struct led_trigger), GFP_KERNEL);
 
-        if (trig) {
-                trig->name = name;
-                err = led_trigger_register(trig);
-                if (err < 0) {
-                        kfree(trig);
-                        trig = NULL;
-                        pr_warn("LED trigger %s failed to register (%d)\n",
-                                name, err);
-                }
-        } else {
-                pr_warn("LED trigger %s failed to register (no memory)\n",
-                        name);
-        }
-        *tp = trig;
+        if (trigger) {
+                trigger->name = name;
+                err = led_trigger_register(trigger);
+                if (err < 0)
+                        printk(KERN_WARNING "LED trigger %s failed to register"
+                                " (%d)\n", name, err);
+        } else
+                printk(KERN_WARNING "LED trigger %s failed to register"
+                        " (no memory)\n", name);
+
+        *tp = trigger;
 }
 EXPORT_SYMBOL_GPL(led_trigger_register_simple);
 
-void led_trigger_unregister_simple(struct led_trigger *trig)
+void led_trigger_unregister_simple(struct led_trigger *trigger)
 {
-        if (trig)
-                led_trigger_unregister(trig);
-        kfree(trig);
+        if (trigger)
+                led_trigger_unregister(trigger);
+        kfree(trigger);
 }
 EXPORT_SYMBOL_GPL(led_trigger_unregister_simple);
 
diff --git a/drivers/leds/leds-88pm860x.c b/drivers/leds/leds-88pm860x.c
index 6be2edd4117..0d4c16678ac 100644
--- a/drivers/leds/leds-88pm860x.c
+++ b/drivers/leds/leds-88pm860x.c
@@ -12,21 +12,25 @@
 
 #include <linux/kernel.h>
 #include <linux/init.h>
-#include <linux/of.h>
 #include <linux/platform_device.h>
 #include <linux/i2c.h>
 #include <linux/leds.h>
 #include <linux/slab.h>
 #include <linux/workqueue.h>
 #include <linux/mfd/88pm860x.h>
-#include <linux/module.h>
 
+#define LED_PWM_SHIFT           (3)
 #define LED_PWM_MASK            (0x1F)
 #define LED_CURRENT_MASK        (0x07 << 5)
 
+#define LED_BLINK_ON_MASK       (0x07)
 #define LED_BLINK_MASK          (0x7F)
 
+#define LED_BLINK_ON(x)         ((x & 0x7) * 66 + 66)
+#define LED_BLINK_ON_MIN        LED_BLINK_ON(0)
+#define LED_BLINK_ON_MAX        LED_BLINK_ON(0x7)
 #define LED_ON_CONTINUOUS       (0x0F << 3)
+#define LED_TO_ON(x)            ((x - 66) / 66)
 
 #define LED1_BLINK_EN           (1 << 1)
 #define LED2_BLINK_EN           (1 << 2)
@@ -44,27 +48,66 @@ struct pm860x_led {
         unsigned char brightness;
         unsigned char current_brightness;
 
-        int reg_control;
-        int reg_blink;
-        int blink_mask;
+        int blink_data;
+        int blink_time;
+        int blink_on;
+        int blink_off;
 };
 
-static int led_power_set(struct pm860x_chip *chip, int port, int on)
+/* return offset of color register */
+static inline int __led_off(int port)
 {
         int ret = -EINVAL;
 
         switch (port) {
-        case 0:
-        case 1:
-        case 2:
-                ret = on ? pm8606_osc_enable(chip, RGB1_ENABLE) :
-                        pm8606_osc_disable(chip, RGB1_ENABLE);
+        case PM8606_LED1_RED:
+        case PM8606_LED1_GREEN:
+        case PM8606_LED1_BLUE:
+                ret = port - PM8606_LED1_RED + PM8606_RGB1B;
                 break;
-        case 3:
-        case 4:
-        case 5:
-                ret = on ? pm8606_osc_enable(chip, RGB2_ENABLE) :
-                        pm8606_osc_disable(chip, RGB2_ENABLE);
+        case PM8606_LED2_RED:
+        case PM8606_LED2_GREEN:
+        case PM8606_LED2_BLUE:
+                ret = port - PM8606_LED2_RED + PM8606_RGB2B;
+                break;
+        }
+        return ret;
+}
+
+/* return offset of blink register */
+static inline int __blink_off(int port)
+{
+        int ret = -EINVAL;
+
+        switch (port) {
+        case PM8606_LED1_RED:
+        case PM8606_LED1_GREEN:
+        case PM8606_LED1_BLUE:
+                ret = PM8606_RGB1A;
+                break;
+        case PM8606_LED2_RED:
+        case PM8606_LED2_GREEN:
+        case PM8606_LED2_BLUE:
+                ret = PM8606_RGB2A;
+                break;
+        }
+        return ret;
+}
+
+static inline int __blink_ctl_mask(int port)
+{
+        int ret = -EINVAL;
+
+        switch (port) {
+        case PM8606_LED1_RED:
+        case PM8606_LED1_GREEN:
+        case PM8606_LED1_BLUE:
+                ret = LED1_BLINK_EN;
+                break;
+        case PM8606_LED2_RED:
+        case PM8606_LED2_GREEN:
+        case PM8606_LED2_BLUE:
+                ret = LED2_BLINK_EN;
                 break;
         }
         return ret;
@@ -76,42 +119,40 @@ static void pm860x_led_work(struct work_struct *work)
         struct pm860x_led *led;
         struct pm860x_chip *chip;
         unsigned char buf[3];
-        int ret;
+        int mask, ret;
 
         led = container_of(work, struct pm860x_led, work);
         chip = led->chip;
         mutex_lock(&led->lock);
         if ((led->current_brightness == 0) && led->brightness) {
-                led_power_set(chip, led->port, 1);
                 if (led->iset) {
-                        pm860x_set_bits(led->i2c, led->reg_control,
+                        pm860x_set_bits(led->i2c, __led_off(led->port),
                                         LED_CURRENT_MASK, led->iset);
                 }
-                pm860x_set_bits(led->i2c, led->reg_blink,
+                pm860x_set_bits(led->i2c, __blink_off(led->port),
                                 LED_BLINK_MASK, LED_ON_CONTINUOUS);
-                pm860x_set_bits(led->i2c, PM8606_WLED3B, led->blink_mask,
-                                led->blink_mask);
+                mask = __blink_ctl_mask(led->port);
+                pm860x_set_bits(led->i2c, PM8606_WLED3B, mask, mask);
         }
-        pm860x_set_bits(led->i2c, led->reg_control, LED_PWM_MASK,
+        pm860x_set_bits(led->i2c, __led_off(led->port), LED_PWM_MASK,
                         led->brightness);
 
         if (led->brightness == 0) {
-                pm860x_bulk_read(led->i2c, led->reg_control, 3, buf);
+                pm860x_bulk_read(led->i2c, __led_off(led->port), 3, buf);
                 ret = buf[0] & LED_PWM_MASK;
                 ret |= buf[1] & LED_PWM_MASK;
                 ret |= buf[2] & LED_PWM_MASK;
                 if (ret == 0) {
                         /* unset current since no led is lighting */
-                        pm860x_set_bits(led->i2c, led->reg_control,
+                        pm860x_set_bits(led->i2c, __led_off(led->port),
                                         LED_CURRENT_MASK, 0);
-                        pm860x_set_bits(led->i2c, PM8606_WLED3B,
-                                        led->blink_mask, 0);
-                        led_power_set(chip, led->port, 0);
+                        mask = __blink_ctl_mask(led->port);
+                        pm860x_set_bits(led->i2c, PM8606_WLED3B, mask, 0);
                 }
         }
         led->current_brightness = led->brightness;
         dev_dbg(chip->dev, "Update LED. (reg:%d, brightness:%d)\n",
-                led->reg_control, led->brightness);
+                __led_off(led->port), led->brightness);
         mutex_unlock(&led->lock);
 }
 
@@ -124,90 +165,40 @@ static void pm860x_led_set(struct led_classdev *cdev,
         schedule_work(&data->work);
 }
 
-#ifdef CONFIG_OF
-static int pm860x_led_dt_init(struct platform_device *pdev,
-                              struct pm860x_led *data)
-{
-        struct device_node *nproot = pdev->dev.parent->of_node, *np;
-        int iset = 0;
-        if (!nproot)
-                return -ENODEV;
-        nproot = of_find_node_by_name(nproot, "leds");
-        if (!nproot) {
-                dev_err(&pdev->dev, "failed to find leds node\n");
-                return -ENODEV;
-        }
-        for_each_child_of_node(nproot, np) {
-                if (!of_node_cmp(np->name, data->name)) {
-                        of_property_read_u32(np, "marvell,88pm860x-iset",
-                                             &iset);
-                        data->iset = PM8606_LED_CURRENT(iset);
-                        break;
-                }
-        }
-        return 0;
-}
-#else
-#define pm860x_led_dt_init(x, y)        (-1)
-#endif
-
 static int pm860x_led_probe(struct platform_device *pdev)
 {
         struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent);
-        struct pm860x_led_pdata *pdata = pdev->dev.platform_data;
+        struct pm860x_led_pdata *pdata;
         struct pm860x_led *data;
         struct resource *res;
-        int ret = 0;
+        int ret;
 
-        data = devm_kzalloc(&pdev->dev, sizeof(struct pm860x_led), GFP_KERNEL);
-        if (data == NULL)
-                return -ENOMEM;
-        res = platform_get_resource_byname(pdev, IORESOURCE_REG, "control");
-        if (!res) {
-                dev_err(&pdev->dev, "No REG resource for control\n");
-                return -ENXIO;
+        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
+        if (res == NULL) {
+                dev_err(&pdev->dev, "No I/O resource!\n");
+                return -EINVAL;
         }
-        data->reg_control = res->start;
-        res = platform_get_resource_byname(pdev, IORESOURCE_REG, "blink");
-        if (!res) {
-                dev_err(&pdev->dev, "No REG resource for blink\n");
-                return -ENXIO;
-        }
-        data->reg_blink = res->start;
-        memset(data->name, 0, MFD_NAME_SIZE);
-        switch (pdev->id) {
-        case 0:
-                data->blink_mask = LED1_BLINK_EN;
-                sprintf(data->name, "led0-red");
-                break;
-        case 1:
-                data->blink_mask = LED1_BLINK_EN;
-                sprintf(data->name, "led0-green");
-                break;
-        case 2:
-                data->blink_mask = LED1_BLINK_EN;
-                sprintf(data->name, "led0-blue");
-                break;
-        case 3:
-                data->blink_mask = LED2_BLINK_EN;
-                sprintf(data->name, "led1-red");
-                break;
-        case 4:
-                data->blink_mask = LED2_BLINK_EN;
-                sprintf(data->name, "led1-green");
-                break;
-        case 5:
-                data->blink_mask = LED2_BLINK_EN;
-                sprintf(data->name, "led1-blue");
-                break;
+
+        pdata = pdev->dev.platform_data;
+        if (pdata == NULL) {
+                dev_err(&pdev->dev, "No platform data!\n");
+                return -EINVAL;
         }
+
+        data = kzalloc(sizeof(struct pm860x_led), GFP_KERNEL);
+        if (data == NULL)
+                return -ENOMEM;
+        strncpy(data->name, res->name, MFD_NAME_SIZE - 1);
         dev_set_drvdata(&pdev->dev, data);
         data->chip = chip;
         data->i2c = (chip->id == CHIP_PM8606) ? chip->client : chip->companion;
-        data->port = pdev->id;
-        if (pm860x_led_dt_init(pdev, data))
-                if (pdata)
-                        data->iset = pdata->iset;
+        data->iset = pdata->iset;
+        data->port = pdata->flags;
+        if (data->port < 0) {
+                dev_err(&pdev->dev, "check device failed\n");
+                kfree(data);
+                return -EINVAL;
+        }
 
         data->current_brightness = 0;
         data->cdev.name = data->name;
@@ -218,10 +209,13 @@ static int pm860x_led_probe(struct platform_device *pdev)
         ret = led_classdev_register(chip->dev, &data->cdev);
         if (ret < 0) {
                 dev_err(&pdev->dev, "Failed to register LED: %d\n", ret);
-                return ret;
+                goto out;
         }
         pm860x_led_set(&data->cdev, 0);
         return 0;
+out:
+        kfree(data);
+        return ret;
 }
 
 static int pm860x_led_remove(struct platform_device *pdev)
@@ -229,6 +223,7 @@ static int pm860x_led_remove(struct platform_device *pdev)
         struct pm860x_led *data = platform_get_drvdata(pdev);
 
         led_classdev_unregister(&data->cdev);
+        kfree(data);
 
         return 0;
 }
@@ -242,7 +237,17 @@ static struct platform_driver pm860x_led_driver = {
         .remove = pm860x_led_remove,
 };
 
-module_platform_driver(pm860x_led_driver);
+static int __devinit pm860x_led_init(void)
+{
+        return platform_driver_register(&pm860x_led_driver);
+}
+module_init(pm860x_led_init);
+
+static void __devexit pm860x_led_exit(void)
+{
+        platform_driver_unregister(&pm860x_led_driver);
+}
+module_exit(pm860x_led_exit);
 
 MODULE_DESCRIPTION("LED driver for Marvell PM860x");
 MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
diff --git a/drivers/leds/leds-adp5520.c b/drivers/leds/leds-adp5520.c
index e8072abe76e..7ba4c7b5b97 100644
--- a/drivers/leds/leds-adp5520.c
+++ b/drivers/leds/leds-adp5520.c
@@ -5,10 +5,10 @@
  *
  * Loosely derived from leds-da903x:
  * Copyright (C) 2008 Compulab, Ltd.
- *      Mike Rapoport <mike@compulab.co.il>
+ *      Mike Rapoport <mike@compulab.co.il>
  *
  * Copyright (C) 2006-2008 Marvell International Ltd.
- *      Eric Miao <eric.miao@marvell.com>
+ *      Eric Miao <eric.miao@marvell.com>
  *
  * Licensed under the GPL-2 or later.
  */
@@ -85,7 +85,7 @@ static int adp5520_led_setup(struct adp5520_led *led)
         return ret;
 }
 
-static int adp5520_led_prepare(struct platform_device *pdev)
+static int __devinit adp5520_led_prepare(struct platform_device *pdev)
 {
         struct adp5520_leds_platform_data *pdata = pdev->dev.platform_data;
         struct device *dev = pdev->dev.parent;
@@ -101,7 +101,7 @@ static int adp5520_led_prepare(struct platform_device *pdev)
         return ret;
 }
 
-static int adp5520_led_probe(struct platform_device *pdev)
+static int __devinit adp5520_led_probe(struct platform_device *pdev)
 {
         struct adp5520_leds_platform_data *pdata = pdev->dev.platform_data;
         struct adp5520_led *led, *led_dat;
@@ -119,8 +119,7 @@ static int adp5520_led_probe(struct platform_device *pdev)
                 return -EFAULT;
         }
 
-        led = devm_kzalloc(&pdev->dev, sizeof(*led) * pdata->num_leds,
-                                GFP_KERNEL);
+        led = kzalloc(sizeof(*led) * pdata->num_leds, GFP_KERNEL);
         if (led == NULL) {
                 dev_err(&pdev->dev, "failed to alloc memory\n");
                 return -ENOMEM;
@@ -130,7 +129,7 @@ static int adp5520_led_probe(struct platform_device *pdev)
 
         if (ret) {
                 dev_err(&pdev->dev, "failed to write\n");
-                return ret;
+                goto err_free;
         }
 
         for (i = 0; i < pdata->num_leds; ++i) {
@@ -180,10 +179,12 @@ err:
                 }
         }
 
+err_free:
+        kfree(led);
         return ret;
 }
 
-static int adp5520_led_remove(struct platform_device *pdev)
+static int __devexit adp5520_led_remove(struct platform_device *pdev)
 {
         struct adp5520_leds_platform_data *pdata = pdev->dev.platform_data;
         struct adp5520_led *led;
@@ -199,6 +200,7 @@ static int adp5520_led_remove(struct platform_device *pdev)
                 cancel_work_sync(&led[i].work);
         }
 
+        kfree(led);
         return 0;
 }
 
@@ -208,10 +210,20 @@ static struct platform_driver adp5520_led_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe          = adp5520_led_probe,
-        .remove         = adp5520_led_remove,
+        .remove         = __devexit_p(adp5520_led_remove),
 };
 
-module_platform_driver(adp5520_led_driver);
+static int __init adp5520_led_init(void)
+{
+        return platform_driver_register(&adp5520_led_driver);
+}
+module_init(adp5520_led_init);
+
+static void __exit adp5520_led_exit(void)
+{
+        platform_driver_unregister(&adp5520_led_driver);
+}
+module_exit(adp5520_led_exit);
 
 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 MODULE_DESCRIPTION("LEDS ADP5520(01) Driver");
diff --git a/drivers/leds/leds-asic3.c b/drivers/leds/leds-asic3.c
index b474745e001..22f847c890c 100644
--- a/drivers/leds/leds-asic3.c
+++ b/drivers/leds/leds-asic3.c
@@ -14,7 +14,6 @@
 
 #include <linux/mfd/asic3.h>
 #include <linux/mfd/core.h>
-#include <linux/module.h>
 
 /*
  *      The HTC ASIC3 LED GPIOs are inputs, not outputs.
@@ -92,92 +91,75 @@ static int blink_set(struct led_classdev *cdev,
         return 0;
 }
 
-static int asic3_led_probe(struct platform_device *pdev)
+static int __devinit asic3_led_probe(struct platform_device *pdev)
 {
         struct asic3_led *led = pdev->dev.platform_data;
         int ret;
 
         ret = mfd_cell_enable(pdev);
         if (ret < 0)
-                return ret;
+                goto ret0;
 
-        led->cdev = devm_kzalloc(&pdev->dev, sizeof(struct led_classdev),
-                                GFP_KERNEL);
+        led->cdev = kzalloc(sizeof(struct led_classdev), GFP_KERNEL);
         if (!led->cdev) {
                 ret = -ENOMEM;
-                goto out;
+                goto ret1;
         }
 
         led->cdev->name = led->name;
-        led->cdev->flags = LED_CORE_SUSPENDRESUME;
+        led->cdev->default_trigger = led->default_trigger;
         led->cdev->brightness_set = brightness_set;
         led->cdev->blink_set = blink_set;
-        led->cdev->default_trigger = led->default_trigger;
 
         ret = led_classdev_register(&pdev->dev, led->cdev);
         if (ret < 0)
-                goto out;
+                goto ret2;
 
         return 0;
 
-out:
+ret2:
+        kfree(led->cdev);
+ret1:
         (void) mfd_cell_disable(pdev);
+ret0:
         return ret;
 }
 
-static int asic3_led_remove(struct platform_device *pdev)
+static int __devexit asic3_led_remove(struct platform_device *pdev)
 {
         struct asic3_led *led = pdev->dev.platform_data;
 
         led_classdev_unregister(led->cdev);
 
-        return mfd_cell_disable(pdev);
-}
-
-static int asic3_led_suspend(struct device *dev)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        const struct mfd_cell *cell = mfd_get_cell(pdev);
-        int ret;
-
-        ret = 0;
-        if (cell->suspend)
-                ret = (*cell->suspend)(pdev);
-
-        return ret;
-}
-
-static int asic3_led_resume(struct device *dev)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        const struct mfd_cell *cell = mfd_get_cell(pdev);
-        int ret;
-
-        ret = 0;
-        if (cell->resume)
-                ret = (*cell->resume)(pdev);
+        kfree(led->cdev);
 
-        return ret;
+        return mfd_cell_disable(pdev);
 }
 
-static const struct dev_pm_ops asic3_led_pm_ops = {
-        .suspend        = asic3_led_suspend,
-        .resume         = asic3_led_resume,
-};
-
 static struct platform_driver asic3_led_driver = {
         .probe          = asic3_led_probe,
-        .remove         = asic3_led_remove,
+        .remove         = __devexit_p(asic3_led_remove),
         .driver         = {
                 .name   = "leds-asic3",
                 .owner  = THIS_MODULE,
-                .pm     = &asic3_led_pm_ops,
         },
 };
 
-module_platform_driver(asic3_led_driver);
+MODULE_ALIAS("platform:leds-asic3");
+
+static int __init asic3_led_init(void)
+{
+        return platform_driver_register(&asic3_led_driver);
+}
+
+static void __exit asic3_led_exit(void)
+{
+        platform_driver_unregister(&asic3_led_driver);
+}
+
+module_init(asic3_led_init);
+module_exit(asic3_led_exit);
 
 MODULE_AUTHOR("Paul Parsons <lost.distance@yahoo.com>");
 MODULE_DESCRIPTION("HTC ASIC3 LED driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:leds-asic3");
diff --git a/drivers/leds/leds-atmel-pwm.c b/drivers/leds/leds-atmel-pwm.c
index 386773532d9..c941d906bba 100644
--- a/drivers/leds/leds-atmel-pwm.c
+++ b/drivers/leds/leds-atmel-pwm.c
@@ -4,7 +4,6 @@
 #include <linux/io.h>
 #include <linux/atmel_pwm.h>
 #include <linux/slab.h>
-#include <linux/module.h>
 
 
 struct pwmled {
@@ -35,7 +34,7 @@ static void pwmled_brightness(struct led_classdev *cdev, enum led_brightness b)
  * NOTE:  we reuse the platform_data structure of GPIO leds,
  * but repurpose its "gpio" number as a PWM channel number.
  */
-static int pwmled_probe(struct platform_device *pdev)
+static int __init pwmled_probe(struct platform_device *pdev)
 {
         const struct gpio_led_platform_data     *pdata;
         struct pwmled                           *leds;
@@ -46,8 +45,7 @@ static int pwmled_probe(struct platform_device *pdev)
         if (!pdata || pdata->num_leds < 1)
                 return -ENODEV;
 
-        leds = devm_kzalloc(&pdev->dev, pdata->num_leds * sizeof(*leds),
-                        GFP_KERNEL);
+        leds = kcalloc(pdata->num_leds, sizeof(*leds), GFP_KERNEL);
         if (!leds)
                 return -ENOMEM;
 
@@ -109,6 +107,7 @@ err:
                         pwm_channel_free(&leds[i].pwmc);
                 }
         }
+        kfree(leds);
 
         return status;
 }
@@ -129,22 +128,34 @@ static int __exit pwmled_remove(struct platform_device *pdev)
                 pwm_channel_free(&led->pwmc);
         }
 
+        kfree(leds);
         platform_set_drvdata(pdev, NULL);
         return 0;
 }
 
+/* work with hotplug and coldplug */
+MODULE_ALIAS("platform:leds-atmel-pwm");
+
 static struct platform_driver pwmled_driver = {
         .driver = {
                 .name =         "leds-atmel-pwm",
                 .owner =        THIS_MODULE,
         },
         /* REVISIT add suspend() and resume() methods */
-        .probe =        pwmled_probe,
         .remove =       __exit_p(pwmled_remove),
 };
 
-module_platform_driver(pwmled_driver);
+static int __init modinit(void)
+{
+        return platform_driver_probe(&pwmled_driver, pwmled_probe);
+}
+module_init(modinit);
+
+static void __exit modexit(void)
+{
+        platform_driver_unregister(&pwmled_driver);
+}
+module_exit(modexit);
 
 MODULE_DESCRIPTION("Driver for LEDs with PWM-controlled brightness");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:leds-atmel-pwm");
diff --git a/drivers/leds/leds-bd2802.c b/drivers/leds/leds-bd2802.c
index 851517030cc..ea2185531f8 100644
--- a/drivers/leds/leds-bd2802.c
+++ b/drivers/leds/leds-bd2802.c
@@ -26,8 +26,8 @@
 #define BD2802_LED_OFFSET               0xa
 #define BD2802_COLOR_OFFSET             0x3
 
-#define BD2802_REG_CLKSETUP             0x00
-#define BD2802_REG_CONTROL              0x01
+#define BD2802_REG_CLKSETUP             0x00
+#define BD2802_REG_CONTROL              0x01
 #define BD2802_REG_HOURSETUP            0x02
 #define BD2802_REG_CURRENT1SETUP        0x03
 #define BD2802_REG_CURRENT2SETUP        0x04
@@ -93,7 +93,7 @@ struct bd2802_led {
          * In ADF mode, user can set registers of BD2802GU directly,
          * therefore BD2802GU doesn't enter reset state.
          */
-        int                             adf_on;
+        int                             adf_on;
 
         enum led_ids                    led_id;
         enum led_colors                 color;
@@ -328,7 +328,7 @@ static ssize_t bd2802_store_reg##reg_addr(struct device *dev,		\
         int ret;                                                        \
         if (!count)                                                     \
                 return -EINVAL;                                         \
-        ret = kstrtoul(buf, 16, &val);                                  \
+        ret = strict_strtoul(buf, 16, &val);                            \
         if (ret)                                                        \
                 return ret;                                             \
         down_write(&led->rwsem);                                        \
@@ -492,7 +492,7 @@ static ssize_t bd2802_store_##attr_name(struct device *dev,		\
         int ret;                                                        \
         if (!count)                                                     \
                 return -EINVAL;                                         \
-        ret = kstrtoul(buf, 16, &val);                                  \
+        ret = strict_strtoul(buf, 16, &val);                            \
         if (ret)                                                        \
                 return ret;                                             \
         down_write(&led->rwsem);                                        \
@@ -670,14 +670,14 @@ static void bd2802_unregister_led_classdev(struct bd2802_led *led)
         led_classdev_unregister(&led->cdev_led1r);
 }
 
-static int bd2802_probe(struct i2c_client *client,
+static int __devinit bd2802_probe(struct i2c_client *client,
                         const struct i2c_device_id *id)
 {
         struct bd2802_led *led;
         struct bd2802_led_platform_data *pdata;
         int ret, i;
 
-        led = devm_kzalloc(&client->dev, sizeof(struct bd2802_led), GFP_KERNEL);
+        led = kzalloc(sizeof(struct bd2802_led), GFP_KERNEL);
         if (!led) {
                 dev_err(&client->dev, "failed to allocate driver data\n");
                 return -ENOMEM;
@@ -688,7 +688,8 @@ static int bd2802_probe(struct i2c_client *client,
         i2c_set_clientdata(client, led);
 
         /* Configure RESET GPIO (L: RESET, H: RESET cancel) */
-        gpio_request_one(pdata->reset_gpio, GPIOF_OUT_INIT_HIGH, "RGB_RESETB");
+        gpio_request(pdata->reset_gpio, "RGB_RESETB");
+        gpio_direction_output(pdata->reset_gpio, 1);
 
         /* Tacss = min 0.1ms */
         udelay(100);
@@ -697,7 +698,7 @@ static int bd2802_probe(struct i2c_client *client,
         ret = bd2802_write_byte(client, BD2802_REG_CLKSETUP, 0x00);
         if (ret < 0) {
                 dev_err(&client->dev, "failed to detect device\n");
-                return ret;
+                goto failed_free;
         } else
                 dev_info(&client->dev, "return 0x%02x\n", ret);
 
@@ -729,6 +730,9 @@ static int bd2802_probe(struct i2c_client *client,
 failed_unregister_dev_file:
         for (i--; i >= 0; i--)
                 device_remove_file(&led->client->dev, bd2802_attributes[i]);
+failed_free:
+        kfree(led);
+
         return ret;
 }
 
@@ -743,6 +747,7 @@ static int __exit bd2802_remove(struct i2c_client *client)
                 bd2802_disable_adv_conf(led);
         for (i = 0; i < ARRAY_SIZE(bd2802_attributes); i++)
                 device_remove_file(&led->client->dev, bd2802_attributes[i]);
+        kfree(led);
 
         return 0;
 }
@@ -808,7 +813,17 @@ static struct i2c_driver bd2802_i2c_driver = {
         .id_table       = bd2802_id,
 };
 
-module_i2c_driver(bd2802_i2c_driver);
+static int __init bd2802_init(void)
+{
+        return i2c_add_driver(&bd2802_i2c_driver);
+}
+module_init(bd2802_init);
+
+static void __exit bd2802_exit(void)
+{
+        i2c_del_driver(&bd2802_i2c_driver);
+}
+module_exit(bd2802_exit);
 
 MODULE_AUTHOR("Kim Kyuwon <q1.kim@samsung.com>");
 MODULE_DESCRIPTION("BD2802 LED driver");
diff --git a/drivers/leds/leds-blinkm.c b/drivers/leds/leds-blinkm.c
deleted file mode 100644
index a502678cc7f..00000000000
--- a/drivers/leds/leds-blinkm.c
+++ /dev/null
@@ -1,815 +0,0 @@
-/*
- *  leds-blinkm.c
- *  (c) Jan-Simon Möller (dl9pf@gmx.de)
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-#include <linux/jiffies.h>
-#include <linux/i2c.h>
-#include <linux/err.h>
-#include <linux/mutex.h>
-#include <linux/sysfs.h>
-#include <linux/printk.h>
-#include <linux/pm_runtime.h>
-#include <linux/leds.h>
-#include <linux/delay.h>
-
-/* Addresses to scan - BlinkM is on 0x09 by default*/
-static const unsigned short normal_i2c[] = { 0x09, I2C_CLIENT_END };
-
-static int blinkm_transfer_hw(struct i2c_client *client, int cmd);
-static int blinkm_test_run(struct i2c_client *client);
-
-struct blinkm_led {
-        struct i2c_client *i2c_client;
-        struct led_classdev led_cdev;
-        int id;
-        atomic_t active;
-};
-
-struct blinkm_work {
-        struct blinkm_led *blinkm_led;
-        struct work_struct work;
-};
-
-#define cdev_to_blmled(c)          container_of(c, struct blinkm_led, led_cdev)
-#define work_to_blmwork(c)         container_of(c, struct blinkm_work, work)
-
-struct blinkm_data {
-        struct i2c_client *i2c_client;
-        struct mutex update_lock;
-        /* used for led class interface */
-        struct blinkm_led blinkm_leds[3];
-        /* used for "blinkm" sysfs interface */
-        u8 red;                 /* color red */
-        u8 green;               /* color green */
-        u8 blue;                /* color blue */
-        /* next values to use for transfer */
-        u8 next_red;                    /* color red */
-        u8 next_green;          /* color green */
-        u8 next_blue;           /* color blue */
-        /* internal use */
-        u8 args[7];             /* set of args for transmission */
-        u8 i2c_addr;            /* i2c addr */
-        u8 fw_ver;              /* firmware version */
-        /* used, but not from userspace */
-        u8 hue;                 /* HSB  hue */
-        u8 saturation;          /* HSB  saturation */
-        u8 brightness;          /* HSB  brightness */
-        u8 next_hue;                    /* HSB  hue */
-        u8 next_saturation;             /* HSB  saturation */
-        u8 next_brightness;             /* HSB  brightness */
-        /* currently unused / todo */
-        u8 fade_speed;          /* fade speed     1 - 255 */
-        s8 time_adjust;         /* time adjust -128 - 127 */
-        u8 fade:1;              /* fade on = 1, off = 0 */
-        u8 rand:1;              /* rand fade mode on = 1 */
-        u8 script_id;           /* script ID */
-        u8 script_repeats;      /* repeats of script */
-        u8 script_startline;    /* line to start */
-};
-
-/* Colors */
-#define RED   0
-#define GREEN 1
-#define BLUE  2
-
-/* mapping command names to cmd chars - see datasheet */
-#define BLM_GO_RGB            0
-#define BLM_FADE_RGB          1
-#define BLM_FADE_HSB          2
-#define BLM_FADE_RAND_RGB     3
-#define BLM_FADE_RAND_HSB     4
-#define BLM_PLAY_SCRIPT       5
-#define BLM_STOP_SCRIPT       6
-#define BLM_SET_FADE_SPEED    7
-#define BLM_SET_TIME_ADJ      8
-#define BLM_GET_CUR_RGB       9
-#define BLM_WRITE_SCRIPT_LINE 10
-#define BLM_READ_SCRIPT_LINE  11
-#define BLM_SET_SCRIPT_LR     12        /* Length & Repeats */
-#define BLM_SET_ADDR          13
-#define BLM_GET_ADDR          14
-#define BLM_GET_FW_VER        15
-#define BLM_SET_STARTUP_PARAM 16
-
-/* BlinkM Commands
- *  as extracted out of the datasheet:
- *
- *  cmdchar = command (ascii)
- *  cmdbyte = command in hex
- *  nr_args = number of arguments (to send)
- *  nr_ret  = number of return values (to read)
- *  dir = direction (0 = read, 1 = write, 2 = both)
- *
- */
-static const struct {
-        char cmdchar;
-        u8 cmdbyte;
-        u8 nr_args;
-        u8 nr_ret;
-        u8 dir:2;
-} blinkm_cmds[17] = {
-  /* cmdchar, cmdbyte, nr_args, nr_ret,  dir */
-        { 'n', 0x6e, 3, 0, 1},
-        { 'c', 0x63, 3, 0, 1},
-        { 'h', 0x68, 3, 0, 1},
-        { 'C', 0x43, 3, 0, 1},
-        { 'H', 0x48, 3, 0, 1},
-        { 'p', 0x70, 3, 0, 1},
-        { 'o', 0x6f, 0, 0, 1},
-        { 'f', 0x66, 1, 0, 1},
-        { 't', 0x74, 1, 0, 1},
-        { 'g', 0x67, 0, 3, 0},
-        { 'W', 0x57, 7, 0, 1},
-        { 'R', 0x52, 2, 5, 2},
-        { 'L', 0x4c, 3, 0, 1},
-        { 'A', 0x41, 4, 0, 1},
-        { 'a', 0x61, 0, 1, 0},
-        { 'Z', 0x5a, 0, 1, 0},
-        { 'B', 0x42, 5, 0, 1},
-};
-
-static ssize_t show_color_common(struct device *dev, char *buf, int color)
-{
-        struct i2c_client *client;
-        struct blinkm_data *data;
-        int ret;
-
-        client = to_i2c_client(dev);
-        data = i2c_get_clientdata(client);
-
-        ret = blinkm_transfer_hw(client, BLM_GET_CUR_RGB);
-        if (ret < 0)
-                return ret;
-        switch (color) {
-        case RED:
-                return scnprintf(buf, PAGE_SIZE, "%02X\n", data->red);
-                break;
-        case GREEN:
-                return scnprintf(buf, PAGE_SIZE, "%02X\n", data->green);
-                break;
-        case BLUE:
-                return scnprintf(buf, PAGE_SIZE, "%02X\n", data->blue);
-                break;
-        default:
-                return -EINVAL;
-        }
-        return -EINVAL;
-}
-
-static int store_color_common(struct device *dev, const char *buf, int color)
-{
-        struct i2c_client *client;
-        struct blinkm_data *data;
-        int ret;
-        u8 value;
-
-        client = to_i2c_client(dev);
-        data = i2c_get_clientdata(client);
-
-        ret = kstrtou8(buf, 10, &value);
-        if (ret < 0) {
-                dev_err(dev, "BlinkM: value too large!\n");
-                return ret;
-        }
-
-        switch (color) {
-        case RED:
-                data->next_red = value;
-                break;
-        case GREEN:
-                data->next_green = value;
-                break;
-        case BLUE:
-                data->next_blue = value;
-                break;
-        default:
-                return -EINVAL;
-        }
-
-        dev_dbg(dev, "next_red = %d, next_green = %d, next_blue = %d\n",
-                        data->next_red, data->next_green, data->next_blue);
-
-        /* if mode ... */
-        ret = blinkm_transfer_hw(client, BLM_GO_RGB);
-        if (ret < 0) {
-                dev_err(dev, "BlinkM: can't set RGB\n");
-                return ret;
-        }
-        return 0;
-}
-
-static ssize_t show_red(struct device *dev, struct device_attribute *attr,
-                        char *buf)
-{
-        return show_color_common(dev, buf, RED);
-}
-
-static ssize_t store_red(struct device *dev, struct device_attribute *attr,
-                         const char *buf, size_t count)
-{
-        int ret;
-
-        ret = store_color_common(dev, buf, RED);
-        if (ret < 0)
-                return ret;
-        return count;
-}
-
-static DEVICE_ATTR(red, S_IRUGO | S_IWUSR, show_red, store_red);
-
-static ssize_t show_green(struct device *dev, struct device_attribute *attr,
-                          char *buf)
-{
-        return show_color_common(dev, buf, GREEN);
-}
-
-static ssize_t store_green(struct device *dev, struct device_attribute *attr,
-                           const char *buf, size_t count)
-{
-
-        int ret;
-
-        ret = store_color_common(dev, buf, GREEN);
-        if (ret < 0)
-                return ret;
-        return count;
-}
-
-static DEVICE_ATTR(green, S_IRUGO | S_IWUSR, show_green, store_green);
-
-static ssize_t show_blue(struct device *dev, struct device_attribute *attr,
-                         char *buf)
-{
-        return show_color_common(dev, buf, BLUE);
-}
-
-static ssize_t store_blue(struct device *dev, struct device_attribute *attr,
-                          const char *buf, size_t count)
-{
-        int ret;
-
-        ret = store_color_common(dev, buf, BLUE);
-        if (ret < 0)
-                return ret;
-        return count;
-}
-
-static DEVICE_ATTR(blue, S_IRUGO | S_IWUSR, show_blue, store_blue);
-
-static ssize_t show_test(struct device *dev, struct device_attribute *attr,
-                         char *buf)
-{
-        return scnprintf(buf, PAGE_SIZE,
-                         "#Write into test to start test sequence!#\n");
-}
-
-static ssize_t store_test(struct device *dev, struct device_attribute *attr,
-                          const char *buf, size_t count)
-{
-
-        struct i2c_client *client;
-        int ret;
-        client = to_i2c_client(dev);
-
-        /*test */
-        ret = blinkm_test_run(client);
-        if (ret < 0)
-                return ret;
-
-        return count;
-}
-
-static DEVICE_ATTR(test, S_IRUGO | S_IWUSR, show_test, store_test);
-
-/* TODO: HSB, fade, timeadj, script ... */
-
-static struct attribute *blinkm_attrs[] = {
-        &dev_attr_red.attr,
-        &dev_attr_green.attr,
-        &dev_attr_blue.attr,
-        &dev_attr_test.attr,
-        NULL,
-};
-
-static struct attribute_group blinkm_group = {
-        .name = "blinkm",
-        .attrs = blinkm_attrs,
-};
-
-static int blinkm_write(struct i2c_client *client, int cmd, u8 *arg)
-{
-        int result;
-        int i;
-        int arglen = blinkm_cmds[cmd].nr_args;
-        /* write out cmd to blinkm - always / default step */
-        result = i2c_smbus_write_byte(client, blinkm_cmds[cmd].cmdbyte);
-        if (result < 0)
-                return result;
-        /* no args to write out */
-        if (arglen == 0)
-                return 0;
-
-        for (i = 0; i < arglen; i++) {
-                /* repeat for arglen */
-                result = i2c_smbus_write_byte(client, arg[i]);
-                if (result < 0)
-                        return result;
-        }
-        return 0;
-}
-
-static int blinkm_read(struct i2c_client *client, int cmd, u8 *arg)
-{
-        int result;
-        int i;
-        int retlen = blinkm_cmds[cmd].nr_ret;
-        for (i = 0; i < retlen; i++) {
-                /* repeat for retlen */
-                result = i2c_smbus_read_byte(client);
-                if (result < 0)
-                        return result;
-                arg[i] = result;
-        }
-
-        return 0;
-}
-
-static int blinkm_transfer_hw(struct i2c_client *client, int cmd)
-{
-        /* the protocol is simple but non-standard:
-         * e.g.  cmd 'g' (= 0x67) for "get device address"
-         * - which defaults to 0x09 - would be the sequence:
-         *   a) write 0x67 to the device (byte write)
-         *   b) read the value (0x09) back right after (byte read)
-         *
-         * Watch out for "unfinished" sequences (i.e. not enough reads
-         * or writes after a command. It will make the blinkM misbehave.
-         * Sequence is key here.
-         */
-
-        /* args / return are in private data struct */
-        struct blinkm_data *data = i2c_get_clientdata(client);
-
-        /* We start hardware transfers which are not to be
-         * mixed with other commands. Aquire a lock now. */
-        if (mutex_lock_interruptible(&data->update_lock) < 0)
-                return -EAGAIN;
-
-        /* switch cmd - usually write before reads */
-        switch (cmd) {
-        case BLM_FADE_RAND_RGB:
-        case BLM_GO_RGB:
-        case BLM_FADE_RGB:
-                data->args[0] = data->next_red;
-                data->args[1] = data->next_green;
-                data->args[2] = data->next_blue;
-                blinkm_write(client, cmd, data->args);
-                data->red = data->args[0];
-                data->green = data->args[1];
-                data->blue = data->args[2];
-                break;
-        case BLM_FADE_HSB:
-        case BLM_FADE_RAND_HSB:
-                data->args[0] = data->next_hue;
-                data->args[1] = data->next_saturation;
-                data->args[2] = data->next_brightness;
-                blinkm_write(client, cmd, data->args);
-                data->hue = data->next_hue;
-                data->saturation = data->next_saturation;
-                data->brightness = data->next_brightness;
-                break;
-        case BLM_PLAY_SCRIPT:
-                data->args[0] = data->script_id;
-                data->args[1] = data->script_repeats;
-                data->args[2] = data->script_startline;
-                blinkm_write(client, cmd, data->args);
-                break;
-        case BLM_STOP_SCRIPT:
-                blinkm_write(client, cmd, NULL);
-                break;
-        case BLM_GET_CUR_RGB:
-                data->args[0] = data->red;
-                data->args[1] = data->green;
-                data->args[2] = data->blue;
-                blinkm_write(client, cmd, NULL);
-                blinkm_read(client, cmd, data->args);
-                data->red = data->args[0];
-                data->green = data->args[1];
-                data->blue = data->args[2];
-                break;
-        case BLM_GET_ADDR:
-                data->args[0] = data->i2c_addr;
-                blinkm_write(client, cmd, NULL);
-                blinkm_read(client, cmd, data->args);
-                data->i2c_addr = data->args[0];
-                break;
-        case BLM_SET_TIME_ADJ:
-        case BLM_SET_FADE_SPEED:
-        case BLM_READ_SCRIPT_LINE:
-        case BLM_WRITE_SCRIPT_LINE:
-        case BLM_SET_SCRIPT_LR:
-        case BLM_SET_ADDR:
-        case BLM_GET_FW_VER:
-        case BLM_SET_STARTUP_PARAM:
-                dev_err(&client->dev,
-                                "BlinkM: cmd %d not implemented yet.\n", cmd);
-                break;
-        default:
-                dev_err(&client->dev, "BlinkM: unknown command %d\n", cmd);
-                mutex_unlock(&data->update_lock);
-                return -EINVAL;
-        }                       /* end switch(cmd) */
-
-        /* transfers done, unlock */
-        mutex_unlock(&data->update_lock);
-        return 0;
-}
-
-static void led_work(struct work_struct *work)
-{
-        int ret;
-        struct blinkm_led *led;
-        struct blinkm_data *data ;
-        struct blinkm_work *blm_work = work_to_blmwork(work);
-
-        led = blm_work->blinkm_led;
-        data = i2c_get_clientdata(led->i2c_client);
-        ret = blinkm_transfer_hw(led->i2c_client, BLM_GO_RGB);
-        atomic_dec(&led->active);
-        dev_dbg(&led->i2c_client->dev,
-                        "# DONE # next_red = %d, next_green = %d,"
-                        " next_blue = %d, active = %d\n",
-                        data->next_red, data->next_green,
-                        data->next_blue, atomic_read(&led->active));
-        kfree(blm_work);
-}
-
-static int blinkm_led_common_set(struct led_classdev *led_cdev,
-                                 enum led_brightness value, int color)
-{
-        /* led_brightness is 0, 127 or 255 - we just use it here as-is */
-        struct blinkm_led *led = cdev_to_blmled(led_cdev);
-        struct blinkm_data *data = i2c_get_clientdata(led->i2c_client);
-        struct blinkm_work *bl_work;
-
-        switch (color) {
-        case RED:
-                /* bail out if there's no change */
-                if (data->next_red == (u8) value)
-                        return 0;
-                /* we assume a quite fast sequence here ([off]->on->off)
-                 * think of network led trigger - we cannot blink that fast, so
-                 * in case we already have a off->on->off transition queued up,
-                 * we refuse to queue up more.
-                 * Revisit: fast-changing brightness. */
-                if (atomic_read(&led->active) > 1)
-                        return 0;
-                data->next_red = (u8) value;
-                break;
-        case GREEN:
-                /* bail out if there's no change */
-                if (data->next_green == (u8) value)
-                        return 0;
-                /* we assume a quite fast sequence here ([off]->on->off)
-                 * Revisit: fast-changing brightness. */
-                if (atomic_read(&led->active) > 1)
-                        return 0;
-                data->next_green = (u8) value;
-                break;
-        case BLUE:
-                /* bail out if there's no change */
-                if (data->next_blue == (u8) value)
-                        return 0;
-                /* we assume a quite fast sequence here ([off]->on->off)
-                 * Revisit: fast-changing brightness. */
-                if (atomic_read(&led->active) > 1)
-                        return 0;
-                data->next_blue = (u8) value;
-                break;
-
-        default:
-                dev_err(&led->i2c_client->dev, "BlinkM: unknown color.\n");
-                return -EINVAL;
-        }
-
-        bl_work = kzalloc(sizeof(*bl_work), GFP_ATOMIC);
-        if (!bl_work)
-                return -ENOMEM;
-
-        atomic_inc(&led->active);
-        dev_dbg(&led->i2c_client->dev,
-                        "#TO_SCHED# next_red = %d, next_green = %d,"
-                        " next_blue = %d, active = %d\n",
-                        data->next_red, data->next_green,
-                        data->next_blue, atomic_read(&led->active));
-
-        /* a fresh work _item_ for each change */
-        bl_work->blinkm_led = led;
-        INIT_WORK(&bl_work->work, led_work);
-        /* queue work in own queue for easy sync on exit*/
-        schedule_work(&bl_work->work);
-
-        return 0;
-}
-
-static void blinkm_led_red_set(struct led_classdev *led_cdev,
-                               enum led_brightness value)
-{
-        blinkm_led_common_set(led_cdev, value, RED);
-}
-
-static void blinkm_led_green_set(struct led_classdev *led_cdev,
-                                 enum led_brightness value)
-{
-        blinkm_led_common_set(led_cdev, value, GREEN);
-}
-
-static void blinkm_led_blue_set(struct led_classdev *led_cdev,
-                                enum led_brightness value)
-{
-        blinkm_led_common_set(led_cdev, value, BLUE);
-}
-
-static void blinkm_init_hw(struct i2c_client *client)
-{
-        int ret;
-        ret = blinkm_transfer_hw(client, BLM_STOP_SCRIPT);
-        ret = blinkm_transfer_hw(client, BLM_GO_RGB);
-}
-
-static int blinkm_test_run(struct i2c_client *client)
-{
-        int ret;
-        struct blinkm_data *data = i2c_get_clientdata(client);
-
-        data->next_red = 0x01;
-        data->next_green = 0x05;
-        data->next_blue = 0x10;
-        ret = blinkm_transfer_hw(client, BLM_GO_RGB);
-        if (ret < 0)
-                return ret;
-        msleep(2000);
-
-        data->next_red = 0x25;
-        data->next_green = 0x10;
-        data->next_blue = 0x31;
-        ret = blinkm_transfer_hw(client, BLM_FADE_RGB);
-        if (ret < 0)
-                return ret;
-        msleep(2000);
-
-        data->next_hue = 0x50;
-        data->next_saturation = 0x10;
-        data->next_brightness = 0x20;
-        ret = blinkm_transfer_hw(client, BLM_FADE_HSB);
-        if (ret < 0)
-                return ret;
-        msleep(2000);
-
-        return 0;
-}
-
-/* Return 0 if detection is successful, -ENODEV otherwise */
-static int blinkm_detect(struct i2c_client *client, struct i2c_board_info *info)
-{
-        struct i2c_adapter *adapter = client->adapter;
-        int ret;
-        int count = 99;
-        u8 tmpargs[7];
-
-        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA
-                                     | I2C_FUNC_SMBUS_WORD_DATA
-                                     | I2C_FUNC_SMBUS_WRITE_BYTE))
-                return -ENODEV;
-
-        /* Now, we do the remaining detection. Simple for now. */
-        /* We might need more guards to protect other i2c slaves */
-
-        /* make sure the blinkM is balanced (read/writes) */
-        while (count > 0) {
-                ret = blinkm_write(client, BLM_GET_ADDR, NULL);
-                usleep_range(5000, 10000);
-                ret = blinkm_read(client, BLM_GET_ADDR, tmpargs);
-                usleep_range(5000, 10000);
-                if (tmpargs[0] == 0x09)
-                        count = 0;
-                count--;
-        }
-
-        /* Step 1: Read BlinkM address back  -  cmd_char 'a' */
-        ret = blinkm_write(client, BLM_GET_ADDR, NULL);
-        if (ret < 0)
-                return ret;
-        usleep_range(20000, 30000);     /* allow a small delay */
-        ret = blinkm_read(client, BLM_GET_ADDR, tmpargs);
-        if (ret < 0)
-                return ret;
-
-        if (tmpargs[0] != 0x09) {
-                dev_err(&client->dev, "enodev DEV ADDR = 0x%02X\n", tmpargs[0]);
-                return -ENODEV;
-        }
-
-        strlcpy(info->type, "blinkm", I2C_NAME_SIZE);
-        return 0;
-}
-
-static int blinkm_probe(struct i2c_client *client,
-                        const struct i2c_device_id *id)
-{
-        struct blinkm_data *data;
-        struct blinkm_led *led[3];
-        int err, i;
-        char blinkm_led_name[28];
-
-        data = devm_kzalloc(&client->dev,
-                        sizeof(struct blinkm_data), GFP_KERNEL);
-        if (!data) {
-                err = -ENOMEM;
-                goto exit;
-        }
-
-        data->i2c_addr = 0x09;
-        data->i2c_addr = 0x08;
-        /* i2c addr  - use fake addr of 0x08 initially (real is 0x09) */
-        data->fw_ver = 0xfe;
-        /* firmware version - use fake until we read real value
-         * (currently broken - BlinkM confused!) */
-        data->script_id = 0x01;
-        data->i2c_client = client;
-
-        i2c_set_clientdata(client, data);
-        mutex_init(&data->update_lock);
-
-        /* Register sysfs hooks */
-        err = sysfs_create_group(&client->dev.kobj, &blinkm_group);
-        if (err < 0) {
-                dev_err(&client->dev, "couldn't register sysfs group\n");
-                goto exit;
-        }
-
-        for (i = 0; i < 3; i++) {
-                /* RED = 0, GREEN = 1, BLUE = 2 */
-                led[i] = &data->blinkm_leds[i];
-                led[i]->i2c_client = client;
-                led[i]->id = i;
-                led[i]->led_cdev.max_brightness = 255;
-                led[i]->led_cdev.flags = LED_CORE_SUSPENDRESUME;
-                atomic_set(&led[i]->active, 0);
-                switch (i) {
-                case RED:
-                        snprintf(blinkm_led_name, sizeof(blinkm_led_name),
-                                         "blinkm-%d-%d-red",
-                                         client->adapter->nr,
-                                         client->addr);
-                        led[i]->led_cdev.name = blinkm_led_name;
-                        led[i]->led_cdev.brightness_set = blinkm_led_red_set;
-                        err = led_classdev_register(&client->dev,
-                                                    &led[i]->led_cdev);
-                        if (err < 0) {
-                                dev_err(&client->dev,
-                                        "couldn't register LED %s\n",
-                                        led[i]->led_cdev.name);
-                                goto failred;
-                        }
-                        break;
-                case GREEN:
-                        snprintf(blinkm_led_name, sizeof(blinkm_led_name),
-                                         "blinkm-%d-%d-green",
-                                         client->adapter->nr,
-                                         client->addr);
-                        led[i]->led_cdev.name = blinkm_led_name;
-                        led[i]->led_cdev.brightness_set = blinkm_led_green_set;
-                        err = led_classdev_register(&client->dev,
-                                                    &led[i]->led_cdev);
-                        if (err < 0) {
-                                dev_err(&client->dev,
-                                        "couldn't register LED %s\n",
-                                        led[i]->led_cdev.name);
-                                goto failgreen;
-                        }
-                        break;
-                case BLUE:
-                        snprintf(blinkm_led_name, sizeof(blinkm_led_name),
-                                         "blinkm-%d-%d-blue",
-                                         client->adapter->nr,
-                                         client->addr);
-                        led[i]->led_cdev.name = blinkm_led_name;
-                        led[i]->led_cdev.brightness_set = blinkm_led_blue_set;
-                        err = led_classdev_register(&client->dev,
-                                                    &led[i]->led_cdev);
-                        if (err < 0) {
-                                dev_err(&client->dev,
-                                        "couldn't register LED %s\n",
-                                        led[i]->led_cdev.name);
-                                goto failblue;
-                        }
-                        break;
-                }               /* end switch */
-        }                       /* end for */
-
-        /* Initialize the blinkm */
-        blinkm_init_hw(client);
-
-        return 0;
-
-failblue:
-        led_classdev_unregister(&led[GREEN]->led_cdev);
-
-failgreen:
-        led_classdev_unregister(&led[RED]->led_cdev);
-
-failred:
-        sysfs_remove_group(&client->dev.kobj, &blinkm_group);
-exit:
-        return err;
-}
-
-static int blinkm_remove(struct i2c_client *client)
-{
-        struct blinkm_data *data = i2c_get_clientdata(client);
-        int ret = 0;
-        int i;
-
-        /* make sure no workqueue entries are pending */
-        for (i = 0; i < 3; i++) {
-                flush_scheduled_work();
-                led_classdev_unregister(&data->blinkm_leds[i].led_cdev);
-        }
-
-        /* reset rgb */
-        data->next_red = 0x00;
-        data->next_green = 0x00;
-        data->next_blue = 0x00;
-        ret = blinkm_transfer_hw(client, BLM_FADE_RGB);
-        if (ret < 0)
-                dev_err(&client->dev, "Failure in blinkm_remove ignored. Continuing.\n");
-
-        /* reset hsb */
-        data->next_hue = 0x00;
-        data->next_saturation = 0x00;
-        data->next_brightness = 0x00;
-        ret = blinkm_transfer_hw(client, BLM_FADE_HSB);
-        if (ret < 0)
-                dev_err(&client->dev, "Failure in blinkm_remove ignored. Continuing.\n");
-
-        /* red fade to off */
-        data->next_red = 0xff;
-        ret = blinkm_transfer_hw(client, BLM_GO_RGB);
-        if (ret < 0)
-                dev_err(&client->dev, "Failure in blinkm_remove ignored. Continuing.\n");
-
-        /* off */
-        data->next_red = 0x00;
-        ret = blinkm_transfer_hw(client, BLM_FADE_RGB);
-        if (ret < 0)
-                dev_err(&client->dev, "Failure in blinkm_remove ignored. Continuing.\n");
-
-        sysfs_remove_group(&client->dev.kobj, &blinkm_group);
-        return 0;
-}
-
-static const struct i2c_device_id blinkm_id[] = {
-        {"blinkm", 0},
-        {}
-};
-
-MODULE_DEVICE_TABLE(i2c, blinkm_id);
-
-  /* This is the driver that will be inserted */
-static struct i2c_driver blinkm_driver = {
-        .class = I2C_CLASS_HWMON,
-        .driver = {
-                   .name = "blinkm",
-                   },
-        .probe = blinkm_probe,
-        .remove = blinkm_remove,
-        .id_table = blinkm_id,
-        .detect = blinkm_detect,
-        .address_list = normal_i2c,
-};
-
-module_i2c_driver(blinkm_driver);
-
-MODULE_AUTHOR("Jan-Simon Moeller <dl9pf@gmx.de>");
-MODULE_DESCRIPTION("BlinkM RGB LED driver");
-MODULE_LICENSE("GPL");
-
diff --git a/drivers/leds/leds-clevo-mail.c b/drivers/leds/leds-clevo-mail.c
index 6a8405df76a..a498135a4e8 100644
--- a/drivers/leds/leds-clevo-mail.c
+++ b/drivers/leds/leds-clevo-mail.c
@@ -1,4 +1,3 @@
-#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
 #include <linux/module.h>
 
@@ -19,7 +18,7 @@ MODULE_AUTHOR("Márton Németh <nm127@freemail.hu>");
 MODULE_DESCRIPTION("Clevo mail LED driver");
 MODULE_LICENSE("GPL");
 
-static bool __initdata nodetect;
+static unsigned int __initdata nodetect;
 module_param_named(nodetect, nodetect, bool, 0);
 MODULE_PARM_DESC(nodetect, "Skip DMI hardware detection");
 
@@ -27,12 +26,12 @@ static struct platform_device *pdev;
 
 static int __init clevo_mail_led_dmi_callback(const struct dmi_system_id *id)
 {
-        pr_info("'%s' found\n", id->ident);
+        printk(KERN_INFO KBUILD_MODNAME ": '%s' found\n", id->ident);
         return 1;
 }
 
 /*
- * struct clevo_mail_led_dmi_table - List of known good models
+ * struct mail_led_whitelist - List of known good models
  *
  * Contains the known good models this driver is compatible with.
  * When adding a new model try to be as strict as possible. This
@@ -40,7 +39,7 @@ static int __init clevo_mail_led_dmi_callback(const struct dmi_system_id *id)
  * detected as working, but in reality it is not) as low as
  * possible.
  */
-static struct dmi_system_id __initdata clevo_mail_led_dmi_table[] = {
+static struct dmi_system_id __initdata mail_led_whitelist[] = {
         {
                 .callback = clevo_mail_led_dmi_callback,
                 .ident = "Clevo D410J",
@@ -60,10 +59,11 @@ static struct dmi_system_id __initdata clevo_mail_led_dmi_table[] = {
         },
         {
                 .callback = clevo_mail_led_dmi_callback,
-                .ident = "Clevo M5x0V",
+                .ident = "Positivo Mobile",
                 .matches = {
                         DMI_MATCH(DMI_BOARD_VENDOR, "CLEVO Co. "),
                         DMI_MATCH(DMI_BOARD_NAME, "M5X0V "),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Positivo Mobile"),
                         DMI_MATCH(DMI_PRODUCT_VERSION, "VT6198")
                 }
         },
@@ -89,7 +89,6 @@ static struct dmi_system_id __initdata clevo_mail_led_dmi_table[] = {
         },
         { }
 };
-MODULE_DEVICE_TABLE(dmi, clevo_mail_led_dmi_table);
 
 static void clevo_mail_led_set(struct led_classdev *led_cdev,
                                 enum led_brightness value)
@@ -136,7 +135,8 @@ static int clevo_mail_led_blink(struct led_classdev *led_cdev,
                 status = 0;
 
         } else {
-                pr_debug("clevo_mail_led_blink(..., %lu, %lu),"
+                printk(KERN_DEBUG KBUILD_MODNAME
+                       ": clevo_mail_led_blink(..., %lu, %lu),"
                        " returning -EINVAL (unsupported)\n",
                        *delay_on, *delay_off);
         }
@@ -153,7 +153,7 @@ static struct led_classdev clevo_mail_led = {
         .flags                  = LED_CORE_SUSPENDRESUME,
 };
 
-static int clevo_mail_led_probe(struct platform_device *pdev)
+static int __devinit clevo_mail_led_probe(struct platform_device *pdev)
 {
         return led_classdev_register(&pdev->dev, &clevo_mail_led);
 }
@@ -180,10 +180,10 @@ static int __init clevo_mail_led_init(void)
 
         /* Check with the help of DMI if we are running on supported hardware */
         if (!nodetect) {
-                count = dmi_check_system(clevo_mail_led_dmi_table);
+                count = dmi_check_system(mail_led_whitelist);
         } else {
                 count = 1;
-                pr_err("Skipping DMI detection. "
+                printk(KERN_ERR KBUILD_MODNAME ": Skipping DMI detection. "
                        "If the driver works on your hardware please "
                        "report model and the output of dmidecode in tracker "
                        "at http://sourceforge.net/projects/clevo-mailled/\n");
@@ -197,7 +197,8 @@ static int __init clevo_mail_led_init(void)
                 error = platform_driver_probe(&clevo_mail_led_driver,
                                               clevo_mail_led_probe);
                 if (error) {
-                        pr_err("Can't probe platform driver\n");
+                        printk(KERN_ERR KBUILD_MODNAME
+                               ": Can't probe platform driver\n");
                         platform_device_unregister(pdev);
                 }
         } else
diff --git a/drivers/leds/leds-cobalt-qube.c b/drivers/leds/leds-cobalt-qube.c
index 8abcb66db01..da5fb016b1a 100644
--- a/drivers/leds/leds-cobalt-qube.c
+++ b/drivers/leds/leds-cobalt-qube.c
@@ -34,7 +34,7 @@ static struct led_classdev qube_front_led = {
         .default_trigger        = "default-on",
 };
 
-static int cobalt_qube_led_probe(struct platform_device *pdev)
+static int __devinit cobalt_qube_led_probe(struct platform_device *pdev)
 {
         struct resource *res;
         int retval;
@@ -43,7 +43,7 @@ static int cobalt_qube_led_probe(struct platform_device *pdev)
         if (!res)
                 return -EBUSY;
 
-        led_port = devm_ioremap(&pdev->dev, res->start, resource_size(res));
+        led_port = ioremap(res->start, resource_size(res));
         if (!led_port)
                 return -ENOMEM;
 
@@ -52,38 +52,54 @@ static int cobalt_qube_led_probe(struct platform_device *pdev)
 
         retval = led_classdev_register(&pdev->dev, &qube_front_led);
         if (retval)
-                goto err_null;
+                goto err_iounmap;
 
         return 0;
 
-err_null:
+err_iounmap:
+        iounmap(led_port);
         led_port = NULL;
 
         return retval;
 }
 
-static int cobalt_qube_led_remove(struct platform_device *pdev)
+static int __devexit cobalt_qube_led_remove(struct platform_device *pdev)
 {
         led_classdev_unregister(&qube_front_led);
 
-        if (led_port)
+        if (led_port) {
+                iounmap(led_port);
                 led_port = NULL;
+        }
 
         return 0;
 }
 
+/* work with hotplug and coldplug */
+MODULE_ALIAS("platform:cobalt-qube-leds");
+
 static struct platform_driver cobalt_qube_led_driver = {
         .probe  = cobalt_qube_led_probe,
-        .remove = cobalt_qube_led_remove,
+        .remove = __devexit_p(cobalt_qube_led_remove),
         .driver = {
                 .name   = "cobalt-qube-leds",
                 .owner  = THIS_MODULE,
         },
 };
 
-module_platform_driver(cobalt_qube_led_driver);
+static int __init cobalt_qube_led_init(void)
+{
+        return platform_driver_register(&cobalt_qube_led_driver);
+}
+
+static void __exit cobalt_qube_led_exit(void)
+{
+        platform_driver_unregister(&cobalt_qube_led_driver);
+}
+
+module_init(cobalt_qube_led_init);
+module_exit(cobalt_qube_led_exit);
 
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("Front LED support for Cobalt Server");
 MODULE_AUTHOR("Florian Fainelli <florian@openwrt.org>");
-MODULE_ALIAS("platform:cobalt-qube-leds");
diff --git a/drivers/leds/leds-cobalt-raq.c b/drivers/leds/leds-cobalt-raq.c
index 001088b3137..438d4838463 100644
--- a/drivers/leds/leds-cobalt-raq.c
+++ b/drivers/leds/leds-cobalt-raq.c
@@ -24,7 +24,6 @@
 #include <linux/platform_device.h>
 #include <linux/spinlock.h>
 #include <linux/types.h>
-#include <linux/export.h>
 
 #define LED_WEB         0x04
 #define LED_POWER_OFF   0x08
@@ -76,7 +75,7 @@ static struct led_classdev raq_power_off_led = {
         .default_trigger        = "power-off",
 };
 
-static int cobalt_raq_led_probe(struct platform_device *pdev)
+static int __devinit cobalt_raq_led_probe(struct platform_device *pdev)
 {
         struct resource *res;
         int retval;
@@ -85,13 +84,13 @@ static int cobalt_raq_led_probe(struct platform_device *pdev)
         if (!res)
                 return -EBUSY;
 
-        led_port = devm_ioremap(&pdev->dev, res->start, resource_size(res));
+        led_port = ioremap(res->start, resource_size(res));
         if (!led_port)
                 return -ENOMEM;
 
         retval = led_classdev_register(&pdev->dev, &raq_power_off_led);
         if (retval)
-                goto err_null;
+                goto err_iounmap;
 
         retval = led_classdev_register(&pdev->dev, &raq_web_led);
         if (retval)
@@ -102,26 +101,29 @@ static int cobalt_raq_led_probe(struct platform_device *pdev)
 err_unregister:
         led_classdev_unregister(&raq_power_off_led);
 
-err_null:
+err_iounmap:
+        iounmap(led_port);
         led_port = NULL;
 
         return retval;
 }
 
-static int cobalt_raq_led_remove(struct platform_device *pdev)
+static int __devexit cobalt_raq_led_remove(struct platform_device *pdev)
 {
         led_classdev_unregister(&raq_power_off_led);
         led_classdev_unregister(&raq_web_led);
 
-        if (led_port)
+        if (led_port) {
+                iounmap(led_port);
                 led_port = NULL;
+        }
 
         return 0;
 }
 
 static struct platform_driver cobalt_raq_led_driver = {
         .probe  = cobalt_raq_led_probe,
-        .remove = cobalt_raq_led_remove,
+        .remove = __devexit_p(cobalt_raq_led_remove),
         .driver = {
                 .name   = "cobalt-raq-leds",
                 .owner  = THIS_MODULE,
diff --git a/drivers/leds/leds-da903x.c b/drivers/leds/leds-da903x.c
index c263a21db82..f28931cf678 100644
--- a/drivers/leds/leds-da903x.c
+++ b/drivers/leds/leds-da903x.c
@@ -2,10 +2,10 @@
  * LEDs driver for Dialog Semiconductor DA9030/DA9034
  *
  * Copyright (C) 2008 Compulab, Ltd.
- *      Mike Rapoport <mike@compulab.co.il>
+ *      Mike Rapoport <mike@compulab.co.il>
  *
  * Copyright (C) 2006-2008 Marvell International Ltd.
- *      Eric Miao <eric.miao@marvell.com>
+ *      Eric Miao <eric.miao@marvell.com>
  *
  * 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
@@ -85,13 +85,13 @@ static void da903x_led_set(struct led_classdev *led_cdev,
                            enum led_brightness value)
 {
         struct da903x_led *led;
-
+        
         led = container_of(led_cdev, struct da903x_led, cdev);
         led->new_brightness = value;
         schedule_work(&led->work);
 }
 
-static int da903x_led_probe(struct platform_device *pdev)
+static int __devinit da903x_led_probe(struct platform_device *pdev)
 {
         struct led_info *pdata = pdev->dev.platform_data;
         struct da903x_led *led;
@@ -108,7 +108,7 @@ static int da903x_led_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
 
-        led = devm_kzalloc(&pdev->dev, sizeof(struct da903x_led), GFP_KERNEL);
+        led = kzalloc(sizeof(struct da903x_led), GFP_KERNEL);
         if (led == NULL) {
                 dev_err(&pdev->dev, "failed to alloc memory for LED%d\n", id);
                 return -ENOMEM;
@@ -129,18 +129,23 @@ static int da903x_led_probe(struct platform_device *pdev)
         ret = led_classdev_register(led->master, &led->cdev);
         if (ret) {
                 dev_err(&pdev->dev, "failed to register LED %d\n", id);
-                return ret;
+                goto err;
         }
 
         platform_set_drvdata(pdev, led);
         return 0;
+
+err:
+        kfree(led);
+        return ret;
 }
 
-static int da903x_led_remove(struct platform_device *pdev)
+static int __devexit da903x_led_remove(struct platform_device *pdev)
 {
         struct da903x_led *led = platform_get_drvdata(pdev);
 
         led_classdev_unregister(&led->cdev);
+        kfree(led);
         return 0;
 }
 
@@ -150,13 +155,23 @@ static struct platform_driver da903x_led_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe          = da903x_led_probe,
-        .remove         = da903x_led_remove,
+        .remove         = __devexit_p(da903x_led_remove),
 };
 
-module_platform_driver(da903x_led_driver);
+static int __init da903x_led_init(void)
+{
+        return platform_driver_register(&da903x_led_driver);
+}
+module_init(da903x_led_init);
+
+static void __exit da903x_led_exit(void)
+{
+        platform_driver_unregister(&da903x_led_driver);
+}
+module_exit(da903x_led_exit);
 
 MODULE_DESCRIPTION("LEDs driver for Dialog Semiconductor DA9030/DA9034");
-MODULE_AUTHOR("Eric Miao <eric.miao@marvell.com>");
-MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
+MODULE_AUTHOR("Eric Miao <eric.miao@marvell.com>"
+              "Mike Rapoport <mike@compulab.co.il>");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:da903x-led");
diff --git a/drivers/leds/leds-da9052.c b/drivers/leds/leds-da9052.c
deleted file mode 100644
index efec43344e9..00000000000
--- a/drivers/leds/leds-da9052.c
+++ /dev/null
@@ -1,214 +0,0 @@
-/*
- * LED Driver for Dialog DA9052 PMICs.
- *
- * Copyright(c) 2012 Dialog Semiconductor Ltd.
- *
- * Author: David Dajun Chen <dchen@diasemi.com>
- *
- *  This program is free software; you can redistribute  it and/or modify it
- *  under  the terms of  the GNU General  Public License as published by the
- *  Free Software Foundation;  either version 2 of the  License, or (at your
- *  option) any later version.
- *
- */
-
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/platform_device.h>
-#include <linux/leds.h>
-#include <linux/workqueue.h>
-#include <linux/slab.h>
-
-#include <linux/mfd/da9052/reg.h>
-#include <linux/mfd/da9052/da9052.h>
-#include <linux/mfd/da9052/pdata.h>
-
-#define DA9052_OPENDRAIN_OUTPUT 2
-#define DA9052_SET_HIGH_LVL_OUTPUT      (1 << 3)
-#define DA9052_MASK_UPPER_NIBBLE        0xF0
-#define DA9052_MASK_LOWER_NIBBLE        0x0F
-#define DA9052_NIBBLE_SHIFT             4
-#define DA9052_MAX_BRIGHTNESS           0x5f
-
-struct da9052_led {
-        struct led_classdev cdev;
-        struct work_struct work;
-        struct da9052 *da9052;
-        unsigned char led_index;
-        unsigned char id;
-        int brightness;
-};
-
-static unsigned char led_reg[] = {
-        DA9052_LED_CONT_4_REG,
-        DA9052_LED_CONT_5_REG,
-};
-
-static int da9052_set_led_brightness(struct da9052_led *led)
-{
-        u8 val;
-        int error;
-
-        val = (led->brightness & 0x7f) | DA9052_LED_CONT_DIM;
-
-        error = da9052_reg_write(led->da9052, led_reg[led->led_index], val);
-        if (error < 0)
-                dev_err(led->da9052->dev, "Failed to set led brightness, %d\n",
-                        error);
-        return error;
-}
-
-static void da9052_led_work(struct work_struct *work)
-{
-        struct da9052_led *led = container_of(work, struct da9052_led, work);
-
-        da9052_set_led_brightness(led);
-}
-
-static void da9052_led_set(struct led_classdev *led_cdev,
-                           enum led_brightness value)
-{
-        struct da9052_led *led;
-
-        led = container_of(led_cdev, struct da9052_led, cdev);
-        led->brightness = value;
-        schedule_work(&led->work);
-}
-
-static int da9052_configure_leds(struct da9052 *da9052)
-{
-        int error;
-        unsigned char register_value = DA9052_OPENDRAIN_OUTPUT
-                                       | DA9052_SET_HIGH_LVL_OUTPUT;
-
-        error = da9052_reg_update(da9052, DA9052_GPIO_14_15_REG,
-                                  DA9052_MASK_LOWER_NIBBLE,
-                                  register_value);
-
-        if (error < 0) {
-                dev_err(da9052->dev, "Failed to write GPIO 14-15 reg, %d\n",
-                        error);
-                return error;
-        }
-
-        error = da9052_reg_update(da9052, DA9052_GPIO_14_15_REG,
-                                  DA9052_MASK_UPPER_NIBBLE,
-                                  register_value << DA9052_NIBBLE_SHIFT);
-        if (error < 0)
-                dev_err(da9052->dev, "Failed to write GPIO 14-15 reg, %d\n",
-                        error);
-
-        return error;
-}
-
-static int da9052_led_probe(struct platform_device *pdev)
-{
-        struct da9052_pdata *pdata;
-        struct da9052 *da9052;
-        struct led_platform_data *pled;
-        struct da9052_led *led = NULL;
-        int error = -ENODEV;
-        int i;
-
-        da9052 = dev_get_drvdata(pdev->dev.parent);
-        pdata = da9052->dev->platform_data;
-        if (pdata == NULL) {
-                dev_err(&pdev->dev, "No platform data\n");
-                goto err;
-        }
-
-        pled = pdata->pled;
-        if (pled == NULL) {
-                dev_err(&pdev->dev, "No platform data for LED\n");
-                goto err;
-        }
-
-        led = devm_kzalloc(&pdev->dev,
-                           sizeof(struct da9052_led) * pled->num_leds,
-                           GFP_KERNEL);
-        if (led == NULL) {
-                dev_err(&pdev->dev, "Failed to alloc memory\n");
-                error = -ENOMEM;
-                goto err;
-        }
-
-        for (i = 0; i < pled->num_leds; i++) {
-                led[i].cdev.name = pled->leds[i].name;
-                led[i].cdev.brightness_set = da9052_led_set;
-                led[i].cdev.brightness = LED_OFF;
-                led[i].cdev.max_brightness = DA9052_MAX_BRIGHTNESS;
-                led[i].brightness = LED_OFF;
-                led[i].led_index = pled->leds[i].flags;
-                led[i].da9052 = dev_get_drvdata(pdev->dev.parent);
-                INIT_WORK(&led[i].work, da9052_led_work);
-
-                error = led_classdev_register(pdev->dev.parent, &led[i].cdev);
-                if (error) {
-                        dev_err(&pdev->dev, "Failed to register led %d\n",
-                                led[i].led_index);
-                        goto err_register;
-                }
-
-                error = da9052_set_led_brightness(&led[i]);
-                if (error) {
-                        dev_err(&pdev->dev, "Unable to init led %d\n",
-                                led[i].led_index);
-                        continue;
-                }
-        }
-        error = da9052_configure_leds(led->da9052);
-        if (error) {
-                dev_err(&pdev->dev, "Failed to configure GPIO LED%d\n", error);
-                goto err_register;
-        }
-
-        platform_set_drvdata(pdev, led);
-
-        return 0;
-
-err_register:
-        for (i = i - 1; i >= 0; i--) {
-                led_classdev_unregister(&led[i].cdev);
-                cancel_work_sync(&led[i].work);
-        }
-err:
-        return error;
-}
-
-static int da9052_led_remove(struct platform_device *pdev)
-{
-        struct da9052_led *led = platform_get_drvdata(pdev);
-        struct da9052_pdata *pdata;
-        struct da9052 *da9052;
-        struct led_platform_data *pled;
-        int i;
-
-        da9052 = dev_get_drvdata(pdev->dev.parent);
-        pdata = da9052->dev->platform_data;
-        pled = pdata->pled;
-
-        for (i = 0; i < pled->num_leds; i++) {
-                led[i].brightness = 0;
-                da9052_set_led_brightness(&led[i]);
-                led_classdev_unregister(&led[i].cdev);
-                cancel_work_sync(&led[i].work);
-        }
-
-        return 0;
-}
-
-static struct platform_driver da9052_led_driver = {
-        .driver         = {
-                .name   = "da9052-leds",
-                .owner  = THIS_MODULE,
-        },
-        .probe          = da9052_led_probe,
-        .remove         = da9052_led_remove,
-};
-
-module_platform_driver(da9052_led_driver);
-
-MODULE_AUTHOR("Dialog Semiconductor Ltd <dchen@diasemi.com>");
-MODULE_DESCRIPTION("LED driver for Dialog DA9052 PMIC");
-MODULE_LICENSE("GPL");
diff --git a/drivers/leds/leds-dac124s085.c b/drivers/leds/leds-dac124s085.c
index 1f9d8e62d37..31cf0d60a9a 100644
--- a/drivers/leds/leds-dac124s085.c
+++ b/drivers/leds/leds-dac124s085.c
@@ -69,7 +69,7 @@ static int dac124s085_probe(struct spi_device *spi)
         struct dac124s085_led   *led;
         int i, ret;
 
-        dac = devm_kzalloc(&spi->dev, sizeof(*dac), GFP_KERNEL);
+        dac = kzalloc(sizeof(*dac), GFP_KERNEL);
         if (!dac)
                 return -ENOMEM;
 
@@ -102,6 +102,7 @@ eledcr:
                 led_classdev_unregister(&dac->leds[i].ldev);
 
         spi_set_drvdata(spi, NULL);
+        kfree(dac);
         return ret;
 }
 
@@ -116,6 +117,7 @@ static int dac124s085_remove(struct spi_device *spi)
         }
 
         spi_set_drvdata(spi, NULL);
+        kfree(dac);
 
         return 0;
 }
@@ -129,7 +131,18 @@ static struct spi_driver dac124s085_driver = {
         },
 };
 
-module_spi_driver(dac124s085_driver);
+static int __init dac124s085_leds_init(void)
+{
+        return spi_register_driver(&dac124s085_driver);
+}
+
+static void __exit dac124s085_leds_exit(void)
+{
+        spi_unregister_driver(&dac124s085_driver);
+}
+
+module_init(dac124s085_leds_init);
+module_exit(dac124s085_leds_exit);
 
 MODULE_AUTHOR("Guennadi Liakhovetski <lg@denx.de>");
 MODULE_DESCRIPTION("DAC124S085 LED driver");
diff --git a/drivers/leds/leds-fsg.c b/drivers/leds/leds-fsg.c
index b4d5a44cc41..d11d05be0de 100644
--- a/drivers/leds/leds-fsg.c
+++ b/drivers/leds/leds-fsg.c
@@ -19,9 +19,8 @@
 #include <linux/init.h>
 #include <linux/platform_device.h>
 #include <linux/leds.h>
-#include <linux/module.h>
-#include <linux/io.h>
 #include <mach/hardware.h>
+#include <asm/io.h>
 
 #define FSG_LED_WLAN_BIT        0
 #define FSG_LED_WAN_BIT         1
@@ -149,10 +148,11 @@ static int fsg_led_probe(struct platform_device *pdev)
         int ret;
 
         /* Map the LED chip select address space */
-        latch_address = (unsigned short *) devm_ioremap(&pdev->dev,
-                                                IXP4XX_EXP_BUS_BASE(2), 512);
-        if (!latch_address)
-                return -ENOMEM;
+        latch_address = (unsigned short *) ioremap(IXP4XX_EXP_BUS_BASE(2), 512);
+        if (!latch_address) {
+                ret = -ENOMEM;
+                goto failremap;
+        }
 
         latch_value = 0xffff;
         *latch_address = latch_value;
@@ -194,6 +194,8 @@ static int fsg_led_probe(struct platform_device *pdev)
  failwan:
         led_classdev_unregister(&fsg_wlan_led);
  failwlan:
+        iounmap(latch_address);
+ failremap:
 
         return ret;
 }
@@ -207,6 +209,8 @@ static int fsg_led_remove(struct platform_device *pdev)
         led_classdev_unregister(&fsg_sync_led);
         led_classdev_unregister(&fsg_ring_led);
 
+        iounmap(latch_address);
+
         return 0;
 }
 
@@ -219,7 +223,20 @@ static struct platform_driver fsg_led_driver = {
         },
 };
 
-module_platform_driver(fsg_led_driver);
+
+static int __init fsg_led_init(void)
+{
+        return platform_driver_register(&fsg_led_driver);
+}
+
+static void __exit fsg_led_exit(void)
+{
+        platform_driver_unregister(&fsg_led_driver);
+}
+
+
+module_init(fsg_led_init);
+module_exit(fsg_led_exit);
 
 MODULE_AUTHOR("Rod Whitby <rod@whitby.id.au>");
 MODULE_DESCRIPTION("Freecom FSG-3 LED driver");
diff --git a/drivers/leds/leds-gpio.c b/drivers/leds/leds-gpio.c
index a0d931bcb37..3d8bc327a68 100644
--- a/drivers/leds/leds-gpio.c
+++ b/drivers/leds/leds-gpio.c
@@ -13,15 +13,13 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/platform_device.h>
-#include <linux/gpio.h>
 #include <linux/leds.h>
 #include <linux/of_platform.h>
 #include <linux/of_gpio.h>
 #include <linux/slab.h>
 #include <linux/workqueue.h>
-#include <linux/module.h>
-#include <linux/pinctrl/consumer.h>
-#include <linux/err.h>
+
+#include <asm/gpio.h>
 
 struct gpio_led_data {
         struct led_classdev cdev;
@@ -92,7 +90,7 @@ static int gpio_blink_set(struct led_classdev *led_cdev,
                                                 delay_on, delay_off);
 }
 
-static int create_gpio_led(const struct gpio_led *template,
+static int __devinit create_gpio_led(const struct gpio_led *template,
         struct gpio_led_data *led_dat, struct device *parent,
         int (*blink_set)(unsigned, int, unsigned long *, unsigned long *))
 {
@@ -102,11 +100,15 @@ static int create_gpio_led(const struct gpio_led *template,
 
         /* skip leds that aren't available */
         if (!gpio_is_valid(template->gpio)) {
-                dev_info(parent, "Skipping unavailable LED gpio %d (%s)\n",
+                printk(KERN_INFO "Skipping unavailable LED gpio %d (%s)\n",
                                 template->gpio, template->name);
                 return 0;
         }
 
+        ret = gpio_request(template->gpio, template->name);
+        if (ret < 0)
+                return ret;
+
         led_dat->cdev.name = template->name;
         led_dat->cdev.default_trigger = template->default_trigger;
         led_dat->gpio = template->gpio;
@@ -119,27 +121,27 @@ static int create_gpio_led(const struct gpio_led *template,
         }
         led_dat->cdev.brightness_set = gpio_led_set;
         if (template->default_state == LEDS_GPIO_DEFSTATE_KEEP)
-                state = !!gpio_get_value_cansleep(led_dat->gpio) ^ led_dat->active_low;
+                state = !!gpio_get_value(led_dat->gpio) ^ led_dat->active_low;
         else
                 state = (template->default_state == LEDS_GPIO_DEFSTATE_ON);
         led_dat->cdev.brightness = state ? LED_FULL : LED_OFF;
         if (!template->retain_state_suspended)
                 led_dat->cdev.flags |= LED_CORE_SUSPENDRESUME;
 
-        ret = devm_gpio_request_one(parent, template->gpio,
-                                    (led_dat->active_low ^ state) ?
-                                    GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW,
-                                    template->name);
+        ret = gpio_direction_output(led_dat->gpio, led_dat->active_low ^ state);
         if (ret < 0)
-                return ret;
-
+                goto err;
+                
         INIT_WORK(&led_dat->work, gpio_led_work);
 
         ret = led_classdev_register(parent, &led_dat->cdev);
         if (ret < 0)
-                return ret;
+                goto err;
 
         return 0;
+err:
+        gpio_free(led_dat->gpio);
+        return ret;
 }
 
 static void delete_gpio_led(struct gpio_led_data *led)
@@ -148,6 +150,7 @@ static void delete_gpio_led(struct gpio_led_data *led)
                 return;
         led_classdev_unregister(&led->cdev);
         cancel_work_sync(&led->work);
+        gpio_free(led->gpio);
 }
 
 struct gpio_leds_priv {
@@ -163,25 +166,21 @@ static inline int sizeof_gpio_leds_priv(int num_leds)
 
 /* Code to create from OpenFirmware platform devices */
 #ifdef CONFIG_OF_GPIO
-static struct gpio_leds_priv *gpio_leds_create_of(struct platform_device *pdev)
+static struct gpio_leds_priv * __devinit gpio_leds_create_of(struct platform_device *pdev)
 {
         struct device_node *np = pdev->dev.of_node, *child;
         struct gpio_leds_priv *priv;
-        int count, ret;
+        int count = 0, ret;
 
         /* count LEDs in this device, so we know how much to allocate */
-        count = of_get_child_count(np);
-        if (!count)
-                return ERR_PTR(-ENODEV);
-
         for_each_child_of_node(np, child)
-                if (of_get_gpio(child, 0) == -EPROBE_DEFER)
-                        return ERR_PTR(-EPROBE_DEFER);
+                count++;
+        if (!count)
+                return NULL;
 
-        priv = devm_kzalloc(&pdev->dev, sizeof_gpio_leds_priv(count),
-                        GFP_KERNEL);
+        priv = kzalloc(sizeof_gpio_leds_priv(count), GFP_KERNEL);
         if (!priv)
-                return ERR_PTR(-ENOMEM);
+                return NULL;
 
         for_each_child_of_node(np, child) {
                 struct gpio_led led = {};
@@ -216,7 +215,8 @@ static struct gpio_leds_priv *gpio_leds_create_of(struct platform_device *pdev)
 err:
         for (count = priv->num_leds - 2; count >= 0; count--)
                 delete_gpio_led(&priv->leds[count]);
-        return ERR_PTR(-ENODEV);
+        kfree(priv);
+        return NULL;
 }
 
 static const struct of_device_id of_gpio_leds_match[] = {
@@ -224,29 +224,23 @@ static const struct of_device_id of_gpio_leds_match[] = {
         {},
 };
 #else /* CONFIG_OF_GPIO */
-static struct gpio_leds_priv *gpio_leds_create_of(struct platform_device *pdev)
+static struct gpio_leds_priv * __devinit gpio_leds_create_of(struct platform_device *pdev)
 {
-        return ERR_PTR(-ENODEV);
+        return NULL;
 }
+#define of_gpio_leds_match NULL
 #endif /* CONFIG_OF_GPIO */
 
 
-static int gpio_led_probe(struct platform_device *pdev)
+static int __devinit gpio_led_probe(struct platform_device *pdev)
 {
         struct gpio_led_platform_data *pdata = pdev->dev.platform_data;
         struct gpio_leds_priv *priv;
-        struct pinctrl *pinctrl;
         int i, ret = 0;
 
-        pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
-        if (IS_ERR(pinctrl))
-                dev_warn(&pdev->dev,
-                        "pins are not configured from the driver\n");
-
         if (pdata && pdata->num_leds) {
-                priv = devm_kzalloc(&pdev->dev,
-                                sizeof_gpio_leds_priv(pdata->num_leds),
-                                        GFP_KERNEL);
+                priv = kzalloc(sizeof_gpio_leds_priv(pdata->num_leds),
+                                GFP_KERNEL);
                 if (!priv)
                         return -ENOMEM;
 
@@ -259,13 +253,14 @@ static int gpio_led_probe(struct platform_device *pdev)
                                 /* On failure: unwind the led creations */
                                 for (i = i - 1; i >= 0; i--)
                                         delete_gpio_led(&priv->leds[i]);
+                                kfree(priv);
                                 return ret;
                         }
                 }
         } else {
                 priv = gpio_leds_create_of(pdev);
-                if (IS_ERR(priv))
-                        return PTR_ERR(priv);
+                if (!priv)
+                        return -ENODEV;
         }
 
         platform_set_drvdata(pdev, priv);
@@ -273,32 +268,45 @@ static int gpio_led_probe(struct platform_device *pdev)
         return 0;
 }
 
-static int gpio_led_remove(struct platform_device *pdev)
+static int __devexit gpio_led_remove(struct platform_device *pdev)
 {
-        struct gpio_leds_priv *priv = platform_get_drvdata(pdev);
+        struct gpio_leds_priv *priv = dev_get_drvdata(&pdev->dev);
         int i;
 
         for (i = 0; i < priv->num_leds; i++)
                 delete_gpio_led(&priv->leds[i]);
 
-        platform_set_drvdata(pdev, NULL);
+        dev_set_drvdata(&pdev->dev, NULL);
+        kfree(priv);
 
         return 0;
 }
 
 static struct platform_driver gpio_led_driver = {
         .probe          = gpio_led_probe,
-        .remove         = gpio_led_remove,
+        .remove         = __devexit_p(gpio_led_remove),
         .driver         = {
                 .name   = "leds-gpio",
                 .owner  = THIS_MODULE,
-                .of_match_table = of_match_ptr(of_gpio_leds_match),
+                .of_match_table = of_gpio_leds_match,
         },
 };
 
-module_platform_driver(gpio_led_driver);
+MODULE_ALIAS("platform:leds-gpio");
+
+static int __init gpio_led_init(void)
+{
+        return platform_driver_register(&gpio_led_driver);
+}
+
+static void __exit gpio_led_exit(void)
+{
+        platform_driver_unregister(&gpio_led_driver);
+}
+
+module_init(gpio_led_init);
+module_exit(gpio_led_exit);
 
 MODULE_AUTHOR("Raphael Assenat <raph@8d.com>, Trent Piepho <tpiepho@freescale.com>");
 MODULE_DESCRIPTION("GPIO LED driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:leds-gpio");
diff --git a/drivers/leds/leds-hp6xx.c b/drivers/leds/leds-hp6xx.c
index 366b6055e33..bcfbd3a60ea 100644
--- a/drivers/leds/leds-hp6xx.c
+++ b/drivers/leds/leds-hp6xx.c
@@ -79,6 +79,9 @@ static int hp6xxled_remove(struct platform_device *pdev)
         return 0;
 }
 
+/* work with hotplug and coldplug */
+MODULE_ALIAS("platform:hp6xx-led");
+
 static struct platform_driver hp6xxled_driver = {
         .probe          = hp6xxled_probe,
         .remove         = hp6xxled_remove,
@@ -88,9 +91,19 @@ static struct platform_driver hp6xxled_driver = {
         },
 };
 
-module_platform_driver(hp6xxled_driver);
+static int __init hp6xxled_init(void)
+{
+        return platform_driver_register(&hp6xxled_driver);
+}
+
+static void __exit hp6xxled_exit(void)
+{
+        platform_driver_unregister(&hp6xxled_driver);
+}
+
+module_init(hp6xxled_init);
+module_exit(hp6xxled_exit);
 
 MODULE_AUTHOR("Kristoffer Ericson <kristoffer.ericson@gmail.com>");
 MODULE_DESCRIPTION("HP Jornada 6xx LED driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:hp6xx-led");
diff --git a/drivers/leds/leds-lm3530.c b/drivers/leds/leds-lm3530.c
index 21414548383..3dd7090a9a9 100644
--- a/drivers/leds/leds-lm3530.c
+++ b/drivers/leds/leds-lm3530.c
@@ -18,7 +18,6 @@
 #include <linux/led-lm3530.h>
 #include <linux/types.h>
 #include <linux/regulator/consumer.h>
-#include <linux/module.h>
 
 #define LM3530_LED_DEV "lcd-backlight"
 #define LM3530_NAME "lm3530-led"
@@ -26,6 +25,7 @@
 #define LM3530_GEN_CONFIG               0x10
 #define LM3530_ALS_CONFIG               0x20
 #define LM3530_BRT_RAMP_RATE            0x30
+#define LM3530_ALS_ZONE_REG             0x40
 #define LM3530_ALS_IMP_SELECT           0x41
 #define LM3530_BRT_CTRL_REG             0xA0
 #define LM3530_ALS_ZB0_REG              0x60
@@ -37,7 +37,7 @@
 #define LM3530_ALS_Z2T_REG              0x72
 #define LM3530_ALS_Z3T_REG              0x73
 #define LM3530_ALS_Z4T_REG              0x74
-#define LM3530_REG_MAX                  14
+#define LM3530_REG_MAX                  15
 
 /* General Control Register */
 #define LM3530_EN_I2C_SHIFT             (0)
@@ -79,9 +79,6 @@
 #define LM3530_DEF_ZT_3                 (0x33)
 #define LM3530_DEF_ZT_4                 (0x19)
 
-/* 7 bits are used for the brightness : LM3530_BRT_CTRL_REG */
-#define MAX_BRIGHTNESS                  (127)
-
 struct lm3530_mode_map {
         const char *mode;
         enum lm3530_mode mode_val;
@@ -113,22 +110,11 @@ struct lm3530_data {
         bool enable;
 };
 
-/*
- * struct lm3530_als_data
- * @config  : value of ALS configuration register
- * @imp_sel : value of ALS resistor select register
- * @zone    : values of ALS ZB(Zone Boundary) registers
- */
-struct lm3530_als_data {
-        u8 config;
-        u8 imp_sel;
-        u8 zones[LM3530_ALS_ZB_MAX];
-};
-
 static const u8 lm3530_reg[LM3530_REG_MAX] = {
         LM3530_GEN_CONFIG,
         LM3530_ALS_CONFIG,
         LM3530_BRT_RAMP_RATE,
+        LM3530_ALS_ZONE_REG,
         LM3530_ALS_IMP_SELECT,
         LM3530_BRT_CTRL_REG,
         LM3530_ALS_ZB0_REG,
@@ -150,100 +136,91 @@ static int lm3530_get_mode_from_str(const char *str)
                 if (sysfs_streq(str, mode_map[i].mode))
                         return mode_map[i].mode_val;
 
-        return -EINVAL;
+        return -1;
 }
 
-static void lm3530_als_configure(struct lm3530_platform_data *pdata,
-                                struct lm3530_als_data *als)
+static int lm3530_init_registers(struct lm3530_data *drvdata)
 {
+        int ret = 0;
         int i;
+        u8 gen_config;
+        u8 als_config = 0;
+        u8 brt_ramp;
+        u8 als_imp_sel = 0;
+        u8 brightness;
+        u8 reg_val[LM3530_REG_MAX];
+        u8 zones[LM3530_ALS_ZB_MAX];
         u32 als_vmin, als_vmax, als_vstep;
+        struct lm3530_platform_data *pltfm = drvdata->pdata;
+        struct i2c_client *client = drvdata->client;
 
-        if (pdata->als_vmax == 0) {
-                pdata->als_vmin = 0;
-                pdata->als_vmax = LM3530_ALS_WINDOW_mV;
-        }
-
-        als_vmin = pdata->als_vmin;
-        als_vmax = pdata->als_vmax;
+        gen_config = (pltfm->brt_ramp_law << LM3530_RAMP_LAW_SHIFT) |
+                        ((pltfm->max_current & 7) << LM3530_MAX_CURR_SHIFT);
 
-        if ((als_vmax - als_vmin) > LM3530_ALS_WINDOW_mV)
-                pdata->als_vmax = als_vmax = als_vmin + LM3530_ALS_WINDOW_mV;
+        if (drvdata->mode == LM3530_BL_MODE_MANUAL ||
+            drvdata->mode == LM3530_BL_MODE_ALS)
+                gen_config |= (LM3530_ENABLE_I2C);
 
-        /* n zone boundary makes n+1 zones */
-        als_vstep = (als_vmax - als_vmin) / (LM3530_ALS_ZB_MAX + 1);
+        if (drvdata->mode == LM3530_BL_MODE_ALS) {
+                if (pltfm->als_vmax == 0) {
+                        pltfm->als_vmin = als_vmin = 0;
+                        pltfm->als_vmin = als_vmax = LM3530_ALS_WINDOW_mV;
+                }
 
-        for (i = 0; i < LM3530_ALS_ZB_MAX; i++)
-                als->zones[i] = (((als_vmin + LM3530_ALS_OFFSET_mV) +
-                        als_vstep + (i * als_vstep)) * LED_FULL) / 1000;
+                als_vmin = pltfm->als_vmin;
+                als_vmax = pltfm->als_vmax;
 
-        als->config =
-                (pdata->als_avrg_time << LM3530_ALS_AVG_TIME_SHIFT) |
-                (LM3530_ENABLE_ALS) |
-                (pdata->als_input_mode << LM3530_ALS_SEL_SHIFT);
+                if ((als_vmax - als_vmin) > LM3530_ALS_WINDOW_mV)
+                        pltfm->als_vmax = als_vmax =
+                                als_vmin + LM3530_ALS_WINDOW_mV;
 
-        als->imp_sel =
-                (pdata->als1_resistor_sel << LM3530_ALS1_IMP_SHIFT) |
-                (pdata->als2_resistor_sel << LM3530_ALS2_IMP_SHIFT);
-}
+                /* n zone boundary makes n+1 zones */
+                als_vstep = (als_vmax - als_vmin) / (LM3530_ALS_ZB_MAX + 1);
 
-static int lm3530_init_registers(struct lm3530_data *drvdata)
-{
-        int ret = 0;
-        int i;
-        u8 gen_config;
-        u8 brt_ramp;
-        u8 brightness;
-        u8 reg_val[LM3530_REG_MAX];
-        struct lm3530_platform_data *pdata = drvdata->pdata;
-        struct i2c_client *client = drvdata->client;
-        struct lm3530_pwm_data *pwm = &pdata->pwm_data;
-        struct lm3530_als_data als;
+                for (i = 0; i < LM3530_ALS_ZB_MAX; i++)
+                        zones[i] = (((als_vmin + LM3530_ALS_OFFSET_mV) +
+                                        als_vstep + (i * als_vstep)) * LED_FULL)
+                                        / 1000;
 
-        memset(&als, 0, sizeof(struct lm3530_als_data));
+                als_config =
+                        (pltfm->als_avrg_time << LM3530_ALS_AVG_TIME_SHIFT) |
+                        (LM3530_ENABLE_ALS) |
+                        (pltfm->als_input_mode << LM3530_ALS_SEL_SHIFT);
 
-        gen_config = (pdata->brt_ramp_law << LM3530_RAMP_LAW_SHIFT) |
-                        ((pdata->max_current & 7) << LM3530_MAX_CURR_SHIFT);
+                als_imp_sel =
+                        (pltfm->als1_resistor_sel << LM3530_ALS1_IMP_SHIFT) |
+                        (pltfm->als2_resistor_sel << LM3530_ALS2_IMP_SHIFT);
 
-        switch (drvdata->mode) {
-        case LM3530_BL_MODE_MANUAL:
-                gen_config |= LM3530_ENABLE_I2C;
-                break;
-        case LM3530_BL_MODE_ALS:
-                gen_config |= LM3530_ENABLE_I2C;
-                lm3530_als_configure(pdata, &als);
-                break;
-        case LM3530_BL_MODE_PWM:
-                gen_config |= LM3530_ENABLE_PWM | LM3530_ENABLE_PWM_SIMPLE |
-                              (pdata->pwm_pol_hi << LM3530_PWM_POL_SHIFT);
-                break;
         }
 
-        brt_ramp = (pdata->brt_ramp_fall << LM3530_BRT_RAMP_FALL_SHIFT) |
-                        (pdata->brt_ramp_rise << LM3530_BRT_RAMP_RISE_SHIFT);
+        if (drvdata->mode == LM3530_BL_MODE_PWM)
+                gen_config |= (LM3530_ENABLE_PWM) |
+                                (pltfm->pwm_pol_hi << LM3530_PWM_POL_SHIFT) |
+                                (LM3530_ENABLE_PWM_SIMPLE);
+
+        brt_ramp = (pltfm->brt_ramp_fall << LM3530_BRT_RAMP_FALL_SHIFT) |
+                        (pltfm->brt_ramp_rise << LM3530_BRT_RAMP_RISE_SHIFT);
 
         if (drvdata->brightness)
                 brightness = drvdata->brightness;
         else
-                brightness = drvdata->brightness = pdata->brt_val;
-
-        if (brightness > drvdata->led_dev.max_brightness)
-                brightness = drvdata->led_dev.max_brightness;
+                brightness = drvdata->brightness = pltfm->brt_val;
 
         reg_val[0] = gen_config;        /* LM3530_GEN_CONFIG */
-        reg_val[1] = als.config;        /* LM3530_ALS_CONFIG */
+        reg_val[1] = als_config;        /* LM3530_ALS_CONFIG */
         reg_val[2] = brt_ramp;          /* LM3530_BRT_RAMP_RATE */
-        reg_val[3] = als.imp_sel;       /* LM3530_ALS_IMP_SELECT */
-        reg_val[4] = brightness;        /* LM3530_BRT_CTRL_REG */
-        reg_val[5] = als.zones[0];      /* LM3530_ALS_ZB0_REG */
-        reg_val[6] = als.zones[1];      /* LM3530_ALS_ZB1_REG */
-        reg_val[7] = als.zones[2];      /* LM3530_ALS_ZB2_REG */
-        reg_val[8] = als.zones[3];      /* LM3530_ALS_ZB3_REG */
-        reg_val[9] = LM3530_DEF_ZT_0;   /* LM3530_ALS_Z0T_REG */
-        reg_val[10] = LM3530_DEF_ZT_1;  /* LM3530_ALS_Z1T_REG */
-        reg_val[11] = LM3530_DEF_ZT_2;  /* LM3530_ALS_Z2T_REG */
-        reg_val[12] = LM3530_DEF_ZT_3;  /* LM3530_ALS_Z3T_REG */
-        reg_val[13] = LM3530_DEF_ZT_4;  /* LM3530_ALS_Z4T_REG */
+        reg_val[3] = 0x00;              /* LM3530_ALS_ZONE_REG */
+        reg_val[4] = als_imp_sel;       /* LM3530_ALS_IMP_SELECT */
+        reg_val[5] = brightness;        /* LM3530_BRT_CTRL_REG */
+        reg_val[6] = zones[0];          /* LM3530_ALS_ZB0_REG */
+        reg_val[7] = zones[1];          /* LM3530_ALS_ZB1_REG */
+        reg_val[8] = zones[2];          /* LM3530_ALS_ZB2_REG */
+        reg_val[9] = zones[3];          /* LM3530_ALS_ZB3_REG */
+        reg_val[10] = LM3530_DEF_ZT_0;  /* LM3530_ALS_Z0T_REG */
+        reg_val[11] = LM3530_DEF_ZT_1;  /* LM3530_ALS_Z1T_REG */
+        reg_val[12] = LM3530_DEF_ZT_2;  /* LM3530_ALS_Z2T_REG */
+        reg_val[13] = LM3530_DEF_ZT_3;  /* LM3530_ALS_Z3T_REG */
+        reg_val[14] = LM3530_DEF_ZT_4;  /* LM3530_ALS_Z4T_REG */
 
         if (!drvdata->enable) {
                 ret = regulator_enable(drvdata->regulator);
@@ -256,15 +233,6 @@ static int lm3530_init_registers(struct lm3530_data *drvdata)
         }
 
         for (i = 0; i < LM3530_REG_MAX; i++) {
-                /* do not update brightness register when pwm mode */
-                if (lm3530_reg[i] == LM3530_BRT_CTRL_REG &&
-                    drvdata->mode == LM3530_BL_MODE_PWM) {
-                        if (pwm->pwm_set_intensity)
-                                pwm->pwm_set_intensity(reg_val[i],
-                                        drvdata->led_dev.max_brightness);
-                        continue;
-                }
-
                 ret = i2c_smbus_write_byte_data(client,
                                 lm3530_reg[i], reg_val[i]);
                 if (ret)
@@ -280,9 +248,6 @@ static void lm3530_brightness_set(struct led_classdev *led_cdev,
         int err;
         struct lm3530_data *drvdata =
             container_of(led_cdev, struct lm3530_data, led_dev);
-        struct lm3530_platform_data *pdata = drvdata->pdata;
-        struct lm3530_pwm_data *pwm = &pdata->pwm_data;
-        u8 max_brightness = led_cdev->max_brightness;
 
         switch (drvdata->mode) {
         case LM3530_BL_MODE_MANUAL:
@@ -298,12 +263,12 @@ static void lm3530_brightness_set(struct led_classdev *led_cdev,
 
                 /* set the brightness in brightness control register*/
                 err = i2c_smbus_write_byte_data(drvdata->client,
-                                LM3530_BRT_CTRL_REG, brt_val);
+                                LM3530_BRT_CTRL_REG, brt_val / 2);
                 if (err)
                         dev_err(&drvdata->client->dev,
                                 "Unable to set brightness: %d\n", err);
                 else
-                        drvdata->brightness = brt_val;
+                        drvdata->brightness = brt_val / 2;
 
                 if (brt_val == 0) {
                         err = regulator_disable(drvdata->regulator);
@@ -316,8 +281,6 @@ static void lm3530_brightness_set(struct led_classdev *led_cdev,
         case LM3530_BL_MODE_ALS:
                 break;
         case LM3530_BL_MODE_PWM:
-                if (pwm->pwm_set_intensity)
-                        pwm->pwm_set_intensity(brt_val, max_brightness);
                 break;
         default:
                 break;
@@ -327,11 +290,11 @@ static void lm3530_brightness_set(struct led_classdev *led_cdev,
 static ssize_t lm3530_mode_get(struct device *dev,
                 struct device_attribute *attr, char *buf)
 {
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct lm3530_data *drvdata;
+        struct i2c_client *client = container_of(
+                                        dev->parent, struct i2c_client, dev);
+        struct lm3530_data *drvdata = i2c_get_clientdata(client);
         int i, len = 0;
 
-        drvdata = container_of(led_cdev, struct lm3530_data, led_dev);
         for (i = 0; i < ARRAY_SIZE(mode_map); i++)
                 if (drvdata->mode == mode_map[i].mode_val)
                         len += sprintf(buf + len, "[%s] ", mode_map[i].mode);
@@ -346,26 +309,26 @@ static ssize_t lm3530_mode_get(struct device *dev,
 static ssize_t lm3530_mode_set(struct device *dev, struct device_attribute
                                    *attr, const char *buf, size_t size)
 {
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct lm3530_data *drvdata;
-        struct lm3530_pwm_data *pwm;
-        u8 max_brightness;
-        int mode, err;
+        int err;
+        struct i2c_client *client = container_of(
+                                        dev->parent, struct i2c_client, dev);
+        struct lm3530_data *drvdata = i2c_get_clientdata(client);
+        int mode;
 
-        drvdata = container_of(led_cdev, struct lm3530_data, led_dev);
-        pwm = &drvdata->pdata->pwm_data;
-        max_brightness = led_cdev->max_brightness;
         mode = lm3530_get_mode_from_str(buf);
         if (mode < 0) {
                 dev_err(dev, "Invalid mode\n");
-                return mode;
+                return -EINVAL;
         }
 
-        drvdata->mode = mode;
-
-        /* set pwm to low if unnecessary */
-        if (mode != LM3530_BL_MODE_PWM && pwm->pwm_set_intensity)
-                pwm->pwm_set_intensity(0, max_brightness);
+        if (mode == LM3530_BL_MODE_MANUAL)
+                drvdata->mode = LM3530_BL_MODE_MANUAL;
+        else if (mode == LM3530_BL_MODE_ALS)
+                drvdata->mode = LM3530_BL_MODE_ALS;
+        else if (mode == LM3530_BL_MODE_PWM) {
+                dev_err(dev, "PWM mode not supported\n");
+                return -EINVAL;
+        }
 
         err = lm3530_init_registers(drvdata);
         if (err) {
@@ -377,7 +340,7 @@ static ssize_t lm3530_mode_set(struct device *dev, struct device_attribute
 }
 static DEVICE_ATTR(mode, 0644, lm3530_mode_get, lm3530_mode_set);
 
-static int lm3530_probe(struct i2c_client *client,
+static int __devinit lm3530_probe(struct i2c_client *client,
                            const struct i2c_device_id *id)
 {
         struct lm3530_platform_data *pdata = client->dev.platform_data;
@@ -386,24 +349,28 @@ static int lm3530_probe(struct i2c_client *client,
 
         if (pdata == NULL) {
                 dev_err(&client->dev, "platform data required\n");
-                return -ENODEV;
+                err = -ENODEV;
+                goto err_out;
         }
 
         /* BL mode */
         if (pdata->mode > LM3530_BL_MODE_PWM) {
                 dev_err(&client->dev, "Illegal Mode request\n");
-                return -EINVAL;
+                err = -EINVAL;
+                goto err_out;
         }
 
         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
                 dev_err(&client->dev, "I2C_FUNC_I2C not supported\n");
-                return -EIO;
+                err = -EIO;
+                goto err_out;
         }
 
-        drvdata = devm_kzalloc(&client->dev, sizeof(struct lm3530_data),
-                                GFP_KERNEL);
-        if (drvdata == NULL)
-                return -ENOMEM;
+        drvdata = kzalloc(sizeof(struct lm3530_data), GFP_KERNEL);
+        if (drvdata == NULL) {
+                err = -ENOMEM;
+                goto err_out;
+        }
 
         drvdata->mode = pdata->mode;
         drvdata->client = client;
@@ -412,16 +379,15 @@ static int lm3530_probe(struct i2c_client *client,
         drvdata->enable = false;
         drvdata->led_dev.name = LM3530_LED_DEV;
         drvdata->led_dev.brightness_set = lm3530_brightness_set;
-        drvdata->led_dev.max_brightness = MAX_BRIGHTNESS;
 
         i2c_set_clientdata(client, drvdata);
 
-        drvdata->regulator = devm_regulator_get(&client->dev, "vin");
+        drvdata->regulator = regulator_get(&client->dev, "vin");
         if (IS_ERR(drvdata->regulator)) {
                 dev_err(&client->dev, "regulator get failed\n");
                 err = PTR_ERR(drvdata->regulator);
                 drvdata->regulator = NULL;
-                return err;
+                goto err_regulator_get;
         }
 
         if (drvdata->pdata->brt_val) {
@@ -429,13 +395,15 @@ static int lm3530_probe(struct i2c_client *client,
                 if (err < 0) {
                         dev_err(&client->dev,
                                 "Register Init failed: %d\n", err);
-                        return err;
+                        err = -ENODEV;
+                        goto err_reg_init;
                 }
         }
         err = led_classdev_register(&client->dev, &drvdata->led_dev);
         if (err < 0) {
                 dev_err(&client->dev, "Register led class failed: %d\n", err);
-                return err;
+                err = -ENODEV;
+                goto err_class_register;
         }
 
         err = device_create_file(drvdata->led_dev.dev, &dev_attr_mode);
@@ -449,10 +417,17 @@ static int lm3530_probe(struct i2c_client *client,
 
 err_create_file:
         led_classdev_unregister(&drvdata->led_dev);
+err_class_register:
+err_reg_init:
+        regulator_put(drvdata->regulator);
+err_regulator_get:
+        i2c_set_clientdata(client, NULL);
+        kfree(drvdata);
+err_out:
         return err;
 }
 
-static int lm3530_remove(struct i2c_client *client)
+static int __devexit lm3530_remove(struct i2c_client *client)
 {
         struct lm3530_data *drvdata = i2c_get_clientdata(client);
 
@@ -460,7 +435,9 @@ static int lm3530_remove(struct i2c_client *client)
 
         if (drvdata->enable)
                 regulator_disable(drvdata->regulator);
+        regulator_put(drvdata->regulator);
         led_classdev_unregister(&drvdata->led_dev);
+        kfree(drvdata);
         return 0;
 }
 
@@ -480,7 +457,18 @@ static struct i2c_driver lm3530_i2c_driver = {
         },
 };
 
-module_i2c_driver(lm3530_i2c_driver);
+static int __init lm3530_init(void)
+{
+        return i2c_add_driver(&lm3530_i2c_driver);
+}
+
+static void __exit lm3530_exit(void)
+{
+        i2c_del_driver(&lm3530_i2c_driver);
+}
+
+module_init(lm3530_init);
+module_exit(lm3530_exit);
 
 MODULE_DESCRIPTION("Back Light driver for LM3530");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/leds/leds-lm3533.c b/drivers/leds/leds-lm3533.c
deleted file mode 100644
index bbf24d038a7..00000000000
--- a/drivers/leds/leds-lm3533.c
+++ /dev/null
@@ -1,785 +0,0 @@
-/*
- * leds-lm3533.c -- LM3533 LED driver
- *
- * Copyright (C) 2011-2012 Texas Instruments
- *
- * Author: Johan Hovold <jhovold@gmail.com>
- *
- * This program is free software; you can redistribute it and/or modify it
- * under  the terms of the GNU General  Public License as published by the
- * Free Software Foundation;  either version 2 of the License, or (at your
- * option) any later version.
- */
-
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/leds.h>
-#include <linux/mfd/core.h>
-#include <linux/mutex.h>
-#include <linux/platform_device.h>
-#include <linux/slab.h>
-#include <linux/workqueue.h>
-
-#include <linux/mfd/lm3533.h>
-
-
-#define LM3533_LVCTRLBANK_MIN           2
-#define LM3533_LVCTRLBANK_MAX           5
-#define LM3533_LVCTRLBANK_COUNT         4
-#define LM3533_RISEFALLTIME_MAX         7
-#define LM3533_ALS_CHANNEL_LV_MIN       1
-#define LM3533_ALS_CHANNEL_LV_MAX       2
-
-#define LM3533_REG_CTRLBANK_BCONF_BASE          0x1b
-#define LM3533_REG_PATTERN_ENABLE               0x28
-#define LM3533_REG_PATTERN_LOW_TIME_BASE        0x71
-#define LM3533_REG_PATTERN_HIGH_TIME_BASE       0x72
-#define LM3533_REG_PATTERN_RISETIME_BASE        0x74
-#define LM3533_REG_PATTERN_FALLTIME_BASE        0x75
-
-#define LM3533_REG_PATTERN_STEP                 0x10
-
-#define LM3533_REG_CTRLBANK_BCONF_MAPPING_MASK          0x04
-#define LM3533_REG_CTRLBANK_BCONF_ALS_EN_MASK           0x02
-#define LM3533_REG_CTRLBANK_BCONF_ALS_CHANNEL_MASK      0x01
-
-#define LM3533_LED_FLAG_PATTERN_ENABLE          1
-
-
-struct lm3533_led {
-        struct lm3533 *lm3533;
-        struct lm3533_ctrlbank cb;
-        struct led_classdev cdev;
-        int id;
-
-        struct mutex mutex;
-        unsigned long flags;
-
-        struct work_struct work;
-        u8 new_brightness;
-};
-
-
-static inline struct lm3533_led *to_lm3533_led(struct led_classdev *cdev)
-{
-        return container_of(cdev, struct lm3533_led, cdev);
-}
-
-static inline int lm3533_led_get_ctrlbank_id(struct lm3533_led *led)
-{
-        return led->id + 2;
-}
-
-static inline u8 lm3533_led_get_lv_reg(struct lm3533_led *led, u8 base)
-{
-        return base + led->id;
-}
-
-static inline u8 lm3533_led_get_pattern(struct lm3533_led *led)
-{
-        return led->id;
-}
-
-static inline u8 lm3533_led_get_pattern_reg(struct lm3533_led *led,
-                                                                u8 base)
-{
-        return base + lm3533_led_get_pattern(led) * LM3533_REG_PATTERN_STEP;
-}
-
-static int lm3533_led_pattern_enable(struct lm3533_led *led, int enable)
-{
-        u8 mask;
-        u8 val;
-        int pattern;
-        int state;
-        int ret = 0;
-
-        dev_dbg(led->cdev.dev, "%s - %d\n", __func__, enable);
-
-        mutex_lock(&led->mutex);
-
-        state = test_bit(LM3533_LED_FLAG_PATTERN_ENABLE, &led->flags);
-        if ((enable && state) || (!enable && !state))
-                goto out;
-
-        pattern = lm3533_led_get_pattern(led);
-        mask = 1 << (2 * pattern);
-
-        if (enable)
-                val = mask;
-        else
-                val = 0;
-
-        ret = lm3533_update(led->lm3533, LM3533_REG_PATTERN_ENABLE, val, mask);
-        if (ret) {
-                dev_err(led->cdev.dev, "failed to enable pattern %d (%d)\n",
-                                                        pattern, enable);
-                goto out;
-        }
-
-        __change_bit(LM3533_LED_FLAG_PATTERN_ENABLE, &led->flags);
-out:
-        mutex_unlock(&led->mutex);
-
-        return ret;
-}
-
-static void lm3533_led_work(struct work_struct *work)
-{
-        struct lm3533_led *led = container_of(work, struct lm3533_led, work);
-
-        dev_dbg(led->cdev.dev, "%s - %u\n", __func__, led->new_brightness);
-
-        if (led->new_brightness == 0)
-                lm3533_led_pattern_enable(led, 0);      /* disable blink */
-
-        lm3533_ctrlbank_set_brightness(&led->cb, led->new_brightness);
-}
-
-static void lm3533_led_set(struct led_classdev *cdev,
-                                                enum led_brightness value)
-{
-        struct lm3533_led *led = to_lm3533_led(cdev);
-
-        dev_dbg(led->cdev.dev, "%s - %d\n", __func__, value);
-
-        led->new_brightness = value;
-        schedule_work(&led->work);
-}
-
-static enum led_brightness lm3533_led_get(struct led_classdev *cdev)
-{
-        struct lm3533_led *led = to_lm3533_led(cdev);
-        u8 val;
-        int ret;
-
-        ret = lm3533_ctrlbank_get_brightness(&led->cb, &val);
-        if (ret)
-                return ret;
-
-        dev_dbg(led->cdev.dev, "%s - %u\n", __func__, val);
-
-        return val;
-}
-
-/* Pattern generator defines (delays in us). */
-#define LM3533_LED_DELAY1_VMIN  0x00
-#define LM3533_LED_DELAY2_VMIN  0x3d
-#define LM3533_LED_DELAY3_VMIN  0x80
-
-#define LM3533_LED_DELAY1_VMAX  (LM3533_LED_DELAY2_VMIN - 1)
-#define LM3533_LED_DELAY2_VMAX  (LM3533_LED_DELAY3_VMIN - 1)
-#define LM3533_LED_DELAY3_VMAX  0xff
-
-#define LM3533_LED_DELAY1_TMIN  16384U
-#define LM3533_LED_DELAY2_TMIN  1130496U
-#define LM3533_LED_DELAY3_TMIN  10305536U
-
-#define LM3533_LED_DELAY1_TMAX  999424U
-#define LM3533_LED_DELAY2_TMAX  9781248U
-#define LM3533_LED_DELAY3_TMAX  76890112U
-
-/* t_step = (t_max - t_min) / (v_max - v_min) */
-#define LM3533_LED_DELAY1_TSTEP 16384
-#define LM3533_LED_DELAY2_TSTEP 131072
-#define LM3533_LED_DELAY3_TSTEP 524288
-
-/* Delay limits for hardware accelerated blinking (in ms). */
-#define LM3533_LED_DELAY_ON_MAX \
-        ((LM3533_LED_DELAY2_TMAX + LM3533_LED_DELAY2_TSTEP / 2) / 1000)
-#define LM3533_LED_DELAY_OFF_MAX \
-        ((LM3533_LED_DELAY3_TMAX + LM3533_LED_DELAY3_TSTEP / 2) / 1000)
-
-/*
- * Returns linear map of *t from [t_min,t_max] to [v_min,v_max] with a step
- * size of t_step, where
- *
- *      t_step = (t_max - t_min) / (v_max - v_min)
- *
- * and updates *t to reflect the mapped value.
- */
-static u8 time_to_val(unsigned *t, unsigned t_min, unsigned t_step,
-                                                        u8 v_min, u8 v_max)
-{
-        unsigned val;
-
-        val = (*t + t_step / 2 - t_min) / t_step + v_min;
-
-        *t = t_step * (val - v_min) + t_min;
-
-        return (u8)val;
-}
-
-/*
- * Returns time code corresponding to *delay (in ms) and updates *delay to
- * reflect actual hardware delay.
- *
- * Hardware supports 256 discrete delay times, divided into three groups with
- * the following ranges and step-sizes:
- *
- *      [   16,   999]  [0x00, 0x3e]    step  16 ms
- *      [ 1130,  9781]  [0x3d, 0x7f]    step 131 ms
- *      [10306, 76890]  [0x80, 0xff]    step 524 ms
- *
- * Note that delay group 3 is only available for delay_off.
- */
-static u8 lm3533_led_get_hw_delay(unsigned *delay)
-{
-        unsigned t;
-        u8 val;
-
-        t = *delay * 1000;
-
-        if (t >= (LM3533_LED_DELAY2_TMAX + LM3533_LED_DELAY3_TMIN) / 2) {
-                t = clamp(t, LM3533_LED_DELAY3_TMIN, LM3533_LED_DELAY3_TMAX);
-                val = time_to_val(&t,   LM3533_LED_DELAY3_TMIN,
-                                        LM3533_LED_DELAY3_TSTEP,
-                                        LM3533_LED_DELAY3_VMIN,
-                                        LM3533_LED_DELAY3_VMAX);
-        } else if (t >= (LM3533_LED_DELAY1_TMAX + LM3533_LED_DELAY2_TMIN) / 2) {
-                t = clamp(t, LM3533_LED_DELAY2_TMIN, LM3533_LED_DELAY2_TMAX);
-                val = time_to_val(&t,   LM3533_LED_DELAY2_TMIN,
-                                        LM3533_LED_DELAY2_TSTEP,
-                                        LM3533_LED_DELAY2_VMIN,
-                                        LM3533_LED_DELAY2_VMAX);
-        } else {
-                t = clamp(t, LM3533_LED_DELAY1_TMIN, LM3533_LED_DELAY1_TMAX);
-                val = time_to_val(&t,   LM3533_LED_DELAY1_TMIN,
-                                        LM3533_LED_DELAY1_TSTEP,
-                                        LM3533_LED_DELAY1_VMIN,
-                                        LM3533_LED_DELAY1_VMAX);
-        }
-
-        *delay = (t + 500) / 1000;
-
-        return val;
-}
-
-/*
- * Set delay register base to *delay (in ms) and update *delay to reflect
- * actual hardware delay used.
- */
-static u8 lm3533_led_delay_set(struct lm3533_led *led, u8 base,
-                                                        unsigned long *delay)
-{
-        unsigned t;
-        u8 val;
-        u8 reg;
-        int ret;
-
-        t = (unsigned)*delay;
-
-        /* Delay group 3 is only available for low time (delay off). */
-        if (base != LM3533_REG_PATTERN_LOW_TIME_BASE)
-                t = min(t, LM3533_LED_DELAY2_TMAX / 1000);
-
-        val = lm3533_led_get_hw_delay(&t);
-
-        dev_dbg(led->cdev.dev, "%s - %lu: %u (0x%02x)\n", __func__,
-                                                        *delay, t, val);
-        reg = lm3533_led_get_pattern_reg(led, base);
-        ret = lm3533_write(led->lm3533, reg, val);
-        if (ret)
-                dev_err(led->cdev.dev, "failed to set delay (%02x)\n", reg);
-
-        *delay = t;
-
-        return ret;
-}
-
-static int lm3533_led_delay_on_set(struct lm3533_led *led, unsigned long *t)
-{
-        return lm3533_led_delay_set(led, LM3533_REG_PATTERN_HIGH_TIME_BASE, t);
-}
-
-static int lm3533_led_delay_off_set(struct lm3533_led *led, unsigned long *t)
-{
-        return lm3533_led_delay_set(led, LM3533_REG_PATTERN_LOW_TIME_BASE, t);
-}
-
-static int lm3533_led_blink_set(struct led_classdev *cdev,
-                                unsigned long *delay_on,
-                                unsigned long *delay_off)
-{
-        struct lm3533_led *led = to_lm3533_led(cdev);
-        int ret;
-
-        dev_dbg(led->cdev.dev, "%s - on = %lu, off = %lu\n", __func__,
-                                                        *delay_on, *delay_off);
-
-        if (*delay_on > LM3533_LED_DELAY_ON_MAX ||
-                                        *delay_off > LM3533_LED_DELAY_OFF_MAX)
-                return -EINVAL;
-
-        if (*delay_on == 0 && *delay_off == 0) {
-                *delay_on = 500;
-                *delay_off = 500;
-        }
-
-        ret = lm3533_led_delay_on_set(led, delay_on);
-        if (ret)
-                return ret;
-
-        ret = lm3533_led_delay_off_set(led, delay_off);
-        if (ret)
-                return ret;
-
-        return lm3533_led_pattern_enable(led, 1);
-}
-
-static ssize_t show_id(struct device *dev,
-                                struct device_attribute *attr, char *buf)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct lm3533_led *led = to_lm3533_led(led_cdev);
-
-        return scnprintf(buf, PAGE_SIZE, "%d\n", led->id);
-}
-
-/*
- * Pattern generator rise/fall times:
- *
- *   0 - 2048 us (default)
- *   1 - 262 ms
- *   2 - 524 ms
- *   3 - 1.049 s
- *   4 - 2.097 s
- *   5 - 4.194 s
- *   6 - 8.389 s
- *   7 - 16.78 s
- */
-static ssize_t show_risefalltime(struct device *dev,
-                                        struct device_attribute *attr,
-                                        char *buf, u8 base)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct lm3533_led *led = to_lm3533_led(led_cdev);
-        ssize_t ret;
-        u8 reg;
-        u8 val;
-
-        reg = lm3533_led_get_pattern_reg(led, base);
-        ret = lm3533_read(led->lm3533, reg, &val);
-        if (ret)
-                return ret;
-
-        return scnprintf(buf, PAGE_SIZE, "%x\n", val);
-}
-
-static ssize_t show_risetime(struct device *dev,
-                                struct device_attribute *attr, char *buf)
-{
-        return show_risefalltime(dev, attr, buf,
-                                        LM3533_REG_PATTERN_RISETIME_BASE);
-}
-
-static ssize_t show_falltime(struct device *dev,
-                                struct device_attribute *attr, char *buf)
-{
-        return show_risefalltime(dev, attr, buf,
-                                        LM3533_REG_PATTERN_FALLTIME_BASE);
-}
-
-static ssize_t store_risefalltime(struct device *dev,
-                                        struct device_attribute *attr,
-                                        const char *buf, size_t len, u8 base)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct lm3533_led *led = to_lm3533_led(led_cdev);
-        u8 val;
-        u8 reg;
-        int ret;
-
-        if (kstrtou8(buf, 0, &val) || val > LM3533_RISEFALLTIME_MAX)
-                return -EINVAL;
-
-        reg = lm3533_led_get_pattern_reg(led, base);
-        ret = lm3533_write(led->lm3533, reg, val);
-        if (ret)
-                return ret;
-
-        return len;
-}
-
-static ssize_t store_risetime(struct device *dev,
-                                        struct device_attribute *attr,
-                                        const char *buf, size_t len)
-{
-        return store_risefalltime(dev, attr, buf, len,
-                                        LM3533_REG_PATTERN_RISETIME_BASE);
-}
-
-static ssize_t store_falltime(struct device *dev,
-                                        struct device_attribute *attr,
-                                        const char *buf, size_t len)
-{
-        return store_risefalltime(dev, attr, buf, len,
-                                        LM3533_REG_PATTERN_FALLTIME_BASE);
-}
-
-static ssize_t show_als_channel(struct device *dev,
-                                struct device_attribute *attr, char *buf)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct lm3533_led *led = to_lm3533_led(led_cdev);
-        unsigned channel;
-        u8 reg;
-        u8 val;
-        int ret;
-
-        reg = lm3533_led_get_lv_reg(led, LM3533_REG_CTRLBANK_BCONF_BASE);
-        ret = lm3533_read(led->lm3533, reg, &val);
-        if (ret)
-                return ret;
-
-        channel = (val & LM3533_REG_CTRLBANK_BCONF_ALS_CHANNEL_MASK) + 1;
-
-        return scnprintf(buf, PAGE_SIZE, "%u\n", channel);
-}
-
-static ssize_t store_als_channel(struct device *dev,
-                                        struct device_attribute *attr,
-                                        const char *buf, size_t len)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct lm3533_led *led = to_lm3533_led(led_cdev);
-        unsigned channel;
-        u8 reg;
-        u8 val;
-        u8 mask;
-        int ret;
-
-        if (kstrtouint(buf, 0, &channel))
-                return -EINVAL;
-
-        if (channel < LM3533_ALS_CHANNEL_LV_MIN ||
-                                        channel > LM3533_ALS_CHANNEL_LV_MAX)
-                return -EINVAL;
-
-        reg = lm3533_led_get_lv_reg(led, LM3533_REG_CTRLBANK_BCONF_BASE);
-        mask = LM3533_REG_CTRLBANK_BCONF_ALS_CHANNEL_MASK;
-        val = channel - 1;
-
-        ret = lm3533_update(led->lm3533, reg, val, mask);
-        if (ret)
-                return ret;
-
-        return len;
-}
-
-static ssize_t show_als_en(struct device *dev,
-                                struct device_attribute *attr, char *buf)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct lm3533_led *led = to_lm3533_led(led_cdev);
-        bool enable;
-        u8 reg;
-        u8 val;
-        int ret;
-
-        reg = lm3533_led_get_lv_reg(led, LM3533_REG_CTRLBANK_BCONF_BASE);
-        ret = lm3533_read(led->lm3533, reg, &val);
-        if (ret)
-                return ret;
-
-        enable = val & LM3533_REG_CTRLBANK_BCONF_ALS_EN_MASK;
-
-        return scnprintf(buf, PAGE_SIZE, "%d\n", enable);
-}
-
-static ssize_t store_als_en(struct device *dev,
-                                        struct device_attribute *attr,
-                                        const char *buf, size_t len)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct lm3533_led *led = to_lm3533_led(led_cdev);
-        unsigned enable;
-        u8 reg;
-        u8 mask;
-        u8 val;
-        int ret;
-
-        if (kstrtouint(buf, 0, &enable))
-                return -EINVAL;
-
-        reg = lm3533_led_get_lv_reg(led, LM3533_REG_CTRLBANK_BCONF_BASE);
-        mask = LM3533_REG_CTRLBANK_BCONF_ALS_EN_MASK;
-
-        if (enable)
-                val = mask;
-        else
-                val = 0;
-
-        ret = lm3533_update(led->lm3533, reg, val, mask);
-        if (ret)
-                return ret;
-
-        return len;
-}
-
-static ssize_t show_linear(struct device *dev,
-                                struct device_attribute *attr, char *buf)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct lm3533_led *led = to_lm3533_led(led_cdev);
-        u8 reg;
-        u8 val;
-        int linear;
-        int ret;
-
-        reg = lm3533_led_get_lv_reg(led, LM3533_REG_CTRLBANK_BCONF_BASE);
-        ret = lm3533_read(led->lm3533, reg, &val);
-        if (ret)
-                return ret;
-
-        if (val & LM3533_REG_CTRLBANK_BCONF_MAPPING_MASK)
-                linear = 1;
-        else
-                linear = 0;
-
-        return scnprintf(buf, PAGE_SIZE, "%x\n", linear);
-}
-
-static ssize_t store_linear(struct device *dev,
-                                        struct device_attribute *attr,
-                                        const char *buf, size_t len)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct lm3533_led *led = to_lm3533_led(led_cdev);
-        unsigned long linear;
-        u8 reg;
-        u8 mask;
-        u8 val;
-        int ret;
-
-        if (kstrtoul(buf, 0, &linear))
-                return -EINVAL;
-
-        reg = lm3533_led_get_lv_reg(led, LM3533_REG_CTRLBANK_BCONF_BASE);
-        mask = LM3533_REG_CTRLBANK_BCONF_MAPPING_MASK;
-
-        if (linear)
-                val = mask;
-        else
-                val = 0;
-
-        ret = lm3533_update(led->lm3533, reg, val, mask);
-        if (ret)
-                return ret;
-
-        return len;
-}
-
-static ssize_t show_pwm(struct device *dev,
-                                        struct device_attribute *attr,
-                                        char *buf)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct lm3533_led *led = to_lm3533_led(led_cdev);
-        u8 val;
-        int ret;
-
-        ret = lm3533_ctrlbank_get_pwm(&led->cb, &val);
-        if (ret)
-                return ret;
-
-        return scnprintf(buf, PAGE_SIZE, "%u\n", val);
-}
-
-static ssize_t store_pwm(struct device *dev,
-                                        struct device_attribute *attr,
-                                        const char *buf, size_t len)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct lm3533_led *led = to_lm3533_led(led_cdev);
-        u8 val;
-        int ret;
-
-        if (kstrtou8(buf, 0, &val))
-                return -EINVAL;
-
-        ret = lm3533_ctrlbank_set_pwm(&led->cb, val);
-        if (ret)
-                return ret;
-
-        return len;
-}
-
-static LM3533_ATTR_RW(als_channel);
-static LM3533_ATTR_RW(als_en);
-static LM3533_ATTR_RW(falltime);
-static LM3533_ATTR_RO(id);
-static LM3533_ATTR_RW(linear);
-static LM3533_ATTR_RW(pwm);
-static LM3533_ATTR_RW(risetime);
-
-static struct attribute *lm3533_led_attributes[] = {
-        &dev_attr_als_channel.attr,
-        &dev_attr_als_en.attr,
-        &dev_attr_falltime.attr,
-        &dev_attr_id.attr,
-        &dev_attr_linear.attr,
-        &dev_attr_pwm.attr,
-        &dev_attr_risetime.attr,
-        NULL,
-};
-
-static umode_t lm3533_led_attr_is_visible(struct kobject *kobj,
-                                             struct attribute *attr, int n)
-{
-        struct device *dev = container_of(kobj, struct device, kobj);
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct lm3533_led *led = to_lm3533_led(led_cdev);
-        umode_t mode = attr->mode;
-
-        if (attr == &dev_attr_als_channel.attr ||
-                                        attr == &dev_attr_als_en.attr) {
-                if (!led->lm3533->have_als)
-                        mode = 0;
-        }
-
-        return mode;
-};
-
-static struct attribute_group lm3533_led_attribute_group = {
-        .is_visible     = lm3533_led_attr_is_visible,
-        .attrs          = lm3533_led_attributes
-};
-
-static int lm3533_led_setup(struct lm3533_led *led,
-                                        struct lm3533_led_platform_data *pdata)
-{
-        int ret;
-
-        ret = lm3533_ctrlbank_set_max_current(&led->cb, pdata->max_current);
-        if (ret)
-                return ret;
-
-        return lm3533_ctrlbank_set_pwm(&led->cb, pdata->pwm);
-}
-
-static int lm3533_led_probe(struct platform_device *pdev)
-{
-        struct lm3533 *lm3533;
-        struct lm3533_led_platform_data *pdata;
-        struct lm3533_led *led;
-        int ret;
-
-        dev_dbg(&pdev->dev, "%s\n", __func__);
-
-        lm3533 = dev_get_drvdata(pdev->dev.parent);
-        if (!lm3533)
-                return -EINVAL;
-
-        pdata = pdev->dev.platform_data;
-        if (!pdata) {
-                dev_err(&pdev->dev, "no platform data\n");
-                return -EINVAL;
-        }
-
-        if (pdev->id < 0 || pdev->id >= LM3533_LVCTRLBANK_COUNT) {
-                dev_err(&pdev->dev, "illegal LED id %d\n", pdev->id);
-                return -EINVAL;
-        }
-
-        led = devm_kzalloc(&pdev->dev, sizeof(*led), GFP_KERNEL);
-        if (!led)
-                return -ENOMEM;
-
-        led->lm3533 = lm3533;
-        led->cdev.name = pdata->name;
-        led->cdev.default_trigger = pdata->default_trigger;
-        led->cdev.brightness_set = lm3533_led_set;
-        led->cdev.brightness_get = lm3533_led_get;
-        led->cdev.blink_set = lm3533_led_blink_set;
-        led->cdev.brightness = LED_OFF;
-        led->id = pdev->id;
-
-        mutex_init(&led->mutex);
-        INIT_WORK(&led->work, lm3533_led_work);
-
-        /* The class framework makes a callback to get brightness during
-         * registration so use parent device (for error reporting) until
-         * registered.
-         */
-        led->cb.lm3533 = lm3533;
-        led->cb.id = lm3533_led_get_ctrlbank_id(led);
-        led->cb.dev = lm3533->dev;
-
-        platform_set_drvdata(pdev, led);
-
-        ret = led_classdev_register(pdev->dev.parent, &led->cdev);
-        if (ret) {
-                dev_err(&pdev->dev, "failed to register LED %d\n", pdev->id);
-                return ret;
-        }
-
-        led->cb.dev = led->cdev.dev;
-
-        ret = sysfs_create_group(&led->cdev.dev->kobj,
-                                                &lm3533_led_attribute_group);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "failed to create sysfs attributes\n");
-                goto err_unregister;
-        }
-
-        ret = lm3533_led_setup(led, pdata);
-        if (ret)
-                goto err_sysfs_remove;
-
-        ret = lm3533_ctrlbank_enable(&led->cb);
-        if (ret)
-                goto err_sysfs_remove;
-
-        return 0;
-
-err_sysfs_remove:
-        sysfs_remove_group(&led->cdev.dev->kobj, &lm3533_led_attribute_group);
-err_unregister:
-        led_classdev_unregister(&led->cdev);
-        flush_work(&led->work);
-
-        return ret;
-}
-
-static int lm3533_led_remove(struct platform_device *pdev)
-{
-        struct lm3533_led *led = platform_get_drvdata(pdev);
-
-        dev_dbg(&pdev->dev, "%s\n", __func__);
-
-        lm3533_ctrlbank_disable(&led->cb);
-        sysfs_remove_group(&led->cdev.dev->kobj, &lm3533_led_attribute_group);
-        led_classdev_unregister(&led->cdev);
-        flush_work(&led->work);
-
-        return 0;
-}
-
-static void lm3533_led_shutdown(struct platform_device *pdev)
-{
-
-        struct lm3533_led *led = platform_get_drvdata(pdev);
-
-        dev_dbg(&pdev->dev, "%s\n", __func__);
-
-        lm3533_ctrlbank_disable(&led->cb);
-        lm3533_led_set(&led->cdev, LED_OFF);            /* disable blink */
-        flush_work(&led->work);
-}
-
-static struct platform_driver lm3533_led_driver = {
-        .driver = {
-                .name = "lm3533-leds",
-                .owner = THIS_MODULE,
-        },
-        .probe          = lm3533_led_probe,
-        .remove         = lm3533_led_remove,
-        .shutdown       = lm3533_led_shutdown,
-};
-module_platform_driver(lm3533_led_driver);
-
-MODULE_AUTHOR("Johan Hovold <jhovold@gmail.com>");
-MODULE_DESCRIPTION("LM3533 LED driver");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:lm3533-leds");
diff --git a/drivers/leds/leds-lm355x.c b/drivers/leds/leds-lm355x.c
deleted file mode 100644
index 65d79284c48..00000000000
--- a/drivers/leds/leds-lm355x.c
+++ /dev/null
@@ -1,572 +0,0 @@
-/*
-* Simple driver for Texas Instruments LM355x LED Flash driver chip
-* Copyright (C) 2012 Texas Instruments
-*
-* 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.
-*/
-
-#include <linux/module.h>
-#include <linux/delay.h>
-#include <linux/i2c.h>
-#include <linux/gpio.h>
-#include <linux/leds.h>
-#include <linux/slab.h>
-#include <linux/platform_device.h>
-#include <linux/fs.h>
-#include <linux/regmap.h>
-#include <linux/workqueue.h>
-#include <linux/platform_data/leds-lm355x.h>
-
-enum lm355x_type {
-        CHIP_LM3554 = 0,
-        CHIP_LM3556,
-};
-
-enum lm355x_regs {
-        REG_FLAG = 0,
-        REG_TORCH_CFG,
-        REG_TORCH_CTRL,
-        REG_STROBE_CFG,
-        REG_FLASH_CTRL,
-        REG_INDI_CFG,
-        REG_INDI_CTRL,
-        REG_OPMODE,
-        REG_MAX,
-};
-
-/* operation mode */
-enum lm355x_mode {
-        MODE_SHDN = 0,
-        MODE_INDIC,
-        MODE_TORCH,
-        MODE_FLASH
-};
-
-/* register map info. */
-struct lm355x_reg_data {
-        u8 regno;
-        u8 mask;
-        u8 shift;
-};
-
-struct lm355x_chip_data {
-        struct device *dev;
-        enum lm355x_type type;
-
-        struct led_classdev cdev_flash;
-        struct led_classdev cdev_torch;
-        struct led_classdev cdev_indicator;
-
-        struct work_struct work_flash;
-        struct work_struct work_torch;
-        struct work_struct work_indicator;
-
-        u8 br_flash;
-        u8 br_torch;
-        u8 br_indicator;
-
-        struct lm355x_platform_data *pdata;
-        struct regmap *regmap;
-        struct mutex lock;
-
-        unsigned int last_flag;
-        struct lm355x_reg_data *regs;
-};
-
-/* specific indicator function for lm3556 */
-enum lm3556_indic_pulse_time {
-        PULSE_TIME_0_MS = 0,
-        PULSE_TIME_32_MS,
-        PULSE_TIME_64_MS,
-        PULSE_TIME_92_MS,
-        PULSE_TIME_128_MS,
-        PULSE_TIME_160_MS,
-        PULSE_TIME_196_MS,
-        PULSE_TIME_224_MS,
-        PULSE_TIME_256_MS,
-        PULSE_TIME_288_MS,
-        PULSE_TIME_320_MS,
-        PULSE_TIME_352_MS,
-        PULSE_TIME_384_MS,
-        PULSE_TIME_416_MS,
-        PULSE_TIME_448_MS,
-        PULSE_TIME_480_MS,
-};
-
-enum lm3556_indic_n_blank {
-        INDIC_N_BLANK_0 = 0,
-        INDIC_N_BLANK_1,
-        INDIC_N_BLANK_2,
-        INDIC_N_BLANK_3,
-        INDIC_N_BLANK_4,
-        INDIC_N_BLANK_5,
-        INDIC_N_BLANK_6,
-        INDIC_N_BLANK_7,
-        INDIC_N_BLANK_8,
-        INDIC_N_BLANK_9,
-        INDIC_N_BLANK_10,
-        INDIC_N_BLANK_11,
-        INDIC_N_BLANK_12,
-        INDIC_N_BLANK_13,
-        INDIC_N_BLANK_14,
-        INDIC_N_BLANK_15,
-};
-
-enum lm3556_indic_period {
-        INDIC_PERIOD_0 = 0,
-        INDIC_PERIOD_1,
-        INDIC_PERIOD_2,
-        INDIC_PERIOD_3,
-        INDIC_PERIOD_4,
-        INDIC_PERIOD_5,
-        INDIC_PERIOD_6,
-        INDIC_PERIOD_7,
-};
-
-#define INDIC_PATTERN_SIZE 4
-
-struct indicator {
-        u8 blinking;
-        u8 period_cnt;
-};
-
-/* indicator pattern data only for lm3556 */
-static struct indicator indicator_pattern[INDIC_PATTERN_SIZE] = {
-        [0] = {(INDIC_N_BLANK_1 << 4) | PULSE_TIME_32_MS, INDIC_PERIOD_1},
-        [1] = {(INDIC_N_BLANK_15 << 4) | PULSE_TIME_32_MS, INDIC_PERIOD_2},
-        [2] = {(INDIC_N_BLANK_10 << 4) | PULSE_TIME_32_MS, INDIC_PERIOD_4},
-        [3] = {(INDIC_N_BLANK_5 << 4) | PULSE_TIME_32_MS, INDIC_PERIOD_7},
-};
-
-static struct lm355x_reg_data lm3554_regs[REG_MAX] = {
-        [REG_FLAG] = {0xD0, 0xBF, 0},
-        [REG_TORCH_CFG] = {0xE0, 0x80, 7},
-        [REG_TORCH_CTRL] = {0xA0, 0x38, 3},
-        [REG_STROBE_CFG] = {0xE0, 0x04, 2},
-        [REG_FLASH_CTRL] = {0xB0, 0x78, 3},
-        [REG_INDI_CFG] = {0xE0, 0x08, 3},
-        [REG_INDI_CTRL] = {0xA0, 0xC0, 6},
-        [REG_OPMODE] = {0xA0, 0x03, 0},
-};
-
-static struct lm355x_reg_data lm3556_regs[REG_MAX] = {
-        [REG_FLAG] = {0x0B, 0xFF, 0},
-        [REG_TORCH_CFG] = {0x0A, 0x10, 4},
-        [REG_TORCH_CTRL] = {0x09, 0x70, 4},
-        [REG_STROBE_CFG] = {0x0A, 0x20, 5},
-        [REG_FLASH_CTRL] = {0x09, 0x0F, 0},
-        [REG_INDI_CFG] = {0xFF, 0xFF, 0},
-        [REG_INDI_CTRL] = {0x09, 0x70, 4},
-        [REG_OPMODE] = {0x0A, 0x03, 0},
-};
-
-static char lm355x_name[][I2C_NAME_SIZE] = {
-        [CHIP_LM3554] = LM3554_NAME,
-        [CHIP_LM3556] = LM3556_NAME,
-};
-
-/* chip initialize */
-static int lm355x_chip_init(struct lm355x_chip_data *chip)
-{
-        int ret;
-        unsigned int reg_val;
-        struct lm355x_platform_data *pdata = chip->pdata;
-
-        /* input and output pins configuration */
-        switch (chip->type) {
-        case CHIP_LM3554:
-                reg_val = pdata->pin_tx2 | pdata->ntc_pin;
-                ret = regmap_update_bits(chip->regmap, 0xE0, 0x28, reg_val);
-                if (ret < 0)
-                        goto out;
-                reg_val = pdata->pass_mode;
-                ret = regmap_update_bits(chip->regmap, 0xA0, 0x04, reg_val);
-                if (ret < 0)
-                        goto out;
-                break;
-
-        case CHIP_LM3556:
-                reg_val = pdata->pin_tx2 | pdata->ntc_pin | pdata->pass_mode;
-                ret = regmap_update_bits(chip->regmap, 0x0A, 0xC4, reg_val);
-                if (ret < 0)
-                        goto out;
-                break;
-        default:
-                return -ENODATA;
-        }
-
-        return ret;
-out:
-        dev_err(chip->dev, "%s:i2c access fail to register\n", __func__);
-        return ret;
-}
-
-/* chip control */
-static void lm355x_control(struct lm355x_chip_data *chip,
-                           u8 brightness, enum lm355x_mode opmode)
-{
-        int ret;
-        unsigned int reg_val;
-        struct lm355x_platform_data *pdata = chip->pdata;
-        struct lm355x_reg_data *preg = chip->regs;
-
-        ret = regmap_read(chip->regmap, preg[REG_FLAG].regno, &chip->last_flag);
-        if (ret < 0)
-                goto out;
-        if (chip->last_flag & preg[REG_FLAG].mask)
-                dev_info(chip->dev, "%s Last FLAG is 0x%x\n",
-                         lm355x_name[chip->type],
-                         chip->last_flag & preg[REG_FLAG].mask);
-        /* brightness 0 means shutdown */
-        if (!brightness)
-                opmode = MODE_SHDN;
-
-        switch (opmode) {
-        case MODE_TORCH:
-                ret =
-                    regmap_update_bits(chip->regmap, preg[REG_TORCH_CTRL].regno,
-                                       preg[REG_TORCH_CTRL].mask,
-                                       (brightness - 1)
-                                       << preg[REG_TORCH_CTRL].shift);
-                if (ret < 0)
-                        goto out;
-
-                if (pdata->pin_tx1 != LM355x_PIN_TORCH_DISABLE) {
-                        ret =
-                            regmap_update_bits(chip->regmap,
-                                               preg[REG_TORCH_CFG].regno,
-                                               preg[REG_TORCH_CFG].mask,
-                                               0x01 <<
-                                               preg[REG_TORCH_CFG].shift);
-                        if (ret < 0)
-                                goto out;
-                        opmode = MODE_SHDN;
-                        dev_info(chip->dev,
-                                 "torch brt is set - ext. torch pin mode\n");
-                }
-                break;
-
-        case MODE_FLASH:
-
-                ret =
-                    regmap_update_bits(chip->regmap, preg[REG_FLASH_CTRL].regno,
-                                       preg[REG_FLASH_CTRL].mask,
-                                       (brightness - 1)
-                                       << preg[REG_FLASH_CTRL].shift);
-                if (ret < 0)
-                        goto out;
-
-                if (pdata->pin_strobe != LM355x_PIN_STROBE_DISABLE) {
-                        if (chip->type == CHIP_LM3554)
-                                reg_val = 0x00;
-                        else
-                                reg_val = 0x01;
-                        ret =
-                            regmap_update_bits(chip->regmap,
-                                               preg[REG_STROBE_CFG].regno,
-                                               preg[REG_STROBE_CFG].mask,
-                                               reg_val <<
-                                               preg[REG_STROBE_CFG].shift);
-                        if (ret < 0)
-                                goto out;
-                        opmode = MODE_SHDN;
-                        dev_info(chip->dev,
-                                 "flash brt is set - ext. strobe pin mode\n");
-                }
-                break;
-
-        case MODE_INDIC:
-                ret =
-                    regmap_update_bits(chip->regmap, preg[REG_INDI_CTRL].regno,
-                                       preg[REG_INDI_CTRL].mask,
-                                       (brightness - 1)
-                                       << preg[REG_INDI_CTRL].shift);
-                if (ret < 0)
-                        goto out;
-
-                if (pdata->pin_tx2 != LM355x_PIN_TX_DISABLE) {
-                        ret =
-                            regmap_update_bits(chip->regmap,
-                                               preg[REG_INDI_CFG].regno,
-                                               preg[REG_INDI_CFG].mask,
-                                               0x01 <<
-                                               preg[REG_INDI_CFG].shift);
-                        if (ret < 0)
-                                goto out;
-                        opmode = MODE_SHDN;
-                }
-                break;
-        case MODE_SHDN:
-                break;
-        default:
-                return;
-        }
-        /* operation mode control */
-        ret = regmap_update_bits(chip->regmap, preg[REG_OPMODE].regno,
-                                 preg[REG_OPMODE].mask,
-                                 opmode << preg[REG_OPMODE].shift);
-        if (ret < 0)
-                goto out;
-        return;
-out:
-        dev_err(chip->dev, "%s:i2c access fail to register\n", __func__);
-        return;
-}
-
-/* torch */
-static void lm355x_deferred_torch_brightness_set(struct work_struct *work)
-{
-        struct lm355x_chip_data *chip =
-            container_of(work, struct lm355x_chip_data, work_torch);
-
-        mutex_lock(&chip->lock);
-        lm355x_control(chip, chip->br_torch, MODE_TORCH);
-        mutex_unlock(&chip->lock);
-}
-
-static void lm355x_torch_brightness_set(struct led_classdev *cdev,
-                                        enum led_brightness brightness)
-{
-        struct lm355x_chip_data *chip =
-            container_of(cdev, struct lm355x_chip_data, cdev_torch);
-
-        chip->br_torch = brightness;
-        schedule_work(&chip->work_torch);
-}
-
-/* flash */
-static void lm355x_deferred_strobe_brightness_set(struct work_struct *work)
-{
-        struct lm355x_chip_data *chip =
-            container_of(work, struct lm355x_chip_data, work_flash);
-
-        mutex_lock(&chip->lock);
-        lm355x_control(chip, chip->br_flash, MODE_FLASH);
-        mutex_unlock(&chip->lock);
-}
-
-static void lm355x_strobe_brightness_set(struct led_classdev *cdev,
-                                         enum led_brightness brightness)
-{
-        struct lm355x_chip_data *chip =
-            container_of(cdev, struct lm355x_chip_data, cdev_flash);
-
-        chip->br_flash = brightness;
-        schedule_work(&chip->work_flash);
-}
-
-/* indicator */
-static void lm355x_deferred_indicator_brightness_set(struct work_struct *work)
-{
-        struct lm355x_chip_data *chip =
-            container_of(work, struct lm355x_chip_data, work_indicator);
-
-        mutex_lock(&chip->lock);
-        lm355x_control(chip, chip->br_indicator, MODE_INDIC);
-        mutex_unlock(&chip->lock);
-}
-
-static void lm355x_indicator_brightness_set(struct led_classdev *cdev,
-                                            enum led_brightness brightness)
-{
-        struct lm355x_chip_data *chip =
-            container_of(cdev, struct lm355x_chip_data, cdev_indicator);
-
-        chip->br_indicator = brightness;
-        schedule_work(&chip->work_indicator);
-}
-
-/* indicator pattern only for lm3556*/
-static ssize_t lm3556_indicator_pattern_store(struct device *dev,
-                                              struct device_attribute *devAttr,
-                                              const char *buf, size_t size)
-{
-        ssize_t ret;
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct lm355x_chip_data *chip =
-            container_of(led_cdev, struct lm355x_chip_data, cdev_indicator);
-        unsigned int state;
-
-        ret = kstrtouint(buf, 10, &state);
-        if (ret)
-                goto out;
-        if (state > INDIC_PATTERN_SIZE - 1)
-                state = INDIC_PATTERN_SIZE - 1;
-
-        ret = regmap_write(chip->regmap, 0x04,
-                           indicator_pattern[state].blinking);
-        if (ret < 0)
-                goto out;
-
-        ret = regmap_write(chip->regmap, 0x05,
-                           indicator_pattern[state].period_cnt);
-        if (ret < 0)
-                goto out;
-
-        return size;
-out:
-        dev_err(chip->dev, "%s:i2c access fail to register\n", __func__);
-        return ret;
-}
-
-static DEVICE_ATTR(pattern, S_IWUSR, NULL, lm3556_indicator_pattern_store);
-
-static const struct regmap_config lm355x_regmap = {
-        .reg_bits = 8,
-        .val_bits = 8,
-        .max_register = 0xFF,
-};
-
-/* module initialize */
-static int lm355x_probe(struct i2c_client *client,
-                                  const struct i2c_device_id *id)
-{
-        struct lm355x_platform_data *pdata = client->dev.platform_data;
-        struct lm355x_chip_data *chip;
-
-        int err;
-
-        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
-                dev_err(&client->dev, "i2c functionality check fail.\n");
-                return -EOPNOTSUPP;
-        }
-
-        if (pdata == NULL) {
-                dev_err(&client->dev, "needs Platform Data.\n");
-                return -ENODATA;
-        }
-
-        chip = devm_kzalloc(&client->dev,
-                            sizeof(struct lm355x_chip_data), GFP_KERNEL);
-        if (!chip)
-                return -ENOMEM;
-
-        chip->dev = &client->dev;
-        chip->type = id->driver_data;
-        switch (id->driver_data) {
-        case CHIP_LM3554:
-                chip->regs = lm3554_regs;
-                break;
-        case CHIP_LM3556:
-                chip->regs = lm3556_regs;
-                break;
-        default:
-                return -ENOSYS;
-        }
-        chip->pdata = pdata;
-
-        chip->regmap = devm_regmap_init_i2c(client, &lm355x_regmap);
-        if (IS_ERR(chip->regmap)) {
-                err = PTR_ERR(chip->regmap);
-                dev_err(&client->dev,
-                        "Failed to allocate register map: %d\n", err);
-                return err;
-        }
-
-        mutex_init(&chip->lock);
-        i2c_set_clientdata(client, chip);
-
-        err = lm355x_chip_init(chip);
-        if (err < 0)
-                goto err_out;
-
-        /* flash */
-        INIT_WORK(&chip->work_flash, lm355x_deferred_strobe_brightness_set);
-        chip->cdev_flash.name = "flash";
-        chip->cdev_flash.max_brightness = 16;
-        chip->cdev_flash.brightness_set = lm355x_strobe_brightness_set;
-        err = led_classdev_register((struct device *)
-                                    &client->dev, &chip->cdev_flash);
-        if (err < 0)
-                goto err_out;
-        /* torch */
-        INIT_WORK(&chip->work_torch, lm355x_deferred_torch_brightness_set);
-        chip->cdev_torch.name = "torch";
-        chip->cdev_torch.max_brightness = 8;
-        chip->cdev_torch.brightness_set = lm355x_torch_brightness_set;
-        err = led_classdev_register((struct device *)
-                                    &client->dev, &chip->cdev_torch);
-        if (err < 0)
-                goto err_create_torch_file;
-        /* indicator */
-        INIT_WORK(&chip->work_indicator,
-                  lm355x_deferred_indicator_brightness_set);
-        chip->cdev_indicator.name = "indicator";
-        if (id->driver_data == CHIP_LM3554)
-                chip->cdev_indicator.max_brightness = 4;
-        else
-                chip->cdev_indicator.max_brightness = 8;
-        chip->cdev_indicator.brightness_set = lm355x_indicator_brightness_set;
-        err = led_classdev_register((struct device *)
-                                    &client->dev, &chip->cdev_indicator);
-        if (err < 0)
-                goto err_create_indicator_file;
-        /* indicator pattern control only for LM3554 */
-        if (id->driver_data == CHIP_LM3556) {
-                err =
-                    device_create_file(chip->cdev_indicator.dev,
-                                       &dev_attr_pattern);
-                if (err < 0)
-                        goto err_create_pattern_file;
-        }
-
-        dev_info(&client->dev, "%s is initialized\n",
-                 lm355x_name[id->driver_data]);
-        return 0;
-
-err_create_pattern_file:
-        led_classdev_unregister(&chip->cdev_indicator);
-err_create_indicator_file:
-        led_classdev_unregister(&chip->cdev_torch);
-err_create_torch_file:
-        led_classdev_unregister(&chip->cdev_flash);
-err_out:
-        return err;
-}
-
-static int lm355x_remove(struct i2c_client *client)
-{
-        struct lm355x_chip_data *chip = i2c_get_clientdata(client);
-        struct lm355x_reg_data *preg = chip->regs;
-
-        regmap_write(chip->regmap, preg[REG_OPMODE].regno, 0);
-        if (chip->type == CHIP_LM3556)
-                device_remove_file(chip->cdev_indicator.dev, &dev_attr_pattern);
-        led_classdev_unregister(&chip->cdev_indicator);
-        flush_work(&chip->work_indicator);
-        led_classdev_unregister(&chip->cdev_torch);
-        flush_work(&chip->work_torch);
-        led_classdev_unregister(&chip->cdev_flash);
-        flush_work(&chip->work_flash);
-        dev_info(&client->dev, "%s is removed\n", lm355x_name[chip->type]);
-
-        return 0;
-}
-
-static const struct i2c_device_id lm355x_id[] = {
-        {LM3554_NAME, CHIP_LM3554},
-        {LM3556_NAME, CHIP_LM3556},
-        {}
-};
-
-MODULE_DEVICE_TABLE(i2c, lm355x_id);
-
-static struct i2c_driver lm355x_i2c_driver = {
-        .driver = {
-                   .name = LM355x_NAME,
-                   .owner = THIS_MODULE,
-                   .pm = NULL,
-                   },
-        .probe = lm355x_probe,
-        .remove = lm355x_remove,
-        .id_table = lm355x_id,
-};
-
-module_i2c_driver(lm355x_i2c_driver);
-
-MODULE_DESCRIPTION("Texas Instruments Flash Lighting driver for LM355x");
-MODULE_AUTHOR("Daniel Jeong <daniel.jeong@ti.com>");
-MODULE_AUTHOR("G.Shark Jeong <gshark.jeong@gmail.com>");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/leds/leds-lm3642.c b/drivers/leds/leds-lm3642.c
deleted file mode 100644
index 07b3dde9061..00000000000
--- a/drivers/leds/leds-lm3642.c
+++ /dev/null
@@ -1,462 +0,0 @@
-/*
-* Simple driver for Texas Instruments LM3642 LED Flash driver chip
-* Copyright (C) 2012 Texas Instruments
-*
-* 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.
-*
-*/
-#include <linux/module.h>
-#include <linux/delay.h>
-#include <linux/i2c.h>
-#include <linux/leds.h>
-#include <linux/slab.h>
-#include <linux/platform_device.h>
-#include <linux/fs.h>
-#include <linux/regmap.h>
-#include <linux/workqueue.h>
-#include <linux/platform_data/leds-lm3642.h>
-
-#define REG_FILT_TIME                   (0x0)
-#define REG_IVFM_MODE                   (0x1)
-#define REG_TORCH_TIME                  (0x6)
-#define REG_FLASH                       (0x8)
-#define REG_I_CTRL                      (0x9)
-#define REG_ENABLE                      (0xA)
-#define REG_FLAG                        (0xB)
-#define REG_MAX                         (0xB)
-
-#define UVLO_EN_SHIFT                   (7)
-#define IVM_D_TH_SHIFT                  (2)
-#define TORCH_RAMP_UP_TIME_SHIFT        (3)
-#define TORCH_RAMP_DN_TIME_SHIFT        (0)
-#define INDUCTOR_I_LIMIT_SHIFT          (6)
-#define FLASH_RAMP_TIME_SHIFT           (3)
-#define FLASH_TOUT_TIME_SHIFT           (0)
-#define TORCH_I_SHIFT                   (4)
-#define FLASH_I_SHIFT                   (0)
-#define IVFM_SHIFT                      (7)
-#define TX_PIN_EN_SHIFT                 (6)
-#define STROBE_PIN_EN_SHIFT             (5)
-#define TORCH_PIN_EN_SHIFT              (4)
-#define MODE_BITS_SHIFT                 (0)
-
-#define UVLO_EN_MASK                    (0x1)
-#define IVM_D_TH_MASK                   (0x7)
-#define TORCH_RAMP_UP_TIME_MASK         (0x7)
-#define TORCH_RAMP_DN_TIME_MASK         (0x7)
-#define INDUCTOR_I_LIMIT_MASK           (0x1)
-#define FLASH_RAMP_TIME_MASK            (0x7)
-#define FLASH_TOUT_TIME_MASK            (0x7)
-#define TORCH_I_MASK                    (0x7)
-#define FLASH_I_MASK                    (0xF)
-#define IVFM_MASK                       (0x1)
-#define TX_PIN_EN_MASK                  (0x1)
-#define STROBE_PIN_EN_MASK              (0x1)
-#define TORCH_PIN_EN_MASK               (0x1)
-#define MODE_BITS_MASK                  (0x73)
-#define EX_PIN_CONTROL_MASK             (0x71)
-#define EX_PIN_ENABLE_MASK              (0x70)
-
-enum lm3642_mode {
-        MODES_STASNDBY = 0,
-        MODES_INDIC,
-        MODES_TORCH,
-        MODES_FLASH
-};
-
-struct lm3642_chip_data {
-        struct device *dev;
-
-        struct led_classdev cdev_flash;
-        struct led_classdev cdev_torch;
-        struct led_classdev cdev_indicator;
-
-        struct work_struct work_flash;
-        struct work_struct work_torch;
-        struct work_struct work_indicator;
-
-        u8 br_flash;
-        u8 br_torch;
-        u8 br_indicator;
-
-        enum lm3642_torch_pin_enable torch_pin;
-        enum lm3642_strobe_pin_enable strobe_pin;
-        enum lm3642_tx_pin_enable tx_pin;
-
-        struct lm3642_platform_data *pdata;
-        struct regmap *regmap;
-        struct mutex lock;
-
-        unsigned int last_flag;
-};
-
-/* chip initialize */
-static int lm3642_chip_init(struct lm3642_chip_data *chip)
-{
-        int ret;
-        struct lm3642_platform_data *pdata = chip->pdata;
-
-        /* set enable register */
-        ret = regmap_update_bits(chip->regmap, REG_ENABLE, EX_PIN_ENABLE_MASK,
-                                 pdata->tx_pin);
-        if (ret < 0)
-                dev_err(chip->dev, "Failed to update REG_ENABLE Register\n");
-        return ret;
-}
-
-/* chip control */
-static int lm3642_control(struct lm3642_chip_data *chip,
-                          u8 brightness, enum lm3642_mode opmode)
-{
-        int ret;
-
-        ret = regmap_read(chip->regmap, REG_FLAG, &chip->last_flag);
-        if (ret < 0) {
-                dev_err(chip->dev, "Failed to read REG_FLAG Register\n");
-                goto out;
-        }
-
-        if (chip->last_flag)
-                dev_info(chip->dev, "Last FLAG is 0x%x\n", chip->last_flag);
-
-        /* brightness 0 means off-state */
-        if (!brightness)
-                opmode = MODES_STASNDBY;
-
-        switch (opmode) {
-        case MODES_TORCH:
-                ret = regmap_update_bits(chip->regmap, REG_I_CTRL,
-                                         TORCH_I_MASK << TORCH_I_SHIFT,
-                                         (brightness - 1) << TORCH_I_SHIFT);
-
-                if (chip->torch_pin)
-                        opmode |= (TORCH_PIN_EN_MASK << TORCH_PIN_EN_SHIFT);
-                break;
-
-        case MODES_FLASH:
-                ret = regmap_update_bits(chip->regmap, REG_I_CTRL,
-                                         FLASH_I_MASK << FLASH_I_SHIFT,
-                                         (brightness - 1) << FLASH_I_SHIFT);
-
-                if (chip->strobe_pin)
-                        opmode |= (STROBE_PIN_EN_MASK << STROBE_PIN_EN_SHIFT);
-                break;
-
-        case MODES_INDIC:
-                ret = regmap_update_bits(chip->regmap, REG_I_CTRL,
-                                         TORCH_I_MASK << TORCH_I_SHIFT,
-                                         (brightness - 1) << TORCH_I_SHIFT);
-                break;
-
-        case MODES_STASNDBY:
-
-                break;
-
-        default:
-                return ret;
-        }
-        if (ret < 0) {
-                dev_err(chip->dev, "Failed to write REG_I_CTRL Register\n");
-                goto out;
-        }
-
-        if (chip->tx_pin)
-                opmode |= (TX_PIN_EN_MASK << TX_PIN_EN_SHIFT);
-
-        ret = regmap_update_bits(chip->regmap, REG_ENABLE,
-                                 MODE_BITS_MASK << MODE_BITS_SHIFT,
-                                 opmode << MODE_BITS_SHIFT);
-out:
-        return ret;
-}
-
-/* torch */
-
-/* torch pin config for lm3642*/
-static ssize_t lm3642_torch_pin_store(struct device *dev,
-                                      struct device_attribute *devAttr,
-                                      const char *buf, size_t size)
-{
-        ssize_t ret;
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct lm3642_chip_data *chip =
-            container_of(led_cdev, struct lm3642_chip_data, cdev_indicator);
-        unsigned int state;
-
-        ret = kstrtouint(buf, 10, &state);
-        if (ret)
-                goto out_strtoint;
-        if (state != 0)
-                state = 0x01 << TORCH_PIN_EN_SHIFT;
-
-        chip->torch_pin = state;
-        ret = regmap_update_bits(chip->regmap, REG_ENABLE,
-                                 TORCH_PIN_EN_MASK << TORCH_PIN_EN_SHIFT,
-                                 state);
-        if (ret < 0)
-                goto out;
-
-        return size;
-out:
-        dev_err(chip->dev, "%s:i2c access fail to register\n", __func__);
-        return ret;
-out_strtoint:
-        dev_err(chip->dev, "%s: fail to change str to int\n", __func__);
-        return ret;
-}
-
-static DEVICE_ATTR(torch_pin, S_IWUSR, NULL, lm3642_torch_pin_store);
-
-static void lm3642_deferred_torch_brightness_set(struct work_struct *work)
-{
-        struct lm3642_chip_data *chip =
-            container_of(work, struct lm3642_chip_data, work_torch);
-
-        mutex_lock(&chip->lock);
-        lm3642_control(chip, chip->br_torch, MODES_TORCH);
-        mutex_unlock(&chip->lock);
-}
-
-static void lm3642_torch_brightness_set(struct led_classdev *cdev,
-                                        enum led_brightness brightness)
-{
-        struct lm3642_chip_data *chip =
-            container_of(cdev, struct lm3642_chip_data, cdev_torch);
-
-        chip->br_torch = brightness;
-        schedule_work(&chip->work_torch);
-}
-
-/* flash */
-
-/* strobe pin config for lm3642*/
-static ssize_t lm3642_strobe_pin_store(struct device *dev,
-                                       struct device_attribute *devAttr,
-                                       const char *buf, size_t size)
-{
-        ssize_t ret;
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct lm3642_chip_data *chip =
-            container_of(led_cdev, struct lm3642_chip_data, cdev_indicator);
-        unsigned int state;
-
-        ret = kstrtouint(buf, 10, &state);
-        if (ret)
-                goto out_strtoint;
-        if (state != 0)
-                state = 0x01 << STROBE_PIN_EN_SHIFT;
-
-        chip->strobe_pin = state;
-        ret = regmap_update_bits(chip->regmap, REG_ENABLE,
-                                 STROBE_PIN_EN_MASK << STROBE_PIN_EN_SHIFT,
-                                 state);
-        if (ret < 0)
-                goto out;
-
-        return size;
-out:
-        dev_err(chip->dev, "%s:i2c access fail to register\n", __func__);
-        return ret;
-out_strtoint:
-        dev_err(chip->dev, "%s: fail to change str to int\n", __func__);
-        return ret;
-}
-
-static DEVICE_ATTR(strobe_pin, S_IWUSR, NULL, lm3642_strobe_pin_store);
-
-static void lm3642_deferred_strobe_brightness_set(struct work_struct *work)
-{
-        struct lm3642_chip_data *chip =
-            container_of(work, struct lm3642_chip_data, work_flash);
-
-        mutex_lock(&chip->lock);
-        lm3642_control(chip, chip->br_flash, MODES_FLASH);
-        mutex_unlock(&chip->lock);
-}
-
-static void lm3642_strobe_brightness_set(struct led_classdev *cdev,
-                                         enum led_brightness brightness)
-{
-        struct lm3642_chip_data *chip =
-            container_of(cdev, struct lm3642_chip_data, cdev_flash);
-
-        chip->br_flash = brightness;
-        schedule_work(&chip->work_flash);
-}
-
-/* indicator */
-static void lm3642_deferred_indicator_brightness_set(struct work_struct *work)
-{
-        struct lm3642_chip_data *chip =
-            container_of(work, struct lm3642_chip_data, work_indicator);
-
-        mutex_lock(&chip->lock);
-        lm3642_control(chip, chip->br_indicator, MODES_INDIC);
-        mutex_unlock(&chip->lock);
-}
-
-static void lm3642_indicator_brightness_set(struct led_classdev *cdev,
-                                            enum led_brightness brightness)
-{
-        struct lm3642_chip_data *chip =
-            container_of(cdev, struct lm3642_chip_data, cdev_indicator);
-
-        chip->br_indicator = brightness;
-        schedule_work(&chip->work_indicator);
-}
-
-static const struct regmap_config lm3642_regmap = {
-        .reg_bits = 8,
-        .val_bits = 8,
-        .max_register = REG_MAX,
-};
-
-static int lm3642_probe(struct i2c_client *client,
-                                  const struct i2c_device_id *id)
-{
-        struct lm3642_platform_data *pdata = client->dev.platform_data;
-        struct lm3642_chip_data *chip;
-
-        int err;
-
-        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
-                dev_err(&client->dev, "i2c functionality check fail.\n");
-                return -EOPNOTSUPP;
-        }
-
-        if (pdata == NULL) {
-                dev_err(&client->dev, "needs Platform Data.\n");
-                return -ENODATA;
-        }
-
-        chip = devm_kzalloc(&client->dev,
-                            sizeof(struct lm3642_chip_data), GFP_KERNEL);
-        if (!chip)
-                return -ENOMEM;
-
-        chip->dev = &client->dev;
-        chip->pdata = pdata;
-
-        chip->tx_pin = pdata->tx_pin;
-        chip->torch_pin = pdata->torch_pin;
-        chip->strobe_pin = pdata->strobe_pin;
-
-        chip->regmap = devm_regmap_init_i2c(client, &lm3642_regmap);
-        if (IS_ERR(chip->regmap)) {
-                err = PTR_ERR(chip->regmap);
-                dev_err(&client->dev, "Failed to allocate register map: %d\n",
-                        err);
-                return err;
-        }
-
-        mutex_init(&chip->lock);
-        i2c_set_clientdata(client, chip);
-
-        err = lm3642_chip_init(chip);
-        if (err < 0)
-                goto err_out;
-
-        /* flash */
-        INIT_WORK(&chip->work_flash, lm3642_deferred_strobe_brightness_set);
-        chip->cdev_flash.name = "flash";
-        chip->cdev_flash.max_brightness = 16;
-        chip->cdev_flash.brightness_set = lm3642_strobe_brightness_set;
-        err = led_classdev_register((struct device *)
-                                    &client->dev, &chip->cdev_flash);
-        if (err < 0) {
-                dev_err(chip->dev, "failed to register flash\n");
-                goto err_out;
-        }
-        err = device_create_file(chip->cdev_flash.dev, &dev_attr_strobe_pin);
-        if (err < 0) {
-                dev_err(chip->dev, "failed to create strobe-pin file\n");
-                goto err_create_flash_pin_file;
-        }
-
-        /* torch */
-        INIT_WORK(&chip->work_torch, lm3642_deferred_torch_brightness_set);
-        chip->cdev_torch.name = "torch";
-        chip->cdev_torch.max_brightness = 8;
-        chip->cdev_torch.brightness_set = lm3642_torch_brightness_set;
-        err = led_classdev_register((struct device *)
-                                    &client->dev, &chip->cdev_torch);
-        if (err < 0) {
-                dev_err(chip->dev, "failed to register torch\n");
-                goto err_create_torch_file;
-        }
-        err = device_create_file(chip->cdev_torch.dev, &dev_attr_torch_pin);
-        if (err < 0) {
-                dev_err(chip->dev, "failed to create torch-pin file\n");
-                goto err_create_torch_pin_file;
-        }
-
-        /* indicator */
-        INIT_WORK(&chip->work_indicator,
-                  lm3642_deferred_indicator_brightness_set);
-        chip->cdev_indicator.name = "indicator";
-        chip->cdev_indicator.max_brightness = 8;
-        chip->cdev_indicator.brightness_set = lm3642_indicator_brightness_set;
-        err = led_classdev_register((struct device *)
-                                    &client->dev, &chip->cdev_indicator);
-        if (err < 0) {
-                dev_err(chip->dev, "failed to register indicator\n");
-                goto err_create_indicator_file;
-        }
-
-        dev_info(&client->dev, "LM3642 is initialized\n");
-        return 0;
-
-err_create_indicator_file:
-        device_remove_file(chip->cdev_torch.dev, &dev_attr_torch_pin);
-err_create_torch_pin_file:
-        led_classdev_unregister(&chip->cdev_torch);
-err_create_torch_file:
-        device_remove_file(chip->cdev_flash.dev, &dev_attr_strobe_pin);
-err_create_flash_pin_file:
-        led_classdev_unregister(&chip->cdev_flash);
-err_out:
-        return err;
-}
-
-static int lm3642_remove(struct i2c_client *client)
-{
-        struct lm3642_chip_data *chip = i2c_get_clientdata(client);
-
-        led_classdev_unregister(&chip->cdev_indicator);
-        flush_work(&chip->work_indicator);
-        device_remove_file(chip->cdev_torch.dev, &dev_attr_torch_pin);
-        led_classdev_unregister(&chip->cdev_torch);
-        flush_work(&chip->work_torch);
-        device_remove_file(chip->cdev_flash.dev, &dev_attr_strobe_pin);
-        led_classdev_unregister(&chip->cdev_flash);
-        flush_work(&chip->work_flash);
-        regmap_write(chip->regmap, REG_ENABLE, 0);
-        return 0;
-}
-
-static const struct i2c_device_id lm3642_id[] = {
-        {LM3642_NAME, 0},
-        {}
-};
-
-MODULE_DEVICE_TABLE(i2c, lm3642_id);
-
-static struct i2c_driver lm3642_i2c_driver = {
-        .driver = {
-                   .name = LM3642_NAME,
-                   .owner = THIS_MODULE,
-                   .pm = NULL,
-                   },
-        .probe = lm3642_probe,
-        .remove = lm3642_remove,
-        .id_table = lm3642_id,
-};
-
-module_i2c_driver(lm3642_i2c_driver);
-
-MODULE_DESCRIPTION("Texas Instruments Flash Lighting driver for LM3642");
-MODULE_AUTHOR("Daniel Jeong <daniel.jeong@ti.com>");
-MODULE_AUTHOR("G.Shark Jeong <gshark.jeong@gmail.com>");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/leds/leds-locomo.c b/drivers/leds/leds-locomo.c
index 80ba048889d..1f7c10f6b7f 100644
--- a/drivers/leds/leds-locomo.c
+++ b/drivers/leds/leds-locomo.c
@@ -10,7 +10,6 @@
 
 #include <linux/kernel.h>
 #include <linux/init.h>
-#include <linux/module.h>
 #include <linux/device.h>
 #include <linux/leds.h>
 
diff --git a/drivers/leds/leds-lp3944.c b/drivers/leds/leds-lp3944.c
index 0c4386e656c..9010c054615 100644
--- a/drivers/leds/leds-lp3944.c
+++ b/drivers/leds/leds-lp3944.c
@@ -86,7 +86,7 @@ static int lp3944_reg_read(struct i2c_client *client, u8 reg, u8 *value)
 
         tmp = i2c_smbus_read_byte_data(client, reg);
         if (tmp < 0)
-                return tmp;
+                return -EINVAL;
 
         *value = tmp;
 
@@ -374,7 +374,7 @@ exit:
         return err;
 }
 
-static int lp3944_probe(struct i2c_client *client,
+static int __devinit lp3944_probe(struct i2c_client *client,
                                   const struct i2c_device_id *id)
 {
         struct lp3944_platform_data *lp3944_pdata = client->dev.platform_data;
@@ -393,8 +393,7 @@ static int lp3944_probe(struct i2c_client *client,
                 return -ENODEV;
         }
 
-        data = devm_kzalloc(&client->dev, sizeof(struct lp3944_data),
-                        GFP_KERNEL);
+        data = kzalloc(sizeof(struct lp3944_data), GFP_KERNEL);
         if (!data)
                 return -ENOMEM;
 
@@ -404,14 +403,16 @@ static int lp3944_probe(struct i2c_client *client,
         mutex_init(&data->lock);
 
         err = lp3944_configure(client, data, lp3944_pdata);
-        if (err < 0)
+        if (err < 0) {
+                kfree(data);
                 return err;
+        }
 
         dev_info(&client->dev, "lp3944 enabled\n");
         return 0;
 }
 
-static int lp3944_remove(struct i2c_client *client)
+static int __devexit lp3944_remove(struct i2c_client *client)
 {
         struct lp3944_platform_data *pdata = client->dev.platform_data;
         struct lp3944_data *data = i2c_get_clientdata(client);
@@ -430,6 +431,8 @@ static int lp3944_remove(struct i2c_client *client)
                         break;
                 }
 
+        kfree(data);
+
         return 0;
 }
 
@@ -446,11 +449,22 @@ static struct i2c_driver lp3944_driver = {
                    .name = "lp3944",
         },
         .probe    = lp3944_probe,
-        .remove   = lp3944_remove,
+        .remove   = __devexit_p(lp3944_remove),
         .id_table = lp3944_id,
 };
 
-module_i2c_driver(lp3944_driver);
+static int __init lp3944_module_init(void)
+{
+        return i2c_add_driver(&lp3944_driver);
+}
+
+static void __exit lp3944_module_exit(void)
+{
+        i2c_del_driver(&lp3944_driver);
+}
+
+module_init(lp3944_module_init);
+module_exit(lp3944_module_exit);
 
 MODULE_AUTHOR("Antonio Ospite <ospite@studenti.unina.it>");
 MODULE_DESCRIPTION("LP3944 Fun Light Chip");
diff --git a/drivers/leds/leds-lp5521.c b/drivers/leds/leds-lp5521.c
index cb8a5220200..9fc122c81f0 100644
--- a/drivers/leds/leds-lp5521.c
+++ b/drivers/leds/leds-lp5521.c
@@ -81,20 +81,22 @@
 #define LP5521_MASTER_ENABLE            0x40    /* Chip master enable */
 #define LP5521_LOGARITHMIC_PWM          0x80    /* Logarithmic PWM adjustment */
 #define LP5521_EXEC_RUN                 0x2A
-#define LP5521_ENABLE_DEFAULT   \
-        (LP5521_MASTER_ENABLE | LP5521_LOGARITHMIC_PWM)
-#define LP5521_ENABLE_RUN_PROGRAM       \
-        (LP5521_ENABLE_DEFAULT | LP5521_EXEC_RUN)
+
+/* Bits in CONFIG register */
+#define LP5521_PWM_HF                   0x40    /* PWM: 0 = 256Hz, 1 = 558Hz */
+#define LP5521_PWRSAVE_EN               0x20    /* 1 = Power save mode */
+#define LP5521_CP_MODE_OFF              0       /* Charge pump (CP) off */
+#define LP5521_CP_MODE_BYPASS           8       /* CP forced to bypass mode */
+#define LP5521_CP_MODE_1X5              0x10    /* CP forced to 1.5x mode */
+#define LP5521_CP_MODE_AUTO             0x18    /* Automatic mode selection */
+#define LP5521_R_TO_BATT                4       /* R out: 0 = CP, 1 = Vbat */
+#define LP5521_CLK_SRC_EXT              0       /* Ext-clk source (CLK_32K) */
+#define LP5521_CLK_INT                  1       /* Internal clock */
+#define LP5521_CLK_AUTO                 2       /* Automatic clock selection */
 
 /* Status */
 #define LP5521_EXT_CLK_USED             0x08
 
-/* default R channel current register value */
-#define LP5521_REG_R_CURR_DEFAULT       0xAF
-
-/* Pattern Mode */
-#define PATTERN_OFF     0
-
 struct lp5521_engine {
         int             id;
         u8              mode;
@@ -152,7 +154,7 @@ static int lp5521_read(struct i2c_client *client, u8 reg, u8 *buf)
 
         ret = i2c_smbus_read_byte_data(client, reg);
         if (ret < 0)
-                return ret;
+                return -EIO;
 
         *buf = ret;
         return 0;
@@ -173,14 +175,14 @@ static int lp5521_set_engine_mode(struct lp5521_engine *engine, u8 mode)
                 mode = LP5521_CMD_DIRECT;
 
         ret = lp5521_read(client, LP5521_REG_OP_MODE, &engine_state);
-        if (ret < 0)
-                return ret;
 
         /* set mode only for this engine */
         engine_state &= ~(engine->engine_mask);
         mode &= engine->engine_mask;
         engine_state |= mode;
-        return lp5521_write(client, LP5521_REG_OP_MODE, engine_state);
+        ret |= lp5521_write(client, LP5521_REG_OP_MODE, engine_state);
+
+        return ret;
 }
 
 static int lp5521_load_program(struct lp5521_engine *eng, const u8 *pattern)
@@ -193,14 +195,9 @@ static int lp5521_load_program(struct lp5521_engine *eng, const u8 *pattern)
 
         /* move current engine to direct mode and remember the state */
         ret = lp5521_set_engine_mode(eng, LP5521_CMD_DIRECT);
-        if (ret)
-                return ret;
-
         /* Mode change requires min 500 us delay. 1 - 2 ms  with margin */
         usleep_range(1000, 2000);
-        ret = lp5521_read(client, LP5521_REG_OP_MODE, &mode);
-        if (ret)
-                return ret;
+        ret |= lp5521_read(client, LP5521_REG_OP_MODE, &mode);
 
         /* For loading, all the engines to load mode */
         lp5521_write(client, LP5521_REG_OP_MODE, LP5521_CMD_DIRECT);
@@ -216,7 +213,8 @@ static int lp5521_load_program(struct lp5521_engine *eng, const u8 *pattern)
                                 LP5521_PROG_MEM_SIZE,
                                 pattern);
 
-        return lp5521_write(client, LP5521_REG_OP_MODE, mode);
+        ret |= lp5521_write(client, LP5521_REG_OP_MODE, mode);
+        return ret;
 }
 
 static int lp5521_set_led_current(struct lp5521_chip *chip, int led, u8 curr)
@@ -240,16 +238,15 @@ static int lp5521_configure(struct i2c_client *client)
 {
         struct lp5521_chip *chip = i2c_get_clientdata(client);
         int ret;
-        u8 cfg;
 
         lp5521_init_engine(chip);
 
         /* Set all PWMs to direct control mode */
-        ret = lp5521_write(client, LP5521_REG_OP_MODE, LP5521_CMD_DIRECT);
+        ret = lp5521_write(client, LP5521_REG_OP_MODE, 0x3F);
 
-        cfg = chip->pdata->update_config ?
-                : (LP5521_PWRSAVE_EN | LP5521_CP_MODE_AUTO | LP5521_R_TO_BATT);
-        ret |= lp5521_write(client, LP5521_REG_CONFIG, cfg);
+        /* Enable auto-powersave, set charge pump to auto, red to battery */
+        ret |= lp5521_write(client, LP5521_REG_CONFIG,
+                LP5521_PWRSAVE_EN | LP5521_CP_MODE_AUTO | LP5521_R_TO_BATT);
 
         /* Initialize all channels PWM to zero -> leds off */
         ret |= lp5521_write(client, LP5521_REG_R_PWM, 0);
@@ -258,7 +255,8 @@ static int lp5521_configure(struct i2c_client *client)
 
         /* Set engines are set to run state when OP_MODE enables engines */
         ret |= lp5521_write(client, LP5521_REG_ENABLE,
-                        LP5521_ENABLE_RUN_PROGRAM);
+                        LP5521_MASTER_ENABLE | LP5521_LOGARITHMIC_PWM |
+                        LP5521_EXEC_RUN);
         /* enable takes 500us. 1 - 2 ms leaves some margin */
         usleep_range(1000, 2000);
 
@@ -309,7 +307,8 @@ static int lp5521_detect(struct i2c_client *client)
         int ret;
         u8 buf;
 
-        ret = lp5521_write(client, LP5521_REG_ENABLE, LP5521_ENABLE_DEFAULT);
+        ret = lp5521_write(client, LP5521_REG_ENABLE,
+                        LP5521_MASTER_ENABLE | LP5521_LOGARITHMIC_PWM);
         if (ret)
                 return ret;
         /* enable takes 500us. 1 - 2 ms leaves some margin */
@@ -317,7 +316,7 @@ static int lp5521_detect(struct i2c_client *client)
         ret = lp5521_read(client, LP5521_REG_ENABLE, &buf);
         if (ret)
                 return ret;
-        if (buf != LP5521_ENABLE_DEFAULT)
+        if (buf != (LP5521_MASTER_ENABLE | LP5521_LOGARITHMIC_PWM))
                 return -ENODEV;
 
         return 0;
@@ -502,7 +501,7 @@ static ssize_t store_current(struct device *dev,
         ssize_t ret;
         unsigned long curr;
 
-        if (kstrtoul(buf, 0, &curr))
+        if (strict_strtoul(buf, 0, &curr))
                 return -EINVAL;
 
         if (curr > led->max_current)
@@ -534,97 +533,6 @@ static ssize_t lp5521_selftest(struct device *dev,
         return sprintf(buf, "%s\n", ret ? "FAIL" : "OK");
 }
 
-static void lp5521_clear_program_memory(struct i2c_client *cl)
-{
-        int i;
-        u8 rgb_mem[] = {
-                LP5521_REG_R_PROG_MEM,
-                LP5521_REG_G_PROG_MEM,
-                LP5521_REG_B_PROG_MEM,
-        };
-
-        for (i = 0; i < ARRAY_SIZE(rgb_mem); i++) {
-                lp5521_write(cl, rgb_mem[i], 0);
-                lp5521_write(cl, rgb_mem[i] + 1, 0);
-        }
-}
-
-static void lp5521_write_program_memory(struct i2c_client *cl,
-                                u8 base, u8 *rgb, int size)
-{
-        int i;
-
-        if (!rgb || size <= 0)
-                return;
-
-        for (i = 0; i < size; i++)
-                lp5521_write(cl, base + i, *(rgb + i));
-
-        lp5521_write(cl, base + i, 0);
-        lp5521_write(cl, base + i + 1, 0);
-}
-
-static inline struct lp5521_led_pattern *lp5521_get_pattern
-                                        (struct lp5521_chip *chip, u8 offset)
-{
-        struct lp5521_led_pattern *ptn;
-        ptn = chip->pdata->patterns + (offset - 1);
-        return ptn;
-}
-
-static void lp5521_run_led_pattern(int mode, struct lp5521_chip *chip)
-{
-        struct lp5521_led_pattern *ptn;
-        struct i2c_client *cl = chip->client;
-        int num_patterns = chip->pdata->num_patterns;
-
-        if (mode > num_patterns || !(chip->pdata->patterns))
-                return;
-
-        if (mode == PATTERN_OFF) {
-                lp5521_write(cl, LP5521_REG_ENABLE, LP5521_ENABLE_DEFAULT);
-                usleep_range(1000, 2000);
-                lp5521_write(cl, LP5521_REG_OP_MODE, LP5521_CMD_DIRECT);
-        } else {
-                ptn = lp5521_get_pattern(chip, mode);
-                if (!ptn)
-                        return;
-
-                lp5521_write(cl, LP5521_REG_OP_MODE, LP5521_CMD_LOAD);
-                usleep_range(1000, 2000);
-
-                lp5521_clear_program_memory(cl);
-
-                lp5521_write_program_memory(cl, LP5521_REG_R_PROG_MEM,
-                                        ptn->r, ptn->size_r);
-                lp5521_write_program_memory(cl, LP5521_REG_G_PROG_MEM,
-                                        ptn->g, ptn->size_g);
-                lp5521_write_program_memory(cl, LP5521_REG_B_PROG_MEM,
-                                        ptn->b, ptn->size_b);
-
-                lp5521_write(cl, LP5521_REG_OP_MODE, LP5521_CMD_RUN);
-                usleep_range(1000, 2000);
-                lp5521_write(cl, LP5521_REG_ENABLE, LP5521_ENABLE_RUN_PROGRAM);
-        }
-}
-
-static ssize_t store_led_pattern(struct device *dev,
-                                struct device_attribute *attr,
-                                const char *buf, size_t len)
-{
-        struct lp5521_chip *chip = i2c_get_clientdata(to_i2c_client(dev));
-        unsigned long val;
-        int ret;
-
-        ret = kstrtoul(buf, 16, &val);
-        if (ret)
-                return ret;
-
-        lp5521_run_led_pattern(val, chip);
-
-        return len;
-}
-
 /* led class device attributes */
 static DEVICE_ATTR(led_current, S_IRUGO | S_IWUSR, show_current, store_current);
 static DEVICE_ATTR(max_current, S_IRUGO , show_max_current, NULL);
@@ -650,7 +558,6 @@ static DEVICE_ATTR(engine1_load, S_IWUSR, NULL, store_engine1_load);
 static DEVICE_ATTR(engine2_load, S_IWUSR, NULL, store_engine2_load);
 static DEVICE_ATTR(engine3_load, S_IWUSR, NULL, store_engine3_load);
 static DEVICE_ATTR(selftest, S_IRUGO, lp5521_selftest, NULL);
-static DEVICE_ATTR(led_pattern, S_IWUSR, NULL, store_led_pattern);
 
 static struct attribute *lp5521_attributes[] = {
         &dev_attr_engine1_mode.attr,
@@ -660,7 +567,6 @@ static struct attribute *lp5521_attributes[] = {
         &dev_attr_engine1_load.attr,
         &dev_attr_engine2_load.attr,
         &dev_attr_engine3_load.attr,
-        &dev_attr_led_pattern.attr,
         NULL
 };
 
@@ -687,7 +593,7 @@ static void lp5521_unregister_sysfs(struct i2c_client *client)
                                 &lp5521_led_attribute_group);
 }
 
-static int lp5521_init_led(struct lp5521_led *led,
+static int __devinit lp5521_init_led(struct lp5521_led *led,
                                 struct i2c_client *client,
                                 int chan, struct lp5521_platform_data *pdata)
 {
@@ -711,15 +617,10 @@ static int lp5521_init_led(struct lp5521_led *led,
                 return -EINVAL;
         }
 
-        led->cdev.brightness_set = lp5521_set_brightness;
-        if (pdata->led_config[chan].name) {
-                led->cdev.name = pdata->led_config[chan].name;
-        } else {
-                snprintf(name, sizeof(name), "%s:channel%d",
+        snprintf(name, sizeof(name), "%s:channel%d",
                         pdata->label ?: client->name, chan);
-                led->cdev.name = name;
-        }
-
+        led->cdev.brightness_set = lp5521_set_brightness;
+        led->cdev.name = name;
         res = led_classdev_register(dev, &led->cdev);
         if (res < 0) {
                 dev_err(dev, "couldn't register led on channel %d\n", chan);
@@ -736,15 +637,14 @@ static int lp5521_init_led(struct lp5521_led *led,
         return 0;
 }
 
-static int lp5521_probe(struct i2c_client *client,
+static int __devinit lp5521_probe(struct i2c_client *client,
                         const struct i2c_device_id *id)
 {
         struct lp5521_chip              *chip;
         struct lp5521_platform_data     *pdata;
         int ret, i, led;
-        u8 buf;
 
-        chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
+        chip = kzalloc(sizeof(*chip), GFP_KERNEL);
         if (!chip)
                 return -ENOMEM;
 
@@ -755,7 +655,8 @@ static int lp5521_probe(struct i2c_client *client,
 
         if (!pdata) {
                 dev_err(&client->dev, "no platform data\n");
-                return -EINVAL;
+                ret = -EINVAL;
+                goto fail1;
         }
 
         mutex_init(&chip->lock);
@@ -765,7 +666,7 @@ static int lp5521_probe(struct i2c_client *client,
         if (pdata->setup_resources) {
                 ret = pdata->setup_resources();
                 if (ret < 0)
-                        return ret;
+                        goto fail1;
         }
 
         if (pdata->enable) {
@@ -780,27 +681,6 @@ static int lp5521_probe(struct i2c_client *client,
                                      * Exact value is not available. 10 - 20ms
                                      * appears to be enough for reset.
                                      */
-
-        /*
-         * Make sure that the chip is reset by reading back the r channel
-         * current reg. This is dummy read is required on some platforms -
-         * otherwise further access to the R G B channels in the
-         * LP5521_REG_ENABLE register will not have any effect - strange!
-         */
-        ret = lp5521_read(client, LP5521_REG_R_CURRENT, &buf);
-        if (ret) {
-                dev_err(&client->dev, "error in resetting chip\n");
-                goto fail2;
-        }
-        if (buf != LP5521_REG_R_CURR_DEFAULT) {
-                dev_err(&client->dev,
-                        "unexpected data in register (expected 0x%x got 0x%x)\n",
-                        LP5521_REG_R_CURR_DEFAULT, buf);
-                ret = -EINVAL;
-                goto fail2;
-        }
-        usleep_range(10000, 20000);
-
         ret = lp5521_detect(client);
 
         if (ret) {
@@ -813,7 +693,7 @@ static int lp5521_probe(struct i2c_client *client,
         ret = lp5521_configure(client);
         if (ret < 0) {
                 dev_err(&client->dev, "error configuring chip\n");
-                goto fail1;
+                goto fail2;
         }
 
         /* Initialize leds */
@@ -828,7 +708,7 @@ static int lp5521_probe(struct i2c_client *client,
                 ret = lp5521_init_led(&chip->leds[led], client, i, pdata);
                 if (ret) {
                         dev_err(&client->dev, "error initializing leds\n");
-                        goto fail2;
+                        goto fail3;
                 }
                 chip->num_leds++;
 
@@ -846,28 +726,29 @@ static int lp5521_probe(struct i2c_client *client,
         ret = lp5521_register_sysfs(client);
         if (ret) {
                 dev_err(&client->dev, "registering sysfs failed\n");
-                goto fail2;
+                goto fail3;
         }
         return ret;
-fail2:
+fail3:
         for (i = 0; i < chip->num_leds; i++) {
                 led_classdev_unregister(&chip->leds[i].cdev);
                 cancel_work_sync(&chip->leds[i].brightness_work);
         }
-fail1:
+fail2:
         if (pdata->enable)
                 pdata->enable(0);
         if (pdata->release_resources)
                 pdata->release_resources();
+fail1:
+        kfree(chip);
         return ret;
 }
 
-static int lp5521_remove(struct i2c_client *client)
+static int __devexit lp5521_remove(struct i2c_client *client)
 {
         struct lp5521_chip *chip = i2c_get_clientdata(client);
         int i;
 
-        lp5521_run_led_pattern(PATTERN_OFF, chip);
         lp5521_unregister_sysfs(client);
 
         for (i = 0; i < chip->num_leds; i++) {
@@ -879,6 +760,7 @@ static int lp5521_remove(struct i2c_client *client)
                 chip->pdata->enable(0);
         if (chip->pdata->release_resources)
                 chip->pdata->release_resources();
+        kfree(chip);
         return 0;
 }
 
@@ -893,11 +775,29 @@ static struct i2c_driver lp5521_driver = {
                 .name   = "lp5521",
         },
         .probe          = lp5521_probe,
-        .remove         = lp5521_remove,
+        .remove         = __devexit_p(lp5521_remove),
         .id_table       = lp5521_id,
 };
 
-module_i2c_driver(lp5521_driver);
+static int __init lp5521_init(void)
+{
+        int ret;
+
+        ret = i2c_add_driver(&lp5521_driver);
+
+        if (ret < 0)
+                printk(KERN_ALERT "Adding lp5521 driver failed\n");
+
+        return ret;
+}
+
+static void __exit lp5521_exit(void)
+{
+        i2c_del_driver(&lp5521_driver);
+}
+
+module_init(lp5521_init);
+module_exit(lp5521_exit);
 
 MODULE_AUTHOR("Mathias Nyman, Yuri Zaporozhets, Samu Onkalo");
 MODULE_DESCRIPTION("LP5521 LED engine");
diff --git a/drivers/leds/leds-lp5523.c b/drivers/leds/leds-lp5523.c
index 7f5be8948cd..5971e309b23 100644
--- a/drivers/leds/leds-lp5523.c
+++ b/drivers/leds/leds-lp5523.c
@@ -104,11 +104,6 @@
 #define LED_ACTIVE(mux, led)            (!!(mux & (0x0001 << led)))
 #define SHIFT_MASK(id)                  (((id) - 1) * 2)
 
-enum lp5523_chip_id {
-        LP5523,
-        LP55231,
-};
-
 struct lp5523_engine {
         int             id;
         u8              mode;
@@ -155,9 +150,9 @@ static inline struct lp5523_chip *led_to_lp5523(struct lp5523_led *led)
                             leds[led->id]);
 }
 
-static void lp5523_set_mode(struct lp5523_engine *engine, u8 mode);
+static int lp5523_set_mode(struct lp5523_engine *engine, u8 mode);
 static int lp5523_set_engine_mode(struct lp5523_engine *engine, u8 mode);
-static int lp5523_load_program(struct lp5523_engine *engine, const u8 *pattern);
+static int lp5523_load_program(struct lp5523_engine *engine, u8 *pattern);
 
 static void lp5523_led_brightness_work(struct work_struct *work);
 
@@ -171,7 +166,7 @@ static int lp5523_read(struct i2c_client *client, u8 reg, u8 *buf)
         s32 ret = i2c_smbus_read_byte_data(client, reg);
 
         if (ret < 0)
-                return ret;
+                return -EIO;
 
         *buf = ret;
         return 0;
@@ -182,7 +177,7 @@ static int lp5523_detect(struct i2c_client *client)
         int ret;
         u8 buf;
 
-        ret = lp5523_write(client, LP5523_REG_ENABLE, LP5523_ENABLE);
+        ret = lp5523_write(client, LP5523_REG_ENABLE, 0x40);
         if (ret)
                 return ret;
         ret = lp5523_read(client, LP5523_REG_ENABLE, &buf);
@@ -201,7 +196,7 @@ static int lp5523_configure(struct i2c_client *client)
         u8 status;
 
         /* one pattern per engine setting led mux start and stop addresses */
-        static const u8 pattern[][LP5523_PROGRAM_LENGTH] =  {
+        u8 pattern[][LP5523_PROGRAM_LENGTH] =  {
                 { 0x9c, 0x30, 0x9c, 0xb0, 0x9d, 0x80, 0xd8, 0x00, 0},
                 { 0x9c, 0x40, 0x9c, 0xc0, 0x9d, 0x80, 0xd8, 0x00, 0},
                 { 0x9c, 0x50, 0x9c, 0xd0, 0x9d, 0x80, 0xd8, 0x00, 0},
@@ -248,10 +243,7 @@ static int lp5523_configure(struct i2c_client *client)
 
         /* Let the programs run for couple of ms and check the engine status */
         usleep_range(3000, 6000);
-        ret = lp5523_read(client, LP5523_REG_STATUS, &status);
-        if (ret < 0)
-                return ret;
-
+        lp5523_read(client, LP5523_REG_STATUS, &status);
         status &= LP5523_ENG_STATUS_MASK;
 
         if (status == LP5523_ENG_STATUS_MASK) {
@@ -309,7 +301,7 @@ static int lp5523_load_mux(struct lp5523_engine *engine, u16 mux)
         return ret;
 }
 
-static int lp5523_load_program(struct lp5523_engine *engine, const u8 *pattern)
+static int lp5523_load_program(struct lp5523_engine *engine, u8 *pattern)
 {
         struct lp5523_chip *chip = engine_to_lp5523(engine);
         struct i2c_client *client = chip->client;
@@ -346,8 +338,7 @@ static int lp5523_mux_parse(const char *buf, u16 *mux, size_t len)
 {
         int i;
         u16 tmp_mux = 0;
-
-        len = min_t(int, len, LP5523_LEDS);
+        len = len < LP5523_LEDS ? len : LP5523_LEDS;
         for (i = 0; i < len; i++) {
                 switch (buf[i]) {
                 case '1':
@@ -467,16 +458,10 @@ static ssize_t lp5523_selftest(struct device *dev,
                                     LP5523_EN_LEDTEST | 16);
         usleep_range(3000, 6000); /* ADC conversion time is typically 2.7 ms */
         ret = lp5523_read(chip->client, LP5523_REG_STATUS, &status);
-        if (ret < 0)
-                goto fail;
-
         if (!(status & LP5523_LEDTEST_DONE))
                 usleep_range(3000, 6000); /* Was not ready. Wait little bit */
 
-        ret = lp5523_read(chip->client, LP5523_REG_LED_TEST_ADC, &vdd);
-        if (ret < 0)
-                goto fail;
-
+        ret |= lp5523_read(chip->client, LP5523_REG_LED_TEST_ADC, &vdd);
         vdd--;  /* There may be some fluctuation in measurement */
 
         for (i = 0; i < LP5523_LEDS; i++) {
@@ -498,14 +483,9 @@ static ssize_t lp5523_selftest(struct device *dev,
                 /* ADC conversion time is 2.7 ms typically */
                 usleep_range(3000, 6000);
                 ret = lp5523_read(chip->client, LP5523_REG_STATUS, &status);
-                if (ret < 0)
-                        goto fail;
-
                 if (!(status & LP5523_LEDTEST_DONE))
                         usleep_range(3000, 6000);/* Was not ready. Wait. */
-                ret = lp5523_read(chip->client, LP5523_REG_LED_TEST_ADC, &adc);
-                if (ret < 0)
-                        goto fail;
+                ret |= lp5523_read(chip->client, LP5523_REG_LED_TEST_ADC, &adc);
 
                 if (adc >= vdd || adc < LP5523_ADC_SHORTCIRC_LIM)
                         pos += sprintf(buf + pos, "LED %d FAIL\n", i);
@@ -566,9 +546,6 @@ static int lp5523_do_store_load(struct lp5523_engine *engine,
         unsigned cmd;
         u8 pattern[LP5523_PROGRAM_LENGTH] = {0};
 
-        if (engine->mode != LP5523_CMD_LOAD)
-                return -EINVAL;
-
         while ((offset < len - 1) && (i < LP5523_PROGRAM_LENGTH)) {
                 /* separate sscanfs because length is working only for %s */
                 ret = sscanf(buf + offset, "%2s%n ", c, &nrchars);
@@ -586,7 +563,12 @@ static int lp5523_do_store_load(struct lp5523_engine *engine,
                 goto fail;
 
         mutex_lock(&chip->lock);
-        ret = lp5523_load_program(engine, pattern);
+
+        if (engine->mode == LP5523_CMD_LOAD)
+                ret = lp5523_load_program(engine, pattern);
+        else
+                ret = -EINVAL;
+
         mutex_unlock(&chip->lock);
 
         if (ret) {
@@ -710,7 +692,7 @@ static ssize_t store_current(struct device *dev,
         ssize_t ret;
         unsigned long curr;
 
-        if (kstrtoul(buf, 0, &curr))
+        if (strict_strtoul(buf, 0, &curr))
                 return -EINVAL;
 
         if (curr > led->max_current)
@@ -773,7 +755,6 @@ static struct attribute *lp5523_attributes[] = {
         &dev_attr_engine2_leds.attr,
         &dev_attr_engine3_load.attr,
         &dev_attr_engine3_leds.attr,
-        NULL,
 };
 
 static const struct attribute_group lp5523_group = {
@@ -808,28 +789,26 @@ static void lp5523_unregister_sysfs(struct i2c_client *client)
 /*--------------------------------------------------------------*/
 /*                      Set chip operating mode                 */
 /*--------------------------------------------------------------*/
-static void lp5523_set_mode(struct lp5523_engine *engine, u8 mode)
+static int lp5523_set_mode(struct lp5523_engine *engine, u8 mode)
 {
+        int ret = 0;
+
         /* if in that mode already do nothing, except for run */
         if (mode == engine->mode && mode != LP5523_CMD_RUN)
-                return;
+                return 0;
 
-        switch (mode) {
-        case LP5523_CMD_RUN:
-                lp5523_run_program(engine);
-                break;
-        case LP5523_CMD_LOAD:
+        if (mode == LP5523_CMD_RUN) {
+                ret = lp5523_run_program(engine);
+        } else if (mode == LP5523_CMD_LOAD) {
                 lp5523_set_engine_mode(engine, LP5523_CMD_DISABLED);
                 lp5523_set_engine_mode(engine, LP5523_CMD_LOAD);
-                break;
-        case LP5523_CMD_DISABLED:
+        } else if (mode == LP5523_CMD_DISABLED) {
                 lp5523_set_engine_mode(engine, LP5523_CMD_DISABLED);
-                break;
-        default:
-                return;
         }
 
         engine->mode = mode;
+
+        return ret;
 }
 
 /*--------------------------------------------------------------*/
@@ -847,9 +826,8 @@ static int __init lp5523_init_engine(struct lp5523_engine *engine, int id)
         return 0;
 }
 
-static int lp5523_init_led(struct lp5523_led *led, struct device *dev,
-                           int chan, struct lp5523_platform_data *pdata,
-                           const char *chip_name)
+static int __devinit lp5523_init_led(struct lp5523_led *led, struct device *dev,
+                           int chan, struct lp5523_platform_data *pdata)
 {
         char name[32];
         int res;
@@ -868,14 +846,10 @@ static int lp5523_init_led(struct lp5523_led *led, struct device *dev,
                         return -EINVAL;
                 }
 
-                if (pdata->led_config[chan].name) {
-                        led->cdev.name = pdata->led_config[chan].name;
-                } else {
-                        snprintf(name, sizeof(name), "%s:channel%d",
-                                pdata->label ? : chip_name, chan);
-                        led->cdev.name = name;
-                }
+                snprintf(name, sizeof(name), "%s:channel%d",
+                        pdata->label ?: "lp5523", chan);
 
+                led->cdev.name = name;
                 led->cdev.brightness_set = lp5523_set_brightness;
                 res = led_classdev_register(dev, &led->cdev);
                 if (res < 0) {
@@ -896,14 +870,16 @@ static int lp5523_init_led(struct lp5523_led *led, struct device *dev,
         return 0;
 }
 
-static int lp5523_probe(struct i2c_client *client,
+static struct i2c_driver lp5523_driver;
+
+static int __devinit lp5523_probe(struct i2c_client *client,
                         const struct i2c_device_id *id)
 {
         struct lp5523_chip              *chip;
         struct lp5523_platform_data     *pdata;
         int ret, i, led;
 
-        chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
+        chip = kzalloc(sizeof(*chip), GFP_KERNEL);
         if (!chip)
                 return -ENOMEM;
 
@@ -914,7 +890,8 @@ static int lp5523_probe(struct i2c_client *client,
 
         if (!pdata) {
                 dev_err(&client->dev, "no platform data\n");
-                return -EINVAL;
+                ret = -EINVAL;
+                goto fail1;
         }
 
         mutex_init(&chip->lock);
@@ -924,7 +901,7 @@ static int lp5523_probe(struct i2c_client *client,
         if (pdata->setup_resources) {
                 ret = pdata->setup_resources();
                 if (ret < 0)
-                        return ret;
+                        goto fail1;
         }
 
         if (pdata->enable) {
@@ -941,22 +918,22 @@ static int lp5523_probe(struct i2c_client *client,
                                      */
         ret = lp5523_detect(client);
         if (ret)
-                goto fail1;
+                goto fail2;
 
-        dev_info(&client->dev, "%s Programmable led chip found\n", id->name);
+        dev_info(&client->dev, "LP5523 Programmable led chip found\n");
 
         /* Initialize engines */
         for (i = 0; i < ARRAY_SIZE(chip->engines); i++) {
                 ret = lp5523_init_engine(&chip->engines[i], i + 1);
                 if (ret) {
                         dev_err(&client->dev, "error initializing engine\n");
-                        goto fail1;
+                        goto fail2;
                 }
         }
         ret = lp5523_configure(client);
         if (ret < 0) {
                 dev_err(&client->dev, "error configuring chip\n");
-                goto fail1;
+                goto fail2;
         }
 
         /* Initialize leds */
@@ -968,14 +945,10 @@ static int lp5523_probe(struct i2c_client *client,
                 if (pdata->led_config[i].led_current == 0)
                         continue;
 
-                INIT_WORK(&chip->leds[led].brightness_work,
-                        lp5523_led_brightness_work);
-
-                ret = lp5523_init_led(&chip->leds[led], &client->dev, i, pdata,
-                                id->name);
+                ret = lp5523_init_led(&chip->leds[led], &client->dev, i, pdata);
                 if (ret) {
                         dev_err(&client->dev, "error initializing leds\n");
-                        goto fail2;
+                        goto fail3;
                 }
                 chip->num_leds++;
 
@@ -985,25 +958,30 @@ static int lp5523_probe(struct i2c_client *client,
                           LP5523_REG_LED_CURRENT_BASE + chip->leds[led].chan_nr,
                           chip->leds[led].led_current);
 
+                INIT_WORK(&(chip->leds[led].brightness_work),
+                        lp5523_led_brightness_work);
+
                 led++;
         }
 
         ret = lp5523_register_sysfs(client);
         if (ret) {
                 dev_err(&client->dev, "registering sysfs failed\n");
-                goto fail2;
+                goto fail3;
         }
         return ret;
-fail2:
+fail3:
         for (i = 0; i < chip->num_leds; i++) {
                 led_classdev_unregister(&chip->leds[i].cdev);
-                flush_work(&chip->leds[i].brightness_work);
+                cancel_work_sync(&chip->leds[i].brightness_work);
         }
-fail1:
+fail2:
         if (pdata->enable)
                 pdata->enable(0);
         if (pdata->release_resources)
                 pdata->release_resources();
+fail1:
+        kfree(chip);
         return ret;
 }
 
@@ -1012,26 +990,23 @@ static int lp5523_remove(struct i2c_client *client)
         struct lp5523_chip *chip = i2c_get_clientdata(client);
         int i;
 
-        /* Disable engine mode */
-        lp5523_write(client, LP5523_REG_OP_MODE, LP5523_CMD_DISABLED);
-
         lp5523_unregister_sysfs(client);
 
         for (i = 0; i < chip->num_leds; i++) {
                 led_classdev_unregister(&chip->leds[i].cdev);
-                flush_work(&chip->leds[i].brightness_work);
+                cancel_work_sync(&chip->leds[i].brightness_work);
         }
 
         if (chip->pdata->enable)
                 chip->pdata->enable(0);
         if (chip->pdata->release_resources)
                 chip->pdata->release_resources();
+        kfree(chip);
         return 0;
 }
 
 static const struct i2c_device_id lp5523_id[] = {
-        { "lp5523",  LP5523 },
-        { "lp55231", LP55231 },
+        { "lp5523", 0 },
         { }
 };
 
@@ -1039,14 +1014,32 @@ MODULE_DEVICE_TABLE(i2c, lp5523_id);
 
 static struct i2c_driver lp5523_driver = {
         .driver = {
-                .name   = "lp5523x",
+                .name   = "lp5523",
         },
         .probe          = lp5523_probe,
         .remove         = lp5523_remove,
         .id_table       = lp5523_id,
 };
 
-module_i2c_driver(lp5523_driver);
+static int __init lp5523_init(void)
+{
+        int ret;
+
+        ret = i2c_add_driver(&lp5523_driver);
+
+        if (ret < 0)
+                printk(KERN_ALERT "Adding lp5523 driver failed\n");
+
+        return ret;
+}
+
+static void __exit lp5523_exit(void)
+{
+        i2c_del_driver(&lp5523_driver);
+}
+
+module_init(lp5523_init);
+module_exit(lp5523_exit);
 
 MODULE_AUTHOR("Mathias Nyman <mathias.nyman@nokia.com>");
 MODULE_DESCRIPTION("LP5523 LED engine");
diff --git a/drivers/leds/leds-lp8788.c b/drivers/leds/leds-lp8788.c
deleted file mode 100644
index 4353942c5fd..00000000000
--- a/drivers/leds/leds-lp8788.c
+++ /dev/null
@@ -1,193 +0,0 @@
-/*
- * TI LP8788 MFD - keyled driver
- *
- * Copyright 2012 Texas Instruments
- *
- * Author: Milo(Woogyom) Kim <milo.kim@ti.com>
- *
- * 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.
- *
- */
-
-#include <linux/module.h>
-#include <linux/slab.h>
-#include <linux/err.h>
-#include <linux/platform_device.h>
-#include <linux/leds.h>
-#include <linux/mutex.h>
-#include <linux/mfd/lp8788.h>
-#include <linux/mfd/lp8788-isink.h>
-
-#define MAX_BRIGHTNESS                  LP8788_ISINK_MAX_PWM
-#define DEFAULT_LED_NAME                "keyboard-backlight"
-
-struct lp8788_led {
-        struct lp8788 *lp;
-        struct mutex lock;
-        struct work_struct work;
-        struct led_classdev led_dev;
-        enum lp8788_isink_number isink_num;
-        enum led_brightness brightness;
-        int on;
-};
-
-struct lp8788_led_config {
-        enum lp8788_isink_scale scale;
-        enum lp8788_isink_number num;
-        int iout;
-};
-
-static struct lp8788_led_config default_led_config = {
-        .scale = LP8788_ISINK_SCALE_100mA,
-        .num   = LP8788_ISINK_3,
-        .iout  = 0,
-};
-
-static int lp8788_led_init_device(struct lp8788_led *led,
-                                struct lp8788_led_platform_data *pdata)
-{
-        struct lp8788_led_config *cfg = &default_led_config;
-        u8 addr, mask, val;
-        int ret;
-
-        if (pdata) {
-                cfg->scale = pdata->scale;
-                cfg->num = pdata->num;
-                cfg->iout = pdata->iout_code;
-        }
-
-        led->isink_num = cfg->num;
-
-        /* scale configuration */
-        addr = LP8788_ISINK_CTRL;
-        mask = 1 << (cfg->num + LP8788_ISINK_SCALE_OFFSET);
-        val = cfg->scale << (cfg->num + LP8788_ISINK_SCALE_OFFSET);
-        ret = lp8788_update_bits(led->lp, addr, mask, val);
-        if (ret)
-                return ret;
-
-        /* current configuration */
-        addr = lp8788_iout_addr[cfg->num];
-        mask = lp8788_iout_mask[cfg->num];
-        val = cfg->iout;
-
-        return lp8788_update_bits(led->lp, addr, mask, val);
-}
-
-static void lp8788_led_enable(struct lp8788_led *led,
-                        enum lp8788_isink_number num, int on)
-{
-        u8 mask = 1 << num;
-        u8 val = on << num;
-
-        if (lp8788_update_bits(led->lp, LP8788_ISINK_CTRL, mask, val))
-                return;
-
-        led->on = on;
-}
-
-static void lp8788_led_work(struct work_struct *work)
-{
-        struct lp8788_led *led = container_of(work, struct lp8788_led, work);
-        enum lp8788_isink_number num = led->isink_num;
-        int enable;
-        u8 val = led->brightness;
-
-        mutex_lock(&led->lock);
-
-        switch (num) {
-        case LP8788_ISINK_1:
-        case LP8788_ISINK_2:
-        case LP8788_ISINK_3:
-                lp8788_write_byte(led->lp, lp8788_pwm_addr[num], val);
-                break;
-        default:
-                mutex_unlock(&led->lock);
-                return;
-        }
-
-        enable = (val > 0) ? 1 : 0;
-        if (enable != led->on)
-                lp8788_led_enable(led, num, enable);
-
-        mutex_unlock(&led->lock);
-}
-
-static void lp8788_brightness_set(struct led_classdev *led_cdev,
-                                enum led_brightness brt_val)
-{
-        struct lp8788_led *led =
-                        container_of(led_cdev, struct lp8788_led, led_dev);
-
-        led->brightness = brt_val;
-        schedule_work(&led->work);
-}
-
-static int lp8788_led_probe(struct platform_device *pdev)
-{
-        struct lp8788 *lp = dev_get_drvdata(pdev->dev.parent);
-        struct lp8788_led_platform_data *led_pdata;
-        struct lp8788_led *led;
-        int ret;
-
-        led = devm_kzalloc(lp->dev, sizeof(struct lp8788_led), GFP_KERNEL);
-        if (!led)
-                return -ENOMEM;
-
-        led->lp = lp;
-        led->led_dev.max_brightness = MAX_BRIGHTNESS;
-        led->led_dev.brightness_set = lp8788_brightness_set;
-
-        led_pdata = lp->pdata ? lp->pdata->led_pdata : NULL;
-
-        if (!led_pdata || !led_pdata->name)
-                led->led_dev.name = DEFAULT_LED_NAME;
-        else
-                led->led_dev.name = led_pdata->name;
-
-        mutex_init(&led->lock);
-        INIT_WORK(&led->work, lp8788_led_work);
-
-        platform_set_drvdata(pdev, led);
-
-        ret = lp8788_led_init_device(led, led_pdata);
-        if (ret) {
-                dev_err(lp->dev, "led init device err: %d\n", ret);
-                return ret;
-        }
-
-        ret = led_classdev_register(lp->dev, &led->led_dev);
-        if (ret) {
-                dev_err(lp->dev, "led register err: %d\n", ret);
-                return ret;
-        }
-
-        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);
-        flush_work(&led->work);
-
-        return 0;
-}
-
-static struct platform_driver lp8788_led_driver = {
-        .probe = lp8788_led_probe,
-        .remove = lp8788_led_remove,
-        .driver = {
-                .name = LP8788_DEV_KEYLED,
-                .owner = THIS_MODULE,
-        },
-};
-module_platform_driver(lp8788_led_driver);
-
-MODULE_DESCRIPTION("Texas Instruments LP8788 Keyboard LED Driver");
-MODULE_AUTHOR("Milo Kim");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:lp8788-keyled");
diff --git a/drivers/leds/leds-lt3593.c b/drivers/leds/leds-lt3593.c
index c9b9e1fec58..2579678f97a 100644
--- a/drivers/leds/leds-lt3593.c
+++ b/drivers/leds/leds-lt3593.c
@@ -24,7 +24,6 @@
 #include <linux/delay.h>
 #include <linux/gpio.h>
 #include <linux/slab.h>
-#include <linux/module.h>
 
 struct lt3593_led_data {
         struct led_classdev cdev;
@@ -82,18 +81,22 @@ static void lt3593_led_set(struct led_classdev *led_cdev,
         schedule_work(&led_dat->work);
 }
 
-static int create_lt3593_led(const struct gpio_led *template,
+static int __devinit create_lt3593_led(const struct gpio_led *template,
         struct lt3593_led_data *led_dat, struct device *parent)
 {
         int ret, state;
 
         /* skip leds on GPIOs that aren't available */
         if (!gpio_is_valid(template->gpio)) {
-                dev_info(parent, "%s: skipping unavailable LT3593 LED at gpio %d (%s)\n",
+                printk(KERN_INFO "%s: skipping unavailable LT3593 LED at gpio %d (%s)\n",
                                 KBUILD_MODNAME, template->gpio, template->name);
                 return 0;
         }
 
+        ret = gpio_request(template->gpio, template->name);
+        if (ret < 0)
+                return ret;
+
         led_dat->cdev.name = template->name;
         led_dat->cdev.default_trigger = template->default_trigger;
         led_dat->gpio = template->gpio;
@@ -106,21 +109,24 @@ static int create_lt3593_led(const struct gpio_led *template,
         if (!template->retain_state_suspended)
                 led_dat->cdev.flags |= LED_CORE_SUSPENDRESUME;
 
-        ret = devm_gpio_request_one(parent, template->gpio,
-                                    GPIOF_DIR_OUT | state, template->name);
+        ret = gpio_direction_output(led_dat->gpio, state);
         if (ret < 0)
-                return ret;
+                goto err;
 
         INIT_WORK(&led_dat->work, lt3593_led_work);
 
         ret = led_classdev_register(parent, &led_dat->cdev);
         if (ret < 0)
-                return ret;
+                goto err;
 
-        dev_info(parent, "%s: registered LT3593 LED '%s' at GPIO %d\n",
+        printk(KERN_INFO "%s: registered LT3593 LED '%s' at GPIO %d\n",
                 KBUILD_MODNAME, template->name, template->gpio);
 
         return 0;
+
+err:
+        gpio_free(led_dat->gpio);
+        return ret;
 }
 
 static void delete_lt3593_led(struct lt3593_led_data *led)
@@ -130,9 +136,10 @@ static void delete_lt3593_led(struct lt3593_led_data *led)
 
         led_classdev_unregister(&led->cdev);
         cancel_work_sync(&led->work);
+        gpio_free(led->gpio);
 }
 
-static int lt3593_led_probe(struct platform_device *pdev)
+static int __devinit lt3593_led_probe(struct platform_device *pdev)
 {
         struct gpio_led_platform_data *pdata = pdev->dev.platform_data;
         struct lt3593_led_data *leds_data;
@@ -141,9 +148,8 @@ static int lt3593_led_probe(struct platform_device *pdev)
         if (!pdata)
                 return -EBUSY;
 
-        leds_data = devm_kzalloc(&pdev->dev,
-                        sizeof(struct lt3593_led_data) * pdata->num_leds,
-                        GFP_KERNEL);
+        leds_data = kzalloc(sizeof(struct lt3593_led_data) * pdata->num_leds,
+                                GFP_KERNEL);
         if (!leds_data)
                 return -ENOMEM;
 
@@ -162,10 +168,12 @@ err:
         for (i = i - 1; i >= 0; i--)
                 delete_lt3593_led(&leds_data[i]);
 
+        kfree(leds_data);
+
         return ret;
 }
 
-static int lt3593_led_remove(struct platform_device *pdev)
+static int __devexit lt3593_led_remove(struct platform_device *pdev)
 {
         int i;
         struct gpio_led_platform_data *pdata = pdev->dev.platform_data;
@@ -176,21 +184,35 @@ static int lt3593_led_remove(struct platform_device *pdev)
         for (i = 0; i < pdata->num_leds; i++)
                 delete_lt3593_led(&leds_data[i]);
 
+        kfree(leds_data);
+
         return 0;
 }
 
 static struct platform_driver lt3593_led_driver = {
         .probe          = lt3593_led_probe,
-        .remove         = lt3593_led_remove,
+        .remove         = __devexit_p(lt3593_led_remove),
         .driver         = {
                 .name   = "leds-lt3593",
                 .owner  = THIS_MODULE,
         },
 };
 
-module_platform_driver(lt3593_led_driver);
+MODULE_ALIAS("platform:leds-lt3593");
+
+static int __init lt3593_led_init(void)
+{
+        return platform_driver_register(&lt3593_led_driver);
+}
+
+static void __exit lt3593_led_exit(void)
+{
+        platform_driver_unregister(&lt3593_led_driver);
+}
+
+module_init(lt3593_led_init);
+module_exit(lt3593_led_exit);
 
 MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>");
 MODULE_DESCRIPTION("LED driver for LT3593 controllers");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:leds-lt3593");
diff --git a/drivers/leds/leds-max8997.c b/drivers/leds/leds-max8997.c
deleted file mode 100644
index f449a8bdddc..00000000000
--- a/drivers/leds/leds-max8997.c
+++ /dev/null
@@ -1,319 +0,0 @@
-/*
- * leds-max8997.c - LED class driver for MAX8997 LEDs.
- *
- * Copyright (C) 2011 Samsung Electronics
- * Donggeun Kim <dg77.kim@samsung.com>
- *
- * 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.
- *
- */
-
-#include <linux/module.h>
-#include <linux/err.h>
-#include <linux/slab.h>
-#include <linux/workqueue.h>
-#include <linux/leds.h>
-#include <linux/mfd/max8997.h>
-#include <linux/mfd/max8997-private.h>
-#include <linux/platform_device.h>
-
-#define MAX8997_LED_FLASH_SHIFT                 3
-#define MAX8997_LED_FLASH_CUR_MASK              0xf8
-#define MAX8997_LED_MOVIE_SHIFT                 4
-#define MAX8997_LED_MOVIE_CUR_MASK              0xf0
-
-#define MAX8997_LED_FLASH_MAX_BRIGHTNESS        0x1f
-#define MAX8997_LED_MOVIE_MAX_BRIGHTNESS        0xf
-#define MAX8997_LED_NONE_MAX_BRIGHTNESS         0
-
-#define MAX8997_LED0_FLASH_MASK                 0x1
-#define MAX8997_LED0_FLASH_PIN_MASK             0x5
-#define MAX8997_LED0_MOVIE_MASK                 0x8
-#define MAX8997_LED0_MOVIE_PIN_MASK             0x28
-
-#define MAX8997_LED1_FLASH_MASK                 0x2
-#define MAX8997_LED1_FLASH_PIN_MASK             0x6
-#define MAX8997_LED1_MOVIE_MASK                 0x10
-#define MAX8997_LED1_MOVIE_PIN_MASK             0x30
-
-#define MAX8997_LED_BOOST_ENABLE_MASK           (1 << 6)
-
-struct max8997_led {
-        struct max8997_dev *iodev;
-        struct led_classdev cdev;
-        bool enabled;
-        int id;
-        enum max8997_led_mode led_mode;
-        struct mutex mutex;
-};
-
-static void max8997_led_set_mode(struct max8997_led *led,
-                        enum max8997_led_mode mode)
-{
-        int ret;
-        struct i2c_client *client = led->iodev->i2c;
-        u8 mask = 0, val;
-
-        switch (mode) {
-        case MAX8997_FLASH_MODE:
-                mask = MAX8997_LED1_FLASH_MASK | MAX8997_LED0_FLASH_MASK;
-                val = led->id ?
-                      MAX8997_LED1_FLASH_MASK : MAX8997_LED0_FLASH_MASK;
-                led->cdev.max_brightness = MAX8997_LED_FLASH_MAX_BRIGHTNESS;
-                break;
-        case MAX8997_MOVIE_MODE:
-                mask = MAX8997_LED1_MOVIE_MASK | MAX8997_LED0_MOVIE_MASK;
-                val = led->id ?
-                      MAX8997_LED1_MOVIE_MASK : MAX8997_LED0_MOVIE_MASK;
-                led->cdev.max_brightness = MAX8997_LED_MOVIE_MAX_BRIGHTNESS;
-                break;
-        case MAX8997_FLASH_PIN_CONTROL_MODE:
-                mask = MAX8997_LED1_FLASH_PIN_MASK |
-                       MAX8997_LED0_FLASH_PIN_MASK;
-                val = led->id ?
-                      MAX8997_LED1_FLASH_PIN_MASK : MAX8997_LED0_FLASH_PIN_MASK;
-                led->cdev.max_brightness = MAX8997_LED_FLASH_MAX_BRIGHTNESS;
-                break;
-        case MAX8997_MOVIE_PIN_CONTROL_MODE:
-                mask = MAX8997_LED1_MOVIE_PIN_MASK |
-                       MAX8997_LED0_MOVIE_PIN_MASK;
-                val = led->id ?
-                      MAX8997_LED1_MOVIE_PIN_MASK : MAX8997_LED0_MOVIE_PIN_MASK;
-                led->cdev.max_brightness = MAX8997_LED_MOVIE_MAX_BRIGHTNESS;
-                break;
-        default:
-                led->cdev.max_brightness = MAX8997_LED_NONE_MAX_BRIGHTNESS;
-                break;
-        }
-
-        if (mask) {
-                ret = max8997_update_reg(client, MAX8997_REG_LEN_CNTL, val,
-                                         mask);
-                if (ret)
-                        dev_err(led->iodev->dev,
-                                "failed to update register(%d)\n", ret);
-        }
-
-        led->led_mode = mode;
-}
-
-static void max8997_led_enable(struct max8997_led *led, bool enable)
-{
-        int ret;
-        struct i2c_client *client = led->iodev->i2c;
-        u8 val = 0, mask = MAX8997_LED_BOOST_ENABLE_MASK;
-
-        if (led->enabled == enable)
-                return;
-
-        val = enable ? MAX8997_LED_BOOST_ENABLE_MASK : 0;
-
-        ret = max8997_update_reg(client, MAX8997_REG_BOOST_CNTL, val, mask);
-        if (ret)
-                dev_err(led->iodev->dev,
-                        "failed to update register(%d)\n", ret);
-
-        led->enabled = enable;
-}
-
-static void max8997_led_set_current(struct max8997_led *led,
-                                enum led_brightness value)
-{
-        int ret;
-        struct i2c_client *client = led->iodev->i2c;
-        u8 val = 0, mask = 0, reg = 0;
-
-        switch (led->led_mode) {
-        case MAX8997_FLASH_MODE:
-        case MAX8997_FLASH_PIN_CONTROL_MODE:
-                val = value << MAX8997_LED_FLASH_SHIFT;
-                mask = MAX8997_LED_FLASH_CUR_MASK;
-                reg = led->id ? MAX8997_REG_FLASH2_CUR : MAX8997_REG_FLASH1_CUR;
-                break;
-        case MAX8997_MOVIE_MODE:
-        case MAX8997_MOVIE_PIN_CONTROL_MODE:
-                val = value << MAX8997_LED_MOVIE_SHIFT;
-                mask = MAX8997_LED_MOVIE_CUR_MASK;
-                reg = MAX8997_REG_MOVIE_CUR;
-                break;
-        default:
-                break;
-        }
-
-        if (mask) {
-                ret = max8997_update_reg(client, reg, val, mask);
-                if (ret)
-                        dev_err(led->iodev->dev,
-                                "failed to update register(%d)\n", ret);
-        }
-}
-
-static void max8997_led_brightness_set(struct led_classdev *led_cdev,
-                                enum led_brightness value)
-{
-        struct max8997_led *led =
-                        container_of(led_cdev, struct max8997_led, cdev);
-
-        if (value) {
-                max8997_led_set_current(led, value);
-                max8997_led_enable(led, true);
-        } else {
-                max8997_led_set_current(led, value);
-                max8997_led_enable(led, false);
-        }
-}
-
-static ssize_t max8997_led_show_mode(struct device *dev,
-                                struct device_attribute *attr, char *buf)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct max8997_led *led =
-                        container_of(led_cdev, struct max8997_led, cdev);
-        ssize_t ret = 0;
-
-        mutex_lock(&led->mutex);
-
-        switch (led->led_mode) {
-        case MAX8997_FLASH_MODE:
-                ret += sprintf(buf, "FLASH\n");
-                break;
-        case MAX8997_MOVIE_MODE:
-                ret += sprintf(buf, "MOVIE\n");
-                break;
-        case MAX8997_FLASH_PIN_CONTROL_MODE:
-                ret += sprintf(buf, "FLASH_PIN_CONTROL\n");
-                break;
-        case MAX8997_MOVIE_PIN_CONTROL_MODE:
-                ret += sprintf(buf, "MOVIE_PIN_CONTROL\n");
-                break;
-        default:
-                ret += sprintf(buf, "NONE\n");
-                break;
-        }
-
-        mutex_unlock(&led->mutex);
-
-        return ret;
-}
-
-static ssize_t max8997_led_store_mode(struct device *dev,
-                                struct device_attribute *attr,
-                                const char *buf, size_t size)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct max8997_led *led =
-                        container_of(led_cdev, struct max8997_led, cdev);
-        enum max8997_led_mode mode;
-
-        mutex_lock(&led->mutex);
-
-        if (!strncmp(buf, "FLASH_PIN_CONTROL", 17))
-                mode = MAX8997_FLASH_PIN_CONTROL_MODE;
-        else if (!strncmp(buf, "MOVIE_PIN_CONTROL", 17))
-                mode = MAX8997_MOVIE_PIN_CONTROL_MODE;
-        else if (!strncmp(buf, "FLASH", 5))
-                mode = MAX8997_FLASH_MODE;
-        else if (!strncmp(buf, "MOVIE", 5))
-                mode = MAX8997_MOVIE_MODE;
-        else
-                mode = MAX8997_NONE;
-
-        max8997_led_set_mode(led, mode);
-
-        mutex_unlock(&led->mutex);
-
-        return size;
-}
-
-static DEVICE_ATTR(mode, 0644, max8997_led_show_mode, max8997_led_store_mode);
-
-static int max8997_led_probe(struct platform_device *pdev)
-{
-        struct max8997_dev *iodev = dev_get_drvdata(pdev->dev.parent);
-        struct max8997_platform_data *pdata = dev_get_platdata(iodev->dev);
-        struct max8997_led *led;
-        char name[20];
-        int ret = 0;
-
-        if (pdata == NULL) {
-                dev_err(&pdev->dev, "no platform data\n");
-                return -ENODEV;
-        }
-
-        led = devm_kzalloc(&pdev->dev, sizeof(*led), GFP_KERNEL);
-        if (led == NULL)
-                return -ENOMEM;
-
-        led->id = pdev->id;
-        snprintf(name, sizeof(name), "max8997-led%d", pdev->id);
-
-        led->cdev.name = name;
-        led->cdev.brightness_set = max8997_led_brightness_set;
-        led->cdev.flags |= LED_CORE_SUSPENDRESUME;
-        led->cdev.brightness = 0;
-        led->iodev = iodev;
-
-        /* initialize mode and brightness according to platform_data */
-        if (pdata->led_pdata) {
-                u8 mode = 0, brightness = 0;
-
-                mode = pdata->led_pdata->mode[led->id];
-                brightness = pdata->led_pdata->brightness[led->id];
-
-                max8997_led_set_mode(led, pdata->led_pdata->mode[led->id]);
-
-                if (brightness > led->cdev.max_brightness)
-                        brightness = led->cdev.max_brightness;
-                max8997_led_set_current(led, brightness);
-                led->cdev.brightness = brightness;
-        } else {
-                max8997_led_set_mode(led, MAX8997_NONE);
-                max8997_led_set_current(led, 0);
-        }
-
-        mutex_init(&led->mutex);
-
-        platform_set_drvdata(pdev, led);
-
-        ret = led_classdev_register(&pdev->dev, &led->cdev);
-        if (ret < 0)
-                return ret;
-
-        ret = device_create_file(led->cdev.dev, &dev_attr_mode);
-        if (ret != 0) {
-                dev_err(&pdev->dev,
-                        "failed to create file: %d\n", ret);
-                led_classdev_unregister(&led->cdev);
-                return ret;
-        }
-
-        return 0;
-}
-
-static int max8997_led_remove(struct platform_device *pdev)
-{
-        struct max8997_led *led = platform_get_drvdata(pdev);
-
-        device_remove_file(led->cdev.dev, &dev_attr_mode);
-        led_classdev_unregister(&led->cdev);
-
-        return 0;
-}
-
-static struct platform_driver max8997_led_driver = {
-        .driver = {
-                .name  = "max8997-led",
-                .owner = THIS_MODULE,
-        },
-        .probe  = max8997_led_probe,
-        .remove = max8997_led_remove,
-};
-
-module_platform_driver(max8997_led_driver);
-
-MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>");
-MODULE_DESCRIPTION("MAX8997 LED driver");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:max8997-led");
diff --git a/drivers/leds/leds-mc13783.c b/drivers/leds/leds-mc13783.c
index e942adaa750..f369e56d654 100644
--- a/drivers/leds/leds-mc13783.c
+++ b/drivers/leds/leds-mc13783.c
@@ -21,13 +21,13 @@
 #include <linux/platform_device.h>
 #include <linux/leds.h>
 #include <linux/workqueue.h>
-#include <linux/mfd/mc13xxx.h>
+#include <linux/mfd/mc13783.h>
 #include <linux/slab.h>
 
 struct mc13783_led {
         struct led_classdev     cdev;
         struct work_struct      work;
-        struct mc13xxx          *master;
+        struct mc13783          *master;
         enum led_brightness     new_brightness;
         int                     id;
 };
@@ -111,11 +111,11 @@ static void mc13783_led_work(struct work_struct *work)
                 break;
         }
 
-        mc13xxx_lock(led->master);
+        mc13783_lock(led->master);
 
-        mc13xxx_reg_rmw(led->master, reg, mask, value);
+        mc13783_reg_rmw(led->master, reg, mask, value);
 
-        mc13xxx_unlock(led->master);
+        mc13783_unlock(led->master);
 }
 
 static void mc13783_led_set(struct led_classdev *led_cdev,
@@ -128,7 +128,7 @@ static void mc13783_led_set(struct led_classdev *led_cdev,
         schedule_work(&led->work);
 }
 
-static int mc13783_led_setup(struct mc13783_led *led, int max_current)
+static int __devinit mc13783_led_setup(struct mc13783_led *led, int max_current)
 {
         int shift = 0;
         int mask = 0;
@@ -172,23 +172,23 @@ static int mc13783_led_setup(struct mc13783_led *led, int max_current)
                 break;
         }
 
-        mc13xxx_lock(led->master);
+        mc13783_lock(led->master);
 
-        ret = mc13xxx_reg_rmw(led->master, reg, mask << shift,
+        ret = mc13783_reg_rmw(led->master, reg, mask << shift,
                                                 value << shift);
 
-        mc13xxx_unlock(led->master);
+        mc13783_unlock(led->master);
         return ret;
 }
 
-static int mc13783_leds_prepare(struct platform_device *pdev)
+static int __devinit mc13783_leds_prepare(struct platform_device *pdev)
 {
-        struct mc13xxx_leds_platform_data *pdata = dev_get_platdata(&pdev->dev);
-        struct mc13xxx *dev = dev_get_drvdata(pdev->dev.parent);
+        struct mc13783_leds_platform_data *pdata = dev_get_platdata(&pdev->dev);
+        struct mc13783 *dev = dev_get_drvdata(pdev->dev.parent);
         int ret = 0;
         int reg = 0;
 
-        mc13xxx_lock(dev);
+        mc13783_lock(dev);
 
         if (pdata->flags & MC13783_LED_TC1HALF)
                 reg |= MC13783_LED_C1_TC1HALF_BIT;
@@ -196,7 +196,7 @@ static int mc13783_leds_prepare(struct platform_device *pdev)
         if (pdata->flags & MC13783_LED_SLEWLIMTC)
                 reg |= MC13783_LED_Cx_SLEWLIM_BIT;
 
-        ret = mc13xxx_reg_write(dev, MC13783_REG_LED_CONTROL_1, reg);
+        ret = mc13783_reg_write(dev, MC13783_REG_LED_CONTROL_1, reg);
         if (ret)
                 goto out;
 
@@ -206,7 +206,7 @@ static int mc13783_leds_prepare(struct platform_device *pdev)
         if (pdata->flags & MC13783_LED_SLEWLIMBL)
                 reg |= MC13783_LED_Cx_SLEWLIM_BIT;
 
-        ret = mc13xxx_reg_write(dev, MC13783_REG_LED_CONTROL_2, reg);
+        ret = mc13783_reg_write(dev, MC13783_REG_LED_CONTROL_2, reg);
         if (ret)
                 goto out;
 
@@ -216,7 +216,7 @@ static int mc13783_leds_prepare(struct platform_device *pdev)
         if (pdata->flags & MC13783_LED_TRIODE_TC1)
                 reg |= MC13783_LED_Cx_TRIODE_TC_BIT;
 
-        ret = mc13xxx_reg_write(dev, MC13783_REG_LED_CONTROL_3, reg);
+        ret = mc13783_reg_write(dev, MC13783_REG_LED_CONTROL_3, reg);
         if (ret)
                 goto out;
 
@@ -226,7 +226,7 @@ static int mc13783_leds_prepare(struct platform_device *pdev)
         if (pdata->flags & MC13783_LED_TRIODE_TC2)
                 reg |= MC13783_LED_Cx_TRIODE_TC_BIT;
 
-        ret = mc13xxx_reg_write(dev, MC13783_REG_LED_CONTROL_4, reg);
+        ret = mc13783_reg_write(dev, MC13783_REG_LED_CONTROL_4, reg);
         if (ret)
                 goto out;
 
@@ -236,7 +236,7 @@ static int mc13783_leds_prepare(struct platform_device *pdev)
         if (pdata->flags & MC13783_LED_TRIODE_TC3)
                 reg |= MC13783_LED_Cx_TRIODE_TC_BIT;
 
-        ret = mc13xxx_reg_write(dev, MC13783_REG_LED_CONTROL_5, reg);
+        ret = mc13783_reg_write(dev, MC13783_REG_LED_CONTROL_5, reg);
         if (ret)
                 goto out;
 
@@ -255,17 +255,17 @@ static int mc13783_leds_prepare(struct platform_device *pdev)
         reg |= (pdata->abref & MC13783_LED_C0_ABREF_MASK) <<
                                                         MC13783_LED_C0_ABREF;
 
-        ret = mc13xxx_reg_write(dev, MC13783_REG_LED_CONTROL_0, reg);
+        ret = mc13783_reg_write(dev, MC13783_REG_LED_CONTROL_0, reg);
 
 out:
-        mc13xxx_unlock(dev);
+        mc13783_unlock(dev);
         return ret;
 }
 
-static int mc13783_led_probe(struct platform_device *pdev)
+static int __devinit mc13783_led_probe(struct platform_device *pdev)
 {
-        struct mc13xxx_leds_platform_data *pdata = dev_get_platdata(&pdev->dev);
-        struct mc13xxx_led_platform_data *led_cur;
+        struct mc13783_leds_platform_data *pdata = dev_get_platdata(&pdev->dev);
+        struct mc13783_led_platform_data *led_cur;
         struct mc13783_led *led, *led_dat;
         int ret, i;
         int init_led = 0;
@@ -275,13 +275,12 @@ static int mc13783_led_probe(struct platform_device *pdev)
                 return -ENODEV;
         }
 
-        if (pdata->num_leds < 1 || pdata->num_leds > (MC13783_LED_MAX + 1)) {
+        if (pdata->num_leds < 1 || pdata->num_leds > MC13783_LED_MAX) {
                 dev_err(&pdev->dev, "Invalid led count %d\n", pdata->num_leds);
                 return -EINVAL;
         }
 
-        led = devm_kzalloc(&pdev->dev, pdata->num_leds * sizeof(*led),
-                                GFP_KERNEL);
+        led = kzalloc(sizeof(*led) * pdata->num_leds, GFP_KERNEL);
         if (led == NULL) {
                 dev_err(&pdev->dev, "failed to alloc memory\n");
                 return -ENOMEM;
@@ -290,7 +289,7 @@ static int mc13783_led_probe(struct platform_device *pdev)
         ret = mc13783_leds_prepare(pdev);
         if (ret) {
                 dev_err(&pdev->dev, "unable to init led driver\n");
-                return ret;
+                goto err_free;
         }
 
         for (i = 0; i < pdata->num_leds; i++) {
@@ -345,14 +344,16 @@ err_register:
                 cancel_work_sync(&led[i].work);
         }
 
+err_free:
+        kfree(led);
         return ret;
 }
 
-static int mc13783_led_remove(struct platform_device *pdev)
+static int __devexit mc13783_led_remove(struct platform_device *pdev)
 {
-        struct mc13xxx_leds_platform_data *pdata = dev_get_platdata(&pdev->dev);
+        struct mc13783_leds_platform_data *pdata = dev_get_platdata(&pdev->dev);
         struct mc13783_led *led = platform_get_drvdata(pdev);
-        struct mc13xxx *dev = dev_get_drvdata(pdev->dev.parent);
+        struct mc13783 *dev = dev_get_drvdata(pdev->dev.parent);
         int i;
 
         for (i = 0; i < pdata->num_leds; i++) {
@@ -360,18 +361,18 @@ static int mc13783_led_remove(struct platform_device *pdev)
                 cancel_work_sync(&led[i].work);
         }
 
-        mc13xxx_lock(dev);
+        mc13783_lock(dev);
 
-        mc13xxx_reg_write(dev, MC13783_REG_LED_CONTROL_0, 0);
-        mc13xxx_reg_write(dev, MC13783_REG_LED_CONTROL_1, 0);
-        mc13xxx_reg_write(dev, MC13783_REG_LED_CONTROL_2, 0);
-        mc13xxx_reg_write(dev, MC13783_REG_LED_CONTROL_3, 0);
-        mc13xxx_reg_write(dev, MC13783_REG_LED_CONTROL_4, 0);
-        mc13xxx_reg_write(dev, MC13783_REG_LED_CONTROL_5, 0);
+        mc13783_reg_write(dev, MC13783_REG_LED_CONTROL_0, 0);
+        mc13783_reg_write(dev, MC13783_REG_LED_CONTROL_1, 0);
+        mc13783_reg_write(dev, MC13783_REG_LED_CONTROL_2, 0);
+        mc13783_reg_write(dev, MC13783_REG_LED_CONTROL_3, 0);
+        mc13783_reg_write(dev, MC13783_REG_LED_CONTROL_4, 0);
+        mc13783_reg_write(dev, MC13783_REG_LED_CONTROL_5, 0);
 
-        mc13xxx_unlock(dev);
+        mc13783_unlock(dev);
 
-        platform_set_drvdata(pdev, NULL);
+        kfree(led);
         return 0;
 }
 
@@ -381,10 +382,20 @@ static struct platform_driver mc13783_led_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe          = mc13783_led_probe,
-        .remove         = mc13783_led_remove,
+        .remove         = __devexit_p(mc13783_led_remove),
 };
 
-module_platform_driver(mc13783_led_driver);
+static int __init mc13783_led_init(void)
+{
+        return platform_driver_register(&mc13783_led_driver);
+}
+module_init(mc13783_led_init);
+
+static void __exit mc13783_led_exit(void)
+{
+        platform_driver_unregister(&mc13783_led_driver);
+}
+module_exit(mc13783_led_exit);
 
 MODULE_DESCRIPTION("LEDs driver for Freescale MC13783 PMIC");
 MODULE_AUTHOR("Philippe Retornaz <philippe.retornaz@epfl.ch>");
diff --git a/drivers/leds/leds-net48xx.c b/drivers/leds/leds-net48xx.c
index 27d06c52824..93987a12da4 100644
--- a/drivers/leds/leds-net48xx.c
+++ b/drivers/leds/leds-net48xx.c
@@ -15,10 +15,9 @@
 #include <linux/platform_device.h>
 #include <linux/leds.h>
 #include <linux/err.h>
-#include <linux/io.h>
+#include <asm/io.h>
 #include <linux/nsc_gpio.h>
 #include <linux/scx200_gpio.h>
-#include <linux/module.h>
 
 #define DRVNAME "net48xx-led"
 #define NET48XX_ERROR_LED_GPIO  20
diff --git a/drivers/leds/leds-netxbig.c b/drivers/leds/leds-netxbig.c
index c61c5ebcc08..f2e51c13439 100644
--- a/drivers/leds/leds-netxbig.c
+++ b/drivers/leds/leds-netxbig.c
@@ -28,7 +28,7 @@
 #include <linux/platform_device.h>
 #include <linux/gpio.h>
 #include <linux/leds.h>
-#include <linux/platform_data/leds-kirkwood-netxbig.h>
+#include <mach/leds-netxbig.h>
 
 /*
  * GPIO extension bus.
@@ -71,7 +71,7 @@ static void gpio_ext_set_value(struct netxbig_gpio_ext *gpio_ext,
         spin_unlock_irqrestore(&gpio_ext_lock, flags);
 }
 
-static int gpio_ext_init(struct netxbig_gpio_ext *gpio_ext)
+static int __devinit gpio_ext_init(struct netxbig_gpio_ext *gpio_ext)
 {
         int err;
         int i;
@@ -81,23 +81,35 @@ static int gpio_ext_init(struct netxbig_gpio_ext *gpio_ext)
 
         /* Configure address GPIOs. */
         for (i = 0; i < gpio_ext->num_addr; i++) {
-                err = gpio_request_one(gpio_ext->addr[i], GPIOF_OUT_INIT_LOW,
-                                       "GPIO extension addr");
+                err = gpio_request(gpio_ext->addr[i], "GPIO extension addr");
                 if (err)
                         goto err_free_addr;
+                err = gpio_direction_output(gpio_ext->addr[i], 0);
+                if (err) {
+                        gpio_free(gpio_ext->addr[i]);
+                        goto err_free_addr;
+                }
         }
         /* Configure data GPIOs. */
         for (i = 0; i < gpio_ext->num_data; i++) {
-                err = gpio_request_one(gpio_ext->data[i], GPIOF_OUT_INIT_LOW,
-                                   "GPIO extension data");
+                err = gpio_request(gpio_ext->data[i], "GPIO extension data");
                 if (err)
                         goto err_free_data;
+                err = gpio_direction_output(gpio_ext->data[i], 0);
+                if (err) {
+                        gpio_free(gpio_ext->data[i]);
+                        goto err_free_data;
+                }
         }
         /* Configure "enable select" GPIO. */
-        err = gpio_request_one(gpio_ext->enable, GPIOF_OUT_INIT_LOW,
-                               "GPIO extension enable");
+        err = gpio_request(gpio_ext->enable, "GPIO extension enable");
         if (err)
                 goto err_free_data;
+        err = gpio_direction_output(gpio_ext->enable, 0);
+        if (err) {
+                gpio_free(gpio_ext->enable);
+                goto err_free_data;
+        }
 
         return 0;
 
@@ -112,7 +124,7 @@ err_free_addr:
         return err;
 }
 
-static void gpio_ext_free(struct netxbig_gpio_ext *gpio_ext)
+static void __devexit gpio_ext_free(struct netxbig_gpio_ext *gpio_ext)
 {
         int i;
 
@@ -243,7 +255,7 @@ static ssize_t netxbig_led_sata_store(struct device *dev,
         int mode_val;
         int ret;
 
-        ret = kstrtoul(buff, 10, &enable);
+        ret = strict_strtoul(buff, 10, &enable);
         if (ret < 0)
                 return ret;
 
@@ -294,14 +306,14 @@ static ssize_t netxbig_led_sata_show(struct device *dev,
 
 static DEVICE_ATTR(sata, 0644, netxbig_led_sata_show, netxbig_led_sata_store);
 
-static void delete_netxbig_led(struct netxbig_led_data *led_dat)
+static void __devexit delete_netxbig_led(struct netxbig_led_data *led_dat)
 {
         if (led_dat->mode_val[NETXBIG_LED_SATA] != NETXBIG_LED_INVALID_MODE)
                 device_remove_file(led_dat->cdev.dev, &dev_attr_sata);
         led_classdev_unregister(&led_dat->cdev);
 }
 
-static int
+static int __devinit
 create_netxbig_led(struct platform_device *pdev,
                    struct netxbig_led_data *led_dat,
                    const struct netxbig_led *template)
@@ -352,7 +364,7 @@ create_netxbig_led(struct platform_device *pdev,
         return ret;
 }
 
-static int netxbig_led_probe(struct platform_device *pdev)
+static int __devinit netxbig_led_probe(struct platform_device *pdev)
 {
         struct netxbig_led_platform_data *pdata = pdev->dev.platform_data;
         struct netxbig_led_data *leds_data;
@@ -362,14 +374,14 @@ static int netxbig_led_probe(struct platform_device *pdev)
         if (!pdata)
                 return -EINVAL;
 
-        leds_data = devm_kzalloc(&pdev->dev,
-                sizeof(struct netxbig_led_data) * pdata->num_leds, GFP_KERNEL);
+        leds_data = kzalloc(sizeof(struct netxbig_led_data) * pdata->num_leds,
+                            GFP_KERNEL);
         if (!leds_data)
                 return -ENOMEM;
 
         ret = gpio_ext_init(pdata->gpio_ext);
         if (ret < 0)
-                return ret;
+                goto err_free_data;
 
         for (i = 0; i < pdata->num_leds; i++) {
                 ret = create_netxbig_led(pdev, &leds_data[i], &pdata->leds[i]);
@@ -386,10 +398,13 @@ err_free_leds:
                 delete_netxbig_led(&leds_data[i]);
 
         gpio_ext_free(pdata->gpio_ext);
+err_free_data:
+        kfree(leds_data);
+
         return ret;
 }
 
-static int netxbig_led_remove(struct platform_device *pdev)
+static int __devexit netxbig_led_remove(struct platform_device *pdev)
 {
         struct netxbig_led_platform_data *pdata = pdev->dev.platform_data;
         struct netxbig_led_data *leds_data;
@@ -401,22 +416,34 @@ static int netxbig_led_remove(struct platform_device *pdev)
                 delete_netxbig_led(&leds_data[i]);
 
         gpio_ext_free(pdata->gpio_ext);
+        kfree(leds_data);
 
         return 0;
 }
 
 static struct platform_driver netxbig_led_driver = {
         .probe          = netxbig_led_probe,
-        .remove         = netxbig_led_remove,
+        .remove         = __devexit_p(netxbig_led_remove),
         .driver         = {
                 .name   = "leds-netxbig",
                 .owner  = THIS_MODULE,
         },
 };
+MODULE_ALIAS("platform:leds-netxbig");
 
-module_platform_driver(netxbig_led_driver);
+static int __init netxbig_led_init(void)
+{
+        return platform_driver_register(&netxbig_led_driver);
+}
+
+static void __exit netxbig_led_exit(void)
+{
+        platform_driver_unregister(&netxbig_led_driver);
+}
+
+module_init(netxbig_led_init);
+module_exit(netxbig_led_exit);
 
 MODULE_AUTHOR("Simon Guinot <sguinot@lacie.com>");
 MODULE_DESCRIPTION("LED driver for LaCie xBig Network boards");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:leds-netxbig");
diff --git a/drivers/leds/leds-ns2.c b/drivers/leds/leds-ns2.c
index d978171c25b..f77d48d0b3e 100644
--- a/drivers/leds/leds-ns2.c
+++ b/drivers/leds/leds-ns2.c
@@ -28,9 +28,7 @@
 #include <linux/slab.h>
 #include <linux/gpio.h>
 #include <linux/leds.h>
-#include <linux/module.h>
-#include <linux/platform_data/leds-kirkwood-ns2.h>
-#include <linux/of_gpio.h>
+#include <mach/leds-ns2.h>
 
 /*
  * The Network Space v2 dual-GPIO LED is wired to a CPLD and can blink in
@@ -150,7 +148,7 @@ static ssize_t ns2_led_sata_store(struct device *dev,
         unsigned long enable;
         enum ns2_led_modes mode;
 
-        ret = kstrtoul(buff, 10, &enable);
+        ret = strict_strtoul(buff, 10, &enable);
         if (ret < 0)
                 return ret;
 
@@ -185,29 +183,36 @@ static ssize_t ns2_led_sata_show(struct device *dev,
 
 static DEVICE_ATTR(sata, 0644, ns2_led_sata_show, ns2_led_sata_store);
 
-static int
+static int __devinit
 create_ns2_led(struct platform_device *pdev, struct ns2_led_data *led_dat,
                const struct ns2_led *template)
 {
         int ret;
         enum ns2_led_modes mode;
 
-        ret = devm_gpio_request_one(&pdev->dev, template->cmd,
-                        GPIOF_DIR_OUT | gpio_get_value(template->cmd),
-                        template->name);
+        ret = gpio_request(template->cmd, template->name);
+        if (ret == 0) {
+                ret = gpio_direction_output(template->cmd,
+                                            gpio_get_value(template->cmd));
+                if (ret)
+                        gpio_free(template->cmd);
+        }
         if (ret) {
                 dev_err(&pdev->dev, "%s: failed to setup command GPIO\n",
                         template->name);
-                return ret;
         }
 
-        ret = devm_gpio_request_one(&pdev->dev, template->slow,
-                        GPIOF_DIR_OUT | gpio_get_value(template->slow),
-                        template->name);
+        ret = gpio_request(template->slow, template->name);
+        if (ret == 0) {
+                ret = gpio_direction_output(template->slow,
+                                            gpio_get_value(template->slow));
+                if (ret)
+                        gpio_free(template->slow);
+        }
         if (ret) {
                 dev_err(&pdev->dev, "%s: failed to setup slow GPIO\n",
                         template->name);
-                return ret;
+                goto err_free_cmd;
         }
 
         rwlock_init(&led_dat->rw_lock);
@@ -222,7 +227,7 @@ create_ns2_led(struct platform_device *pdev, struct ns2_led_data *led_dat,
 
         ret = ns2_led_get_mode(led_dat, &mode);
         if (ret < 0)
-                return ret;
+                goto err_free_slow;
 
         /* Set LED initial state. */
         led_dat->sata = (mode == NS_V2_LED_SATA) ? 1 : 0;
@@ -231,7 +236,7 @@ create_ns2_led(struct platform_device *pdev, struct ns2_led_data *led_dat,
 
         ret = led_classdev_register(&pdev->dev, &led_dat->cdev);
         if (ret < 0)
-                return ret;
+                goto err_free_slow;
 
         ret = device_create_file(led_dat->cdev.dev, &dev_attr_sata);
         if (ret < 0)
@@ -241,115 +246,58 @@ create_ns2_led(struct platform_device *pdev, struct ns2_led_data *led_dat,
 
 err_free_cdev:
         led_classdev_unregister(&led_dat->cdev);
+err_free_slow:
+        gpio_free(led_dat->slow);
+err_free_cmd:
+        gpio_free(led_dat->cmd);
+
         return ret;
 }
 
-static void delete_ns2_led(struct ns2_led_data *led_dat)
+static void __devexit delete_ns2_led(struct ns2_led_data *led_dat)
 {
         device_remove_file(led_dat->cdev.dev, &dev_attr_sata);
         led_classdev_unregister(&led_dat->cdev);
+        gpio_free(led_dat->cmd);
+        gpio_free(led_dat->slow);
 }
 
-#ifdef CONFIG_OF_GPIO
-/*
- * Translate OpenFirmware node properties into platform_data.
- */
-static int
-ns2_leds_get_of_pdata(struct device *dev, struct ns2_led_platform_data *pdata)
-{
-        struct device_node *np = dev->of_node;
-        struct device_node *child;
-        struct ns2_led *leds;
-        int num_leds = 0;
-        int i = 0;
-
-        num_leds = of_get_child_count(np);
-        if (!num_leds)
-                return -ENODEV;
-
-        leds = devm_kzalloc(dev, num_leds * sizeof(struct ns2_led),
-                            GFP_KERNEL);
-        if (!leds)
-                return -ENOMEM;
-
-        for_each_child_of_node(np, child) {
-                const char *string;
-                int ret;
-
-                ret = of_get_named_gpio(child, "cmd-gpio", 0);
-                if (ret < 0)
-                        return ret;
-                leds[i].cmd = ret;
-                ret = of_get_named_gpio(child, "slow-gpio", 0);
-                if (ret < 0)
-                        return ret;
-                leds[i].slow = ret;
-                ret = of_property_read_string(child, "label", &string);
-                leds[i].name = (ret == 0) ? string : child->name;
-                ret = of_property_read_string(child, "linux,default-trigger",
-                                              &string);
-                if (ret == 0)
-                        leds[i].default_trigger = string;
-
-                i++;
-        }
-
-        pdata->leds = leds;
-        pdata->num_leds = num_leds;
-
-        return 0;
-}
-
-static const struct of_device_id of_ns2_leds_match[] = {
-        { .compatible = "lacie,ns2-leds", },
-        {},
-};
-#endif /* CONFIG_OF_GPIO */
-
-static int ns2_led_probe(struct platform_device *pdev)
+static int __devinit ns2_led_probe(struct platform_device *pdev)
 {
         struct ns2_led_platform_data *pdata = pdev->dev.platform_data;
         struct ns2_led_data *leds_data;
         int i;
         int ret;
 
-#ifdef CONFIG_OF_GPIO
-        if (!pdata) {
-                pdata = devm_kzalloc(&pdev->dev,
-                                     sizeof(struct ns2_led_platform_data),
-                                     GFP_KERNEL);
-                if (!pdata)
-                        return -ENOMEM;
-
-                ret = ns2_leds_get_of_pdata(&pdev->dev, pdata);
-                if (ret)
-                        return ret;
-        }
-#else
         if (!pdata)
                 return -EINVAL;
-#endif /* CONFIG_OF_GPIO */
 
-        leds_data = devm_kzalloc(&pdev->dev, sizeof(struct ns2_led_data) *
-                                 pdata->num_leds, GFP_KERNEL);
+        leds_data = kzalloc(sizeof(struct ns2_led_data) *
+                            pdata->num_leds, GFP_KERNEL);
         if (!leds_data)
                 return -ENOMEM;
 
         for (i = 0; i < pdata->num_leds; i++) {
                 ret = create_ns2_led(pdev, &leds_data[i], &pdata->leds[i]);
-                if (ret < 0) {
-                        for (i = i - 1; i >= 0; i--)
-                                delete_ns2_led(&leds_data[i]);
-                        return ret;
-                }
+                if (ret < 0)
+                        goto err;
+
         }
 
         platform_set_drvdata(pdev, leds_data);
 
         return 0;
+
+err:
+        for (i = i - 1; i >= 0; i--)
+                delete_ns2_led(&leds_data[i]);
+
+        kfree(leds_data);
+
+        return ret;
 }
 
-static int ns2_led_remove(struct platform_device *pdev)
+static int __devexit ns2_led_remove(struct platform_device *pdev)
 {
         int i;
         struct ns2_led_platform_data *pdata = pdev->dev.platform_data;
@@ -360,6 +308,7 @@ static int ns2_led_remove(struct platform_device *pdev)
         for (i = 0; i < pdata->num_leds; i++)
                 delete_ns2_led(&leds_data[i]);
 
+        kfree(leds_data);
         platform_set_drvdata(pdev, NULL);
 
         return 0;
@@ -367,17 +316,27 @@ static int ns2_led_remove(struct platform_device *pdev)
 
 static struct platform_driver ns2_led_driver = {
         .probe          = ns2_led_probe,
-        .remove         = ns2_led_remove,
+        .remove         = __devexit_p(ns2_led_remove),
         .driver         = {
-                .name           = "leds-ns2",
-                .owner          = THIS_MODULE,
-                .of_match_table = of_match_ptr(of_ns2_leds_match),
+                .name   = "leds-ns2",
+                .owner  = THIS_MODULE,
         },
 };
+MODULE_ALIAS("platform:leds-ns2");
 
-module_platform_driver(ns2_led_driver);
+static int __init ns2_led_init(void)
+{
+        return platform_driver_register(&ns2_led_driver);
+}
+
+static void __exit ns2_led_exit(void)
+{
+        platform_driver_unregister(&ns2_led_driver);
+}
+
+module_init(ns2_led_init);
+module_exit(ns2_led_exit);
 
 MODULE_AUTHOR("Simon Guinot <sguinot@lacie.com>");
 MODULE_DESCRIPTION("Network Space v2 LED driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:leds-ns2");
diff --git a/drivers/leds/leds-ot200.c b/drivers/leds/leds-ot200.c
deleted file mode 100644
index ee14662ed5c..00000000000
--- a/drivers/leds/leds-ot200.c
+++ /dev/null
@@ -1,171 +0,0 @@
-/*
- * Bachmann ot200 leds driver.
- *
- * Author: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
- *         Christian Gmeiner <christian.gmeiner@gmail.com>
- *
- * License: GPL as published by the FSF.
- */
-
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/platform_device.h>
-#include <linux/slab.h>
-#include <linux/leds.h>
-#include <linux/io.h>
-#include <linux/module.h>
-
-
-struct ot200_led {
-        struct led_classdev cdev;
-        const char *name;
-        unsigned long port;
-        u8 mask;
-};
-
-/*
- * The device has three leds on the back panel (led_err, led_init and led_run)
- * and can handle up to seven leds on the front panel.
- */
-
-static struct ot200_led leds[] = {
-        {
-                .name = "led_run",
-                .port = 0x5a,
-                .mask = BIT(0),
-        },
-        {
-                .name = "led_init",
-                .port = 0x5a,
-                .mask = BIT(1),
-        },
-        {
-                .name = "led_err",
-                .port = 0x5a,
-                .mask = BIT(2),
-        },
-        {
-                .name = "led_1",
-                .port = 0x49,
-                .mask = BIT(7),
-        },
-        {
-                .name = "led_2",
-                .port = 0x49,
-                .mask = BIT(6),
-        },
-        {
-                .name = "led_3",
-                .port = 0x49,
-                .mask = BIT(5),
-        },
-        {
-                .name = "led_4",
-                .port = 0x49,
-                .mask = BIT(4),
-        },
-        {
-                .name = "led_5",
-                .port = 0x49,
-                .mask = BIT(3),
-        },
-        {
-                .name = "led_6",
-                .port = 0x49,
-                .mask = BIT(2),
-        },
-        {
-                .name = "led_7",
-                .port = 0x49,
-                .mask = BIT(1),
-        }
-};
-
-static DEFINE_SPINLOCK(value_lock);
-
-/*
- * we need to store the current led states, as it is not
- * possible to read the current led state via inb().
- */
-static u8 leds_back;
-static u8 leds_front;
-
-static void ot200_led_brightness_set(struct led_classdev *led_cdev,
-                enum led_brightness value)
-{
-        struct ot200_led *led = container_of(led_cdev, struct ot200_led, cdev);
-        u8 *val;
-        unsigned long flags;
-
-        spin_lock_irqsave(&value_lock, flags);
-
-        if (led->port == 0x49)
-                val = &leds_front;
-        else if (led->port == 0x5a)
-                val = &leds_back;
-        else
-                BUG();
-
-        if (value == LED_OFF)
-                *val &= ~led->mask;
-        else
-                *val |= led->mask;
-
-        outb(*val, led->port);
-        spin_unlock_irqrestore(&value_lock, flags);
-}
-
-static int ot200_led_probe(struct platform_device *pdev)
-{
-        int i;
-        int ret;
-
-        for (i = 0; i < ARRAY_SIZE(leds); i++) {
-
-                leds[i].cdev.name = leds[i].name;
-                leds[i].cdev.brightness_set = ot200_led_brightness_set;
-
-                ret = led_classdev_register(&pdev->dev, &leds[i].cdev);
-                if (ret < 0)
-                        goto err;
-        }
-
-        leds_front = 0;         /* turn off all front leds */
-        leds_back = BIT(1);     /* turn on init led */
-        outb(leds_front, 0x49);
-        outb(leds_back, 0x5a);
-
-        return 0;
-
-err:
-        for (i = i - 1; i >= 0; i--)
-                led_classdev_unregister(&leds[i].cdev);
-
-        return ret;
-}
-
-static int ot200_led_remove(struct platform_device *pdev)
-{
-        int i;
-
-        for (i = 0; i < ARRAY_SIZE(leds); i++)
-                led_classdev_unregister(&leds[i].cdev);
-
-        return 0;
-}
-
-static struct platform_driver ot200_led_driver = {
-        .probe          = ot200_led_probe,
-        .remove         = ot200_led_remove,
-        .driver         = {
-                .name   = "leds-ot200",
-                .owner  = THIS_MODULE,
-        },
-};
-
-module_platform_driver(ot200_led_driver);
-
-MODULE_AUTHOR("Sebastian A. Siewior <bigeasy@linutronix.de>");
-MODULE_DESCRIPTION("ot200 LED driver");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:leds-ot200");
diff --git a/drivers/leds/leds-pca9532.c b/drivers/leds/leds-pca9532.c
index cee8a5b483a..a2c874623e3 100644
--- a/drivers/leds/leds-pca9532.c
+++ b/drivers/leds/leds-pca9532.c
@@ -449,6 +449,7 @@ static int pca9532_probe(struct i2c_client *client,
 {
         struct pca9532_data *data = i2c_get_clientdata(client);
         struct pca9532_platform_data *pca9532_pdata = client->dev.platform_data;
+        int err;
 
         if (!pca9532_pdata)
                 return -EIO;
@@ -457,7 +458,7 @@ static int pca9532_probe(struct i2c_client *client,
                 I2C_FUNC_SMBUS_BYTE_DATA))
                 return -EIO;
 
-        data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
+        data = kzalloc(sizeof(*data), GFP_KERNEL);
         if (!data)
                 return -ENOMEM;
 
@@ -468,7 +469,11 @@ static int pca9532_probe(struct i2c_client *client,
         data->client = client;
         mutex_init(&data->update_lock);
 
-        return pca9532_configure(client, data, pca9532_pdata);
+        err = pca9532_configure(client, data, pca9532_pdata);
+        if (err)
+                kfree(data);
+
+        return err;
 }
 
 static int pca9532_remove(struct i2c_client *client)
@@ -480,11 +485,24 @@ static int pca9532_remove(struct i2c_client *client)
         if (err)
                 return err;
 
+        kfree(data);
         return 0;
 }
 
-module_i2c_driver(pca9532_driver);
+static int __init pca9532_init(void)
+{
+        return i2c_add_driver(&pca9532_driver);
+}
+
+static void __exit pca9532_exit(void)
+{
+        i2c_del_driver(&pca9532_driver);
+}
 
 MODULE_AUTHOR("Riku Voipio");
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("PCA 9532 LED dimmer");
+
+module_init(pca9532_init);
+module_exit(pca9532_exit);
+
diff --git a/drivers/leds/leds-pca955x.c b/drivers/leds/leds-pca955x.c
index edf485b773c..66aa3e8e786 100644
--- a/drivers/leds/leds-pca955x.c
+++ b/drivers/leds/leds-pca955x.c
@@ -101,16 +101,11 @@ static const struct i2c_device_id pca955x_id[] = {
 };
 MODULE_DEVICE_TABLE(i2c, pca955x_id);
 
-struct pca955x {
-        struct mutex lock;
-        struct pca955x_led *leds;
+struct pca955x_led {
         struct pca955x_chipdef  *chipdef;
         struct i2c_client       *client;
-};
-
-struct pca955x_led {
-        struct pca955x  *pca955x;
         struct work_struct      work;
+        spinlock_t              lock;
         enum led_brightness     brightness;
         struct led_classdev     led_cdev;
         int                     led_num;        /* 0 .. 15 potentially */
@@ -145,7 +140,7 @@ static inline u8 pca955x_ledsel(u8 oldval, int led_num, int state)
  */
 static void pca955x_write_psc(struct i2c_client *client, int n, u8 val)
 {
-        struct pca955x *pca955x = i2c_get_clientdata(client);
+        struct pca955x_led *pca955x = i2c_get_clientdata(client);
 
         i2c_smbus_write_byte_data(client,
                 pca95xx_num_input_regs(pca955x->chipdef->bits) + 2*n,
@@ -161,7 +156,7 @@ static void pca955x_write_psc(struct i2c_client *client, int n, u8 val)
  */
 static void pca955x_write_pwm(struct i2c_client *client, int n, u8 val)
 {
-        struct pca955x *pca955x = i2c_get_clientdata(client);
+        struct pca955x_led *pca955x = i2c_get_clientdata(client);
 
         i2c_smbus_write_byte_data(client,
                 pca95xx_num_input_regs(pca955x->chipdef->bits) + 1 + 2*n,
@@ -174,7 +169,7 @@ static void pca955x_write_pwm(struct i2c_client *client, int n, u8 val)
  */
 static void pca955x_write_ls(struct i2c_client *client, int n, u8 val)
 {
-        struct pca955x *pca955x = i2c_get_clientdata(client);
+        struct pca955x_led *pca955x = i2c_get_clientdata(client);
 
         i2c_smbus_write_byte_data(client,
                 pca95xx_num_input_regs(pca955x->chipdef->bits) + 4 + n,
@@ -187,7 +182,7 @@ static void pca955x_write_ls(struct i2c_client *client, int n, u8 val)
  */
 static u8 pca955x_read_ls(struct i2c_client *client, int n)
 {
-        struct pca955x *pca955x = i2c_get_clientdata(client);
+        struct pca955x_led *pca955x = i2c_get_clientdata(client);
 
         return (u8) i2c_smbus_read_byte_data(client,
                 pca95xx_num_input_regs(pca955x->chipdef->bits) + 4 + n);
@@ -195,23 +190,18 @@ static u8 pca955x_read_ls(struct i2c_client *client, int n)
 
 static void pca955x_led_work(struct work_struct *work)
 {
-        struct pca955x_led *pca955x_led;
-        struct pca955x *pca955x;
+        struct pca955x_led *pca955x;
         u8 ls;
         int chip_ls;    /* which LSx to use (0-3 potentially) */
         int ls_led;     /* which set of bits within LSx to use (0-3) */
 
-        pca955x_led = container_of(work, struct pca955x_led, work);
-        pca955x = pca955x_led->pca955x;
-
-        chip_ls = pca955x_led->led_num / 4;
-        ls_led = pca955x_led->led_num % 4;
-
-        mutex_lock(&pca955x->lock);
+        pca955x = container_of(work, struct pca955x_led, work);
+        chip_ls = pca955x->led_num / 4;
+        ls_led = pca955x->led_num % 4;
 
         ls = pca955x_read_ls(pca955x->client, chip_ls);
 
-        switch (pca955x_led->brightness) {
+        switch (pca955x->brightness) {
         case LED_FULL:
                 ls = pca955x_ledsel(ls, ls_led, PCA955X_LS_LED_ON);
                 break;
@@ -229,15 +219,12 @@ static void pca955x_led_work(struct work_struct *work)
                  * OFF, HALF, or FULL.  But, this is probably better than
                  * just turning off for all other values.
                  */
-                pca955x_write_pwm(pca955x->client, 1,
-                                255 - pca955x_led->brightness);
+                pca955x_write_pwm(pca955x->client, 1, 255-pca955x->brightness);
                 ls = pca955x_ledsel(ls, ls_led, PCA955X_LS_BLINK1);
                 break;
         }
 
         pca955x_write_ls(pca955x->client, chip_ls, ls);
-
-        mutex_unlock(&pca955x->lock);
 }
 
 static void pca955x_led_set(struct led_classdev *led_cdev, enum led_brightness value)
@@ -246,6 +233,7 @@ static void pca955x_led_set(struct led_classdev *led_cdev, enum led_brightness v
 
         pca955x = container_of(led_cdev, struct pca955x_led, led_cdev);
 
+        spin_lock(&pca955x->lock);
         pca955x->brightness = value;
 
         /*
@@ -253,13 +241,14 @@ static void pca955x_led_set(struct led_classdev *led_cdev, enum led_brightness v
          * can sleep.
          */
         schedule_work(&pca955x->work);
+
+        spin_unlock(&pca955x->lock);
 }
 
-static int pca955x_probe(struct i2c_client *client,
+static int __devinit pca955x_probe(struct i2c_client *client,
                                         const struct i2c_device_id *id)
 {
-        struct pca955x *pca955x;
-        struct pca955x_led *pca955x_led;
+        struct pca955x_led *pca955x;
         struct pca955x_chipdef *chip;
         struct i2c_adapter *adapter;
         struct led_platform_data *pdata;
@@ -277,7 +266,7 @@ static int pca955x_probe(struct i2c_client *client,
                 return -ENODEV;
         }
 
-        dev_info(&client->dev, "leds-pca955x: Using %s %d-bit LED driver at "
+        printk(KERN_INFO "leds-pca955x: Using %s %d-bit LED driver at "
                         "slave address 0x%02x\n",
                         id->name, chip->bits, client->addr);
 
@@ -293,47 +282,39 @@ static int pca955x_probe(struct i2c_client *client,
                 }
         }
 
-        pca955x = devm_kzalloc(&client->dev, sizeof(*pca955x), GFP_KERNEL);
+        pca955x = kzalloc(sizeof(*pca955x) * chip->bits, GFP_KERNEL);
         if (!pca955x)
                 return -ENOMEM;
 
-        pca955x->leds = devm_kzalloc(&client->dev,
-                        sizeof(*pca955x_led) * chip->bits, GFP_KERNEL);
-        if (!pca955x->leds)
-                return -ENOMEM;
-
         i2c_set_clientdata(client, pca955x);
 
-        mutex_init(&pca955x->lock);
-        pca955x->client = client;
-        pca955x->chipdef = chip;
-
         for (i = 0; i < chip->bits; i++) {
-                pca955x_led = &pca955x->leds[i];
-                pca955x_led->led_num = i;
-                pca955x_led->pca955x = pca955x;
+                pca955x[i].chipdef = chip;
+                pca955x[i].client = client;
+                pca955x[i].led_num = i;
 
                 /* Platform data can specify LED names and default triggers */
                 if (pdata) {
                         if (pdata->leds[i].name)
-                                snprintf(pca955x_led->name,
-                                        sizeof(pca955x_led->name), "pca955x:%s",
-                                        pdata->leds[i].name);
+                                snprintf(pca955x[i].name,
+                                         sizeof(pca955x[i].name), "pca955x:%s",
+                                         pdata->leds[i].name);
                         if (pdata->leds[i].default_trigger)
-                                pca955x_led->led_cdev.default_trigger =
+                                pca955x[i].led_cdev.default_trigger =
                                         pdata->leds[i].default_trigger;
                 } else {
-                        snprintf(pca955x_led->name, sizeof(pca955x_led->name),
+                        snprintf(pca955x[i].name, sizeof(pca955x[i].name),
                                  "pca955x:%d", i);
                 }
 
-                pca955x_led->led_cdev.name = pca955x_led->name;
-                pca955x_led->led_cdev.brightness_set = pca955x_led_set;
+                spin_lock_init(&pca955x[i].lock);
+
+                pca955x[i].led_cdev.name = pca955x[i].name;
+                pca955x[i].led_cdev.brightness_set = pca955x_led_set;
 
-                INIT_WORK(&pca955x_led->work, pca955x_led_work);
+                INIT_WORK(&pca955x[i].work, pca955x_led_work);
 
-                err = led_classdev_register(&client->dev,
-                                        &pca955x_led->led_cdev);
+                err = led_classdev_register(&client->dev, &pca955x[i].led_cdev);
                 if (err < 0)
                         goto exit;
         }
@@ -356,23 +337,27 @@ static int pca955x_probe(struct i2c_client *client,
 
 exit:
         while (i--) {
-                led_classdev_unregister(&pca955x->leds[i].led_cdev);
-                cancel_work_sync(&pca955x->leds[i].work);
+                led_classdev_unregister(&pca955x[i].led_cdev);
+                cancel_work_sync(&pca955x[i].work);
         }
 
+        kfree(pca955x);
+
         return err;
 }
 
-static int pca955x_remove(struct i2c_client *client)
+static int __devexit pca955x_remove(struct i2c_client *client)
 {
-        struct pca955x *pca955x = i2c_get_clientdata(client);
+        struct pca955x_led *pca955x = i2c_get_clientdata(client);
         int i;
 
         for (i = 0; i < pca955x->chipdef->bits; i++) {
-                led_classdev_unregister(&pca955x->leds[i].led_cdev);
-                cancel_work_sync(&pca955x->leds[i].work);
+                led_classdev_unregister(&pca955x[i].led_cdev);
+                cancel_work_sync(&pca955x[i].work);
         }
 
+        kfree(pca955x);
+
         return 0;
 }
 
@@ -382,11 +367,22 @@ static struct i2c_driver pca955x_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe  = pca955x_probe,
-        .remove = pca955x_remove,
+        .remove = __devexit_p(pca955x_remove),
         .id_table = pca955x_id,
 };
 
-module_i2c_driver(pca955x_driver);
+static int __init pca955x_leds_init(void)
+{
+        return i2c_add_driver(&pca955x_driver);
+}
+
+static void __exit pca955x_leds_exit(void)
+{
+        i2c_del_driver(&pca955x_driver);
+}
+
+module_init(pca955x_leds_init);
+module_exit(pca955x_leds_exit);
 
 MODULE_AUTHOR("Nate Case <ncase@xes-inc.com>");
 MODULE_DESCRIPTION("PCA955x LED driver");
diff --git a/drivers/leds/leds-pca9633.c b/drivers/leds/leds-pca9633.c
deleted file mode 100644
index 9aae5679ffb..00000000000
--- a/drivers/leds/leds-pca9633.c
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- * Copyright 2011 bct electronic GmbH
- *
- * Author: Peter Meerwald <p.meerwald@bct-electronic.com>
- *
- * Based on leds-pca955x.c
- *
- * This file is subject to the terms and conditions of version 2 of
- * the GNU General Public License.  See the file COPYING in the main
- * directory of this archive for more details.
- *
- * LED driver for the PCA9633 I2C LED driver (7-bit slave address 0x62)
- *
- */
-
-#include <linux/module.h>
-#include <linux/delay.h>
-#include <linux/string.h>
-#include <linux/ctype.h>
-#include <linux/leds.h>
-#include <linux/err.h>
-#include <linux/i2c.h>
-#include <linux/workqueue.h>
-#include <linux/slab.h>
-#include <linux/platform_data/leds-pca9633.h>
-
-/* LED select registers determine the source that drives LED outputs */
-#define PCA9633_LED_OFF         0x0     /* LED driver off */
-#define PCA9633_LED_ON          0x1     /* LED driver on */
-#define PCA9633_LED_PWM         0x2     /* Controlled through PWM */
-#define PCA9633_LED_GRP_PWM     0x3     /* Controlled through PWM/GRPPWM */
-
-#define PCA9633_MODE1           0x00
-#define PCA9633_MODE2           0x01
-#define PCA9633_PWM_BASE        0x02
-#define PCA9633_LEDOUT          0x08
-
-static const struct i2c_device_id pca9633_id[] = {
-        { "pca9633", 0 },
-        { }
-};
-MODULE_DEVICE_TABLE(i2c, pca9633_id);
-
-struct pca9633_led {
-        struct i2c_client *client;
-        struct work_struct work;
-        enum led_brightness brightness;
-        struct led_classdev led_cdev;
-        int led_num; /* 0 .. 3 potentially */
-        char name[32];
-};
-
-static void pca9633_led_work(struct work_struct *work)
-{
-        struct pca9633_led *pca9633 = container_of(work,
-                struct pca9633_led, work);
-        u8 ledout = i2c_smbus_read_byte_data(pca9633->client, PCA9633_LEDOUT);
-        int shift = 2 * pca9633->led_num;
-        u8 mask = 0x3 << shift;
-
-        switch (pca9633->brightness) {
-        case LED_FULL:
-                i2c_smbus_write_byte_data(pca9633->client, PCA9633_LEDOUT,
-                        (ledout & ~mask) | (PCA9633_LED_ON << shift));
-                break;
-        case LED_OFF:
-                i2c_smbus_write_byte_data(pca9633->client, PCA9633_LEDOUT,
-                        ledout & ~mask);
-                break;
-        default:
-                i2c_smbus_write_byte_data(pca9633->client,
-                        PCA9633_PWM_BASE + pca9633->led_num,
-                        pca9633->brightness);
-                i2c_smbus_write_byte_data(pca9633->client, PCA9633_LEDOUT,
-                        (ledout & ~mask) | (PCA9633_LED_PWM << shift));
-                break;
-        }
-}
-
-static void pca9633_led_set(struct led_classdev *led_cdev,
-        enum led_brightness value)
-{
-        struct pca9633_led *pca9633;
-
-        pca9633 = container_of(led_cdev, struct pca9633_led, led_cdev);
-
-        pca9633->brightness = value;
-
-        /*
-         * Must use workqueue for the actual I/O since I2C operations
-         * can sleep.
-         */
-        schedule_work(&pca9633->work);
-}
-
-static int pca9633_probe(struct i2c_client *client,
-                                        const struct i2c_device_id *id)
-{
-        struct pca9633_led *pca9633;
-        struct pca9633_platform_data *pdata;
-        int i, err;
-
-        pdata = client->dev.platform_data;
-
-        if (pdata) {
-                if (pdata->leds.num_leds <= 0 || pdata->leds.num_leds > 4) {
-                        dev_err(&client->dev, "board info must claim at most 4 LEDs");
-                        return -EINVAL;
-                }
-        }
-
-        pca9633 = devm_kzalloc(&client->dev, 4 * sizeof(*pca9633), GFP_KERNEL);
-        if (!pca9633)
-                return -ENOMEM;
-
-        i2c_set_clientdata(client, pca9633);
-
-        for (i = 0; i < 4; i++) {
-                pca9633[i].client = client;
-                pca9633[i].led_num = i;
-
-                /* Platform data can specify LED names and default triggers */
-                if (pdata && i < pdata->leds.num_leds) {
-                        if (pdata->leds.leds[i].name)
-                                snprintf(pca9633[i].name,
-                                         sizeof(pca9633[i].name), "pca9633:%s",
-                                         pdata->leds.leds[i].name);
-                        if (pdata->leds.leds[i].default_trigger)
-                                pca9633[i].led_cdev.default_trigger =
-                                        pdata->leds.leds[i].default_trigger;
-                } else {
-                        snprintf(pca9633[i].name, sizeof(pca9633[i].name),
-                                 "pca9633:%d", i);
-                }
-
-                pca9633[i].led_cdev.name = pca9633[i].name;
-                pca9633[i].led_cdev.brightness_set = pca9633_led_set;
-
-                INIT_WORK(&pca9633[i].work, pca9633_led_work);
-
-                err = led_classdev_register(&client->dev, &pca9633[i].led_cdev);
-                if (err < 0)
-                        goto exit;
-        }
-
-        /* Disable LED all-call address and set normal mode */
-        i2c_smbus_write_byte_data(client, PCA9633_MODE1, 0x00);
-
-        /* Configure output: open-drain or totem pole (push-pull) */
-        if (pdata && pdata->outdrv == PCA9633_OPEN_DRAIN)
-                i2c_smbus_write_byte_data(client, PCA9633_MODE2, 0x01);
-
-        /* Turn off LEDs */
-        i2c_smbus_write_byte_data(client, PCA9633_LEDOUT, 0x00);
-
-        return 0;
-
-exit:
-        while (i--) {
-                led_classdev_unregister(&pca9633[i].led_cdev);
-                cancel_work_sync(&pca9633[i].work);
-        }
-
-        return err;
-}
-
-static int pca9633_remove(struct i2c_client *client)
-{
-        struct pca9633_led *pca9633 = i2c_get_clientdata(client);
-        int i;
-
-        for (i = 0; i < 4; i++) {
-                led_classdev_unregister(&pca9633[i].led_cdev);
-                cancel_work_sync(&pca9633[i].work);
-        }
-
-        return 0;
-}
-
-static struct i2c_driver pca9633_driver = {
-        .driver = {
-                .name   = "leds-pca9633",
-                .owner  = THIS_MODULE,
-        },
-        .probe  = pca9633_probe,
-        .remove = pca9633_remove,
-        .id_table = pca9633_id,
-};
-
-module_i2c_driver(pca9633_driver);
-
-MODULE_AUTHOR("Peter Meerwald <p.meerwald@bct-electronic.com>");
-MODULE_DESCRIPTION("PCA9633 LED driver");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/leds/leds-pwm.c b/drivers/leds/leds-pwm.c
index 2157524f277..666daf77872 100644
--- a/drivers/leds/leds-pwm.c
+++ b/drivers/leds/leds-pwm.c
@@ -26,7 +26,7 @@
 struct led_pwm_data {
         struct led_classdev     cdev;
         struct pwm_device       *pwm;
-        unsigned int            active_low;
+        unsigned int            active_low;
         unsigned int            period;
 };
 
@@ -57,8 +57,7 @@ static int led_pwm_probe(struct platform_device *pdev)
         if (!pdata)
                 return -EBUSY;
 
-        leds_data = devm_kzalloc(&pdev->dev,
-                        sizeof(struct led_pwm_data) * pdata->num_leds,
+        leds_data = kzalloc(sizeof(struct led_pwm_data) * pdata->num_leds,
                                 GFP_KERNEL);
         if (!leds_data)
                 return -ENOMEM;
@@ -104,10 +103,12 @@ err:
                 }
         }
 
+        kfree(leds_data);
+
         return ret;
 }
 
-static int led_pwm_remove(struct platform_device *pdev)
+static int __devexit led_pwm_remove(struct platform_device *pdev)
 {
         int i;
         struct led_pwm_platform_data *pdata = pdev->dev.platform_data;
@@ -120,19 +121,32 @@ static int led_pwm_remove(struct platform_device *pdev)
                 pwm_free(leds_data[i].pwm);
         }
 
+        kfree(leds_data);
+
         return 0;
 }
 
 static struct platform_driver led_pwm_driver = {
         .probe          = led_pwm_probe,
-        .remove         = led_pwm_remove,
+        .remove         = __devexit_p(led_pwm_remove),
         .driver         = {
                 .name   = "leds_pwm",
                 .owner  = THIS_MODULE,
         },
 };
 
-module_platform_driver(led_pwm_driver);
+static int __init led_pwm_init(void)
+{
+        return platform_driver_register(&led_pwm_driver);
+}
+
+static void __exit led_pwm_exit(void)
+{
+        platform_driver_unregister(&led_pwm_driver);
+}
+
+module_init(led_pwm_init);
+module_exit(led_pwm_exit);
 
 MODULE_AUTHOR("Luotao Fu <l.fu@pengutronix.de>");
 MODULE_DESCRIPTION("PWM LED driver for PXA");
diff --git a/drivers/leds/leds-rb532.c b/drivers/leds/leds-rb532.c
index 2e746d257b0..c3525f37f73 100644
--- a/drivers/leds/leds-rb532.c
+++ b/drivers/leds/leds-rb532.c
@@ -16,7 +16,7 @@
 #include <asm/mach-rc32434/rb.h>
 
 static void rb532_led_set(struct led_classdev *cdev,
-                          enum led_brightness brightness)
+                          enum led_brightness brightness)
 {
         if (brightness)
                 set_latch_u5(LO_ULED, 0);
@@ -37,12 +37,12 @@ static struct led_classdev rb532_uled = {
         .default_trigger = "nand-disk",
 };
 
-static int rb532_led_probe(struct platform_device *pdev)
+static int __devinit rb532_led_probe(struct platform_device *pdev)
 {
         return led_classdev_register(&pdev->dev, &rb532_uled);
 }
 
-static int rb532_led_remove(struct platform_device *pdev)
+static int __devexit rb532_led_remove(struct platform_device *pdev)
 {
         led_classdev_unregister(&rb532_uled);
         return 0;
@@ -50,16 +50,28 @@ static int rb532_led_remove(struct platform_device *pdev)
 
 static struct platform_driver rb532_led_driver = {
         .probe = rb532_led_probe,
-        .remove = rb532_led_remove,
+        .remove = __devexit_p(rb532_led_remove),
         .driver = {
                 .name = "rb532-led",
                 .owner = THIS_MODULE,
         },
 };
 
-module_platform_driver(rb532_led_driver);
+static int __init rb532_led_init(void)
+{
+        return platform_driver_register(&rb532_led_driver);
+}
+
+static void __exit rb532_led_exit(void)
+{
+        platform_driver_unregister(&rb532_led_driver);
+}
+
+module_init(rb532_led_init);
+module_exit(rb532_led_exit);
+
+MODULE_ALIAS("platform:rb532-led");
 
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("User LED support for Routerboard532");
 MODULE_AUTHOR("Phil Sutter <n0-1@freewrt.org>");
-MODULE_ALIAS("platform:rb532-led");
diff --git a/drivers/leds/leds-regulator.c b/drivers/leds/leds-regulator.c
index 4253a9b03db..8497f56f8e4 100644
--- a/drivers/leds/leds-regulator.c
+++ b/drivers/leds/leds-regulator.c
@@ -140,7 +140,7 @@ static void regulator_led_brightness_set(struct led_classdev *led_cdev,
         schedule_work(&led->work);
 }
 
-static int regulator_led_probe(struct platform_device *pdev)
+static int __devinit regulator_led_probe(struct platform_device *pdev)
 {
         struct led_regulator_platform_data *pdata = pdev->dev.platform_data;
         struct regulator_led *led;
@@ -158,7 +158,7 @@ static int regulator_led_probe(struct platform_device *pdev)
                 return PTR_ERR(vcc);
         }
 
-        led = devm_kzalloc(&pdev->dev, sizeof(*led), GFP_KERNEL);
+        led = kzalloc(sizeof(*led), GFP_KERNEL);
         if (led == NULL) {
                 ret = -ENOMEM;
                 goto err_vcc;
@@ -169,7 +169,7 @@ static int regulator_led_probe(struct platform_device *pdev)
                 dev_err(&pdev->dev, "Invalid default brightness %d\n",
                                 pdata->brightness);
                 ret = -EINVAL;
-                goto err_vcc;
+                goto err_led;
         }
         led->value = pdata->brightness;
 
@@ -190,7 +190,7 @@ static int regulator_led_probe(struct platform_device *pdev)
         ret = led_classdev_register(&pdev->dev, &led->cdev);
         if (ret < 0) {
                 cancel_work_sync(&led->work);
-                goto err_vcc;
+                goto err_led;
         }
 
         /* to expose the default value to userspace */
@@ -201,12 +201,14 @@ static int regulator_led_probe(struct platform_device *pdev)
 
         return 0;
 
+err_led:
+        kfree(led);
 err_vcc:
         regulator_put(vcc);
         return ret;
 }
 
-static int regulator_led_remove(struct platform_device *pdev)
+static int __devexit regulator_led_remove(struct platform_device *pdev)
 {
         struct regulator_led *led = platform_get_drvdata(pdev);
 
@@ -214,6 +216,7 @@ static int regulator_led_remove(struct platform_device *pdev)
         cancel_work_sync(&led->work);
         regulator_led_disable(led);
         regulator_put(led->vcc);
+        kfree(led);
         return 0;
 }
 
@@ -223,10 +226,20 @@ static struct platform_driver regulator_led_driver = {
                    .owner = THIS_MODULE,
                    },
         .probe  = regulator_led_probe,
-        .remove = regulator_led_remove,
+        .remove = __devexit_p(regulator_led_remove),
 };
 
-module_platform_driver(regulator_led_driver);
+static int __init regulator_led_init(void)
+{
+        return platform_driver_register(&regulator_led_driver);
+}
+module_init(regulator_led_init);
+
+static void __exit regulator_led_exit(void)
+{
+        platform_driver_unregister(&regulator_led_driver);
+}
+module_exit(regulator_led_exit);
 
 MODULE_AUTHOR("Antonio Ospite <ospite@studenti.unina.it>");
 MODULE_DESCRIPTION("Regulator driven LED driver");
diff --git a/drivers/leds/leds-renesas-tpu.c b/drivers/leds/leds-renesas-tpu.c
deleted file mode 100644
index e0fff1ca592..00000000000
--- a/drivers/leds/leds-renesas-tpu.c
+++ /dev/null
@@ -1,336 +0,0 @@
-/*
- * LED control using Renesas TPU
- *
- *  Copyright (C) 2011 Magnus Damm
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- */
-
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/platform_device.h>
-#include <linux/spinlock.h>
-#include <linux/printk.h>
-#include <linux/ioport.h>
-#include <linux/io.h>
-#include <linux/clk.h>
-#include <linux/leds.h>
-#include <linux/platform_data/leds-renesas-tpu.h>
-#include <linux/gpio.h>
-#include <linux/err.h>
-#include <linux/slab.h>
-#include <linux/pm_runtime.h>
-#include <linux/workqueue.h>
-
-enum r_tpu_pin { R_TPU_PIN_UNUSED, R_TPU_PIN_GPIO, R_TPU_PIN_GPIO_FN };
-enum r_tpu_timer { R_TPU_TIMER_UNUSED, R_TPU_TIMER_ON };
-
-struct r_tpu_priv {
-        struct led_classdev ldev;
-        void __iomem *mapbase;
-        struct clk *clk;
-        struct platform_device *pdev;
-        enum r_tpu_pin pin_state;
-        enum r_tpu_timer timer_state;
-        unsigned long min_rate;
-        unsigned int refresh_rate;
-        struct work_struct work;
-        enum led_brightness new_brightness;
-};
-
-static DEFINE_SPINLOCK(r_tpu_lock);
-
-#define TSTR -1 /* Timer start register (shared register) */
-#define TCR  0 /* Timer control register (+0x00) */
-#define TMDR 1 /* Timer mode register (+0x04) */
-#define TIOR 2 /* Timer I/O control register (+0x08) */
-#define TIER 3 /* Timer interrupt enable register (+0x0c) */
-#define TSR  4 /* Timer status register (+0x10) */
-#define TCNT 5 /* Timer counter (+0x14) */
-#define TGRA 6 /* Timer general register A (+0x18) */
-#define TGRB 7 /* Timer general register B (+0x1c) */
-#define TGRC 8 /* Timer general register C (+0x20) */
-#define TGRD 9 /* Timer general register D (+0x24) */
-
-static inline unsigned short r_tpu_read(struct r_tpu_priv *p, int reg_nr)
-{
-        struct led_renesas_tpu_config *cfg = p->pdev->dev.platform_data;
-        void __iomem *base = p->mapbase;
-        unsigned long offs = reg_nr << 2;
-
-        if (reg_nr == TSTR)
-                return ioread16(base - cfg->channel_offset);
-
-        return ioread16(base + offs);
-}
-
-static inline void r_tpu_write(struct r_tpu_priv *p, int reg_nr,
-                               unsigned short value)
-{
-        struct led_renesas_tpu_config *cfg = p->pdev->dev.platform_data;
-        void __iomem *base = p->mapbase;
-        unsigned long offs = reg_nr << 2;
-
-        if (reg_nr == TSTR) {
-                iowrite16(value, base - cfg->channel_offset);
-                return;
-        }
-
-        iowrite16(value, base + offs);
-}
-
-static void r_tpu_start_stop_ch(struct r_tpu_priv *p, int start)
-{
-        struct led_renesas_tpu_config *cfg = p->pdev->dev.platform_data;
-        unsigned long flags, value;
-
-        /* start stop register shared by multiple timer channels */
-        spin_lock_irqsave(&r_tpu_lock, flags);
-        value = r_tpu_read(p, TSTR);
-
-        if (start)
-                value |= 1 << cfg->timer_bit;
-        else
-                value &= ~(1 << cfg->timer_bit);
-
-        r_tpu_write(p, TSTR, value);
-        spin_unlock_irqrestore(&r_tpu_lock, flags);
-}
-
-static int r_tpu_enable(struct r_tpu_priv *p, enum led_brightness brightness)
-{
-        struct led_renesas_tpu_config *cfg = p->pdev->dev.platform_data;
-        int prescaler[] = { 1, 4, 16, 64 };
-        int k, ret;
-        unsigned long rate, tmp;
-
-        if (p->timer_state == R_TPU_TIMER_ON)
-                return 0;
-
-        /* wake up device and enable clock */
-        pm_runtime_get_sync(&p->pdev->dev);
-        ret = clk_enable(p->clk);
-        if (ret) {
-                dev_err(&p->pdev->dev, "cannot enable clock\n");
-                return ret;
-        }
-
-        /* make sure channel is disabled */
-        r_tpu_start_stop_ch(p, 0);
-
-        /* get clock rate after enabling it */
-        rate = clk_get_rate(p->clk);
-
-        /* pick the lowest acceptable rate */
-        for (k = 0; k < ARRAY_SIZE(prescaler); k++)
-                if ((rate / prescaler[k]) < p->min_rate)
-                        break;
-
-        if (!k) {
-                dev_err(&p->pdev->dev, "clock rate mismatch\n");
-                goto err0;
-        }
-        dev_dbg(&p->pdev->dev, "rate = %lu, prescaler %u\n",
-                rate, prescaler[k - 1]);
-
-        /* clear TCNT on TGRB match, count on rising edge, set prescaler */
-        r_tpu_write(p, TCR, 0x0040 | (k - 1));
-
-        /* output 0 until TGRA, output 1 until TGRB */
-        r_tpu_write(p, TIOR, 0x0002);
-
-        rate /= prescaler[k - 1] * p->refresh_rate;
-        r_tpu_write(p, TGRB, rate);
-        dev_dbg(&p->pdev->dev, "TRGB = 0x%04lx\n", rate);
-
-        tmp = (cfg->max_brightness - brightness) * rate;
-        r_tpu_write(p, TGRA, tmp / cfg->max_brightness);
-        dev_dbg(&p->pdev->dev, "TRGA = 0x%04lx\n", tmp / cfg->max_brightness);
-
-        /* PWM mode */
-        r_tpu_write(p, TMDR, 0x0002);
-
-        /* enable channel */
-        r_tpu_start_stop_ch(p, 1);
-
-        p->timer_state = R_TPU_TIMER_ON;
-        return 0;
- err0:
-        clk_disable(p->clk);
-        pm_runtime_put_sync(&p->pdev->dev);
-        return -ENOTSUPP;
-}
-
-static void r_tpu_disable(struct r_tpu_priv *p)
-{
-        if (p->timer_state == R_TPU_TIMER_UNUSED)
-                return;
-
-        /* disable channel */
-        r_tpu_start_stop_ch(p, 0);
-
-        /* stop clock and mark device as idle */
-        clk_disable(p->clk);
-        pm_runtime_put_sync(&p->pdev->dev);
-
-        p->timer_state = R_TPU_TIMER_UNUSED;
-}
-
-static void r_tpu_set_pin(struct r_tpu_priv *p, enum r_tpu_pin new_state,
-                          enum led_brightness brightness)
-{
-        struct led_renesas_tpu_config *cfg = p->pdev->dev.platform_data;
-
-        if (p->pin_state == new_state) {
-                if (p->pin_state == R_TPU_PIN_GPIO)
-                        gpio_set_value(cfg->pin_gpio, brightness);
-                return;
-        }
-
-        if (p->pin_state == R_TPU_PIN_GPIO)
-                gpio_free(cfg->pin_gpio);
-
-        if (p->pin_state == R_TPU_PIN_GPIO_FN)
-                gpio_free(cfg->pin_gpio_fn);
-
-        if (new_state == R_TPU_PIN_GPIO)
-                gpio_request_one(cfg->pin_gpio, GPIOF_DIR_OUT | !!brightness,
-                                cfg->name);
-
-        if (new_state == R_TPU_PIN_GPIO_FN)
-                gpio_request(cfg->pin_gpio_fn, cfg->name);
-
-        p->pin_state = new_state;
-}
-
-static void r_tpu_work(struct work_struct *work)
-{
-        struct r_tpu_priv *p = container_of(work, struct r_tpu_priv, work);
-        enum led_brightness brightness = p->new_brightness;
-
-        r_tpu_disable(p);
-
-        /* off and maximum are handled as GPIO pins, in between PWM */
-        if ((brightness == 0) || (brightness == p->ldev.max_brightness))
-                r_tpu_set_pin(p, R_TPU_PIN_GPIO, brightness);
-        else {
-                r_tpu_set_pin(p, R_TPU_PIN_GPIO_FN, 0);
-                r_tpu_enable(p, brightness);
-        }
-}
-
-static void r_tpu_set_brightness(struct led_classdev *ldev,
-                                 enum led_brightness brightness)
-{
-        struct r_tpu_priv *p = container_of(ldev, struct r_tpu_priv, ldev);
-        p->new_brightness = brightness;
-        schedule_work(&p->work);
-}
-
-static int r_tpu_probe(struct platform_device *pdev)
-{
-        struct led_renesas_tpu_config *cfg = pdev->dev.platform_data;
-        struct r_tpu_priv *p;
-        struct resource *res;
-        int ret;
-
-        if (!cfg) {
-                dev_err(&pdev->dev, "missing platform data\n");
-                return -ENODEV;
-        }
-
-        p = devm_kzalloc(&pdev->dev, sizeof(*p), GFP_KERNEL);
-        if (p == NULL) {
-                dev_err(&pdev->dev, "failed to allocate driver data\n");
-                return -ENOMEM;
-        }
-
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!res) {
-                dev_err(&pdev->dev, "failed to get I/O memory\n");
-                return -ENXIO;
-        }
-
-        /* map memory, let mapbase point to our channel */
-        p->mapbase = devm_ioremap_nocache(&pdev->dev, res->start,
-                                        resource_size(res));
-        if (p->mapbase == NULL) {
-                dev_err(&pdev->dev, "failed to remap I/O memory\n");
-                return -ENXIO;
-        }
-
-        /* get hold of clock */
-        p->clk = devm_clk_get(&pdev->dev, NULL);
-        if (IS_ERR(p->clk)) {
-                dev_err(&pdev->dev, "cannot get clock\n");
-                return PTR_ERR(p->clk);
-        }
-
-        p->pdev = pdev;
-        p->pin_state = R_TPU_PIN_UNUSED;
-        p->timer_state = R_TPU_TIMER_UNUSED;
-        p->refresh_rate = cfg->refresh_rate ? cfg->refresh_rate : 100;
-        r_tpu_set_pin(p, R_TPU_PIN_GPIO, LED_OFF);
-        platform_set_drvdata(pdev, p);
-
-        INIT_WORK(&p->work, r_tpu_work);
-
-        p->ldev.name = cfg->name;
-        p->ldev.brightness = LED_OFF;
-        p->ldev.max_brightness = cfg->max_brightness;
-        p->ldev.brightness_set = r_tpu_set_brightness;
-        p->ldev.flags |= LED_CORE_SUSPENDRESUME;
-        ret = led_classdev_register(&pdev->dev, &p->ldev);
-        if (ret < 0)
-                goto err0;
-
-        /* max_brightness may be updated by the LED core code */
-        p->min_rate = p->ldev.max_brightness * p->refresh_rate;
-
-        pm_runtime_enable(&pdev->dev);
-        return 0;
-
- err0:
-        r_tpu_set_pin(p, R_TPU_PIN_UNUSED, LED_OFF);
-        return ret;
-}
-
-static int r_tpu_remove(struct platform_device *pdev)
-{
-        struct r_tpu_priv *p = platform_get_drvdata(pdev);
-
-        r_tpu_set_brightness(&p->ldev, LED_OFF);
-        led_classdev_unregister(&p->ldev);
-        cancel_work_sync(&p->work);
-        r_tpu_disable(p);
-        r_tpu_set_pin(p, R_TPU_PIN_UNUSED, LED_OFF);
-
-        pm_runtime_disable(&pdev->dev);
-
-        return 0;
-}
-
-static struct platform_driver r_tpu_device_driver = {
-        .probe          = r_tpu_probe,
-        .remove         = r_tpu_remove,
-        .driver         = {
-                .name   = "leds-renesas-tpu",
-        }
-};
-
-module_platform_driver(r_tpu_device_driver);
-
-MODULE_AUTHOR("Magnus Damm");
-MODULE_DESCRIPTION("Renesas TPU LED Driver");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/leds/leds-s3c24xx.c b/drivers/leds/leds-s3c24xx.c
index e1a0df63a37..a77771dc2e9 100644
--- a/drivers/leds/leds-s3c24xx.c
+++ b/drivers/leds/leds-s3c24xx.c
@@ -17,11 +17,10 @@
 #include <linux/leds.h>
 #include <linux/gpio.h>
 #include <linux/slab.h>
-#include <linux/module.h>
 
 #include <mach/hardware.h>
 #include <mach/regs-gpio.h>
-#include <linux/platform_data/leds-s3c24xx.h>
+#include <mach/leds-gpio.h>
 
 /* our context */
 
@@ -45,19 +44,17 @@ static void s3c24xx_led_set(struct led_classdev *led_cdev,
 {
         struct s3c24xx_gpio_led *led = to_gpio(led_cdev);
         struct s3c24xx_led_platdata *pd = led->pdata;
-        int state = (value ? 1 : 0) ^ (pd->flags & S3C24XX_LEDF_ACTLOW);
 
         /* there will be a short delay between setting the output and
          * going from output to input when using tristate. */
 
-        gpio_set_value(pd->gpio, state);
+        s3c2410_gpio_setpin(pd->gpio, (value ? 1 : 0) ^
+                            (pd->flags & S3C24XX_LEDF_ACTLOW));
+
+        if (pd->flags & S3C24XX_LEDF_TRISTATE)
+                s3c2410_gpio_cfgpin(pd->gpio,
+                        value ? S3C2410_GPIO_OUTPUT : S3C2410_GPIO_INPUT);
 
-        if (pd->flags & S3C24XX_LEDF_TRISTATE) {
-                if (value)
-                        gpio_direction_output(pd->gpio, state);
-                else
-                        gpio_direction_input(pd->gpio);
-        }
 }
 
 static int s3c24xx_led_remove(struct platform_device *dev)
@@ -65,6 +62,7 @@ static int s3c24xx_led_remove(struct platform_device *dev)
         struct s3c24xx_gpio_led *led = pdev_to_gpio(dev);
 
         led_classdev_unregister(&led->cdev);
+        kfree(led);
 
         return 0;
 }
@@ -75,8 +73,7 @@ static int s3c24xx_led_probe(struct platform_device *dev)
         struct s3c24xx_gpio_led *led;
         int ret;
 
-        led = devm_kzalloc(&dev->dev, sizeof(struct s3c24xx_gpio_led),
-                           GFP_KERNEL);
+        led = kzalloc(sizeof(struct s3c24xx_gpio_led), GFP_KERNEL);
         if (led == NULL) {
                 dev_err(&dev->dev, "No memory for device\n");
                 return -ENOMEM;
@@ -91,27 +88,27 @@ static int s3c24xx_led_probe(struct platform_device *dev)
 
         led->pdata = pdata;
 
-        ret = devm_gpio_request(&dev->dev, pdata->gpio, "S3C24XX_LED");
-        if (ret < 0)
-                return ret;
-
         /* no point in having a pull-up if we are always driving */
 
-        s3c_gpio_setpull(pdata->gpio, S3C_GPIO_PULL_NONE);
-
-        if (pdata->flags & S3C24XX_LEDF_TRISTATE)
-                gpio_direction_input(pdata->gpio);
-        else
-                gpio_direction_output(pdata->gpio,
-                        pdata->flags & S3C24XX_LEDF_ACTLOW ? 1 : 0);
+        if (pdata->flags & S3C24XX_LEDF_TRISTATE) {
+                s3c2410_gpio_setpin(pdata->gpio, 0);
+                s3c2410_gpio_cfgpin(pdata->gpio, S3C2410_GPIO_INPUT);
+        } else {
+                s3c2410_gpio_pullup(pdata->gpio, 0);
+                s3c2410_gpio_setpin(pdata->gpio, 0);
+                s3c2410_gpio_cfgpin(pdata->gpio, S3C2410_GPIO_OUTPUT);
+        }
 
         /* register our new led device */
 
         ret = led_classdev_register(&dev->dev, &led->cdev);
-        if (ret < 0)
+        if (ret < 0) {
                 dev_err(&dev->dev, "led_classdev_register failed\n");
+                kfree(led);
+                return ret;
+        }
 
-        return ret;
+        return 0;
 }
 
 static struct platform_driver s3c24xx_led_driver = {
@@ -123,7 +120,18 @@ static struct platform_driver s3c24xx_led_driver = {
         },
 };
 
-module_platform_driver(s3c24xx_led_driver);
+static int __init s3c24xx_led_init(void)
+{
+        return platform_driver_register(&s3c24xx_led_driver);
+}
+
+static void __exit s3c24xx_led_exit(void)
+{
+        platform_driver_unregister(&s3c24xx_led_driver);
+}
+
+module_init(s3c24xx_led_init);
+module_exit(s3c24xx_led_exit);
 
 MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
 MODULE_DESCRIPTION("S3C24XX LED driver");
diff --git a/drivers/leds/leds-ss4200.c b/drivers/leds/leds-ss4200.c
index ec9b287ecfb..614ebebaaa2 100644
--- a/drivers/leds/leds-ss4200.c
+++ b/drivers/leds/leds-ss4200.c
@@ -79,7 +79,7 @@ static int __init ss4200_led_dmi_callback(const struct dmi_system_id *id)
         return 1;
 }
 
-static bool __initdata nodetect;
+static unsigned int __initdata nodetect;
 module_param_named(nodetect, nodetect, bool, 0);
 MODULE_PARM_DESC(nodetect, "Skip DMI-based hardware detection");
 
@@ -263,7 +263,7 @@ static int nasgpio_led_set_blink(struct led_classdev *led_cdev,
  * already taken care of this, but we will do so in a non destructive manner
  * so that we have what we need whether the BIOS did it or not.
  */
-static int ich7_gpio_init(struct device *dev)
+static int __devinit ich7_gpio_init(struct device *dev)
 {
         int i;
         u32 config_data = 0;
@@ -342,7 +342,7 @@ static void ich7_lpc_cleanup(struct device *dev)
  * so we can retrive the required operational information and prepare the GPIO.
  */
 static struct pci_dev *nas_gpio_pci_dev;
-static int ich7_lpc_probe(struct pci_dev *dev,
+static int __devinit ich7_lpc_probe(struct pci_dev *dev,
                                     const struct pci_device_id *id)
 {
         int status;
@@ -459,7 +459,7 @@ static ssize_t nas_led_blink_store(struct device *dev,
         struct led_classdev *led = dev_get_drvdata(dev);
         unsigned long blink_state;
 
-        ret = kstrtoul(buf, 10, &blink_state);
+        ret = strict_strtoul(buf, 10, &blink_state);
         if (ret)
                 return ret;
 
diff --git a/drivers/leds/leds-sunfire.c b/drivers/leds/leds-sunfire.c
index 07ff5a3a6ce..1757396b20b 100644
--- a/drivers/leds/leds-sunfire.c
+++ b/drivers/leds/leds-sunfire.c
@@ -123,7 +123,7 @@ struct sunfire_drvdata {
         struct sunfire_led      leds[NUM_LEDS_PER_BOARD];
 };
 
-static int sunfire_led_generic_probe(struct platform_device *pdev,
+static int __devinit sunfire_led_generic_probe(struct platform_device *pdev,
                                                struct led_type *types)
 {
         struct sunfire_drvdata *p;
@@ -132,13 +132,15 @@ static int sunfire_led_generic_probe(struct platform_device *pdev,
         if (pdev->num_resources != 1) {
                 printk(KERN_ERR PFX "Wrong number of resources %d, should be 1\n",
                        pdev->num_resources);
-                return -EINVAL;
+                err = -EINVAL;
+                goto out;
         }
 
-        p = devm_kzalloc(&pdev->dev, sizeof(*p), GFP_KERNEL);
+        p = kzalloc(sizeof(*p), GFP_KERNEL);
         if (!p) {
                 printk(KERN_ERR PFX "Could not allocate struct sunfire_drvdata\n");
-                return -ENOMEM;
+                err = -ENOMEM;
+                goto out;
         }
 
         for (i = 0; i < NUM_LEDS_PER_BOARD; i++) {
@@ -154,18 +156,23 @@ static int sunfire_led_generic_probe(struct platform_device *pdev,
                 if (err) {
                         printk(KERN_ERR PFX "Could not register %s LED\n",
                                lp->name);
-                        for (i--; i >= 0; i--)
-                                led_classdev_unregister(&p->leds[i].led_cdev);
-                        return err;
+                        goto out_unregister_led_cdevs;
                 }
         }
 
         dev_set_drvdata(&pdev->dev, p);
 
         return 0;
+
+out_unregister_led_cdevs:
+        for (i--; i >= 0; i--)
+                led_classdev_unregister(&p->leds[i].led_cdev);
+        kfree(p);
+out:
+        return err;
 }
 
-static int sunfire_led_generic_remove(struct platform_device *pdev)
+static int __devexit sunfire_led_generic_remove(struct platform_device *pdev)
 {
         struct sunfire_drvdata *p = dev_get_drvdata(&pdev->dev);
         int i;
@@ -173,6 +180,8 @@ static int sunfire_led_generic_remove(struct platform_device *pdev)
         for (i = 0; i < NUM_LEDS_PER_BOARD; i++)
                 led_classdev_unregister(&p->leds[i].led_cdev);
 
+        kfree(p);
+
         return 0;
 }
 
@@ -192,7 +201,7 @@ static struct led_type clockboard_led_types[NUM_LEDS_PER_BOARD] = {
         },
 };
 
-static int sunfire_clockboard_led_probe(struct platform_device *pdev)
+static int __devinit sunfire_clockboard_led_probe(struct platform_device *pdev)
 {
         return sunfire_led_generic_probe(pdev, clockboard_led_types);
 }
@@ -213,7 +222,7 @@ static struct led_type fhc_led_types[NUM_LEDS_PER_BOARD] = {
         },
 };
 
-static int sunfire_fhc_led_probe(struct platform_device *pdev)
+static int __devinit sunfire_fhc_led_probe(struct platform_device *pdev)
 {
         return sunfire_led_generic_probe(pdev, fhc_led_types);
 }
@@ -223,7 +232,7 @@ MODULE_ALIAS("platform:sunfire-fhc-leds");
 
 static struct platform_driver sunfire_clockboard_led_driver = {
         .probe          = sunfire_clockboard_led_probe,
-        .remove         = sunfire_led_generic_remove,
+        .remove         = __devexit_p(sunfire_led_generic_remove),
         .driver         = {
                 .name   = "sunfire-clockboard-leds",
                 .owner  = THIS_MODULE,
@@ -232,7 +241,7 @@ static struct platform_driver sunfire_clockboard_led_driver = {
 
 static struct platform_driver sunfire_fhc_led_driver = {
         .probe          = sunfire_fhc_led_probe,
-        .remove         = sunfire_led_generic_remove,
+        .remove         = __devexit_p(sunfire_led_generic_remove),
         .driver         = {
                 .name   = "sunfire-fhc-leds",
                 .owner  = THIS_MODULE,
diff --git a/drivers/leds/leds-tca6507.c b/drivers/leds/leds-tca6507.c
deleted file mode 100644
index b26a63bae16..00000000000
--- a/drivers/leds/leds-tca6507.c
+++ /dev/null
@@ -1,763 +0,0 @@
-/*
- * leds-tca6507
- *
- * The TCA6507 is a programmable LED controller that can drive 7
- * separate lines either by holding them low, or by pulsing them
- * with modulated width.
- * The modulation can be varied in a simple pattern to produce a blink or
- * double-blink.
- *
- * This driver can configure each line either as a 'GPIO' which is out-only
- * (no pull-up) or as an LED with variable brightness and hardware-assisted
- * blinking.
- *
- * Apart from OFF and ON there are three programmable brightness levels which
- * can be programmed from 0 to 15 and indicate how many 500usec intervals in
- * each 8msec that the led is 'on'.  The levels are named MASTER, BANK0 and
- * BANK1.
- *
- * There are two different blink rates that can be programmed, each with
- * separate time for rise, on, fall, off and second-off.  Thus if 3 or more
- * different non-trivial rates are required, software must be used for the extra
- * rates. The two different blink rates must align with the two levels BANK0 and
- * BANK1.
- * This driver does not support double-blink so 'second-off' always matches
- * 'off'.
- *
- * Only 16 different times can be programmed in a roughly logarithmic scale from
- * 64ms to 16320ms.  To be precise the possible times are:
- *    0, 64, 128, 192, 256, 384, 512, 768,
- *    1024, 1536, 2048, 3072, 4096, 5760, 8128, 16320
- *
- * Times that cannot be closely matched with these must be
- * handled in software.  This driver allows 12.5% error in matching.
- *
- * This driver does not allow rise/fall rates to be set explicitly.  When trying
- * to match a given 'on' or 'off' period, an appropriate pair of 'change' and
- * 'hold' times are chosen to get a close match.  If the target delay is even,
- * the 'change' number will be the smaller; if odd, the 'hold' number will be
- * the smaller.
-
- * Choosing pairs of delays with 12.5% errors allows us to match delays in the
- * ranges: 56-72, 112-144, 168-216, 224-27504, 28560-36720.
- * 26% of the achievable sums can be matched by multiple pairings. For example
- * 1536 == 1536+0, 1024+512, or 768+768.  This driver will always choose the
- * pairing with the least maximum - 768+768 in this case.  Other pairings are
- * not available.
- *
- * Access to the 3 levels and 2 blinks are on a first-come, first-served basis.
- * Access can be shared by multiple leds if they have the same level and
- * either same blink rates, or some don't blink.
- * When a led changes, it relinquishes access and tries again, so it might
- * lose access to hardware blink.
- * If a blink engine cannot be allocated, software blink is used.
- * If the desired brightness cannot be allocated, the closest available non-zero
- * brightness is used.  As 'full' is always available, the worst case would be
- * to have two different blink rates at '1', with Max at '2', then other leds
- * will have to choose between '2' and '16'.  Hopefully this is not likely.
- *
- * Each bank (BANK0 and BANK1) has two usage counts - LEDs using the brightness
- * and LEDs using the blink.  It can only be reprogrammed when the appropriate
- * counter is zero.  The MASTER level has a single usage count.
- *
- * Each Led has programmable 'on' and 'off' time as milliseconds.  With each
- * there is a flag saying if it was explicitly requested or defaulted.
- * Similarly the banks know if each time was explicit or a default.  Defaults
- * are permitted to be changed freely - they are not recognised when matching.
- *
- *
- * An led-tca6507 device must be provided with platform data.  This data
- * lists for each output: the name, default trigger, and whether the signal
- * is being used as a GPiO rather than an led.  'struct led_plaform_data'
- * is used for this.  If 'name' is NULL, the output isn't used.  If 'flags'
- * is TCA6507_MAKE_CPIO, the output is a GPO.
- * The "struct led_platform_data" can be embedded in a
- * "struct tca6507_platform_data" which adds a 'gpio_base' for the GPiOs,
- * and a 'setup' callback which is called once the GPiOs are available.
- *
- */
-
-#include <linux/module.h>
-#include <linux/slab.h>
-#include <linux/leds.h>
-#include <linux/err.h>
-#include <linux/i2c.h>
-#include <linux/gpio.h>
-#include <linux/workqueue.h>
-#include <linux/leds-tca6507.h>
-
-/* LED select registers determine the source that drives LED outputs */
-#define TCA6507_LS_LED_OFF      0x0     /* Output HI-Z (off) */
-#define TCA6507_LS_LED_OFF1     0x1     /* Output HI-Z (off) - not used */
-#define TCA6507_LS_LED_PWM0     0x2     /* Output LOW with Bank0 rate */
-#define TCA6507_LS_LED_PWM1     0x3     /* Output LOW with Bank1 rate */
-#define TCA6507_LS_LED_ON       0x4     /* Output LOW (on) */
-#define TCA6507_LS_LED_MIR      0x5     /* Output LOW with Master Intensity */
-#define TCA6507_LS_BLINK0       0x6     /* Blink at Bank0 rate */
-#define TCA6507_LS_BLINK1       0x7     /* Blink at Bank1 rate */
-
-enum {
-        BANK0,
-        BANK1,
-        MASTER,
-};
-static int bank_source[3] = {
-        TCA6507_LS_LED_PWM0,
-        TCA6507_LS_LED_PWM1,
-        TCA6507_LS_LED_MIR,
-};
-static int blink_source[2] = {
-        TCA6507_LS_BLINK0,
-        TCA6507_LS_BLINK1,
-};
-
-/* PWM registers */
-#define TCA6507_REG_CNT                 11
-
-/*
- * 0x00, 0x01, 0x02 encode the TCA6507_LS_* values, each output
- * owns one bit in each register
- */
-#define TCA6507_FADE_ON                 0x03
-#define TCA6507_FULL_ON                 0x04
-#define TCA6507_FADE_OFF                0x05
-#define TCA6507_FIRST_OFF               0x06
-#define TCA6507_SECOND_OFF              0x07
-#define TCA6507_MAX_INTENSITY           0x08
-#define TCA6507_MASTER_INTENSITY        0x09
-#define TCA6507_INITIALIZE              0x0A
-
-#define INIT_CODE                       0x8
-
-#define TIMECODES 16
-static int time_codes[TIMECODES] = {
-        0, 64, 128, 192, 256, 384, 512, 768,
-        1024, 1536, 2048, 3072, 4096, 5760, 8128, 16320
-};
-
-/* Convert an led.brightness level (0..255) to a TCA6507 level (0..15) */
-static inline int TO_LEVEL(int brightness)
-{
-        return brightness >> 4;
-}
-
-/* ...and convert back */
-static inline int TO_BRIGHT(int level)
-{
-        if (level)
-                return (level << 4) | 0xf;
-        return 0;
-}
-
-#define NUM_LEDS 7
-struct tca6507_chip {
-        int                     reg_set;        /* One bit per register where
-                                                 * a '1' means the register
-                                                 * should be written */
-        u8                      reg_file[TCA6507_REG_CNT];
-        /* Bank 2 is Master Intensity and doesn't use times */
-        struct bank {
-                int level;
-                int ontime, offtime;
-                int on_dflt, off_dflt;
-                int time_use, level_use;
-        } bank[3];
-        struct i2c_client       *client;
-        struct work_struct      work;
-        spinlock_t              lock;
-
-        struct tca6507_led {
-                struct tca6507_chip     *chip;
-                struct led_classdev     led_cdev;
-                int                     num;
-                int                     ontime, offtime;
-                int                     on_dflt, off_dflt;
-                int                     bank;   /* Bank used, or -1 */
-                int                     blink;  /* Set if hardware-blinking */
-        } leds[NUM_LEDS];
-#ifdef CONFIG_GPIOLIB
-        struct gpio_chip                gpio;
-        const char                      *gpio_name[NUM_LEDS];
-        int                             gpio_map[NUM_LEDS];
-#endif
-};
-
-static const struct i2c_device_id tca6507_id[] = {
-        { "tca6507" },
-        { }
-};
-MODULE_DEVICE_TABLE(i2c, tca6507_id);
-
-static int choose_times(int msec, int *c1p, int *c2p)
-{
-        /*
-         * Choose two timecodes which add to 'msec' as near as possible.
-         * The first returned is the 'on' or 'off' time.  The second is to be
-         * used as a 'fade-on' or 'fade-off' time.  If 'msec' is even,
-         * the first will not be smaller than the second.  If 'msec' is odd,
-         * the first will not be larger than the second.
-         * If we cannot get a sum within 1/8 of 'msec' fail with -EINVAL,
-         * otherwise return the sum that was achieved, plus 1 if the first is
-         * smaller.
-         * If two possibilities are equally good (e.g. 512+0, 256+256), choose
-         * the first pair so there is more change-time visible (i.e. it is
-         * softer).
-         */
-        int c1, c2;
-        int tmax = msec * 9 / 8;
-        int tmin = msec * 7 / 8;
-        int diff = 65536;
-
-        /* We start at '1' to ensure we never even think of choosing a
-         * total time of '0'.
-         */
-        for (c1 = 1; c1 < TIMECODES; c1++) {
-                int t = time_codes[c1];
-                if (t*2 < tmin)
-                        continue;
-                if (t > tmax)
-                        break;
-                for (c2 = 0; c2 <= c1; c2++) {
-                        int tt = t + time_codes[c2];
-                        int d;
-                        if (tt < tmin)
-                                continue;
-                        if (tt > tmax)
-                                break;
-                        /* This works! */
-                        d = abs(msec - tt);
-                        if (d >= diff)
-                                continue;
-                        /* Best yet */
-                        *c1p = c1;
-                        *c2p = c2;
-                        diff = d;
-                        if (d == 0)
-                                return msec;
-                }
-        }
-        if (diff < 65536) {
-                int actual;
-                if (msec & 1) {
-                        c1 = *c2p;
-                        *c2p = *c1p;
-                        *c1p = c1;
-                }
-                actual = time_codes[*c1p] + time_codes[*c2p];
-                if (*c1p < *c2p)
-                        return actual + 1;
-                else
-                        return actual;
-        }
-        /* No close match */
-        return -EINVAL;
-}
-
-/*
- * Update the register file with the appropriate 3-bit state for
- * the given led.
- */
-static void set_select(struct tca6507_chip *tca, int led, int val)
-{
-        int mask = (1 << led);
-        int bit;
-
-        for (bit = 0; bit < 3; bit++) {
-                int n = tca->reg_file[bit] & ~mask;
-                if (val & (1 << bit))
-                        n |= mask;
-                if (tca->reg_file[bit] != n) {
-                        tca->reg_file[bit] = n;
-                        tca->reg_set |= (1 << bit);
-                }
-        }
-}
-
-/* Update the register file with the appropriate 4-bit code for
- * one bank or other.  This can be used for timers, for levels, or
- * for initialisation.
- */
-static void set_code(struct tca6507_chip *tca, int reg, int bank, int new)
-{
-        int mask = 0xF;
-        int n;
-        if (bank) {
-                mask <<= 4;
-                new <<= 4;
-        }
-        n = tca->reg_file[reg] & ~mask;
-        n |= new;
-        if (tca->reg_file[reg] != n) {
-                tca->reg_file[reg] = n;
-                tca->reg_set |= 1 << reg;
-        }
-}
-
-/* Update brightness level. */
-static void set_level(struct tca6507_chip *tca, int bank, int level)
-{
-        switch (bank) {
-        case BANK0:
-        case BANK1:
-                set_code(tca, TCA6507_MAX_INTENSITY, bank, level);
-                break;
-        case MASTER:
-                set_code(tca, TCA6507_MASTER_INTENSITY, 0, level);
-                break;
-        }
-        tca->bank[bank].level = level;
-}
-
-/* Record all relevant time code for a given bank */
-static void set_times(struct tca6507_chip *tca, int bank)
-{
-        int c1, c2;
-        int result;
-
-        result = choose_times(tca->bank[bank].ontime, &c1, &c2);
-        dev_dbg(&tca->client->dev,
-                "Chose on  times %d(%d) %d(%d) for %dms\n", c1, time_codes[c1],
-                c2, time_codes[c2], tca->bank[bank].ontime);
-        set_code(tca, TCA6507_FADE_ON, bank, c2);
-        set_code(tca, TCA6507_FULL_ON, bank, c1);
-        tca->bank[bank].ontime = result;
-
-        result = choose_times(tca->bank[bank].offtime, &c1, &c2);
-        dev_dbg(&tca->client->dev,
-                "Chose off times %d(%d) %d(%d) for %dms\n", c1, time_codes[c1],
-                c2, time_codes[c2], tca->bank[bank].offtime);
-        set_code(tca, TCA6507_FADE_OFF, bank, c2);
-        set_code(tca, TCA6507_FIRST_OFF, bank, c1);
-        set_code(tca, TCA6507_SECOND_OFF, bank, c1);
-        tca->bank[bank].offtime = result;
-
-        set_code(tca, TCA6507_INITIALIZE, bank, INIT_CODE);
-}
-
-/* Write all needed register of tca6507 */
-
-static void tca6507_work(struct work_struct *work)
-{
-        struct tca6507_chip *tca = container_of(work, struct tca6507_chip,
-                                                work);
-        struct i2c_client *cl = tca->client;
-        int set;
-        u8 file[TCA6507_REG_CNT];
-        int r;
-
-        spin_lock_irq(&tca->lock);
-        set = tca->reg_set;
-        memcpy(file, tca->reg_file, TCA6507_REG_CNT);
-        tca->reg_set = 0;
-        spin_unlock_irq(&tca->lock);
-
-        for (r = 0; r < TCA6507_REG_CNT; r++)
-                if (set & (1<<r))
-                        i2c_smbus_write_byte_data(cl, r, file[r]);
-}
-
-static void led_release(struct tca6507_led *led)
-{
-        /* If led owns any resource, release it. */
-        struct tca6507_chip *tca = led->chip;
-        if (led->bank >= 0) {
-                struct bank *b = tca->bank + led->bank;
-                if (led->blink)
-                        b->time_use--;
-                b->level_use--;
-        }
-        led->blink = 0;
-        led->bank = -1;
-}
-
-static int led_prepare(struct tca6507_led *led)
-{
-        /* Assign this led to a bank, configuring that bank if necessary. */
-        int level = TO_LEVEL(led->led_cdev.brightness);
-        struct tca6507_chip *tca = led->chip;
-        int c1, c2;
-        int i;
-        struct bank *b;
-        int need_init = 0;
-
-        led->led_cdev.brightness = TO_BRIGHT(level);
-        if (level == 0) {
-                set_select(tca, led->num, TCA6507_LS_LED_OFF);
-                return 0;
-        }
-
-        if (led->ontime == 0 || led->offtime == 0) {
-                /*
-                 * Just set the brightness, choosing first usable bank.
-                 * If none perfect, choose best.
-                 * Count backwards so we check MASTER bank first
-                 * to avoid wasting a timer.
-                 */
-                int best = -1;/* full-on */
-                int diff = 15-level;
-
-                if (level == 15) {
-                        set_select(tca, led->num, TCA6507_LS_LED_ON);
-                        return 0;
-                }
-
-                for (i = MASTER; i >= BANK0; i--) {
-                        int d;
-                        if (tca->bank[i].level == level ||
-                            tca->bank[i].level_use == 0) {
-                                best = i;
-                                break;
-                        }
-                        d = abs(level - tca->bank[i].level);
-                        if (d < diff) {
-                                diff = d;
-                                best = i;
-                        }
-                }
-                if (best == -1) {
-                        /* Best brightness is full-on */
-                        set_select(tca, led->num, TCA6507_LS_LED_ON);
-                        led->led_cdev.brightness = LED_FULL;
-                        return 0;
-                }
-
-                if (!tca->bank[best].level_use)
-                        set_level(tca, best, level);
-
-                tca->bank[best].level_use++;
-                led->bank = best;
-                set_select(tca, led->num, bank_source[best]);
-                led->led_cdev.brightness = TO_BRIGHT(tca->bank[best].level);
-                return 0;
-        }
-
-        /*
-         * We have on/off time so we need to try to allocate a timing bank.
-         * First check if times are compatible with hardware and give up if
-         * not.
-         */
-        if (choose_times(led->ontime, &c1, &c2) < 0)
-                return -EINVAL;
-        if (choose_times(led->offtime, &c1, &c2) < 0)
-                return -EINVAL;
-
-        for (i = BANK0; i <= BANK1; i++) {
-                if (tca->bank[i].level_use == 0)
-                        /* not in use - it is ours! */
-                        break;
-                if (tca->bank[i].level != level)
-                        /* Incompatible level - skip */
-                        /* FIX: if timer matches we maybe should consider
-                         * this anyway...
-                         */
-                        continue;
-
-                if (tca->bank[i].time_use == 0)
-                        /* Timer not in use, and level matches - use it */
-                        break;
-
-                if (!(tca->bank[i].on_dflt ||
-                      led->on_dflt ||
-                      tca->bank[i].ontime == led->ontime))
-                        /* on time is incompatible */
-                        continue;
-
-                if (!(tca->bank[i].off_dflt ||
-                      led->off_dflt ||
-                      tca->bank[i].offtime == led->offtime))
-                        /* off time is incompatible */
-                        continue;
-
-                /* looks like a suitable match */
-                break;
-        }
-
-        if (i > BANK1)
-                /* Nothing matches - how sad */
-                return -EINVAL;
-
-        b = &tca->bank[i];
-        if (b->level_use == 0)
-                set_level(tca, i, level);
-        b->level_use++;
-        led->bank = i;
-
-        if (b->on_dflt ||
-            !led->on_dflt ||
-            b->time_use == 0) {
-                b->ontime = led->ontime;
-                b->on_dflt = led->on_dflt;
-                need_init = 1;
-        }
-
-        if (b->off_dflt ||
-            !led->off_dflt ||
-            b->time_use == 0) {
-                b->offtime = led->offtime;
-                b->off_dflt = led->off_dflt;
-                need_init = 1;
-        }
-
-        if (need_init)
-                set_times(tca, i);
-
-        led->ontime = b->ontime;
-        led->offtime = b->offtime;
-
-        b->time_use++;
-        led->blink = 1;
-        led->led_cdev.brightness = TO_BRIGHT(b->level);
-        set_select(tca, led->num, blink_source[i]);
-        return 0;
-}
-
-static int led_assign(struct tca6507_led *led)
-{
-        struct tca6507_chip *tca = led->chip;
-        int err;
-        unsigned long flags;
-
-        spin_lock_irqsave(&tca->lock, flags);
-        led_release(led);
-        err = led_prepare(led);
-        if (err) {
-                /*
-                 * Can only fail on timer setup.  In that case we need to
-                 * re-establish as steady level.
-                 */
-                led->ontime = 0;
-                led->offtime = 0;
-                led_prepare(led);
-        }
-        spin_unlock_irqrestore(&tca->lock, flags);
-
-        if (tca->reg_set)
-                schedule_work(&tca->work);
-        return err;
-}
-
-static void tca6507_brightness_set(struct led_classdev *led_cdev,
-                                   enum led_brightness brightness)
-{
-        struct tca6507_led *led = container_of(led_cdev, struct tca6507_led,
-                                               led_cdev);
-        led->led_cdev.brightness = brightness;
-        led->ontime = 0;
-        led->offtime = 0;
-        led_assign(led);
-}
-
-static int tca6507_blink_set(struct led_classdev *led_cdev,
-                             unsigned long *delay_on,
-                             unsigned long *delay_off)
-{
-        struct tca6507_led *led = container_of(led_cdev, struct tca6507_led,
-                                               led_cdev);
-
-        if (*delay_on == 0)
-                led->on_dflt = 1;
-        else if (delay_on != &led_cdev->blink_delay_on)
-                led->on_dflt = 0;
-        led->ontime = *delay_on;
-
-        if (*delay_off == 0)
-                led->off_dflt = 1;
-        else if (delay_off != &led_cdev->blink_delay_off)
-                led->off_dflt = 0;
-        led->offtime = *delay_off;
-
-        if (led->ontime == 0)
-                led->ontime = 512;
-        if (led->offtime == 0)
-                led->offtime = 512;
-
-        if (led->led_cdev.brightness == LED_OFF)
-                led->led_cdev.brightness = LED_FULL;
-        if (led_assign(led) < 0) {
-                led->ontime = 0;
-                led->offtime = 0;
-                led->led_cdev.brightness = LED_OFF;
-                return -EINVAL;
-        }
-        *delay_on = led->ontime;
-        *delay_off = led->offtime;
-        return 0;
-}
-
-#ifdef CONFIG_GPIOLIB
-static void tca6507_gpio_set_value(struct gpio_chip *gc,
-                                   unsigned offset, int val)
-{
-        struct tca6507_chip *tca = container_of(gc, struct tca6507_chip, gpio);
-        unsigned long flags;
-
-        spin_lock_irqsave(&tca->lock, flags);
-        /*
-         * 'OFF' is floating high, and 'ON' is pulled down, so it has the
-         * inverse sense of 'val'.
-         */
-        set_select(tca, tca->gpio_map[offset],
-                   val ? TCA6507_LS_LED_OFF : TCA6507_LS_LED_ON);
-        spin_unlock_irqrestore(&tca->lock, flags);
-        if (tca->reg_set)
-                schedule_work(&tca->work);
-}
-
-static int tca6507_gpio_direction_output(struct gpio_chip *gc,
-                                          unsigned offset, int val)
-{
-        tca6507_gpio_set_value(gc, offset, val);
-        return 0;
-}
-
-static int tca6507_probe_gpios(struct i2c_client *client,
-                               struct tca6507_chip *tca,
-                               struct tca6507_platform_data *pdata)
-{
-        int err;
-        int i = 0;
-        int gpios = 0;
-
-        for (i = 0; i < NUM_LEDS; i++)
-                if (pdata->leds.leds[i].name && pdata->leds.leds[i].flags) {
-                        /* Configure as a gpio */
-                        tca->gpio_name[gpios] = pdata->leds.leds[i].name;
-                        tca->gpio_map[gpios] = i;
-                        gpios++;
-                }
-
-        if (!gpios)
-                return 0;
-
-        tca->gpio.label = "gpio-tca6507";
-        tca->gpio.names = tca->gpio_name;
-        tca->gpio.ngpio = gpios;
-        tca->gpio.base = pdata->gpio_base;
-        tca->gpio.owner = THIS_MODULE;
-        tca->gpio.direction_output = tca6507_gpio_direction_output;
-        tca->gpio.set = tca6507_gpio_set_value;
-        tca->gpio.dev = &client->dev;
-        err = gpiochip_add(&tca->gpio);
-        if (err) {
-                tca->gpio.ngpio = 0;
-                return err;
-        }
-        if (pdata->setup)
-                pdata->setup(tca->gpio.base, tca->gpio.ngpio);
-        return 0;
-}
-
-static void tca6507_remove_gpio(struct tca6507_chip *tca)
-{
-        if (tca->gpio.ngpio) {
-                int err = gpiochip_remove(&tca->gpio);
-                dev_err(&tca->client->dev, "%s failed, %d\n",
-                        "gpiochip_remove()", err);
-        }
-}
-#else /* CONFIG_GPIOLIB */
-static int tca6507_probe_gpios(struct i2c_client *client,
-                               struct tca6507_chip *tca,
-                               struct tca6507_platform_data *pdata)
-{
-        return 0;
-}
-static void tca6507_remove_gpio(struct tca6507_chip *tca)
-{
-}
-#endif /* CONFIG_GPIOLIB */
-
-static int tca6507_probe(struct i2c_client *client,
-                                   const struct i2c_device_id *id)
-{
-        struct tca6507_chip *tca;
-        struct i2c_adapter *adapter;
-        struct tca6507_platform_data *pdata;
-        int err;
-        int i = 0;
-
-        adapter = to_i2c_adapter(client->dev.parent);
-        pdata = client->dev.platform_data;
-
-        if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))
-                return -EIO;
-
-        if (!pdata || pdata->leds.num_leds != NUM_LEDS) {
-                dev_err(&client->dev, "Need %d entries in platform-data list\n",
-                        NUM_LEDS);
-                return -ENODEV;
-        }
-        tca = devm_kzalloc(&client->dev, sizeof(*tca), GFP_KERNEL);
-        if (!tca)
-                return -ENOMEM;
-
-        tca->client = client;
-        INIT_WORK(&tca->work, tca6507_work);
-        spin_lock_init(&tca->lock);
-        i2c_set_clientdata(client, tca);
-
-        for (i = 0; i < NUM_LEDS; i++) {
-                struct tca6507_led *l = tca->leds + i;
-
-                l->chip = tca;
-                l->num = i;
-                if (pdata->leds.leds[i].name && !pdata->leds.leds[i].flags) {
-                        l->led_cdev.name = pdata->leds.leds[i].name;
-                        l->led_cdev.default_trigger
-                                = pdata->leds.leds[i].default_trigger;
-                        l->led_cdev.brightness_set = tca6507_brightness_set;
-                        l->led_cdev.blink_set = tca6507_blink_set;
-                        l->bank = -1;
-                        err = led_classdev_register(&client->dev,
-                                                    &l->led_cdev);
-                        if (err < 0)
-                                goto exit;
-                }
-        }
-        err = tca6507_probe_gpios(client, tca, pdata);
-        if (err)
-                goto exit;
-        /* set all registers to known state - zero */
-        tca->reg_set = 0x7f;
-        schedule_work(&tca->work);
-
-        return 0;
-exit:
-        while (i--) {
-                if (tca->leds[i].led_cdev.name)
-                        led_classdev_unregister(&tca->leds[i].led_cdev);
-        }
-        return err;
-}
-
-static int tca6507_remove(struct i2c_client *client)
-{
-        int i;
-        struct tca6507_chip *tca = i2c_get_clientdata(client);
-        struct tca6507_led *tca_leds = tca->leds;
-
-        for (i = 0; i < NUM_LEDS; i++) {
-                if (tca_leds[i].led_cdev.name)
-                        led_classdev_unregister(&tca_leds[i].led_cdev);
-        }
-        tca6507_remove_gpio(tca);
-        cancel_work_sync(&tca->work);
-
-        return 0;
-}
-
-static struct i2c_driver tca6507_driver = {
-        .driver   = {
-                .name    = "leds-tca6507",
-                .owner   = THIS_MODULE,
-        },
-        .probe    = tca6507_probe,
-        .remove   = tca6507_remove,
-        .id_table = tca6507_id,
-};
-
-module_i2c_driver(tca6507_driver);
-
-MODULE_AUTHOR("NeilBrown <neilb@suse.de>");
-MODULE_DESCRIPTION("TCA6507 LED/GPO driver");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/leds/leds-wm831x-status.c b/drivers/leds/leds-wm831x-status.c
index 74a24cf897c..ef5c24140a4 100644
--- a/drivers/leds/leds-wm831x-status.c
+++ b/drivers/leds/leds-wm831x-status.c
@@ -18,7 +18,6 @@
 #include <linux/mfd/wm831x/core.h>
 #include <linux/mfd/wm831x/pdata.h>
 #include <linux/mfd/wm831x/status.h>
-#include <linux/module.h>
 
 
 struct wm831x_status {
@@ -237,8 +236,7 @@ static int wm831x_status_probe(struct platform_device *pdev)
                 goto err;
         }
 
-        drvdata = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_status),
-                               GFP_KERNEL);
+        drvdata = kzalloc(sizeof(struct wm831x_status), GFP_KERNEL);
         if (!drvdata)
                 return -ENOMEM;
         dev_set_drvdata(&pdev->dev, drvdata);
@@ -301,6 +299,7 @@ static int wm831x_status_probe(struct platform_device *pdev)
 
 err_led:
         led_classdev_unregister(&drvdata->cdev);
+        kfree(drvdata);
 err:
         return ret;
 }
@@ -311,6 +310,7 @@ static int wm831x_status_remove(struct platform_device *pdev)
 
         device_remove_file(drvdata->cdev.dev, &dev_attr_src);
         led_classdev_unregister(&drvdata->cdev);
+        kfree(drvdata);
 
         return 0;
 }
@@ -324,7 +324,17 @@ static struct platform_driver wm831x_status_driver = {
         .remove = wm831x_status_remove,
 };
 
-module_platform_driver(wm831x_status_driver);
+static int __devinit wm831x_status_init(void)
+{
+        return platform_driver_register(&wm831x_status_driver);
+}
+module_init(wm831x_status_init);
+
+static void wm831x_status_exit(void)
+{
+        platform_driver_unregister(&wm831x_status_driver);
+}
+module_exit(wm831x_status_exit);
 
 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
 MODULE_DESCRIPTION("WM831x status LED driver");
diff --git a/drivers/leds/leds-wm8350.c b/drivers/leds/leds-wm8350.c
index ed15157c8f6..f14edd82cb0 100644
--- a/drivers/leds/leds-wm8350.c
+++ b/drivers/leds/leds-wm8350.c
@@ -17,7 +17,6 @@
 #include <linux/mfd/wm8350/pmic.h>
 #include <linux/regulator/consumer.h>
 #include <linux/slab.h>
-#include <linux/module.h>
 
 /* Microamps */
 static const int isink_cur[] = {
@@ -201,7 +200,7 @@ static int wm8350_led_probe(struct platform_device *pdev)
         struct regulator *isink, *dcdc;
         struct wm8350_led *led;
         struct wm8350_led_platform_data *pdata = pdev->dev.platform_data;
-        int i;
+        int ret, i;
 
         if (pdata == NULL) {
                 dev_err(&pdev->dev, "no platform data\n");
@@ -214,21 +213,24 @@ static int wm8350_led_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
 
-        isink = devm_regulator_get(&pdev->dev, "led_isink");
+        isink = regulator_get(&pdev->dev, "led_isink");
         if (IS_ERR(isink)) {
-                dev_err(&pdev->dev, "%s: can't get ISINK\n", __func__);
+                printk(KERN_ERR "%s: can't get ISINK\n", __func__);
                 return PTR_ERR(isink);
         }
 
-        dcdc = devm_regulator_get(&pdev->dev, "led_vcc");
+        dcdc = regulator_get(&pdev->dev, "led_vcc");
         if (IS_ERR(dcdc)) {
-                dev_err(&pdev->dev, "%s: can't get DCDC\n", __func__);
-                return PTR_ERR(dcdc);
+                printk(KERN_ERR "%s: can't get DCDC\n", __func__);
+                ret = PTR_ERR(dcdc);
+                goto err_isink;
         }
 
-        led = devm_kzalloc(&pdev->dev, sizeof(*led), GFP_KERNEL);
-        if (led == NULL)
-                return -ENOMEM;
+        led = kzalloc(sizeof(*led), GFP_KERNEL);
+        if (led == NULL) {
+                ret = -ENOMEM;
+                goto err_dcdc;
+        }
 
         led->cdev.brightness_set = wm8350_led_set;
         led->cdev.default_trigger = pdata->default_trigger;
@@ -254,7 +256,19 @@ static int wm8350_led_probe(struct platform_device *pdev)
         led->value = LED_OFF;
         platform_set_drvdata(pdev, led);
 
-        return led_classdev_register(&pdev->dev, &led->cdev);
+        ret = led_classdev_register(&pdev->dev, &led->cdev);
+        if (ret < 0)
+                goto err_led;
+
+        return 0;
+
+ err_led:
+        kfree(led);
+ err_dcdc:
+        regulator_put(dcdc);
+ err_isink:
+        regulator_put(isink);
+        return ret;
 }
 
 static int wm8350_led_remove(struct platform_device *pdev)
@@ -262,8 +276,11 @@ static int wm8350_led_remove(struct platform_device *pdev)
         struct wm8350_led *led = platform_get_drvdata(pdev);
 
         led_classdev_unregister(&led->cdev);
-        flush_work(&led->work);
+        flush_work_sync(&led->work);
         wm8350_led_disable(led);
+        regulator_put(led->dcdc);
+        regulator_put(led->isink);
+        kfree(led);
         return 0;
 }
 
@@ -277,7 +294,17 @@ static struct platform_driver wm8350_led_driver = {
         .shutdown = wm8350_led_shutdown,
 };
 
-module_platform_driver(wm8350_led_driver);
+static int __devinit wm8350_led_init(void)
+{
+        return platform_driver_register(&wm8350_led_driver);
+}
+module_init(wm8350_led_init);
+
+static void wm8350_led_exit(void)
+{
+        platform_driver_unregister(&wm8350_led_driver);
+}
+module_exit(wm8350_led_exit);
 
 MODULE_AUTHOR("Mark Brown");
 MODULE_DESCRIPTION("WM8350 LED driver");
diff --git a/drivers/leds/leds-wrap.c b/drivers/leds/leds-wrap.c
index b358cc05eff..2982c86ac4c 100644
--- a/drivers/leds/leds-wrap.c
+++ b/drivers/leds/leds-wrap.c
@@ -15,9 +15,8 @@
 #include <linux/platform_device.h>
 #include <linux/leds.h>
 #include <linux/err.h>
-#include <linux/io.h>
+#include <asm/io.h>
 #include <linux/scx200_gpio.h>
-#include <linux/module.h>
 
 #define DRVNAME "wrap-led"
 #define WRAP_POWER_LED_GPIO     2
diff --git a/drivers/leds/leds.h b/drivers/leds/leds.h
index 4c50365344a..e77c7f8dcdd 100644
--- a/drivers/leds/leds.h
+++ b/drivers/leds/leds.h
@@ -17,7 +17,7 @@
 #include <linux/rwsem.h>
 #include <linux/leds.h>
 
-static inline void __led_set_brightness(struct led_classdev *led_cdev,
+static inline void led_set_brightness(struct led_classdev *led_cdev,
                                         enum led_brightness value)
 {
         if (value > led_cdev->max_brightness)
@@ -32,8 +32,6 @@ static inline int led_get_brightness(struct led_classdev *led_cdev)
         return led_cdev->brightness;
 }
 
-void led_stop_software_blink(struct led_classdev *led_cdev);
-
 extern struct rw_semaphore leds_list_lock;
 extern struct list_head leds_list;
 
diff --git a/drivers/leds/ledtrig-backlight.c b/drivers/leds/ledtrig-backlight.c
index 027a2b15d7d..2b513a2ad7d 100644
--- a/drivers/leds/ledtrig-backlight.c
+++ b/drivers/leds/ledtrig-backlight.c
@@ -40,15 +40,15 @@ static int fb_notifier_callback(struct notifier_block *p,
         int new_status = *blank ? BLANK : UNBLANK;
 
         switch (event) {
-        case FB_EVENT_BLANK:
+        case FB_EVENT_BLANK :
                 if (new_status == n->old_status)
                         break;
 
                 if ((n->old_status == UNBLANK) ^ n->invert) {
                         n->brightness = led->brightness;
-                        __led_set_brightness(led, LED_OFF);
+                        led_set_brightness(led, LED_OFF);
                 } else {
-                        __led_set_brightness(led, n->brightness);
+                        led_set_brightness(led, n->brightness);
                 }
 
                 n->old_status = new_status;
@@ -76,7 +76,7 @@ static ssize_t bl_trig_invert_store(struct device *dev,
         unsigned long invert;
         int ret;
 
-        ret = kstrtoul(buf, 10, &invert);
+        ret = strict_strtoul(buf, 10, &invert);
         if (ret < 0)
                 return ret;
 
@@ -87,9 +87,9 @@ static ssize_t bl_trig_invert_store(struct device *dev,
 
         /* After inverting, we need to update the LED. */
         if ((n->old_status == BLANK) ^ n->invert)
-                __led_set_brightness(led, LED_OFF);
+                led_set_brightness(led, LED_OFF);
         else
-                __led_set_brightness(led, n->brightness);
+                led_set_brightness(led, n->brightness);
 
         return num;
 }
@@ -120,7 +120,6 @@ static void bl_trig_activate(struct led_classdev *led)
         ret = fb_register_client(&n->notifier);
         if (ret)
                 dev_err(led->dev, "unable to register backlight trigger\n");
-        led->activated = true;
 
         return;
 
@@ -134,11 +133,10 @@ static void bl_trig_deactivate(struct led_classdev *led)
         struct bl_trig_notifier *n =
                 (struct bl_trig_notifier *) led->trigger_data;
 
-        if (led->activated) {
+        if (n) {
                 device_remove_file(led->dev, &dev_attr_inverted);
                 fb_unregister_client(&n->notifier);
                 kfree(n);
-                led->activated = false;
         }
 }
 
diff --git a/drivers/leds/ledtrig-cpu.c b/drivers/leds/ledtrig-cpu.c
deleted file mode 100644
index 4239b3955ff..00000000000
--- a/drivers/leds/ledtrig-cpu.c
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- * ledtrig-cpu.c - LED trigger based on CPU activity
- *
- * This LED trigger will be registered for each possible CPU and named as
- * cpu0, cpu1, cpu2, cpu3, etc.
- *
- * It can be bound to any LED just like other triggers using either a
- * board file or via sysfs interface.
- *
- * An API named ledtrig_cpu is exported for any user, who want to add CPU
- * activity indication in their code
- *
- * Copyright 2011 Linus Walleij <linus.walleij@linaro.org>
- * Copyright 2011 - 2012 Bryan Wu <bryan.wu@canonical.com>
- *
- * 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.
- *
- */
-
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-#include <linux/percpu.h>
-#include <linux/syscore_ops.h>
-#include <linux/rwsem.h>
-#include "leds.h"
-
-#define MAX_NAME_LEN    8
-
-struct led_trigger_cpu {
-        char name[MAX_NAME_LEN];
-        struct led_trigger *_trig;
-};
-
-static DEFINE_PER_CPU(struct led_trigger_cpu, cpu_trig);
-
-/**
- * ledtrig_cpu - emit a CPU event as a trigger
- * @evt: CPU event to be emitted
- *
- * Emit a CPU event on a CPU core, which will trigger a
- * binded LED to turn on or turn off.
- */
-void ledtrig_cpu(enum cpu_led_event ledevt)
-{
-        struct led_trigger_cpu *trig = &__get_cpu_var(cpu_trig);
-
-        /* Locate the correct CPU LED */
-        switch (ledevt) {
-        case CPU_LED_IDLE_END:
-        case CPU_LED_START:
-                /* Will turn the LED on, max brightness */
-                led_trigger_event(trig->_trig, LED_FULL);
-                break;
-
-        case CPU_LED_IDLE_START:
-        case CPU_LED_STOP:
-        case CPU_LED_HALTED:
-                /* Will turn the LED off */
-                led_trigger_event(trig->_trig, LED_OFF);
-                break;
-
-        default:
-                /* Will leave the LED as it is */
-                break;
-        }
-}
-EXPORT_SYMBOL(ledtrig_cpu);
-
-static int ledtrig_cpu_syscore_suspend(void)
-{
-        ledtrig_cpu(CPU_LED_STOP);
-        return 0;
-}
-
-static void ledtrig_cpu_syscore_resume(void)
-{
-        ledtrig_cpu(CPU_LED_START);
-}
-
-static void ledtrig_cpu_syscore_shutdown(void)
-{
-        ledtrig_cpu(CPU_LED_HALTED);
-}
-
-static struct syscore_ops ledtrig_cpu_syscore_ops = {
-        .shutdown       = ledtrig_cpu_syscore_shutdown,
-        .suspend        = ledtrig_cpu_syscore_suspend,
-        .resume         = ledtrig_cpu_syscore_resume,
-};
-
-static int __init ledtrig_cpu_init(void)
-{
-        int cpu;
-
-        /* Supports up to 9999 cpu cores */
-        BUILD_BUG_ON(CONFIG_NR_CPUS > 9999);
-
-        /*
-         * Registering CPU led trigger for each CPU core here
-         * ignores CPU hotplug, but after this CPU hotplug works
-         * fine with this trigger.
-         */
-        for_each_possible_cpu(cpu) {
-                struct led_trigger_cpu *trig = &per_cpu(cpu_trig, cpu);
-
-                snprintf(trig->name, MAX_NAME_LEN, "cpu%d", cpu);
-
-                led_trigger_register_simple(trig->name, &trig->_trig);
-        }
-
-        register_syscore_ops(&ledtrig_cpu_syscore_ops);
-
-        pr_info("ledtrig-cpu: registered to indicate activity on CPUs\n");
-
-        return 0;
-}
-module_init(ledtrig_cpu_init);
-
-static void __exit ledtrig_cpu_exit(void)
-{
-        int cpu;
-
-        for_each_possible_cpu(cpu) {
-                struct led_trigger_cpu *trig = &per_cpu(cpu_trig, cpu);
-
-                led_trigger_unregister_simple(trig->_trig);
-                trig->_trig = NULL;
-                memset(trig->name, 0, MAX_NAME_LEN);
-        }
-
-        unregister_syscore_ops(&ledtrig_cpu_syscore_ops);
-}
-module_exit(ledtrig_cpu_exit);
-
-MODULE_AUTHOR("Linus Walleij <linus.walleij@linaro.org>");
-MODULE_AUTHOR("Bryan Wu <bryan.wu@canonical.com>");
-MODULE_DESCRIPTION("CPU LED trigger");
-MODULE_LICENSE("GPL");
diff --git a/drivers/leds/ledtrig-default-on.c b/drivers/leds/ledtrig-default-on.c
index eac1f1b1ada..a4ef54b9d50 100644
--- a/drivers/leds/ledtrig-default-on.c
+++ b/drivers/leds/ledtrig-default-on.c
@@ -19,7 +19,7 @@
 
 static void defon_trig_activate(struct led_classdev *led_cdev)
 {
-        __led_set_brightness(led_cdev, led_cdev->max_brightness);
+        led_set_brightness(led_cdev, led_cdev->max_brightness);
 }
 
 static struct led_trigger defon_led_trigger = {
diff --git a/drivers/leds/ledtrig-gpio.c b/drivers/leds/ledtrig-gpio.c
index 72e3ebfc281..ecc4bf3f37a 100644
--- a/drivers/leds/ledtrig-gpio.c
+++ b/drivers/leds/ledtrig-gpio.c
@@ -54,12 +54,12 @@ static void gpio_trig_work(struct work_struct *work)
 
         if (tmp) {
                 if (gpio_data->desired_brightness)
-                        __led_set_brightness(gpio_data->led,
+                        led_set_brightness(gpio_data->led,
                                            gpio_data->desired_brightness);
                 else
-                        __led_set_brightness(gpio_data->led, LED_FULL);
+                        led_set_brightness(gpio_data->led, LED_FULL);
         } else {
-                __led_set_brightness(gpio_data->led, LED_OFF);
+                led_set_brightness(gpio_data->led, LED_OFF);
         }
 }
 
@@ -110,7 +110,7 @@ static ssize_t gpio_trig_inverted_store(struct device *dev,
         unsigned long inverted;
         int ret;
 
-        ret = kstrtoul(buf, 10, &inverted);
+        ret = strict_strtoul(buf, 10, &inverted);
         if (ret < 0)
                 return ret;
 
@@ -200,7 +200,6 @@ static void gpio_trig_activate(struct led_classdev *led)
         gpio_data->led = led;
         led->trigger_data = gpio_data;
         INIT_WORK(&gpio_data->work, gpio_trig_work);
-        led->activated = true;
 
         return;
 
@@ -218,7 +217,7 @@ static void gpio_trig_deactivate(struct led_classdev *led)
 {
         struct gpio_trig_data *gpio_data = led->trigger_data;
 
-        if (led->activated) {
+        if (gpio_data) {
                 device_remove_file(led->dev, &dev_attr_gpio);
                 device_remove_file(led->dev, &dev_attr_inverted);
                 device_remove_file(led->dev, &dev_attr_desired_brightness);
@@ -226,7 +225,6 @@ static void gpio_trig_deactivate(struct led_classdev *led)
                 if (gpio_data->gpio != 0)
                         free_irq(gpio_to_irq(gpio_data->gpio), led);
                 kfree(gpio_data);
-                led->activated = false;
         }
 }
 
diff --git a/drivers/leds/ledtrig-heartbeat.c b/drivers/leds/ledtrig-heartbeat.c
index 1edc7463ce8..759c0bba4a8 100644
--- a/drivers/leds/ledtrig-heartbeat.c
+++ b/drivers/leds/ledtrig-heartbeat.c
@@ -18,11 +18,8 @@
 #include <linux/timer.h>
 #include <linux/sched.h>
 #include <linux/leds.h>
-#include <linux/reboot.h>
 #include "leds.h"
 
-static int panic_heartbeats;
-
 struct heartbeat_trig_data {
         unsigned int phase;
         unsigned int period;
@@ -36,11 +33,6 @@ static void led_heartbeat_function(unsigned long data)
         unsigned long brightness = LED_OFF;
         unsigned long delay = 0;
 
-        if (unlikely(panic_heartbeats)) {
-                led_set_brightness(led_cdev, LED_OFF);
-                return;
-        }
-
         /* acts like an actual heart beat -- ie thump-thump-pause... */
         switch (heartbeat_data->phase) {
         case 0:
@@ -74,7 +66,7 @@ static void led_heartbeat_function(unsigned long data)
                 break;
         }
 
-        __led_set_brightness(led_cdev, brightness);
+        led_set_brightness(led_cdev, brightness);
         mod_timer(&heartbeat_data->timer, jiffies + delay);
 }
 
@@ -91,17 +83,15 @@ static void heartbeat_trig_activate(struct led_classdev *led_cdev)
                     led_heartbeat_function, (unsigned long) led_cdev);
         heartbeat_data->phase = 0;
         led_heartbeat_function(heartbeat_data->timer.data);
-        led_cdev->activated = true;
 }
 
 static void heartbeat_trig_deactivate(struct led_classdev *led_cdev)
 {
         struct heartbeat_trig_data *heartbeat_data = led_cdev->trigger_data;
 
-        if (led_cdev->activated) {
+        if (heartbeat_data) {
                 del_timer_sync(&heartbeat_data->timer);
                 kfree(heartbeat_data);
-                led_cdev->activated = false;
         }
 }
 
@@ -111,45 +101,13 @@ static struct led_trigger heartbeat_led_trigger = {
         .deactivate = heartbeat_trig_deactivate,
 };
 
-static int heartbeat_reboot_notifier(struct notifier_block *nb,
-                                     unsigned long code, void *unused)
-{
-        led_trigger_unregister(&heartbeat_led_trigger);
-        return NOTIFY_DONE;
-}
-
-static int heartbeat_panic_notifier(struct notifier_block *nb,
-                                     unsigned long code, void *unused)
-{
-        panic_heartbeats = 1;
-        return NOTIFY_DONE;
-}
-
-static struct notifier_block heartbeat_reboot_nb = {
-        .notifier_call = heartbeat_reboot_notifier,
-};
-
-static struct notifier_block heartbeat_panic_nb = {
-        .notifier_call = heartbeat_panic_notifier,
-};
-
 static int __init heartbeat_trig_init(void)
 {
-        int rc = led_trigger_register(&heartbeat_led_trigger);
-
-        if (!rc) {
-                atomic_notifier_chain_register(&panic_notifier_list,
-                                               &heartbeat_panic_nb);
-                register_reboot_notifier(&heartbeat_reboot_nb);
-        }
-        return rc;
+        return led_trigger_register(&heartbeat_led_trigger);
 }
 
 static void __exit heartbeat_trig_exit(void)
 {
-        unregister_reboot_notifier(&heartbeat_reboot_nb);
-        atomic_notifier_chain_unregister(&panic_notifier_list,
-                                         &heartbeat_panic_nb);
         led_trigger_unregister(&heartbeat_led_trigger);
 }
 
diff --git a/drivers/leds/ledtrig-ide-disk.c b/drivers/leds/ledtrig-ide-disk.c
index 2cd7c0cf592..ec099fcbcb0 100644
--- a/drivers/leds/ledtrig-ide-disk.c
+++ b/drivers/leds/ledtrig-ide-disk.c
@@ -12,22 +12,39 @@
  */
 
 #include <linux/module.h>
+#include <linux/jiffies.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
+#include <linux/timer.h>
 #include <linux/leds.h>
 
-#define BLINK_DELAY 30
+static void ledtrig_ide_timerfunc(unsigned long data);
 
 DEFINE_LED_TRIGGER(ledtrig_ide);
-static unsigned long ide_blink_delay = BLINK_DELAY;
+static DEFINE_TIMER(ledtrig_ide_timer, ledtrig_ide_timerfunc, 0, 0);
+static int ide_activity;
+static int ide_lastactivity;
 
 void ledtrig_ide_activity(void)
 {
-        led_trigger_blink_oneshot(ledtrig_ide,
-                                  &ide_blink_delay, &ide_blink_delay, 0);
+        ide_activity++;
+        if (!timer_pending(&ledtrig_ide_timer))
+                mod_timer(&ledtrig_ide_timer, jiffies + msecs_to_jiffies(10));
 }
 EXPORT_SYMBOL(ledtrig_ide_activity);
 
+static void ledtrig_ide_timerfunc(unsigned long data)
+{
+        if (ide_lastactivity != ide_activity) {
+                ide_lastactivity = ide_activity;
+                /* INT_MAX will set each LED to its maximum brightness */
+                led_trigger_event(ledtrig_ide, INT_MAX);
+                mod_timer(&ledtrig_ide_timer, jiffies + msecs_to_jiffies(10));
+        } else {
+                led_trigger_event(ledtrig_ide, LED_OFF);
+        }
+}
+
 static int __init ledtrig_ide_init(void)
 {
         led_trigger_register_simple("ide-disk", &ledtrig_ide);
diff --git a/drivers/leds/ledtrig-oneshot.c b/drivers/leds/ledtrig-oneshot.c
deleted file mode 100644
index 2c029aa5c4f..00000000000
--- a/drivers/leds/ledtrig-oneshot.c
+++ /dev/null
@@ -1,204 +0,0 @@
-/*
- * One-shot LED Trigger
- *
- * Copyright 2012, Fabio Baltieri <fabio.baltieri@gmail.com>
- *
- * Based on ledtrig-timer.c by Richard Purdie <rpurdie@openedhand.com>
- *
- * 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.
- *
- */
-
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/device.h>
-#include <linux/ctype.h>
-#include <linux/slab.h>
-#include <linux/leds.h>
-#include "leds.h"
-
-#define DEFAULT_DELAY 100
-
-struct oneshot_trig_data {
-        unsigned int invert;
-};
-
-static ssize_t led_shot(struct device *dev,
-                struct device_attribute *attr, const char *buf, size_t size)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct oneshot_trig_data *oneshot_data = led_cdev->trigger_data;
-
-        led_blink_set_oneshot(led_cdev,
-                        &led_cdev->blink_delay_on, &led_cdev->blink_delay_off,
-                        oneshot_data->invert);
-
-        /* content is ignored */
-        return size;
-}
-static ssize_t led_invert_show(struct device *dev,
-                struct device_attribute *attr, char *buf)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct oneshot_trig_data *oneshot_data = led_cdev->trigger_data;
-
-        return sprintf(buf, "%u\n", oneshot_data->invert);
-}
-
-static ssize_t led_invert_store(struct device *dev,
-                struct device_attribute *attr, const char *buf, size_t size)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct oneshot_trig_data *oneshot_data = led_cdev->trigger_data;
-        unsigned long state;
-        int ret;
-
-        ret = kstrtoul(buf, 0, &state);
-        if (ret)
-                return ret;
-
-        oneshot_data->invert = !!state;
-
-        if (oneshot_data->invert)
-                __led_set_brightness(led_cdev, LED_FULL);
-        else
-                __led_set_brightness(led_cdev, LED_OFF);
-
-        return size;
-}
-
-static ssize_t led_delay_on_show(struct device *dev,
-                struct device_attribute *attr, char *buf)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-
-        return sprintf(buf, "%lu\n", led_cdev->blink_delay_on);
-}
-
-static ssize_t led_delay_on_store(struct device *dev,
-                struct device_attribute *attr, const char *buf, size_t size)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        unsigned long state;
-        int ret;
-
-        ret = kstrtoul(buf, 0, &state);
-        if (ret)
-                return ret;
-
-        led_cdev->blink_delay_on = state;
-
-        return size;
-}
-static ssize_t led_delay_off_show(struct device *dev,
-                struct device_attribute *attr, char *buf)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-
-        return sprintf(buf, "%lu\n", led_cdev->blink_delay_off);
-}
-
-static ssize_t led_delay_off_store(struct device *dev,
-                struct device_attribute *attr, const char *buf, size_t size)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        unsigned long state;
-        int ret;
-
-        ret = kstrtoul(buf, 0, &state);
-        if (ret)
-                return ret;
-
-        led_cdev->blink_delay_off = state;
-
-        return size;
-}
-
-static DEVICE_ATTR(delay_on, 0644, led_delay_on_show, led_delay_on_store);
-static DEVICE_ATTR(delay_off, 0644, led_delay_off_show, led_delay_off_store);
-static DEVICE_ATTR(invert, 0644, led_invert_show, led_invert_store);
-static DEVICE_ATTR(shot, 0200, NULL, led_shot);
-
-static void oneshot_trig_activate(struct led_classdev *led_cdev)
-{
-        struct oneshot_trig_data *oneshot_data;
-        int rc;
-
-        oneshot_data = kzalloc(sizeof(*oneshot_data), GFP_KERNEL);
-        if (!oneshot_data)
-                return;
-
-        led_cdev->trigger_data = oneshot_data;
-
-        rc = device_create_file(led_cdev->dev, &dev_attr_delay_on);
-        if (rc)
-                goto err_out_trig_data;
-        rc = device_create_file(led_cdev->dev, &dev_attr_delay_off);
-        if (rc)
-                goto err_out_delayon;
-        rc = device_create_file(led_cdev->dev, &dev_attr_invert);
-        if (rc)
-                goto err_out_delayoff;
-        rc = device_create_file(led_cdev->dev, &dev_attr_shot);
-        if (rc)
-                goto err_out_invert;
-
-        led_cdev->blink_delay_on = DEFAULT_DELAY;
-        led_cdev->blink_delay_off = DEFAULT_DELAY;
-
-        led_cdev->activated = true;
-
-        return;
-
-err_out_invert:
-        device_remove_file(led_cdev->dev, &dev_attr_invert);
-err_out_delayoff:
-        device_remove_file(led_cdev->dev, &dev_attr_delay_off);
-err_out_delayon:
-        device_remove_file(led_cdev->dev, &dev_attr_delay_on);
-err_out_trig_data:
-        kfree(led_cdev->trigger_data);
-}
-
-static void oneshot_trig_deactivate(struct led_classdev *led_cdev)
-{
-        struct oneshot_trig_data *oneshot_data = led_cdev->trigger_data;
-
-        if (led_cdev->activated) {
-                device_remove_file(led_cdev->dev, &dev_attr_delay_on);
-                device_remove_file(led_cdev->dev, &dev_attr_delay_off);
-                device_remove_file(led_cdev->dev, &dev_attr_invert);
-                device_remove_file(led_cdev->dev, &dev_attr_shot);
-                kfree(oneshot_data);
-                led_cdev->activated = false;
-        }
-
-        /* Stop blinking */
-        led_set_brightness(led_cdev, LED_OFF);
-}
-
-static struct led_trigger oneshot_led_trigger = {
-        .name     = "oneshot",
-        .activate = oneshot_trig_activate,
-        .deactivate = oneshot_trig_deactivate,
-};
-
-static int __init oneshot_trig_init(void)
-{
-        return led_trigger_register(&oneshot_led_trigger);
-}
-
-static void __exit oneshot_trig_exit(void)
-{
-        led_trigger_unregister(&oneshot_led_trigger);
-}
-
-module_init(oneshot_trig_init);
-module_exit(oneshot_trig_exit);
-
-MODULE_AUTHOR("Fabio Baltieri <fabio.baltieri@gmail.com>");
-MODULE_DESCRIPTION("One-shot LED trigger");
-MODULE_LICENSE("GPL");
diff --git a/drivers/leds/ledtrig-timer.c b/drivers/leds/ledtrig-timer.c
index f774d059220..328c64c0841 100644
--- a/drivers/leds/ledtrig-timer.c
+++ b/drivers/leds/ledtrig-timer.c
@@ -31,17 +31,21 @@ static ssize_t led_delay_on_store(struct device *dev,
                 struct device_attribute *attr, const char *buf, size_t size)
 {
         struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        unsigned long state;
-        ssize_t ret = -EINVAL;
-
-        ret = kstrtoul(buf, 10, &state);
-        if (ret)
-                return ret;
-
-        led_blink_set(led_cdev, &state, &led_cdev->blink_delay_off);
-        led_cdev->blink_delay_on = state;
+        int ret = -EINVAL;
+        char *after;
+        unsigned long state = simple_strtoul(buf, &after, 10);
+        size_t count = after - buf;
+
+        if (isspace(*after))
+                count++;
+
+        if (count == size) {
+                led_blink_set(led_cdev, &state, &led_cdev->blink_delay_off);
+                led_cdev->blink_delay_on = state;
+                ret = count;
+        }
 
-        return size;
+        return ret;
 }
 
 static ssize_t led_delay_off_show(struct device *dev,
@@ -56,17 +60,21 @@ static ssize_t led_delay_off_store(struct device *dev,
                 struct device_attribute *attr, const char *buf, size_t size)
 {
         struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        unsigned long state;
-        ssize_t ret = -EINVAL;
-
-        ret = kstrtoul(buf, 10, &state);
-        if (ret)
-                return ret;
-
-        led_blink_set(led_cdev, &led_cdev->blink_delay_on, &state);
-        led_cdev->blink_delay_off = state;
+        int ret = -EINVAL;
+        char *after;
+        unsigned long state = simple_strtoul(buf, &after, 10);
+        size_t count = after - buf;
+
+        if (isspace(*after))
+                count++;
+
+        if (count == size) {
+                led_blink_set(led_cdev, &led_cdev->blink_delay_on, &state);
+                led_cdev->blink_delay_off = state;
+                ret = count;
+        }
 
-        return size;
+        return ret;
 }
 
 static DEVICE_ATTR(delay_on, 0644, led_delay_on_show, led_delay_on_store);
@@ -87,7 +95,8 @@ static void timer_trig_activate(struct led_classdev *led_cdev)
 
         led_blink_set(led_cdev, &led_cdev->blink_delay_on,
                       &led_cdev->blink_delay_off);
-        led_cdev->activated = true;
+
+        led_cdev->trigger_data = (void *)1;
 
         return;
 
@@ -97,14 +106,13 @@ err_out_delayon:
 
 static void timer_trig_deactivate(struct led_classdev *led_cdev)
 {
-        if (led_cdev->activated) {
+        if (led_cdev->trigger_data) {
                 device_remove_file(led_cdev->dev, &dev_attr_delay_on);
                 device_remove_file(led_cdev->dev, &dev_attr_delay_off);
-                led_cdev->activated = false;
         }
 
         /* Stop blinking */
-        led_set_brightness(led_cdev, LED_OFF);
+        led_brightness_set(led_cdev, LED_OFF);
 }
 
 static struct led_trigger timer_led_trigger = {
diff --git a/drivers/leds/ledtrig-transient.c b/drivers/leds/ledtrig-transient.c
deleted file mode 100644
index 398f1042c43..00000000000
--- a/drivers/leds/ledtrig-transient.c
+++ /dev/null
@@ -1,237 +0,0 @@
-/*
- * LED Kernel Transient Trigger
- *
- * Copyright (C) 2012 Shuah Khan <shuahkhan@gmail.com>
- *
- * Based on Richard Purdie's ledtrig-timer.c and Atsushi Nemoto's
- * ledtrig-heartbeat.c
- * Design and use-case input from Jonas Bonn <jonas@southpole.se> and
- * Neil Brown <neilb@suse.de>
- *
- * 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.
- *
- */
-/*
- * Transient trigger allows one shot timer activation. Please refer to
- * Documentation/leds/ledtrig-transient.txt for details
-*/
-
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/device.h>
-#include <linux/slab.h>
-#include <linux/timer.h>
-#include <linux/leds.h>
-#include "leds.h"
-
-struct transient_trig_data {
-        int activate;
-        int state;
-        int restore_state;
-        unsigned long duration;
-        struct timer_list timer;
-};
-
-static void transient_timer_function(unsigned long data)
-{
-        struct led_classdev *led_cdev = (struct led_classdev *) data;
-        struct transient_trig_data *transient_data = led_cdev->trigger_data;
-
-        transient_data->activate = 0;
-        __led_set_brightness(led_cdev, transient_data->restore_state);
-}
-
-static ssize_t transient_activate_show(struct device *dev,
-                struct device_attribute *attr, char *buf)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct transient_trig_data *transient_data = led_cdev->trigger_data;
-
-        return sprintf(buf, "%d\n", transient_data->activate);
-}
-
-static ssize_t transient_activate_store(struct device *dev,
-                struct device_attribute *attr, const char *buf, size_t size)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct transient_trig_data *transient_data = led_cdev->trigger_data;
-        unsigned long state;
-        ssize_t ret;
-
-        ret = kstrtoul(buf, 10, &state);
-        if (ret)
-                return ret;
-
-        if (state != 1 && state != 0)
-                return -EINVAL;
-
-        /* cancel the running timer */
-        if (state == 0 && transient_data->activate == 1) {
-                del_timer(&transient_data->timer);
-                transient_data->activate = state;
-                __led_set_brightness(led_cdev, transient_data->restore_state);
-                return size;
-        }
-
-        /* start timer if there is no active timer */
-        if (state == 1 && transient_data->activate == 0 &&
-            transient_data->duration != 0) {
-                transient_data->activate = state;
-                __led_set_brightness(led_cdev, transient_data->state);
-                transient_data->restore_state =
-                    (transient_data->state == LED_FULL) ? LED_OFF : LED_FULL;
-                mod_timer(&transient_data->timer,
-                          jiffies + transient_data->duration);
-        }
-
-        /* state == 0 && transient_data->activate == 0
-                timer is not active - just return */
-        /* state == 1 && transient_data->activate == 1
-                timer is already active - just return */
-
-        return size;
-}
-
-static ssize_t transient_duration_show(struct device *dev,
-                struct device_attribute *attr, char *buf)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct transient_trig_data *transient_data = led_cdev->trigger_data;
-
-        return sprintf(buf, "%lu\n", transient_data->duration);
-}
-
-static ssize_t transient_duration_store(struct device *dev,
-                struct device_attribute *attr, const char *buf, size_t size)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct transient_trig_data *transient_data = led_cdev->trigger_data;
-        unsigned long state;
-        ssize_t ret;
-
-        ret = kstrtoul(buf, 10, &state);
-        if (ret)
-                return ret;
-
-        transient_data->duration = state;
-        return size;
-}
-
-static ssize_t transient_state_show(struct device *dev,
-                struct device_attribute *attr, char *buf)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct transient_trig_data *transient_data = led_cdev->trigger_data;
-        int state;
-
-        state = (transient_data->state == LED_FULL) ? 1 : 0;
-        return sprintf(buf, "%d\n", state);
-}
-
-static ssize_t transient_state_store(struct device *dev,
-                struct device_attribute *attr, const char *buf, size_t size)
-{
-        struct led_classdev *led_cdev = dev_get_drvdata(dev);
-        struct transient_trig_data *transient_data = led_cdev->trigger_data;
-        unsigned long state;
-        ssize_t ret;
-
-        ret = kstrtoul(buf, 10, &state);
-        if (ret)
-                return ret;
-
-        if (state != 1 && state != 0)
-                return -EINVAL;
-
-        transient_data->state = (state == 1) ? LED_FULL : LED_OFF;
-        return size;
-}
-
-static DEVICE_ATTR(activate, 0644, transient_activate_show,
-                   transient_activate_store);
-static DEVICE_ATTR(duration, 0644, transient_duration_show,
-                   transient_duration_store);
-static DEVICE_ATTR(state, 0644, transient_state_show, transient_state_store);
-
-static void transient_trig_activate(struct led_classdev *led_cdev)
-{
-        int rc;
-        struct transient_trig_data *tdata;
-
-        tdata = kzalloc(sizeof(struct transient_trig_data), GFP_KERNEL);
-        if (!tdata) {
-                dev_err(led_cdev->dev,
-                        "unable to allocate transient trigger\n");
-                return;
-        }
-        led_cdev->trigger_data = tdata;
-
-        rc = device_create_file(led_cdev->dev, &dev_attr_activate);
-        if (rc)
-                goto err_out;
-
-        rc = device_create_file(led_cdev->dev, &dev_attr_duration);
-        if (rc)
-                goto err_out_duration;
-
-        rc = device_create_file(led_cdev->dev, &dev_attr_state);
-        if (rc)
-                goto err_out_state;
-
-        setup_timer(&tdata->timer, transient_timer_function,
-                    (unsigned long) led_cdev);
-        led_cdev->activated = true;
-
-        return;
-
-err_out_state:
-        device_remove_file(led_cdev->dev, &dev_attr_duration);
-err_out_duration:
-        device_remove_file(led_cdev->dev, &dev_attr_activate);
-err_out:
-        dev_err(led_cdev->dev, "unable to register transient trigger\n");
-        led_cdev->trigger_data = NULL;
-        kfree(tdata);
-}
-
-static void transient_trig_deactivate(struct led_classdev *led_cdev)
-{
-        struct transient_trig_data *transient_data = led_cdev->trigger_data;
-
-        if (led_cdev->activated) {
-                del_timer_sync(&transient_data->timer);
-                __led_set_brightness(led_cdev, transient_data->restore_state);
-                device_remove_file(led_cdev->dev, &dev_attr_activate);
-                device_remove_file(led_cdev->dev, &dev_attr_duration);
-                device_remove_file(led_cdev->dev, &dev_attr_state);
-                led_cdev->trigger_data = NULL;
-                led_cdev->activated = false;
-                kfree(transient_data);
-        }
-}
-
-static struct led_trigger transient_trigger = {
-        .name     = "transient",
-        .activate = transient_trig_activate,
-        .deactivate = transient_trig_deactivate,
-};
-
-static int __init transient_trig_init(void)
-{
-        return led_trigger_register(&transient_trigger);
-}
-
-static void __exit transient_trig_exit(void)
-{
-        led_trigger_unregister(&transient_trigger);
-}
-
-module_init(transient_trig_init);
-module_exit(transient_trig_exit);
-
-MODULE_AUTHOR("Shuah Khan <shuahkhan@gmail.com>");
-MODULE_DESCRIPTION("Transient LED trigger");
-MODULE_LICENSE("GPL");