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
  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_device *usbdev; /* the usb device for this device */
 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[10] = "";
 228
 229
 230         dev_dbg(ddev, "======>>>>>>PARSE<<<<<<======\n");
 231
 232         /* Walk  this report and pull out the info we need */
 233         while (i < length) {
 234                 prefix = report[i];
 235
 236                 /* Skip over prefix */
 237                 i++;
 238
 239                 /* Determine data size and save the data in the proper variable */
 240                 size = PREF_SIZE(prefix);
 241                 switch (size) {
 242                 case 1:
 243                         data = report[i];
 244                         break;
 245                 case 2:
 246                         data16 = get_unaligned_le16(&report[i]);
 247                         break;
 248                 case 3:
 249                         size = 4;
 250                         data32 = get_unaligned_le32(&report[i]);
 251                         break;
 252                 }
 253
 254                 /* Skip size of data */
 255                 i += size;
 256
 257                 /* What we do depends on the tag type */
 258                 tag  = PREF_TAG(prefix);
 259                 type = PREF_TYPE(prefix);
 260                 switch (type) {
 261                 case TYPE_MAIN:
 262                         strcpy(globtype, "");
 263                         switch (tag) {
 264
 265                         case TAG_MAIN_INPUT:
 266                                 /*
 267                                  * The INPUT MAIN tag signifies this is
 268                                  * information from a report.  We need to
 269                                  * figure out what it is and store the
 270                                  * min/max values
 271                                  */
 272
 273                                 maintype = 'I';
 274                                 if (data == 2)
 275                                         strcpy(globtype, "Variable");
 276                                 else if (data == 3)
 277                                         strcpy(globtype, "Var|Const");
 278
 279                                 dev_dbg(ddev, "::::: Saving Report: %d input #%d Max: 0x%X(%d) Min:0x%X(%d) of %d bits\n",
 280                                         globalval[TAG_GLOB_REPORT_ID], inputnum,
 281                                         globalval[TAG_GLOB_LOG_MAX], globalval[TAG_GLOB_LOG_MAX],
 282                                         globalval[TAG_GLOB_LOG_MIN], globalval[TAG_GLOB_LOG_MIN],
 283                                         globalval[TAG_GLOB_REPORT_SZ] * globalval[TAG_GLOB_REPORT_CNT]);
 284
 285
 286                                 /*
 287                                   We can assume that the first two input items
 288                                   are always the X and Y coordinates.  After
 289                                   that, we look for everything else by
 290                                   local usage value
 291                                  */
 292                                 switch (inputnum) {
 293                                 case 0:  /* X coord */
 294                                         dev_dbg(ddev, "GER: X Usage: 0x%x\n", usage);
 295                                         if (device->max_X == 0) {
 296                                                 device->max_X = globalval[TAG_GLOB_LOG_MAX];
 297                                                 device->min_X = globalval[TAG_GLOB_LOG_MIN];
 298                                         }
 299                                         break;
 300
 301                                 case 1:  /* Y coord */
 302                                         dev_dbg(ddev, "GER: Y Usage: 0x%x\n", usage);
 303                                         if (device->max_Y == 0) {
 304                                                 device->max_Y = globalval[TAG_GLOB_LOG_MAX];
 305                                                 device->min_Y = globalval[TAG_GLOB_LOG_MIN];
 306                                         }
 307                                         break;
 308
 309                                 default:
 310                                         /* Tilt X */
 311                                         if (usage == DIGITIZER_USAGE_TILT_X) {
 312                                                 if (device->maxtilt_X == 0) {
 313                                                         device->maxtilt_X = globalval[TAG_GLOB_LOG_MAX];
 314                                                         device->mintilt_X = globalval[TAG_GLOB_LOG_MIN];
 315                                                 }
 316                                         }
 317
 318                                         /* Tilt Y */
 319                                         if (usage == DIGITIZER_USAGE_TILT_Y) {
 320                                                 if (device->maxtilt_Y == 0) {
 321                                                         device->maxtilt_Y = globalval[TAG_GLOB_LOG_MAX];
 322                                                         device->mintilt_Y = globalval[TAG_GLOB_LOG_MIN];
 323                                                 }
 324                                         }
 325
 326                                         /* Pressure */
 327                                         if (usage == DIGITIZER_USAGE_TIP_PRESSURE) {
 328                                                 if (device->maxpressure == 0) {
 329                                                         device->maxpressure = globalval[TAG_GLOB_LOG_MAX];
 330                                                         device->minpressure = globalval[TAG_GLOB_LOG_MIN];
 331                                                 }
 332                                         }
 333
 334                                         break;
 335                                 }
 336
 337                                 inputnum++;
 338                                 break;
 339
 340                         case TAG_MAIN_OUTPUT:
 341                                 maintype = 'O';
 342                                 break;
 343
 344                         case TAG_MAIN_FEATURE:
 345                                 maintype = 'F';
 346                                 break;
 347
 348                         case TAG_MAIN_COL_START:
 349                                 maintype = 'S';
 350
 351                                 if (data == 0) {
 352                                         dev_dbg(ddev, "======>>>>>> Physical\n");
 353                                         strcpy(globtype, "Physical");
 354                                 } else
 355                                         dev_dbg(ddev, "======>>>>>>\n");
 356
 357                                 /* Indent the debug output */
 358                                 indent++;
 359                                 for (x = 0; x < indent; x++)
 360                                         indentstr[x] = '-';
 361                                 indentstr[x] = 0;
 362
 363                                 /* Save global tags */
 364                                 for (x = 0; x < TAG_GLOB_MAX; x++)
 365                                         oldval[x] = globalval[x];
 366
 367                                 break;
 368
 369                         case TAG_MAIN_COL_END:
 370                                 dev_dbg(ddev, "<<<<<<======\n");
 371                                 maintype = 'E';
 372                                 indent--;
 373                                 for (x = 0; x < indent; x++)
 374                                         indentstr[x] = '-';
 375                                 indentstr[x] = 0;
 376
 377                                 /* Copy global tags back */
 378                                 for (x = 0; x < TAG_GLOB_MAX; x++)
 379                                         globalval[x] = oldval[x];
 380
 381                                 break;
 382                         }
 383
 384                         switch (size) {
 385                         case 1:
 386                                 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
 387                                         indentstr, tag, maintype, size, globtype, data);
 388                                 break;
 389
 390                         case 2:
 391                                 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
 392                                         indentstr, tag, maintype, size, globtype, data16);
 393                                 break;
 394
 395                         case 4:
 396                                 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
 397                                         indentstr, tag, maintype, size, globtype, data32);
 398                                 break;
 399                         }
 400                         break;
 401
 402                 case TYPE_GLOBAL:
 403                         switch (tag) {
 404                         case TAG_GLOB_USAGE:
 405                                 /*
 406                                  * First time we hit the global usage tag,
 407                                  * it should tell us the type of device
 408                                  */
 409                                 if (device->usage == 0)
 410                                         device->usage = data;
 411
 412                                 strcpy(globtype, "USAGE");
 413                                 break;
 414
 415                         case TAG_GLOB_LOG_MIN:
 416                                 strcpy(globtype, "LOG_MIN");
 417                                 break;
 418
 419                         case TAG_GLOB_LOG_MAX:
 420                                 strcpy(globtype, "LOG_MAX");
 421                                 break;
 422
 423                         case TAG_GLOB_PHYS_MIN:
 424                                 strcpy(globtype, "PHYS_MIN");
 425                                 break;
 426
 427                         case TAG_GLOB_PHYS_MAX:
 428                                 strcpy(globtype, "PHYS_MAX");
 429                                 break;
 430
 431                         case TAG_GLOB_UNIT_EXP:
 432                                 strcpy(globtype, "EXP");
 433                                 break;
 434
 435                         case TAG_GLOB_UNIT:
 436                                 strcpy(globtype, "UNIT");
 437                                 break;
 438
 439                         case TAG_GLOB_REPORT_SZ:
 440                                 strcpy(globtype, "REPORT_SZ");
 441                                 break;
 442
 443                         case TAG_GLOB_REPORT_ID:
 444                                 strcpy(globtype, "REPORT_ID");
 445                                 /* New report, restart numbering */
 446                                 inputnum = 0;
 447                                 break;
 448
 449                         case TAG_GLOB_REPORT_CNT:
 450                                 strcpy(globtype, "REPORT_CNT");
 451                                 break;
 452
 453                         case TAG_GLOB_PUSH:
 454                                 strcpy(globtype, "PUSH");
 455                                 break;
 456
 457                         case TAG_GLOB_POP:
 458                                 strcpy(globtype, "POP");
 459                                 break;
 460                         }
 461
 462                         /* Check to make sure we have a good tag number
 463                            so we don't overflow array */
 464                         if (tag < TAG_GLOB_MAX) {
 465                                 switch (size) {
 466                                 case 1:
 467                                         dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
 468                                                 indentstr, globtype, tag, size, data);
 469                                         globalval[tag] = data;
 470                                         break;
 471
 472                                 case 2:
 473                                         dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
 474                                                 indentstr, globtype, tag, size, data16);
 475                                         globalval[tag] = data16;
 476                                         break;
 477
 478                                 case 4:
 479                                         dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
 480                                                 indentstr, globtype, tag, size, data32);
 481                                         globalval[tag] = data32;
 482                                         break;
 483                                 }
 484                         } else {
 485                                 dev_dbg(ddev, "%sGLOBALTAG: ILLEGAL TAG:%d SIZE: %d\n",
 486                                         indentstr, tag, size);
 487                         }
 488                         break;
 489
 490                 case TYPE_LOCAL:
 491                         switch (tag) {
 492                         case TAG_GLOB_USAGE:
 493                                 strcpy(globtype, "USAGE");
 494                                 /* Always 1 byte */
 495                                 usage = data;
 496                                 break;
 497
 498                         case TAG_GLOB_LOG_MIN:
 499                                 strcpy(globtype, "MIN");
 500                                 break;
 501
 502                         case TAG_GLOB_LOG_MAX:
 503                                 strcpy(globtype, "MAX");
 504                                 break;
 505
 506                         default:
 507                                 strcpy(globtype, "UNKNOWN");
 508                                 break;
 509                         }
 510
 511                         switch (size) {
 512                         case 1:
 513                                 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
 514                                         indentstr, tag, globtype, size, data);
 515                                 break;
 516
 517                         case 2:
 518                                 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
 519                                         indentstr, tag, globtype, size, data16);
 520                                 break;
 521
 522                         case 4:
 523                                 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
 524                                         indentstr, tag, globtype, size, data32);
 525                                 break;
 526                         }
 527
 528                         break;
 529                 }
 530         }
 531 }
 532
 533 /*   INPUT DRIVER Routines                               */
 534
 535 /*
 536  * Called when opening the input device.  This will submit the URB to
 537  * the usb system so we start getting reports
 538  */
 539 static int gtco_input_open(struct input_dev *inputdev)
 540 {
 541         struct gtco *device = input_get_drvdata(inputdev);
 542
 543         device->urbinfo->dev = device->usbdev;
 544         if (usb_submit_urb(device->urbinfo, GFP_KERNEL))
 545                 return -EIO;
 546
 547         return 0;
 548 }
 549
 550 /*
 551  * Called when closing the input device.  This will unlink the URB
 552  */
 553 static void gtco_input_close(struct input_dev *inputdev)
 554 {
 555         struct gtco *device = input_get_drvdata(inputdev);
 556
 557         usb_kill_urb(device->urbinfo);
 558 }
 559
 560
 561 /*
 562  *  Setup input device capabilities.  Tell the input system what this
 563  *  device is capable of generating.
 564  *
 565  *  This information is based on what is read from the HID report and
 566  *  placed in the struct gtco structure
 567  *
 568  */
 569 static void gtco_setup_caps(struct input_dev *inputdev)
 570 {
 571         struct gtco *device = input_get_drvdata(inputdev);
 572
 573         /* Which events */
 574         inputdev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) |
 575                 BIT_MASK(EV_MSC);
 576
 577         /* Misc event menu block */
 578         inputdev->mscbit[0] = BIT_MASK(MSC_SCAN) | BIT_MASK(MSC_SERIAL) |
 579                 BIT_MASK(MSC_RAW);
 580
 581         /* Absolute values based on HID report info */
 582         input_set_abs_params(inputdev, ABS_X, device->min_X, device->max_X,
 583                              0, 0);
 584         input_set_abs_params(inputdev, ABS_Y, device->min_Y, device->max_Y,
 585                              0, 0);
 586
 587         /* Proximity */
 588         input_set_abs_params(inputdev, ABS_DISTANCE, 0, 1, 0, 0);
 589
 590         /* Tilt & pressure */
 591         input_set_abs_params(inputdev, ABS_TILT_X, device->mintilt_X,
 592                              device->maxtilt_X, 0, 0);
 593         input_set_abs_params(inputdev, ABS_TILT_Y, device->mintilt_Y,
 594                              device->maxtilt_Y, 0, 0);
 595         input_set_abs_params(inputdev, ABS_PRESSURE, device->minpressure,
 596                              device->maxpressure, 0, 0);
 597
 598         /* Transducer */
 599         input_set_abs_params(inputdev, ABS_MISC, 0, 0xFF, 0, 0);
 600 }
 601
 602 /*   USB Routines  */
 603
 604 /*
 605  * URB callback routine.  Called when we get IRQ reports from the
 606  *  digitizer.
 607  *
 608  *  This bridges the USB and input device worlds.  It generates events
 609  *  on the input device based on the USB reports.
 610  */
 611 static void gtco_urb_callback(struct urb *urbinfo)
 612 {
 613         struct gtco *device = urbinfo->context;
 614         struct input_dev  *inputdev;
 615         int               rc;
 616         u32               val = 0;
 617         s8                valsigned = 0;
 618         char              le_buffer[2];
 619
 620         inputdev = device->inputdevice;
 621
 622         /* Was callback OK? */
 623         if (urbinfo->status == -ECONNRESET ||
 624             urbinfo->status == -ENOENT ||
 625             urbinfo->status == -ESHUTDOWN) {
 626
 627                 /* Shutdown is occurring. Return and don't queue up any more */
 628                 return;
 629         }
 630
 631         if (urbinfo->status != 0) {
 632                 /*
 633                  * Some unknown error.  Hopefully temporary. Just go and
 634                  * requeue an URB
 635                  */
 636                 goto resubmit;
 637         }
 638
 639         /*
 640          * Good URB, now process
 641          */
 642
 643         /* PID dependent when we interpret the report */
 644         if (inputdev->id.product == PID_1000 ||
 645             inputdev->id.product == PID_1001 ||
 646             inputdev->id.product == PID_1002) {
 647
 648                 /*
 649                  * Switch on the report ID
 650                  * Conveniently, the reports have more information, the higher
 651                  * the report number.  We can just fall through the case
 652                  * statements if we start with the highest number report
 653                  */
 654                 switch (device->buffer[0]) {
 655                 case 5:
 656                         /* Pressure is 9 bits */
 657                         val = ((u16)(device->buffer[8]) << 1);
 658                         val |= (u16)(device->buffer[7] >> 7);
 659                         input_report_abs(inputdev, ABS_PRESSURE,
 660                                          device->buffer[8]);
 661
 662                         /* Mask out the Y tilt value used for pressure */
 663                         device->buffer[7] = (u8)((device->buffer[7]) & 0x7F);
 664
 665                         /* Fall thru */
 666                 case 4:
 667                         /* Tilt */
 668
 669                         /* Sign extend these 7 bit numbers.  */
 670                         if (device->buffer[6] & 0x40)
 671                                 device->buffer[6] |= 0x80;
 672
 673                         if (device->buffer[7] & 0x40)
 674                                 device->buffer[7] |= 0x80;
 675
 676
 677                         valsigned = (device->buffer[6]);
 678                         input_report_abs(inputdev, ABS_TILT_X, (s32)valsigned);
 679
 680                         valsigned = (device->buffer[7]);
 681                         input_report_abs(inputdev, ABS_TILT_Y, (s32)valsigned);
 682
 683                         /* Fall thru */
 684                 case 2:
 685                 case 3:
 686                         /* Convert buttons, only 5 bits possible */
 687                         val = (device->buffer[5]) & MASK_BUTTON;
 688
 689                         /* We don't apply any meaning to the bitmask,
 690                            just report */
 691                         input_event(inputdev, EV_MSC, MSC_SERIAL, val);
 692
 693                         /*  Fall thru */
 694                 case 1:
 695                         /* All reports have X and Y coords in the same place */
 696                         val = get_unaligned_le16(&device->buffer[1]);
 697                         input_report_abs(inputdev, ABS_X, val);
 698
 699                         val = get_unaligned_le16(&device->buffer[3]);
 700                         input_report_abs(inputdev, ABS_Y, val);
 701
 702                         /* Ditto for proximity bit */
 703                         val = device->buffer[5] & MASK_INRANGE ? 1 : 0;
 704                         input_report_abs(inputdev, ABS_DISTANCE, val);
 705
 706                         /* Report 1 is an exception to how we handle buttons */
 707                         /* Buttons are an index, not a bitmask */
 708                         if (device->buffer[0] == 1) {
 709
 710                                 /*
 711                                  * Convert buttons, 5 bit index
 712                                  * Report value of index set as one,
 713                                  * the rest as 0
 714                                  */
 715                                 val = device->buffer[5] & MASK_BUTTON;
 716                                 dev_dbg(&device->intf->dev,
 717                                         "======>>>>>>REPORT 1: val 0x%X(%d)\n",
 718                                         val, val);
 719
 720                                 /*
 721                                  * We don't apply any meaning to the button
 722                                  * index, just report it
 723                                  */
 724                                 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
 725                         }
 726                         break;
 727
 728                 case 7:
 729                         /* Menu blocks */
 730                         input_event(inputdev, EV_MSC, MSC_SCAN,
 731                                     device->buffer[1]);
 732                         break;
 733                 }
 734         }
 735
 736         /* Other pid class */
 737         if (inputdev->id.product == PID_400 ||
 738             inputdev->id.product == PID_401) {
 739
 740                 /* Report 2 */
 741                 if (device->buffer[0] == 2) {
 742                         /* Menu blocks */
 743                         input_event(inputdev, EV_MSC, MSC_SCAN, device->buffer[1]);
 744                 }
 745
 746                 /*  Report 1 */
 747                 if (device->buffer[0] == 1) {
 748                         char buttonbyte;
 749
 750                         /*  IF X max > 64K, we still a bit from the y report */
 751                         if (device->max_X > 0x10000) {
 752
 753                                 val = (u16)(((u16)(device->buffer[2] << 8)) | (u8)device->buffer[1]);
 754                                 val |= (u32)(((u8)device->buffer[3] & 0x1) << 16);
 755
 756                                 input_report_abs(inputdev, ABS_X, val);
 757
 758                                 le_buffer[0]  = (u8)((u8)(device->buffer[3]) >> 1);
 759                                 le_buffer[0] |= (u8)((device->buffer[3] & 0x1) << 7);
 760
 761                                 le_buffer[1]  = (u8)(device->buffer[4] >> 1);
 762                                 le_buffer[1] |= (u8)((device->buffer[5] & 0x1) << 7);
 763
 764                                 val = get_unaligned_le16(le_buffer);
 765                                 input_report_abs(inputdev, ABS_Y, val);
 766
 767                                 /*
 768                                  * Shift the button byte right by one to
 769                                  * make it look like the standard report
 770                                  */
 771                                 buttonbyte = device->buffer[5] >> 1;
 772                         } else {
 773
 774                                 val = get_unaligned_le16(&device->buffer[1]);
 775                                 input_report_abs(inputdev, ABS_X, val);
 776
 777                                 val = get_unaligned_le16(&device->buffer[3]);
 778                                 input_report_abs(inputdev, ABS_Y, val);
 779
 780                                 buttonbyte = device->buffer[5];
 781                         }
 782
 783                         /* BUTTONS and PROXIMITY */
 784                         val = buttonbyte & MASK_INRANGE ? 1 : 0;
 785                         input_report_abs(inputdev, ABS_DISTANCE, val);
 786
 787                         /* Convert buttons, only 4 bits possible */
 788                         val = buttonbyte & 0x0F;
 789 #ifdef USE_BUTTONS
 790                         for (i = 0; i < 5; i++)
 791                                 input_report_key(inputdev, BTN_DIGI + i, val & (1 << i));
 792 #else
 793                         /* We don't apply any meaning to the bitmask, just report */
 794                         input_event(inputdev, EV_MSC, MSC_SERIAL, val);
 795 #endif
 796
 797                         /* TRANSDUCER */
 798                         input_report_abs(inputdev, ABS_MISC, device->buffer[6]);
 799                 }
 800         }
 801
 802         /* Everybody gets report ID's */
 803         input_event(inputdev, EV_MSC, MSC_RAW,  device->buffer[0]);
 804
 805         /* Sync it up */
 806         input_sync(inputdev);
 807
 808  resubmit:
 809         rc = usb_submit_urb(urbinfo, GFP_ATOMIC);
 810         if (rc != 0)
 811                 dev_err(&device->intf->dev,
 812                         "usb_submit_urb failed rc=0x%x\n", rc);
 813 }
 814
 815 /*
 816  *  The probe routine.  This is called when the kernel find the matching USB
 817  *   vendor/product.  We do the following:
 818  *
 819  *    - Allocate mem for a local structure to manage the device
 820  *    - Request a HID Report Descriptor from the device and parse it to
 821  *      find out the device parameters
 822  *    - Create an input device and assign it attributes
 823  *   - Allocate an URB so the device can talk to us when the input
 824  *      queue is open
 825  */
 826 static int gtco_probe(struct usb_interface *usbinterface,
 827                       const struct usb_device_id *id)
 828 {
 829
 830         struct gtco             *gtco;
 831         struct input_dev        *input_dev;
 832         struct hid_descriptor   *hid_desc;
 833         char                    *report;
 834         int                     result = 0, retry;
 835         int                     error;
 836         struct usb_endpoint_descriptor *endpoint;
 837
 838         /* Allocate memory for device structure */
 839         gtco = kzalloc(sizeof(struct gtco), GFP_KERNEL);
 840         input_dev = input_allocate_device();
 841         if (!gtco || !input_dev) {
 842                 dev_err(&usbinterface->dev, "No more memory\n");
 843                 error = -ENOMEM;
 844                 goto err_free_devs;
 845         }
 846
 847         /* Set pointer to the input device */
 848         gtco->inputdevice = input_dev;
 849
 850         /* Save interface information */
 851         gtco->usbdev = interface_to_usbdev(usbinterface);
 852         gtco->intf = usbinterface;
 853
 854         /* Allocate some data for incoming reports */
 855         gtco->buffer = usb_alloc_coherent(gtco->usbdev, REPORT_MAX_SIZE,
 856                                           GFP_KERNEL, &gtco->buf_dma);
 857         if (!gtco->buffer) {
 858                 dev_err(&usbinterface->dev, "No more memory for us buffers\n");
 859                 error = -ENOMEM;
 860                 goto err_free_devs;
 861         }
 862
 863         /* Allocate URB for reports */
 864         gtco->urbinfo = usb_alloc_urb(0, GFP_KERNEL);
 865         if (!gtco->urbinfo) {
 866                 dev_err(&usbinterface->dev, "Failed to allocate URB\n");
 867                 error = -ENOMEM;
 868                 goto err_free_buf;
 869         }
 870
 871         /* Sanity check that a device has an endpoint */
 872         if (usbinterface->altsetting[0].desc.bNumEndpoints < 1) {
 873                 dev_err(&usbinterface->dev,
 874                         "Invalid number of endpoints\n");
 875                 error = -EINVAL;
 876                 goto err_free_urb;
 877         }
 878
 879         /*
 880          * The endpoint is always altsetting 0, we know this since we know
 881          * this device only has one interrupt endpoint
 882          */
 883         endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
 884
 885         /* Some debug */
 886         dev_dbg(&usbinterface->dev, "gtco # interfaces: %d\n", usbinterface->num_altsetting);
 887         dev_dbg(&usbinterface->dev, "num endpoints:     %d\n", usbinterface->cur_altsetting->desc.bNumEndpoints);
 888         dev_dbg(&usbinterface->dev, "interface class:   %d\n", usbinterface->cur_altsetting->desc.bInterfaceClass);
 889         dev_dbg(&usbinterface->dev, "endpoint: attribute:0x%x type:0x%x\n", endpoint->bmAttributes, endpoint->bDescriptorType);
 890         if (usb_endpoint_xfer_int(endpoint))
 891                 dev_dbg(&usbinterface->dev, "endpoint: we have interrupt endpoint\n");
 892
 893         dev_dbg(&usbinterface->dev, "endpoint extra len:%d\n", usbinterface->altsetting[0].extralen);
 894
 895         /*
 896          * Find the HID descriptor so we can find out the size of the
 897          * HID report descriptor
 898          */
 899         if (usb_get_extra_descriptor(usbinterface->cur_altsetting,
 900                                      HID_DEVICE_TYPE, &hid_desc) != 0) {
 901                 dev_err(&usbinterface->dev,
 902                         "Can't retrieve exta USB descriptor to get hid report descriptor length\n");
 903                 error = -EIO;
 904                 goto err_free_urb;
 905         }
 906
 907         dev_dbg(&usbinterface->dev,
 908                 "Extra descriptor success: type:%d  len:%d\n",
 909                 hid_desc->bDescriptorType,  hid_desc->wDescriptorLength);
 910
 911         report = kzalloc(le16_to_cpu(hid_desc->wDescriptorLength), GFP_KERNEL);
 912         if (!report) {
 913                 dev_err(&usbinterface->dev, "No more memory for report\n");
 914                 error = -ENOMEM;
 915                 goto err_free_urb;
 916         }
 917
 918         /* Couple of tries to get reply */
 919         for (retry = 0; retry < 3; retry++) {
 920                 result = usb_control_msg(gtco->usbdev,
 921                                          usb_rcvctrlpipe(gtco->usbdev, 0),
 922                                          USB_REQ_GET_DESCRIPTOR,
 923                                          USB_RECIP_INTERFACE | USB_DIR_IN,
 924                                          REPORT_DEVICE_TYPE << 8,
 925                                          0, /* interface */
 926                                          report,
 927                                          le16_to_cpu(hid_desc->wDescriptorLength),
 928                                          5000); /* 5 secs */
 929
 930                 dev_dbg(&usbinterface->dev, "usb_control_msg result: %d\n", result);
 931                 if (result == le16_to_cpu(hid_desc->wDescriptorLength)) {
 932                         parse_hid_report_descriptor(gtco, report, result);
 933                         break;
 934                 }
 935         }
 936
 937         kfree(report);
 938
 939         /* If we didn't get the report, fail */
 940         if (result != le16_to_cpu(hid_desc->wDescriptorLength)) {
 941                 dev_err(&usbinterface->dev,
 942                         "Failed to get HID Report Descriptor of size: %d\n",
 943                         hid_desc->wDescriptorLength);
 944                 error = -EIO;
 945                 goto err_free_urb;
 946         }
 947
 948         /* Create a device file node */
 949         usb_make_path(gtco->usbdev, gtco->usbpath, sizeof(gtco->usbpath));
 950         strlcat(gtco->usbpath, "/input0", sizeof(gtco->usbpath));
 951
 952         /* Set Input device functions */
 953         input_dev->open = gtco_input_open;
 954         input_dev->close = gtco_input_close;
 955
 956         /* Set input device information */
 957         input_dev->name = "GTCO_CalComp";
 958         input_dev->phys = gtco->usbpath;
 959
 960         input_set_drvdata(input_dev, gtco);
 961
 962         /* Now set up all the input device capabilities */
 963         gtco_setup_caps(input_dev);
 964
 965         /* Set input device required ID information */
 966         usb_to_input_id(gtco->usbdev, &input_dev->id);
 967         input_dev->dev.parent = &usbinterface->dev;
 968
 969         /* Setup the URB, it will be posted later on open of input device */
 970         endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
 971
 972         usb_fill_int_urb(gtco->urbinfo,
 973                          gtco->usbdev,
 974                          usb_rcvintpipe(gtco->usbdev,
 975                                         endpoint->bEndpointAddress),
 976                          gtco->buffer,
 977                          REPORT_MAX_SIZE,
 978                          gtco_urb_callback,
 979                          gtco,
 980                          endpoint->bInterval);
 981
 982         gtco->urbinfo->transfer_dma = gtco->buf_dma;
 983         gtco->urbinfo->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 984
 985         /* Save gtco pointer in USB interface gtco */
 986         usb_set_intfdata(usbinterface, gtco);
 987
 988         /* All done, now register the input device */
 989         error = input_register_device(input_dev);
 990         if (error)
 991                 goto err_free_urb;
 992
 993         return 0;
 994
 995  err_free_urb:
 996         usb_free_urb(gtco->urbinfo);
 997  err_free_buf:
 998         usb_free_coherent(gtco->usbdev, REPORT_MAX_SIZE,
 999                           gtco->buffer, gtco->buf_dma);
1000  err_free_devs:
1001         input_free_device(input_dev);
1002         kfree(gtco);
1003         return error;
1004 }
1005
1006 /*
1007  *  This function is a standard USB function called when the USB device
1008  *  is disconnected.  We will get rid of the URV, de-register the input
1009  *  device, and free up allocated memory
1010  */
1011 static void gtco_disconnect(struct usb_interface *interface)
1012 {
1013         /* Grab private device ptr */
1014         struct gtco *gtco = usb_get_intfdata(interface);
1015
1016         /* Now reverse all the registration stuff */
1017         if (gtco) {
1018                 input_unregister_device(gtco->inputdevice);
1019                 usb_kill_urb(gtco->urbinfo);
1020                 usb_free_urb(gtco->urbinfo);
1021                 usb_free_coherent(gtco->usbdev, REPORT_MAX_SIZE,
1022                                   gtco->buffer, gtco->buf_dma);
1023                 kfree(gtco);
1024         }
1025
1026         dev_info(&interface->dev, "gtco driver disconnected\n");
1027 }
1028
1029 /*   STANDARD MODULE LOAD ROUTINES  */
1030
1031 static struct usb_driver gtco_driverinfo_table = {
1032         .name           = "gtco",
1033         .id_table       = gtco_usbid_table,
1034         .probe          = gtco_probe,
1035         .disconnect     = gtco_disconnect,
1036 };
1037
1038 module_usb_driver(gtco_driverinfo_table);
1039
1040 MODULE_DESCRIPTION("GTCO digitizer USB driver");
1041 MODULE_LICENSE("GPL");