2 * ThingM blink(1) USB RGB LED driver
4 * Copyright 2013-2014 Savoir-faire Linux Inc.
5 * Vivien Didelot <vivien.didelot@savoirfairelinux.com>
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License as
9 * published by the Free Software Foundation, version 2.
12 #include <linux/hid.h>
13 #include <linux/hidraw.h>
14 #include <linux/leds.h>
15 #include <linux/module.h>
16 #include <linux/mutex.h>
23 /* Firmware major number of supported devices */
24 #define THINGM_MAJOR_MK1 '1'
25 #define THINGM_MAJOR_MK2 '2'
27 struct thingm_fwinfo {
33 static const struct thingm_fwinfo thingm_fwinfo[] = {
35 .major = THINGM_MAJOR_MK1,
39 .major = THINGM_MAJOR_MK2,
45 /* A red, green or blue channel, part of an RGB chip */
47 struct thingm_rgb *rgb;
48 struct led_classdev ldev;
52 /* Basically a WS2812 5050 RGB LED chip */
54 struct thingm_device *tdev;
55 struct thingm_led red;
56 struct thingm_led green;
57 struct thingm_led blue;
61 struct thingm_device {
62 struct hid_device *hdev;
67 const struct thingm_fwinfo *fwinfo;
69 struct thingm_rgb *rgb;
72 static int thingm_send(struct thingm_device *tdev, u8 buf[REPORT_SIZE])
76 hid_dbg(tdev->hdev, "-> %d %c %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx\n",
77 buf[0], buf[1], buf[2], buf[3], buf[4],
78 buf[5], buf[6], buf[7], buf[8]);
80 mutex_lock(&tdev->lock);
82 ret = hid_hw_raw_request(tdev->hdev, buf[0], buf, REPORT_SIZE,
83 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
85 mutex_unlock(&tdev->lock);
87 return ret < 0 ? ret : 0;
90 static int thingm_recv(struct thingm_device *tdev, u8 buf[REPORT_SIZE])
95 * A read consists of two operations: sending the read command
96 * and the actual read from the device. Use the mutex to protect
97 * the full sequence of both operations.
99 mutex_lock(&tdev->lock);
101 ret = hid_hw_raw_request(tdev->hdev, buf[0], buf, REPORT_SIZE,
102 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
106 ret = hid_hw_raw_request(tdev->hdev, buf[0], buf, REPORT_SIZE,
107 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
113 hid_dbg(tdev->hdev, "<- %d %c %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx\n",
114 buf[0], buf[1], buf[2], buf[3], buf[4],
115 buf[5], buf[6], buf[7], buf[8]);
117 mutex_unlock(&tdev->lock);
121 static int thingm_version(struct thingm_device *tdev)
123 u8 buf[REPORT_SIZE] = { REPORT_ID, 'v', 0, 0, 0, 0, 0, 0, 0 };
126 err = thingm_recv(tdev, buf);
130 tdev->version.major = buf[3];
131 tdev->version.minor = buf[4];
136 static int thingm_write_color(struct thingm_rgb *rgb)
138 u8 buf[REPORT_SIZE] = { REPORT_ID, 'c', 0, 0, 0, 0, 0, rgb->num, 0 };
140 buf[2] = rgb->red.ldev.brightness;
141 buf[3] = rgb->green.ldev.brightness;
142 buf[4] = rgb->blue.ldev.brightness;
144 return thingm_send(rgb->tdev, buf);
147 static int thingm_led_set(struct led_classdev *ldev,
148 enum led_brightness brightness)
150 struct thingm_led *led = container_of(ldev, struct thingm_led, ldev);
152 return thingm_write_color(led->rgb);
155 static int thingm_init_led(struct thingm_led *led, const char *color_name,
156 struct thingm_rgb *rgb, int minor)
158 snprintf(led->name, sizeof(led->name), "thingm%d:%s:led%d",
159 minor, color_name, rgb->num);
160 led->ldev.name = led->name;
161 led->ldev.max_brightness = 255;
162 led->ldev.brightness_set_blocking = thingm_led_set;
163 led->ldev.flags = LED_HW_PLUGGABLE;
165 return devm_led_classdev_register(&rgb->tdev->hdev->dev, &led->ldev);
168 static int thingm_init_rgb(struct thingm_rgb *rgb)
170 const int minor = ((struct hidraw *) rgb->tdev->hdev->hidraw)->minor;
173 /* Register the red diode */
174 err = thingm_init_led(&rgb->red, "red", rgb, minor);
178 /* Register the green diode */
179 err = thingm_init_led(&rgb->green, "green", rgb, minor);
183 /* Register the blue diode */
184 return thingm_init_led(&rgb->blue, "blue", rgb, minor);
187 static int thingm_probe(struct hid_device *hdev, const struct hid_device_id *id)
189 struct thingm_device *tdev;
192 tdev = devm_kzalloc(&hdev->dev, sizeof(struct thingm_device),
198 hid_set_drvdata(hdev, tdev);
200 err = hid_parse(hdev);
204 mutex_init(&tdev->lock);
206 err = thingm_version(tdev);
210 hid_dbg(hdev, "firmware version: %c.%c\n",
211 tdev->version.major, tdev->version.minor);
213 for (i = 0; i < ARRAY_SIZE(thingm_fwinfo) && !tdev->fwinfo; ++i)
214 if (thingm_fwinfo[i].major == tdev->version.major)
215 tdev->fwinfo = &thingm_fwinfo[i];
218 hid_err(hdev, "unsupported firmware %c\n", tdev->version.major);
222 tdev->rgb = devm_kzalloc(&hdev->dev,
223 sizeof(struct thingm_rgb) * tdev->fwinfo->numrgb,
228 err = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
232 for (i = 0; i < tdev->fwinfo->numrgb; ++i) {
233 struct thingm_rgb *rgb = tdev->rgb + i;
236 rgb->num = tdev->fwinfo->first + i;
237 err = thingm_init_rgb(rgb);
247 static const struct hid_device_id thingm_table[] = {
248 { HID_USB_DEVICE(USB_VENDOR_ID_THINGM, USB_DEVICE_ID_BLINK1) },
251 MODULE_DEVICE_TABLE(hid, thingm_table);
253 static struct hid_driver thingm_driver = {
255 .probe = thingm_probe,
256 .id_table = thingm_table,
259 module_hid_driver(thingm_driver);
261 MODULE_LICENSE("GPL");
262 MODULE_AUTHOR("Vivien Didelot <vivien.didelot@savoirfairelinux.com>");
263 MODULE_DESCRIPTION("ThingM blink(1) USB RGB LED driver");