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 aiptek->inputdev->absmin[ABS_X] = 0;
991 aiptek->inputdev->absmax[ABS_X] = ret - 1;
992
993
994 if ((ret = aiptek_query(aiptek, 0x01, 0x01)) < 0)
995 return ret;
996 aiptek->inputdev->absmin[ABS_Y] = 0;
997 aiptek->inputdev->absmax[ABS_Y] = ret - 1;
998
999
1000 if ((ret = aiptek_query(aiptek, 0x08, 0x00)) < 0)
1001 return ret;
1002 aiptek->inputdev->absmin[ABS_PRESSURE] = 0;
1003 aiptek->inputdev->absmax[ABS_PRESSURE] = ret - 1;
1004
1005
1006
1007
1008 if (aiptek->curSetting.coordinateMode ==
1009 AIPTEK_COORDINATE_ABSOLUTE_MODE) {
1010
1011 if ((ret = aiptek_command(aiptek, 0x10, 0x01)) < 0) {
1012 return ret;
1013 }
1014 } else {
1015
1016 if ((ret = aiptek_command(aiptek, 0x10, 0x00)) < 0) {
1017 return ret;
1018 }
1019 }
1020
1021
1022 if ((ret = aiptek_command(aiptek, 0x11, 0x02)) < 0)
1023 return ret;
1024#if 0
1025
1026 if ((ret = aiptek_command(aiptek, 0x17, 0x00)) < 0)
1027 return ret;
1028#endif
1029
1030
1031 if ((ret = aiptek_command(aiptek, 0x12, 0xff)) < 0)
1032 return ret;
1033
1034
1035
1036 aiptek->diagnostic = AIPTEK_DIAGNOSTIC_NA;
1037 aiptek->eventCount = 0;
1038
1039 return 0;
1040}
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052static ssize_t show_tabletSize(struct device *dev, struct device_attribute *attr, char *buf)
1053{
1054 struct aiptek *aiptek = dev_get_drvdata(dev);
1055
1056 return snprintf(buf, PAGE_SIZE, "%dx%d\n",
1057 aiptek->inputdev->absmax[ABS_X] + 1,
1058 aiptek->inputdev->absmax[ABS_Y] + 1);
1059}
1060
1061
1062
1063
1064
1065
1066
1067static DEVICE_ATTR(size, S_IRUGO, show_tabletSize, NULL);
1068
1069
1070
1071
1072
1073static struct aiptek_map pointer_mode_map[] = {
1074 { "stylus", AIPTEK_POINTER_ONLY_STYLUS_MODE },
1075 { "mouse", AIPTEK_POINTER_ONLY_MOUSE_MODE },
1076 { "either", AIPTEK_POINTER_EITHER_MODE },
1077 { NULL, AIPTEK_INVALID_VALUE }
1078};
1079
1080static ssize_t show_tabletPointerMode(struct device *dev, struct device_attribute *attr, char *buf)
1081{
1082 struct aiptek *aiptek = dev_get_drvdata(dev);
1083
1084 return snprintf(buf, PAGE_SIZE, "%s\n",
1085 map_val_to_str(pointer_mode_map,
1086 aiptek->curSetting.pointerMode));
1087}
1088
1089static ssize_t
1090store_tabletPointerMode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1091{
1092 struct aiptek *aiptek = dev_get_drvdata(dev);
1093 int new_mode = map_str_to_val(pointer_mode_map, buf, count);
1094
1095 if (new_mode == AIPTEK_INVALID_VALUE)
1096 return -EINVAL;
1097
1098 aiptek->newSetting.pointerMode = new_mode;
1099 return count;
1100}
1101
1102static DEVICE_ATTR(pointer_mode,
1103 S_IRUGO | S_IWUGO,
1104 show_tabletPointerMode, store_tabletPointerMode);
1105
1106
1107
1108
1109
1110
1111static struct aiptek_map coordinate_mode_map[] = {
1112 { "absolute", AIPTEK_COORDINATE_ABSOLUTE_MODE },
1113 { "relative", AIPTEK_COORDINATE_RELATIVE_MODE },
1114 { NULL, AIPTEK_INVALID_VALUE }
1115};
1116
1117static ssize_t show_tabletCoordinateMode(struct device *dev, struct device_attribute *attr, char *buf)
1118{
1119 struct aiptek *aiptek = dev_get_drvdata(dev);
1120
1121 return snprintf(buf, PAGE_SIZE, "%s\n",
1122 map_val_to_str(coordinate_mode_map,
1123 aiptek->curSetting.coordinateMode));
1124}
1125
1126static ssize_t
1127store_tabletCoordinateMode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1128{
1129 struct aiptek *aiptek = dev_get_drvdata(dev);
1130 int new_mode = map_str_to_val(coordinate_mode_map, buf, count);
1131
1132 if (new_mode == AIPTEK_INVALID_VALUE)
1133 return -EINVAL;
1134
1135 aiptek->newSetting.coordinateMode = new_mode;
1136 return count;
1137}
1138
1139static DEVICE_ATTR(coordinate_mode,
1140 S_IRUGO | S_IWUGO,
1141 show_tabletCoordinateMode, store_tabletCoordinateMode);
1142
1143
1144
1145
1146
1147
1148static struct aiptek_map tool_mode_map[] = {
1149 { "mouse", AIPTEK_TOOL_BUTTON_MOUSE_MODE },
1150 { "eraser", AIPTEK_TOOL_BUTTON_ERASER_MODE },
1151 { "pencil", AIPTEK_TOOL_BUTTON_PENCIL_MODE },
1152 { "pen", AIPTEK_TOOL_BUTTON_PEN_MODE },
1153 { "brush", AIPTEK_TOOL_BUTTON_BRUSH_MODE },
1154 { "airbrush", AIPTEK_TOOL_BUTTON_AIRBRUSH_MODE },
1155 { "lens", AIPTEK_TOOL_BUTTON_LENS_MODE },
1156 { NULL, AIPTEK_INVALID_VALUE }
1157};
1158
1159static ssize_t show_tabletToolMode(struct device *dev, struct device_attribute *attr, char *buf)
1160{
1161 struct aiptek *aiptek = dev_get_drvdata(dev);
1162
1163 return snprintf(buf, PAGE_SIZE, "%s\n",
1164 map_val_to_str(tool_mode_map,
1165 aiptek->curSetting.toolMode));
1166}
1167
1168static ssize_t
1169store_tabletToolMode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1170{
1171 struct aiptek *aiptek = dev_get_drvdata(dev);
1172 int new_mode = map_str_to_val(tool_mode_map, buf, count);
1173
1174 if (new_mode == AIPTEK_INVALID_VALUE)
1175 return -EINVAL;
1176
1177 aiptek->newSetting.toolMode = new_mode;
1178 return count;
1179}
1180
1181static DEVICE_ATTR(tool_mode,
1182 S_IRUGO | S_IWUGO,
1183 show_tabletToolMode, store_tabletToolMode);
1184
1185
1186
1187
1188
1189static ssize_t show_tabletXtilt(struct device *dev, struct device_attribute *attr, char *buf)
1190{
1191 struct aiptek *aiptek = dev_get_drvdata(dev);
1192
1193 if (aiptek->curSetting.xTilt == AIPTEK_TILT_DISABLE) {
1194 return snprintf(buf, PAGE_SIZE, "disable\n");
1195 } else {
1196 return snprintf(buf, PAGE_SIZE, "%d\n",
1197 aiptek->curSetting.xTilt);
1198 }
1199}
1200
1201static ssize_t
1202store_tabletXtilt(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1203{
1204 struct aiptek *aiptek = dev_get_drvdata(dev);
1205 long x;
1206
1207 if (strict_strtol(buf, 10, &x)) {
1208 size_t len = buf[count - 1] == '\n' ? count - 1 : count;
1209
1210 if (strncmp(buf, "disable", len))
1211 return -EINVAL;
1212
1213 aiptek->newSetting.xTilt = AIPTEK_TILT_DISABLE;
1214 } else {
1215 if (x < AIPTEK_TILT_MIN || x > AIPTEK_TILT_MAX)
1216 return -EINVAL;
1217
1218 aiptek->newSetting.xTilt = x;
1219 }
1220
1221 return count;
1222}
1223
1224static DEVICE_ATTR(xtilt,
1225 S_IRUGO | S_IWUGO, show_tabletXtilt, store_tabletXtilt);
1226
1227
1228
1229
1230
1231static ssize_t show_tabletYtilt(struct device *dev, struct device_attribute *attr, char *buf)
1232{
1233 struct aiptek *aiptek = dev_get_drvdata(dev);
1234
1235 if (aiptek->curSetting.yTilt == AIPTEK_TILT_DISABLE) {
1236 return snprintf(buf, PAGE_SIZE, "disable\n");
1237 } else {
1238 return snprintf(buf, PAGE_SIZE, "%d\n",
1239 aiptek->curSetting.yTilt);
1240 }
1241}
1242
1243static ssize_t
1244store_tabletYtilt(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1245{
1246 struct aiptek *aiptek = dev_get_drvdata(dev);
1247 long y;
1248
1249 if (strict_strtol(buf, 10, &y)) {
1250 size_t len = buf[count - 1] == '\n' ? count - 1 : count;
1251
1252 if (strncmp(buf, "disable", len))
1253 return -EINVAL;
1254
1255 aiptek->newSetting.yTilt = AIPTEK_TILT_DISABLE;
1256 } else {
1257 if (y < AIPTEK_TILT_MIN || y > AIPTEK_TILT_MAX)
1258 return -EINVAL;
1259
1260 aiptek->newSetting.yTilt = y;
1261 }
1262
1263 return count;
1264}
1265
1266static DEVICE_ATTR(ytilt,
1267 S_IRUGO | S_IWUGO, show_tabletYtilt, store_tabletYtilt);
1268
1269
1270
1271
1272
1273static ssize_t show_tabletJitterDelay(struct device *dev, struct device_attribute *attr, char *buf)
1274{
1275 struct aiptek *aiptek = dev_get_drvdata(dev);
1276
1277 return snprintf(buf, PAGE_SIZE, "%d\n", aiptek->curSetting.jitterDelay);
1278}
1279
1280static ssize_t
1281store_tabletJitterDelay(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1282{
1283 struct aiptek *aiptek = dev_get_drvdata(dev);
1284 long j;
1285
1286 if (strict_strtol(buf, 10, &j))
1287 return -EINVAL;
1288
1289 aiptek->newSetting.jitterDelay = (int)j;
1290 return count;
1291}
1292
1293static DEVICE_ATTR(jitter,
1294 S_IRUGO | S_IWUGO,
1295 show_tabletJitterDelay, store_tabletJitterDelay);
1296
1297
1298
1299
1300
1301static ssize_t show_tabletProgrammableDelay(struct device *dev, struct device_attribute *attr, char *buf)
1302{
1303 struct aiptek *aiptek = dev_get_drvdata(dev);
1304
1305 return snprintf(buf, PAGE_SIZE, "%d\n",
1306 aiptek->curSetting.programmableDelay);
1307}
1308
1309static ssize_t
1310store_tabletProgrammableDelay(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1311{
1312 struct aiptek *aiptek = dev_get_drvdata(dev);
1313 long d;
1314
1315 if (strict_strtol(buf, 10, &d))
1316 return -EINVAL;
1317
1318 aiptek->newSetting.programmableDelay = (int)d;
1319 return count;
1320}
1321
1322static DEVICE_ATTR(delay,
1323 S_IRUGO | S_IWUGO,
1324 show_tabletProgrammableDelay, store_tabletProgrammableDelay);
1325
1326
1327
1328
1329
1330static ssize_t show_tabletEventsReceived(struct device *dev, struct device_attribute *attr, char *buf)
1331{
1332 struct aiptek *aiptek = dev_get_drvdata(dev);
1333
1334 return snprintf(buf, PAGE_SIZE, "%ld\n", aiptek->eventCount);
1335}
1336
1337static DEVICE_ATTR(event_count, S_IRUGO, show_tabletEventsReceived, NULL);
1338
1339
1340
1341
1342
1343static ssize_t show_tabletDiagnosticMessage(struct device *dev, struct device_attribute *attr, char *buf)
1344{
1345 struct aiptek *aiptek = dev_get_drvdata(dev);
1346 char *retMsg;
1347
1348 switch (aiptek->diagnostic) {
1349 case AIPTEK_DIAGNOSTIC_NA:
1350 retMsg = "no errors\n";
1351 break;
1352
1353 case AIPTEK_DIAGNOSTIC_SENDING_RELATIVE_IN_ABSOLUTE:
1354 retMsg = "Error: receiving relative reports\n";
1355 break;
1356
1357 case AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE:
1358 retMsg = "Error: receiving absolute reports\n";
1359 break;
1360
1361 case AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED:
1362 if (aiptek->curSetting.pointerMode ==
1363 AIPTEK_POINTER_ONLY_MOUSE_MODE) {
1364 retMsg = "Error: receiving stylus reports\n";
1365 } else {
1366 retMsg = "Error: receiving mouse reports\n";
1367 }
1368 break;
1369
1370 default:
1371 return 0;
1372 }
1373 return snprintf(buf, PAGE_SIZE, retMsg);
1374}
1375
1376static DEVICE_ATTR(diagnostic, S_IRUGO, show_tabletDiagnosticMessage, NULL);
1377
1378
1379
1380
1381
1382
1383static struct aiptek_map stylus_button_map[] = {
1384 { "upper", AIPTEK_STYLUS_UPPER_BUTTON },
1385 { "lower", AIPTEK_STYLUS_LOWER_BUTTON },
1386 { NULL, AIPTEK_INVALID_VALUE }
1387};
1388
1389static ssize_t show_tabletStylusUpper(struct device *dev, struct device_attribute *attr, char *buf)
1390{
1391 struct aiptek *aiptek = dev_get_drvdata(dev);
1392
1393 return snprintf(buf, PAGE_SIZE, "%s\n",
1394 map_val_to_str(stylus_button_map,
1395 aiptek->curSetting.stylusButtonUpper));
1396}
1397
1398static ssize_t
1399store_tabletStylusUpper(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1400{
1401 struct aiptek *aiptek = dev_get_drvdata(dev);
1402 int new_button = map_str_to_val(stylus_button_map, buf, count);
1403
1404 if (new_button == AIPTEK_INVALID_VALUE)
1405 return -EINVAL;
1406
1407 aiptek->newSetting.stylusButtonUpper = new_button;
1408 return count;
1409}
1410
1411static DEVICE_ATTR(stylus_upper,
1412 S_IRUGO | S_IWUGO,
1413 show_tabletStylusUpper, store_tabletStylusUpper);
1414
1415
1416
1417
1418
1419
1420static ssize_t show_tabletStylusLower(struct device *dev, struct device_attribute *attr, char *buf)
1421{
1422 struct aiptek *aiptek = dev_get_drvdata(dev);
1423
1424 return snprintf(buf, PAGE_SIZE, "%s\n",
1425 map_val_to_str(stylus_button_map,
1426 aiptek->curSetting.stylusButtonLower));
1427}
1428
1429static ssize_t
1430store_tabletStylusLower(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1431{
1432 struct aiptek *aiptek = dev_get_drvdata(dev);
1433 int new_button = map_str_to_val(stylus_button_map, buf, count);
1434
1435 if (new_button == AIPTEK_INVALID_VALUE)
1436 return -EINVAL;
1437
1438 aiptek->newSetting.stylusButtonLower = new_button;
1439 return count;
1440}
1441
1442static DEVICE_ATTR(stylus_lower,
1443 S_IRUGO | S_IWUGO,
1444 show_tabletStylusLower, store_tabletStylusLower);
1445
1446
1447
1448
1449
1450
1451static struct aiptek_map mouse_button_map[] = {
1452 { "left", AIPTEK_MOUSE_LEFT_BUTTON },
1453 { "middle", AIPTEK_MOUSE_MIDDLE_BUTTON },
1454 { "right", AIPTEK_MOUSE_RIGHT_BUTTON },
1455 { NULL, AIPTEK_INVALID_VALUE }
1456};
1457
1458static ssize_t show_tabletMouseLeft(struct device *dev, struct device_attribute *attr, char *buf)
1459{
1460 struct aiptek *aiptek = dev_get_drvdata(dev);
1461
1462 return snprintf(buf, PAGE_SIZE, "%s\n",
1463 map_val_to_str(mouse_button_map,
1464 aiptek->curSetting.mouseButtonLeft));
1465}
1466
1467static ssize_t
1468store_tabletMouseLeft(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1469{
1470 struct aiptek *aiptek = dev_get_drvdata(dev);
1471 int new_button = map_str_to_val(mouse_button_map, buf, count);
1472
1473 if (new_button == AIPTEK_INVALID_VALUE)
1474 return -EINVAL;
1475
1476 aiptek->newSetting.mouseButtonLeft = new_button;
1477 return count;
1478}
1479
1480static DEVICE_ATTR(mouse_left,
1481 S_IRUGO | S_IWUGO,
1482 show_tabletMouseLeft, store_tabletMouseLeft);
1483
1484
1485
1486
1487
1488static ssize_t show_tabletMouseMiddle(struct device *dev, struct device_attribute *attr, char *buf)
1489{
1490 struct aiptek *aiptek = dev_get_drvdata(dev);
1491
1492 return snprintf(buf, PAGE_SIZE, "%s\n",
1493 map_val_to_str(mouse_button_map,
1494 aiptek->curSetting.mouseButtonMiddle));
1495}
1496
1497static ssize_t
1498store_tabletMouseMiddle(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1499{
1500 struct aiptek *aiptek = dev_get_drvdata(dev);
1501 int new_button = map_str_to_val(mouse_button_map, buf, count);
1502
1503 if (new_button == AIPTEK_INVALID_VALUE)
1504 return -EINVAL;
1505
1506 aiptek->newSetting.mouseButtonMiddle = new_button;
1507 return count;
1508}
1509
1510static DEVICE_ATTR(mouse_middle,
1511 S_IRUGO | S_IWUGO,
1512 show_tabletMouseMiddle, store_tabletMouseMiddle);
1513
1514
1515
1516
1517
1518static ssize_t show_tabletMouseRight(struct device *dev, struct device_attribute *attr, char *buf)
1519{
1520 struct aiptek *aiptek = dev_get_drvdata(dev);
1521
1522 return snprintf(buf, PAGE_SIZE, "%s\n",
1523 map_val_to_str(mouse_button_map,
1524 aiptek->curSetting.mouseButtonRight));
1525}
1526
1527static ssize_t
1528store_tabletMouseRight(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1529{
1530 struct aiptek *aiptek = dev_get_drvdata(dev);
1531 int new_button = map_str_to_val(mouse_button_map, buf, count);
1532
1533 if (new_button == AIPTEK_INVALID_VALUE)
1534 return -EINVAL;
1535
1536 aiptek->newSetting.mouseButtonRight = new_button;
1537 return count;
1538}
1539
1540static DEVICE_ATTR(mouse_right,
1541 S_IRUGO | S_IWUGO,
1542 show_tabletMouseRight, store_tabletMouseRight);
1543
1544
1545
1546
1547
1548static ssize_t show_tabletWheel(struct device *dev, struct device_attribute *attr, char *buf)
1549{
1550 struct aiptek *aiptek = dev_get_drvdata(dev);
1551
1552 if (aiptek->curSetting.wheel == AIPTEK_WHEEL_DISABLE) {
1553 return snprintf(buf, PAGE_SIZE, "disable\n");
1554 } else {
1555 return snprintf(buf, PAGE_SIZE, "%d\n",
1556 aiptek->curSetting.wheel);
1557 }
1558}
1559
1560static ssize_t
1561store_tabletWheel(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1562{
1563 struct aiptek *aiptek = dev_get_drvdata(dev);
1564 long w;
1565
1566 if (strict_strtol(buf, 10, &w)) return -EINVAL;
1567
1568 aiptek->newSetting.wheel = (int)w;
1569 return count;
1570}
1571
1572static DEVICE_ATTR(wheel,
1573 S_IRUGO | S_IWUGO, show_tabletWheel, store_tabletWheel);
1574
1575
1576
1577
1578
1579static ssize_t show_tabletExecute(struct device *dev, struct device_attribute *attr, char *buf)
1580{
1581
1582
1583
1584 return snprintf(buf, PAGE_SIZE,
1585 "Write anything to this file to program your tablet.\n");
1586}
1587
1588static ssize_t
1589store_tabletExecute(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1590{
1591 struct aiptek *aiptek = dev_get_drvdata(dev);
1592
1593
1594
1595
1596 memcpy(&aiptek->curSetting, &aiptek->newSetting,
1597 sizeof(struct aiptek_settings));
1598
1599 if (aiptek_program_tablet(aiptek) < 0)
1600 return -EIO;
1601
1602 return count;
1603}
1604
1605static DEVICE_ATTR(execute,
1606 S_IRUGO | S_IWUGO, show_tabletExecute, store_tabletExecute);
1607
1608
1609
1610
1611
1612static ssize_t show_tabletODMCode(struct device *dev, struct device_attribute *attr, char *buf)
1613{
1614 struct aiptek *aiptek = dev_get_drvdata(dev);
1615
1616 return snprintf(buf, PAGE_SIZE, "0x%04x\n", aiptek->features.odmCode);
1617}
1618
1619static DEVICE_ATTR(odm_code, S_IRUGO, show_tabletODMCode, NULL);
1620
1621
1622
1623
1624
1625static ssize_t show_tabletModelCode(struct device *dev, struct device_attribute *attr, char *buf)
1626{
1627 struct aiptek *aiptek = dev_get_drvdata(dev);
1628
1629 return snprintf(buf, PAGE_SIZE, "0x%04x\n", aiptek->features.modelCode);
1630}
1631
1632static DEVICE_ATTR(model_code, S_IRUGO, show_tabletModelCode, NULL);
1633
1634
1635
1636
1637
1638static ssize_t show_firmwareCode(struct device *dev, struct device_attribute *attr, char *buf)
1639{
1640 struct aiptek *aiptek = dev_get_drvdata(dev);
1641
1642 return snprintf(buf, PAGE_SIZE, "%04x\n",
1643 aiptek->features.firmwareCode);
1644}
1645
1646static DEVICE_ATTR(firmware_code, S_IRUGO, show_firmwareCode, NULL);
1647
1648static struct attribute *aiptek_attributes[] = {
1649 &dev_attr_size.attr,
1650 &dev_attr_pointer_mode.attr,
1651 &dev_attr_coordinate_mode.attr,
1652 &dev_attr_tool_mode.attr,
1653 &dev_attr_xtilt.attr,
1654 &dev_attr_ytilt.attr,
1655 &dev_attr_jitter.attr,
1656 &dev_attr_delay.attr,
1657 &dev_attr_event_count.attr,
1658 &dev_attr_diagnostic.attr,
1659 &dev_attr_odm_code.attr,
1660 &dev_attr_model_code.attr,
1661 &dev_attr_firmware_code.attr,
1662 &dev_attr_stylus_lower.attr,
1663 &dev_attr_stylus_upper.attr,
1664 &dev_attr_mouse_left.attr,
1665 &dev_attr_mouse_middle.attr,
1666 &dev_attr_mouse_right.attr,
1667 &dev_attr_wheel.attr,
1668 &dev_attr_execute.attr,
1669 NULL
1670};
1671
1672static struct attribute_group aiptek_attribute_group = {
1673 .attrs = aiptek_attributes,
1674};
1675
1676
1677
1678
1679
1680static int
1681aiptek_probe(struct usb_interface *intf, const struct usb_device_id *id)
1682{
1683 struct usb_device *usbdev = interface_to_usbdev(intf);
1684 struct usb_endpoint_descriptor *endpoint;
1685 struct aiptek *aiptek;
1686 struct input_dev *inputdev;
1687 int i;
1688 int speeds[] = { 0,
1689 AIPTEK_PROGRAMMABLE_DELAY_50,
1690 AIPTEK_PROGRAMMABLE_DELAY_400,
1691 AIPTEK_PROGRAMMABLE_DELAY_25,
1692 AIPTEK_PROGRAMMABLE_DELAY_100,
1693 AIPTEK_PROGRAMMABLE_DELAY_200,
1694 AIPTEK_PROGRAMMABLE_DELAY_300
1695 };
1696 int err = -ENOMEM;
1697
1698
1699
1700
1701
1702
1703
1704 speeds[0] = programmableDelay;
1705
1706 aiptek = kzalloc(sizeof(struct aiptek), GFP_KERNEL);
1707 inputdev = input_allocate_device();
1708 if (!aiptek || !inputdev) {
1709 dev_warn(&intf->dev,
1710 "cannot allocate memory or input device\n");
1711 goto fail1;
1712 }
1713
1714 aiptek->data = usb_buffer_alloc(usbdev, AIPTEK_PACKET_LENGTH,
1715 GFP_ATOMIC, &aiptek->data_dma);
1716 if (!aiptek->data) {
1717 dev_warn(&intf->dev, "cannot allocate usb buffer\n");
1718 goto fail1;
1719 }
1720
1721 aiptek->urb = usb_alloc_urb(0, GFP_KERNEL);
1722 if (!aiptek->urb) {
1723 dev_warn(&intf->dev, "cannot allocate urb\n");
1724 goto fail2;
1725 }
1726
1727 aiptek->inputdev = inputdev;
1728 aiptek->usbdev = usbdev;
1729 aiptek->ifnum = intf->altsetting[0].desc.bInterfaceNumber;
1730 aiptek->inDelay = 0;
1731 aiptek->endDelay = 0;
1732 aiptek->previousJitterable = 0;
1733 aiptek->lastMacro = -1;
1734
1735
1736
1737
1738
1739
1740
1741 aiptek->curSetting.pointerMode = AIPTEK_POINTER_EITHER_MODE;
1742 aiptek->curSetting.coordinateMode = AIPTEK_COORDINATE_ABSOLUTE_MODE;
1743 aiptek->curSetting.toolMode = AIPTEK_TOOL_BUTTON_PEN_MODE;
1744 aiptek->curSetting.xTilt = AIPTEK_TILT_DISABLE;
1745 aiptek->curSetting.yTilt = AIPTEK_TILT_DISABLE;
1746 aiptek->curSetting.mouseButtonLeft = AIPTEK_MOUSE_LEFT_BUTTON;
1747 aiptek->curSetting.mouseButtonMiddle = AIPTEK_MOUSE_MIDDLE_BUTTON;
1748 aiptek->curSetting.mouseButtonRight = AIPTEK_MOUSE_RIGHT_BUTTON;
1749 aiptek->curSetting.stylusButtonUpper = AIPTEK_STYLUS_UPPER_BUTTON;
1750 aiptek->curSetting.stylusButtonLower = AIPTEK_STYLUS_LOWER_BUTTON;
1751 aiptek->curSetting.jitterDelay = jitterDelay;
1752 aiptek->curSetting.programmableDelay = programmableDelay;
1753
1754
1755
1756 aiptek->newSetting = aiptek->curSetting;
1757
1758
1759
1760
1761
1762
1763
1764
1765 usb_make_path(usbdev, aiptek->features.usbPath,
1766 sizeof(aiptek->features.usbPath));
1767 strlcat(aiptek->features.usbPath, "/input0",
1768 sizeof(aiptek->features.usbPath));
1769
1770
1771
1772
1773 inputdev->name = "Aiptek";
1774 inputdev->phys = aiptek->features.usbPath;
1775 usb_to_input_id(usbdev, &inputdev->id);
1776 inputdev->dev.parent = &intf->dev;
1777
1778 input_set_drvdata(inputdev, aiptek);
1779
1780 inputdev->open = aiptek_open;
1781 inputdev->close = aiptek_close;
1782
1783
1784
1785
1786 for (i = 0; i < ARRAY_SIZE(eventTypes); ++i)
1787 __set_bit(eventTypes[i], inputdev->evbit);
1788
1789 for (i = 0; i < ARRAY_SIZE(absEvents); ++i)
1790 __set_bit(absEvents[i], inputdev->absbit);
1791
1792 for (i = 0; i < ARRAY_SIZE(relEvents); ++i)
1793 __set_bit(relEvents[i], inputdev->relbit);
1794
1795 __set_bit(MSC_SERIAL, inputdev->mscbit);
1796
1797
1798 for (i = 0; i < ARRAY_SIZE(buttonEvents); ++i)
1799 __set_bit(buttonEvents[i], inputdev->keybit);
1800
1801 for (i = 0; i < ARRAY_SIZE(macroKeyEvents); ++i)
1802 __set_bit(macroKeyEvents[i], inputdev->keybit);
1803
1804
1805
1806
1807
1808
1809
1810 input_set_abs_params(inputdev, ABS_X, 0, 2999, 0, 0);
1811 input_set_abs_params(inputdev, ABS_Y, 0, 2249, 0, 0);
1812 input_set_abs_params(inputdev, ABS_PRESSURE, 0, 511, 0, 0);
1813 input_set_abs_params(inputdev, ABS_TILT_X, AIPTEK_TILT_MIN, AIPTEK_TILT_MAX, 0, 0);
1814 input_set_abs_params(inputdev, ABS_TILT_Y, AIPTEK_TILT_MIN, AIPTEK_TILT_MAX, 0, 0);
1815 input_set_abs_params(inputdev, ABS_WHEEL, AIPTEK_WHEEL_MIN, AIPTEK_WHEEL_MAX - 1, 0, 0);
1816
1817 endpoint = &intf->altsetting[0].endpoint[0].desc;
1818
1819
1820
1821
1822 usb_fill_int_urb(aiptek->urb,
1823 aiptek->usbdev,
1824 usb_rcvintpipe(aiptek->usbdev,
1825 endpoint->bEndpointAddress),
1826 aiptek->data, 8, aiptek_irq, aiptek,
1827 endpoint->bInterval);
1828
1829 aiptek->urb->transfer_dma = aiptek->data_dma;
1830 aiptek->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843 for (i = 0; i < ARRAY_SIZE(speeds); ++i) {
1844 aiptek->curSetting.programmableDelay = speeds[i];
1845 (void)aiptek_program_tablet(aiptek);
1846 if (aiptek->inputdev->absmax[ABS_X] > 0) {
1847 dev_info(&intf->dev,
1848 "Aiptek using %d ms programming speed\n",
1849 aiptek->curSetting.programmableDelay);
1850 break;
1851 }
1852 }
1853
1854
1855
1856 if (i == ARRAY_SIZE(speeds)) {
1857 dev_info(&intf->dev,
1858 "Aiptek tried all speeds, no sane response\n");
1859 goto fail2;
1860 }
1861
1862
1863
1864 usb_set_intfdata(intf, aiptek);
1865
1866
1867
1868 err = sysfs_create_group(&intf->dev.kobj, &aiptek_attribute_group);
1869 if (err) {
1870 dev_warn(&intf->dev, "cannot create sysfs group err: %d\n",
1871 err);
1872 goto fail3;
1873 }
1874
1875
1876
1877 err = input_register_device(aiptek->inputdev);
1878 if (err) {
1879 dev_warn(&intf->dev,
1880 "input_register_device returned err: %d\n", err);
1881 goto fail4;
1882 }
1883 return 0;
1884
1885 fail4: sysfs_remove_group(&intf->dev.kobj, &aiptek_attribute_group);
1886 fail3: usb_free_urb(aiptek->urb);
1887 fail2: usb_buffer_free(usbdev, AIPTEK_PACKET_LENGTH, aiptek->data,
1888 aiptek->data_dma);
1889 fail1: usb_set_intfdata(intf, NULL);
1890 input_free_device(inputdev);
1891 kfree(aiptek);
1892 return err;
1893}
1894
1895
1896
1897
1898static void aiptek_disconnect(struct usb_interface *intf)
1899{
1900 struct aiptek *aiptek = usb_get_intfdata(intf);
1901
1902
1903
1904 usb_set_intfdata(intf, NULL);
1905 if (aiptek != NULL) {
1906
1907
1908 usb_kill_urb(aiptek->urb);
1909 input_unregister_device(aiptek->inputdev);
1910 sysfs_remove_group(&intf->dev.kobj, &aiptek_attribute_group);
1911 usb_free_urb(aiptek->urb);
1912 usb_buffer_free(interface_to_usbdev(intf),
1913 AIPTEK_PACKET_LENGTH,
1914 aiptek->data, aiptek->data_dma);
1915 kfree(aiptek);
1916 }
1917}
1918
1919static struct usb_driver aiptek_driver = {
1920 .name = "aiptek",
1921 .probe = aiptek_probe,
1922 .disconnect = aiptek_disconnect,
1923 .id_table = aiptek_ids,
1924};
1925
1926static int __init aiptek_init(void)
1927{
1928 int result = usb_register(&aiptek_driver);
1929 if (result == 0) {
1930 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
1931 DRIVER_DESC "\n");
1932 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_AUTHOR "\n");
1933 }
1934 return result;
1935}
1936
1937static void __exit aiptek_exit(void)
1938{
1939 usb_deregister(&aiptek_driver);
1940}
1941
1942MODULE_AUTHOR(DRIVER_AUTHOR);
1943MODULE_DESCRIPTION(DRIVER_DESC);
1944MODULE_LICENSE("GPL");
1945
1946module_param(programmableDelay, int, 0);
1947MODULE_PARM_DESC(programmableDelay, "delay used during tablet programming");
1948module_param(jitterDelay, int, 0);
1949MODULE_PARM_DESC(jitterDelay, "stylus/mouse settlement delay");
1950
1951module_init(aiptek_init);
1952module_exit(aiptek_exit);
1953