2 * Roccat Isku driver for Linux
4 * Copyright (c) 2011 Stefan Achatz <erazor_de@users.sourceforge.net>
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the Free
10 * Software Foundation; either version 2 of the License, or (at your option)
15 * Roccat Isku is a gamer keyboard with macro keys that can be configured in
19 #include <linux/device.h>
20 #include <linux/input.h>
21 #include <linux/hid.h>
22 #include <linux/module.h>
23 #include <linux/slab.h>
24 #include <linux/hid-roccat.h>
26 #include "hid-roccat-common.h"
27 #include "hid-roccat-isku.h"
29 static struct class *isku_class
;
31 static void isku_profile_activated(struct isku_device
*isku
, uint new_profile
)
33 isku
->actual_profile
= new_profile
;
36 static int isku_receive(struct usb_device
*usb_dev
, uint command
,
39 return roccat_common2_receive(usb_dev
, command
, buf
, size
);
42 static int isku_get_actual_profile(struct usb_device
*usb_dev
)
44 struct isku_actual_profile buf
;
47 retval
= isku_receive(usb_dev
, ISKU_COMMAND_ACTUAL_PROFILE
,
48 &buf
, sizeof(struct isku_actual_profile
));
49 return retval
? retval
: buf
.actual_profile
;
52 static int isku_set_actual_profile(struct usb_device
*usb_dev
, int new_profile
)
54 struct isku_actual_profile buf
;
56 buf
.command
= ISKU_COMMAND_ACTUAL_PROFILE
;
57 buf
.size
= sizeof(struct isku_actual_profile
);
58 buf
.actual_profile
= new_profile
;
59 return roccat_common2_send_with_status(usb_dev
,
60 ISKU_COMMAND_ACTUAL_PROFILE
, &buf
,
61 sizeof(struct isku_actual_profile
));
64 static ssize_t
isku_sysfs_show_actual_profile(struct device
*dev
,
65 struct device_attribute
*attr
, char *buf
)
67 struct isku_device
*isku
=
68 hid_get_drvdata(dev_get_drvdata(dev
->parent
->parent
));
69 return snprintf(buf
, PAGE_SIZE
, "%d\n", isku
->actual_profile
);
72 static ssize_t
isku_sysfs_set_actual_profile(struct device
*dev
,
73 struct device_attribute
*attr
, char const *buf
, size_t size
)
75 struct isku_device
*isku
;
76 struct usb_device
*usb_dev
;
77 unsigned long profile
;
79 struct isku_roccat_report roccat_report
;
81 dev
= dev
->parent
->parent
;
82 isku
= hid_get_drvdata(dev_get_drvdata(dev
));
83 usb_dev
= interface_to_usbdev(to_usb_interface(dev
));
85 retval
= strict_strtoul(buf
, 10, &profile
);
92 mutex_lock(&isku
->isku_lock
);
94 retval
= isku_set_actual_profile(usb_dev
, profile
);
96 mutex_unlock(&isku
->isku_lock
);
100 isku_profile_activated(isku
, profile
);
102 roccat_report
.event
= ISKU_REPORT_BUTTON_EVENT_PROFILE
;
103 roccat_report
.data1
= profile
+ 1;
104 roccat_report
.data2
= 0;
105 roccat_report
.profile
= profile
+ 1;
106 roccat_report_event(isku
->chrdev_minor
, (uint8_t const *)&roccat_report
);
108 mutex_unlock(&isku
->isku_lock
);
112 static DEVICE_ATTR(actual_profile
, 0660, isku_sysfs_show_actual_profile
,
113 isku_sysfs_set_actual_profile
);
115 static struct attribute
*isku_attrs
[] = {
116 &dev_attr_actual_profile
.attr
,
119 ATTRIBUTE_GROUPS(isku
);
121 static ssize_t
isku_sysfs_read(struct file
*fp
, struct kobject
*kobj
,
122 char *buf
, loff_t off
, size_t count
,
123 size_t real_size
, uint command
)
126 container_of(kobj
, struct device
, kobj
)->parent
->parent
;
127 struct isku_device
*isku
= hid_get_drvdata(dev_get_drvdata(dev
));
128 struct usb_device
*usb_dev
= interface_to_usbdev(to_usb_interface(dev
));
131 if (off
>= real_size
)
134 if (off
!= 0 || count
> real_size
)
137 mutex_lock(&isku
->isku_lock
);
138 retval
= isku_receive(usb_dev
, command
, buf
, count
);
139 mutex_unlock(&isku
->isku_lock
);
141 return retval
? retval
: count
;
144 static ssize_t
isku_sysfs_write(struct file
*fp
, struct kobject
*kobj
,
145 void const *buf
, loff_t off
, size_t count
,
146 size_t real_size
, uint command
)
149 container_of(kobj
, struct device
, kobj
)->parent
->parent
;
150 struct isku_device
*isku
= hid_get_drvdata(dev_get_drvdata(dev
));
151 struct usb_device
*usb_dev
= interface_to_usbdev(to_usb_interface(dev
));
154 if (off
!= 0 || count
> real_size
)
157 mutex_lock(&isku
->isku_lock
);
158 retval
= roccat_common2_send_with_status(usb_dev
, command
,
160 mutex_unlock(&isku
->isku_lock
);
162 return retval
? retval
: count
;
165 #define ISKU_SYSFS_W(thingy, THINGY) \
166 static ssize_t isku_sysfs_write_ ## thingy(struct file *fp, struct kobject *kobj, \
167 struct bin_attribute *attr, char *buf, \
168 loff_t off, size_t count) \
170 return isku_sysfs_write(fp, kobj, buf, off, count, \
171 ISKU_SIZE_ ## THINGY, ISKU_COMMAND_ ## THINGY); \
174 #define ISKU_SYSFS_R(thingy, THINGY) \
175 static ssize_t isku_sysfs_read_ ## thingy(struct file *fp, struct kobject *kobj, \
176 struct bin_attribute *attr, char *buf, \
177 loff_t off, size_t count) \
179 return isku_sysfs_read(fp, kobj, buf, off, count, \
180 ISKU_SIZE_ ## THINGY, ISKU_COMMAND_ ## THINGY); \
183 #define ISKU_SYSFS_RW(thingy, THINGY) \
184 ISKU_SYSFS_R(thingy, THINGY) \
185 ISKU_SYSFS_W(thingy, THINGY)
187 #define ISKU_BIN_ATTR_RW(thingy, THINGY) \
189 .attr = { .name = #thingy, .mode = 0660 }, \
190 .size = ISKU_SIZE_ ## THINGY, \
191 .read = isku_sysfs_read_ ## thingy, \
192 .write = isku_sysfs_write_ ## thingy \
195 #define ISKU_BIN_ATTR_R(thingy, THINGY) \
197 .attr = { .name = #thingy, .mode = 0440 }, \
198 .size = ISKU_SIZE_ ## THINGY, \
199 .read = isku_sysfs_read_ ## thingy, \
202 #define ISKU_BIN_ATTR_W(thingy, THINGY) \
204 .attr = { .name = #thingy, .mode = 0220 }, \
205 .size = ISKU_SIZE_ ## THINGY, \
206 .write = isku_sysfs_write_ ## thingy \
209 ISKU_SYSFS_RW(macro
, MACRO
)
210 ISKU_SYSFS_RW(keys_function
, KEYS_FUNCTION
)
211 ISKU_SYSFS_RW(keys_easyzone
, KEYS_EASYZONE
)
212 ISKU_SYSFS_RW(keys_media
, KEYS_MEDIA
)
213 ISKU_SYSFS_RW(keys_thumbster
, KEYS_THUMBSTER
)
214 ISKU_SYSFS_RW(keys_macro
, KEYS_MACRO
)
215 ISKU_SYSFS_RW(keys_capslock
, KEYS_CAPSLOCK
)
216 ISKU_SYSFS_RW(light
, LIGHT
)
217 ISKU_SYSFS_RW(key_mask
, KEY_MASK
)
218 ISKU_SYSFS_RW(last_set
, LAST_SET
)
219 ISKU_SYSFS_W(talk
, TALK
)
220 ISKU_SYSFS_W(talkfx
, TALKFX
)
221 ISKU_SYSFS_R(info
, INFO
)
222 ISKU_SYSFS_W(control
, CONTROL
)
223 ISKU_SYSFS_W(reset
, RESET
)
225 static struct bin_attribute isku_bin_attributes
[] = {
226 ISKU_BIN_ATTR_RW(macro
, MACRO
),
227 ISKU_BIN_ATTR_RW(keys_function
, KEYS_FUNCTION
),
228 ISKU_BIN_ATTR_RW(keys_easyzone
, KEYS_EASYZONE
),
229 ISKU_BIN_ATTR_RW(keys_media
, KEYS_MEDIA
),
230 ISKU_BIN_ATTR_RW(keys_thumbster
, KEYS_THUMBSTER
),
231 ISKU_BIN_ATTR_RW(keys_macro
, KEYS_MACRO
),
232 ISKU_BIN_ATTR_RW(keys_capslock
, KEYS_CAPSLOCK
),
233 ISKU_BIN_ATTR_RW(light
, LIGHT
),
234 ISKU_BIN_ATTR_RW(key_mask
, KEY_MASK
),
235 ISKU_BIN_ATTR_RW(last_set
, LAST_SET
),
236 ISKU_BIN_ATTR_W(talk
, TALK
),
237 ISKU_BIN_ATTR_W(talkfx
, TALKFX
),
238 ISKU_BIN_ATTR_R(info
, INFO
),
239 ISKU_BIN_ATTR_W(control
, CONTROL
),
240 ISKU_BIN_ATTR_W(reset
, RESET
),
244 static int isku_init_isku_device_struct(struct usb_device
*usb_dev
,
245 struct isku_device
*isku
)
249 mutex_init(&isku
->isku_lock
);
251 retval
= isku_get_actual_profile(usb_dev
);
254 isku_profile_activated(isku
, retval
);
259 static int isku_init_specials(struct hid_device
*hdev
)
261 struct usb_interface
*intf
= to_usb_interface(hdev
->dev
.parent
);
262 struct usb_device
*usb_dev
= interface_to_usbdev(intf
);
263 struct isku_device
*isku
;
266 if (intf
->cur_altsetting
->desc
.bInterfaceProtocol
267 != ISKU_USB_INTERFACE_PROTOCOL
) {
268 hid_set_drvdata(hdev
, NULL
);
272 isku
= kzalloc(sizeof(*isku
), GFP_KERNEL
);
274 hid_err(hdev
, "can't alloc device descriptor\n");
277 hid_set_drvdata(hdev
, isku
);
279 retval
= isku_init_isku_device_struct(usb_dev
, isku
);
281 hid_err(hdev
, "couldn't init struct isku_device\n");
285 retval
= roccat_connect(isku_class
, hdev
,
286 sizeof(struct isku_roccat_report
));
288 hid_err(hdev
, "couldn't init char dev\n");
290 isku
->chrdev_minor
= retval
;
291 isku
->roccat_claimed
= 1;
300 static void isku_remove_specials(struct hid_device
*hdev
)
302 struct usb_interface
*intf
= to_usb_interface(hdev
->dev
.parent
);
303 struct isku_device
*isku
;
305 if (intf
->cur_altsetting
->desc
.bInterfaceProtocol
306 != ISKU_USB_INTERFACE_PROTOCOL
)
309 isku
= hid_get_drvdata(hdev
);
310 if (isku
->roccat_claimed
)
311 roccat_disconnect(isku
->chrdev_minor
);
315 static int isku_probe(struct hid_device
*hdev
,
316 const struct hid_device_id
*id
)
320 retval
= hid_parse(hdev
);
322 hid_err(hdev
, "parse failed\n");
326 retval
= hid_hw_start(hdev
, HID_CONNECT_DEFAULT
);
328 hid_err(hdev
, "hw start failed\n");
332 retval
= isku_init_specials(hdev
);
334 hid_err(hdev
, "couldn't install keyboard\n");
346 static void isku_remove(struct hid_device
*hdev
)
348 isku_remove_specials(hdev
);
352 static void isku_keep_values_up_to_date(struct isku_device
*isku
,
355 struct isku_report_button
const *button_report
;
358 case ISKU_REPORT_NUMBER_BUTTON
:
359 button_report
= (struct isku_report_button
const *)data
;
360 switch (button_report
->event
) {
361 case ISKU_REPORT_BUTTON_EVENT_PROFILE
:
362 isku_profile_activated(isku
, button_report
->data1
- 1);
369 static void isku_report_to_chrdev(struct isku_device
const *isku
,
372 struct isku_roccat_report roccat_report
;
373 struct isku_report_button
const *button_report
;
375 if (data
[0] != ISKU_REPORT_NUMBER_BUTTON
)
378 button_report
= (struct isku_report_button
const *)data
;
380 roccat_report
.event
= button_report
->event
;
381 roccat_report
.data1
= button_report
->data1
;
382 roccat_report
.data2
= button_report
->data2
;
383 roccat_report
.profile
= isku
->actual_profile
+ 1;
384 roccat_report_event(isku
->chrdev_minor
,
385 (uint8_t const *)&roccat_report
);
388 static int isku_raw_event(struct hid_device
*hdev
,
389 struct hid_report
*report
, u8
*data
, int size
)
391 struct usb_interface
*intf
= to_usb_interface(hdev
->dev
.parent
);
392 struct isku_device
*isku
= hid_get_drvdata(hdev
);
394 if (intf
->cur_altsetting
->desc
.bInterfaceProtocol
395 != ISKU_USB_INTERFACE_PROTOCOL
)
401 isku_keep_values_up_to_date(isku
, data
);
403 if (isku
->roccat_claimed
)
404 isku_report_to_chrdev(isku
, data
);
409 static const struct hid_device_id isku_devices
[] = {
410 { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT
, USB_DEVICE_ID_ROCCAT_ISKU
) },
411 { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT
, USB_DEVICE_ID_ROCCAT_ISKUFX
) },
415 MODULE_DEVICE_TABLE(hid
, isku_devices
);
417 static struct hid_driver isku_driver
= {
419 .id_table
= isku_devices
,
421 .remove
= isku_remove
,
422 .raw_event
= isku_raw_event
425 static int __init
isku_init(void)
428 isku_class
= class_create(THIS_MODULE
, "isku");
429 if (IS_ERR(isku_class
))
430 return PTR_ERR(isku_class
);
431 isku_class
->dev_groups
= isku_groups
;
432 isku_class
->dev_bin_attrs
= isku_bin_attributes
;
434 retval
= hid_register_driver(&isku_driver
);
436 class_destroy(isku_class
);
440 static void __exit
isku_exit(void)
442 hid_unregister_driver(&isku_driver
);
443 class_destroy(isku_class
);
446 module_init(isku_init
);
447 module_exit(isku_exit
);
449 MODULE_AUTHOR("Stefan Achatz");
450 MODULE_DESCRIPTION("USB Roccat Isku/FX driver");
451 MODULE_LICENSE("GPL v2");