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 289static int programmableDelay = AIPTEK_PROGRAMMABLE_DELAY_DEFAULT; 290static int jitterDelay = AIPTEK_JITTER_DELAY_DEFAULT; 291 292struct 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 300struct 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 316struct 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 */ 338static 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 */ 351static 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 398static 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 767exit: 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 */ 783static 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 794MODULE_DEVICE_TABLE(usb, aiptek_ids); 795 796/*********************************************************************** 797 * Open an instance of the tablet driver. 798 */ 799static 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 */ 813static 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 */ 824static int 825aiptek_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 837static int 838aiptek_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 */ 853static int 854aiptek_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 */ 882static int 883aiptek_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 */ 919static 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 979 /* Execute AutoGainOn */ 980 if ((ret = aiptek_command(aiptek, 0x12, 0xff)) < 0) 981 return ret; 982 983 /* Reset the eventCount, so we track events from last (re)programming 984 */ 985 aiptek->diagnostic = AIPTEK_DIAGNOSTIC_NA; 986 aiptek->eventCount = 0; 987 988 return 0; 989} 990 991/*********************************************************************** 992 * Sysfs functions. Sysfs prefers that individually-tunable parameters 993 * exist in their separate pseudo-files. Summary data that is immutable 994 * may exist in a singular file so long as you don't define a writeable 995 * interface. 996 */ 997 998/*********************************************************************** 999 * support the 'size' file -- display support 1000 */ 1001static ssize_t show_tabletSize(struct device *dev, struct device_attribute *attr, char *buf) 1002{ 1003 struct aiptek *aiptek = dev_get_drvdata(dev); 1004 1005 if (aiptek == NULL) 1006 return 0; 1007 1008 return snprintf(buf, PAGE_SIZE, "%dx%d\n", 1009 aiptek->inputdev->absmax[ABS_X] + 1, 1010 aiptek->inputdev->absmax[ABS_Y] + 1); 1011} 1012 1013/* These structs define the sysfs files, param #1 is the name of the 1014 * file, param 2 is the file permissions, param 3 & 4 are to the 1015 * output generator and input parser routines. Absence of a routine is 1016 * permitted -- it only means can't either 'cat' the file, or send data 1017 * to it. 1018 */ 1019static DEVICE_ATTR(size, S_IRUGO, show_tabletSize, NULL); 1020 1021/*********************************************************************** 1022 * support routines for the 'product_id' file 1023 */ 1024static ssize_t show_tabletProductId(struct device *dev, struct device_attribute *attr, char *buf) 1025{ 1026 struct aiptek *aiptek = dev_get_drvdata(dev); 1027 1028 if (aiptek == NULL) 1029 return 0; 1030 1031 return snprintf(buf, PAGE_SIZE, "0x%04x\n", 1032 aiptek->inputdev->id.product); 1033} 1034 1035static DEVICE_ATTR(product_id, S_IRUGO, show_tabletProductId, NULL); 1036 1037/*********************************************************************** 1038 * support routines for the 'vendor_id' file 1039 */ 1040static ssize_t show_tabletVendorId(struct device *dev, struct device_attribute *attr, char *buf) 1041{ 1042 struct aiptek *aiptek = dev_get_drvdata(dev); 1043 1044 if (aiptek == NULL) 1045 return 0; 1046 1047 return snprintf(buf, PAGE_SIZE, "0x%04x\n", aiptek->inputdev->id.vendor); 1048} 1049 1050static DEVICE_ATTR(vendor_id, S_IRUGO, show_tabletVendorId, NULL); 1051 1052/*********************************************************************** 1053 * support routines for the 'vendor' file 1054 */ 1055static ssize_t show_tabletManufacturer(struct device *dev, struct device_attribute *attr, char *buf) 1056{ 1057 struct aiptek *aiptek = dev_get_drvdata(dev); 1058 int retval; 1059 1060 if (aiptek == NULL) 1061 return 0; 1062 1063 retval = snprintf(buf, PAGE_SIZE, "%s\n", aiptek->usbdev->manufacturer); 1064 return retval; 1065} 1066 1067static DEVICE_ATTR(vendor, S_IRUGO, show_tabletManufacturer, NULL); 1068 1069/*********************************************************************** 1070 * support routines for the 'product' file 1071 */ 1072static ssize_t show_tabletProduct(struct device *dev, struct device_attribute *attr, char *buf) 1073{ 1074 struct aiptek *aiptek = dev_get_drvdata(dev); 1075 int retval; 1076 1077 if (aiptek == NULL) 1078 return 0; 1079 1080 retval = snprintf(buf, PAGE_SIZE, "%s\n", aiptek->usbdev->product); 1081 return retval; 1082} 1083 1084static DEVICE_ATTR(product, S_IRUGO, show_tabletProduct, NULL); 1085 1086/*********************************************************************** 1087 * support routines for the 'pointer_mode' file. Note that this file 1088 * both displays current setting and allows reprogramming. 1089 */ 1090static ssize_t show_tabletPointerMode(struct device *dev, struct device_attribute *attr, char *buf) 1091{ 1092 struct aiptek *aiptek = dev_get_drvdata(dev); 1093 char *s; 1094 1095 if (aiptek == NULL) 1096 return 0; 1097 1098 switch (aiptek->curSetting.pointerMode) { 1099 case AIPTEK_POINTER_ONLY_STYLUS_MODE: 1100 s = "stylus"; 1101 break; 1102 1103 case AIPTEK_POINTER_ONLY_MOUSE_MODE: 1104 s = "mouse"; 1105 break; 1106 1107 case AIPTEK_POINTER_EITHER_MODE: 1108 s = "either"; 1109 break; 1110 1111 default: 1112 s = "unknown"; 1113 break; 1114 } 1115 return snprintf(buf, PAGE_SIZE, "%s\n", s); 1116} 1117 1118static ssize_t 1119store_tabletPointerMode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1120{ 1121 struct aiptek *aiptek = dev_get_drvdata(dev); 1122 if (aiptek == NULL) 1123 return 0; 1124 1125 if (strcmp(buf, "stylus") == 0) { 1126 aiptek->newSetting.pointerMode = 1127 AIPTEK_POINTER_ONLY_STYLUS_MODE; 1128 } else if (strcmp(buf, "mouse") == 0) { 1129 aiptek->newSetting.pointerMode = AIPTEK_POINTER_ONLY_MOUSE_MODE; 1130 } else if (strcmp(buf, "either") == 0) { 1131 aiptek->newSetting.pointerMode = AIPTEK_POINTER_EITHER_MODE; 1132 } 1133 return count; 1134} 1135 1136static DEVICE_ATTR(pointer_mode, 1137 S_IRUGO | S_IWUGO, 1138 show_tabletPointerMode, store_tabletPointerMode); 1139 1140/*********************************************************************** 1141 * support routines for the 'coordinate_mode' file. Note that this file 1142 * both displays current setting and allows reprogramming. 1143 */ 1144static ssize_t show_tabletCoordinateMode(struct device *dev, struct device_attribute *attr, char *buf) 1145{ 1146 struct aiptek *aiptek = dev_get_drvdata(dev); 1147 char *s; 1148 1149 if (aiptek == NULL) 1150 return 0; 1151 1152 switch (aiptek->curSetting.coordinateMode) { 1153 case AIPTEK_COORDINATE_ABSOLUTE_MODE: 1154 s = "absolute"; 1155 break; 1156 1157 case AIPTEK_COORDINATE_RELATIVE_MODE: 1158 s = "relative"; 1159 break; 1160 1161 default: 1162 s = "unknown"; 1163 break; 1164 } 1165 return snprintf(buf, PAGE_SIZE, "%s\n", s); 1166} 1167 1168static ssize_t 1169store_tabletCoordinateMode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1170{ 1171 struct aiptek *aiptek = dev_get_drvdata(dev); 1172 if (aiptek == NULL) 1173 return 0; 1174 1175 if (strcmp(buf, "absolute") == 0) { 1176 aiptek->newSetting.pointerMode = 1177 AIPTEK_COORDINATE_ABSOLUTE_MODE; 1178 } else if (strcmp(buf, "relative") == 0) { 1179 aiptek->newSetting.pointerMode = 1180 AIPTEK_COORDINATE_RELATIVE_MODE; 1181 } 1182 return count; 1183} 1184 1185static DEVICE_ATTR(coordinate_mode, 1186 S_IRUGO | S_IWUGO, 1187 show_tabletCoordinateMode, store_tabletCoordinateMode); 1188 1189/*********************************************************************** 1190 * support routines for the 'tool_mode' file. Note that this file 1191 * both displays current setting and allows reprogramming. 1192 */ 1193static ssize_t show_tabletToolMode(struct device *dev, struct device_attribute *attr, char *buf) 1194{ 1195 struct aiptek *aiptek = dev_get_drvdata(dev); 1196 char *s; 1197 1198 if (aiptek == NULL) 1199 return 0; 1200 1201 switch (TOOL_BUTTON(aiptek->curSetting.toolMode)) { 1202 case AIPTEK_TOOL_BUTTON_MOUSE_MODE: 1203 s = "mouse"; 1204 break; 1205 1206 case AIPTEK_TOOL_BUTTON_ERASER_MODE: 1207 s = "eraser"; 1208 break; 1209 1210 case AIPTEK_TOOL_BUTTON_PENCIL_MODE: 1211 s = "pencil"; 1212 break; 1213 1214 case AIPTEK_TOOL_BUTTON_PEN_MODE: 1215 s = "pen"; 1216 break; 1217 1218 case AIPTEK_TOOL_BUTTON_BRUSH_MODE: 1219 s = "brush"; 1220 break; 1221 1222 case AIPTEK_TOOL_BUTTON_AIRBRUSH_MODE: 1223 s = "airbrush"; 1224 break; 1225 1226 case AIPTEK_TOOL_BUTTON_LENS_MODE: 1227 s = "lens"; 1228 break; 1229 1230 default: 1231 s = "unknown"; 1232 break; 1233 } 1234 return snprintf(buf, PAGE_SIZE, "%s\n", s); 1235} 1236 1237static ssize_t 1238store_tabletToolMode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1239{ 1240 struct aiptek *aiptek = dev_get_drvdata(dev); 1241 if (aiptek == NULL) 1242 return 0; 1243 1244 if (strcmp(buf, "mouse") == 0) { 1245 aiptek->newSetting.toolMode = AIPTEK_TOOL_BUTTON_MOUSE_MODE; 1246 } else if (strcmp(buf, "eraser") == 0) { 1247 aiptek->newSetting.toolMode = AIPTEK_TOOL_BUTTON_ERASER_MODE; 1248 } else if (strcmp(buf, "pencil") == 0) { 1249 aiptek->newSetting.toolMode = AIPTEK_TOOL_BUTTON_PENCIL_MODE; 1250 } else if (strcmp(buf, "pen") == 0) { 1251 aiptek->newSetting.toolMode = AIPTEK_TOOL_BUTTON_PEN_MODE; 1252 } else if (strcmp(buf, "brush") == 0) { 1253 aiptek->newSetting.toolMode = AIPTEK_TOOL_BUTTON_BRUSH_MODE; 1254 } else if (strcmp(buf, "airbrush") == 0) { 1255 aiptek->newSetting.toolMode = AIPTEK_TOOL_BUTTON_AIRBRUSH_MODE; 1256 } else if (strcmp(buf, "lens") == 0) { 1257 aiptek->newSetting.toolMode = AIPTEK_TOOL_BUTTON_LENS_MODE; 1258 } 1259 1260 return count; 1261} 1262 1263static DEVICE_ATTR(tool_mode, 1264 S_IRUGO | S_IWUGO, 1265 show_tabletToolMode, store_tabletToolMode); 1266 1267/*********************************************************************** 1268 * support routines for the 'xtilt' file. Note that this file 1269 * both displays current setting and allows reprogramming. 1270 */ 1271static ssize_t show_tabletXtilt(struct device *dev, struct device_attribute *attr, char *buf) 1272{ 1273 struct aiptek *aiptek = dev_get_drvdata(dev); 1274 1275 if (aiptek == NULL) 1276 return 0; 1277 1278 if (aiptek->curSetting.xTilt == AIPTEK_TILT_DISABLE) { 1279 return snprintf(buf, PAGE_SIZE, "disable\n"); 1280 } else { 1281 return snprintf(buf, PAGE_SIZE, "%d\n", 1282 aiptek->curSetting.xTilt); 1283 } 1284} 1285 1286static ssize_t 1287store_tabletXtilt(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1288{ 1289 struct aiptek *aiptek = dev_get_drvdata(dev); 1290 int x; 1291 1292 if (aiptek == NULL) 1293 return 0; 1294 1295 if (strcmp(buf, "disable") == 0) { 1296 aiptek->newSetting.xTilt = AIPTEK_TILT_DISABLE; 1297 } else { 1298 x = (int)simple_strtol(buf, NULL, 10); 1299 if (x >= AIPTEK_TILT_MIN && x <= AIPTEK_TILT_MAX) { 1300 aiptek->newSetting.xTilt = x; 1301 } 1302 } 1303 return count; 1304} 1305 1306static DEVICE_ATTR(xtilt, 1307 S_IRUGO | S_IWUGO, show_tabletXtilt, store_tabletXtilt); 1308 1309/*********************************************************************** 1310 * support routines for the 'ytilt' file. Note that this file 1311 * both displays current setting and allows reprogramming. 1312 */ 1313static ssize_t show_tabletYtilt(struct device *dev, struct device_attribute *attr, char *buf) 1314{ 1315 struct aiptek *aiptek = dev_get_drvdata(dev); 1316 1317 if (aiptek == NULL) 1318 return 0; 1319 1320 if (aiptek->curSetting.yTilt == AIPTEK_TILT_DISABLE) { 1321 return snprintf(buf, PAGE_SIZE, "disable\n"); 1322 } else { 1323 return snprintf(buf, PAGE_SIZE, "%d\n", 1324 aiptek->curSetting.yTilt); 1325 } 1326} 1327 1328static ssize_t 1329store_tabletYtilt(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1330{ 1331 struct aiptek *aiptek = dev_get_drvdata(dev); 1332 int y; 1333 1334 if (aiptek == NULL) 1335 return 0; 1336 1337 if (strcmp(buf, "disable") == 0) { 1338 aiptek->newSetting.yTilt = AIPTEK_TILT_DISABLE; 1339 } else { 1340 y = (int)simple_strtol(buf, NULL, 10); 1341 if (y >= AIPTEK_TILT_MIN && y <= AIPTEK_TILT_MAX) { 1342 aiptek->newSetting.yTilt = y; 1343 } 1344 } 1345 return count; 1346} 1347 1348static DEVICE_ATTR(ytilt, 1349 S_IRUGO | S_IWUGO, show_tabletYtilt, store_tabletYtilt); 1350 1351/*********************************************************************** 1352 * support routines for the 'jitter' file. Note that this file 1353 * both displays current setting and allows reprogramming. 1354 */ 1355static ssize_t show_tabletJitterDelay(struct device *dev, struct device_attribute *attr, char *buf) 1356{ 1357 struct aiptek *aiptek = dev_get_drvdata(dev); 1358 1359 if (aiptek == NULL) 1360 return 0; 1361 1362 return snprintf(buf, PAGE_SIZE, "%d\n", aiptek->curSetting.jitterDelay); 1363} 1364 1365static ssize_t 1366store_tabletJitterDelay(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1367{ 1368 struct aiptek *aiptek = dev_get_drvdata(dev); 1369 1370 if (aiptek == NULL) 1371 return 0; 1372 1373 aiptek->newSetting.jitterDelay = (int)simple_strtol(buf, NULL, 10); 1374 return count; 1375} 1376 1377static DEVICE_ATTR(jitter, 1378 S_IRUGO | S_IWUGO, 1379 show_tabletJitterDelay, store_tabletJitterDelay); 1380 1381/*********************************************************************** 1382 * support routines for the 'delay' file. Note that this file 1383 * both displays current setting and allows reprogramming. 1384 */ 1385static ssize_t show_tabletProgrammableDelay(struct device *dev, struct device_attribute *attr, char *buf) 1386{ 1387 struct aiptek *aiptek = dev_get_drvdata(dev); 1388 1389 if (aiptek == NULL) 1390 return 0; 1391 1392 return snprintf(buf, PAGE_SIZE, "%d\n", 1393 aiptek->curSetting.programmableDelay); 1394} 1395 1396static ssize_t 1397store_tabletProgrammableDelay(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1398{ 1399 struct aiptek *aiptek = dev_get_drvdata(dev); 1400 1401 if (aiptek == NULL) 1402 return 0; 1403 1404 aiptek->newSetting.programmableDelay = (int)simple_strtol(buf, NULL, 10); 1405 return count; 1406} 1407 1408static DEVICE_ATTR(delay, 1409 S_IRUGO | S_IWUGO, 1410 show_tabletProgrammableDelay, store_tabletProgrammableDelay); 1411 1412/*********************************************************************** 1413 * support routines for the 'input_path' file. Note that this file 1414 * only displays current setting. 1415 */ 1416static ssize_t show_tabletInputDevice(struct device *dev, struct device_attribute *attr, char *buf) 1417{ 1418 struct aiptek *aiptek = dev_get_drvdata(dev); 1419 1420 if (aiptek == NULL) 1421 return 0; 1422 1423 return snprintf(buf, PAGE_SIZE, "/dev/input/%s\n", 1424 aiptek->features.inputPath); 1425} 1426 1427static DEVICE_ATTR(input_path, S_IRUGO, show_tabletInputDevice, NULL); 1428 1429/*********************************************************************** 1430 * support routines for the 'event_count' file. Note that this file 1431 * only displays current setting. 1432 */ 1433static ssize_t show_tabletEventsReceived(struct device *dev, struct device_attribute *attr, char *buf) 1434{ 1435 struct aiptek *aiptek = dev_get_drvdata(dev); 1436 1437 if (aiptek == NULL) 1438 return 0; 1439 1440 return snprintf(buf, PAGE_SIZE, "%ld\n", aiptek->eventCount); 1441} 1442 1443static DEVICE_ATTR(event_count, S_IRUGO, show_tabletEventsReceived, NULL); 1444 1445/*********************************************************************** 1446 * support routines for the 'diagnostic' file. Note that this file 1447 * only displays current setting. 1448 */ 1449static ssize_t show_tabletDiagnosticMessage(struct device *dev, struct device_attribute *attr, char *buf) 1450{ 1451 struct aiptek *aiptek = dev_get_drvdata(dev); 1452 char *retMsg; 1453 1454 if (aiptek == NULL) 1455 return 0; 1456 1457 switch (aiptek->diagnostic) { 1458 case AIPTEK_DIAGNOSTIC_NA: 1459 retMsg = "no errors\n"; 1460 break; 1461 1462 case AIPTEK_DIAGNOSTIC_SENDING_RELATIVE_IN_ABSOLUTE: 1463 retMsg = "Error: receiving relative reports\n"; 1464 break; 1465 1466 case AIPTEK_DIAGNOSTIC_SENDING_ABSOLUTE_IN_RELATIVE: 1467 retMsg = "Error: receiving absolute reports\n"; 1468 break; 1469 1470 case AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED: 1471 if (aiptek->curSetting.pointerMode == 1472 AIPTEK_POINTER_ONLY_MOUSE_MODE) { 1473 retMsg = "Error: receiving stylus reports\n"; 1474 } else { 1475 retMsg = "Error: receiving mouse reports\n"; 1476 } 1477 break; 1478 1479 default: 1480 return 0; 1481 } 1482 return snprintf(buf, PAGE_SIZE, retMsg); 1483} 1484 1485static DEVICE_ATTR(diagnostic, S_IRUGO, show_tabletDiagnosticMessage, NULL); 1486 1487/*********************************************************************** 1488 * support routines for the 'stylus_upper' file. Note that this file 1489 * both displays current setting and allows for setting changing. 1490 */ 1491static ssize_t show_tabletStylusUpper(struct device *dev, struct device_attribute *attr, char *buf) 1492{ 1493 struct aiptek *aiptek = dev_get_drvdata(dev); 1494 char *s; 1495 1496 if (aiptek == NULL) 1497 return 0; 1498 1499 switch (aiptek->curSetting.stylusButtonUpper) { 1500 case AIPTEK_STYLUS_UPPER_BUTTON: 1501 s = "upper"; 1502 break; 1503 1504 case AIPTEK_STYLUS_LOWER_BUTTON: 1505 s = "lower"; 1506 break; 1507 1508 default: 1509 s = "unknown"; 1510 break; 1511 } 1512 return snprintf(buf, PAGE_SIZE, "%s\n", s); 1513} 1514 1515static ssize_t 1516store_tabletStylusUpper(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1517{ 1518 struct aiptek *aiptek = dev_get_drvdata(dev); 1519 1520 if (aiptek == NULL) 1521 return 0; 1522 1523 if (strcmp(buf, "upper") == 0) { 1524 aiptek->newSetting.stylusButtonUpper = 1525 AIPTEK_STYLUS_UPPER_BUTTON; 1526 } else if (strcmp(buf, "lower") == 0) { 1527 aiptek->newSetting.stylusButtonUpper = 1528 AIPTEK_STYLUS_LOWER_BUTTON; 1529 } 1530 return count; 1531} 1532 1533static DEVICE_ATTR(stylus_upper, 1534 S_IRUGO | S_IWUGO, 1535 show_tabletStylusUpper, store_tabletStylusUpper); 1536 1537/*********************************************************************** 1538 * support routines for the 'stylus_lower' file. Note that this file 1539 * both displays current setting and allows for setting changing. 1540 */ 1541static ssize_t show_tabletStylusLower(struct device *dev, struct device_attribute *attr, char *buf) 1542{ 1543 struct aiptek *aiptek = dev_get_drvdata(dev); 1544 char *s; 1545 1546 if (aiptek == NULL) 1547 return 0; 1548 1549 switch (aiptek->curSetting.stylusButtonLower) { 1550 case AIPTEK_STYLUS_UPPER_BUTTON: 1551 s = "upper"; 1552 break; 1553 1554 case AIPTEK_STYLUS_LOWER_BUTTON: 1555 s = "lower"; 1556 break; 1557 1558 default: 1559 s = "unknown"; 1560 break; 1561 } 1562 return snprintf(buf, PAGE_SIZE, "%s\n", s); 1563} 1564 1565static ssize_t 1566store_tabletStylusLower(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1567{ 1568 struct aiptek *aiptek = dev_get_drvdata(dev); 1569 1570 if (aiptek == NULL) 1571 return 0; 1572 1573 if (strcmp(buf, "upper") == 0) { 1574 aiptek->newSetting.stylusButtonLower = 1575 AIPTEK_STYLUS_UPPER_BUTTON; 1576 } else if (strcmp(buf, "lower") == 0) { 1577 aiptek->newSetting.stylusButtonLower = 1578 AIPTEK_STYLUS_LOWER_BUTTON; 1579 } 1580 return count; 1581} 1582 1583static DEVICE_ATTR(stylus_lower, 1584 S_IRUGO | S_IWUGO, 1585 show_tabletStylusLower, store_tabletStylusLower); 1586 1587/*********************************************************************** 1588 * support routines for the 'mouse_left' file. Note that this file 1589 * both displays current setting and allows for setting changing. 1590 */ 1591static ssize_t show_tabletMouseLeft(struct device *dev, struct device_attribute *attr, char *buf) 1592{ 1593 struct aiptek *aiptek = dev_get_drvdata(dev); 1594 char *s; 1595 1596 if (aiptek == NULL) 1597 return 0; 1598 1599 switch (aiptek->curSetting.mouseButtonLeft) { 1600 case AIPTEK_MOUSE_LEFT_BUTTON: 1601 s = "left"; 1602 break; 1603 1604 case AIPTEK_MOUSE_MIDDLE_BUTTON: 1605 s = "middle"; 1606 break; 1607 1608 case AIPTEK_MOUSE_RIGHT_BUTTON: 1609 s = "right"; 1610 break; 1611 1612 default: 1613 s = "unknown"; 1614 break; 1615 } 1616 return snprintf(buf, PAGE_SIZE, "%s\n", s); 1617} 1618 1619static ssize_t 1620store_tabletMouseLeft(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1621{ 1622 struct aiptek *aiptek = dev_get_drvdata(dev); 1623 1624 if (aiptek == NULL) 1625 return 0; 1626 1627 if (strcmp(buf, "left") == 0) { 1628 aiptek->newSetting.mouseButtonLeft = AIPTEK_MOUSE_LEFT_BUTTON; 1629 } else if (strcmp(buf, "middle") == 0) { 1630 aiptek->newSetting.mouseButtonLeft = AIPTEK_MOUSE_MIDDLE_BUTTON; 1631 } else if (strcmp(buf, "right") == 0) { 1632 aiptek->newSetting.mouseButtonLeft = AIPTEK_MOUSE_RIGHT_BUTTON; 1633 } 1634 return count; 1635} 1636 1637static DEVICE_ATTR(mouse_left, 1638 S_IRUGO | S_IWUGO, 1639 show_tabletMouseLeft, store_tabletMouseLeft); 1640 1641/*********************************************************************** 1642 * support routines for the 'mouse_middle' file. Note that this file 1643 * both displays current setting and allows for setting changing. 1644 */ 1645static ssize_t show_tabletMouseMiddle(struct device *dev, struct device_attribute *attr, char *buf) 1646{ 1647 struct aiptek *aiptek = dev_get_drvdata(dev); 1648 char *s; 1649 1650 if (aiptek == NULL) 1651 return 0; 1652 1653 switch (aiptek->curSetting.mouseButtonMiddle) { 1654 case AIPTEK_MOUSE_LEFT_BUTTON: 1655 s = "left"; 1656 break; 1657 1658 case AIPTEK_MOUSE_MIDDLE_BUTTON: 1659 s = "middle"; 1660 break; 1661 1662 case AIPTEK_MOUSE_RIGHT_BUTTON: 1663 s = "right"; 1664 break; 1665 1666 default: 1667 s = "unknown"; 1668 break; 1669 } 1670 return snprintf(buf, PAGE_SIZE, "%s\n", s); 1671} 1672 1673static ssize_t 1674store_tabletMouseMiddle(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1675{ 1676 struct aiptek *aiptek = dev_get_drvdata(dev); 1677 1678 if (aiptek == NULL) 1679 return 0; 1680 1681 if (strcmp(buf, "left") == 0) { 1682 aiptek->newSetting.mouseButtonMiddle = AIPTEK_MOUSE_LEFT_BUTTON; 1683 } else if (strcmp(buf, "middle") == 0) { 1684 aiptek->newSetting.mouseButtonMiddle = 1685 AIPTEK_MOUSE_MIDDLE_BUTTON; 1686 } else if (strcmp(buf, "right") == 0) { 1687 aiptek->newSetting.mouseButtonMiddle = 1688 AIPTEK_MOUSE_RIGHT_BUTTON; 1689 } 1690 return count; 1691} 1692 1693static DEVICE_ATTR(mouse_middle, 1694 S_IRUGO | S_IWUGO, 1695 show_tabletMouseMiddle, store_tabletMouseMiddle); 1696 1697/*********************************************************************** 1698 * support routines for the 'mouse_right' file. Note that this file 1699 * both displays current setting and allows for setting changing. 1700 */ 1701static ssize_t show_tabletMouseRight(struct device *dev, struct device_attribute *attr, char *buf) 1702{ 1703 struct aiptek *aiptek = dev_get_drvdata(dev); 1704 char *s; 1705 1706 if (aiptek == NULL) 1707 return 0; 1708 1709 switch (aiptek->curSetting.mouseButtonRight) { 1710 case AIPTEK_MOUSE_LEFT_BUTTON: 1711 s = "left"; 1712 break; 1713 1714 case AIPTEK_MOUSE_MIDDLE_BUTTON: 1715 s = "middle"; 1716 break; 1717 1718 case AIPTEK_MOUSE_RIGHT_BUTTON: 1719 s = "right"; 1720 break; 1721 1722 default: 1723 s = "unknown"; 1724 break; 1725 } 1726 return snprintf(buf, PAGE_SIZE, "%s\n", s); 1727} 1728 1729static ssize_t 1730store_tabletMouseRight(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1731{ 1732 struct aiptek *aiptek = dev_get_drvdata(dev); 1733 1734 if (aiptek == NULL) 1735 return 0; 1736 1737 if (strcmp(buf, "left") == 0) { 1738 aiptek->newSetting.mouseButtonRight = AIPTEK_MOUSE_LEFT_BUTTON; 1739 } else if (strcmp(buf, "middle") == 0) { 1740 aiptek->newSetting.mouseButtonRight = 1741 AIPTEK_MOUSE_MIDDLE_BUTTON; 1742 } else if (strcmp(buf, "right") == 0) { 1743 aiptek->newSetting.mouseButtonRight = AIPTEK_MOUSE_RIGHT_BUTTON; 1744 } 1745 return count; 1746} 1747 1748static DEVICE_ATTR(mouse_right, 1749 S_IRUGO | S_IWUGO, 1750 show_tabletMouseRight, store_tabletMouseRight); 1751 1752/*********************************************************************** 1753 * support routines for the 'wheel' file. Note that this file 1754 * both displays current setting and allows for setting changing. 1755 */ 1756static ssize_t show_tabletWheel(struct device *dev, struct device_attribute *attr, char *buf) 1757{ 1758 struct aiptek *aiptek = dev_get_drvdata(dev); 1759 1760 if (aiptek == NULL) 1761 return 0; 1762 1763 if (aiptek->curSetting.wheel == AIPTEK_WHEEL_DISABLE) { 1764 return snprintf(buf, PAGE_SIZE, "disable\n"); 1765 } else { 1766 return snprintf(buf, PAGE_SIZE, "%d\n", 1767 aiptek->curSetting.wheel); 1768 } 1769} 1770 1771static ssize_t 1772store_tabletWheel(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1773{ 1774 struct aiptek *aiptek = dev_get_drvdata(dev); 1775 1776 if (aiptek == NULL) 1777 return 0; 1778 1779 aiptek->newSetting.wheel = (int)simple_strtol(buf, NULL, 10); 1780 return count; 1781} 1782 1783static DEVICE_ATTR(wheel, 1784 S_IRUGO | S_IWUGO, show_tabletWheel, store_tabletWheel); 1785 1786/*********************************************************************** 1787 * support routines for the 'execute' file. Note that this file 1788 * both displays current setting and allows for setting changing. 1789 */ 1790static ssize_t show_tabletExecute(struct device *dev, struct device_attribute *attr, char *buf) 1791{ 1792 struct aiptek *aiptek = dev_get_drvdata(dev); 1793 1794 if (aiptek == NULL) 1795 return 0; 1796 1797 /* There is nothing useful to display, so a one-line manual 1798 * is in order... 1799 */ 1800 return snprintf(buf, PAGE_SIZE, 1801 "Write anything to this file to program your tablet.\n"); 1802} 1803 1804static ssize_t 1805store_tabletExecute(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1806{ 1807 struct aiptek *aiptek = dev_get_drvdata(dev); 1808 1809 if (aiptek == NULL) 1810 return 0; 1811 1812 /* We do not care what you write to this file. Merely the action 1813 * of writing to this file triggers a tablet reprogramming. 1814 */ 1815 memcpy(&aiptek->curSetting, &aiptek->newSetting, 1816 sizeof(struct aiptek_settings)); 1817 1818 if (aiptek_program_tablet(aiptek) < 0) 1819 return -EIO; 1820 1821 return count; 1822} 1823 1824static DEVICE_ATTR(execute, 1825 S_IRUGO | S_IWUGO, show_tabletExecute, store_tabletExecute); 1826 1827/*********************************************************************** 1828 * support routines for the 'odm_code' file. Note that this file 1829 * only displays current setting. 1830 */ 1831static ssize_t show_tabletODMCode(struct device *dev, struct device_attribute *attr, char *buf) 1832{ 1833 struct aiptek *aiptek = dev_get_drvdata(dev); 1834 1835 if (aiptek == NULL) 1836 return 0; 1837 1838 return snprintf(buf, PAGE_SIZE, "0x%04x\n", aiptek->features.odmCode); 1839} 1840 1841static DEVICE_ATTR(odm_code, S_IRUGO, show_tabletODMCode, NULL); 1842 1843/*********************************************************************** 1844 * support routines for the 'model_code' file. Note that this file 1845 * only displays current setting. 1846 */ 1847static ssize_t show_tabletModelCode(struct device *dev, struct device_attribute *attr, char *buf) 1848{ 1849 struct aiptek *aiptek = dev_get_drvdata(dev); 1850 1851 if (aiptek == NULL) 1852 return 0; 1853 1854 return snprintf(buf, PAGE_SIZE, "0x%04x\n", aiptek->features.modelCode); 1855} 1856 1857static DEVICE_ATTR(model_code, S_IRUGO, show_tabletModelCode, NULL); 1858 1859/*********************************************************************** 1860 * support routines for the 'firmware_code' file. Note that this file 1861 * only displays current setting. 1862 */ 1863static ssize_t show_firmwareCode(struct device *dev, struct device_attribute *attr, char *buf) 1864{ 1865 struct aiptek *aiptek = dev_get_drvdata(dev); 1866 1867 if (aiptek == NULL) 1868 return 0; 1869 1870 return snprintf(buf, PAGE_SIZE, "%04x\n", 1871 aiptek->features.firmwareCode); 1872} 1873 1874static DEVICE_ATTR(firmware_code, S_IRUGO, show_firmwareCode, NULL); 1875 1876/*********************************************************************** 1877 * This routine removes all existing sysfs files managed by this device 1878 * driver. 1879 */ 1880static void aiptek_delete_files(struct device *dev) 1881{ 1882 device_remove_file(dev, &dev_attr_size); 1883 device_remove_file(dev, &dev_attr_product_id); 1884 device_remove_file(dev, &dev_attr_vendor_id); 1885 device_remove_file(dev, &dev_attr_vendor); 1886 device_remove_file(dev, &dev_attr_product); 1887 device_remove_file(dev, &dev_attr_pointer_mode); 1888 device_remove_file(dev, &dev_attr_coordinate_mode); 1889 device_remove_file(dev, &dev_attr_tool_mode); 1890 device_remove_file(dev, &dev_attr_xtilt); 1891 device_remove_file(dev, &dev_attr_ytilt); 1892 device_remove_file(dev, &dev_attr_jitter); 1893 device_remove_file(dev, &dev_attr_delay); 1894 device_remove_file(dev, &dev_attr_input_path); 1895 device_remove_file(dev, &dev_attr_event_count); 1896 device_remove_file(dev, &dev_attr_diagnostic); 1897 device_remove_file(dev, &dev_attr_odm_code); 1898 device_remove_file(dev, &dev_attr_model_code); 1899 device_remove_file(dev, &dev_attr_firmware_code); 1900 device_remove_file(dev, &dev_attr_stylus_lower); 1901 device_remove_file(dev, &dev_attr_stylus_upper); 1902 device_remove_file(dev, &dev_attr_mouse_left); 1903 device_remove_file(dev, &dev_attr_mouse_middle); 1904 device_remove_file(dev, &dev_attr_mouse_right); 1905 device_remove_file(dev, &dev_attr_wheel); 1906 device_remove_file(dev, &dev_attr_execute); 1907} 1908 1909/*********************************************************************** 1910 * This routine creates the sysfs files managed by this device 1911 * driver. 1912 */ 1913static int aiptek_add_files(struct device *dev) 1914{ 1915 int ret; 1916 1917 if ((ret = device_create_file(dev, &dev_attr_size)) || 1918 (ret = device_create_file(dev, &dev_attr_product_id)) || 1919 (ret = device_create_file(dev, &dev_attr_vendor_id)) || 1920 (ret = device_create_file(dev, &dev_attr_vendor)) || 1921 (ret = device_create_file(dev, &dev_attr_product)) || 1922 (ret = device_create_file(dev, &dev_attr_pointer_mode)) || 1923 (ret = device_create_file(dev, &dev_attr_coordinate_mode)) || 1924 (ret = device_create_file(dev, &dev_attr_tool_mode)) || 1925 (ret = device_create_file(dev, &dev_attr_xtilt)) || 1926 (ret = device_create_file(dev, &dev_attr_ytilt)) || 1927 (ret = device_create_file(dev, &dev_attr_jitter)) || 1928 (ret = device_create_file(dev, &dev_attr_delay)) || 1929 (ret = device_create_file(dev, &dev_attr_input_path)) || 1930 (ret = device_create_file(dev, &dev_attr_event_count)) || 1931 (ret = device_create_file(dev, &dev_attr_diagnostic)) || 1932 (ret = device_create_file(dev, &dev_attr_odm_code)) || 1933 (ret = device_create_file(dev, &dev_attr_model_code)) || 1934 (ret = device_create_file(dev, &dev_attr_firmware_code)) || 1935 (ret = device_create_file(dev, &dev_attr_stylus_lower)) || 1936 (ret = device_create_file(dev, &dev_attr_stylus_upper)) || 1937 (ret = device_create_file(dev, &dev_attr_mouse_left)) || 1938 (ret = device_create_file(dev, &dev_attr_mouse_middle)) || 1939 (ret = device_create_file(dev, &dev_attr_mouse_right)) || 1940 (ret = device_create_file(dev, &dev_attr_wheel)) || 1941 (ret = device_create_file(dev, &dev_attr_execute))) { 1942 err("aiptek: killing own sysfs device files\n"); 1943 aiptek_delete_files(dev); 1944 } 1945 return ret; 1946} 1947 1948/*********************************************************************** 1949 * This routine is called when a tablet has been identified. It basically 1950 * sets up the tablet and the driver's internal structures. 1951 */ 1952static int 1953aiptek_probe(struct usb_interface *intf, const struct usb_device_id *id) 1954{ 1955 struct usb_device *usbdev = interface_to_usbdev(intf); 1956 struct usb_endpoint_descriptor *endpoint; 1957 struct aiptek *aiptek; 1958 struct input_dev *inputdev; 1959 struct input_handle *inputhandle; 1960 struct list_head *node, *next; 1961 int i; 1962 int speeds[] = { 0, 1963 AIPTEK_PROGRAMMABLE_DELAY_50, 1964 AIPTEK_PROGRAMMABLE_DELAY_400, 1965 AIPTEK_PROGRAMMABLE_DELAY_25, 1966 AIPTEK_PROGRAMMABLE_DELAY_100, 1967 AIPTEK_PROGRAMMABLE_DELAY_200, 1968 AIPTEK_PROGRAMMABLE_DELAY_300 1969 }; 1970 int err = -ENOMEM; 1971 1972 /* programmableDelay is where the command-line specified 1973 * delay is kept. We make it the first element of speeds[], 1974 * so therefore, your override speed is tried first, then the 1975 * remainder. Note that the default value of 400ms will be tried 1976 * if you do not specify any command line parameter. 1977 */ 1978 speeds[0] = programmableDelay; 1979 1980 aiptek = kzalloc(sizeof(struct aiptek), GFP_KERNEL); 1981 inputdev = input_allocate_device(); 1982 if (!aiptek || !inputdev) 1983 goto fail1; 1984 1985 aiptek->data = usb_buffer_alloc(usbdev, AIPTEK_PACKET_LENGTH, 1986 GFP_ATOMIC, &aiptek->data_dma); 1987 if (!aiptek->data) 1988 goto fail1; 1989 1990 aiptek->urb = usb_alloc_urb(0, GFP_KERNEL); 1991 if (!aiptek->urb) 1992 goto fail2; 1993 1994 aiptek->inputdev = inputdev; 1995 aiptek->usbdev = usbdev; 1996 aiptek->ifnum = intf->altsetting[0].desc.bInterfaceNumber; 1997 aiptek->inDelay = 0; 1998 aiptek->endDelay = 0; 1999 aiptek->previousJitterable = 0; 2000 2001 /* Set up the curSettings struct. Said struct contains the current 2002 * programmable parameters. The newSetting struct contains changes 2003 * the user makes to the settings via the sysfs interface. Those 2004 * changes are not "committed" to curSettings until the user 2005 * writes to the sysfs/.../execute file. 2006 */ 2007 aiptek->curSetting.pointerMode = AIPTEK_POINTER_EITHER_MODE; 2008 aiptek->curSetting.coordinateMode = AIPTEK_COORDINATE_ABSOLUTE_MODE; 2009 aiptek->curSetting.toolMode = AIPTEK_TOOL_BUTTON_PEN_MODE; 2010 aiptek->curSetting.xTilt = AIPTEK_TILT_DISABLE; 2011 aiptek->curSetting.yTilt = AIPTEK_TILT_DISABLE; 2012 aiptek->curSetting.mouseButtonLeft = AIPTEK_MOUSE_LEFT_BUTTON; 2013 aiptek->curSetting.mouseButtonMiddle = AIPTEK_MOUSE_MIDDLE_BUTTON; 2014 aiptek->curSetting.mouseButtonRight = AIPTEK_MOUSE_RIGHT_BUTTON; 2015 aiptek->curSetting.stylusButtonUpper = AIPTEK_STYLUS_UPPER_BUTTON; 2016 aiptek->curSetting.stylusButtonLower = AIPTEK_STYLUS_LOWER_BUTTON; 2017 aiptek->curSetting.jitterDelay = jitterDelay; 2018 aiptek->curSetting.programmableDelay = programmableDelay; 2019 2020 /* Both structs should have equivalent settings 2021 */ 2022 aiptek->newSetting = aiptek->curSetting; 2023 2024 /* Determine the usb devices' physical path. 2025 * Asketh not why we always pretend we're using "../input0", 2026 * but I suspect this will have to be refactored one 2027 * day if a single USB device can be a keyboard & a mouse 2028 * & a tablet, and the inputX number actually will tell 2029 * us something... 2030 */ 2031 usb_make_path(usbdev, aiptek->features.usbPath, 2032 sizeof(aiptek->features.usbPath)); 2033 strlcat(aiptek->features.usbPath, "/input0", 2034 sizeof(aiptek->features.usbPath)); 2035 2036 /* Set up client data, pointers to open and close routines 2037 * for the input device. 2038 */ 2039 inputdev->name = "Aiptek"; 2040 inputdev->phys = aiptek->features.usbPath; 2041 usb_to_input_id(usbdev, &inputdev->id); 2042 inputdev->dev.parent = &intf->dev; 2043 2044 input_set_drvdata(inputdev, aiptek); 2045 2046 inputdev->open = aiptek_open; 2047 inputdev->close = aiptek_close; 2048 2049 /* Now program the capacities of the tablet, in terms of being 2050 * an input device. 2051 */ 2052 inputdev->evbit[0] |= BIT(EV_KEY) 2053 | BIT(EV_ABS) 2054 | BIT(EV_REL) 2055 | BIT(EV_MSC); 2056 2057 inputdev->absbit[0] |= BIT(ABS_MISC); 2058 2059 inputdev->relbit[0] |= 2060 (BIT(REL_X) | BIT(REL_Y) | BIT(REL_WHEEL) | BIT(REL_MISC)); 2061 2062 inputdev->keybit[LONG(BTN_LEFT)] |= 2063 (BIT(BTN_LEFT) | BIT(BTN_RIGHT) | BIT(BTN_MIDDLE)); 2064 2065 inputdev->keybit[LONG(BTN_DIGI)] |= 2066 (BIT(BTN_TOOL_PEN) | 2067 BIT(BTN_TOOL_RUBBER) | 2068 BIT(BTN_TOOL_PENCIL) | 2069 BIT(BTN_TOOL_AIRBRUSH) | 2070 BIT(BTN_TOOL_BRUSH) | 2071 BIT(BTN_TOOL_MOUSE) | 2072 BIT(BTN_TOOL_LENS) | 2073 BIT(BTN_TOUCH) | BIT(BTN_STYLUS) | BIT(BTN_STYLUS2)); 2074 2075 inputdev->mscbit[0] = BIT(MSC_SERIAL); 2076 2077 /* Programming the tablet macro keys needs to be done with a for loop 2078 * as the keycodes are discontiguous. 2079 */ 2080 for (i = 0; i < ARRAY_SIZE(macroKeyEvents); ++i) 2081 set_bit(macroKeyEvents[i], inputdev->keybit); 2082 2083 /* 2084 * Program the input device coordinate capacities. We do not yet 2085 * know what maximum X, Y, and Z values are, so we're putting fake 2086 * values in. Later, we'll ask the tablet to put in the correct 2087 * values. 2088 */ 2089 input_set_abs_params(inputdev, ABS_X, 0, 2999, 0, 0); 2090 input_set_abs_params(inputdev, ABS_Y, 0, 2249, 0, 0); 2091 input_set_abs_params(inputdev, ABS_PRESSURE, 0, 511, 0, 0); 2092 input_set_abs_params(inputdev, ABS_TILT_X, AIPTEK_TILT_MIN, AIPTEK_TILT_MAX, 0, 0); 2093 input_set_abs_params(inputdev, ABS_TILT_Y, AIPTEK_TILT_MIN, AIPTEK_TILT_MAX, 0, 0); 2094 input_set_abs_params(inputdev, ABS_WHEEL, AIPTEK_WHEEL_MIN, AIPTEK_WHEEL_MAX - 1, 0, 0); 2095 2096 endpoint = &intf->altsetting[0].endpoint[0].desc; 2097 2098 /* Go set up our URB, which is called when the tablet receives 2099 * input. 2100 */ 2101 usb_fill_int_urb(aiptek->urb, 2102 aiptek->usbdev, 2103 usb_rcvintpipe(aiptek->usbdev, 2104 endpoint->bEndpointAddress), 2105 aiptek->data, 8, aiptek_irq, aiptek, 2106 endpoint->bInterval); 2107 2108 aiptek->urb->transfer_dma = aiptek->data_dma; 2109 aiptek->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 2110 2111 /* Program the tablet. This sets the tablet up in the mode 2112 * specified in newSetting, and also queries the tablet's 2113 * physical capacities. 2114 * 2115 * Sanity check: if a tablet doesn't like the slow programmatic 2116 * delay, we often get sizes of 0x0. Let's use that as an indicator 2117 * to try faster delays, up to 25 ms. If that logic fails, well, you'll 2118 * have to explain to us how your tablet thinks it's 0x0, and yet that's 2119 * not an error :-) 2120 */ 2121 2122 for (i = 0; i < ARRAY_SIZE(speeds); ++i) { 2123 aiptek->curSetting.programmableDelay = speeds[i]; 2124 (void)aiptek_program_tablet(aiptek); 2125 if (aiptek->inputdev->absmax[ABS_X] > 0) { 2126 info("input: Aiptek using %d ms programming speed\n", 2127 aiptek->curSetting.programmableDelay); 2128 break; 2129 } 2130 } 2131 2132 /* Register the tablet as an Input Device 2133 */ 2134 err = input_register_device(aiptek->inputdev); 2135 if (err) 2136 goto fail2; 2137 2138 /* We now will look for the evdev device which is mapped to 2139 * the tablet. The partial name is kept in the link list of 2140 * input_handles associated with this input device. 2141 * What identifies an evdev input_handler is that it begins 2142 * with 'event', continues with a digit, and that in turn 2143 * is mapped to input/eventN. 2144 */ 2145 list_for_each_safe(node, next, &inputdev->h_list) { 2146 inputhandle = to_handle(node); 2147 if (strncmp(inputhandle->name, "event", 5) == 0) { 2148 strcpy(aiptek->features.inputPath, inputhandle->name); 2149 break; 2150 } 2151 } 2152 2153 /* Associate this driver's struct with the usb interface. 2154 */ 2155 usb_set_intfdata(intf, aiptek); 2156 2157 /* Set up the sysfs files 2158 */ 2159 aiptek_add_files(&intf->dev); 2160 2161 /* Make sure the evdev module is loaded. Assuming evdev IS a module :-) 2162 */ 2163 if (request_module("evdev") != 0) 2164 info("aiptek: error loading 'evdev' module"); 2165 2166 return 0; 2167 2168 fail2: usb_buffer_free(usbdev, AIPTEK_PACKET_LENGTH, aiptek->data, 2169 aiptek->data_dma); 2170 fail1: input_free_device(inputdev); 2171 kfree(aiptek); 2172 return err; 2173} 2174 2175/*********************************************************************** 2176 * Deal with tablet disconnecting from the system. 2177 */ 2178static void aiptek_disconnect(struct usb_interface *intf) 2179{ 2180 struct aiptek *aiptek = usb_get_intfdata(intf); 2181 2182 /* Disassociate driver's struct with usb interface 2183 */ 2184 usb_set_intfdata(intf, NULL); 2185 if (aiptek != NULL) { 2186 /* Free & unhook everything from the system. 2187 */ 2188 usb_kill_urb(aiptek->urb); 2189 input_unregister_device(aiptek->inputdev); 2190 aiptek_delete_files(&intf->dev); 2191 usb_free_urb(aiptek->urb); 2192 usb_buffer_free(interface_to_usbdev(intf), 2193 AIPTEK_PACKET_LENGTH, 2194 aiptek->data, aiptek->data_dma); 2195 kfree(aiptek); 2196 } 2197} 2198 2199static struct usb_driver aiptek_driver = { 2200 .name = "aiptek", 2201 .probe = aiptek_probe, 2202 .disconnect = aiptek_disconnect, 2203 .id_table = aiptek_ids, 2204}; 2205 2206static int __init aiptek_init(void) 2207{ 2208 int result = usb_register(&aiptek_driver); 2209 if (result == 0) { 2210 info(DRIVER_VERSION ": " DRIVER_AUTHOR); 2211 info(DRIVER_DESC); 2212 } 2213 return result; 2214} 2215 2216static void __exit aiptek_exit(void) 2217{ 2218 usb_deregister(&aiptek_driver); 2219} 2220 2221MODULE_AUTHOR(DRIVER_AUTHOR); 2222MODULE_DESCRIPTION(DRIVER_DESC); 2223MODULE_LICENSE("GPL"); 2224 2225module_param(programmableDelay, int, 0); 2226MODULE_PARM_DESC(programmableDelay, "delay used during tablet programming"); 2227module_param(jitterDelay, int, 0); 2228MODULE_PARM_DESC(jitterDelay, "stylus/mouse settlement delay"); 2229 2230module_init(aiptek_init); 2231module_exit(aiptek_exit); 2232