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