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/input.h>
77 #include <linux/module.h>
78 #include <linux/init.h>
79 #include <linux/usb.h>
80 #include <linux/sched.h>
81 #include <asm/uaccess.h>
82 #include <asm/unaligned.h>
87 #define DRIVER_VERSION "v1.5 (May-15-2004)"
88 #define DRIVER_AUTHOR "Bryan W. Headley/Chris Atenasio"
89 #define DRIVER_DESC "Aiptek HyperPen USB Tablet Driver (Linux 2.6.x)"
92 * Aiptek status packet:
94 * (returned as Report 1 - relative coordinates from mouse and stylus)
96 * bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0
97 * byte0 0 0 0 0 0 0 0 1
98 * byte1 0 0 0 0 0 BS2 BS Tip
99 * byte2 X7 X6 X5 X4 X3 X2 X1 X0
100 * byte3 Y7 Y6 Y5 Y4 Y3 Y2 Y1 Y0
102 * (returned as Report 2 - absolute coordinates from the stylus)
104 * bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0
105 * byte0 0 0 0 0 0 0 1 0
106 * byte1 X7 X6 X5 X4 X3 X2 X1 X0
107 * byte2 X15 X14 X13 X12 X11 X10 X9 X8
108 * byte3 Y7 Y6 Y5 Y4 Y3 Y2 Y1 Y0
109 * byte4 Y15 Y14 Y13 Y12 Y11 Y10 Y9 Y8
110 * byte5 * * * BS2 BS1 Tip IR DV
111 * byte6 P7 P6 P5 P4 P3 P2 P1 P0
112 * byte7 P15 P14 P13 P12 P11 P10 P9 P8
114 * (returned as Report 3 - absolute coordinates from the mouse)
116 * bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0
117 * byte0 0 0 0 0 0 0 1 0
118 * byte1 X7 X6 X5 X4 X3 X2 X1 X0
119 * byte2 X15 X14 X13 X12 X11 X10 X9 X8
120 * byte3 Y7 Y6 Y5 Y4 Y3 Y2 Y1 Y0
121 * byte4 Y15 Y14 Y13 Y12 Y11 Y10 Y9 Y8
122 * byte5 * * * BS2 BS1 Tip IR DV
123 * byte6 P7 P6 P5 P4 P3 P2 P1 P0
124 * byte7 P15 P14 P13 P12 P11 P10 P9 P8
126 * (returned as Report 4 - macrokeys from the stylus)
128 * bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0
129 * byte0 0 0 0 0 0 1 0 0
130 * byte1 0 0 0 BS2 BS Tip IR DV
131 * byte2 0 0 0 0 0 0 1 0
132 * byte3 0 0 0 K4 K3 K2 K1 K0
133 * byte4 P7 P6 P5 P4 P3 P2 P1 P0
134 * byte5 P15 P14 P13 P12 P11 P10 P9 P8
136 * (returned as Report 5 - macrokeys from the mouse)
138 * bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0
139 * byte0 0 0 0 0 0 1 0 0
140 * byte1 0 0 0 BS2 BS Tip IR DV
141 * byte2 0 0 0 0 0 0 1 0
142 * byte3 0 0 0 K4 K3 K2 K1 K0
143 * byte4 P7 P6 P5 P4 P3 P2 P1 P0
144 * byte5 P15 P14 P13 P12 P11 P10 P9 P8
146 * IR: In Range = Proximity on
148 * BS = Barrel Switch (as in, macro keys)
149 * BS2 also referred to as Tablet Pick
153 * Use report_type CONTROL (3)
156 * Command/Data Description Return Bytes Return Value
157 * 0x10/0x00 SwitchToMouse 0
158 * 0x10/0x01 SwitchToTablet 0
159 * 0x18/0x04 SetResolution 0
160 * 0x12/0xFF AutoGainOn 0
161 * 0x17/0x00 FilterOn 0
162 * 0x01/0x00 GetXExtension 2 MaxX
163 * 0x01/0x01 GetYExtension 2 MaxY
164 * 0x02/0x00 GetModelCode 2 ModelCode = LOBYTE
165 * 0x03/0x00 GetODMCode 2 ODMCode
166 * 0x08/0x00 GetPressureLevels 2 =512
167 * 0x04/0x00 GetFirmwareVersion 2 Firmware Version
168 * 0x11/0x02 EnableMacroKeys 0
170 * To initialize the tablet:
172 * (1) Send Resolution500LPI (Command)
173 * (2) Query for Model code (Option Report)
174 * (3) Query for ODM code (Option Report)
175 * (4) Query for firmware (Option Report)
176 * (5) Query for GetXExtension (Option Report)
177 * (6) Query for GetYExtension (Option Report)
178 * (7) Query for GetPressureLevels (Option Report)
179 * (8) SwitchToTablet for Absolute coordinates, or
180 * SwitchToMouse for Relative coordinates (Command)
181 * (9) EnableMacroKeys (Command)
182 * (10) FilterOn (Command)
183 * (11) AutoGainOn (Command)
185 * (Step 9 can be omitted, but you'll then have no function keys.)
188 #define USB_VENDOR_ID_AIPTEK 0x08ca
189 #define USB_REQ_GET_REPORT 0x01
190 #define USB_REQ_SET_REPORT 0x09
194 #define AIPTEK_POINTER_ONLY_MOUSE_MODE 0
195 #define AIPTEK_POINTER_ONLY_STYLUS_MODE 1
196 #define AIPTEK_POINTER_EITHER_MODE 2
198 #define AIPTEK_POINTER_ALLOW_MOUSE_MODE(a) \
199 (a == AIPTEK_POINTER_ONLY_MOUSE_MODE || \
200 a == AIPTEK_POINTER_EITHER_MODE)
201 #define AIPTEK_POINTER_ALLOW_STYLUS_MODE(a) \
202 (a == AIPTEK_POINTER_ONLY_STYLUS_MODE || \
203 a == AIPTEK_POINTER_EITHER_MODE)
205 /* CoordinateMode code
207 #define AIPTEK_COORDINATE_RELATIVE_MODE 0
208 #define AIPTEK_COORDINATE_ABSOLUTE_MODE 1
210 /* XTilt and YTilt values
212 #define AIPTEK_TILT_MIN (-128)
213 #define AIPTEK_TILT_MAX 127
214 #define AIPTEK_TILT_DISABLE (-10101)
218 #define AIPTEK_WHEEL_MIN 0
219 #define AIPTEK_WHEEL_MAX 1024
220 #define AIPTEK_WHEEL_DISABLE (-10101)
222 /* ToolCode values, which BTW are 0x140 .. 0x14f
223 * We have things set up such that if TOOL_BUTTON_FIRED_BIT is
224 * not set, we'll send one instance of AIPTEK_TOOL_BUTTON_xxx.
226 * Whenever the user resets the value, TOOL_BUTTON_FIRED_BIT will
229 #define TOOL_BUTTON(x) ((x) & 0x14f)
230 #define TOOL_BUTTON_FIRED(x) ((x) & 0x200)
231 #define TOOL_BUTTON_FIRED_BIT 0x200
234 #define AIPTEK_TOOL_BUTTON_PEN_MODE BTN_TOOL_PEN
235 #define AIPTEK_TOOL_BUTTON_PEN_MODE BTN_TOOL_PEN
236 #define AIPTEK_TOOL_BUTTON_PENCIL_MODE BTN_TOOL_PENCIL
237 #define AIPTEK_TOOL_BUTTON_BRUSH_MODE BTN_TOOL_BRUSH
238 #define AIPTEK_TOOL_BUTTON_AIRBRUSH_MODE BTN_TOOL_AIRBRUSH
239 #define AIPTEK_TOOL_BUTTON_ERASER_MODE BTN_TOOL_RUBBER
240 #define AIPTEK_TOOL_BUTTON_MOUSE_MODE BTN_TOOL_MOUSE
241 #define AIPTEK_TOOL_BUTTON_LENS_MODE BTN_TOOL_LENS
243 /* Diagnostic message codes
245 #define AIPTEK_DIAGNOSTIC_NA 0
246 #define AIPTEK_DIAGNOSTIC_SENDING_RELATIVE_IN_ABSOLUTE 1
247 #define AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE 2
248 #define AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED 3
250 /* Time to wait (in ms) to help mask hand jittering
251 * when pressing the stylus buttons.
253 #define AIPTEK_JITTER_DELAY_DEFAULT 50
255 /* Time to wait (in ms) in-between sending the tablet
256 * a command and beginning the process of reading the return
257 * sequence from the tablet.
259 #define AIPTEK_PROGRAMMABLE_DELAY_25 25
260 #define AIPTEK_PROGRAMMABLE_DELAY_50 50
261 #define AIPTEK_PROGRAMMABLE_DELAY_100 100
262 #define AIPTEK_PROGRAMMABLE_DELAY_200 200
263 #define AIPTEK_PROGRAMMABLE_DELAY_300 300
264 #define AIPTEK_PROGRAMMABLE_DELAY_400 400
265 #define AIPTEK_PROGRAMMABLE_DELAY_DEFAULT AIPTEK_PROGRAMMABLE_DELAY_400
267 /* Mouse button programming
269 #define AIPTEK_MOUSE_LEFT_BUTTON 0x01
270 #define AIPTEK_MOUSE_RIGHT_BUTTON 0x02
271 #define AIPTEK_MOUSE_MIDDLE_BUTTON 0x04
273 /* Stylus button programming
275 #define AIPTEK_STYLUS_LOWER_BUTTON 0x08
276 #define AIPTEK_STYLUS_UPPER_BUTTON 0x10
278 /* Length of incoming packet from the tablet
280 #define AIPTEK_PACKET_LENGTH 8
282 /* We report in EV_MISC both the proximity and
283 * whether the report came from the stylus, tablet mouse
284 * or "unknown" -- Unknown when the tablet is in relative
285 * mode, because we only get report 1's.
287 #define AIPTEK_REPORT_TOOL_UNKNOWN 0x10
288 #define AIPTEK_REPORT_TOOL_STYLUS 0x20
289 #define AIPTEK_REPORT_TOOL_MOUSE 0x40
291 static int programmableDelay = AIPTEK_PROGRAMMABLE_DELAY_DEFAULT;
292 static int jitterDelay = AIPTEK_JITTER_DELAY_DEFAULT;
294 struct aiptek_features {
295 int odmCode; /* Tablet manufacturer code */
296 int modelCode; /* Tablet model code (not unique) */
297 int firmwareCode; /* prom/eeprom version */
298 char usbPath[64 + 1]; /* device's physical usb path */
299 char inputPath[64 + 1]; /* input device path */
302 struct aiptek_settings {
303 int pointerMode; /* stylus-, mouse-only or either */
304 int coordinateMode; /* absolute/relative coords */
305 int toolMode; /* pen, pencil, brush, etc. tool */
306 int xTilt; /* synthetic xTilt amount */
307 int yTilt; /* synthetic yTilt amount */
308 int wheel; /* synthetic wheel amount */
309 int stylusButtonUpper; /* stylus upper btn delivers... */
310 int stylusButtonLower; /* stylus lower btn delivers... */
311 int mouseButtonLeft; /* mouse left btn delivers... */
312 int mouseButtonMiddle; /* mouse middle btn delivers... */
313 int mouseButtonRight; /* mouse right btn delivers... */
314 int programmableDelay; /* delay for tablet programming */
315 int jitterDelay; /* delay for hand jittering */
319 struct input_dev inputdev; /* input device struct */
320 struct usb_device *usbdev; /* usb device struct */
321 struct urb *urb; /* urb for incoming reports */
322 dma_addr_t data_dma; /* our dma stuffage */
323 struct aiptek_features features; /* tablet's array of features */
324 struct aiptek_settings curSetting; /* tablet's current programmable */
325 struct aiptek_settings newSetting; /* ... and new param settings */
326 unsigned int ifnum; /* interface number for IO */
327 int diagnostic; /* tablet diagnostic codes */
328 unsigned long eventCount; /* event count */
329 int inDelay; /* jitter: in jitter delay? */
330 unsigned long endDelay; /* jitter: time when delay ends */
331 int previousJitterable; /* jitterable prev value */
332 unsigned char *data; /* incoming packet data */
336 * Permit easy lookup of keyboard events to send, versus
337 * the bitmap which comes from the tablet. This hides the
338 * issue that the F_keys are not sequentially numbered.
340 static int macroKeyEvents[] = {
341 KEY_ESC, KEY_F1, KEY_F2, KEY_F3, KEY_F4, KEY_F5,
342 KEY_F6, KEY_F7, KEY_F8, KEY_F9, KEY_F10, KEY_F11,
343 KEY_F12, KEY_F13, KEY_F14, KEY_F15, KEY_F16, KEY_F17,
344 KEY_F18, KEY_F19, KEY_F20, KEY_F21, KEY_F22, KEY_F23,
345 KEY_F24, KEY_STOP, KEY_AGAIN, KEY_PROPS, KEY_UNDO,
346 KEY_FRONT, KEY_COPY, KEY_OPEN, KEY_PASTE, 0
349 /***********************************************************************
350 * Relative reports deliver values in 2's complement format to
351 * deal with negative offsets.
353 static int aiptek_convert_from_2s_complement(unsigned char c)
359 if ((b & 0x80) != 0) {
365 ret = (negate == 1) ? -ret : ret;
369 /***********************************************************************
370 * aiptek_irq can receive one of six potential reports.
371 * The documentation for each is in the body of the function.
373 * The tablet reports on several attributes per invocation of
374 * aiptek_irq. Because the Linux Input Event system allows the
375 * transmission of ONE attribute per input_report_xxx() call,
376 * collation has to be done on the other end to reconstitute
377 * a complete tablet report. Further, the number of Input Event reports
378 * submitted varies, depending on what USB report type, and circumstance.
379 * To deal with this, EV_MSC is used to indicate an 'end-of-report'
380 * message. This has been an undocumented convention understood by the kernel
381 * tablet driver and clients such as gpm and XFree86's tablet drivers.
383 * Of the information received from the tablet, the one piece I
384 * cannot transmit is the proximity bit (without resorting to an EV_MSC
385 * convention above.) I therefore have taken over REL_MISC and ABS_MISC
386 * (for relative and absolute reports, respectively) for communicating
387 * Proximity. Why two events? I thought it interesting to know if the
388 * Proximity event occurred while the tablet was in absolute or relative
391 * Other tablets use the notion of a certain minimum stylus pressure
392 * to infer proximity. While that could have been done, that is yet
393 * another 'by convention' behavior, the documentation for which
394 * would be spread between two (or more) pieces of software.
396 * EV_MSC usage was terminated for this purpose in Linux 2.5.x, and
397 * replaced with the input_sync() method (which emits EV_SYN.)
400 static void aiptek_irq(struct urb *urb, struct pt_regs *regs)
402 struct aiptek *aiptek = urb->context;
403 unsigned char *data = aiptek->data;
404 struct input_dev *inputdev = &aiptek->inputdev;
406 int retval, macro, x, y, z, left, right, middle, p, dv, tip, bs, pck;
408 switch (urb->status) {
416 /* This urb is terminated, clean up */
417 dbg("%s - urb shutting down with status: %d",
418 __FUNCTION__, urb->status);
422 dbg("%s - nonzero urb status received: %d",
423 __FUNCTION__, urb->status);
427 /* See if we are in a delay loop -- throw out report if true.
429 if (aiptek->inDelay == 1 && time_after(aiptek->endDelay, jiffies)) {
434 aiptek->eventCount++;
436 /* Report 1 delivers relative coordinates with either a stylus
437 * or the mouse. You do not know, however, which input
438 * tool generated the event.
441 if (aiptek->curSetting.coordinateMode ==
442 AIPTEK_COORDINATE_ABSOLUTE_MODE) {
444 AIPTEK_DIAGNOSTIC_SENDING_RELATIVE_IN_ABSOLUTE;
446 input_regs(inputdev, regs);
448 x = aiptek_convert_from_2s_complement(data[2]);
449 y = aiptek_convert_from_2s_complement(data[3]);
451 /* jitterable keeps track of whether any button has been pressed.
452 * We're also using it to remap the physical mouse button mask
453 * to pseudo-settings. (We don't specifically care about it's
454 * value after moving/transposing mouse button bitmasks, except
455 * that a non-zero value indicates that one or more
456 * mouse button was pressed.)
458 jitterable = data[5] & 0x07;
460 left = (data[5] & aiptek->curSetting.mouseButtonLeft) != 0 ? 1 : 0;
461 right = (data[5] & aiptek->curSetting.mouseButtonRight) != 0 ? 1 : 0;
462 middle = (data[5] & aiptek->curSetting.mouseButtonMiddle) != 0 ? 1 : 0;
464 input_report_key(inputdev, BTN_LEFT, left);
465 input_report_key(inputdev, BTN_MIDDLE, middle);
466 input_report_key(inputdev, BTN_RIGHT, right);
467 input_report_rel(inputdev, REL_X, x);
468 input_report_rel(inputdev, REL_Y, y);
469 input_report_rel(inputdev, REL_MISC, 1 | AIPTEK_REPORT_TOOL_UNKNOWN);
471 /* Wheel support is in the form of a single-event
474 if (aiptek->curSetting.wheel != AIPTEK_WHEEL_DISABLE) {
475 input_report_rel(inputdev, REL_WHEEL,
476 aiptek->curSetting.wheel);
477 aiptek->curSetting.wheel = AIPTEK_WHEEL_DISABLE;
479 input_sync(inputdev);
482 /* Report 2 is delivered only by the stylus, and delivers
483 * absolute coordinates.
485 else if (data[0] == 2) {
486 if (aiptek->curSetting.coordinateMode == AIPTEK_COORDINATE_RELATIVE_MODE) {
487 aiptek->diagnostic = AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE;
488 } else if (!AIPTEK_POINTER_ALLOW_STYLUS_MODE
489 (aiptek->curSetting.pointerMode)) {
490 aiptek->diagnostic = AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED;
492 input_regs(inputdev, regs);
494 x = le16_to_cpu(get_unaligned((__le16 *) (data + 1)));
495 y = le16_to_cpu(get_unaligned((__le16 *) (data + 3)));
496 z = le16_to_cpu(get_unaligned((__le16 *) (data + 6)));
498 p = (data[5] & 0x01) != 0 ? 1 : 0;
499 dv = (data[5] & 0x02) != 0 ? 1 : 0;
500 tip = (data[5] & 0x04) != 0 ? 1 : 0;
502 /* Use jitterable to re-arrange button masks
504 jitterable = data[5] & 0x18;
506 bs = (data[5] & aiptek->curSetting.stylusButtonLower) != 0 ? 1 : 0;
507 pck = (data[5] & aiptek->curSetting.stylusButtonUpper) != 0 ? 1 : 0;
509 /* dv indicates 'data valid' (e.g., the tablet is in sync
510 * and has delivered a "correct" report) We will ignore
511 * all 'bad' reports...
514 /* If we've not already sent a tool_button_?? code, do
515 * so now. Then set FIRED_BIT so it won't be resent unless
516 * the user forces FIRED_BIT off.
518 if (TOOL_BUTTON_FIRED
519 (aiptek->curSetting.toolMode) == 0) {
520 input_report_key(inputdev,
521 TOOL_BUTTON(aiptek->curSetting.toolMode),
523 aiptek->curSetting.toolMode |= TOOL_BUTTON_FIRED_BIT;
527 input_report_abs(inputdev, ABS_X, x);
528 input_report_abs(inputdev, ABS_Y, y);
529 input_report_abs(inputdev, ABS_PRESSURE, z);
531 input_report_key(inputdev, BTN_TOUCH, tip);
532 input_report_key(inputdev, BTN_STYLUS, bs);
533 input_report_key(inputdev, BTN_STYLUS2, pck);
535 if (aiptek->curSetting.xTilt !=
536 AIPTEK_TILT_DISABLE) {
537 input_report_abs(inputdev,
539 aiptek->curSetting.xTilt);
541 if (aiptek->curSetting.yTilt != AIPTEK_TILT_DISABLE) {
542 input_report_abs(inputdev,
544 aiptek->curSetting.yTilt);
547 /* Wheel support is in the form of a single-event
550 if (aiptek->curSetting.wheel !=
551 AIPTEK_WHEEL_DISABLE) {
552 input_report_abs(inputdev,
554 aiptek->curSetting.wheel);
555 aiptek->curSetting.wheel = AIPTEK_WHEEL_DISABLE;
558 input_report_abs(inputdev, ABS_MISC, p | AIPTEK_REPORT_TOOL_STYLUS);
559 input_sync(inputdev);
563 /* Report 3's come from the mouse in absolute mode.
565 else if (data[0] == 3) {
566 if (aiptek->curSetting.coordinateMode == AIPTEK_COORDINATE_RELATIVE_MODE) {
567 aiptek->diagnostic = AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE;
568 } else if (!AIPTEK_POINTER_ALLOW_MOUSE_MODE
569 (aiptek->curSetting.pointerMode)) {
570 aiptek->diagnostic = AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED;
572 input_regs(inputdev, regs);
573 x = le16_to_cpu(get_unaligned((__le16 *) (data + 1)));
574 y = le16_to_cpu(get_unaligned((__le16 *) (data + 3)));
576 jitterable = data[5] & 0x1c;
578 p = (data[5] & 0x01) != 0 ? 1 : 0;
579 dv = (data[5] & 0x02) != 0 ? 1 : 0;
580 left = (data[5] & aiptek->curSetting.mouseButtonLeft) != 0 ? 1 : 0;
581 right = (data[5] & aiptek->curSetting.mouseButtonRight) != 0 ? 1 : 0;
582 middle = (data[5] & aiptek->curSetting.mouseButtonMiddle) != 0 ? 1 : 0;
585 /* If we've not already sent a tool_button_?? code, do
586 * so now. Then set FIRED_BIT so it won't be resent unless
587 * the user forces FIRED_BIT off.
589 if (TOOL_BUTTON_FIRED
590 (aiptek->curSetting.toolMode) == 0) {
591 input_report_key(inputdev,
592 TOOL_BUTTON(aiptek->curSetting.toolMode),
594 aiptek->curSetting.toolMode |= TOOL_BUTTON_FIRED_BIT;
598 input_report_abs(inputdev, ABS_X, x);
599 input_report_abs(inputdev, ABS_Y, y);
601 input_report_key(inputdev, BTN_LEFT, left);
602 input_report_key(inputdev, BTN_MIDDLE, middle);
603 input_report_key(inputdev, BTN_RIGHT, right);
605 /* Wheel support is in the form of a single-event
608 if (aiptek->curSetting.wheel != AIPTEK_WHEEL_DISABLE) {
609 input_report_abs(inputdev,
611 aiptek->curSetting.wheel);
612 aiptek->curSetting.wheel = AIPTEK_WHEEL_DISABLE;
615 input_report_rel(inputdev, REL_MISC, p | AIPTEK_REPORT_TOOL_MOUSE);
616 input_sync(inputdev);
620 /* Report 4s come from the macro keys when pressed by stylus
622 else if (data[0] == 4) {
623 jitterable = data[1] & 0x18;
625 p = (data[1] & 0x01) != 0 ? 1 : 0;
626 dv = (data[1] & 0x02) != 0 ? 1 : 0;
627 tip = (data[1] & 0x04) != 0 ? 1 : 0;
628 bs = (data[1] & aiptek->curSetting.stylusButtonLower) != 0 ? 1 : 0;
629 pck = (data[1] & aiptek->curSetting.stylusButtonUpper) != 0 ? 1 : 0;
632 z = le16_to_cpu(get_unaligned((__le16 *) (data + 4)));
635 input_regs(inputdev, regs);
637 /* If we've not already sent a tool_button_?? code, do
638 * so now. Then set FIRED_BIT so it won't be resent unless
639 * the user forces FIRED_BIT off.
641 if (TOOL_BUTTON_FIRED(aiptek->curSetting.toolMode) == 0) {
642 input_report_key(inputdev,
643 TOOL_BUTTON(aiptek->curSetting.toolMode),
645 aiptek->curSetting.toolMode |= TOOL_BUTTON_FIRED_BIT;
649 input_report_key(inputdev, BTN_TOUCH, tip);
650 input_report_key(inputdev, BTN_STYLUS, bs);
651 input_report_key(inputdev, BTN_STYLUS2, pck);
652 input_report_abs(inputdev, ABS_PRESSURE, z);
655 /* For safety, we're sending key 'break' codes for the
656 * neighboring macro keys.
659 input_report_key(inputdev,
660 macroKeyEvents[macro - 1], 0);
663 input_report_key(inputdev,
664 macroKeyEvents[macro + 1], 0);
666 input_report_key(inputdev, macroKeyEvents[macro], p);
667 input_report_abs(inputdev, ABS_MISC,
668 p | AIPTEK_REPORT_TOOL_STYLUS);
669 input_sync(inputdev);
672 /* Report 5s come from the macro keys when pressed by mouse
674 else if (data[0] == 5) {
675 jitterable = data[1] & 0x1c;
677 p = (data[1] & 0x01) != 0 ? 1 : 0;
678 dv = (data[1] & 0x02) != 0 ? 1 : 0;
679 left = (data[1]& aiptek->curSetting.mouseButtonLeft) != 0 ? 1 : 0;
680 right = (data[1] & aiptek->curSetting.mouseButtonRight) != 0 ? 1 : 0;
681 middle = (data[1] & aiptek->curSetting.mouseButtonMiddle) != 0 ? 1 : 0;
685 input_regs(inputdev, regs);
687 /* If we've not already sent a tool_button_?? code, do
688 * so now. Then set FIRED_BIT so it won't be resent unless
689 * the user forces FIRED_BIT off.
691 if (TOOL_BUTTON_FIRED(aiptek->curSetting.toolMode) == 0) {
692 input_report_key(inputdev,
693 TOOL_BUTTON(aiptek->curSetting.toolMode),
695 aiptek->curSetting.toolMode |= TOOL_BUTTON_FIRED_BIT;
699 input_report_key(inputdev, BTN_LEFT, left);
700 input_report_key(inputdev, BTN_MIDDLE, middle);
701 input_report_key(inputdev, BTN_RIGHT, right);
704 /* For safety, we're sending key 'break' codes for the
705 * neighboring macro keys.
708 input_report_key(inputdev,
709 macroKeyEvents[macro - 1], 0);
712 input_report_key(inputdev,
713 macroKeyEvents[macro + 1], 0);
716 input_report_key(inputdev, macroKeyEvents[macro], 1);
717 input_report_rel(inputdev, ABS_MISC,
718 p | AIPTEK_REPORT_TOOL_MOUSE);
719 input_sync(inputdev);
722 /* We have no idea which tool can generate a report 6. Theoretically,
723 * neither need to, having been given reports 4 & 5 for such use.
724 * However, report 6 is the 'official-looking' report for macroKeys;
725 * reports 4 & 5 supposively are used to support unnamed, unknown
726 * hat switches (which just so happen to be the macroKeys.)
728 else if (data[0] == 6) {
729 macro = le16_to_cpu(get_unaligned((__le16 *) (data + 1)));
730 input_regs(inputdev, regs);
733 input_report_key(inputdev, macroKeyEvents[macro - 1],
737 input_report_key(inputdev, macroKeyEvents[macro + 1],
741 /* If we've not already sent a tool_button_?? code, do
742 * so now. Then set FIRED_BIT so it won't be resent unless
743 * the user forces FIRED_BIT off.
745 if (TOOL_BUTTON_FIRED(aiptek->curSetting.toolMode) == 0) {
746 input_report_key(inputdev,
747 TOOL_BUTTON(aiptek->curSetting.
749 aiptek->curSetting.toolMode |= TOOL_BUTTON_FIRED_BIT;
752 input_report_key(inputdev, macroKeyEvents[macro], 1);
753 input_report_abs(inputdev, ABS_MISC,
754 1 | AIPTEK_REPORT_TOOL_UNKNOWN);
755 input_sync(inputdev);
757 dbg("Unknown report %d", data[0]);
760 /* Jitter may occur when the user presses a button on the stlyus
761 * or the mouse. What we do to prevent that is wait 'x' milliseconds
762 * following a 'jitterable' event, which should give the hand some time
765 * We just introduced aiptek->previousJitterable to carry forth the
766 * notion that jitter occurs when the button state changes from on to off:
767 * a person drawing, holding a button down is not subject to jittering.
768 * With that in mind, changing from upper button depressed to lower button
769 * WILL transition through a jitter delay.
772 if (aiptek->previousJitterable != jitterable &&
773 aiptek->curSetting.jitterDelay != 0 && aiptek->inDelay != 1) {
774 aiptek->endDelay = jiffies +
775 ((aiptek->curSetting.jitterDelay * HZ) / 1000);
778 aiptek->previousJitterable = jitterable;
781 retval = usb_submit_urb(urb, GFP_ATOMIC);
783 err("%s - usb_submit_urb failed with result %d",
784 __FUNCTION__, retval);
788 /***********************************************************************
789 * These are the USB id's known so far. We do not identify them to
790 * specific Aiptek model numbers, because there has been overlaps,
791 * use, and reuse of id's in existing models. Certain models have
792 * been known to use more than one ID, indicative perhaps of
793 * manufacturing revisions. In any event, we consider these
794 * IDs to not be model-specific nor unique.
796 static const struct usb_device_id aiptek_ids[] = {
797 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x01)},
798 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x10)},
799 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x20)},
800 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x21)},
801 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x22)},
802 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x23)},
803 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x24)},
807 MODULE_DEVICE_TABLE(usb, aiptek_ids);
809 /***********************************************************************
810 * Open an instance of the tablet driver.
812 static int aiptek_open(struct input_dev *inputdev)
814 struct aiptek *aiptek = inputdev->private;
816 aiptek->urb->dev = aiptek->usbdev;
817 if (usb_submit_urb(aiptek->urb, GFP_KERNEL) != 0)
823 /***********************************************************************
824 * Close an instance of the tablet driver.
826 static void aiptek_close(struct input_dev *inputdev)
828 struct aiptek *aiptek = inputdev->private;
830 usb_kill_urb(aiptek->urb);
833 /***********************************************************************
834 * aiptek_set_report and aiptek_get_report() are borrowed from Linux 2.4.x,
835 * where they were known as usb_set_report and usb_get_report.
838 aiptek_set_report(struct aiptek *aiptek,
839 unsigned char report_type,
840 unsigned char report_id, void *buffer, int size)
842 return usb_control_msg(aiptek->usbdev,
843 usb_sndctrlpipe(aiptek->usbdev, 0),
845 USB_TYPE_CLASS | USB_RECIP_INTERFACE |
846 USB_DIR_OUT, (report_type << 8) + report_id,
847 aiptek->ifnum, buffer, size, 5000);
851 aiptek_get_report(struct aiptek *aiptek,
852 unsigned char report_type,
853 unsigned char report_id, void *buffer, int size)
855 return usb_control_msg(aiptek->usbdev,
856 usb_rcvctrlpipe(aiptek->usbdev, 0),
858 USB_TYPE_CLASS | USB_RECIP_INTERFACE |
859 USB_DIR_IN, (report_type << 8) + report_id,
860 aiptek->ifnum, buffer, size, 5000);
863 /***********************************************************************
864 * Send a command to the tablet.
867 aiptek_command(struct aiptek *aiptek, unsigned char command, unsigned char data)
869 const int sizeof_buf = 3 * sizeof(u8);
873 buf = kmalloc(sizeof_buf, GFP_KERNEL);
882 aiptek_set_report(aiptek, 3, 2, buf, sizeof_buf)) != sizeof_buf) {
883 dbg("aiptek_program: failed, tried to send: 0x%02x 0x%02x",
887 return ret < 0 ? ret : 0;
890 /***********************************************************************
891 * Retrieve information from the tablet. Querying info is defined as first
892 * sending the {command,data} sequence as a command, followed by a wait
893 * (aka, "programmaticDelay") and then a "read" request.
896 aiptek_query(struct aiptek *aiptek, unsigned char command, unsigned char data)
898 const int sizeof_buf = 3 * sizeof(u8);
902 buf = kmalloc(sizeof_buf, GFP_KERNEL);
910 if (aiptek_command(aiptek, command, data) != 0) {
914 msleep(aiptek->curSetting.programmableDelay);
917 aiptek_get_report(aiptek, 3, 2, buf, sizeof_buf)) != sizeof_buf) {
918 dbg("aiptek_query failed: returned 0x%02x 0x%02x 0x%02x",
919 buf[0], buf[1], buf[2]);
922 ret = le16_to_cpu(get_unaligned((__le16 *) (buf + 1)));
928 /***********************************************************************
929 * Program the tablet into either absolute or relative mode.
930 * We also get information about the tablet's size.
932 static int aiptek_program_tablet(struct aiptek *aiptek)
935 /* Execute Resolution500LPI */
936 if ((ret = aiptek_command(aiptek, 0x18, 0x04)) < 0)
939 /* Query getModelCode */
940 if ((ret = aiptek_query(aiptek, 0x02, 0x00)) < 0)
942 aiptek->features.modelCode = ret & 0xff;
944 /* Query getODMCode */
945 if ((ret = aiptek_query(aiptek, 0x03, 0x00)) < 0)
947 aiptek->features.odmCode = ret;
949 /* Query getFirmwareCode */
950 if ((ret = aiptek_query(aiptek, 0x04, 0x00)) < 0)
952 aiptek->features.firmwareCode = ret;
954 /* Query getXextension */
955 if ((ret = aiptek_query(aiptek, 0x01, 0x00)) < 0)
957 aiptek->inputdev.absmin[ABS_X] = 0;
958 aiptek->inputdev.absmax[ABS_X] = ret - 1;
960 /* Query getYextension */
961 if ((ret = aiptek_query(aiptek, 0x01, 0x01)) < 0)
963 aiptek->inputdev.absmin[ABS_Y] = 0;
964 aiptek->inputdev.absmax[ABS_Y] = ret - 1;
966 /* Query getPressureLevels */
967 if ((ret = aiptek_query(aiptek, 0x08, 0x00)) < 0)
969 aiptek->inputdev.absmin[ABS_PRESSURE] = 0;
970 aiptek->inputdev.absmax[ABS_PRESSURE] = ret - 1;
972 /* Depending on whether we are in absolute or relative mode, we will
973 * do a switchToTablet(absolute) or switchToMouse(relative) command.
975 if (aiptek->curSetting.coordinateMode ==
976 AIPTEK_COORDINATE_ABSOLUTE_MODE) {
977 /* Execute switchToTablet */
978 if ((ret = aiptek_command(aiptek, 0x10, 0x01)) < 0) {
982 /* Execute switchToMouse */
983 if ((ret = aiptek_command(aiptek, 0x10, 0x00)) < 0) {
988 /* Enable the macro keys */
989 if ((ret = aiptek_command(aiptek, 0x11, 0x02)) < 0)
992 /* Execute FilterOn */
993 if ((ret = aiptek_command(aiptek, 0x17, 0x00)) < 0)
997 /* Execute AutoGainOn */
998 if ((ret = aiptek_command(aiptek, 0x12, 0xff)) < 0)
1001 /* Reset the eventCount, so we track events from last (re)programming
1003 aiptek->diagnostic = AIPTEK_DIAGNOSTIC_NA;
1004 aiptek->eventCount = 0;
1009 /***********************************************************************
1010 * Sysfs functions. Sysfs prefers that individually-tunable parameters
1011 * exist in their separate pseudo-files. Summary data that is immutable
1012 * may exist in a singular file so long as you don't define a writeable
1016 /***********************************************************************
1017 * support the 'size' file -- display support
1019 static ssize_t show_tabletSize(struct device *dev, struct device_attribute *attr, char *buf)
1021 struct aiptek *aiptek = dev_get_drvdata(dev);
1026 return snprintf(buf, PAGE_SIZE, "%dx%d\n",
1027 aiptek->inputdev.absmax[ABS_X] + 1,
1028 aiptek->inputdev.absmax[ABS_Y] + 1);
1031 /* These structs define the sysfs files, param #1 is the name of the
1032 * file, param 2 is the file permissions, param 3 & 4 are to the
1033 * output generator and input parser routines. Absence of a routine is
1034 * permitted -- it only means can't either 'cat' the file, or send data
1037 static DEVICE_ATTR(size, S_IRUGO, show_tabletSize, NULL);
1039 /***********************************************************************
1040 * support routines for the 'product_id' file
1042 static ssize_t show_tabletProductId(struct device *dev, struct device_attribute *attr, char *buf)
1044 struct aiptek *aiptek = dev_get_drvdata(dev);
1049 return snprintf(buf, PAGE_SIZE, "0x%04x\n",
1050 aiptek->inputdev.id.product);
1053 static DEVICE_ATTR(product_id, S_IRUGO, show_tabletProductId, NULL);
1055 /***********************************************************************
1056 * support routines for the 'vendor_id' file
1058 static ssize_t show_tabletVendorId(struct device *dev, struct device_attribute *attr, char *buf)
1060 struct aiptek *aiptek = dev_get_drvdata(dev);
1065 return snprintf(buf, PAGE_SIZE, "0x%04x\n", aiptek->inputdev.id.vendor);
1068 static DEVICE_ATTR(vendor_id, S_IRUGO, show_tabletVendorId, NULL);
1070 /***********************************************************************
1071 * support routines for the 'vendor' file
1073 static ssize_t show_tabletManufacturer(struct device *dev, struct device_attribute *attr, char *buf)
1075 struct aiptek *aiptek = dev_get_drvdata(dev);
1081 retval = snprintf(buf, PAGE_SIZE, "%s\n", aiptek->usbdev->manufacturer);
1085 static DEVICE_ATTR(vendor, S_IRUGO, show_tabletManufacturer, NULL);
1087 /***********************************************************************
1088 * support routines for the 'product' file
1090 static ssize_t show_tabletProduct(struct device *dev, struct device_attribute *attr, char *buf)
1092 struct aiptek *aiptek = dev_get_drvdata(dev);
1098 retval = snprintf(buf, PAGE_SIZE, "%s\n", aiptek->usbdev->product);
1102 static DEVICE_ATTR(product, S_IRUGO, show_tabletProduct, NULL);
1104 /***********************************************************************
1105 * support routines for the 'pointer_mode' file. Note that this file
1106 * both displays current setting and allows reprogramming.
1108 static ssize_t show_tabletPointerMode(struct device *dev, struct device_attribute *attr, char *buf)
1110 struct aiptek *aiptek = dev_get_drvdata(dev);
1116 switch (aiptek->curSetting.pointerMode) {
1117 case AIPTEK_POINTER_ONLY_STYLUS_MODE:
1121 case AIPTEK_POINTER_ONLY_MOUSE_MODE:
1125 case AIPTEK_POINTER_EITHER_MODE:
1133 return snprintf(buf, PAGE_SIZE, "%s\n", s);
1137 store_tabletPointerMode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1139 struct aiptek *aiptek = dev_get_drvdata(dev);
1143 if (strcmp(buf, "stylus") == 0) {
1144 aiptek->newSetting.pointerMode =
1145 AIPTEK_POINTER_ONLY_STYLUS_MODE;
1146 } else if (strcmp(buf, "mouse") == 0) {
1147 aiptek->newSetting.pointerMode = AIPTEK_POINTER_ONLY_MOUSE_MODE;
1148 } else if (strcmp(buf, "either") == 0) {
1149 aiptek->newSetting.pointerMode = AIPTEK_POINTER_EITHER_MODE;
1154 static DEVICE_ATTR(pointer_mode,
1156 show_tabletPointerMode, store_tabletPointerMode);
1158 /***********************************************************************
1159 * support routines for the 'coordinate_mode' file. Note that this file
1160 * both displays current setting and allows reprogramming.
1162 static ssize_t show_tabletCoordinateMode(struct device *dev, struct device_attribute *attr, char *buf)
1164 struct aiptek *aiptek = dev_get_drvdata(dev);
1170 switch (aiptek->curSetting.coordinateMode) {
1171 case AIPTEK_COORDINATE_ABSOLUTE_MODE:
1175 case AIPTEK_COORDINATE_RELATIVE_MODE:
1183 return snprintf(buf, PAGE_SIZE, "%s\n", s);
1187 store_tabletCoordinateMode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1189 struct aiptek *aiptek = dev_get_drvdata(dev);
1193 if (strcmp(buf, "absolute") == 0) {
1194 aiptek->newSetting.pointerMode =
1195 AIPTEK_COORDINATE_ABSOLUTE_MODE;
1196 } else if (strcmp(buf, "relative") == 0) {
1197 aiptek->newSetting.pointerMode =
1198 AIPTEK_COORDINATE_RELATIVE_MODE;
1203 static DEVICE_ATTR(coordinate_mode,
1205 show_tabletCoordinateMode, store_tabletCoordinateMode);
1207 /***********************************************************************
1208 * support routines for the 'tool_mode' file. Note that this file
1209 * both displays current setting and allows reprogramming.
1211 static ssize_t show_tabletToolMode(struct device *dev, struct device_attribute *attr, char *buf)
1213 struct aiptek *aiptek = dev_get_drvdata(dev);
1219 switch (TOOL_BUTTON(aiptek->curSetting.toolMode)) {
1220 case AIPTEK_TOOL_BUTTON_MOUSE_MODE:
1224 case AIPTEK_TOOL_BUTTON_ERASER_MODE:
1228 case AIPTEK_TOOL_BUTTON_PENCIL_MODE:
1232 case AIPTEK_TOOL_BUTTON_PEN_MODE:
1236 case AIPTEK_TOOL_BUTTON_BRUSH_MODE:
1240 case AIPTEK_TOOL_BUTTON_AIRBRUSH_MODE:
1244 case AIPTEK_TOOL_BUTTON_LENS_MODE:
1252 return snprintf(buf, PAGE_SIZE, "%s\n", s);
1256 store_tabletToolMode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1258 struct aiptek *aiptek = dev_get_drvdata(dev);
1262 if (strcmp(buf, "mouse") == 0) {
1263 aiptek->newSetting.toolMode = AIPTEK_TOOL_BUTTON_MOUSE_MODE;
1264 } else if (strcmp(buf, "eraser") == 0) {
1265 aiptek->newSetting.toolMode = AIPTEK_TOOL_BUTTON_ERASER_MODE;
1266 } else if (strcmp(buf, "pencil") == 0) {
1267 aiptek->newSetting.toolMode = AIPTEK_TOOL_BUTTON_PENCIL_MODE;
1268 } else if (strcmp(buf, "pen") == 0) {
1269 aiptek->newSetting.toolMode = AIPTEK_TOOL_BUTTON_PEN_MODE;
1270 } else if (strcmp(buf, "brush") == 0) {
1271 aiptek->newSetting.toolMode = AIPTEK_TOOL_BUTTON_BRUSH_MODE;
1272 } else if (strcmp(buf, "airbrush") == 0) {
1273 aiptek->newSetting.toolMode = AIPTEK_TOOL_BUTTON_AIRBRUSH_MODE;
1274 } else if (strcmp(buf, "lens") == 0) {
1275 aiptek->newSetting.toolMode = AIPTEK_TOOL_BUTTON_LENS_MODE;
1281 static DEVICE_ATTR(tool_mode,
1283 show_tabletToolMode, store_tabletToolMode);
1285 /***********************************************************************
1286 * support routines for the 'xtilt' file. Note that this file
1287 * both displays current setting and allows reprogramming.
1289 static ssize_t show_tabletXtilt(struct device *dev, struct device_attribute *attr, char *buf)
1291 struct aiptek *aiptek = dev_get_drvdata(dev);
1296 if (aiptek->curSetting.xTilt == AIPTEK_TILT_DISABLE) {
1297 return snprintf(buf, PAGE_SIZE, "disable\n");
1299 return snprintf(buf, PAGE_SIZE, "%d\n",
1300 aiptek->curSetting.xTilt);
1305 store_tabletXtilt(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1307 struct aiptek *aiptek = dev_get_drvdata(dev);
1313 if (strcmp(buf, "disable") == 0) {
1314 aiptek->newSetting.xTilt = AIPTEK_TILT_DISABLE;
1316 x = (int)simple_strtol(buf, NULL, 10);
1317 if (x >= AIPTEK_TILT_MIN && x <= AIPTEK_TILT_MAX) {
1318 aiptek->newSetting.xTilt = x;
1324 static DEVICE_ATTR(xtilt,
1325 S_IRUGO | S_IWUGO, show_tabletXtilt, store_tabletXtilt);
1327 /***********************************************************************
1328 * support routines for the 'ytilt' file. Note that this file
1329 * both displays current setting and allows reprogramming.
1331 static ssize_t show_tabletYtilt(struct device *dev, struct device_attribute *attr, char *buf)
1333 struct aiptek *aiptek = dev_get_drvdata(dev);
1338 if (aiptek->curSetting.yTilt == AIPTEK_TILT_DISABLE) {
1339 return snprintf(buf, PAGE_SIZE, "disable\n");
1341 return snprintf(buf, PAGE_SIZE, "%d\n",
1342 aiptek->curSetting.yTilt);
1347 store_tabletYtilt(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1349 struct aiptek *aiptek = dev_get_drvdata(dev);
1355 if (strcmp(buf, "disable") == 0) {
1356 aiptek->newSetting.yTilt = AIPTEK_TILT_DISABLE;
1358 y = (int)simple_strtol(buf, NULL, 10);
1359 if (y >= AIPTEK_TILT_MIN && y <= AIPTEK_TILT_MAX) {
1360 aiptek->newSetting.yTilt = y;
1366 static DEVICE_ATTR(ytilt,
1367 S_IRUGO | S_IWUGO, show_tabletYtilt, store_tabletYtilt);
1369 /***********************************************************************
1370 * support routines for the 'jitter' file. Note that this file
1371 * both displays current setting and allows reprogramming.
1373 static ssize_t show_tabletJitterDelay(struct device *dev, struct device_attribute *attr, char *buf)
1375 struct aiptek *aiptek = dev_get_drvdata(dev);
1380 return snprintf(buf, PAGE_SIZE, "%d\n", aiptek->curSetting.jitterDelay);
1384 store_tabletJitterDelay(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1386 struct aiptek *aiptek = dev_get_drvdata(dev);
1391 aiptek->newSetting.jitterDelay = (int)simple_strtol(buf, NULL, 10);
1395 static DEVICE_ATTR(jitter,
1397 show_tabletJitterDelay, store_tabletJitterDelay);
1399 /***********************************************************************
1400 * support routines for the 'delay' file. Note that this file
1401 * both displays current setting and allows reprogramming.
1403 static ssize_t show_tabletProgrammableDelay(struct device *dev, struct device_attribute *attr, char *buf)
1405 struct aiptek *aiptek = dev_get_drvdata(dev);
1410 return snprintf(buf, PAGE_SIZE, "%d\n",
1411 aiptek->curSetting.programmableDelay);
1415 store_tabletProgrammableDelay(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1417 struct aiptek *aiptek = dev_get_drvdata(dev);
1422 aiptek->newSetting.programmableDelay = (int)simple_strtol(buf, NULL, 10);
1426 static DEVICE_ATTR(delay,
1428 show_tabletProgrammableDelay, store_tabletProgrammableDelay);
1430 /***********************************************************************
1431 * support routines for the 'input_path' file. Note that this file
1432 * only displays current setting.
1434 static ssize_t show_tabletInputDevice(struct device *dev, struct device_attribute *attr, char *buf)
1436 struct aiptek *aiptek = dev_get_drvdata(dev);
1441 return snprintf(buf, PAGE_SIZE, "/dev/input/%s\n",
1442 aiptek->features.inputPath);
1445 static DEVICE_ATTR(input_path, S_IRUGO, show_tabletInputDevice, NULL);
1447 /***********************************************************************
1448 * support routines for the 'event_count' file. Note that this file
1449 * only displays current setting.
1451 static ssize_t show_tabletEventsReceived(struct device *dev, struct device_attribute *attr, char *buf)
1453 struct aiptek *aiptek = dev_get_drvdata(dev);
1458 return snprintf(buf, PAGE_SIZE, "%ld\n", aiptek->eventCount);
1461 static DEVICE_ATTR(event_count, S_IRUGO, show_tabletEventsReceived, NULL);
1463 /***********************************************************************
1464 * support routines for the 'diagnostic' file. Note that this file
1465 * only displays current setting.
1467 static ssize_t show_tabletDiagnosticMessage(struct device *dev, struct device_attribute *attr, char *buf)
1469 struct aiptek *aiptek = dev_get_drvdata(dev);
1475 switch (aiptek->diagnostic) {
1476 case AIPTEK_DIAGNOSTIC_NA:
1477 retMsg = "no errors\n";
1480 case AIPTEK_DIAGNOSTIC_SENDING_RELATIVE_IN_ABSOLUTE:
1481 retMsg = "Error: receiving relative reports\n";
1484 case AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE:
1485 retMsg = "Error: receiving absolute reports\n";
1488 case AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED:
1489 if (aiptek->curSetting.pointerMode ==
1490 AIPTEK_POINTER_ONLY_MOUSE_MODE) {
1491 retMsg = "Error: receiving stylus reports\n";
1493 retMsg = "Error: receiving mouse reports\n";
1500 return snprintf(buf, PAGE_SIZE, retMsg);
1503 static DEVICE_ATTR(diagnostic, S_IRUGO, show_tabletDiagnosticMessage, NULL);
1505 /***********************************************************************
1506 * support routines for the 'stylus_upper' file. Note that this file
1507 * both displays current setting and allows for setting changing.
1509 static ssize_t show_tabletStylusUpper(struct device *dev, struct device_attribute *attr, char *buf)
1511 struct aiptek *aiptek = dev_get_drvdata(dev);
1517 switch (aiptek->curSetting.stylusButtonUpper) {
1518 case AIPTEK_STYLUS_UPPER_BUTTON:
1522 case AIPTEK_STYLUS_LOWER_BUTTON:
1530 return snprintf(buf, PAGE_SIZE, "%s\n", s);
1534 store_tabletStylusUpper(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1536 struct aiptek *aiptek = dev_get_drvdata(dev);
1541 if (strcmp(buf, "upper") == 0) {
1542 aiptek->newSetting.stylusButtonUpper =
1543 AIPTEK_STYLUS_UPPER_BUTTON;
1544 } else if (strcmp(buf, "lower") == 0) {
1545 aiptek->newSetting.stylusButtonUpper =
1546 AIPTEK_STYLUS_LOWER_BUTTON;
1551 static DEVICE_ATTR(stylus_upper,
1553 show_tabletStylusUpper, store_tabletStylusUpper);
1555 /***********************************************************************
1556 * support routines for the 'stylus_lower' file. Note that this file
1557 * both displays current setting and allows for setting changing.
1559 static ssize_t show_tabletStylusLower(struct device *dev, struct device_attribute *attr, char *buf)
1561 struct aiptek *aiptek = dev_get_drvdata(dev);
1567 switch (aiptek->curSetting.stylusButtonLower) {
1568 case AIPTEK_STYLUS_UPPER_BUTTON:
1572 case AIPTEK_STYLUS_LOWER_BUTTON:
1580 return snprintf(buf, PAGE_SIZE, "%s\n", s);
1584 store_tabletStylusLower(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1586 struct aiptek *aiptek = dev_get_drvdata(dev);
1591 if (strcmp(buf, "upper") == 0) {
1592 aiptek->newSetting.stylusButtonLower =
1593 AIPTEK_STYLUS_UPPER_BUTTON;
1594 } else if (strcmp(buf, "lower") == 0) {
1595 aiptek->newSetting.stylusButtonLower =
1596 AIPTEK_STYLUS_LOWER_BUTTON;
1601 static DEVICE_ATTR(stylus_lower,
1603 show_tabletStylusLower, store_tabletStylusLower);
1605 /***********************************************************************
1606 * support routines for the 'mouse_left' file. Note that this file
1607 * both displays current setting and allows for setting changing.
1609 static ssize_t show_tabletMouseLeft(struct device *dev, struct device_attribute *attr, char *buf)
1611 struct aiptek *aiptek = dev_get_drvdata(dev);
1617 switch (aiptek->curSetting.mouseButtonLeft) {
1618 case AIPTEK_MOUSE_LEFT_BUTTON:
1622 case AIPTEK_MOUSE_MIDDLE_BUTTON:
1626 case AIPTEK_MOUSE_RIGHT_BUTTON:
1634 return snprintf(buf, PAGE_SIZE, "%s\n", s);
1638 store_tabletMouseLeft(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1640 struct aiptek *aiptek = dev_get_drvdata(dev);
1645 if (strcmp(buf, "left") == 0) {
1646 aiptek->newSetting.mouseButtonLeft = AIPTEK_MOUSE_LEFT_BUTTON;
1647 } else if (strcmp(buf, "middle") == 0) {
1648 aiptek->newSetting.mouseButtonLeft = AIPTEK_MOUSE_MIDDLE_BUTTON;
1649 } else if (strcmp(buf, "right") == 0) {
1650 aiptek->newSetting.mouseButtonLeft = AIPTEK_MOUSE_RIGHT_BUTTON;
1655 static DEVICE_ATTR(mouse_left,
1657 show_tabletMouseLeft, store_tabletMouseLeft);
1659 /***********************************************************************
1660 * support routines for the 'mouse_middle' file. Note that this file
1661 * both displays current setting and allows for setting changing.
1663 static ssize_t show_tabletMouseMiddle(struct device *dev, struct device_attribute *attr, char *buf)
1665 struct aiptek *aiptek = dev_get_drvdata(dev);
1671 switch (aiptek->curSetting.mouseButtonMiddle) {
1672 case AIPTEK_MOUSE_LEFT_BUTTON:
1676 case AIPTEK_MOUSE_MIDDLE_BUTTON:
1680 case AIPTEK_MOUSE_RIGHT_BUTTON:
1688 return snprintf(buf, PAGE_SIZE, "%s\n", s);
1692 store_tabletMouseMiddle(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1694 struct aiptek *aiptek = dev_get_drvdata(dev);
1699 if (strcmp(buf, "left") == 0) {
1700 aiptek->newSetting.mouseButtonMiddle = AIPTEK_MOUSE_LEFT_BUTTON;
1701 } else if (strcmp(buf, "middle") == 0) {
1702 aiptek->newSetting.mouseButtonMiddle =
1703 AIPTEK_MOUSE_MIDDLE_BUTTON;
1704 } else if (strcmp(buf, "right") == 0) {
1705 aiptek->newSetting.mouseButtonMiddle =
1706 AIPTEK_MOUSE_RIGHT_BUTTON;
1711 static DEVICE_ATTR(mouse_middle,
1713 show_tabletMouseMiddle, store_tabletMouseMiddle);
1715 /***********************************************************************
1716 * support routines for the 'mouse_right' file. Note that this file
1717 * both displays current setting and allows for setting changing.
1719 static ssize_t show_tabletMouseRight(struct device *dev, struct device_attribute *attr, char *buf)
1721 struct aiptek *aiptek = dev_get_drvdata(dev);
1727 switch (aiptek->curSetting.mouseButtonRight) {
1728 case AIPTEK_MOUSE_LEFT_BUTTON:
1732 case AIPTEK_MOUSE_MIDDLE_BUTTON:
1736 case AIPTEK_MOUSE_RIGHT_BUTTON:
1744 return snprintf(buf, PAGE_SIZE, "%s\n", s);
1748 store_tabletMouseRight(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1750 struct aiptek *aiptek = dev_get_drvdata(dev);
1755 if (strcmp(buf, "left") == 0) {
1756 aiptek->newSetting.mouseButtonRight = AIPTEK_MOUSE_LEFT_BUTTON;
1757 } else if (strcmp(buf, "middle") == 0) {
1758 aiptek->newSetting.mouseButtonRight =
1759 AIPTEK_MOUSE_MIDDLE_BUTTON;
1760 } else if (strcmp(buf, "right") == 0) {
1761 aiptek->newSetting.mouseButtonRight = AIPTEK_MOUSE_RIGHT_BUTTON;
1766 static DEVICE_ATTR(mouse_right,
1768 show_tabletMouseRight, store_tabletMouseRight);
1770 /***********************************************************************
1771 * support routines for the 'wheel' file. Note that this file
1772 * both displays current setting and allows for setting changing.
1774 static ssize_t show_tabletWheel(struct device *dev, struct device_attribute *attr, char *buf)
1776 struct aiptek *aiptek = dev_get_drvdata(dev);
1781 if (aiptek->curSetting.wheel == AIPTEK_WHEEL_DISABLE) {
1782 return snprintf(buf, PAGE_SIZE, "disable\n");
1784 return snprintf(buf, PAGE_SIZE, "%d\n",
1785 aiptek->curSetting.wheel);
1790 store_tabletWheel(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1792 struct aiptek *aiptek = dev_get_drvdata(dev);
1797 aiptek->newSetting.wheel = (int)simple_strtol(buf, NULL, 10);
1801 static DEVICE_ATTR(wheel,
1802 S_IRUGO | S_IWUGO, show_tabletWheel, store_tabletWheel);
1804 /***********************************************************************
1805 * support routines for the 'execute' file. Note that this file
1806 * both displays current setting and allows for setting changing.
1808 static ssize_t show_tabletExecute(struct device *dev, struct device_attribute *attr, char *buf)
1810 struct aiptek *aiptek = dev_get_drvdata(dev);
1815 /* There is nothing useful to display, so a one-line manual
1818 return snprintf(buf, PAGE_SIZE,
1819 "Write anything to this file to program your tablet.\n");
1823 store_tabletExecute(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1825 struct aiptek *aiptek = dev_get_drvdata(dev);
1830 /* We do not care what you write to this file. Merely the action
1831 * of writing to this file triggers a tablet reprogramming.
1833 memcpy(&aiptek->curSetting, &aiptek->newSetting,
1834 sizeof(struct aiptek_settings));
1836 if (aiptek_program_tablet(aiptek) < 0)
1842 static DEVICE_ATTR(execute,
1843 S_IRUGO | S_IWUGO, show_tabletExecute, store_tabletExecute);
1845 /***********************************************************************
1846 * support routines for the 'odm_code' file. Note that this file
1847 * only displays current setting.
1849 static ssize_t show_tabletODMCode(struct device *dev, struct device_attribute *attr, char *buf)
1851 struct aiptek *aiptek = dev_get_drvdata(dev);
1856 return snprintf(buf, PAGE_SIZE, "0x%04x\n", aiptek->features.odmCode);
1859 static DEVICE_ATTR(odm_code, S_IRUGO, show_tabletODMCode, NULL);
1861 /***********************************************************************
1862 * support routines for the 'model_code' file. Note that this file
1863 * only displays current setting.
1865 static ssize_t show_tabletModelCode(struct device *dev, struct device_attribute *attr, char *buf)
1867 struct aiptek *aiptek = dev_get_drvdata(dev);
1872 return snprintf(buf, PAGE_SIZE, "0x%04x\n", aiptek->features.modelCode);
1875 static DEVICE_ATTR(model_code, S_IRUGO, show_tabletModelCode, NULL);
1877 /***********************************************************************
1878 * support routines for the 'firmware_code' file. Note that this file
1879 * only displays current setting.
1881 static ssize_t show_firmwareCode(struct device *dev, struct device_attribute *attr, char *buf)
1883 struct aiptek *aiptek = dev_get_drvdata(dev);
1888 return snprintf(buf, PAGE_SIZE, "%04x\n",
1889 aiptek->features.firmwareCode);
1892 static DEVICE_ATTR(firmware_code, S_IRUGO, show_firmwareCode, NULL);
1894 /***********************************************************************
1895 * This routine removes all existing sysfs files managed by this device
1898 static void aiptek_delete_files(struct device *dev)
1900 device_remove_file(dev, &dev_attr_size);
1901 device_remove_file(dev, &dev_attr_product_id);
1902 device_remove_file(dev, &dev_attr_vendor_id);
1903 device_remove_file(dev, &dev_attr_vendor);
1904 device_remove_file(dev, &dev_attr_product);
1905 device_remove_file(dev, &dev_attr_pointer_mode);
1906 device_remove_file(dev, &dev_attr_coordinate_mode);
1907 device_remove_file(dev, &dev_attr_tool_mode);
1908 device_remove_file(dev, &dev_attr_xtilt);
1909 device_remove_file(dev, &dev_attr_ytilt);
1910 device_remove_file(dev, &dev_attr_jitter);
1911 device_remove_file(dev, &dev_attr_delay);
1912 device_remove_file(dev, &dev_attr_input_path);
1913 device_remove_file(dev, &dev_attr_event_count);
1914 device_remove_file(dev, &dev_attr_diagnostic);
1915 device_remove_file(dev, &dev_attr_odm_code);
1916 device_remove_file(dev, &dev_attr_model_code);
1917 device_remove_file(dev, &dev_attr_firmware_code);
1918 device_remove_file(dev, &dev_attr_stylus_lower);
1919 device_remove_file(dev, &dev_attr_stylus_upper);
1920 device_remove_file(dev, &dev_attr_mouse_left);
1921 device_remove_file(dev, &dev_attr_mouse_middle);
1922 device_remove_file(dev, &dev_attr_mouse_right);
1923 device_remove_file(dev, &dev_attr_wheel);
1924 device_remove_file(dev, &dev_attr_execute);
1927 /***********************************************************************
1928 * This routine creates the sysfs files managed by this device
1931 static int aiptek_add_files(struct device *dev)
1935 if ((ret = device_create_file(dev, &dev_attr_size)) ||
1936 (ret = device_create_file(dev, &dev_attr_product_id)) ||
1937 (ret = device_create_file(dev, &dev_attr_vendor_id)) ||
1938 (ret = device_create_file(dev, &dev_attr_vendor)) ||
1939 (ret = device_create_file(dev, &dev_attr_product)) ||
1940 (ret = device_create_file(dev, &dev_attr_pointer_mode)) ||
1941 (ret = device_create_file(dev, &dev_attr_coordinate_mode)) ||
1942 (ret = device_create_file(dev, &dev_attr_tool_mode)) ||
1943 (ret = device_create_file(dev, &dev_attr_xtilt)) ||
1944 (ret = device_create_file(dev, &dev_attr_ytilt)) ||
1945 (ret = device_create_file(dev, &dev_attr_jitter)) ||
1946 (ret = device_create_file(dev, &dev_attr_delay)) ||
1947 (ret = device_create_file(dev, &dev_attr_input_path)) ||
1948 (ret = device_create_file(dev, &dev_attr_event_count)) ||
1949 (ret = device_create_file(dev, &dev_attr_diagnostic)) ||
1950 (ret = device_create_file(dev, &dev_attr_odm_code)) ||
1951 (ret = device_create_file(dev, &dev_attr_model_code)) ||
1952 (ret = device_create_file(dev, &dev_attr_firmware_code)) ||
1953 (ret = device_create_file(dev, &dev_attr_stylus_lower)) ||
1954 (ret = device_create_file(dev, &dev_attr_stylus_upper)) ||
1955 (ret = device_create_file(dev, &dev_attr_mouse_left)) ||
1956 (ret = device_create_file(dev, &dev_attr_mouse_middle)) ||
1957 (ret = device_create_file(dev, &dev_attr_mouse_right)) ||
1958 (ret = device_create_file(dev, &dev_attr_wheel)) ||
1959 (ret = device_create_file(dev, &dev_attr_execute))) {
1960 err("aiptek: killing own sysfs device files\n");
1961 aiptek_delete_files(dev);
1966 /***********************************************************************
1967 * This routine is called when a tablet has been identified. It basically
1968 * sets up the tablet and the driver's internal structures.
1971 aiptek_probe(struct usb_interface *intf, const struct usb_device_id *id)
1973 struct usb_device *usbdev = interface_to_usbdev(intf);
1974 struct usb_endpoint_descriptor *endpoint;
1975 struct aiptek *aiptek;
1976 struct input_dev *inputdev;
1977 struct input_handle *inputhandle;
1978 struct list_head *node, *next;
1982 AIPTEK_PROGRAMMABLE_DELAY_50,
1983 AIPTEK_PROGRAMMABLE_DELAY_400,
1984 AIPTEK_PROGRAMMABLE_DELAY_25,
1985 AIPTEK_PROGRAMMABLE_DELAY_100,
1986 AIPTEK_PROGRAMMABLE_DELAY_200,
1987 AIPTEK_PROGRAMMABLE_DELAY_300
1990 /* programmableDelay is where the command-line specified
1991 * delay is kept. We make it the first element of speeds[],
1992 * so therefore, your override speed is tried first, then the
1993 * remainder. Note that the default value of 400ms will be tried
1994 * if you do not specify any command line parameter.
1996 speeds[0] = programmableDelay;
1998 if ((aiptek = kmalloc(sizeof(struct aiptek), GFP_KERNEL)) == NULL)
2000 memset(aiptek, 0, sizeof(struct aiptek));
2002 aiptek->data = usb_buffer_alloc(usbdev, AIPTEK_PACKET_LENGTH,
2003 SLAB_ATOMIC, &aiptek->data_dma);
2004 if (aiptek->data == NULL) {
2009 aiptek->urb = usb_alloc_urb(0, GFP_KERNEL);
2010 if (aiptek->urb == NULL) {
2011 usb_buffer_free(usbdev, AIPTEK_PACKET_LENGTH, aiptek->data,
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 memcpy(&aiptek->newSetting, &aiptek->curSetting,
2039 sizeof(struct aiptek_settings));
2041 /* Now program the capacities of the tablet, in terms of being
2044 aiptek->inputdev.evbit[0] |= BIT(EV_KEY)
2049 aiptek->inputdev.absbit[0] |=
2054 BIT(ABS_TILT_Y) | BIT(ABS_WHEEL) | BIT(ABS_MISC));
2056 aiptek->inputdev.relbit[0] |=
2057 (BIT(REL_X) | BIT(REL_Y) | BIT(REL_WHEEL) | BIT(REL_MISC));
2059 aiptek->inputdev.keybit[LONG(BTN_LEFT)] |=
2060 (BIT(BTN_LEFT) | BIT(BTN_RIGHT) | BIT(BTN_MIDDLE));
2062 aiptek->inputdev.keybit[LONG(BTN_DIGI)] |=
2063 (BIT(BTN_TOOL_PEN) |
2064 BIT(BTN_TOOL_RUBBER) |
2065 BIT(BTN_TOOL_PENCIL) |
2066 BIT(BTN_TOOL_AIRBRUSH) |
2067 BIT(BTN_TOOL_BRUSH) |
2068 BIT(BTN_TOOL_MOUSE) |
2069 BIT(BTN_TOOL_LENS) |
2070 BIT(BTN_TOUCH) | BIT(BTN_STYLUS) | BIT(BTN_STYLUS2));
2072 aiptek->inputdev.mscbit[0] = BIT(MSC_SERIAL);
2074 /* Programming the tablet macro keys needs to be done with a for loop
2075 * as the keycodes are discontiguous.
2077 for (i = 0; i < sizeof(macroKeyEvents) / sizeof(macroKeyEvents[0]); ++i)
2078 set_bit(macroKeyEvents[i], aiptek->inputdev.keybit);
2080 /* Set up client data, pointers to open and close routines
2081 * for the input device.
2083 aiptek->inputdev.private = aiptek;
2084 aiptek->inputdev.open = aiptek_open;
2085 aiptek->inputdev.close = aiptek_close;
2087 /* Determine the usb devices' physical path.
2088 * Asketh not why we always pretend we're using "../input0",
2089 * but I suspect this will have to be refactored one
2090 * day if a single USB device can be a keyboard & a mouse
2091 * & a tablet, and the inputX number actually will tell
2094 if (usb_make_path(usbdev, path, 64) > 0)
2095 sprintf(aiptek->features.usbPath, "%s/input0", path);
2097 /* Program the input device coordinate capacities. We do not yet
2098 * know what maximum X, Y, and Z values are, so we're putting fake
2099 * values in. Later, we'll ask the tablet to put in the correct
2102 aiptek->inputdev.absmin[ABS_X] = 0;
2103 aiptek->inputdev.absmax[ABS_X] = 2999;
2104 aiptek->inputdev.absmin[ABS_Y] = 0;
2105 aiptek->inputdev.absmax[ABS_Y] = 2249;
2106 aiptek->inputdev.absmin[ABS_PRESSURE] = 0;
2107 aiptek->inputdev.absmax[ABS_PRESSURE] = 511;
2108 aiptek->inputdev.absmin[ABS_TILT_X] = AIPTEK_TILT_MIN;
2109 aiptek->inputdev.absmax[ABS_TILT_X] = AIPTEK_TILT_MAX;
2110 aiptek->inputdev.absmin[ABS_TILT_Y] = AIPTEK_TILT_MIN;
2111 aiptek->inputdev.absmax[ABS_TILT_Y] = AIPTEK_TILT_MAX;
2112 aiptek->inputdev.absmin[ABS_WHEEL] = AIPTEK_WHEEL_MIN;
2113 aiptek->inputdev.absmax[ABS_WHEEL] = AIPTEK_WHEEL_MAX - 1;
2114 aiptek->inputdev.absfuzz[ABS_X] = 0;
2115 aiptek->inputdev.absfuzz[ABS_Y] = 0;
2116 aiptek->inputdev.absfuzz[ABS_PRESSURE] = 0;
2117 aiptek->inputdev.absfuzz[ABS_TILT_X] = 0;
2118 aiptek->inputdev.absfuzz[ABS_TILT_Y] = 0;
2119 aiptek->inputdev.absfuzz[ABS_WHEEL] = 0;
2120 aiptek->inputdev.absflat[ABS_X] = 0;
2121 aiptek->inputdev.absflat[ABS_Y] = 0;
2122 aiptek->inputdev.absflat[ABS_PRESSURE] = 0;
2123 aiptek->inputdev.absflat[ABS_TILT_X] = 0;
2124 aiptek->inputdev.absflat[ABS_TILT_Y] = 0;
2125 aiptek->inputdev.absflat[ABS_WHEEL] = 0;
2126 aiptek->inputdev.name = "Aiptek";
2127 aiptek->inputdev.phys = aiptek->features.usbPath;
2128 aiptek->inputdev.id.bustype = BUS_USB;
2129 aiptek->inputdev.id.vendor = le16_to_cpu(usbdev->descriptor.idVendor);
2130 aiptek->inputdev.id.product = le16_to_cpu(usbdev->descriptor.idProduct);
2131 aiptek->inputdev.id.version = le16_to_cpu(usbdev->descriptor.bcdDevice);
2132 aiptek->inputdev.dev = &intf->dev;
2134 aiptek->usbdev = usbdev;
2135 aiptek->ifnum = intf->altsetting[0].desc.bInterfaceNumber;
2136 aiptek->inDelay = 0;
2137 aiptek->endDelay = 0;
2138 aiptek->previousJitterable = 0;
2140 endpoint = &intf->altsetting[0].endpoint[0].desc;
2142 /* Go set up our URB, which is called when the tablet receives
2145 usb_fill_int_urb(aiptek->urb,
2147 usb_rcvintpipe(aiptek->usbdev,
2148 endpoint->bEndpointAddress),
2149 aiptek->data, 8, aiptek_irq, aiptek,
2150 endpoint->bInterval);
2152 aiptek->urb->transfer_dma = aiptek->data_dma;
2153 aiptek->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
2155 /* Register the tablet as an Input Device
2157 input_register_device(&aiptek->inputdev);
2159 /* We now will look for the evdev device which is mapped to
2160 * the tablet. The partial name is kept in the link list of
2161 * input_handles associated with this input device.
2162 * What identifies an evdev input_handler is that it begins
2163 * with 'event', continues with a digit, and that in turn
2164 * is mapped to /{devfs}/input/eventN.
2166 inputdev = &aiptek->inputdev;
2167 list_for_each_safe(node, next, &inputdev->h_list) {
2168 inputhandle = to_handle(node);
2169 if (strncmp(inputhandle->name, "event", 5) == 0) {
2170 strcpy(aiptek->features.inputPath, inputhandle->name);
2175 info("input: Aiptek on %s (%s)\n", path, aiptek->features.inputPath);
2177 /* Program the tablet. This sets the tablet up in the mode
2178 * specified in newSetting, and also queries the tablet's
2179 * physical capacities.
2181 * Sanity check: if a tablet doesn't like the slow programmatic
2182 * delay, we often get sizes of 0x0. Let's use that as an indicator
2183 * to try faster delays, up to 25 ms. If that logic fails, well, you'll
2184 * have to explain to us how your tablet thinks it's 0x0, and yet that's
2188 for (i = 0; i < sizeof(speeds) / sizeof(speeds[0]); ++i) {
2189 aiptek->curSetting.programmableDelay = speeds[i];
2190 (void)aiptek_program_tablet(aiptek);
2191 if (aiptek->inputdev.absmax[ABS_X] > 0) {
2192 info("input: Aiptek using %d ms programming speed\n",
2193 aiptek->curSetting.programmableDelay);
2198 /* Associate this driver's struct with the usb interface.
2200 usb_set_intfdata(intf, aiptek);
2202 /* Set up the sysfs files
2204 aiptek_add_files(&intf->dev);
2206 /* Make sure the evdev module is loaded. Assuming evdev IS a module :-)
2208 if (request_module("evdev") != 0)
2209 info("aiptek: error loading 'evdev' module");
2214 /* Forward declaration */
2215 static void aiptek_disconnect(struct usb_interface *intf);
2217 static struct usb_driver aiptek_driver = {
2218 .owner = THIS_MODULE,
2220 .probe = aiptek_probe,
2221 .disconnect = aiptek_disconnect,
2222 .id_table = aiptek_ids,
2225 /***********************************************************************
2226 * Deal with tablet disconnecting from the system.
2228 static void aiptek_disconnect(struct usb_interface *intf)
2230 struct aiptek *aiptek = usb_get_intfdata(intf);
2232 /* Disassociate driver's struct with usb interface
2234 usb_set_intfdata(intf, NULL);
2235 if (aiptek != NULL) {
2236 /* Free & unhook everything from the system.
2238 usb_kill_urb(aiptek->urb);
2239 input_unregister_device(&aiptek->inputdev);
2240 aiptek_delete_files(&intf->dev);
2241 usb_free_urb(aiptek->urb);
2242 usb_buffer_free(interface_to_usbdev(intf),
2243 AIPTEK_PACKET_LENGTH,
2244 aiptek->data, aiptek->data_dma);
2249 static int __init aiptek_init(void)
2251 int result = usb_register(&aiptek_driver);
2253 info(DRIVER_VERSION ": " DRIVER_AUTHOR);
2259 static void __exit aiptek_exit(void)
2261 usb_deregister(&aiptek_driver);
2264 MODULE_AUTHOR(DRIVER_AUTHOR);
2265 MODULE_DESCRIPTION(DRIVER_DESC);
2266 MODULE_LICENSE("GPL");
2268 module_param(programmableDelay, int, 0);
2269 MODULE_PARM_DESC(programmableDelay, "delay used during tablet programming");
2270 module_param(jitterDelay, int, 0);
2271 MODULE_PARM_DESC(jitterDelay, "stylus/mouse settlement delay");
2273 module_init(aiptek_init);
2274 module_exit(aiptek_exit);