2 * Simple USB RGB LED driver
4 * Copyright 2016 Heiner Kallweit <hkallweit1@gmail.com>
5 * Based on drivers/hid/hid-thingm.c and
6 * drivers/usb/misc/usbled.c
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as
10 * published by the Free Software Foundation, version 2.
13 #include <linux/hid.h>
14 #include <linux/hidraw.h>
15 #include <linux/leds.h>
16 #include <linux/module.h>
17 #include <linux/mutex.h>
21 enum hidled_report_type
{
33 static unsigned const char riso_kagaku_tbl
[] = {
34 /* R+2G+4B -> riso kagaku color index */
40 [5] = 6, /* magenta */
45 #define RISO_KAGAKU_IX(r, g, b) riso_kagaku_tbl[((r)?1:0)+((g)?2:0)+((b)?4:0)]
65 #define DELCOM_GREEN_LED 0
66 #define DELCOM_RED_LED 1
67 #define DELCOM_BLUE_LED 2
72 struct hidled_config
{
73 enum hidled_type type
;
75 const char *short_name
;
76 enum led_brightness max_brightness
;
79 enum hidled_report_type report_type
;
80 int (*init
)(struct hidled_device
*ldev
);
81 int (*write
)(struct led_classdev
*cdev
, enum led_brightness br
);
85 struct led_classdev cdev
;
86 struct hidled_rgb
*rgb
;
91 struct hidled_device
*ldev
;
92 struct hidled_led red
;
93 struct hidled_led green
;
94 struct hidled_led blue
;
98 struct hidled_device
{
99 const struct hidled_config
*config
;
100 struct hid_device
*hdev
;
101 struct hidled_rgb
*rgb
;
105 #define MAX_REPORT_SIZE 16
107 #define to_hidled_led(arg) container_of(arg, struct hidled_led, cdev)
109 static bool riso_kagaku_switch_green_blue
;
110 module_param(riso_kagaku_switch_green_blue
, bool, S_IRUGO
| S_IWUSR
);
111 MODULE_PARM_DESC(riso_kagaku_switch_green_blue
,
112 "switch green and blue RGB component for Riso Kagaku devices");
114 static int hidled_send(struct hidled_device
*ldev
, __u8
*buf
)
118 mutex_lock(&ldev
->lock
);
120 if (ldev
->config
->report_type
== RAW_REQUEST
)
121 ret
= hid_hw_raw_request(ldev
->hdev
, buf
[0], buf
,
122 ldev
->config
->report_size
,
125 else if (ldev
->config
->report_type
== OUTPUT_REPORT
)
126 ret
= hid_hw_output_report(ldev
->hdev
, buf
,
127 ldev
->config
->report_size
);
131 mutex_unlock(&ldev
->lock
);
136 return ret
== ldev
->config
->report_size
? 0 : -EMSGSIZE
;
139 /* reading data is supported for report type RAW_REQUEST only */
140 static int hidled_recv(struct hidled_device
*ldev
, __u8
*buf
)
144 if (ldev
->config
->report_type
!= RAW_REQUEST
)
147 mutex_lock(&ldev
->lock
);
149 ret
= hid_hw_raw_request(ldev
->hdev
, buf
[0], buf
,
150 ldev
->config
->report_size
,
156 ret
= hid_hw_raw_request(ldev
->hdev
, buf
[0], buf
,
157 ldev
->config
->report_size
,
161 mutex_unlock(&ldev
->lock
);
163 return ret
< 0 ? ret
: 0;
166 static u8
riso_kagaku_index(struct hidled_rgb
*rgb
)
168 enum led_brightness r
, g
, b
;
170 r
= rgb
->red
.cdev
.brightness
;
171 g
= rgb
->green
.cdev
.brightness
;
172 b
= rgb
->blue
.cdev
.brightness
;
174 if (riso_kagaku_switch_green_blue
)
175 return RISO_KAGAKU_IX(r
, b
, g
);
177 return RISO_KAGAKU_IX(r
, g
, b
);
180 static int riso_kagaku_write(struct led_classdev
*cdev
, enum led_brightness br
)
182 struct hidled_led
*led
= to_hidled_led(cdev
);
183 struct hidled_rgb
*rgb
= led
->rgb
;
184 __u8 buf
[MAX_REPORT_SIZE
] = {};
186 buf
[1] = riso_kagaku_index(rgb
);
188 return hidled_send(rgb
->ldev
, buf
);
191 static int dream_cheeky_write(struct led_classdev
*cdev
, enum led_brightness br
)
193 struct hidled_led
*led
= to_hidled_led(cdev
);
194 struct hidled_rgb
*rgb
= led
->rgb
;
195 __u8 buf
[MAX_REPORT_SIZE
] = {};
197 buf
[1] = rgb
->red
.cdev
.brightness
;
198 buf
[2] = rgb
->green
.cdev
.brightness
;
199 buf
[3] = rgb
->blue
.cdev
.brightness
;
203 return hidled_send(rgb
->ldev
, buf
);
206 static int dream_cheeky_init(struct hidled_device
*ldev
)
208 __u8 buf
[MAX_REPORT_SIZE
] = {};
210 /* Dream Cheeky magic */
217 return hidled_send(ldev
, buf
);
220 static int _thingm_write(struct led_classdev
*cdev
, enum led_brightness br
,
223 struct hidled_led
*led
= to_hidled_led(cdev
);
224 __u8 buf
[MAX_REPORT_SIZE
] = { 1, 'c' };
226 buf
[2] = led
->rgb
->red
.cdev
.brightness
;
227 buf
[3] = led
->rgb
->green
.cdev
.brightness
;
228 buf
[4] = led
->rgb
->blue
.cdev
.brightness
;
229 buf
[7] = led
->rgb
->num
+ offset
;
231 return hidled_send(led
->rgb
->ldev
, buf
);
234 static int thingm_write_v1(struct led_classdev
*cdev
, enum led_brightness br
)
236 return _thingm_write(cdev
, br
, 0);
239 static int thingm_write(struct led_classdev
*cdev
, enum led_brightness br
)
241 return _thingm_write(cdev
, br
, 1);
244 static const struct hidled_config hidled_config_thingm_v1
= {
245 .name
= "ThingM blink(1) v1",
246 .short_name
= "thingm",
247 .max_brightness
= 255,
250 .report_type
= RAW_REQUEST
,
251 .write
= thingm_write_v1
,
254 static int thingm_init(struct hidled_device
*ldev
)
256 __u8 buf
[MAX_REPORT_SIZE
] = { 1, 'v' };
259 ret
= hidled_recv(ldev
, buf
);
263 /* Check for firmware major version 1 */
265 ldev
->config
= &hidled_config_thingm_v1
;
270 static inline int delcom_get_lednum(const struct hidled_led
*led
)
272 if (led
== &led
->rgb
->red
)
273 return DELCOM_RED_LED
;
274 else if (led
== &led
->rgb
->green
)
275 return DELCOM_GREEN_LED
;
277 return DELCOM_BLUE_LED
;
280 static int delcom_enable_led(struct hidled_led
*led
)
282 union delcom_packet dp
= { .tx
.major_cmd
= 101, .tx
.minor_cmd
= 12 };
284 dp
.tx
.data_lsb
= 1 << delcom_get_lednum(led
);
287 return hidled_send(led
->rgb
->ldev
, dp
.data
);
290 static int delcom_set_pwm(struct hidled_led
*led
)
292 union delcom_packet dp
= { .tx
.major_cmd
= 101, .tx
.minor_cmd
= 34 };
294 dp
.tx
.data_lsb
= delcom_get_lednum(led
);
295 dp
.tx
.data_msb
= led
->cdev
.brightness
;
297 return hidled_send(led
->rgb
->ldev
, dp
.data
);
300 static int delcom_write(struct led_classdev
*cdev
, enum led_brightness br
)
302 struct hidled_led
*led
= to_hidled_led(cdev
);
307 * We can't do this in the init function already because the device
308 * is internally reset later.
310 ret
= delcom_enable_led(led
);
314 return delcom_set_pwm(led
);
317 static int delcom_init(struct hidled_device
*ldev
)
319 union delcom_packet dp
= { .rx
.cmd
= 104 };
322 ret
= hidled_recv(ldev
, dp
.data
);
326 * Several Delcom devices share the same USB VID/PID
327 * Check for family id 2 for Visual Signal Indicator
329 return dp
.fw
.family_code
== 2 ? 0 : -ENODEV
;
332 static const struct hidled_config hidled_configs
[] = {
335 .name
= "Riso Kagaku Webmail Notifier",
336 .short_name
= "riso_kagaku",
340 .report_type
= OUTPUT_REPORT
,
341 .write
= riso_kagaku_write
,
344 .type
= DREAM_CHEEKY
,
345 .name
= "Dream Cheeky Webmail Notifier",
346 .short_name
= "dream_cheeky",
347 .max_brightness
= 31,
350 .report_type
= RAW_REQUEST
,
351 .init
= dream_cheeky_init
,
352 .write
= dream_cheeky_write
,
356 .name
= "ThingM blink(1)",
357 .short_name
= "thingm",
358 .max_brightness
= 255,
361 .report_type
= RAW_REQUEST
,
363 .write
= thingm_write
,
367 .name
= "Delcom Visual Signal Indicator G2",
368 .short_name
= "delcom",
369 .max_brightness
= 100,
372 .report_type
= RAW_REQUEST
,
374 .write
= delcom_write
,
378 static int hidled_init_led(struct hidled_led
*led
, const char *color_name
,
379 struct hidled_rgb
*rgb
, unsigned int minor
)
381 const struct hidled_config
*config
= rgb
->ldev
->config
;
383 if (config
->num_leds
> 1)
384 snprintf(led
->name
, sizeof(led
->name
), "%s%u:%s:led%u",
385 config
->short_name
, minor
, color_name
, rgb
->num
);
387 snprintf(led
->name
, sizeof(led
->name
), "%s%u:%s",
388 config
->short_name
, minor
, color_name
);
389 led
->cdev
.name
= led
->name
;
390 led
->cdev
.max_brightness
= config
->max_brightness
;
391 led
->cdev
.brightness_set_blocking
= config
->write
;
392 led
->cdev
.flags
= LED_HW_PLUGGABLE
;
395 return devm_led_classdev_register(&rgb
->ldev
->hdev
->dev
, &led
->cdev
);
398 static int hidled_init_rgb(struct hidled_rgb
*rgb
, unsigned int minor
)
402 /* Register the red diode */
403 ret
= hidled_init_led(&rgb
->red
, "red", rgb
, minor
);
407 /* Register the green diode */
408 ret
= hidled_init_led(&rgb
->green
, "green", rgb
, minor
);
412 /* Register the blue diode */
413 return hidled_init_led(&rgb
->blue
, "blue", rgb
, minor
);
416 static int hidled_probe(struct hid_device
*hdev
, const struct hid_device_id
*id
)
418 struct hidled_device
*ldev
;
422 ldev
= devm_kzalloc(&hdev
->dev
, sizeof(*ldev
), GFP_KERNEL
);
426 ret
= hid_parse(hdev
);
431 mutex_init(&ldev
->lock
);
433 for (i
= 0; !ldev
->config
&& i
< ARRAY_SIZE(hidled_configs
); i
++)
434 if (hidled_configs
[i
].type
== id
->driver_data
)
435 ldev
->config
= &hidled_configs
[i
];
440 if (ldev
->config
->init
) {
441 ret
= ldev
->config
->init(ldev
);
446 ldev
->rgb
= devm_kcalloc(&hdev
->dev
, ldev
->config
->num_leds
,
447 sizeof(struct hidled_rgb
), GFP_KERNEL
);
451 ret
= hid_hw_start(hdev
, HID_CONNECT_HIDRAW
);
455 minor
= ((struct hidraw
*) hdev
->hidraw
)->minor
;
457 for (i
= 0; i
< ldev
->config
->num_leds
; i
++) {
458 ldev
->rgb
[i
].ldev
= ldev
;
459 ldev
->rgb
[i
].num
= i
;
460 ret
= hidled_init_rgb(&ldev
->rgb
[i
], minor
);
467 hid_info(hdev
, "%s initialized\n", ldev
->config
->name
);
472 static const struct hid_device_id hidled_table
[] = {
473 { HID_USB_DEVICE(USB_VENDOR_ID_RISO_KAGAKU
,
474 USB_DEVICE_ID_RI_KA_WEBMAIL
), .driver_data
= RISO_KAGAKU
},
475 { HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY
,
476 USB_DEVICE_ID_DREAM_CHEEKY_WN
), .driver_data
= DREAM_CHEEKY
},
477 { HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY
,
478 USB_DEVICE_ID_DREAM_CHEEKY_FA
), .driver_data
= DREAM_CHEEKY
},
479 { HID_USB_DEVICE(USB_VENDOR_ID_THINGM
,
480 USB_DEVICE_ID_BLINK1
), .driver_data
= THINGM
},
481 { HID_USB_DEVICE(USB_VENDOR_ID_DELCOM
,
482 USB_DEVICE_ID_DELCOM_VISUAL_IND
), .driver_data
= DELCOM
},
485 MODULE_DEVICE_TABLE(hid
, hidled_table
);
487 static struct hid_driver hidled_driver
= {
489 .probe
= hidled_probe
,
490 .id_table
= hidled_table
,
493 module_hid_driver(hidled_driver
);
495 MODULE_LICENSE("GPL");
496 MODULE_AUTHOR("Heiner Kallweit <hkallweit1@gmail.com>");
497 MODULE_DESCRIPTION("Simple USB RGB LED driver");