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