mfd: Add pm8xxx irq support
[linux-2.6.git] / drivers / hid / hid-roccat-kone.c
1 /*
2  * Roccat Kone driver for Linux
3  *
4  * Copyright (c) 2010 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 Kone is a gamer mouse which consists of a mouse part and a keyboard
16  * part. The keyboard part enables the mouse to execute stored macros with mixed
17  * key- and button-events.
18  *
19  * TODO implement on-the-fly polling-rate change
20  *      The windows driver has the ability to change the polling rate of the
21  *      device on the press of a mousebutton.
22  *      Is it possible to remove and reinstall the urb in raw-event- or any
23  *      other handler, or to defer this action to be executed somewhere else?
24  *
25  * TODO is it possible to overwrite group for sysfs attributes via udev?
26  */
27
28 #include <linux/device.h>
29 #include <linux/input.h>
30 #include <linux/hid.h>
31 #include <linux/module.h>
32 #include <linux/slab.h>
33 #include <linux/hid-roccat.h>
34 #include "hid-ids.h"
35 #include "hid-roccat-common.h"
36 #include "hid-roccat-kone.h"
37
38 static uint profile_numbers[5] = {0, 1, 2, 3, 4};
39
40 /* kone_class is used for creating sysfs attributes via roccat char device */
41 static struct class *kone_class;
42
43 static void kone_set_settings_checksum(struct kone_settings *settings)
44 {
45         uint16_t checksum = 0;
46         unsigned char *address = (unsigned char *)settings;
47         int i;
48
49         for (i = 0; i < sizeof(struct kone_settings) - 2; ++i, ++address)
50                 checksum += *address;
51         settings->checksum = cpu_to_le16(checksum);
52 }
53
54 /*
55  * Checks success after writing data to mouse
56  * On success returns 0
57  * On failure returns errno
58  */
59 static int kone_check_write(struct usb_device *usb_dev)
60 {
61         int retval;
62         uint8_t data;
63
64         do {
65                 /*
66                  * Mouse needs 50 msecs until it says ok, but there are
67                  * 30 more msecs needed for next write to work.
68                  */
69                 msleep(80);
70
71                 retval = roccat_common_receive(usb_dev,
72                                 kone_command_confirm_write, &data, 1);
73                 if (retval)
74                         return retval;
75
76                 /*
77                  * value of 3 seems to mean something like
78                  * "not finished yet, but it looks good"
79                  * So check again after a moment.
80                  */
81         } while (data == 3);
82
83         if (data == 1) /* everything alright */
84                 return 0;
85
86         /* unknown answer */
87         hid_err(usb_dev, "got retval %d when checking write\n", data);
88         return -EIO;
89 }
90
91 /*
92  * Reads settings from mouse and stores it in @buf
93  * On success returns 0
94  * On failure returns errno
95  */
96 static int kone_get_settings(struct usb_device *usb_dev,
97                 struct kone_settings *buf)
98 {
99         return roccat_common_receive(usb_dev, kone_command_settings, buf,
100                         sizeof(struct kone_settings));
101 }
102
103 /*
104  * Writes settings from @buf to mouse
105  * On success returns 0
106  * On failure returns errno
107  */
108 static int kone_set_settings(struct usb_device *usb_dev,
109                 struct kone_settings const *settings)
110 {
111         int retval;
112         retval = roccat_common_send(usb_dev, kone_command_settings,
113                         settings, sizeof(struct kone_settings));
114         if (retval)
115                 return retval;
116         return kone_check_write(usb_dev);
117 }
118
119 /*
120  * Reads profile data from mouse and stores it in @buf
121  * @number: profile number to read
122  * On success returns 0
123  * On failure returns errno
124  */
125 static int kone_get_profile(struct usb_device *usb_dev,
126                 struct kone_profile *buf, int number)
127 {
128         int len;
129
130         if (number < 1 || number > 5)
131                 return -EINVAL;
132
133         len = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
134                         USB_REQ_CLEAR_FEATURE,
135                         USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
136                         kone_command_profile, number, buf,
137                         sizeof(struct kone_profile), USB_CTRL_SET_TIMEOUT);
138
139         if (len != sizeof(struct kone_profile))
140                 return -EIO;
141
142         return 0;
143 }
144
145 /*
146  * Writes profile data to mouse.
147  * @number: profile number to write
148  * On success returns 0
149  * On failure returns errno
150  */
151 static int kone_set_profile(struct usb_device *usb_dev,
152                 struct kone_profile const *profile, int number)
153 {
154         int len;
155
156         if (number < 1 || number > 5)
157                 return -EINVAL;
158
159         len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
160                         USB_REQ_SET_CONFIGURATION,
161                         USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
162                         kone_command_profile, number, (void *)profile,
163                         sizeof(struct kone_profile),
164                         USB_CTRL_SET_TIMEOUT);
165
166         if (len != sizeof(struct kone_profile))
167                 return len;
168
169         if (kone_check_write(usb_dev))
170                 return -EIO;
171
172         return 0;
173 }
174
175 /*
176  * Reads value of "fast-clip-weight" and stores it in @result
177  * On success returns 0
178  * On failure returns errno
179  */
180 static int kone_get_weight(struct usb_device *usb_dev, int *result)
181 {
182         int retval;
183         uint8_t data;
184
185         retval = roccat_common_receive(usb_dev, kone_command_weight, &data, 1);
186
187         if (retval)
188                 return retval;
189
190         *result = (int)data;
191         return 0;
192 }
193
194 /*
195  * Reads firmware_version of mouse and stores it in @result
196  * On success returns 0
197  * On failure returns errno
198  */
199 static int kone_get_firmware_version(struct usb_device *usb_dev, int *result)
200 {
201         int retval;
202         uint16_t data;
203
204         retval = roccat_common_receive(usb_dev, kone_command_firmware_version,
205                         &data, 2);
206         if (retval)
207                 return retval;
208
209         *result = le16_to_cpu(data);
210         return 0;
211 }
212
213 static ssize_t kone_sysfs_read_settings(struct file *fp, struct kobject *kobj,
214                 struct bin_attribute *attr, char *buf,
215                 loff_t off, size_t count) {
216         struct device *dev =
217                         container_of(kobj, struct device, kobj)->parent->parent;
218         struct kone_device *kone = hid_get_drvdata(dev_get_drvdata(dev));
219
220         if (off >= sizeof(struct kone_settings))
221                 return 0;
222
223         if (off + count > sizeof(struct kone_settings))
224                 count = sizeof(struct kone_settings) - off;
225
226         mutex_lock(&kone->kone_lock);
227         memcpy(buf, ((char const *)&kone->settings) + off, count);
228         mutex_unlock(&kone->kone_lock);
229
230         return count;
231 }
232
233 /*
234  * Writing settings automatically activates startup_profile.
235  * This function keeps values in kone_device up to date and assumes that in
236  * case of error the old data is still valid
237  */
238 static ssize_t kone_sysfs_write_settings(struct file *fp, struct kobject *kobj,
239                 struct bin_attribute *attr, char *buf,
240                 loff_t off, size_t count) {
241         struct device *dev =
242                         container_of(kobj, struct device, kobj)->parent->parent;
243         struct kone_device *kone = hid_get_drvdata(dev_get_drvdata(dev));
244         struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
245         int retval = 0, difference;
246
247         /* I need to get my data in one piece */
248         if (off != 0 || count != sizeof(struct kone_settings))
249                 return -EINVAL;
250
251         mutex_lock(&kone->kone_lock);
252         difference = memcmp(buf, &kone->settings, sizeof(struct kone_settings));
253         if (difference) {
254                 retval = kone_set_settings(usb_dev,
255                                 (struct kone_settings const *)buf);
256                 if (!retval)
257                         memcpy(&kone->settings, buf,
258                                         sizeof(struct kone_settings));
259         }
260         mutex_unlock(&kone->kone_lock);
261
262         if (retval)
263                 return retval;
264
265         /*
266          * If we get here, treat settings as okay and update actual values
267          * according to startup_profile
268          */
269         kone->actual_profile = kone->settings.startup_profile;
270         kone->actual_dpi = kone->profiles[kone->actual_profile - 1].startup_dpi;
271
272         return sizeof(struct kone_settings);
273 }
274
275 static ssize_t kone_sysfs_read_profilex(struct file *fp,
276                 struct kobject *kobj, struct bin_attribute *attr,
277                 char *buf, loff_t off, size_t count) {
278         struct device *dev =
279                         container_of(kobj, struct device, kobj)->parent->parent;
280         struct kone_device *kone = hid_get_drvdata(dev_get_drvdata(dev));
281
282         if (off >= sizeof(struct kone_profile))
283                 return 0;
284
285         if (off + count > sizeof(struct kone_profile))
286                 count = sizeof(struct kone_profile) - off;
287
288         mutex_lock(&kone->kone_lock);
289         memcpy(buf, ((char const *)&kone->profiles[*(uint *)(attr->private)]) + off, count);
290         mutex_unlock(&kone->kone_lock);
291
292         return count;
293 }
294
295 /* Writes data only if different to stored data */
296 static ssize_t kone_sysfs_write_profilex(struct file *fp,
297                 struct kobject *kobj, struct bin_attribute *attr,
298                 char *buf, loff_t off, size_t count) {
299         struct device *dev =
300                         container_of(kobj, struct device, kobj)->parent->parent;
301         struct kone_device *kone = hid_get_drvdata(dev_get_drvdata(dev));
302         struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
303         struct kone_profile *profile;
304         int retval = 0, difference;
305
306         /* I need to get my data in one piece */
307         if (off != 0 || count != sizeof(struct kone_profile))
308                 return -EINVAL;
309
310         profile = &kone->profiles[*(uint *)(attr->private)];
311
312         mutex_lock(&kone->kone_lock);
313         difference = memcmp(buf, profile, sizeof(struct kone_profile));
314         if (difference) {
315                 retval = kone_set_profile(usb_dev,
316                                 (struct kone_profile const *)buf,
317                                 *(uint *)(attr->private) + 1);
318                 if (!retval)
319                         memcpy(profile, buf, sizeof(struct kone_profile));
320         }
321         mutex_unlock(&kone->kone_lock);
322
323         if (retval)
324                 return retval;
325
326         return sizeof(struct kone_profile);
327 }
328
329 static ssize_t kone_sysfs_show_actual_profile(struct device *dev,
330                 struct device_attribute *attr, char *buf)
331 {
332         struct kone_device *kone =
333                         hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
334         return snprintf(buf, PAGE_SIZE, "%d\n", kone->actual_profile);
335 }
336
337 static ssize_t kone_sysfs_show_actual_dpi(struct device *dev,
338                 struct device_attribute *attr, char *buf)
339 {
340         struct kone_device *kone =
341                         hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
342         return snprintf(buf, PAGE_SIZE, "%d\n", kone->actual_dpi);
343 }
344
345 /* weight is read each time, since we don't get informed when it's changed */
346 static ssize_t kone_sysfs_show_weight(struct device *dev,
347                 struct device_attribute *attr, char *buf)
348 {
349         struct kone_device *kone;
350         struct usb_device *usb_dev;
351         int weight = 0;
352         int retval;
353
354         dev = dev->parent->parent;
355         kone = hid_get_drvdata(dev_get_drvdata(dev));
356         usb_dev = interface_to_usbdev(to_usb_interface(dev));
357
358         mutex_lock(&kone->kone_lock);
359         retval = kone_get_weight(usb_dev, &weight);
360         mutex_unlock(&kone->kone_lock);
361
362         if (retval)
363                 return retval;
364         return snprintf(buf, PAGE_SIZE, "%d\n", weight);
365 }
366
367 static ssize_t kone_sysfs_show_firmware_version(struct device *dev,
368                 struct device_attribute *attr, char *buf)
369 {
370         struct kone_device *kone =
371                         hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
372         return snprintf(buf, PAGE_SIZE, "%d\n", kone->firmware_version);
373 }
374
375 static ssize_t kone_sysfs_show_tcu(struct device *dev,
376                 struct device_attribute *attr, char *buf)
377 {
378         struct kone_device *kone =
379                         hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
380         return snprintf(buf, PAGE_SIZE, "%d\n", kone->settings.tcu);
381 }
382
383 static int kone_tcu_command(struct usb_device *usb_dev, int number)
384 {
385         unsigned char value;
386         value = number;
387         return roccat_common_send(usb_dev, kone_command_calibrate, &value, 1);
388 }
389
390 /*
391  * Calibrating the tcu is the only action that changes settings data inside the
392  * mouse, so this data needs to be reread
393  */
394 static ssize_t kone_sysfs_set_tcu(struct device *dev,
395                 struct device_attribute *attr, char const *buf, size_t size)
396 {
397         struct kone_device *kone;
398         struct usb_device *usb_dev;
399         int retval;
400         unsigned long state;
401
402         dev = dev->parent->parent;
403         kone = hid_get_drvdata(dev_get_drvdata(dev));
404         usb_dev = interface_to_usbdev(to_usb_interface(dev));
405
406         retval = strict_strtoul(buf, 10, &state);
407         if (retval)
408                 return retval;
409
410         if (state != 0 && state != 1)
411                 return -EINVAL;
412
413         mutex_lock(&kone->kone_lock);
414
415         if (state == 1) { /* state activate */
416                 retval = kone_tcu_command(usb_dev, 1);
417                 if (retval)
418                         goto exit_unlock;
419                 retval = kone_tcu_command(usb_dev, 2);
420                 if (retval)
421                         goto exit_unlock;
422                 ssleep(5); /* tcu needs this time for calibration */
423                 retval = kone_tcu_command(usb_dev, 3);
424                 if (retval)
425                         goto exit_unlock;
426                 retval = kone_tcu_command(usb_dev, 0);
427                 if (retval)
428                         goto exit_unlock;
429                 retval = kone_tcu_command(usb_dev, 4);
430                 if (retval)
431                         goto exit_unlock;
432                 /*
433                  * Kone needs this time to settle things.
434                  * Reading settings too early will result in invalid data.
435                  * Roccat's driver waits 1 sec, maybe this time could be
436                  * shortened.
437                  */
438                 ssleep(1);
439         }
440
441         /* calibration changes values in settings, so reread */
442         retval = kone_get_settings(usb_dev, &kone->settings);
443         if (retval)
444                 goto exit_no_settings;
445
446         /* only write settings back if activation state is different */
447         if (kone->settings.tcu != state) {
448                 kone->settings.tcu = state;
449                 kone_set_settings_checksum(&kone->settings);
450
451                 retval = kone_set_settings(usb_dev, &kone->settings);
452                 if (retval) {
453                         hid_err(usb_dev, "couldn't set tcu state\n");
454                         /*
455                          * try to reread valid settings into buffer overwriting
456                          * first error code
457                          */
458                         retval = kone_get_settings(usb_dev, &kone->settings);
459                         if (retval)
460                                 goto exit_no_settings;
461                         goto exit_unlock;
462                 }
463         }
464
465         retval = size;
466 exit_no_settings:
467         hid_err(usb_dev, "couldn't read settings\n");
468 exit_unlock:
469         mutex_unlock(&kone->kone_lock);
470         return retval;
471 }
472
473 static ssize_t kone_sysfs_show_startup_profile(struct device *dev,
474                 struct device_attribute *attr, char *buf)
475 {
476         struct kone_device *kone =
477                         hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
478         return snprintf(buf, PAGE_SIZE, "%d\n", kone->settings.startup_profile);
479 }
480
481 static ssize_t kone_sysfs_set_startup_profile(struct device *dev,
482                 struct device_attribute *attr, char const *buf, size_t size)
483 {
484         struct kone_device *kone;
485         struct usb_device *usb_dev;
486         int retval;
487         unsigned long new_startup_profile;
488
489         dev = dev->parent->parent;
490         kone = hid_get_drvdata(dev_get_drvdata(dev));
491         usb_dev = interface_to_usbdev(to_usb_interface(dev));
492
493         retval = strict_strtoul(buf, 10, &new_startup_profile);
494         if (retval)
495                 return retval;
496
497         if (new_startup_profile  < 1 || new_startup_profile > 5)
498                 return -EINVAL;
499
500         mutex_lock(&kone->kone_lock);
501
502         kone->settings.startup_profile = new_startup_profile;
503         kone_set_settings_checksum(&kone->settings);
504
505         retval = kone_set_settings(usb_dev, &kone->settings);
506
507         mutex_unlock(&kone->kone_lock);
508
509         if (retval)
510                 return retval;
511
512         /* changing the startup profile immediately activates this profile */
513         kone->actual_profile = new_startup_profile;
514         kone->actual_dpi = kone->profiles[kone->actual_profile - 1].startup_dpi;
515
516         return size;
517 }
518
519 static struct device_attribute kone_attributes[] = {
520         /*
521          * Read actual dpi settings.
522          * Returns raw value for further processing. Refer to enum
523          * kone_polling_rates to get real value.
524          */
525         __ATTR(actual_dpi, 0440, kone_sysfs_show_actual_dpi, NULL),
526         __ATTR(actual_profile, 0440, kone_sysfs_show_actual_profile, NULL),
527
528         /*
529          * The mouse can be equipped with one of four supplied weights from 5
530          * to 20 grams which are recognized and its value can be read out.
531          * This returns the raw value reported by the mouse for easy evaluation
532          * by software. Refer to enum kone_weights to get corresponding real
533          * weight.
534          */
535         __ATTR(weight, 0440, kone_sysfs_show_weight, NULL),
536
537         /*
538          * Prints firmware version stored in mouse as integer.
539          * The raw value reported by the mouse is returned for easy evaluation,
540          * to get the real version number the decimal point has to be shifted 2
541          * positions to the left. E.g. a value of 138 means 1.38.
542          */
543         __ATTR(firmware_version, 0440,
544                         kone_sysfs_show_firmware_version, NULL),
545
546         /*
547          * Prints state of Tracking Control Unit as number where 0 = off and
548          * 1 = on. Writing 0 deactivates tcu and writing 1 calibrates and
549          * activates the tcu
550          */
551         __ATTR(tcu, 0660, kone_sysfs_show_tcu, kone_sysfs_set_tcu),
552
553         /* Prints and takes the number of the profile the mouse starts with */
554         __ATTR(startup_profile, 0660,
555                         kone_sysfs_show_startup_profile,
556                         kone_sysfs_set_startup_profile),
557         __ATTR_NULL
558 };
559
560 static struct bin_attribute kone_bin_attributes[] = {
561         {
562                 .attr = { .name = "settings", .mode = 0660 },
563                 .size = sizeof(struct kone_settings),
564                 .read = kone_sysfs_read_settings,
565                 .write = kone_sysfs_write_settings
566         },
567         {
568                 .attr = { .name = "profile1", .mode = 0660 },
569                 .size = sizeof(struct kone_profile),
570                 .read = kone_sysfs_read_profilex,
571                 .write = kone_sysfs_write_profilex,
572                 .private = &profile_numbers[0]
573         },
574         {
575                 .attr = { .name = "profile2", .mode = 0660 },
576                 .size = sizeof(struct kone_profile),
577                 .read = kone_sysfs_read_profilex,
578                 .write = kone_sysfs_write_profilex,
579                 .private = &profile_numbers[1]
580         },
581         {
582                 .attr = { .name = "profile3", .mode = 0660 },
583                 .size = sizeof(struct kone_profile),
584                 .read = kone_sysfs_read_profilex,
585                 .write = kone_sysfs_write_profilex,
586                 .private = &profile_numbers[2]
587         },
588         {
589                 .attr = { .name = "profile4", .mode = 0660 },
590                 .size = sizeof(struct kone_profile),
591                 .read = kone_sysfs_read_profilex,
592                 .write = kone_sysfs_write_profilex,
593                 .private = &profile_numbers[3]
594         },
595         {
596                 .attr = { .name = "profile5", .mode = 0660 },
597                 .size = sizeof(struct kone_profile),
598                 .read = kone_sysfs_read_profilex,
599                 .write = kone_sysfs_write_profilex,
600                 .private = &profile_numbers[4]
601         },
602         __ATTR_NULL
603 };
604
605 static int kone_init_kone_device_struct(struct usb_device *usb_dev,
606                 struct kone_device *kone)
607 {
608         uint i;
609         int retval;
610
611         mutex_init(&kone->kone_lock);
612
613         for (i = 0; i < 5; ++i) {
614                 retval = kone_get_profile(usb_dev, &kone->profiles[i], i + 1);
615                 if (retval)
616                         return retval;
617         }
618
619         retval = kone_get_settings(usb_dev, &kone->settings);
620         if (retval)
621                 return retval;
622
623         retval = kone_get_firmware_version(usb_dev, &kone->firmware_version);
624         if (retval)
625                 return retval;
626
627         kone->actual_profile = kone->settings.startup_profile;
628         kone->actual_dpi = kone->profiles[kone->actual_profile].startup_dpi;
629
630         return 0;
631 }
632
633 /*
634  * Since IGNORE_MOUSE quirk moved to hid-apple, there is no way to bind only to
635  * mousepart if usb_hid is compiled into the kernel and kone is compiled as
636  * module.
637  * Secial behaviour is bound only to mousepart since only mouseevents contain
638  * additional notifications.
639  */
640 static int kone_init_specials(struct hid_device *hdev)
641 {
642         struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
643         struct usb_device *usb_dev = interface_to_usbdev(intf);
644         struct kone_device *kone;
645         int retval;
646
647         if (intf->cur_altsetting->desc.bInterfaceProtocol
648                         == USB_INTERFACE_PROTOCOL_MOUSE) {
649
650                 kone = kzalloc(sizeof(*kone), GFP_KERNEL);
651                 if (!kone) {
652                         hid_err(hdev, "can't alloc device descriptor\n");
653                         return -ENOMEM;
654                 }
655                 hid_set_drvdata(hdev, kone);
656
657                 retval = kone_init_kone_device_struct(usb_dev, kone);
658                 if (retval) {
659                         hid_err(hdev, "couldn't init struct kone_device\n");
660                         goto exit_free;
661                 }
662
663                 retval = roccat_connect(kone_class, hdev,
664                                 sizeof(struct kone_roccat_report));
665                 if (retval < 0) {
666                         hid_err(hdev, "couldn't init char dev\n");
667                         /* be tolerant about not getting chrdev */
668                 } else {
669                         kone->roccat_claimed = 1;
670                         kone->chrdev_minor = retval;
671                 }
672         } else {
673                 hid_set_drvdata(hdev, NULL);
674         }
675
676         return 0;
677 exit_free:
678         kfree(kone);
679         return retval;
680 }
681
682 static void kone_remove_specials(struct hid_device *hdev)
683 {
684         struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
685         struct kone_device *kone;
686
687         if (intf->cur_altsetting->desc.bInterfaceProtocol
688                         == USB_INTERFACE_PROTOCOL_MOUSE) {
689                 kone = hid_get_drvdata(hdev);
690                 if (kone->roccat_claimed)
691                         roccat_disconnect(kone->chrdev_minor);
692                 kfree(hid_get_drvdata(hdev));
693         }
694 }
695
696 static int kone_probe(struct hid_device *hdev, const struct hid_device_id *id)
697 {
698         int retval;
699
700         retval = hid_parse(hdev);
701         if (retval) {
702                 hid_err(hdev, "parse failed\n");
703                 goto exit;
704         }
705
706         retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
707         if (retval) {
708                 hid_err(hdev, "hw start failed\n");
709                 goto exit;
710         }
711
712         retval = kone_init_specials(hdev);
713         if (retval) {
714                 hid_err(hdev, "couldn't install mouse\n");
715                 goto exit_stop;
716         }
717
718         return 0;
719
720 exit_stop:
721         hid_hw_stop(hdev);
722 exit:
723         return retval;
724 }
725
726 static void kone_remove(struct hid_device *hdev)
727 {
728         kone_remove_specials(hdev);
729         hid_hw_stop(hdev);
730 }
731
732 /* handle special events and keep actual profile and dpi values up to date */
733 static void kone_keep_values_up_to_date(struct kone_device *kone,
734                 struct kone_mouse_event const *event)
735 {
736         switch (event->event) {
737         case kone_mouse_event_switch_profile:
738         case kone_mouse_event_osd_profile:
739                 kone->actual_profile = event->value;
740                 kone->actual_dpi = kone->profiles[kone->actual_profile - 1].
741                                 startup_dpi;
742                 break;
743         case kone_mouse_event_switch_dpi:
744         case kone_mouse_event_osd_dpi:
745                 kone->actual_dpi = event->value;
746                 break;
747         }
748 }
749
750 static void kone_report_to_chrdev(struct kone_device const *kone,
751                 struct kone_mouse_event const *event)
752 {
753         struct kone_roccat_report roccat_report;
754
755         switch (event->event) {
756         case kone_mouse_event_switch_profile:
757         case kone_mouse_event_switch_dpi:
758         case kone_mouse_event_osd_profile:
759         case kone_mouse_event_osd_dpi:
760                 roccat_report.event = event->event;
761                 roccat_report.value = event->value;
762                 roccat_report.key = 0;
763                 roccat_report_event(kone->chrdev_minor,
764                                 (uint8_t *)&roccat_report);
765                 break;
766         case kone_mouse_event_call_overlong_macro:
767                 if (event->value == kone_keystroke_action_press) {
768                         roccat_report.event = kone_mouse_event_call_overlong_macro;
769                         roccat_report.value = kone->actual_profile;
770                         roccat_report.key = event->macro_key;
771                         roccat_report_event(kone->chrdev_minor,
772                                         (uint8_t *)&roccat_report);
773                 }
774                 break;
775         }
776
777 }
778
779 /*
780  * Is called for keyboard- and mousepart.
781  * Only mousepart gets informations about special events in its extended event
782  * structure.
783  */
784 static int kone_raw_event(struct hid_device *hdev, struct hid_report *report,
785                 u8 *data, int size)
786 {
787         struct kone_device *kone = hid_get_drvdata(hdev);
788         struct kone_mouse_event *event = (struct kone_mouse_event *)data;
789
790         /* keyboard events are always processed by default handler */
791         if (size != sizeof(struct kone_mouse_event))
792                 return 0;
793
794         /*
795          * Firmware 1.38 introduced new behaviour for tilt and special buttons.
796          * Pressed button is reported in each movement event.
797          * Workaround sends only one event per press.
798          */
799         if (memcmp(&kone->last_mouse_event.tilt, &event->tilt, 5))
800                 memcpy(&kone->last_mouse_event, event,
801                                 sizeof(struct kone_mouse_event));
802         else
803                 memset(&event->tilt, 0, 5);
804
805         kone_keep_values_up_to_date(kone, event);
806
807         if (kone->roccat_claimed)
808                 kone_report_to_chrdev(kone, event);
809
810         return 0; /* always do further processing */
811 }
812
813 static const struct hid_device_id kone_devices[] = {
814         { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONE) },
815         { }
816 };
817
818 MODULE_DEVICE_TABLE(hid, kone_devices);
819
820 static struct hid_driver kone_driver = {
821                 .name = "kone",
822                 .id_table = kone_devices,
823                 .probe = kone_probe,
824                 .remove = kone_remove,
825                 .raw_event = kone_raw_event
826 };
827
828 static int __init kone_init(void)
829 {
830         int retval;
831
832         /* class name has to be same as driver name */
833         kone_class = class_create(THIS_MODULE, "kone");
834         if (IS_ERR(kone_class))
835                 return PTR_ERR(kone_class);
836         kone_class->dev_attrs = kone_attributes;
837         kone_class->dev_bin_attrs = kone_bin_attributes;
838
839         retval = hid_register_driver(&kone_driver);
840         if (retval)
841                 class_destroy(kone_class);
842         return retval;
843 }
844
845 static void __exit kone_exit(void)
846 {
847         hid_unregister_driver(&kone_driver);
848         class_destroy(kone_class);
849 }
850
851 module_init(kone_init);
852 module_exit(kone_exit);
853
854 MODULE_AUTHOR("Stefan Achatz");
855 MODULE_DESCRIPTION("USB Roccat Kone driver");
856 MODULE_LICENSE("GPL v2");