1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60#include <linux/jiffies.h>
61#include <linux/kernel.h>
62#include <linux/slab.h>
63#include <linux/module.h>
64#include <linux/usb/input.h>
65#include <linux/uaccess.h>
66#include <asm/unaligned.h>
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165#define USB_VENDOR_ID_AIPTEK 0x08ca
166#define USB_VENDOR_ID_KYE 0x0458
167#define USB_REQ_GET_REPORT 0x01
168#define USB_REQ_SET_REPORT 0x09
169
170
171
172#define AIPTEK_POINTER_ONLY_MOUSE_MODE 0
173#define AIPTEK_POINTER_ONLY_STYLUS_MODE 1
174#define AIPTEK_POINTER_EITHER_MODE 2
175
176#define AIPTEK_POINTER_ALLOW_MOUSE_MODE(a) \
177 (a == AIPTEK_POINTER_ONLY_MOUSE_MODE || \
178 a == AIPTEK_POINTER_EITHER_MODE)
179#define AIPTEK_POINTER_ALLOW_STYLUS_MODE(a) \
180 (a == AIPTEK_POINTER_ONLY_STYLUS_MODE || \
181 a == AIPTEK_POINTER_EITHER_MODE)
182
183
184
185#define AIPTEK_COORDINATE_RELATIVE_MODE 0
186#define AIPTEK_COORDINATE_ABSOLUTE_MODE 1
187
188
189
190#define AIPTEK_TILT_MIN (-128)
191#define AIPTEK_TILT_MAX 127
192#define AIPTEK_TILT_DISABLE (-10101)
193
194
195
196#define AIPTEK_WHEEL_MIN 0
197#define AIPTEK_WHEEL_MAX 1024
198#define AIPTEK_WHEEL_DISABLE (-10101)
199
200
201
202
203
204
205
206#define AIPTEK_TOOL_BUTTON_PEN_MODE BTN_TOOL_PEN
207#define AIPTEK_TOOL_BUTTON_PENCIL_MODE BTN_TOOL_PENCIL
208#define AIPTEK_TOOL_BUTTON_BRUSH_MODE BTN_TOOL_BRUSH
209#define AIPTEK_TOOL_BUTTON_AIRBRUSH_MODE BTN_TOOL_AIRBRUSH
210#define AIPTEK_TOOL_BUTTON_ERASER_MODE BTN_TOOL_RUBBER
211#define AIPTEK_TOOL_BUTTON_MOUSE_MODE BTN_TOOL_MOUSE
212#define AIPTEK_TOOL_BUTTON_LENS_MODE BTN_TOOL_LENS
213
214
215
216#define AIPTEK_DIAGNOSTIC_NA 0
217#define AIPTEK_DIAGNOSTIC_SENDING_RELATIVE_IN_ABSOLUTE 1
218#define AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE 2
219#define AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED 3
220
221
222
223
224#define AIPTEK_JITTER_DELAY_DEFAULT 50
225
226
227
228
229
230#define AIPTEK_PROGRAMMABLE_DELAY_25 25
231#define AIPTEK_PROGRAMMABLE_DELAY_50 50
232#define AIPTEK_PROGRAMMABLE_DELAY_100 100
233#define AIPTEK_PROGRAMMABLE_DELAY_200 200
234#define AIPTEK_PROGRAMMABLE_DELAY_300 300
235#define AIPTEK_PROGRAMMABLE_DELAY_400 400
236#define AIPTEK_PROGRAMMABLE_DELAY_DEFAULT AIPTEK_PROGRAMMABLE_DELAY_400
237
238
239
240#define AIPTEK_MOUSE_LEFT_BUTTON 0x04
241#define AIPTEK_MOUSE_RIGHT_BUTTON 0x08
242#define AIPTEK_MOUSE_MIDDLE_BUTTON 0x10
243
244
245
246#define AIPTEK_STYLUS_LOWER_BUTTON 0x08
247#define AIPTEK_STYLUS_UPPER_BUTTON 0x10
248
249
250
251#define AIPTEK_PACKET_LENGTH 8
252
253
254
255
256
257
258#define AIPTEK_REPORT_TOOL_UNKNOWN 0x10
259#define AIPTEK_REPORT_TOOL_STYLUS 0x20
260#define AIPTEK_REPORT_TOOL_MOUSE 0x40
261
262static int programmableDelay = AIPTEK_PROGRAMMABLE_DELAY_DEFAULT;
263static int jitterDelay = AIPTEK_JITTER_DELAY_DEFAULT;
264
265struct aiptek_features {
266 int odmCode;
267 int modelCode;
268 int firmwareCode;
269 char usbPath[64 + 1];
270};
271
272struct aiptek_settings {
273 int pointerMode;
274 int coordinateMode;
275 int toolMode;
276 int xTilt;
277 int yTilt;
278 int wheel;
279 int stylusButtonUpper;
280 int stylusButtonLower;
281 int mouseButtonLeft;
282 int mouseButtonMiddle;
283 int mouseButtonRight;
284 int programmableDelay;
285 int jitterDelay;
286};
287
288struct aiptek {
289 struct input_dev *inputdev;
290 struct usb_interface *intf;
291 struct urb *urb;
292 dma_addr_t data_dma;
293 struct aiptek_features features;
294 struct aiptek_settings curSetting;
295 struct aiptek_settings newSetting;
296 unsigned int ifnum;
297 int diagnostic;
298 unsigned long eventCount;
299 int inDelay;
300 unsigned long endDelay;
301 int previousJitterable;
302
303 int lastMacro;
304 int previousToolMode;
305 unsigned char *data;
306};
307
308static const int eventTypes[] = {
309 EV_KEY, EV_ABS, EV_REL, EV_MSC,
310};
311
312static const int absEvents[] = {
313 ABS_X, ABS_Y, ABS_PRESSURE, ABS_TILT_X, ABS_TILT_Y,
314 ABS_WHEEL, ABS_MISC,
315};
316
317static const int relEvents[] = {
318 REL_X, REL_Y, REL_WHEEL,
319};
320
321static const int buttonEvents[] = {
322 BTN_LEFT, BTN_RIGHT, BTN_MIDDLE,
323 BTN_TOOL_PEN, BTN_TOOL_RUBBER, BTN_TOOL_PENCIL, BTN_TOOL_AIRBRUSH,
324 BTN_TOOL_BRUSH, BTN_TOOL_MOUSE, BTN_TOOL_LENS, BTN_TOUCH,
325 BTN_STYLUS, BTN_STYLUS2,
326};
327
328
329
330
331
332
333static const int macroKeyEvents[] = {
334 KEY_ESC, KEY_F1, KEY_F2, KEY_F3, KEY_F4, KEY_F5,
335 KEY_F6, KEY_F7, KEY_F8, KEY_F9, KEY_F10, KEY_F11,
336 KEY_F12, KEY_F13, KEY_F14, KEY_F15, KEY_F16, KEY_F17,
337 KEY_F18, KEY_F19, KEY_F20, KEY_F21, KEY_F22, KEY_F23,
338 KEY_F24, KEY_STOP, KEY_AGAIN, KEY_PROPS, KEY_UNDO,
339 KEY_FRONT, KEY_COPY, KEY_OPEN, KEY_PASTE, 0
340};
341
342
343
344
345
346#define AIPTEK_INVALID_VALUE -1
347
348struct aiptek_map {
349 const char *string;
350 int value;
351};
352
353static int map_str_to_val(const struct aiptek_map *map, const char *str, size_t count)
354{
355 const struct aiptek_map *p;
356
357 if (str[count - 1] == '\n')
358 count--;
359
360 for (p = map; p->string; p++)
361 if (!strncmp(str, p->string, count))
362 return p->value;
363
364 return AIPTEK_INVALID_VALUE;
365}
366
367static const char *map_val_to_str(const struct aiptek_map *map, int val)
368{
369 const struct aiptek_map *p;
370
371 for (p = map; p->value != AIPTEK_INVALID_VALUE; p++)
372 if (val == p->value)
373 return p->string;
374
375 return "unknown";
376}
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412static void aiptek_irq(struct urb *urb)
413{
414 struct aiptek *aiptek = urb->context;
415 unsigned char *data = aiptek->data;
416 struct input_dev *inputdev = aiptek->inputdev;
417 struct usb_interface *intf = aiptek->intf;
418 int jitterable = 0;
419 int retval, macro, x, y, z, left, right, middle, p, dv, tip, bs, pck;
420
421 switch (urb->status) {
422 case 0:
423
424 break;
425
426 case -ECONNRESET:
427 case -ENOENT:
428 case -ESHUTDOWN:
429
430 dev_dbg(&intf->dev, "%s - urb shutting down with status: %d\n",
431 __func__, urb->status);
432 return;
433
434 default:
435 dev_dbg(&intf->dev, "%s - nonzero urb status received: %d\n",
436 __func__, urb->status);
437 goto exit;
438 }
439
440
441
442 if (aiptek->inDelay == 1 && time_after(aiptek->endDelay, jiffies)) {
443 goto exit;
444 }
445
446 aiptek->inDelay = 0;
447 aiptek->eventCount++;
448
449
450
451
452
453 if (data[0] == 1) {
454 if (aiptek->curSetting.coordinateMode ==
455 AIPTEK_COORDINATE_ABSOLUTE_MODE) {
456 aiptek->diagnostic =
457 AIPTEK_DIAGNOSTIC_SENDING_RELATIVE_IN_ABSOLUTE;
458 } else {
459 x = (signed char) data[2];
460 y = (signed char) data[3];
461
462
463
464
465
466
467
468
469 jitterable = data[1] & 0x07;
470
471 left = (data[1] & aiptek->curSetting.mouseButtonLeft >> 2) != 0 ? 1 : 0;
472 right = (data[1] & aiptek->curSetting.mouseButtonRight >> 2) != 0 ? 1 : 0;
473 middle = (data[1] & aiptek->curSetting.mouseButtonMiddle >> 2) != 0 ? 1 : 0;
474
475 input_report_key(inputdev, BTN_LEFT, left);
476 input_report_key(inputdev, BTN_MIDDLE, middle);
477 input_report_key(inputdev, BTN_RIGHT, right);
478
479 input_report_abs(inputdev, ABS_MISC,
480 1 | AIPTEK_REPORT_TOOL_UNKNOWN);
481 input_report_rel(inputdev, REL_X, x);
482 input_report_rel(inputdev, REL_Y, y);
483
484
485
486
487 if (aiptek->curSetting.wheel != AIPTEK_WHEEL_DISABLE) {
488 input_report_rel(inputdev, REL_WHEEL,
489 aiptek->curSetting.wheel);
490 aiptek->curSetting.wheel = AIPTEK_WHEEL_DISABLE;
491 }
492 if (aiptek->lastMacro != -1) {
493 input_report_key(inputdev,
494 macroKeyEvents[aiptek->lastMacro], 0);
495 aiptek->lastMacro = -1;
496 }
497 input_sync(inputdev);
498 }
499 }
500
501
502
503 else if (data[0] == 2) {
504 if (aiptek->curSetting.coordinateMode == AIPTEK_COORDINATE_RELATIVE_MODE) {
505 aiptek->diagnostic = AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE;
506 } else if (!AIPTEK_POINTER_ALLOW_STYLUS_MODE
507 (aiptek->curSetting.pointerMode)) {
508 aiptek->diagnostic = AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED;
509 } else {
510 x = get_unaligned_le16(data + 1);
511 y = get_unaligned_le16(data + 3);
512 z = get_unaligned_le16(data + 6);
513
514 dv = (data[5] & 0x01) != 0 ? 1 : 0;
515 p = (data[5] & 0x02) != 0 ? 1 : 0;
516 tip = (data[5] & 0x04) != 0 ? 1 : 0;
517
518
519
520 jitterable = data[5] & 0x18;
521
522 bs = (data[5] & aiptek->curSetting.stylusButtonLower) != 0 ? 1 : 0;
523 pck = (data[5] & aiptek->curSetting.stylusButtonUpper) != 0 ? 1 : 0;
524
525
526
527
528
529 if (dv != 0) {
530
531
532
533 if (aiptek->previousToolMode !=
534 aiptek->curSetting.toolMode) {
535 input_report_key(inputdev,
536 aiptek->previousToolMode, 0);
537 input_report_key(inputdev,
538 aiptek->curSetting.toolMode,
539 1);
540 aiptek->previousToolMode =
541 aiptek->curSetting.toolMode;
542 }
543
544 if (p != 0) {
545 input_report_abs(inputdev, ABS_X, x);
546 input_report_abs(inputdev, ABS_Y, y);
547 input_report_abs(inputdev, ABS_PRESSURE, z);
548
549 input_report_key(inputdev, BTN_TOUCH, tip);
550 input_report_key(inputdev, BTN_STYLUS, bs);
551 input_report_key(inputdev, BTN_STYLUS2, pck);
552
553 if (aiptek->curSetting.xTilt !=
554 AIPTEK_TILT_DISABLE) {
555 input_report_abs(inputdev,
556 ABS_TILT_X,
557 aiptek->curSetting.xTilt);
558 }
559 if (aiptek->curSetting.yTilt != AIPTEK_TILT_DISABLE) {
560 input_report_abs(inputdev,
561 ABS_TILT_Y,
562 aiptek->curSetting.yTilt);
563 }
564
565
566
567
568 if (aiptek->curSetting.wheel !=
569 AIPTEK_WHEEL_DISABLE) {
570 input_report_abs(inputdev,
571 ABS_WHEEL,
572 aiptek->curSetting.wheel);
573 aiptek->curSetting.wheel = AIPTEK_WHEEL_DISABLE;
574 }
575 }
576 input_report_abs(inputdev, ABS_MISC, p | AIPTEK_REPORT_TOOL_STYLUS);
577 if (aiptek->lastMacro != -1) {
578 input_report_key(inputdev,
579 macroKeyEvents[aiptek->lastMacro], 0);
580 aiptek->lastMacro = -1;
581 }
582 input_sync(inputdev);
583 }
584 }
585 }
586
587
588 else if (data[0] == 3) {
589 if (aiptek->curSetting.coordinateMode == AIPTEK_COORDINATE_RELATIVE_MODE) {
590 aiptek->diagnostic = AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE;
591 } else if (!AIPTEK_POINTER_ALLOW_MOUSE_MODE
592 (aiptek->curSetting.pointerMode)) {
593 aiptek->diagnostic = AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED;
594 } else {
595 x = get_unaligned_le16(data + 1);
596 y = get_unaligned_le16(data + 3);
597
598 jitterable = data[5] & 0x1c;
599
600 dv = (data[5] & 0x01) != 0 ? 1 : 0;
601 p = (data[5] & 0x02) != 0 ? 1 : 0;
602 left = (data[5] & aiptek->curSetting.mouseButtonLeft) != 0 ? 1 : 0;
603 right = (data[5] & aiptek->curSetting.mouseButtonRight) != 0 ? 1 : 0;
604 middle = (data[5] & aiptek->curSetting.mouseButtonMiddle) != 0 ? 1 : 0;
605
606 if (dv != 0) {
607
608
609
610 if (aiptek->previousToolMode !=
611 aiptek->curSetting.toolMode) {
612 input_report_key(inputdev,
613 aiptek->previousToolMode, 0);
614 input_report_key(inputdev,
615 aiptek->curSetting.toolMode,
616 1);
617 aiptek->previousToolMode =
618 aiptek->curSetting.toolMode;
619 }
620
621 if (p != 0) {
622 input_report_abs(inputdev, ABS_X, x);
623 input_report_abs(inputdev, ABS_Y, y);
624
625 input_report_key(inputdev, BTN_LEFT, left);
626 input_report_key(inputdev, BTN_MIDDLE, middle);
627 input_report_key(inputdev, BTN_RIGHT, right);
628
629
630
631
632 if (aiptek->curSetting.wheel != AIPTEK_WHEEL_DISABLE) {
633 input_report_abs(inputdev,
634 ABS_WHEEL,
635 aiptek->curSetting.wheel);
636 aiptek->curSetting.wheel = AIPTEK_WHEEL_DISABLE;
637 }
638 }
639 input_report_abs(inputdev, ABS_MISC, p | AIPTEK_REPORT_TOOL_MOUSE);
640 if (aiptek->lastMacro != -1) {
641 input_report_key(inputdev,
642 macroKeyEvents[aiptek->lastMacro], 0);
643 aiptek->lastMacro = -1;
644 }
645 input_sync(inputdev);
646 }
647 }
648 }
649
650
651 else if (data[0] == 4) {
652 jitterable = data[1] & 0x18;
653
654 dv = (data[1] & 0x01) != 0 ? 1 : 0;
655 p = (data[1] & 0x02) != 0 ? 1 : 0;
656 tip = (data[1] & 0x04) != 0 ? 1 : 0;
657 bs = (data[1] & aiptek->curSetting.stylusButtonLower) != 0 ? 1 : 0;
658 pck = (data[1] & aiptek->curSetting.stylusButtonUpper) != 0 ? 1 : 0;
659
660 macro = dv && p && tip && !(data[3] & 1) ? (data[3] >> 1) : -1;
661 z = get_unaligned_le16(data + 4);
662
663 if (dv) {
664
665
666
667 if (aiptek->previousToolMode !=
668 aiptek->curSetting.toolMode) {
669 input_report_key(inputdev,
670 aiptek->previousToolMode, 0);
671 input_report_key(inputdev,
672 aiptek->curSetting.toolMode,
673 1);
674 aiptek->previousToolMode =
675 aiptek->curSetting.toolMode;
676 }
677 }
678
679 if (aiptek->lastMacro != -1 && aiptek->lastMacro != macro) {
680 input_report_key(inputdev, macroKeyEvents[aiptek->lastMacro], 0);
681 aiptek->lastMacro = -1;
682 }
683
684 if (macro != -1 && macro != aiptek->lastMacro) {
685 input_report_key(inputdev, macroKeyEvents[macro], 1);
686 aiptek->lastMacro = macro;
687 }
688 input_report_abs(inputdev, ABS_MISC,
689 p | AIPTEK_REPORT_TOOL_STYLUS);
690 input_sync(inputdev);
691 }
692
693
694 else if (data[0] == 5) {
695 jitterable = data[1] & 0x1c;
696
697 dv = (data[1] & 0x01) != 0 ? 1 : 0;
698 p = (data[1] & 0x02) != 0 ? 1 : 0;
699 left = (data[1]& aiptek->curSetting.mouseButtonLeft) != 0 ? 1 : 0;
700 right = (data[1] & aiptek->curSetting.mouseButtonRight) != 0 ? 1 : 0;
701 middle = (data[1] & aiptek->curSetting.mouseButtonMiddle) != 0 ? 1 : 0;
702 macro = dv && p && left && !(data[3] & 1) ? (data[3] >> 1) : 0;
703
704 if (dv) {
705
706
707
708 if (aiptek->previousToolMode !=
709 aiptek->curSetting.toolMode) {
710 input_report_key(inputdev,
711 aiptek->previousToolMode, 0);
712 input_report_key(inputdev,
713 aiptek->curSetting.toolMode, 1);
714 aiptek->previousToolMode = aiptek->curSetting.toolMode;
715 }
716 }
717
718 if (aiptek->lastMacro != -1 && aiptek->lastMacro != macro) {
719 input_report_key(inputdev, macroKeyEvents[aiptek->lastMacro], 0);
720 aiptek->lastMacro = -1;
721 }
722
723 if (macro != -1 && macro != aiptek->lastMacro) {
724 input_report_key(inputdev, macroKeyEvents[macro], 1);
725 aiptek->lastMacro = macro;
726 }
727
728 input_report_abs(inputdev, ABS_MISC,
729 p | AIPTEK_REPORT_TOOL_MOUSE);
730 input_sync(inputdev);
731 }
732
733
734
735
736
737
738 else if (data[0] == 6) {
739 macro = get_unaligned_le16(data + 1);
740 if (macro > 0) {
741 input_report_key(inputdev, macroKeyEvents[macro - 1],
742 0);
743 }
744 if (macro < 25) {
745 input_report_key(inputdev, macroKeyEvents[macro + 1],
746 0);
747 }
748
749
750
751
752 if (aiptek->previousToolMode !=
753 aiptek->curSetting.toolMode) {
754 input_report_key(inputdev,
755 aiptek->previousToolMode, 0);
756 input_report_key(inputdev,
757 aiptek->curSetting.toolMode,
758 1);
759 aiptek->previousToolMode =
760 aiptek->curSetting.toolMode;
761 }
762
763 input_report_key(inputdev, macroKeyEvents[macro], 1);
764 input_report_abs(inputdev, ABS_MISC,
765 1 | AIPTEK_REPORT_TOOL_UNKNOWN);
766 input_sync(inputdev);
767 } else {
768 dev_dbg(&intf->dev, "Unknown report %d\n", data[0]);
769 }
770
771
772
773
774
775
776
777
778
779
780
781
782
783 if (aiptek->previousJitterable != jitterable &&
784 aiptek->curSetting.jitterDelay != 0 && aiptek->inDelay != 1) {
785 aiptek->endDelay = jiffies +
786 ((aiptek->curSetting.jitterDelay * HZ) / 1000);
787 aiptek->inDelay = 1;
788 }
789 aiptek->previousJitterable = jitterable;
790
791exit:
792 retval = usb_submit_urb(urb, GFP_ATOMIC);
793 if (retval != 0) {
794 dev_err(&intf->dev,
795 "%s - usb_submit_urb failed with result %d\n",
796 __func__, retval);
797 }
798}
799
800
801
802
803
804
805
806
807
808static const struct usb_device_id aiptek_ids[] = {
809 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x01)},
810 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x10)},
811 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x20)},
812 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x21)},
813 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x22)},
814 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x23)},
815 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x24)},
816 {USB_DEVICE(USB_VENDOR_ID_KYE, 0x5003)},
817 {}
818};
819
820MODULE_DEVICE_TABLE(usb, aiptek_ids);
821
822
823
824
825static int aiptek_open(struct input_dev *inputdev)
826{
827 struct aiptek *aiptek = input_get_drvdata(inputdev);
828
829 aiptek->urb->dev = interface_to_usbdev(aiptek->intf);
830 if (usb_submit_urb(aiptek->urb, GFP_KERNEL) != 0)
831 return -EIO;
832
833 return 0;
834}
835
836
837
838
839static void aiptek_close(struct input_dev *inputdev)
840{
841 struct aiptek *aiptek = input_get_drvdata(inputdev);
842
843 usb_kill_urb(aiptek->urb);
844}
845
846
847
848
849
850static int
851aiptek_set_report(struct aiptek *aiptek,
852 unsigned char report_type,
853 unsigned char report_id, void *buffer, int size)
854{
855 struct usb_device *udev = interface_to_usbdev(aiptek->intf);
856
857 return usb_control_msg(udev,
858 usb_sndctrlpipe(udev, 0),
859 USB_REQ_SET_REPORT,
860 USB_TYPE_CLASS | USB_RECIP_INTERFACE |
861 USB_DIR_OUT, (report_type << 8) + report_id,
862 aiptek->ifnum, buffer, size, 5000);
863}
864
865static int
866aiptek_get_report(struct aiptek *aiptek,
867 unsigned char report_type,
868 unsigned char report_id, void *buffer, int size)
869{
870 struct usb_device *udev = interface_to_usbdev(aiptek->intf);
871
872 return usb_control_msg(udev,
873 usb_rcvctrlpipe(udev, 0),
874 USB_REQ_GET_REPORT,
875 USB_TYPE_CLASS | USB_RECIP_INTERFACE |
876 USB_DIR_IN, (report_type << 8) + report_id,
877 aiptek->ifnum, buffer, size, 5000);
878}
879
880
881
882
883static int
884aiptek_command(struct aiptek *aiptek, unsigned char command, unsigned char data)
885{
886 const int sizeof_buf = 3 * sizeof(u8);
887 int ret;
888 u8 *buf;
889
890 buf = kmalloc(sizeof_buf, GFP_KERNEL);
891 if (!buf)
892 return -ENOMEM;
893
894 buf[0] = 2;
895 buf[1] = command;
896 buf[2] = data;
897
898 if ((ret =
899 aiptek_set_report(aiptek, 3, 2, buf, sizeof_buf)) != sizeof_buf) {
900 dev_dbg(&aiptek->intf->dev,
901 "aiptek_program: failed, tried to send: 0x%02x 0x%02x\n",
902 command, data);
903 }
904 kfree(buf);
905 return ret < 0 ? ret : 0;
906}
907
908
909
910
911
912
913static int
914aiptek_query(struct aiptek *aiptek, unsigned char command, unsigned char data)
915{
916 const int sizeof_buf = 3 * sizeof(u8);
917 int ret;
918 u8 *buf;
919
920 buf = kmalloc(sizeof_buf, GFP_KERNEL);
921 if (!buf)
922 return -ENOMEM;
923
924 buf[0] = 2;
925 buf[1] = command;
926 buf[2] = data;
927
928 if (aiptek_command(aiptek, command, data) != 0) {
929 kfree(buf);
930 return -EIO;
931 }
932 msleep(aiptek->curSetting.programmableDelay);
933
934 if ((ret =
935 aiptek_get_report(aiptek, 3, 2, buf, sizeof_buf)) != sizeof_buf) {
936 dev_dbg(&aiptek->intf->dev,
937 "aiptek_query failed: returned 0x%02x 0x%02x 0x%02x\n",
938 buf[0], buf[1], buf[2]);
939 ret = -EIO;
940 } else {
941 ret = get_unaligned_le16(buf + 1);
942 }
943 kfree(buf);
944 return ret;
945}
946
947
948
949
950
951static int aiptek_program_tablet(struct aiptek *aiptek)
952{
953 int ret;
954
955 if ((ret = aiptek_command(aiptek, 0x18, 0x04)) < 0)
956 return ret;
957
958
959 if ((ret = aiptek_query(aiptek, 0x02, 0x00)) < 0)
960 return ret;
961 aiptek->features.modelCode = ret & 0xff;
962
963
964 if ((ret = aiptek_query(aiptek, 0x03, 0x00)) < 0)
965 return ret;
966 aiptek->features.odmCode = ret;
967
968
969 if ((ret = aiptek_query(aiptek, 0x04, 0x00)) < 0)
970 return ret;
971 aiptek->features.firmwareCode = ret;
972
973
974 if ((ret = aiptek_query(aiptek, 0x01, 0x00)) < 0)
975 return ret;
976 input_set_abs_params(aiptek->inputdev, ABS_X, 0, ret - 1, 0, 0);
977
978
979 if ((ret = aiptek_query(aiptek, 0x01, 0x01)) < 0)
980 return ret;
981 input_set_abs_params(aiptek->inputdev, ABS_Y, 0, ret - 1, 0, 0);
982
983
984 if ((ret = aiptek_query(aiptek, 0x08, 0x00)) < 0)
985 return ret;
986 input_set_abs_params(aiptek->inputdev, ABS_PRESSURE, 0, ret - 1, 0, 0);
987
988
989
990
991 if (aiptek->curSetting.coordinateMode ==
992 AIPTEK_COORDINATE_ABSOLUTE_MODE) {
993
994 if ((ret = aiptek_command(aiptek, 0x10, 0x01)) < 0) {
995 return ret;
996 }
997 } else {
998
999 if ((ret = aiptek_command(aiptek, 0x10, 0x00)) < 0) {
1000 return ret;
1001 }
1002 }
1003
1004
1005 if ((ret = aiptek_command(aiptek, 0x11, 0x02)) < 0)
1006 return ret;
1007#if 0
1008
1009 if ((ret = aiptek_command(aiptek, 0x17, 0x00)) < 0)
1010 return ret;
1011#endif
1012
1013
1014 if ((ret = aiptek_command(aiptek, 0x12, 0xff)) < 0)
1015 return ret;
1016
1017
1018
1019 aiptek->diagnostic = AIPTEK_DIAGNOSTIC_NA;
1020 aiptek->eventCount = 0;
1021
1022 return 0;
1023}
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035static ssize_t show_tabletSize(struct device *dev, struct device_attribute *attr, char *buf)
1036{
1037 struct aiptek *aiptek = dev_get_drvdata(dev);
1038
1039 return sysfs_emit(buf, "%dx%d\n",
1040 input_abs_get_max(aiptek->inputdev, ABS_X) + 1,
1041 input_abs_get_max(aiptek->inputdev, ABS_Y) + 1);
1042}
1043
1044
1045
1046
1047
1048
1049
1050static DEVICE_ATTR(size, S_IRUGO, show_tabletSize, NULL);
1051
1052
1053
1054
1055
1056static struct aiptek_map pointer_mode_map[] = {
1057 { "stylus", AIPTEK_POINTER_ONLY_STYLUS_MODE },
1058 { "mouse", AIPTEK_POINTER_ONLY_MOUSE_MODE },
1059 { "either", AIPTEK_POINTER_EITHER_MODE },
1060 { NULL, AIPTEK_INVALID_VALUE }
1061};
1062
1063static ssize_t show_tabletPointerMode(struct device *dev, struct device_attribute *attr, char *buf)
1064{
1065 struct aiptek *aiptek = dev_get_drvdata(dev);
1066
1067 return sysfs_emit(buf, "%s\n", map_val_to_str(pointer_mode_map,
1068 aiptek->curSetting.pointerMode));
1069}
1070
1071static ssize_t
1072store_tabletPointerMode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1073{
1074 struct aiptek *aiptek = dev_get_drvdata(dev);
1075 int new_mode = map_str_to_val(pointer_mode_map, buf, count);
1076
1077 if (new_mode == AIPTEK_INVALID_VALUE)
1078 return -EINVAL;
1079
1080 aiptek->newSetting.pointerMode = new_mode;
1081 return count;
1082}
1083
1084static DEVICE_ATTR(pointer_mode,
1085 S_IRUGO | S_IWUSR,
1086 show_tabletPointerMode, store_tabletPointerMode);
1087
1088
1089
1090
1091
1092
1093static struct aiptek_map coordinate_mode_map[] = {
1094 { "absolute", AIPTEK_COORDINATE_ABSOLUTE_MODE },
1095 { "relative", AIPTEK_COORDINATE_RELATIVE_MODE },
1096 { NULL, AIPTEK_INVALID_VALUE }
1097};
1098
1099static ssize_t show_tabletCoordinateMode(struct device *dev, struct device_attribute *attr, char *buf)
1100{
1101 struct aiptek *aiptek = dev_get_drvdata(dev);
1102
1103 return sysfs_emit(buf, "%s\n", map_val_to_str(coordinate_mode_map,
1104 aiptek->curSetting.coordinateMode));
1105}
1106
1107static ssize_t
1108store_tabletCoordinateMode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1109{
1110 struct aiptek *aiptek = dev_get_drvdata(dev);
1111 int new_mode = map_str_to_val(coordinate_mode_map, buf, count);
1112
1113 if (new_mode == AIPTEK_INVALID_VALUE)
1114 return -EINVAL;
1115
1116 aiptek->newSetting.coordinateMode = new_mode;
1117 return count;
1118}
1119
1120static DEVICE_ATTR(coordinate_mode,
1121 S_IRUGO | S_IWUSR,
1122 show_tabletCoordinateMode, store_tabletCoordinateMode);
1123
1124
1125
1126
1127
1128
1129static struct aiptek_map tool_mode_map[] = {
1130 { "mouse", AIPTEK_TOOL_BUTTON_MOUSE_MODE },
1131 { "eraser", AIPTEK_TOOL_BUTTON_ERASER_MODE },
1132 { "pencil", AIPTEK_TOOL_BUTTON_PENCIL_MODE },
1133 { "pen", AIPTEK_TOOL_BUTTON_PEN_MODE },
1134 { "brush", AIPTEK_TOOL_BUTTON_BRUSH_MODE },
1135 { "airbrush", AIPTEK_TOOL_BUTTON_AIRBRUSH_MODE },
1136 { "lens", AIPTEK_TOOL_BUTTON_LENS_MODE },
1137 { NULL, AIPTEK_INVALID_VALUE }
1138};
1139
1140static ssize_t show_tabletToolMode(struct device *dev, struct device_attribute *attr, char *buf)
1141{
1142 struct aiptek *aiptek = dev_get_drvdata(dev);
1143
1144 return sysfs_emit(buf, "%s\n", map_val_to_str(tool_mode_map,
1145 aiptek->curSetting.toolMode));
1146}
1147
1148static ssize_t
1149store_tabletToolMode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1150{
1151 struct aiptek *aiptek = dev_get_drvdata(dev);
1152 int new_mode = map_str_to_val(tool_mode_map, buf, count);
1153
1154 if (new_mode == AIPTEK_INVALID_VALUE)
1155 return -EINVAL;
1156
1157 aiptek->newSetting.toolMode = new_mode;
1158 return count;
1159}
1160
1161static DEVICE_ATTR(tool_mode,
1162 S_IRUGO | S_IWUSR,
1163 show_tabletToolMode, store_tabletToolMode);
1164
1165
1166
1167
1168
1169static ssize_t show_tabletXtilt(struct device *dev, struct device_attribute *attr, char *buf)
1170{
1171 struct aiptek *aiptek = dev_get_drvdata(dev);
1172
1173 if (aiptek->curSetting.xTilt == AIPTEK_TILT_DISABLE) {
1174 return sysfs_emit(buf, "disable\n");
1175 } else {
1176 return sysfs_emit(buf, "%d\n", aiptek->curSetting.xTilt);
1177 }
1178}
1179
1180static ssize_t
1181store_tabletXtilt(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1182{
1183 struct aiptek *aiptek = dev_get_drvdata(dev);
1184 int x;
1185
1186 if (kstrtoint(buf, 10, &x)) {
1187 size_t len = buf[count - 1] == '\n' ? count - 1 : count;
1188
1189 if (strncmp(buf, "disable", len))
1190 return -EINVAL;
1191
1192 aiptek->newSetting.xTilt = AIPTEK_TILT_DISABLE;
1193 } else {
1194 if (x < AIPTEK_TILT_MIN || x > AIPTEK_TILT_MAX)
1195 return -EINVAL;
1196
1197 aiptek->newSetting.xTilt = x;
1198 }
1199
1200 return count;
1201}
1202
1203static DEVICE_ATTR(xtilt,
1204 S_IRUGO | S_IWUSR, show_tabletXtilt, store_tabletXtilt);
1205
1206
1207
1208
1209
1210static ssize_t show_tabletYtilt(struct device *dev, struct device_attribute *attr, char *buf)
1211{
1212 struct aiptek *aiptek = dev_get_drvdata(dev);
1213
1214 if (aiptek->curSetting.yTilt == AIPTEK_TILT_DISABLE) {
1215 return sysfs_emit(buf, "disable\n");
1216 } else {
1217 return sysfs_emit(buf, "%d\n", aiptek->curSetting.yTilt);
1218 }
1219}
1220
1221static ssize_t
1222store_tabletYtilt(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1223{
1224 struct aiptek *aiptek = dev_get_drvdata(dev);
1225 int y;
1226
1227 if (kstrtoint(buf, 10, &y)) {
1228 size_t len = buf[count - 1] == '\n' ? count - 1 : count;
1229
1230 if (strncmp(buf, "disable", len))
1231 return -EINVAL;
1232
1233 aiptek->newSetting.yTilt = AIPTEK_TILT_DISABLE;
1234 } else {
1235 if (y < AIPTEK_TILT_MIN || y > AIPTEK_TILT_MAX)
1236 return -EINVAL;
1237
1238 aiptek->newSetting.yTilt = y;
1239 }
1240
1241 return count;
1242}
1243
1244static DEVICE_ATTR(ytilt,
1245 S_IRUGO | S_IWUSR, show_tabletYtilt, store_tabletYtilt);
1246
1247
1248
1249
1250
1251static ssize_t show_tabletJitterDelay(struct device *dev, struct device_attribute *attr, char *buf)
1252{
1253 struct aiptek *aiptek = dev_get_drvdata(dev);
1254
1255 return sysfs_emit(buf, "%d\n", aiptek->curSetting.jitterDelay);
1256}
1257
1258static ssize_t
1259store_tabletJitterDelay(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1260{
1261 struct aiptek *aiptek = dev_get_drvdata(dev);
1262 int err, j;
1263
1264 err = kstrtoint(buf, 10, &j);
1265 if (err)
1266 return err;
1267
1268 aiptek->newSetting.jitterDelay = j;
1269 return count;
1270}
1271
1272static DEVICE_ATTR(jitter,
1273 S_IRUGO | S_IWUSR,
1274 show_tabletJitterDelay, store_tabletJitterDelay);
1275
1276
1277
1278
1279
1280static ssize_t show_tabletProgrammableDelay(struct device *dev, struct device_attribute *attr, char *buf)
1281{
1282 struct aiptek *aiptek = dev_get_drvdata(dev);
1283
1284 return sysfs_emit(buf, "%d\n", aiptek->curSetting.programmableDelay);
1285}
1286
1287static ssize_t
1288store_tabletProgrammableDelay(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1289{
1290 struct aiptek *aiptek = dev_get_drvdata(dev);
1291 int err, d;
1292
1293 err = kstrtoint(buf, 10, &d);
1294 if (err)
1295 return err;
1296
1297 aiptek->newSetting.programmableDelay = d;
1298 return count;
1299}
1300
1301static DEVICE_ATTR(delay,
1302 S_IRUGO | S_IWUSR,
1303 show_tabletProgrammableDelay, store_tabletProgrammableDelay);
1304
1305
1306
1307
1308
1309static ssize_t show_tabletEventsReceived(struct device *dev, struct device_attribute *attr, char *buf)
1310{
1311 struct aiptek *aiptek = dev_get_drvdata(dev);
1312
1313 return sysfs_emit(buf, "%ld\n", aiptek->eventCount);
1314}
1315
1316static DEVICE_ATTR(event_count, S_IRUGO, show_tabletEventsReceived, NULL);
1317
1318
1319
1320
1321
1322static ssize_t show_tabletDiagnosticMessage(struct device *dev, struct device_attribute *attr, char *buf)
1323{
1324 struct aiptek *aiptek = dev_get_drvdata(dev);
1325 char *retMsg;
1326
1327 switch (aiptek->diagnostic) {
1328 case AIPTEK_DIAGNOSTIC_NA:
1329 retMsg = "no errors\n";
1330 break;
1331
1332 case AIPTEK_DIAGNOSTIC_SENDING_RELATIVE_IN_ABSOLUTE:
1333 retMsg = "Error: receiving relative reports\n";
1334 break;
1335
1336 case AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE:
1337 retMsg = "Error: receiving absolute reports\n";
1338 break;
1339
1340 case AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED:
1341 if (aiptek->curSetting.pointerMode ==
1342 AIPTEK_POINTER_ONLY_MOUSE_MODE) {
1343 retMsg = "Error: receiving stylus reports\n";
1344 } else {
1345 retMsg = "Error: receiving mouse reports\n";
1346 }
1347 break;
1348
1349 default:
1350 return 0;
1351 }
1352 return sysfs_emit(buf, retMsg);
1353}
1354
1355static DEVICE_ATTR(diagnostic, S_IRUGO, show_tabletDiagnosticMessage, NULL);
1356
1357
1358
1359
1360
1361
1362static struct aiptek_map stylus_button_map[] = {
1363 { "upper", AIPTEK_STYLUS_UPPER_BUTTON },
1364 { "lower", AIPTEK_STYLUS_LOWER_BUTTON },
1365 { NULL, AIPTEK_INVALID_VALUE }
1366};
1367
1368static ssize_t show_tabletStylusUpper(struct device *dev, struct device_attribute *attr, char *buf)
1369{
1370 struct aiptek *aiptek = dev_get_drvdata(dev);
1371
1372 return sysfs_emit(buf, "%s\n", map_val_to_str(stylus_button_map,
1373 aiptek->curSetting.stylusButtonUpper));
1374}
1375
1376static ssize_t
1377store_tabletStylusUpper(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1378{
1379 struct aiptek *aiptek = dev_get_drvdata(dev);
1380 int new_button = map_str_to_val(stylus_button_map, buf, count);
1381
1382 if (new_button == AIPTEK_INVALID_VALUE)
1383 return -EINVAL;
1384
1385 aiptek->newSetting.stylusButtonUpper = new_button;
1386 return count;
1387}
1388
1389static DEVICE_ATTR(stylus_upper,
1390 S_IRUGO | S_IWUSR,
1391 show_tabletStylusUpper, store_tabletStylusUpper);
1392
1393
1394
1395
1396
1397
1398static ssize_t show_tabletStylusLower(struct device *dev, struct device_attribute *attr, char *buf)
1399{
1400 struct aiptek *aiptek = dev_get_drvdata(dev);
1401
1402 return sysfs_emit(buf, "%s\n", map_val_to_str(stylus_button_map,
1403 aiptek->curSetting.stylusButtonLower));
1404}
1405
1406static ssize_t
1407store_tabletStylusLower(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1408{
1409 struct aiptek *aiptek = dev_get_drvdata(dev);
1410 int new_button = map_str_to_val(stylus_button_map, buf, count);
1411
1412 if (new_button == AIPTEK_INVALID_VALUE)
1413 return -EINVAL;
1414
1415 aiptek->newSetting.stylusButtonLower = new_button;
1416 return count;
1417}
1418
1419static DEVICE_ATTR(stylus_lower,
1420 S_IRUGO | S_IWUSR,
1421 show_tabletStylusLower, store_tabletStylusLower);
1422
1423
1424
1425
1426
1427
1428static struct aiptek_map mouse_button_map[] = {
1429 { "left", AIPTEK_MOUSE_LEFT_BUTTON },
1430 { "middle", AIPTEK_MOUSE_MIDDLE_BUTTON },
1431 { "right", AIPTEK_MOUSE_RIGHT_BUTTON },
1432 { NULL, AIPTEK_INVALID_VALUE }
1433};
1434
1435static ssize_t show_tabletMouseLeft(struct device *dev, struct device_attribute *attr, char *buf)
1436{
1437 struct aiptek *aiptek = dev_get_drvdata(dev);
1438
1439 return sysfs_emit(buf, "%s\n", map_val_to_str(mouse_button_map,
1440 aiptek->curSetting.mouseButtonLeft));
1441}
1442
1443static ssize_t
1444store_tabletMouseLeft(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1445{
1446 struct aiptek *aiptek = dev_get_drvdata(dev);
1447 int new_button = map_str_to_val(mouse_button_map, buf, count);
1448
1449 if (new_button == AIPTEK_INVALID_VALUE)
1450 return -EINVAL;
1451
1452 aiptek->newSetting.mouseButtonLeft = new_button;
1453 return count;
1454}
1455
1456static DEVICE_ATTR(mouse_left,
1457 S_IRUGO | S_IWUSR,
1458 show_tabletMouseLeft, store_tabletMouseLeft);
1459
1460
1461
1462
1463
1464static ssize_t show_tabletMouseMiddle(struct device *dev, struct device_attribute *attr, char *buf)
1465{
1466 struct aiptek *aiptek = dev_get_drvdata(dev);
1467
1468 return sysfs_emit(buf, "%s\n", map_val_to_str(mouse_button_map,
1469 aiptek->curSetting.mouseButtonMiddle));
1470}
1471
1472static ssize_t
1473store_tabletMouseMiddle(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1474{
1475 struct aiptek *aiptek = dev_get_drvdata(dev);
1476 int new_button = map_str_to_val(mouse_button_map, buf, count);
1477
1478 if (new_button == AIPTEK_INVALID_VALUE)
1479 return -EINVAL;
1480
1481 aiptek->newSetting.mouseButtonMiddle = new_button;
1482 return count;
1483}
1484
1485static DEVICE_ATTR(mouse_middle,
1486 S_IRUGO | S_IWUSR,
1487 show_tabletMouseMiddle, store_tabletMouseMiddle);
1488
1489
1490
1491
1492
1493static ssize_t show_tabletMouseRight(struct device *dev, struct device_attribute *attr, char *buf)
1494{
1495 struct aiptek *aiptek = dev_get_drvdata(dev);
1496
1497 return sysfs_emit(buf, "%s\n", map_val_to_str(mouse_button_map,
1498 aiptek->curSetting.mouseButtonRight));
1499}
1500
1501static ssize_t
1502store_tabletMouseRight(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1503{
1504 struct aiptek *aiptek = dev_get_drvdata(dev);
1505 int new_button = map_str_to_val(mouse_button_map, buf, count);
1506
1507 if (new_button == AIPTEK_INVALID_VALUE)
1508 return -EINVAL;
1509
1510 aiptek->newSetting.mouseButtonRight = new_button;
1511 return count;
1512}
1513
1514static DEVICE_ATTR(mouse_right,
1515 S_IRUGO | S_IWUSR,
1516 show_tabletMouseRight, store_tabletMouseRight);
1517
1518
1519
1520
1521
1522static ssize_t show_tabletWheel(struct device *dev, struct device_attribute *attr, char *buf)
1523{
1524 struct aiptek *aiptek = dev_get_drvdata(dev);
1525
1526 if (aiptek->curSetting.wheel == AIPTEK_WHEEL_DISABLE) {
1527 return sysfs_emit(buf, "disable\n");
1528 } else {
1529 return sysfs_emit(buf, "%d\n", aiptek->curSetting.wheel);
1530 }
1531}
1532
1533static ssize_t
1534store_tabletWheel(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1535{
1536 struct aiptek *aiptek = dev_get_drvdata(dev);
1537 int err, w;
1538
1539 err = kstrtoint(buf, 10, &w);
1540 if (err)
1541 return err;
1542
1543 aiptek->newSetting.wheel = w;
1544 return count;
1545}
1546
1547static DEVICE_ATTR(wheel,
1548 S_IRUGO | S_IWUSR, show_tabletWheel, store_tabletWheel);
1549
1550
1551
1552
1553
1554static ssize_t show_tabletExecute(struct device *dev, struct device_attribute *attr, char *buf)
1555{
1556
1557
1558
1559 return sysfs_emit(buf, "Write anything to this file to program your tablet.\n");
1560}
1561
1562static ssize_t
1563store_tabletExecute(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1564{
1565 struct aiptek *aiptek = dev_get_drvdata(dev);
1566
1567
1568
1569
1570 memcpy(&aiptek->curSetting, &aiptek->newSetting,
1571 sizeof(struct aiptek_settings));
1572
1573 if (aiptek_program_tablet(aiptek) < 0)
1574 return -EIO;
1575
1576 return count;
1577}
1578
1579static DEVICE_ATTR(execute,
1580 S_IRUGO | S_IWUSR, show_tabletExecute, store_tabletExecute);
1581
1582
1583
1584
1585
1586static ssize_t show_tabletODMCode(struct device *dev, struct device_attribute *attr, char *buf)
1587{
1588 struct aiptek *aiptek = dev_get_drvdata(dev);
1589
1590 return sysfs_emit(buf, "0x%04x\n", aiptek->features.odmCode);
1591}
1592
1593static DEVICE_ATTR(odm_code, S_IRUGO, show_tabletODMCode, NULL);
1594
1595
1596
1597
1598
1599static ssize_t show_tabletModelCode(struct device *dev, struct device_attribute *attr, char *buf)
1600{
1601 struct aiptek *aiptek = dev_get_drvdata(dev);
1602
1603 return sysfs_emit(buf, "0x%04x\n", aiptek->features.modelCode);
1604}
1605
1606static DEVICE_ATTR(model_code, S_IRUGO, show_tabletModelCode, NULL);
1607
1608
1609
1610
1611
1612static ssize_t show_firmwareCode(struct device *dev, struct device_attribute *attr, char *buf)
1613{
1614 struct aiptek *aiptek = dev_get_drvdata(dev);
1615
1616 return sysfs_emit(buf, "%04x\n", aiptek->features.firmwareCode);
1617}
1618
1619static DEVICE_ATTR(firmware_code, S_IRUGO, show_firmwareCode, NULL);
1620
1621static struct attribute *aiptek_attributes[] = {
1622 &dev_attr_size.attr,
1623 &dev_attr_pointer_mode.attr,
1624 &dev_attr_coordinate_mode.attr,
1625 &dev_attr_tool_mode.attr,
1626 &dev_attr_xtilt.attr,
1627 &dev_attr_ytilt.attr,
1628 &dev_attr_jitter.attr,
1629 &dev_attr_delay.attr,
1630 &dev_attr_event_count.attr,
1631 &dev_attr_diagnostic.attr,
1632 &dev_attr_odm_code.attr,
1633 &dev_attr_model_code.attr,
1634 &dev_attr_firmware_code.attr,
1635 &dev_attr_stylus_lower.attr,
1636 &dev_attr_stylus_upper.attr,
1637 &dev_attr_mouse_left.attr,
1638 &dev_attr_mouse_middle.attr,
1639 &dev_attr_mouse_right.attr,
1640 &dev_attr_wheel.attr,
1641 &dev_attr_execute.attr,
1642 NULL
1643};
1644
1645static const struct attribute_group aiptek_attribute_group = {
1646 .attrs = aiptek_attributes,
1647};
1648
1649
1650
1651
1652
1653static int
1654aiptek_probe(struct usb_interface *intf, const struct usb_device_id *id)
1655{
1656 struct usb_device *usbdev = interface_to_usbdev(intf);
1657 struct usb_endpoint_descriptor *endpoint;
1658 struct aiptek *aiptek;
1659 struct input_dev *inputdev;
1660 int i;
1661 int speeds[] = { 0,
1662 AIPTEK_PROGRAMMABLE_DELAY_50,
1663 AIPTEK_PROGRAMMABLE_DELAY_400,
1664 AIPTEK_PROGRAMMABLE_DELAY_25,
1665 AIPTEK_PROGRAMMABLE_DELAY_100,
1666 AIPTEK_PROGRAMMABLE_DELAY_200,
1667 AIPTEK_PROGRAMMABLE_DELAY_300
1668 };
1669 int err = -ENOMEM;
1670
1671
1672
1673
1674
1675
1676
1677 speeds[0] = programmableDelay;
1678
1679 aiptek = kzalloc(sizeof(struct aiptek), GFP_KERNEL);
1680 inputdev = input_allocate_device();
1681 if (!aiptek || !inputdev) {
1682 dev_warn(&intf->dev,
1683 "cannot allocate memory or input device\n");
1684 goto fail1;
1685 }
1686
1687 aiptek->data = usb_alloc_coherent(usbdev, AIPTEK_PACKET_LENGTH,
1688 GFP_KERNEL, &aiptek->data_dma);
1689 if (!aiptek->data) {
1690 dev_warn(&intf->dev, "cannot allocate usb buffer\n");
1691 goto fail1;
1692 }
1693
1694 aiptek->urb = usb_alloc_urb(0, GFP_KERNEL);
1695 if (!aiptek->urb) {
1696 dev_warn(&intf->dev, "cannot allocate urb\n");
1697 goto fail2;
1698 }
1699
1700 aiptek->inputdev = inputdev;
1701 aiptek->intf = intf;
1702 aiptek->ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
1703 aiptek->inDelay = 0;
1704 aiptek->endDelay = 0;
1705 aiptek->previousJitterable = 0;
1706 aiptek->lastMacro = -1;
1707
1708
1709
1710
1711
1712
1713
1714 aiptek->curSetting.pointerMode = AIPTEK_POINTER_EITHER_MODE;
1715 aiptek->curSetting.coordinateMode = AIPTEK_COORDINATE_ABSOLUTE_MODE;
1716 aiptek->curSetting.toolMode = AIPTEK_TOOL_BUTTON_PEN_MODE;
1717 aiptek->curSetting.xTilt = AIPTEK_TILT_DISABLE;
1718 aiptek->curSetting.yTilt = AIPTEK_TILT_DISABLE;
1719 aiptek->curSetting.mouseButtonLeft = AIPTEK_MOUSE_LEFT_BUTTON;
1720 aiptek->curSetting.mouseButtonMiddle = AIPTEK_MOUSE_MIDDLE_BUTTON;
1721 aiptek->curSetting.mouseButtonRight = AIPTEK_MOUSE_RIGHT_BUTTON;
1722 aiptek->curSetting.stylusButtonUpper = AIPTEK_STYLUS_UPPER_BUTTON;
1723 aiptek->curSetting.stylusButtonLower = AIPTEK_STYLUS_LOWER_BUTTON;
1724 aiptek->curSetting.jitterDelay = jitterDelay;
1725 aiptek->curSetting.programmableDelay = programmableDelay;
1726
1727
1728
1729 aiptek->newSetting = aiptek->curSetting;
1730
1731
1732
1733
1734
1735
1736
1737
1738 usb_make_path(usbdev, aiptek->features.usbPath,
1739 sizeof(aiptek->features.usbPath));
1740 strlcat(aiptek->features.usbPath, "/input0",
1741 sizeof(aiptek->features.usbPath));
1742
1743
1744
1745
1746 inputdev->name = "Aiptek";
1747 inputdev->phys = aiptek->features.usbPath;
1748 usb_to_input_id(usbdev, &inputdev->id);
1749 inputdev->dev.parent = &intf->dev;
1750
1751 input_set_drvdata(inputdev, aiptek);
1752
1753 inputdev->open = aiptek_open;
1754 inputdev->close = aiptek_close;
1755
1756
1757
1758
1759 for (i = 0; i < ARRAY_SIZE(eventTypes); ++i)
1760 __set_bit(eventTypes[i], inputdev->evbit);
1761
1762 for (i = 0; i < ARRAY_SIZE(absEvents); ++i)
1763 __set_bit(absEvents[i], inputdev->absbit);
1764
1765 for (i = 0; i < ARRAY_SIZE(relEvents); ++i)
1766 __set_bit(relEvents[i], inputdev->relbit);
1767
1768 __set_bit(MSC_SERIAL, inputdev->mscbit);
1769
1770
1771 for (i = 0; i < ARRAY_SIZE(buttonEvents); ++i)
1772 __set_bit(buttonEvents[i], inputdev->keybit);
1773
1774 for (i = 0; i < ARRAY_SIZE(macroKeyEvents); ++i)
1775 __set_bit(macroKeyEvents[i], inputdev->keybit);
1776
1777
1778
1779
1780
1781
1782
1783 input_set_abs_params(inputdev, ABS_X, 0, 2999, 0, 0);
1784 input_set_abs_params(inputdev, ABS_Y, 0, 2249, 0, 0);
1785 input_set_abs_params(inputdev, ABS_PRESSURE, 0, 511, 0, 0);
1786 input_set_abs_params(inputdev, ABS_TILT_X, AIPTEK_TILT_MIN, AIPTEK_TILT_MAX, 0, 0);
1787 input_set_abs_params(inputdev, ABS_TILT_Y, AIPTEK_TILT_MIN, AIPTEK_TILT_MAX, 0, 0);
1788 input_set_abs_params(inputdev, ABS_WHEEL, AIPTEK_WHEEL_MIN, AIPTEK_WHEEL_MAX - 1, 0, 0);
1789
1790
1791 if (intf->cur_altsetting->desc.bNumEndpoints < 1) {
1792 dev_err(&intf->dev,
1793 "interface has %d endpoints, but must have minimum 1\n",
1794 intf->cur_altsetting->desc.bNumEndpoints);
1795 err = -EINVAL;
1796 goto fail3;
1797 }
1798 endpoint = &intf->cur_altsetting->endpoint[0].desc;
1799
1800
1801
1802
1803 usb_fill_int_urb(aiptek->urb,
1804 usbdev,
1805 usb_rcvintpipe(usbdev,
1806 endpoint->bEndpointAddress),
1807 aiptek->data, 8, aiptek_irq, aiptek,
1808 endpoint->bInterval);
1809
1810 aiptek->urb->transfer_dma = aiptek->data_dma;
1811 aiptek->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824 for (i = 0; i < ARRAY_SIZE(speeds); ++i) {
1825 aiptek->curSetting.programmableDelay = speeds[i];
1826 (void)aiptek_program_tablet(aiptek);
1827 if (input_abs_get_max(aiptek->inputdev, ABS_X) > 0) {
1828 dev_info(&intf->dev,
1829 "Aiptek using %d ms programming speed\n",
1830 aiptek->curSetting.programmableDelay);
1831 break;
1832 }
1833 }
1834
1835
1836
1837 if (i == ARRAY_SIZE(speeds)) {
1838 dev_info(&intf->dev,
1839 "Aiptek tried all speeds, no sane response\n");
1840 err = -EINVAL;
1841 goto fail3;
1842 }
1843
1844
1845
1846 usb_set_intfdata(intf, aiptek);
1847
1848
1849
1850 err = sysfs_create_group(&intf->dev.kobj, &aiptek_attribute_group);
1851 if (err) {
1852 dev_warn(&intf->dev, "cannot create sysfs group err: %d\n",
1853 err);
1854 goto fail3;
1855 }
1856
1857
1858
1859 err = input_register_device(aiptek->inputdev);
1860 if (err) {
1861 dev_warn(&intf->dev,
1862 "input_register_device returned err: %d\n", err);
1863 goto fail4;
1864 }
1865 return 0;
1866
1867 fail4: sysfs_remove_group(&intf->dev.kobj, &aiptek_attribute_group);
1868 fail3: usb_free_urb(aiptek->urb);
1869 fail2: usb_free_coherent(usbdev, AIPTEK_PACKET_LENGTH, aiptek->data,
1870 aiptek->data_dma);
1871 fail1: usb_set_intfdata(intf, NULL);
1872 input_free_device(inputdev);
1873 kfree(aiptek);
1874 return err;
1875}
1876
1877
1878
1879
1880static void aiptek_disconnect(struct usb_interface *intf)
1881{
1882 struct aiptek *aiptek = usb_get_intfdata(intf);
1883
1884
1885
1886 usb_set_intfdata(intf, NULL);
1887 if (aiptek != NULL) {
1888
1889
1890 usb_kill_urb(aiptek->urb);
1891 input_unregister_device(aiptek->inputdev);
1892 sysfs_remove_group(&intf->dev.kobj, &aiptek_attribute_group);
1893 usb_free_urb(aiptek->urb);
1894 usb_free_coherent(interface_to_usbdev(intf),
1895 AIPTEK_PACKET_LENGTH,
1896 aiptek->data, aiptek->data_dma);
1897 kfree(aiptek);
1898 }
1899}
1900
1901static struct usb_driver aiptek_driver = {
1902 .name = "aiptek",
1903 .probe = aiptek_probe,
1904 .disconnect = aiptek_disconnect,
1905 .id_table = aiptek_ids,
1906};
1907
1908module_usb_driver(aiptek_driver);
1909
1910MODULE_AUTHOR("Bryan W. Headley/Chris Atenasio/Cedric Brun/Rene van Paassen");
1911MODULE_DESCRIPTION("Aiptek HyperPen USB Tablet Driver");
1912MODULE_LICENSE("GPL");
1913
1914module_param(programmableDelay, int, 0);
1915MODULE_PARM_DESC(programmableDelay, "delay used during tablet programming");
1916module_param(jitterDelay, int, 0);
1917MODULE_PARM_DESC(jitterDelay, "stylus/mouse settlement delay");
1918