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