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