Version:  2.0.40 2.2.26 2.4.37 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7

Linux/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 
 29 static struct class *isku_class;
 30 
 31 static void isku_profile_activated(struct isku_device *isku, uint new_profile)
 32 {
 33         isku->actual_profile = new_profile;
 34 }
 35 
 36 static 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 
 42 static 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 
 52 static 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 
 64 static 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 
 72 static 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 = kstrtoul(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 static DEVICE_ATTR(actual_profile, 0660, isku_sysfs_show_actual_profile,
113                    isku_sysfs_set_actual_profile);
114 
115 static struct attribute *isku_attrs[] = {
116         &dev_attr_actual_profile.attr,
117         NULL,
118 };
119 
120 static 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 = kobj_to_dev(kobj)->parent->parent;
125         struct isku_device *isku = hid_get_drvdata(dev_get_drvdata(dev));
126         struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
127         int retval;
128 
129         if (off >= real_size)
130                 return 0;
131 
132         if (off != 0 || count > real_size)
133                 return -EINVAL;
134 
135         mutex_lock(&isku->isku_lock);
136         retval = isku_receive(usb_dev, command, buf, count);
137         mutex_unlock(&isku->isku_lock);
138 
139         return retval ? retval : count;
140 }
141 
142 static ssize_t isku_sysfs_write(struct file *fp, struct kobject *kobj,
143                 void const *buf, loff_t off, size_t count,
144                 size_t real_size, uint command)
145 {
146         struct device *dev = kobj_to_dev(kobj)->parent->parent;
147         struct isku_device *isku = hid_get_drvdata(dev_get_drvdata(dev));
148         struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
149         int retval;
150 
151         if (off != 0 || count > real_size)
152                 return -EINVAL;
153 
154         mutex_lock(&isku->isku_lock);
155         retval = roccat_common2_send_with_status(usb_dev, command,
156                         (void *)buf, count);
157         mutex_unlock(&isku->isku_lock);
158 
159         return retval ? retval : count;
160 }
161 
162 #define ISKU_SYSFS_W(thingy, THINGY) \
163 static ssize_t isku_sysfs_write_ ## thingy(struct file *fp, struct kobject *kobj, \
164                 struct bin_attribute *attr, char *buf, \
165                 loff_t off, size_t count) \
166 { \
167         return isku_sysfs_write(fp, kobj, buf, off, count, \
168                         ISKU_SIZE_ ## THINGY, ISKU_COMMAND_ ## THINGY); \
169 }
170 
171 #define ISKU_SYSFS_R(thingy, THINGY) \
172 static ssize_t isku_sysfs_read_ ## thingy(struct file *fp, struct kobject *kobj, \
173                 struct bin_attribute *attr, char *buf, \
174                 loff_t off, size_t count) \
175 { \
176         return isku_sysfs_read(fp, kobj, buf, off, count, \
177                         ISKU_SIZE_ ## THINGY, ISKU_COMMAND_ ## THINGY); \
178 }
179 
180 #define ISKU_SYSFS_RW(thingy, THINGY) \
181 ISKU_SYSFS_R(thingy, THINGY) \
182 ISKU_SYSFS_W(thingy, THINGY)
183 
184 #define ISKU_BIN_ATTR_RW(thingy, THINGY) \
185 ISKU_SYSFS_RW(thingy, THINGY); \
186 static struct bin_attribute bin_attr_##thingy = { \
187         .attr = { .name = #thingy, .mode = 0660 }, \
188         .size = ISKU_SIZE_ ## THINGY, \
189         .read = isku_sysfs_read_ ## thingy, \
190         .write = isku_sysfs_write_ ## thingy \
191 }
192 
193 #define ISKU_BIN_ATTR_R(thingy, THINGY) \
194 ISKU_SYSFS_R(thingy, THINGY); \
195 static struct bin_attribute bin_attr_##thingy = { \
196         .attr = { .name = #thingy, .mode = 0440 }, \
197         .size = ISKU_SIZE_ ## THINGY, \
198         .read = isku_sysfs_read_ ## thingy, \
199 }
200 
201 #define ISKU_BIN_ATTR_W(thingy, THINGY) \
202 ISKU_SYSFS_W(thingy, THINGY); \
203 static struct bin_attribute bin_attr_##thingy = { \
204         .attr = { .name = #thingy, .mode = 0220 }, \
205         .size = ISKU_SIZE_ ## THINGY, \
206         .write = isku_sysfs_write_ ## thingy \
207 }
208 
209 ISKU_BIN_ATTR_RW(macro, MACRO);
210 ISKU_BIN_ATTR_RW(keys_function, KEYS_FUNCTION);
211 ISKU_BIN_ATTR_RW(keys_easyzone, KEYS_EASYZONE);
212 ISKU_BIN_ATTR_RW(keys_media, KEYS_MEDIA);
213 ISKU_BIN_ATTR_RW(keys_thumbster, KEYS_THUMBSTER);
214 ISKU_BIN_ATTR_RW(keys_macro, KEYS_MACRO);
215 ISKU_BIN_ATTR_RW(keys_capslock, KEYS_CAPSLOCK);
216 ISKU_BIN_ATTR_RW(light, LIGHT);
217 ISKU_BIN_ATTR_RW(key_mask, KEY_MASK);
218 ISKU_BIN_ATTR_RW(last_set, LAST_SET);
219 ISKU_BIN_ATTR_W(talk, TALK);
220 ISKU_BIN_ATTR_W(talkfx, TALKFX);
221 ISKU_BIN_ATTR_W(control, CONTROL);
222 ISKU_BIN_ATTR_W(reset, RESET);
223 ISKU_BIN_ATTR_R(info, INFO);
224 
225 static struct bin_attribute *isku_bin_attributes[] = {
226         &bin_attr_macro,
227         &bin_attr_keys_function,
228         &bin_attr_keys_easyzone,
229         &bin_attr_keys_media,
230         &bin_attr_keys_thumbster,
231         &bin_attr_keys_macro,
232         &bin_attr_keys_capslock,
233         &bin_attr_light,
234         &bin_attr_key_mask,
235         &bin_attr_last_set,
236         &bin_attr_talk,
237         &bin_attr_talkfx,
238         &bin_attr_control,
239         &bin_attr_reset,
240         &bin_attr_info,
241         NULL,
242 };
243 
244 static const struct attribute_group isku_group = {
245         .attrs = isku_attrs,
246         .bin_attrs = isku_bin_attributes,
247 };
248 
249 static const struct attribute_group *isku_groups[] = {
250         &isku_group,
251         NULL,
252 };
253 
254 static int isku_init_isku_device_struct(struct usb_device *usb_dev,
255                 struct isku_device *isku)
256 {
257         int retval;
258 
259         mutex_init(&isku->isku_lock);
260 
261         retval = isku_get_actual_profile(usb_dev);
262         if (retval < 0)
263                 return retval;
264         isku_profile_activated(isku, retval);
265 
266         return 0;
267 }
268 
269 static int isku_init_specials(struct hid_device *hdev)
270 {
271         struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
272         struct usb_device *usb_dev = interface_to_usbdev(intf);
273         struct isku_device *isku;
274         int retval;
275 
276         if (intf->cur_altsetting->desc.bInterfaceProtocol
277                         != ISKU_USB_INTERFACE_PROTOCOL) {
278                 hid_set_drvdata(hdev, NULL);
279                 return 0;
280         }
281 
282         isku = kzalloc(sizeof(*isku), GFP_KERNEL);
283         if (!isku) {
284                 hid_err(hdev, "can't alloc device descriptor\n");
285                 return -ENOMEM;
286         }
287         hid_set_drvdata(hdev, isku);
288 
289         retval = isku_init_isku_device_struct(usb_dev, isku);
290         if (retval) {
291                 hid_err(hdev, "couldn't init struct isku_device\n");
292                 goto exit_free;
293         }
294 
295         retval = roccat_connect(isku_class, hdev,
296                         sizeof(struct isku_roccat_report));
297         if (retval < 0) {
298                 hid_err(hdev, "couldn't init char dev\n");
299         } else {
300                 isku->chrdev_minor = retval;
301                 isku->roccat_claimed = 1;
302         }
303 
304         return 0;
305 exit_free:
306         kfree(isku);
307         return retval;
308 }
309 
310 static void isku_remove_specials(struct hid_device *hdev)
311 {
312         struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
313         struct isku_device *isku;
314 
315         if (intf->cur_altsetting->desc.bInterfaceProtocol
316                         != ISKU_USB_INTERFACE_PROTOCOL)
317                 return;
318 
319         isku = hid_get_drvdata(hdev);
320         if (isku->roccat_claimed)
321                 roccat_disconnect(isku->chrdev_minor);
322         kfree(isku);
323 }
324 
325 static int isku_probe(struct hid_device *hdev,
326                 const struct hid_device_id *id)
327 {
328         int retval;
329 
330         retval = hid_parse(hdev);
331         if (retval) {
332                 hid_err(hdev, "parse failed\n");
333                 goto exit;
334         }
335 
336         retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
337         if (retval) {
338                 hid_err(hdev, "hw start failed\n");
339                 goto exit;
340         }
341 
342         retval = isku_init_specials(hdev);
343         if (retval) {
344                 hid_err(hdev, "couldn't install keyboard\n");
345                 goto exit_stop;
346         }
347 
348         return 0;
349 
350 exit_stop:
351         hid_hw_stop(hdev);
352 exit:
353         return retval;
354 }
355 
356 static void isku_remove(struct hid_device *hdev)
357 {
358         isku_remove_specials(hdev);
359         hid_hw_stop(hdev);
360 }
361 
362 static void isku_keep_values_up_to_date(struct isku_device *isku,
363                 u8 const *data)
364 {
365         struct isku_report_button const *button_report;
366 
367         switch (data[0]) {
368         case ISKU_REPORT_NUMBER_BUTTON:
369                 button_report = (struct isku_report_button const *)data;
370                 switch (button_report->event) {
371                 case ISKU_REPORT_BUTTON_EVENT_PROFILE:
372                         isku_profile_activated(isku, button_report->data1 - 1);
373                         break;
374                 }
375                 break;
376         }
377 }
378 
379 static void isku_report_to_chrdev(struct isku_device const *isku,
380                 u8 const *data)
381 {
382         struct isku_roccat_report roccat_report;
383         struct isku_report_button const *button_report;
384 
385         if (data[0] != ISKU_REPORT_NUMBER_BUTTON)
386                 return;
387 
388         button_report = (struct isku_report_button const *)data;
389 
390         roccat_report.event = button_report->event;
391         roccat_report.data1 = button_report->data1;
392         roccat_report.data2 = button_report->data2;
393         roccat_report.profile = isku->actual_profile + 1;
394         roccat_report_event(isku->chrdev_minor,
395                         (uint8_t const *)&roccat_report);
396 }
397 
398 static int isku_raw_event(struct hid_device *hdev,
399                 struct hid_report *report, u8 *data, int size)
400 {
401         struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
402         struct isku_device *isku = hid_get_drvdata(hdev);
403 
404         if (intf->cur_altsetting->desc.bInterfaceProtocol
405                         != ISKU_USB_INTERFACE_PROTOCOL)
406                 return 0;
407 
408         if (isku == NULL)
409                 return 0;
410 
411         isku_keep_values_up_to_date(isku, data);
412 
413         if (isku->roccat_claimed)
414                 isku_report_to_chrdev(isku, data);
415 
416         return 0;
417 }
418 
419 static const struct hid_device_id isku_devices[] = {
420         { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ISKU) },
421         { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ISKUFX) },
422         { }
423 };
424 
425 MODULE_DEVICE_TABLE(hid, isku_devices);
426 
427 static struct hid_driver isku_driver = {
428                 .name = "isku",
429                 .id_table = isku_devices,
430                 .probe = isku_probe,
431                 .remove = isku_remove,
432                 .raw_event = isku_raw_event
433 };
434 
435 static int __init isku_init(void)
436 {
437         int retval;
438         isku_class = class_create(THIS_MODULE, "isku");
439         if (IS_ERR(isku_class))
440                 return PTR_ERR(isku_class);
441         isku_class->dev_groups = isku_groups;
442 
443         retval = hid_register_driver(&isku_driver);
444         if (retval)
445                 class_destroy(isku_class);
446         return retval;
447 }
448 
449 static void __exit isku_exit(void)
450 {
451         hid_unregister_driver(&isku_driver);
452         class_destroy(isku_class);
453 }
454 
455 module_init(isku_init);
456 module_exit(isku_exit);
457 
458 MODULE_AUTHOR("Stefan Achatz");
459 MODULE_DESCRIPTION("USB Roccat Isku/FX driver");
460 MODULE_LICENSE("GPL v2");
461 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us