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