Pileus Git - ~andy/linux/blob - drivers/input/mouse/appletouch.c

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