HID: thingm: refactor blink(1) support

This patch refactors the way the thingm driver registers a blink(1) LED.
In order to make the driver simpler and more standard, drop the "rgb"
sysfs attribute and create one instance of LED class per RGB channel.

Actually, the name of the LED class instance registered for a blink(1)
device is "blink1::ABCD", where ABCD is the last 4 chars of the serial
number. The driver now registers 3 instances per RGB chip, named
"thingmX:{red,green,blue}:ledY" where X is the hidraw minor number and Y
is the RGB chip number (as seen by the firmware).

This patch also uses work queues to defer calls with the device, which
now allows triggers to work as expected with this LED device.

Also remove the brightness structure field and the brightness_get
backend, as it is already handled by the LED class, and changes the
prefix of functions and structures to thingm_ to match the driver name.

Signed-off-by: Vivien Didelot <vivien.didelot@savoirfairelinux.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>

3 files changed, 209 insertions, 105 deletions

diff --git a/Documentation/ABI/testing/sysfs-driver-hid-thingm b/Documentation/ABI/testing/sysfs-driver-hid-thingm
deleted file mode 100644
index 735c5cb0bb07..000000000000
--- a/Documentation/ABI/testing/sysfs-driver-hid-thingm
+++ /dev/null
@@ -1,8 +0,0 @@
-What:           /sys/class/leds/blink1::<serial>/rgb
-Date:           January 2013
-Contact:        Vivien Didelot <vivien.didelot@savoirfairelinux.com>
-Description:    The ThingM blink1 is an USB RGB LED. The color notation is
-                3-byte hexadecimal. Read this attribute to get the last set
-                color. Write the 24-bit hexadecimal color to change the current
-                LED color. The default color is full white (0xFFFFFF).
-                For instance, set the color to green with: echo 00FF00 > rgb
diff --git a/drivers/hid/hid-thingm.c b/drivers/hid/hid-thingm.c
index e3b6647e00ce..0af0eb446636 100644
--- a/drivers/hid/hid-thingm.c
+++ b/drivers/hid/hid-thingm.c
@@ -1,7 +1,7 @@
 /*
  * ThingM blink(1) USB RGB LED driver
  *
- * Copyright 2013 Savoir-faire Linux Inc.
+ * Copyright 2013-2014 Savoir-faire Linux Inc.
  *      Vivien Didelot <vivien.didelot@savoirfairelinux.com>
  *
  * This program is free software; you can redistribute it and/or
@@ -10,170 +10,280 @@
  */
 
 #include <linux/hid.h>
+#include <linux/hidraw.h>
 #include <linux/leds.h>
 #include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/workqueue.h>
 
 #include "hid-ids.h"
 
-#define BLINK1_CMD_SIZE         9
+#define REPORT_ID       1
+#define REPORT_SIZE     9
 
-#define blink1_rgb_to_r(rgb)    ((rgb & 0xFF0000) >> 16)
-#define blink1_rgb_to_g(rgb)    ((rgb & 0x00FF00) >> 8)
-#define blink1_rgb_to_b(rgb)    ((rgb & 0x0000FF) >> 0)
+/* Firmware major number of supported devices */
+#define THINGM_MAJOR_MK1        '1'
 
