2 * Apple USB Touchpad (for post-February 2005 PowerBooks and MacBooks) driver
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 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)
13 * Thanks to Alex Harper <basilisk@foobox.net> for his inputs.
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.
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.
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.
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>
38 /* Type of touchpad */
39 enum atp_touchpad_type
{
47 #define ATP_DEVICE(prod, type) \
49 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
50 USB_DEVICE_ID_MATCH_INT_CLASS | \
51 USB_DEVICE_ID_MATCH_INT_PROTOCOL, \
52 .idVendor = 0x05ac, /* Apple */ \
53 .idProduct = (prod), \
54 .bInterfaceClass = 0x03, \
55 .bInterfaceProtocol = 0x02, \
56 .driver_info = ATP_ ## type, \
60 * Table of devices (Product IDs) that work with this driver.
61 * (The names come from Info.plist in AppleUSBTrackpad.kext,
62 * According to Info.plist Geyser IV is the same as Geyser III.)
65 static struct usb_device_id atp_table
[] = {
66 /* PowerBooks Feb 2005, iBooks G4 */
67 ATP_DEVICE(0x020e, FOUNTAIN
), /* FOUNTAIN ANSI */
68 ATP_DEVICE(0x020f, FOUNTAIN
), /* FOUNTAIN ISO */
69 ATP_DEVICE(0x030a, FOUNTAIN
), /* FOUNTAIN TP ONLY */
70 ATP_DEVICE(0x030b, GEYSER1
), /* GEYSER 1 TP ONLY */
72 /* PowerBooks Oct 2005 */
73 ATP_DEVICE(0x0214, GEYSER2
), /* GEYSER 2 ANSI */
74 ATP_DEVICE(0x0215, GEYSER2
), /* GEYSER 2 ISO */
75 ATP_DEVICE(0x0216, GEYSER2
), /* GEYSER 2 JIS */
77 /* Core Duo MacBook & MacBook Pro */
78 ATP_DEVICE(0x0217, GEYSER3
), /* GEYSER 3 ANSI */
79 ATP_DEVICE(0x0218, GEYSER3
), /* GEYSER 3 ISO */
80 ATP_DEVICE(0x0219, GEYSER3
), /* GEYSER 3 JIS */
82 /* Core2 Duo MacBook & MacBook Pro */
83 ATP_DEVICE(0x021a, GEYSER4
), /* GEYSER 4 ANSI */
84 ATP_DEVICE(0x021b, GEYSER4
), /* GEYSER 4 ISO */
85 ATP_DEVICE(0x021c, GEYSER4
), /* GEYSER 4 JIS */
87 /* Core2 Duo MacBook3,1 */
88 ATP_DEVICE(0x0229, GEYSER4
), /* GEYSER 4 HF ANSI */
89 ATP_DEVICE(0x022a, GEYSER4
), /* GEYSER 4 HF ISO */
90 ATP_DEVICE(0x022b, GEYSER4
), /* GEYSER 4 HF JIS */
92 /* Terminating entry */
95 MODULE_DEVICE_TABLE(usb
, atp_table
);
98 * number of sensors. Note that only 16 instead of 26 X (horizontal)
99 * sensors exist on 12" and 15" PowerBooks. All models have 16 Y
100 * (vertical) sensors.
102 #define ATP_XSENSORS 26
103 #define ATP_YSENSORS 16
105 /* amount of fuzz this touchpad generates */
108 /* maximum pressure this driver will report */
109 #define ATP_PRESSURE 300
111 * multiplication factor for the X and Y coordinates.
112 * We try to keep the touchpad aspect ratio while still doing only simple
114 * The factors below give coordinates like:
116 * 0 <= x < 960 on 12" and 15" Powerbooks
117 * 0 <= x < 1600 on 17" Powerbooks and 17" MacBook Pro
118 * 0 <= x < 1216 on MacBooks and 15" MacBook Pro
120 * 0 <= y < 646 on all Powerbooks
121 * 0 <= y < 774 on all MacBooks
127 * Threshold for the touchpad sensors. Any change less than ATP_THRESHOLD is
130 #define ATP_THRESHOLD 5
132 /* Geyser initialization constants */
133 #define ATP_GEYSER_MODE_READ_REQUEST_ID 1
134 #define ATP_GEYSER_MODE_WRITE_REQUEST_ID 9
135 #define ATP_GEYSER_MODE_REQUEST_VALUE 0x300
136 #define ATP_GEYSER_MODE_REQUEST_INDEX 0
137 #define ATP_GEYSER_MODE_VENDOR_VALUE 0x04
139 /* Structure to hold all of our device specific stuff */
142 struct usb_device
*udev
; /* usb device */
143 struct urb
*urb
; /* usb request block */
144 signed char *data
; /* transferred data */
145 struct input_dev
*input
; /* input dev */
146 enum atp_touchpad_type type
; /* type of touchpad */
148 bool valid
; /* are the samples valid? */
149 bool size_detect_done
;
150 bool overflow_warned
;
151 int x_old
; /* last reported x/y, */
152 int y_old
; /* used for smoothing */
153 signed char xy_cur
[ATP_XSENSORS
+ ATP_YSENSORS
];
154 signed char xy_old
[ATP_XSENSORS
+ ATP_YSENSORS
];
155 int xy_acc
[ATP_XSENSORS
+ ATP_YSENSORS
];
156 int datalen
; /* size of USB transfer */
157 int idlecount
; /* number of empty packets */
158 struct work_struct work
;
161 #define dbg_dump(msg, tab) \
164 printk(KERN_DEBUG "appletouch: %s", msg); \
165 for (__i = 0; __i < ATP_XSENSORS + ATP_YSENSORS; __i++) \
166 printk(" %02x", tab[__i]); \
170 #define dprintk(format, a...) \
173 printk(KERN_DEBUG format, ##a); \
176 MODULE_AUTHOR("Johannes Berg");
177 MODULE_AUTHOR("Stelian Pop");
178 MODULE_AUTHOR("Frank Arnold");
179 MODULE_AUTHOR("Michael Hanselmann");
180 MODULE_AUTHOR("Sven Anders");
181 MODULE_DESCRIPTION("Apple PowerBook and MacBook USB touchpad driver");
182 MODULE_LICENSE("GPL");
185 * Make the threshold a module parameter
187 static int threshold
= ATP_THRESHOLD
;
188 module_param(threshold
, int, 0644);
189 MODULE_PARM_DESC(threshold
, "Discard any change in data from a sensor"
190 " (the trackpad has many of these sensors)"
191 " less than this value.");
194 module_param(debug
, int, 0644);
195 MODULE_PARM_DESC(debug
, "Activate debugging output");
198 * By default newer Geyser devices send standard USB HID mouse
199 * packets (Report ID 2). This code changes device mode, so it
200 * sends raw sensor reports (Report ID 5).
202 static int atp_geyser_init(struct usb_device
*udev
)
208 size
= usb_control_msg(udev
, usb_rcvctrlpipe(udev
, 0),
209 ATP_GEYSER_MODE_READ_REQUEST_ID
,
210 USB_DIR_IN
| USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
211 ATP_GEYSER_MODE_REQUEST_VALUE
,
212 ATP_GEYSER_MODE_REQUEST_INDEX
, &data
, 8, 5000);
215 dprintk("atp_geyser_init: read error\n");
216 for (i
= 0; i
< 8; i
++)
217 dprintk("appletouch[%d]: %d\n", i
, data
[i
]);
219 err("Failed to read mode from device.");
223 /* Apply the mode switch */
224 data
[0] = ATP_GEYSER_MODE_VENDOR_VALUE
;
226 size
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0),
227 ATP_GEYSER_MODE_WRITE_REQUEST_ID
,
228 USB_DIR_OUT
| USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
229 ATP_GEYSER_MODE_REQUEST_VALUE
,
230 ATP_GEYSER_MODE_REQUEST_INDEX
, &data
, 8, 5000);
233 dprintk("atp_geyser_init: write error\n");
234 for (i
= 0; i
< 8; i
++)
235 dprintk("appletouch[%d]: %d\n", i
, data
[i
]);
237 err("Failed to request geyser raw mode");
244 * Reinitialise the device. This usually stops stream of empty packets
247 static void atp_reinit(struct work_struct
*work
)
249 struct atp
*dev
= container_of(work
, struct atp
, work
);
250 struct usb_device
*udev
= dev
->udev
;
253 dprintk("appletouch: putting appletouch to sleep (reinit)\n");
256 atp_geyser_init(udev
);
258 retval
= usb_submit_urb(dev
->urb
, GFP_ATOMIC
);
260 err("atp_reinit: usb_submit_urb failed with error %d",
264 static int atp_calculate_abs(int *xy_sensors
, int nb_sensors
, int fact
,
265 int *z
, int *fingers
)
268 /* values to calculate mean */
269 int pcum
= 0, psum
= 0;
270 int is_increasing
= 0;
274 for (i
= 0; i
< nb_sensors
; i
++) {
275 if (xy_sensors
[i
] < threshold
) {
283 * Makes the finger detection more versatile. For example,
284 * two fingers with no gap will be detected. Also, my
285 * tests show it less likely to have intermittent loss
286 * of multiple finger readings while moving around (scrolling).
288 * Changes the multiple finger detection to counting humps on
289 * sensors (transitions from nonincreasing to increasing)
290 * instead of counting transitions from low sensors (no
291 * finger reading) to high sensors (finger above
294 * - Jason Parekh <jasonparekh@gmail.com>
297 (!is_increasing
&& xy_sensors
[i
- 1] < xy_sensors
[i
])) {
300 } else if (i
> 0 && xy_sensors
[i
- 1] >= xy_sensors
[i
]) {
305 * Subtracts threshold so a high sensor that just passes the
306 * threshold won't skew the calculated absolute coordinate.
307 * Fixes an issue where slowly moving the mouse would
308 * occasionally jump a number of pixels (slowly moving the
309 * finger makes this issue most apparent.)
311 pcum
+= (xy_sensors
[i
] - threshold
) * i
;
312 psum
+= (xy_sensors
[i
] - threshold
);
317 return pcum
* fact
/ psum
;
323 static inline void atp_report_fingers(struct input_dev
*input
, int fingers
)
325 input_report_key(input
, BTN_TOOL_FINGER
, fingers
== 1);
326 input_report_key(input
, BTN_TOOL_DOUBLETAP
, fingers
== 2);
327 input_report_key(input
, BTN_TOOL_TRIPLETAP
, fingers
> 2);
330 static void atp_complete(struct urb
*urb
)
332 int x
, y
, x_z
, y_z
, x_f
, y_f
;
335 struct atp
*dev
= urb
->context
;
337 switch (urb
->status
) {
342 if (!dev
->overflow_warned
) {
343 printk(KERN_WARNING
"appletouch: OVERFLOW with data "
344 "length %d, actual length is %d\n",
345 dev
->datalen
, dev
->urb
->actual_length
);
346 dev
->overflow_warned
= true;
351 /* This urb is terminated, clean up */
352 dbg("atp_complete: urb shutting down with status: %d",
356 dbg("atp_complete: nonzero urb status received: %d",
361 /* drop incomplete datasets */
362 if (dev
->urb
->actual_length
!= dev
->datalen
) {
363 dprintk("appletouch: incomplete data package"
364 " (first byte: %d, length: %d).\n",
365 dev
->data
[0], dev
->urb
->actual_length
);
369 /* reorder the sensors values */
370 if (dev
->type
== ATP_GEYSER3
|| dev
->type
== ATP_GEYSER4
) {
371 memset(dev
->xy_cur
, 0, sizeof(dev
->xy_cur
));
374 * The values are laid out like this:
375 * -, Y1, Y2, -, Y3, Y4, -, ..., -, X1, X2, -, X3, X4, ...
376 * '-' is an unused value.
380 for (i
= 0, j
= 19; i
< 20; i
+= 2, j
+= 3) {
381 dev
->xy_cur
[i
] = dev
->data
[j
+ 1];
382 dev
->xy_cur
[i
+ 1] = dev
->data
[j
+ 2];
385 for (i
= 0, j
= 1; i
< 9; i
+= 2, j
+= 3) {
386 dev
->xy_cur
[ATP_XSENSORS
+ i
] = dev
->data
[j
+ 1];
387 dev
->xy_cur
[ATP_XSENSORS
+ i
+ 1] = dev
->data
[j
+ 2];
389 } else if (dev
->type
== ATP_GEYSER2
) {
390 memset(dev
->xy_cur
, 0, sizeof(dev
->xy_cur
));
393 * The values are laid out like this:
394 * Y1, Y2, -, Y3, Y4, -, ..., X1, X2, -, X3, X4, -, ...
395 * '-' is an unused value.
399 for (i
= 0, j
= 19; i
< 20; i
+= 2, j
+= 3) {
400 dev
->xy_cur
[i
] = dev
->data
[j
];
401 dev
->xy_cur
[i
+ 1] = dev
->data
[j
+ 1];
405 for (i
= 0, j
= 1; i
< 9; i
+= 2, j
+= 3) {
406 dev
->xy_cur
[ATP_XSENSORS
+ i
] = dev
->data
[j
];
407 dev
->xy_cur
[ATP_XSENSORS
+ i
+ 1] = dev
->data
[j
+ 1];
410 for (i
= 0; i
< 8; i
++) {
412 dev
->xy_cur
[i
+ 0] = dev
->data
[5 * i
+ 2];
413 dev
->xy_cur
[i
+ 8] = dev
->data
[5 * i
+ 4];
414 dev
->xy_cur
[i
+ 16] = dev
->data
[5 * i
+ 42];
416 dev
->xy_cur
[i
+ 24] = dev
->data
[5 * i
+ 44];
419 dev
->xy_cur
[i
+ 26] = dev
->data
[5 * i
+ 1];
420 dev
->xy_cur
[i
+ 34] = dev
->data
[5 * i
+ 3];
424 dbg_dump("sample", dev
->xy_cur
);
429 dev
->x_old
= dev
->y_old
= -1;
430 memcpy(dev
->xy_old
, dev
->xy_cur
, sizeof(dev
->xy_old
));
432 if (dev
->size_detect_done
||
433 dev
->type
== ATP_GEYSER3
) /* No 17" Macbooks (yet) */
436 /* 17" Powerbooks have extra X sensors */
437 for (i
= (dev
->type
== ATP_GEYSER2
? 15 : 16);
438 i
< ATP_XSENSORS
; i
++) {
442 printk(KERN_INFO
"appletouch: 17\" model detected.\n");
443 if (dev
->type
== ATP_GEYSER2
)
444 input_set_abs_params(dev
->input
, ABS_X
, 0,
449 input_set_abs_params(dev
->input
, ABS_X
, 0,
456 dev
->size_detect_done
= 1;
460 for (i
= 0; i
< ATP_XSENSORS
+ ATP_YSENSORS
; i
++) {
461 /* accumulate the change */
462 signed char change
= dev
->xy_old
[i
] - dev
->xy_cur
[i
];
463 dev
->xy_acc
[i
] -= change
;
465 /* prevent down drifting */
466 if (dev
->xy_acc
[i
] < 0)
470 memcpy(dev
->xy_old
, dev
->xy_cur
, sizeof(dev
->xy_old
));
472 dbg_dump("accumulator", dev
->xy_acc
);
474 x
= atp_calculate_abs(dev
->xy_acc
, ATP_XSENSORS
,
475 ATP_XFACT
, &x_z
, &x_f
);
476 y
= atp_calculate_abs(dev
->xy_acc
+ ATP_XSENSORS
, ATP_YSENSORS
,
477 ATP_YFACT
, &y_z
, &y_f
);
478 key
= dev
->data
[dev
->datalen
- 1] & 1;
481 if (dev
->x_old
!= -1) {
482 x
= (dev
->x_old
* 3 + x
) >> 2;
483 y
= (dev
->y_old
* 3 + y
) >> 2;
488 printk(KERN_DEBUG
"appletouch: X: %3d Y: %3d "
492 input_report_key(dev
->input
, BTN_TOUCH
, 1);
493 input_report_abs(dev
->input
, ABS_X
, x
);
494 input_report_abs(dev
->input
, ABS_Y
, y
);
495 input_report_abs(dev
->input
, ABS_PRESSURE
,
496 min(ATP_PRESSURE
, x_z
+ y_z
));
497 atp_report_fingers(dev
->input
, max(x_f
, y_f
));
502 } else if (!x
&& !y
) {
504 dev
->x_old
= dev
->y_old
= -1;
505 input_report_key(dev
->input
, BTN_TOUCH
, 0);
506 input_report_abs(dev
->input
, ABS_PRESSURE
, 0);
507 atp_report_fingers(dev
->input
, 0);
509 /* reset the accumulator on release */
510 memset(dev
->xy_acc
, 0, sizeof(dev
->xy_acc
));
513 input_report_key(dev
->input
, BTN_LEFT
, key
);
514 input_sync(dev
->input
);
517 * Many Geysers will continue to send packets continually after
518 * the first touch unless reinitialised. Do so if it's been
519 * idle for a while in order to avoid waking the kernel up
520 * several hundred times a second. Re-initialization does not
521 * work on Fountain touchpads.
523 if (dev
->type
!= ATP_FOUNTAIN
) {
525 * Button must not be pressed when entering suspend,
526 * otherwise we will never release the button.
528 if (!x
&& !y
&& !key
) {
530 if (dev
->idlecount
== 10) {
532 schedule_work(&dev
->work
);
533 /* Don't resubmit urb here, wait for reinit */
541 retval
= usb_submit_urb(dev
->urb
, GFP_ATOMIC
);
543 err("atp_complete: usb_submit_urb failed with result %d",
547 static int atp_open(struct input_dev
*input
)
549 struct atp
*dev
= input_get_drvdata(input
);
551 if (usb_submit_urb(dev
->urb
, GFP_ATOMIC
))
558 static void atp_close(struct input_dev
*input
)
560 struct atp
*dev
= input_get_drvdata(input
);
562 usb_kill_urb(dev
->urb
);
563 cancel_work_sync(&dev
->work
);
567 static int atp_handle_geyser(struct atp
*dev
)
569 struct usb_device
*udev
= dev
->udev
;
571 if (dev
->type
!= ATP_FOUNTAIN
) {
572 /* switch to raw sensor mode */
573 if (atp_geyser_init(udev
))
576 printk(KERN_INFO
"appletouch: Geyser mode initialized.\n");
582 static int atp_probe(struct usb_interface
*iface
,
583 const struct usb_device_id
*id
)
586 struct input_dev
*input_dev
;
587 struct usb_device
*udev
= interface_to_usbdev(iface
);
588 struct usb_host_interface
*iface_desc
;
589 struct usb_endpoint_descriptor
*endpoint
;
590 int int_in_endpointAddr
= 0;
591 int i
, error
= -ENOMEM
;
593 /* set up the endpoint information */
594 /* use only the first interrupt-in endpoint */
595 iface_desc
= iface
->cur_altsetting
;
596 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; i
++) {
597 endpoint
= &iface_desc
->endpoint
[i
].desc
;
598 if (!int_in_endpointAddr
&& usb_endpoint_is_int_in(endpoint
)) {
599 /* we found an interrupt in endpoint */
600 int_in_endpointAddr
= endpoint
->bEndpointAddress
;
604 if (!int_in_endpointAddr
) {
605 err("Could not find int-in endpoint");
609 /* allocate memory for our device state and initialize it */
610 dev
= kzalloc(sizeof(struct atp
), GFP_KERNEL
);
611 input_dev
= input_allocate_device();
612 if (!dev
|| !input_dev
) {
613 err("Out of memory");
618 dev
->input
= input_dev
;
619 dev
->type
= id
->driver_info
;
620 dev
->overflow_warned
= false;
621 if (dev
->type
== ATP_FOUNTAIN
|| dev
->type
== ATP_GEYSER1
)
626 dev
->urb
= usb_alloc_urb(0, GFP_KERNEL
);
630 dev
->data
= usb_buffer_alloc(dev
->udev
, dev
->datalen
, GFP_KERNEL
,
631 &dev
->urb
->transfer_dma
);
635 usb_fill_int_urb(dev
->urb
, udev
,
636 usb_rcvintpipe(udev
, int_in_endpointAddr
),
637 dev
->data
, dev
->datalen
, atp_complete
, dev
, 1);
639 error
= atp_handle_geyser(dev
);
641 goto err_free_buffer
;
643 usb_make_path(udev
, dev
->phys
, sizeof(dev
->phys
));
644 strlcat(dev
->phys
, "/input0", sizeof(dev
->phys
));
646 input_dev
->name
= "appletouch";
647 input_dev
->phys
= dev
->phys
;
648 usb_to_input_id(dev
->udev
, &input_dev
->id
);
649 input_dev
->dev
.parent
= &iface
->dev
;
651 input_set_drvdata(input_dev
, dev
);
653 input_dev
->open
= atp_open
;
654 input_dev
->close
= atp_close
;
656 set_bit(EV_ABS
, input_dev
->evbit
);
658 if (dev
->type
== ATP_GEYSER3
|| dev
->type
== ATP_GEYSER4
) {
660 * MacBook have 20 X sensors, 10 Y sensors
662 input_set_abs_params(input_dev
, ABS_X
, 0,
663 ((20 - 1) * ATP_XFACT
) - 1, ATP_FUZZ
, 0);
664 input_set_abs_params(input_dev
, ABS_Y
, 0,
665 ((10 - 1) * ATP_YFACT
) - 1, ATP_FUZZ
, 0);
666 } else if (dev
->type
== ATP_GEYSER2
) {
668 * Oct 2005 15" PowerBooks have 15 X sensors, 17" are detected
671 input_set_abs_params(input_dev
, ABS_X
, 0,
672 ((15 - 1) * ATP_XFACT
) - 1, ATP_FUZZ
, 0);
673 input_set_abs_params(input_dev
, ABS_Y
, 0,
674 ((9 - 1) * ATP_YFACT
) - 1, ATP_FUZZ
, 0);
677 * 12" and 15" Powerbooks only have 16 x sensors,
678 * 17" models are detected later.
680 input_set_abs_params(input_dev
, ABS_X
, 0,
681 (16 - 1) * ATP_XFACT
- 1,
683 input_set_abs_params(input_dev
, ABS_Y
, 0,
684 (ATP_YSENSORS
- 1) * ATP_YFACT
- 1,
687 input_set_abs_params(input_dev
, ABS_PRESSURE
, 0, ATP_PRESSURE
, 0, 0);
689 set_bit(EV_KEY
, input_dev
->evbit
);
690 set_bit(BTN_TOUCH
, input_dev
->keybit
);
691 set_bit(BTN_TOOL_FINGER
, input_dev
->keybit
);
692 set_bit(BTN_TOOL_DOUBLETAP
, input_dev
->keybit
);
693 set_bit(BTN_TOOL_TRIPLETAP
, input_dev
->keybit
);
694 set_bit(BTN_LEFT
, input_dev
->keybit
);
696 error
= input_register_device(dev
->input
);
698 goto err_free_buffer
;
700 /* save our data pointer in this interface device */
701 usb_set_intfdata(iface
, dev
);
703 INIT_WORK(&dev
->work
, atp_reinit
);
708 usb_buffer_free(dev
->udev
, dev
->datalen
,
709 dev
->data
, dev
->urb
->transfer_dma
);
711 usb_free_urb(dev
->urb
);
713 usb_set_intfdata(iface
, NULL
);
715 input_free_device(input_dev
);
719 static void atp_disconnect(struct usb_interface
*iface
)
721 struct atp
*dev
= usb_get_intfdata(iface
);
723 usb_set_intfdata(iface
, NULL
);
725 usb_kill_urb(dev
->urb
);
726 input_unregister_device(dev
->input
);
727 usb_buffer_free(dev
->udev
, dev
->datalen
,
728 dev
->data
, dev
->urb
->transfer_dma
);
729 usb_free_urb(dev
->urb
);
732 printk(KERN_INFO
"input: appletouch disconnected\n");
735 static int atp_recover(struct atp
*dev
)
739 error
= atp_handle_geyser(dev
);
743 if (dev
->open
&& usb_submit_urb(dev
->urb
, GFP_ATOMIC
))
749 static int atp_suspend(struct usb_interface
*iface
, pm_message_t message
)
751 struct atp
*dev
= usb_get_intfdata(iface
);
753 usb_kill_urb(dev
->urb
);
759 static int atp_resume(struct usb_interface
*iface
)
761 struct atp
*dev
= usb_get_intfdata(iface
);
763 if (dev
->open
&& usb_submit_urb(dev
->urb
, GFP_ATOMIC
))
769 static int atp_reset_resume(struct usb_interface
*iface
)
771 struct atp
*dev
= usb_get_intfdata(iface
);
773 return atp_recover(dev
);
776 static struct usb_driver atp_driver
= {
777 .name
= "appletouch",
779 .disconnect
= atp_disconnect
,
780 .suspend
= atp_suspend
,
781 .resume
= atp_resume
,
782 .reset_resume
= atp_reset_resume
,
783 .id_table
= atp_table
,
786 static int __init
atp_init(void)
788 return usb_register(&atp_driver
);
791 static void __exit
atp_exit(void)
793 usb_deregister(&atp_driver
);
796 module_init(atp_init
);
797 module_exit(atp_exit
);