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