Root/drivers/hid/hid-roccat-isku.c

1/*
2 * Roccat Isku driver for Linux
3 *
4 * Copyright (c) 2011 Stefan Achatz <erazor_de@users.sourceforge.net>
5 */
6
7/*
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)
11 * any later version.
12 */
13
14/*
15 * Roccat Isku is a gamer keyboard with macro keys that can be configured in
16 * 5 profiles.
17 */
18
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>
25#include "hid-ids.h"
26#include "hid-roccat-common.h"
27#include "hid-roccat-isku.h"
28
29static struct class *isku_class;
30
31static void isku_profile_activated(struct isku_device *isku, uint new_profile)
32{
33    isku->actual_profile = new_profile;
34}
35
36static int isku_receive(struct usb_device *usb_dev, uint command,
37        void *buf, uint size)
38{
39    return roccat_common2_receive(usb_dev, command, buf, size);
40}
41
42static int isku_get_actual_profile(struct usb_device *usb_dev)
43{
44    struct isku_actual_profile buf;
45    int retval;
46
47    retval = isku_receive(usb_dev, ISKU_COMMAND_ACTUAL_PROFILE,
48            &buf, sizeof(struct isku_actual_profile));
49    return retval ? retval : buf.actual_profile;
50}
51
52static int isku_set_actual_profile(struct usb_device *usb_dev, int new_profile)
53{
54    struct isku_actual_profile buf;
55
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));
62}
63
64static ssize_t isku_sysfs_show_actual_profile(struct device *dev,
65        struct device_attribute *attr, char *buf)
66{
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);
70}
71
72static ssize_t isku_sysfs_set_actual_profile(struct device *dev,
73        struct device_attribute *attr, char const *buf, size_t size)
74{
75    struct isku_device *isku;
76    struct usb_device *usb_dev;
77    unsigned long profile;
78    int retval;
79    struct isku_roccat_report roccat_report;
80
81    dev = dev->parent->parent;
82    isku = hid_get_drvdata(dev_get_drvdata(dev));
83    usb_dev = interface_to_usbdev(to_usb_interface(dev));
84
85    retval = strict_strtoul(buf, 10, &profile);
86    if (retval)
87        return retval;
88
89    if (profile > 4)
90        return -EINVAL;
91
92    mutex_lock(&isku->isku_lock);
93
94    retval = isku_set_actual_profile(usb_dev, profile);
95    if (retval) {
96        mutex_unlock(&isku->isku_lock);
97        return retval;
98    }
99
100    isku_profile_activated(isku, profile);
101
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);
107
108    mutex_unlock(&isku->isku_lock);
109
110    return size;
111}
112
113static struct device_attribute isku_attributes[] = {
114    __ATTR(actual_profile, 0660,
115            isku_sysfs_show_actual_profile,
116            isku_sysfs_set_actual_profile),
117    __ATTR_NULL
118};
119
120static ssize_t isku_sysfs_read(struct file *fp, struct kobject *kobj,
121        char *buf, loff_t off, size_t count,
122        size_t real_size, uint command)
123{
124    struct device *dev =
125            container_of(kobj, struct device, kobj)->parent->parent;
126    struct isku_device *isku = hid_get_drvdata(dev_get_drvdata(dev));
127    struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
128    int retval;
129
130    if (off >= real_size)
131        return 0;
132
133    if (off != 0 || count != real_size)
134        return -EINVAL;
135
136    mutex_lock(&isku->isku_lock);
137    retval = isku_receive(usb_dev, command, buf, real_size);
138    mutex_unlock(&isku->isku_lock);
139
140    return retval ? retval : real_size;
141}
142
143static ssize_t isku_sysfs_write(struct file *fp, struct kobject *kobj,
144        void const *buf, loff_t off, size_t count,
145        size_t real_size, uint command)
146{
147    struct device *dev =
148            container_of(kobj, struct device, kobj)->parent->parent;
149    struct isku_device *isku = hid_get_drvdata(dev_get_drvdata(dev));
150    struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
151    int retval;
152
153    if (off != 0 || count != real_size)
154        return -EINVAL;
155
156    mutex_lock(&isku->isku_lock);
157    retval = roccat_common2_send_with_status(usb_dev, command,
158            (void *)buf, real_size);
159    mutex_unlock(&isku->isku_lock);
160
161    return retval ? retval : real_size;
162}
163
164#define ISKU_SYSFS_W(thingy, THINGY) \
165static ssize_t isku_sysfs_write_ ## thingy(struct file *fp, struct kobject *kobj, \
166        struct bin_attribute *attr, char *buf, \
167        loff_t off, size_t count) \
168{ \
169    return isku_sysfs_write(fp, kobj, buf, off, count, \
170            sizeof(struct isku_ ## thingy), ISKU_COMMAND_ ## THINGY); \
171}
172
173#define ISKU_SYSFS_R(thingy, THINGY) \
174static ssize_t isku_sysfs_read_ ## thingy(struct file *fp, struct kobject *kobj, \
175        struct bin_attribute *attr, char *buf, \
176        loff_t off, size_t count) \
177{ \
178    return isku_sysfs_read(fp, kobj, buf, off, count, \
179            sizeof(struct isku_ ## thingy), ISKU_COMMAND_ ## THINGY); \
180}
181
182#define ISKU_SYSFS_RW(thingy, THINGY) \
183ISKU_SYSFS_R(thingy, THINGY) \
184ISKU_SYSFS_W(thingy, THINGY)
185
186#define ISKU_BIN_ATTR_RW(thingy) \
187{ \
188    .attr = { .name = #thingy, .mode = 0660 }, \
189    .size = sizeof(struct isku_ ## thingy), \
190    .read = isku_sysfs_read_ ## thingy, \
191    .write = isku_sysfs_write_ ## thingy \
192}
193
194#define ISKU_BIN_ATTR_R(thingy) \
195{ \
196    .attr = { .name = #thingy, .mode = 0440 }, \
197    .size = sizeof(struct isku_ ## thingy), \
198    .read = isku_sysfs_read_ ## thingy, \
199}
200
201#define ISKU_BIN_ATTR_W(thingy) \
202{ \
203    .attr = { .name = #thingy, .mode = 0220 }, \
204    .size = sizeof(struct isku_ ## thingy), \
205    .write = isku_sysfs_write_ ## thingy \
206}
207
208ISKU_SYSFS_RW(macro, MACRO)
209ISKU_SYSFS_RW(keys_function, KEYS_FUNCTION)
210ISKU_SYSFS_RW(keys_easyzone, KEYS_EASYZONE)
211ISKU_SYSFS_RW(keys_media, KEYS_MEDIA)
212ISKU_SYSFS_RW(keys_thumbster, KEYS_THUMBSTER)
213ISKU_SYSFS_RW(keys_macro, KEYS_MACRO)
214ISKU_SYSFS_RW(keys_capslock, KEYS_CAPSLOCK)
215ISKU_SYSFS_RW(light, LIGHT)
216ISKU_SYSFS_RW(key_mask, KEY_MASK)
217ISKU_SYSFS_RW(last_set, LAST_SET)
218ISKU_SYSFS_W(talk, TALK)
219ISKU_SYSFS_R(info, INFO)
220ISKU_SYSFS_W(control, CONTROL)
221
222static struct bin_attribute isku_bin_attributes[] = {
223    ISKU_BIN_ATTR_RW(macro),
224    ISKU_BIN_ATTR_RW(keys_function),
225    ISKU_BIN_ATTR_RW(keys_easyzone),
226    ISKU_BIN_ATTR_RW(keys_media),
227    ISKU_BIN_ATTR_RW(keys_thumbster),
228    ISKU_BIN_ATTR_RW(keys_macro),
229    ISKU_BIN_ATTR_RW(keys_capslock),
230    ISKU_BIN_ATTR_RW(light),
231    ISKU_BIN_ATTR_RW(key_mask),
232    ISKU_BIN_ATTR_RW(last_set),
233    ISKU_BIN_ATTR_W(talk),
234    ISKU_BIN_ATTR_R(info),
235    ISKU_BIN_ATTR_W(control),
236    __ATTR_NULL
237};
238
239static int isku_init_isku_device_struct(struct usb_device *usb_dev,
240        struct isku_device *isku)
241{
242    int retval;
243
244    mutex_init(&isku->isku_lock);
245
246    retval = isku_get_actual_profile(usb_dev);
247    if (retval < 0)
248        return retval;
249    isku_profile_activated(isku, retval);
250
251    return 0;
252}
253
254static int isku_init_specials(struct hid_device *hdev)
255{
256    struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
257    struct usb_device *usb_dev = interface_to_usbdev(intf);
258    struct isku_device *isku;
259    int retval;
260
261    if (intf->cur_altsetting->desc.bInterfaceProtocol
262            != ISKU_USB_INTERFACE_PROTOCOL) {
263        hid_set_drvdata(hdev, NULL);
264        return 0;
265    }
266
267    isku = kzalloc(sizeof(*isku), GFP_KERNEL);
268    if (!isku) {
269        hid_err(hdev, "can't alloc device descriptor\n");
270        return -ENOMEM;
271    }
272    hid_set_drvdata(hdev, isku);
273
274    retval = isku_init_isku_device_struct(usb_dev, isku);
275    if (retval) {
276        hid_err(hdev, "couldn't init struct isku_device\n");
277        goto exit_free;
278    }
279
280    retval = roccat_connect(isku_class, hdev,
281            sizeof(struct isku_roccat_report));
282    if (retval < 0) {
283        hid_err(hdev, "couldn't init char dev\n");
284    } else {
285        isku->chrdev_minor = retval;
286        isku->roccat_claimed = 1;
287    }
288
289    return 0;
290exit_free:
291    kfree(isku);
292    return retval;
293}
294
295static void isku_remove_specials(struct hid_device *hdev)
296{
297    struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
298    struct isku_device *isku;
299
300    if (intf->cur_altsetting->desc.bInterfaceProtocol
301            != ISKU_USB_INTERFACE_PROTOCOL)
302        return;
303
304    isku = hid_get_drvdata(hdev);
305    if (isku->roccat_claimed)
306        roccat_disconnect(isku->chrdev_minor);
307    kfree(isku);
308}
309
310static int isku_probe(struct hid_device *hdev,
311        const struct hid_device_id *id)
312{
313    int retval;
314
315    retval = hid_parse(hdev);
316    if (retval) {
317        hid_err(hdev, "parse failed\n");
318        goto exit;
319    }
320
321    retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
322    if (retval) {
323        hid_err(hdev, "hw start failed\n");
324        goto exit;
325    }
326
327    retval = isku_init_specials(hdev);
328    if (retval) {
329        hid_err(hdev, "couldn't install keyboard\n");
330        goto exit_stop;
331    }
332
333    return 0;
334
335exit_stop:
336    hid_hw_stop(hdev);
337exit:
338    return retval;
339}
340
341static void isku_remove(struct hid_device *hdev)
342{
343    isku_remove_specials(hdev);
344    hid_hw_stop(hdev);
345}
346
347static void isku_keep_values_up_to_date(struct isku_device *isku,
348        u8 const *data)
349{
350    struct isku_report_button const *button_report;
351
352    switch (data[0]) {
353    case ISKU_REPORT_NUMBER_BUTTON:
354        button_report = (struct isku_report_button const *)data;
355        switch (button_report->event) {
356        case ISKU_REPORT_BUTTON_EVENT_PROFILE:
357            isku_profile_activated(isku, button_report->data1 - 1);
358            break;
359        }
360        break;
361    }
362}
363
364static void isku_report_to_chrdev(struct isku_device const *isku,
365        u8 const *data)
366{
367    struct isku_roccat_report roccat_report;
368    struct isku_report_button const *button_report;
369
370    if (data[0] != ISKU_REPORT_NUMBER_BUTTON)
371        return;
372
373    button_report = (struct isku_report_button const *)data;
374
375    roccat_report.event = button_report->event;
376    roccat_report.data1 = button_report->data1;
377    roccat_report.data2 = button_report->data2;
378    roccat_report.profile = isku->actual_profile + 1;
379    roccat_report_event(isku->chrdev_minor,
380            (uint8_t const *)&roccat_report);
381}
382
383static int isku_raw_event(struct hid_device *hdev,
384        struct hid_report *report, u8 *data, int size)
385{
386    struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
387    struct isku_device *isku = hid_get_drvdata(hdev);
388
389    if (intf->cur_altsetting->desc.bInterfaceProtocol
390            != ISKU_USB_INTERFACE_PROTOCOL)
391        return 0;
392
393    if (isku == NULL)
394        return 0;
395
396    isku_keep_values_up_to_date(isku, data);
397
398    if (isku->roccat_claimed)
399        isku_report_to_chrdev(isku, data);
400
401    return 0;
402}
403
404static const struct hid_device_id isku_devices[] = {
405    { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ISKU) },
406    { }
407};
408
409MODULE_DEVICE_TABLE(hid, isku_devices);
410
411static struct hid_driver isku_driver = {
412        .name = "isku",
413        .id_table = isku_devices,
414        .probe = isku_probe,
415        .remove = isku_remove,
416        .raw_event = isku_raw_event
417};
418
419static int __init isku_init(void)
420{
421    int retval;
422    isku_class = class_create(THIS_MODULE, "isku");
423    if (IS_ERR(isku_class))
424        return PTR_ERR(isku_class);
425    isku_class->dev_attrs = isku_attributes;
426    isku_class->dev_bin_attrs = isku_bin_attributes;
427
428    retval = hid_register_driver(&isku_driver);
429    if (retval)
430        class_destroy(isku_class);
431    return retval;
432}
433
434static void __exit isku_exit(void)
435{
436    hid_unregister_driver(&isku_driver);
437    class_destroy(isku_class);
438}
439
440module_init(isku_init);
441module_exit(isku_exit);
442
443MODULE_AUTHOR("Stefan Achatz");
444MODULE_DESCRIPTION("USB Roccat Isku driver");
445MODULE_LICENSE("GPL v2");
446

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive