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