-/**
- * struct blink1_data - blink(1) device specific data
- * @hdev:               HID device.
- * @led_cdev:           LED class instance.
- * @rgb:                8-bit per channel RGB notation.
- * @brightness:         brightness coefficient.
- */
-struct blink1_data {
+struct thingm_fwinfo {
+        char major;
+        unsigned numrgb;
+        unsigned first;
+};
+
+const struct thingm_fwinfo thingm_fwinfo[] = {
+        {
+                .major = THINGM_MAJOR_MK1,
+                .numrgb = 1,
+                .first = 0,
+        }
+};
+
+/* A red, green or blue channel, part of an RGB chip */
+struct thingm_led {
+        struct thingm_rgb *rgb;
+        struct led_classdev ldev;
+        char name[32];
+};
+
+/* Basically a WS2812 5050 RGB LED chip */
+struct thingm_rgb {
+        struct thingm_device *tdev;
+        struct thingm_led red;
+        struct thingm_led green;
+        struct thingm_led blue;
+        struct work_struct work;
+        u8 num;
+};
+
+struct thingm_device {
         struct hid_device *hdev;
-        struct led_classdev led_cdev;
-        u32 rgb;
-        u8 brightness;
+        struct {
+                char major;
+                char minor;
+        } version;
+        const struct thingm_fwinfo *fwinfo;
+        struct mutex lock;
+        struct thingm_rgb *rgb;
 };
 
-static int blink1_send_command(struct blink1_data *data,
-                u8 buf[BLINK1_CMD_SIZE])
+static int thingm_send(struct thingm_device *tdev, u8 buf[REPORT_SIZE])
 {
         int ret;
 
-        hid_dbg(data->hdev, "command: %d%c%.2x%.2x%.2x%.2x%.2x%.2x%.2x\n",
+        hid_dbg(tdev->hdev, "-> %d %c %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx\n",
                         buf[0], buf[1], buf[2], buf[3], buf[4],
                         buf[5], buf[6], buf[7], buf[8]);
 
-        ret = hid_hw_raw_request(data->hdev, buf[0], buf, BLINK1_CMD_SIZE,
-                                 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
+        ret = hid_hw_raw_request(tdev->hdev, buf[0], buf, REPORT_SIZE,
+                        HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
 
         return ret < 0 ? ret : 0;
 }
 
-static int blink1_update_color(struct blink1_data *data)
+static int thingm_recv(struct thingm_device *tdev, u8 buf[REPORT_SIZE])
 {
-        u8 buf[BLINK1_CMD_SIZE] = { 1, 'n', 0, 0, 0, 0, 0, 0, 0 };
+        int ret;
 
-        if (data->brightness) {
-                unsigned int coef = DIV_ROUND_CLOSEST(255, data->brightness);
+        ret = hid_hw_raw_request(tdev->hdev, buf[0], buf, REPORT_SIZE,
+                        HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
+        if (ret < 0)
+                return ret;
 
-                buf[2] = DIV_ROUND_CLOSEST(blink1_rgb_to_r(data->rgb), coef);
-                buf[3] = DIV_ROUND_CLOSEST(blink1_rgb_to_g(data->rgb), coef);
-                buf[4] = DIV_ROUND_CLOSEST(blink1_rgb_to_b(data->rgb), coef);
-        }
+        hid_dbg(tdev->hdev, "<- %d %c %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx\n",
+                        buf[0], buf[1], buf[2], buf[3], buf[4],
+                        buf[5], buf[6], buf[7], buf[8]);
 
-        return blink1_send_command(data, buf);
+        return 0;
 }
 
-static void blink1_led_set(struct led_classdev *led_cdev,
-                enum led_brightness brightness)
+static int thingm_version(struct thingm_device *tdev)
 {
-        struct blink1_data *data = dev_get_drvdata(led_cdev->dev->parent);
+        u8 buf[REPORT_SIZE] = { REPORT_ID, 'v', 0, 0, 0, 0, 0, 0, 0 };
+        int err;
+
+        err = thingm_send(tdev, buf);
+        if (err)
+                return err;
+
+        err = thingm_recv(tdev, buf);
+        if (err)
+                return err;
 
-        data->brightness = brightness;
-        if (blink1_update_color(data))
-                hid_err(data->hdev, "failed to update color\n");
+        tdev->version.major = buf[3];
+        tdev->version.minor = buf[4];
+
+        return 0;
 }
 
-static enum led_brightness blink1_led_get(struct led_classdev *led_cdev)
+static int thingm_write_color(struct thingm_rgb *rgb)
 {
-        struct blink1_data *data = dev_get_drvdata(led_cdev->dev->parent);
+        u8 buf[REPORT_SIZE] = { REPORT_ID, 'n', 0, 0, 0, 0, 0, 0, 0 };
+
+        buf[2] = rgb->red.ldev.brightness;
+        buf[3] = rgb->green.ldev.brightness;
+        buf[4] = rgb->blue.ldev.brightness;
 
-        return data->brightness;
+        return thingm_send(rgb->tdev, buf);
 }
 
-static ssize_t blink1_show_rgb(struct device *dev,
-                struct device_attribute *attr, char *buf)
+static void thingm_work(struct work_struct *work)
 {
-        struct blink1_data *data = dev_get_drvdata(dev->parent);
+        struct thingm_rgb *rgb = container_of(work, struct thingm_rgb, work);
 
-        return sprintf(buf, "%.6X\n", data->rgb);
+        mutex_lock(&rgb->tdev->lock);
+
+        if (thingm_write_color(rgb))