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-2008 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 * Copyright (C) 2007-2008 Sven Anders (anders@anduras.de) 12 * 13 * Thanks to Alex Harper <basilisk@foobox.net> for his inputs. 14 * 15 * This program is free software; you can redistribute it and/or modify 16 * it under the terms of the GNU General Public License as published by 17 * the Free Software Foundation; either version 2 of the License, or 18 * (at your option) any later version. 19 * 20 * This program is distributed in the hope that it will be useful, 21 * but WITHOUT ANY WARRANTY; without even the implied warranty of 22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 23 * GNU General Public License for more details. 24 * 25 * You should have received a copy of the GNU General Public License 26 * along with this program; if not, write to the Free Software 27 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 28 * 29 */ 30 31 #include <linux/kernel.h> 32 #include <linux/errno.h> 33 #include <linux/init.h> 34 #include <linux/slab.h> 35 #include <linux/module.h> 36 #include <linux/usb/input.h> 37 38 /* Type of touchpad */ 39 enum atp_touchpad_type { 40 ATP_FOUNTAIN, 41 ATP_GEYSER1, 42 ATP_GEYSER2, 43 ATP_GEYSER3, 44 ATP_GEYSER4 45 }; 46 47 #define ATP_DEVICE(prod, type) \ 48 { \ 49 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \ 50 USB_DEVICE_ID_MATCH_INT_CLASS | \ 51 USB_DEVICE_ID_MATCH_INT_PROTOCOL, \ 52 .idVendor = 0x05ac, /* Apple */ \ 53 .idProduct = (prod), \ 54 .bInterfaceClass = 0x03, \ 55 .bInterfaceProtocol = 0x02, \ 56 .driver_info = ATP_ ## type, \ 57 } 58 59 /* 60 * Table of devices (Product IDs) that work with this driver. 61 * (The names come from Info.plist in AppleUSBTrackpad.kext, 62 * According to Info.plist Geyser IV is the same as Geyser III.) 63 */ 64 65 static struct usb_device_id atp_table [] = { 66 /* PowerBooks Feb 2005, iBooks G4 */ 67 ATP_DEVICE(0x020e, FOUNTAIN), /* FOUNTAIN ANSI */ 68 ATP_DEVICE(0x020f, FOUNTAIN), /* FOUNTAIN ISO */ 69 ATP_DEVICE(0x030a, FOUNTAIN), /* FOUNTAIN TP ONLY */ 70 ATP_DEVICE(0x030b, GEYSER1), /* GEYSER 1 TP ONLY */ 71 72 /* PowerBooks Oct 2005 */ 73 ATP_DEVICE(0x0214, GEYSER2), /* GEYSER 2 ANSI */ 74 ATP_DEVICE(0x0215, GEYSER2), /* GEYSER 2 ISO */ 75 ATP_DEVICE(0x0216, GEYSER2), /* GEYSER 2 JIS */ 76 77 /* Core Duo MacBook & MacBook Pro */ 78 ATP_DEVICE(0x0217, GEYSER3), /* GEYSER 3 ANSI */ 79 ATP_DEVICE(0x0218, GEYSER3), /* GEYSER 3 ISO */ 80 ATP_DEVICE(0x0219, GEYSER3), /* GEYSER 3 JIS */ 81 82 /* Core2 Duo MacBook & MacBook Pro */ 83 ATP_DEVICE(0x021a, GEYSER4), /* GEYSER 4 ANSI */ 84 ATP_DEVICE(0x021b, GEYSER4), /* GEYSER 4 ISO */ 85 ATP_DEVICE(0x021c, GEYSER4), /* GEYSER 4 JIS */ 86 87 /* Core2 Duo MacBook3,1 */ 88 ATP_DEVICE(0x0229, GEYSER4), /* GEYSER 4 HF ANSI */ 89 ATP_DEVICE(0x022a, GEYSER4), /* GEYSER 4 HF ISO */ 90 ATP_DEVICE(0x022b, GEYSER4), /* GEYSER 4 HF JIS */ 91 92 /* Terminating entry */ 93 { } 94 }; 95 MODULE_DEVICE_TABLE(usb, atp_table); 96 97 /* 98 * number of sensors. Note that only 16 instead of 26 X (horizontal) 99 * sensors exist on 12" and 15" PowerBooks. All models have 16 Y 100 * (vertical) sensors. 101 */ 102 #define ATP_XSENSORS 26 103 #define ATP_YSENSORS 16 104 105 /* amount of fuzz this touchpad generates */ 106 #define ATP_FUZZ 16 107 108 /* maximum pressure this driver will report */ 109 #define ATP_PRESSURE 300 110 /* 111 * multiplication factor for the X and Y coordinates. 112 * We try to keep the touchpad aspect ratio while still doing only simple 113 * arithmetics. 114 * The factors below give coordinates like: 115 * 116 * 0 <= x < 960 on 12" and 15" Powerbooks 117 * 0 <= x < 1600 on 17" Powerbooks and 17" MacBook Pro 118 * 0 <= x < 1216 on MacBooks and 15" MacBook Pro 119 * 120 * 0 <= y < 646 on all Powerbooks 121 * 0 <= y < 774 on all MacBooks 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 /** 140 * enum atp_status_bits - status bit meanings 141 * 142 * These constants represent the meaning of the status bits. 143 * (only Geyser 3/4) 144 * 145 * @ATP_STATUS_BUTTON: The button was pressed 146 * @ATP_STATUS_BASE_UPDATE: Update of the base values (untouched pad) 147 * @ATP_STATUS_FROM_RESET: Reset previously performed 148 */ 149 enum atp_status_bits { 150 ATP_STATUS_BUTTON = BIT(0), 151 ATP_STATUS_BASE_UPDATE = BIT(2), 152 ATP_STATUS_FROM_RESET = BIT(4), 153 }; 154 155 /* Structure to hold all of our device specific stuff */ 156 struct atp { 157 char phys[64]; 158 struct usb_device *udev; /* usb device */ 159 struct urb *urb; /* usb request block */ 160 u8 *data; /* transferred data */ 161 struct input_dev *input; /* input dev */ 162 enum atp_touchpad_type type; /* type of touchpad */ 163 bool open; 164 bool valid; /* are the samples valid? */ 165 bool size_detect_done; 166 bool overflow_warned; 167 int x_old; /* last reported x/y, */ 168 int y_old; /* used for smoothing */ 169 signed char xy_cur[ATP_XSENSORS + ATP_YSENSORS]; 170 signed char xy_old[ATP_XSENSORS + ATP_YSENSORS]; 171 int xy_acc[ATP_XSENSORS + ATP_YSENSORS]; 172 int datalen; /* size of USB transfer */ 173 int idlecount; /* number of empty packets */ 174 struct work_struct work; 175 }; 176 177 #define dbg_dump(msg, tab) \ 178 if (debug > 1) { \ 179 int __i; \ 180 printk(KERN_DEBUG "appletouch: %s", msg); \ 181 for (__i = 0; __i < ATP_XSENSORS + ATP_YSENSORS; __i++) \ 182 printk(" %02x", tab[__i]); \ 183 printk("\n"); \ 184 } 185 186 #define dprintk(format, a...) \ 187 do { \ 188 if (debug) \ 189 printk(KERN_DEBUG format, ##a); \ 190 } while (0) 191 192 MODULE_AUTHOR("Johannes Berg"); 193 MODULE_AUTHOR("Stelian Pop"); 194 MODULE_AUTHOR("Frank Arnold"); 195 MODULE_AUTHOR("Michael Hanselmann"); 196 MODULE_AUTHOR("Sven Anders"); 197 MODULE_DESCRIPTION("Apple PowerBook and MacBook USB touchpad driver"); 198 MODULE_LICENSE("GPL"); 199 200 /* 201 * Make the threshold a module parameter 202 */ 203 static int threshold = ATP_THRESHOLD; 204 module_param(threshold, int, 0644); 205 MODULE_PARM_DESC(threshold, "Discard any change in data from a sensor" 206 " (the trackpad has many of these sensors)" 207 " less than this value."); 208 209 static int debug; 210 module_param(debug, int, 0644); 211 MODULE_PARM_DESC(debug, "Activate debugging output"); 212 213 /* 214 * By default newer Geyser devices send standard USB HID mouse 215 * packets (Report ID 2). This code changes device mode, so it 216 * sends raw sensor reports (Report ID 5). 217 */ 218 static int atp_geyser_init(struct usb_device *udev) 219 { 220 char data[8]; 221 int size; 222 int i; 223 224 size = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 225 ATP_GEYSER_MODE_READ_REQUEST_ID, 226 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 227 ATP_GEYSER_MODE_REQUEST_VALUE, 228 ATP_GEYSER_MODE_REQUEST_INDEX, &data, 8, 5000); 229 230 if (size != 8) { 231 dprintk("atp_geyser_init: read error\n"); 232 for (i = 0; i < 8; i++) 233 dprintk("appletouch[%d]: %d\n", i, data[i]); 234 235 err("Failed to read mode from device."); 236 return -EIO; 237 } 238 239 /* Apply the mode switch */ 240 data[0] = ATP_GEYSER_MODE_VENDOR_VALUE; 241 242 size = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 243 ATP_GEYSER_MODE_WRITE_REQUEST_ID, 244 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 245 ATP_GEYSER_MODE_REQUEST_VALUE, 246 ATP_GEYSER_MODE_REQUEST_INDEX, &data, 8, 5000); 247 248 if (size != 8) { 249 dprintk("atp_geyser_init: write error\n"); 250 for (i = 0; i < 8; i++) 251 dprintk("appletouch[%d]: %d\n", i, data[i]); 252 253 err("Failed to request geyser raw mode"); 254 return -EIO; 255 } 256 return 0; 257 } 258 259 /* 260 * Reinitialise the device. This usually stops stream of empty packets 261 * coming from it. 262 */ 263 static void atp_reinit(struct work_struct *work) 264 { 265 struct atp *dev = container_of(work, struct atp, work); 266 struct usb_device *udev = dev->udev; 267 int retval; 268 269 dprintk("appletouch: putting appletouch to sleep (reinit)\n"); 270 atp_geyser_init(udev); 271 272 retval = usb_submit_urb(dev->urb, GFP_ATOMIC); 273 if (retval) 274 err("atp_reinit: usb_submit_urb failed with error %d", 275 retval); 276 } 277 278 static int atp_calculate_abs(int *xy_sensors, int nb_sensors, int fact, 279 int *z, int *fingers) 280 { 281 int i; 282 /* values to calculate mean */ 283 int pcum = 0, psum = 0; 284 int is_increasing = 0; 285 286 *fingers = 0; 287 288 for (i = 0; i < nb_sensors; i++) { 289 if (xy_sensors[i] < threshold) { 290 if (is_increasing) 291 is_increasing = 0; 292 293 continue; 294 } 295 296 /* 297 * Makes the finger detection more versatile. For example, 298 * two fingers with no gap will be detected. Also, my 299 * tests show it less likely to have intermittent loss 300 * of multiple finger readings while moving around (scrolling). 301 * 302 * Changes the multiple finger detection to counting humps on 303 * sensors (transitions from nonincreasing to increasing) 304 * instead of counting transitions from low sensors (no 305 * finger reading) to high sensors (finger above 306 * sensor) 307 * 308 * - Jason Parekh <jasonparekh@gmail.com> 309 */ 310 if (i < 1 || 311 (!is_increasing && xy_sensors[i - 1] < xy_sensors[i])) { 312 (*fingers)++; 313 is_increasing = 1; 314 } else if (i > 0 && xy_sensors[i - 1] >= xy_sensors[i]) { 315 is_increasing = 0; 316 } 317 318 /* 319 * Subtracts threshold so a high sensor that just passes the 320 * threshold won't skew the calculated absolute coordinate. 321 * Fixes an issue where slowly moving the mouse would 322 * occasionally jump a number of pixels (slowly moving the 323 * finger makes this issue most apparent.) 324 */ 325 pcum += (xy_sensors[i] - threshold) * i; 326 psum += (xy_sensors[i] - threshold); 327 } 328 329 if (psum > 0) { 330 *z = psum; 331 return pcum * fact / psum; 332 } 333 334 return 0; 335 } 336 337 static inline void atp_report_fingers(struct input_dev *input, int fingers) 338 { 339 input_report_key(input, BTN_TOOL_FINGER, fingers == 1); 340 input_report_key(input, BTN_TOOL_DOUBLETAP, fingers == 2); 341 input_report_key(input, BTN_TOOL_TRIPLETAP, fingers > 2); 342 } 343 344 /* Check URB status and for correct length of data package */ 345 346 #define ATP_URB_STATUS_SUCCESS 0 347 #define ATP_URB_STATUS_ERROR 1 348 #define ATP_URB_STATUS_ERROR_FATAL 2 349 350 static int atp_status_check(struct urb *urb) 351 { 352 struct atp *dev = urb->context; 353 354 switch (urb->status) { 355 case 0: 356 /* success */ 357 break; 358 case -EOVERFLOW: 359 if (!dev->overflow_warned) { 360 printk(KERN_WARNING "appletouch: OVERFLOW with data " 361 "length %d, actual length is %d\n", 362 dev->datalen, dev->urb->actual_length); 363 dev->overflow_warned = true; 364 } 365 case -ECONNRESET: 366 case -ENOENT: 367 case -ESHUTDOWN: 368 /* This urb is terminated, clean up */ 369 dbg("atp_complete: urb shutting down with status: %d", 370 urb->status); 371 return ATP_URB_STATUS_ERROR_FATAL; 372 373 default: 374 dbg("atp_complete: nonzero urb status received: %d", 375 urb->status); 376 return ATP_URB_STATUS_ERROR; 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 return ATP_URB_STATUS_ERROR; 385 } 386 387 return ATP_URB_STATUS_SUCCESS; 388 } 389 390 /* 391 * USB interrupt callback functions 392 */ 393 394 /* Interrupt function for older touchpads: FOUNTAIN/GEYSER1/GEYSER2 */ 395 396 static void atp_complete_geyser_1_2(struct urb *urb) 397 { 398 int x, y, x_z, y_z, x_f, y_f; 399 int retval, i, j; 400 int key; 401 struct atp *dev = urb->context; 402 int status = atp_status_check(urb); 403 404 if (status == ATP_URB_STATUS_ERROR_FATAL) 405 return; 406 else if (status == ATP_URB_STATUS_ERROR) 407 goto exit; 408 409 /* reorder the sensors values */ 410 if (dev->type == ATP_GEYSER2) { 411 memset(dev->xy_cur, 0, sizeof(dev->xy_cur)); 412 413 /* 414 * The values are laid out like this: 415 * Y1, Y2, -, Y3, Y4, -, ..., X1, X2, -, X3, X4, -, ... 416 * '-' is an unused value. 417 */ 418 419 /* read X values */ 420 for (i = 0, j = 19; i < 20; i += 2, j += 3) { 421 dev->xy_cur[i] = dev->data[j]; 422 dev->xy_cur[i + 1] = dev->data[j + 1]; 423 } 424 425 /* read Y values */ 426 for (i = 0, j = 1; i < 9; i += 2, j += 3) { 427 dev->xy_cur[ATP_XSENSORS + i] = dev->data[j]; 428 dev->xy_cur[ATP_XSENSORS + i + 1] = dev->data[j + 1]; 429 } 430 } else { 431 for (i = 0; i < 8; i++) { 432 /* X values */ 433 dev->xy_cur[i + 0] = dev->data[5 * i + 2]; 434 dev->xy_cur[i + 8] = dev->data[5 * i + 4]; 435 dev->xy_cur[i + 16] = dev->data[5 * i + 42]; 436 if (i < 2) 437 dev->xy_cur[i + 24] = dev->data[5 * i + 44]; 438 439 /* Y values */ 440 dev->xy_cur[i + 26] = dev->data[5 * i + 1]; 441 dev->xy_cur[i + 34] = dev->data[5 * i + 3]; 442 } 443 } 444 445 dbg_dump("sample", dev->xy_cur); 446 447 if (!dev->valid) { 448 /* first sample */ 449 dev->valid = true; 450 dev->x_old = dev->y_old = -1; 451 452 /* Store first sample */ 453 memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old)); 454 455 /* Perform size detection, if not done already */ 456 if (!dev->size_detect_done) { 457 458 /* 17" Powerbooks have extra X sensors */ 459 for (i = (dev->type == ATP_GEYSER2 ? 15 : 16); 460 i < ATP_XSENSORS; i++) { 461 if (!dev->xy_cur[i]) 462 continue; 463 464 printk(KERN_INFO 465 "appletouch: 17\" model detected.\n"); 466 467 if (dev->type == ATP_GEYSER2) 468 input_set_abs_params(dev->input, ABS_X, 469 0, 470 (20 - 1) * 471 ATP_XFACT - 1, 472 ATP_FUZZ, 0); 473 else 474 input_set_abs_params(dev->input, ABS_X, 475 0, 476 (26 - 1) * 477 ATP_XFACT - 1, 478 ATP_FUZZ, 0); 479 break; 480 } 481 482 dev->size_detect_done = 1; 483 goto exit; 484 } 485 } 486 487 for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) { 488 /* accumulate the change */ 489 signed char change = dev->xy_old[i] - dev->xy_cur[i]; 490 dev->xy_acc[i] -= change; 491 492 /* prevent down drifting */ 493 if (dev->xy_acc[i] < 0) 494 dev->xy_acc[i] = 0; 495 } 496 497 memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old)); 498 499 dbg_dump("accumulator", dev->xy_acc); 500 501 x = atp_calculate_abs(dev->xy_acc, ATP_XSENSORS, 502 ATP_XFACT, &x_z, &x_f); 503 y = atp_calculate_abs(dev->xy_acc + ATP_XSENSORS, ATP_YSENSORS, 504 ATP_YFACT, &y_z, &y_f); 505 key = dev->data[dev->datalen - 1] & ATP_STATUS_BUTTON; 506 507 if (x && y) { 508 if (dev->x_old != -1) { 509 x = (dev->x_old * 3 + x) >> 2; 510 y = (dev->y_old * 3 + y) >> 2; 511 dev->x_old = x; 512 dev->y_old = y; 513 514 if (debug > 1) 515 printk(KERN_DEBUG "appletouch: " 516 "X: %3d Y: %3d Xz: %3d Yz: %3d\n", 517 x, y, x_z, y_z); 518 519 input_report_key(dev->input, BTN_TOUCH, 1); 520 input_report_abs(dev->input, ABS_X, x); 521 input_report_abs(dev->input, ABS_Y, y); 522 input_report_abs(dev->input, ABS_PRESSURE, 523 min(ATP_PRESSURE, x_z + y_z)); 524 atp_report_fingers(dev->input, max(x_f, y_f)); 525 } 526 dev->x_old = x; 527 dev->y_old = y; 528 529 } else if (!x && !y) { 530 531 dev->x_old = dev->y_old = -1; 532 input_report_key(dev->input, BTN_TOUCH, 0); 533 input_report_abs(dev->input, ABS_PRESSURE, 0); 534 atp_report_fingers(dev->input, 0); 535 536 /* reset the accumulator on release */ 537 memset(dev->xy_acc, 0, sizeof(dev->xy_acc)); 538 } 539 540 input_report_key(dev->input, BTN_LEFT, key); 541 input_sync(dev->input); 542 543 exit: 544 retval = usb_submit_urb(dev->urb, GFP_ATOMIC); 545 if (retval) 546 err("atp_complete: usb_submit_urb failed with result %d", 547 retval); 548 } 549 550 /* Interrupt function for older touchpads: GEYSER3/GEYSER4 */ 551 552 static void atp_complete_geyser_3_4(struct urb *urb) 553 { 554 int x, y, x_z, y_z, x_f, y_f; 555 int retval, i, j; 556 int key; 557 struct atp *dev = urb->context; 558 int status = atp_status_check(urb); 559 560 if (status == ATP_URB_STATUS_ERROR_FATAL) 561 return; 562 else if (status == ATP_URB_STATUS_ERROR) 563 goto exit; 564 565 /* Reorder the sensors values: 566 * 567 * The values are laid out like this: 568 * -, Y1, Y2, -, Y3, Y4, -, ..., -, X1, X2, -, X3, X4, ... 569 * '-' is an unused value. 570 */ 571 572 /* read X values */ 573 for (i = 0, j = 19; i < 20; i += 2, j += 3) { 574 dev->xy_cur[i] = dev->data[j + 1]; 575 dev->xy_cur[i + 1] = dev->data[j + 2]; 576 } 577 /* read Y values */ 578 for (i = 0, j = 1; i < 9; i += 2, j += 3) { 579 dev->xy_cur[ATP_XSENSORS + i] = dev->data[j + 1]; 580 dev->xy_cur[ATP_XSENSORS + i + 1] = dev->data[j + 2]; 581 } 582 583 dbg_dump("sample", dev->xy_cur); 584 585 /* Just update the base values (i.e. touchpad in untouched state) */ 586 if (dev->data[dev->datalen - 1] & ATP_STATUS_BASE_UPDATE) { 587 588 dprintk(KERN_DEBUG "appletouch: updated base values\n"); 589 590 memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old)); 591 goto exit; 592 } 593 594 for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) { 595 /* calculate the change */ 596 dev->xy_acc[i] = dev->xy_cur[i] - dev->xy_old[i]; 597 598 /* this is a round-robin value, so couple with that */ 599 if (dev->xy_acc[i] > 127) 600 dev->xy_acc[i] -= 256; 601 602 if (dev->xy_acc[i] < -127) 603 dev->xy_acc[i] += 256; 604 605 /* prevent down drifting */ 606 if (dev->xy_acc[i] < 0) 607 dev->xy_acc[i] = 0; 608 } 609 610 dbg_dump("accumulator", dev->xy_acc); 611 612 x = atp_calculate_abs(dev->xy_acc, ATP_XSENSORS, 613 ATP_XFACT, &x_z, &x_f); 614 y = atp_calculate_abs(dev->xy_acc + ATP_XSENSORS, ATP_YSENSORS, 615 ATP_YFACT, &y_z, &y_f); 616 key = dev->data[dev->datalen - 1] & ATP_STATUS_BUTTON; 617 618 if (x && y) { 619 if (dev->x_old != -1) { 620 x = (dev->x_old * 3 + x) >> 2; 621 y = (dev->y_old * 3 + y) >> 2; 622 dev->x_old = x; 623 dev->y_old = y; 624 625 if (debug > 1) 626 printk(KERN_DEBUG "appletouch: X: %3d Y: %3d " 627 "Xz: %3d Yz: %3d\n", 628 x, y, x_z, y_z); 629 630 input_report_key(dev->input, BTN_TOUCH, 1); 631 input_report_abs(dev->input, ABS_X, x); 632 input_report_abs(dev->input, ABS_Y, y); 633 input_report_abs(dev->input, ABS_PRESSURE, 634 min(ATP_PRESSURE, x_z + y_z)); 635 atp_report_fingers(dev->input, max(x_f, y_f)); 636 } 637 dev->x_old = x; 638 dev->y_old = y; 639 640 } else if (!x && !y) { 641 642 dev->x_old = dev->y_old = -1; 643 input_report_key(dev->input, BTN_TOUCH, 0); 644 input_report_abs(dev->input, ABS_PRESSURE, 0); 645 atp_report_fingers(dev->input, 0); 646 647 /* reset the accumulator on release */ 648 memset(dev->xy_acc, 0, sizeof(dev->xy_acc)); 649 } 650 651 input_report_key(dev->input, BTN_LEFT, key); 652 input_sync(dev->input); 653 654 /* 655 * Geysers 3/4 will continue to send packets continually after 656 * the first touch unless reinitialised. Do so if it's been 657 * idle for a while in order to avoid waking the kernel up 658 * several hundred times a second. 659 */ 660 661 /* 662 * Button must not be pressed when entering suspend, 663 * otherwise we will never release the button. 664 */ 665 if (!x && !y && !key) { 666 dev->idlecount++; 667 if (dev->idlecount == 10) { 668 dev->x_old = dev->y_old = -1; 669 dev->idlecount = 0; 670 schedule_work(&dev->work); 671 /* Don't resubmit urb here, wait for reinit */ 672 return; 673 } 674 } else 675 dev->idlecount = 0; 676 677 exit: 678 retval = usb_submit_urb(dev->urb, GFP_ATOMIC); 679 if (retval) 680 err("atp_complete: usb_submit_urb failed with result %d", 681 retval); 682 } 683 684 static int atp_open(struct input_dev *input) 685 { 686 struct atp *dev = input_get_drvdata(input); 687 688 if (usb_submit_urb(dev->urb, GFP_ATOMIC)) 689 return -EIO; 690 691 dev->open = 1; 692 return 0; 693 } 694 695 static void atp_close(struct input_dev *input) 696 { 697 struct atp *dev = input_get_drvdata(input); 698 699 usb_kill_urb(dev->urb); 700 cancel_work_sync(&dev->work); 701 dev->open = 0; 702 } 703 704 static int atp_handle_geyser(struct atp *dev) 705 { 706 struct usb_device *udev = dev->udev; 707 708 if (dev->type != ATP_FOUNTAIN) { 709 /* switch to raw sensor mode */ 710 if (atp_geyser_init(udev)) 711 return -EIO; 712 713 printk(KERN_INFO "appletouch: Geyser mode initialized.\n"); 714 } 715 716 return 0; 717 } 718 719 static int atp_probe(struct usb_interface *iface, 720 const struct usb_device_id *id) 721 { 722 struct atp *dev; 723 struct input_dev *input_dev; 724 struct usb_device *udev = interface_to_usbdev(iface); 725 struct usb_host_interface *iface_desc; 726 struct usb_endpoint_descriptor *endpoint; 727 int int_in_endpointAddr = 0; 728 int i, error = -ENOMEM; 729 730 /* set up the endpoint information */ 731 /* use only the first interrupt-in endpoint */ 732 iface_desc = iface->cur_altsetting; 733 for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) { 734 endpoint = &iface_desc->endpoint[i].desc; 735 if (!int_in_endpointAddr && usb_endpoint_is_int_in(endpoint)) { 736 /* we found an interrupt in endpoint */ 737 int_in_endpointAddr = endpoint->bEndpointAddress; 738 break; 739 } 740 } 741 if (!int_in_endpointAddr) { 742 err("Could not find int-in endpoint"); 743 return -EIO; 744 } 745 746 /* allocate memory for our device state and initialize it */ 747 dev = kzalloc(sizeof(struct atp), GFP_KERNEL); 748 input_dev = input_allocate_device(); 749 if (!dev || !input_dev) { 750 err("Out of memory"); 751 goto err_free_devs; 752 } 753 754 dev->udev = udev; 755 dev->input = input_dev; 756 dev->type = id->driver_info; 757 dev->overflow_warned = false; 758 if (dev->type == ATP_FOUNTAIN || dev->type == ATP_GEYSER1) 759 dev->datalen = 81; 760 else 761 dev->datalen = 64; 762 763 dev->urb = usb_alloc_urb(0, GFP_KERNEL); 764 if (!dev->urb) 765 goto err_free_devs; 766 767 dev->data = usb_buffer_alloc(dev->udev, dev->datalen, GFP_KERNEL, 768 &dev->urb->transfer_dma); 769 if (!dev->data) 770 goto err_free_urb; 771 772 /* Select the USB complete (callback) function */ 773 if (dev->type == ATP_FOUNTAIN || 774 dev->type == ATP_GEYSER1 || 775 dev->type == ATP_GEYSER2) 776 usb_fill_int_urb(dev->urb, udev, 777 usb_rcvintpipe(udev, int_in_endpointAddr), 778 dev->data, dev->datalen, 779 atp_complete_geyser_1_2, dev, 1); 780 else 781 usb_fill_int_urb(dev->urb, udev, 782 usb_rcvintpipe(udev, int_in_endpointAddr), 783 dev->data, dev->datalen, 784 atp_complete_geyser_3_4, dev, 1); 785 786 error = atp_handle_geyser(dev); 787 if (error) 788 goto err_free_buffer; 789 790 usb_make_path(udev, dev->phys, sizeof(dev->phys)); 791 strlcat(dev->phys, "/input0", sizeof(dev->phys)); 792 793 input_dev->name = "appletouch"; 794 input_dev->phys = dev->phys; 795 usb_to_input_id(dev->udev, &input_dev->id); 796 input_dev->dev.parent = &iface->dev; 797 798 input_set_drvdata(input_dev, dev); 799 800 input_dev->open = atp_open; 801 input_dev->close = atp_close; 802 803 set_bit(EV_ABS, input_dev->evbit); 804 805 if (dev->type == ATP_GEYSER3 || dev->type == ATP_GEYSER4) { 806 /* 807 * MacBook have 20 X sensors, 10 Y sensors 808 */ 809 input_set_abs_params(input_dev, ABS_X, 0, 810 ((20 - 1) * ATP_XFACT) - 1, ATP_FUZZ, 0); 811 input_set_abs_params(input_dev, ABS_Y, 0, 812 ((10 - 1) * ATP_YFACT) - 1, ATP_FUZZ, 0); 813 } else if (dev->type == ATP_GEYSER2) { 814 /* 815 * Oct 2005 15" PowerBooks have 15 X sensors, 17" are detected 816 * later. 817 */ 818 input_set_abs_params(input_dev, ABS_X, 0, 819 ((15 - 1) * ATP_XFACT) - 1, ATP_FUZZ, 0); 820 input_set_abs_params(input_dev, ABS_Y, 0, 821 ((9 - 1) * ATP_YFACT) - 1, ATP_FUZZ, 0); 822 } else { 823 /* 824 * 12" and 15" Powerbooks only have 16 x sensors, 825 * 17" models are detected later. 826 */ 827 input_set_abs_params(input_dev, ABS_X, 0, 828 (16 - 1) * ATP_XFACT - 1, 829 ATP_FUZZ, 0); 830 input_set_abs_params(input_dev, ABS_Y, 0, 831 (ATP_YSENSORS - 1) * ATP_YFACT - 1, 832 ATP_FUZZ, 0); 833 } 834 input_set_abs_params(input_dev, ABS_PRESSURE, 0, ATP_PRESSURE, 0, 0); 835 836 set_bit(EV_KEY, input_dev->evbit); 837 set_bit(BTN_TOUCH, input_dev->keybit); 838 set_bit(BTN_TOOL_FINGER, input_dev->keybit); 839 set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit); 840 set_bit(BTN_TOOL_TRIPLETAP, input_dev->keybit); 841 set_bit(BTN_LEFT, input_dev->keybit); 842 843 error = input_register_device(dev->input); 844 if (error) 845 goto err_free_buffer; 846 847 /* save our data pointer in this interface device */ 848 usb_set_intfdata(iface, dev); 849 850 INIT_WORK(&dev->work, atp_reinit); 851 852 return 0; 853 854 err_free_buffer: 855 usb_buffer_free(dev->udev, dev->datalen, 856 dev->data, dev->urb->transfer_dma); 857 err_free_urb: 858 usb_free_urb(dev->urb); 859 err_free_devs: 860 usb_set_intfdata(iface, NULL); 861 kfree(dev); 862 input_free_device(input_dev); 863 return error; 864 } 865 866 static void atp_disconnect(struct usb_interface *iface) 867 { 868 struct atp *dev = usb_get_intfdata(iface); 869 870 usb_set_intfdata(iface, NULL); 871 if (dev) { 872 usb_kill_urb(dev->urb); 873 input_unregister_device(dev->input); 874 usb_buffer_free(dev->udev, dev->datalen, 875 dev->data, dev->urb->transfer_dma); 876 usb_free_urb(dev->urb); 877 kfree(dev); 878 } 879 printk(KERN_INFO "input: appletouch disconnected\n"); 880 } 881 882 static int atp_recover(struct atp *dev) 883 { 884 int error; 885 886 error = atp_handle_geyser(dev); 887 if (error) 888 return error; 889 890 if (dev->open && usb_submit_urb(dev->urb, GFP_ATOMIC)) 891 return -EIO; 892 893 return 0; 894 } 895 896 static int atp_suspend(struct usb_interface *iface, pm_message_t message) 897 { 898 struct atp *dev = usb_get_intfdata(iface); 899 900 usb_kill_urb(dev->urb); 901 return 0; 902 } 903 904 static int atp_resume(struct usb_interface *iface) 905 { 906 struct atp *dev = usb_get_intfdata(iface); 907 908 if (dev->open && usb_submit_urb(dev->urb, GFP_ATOMIC)) 909 return -EIO; 910 911 return 0; 912 } 913 914 static int atp_reset_resume(struct usb_interface *iface) 915 { 916 struct atp *dev = usb_get_intfdata(iface); 917 918 return atp_recover(dev); 919 } 920 921 static struct usb_driver atp_driver = { 922 .name = "appletouch", 923 .probe = atp_probe, 924 .disconnect = atp_disconnect, 925 .suspend = atp_suspend, 926 .resume = atp_resume, 927 .reset_resume = atp_reset_resume, 928 .id_table = atp_table, 929 }; 930 931 static int __init atp_init(void) 932 { 933 return usb_register(&atp_driver); 934 } 935 936 static void __exit atp_exit(void) 937 { 938 usb_deregister(&atp_driver); 939 } 940 941 module_init(atp_init); 942 module_exit(atp_exit); 943