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