git.oblomov.eu Git - linux-2.6/blob - drivers/input/mouse/appletouch.c

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