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