1/* -*- linux-c -*- 2 3GTCO digitizer USB driver 4 5Use the err(), dbg() and info() macros from usb.h for system logging 6 7TO CHECK: Is pressure done right on report 5? 8 9Copyright (C) 2006 GTCO CalComp 10 11This program is free software; you can redistribute it and/or 12modify it under the terms of the GNU General Public License 13as published by the Free Software Foundation; version 2 14of the License. 15 16This program is distributed in the hope that it will be useful, 17but WITHOUT ANY WARRANTY; without even the implied warranty of 18MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19GNU General Public License for more details. 20 21You should have received a copy of the GNU General Public License 22along with this program; if not, write to the Free Software 23Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 24 25Permission to use, copy, modify, distribute, and sell this software and its 26documentation for any purpose is hereby granted without fee, provided that 27the above copyright notice appear in all copies and that both that 28copyright notice and this permission notice appear in supporting 29documentation, and that the name of GTCO-CalComp not be used in advertising 30or publicity pertaining to distribution of the software without specific, 31written prior permission. GTCO-CalComp makes no representations about the 32suitability of this software for any purpose. It is provided "as is" 33without express or implied warranty. 34 35GTCO-CALCOMP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 36INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO 37EVENT SHALL GTCO-CALCOMP BE LIABLE FOR ANY SPECIAL, INDIRECT OR 38CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 39DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 40TORTIOUS ACTIONS, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 41PERFORMANCE OF THIS SOFTWARE. 42 43GTCO CalComp, Inc. 447125 Riverwood Drive 45Columbia, MD 21046 46 47Jeremy Roberson jroberson@gtcocalcomp.com 48Scott 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 */ 96static 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}; 104MODULE_DEVICE_TABLE (usb, gtco_usbid_table); 105 106 107/* Structure to hold all of our device specific stuff */ 108struct 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 */ 138struct 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 */ 203static 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 */ 541static 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 */ 555static 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 */ 571static 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(EV_KEY) | BIT(EV_ABS) | BIT(EV_MSC); 577 578 /* Misc event menu block */ 579 inputdev->mscbit[0] = BIT(MSC_SCAN)|BIT(MSC_SERIAL)|BIT(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 */ 611static void gtco_urb_callback(struct urb *urbinfo) 612{ 613 struct gtco *device = urbinfo->context; 614 struct input_dev *inputdev; 615 int rc; 616 u32 val = 0; 617 s8 valsigned = 0; 618 char le_buffer[2]; 619 620 inputdev = device->inputdevice; 621 622 /* Was callback OK? */ 623 if (urbinfo->status == -ECONNRESET || 624 urbinfo->status == -ENOENT || 625 urbinfo->status == -ESHUTDOWN) { 626 627 /* Shutdown is occurring. Return and don't queue up any more */ 628 return; 629 } 630 631 if (urbinfo->status != 0) { 632 /* 633 * Some unknown error. Hopefully temporary. Just go and 634 * requeue an URB 635 */ 636 goto resubmit; 637 } 638 639 /* 640 * Good URB, now process 641 */ 642 643 /* PID dependent when we interpret the report */ 644 if (inputdev->id.product == PID_1000 || 645 inputdev->id.product == PID_1001 || 646 inputdev->id.product == PID_1002) { 647 648 /* 649 * Switch on the report ID 650 * Conveniently, the reports have more information, the higher 651 * the report number. We can just fall through the case 652 * statements if we start with the highest number report 653 */ 654 switch (device->buffer[0]) { 655 case 5: 656 /* Pressure is 9 bits */ 657 val = ((u16)(device->buffer[8]) << 1); 658 val |= (u16)(device->buffer[7] >> 7); 659 input_report_abs(inputdev, ABS_PRESSURE, 660 device->buffer[8]); 661 662 /* Mask out the Y tilt value used for pressure */ 663 device->buffer[7] = (u8)((device->buffer[7]) & 0x7F); 664 665 /* Fall thru */ 666 case 4: 667 /* Tilt */ 668 669 /* Sign extend these 7 bit numbers. */ 670 if (device->buffer[6] & 0x40) 671 device->buffer[6] |= 0x80; 672 673 if (device->buffer[7] & 0x40) 674 device->buffer[7] |= 0x80; 675 676 677 valsigned = (device->buffer[6]); 678 input_report_abs(inputdev, ABS_TILT_X, (s32)valsigned); 679 680 valsigned = (device->buffer[7]); 681 input_report_abs(inputdev, ABS_TILT_Y, (s32)valsigned); 682 683 /* Fall thru */ 684 case 2: 685 case 3: 686 /* Convert buttons, only 5 bits possible */ 687 val = (device->buffer[5]) & MASK_BUTTON; 688 689 /* We don't apply any meaning to the bitmask, 690 just report */ 691 input_event(inputdev, EV_MSC, MSC_SERIAL, val); 692 693 /* Fall thru */ 694 case 1: 695 /* All reports have X and Y coords in the same place */ 696 val = le16_to_cpu(get_unaligned((__le16 *)&device->buffer[1])); 697 input_report_abs(inputdev, ABS_X, val); 698 699 val = le16_to_cpu(get_unaligned((__le16 *)&device->buffer[3])); 700 input_report_abs(inputdev, ABS_Y, val); 701 702 /* Ditto for proximity bit */ 703 val = device->buffer[5] & MASK_INRANGE ? 1 : 0; 704 input_report_abs(inputdev, ABS_DISTANCE, val); 705 706 /* Report 1 is an exception to how we handle buttons */ 707 /* Buttons are an index, not a bitmask */ 708 if (device->buffer[0] == 1) { 709 710 /* 711 * Convert buttons, 5 bit index 712 * Report value of index set as one, 713 * the rest as 0 714 */ 715 val = device->buffer[5] & MASK_BUTTON; 716 dbg("======>>>>>>REPORT 1: val 0x%X(%d)", 717 val, val); 718 719 /* 720 * We don't apply any meaning to the button 721 * index, just report it 722 */ 723 input_event(inputdev, EV_MSC, MSC_SERIAL, val); 724 } 725 break; 726 727 case 7: 728 /* Menu blocks */ 729 input_event(inputdev, EV_MSC, MSC_SCAN, 730 device->buffer[1]); 731 break; 732 } 733 } 734 735 /* Other pid class */ 736 if (inputdev->id.product == PID_400 || 737 inputdev->id.product == PID_401) { 738 739 /* Report 2 */ 740 if (device->buffer[0] == 2) { 741 /* Menu blocks */ 742 input_event(inputdev, EV_MSC, MSC_SCAN, device->buffer[1]); 743 } 744 745 /* Report 1 */ 746 if (device->buffer[0] == 1) { 747 char buttonbyte; 748 749 /* IF X max > 64K, we still a bit from the y report */ 750 if (device->max_X > 0x10000) { 751 752 val = (u16)(((u16)(device->buffer[2] << 8)) | (u8)device->buffer[1]); 753 val |= (u32)(((u8)device->buffer[3] & 0x1) << 16); 754 755 input_report_abs(inputdev, ABS_X, val); 756 757 le_buffer[0] = (u8)((u8)(device->buffer[3]) >> 1); 758 le_buffer[0] |= (u8)((device->buffer[3] & 0x1) << 7); 759 760 le_buffer[1] = (u8)(device->buffer[4] >> 1); 761 le_buffer[1] |= (u8)((device->buffer[5] & 0x1) << 7); 762 763 val = le16_to_cpu(get_unaligned((__le16 *)le_buffer)); 764 input_report_abs(inputdev, ABS_Y, val); 765 766 /* 767 * Shift the button byte right by one to 768 * make it look like the standard report 769 */ 770 buttonbyte = device->buffer[5] >> 1; 771 } else { 772 773 val = le16_to_cpu(get_unaligned((__le16 *)&device->buffer[1])); 774 input_report_abs(inputdev, ABS_X, val); 775 776 val = le16_to_cpu(get_unaligned((__le16 *)&device->buffer[3])); 777 input_report_abs(inputdev, ABS_Y, val); 778 779 buttonbyte = device->buffer[5]; 780 } 781 782 /* BUTTONS and PROXIMITY */ 783 val = buttonbyte & MASK_INRANGE ? 1 : 0; 784 input_report_abs(inputdev, ABS_DISTANCE, val); 785 786 /* Convert buttons, only 4 bits possible */ 787 val = buttonbyte & 0x0F; 788#ifdef USE_BUTTONS 789 for (i = 0; i < 5; i++) 790 input_report_key(inputdev, BTN_DIGI + i, val & (1 << i)); 791#else 792 /* We don't apply any meaning to the bitmask, just report */ 793 input_event(inputdev, EV_MSC, MSC_SERIAL, val); 794#endif 795 796 /* TRANSDUCER */ 797 input_report_abs(inputdev, ABS_MISC, device->buffer[6]); 798 } 799 } 800 801 /* Everybody gets report ID's */ 802 input_event(inputdev, EV_MSC, MSC_RAW, device->buffer[0]); 803 804 /* Sync it up */ 805 input_sync(inputdev); 806 807 resubmit: 808 rc = usb_submit_urb(urbinfo, GFP_ATOMIC); 809 if (rc != 0) 810 err("usb_submit_urb failed rc=0x%x", rc); 811} 812 813/* 814 * The probe routine. This is called when the kernel find the matching USB 815 * vendor/product. We do the following: 816 * 817 * - Allocate mem for a local structure to manage the device 818 * - Request a HID Report Descriptor from the device and parse it to 819 * find out the device parameters 820 * - Create an input device and assign it attributes 821 * - Allocate an URB so the device can talk to us when the input 822 * queue is open 823 */ 824static int gtco_probe(struct usb_interface *usbinterface, 825 const struct usb_device_id *id) 826{ 827 828 struct gtco *gtco; 829 struct input_dev *input_dev; 830 struct hid_descriptor *hid_desc; 831 char *report = NULL; 832 int result = 0, retry; 833 int error; 834 struct usb_endpoint_descriptor *endpoint; 835 836 /* Allocate memory for device structure */ 837 gtco = kzalloc(sizeof(struct gtco), GFP_KERNEL); 838 input_dev = input_allocate_device(); 839 if (!gtco || !input_dev) { 840 err("No more memory"); 841 error = -ENOMEM; 842 goto err_free_devs; 843 } 844 845 /* Set pointer to the input device */ 846 gtco->inputdevice = input_dev; 847 848 /* Save interface information */ 849 gtco->usbdev = usb_get_dev(interface_to_usbdev(usbinterface)); 850 851 /* Allocate some data for incoming reports */ 852 gtco->buffer = usb_buffer_alloc(gtco->usbdev, REPORT_MAX_SIZE, 853 GFP_KERNEL, >co->buf_dma); 854 if (!gtco->buffer) { 855 err("No more memory for us buffers"); 856 error = -ENOMEM; 857 goto err_free_devs; 858 } 859 860 /* Allocate URB for reports */ 861 gtco->urbinfo = usb_alloc_urb(0, GFP_KERNEL); 862 if (!gtco->urbinfo) { 863 err("Failed to allocate URB"); 864 return -ENOMEM; 865 goto err_free_buf; 866 } 867 868 /* 869 * The endpoint is always altsetting 0, we know this since we know 870 * this device only has one interrupt endpoint 871 */ 872 endpoint = &usbinterface->altsetting[0].endpoint[0].desc; 873 874 /* Some debug */ 875 dbg("gtco # interfaces: %d", usbinterface->num_altsetting); 876 dbg("num endpoints: %d", usbinterface->cur_altsetting->desc.bNumEndpoints); 877 dbg("interface class: %d", usbinterface->cur_altsetting->desc.bInterfaceClass); 878 dbg("endpoint: attribute:0x%x type:0x%x", endpoint->bmAttributes, endpoint->bDescriptorType); 879 if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT) 880 dbg("endpoint: we have interrupt endpoint\n"); 881 882 dbg("endpoint extra len:%d ", usbinterface->altsetting[0].extralen); 883 884 /* 885 * Find the HID descriptor so we can find out the size of the 886 * HID report descriptor 887 */ 888 if (usb_get_extra_descriptor(usbinterface->cur_altsetting, 889 HID_DEVICE_TYPE, &hid_desc) != 0){ 890 err("Can't retrieve exta USB descriptor to get hid report descriptor length"); 891 error = -EIO; 892 goto err_free_urb; 893 } 894 895 dbg("Extra descriptor success: type:%d len:%d", 896 hid_desc->bDescriptorType, hid_desc->wDescriptorLength); 897 898 report = kzalloc(hid_desc->wDescriptorLength, GFP_KERNEL); 899 if (!report) { 900 err("No more memory for report"); 901 error = -ENOMEM; 902 goto err_free_urb; 903 } 904 905 /* Couple of tries to get reply */ 906 for (retry = 0; retry < 3; retry++) { 907 result = usb_control_msg(gtco->usbdev, 908 usb_rcvctrlpipe(gtco->usbdev, 0), 909 USB_REQ_GET_DESCRIPTOR, 910 USB_RECIP_INTERFACE | USB_DIR_IN, 911 REPORT_DEVICE_TYPE << 8, 912 0, /* interface */ 913 report, 914 hid_desc->wDescriptorLength, 915 5000); /* 5 secs */ 916 917 if (result == hid_desc->wDescriptorLength) 918 break; 919 } 920 921 /* If we didn't get the report, fail */ 922 dbg("usb_control_msg result: :%d", result); 923 if (result != hid_desc->wDescriptorLength) { 924 err("Failed to get HID Report Descriptor of size: %d", 925 hid_desc->wDescriptorLength); 926 error = -EIO; 927 goto err_free_urb; 928 } 929 930 /* Now we parse the report */ 931 parse_hid_report_descriptor(gtco, report, result); 932 933 /* Now we delete it */ 934 kfree(report); 935 936 /* Create a device file node */ 937 usb_make_path(gtco->usbdev, gtco->usbpath, sizeof(gtco->usbpath)); 938 strlcat(gtco->usbpath, "/input0", sizeof(gtco->usbpath)); 939 940 /* Set Input device functions */ 941 input_dev->open = gtco_input_open; 942 input_dev->close = gtco_input_close; 943 944 /* Set input device information */ 945 input_dev->name = "GTCO_CalComp"; 946 input_dev->phys = gtco->usbpath; 947 948 input_set_drvdata(input_dev, gtco); 949 950 /* Now set up all the input device capabilities */ 951 gtco_setup_caps(input_dev); 952 953 /* Set input device required ID information */ 954 usb_to_input_id(gtco->usbdev, &input_dev->id); 955 input_dev->dev.parent = &usbinterface->dev; 956 957 /* Setup the URB, it will be posted later on open of input device */ 958 endpoint = &usbinterface->altsetting[0].endpoint[0].desc; 959 960 usb_fill_int_urb(gtco->urbinfo, 961 gtco->usbdev, 962 usb_rcvintpipe(gtco->usbdev, 963 endpoint->bEndpointAddress), 964 gtco->buffer, 965 REPORT_MAX_SIZE, 966 gtco_urb_callback, 967 gtco, 968 endpoint->bInterval); 969 970 gtco->urbinfo->transfer_dma = gtco->buf_dma; 971 gtco->urbinfo->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 972 973 /* Save gtco pointer in USB interface gtco */ 974 usb_set_intfdata(usbinterface, gtco); 975 976 /* All done, now register the input device */ 977 error = input_register_device(input_dev); 978 if (error) 979 goto err_free_urb; 980 981 return 0; 982 983 err_free_urb: 984 usb_free_urb(gtco->urbinfo); 985 err_free_buf: 986 usb_buffer_free(gtco->usbdev, REPORT_MAX_SIZE, 987 gtco->buffer, gtco->buf_dma); 988 err_free_devs: 989 kfree(report); 990 input_free_device(input_dev); 991 kfree(gtco); 992 return error; 993} 994 995/* 996 * This function is a standard USB function called when the USB device 997 * is disconnected. We will get rid of the URV, de-register the input 998 * device, and free up allocated memory 999 */ 1000static void gtco_disconnect(struct usb_interface *interface) 1001{ 1002 /* Grab private device ptr */ 1003 struct gtco *gtco = usb_get_intfdata(interface); 1004 1005 /* Now reverse all the registration stuff */ 1006 if (gtco) { 1007 input_unregister_device(gtco->inputdevice); 1008 usb_kill_urb(gtco->urbinfo); 1009 usb_free_urb(gtco->urbinfo); 1010 usb_buffer_free(gtco->usbdev, REPORT_MAX_SIZE, 1011 gtco->buffer, gtco->buf_dma); 1012 kfree(gtco); 1013 } 1014 1015 info("gtco driver disconnected"); 1016} 1017 1018/* STANDARD MODULE LOAD ROUTINES */ 1019 1020static struct usb_driver gtco_driverinfo_table = { 1021 .name = "gtco", 1022 .id_table = gtco_usbid_table, 1023 .probe = gtco_probe, 1024 .disconnect = gtco_disconnect, 1025}; 1026 1027/* 1028 * Register this module with the USB subsystem 1029 */ 1030static int __init gtco_init(void) 1031{ 1032 int error; 1033 1034 error = usb_register(>co_driverinfo_table); 1035 if (error) { 1036 err("usb_register() failed rc=0x%x", error); 1037 return error; 1038 } 1039 1040 printk("GTCO usb driver version: %s", GTCO_VERSION); 1041 return 0; 1042} 1043 1044/* 1045 * Deregister this module with the USB subsystem 1046 */ 1047static void __exit gtco_exit(void) 1048{ 1049 usb_deregister(>co_driverinfo_table); 1050} 1051 1052module_init(gtco_init); 1053module_exit(gtco_exit); 1054 1055MODULE_LICENSE("GPL"); 1056