git.oblomov.eu Git - linux-2.6/blob - drivers/input/tablet/gtco.c

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