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