drivers/input/tablet/gtco.c

   1 /*    -*- linux-c -*-
   2
   3 GTCO digitizer USB driver
   4
   5 TO CHECK:  Is pressure done right on report 5?
   6
   7 Copyright (C) 2006  GTCO CalComp
   8
   9 This program is free software; you can redistribute it and/or
  10 modify it under the terms of the GNU General Public License
  11 as published by the Free Software Foundation; version 2
  12 of the License.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with this program; if not, write to the Free Software
  21 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  22
  23 Permission to use, copy, modify, distribute, and sell this software and its
  24 documentation for any purpose is hereby granted without fee, provided that
  25 the above copyright notice appear in all copies and that both that
  26 copyright notice and this permission notice appear in supporting
  27 documentation, and that the name of GTCO-CalComp not be used in advertising
  28 or publicity pertaining to distribution of the software without specific,
  29 written prior permission. GTCO-CalComp makes no representations about the
  30 suitability of this software for any purpose.  It is provided "as is"
  31 without express or implied warranty.
  32
  33 GTCO-CALCOMP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  34 INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  35 EVENT SHALL GTCO-CALCOMP BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  36 CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  37 DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  38 TORTIOUS ACTIONS, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  39 PERFORMANCE OF THIS SOFTWARE.
  40
  41 GTCO CalComp, Inc.
  42 7125 Riverwood Drive
  43 Columbia, MD 21046
  44
  45 Jeremy Roberson jroberson@gtcocalcomp.com
  46 Scott 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 <asm/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 */
  93 static 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 };
 101 MODULE_DEVICE_TABLE (usb, gtco_usbid_table);
 102
 103
 104 /* Structure to hold all of our device specific stuff */
 105 struct 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 */
 135 struct 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  */
 200 static 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  */
 555 static 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  */
 569 static 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  */
 585 static 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  */
 627 static 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  */
 832 static 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, "endpoint extra len:%d\n", usbinterface->altsetting[0].extralen);
 896
 897         /*
 898          * Find the HID descriptor so we can find out the size of the
 899          * HID report descriptor
 900          */
 901         if (usb_get_extra_descriptor(usbinterface->cur_altsetting,
 902                                      HID_DEVICE_TYPE, &hid_desc) != 0) {
 903                 dev_err(&usbinterface->dev,
 904                         "Can't retrieve exta USB descriptor to get hid report descriptor length\n");
 905                 error = -EIO;
 906                 goto err_free_urb;
 907         }
 908
 909         dev_dbg(&usbinterface->dev,
 910                 "Extra descriptor success: type:%d  len:%d\n",
 911                 hid_desc->bDescriptorType,  hid_desc->wDescriptorLength);
 912
 913         report = kzalloc(le16_to_cpu(hid_desc->wDescriptorLength), GFP_KERNEL);
 914         if (!report) {
 915                 dev_err(&usbinterface->dev, "No more memory for report\n");
 916                 error = -ENOMEM;
 917                 goto err_free_urb;
 918         }
 919
 920         /* Couple of tries to get reply */
 921         for (retry = 0; retry < 3; retry++) {
 922                 result = usb_control_msg(udev,
 923                                          usb_rcvctrlpipe(udev, 0),
 924                                          USB_REQ_GET_DESCRIPTOR,
 925                                          USB_RECIP_INTERFACE | USB_DIR_IN,
 926                                          REPORT_DEVICE_TYPE << 8,
 927                                          0, /* interface */
 928                                          report,
 929                                          le16_to_cpu(hid_desc->wDescriptorLength),
 930                                          5000); /* 5 secs */
 931
 932                 dev_dbg(&usbinterface->dev, "usb_control_msg result: %d\n", result);
 933                 if (result == le16_to_cpu(hid_desc->wDescriptorLength)) {
 934                         parse_hid_report_descriptor(gtco, report, result);
 935                         break;
 936                 }
 937         }
 938
 939         kfree(report);
 940
 941         /* If we didn't get the report, fail */
 942         if (result != le16_to_cpu(hid_desc->wDescriptorLength)) {
 943                 dev_err(&usbinterface->dev,
 944                         "Failed to get HID Report Descriptor of size: %d\n",
 945                         hid_desc->wDescriptorLength);
 946                 error = -EIO;
 947                 goto err_free_urb;
 948         }
 949
 950         /* Create a device file node */
 951         usb_make_path(udev, gtco->usbpath, sizeof(gtco->usbpath));
 952         strlcat(gtco->usbpath, "/input0", sizeof(gtco->usbpath));
 953
 954         /* Set Input device functions */
 955         input_dev->open = gtco_input_open;
 956         input_dev->close = gtco_input_close;
 957
 958         /* Set input device information */
 959         input_dev->name = "GTCO_CalComp";
 960         input_dev->phys = gtco->usbpath;
 961
 962         input_set_drvdata(input_dev, gtco);
 963
 964         /* Now set up all the input device capabilities */
 965         gtco_setup_caps(input_dev);
 966
 967         /* Set input device required ID information */
 968         usb_to_input_id(udev, &input_dev->id);
 969         input_dev->dev.parent = &usbinterface->dev;
 970
 971         /* Setup the URB, it will be posted later on open of input device */
 972         endpoint = &usbinterface->cur_altsetting->endpoint[0].desc;
 973
 974         usb_fill_int_urb(gtco->urbinfo,
 975                          udev,
 976                          usb_rcvintpipe(udev,
 977                                         endpoint->bEndpointAddress),
 978                          gtco->buffer,
 979                          REPORT_MAX_SIZE,
 980                          gtco_urb_callback,
 981                          gtco,
 982                          endpoint->bInterval);
 983
 984         gtco->urbinfo->transfer_dma = gtco->buf_dma;
 985         gtco->urbinfo->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 986
 987         /* Save gtco pointer in USB interface gtco */
 988         usb_set_intfdata(usbinterface, gtco);
 989
 990         /* All done, now register the input device */
 991         error = input_register_device(input_dev);
 992         if (error)
 993                 goto err_free_urb;
 994
 995         return 0;
 996
 997  err_free_urb:
 998         usb_free_urb(gtco->urbinfo);
 999  err_free_buf:
