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 ([email protected])
   5  * Copyright (C) 2005-2008 Johannes Berg ([email protected])
   6  * Copyright (C) 2005-2008 Stelian Pop ([email protected])
   7  * Copyright (C) 2005      Frank Arnold ([email protected])
   8  * Copyright (C) 2005      Peter Osterlund ([email protected])
   9  * Copyright (C) 2005      Michael Hanselmann ([email protected])
  10  * Copyright (C) 2006      Nicolas Boichat ([email protected])
  11  * Copyright (C) 2007-2008 Sven Anders ([email protected])
  12  *
  13  * Thanks to Alex Harper <[email protected]> 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 usb_interface    *intf;          /* usb interface */
 199         struct urb              *urb;           /* usb request block */
 200         u8                      *data;          /* transferred data */
 201         struct input_dev        *input;         /* input dev */
 202         const struct atp_info   *info;          /* touchpad model */
 203         bool                    open;
 204         bool                    valid;          /* are the samples valid? */
 205         bool                    size_detect_done;
 206         bool                    overflow_warned;
 207         int                     x_old;          /* last reported x/y, */
 208         int                     y_old;          /* used for smoothing */
 209         signed char             xy_cur[ATP_XSENSORS + ATP_YSENSORS];
 210         signed char             xy_old[ATP_XSENSORS + ATP_YSENSORS];
 211         int                     xy_acc[ATP_XSENSORS + ATP_YSENSORS];
 212         int                     idlecount;      /* number of empty packets */
 213         struct work_struct      work;
 214 };
 215
 216 #define dbg_dump(msg, tab) \
 217         if (debug > 1) {                                                \
 218                 int __i;                                                \
 219                 printk(KERN_DEBUG "appletouch: %s", msg);               \
 220                 for (__i = 0; __i < ATP_XSENSORS + ATP_YSENSORS; __i++) \
 221                         printk(" %02x", tab[__i]);                      \
 222                 printk("\n");                                           \
 223         }
 224
 225 #define dprintk(format, a...)                                           \
 226         do {                                                            \
 227                 if (debug)                                              \
 228                         printk(KERN_DEBUG format, ##a);                 \
 229         } while (0)
 230
 231 MODULE_AUTHOR("Johannes Berg");
 232 MODULE_AUTHOR("Stelian Pop");
 233 MODULE_AUTHOR("Frank Arnold");
 234 MODULE_AUTHOR("Michael Hanselmann");
 235 MODULE_AUTHOR("Sven Anders");
 236 MODULE_DESCRIPTION("Apple PowerBook and MacBook USB touchpad driver");
 237 MODULE_LICENSE("GPL");
 238
 239 /*
 240  * Make the threshold a module parameter
 241  */
 242 static int threshold = ATP_THRESHOLD;
 243 module_param(threshold, int, 0644);
 244 MODULE_PARM_DESC(threshold, "Discard any change in data from a sensor"
 245                             " (the trackpad has many of these sensors)"
 246                             " less than this value.");
 247
 248 static int debug;
 249 module_param(debug, int, 0644);
 250 MODULE_PARM_DESC(debug, "Activate debugging output");
 251
 252 /*
 253  * By default newer Geyser devices send standard USB HID mouse
 254  * packets (Report ID 2). This code changes device mode, so it
 255  * sends raw sensor reports (Report ID 5).
 256  */
 257 static int atp_geyser_init(struct atp *dev)
 258 {
 259         struct usb_device *udev = dev->udev;
 260         char *data;
 261         int size;
 262         int i;
 263         int ret;
 264
 265         data = kmalloc(8, GFP_KERNEL);
 266         if (!data) {
 267                 dev_err(&dev->intf->dev, "Out of memory\n");
 268                 return -ENOMEM;
 269         }
 270
 271         size = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
 272                         ATP_GEYSER_MODE_READ_REQUEST_ID,
 273                         USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 274                         ATP_GEYSER_MODE_REQUEST_VALUE,
 275                         ATP_GEYSER_MODE_REQUEST_INDEX, data, 8, 5000);
 276
 277         if (size != 8) {
 278                 dprintk("atp_geyser_init: read error\n");
 279                 for (i = 0; i < 8; i++)
 280                         dprintk("appletouch[%d]: %d\n", i, data[i]);
 281
 282                 dev_err(&dev->intf->dev, "Failed to read mode from device.\n");
 283                 ret = -EIO;
 284                 goto out_free;
 285         }
 286
 287         /* Apply the mode switch */
 288         data[0] = ATP_GEYSER_MODE_VENDOR_VALUE;
 289
 290         size = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
 291                         ATP_GEYSER_MODE_WRITE_REQUEST_ID,
 292                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 293                         ATP_GEYSER_MODE_REQUEST_VALUE,
 294                         ATP_GEYSER_MODE_REQUEST_INDEX, data, 8, 5000);
 295
 296         if (size != 8) {
 297                 dprintk("atp_geyser_init: write error\n");
 298                 for (i = 0; i < 8; i++)
 299                         dprintk("appletouch[%d]: %d\n", i, data[i]);
 300
 301                 dev_err(&dev->intf->dev, "Failed to request geyser raw mode\n");
 302                 ret = -EIO;
 303                 goto out_free;
 304         }
 305         ret = 0;
 306 out_free:
 307         kfree(data);
 308         return ret;
 309 }
 310
 311 /*
 312  * Reinitialise the device. This usually stops stream of empty packets
 313  * coming from it.
 314  */
 315 static void atp_reinit(struct work_struct *work)
 316 {
 317         struct atp *dev = container_of(work, struct atp, work);
 318         int retval;
 319
 320         dprintk("appletouch: putting appletouch to sleep (reinit)\n");
 321         atp_geyser_init(dev);
 322
 323         retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
 324         if (retval)
 325                 dev_err(&dev->intf->dev,
 326                         "atp_reinit: usb_submit_urb failed with error %d\n",
 327                         retval);
 328 }
 329
 330 static int atp_calculate_abs(int *xy_sensors, int nb_sensors, int fact,
 331                              int *z, int *fingers)
 332 {
 333         int i;
 334         /* values to calculate mean */
 335         int pcum = 0, psum = 0;
 336         int is_increasing = 0;
 337
 338         *fingers = 0;
 339
 340         for (i = 0; i < nb_sensors; i++) {
 341                 if (xy_sensors[i] < threshold) {
 342                         if (is_increasing)
 343                                 is_increasing = 0;
 344
 345                         continue;
 346                 }
 347
 348                 /*
 349                  * Makes the finger detection more versatile.  For example,
 350                  * two fingers with no gap will be detected.  Also, my
 351                  * tests show it less likely to have intermittent loss
 352                  * of multiple finger readings while moving around (scrolling).
 353                  *
 354                  * Changes the multiple finger detection to counting humps on
 355                  * sensors (transitions from nonincreasing to increasing)
 356                  * instead of counting transitions from low sensors (no
 357                  * finger reading) to high sensors (finger above
 358                  * sensor)
 359                  *
 360                  * - Jason Parekh <[email protected]>
 361                  */
 362                 if (i < 1 ||
 363                     (!is_increasing && xy_sensors[i - 1] < xy_sensors[i])) {
 364                         (*fingers)++;
 365                         is_increasing = 1;
 366                 } else if (i > 0 && (xy_sensors[i - 1] - xy_sensors[i] > threshold)) {
 367                         is_increasing = 0;
 368                 }
 369
 370                 /*
 371                  * Subtracts threshold so a high sensor that just passes the
 372                  * threshold won't skew the calculated absolute coordinate.
 373                  * Fixes an issue where slowly moving the mouse would
 374                  * occasionally jump a number of pixels (slowly moving the
 375                  * finger makes this issue most apparent.)
 376                  */
 377                 pcum += (xy_sensors[i] - threshold) * i;
 378                 psum += (xy_sensors[i] - threshold);
 379         }
 380
 381         if (psum > 0) {
 382                 *z = psum;
 383                 return pcum * fact / psum;
 384         }
 385
 386         return 0;
 387 }
 388
 389 static inline void atp_report_fingers(struct input_dev *input, int fingers)
 390 {
 391         input_report_key(input, BTN_TOOL_FINGER, fingers == 1);
 392         input_report_key(input, BTN_TOOL_DOUBLETAP, fingers == 2);
 393         input_report_key(input, BTN_TOOL_TRIPLETAP, fingers > 2);
 394 }
 395
 396 /* Check URB status and for correct length of data package */
 397
 398 #define ATP_URB_STATUS_SUCCESS          0
 399 #define ATP_URB_STATUS_ERROR            1
 400 #define ATP_URB_STATUS_ERROR_FATAL      2
 401
 402 static int atp_status_check(struct urb *urb)
 403 {
 404         struct atp *dev = urb->context;
 405         struct usb_interface *intf = dev->intf;
 406
 407         switch (urb->status) {
 408         case 0:
 409                 /* success */
 410                 break;
 411         case -EOVERFLOW:
 412                 if (!dev->overflow_warned) {
 413                         dev_warn(&intf->dev,
 414                                 "appletouch: OVERFLOW with data length %d, actual length is %d\n",
 415                                 dev->info->datalen, dev->urb->actual_length);
 416                         dev->overflow_warned = true;
 417                 }
 418         case -ECONNRESET:
 419         case -ENOENT:
 420         case -ESHUTDOWN:
 421                 /* This urb is terminated, clean up */
 422                 dev_dbg(&intf->dev,
 423                         "atp_complete: urb shutting down with status: %d\n",
 424                         urb->status);
 425                 return ATP_URB_STATUS_ERROR_FATAL;
 426
 427         default:
 428                 dev_dbg(&intf->dev,
 429                         "atp_complete: nonzero urb status received: %d\n",
 430                         urb->status);
 431                 return ATP_URB_STATUS_ERROR;
 432         }
 433
 434         /* drop incomplete datasets */
 435         if (dev->urb->actual_length != dev->info->datalen) {
 436                 dprintk("appletouch: incomplete data package"
 437                         " (first byte: %d, length: %d).\n",
 438                         dev->data[0], dev->urb->actual_length);
 439                 return ATP_URB_STATUS_ERROR;
 440         }
 441
 442         return ATP_URB_STATUS_SUCCESS;
 443 }
 444
 445 static void atp_detect_size(struct atp *dev)
 446 {
 447         int i;
 448
 449         /* 17" Powerbooks have extra X sensors */
 450         for (i = dev->info->xsensors; i < ATP_XSENSORS; i++) {
 451                 if (dev->xy_cur[i]) {
 452
 453                         dev_info(&dev->intf->dev,
 454                                 "appletouch: 17\" model detected.\n");
 455
 456                         input_set_abs_params(dev->input, ABS_X, 0,
 457                                              (dev->info->xsensors_17 - 1) *
 458                                                         dev->info->xfact - 1,
 459                                              ATP_FUZZ, 0);
 460                         break;
 461                 }
 462         }
 463 }
 464
 465 /*
 466  * USB interrupt callback functions
 467  */
 468
 469 /* Interrupt function for older touchpads: FOUNTAIN/GEYSER1/GEYSER2 */
 470
 471 static void atp_complete_geyser_1_2(struct urb *urb)
 472 {
 473         int x, y, x_z, y_z, x_f, y_f;
 474         int retval, i, j;
 475         int key;
 476         struct atp *dev = urb->context;
 477         int status = atp_status_check(urb);
 478
 479         if (status == ATP_URB_STATUS_ERROR_FATAL)
 480                 return;
 481         else if (status == ATP_URB_STATUS_ERROR)
 482                 goto exit;
 483
 484         /* reorder the sensors values */
 485         if (dev->info == &geyser2_info) {
 486                 memset(dev->xy_cur, 0, sizeof(dev->xy_cur));
 487
 488                 /*
 489                  * The values are laid out like this:
 490                  * Y1, Y2, -, Y3, Y4, -, ..., X1, X2, -, X3, X4, -, ...
 491                  * '-' is an unused value.
 492                  */
 493
 494                 /* read X values */
 495                 for (i = 0, j = 19; i < 20; i += 2, j += 3) {
 496                         dev->xy_cur[i] = dev->data[j];
 497                         dev->xy_cur[i + 1] = dev->data[j + 1];
 498                 }
 499
 500                 /* read Y values */
 501                 for (i = 0, j = 1; i < 9; i += 2, j += 3) {
 502                         dev->xy_cur[ATP_XSENSORS + i] = dev->data[j];
 503                         dev->xy_cur[ATP_XSENSORS + i + 1] = dev->data[j + 1];
 504                 }
 505         } else {
 506                 for (i = 0; i < 8; i++) {
 507                         /* X values */
 508                         dev->xy_cur[i +  0] = dev->data[5 * i +  2];
 509                         dev->xy_cur[i +  8] = dev->data[5 * i +  4];
 510                         dev->xy_cur[i + 16] = dev->data[5 * i + 42];
 511                         if (i < 2)
 512                                 dev->xy_cur[i + 24] = dev->data[5 * i + 44];
 513
 514                         /* Y values */
 515                         dev->xy_cur[ATP_XSENSORS + i] = dev->data[5 * i +  1];
 516                         dev->xy_cur[ATP_XSENSORS + i + 8] = dev->data[5 * i + 3];
 517                 }
 518         }
 519
 520         dbg_dump("sample", dev->xy_cur);
 521
 522         if (!dev->valid) {
 523                 /* first sample */
 524                 dev->valid = true;
 525                 dev->x_old = dev->y_old = -1;
 526
 527                 /* Store first sample */
 528                 memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
 529
 530                 /* Perform size detection, if not done already */
 531                 if (unlikely(!dev->size_detect_done)) {
 532                         atp_detect_size(dev);
 533                         dev->size_detect_done = 1;
 534                         goto exit;
 535                 }
 536         }
 537
 538         for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) {
 539                 /* accumulate the change */
 540                 signed char change = dev->xy_old[i] - dev->xy_cur[i];
 541                 dev->xy_acc[i] -= change;
 542
 543                 /* prevent down drifting */
 544                 if (dev->xy_acc[i] < 0)
 545                         dev->xy_acc[i] = 0;
 546         }
 547
 548         memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
 549
 550         dbg_dump("accumulator", dev->xy_acc);
 551
 552         x = atp_calculate_abs(dev->xy_acc, ATP_XSENSORS,
 553                               dev->info->xfact, &x_z, &x_f);
 554         y = atp_calculate_abs(dev->xy_acc + ATP_XSENSORS, ATP_YSENSORS,
 555                               dev->info->yfact, &y_z, &y_f);
 556         key = dev->data[dev->info->datalen - 1] & ATP_STATUS_BUTTON;
 557
 558         if (x && y) {
 559                 if (dev->x_old != -1) {
 560                         x = (dev->x_old * 3 + x) >> 2;
 561                         y = (dev->y_old * 3 + y) >> 2;
 562                         dev->x_old = x;
 563                         dev->y_old = y;
 564
 565                         if (debug > 1)
 566                                 printk(KERN_DEBUG "appletouch: "
 567                                         "X: %3d Y: %3d Xz: %3d Yz: %3d\n",
 568                                         x, y, x_z, y_z);
 569
 570                         input_report_key(dev->input, BTN_TOUCH, 1);
 571                         input_report_abs(dev->input, ABS_X, x);
 572                         input_report_abs(dev->input, ABS_Y, y);
 573                         input_report_abs(dev->input, ABS_PRESSURE,
 574                                          min(ATP_PRESSURE, x_z + y_z));
 575                         atp_report_fingers(dev->input, max(x_f, y_f));
 576                 }
 577                 dev->x_old = x;
 578                 dev->y_old = y;
 579
 580         } else if (!x && !y) {
 581
 582                 dev->x_old = dev->y_old = -1;
 583                 input_report_key(dev->input, BTN_TOUCH, 0);
 584                 input_report_abs(dev->input, ABS_PRESSURE, 0);
 585                 atp_report_fingers(dev->input, 0);
 586
 587                 /* reset the accumulator on release */
 588                 memset(dev->xy_acc, 0, sizeof(dev->xy_acc));
 589         }
 590
 591         input_report_key(dev->input, BTN_LEFT, key);
 592         input_sync(dev->input);
 593
 594  exit:
 595         retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
 596         if (retval)
 597                 dev_err(&dev->intf->dev,
 598                         "atp_complete: usb_submit_urb failed with result %d\n",
 599                         retval);
 600 }
 601
 602 /* Interrupt function for older touchpads: GEYSER3/GEYSER4 */
 603
 604 static void atp_complete_geyser_3_4(struct urb *urb)
 605 {
 606         int x, y, x_z, y_z, x_f, y_f;
 607         int retval, i, j;
 608         int key;
 609         struct atp *dev = urb->context;
 610         int status = atp_status_check(urb);
 611
 612         if (status == ATP_URB_STATUS_ERROR_FATAL)
 613                 return;
 614         else if (status == ATP_URB_STATUS_ERROR)
 615                 goto exit;
 616
 617         /* Reorder the sensors values:
 618          *
 619          * The values are laid out like this:
 620          * -, Y1, Y2, -, Y3, Y4, -, ..., -, X1, X2, -, X3, X4, ...
 621          * '-' is an unused value.
 622          */
 623
 624         /* read X values */
 625         for (i = 0, j = 19; i < 20; i += 2, j += 3) {
 626                 dev->xy_cur[i] = dev->data[j + 1];
 627                 dev->xy_cur[i + 1] = dev->data[j + 2];
 628         }
 629         /* read Y values */
 630         for (i = 0, j = 1; i < 9; i += 2, j += 3) {
 631                 dev->xy_cur[ATP_XSENSORS + i] = dev->data[j + 1];
 632                 dev->xy_cur[ATP_XSENSORS + i + 1] = dev->data[j + 2];
 633         }
 634
 635         dbg_dump("sample", dev->xy_cur);
 636
 637         /* Just update the base values (i.e. touchpad in untouched state) */
 638         if (dev->data[dev->info->datalen - 1] & ATP_STATUS_BASE_UPDATE) {
 639
 640                 dprintk("appletouch: updated base values\n");
 641
 642                 memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
 643                 goto exit;
 644         }
 645
 646         for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) {
 647                 /* calculate the change */
 648                 dev->xy_acc[i] = dev->xy_cur[i] - dev->xy_old[i];
 649
 650                 /* this is a round-robin value, so couple with that */
 651                 if (dev->xy_acc[i] > 127)
 652                         dev->xy_acc[i] -= 256;
 653
 654                 if (dev->xy_acc[i] < -127)
 655                         dev->xy_acc[i] += 256;
 656
 657                 /* prevent down drifting */
 658                 if (dev->xy_acc[i] < 0)
 659                         dev->xy_acc[i] = 0;
 660         }
 661
 662         dbg_dump("accumulator", dev->xy_acc);
 663
 664         x = atp_calculate_abs(dev->xy_acc, ATP_XSENSORS,
 665                               dev->info->xfact, &x_z, &x_f);
 666         y = atp_calculate_abs(dev->xy_acc + ATP_XSENSORS, ATP_YSENSORS,
 667                               dev->info->yfact, &y_z, &y_f);
 668         key = dev->data[dev->info->datalen - 1] & ATP_STATUS_BUTTON;
 669
 670         if (x && y) {
 671                 if (dev->x_old != -1) {
 672                         x = (dev->x_old * 3 + x) >> 2;
 673                         y = (dev->y_old * 3 + y) >> 2;
 674                         dev->x_old = x;
 675                         dev->y_old = y;
 676
 677                         if (debug > 1)
 678                                 printk(KERN_DEBUG "appletouch: X: %3d Y: %3d "
 679                                        "Xz: %3d Yz: %3d\n",
 680                                        x, y, x_z, y_z);
 681
 682                         input_report_key(dev->input, BTN_TOUCH, 1);
 683                         input_report_abs(dev->input, ABS_X, x);
 684                         input_report_abs(dev->input, ABS_Y, y);
 685                         input_report_abs(dev->input, ABS_PRESSURE,
 686                                          min(ATP_PRESSURE, x_z + y_z));
 687                         atp_report_fingers(dev->input, max(x_f, y_f));
 688                 }
 689                 dev->x_old = x;
 690                 dev->y_old = y;
 691
 692         } else if (!x && !y) {
 693
 694                 dev->x_old = dev->y_old = -1;
 695                 input_report_key(dev->input, BTN_TOUCH, 0);
 696                 input_report_abs(dev->input, ABS_PRESSURE, 0);
 697                 atp_report_fingers(dev->input, 0);
 698
 699                 /* reset the accumulator on release */
 700                 memset(dev->xy_acc, 0, sizeof(dev->xy_acc));
 701         }
 702
 703         input_report_key(dev->input, BTN_LEFT, key);
 704         input_sync(dev->input);
 705
 706         /*
 707          * Geysers 3/4 will continue to send packets continually after
 708          * the first touch unless reinitialised. Do so if it's been
 709          * idle for a while in order to avoid waking the kernel up
 710          * several hundred times a second.
 711          */
 712
 713         /*
 714          * Button must not be pressed when entering suspend,
 715          * otherwise we will never release the button.
 716          */
 717         if (!x && !y && !key) {
 718                 dev->idlecount++;
 719                 if (dev->idlecount == 10) {
 720                         dev->x_old = dev->y_old = -1;
 721                         dev->idlecount = 0;
 722                         schedule_work(&dev->work);
 723                         /* Don't resubmit urb here, wait for reinit */
 724                         return;
 725                 }
 726         } else
 727                 dev->idlecount = 0;
 728
 729  exit:
 730         retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
 731         if (retval)
 732                 dev_err(&dev->intf->dev,
 733                         "atp_complete: usb_submit_urb failed with result %d\n",
 734                         retval);
 735 }
 736
 737 static int atp_open(struct input_dev *input)
 738 {
 739         struct atp *dev = input_get_drvdata(input);
 740
 741         if (usb_submit_urb(dev->urb, GFP_ATOMIC))
 742                 return -EIO;
 743
 744         dev->open = 1;
 745         return 0;
 746 }
 747
 748 static void atp_close(struct input_dev *input)
 749 {
 750         struct atp *dev = input_get_drvdata(input);
 751
 752         usb_kill_urb(dev->urb);
 753         cancel_work_sync(&dev->work);
 754         dev->open = 0;
 755 }
 756
 757 static int atp_handle_geyser(struct atp *dev)
 758 {
 759         if (dev->info != &fountain_info) {
 760                 /* switch to raw sensor mode */
 761                 if (atp_geyser_init(dev))
 762                         return -EIO;
 763
 764                 dev_info(&dev->intf->dev, "Geyser mode initialized.\n");
 765         }
 766
 767         return 0;
 768 }
 769
 770 static int atp_probe(struct usb_interface *iface,
 771                      const struct usb_device_id *id)
 772 {
 773         struct atp *dev;
 774         struct input_dev *input_dev;
 775         struct usb_device *udev = interface_to_usbdev(iface);
 776         struct usb_host_interface *iface_desc;
 777         struct usb_endpoint_descriptor *endpoint;
 778         int int_in_endpointAddr = 0;
 779         int i, error = -ENOMEM;
 780         const struct atp_info *info = (const struct atp_info *)id->driver_info;
 781
 782         /* set up the endpoint information */
 783         /* use only the first interrupt-in endpoint */
 784         iface_desc = iface->cur_altsetting;
 785         for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
 786                 endpoint = &iface_desc->endpoint[i].desc;
 787                 if (!int_in_endpointAddr && usb_endpoint_is_int_in(endpoint)) {
 788                         /* we found an interrupt in endpoint */
 789                         int_in_endpointAddr = endpoint->bEndpointAddress;
 790                         break;
 791                 }
 792         }
 793         if (!int_in_endpointAddr) {
 794                 dev_err(&iface->dev, "Could not find int-in endpoint\n");
 795                 return -EIO;
 796         }
 797
 798         /* allocate memory for our device state and initialize it */
 799         dev = kzalloc(sizeof(struct atp), GFP_KERNEL);
 800         input_dev = input_allocate_device();
 801         if (!dev || !input_dev) {
 802                 dev_err(&iface->dev, "Out of memory\n");
 803                 goto err_free_devs;
 804         }
 805
 806         dev->udev = udev;
 807         dev->intf = iface;
 808         dev->input = input_dev;
 809         dev->info = info;
 810         dev->overflow_warned = false;
 811
 812         dev->urb = usb_alloc_urb(0, GFP_KERNEL);
 813         if (!dev->urb)
 814                 goto err_free_devs;
 815
 816         dev->data = usb_alloc_coherent(dev->udev, dev->info->datalen, GFP_KERNEL,
 817                                        &dev->urb->transfer_dma);
 818         if (!dev->data)
 819                 goto err_free_urb;
 820
 821         usb_fill_int_urb(dev->urb, udev,
 822                          usb_rcvintpipe(udev, int_in_endpointAddr),
 823                          dev->data, dev->info->datalen,
 824                          dev->info->callback, dev, 1);
 825
 826         error = atp_handle_geyser(dev);
 827         if (error)
 828                 goto err_free_buffer;
 829
 830         usb_make_path(udev, dev->phys, sizeof(dev->phys));
 831         strlcat(dev->phys, "/input0", sizeof(dev->phys));
 832
 833         input_dev->name = "appletouch";
 834         input_dev->phys = dev->phys;
 835         usb_to_input_id(dev->udev, &input_dev->id);
 836         input_dev->dev.parent = &iface->dev;
 837
 838         input_set_drvdata(input_dev, dev);
 839
 840         input_dev->open = atp_open;
 841         input_dev->close = atp_close;
 842
 843         set_bit(EV_ABS, input_dev->evbit);
 844
 845         input_set_abs_params(input_dev, ABS_X, 0,
 846                              (dev->info->xsensors - 1) * dev->info->xfact - 1,
 847                              ATP_FUZZ, 0);
 848         input_set_abs_params(input_dev, ABS_Y, 0,
 849                              (dev->info->ysensors - 1) * dev->info->yfact - 1,
 850                              ATP_FUZZ, 0);
 851         input_set_abs_params(input_dev, ABS_PRESSURE, 0, ATP_PRESSURE, 0, 0);
 852
 853         set_bit(EV_KEY, input_dev->evbit);
 854         set_bit(BTN_TOUCH, input_dev->keybit);
 855         set_bit(BTN_TOOL_FINGER, input_dev->keybit);
 856         set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit);
 857         set_bit(BTN_TOOL_TRIPLETAP, input_dev->keybit);
 858         set_bit(BTN_LEFT, input_dev->keybit);
 859
 860         error = input_register_device(dev->input);
 861         if (error)
 862                 goto err_free_buffer;
 863
 864         /* save our data pointer in this interface device */
 865         usb_set_intfdata(iface, dev);
 866
 867         INIT_WORK(&dev->work, atp_reinit);
 868
 869         return 0;
 870
 871  err_free_buffer:
 872         usb_free_coherent(dev->udev, dev->info->datalen,
 873                           dev->data, dev->urb->transfer_dma);
 874  err_free_urb:
 875         usb_free_urb(dev->urb);
 876  err_free_devs:
 877         usb_set_intfdata(iface, NULL);
 878         kfree(dev);
 879         input_free_device(input_dev);
 880         return error;
 881 }
 882
 883 static void atp_disconnect(struct usb_interface *iface)
 884 {
 885         struct atp *dev = usb_get_intfdata(iface);
 886
 887         usb_set_intfdata(iface, NULL);
 888         if (dev) {
 889                 usb_kill_urb(dev->urb);
 890                 input_unregister_device(dev->input);
 891                 usb_free_coherent(dev->udev, dev->info->datalen,
 892                                   dev->data, dev->urb->transfer_dma);
 893                 usb_free_urb(dev->urb);
 894                 kfree(dev);
 895         }
 896         dev_info(&iface->dev, "input: appletouch disconnected\n");
 897 }
 898
 899 static int atp_recover(struct atp *dev)
 900 {
 901         int error;
 902
 903         error = atp_handle_geyser(dev);
 904         if (error)
 905                 return error;
 906
 907         if (dev->open && usb_submit_urb(dev->urb, GFP_ATOMIC))
 908                 return -EIO;
 909
 910         return 0;
 911 }
 912
 913 static int atp_suspend(struct usb_interface *iface, pm_message_t message)
 914 {
 915         struct atp *dev = usb_get_intfdata(iface);
 916
 917         usb_kill_urb(dev->urb);
 918         return 0;
 919 }
 920
 921 static int atp_resume(struct usb_interface *iface)
 922 {
 923         struct atp *dev = usb_get_intfdata(iface);
 924
 925         if (dev->open && usb_submit_urb(dev->urb, GFP_ATOMIC))
 926                 return -EIO;
 927
 928         return 0;
 929 }
 930
 931 static int atp_reset_resume(struct usb_interface *iface)
 932 {
 933         struct atp *dev = usb_get_intfdata(iface);
 934
 935         return atp_recover(dev);
 936 }
 937
 938 static struct usb_driver atp_driver = {
 939         .name           = "appletouch",
 940         .probe          = atp_probe,
 941         .disconnect     = atp_disconnect,
 942         .suspend        = atp_suspend,
 943         .resume         = atp_resume,
 944         .reset_resume   = atp_reset_resume,
 945         .id_table       = atp_table,
 946 };
 947
 948 module_usb_driver(atp_driver);