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