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/init.h>
  57 #include <linux/slab.h>
  58 #include <linux/input.h>
  59 #include <linux/usb.h>
  60 #include <asm/uaccess.h>
  61 #include <asm/unaligned.h>
  62 #include <asm/byteorder.h>
  63
  64
  65 #include <linux/usb/input.h>
  66
  67 /* Version with a Major number of 2 is for kernel inclusion only. */
  68 #define  GTCO_VERSION   "2.00.0006"
  69
  70
  71 /*   MACROS  */
  72
  73 #define VENDOR_ID_GTCO        0x078C
  74 #define PID_400               0x400
  75 #define PID_401               0x401
  76 #define PID_1000              0x1000
  77 #define PID_1001              0x1001
  78 #define PID_1002              0x1002
  79
  80 /* Max size of a single report */
  81 #define REPORT_MAX_SIZE       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_device *usbdev; /* the usb device for this device */
 109         struct usb_interface *intf;     /* the usb interface for this device */
 110         struct urb        *urbinfo;      /* urb for incoming reports      */
 111         dma_addr_t        buf_dma;  /* dma addr of the data buffer*/
 112         unsigned char *   buffer;   /* databuffer for reports */
 113
 114         char  usbpath[PATHLENGTH];
 115         int   openCount;
 116
 117         /* Information pulled from Report Descriptor */
 118         u32  usage;
 119         u32  min_X;
 120         u32  max_X;
 121         u32  min_Y;
 122         u32  max_Y;
 123         s8   mintilt_X;
 124         s8   maxtilt_X;
 125         s8   mintilt_Y;
 126         s8   maxtilt_Y;
 127         u32  maxpressure;
 128         u32  minpressure;
 129 };
 130
 131
 132
 133 /*   Code for parsing the HID REPORT DESCRIPTOR          */
 134
 135 /* From HID1.11 spec */
 136 struct hid_descriptor
 137 {
 138         struct usb_descriptor_header header;
 139         __le16   bcdHID;
 140         u8       bCountryCode;
 141         u8       bNumDescriptors;
 142         u8       bDescriptorType;
 143         __le16   wDescriptorLength;
 144 } __attribute__ ((packed));
 145
 146
 147 #define HID_DESCRIPTOR_SIZE   9
 148 #define HID_DEVICE_TYPE       33
 149 #define REPORT_DEVICE_TYPE    34
 150
 151
 152 #define PREF_TAG(x)     ((x)>>4)
 153 #define PREF_TYPE(x)    ((x>>2)&0x03)
 154 #define PREF_SIZE(x)    ((x)&0x03)
 155
 156 #define TYPE_MAIN       0
 157 #define TYPE_GLOBAL     1
 158 #define TYPE_LOCAL      2
 159 #define TYPE_RESERVED   3
 160
 161 #define TAG_MAIN_INPUT        0x8
 162 #define TAG_MAIN_OUTPUT       0x9
 163 #define TAG_MAIN_FEATURE      0xB
 164 #define TAG_MAIN_COL_START    0xA
 165 #define TAG_MAIN_COL_END      0xC
 166
 167 #define TAG_GLOB_USAGE        0
 168 #define TAG_GLOB_LOG_MIN      1
 169 #define TAG_GLOB_LOG_MAX      2
 170 #define TAG_GLOB_PHYS_MIN     3
 171 #define TAG_GLOB_PHYS_MAX     4
 172 #define TAG_GLOB_UNIT_EXP     5
 173 #define TAG_GLOB_UNIT         6
 174 #define TAG_GLOB_REPORT_SZ    7
 175 #define TAG_GLOB_REPORT_ID    8
 176 #define TAG_GLOB_REPORT_CNT   9
 177 #define TAG_GLOB_PUSH         10
 178 #define TAG_GLOB_POP          11
 179
 180 #define TAG_GLOB_MAX          12
 181
 182 #define DIGITIZER_USAGE_TIP_PRESSURE   0x30
 183 #define DIGITIZER_USAGE_TILT_X         0x3D
 184 #define DIGITIZER_USAGE_TILT_Y         0x3E
 185
 186
 187 /*
 188  *   This is an abbreviated parser for the HID Report Descriptor.  We
 189  *   know what devices we are talking to, so this is by no means meant
 190  *   to be generic.  We can make some safe assumptions:
 191  *
 192  *   - We know there are no LONG tags, all short
 193  *   - We know that we have no MAIN Feature and MAIN Output items
 194  *   - We know what the IRQ reports are supposed to look like.
 195  *
 196  *   The main purpose of this is to use the HID report desc to figure
 197  *   out the mins and maxs of the fields in the IRQ reports.  The IRQ
 198  *   reports for 400/401 change slightly if the max X is bigger than 64K.
 199  *
 200  */
 201 static void parse_hid_report_descriptor(struct gtco *device, char * report,
 202                                         int length)
 203 {
 204         struct device *ddev = &device->intf->dev;
 205         int   x, i = 0;
 206
 207         /* Tag primitive vars */
 208         __u8   prefix;
 209         __u8   size;
 210         __u8   tag;
 211         __u8   type;
 212         __u8   data   = 0;
 213         __u16  data16 = 0;
 214         __u32  data32 = 0;
 215
 216         /* For parsing logic */
 217         int   inputnum = 0;
 218         __u32 usage = 0;
 219
 220         /* Global Values, indexed by TAG */
 221         __u32 globalval[TAG_GLOB_MAX];
 222         __u32 oldval[TAG_GLOB_MAX];
 223
 224         /* Debug stuff */
 225         char  maintype = 'x';
 226         char  globtype[12];
 227         int   indent = 0;
 228         char  indentstr[10] = "";
 229
 230
 231         dev_dbg(ddev, "======>>>>>>PARSE<<<<<<======\n");
 232
 233         /* Walk  this report and pull out the info we need */
 234         while (i < length) {
 235                 prefix = report[i];
 236
 237                 /* Skip over prefix */
 238                 i++;
 239
 240                 /* Determine data size and save the data in the proper variable */
 241                 size = PREF_SIZE(prefix);
 242                 switch (size) {
 243                 case 1:
 244                         data = report[i];
 245                         break;
 246                 case 2:
 247                         data16 = get_unaligned_le16(&report[i]);
 248                         break;
 249                 case 3:
 250                         size = 4;
 251                         data32 = get_unaligned_le32(&report[i]);
 252                         break;
 253                 }
 254
 255                 /* Skip size of data */
 256                 i += size;
 257
 258                 /* What we do depends on the tag type */
 259                 tag  = PREF_TAG(prefix);
 260                 type = PREF_TYPE(prefix);
 261                 switch (type) {
 262                 case TYPE_MAIN:
 263                         strcpy(globtype, "");
 264                         switch (tag) {
 265
 266                         case TAG_MAIN_INPUT:
 267                                 /*
 268                                  * The INPUT MAIN tag signifies this is
 269                                  * information from a report.  We need to
 270                                  * figure out what it is and store the
 271                                  * min/max values
 272                                  */
 273
 274                                 maintype = 'I';
 275                                 if (data == 2)
 276                                         strcpy(globtype, "Variable");
 277                                 else if (data == 3)
 278                                         strcpy(globtype, "Var|Const");
 279
 280                                 dev_dbg(ddev, "::::: Saving Report: %d input #%d Max: 0x%X(%d) Min:0x%X(%d) of %d bits\n",
 281                                         globalval[TAG_GLOB_REPORT_ID], inputnum,
 282                                         globalval[TAG_GLOB_LOG_MAX], globalval[TAG_GLOB_LOG_MAX],
 283                                         globalval[TAG_GLOB_LOG_MIN], globalval[TAG_GLOB_LOG_MIN],
 284                                         globalval[TAG_GLOB_REPORT_SZ] * globalval[TAG_GLOB_REPORT_CNT]);
 285
 286
 287                                 /*
 288                                   We can assume that the first two input items
 289                                   are always the X and Y coordinates.  After
 290                                   that, we look for everything else by
 291                                   local usage value
 292                                  */
 293                                 switch (inputnum) {
 294                                 case 0:  /* X coord */
 295                                         dev_dbg(ddev, "GER: X Usage: 0x%x\n", usage);
 296                                         if (device->max_X == 0) {
 297                                                 device->max_X = globalval[TAG_GLOB_LOG_MAX];
 298                                                 device->min_X = globalval[TAG_GLOB_LOG_MIN];
 299                                         }
 300                                         break;
 301
 302                                 case 1:  /* Y coord */
 303                                         dev_dbg(ddev, "GER: Y Usage: 0x%x\n", usage);
 304                                         if (device->max_Y == 0) {
 305                                                 device->max_Y = globalval[TAG_GLOB_LOG_MAX];
 306                                                 device->min_Y = globalval[TAG_GLOB_LOG_MIN];
 307                                         }
 308                                         break;
 309
 310                                 default:
 311                                         /* Tilt X */
 312                                         if (usage == DIGITIZER_USAGE_TILT_X) {
 313                                                 if (device->maxtilt_X == 0) {
 314                                                         device->maxtilt_X = globalval[TAG_GLOB_LOG_MAX];
 315                                                         device->mintilt_X = globalval[TAG_GLOB_LOG_MIN];
 316                                                 }
 317                                         }
 318
 319                                         /* Tilt Y */
 320                                         if (usage == DIGITIZER_USAGE_TILT_Y) {
 321                                                 if (device->maxtilt_Y == 0) {
 322                                                         device->maxtilt_Y = globalval[TAG_GLOB_LOG_MAX];
 323                                                         device->mintilt_Y = globalval[TAG_GLOB_LOG_MIN];
 324                                                 }
 325                                         }
 326
 327                                         /* Pressure */
 328                                         if (usage == DIGITIZER_USAGE_TIP_PRESSURE) {
 329                                                 if (device->maxpressure == 0) {
 330                                                         device->maxpressure = globalval[TAG_GLOB_LOG_MAX];
 331                                                         device->minpressure = globalval[TAG_GLOB_LOG_MIN];
 332                                                 }
 333                                         }
 334
 335                                         break;
 336                                 }
 337
 338                                 inputnum++;
 339                                 break;
 340
 341                         case TAG_MAIN_OUTPUT:
 342                                 maintype = 'O';
 343                                 break;
 344
 345                         case TAG_MAIN_FEATURE:
 346                                 maintype = 'F';
 347                                 break;
 348
 349                         case TAG_MAIN_COL_START:
 350                                 maintype = 'S';
 351
 352                                 if (data == 0) {
 353                                         dev_dbg(ddev, "======>>>>>> Physical\n");
 354                                         strcpy(globtype, "Physical");
 355                                 } else
 356                                         dev_dbg(ddev, "======>>>>>>\n");
 357
 358                                 /* Indent the debug output */
 359                                 indent++;
 360                                 for (x = 0; x < indent; x++)
 361                                         indentstr[x] = '-';
 362                                 indentstr[x] = 0;
 363
 364                                 /* Save global tags */
 365                                 for (x = 0; x < TAG_GLOB_MAX; x++)
 366                                         oldval[x] = globalval[x];
 367
 368                                 break;
 369
 370                         case TAG_MAIN_COL_END:
 371                                 dev_dbg(ddev, "<<<<<<======\n");
 372                                 maintype = 'E';
 373                                 indent--;
 374                                 for (x = 0; x < indent; x++)
 375                                         indentstr[x] = '-';
 376                                 indentstr[x] = 0;
 377
 378                                 /* Copy global tags back */
 379                                 for (x = 0; x < TAG_GLOB_MAX; x++)
 380                                         globalval[x] = oldval[x];
 381
 382                                 break;
 383                         }
 384
 385                         switch (size) {
 386                         case 1:
 387                                 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
 388                                         indentstr, tag, maintype, size, globtype, data);
 389                                 break;
 390
 391                         case 2:
 392                                 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
 393                                         indentstr, tag, maintype, size, globtype, data16);
 394                                 break;
 395
 396                         case 4:
 397                                 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
 398                                         indentstr, tag, maintype, size, globtype, data32);
 399                                 break;
 400                         }
 401                         break;
 402
 403                 case TYPE_GLOBAL:
 404                         switch (tag) {
 405                         case TAG_GLOB_USAGE:
 406                                 /*
 407                                  * First time we hit the global usage tag,
 408                                  * it should tell us the type of device
 409                                  */
 410                                 if (device->usage == 0)
 411                                         device->usage = data;
 412
 413                                 strcpy(globtype, "USAGE");
 414                                 break;
 415
 416                         case TAG_GLOB_LOG_MIN:
 417                                 strcpy(globtype, "LOG_MIN");
 418                                 break;
 419
 420                         case TAG_GLOB_LOG_MAX:
 421                                 strcpy(globtype, "LOG_MAX");
 422                                 break;
 423
 424                         case TAG_GLOB_PHYS_MIN:
 425                                 strcpy(globtype, "PHYS_MIN");
 426                                 break;
 427
 428                         case TAG_GLOB_PHYS_MAX:
 429                                 strcpy(globtype, "PHYS_MAX");
 430                                 break;
 431
 432                         case TAG_GLOB_UNIT_EXP:
 433                                 strcpy(globtype, "EXP");
 434                                 break;
 435
 436                         case TAG_GLOB_UNIT:
 437                                 strcpy(globtype, "UNIT");
 438                                 break;
 439
 440                         case TAG_GLOB_REPORT_SZ:
 441                                 strcpy(globtype, "REPORT_SZ");
 442                                 break;
 443
 444                         case TAG_GLOB_REPORT_ID:
 445                                 strcpy(globtype, "REPORT_ID");
 446                                 /* New report, restart numbering */
 447                                 inputnum = 0;
 448                                 break;
 449
 450                         case TAG_GLOB_REPORT_CNT:
 451                                 strcpy(globtype, "REPORT_CNT");
 452                                 break;
 453
 454                         case TAG_GLOB_PUSH:
 455                                 strcpy(globtype, "PUSH");
 456                                 break;
 457
 458                         case TAG_GLOB_POP:
 459                                 strcpy(globtype, "POP");
 460                                 break;
 461                         }
 462
 463                         /* Check to make sure we have a good tag number
 464                            so we don't overflow array */
 465                         if (tag < TAG_GLOB_MAX) {
 466                                 switch (size) {
 467                                 case 1:
 468                                         dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
 469                                                 indentstr, globtype, tag, size, data);
 470                                         globalval[tag] = data;
 471                                         break;
 472
 473                                 case 2:
 474                                         dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
 475                                                 indentstr, globtype, tag, size, data16);
 476                                         globalval[tag] = data16;
 477                                         break;
 478
 479                                 case 4:
 480                                         dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
 481                                                 indentstr, globtype, tag, size, data32);
 482                                         globalval[tag] = data32;
 483                                         break;
 484                                 }
 485                         } else {
 486                                 dev_dbg(ddev, "%sGLOBALTAG: ILLEGAL TAG:%d SIZE: %d\n",
 487                                         indentstr, tag, size);
 488                         }
 489                         break;
 490
 491                 case TYPE_LOCAL:
 492                         switch (tag) {
 493                         case TAG_GLOB_USAGE:
 494                                 strcpy(globtype, "USAGE");
 495                                 /* Always 1 byte */
 496                                 usage = data;
 497                                 break;
 498
 499                         case TAG_GLOB_LOG_MIN:
 500                                 strcpy(globtype, "MIN");
 501                                 break;
 502
 503                         case TAG_GLOB_LOG_MAX:
 504                                 strcpy(globtype, "MAX");
 505                                 break;
 506
 507                         default:
 508                                 strcpy(globtype, "UNKNOWN");
 509                                 break;
 510                         }
 511
 512                         switch (size) {
 513                         case 1:
 514                                 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
 515                                         indentstr, tag, globtype, size, data);
 516                                 break;
 517
 518                         case 2:
 519                                 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
 520                                         indentstr, tag, globtype, size, data16);
 521                                 break;
 522
 523                         case 4:
 524                                 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
 525                                         indentstr, tag, globtype, size, data32);
 526                                 break;
 527                         }
 528
 529                         break;
 530                 }
 531         }
 532 }
 533
 534 /*   INPUT DRIVER Routines                               */
 535
 536 /*
 537  * Called when opening the input device.  This will submit the URB to
 538  * the usb system so we start getting reports
 539  */
 540 static int gtco_input_open(struct input_dev *inputdev)
 541 {
 542         struct gtco *device = input_get_drvdata(inputdev);
 543
 544         device->urbinfo->dev = device->usbdev;
 545         if (usb_submit_urb(device->urbinfo, GFP_KERNEL))
 546                 return -EIO;
 547
 548         return 0;
 549 }
 550
 551 /*
 552  * Called when closing the input device.  This will unlink the URB
 553  */
 554 static void gtco_input_close(struct input_dev *inputdev)
 555 {
 556         struct gtco *device = input_get_drvdata(inputdev);
 557
 558         usb_kill_urb(device->urbinfo);
 559 }
 560
 561
 562 /*
 563  *  Setup input device capabilities.  Tell the input system what this
 564  *  device is capable of generating.
 565  *
 566  *  This information is based on what is read from the HID report and
 567  *  placed in the struct gtco structure
 568  *
 569  */
 570 static void gtco_setup_caps(struct input_dev *inputdev)
 571 {
 572         struct gtco *device = input_get_drvdata(inputdev);
 573
 574         /* Which events */
 575         inputdev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) |
 576                 BIT_MASK(EV_MSC);
 577
 578         /* Misc event menu block */
 579         inputdev->mscbit[0] = BIT_MASK(MSC_SCAN) | BIT_MASK(MSC_SERIAL) |
 580                 BIT_MASK(MSC_RAW);
 581
 582         /* Absolute values based on HID report info */
 583         input_set_abs_params(inputdev, ABS_X, device->min_X, device->max_X,
 584                              0, 0);
 585         input_set_abs_params(inputdev, ABS_Y, device->min_Y, device->max_Y,
 586                              0, 0);
 587
 588         /* Proximity */
 589         input_set_abs_params(inputdev, ABS_DISTANCE, 0, 1, 0, 0);
 590
 591         /* Tilt & pressure */
 592         input_set_abs_params(inputdev, ABS_TILT_X, device->mintilt_X,
 593                              device->maxtilt_X, 0, 0);
 594         input_set_abs_params(inputdev, ABS_TILT_Y, device->mintilt_Y,
 595                              device->maxtilt_Y, 0, 0);
 596         input_set_abs_params(inputdev, ABS_PRESSURE, device->minpressure,
 597                              device->maxpressure, 0, 0);
 598
 599         /* Transducer */
 600         input_set_abs_params(inputdev, ABS_MISC, 0, 0xFF, 0, 0);
 601 }
 602
 603 /*   USB Routines  */
 604
 605 /*
 606  * URB callback routine.  Called when we get IRQ reports from the
 607  *  digitizer.
 608  *
 609  *  This bridges the USB and input device worlds.  It generates events
 610  *  on the input device based on the USB reports.
 611  */
 612 static void gtco_urb_callback(struct urb *urbinfo)
 613 {
 614         struct gtco *device = urbinfo->context;
 615         struct input_dev  *inputdev;
 616         int               rc;
 617         u32               val = 0;
 618         s8                valsigned = 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
 670                         /* Sign extend these 7 bit numbers.  */
 671                         if (device->buffer[6] & 0x40)
 672                                 device->buffer[6] |= 0x80;
 673
 674                         if (device->buffer[7] & 0x40)
 675                                 device->buffer[7] |= 0x80;
 676
 677
 678                         valsigned = (device->buffer[6]);
 679                         input_report_abs(inputdev, ABS_TILT_X, (s32)valsigned);
 680
 681                         valsigned = (device->buffer[7]);
 682                         input_report_abs(inputdev, ABS_TILT_Y, (s32)valsigned);
 683
 684                         /* Fall thru */
 685                 case 2:
 686                 case 3:
 687                         /* Convert buttons, only 5 bits possible */
 688                         val = (device->buffer[5]) & MASK_BUTTON;
 689
 690                         /* We don't apply any meaning to the bitmask,
 691                            just report */
 692                         input_event(inputdev, EV_MSC, MSC_SERIAL, val);
 693
 694                         /*  Fall thru */
 695                 case 1:
 696                         /* All reports have X and Y coords in the same place */
 697                         val = get_unaligned_le16(&device->buffer[1]);
 698                         input_report_abs(inputdev, ABS_X, val);
 699
 700                         val = get_unaligned_le16(&device->buffer[3]);
 701                         input_report_abs(inputdev, ABS_Y, val);
 702
 703                         /* Ditto for proximity bit */
 704                         val = device->buffer[5] & MASK_INRANGE ? 1 : 0;
 705                         input_report_abs(inputdev, ABS_DISTANCE, val);
 706
 707                         /* Report 1 is an exception to how we handle buttons */
 708                         /* Buttons are an index, not a bitmask */
 709                         if (device->buffer[0] == 1) {
 710
 711                                 /*
 712                                  * Convert buttons, 5 bit index
 713                                  * Report value of index set as one,
 714                                  * the rest as 0
 715                                  */
 716                                 val = device->buffer[5] & MASK_BUTTON;
 717                                 dev_dbg(&device->intf->dev,
 718                                         "======>>>>>>REPORT 1: val 0x%X(%d)\n",
 719                                         val, val);
 720
 721                                 /*
 722                                  * We don't apply any meaning to the button
 723                                  * index, just report it
 724                                  */
 725                                 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
 726                         }
 727                         break;
 728
 729                 case 7:
 730                         /* Menu blocks */
 731                         input_event(inputdev, EV_MSC, MSC_SCAN,
 732                                     device->buffer[1]);
 733                         break;
 734                 }
 735         }
 736
 737         /* Other pid class */
 738         if (inputdev->id.product == PID_400 ||
 739             inputdev->id.product == PID_401) {
 740
 741                 /* Report 2 */
 742                 if (device->buffer[0] == 2) {
 743                         /* Menu blocks */
 744                         input_event(inputdev, EV_MSC, MSC_SCAN, device->buffer[1]);
 745                 }
 746
 747                 /*  Report 1 */
 748                 if (device->buffer[0] == 1) {
 749                         char buttonbyte;
 750
 751                         /*  IF X max > 64K, we still a bit from the y report */
 752                         if (device->max_X > 0x10000) {
 753
 754                                 val = (u16)(((u16)(device->buffer[2] << 8)) | (u8)device->buffer[1]);
 755                                 val |= (u32)(((u8)device->buffer[3] & 0x1) << 16);
 756
 757                                 input_report_abs(inputdev, ABS_X, val);
 758
 759                                 le_buffer[0]  = (u8)((u8)(device->buffer[3]) >> 1);
 760                                 le_buffer[0] |= (u8)((device->buffer[3] & 0x1) << 7);
 761
 762                                 le_buffer[1]  = (u8)(device->buffer[4] >> 1);
 763                                 le_buffer[1] |= (u8)((device->buffer[5] & 0x1) << 7);
 764
 765                                 val = get_unaligned_le16(le_buffer);
 766                                 input_report_abs(inputdev, ABS_Y, val);
 767
 768                                 /*
 769                                  * Shift the button byte right by one to
 770                                  * make it look like the standard report
 771                                  */
 772                                 buttonbyte = device->buffer[5] >> 1;
 773                         } else {
 774
 775                                 val = get_unaligned_le16(&device->buffer[1]);
 776                                 input_report_abs(inputdev, ABS_X, val);
 777
 778                                 val = get_unaligned_le16(&device->buffer[3]);
 779                                 input_report_abs(inputdev, ABS_Y, val);
 780
 781                                 buttonbyte = device->buffer[5];
 782                         }
 783
 784                         /* BUTTONS and PROXIMITY */
 785                         val = buttonbyte & MASK_INRANGE ? 1 : 0;
 786                         input_report_abs(inputdev, ABS_DISTANCE, val);
 787
 788                         /* Convert buttons, only 4 bits possible */
 789                         val = buttonbyte & 0x0F;
 790 #ifdef USE_BUTTONS
 791                         for (i = 0; i < 5; i++)
 792                                 input_report_key(inputdev, BTN_DIGI + i, val & (1 << i));
 793 #else
 794                         /* We don't apply any meaning to the bitmask, just report */
 795                         input_event(inputdev, EV_MSC, MSC_SERIAL, val);
 796 #endif
 797
 798                         /* TRANSDUCER */
 799                         input_report_abs(inputdev, ABS_MISC, device->buffer[6]);
 800                 }
 801         }
 802
 803         /* Everybody gets report ID's */
 804         input_event(inputdev, EV_MSC, MSC_RAW,  device->buffer[0]);
 805
 806         /* Sync it up */
 807         input_sync(inputdev);
 808
 809  resubmit:
 810         rc = usb_submit_urb(urbinfo, GFP_ATOMIC);
 811         if (rc != 0)
 812                 dev_err(&device->intf->dev,
 813                         "usb_submit_urb failed rc=0x%x\n", rc);
 814 }
 815
 816 /*
 817  *  The probe routine.  This is called when the kernel find the matching USB
 818  *   vendor/product.  We do the following:
 819  *
 820  *    - Allocate mem for a local structure to manage the device
 821  *    - Request a HID Report Descriptor from the device and parse it to
 822  *      find out the device parameters
 823  *    - Create an input device and assign it attributes
 824  *   - Allocate an URB so the device can talk to us when the input
 825  *      queue is open
 826  */
 827 static int gtco_probe(struct usb_interface *usbinterface,
 828                       const struct usb_device_id *id)
 829 {
 830
 831         struct gtco             *gtco;
 832         struct input_dev        *input_dev;
 833         struct hid_descriptor   *hid_desc;
 834         char                    *report;
 835         int                     result = 0, retry;
 836         int                     error;
 837         struct usb_endpoint_descriptor *endpoint;
 838
 839         /* Allocate memory for device structure */
 840         gtco = kzalloc(sizeof(struct gtco), GFP_KERNEL);
 841         input_dev = input_allocate_device();
 842         if (!gtco || !input_dev) {
 843                 dev_err(&usbinterface->dev, "No more memory\n");
 844                 error = -ENOMEM;
 845                 goto err_free_devs;
 846         }
 847
 848         /* Set pointer to the input device */
 849         gtco->inputdevice = input_dev;
 850
 851         /* Save interface information */
 852         gtco->usbdev = usb_get_dev(interface_to_usbdev(usbinterface));
 853         gtco->intf = usbinterface;
 854
 855         /* Allocate some data for incoming reports */
 856         gtco->buffer = usb_alloc_coherent(gtco->usbdev, REPORT_MAX_SIZE,
 857                                           GFP_KERNEL, &gtco->buf_dma);
 858         if (!gtco->buffer) {
 859                 dev_err(&usbinterface->dev, "No more memory for us buffers\n");
 860                 error = -ENOMEM;
 861                 goto err_free_devs;
 862         }
 863
 864         /* Allocate URB for reports */
 865         gtco->urbinfo = usb_alloc_urb(0, GFP_KERNEL);
 866         if (!gtco->urbinfo) {
 867                 dev_err(&usbinterface->dev, "Failed to allocate URB\n");
 868                 error = -ENOMEM;
 869                 goto err_free_buf;
 870         }
 871
 872         /*
 873          * The endpoint is always altsetting 0, we know this since we know
 874          * this device only has one interrupt endpoint
 875          */
 876         endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
 877
 878         /* Some debug */
 879         dev_dbg(&usbinterface->dev, "gtco # interfaces: %d\n", usbinterface->num_altsetting);
 880         dev_dbg(&usbinterface->dev, "num endpoints:     %d\n", usbinterface->cur_altsetting->desc.bNumEndpoints);
 881         dev_dbg(&usbinterface->dev, "interface class:   %d\n", usbinterface->cur_altsetting->desc.bInterfaceClass);
 882         dev_dbg(&usbinterface->dev, "endpoint: attribute:0x%x type:0x%x\n", endpoint->bmAttributes, endpoint->bDescriptorType);
 883         if (usb_endpoint_xfer_int(endpoint))
 884                 dev_dbg(&usbinterface->dev, "endpoint: we have interrupt endpoint\n");
 885
 886         dev_dbg(&usbinterface->dev, "endpoint extra len:%d\n", usbinterface->altsetting[0].extralen);
 887
 888         /*
 889          * Find the HID descriptor so we can find out the size of the
 890          * HID report descriptor
 891          */
 892         if (usb_get_extra_descriptor(usbinterface->cur_altsetting,
 893                                      HID_DEVICE_TYPE, &hid_desc) != 0){
 894                 dev_err(&usbinterface->dev,
 895                         "Can't retrieve exta USB descriptor to get hid report descriptor length\n");
 896                 error = -EIO;
 897                 goto err_free_urb;
 898         }
 899
 900         dev_dbg(&usbinterface->dev,
 901                 "Extra descriptor success: type:%d  len:%d\n",
 902                 hid_desc->bDescriptorType,  hid_desc->wDescriptorLength);
 903
 904         report = kzalloc(le16_to_cpu(hid_desc->wDescriptorLength), GFP_KERNEL);
 905         if (!report) {
 906                 dev_err(&usbinterface->dev, "No more memory for report\n");
 907                 error = -ENOMEM;
 908                 goto err_free_urb;
 909         }
 910
 911         /* Couple of tries to get reply */
 912         for (retry = 0; retry < 3; retry++) {
 913                 result = usb_control_msg(gtco->usbdev,
 914                                          usb_rcvctrlpipe(gtco->usbdev, 0),
 915                                          USB_REQ_GET_DESCRIPTOR,
 916                                          USB_RECIP_INTERFACE | USB_DIR_IN,
 917                                          REPORT_DEVICE_TYPE << 8,
 918                                          0, /* interface */
 919                                          report,
 920                                          le16_to_cpu(hid_desc->wDescriptorLength),
 921                                          5000); /* 5 secs */
 922
 923                 dev_dbg(&usbinterface->dev, "usb_control_msg result: %d\n", result);
 924                 if (result == le16_to_cpu(hid_desc->wDescriptorLength)) {
 925                         parse_hid_report_descriptor(gtco, report, result);
 926                         break;
 927                 }
 928         }
 929
 930         kfree(report);
 931
 932         /* If we didn't get the report, fail */
 933         if (result != le16_to_cpu(hid_desc->wDescriptorLength)) {
 934                 dev_err(&usbinterface->dev,
 935                         "Failed to get HID Report Descriptor of size: %d\n",
 936                         hid_desc->wDescriptorLength);
 937                 error = -EIO;
 938                 goto err_free_urb;
 939         }
 940
 941         /* Create a device file node */
 942         usb_make_path(gtco->usbdev, gtco->usbpath, sizeof(gtco->usbpath));
 943         strlcat(gtco->usbpath, "/input0", sizeof(gtco->usbpath));
 944
 945         /* Set Input device functions */
 946         input_dev->open = gtco_input_open;
 947         input_dev->close = gtco_input_close;
 948
 949         /* Set input device information */
 950         input_dev->name = "GTCO_CalComp";
 951         input_dev->phys = gtco->usbpath;
 952
 953         input_set_drvdata(input_dev, gtco);
 954
 955         /* Now set up all the input device capabilities */
 956         gtco_setup_caps(input_dev);
 957
 958         /* Set input device required ID information */
 959         usb_to_input_id(gtco->usbdev, &input_dev->id);
 960         input_dev->dev.parent = &usbinterface->dev;
 961
 962         /* Setup the URB, it will be posted later on open of input device */
 963         endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
 964
 965         usb_fill_int_urb(gtco->urbinfo,
 966                          gtco->usbdev,
 967                          usb_rcvintpipe(gtco->usbdev,
 968                                         endpoint->bEndpointAddress),
 969                          gtco->buffer,
 970                          REPORT_MAX_SIZE,
 971                          gtco_urb_callback,
 972                          gtco,
 973                          endpoint->bInterval);
 974
 975         gtco->urbinfo->transfer_dma = gtco->buf_dma;
 976         gtco->urbinfo->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 977
 978         /* Save gtco pointer in USB interface gtco */
 979         usb_set_intfdata(usbinterface, gtco);
 980
 981         /* All done, now register the input device */
 982         error = input_register_device(input_dev);
 983         if (error)
 984                 goto err_free_urb;
 985
 986         return 0;
 987
 988  err_free_urb:
 989         usb_free_urb(gtco->urbinfo);
 990  err_free_buf:
 991         usb_free_coherent(gtco->usbdev, REPORT_MAX_SIZE,
 992                           gtco->buffer, gtco->buf_dma);
 993  err_free_devs:
 994         input_free_device(input_dev);
 995         kfree(gtco);
 996         return error;
 997 }
 998
 999 /*
1000  *  This function is a standard USB function called when the USB device
1001  *  is disconnected.  We will get rid of the URV, de-register the input
1002  *  device, and free up allocated memory
1003  */
1004 static void gtco_disconnect(struct usb_interface *interface)
1005 {
1006         /* Grab private device ptr */
1007         struct gtco *gtco = usb_get_intfdata(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(gtco->usbdev, 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");