LEDS: add BlinkM RGB LED driver, documentation and update MAINTAINERS
authorJan-Simon Möller <jansimon.moeller@gmx.de>
Fri, 20 Jul 2012 08:49:06 +0000 (16:49 +0800)
committerBryan Wu <bryan.wu@canonical.com>
Tue, 24 Jul 2012 08:00:51 +0000 (16:00 +0800)
Add driver for BlinkM device to drivers/leds/.
Add entry to MAINTAINERS file.
Add documentation in Documentation/leds/.

A BlinkM is a RGB LED controlled through I2C.

This driver implements an interface to the LED framework
and another sysfs group to access the internal options
of the BlinkM.

rev6: Use module_i2c_driver().
rev5: Removed own workqueue in favor of events wq.
rev4: Fixed comments by Bryan Wu.
rev3: Fixed issues found by Jonathan Neuschäfer.

(bryan.wu@canonical.com: remove 2 trailing whitespace)

Signed-off-by: Jan-Simon Möller <jansimon.moeller@gmx.de>
Signed-off-by: Bryan Wu <bryan.wu@canonical.com>
Documentation/leds/leds-blinkm.txt [new file with mode: 0644]
MAINTAINERS
drivers/leds/Kconfig
drivers/leds/Makefile
drivers/leds/leds-blinkm.c [new file with mode: 0644]

diff --git a/Documentation/leds/leds-blinkm.txt b/Documentation/leds/leds-blinkm.txt
new file mode 100644 (file)
index 0000000..9dd92f4
--- /dev/null
@@ -0,0 +1,80 @@
+The leds-blinkm driver supports the devices of the BlinkM family.
+
+They are RGB-LED modules driven by a (AT)tiny microcontroller and
+communicate through I2C. The default address of these modules is
+0x09 but this can be changed through a command. By this you could
+dasy-chain up to 127 BlinkMs on an I2C bus.
+
+The device accepts RGB and HSB color values through separate commands.
+Also you can store blinking sequences as "scripts" in
+the controller and run them. Also fading is an option.
+
+The interface this driver provides is 2-fold:
+
+a) LED class interface for use with triggers
+############################################
+
+The registration follows the scheme:
+blinkm-<i2c-bus-nr>-<i2c-device-nr>-<color>
+
+$ ls -h /sys/class/leds/blinkm-6-*
+/sys/class/leds/blinkm-6-9-blue:
+brightness  device  max_brightness  power  subsystem  trigger  uevent
+
+/sys/class/leds/blinkm-6-9-green:
+brightness  device  max_brightness  power  subsystem  trigger  uevent
+
+/sys/class/leds/blinkm-6-9-red:
+brightness  device  max_brightness  power  subsystem  trigger  uevent
+
+(same is /sys/bus/i2c/devices/6-0009/leds)
+
+We can control the colors separated into red, green and blue and
+assign triggers on each color.
+
+E.g.:
+
+$ cat blinkm-6-9-blue/brightness
+05
+
+$ echo 200 > blinkm-6-9-blue/brightness
+$
+
+$ modprobe ledtrig-heartbeat
+$ echo heartbeat > blinkm-6-9-green/trigger
+$
+
+
+b) Sysfs group to control rgb, fade, hsb, scripts ...
+#####################################################
+
+This extended interface is available as folder blinkm
+in the sysfs folder of the I2C device.
+E.g. below /sys/bus/i2c/devices/6-0009/blinkm
+
+$ ls -h /sys/bus/i2c/devices/6-0009/blinkm/
+blue  green  red  test
+
+Currently supported is just setting red, green, blue
+and a test sequence.
+
+E.g.:
+
+$ cat *
+00
+00
+00
+#Write into test to start test sequence!#
+
+$ echo 1 > test
+$
+
+$ echo 255 > red
+$
+
+
+
+as of 6/2012
+
+dl9pf <at> gmx <dot> de
+
index fe643e7b9df6360442ba2bfeb653a971da83b0f4..4d8811af9edd732d56d9786e19f15bb7501ee91d 100644 (file)
@@ -1518,6 +1518,11 @@ W:       http://blackfin.uclinux.org/
 S:     Supported
 F:     drivers/i2c/busses/i2c-bfin-twi.c
 
+BLINKM RGB LED DRIVER
+M:     Jan-Simon Moeller <jansimon.moeller@gmx.de>
+S:     Maintained
+F:     drivers/leds/leds-blinkm.c
+
 BLOCK LAYER
 M:     Jens Axboe <axboe@kernel.dk>
 T:     git git://git.kernel.org/pub/scm/linux/kernel/git/axboe/linux-block.git
index f028f0348e838358f177077f223d7f0d13c9ac7b..f0aaf415316d92a221e58df050914ce2ff1df391 100644 (file)
@@ -430,6 +430,14 @@ config LEDS_OT200
          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
index 5eebd7bce4bece511a8da8b34fa4653f19a557e6..d94d18f8a4be3dda74215948109de7e80ab6b2df 100644 (file)
@@ -48,6 +48,7 @@ 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_LM3556)              += leds-lm3556.o
+obj-$(CONFIG_LEDS_BLINKM)              += leds-blinkm.o
 
 # LED SPI Drivers
 obj-$(CONFIG_LEDS_DAC124S085)          += leds-dac124s085.o
diff --git a/drivers/leds/leds-blinkm.c b/drivers/leds/leds-blinkm.c
new file mode 100644 (file)
index 0000000..5a9df43
--- /dev/null
@@ -0,0 +1,812 @@
+/*
+ *  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 = kzalloc(sizeof(struct blinkm_work),
+                                             GFP_ATOMIC);
+
+       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;
+       }
+
+       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 -ENODEV;
+       usleep_range(20000, 30000);     /* allow a small delay */
+       ret = blinkm_read(client, BLM_GET_ADDR, tmpargs);
+       if (ret < 0)
+               return -ENODEV;
+
+       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 __devinit 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 __devexit 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 = __devexit_p(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");
+