kernel/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_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         char              le_buffer[2];
 618
 619         inputdev = device->inputdevice;
 620
 621         /* Was callback OK? */
 622         if (urbinfo->status == -ECONNRESET ||
 623             urbinfo->status == -ENOENT ||
 624             urbinfo->status == -ESHUTDOWN) {
 625
 626                 /* Shutdown is occurring. Return and don't queue up any more */
 627                 return;
 628         }
 629
 630         if (urbinfo->status != 0) {
 631                 /*
 632                  * Some unknown error.  Hopefully temporary. Just go and
 633                  * requeue an URB
 634                  */
 635                 goto resubmit;
 636         }
 637
 638         /*
 639          * Good URB, now process
 640          */
 641
 642         /* PID dependent when we interpret the report */
 643         if (inputdev->id.product == PID_1000 ||
 644             inputdev->id.product == PID_1001 ||
 645             inputdev->id.product == PID_1002) {
 646
 647                 /*
 648                  * Switch on the report ID
 649                  * Conveniently, the reports have more information, the higher
 650                  * the report number.  We can just fall through the case
 651                  * statements if we start with the highest number report
 652                  */
 653                 switch (device->buffer[0]) {
 654                 case 5:
 655                         /* Pressure is 9 bits */
 656                         val = ((u16)(device->buffer[8]) << 1);
 657                         val |= (u16)(device->buffer[7] >> 7);
 658                         input_report_abs(inputdev, ABS_PRESSURE,
 659                                          device->buffer[8]);
 660
 661                         /* Mask out the Y tilt value used for pressure */
 662                         device->buffer[7] = (u8)((device->buffer[7]) & 0x7F);
 663
 664                         /* Fall thru */
 665                 case 4:
 666                         /* Tilt */
 667                         input_report_abs(inputdev, ABS_TILT_X,
 668                                          sign_extend32(device->buffer[6], 6));
 669
 670                         input_report_abs(inputdev, ABS_TILT_Y,
 671                                          sign_extend32(device->buffer[7], 6));
 672
 673                         /* Fall thru */
 674                 case 2:
 675                 case 3:
 676                         /* Convert buttons, only 5 bits possible */
 677                         val = (device->buffer[5]) & MASK_BUTTON;
 678
 679                         /* We don't apply any meaning to the bitmask,
 680                            just report */
 681                         input_event(inputdev, EV_MSC, MSC_SERIAL, val);
 682
 683                         /*  Fall thru */
 684                 case 1:
 685                         /* All reports have X and Y coords in the same place */
 686                         val = get_unaligned_le16(&device->buffer[1]);
 687                         input_report_abs(inputdev, ABS_X, val);
 688
 689                         val = get_unaligned_le16(&device->buffer[3]);
 690                         input_report_abs(inputdev, ABS_Y, val);
 691
 692                         /* Ditto for proximity bit */
 693                         val = device->buffer[5] & MASK_INRANGE ? 1 : 0;
 694                         input_report_abs(inputdev, ABS_DISTANCE, val);
 695
 696                         /* Report 1 is an exception to how we handle buttons */
 697                         /* Buttons are an index, not a bitmask */
 698                         if (device->buffer[0] == 1) {
 699
 700                                 /*
 701                                  * Convert buttons, 5 bit index
 702                                  * Report value of index set as one,
 703                                  * the rest as 0
 704                                  */
 705                                 val = device->buffer[5] & MASK_BUTTON;
 706                                 dev_dbg(&device->intf->dev,
 707                                         "======>>>>>>REPORT 1: val 0x%X(%d)\n",
 708                                         val, val);
 709
 710                                 /*
 711                                  * We don't apply any meaning to the button
 712                                  * index, just report it
 713                                  */
 714                                 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
 715                         }
 716                         break;
 717
 718                 case 7:
 719                         /* Menu blocks */
 720                         input_event(inputdev, EV_MSC, MSC_SCAN,
 721                                     device->buffer[1]);
 722                         break;
 723                 }
 724         }
 725
 726         /* Other pid class */
 727         if (inputdev->id.product == PID_400 ||
 728             inputdev->id.product == PID_401) {
 729
 730                 /* Report 2 */
 731                 if (device->buffer[0] == 2) {
 732                         /* Menu blocks */
 733                         input_event(inputdev, EV_MSC, MSC_SCAN, device->buffer[1]);
 734                 }
 735
 736                 /*  Report 1 */
 737                 if (device->buffer[0] == 1) {
 738                         char buttonbyte;
 739
 740                         /*  IF X max > 64K, we still a bit from the y report */
 741                         if (device->max_X > 0x10000) {
 742
 743                                 val = (u16)(((u16)(device->buffer[2] << 8)) | (u8)device->buffer[1]);
 744                                 val |= (u32)(((u8)device->buffer[3] & 0x1) << 16);
 745
 746                                 input_report_abs(inputdev, ABS_X, val);
 747
 748                                 le_buffer[0]  = (u8)((u8)(device->buffer[3]) >> 1);
 749                                 le_buffer[0] |= (u8)((device->buffer[3] & 0x1) << 7);
 750
 751                                 le_buffer[1]  = (u8)(device->buffer[4] >> 1);
 752                                 le_buffer[1] |= (u8)((device->buffer[5] & 0x1) << 7);
 753
 754                                 val = get_unaligned_le16(le_buffer);
 755                                 input_report_abs(inputdev, ABS_Y, val);
 756
 757                                 /*
 758                                  * Shift the button byte right by one to
 759                                  * make it look like the standard report
 760                                  */
 761                                 buttonbyte = device->buffer[5] >> 1;
 762                         } else {
 763
 764                                 val = get_unaligned_le16(&device->buffer[1]);
 765                                 input_report_abs(inputdev, ABS_X, val);
 766
 767                                 val = get_unaligned_le16(&device->buffer[3]);
 768                                 input_report_abs(inputdev, ABS_Y, val);
 769
 770                                 buttonbyte = device->buffer[5];
 771                         }
 772
 773                         /* BUTTONS and PROXIMITY */
 774                         val = buttonbyte & MASK_INRANGE ? 1 : 0;
 775                         input_report_abs(inputdev, ABS_DISTANCE, val);
 776
 777                         /* Convert buttons, only 4 bits possible */
 778                         val = buttonbyte & 0x0F;
 779 #ifdef USE_BUTTONS
 780                         for (i = 0; i < 5; i++)
 781                                 input_report_key(inputdev, BTN_DIGI + i, val & (1 << i));
 782 #else
 783                         /* We don't apply any meaning to the bitmask, just report */
 784                         input_event(inputdev, EV_MSC, MSC_SERIAL, val);
 785 #endif
 786
 787                         /* TRANSDUCER */
 788                         input_report_abs(inputdev, ABS_MISC, device->buffer[6]);
 789                 }
 790         }
 791
 792         /* Everybody gets report ID's */
 793         input_event(inputdev, EV_MSC, MSC_RAW,  device->buffer[0]);
 794
 795         /* Sync it up */
 796         input_sync(inputdev);
 797
 798  resubmit:
 799         rc = usb_submit_urb(urbinfo, GFP_ATOMIC);
 800         if (rc != 0)
 801                 dev_err(&device->intf->dev,
 802                         "usb_submit_urb failed rc=0x%x\n", rc);
 803 }
 804
 805 /*
 806  *  The probe routine.  This is called when the kernel find the matching USB
 807  *   vendor/product.  We do the following:
 808  *
 809  *    - Allocate mem for a local structure to manage the device
 810  *    - Request a HID Report Descriptor from the device and parse it to
 811  *      find out the device parameters
 812  *    - Create an input device and assign it attributes
 813  *   - Allocate an URB so the device can talk to us when the input
 814  *      queue is open
 815  */
 816 static int gtco_probe(struct usb_interface *usbinterface,
 817                       const struct usb_device_id *id)
 818 {
 819
 820         struct gtco             *gtco;
 821         struct input_dev        *input_dev;
 822         struct hid_descriptor   *hid_desc;
 823         char                    *report;
 824         int                     result = 0, retry;
 825         int                     error;
 826         struct usb_endpoint_descriptor *endpoint;
 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->usbdev = interface_to_usbdev(usbinterface);
 842         gtco->intf = usbinterface;
 843
 844         /* Allocate some data for incoming reports */
 845         gtco->buffer = usb_alloc_coherent(gtco->usbdev, REPORT_MAX_SIZE,
 846                                           GFP_KERNEL, &gtco->buf_dma);
 847         if (!gtco->buffer) {
 848                 dev_err(&usbinterface->dev, "No more memory for us buffers\n");
 849                 error = -ENOMEM;
 850                 goto err_free_devs;
 851         }
 852
 853         /* Allocate URB for reports */
 854         gtco->urbinfo = usb_alloc_urb(0, GFP_KERNEL);
 855         if (!gtco->urbinfo) {
 856                 dev_err(&usbinterface->dev, "Failed to allocate URB\n");
 857                 error = -ENOMEM;
 858                 goto err_free_buf;
 859         }
 860
 861         /* Sanity check that a device has an endpoint */
 862         if (usbinterface->altsetting[0].desc.bNumEndpoints < 1) {
 863                 dev_err(&usbinterface->dev,
 864                         "Invalid number of endpoints\n");
 865                 error = -EINVAL;
 866                 goto err_free_urb;
 867         }
 868
 869         /*
 870          * The endpoint is always altsetting 0, we know this since we know
 871          * this device only has one interrupt endpoint
 872          */
 873         endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
 874
 875         /* Some debug */
 876         dev_dbg(&usbinterface->dev, "gtco # interfaces: %d\n", usbinterface->num_altsetting);
 877         dev_dbg(&usbinterface->dev, "num endpoints:     %d\n", usbinterface->cur_altsetting->desc.bNumEndpoints);
 878         dev_dbg(&usbinterface->dev, "interface class:   %d\n", usbinterface->cur_altsetting->desc.bInterfaceClass);
 879         dev_dbg(&usbinterface->dev, "endpoint: attribute:0x%x type:0x%x\n", endpoint->bmAttributes, endpoint->bDescriptorType);
 880         if (usb_endpoint_xfer_int(endpoint))
 881                 dev_dbg(&usbinterface->dev, "endpoint: we have interrupt endpoint\n");
 882
 883         dev_dbg(&usbinterface->dev, "endpoint extra len:%d\n", usbinterface->altsetting[0].extralen);
 884
 885         /*
 886          * Find the HID descriptor so we can find out the size of the
 887          * HID report descriptor
 888          */
 889         if (usb_get_extra_descriptor(usbinterface->cur_altsetting,
 890                                      HID_DEVICE_TYPE, &hid_desc) != 0) {
 891                 dev_err(&usbinterface->dev,
 892                         "Can't retrieve exta USB descriptor to get hid report descriptor length\n");
 893                 error = -EIO;
 894                 goto err_free_urb;
 895         }
 896
 897         dev_dbg(&usbinterface->dev,
 898                 "Extra descriptor success: type:%d  len:%d\n",
 899                 hid_desc->bDescriptorType,  hid_desc->wDescriptorLength);
 900
 901         report = kzalloc(le16_to_cpu(hid_desc->wDescriptorLength), GFP_KERNEL);
 902         if (!report) {
 903                 dev_err(&usbinterface->dev, "No more memory for report\n");
 904                 error = -ENOMEM;
 905                 goto err_free_urb;
 906         }
 907
 908         /* Couple of tries to get reply */
 909         for (retry = 0; retry < 3; retry++) {
 910                 result = usb_control_msg(gtco->usbdev,
 911                                          usb_rcvctrlpipe(gtco->usbdev, 0),
 912                                          USB_REQ_GET_DESCRIPTOR,
 913                                          USB_RECIP_INTERFACE | USB_DIR_IN,
 914                                          REPORT_DEVICE_TYPE << 8,
 915                                          0, /* interface */
 916                                          report,
 917                                          le16_to_cpu(hid_desc->wDescriptorLength),
 918                                          5000); /* 5 secs */
 919
 920                 dev_dbg(&usbinterface->dev, "usb_control_msg result: %d\n", result);
 921                 if (result == le16_to_cpu(hid_desc->wDescriptorLength)) {
 922                         parse_hid_report_descriptor(gtco, report, result);
 923                         break;
 924                 }
 925         }
 926
 927         kfree(report);
 928
 929         /* If we didn't get the report, fail */
 930         if (result != le16_to_cpu(hid_desc->wDescriptorLength)) {
 931                 dev_err(&usbinterface->dev,
 932                         "Failed to get HID Report Descriptor of size: %d\n",
 933                         hid_desc->wDescriptorLength);
 934                 error = -EIO;
 935                 goto err_free_urb;
 936         }
 937
 938         /* Create a device file node */
 939         usb_make_path(gtco->usbdev, gtco->usbpath, sizeof(gtco->usbpath));
 940         strlcat(gtco->usbpath, "/input0", sizeof(gtco->usbpath));
 941
 942         /* Set Input device functions */
 943         input_dev->open = gtco_input_open;
 944         input_dev->close = gtco_input_close;
 945
 946         /* Set input device information */
 947         input_dev->name = "GTCO_CalComp";
 948         input_dev->phys = gtco->usbpath;
 949
 950         input_set_drvdata(input_dev, gtco);
 951
 952         /* Now set up all the input device capabilities */
 953         gtco_setup_caps(input_dev);
 954
 955         /* Set input device required ID information */
 956         usb_to_input_id(gtco->usbdev, &input_dev->id);
 957         input_dev->dev.parent = &usbinterface->dev;
 958
 959         /* Setup the URB, it will be posted later on open of input device */
 960         endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
 961
 962         usb_fill_int_urb(gtco->urbinfo,
 963                          gtco->usbdev,
 964                          usb_rcvintpipe(gtco->usbdev,
 965                                         endpoint->bEndpointAddress),
 966                          gtco->buffer,
 967                          REPORT_MAX_SIZE,
 968                          gtco_urb_callback,
 969                          gtco,
 970                          endpoint->bInterval);
 971
 972         gtco->urbinfo->transfer_dma = gtco->buf_dma;
 973         gtco->urbinfo->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 974
 975         /* Save gtco pointer in USB interface gtco */
 976         usb_set_intfdata(usbinterface, gtco);
 977
 978         /* All done, now register the input device */
 979         error = input_register_device(input_dev);
 980         if (error)
 981                 goto err_free_urb;
 982
 983         return 0;
 984
 985  err_free_urb:
 986         usb_free_urb(gtco->urbinfo);
 987  err_free_buf:
 988         usb_free_coherent(gtco->usbdev, REPORT_MAX_SIZE,
 989                           gtco->buffer, gtco->buf_dma);
 990  err_free_devs:
 991         input_free_device(input_dev);
 992         kfree(gtco);
 993         return error;
 994 }
 995
 996 /*
 997  *  This function is a standard USB function called when the USB device
 998  *  is disconnected.  We will get rid of the URV, de-register the input
 999  *  device, and free up allocated memory
1000  */
1001 static void gtco_disconnect(struct usb_interface *interface)
1002 {
1003         /* Grab private device ptr */
1004         struct gtco *gtco = usb_get_intfdata(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(gtco->usbdev, 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");