PageRenderTime 63ms CodeModel.GetById 12ms app.highlight 43ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/input/tablet/gtco.c

http://github.com/mirrors/linux
C | 1043 lines | 625 code | 188 blank | 230 comment | 88 complexity | f938252a3370267fe227ef52b84e87b5 MD5 | raw file
   1/*    -*- linux-c -*-
   2
   3GTCO digitizer USB driver
   4
   5TO CHECK:  Is pressure done right on report 5?
   6
   7Copyright (C) 2006  GTCO CalComp
   8
   9This program is free software; you can redistribute it and/or
  10modify it under the terms of the GNU General Public License
  11as published by the Free Software Foundation; version 2
  12of the License.
  13
  14This program is distributed in the hope that it will be useful,
  15but WITHOUT ANY WARRANTY; without even the implied warranty of
  16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17GNU General Public License for more details.
  18
  19You should have received a copy of the GNU General Public License
  20along with this program; if not, write to the Free Software
  21Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  22
  23Permission to use, copy, modify, distribute, and sell this software and its
  24documentation for any purpose is hereby granted without fee, provided that
  25the above copyright notice appear in all copies and that both that
  26copyright notice and this permission notice appear in supporting
  27documentation, and that the name of GTCO-CalComp not be used in advertising
  28or publicity pertaining to distribution of the software without specific,
  29written prior permission. GTCO-CalComp makes no representations about the
  30suitability of this software for any purpose.  It is provided "as is"
  31without express or implied warranty.
  32
  33GTCO-CALCOMP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  34INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  35EVENT SHALL GTCO-CALCOMP BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  36CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  37DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  38TORTIOUS ACTIONS, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  39PERFORMANCE OF THIS SOFTWARE.
  40
  41GTCO CalComp, Inc.
  427125 Riverwood Drive
  43Columbia, MD 21046
  44
  45Jeremy Roberson jroberson@gtcocalcomp.com
  46Scott Hill shill@gtcocalcomp.com
  47*/
  48
  49
  50
  51/*#define DEBUG*/
  52
  53#include <linux/kernel.h>
  54#include <linux/module.h>
  55#include <linux/errno.h>
  56#include <linux/slab.h>
  57#include <linux/input.h>
  58#include <linux/usb.h>
  59#include <linux/uaccess.h>
  60#include <asm/unaligned.h>
  61#include <asm/byteorder.h>
  62#include <linux/bitops.h>
  63
  64#include <linux/usb/input.h>
  65
  66/* Version with a Major number of 2 is for kernel inclusion only. */
  67#define  GTCO_VERSION   "2.00.0006"
  68
  69
  70/*   MACROS  */
  71
  72#define VENDOR_ID_GTCO	      0x078C
  73#define PID_400               0x400
  74#define PID_401               0x401
  75#define PID_1000              0x1000
  76#define PID_1001              0x1001
  77#define PID_1002              0x1002
  78
  79/* Max size of a single report */
  80#define REPORT_MAX_SIZE       10
  81#define MAX_COLLECTION_LEVELS  10
  82
  83
  84/* Bitmask whether pen is in range */
  85#define MASK_INRANGE 0x20
  86#define MASK_BUTTON  0x01F
  87
  88#define  PATHLENGTH     64
  89
  90/* DATA STRUCTURES */
  91
  92/* Device table */
  93static const struct usb_device_id gtco_usbid_table[] = {
  94	{ USB_DEVICE(VENDOR_ID_GTCO, PID_400) },
  95	{ USB_DEVICE(VENDOR_ID_GTCO, PID_401) },
  96	{ USB_DEVICE(VENDOR_ID_GTCO, PID_1000) },
  97	{ USB_DEVICE(VENDOR_ID_GTCO, PID_1001) },
  98	{ USB_DEVICE(VENDOR_ID_GTCO, PID_1002) },
  99	{ }
 100};
 101MODULE_DEVICE_TABLE (usb, gtco_usbid_table);
 102
 103
 104/* Structure to hold all of our device specific stuff */
 105struct gtco {
 106
 107	struct input_dev  *inputdevice; /* input device struct pointer  */
 108	struct usb_interface *intf;	/* the usb interface for this device */
 109	struct urb        *urbinfo;	 /* urb for incoming reports      */
 110	dma_addr_t        buf_dma;  /* dma addr of the data buffer*/
 111	unsigned char *   buffer;   /* databuffer for reports */
 112
 113	char  usbpath[PATHLENGTH];
 114	int   openCount;
 115
 116	/* Information pulled from Report Descriptor */
 117	u32  usage;
 118	u32  min_X;
 119	u32  max_X;
 120	u32  min_Y;
 121	u32  max_Y;
 122	s8   mintilt_X;
 123	s8   maxtilt_X;
 124	s8   mintilt_Y;
 125	s8   maxtilt_Y;
 126	u32  maxpressure;
 127	u32  minpressure;
 128};
 129
 130
 131
 132/*   Code for parsing the HID REPORT DESCRIPTOR          */
 133
 134/* From HID1.11 spec */
 135struct hid_descriptor
 136{
 137	struct usb_descriptor_header header;
 138	__le16   bcdHID;
 139	u8       bCountryCode;
 140	u8       bNumDescriptors;
 141	u8       bDescriptorType;
 142	__le16   wDescriptorLength;
 143} __attribute__ ((packed));
 144
 145
 146#define HID_DESCRIPTOR_SIZE   9
 147#define HID_DEVICE_TYPE       33
 148#define REPORT_DEVICE_TYPE    34
 149
 150
 151#define PREF_TAG(x)     ((x)>>4)
 152#define PREF_TYPE(x)    ((x>>2)&0x03)
 153#define PREF_SIZE(x)    ((x)&0x03)
 154
 155#define TYPE_MAIN       0
 156#define TYPE_GLOBAL     1
 157#define TYPE_LOCAL      2
 158#define TYPE_RESERVED   3
 159
 160#define TAG_MAIN_INPUT        0x8
 161#define TAG_MAIN_OUTPUT       0x9
 162#define TAG_MAIN_FEATURE      0xB
 163#define TAG_MAIN_COL_START    0xA
 164#define TAG_MAIN_COL_END      0xC
 165
 166#define TAG_GLOB_USAGE        0
 167#define TAG_GLOB_LOG_MIN      1
 168#define TAG_GLOB_LOG_MAX      2
 169#define TAG_GLOB_PHYS_MIN     3
 170#define TAG_GLOB_PHYS_MAX     4
 171#define TAG_GLOB_UNIT_EXP     5
 172#define TAG_GLOB_UNIT         6
 173#define TAG_GLOB_REPORT_SZ    7
 174#define TAG_GLOB_REPORT_ID    8
 175#define TAG_GLOB_REPORT_CNT   9
 176#define TAG_GLOB_PUSH         10
 177#define TAG_GLOB_POP          11
 178
 179#define TAG_GLOB_MAX          12
 180
 181#define DIGITIZER_USAGE_TIP_PRESSURE   0x30
 182#define DIGITIZER_USAGE_TILT_X         0x3D
 183#define DIGITIZER_USAGE_TILT_Y         0x3E
 184
 185
 186/*
 187 *   This is an abbreviated parser for the HID Report Descriptor.  We
 188 *   know what devices we are talking to, so this is by no means meant
 189 *   to be generic.  We can make some safe assumptions:
 190 *
 191 *   - We know there are no LONG tags, all short
 192 *   - We know that we have no MAIN Feature and MAIN Output items
 193 *   - We know what the IRQ reports are supposed to look like.
 194 *
 195 *   The main purpose of this is to use the HID report desc to figure
 196 *   out the mins and maxs of the fields in the IRQ reports.  The IRQ
 197 *   reports for 400/401 change slightly if the max X is bigger than 64K.
 198 *
 199 */
 200static void parse_hid_report_descriptor(struct gtco *device, char * report,
 201					int length)
 202{
 203	struct device *ddev = &device->intf->dev;
 204	int   x, i = 0;
 205
 206	/* Tag primitive vars */
 207	__u8   prefix;
 208	__u8   size;
 209	__u8   tag;
 210	__u8   type;
 211	__u8   data   = 0;
 212	__u16  data16 = 0;
 213	__u32  data32 = 0;
 214
 215	/* For parsing logic */
 216	int   inputnum = 0;
 217	__u32 usage = 0;
 218
 219	/* Global Values, indexed by TAG */
 220	__u32 globalval[TAG_GLOB_MAX];
 221	__u32 oldval[TAG_GLOB_MAX];
 222
 223	/* Debug stuff */
 224	char  maintype = 'x';
 225	char  globtype[12];
 226	int   indent = 0;
 227	char  indentstr[MAX_COLLECTION_LEVELS + 1] = { 0 };
 228
 229	dev_dbg(ddev, "======>>>>>>PARSE<<<<<<======\n");
 230
 231	/* Walk  this report and pull out the info we need */
 232	while (i < length) {
 233		prefix = report[i++];
 234
 235		/* Determine data size and save the data in the proper variable */
 236		size = (1U << PREF_SIZE(prefix)) >> 1;
 237		if (i + size > length) {
 238			dev_err(ddev,
 239				"Not enough data (need %d, have %d)\n",
 240				i + size, length);
 241			break;
 242		}
 243
 244		switch (size) {
 245		case 1:
 246			data = report[i];
 247			break;
 248		case 2:
 249			data16 = get_unaligned_le16(&report[i]);
 250			break;
 251		case 4:
 252			data32 = get_unaligned_le32(&report[i]);
 253			break;
 254		}
 255
 256		/* Skip size of data */
 257		i += size;
 258
 259		/* What we do depends on the tag type */
 260		tag  = PREF_TAG(prefix);
 261		type = PREF_TYPE(prefix);
 262		switch (type) {
 263		case TYPE_MAIN:
 264			strcpy(globtype, "");
 265			switch (tag) {
 266
 267			case TAG_MAIN_INPUT:
 268				/*
 269				 * The INPUT MAIN tag signifies this is
 270				 * information from a report.  We need to
 271				 * figure out what it is and store the
 272				 * min/max values
 273				 */
 274
 275				maintype = 'I';
 276				if (data == 2)
 277					strcpy(globtype, "Variable");
 278				else if (data == 3)
 279					strcpy(globtype, "Var|Const");
 280
 281				dev_dbg(ddev, "::::: Saving Report: %d input #%d Max: 0x%X(%d) Min:0x%X(%d) of %d bits\n",
 282					globalval[TAG_GLOB_REPORT_ID], inputnum,
 283					globalval[TAG_GLOB_LOG_MAX], globalval[TAG_GLOB_LOG_MAX],
 284					globalval[TAG_GLOB_LOG_MIN], globalval[TAG_GLOB_LOG_MIN],
 285					globalval[TAG_GLOB_REPORT_SZ] * globalval[TAG_GLOB_REPORT_CNT]);
 286
 287
 288				/*
 289				  We can assume that the first two input items
 290				  are always the X and Y coordinates.  After
 291				  that, we look for everything else by
 292				  local usage value
 293				 */
 294				switch (inputnum) {
 295				case 0:  /* X coord */
 296					dev_dbg(ddev, "GER: X Usage: 0x%x\n", usage);
 297					if (device->max_X == 0) {
 298						device->max_X = globalval[TAG_GLOB_LOG_MAX];
 299						device->min_X = globalval[TAG_GLOB_LOG_MIN];
 300					}
 301					break;
 302
 303				case 1:  /* Y coord */
 304					dev_dbg(ddev, "GER: Y Usage: 0x%x\n", usage);
 305					if (device->max_Y == 0) {
 306						device->max_Y = globalval[TAG_GLOB_LOG_MAX];
 307						device->min_Y = globalval[TAG_GLOB_LOG_MIN];
 308					}
 309					break;
 310
 311				default:
 312					/* Tilt X */
 313					if (usage == DIGITIZER_USAGE_TILT_X) {
 314						if (device->maxtilt_X == 0) {
 315							device->maxtilt_X = globalval[TAG_GLOB_LOG_MAX];
 316							device->mintilt_X = globalval[TAG_GLOB_LOG_MIN];
 317						}
 318					}
 319
 320					/* Tilt Y */
 321					if (usage == DIGITIZER_USAGE_TILT_Y) {
 322						if (device->maxtilt_Y == 0) {
 323							device->maxtilt_Y = globalval[TAG_GLOB_LOG_MAX];
 324							device->mintilt_Y = globalval[TAG_GLOB_LOG_MIN];
 325						}
 326					}
 327
 328					/* Pressure */
 329					if (usage == DIGITIZER_USAGE_TIP_PRESSURE) {
 330						if (device->maxpressure == 0) {
 331							device->maxpressure = globalval[TAG_GLOB_LOG_MAX];
 332							device->minpressure = globalval[TAG_GLOB_LOG_MIN];
 333						}
 334					}
 335
 336					break;
 337				}
 338
 339				inputnum++;
 340				break;
 341
 342			case TAG_MAIN_OUTPUT:
 343				maintype = 'O';
 344				break;
 345
 346			case TAG_MAIN_FEATURE:
 347				maintype = 'F';
 348				break;
 349
 350			case TAG_MAIN_COL_START:
 351				maintype = 'S';
 352
 353				if (indent == MAX_COLLECTION_LEVELS) {
 354					dev_err(ddev, "Collection level %d would exceed limit of %d\n",
 355						indent + 1,
 356						MAX_COLLECTION_LEVELS);
 357					break;
 358				}
 359
 360				if (data == 0) {
 361					dev_dbg(ddev, "======>>>>>> Physical\n");
 362					strcpy(globtype, "Physical");
 363				} else
 364					dev_dbg(ddev, "======>>>>>>\n");
 365
 366				/* Indent the debug output */
 367				indent++;
 368				for (x = 0; x < indent; x++)
 369					indentstr[x] = '-';
 370				indentstr[x] = 0;
 371
 372				/* Save global tags */
 373				for (x = 0; x < TAG_GLOB_MAX; x++)
 374					oldval[x] = globalval[x];
 375
 376				break;
 377
 378			case TAG_MAIN_COL_END:
 379				maintype = 'E';
 380
 381				if (indent == 0) {
 382					dev_err(ddev, "Collection level already at zero\n");
 383					break;
 384				}
 385
 386				dev_dbg(ddev, "<<<<<<======\n");
 387
 388				indent--;
 389				for (x = 0; x < indent; x++)
 390					indentstr[x] = '-';
 391				indentstr[x] = 0;
 392
 393				/* Copy global tags back */
 394				for (x = 0; x < TAG_GLOB_MAX; x++)
 395					globalval[x] = oldval[x];
 396
 397				break;
 398			}
 399
 400			switch (size) {
 401			case 1:
 402				dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
 403					indentstr, tag, maintype, size, globtype, data);
 404				break;
 405
 406			case 2:
 407				dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
 408					indentstr, tag, maintype, size, globtype, data16);
 409				break;
 410
 411			case 4:
 412				dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
 413					indentstr, tag, maintype, size, globtype, data32);
 414				break;
 415			}
 416			break;
 417
 418		case TYPE_GLOBAL:
 419			switch (tag) {
 420			case TAG_GLOB_USAGE:
 421				/*
 422				 * First time we hit the global usage tag,
 423				 * it should tell us the type of device
 424				 */
 425				if (device->usage == 0)
 426					device->usage = data;
 427
 428				strcpy(globtype, "USAGE");
 429				break;
 430
 431			case TAG_GLOB_LOG_MIN:
 432				strcpy(globtype, "LOG_MIN");
 433				break;
 434
 435			case TAG_GLOB_LOG_MAX:
 436				strcpy(globtype, "LOG_MAX");
 437				break;
 438
 439			case TAG_GLOB_PHYS_MIN:
 440				strcpy(globtype, "PHYS_MIN");
 441				break;
 442
 443			case TAG_GLOB_PHYS_MAX:
 444				strcpy(globtype, "PHYS_MAX");
 445				break;
 446
 447			case TAG_GLOB_UNIT_EXP:
 448				strcpy(globtype, "EXP");
 449				break;
 450
 451			case TAG_GLOB_UNIT:
 452				strcpy(globtype, "UNIT");
 453				break;
 454
 455			case TAG_GLOB_REPORT_SZ:
 456				strcpy(globtype, "REPORT_SZ");
 457				break;
 458
 459			case TAG_GLOB_REPORT_ID:
 460				strcpy(globtype, "REPORT_ID");
 461				/* New report, restart numbering */
 462				inputnum = 0;
 463				break;
 464
 465			case TAG_GLOB_REPORT_CNT:
 466				strcpy(globtype, "REPORT_CNT");
 467				break;
 468
 469			case TAG_GLOB_PUSH:
 470				strcpy(globtype, "PUSH");
 471				break;
 472
 473			case TAG_GLOB_POP:
 474				strcpy(globtype, "POP");
 475				break;
 476			}
 477
 478			/* Check to make sure we have a good tag number
 479			   so we don't overflow array */
 480			if (tag < TAG_GLOB_MAX) {
 481				switch (size) {
 482				case 1:
 483					dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
 484						indentstr, globtype, tag, size, data);
 485					globalval[tag] = data;
 486					break;
 487
 488				case 2:
 489					dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
 490						indentstr, globtype, tag, size, data16);
 491					globalval[tag] = data16;
 492					break;
 493
 494				case 4:
 495					dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
 496						indentstr, globtype, tag, size, data32);
 497					globalval[tag] = data32;
 498					break;
 499				}
 500			} else {
 501				dev_dbg(ddev, "%sGLOBALTAG: ILLEGAL TAG:%d SIZE: %d\n",
 502					indentstr, tag, size);
 503			}
 504			break;
 505
 506		case TYPE_LOCAL:
 507			switch (tag) {
 508			case TAG_GLOB_USAGE:
 509				strcpy(globtype, "USAGE");
 510				/* Always 1 byte */
 511				usage = data;
 512				break;
 513
 514			case TAG_GLOB_LOG_MIN:
 515				strcpy(globtype, "MIN");
 516				break;
 517
 518			case TAG_GLOB_LOG_MAX:
 519				strcpy(globtype, "MAX");
 520				break;
 521
 522			default:
 523				strcpy(globtype, "UNKNOWN");
 524				break;
 525			}
 526
 527			switch (size) {
 528			case 1:
 529				dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
 530					indentstr, tag, globtype, size, data);
 531				break;
 532
 533			case 2:
 534				dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
 535					indentstr, tag, globtype, size, data16);
 536				break;
 537
 538			case 4:
 539				dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
 540					indentstr, tag, globtype, size, data32);
 541				break;
 542			}
 543
 544			break;
 545		}
 546	}
 547}
 548
 549/*   INPUT DRIVER Routines                               */
 550
 551/*
 552 * Called when opening the input device.  This will submit the URB to
 553 * the usb system so we start getting reports
 554 */
 555static int gtco_input_open(struct input_dev *inputdev)
 556{
 557	struct gtco *device = input_get_drvdata(inputdev);
 558
 559	device->urbinfo->dev = interface_to_usbdev(device->intf);
 560	if (usb_submit_urb(device->urbinfo, GFP_KERNEL))
 561		return -EIO;
 562
 563	return 0;
 564}
 565
 566/*
 567 * Called when closing the input device.  This will unlink the URB
 568 */
 569static void gtco_input_close(struct input_dev *inputdev)
 570{
 571	struct gtco *device = input_get_drvdata(inputdev);
 572
 573	usb_kill_urb(device->urbinfo);
 574}
 575
 576
 577/*
 578 *  Setup input device capabilities.  Tell the input system what this
 579 *  device is capable of generating.
 580 *
 581 *  This information is based on what is read from the HID report and
 582 *  placed in the struct gtco structure
 583 *
 584 */
 585static void gtco_setup_caps(struct input_dev *inputdev)
 586{
 587	struct gtco *device = input_get_drvdata(inputdev);
 588
 589	/* Which events */
 590	inputdev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) |
 591		BIT_MASK(EV_MSC);
 592
 593	/* Misc event menu block */
 594	inputdev->mscbit[0] = BIT_MASK(MSC_SCAN) | BIT_MASK(MSC_SERIAL) |
 595		BIT_MASK(MSC_RAW);
 596
 597	/* Absolute values based on HID report info */
 598	input_set_abs_params(inputdev, ABS_X, device->min_X, device->max_X,
 599			     0, 0);
 600	input_set_abs_params(inputdev, ABS_Y, device->min_Y, device->max_Y,
 601			     0, 0);
 602
 603	/* Proximity */
 604	input_set_abs_params(inputdev, ABS_DISTANCE, 0, 1, 0, 0);
 605
 606	/* Tilt & pressure */
 607	input_set_abs_params(inputdev, ABS_TILT_X, device->mintilt_X,
 608			     device->maxtilt_X, 0, 0);
 609	input_set_abs_params(inputdev, ABS_TILT_Y, device->mintilt_Y,
 610			     device->maxtilt_Y, 0, 0);
 611	input_set_abs_params(inputdev, ABS_PRESSURE, device->minpressure,
 612			     device->maxpressure, 0, 0);
 613
 614	/* Transducer */
 615	input_set_abs_params(inputdev, ABS_MISC, 0, 0xFF, 0, 0);
 616}
 617
 618/*   USB Routines  */
 619
 620/*
 621 * URB callback routine.  Called when we get IRQ reports from the
 622 *  digitizer.
 623 *
 624 *  This bridges the USB and input device worlds.  It generates events
 625 *  on the input device based on the USB reports.
 626 */
 627static void gtco_urb_callback(struct urb *urbinfo)
 628{
 629	struct gtco *device = urbinfo->context;
 630	struct input_dev  *inputdev;
 631	int               rc;
 632	u32               val = 0;
 633	char              le_buffer[2];
 634
 635	inputdev = device->inputdevice;
 636
 637	/* Was callback OK? */
 638	if (urbinfo->status == -ECONNRESET ||
 639	    urbinfo->status == -ENOENT ||
 640	    urbinfo->status == -ESHUTDOWN) {
 641
 642		/* Shutdown is occurring. Return and don't queue up any more */
 643		return;
 644	}
 645
 646	if (urbinfo->status != 0) {
 647		/*
 648		 * Some unknown error.  Hopefully temporary. Just go and
 649		 * requeue an URB
 650		 */
 651		goto resubmit;
 652	}
 653
 654	/*
 655	 * Good URB, now process
 656	 */
 657
 658	/* PID dependent when we interpret the report */
 659	if (inputdev->id.product == PID_1000 ||
 660	    inputdev->id.product == PID_1001 ||
 661	    inputdev->id.product == PID_1002) {
 662
 663		/*
 664		 * Switch on the report ID
 665		 * Conveniently, the reports have more information, the higher
 666		 * the report number.  We can just fall through the case
 667		 * statements if we start with the highest number report
 668		 */
 669		switch (device->buffer[0]) {
 670		case 5:
 671			/* Pressure is 9 bits */
 672			val = ((u16)(device->buffer[8]) << 1);
 673			val |= (u16)(device->buffer[7] >> 7);
 674			input_report_abs(inputdev, ABS_PRESSURE,
 675					 device->buffer[8]);
 676
 677			/* Mask out the Y tilt value used for pressure */
 678			device->buffer[7] = (u8)((device->buffer[7]) & 0x7F);
 679
 680			/* Fall thru */
 681		case 4:
 682			/* Tilt */
 683			input_report_abs(inputdev, ABS_TILT_X,
 684					 sign_extend32(device->buffer[6], 6));
 685
 686			input_report_abs(inputdev, ABS_TILT_Y,
 687					 sign_extend32(device->buffer[7], 6));
 688
 689			/* Fall thru */
 690		case 2:
 691		case 3:
 692			/* Convert buttons, only 5 bits possible */
 693			val = (device->buffer[5]) & MASK_BUTTON;
 694
 695			/* We don't apply any meaning to the bitmask,
 696			   just report */
 697			input_event(inputdev, EV_MSC, MSC_SERIAL, val);
 698
 699			/*  Fall thru */
 700		case 1:
 701			/* All reports have X and Y coords in the same place */
 702			val = get_unaligned_le16(&device->buffer[1]);
 703			input_report_abs(inputdev, ABS_X, val);
 704
 705			val = get_unaligned_le16(&device->buffer[3]);
 706			input_report_abs(inputdev, ABS_Y, val);
 707
 708			/* Ditto for proximity bit */
 709			val = device->buffer[5] & MASK_INRANGE ? 1 : 0;
 710			input_report_abs(inputdev, ABS_DISTANCE, val);
 711
 712			/* Report 1 is an exception to how we handle buttons */
 713			/* Buttons are an index, not a bitmask */
 714			if (device->buffer[0] == 1) {
 715
 716				/*
 717				 * Convert buttons, 5 bit index
 718				 * Report value of index set as one,
 719				 * the rest as 0
 720				 */
 721				val = device->buffer[5] & MASK_BUTTON;
 722				dev_dbg(&device->intf->dev,
 723					"======>>>>>>REPORT 1: val 0x%X(%d)\n",
 724					val, val);
 725
 726				/*
 727				 * We don't apply any meaning to the button
 728				 * index, just report it
 729				 */
 730				input_event(inputdev, EV_MSC, MSC_SERIAL, val);
 731			}
 732			break;
 733
 734		case 7:
 735			/* Menu blocks */
 736			input_event(inputdev, EV_MSC, MSC_SCAN,
 737				    device->buffer[1]);
 738			break;
 739		}
 740	}
 741
 742	/* Other pid class */
 743	if (inputdev->id.product == PID_400 ||
 744	    inputdev->id.product == PID_401) {
 745
 746		/* Report 2 */
 747		if (device->buffer[0] == 2) {
 748			/* Menu blocks */
 749			input_event(inputdev, EV_MSC, MSC_SCAN, device->buffer[1]);
 750		}
 751
 752		/*  Report 1 */
 753		if (device->buffer[0] == 1) {
 754			char buttonbyte;
 755
 756			/*  IF X max > 64K, we still a bit from the y report */
 757			if (device->max_X > 0x10000) {
 758
 759				val = (u16)(((u16)(device->buffer[2] << 8)) | (u8)device->buffer[1]);
 760				val |= (u32)(((u8)device->buffer[3] & 0x1) << 16);
 761
 762				input_report_abs(inputdev, ABS_X, val);
 763
 764				le_buffer[0]  = (u8)((u8)(device->buffer[3]) >> 1);
 765				le_buffer[0] |= (u8)((device->buffer[3] & 0x1) << 7);
 766
 767				le_buffer[1]  = (u8)(device->buffer[4] >> 1);
 768				le_buffer[1] |= (u8)((device->buffer[5] & 0x1) << 7);
 769
 770				val = get_unaligned_le16(le_buffer);
 771				input_report_abs(inputdev, ABS_Y, val);
 772
 773				/*
 774				 * Shift the button byte right by one to
 775				 * make it look like the standard report
 776				 */
 777				buttonbyte = device->buffer[5] >> 1;
 778			} else {
 779
 780				val = get_unaligned_le16(&device->buffer[1]);
 781				input_report_abs(inputdev, ABS_X, val);
 782
 783				val = get_unaligned_le16(&device->buffer[3]);
 784				input_report_abs(inputdev, ABS_Y, val);
 785
 786				buttonbyte = device->buffer[5];
 787			}
 788
 789			/* BUTTONS and PROXIMITY */
 790			val = buttonbyte & MASK_INRANGE ? 1 : 0;
 791			input_report_abs(inputdev, ABS_DISTANCE, val);
 792
 793			/* Convert buttons, only 4 bits possible */
 794			val = buttonbyte & 0x0F;
 795#ifdef USE_BUTTONS
 796			for (i = 0; i < 5; i++)
 797				input_report_key(inputdev, BTN_DIGI + i, val & (1 << i));
 798#else
 799			/* We don't apply any meaning to the bitmask, just report */
 800			input_event(inputdev, EV_MSC, MSC_SERIAL, val);
 801#endif
 802
 803			/* TRANSDUCER */
 804			input_report_abs(inputdev, ABS_MISC, device->buffer[6]);
 805		}
 806	}
 807
 808	/* Everybody gets report ID's */
 809	input_event(inputdev, EV_MSC, MSC_RAW,  device->buffer[0]);
 810
 811	/* Sync it up */
 812	input_sync(inputdev);
 813
 814 resubmit:
 815	rc = usb_submit_urb(urbinfo, GFP_ATOMIC);
 816	if (rc != 0)
 817		dev_err(&device->intf->dev,
 818			"usb_submit_urb failed rc=0x%x\n", rc);
 819}
 820
 821/*
 822 *  The probe routine.  This is called when the kernel find the matching USB
 823 *   vendor/product.  We do the following:
 824 *
 825 *    - Allocate mem for a local structure to manage the device
 826 *    - Request a HID Report Descriptor from the device and parse it to
 827 *      find out the device parameters
 828 *    - Create an input device and assign it attributes
 829 *   - Allocate an URB so the device can talk to us when the input
 830 *      queue is open
 831 */
 832static int gtco_probe(struct usb_interface *usbinterface,
 833		      const struct usb_device_id *id)
 834{
 835
 836	struct gtco             *gtco;
 837	struct input_dev        *input_dev;
 838	struct hid_descriptor   *hid_desc;
 839	char                    *report;
 840	int                     result = 0, retry;
 841	int			error;
 842	struct usb_endpoint_descriptor *endpoint;
 843	struct usb_device	*udev = interface_to_usbdev(usbinterface);
 844
 845	/* Allocate memory for device structure */
 846	gtco = kzalloc(sizeof(struct gtco), GFP_KERNEL);
 847	input_dev = input_allocate_device();
 848	if (!gtco || !input_dev) {
 849		dev_err(&usbinterface->dev, "No more memory\n");
 850		error = -ENOMEM;
 851		goto err_free_devs;
 852	}
 853
 854	/* Set pointer to the input device */
 855	gtco->inputdevice = input_dev;
 856
 857	/* Save interface information */
 858	gtco->intf = usbinterface;
 859
 860	/* Allocate some data for incoming reports */
 861	gtco->buffer = usb_alloc_coherent(udev, REPORT_MAX_SIZE,
 862					  GFP_KERNEL, &gtco->buf_dma);
 863	if (!gtco->buffer) {
 864		dev_err(&usbinterface->dev, "No more memory for us buffers\n");
 865		error = -ENOMEM;
 866		goto err_free_devs;
 867	}
 868
 869	/* Allocate URB for reports */
 870	gtco->urbinfo = usb_alloc_urb(0, GFP_KERNEL);
 871	if (!gtco->urbinfo) {
 872		dev_err(&usbinterface->dev, "Failed to allocate URB\n");
 873		error = -ENOMEM;
 874		goto err_free_buf;
 875	}
 876
 877	/* Sanity check that a device has an endpoint */
 878	if (usbinterface->cur_altsetting->desc.bNumEndpoints < 1) {
 879		dev_err(&usbinterface->dev,
 880			"Invalid number of endpoints\n");
 881		error = -EINVAL;
 882		goto err_free_urb;
 883	}
 884
 885	endpoint = &usbinterface->cur_altsetting->endpoint[0].desc;
 886
 887	/* Some debug */
 888	dev_dbg(&usbinterface->dev, "gtco # interfaces: %d\n", usbinterface->num_altsetting);
 889	dev_dbg(&usbinterface->dev, "num endpoints:     %d\n", usbinterface->cur_altsetting->desc.bNumEndpoints);
 890	dev_dbg(&usbinterface->dev, "interface class:   %d\n", usbinterface->cur_altsetting->desc.bInterfaceClass);
 891	dev_dbg(&usbinterface->dev, "endpoint: attribute:0x%x type:0x%x\n", endpoint->bmAttributes, endpoint->bDescriptorType);
 892	if (usb_endpoint_xfer_int(endpoint))
 893		dev_dbg(&usbinterface->dev, "endpoint: we have interrupt endpoint\n");
 894
 895	dev_dbg(&usbinterface->dev, "interface extra len:%d\n",
 896		usbinterface->cur_altsetting->extralen);
 897
 898	/*
 899	 * Find the HID descriptor so we can find out the size of the
 900	 * HID report descriptor
 901	 */
 902	if (usb_get_extra_descriptor(usbinterface->cur_altsetting,
 903				     HID_DEVICE_TYPE, &hid_desc) != 0) {
 904		dev_err(&usbinterface->dev,
 905			"Can't retrieve exta USB descriptor to get hid report descriptor length\n");
 906		error = -EIO;
 907		goto err_free_urb;
 908	}
 909
 910	dev_dbg(&usbinterface->dev,
 911		"Extra descriptor success: type:%d  len:%d\n",
 912		hid_desc->bDescriptorType,  hid_desc->wDescriptorLength);
 913
 914	report = kzalloc(le16_to_cpu(hid_desc->wDescriptorLength), GFP_KERNEL);
 915	if (!report) {
 916		dev_err(&usbinterface->dev, "No more memory for report\n");
 917		error = -ENOMEM;
 918		goto err_free_urb;
 919	}
 920
 921	/* Couple of tries to get reply */
 922	for (retry = 0; retry < 3; retry++) {
 923		result = usb_control_msg(udev,
 924					 usb_rcvctrlpipe(udev, 0),
 925					 USB_REQ_GET_DESCRIPTOR,
 926					 USB_RECIP_INTERFACE | USB_DIR_IN,
 927					 REPORT_DEVICE_TYPE << 8,
 928					 0, /* interface */
 929					 report,
 930					 le16_to_cpu(hid_desc->wDescriptorLength),
 931					 5000); /* 5 secs */
 932
 933		dev_dbg(&usbinterface->dev, "usb_control_msg result: %d\n", result);
 934		if (result == le16_to_cpu(hid_desc->wDescriptorLength)) {
 935			parse_hid_report_descriptor(gtco, report, result);
 936			break;
 937		}
 938	}
 939
 940	kfree(report);
 941
 942	/* If we didn't get the report, fail */
 943	if (result != le16_to_cpu(hid_desc->wDescriptorLength)) {
 944		dev_err(&usbinterface->dev,
 945			"Failed to get HID Report Descriptor of size: %d\n",
 946			hid_desc->wDescriptorLength);
 947		error = -EIO;
 948		goto err_free_urb;
 949	}
 950
 951	/* Create a device file node */
 952	usb_make_path(udev, gtco->usbpath, sizeof(gtco->usbpath));
 953	strlcat(gtco->usbpath, "/input0", sizeof(gtco->usbpath));
 954
 955	/* Set Input device functions */
 956	input_dev->open = gtco_input_open;
 957	input_dev->close = gtco_input_close;
 958
 959	/* Set input device information */
 960	input_dev->name = "GTCO_CalComp";
 961	input_dev->phys = gtco->usbpath;
 962
 963	input_set_drvdata(input_dev, gtco);
 964
 965	/* Now set up all the input device capabilities */
 966	gtco_setup_caps(input_dev);
 967
 968	/* Set input device required ID information */
 969	usb_to_input_id(udev, &input_dev->id);
 970	input_dev->dev.parent = &usbinterface->dev;
 971
 972	/* Setup the URB, it will be posted later on open of input device */
 973	usb_fill_int_urb(gtco->urbinfo,
 974			 udev,
 975			 usb_rcvintpipe(udev,
 976					endpoint->bEndpointAddress),
 977			 gtco->buffer,
 978			 REPORT_MAX_SIZE,
 979			 gtco_urb_callback,
 980			 gtco,
 981			 endpoint->bInterval);
 982
 983	gtco->urbinfo->transfer_dma = gtco->buf_dma;
 984	gtco->urbinfo->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 985
 986	/* Save gtco pointer in USB interface gtco */
 987	usb_set_intfdata(usbinterface, gtco);
 988
 989	/* All done, now register the input device */
 990	error = input_register_device(input_dev);
 991	if (error)
 992		goto err_free_urb;
 993
 994	return 0;
 995
 996 err_free_urb:
 997	usb_free_urb(gtco->urbinfo);
 998 err_free_buf:
 999	usb_free_coherent(udev, REPORT_MAX_SIZE,
1000			  gtco->buffer, gtco->buf_dma);
1001 err_free_devs:
1002	input_free_device(input_dev);
1003	kfree(gtco);
1004	return error;
1005}
1006
1007/*
1008 *  This function is a standard USB function called when the USB device
1009 *  is disconnected.  We will get rid of the URV, de-register the input
1010 *  device, and free up allocated memory
1011 */
1012static void gtco_disconnect(struct usb_interface *interface)
1013{
1014	/* Grab private device ptr */
1015	struct gtco *gtco = usb_get_intfdata(interface);
1016	struct usb_device *udev = interface_to_usbdev(interface);
1017
1018	/* Now reverse all the registration stuff */
1019	if (gtco) {
1020		input_unregister_device(gtco->inputdevice);
1021		usb_kill_urb(gtco->urbinfo);
1022		usb_free_urb(gtco->urbinfo);
1023		usb_free_coherent(udev, REPORT_MAX_SIZE,
1024				  gtco->buffer, gtco->buf_dma);
1025		kfree(gtco);
1026	}
1027
1028	dev_info(&interface->dev, "gtco driver disconnected\n");
1029}
1030
1031/*   STANDARD MODULE LOAD ROUTINES  */
1032
1033static struct usb_driver gtco_driverinfo_table = {
1034	.name		= "gtco",
1035	.id_table	= gtco_usbid_table,
1036	.probe		= gtco_probe,
1037	.disconnect	= gtco_disconnect,
1038};
1039
1040module_usb_driver(gtco_driverinfo_table);
1041
1042MODULE_DESCRIPTION("GTCO digitizer USB driver");
1043MODULE_LICENSE("GPL");