drivers/input/mouse/appletouch.c

   1 /*
   2  * Apple USB Touchpad (for post-February 2005 PowerBooks and MacBooks) driver
   3  *
   4  * Copyright (C) 2001-2004 Greg Kroah-Hartman ([email protected])
   5  * Copyright (C) 2005-2008 Johannes Berg ([email protected])
   6  * Copyright (C) 2005-2008 Stelian Pop ([email protected])
   7  * Copyright (C) 2005      Frank Arnold ([email protected])
   8  * Copyright (C) 2005      Peter Osterlund ([email protected])
   9  * Copyright (C) 2005      Michael Hanselmann ([email protected])
  10  * Copyright (C) 2006      Nicolas Boichat ([email protected])
  11  * Copyright (C) 2007-2008 Sven Anders ([email protected])
  12  *
  13  * Thanks to Alex Harper <[email protected]> for his inputs.
  14  *
  15  * This program is free software; you can redistribute it and/or modify
  16  * it under the terms of the GNU General Public License as published by
  17  * the Free Software Foundation; either version 2 of the License, or
  18  * (at your option) any later version.
  19  *
  20  * This program is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  * GNU General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU General Public License
  26  * along with this program; if not, write to the Free Software
  27  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  28  *
  29  */
  30
  31 #include <linux/kernel.h>
  32 #include <linux/errno.h>
  33 #include <linux/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         int fuzz;                               /* fuzz touchpad generates */
  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         .fuzz           = 16,
  66 };
  67
  68 static const struct atp_info geyser1_info = {
  69         .xsensors       = 16,
  70         .xsensors_17    = 26,
  71         .ysensors       = 16,
  72         .xfact          = 64,
  73         .yfact          = 43,
  74         .datalen        = 81,
  75         .callback       = atp_complete_geyser_1_2,
  76         .fuzz           = 16,
  77 };
  78
  79 static const struct atp_info geyser2_info = {
  80         .xsensors       = 15,
  81         .xsensors_17    = 20,
  82         .ysensors       = 9,
  83         .xfact          = 64,
  84         .yfact          = 43,
  85         .datalen        = 64,
  86         .callback       = atp_complete_geyser_1_2,
  87         .fuzz           = 0,
  88 };
  89
  90 static const struct atp_info geyser3_info = {
  91         .xsensors       = 20,
  92         .ysensors       = 10,
  93         .xfact          = 64,
  94         .yfact          = 64,
  95         .datalen        = 64,
  96         .callback       = atp_complete_geyser_3_4,
  97         .fuzz           = 0,
  98 };
  99
 100 static const struct atp_info geyser4_info = {
 101         .xsensors       = 20,
 102         .ysensors       = 10,
 103         .xfact          = 64,
 104         .yfact          = 64,
 105         .datalen        = 64,
 106         .callback       = atp_complete_geyser_3_4,
 107         .fuzz           = 0,
 108 };
 109
 110 #define ATP_DEVICE(prod, info)                                  \
 111 {                                                               \
 112         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |             \
 113                        USB_DEVICE_ID_MATCH_INT_CLASS |          \
 114                        USB_DEVICE_ID_MATCH_INT_PROTOCOL,        \
 115         .idVendor = 0x05ac, /* Apple */                         \
 116         .idProduct = (prod),                                    \
 117         .bInterfaceClass = 0x03,                                \
 118         .bInterfaceProtocol = 0x02,                             \
 119         .driver_info = (unsigned long) &info,                   \
 120 }
 121
 122 /*
 123  * Table of devices (Product IDs) that work with this driver.
 124  * (The names come from Info.plist in AppleUSBTrackpad.kext,
 125  *  According to Info.plist Geyser IV is the same as Geyser III.)
 126  */
 127
 128 static struct usb_device_id atp_table[] = {
 129         /* PowerBooks Feb 2005, iBooks G4 */
 130         ATP_DEVICE(0x020e, fountain_info),      /* FOUNTAIN ANSI */
 131         ATP_DEVICE(0x020f, fountain_info),      /* FOUNTAIN ISO */
 132         ATP_DEVICE(0x030a, fountain_info),      /* FOUNTAIN TP ONLY */
 133         ATP_DEVICE(0x030b, geyser1_info),       /* GEYSER 1 TP ONLY */
 134
 135         /* PowerBooks Oct 2005 */
 136         ATP_DEVICE(0x0214, geyser2_info),       /* GEYSER 2 ANSI */
 137         ATP_DEVICE(0x0215, geyser2_info),       /* GEYSER 2 ISO */
 138         ATP_DEVICE(0x0216, geyser2_info),       /* GEYSER 2 JIS */
 139
 140         /* Core Duo MacBook & MacBook Pro */
 141         ATP_DEVICE(0x0217, geyser3_info),       /* GEYSER 3 ANSI */
 142         ATP_DEVICE(0x0218, geyser3_info),       /* GEYSER 3 ISO */
 143         ATP_DEVICE(0x0219, geyser3_info),       /* GEYSER 3 JIS */
 144
 145         /* Core2 Duo MacBook & MacBook Pro */
 146         ATP_DEVICE(0x021a, geyser4_info),       /* GEYSER 4 ANSI */
 147         ATP_DEVICE(0x021b, geyser4_info),       /* GEYSER 4 ISO */
 148         ATP_DEVICE(0x021c, geyser4_info),       /* GEYSER 4 JIS */
 149
 150         /* Core2 Duo MacBook3,1 */
 151         ATP_DEVICE(0x0229, geyser4_info),       /* GEYSER 4 HF ANSI */
 152         ATP_DEVICE(0x022a, geyser4_info),       /* GEYSER 4 HF ISO */
 153         ATP_DEVICE(0x022b, geyser4_info),       /* GEYSER 4 HF JIS */
 154
 155         /* Terminating entry */
 156         { }
 157 };
 158 MODULE_DEVICE_TABLE(usb, atp_table);
 159
 160 /* maximum number of sensors */
 161 #define ATP_XSENSORS    26
 162 #define ATP_YSENSORS    16
 163
 164 /*
 165  * The largest possible bank of sensors with additional buffer of 4 extra values
 166  * on either side, for an array of smoothed sensor values.
 167  */
 168 #define ATP_SMOOTHSIZE  34
 169
 170 /* maximum pressure this driver will report */
 171 #define ATP_PRESSURE    300
 172
 173 /*
 174  * Threshold for the touchpad sensors. Any change less than ATP_THRESHOLD is
 175  * ignored.
 176  */
 177 #define ATP_THRESHOLD   5
 178
 179 /*
 180  * How far we'll bitshift our sensor values before averaging them. Mitigates
 181  * rounding errors.
 182  */
 183 #define ATP_SCALE       12
 184
 185 /* Geyser initialization constants */
 186 #define ATP_GEYSER_MODE_READ_REQUEST_ID         1
 187 #define ATP_GEYSER_MODE_WRITE_REQUEST_ID        9
 188 #define ATP_GEYSER_MODE_REQUEST_VALUE           0x300
 189 #define ATP_GEYSER_MODE_REQUEST_INDEX           0
 190 #define ATP_GEYSER_MODE_VENDOR_VALUE            0x04
 191
 192 /**
 193  * enum atp_status_bits - status bit meanings
 194  *
 195  * These constants represent the meaning of the status bits.
 196  * (only Geyser 3/4)
 197  *
 198  * @ATP_STATUS_BUTTON: The button was pressed
 199  * @ATP_STATUS_BASE_UPDATE: Update of the base values (untouched pad)
 200  * @ATP_STATUS_FROM_RESET: Reset previously performed
 201  */
 202 enum atp_status_bits {
 203         ATP_STATUS_BUTTON       = BIT(0),
 204         ATP_STATUS_BASE_UPDATE  = BIT(2),
 205         ATP_STATUS_FROM_RESET   = BIT(4),
 206 };
 207
 208 /* Structure to hold all of our device specific stuff */
 209 struct atp {
 210         char                    phys[64];
 211         struct usb_device       *udev;          /* usb device */
 212         struct usb_interface    *intf;          /* usb interface */
 213         struct urb              *urb;           /* usb request block */
 214         u8                      *data;          /* transferred data */
 215         struct input_dev        *input;         /* input dev */
 216         const struct atp_info   *info;          /* touchpad model */
 217         bool                    open;
 218         bool                    valid;          /* are the samples valid? */
 219         bool                    size_detect_done;
 220         bool                    overflow_warned;
 221         int                     fingers_old;    /* last reported finger count */
 222         int                     x_old;          /* last reported x/y, */
 223         int                     y_old;          /* used for smoothing */
 224         signed char             xy_cur[ATP_XSENSORS + ATP_YSENSORS];
 225         signed char             xy_old[ATP_XSENSORS + ATP_YSENSORS];
 226         int                     xy_acc[ATP_XSENSORS + ATP_YSENSORS];
 227         int                     smooth[ATP_SMOOTHSIZE];
 228         int                     smooth_tmp[ATP_SMOOTHSIZE];
 229         int                     idlecount;      /* number of empty packets */
 230         struct work_struct      work;
 231 };
 232
 233 #define dbg_dump(msg, tab) \
 234         if (debug > 1) {                                                \
 235                 int __i;                                                \
 236                 printk(KERN_DEBUG "appletouch: %s", msg);               \
 237                 for (__i = 0; __i < ATP_XSENSORS + ATP_YSENSORS; __i++) \
 238                         printk(" %02x", tab[__i]);                      \
 239                 printk("\n");                                           \
 240         }
 241
 242 #define dprintk(format, a...)                                           \
 243         do {                                                            \
 244                 if (debug)                                              \
 245                         printk(KERN_DEBUG format, ##a);                 \
 246         } while (0)
 247
 248 MODULE_AUTHOR("Johannes Berg");
 249 MODULE_AUTHOR("Stelian Pop");
 250 MODULE_AUTHOR("Frank Arnold");
 251 MODULE_AUTHOR("Michael Hanselmann");
 252 MODULE_AUTHOR("Sven Anders");
 253 MODULE_DESCRIPTION("Apple PowerBook and MacBook USB touchpad driver");
 254 MODULE_LICENSE("GPL");
 255
 256 /*
 257  * Make the threshold a module parameter
 258  */
 259 static int threshold = ATP_THRESHOLD;
 260 module_param(threshold, int, 0644);
 261 MODULE_PARM_DESC(threshold, "Discard any change in data from a sensor"
 262                             " (the trackpad has many of these sensors)"
 263                             " less than this value.");
 264
 265 static int debug;
 266 module_param(debug, int, 0644);
 267 MODULE_PARM_DESC(debug, "Activate debugging output");
 268
 269 /*
 270  * By default newer Geyser devices send standard USB HID mouse
 271  * packets (Report ID 2). This code changes device mode, so it
 272  * sends raw sensor reports (Report ID 5).
 273  */
 274 static int atp_geyser_init(struct atp *dev)
 275 {
 276         struct usb_device *udev = dev->udev;
 277         char *data;
 278         int size;
 279         int i;
 280         int ret;
 281
 282         data = kmalloc(8, GFP_KERNEL);
 283         if (!data) {
 284                 dev_err(&dev->intf->dev, "Out of memory\n");
 285                 return -ENOMEM;
 286         }
 287
 288         size = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
 289                         ATP_GEYSER_MODE_READ_REQUEST_ID,
 290                         USB_DIR_IN | 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: read error\n");
 296                 for (i = 0; i < 8; i++)
 297                         dprintk("appletouch[%d]: %d\n", i, data[i]);
 298
 299                 dev_err(&dev->intf->dev, "Failed to read mode from device.\n");
 300                 ret = -EIO;
 301                 goto out_free;
 302         }
 303
 304         /* Apply the mode switch */
 305         data[0] = ATP_GEYSER_MODE_VENDOR_VALUE;
 306
 307         size = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
 308                         ATP_GEYSER_MODE_WRITE_REQUEST_ID,
 309                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 310                         ATP_GEYSER_MODE_REQUEST_VALUE,
 311                         ATP_GEYSER_MODE_REQUEST_INDEX, data, 8, 5000);
 312
 313         if (size != 8) {
 314                 dprintk("atp_geyser_init: write error\n");
 315                 for (i = 0; i < 8; i++)
 316                         dprintk("appletouch[%d]: %d\n", i, data[i]);
 317
 318                 dev_err(&dev->intf->dev, "Failed to request geyser raw mode\n");
 319                 ret = -EIO;
 320                 goto out_free;
 321         }
 322         ret = 0;
 323 out_free:
 324         kfree(data);
 325         return ret;
 326 }
 327
 328 /*
 329  * Reinitialise the device. This usually stops stream of empty packets
 330  * coming from it.
 331  */
 332 static void atp_reinit(struct work_struct *work)
 333 {
 334         struct atp *dev = container_of(work, struct atp, work);
 335         int retval;
 336
 337         dprintk("appletouch: putting appletouch to sleep (reinit)\n");
 338         atp_geyser_init(dev);
 339
 340         retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
 341         if (retval)
 342                 dev_err(&dev->intf->dev,
 343                         "atp_reinit: usb_submit_urb failed with error %d\n",
 344                         retval);
 345 }
 346
 347 static int atp_calculate_abs(struct atp *dev, int offset, int nb_sensors,
 348                              int fact, int *z, int *fingers)
 349 {
 350         int i, pass;
 351
 352         /*
 353          * Use offset to point xy_sensors at the first value in dev->xy_acc
 354          * for whichever dimension we're looking at this particular go-round.
 355          */
 356         int *xy_sensors = dev->xy_acc + offset;
 357
 358         /* values to calculate mean */
 359         int pcum = 0, psum = 0;
 360         int is_increasing = 0;
 361
 362         *fingers = 0;
 363
 364         for (i = 0; i < nb_sensors; i++) {
 365                 if (xy_sensors[i] < threshold) {
 366                         if (is_increasing)
 367                                 is_increasing = 0;
 368
 369                 /*
 370                  * Makes the finger detection more versatile.  For example,
 371                  * two fingers with no gap will be detected.  Also, my
 372                  * tests show it less likely to have intermittent loss
 373                  * of multiple finger readings while moving around (scrolling).
 374                  *
 375                  * Changes the multiple finger detection to counting humps on
 376                  * sensors (transitions from nonincreasing to increasing)
 377                  * instead of counting transitions from low sensors (no
 378                  * finger reading) to high sensors (finger above
 379                  * sensor)
 380                  *
 381                  * - Jason Parekh <[email protected]>
 382                  */
 383
 384                 } else if (i < 1 ||
 385                     (!is_increasing && xy_sensors[i - 1] < xy_sensors[i])) {
 386                         (*fingers)++;
 387                         is_increasing = 1;
 388                 } else if (i > 0 && (xy_sensors[i - 1] - xy_sensors[i] > threshold)) {
 389                         is_increasing = 0;
 390                 }
 391         }
 392
 393         if (*fingers < 1)     /* No need to continue if no fingers are found. */
 394                 return 0;
 395
 396         /*
 397          * Use a smoothed version of sensor data for movement calculations, to
 398          * combat noise without needing to rely so heavily on a threshold.
 399          * This improves tracking.
 400          *
 401          * The smoothed array is bigger than the original so that the smoothing
 402          * doesn't result in edge values being truncated.
 403          */
 404
 405         memset(dev->smooth, 0, 4 * sizeof(dev->smooth[0]));
 406         /* Pull base values, scaled up to help avoid truncation errors. */
 407         for (i = 0; i < nb_sensors; i++)
 408                 dev->smooth[i + 4] = xy_sensors[i] << ATP_SCALE;
 409         memset(&dev->smooth[nb_sensors + 4], 0, 4 * sizeof(dev->smooth[0]));
 410
 411         for (pass = 0; pass < 4; pass++) {
 412                 /* Handle edge. */
 413                 dev->smooth_tmp[0] = (dev->smooth[0] + dev->smooth[1]) / 2;
 414
 415                 /* Average values with neighbors. */
 416                 for (i = 1; i < nb_sensors + 7; i++)
 417                         dev->smooth_tmp[i] = (dev->smooth[i - 1] +
 418                                               dev->smooth[i] * 2 +
 419                                               dev->smooth[i + 1]) / 4;
 420
 421                 /* Handle other edge. */
 422                 dev->smooth_tmp[i] = (dev->smooth[i - 1] + dev->smooth[i]) / 2;
 423
 424                 memcpy(dev->smooth, dev->smooth_tmp, sizeof(dev->smooth));
 425         }
 426
 427         for (i = 0; i < nb_sensors + 8; i++) {
 428                 /*
 429                  * Skip values if they're small enough to be truncated to 0
 430                  * by scale. Mostly noise.
 431                  */
 432                 if ((dev->smooth[i] >> ATP_SCALE) > 0) {
 433                         pcum += dev->smooth[i] * i;
 434                         psum += dev->smooth[i];
 435                 }
 436         }
 437
 438         if (psum > 0) {
 439                 *z = psum >> ATP_SCALE;        /* Scale down pressure output. */
 440                 return pcum * fact / psum;
 441         }
 442
 443         return 0;
 444 }
 445
 446 static inline void atp_report_fingers(struct input_dev *input, int fingers)
 447 {
 448         input_report_key(input, BTN_TOOL_FINGER, fingers == 1);
 449         input_report_key(input, BTN_TOOL_DOUBLETAP, fingers == 2);
 450         input_report_key(input, BTN_TOOL_TRIPLETAP, fingers > 2);
 451 }
 452
 453 /* Check URB status and for correct length of data package */
 454
 455 #define ATP_URB_STATUS_SUCCESS          0
 456 #define ATP_URB_STATUS_ERROR            1
 457 #define ATP_URB_STATUS_ERROR_FATAL      2
 458
 459 static int atp_status_check(struct urb *urb)
 460 {
 461         struct atp *dev = urb->context;
 462         struct usb_interface *intf = dev->intf;
 463
 464         switch (urb->status) {
 465         case 0:
 466                 /* success */
 467                 break;
 468         case -EOVERFLOW:
 469                 if (!dev->overflow_warned) {
 470                         dev_warn(&intf->dev,
 471                                 "appletouch: OVERFLOW with data length %d, actual length is %d\n",
 472                                 dev->info->datalen, dev->urb->actual_length);
 473                         dev->overflow_warned = true;
 474                 }
 475         case -ECONNRESET:
 476         case -ENOENT:
 477         case -ESHUTDOWN:
 478                 /* This urb is terminated, clean up */
 479                 dev_dbg(&intf->dev,
 480                         "atp_complete: urb shutting down with status: %d\n",
 481                         urb->status);
 482                 return ATP_URB_STATUS_ERROR_FATAL;
 483
 484         default:
 485                 dev_dbg(&intf->dev,
 486                         "atp_complete: nonzero urb status received: %d\n",
 487                         urb->status);
 488                 return ATP_URB_STATUS_ERROR;
 489         }
 490
 491         /* drop incomplete datasets */
 492         if (dev->urb->actual_length != dev->info->datalen) {
 493                 dprintk("appletouch: incomplete data package"
 494                         " (first byte: %d, length: %d).\n",
 495                         dev->data[0], dev->urb->actual_length);
 496                 return ATP_URB_STATUS_ERROR;
 497         }
 498
 499         return ATP_URB_STATUS_SUCCESS;
 500 }
 501
 502 static void atp_detect_size(struct atp *dev)
 503 {
 504         int i;
 505
 506         /* 17" Powerbooks have extra X sensors */
 507         for (i = dev->info->xsensors; i < ATP_XSENSORS; i++) {
 508                 if (dev->xy_cur[i]) {
 509
 510                         dev_info(&dev->intf->dev,
 511                                 "appletouch: 17\" model detected.\n");
 512
 513                         input_set_abs_params(dev->input, ABS_X, 0,
 514                                              (dev->info->xsensors_17 - 1) *
 515                                                         dev->info->xfact - 1,
 516                                              dev->info->fuzz, 0);
 517                         break;
 518                 }
 519         }
 520 }
 521
 522 /*
 523  * USB interrupt callback functions
 524  */
 525
 526 /* Interrupt function for older touchpads: FOUNTAIN/GEYSER1/GEYSER2 */
 527
 528 static void atp_complete_geyser_1_2(struct urb *urb)
 529 {
 530         int x, y, x_z, y_z, x_f, y_f;
 531         int retval, i, j;
 532         int key, fingers;
 533         struct atp *dev = urb->context;
 534         int status = atp_status_check(urb);
 535
 536         if (status == ATP_URB_STATUS_ERROR_FATAL)
 537                 return;
 538         else if (status == ATP_URB_STATUS_ERROR)
 539                 goto exit;
 540
 541         /* reorder the sensors values */
 542         if (dev->info == &geyser2_info) {
 543                 memset(dev->xy_cur, 0, sizeof(dev->xy_cur));
 544
 545                 /*
 546                  * The values are laid out like this:
 547                  * Y1, Y2, -, Y3, Y4, -, ..., X1, X2, -, X3, X4, -, ...
 548                  * '-' is an unused value.
 549                  */
 550
 551                 /* read X values */
 552                 for (i = 0, j = 19; i < 20; i += 2, j += 3) {
 553                         dev->xy_cur[i] = dev->data[j];
 554                         dev->xy_cur[i + 1] = dev->data[j + 1];
 555                 }
 556
 557                 /* read Y values */
 558                 for (i = 0, j = 1; i < 9; i += 2, j += 3) {
 559                         dev->xy_cur[ATP_XSENSORS + i] = dev->data[j];
 560                         dev->xy_cur[ATP_XSENSORS + i + 1] = dev->data[j + 1];
 561                 }
 562         } else {
 563                 for (i = 0; i < 8; i++) {
 564                         /* X values */
 565                         dev->xy_cur[i +  0] = dev->data[5 * i +  2];
 566                         dev->xy_cur[i +  8] = dev->data[5 * i +  4];
 567                         dev->xy_cur[i + 16] = dev->data[5 * i + 42];
 568                         if (i < 2)
 569                                 dev->xy_cur[i + 24] = dev->data[5 * i + 44];
 570
 571                         /* Y values */
 572                         dev->xy_cur[ATP_XSENSORS + i] = dev->data[5 * i +  1];
 573                         dev->xy_cur[ATP_XSENSORS + i + 8] = dev->data[5 * i + 3];
 574                 }
 575         }
 576
 577         dbg_dump("sample", dev->xy_cur);
 578
 579         if (!dev->valid) {
 580                 /* first sample */
 581                 dev->valid = true;
 582                 dev->x_old = dev->y_old = -1;
 583
 584                 /* Store first sample */
 585                 memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
 586
 587                 /* Perform size detection, if not done already */
 588                 if (unlikely(!dev->size_detect_done)) {
 589                         atp_detect_size(dev);
 590                         dev->size_detect_done = 1;
 591                         goto exit;
 592                 }
 593         }
 594
 595         for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) {
 596                 /* accumulate the change */
 597                 signed char change = dev->xy_old[i] - dev->xy_cur[i];
 598                 dev->xy_acc[i] -= change;
 599
 600                 /* prevent down drifting */
 601                 if (dev->xy_acc[i] < 0)
 602                         dev->xy_acc[i] = 0;
 603         }
 604
 605         memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
 606
 607         dbg_dump("accumulator", dev->xy_acc);
 608
 609         x = atp_calculate_abs(dev, 0, ATP_XSENSORS,
 610                               dev->info->xfact, &x_z, &x_f);
 611         y = atp_calculate_abs(dev, ATP_XSENSORS, ATP_YSENSORS,
 612                               dev->info->yfact, &y_z, &y_f);
 613         key = dev->data[dev->info->datalen - 1] & ATP_STATUS_BUTTON;
 614
 615         fingers = max(x_f, y_f);
 616
 617         if (x && y && fingers == dev->fingers_old) {
 618                 if (dev->x_old != -1) {
 619                         x = (dev->x_old * 7 + x) >> 3;
 620                         y = (dev->y_old * 7 + y) >> 3;
 621                         dev->x_old = x;
 622                         dev->y_old = y;
 623
 624                         if (debug > 1)
 625                                 printk(KERN_DEBUG "appletouch: "
 626                                         "X: %3d Y: %3d Xz: %3d Yz: %3d\n",
 627                                         x, y, x_z, y_z);
 628
 629                         input_report_key(dev->input, BTN_TOUCH, 1);
 630                         input_report_abs(dev->input, ABS_X, x);
 631                         input_report_abs(dev->input, ABS_Y, y);
 632                         input_report_abs(dev->input, ABS_PRESSURE,
 633                                          min(ATP_PRESSURE, x_z + y_z));
 634                         atp_report_fingers(dev->input, fingers);
 635                 }
 636                 dev->x_old = x;
 637                 dev->y_old = y;
 638
 639         } else if (!x && !y) {
 640
 641                 dev->x_old = dev->y_old = -1;
 642                 dev->fingers_old = 0;
 643                 input_report_key(dev->input, BTN_TOUCH, 0);
 644                 input_report_abs(dev->input, ABS_PRESSURE, 0);
 645                 atp_report_fingers(dev->input, 0);
 646
 647                 /* reset the accumulator on release */
 648                 memset(dev->xy_acc, 0, sizeof(dev->xy_acc));
 649         }
 650
 651         if (fingers != dev->fingers_old)
 652                 dev->x_old = dev->y_old = -1;
 653         dev->fingers_old = fingers;
 654
 655         input_report_key(dev->input, BTN_LEFT, key);
 656         input_sync(dev->input);
 657
 658  exit:
 659         retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
 660         if (retval)
 661                 dev_err(&dev->intf->dev,
 662                         "atp_complete: usb_submit_urb failed with result %d\n",
 663                         retval);
 664 }
 665
 666 /* Interrupt function for older touchpads: GEYSER3/GEYSER4 */
 667
 668 static void atp_complete_geyser_3_4(struct urb *urb)
 669 {
 670         int x, y, x_z, y_z, x_f, y_f;
 671         int retval, i, j;
 672         int key, fingers;
 673         struct atp *dev = urb->context;
 674         int status = atp_status_check(urb);
 675
 676         if (status == ATP_URB_STATUS_ERROR_FATAL)
 677                 return;
 678         else if (status == ATP_URB_STATUS_ERROR)
 679                 goto exit;
 680
 681         /* Reorder the sensors values:
 682          *
 683          * The values are laid out like this:
 684          * -, Y1, Y2, -, Y3, Y4, -, ..., -, X1, X2, -, X3, X4, ...
 685          * '-' is an unused value.
 686          */
 687
 688         /* read X values */
 689         for (i = 0, j = 19; i < 20; i += 2, j += 3) {
 690                 dev->xy_cur[i] = dev->data[j + 1];
 691                 dev->xy_cur[i + 1] = dev->data[j + 2];
 692         }
 693         /* read Y values */
 694         for (i = 0, j = 1; i < 9; i += 2, j += 3) {
 695                 dev->xy_cur[ATP_XSENSORS + i] = dev->data[j + 1];
 696                 dev->xy_cur[ATP_XSENSORS + i + 1] = dev->data[j + 2];
 697         }
 698
 699         dbg_dump("sample", dev->xy_cur);
 700
 701         /* Just update the base values (i.e. touchpad in untouched state) */
 702         if (dev->data[dev->info->datalen - 1] & ATP_STATUS_BASE_UPDATE) {
 703
 704                 dprintk("appletouch: updated base values\n");
 705
 706                 memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
 707                 goto exit;
 708         }
 709
 710         for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) {
 711                 /* calculate the change */
 712                 dev->xy_acc[i] = dev->xy_cur[i] - dev->xy_old[i];
 713
 714                 /* this is a round-robin value, so couple with that */
 715                 if (dev->xy_acc[i] > 127)
 716                         dev->xy_acc[i] -= 256;
 717
 718                 if (dev->xy_acc[i] < -127)
 719                         dev->xy_acc[i] += 256;
 720
 721                 /* prevent down drifting */
 722                 if (dev->xy_acc[i] < 0)
 723                         dev->xy_acc[i] = 0;
 724         }
 725
 726         dbg_dump("accumulator", dev->xy_acc);
 727
 728         x = atp_calculate_abs(dev, 0, ATP_XSENSORS,
 729                               dev->info->xfact, &x_z, &x_f);
 730         y = atp_calculate_abs(dev, ATP_XSENSORS, ATP_YSENSORS,
 731                               dev->info->yfact, &y_z, &y_f);
 732
 733         key = dev->data[dev->info->datalen - 1] & ATP_STATUS_BUTTON;
 734
 735         fingers = max(x_f, y_f);
 736
 737         if (x && y && fingers == dev->fingers_old) {
 738                 if (dev->x_old != -1) {
 739                         x = (dev->x_old * 7 + x) >> 3;
 740                         y = (dev->y_old * 7 + y) >> 3;
 741                         dev->x_old = x;
 742                         dev->y_old = y;
 743
 744                         if (debug > 1)
 745                                 printk(KERN_DEBUG "appletouch: X: %3d Y: %3d "
 746                                        "Xz: %3d Yz: %3d\n",
 747                                        x, y, x_z, y_z);
 748
 749                         input_report_key(dev->input, BTN_TOUCH, 1);
 750                         input_report_abs(dev->input, ABS_X, x);
 751                         input_report_abs(dev->input, ABS_Y, y);
 752                         input_report_abs(dev->input, ABS_PRESSURE,
 753                                          min(ATP_PRESSURE, x_z + y_z));
 754                         atp_report_fingers(dev->input, fingers);
 755                 }
 756                 dev->x_old = x;
 757                 dev->y_old = y;
 758
 759         } else if (!x && !y) {
 760
 761                 dev->x_old = dev->y_old = -1;
 762                 dev->fingers_old = 0;
 763                 input_report_key(dev->input, BTN_TOUCH, 0);
 764                 input_report_abs(dev->input, ABS_PRESSURE, 0);
 765                 atp_report_fingers(dev->input, 0);
 766
 767                 /* reset the accumulator on release */
 768                 memset(dev->xy_acc, 0, sizeof(dev->xy_acc));
 769         }
 770
 771         if (fingers != dev->fingers_old)
 772                 dev->x_old = dev->y_old = -1;
 773         dev->fingers_old = fingers;
 774
 775         input_report_key(dev->input, BTN_LEFT, key);
 776         input_sync(dev->input);
 777
 778         /*
 779          * Geysers 3/4 will continue to send packets continually after
 780          * the first touch unless reinitialised. Do so if it's been
 781          * idle for a while in order to avoid waking the kernel up
 782          * several hundred times a second.
 783          */
 784
 785         /*
 786          * Button must not be pressed when entering suspend,
 787          * otherwise we will never release the button.
 788          */
 789         if (!x && !y && !key) {
 790                 dev->idlecount++;
 791                 if (dev->idlecount == 10) {
 792                         dev->x_old = dev->y_old = -1;
 793                         dev->idlecount = 0;
 794                         schedule_work(&dev->work);
 795                         /* Don't resubmit urb here, wait for reinit */
 796                         return;
 797                 }
 798         } else
 799                 dev->idlecount = 0;
 800
 801  exit:
 802         retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
 803         if (retval)
 804                 dev_err(&dev->intf->dev,
 805                         "atp_complete: usb_submit_urb failed with result %d\n",
 806                         retval);
 807 }
 808
 809 static int atp_open(struct input_dev *input)
 810 {
 811         struct atp *dev = input_get_drvdata(input);
 812
 813         if (usb_submit_urb(dev->urb, GFP_ATOMIC))
 814                 return -EIO;
 815
 816         dev->open = 1;
 817         return 0;
 818 }
 819
 820 static void atp_close(struct input_dev *input)
 821 {
 822         struct atp *dev = input_get_drvdata(input);
 823
 824         usb_kill_urb(dev->urb);
 825         cancel_work_sync(&dev->work);
 826         dev->open = 0;
 827 }
 828
 829 static int atp_handle_geyser(struct atp *dev)
 830 {
 831         if (dev->info != &fountain_info) {
 832                 /* switch to raw sensor mode */
 833                 if (atp_geyser_init(dev))
 834                         return -EIO;
 835
 836                 dev_info(&dev->intf->dev, "Geyser mode initialized.\n");
 837         }
 838
 839         return 0;
 840 }
 841
 842 static int atp_probe(struct usb_interface *iface,
 843                      const struct usb_device_id *id)
 844 {
 845         struct atp *dev;
 846         struct input_dev *input_dev;
 847         struct usb_device *udev = interface_to_usbdev(iface);
 848         struct usb_host_interface *iface_desc;
 849         struct usb_endpoint_descriptor *endpoint;
 850         int int_in_endpointAddr = 0;
 851         int i, error = -ENOMEM;
 852         const struct atp_info *info = (const struct atp_info *)id->driver_info;
 853
 854         /* set up the endpoint information */
 855         /* use only the first interrupt-in endpoint */
 856         iface_desc = iface->cur_altsetting;
 857         for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
 858                 endpoint = &iface_desc->endpoint[i].desc;
 859                 if (!int_in_endpointAddr && usb_endpoint_is_int_in(endpoint)) {
 860                         /* we found an interrupt in endpoint */
 861                         int_in_endpointAddr = endpoint->bEndpointAddress;
 862                         break;
 863                 }
 864         }
 865         if (!int_in_endpointAddr) {
 866                 dev_err(&iface->dev, "Could not find int-in endpoint\n");
 867                 return -EIO;
 868         }
 869
 870         /* allocate memory for our device state and initialize it */
 871         dev = kzalloc(sizeof(struct atp), GFP_KERNEL);
 872         input_dev = input_allocate_device();
 873         if (!dev || !input_dev) {
 874                 dev_err(&iface->dev, "Out of memory\n");
 875                 goto err_free_devs;
 876         }
 877
 878         dev->udev = udev;
 879         dev->intf = iface;
 880         dev->input = input_dev;
 881         dev->info = info;
 882         dev->overflow_warned = false;
 883
 884         dev->urb = usb_alloc_urb(0, GFP_KERNEL);
 885         if (!dev->urb)
 886                 goto err_free_devs;
 887
 888         dev->data = usb_alloc_coherent(dev->udev, dev->info->datalen, GFP_KERNEL,
 889                                        &dev->urb->transfer_dma);
 890         if (!dev->data)
 891                 goto err_free_urb;
 892
 893         usb_fill_int_urb(dev->urb, udev,
 894                          usb_rcvintpipe(udev, int_in_endpointAddr),
 895                          dev->data, dev->info->datalen,
 896                          dev->info->callback, dev, 1);
 897
 898         error = atp_handle_geyser(dev);
 899         if (error)
 900                 goto err_free_buffer;
 901
 902         usb_make_path(udev, dev->phys, sizeof(dev->phys));
 903         strlcat(dev->phys, "/input0", sizeof(dev->phys));
 904
 905         input_dev->name = "appletouch";
 906         input_dev->phys = dev->phys;
 907         usb_to_input_id(dev->udev, &input_dev->id);
 908         input_dev->dev.parent = &iface->dev;
 909
 910         input_set_drvdata(input_dev, dev);
 911
 912         input_dev->open = atp_open;
 913         input_dev->close = atp_close;
 914
 915         set_bit(EV_ABS, input_dev->evbit);
 916
 917         input_set_abs_params(input_dev, ABS_X, 0,
 918                              (dev->info->xsensors - 1) * dev->info->xfact - 1,
 919                              dev->info->fuzz, 0);
 920         input_set_abs_params(input_dev, ABS_Y, 0,
 921                              (dev->info->ysensors - 1) * dev->info->yfact - 1,
 922                              dev->info->fuzz, 0);
 923         input_set_abs_params(input_dev, ABS_PRESSURE, 0, ATP_PRESSURE, 0, 0);
 924
 925         set_bit(EV_KEY, input_dev->evbit);
 926         set_bit(BTN_TOUCH, input_dev->keybit);
 927         set_bit(BTN_TOOL_FINGER, input_dev->keybit);
 928         set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit);
 929         set_bit(BTN_TOOL_TRIPLETAP, input_dev->keybit);
 930         set_bit(BTN_LEFT, input_dev->keybit);
 931
 932         error = input_register_device(dev->input);
 933         if (error)
 934                 goto err_free_buffer;
 935
 936         /* save our data pointer in this interface device */
 937         usb_set_intfdata(iface, dev);
 938
 939         INIT_WORK(&dev->work, atp_reinit);
 940
 941         return 0;
 942
 943  err_free_buffer:
 944         usb_free_coherent(dev->udev, dev->info->datalen,
 945                           dev->data, dev->urb->transfer_dma);
 946  err_free_urb:
 947         usb_free_urb(dev->urb);
 948  err_free_devs:
 949         usb_set_intfdata(iface, NULL);
 950         kfree(dev);
 951         input_free_device(input_dev);
 952         return error;
 953 }
 954
 955 static void atp_disconnect(struct usb_interface *iface)
 956 {
 957         struct atp *dev = usb_get_intfdata(iface);
 958
 959         usb_set_intfdata(iface, NULL);
 960         if (dev) {
 961                 usb_kill_urb(dev->urb);
 962                 input_unregister_device(dev->input);
 963                 usb_free_coherent(dev->udev, dev->info->datalen,
 964                                   dev->data, dev->urb->transfer_dma);
 965                 usb_free_urb(dev->urb);
 966                 kfree(dev);
 967         }
 968         dev_info(&iface->dev, "input: appletouch disconnected\n");
 969 }
 970
 971 static int atp_recover(struct atp *dev)
 972 {
 973         int error;
 974
 975         error = atp_handle_geyser(dev);
 976         if (error)
 977                 return error;
 978
 979         if (dev->open && usb_submit_urb(dev->urb, GFP_ATOMIC))
 980                 return -EIO;
 981
 982         return 0;
 983 }
 984
 985 static int atp_suspend(struct usb_interface *iface, pm_message_t message)
 986 {
 987         struct atp *dev = usb_get_intfdata(iface);
 988
 989         usb_kill_urb(dev->urb);
 990         return 0;
 991 }
 992
 993 static int atp_resume(struct usb_interface *iface)
 994 {
 995         struct atp *dev = usb_get_intfdata(iface);
 996
 997         if (dev->open && usb_submit_urb(dev->urb, GFP_ATOMIC))
 998                 return -EIO;
 999
1000         return 0;
1001 }
1002
1003 static int atp_reset_resume(struct usb_interface *iface)
1004 {
1005         struct atp *dev = usb_get_intfdata(iface);
1006
1007         return atp_recover(dev);
1008 }
1009
1010 static struct usb_driver atp_driver = {
1011         .name           = "appletouch",
1012         .probe          = atp_probe,
1013         .disconnect     = atp_disconnect,
1014         .suspend        = atp_suspend,
1015         .resume         = atp_resume,
1016         .reset_resume   = atp_reset_resume,
1017         .id_table       = atp_table,
1018 };
1019
1020 module_usb_driver(atp_driver);