?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux v2.6.13
[linux-2.6/next.git] / drivers / usb / input / aiptek.c
blobcd0cbfe207232a3fd32ca468a07811279b2b59db
1 /*
2 * Native support for the Aiptek HyperPen USB Tablets
3 * (4000U/5000U/6000U/8000U/12000U)
4 *
5 * Copyright (c) 2001 Chris Atenasio <chris@crud.net>
6 * Copyright (c) 2002-2004 Bryan W. Headley <bwheadley@earthlink.net>
7 *
8 * based on wacom.c by
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>
15 *
16 * Many thanks to Oliver Kuechemann for his support.
17 *
18 * ChangeLog:
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
42 * for reports 1, 6.)
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.
48 *
49 * NOTE:
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
52 * "Tablet Manager".
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.
57 *
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.
62 *
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.
67 *
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
71 */
72
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/usb_input.h>
81 #include <linux/sched.h>
82 #include <asm/uaccess.h>
83 #include <asm/unaligned.h>
84
85 /*
86 * Version Information
87 */
88 #define DRIVER_VERSION "v1.5 (May-15-2004)"
89 #define DRIVER_AUTHOR "Bryan W. Headley/Chris Atenasio"
90 #define DRIVER_DESC "Aiptek HyperPen USB Tablet Driver (Linux 2.6.x)"
91
92 /*
93 * Aiptek status packet:
94 *
95 * (returned as Report 1 - relative coordinates from mouse and stylus)
96 *
97 * bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0
98 * byte0 0 0 0 0 0 0 0 1
99 * byte1 0 0 0 0 0 BS2 BS Tip
100 * byte2 X7 X6 X5 X4 X3 X2 X1 X0
101 * byte3 Y7 Y6 Y5 Y4 Y3 Y2 Y1 Y0
102 *
103 * (returned as Report 2 - absolute coordinates from the stylus)
104 *
105 * bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0
106 * byte0 0 0 0 0 0 0 1 0
107 * byte1 X7 X6 X5 X4 X3 X2 X1 X0
108 * byte2 X15 X14 X13 X12 X11 X10 X9 X8
109 * byte3 Y7 Y6 Y5 Y4 Y3 Y2 Y1 Y0
110 * byte4 Y15 Y14 Y13 Y12 Y11 Y10 Y9 Y8
111 * byte5 * * * BS2 BS1 Tip IR DV
112 * byte6 P7 P6 P5 P4 P3 P2 P1 P0
113 * byte7 P15 P14 P13 P12 P11 P10 P9 P8
114 *
115 * (returned as Report 3 - absolute coordinates from the mouse)
116 *
117 * bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0
118 * byte0 0 0 0 0 0 0 1 0
119 * byte1 X7 X6 X5 X4 X3 X2 X1 X0
120 * byte2 X15 X14 X13 X12 X11 X10 X9 X8
121 * byte3 Y7 Y6 Y5 Y4 Y3 Y2 Y1 Y0
122 * byte4 Y15 Y14 Y13 Y12 Y11 Y10 Y9 Y8
123 * byte5 * * * BS2 BS1 Tip IR DV
124 * byte6 P7 P6 P5 P4 P3 P2 P1 P0
125 * byte7 P15 P14 P13 P12 P11 P10 P9 P8
126 *
127 * (returned as Report 4 - macrokeys from the stylus)
128 *
129 * bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0
130 * byte0 0 0 0 0 0 1 0 0
131 * byte1 0 0 0 BS2 BS Tip IR DV
132 * byte2 0 0 0 0 0 0 1 0
133 * byte3 0 0 0 K4 K3 K2 K1 K0
134 * byte4 P7 P6 P5 P4 P3 P2 P1 P0
135 * byte5 P15 P14 P13 P12 P11 P10 P9 P8
136 *
137 * (returned as Report 5 - macrokeys from the mouse)
138 *
139 * bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0
140 * byte0 0 0 0 0 0 1 0 0
141 * byte1 0 0 0 BS2 BS Tip IR DV
142 * byte2 0 0 0 0 0 0 1 0
143 * byte3 0 0 0 K4 K3 K2 K1 K0
144 * byte4 P7 P6 P5 P4 P3 P2 P1 P0
145 * byte5 P15 P14 P13 P12 P11 P10 P9 P8
146 *
147 * IR: In Range = Proximity on
148 * DV = Data Valid
149 * BS = Barrel Switch (as in, macro keys)
150 * BS2 also referred to as Tablet Pick
151 *
152 * Command Summary:
153 *
154 * Use report_type CONTROL (3)
155 * Use report_id 2
156 *
157 * Command/Data Description Return Bytes Return Value
158 * 0x10/0x00 SwitchToMouse 0
159 * 0x10/0x01 SwitchToTablet 0
160 * 0x18/0x04 SetResolution 0
161 * 0x12/0xFF AutoGainOn 0
162 * 0x17/0x00 FilterOn 0
163 * 0x01/0x00 GetXExtension 2 MaxX
164 * 0x01/0x01 GetYExtension 2 MaxY
165 * 0x02/0x00 GetModelCode 2 ModelCode = LOBYTE
166 * 0x03/0x00 GetODMCode 2 ODMCode
167 * 0x08/0x00 GetPressureLevels 2 =512
168 * 0x04/0x00 GetFirmwareVersion 2 Firmware Version
169 * 0x11/0x02 EnableMacroKeys 0
170 *
171 * To initialize the tablet:
172 *
173 * (1) Send Resolution500LPI (Command)
174 * (2) Query for Model code (Option Report)
175 * (3) Query for ODM code (Option Report)
176 * (4) Query for firmware (Option Report)
177 * (5) Query for GetXExtension (Option Report)
178 * (6) Query for GetYExtension (Option Report)
179 * (7) Query for GetPressureLevels (Option Report)
180 * (8) SwitchToTablet for Absolute coordinates, or
181 * SwitchToMouse for Relative coordinates (Command)
182 * (9) EnableMacroKeys (Command)
183 * (10) FilterOn (Command)
184 * (11) AutoGainOn (Command)
185 *
186 * (Step 9 can be omitted, but you'll then have no function keys.)
187 */
188
189 #define USB_VENDOR_ID_AIPTEK 0x08ca
190 #define USB_REQ_GET_REPORT 0x01
191 #define USB_REQ_SET_REPORT 0x09
192
193 /* PointerMode codes
194 */
195 #define AIPTEK_POINTER_ONLY_MOUSE_MODE 0
196 #define AIPTEK_POINTER_ONLY_STYLUS_MODE 1
197 #define AIPTEK_POINTER_EITHER_MODE 2
198
199 #define AIPTEK_POINTER_ALLOW_MOUSE_MODE(a) \
200 (a == AIPTEK_POINTER_ONLY_MOUSE_MODE || \
201 a == AIPTEK_POINTER_EITHER_MODE)
202 #define AIPTEK_POINTER_ALLOW_STYLUS_MODE(a) \
203 (a == AIPTEK_POINTER_ONLY_STYLUS_MODE || \
204 a == AIPTEK_POINTER_EITHER_MODE)
205
206 /* CoordinateMode code
207 */
208 #define AIPTEK_COORDINATE_RELATIVE_MODE 0
209 #define AIPTEK_COORDINATE_ABSOLUTE_MODE 1
210
211 /* XTilt and YTilt values
212 */
213 #define AIPTEK_TILT_MIN (-128)
214 #define AIPTEK_TILT_MAX 127
215 #define AIPTEK_TILT_DISABLE (-10101)
216
217 /* Wheel values
218 */
219 #define AIPTEK_WHEEL_MIN 0
220 #define AIPTEK_WHEEL_MAX 1024
221 #define AIPTEK_WHEEL_DISABLE (-10101)
222
223 /* ToolCode values, which BTW are 0x140 .. 0x14f
224 * We have things set up such that if TOOL_BUTTON_FIRED_BIT is
225 * not set, we'll send one instance of AIPTEK_TOOL_BUTTON_xxx.
226 *
227 * Whenever the user resets the value, TOOL_BUTTON_FIRED_BIT will
228 * get reset.
229 */
230 #define TOOL_BUTTON(x) ((x) & 0x14f)
231 #define TOOL_BUTTON_FIRED(x) ((x) & 0x200)
232 #define TOOL_BUTTON_FIRED_BIT 0x200
233 /* toolMode codes
234 */
235 #define AIPTEK_TOOL_BUTTON_PEN_MODE BTN_TOOL_PEN
236 #define AIPTEK_TOOL_BUTTON_PEN_MODE BTN_TOOL_PEN
237 #define AIPTEK_TOOL_BUTTON_PENCIL_MODE BTN_TOOL_PENCIL
238 #define AIPTEK_TOOL_BUTTON_BRUSH_MODE BTN_TOOL_BRUSH
239 #define AIPTEK_TOOL_BUTTON_AIRBRUSH_MODE BTN_TOOL_AIRBRUSH
240 #define AIPTEK_TOOL_BUTTON_ERASER_MODE BTN_TOOL_RUBBER
241 #define AIPTEK_TOOL_BUTTON_MOUSE_MODE BTN_TOOL_MOUSE
242 #define AIPTEK_TOOL_BUTTON_LENS_MODE BTN_TOOL_LENS
243
244 /* Diagnostic message codes
245 */
246 #define AIPTEK_DIAGNOSTIC_NA 0
247 #define AIPTEK_DIAGNOSTIC_SENDING_RELATIVE_IN_ABSOLUTE 1
248 #define AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE 2
249 #define AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED 3
250
251 /* Time to wait (in ms) to help mask hand jittering
252 * when pressing the stylus buttons.
253 */
254 #define AIPTEK_JITTER_DELAY_DEFAULT 50
255
256 /* Time to wait (in ms) in-between sending the tablet
257 * a command and beginning the process of reading the return
258 * sequence from the tablet.
259 */
260 #define AIPTEK_PROGRAMMABLE_DELAY_25 25
261 #define AIPTEK_PROGRAMMABLE_DELAY_50 50
262 #define AIPTEK_PROGRAMMABLE_DELAY_100 100
263 #define AIPTEK_PROGRAMMABLE_DELAY_200 200
264 #define AIPTEK_PROGRAMMABLE_DELAY_300 300
265 #define AIPTEK_PROGRAMMABLE_DELAY_400 400
266 #define AIPTEK_PROGRAMMABLE_DELAY_DEFAULT AIPTEK_PROGRAMMABLE_DELAY_400
267
268 /* Mouse button programming
269 */
270 #define AIPTEK_MOUSE_LEFT_BUTTON 0x01
271 #define AIPTEK_MOUSE_RIGHT_BUTTON 0x02
272 #define AIPTEK_MOUSE_MIDDLE_BUTTON 0x04
273
274 /* Stylus button programming
275 */
276 #define AIPTEK_STYLUS_LOWER_BUTTON 0x08
277 #define AIPTEK_STYLUS_UPPER_BUTTON 0x10
278
279 /* Length of incoming packet from the tablet
280 */
281 #define AIPTEK_PACKET_LENGTH 8
282
283 /* We report in EV_MISC both the proximity and
284 * whether the report came from the stylus, tablet mouse
285 * or "unknown" -- Unknown when the tablet is in relative
286 * mode, because we only get report 1's.
287 */
288 #define AIPTEK_REPORT_TOOL_UNKNOWN 0x10
289 #define AIPTEK_REPORT_TOOL_STYLUS 0x20
290 #define AIPTEK_REPORT_TOOL_MOUSE 0x40
291
292 static int programmableDelay = AIPTEK_PROGRAMMABLE_DELAY_DEFAULT;
293 static int jitterDelay = AIPTEK_JITTER_DELAY_DEFAULT;
294
295 struct aiptek_features {
296 int odmCode; /* Tablet manufacturer code */
297 int modelCode; /* Tablet model code (not unique) */
298 int firmwareCode; /* prom/eeprom version */
299 char usbPath[64 + 1]; /* device's physical usb path */
300 char inputPath[64 + 1]; /* input device path */
301 };
302
303 struct aiptek_settings {
304 int pointerMode; /* stylus-, mouse-only or either */
305 int coordinateMode; /* absolute/relative coords */
306 int toolMode; /* pen, pencil, brush, etc. tool */
307 int xTilt; /* synthetic xTilt amount */
308 int yTilt; /* synthetic yTilt amount */
309 int wheel; /* synthetic wheel amount */
310 int stylusButtonUpper; /* stylus upper btn delivers... */
311 int stylusButtonLower; /* stylus lower btn delivers... */
312 int mouseButtonLeft; /* mouse left btn delivers... */
313 int mouseButtonMiddle; /* mouse middle btn delivers... */
314 int mouseButtonRight; /* mouse right btn delivers... */
315 int programmableDelay; /* delay for tablet programming */
316 int jitterDelay; /* delay for hand jittering */
317 };
318
319 struct aiptek {
320 struct input_dev inputdev; /* input device struct */
321 struct usb_device *usbdev; /* usb device struct */
322 struct urb *urb; /* urb for incoming reports */
323 dma_addr_t data_dma; /* our dma stuffage */
324 struct aiptek_features features; /* tablet's array of features */
325 struct aiptek_settings curSetting; /* tablet's current programmable */
326 struct aiptek_settings newSetting; /* ... and new param settings */
327 unsigned int ifnum; /* interface number for IO */
328 int diagnostic; /* tablet diagnostic codes */
329 unsigned long eventCount; /* event count */
330 int inDelay; /* jitter: in jitter delay? */
331 unsigned long endDelay; /* jitter: time when delay ends */
332 int previousJitterable; /* jitterable prev value */
333 unsigned char *data; /* incoming packet data */
334 };
335
336 /*
337 * Permit easy lookup of keyboard events to send, versus
338 * the bitmap which comes from the tablet. This hides the
339 * issue that the F_keys are not sequentially numbered.
340 */
341 static int macroKeyEvents[] = {
342 KEY_ESC, KEY_F1, KEY_F2, KEY_F3, KEY_F4, KEY_F5,
343 KEY_F6, KEY_F7, KEY_F8, KEY_F9, KEY_F10, KEY_F11,
344 KEY_F12, KEY_F13, KEY_F14, KEY_F15, KEY_F16, KEY_F17,
345 KEY_F18, KEY_F19, KEY_F20, KEY_F21, KEY_F22, KEY_F23,
346 KEY_F24, KEY_STOP, KEY_AGAIN, KEY_PROPS, KEY_UNDO,
347 KEY_FRONT, KEY_COPY, KEY_OPEN, KEY_PASTE, 0
348 };
349
350 /***********************************************************************
351 * Relative reports deliver values in 2's complement format to
352 * deal with negative offsets.
353 */
354 static int aiptek_convert_from_2s_complement(unsigned char c)
355 {
356 int ret;
357 unsigned char b = c;
358 int negate = 0;
359
360 if ((b & 0x80) != 0) {
361 b = ~b;
362 b--;
363 negate = 1;
364 }
365 ret = b;
366 ret = (negate == 1) ? -ret : ret;
367 return ret;
368 }
369
370 /***********************************************************************
371 * aiptek_irq can receive one of six potential reports.
372 * The documentation for each is in the body of the function.
373 *
374 * The tablet reports on several attributes per invocation of
375 * aiptek_irq. Because the Linux Input Event system allows the
376 * transmission of ONE attribute per input_report_xxx() call,
377 * collation has to be done on the other end to reconstitute
378 * a complete tablet report. Further, the number of Input Event reports
379 * submitted varies, depending on what USB report type, and circumstance.
380 * To deal with this, EV_MSC is used to indicate an 'end-of-report'
381 * message. This has been an undocumented convention understood by the kernel
382 * tablet driver and clients such as gpm and XFree86's tablet drivers.
383 *
384 * Of the information received from the tablet, the one piece I
385 * cannot transmit is the proximity bit (without resorting to an EV_MSC
386 * convention above.) I therefore have taken over REL_MISC and ABS_MISC
387 * (for relative and absolute reports, respectively) for communicating
388 * Proximity. Why two events? I thought it interesting to know if the
389 * Proximity event occurred while the tablet was in absolute or relative
390 * mode.
391 *
392 * Other tablets use the notion of a certain minimum stylus pressure
393 * to infer proximity. While that could have been done, that is yet
394 * another 'by convention' behavior, the documentation for which
395 * would be spread between two (or more) pieces of software.
396 *
397 * EV_MSC usage was terminated for this purpose in Linux 2.5.x, and
398 * replaced with the input_sync() method (which emits EV_SYN.)
399 */
400
401 static void aiptek_irq(struct urb *urb, struct pt_regs *regs)
402 {
403 struct aiptek *aiptek = urb->context;
404 unsigned char *data = aiptek->data;
405 struct input_dev *inputdev = &aiptek->inputdev;
406 int jitterable = 0;
407 int retval, macro, x, y, z, left, right, middle, p, dv, tip, bs, pck;
408
409 switch (urb->status) {
410 case 0:
411 /* Success */
412 break;
413
414 case -ECONNRESET:
415 case -ENOENT:
416 case -ESHUTDOWN:
417 /* This urb is terminated, clean up */
418 dbg("%s - urb shutting down with status: %d",
419 __FUNCTION__, urb->status);
420 return;
421
422 default:
423 dbg("%s - nonzero urb status received: %d",
424 __FUNCTION__, urb->status);
425 goto exit;
426 }
427
428 /* See if we are in a delay loop -- throw out report if true.
429 */
430 if (aiptek->inDelay == 1 && time_after(aiptek->endDelay, jiffies)) {
431 goto exit;
432 }
433
434 aiptek->inDelay = 0;
435 aiptek->eventCount++;
436
437 /* Report 1 delivers relative coordinates with either a stylus
438 * or the mouse. You do not know, however, which input
439 * tool generated the event.
440 */
441 if (data[0] == 1) {
442 if (aiptek->curSetting.coordinateMode ==
443 AIPTEK_COORDINATE_ABSOLUTE_MODE) {
444 aiptek->diagnostic =
445 AIPTEK_DIAGNOSTIC_SENDING_RELATIVE_IN_ABSOLUTE;
446 } else {
447 input_regs(inputdev, regs);
448
449 x = aiptek_convert_from_2s_complement(data[2]);
450 y = aiptek_convert_from_2s_complement(data[3]);
451
452 /* jitterable keeps track of whether any button has been pressed.
453 * We're also using it to remap the physical mouse button mask
454 * to pseudo-settings. (We don't specifically care about it's
455 * value after moving/transposing mouse button bitmasks, except
456 * that a non-zero value indicates that one or more
457 * mouse button was pressed.)
458 */
459 jitterable = data[5] & 0x07;
460
461 left = (data[5] & aiptek->curSetting.mouseButtonLeft) != 0 ? 1 : 0;
462 right = (data[5] & aiptek->curSetting.mouseButtonRight) != 0 ? 1 : 0;
463 middle = (data[5] & aiptek->curSetting.mouseButtonMiddle) != 0 ? 1 : 0;
464
465 input_report_key(inputdev, BTN_LEFT, left);
466 input_report_key(inputdev, BTN_MIDDLE, middle);
467 input_report_key(inputdev, BTN_RIGHT, right);
468 input_report_rel(inputdev, REL_X, x);
469 input_report_rel(inputdev, REL_Y, y);
470 input_report_rel(inputdev, REL_MISC, 1 | AIPTEK_REPORT_TOOL_UNKNOWN);
471
472 /* Wheel support is in the form of a single-event
473 * firing.
474 */
475 if (aiptek->curSetting.wheel != AIPTEK_WHEEL_DISABLE) {
476 input_report_rel(inputdev, REL_WHEEL,
477 aiptek->curSetting.wheel);
478 aiptek->curSetting.wheel = AIPTEK_WHEEL_DISABLE;
479 }
480 input_sync(inputdev);
481 }
482 }
483 /* Report 2 is delivered only by the stylus, and delivers
484 * absolute coordinates.
485 */
486 else if (data[0] == 2) {
487 if (aiptek->curSetting.coordinateMode == AIPTEK_COORDINATE_RELATIVE_MODE) {
488 aiptek->diagnostic = AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE;
489 } else if (!AIPTEK_POINTER_ALLOW_STYLUS_MODE
490 (aiptek->curSetting.pointerMode)) {
491 aiptek->diagnostic = AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED;
492 } else {
493 input_regs(inputdev, regs);
494
495 x = le16_to_cpu(get_unaligned((__le16 *) (data + 1)));
496 y = le16_to_cpu(get_unaligned((__le16 *) (data + 3)));
497 z = le16_to_cpu(get_unaligned((__le16 *) (data + 6)));
498
499 p = (data[5] & 0x01) != 0 ? 1 : 0;
500 dv = (data[5] & 0x02) != 0 ? 1 : 0;
501 tip = (data[5] & 0x04) != 0 ? 1 : 0;
502
503 /* Use jitterable to re-arrange button masks
504 */
505 jitterable = data[5] & 0x18;
506
507 bs = (data[5] & aiptek->curSetting.stylusButtonLower) != 0 ? 1 : 0;
508 pck = (data[5] & aiptek->curSetting.stylusButtonUpper) != 0 ? 1 : 0;
509
510 /* dv indicates 'data valid' (e.g., the tablet is in sync
511 * and has delivered a "correct" report) We will ignore
512 * all 'bad' reports...
513 */
514 if (dv != 0) {
515 /* If we've not already sent a tool_button_?? code, do
516 * so now. Then set FIRED_BIT so it won't be resent unless
517 * the user forces FIRED_BIT off.
518 */
519 if (TOOL_BUTTON_FIRED
520 (aiptek->curSetting.toolMode) == 0) {
521 input_report_key(inputdev,
522 TOOL_BUTTON(aiptek->curSetting.toolMode),
523 1);
524 aiptek->curSetting.toolMode |= TOOL_BUTTON_FIRED_BIT;
525 }
526
527 if (p != 0) {
528 input_report_abs(inputdev, ABS_X, x);
529 input_report_abs(inputdev, ABS_Y, y);
530 input_report_abs(inputdev, ABS_PRESSURE, z);
531
532 input_report_key(inputdev, BTN_TOUCH, tip);
533 input_report_key(inputdev, BTN_STYLUS, bs);
534 input_report_key(inputdev, BTN_STYLUS2, pck);
535
536 if (aiptek->curSetting.xTilt !=
537 AIPTEK_TILT_DISABLE) {
538 input_report_abs(inputdev,
539 ABS_TILT_X,
540 aiptek->curSetting.xTilt);
541 }
542 if (aiptek->curSetting.yTilt != AIPTEK_TILT_DISABLE) {
543 input_report_abs(inputdev,
544 ABS_TILT_Y,
545 aiptek->curSetting.yTilt);
546 }
547
548 /* Wheel support is in the form of a single-event
549 * firing.
550 */
551 if (aiptek->curSetting.wheel !=
552 AIPTEK_WHEEL_DISABLE) {
553 input_report_abs(inputdev,
554 ABS_WHEEL,
555 aiptek->curSetting.wheel);
556 aiptek->curSetting.wheel = AIPTEK_WHEEL_DISABLE;
557 }
558 }
559 input_report_abs(inputdev, ABS_MISC, p | AIPTEK_REPORT_TOOL_STYLUS);
560 input_sync(inputdev);
561 }
562 }
563 }
564 /* Report 3's come from the mouse in absolute mode.
565 */
566 else if (data[0] == 3) {
567 if (aiptek->curSetting.coordinateMode == AIPTEK_COORDINATE_RELATIVE_MODE) {
568 aiptek->diagnostic = AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE;
569 } else if (!AIPTEK_POINTER_ALLOW_MOUSE_MODE
570 (aiptek->curSetting.pointerMode)) {
571 aiptek->diagnostic = AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED;
572 } else {
573 input_regs(inputdev, regs);
574 x = le16_to_cpu(get_unaligned((__le16 *) (data + 1)));
575 y = le16_to_cpu(get_unaligned((__le16 *) (data + 3)));
576
577 jitterable = data[5] & 0x1c;
578
579 p = (data[5] & 0x01) != 0 ? 1 : 0;
580 dv = (data[5] & 0x02) != 0 ? 1 : 0;
581 left = (data[5] & aiptek->curSetting.mouseButtonLeft) != 0 ? 1 : 0;
582 right = (data[5] & aiptek->curSetting.mouseButtonRight) != 0 ? 1 : 0;
583 middle = (data[5] & aiptek->curSetting.mouseButtonMiddle) != 0 ? 1 : 0;
584
585 if (dv != 0) {
586 /* If we've not already sent a tool_button_?? code, do
587 * so now. Then set FIRED_BIT so it won't be resent unless
588 * the user forces FIRED_BIT off.
589 */
590 if (TOOL_BUTTON_FIRED
591 (aiptek->curSetting.toolMode) == 0) {
592 input_report_key(inputdev,
593 TOOL_BUTTON(aiptek->curSetting.toolMode),
594 1);
595 aiptek->curSetting.toolMode |= TOOL_BUTTON_FIRED_BIT;
596 }
597
598 if (p != 0) {
599 input_report_abs(inputdev, ABS_X, x);
600 input_report_abs(inputdev, ABS_Y, y);
601
602 input_report_key(inputdev, BTN_LEFT, left);
603 input_report_key(inputdev, BTN_MIDDLE, middle);
604 input_report_key(inputdev, BTN_RIGHT, right);
605
606 /* Wheel support is in the form of a single-event
607 * firing.
608 */
609 if (aiptek->curSetting.wheel != AIPTEK_WHEEL_DISABLE) {
610 input_report_abs(inputdev,
611 ABS_WHEEL,
612 aiptek->curSetting.wheel);
613 aiptek->curSetting.wheel = AIPTEK_WHEEL_DISABLE;
614 }
615 }
616 input_report_rel(inputdev, REL_MISC, p | AIPTEK_REPORT_TOOL_MOUSE);
617 input_sync(inputdev);
618 }
619 }
620 }
621 /* Report 4s come from the macro keys when pressed by stylus
622 */
623 else if (data[0] == 4) {
624 jitterable = data[1] & 0x18;
625
626 p = (data[1] & 0x01) != 0 ? 1 : 0;
627 dv = (data[1] & 0x02) != 0 ? 1 : 0;
628 tip = (data[1] & 0x04) != 0 ? 1 : 0;
629 bs = (data[1] & aiptek->curSetting.stylusButtonLower) != 0 ? 1 : 0;
630 pck = (data[1] & aiptek->curSetting.stylusButtonUpper) != 0 ? 1 : 0;
631
632 macro = data[3];
633 z = le16_to_cpu(get_unaligned((__le16 *) (data + 4)));
634
635 if (dv != 0) {
636 input_regs(inputdev, regs);
637
638 /* If we've not already sent a tool_button_?? code, do
639 * so now. Then set FIRED_BIT so it won't be resent unless
640 * the user forces FIRED_BIT off.
641 */
642 if (TOOL_BUTTON_FIRED(aiptek->curSetting.toolMode) == 0) {
643 input_report_key(inputdev,
644 TOOL_BUTTON(aiptek->curSetting.toolMode),
645 1);
646 aiptek->curSetting.toolMode |= TOOL_BUTTON_FIRED_BIT;
647 }
648
649 if (p != 0) {
650 input_report_key(inputdev, BTN_TOUCH, tip);
651 input_report_key(inputdev, BTN_STYLUS, bs);
652 input_report_key(inputdev, BTN_STYLUS2, pck);
653 input_report_abs(inputdev, ABS_PRESSURE, z);
654 }
655
656 /* For safety, we're sending key 'break' codes for the
657 * neighboring macro keys.
658 */
659 if (macro > 0) {
660 input_report_key(inputdev,
661 macroKeyEvents[macro - 1], 0);
662 }
663 if (macro < 25) {
664 input_report_key(inputdev,
665 macroKeyEvents[macro + 1], 0);
666 }
667 input_report_key(inputdev, macroKeyEvents[macro], p);
668 input_report_abs(inputdev, ABS_MISC,
669 p | AIPTEK_REPORT_TOOL_STYLUS);
670 input_sync(inputdev);
671 }
672 }
673 /* Report 5s come from the macro keys when pressed by mouse
674 */
675 else if (data[0] == 5) {
676 jitterable = data[1] & 0x1c;
677
678 p = (data[1] & 0x01) != 0 ? 1 : 0;
679 dv = (data[1] & 0x02) != 0 ? 1 : 0;
680 left = (data[1]& aiptek->curSetting.mouseButtonLeft) != 0 ? 1 : 0;
681 right = (data[1] & aiptek->curSetting.mouseButtonRight) != 0 ? 1 : 0;
682 middle = (data[1] & aiptek->curSetting.mouseButtonMiddle) != 0 ? 1 : 0;
683 macro = data[3];
684
685 if (dv != 0) {
686 input_regs(inputdev, regs);
687
688 /* If we've not already sent a tool_button_?? code, do
689 * so now. Then set FIRED_BIT so it won't be resent unless
690 * the user forces FIRED_BIT off.
691 */
692 if (TOOL_BUTTON_FIRED(aiptek->curSetting.toolMode) == 0) {
693 input_report_key(inputdev,
694 TOOL_BUTTON(aiptek->curSetting.toolMode),
695 1);
696 aiptek->curSetting.toolMode |= TOOL_BUTTON_FIRED_BIT;
697 }
698
699 if (p != 0) {
700 input_report_key(inputdev, BTN_LEFT, left);
701 input_report_key(inputdev, BTN_MIDDLE, middle);
702 input_report_key(inputdev, BTN_RIGHT, right);
703 }
704
705 /* For safety, we're sending key 'break' codes for the
706 * neighboring macro keys.
707 */
708 if (macro > 0) {
709 input_report_key(inputdev,
710 macroKeyEvents[macro - 1], 0);
711 }
712 if (macro < 25) {
713 input_report_key(inputdev,
714 macroKeyEvents[macro + 1], 0);
715 }
716
717 input_report_key(inputdev, macroKeyEvents[macro], 1);
718 input_report_rel(inputdev, ABS_MISC,
719 p | AIPTEK_REPORT_TOOL_MOUSE);
720 input_sync(inputdev);
721 }
722 }
723 /* We have no idea which tool can generate a report 6. Theoretically,
724 * neither need to, having been given reports 4 & 5 for such use.
725 * However, report 6 is the 'official-looking' report for macroKeys;
726 * reports 4 & 5 supposively are used to support unnamed, unknown
727 * hat switches (which just so happen to be the macroKeys.)
728 */
729 else if (data[0] == 6) {
730 macro = le16_to_cpu(get_unaligned((__le16 *) (data + 1)));
731 input_regs(inputdev, regs);
732
733 if (macro > 0) {
734 input_report_key(inputdev, macroKeyEvents[macro - 1],
735 0);
736 }
737 if (macro < 25) {
738 input_report_key(inputdev, macroKeyEvents[macro + 1],
739 0);
740 }
741
742 /* If we've not already sent a tool_button_?? code, do
743 * so now. Then set FIRED_BIT so it won't be resent unless
744 * the user forces FIRED_BIT off.
745 */
746 if (TOOL_BUTTON_FIRED(aiptek->curSetting.toolMode) == 0) {
747 input_report_key(inputdev,
748 TOOL_BUTTON(aiptek->curSetting.
749 toolMode), 1);
750 aiptek->curSetting.toolMode |= TOOL_BUTTON_FIRED_BIT;
751 }
752
753 input_report_key(inputdev, macroKeyEvents[macro], 1);
754 input_report_abs(inputdev, ABS_MISC,
755 1 | AIPTEK_REPORT_TOOL_UNKNOWN);
756 input_sync(inputdev);
757 } else {
758 dbg("Unknown report %d", data[0]);
759 }
760
761 /* Jitter may occur when the user presses a button on the stlyus
762 * or the mouse. What we do to prevent that is wait 'x' milliseconds
763 * following a 'jitterable' event, which should give the hand some time
764 * stabilize itself.
765 *
766 * We just introduced aiptek->previousJitterable to carry forth the
767 * notion that jitter occurs when the button state changes from on to off:
768 * a person drawing, holding a button down is not subject to jittering.
769 * With that in mind, changing from upper button depressed to lower button
770 * WILL transition through a jitter delay.
771 */
772
773 if (aiptek->previousJitterable != jitterable &&
774 aiptek->curSetting.jitterDelay != 0 && aiptek->inDelay != 1) {
775 aiptek->endDelay = jiffies +
776 ((aiptek->curSetting.jitterDelay * HZ) / 1000);
777 aiptek->inDelay = 1;
778 }
779 aiptek->previousJitterable = jitterable;
780
781 exit:
782 retval = usb_submit_urb(urb, GFP_ATOMIC);
783 if (retval != 0) {
784 err("%s - usb_submit_urb failed with result %d",
785 __FUNCTION__, retval);
786 }
787 }
788
789 /***********************************************************************
790 * These are the USB id's known so far. We do not identify them to
791 * specific Aiptek model numbers, because there has been overlaps,
792 * use, and reuse of id's in existing models. Certain models have
793 * been known to use more than one ID, indicative perhaps of
794 * manufacturing revisions. In any event, we consider these
795 * IDs to not be model-specific nor unique.
796 */
797 static const struct usb_device_id aiptek_ids[] = {
798 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x01)},
799 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x10)},
800 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x20)},
801 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x21)},
802 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x22)},
803 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x23)},
804 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x24)},
805 {}
806 };
807
808 MODULE_DEVICE_TABLE(usb, aiptek_ids);
809
810 /***********************************************************************
811 * Open an instance of the tablet driver.
812 */
813 static int aiptek_open(struct input_dev *inputdev)
814 {
815 struct aiptek *aiptek = inputdev->private;
816
817 aiptek->urb->dev = aiptek->usbdev;
818 if (usb_submit_urb(aiptek->urb, GFP_KERNEL) != 0)
819 return -EIO;
820
821 return 0;
822 }
823
824 /***********************************************************************
825 * Close an instance of the tablet driver.
826 */
827 static void aiptek_close(struct input_dev *inputdev)
828 {
829 struct aiptek *aiptek = inputdev->private;
830
831 usb_kill_urb(aiptek->urb);
832 }
833
834 /***********************************************************************
835 * aiptek_set_report and aiptek_get_report() are borrowed from Linux 2.4.x,
836 * where they were known as usb_set_report and usb_get_report.
837 */
838 static int
839 aiptek_set_report(struct aiptek *aiptek,
840 unsigned char report_type,
841 unsigned char report_id, void *buffer, int size)
842 {
843 return usb_control_msg(aiptek->usbdev,
844 usb_sndctrlpipe(aiptek->usbdev, 0),
845 USB_REQ_SET_REPORT,
846 USB_TYPE_CLASS | USB_RECIP_INTERFACE |
847 USB_DIR_OUT, (report_type << 8) + report_id,
848 aiptek->ifnum, buffer, size, 5000);
849 }
850
851 static int
852 aiptek_get_report(struct aiptek *aiptek,
853 unsigned char report_type,
854 unsigned char report_id, void *buffer, int size)
855 {
856 return usb_control_msg(aiptek->usbdev,
857 usb_rcvctrlpipe(aiptek->usbdev, 0),
858 USB_REQ_GET_REPORT,
859 USB_TYPE_CLASS | USB_RECIP_INTERFACE |
860 USB_DIR_IN, (report_type << 8) + report_id,
861 aiptek->ifnum, buffer, size, 5000);
862 }
863
864 /***********************************************************************
865 * Send a command to the tablet.
866 */
867 static int
868 aiptek_command(struct aiptek *aiptek, unsigned char command, unsigned char data)
869 {
870 const int sizeof_buf = 3 * sizeof(u8);
871 int ret;
872 u8 *buf;
873
874 buf = kmalloc(sizeof_buf, GFP_KERNEL);
875 if (!buf)
876 return -ENOMEM;
877
878 buf[0] = 2;
879 buf[1] = command;
880 buf[2] = data;
881
882 if ((ret =
883 aiptek_set_report(aiptek, 3, 2, buf, sizeof_buf)) != sizeof_buf) {
884 dbg("aiptek_program: failed, tried to send: 0x%02x 0x%02x",
885 command, data);
886 }
887 kfree(buf);
888 return ret < 0 ? ret : 0;
889 }
890
891 /***********************************************************************
892 * Retrieve information from the tablet. Querying info is defined as first
893 * sending the {command,data} sequence as a command, followed by a wait
894 * (aka, "programmaticDelay") and then a "read" request.
895 */
896 static int
897 aiptek_query(struct aiptek *aiptek, unsigned char command, unsigned char data)
898 {
899 const int sizeof_buf = 3 * sizeof(u8);
900 int ret;
901 u8 *buf;
902
903 buf = kmalloc(sizeof_buf, GFP_KERNEL);
904 if (!buf)
905 return -ENOMEM;
906
907 buf[0] = 2;
908 buf[1] = command;
909 buf[2] = data;
910
911 if (aiptek_command(aiptek, command, data) != 0) {
912 kfree(buf);
913 return -EIO;
914 }
915 msleep(aiptek->curSetting.programmableDelay);
916
917 if ((ret =
918 aiptek_get_report(aiptek, 3, 2, buf, sizeof_buf)) != sizeof_buf) {
919 dbg("aiptek_query failed: returned 0x%02x 0x%02x 0x%02x",
920 buf[0], buf[1], buf[2]);
921 ret = -EIO;
922 } else {
923 ret = le16_to_cpu(get_unaligned((__le16 *) (buf + 1)));
924 }
925 kfree(buf);
926 return ret;
927 }
928
929 /***********************************************************************
930 * Program the tablet into either absolute or relative mode.
931 * We also get information about the tablet's size.
932 */
933 static int aiptek_program_tablet(struct aiptek *aiptek)
934 {
935 int ret;
936 /* Execute Resolution500LPI */
937 if ((ret = aiptek_command(aiptek, 0x18, 0x04)) < 0)
938 return ret;
939
940 /* Query getModelCode */
941 if ((ret = aiptek_query(aiptek, 0x02, 0x00)) < 0)
942 return ret;
943 aiptek->features.modelCode = ret & 0xff;
944
945 /* Query getODMCode */
946 if ((ret = aiptek_query(aiptek, 0x03, 0x00)) < 0)
947 return ret;
948 aiptek->features.odmCode = ret;
949
950 /* Query getFirmwareCode */
951 if ((ret = aiptek_query(aiptek, 0x04, 0x00)) < 0)
952 return ret;
953 aiptek->features.firmwareCode = ret;
954
955 /* Query getXextension */
956 if ((ret = aiptek_query(aiptek, 0x01, 0x00)) < 0)
957 return ret;
958 aiptek->inputdev.absmin[ABS_X] = 0;
959 aiptek->inputdev.absmax[ABS_X] = ret - 1;
960
961 /* Query getYextension */
962 if ((ret = aiptek_query(aiptek, 0x01, 0x01)) < 0)
963 return ret;
964 aiptek->inputdev.absmin[ABS_Y] = 0;
965 aiptek->inputdev.absmax[ABS_Y] = ret - 1;
966
967 /* Query getPressureLevels */
968 if ((ret = aiptek_query(aiptek, 0x08, 0x00)) < 0)
969 return ret;
970 aiptek->inputdev.absmin[ABS_PRESSURE] = 0;
971 aiptek->inputdev.absmax[ABS_PRESSURE] = ret - 1;
972
973 /* Depending on whether we are in absolute or relative mode, we will
974 * do a switchToTablet(absolute) or switchToMouse(relative) command.
975 */
976 if (aiptek->curSetting.coordinateMode ==
977 AIPTEK_COORDINATE_ABSOLUTE_MODE) {
978 /* Execute switchToTablet */
979 if ((ret = aiptek_command(aiptek, 0x10, 0x01)) < 0) {
980 return ret;
981 }
982 } else {
983 /* Execute switchToMouse */
984 if ((ret = aiptek_command(aiptek, 0x10, 0x00)) < 0) {
985 return ret;
986 }
987 }
988
989 /* Enable the macro keys */
990 if ((ret = aiptek_command(aiptek, 0x11, 0x02)) < 0)
991 return ret;
992 #if 0
993 /* Execute FilterOn */
994 if ((ret = aiptek_command(aiptek, 0x17, 0x00)) < 0)
995 return ret;
996 #endif
997
998 /* Execute AutoGainOn */
999 if ((ret = aiptek_command(aiptek, 0x12, 0xff)) < 0)
1000 return ret;
1001
1002 /* Reset the eventCount, so we track events from last (re)programming
1003 */
1004 aiptek->diagnostic = AIPTEK_DIAGNOSTIC_NA;
1005 aiptek->eventCount = 0;
1006
1007 return 0;
1008 }
1009
1010 /***********************************************************************
1011 * Sysfs functions. Sysfs prefers that individually-tunable parameters
1012 * exist in their separate pseudo-files. Summary data that is immutable
1013 * may exist in a singular file so long as you don't define a writeable
1014 * interface.
1015 */
1016
1017 /***********************************************************************
1018 * support the 'size' file -- display support
1019 */
1020 static ssize_t show_tabletSize(struct device *dev, struct device_attribute *attr, char *buf)
1021 {
1022 struct aiptek *aiptek = dev_get_drvdata(dev);
1023
1024 if (aiptek == NULL)
1025 return 0;
1026
1027 return snprintf(buf, PAGE_SIZE, "%dx%d\n",
1028 aiptek->inputdev.absmax[ABS_X] + 1,
1029 aiptek->inputdev.absmax[ABS_Y] + 1);
1030 }
1031
1032 /* These structs define the sysfs files, param #1 is the name of the
1033 * file, param 2 is the file permissions, param 3 & 4 are to the
1034 * output generator and input parser routines. Absence of a routine is
1035 * permitted -- it only means can't either 'cat' the file, or send data
1036 * to it.
1037 */
1038 static DEVICE_ATTR(size, S_IRUGO, show_tabletSize, NULL);
1039
1040 /***********************************************************************
1041 * support routines for the 'product_id' file
1042 */
1043 static ssize_t show_tabletProductId(struct device *dev, struct device_attribute *attr, char *buf)
1044 {
1045 struct aiptek *aiptek = dev_get_drvdata(dev);
1046
1047 if (aiptek == NULL)
1048 return 0;
1049
1050 return snprintf(buf, PAGE_SIZE, "0x%04x\n",
1051 aiptek->inputdev.id.product);
1052 }
1053
1054 static DEVICE_ATTR(product_id, S_IRUGO, show_tabletProductId, NULL);
1055
1056 /***********************************************************************
1057 * support routines for the 'vendor_id' file
1058 */
1059 static ssize_t show_tabletVendorId(struct device *dev, struct device_attribute *attr, char *buf)
1060 {
1061 struct aiptek *aiptek = dev_get_drvdata(dev);
1062
1063 if (aiptek == NULL)
1064 return 0;
1065
1066 return snprintf(buf, PAGE_SIZE, "0x%04x\n", aiptek->inputdev.id.vendor);
1067 }
1068
1069 static DEVICE_ATTR(vendor_id, S_IRUGO, show_tabletVendorId, NULL);
1070
1071 /***********************************************************************
1072 * support routines for the 'vendor' file
1073 */
1074 static ssize_t show_tabletManufacturer(struct device *dev, struct device_attribute *attr, char *buf)
1075 {
1076 struct aiptek *aiptek = dev_get_drvdata(dev);
1077 int retval;
1078
1079 if (aiptek == NULL)
1080 return 0;
1081
1082 retval = snprintf(buf, PAGE_SIZE, "%s\n", aiptek->usbdev->manufacturer);
1083 return retval;
1084 }
1085
1086 static DEVICE_ATTR(vendor, S_IRUGO, show_tabletManufacturer, NULL);
1087
1088 /***********************************************************************
1089 * support routines for the 'product' file
1090 */
1091 static ssize_t show_tabletProduct(struct device *dev, struct device_attribute *attr, char *buf)
1092 {
1093 struct aiptek *aiptek = dev_get_drvdata(dev);
1094 int retval;
1095
1096 if (aiptek == NULL)
1097 return 0;
1098
1099 retval = snprintf(buf, PAGE_SIZE, "%s\n", aiptek->usbdev->product);
1100 return retval;
1101 }
1102
1103 static DEVICE_ATTR(product, S_IRUGO, show_tabletProduct, NULL);
1104
1105 /***********************************************************************
1106 * support routines for the 'pointer_mode' file. Note that this file
1107 * both displays current setting and allows reprogramming.
1108 */
1109 static ssize_t show_tabletPointerMode(struct device *dev, struct device_attribute *attr, char *buf)
1110 {
1111 struct aiptek *aiptek = dev_get_drvdata(dev);
1112 char *s;
1113
1114 if (aiptek == NULL)
1115 return 0;
1116
1117 switch (aiptek->curSetting.pointerMode) {
1118 case AIPTEK_POINTER_ONLY_STYLUS_MODE:
1119 s = "stylus";
1120 break;
1121
1122 case AIPTEK_POINTER_ONLY_MOUSE_MODE:
1123 s = "mouse";
1124 break;
1125
1126 case AIPTEK_POINTER_EITHER_MODE:
1127 s = "either";
1128 break;
1129
1130 default:
1131 s = "unknown";
1132 break;
1133 }
1134 return snprintf(buf, PAGE_SIZE, "%s\n", s);
1135 }
1136
1137 static ssize_t
1138 store_tabletPointerMode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1139 {
1140 struct aiptek *aiptek = dev_get_drvdata(dev);
1141 if (aiptek == NULL)
1142 return 0;
1143
1144 if (strcmp(buf, "stylus") == 0) {
1145 aiptek->newSetting.pointerMode =
1146 AIPTEK_POINTER_ONLY_STYLUS_MODE;
1147 } else if (strcmp(buf, "mouse") == 0) {
1148 aiptek->newSetting.pointerMode = AIPTEK_POINTER_ONLY_MOUSE_MODE;
1149 } else if (strcmp(buf, "either") == 0) {
1150 aiptek->newSetting.pointerMode = AIPTEK_POINTER_EITHER_MODE;
1151 }
1152 return count;
1153 }
1154
1155 static DEVICE_ATTR(pointer_mode,
1156 S_IRUGO | S_IWUGO,
1157 show_tabletPointerMode, store_tabletPointerMode);
1158
1159 /***********************************************************************
1160 * support routines for the 'coordinate_mode' file. Note that this file
1161 * both displays current setting and allows reprogramming.
1162 */
1163 static ssize_t show_tabletCoordinateMode(struct device *dev, struct device_attribute *attr, char *buf)
1164 {
1165 struct aiptek *aiptek = dev_get_drvdata(dev);
1166 char *s;
1167
1168 if (aiptek == NULL)
1169 return 0;
1170
1171 switch (aiptek->curSetting.coordinateMode) {
1172 case AIPTEK_COORDINATE_ABSOLUTE_MODE:
1173 s = "absolute";
1174 break;
1175
1176 case AIPTEK_COORDINATE_RELATIVE_MODE:
1177 s = "relative";
1178 break;
1179
1180 default:
1181 s = "unknown";
1182 break;
1183 }
1184 return snprintf(buf, PAGE_SIZE, "%s\n", s);
1185 }
1186
1187 static ssize_t
1188 store_tabletCoordinateMode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1189 {
1190 struct aiptek *aiptek = dev_get_drvdata(dev);
1191 if (aiptek == NULL)
1192 return 0;
1193
1194 if (strcmp(buf, "absolute") == 0) {
1195 aiptek->newSetting.pointerMode =
1196 AIPTEK_COORDINATE_ABSOLUTE_MODE;
1197 } else if (strcmp(buf, "relative") == 0) {
1198 aiptek->newSetting.pointerMode =
1199 AIPTEK_COORDINATE_RELATIVE_MODE;
1200 }
1201 return count;
1202 }
1203
1204 static DEVICE_ATTR(coordinate_mode,
1205 S_IRUGO | S_IWUGO,
1206 show_tabletCoordinateMode, store_tabletCoordinateMode);
1207
1208 /***********************************************************************
1209 * support routines for the 'tool_mode' file. Note that this file
1210 * both displays current setting and allows reprogramming.
1211 */
1212 static ssize_t show_tabletToolMode(struct device *dev, struct device_attribute *attr, char *buf)
1213 {
1214 struct aiptek *aiptek = dev_get_drvdata(dev);
1215 char *s;
1216
1217 if (aiptek == NULL)
1218 return 0;
1219
1220 switch (TOOL_BUTTON(aiptek->curSetting.toolMode)) {
1221 case AIPTEK_TOOL_BUTTON_MOUSE_MODE:
1222 s = "mouse";
1223 break;
1224
1225 case AIPTEK_TOOL_BUTTON_ERASER_MODE:
1226 s = "eraser";
1227 break;
1228
1229 case AIPTEK_TOOL_BUTTON_PENCIL_MODE:
1230 s = "pencil";
1231 break;
1232
1233 case AIPTEK_TOOL_BUTTON_PEN_MODE:
1234 s = "pen";
1235 break;
1236
1237 case AIPTEK_TOOL_BUTTON_BRUSH_MODE:
1238 s = "brush";
1239 break;
1240
1241 case AIPTEK_TOOL_BUTTON_AIRBRUSH_MODE:
1242 s = "airbrush";
1243 break;
1244
1245 case AIPTEK_TOOL_BUTTON_LENS_MODE:
1246 s = "lens";
1247 break;
1248
1249 default:
1250 s = "unknown";
1251 break;
1252 }
1253 return snprintf(buf, PAGE_SIZE, "%s\n", s);
1254 }
1255
1256 static ssize_t
1257 store_tabletToolMode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1258 {
1259 struct aiptek *aiptek = dev_get_drvdata(dev);
1260 if (aiptek == NULL)
1261 return 0;
1262
1263 if (strcmp(buf, "mouse") == 0) {
1264 aiptek->newSetting.toolMode = AIPTEK_TOOL_BUTTON_MOUSE_MODE;
1265 } else if (strcmp(buf, "eraser") == 0) {
1266 aiptek->newSetting.toolMode = AIPTEK_TOOL_BUTTON_ERASER_MODE;
1267 } else if (strcmp(buf, "pencil") == 0) {
1268 aiptek->newSetting.toolMode = AIPTEK_TOOL_BUTTON_PENCIL_MODE;
1269 } else if (strcmp(buf, "pen") == 0) {
1270 aiptek->newSetting.toolMode = AIPTEK_TOOL_BUTTON_PEN_MODE;
1271 } else if (strcmp(buf, "brush") == 0) {
1272 aiptek->newSetting.toolMode = AIPTEK_TOOL_BUTTON_BRUSH_MODE;
1273 } else if (strcmp(buf, "airbrush") == 0) {
1274 aiptek->newSetting.toolMode = AIPTEK_TOOL_BUTTON_AIRBRUSH_MODE;
1275 } else if (strcmp(buf, "lens") == 0) {
1276 aiptek->newSetting.toolMode = AIPTEK_TOOL_BUTTON_LENS_MODE;
1277 }
1278
1279 return count;
1280 }
1281
1282 static DEVICE_ATTR(tool_mode,
1283 S_IRUGO | S_IWUGO,
1284 show_tabletToolMode, store_tabletToolMode);
1285
1286 /***********************************************************************
1287 * support routines for the 'xtilt' file. Note that this file
1288 * both displays current setting and allows reprogramming.
1289 */
1290 static ssize_t show_tabletXtilt(struct device *dev, struct device_attribute *attr, char *buf)
1291 {
1292 struct aiptek *aiptek = dev_get_drvdata(dev);
1293
1294 if (aiptek == NULL)
1295 return 0;
1296
1297 if (aiptek->curSetting.xTilt == AIPTEK_TILT_DISABLE) {
1298 return snprintf(buf, PAGE_SIZE, "disable\n");
1299 } else {
1300 return snprintf(buf, PAGE_SIZE, "%d\n",
1301 aiptek->curSetting.xTilt);
1302 }
1303 }
1304
1305 static ssize_t
1306 store_tabletXtilt(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1307 {
1308 struct aiptek *aiptek = dev_get_drvdata(dev);
1309 int x;
1310
1311 if (aiptek == NULL)
1312 return 0;
1313
1314 if (strcmp(buf, "disable") == 0) {
1315 aiptek->newSetting.xTilt = AIPTEK_TILT_DISABLE;
1316 } else {
1317 x = (int)simple_strtol(buf, NULL, 10);
1318 if (x >= AIPTEK_TILT_MIN && x <= AIPTEK_TILT_MAX) {
1319 aiptek->newSetting.xTilt = x;
1320 }
1321 }
1322 return count;
1323 }
1324
1325 static DEVICE_ATTR(xtilt,
1326 S_IRUGO | S_IWUGO, show_tabletXtilt, store_tabletXtilt);
1327
1328 /***********************************************************************
1329 * support routines for the 'ytilt' file. Note that this file
1330 * both displays current setting and allows reprogramming.
1331 */
1332 static ssize_t show_tabletYtilt(struct device *dev, struct device_attribute *attr, char *buf)
1333 {
1334 struct aiptek *aiptek = dev_get_drvdata(dev);
1335
1336 if (aiptek == NULL)
1337 return 0;
1338
1339 if (aiptek->curSetting.yTilt == AIPTEK_TILT_DISABLE) {
1340 return snprintf(buf, PAGE_SIZE, "disable\n");
1341 } else {
1342 return snprintf(buf, PAGE_SIZE, "%d\n",
1343 aiptek->curSetting.yTilt);
1344 }
1345 }
1346
1347 static ssize_t
1348 store_tabletYtilt(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1349 {
1350 struct aiptek *aiptek = dev_get_drvdata(dev);
1351 int y;
1352
1353 if (aiptek == NULL)
1354 return 0;
1355
1356 if (strcmp(buf, "disable") == 0) {
1357 aiptek->newSetting.yTilt = AIPTEK_TILT_DISABLE;
1358 } else {
1359 y = (int)simple_strtol(buf, NULL, 10);
1360 if (y >= AIPTEK_TILT_MIN && y <= AIPTEK_TILT_MAX) {
1361 aiptek->newSetting.yTilt = y;
1362 }
1363 }
1364 return count;
1365 }
1366
1367 static DEVICE_ATTR(ytilt,
1368 S_IRUGO | S_IWUGO, show_tabletYtilt, store_tabletYtilt);
1369
1370 /***********************************************************************
1371 * support routines for the 'jitter' file. Note that this file
1372 * both displays current setting and allows reprogramming.
1373 */
1374 static ssize_t show_tabletJitterDelay(struct device *dev, struct device_attribute *attr, char *buf)
1375 {
1376 struct aiptek *aiptek = dev_get_drvdata(dev);
1377
1378 if (aiptek == NULL)
1379 return 0;
1380
1381 return snprintf(buf, PAGE_SIZE, "%d\n", aiptek->curSetting.jitterDelay);
1382 }
1383
1384 static ssize_t
1385 store_tabletJitterDelay(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1386 {
1387 struct aiptek *aiptek = dev_get_drvdata(dev);
1388
1389 if (aiptek == NULL)
1390 return 0;
1391
1392 aiptek->newSetting.jitterDelay = (int)simple_strtol(buf, NULL, 10);
1393 return count;
1394 }
1395
1396 static DEVICE_ATTR(jitter,
1397 S_IRUGO | S_IWUGO,
1398 show_tabletJitterDelay, store_tabletJitterDelay);
1399
1400 /***********************************************************************
1401 * support routines for the 'delay' file. Note that this file
1402 * both displays current setting and allows reprogramming.
1403 */
1404 static ssize_t show_tabletProgrammableDelay(struct device *dev, struct device_attribute *attr, char *buf)
1405 {
1406 struct aiptek *aiptek = dev_get_drvdata(dev);
1407
1408 if (aiptek == NULL)
1409 return 0;
1410
1411 return snprintf(buf, PAGE_SIZE, "%d\n",
1412 aiptek->curSetting.programmableDelay);
1413 }
1414
1415 static ssize_t
1416 store_tabletProgrammableDelay(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1417 {
1418 struct aiptek *aiptek = dev_get_drvdata(dev);
1419
1420 if (aiptek == NULL)
1421 return 0;
1422
1423 aiptek->newSetting.programmableDelay = (int)simple_strtol(buf, NULL, 10);
1424 return count;
1425 }
1426
1427 static DEVICE_ATTR(delay,
1428 S_IRUGO | S_IWUGO,
1429 show_tabletProgrammableDelay, store_tabletProgrammableDelay);
1430
1431 /***********************************************************************
1432 * support routines for the 'input_path' file. Note that this file
1433 * only displays current setting.
1434 */
1435 static ssize_t show_tabletInputDevice(struct device *dev, struct device_attribute *attr, char *buf)
1436 {
1437 struct aiptek *aiptek = dev_get_drvdata(dev);
1438
1439 if (aiptek == NULL)
1440 return 0;
1441
1442 return snprintf(buf, PAGE_SIZE, "/dev/input/%s\n",
1443 aiptek->features.inputPath);
1444 }
1445
1446 static DEVICE_ATTR(input_path, S_IRUGO, show_tabletInputDevice, NULL);
1447
1448 /***********************************************************************
1449 * support routines for the 'event_count' file. Note that this file
1450 * only displays current setting.
1451 */
1452 static ssize_t show_tabletEventsReceived(struct device *dev, struct device_attribute *attr, char *buf)
1453 {
1454 struct aiptek *aiptek = dev_get_drvdata(dev);
1455
1456 if (aiptek == NULL)
1457 return 0;
1458
1459 return snprintf(buf, PAGE_SIZE, "%ld\n", aiptek->eventCount);
1460 }
1461
1462 static DEVICE_ATTR(event_count, S_IRUGO, show_tabletEventsReceived, NULL);
1463
1464 /***********************************************************************
1465 * support routines for the 'diagnostic' file. Note that this file
1466 * only displays current setting.
1467 */
1468 static ssize_t show_tabletDiagnosticMessage(struct device *dev, struct device_attribute *attr, char *buf)
1469 {
1470 struct aiptek *aiptek = dev_get_drvdata(dev);
1471 char *retMsg;
1472
1473 if (aiptek == NULL)
1474 return 0;
1475
1476 switch (aiptek->diagnostic) {
1477 case AIPTEK_DIAGNOSTIC_NA:
1478 retMsg = "no errors\n";
1479 break;
1480
1481 case AIPTEK_DIAGNOSTIC_SENDING_RELATIVE_IN_ABSOLUTE:
1482 retMsg = "Error: receiving relative reports\n";
1483 break;
1484
1485 case AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE:
1486 retMsg = "Error: receiving absolute reports\n";
1487 break;
1488
1489 case AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED:
1490 if (aiptek->curSetting.pointerMode ==
1491 AIPTEK_POINTER_ONLY_MOUSE_MODE) {
1492 retMsg = "Error: receiving stylus reports\n";
1493 } else {
1494 retMsg = "Error: receiving mouse reports\n";
1495 }
1496 break;
1497
1498 default:
1499 return 0;
1500 }
1501 return snprintf(buf, PAGE_SIZE, retMsg);
1502 }
1503
1504 static DEVICE_ATTR(diagnostic, S_IRUGO, show_tabletDiagnosticMessage, NULL);
1505
1506 /***********************************************************************
1507 * support routines for the 'stylus_upper' file. Note that this file
1508 * both displays current setting and allows for setting changing.
1509 */
1510 static ssize_t show_tabletStylusUpper(struct device *dev, struct device_attribute *attr, char *buf)
1511 {
1512 struct aiptek *aiptek = dev_get_drvdata(dev);
1513 char *s;
1514
1515 if (aiptek == NULL)
1516 return 0;
1517
1518 switch (aiptek->curSetting.stylusButtonUpper) {
1519 case AIPTEK_STYLUS_UPPER_BUTTON:
1520 s = "upper";
1521 break;
1522
1523 case AIPTEK_STYLUS_LOWER_BUTTON:
1524 s = "lower";
1525 break;
1526
1527 default:
1528 s = "unknown";
1529 break;
1530 }
1531 return snprintf(buf, PAGE_SIZE, "%s\n", s);
1532 }
1533
1534 static ssize_t
1535 store_tabletStylusUpper(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1536 {
1537 struct aiptek *aiptek = dev_get_drvdata(dev);
1538
1539 if (aiptek == NULL)
1540 return 0;
1541
1542 if (strcmp(buf, "upper") == 0) {
1543 aiptek->newSetting.stylusButtonUpper =
1544 AIPTEK_STYLUS_UPPER_BUTTON;
1545 } else if (strcmp(buf, "lower") == 0) {
1546 aiptek->newSetting.stylusButtonUpper =
1547 AIPTEK_STYLUS_LOWER_BUTTON;
1548 }
1549 return count;
1550 }
1551
1552 static DEVICE_ATTR(stylus_upper,
1553 S_IRUGO | S_IWUGO,
1554 show_tabletStylusUpper, store_tabletStylusUpper);
1555
1556 /***********************************************************************
1557 * support routines for the 'stylus_lower' file. Note that this file
1558 * both displays current setting and allows for setting changing.
1559 */
1560 static ssize_t show_tabletStylusLower(struct device *dev, struct device_attribute *attr, char *buf)
1561 {
1562 struct aiptek *aiptek = dev_get_drvdata(dev);
1563 char *s;
1564
1565 if (aiptek == NULL)
1566 return 0;
1567
1568 switch (aiptek->curSetting.stylusButtonLower) {
1569 case AIPTEK_STYLUS_UPPER_BUTTON:
1570 s = "upper";
1571 break;
1572
1573 case AIPTEK_STYLUS_LOWER_BUTTON:
1574 s = "lower";
1575 break;
1576
1577 default:
1578 s = "unknown";
1579 break;
1580 }
1581 return snprintf(buf, PAGE_SIZE, "%s\n", s);
1582 }
1583
1584 static ssize_t
1585 store_tabletStylusLower(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1586 {
1587 struct aiptek *aiptek = dev_get_drvdata(dev);
1588
1589 if (aiptek == NULL)
1590 return 0;
1591
1592 if (strcmp(buf, "upper") == 0) {
1593 aiptek->newSetting.stylusButtonLower =
1594 AIPTEK_STYLUS_UPPER_BUTTON;
1595 } else if (strcmp(buf, "lower") == 0) {
1596 aiptek->newSetting.stylusButtonLower =
1597 AIPTEK_STYLUS_LOWER_BUTTON;
1598 }
1599 return count;
1600 }
1601
1602 static DEVICE_ATTR(stylus_lower,
1603 S_IRUGO | S_IWUGO,
1604 show_tabletStylusLower, store_tabletStylusLower);
1605
1606 /***********************************************************************
1607 * support routines for the 'mouse_left' file. Note that this file
1608 * both displays current setting and allows for setting changing.
1609 */
1610 static ssize_t show_tabletMouseLeft(struct device *dev, struct device_attribute *attr, char *buf)
1611 {
1612 struct aiptek *aiptek = dev_get_drvdata(dev);
1613 char *s;
1614
1615 if (aiptek == NULL)
1616 return 0;
1617
1618 switch (aiptek->curSetting.mouseButtonLeft) {
1619 case AIPTEK_MOUSE_LEFT_BUTTON:
1620 s = "left";
1621 break;
1622
1623 case AIPTEK_MOUSE_MIDDLE_BUTTON:
1624 s = "middle";
1625 break;
1626
1627 case AIPTEK_MOUSE_RIGHT_BUTTON:
1628 s = "right";
1629 break;
1630
1631 default:
1632 s = "unknown";
1633 break;
1634 }
1635 return snprintf(buf, PAGE_SIZE, "%s\n", s);
1636 }
1637
1638 static ssize_t
1639 store_tabletMouseLeft(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1640 {
1641 struct aiptek *aiptek = dev_get_drvdata(dev);
1642
1643 if (aiptek == NULL)
1644 return 0;
1645
1646 if (strcmp(buf, "left") == 0) {
1647 aiptek->newSetting.mouseButtonLeft = AIPTEK_MOUSE_LEFT_BUTTON;
1648 } else if (strcmp(buf, "middle") == 0) {
1649 aiptek->newSetting.mouseButtonLeft = AIPTEK_MOUSE_MIDDLE_BUTTON;
1650 } else if (strcmp(buf, "right") == 0) {
1651 aiptek->newSetting.mouseButtonLeft = AIPTEK_MOUSE_RIGHT_BUTTON;
1652 }
1653 return count;
1654 }
1655
1656 static DEVICE_ATTR(mouse_left,
1657 S_IRUGO | S_IWUGO,
1658 show_tabletMouseLeft, store_tabletMouseLeft);
1659
1660 /***********************************************************************
1661 * support routines for the 'mouse_middle' file. Note that this file
1662 * both displays current setting and allows for setting changing.
1663 */
1664 static ssize_t show_tabletMouseMiddle(struct device *dev, struct device_attribute *attr, char *buf)
1665 {
1666 struct aiptek *aiptek = dev_get_drvdata(dev);
1667 char *s;
1668
1669 if (aiptek == NULL)
1670 return 0;
1671
1672 switch (aiptek->curSetting.mouseButtonMiddle) {
1673 case AIPTEK_MOUSE_LEFT_BUTTON:
1674 s = "left";
1675 break;
1676
1677 case AIPTEK_MOUSE_MIDDLE_BUTTON:
1678 s = "middle";
1679 break;
1680
1681 case AIPTEK_MOUSE_RIGHT_BUTTON:
1682 s = "right";
1683 break;
1684
1685 default:
1686 s = "unknown";
1687 break;
1688 }
1689 return snprintf(buf, PAGE_SIZE, "%s\n", s);
1690 }
1691
1692 static ssize_t
1693 store_tabletMouseMiddle(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1694 {
1695 struct aiptek *aiptek = dev_get_drvdata(dev);
1696
1697 if (aiptek == NULL)
1698 return 0;
1699
1700 if (strcmp(buf, "left") == 0) {
1701 aiptek->newSetting.mouseButtonMiddle = AIPTEK_MOUSE_LEFT_BUTTON;
1702 } else if (strcmp(buf, "middle") == 0) {
1703 aiptek->newSetting.mouseButtonMiddle =
1704 AIPTEK_MOUSE_MIDDLE_BUTTON;
1705 } else if (strcmp(buf, "right") == 0) {
1706 aiptek->newSetting.mouseButtonMiddle =
1707 AIPTEK_MOUSE_RIGHT_BUTTON;
1708 }
1709 return count;
1710 }
1711
1712 static DEVICE_ATTR(mouse_middle,
1713 S_IRUGO | S_IWUGO,
1714 show_tabletMouseMiddle, store_tabletMouseMiddle);
1715
1716 /***********************************************************************
1717 * support routines for the 'mouse_right' file. Note that this file
1718 * both displays current setting and allows for setting changing.
1719 */
1720 static ssize_t show_tabletMouseRight(struct device *dev, struct device_attribute *attr, char *buf)
1721 {
1722 struct aiptek *aiptek = dev_get_drvdata(dev);
1723 char *s;
1724
1725 if (aiptek == NULL)
1726 return 0;
1727
1728 switch (aiptek->curSetting.mouseButtonRight) {
1729 case AIPTEK_MOUSE_LEFT_BUTTON:
1730 s = "left";
1731 break;
1732
1733 case AIPTEK_MOUSE_MIDDLE_BUTTON:
1734 s = "middle";
1735 break;
1736
1737 case AIPTEK_MOUSE_RIGHT_BUTTON:
1738 s = "right";
1739 break;
1740
1741 default:
1742 s = "unknown";
1743 break;
1744 }
1745 return snprintf(buf, PAGE_SIZE, "%s\n", s);
1746 }
1747
1748 static ssize_t
1749 store_tabletMouseRight(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1750 {
1751 struct aiptek *aiptek = dev_get_drvdata(dev);
1752
1753 if (aiptek == NULL)
1754 return 0;
1755
1756 if (strcmp(buf, "left") == 0) {
1757 aiptek->newSetting.mouseButtonRight = AIPTEK_MOUSE_LEFT_BUTTON;
1758 } else if (strcmp(buf, "middle") == 0) {
1759 aiptek->newSetting.mouseButtonRight =
1760 AIPTEK_MOUSE_MIDDLE_BUTTON;
1761 } else if (strcmp(buf, "right") == 0) {
1762 aiptek->newSetting.mouseButtonRight = AIPTEK_MOUSE_RIGHT_BUTTON;
1763 }
1764 return count;
1765 }
1766
1767 static DEVICE_ATTR(mouse_right,
1768 S_IRUGO | S_IWUGO,
1769 show_tabletMouseRight, store_tabletMouseRight);
1770
1771 /***********************************************************************
1772 * support routines for the 'wheel' file. Note that this file
1773 * both displays current setting and allows for setting changing.
1774 */
1775 static ssize_t show_tabletWheel(struct device *dev, struct device_attribute *attr, char *buf)
1776 {
1777 struct aiptek *aiptek = dev_get_drvdata(dev);
1778
1779 if (aiptek == NULL)
1780 return 0;
1781
1782 if (aiptek->curSetting.wheel == AIPTEK_WHEEL_DISABLE) {
1783 return snprintf(buf, PAGE_SIZE, "disable\n");
1784 } else {
1785 return snprintf(buf, PAGE_SIZE, "%d\n",
1786 aiptek->curSetting.wheel);
1787 }
1788 }
1789
1790 static ssize_t
1791 store_tabletWheel(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1792 {
1793 struct aiptek *aiptek = dev_get_drvdata(dev);
1794
1795 if (aiptek == NULL)
1796 return 0;
1797
1798 aiptek->newSetting.wheel = (int)simple_strtol(buf, NULL, 10);
1799 return count;
1800 }
1801
1802 static DEVICE_ATTR(wheel,
1803 S_IRUGO | S_IWUGO, show_tabletWheel, store_tabletWheel);
1804
1805 /***********************************************************************
1806 * support routines for the 'execute' file. Note that this file
1807 * both displays current setting and allows for setting changing.
1808 */
1809 static ssize_t show_tabletExecute(struct device *dev, struct device_attribute *attr, char *buf)
1810 {
1811 struct aiptek *aiptek = dev_get_drvdata(dev);
1812
1813 if (aiptek == NULL)
1814 return 0;
1815
1816 /* There is nothing useful to display, so a one-line manual
1817 * is in order...
1818 */
1819 return snprintf(buf, PAGE_SIZE,
1820 "Write anything to this file to program your tablet.\n");
1821 }
1822
1823 static ssize_t
1824 store_tabletExecute(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1825 {
1826 struct aiptek *aiptek = dev_get_drvdata(dev);
1827
1828 if (aiptek == NULL)
1829 return 0;
1830
1831 /* We do not care what you write to this file. Merely the action
1832 * of writing to this file triggers a tablet reprogramming.
1833 */
1834 memcpy(&aiptek->curSetting, &aiptek->newSetting,
1835 sizeof(struct aiptek_settings));
1836
1837 if (aiptek_program_tablet(aiptek) < 0)
1838 return -EIO;
1839
1840 return count;
1841 }
1842
1843 static DEVICE_ATTR(execute,
1844 S_IRUGO | S_IWUGO, show_tabletExecute, store_tabletExecute);
1845
1846 /***********************************************************************
1847 * support routines for the 'odm_code' file. Note that this file
1848 * only displays current setting.
1849 */
1850 static ssize_t show_tabletODMCode(struct device *dev, struct device_attribute *attr, char *buf)
1851 {
1852 struct aiptek *aiptek = dev_get_drvdata(dev);
1853
1854 if (aiptek == NULL)
1855 return 0;
1856
1857 return snprintf(buf, PAGE_SIZE, "0x%04x\n", aiptek->features.odmCode);
1858 }
1859
1860 static DEVICE_ATTR(odm_code, S_IRUGO, show_tabletODMCode, NULL);
1861
1862 /***********************************************************************
1863 * support routines for the 'model_code' file. Note that this file
1864 * only displays current setting.
1865 */
1866 static ssize_t show_tabletModelCode(struct device *dev, struct device_attribute *attr, char *buf)
1867 {
1868 struct aiptek *aiptek = dev_get_drvdata(dev);
1869
1870 if (aiptek == NULL)
1871 return 0;
1872
1873 return snprintf(buf, PAGE_SIZE, "0x%04x\n", aiptek->features.modelCode);
1874 }
1875
1876 static DEVICE_ATTR(model_code, S_IRUGO, show_tabletModelCode, NULL);
1877
1878 /***********************************************************************
1879 * support routines for the 'firmware_code' file. Note that this file
1880 * only displays current setting.
1881 */
1882 static ssize_t show_firmwareCode(struct device *dev, struct device_attribute *attr, char *buf)
1883 {
1884 struct aiptek *aiptek = dev_get_drvdata(dev);
1885
1886 if (aiptek == NULL)
1887 return 0;
1888
1889 return snprintf(buf, PAGE_SIZE, "%04x\n",
1890 aiptek->features.firmwareCode);
1891 }
1892
1893 static DEVICE_ATTR(firmware_code, S_IRUGO, show_firmwareCode, NULL);
1894
1895 /***********************************************************************
1896 * This routine removes all existing sysfs files managed by this device
1897 * driver.
1898 */
1899 static void aiptek_delete_files(struct device *dev)
1900 {
1901 device_remove_file(dev, &dev_attr_size);
1902 device_remove_file(dev, &dev_attr_product_id);
1903 device_remove_file(dev, &dev_attr_vendor_id);
1904 device_remove_file(dev, &dev_attr_vendor);
1905 device_remove_file(dev, &dev_attr_product);
1906 device_remove_file(dev, &dev_attr_pointer_mode);
1907 device_remove_file(dev, &dev_attr_coordinate_mode);
1908 device_remove_file(dev, &dev_attr_tool_mode);
1909 device_remove_file(dev, &dev_attr_xtilt);
1910 device_remove_file(dev, &dev_attr_ytilt);
1911 device_remove_file(dev, &dev_attr_jitter);
1912 device_remove_file(dev, &dev_attr_delay);
1913 device_remove_file(dev, &dev_attr_input_path);
1914 device_remove_file(dev, &dev_attr_event_count);
1915 device_remove_file(dev, &dev_attr_diagnostic);
1916 device_remove_file(dev, &dev_attr_odm_code);
1917 device_remove_file(dev, &dev_attr_model_code);
1918 device_remove_file(dev, &dev_attr_firmware_code);
1919 device_remove_file(dev, &dev_attr_stylus_lower);
1920 device_remove_file(dev, &dev_attr_stylus_upper);
1921 device_remove_file(dev, &dev_attr_mouse_left);
1922 device_remove_file(dev, &dev_attr_mouse_middle);
1923 device_remove_file(dev, &dev_attr_mouse_right);
1924 device_remove_file(dev, &dev_attr_wheel);
1925 device_remove_file(dev, &dev_attr_execute);
1926 }
1927
1928 /***********************************************************************
1929 * This routine creates the sysfs files managed by this device
1930 * driver.
1931 */
1932 static int aiptek_add_files(struct device *dev)
1933 {
1934 int ret;
1935
1936 if ((ret = device_create_file(dev, &dev_attr_size)) ||
1937 (ret = device_create_file(dev, &dev_attr_product_id)) ||
1938 (ret = device_create_file(dev, &dev_attr_vendor_id)) ||
1939 (ret = device_create_file(dev, &dev_attr_vendor)) ||
1940 (ret = device_create_file(dev, &dev_attr_product)) ||
1941 (ret = device_create_file(dev, &dev_attr_pointer_mode)) ||
1942 (ret = device_create_file(dev, &dev_attr_coordinate_mode)) ||
1943 (ret = device_create_file(dev, &dev_attr_tool_mode)) ||
1944 (ret = device_create_file(dev, &dev_attr_xtilt)) ||
1945 (ret = device_create_file(dev, &dev_attr_ytilt)) ||
1946 (ret = device_create_file(dev, &dev_attr_jitter)) ||
1947 (ret = device_create_file(dev, &dev_attr_delay)) ||
1948 (ret = device_create_file(dev, &dev_attr_input_path)) ||
1949 (ret = device_create_file(dev, &dev_attr_event_count)) ||
1950 (ret = device_create_file(dev, &dev_attr_diagnostic)) ||
1951 (ret = device_create_file(dev, &dev_attr_odm_code)) ||
1952 (ret = device_create_file(dev, &dev_attr_model_code)) ||
1953 (ret = device_create_file(dev, &dev_attr_firmware_code)) ||
1954 (ret = device_create_file(dev, &dev_attr_stylus_lower)) ||
1955 (ret = device_create_file(dev, &dev_attr_stylus_upper)) ||
1956 (ret = device_create_file(dev, &dev_attr_mouse_left)) ||
1957 (ret = device_create_file(dev, &dev_attr_mouse_middle)) ||
1958 (ret = device_create_file(dev, &dev_attr_mouse_right)) ||
1959 (ret = device_create_file(dev, &dev_attr_wheel)) ||
1960 (ret = device_create_file(dev, &dev_attr_execute))) {
1961 err("aiptek: killing own sysfs device files\n");
1962 aiptek_delete_files(dev);
1963 }
1964 return ret;
1965 }
1966
1967 /***********************************************************************
1968 * This routine is called when a tablet has been identified. It basically
1969 * sets up the tablet and the driver's internal structures.
1970 */
1971 static int
1972 aiptek_probe(struct usb_interface *intf, const struct usb_device_id *id)
1973 {
1974 struct usb_device *usbdev = interface_to_usbdev(intf);
1975 struct usb_endpoint_descriptor *endpoint;
1976 struct aiptek *aiptek;
1977 struct input_dev *inputdev;
1978 struct input_handle *inputhandle;
1979 struct list_head *node, *next;
1980 char path[64 + 1];
1981 int i;
1982 int speeds[] = { 0,
1983 AIPTEK_PROGRAMMABLE_DELAY_50,
1984 AIPTEK_PROGRAMMABLE_DELAY_400,
1985 AIPTEK_PROGRAMMABLE_DELAY_25,
1986 AIPTEK_PROGRAMMABLE_DELAY_100,
1987 AIPTEK_PROGRAMMABLE_DELAY_200,
1988 AIPTEK_PROGRAMMABLE_DELAY_300
1989 };
1990
1991 /* programmableDelay is where the command-line specified
1992 * delay is kept. We make it the first element of speeds[],
1993 * so therefore, your override speed is tried first, then the
1994 * remainder. Note that the default value of 400ms will be tried
1995 * if you do not specify any command line parameter.
1996 */
1997 speeds[0] = programmableDelay;
1998
1999 if ((aiptek = kmalloc(sizeof(struct aiptek), GFP_KERNEL)) == NULL)
2000 return -ENOMEM;
2001 memset(aiptek, 0, sizeof(struct aiptek));
2002
2003 aiptek->data = usb_buffer_alloc(usbdev, AIPTEK_PACKET_LENGTH,
2004 SLAB_ATOMIC, &aiptek->data_dma);
2005 if (aiptek->data == NULL) {
2006 kfree(aiptek);
2007 return -ENOMEM;
2008 }
2009
2010 aiptek->urb = usb_alloc_urb(0, GFP_KERNEL);
2011 if (aiptek->urb == NULL) {
2012 usb_buffer_free(usbdev, AIPTEK_PACKET_LENGTH, aiptek->data,
2013 aiptek->data_dma);
2014 kfree(aiptek);
2015 return -ENOMEM;
2016 }
2017
2018 /* Set up the curSettings struct. Said struct contains the current
2019 * programmable parameters. The newSetting struct contains changes
2020 * the user makes to the settings via the sysfs interface. Those
2021 * changes are not "committed" to curSettings until the user
2022 * writes to the sysfs/.../execute file.
2023 */
2024 aiptek->curSetting.pointerMode = AIPTEK_POINTER_EITHER_MODE;
2025 aiptek->curSetting.coordinateMode = AIPTEK_COORDINATE_ABSOLUTE_MODE;
2026 aiptek->curSetting.toolMode = AIPTEK_TOOL_BUTTON_PEN_MODE;
2027 aiptek->curSetting.xTilt = AIPTEK_TILT_DISABLE;
2028 aiptek->curSetting.yTilt = AIPTEK_TILT_DISABLE;
2029 aiptek->curSetting.mouseButtonLeft = AIPTEK_MOUSE_LEFT_BUTTON;
2030 aiptek->curSetting.mouseButtonMiddle = AIPTEK_MOUSE_MIDDLE_BUTTON;
2031 aiptek->curSetting.mouseButtonRight = AIPTEK_MOUSE_RIGHT_BUTTON;
2032 aiptek->curSetting.stylusButtonUpper = AIPTEK_STYLUS_UPPER_BUTTON;
2033 aiptek->curSetting.stylusButtonLower = AIPTEK_STYLUS_LOWER_BUTTON;
2034 aiptek->curSetting.jitterDelay = jitterDelay;
2035 aiptek->curSetting.programmableDelay = programmableDelay;
2036
2037 /* Both structs should have equivalent settings
2038 */
2039 memcpy(&aiptek->newSetting, &aiptek->curSetting,
2040 sizeof(struct aiptek_settings));
2041
2042 /* Now program the capacities of the tablet, in terms of being
2043 * an input device.
2044 */
2045 aiptek->inputdev.evbit[0] |= BIT(EV_KEY)
2046 | BIT(EV_ABS)
2047 | BIT(EV_REL)
2048 | BIT(EV_MSC);
2049
2050 aiptek->inputdev.absbit[0] |=
2051 (BIT(ABS_X) |
2052 BIT(ABS_Y) |
2053 BIT(ABS_PRESSURE) |
2054 BIT(ABS_TILT_X) |
2055 BIT(ABS_TILT_Y) | BIT(ABS_WHEEL) | BIT(ABS_MISC));
2056
2057 aiptek->inputdev.relbit[0] |=
2058 (BIT(REL_X) | BIT(REL_Y) | BIT(REL_WHEEL) | BIT(REL_MISC));
2059
2060 aiptek->inputdev.keybit[LONG(BTN_LEFT)] |=
2061 (BIT(BTN_LEFT) | BIT(BTN_RIGHT) | BIT(BTN_MIDDLE));
2062
2063 aiptek->inputdev.keybit[LONG(BTN_DIGI)] |=
2064 (BIT(BTN_TOOL_PEN) |
2065 BIT(BTN_TOOL_RUBBER) |
2066 BIT(BTN_TOOL_PENCIL) |
2067 BIT(BTN_TOOL_AIRBRUSH) |
2068 BIT(BTN_TOOL_BRUSH) |
2069 BIT(BTN_TOOL_MOUSE) |
2070 BIT(BTN_TOOL_LENS) |
2071 BIT(BTN_TOUCH) | BIT(BTN_STYLUS) | BIT(BTN_STYLUS2));
2072
2073 aiptek->inputdev.mscbit[0] = BIT(MSC_SERIAL);
2074
2075 /* Programming the tablet macro keys needs to be done with a for loop
2076 * as the keycodes are discontiguous.
2077 */
2078 for (i = 0; i < sizeof(macroKeyEvents) / sizeof(macroKeyEvents[0]); ++i)
2079 set_bit(macroKeyEvents[i], aiptek->inputdev.keybit);
2080
2081 /* Set up client data, pointers to open and close routines
2082 * for the input device.
2083 */
2084 aiptek->inputdev.private = aiptek;
2085 aiptek->inputdev.open = aiptek_open;
2086 aiptek->inputdev.close = aiptek_close;
2087
2088 /* Determine the usb devices' physical path.
2089 * Asketh not why we always pretend we're using "../input0",
2090 * but I suspect this will have to be refactored one
2091 * day if a single USB device can be a keyboard & a mouse
2092 * & a tablet, and the inputX number actually will tell
2093 * us something...
2094 */
2095 if (usb_make_path(usbdev, path, 64) > 0)
2096 sprintf(aiptek->features.usbPath, "%s/input0", path);
2097
2098 /* Program the input device coordinate capacities. We do not yet
2099 * know what maximum X, Y, and Z values are, so we're putting fake
2100 * values in. Later, we'll ask the tablet to put in the correct
2101 * values.
2102 */
2103 aiptek->inputdev.absmin[ABS_X] = 0;
2104 aiptek->inputdev.absmax[ABS_X] = 2999;
2105 aiptek->inputdev.absmin[ABS_Y] = 0;
2106 aiptek->inputdev.absmax[ABS_Y] = 2249;
2107 aiptek->inputdev.absmin[ABS_PRESSURE] = 0;
2108 aiptek->inputdev.absmax[ABS_PRESSURE] = 511;
2109 aiptek->inputdev.absmin[ABS_TILT_X] = AIPTEK_TILT_MIN;
2110 aiptek->inputdev.absmax[ABS_TILT_X] = AIPTEK_TILT_MAX;
2111 aiptek->inputdev.absmin[ABS_TILT_Y] = AIPTEK_TILT_MIN;
2112 aiptek->inputdev.absmax[ABS_TILT_Y] = AIPTEK_TILT_MAX;
2113 aiptek->inputdev.absmin[ABS_WHEEL] = AIPTEK_WHEEL_MIN;
2114 aiptek->inputdev.absmax[ABS_WHEEL] = AIPTEK_WHEEL_MAX - 1;
2115 aiptek->inputdev.absfuzz[ABS_X] = 0;
2116 aiptek->inputdev.absfuzz[ABS_Y] = 0;
2117 aiptek->inputdev.absfuzz[ABS_PRESSURE] = 0;
2118 aiptek->inputdev.absfuzz[ABS_TILT_X] = 0;
2119 aiptek->inputdev.absfuzz[ABS_TILT_Y] = 0;
2120 aiptek->inputdev.absfuzz[ABS_WHEEL] = 0;
2121 aiptek->inputdev.absflat[ABS_X] = 0;
2122 aiptek->inputdev.absflat[ABS_Y] = 0;
2123 aiptek->inputdev.absflat[ABS_PRESSURE] = 0;
2124 aiptek->inputdev.absflat[ABS_TILT_X] = 0;
2125 aiptek->inputdev.absflat[ABS_TILT_Y] = 0;
2126 aiptek->inputdev.absflat[ABS_WHEEL] = 0;
2127 aiptek->inputdev.name = "Aiptek";
2128 aiptek->inputdev.phys = aiptek->features.usbPath;
2129 usb_to_input_id(usbdev, &aiptek->inputdev.id);
2130 aiptek->inputdev.dev = &intf->dev;
2131
2132 aiptek->usbdev = usbdev;
2133 aiptek->ifnum = intf->altsetting[0].desc.bInterfaceNumber;
2134 aiptek->inDelay = 0;
2135 aiptek->endDelay = 0;
2136 aiptek->previousJitterable = 0;
2137
2138 endpoint = &intf->altsetting[0].endpoint[0].desc;
2139
2140 /* Go set up our URB, which is called when the tablet receives
2141 * input.
2142 */
2143 usb_fill_int_urb(aiptek->urb,
2144 aiptek->usbdev,
2145 usb_rcvintpipe(aiptek->usbdev,
2146 endpoint->bEndpointAddress),
2147 aiptek->data, 8, aiptek_irq, aiptek,
2148 endpoint->bInterval);
2149
2150 aiptek->urb->transfer_dma = aiptek->data_dma;
2151 aiptek->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
2152
2153 /* Register the tablet as an Input Device
2154 */
2155 input_register_device(&aiptek->inputdev);
2156
2157 /* We now will look for the evdev device which is mapped to
2158 * the tablet. The partial name is kept in the link list of
2159 * input_handles associated with this input device.
2160 * What identifies an evdev input_handler is that it begins
2161 * with 'event', continues with a digit, and that in turn
2162 * is mapped to /{devfs}/input/eventN.
2163 */
2164 inputdev = &aiptek->inputdev;
2165 list_for_each_safe(node, next, &inputdev->h_list) {
2166 inputhandle = to_handle(node);
2167 if (strncmp(inputhandle->name, "event", 5) == 0) {
2168 strcpy(aiptek->features.inputPath, inputhandle->name);
2169 break;
2170 }
2171 }
2172
2173 info("input: Aiptek on %s (%s)\n", path, aiptek->features.inputPath);
2174
2175 /* Program the tablet. This sets the tablet up in the mode
2176 * specified in newSetting, and also queries the tablet's
2177 * physical capacities.
2178 *
2179 * Sanity check: if a tablet doesn't like the slow programmatic
2180 * delay, we often get sizes of 0x0. Let's use that as an indicator
2181 * to try faster delays, up to 25 ms. If that logic fails, well, you'll
2182 * have to explain to us how your tablet thinks it's 0x0, and yet that's
2183 * not an error :-)
2184 */
2185
2186 for (i = 0; i < sizeof(speeds) / sizeof(speeds[0]); ++i) {
2187 aiptek->curSetting.programmableDelay = speeds[i];
2188 (void)aiptek_program_tablet(aiptek);
2189 if (aiptek->inputdev.absmax[ABS_X] > 0) {
2190 info("input: Aiptek using %d ms programming speed\n",
2191 aiptek->curSetting.programmableDelay);
2192 break;
2193 }
2194 }
2195
2196 /* Associate this driver's struct with the usb interface.
2197 */
2198 usb_set_intfdata(intf, aiptek);
2199
2200 /* Set up the sysfs files
2201 */
2202 aiptek_add_files(&intf->dev);
2203
2204 /* Make sure the evdev module is loaded. Assuming evdev IS a module :-)
2205 */
2206 if (request_module("evdev") != 0)
2207 info("aiptek: error loading 'evdev' module");
2208
2209 return 0;
2210 }
2211
2212 /* Forward declaration */
2213 static void aiptek_disconnect(struct usb_interface *intf);
2214
2215 static struct usb_driver aiptek_driver = {
2216 .owner = THIS_MODULE,
2217 .name = "aiptek",
2218 .probe = aiptek_probe,
2219 .disconnect = aiptek_disconnect,
2220 .id_table = aiptek_ids,
2221 };
2222
2223 /***********************************************************************
2224 * Deal with tablet disconnecting from the system.
2225 */
2226 static void aiptek_disconnect(struct usb_interface *intf)
2227 {
2228 struct aiptek *aiptek = usb_get_intfdata(intf);
2229
2230 /* Disassociate driver's struct with usb interface
2231 */
2232 usb_set_intfdata(intf, NULL);
2233 if (aiptek != NULL) {
2234 /* Free & unhook everything from the system.
2235 */
2236 usb_kill_urb(aiptek->urb);
2237 input_unregister_device(&aiptek->inputdev);
2238 aiptek_delete_files(&intf->dev);
2239 usb_free_urb(aiptek->urb);
2240 usb_buffer_free(interface_to_usbdev(intf),
2241 AIPTEK_PACKET_LENGTH,
2242 aiptek->data, aiptek->data_dma);
2243 kfree(aiptek);
2244 }
2245 }
2246
2247 static int __init aiptek_init(void)
2248 {
2249 int result = usb_register(&aiptek_driver);
2250 if (result == 0) {
2251 info(DRIVER_VERSION ": " DRIVER_AUTHOR);
2252 info(DRIVER_DESC);
2253 }
2254 return result;
2255 }
2256
2257 static void __exit aiptek_exit(void)
2258 {
2259 usb_deregister(&aiptek_driver);
2260 }
2261
2262 MODULE_AUTHOR(DRIVER_AUTHOR);
2263 MODULE_DESCRIPTION(DRIVER_DESC);
2264 MODULE_LICENSE("GPL");
2265
2266 module_param(programmableDelay, int, 0);
2267 MODULE_PARM_DESC(programmableDelay, "delay used during tablet programming");
2268 module_param(jitterDelay, int, 0);
2269 MODULE_PARM_DESC(jitterDelay, "stylus/mouse settlement delay");
2270
2271 module_init(aiptek_init);
2272 module_exit(aiptek_exit);
linux-next