drivers/input/tablet/gtco.c

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