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 <linux/sched.h>
80 #include <asm/uaccess.h>
81 #include <asm/unaligned.h>
86 #define DRIVER_VERSION "v1.5 (May-15-2004)"
87 #define DRIVER_AUTHOR "Bryan W. Headley/Chris Atenasio"
88 #define DRIVER_DESC "Aiptek HyperPen USB Tablet Driver (Linux 2.6.x)"
91 * Aiptek status packet:
93 * (returned as Report 1 - relative coordinates from mouse and stylus)
95 * bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0
96 * byte0 0 0 0 0 0 0 0 1
97 * byte1 0 0 0 0 0 BS2 BS Tip
98 * byte2 X7 X6 X5 X4 X3 X2 X1 X0
99 * byte3 Y7 Y6 Y5 Y4 Y3 Y2 Y1 Y0
101 * (returned as Report 2 - absolute coordinates from the stylus)
103 * bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0
104 * byte0 0 0 0 0 0 0 1 0
105 * byte1 X7 X6 X5 X4 X3 X2 X1 X0
106 * byte2 X15 X14 X13 X12 X11 X10 X9 X8
107 * byte3 Y7 Y6 Y5 Y4 Y3 Y2 Y1 Y0
108 * byte4 Y15 Y14 Y13 Y12 Y11 Y10 Y9 Y8
109 * byte5 * * * BS2 BS1 Tip IR DV
110 * byte6 P7 P6 P5 P4 P3 P2 P1 P0
111 * byte7 P15 P14 P13 P12 P11 P10 P9 P8
113 * (returned as Report 3 - absolute coordinates from the mouse)
115 * bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0
116 * byte0 0 0 0 0 0 0 1 0
117 * byte1 X7 X6 X5 X4 X3 X2 X1 X0
118 * byte2 X15 X14 X13 X12 X11 X10 X9 X8
119 * byte3 Y7 Y6 Y5 Y4 Y3 Y2 Y1 Y0
120 * byte4 Y15 Y14 Y13 Y12 Y11 Y10 Y9 Y8
121 * byte5 * * * BS2 BS1 Tip IR DV
122 * byte6 P7 P6 P5 P4 P3 P2 P1 P0
123 * byte7 P15 P14 P13 P12 P11 P10 P9 P8
125 * (returned as Report 4 - macrokeys from the stylus)
127 * bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0
128 * byte0 0 0 0 0 0 1 0 0
129 * byte1 0 0 0 BS2 BS Tip IR DV
130 * byte2 0 0 0 0 0 0 1 0
131 * byte3 0 0 0 K4 K3 K2 K1 K0
132 * byte4 P7 P6 P5 P4 P3 P2 P1 P0
133 * byte5 P15 P14 P13 P12 P11 P10 P9 P8
135 * (returned as Report 5 - macrokeys from the mouse)
137 * bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0
138 * byte0 0 0 0 0 0 1 0 0
139 * byte1 0 0 0 BS2 BS Tip IR DV
140 * byte2 0 0 0 0 0 0 1 0
141 * byte3 0 0 0 K4 K3 K2 K1 K0
142 * byte4 P7 P6 P5 P4 P3 P2 P1 P0
143 * byte5 P15 P14 P13 P12 P11 P10 P9 P8
145 * IR: In Range = Proximity on
147 * BS = Barrel Switch (as in, macro keys)
148 * BS2 also referred to as Tablet Pick
152 * Use report_type CONTROL (3)
155 * Command/Data Description Return Bytes Return Value
156 * 0x10/0x00 SwitchToMouse 0
157 * 0x10/0x01 SwitchToTablet 0
158 * 0x18/0x04 SetResolution 0
159 * 0x12/0xFF AutoGainOn 0
160 * 0x17/0x00 FilterOn 0
161 * 0x01/0x00 GetXExtension 2 MaxX
162 * 0x01/0x01 GetYExtension 2 MaxY
163 * 0x02/0x00 GetModelCode 2 ModelCode = LOBYTE
164 * 0x03/0x00 GetODMCode 2 ODMCode
165 * 0x08/0x00 GetPressureLevels 2 =512
166 * 0x04/0x00 GetFirmwareVersion 2 Firmware Version
167 * 0x11/0x02 EnableMacroKeys 0
169 * To initialize the tablet:
171 * (1) Send Resolution500LPI (Command)
172 * (2) Query for Model code (Option Report)
173 * (3) Query for ODM code (Option Report)
174 * (4) Query for firmware (Option Report)
175 * (5) Query for GetXExtension (Option Report)
176 * (6) Query for GetYExtension (Option Report)
177 * (7) Query for GetPressureLevels (Option Report)
178 * (8) SwitchToTablet for Absolute coordinates, or
179 * SwitchToMouse for Relative coordinates (Command)
180 * (9) EnableMacroKeys (Command)
181 * (10) FilterOn (Command)
182 * (11) AutoGainOn (Command)
184 * (Step 9 can be omitted, but you'll then have no function keys.)
187 #define USB_VENDOR_ID_AIPTEK 0x08ca
188 #define USB_REQ_GET_REPORT 0x01
189 #define USB_REQ_SET_REPORT 0x09
193 #define AIPTEK_POINTER_ONLY_MOUSE_MODE 0
194 #define AIPTEK_POINTER_ONLY_STYLUS_MODE 1
195 #define AIPTEK_POINTER_EITHER_MODE 2
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)
204 /* CoordinateMode code
206 #define AIPTEK_COORDINATE_RELATIVE_MODE 0
207 #define AIPTEK_COORDINATE_ABSOLUTE_MODE 1
209 /* XTilt and YTilt values
211 #define AIPTEK_TILT_MIN (-128)
212 #define AIPTEK_TILT_MAX 127
213 #define AIPTEK_TILT_DISABLE (-10101)
217 #define AIPTEK_WHEEL_MIN 0
218 #define AIPTEK_WHEEL_MAX 1024
219 #define AIPTEK_WHEEL_DISABLE (-10101)
221 /* ToolCode values, which BTW are 0x140 .. 0x14f
222 * We have things set up such that if TOOL_BUTTON_FIRED_BIT is
223 * not set, we'll send one instance of AIPTEK_TOOL_BUTTON_xxx.
225 * Whenever the user resets the value, TOOL_BUTTON_FIRED_BIT will
228 #define TOOL_BUTTON(x) ((x) & 0x14f)
229 #define TOOL_BUTTON_FIRED(x) ((x) & 0x200)
230 #define TOOL_BUTTON_FIRED_BIT 0x200
233 #define AIPTEK_TOOL_BUTTON_PEN_MODE BTN_TOOL_PEN
234 #define AIPTEK_TOOL_BUTTON_PEN_MODE BTN_TOOL_PEN
235 #define AIPTEK_TOOL_BUTTON_PENCIL_MODE BTN_TOOL_PENCIL
236 #define AIPTEK_TOOL_BUTTON_BRUSH_MODE BTN_TOOL_BRUSH
237 #define AIPTEK_TOOL_BUTTON_AIRBRUSH_MODE BTN_TOOL_AIRBRUSH
238 #define AIPTEK_TOOL_BUTTON_ERASER_MODE BTN_TOOL_RUBBER
239 #define AIPTEK_TOOL_BUTTON_MOUSE_MODE BTN_TOOL_MOUSE
240 #define AIPTEK_TOOL_BUTTON_LENS_MODE BTN_TOOL_LENS
242 /* Diagnostic message codes
244 #define AIPTEK_DIAGNOSTIC_NA 0
245 #define AIPTEK_DIAGNOSTIC_SENDING_RELATIVE_IN_ABSOLUTE 1
246 #define AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE 2
247 #define AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED 3
249 /* Time to wait (in ms) to help mask hand jittering
250 * when pressing the stylus buttons.
252 #define AIPTEK_JITTER_DELAY_DEFAULT 50
254 /* Time to wait (in ms) in-between sending the tablet
255 * a command and beginning the process of reading the return
256 * sequence from the tablet.
258 #define AIPTEK_PROGRAMMABLE_DELAY_25 25
259 #define AIPTEK_PROGRAMMABLE_DELAY_50 50
260 #define AIPTEK_PROGRAMMABLE_DELAY_100 100
261 #define AIPTEK_PROGRAMMABLE_DELAY_200 200
262 #define AIPTEK_PROGRAMMABLE_DELAY_300 300
263 #define AIPTEK_PROGRAMMABLE_DELAY_400 400
264 #define AIPTEK_PROGRAMMABLE_DELAY_DEFAULT AIPTEK_PROGRAMMABLE_DELAY_400
266 /* Mouse button programming
268 #define AIPTEK_MOUSE_LEFT_BUTTON 0x01
269 #define AIPTEK_MOUSE_RIGHT_BUTTON 0x02
270 #define AIPTEK_MOUSE_MIDDLE_BUTTON 0x04
272 /* Stylus button programming
274 #define AIPTEK_STYLUS_LOWER_BUTTON 0x08
275 #define AIPTEK_STYLUS_UPPER_BUTTON 0x10
277 /* Length of incoming packet from the tablet
279 #define AIPTEK_PACKET_LENGTH 8
281 /* We report in EV_MISC both the proximity and
282 * whether the report came from the stylus, tablet mouse
283 * or "unknown" -- Unknown when the tablet is in relative
284 * mode, because we only get report 1's.
286 #define AIPTEK_REPORT_TOOL_UNKNOWN 0x10
287 #define AIPTEK_REPORT_TOOL_STYLUS 0x20
288 #define AIPTEK_REPORT_TOOL_MOUSE 0x40
290 static int programmableDelay
= AIPTEK_PROGRAMMABLE_DELAY_DEFAULT
;
291 static int jitterDelay
= AIPTEK_JITTER_DELAY_DEFAULT
;
293 struct aiptek_features
{
294 int odmCode
; /* Tablet manufacturer code */
295 int modelCode
; /* Tablet model code (not unique) */
296 int firmwareCode
; /* prom/eeprom version */
297 char usbPath
[64 + 1]; /* device's physical usb path */
298 char inputPath
[64 + 1]; /* input device path */
301 struct aiptek_settings
{
302 int pointerMode
; /* stylus-, mouse-only or either */
303 int coordinateMode
; /* absolute/relative coords */
304 int toolMode
; /* pen, pencil, brush, etc. tool */
305 int xTilt
; /* synthetic xTilt amount */
306 int yTilt
; /* synthetic yTilt amount */
307 int wheel
; /* synthetic wheel amount */
308 int stylusButtonUpper
; /* stylus upper btn delivers... */
309 int stylusButtonLower
; /* stylus lower btn delivers... */
310 int mouseButtonLeft
; /* mouse left btn delivers... */
311 int mouseButtonMiddle
; /* mouse middle btn delivers... */
312 int mouseButtonRight
; /* mouse right btn delivers... */
313 int programmableDelay
; /* delay for tablet programming */
314 int jitterDelay
; /* delay for hand jittering */
318 struct input_dev
*inputdev
; /* input device struct */
319 struct usb_device
*usbdev
; /* usb device struct */
320 struct urb
*urb
; /* urb for incoming reports */
321 dma_addr_t data_dma
; /* our dma stuffage */
322 struct aiptek_features features
; /* tablet's array of features */
323 struct aiptek_settings curSetting
; /* tablet's current programmable */
324 struct aiptek_settings newSetting
; /* ... and new param settings */
325 unsigned int ifnum
; /* interface number for IO */
326 int diagnostic
; /* tablet diagnostic codes */
327 unsigned long eventCount
; /* event count */
328 int inDelay
; /* jitter: in jitter delay? */
329 unsigned long endDelay
; /* jitter: time when delay ends */
330 int previousJitterable
; /* jitterable prev value */
331 unsigned char *data
; /* incoming packet data */
335 * Permit easy lookup of keyboard events to send, versus
336 * the bitmap which comes from the tablet. This hides the
337 * issue that the F_keys are not sequentially numbered.
339 static const int macroKeyEvents
[] = {
340 KEY_ESC
, KEY_F1
, KEY_F2
, KEY_F3
, KEY_F4
, KEY_F5
,
341 KEY_F6
, KEY_F7
, KEY_F8
, KEY_F9
, KEY_F10
, KEY_F11
,
342 KEY_F12
, KEY_F13
, KEY_F14
, KEY_F15
, KEY_F16
, KEY_F17
,
343 KEY_F18
, KEY_F19
, KEY_F20
, KEY_F21
, KEY_F22
, KEY_F23
,
344 KEY_F24
, KEY_STOP
, KEY_AGAIN
, KEY_PROPS
, KEY_UNDO
,
345 KEY_FRONT
, KEY_COPY
, KEY_OPEN
, KEY_PASTE
, 0
348 /***********************************************************************
349 * Relative reports deliver values in 2's complement format to
350 * deal with negative offsets.
352 static int aiptek_convert_from_2s_complement(unsigned char c
)
358 if ((b
& 0x80) != 0) {
364 ret
= (negate
== 1) ? -ret
: ret
;
368 /***********************************************************************
369 * aiptek_irq can receive one of six potential reports.
370 * The documentation for each is in the body of the function.
372 * The tablet reports on several attributes per invocation of
373 * aiptek_irq. Because the Linux Input Event system allows the
374 * transmission of ONE attribute per input_report_xxx() call,
375 * collation has to be done on the other end to reconstitute
376 * a complete tablet report. Further, the number of Input Event reports
377 * submitted varies, depending on what USB report type, and circumstance.
378 * To deal with this, EV_MSC is used to indicate an 'end-of-report'
379 * message. This has been an undocumented convention understood by the kernel
380 * tablet driver and clients such as gpm and XFree86's tablet drivers.
382 * Of the information received from the tablet, the one piece I
383 * cannot transmit is the proximity bit (without resorting to an EV_MSC
384 * convention above.) I therefore have taken over REL_MISC and ABS_MISC
385 * (for relative and absolute reports, respectively) for communicating
386 * Proximity. Why two events? I thought it interesting to know if the
387 * Proximity event occurred while the tablet was in absolute or relative
390 * Other tablets use the notion of a certain minimum stylus pressure
391 * to infer proximity. While that could have been done, that is yet
392 * another 'by convention' behavior, the documentation for which
393 * would be spread between two (or more) pieces of software.
395 * EV_MSC usage was terminated for this purpose in Linux 2.5.x, and
396 * replaced with the input_sync() method (which emits EV_SYN.)
399 static void aiptek_irq(struct urb
*urb
, struct pt_regs
*regs
)
401 struct aiptek
*aiptek
= urb
->context
;
402 unsigned char *data
= aiptek
->data
;
403 struct input_dev
*inputdev
= aiptek
->inputdev
;
405 int retval
, macro
, x
, y
, z
, left
, right
, middle
, p
, dv
, tip
, bs
, pck
;
407 switch (urb
->status
) {
415 /* This urb is terminated, clean up */
416 dbg("%s - urb shutting down with status: %d",
417 __FUNCTION__
, urb
->status
);
421 dbg("%s - nonzero urb status received: %d",
422 __FUNCTION__
, urb
->status
);
426 /* See if we are in a delay loop -- throw out report if true.
428 if (aiptek
->inDelay
== 1 && time_after(aiptek
->endDelay
, jiffies
)) {
433 aiptek
->eventCount
++;
435 /* Report 1 delivers relative coordinates with either a stylus
436 * or the mouse. You do not know, however, which input
437 * tool generated the event.
440 if (aiptek
->curSetting
.coordinateMode
==
441 AIPTEK_COORDINATE_ABSOLUTE_MODE
) {
443 AIPTEK_DIAGNOSTIC_SENDING_RELATIVE_IN_ABSOLUTE
;
445 input_regs(inputdev
, regs
);
447 x
= aiptek_convert_from_2s_complement(data
[2]);
448 y
= aiptek_convert_from_2s_complement(data
[3]);
450 /* jitterable keeps track of whether any button has been pressed.
451 * We're also using it to remap the physical mouse button mask
452 * to pseudo-settings. (We don't specifically care about it's
453 * value after moving/transposing mouse button bitmasks, except
454 * that a non-zero value indicates that one or more
455 * mouse button was pressed.)
457 jitterable
= data
[5] & 0x07;
459 left
= (data
[5] & aiptek
->curSetting
.mouseButtonLeft
) != 0 ? 1 : 0;
460 right
= (data
[5] & aiptek
->curSetting
.mouseButtonRight
) != 0 ? 1 : 0;
461 middle
= (data
[5] & aiptek
->curSetting
.mouseButtonMiddle
) != 0 ? 1 : 0;
463 input_report_key(inputdev
, BTN_LEFT
, left
);
464 input_report_key(inputdev
, BTN_MIDDLE
, middle
);
465 input_report_key(inputdev
, BTN_RIGHT
, right
);
466 input_report_rel(inputdev
, REL_X
, x
);
467 input_report_rel(inputdev
, REL_Y
, y
);
468 input_report_rel(inputdev
, REL_MISC
, 1 | AIPTEK_REPORT_TOOL_UNKNOWN
);
470 /* Wheel support is in the form of a single-event
473 if (aiptek
->curSetting
.wheel
!= AIPTEK_WHEEL_DISABLE
) {
474 input_report_rel(inputdev
, REL_WHEEL
,
475 aiptek
->curSetting
.wheel
);
476 aiptek
->curSetting
.wheel
= AIPTEK_WHEEL_DISABLE
;
478 input_sync(inputdev
);
481 /* Report 2 is delivered only by the stylus, and delivers
482 * absolute coordinates.
484 else if (data
[0] == 2) {
485 if (aiptek
->curSetting
.coordinateMode
== AIPTEK_COORDINATE_RELATIVE_MODE
) {
486 aiptek
->diagnostic
= AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE
;
487 } else if (!AIPTEK_POINTER_ALLOW_STYLUS_MODE
488 (aiptek
->curSetting
.pointerMode
)) {
489 aiptek
->diagnostic
= AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED
;
491 input_regs(inputdev
, regs
);
493 x
= le16_to_cpu(get_unaligned((__le16
*) (data
+ 1)));
494 y
= le16_to_cpu(get_unaligned((__le16
*) (data
+ 3)));
495 z
= le16_to_cpu(get_unaligned((__le16
*) (data
+ 6)));
497 p
= (data
[5] & 0x01) != 0 ? 1 : 0;
498 dv
= (data
[5] & 0x02) != 0 ? 1 : 0;
499 tip
= (data
[5] & 0x04) != 0 ? 1 : 0;
501 /* Use jitterable to re-arrange button masks
503 jitterable
= data
[5] & 0x18;
505 bs
= (data
[5] & aiptek
->curSetting
.stylusButtonLower
) != 0 ? 1 : 0;
506 pck
= (data
[5] & aiptek
->curSetting
.stylusButtonUpper
) != 0 ? 1 : 0;
508 /* dv indicates 'data valid' (e.g., the tablet is in sync
509 * and has delivered a "correct" report) We will ignore
510 * all 'bad' reports...
513 /* If we've not already sent a tool_button_?? code, do
514 * so now. Then set FIRED_BIT so it won't be resent unless
515 * the user forces FIRED_BIT off.
517 if (TOOL_BUTTON_FIRED
518 (aiptek
->curSetting
.toolMode
) == 0) {
519 input_report_key(inputdev
,
520 TOOL_BUTTON(aiptek
->curSetting
.toolMode
),
522 aiptek
->curSetting
.toolMode
|= TOOL_BUTTON_FIRED_BIT
;
526 input_report_abs(inputdev
, ABS_X
, x
);
527 input_report_abs(inputdev
, ABS_Y
, y
);
528 input_report_abs(inputdev
, ABS_PRESSURE
, z
);
530 input_report_key(inputdev
, BTN_TOUCH
, tip
);
531 input_report_key(inputdev
, BTN_STYLUS
, bs
);
532 input_report_key(inputdev
, BTN_STYLUS2
, pck
);
534 if (aiptek
->curSetting
.xTilt
!=
535 AIPTEK_TILT_DISABLE
) {
536 input_report_abs(inputdev
,
538 aiptek
->curSetting
.xTilt
);
540 if (aiptek
->curSetting
.yTilt
!= AIPTEK_TILT_DISABLE
) {
541 input_report_abs(inputdev
,
543 aiptek
->curSetting
.yTilt
);
546 /* Wheel support is in the form of a single-event
549 if (aiptek
->curSetting
.wheel
!=
550 AIPTEK_WHEEL_DISABLE
) {
551 input_report_abs(inputdev
,
553 aiptek
->curSetting
.wheel
);
554 aiptek
->curSetting
.wheel
= AIPTEK_WHEEL_DISABLE
;
557 input_report_abs(inputdev
, ABS_MISC
, p
| AIPTEK_REPORT_TOOL_STYLUS
);
558 input_sync(inputdev
);
562 /* Report 3's come from the mouse in absolute mode.
564 else if (data
[0] == 3) {
565 if (aiptek
->curSetting
.coordinateMode
== AIPTEK_COORDINATE_RELATIVE_MODE
) {
566 aiptek
->diagnostic
= AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE
;
567 } else if (!AIPTEK_POINTER_ALLOW_MOUSE_MODE
568 (aiptek
->curSetting
.pointerMode
)) {
569 aiptek
->diagnostic
= AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED
;
571 input_regs(inputdev
, regs
);
572 x
= le16_to_cpu(get_unaligned((__le16
*) (data
+ 1)));
573 y
= le16_to_cpu(get_unaligned((__le16
*) (data
+ 3)));
575 jitterable
= data
[5] & 0x1c;
577 p
= (data
[5] & 0x01) != 0 ? 1 : 0;
578 dv
= (data
[5] & 0x02) != 0 ? 1 : 0;
579 left
= (data
[5] & aiptek
->curSetting
.mouseButtonLeft
) != 0 ? 1 : 0;
580 right
= (data
[5] & aiptek
->curSetting
.mouseButtonRight
) != 0 ? 1 : 0;
581 middle
= (data
[5] & aiptek
->curSetting
.mouseButtonMiddle
) != 0 ? 1 : 0;
584 /* If we've not already sent a tool_button_?? code, do
585 * so now. Then set FIRED_BIT so it won't be resent unless
586 * the user forces FIRED_BIT off.
588 if (TOOL_BUTTON_FIRED
589 (aiptek
->curSetting
.toolMode
) == 0) {
590 input_report_key(inputdev
,
591 TOOL_BUTTON(aiptek
->curSetting
.toolMode
),
593 aiptek
->curSetting
.toolMode
|= TOOL_BUTTON_FIRED_BIT
;
597 input_report_abs(inputdev
, ABS_X
, x
);
598 input_report_abs(inputdev
, ABS_Y
, y
);
600 input_report_key(inputdev
, BTN_LEFT
, left
);
601 input_report_key(inputdev
, BTN_MIDDLE
, middle
);
602 input_report_key(inputdev
, BTN_RIGHT
, right
);
604 /* Wheel support is in the form of a single-event
607 if (aiptek
->curSetting
.wheel
!= AIPTEK_WHEEL_DISABLE
) {
608 input_report_abs(inputdev
,
610 aiptek
->curSetting
.wheel
);
611 aiptek
->curSetting
.wheel
= AIPTEK_WHEEL_DISABLE
;
614 input_report_rel(inputdev
, REL_MISC
, p
| AIPTEK_REPORT_TOOL_MOUSE
);
615 input_sync(inputdev
);
619 /* Report 4s come from the macro keys when pressed by stylus
621 else if (data
[0] == 4) {
622 jitterable
= data
[1] & 0x18;
624 p
= (data
[1] & 0x01) != 0 ? 1 : 0;
625 dv
= (data
[1] & 0x02) != 0 ? 1 : 0;
626 tip
= (data
[1] & 0x04) != 0 ? 1 : 0;
627 bs
= (data
[1] & aiptek
->curSetting
.stylusButtonLower
) != 0 ? 1 : 0;
628 pck
= (data
[1] & aiptek
->curSetting
.stylusButtonUpper
) != 0 ? 1 : 0;
631 z
= le16_to_cpu(get_unaligned((__le16
*) (data
+ 4)));
634 input_regs(inputdev
, regs
);
636 /* If we've not already sent a tool_button_?? code, do
637 * so now. Then set FIRED_BIT so it won't be resent unless
638 * the user forces FIRED_BIT off.
640 if (TOOL_BUTTON_FIRED(aiptek
->curSetting
.toolMode
) == 0) {
641 input_report_key(inputdev
,
642 TOOL_BUTTON(aiptek
->curSetting
.toolMode
),
644 aiptek
->curSetting
.toolMode
|= TOOL_BUTTON_FIRED_BIT
;
648 input_report_key(inputdev
, BTN_TOUCH
, tip
);
649 input_report_key(inputdev
, BTN_STYLUS
, bs
);
650 input_report_key(inputdev
, BTN_STYLUS2
, pck
);
651 input_report_abs(inputdev
, ABS_PRESSURE
, z
);
654 /* For safety, we're sending key 'break' codes for the
655 * neighboring macro keys.
658 input_report_key(inputdev
,
659 macroKeyEvents
[macro
- 1], 0);
662 input_report_key(inputdev
,
663 macroKeyEvents
[macro
+ 1], 0);
665 input_report_key(inputdev
, macroKeyEvents
[macro
], p
);
666 input_report_abs(inputdev
, ABS_MISC
,
667 p
| AIPTEK_REPORT_TOOL_STYLUS
);
668 input_sync(inputdev
);
671 /* Report 5s come from the macro keys when pressed by mouse
673 else if (data
[0] == 5) {
674 jitterable
= data
[1] & 0x1c;
676 p
= (data
[1] & 0x01) != 0 ? 1 : 0;
677 dv
= (data
[1] & 0x02) != 0 ? 1 : 0;
678 left
= (data
[1]& aiptek
->curSetting
.mouseButtonLeft
) != 0 ? 1 : 0;
679 right
= (data
[1] & aiptek
->curSetting
.mouseButtonRight
) != 0 ? 1 : 0;
680 middle
= (data
[1] & aiptek
->curSetting
.mouseButtonMiddle
) != 0 ? 1 : 0;
684 input_regs(inputdev
, regs
);
686 /* If we've not already sent a tool_button_?? code, do
687 * so now. Then set FIRED_BIT so it won't be resent unless
688 * the user forces FIRED_BIT off.
690 if (TOOL_BUTTON_FIRED(aiptek
->curSetting
.toolMode
) == 0) {
691 input_report_key(inputdev
,
692 TOOL_BUTTON(aiptek
->curSetting
.toolMode
),
694 aiptek
->curSetting
.toolMode
|= TOOL_BUTTON_FIRED_BIT
;
698 input_report_key(inputdev
, BTN_LEFT
, left
);
699 input_report_key(inputdev
, BTN_MIDDLE
, middle
);
700 input_report_key(inputdev
, BTN_RIGHT
, right
);
703 /* For safety, we're sending key 'break' codes for the
704 * neighboring macro keys.
707 input_report_key(inputdev
,
708 macroKeyEvents
[macro
- 1], 0);
711 input_report_key(inputdev
,
712 macroKeyEvents
[macro
+ 1], 0);
715 input_report_key(inputdev
, macroKeyEvents
[macro
], 1);
716 input_report_rel(inputdev
, ABS_MISC
,
717 p
| AIPTEK_REPORT_TOOL_MOUSE
);
718 input_sync(inputdev
);
721 /* We have no idea which tool can generate a report 6. Theoretically,
722 * neither need to, having been given reports 4 & 5 for such use.
723 * However, report 6 is the 'official-looking' report for macroKeys;
724 * reports 4 & 5 supposively are used to support unnamed, unknown
725 * hat switches (which just so happen to be the macroKeys.)
727 else if (data
[0] == 6) {
728 macro
= le16_to_cpu(get_unaligned((__le16
*) (data
+ 1)));
729 input_regs(inputdev
, regs
);
732 input_report_key(inputdev
, macroKeyEvents
[macro
- 1],
736 input_report_key(inputdev
, macroKeyEvents
[macro
+ 1],
740 /* If we've not already sent a tool_button_?? code, do
741 * so now. Then set FIRED_BIT so it won't be resent unless
742 * the user forces FIRED_BIT off.
744 if (TOOL_BUTTON_FIRED(aiptek
->curSetting
.toolMode
) == 0) {
745 input_report_key(inputdev
,
746 TOOL_BUTTON(aiptek
->curSetting
.
748 aiptek
->curSetting
.toolMode
|= TOOL_BUTTON_FIRED_BIT
;
751 input_report_key(inputdev
, macroKeyEvents
[macro
], 1);
752 input_report_abs(inputdev
, ABS_MISC
,
753 1 | AIPTEK_REPORT_TOOL_UNKNOWN
);
754 input_sync(inputdev
);
756 dbg("Unknown report %d", data
[0]);
759 /* Jitter may occur when the user presses a button on the stlyus
760 * or the mouse. What we do to prevent that is wait 'x' milliseconds
761 * following a 'jitterable' event, which should give the hand some time
764 * We just introduced aiptek->previousJitterable to carry forth the
765 * notion that jitter occurs when the button state changes from on to off:
766 * a person drawing, holding a button down is not subject to jittering.
767 * With that in mind, changing from upper button depressed to lower button
768 * WILL transition through a jitter delay.
771 if (aiptek
->previousJitterable
!= jitterable
&&
772 aiptek
->curSetting
.jitterDelay
!= 0 && aiptek
->inDelay
!= 1) {
773 aiptek
->endDelay
= jiffies
+
774 ((aiptek
->curSetting
.jitterDelay
* HZ
) / 1000);
777 aiptek
->previousJitterable
= jitterable
;
780 retval
= usb_submit_urb(urb
, GFP_ATOMIC
);
782 err("%s - usb_submit_urb failed with result %d",
783 __FUNCTION__
, retval
);
787 /***********************************************************************
788 * These are the USB id's known so far. We do not identify them to
789 * specific Aiptek model numbers, because there has been overlaps,
790 * use, and reuse of id's in existing models. Certain models have
791 * been known to use more than one ID, indicative perhaps of
792 * manufacturing revisions. In any event, we consider these
793 * IDs to not be model-specific nor unique.
795 static const struct usb_device_id aiptek_ids
[] = {
796 {USB_DEVICE(USB_VENDOR_ID_AIPTEK
, 0x01)},
797 {USB_DEVICE(USB_VENDOR_ID_AIPTEK
, 0x10)},
798 {USB_DEVICE(USB_VENDOR_ID_AIPTEK
, 0x20)},
799 {USB_DEVICE(USB_VENDOR_ID_AIPTEK
, 0x21)},
800 {USB_DEVICE(USB_VENDOR_ID_AIPTEK
, 0x22)},
801 {USB_DEVICE(USB_VENDOR_ID_AIPTEK
, 0x23)},
802 {USB_DEVICE(USB_VENDOR_ID_AIPTEK
, 0x24)},
806 MODULE_DEVICE_TABLE(usb
, aiptek_ids
);
808 /***********************************************************************
809 * Open an instance of the tablet driver.
811 static int aiptek_open(struct input_dev
*inputdev
)
813 struct aiptek
*aiptek
= inputdev
->private;
815 aiptek
->urb
->dev
= aiptek
->usbdev
;
816 if (usb_submit_urb(aiptek
->urb
, GFP_KERNEL
) != 0)
822 /***********************************************************************
823 * Close an instance of the tablet driver.
825 static void aiptek_close(struct input_dev
*inputdev
)
827 struct aiptek
*aiptek
= inputdev
->private;
829 usb_kill_urb(aiptek
->urb
);
832 /***********************************************************************
833 * aiptek_set_report and aiptek_get_report() are borrowed from Linux 2.4.x,
834 * where they were known as usb_set_report and usb_get_report.
837 aiptek_set_report(struct aiptek
*aiptek
,
838 unsigned char report_type
,
839 unsigned char report_id
, void *buffer
, int size
)
841 return usb_control_msg(aiptek
->usbdev
,
842 usb_sndctrlpipe(aiptek
->usbdev
, 0),
844 USB_TYPE_CLASS
| USB_RECIP_INTERFACE
|
845 USB_DIR_OUT
, (report_type
<< 8) + report_id
,
846 aiptek
->ifnum
, buffer
, size
, 5000);
850 aiptek_get_report(struct aiptek
*aiptek
,
851 unsigned char report_type
,
852 unsigned char report_id
, void *buffer
, int size
)
854 return usb_control_msg(aiptek
->usbdev
,
855 usb_rcvctrlpipe(aiptek
->usbdev
, 0),
857 USB_TYPE_CLASS
| USB_RECIP_INTERFACE
|
858 USB_DIR_IN
, (report_type
<< 8) + report_id
,
859 aiptek
->ifnum
, buffer
, size
, 5000);
862 /***********************************************************************
863 * Send a command to the tablet.
866 aiptek_command(struct aiptek
*aiptek
, unsigned char command
, unsigned char data
)
868 const int sizeof_buf
= 3 * sizeof(u8
);
872 buf
= kmalloc(sizeof_buf
, GFP_KERNEL
);
881 aiptek_set_report(aiptek
, 3, 2, buf
, sizeof_buf
)) != sizeof_buf
) {
882 dbg("aiptek_program: failed, tried to send: 0x%02x 0x%02x",
886 return ret
< 0 ? ret
: 0;
889 /***********************************************************************
890 * Retrieve information from the tablet. Querying info is defined as first
891 * sending the {command,data} sequence as a command, followed by a wait
892 * (aka, "programmaticDelay") and then a "read" request.
895 aiptek_query(struct aiptek
*aiptek
, unsigned char command
, unsigned char data
)
897 const int sizeof_buf
= 3 * sizeof(u8
);
901 buf
= kmalloc(sizeof_buf
, GFP_KERNEL
);
909 if (aiptek_command(aiptek
, command
, data
) != 0) {
913 msleep(aiptek
->curSetting
.programmableDelay
);
916 aiptek_get_report(aiptek
, 3, 2, buf
, sizeof_buf
)) != sizeof_buf
) {
917 dbg("aiptek_query failed: returned 0x%02x 0x%02x 0x%02x",
918 buf
[0], buf
[1], buf
[2]);
921 ret
= le16_to_cpu(get_unaligned((__le16
*) (buf
+ 1)));
927 /***********************************************************************
928 * Program the tablet into either absolute or relative mode.
929 * We also get information about the tablet's size.
931 static int aiptek_program_tablet(struct aiptek
*aiptek
)
934 /* Execute Resolution500LPI */
935 if ((ret
= aiptek_command(aiptek
, 0x18, 0x04)) < 0)
938 /* Query getModelCode */
939 if ((ret
= aiptek_query(aiptek
, 0x02, 0x00)) < 0)
941 aiptek
->features
.modelCode
= ret
& 0xff;
943 /* Query getODMCode */
944 if ((ret
= aiptek_query(aiptek
, 0x03, 0x00)) < 0)
946 aiptek
->features
.odmCode
= ret
;
948 /* Query getFirmwareCode */
949 if ((ret
= aiptek_query(aiptek
, 0x04, 0x00)) < 0)
951 aiptek
->features
.firmwareCode
= ret
;
953 /* Query getXextension */
954 if ((ret
= aiptek_query(aiptek
, 0x01, 0x00)) < 0)
956 aiptek
->inputdev
->absmin
[ABS_X
] = 0;
957 aiptek
->inputdev
->absmax
[ABS_X
] = ret
- 1;
959 /* Query getYextension */
960 if ((ret
= aiptek_query(aiptek
, 0x01, 0x01)) < 0)
962 aiptek
->inputdev
->absmin
[ABS_Y
] = 0;
963 aiptek
->inputdev
->absmax
[ABS_Y
] = ret
- 1;
965 /* Query getPressureLevels */
966 if ((ret
= aiptek_query(aiptek
, 0x08, 0x00)) < 0)
968 aiptek
->inputdev
->absmin
[ABS_PRESSURE
] = 0;
969 aiptek
->inputdev
->absmax
[ABS_PRESSURE
] = ret
- 1;
971 /* Depending on whether we are in absolute or relative mode, we will
972 * do a switchToTablet(absolute) or switchToMouse(relative) command.
974 if (aiptek
->curSetting
.coordinateMode
==
975 AIPTEK_COORDINATE_ABSOLUTE_MODE
) {
976 /* Execute switchToTablet */
977 if ((ret
= aiptek_command(aiptek
, 0x10, 0x01)) < 0) {
981 /* Execute switchToMouse */
982 if ((ret
= aiptek_command(aiptek
, 0x10, 0x00)) < 0) {
987 /* Enable the macro keys */
988 if ((ret
= aiptek_command(aiptek
, 0x11, 0x02)) < 0)
991 /* Execute FilterOn */
992 if ((ret
= aiptek_command(aiptek
, 0x17, 0x00)) < 0)
996 /* Execute AutoGainOn */
997 if ((ret
= aiptek_command(aiptek
, 0x12, 0xff)) < 0)
1000 /* Reset the eventCount, so we track events from last (re)programming
1002 aiptek
->diagnostic
= AIPTEK_DIAGNOSTIC_NA
;
1003 aiptek
->eventCount
= 0;
1008 /***********************************************************************
1009 * Sysfs functions. Sysfs prefers that individually-tunable parameters
1010 * exist in their separate pseudo-files. Summary data that is immutable
1011 * may exist in a singular file so long as you don't define a writeable
1015 /***********************************************************************
1016 * support the 'size' file -- display support
1018 static ssize_t
show_tabletSize(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1020 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1025 return snprintf(buf
, PAGE_SIZE
, "%dx%d\n",
1026 aiptek
->inputdev
->absmax
[ABS_X
] + 1,
1027 aiptek
->inputdev
->absmax
[ABS_Y
] + 1);
1030 /* These structs define the sysfs files, param #1 is the name of the
1031 * file, param 2 is the file permissions, param 3 & 4 are to the
1032 * output generator and input parser routines. Absence of a routine is
1033 * permitted -- it only means can't either 'cat' the file, or send data
1036 static DEVICE_ATTR(size
, S_IRUGO
, show_tabletSize
, NULL
);
1038 /***********************************************************************
1039 * support routines for the 'product_id' file
1041 static ssize_t
show_tabletProductId(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1043 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1048 return snprintf(buf
, PAGE_SIZE
, "0x%04x\n",
1049 aiptek
->inputdev
->id
.product
);
1052 static DEVICE_ATTR(product_id
, S_IRUGO
, show_tabletProductId
, NULL
);
1054 /***********************************************************************
1055 * support routines for the 'vendor_id' file
1057 static ssize_t
show_tabletVendorId(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1059 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1064 return snprintf(buf
, PAGE_SIZE
, "0x%04x\n", aiptek
->inputdev
->id
.vendor
);
1067 static DEVICE_ATTR(vendor_id
, S_IRUGO
, show_tabletVendorId
, NULL
);
1069 /***********************************************************************
1070 * support routines for the 'vendor' file
1072 static ssize_t
show_tabletManufacturer(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1074 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1080 retval
= snprintf(buf
, PAGE_SIZE
, "%s\n", aiptek
->usbdev
->manufacturer
);
1084 static DEVICE_ATTR(vendor
, S_IRUGO
, show_tabletManufacturer
, NULL
);
1086 /***********************************************************************
1087 * support routines for the 'product' file
1089 static ssize_t
show_tabletProduct(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1091 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1097 retval
= snprintf(buf
, PAGE_SIZE
, "%s\n", aiptek
->usbdev
->product
);
1101 static DEVICE_ATTR(product
, S_IRUGO
, show_tabletProduct
, NULL
);
1103 /***********************************************************************
1104 * support routines for the 'pointer_mode' file. Note that this file
1105 * both displays current setting and allows reprogramming.
1107 static ssize_t
show_tabletPointerMode(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1109 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1115 switch (aiptek
->curSetting
.pointerMode
) {
1116 case AIPTEK_POINTER_ONLY_STYLUS_MODE
:
1120 case AIPTEK_POINTER_ONLY_MOUSE_MODE
:
1124 case AIPTEK_POINTER_EITHER_MODE
:
1132 return snprintf(buf
, PAGE_SIZE
, "%s\n", s
);
1136 store_tabletPointerMode(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1138 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1142 if (strcmp(buf
, "stylus") == 0) {
1143 aiptek
->newSetting
.pointerMode
=
1144 AIPTEK_POINTER_ONLY_STYLUS_MODE
;
1145 } else if (strcmp(buf
, "mouse") == 0) {
1146 aiptek
->newSetting
.pointerMode
= AIPTEK_POINTER_ONLY_MOUSE_MODE
;
1147 } else if (strcmp(buf
, "either") == 0) {
1148 aiptek
->newSetting
.pointerMode
= AIPTEK_POINTER_EITHER_MODE
;
1153 static DEVICE_ATTR(pointer_mode
,
1155 show_tabletPointerMode
, store_tabletPointerMode
);
1157 /***********************************************************************
1158 * support routines for the 'coordinate_mode' file. Note that this file
1159 * both displays current setting and allows reprogramming.
1161 static ssize_t
show_tabletCoordinateMode(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1163 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1169 switch (aiptek
->curSetting
.coordinateMode
) {
1170 case AIPTEK_COORDINATE_ABSOLUTE_MODE
:
1174 case AIPTEK_COORDINATE_RELATIVE_MODE
:
1182 return snprintf(buf
, PAGE_SIZE
, "%s\n", s
);
1186 store_tabletCoordinateMode(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1188 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1192 if (strcmp(buf
, "absolute") == 0) {
1193 aiptek
->newSetting
.pointerMode
=
1194 AIPTEK_COORDINATE_ABSOLUTE_MODE
;
1195 } else if (strcmp(buf
, "relative") == 0) {
1196 aiptek
->newSetting
.pointerMode
=
1197 AIPTEK_COORDINATE_RELATIVE_MODE
;
1202 static DEVICE_ATTR(coordinate_mode
,
1204 show_tabletCoordinateMode
, store_tabletCoordinateMode
);
1206 /***********************************************************************
1207 * support routines for the 'tool_mode' file. Note that this file
1208 * both displays current setting and allows reprogramming.
1210 static ssize_t
show_tabletToolMode(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1212 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1218 switch (TOOL_BUTTON(aiptek
->curSetting
.toolMode
)) {
1219 case AIPTEK_TOOL_BUTTON_MOUSE_MODE
:
1223 case AIPTEK_TOOL_BUTTON_ERASER_MODE
:
1227 case AIPTEK_TOOL_BUTTON_PENCIL_MODE
:
1231 case AIPTEK_TOOL_BUTTON_PEN_MODE
:
1235 case AIPTEK_TOOL_BUTTON_BRUSH_MODE
:
1239 case AIPTEK_TOOL_BUTTON_AIRBRUSH_MODE
:
1243 case AIPTEK_TOOL_BUTTON_LENS_MODE
:
1251 return snprintf(buf
, PAGE_SIZE
, "%s\n", s
);
1255 store_tabletToolMode(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1257 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1261 if (strcmp(buf
, "mouse") == 0) {
1262 aiptek
->newSetting
.toolMode
= AIPTEK_TOOL_BUTTON_MOUSE_MODE
;
1263 } else if (strcmp(buf
, "eraser") == 0) {
1264 aiptek
->newSetting
.toolMode
= AIPTEK_TOOL_BUTTON_ERASER_MODE
;
1265 } else if (strcmp(buf
, "pencil") == 0) {
1266 aiptek
->newSetting
.toolMode
= AIPTEK_TOOL_BUTTON_PENCIL_MODE
;
1267 } else if (strcmp(buf
, "pen") == 0) {
1268 aiptek
->newSetting
.toolMode
= AIPTEK_TOOL_BUTTON_PEN_MODE
;
1269 } else if (strcmp(buf
, "brush") == 0) {
1270 aiptek
->newSetting
.toolMode
= AIPTEK_TOOL_BUTTON_BRUSH_MODE
;
1271 } else if (strcmp(buf
, "airbrush") == 0) {
1272 aiptek
->newSetting
.toolMode
= AIPTEK_TOOL_BUTTON_AIRBRUSH_MODE
;
1273 } else if (strcmp(buf
, "lens") == 0) {
1274 aiptek
->newSetting
.toolMode
= AIPTEK_TOOL_BUTTON_LENS_MODE
;
1280 static DEVICE_ATTR(tool_mode
,
1282 show_tabletToolMode
, store_tabletToolMode
);
1284 /***********************************************************************
1285 * support routines for the 'xtilt' file. Note that this file
1286 * both displays current setting and allows reprogramming.
1288 static ssize_t
show_tabletXtilt(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1290 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1295 if (aiptek
->curSetting
.xTilt
== AIPTEK_TILT_DISABLE
) {
1296 return snprintf(buf
, PAGE_SIZE
, "disable\n");
1298 return snprintf(buf
, PAGE_SIZE
, "%d\n",
1299 aiptek
->curSetting
.xTilt
);
1304 store_tabletXtilt(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1306 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1312 if (strcmp(buf
, "disable") == 0) {
1313 aiptek
->newSetting
.xTilt
= AIPTEK_TILT_DISABLE
;
1315 x
= (int)simple_strtol(buf
, NULL
, 10);
1316 if (x
>= AIPTEK_TILT_MIN
&& x
<= AIPTEK_TILT_MAX
) {
1317 aiptek
->newSetting
.xTilt
= x
;
1323 static DEVICE_ATTR(xtilt
,
1324 S_IRUGO
| S_IWUGO
, show_tabletXtilt
, store_tabletXtilt
);
1326 /***********************************************************************
1327 * support routines for the 'ytilt' file. Note that this file
1328 * both displays current setting and allows reprogramming.
1330 static ssize_t
show_tabletYtilt(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1332 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1337 if (aiptek
->curSetting
.yTilt
== AIPTEK_TILT_DISABLE
) {
1338 return snprintf(buf
, PAGE_SIZE
, "disable\n");
1340 return snprintf(buf
, PAGE_SIZE
, "%d\n",
1341 aiptek
->curSetting
.yTilt
);
1346 store_tabletYtilt(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1348 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1354 if (strcmp(buf
, "disable") == 0) {
1355 aiptek
->newSetting
.yTilt
= AIPTEK_TILT_DISABLE
;
1357 y
= (int)simple_strtol(buf
, NULL
, 10);
1358 if (y
>= AIPTEK_TILT_MIN
&& y
<= AIPTEK_TILT_MAX
) {
1359 aiptek
->newSetting
.yTilt
= y
;
1365 static DEVICE_ATTR(ytilt
,
1366 S_IRUGO
| S_IWUGO
, show_tabletYtilt
, store_tabletYtilt
);
1368 /***********************************************************************
1369 * support routines for the 'jitter' file. Note that this file
1370 * both displays current setting and allows reprogramming.
1372 static ssize_t
show_tabletJitterDelay(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1374 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1379 return snprintf(buf
, PAGE_SIZE
, "%d\n", aiptek
->curSetting
.jitterDelay
);
1383 store_tabletJitterDelay(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1385 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1390 aiptek
->newSetting
.jitterDelay
= (int)simple_strtol(buf
, NULL
, 10);
1394 static DEVICE_ATTR(jitter
,
1396 show_tabletJitterDelay
, store_tabletJitterDelay
);
1398 /***********************************************************************
1399 * support routines for the 'delay' file. Note that this file
1400 * both displays current setting and allows reprogramming.
1402 static ssize_t
show_tabletProgrammableDelay(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1404 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1409 return snprintf(buf
, PAGE_SIZE
, "%d\n",
1410 aiptek
->curSetting
.programmableDelay
);
1414 store_tabletProgrammableDelay(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1416 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1421 aiptek
->newSetting
.programmableDelay
= (int)simple_strtol(buf
, NULL
, 10);
1425 static DEVICE_ATTR(delay
,
1427 show_tabletProgrammableDelay
, store_tabletProgrammableDelay
);
1429 /***********************************************************************
1430 * support routines for the 'input_path' file. Note that this file
1431 * only displays current setting.
1433 static ssize_t
show_tabletInputDevice(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1435 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1440 return snprintf(buf
, PAGE_SIZE
, "/dev/input/%s\n",
1441 aiptek
->features
.inputPath
);
1444 static DEVICE_ATTR(input_path
, S_IRUGO
, show_tabletInputDevice
, NULL
);
1446 /***********************************************************************
1447 * support routines for the 'event_count' file. Note that this file
1448 * only displays current setting.
1450 static ssize_t
show_tabletEventsReceived(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1452 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1457 return snprintf(buf
, PAGE_SIZE
, "%ld\n", aiptek
->eventCount
);
1460 static DEVICE_ATTR(event_count
, S_IRUGO
, show_tabletEventsReceived
, NULL
);
1462 /***********************************************************************
1463 * support routines for the 'diagnostic' file. Note that this file
1464 * only displays current setting.
1466 static ssize_t
show_tabletDiagnosticMessage(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1468 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1474 switch (aiptek
->diagnostic
) {
1475 case AIPTEK_DIAGNOSTIC_NA
:
1476 retMsg
= "no errors\n";
1479 case AIPTEK_DIAGNOSTIC_SENDING_RELATIVE_IN_ABSOLUTE
:
1480 retMsg
= "Error: receiving relative reports\n";
1483 case AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE
:
1484 retMsg
= "Error: receiving absolute reports\n";
1487 case AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED
:
1488 if (aiptek
->curSetting
.pointerMode
==
1489 AIPTEK_POINTER_ONLY_MOUSE_MODE
) {
1490 retMsg
= "Error: receiving stylus reports\n";
1492 retMsg
= "Error: receiving mouse reports\n";
1499 return snprintf(buf
, PAGE_SIZE
, retMsg
);
1502 static DEVICE_ATTR(diagnostic
, S_IRUGO
, show_tabletDiagnosticMessage
, NULL
);
1504 /***********************************************************************
1505 * support routines for the 'stylus_upper' file. Note that this file
1506 * both displays current setting and allows for setting changing.
1508 static ssize_t
show_tabletStylusUpper(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1510 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1516 switch (aiptek
->curSetting
.stylusButtonUpper
) {
1517 case AIPTEK_STYLUS_UPPER_BUTTON
:
1521 case AIPTEK_STYLUS_LOWER_BUTTON
:
1529 return snprintf(buf
, PAGE_SIZE
, "%s\n", s
);
1533 store_tabletStylusUpper(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1535 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1540 if (strcmp(buf
, "upper") == 0) {
1541 aiptek
->newSetting
.stylusButtonUpper
=
1542 AIPTEK_STYLUS_UPPER_BUTTON
;
1543 } else if (strcmp(buf
, "lower") == 0) {
1544 aiptek
->newSetting
.stylusButtonUpper
=
1545 AIPTEK_STYLUS_LOWER_BUTTON
;
1550 static DEVICE_ATTR(stylus_upper
,
1552 show_tabletStylusUpper
, store_tabletStylusUpper
);
1554 /***********************************************************************
1555 * support routines for the 'stylus_lower' file. Note that this file
1556 * both displays current setting and allows for setting changing.
1558 static ssize_t
show_tabletStylusLower(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1560 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1566 switch (aiptek
->curSetting
.stylusButtonLower
) {
1567 case AIPTEK_STYLUS_UPPER_BUTTON
:
1571 case AIPTEK_STYLUS_LOWER_BUTTON
:
1579 return snprintf(buf
, PAGE_SIZE
, "%s\n", s
);
1583 store_tabletStylusLower(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1585 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1590 if (strcmp(buf
, "upper") == 0) {
1591 aiptek
->newSetting
.stylusButtonLower
=
1592 AIPTEK_STYLUS_UPPER_BUTTON
;
1593 } else if (strcmp(buf
, "lower") == 0) {
1594 aiptek
->newSetting
.stylusButtonLower
=
1595 AIPTEK_STYLUS_LOWER_BUTTON
;
1600 static DEVICE_ATTR(stylus_lower
,
1602 show_tabletStylusLower
, store_tabletStylusLower
);
1604 /***********************************************************************
1605 * support routines for the 'mouse_left' file. Note that this file
1606 * both displays current setting and allows for setting changing.
1608 static ssize_t
show_tabletMouseLeft(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1610 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1616 switch (aiptek
->curSetting
.mouseButtonLeft
) {
1617 case AIPTEK_MOUSE_LEFT_BUTTON
:
1621 case AIPTEK_MOUSE_MIDDLE_BUTTON
:
1625 case AIPTEK_MOUSE_RIGHT_BUTTON
:
1633 return snprintf(buf
, PAGE_SIZE
, "%s\n", s
);
1637 store_tabletMouseLeft(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1639 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1644 if (strcmp(buf
, "left") == 0) {
1645 aiptek
->newSetting
.mouseButtonLeft
= AIPTEK_MOUSE_LEFT_BUTTON
;
1646 } else if (strcmp(buf
, "middle") == 0) {
1647 aiptek
->newSetting
.mouseButtonLeft
= AIPTEK_MOUSE_MIDDLE_BUTTON
;
1648 } else if (strcmp(buf
, "right") == 0) {
1649 aiptek
->newSetting
.mouseButtonLeft
= AIPTEK_MOUSE_RIGHT_BUTTON
;
1654 static DEVICE_ATTR(mouse_left
,
1656 show_tabletMouseLeft
, store_tabletMouseLeft
);
1658 /***********************************************************************
1659 * support routines for the 'mouse_middle' file. Note that this file
1660 * both displays current setting and allows for setting changing.
1662 static ssize_t
show_tabletMouseMiddle(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1664 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1670 switch (aiptek
->curSetting
.mouseButtonMiddle
) {
1671 case AIPTEK_MOUSE_LEFT_BUTTON
:
1675 case AIPTEK_MOUSE_MIDDLE_BUTTON
:
1679 case AIPTEK_MOUSE_RIGHT_BUTTON
:
1687 return snprintf(buf
, PAGE_SIZE
, "%s\n", s
);
1691 store_tabletMouseMiddle(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1693 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1698 if (strcmp(buf
, "left") == 0) {
1699 aiptek
->newSetting
.mouseButtonMiddle
= AIPTEK_MOUSE_LEFT_BUTTON
;
1700 } else if (strcmp(buf
, "middle") == 0) {
1701 aiptek
->newSetting
.mouseButtonMiddle
=
1702 AIPTEK_MOUSE_MIDDLE_BUTTON
;
1703 } else if (strcmp(buf
, "right") == 0) {
1704 aiptek
->newSetting
.mouseButtonMiddle
=
1705 AIPTEK_MOUSE_RIGHT_BUTTON
;
1710 static DEVICE_ATTR(mouse_middle
,
1712 show_tabletMouseMiddle
, store_tabletMouseMiddle
);
1714 /***********************************************************************
1715 * support routines for the 'mouse_right' file. Note that this file
1716 * both displays current setting and allows for setting changing.
1718 static ssize_t
show_tabletMouseRight(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1720 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1726 switch (aiptek
->curSetting
.mouseButtonRight
) {
1727 case AIPTEK_MOUSE_LEFT_BUTTON
:
1731 case AIPTEK_MOUSE_MIDDLE_BUTTON
:
1735 case AIPTEK_MOUSE_RIGHT_BUTTON
:
1743 return snprintf(buf
, PAGE_SIZE
, "%s\n", s
);
1747 store_tabletMouseRight(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1749 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1754 if (strcmp(buf
, "left") == 0) {
1755 aiptek
->newSetting
.mouseButtonRight
= AIPTEK_MOUSE_LEFT_BUTTON
;
1756 } else if (strcmp(buf
, "middle") == 0) {
1757 aiptek
->newSetting
.mouseButtonRight
=
1758 AIPTEK_MOUSE_MIDDLE_BUTTON
;
1759 } else if (strcmp(buf
, "right") == 0) {
1760 aiptek
->newSetting
.mouseButtonRight
= AIPTEK_MOUSE_RIGHT_BUTTON
;
1765 static DEVICE_ATTR(mouse_right
,
1767 show_tabletMouseRight
, store_tabletMouseRight
);
1769 /***********************************************************************
1770 * support routines for the 'wheel' file. Note that this file
1771 * both displays current setting and allows for setting changing.
1773 static ssize_t
show_tabletWheel(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1775 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1780 if (aiptek
->curSetting
.wheel
== AIPTEK_WHEEL_DISABLE
) {
1781 return snprintf(buf
, PAGE_SIZE
, "disable\n");
1783 return snprintf(buf
, PAGE_SIZE
, "%d\n",
1784 aiptek
->curSetting
.wheel
);
1789 store_tabletWheel(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1791 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1796 aiptek
->newSetting
.wheel
= (int)simple_strtol(buf
, NULL
, 10);
1800 static DEVICE_ATTR(wheel
,
1801 S_IRUGO
| S_IWUGO
, show_tabletWheel
, store_tabletWheel
);
1803 /***********************************************************************
1804 * support routines for the 'execute' file. Note that this file
1805 * both displays current setting and allows for setting changing.
1807 static ssize_t
show_tabletExecute(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1809 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1814 /* There is nothing useful to display, so a one-line manual
1817 return snprintf(buf
, PAGE_SIZE
,
1818 "Write anything to this file to program your tablet.\n");
1822 store_tabletExecute(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1824 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1829 /* We do not care what you write to this file. Merely the action
1830 * of writing to this file triggers a tablet reprogramming.
1832 memcpy(&aiptek
->curSetting
, &aiptek
->newSetting
,
1833 sizeof(struct aiptek_settings
));
1835 if (aiptek_program_tablet(aiptek
) < 0)
1841 static DEVICE_ATTR(execute
,
1842 S_IRUGO
| S_IWUGO
, show_tabletExecute
, store_tabletExecute
);
1844 /***********************************************************************
1845 * support routines for the 'odm_code' file. Note that this file
1846 * only displays current setting.
1848 static ssize_t
show_tabletODMCode(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1850 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1855 return snprintf(buf
, PAGE_SIZE
, "0x%04x\n", aiptek
->features
.odmCode
);
1858 static DEVICE_ATTR(odm_code
, S_IRUGO
, show_tabletODMCode
, NULL
);
1860 /***********************************************************************
1861 * support routines for the 'model_code' file. Note that this file
1862 * only displays current setting.
1864 static ssize_t
show_tabletModelCode(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1866 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1871 return snprintf(buf
, PAGE_SIZE
, "0x%04x\n", aiptek
->features
.modelCode
);
1874 static DEVICE_ATTR(model_code
, S_IRUGO
, show_tabletModelCode
, NULL
);
1876 /***********************************************************************
1877 * support routines for the 'firmware_code' file. Note that this file
1878 * only displays current setting.
1880 static ssize_t
show_firmwareCode(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1882 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1887 return snprintf(buf
, PAGE_SIZE
, "%04x\n",
1888 aiptek
->features
.firmwareCode
);
1891 static DEVICE_ATTR(firmware_code
, S_IRUGO
, show_firmwareCode
, NULL
);
1893 /***********************************************************************
1894 * This routine removes all existing sysfs files managed by this device
1897 static void aiptek_delete_files(struct device
*dev
)
1899 device_remove_file(dev
, &dev_attr_size
);
1900 device_remove_file(dev
, &dev_attr_product_id
);
1901 device_remove_file(dev
, &dev_attr_vendor_id
);
1902 device_remove_file(dev
, &dev_attr_vendor
);
1903 device_remove_file(dev
, &dev_attr_product
);
1904 device_remove_file(dev
, &dev_attr_pointer_mode
);
1905 device_remove_file(dev
, &dev_attr_coordinate_mode
);
1906 device_remove_file(dev
, &dev_attr_tool_mode
);
1907 device_remove_file(dev
, &dev_attr_xtilt
);
1908 device_remove_file(dev
, &dev_attr_ytilt
);
1909 device_remove_file(dev
, &dev_attr_jitter
);
1910 device_remove_file(dev
, &dev_attr_delay
);
1911 device_remove_file(dev
, &dev_attr_input_path
);
1912 device_remove_file(dev
, &dev_attr_event_count
);
1913 device_remove_file(dev
, &dev_attr_diagnostic
);
1914 device_remove_file(dev
, &dev_attr_odm_code
);
1915 device_remove_file(dev
, &dev_attr_model_code
);
1916 device_remove_file(dev
, &dev_attr_firmware_code
);
1917 device_remove_file(dev
, &dev_attr_stylus_lower
);
1918 device_remove_file(dev
, &dev_attr_stylus_upper
);
1919 device_remove_file(dev
, &dev_attr_mouse_left
);
1920 device_remove_file(dev
, &dev_attr_mouse_middle
);
1921 device_remove_file(dev
, &dev_attr_mouse_right
);
1922 device_remove_file(dev
, &dev_attr_wheel
);
1923 device_remove_file(dev
, &dev_attr_execute
);
1926 /***********************************************************************
1927 * This routine creates the sysfs files managed by this device
1930 static int aiptek_add_files(struct device
*dev
)
1934 if ((ret
= device_create_file(dev
, &dev_attr_size
)) ||
1935 (ret
= device_create_file(dev
, &dev_attr_product_id
)) ||
1936 (ret
= device_create_file(dev
, &dev_attr_vendor_id
)) ||
1937 (ret
= device_create_file(dev
, &dev_attr_vendor
)) ||
1938 (ret
= device_create_file(dev
, &dev_attr_product
)) ||
1939 (ret
= device_create_file(dev
, &dev_attr_pointer_mode
)) ||
1940 (ret
= device_create_file(dev
, &dev_attr_coordinate_mode
)) ||
1941 (ret
= device_create_file(dev
, &dev_attr_tool_mode
)) ||
1942 (ret
= device_create_file(dev
, &dev_attr_xtilt
)) ||
1943 (ret
= device_create_file(dev
, &dev_attr_ytilt
)) ||
1944 (ret
= device_create_file(dev
, &dev_attr_jitter
)) ||
1945 (ret
= device_create_file(dev
, &dev_attr_delay
)) ||
1946 (ret
= device_create_file(dev
, &dev_attr_input_path
)) ||
1947 (ret
= device_create_file(dev
, &dev_attr_event_count
)) ||
1948 (ret
= device_create_file(dev
, &dev_attr_diagnostic
)) ||
1949 (ret
= device_create_file(dev
, &dev_attr_odm_code
)) ||
1950 (ret
= device_create_file(dev
, &dev_attr_model_code
)) ||
1951 (ret
= device_create_file(dev
, &dev_attr_firmware_code
)) ||
1952 (ret
= device_create_file(dev
, &dev_attr_stylus_lower
)) ||
1953 (ret
= device_create_file(dev
, &dev_attr_stylus_upper
)) ||
1954 (ret
= device_create_file(dev
, &dev_attr_mouse_left
)) ||
1955 (ret
= device_create_file(dev
, &dev_attr_mouse_middle
)) ||
1956 (ret
= device_create_file(dev
, &dev_attr_mouse_right
)) ||
1957 (ret
= device_create_file(dev
, &dev_attr_wheel
)) ||
1958 (ret
= device_create_file(dev
, &dev_attr_execute
))) {
1959 err("aiptek: killing own sysfs device files\n");
1960 aiptek_delete_files(dev
);
1965 /***********************************************************************
1966 * This routine is called when a tablet has been identified. It basically
1967 * sets up the tablet and the driver's internal structures.
1970 aiptek_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
)
1972 struct usb_device
*usbdev
= interface_to_usbdev(intf
);
1973 struct usb_endpoint_descriptor
*endpoint
;
1974 struct aiptek
*aiptek
;
1975 struct input_dev
*inputdev
;
1976 struct input_handle
*inputhandle
;
1977 struct list_head
*node
, *next
;
1980 AIPTEK_PROGRAMMABLE_DELAY_50
,
1981 AIPTEK_PROGRAMMABLE_DELAY_400
,
1982 AIPTEK_PROGRAMMABLE_DELAY_25
,
1983 AIPTEK_PROGRAMMABLE_DELAY_100
,
1984 AIPTEK_PROGRAMMABLE_DELAY_200
,
1985 AIPTEK_PROGRAMMABLE_DELAY_300
1988 /* programmableDelay is where the command-line specified
1989 * delay is kept. We make it the first element of speeds[],
1990 * so therefore, your override speed is tried first, then the
1991 * remainder. Note that the default value of 400ms will be tried
1992 * if you do not specify any command line parameter.
1994 speeds
[0] = programmableDelay
;
1996 aiptek
= kzalloc(sizeof(struct aiptek
), GFP_KERNEL
);
1997 inputdev
= input_allocate_device();
1998 if (!aiptek
|| !inputdev
)
2001 aiptek
->data
= usb_buffer_alloc(usbdev
, AIPTEK_PACKET_LENGTH
,
2002 SLAB_ATOMIC
, &aiptek
->data_dma
);
2006 aiptek
->urb
= usb_alloc_urb(0, GFP_KERNEL
);
2010 aiptek
->inputdev
= inputdev
;
2011 aiptek
->usbdev
= usbdev
;
2012 aiptek
->ifnum
= intf
->altsetting
[0].desc
.bInterfaceNumber
;
2013 aiptek
->inDelay
= 0;
2014 aiptek
->endDelay
= 0;
2015 aiptek
->previousJitterable
= 0;
2017 /* Set up the curSettings struct. Said struct contains the current
2018 * programmable parameters. The newSetting struct contains changes
2019 * the user makes to the settings via the sysfs interface. Those
2020 * changes are not "committed" to curSettings until the user
2021 * writes to the sysfs/.../execute file.
2023 aiptek
->curSetting
.pointerMode
= AIPTEK_POINTER_EITHER_MODE
;
2024 aiptek
->curSetting
.coordinateMode
= AIPTEK_COORDINATE_ABSOLUTE_MODE
;
2025 aiptek
->curSetting
.toolMode
= AIPTEK_TOOL_BUTTON_PEN_MODE
;
2026 aiptek
->curSetting
.xTilt
= AIPTEK_TILT_DISABLE
;
2027 aiptek
->curSetting
.yTilt
= AIPTEK_TILT_DISABLE
;
2028 aiptek
->curSetting
.mouseButtonLeft
= AIPTEK_MOUSE_LEFT_BUTTON
;
2029 aiptek
->curSetting
.mouseButtonMiddle
= AIPTEK_MOUSE_MIDDLE_BUTTON
;
2030 aiptek
->curSetting
.mouseButtonRight
= AIPTEK_MOUSE_RIGHT_BUTTON
;
2031 aiptek
->curSetting
.stylusButtonUpper
= AIPTEK_STYLUS_UPPER_BUTTON
;
2032 aiptek
->curSetting
.stylusButtonLower
= AIPTEK_STYLUS_LOWER_BUTTON
;
2033 aiptek
->curSetting
.jitterDelay
= jitterDelay
;
2034 aiptek
->curSetting
.programmableDelay
= programmableDelay
;
2036 /* Both structs should have equivalent settings
2038 aiptek
->newSetting
= aiptek
->curSetting
;
2040 /* Determine the usb devices' physical path.
2041 * Asketh not why we always pretend we're using "../input0",
2042 * but I suspect this will have to be refactored one
2043 * day if a single USB device can be a keyboard & a mouse
2044 * & a tablet, and the inputX number actually will tell
2047 usb_make_path(usbdev
, aiptek
->features
.usbPath
,
2048 sizeof(aiptek
->features
.usbPath
));
2049 strlcat(aiptek
->features
.usbPath
, "/input0",
2050 sizeof(aiptek
->features
.usbPath
));
2052 /* Set up client data, pointers to open and close routines
2053 * for the input device.
2055 inputdev
->name
= "Aiptek";
2056 inputdev
->phys
= aiptek
->features
.usbPath
;
2057 usb_to_input_id(usbdev
, &inputdev
->id
);
2058 inputdev
->cdev
.dev
= &intf
->dev
;
2059 inputdev
->private = aiptek
;
2060 inputdev
->open
= aiptek_open
;
2061 inputdev
->close
= aiptek_close
;
2063 /* Now program the capacities of the tablet, in terms of being
2066 inputdev
->evbit
[0] |= BIT(EV_KEY
)
2071 inputdev
->absbit
[0] |= BIT(ABS_MISC
);
2073 inputdev
->relbit
[0] |=
2074 (BIT(REL_X
) | BIT(REL_Y
) | BIT(REL_WHEEL
) | BIT(REL_MISC
));
2076 inputdev
->keybit
[LONG(BTN_LEFT
)] |=
2077 (BIT(BTN_LEFT
) | BIT(BTN_RIGHT
) | BIT(BTN_MIDDLE
));
2079 inputdev
->keybit
[LONG(BTN_DIGI
)] |=
2080 (BIT(BTN_TOOL_PEN
) |
2081 BIT(BTN_TOOL_RUBBER
) |
2082 BIT(BTN_TOOL_PENCIL
) |
2083 BIT(BTN_TOOL_AIRBRUSH
) |
2084 BIT(BTN_TOOL_BRUSH
) |
2085 BIT(BTN_TOOL_MOUSE
) |
2086 BIT(BTN_TOOL_LENS
) |
2087 BIT(BTN_TOUCH
) | BIT(BTN_STYLUS
) | BIT(BTN_STYLUS2
));
2089 inputdev
->mscbit
[0] = BIT(MSC_SERIAL
);
2091 /* Programming the tablet macro keys needs to be done with a for loop
2092 * as the keycodes are discontiguous.
2094 for (i
= 0; i
< ARRAY_SIZE(macroKeyEvents
); ++i
)
2095 set_bit(macroKeyEvents
[i
], inputdev
->keybit
);
2098 * Program the input device coordinate capacities. We do not yet
2099 * know what maximum X, Y, and Z values are, so we're putting fake
2100 * values in. Later, we'll ask the tablet to put in the correct
2103 input_set_abs_params(inputdev
, ABS_X
, 0, 2999, 0, 0);
2104 input_set_abs_params(inputdev
, ABS_Y
, 0, 2249, 0, 0);
2105 input_set_abs_params(inputdev
, ABS_PRESSURE
, 0, 511, 0, 0);
2106 input_set_abs_params(inputdev
, ABS_TILT_X
, AIPTEK_TILT_MIN
, AIPTEK_TILT_MAX
, 0, 0);
2107 input_set_abs_params(inputdev
, ABS_TILT_Y
, AIPTEK_TILT_MIN
, AIPTEK_TILT_MAX
, 0, 0);
2108 input_set_abs_params(inputdev
, ABS_WHEEL
, AIPTEK_WHEEL_MIN
, AIPTEK_WHEEL_MAX
- 1, 0, 0);
2110 endpoint
= &intf
->altsetting
[0].endpoint
[0].desc
;
2112 /* Go set up our URB, which is called when the tablet receives
2115 usb_fill_int_urb(aiptek
->urb
,
2117 usb_rcvintpipe(aiptek
->usbdev
,
2118 endpoint
->bEndpointAddress
),
2119 aiptek
->data
, 8, aiptek_irq
, aiptek
,
2120 endpoint
->bInterval
);
2122 aiptek
->urb
->transfer_dma
= aiptek
->data_dma
;
2123 aiptek
->urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
2125 /* Program the tablet. This sets the tablet up in the mode
2126 * specified in newSetting, and also queries the tablet's
2127 * physical capacities.
2129 * Sanity check: if a tablet doesn't like the slow programmatic
2130 * delay, we often get sizes of 0x0. Let's use that as an indicator
2131 * to try faster delays, up to 25 ms. If that logic fails, well, you'll
2132 * have to explain to us how your tablet thinks it's 0x0, and yet that's
2136 for (i
= 0; i
< ARRAY_SIZE(speeds
); ++i
) {
2137 aiptek
->curSetting
.programmableDelay
= speeds
[i
];
2138 (void)aiptek_program_tablet(aiptek
);
2139 if (aiptek
->inputdev
->absmax
[ABS_X
] > 0) {
2140 info("input: Aiptek using %d ms programming speed\n",
2141 aiptek
->curSetting
.programmableDelay
);
2146 /* Register the tablet as an Input Device
2148 input_register_device(aiptek
->inputdev
);
2150 /* We now will look for the evdev device which is mapped to
2151 * the tablet. The partial name is kept in the link list of
2152 * input_handles associated with this input device.
2153 * What identifies an evdev input_handler is that it begins
2154 * with 'event', continues with a digit, and that in turn
2155 * is mapped to input/eventN.
2157 list_for_each_safe(node
, next
, &inputdev
->h_list
) {
2158 inputhandle
= to_handle(node
);
2159 if (strncmp(inputhandle
->name
, "event", 5) == 0) {
2160 strcpy(aiptek
->features
.inputPath
, inputhandle
->name
);
2165 /* Associate this driver's struct with the usb interface.
2167 usb_set_intfdata(intf
, aiptek
);
2169 /* Set up the sysfs files
2171 aiptek_add_files(&intf
->dev
);
2173 /* Make sure the evdev module is loaded. Assuming evdev IS a module :-)
2175 if (request_module("evdev") != 0)
2176 info("aiptek: error loading 'evdev' module");
2180 fail2
: usb_buffer_free(usbdev
, AIPTEK_PACKET_LENGTH
, aiptek
->data
,
2182 fail1
: input_free_device(inputdev
);
2187 /* Forward declaration */
2188 static void aiptek_disconnect(struct usb_interface
*intf
);
2190 static struct usb_driver aiptek_driver
= {
2192 .probe
= aiptek_probe
,
2193 .disconnect
= aiptek_disconnect
,
2194 .id_table
= aiptek_ids
,
2197 /***********************************************************************
2198 * Deal with tablet disconnecting from the system.
2200 static void aiptek_disconnect(struct usb_interface
*intf
)
2202 struct aiptek
*aiptek
= usb_get_intfdata(intf
);
2204 /* Disassociate driver's struct with usb interface
2206 usb_set_intfdata(intf
, NULL
);
2207 if (aiptek
!= NULL
) {
2208 /* Free & unhook everything from the system.
2210 usb_kill_urb(aiptek
->urb
);
2211 input_unregister_device(aiptek
->inputdev
);
2212 aiptek_delete_files(&intf
->dev
);
2213 usb_free_urb(aiptek
->urb
);
2214 usb_buffer_free(interface_to_usbdev(intf
),
2215 AIPTEK_PACKET_LENGTH
,
2216 aiptek
->data
, aiptek
->data_dma
);
2221 static int __init
aiptek_init(void)
2223 int result
= usb_register(&aiptek_driver
);
2225 info(DRIVER_VERSION
": " DRIVER_AUTHOR
);
2231 static void __exit
aiptek_exit(void)
2233 usb_deregister(&aiptek_driver
);
2236 MODULE_AUTHOR(DRIVER_AUTHOR
);
2237 MODULE_DESCRIPTION(DRIVER_DESC
);
2238 MODULE_LICENSE("GPL");
2240 module_param(programmableDelay
, int, 0);
2241 MODULE_PARM_DESC(programmableDelay
, "delay used during tablet programming");
2242 module_param(jitterDelay
, int, 0);
2243 MODULE_PARM_DESC(jitterDelay
, "stylus/mouse settlement delay");
2245 module_init(aiptek_init
);
2246 module_exit(aiptek_exit
);