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 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)
12 * Thanks to Alex Harper <basilisk@foobox.net> for his inputs.
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.
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.
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.
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>
37 /* Apple has powerbooks which have the keyboard with different Product IDs */
38 #define APPLE_VENDOR_ID 0x05AC
40 /* These names come from Info.plist in AppleUSBTrackpad.kext */
41 #define FOUNTAIN_ANSI_PRODUCT_ID 0x020E
42 #define FOUNTAIN_ISO_PRODUCT_ID 0x020F
44 #define FOUNTAIN_TP_ONLY_PRODUCT_ID 0x030A
46 #define GEYSER1_TP_ONLY_PRODUCT_ID 0x030B
48 #define GEYSER_ANSI_PRODUCT_ID 0x0214
49 #define GEYSER_ISO_PRODUCT_ID 0x0215
50 #define GEYSER_JIS_PRODUCT_ID 0x0216
53 #define GEYSER3_ANSI_PRODUCT_ID 0x0217
54 #define GEYSER3_ISO_PRODUCT_ID 0x0218
55 #define GEYSER3_JIS_PRODUCT_ID 0x0219
58 * Geyser IV: same as Geyser III according to Info.plist in AppleUSBTrackpad.kext
59 * -> same IOClass (AppleUSBGrIIITrackpad), same acceleration tables
61 #define GEYSER4_ANSI_PRODUCT_ID 0x021A
62 #define GEYSER4_ISO_PRODUCT_ID 0x021B
63 #define GEYSER4_JIS_PRODUCT_ID 0x021C
65 #define ATP_DEVICE(prod) \
66 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
67 USB_DEVICE_ID_MATCH_INT_CLASS | \
68 USB_DEVICE_ID_MATCH_INT_PROTOCOL, \
69 .idVendor = APPLE_VENDOR_ID, \
70 .idProduct = (prod), \
71 .bInterfaceClass = 0x03, \
72 .bInterfaceProtocol = 0x02
74 /* table of devices that work with this driver */
75 static struct usb_device_id atp_table
[] = {
76 { ATP_DEVICE(FOUNTAIN_ANSI_PRODUCT_ID
) },
77 { ATP_DEVICE(FOUNTAIN_ISO_PRODUCT_ID
) },
78 { ATP_DEVICE(FOUNTAIN_TP_ONLY_PRODUCT_ID
) },
79 { ATP_DEVICE(GEYSER1_TP_ONLY_PRODUCT_ID
) },
81 /* PowerBooks Oct 2005 */
82 { ATP_DEVICE(GEYSER_ANSI_PRODUCT_ID
) },
83 { ATP_DEVICE(GEYSER_ISO_PRODUCT_ID
) },
84 { ATP_DEVICE(GEYSER_JIS_PRODUCT_ID
) },
86 /* Core Duo MacBook & MacBook Pro */
87 { ATP_DEVICE(GEYSER3_ANSI_PRODUCT_ID
) },
88 { ATP_DEVICE(GEYSER3_ISO_PRODUCT_ID
) },
89 { ATP_DEVICE(GEYSER3_JIS_PRODUCT_ID
) },
91 /* Core2 Duo MacBook & MacBook Pro */
92 { ATP_DEVICE(GEYSER4_ANSI_PRODUCT_ID
) },
93 { ATP_DEVICE(GEYSER4_ISO_PRODUCT_ID
) },
94 { ATP_DEVICE(GEYSER4_JIS_PRODUCT_ID
) },
96 /* Terminating entry */
99 MODULE_DEVICE_TABLE (usb
, atp_table
);
102 * number of sensors. Note that only 16 instead of 26 X (horizontal)
103 * sensors exist on 12" and 15" PowerBooks. All models have 16 Y
104 * (vertical) sensors.
106 #define ATP_XSENSORS 26
107 #define ATP_YSENSORS 16
109 /* amount of fuzz this touchpad generates */
112 /* maximum pressure this driver will report */
113 #define ATP_PRESSURE 300
115 * multiplication factor for the X and Y coordinates.
116 * We try to keep the touchpad aspect ratio while still doing only simple
118 * The factors below give coordinates like:
119 * 0 <= x < 960 on 12" and 15" Powerbooks
120 * 0 <= x < 1600 on 17" Powerbooks
127 * Threshold for the touchpad sensors. Any change less than ATP_THRESHOLD is
130 #define ATP_THRESHOLD 5
132 /* MacBook Pro (Geyser 3 & 4) initialization constants */
133 #define ATP_GEYSER3_MODE_READ_REQUEST_ID 1
134 #define ATP_GEYSER3_MODE_WRITE_REQUEST_ID 9
135 #define ATP_GEYSER3_MODE_REQUEST_VALUE 0x300
136 #define ATP_GEYSER3_MODE_REQUEST_INDEX 0
137 #define ATP_GEYSER3_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 int open
; /* non-zero if opened */
146 struct input_dev
*input
; /* input dev */
147 int valid
; /* are the sensors valid ? */
148 int x_old
; /* last reported x/y, */
149 int y_old
; /* used for smoothing */
150 /* current value of the sensors */
151 signed char xy_cur
[ATP_XSENSORS
+ ATP_YSENSORS
];
152 /* last value of the sensors */
153 signed char xy_old
[ATP_XSENSORS
+ ATP_YSENSORS
];
154 /* accumulated sensors */
155 int xy_acc
[ATP_XSENSORS
+ ATP_YSENSORS
];
156 int overflowwarn
; /* overflow warning printed? */
157 int datalen
; /* size of an USB urb transfer */
158 int idlecount
; /* number of empty packets */
159 struct work_struct work
;
162 #define dbg_dump(msg, tab) \
165 printk("appletouch: %s %lld", msg, (long long)jiffies); \
166 for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) \
167 printk(" %02x", tab[i]); \
171 #define dprintk(format, a...) \
173 if (debug) printk(format, ##a); \
176 MODULE_AUTHOR("Johannes Berg, Stelian Pop, Frank Arnold, Michael Hanselmann");
177 MODULE_DESCRIPTION("Apple PowerBooks USB touchpad driver");
178 MODULE_LICENSE("GPL");
181 * Make the threshold a module parameter
183 static int threshold
= ATP_THRESHOLD
;
184 module_param(threshold
, int, 0644);
185 MODULE_PARM_DESC(threshold
, "Discards any change in data from a sensor (trackpad has hundreds of these sensors) less than this value");
187 static int debug
= 1;
188 module_param(debug
, int, 0644);
189 MODULE_PARM_DESC(debug
, "Activate debugging output");
191 /* Checks if the device a Geyser 2 (ANSI, ISO, JIS) */
192 static inline int atp_is_geyser_2(struct atp
*dev
)
194 u16 productId
= le16_to_cpu(dev
->udev
->descriptor
.idProduct
);
196 return (productId
== GEYSER_ANSI_PRODUCT_ID
) ||
197 (productId
== GEYSER_ISO_PRODUCT_ID
) ||
198 (productId
== GEYSER_JIS_PRODUCT_ID
);
201 static inline int atp_is_geyser_3(struct atp
*dev
)
203 u16 productId
= le16_to_cpu(dev
->udev
->descriptor
.idProduct
);
205 return (productId
== GEYSER3_ANSI_PRODUCT_ID
) ||
206 (productId
== GEYSER3_ISO_PRODUCT_ID
) ||
207 (productId
== GEYSER3_JIS_PRODUCT_ID
) ||
208 (productId
== GEYSER4_ANSI_PRODUCT_ID
) ||
209 (productId
== GEYSER4_ISO_PRODUCT_ID
) ||
210 (productId
== GEYSER4_JIS_PRODUCT_ID
);
214 * By default Geyser 3 device sends standard USB HID mouse
215 * packets (Report ID 2). This code changes device mode, so it
216 * sends raw sensor reports (Report ID 5).
218 static int atp_geyser3_init(struct usb_device
*udev
)
223 size
= usb_control_msg(udev
, usb_rcvctrlpipe(udev
, 0),
224 ATP_GEYSER3_MODE_READ_REQUEST_ID
,
225 USB_DIR_IN
| USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
226 ATP_GEYSER3_MODE_REQUEST_VALUE
,
227 ATP_GEYSER3_MODE_REQUEST_INDEX
, &data
, 8, 5000);
230 err("Could not do mode read request from device"
235 /* Apply the mode switch */
236 data
[0] = ATP_GEYSER3_MODE_VENDOR_VALUE
;
238 size
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0),
239 ATP_GEYSER3_MODE_WRITE_REQUEST_ID
,
240 USB_DIR_OUT
| USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
241 ATP_GEYSER3_MODE_REQUEST_VALUE
,
242 ATP_GEYSER3_MODE_REQUEST_INDEX
, &data
, 8, 5000);
245 err("Could not do mode write request to device"
252 /* Reinitialise the device if it's a geyser 3 */
253 static void atp_reinit(struct work_struct
*work
)
255 struct atp
*dev
= container_of(work
, struct atp
, work
);
256 struct usb_device
*udev
= dev
->udev
;
259 atp_geyser3_init(udev
);
262 static int atp_calculate_abs(int *xy_sensors
, int nb_sensors
, int fact
,
263 int *z
, int *fingers
)
266 /* values to calculate mean */
267 int pcum
= 0, psum
= 0;
268 int is_increasing
= 0;
272 for (i
= 0; i
< nb_sensors
; i
++) {
273 if (xy_sensors
[i
] < threshold
) {
281 * Makes the finger detection more versatile. For example,
282 * two fingers with no gap will be detected. Also, my
283 * tests show it less likely to have intermittent loss
284 * of multiple finger readings while moving around (scrolling).
286 * Changes the multiple finger detection to counting humps on
287 * sensors (transitions from nonincreasing to increasing)
288 * instead of counting transitions from low sensors (no
289 * finger reading) to high sensors (finger above
292 * - Jason Parekh <jasonparekh@gmail.com>
294 if (i
< 1 || (!is_increasing
&& xy_sensors
[i
- 1] < xy_sensors
[i
])) {
297 } else if (i
> 0 && xy_sensors
[i
- 1] >= xy_sensors
[i
]) {
302 * Subtracts threshold so a high sensor that just passes the threshold
303 * won't skew the calculated absolute coordinate. Fixes an issue
304 * where slowly moving the mouse would occassionaly jump a number of
305 * pixels (let me restate--slowly moving the mouse makes this issue
308 pcum
+= (xy_sensors
[i
] - threshold
) * i
;
309 psum
+= (xy_sensors
[i
] - threshold
);
314 return pcum
* fact
/ psum
;
320 static inline void atp_report_fingers(struct input_dev
*input
, int fingers
)
322 input_report_key(input
, BTN_TOOL_FINGER
, fingers
== 1);
323 input_report_key(input
, BTN_TOOL_DOUBLETAP
, fingers
== 2);
324 input_report_key(input
, BTN_TOOL_TRIPLETAP
, fingers
> 2);
327 static void atp_complete(struct urb
* urb
)
329 int x
, y
, x_z
, y_z
, x_f
, y_f
;
332 struct atp
*dev
= urb
->context
;
334 switch (urb
->status
) {
339 if(!dev
->overflowwarn
) {
340 printk("appletouch: OVERFLOW with data "
341 "length %d, actual length is %d\n",
342 dev
->datalen
, dev
->urb
->actual_length
);
343 dev
->overflowwarn
= 1;
348 /* This urb is terminated, clean up */
349 dbg("%s - urb shutting down with status: %d",
350 __FUNCTION__
, urb
->status
);
353 dbg("%s - nonzero urb status received: %d",
354 __FUNCTION__
, urb
->status
);
358 /* drop incomplete datasets */
359 if (dev
->urb
->actual_length
!= dev
->datalen
) {
360 dprintk("appletouch: incomplete data package"
361 " (first byte: %d, length: %d).\n",
362 dev
->data
[0], dev
->urb
->actual_length
);
366 /* reorder the sensors values */
367 if (atp_is_geyser_3(dev
)) {
368 memset(dev
->xy_cur
, 0, sizeof(dev
->xy_cur
));
371 * The values are laid out like this:
372 * -, Y1, Y2, -, Y3, Y4, -, ..., -, X1, X2, -, X3, X4, ...
373 * '-' is an unused value.
377 for (i
= 0, j
= 19; i
< 20; i
+= 2, j
+= 3) {
378 dev
->xy_cur
[i
] = dev
->data
[j
+ 1];
379 dev
->xy_cur
[i
+ 1] = dev
->data
[j
+ 2];
382 for (i
= 0, j
= 1; i
< 9; i
+= 2, j
+= 3) {
383 dev
->xy_cur
[ATP_XSENSORS
+ i
] = dev
->data
[j
+ 1];
384 dev
->xy_cur
[ATP_XSENSORS
+ i
+ 1] = dev
->data
[j
+ 2];
386 } else if (atp_is_geyser_2(dev
)) {
387 memset(dev
->xy_cur
, 0, sizeof(dev
->xy_cur
));
390 * The values are laid out like this:
391 * Y1, Y2, -, Y3, Y4, -, ..., X1, X2, -, X3, X4, -, ...
392 * '-' is an unused value.
396 for (i
= 0, j
= 19; i
< 20; i
+= 2, j
+= 3) {
397 dev
->xy_cur
[i
] = dev
->data
[j
];
398 dev
->xy_cur
[i
+ 1] = dev
->data
[j
+ 1];
402 for (i
= 0, j
= 1; i
< 9; i
+= 2, j
+= 3) {
403 dev
->xy_cur
[ATP_XSENSORS
+ i
] = dev
->data
[j
];
404 dev
->xy_cur
[ATP_XSENSORS
+ i
+ 1] = dev
->data
[j
+ 1];
407 for (i
= 0; i
< 8; i
++) {
409 dev
->xy_cur
[i
] = dev
->data
[5 * i
+ 2];
410 dev
->xy_cur
[i
+ 8] = dev
->data
[5 * i
+ 4];
411 dev
->xy_cur
[i
+ 16] = dev
->data
[5 * i
+ 42];
413 dev
->xy_cur
[i
+ 24] = dev
->data
[5 * i
+ 44];
416 dev
->xy_cur
[i
+ 26] = dev
->data
[5 * i
+ 1];
417 dev
->xy_cur
[i
+ 34] = dev
->data
[5 * i
+ 3];
421 dbg_dump("sample", dev
->xy_cur
);
426 dev
->x_old
= dev
->y_old
= -1;
427 memcpy(dev
->xy_old
, dev
->xy_cur
, sizeof(dev
->xy_old
));
429 if (atp_is_geyser_3(dev
)) /* No 17" Macbooks (yet) */
432 /* 17" Powerbooks have extra X sensors */
433 for (i
= (atp_is_geyser_2(dev
)?15:16); i
< ATP_XSENSORS
; i
++) {
434 if (!dev
->xy_cur
[i
]) continue;
436 printk("appletouch: 17\" model detected.\n");
437 if(atp_is_geyser_2(dev
))
438 input_set_abs_params(dev
->input
, ABS_X
, 0,
443 input_set_abs_params(dev
->input
, ABS_X
, 0,
454 for (i
= 0; i
< ATP_XSENSORS
+ ATP_YSENSORS
; i
++) {
455 /* accumulate the change */
456 signed char change
= dev
->xy_old
[i
] - dev
->xy_cur
[i
];
457 dev
->xy_acc
[i
] -= change
;
459 /* prevent down drifting */
460 if (dev
->xy_acc
[i
] < 0)
464 memcpy(dev
->xy_old
, dev
->xy_cur
, sizeof(dev
->xy_old
));
466 dbg_dump("accumulator", dev
->xy_acc
);
468 x
= atp_calculate_abs(dev
->xy_acc
, ATP_XSENSORS
,
469 ATP_XFACT
, &x_z
, &x_f
);
470 y
= atp_calculate_abs(dev
->xy_acc
+ ATP_XSENSORS
, ATP_YSENSORS
,
471 ATP_YFACT
, &y_z
, &y_f
);
472 key
= dev
->data
[dev
->datalen
- 1] & 1;
475 if (dev
->x_old
!= -1) {
476 x
= (dev
->x_old
* 3 + x
) >> 2;
477 y
= (dev
->y_old
* 3 + y
) >> 2;
482 printk("appletouch: X: %3d Y: %3d "
486 input_report_key(dev
->input
, BTN_TOUCH
, 1);
487 input_report_abs(dev
->input
, ABS_X
, x
);
488 input_report_abs(dev
->input
, ABS_Y
, y
);
489 input_report_abs(dev
->input
, ABS_PRESSURE
,
490 min(ATP_PRESSURE
, x_z
+ y_z
));
491 atp_report_fingers(dev
->input
, max(x_f
, y_f
));
496 } else if (!x
&& !y
) {
498 dev
->x_old
= dev
->y_old
= -1;
499 input_report_key(dev
->input
, BTN_TOUCH
, 0);
500 input_report_abs(dev
->input
, ABS_PRESSURE
, 0);
501 atp_report_fingers(dev
->input
, 0);
503 /* reset the accumulator on release */
504 memset(dev
->xy_acc
, 0, sizeof(dev
->xy_acc
));
507 input_report_key(dev
->input
, BTN_LEFT
, key
);
508 input_sync(dev
->input
);
510 /* Many Geysers will continue to send packets continually after
511 the first touch unless reinitialised. Do so if it's been
512 idle for a while in order to avoid waking the kernel up
513 several hundred times a second */
515 if (!x
&& !y
&& !key
) {
517 if (dev
->idlecount
== 10) {
519 schedule_work(&dev
->work
);
525 retval
= usb_submit_urb(dev
->urb
, GFP_ATOMIC
);
527 err("%s - usb_submit_urb failed with result %d",
528 __FUNCTION__
, retval
);
532 static int atp_open(struct input_dev
*input
)
534 struct atp
*dev
= input_get_drvdata(input
);
536 if (usb_submit_urb(dev
->urb
, GFP_ATOMIC
))
543 static void atp_close(struct input_dev
*input
)
545 struct atp
*dev
= input_get_drvdata(input
);
547 usb_kill_urb(dev
->urb
);
548 cancel_work_sync(&dev
->work
);
552 static int atp_probe(struct usb_interface
*iface
, const struct usb_device_id
*id
)
555 struct input_dev
*input_dev
;
556 struct usb_device
*udev
= interface_to_usbdev(iface
);
557 struct usb_host_interface
*iface_desc
;
558 struct usb_endpoint_descriptor
*endpoint
;
559 int int_in_endpointAddr
= 0;
560 int i
, error
= -ENOMEM
;
562 /* set up the endpoint information */
563 /* use only the first interrupt-in endpoint */
564 iface_desc
= iface
->cur_altsetting
;
565 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; i
++) {
566 endpoint
= &iface_desc
->endpoint
[i
].desc
;
567 if (!int_in_endpointAddr
&& usb_endpoint_is_int_in(endpoint
)) {
568 /* we found an interrupt in endpoint */
569 int_in_endpointAddr
= endpoint
->bEndpointAddress
;
573 if (!int_in_endpointAddr
) {
574 err("Could not find int-in endpoint");
578 /* allocate memory for our device state and initialize it */
579 dev
= kzalloc(sizeof(struct atp
), GFP_KERNEL
);
580 input_dev
= input_allocate_device();
581 if (!dev
|| !input_dev
) {
582 err("Out of memory");
587 dev
->input
= input_dev
;
588 dev
->overflowwarn
= 0;
589 if (atp_is_geyser_3(dev
))
591 else if (atp_is_geyser_2(dev
))
596 if (atp_is_geyser_3(dev
)) {
597 /* switch to raw sensor mode */
598 if (atp_geyser3_init(udev
))
601 printk("appletouch Geyser 3 inited.\n");
604 dev
->urb
= usb_alloc_urb(0, GFP_KERNEL
);
608 dev
->data
= usb_buffer_alloc(dev
->udev
, dev
->datalen
, GFP_KERNEL
,
609 &dev
->urb
->transfer_dma
);
613 usb_fill_int_urb(dev
->urb
, udev
,
614 usb_rcvintpipe(udev
, int_in_endpointAddr
),
615 dev
->data
, dev
->datalen
, atp_complete
, dev
, 1);
617 usb_make_path(udev
, dev
->phys
, sizeof(dev
->phys
));
618 strlcat(dev
->phys
, "/input0", sizeof(dev
->phys
));
620 input_dev
->name
= "appletouch";
621 input_dev
->phys
= dev
->phys
;
622 usb_to_input_id(dev
->udev
, &input_dev
->id
);
623 input_dev
->dev
.parent
= &iface
->dev
;
625 input_set_drvdata(input_dev
, dev
);
627 input_dev
->open
= atp_open
;
628 input_dev
->close
= atp_close
;
630 set_bit(EV_ABS
, input_dev
->evbit
);
632 if (atp_is_geyser_3(dev
)) {
634 * MacBook have 20 X sensors, 10 Y sensors
636 input_set_abs_params(input_dev
, ABS_X
, 0,
637 ((20 - 1) * ATP_XFACT
) - 1, ATP_FUZZ
, 0);
638 input_set_abs_params(input_dev
, ABS_Y
, 0,
639 ((10 - 1) * ATP_YFACT
) - 1, ATP_FUZZ
, 0);
640 } else if (atp_is_geyser_2(dev
)) {
642 * Oct 2005 15" PowerBooks have 15 X sensors, 17" are detected
645 input_set_abs_params(input_dev
, ABS_X
, 0,
646 ((15 - 1) * ATP_XFACT
) - 1, ATP_FUZZ
, 0);
647 input_set_abs_params(input_dev
, ABS_Y
, 0,
648 ((9 - 1) * ATP_YFACT
) - 1, ATP_FUZZ
, 0);
651 * 12" and 15" Powerbooks only have 16 x sensors,
652 * 17" models are detected later.
654 input_set_abs_params(input_dev
, ABS_X
, 0,
655 (16 - 1) * ATP_XFACT
- 1, ATP_FUZZ
, 0);
656 input_set_abs_params(input_dev
, ABS_Y
, 0,
657 (ATP_YSENSORS
- 1) * ATP_YFACT
- 1, ATP_FUZZ
, 0);
659 input_set_abs_params(input_dev
, ABS_PRESSURE
, 0, ATP_PRESSURE
, 0, 0);
661 set_bit(EV_KEY
, input_dev
->evbit
);
662 set_bit(BTN_TOUCH
, input_dev
->keybit
);
663 set_bit(BTN_TOOL_FINGER
, input_dev
->keybit
);
664 set_bit(BTN_TOOL_DOUBLETAP
, input_dev
->keybit
);
665 set_bit(BTN_TOOL_TRIPLETAP
, input_dev
->keybit
);
666 set_bit(BTN_LEFT
, input_dev
->keybit
);
668 error
= input_register_device(dev
->input
);
670 goto err_free_buffer
;
672 /* save our data pointer in this interface device */
673 usb_set_intfdata(iface
, dev
);
675 INIT_WORK(&dev
->work
, atp_reinit
);
680 usb_buffer_free(dev
->udev
, dev
->datalen
,
681 dev
->data
, dev
->urb
->transfer_dma
);
683 usb_free_urb(dev
->urb
);
685 usb_set_intfdata(iface
, NULL
);
687 input_free_device(input_dev
);
691 static void atp_disconnect(struct usb_interface
*iface
)
693 struct atp
*dev
= usb_get_intfdata(iface
);
695 usb_set_intfdata(iface
, NULL
);
697 usb_kill_urb(dev
->urb
);
698 input_unregister_device(dev
->input
);
699 usb_buffer_free(dev
->udev
, dev
->datalen
,
700 dev
->data
, dev
->urb
->transfer_dma
);
701 usb_free_urb(dev
->urb
);
704 printk(KERN_INFO
"input: appletouch disconnected\n");
707 static int atp_suspend(struct usb_interface
*iface
, pm_message_t message
)
709 struct atp
*dev
= usb_get_intfdata(iface
);
711 usb_kill_urb(dev
->urb
);
717 static int atp_resume(struct usb_interface
*iface
)
719 struct atp
*dev
= usb_get_intfdata(iface
);
721 if (dev
->open
&& usb_submit_urb(dev
->urb
, GFP_ATOMIC
))
727 static struct usb_driver atp_driver
= {
728 .name
= "appletouch",
730 .disconnect
= atp_disconnect
,
731 .suspend
= atp_suspend
,
732 .resume
= atp_resume
,
733 .id_table
= atp_table
,
736 static int __init
atp_init(void)
738 return usb_register(&atp_driver
);
741 static void __exit
atp_exit(void)
743 usb_deregister(&atp_driver
);
746 module_init(atp_init
);
747 module_exit(atp_exit
);