drivers/input/tablet/gtco.c

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