Version:  2.0.40 2.2.26 2.4.37 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6

Linux/drivers/hid/hid-thingm.c

  1 /*
  2  * ThingM blink(1) USB RGB LED driver
  3  *
  4  * Copyright 2013-2014 Savoir-faire Linux Inc.
  5  *      Vivien Didelot <vivien.didelot@savoirfairelinux.com>
  6  *
  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.
 10  */
 11 
 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>
 17 
 18 #include "hid-ids.h"
 19 
 20 #define REPORT_ID       1
 21 #define REPORT_SIZE     9
 22 
 23 /* Firmware major number of supported devices */
 24 #define THINGM_MAJOR_MK1        '1'
 25 #define THINGM_MAJOR_MK2        '2'
 26 
 27 struct thingm_fwinfo {
 28         char major;
 29         unsigned numrgb;
 30         unsigned first;
 31 };
 32 
 33 static const struct thingm_fwinfo thingm_fwinfo[] = {
 34         {
 35                 .major = THINGM_MAJOR_MK1,
 36                 .numrgb = 1,
 37                 .first = 0,
 38         }, {
 39                 .major = THINGM_MAJOR_MK2,
 40                 .numrgb = 2,
 41                 .first = 1,
 42         }
 43 };
 44 
 45 /* A red, green or blue channel, part of an RGB chip */
 46 struct thingm_led {
 47         struct thingm_rgb *rgb;
 48         struct led_classdev ldev;
 49         char name[32];
 50 };
 51 
 52 /* Basically a WS2812 5050 RGB LED chip */
 53 struct thingm_rgb {
 54         struct thingm_device *tdev;
 55         struct thingm_led red;
 56         struct thingm_led green;
 57         struct thingm_led blue;
 58         u8 num;
 59 };
 60 
 61 struct thingm_device {
 62         struct hid_device *hdev;
 63         struct {
 64                 char major;
 65                 char minor;
 66         } version;
 67         const struct thingm_fwinfo *fwinfo;
 68         struct mutex lock;
 69         struct thingm_rgb *rgb;
 70 };
 71 
 72 static int thingm_send(struct thingm_device *tdev, u8 buf[REPORT_SIZE])
 73 {
 74         int ret;
 75 
 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]);
 79 
 80         mutex_lock(&tdev->lock);
 81 
 82         ret = hid_hw_raw_request(tdev->hdev, buf[0], buf, REPORT_SIZE,
 83                         HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
 84 
 85         mutex_unlock(&tdev->lock);
 86 
 87         return ret < 0 ? ret : 0;
 88 }
 89 
 90 static int thingm_recv(struct thingm_device *tdev, u8 buf[REPORT_SIZE])
 91 {
 92         int ret;
 93 
 94         /*
 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.
 98          */
 99         mutex_lock(&tdev->lock);
100 
101         ret = hid_hw_raw_request(tdev->hdev, buf[0], buf, REPORT_SIZE,
102                         HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
103         if (ret < 0)
104                 goto err;
105 
106         ret = hid_hw_raw_request(tdev->hdev, buf[0], buf, REPORT_SIZE,
107                         HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
108         if (ret < 0)
109                 goto err;
110 
111         ret = 0;
112 
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]);
116 err:
117         mutex_unlock(&tdev->lock);
118         return ret;
119 }
120 
121 static int thingm_version(struct thingm_device *tdev)
122 {
123         u8 buf[REPORT_SIZE] = { REPORT_ID, 'v', 0, 0, 0, 0, 0, 0, 0 };
124         int err;
125 
126         err = thingm_recv(tdev, buf);
127         if (err)
128                 return err;
129 
130         tdev->version.major = buf[3];
131         tdev->version.minor = buf[4];
132 
133         return 0;
134 }
135 
136 static int thingm_write_color(struct thingm_rgb *rgb)
137 {
138         u8 buf[REPORT_SIZE] = { REPORT_ID, 'c', 0, 0, 0, 0, 0, rgb->num, 0 };
139 
140         buf[2] = rgb->red.ldev.brightness;
141         buf[3] = rgb->green.ldev.brightness;
142         buf[4] = rgb->blue.ldev.brightness;
143 
144         return thingm_send(rgb->tdev, buf);
145 }
146 
147 static int thingm_led_set(struct led_classdev *ldev,
148                           enum led_brightness brightness)
149 {
150         struct thingm_led *led = container_of(ldev, struct thingm_led, ldev);
151         int ret;
152 
153         ret = thingm_write_color(led->rgb);
154         if (ret)
155                 hid_err(led->rgb->tdev->hdev, "failed to write color\n");
156 
157         return ret;
158 }
159 
160 static int thingm_init_rgb(struct thingm_rgb *rgb)
161 {
162         const int minor = ((struct hidraw *) rgb->tdev->hdev->hidraw)->minor;
163         int err;
164 
165         /* Register the red diode */
166         snprintf(rgb->red.name, sizeof(rgb->red.name),
167                         "thingm%d:red:led%d", minor, rgb->num);
168         rgb->red.ldev.name = rgb->red.name;
169         rgb->red.ldev.max_brightness = 255;
170         rgb->red.ldev.brightness_set_blocking = thingm_led_set;
171         rgb->red.rgb = rgb;
172 
173         err = devm_led_classdev_register(&rgb->tdev->hdev->dev,
174                                          &rgb->red.ldev);
175         if (err)
176                 return err;
177 
178         /* Register the green diode */
179         snprintf(rgb->green.name, sizeof(rgb->green.name),
180                         "thingm%d:green:led%d", minor, rgb->num);
181         rgb->green.ldev.name = rgb->green.name;
182         rgb->green.ldev.max_brightness = 255;
183         rgb->green.ldev.brightness_set_blocking = thingm_led_set;
184         rgb->green.rgb = rgb;
185 
186         err = devm_led_classdev_register(&rgb->tdev->hdev->dev,
187                                          &rgb->green.ldev);
188         if (err)
189                 return err;
190 
191         /* Register the blue diode */
192         snprintf(rgb->blue.name, sizeof(rgb->blue.name),
193                         "thingm%d:blue:led%d", minor, rgb->num);
194         rgb->blue.ldev.name = rgb->blue.name;
195         rgb->blue.ldev.max_brightness = 255;
196         rgb->blue.ldev.brightness_set_blocking = thingm_led_set;
197         rgb->blue.rgb = rgb;
198 
199         err = devm_led_classdev_register(&rgb->tdev->hdev->dev,
200                                          &rgb->blue.ldev);
201         return err;
202 }
203 
204 static int thingm_probe(struct hid_device *hdev, const struct hid_device_id *id)
205 {
206         struct thingm_device *tdev;
207         int i, err;
208 
209         tdev = devm_kzalloc(&hdev->dev, sizeof(struct thingm_device),
210                         GFP_KERNEL);
211         if (!tdev)
212                 return -ENOMEM;
213 
214         tdev->hdev = hdev;
215         hid_set_drvdata(hdev, tdev);
216 
217         err = hid_parse(hdev);
218         if (err)
219                 return err;
220 
221         mutex_init(&tdev->lock);
222 
223         err = thingm_version(tdev);
224         if (err)
225                 return err;
226 
227         hid_dbg(hdev, "firmware version: %c.%c\n",
228                         tdev->version.major, tdev->version.minor);
229 
230         for (i = 0; i < ARRAY_SIZE(thingm_fwinfo) && !tdev->fwinfo; ++i)
231                 if (thingm_fwinfo[i].major == tdev->version.major)
232                         tdev->fwinfo = &thingm_fwinfo[i];
233 
234         if (!tdev->fwinfo) {
235                 hid_err(hdev, "unsupported firmware %c\n", tdev->version.major);
236                 return -ENODEV;
237         }
238 
239         tdev->rgb = devm_kzalloc(&hdev->dev,
240                         sizeof(struct thingm_rgb) * tdev->fwinfo->numrgb,
241                         GFP_KERNEL);
242         if (!tdev->rgb)
243                 return -ENOMEM;
244 
245         err = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
246         if (err)
247                 return err;
248 
249         for (i = 0; i < tdev->fwinfo->numrgb; ++i) {
250                 struct thingm_rgb *rgb = tdev->rgb + i;
251 
252                 rgb->tdev = tdev;
253                 rgb->num = tdev->fwinfo->first + i;
254                 err = thingm_init_rgb(rgb);
255                 if (err) {
256                         hid_hw_stop(hdev);
257                         return err;
258                 }
259         }
260 
261         return 0;
262 }
263 
264 static const struct hid_device_id thingm_table[] = {
265         { HID_USB_DEVICE(USB_VENDOR_ID_THINGM, USB_DEVICE_ID_BLINK1) },
266         { }
267 };
268 MODULE_DEVICE_TABLE(hid, thingm_table);
269 
270 static struct hid_driver thingm_driver = {
271         .name = "thingm",
272         .probe = thingm_probe,
273         .id_table = thingm_table,
274 };
275 
276 module_hid_driver(thingm_driver);
277 
278 MODULE_LICENSE("GPL");
279 MODULE_AUTHOR("Vivien Didelot <vivien.didelot@savoirfairelinux.com>");
280 MODULE_DESCRIPTION("ThingM blink(1) USB RGB LED driver");
281 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us