1000         usb_free_coherent(udev, REPORT_MAX_SIZE,
1001                           gtco->buffer, gtco->buf_dma);
1002  err_free_devs:
1003         input_free_device(input_dev);
1004         kfree(gtco);
1005         return error;
1006 }
1007
1008 /*
1009  *  This function is a standard USB function called when the USB device
1010  *  is disconnected.  We will get rid of the URV, de-register the input
1011  *  device, and free up allocated memory
1012  */
1013 static void gtco_disconnect(struct usb_interface *interface)
1014 {
1015         /* Grab private device ptr */
1016         struct gtco *gtco = usb_get_intfdata(interface);
1017         struct usb_device *udev = interface_to_usbdev(interface);
1018
1019         /* Now reverse all the registration stuff */
1020         if (gtco) {
1021                 input_unregister_device(gtco->inputdevice);
1022                 usb_kill_urb(gtco->urbinfo);
1023                 usb_free_urb(gtco->urbinfo);
1024                 usb_free_coherent(udev, REPORT_MAX_SIZE,
1025                                   gtco->buffer, gtco->buf_dma);
1026                 kfree(gtco);
1027         }
1028
1029         dev_info(&interface->dev, "gtco driver disconnected\n");
1030 }
1031
1032 /*   STANDARD MODULE LOAD ROUTINES  */
1033
1034 static struct usb_driver gtco_driverinfo_table = {
1035         .name           = "gtco",
1036         .id_table       = gtco_usbid_table,
1037         .probe          = gtco_probe,
1038         .disconnect     = gtco_disconnect,
1039 };
1040
1041 module_usb_driver(gtco_driverinfo_table);
1042
1043 MODULE_DESCRIPTION("GTCO digitizer USB driver");
1044 MODULE_LICENSE("GPL");