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