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