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