1 files changed, 207 insertions, 97 deletions

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))
+                hid_err(rgb->tdev->hdev, "failed to write color\n");
+
+        mutex_unlock(&rgb->tdev->lock);
 }
 
-static ssize_t blink1_store_rgb(struct device *dev,
-                struct device_attribute *attr, const char *buf, size_t count)
+static void thingm_led_set(struct led_classdev *ldev,
+                enum led_brightness brightness)
 {
-        struct blink1_data *data = dev_get_drvdata(dev->parent);
-        long unsigned int rgb;
-        int ret;
+        struct thingm_led *led = container_of(ldev, struct thingm_led, ldev);
 
-        ret = kstrtoul(buf, 16, &rgb);
-        if (ret)
-                return ret;
+        /* the ledclass has already stored the brightness value */
+        schedule_work(&led->rgb->work);
+}
 
-        /* RGB triplet notation is 24-bit hexadecimal */
-        if (rgb > 0xFFFFFF)
-                return -EINVAL;
+static int thingm_init_rgb(struct thingm_rgb *rgb)
+{
+        const int minor = ((struct hidraw *) rgb->tdev->hdev->hidraw)->minor;
+        int err;
+
+        /* Register the red diode */
+        snprintf(rgb->red.name, sizeof(rgb->red.name),
+                        "thingm%d:red:led%d", minor, rgb->num);
+        rgb->red.ldev.name = rgb->red.name;
+        rgb->red.ldev.max_brightness = 255;
+        rgb->red.ldev.brightness_set = thingm_led_set;
+        rgb->red.rgb = rgb;
+
+        err = led_classdev_register(&rgb->tdev->hdev->dev, &rgb->red.ldev);
+        if (err)
+                return err;
+
+        /* Register the green diode */
+        snprintf(rgb->green.name, sizeof(rgb->green.name),
+                        "thingm%d:green:led%d", minor, rgb->num);
+        rgb->green.ldev.name = rgb->green.name;
+        rgb->green.ldev.max_brightness = 255;
+        rgb->green.ldev.brightness_set = thingm_led_set;
+        rgb->green.rgb = rgb;
+
+        err = led_classdev_register(&rgb->tdev->hdev->dev, &rgb->green.ldev);
+        if (err)
+                goto unregister_red;
+
+        /* Register the blue diode */
+        snprintf(rgb->blue.name, sizeof(rgb->blue.name),
+                        "thingm%d:blue:led%d", minor, rgb->num);
+        rgb->blue.ldev.name = rgb->blue.name;
+        rgb->blue.ldev.max_brightness = 255;
+        rgb->blue.ldev.brightness_set = thingm_led_set;
+        rgb->blue.rgb = rgb;
+
+        err = led_classdev_register(&rgb->tdev->hdev->dev, &rgb->blue.ldev);
+        if (err)
+                goto unregister_green;
+
+        INIT_WORK(&rgb->work, thingm_work);
 
-        data->rgb = rgb;
-        ret = blink1_update_color(data);
+        return 0;
 
-        return ret ? ret : count;
-}
+unregister_green:
+        led_classdev_unregister(&rgb->green.ldev);
 
-static DEVICE_ATTR(rgb, S_IRUGO | S_IWUSR, blink1_show_rgb, blink1_store_rgb);
+unregister_red:
+        led_classdev_unregister(&rgb->red.ldev);
 
