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