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
)
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 x
= aiptek_convert_from_2s_complement(data
[2]);
446 y
= aiptek_convert_from_2s_complement(data
[3]);
448 /* jitterable keeps track of whether any button has been pressed.
449 * We're also using it to remap the physical mouse button mask
450 * to pseudo-settings. (We don't specifically care about it's
451 * value after moving/transposing mouse button bitmasks, except
452 * that a non-zero value indicates that one or more
453 * mouse button was pressed.)
455 jitterable
= data
[5] & 0x07;
457 left
= (data
[5] & aiptek
->curSetting
.mouseButtonLeft
) != 0 ? 1 : 0;
458 right
= (data
[5] & aiptek
->curSetting
.mouseButtonRight
) != 0 ? 1 : 0;
459 middle
= (data
[5] & aiptek
->curSetting
.mouseButtonMiddle
) != 0 ? 1 : 0;
461 input_report_key(inputdev
, BTN_LEFT
, left
);
462 input_report_key(inputdev
, BTN_MIDDLE
, middle
);
463 input_report_key(inputdev
, BTN_RIGHT
, right
);
464 input_report_rel(inputdev
, REL_X
, x
);
465 input_report_rel(inputdev
, REL_Y
, y
);
466 input_report_rel(inputdev
, REL_MISC
, 1 | AIPTEK_REPORT_TOOL_UNKNOWN
);
468 /* Wheel support is in the form of a single-event
471 if (aiptek
->curSetting
.wheel
!= AIPTEK_WHEEL_DISABLE
) {
472 input_report_rel(inputdev
, REL_WHEEL
,
473 aiptek
->curSetting
.wheel
);
474 aiptek
->curSetting
.wheel
= AIPTEK_WHEEL_DISABLE
;
476 input_sync(inputdev
);
479 /* Report 2 is delivered only by the stylus, and delivers
480 * absolute coordinates.
482 else if (data
[0] == 2) {
483 if (aiptek
->curSetting
.coordinateMode
== AIPTEK_COORDINATE_RELATIVE_MODE
) {
484 aiptek
->diagnostic
= AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE
;
485 } else if (!AIPTEK_POINTER_ALLOW_STYLUS_MODE
486 (aiptek
->curSetting
.pointerMode
)) {
487 aiptek
->diagnostic
= AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED
;
489 x
= le16_to_cpu(get_unaligned((__le16
*) (data
+ 1)));
490 y
= le16_to_cpu(get_unaligned((__le16
*) (data
+ 3)));
491 z
= le16_to_cpu(get_unaligned((__le16
*) (data
+ 6)));
493 p
= (data
[5] & 0x01) != 0 ? 1 : 0;
494 dv
= (data
[5] & 0x02) != 0 ? 1 : 0;
495 tip
= (data
[5] & 0x04) != 0 ? 1 : 0;
497 /* Use jitterable to re-arrange button masks
499 jitterable
= data
[5] & 0x18;
501 bs
= (data
[5] & aiptek
->curSetting
.stylusButtonLower
) != 0 ? 1 : 0;
502 pck
= (data
[5] & aiptek
->curSetting
.stylusButtonUpper
) != 0 ? 1 : 0;
504 /* dv indicates 'data valid' (e.g., the tablet is in sync
505 * and has delivered a "correct" report) We will ignore
506 * all 'bad' reports...
509 /* If we've not already sent a tool_button_?? code, do
510 * so now. Then set FIRED_BIT so it won't be resent unless
511 * the user forces FIRED_BIT off.
513 if (TOOL_BUTTON_FIRED
514 (aiptek
->curSetting
.toolMode
) == 0) {
515 input_report_key(inputdev
,
516 TOOL_BUTTON(aiptek
->curSetting
.toolMode
),
518 aiptek
->curSetting
.toolMode
|= TOOL_BUTTON_FIRED_BIT
;
522 input_report_abs(inputdev
, ABS_X
, x
);
523 input_report_abs(inputdev
, ABS_Y
, y
);
524 input_report_abs(inputdev
, ABS_PRESSURE
, z
);
526 input_report_key(inputdev
, BTN_TOUCH
, tip
);
527 input_report_key(inputdev
, BTN_STYLUS
, bs
);
528 input_report_key(inputdev
, BTN_STYLUS2
, pck
);
530 if (aiptek
->curSetting
.xTilt
!=
531 AIPTEK_TILT_DISABLE
) {
532 input_report_abs(inputdev
,
534 aiptek
->curSetting
.xTilt
);
536 if (aiptek
->curSetting
.yTilt
!= AIPTEK_TILT_DISABLE
) {
537 input_report_abs(inputdev
,
539 aiptek
->curSetting
.yTilt
);
542 /* Wheel support is in the form of a single-event
545 if (aiptek
->curSetting
.wheel
!=
546 AIPTEK_WHEEL_DISABLE
) {
547 input_report_abs(inputdev
,
549 aiptek
->curSetting
.wheel
);
550 aiptek
->curSetting
.wheel
= AIPTEK_WHEEL_DISABLE
;
553 input_report_abs(inputdev
, ABS_MISC
, p
| AIPTEK_REPORT_TOOL_STYLUS
);
554 input_sync(inputdev
);
558 /* Report 3's come from the mouse in absolute mode.
560 else if (data
[0] == 3) {
561 if (aiptek
->curSetting
.coordinateMode
== AIPTEK_COORDINATE_RELATIVE_MODE
) {
562 aiptek
->diagnostic
= AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE
;
563 } else if (!AIPTEK_POINTER_ALLOW_MOUSE_MODE
564 (aiptek
->curSetting
.pointerMode
)) {
565 aiptek
->diagnostic
= AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED
;
567 x
= le16_to_cpu(get_unaligned((__le16
*) (data
+ 1)));
568 y
= le16_to_cpu(get_unaligned((__le16
*) (data
+ 3)));
570 jitterable
= data
[5] & 0x1c;
572 p
= (data
[5] & 0x01) != 0 ? 1 : 0;
573 dv
= (data
[5] & 0x02) != 0 ? 1 : 0;
574 left
= (data
[5] & aiptek
->curSetting
.mouseButtonLeft
) != 0 ? 1 : 0;
575 right
= (data
[5] & aiptek
->curSetting
.mouseButtonRight
) != 0 ? 1 : 0;
576 middle
= (data
[5] & aiptek
->curSetting
.mouseButtonMiddle
) != 0 ? 1 : 0;
579 /* If we've not already sent a tool_button_?? code, do
580 * so now. Then set FIRED_BIT so it won't be resent unless
581 * the user forces FIRED_BIT off.
583 if (TOOL_BUTTON_FIRED
584 (aiptek
->curSetting
.toolMode
) == 0) {
585 input_report_key(inputdev
,
586 TOOL_BUTTON(aiptek
->curSetting
.toolMode
),
588 aiptek
->curSetting
.toolMode
|= TOOL_BUTTON_FIRED_BIT
;
592 input_report_abs(inputdev
, ABS_X
, x
);
593 input_report_abs(inputdev
, ABS_Y
, y
);
595 input_report_key(inputdev
, BTN_LEFT
, left
);
596 input_report_key(inputdev
, BTN_MIDDLE
, middle
);
597 input_report_key(inputdev
, BTN_RIGHT
, right
);
599 /* Wheel support is in the form of a single-event
602 if (aiptek
->curSetting
.wheel
!= AIPTEK_WHEEL_DISABLE
) {
603 input_report_abs(inputdev
,
605 aiptek
->curSetting
.wheel
);
606 aiptek
->curSetting
.wheel
= AIPTEK_WHEEL_DISABLE
;
609 input_report_rel(inputdev
, REL_MISC
, p
| AIPTEK_REPORT_TOOL_MOUSE
);
610 input_sync(inputdev
);
614 /* Report 4s come from the macro keys when pressed by stylus
616 else if (data
[0] == 4) {
617 jitterable
= data
[1] & 0x18;
619 p
= (data
[1] & 0x01) != 0 ? 1 : 0;
620 dv
= (data
[1] & 0x02) != 0 ? 1 : 0;
621 tip
= (data
[1] & 0x04) != 0 ? 1 : 0;
622 bs
= (data
[1] & aiptek
->curSetting
.stylusButtonLower
) != 0 ? 1 : 0;
623 pck
= (data
[1] & aiptek
->curSetting
.stylusButtonUpper
) != 0 ? 1 : 0;
626 z
= le16_to_cpu(get_unaligned((__le16
*) (data
+ 4)));
629 /* If we've not already sent a tool_button_?? code, do
630 * so now. Then set FIRED_BIT so it won't be resent unless
631 * the user forces FIRED_BIT off.
633 if (TOOL_BUTTON_FIRED(aiptek
->curSetting
.toolMode
) == 0) {
634 input_report_key(inputdev
,
635 TOOL_BUTTON(aiptek
->curSetting
.toolMode
),
637 aiptek
->curSetting
.toolMode
|= TOOL_BUTTON_FIRED_BIT
;
641 input_report_key(inputdev
, BTN_TOUCH
, tip
);
642 input_report_key(inputdev
, BTN_STYLUS
, bs
);
643 input_report_key(inputdev
, BTN_STYLUS2
, pck
);
644 input_report_abs(inputdev
, ABS_PRESSURE
, z
);
647 /* For safety, we're sending key 'break' codes for the
648 * neighboring macro keys.
651 input_report_key(inputdev
,
652 macroKeyEvents
[macro
- 1], 0);
655 input_report_key(inputdev
,
656 macroKeyEvents
[macro
+ 1], 0);
658 input_report_key(inputdev
, macroKeyEvents
[macro
], p
);
659 input_report_abs(inputdev
, ABS_MISC
,
660 p
| AIPTEK_REPORT_TOOL_STYLUS
);
661 input_sync(inputdev
);
664 /* Report 5s come from the macro keys when pressed by mouse
666 else if (data
[0] == 5) {
667 jitterable
= data
[1] & 0x1c;
669 p
= (data
[1] & 0x01) != 0 ? 1 : 0;
670 dv
= (data
[1] & 0x02) != 0 ? 1 : 0;
671 left
= (data
[1]& aiptek
->curSetting
.mouseButtonLeft
) != 0 ? 1 : 0;
672 right
= (data
[1] & aiptek
->curSetting
.mouseButtonRight
) != 0 ? 1 : 0;
673 middle
= (data
[1] & aiptek
->curSetting
.mouseButtonMiddle
) != 0 ? 1 : 0;
677 /* If we've not already sent a tool_button_?? code, do
678 * so now. Then set FIRED_BIT so it won't be resent unless
679 * the user forces FIRED_BIT off.
681 if (TOOL_BUTTON_FIRED(aiptek
->curSetting
.toolMode
) == 0) {
682 input_report_key(inputdev
,
683 TOOL_BUTTON(aiptek
->curSetting
.toolMode
),
685 aiptek
->curSetting
.toolMode
|= TOOL_BUTTON_FIRED_BIT
;
689 input_report_key(inputdev
, BTN_LEFT
, left
);
690 input_report_key(inputdev
, BTN_MIDDLE
, middle
);
691 input_report_key(inputdev
, BTN_RIGHT
, right
);
694 /* For safety, we're sending key 'break' codes for the
695 * neighboring macro keys.
698 input_report_key(inputdev
,
699 macroKeyEvents
[macro
- 1], 0);
702 input_report_key(inputdev
,
703 macroKeyEvents
[macro
+ 1], 0);
706 input_report_key(inputdev
, macroKeyEvents
[macro
], 1);
707 input_report_rel(inputdev
, ABS_MISC
,
708 p
| AIPTEK_REPORT_TOOL_MOUSE
);
709 input_sync(inputdev
);
712 /* We have no idea which tool can generate a report 6. Theoretically,
713 * neither need to, having been given reports 4 & 5 for such use.
714 * However, report 6 is the 'official-looking' report for macroKeys;
715 * reports 4 & 5 supposively are used to support unnamed, unknown
716 * hat switches (which just so happen to be the macroKeys.)
718 else if (data
[0] == 6) {
719 macro
= le16_to_cpu(get_unaligned((__le16
*) (data
+ 1)));
721 input_report_key(inputdev
, macroKeyEvents
[macro
- 1],
725 input_report_key(inputdev
, macroKeyEvents
[macro
+ 1],
729 /* If we've not already sent a tool_button_?? code, do
730 * so now. Then set FIRED_BIT so it won't be resent unless
731 * the user forces FIRED_BIT off.
733 if (TOOL_BUTTON_FIRED(aiptek
->curSetting
.toolMode
) == 0) {
734 input_report_key(inputdev
,
735 TOOL_BUTTON(aiptek
->curSetting
.
737 aiptek
->curSetting
.toolMode
|= TOOL_BUTTON_FIRED_BIT
;
740 input_report_key(inputdev
, macroKeyEvents
[macro
], 1);
741 input_report_abs(inputdev
, ABS_MISC
,
742 1 | AIPTEK_REPORT_TOOL_UNKNOWN
);
743 input_sync(inputdev
);
745 dbg("Unknown report %d", data
[0]);
748 /* Jitter may occur when the user presses a button on the stlyus
749 * or the mouse. What we do to prevent that is wait 'x' milliseconds
750 * following a 'jitterable' event, which should give the hand some time
753 * We just introduced aiptek->previousJitterable to carry forth the
754 * notion that jitter occurs when the button state changes from on to off:
755 * a person drawing, holding a button down is not subject to jittering.
756 * With that in mind, changing from upper button depressed to lower button
757 * WILL transition through a jitter delay.
760 if (aiptek
->previousJitterable
!= jitterable
&&
761 aiptek
->curSetting
.jitterDelay
!= 0 && aiptek
->inDelay
!= 1) {
762 aiptek
->endDelay
= jiffies
+
763 ((aiptek
->curSetting
.jitterDelay
* HZ
) / 1000);
766 aiptek
->previousJitterable
= jitterable
;
769 retval
= usb_submit_urb(urb
, GFP_ATOMIC
);
771 err("%s - usb_submit_urb failed with result %d",
772 __FUNCTION__
, retval
);
776 /***********************************************************************
777 * These are the USB id's known so far. We do not identify them to
778 * specific Aiptek model numbers, because there has been overlaps,
779 * use, and reuse of id's in existing models. Certain models have
780 * been known to use more than one ID, indicative perhaps of
781 * manufacturing revisions. In any event, we consider these
782 * IDs to not be model-specific nor unique.
784 static const struct usb_device_id aiptek_ids
[] = {
785 {USB_DEVICE(USB_VENDOR_ID_AIPTEK
, 0x01)},
786 {USB_DEVICE(USB_VENDOR_ID_AIPTEK
, 0x10)},
787 {USB_DEVICE(USB_VENDOR_ID_AIPTEK
, 0x20)},
788 {USB_DEVICE(USB_VENDOR_ID_AIPTEK
, 0x21)},
789 {USB_DEVICE(USB_VENDOR_ID_AIPTEK
, 0x22)},
790 {USB_DEVICE(USB_VENDOR_ID_AIPTEK
, 0x23)},
791 {USB_DEVICE(USB_VENDOR_ID_AIPTEK
, 0x24)},
795 MODULE_DEVICE_TABLE(usb
, aiptek_ids
);
797 /***********************************************************************
798 * Open an instance of the tablet driver.
800 static int aiptek_open(struct input_dev
*inputdev
)
802 struct aiptek
*aiptek
= inputdev
->private;
804 aiptek
->urb
->dev
= aiptek
->usbdev
;
805 if (usb_submit_urb(aiptek
->urb
, GFP_KERNEL
) != 0)
811 /***********************************************************************
812 * Close an instance of the tablet driver.
814 static void aiptek_close(struct input_dev
*inputdev
)
816 struct aiptek
*aiptek
= inputdev
->private;
818 usb_kill_urb(aiptek
->urb
);
821 /***********************************************************************
822 * aiptek_set_report and aiptek_get_report() are borrowed from Linux 2.4.x,
823 * where they were known as usb_set_report and usb_get_report.
826 aiptek_set_report(struct aiptek
*aiptek
,
827 unsigned char report_type
,
828 unsigned char report_id
, void *buffer
, int size
)
830 return usb_control_msg(aiptek
->usbdev
,
831 usb_sndctrlpipe(aiptek
->usbdev
, 0),
833 USB_TYPE_CLASS
| USB_RECIP_INTERFACE
|
834 USB_DIR_OUT
, (report_type
<< 8) + report_id
,
835 aiptek
->ifnum
, buffer
, size
, 5000);
839 aiptek_get_report(struct aiptek
*aiptek
,
840 unsigned char report_type
,
841 unsigned char report_id
, void *buffer
, int size
)
843 return usb_control_msg(aiptek
->usbdev
,
844 usb_rcvctrlpipe(aiptek
->usbdev
, 0),
846 USB_TYPE_CLASS
| USB_RECIP_INTERFACE
|
847 USB_DIR_IN
, (report_type
<< 8) + report_id
,
848 aiptek
->ifnum
, buffer
, size
, 5000);
851 /***********************************************************************
852 * Send a command to the tablet.
855 aiptek_command(struct aiptek
*aiptek
, unsigned char command
, unsigned char data
)
857 const int sizeof_buf
= 3 * sizeof(u8
);
861 buf
= kmalloc(sizeof_buf
, GFP_KERNEL
);
870 aiptek_set_report(aiptek
, 3, 2, buf
, sizeof_buf
)) != sizeof_buf
) {
871 dbg("aiptek_program: failed, tried to send: 0x%02x 0x%02x",
875 return ret
< 0 ? ret
: 0;
878 /***********************************************************************
879 * Retrieve information from the tablet. Querying info is defined as first
880 * sending the {command,data} sequence as a command, followed by a wait
881 * (aka, "programmaticDelay") and then a "read" request.
884 aiptek_query(struct aiptek
*aiptek
, unsigned char command
, unsigned char data
)
886 const int sizeof_buf
= 3 * sizeof(u8
);
890 buf
= kmalloc(sizeof_buf
, GFP_KERNEL
);
898 if (aiptek_command(aiptek
, command
, data
) != 0) {
902 msleep(aiptek
->curSetting
.programmableDelay
);
905 aiptek_get_report(aiptek
, 3, 2, buf
, sizeof_buf
)) != sizeof_buf
) {
906 dbg("aiptek_query failed: returned 0x%02x 0x%02x 0x%02x",
907 buf
[0], buf
[1], buf
[2]);
910 ret
= le16_to_cpu(get_unaligned((__le16
*) (buf
+ 1)));
916 /***********************************************************************
917 * Program the tablet into either absolute or relative mode.
918 * We also get information about the tablet's size.
920 static int aiptek_program_tablet(struct aiptek
*aiptek
)
923 /* Execute Resolution500LPI */
924 if ((ret
= aiptek_command(aiptek
, 0x18, 0x04)) < 0)
927 /* Query getModelCode */
928 if ((ret
= aiptek_query(aiptek
, 0x02, 0x00)) < 0)
930 aiptek
->features
.modelCode
= ret
& 0xff;
932 /* Query getODMCode */
933 if ((ret
= aiptek_query(aiptek
, 0x03, 0x00)) < 0)
935 aiptek
->features
.odmCode
= ret
;
937 /* Query getFirmwareCode */
938 if ((ret
= aiptek_query(aiptek
, 0x04, 0x00)) < 0)
940 aiptek
->features
.firmwareCode
= ret
;
942 /* Query getXextension */
943 if ((ret
= aiptek_query(aiptek
, 0x01, 0x00)) < 0)
945 aiptek
->inputdev
->absmin
[ABS_X
] = 0;
946 aiptek
->inputdev
->absmax
[ABS_X
] = ret
- 1;
948 /* Query getYextension */
949 if ((ret
= aiptek_query(aiptek
, 0x01, 0x01)) < 0)
951 aiptek
->inputdev
->absmin
[ABS_Y
] = 0;
952 aiptek
->inputdev
->absmax
[ABS_Y
] = ret
- 1;
954 /* Query getPressureLevels */
955 if ((ret
= aiptek_query(aiptek
, 0x08, 0x00)) < 0)
957 aiptek
->inputdev
->absmin
[ABS_PRESSURE
] = 0;
958 aiptek
->inputdev
->absmax
[ABS_PRESSURE
] = ret
- 1;
960 /* Depending on whether we are in absolute or relative mode, we will
961 * do a switchToTablet(absolute) or switchToMouse(relative) command.
963 if (aiptek
->curSetting
.coordinateMode
==
964 AIPTEK_COORDINATE_ABSOLUTE_MODE
) {
965 /* Execute switchToTablet */
966 if ((ret
= aiptek_command(aiptek
, 0x10, 0x01)) < 0) {
970 /* Execute switchToMouse */
971 if ((ret
= aiptek_command(aiptek
, 0x10, 0x00)) < 0) {
976 /* Enable the macro keys */
977 if ((ret
= aiptek_command(aiptek
, 0x11, 0x02)) < 0)
980 /* Execute FilterOn */
981 if ((ret
= aiptek_command(aiptek
, 0x17, 0x00)) < 0)
985 /* Execute AutoGainOn */
986 if ((ret
= aiptek_command(aiptek
, 0x12, 0xff)) < 0)
989 /* Reset the eventCount, so we track events from last (re)programming
991 aiptek
->diagnostic
= AIPTEK_DIAGNOSTIC_NA
;
992 aiptek
->eventCount
= 0;
997 /***********************************************************************
998 * Sysfs functions. Sysfs prefers that individually-tunable parameters
999 * exist in their separate pseudo-files. Summary data that is immutable
1000 * may exist in a singular file so long as you don't define a writeable
1004 /***********************************************************************
1005 * support the 'size' file -- display support
1007 static ssize_t
show_tabletSize(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1009 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1014 return snprintf(buf
, PAGE_SIZE
, "%dx%d\n",
1015 aiptek
->inputdev
->absmax
[ABS_X
] + 1,
1016 aiptek
->inputdev
->absmax
[ABS_Y
] + 1);
1019 /* These structs define the sysfs files, param #1 is the name of the
1020 * file, param 2 is the file permissions, param 3 & 4 are to the
1021 * output generator and input parser routines. Absence of a routine is
1022 * permitted -- it only means can't either 'cat' the file, or send data
1025 static DEVICE_ATTR(size
, S_IRUGO
, show_tabletSize
, NULL
);
1027 /***********************************************************************
1028 * support routines for the 'product_id' file
1030 static ssize_t
show_tabletProductId(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1032 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1037 return snprintf(buf
, PAGE_SIZE
, "0x%04x\n",
1038 aiptek
->inputdev
->id
.product
);
1041 static DEVICE_ATTR(product_id
, S_IRUGO
, show_tabletProductId
, NULL
);
1043 /***********************************************************************
1044 * support routines for the 'vendor_id' file
1046 static ssize_t
show_tabletVendorId(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1048 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1053 return snprintf(buf
, PAGE_SIZE
, "0x%04x\n", aiptek
->inputdev
->id
.vendor
);
1056 static DEVICE_ATTR(vendor_id
, S_IRUGO
, show_tabletVendorId
, NULL
);
1058 /***********************************************************************
1059 * support routines for the 'vendor' file
1061 static ssize_t
show_tabletManufacturer(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1063 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1069 retval
= snprintf(buf
, PAGE_SIZE
, "%s\n", aiptek
->usbdev
->manufacturer
);
1073 static DEVICE_ATTR(vendor
, S_IRUGO
, show_tabletManufacturer
, NULL
);
1075 /***********************************************************************
1076 * support routines for the 'product' file
1078 static ssize_t
show_tabletProduct(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1080 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1086 retval
= snprintf(buf
, PAGE_SIZE
, "%s\n", aiptek
->usbdev
->product
);
1090 static DEVICE_ATTR(product
, S_IRUGO
, show_tabletProduct
, NULL
);
1092 /***********************************************************************
1093 * support routines for the 'pointer_mode' file. Note that this file
1094 * both displays current setting and allows reprogramming.
1096 static ssize_t
show_tabletPointerMode(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1098 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1104 switch (aiptek
->curSetting
.pointerMode
) {
1105 case AIPTEK_POINTER_ONLY_STYLUS_MODE
:
1109 case AIPTEK_POINTER_ONLY_MOUSE_MODE
:
1113 case AIPTEK_POINTER_EITHER_MODE
:
1121 return snprintf(buf
, PAGE_SIZE
, "%s\n", s
);
1125 store_tabletPointerMode(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1127 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1131 if (strcmp(buf
, "stylus") == 0) {
1132 aiptek
->newSetting
.pointerMode
=
1133 AIPTEK_POINTER_ONLY_STYLUS_MODE
;
1134 } else if (strcmp(buf
, "mouse") == 0) {
1135 aiptek
->newSetting
.pointerMode
= AIPTEK_POINTER_ONLY_MOUSE_MODE
;
1136 } else if (strcmp(buf
, "either") == 0) {
1137 aiptek
->newSetting
.pointerMode
= AIPTEK_POINTER_EITHER_MODE
;
1142 static DEVICE_ATTR(pointer_mode
,
1144 show_tabletPointerMode
, store_tabletPointerMode
);
1146 /***********************************************************************
1147 * support routines for the 'coordinate_mode' file. Note that this file
1148 * both displays current setting and allows reprogramming.
1150 static ssize_t
show_tabletCoordinateMode(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1152 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1158 switch (aiptek
->curSetting
.coordinateMode
) {
1159 case AIPTEK_COORDINATE_ABSOLUTE_MODE
:
1163 case AIPTEK_COORDINATE_RELATIVE_MODE
:
1171 return snprintf(buf
, PAGE_SIZE
, "%s\n", s
);
1175 store_tabletCoordinateMode(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1177 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1181 if (strcmp(buf
, "absolute") == 0) {
1182 aiptek
->newSetting
.pointerMode
=
1183 AIPTEK_COORDINATE_ABSOLUTE_MODE
;
1184 } else if (strcmp(buf
, "relative") == 0) {
1185 aiptek
->newSetting
.pointerMode
=
1186 AIPTEK_COORDINATE_RELATIVE_MODE
;
1191 static DEVICE_ATTR(coordinate_mode
,
1193 show_tabletCoordinateMode
, store_tabletCoordinateMode
);
1195 /***********************************************************************
1196 * support routines for the 'tool_mode' file. Note that this file
1197 * both displays current setting and allows reprogramming.
1199 static ssize_t
show_tabletToolMode(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1201 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1207 switch (TOOL_BUTTON(aiptek
->curSetting
.toolMode
)) {
1208 case AIPTEK_TOOL_BUTTON_MOUSE_MODE
:
1212 case AIPTEK_TOOL_BUTTON_ERASER_MODE
:
1216 case AIPTEK_TOOL_BUTTON_PENCIL_MODE
:
1220 case AIPTEK_TOOL_BUTTON_PEN_MODE
:
1224 case AIPTEK_TOOL_BUTTON_BRUSH_MODE
:
1228 case AIPTEK_TOOL_BUTTON_AIRBRUSH_MODE
:
1232 case AIPTEK_TOOL_BUTTON_LENS_MODE
:
1240 return snprintf(buf
, PAGE_SIZE
, "%s\n", s
);
1244 store_tabletToolMode(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1246 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1250 if (strcmp(buf
, "mouse") == 0) {
1251 aiptek
->newSetting
.toolMode
= AIPTEK_TOOL_BUTTON_MOUSE_MODE
;
1252 } else if (strcmp(buf
, "eraser") == 0) {
1253 aiptek
->newSetting
.toolMode
= AIPTEK_TOOL_BUTTON_ERASER_MODE
;
1254 } else if (strcmp(buf
, "pencil") == 0) {
1255 aiptek
->newSetting
.toolMode
= AIPTEK_TOOL_BUTTON_PENCIL_MODE
;
1256 } else if (strcmp(buf
, "pen") == 0) {
1257 aiptek
->newSetting
.toolMode
= AIPTEK_TOOL_BUTTON_PEN_MODE
;
1258 } else if (strcmp(buf
, "brush") == 0) {
1259 aiptek
->newSetting
.toolMode
= AIPTEK_TOOL_BUTTON_BRUSH_MODE
;
1260 } else if (strcmp(buf
, "airbrush") == 0) {
1261 aiptek
->newSetting
.toolMode
= AIPTEK_TOOL_BUTTON_AIRBRUSH_MODE
;
1262 } else if (strcmp(buf
, "lens") == 0) {
1263 aiptek
->newSetting
.toolMode
= AIPTEK_TOOL_BUTTON_LENS_MODE
;
1269 static DEVICE_ATTR(tool_mode
,
1271 show_tabletToolMode
, store_tabletToolMode
);
1273 /***********************************************************************
1274 * support routines for the 'xtilt' file. Note that this file
1275 * both displays current setting and allows reprogramming.
1277 static ssize_t
show_tabletXtilt(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1279 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1284 if (aiptek
->curSetting
.xTilt
== AIPTEK_TILT_DISABLE
) {
1285 return snprintf(buf
, PAGE_SIZE
, "disable\n");
1287 return snprintf(buf
, PAGE_SIZE
, "%d\n",
1288 aiptek
->curSetting
.xTilt
);
1293 store_tabletXtilt(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1295 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1301 if (strcmp(buf
, "disable") == 0) {
1302 aiptek
->newSetting
.xTilt
= AIPTEK_TILT_DISABLE
;
1304 x
= (int)simple_strtol(buf
, NULL
, 10);
1305 if (x
>= AIPTEK_TILT_MIN
&& x
<= AIPTEK_TILT_MAX
) {
1306 aiptek
->newSetting
.xTilt
= x
;
1312 static DEVICE_ATTR(xtilt
,
1313 S_IRUGO
| S_IWUGO
, show_tabletXtilt
, store_tabletXtilt
);
1315 /***********************************************************************
1316 * support routines for the 'ytilt' file. Note that this file
1317 * both displays current setting and allows reprogramming.
1319 static ssize_t
show_tabletYtilt(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1321 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1326 if (aiptek
->curSetting
.yTilt
== AIPTEK_TILT_DISABLE
) {
1327 return snprintf(buf
, PAGE_SIZE
, "disable\n");
1329 return snprintf(buf
, PAGE_SIZE
, "%d\n",
1330 aiptek
->curSetting
.yTilt
);
1335 store_tabletYtilt(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1337 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1343 if (strcmp(buf
, "disable") == 0) {
1344 aiptek
->newSetting
.yTilt
= AIPTEK_TILT_DISABLE
;
1346 y
= (int)simple_strtol(buf
, NULL
, 10);
1347 if (y
>= AIPTEK_TILT_MIN
&& y
<= AIPTEK_TILT_MAX
) {
1348 aiptek
->newSetting
.yTilt
= y
;
1354 static DEVICE_ATTR(ytilt
,
1355 S_IRUGO
| S_IWUGO
, show_tabletYtilt
, store_tabletYtilt
);
1357 /***********************************************************************
1358 * support routines for the 'jitter' file. Note that this file
1359 * both displays current setting and allows reprogramming.
1361 static ssize_t
show_tabletJitterDelay(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1363 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1368 return snprintf(buf
, PAGE_SIZE
, "%d\n", aiptek
->curSetting
.jitterDelay
);
1372 store_tabletJitterDelay(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1374 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1379 aiptek
->newSetting
.jitterDelay
= (int)simple_strtol(buf
, NULL
, 10);
1383 static DEVICE_ATTR(jitter
,
1385 show_tabletJitterDelay
, store_tabletJitterDelay
);
1387 /***********************************************************************
1388 * support routines for the 'delay' file. Note that this file
1389 * both displays current setting and allows reprogramming.
1391 static ssize_t
show_tabletProgrammableDelay(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1393 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1398 return snprintf(buf
, PAGE_SIZE
, "%d\n",
1399 aiptek
->curSetting
.programmableDelay
);
1403 store_tabletProgrammableDelay(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1405 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1410 aiptek
->newSetting
.programmableDelay
= (int)simple_strtol(buf
, NULL
, 10);
1414 static DEVICE_ATTR(delay
,
1416 show_tabletProgrammableDelay
, store_tabletProgrammableDelay
);
1418 /***********************************************************************
1419 * support routines for the 'input_path' file. Note that this file
1420 * only displays current setting.
1422 static ssize_t
show_tabletInputDevice(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1424 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1429 return snprintf(buf
, PAGE_SIZE
, "/dev/input/%s\n",
1430 aiptek
->features
.inputPath
);
1433 static DEVICE_ATTR(input_path
, S_IRUGO
, show_tabletInputDevice
, NULL
);
1435 /***********************************************************************
1436 * support routines for the 'event_count' file. Note that this file
1437 * only displays current setting.
1439 static ssize_t
show_tabletEventsReceived(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1441 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1446 return snprintf(buf
, PAGE_SIZE
, "%ld\n", aiptek
->eventCount
);
1449 static DEVICE_ATTR(event_count
, S_IRUGO
, show_tabletEventsReceived
, NULL
);
1451 /***********************************************************************
1452 * support routines for the 'diagnostic' file. Note that this file
1453 * only displays current setting.
1455 static ssize_t
show_tabletDiagnosticMessage(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1457 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1463 switch (aiptek
->diagnostic
) {
1464 case AIPTEK_DIAGNOSTIC_NA
:
1465 retMsg
= "no errors\n";
1468 case AIPTEK_DIAGNOSTIC_SENDING_RELATIVE_IN_ABSOLUTE
:
1469 retMsg
= "Error: receiving relative reports\n";
1472 case AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE
:
1473 retMsg
= "Error: receiving absolute reports\n";
1476 case AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED
:
1477 if (aiptek
->curSetting
.pointerMode
==
1478 AIPTEK_POINTER_ONLY_MOUSE_MODE
) {
1479 retMsg
= "Error: receiving stylus reports\n";
1481 retMsg
= "Error: receiving mouse reports\n";
1488 return snprintf(buf
, PAGE_SIZE
, retMsg
);
1491 static DEVICE_ATTR(diagnostic
, S_IRUGO
, show_tabletDiagnosticMessage
, NULL
);
1493 /***********************************************************************
1494 * support routines for the 'stylus_upper' file. Note that this file
1495 * both displays current setting and allows for setting changing.
1497 static ssize_t
show_tabletStylusUpper(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1499 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1505 switch (aiptek
->curSetting
.stylusButtonUpper
) {
1506 case AIPTEK_STYLUS_UPPER_BUTTON
:
1510 case AIPTEK_STYLUS_LOWER_BUTTON
:
1518 return snprintf(buf
, PAGE_SIZE
, "%s\n", s
);
1522 store_tabletStylusUpper(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1524 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1529 if (strcmp(buf
, "upper") == 0) {
1530 aiptek
->newSetting
.stylusButtonUpper
=
1531 AIPTEK_STYLUS_UPPER_BUTTON
;
1532 } else if (strcmp(buf
, "lower") == 0) {
1533 aiptek
->newSetting
.stylusButtonUpper
=
1534 AIPTEK_STYLUS_LOWER_BUTTON
;
1539 static DEVICE_ATTR(stylus_upper
,
1541 show_tabletStylusUpper
, store_tabletStylusUpper
);
1543 /***********************************************************************
1544 * support routines for the 'stylus_lower' file. Note that this file
1545 * both displays current setting and allows for setting changing.
1547 static ssize_t
show_tabletStylusLower(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1549 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1555 switch (aiptek
->curSetting
.stylusButtonLower
) {
1556 case AIPTEK_STYLUS_UPPER_BUTTON
:
1560 case AIPTEK_STYLUS_LOWER_BUTTON
:
1568 return snprintf(buf
, PAGE_SIZE
, "%s\n", s
);
1572 store_tabletStylusLower(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1574 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1579 if (strcmp(buf
, "upper") == 0) {
1580 aiptek
->newSetting
.stylusButtonLower
=
1581 AIPTEK_STYLUS_UPPER_BUTTON
;
1582 } else if (strcmp(buf
, "lower") == 0) {
1583 aiptek
->newSetting
.stylusButtonLower
=
1584 AIPTEK_STYLUS_LOWER_BUTTON
;
1589 static DEVICE_ATTR(stylus_lower
,
1591 show_tabletStylusLower
, store_tabletStylusLower
);
1593 /***********************************************************************
1594 * support routines for the 'mouse_left' file. Note that this file
1595 * both displays current setting and allows for setting changing.
1597 static ssize_t
show_tabletMouseLeft(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1599 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1605 switch (aiptek
->curSetting
.mouseButtonLeft
) {
1606 case AIPTEK_MOUSE_LEFT_BUTTON
:
1610 case AIPTEK_MOUSE_MIDDLE_BUTTON
:
1614 case AIPTEK_MOUSE_RIGHT_BUTTON
:
1622 return snprintf(buf
, PAGE_SIZE
, "%s\n", s
);
1626 store_tabletMouseLeft(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1628 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1633 if (strcmp(buf
, "left") == 0) {
1634 aiptek
->newSetting
.mouseButtonLeft
= AIPTEK_MOUSE_LEFT_BUTTON
;
1635 } else if (strcmp(buf
, "middle") == 0) {
1636 aiptek
->newSetting
.mouseButtonLeft
= AIPTEK_MOUSE_MIDDLE_BUTTON
;
1637 } else if (strcmp(buf
, "right") == 0) {
1638 aiptek
->newSetting
.mouseButtonLeft
= AIPTEK_MOUSE_RIGHT_BUTTON
;
1643 static DEVICE_ATTR(mouse_left
,
1645 show_tabletMouseLeft
, store_tabletMouseLeft
);
1647 /***********************************************************************
1648 * support routines for the 'mouse_middle' file. Note that this file
1649 * both displays current setting and allows for setting changing.
1651 static ssize_t
show_tabletMouseMiddle(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1653 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1659 switch (aiptek
->curSetting
.mouseButtonMiddle
) {
1660 case AIPTEK_MOUSE_LEFT_BUTTON
:
1664 case AIPTEK_MOUSE_MIDDLE_BUTTON
:
1668 case AIPTEK_MOUSE_RIGHT_BUTTON
:
1676 return snprintf(buf
, PAGE_SIZE
, "%s\n", s
);
1680 store_tabletMouseMiddle(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1682 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1687 if (strcmp(buf
, "left") == 0) {
1688 aiptek
->newSetting
.mouseButtonMiddle
= AIPTEK_MOUSE_LEFT_BUTTON
;
1689 } else if (strcmp(buf
, "middle") == 0) {
1690 aiptek
->newSetting
.mouseButtonMiddle
=
1691 AIPTEK_MOUSE_MIDDLE_BUTTON
;
1692 } else if (strcmp(buf
, "right") == 0) {
1693 aiptek
->newSetting
.mouseButtonMiddle
=
1694 AIPTEK_MOUSE_RIGHT_BUTTON
;
1699 static DEVICE_ATTR(mouse_middle
,
1701 show_tabletMouseMiddle
, store_tabletMouseMiddle
);
1703 /***********************************************************************
1704 * support routines for the 'mouse_right' file. Note that this file
1705 * both displays current setting and allows for setting changing.
1707 static ssize_t
show_tabletMouseRight(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1709 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1715 switch (aiptek
->curSetting
.mouseButtonRight
) {
1716 case AIPTEK_MOUSE_LEFT_BUTTON
:
1720 case AIPTEK_MOUSE_MIDDLE_BUTTON
:
1724 case AIPTEK_MOUSE_RIGHT_BUTTON
:
1732 return snprintf(buf
, PAGE_SIZE
, "%s\n", s
);
1736 store_tabletMouseRight(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1738 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1743 if (strcmp(buf
, "left") == 0) {
1744 aiptek
->newSetting
.mouseButtonRight
= AIPTEK_MOUSE_LEFT_BUTTON
;
1745 } else if (strcmp(buf
, "middle") == 0) {
1746 aiptek
->newSetting
.mouseButtonRight
=
1747 AIPTEK_MOUSE_MIDDLE_BUTTON
;
1748 } else if (strcmp(buf
, "right") == 0) {
1749 aiptek
->newSetting
.mouseButtonRight
= AIPTEK_MOUSE_RIGHT_BUTTON
;
1754 static DEVICE_ATTR(mouse_right
,
1756 show_tabletMouseRight
, store_tabletMouseRight
);
1758 /***********************************************************************
1759 * support routines for the 'wheel' file. Note that this file
1760 * both displays current setting and allows for setting changing.
1762 static ssize_t
show_tabletWheel(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1764 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1769 if (aiptek
->curSetting
.wheel
== AIPTEK_WHEEL_DISABLE
) {
1770 return snprintf(buf
, PAGE_SIZE
, "disable\n");
1772 return snprintf(buf
, PAGE_SIZE
, "%d\n",
1773 aiptek
->curSetting
.wheel
);
1778 store_tabletWheel(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1780 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1785 aiptek
->newSetting
.wheel
= (int)simple_strtol(buf
, NULL
, 10);
1789 static DEVICE_ATTR(wheel
,
1790 S_IRUGO
| S_IWUGO
, show_tabletWheel
, store_tabletWheel
);
1792 /***********************************************************************
1793 * support routines for the 'execute' file. Note that this file
1794 * both displays current setting and allows for setting changing.
1796 static ssize_t
show_tabletExecute(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1798 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1803 /* There is nothing useful to display, so a one-line manual
1806 return snprintf(buf
, PAGE_SIZE
,
1807 "Write anything to this file to program your tablet.\n");
1811 store_tabletExecute(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1813 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1818 /* We do not care what you write to this file. Merely the action
1819 * of writing to this file triggers a tablet reprogramming.
1821 memcpy(&aiptek
->curSetting
, &aiptek
->newSetting
,
1822 sizeof(struct aiptek_settings
));
1824 if (aiptek_program_tablet(aiptek
) < 0)
1830 static DEVICE_ATTR(execute
,
1831 S_IRUGO
| S_IWUGO
, show_tabletExecute
, store_tabletExecute
);
1833 /***********************************************************************
1834 * support routines for the 'odm_code' file. Note that this file
1835 * only displays current setting.
1837 static ssize_t
show_tabletODMCode(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1839 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1844 return snprintf(buf
, PAGE_SIZE
, "0x%04x\n", aiptek
->features
.odmCode
);
1847 static DEVICE_ATTR(odm_code
, S_IRUGO
, show_tabletODMCode
, NULL
);
1849 /***********************************************************************
1850 * support routines for the 'model_code' file. Note that this file
1851 * only displays current setting.
1853 static ssize_t
show_tabletModelCode(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1855 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1860 return snprintf(buf
, PAGE_SIZE
, "0x%04x\n", aiptek
->features
.modelCode
);
1863 static DEVICE_ATTR(model_code
, S_IRUGO
, show_tabletModelCode
, NULL
);
1865 /***********************************************************************
1866 * support routines for the 'firmware_code' file. Note that this file
1867 * only displays current setting.
1869 static ssize_t
show_firmwareCode(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1871 struct aiptek
*aiptek
= dev_get_drvdata(dev
);
1876 return snprintf(buf
, PAGE_SIZE
, "%04x\n",
1877 aiptek
->features
.firmwareCode
);
1880 static DEVICE_ATTR(firmware_code
, S_IRUGO
, show_firmwareCode
, NULL
);
1882 /***********************************************************************
1883 * This routine removes all existing sysfs files managed by this device
1886 static void aiptek_delete_files(struct device
*dev
)
1888 device_remove_file(dev
, &dev_attr_size
);
1889 device_remove_file(dev
, &dev_attr_product_id
);
1890 device_remove_file(dev
, &dev_attr_vendor_id
);
1891 device_remove_file(dev
, &dev_attr_vendor
);
1892 device_remove_file(dev
, &dev_attr_product
);
1893 device_remove_file(dev
, &dev_attr_pointer_mode
);
1894 device_remove_file(dev
, &dev_attr_coordinate_mode
);
1895 device_remove_file(dev
, &dev_attr_tool_mode
);
1896 device_remove_file(dev
, &dev_attr_xtilt
);
1897 device_remove_file(dev
, &dev_attr_ytilt
);
1898 device_remove_file(dev
, &dev_attr_jitter
);
1899 device_remove_file(dev
, &dev_attr_delay
);
1900 device_remove_file(dev
, &dev_attr_input_path
);
1901 device_remove_file(dev
, &dev_attr_event_count
);
1902 device_remove_file(dev
, &dev_attr_diagnostic
);
1903 device_remove_file(dev
, &dev_attr_odm_code
);
1904 device_remove_file(dev
, &dev_attr_model_code
);
1905 device_remove_file(dev
, &dev_attr_firmware_code
);
1906 device_remove_file(dev
, &dev_attr_stylus_lower
);
1907 device_remove_file(dev
, &dev_attr_stylus_upper
);
1908 device_remove_file(dev
, &dev_attr_mouse_left
);
1909 device_remove_file(dev
, &dev_attr_mouse_middle
);
1910 device_remove_file(dev
, &dev_attr_mouse_right
);
1911 device_remove_file(dev
, &dev_attr_wheel
);
1912 device_remove_file(dev
, &dev_attr_execute
);
1915 /***********************************************************************
1916 * This routine creates the sysfs files managed by this device
1919 static int aiptek_add_files(struct device
*dev
)
1923 if ((ret
= device_create_file(dev
, &dev_attr_size
)) ||
1924 (ret
= device_create_file(dev
, &dev_attr_product_id
)) ||
1925 (ret
= device_create_file(dev
, &dev_attr_vendor_id
)) ||
1926 (ret
= device_create_file(dev
, &dev_attr_vendor
)) ||
1927 (ret
= device_create_file(dev
, &dev_attr_product
)) ||
1928 (ret
= device_create_file(dev
, &dev_attr_pointer_mode
)) ||
1929 (ret
= device_create_file(dev
, &dev_attr_coordinate_mode
)) ||
1930 (ret
= device_create_file(dev
, &dev_attr_tool_mode
)) ||
1931 (ret
= device_create_file(dev
, &dev_attr_xtilt
)) ||
1932 (ret
= device_create_file(dev
, &dev_attr_ytilt
)) ||
1933 (ret
= device_create_file(dev
, &dev_attr_jitter
)) ||
1934 (ret
= device_create_file(dev
, &dev_attr_delay
)) ||
1935 (ret
= device_create_file(dev
, &dev_attr_input_path
)) ||
1936 (ret
= device_create_file(dev
, &dev_attr_event_count
)) ||
1937 (ret
= device_create_file(dev
, &dev_attr_diagnostic
)) ||
1938 (ret
= device_create_file(dev
, &dev_attr_odm_code
)) ||
1939 (ret
= device_create_file(dev
, &dev_attr_model_code
)) ||
1940 (ret
= device_create_file(dev
, &dev_attr_firmware_code
)) ||
1941 (ret
= device_create_file(dev
, &dev_attr_stylus_lower
)) ||
1942 (ret
= device_create_file(dev
, &dev_attr_stylus_upper
)) ||
1943 (ret
= device_create_file(dev
, &dev_attr_mouse_left
)) ||
1944 (ret
= device_create_file(dev
, &dev_attr_mouse_middle
)) ||
1945 (ret
= device_create_file(dev
, &dev_attr_mouse_right
)) ||
1946 (ret
= device_create_file(dev
, &dev_attr_wheel
)) ||
1947 (ret
= device_create_file(dev
, &dev_attr_execute
))) {
1948 err("aiptek: killing own sysfs device files\n");
1949 aiptek_delete_files(dev
);
1954 /***********************************************************************
1955 * This routine is called when a tablet has been identified. It basically
1956 * sets up the tablet and the driver's internal structures.
1959 aiptek_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
)
1961 struct usb_device
*usbdev
= interface_to_usbdev(intf
);
1962 struct usb_endpoint_descriptor
*endpoint
;
1963 struct aiptek
*aiptek
;
1964 struct input_dev
*inputdev
;
1965 struct input_handle
*inputhandle
;
1966 struct list_head
*node
, *next
;
1969 AIPTEK_PROGRAMMABLE_DELAY_50
,
1970 AIPTEK_PROGRAMMABLE_DELAY_400
,
1971 AIPTEK_PROGRAMMABLE_DELAY_25
,
1972 AIPTEK_PROGRAMMABLE_DELAY_100
,
1973 AIPTEK_PROGRAMMABLE_DELAY_200
,
1974 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 SLAB_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
->cdev
.dev
= &intf
->dev
;
2048 inputdev
->private = aiptek
;
2049 inputdev
->open
= aiptek_open
;
2050 inputdev
->close
= aiptek_close
;
2052 /* Now program the capacities of the tablet, in terms of being
2055 inputdev
->evbit
[0] |= BIT(EV_KEY
)
2060 inputdev
->absbit
[0] |= BIT(ABS_MISC
);
2062 inputdev
->relbit
[0] |=
2063 (BIT(REL_X
) | BIT(REL_Y
) | BIT(REL_WHEEL
) | BIT(REL_MISC
));
2065 inputdev
->keybit
[LONG(BTN_LEFT
)] |=
2066 (BIT(BTN_LEFT
) | BIT(BTN_RIGHT
) | BIT(BTN_MIDDLE
));
2068 inputdev
->keybit
[LONG(BTN_DIGI
)] |=
2069 (BIT(BTN_TOOL_PEN
) |
2070 BIT(BTN_TOOL_RUBBER
) |
2071 BIT(BTN_TOOL_PENCIL
) |
2072 BIT(BTN_TOOL_AIRBRUSH
) |
2073 BIT(BTN_TOOL_BRUSH
) |
2074 BIT(BTN_TOOL_MOUSE
) |
2075 BIT(BTN_TOOL_LENS
) |
2076 BIT(BTN_TOUCH
) | BIT(BTN_STYLUS
) | BIT(BTN_STYLUS2
));
2078 inputdev
->mscbit
[0] = BIT(MSC_SERIAL
);
2080 /* Programming the tablet macro keys needs to be done with a for loop
2081 * as the keycodes are discontiguous.
2083 for (i
= 0; i
< ARRAY_SIZE(macroKeyEvents
); ++i
)
2084 set_bit(macroKeyEvents
[i
], inputdev
->keybit
);
2087 * Program the input device coordinate capacities. We do not yet
2088 * know what maximum X, Y, and Z values are, so we're putting fake
2089 * values in. Later, we'll ask the tablet to put in the correct
2092 input_set_abs_params(inputdev
, ABS_X
, 0, 2999, 0, 0);
2093 input_set_abs_params(inputdev
, ABS_Y
, 0, 2249, 0, 0);
2094 input_set_abs_params(inputdev
, ABS_PRESSURE
, 0, 511, 0, 0);
2095 input_set_abs_params(inputdev
, ABS_TILT_X
, AIPTEK_TILT_MIN
, AIPTEK_TILT_MAX
, 0, 0);
2096 input_set_abs_params(inputdev
, ABS_TILT_Y
, AIPTEK_TILT_MIN
, AIPTEK_TILT_MAX
, 0, 0);
2097 input_set_abs_params(inputdev
, ABS_WHEEL
, AIPTEK_WHEEL_MIN
, AIPTEK_WHEEL_MAX
- 1, 0, 0);
2099 endpoint
= &intf
->altsetting
[0].endpoint
[0].desc
;
2101 /* Go set up our URB, which is called when the tablet receives
2104 usb_fill_int_urb(aiptek
->urb
,
2106 usb_rcvintpipe(aiptek
->usbdev
,
2107 endpoint
->bEndpointAddress
),
2108 aiptek
->data
, 8, aiptek_irq
, aiptek
,
2109 endpoint
->bInterval
);
2111 aiptek
->urb
->transfer_dma
= aiptek
->data_dma
;
2112 aiptek
->urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
2114 /* Program the tablet. This sets the tablet up in the mode
2115 * specified in newSetting, and also queries the tablet's
2116 * physical capacities.
2118 * Sanity check: if a tablet doesn't like the slow programmatic
2119 * delay, we often get sizes of 0x0. Let's use that as an indicator
2120 * to try faster delays, up to 25 ms. If that logic fails, well, you'll
2121 * have to explain to us how your tablet thinks it's 0x0, and yet that's
2125 for (i
= 0; i
< ARRAY_SIZE(speeds
); ++i
) {
2126 aiptek
->curSetting
.programmableDelay
= speeds
[i
];
2127 (void)aiptek_program_tablet(aiptek
);
2128 if (aiptek
->inputdev
->absmax
[ABS_X
] > 0) {
2129 info("input: Aiptek using %d ms programming speed\n",
2130 aiptek
->curSetting
.programmableDelay
);
2135 /* Register the tablet as an Input Device
2137 input_register_device(aiptek
->inputdev
);
2139 /* We now will look for the evdev device which is mapped to
2140 * the tablet. The partial name is kept in the link list of
2141 * input_handles associated with this input device.
2142 * What identifies an evdev input_handler is that it begins
2143 * with 'event', continues with a digit, and that in turn
2144 * is mapped to input/eventN.
2146 list_for_each_safe(node
, next
, &inputdev
->h_list
) {
2147 inputhandle
= to_handle(node
);
2148 if (strncmp(inputhandle
->name
, "event", 5) == 0) {
2149 strcpy(aiptek
->features
.inputPath
, inputhandle
->name
);
2154 /* Associate this driver's struct with the usb interface.
2156 usb_set_intfdata(intf
, aiptek
);
2158 /* Set up the sysfs files
2160 aiptek_add_files(&intf
->dev
);
2162 /* Make sure the evdev module is loaded. Assuming evdev IS a module :-)
2164 if (request_module("evdev") != 0)
2165 info("aiptek: error loading 'evdev' module");
2169 fail2
: usb_buffer_free(usbdev
, AIPTEK_PACKET_LENGTH
, aiptek
->data
,
2171 fail1
: input_free_device(inputdev
);
2176 /* Forward declaration */
2177 static void aiptek_disconnect(struct usb_interface
*intf
);
2179 static struct usb_driver aiptek_driver
= {
2181 .probe
= aiptek_probe
,
2182 .disconnect
= aiptek_disconnect
,
2183 .id_table
= aiptek_ids
,
2186 /***********************************************************************
2187 * Deal with tablet disconnecting from the system.
2189 static void aiptek_disconnect(struct usb_interface
*intf
)
2191 struct aiptek
*aiptek
= usb_get_intfdata(intf
);
2193 /* Disassociate driver's struct with usb interface
2195 usb_set_intfdata(intf
, NULL
);
2196 if (aiptek
!= NULL
) {
2197 /* Free & unhook everything from the system.
2199 usb_kill_urb(aiptek
->urb
);
2200 input_unregister_device(aiptek
->inputdev
);
2201 aiptek_delete_files(&intf
->dev
);
2202 usb_free_urb(aiptek
->urb
);
2203 usb_buffer_free(interface_to_usbdev(intf
),
2204 AIPTEK_PACKET_LENGTH
,
2205 aiptek
->data
, aiptek
->data_dma
);
2210 static int __init
aiptek_init(void)
2212 int result
= usb_register(&aiptek_driver
);
2214 info(DRIVER_VERSION
": " DRIVER_AUTHOR
);
2220 static void __exit
aiptek_exit(void)
2222 usb_deregister(&aiptek_driver
);
2225 MODULE_AUTHOR(DRIVER_AUTHOR
);
2226 MODULE_DESCRIPTION(DRIVER_DESC
);
2227 MODULE_LICENSE("GPL");
2229 module_param(programmableDelay
, int, 0);
2230 MODULE_PARM_DESC(programmableDelay
, "delay used during tablet programming");
2231 module_param(jitterDelay
, int, 0);
2232 MODULE_PARM_DESC(jitterDelay
, "stylus/mouse settlement delay");
2234 module_init(aiptek_init
);
2235 module_exit(aiptek_exit
);