1 /* 2 * Apple USB Touchpad (for post-February 2005 PowerBooks and MacBooks) driver 3 * 4 * Copyright (C) 2001-2004 Greg Kroah-Hartman (greg@kroah.com) 5 * Copyright (C) 2005 Johannes Berg (johannes@sipsolutions.net) 6 * Copyright (C) 2005 Stelian Pop (stelian@popies.net) 7 * Copyright (C) 2005 Frank Arnold (frank@scirocco-5v-turbo.de) 8 * Copyright (C) 2005 Peter Osterlund (petero2@telia.com) 9 * Copyright (C) 2005 Michael Hanselmann (linux-kernel@hansmi.ch) 10 * Copyright (C) 2006 Nicolas Boichat (nicolas@boichat.ch) 11 * 12 * Thanks to Alex Harper <basilisk@foobox.net> for his inputs. 13 * 14 * This program is free software; you can redistribute it and/or modify 15 * it under the terms of the GNU General Public License as published by 16 * the Free Software Foundation; either version 2 of the License, or 17 * (at your option) any later version. 18 * 19 * This program is distributed in the hope that it will be useful, 20 * but WITHOUT ANY WARRANTY; without even the implied warranty of 21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 22 * GNU General Public License for more details. 23 * 24 * You should have received a copy of the GNU General Public License 25 * along with this program; if not, write to the Free Software 26 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 27 * 28 */ 29 30 #include <linux/kernel.h> 31 #include <linux/errno.h> 32 #include <linux/init.h> 33 #include <linux/slab.h> 34 #include <linux/module.h> 35 #include <linux/usb/input.h> 36 37 /* Apple has powerbooks which have the keyboard with different Product IDs */ 38 #define APPLE_VENDOR_ID 0x05AC 39 40 /* These names come from Info.plist in AppleUSBTrackpad.kext */ 41 #define FOUNTAIN_ANSI_PRODUCT_ID 0x020E 42 #define FOUNTAIN_ISO_PRODUCT_ID 0x020F 43 44 #define FOUNTAIN_TP_ONLY_PRODUCT_ID 0x030A 45 46 #define GEYSER1_TP_ONLY_PRODUCT_ID 0x030B 47 48 #define GEYSER_ANSI_PRODUCT_ID 0x0214 49 #define GEYSER_ISO_PRODUCT_ID 0x0215 50 #define GEYSER_JIS_PRODUCT_ID 0x0216 51 52 /* MacBook devices */ 53 #define GEYSER3_ANSI_PRODUCT_ID 0x0217 54 #define GEYSER3_ISO_PRODUCT_ID 0x0218 55 #define GEYSER3_JIS_PRODUCT_ID 0x0219 56 57 /* 58 * Geyser IV: same as Geyser III according to Info.plist in AppleUSBTrackpad.kext 59 * -> same IOClass (AppleUSBGrIIITrackpad), same acceleration tables 60 */ 61 #define GEYSER4_ANSI_PRODUCT_ID 0x021A 62 #define GEYSER4_ISO_PRODUCT_ID 0x021B 63 #define GEYSER4_JIS_PRODUCT_ID 0x021C 64 65 #define ATP_DEVICE(prod) \ 66 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \ 67 USB_DEVICE_ID_MATCH_INT_CLASS | \ 68 USB_DEVICE_ID_MATCH_INT_PROTOCOL, \ 69 .idVendor = APPLE_VENDOR_ID, \ 70 .idProduct = (prod), \ 71 .bInterfaceClass = 0x03, \ 72 .bInterfaceProtocol = 0x02 73 74 /* table of devices that work with this driver */ 75 static struct usb_device_id atp_table [] = { 76 { ATP_DEVICE(FOUNTAIN_ANSI_PRODUCT_ID) }, 77 { ATP_DEVICE(FOUNTAIN_ISO_PRODUCT_ID) }, 78 { ATP_DEVICE(FOUNTAIN_TP_ONLY_PRODUCT_ID) }, 79 { ATP_DEVICE(GEYSER1_TP_ONLY_PRODUCT_ID) }, 80 81 /* PowerBooks Oct 2005 */ 82 { ATP_DEVICE(GEYSER_ANSI_PRODUCT_ID) }, 83 { ATP_DEVICE(GEYSER_ISO_PRODUCT_ID) }, 84 { ATP_DEVICE(GEYSER_JIS_PRODUCT_ID) }, 85 86 /* Core Duo MacBook & MacBook Pro */ 87 { ATP_DEVICE(GEYSER3_ANSI_PRODUCT_ID) }, 88 { ATP_DEVICE(GEYSER3_ISO_PRODUCT_ID) }, 89 { ATP_DEVICE(GEYSER3_JIS_PRODUCT_ID) }, 90 91 /* Core2 Duo MacBook & MacBook Pro */ 92 { ATP_DEVICE(GEYSER4_ANSI_PRODUCT_ID) }, 93 { ATP_DEVICE(GEYSER4_ISO_PRODUCT_ID) }, 94 { ATP_DEVICE(GEYSER4_JIS_PRODUCT_ID) }, 95 96 /* Terminating entry */ 97 { } 98 }; 99 MODULE_DEVICE_TABLE (usb, atp_table); 100 101 /* 102 * number of sensors. Note that only 16 instead of 26 X (horizontal) 103 * sensors exist on 12" and 15" PowerBooks. All models have 16 Y 104 * (vertical) sensors. 105 */ 106 #define ATP_XSENSORS 26 107 #define ATP_YSENSORS 16 108 109 /* amount of fuzz this touchpad generates */ 110 #define ATP_FUZZ 16 111 112 /* maximum pressure this driver will report */ 113 #define ATP_PRESSURE 300 114 /* 115 * multiplication factor for the X and Y coordinates. 116 * We try to keep the touchpad aspect ratio while still doing only simple 117 * arithmetics. 118 * The factors below give coordinates like: 119 * 0 <= x < 960 on 12" and 15" Powerbooks 120 * 0 <= x < 1600 on 17" Powerbooks 121 * 0 <= y < 646 122 */ 123 #define ATP_XFACT 64 124 #define ATP_YFACT 43 125 126 /* 127 * Threshold for the touchpad sensors. Any change less than ATP_THRESHOLD is 128 * ignored. 129 */ 130 #define ATP_THRESHOLD 5 131 132 /* Geyser initialization constants */ 133 #define ATP_GEYSER_MODE_READ_REQUEST_ID 1 134 #define ATP_GEYSER_MODE_WRITE_REQUEST_ID 9 135 #define ATP_GEYSER_MODE_REQUEST_VALUE 0x300 136 #define ATP_GEYSER_MODE_REQUEST_INDEX 0 137 #define ATP_GEYSER_MODE_VENDOR_VALUE 0x04 138 139 /* Structure to hold all of our device specific stuff */ 140 struct atp { 141 char phys[64]; 142 struct usb_device * udev; /* usb device */ 143 struct urb * urb; /* usb request block */ 144 signed char * data; /* transferred data */ 145 struct input_dev * input; /* input dev */ 146 unsigned char open; /* non-zero if opened */ 147 unsigned char valid; /* are the sensors valid ? */ 148 unsigned char size_detect_done; 149 unsigned char overflowwarn; /* overflow warning printed? */ 150 int x_old; /* last reported x/y, */ 151 int y_old; /* used for smoothing */ 152 /* current value of the sensors */ 153 signed char xy_cur[ATP_XSENSORS + ATP_YSENSORS]; 154 /* last value of the sensors */ 155 signed char xy_old[ATP_XSENSORS + ATP_YSENSORS]; 156 /* accumulated sensors */ 157 int xy_acc[ATP_XSENSORS + ATP_YSENSORS]; 158 int datalen; /* size of an USB urb transfer */ 159 int idlecount; /* number of empty packets */ 160 struct work_struct work; 161 }; 162 163 #define dbg_dump(msg, tab) \ 164 if (debug > 1) { \ 165 int i; \ 166 printk("appletouch: %s %lld", msg, (long long)jiffies); \ 167 for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) \ 168 printk(" %02x", tab[i]); \ 169 printk("\n"); \ 170 } 171 172 #define dprintk(format, a...) \ 173 do { \ 174 if (debug) printk(KERN_DEBUG format, ##a); \ 175 } while (0) 176 177 MODULE_AUTHOR("Johannes Berg, Stelian Pop, Frank Arnold, Michael Hanselmann"); 178 MODULE_DESCRIPTION("Apple PowerBooks USB touchpad driver"); 179 MODULE_LICENSE("GPL"); 180 181 /* 182 * Make the threshold a module parameter 183 */ 184 static int threshold = ATP_THRESHOLD; 185 module_param(threshold, int, 0644); 186 MODULE_PARM_DESC(threshold, "Discards any change in data from a sensor (trackpad has hundreds of these sensors) less than this value"); 187 188 static int debug = 1; 189 module_param(debug, int, 0644); 190 MODULE_PARM_DESC(debug, "Activate debugging output"); 191 192 static inline int atp_is_fountain(struct atp *dev) 193 { 194 u16 productId = le16_to_cpu(dev->udev->descriptor.idProduct); 195 196 return productId == FOUNTAIN_ANSI_PRODUCT_ID || 197 productId == FOUNTAIN_ISO_PRODUCT_ID || 198 productId == FOUNTAIN_TP_ONLY_PRODUCT_ID; 199 } 200 201 /* Checks if the device a Geyser 2 (ANSI, ISO, JIS) */ 202 static inline int atp_is_geyser_2(struct atp *dev) 203 { 204 u16 productId = le16_to_cpu(dev->udev->descriptor.idProduct); 205 206 return (productId == GEYSER_ANSI_PRODUCT_ID) || 207 (productId == GEYSER_ISO_PRODUCT_ID) || 208 (productId == GEYSER_JIS_PRODUCT_ID); 209 } 210 211 static inline int atp_is_geyser_3(struct atp *dev) 212 { 213 u16 productId = le16_to_cpu(dev->udev->descriptor.idProduct); 214 215 return (productId == GEYSER3_ANSI_PRODUCT_ID) || 216 (productId == GEYSER3_ISO_PRODUCT_ID) || 217 (productId == GEYSER3_JIS_PRODUCT_ID) || 218 (productId == GEYSER4_ANSI_PRODUCT_ID) || 219 (productId == GEYSER4_ISO_PRODUCT_ID) || 220 (productId == GEYSER4_JIS_PRODUCT_ID); 221 } 222 223 /* 224 * By default newer Geyser devices send standard USB HID mouse 225 * packets (Report ID 2). This code changes device mode, so it 226 * sends raw sensor reports (Report ID 5). 227 */ 228 static int atp_geyser_init(struct usb_device *udev) 229 { 230 char data[8]; 231 int size; 232 233 size = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 234 ATP_GEYSER_MODE_READ_REQUEST_ID, 235 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 236 ATP_GEYSER_MODE_REQUEST_VALUE, 237 ATP_GEYSER_MODE_REQUEST_INDEX, &data, 8, 5000); 238 239 if (size != 8) { 240 err("Could not do mode read request from device" 241 " (Geyser Raw mode)"); 242 return -EIO; 243 } 244 245 /* Apply the mode switch */ 246 data[0] = ATP_GEYSER_MODE_VENDOR_VALUE; 247 248 size = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 249 ATP_GEYSER_MODE_WRITE_REQUEST_ID, 250 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 251 ATP_GEYSER_MODE_REQUEST_VALUE, 252 ATP_GEYSER_MODE_REQUEST_INDEX, &data, 8, 5000); 253 254 if (size != 8) { 255 err("Could not do mode write request to device" 256 " (Geyser Raw mode)"); 257 return -EIO; 258 } 259 return 0; 260 } 261 262 /* 263 * Reinitialise the device. This usually stops stream of empty packets 264 * coming from it. 265 */ 266 static void atp_reinit(struct work_struct *work) 267 { 268 struct atp *dev = container_of(work, struct atp, work); 269 struct usb_device *udev = dev->udev; 270 int retval; 271 272 dev->idlecount = 0; 273 274 atp_geyser_init(udev); 275 276 retval = usb_submit_urb(dev->urb, GFP_ATOMIC); 277 if (retval) { 278 err("%s - usb_submit_urb failed with result %d", 279 __FUNCTION__, retval); 280 } 281 } 282 283 static int atp_calculate_abs(int *xy_sensors, int nb_sensors, int fact, 284 int *z, int *fingers) 285 { 286 int i; 287 /* values to calculate mean */ 288 int pcum = 0, psum = 0; 289 int is_increasing = 0; 290 291 *fingers = 0; 292 293 for (i = 0; i < nb_sensors; i++) { 294 if (xy_sensors[i] < threshold) { 295 if (is_increasing) 296 is_increasing = 0; 297 298 continue; 299 } 300 301 /* 302 * Makes the finger detection more versatile. For example, 303 * two fingers with no gap will be detected. Also, my 304 * tests show it less likely to have intermittent loss 305 * of multiple finger readings while moving around (scrolling). 306 * 307 * Changes the multiple finger detection to counting humps on 308 * sensors (transitions from nonincreasing to increasing) 309 * instead of counting transitions from low sensors (no 310 * finger reading) to high sensors (finger above 311 * sensor) 312 * 313 * - Jason Parekh <jasonparekh@gmail.com> 314 */ 315 if (i < 1 || (!is_increasing && xy_sensors[i - 1] < xy_sensors[i])) { 316 (*fingers)++; 317 is_increasing = 1; 318 } else if (i > 0 && xy_sensors[i - 1] >= xy_sensors[i]) { 319 is_increasing = 0; 320 } 321 322 /* 323 * Subtracts threshold so a high sensor that just passes the threshold 324 * won't skew the calculated absolute coordinate. Fixes an issue 325 * where slowly moving the mouse would occassionaly jump a number of 326 * pixels (let me restate--slowly moving the mouse makes this issue 327 * most apparent). 328 */ 329 pcum += (xy_sensors[i] - threshold) * i; 330 psum += (xy_sensors[i] - threshold); 331 } 332 333 if (psum > 0) { 334 *z = psum; 335 return pcum * fact / psum; 336 } 337 338 return 0; 339 } 340 341 static inline void atp_report_fingers(struct input_dev *input, int fingers) 342 { 343 input_report_key(input, BTN_TOOL_FINGER, fingers == 1); 344 input_report_key(input, BTN_TOOL_DOUBLETAP, fingers == 2); 345 input_report_key(input, BTN_TOOL_TRIPLETAP, fingers > 2); 346 } 347 348 static void atp_complete(struct urb* urb) 349 { 350 int x, y, x_z, y_z, x_f, y_f; 351 int retval, i, j; 352 int key; 353 struct atp *dev = urb->context; 354 355 switch (urb->status) { 356 case 0: 357 /* success */ 358 break; 359 case -EOVERFLOW: 360 if(!dev->overflowwarn) { 361 printk(KERN_WARNING "appletouch: OVERFLOW with data " 362 "length %d, actual length is %d\n", 363 dev->datalen, dev->urb->actual_length); 364 dev->overflowwarn = 1; 365 } 366 case -ECONNRESET: 367 case -ENOENT: 368 case -ESHUTDOWN: 369 /* This urb is terminated, clean up */ 370 dbg("%s - urb shutting down with status: %d", 371 __FUNCTION__, urb->status); 372 return; 373 default: 374 dbg("%s - nonzero urb status received: %d", 375 __FUNCTION__, urb->status); 376 goto exit; 377 } 378 379 /* drop incomplete datasets */ 380 if (dev->urb->actual_length != dev->datalen) { 381 dprintk("appletouch: incomplete data package" 382 " (first byte: %d, length: %d).\n", 383 dev->data[0], dev->urb->actual_length); 384 goto exit; 385 } 386 387 /* reorder the sensors values */ 388 if (atp_is_geyser_3(dev)) { 389 memset(dev->xy_cur, 0, sizeof(dev->xy_cur)); 390 391 /* 392 * The values are laid out like this: 393 * -, Y1, Y2, -, Y3, Y4, -, ..., -, X1, X2, -, X3, X4, ... 394 * '-' is an unused value. 395 */ 396 397 /* read X values */ 398 for (i = 0, j = 19; i < 20; i += 2, j += 3) { 399 dev->xy_cur[i] = dev->data[j + 1]; 400 dev->xy_cur[i + 1] = dev->data[j + 2]; 401 } 402 /* read Y values */ 403 for (i = 0, j = 1; i < 9; i += 2, j += 3) { 404 dev->xy_cur[ATP_XSENSORS + i] = dev->data[j + 1]; 405 dev->xy_cur[ATP_XSENSORS + i + 1] = dev->data[j + 2]; 406 } 407 } else if (atp_is_geyser_2(dev)) { 408 memset(dev->xy_cur, 0, sizeof(dev->xy_cur)); 409 410 /* 411 * The values are laid out like this: 412 * Y1, Y2, -, Y3, Y4, -, ..., X1, X2, -, X3, X4, -, ... 413 * '-' is an unused value. 414 */ 415 416 /* read X values */ 417 for (i = 0, j = 19; i < 20; i += 2, j += 3) { 418 dev->xy_cur[i] = dev->data[j]; 419 dev->xy_cur[i + 1] = dev->data[j + 1]; 420 } 421 422 /* read Y values */ 423 for (i = 0, j = 1; i < 9; i += 2, j += 3) { 424 dev->xy_cur[ATP_XSENSORS + i] = dev->data[j]; 425 dev->xy_cur[ATP_XSENSORS + i + 1] = dev->data[j + 1]; 426 } 427 } else { 428 for (i = 0; i < 8; i++) { 429 /* X values */ 430 dev->xy_cur[i ] = dev->data[5 * i + 2]; 431 dev->xy_cur[i + 8] = dev->data[5 * i + 4]; 432 dev->xy_cur[i + 16] = dev->data[5 * i + 42]; 433 if (i < 2) 434 dev->xy_cur[i + 24] = dev->data[5 * i + 44]; 435 436 /* Y values */ 437 dev->xy_cur[i + 26] = dev->data[5 * i + 1]; 438 dev->xy_cur[i + 34] = dev->data[5 * i + 3]; 439 } 440 } 441 442 dbg_dump("sample", dev->xy_cur); 443 444 if (!dev->valid) { 445 /* first sample */ 446 dev->valid = 1; 447 dev->x_old = dev->y_old = -1; 448 memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old)); 449 450 if (dev->size_detect_done || 451 atp_is_geyser_3(dev)) /* No 17" Macbooks (yet) */ 452 goto exit; 453 454 /* 17" Powerbooks have extra X sensors */ 455 for (i = (atp_is_geyser_2(dev) ? 15 : 16); i < ATP_XSENSORS; i++) { 456 if (!dev->xy_cur[i]) 457 continue; 458 459 printk(KERN_INFO "appletouch: 17\" model detected.\n"); 460 if (atp_is_geyser_2(dev)) 461 input_set_abs_params(dev->input, ABS_X, 0, 462 (20 - 1) * 463 ATP_XFACT - 1, 464 ATP_FUZZ, 0); 465 else 466 input_set_abs_params(dev->input, ABS_X, 0, 467 (ATP_XSENSORS - 1) * 468 ATP_XFACT - 1, 469 ATP_FUZZ, 0); 470 break; 471 } 472 473 dev->size_detect_done = 1; 474 goto exit; 475 } 476 477 for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) { 478 /* accumulate the change */ 479 signed char change = dev->xy_old[i] - dev->xy_cur[i]; 480 dev->xy_acc[i] -= change; 481 482 /* prevent down drifting */ 483 if (dev->xy_acc[i] < 0) 484 dev->xy_acc[i] = 0; 485 } 486 487 memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old)); 488 489 dbg_dump("accumulator", dev->xy_acc); 490 491 x = atp_calculate_abs(dev->xy_acc, ATP_XSENSORS, 492 ATP_XFACT, &x_z, &x_f); 493 y = atp_calculate_abs(dev->xy_acc + ATP_XSENSORS, ATP_YSENSORS, 494 ATP_YFACT, &y_z, &y_f); 495 key = dev->data[dev->datalen - 1] & 1; 496 497 if (x && y) { 498 if (dev->x_old != -1) { 499 x = (dev->x_old * 3 + x) >> 2; 500 y = (dev->y_old * 3 + y) >> 2; 501 dev->x_old = x; 502 dev->y_old = y; 503 504 if (debug > 1) 505 printk(KERN_DEBUG "appletouch: X: %3d Y: %3d " 506 "Xz: %3d Yz: %3d\n", 507 x, y, x_z, y_z); 508 509 input_report_key(dev->input, BTN_TOUCH, 1); 510 input_report_abs(dev->input, ABS_X, x); 511 input_report_abs(dev->input, ABS_Y, y); 512 input_report_abs(dev->input, ABS_PRESSURE, 513 min(ATP_PRESSURE, x_z + y_z)); 514 atp_report_fingers(dev->input, max(x_f, y_f)); 515 } 516 dev->x_old = x; 517 dev->y_old = y; 518 519 } else if (!x && !y) { 520 521 dev->x_old = dev->y_old = -1; 522 input_report_key(dev->input, BTN_TOUCH, 0); 523 input_report_abs(dev->input, ABS_PRESSURE, 0); 524 atp_report_fingers(dev->input, 0); 525 526 /* reset the accumulator on release */ 527 memset(dev->xy_acc, 0, sizeof(dev->xy_acc)); 528 } 529 530 input_report_key(dev->input, BTN_LEFT, key); 531 input_sync(dev->input); 532 533 /* 534 * Many Geysers will continue to send packets continually after 535 * the first touch unless reinitialised. Do so if it's been 536 * idle for a while in order to avoid waking the kernel up 537 * several hundred times a second. Re-initialization does not 538 * work on Fountain touchpads. 539 */ 540 if (!atp_is_fountain(dev)) { 541 if (!x && !y && !key) { 542 dev->idlecount++; 543 if (dev->idlecount == 10) { 544 dev->valid = 0; 545 schedule_work(&dev->work); 546 /* Don't resubmit urb here, wait for reinit */ 547 return; 548 } 549 } else 550 dev->idlecount = 0; 551 } 552 553 exit: 554 retval = usb_submit_urb(dev->urb, GFP_ATOMIC); 555 if (retval) { 556 err("%s - usb_submit_urb failed with result %d", 557 __FUNCTION__, retval); 558 } 559 } 560 561 static int atp_open(struct input_dev *input) 562 { 563 struct atp *dev = input_get_drvdata(input); 564 565 if (usb_submit_urb(dev->urb, GFP_ATOMIC)) 566 return -EIO; 567 568 dev->open = 1; 569 return 0; 570 } 571 572 static void atp_close(struct input_dev *input) 573 { 574 struct atp *dev = input_get_drvdata(input); 575 576 usb_kill_urb(dev->urb); 577 cancel_work_sync(&dev->work); 578 dev->open = 0; 579 } 580 581 static int atp_probe(struct usb_interface *iface, const struct usb_device_id *id) 582 { 583 struct atp *dev; 584 struct input_dev *input_dev; 585 struct usb_device *udev = interface_to_usbdev(iface); 586 struct usb_host_interface *iface_desc; 587 struct usb_endpoint_descriptor *endpoint; 588 int int_in_endpointAddr = 0; 589 int i, error = -ENOMEM; 590 591 /* set up the endpoint information */ 592 /* use only the first interrupt-in endpoint */ 593 iface_desc = iface->cur_altsetting; 594 for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) { 595 endpoint = &iface_desc->endpoint[i].desc; 596 if (!int_in_endpointAddr && usb_endpoint_is_int_in(endpoint)) { 597 /* we found an interrupt in endpoint */ 598 int_in_endpointAddr = endpoint->bEndpointAddress; 599 break; 600 } 601 } 602 if (!int_in_endpointAddr) { 603 err("Could not find int-in endpoint"); 604 return -EIO; 605 } 606 607 /* allocate memory for our device state and initialize it */ 608 dev = kzalloc(sizeof(struct atp), GFP_KERNEL); 609 input_dev = input_allocate_device(); 610 if (!dev || !input_dev) { 611 err("Out of memory"); 612 goto err_free_devs; 613 } 614 615 dev->udev = udev; 616 dev->input = input_dev; 617 dev->overflowwarn = 0; 618 if (atp_is_geyser_3(dev)) 619 dev->datalen = 64; 620 else if (atp_is_geyser_2(dev)) 621 dev->datalen = 64; 622 else 623 dev->datalen = 81; 624 625 if (!atp_is_fountain(dev)) { 626 /* switch to raw sensor mode */ 627 if (atp_geyser_init(udev)) 628 goto err_free_devs; 629 630 printk(KERN_INFO "appletouch: Geyser mode initialized.\n"); 631 } 632 633 dev->urb = usb_alloc_urb(0, GFP_KERNEL); 634 if (!dev->urb) 635 goto err_free_devs; 636 637 dev->data = usb_buffer_alloc(dev->udev, dev->datalen, GFP_KERNEL, 638 &dev->urb->transfer_dma); 639 if (!dev->data) 640 goto err_free_urb; 641 642 usb_fill_int_urb(dev->urb, udev, 643 usb_rcvintpipe(udev, int_in_endpointAddr), 644 dev->data, dev->datalen, atp_complete, dev, 1); 645 646 usb_make_path(udev, dev->phys, sizeof(dev->phys)); 647 strlcat(dev->phys, "/input0", sizeof(dev->phys)); 648 649 input_dev->name = "appletouch"; 650 input_dev->phys = dev->phys; 651 usb_to_input_id(dev->udev, &input_dev->id); 652 input_dev->dev.parent = &iface->dev; 653 654 input_set_drvdata(input_dev, dev); 655 656 input_dev->open = atp_open; 657 input_dev->close = atp_close; 658 659 set_bit(EV_ABS, input_dev->evbit); 660 661 if (atp_is_geyser_3(dev)) { 662 /* 663 * MacBook have 20 X sensors, 10 Y sensors 664 */ 665 input_set_abs_params(input_dev, ABS_X, 0, 666 ((20 - 1) * ATP_XFACT) - 1, ATP_FUZZ, 0); 667 input_set_abs_params(input_dev, ABS_Y, 0, 668 ((10 - 1) * ATP_YFACT) - 1, ATP_FUZZ, 0); 669 } else if (atp_is_geyser_2(dev)) { 670 /* 671 * Oct 2005 15" PowerBooks have 15 X sensors, 17" are detected 672 * later. 673 */ 674 input_set_abs_params(input_dev, ABS_X, 0, 675 ((15 - 1) * ATP_XFACT) - 1, ATP_FUZZ, 0); 676 input_set_abs_params(input_dev, ABS_Y, 0, 677 ((9 - 1) * ATP_YFACT) - 1, ATP_FUZZ, 0); 678 } else { 679 /* 680 * 12" and 15" Powerbooks only have 16 x sensors, 681 * 17" models are detected later. 682 */ 683 input_set_abs_params(input_dev, ABS_X, 0, 684 (16 - 1) * ATP_XFACT - 1, ATP_FUZZ, 0); 685 input_set_abs_params(input_dev, ABS_Y, 0, 686 (ATP_YSENSORS - 1) * ATP_YFACT - 1, ATP_FUZZ, 0); 687 } 688 input_set_abs_params(input_dev, ABS_PRESSURE, 0, ATP_PRESSURE, 0, 0); 689 690 set_bit(EV_KEY, input_dev->evbit); 691 set_bit(BTN_TOUCH, input_dev->keybit); 692 set_bit(BTN_TOOL_FINGER, input_dev->keybit); 693 set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit); 694 set_bit(BTN_TOOL_TRIPLETAP, input_dev->keybit); 695 set_bit(BTN_LEFT, input_dev->keybit); 696 697 error = input_register_device(dev->input); 698 if (error) 699 goto err_free_buffer; 700 701 /* save our data pointer in this interface device */ 702 usb_set_intfdata(iface, dev); 703 704 INIT_WORK(&dev->work, atp_reinit); 705 706 return 0; 707 708 err_free_buffer: 709 usb_buffer_free(dev->udev, dev->datalen, 710 dev->data, dev->urb->transfer_dma); 711 err_free_urb: 712 usb_free_urb(dev->urb); 713 err_free_devs: 714 usb_set_intfdata(iface, NULL); 715 kfree(dev); 716 input_free_device(input_dev); 717 return error; 718 } 719 720 static void atp_disconnect(struct usb_interface *iface) 721 { 722 struct atp *dev = usb_get_intfdata(iface); 723 724 usb_set_intfdata(iface, NULL); 725 if (dev) { 726 usb_kill_urb(dev->urb); 727 input_unregister_device(dev->input); 728 usb_buffer_free(dev->udev, dev->datalen, 729 dev->data, dev->urb->transfer_dma); 730 usb_free_urb(dev->urb); 731 kfree(dev); 732 } 733 printk(KERN_INFO "input: appletouch disconnected\n"); 734 } 735 736 static int atp_suspend(struct usb_interface *iface, pm_message_t message) 737 { 738 struct atp *dev = usb_get_intfdata(iface); 739 740 usb_kill_urb(dev->urb); 741 dev->valid = 0; 742 743 return 0; 744 } 745 746 static int atp_resume(struct usb_interface *iface) 747 { 748 struct atp *dev = usb_get_intfdata(iface); 749 750 if (dev->open && usb_submit_urb(dev->urb, GFP_ATOMIC)) 751 return -EIO; 752 753 return 0; 754 } 755 756 static struct usb_driver atp_driver = { 757 .name = "appletouch", 758 .probe = atp_probe, 759 .disconnect = atp_disconnect, 760 .suspend = atp_suspend, 761 .resume = atp_resume, 762 .id_table = atp_table, 763 }; 764 765 static int __init atp_init(void) 766 { 767 return usb_register(&atp_driver); 768 } 769 770 static void __exit atp_exit(void) 771 { 772 usb_deregister(&atp_driver); 773 } 774 775 module_init(atp_init); 776 module_exit(atp_exit); 777