2 * Native support for the Aiptek HyperPen USB Tablets
3 * (4000U/5000U/6000U/8000U/12000U)
5 * Copyright (c) 2001 Chris Atenasio <chris@crud.net>
6 * Copyright (c) 2002-2004 Bryan W. Headley <bwheadley@earthlink.net>
9 * Vojtech Pavlik <vojtech@suse.cz>
10 * Andreas Bach Aaen <abach@stofanet.dk>
11 * Clifford Wolf <clifford@clifford.at>
12 * Sam Mosel <sam.mosel@computer.org>
13 * James E. Blair <corvus@gnu.org>
14 * Daniel Egger <egger@suse.de>
16 * Many thanks to Oliver Kuechemann for his support.
19 * v0.1 - Initial release
20 * v0.2 - Hack to get around fake event 28's. (Bryan W. Headley)
21 * v0.3 - Make URB dynamic (Bryan W. Headley, Jun-8-2002)
22 * Released to Linux 2.4.19 and 2.5.x
23 * v0.4 - Rewrote substantial portions of the code to deal with
24 * corrected control sequences, timing, dynamic configuration,
25 * support of 6000U - 12000U, procfs, and macro key support
26 * (Jan-1-2003 - Feb-5-2003, Bryan W. Headley)
27 * v1.0 - Added support for diagnostic messages, count of messages
28 * received from URB - Mar-8-2003, Bryan W. Headley
29 * v1.1 - added support for tablet resolution, changed DV and proximity
30 * some corrections - Jun-22-2003, martin schneebacher
31 * - Added support for the sysfs interface, deprecating the
32 * procfs interface for 2.5.x kernel. Also added support for
33 * Wheel command. Bryan W. Headley July-15-2003.
34 * v1.2 - Reworked jitter timer as a kernel thread.
35 * Bryan W. Headley November-28-2003/Jan-10-2004.
36 * v1.3 - Repaired issue of kernel thread going nuts on single-processor
37 * machines, introduced programmableDelay as a command line
38 * parameter. Feb 7 2004, Bryan W. Headley.
39 * v1.4 - Re-wire jitter so it does not require a thread. Courtesy of
40 * Rene van Paassen. Added reporting of physical pointer device
41 * (e.g., stylus, mouse in reports 2, 3, 4, 5. We don't know
43 * what physical device reports for reports 1, 6.) Also enabled
44 * MOUSE and LENS tool button modes. Renamed "rubber" to "eraser".
45 * Feb 20, 2004, Bryan W. Headley.
46 * v1.5 - Added previousJitterable, so we don't do jitter delay when the
47 * user is holding a button down for periods of time.
50 * This kernel driver is augmented by the "Aiptek" XFree86 input
51 * driver for your X server, as well as the Gaiptek GUI Front-end
53 * These three products are highly interactive with one another,
54 * so therefore it's easier to document them all as one subsystem.
55 * Please visit the project's "home page", located at,
56 * http://aiptektablet.sourceforge.net.
58 * This program is free software; you can redistribute it and/or modify
59 * it under the terms of the GNU General Public License as published by
60 * the Free Software Foundation; either version 2 of the License, or
61 * (at your option) any later version.
63 * This program is distributed in the hope that it will be useful,
64 * but WITHOUT ANY WARRANTY; without even the implied warranty of
65 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
66 * GNU General Public License for more details.
68 * You should have received a copy of the GNU General Public License
69 * along with this program; if not, write to the Free Software
70 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
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>
85 #define DRIVER_VERSION "v1.5 (May-15-2004)"
86 #define DRIVER_AUTHOR "Bryan W. Headley/Chris Atenasio"
87 #define DRIVER_DESC "Aiptek HyperPen USB Tablet Driver (Linux 2.6.x)"
90 * Aiptek status packet:
92 * (returned as Report 1 - relative coordinates from mouse and stylus)
94 * bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0
95 * byte0 0 0 0 0 0 0 0 1
96 * byte1 0 0 0 0 0 BS2 BS Tip
97 * byte2 X7 X6 X5 X4 X3 X2 X1 X0
98 * byte3 Y7 Y6 Y5 Y4 Y3 Y2 Y1 Y0
100 * (returned as Report 2 - absolute coordinates from the stylus)
102 * bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0
103 * byte0 0 0 0 0 0 0 1 0
104 * byte1 X7 X6 X5 X4 X3 X2 X1 X0
105 * byte2 X15 X14 X13 X12 X11 X10 X9 X8
106 * byte3 Y7 Y6 Y5 Y4 Y3 Y2 Y1 Y0
107 * byte4 Y15 Y14 Y13 Y12 Y11 Y10 Y9 Y8
108 * byte5 * * * BS2 BS1 Tip IR DV
109 * byte6 P7 P6 P5 P4 P3 P2 P1 P0
110 * byte7 P15 P14 P13 P12 P11 P10 P9 P8
112 * (returned as Report 3 - absolute coordinates from the mouse)
114 * bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0
115 * byte0 0 0 0 0 0 0 1 0
116 * byte1 X7 X6 X5 X4 X3 X2 X1 X0
117 * byte2 X15 X14 X13 X12 X11 X10 X9 X8
118 * byte3 Y7 Y6 Y5 Y4 Y3 Y2 Y1 Y0
119 * byte4 Y15 Y14 Y13 Y12 Y11 Y10 Y9 Y8
120 * byte5 * * * BS2 BS1 Tip IR DV
121 * byte6 P7 P6 P5 P4 P3 P2 P1 P0
122 * byte7 P15 P14 P13 P12 P11 P10 P9 P8
124 * (returned as Report 4 - macrokeys from the stylus)
126 * bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0
127 * byte0 0 0 0 0 0 1 0 0
128 * byte1 0 0 0 BS2 BS Tip IR DV
129 * byte2 0 0 0 0 0 0 1 0
130 * byte3 0 0 0 K4 K3 K2 K1 K0
131 * byte4 P7 P6 P5 P4 P3 P2 P1 P0
132 * byte5 P15 P14 P13 P12 P11 P10 P9 P8
134 * (returned as Report 5 - macrokeys from the mouse)
136 * bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0
137 * byte0 0 0 0 0 0 1 0 0
138 * byte1 0 0 0 BS2 BS Tip IR DV
139 * byte2 0 0 0 0 0 0 1 0
140 * byte3 0 0 0 K4 K3 K2 K1 K0
141 * byte4 P7 P6 P5 P4 P3 P2 P1 P0
142 * byte5 P15 P14 P13 P12 P11 P10 P9 P8
144 * IR: In Range = Proximity on
146 * BS = Barrel Switch (as in, macro keys)
147 * BS2 also referred to as Tablet Pick
151 * Use report_type CONTROL (3)
154 * Command/Data Description Return Bytes Return Value
155 * 0x10/0x00 SwitchToMouse 0
156 * 0x10/0x01 SwitchToTablet 0
157 * 0x18/0x04 SetResolution 0
158 * 0x12/0xFF AutoGainOn 0
159 * 0x17/0x00 FilterOn 0
160 * 0x01/0x00 GetXExtension 2 MaxX
161 * 0x01/0x01 GetYExtension 2 MaxY
162 * 0x02/0x00 GetModelCode 2 ModelCode = LOBYTE
163 * 0x03/0x00 GetODMCode 2 ODMCode
164 * 0x08/0x00 GetPressureLevels 2 =512
165 * 0x04/0x00 GetFirmwareVersion 2 Firmware Version
166 * 0x11/0x02 EnableMacroKeys 0
168 * To initialize the tablet:
170 * (1) Send Resolution500LPI (Command)
171 * (2) Query for Model code (Option Report)
172 * (3) Query for ODM code (Option Report)
173 * (4) Query for firmware (Option Report)
174 * (5) Query for GetXExtension (Option Report)
175 * (6) Query for GetYExtension (Option Report)
176 * (7) Query for GetPressureLevels (Option Report)
177 * (8) SwitchToTablet for Absolute coordinates, or
178 * SwitchToMouse for Relative coordinates (Command)
179 * (9) EnableMacroKeys (Command)
180 * (10) FilterOn (Command)
181 * (11) AutoGainOn (Command)
183 * (Step 9 can be omitted, but you'll then have no function keys.)
186 #define USB_VENDOR_ID_AIPTEK 0x08ca
187 #define USB_REQ_GET_REPORT 0x01
188 #define USB_REQ_SET_REPORT 0x09
192 #define AIPTEK_POINTER_ONLY_MOUSE_MODE 0
193 #define AIPTEK_POINTER_ONLY_STYLUS_MODE 1
194 #define AIPTEK_POINTER_EITHER_MODE 2
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)
203 /* CoordinateMode code
205 #define AIPTEK_COORDINATE_RELATIVE_MODE 0
206 #define AIPTEK_COORDINATE_ABSOLUTE_MODE 1
208 /* XTilt and YTilt values
210 #define AIPTEK_TILT_MIN (-128)
211 #define AIPTEK_TILT_MAX 127
212 #define AIPTEK_TILT_DISABLE (-10101)
216 #define AIPTEK_WHEEL_MIN 0
217 #define AIPTEK_WHEEL_MAX 1024
218 #define AIPTEK_WHEEL_DISABLE (-10101)
220 /* ToolCode values, which BTW are 0x140 .. 0x14f
221 * We have things set up such that if TOOL_BUTTON_FIRED_BIT is
222 * not set, we'll send one instance of AIPTEK_TOOL_BUTTON_xxx.
224 * Whenever the user resets the value, TOOL_BUTTON_FIRED_BIT will
227 #define TOOL_BUTTON(x) ((x) & 0x14f)
228 #define TOOL_BUTTON_FIRED(x) ((x) & 0x200)
229 #define TOOL_BUTTON_FIRED_BIT 0x200
232 #define AIPTEK_TOOL_BUTTON_PEN_MODE BTN_TOOL_PEN
233 #define AIPTEK_TOOL_BUTTON_PEN_MODE BTN_TOOL_PEN
234 #define AIPTEK_TOOL_BUTTON_PENCIL_MODE BTN_TOOL_PENCIL
235 #define AIPTEK_TOOL_BUTTON_BRUSH_MODE BTN_TOOL_BRUSH
236 #define AIPTEK_TOOL_BUTTON_AIRBRUSH_MODE BTN_TOOL_AIRBRUSH
237 #define AIPTEK_TOOL_BUTTON_ERASER_MODE BTN_TOOL_RUBBER
238 #define AIPTEK_TOOL_BUTTON_MOUSE_MODE BTN_TOOL_MOUSE
239 #define AIPTEK_TOOL_BUTTON_LENS_MODE BTN_TOOL_LENS
241 /* Diagnostic message codes
243 #define AIPTEK_DIAGNOSTIC_NA 0
244 #define AIPTEK_DIAGNOSTIC_SENDING_RELATIVE_IN_ABSOLUTE 1
245 #define AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE 2
246 #define AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED 3
248 /* Time to wait (in ms) to help mask hand jittering
249 * when pressing the stylus buttons.
251 #define AIPTEK_JITTER_DELAY_DEFAULT 50
253 /* Time to wait (in ms) in-between sending the tablet
254 * a command and beginning the process of reading the return
255 * sequence from the tablet.
257 #define AIPTEK_PROGRAMMABLE_DELAY_25 25
258 #define AIPTEK_PROGRAMMABLE_DELAY_50 50
259 #define AIPTEK_PROGRAMMABLE_DELAY_100 100
260 #define AIPTEK_PROGRAMMABLE_DELAY_200 200
261 #define AIPTEK_PROGRAMMABLE_DELAY_300 300
262 #define AIPTEK_PROGRAMMABLE_DELAY_400 400
263 #define AIPTEK_PROGRAMMABLE_DELAY_DEFAULT AIPTEK_PROGRAMMABLE_DELAY_400
265 /* Mouse button programming
267 #define AIPTEK_MOUSE_LEFT_BUTTON 0x01
268 #define AIPTEK_MOUSE_RIGHT_BUTTON 0x02
269 #define AIPTEK_MOUSE_MIDDLE_BUTTON 0x04
271 /* Stylus button programming
273 #define AIPTEK_STYLUS_LOWER_BUTTON 0x08
274 #define AIPTEK_STYLUS_UPPER_BUTTON 0x10
276 /* Length of incoming packet from the tablet
278 #define AIPTEK_PACKET_LENGTH 8
280 /* We report in EV_MISC both the proximity and
281 * whether the report came from the stylus, tablet mouse
282 * or "unknown" -- Unknown when the tablet is in relative
283 * mode, because we only get report 1's.
285 #define AIPTEK_REPORT_TOOL_UNKNOWN 0x10
286 #define AIPTEK_REPORT_TOOL_STYLUS 0x20
287 #define AIPTEK_REPORT_TOOL_MOUSE 0x40
289 static int programmableDelay
= AIPTEK_PROGRAMMABLE_DELAY_DEFAULT
;
290 static int jitterDelay
= AIPTEK_JITTER_DELAY_DEFAULT
;
292 struct aiptek_features
{
293 int odmCode
; /* Tablet manufacturer code */
294 int modelCode
; /* Tablet model code (not unique) */
295 int firmwareCode
; /* prom/eeprom version */
296 char usbPath
[64 + 1]; /* device's physical usb path */
297 char inputPath
[64 + 1]; /* input device path */
300 struct aiptek_settings
{
301 int pointerMode
; /* stylus-, mouse-only or either */
302 int coordinateMode
; /* absolute/relative coords */
303 int toolMode
; /* pen, pencil, brush, etc. tool */
304 int xTilt
; /* synthetic xTilt amount */
305 int yTilt
; /* synthetic yTilt amount */
306 int wheel
; /* synthetic wheel amount */
307 int stylusButtonUpper
; /* stylus upper btn delivers... */
308 int stylusButtonLower
; /* stylus lower btn delivers... */
309 int mouseButtonLeft
; /* mouse left btn delivers... */
310 int mouseButtonMiddle
; /* mouse middle btn delivers... */
311 int mouseButtonRight
; /* mouse right btn delivers... */
312 int programmableDelay
; /* delay for tablet programming */
313 int jitterDelay
; /* delay for hand jittering */
317 struct input_dev
*inputdev
; /* input device struct */
318 struct usb_device
*usbdev
; /* usb device struct */
319 struct urb
*urb
; /* urb for incoming reports */
320 dma_addr_t data_dma
; /* our dma stuffage */
321 struct aiptek_features features
; /* tablet's array of features */
322 struct aiptek_settings curSetting
; /* tablet's current programmable */
323 struct aiptek_settings newSetting
; /* ... and new param settings */
324 unsigned int ifnum
; /* interface number for IO */
325 int diagnostic
; /* tablet diagnostic codes */
326 unsigned long eventCount
; /* event count */
327 int inDelay
; /* jitter: in jitter delay? */
328 unsigned long endDelay
; /* jitter: time when delay ends */
329 int previousJitterable
; /* jitterable prev value */
330 unsigned char *data
; /* incoming packet data */
334 * Permit easy lookup of keyboard events to send, versus
335 * the bitmap which comes from the tablet. This hides the
336 * issue that the F_keys are not sequentially numbered.
338 static const int macroKeyEvents
[] = {
339 KEY_ESC
, KEY_F1
, KEY_F2
, KEY_F3
, KEY_F4
, KEY_F5
,
340 KEY_F6
, KEY_F7
, KEY_F8
, KEY_F9
, KEY_F10
, KEY_F11
,
341 KEY_F12
, KEY_F13
, KEY_F14
, KEY_F15
, KEY_F16
, KEY_F17
,
342 KEY_F18
, KEY_F19
, KEY_F20
, KEY_F21
, KEY_F22
, KEY_F23
,
343 KEY_F24
, KEY_STOP
, KEY_AGAIN
, KEY_PROPS
, KEY_UNDO
,
344 KEY_FRONT
, KEY_COPY
, KEY_OPEN
, KEY_PASTE
, 0
347 /***********************************************************************
348 * Relative reports deliver values in 2's complement format to
349 * deal with negative offsets.
351 static int aiptek_convert_from_2s_complement(unsigned char c
)
357 if ((b
& 0x80) != 0) {
363 ret
= (negate
== 1) ? -ret
: ret
;
367 /***********************************************************************
368 * aiptek_irq can receive one of six potential reports.
369 * The documentation for each is in the body of the function.
371 * The tablet reports on several attributes per invocation of
372 * aiptek_irq. Because the Linux Input Event system allows the
373 * transmission of ONE attribute per input_report_xxx() call,
374 * collation has to be done on the other end to reconstitute
375 * a complete tablet report. Further, the number of Input Event reports
376 * submitted varies, depending on what USB report type, and circumstance.
377 * To deal with this, EV_MSC is used to indicate an 'end-of-report'
378 * message. This has been an undocumented convention understood by the kernel
379 * tablet driver and clients such as gpm and XFree86's tablet drivers.
381 * Of the information received from the tablet, the one piece I
382 * cannot transmit is the proximity bit (without resorting to an EV_MSC
383 * convention above.) I therefore have taken over REL_MISC and ABS_MISC
384 * (for relative and absolute reports, respectively) for communicating
385 * Proximity. Why two events? I thought it interesting to know if the
386 * Proximity event occurred while the tablet was in absolute or relative
389 * Other tablets use the notion of a certain minimum stylus pressure
390 * to infer proximity. While that could have been done, that is yet
391 * another 'by convention' behavior, the documentation for which
392 * would be spread between two (or more) pieces of software.
394 * EV_MSC usage was terminated for this purpose in Linux 2.5.x, and
395 * replaced with the input_sync() method (which emits EV_SYN.)
398 static void aiptek_irq(struct urb
*urb
)
400 struct aiptek
*aiptek
= urb
->context
;
401 unsigned char *data
= aiptek
->data
;
402 struct input_dev
*inputdev
= aiptek
->inputdev
;
404 int retval
, macro
, x
, y
, z
, left
, right
, middle
, p
, dv
, tip
, bs
, pck
;
406 switch (urb
->status
) {
414 /* This urb is terminated, clean up */
415 dbg("%s - urb shutting down with status: %d",
416 __FUNCTION__
, urb
->status
);
420 dbg("%s - nonzero urb status received: %d",
421 __FUNCTION__
, urb
->status
);
425 /* See if we are in a delay loop -- throw out report if true.
427 if (aiptek
->inDelay
== 1 && time_after(aiptek
->endDelay
, jiffies
)) {
432 aiptek
->eventCount
++;
434 /* Report 1 delivers relative coordinates with either a stylus
435 * or the mouse. You do not know, however, which input
436 * tool generated the event.
439 if (aiptek
->curSetting
.coordinateMode
==
440 AIPTEK_COORDINATE_ABSOLUTE_MODE
) {
442 AIPTEK_DIAGNOSTIC_SENDING_RELATIVE_IN_ABSOLUTE
;
444 x
= aiptek_convert_from_2s_complement(data
[2]);
445 y
= aiptek_convert_from_2s_complement(data
[3]);
447 /* jitterable keeps track of whether any button has been pressed.
448 * We're also using it to remap the physical mouse button mask
449 * to pseudo-settings. (We don't specifically care about it's
450 * value after moving/transposing mouse button bitmasks, except
451 * that a non-zero value indicates that one or more
452 * mouse button was pressed.)
454 jitterable
= data
[5] & 0x07;
456 left
= (data
[5] & aiptek
->curSetting
.mouseButtonLeft
) != 0 ? 1 : 0;
457 right
= (data
[5] & aiptek
->curSetting
.mouseButtonRight
) != 0 ? 1 : 0;
458 middle
= (data
[5] & aiptek
->curSetting
.mouseButtonMiddle
) != 0 ? 1 : 0;
460 input_report_key(inputdev
, BTN_LEFT
, left
);
461 input_report_key(inputdev
, BTN_MIDDLE
, middle
);
462 input_report_key(inputdev
, BTN_RIGHT
, right
);
463 input_report_rel(inputdev
, REL_X
, x
);
464 input_report_rel(inputdev
, REL_Y
, y
);
465 input_report_rel(inputdev
, REL_MISC
, 1 | AIPTEK_REPORT_TOOL_UNKNOWN
);
467 /* Wheel support is in the form of a single-event
470 if (aiptek
->curSetting
.wheel
!= AIPTEK_WHEEL_DISABLE
) {
471 input_report_rel(inputdev
, REL_WHEEL
,
472 aiptek
->curSetting
.wheel
);
473 aiptek
->curSetting
.wheel
= AIPTEK_WHEEL_DISABLE
;
475 input_sync(inputdev
);
478 /* Report 2 is delivered only by the stylus, and delivers
479 * absolute coordinates.
481 else if (data
[0] == 2) {
482 if (aiptek
->curSetting
.coordinateMode
== AIPTEK_COORDINATE_RELATIVE_MODE
) {
483 aiptek
->diagnostic
= AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE
;
484 } else if (!AIPTEK_POINTER_ALLOW_STYLUS_MODE
485 (aiptek
->curSetting
.pointerMode
)) {
486 aiptek
->diagnostic
= AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED
;
488 x
= le16_to_cpu(get_unaligned((__le16
*) (data
+ 1)));
489 y
= le16_to_cpu(get_unaligned((__le16
*) (data
+ 3)));
490 z
= le16_to_cpu(get_unaligned((__le16
*) (data
+ 6)));
492 p
= (data
[5] & 0x01) != 0 ? 1 : 0;
493 dv
= (data
[5] & 0x02) != 0 ? 1 : 0;
494 tip
= (data
[5] & 0x04) != 0 ? 1 : 0;
496 /* Use jitterable to re-arrange button masks
498 jitterable
= data
[5] & 0x18;
500 bs
= (data
[5] & aiptek
->curSetting
.stylusButtonLower
) != 0 ? 1 : 0;
501 pck
= (data
[5] & aiptek
->curSetting
.stylusButtonUpper
) != 0 ? 1 : 0;
503 /* dv indicates 'data valid' (e.g., the tablet is in sync
504 * and has delivered a "correct" report) We will ignore
505 * all 'bad' reports...
508 /* If we've not already sent a tool_button_?? code, do
509 * so now. Then set FIRED_BIT so it won't be resent unless
510 * the user forces FIRED_BIT off.
512 if (TOOL_BUTTON_FIRED
513 (aiptek
->curSetting
.toolMode
) == 0) {
514 input_report_key(inputdev
,
515 TOOL_BUTTON(aiptek
->curSetting
.toolMode
),
517 aiptek
->curSetting
.toolMode
|= TOOL_BUTTON_FIRED_BIT
;
521 input_report_abs(inputdev
, ABS_X
, x
);
522 input_report_abs(inputdev
, ABS_Y
, y
);
523 input_report_abs(inputdev
, ABS_PRESSURE
, z
);
525 input_report_key(inputdev
, BTN_TOUCH
, tip
);
526 input_report_key(inputdev
, BTN_STYLUS
, bs
);
527 input_report_key(inputdev
, BTN_STYLUS2
, pck
);
529 if (aiptek
->curSetting
.xTilt
!=
530 AIPTEK_TILT_DISABLE
) {
531 input_report_abs(inputdev
,
533 aiptek
->curSetting
.xTilt
);
535 if (aiptek
->curSetting
.yTilt
!= AIPTEK_TILT_DISABLE
) {
536 input_report_abs(inputdev
,
538 aiptek
->curSetting
.yTilt
);
541 /* Wheel support is in the form of a single-event
544 if (aiptek
->curSetting
.wheel
!=
545 AIPTEK_WHEEL_DISABLE
) {
546 input_report_abs(inputdev
,
548 aiptek
->curSetting
.wheel
);
549 aiptek
->curSetting
.wheel
= AIPTEK_WHEEL_DISABLE
;
552 input_report_abs(inputdev
, ABS_MISC
, p
| AIPTEK_REPORT_TOOL_STYLUS
);
553 input_sync(inputdev
);
557 /* Report 3's come from the mouse in absolute mode.
559 else if (data
[0] == 3) {
560 if (aiptek
->curSetting
.coordinateMode
== AIPTEK_COORDINATE_RELATIVE_MODE
) {
561 aiptek
->diagnostic
= AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE
;
562 } else if (!AIPTEK_POINTER_ALLOW_MOUSE_MODE
563 (aiptek
->curSetting
.pointerMode
)) {
564 aiptek
->diagnostic
= AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED
;
566 x
= le16_to_cpu(get_unaligned((__le16
*) (data
+ 1)));
567 y
= le16_to_cpu(get_unaligned((__le16
*) (data
+ 3)));
569 jitterable
= data
[5] & 0x1c;
571 p
= (data
[5] & 0x01) != 0 ? 1 : 0;
572 dv
= (data
[5] & 0x02) != 0 ? 1 : 0;
573 left
= (data
[5] & aiptek
->curSetting
.mouseButtonLeft
) != 0 ? 1 : 0;
574 right
= (data
[5] & aiptek
->curSetting
.mouseButtonRight
) != 0 ? 1 : 0;
575 middle
= (data
[5] & aiptek
->curSetting
.mouseButtonMiddle
) != 0 ? 1 : 0;
578 /* If we've not already sent a tool_button_?? code, do
579 * so now. Then set FIRED_BIT so it won't be resent unless
580 * the user forces FIRED_BIT off.
582 if (TOOL_BUTTON_FIRED
583 (aiptek
->curSetting
.toolMode
) == 0) {
584 input_report_key(inputdev
,
585 TOOL_BUTTON(aiptek
->curSetting
.toolMode
),
587 aiptek
->curSetting
.toolMode
|= TOOL_BUTTON_FIRED_BIT
;
591 input_report_abs(inputdev
, ABS_X
, x
);
592 input_report_abs(inputdev
, ABS_Y
, y
);
594 input_report_key(inputdev
, BTN_LEFT
, left
);
595 input_report_key(inputdev
, BTN_MIDDLE
, middle
);
596 input_report_key(inputdev
, BTN_RIGHT
, right
);
598 /* Wheel support is in the form of a single-event
601 if (aiptek
->curSetting
.wheel
!= AIPTEK_WHEEL_DISABLE
) {
602 input_report_abs(inputdev
,
604 aiptek
->curSetting
.wheel
);
605 aiptek
->curSetting
.wheel
= AIPTEK_WHEEL_DISABLE
;
608 input_report_rel(inputdev
, REL_MISC
, p
| AIPTEK_REPORT_TOOL_MOUSE
);
609 input_sync(inputdev
);
613 /* Report 4s come from the macro keys when pressed by stylus
615 else if (data
[0] == 4) {
616 jitterable
= data
[1] & 0x18;
618 p
= (data
[1] & 0x01) != 0 ? 1 : 0;
619 dv
= (data
[1] & 0x02) != 0 ? 1 : 0;
620 tip
= (data
[1] & 0x04) != 0 ? 1 : 0;
621 bs
= (data
[1] & aiptek
->curSetting
.stylusButtonLower
) != 0 ? 1 : 0;
622 pck
= (data
[1] & aiptek
->curSetting
.stylusButtonUpper
) != 0 ? 1 : 0;
625 z
= le16_to_cpu(get_unaligned((__le16
*) (data
+ 4)));
628 /* If we've not already sent a tool_button_?? code, do
629 * so now. Then set FIRED_BIT so it won't be resent unless
630 * the user forces FIRED_BIT off.
632 if (TOOL_BUTTON_FIRED(aiptek
->curSetting
.toolMode
) == 0) {
633 input_report_key(inputdev
,
634 TOOL_BUTTON(aiptek
->curSetting
.toolMode
),
636 aiptek
->curSetting
.toolMode
|= TOOL_BUTTON_FIRED_BIT
;
640 input_report_key(inputdev
, BTN_TOUCH
, tip
);
641 input_report_key(inputdev
, BTN_STYLUS
, bs
);
642 input_report_key(inputdev
, BTN_STYLUS2
, pck
);
643 input_report_abs(inputdev
, ABS_PRESSURE
, z
);
646 /* For safety, we're sending key 'break' codes for the
647 * neighboring macro keys.
650 input_report_key(inputdev
,
651 macroKeyEvents
[macro
- 1], 0);
654 input_report_key(inputdev
,
655 macroKeyEvents
[macro
+ 1], 0);
657 input_report_key(inputdev
, macroKeyEvents
[macro
], p
);
658 input_report_abs(inputdev
, ABS_MISC
,
659 p
| AIPTEK_REPORT_TOOL_STYLUS
);
660 input_sync(inputdev
);
663 /* Report 5s come from the macro keys when pressed by mouse
665 else if (data
[0] == 5) {
666 jitterable
= data
[1] & 0x1c;
668 p
= (data
[1] & 0x01) != 0 ? 1 : 0;
669 dv
= (data
[1] & 0x02) != 0 ? 1 : 0;
670 left
= (data
[1]& aiptek
->curSetting
.mouseButtonLeft
) != 0 ? 1 : 0;
671 right
= (data
[1] & aiptek
->curSetting
.mouseButtonRight
) != 0 ? 1 : 0;
672 middle
= (data
[1] & aiptek
->curSetting
.mouseButtonMiddle
) != 0 ? 1 : 0;
676 /* If we've not already sent a tool_button_?? code, do
677 * so now. Then set FIRED_BIT so it won't be resent unless
678 * the user forces FIRED_BIT off.
680 if (TOOL_BUTTON_FIRED(aiptek
->curSetting
.toolMode
) == 0) {
681 input_report_key(inputdev
,
682 TOOL_BUTTON(aiptek
->curSetting
.toolMode
),
684 aiptek
->curSetting
.toolMode
|= TOOL_BUTTON_FIRED_BIT
;
688 input_report_key(inputdev
, BTN_LEFT
, left
);
689 input_report_key(inputdev
, BTN_MIDDLE
, middle
);
690 input_report_key(inputdev
, BTN_RIGHT
, right
);
693 /* For safety, we're sending key 'break' codes for the
694 * neighboring macro keys.
697 input_report_key(inputdev
,
698 macroKeyEvents
[macro
- 1], 0);
701 input_report_key(inputdev
,
702 macroKeyEvents
[macro
+ 1], 0);
705 input_report_key(inputdev
, macroKeyEvents
[macro
], 1);
706 input_report_rel(inputdev
, ABS_MISC
,
707 p
| AIPTEK_REPORT_TOOL_MOUSE
);
708 input_sync(inputdev
);
711 /* We have no idea which tool can generate a report 6. Theoretically,
712 * neither need to, having been given reports 4 & 5 for such use.
713 * However, report 6 is the 'official-looking' report for macroKeys;
714 * reports 4 & 5 supposively are used to support unnamed, unknown
715 * hat switches (which just so happen to be the macroKeys.)
717 else if (data
[0] == 6) {
718 macro
= le16_to_cpu(get_unaligned((__le16
*) (data
+ 1)));
720 input_report_key(inputdev
, macroKeyEvents
[macro
- 1],
724 input_report_key(inputdev
, macroKeyEvents
[macro
+ 1],
728 /* If we've not already sent a tool_button_?? code, do
729 * so now. Then set FIRED_BIT so it won't be resent unless
730 * the user forces FIRED_BIT off.
732 if (TOOL_BUTTON_FIRED(aiptek
->curSetting
.toolMode
) == 0) {
733 input_report_key(inputdev
,
734 TOOL_BUTTON(aiptek
->curSetting
.
736 aiptek
->curSetting
.toolMode
|= TOOL_BUTTON_FIRED_BIT
;
739 input_report_key(inputdev
, macroKeyEvents
[macro
], 1);
740 input_report_abs(inputdev
, ABS_MISC
,
741 1 | AIPTEK_REPORT_TOOL_UNKNOWN
);
742 input_sync(inputdev
);
744 dbg("Unknown report %d", data
[0]);
747 /* Jitter may occur when the user presses a button on the stlyus
748 * or the mouse. What we do to prevent that is wait 'x' milliseconds
749 * following a 'jitterable' event, which should give the hand some time
752 * We just introduced aiptek->previousJitterable to carry forth the
753 * notion that jitter occurs when the button state changes from on to off:
754 * a person drawing, holding a button down is not subject to jittering.
755 * With that in mind, changing from upper button depressed to lower button
756 * WILL transition through a jitter delay.
759 if (aiptek
->previousJitterable
!= jitterable
&&
760 aiptek
->curSetting
.jitterDelay
!= 0 && aiptek
->inDelay
!= 1) {
761 aiptek
->endDelay
= jiffies
+
762 ((aiptek
->curSetting
.jitterDelay
* HZ
) / 1000);
765 aiptek
->previousJitterable
= jitterable
;
768 retval
= usb_submit_urb(urb
, GFP_ATOMIC
);
770 err("%s - usb_submit_urb failed with result %d",
771 __FUNCTION__
, retval
);
775 /***********************************************************************
776 * These are the USB id's known so far. We do not identify them to
777 * specific Aiptek model numbers, because there has been overlaps,
778 * use, and reuse of id's in existing models. Certain models have
779 * been known to use more than one ID, indicative perhaps of
780 * manufacturing revisions. In any event, we consider these
781 * IDs to not be model-specific nor unique.
783 static const struct usb_device_id aiptek_ids
[] = {
784 {USB_DEVICE(USB_VENDOR_ID_AIPTEK
, 0x01)},
785 {USB_DEVICE(USB_VENDOR_ID_AIPTEK
, 0x10)},
786 {USB_DEVICE(USB_VENDOR_ID_AIPTEK
, 0x20)},
787 {USB_DEVICE(USB_VENDOR_ID_AIPTEK
, 0x21)},
788 {USB_DEVICE(USB_VENDOR_ID_AIPTEK
, 0x22)},
789 {USB_DEVICE(USB_VENDOR_ID_AIPTEK
, 0x23)},
790 {USB_DEVICE(USB_VENDOR_ID_AIPTEK
, 0x24)},
794 MODULE_DEVICE_TABLE(usb
, aiptek_ids
);
796 /***********************************************************************
797 * Open an instance of the tablet driver.
799 static int aiptek_open(struct input_dev
*inputdev
)
801 struct aiptek
*aiptek
= input_get_drvdata(inputdev
);
803 aiptek
->urb
->dev
= aiptek
->usbdev
;
804 if (usb_submit_urb(aiptek
->urb
, GFP_KERNEL
) != 0)
810 /***********************************************************************
811 * Close an instance of the tablet driver.
813 static void aiptek_close(struct input_dev
*inputdev
)
815 struct aiptek
*aiptek
= input_get_drvdata(inputdev
);
817 usb_kill_urb(aiptek
->urb
);
820 /***********************************************************************
821 * aiptek_set_report and aiptek_get_report() are borrowed from Linux 2.4.x,
822 * where they were known as usb_set_report and usb_get_report.
825 aiptek_set_report(struct aiptek
*aiptek
,
826 unsigned char report_type
,
827 unsigned char report_id
, void *buffer
, int size
)
829 return usb_control_msg(aiptek
->usbdev
,
830 usb_sndctrlpipe(aiptek
->usbdev
, 0),
832 USB_TYPE_CLASS
| USB_RECIP_INTERFACE
|
833 USB_DIR_OUT
, (report_type
<< 8) + report_id
,
834 aiptek
->ifnum
, buffer
, size
, 5000);
838 aiptek_get_report(struct aiptek
*aiptek
,
839 unsigned char report_type
,
840 unsigned char report_id
, void *buffer
, int size
)
842 return usb_control_msg(aiptek
->usbdev
,
843 usb_rcvctrlpipe(aiptek
->usbdev
, 0),
845 USB_TYPE_CLASS
| USB_RECIP_INTERFACE
|
846 USB_DIR_IN
, (report_type
<< 8) + report_id
,
847 aiptek
->ifnum
, buffer
, size
, 5000);
850 /***********************************************************************
851 * Send a command to the tablet.
854 aiptek_command(struct aiptek
*aiptek
, unsigned char command
, unsigned char data
)
856 const int sizeof_buf
= 3 * sizeof(u8
);
860 buf
= kmalloc(sizeof_buf
, GFP_KERNEL
);
869 aiptek_set_report(aiptek
, 3, 2, buf
, sizeof_buf
)) != sizeof_buf
) {
870 dbg("aiptek_program: failed, tried to send: 0x%02x 0x%02x",
874 return ret
< 0 ? ret
: 0;
877 /***********************************************************************
878 * Retrieve information from the tablet. Querying info is defined as first
879 * sending the {command,data} sequence as a command, followed by a wait
880 * (aka, "programmaticDelay") and then a "read" request.
883 aiptek_query(struct aiptek
*aiptek
, unsigned char command
, unsigned char data
)
885 const int sizeof_buf
= 3 * sizeof(u8
);
889 buf
= kmalloc(sizeof_buf
, GFP_KERNEL
);
897 if (aiptek_command(aiptek
, command
, data
) != 0) {
901 msleep(aiptek
->curSetting
.programmableDelay
);
904 aiptek_get_report(aiptek
, 3, 2, buf
, sizeof_buf
)) != sizeof_buf
) {
905 dbg("aiptek_query failed: returned 0x%02x 0x%02x 0x%02x",
906 buf
[0], buf
[1], buf
[2]);
909 ret
= le16_to_cpu(get_unaligned((__le16
*) (buf
+ 1)));
915 /***********************************************************************
916 * Program the tablet into either absolute or relative mode.
917 * We also get information about the tablet's size.
919 static int aiptek_program_tablet(struct aiptek
*aiptek
)
922 /* Execute Resolution500LPI */
923 if ((ret
= aiptek_command(aiptek
, 0x18, 0x04)) < 0)
926 /* Query getModelCode */
927 if ((ret
= aiptek_query(aiptek
, 0x02, 0x00)) < 0)
929 aiptek
->features
.modelCode
= ret
& 0xff;
931 /* Query getODMCode */
932 if ((ret
= aiptek_query(aiptek
, 0x03, 0x00)) < 0)
934 aiptek
->features
.odmCode
= ret
;
936 /* Query getFirmwareCode */
937 if ((ret
= aiptek_query(aiptek
, 0x04, 0x00)) < 0)
939 aiptek
->features
.firmwareCode
= ret
;
941 /* Query getXextension */
942 if ((ret
= aiptek_query(aiptek
, 0x01, 0x00)) < 0)
944 aiptek
->inputdev
->absmin
[ABS_X
] = 0;
945 aiptek
->inputdev
->absmax
[ABS_X
] = ret
- 1;
947 /* Query getYextension */
948 if ((ret
= aiptek_query(aiptek
, 0x01, 0x01)) < 0)
950 aiptek
->inputdev
->absmin
[ABS_Y
] = 0;
951 aiptek
->inputdev
->absmax
[ABS_Y
] = ret
- 1;
953 /* Query getPressureLevels */
954 if ((ret
= aiptek_query(aiptek
, 0x08, 0x00)) < 0)
956 aiptek
->inputdev
->absmin
[ABS_PRESSURE
] = 0;
957 aiptek
->inputdev
->absmax
[ABS_PRESSURE
] = ret
- 1;
959 /* Depending on whether we are in absolute or relative mode, we will
960 * do a switchToTablet(absolute) or switchToMouse(relative) command.
962 if (aiptek
->curSetting
.coordinateMode
==
963 AIPTEK_COORDINATE_ABSOLUTE_MODE
) {
964 /* Execute switchToTablet */
965 if ((ret
= aiptek_command(aiptek
, 0x10, 0x01)) < 0) {
969 /* Execute switchToMouse */
970 if ((ret
= aiptek_command(aiptek
, 0x10, 0x00)) < 0) {
975 /* Enable the macro keys */
976 if ((ret
= aiptek_command(aiptek
, 0x11, 0x02)) < 0)
979 /* Execute FilterOn */
980 if ((ret
= aiptek_command(aiptek
, 0x17, 0x00)) < 0)
984 /* Execute AutoGainOn */
985 if ((ret
= aiptek_command(aiptek
, 0x12, 0xff)) < 0)
988 /* Reset the eventCount, so we track events from last (re)programming
990 aiptek
->diagnostic
= AIPTEK_DIAGNOSTIC_NA
;
991 aiptek
->eventCount
= 0;
996 /***********************************************************************
997 * Sysfs functions. Sysfs prefers that individually-tunable parameters
998 * exist in their separate pseudo-files. Summary data that is immutable
999 * may exist in a singular file so long as you don't define a writeable
1003 /***********************************************************************
1004 * support the 'size' file -- display support
1006 static ssize_t
show_tabletSize(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1008 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1013 return snprintf(buf
, PAGE_SIZE
, "%dx%d\n",
1014 aiptek
->inputdev
->absmax
[ABS_X
] + 1,
1015 aiptek
->inputdev
->absmax
[ABS_Y
] + 1);
1018 /* These structs define the sysfs files, param #1 is the name of the
1019 * file, param 2 is the file permissions, param 3 & 4 are to the
1020 * output generator and input parser routines. Absence of a routine is
1021 * permitted -- it only means can't either 'cat' the file, or send data
1024 static DEVICE_ATTR(size
, S_IRUGO
, show_tabletSize
, NULL
);
1026 /***********************************************************************
1027 * support routines for the 'product_id' file
1029 static ssize_t
show_tabletProductId(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1031 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1036 return snprintf(buf
, PAGE_SIZE
, "0x%04x\n",
1037 aiptek
->inputdev
->id
.product
);
1040 static DEVICE_ATTR(product_id
, S_IRUGO
, show_tabletProductId
, NULL
);
1042 /***********************************************************************
1043 * support routines for the 'vendor_id' file
1045 static ssize_t
show_tabletVendorId(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1047 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1052 return snprintf(buf
, PAGE_SIZE
, "0x%04x\n", aiptek
->inputdev
->id
.vendor
);
1055 static DEVICE_ATTR(vendor_id
, S_IRUGO
, show_tabletVendorId
, NULL
);
1057 /***********************************************************************
1058 * support routines for the 'vendor' file
1060 static ssize_t
show_tabletManufacturer(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1062 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1068 retval
= snprintf(buf
, PAGE_SIZE
, "%s\n", aiptek
->usbdev
->manufacturer
);
1072 static DEVICE_ATTR(vendor
, S_IRUGO
, show_tabletManufacturer
, NULL
);
1074 /***********************************************************************
1075 * support routines for the 'product' file
1077 static ssize_t
show_tabletProduct(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1079 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1085 retval
= snprintf(buf
, PAGE_SIZE
, "%s\n", aiptek
->usbdev
->product
);
1089 static DEVICE_ATTR(product
, S_IRUGO
, show_tabletProduct
, NULL
);
1091 /***********************************************************************
1092 * support routines for the 'pointer_mode' file. Note that this file
1093 * both displays current setting and allows reprogramming.
1095 static ssize_t
show_tabletPointerMode(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1097 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1103 switch (aiptek
->curSetting
.pointerMode
) {
1104 case AIPTEK_POINTER_ONLY_STYLUS_MODE
:
1108 case AIPTEK_POINTER_ONLY_MOUSE_MODE
:
1112 case AIPTEK_POINTER_EITHER_MODE
:
1120 return snprintf(buf
, PAGE_SIZE
, "%s\n", s
);
1124 store_tabletPointerMode(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1126 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1130 if (strcmp(buf
, "stylus") == 0) {
1131 aiptek
->newSetting
.pointerMode
=
1132 AIPTEK_POINTER_ONLY_STYLUS_MODE
;
1133 } else if (strcmp(buf
, "mouse") == 0) {
1134 aiptek
->newSetting
.pointerMode
= AIPTEK_POINTER_ONLY_MOUSE_MODE
;
1135 } else if (strcmp(buf
, "either") == 0) {
1136 aiptek
->newSetting
.pointerMode
= AIPTEK_POINTER_EITHER_MODE
;
1141 static DEVICE_ATTR(pointer_mode
,
1143 show_tabletPointerMode
, store_tabletPointerMode
);
1145 /***********************************************************************
1146 * support routines for the 'coordinate_mode' file. Note that this file
1147 * both displays current setting and allows reprogramming.
1149 static ssize_t
show_tabletCoordinateMode(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1151 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1157 switch (aiptek
->curSetting
.coordinateMode
) {
1158 case AIPTEK_COORDINATE_ABSOLUTE_MODE
:
1162 case AIPTEK_COORDINATE_RELATIVE_MODE
:
1170 return snprintf(buf
, PAGE_SIZE
, "%s\n", s
);
1174 store_tabletCoordinateMode(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1176 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1180 if (strcmp(buf
, "absolute") == 0) {
1181 aiptek
->newSetting
.pointerMode
=
1182 AIPTEK_COORDINATE_ABSOLUTE_MODE
;
1183 } else if (strcmp(buf
, "relative") == 0) {
1184 aiptek
->newSetting
.pointerMode
=
1185 AIPTEK_COORDINATE_RELATIVE_MODE
;
1190 static DEVICE_ATTR(coordinate_mode
,
1192 show_tabletCoordinateMode
, store_tabletCoordinateMode
);
1194 /***********************************************************************
1195 * support routines for the 'tool_mode' file. Note that this file
1196 * both displays current setting and allows reprogramming.
1198 static ssize_t
show_tabletToolMode(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1200 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1206 switch (TOOL_BUTTON(aiptek
->curSetting
.toolMode
)) {
1207 case AIPTEK_TOOL_BUTTON_MOUSE_MODE
:
1211 case AIPTEK_TOOL_BUTTON_ERASER_MODE
:
1215 case AIPTEK_TOOL_BUTTON_PENCIL_MODE
:
1219 case AIPTEK_TOOL_BUTTON_PEN_MODE
:
1223 case AIPTEK_TOOL_BUTTON_BRUSH_MODE
:
1227 case AIPTEK_TOOL_BUTTON_AIRBRUSH_MODE
:
1231 case AIPTEK_TOOL_BUTTON_LENS_MODE
:
1239 return snprintf(buf
, PAGE_SIZE
, "%s\n", s
);
1243 store_tabletToolMode(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1245 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1249 if (strcmp(buf
, "mouse") == 0) {
1250 aiptek
->newSetting
.toolMode
= AIPTEK_TOOL_BUTTON_MOUSE_MODE
;
1251 } else if (strcmp(buf
, "eraser") == 0) {
1252 aiptek
->newSetting
.toolMode
= AIPTEK_TOOL_BUTTON_ERASER_MODE
;
1253 } else if (strcmp(buf
, "pencil") == 0) {
1254 aiptek
->newSetting
.toolMode
= AIPTEK_TOOL_BUTTON_PENCIL_MODE
;
1255 } else if (strcmp(buf
, "pen") == 0) {
1256 aiptek
->newSetting
.toolMode
= AIPTEK_TOOL_BUTTON_PEN_MODE
;
1257 } else if (strcmp(buf
, "brush") == 0) {
1258 aiptek
->newSetting
.toolMode
= AIPTEK_TOOL_BUTTON_BRUSH_MODE
;
1259 } else if (strcmp(buf
, "airbrush") == 0) {
1260 aiptek
->newSetting
.toolMode
= AIPTEK_TOOL_BUTTON_AIRBRUSH_MODE
;
1261 } else if (strcmp(buf
, "lens") == 0) {
1262 aiptek
->newSetting
.toolMode
= AIPTEK_TOOL_BUTTON_LENS_MODE
;
1268 static DEVICE_ATTR(tool_mode
,
1270 show_tabletToolMode
, store_tabletToolMode
);
1272 /***********************************************************************
1273 * support routines for the 'xtilt' file. Note that this file
1274 * both displays current setting and allows reprogramming.
1276 static ssize_t
show_tabletXtilt(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1278 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1283 if (aiptek
->curSetting
.xTilt
== AIPTEK_TILT_DISABLE
) {
1284 return snprintf(buf
, PAGE_SIZE
, "disable\n");
1286 return snprintf(buf
, PAGE_SIZE
, "%d\n",
1287 aiptek
->curSetting
.xTilt
);
1292 store_tabletXtilt(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1294 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1300 if (strcmp(buf
, "disable") == 0) {
1301 aiptek
->newSetting
.xTilt
= AIPTEK_TILT_DISABLE
;
1303 x
= (int)simple_strtol(buf
, NULL
, 10);
1304 if (x
>= AIPTEK_TILT_MIN
&& x
<= AIPTEK_TILT_MAX
) {
1305 aiptek
->newSetting
.xTilt
= x
;
1311 static DEVICE_ATTR(xtilt
,
1312 S_IRUGO
| S_IWUGO
, show_tabletXtilt
, store_tabletXtilt
);
1314 /***********************************************************************
1315 * support routines for the 'ytilt' file. Note that this file
1316 * both displays current setting and allows reprogramming.
1318 static ssize_t
show_tabletYtilt(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1320 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1325 if (aiptek
->curSetting
.yTilt
== AIPTEK_TILT_DISABLE
) {
1326 return snprintf(buf
, PAGE_SIZE
, "disable\n");
1328 return snprintf(buf
, PAGE_SIZE
, "%d\n",
1329 aiptek
->curSetting
.yTilt
);
1334 store_tabletYtilt(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1336 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1342 if (strcmp(buf
, "disable") == 0) {
1343 aiptek
->newSetting
.yTilt
= AIPTEK_TILT_DISABLE
;
1345 y
= (int)simple_strtol(buf
, NULL
, 10);
1346 if (y
>= AIPTEK_TILT_MIN
&& y
<= AIPTEK_TILT_MAX
) {
1347 aiptek
->newSetting
.yTilt
= y
;
1353 static DEVICE_ATTR(ytilt
,
1354 S_IRUGO
| S_IWUGO
, show_tabletYtilt
, store_tabletYtilt
);
1356 /***********************************************************************
1357 * support routines for the 'jitter' file. Note that this file
1358 * both displays current setting and allows reprogramming.
1360 static ssize_t
show_tabletJitterDelay(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1362 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1367 return snprintf(buf
, PAGE_SIZE
, "%d\n", aiptek
->curSetting
.jitterDelay
);
1371 store_tabletJitterDelay(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1373 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1378 aiptek
->newSetting
.jitterDelay
= (int)simple_strtol(buf
, NULL
, 10);
1382 static DEVICE_ATTR(jitter
,
1384 show_tabletJitterDelay
, store_tabletJitterDelay
);
1386 /***********************************************************************
1387 * support routines for the 'delay' file. Note that this file
1388 * both displays current setting and allows reprogramming.
1390 static ssize_t
show_tabletProgrammableDelay(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1392 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1397 return snprintf(buf
, PAGE_SIZE
, "%d\n",
1398 aiptek
->curSetting
.programmableDelay
);
1402 store_tabletProgrammableDelay(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1404 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1409 aiptek
->newSetting
.programmableDelay
= (int)simple_strtol(buf
, NULL
, 10);
1413 static DEVICE_ATTR(delay
,
1415 show_tabletProgrammableDelay
, store_tabletProgrammableDelay
);
1417 /***********************************************************************
1418 * support routines for the 'input_path' file. Note that this file
1419 * only displays current setting.
1421 static ssize_t
show_tabletInputDevice(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1423 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1428 return snprintf(buf
, PAGE_SIZE
, "/dev/input/%s\n",
1429 aiptek
->features
.inputPath
);
1432 static DEVICE_ATTR(input_path
, S_IRUGO
, show_tabletInputDevice
, NULL
);
1434 /***********************************************************************
1435 * support routines for the 'event_count' file. Note that this file
1436 * only displays current setting.
1438 static ssize_t
show_tabletEventsReceived(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1440 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1445 return snprintf(buf
, PAGE_SIZE
, "%ld\n", aiptek
->eventCount
);
1448 static DEVICE_ATTR(event_count
, S_IRUGO
, show_tabletEventsReceived
, NULL
);
1450 /***********************************************************************
1451 * support routines for the 'diagnostic' file. Note that this file
1452 * only displays current setting.
1454 static ssize_t
show_tabletDiagnosticMessage(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1456 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1462 switch (aiptek
->diagnostic
) {
1463 case AIPTEK_DIAGNOSTIC_NA
:
1464 retMsg
= "no errors\n";
1467 case AIPTEK_DIAGNOSTIC_SENDING_RELATIVE_IN_ABSOLUTE
:
1468 retMsg
= "Error: receiving relative reports\n";
1471 case AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE
:
1472 retMsg
= "Error: receiving absolute reports\n";
1475 case AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED
:
1476 if (aiptek
->curSetting
.pointerMode
==
1477 AIPTEK_POINTER_ONLY_MOUSE_MODE
) {
1478 retMsg
= "Error: receiving stylus reports\n";
1480 retMsg
= "Error: receiving mouse reports\n";
1487 return snprintf(buf
, PAGE_SIZE
, retMsg
);
1490 static DEVICE_ATTR(diagnostic
, S_IRUGO
, show_tabletDiagnosticMessage
, NULL
);
1492 /***********************************************************************
1493 * support routines for the 'stylus_upper' file. Note that this file
1494 * both displays current setting and allows for setting changing.
1496 static ssize_t
show_tabletStylusUpper(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1498 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1504 switch (aiptek
->curSetting
.stylusButtonUpper
) {
1505 case AIPTEK_STYLUS_UPPER_BUTTON
:
1509 case AIPTEK_STYLUS_LOWER_BUTTON
:
1517 return snprintf(buf
, PAGE_SIZE
, "%s\n", s
);
1521 store_tabletStylusUpper(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1523 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1528 if (strcmp(buf
, "upper") == 0) {
1529 aiptek
->newSetting
.stylusButtonUpper
=
1530 AIPTEK_STYLUS_UPPER_BUTTON
;
1531 } else if (strcmp(buf
, "lower") == 0) {
1532 aiptek
->newSetting
.stylusButtonUpper
=
1533 AIPTEK_STYLUS_LOWER_BUTTON
;
1538 static DEVICE_ATTR(stylus_upper
,
1540 show_tabletStylusUpper
, store_tabletStylusUpper
);
1542 /***********************************************************************
1543 * support routines for the 'stylus_lower' file. Note that this file
1544 * both displays current setting and allows for setting changing.
1546 static ssize_t
show_tabletStylusLower(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1548 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1554 switch (aiptek
->curSetting
.stylusButtonLower
) {
1555 case AIPTEK_STYLUS_UPPER_BUTTON
:
1559 case AIPTEK_STYLUS_LOWER_BUTTON
:
1567 return snprintf(buf
, PAGE_SIZE
, "%s\n", s
);
1571 store_tabletStylusLower(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1573 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1578 if (strcmp(buf
, "upper") == 0) {
1579 aiptek
->newSetting
.stylusButtonLower
=
1580 AIPTEK_STYLUS_UPPER_BUTTON
;
1581 } else if (strcmp(buf
, "lower") == 0) {
1582 aiptek
->newSetting
.stylusButtonLower
=
1583 AIPTEK_STYLUS_LOWER_BUTTON
;
1588 static DEVICE_ATTR(stylus_lower
,
1590 show_tabletStylusLower
, store_tabletStylusLower
);
1592 /***********************************************************************
1593 * support routines for the 'mouse_left' file. Note that this file
1594 * both displays current setting and allows for setting changing.
1596 static ssize_t
show_tabletMouseLeft(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1598 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1604 switch (aiptek
->curSetting
.mouseButtonLeft
) {
1605 case AIPTEK_MOUSE_LEFT_BUTTON
:
1609 case AIPTEK_MOUSE_MIDDLE_BUTTON
:
1613 case AIPTEK_MOUSE_RIGHT_BUTTON
:
1621 return snprintf(buf
, PAGE_SIZE
, "%s\n", s
);
1625 store_tabletMouseLeft(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1627 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1632 if (strcmp(buf
, "left") == 0) {
1633 aiptek
->newSetting
.mouseButtonLeft
= AIPTEK_MOUSE_LEFT_BUTTON
;
1634 } else if (strcmp(buf
, "middle") == 0) {
1635 aiptek
->newSetting
.mouseButtonLeft
= AIPTEK_MOUSE_MIDDLE_BUTTON
;
1636 } else if (strcmp(buf
, "right") == 0) {
1637 aiptek
->newSetting
.mouseButtonLeft
= AIPTEK_MOUSE_RIGHT_BUTTON
;
1642 static DEVICE_ATTR(mouse_left
,
1644 show_tabletMouseLeft
, store_tabletMouseLeft
);
1646 /***********************************************************************
1647 * support routines for the 'mouse_middle' file. Note that this file
1648 * both displays current setting and allows for setting changing.
1650 static ssize_t
show_tabletMouseMiddle(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1652 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1658 switch (aiptek
->curSetting
.mouseButtonMiddle
) {
1659 case AIPTEK_MOUSE_LEFT_BUTTON
:
1663 case AIPTEK_MOUSE_MIDDLE_BUTTON
:
1667 case AIPTEK_MOUSE_RIGHT_BUTTON
:
1675 return snprintf(buf
, PAGE_SIZE
, "%s\n", s
);
1679 store_tabletMouseMiddle(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1681 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1686 if (strcmp(buf
, "left") == 0) {
1687 aiptek
->newSetting
.mouseButtonMiddle
= AIPTEK_MOUSE_LEFT_BUTTON
;
1688 } else if (strcmp(buf
, "middle") == 0) {
1689 aiptek
->newSetting
.mouseButtonMiddle
=
1690 AIPTEK_MOUSE_MIDDLE_BUTTON
;
1691 } else if (strcmp(buf
, "right") == 0) {
1692 aiptek
->newSetting
.mouseButtonMiddle
=
1693 AIPTEK_MOUSE_RIGHT_BUTTON
;
1698 static DEVICE_ATTR(mouse_middle
,
1700 show_tabletMouseMiddle
, store_tabletMouseMiddle
);
1702 /***********************************************************************
1703 * support routines for the 'mouse_right' file. Note that this file
1704 * both displays current setting and allows for setting changing.
1706 static ssize_t
show_tabletMouseRight(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1708 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1714 switch (aiptek
->curSetting
.mouseButtonRight
) {
1715 case AIPTEK_MOUSE_LEFT_BUTTON
:
1719 case AIPTEK_MOUSE_MIDDLE_BUTTON
:
1723 case AIPTEK_MOUSE_RIGHT_BUTTON
:
1731 return snprintf(buf
, PAGE_SIZE
, "%s\n", s
);
1735 store_tabletMouseRight(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1737 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1742 if (strcmp(buf
, "left") == 0) {
1743 aiptek
->newSetting
.mouseButtonRight
= AIPTEK_MOUSE_LEFT_BUTTON
;
1744 } else if (strcmp(buf
, "middle") == 0) {
1745 aiptek
->newSetting
.mouseButtonRight
=
1746 AIPTEK_MOUSE_MIDDLE_BUTTON
;
1747 } else if (strcmp(buf
, "right") == 0) {
1748 aiptek
->newSetting
.mouseButtonRight
= AIPTEK_MOUSE_RIGHT_BUTTON
;
1753 static DEVICE_ATTR(mouse_right
,
1755 show_tabletMouseRight
, store_tabletMouseRight
);
1757 /***********************************************************************
1758 * support routines for the 'wheel' file. Note that this file
1759 * both displays current setting and allows for setting changing.
1761 static ssize_t
show_tabletWheel(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1763 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1768 if (aiptek
->curSetting
.wheel
== AIPTEK_WHEEL_DISABLE
) {
1769 return snprintf(buf
, PAGE_SIZE
, "disable\n");
1771 return snprintf(buf
, PAGE_SIZE
, "%d\n",
1772 aiptek
->curSetting
.wheel
);
1777 store_tabletWheel(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1779 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1784 aiptek
->newSetting
.wheel
= (int)simple_strtol(buf
, NULL
, 10);
1788 static DEVICE_ATTR(wheel
,
1789 S_IRUGO
| S_IWUGO
, show_tabletWheel
, store_tabletWheel
);
1791 /***********************************************************************
1792 * support routines for the 'execute' file. Note that this file
1793 * both displays current setting and allows for setting changing.
1795 static ssize_t
show_tabletExecute(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1797 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1802 /* There is nothing useful to display, so a one-line manual
1805 return snprintf(buf
, PAGE_SIZE
,
1806 "Write anything to this file to program your tablet.\n");
1810 store_tabletExecute(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1812 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1817 /* We do not care what you write to this file. Merely the action
1818 * of writing to this file triggers a tablet reprogramming.
1820 memcpy(&aiptek
->curSetting
, &aiptek
->newSetting
,
1821 sizeof(struct aiptek_settings
));
1823 if (aiptek_program_tablet(aiptek
) < 0)
1829 static DEVICE_ATTR(execute
,
1830 S_IRUGO
| S_IWUGO
, show_tabletExecute
, store_tabletExecute
);
1832 /***********************************************************************
1833 * support routines for the 'odm_code' file. Note that this file
1834 * only displays current setting.
1836 static ssize_t
show_tabletODMCode(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1838 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1843 return snprintf(buf
, PAGE_SIZE
, "0x%04x\n", aiptek
->features
.odmCode
);
1846 static DEVICE_ATTR(odm_code
, S_IRUGO
, show_tabletODMCode
, NULL
);
1848 /***********************************************************************
1849 * support routines for the 'model_code' file. Note that this file
1850 * only displays current setting.
1852 static ssize_t
show_tabletModelCode(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1854 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1859 return snprintf(buf
, PAGE_SIZE
, "0x%04x\n", aiptek
->features
.modelCode
);
1862 static DEVICE_ATTR(model_code
, S_IRUGO
, show_tabletModelCode
, NULL
);
1864 /***********************************************************************
1865 * support routines for the 'firmware_code' file. Note that this file
1866 * only displays current setting.
1868 static ssize_t
show_firmwareCode(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1870 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1875 return snprintf(buf
, PAGE_SIZE
, "%04x\n",
1876 aiptek
->features
.firmwareCode
);
1879 static DEVICE_ATTR(firmware_code
, S_IRUGO
, show_firmwareCode
, NULL
);
1881 /***********************************************************************
1882 * This routine removes all existing sysfs files managed by this device
1885 static void aiptek_delete_files(struct device
*dev
)
1887 device_remove_file(dev
, &dev_attr_size
);
1888 device_remove_file(dev
, &dev_attr_product_id
);
1889 device_remove_file(dev
, &dev_attr_vendor_id
);
1890 device_remove_file(dev
, &dev_attr_vendor
);
1891 device_remove_file(dev
, &dev_attr_product
);
1892 device_remove_file(dev
, &dev_attr_pointer_mode
);
1893 device_remove_file(dev
, &dev_attr_coordinate_mode
);
1894 device_remove_file(dev
, &dev_attr_tool_mode
);
1895 device_remove_file(dev
, &dev_attr_xtilt
);
1896 device_remove_file(dev
, &dev_attr_ytilt
);
1897 device_remove_file(dev
, &dev_attr_jitter
);
1898 device_remove_file(dev
, &dev_attr_delay
);
1899 device_remove_file(dev
, &dev_attr_input_path
);
1900 device_remove_file(dev
, &dev_attr_event_count
);
1901 device_remove_file(dev
, &dev_attr_diagnostic
);
1902 device_remove_file(dev
, &dev_attr_odm_code
);
1903 device_remove_file(dev
, &dev_attr_model_code
);
1904 device_remove_file(dev
, &dev_attr_firmware_code
);
1905 device_remove_file(dev
, &dev_attr_stylus_lower
);
1906 device_remove_file(dev
, &dev_attr_stylus_upper
);
1907 device_remove_file(dev
, &dev_attr_mouse_left
);
1908 device_remove_file(dev
, &dev_attr_mouse_middle
);
1909 device_remove_file(dev
, &dev_attr_mouse_right
);
1910 device_remove_file(dev
, &dev_attr_wheel
);
1911 device_remove_file(dev
, &dev_attr_execute
);
1914 /***********************************************************************
1915 * This routine creates the sysfs files managed by this device
1918 static int aiptek_add_files(struct device
*dev
)
1922 if ((ret
= device_create_file(dev
, &dev_attr_size
)) ||
1923 (ret
= device_create_file(dev
, &dev_attr_product_id
)) ||
1924 (ret
= device_create_file(dev
, &dev_attr_vendor_id
)) ||
1925 (ret
= device_create_file(dev
, &dev_attr_vendor
)) ||
1926 (ret
= device_create_file(dev
, &dev_attr_product
)) ||
1927 (ret
= device_create_file(dev
, &dev_attr_pointer_mode
)) ||
1928 (ret
= device_create_file(dev
, &dev_attr_coordinate_mode
)) ||
1929 (ret
= device_create_file(dev
, &dev_attr_tool_mode
)) ||
1930 (ret
= device_create_file(dev
, &dev_attr_xtilt
)) ||
1931 (ret
= device_create_file(dev
, &dev_attr_ytilt
)) ||
1932 (ret
= device_create_file(dev
, &dev_attr_jitter
)) ||
1933 (ret
= device_create_file(dev
, &dev_attr_delay
)) ||
1934 (ret
= device_create_file(dev
, &dev_attr_input_path
)) ||
1935 (ret
= device_create_file(dev
, &dev_attr_event_count
)) ||
1936 (ret
= device_create_file(dev
, &dev_attr_diagnostic
)) ||
1937 (ret
= device_create_file(dev
, &dev_attr_odm_code
)) ||
1938 (ret
= device_create_file(dev
, &dev_attr_model_code
)) ||
1939 (ret
= device_create_file(dev
, &dev_attr_firmware_code
)) ||
1940 (ret
= device_create_file(dev
, &dev_attr_stylus_lower
)) ||
1941 (ret
= device_create_file(dev
, &dev_attr_stylus_upper
)) ||
1942 (ret
= device_create_file(dev
, &dev_attr_mouse_left
)) ||
1943 (ret
= device_create_file(dev
, &dev_attr_mouse_middle
)) ||
1944 (ret
= device_create_file(dev
, &dev_attr_mouse_right
)) ||
1945 (ret
= device_create_file(dev
, &dev_attr_wheel
)) ||
1946 (ret
= device_create_file(dev
, &dev_attr_execute
))) {
1947 err("aiptek: killing own sysfs device files\n");
1948 aiptek_delete_files(dev
);
1953 /***********************************************************************
1954 * This routine is called when a tablet has been identified. It basically
1955 * sets up the tablet and the driver's internal structures.
1958 aiptek_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
)
1960 struct usb_device
*usbdev
= interface_to_usbdev(intf
);
1961 struct usb_endpoint_descriptor
*endpoint
;
1962 struct aiptek
*aiptek
;
1963 struct input_dev
*inputdev
;
1964 struct input_handle
*inputhandle
;
1965 struct list_head
*node
, *next
;
1968 AIPTEK_PROGRAMMABLE_DELAY_50
,
1969 AIPTEK_PROGRAMMABLE_DELAY_400
,
1970 AIPTEK_PROGRAMMABLE_DELAY_25
,
1971 AIPTEK_PROGRAMMABLE_DELAY_100
,
1972 AIPTEK_PROGRAMMABLE_DELAY_200
,
1973 AIPTEK_PROGRAMMABLE_DELAY_300
1977 /* programmableDelay is where the command-line specified
1978 * delay is kept. We make it the first element of speeds[],
1979 * so therefore, your override speed is tried first, then the
1980 * remainder. Note that the default value of 400ms will be tried
1981 * if you do not specify any command line parameter.
1983 speeds
[0] = programmableDelay
;
1985 aiptek
= kzalloc(sizeof(struct aiptek
), GFP_KERNEL
);
1986 inputdev
= input_allocate_device();
1987 if (!aiptek
|| !inputdev
)
1990 aiptek
->data
= usb_buffer_alloc(usbdev
, AIPTEK_PACKET_LENGTH
,
1991 GFP_ATOMIC
, &aiptek
->data_dma
);
1995 aiptek
->urb
= usb_alloc_urb(0, GFP_KERNEL
);
1999 aiptek
->inputdev
= inputdev
;
2000 aiptek
->usbdev
= usbdev
;
2001 aiptek
->ifnum
= intf
->altsetting
[0].desc
.bInterfaceNumber
;
2002 aiptek
->inDelay
= 0;
2003 aiptek
->endDelay
= 0;
2004 aiptek
->previousJitterable
= 0;
2006 /* Set up the curSettings struct. Said struct contains the current
2007 * programmable parameters. The newSetting struct contains changes
2008 * the user makes to the settings via the sysfs interface. Those
2009 * changes are not "committed" to curSettings until the user
2010 * writes to the sysfs/.../execute file.
2012 aiptek
->curSetting
.pointerMode
= AIPTEK_POINTER_EITHER_MODE
;
2013 aiptek
->curSetting
.coordinateMode
= AIPTEK_COORDINATE_ABSOLUTE_MODE
;
2014 aiptek
->curSetting
.toolMode
= AIPTEK_TOOL_BUTTON_PEN_MODE
;
2015 aiptek
->curSetting
.xTilt
= AIPTEK_TILT_DISABLE
;
2016 aiptek
->curSetting
.yTilt
= AIPTEK_TILT_DISABLE
;
2017 aiptek
->curSetting
.mouseButtonLeft
= AIPTEK_MOUSE_LEFT_BUTTON
;
2018 aiptek
->curSetting
.mouseButtonMiddle
= AIPTEK_MOUSE_MIDDLE_BUTTON
;
2019 aiptek
->curSetting
.mouseButtonRight
= AIPTEK_MOUSE_RIGHT_BUTTON
;
2020 aiptek
->curSetting
.stylusButtonUpper
= AIPTEK_STYLUS_UPPER_BUTTON
;
2021 aiptek
->curSetting
.stylusButtonLower
= AIPTEK_STYLUS_LOWER_BUTTON
;
2022 aiptek
->curSetting
.jitterDelay
= jitterDelay
;
2023 aiptek
->curSetting
.programmableDelay
= programmableDelay
;
2025 /* Both structs should have equivalent settings
2027 aiptek
->newSetting
= aiptek
->curSetting
;
2029 /* Determine the usb devices' physical path.
2030 * Asketh not why we always pretend we're using "../input0",
2031 * but I suspect this will have to be refactored one
2032 * day if a single USB device can be a keyboard & a mouse
2033 * & a tablet, and the inputX number actually will tell
2036 usb_make_path(usbdev
, aiptek
->features
.usbPath
,
2037 sizeof(aiptek
->features
.usbPath
));
2038 strlcat(aiptek
->features
.usbPath
, "/input0",
2039 sizeof(aiptek
->features
.usbPath
));
2041 /* Set up client data, pointers to open and close routines
2042 * for the input device.
2044 inputdev
->name
= "Aiptek";
2045 inputdev
->phys
= aiptek
->features
.usbPath
;
2046 usb_to_input_id(usbdev
, &inputdev
->id
);
2047 inputdev
->dev
.parent
= &intf
->dev
;
2049 input_set_drvdata(inputdev
, aiptek
);
2051 inputdev
->open
= aiptek_open
;
2052 inputdev
->close
= aiptek_close
;
2054 /* Now program the capacities of the tablet, in terms of being
2057 inputdev
->evbit
[0] |= BIT(EV_KEY
)
2062 inputdev
->absbit
[0] |= BIT(ABS_MISC
);
2064 inputdev
->relbit
[0] |=
2065 (BIT(REL_X
) | BIT(REL_Y
) | BIT(REL_WHEEL
) | BIT(REL_MISC
));
2067 inputdev
->keybit
[LONG(BTN_LEFT
)] |=
2068 (BIT(BTN_LEFT
) | BIT(BTN_RIGHT
) | BIT(BTN_MIDDLE
));
2070 inputdev
->keybit
[LONG(BTN_DIGI
)] |=
2071 (BIT(BTN_TOOL_PEN
) |
2072 BIT(BTN_TOOL_RUBBER
) |
2073 BIT(BTN_TOOL_PENCIL
) |
2074 BIT(BTN_TOOL_AIRBRUSH
) |
2075 BIT(BTN_TOOL_BRUSH
) |
2076 BIT(BTN_TOOL_MOUSE
) |
2077 BIT(BTN_TOOL_LENS
) |
2078 BIT(BTN_TOUCH
) | BIT(BTN_STYLUS
) | BIT(BTN_STYLUS2
));
2080 inputdev
->mscbit
[0] = BIT(MSC_SERIAL
);
2082 /* Programming the tablet macro keys needs to be done with a for loop
2083 * as the keycodes are discontiguous.
2085 for (i
= 0; i
< ARRAY_SIZE(macroKeyEvents
); ++i
)
2086 set_bit(macroKeyEvents
[i
], inputdev
->keybit
);
2089 * Program the input device coordinate capacities. We do not yet
2090 * know what maximum X, Y, and Z values are, so we're putting fake
2091 * values in. Later, we'll ask the tablet to put in the correct
2094 input_set_abs_params(inputdev
, ABS_X
, 0, 2999, 0, 0);
2095 input_set_abs_params(inputdev
, ABS_Y
, 0, 2249, 0, 0);
2096 input_set_abs_params(inputdev
, ABS_PRESSURE
, 0, 511, 0, 0);
2097 input_set_abs_params(inputdev
, ABS_TILT_X
, AIPTEK_TILT_MIN
, AIPTEK_TILT_MAX
, 0, 0);
2098 input_set_abs_params(inputdev
, ABS_TILT_Y
, AIPTEK_TILT_MIN
, AIPTEK_TILT_MAX
, 0, 0);
2099 input_set_abs_params(inputdev
, ABS_WHEEL
, AIPTEK_WHEEL_MIN
, AIPTEK_WHEEL_MAX
- 1, 0, 0);
2101 endpoint
= &intf
->altsetting
[0].endpoint
[0].desc
;
2103 /* Go set up our URB, which is called when the tablet receives
2106 usb_fill_int_urb(aiptek
->urb
,
2108 usb_rcvintpipe(aiptek
->usbdev
,
2109 endpoint
->bEndpointAddress
),
2110 aiptek
->data
, 8, aiptek_irq
, aiptek
,
2111 endpoint
->bInterval
);
2113 aiptek
->urb
->transfer_dma
= aiptek
->data_dma
;
2114 aiptek
->urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
2116 /* Program the tablet. This sets the tablet up in the mode
2117 * specified in newSetting, and also queries the tablet's
2118 * physical capacities.
2120 * Sanity check: if a tablet doesn't like the slow programmatic
2121 * delay, we often get sizes of 0x0. Let's use that as an indicator
2122 * to try faster delays, up to 25 ms. If that logic fails, well, you'll
2123 * have to explain to us how your tablet thinks it's 0x0, and yet that's
2127 for (i
= 0; i
< ARRAY_SIZE(speeds
); ++i
) {
2128 aiptek
->curSetting
.programmableDelay
= speeds
[i
];
2129 (void)aiptek_program_tablet(aiptek
);
2130 if (aiptek
->inputdev
->absmax
[ABS_X
] > 0) {
2131 info("input: Aiptek using %d ms programming speed\n",
2132 aiptek
->curSetting
.programmableDelay
);
2137 /* Register the tablet as an Input Device
2139 err
= input_register_device(aiptek
->inputdev
);
2143 /* We now will look for the evdev device which is mapped to
2144 * the tablet. The partial name is kept in the link list of
2145 * input_handles associated with this input device.
2146 * What identifies an evdev input_handler is that it begins
2147 * with 'event', continues with a digit, and that in turn
2148 * is mapped to input/eventN.
2150 list_for_each_safe(node
, next
, &inputdev
->h_list
) {
2151 inputhandle
= to_handle(node
);
2152 if (strncmp(inputhandle
->name
, "event", 5) == 0) {
2153 strcpy(aiptek
->features
.inputPath
, inputhandle
->name
);
2158 /* Associate this driver's struct with the usb interface.
2160 usb_set_intfdata(intf
, aiptek
);
2162 /* Set up the sysfs files
2164 aiptek_add_files(&intf
->dev
);
2166 /* Make sure the evdev module is loaded. Assuming evdev IS a module :-)
2168 if (request_module("evdev") != 0)
2169 info("aiptek: error loading 'evdev' module");
2173 fail2
: usb_buffer_free(usbdev
, AIPTEK_PACKET_LENGTH
, aiptek
->data
,
2175 fail1
: input_free_device(inputdev
);
2180 /***********************************************************************
2181 * Deal with tablet disconnecting from the system.
2183 static void aiptek_disconnect(struct usb_interface
*intf
)
2185 struct aiptek
*aiptek
= usb_get_intfdata(intf
);
2187 /* Disassociate driver's struct with usb interface
2189 usb_set_intfdata(intf
, NULL
);
2190 if (aiptek
!= NULL
) {
2191 /* Free & unhook everything from the system.
2193 usb_kill_urb(aiptek
->urb
);
2194 input_unregister_device(aiptek
->inputdev
);
2195 aiptek_delete_files(&intf
->dev
);
2196 usb_free_urb(aiptek
->urb
);
2197 usb_buffer_free(interface_to_usbdev(intf
),
2198 AIPTEK_PACKET_LENGTH
,
2199 aiptek
->data
, aiptek
->data_dma
);
2204 static struct usb_driver aiptek_driver
= {
2206 .probe
= aiptek_probe
,
2207 .disconnect
= aiptek_disconnect
,
2208 .id_table
= aiptek_ids
,
2211 static int __init
aiptek_init(void)
2213 int result
= usb_register(&aiptek_driver
);
2215 info(DRIVER_VERSION
": " DRIVER_AUTHOR
);
2221 static void __exit
aiptek_exit(void)
2223 usb_deregister(&aiptek_driver
);
2226 MODULE_AUTHOR(DRIVER_AUTHOR
);
2227 MODULE_DESCRIPTION(DRIVER_DESC
);
2228 MODULE_LICENSE("GPL");
2230 module_param(programmableDelay
, int, 0);
2231 MODULE_PARM_DESC(programmableDelay
, "delay used during tablet programming");
2232 module_param(jitterDelay
, int, 0);
2233 MODULE_PARM_DESC(jitterDelay
, "stylus/mouse settlement delay");
2235 module_init(aiptek_init
);
2236 module_exit(aiptek_exit
);