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