Merge branch 'pxa-tosa' into pxa
[linux-2.6] / 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      Johannes Berg (johannes@sipsolutions.net)
6  * Copyright (C) 2005      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  *
12  * Thanks to Alex Harper <basilisk@foobox.net> for his inputs.
13  *
14  * This program is free software; you can redistribute it and/or modify
15  * it under the terms of the GNU General Public License as published by
16  * the Free Software Foundation; either version 2 of the License, or
17  * (at your option) any later version.
18  *
19  * This program is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  * GNU General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License
25  * along with this program; if not, write to the Free Software
26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27  *
28  */
29
30 #include <linux/kernel.h>
31 #include <linux/errno.h>
32 #include <linux/init.h>
33 #include <linux/slab.h>
34 #include <linux/module.h>
35 #include <linux/usb/input.h>
36
37 /* Apple has powerbooks which have the keyboard with different Product IDs */
38 #define APPLE_VENDOR_ID         0x05AC
39
40 /* These names come from Info.plist in AppleUSBTrackpad.kext */
41 #define FOUNTAIN_ANSI_PRODUCT_ID        0x020E
42 #define FOUNTAIN_ISO_PRODUCT_ID         0x020F
43
44 #define FOUNTAIN_TP_ONLY_PRODUCT_ID     0x030A
45
46 #define GEYSER1_TP_ONLY_PRODUCT_ID      0x030B
47
48 #define GEYSER_ANSI_PRODUCT_ID          0x0214
49 #define GEYSER_ISO_PRODUCT_ID           0x0215
50 #define GEYSER_JIS_PRODUCT_ID           0x0216
51
52 /* MacBook devices */
53 #define GEYSER3_ANSI_PRODUCT_ID         0x0217
54 #define GEYSER3_ISO_PRODUCT_ID          0x0218
55 #define GEYSER3_JIS_PRODUCT_ID          0x0219
56
57 /*
58  * Geyser IV: same as Geyser III according to Info.plist in AppleUSBTrackpad.kext
59  * -> same IOClass (AppleUSBGrIIITrackpad), same acceleration tables
60  */
61 #define GEYSER4_ANSI_PRODUCT_ID 0x021A
62 #define GEYSER4_ISO_PRODUCT_ID  0x021B
63 #define GEYSER4_JIS_PRODUCT_ID  0x021C
64
65 #define GEYSER4_HF_ANSI_PRODUCT_ID      0x0229
66 #define GEYSER4_HF_ISO_PRODUCT_ID       0x022A
67 #define GEYSER4_HF_JIS_PRODUCT_ID       0x022B
68
69 #define ATP_DEVICE(prod)                                        \
70         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |             \
71                        USB_DEVICE_ID_MATCH_INT_CLASS |          \
72                        USB_DEVICE_ID_MATCH_INT_PROTOCOL,        \
73         .idVendor = APPLE_VENDOR_ID,                            \
74         .idProduct = (prod),                                    \
75         .bInterfaceClass = 0x03,                                \
76         .bInterfaceProtocol = 0x02
77
78 /* table of devices that work with this driver */
79 static struct usb_device_id atp_table [] = {
80         { ATP_DEVICE(FOUNTAIN_ANSI_PRODUCT_ID) },
81         { ATP_DEVICE(FOUNTAIN_ISO_PRODUCT_ID) },
82         { ATP_DEVICE(FOUNTAIN_TP_ONLY_PRODUCT_ID) },
83         { ATP_DEVICE(GEYSER1_TP_ONLY_PRODUCT_ID) },
84
85         /* PowerBooks Oct 2005 */
86         { ATP_DEVICE(GEYSER_ANSI_PRODUCT_ID) },
87         { ATP_DEVICE(GEYSER_ISO_PRODUCT_ID) },
88         { ATP_DEVICE(GEYSER_JIS_PRODUCT_ID) },
89
90         /* Core Duo MacBook & MacBook Pro */
91         { ATP_DEVICE(GEYSER3_ANSI_PRODUCT_ID) },
92         { ATP_DEVICE(GEYSER3_ISO_PRODUCT_ID) },
93         { ATP_DEVICE(GEYSER3_JIS_PRODUCT_ID) },
94
95         /* Core2 Duo MacBook & MacBook Pro */
96         { ATP_DEVICE(GEYSER4_ANSI_PRODUCT_ID) },
97         { ATP_DEVICE(GEYSER4_ISO_PRODUCT_ID) },
98         { ATP_DEVICE(GEYSER4_JIS_PRODUCT_ID) },
99
100         { ATP_DEVICE(GEYSER4_HF_ANSI_PRODUCT_ID) },
101         { ATP_DEVICE(GEYSER4_HF_ISO_PRODUCT_ID) },
102         { ATP_DEVICE(GEYSER4_HF_JIS_PRODUCT_ID) },
103
104         /* Terminating entry */
105         { }
106 };
107 MODULE_DEVICE_TABLE (usb, atp_table);
108
109 /*
110  * number of sensors. Note that only 16 instead of 26 X (horizontal)
111  * sensors exist on 12" and 15" PowerBooks. All models have 16 Y
112  * (vertical) sensors.
113  */
114 #define ATP_XSENSORS    26
115 #define ATP_YSENSORS    16
116
117 /* amount of fuzz this touchpad generates */
118 #define ATP_FUZZ        16
119
120 /* maximum pressure this driver will report */
121 #define ATP_PRESSURE    300
122 /*
123  * multiplication factor for the X and Y coordinates.
124  * We try to keep the touchpad aspect ratio while still doing only simple
125  * arithmetics.
126  * The factors below give coordinates like:
127  *      0 <= x <  960 on 12" and 15" Powerbooks
128  *      0 <= x < 1600 on 17" Powerbooks
129  *      0 <= y <  646
130  */
131 #define ATP_XFACT       64
132 #define ATP_YFACT       43
133
134 /*
135  * Threshold for the touchpad sensors. Any change less than ATP_THRESHOLD is
136  * ignored.
137  */
138 #define ATP_THRESHOLD    5
139
140 /* Geyser initialization constants */
141 #define ATP_GEYSER_MODE_READ_REQUEST_ID         1
142 #define ATP_GEYSER_MODE_WRITE_REQUEST_ID        9
143 #define ATP_GEYSER_MODE_REQUEST_VALUE           0x300
144 #define ATP_GEYSER_MODE_REQUEST_INDEX           0
145 #define ATP_GEYSER_MODE_VENDOR_VALUE            0x04
146
147 /* Structure to hold all of our device specific stuff */
148 struct atp {
149         char                    phys[64];
150         struct usb_device *     udev;           /* usb device */
151         struct urb *            urb;            /* usb request block */
152         signed char *           data;           /* transferred data */
153         struct input_dev *      input;          /* input dev */
154         unsigned char           open;           /* non-zero if opened */
155         unsigned char           valid;          /* are the sensors valid ? */
156         unsigned char           size_detect_done;
157         unsigned char           overflowwarn;   /* overflow warning printed? */
158         int                     x_old;          /* last reported x/y, */
159         int                     y_old;          /* used for smoothing */
160                                                 /* current value of the sensors */
161         signed char             xy_cur[ATP_XSENSORS + ATP_YSENSORS];
162                                                 /* last value of the sensors */
163         signed char             xy_old[ATP_XSENSORS + ATP_YSENSORS];
164                                                 /* accumulated sensors */
165         int                     xy_acc[ATP_XSENSORS + ATP_YSENSORS];
166         int                     datalen;        /* size of an USB urb transfer */
167         int                     idlecount;      /* number of empty packets */
168         struct work_struct      work;
169 };
170
171 #define dbg_dump(msg, tab) \
172         if (debug > 1) {                                                \
173                 int i;                                                  \
174                 printk("appletouch: %s %lld", msg, (long long)jiffies); \
175                 for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++)       \
176                         printk(" %02x", tab[i]);                        \
177                 printk("\n");                                           \
178         }
179
180 #define dprintk(format, a...)                                           \
181         do {                                                            \
182                 if (debug) printk(KERN_DEBUG format, ##a);              \
183         } while (0)
184
185 MODULE_AUTHOR("Johannes Berg, Stelian Pop, Frank Arnold, Michael Hanselmann");
186 MODULE_DESCRIPTION("Apple PowerBooks USB touchpad driver");
187 MODULE_LICENSE("GPL");
188
189 /*
190  * Make the threshold a module parameter
191  */
192 static int threshold = ATP_THRESHOLD;
193 module_param(threshold, int, 0644);
194 MODULE_PARM_DESC(threshold, "Discards any change in data from a sensor (trackpad has hundreds of these sensors) less than this value");
195
196 static int debug = 1;
197 module_param(debug, int, 0644);
198 MODULE_PARM_DESC(debug, "Activate debugging output");
199
200 static inline int atp_is_fountain(struct atp *dev)
201 {
202         u16 productId = le16_to_cpu(dev->udev->descriptor.idProduct);
203
204         return productId == FOUNTAIN_ANSI_PRODUCT_ID ||
205                productId == FOUNTAIN_ISO_PRODUCT_ID ||
206                productId == FOUNTAIN_TP_ONLY_PRODUCT_ID;
207 }
208
209 /* Checks if the device a Geyser 2 (ANSI, ISO, JIS) */
210 static inline int atp_is_geyser_2(struct atp *dev)
211 {
212         u16 productId = le16_to_cpu(dev->udev->descriptor.idProduct);
213
214         return (productId == GEYSER_ANSI_PRODUCT_ID) ||
215                 (productId == GEYSER_ISO_PRODUCT_ID) ||
216                 (productId == GEYSER_JIS_PRODUCT_ID);
217 }
218
219 static inline int atp_is_geyser_3(struct atp *dev)
220 {
221         u16 productId = le16_to_cpu(dev->udev->descriptor.idProduct);
222
223         return (productId == GEYSER3_ANSI_PRODUCT_ID) ||
224                 (productId == GEYSER3_ISO_PRODUCT_ID) ||
225                 (productId == GEYSER3_JIS_PRODUCT_ID) ||
226                 (productId == GEYSER4_ANSI_PRODUCT_ID) ||
227                 (productId == GEYSER4_ISO_PRODUCT_ID) ||
228                 (productId == GEYSER4_JIS_PRODUCT_ID) ||
229                 (productId == GEYSER4_HF_ANSI_PRODUCT_ID) ||
230                 (productId == GEYSER4_HF_ISO_PRODUCT_ID) ||
231                 (productId == GEYSER4_HF_JIS_PRODUCT_ID);
232 }
233
234 /*
235  * By default newer Geyser devices send standard USB HID mouse
236  * packets (Report ID 2). This code changes device mode, so it
237  * sends raw sensor reports (Report ID 5).
238  */
239 static int atp_geyser_init(struct usb_device *udev)
240 {
241         char data[8];
242         int size;
243
244         size = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
245                         ATP_GEYSER_MODE_READ_REQUEST_ID,
246                         USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
247                         ATP_GEYSER_MODE_REQUEST_VALUE,
248                         ATP_GEYSER_MODE_REQUEST_INDEX, &data, 8, 5000);
249
250         if (size != 8) {
251                 err("Could not do mode read request from device"
252                     " (Geyser Raw mode)");
253                 return -EIO;
254         }
255
256         /* Apply the mode switch */
257         data[0] = ATP_GEYSER_MODE_VENDOR_VALUE;
258
259         size = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
260                         ATP_GEYSER_MODE_WRITE_REQUEST_ID,
261                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
262                         ATP_GEYSER_MODE_REQUEST_VALUE,
263                         ATP_GEYSER_MODE_REQUEST_INDEX, &data, 8, 5000);
264
265         if (size != 8) {
266                 err("Could not do mode write request to device"
267                     " (Geyser Raw mode)");
268                 return -EIO;
269         }
270         return 0;
271 }
272
273 /*
274  * Reinitialise the device. This usually stops stream of empty packets
275  * coming from it.
276  */
277 static void atp_reinit(struct work_struct *work)
278 {
279         struct atp *dev = container_of(work, struct atp, work);
280         struct usb_device *udev = dev->udev;
281         int retval;
282
283         dev->idlecount = 0;
284
285         atp_geyser_init(udev);
286
287         retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
288         if (retval) {
289                 err("%s - usb_submit_urb failed with result %d",
290                     __FUNCTION__, retval);
291         }
292 }
293
294 static int atp_calculate_abs(int *xy_sensors, int nb_sensors, int fact,
295                              int *z, int *fingers)
296 {
297         int i;
298         /* values to calculate mean */
299         int pcum = 0, psum = 0;
300         int is_increasing = 0;
301
302         *fingers = 0;
303
304         for (i = 0; i < nb_sensors; i++) {
305                 if (xy_sensors[i] < threshold) {
306                         if (is_increasing)
307                                 is_increasing = 0;
308
309                         continue;
310                 }
311
312                 /*
313                  * Makes the finger detection more versatile.  For example,
314                  * two fingers with no gap will be detected.  Also, my
315                  * tests show it less likely to have intermittent loss
316                  * of multiple finger readings while moving around (scrolling).
317                  *
318                  * Changes the multiple finger detection to counting humps on
319                  * sensors (transitions from nonincreasing to increasing)
320                  * instead of counting transitions from low sensors (no
321                  * finger reading) to high sensors (finger above
322                  * sensor)
323                  *
324                  * - Jason Parekh <jasonparekh@gmail.com>
325                  */
326                 if (i < 1 || (!is_increasing && xy_sensors[i - 1] < xy_sensors[i])) {
327                         (*fingers)++;
328                         is_increasing = 1;
329                 } else if (i > 0 && xy_sensors[i - 1] >= xy_sensors[i]) {
330                         is_increasing = 0;
331                 }
332
333                 /*
334                  * Subtracts threshold so a high sensor that just passes the threshold
335                  * won't skew the calculated absolute coordinate.  Fixes an issue
336                  * where slowly moving the mouse would occassionaly jump a number of
337                  * pixels (let me restate--slowly moving the mouse makes this issue
338                  * most apparent).
339                  */
340                 pcum += (xy_sensors[i] - threshold) * i;
341                 psum += (xy_sensors[i] - threshold);
342         }
343
344         if (psum > 0) {
345                 *z = psum;
346                 return pcum * fact / psum;
347         }
348
349         return 0;
350 }
351
352 static inline void atp_report_fingers(struct input_dev *input, int fingers)
353 {
354         input_report_key(input, BTN_TOOL_FINGER, fingers == 1);
355         input_report_key(input, BTN_TOOL_DOUBLETAP, fingers == 2);
356         input_report_key(input, BTN_TOOL_TRIPLETAP, fingers > 2);
357 }
358
359 static void atp_complete(struct urb* urb)
360 {
361         int x, y, x_z, y_z, x_f, y_f;
362         int retval, i, j;
363         int key;
364         struct atp *dev = urb->context;
365
366         switch (urb->status) {
367         case 0:
368                 /* success */
369                 break;
370         case -EOVERFLOW:
371                 if(!dev->overflowwarn) {
372                         printk(KERN_WARNING "appletouch: OVERFLOW with data "
373                                 "length %d, actual length is %d\n",
374                                 dev->datalen, dev->urb->actual_length);
375                         dev->overflowwarn = 1;
376                 }
377         case -ECONNRESET:
378         case -ENOENT:
379         case -ESHUTDOWN:
380                 /* This urb is terminated, clean up */
381                 dbg("%s - urb shutting down with status: %d",
382                     __FUNCTION__, urb->status);
383                 return;
384         default:
385                 dbg("%s - nonzero urb status received: %d",
386                     __FUNCTION__, urb->status);
387                 goto exit;
388         }
389
390         /* drop incomplete datasets */
391         if (dev->urb->actual_length != dev->datalen) {
392                 dprintk("appletouch: incomplete data package"
393                         " (first byte: %d, length: %d).\n",
394                         dev->data[0], dev->urb->actual_length);
395                 goto exit;
396         }
397
398         /* reorder the sensors values */
399         if (atp_is_geyser_3(dev)) {
400                 memset(dev->xy_cur, 0, sizeof(dev->xy_cur));
401
402                 /*
403                  * The values are laid out like this:
404                  * -, Y1, Y2, -, Y3, Y4, -, ..., -, X1, X2, -, X3, X4, ...
405                  * '-' is an unused value.
406                  */
407
408                 /* read X values */
409                 for (i = 0, j = 19; i < 20; i += 2, j += 3) {
410                         dev->xy_cur[i] = dev->data[j + 1];
411                         dev->xy_cur[i + 1] = dev->data[j + 2];
412                 }
413                 /* read Y values */
414                 for (i = 0, j = 1; i < 9; i += 2, j += 3) {
415                         dev->xy_cur[ATP_XSENSORS + i] = dev->data[j + 1];
416                         dev->xy_cur[ATP_XSENSORS + i + 1] = dev->data[j + 2];
417                 }
418         } else if (atp_is_geyser_2(dev)) {
419                 memset(dev->xy_cur, 0, sizeof(dev->xy_cur));
420
421                 /*
422                  * The values are laid out like this:
423                  * Y1, Y2, -, Y3, Y4, -, ..., X1, X2, -, X3, X4, -, ...
424                  * '-' is an unused value.
425                  */
426
427                 /* read X values */
428                 for (i = 0, j = 19; i < 20; i += 2, j += 3) {
429                         dev->xy_cur[i] = dev->data[j];
430                         dev->xy_cur[i + 1] = dev->data[j + 1];
431                 }
432
433                 /* read Y values */
434                 for (i = 0, j = 1; i < 9; i += 2, j += 3) {
435                         dev->xy_cur[ATP_XSENSORS + i] = dev->data[j];
436                         dev->xy_cur[ATP_XSENSORS + i + 1] = dev->data[j + 1];
437                 }
438         } else {
439                 for (i = 0; i < 8; i++) {
440                         /* X values */
441                         dev->xy_cur[i     ] = dev->data[5 * i +  2];
442                         dev->xy_cur[i +  8] = dev->data[5 * i +  4];
443                         dev->xy_cur[i + 16] = dev->data[5 * i + 42];
444                         if (i < 2)
445                                 dev->xy_cur[i + 24] = dev->data[5 * i + 44];
446
447                         /* Y values */
448                         dev->xy_cur[i + 26] = dev->data[5 * i +  1];
449                         dev->xy_cur[i + 34] = dev->data[5 * i +  3];
450                 }
451         }
452
453         dbg_dump("sample", dev->xy_cur);
454
455         if (!dev->valid) {
456                 /* first sample */
457                 dev->valid = 1;
458                 dev->x_old = dev->y_old = -1;
459                 memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
460
461                 if (dev->size_detect_done ||
462                     atp_is_geyser_3(dev)) /* No 17" Macbooks (yet) */
463                         goto exit;
464
465                 /* 17" Powerbooks have extra X sensors */
466                 for (i = (atp_is_geyser_2(dev) ? 15 : 16); i < ATP_XSENSORS; i++) {
467                         if (!dev->xy_cur[i])
468                                 continue;
469
470                         printk(KERN_INFO "appletouch: 17\" model detected.\n");
471                         if (atp_is_geyser_2(dev))
472                                 input_set_abs_params(dev->input, ABS_X, 0,
473                                                      (20 - 1) *
474                                                      ATP_XFACT - 1,
475                                                      ATP_FUZZ, 0);
476                         else
477                                 input_set_abs_params(dev->input, ABS_X, 0,
478                                                      (ATP_XSENSORS - 1) *
479                                                      ATP_XFACT - 1,
480                                                      ATP_FUZZ, 0);
481                         break;
482                 }
483
484                 dev->size_detect_done = 1;
485                 goto exit;
486         }
487
488         for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) {
489                 /* accumulate the change */
490                 signed char change = dev->xy_old[i] - dev->xy_cur[i];
491                 dev->xy_acc[i] -= change;
492
493                 /* prevent down drifting */
494                 if (dev->xy_acc[i] < 0)
495                         dev->xy_acc[i] = 0;
496         }
497
498         memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
499
500         dbg_dump("accumulator", dev->xy_acc);
501
502         x = atp_calculate_abs(dev->xy_acc, ATP_XSENSORS,
503                               ATP_XFACT, &x_z, &x_f);
504         y = atp_calculate_abs(dev->xy_acc + ATP_XSENSORS, ATP_YSENSORS,
505                               ATP_YFACT, &y_z, &y_f);
506         key = dev->data[dev->datalen - 1] & 1;
507
508         if (x && y) {
509                 if (dev->x_old != -1) {
510                         x = (dev->x_old * 3 + x) >> 2;
511                         y = (dev->y_old * 3 + y) >> 2;
512                         dev->x_old = x;
513                         dev->y_old = y;
514
515                         if (debug > 1)
516                                 printk(KERN_DEBUG "appletouch: X: %3d Y: %3d "
517                                        "Xz: %3d Yz: %3d\n",
518                                        x, y, x_z, y_z);
519
520                         input_report_key(dev->input, BTN_TOUCH, 1);
521                         input_report_abs(dev->input, ABS_X, x);
522                         input_report_abs(dev->input, ABS_Y, y);
523                         input_report_abs(dev->input, ABS_PRESSURE,
524                                          min(ATP_PRESSURE, x_z + y_z));
525                         atp_report_fingers(dev->input, max(x_f, y_f));
526                 }
527                 dev->x_old = x;
528                 dev->y_old = y;
529
530         } else if (!x && !y) {
531
532                 dev->x_old = dev->y_old = -1;
533                 input_report_key(dev->input, BTN_TOUCH, 0);
534                 input_report_abs(dev->input, ABS_PRESSURE, 0);
535                 atp_report_fingers(dev->input, 0);
536
537                 /* reset the accumulator on release */
538                 memset(dev->xy_acc, 0, sizeof(dev->xy_acc));
539         }
540
541         input_report_key(dev->input, BTN_LEFT, key);
542         input_sync(dev->input);
543
544         /*
545          * Many Geysers will continue to send packets continually after
546          * the first touch unless reinitialised. Do so if it's been
547          * idle for a while in order to avoid waking the kernel up
548          * several hundred times a second. Re-initialization does not
549          * work on Fountain touchpads.
550          */
551         if (!atp_is_fountain(dev)) {
552                 if (!x && !y && !key) {
553                         dev->idlecount++;
554                         if (dev->idlecount == 10) {
555                                 dev->valid = 0;
556                                 schedule_work(&dev->work);
557                                 /* Don't resubmit urb here, wait for reinit */
558                                 return;
559                         }
560                 } else
561                         dev->idlecount = 0;
562         }
563
564 exit:
565         retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
566         if (retval) {
567                 err("%s - usb_submit_urb failed with result %d",
568                     __FUNCTION__, retval);
569         }
570 }
571
572 static int atp_open(struct input_dev *input)
573 {
574         struct atp *dev = input_get_drvdata(input);
575
576         if (usb_submit_urb(dev->urb, GFP_ATOMIC))
577                 return -EIO;
578
579         dev->open = 1;
580         return 0;
581 }
582
583 static void atp_close(struct input_dev *input)
584 {
585         struct atp *dev = input_get_drvdata(input);
586
587         usb_kill_urb(dev->urb);
588         cancel_work_sync(&dev->work);
589         dev->open = 0;
590 }
591
592 static int atp_handle_geyser(struct atp *dev)
593 {
594         struct usb_device *udev = dev->udev;
595
596         if (!atp_is_fountain(dev)) {
597                 /* switch to raw sensor mode */
598                 if (atp_geyser_init(udev))
599                         return -EIO;
600
601                 printk(KERN_INFO "appletouch: Geyser mode initialized.\n");
602         }
603
604         return 0;
605 }
606
607 static int atp_probe(struct usb_interface *iface, const struct usb_device_id *id)
608 {
609         struct atp *dev;
610         struct input_dev *input_dev;
611         struct usb_device *udev = interface_to_usbdev(iface);
612         struct usb_host_interface *iface_desc;
613         struct usb_endpoint_descriptor *endpoint;
614         int int_in_endpointAddr = 0;
615         int i, error = -ENOMEM;
616
617         /* set up the endpoint information */
618         /* use only the first interrupt-in endpoint */
619         iface_desc = iface->cur_altsetting;
620         for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
621                 endpoint = &iface_desc->endpoint[i].desc;
622                 if (!int_in_endpointAddr && usb_endpoint_is_int_in(endpoint)) {
623                         /* we found an interrupt in endpoint */
624                         int_in_endpointAddr = endpoint->bEndpointAddress;
625                         break;
626                 }
627         }
628         if (!int_in_endpointAddr) {
629                 err("Could not find int-in endpoint");
630                 return -EIO;
631         }
632
633         /* allocate memory for our device state and initialize it */
634         dev = kzalloc(sizeof(struct atp), GFP_KERNEL);
635         input_dev = input_allocate_device();
636         if (!dev || !input_dev) {
637                 err("Out of memory");
638                 goto err_free_devs;
639         }
640
641         dev->udev = udev;
642         dev->input = input_dev;
643         dev->overflowwarn = 0;
644         if (atp_is_geyser_3(dev))
645                 dev->datalen = 64;
646         else if (atp_is_geyser_2(dev))
647                 dev->datalen = 64;
648         else
649                 dev->datalen = 81;
650
651         dev->urb = usb_alloc_urb(0, GFP_KERNEL);
652         if (!dev->urb)
653                 goto err_free_devs;
654
655         dev->data = usb_buffer_alloc(dev->udev, dev->datalen, GFP_KERNEL,
656                                      &dev->urb->transfer_dma);
657         if (!dev->data)
658                 goto err_free_urb;
659
660         usb_fill_int_urb(dev->urb, udev,
661                          usb_rcvintpipe(udev, int_in_endpointAddr),
662                          dev->data, dev->datalen, atp_complete, dev, 1);
663
664         error = atp_handle_geyser(dev);
665         if (error)
666                 goto err_free_buffer;
667
668         usb_make_path(udev, dev->phys, sizeof(dev->phys));
669         strlcat(dev->phys, "/input0", sizeof(dev->phys));
670
671         input_dev->name = "appletouch";
672         input_dev->phys = dev->phys;
673         usb_to_input_id(dev->udev, &input_dev->id);
674         input_dev->dev.parent = &iface->dev;
675
676         input_set_drvdata(input_dev, dev);
677
678         input_dev->open = atp_open;
679         input_dev->close = atp_close;
680
681         set_bit(EV_ABS, input_dev->evbit);
682
683         if (atp_is_geyser_3(dev)) {
684                 /*
685                  * MacBook have 20 X sensors, 10 Y sensors
686                  */
687                 input_set_abs_params(input_dev, ABS_X, 0,
688                                      ((20 - 1) * ATP_XFACT) - 1, ATP_FUZZ, 0);
689                 input_set_abs_params(input_dev, ABS_Y, 0,
690                                      ((10 - 1) * ATP_YFACT) - 1, ATP_FUZZ, 0);
691         } else if (atp_is_geyser_2(dev)) {
692                 /*
693                  * Oct 2005 15" PowerBooks have 15 X sensors, 17" are detected
694                  * later.
695                  */
696                 input_set_abs_params(input_dev, ABS_X, 0,
697                                      ((15 - 1) * ATP_XFACT) - 1, ATP_FUZZ, 0);
698                 input_set_abs_params(input_dev, ABS_Y, 0,
699                                      ((9 - 1) * ATP_YFACT) - 1, ATP_FUZZ, 0);
700         } else {
701                 /*
702                  * 12" and 15" Powerbooks only have 16 x sensors,
703                  * 17" models are detected later.
704                  */
705                 input_set_abs_params(input_dev, ABS_X, 0,
706                                      (16 - 1) * ATP_XFACT - 1, ATP_FUZZ, 0);
707                 input_set_abs_params(input_dev, ABS_Y, 0,
708                                      (ATP_YSENSORS - 1) * ATP_YFACT - 1, ATP_FUZZ, 0);
709         }
710         input_set_abs_params(input_dev, ABS_PRESSURE, 0, ATP_PRESSURE, 0, 0);
711
712         set_bit(EV_KEY, input_dev->evbit);
713         set_bit(BTN_TOUCH, input_dev->keybit);
714         set_bit(BTN_TOOL_FINGER, input_dev->keybit);
715         set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit);
716         set_bit(BTN_TOOL_TRIPLETAP, input_dev->keybit);
717         set_bit(BTN_LEFT, input_dev->keybit);
718
719         error = input_register_device(dev->input);
720         if (error)
721                 goto err_free_buffer;
722
723         /* save our data pointer in this interface device */
724         usb_set_intfdata(iface, dev);
725
726         INIT_WORK(&dev->work, atp_reinit);
727
728         return 0;
729
730  err_free_buffer:
731         usb_buffer_free(dev->udev, dev->datalen,
732                         dev->data, dev->urb->transfer_dma);
733  err_free_urb:
734         usb_free_urb(dev->urb);
735  err_free_devs:
736         usb_set_intfdata(iface, NULL);
737         kfree(dev);
738         input_free_device(input_dev);
739         return error;
740 }
741
742 static void atp_disconnect(struct usb_interface *iface)
743 {
744         struct atp *dev = usb_get_intfdata(iface);
745
746         usb_set_intfdata(iface, NULL);
747         if (dev) {
748                 usb_kill_urb(dev->urb);
749                 input_unregister_device(dev->input);
750                 usb_buffer_free(dev->udev, dev->datalen,
751                                 dev->data, dev->urb->transfer_dma);
752                 usb_free_urb(dev->urb);
753                 kfree(dev);
754         }
755         printk(KERN_INFO "input: appletouch disconnected\n");
756 }
757
758 static int atp_recover(struct atp *dev)
759 {
760         int error;
761
762         error = atp_handle_geyser(dev);
763         if (error)
764                 return error;
765
766         if (dev->open && usb_submit_urb(dev->urb, GFP_ATOMIC))
767                 return -EIO;
768
769         return 0;
770 }
771
772 static int atp_suspend(struct usb_interface *iface, pm_message_t message)
773 {
774         struct atp *dev = usb_get_intfdata(iface);
775
776         usb_kill_urb(dev->urb);
777         dev->valid = 0;
778
779         return 0;
780 }
781
782 static int atp_resume(struct usb_interface *iface)
783 {
784         struct atp *dev = usb_get_intfdata(iface);
785
786         if (dev->open && usb_submit_urb(dev->urb, GFP_ATOMIC))
787                 return -EIO;
788
789         return 0;
790 }
791
792 static int atp_reset_resume(struct usb_interface *iface)
793 {
794         struct atp *dev = usb_get_intfdata(iface);
795
796         return atp_recover(dev);
797 }
798
799 static struct usb_driver atp_driver = {
800         .name           = "appletouch",
801         .probe          = atp_probe,
802         .disconnect     = atp_disconnect,
803         .suspend        = atp_suspend,
804         .resume         = atp_resume,
805         .reset_resume   = atp_reset_resume,
806         .id_table       = atp_table,
807 };
808
809 static int __init atp_init(void)
810 {
811         return usb_register(&atp_driver);
812 }
813
814 static void __exit atp_exit(void)
815 {
816         usb_deregister(&atp_driver);
817 }
818
819 module_init(atp_init);
820 module_exit(atp_exit);