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-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);