-static const struct attribute_group blink1_sysfs_group = {
-        .attrs = (struct attribute *[]) {
-                &dev_attr_rgb.attr,
-                NULL
-        },
-};
+        return err;
+}
+
+static void thingm_remove_rgb(struct thingm_rgb *rgb)
+{
+        flush_work(&rgb->work);
+        led_classdev_unregister(&rgb->red.ldev);
+        led_classdev_unregister(&rgb->green.ldev);
+        led_classdev_unregister(&rgb->blue.ldev);
+}
 
 static int thingm_probe(struct hid_device *hdev, const struct hid_device_id *id)
 {
-        struct blink1_data *data;
-        struct led_classdev *led;
-        char led_name[13];
-        int ret;
+        struct thingm_device *tdev;
+        int i, err;
 
-        data = devm_kzalloc(&hdev->dev, sizeof(struct blink1_data), GFP_KERNEL);
-        if (!data)
+        tdev = devm_kzalloc(&hdev->dev, sizeof(struct thingm_device),
+                        GFP_KERNEL);
+        if (!tdev)
                 return -ENOMEM;
 
-        hid_set_drvdata(hdev, data);
-        data->hdev = hdev;
-        data->rgb = 0xFFFFFF; /* set a default white color */
+        tdev->hdev = hdev;
+        hid_set_drvdata(hdev, tdev);
 
-        ret = hid_parse(hdev);
-        if (ret)
+        err = hid_parse(hdev);
+        if (err)
                 goto error;
 
-        ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
-        if (ret)
+        err = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
+        if (err)
                 goto error;
 
-        /* blink(1) serial numbers range is 0x1A001000 to 0x1A002FFF */
-        led = &data->led_cdev;
-        snprintf(led_name, sizeof(led_name), "blink1::%s", hdev->uniq + 4);
-        led->name = led_name;
-        led->brightness_set = blink1_led_set;
-        led->brightness_get = blink1_led_get;
-        ret = led_classdev_register(&hdev->dev, led);
-        if (ret)
+        mutex_init(&tdev->lock);
+
+        err = thingm_version(tdev);
+        if (err)
                 goto stop;
 
-        ret = sysfs_create_group(&led->dev->kobj, &blink1_sysfs_group);
-        if (ret)
-                goto remove_led;
+        hid_dbg(hdev, "firmware version: %c.%c\n",
+                        tdev->version.major, tdev->version.minor);
 
-        return 0;
+        for (i = 0; i < ARRAY_SIZE(thingm_fwinfo) && !tdev->fwinfo; ++i)
+                if (thingm_fwinfo[i].major == tdev->version.major)
+                        tdev->fwinfo = &thingm_fwinfo[i];
+
+        if (!tdev->fwinfo) {
+                hid_err(hdev, "unsupported firmware %c\n", tdev->version.major);
+                goto stop;
+        }
+
+        tdev->rgb = devm_kzalloc(&hdev->dev,
+                        sizeof(struct thingm_rgb) * tdev->fwinfo->numrgb,
+                        GFP_KERNEL);
+        if (!tdev->rgb) {
+                err = -ENOMEM;
+                goto stop;
+        }
+
+        for (i = 0; i < tdev->fwinfo->numrgb; ++i) {
+                struct thingm_rgb *rgb = tdev->rgb + i;
+
+                rgb->tdev = tdev;
+                rgb->num = tdev->fwinfo->first + i;
+                err = thingm_init_rgb(rgb);
+                if (err) {
+                        while (--i >= 0)
+                                thingm_remove_rgb(tdev->rgb + i);
+                        goto stop;
+                }
+        }
 
-remove_led:
-        led_classdev_unregister(led);
+        return 0;
 stop:
         hid_hw_stop(hdev);
 error:
-        return ret;
+        return err;
 }
 
 static void thingm_remove(struct hid_device *hdev)
 {
-        struct blink1_data *data = hid_get_drvdata(hdev);
-        struct led_classdev *led = &data->led_cdev;
+        struct thingm_device *tdev = hid_get_drvdata(hdev);
+        int i;
+
+        for (i = 0; i < tdev->fwinfo->numrgb; ++i)
+                thingm_remove_rgb(tdev->rgb + i);
 
-        sysfs_remove_group(&led->dev->kobj, &blink1_sysfs_group);
-        led_classdev_unregister(led);
         hid_hw_stop(hdev);
 }