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 [email protected]
  46 Scott Hill [email protected]
  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
  82
  83 /* Bitmask whether pen is in range */
  84 #define MASK_INRANGE 0x20
  85 #define MASK_BUTTON  0x01F
  86
  87 #define  PATHLENGTH     64
  88
  89 /* DATA STRUCTURES */
  90
  91 /* Device table */
  92 static const struct usb_device_id gtco_usbid_table[] = {
  93         { USB_DEVICE(VENDOR_ID_GTCO, PID_400) },
  94         { USB_DEVICE(VENDOR_ID_GTCO, PID_401) },
  95         { USB_DEVICE(VENDOR_ID_GTCO, PID_1000) },
  96         { USB_DEVICE(VENDOR_ID_GTCO, PID_1001) },
  97         { USB_DEVICE(VENDOR_ID_GTCO, PID_1002) },
  98         { }
  99 };
 100 MODULE_DEVICE_TABLE (usb, gtco_usbid_table);
 101
 102
 103 /* Structure to hold all of our device specific stuff */
 104 struct gtco {
 105
 106         struct input_dev  *inputdevice; /* input device struct pointer  */
 107         struct usb_interface *intf;     /* the usb interface for this device */
 108         struct urb        *urbinfo;      /* urb for incoming reports      */
 109         dma_addr_t        buf_dma;  /* dma addr of the data buffer*/
 110         unsigned char *   buffer;   /* databuffer for reports */
 111
 112         char  usbpath[PATHLENGTH];
 113         int   openCount;
 114
 115         /* Information pulled from Report Descriptor */
 116         u32  usage;
 117         u32  min_X;
 118         u32  max_X;
 119         u32  min_Y;
 120         u32  max_Y;
 121         s8   mintilt_X;
 122         s8   maxtilt_X;
 123         s8   mintilt_Y;
 124         s8   maxtilt_Y;
 125         u32  maxpressure;
 126         u32  minpressure;
 127 };
 128
 129
 130
 131 /*   Code for parsing the HID REPORT DESCRIPTOR          */
 132
 133 /* From HID1.11 spec */
 134 struct hid_descriptor
 135 {
 136         struct usb_descriptor_header header;
 137         __le16   bcdHID;
 138         u8       bCountryCode;
 139         u8       bNumDescriptors;
 140         u8       bDescriptorType;
 141         __le16   wDescriptorLength;
 142 } __attribute__ ((packed));
 143
 144
 145 #define HID_DESCRIPTOR_SIZE   9
 146 #define HID_DEVICE_TYPE       33
 147 #define REPORT_DEVICE_TYPE    34
 148
 149
 150 #define PREF_TAG(x)     ((x)>>4)
 151 #define PREF_TYPE(x)    ((x>>2)&0x03)
 152 #define PREF_SIZE(x)    ((x)&0x03)
 153
 154 #define TYPE_MAIN       0
 155 #define TYPE_GLOBAL     1
 156 #define TYPE_LOCAL      2
 157 #define TYPE_RESERVED   3
 158
 159 #define TAG_MAIN_INPUT        0x8
 160 #define TAG_MAIN_OUTPUT       0x9
 161 #define TAG_MAIN_FEATURE      0xB
 162 #define TAG_MAIN_COL_START    0xA
 163 #define TAG_MAIN_COL_END      0xC
 164
 165 #define TAG_GLOB_USAGE        0
 166 #define TAG_GLOB_LOG_MIN      1
 167 #define TAG_GLOB_LOG_MAX      2
 168 #define TAG_GLOB_PHYS_MIN     3
 169 #define TAG_GLOB_PHYS_MAX     4
 170 #define TAG_GLOB_UNIT_EXP     5
 171 #define TAG_GLOB_UNIT         6
 172 #define TAG_GLOB_REPORT_SZ    7
 173 #define TAG_GLOB_REPORT_ID    8
 174 #define TAG_GLOB_REPORT_CNT   9
 175 #define TAG_GLOB_PUSH         10
 176 #define TAG_GLOB_POP          11
 177
 178 #define TAG_GLOB_MAX          12
 179
 180 #define DIGITIZER_USAGE_TIP_PRESSURE   0x30
 181 #define DIGITIZER_USAGE_TILT_X         0x3D
 182 #define DIGITIZER_USAGE_TILT_Y         0x3E
 183
 184
 185 /*
 186  *   This is an abbreviated parser for the HID Report Descriptor.  We
 187  *   know what devices we are talking to, so this is by no means meant
 188  *   to be generic.  We can make some safe assumptions:
 189  *
 190  *   - We know there are no LONG tags, all short
 191  *   - We know that we have no MAIN Feature and MAIN Output items
 192  *   - We know what the IRQ reports are supposed to look like.
 193  *
 194  *   The main purpose of this is to use the HID report desc to figure
 195  *   out the mins and maxs of the fields in the IRQ reports.  The IRQ
 196  *   reports for 400/401 change slightly if the max X is bigger than 64K.
 197  *
 198  */
 199 static void parse_hid_report_descriptor(struct gtco *device, char * report,
 200                                         int length)
 201 {
 202         struct device *ddev = &device->intf->dev;
 203         int   x, i = 0;
 204
 205         /* Tag primitive vars */
 206         __u8   prefix;
 207         __u8   size;
 208         __u8   tag;
 209         __u8   type;
 210         __u8   data   = 0;
 211         __u16  data16 = 0;
 212         __u32  data32 = 0;
 213
 214         /* For parsing logic */
 215         int   inputnum = 0;
 216         __u32 usage = 0;
 217
 218         /* Global Values, indexed by TAG */
 219         __u32 globalval[TAG_GLOB_MAX];
 220         __u32 oldval[TAG_GLOB_MAX];
 221
 222         /* Debug stuff */
 223         char  maintype = 'x';
 224         char  globtype[12];
 225         int   indent = 0;
 226         char  indentstr[10] = "";
 227
 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 (data == 0) {
 354                                         dev_dbg(ddev, "======>>>>>> Physical\n");
 355                                         strcpy(globtype, "Physical");
 356                                 } else
 357                                         dev_dbg(ddev, "======>>>>>>\n");
 358
 359                                 /* Indent the debug output */
 360                                 indent++;
 361                                 for (x = 0; x < indent; x++)
 362                                         indentstr[x] = '-';
 363                                 indentstr[x] = 0;
 364
 365                                 /* Save global tags */
 366                                 for (x = 0; x < TAG_GLOB_MAX; x++)
 367                                         oldval[x] = globalval[x];
 368
 369                                 break;
 370
 371                         case TAG_MAIN_COL_END:
 372                                 dev_dbg(ddev, "<<<<<<======\n");
 373                                 maintype = 'E';
 374                                 indent--;
 375                                 for (x = 0; x < indent; x++)
 376                                         indentstr[x] = '-';
 377                                 indentstr[x] = 0;
 378
 379                                 /* Copy global tags back */
 380                                 for (x = 0; x < TAG_GLOB_MAX; x++)
 381                                         globalval[x] = oldval[x];
 382
 383                                 break;
 384                         }
 385
 386                         switch (size) {
 387                         case 1:
 388                                 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
 389                                         indentstr, tag, maintype, size, globtype, data);
 390                                 break;
 391
 392                         case 2:
 393                                 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
 394                                         indentstr, tag, maintype, size, globtype, data16);
 395                                 break;
 396
 397                         case 4:
 398                                 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
 399                                         indentstr, tag, maintype, size, globtype, data32);
 400                                 break;
 401                         }
 402                         break;
 403
 404                 case TYPE_GLOBAL:
 405                         switch (tag) {
 406                         case TAG_GLOB_USAGE:
 407                                 /*
 408                                  * First time we hit the global usage tag,
 409                                  * it should tell us the type of device
 410                                  */
 411                                 if (device->usage == 0)
 412                                         device->usage = data;
 413
 414                                 strcpy(globtype, "USAGE");
 415                                 break;
 416
 417                         case TAG_GLOB_LOG_MIN:
 418                                 strcpy(globtype, "LOG_MIN");
 419                                 break;
 420
 421                         case TAG_GLOB_LOG_MAX:
 422                                 strcpy(globtype, "LOG_MAX");
 423                                 break;
 424
 425                         case TAG_GLOB_PHYS_MIN:
 426                                 strcpy(globtype, "PHYS_MIN");
 427                                 break;
 428
 429                         case TAG_GLOB_PHYS_MAX:
 430                                 strcpy(globtype, "PHYS_MAX");
 431                                 break;
 432
 433                         case TAG_GLOB_UNIT_EXP:
 434                                 strcpy(globtype, "EXP");
 435                                 break;
 436
 437                         case TAG_GLOB_UNIT:
 438                                 strcpy(globtype, "UNIT");
 439                                 break;
 440
 441                         case TAG_GLOB_REPORT_SZ:
 442                                 strcpy(globtype, "REPORT_SZ");
 443                                 break;
 444
 445                         case TAG_GLOB_REPORT_ID:
 446                                 strcpy(globtype, "REPORT_ID");
 447                                 /* New report, restart numbering */
 448                                 inputnum = 0;
 449                                 break;
 450
 451                         case TAG_GLOB_REPORT_CNT:
 452                                 strcpy(globtype, "REPORT_CNT");
 453                                 break;
 454
 455                         case TAG_GLOB_PUSH:
 456                                 strcpy(globtype, "PUSH");
 457                                 break;
 458
 459                         case TAG_GLOB_POP:
 460                                 strcpy(globtype, "POP");
 461                                 break;
 462                         }
 463
 464                         /* Check to make sure we have a good tag number
 465                            so we don't overflow array */
 466                         if (tag < TAG_GLOB_MAX) {
 467                                 switch (size) {
 468                                 case 1:
 469                                         dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
 470                                                 indentstr, globtype, tag, size, data);
 471                                         globalval[tag] = data;
 472                                         break;
 473
 474                                 case 2:
 475                                         dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
 476                                                 indentstr, globtype, tag, size, data16);
 477                                         globalval[tag] = data16;
 478                                         break;
 479
 480                                 case 4:
 481                                         dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
 482                                                 indentstr, globtype, tag, size, data32);
 483                                         globalval[tag] = data32;
 484                                         break;
 485                                 }
 486                         } else {
 487                                 dev_dbg(ddev, "%sGLOBALTAG: ILLEGAL TAG:%d SIZE: %d\n",
 488                                         indentstr, tag, size);
 489                         }
 490                         break;
 491
 492                 case TYPE_LOCAL:
 493                         switch (tag) {
 494                         case TAG_GLOB_USAGE:
 495                                 strcpy(globtype, "USAGE");
 496                                 /* Always 1 byte */
 497                                 usage = data;
 498                                 break;
 499
 500                         case TAG_GLOB_LOG_MIN:
 501                                 strcpy(globtype, "MIN");
 502                                 break;
 503
 504                         case TAG_GLOB_LOG_MAX:
 505                                 strcpy(globtype, "MAX");
 506                                 break;
 507
 508                         default:
 509                                 strcpy(globtype, "UNKNOWN");
 510                                 break;
 511                         }
 512
 513                         switch (size) {
 514                         case 1:
 515                                 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
 516                                         indentstr, tag, globtype, size, data);
 517                                 break;
 518
 519                         case 2:
 520                                 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
 521                                         indentstr, tag, globtype, size, data16);
 522                                 break;
 523
 524                         case 4:
 525                                 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
 526                                         indentstr, tag, globtype, size, data32);
 527                                 break;
 528                         }
 529
 530                         break;
 531                 }
 532         }
 533 }
 534
 535 /*   INPUT DRIVER Routines                               */
 536
 537 /*
 538  * Called when opening the input device.  This will submit the URB to
 539  * the usb system so we start getting reports
 540  */
 541 static int gtco_input_open(struct input_dev *inputdev)
 542 {
 543         struct gtco *device = input_get_drvdata(inputdev);
 544
 545         device->urbinfo->dev = interface_to_usbdev(device->intf);
 546         if (usb_submit_urb(device->urbinfo, GFP_KERNEL))
 547                 return -EIO;
 548
 549         return 0;
 550 }
 551
 552 /*
 553  * Called when closing the input device.  This will unlink the URB
 554  */
 555 static void gtco_input_close(struct input_dev *inputdev)
 556 {
 557         struct gtco *device = input_get_drvdata(inputdev);
 558
 559         usb_kill_urb(device->urbinfo);
 560 }
 561
 562
 563 /*
 564  *  Setup input device capabilities.  Tell the input system what this
 565  *  device is capable of generating.
 566  *
 567  *  This information is based on what is read from the HID report and
 568  *  placed in the struct gtco structure
 569  *
 570  */
 571 static void gtco_setup_caps(struct input_dev *inputdev)
 572 {
 573         struct gtco *device = input_get_drvdata(inputdev);
 574
 575         /* Which events */
 576         inputdev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) |
 577                 BIT_MASK(EV_MSC);
 578
 579         /* Misc event menu block */
 580         inputdev->mscbit[0] = BIT_MASK(MSC_SCAN) | BIT_MASK(MSC_SERIAL) |
 581                 BIT_MASK(MSC_RAW);
 582
 583         /* Absolute values based on HID report info */
 584         input_set_abs_params(inputdev, ABS_X, device->min_X, device->max_X,
 585                              0, 0);
 586         input_set_abs_params(inputdev, ABS_Y, device->min_Y, device->max_Y,
 587                              0, 0);
 588
 589         /* Proximity */
 590         input_set_abs_params(inputdev, ABS_DISTANCE, 0, 1, 0, 0);
 591
 592         /* Tilt & pressure */
 593         input_set_abs_params(inputdev, ABS_TILT_X, device->mintilt_X,
 594                              device->maxtilt_X, 0, 0);
 595         input_set_abs_params(inputdev, ABS_TILT_Y, device->mintilt_Y,
 596                              device->maxtilt_Y, 0, 0);
 597         input_set_abs_params(inputdev, ABS_PRESSURE, device->minpressure,
 598                              device->maxpressure, 0, 0);
 599
 600         /* Transducer */
 601         input_set_abs_params(inputdev, ABS_MISC, 0, 0xFF, 0, 0);
 602 }
 603
 604 /*   USB Routines  */
 605
 606 /*
 607  * URB callback routine.  Called when we get IRQ reports from the
 608  *  digitizer.
 609  *
 610  *  This bridges the USB and input device worlds.  It generates events
 611  *  on the input device based on the USB reports.
 612  */
 613 static void gtco_urb_callback(struct urb *urbinfo)
 614 {
 615         struct gtco *device = urbinfo->context;
 616         struct input_dev  *inputdev;
 617         int               rc;
 618         u32               val = 0;
 619         char              le_buffer[2];
 620
 621         inputdev = device->inputdevice;
 622
 623         /* Was callback OK? */
 624         if (urbinfo->status == -ECONNRESET ||
 625             urbinfo->status == -ENOENT ||
 626             urbinfo->status == -ESHUTDOWN) {
 627
 628                 /* Shutdown is occurring. Return and don't queue up any more */
 629                 return;
 630         }
 631
 632         if (urbinfo->status != 0) {
 633                 /*
 634                  * Some unknown error.  Hopefully temporary. Just go and
 635                  * requeue an URB
 636                  */
 637                 goto resubmit;
 638         }
 639
 640         /*
 641          * Good URB, now process
 642          */
 643
 644         /* PID dependent when we interpret the report */
 645         if (inputdev->id.product == PID_1000 ||
 646             inputdev->id.product == PID_1001 ||
 647             inputdev->id.product == PID_1002) {
 648
 649                 /*
 650                  * Switch on the report ID
 651                  * Conveniently, the reports have more information, the higher
 652                  * the report number.  We can just fall through the case
 653                  * statements if we start with the highest number report
 654                  */
 655                 switch (device->buffer[0]) {
 656                 case 5:
 657                         /* Pressure is 9 bits */
 658                         val = ((u16)(device->buffer[8]) << 1);
 659                         val |= (u16)(device->buffer[7] >> 7);
 660                         input_report_abs(inputdev, ABS_PRESSURE,
 661                                          device->buffer[8]);
 662
 663                         /* Mask out the Y tilt value used for pressure */
 664                         device->buffer[7] = (u8)((device->buffer[7]) & 0x7F);
 665
 666                         /* Fall thru */
 667                 case 4:
 668                         /* Tilt */
 669                         input_report_abs(inputdev, ABS_TILT_X,
 670                                          sign_extend32(device->buffer[6], 6));
 671
 672                         input_report_abs(inputdev, ABS_TILT_Y,
 673                                          sign_extend32(device->buffer[7], 6));
 674
 675                         /* Fall thru */
 676                 case 2:
 677                 case 3:
 678                         /* Convert buttons, only 5 bits possible */
 679                         val = (device->buffer[5]) & MASK_BUTTON;
 680
 681                         /* We don't apply any meaning to the bitmask,
 682                            just report */
 683                         input_event(inputdev, EV_MSC, MSC_SERIAL, val);
 684
 685                         /*  Fall thru */
 686                 case 1:
 687                         /* All reports have X and Y coords in the same place */
 688                         val = get_unaligned_le16(&device->buffer[1]);
 689                         input_report_abs(inputdev, ABS_X, val);
 690
 691                         val = get_unaligned_le16(&device->buffer[3]);
 692                         input_report_abs(inputdev, ABS_Y, val);
 693
 694                         /* Ditto for proximity bit */
 695                         val = device->buffer[5] & MASK_INRANGE ? 1 : 0;
 696                         input_report_abs(inputdev, ABS_DISTANCE, val);
 697
 698                         /* Report 1 is an exception to how we handle buttons */
 699                         /* Buttons are an index, not a bitmask */
 700                         if (device->buffer[0] == 1) {
 701
 702                                 /*
 703                                  * Convert buttons, 5 bit index
 704                                  * Report value of index set as one,
 705                                  * the rest as 0
 706                                  */
 707                                 val = device->buffer[5] & MASK_BUTTON;
 708                                 dev_dbg(&device->intf->dev,
 709                                         "======>>>>>>REPORT 1: val 0x%X(%d)\n",
 710                                         val, val);
 711
 712                                 /*
 713                                  * We don't apply any meaning to the button
 714                                  * index, just report it
 715                                  */
 716                                 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
 717                         }
 718                         break;
 719
 720                 case 7:
 721                         /* Menu blocks */
 722                         input_event(inputdev, EV_MSC, MSC_SCAN,
 723                                     device->buffer[1]);
 724                         break;
 725                 }
 726         }
 727
 728         /* Other pid class */
 729         if (inputdev->id.product == PID_400 ||
 730             inputdev->id.product == PID_401) {
 731
 732                 /* Report 2 */
 733                 if (device->buffer[0] == 2) {
 734                         /* Menu blocks */
 735                         input_event(inputdev, EV_MSC, MSC_SCAN, device->buffer[1]);
 736                 }
 737
 738                 /*  Report 1 */
 739                 if (device->buffer[0] == 1) {
 740                         char buttonbyte;
 741
 742                         /*  IF X max > 64K, we still a bit from the y report */
 743                         if (device->max_X > 0x10000) {
 744
 745                                 val = (u16)(((u16)(device->buffer[2] << 8)) | (u8)device->buffer[1]);
 746                                 val |= (u32)(((u8)device->buffer[3] & 0x1) << 16);
 747
 748                                 input_report_abs(inputdev, ABS_X, val);
 749
 750                                 le_buffer[0]  = (u8)((u8)(device->buffer[3]) >> 1);
 751                                 le_buffer[0] |= (u8)((device->buffer[3] & 0x1) << 7);
 752
 753                                 le_buffer[1]  = (u8)(device->buffer[4] >> 1);
 754                                 le_buffer[1] |= (u8)((device->buffer[5] & 0x1) << 7);
 755
 756                                 val = get_unaligned_le16(le_buffer);
 757                                 input_report_abs(inputdev, ABS_Y, val);
 758
 759                                 /*
 760                                  * Shift the button byte right by one to
 761                                  * make it look like the standard report
 762                                  */
 763                                 buttonbyte = device->buffer[5] >> 1;
 764                         } else {
 765
 766                                 val = get_unaligned_le16(&device->buffer[1]);
 767                                 input_report_abs(inputdev, ABS_X, val);
 768
 769                                 val = get_unaligned_le16(&device->buffer[3]);
 770                                 input_report_abs(inputdev, ABS_Y, val);
 771
 772                                 buttonbyte = device->buffer[5];
 773                         }
 774
 775                         /* BUTTONS and PROXIMITY */
 776                         val = buttonbyte & MASK_INRANGE ? 1 : 0;
 777                         input_report_abs(inputdev, ABS_DISTANCE, val);
 778
 779                         /* Convert buttons, only 4 bits possible */
 780                         val = buttonbyte & 0x0F;
 781 #ifdef USE_BUTTONS
 782                         for (i = 0; i < 5; i++)
 783                                 input_report_key(inputdev, BTN_DIGI + i, val & (1 << i));
 784 #else
 785                         /* We don't apply any meaning to the bitmask, just report */
 786                         input_event(inputdev, EV_MSC, MSC_SERIAL, val);
 787 #endif
 788
 789                         /* TRANSDUCER */
 790                         input_report_abs(inputdev, ABS_MISC, device->buffer[6]);
 791                 }
 792         }
 793
 794         /* Everybody gets report ID's */
 795         input_event(inputdev, EV_MSC, MSC_RAW,  device->buffer[0]);
 796
 797         /* Sync it up */
 798         input_sync(inputdev);
 799
 800  resubmit:
 801         rc = usb_submit_urb(urbinfo, GFP_ATOMIC);
 802         if (rc != 0)
 803                 dev_err(&device->intf->dev,
 804                         "usb_submit_urb failed rc=0x%x\n", rc);
 805 }
 806
 807 /*
 808  *  The probe routine.  This is called when the kernel find the matching USB
 809  *   vendor/product.  We do the following:
 810  *
 811  *    - Allocate mem for a local structure to manage the device
 812  *    - Request a HID Report Descriptor from the device and parse it to
 813  *      find out the device parameters
 814  *    - Create an input device and assign it attributes
 815  *   - Allocate an URB so the device can talk to us when the input
 816  *      queue is open
 817  */
 818 static int gtco_probe(struct usb_interface *usbinterface,
 819                       const struct usb_device_id *id)
 820 {
 821
 822         struct gtco             *gtco;
 823         struct input_dev        *input_dev;
 824         struct hid_descriptor   *hid_desc;
 825         char                    *report;
 826         int                     result = 0, retry;
 827         int                     error;
 828         struct usb_endpoint_descriptor *endpoint;
 829         struct usb_device       *udev = interface_to_usbdev(usbinterface);
 830
 831         /* Allocate memory for device structure */
 832         gtco = kzalloc(sizeof(struct gtco), GFP_KERNEL);
 833         input_dev = input_allocate_device();
 834         if (!gtco || !input_dev) {
 835                 dev_err(&usbinterface->dev, "No more memory\n");
 836                 error = -ENOMEM;
 837                 goto err_free_devs;
 838         }
 839
 840         /* Set pointer to the input device */
 841         gtco->inputdevice = input_dev;
 842
 843         /* Save interface information */
 844         gtco->intf = usbinterface;
 845
 846         /* Allocate some data for incoming reports */
 847         gtco->buffer = usb_alloc_coherent(udev, REPORT_MAX_SIZE,
 848                                           GFP_KERNEL, &gtco->buf_dma);
 849         if (!gtco->buffer) {
 850                 dev_err(&usbinterface->dev, "No more memory for us buffers\n");
 851                 error = -ENOMEM;
 852                 goto err_free_devs;
 853         }
 854
 855         /* Allocate URB for reports */
 856         gtco->urbinfo = usb_alloc_urb(0, GFP_KERNEL);
 857         if (!gtco->urbinfo) {
 858                 dev_err(&usbinterface->dev, "Failed to allocate URB\n");
 859                 error = -ENOMEM;
 860                 goto err_free_buf;
 861         }
 862
 863         /* Sanity check that a device has an endpoint */
 864         if (usbinterface->altsetting[0].desc.bNumEndpoints < 1) {
 865                 dev_err(&usbinterface->dev,
 866                         "Invalid number of endpoints\n");
 867                 error = -EINVAL;
 868                 goto err_free_urb;
 869         }
 870
 871         /*
 872          * The endpoint is always altsetting 0, we know this since we know
 873          * this device only has one interrupt endpoint
 874          */
 875         endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
 876
 877         /* Some debug */
 878         dev_dbg(&usbinterface->dev, "gtco # interfaces: %d\n", usbinterface->num_altsetting);
 879         dev_dbg(&usbinterface->dev, "num endpoints:     %d\n", usbinterface->cur_altsetting->desc.bNumEndpoints);
 880         dev_dbg(&usbinterface->dev, "interface class:   %d\n", usbinterface->cur_altsetting->desc.bInterfaceClass);
 881         dev_dbg(&usbinterface->dev, "endpoint: attribute:0x%x type:0x%x\n", endpoint->bmAttributes, endpoint->bDescriptorType);
 882         if (usb_endpoint_xfer_int(endpoint))
 883                 dev_dbg(&usbinterface->dev, "endpoint: we have interrupt endpoint\n");
 884
 885         dev_dbg(&usbinterface->dev, "endpoint extra len:%d\n", usbinterface->altsetting[0].extralen);
 886
 887         /*
 888          * Find the HID descriptor so we can find out the size of the
 889          * HID report descriptor
 890          */
 891         if (usb_get_extra_descriptor(usbinterface->cur_altsetting,
 892                                      HID_DEVICE_TYPE, &hid_desc) != 0) {
 893                 dev_err(&usbinterface->dev,
 894                         "Can't retrieve exta USB descriptor to get hid report descriptor length\n");
 895                 error = -EIO;
 896                 goto err_free_urb;
 897         }
 898
 899         dev_dbg(&usbinterface->dev,
 900                 "Extra descriptor success: type:%d  len:%d\n",
 901                 hid_desc->bDescriptorType,  hid_desc->wDescriptorLength);
 902
 903         report = kzalloc(le16_to_cpu(hid_desc->wDescriptorLength), GFP_KERNEL);
 904         if (!report) {
 905                 dev_err(&usbinterface->dev, "No more memory for report\n");
 906                 error = -ENOMEM;
 907                 goto err_free_urb;
 908         }
 909
 910         /* Couple of tries to get reply */
 911         for (retry = 0; retry < 3; retry++) {
 912                 result = usb_control_msg(udev,
 913                                          usb_rcvctrlpipe(udev, 0),
 914                                          USB_REQ_GET_DESCRIPTOR,
 915                                          USB_RECIP_INTERFACE | USB_DIR_IN,
 916                                          REPORT_DEVICE_TYPE << 8,
 917                                          0, /* interface */
 918                                          report,
 919                                          le16_to_cpu(hid_desc->wDescriptorLength),
 920                                          5000); /* 5 secs */
 921
 922                 dev_dbg(&usbinterface->dev, "usb_control_msg result: %d\n", result);
 923                 if (result == le16_to_cpu(hid_desc->wDescriptorLength)) {
 924                         parse_hid_report_descriptor(gtco, report, result);
 925                         break;
 926                 }
 927         }
 928
 929         kfree(report);
 930
 931         /* If we didn't get the report, fail */
 932         if (result != le16_to_cpu(hid_desc->wDescriptorLength)) {
 933                 dev_err(&usbinterface->dev,
 934                         "Failed to get HID Report Descriptor of size: %d\n",
 935                         hid_desc->wDescriptorLength);
 936                 error = -EIO;
 937                 goto err_free_urb;
 938         }
 939
 940         /* Create a device file node */
 941         usb_make_path(udev, gtco->usbpath, sizeof(gtco->usbpath));
 942         strlcat(gtco->usbpath, "/input0", sizeof(gtco->usbpath));
 943
 944         /* Set Input device functions */
 945         input_dev->open = gtco_input_open;
 946         input_dev->close = gtco_input_close;
 947
 948         /* Set input device information */
 949         input_dev->name = "GTCO_CalComp";
 950         input_dev->phys = gtco->usbpath;
 951
 952         input_set_drvdata(input_dev, gtco);
 953
 954         /* Now set up all the input device capabilities */
 955         gtco_setup_caps(input_dev);
 956
 957         /* Set input device required ID information */
 958         usb_to_input_id(udev, &input_dev->id);
 959         input_dev->dev.parent = &usbinterface->dev;
 960
 961         /* Setup the URB, it will be posted later on open of input device */
 962         endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
 963
 964         usb_fill_int_urb(gtco->urbinfo,
 965                          udev,
 966                          usb_rcvintpipe(udev,
 967                                         endpoint->bEndpointAddress),
 968                          gtco->buffer,
 969                          REPORT_MAX_SIZE,
 970                          gtco_urb_callback,
 971                          gtco,
 972                          endpoint->bInterval);
 973
 974         gtco->urbinfo->transfer_dma = gtco->buf_dma;
 975         gtco->urbinfo->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 976
 977         /* Save gtco pointer in USB interface gtco */
 978         usb_set_intfdata(usbinterface, gtco);
 979
 980         /* All done, now register the input device */
 981         error = input_register_device(input_dev);
 982         if (error)
 983                 goto err_free_urb;
 984
 985         return 0;
 986
 987  err_free_urb:
 988         usb_free_urb(gtco->urbinfo);
 989  err_free_buf:
 990         usb_free_coherent(udev, REPORT_MAX_SIZE,
 991                           gtco->buffer, gtco->buf_dma);
 992  err_free_devs:
 993         input_free_device(input_dev);
 994         kfree(gtco);
 995         return error;
 996 }
 997
 998 /*
 999  *  This function is a standard USB function called when the USB device
1000  *  is disconnected.  We will get rid of the URV, de-register the input
1001  *  device, and free up allocated memory
1002  */
1003 static void gtco_disconnect(struct usb_interface *interface)
1004 {
1005         /* Grab private device ptr */
1006         struct gtco *gtco = usb_get_intfdata(interface);
1007         struct usb_device *udev = interface_to_usbdev(interface);
1008
1009         /* Now reverse all the registration stuff */
1010         if (gtco) {
1011                 input_unregister_device(gtco->inputdevice);
1012                 usb_kill_urb(gtco->urbinfo);
1013                 usb_free_urb(gtco->urbinfo);
1014                 usb_free_coherent(udev, REPORT_MAX_SIZE,
1015                                   gtco->buffer, gtco->buf_dma);
1016                 kfree(gtco);
1017         }
1018
1019         dev_info(&interface->dev, "gtco driver disconnected\n");
1020 }
1021
1022 /*   STANDARD MODULE LOAD ROUTINES  */
1023
1024 static struct usb_driver gtco_driverinfo_table = {
1025         .name           = "gtco",
1026         .id_table       = gtco_usbid_table,
1027         .probe          = gtco_probe,
1028         .disconnect     = gtco_disconnect,
1029 };
1030
1031 module_usb_driver(gtco_driverinfo_table);
1032
1033 MODULE_DESCRIPTION("GTCO digitizer USB driver");
1034 MODULE_LICENSE("GPL");