HID: add ThingM blink(1) USB RGB LED support
[linux-3.10.git] / drivers / hid / hid-thingm.c
1 /*
2  * ThingM blink(1) USB RGB LED driver
3  *
4  * Copyright 2013 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/leds.h>
14 #include <linux/module.h>
15 #include <linux/usb.h>
16
17 #include "hid-ids.h"
18
19 #define BLINK1_CMD_SIZE         9
20
21 #define blink1_rgb_to_r(rgb)    ((rgb & 0xFF0000) >> 16)
22 #define blink1_rgb_to_g(rgb)    ((rgb & 0x00FF00) >> 8)
23 #define blink1_rgb_to_b(rgb)    ((rgb & 0x0000FF) >> 0)
24
25 /**
26  * struct blink1_data - blink(1) device specific data
27  * @hdev:               HID device.
28  * @led_cdev:           LED class instance.
29  * @rgb:                8-bit per channel RGB notation.
30  * @fade:               fade time in hundredths of a second.
31  * @brightness:         brightness coefficient.
32  * @play:               play/pause in-memory patterns.
33  */
34 struct blink1_data {
35         struct hid_device *hdev;
36         struct led_classdev led_cdev;
37         u32 rgb;
38         u16 fade;
39         u8 brightness;
40         bool play;
41 };
42
43 static int blink1_send_command(struct blink1_data *data,
44                 u8 buf[BLINK1_CMD_SIZE])
45 {
46         int ret;
47
48         hid_dbg(data->hdev, "command: %d%c%.2x%.2x%.2x%.2x%.2x%.2x%.2x\n",
49                         buf[0], buf[1], buf[2], buf[3], buf[4],
50                         buf[5], buf[6], buf[7], buf[8]);
51
52         ret = data->hdev->hid_output_raw_report(data->hdev, buf,
53                         BLINK1_CMD_SIZE, HID_FEATURE_REPORT);
54
55         return ret < 0 ? ret : 0;
56 }
57
58 static int blink1_update_color(struct blink1_data *data)
59 {
60         u8 buf[BLINK1_CMD_SIZE] = { 1, 'n', 0, 0, 0, 0, 0, 0, 0 };
61
62         if (data->brightness) {
63                 unsigned int coef = DIV_ROUND_CLOSEST(255, data->brightness);
64
65                 buf[2] = DIV_ROUND_CLOSEST(blink1_rgb_to_r(data->rgb), coef);
66                 buf[3] = DIV_ROUND_CLOSEST(blink1_rgb_to_g(data->rgb), coef);
67                 buf[4] = DIV_ROUND_CLOSEST(blink1_rgb_to_b(data->rgb), coef);
68         }
69
70         if (data->fade) {
71                 buf[1] = 'c';
72                 buf[5] = (data->fade & 0xFF00) >> 8;
73                 buf[6] = (data->fade & 0x00FF);
74         }
75
76         return blink1_send_command(data, buf);
77 }
78
79 static void blink1_led_set(struct led_classdev *led_cdev,
80                 enum led_brightness brightness)
81 {
82         struct blink1_data *data = dev_get_drvdata(led_cdev->dev->parent);
83
84         data->brightness = brightness;
85         if (blink1_update_color(data))
86                 hid_err(data->hdev, "failed to update color\n");
87 }
88
89 static enum led_brightness blink1_led_get(struct led_classdev *led_cdev)
90 {
91         struct blink1_data *data = dev_get_drvdata(led_cdev->dev->parent);
92
93         return data->brightness;
94 }
95
96 static ssize_t blink1_show_rgb(struct device *dev,
97                 struct device_attribute *attr, char *buf)
98 {
99         struct blink1_data *data = dev_get_drvdata(dev->parent);
100
101         return sprintf(buf, "%.6X\n", data->rgb);
102 }
103
104 static ssize_t blink1_store_rgb(struct device *dev,
105                 struct device_attribute *attr, const char *buf, size_t count)
106 {
107         struct blink1_data *data = dev_get_drvdata(dev->parent);
108         long unsigned int rgb;
109         int ret;
110
111         ret = kstrtoul(buf, 16, &rgb);
112         if (ret)
113                 return ret;
114
115         /* RGB triplet notation is 24-bit hexadecimal */
116         if (rgb > 0xFFFFFF)
117                 return -EINVAL;
118
119         data->rgb = rgb;
120         ret = blink1_update_color(data);
121
122         return ret ? ret : count;
123 }
124
125 static DEVICE_ATTR(rgb, S_IRUGO | S_IWUSR, blink1_show_rgb, blink1_store_rgb);
126
127 static ssize_t blink1_show_fade(struct device *dev,
128                 struct device_attribute *attr, char *buf)
129 {
130         struct blink1_data *data = dev_get_drvdata(dev->parent);
131
132         return sprintf(buf, "%d\n", data->fade * 10);
133 }
134
135 static ssize_t blink1_store_fade(struct device *dev,
136                 struct device_attribute *attr, const char *buf, size_t count)
137 {
138         struct blink1_data *data = dev_get_drvdata(dev->parent);
139         long unsigned int fade;
140         int ret;
141
142         ret = kstrtoul(buf, 10, &fade);
143         if (ret)
144                 return ret;
145
146         /* blink(1) accepts 16-bit fade time, number of 10ms ticks */
147         fade = DIV_ROUND_CLOSEST(fade, 10);
148         if (fade > 65535)
149                 return -EINVAL;
150
151         data->fade = fade;
152
153         return count;
154 }
155
156 static DEVICE_ATTR(fade, S_IRUGO | S_IWUSR,
157                 blink1_show_fade, blink1_store_fade);
158
159 static ssize_t blink1_show_play(struct device *dev,
160                 struct device_attribute *attr, char *buf)
161 {
162         struct blink1_data *data = dev_get_drvdata(dev->parent);
163
164         return sprintf(buf, "%d\n", data->play);
165 }
166
167 static ssize_t blink1_store_play(struct device *dev,
168                 struct device_attribute *attr, const char *buf, size_t count)
169 {
170         struct blink1_data *data = dev_get_drvdata(dev->parent);
171         u8 cmd[BLINK1_CMD_SIZE] = { 1, 'p', 0, 0, 0, 0, 0, 0, 0 };
172         long unsigned int play;
173         int ret;
174
175         ret = kstrtoul(buf, 10, &play);
176         if (ret)
177                 return ret;
178
179         data->play = !!play;
180         cmd[2] = data->play;
181         ret = blink1_send_command(data, cmd);
182
183         return ret ? ret : count;
184 }
185
186 static DEVICE_ATTR(play, S_IRUGO | S_IWUSR,
187                 blink1_show_play, blink1_store_play);
188
189 static const struct attribute_group blink1_sysfs_group = {
190         .attrs = (struct attribute *[]) {
191                 &dev_attr_rgb.attr,
192                 &dev_attr_fade.attr,
193                 &dev_attr_play.attr,
194                 NULL
195         },
196 };
197
198 static int thingm_probe(struct hid_device *hdev, const struct hid_device_id *id)
199 {
200         struct blink1_data *data;
201         struct led_classdev *led;
202         char led_name[13];
203         int ret;
204
205         data = devm_kzalloc(&hdev->dev, sizeof(struct blink1_data), GFP_KERNEL);
206         if (!data)
207                 return -ENOMEM;
208
209         hid_set_drvdata(hdev, data);
210         data->hdev = hdev;
211         data->rgb = 0xFFFFFF; /* set a default white color */
212
213         ret = hid_parse(hdev);
214         if (ret)
215                 goto error;
216
217         ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
218         if (ret)
219                 goto error;
220
221         /* blink(1) serial numbers range is 0x1A001000 to 0x1A002FFF */
222         led = &data->led_cdev;
223         snprintf(led_name, sizeof(led_name), "blink1::%s", hdev->uniq + 4);
224         led->name = led_name;
225         led->brightness_set = blink1_led_set;
226         led->brightness_get = blink1_led_get;
227         ret = led_classdev_register(&hdev->dev, led);
228         if (ret)
229                 goto stop;
230
231         ret = sysfs_create_group(&led->dev->kobj, &blink1_sysfs_group);
232         if (ret)
233                 goto remove_led;
234
235         return 0;
236
237 remove_led:
238         led_classdev_unregister(led);
239 stop:
240         hid_hw_stop(hdev);
241 error:
242         return ret;
243 }
244
245 static void thingm_remove(struct hid_device *hdev)
246 {
247         struct blink1_data *data = hid_get_drvdata(hdev);
248         struct led_classdev *led = &data->led_cdev;
249
250         sysfs_remove_group(&led->dev->kobj, &blink1_sysfs_group);
251         led_classdev_unregister(led);
252         hid_hw_stop(hdev);
253 }
254
255 static const struct hid_device_id thingm_table[] = {
256         { HID_USB_DEVICE(USB_VENDOR_ID_THINGM, USB_DEVICE_ID_BLINK1) },
257         { }
258 };
259 MODULE_DEVICE_TABLE(hid, thingm_table);
260
261 static struct hid_driver thingm_driver = {
262         .name = "thingm",
263         .probe = thingm_probe,
264         .remove = thingm_remove,
265         .id_table = thingm_table,
266 };
267
268 module_hid_driver(thingm_driver);
269
270 MODULE_LICENSE("GPL");
271 MODULE_AUTHOR("Vivien Didelot <vivien.didelot@savoirfairelinux.com>");
272 MODULE_DESCRIPTION("ThingM blink(1) USB RGB LED driver");