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