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/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_PEN_MODE BTN_TOOL_PEN 229 #define AIPTEK_TOOL_BUTTON_PENCIL_MODE BTN_TOOL_PENCIL 230 #define AIPTEK_TOOL_BUTTON_BRUSH_MODE BTN_TOOL_BRUSH 231 #define AIPTEK_TOOL_BUTTON_AIRBRUSH_MODE BTN_TOOL_AIRBRUSH 232 #define AIPTEK_TOOL_BUTTON_ERASER_MODE BTN_TOOL_RUBBER 233 #define AIPTEK_TOOL_BUTTON_MOUSE_MODE BTN_TOOL_MOUSE 234 #define AIPTEK_TOOL_BUTTON_LENS_MODE BTN_TOOL_LENS 235 236 /* Diagnostic message codes 237 */ 238 #define AIPTEK_DIAGNOSTIC_NA 0 239 #define AIPTEK_DIAGNOSTIC_SENDING_RELATIVE_IN_ABSOLUTE 1 240 #define AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE 2 241 #define AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED 3 242 243 /* Time to wait (in ms) to help mask hand jittering 244 * when pressing the stylus buttons. 245 */ 246 #define AIPTEK_JITTER_DELAY_DEFAULT 50 247 248 /* Time to wait (in ms) in-between sending the tablet 249 * a command and beginning the process of reading the return 250 * sequence from the tablet. 251 */ 252 #define AIPTEK_PROGRAMMABLE_DELAY_25 25 253 #define AIPTEK_PROGRAMMABLE_DELAY_50 50 254 #define AIPTEK_PROGRAMMABLE_DELAY_100 100 255 #define AIPTEK_PROGRAMMABLE_DELAY_200 200 256 #define AIPTEK_PROGRAMMABLE_DELAY_300 300 257 #define AIPTEK_PROGRAMMABLE_DELAY_400 400 258 #define AIPTEK_PROGRAMMABLE_DELAY_DEFAULT AIPTEK_PROGRAMMABLE_DELAY_400 259 260 /* Mouse button programming 261 */ 262 #define AIPTEK_MOUSE_LEFT_BUTTON 0x04 263 #define AIPTEK_MOUSE_RIGHT_BUTTON 0x08 264 #define AIPTEK_MOUSE_MIDDLE_BUTTON 0x10 265 266 /* Stylus button programming 267 */ 268 #define AIPTEK_STYLUS_LOWER_BUTTON 0x08 269 #define AIPTEK_STYLUS_UPPER_BUTTON 0x10 270 271 /* Length of incoming packet from the tablet 272 */ 273 #define AIPTEK_PACKET_LENGTH 8 274 275 /* We report in EV_MISC both the proximity and 276 * whether the report came from the stylus, tablet mouse 277 * or "unknown" -- Unknown when the tablet is in relative 278 * mode, because we only get report 1's. 279 */ 280 #define AIPTEK_REPORT_TOOL_UNKNOWN 0x10 281 #define AIPTEK_REPORT_TOOL_STYLUS 0x20 282 #define AIPTEK_REPORT_TOOL_MOUSE 0x40 283 284 static int programmableDelay = AIPTEK_PROGRAMMABLE_DELAY_DEFAULT; 285 static int jitterDelay = AIPTEK_JITTER_DELAY_DEFAULT; 286 287 struct aiptek_features { 288 int odmCode; /* Tablet manufacturer code */ 289 int modelCode; /* Tablet model code (not unique) */ 290 int firmwareCode; /* prom/eeprom version */ 291 char usbPath[64 + 1]; /* device's physical usb path */ 292 }; 293 294 struct aiptek_settings { 295 int pointerMode; /* stylus-, mouse-only or either */ 296 int coordinateMode; /* absolute/relative coords */ 297 int toolMode; /* pen, pencil, brush, etc. tool */ 298 int xTilt; /* synthetic xTilt amount */ 299 int yTilt; /* synthetic yTilt amount */ 300 int wheel; /* synthetic wheel amount */ 301 int stylusButtonUpper; /* stylus upper btn delivers... */ 302 int stylusButtonLower; /* stylus lower btn delivers... */ 303 int mouseButtonLeft; /* mouse left btn delivers... */ 304 int mouseButtonMiddle; /* mouse middle btn delivers... */ 305 int mouseButtonRight; /* mouse right btn delivers... */ 306 int programmableDelay; /* delay for tablet programming */ 307 int jitterDelay; /* delay for hand jittering */ 308 }; 309 310 struct aiptek { 311 struct input_dev *inputdev; /* input device struct */ 312 struct usb_device *usbdev; /* usb device 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 int jitterable = 0; 440 int retval, macro, x, y, z, left, right, middle, p, dv, tip, bs, pck; 441 442 switch (urb->status) { 443 case 0: 444 /* Success */ 445 break; 446 447 case -ECONNRESET: 448 case -ENOENT: 449 case -ESHUTDOWN: 450 /* This urb is terminated, clean up */ 451 dbg("%s - urb shutting down with status: %d", 452 __func__, urb->status); 453 return; 454 455 default: 456 dbg("%s - nonzero urb status received: %d", 457 __func__, urb->status); 458 goto exit; 459 } 460 461 /* See if we are in a delay loop -- throw out report if true. 462 */ 463 if (aiptek->inDelay == 1 && time_after(aiptek->endDelay, jiffies)) { 464 goto exit; 465 } 466 467 aiptek->inDelay = 0; 468 aiptek->eventCount++; 469 470 /* Report 1 delivers relative coordinates with either a stylus 471 * or the mouse. You do not know, however, which input 472 * tool generated the event. 473 */ 474 if (data[0] == 1) { 475 if (aiptek->curSetting.coordinateMode == 476 AIPTEK_COORDINATE_ABSOLUTE_MODE) { 477 aiptek->diagnostic = 478 AIPTEK_DIAGNOSTIC_SENDING_RELATIVE_IN_ABSOLUTE; 479 } else { 480 x = (signed char) data[2]; 481 y = (signed char) data[3]; 482 483 /* jitterable keeps track of whether any button has been pressed. 484 * We're also using it to remap the physical mouse button mask 485 * to pseudo-settings. (We don't specifically care about it's 486 * value after moving/transposing mouse button bitmasks, except 487 * that a non-zero value indicates that one or more 488 * mouse button was pressed.) 489 */ 490 jitterable = data[1] & 0x07; 491 492 left = (data[1] & aiptek->curSetting.mouseButtonLeft >> 2) != 0 ? 1 : 0; 493 right = (data[1] & aiptek->curSetting.mouseButtonRight >> 2) != 0 ? 1 : 0; 494 middle = (data[1] & aiptek->curSetting.mouseButtonMiddle >> 2) != 0 ? 1 : 0; 495 496 input_report_key(inputdev, BTN_LEFT, left); 497 input_report_key(inputdev, BTN_MIDDLE, middle); 498 input_report_key(inputdev, BTN_RIGHT, right); 499 500 input_report_abs(inputdev, ABS_MISC, 501 1 | AIPTEK_REPORT_TOOL_UNKNOWN); 502 input_report_rel(inputdev, REL_X, x); 503 input_report_rel(inputdev, REL_Y, y); 504 505 /* Wheel support is in the form of a single-event 506 * firing. 507 */ 508 if (aiptek->curSetting.wheel != AIPTEK_WHEEL_DISABLE) { 509 input_report_rel(inputdev, REL_WHEEL, 510 aiptek->curSetting.wheel); 511 aiptek->curSetting.wheel = AIPTEK_WHEEL_DISABLE; 512 } 513 if (aiptek->lastMacro != -1) { 514 input_report_key(inputdev, 515 macroKeyEvents[aiptek->lastMacro], 0); 516 aiptek->lastMacro = -1; 517 } 518 input_sync(inputdev); 519 } 520 } 521 /* Report 2 is delivered only by the stylus, and delivers 522 * absolute coordinates. 523 */ 524 else if (data[0] == 2) { 525 if (aiptek->curSetting.coordinateMode == AIPTEK_COORDINATE_RELATIVE_MODE) { 526 aiptek->diagnostic = AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE; 527 } else if (!AIPTEK_POINTER_ALLOW_STYLUS_MODE 528 (aiptek->curSetting.pointerMode)) { 529 aiptek->diagnostic = AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED; 530 } else { 531 x = get_unaligned_le16(data + 1); 532 y = get_unaligned_le16(data + 3); 533 z = get_unaligned_le16(data + 6); 534 535 dv = (data[5] & 0x01) != 0 ? 1 : 0; 536 p = (data[5] & 0x02) != 0 ? 1 : 0; 537 tip = (data[5] & 0x04) != 0 ? 1 : 0; 538 539 /* Use jitterable to re-arrange button masks 540 */ 541 jitterable = data[5] & 0x18; 542 543 bs = (data[5] & aiptek->curSetting.stylusButtonLower) != 0 ? 1 : 0; 544 pck = (data[5] & aiptek->curSetting.stylusButtonUpper) != 0 ? 1 : 0; 545 546 /* dv indicates 'data valid' (e.g., the tablet is in sync 547 * and has delivered a "correct" report) We will ignore 548 * all 'bad' reports... 549 */ 550 if (dv != 0) { 551 /* If the selected tool changed, reset the old 552 * tool key, and set the new one. 553 */ 554 if (aiptek->previousToolMode != 555 aiptek->curSetting.toolMode) { 556 input_report_key(inputdev, 557 aiptek->previousToolMode, 0); 558 input_report_key(inputdev, 559 aiptek->curSetting.toolMode, 560 1); 561 aiptek->previousToolMode = 562 aiptek->curSetting.toolMode; 563 } 564 565 if (p != 0) { 566 input_report_abs(inputdev, ABS_X, x); 567 input_report_abs(inputdev, ABS_Y, y); 568 input_report_abs(inputdev, ABS_PRESSURE, z); 569 570 input_report_key(inputdev, BTN_TOUCH, tip); 571 input_report_key(inputdev, BTN_STYLUS, bs); 572 input_report_key(inputdev, BTN_STYLUS2, pck); 573 574 if (aiptek->curSetting.xTilt != 575 AIPTEK_TILT_DISABLE) { 576 input_report_abs(inputdev, 577 ABS_TILT_X, 578 aiptek->curSetting.xTilt); 579 } 580 if (aiptek->curSetting.yTilt != AIPTEK_TILT_DISABLE) { 581 input_report_abs(inputdev, 582 ABS_TILT_Y, 583 aiptek->curSetting.yTilt); 584 } 585 586 /* Wheel support is in the form of a single-event 587 * firing. 588 */ 589 if (aiptek->curSetting.wheel != 590 AIPTEK_WHEEL_DISABLE) { 591 input_report_abs(inputdev, 592 ABS_WHEEL, 593 aiptek->curSetting.wheel); 594 aiptek->curSetting.wheel = AIPTEK_WHEEL_DISABLE; 595 } 596 } 597 input_report_abs(inputdev, ABS_MISC, p | AIPTEK_REPORT_TOOL_STYLUS); 598 if (aiptek->lastMacro != -1) { 599 input_report_key(inputdev, 600 macroKeyEvents[aiptek->lastMacro], 0); 601 aiptek->lastMacro = -1; 602 } 603 input_sync(inputdev); 604 } 605 } 606 } 607 /* Report 3's come from the mouse in absolute mode. 608 */ 609 else if (data[0] == 3) { 610 if (aiptek->curSetting.coordinateMode == AIPTEK_COORDINATE_RELATIVE_MODE) { 611 aiptek->diagnostic = AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE; 612 } else if (!AIPTEK_POINTER_ALLOW_MOUSE_MODE 613 (aiptek->curSetting.pointerMode)) { 614 aiptek->diagnostic = AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED; 615 } else { 616 x = get_unaligned_le16(data + 1); 617 y = get_unaligned_le16(data + 3); 618 619 jitterable = data[5] & 0x1c; 620 621 dv = (data[5] & 0x01) != 0 ? 1 : 0; 622 p = (data[5] & 0x02) != 0 ? 1 : 0; 623 left = (data[5] & aiptek->curSetting.mouseButtonLeft) != 0 ? 1 : 0; 624 right = (data[5] & aiptek->curSetting.mouseButtonRight) != 0 ? 1 : 0; 625 middle = (data[5] & aiptek->curSetting.mouseButtonMiddle) != 0 ? 1 : 0; 626 627 if (dv != 0) { 628 /* If the selected tool changed, reset the old 629 * tool key, and set the new one. 630 */ 631 if (aiptek->previousToolMode != 632 aiptek->curSetting.toolMode) { 633 input_report_key(inputdev, 634 aiptek->previousToolMode, 0); 635 input_report_key(inputdev, 636 aiptek->curSetting.toolMode, 637 1); 638 aiptek->previousToolMode = 639 aiptek->curSetting.toolMode; 640 } 641 642 if (p != 0) { 643 input_report_abs(inputdev, ABS_X, x); 644 input_report_abs(inputdev, ABS_Y, y); 645 646 input_report_key(inputdev, BTN_LEFT, left); 647 input_report_key(inputdev, BTN_MIDDLE, middle); 648 input_report_key(inputdev, BTN_RIGHT, right); 649 650 /* Wheel support is in the form of a single-event 651 * firing. 652 */ 653 if (aiptek->curSetting.wheel != AIPTEK_WHEEL_DISABLE) { 654 input_report_abs(inputdev, 655 ABS_WHEEL, 656 aiptek->curSetting.wheel); 657 aiptek->curSetting.wheel = AIPTEK_WHEEL_DISABLE; 658 } 659 } 660 input_report_abs(inputdev, ABS_MISC, p | AIPTEK_REPORT_TOOL_MOUSE); 661 if (aiptek->lastMacro != -1) { 662 input_report_key(inputdev, 663 macroKeyEvents[aiptek->lastMacro], 0); 664 aiptek->lastMacro = -1; 665 } 666 input_sync(inputdev); 667 } 668 } 669 } 670 /* Report 4s come from the macro keys when pressed by stylus 671 */ 672 else if (data[0] == 4) { 673 jitterable = data[1] & 0x18; 674 675 dv = (data[1] & 0x01) != 0 ? 1 : 0; 676 p = (data[1] & 0x02) != 0 ? 1 : 0; 677 tip = (data[1] & 0x04) != 0 ? 1 : 0; 678 bs = (data[1] & aiptek->curSetting.stylusButtonLower) != 0 ? 1 : 0; 679 pck = (data[1] & aiptek->curSetting.stylusButtonUpper) != 0 ? 1 : 0; 680 681 macro = dv && p && tip && !(data[3] & 1) ? (data[3] >> 1) : -1; 682 z = get_unaligned_le16(data + 4); 683 684 if (dv) { 685 /* If the selected tool changed, reset the old 686 * tool key, and set the new one. 687 */ 688 if (aiptek->previousToolMode != 689 aiptek->curSetting.toolMode) { 690 input_report_key(inputdev, 691 aiptek->previousToolMode, 0); 692 input_report_key(inputdev, 693 aiptek->curSetting.toolMode, 694 1); 695 aiptek->previousToolMode = 696 aiptek->curSetting.toolMode; 697 } 698 } 699 700 if (aiptek->lastMacro != -1 && aiptek->lastMacro != macro) { 701 input_report_key(inputdev, macroKeyEvents[aiptek->lastMacro], 0); 702 aiptek->lastMacro = -1; 703 } 704 705 if (macro != -1 && macro != aiptek->lastMacro) { 706 input_report_key(inputdev, macroKeyEvents[macro], 1); 707 aiptek->lastMacro = macro; 708 } 709 input_report_abs(inputdev, ABS_MISC, 710 p | AIPTEK_REPORT_TOOL_STYLUS); 711 input_sync(inputdev); 712 } 713 /* Report 5s come from the macro keys when pressed by mouse 714 */ 715 else if (data[0] == 5) { 716 jitterable = data[1] & 0x1c; 717 718 dv = (data[1] & 0x01) != 0 ? 1 : 0; 719 p = (data[1] & 0x02) != 0 ? 1 : 0; 720 left = (data[1]& aiptek->curSetting.mouseButtonLeft) != 0 ? 1 : 0; 721 right = (data[1] & aiptek->curSetting.mouseButtonRight) != 0 ? 1 : 0; 722 middle = (data[1] & aiptek->curSetting.mouseButtonMiddle) != 0 ? 1 : 0; 723 macro = dv && p && left && !(data[3] & 1) ? (data[3] >> 1) : 0; 724 725 if (dv) { 726 /* If the selected tool changed, reset the old 727 * tool key, and set the new one. 728 */ 729 if (aiptek->previousToolMode != 730 aiptek->curSetting.toolMode) { 731 input_report_key(inputdev, 732 aiptek->previousToolMode, 0); 733 input_report_key(inputdev, 734 aiptek->curSetting.toolMode, 1); 735 aiptek->previousToolMode = aiptek->curSetting.toolMode; 736 } 737 } 738 739 if (aiptek->lastMacro != -1 && aiptek->lastMacro != macro) { 740 input_report_key(inputdev, macroKeyEvents[aiptek->lastMacro], 0); 741 aiptek->lastMacro = -1; 742 } 743 744 if (macro != -1 && macro != aiptek->lastMacro) { 745 input_report_key(inputdev, macroKeyEvents[macro], 1); 746 aiptek->lastMacro = macro; 747 } 748 749 input_report_abs(inputdev, ABS_MISC, 750 p | AIPTEK_REPORT_TOOL_MOUSE); 751 input_sync(inputdev); 752 } 753 /* We have no idea which tool can generate a report 6. Theoretically, 754 * neither need to, having been given reports 4 & 5 for such use. 755 * However, report 6 is the 'official-looking' report for macroKeys; 756 * reports 4 & 5 supposively are used to support unnamed, unknown 757 * hat switches (which just so happen to be the macroKeys.) 758 */ 759 else if (data[0] == 6) { 760 macro = get_unaligned_le16(data + 1); 761 if (macro > 0) { 762 input_report_key(inputdev, macroKeyEvents[macro - 1], 763 0); 764 } 765 if (macro < 25) { 766 input_report_key(inputdev, macroKeyEvents[macro + 1], 767 0); 768 } 769 770 /* If the selected tool changed, reset the old 771 tool key, and set the new one. 772 */ 773 if (aiptek->previousToolMode != 774 aiptek->curSetting.toolMode) { 775 input_report_key(inputdev, 776 aiptek->previousToolMode, 0); 777 input_report_key(inputdev, 778 aiptek->curSetting.toolMode, 779 1); 780 aiptek->previousToolMode = 781 aiptek->curSetting.toolMode; 782 } 783 784 input_report_key(inputdev, macroKeyEvents[macro], 1); 785 input_report_abs(inputdev, ABS_MISC, 786 1 | AIPTEK_REPORT_TOOL_UNKNOWN); 787 input_sync(inputdev); 788 } else { 789 dbg("Unknown report %d", data[0]); 790 } 791 792 /* Jitter may occur when the user presses a button on the stlyus 793 * or the mouse. What we do to prevent that is wait 'x' milliseconds 794 * following a 'jitterable' event, which should give the hand some time 795 * stabilize itself. 796 * 797 * We just introduced aiptek->previousJitterable to carry forth the 798 * notion that jitter occurs when the button state changes from on to off: 799 * a person drawing, holding a button down is not subject to jittering. 800 * With that in mind, changing from upper button depressed to lower button 801 * WILL transition through a jitter delay. 802 */ 803 804 if (aiptek->previousJitterable != jitterable && 805 aiptek->curSetting.jitterDelay != 0 && aiptek->inDelay != 1) { 806 aiptek->endDelay = jiffies + 807 ((aiptek->curSetting.jitterDelay * HZ) / 1000); 808 aiptek->inDelay = 1; 809 } 810 aiptek->previousJitterable = jitterable; 811 812 exit: 813 retval = usb_submit_urb(urb, GFP_ATOMIC); 814 if (retval != 0) { 815 err("%s - usb_submit_urb failed with result %d", 816 __func__, retval); 817 } 818 } 819 820 /*********************************************************************** 821 * These are the USB id's known so far. We do not identify them to 822 * specific Aiptek model numbers, because there has been overlaps, 823 * use, and reuse of id's in existing models. Certain models have 824 * been known to use more than one ID, indicative perhaps of 825 * manufacturing revisions. In any event, we consider these 826 * IDs to not be model-specific nor unique. 827 */ 828 static const struct usb_device_id aiptek_ids[] = { 829 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x01)}, 830 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x10)}, 831 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x20)}, 832 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x21)}, 833 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x22)}, 834 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x23)}, 835 {USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x24)}, 836 {USB_DEVICE(USB_VENDOR_ID_KYE, 0x5003)}, 837 {} 838 }; 839 840 MODULE_DEVICE_TABLE(usb, aiptek_ids); 841 842 /*********************************************************************** 843 * Open an instance of the tablet driver. 844 */ 845 static int aiptek_open(struct input_dev *inputdev) 846 { 847 struct aiptek *aiptek = input_get_drvdata(inputdev); 848 849 aiptek->urb->dev = aiptek->usbdev; 850 if (usb_submit_urb(aiptek->urb, GFP_KERNEL) != 0) 851 return -EIO; 852 853 return 0; 854 } 855 856 /*********************************************************************** 857 * Close an instance of the tablet driver. 858 */ 859 static void aiptek_close(struct input_dev *inputdev) 860 { 861 struct aiptek *aiptek = input_get_drvdata(inputdev); 862 863 usb_kill_urb(aiptek->urb); 864 } 865 866 /*********************************************************************** 867 * aiptek_set_report and aiptek_get_report() are borrowed from Linux 2.4.x, 868 * where they were known as usb_set_report and usb_get_report. 869 */ 870 static int 871 aiptek_set_report(struct aiptek *aiptek, 872 unsigned char report_type, 873 unsigned char report_id, void *buffer, int size) 874 { 875 return usb_control_msg(aiptek->usbdev, 876 usb_sndctrlpipe(aiptek->usbdev, 0), 877 USB_REQ_SET_REPORT, 878 USB_TYPE_CLASS | USB_RECIP_INTERFACE | 879 USB_DIR_OUT, (report_type << 8) + report_id, 880 aiptek->ifnum, buffer, size, 5000); 881 } 882 883 static int 884 aiptek_get_report(struct aiptek *aiptek, 885 unsigned char report_type, 886 unsigned char report_id, void *buffer, int size) 887 { 888 return usb_control_msg(aiptek->usbdev, 889 usb_rcvctrlpipe(aiptek->usbdev, 0), 890 USB_REQ_GET_REPORT, 891 USB_TYPE_CLASS | USB_RECIP_INTERFACE | 892 USB_DIR_IN, (report_type << 8) + report_id, 893 aiptek->ifnum, buffer, size, 5000); 894 } 895 896 /*********************************************************************** 897 * Send a command to the tablet. 898 */ 899 static int 900 aiptek_command(struct aiptek *aiptek, unsigned char command, unsigned char data) 901 { 902 const int sizeof_buf = 3 * sizeof(u8); 903 int ret; 904 u8 *buf; 905 906 buf = kmalloc(sizeof_buf, GFP_KERNEL); 907 if (!buf) 908 return -ENOMEM; 909 910 buf[0] = 2; 911 buf[1] = command; 912 buf[2] = data; 913 914 if ((ret = 915 aiptek_set_report(aiptek, 3, 2, buf, sizeof_buf)) != sizeof_buf) { 916 dbg("aiptek_program: failed, tried to send: 0x%02x 0x%02x", 917 command, data); 918 } 919 kfree(buf); 920 return ret < 0 ? ret : 0; 921 } 922 923 /*********************************************************************** 924 * Retrieve information from the tablet. Querying info is defined as first 925 * sending the {command,data} sequence as a command, followed by a wait 926 * (aka, "programmaticDelay") and then a "read" request. 927 */ 928 static int 929 aiptek_query(struct aiptek *aiptek, unsigned char command, unsigned char data) 930 { 931 const int sizeof_buf = 3 * sizeof(u8); 932 int ret; 933 u8 *buf; 934 935 buf = kmalloc(sizeof_buf, GFP_KERNEL); 936 if (!buf) 937 return -ENOMEM; 938 939 buf[0] = 2; 940 buf[1] = command; 941 buf[2] = data; 942 943 if (aiptek_command(aiptek, command, data) != 0) { 944 kfree(buf); 945 return -EIO; 946 } 947 msleep(aiptek->curSetting.programmableDelay); 948 949 if ((ret = 950 aiptek_get_report(aiptek, 3, 2, buf, sizeof_buf)) != sizeof_buf) { 951 dbg("aiptek_query failed: returned 0x%02x 0x%02x 0x%02x", 952 buf[0], buf[1], buf[2]); 953 ret = -EIO; 954 } else { 955 ret = get_unaligned_le16(buf + 1); 956 } 957 kfree(buf); 958 return ret; 959 } 960 961 /*********************************************************************** 962 * Program the tablet into either absolute or relative mode. 963 * We also get information about the tablet's size. 964 */ 965 static int aiptek_program_tablet(struct aiptek *aiptek) 966 { 967 int ret; 968 /* Execute Resolution500LPI */ 969 if ((ret = aiptek_command(aiptek, 0x18, 0x04)) < 0) 970 return ret; 971 972 /* Query getModelCode */ 973 if ((ret = aiptek_query(aiptek, 0x02, 0x00)) < 0) 974 return ret; 975 aiptek->features.modelCode = ret & 0xff; 976 977 /* Query getODMCode */ 978 if ((ret = aiptek_query(aiptek, 0x03, 0x00)) < 0) 979 return ret; 980 aiptek->features.odmCode = ret; 981 982 /* Query getFirmwareCode */ 983 if ((ret = aiptek_query(aiptek, 0x04, 0x00)) < 0) 984 return ret; 985 aiptek->features.firmwareCode = ret; 986 987 /* Query getXextension */ 988 if ((ret = aiptek_query(aiptek, 0x01, 0x00)) < 0) 989 return ret; 990 input_set_abs_params(aiptek->inputdev, ABS_X, 0, ret - 1, 0, 0); 991 992 /* Query getYextension */ 993 if ((ret = aiptek_query(aiptek, 0x01, 0x01)) < 0) 994 return ret; 995 input_set_abs_params(aiptek->inputdev, ABS_Y, 0, ret - 1, 0, 0); 996 997 /* Query getPressureLevels */ 998 if ((ret = aiptek_query(aiptek, 0x08, 0x00)) < 0) 999 return ret; 1000 input_set_abs_params(aiptek->inputdev, ABS_PRESSURE, 0, ret - 1, 0, 0); 1001 1002 /* Depending on whether we are in absolute or relative mode, we will 1003 * do a switchToTablet(absolute) or switchToMouse(relative) command. 1004 */ 1005 if (aiptek->curSetting.coordinateMode == 1006 AIPTEK_COORDINATE_ABSOLUTE_MODE) { 1007 /* Execute switchToTablet */ 1008 if ((ret = aiptek_command(aiptek, 0x10, 0x01)) < 0) { 1009 return ret; 1010 } 1011 } else { 1012 /* Execute switchToMouse */ 1013 if ((ret = aiptek_command(aiptek, 0x10, 0x00)) < 0) { 1014 return ret; 1015 } 1016 } 1017 1018 /* Enable the macro keys */ 1019 if ((ret = aiptek_command(aiptek, 0x11, 0x02)) < 0) 1020 return ret; 1021 #if 0 1022 /* Execute FilterOn */ 1023 if ((ret = aiptek_command(aiptek, 0x17, 0x00)) < 0) 1024 return ret; 1025 #endif 1026 1027 /* Execute AutoGainOn */ 1028 if ((ret = aiptek_command(aiptek, 0x12, 0xff)) < 0) 1029 return ret; 1030 1031 /* Reset the eventCount, so we track events from last (re)programming 1032 */ 1033 aiptek->diagnostic = AIPTEK_DIAGNOSTIC_NA; 1034 aiptek->eventCount = 0; 1035 1036 return 0; 1037 } 1038 1039 /*********************************************************************** 1040 * Sysfs functions. Sysfs prefers that individually-tunable parameters 1041 * exist in their separate pseudo-files. Summary data that is immutable 1042 * may exist in a singular file so long as you don't define a writeable 1043 * interface. 1044 */ 1045 1046 /*********************************************************************** 1047 * support the 'size' file -- display support 1048 */ 1049 static ssize_t show_tabletSize(struct device *dev, struct device_attribute *attr, char *buf) 1050 { 1051 struct aiptek *aiptek = dev_get_drvdata(dev); 1052 1053 return snprintf(buf, PAGE_SIZE, "%dx%d\n", 1054 input_abs_get_max(aiptek->inputdev, ABS_X) + 1, 1055 input_abs_get_max(aiptek->inputdev, ABS_Y) + 1); 1056 } 1057 1058 /* These structs define the sysfs files, param #1 is the name of the 1059 * file, param 2 is the file permissions, param 3 & 4 are to the 1060 * output generator and input parser routines. Absence of a routine is 1061 * permitted -- it only means can't either 'cat' the file, or send data 1062 * to it. 1063 */ 1064 static DEVICE_ATTR(size, S_IRUGO, show_tabletSize, NULL); 1065 1066 /*********************************************************************** 1067 * support routines for the 'pointer_mode' file. Note that this file 1068 * both displays current setting and allows reprogramming. 1069 */ 1070 static struct aiptek_map pointer_mode_map[] = { 1071 { "stylus", AIPTEK_POINTER_ONLY_STYLUS_MODE }, 1072 { "mouse", AIPTEK_POINTER_ONLY_MOUSE_MODE }, 1073 { "either", AIPTEK_POINTER_EITHER_MODE }, 1074 { NULL, AIPTEK_INVALID_VALUE } 1075 }; 1076 1077 static ssize_t show_tabletPointerMode(struct device *dev, struct device_attribute *attr, char *buf) 1078 { 1079 struct aiptek *aiptek = dev_get_drvdata(dev); 1080 1081 return snprintf(buf, PAGE_SIZE, "%s\n", 1082 map_val_to_str(pointer_mode_map, 1083 aiptek->curSetting.pointerMode)); 1084 } 1085 1086 static ssize_t 1087 store_tabletPointerMode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1088 { 1089 struct aiptek *aiptek = dev_get_drvdata(dev); 1090 int new_mode = map_str_to_val(pointer_mode_map, buf, count); 1091 1092 if (new_mode == AIPTEK_INVALID_VALUE) 1093 return -EINVAL; 1094 1095 aiptek->newSetting.pointerMode = new_mode; 1096 return count; 1097 } 1098 1099 static DEVICE_ATTR(pointer_mode, 1100 S_IRUGO | S_IWUSR, 1101 show_tabletPointerMode, store_tabletPointerMode); 1102 1103 /*********************************************************************** 1104 * support routines for the 'coordinate_mode' file. Note that this file 1105 * both displays current setting and allows reprogramming. 1106 */ 1107 1108 static struct aiptek_map coordinate_mode_map[] = { 1109 { "absolute", AIPTEK_COORDINATE_ABSOLUTE_MODE }, 1110 { "relative", AIPTEK_COORDINATE_RELATIVE_MODE }, 1111 { NULL, AIPTEK_INVALID_VALUE } 1112 }; 1113 1114 static ssize_t show_tabletCoordinateMode(struct device *dev, struct device_attribute *attr, char *buf) 1115 { 1116 struct aiptek *aiptek = dev_get_drvdata(dev); 1117 1118 return snprintf(buf, PAGE_SIZE, "%s\n", 1119 map_val_to_str(coordinate_mode_map, 1120 aiptek->curSetting.coordinateMode)); 1121 } 1122 1123 static ssize_t 1124 store_tabletCoordinateMode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1125 { 1126 struct aiptek *aiptek = dev_get_drvdata(dev); 1127 int new_mode = map_str_to_val(coordinate_mode_map, buf, count); 1128 1129 if (new_mode == AIPTEK_INVALID_VALUE) 1130 return -EINVAL; 1131 1132 aiptek->newSetting.coordinateMode = new_mode; 1133 return count; 1134 } 1135 1136 static DEVICE_ATTR(coordinate_mode, 1137 S_IRUGO | S_IWUSR, 1138 show_tabletCoordinateMode, store_tabletCoordinateMode); 1139 1140 /*********************************************************************** 1141 * support routines for the 'tool_mode' file. Note that this file 1142 * both displays current setting and allows reprogramming. 1143 */ 1144 1145 static struct aiptek_map tool_mode_map[] = { 1146 { "mouse", AIPTEK_TOOL_BUTTON_MOUSE_MODE }, 1147 { "eraser", AIPTEK_TOOL_BUTTON_ERASER_MODE }, 1148 { "pencil", AIPTEK_TOOL_BUTTON_PENCIL_MODE }, 1149 { "pen", AIPTEK_TOOL_BUTTON_PEN_MODE }, 1150 { "brush", AIPTEK_TOOL_BUTTON_BRUSH_MODE }, 1151 { "airbrush", AIPTEK_TOOL_BUTTON_AIRBRUSH_MODE }, 1152 { "lens", AIPTEK_TOOL_BUTTON_LENS_MODE }, 1153 { NULL, AIPTEK_INVALID_VALUE } 1154 }; 1155 1156 static ssize_t show_tabletToolMode(struct device *dev, struct device_attribute *attr, char *buf) 1157 { 1158 struct aiptek *aiptek = dev_get_drvdata(dev); 1159 1160 return snprintf(buf, PAGE_SIZE, "%s\n", 1161 map_val_to_str(tool_mode_map, 1162 aiptek->curSetting.toolMode)); 1163 } 1164 1165 static ssize_t 1166 store_tabletToolMode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1167 { 1168 struct aiptek *aiptek = dev_get_drvdata(dev); 1169 int new_mode = map_str_to_val(tool_mode_map, buf, count); 1170 1171 if (new_mode == AIPTEK_INVALID_VALUE) 1172 return -EINVAL; 1173 1174 aiptek->newSetting.toolMode = new_mode; 1175 return count; 1176 } 1177 1178 static DEVICE_ATTR(tool_mode, 1179 S_IRUGO | S_IWUSR, 1180 show_tabletToolMode, store_tabletToolMode); 1181 1182 /*********************************************************************** 1183 * support routines for the 'xtilt' file. Note that this file 1184 * both displays current setting and allows reprogramming. 1185 */ 1186 static ssize_t show_tabletXtilt(struct device *dev, struct device_attribute *attr, char *buf) 1187 { 1188 struct aiptek *aiptek = dev_get_drvdata(dev); 1189 1190 if (aiptek->curSetting.xTilt == AIPTEK_TILT_DISABLE) { 1191 return snprintf(buf, PAGE_SIZE, "disable\n"); 1192 } else { 1193 return snprintf(buf, PAGE_SIZE, "%d\n", 1194 aiptek->curSetting.xTilt); 1195 } 1196 } 1197 1198 static ssize_t 1199 store_tabletXtilt(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1200 { 1201 struct aiptek *aiptek = dev_get_drvdata(dev); 1202 long x; 1203 1204 if (strict_strtol(buf, 10, &x)) { 1205 size_t len = buf[count - 1] == '\n' ? count - 1 : count; 1206 1207 if (strncmp(buf, "disable", len)) 1208 return -EINVAL; 1209 1210 aiptek->newSetting.xTilt = AIPTEK_TILT_DISABLE; 1211 } else { 1212 if (x < AIPTEK_TILT_MIN || x > AIPTEK_TILT_MAX) 1213 return -EINVAL; 1214 1215 aiptek->newSetting.xTilt = x; 1216 } 1217 1218 return count; 1219 } 1220 1221 static DEVICE_ATTR(xtilt, 1222 S_IRUGO | S_IWUSR, show_tabletXtilt, store_tabletXtilt); 1223 1224 /*********************************************************************** 1225 * support routines for the 'ytilt' file. Note that this file 1226 * both displays current setting and allows reprogramming. 1227 */ 1228 static ssize_t show_tabletYtilt(struct device *dev, struct device_attribute *attr, char *buf) 1229 { 1230 struct aiptek *aiptek = dev_get_drvdata(dev); 1231 1232 if (aiptek->curSetting.yTilt == AIPTEK_TILT_DISABLE) { 1233 return snprintf(buf, PAGE_SIZE, "disable\n"); 1234 } else { 1235 return snprintf(buf, PAGE_SIZE, "%d\n", 1236 aiptek->curSetting.yTilt); 1237 } 1238 } 1239 1240 static ssize_t 1241 store_tabletYtilt(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1242 { 1243 struct aiptek *aiptek = dev_get_drvdata(dev); 1244 long y; 1245 1246 if (strict_strtol(buf, 10, &y)) { 1247 size_t len = buf[count - 1] == '\n' ? count - 1 : count; 1248 1249 if (strncmp(buf, "disable", len)) 1250 return -EINVAL; 1251 1252 aiptek->newSetting.yTilt = AIPTEK_TILT_DISABLE; 1253 } else { 1254 if (y < AIPTEK_TILT_MIN || y > AIPTEK_TILT_MAX) 1255 return -EINVAL; 1256 1257 aiptek->newSetting.yTilt = y; 1258 } 1259 1260 return count; 1261 } 1262 1263 static DEVICE_ATTR(ytilt, 1264 S_IRUGO | S_IWUSR, show_tabletYtilt, store_tabletYtilt); 1265 1266 /*********************************************************************** 1267 * support routines for the 'jitter' file. Note that this file 1268 * both displays current setting and allows reprogramming. 1269 */ 1270 static ssize_t show_tabletJitterDelay(struct device *dev, struct device_attribute *attr, char *buf) 1271 { 1272 struct aiptek *aiptek = dev_get_drvdata(dev); 1273 1274 return snprintf(buf, PAGE_SIZE, "%d\n", aiptek->curSetting.jitterDelay); 1275 } 1276 1277 static ssize_t 1278 store_tabletJitterDelay(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1279 { 1280 struct aiptek *aiptek = dev_get_drvdata(dev); 1281 long j; 1282 1283 if (strict_strtol(buf, 10, &j)) 1284 return -EINVAL; 1285 1286 aiptek->newSetting.jitterDelay = (int)j; 1287 return count; 1288 } 1289 1290 static DEVICE_ATTR(jitter, 1291 S_IRUGO | S_IWUSR, 1292 show_tabletJitterDelay, store_tabletJitterDelay); 1293 1294 /*********************************************************************** 1295 * support routines for the 'delay' file. Note that this file 1296 * both displays current setting and allows reprogramming. 1297 */ 1298 static ssize_t show_tabletProgrammableDelay(struct device *dev, struct device_attribute *attr, char *buf) 1299 { 1300 struct aiptek *aiptek = dev_get_drvdata(dev); 1301 1302 return snprintf(buf, PAGE_SIZE, "%d\n", 1303 aiptek->curSetting.programmableDelay); 1304 } 1305 1306 static ssize_t 1307 store_tabletProgrammableDelay(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1308 { 1309 struct aiptek *aiptek = dev_get_drvdata(dev); 1310 long d; 1311 1312 if (strict_strtol(buf, 10, &d)) 1313 return -EINVAL; 1314 1315 aiptek->newSetting.programmableDelay = (int)d; 1316 return count; 1317 } 1318 1319 static DEVICE_ATTR(delay, 1320 S_IRUGO | S_IWUSR, 1321 show_tabletProgrammableDelay, store_tabletProgrammableDelay); 1322 1323 /*********************************************************************** 1324 * support routines for the 'event_count' file. Note that this file 1325 * only displays current setting. 1326 */ 1327 static ssize_t show_tabletEventsReceived(struct device *dev, struct device_attribute *attr, char *buf) 1328 { 1329 struct aiptek *aiptek = dev_get_drvdata(dev); 1330 1331 return snprintf(buf, PAGE_SIZE, "%ld\n", aiptek->eventCount); 1332 } 1333 1334 static DEVICE_ATTR(event_count, S_IRUGO, show_tabletEventsReceived, NULL); 1335 1336 /*********************************************************************** 1337 * support routines for the 'diagnostic' file. Note that this file 1338 * only displays current setting. 1339 */ 1340 static ssize_t show_tabletDiagnosticMessage(struct device *dev, struct device_attribute *attr, char *buf) 1341 { 1342 struct aiptek *aiptek = dev_get_drvdata(dev); 1343 char *retMsg; 1344 1345 switch (aiptek->diagnostic) { 1346 case AIPTEK_DIAGNOSTIC_NA: 1347 retMsg = "no errors\n"; 1348 break; 1349 1350 case AIPTEK_DIAGNOSTIC_SENDING_RELATIVE_IN_ABSOLUTE: 1351 retMsg = "Error: receiving relative reports\n"; 1352 break; 1353 1354 case AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE: 1355 retMsg = "Error: receiving absolute reports\n"; 1356 break; 1357 1358 case AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED: 1359 if (aiptek->curSetting.pointerMode == 1360 AIPTEK_POINTER_ONLY_MOUSE_MODE) { 1361 retMsg = "Error: receiving stylus reports\n"; 1362 } else { 1363 retMsg = "Error: receiving mouse reports\n"; 1364 } 1365 break; 1366 1367 default: 1368 return 0; 1369 } 1370 return snprintf(buf, PAGE_SIZE, retMsg); 1371 } 1372 1373 static DEVICE_ATTR(diagnostic, S_IRUGO, show_tabletDiagnosticMessage, NULL); 1374 1375 /*********************************************************************** 1376 * support routines for the 'stylus_upper' file. Note that this file 1377 * both displays current setting and allows for setting changing. 1378 */ 1379 1380 static struct aiptek_map stylus_button_map[] = { 1381 { "upper", AIPTEK_STYLUS_UPPER_BUTTON }, 1382 { "lower", AIPTEK_STYLUS_LOWER_BUTTON }, 1383 { NULL, AIPTEK_INVALID_VALUE } 1384 }; 1385 1386 static ssize_t show_tabletStylusUpper(struct device *dev, struct device_attribute *attr, char *buf) 1387 { 1388 struct aiptek *aiptek = dev_get_drvdata(dev); 1389 1390 return snprintf(buf, PAGE_SIZE, "%s\n", 1391 map_val_to_str(stylus_button_map, 1392 aiptek->curSetting.stylusButtonUpper)); 1393 } 1394 1395 static ssize_t 1396 store_tabletStylusUpper(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1397 { 1398 struct aiptek *aiptek = dev_get_drvdata(dev); 1399 int new_button = map_str_to_val(stylus_button_map, buf, count); 1400 1401 if (new_button == AIPTEK_INVALID_VALUE) 1402 return -EINVAL; 1403 1404 aiptek->newSetting.stylusButtonUpper = new_button; 1405 return count; 1406 } 1407 1408 static DEVICE_ATTR(stylus_upper, 1409 S_IRUGO | S_IWUSR, 1410 show_tabletStylusUpper, store_tabletStylusUpper); 1411 1412 /*********************************************************************** 1413 * support routines for the 'stylus_lower' file. Note that this file 1414 * both displays current setting and allows for setting changing. 1415 */ 1416 1417 static ssize_t show_tabletStylusLower(struct device *dev, struct device_attribute *attr, char *buf) 1418 { 1419 struct aiptek *aiptek = dev_get_drvdata(dev); 1420 1421 return snprintf(buf, PAGE_SIZE, "%s\n", 1422 map_val_to_str(stylus_button_map, 1423 aiptek->curSetting.stylusButtonLower)); 1424 } 1425 1426 static ssize_t 1427 store_tabletStylusLower(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1428 { 1429 struct aiptek *aiptek = dev_get_drvdata(dev); 1430 int new_button = map_str_to_val(stylus_button_map, buf, count); 1431 1432 if (new_button == AIPTEK_INVALID_VALUE) 1433 return -EINVAL; 1434 1435 aiptek->newSetting.stylusButtonLower = new_button; 1436 return count; 1437 } 1438 1439 static DEVICE_ATTR(stylus_lower, 1440 S_IRUGO | S_IWUSR, 1441 show_tabletStylusLower, store_tabletStylusLower); 1442 1443 /*********************************************************************** 1444 * support routines for the 'mouse_left' file. Note that this file 1445 * both displays current setting and allows for setting changing. 1446 */ 1447 1448 static struct aiptek_map mouse_button_map[] = { 1449 { "left", AIPTEK_MOUSE_LEFT_BUTTON }, 1450 { "middle", AIPTEK_MOUSE_MIDDLE_BUTTON }, 1451 { "right", AIPTEK_MOUSE_RIGHT_BUTTON }, 1452 { NULL, AIPTEK_INVALID_VALUE } 1453 }; 1454 1455 static ssize_t show_tabletMouseLeft(struct device *dev, struct device_attribute *attr, char *buf) 1456 { 1457 struct aiptek *aiptek = dev_get_drvdata(dev); 1458 1459 return snprintf(buf, PAGE_SIZE, "%s\n", 1460 map_val_to_str(mouse_button_map, 1461 aiptek->curSetting.mouseButtonLeft)); 1462 } 1463 1464 static ssize_t 1465 store_tabletMouseLeft(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1466 { 1467 struct aiptek *aiptek = dev_get_drvdata(dev); 1468 int new_button = map_str_to_val(mouse_button_map, buf, count); 1469 1470 if (new_button == AIPTEK_INVALID_VALUE) 1471 return -EINVAL; 1472 1473 aiptek->newSetting.mouseButtonLeft = new_button; 1474 return count; 1475 } 1476 1477 static DEVICE_ATTR(mouse_left, 1478 S_IRUGO | S_IWUSR, 1479 show_tabletMouseLeft, store_tabletMouseLeft); 1480 1481 /*********************************************************************** 1482 * support routines for the 'mouse_middle' file. Note that this file 1483 * both displays current setting and allows for setting changing. 1484 */ 1485 static ssize_t show_tabletMouseMiddle(struct device *dev, struct device_attribute *attr, char *buf) 1486 { 1487 struct aiptek *aiptek = dev_get_drvdata(dev); 1488 1489 return snprintf(buf, PAGE_SIZE, "%s\n", 1490 map_val_to_str(mouse_button_map, 1491 aiptek->curSetting.mouseButtonMiddle)); 1492 } 1493 1494 static ssize_t 1495 store_tabletMouseMiddle(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1496 { 1497 struct aiptek *aiptek = dev_get_drvdata(dev); 1498 int new_button = map_str_to_val(mouse_button_map, buf, count); 1499 1500 if (new_button == AIPTEK_INVALID_VALUE) 1501 return -EINVAL; 1502 1503 aiptek->newSetting.mouseButtonMiddle = new_button; 1504 return count; 1505 } 1506 1507 static DEVICE_ATTR(mouse_middle, 1508 S_IRUGO | S_IWUSR, 1509 show_tabletMouseMiddle, store_tabletMouseMiddle); 1510 1511 /*********************************************************************** 1512 * support routines for the 'mouse_right' file. Note that this file 1513 * both displays current setting and allows for setting changing. 1514 */ 1515 static ssize_t show_tabletMouseRight(struct device *dev, struct device_attribute *attr, char *buf) 1516 { 1517 struct aiptek *aiptek = dev_get_drvdata(dev); 1518 1519 return snprintf(buf, PAGE_SIZE, "%s\n", 1520 map_val_to_str(mouse_button_map, 1521 aiptek->curSetting.mouseButtonRight)); 1522 } 1523 1524 static ssize_t 1525 store_tabletMouseRight(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1526 { 1527 struct aiptek *aiptek = dev_get_drvdata(dev); 1528 int new_button = map_str_to_val(mouse_button_map, buf, count); 1529 1530 if (new_button == AIPTEK_INVALID_VALUE) 1531 return -EINVAL; 1532 1533 aiptek->newSetting.mouseButtonRight = new_button; 1534 return count; 1535 } 1536 1537 static DEVICE_ATTR(mouse_right, 1538 S_IRUGO | S_IWUSR, 1539 show_tabletMouseRight, store_tabletMouseRight); 1540 1541 /*********************************************************************** 1542 * support routines for the 'wheel' file. Note that this file 1543 * both displays current setting and allows for setting changing. 1544 */ 1545 static ssize_t show_tabletWheel(struct device *dev, struct device_attribute *attr, char *buf) 1546 { 1547 struct aiptek *aiptek = dev_get_drvdata(dev); 1548 1549 if (aiptek->curSetting.wheel == AIPTEK_WHEEL_DISABLE) { 1550 return snprintf(buf, PAGE_SIZE, "disable\n"); 1551 } else { 1552 return snprintf(buf, PAGE_SIZE, "%d\n", 1553 aiptek->curSetting.wheel); 1554 } 1555 } 1556 1557 static ssize_t 1558 store_tabletWheel(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1559 { 1560 struct aiptek *aiptek = dev_get_drvdata(dev); 1561 long w; 1562 1563 if (strict_strtol(buf, 10, &w)) return -EINVAL; 1564 1565 aiptek->newSetting.wheel = (int)w; 1566 return count; 1567 } 1568 1569 static DEVICE_ATTR(wheel, 1570 S_IRUGO | S_IWUSR, show_tabletWheel, store_tabletWheel); 1571 1572 /*********************************************************************** 1573 * support routines for the 'execute' file. Note that this file 1574 * both displays current setting and allows for setting changing. 1575 */ 1576 static ssize_t show_tabletExecute(struct device *dev, struct device_attribute *attr, char *buf) 1577 { 1578 /* There is nothing useful to display, so a one-line manual 1579 * is in order... 1580 */ 1581 return snprintf(buf, PAGE_SIZE, 1582 "Write anything to this file to program your tablet.\n"); 1583 } 1584 1585 static ssize_t 1586 store_tabletExecute(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1587 { 1588 struct aiptek *aiptek = dev_get_drvdata(dev); 1589 1590 /* We do not care what you write to this file. Merely the action 1591 * of writing to this file triggers a tablet reprogramming. 1592 */ 1593 memcpy(&aiptek->curSetting, &aiptek->newSetting, 1594 sizeof(struct aiptek_settings)); 1595 1596 if (aiptek_program_tablet(aiptek) < 0) 1597 return -EIO; 1598 1599 return count; 1600 } 1601 1602 static DEVICE_ATTR(execute, 1603 S_IRUGO | S_IWUSR, show_tabletExecute, store_tabletExecute); 1604 1605 /*********************************************************************** 1606 * support routines for the 'odm_code' file. Note that this file 1607 * only displays current setting. 1608 */ 1609 static ssize_t show_tabletODMCode(struct device *dev, struct device_attribute *attr, char *buf) 1610 { 1611 struct aiptek *aiptek = dev_get_drvdata(dev); 1612 1613 return snprintf(buf, PAGE_SIZE, "0x%04x\n", aiptek->features.odmCode); 1614 } 1615 1616 static DEVICE_ATTR(odm_code, S_IRUGO, show_tabletODMCode, NULL); 1617 1618 /*********************************************************************** 1619 * support routines for the 'model_code' file. Note that this file 1620 * only displays current setting. 1621 */ 1622 static ssize_t show_tabletModelCode(struct device *dev, struct device_attribute *attr, char *buf) 1623 { 1624 struct aiptek *aiptek = dev_get_drvdata(dev); 1625 1626 return snprintf(buf, PAGE_SIZE, "0x%04x\n", aiptek->features.modelCode); 1627 } 1628 1629 static DEVICE_ATTR(model_code, S_IRUGO, show_tabletModelCode, NULL); 1630 1631 /*********************************************************************** 1632 * support routines for the 'firmware_code' file. Note that this file 1633 * only displays current setting. 1634 */ 1635 static ssize_t show_firmwareCode(struct device *dev, struct device_attribute *attr, char *buf) 1636 { 1637 struct aiptek *aiptek = dev_get_drvdata(dev); 1638 1639 return snprintf(buf, PAGE_SIZE, "%04x\n", 1640 aiptek->features.firmwareCode); 1641 } 1642 1643 static DEVICE_ATTR(firmware_code, S_IRUGO, show_firmwareCode, NULL); 1644 1645 static struct attribute *aiptek_attributes[] = { 1646 &dev_attr_size.attr, 1647 &dev_attr_pointer_mode.attr, 1648 &dev_attr_coordinate_mode.attr, 1649 &dev_attr_tool_mode.attr, 1650 &dev_attr_xtilt.attr, 1651 &dev_attr_ytilt.attr, 1652 &dev_attr_jitter.attr, 1653 &dev_attr_delay.attr, 1654 &dev_attr_event_count.attr, 1655 &dev_attr_diagnostic.attr, 1656 &dev_attr_odm_code.attr, 1657 &dev_attr_model_code.attr, 1658 &dev_attr_firmware_code.attr, 1659 &dev_attr_stylus_lower.attr, 1660 &dev_attr_stylus_upper.attr, 1661 &dev_attr_mouse_left.attr, 1662 &dev_attr_mouse_middle.attr, 1663 &dev_attr_mouse_right.attr, 1664 &dev_attr_wheel.attr, 1665 &dev_attr_execute.attr, 1666 NULL 1667 }; 1668 1669 static struct attribute_group aiptek_attribute_group = { 1670 .attrs = aiptek_attributes, 1671 }; 1672 1673 /*********************************************************************** 1674 * This routine is called when a tablet has been identified. It basically 1675 * sets up the tablet and the driver's internal structures. 1676 */ 1677 static int 1678 aiptek_probe(struct usb_interface *intf, const struct usb_device_id *id) 1679 { 1680 struct usb_device *usbdev = interface_to_usbdev(intf); 1681 struct usb_endpoint_descriptor *endpoint; 1682 struct aiptek *aiptek; 1683 struct input_dev *inputdev; 1684 int i; 1685 int speeds[] = { 0, 1686 AIPTEK_PROGRAMMABLE_DELAY_50, 1687 AIPTEK_PROGRAMMABLE_DELAY_400, 1688 AIPTEK_PROGRAMMABLE_DELAY_25, 1689 AIPTEK_PROGRAMMABLE_DELAY_100, 1690 AIPTEK_PROGRAMMABLE_DELAY_200, 1691 AIPTEK_PROGRAMMABLE_DELAY_300 1692 }; 1693 int err = -ENOMEM; 1694 1695 /* programmableDelay is where the command-line specified 1696 * delay is kept. We make it the first element of speeds[], 1697 * so therefore, your override speed is tried first, then the 1698 * remainder. Note that the default value of 400ms will be tried 1699 * if you do not specify any command line parameter. 1700 */ 1701 speeds[0] = programmableDelay; 1702 1703 aiptek = kzalloc(sizeof(struct aiptek), GFP_KERNEL); 1704 inputdev = input_allocate_device(); 1705 if (!aiptek || !inputdev) { 1706 dev_warn(&intf->dev, 1707 "cannot allocate memory or input device\n"); 1708 goto fail1; 1709 } 1710 1711 aiptek->data = usb_alloc_coherent(usbdev, AIPTEK_PACKET_LENGTH, 1712 GFP_ATOMIC, &aiptek->data_dma); 1713 if (!aiptek->data) { 1714 dev_warn(&intf->dev, "cannot allocate usb buffer\n"); 1715 goto fail1; 1716 } 1717 1718 aiptek->urb = usb_alloc_urb(0, GFP_KERNEL); 1719 if (!aiptek->urb) { 1720 dev_warn(&intf->dev, "cannot allocate urb\n"); 1721 goto fail2; 1722 } 1723 1724 aiptek->inputdev = inputdev; 1725 aiptek->usbdev = usbdev; 1726 aiptek->ifnum = intf->altsetting[0].desc.bInterfaceNumber; 1727 aiptek->inDelay = 0; 1728 aiptek->endDelay = 0; 1729 aiptek->previousJitterable = 0; 1730 aiptek->lastMacro = -1; 1731 1732 /* Set up the curSettings struct. Said struct contains the current 1733 * programmable parameters. The newSetting struct contains changes 1734 * the user makes to the settings via the sysfs interface. Those 1735 * changes are not "committed" to curSettings until the user 1736 * writes to the sysfs/.../execute file. 1737 */ 1738 aiptek->curSetting.pointerMode = AIPTEK_POINTER_EITHER_MODE; 1739 aiptek->curSetting.coordinateMode = AIPTEK_COORDINATE_ABSOLUTE_MODE; 1740 aiptek->curSetting.toolMode = AIPTEK_TOOL_BUTTON_PEN_MODE; 1741 aiptek->curSetting.xTilt = AIPTEK_TILT_DISABLE; 1742 aiptek->curSetting.yTilt = AIPTEK_TILT_DISABLE; 1743 aiptek->curSetting.mouseButtonLeft = AIPTEK_MOUSE_LEFT_BUTTON; 1744 aiptek->curSetting.mouseButtonMiddle = AIPTEK_MOUSE_MIDDLE_BUTTON; 1745 aiptek->curSetting.mouseButtonRight = AIPTEK_MOUSE_RIGHT_BUTTON; 1746 aiptek->curSetting.stylusButtonUpper = AIPTEK_STYLUS_UPPER_BUTTON; 1747 aiptek->curSetting.stylusButtonLower = AIPTEK_STYLUS_LOWER_BUTTON; 1748 aiptek->curSetting.jitterDelay = jitterDelay; 1749 aiptek->curSetting.programmableDelay = programmableDelay; 1750 1751 /* Both structs should have equivalent settings 1752 */ 1753 aiptek->newSetting = aiptek->curSetting; 1754 1755 /* Determine the usb devices' physical path. 1756 * Asketh not why we always pretend we're using "../input0", 1757 * but I suspect this will have to be refactored one 1758 * day if a single USB device can be a keyboard & a mouse 1759 * & a tablet, and the inputX number actually will tell 1760 * us something... 1761 */ 1762 usb_make_path(usbdev, aiptek->features.usbPath, 1763 sizeof(aiptek->features.usbPath)); 1764 strlcat(aiptek->features.usbPath, "/input0", 1765 sizeof(aiptek->features.usbPath)); 1766 1767 /* Set up client data, pointers to open and close routines 1768 * for the input device. 1769 */ 1770 inputdev->name = "Aiptek"; 1771 inputdev->phys = aiptek->features.usbPath; 1772 usb_to_input_id(usbdev, &inputdev->id); 1773 inputdev->dev.parent = &intf->dev; 1774 1775 input_set_drvdata(inputdev, aiptek); 1776 1777 inputdev->open = aiptek_open; 1778 inputdev->close = aiptek_close; 1779 1780 /* Now program the capacities of the tablet, in terms of being 1781 * an input device. 1782 */ 1783 for (i = 0; i < ARRAY_SIZE(eventTypes); ++i) 1784 __set_bit(eventTypes[i], inputdev->evbit); 1785 1786 for (i = 0; i < ARRAY_SIZE(absEvents); ++i) 1787 __set_bit(absEvents[i], inputdev->absbit); 1788 1789 for (i = 0; i < ARRAY_SIZE(relEvents); ++i) 1790 __set_bit(relEvents[i], inputdev->relbit); 1791 1792 __set_bit(MSC_SERIAL, inputdev->mscbit); 1793 1794 /* Set up key and button codes */ 1795 for (i = 0; i < ARRAY_SIZE(buttonEvents); ++i) 1796 __set_bit(buttonEvents[i], inputdev->keybit); 1797 1798 for (i = 0; i < ARRAY_SIZE(macroKeyEvents); ++i) 1799 __set_bit(macroKeyEvents[i], inputdev->keybit); 1800 1801 /* 1802 * Program the input device coordinate capacities. We do not yet 1803 * know what maximum X, Y, and Z values are, so we're putting fake 1804 * values in. Later, we'll ask the tablet to put in the correct 1805 * values. 1806 */ 1807 input_set_abs_params(inputdev, ABS_X, 0, 2999, 0, 0); 1808 input_set_abs_params(inputdev, ABS_Y, 0, 2249, 0, 0); 1809 input_set_abs_params(inputdev, ABS_PRESSURE, 0, 511, 0, 0); 1810 input_set_abs_params(inputdev, ABS_TILT_X, AIPTEK_TILT_MIN, AIPTEK_TILT_MAX, 0, 0); 1811 input_set_abs_params(inputdev, ABS_TILT_Y, AIPTEK_TILT_MIN, AIPTEK_TILT_MAX, 0, 0); 1812 input_set_abs_params(inputdev, ABS_WHEEL, AIPTEK_WHEEL_MIN, AIPTEK_WHEEL_MAX - 1, 0, 0); 1813 1814 endpoint = &intf->altsetting[0].endpoint[0].desc; 1815 1816 /* Go set up our URB, which is called when the tablet receives 1817 * input. 1818 */ 1819 usb_fill_int_urb(aiptek->urb, 1820 aiptek->usbdev, 1821 usb_rcvintpipe(aiptek->usbdev, 1822 endpoint->bEndpointAddress), 1823 aiptek->data, 8, aiptek_irq, aiptek, 1824 endpoint->bInterval); 1825 1826 aiptek->urb->transfer_dma = aiptek->data_dma; 1827 aiptek->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1828 1829 /* Program the tablet. This sets the tablet up in the mode 1830 * specified in newSetting, and also queries the tablet's 1831 * physical capacities. 1832 * 1833 * Sanity check: if a tablet doesn't like the slow programmatic 1834 * delay, we often get sizes of 0x0. Let's use that as an indicator 1835 * to try faster delays, up to 25 ms. If that logic fails, well, you'll 1836 * have to explain to us how your tablet thinks it's 0x0, and yet that's 1837 * not an error :-) 1838 */ 1839 1840 for (i = 0; i < ARRAY_SIZE(speeds); ++i) { 1841 aiptek->curSetting.programmableDelay = speeds[i]; 1842 (void)aiptek_program_tablet(aiptek); 1843 if (input_abs_get_max(aiptek->inputdev, ABS_X) > 0) { 1844 dev_info(&intf->dev, 1845 "Aiptek using %d ms programming speed\n", 1846 aiptek->curSetting.programmableDelay); 1847 break; 1848 } 1849 } 1850 1851 /* Murphy says that some day someone will have a tablet that fails the 1852 above test. That's you, Frederic Rodrigo */ 1853 if (i == ARRAY_SIZE(speeds)) { 1854 dev_info(&intf->dev, 1855 "Aiptek tried all speeds, no sane response\n"); 1856 goto fail2; 1857 } 1858 1859 /* Associate this driver's struct with the usb interface. 1860 */ 1861 usb_set_intfdata(intf, aiptek); 1862 1863 /* Set up the sysfs files 1864 */ 1865 err = sysfs_create_group(&intf->dev.kobj, &aiptek_attribute_group); 1866 if (err) { 1867 dev_warn(&intf->dev, "cannot create sysfs group err: %d\n", 1868 err); 1869 goto fail3; 1870 } 1871 1872 /* Register the tablet as an Input Device 1873 */ 1874 err = input_register_device(aiptek->inputdev); 1875 if (err) { 1876 dev_warn(&intf->dev, 1877 "input_register_device returned err: %d\n", err); 1878 goto fail4; 1879 } 1880 return 0; 1881 1882 fail4: sysfs_remove_group(&intf->dev.kobj, &aiptek_attribute_group); 1883 fail3: usb_free_urb(aiptek->urb); 1884 fail2: usb_free_coherent(usbdev, AIPTEK_PACKET_LENGTH, aiptek->data, 1885 aiptek->data_dma); 1886 fail1: usb_set_intfdata(intf, NULL); 1887 input_free_device(inputdev); 1888 kfree(aiptek); 1889 return err; 1890 } 1891 1892 /*********************************************************************** 1893 * Deal with tablet disconnecting from the system. 1894 */ 1895 static void aiptek_disconnect(struct usb_interface *intf) 1896 { 1897 struct aiptek *aiptek = usb_get_intfdata(intf); 1898 1899 /* Disassociate driver's struct with usb interface 1900 */ 1901 usb_set_intfdata(intf, NULL); 1902 if (aiptek != NULL) { 1903 /* Free & unhook everything from the system. 1904 */ 1905 usb_kill_urb(aiptek->urb); 1906 input_unregister_device(aiptek->inputdev); 1907 sysfs_remove_group(&intf->dev.kobj, &aiptek_attribute_group); 1908 usb_free_urb(aiptek->urb); 1909 usb_free_coherent(interface_to_usbdev(intf), 1910 AIPTEK_PACKET_LENGTH, 1911 aiptek->data, aiptek->data_dma); 1912 kfree(aiptek); 1913 } 1914 } 1915 1916 static struct usb_driver aiptek_driver = { 1917 .name = "aiptek", 1918 .probe = aiptek_probe, 1919 .disconnect = aiptek_disconnect, 1920 .id_table = aiptek_ids, 1921 }; 1922 1923 static int __init aiptek_init(void) 1924 { 1925 int result = usb_register(&aiptek_driver); 1926 if (result == 0) { 1927 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 1928 DRIVER_DESC "\n"); 1929 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_AUTHOR "\n"); 1930 } 1931 return result; 1932 } 1933 1934 static void __exit aiptek_exit(void) 1935 { 1936 usb_deregister(&aiptek_driver); 1937 } 1938 1939 MODULE_AUTHOR(DRIVER_AUTHOR); 1940 MODULE_DESCRIPTION(DRIVER_DESC); 1941 MODULE_LICENSE("GPL"); 1942 1943 module_param(programmableDelay, int, 0); 1944 MODULE_PARM_DESC(programmableDelay, "delay used during tablet programming"); 1945 module_param(jitterDelay, int, 0); 1946 MODULE_PARM_DESC(jitterDelay, "stylus/mouse settlement delay"); 1947 1948 module_init(aiptek_init); 1949 module_exit(aiptek_exit); 1950