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
140 * enum atp_status_bits - status bit meanings
142 * These constants represent the meaning of the status bits.
145 * @ATP_STATUS_BUTTON: The button was pressed
146 * @ATP_STATUS_BASE_UPDATE: Update of the base values (untouched pad)
147 * @ATP_STATUS_FROM_RESET: Reset previously performed
149 enum atp_status_bits
{
150 ATP_STATUS_BUTTON
= BIT(0),
151 ATP_STATUS_BASE_UPDATE
= BIT(2),
152 ATP_STATUS_FROM_RESET
= BIT(4),
155 /* Structure to hold all of our device specific stuff */
158 struct usb_device
*udev
; /* usb device */
159 struct urb
*urb
; /* usb request block */
160 u8
*data
; /* transferred data */
161 struct input_dev
*input
; /* input dev */
162 enum atp_touchpad_type type
; /* type of touchpad */
164 bool valid
; /* are the samples valid? */
165 bool size_detect_done
;
166 bool overflow_warned
;
167 int x_old
; /* last reported x/y, */
168 int y_old
; /* used for smoothing */
169 signed char xy_cur
[ATP_XSENSORS
+ ATP_YSENSORS
];
170 signed char xy_old
[ATP_XSENSORS
+ ATP_YSENSORS
];
171 int xy_acc
[ATP_XSENSORS
+ ATP_YSENSORS
];
172 int datalen
; /* size of USB transfer */
173 int idlecount
; /* number of empty packets */
174 struct work_struct work
;
177 #define dbg_dump(msg, tab) \
180 printk(KERN_DEBUG "appletouch: %s", msg); \
181 for (__i = 0; __i < ATP_XSENSORS + ATP_YSENSORS; __i++) \
182 printk(" %02x", tab[__i]); \
186 #define dprintk(format, a...) \
189 printk(KERN_DEBUG format, ##a); \
192 MODULE_AUTHOR("Johannes Berg");
193 MODULE_AUTHOR("Stelian Pop");
194 MODULE_AUTHOR("Frank Arnold");
195 MODULE_AUTHOR("Michael Hanselmann");
196 MODULE_AUTHOR("Sven Anders");
197 MODULE_DESCRIPTION("Apple PowerBook and MacBook USB touchpad driver");
198 MODULE_LICENSE("GPL");
201 * Make the threshold a module parameter
203 static int threshold
= ATP_THRESHOLD
;
204 module_param(threshold
, int, 0644);
205 MODULE_PARM_DESC(threshold
, "Discard any change in data from a sensor"
206 " (the trackpad has many of these sensors)"
207 " less than this value.");
210 module_param(debug
, int, 0644);
211 MODULE_PARM_DESC(debug
, "Activate debugging output");
214 * By default newer Geyser devices send 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_geyser_init(struct usb_device
*udev
)
224 size
= usb_control_msg(udev
, usb_rcvctrlpipe(udev
, 0),
225 ATP_GEYSER_MODE_READ_REQUEST_ID
,
226 USB_DIR_IN
| USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
227 ATP_GEYSER_MODE_REQUEST_VALUE
,
228 ATP_GEYSER_MODE_REQUEST_INDEX
, &data
, 8, 5000);
231 dprintk("atp_geyser_init: read error\n");
232 for (i
= 0; i
< 8; i
++)
233 dprintk("appletouch[%d]: %d\n", i
, data
[i
]);
235 err("Failed to read mode from device.");
239 /* Apply the mode switch */
240 data
[0] = ATP_GEYSER_MODE_VENDOR_VALUE
;
242 size
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0),
243 ATP_GEYSER_MODE_WRITE_REQUEST_ID
,
244 USB_DIR_OUT
| USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
245 ATP_GEYSER_MODE_REQUEST_VALUE
,
246 ATP_GEYSER_MODE_REQUEST_INDEX
, &data
, 8, 5000);
249 dprintk("atp_geyser_init: write error\n");
250 for (i
= 0; i
< 8; i
++)
251 dprintk("appletouch[%d]: %d\n", i
, data
[i
]);
253 err("Failed to request geyser raw mode");
260 * Reinitialise the device. This usually stops stream of empty packets
263 static void atp_reinit(struct work_struct
*work
)
265 struct atp
*dev
= container_of(work
, struct atp
, work
);
266 struct usb_device
*udev
= dev
->udev
;
269 dprintk("appletouch: putting appletouch to sleep (reinit)\n");
270 atp_geyser_init(udev
);
272 retval
= usb_submit_urb(dev
->urb
, GFP_ATOMIC
);
274 err("atp_reinit: usb_submit_urb failed with error %d",
278 static int atp_calculate_abs(int *xy_sensors
, int nb_sensors
, int fact
,
279 int *z
, int *fingers
)
282 /* values to calculate mean */
283 int pcum
= 0, psum
= 0;
284 int is_increasing
= 0;
288 for (i
= 0; i
< nb_sensors
; i
++) {
289 if (xy_sensors
[i
] < threshold
) {
297 * Makes the finger detection more versatile. For example,
298 * two fingers with no gap will be detected. Also, my
299 * tests show it less likely to have intermittent loss
300 * of multiple finger readings while moving around (scrolling).
302 * Changes the multiple finger detection to counting humps on
303 * sensors (transitions from nonincreasing to increasing)
304 * instead of counting transitions from low sensors (no
305 * finger reading) to high sensors (finger above
308 * - Jason Parekh <jasonparekh@gmail.com>
311 (!is_increasing
&& xy_sensors
[i
- 1] < xy_sensors
[i
])) {
314 } else if (i
> 0 && xy_sensors
[i
- 1] >= xy_sensors
[i
]) {
319 * Subtracts threshold so a high sensor that just passes the
320 * threshold won't skew the calculated absolute coordinate.
321 * Fixes an issue where slowly moving the mouse would
322 * occasionally jump a number of pixels (slowly moving the
323 * finger makes this issue most apparent.)
325 pcum
+= (xy_sensors
[i
] - threshold
) * i
;
326 psum
+= (xy_sensors
[i
] - threshold
);
331 return pcum
* fact
/ psum
;
337 static inline void atp_report_fingers(struct input_dev
*input
, int fingers
)
339 input_report_key(input
, BTN_TOOL_FINGER
, fingers
== 1);
340 input_report_key(input
, BTN_TOOL_DOUBLETAP
, fingers
== 2);
341 input_report_key(input
, BTN_TOOL_TRIPLETAP
, fingers
> 2);
344 /* Check URB status and for correct length of data package */
346 #define ATP_URB_STATUS_SUCCESS 0
347 #define ATP_URB_STATUS_ERROR 1
348 #define ATP_URB_STATUS_ERROR_FATAL 2
350 static int atp_status_check(struct urb
*urb
)
352 struct atp
*dev
= urb
->context
;
354 switch (urb
->status
) {
359 if (!dev
->overflow_warned
) {
360 printk(KERN_WARNING
"appletouch: OVERFLOW with data "
361 "length %d, actual length is %d\n",
362 dev
->datalen
, dev
->urb
->actual_length
);
363 dev
->overflow_warned
= true;
368 /* This urb is terminated, clean up */
369 dbg("atp_complete: urb shutting down with status: %d",
371 return ATP_URB_STATUS_ERROR_FATAL
;
374 dbg("atp_complete: nonzero urb status received: %d",
376 return ATP_URB_STATUS_ERROR
;
379 /* drop incomplete datasets */
380 if (dev
->urb
->actual_length
!= dev
->datalen
) {
381 dprintk("appletouch: incomplete data package"
382 " (first byte: %d, length: %d).\n",
383 dev
->data
[0], dev
->urb
->actual_length
);
384 return ATP_URB_STATUS_ERROR
;
387 return ATP_URB_STATUS_SUCCESS
;
391 * USB interrupt callback functions
394 /* Interrupt function for older touchpads: FOUNTAIN/GEYSER1/GEYSER2 */
396 static void atp_complete_geyser_1_2(struct urb
*urb
)
398 int x
, y
, x_z
, y_z
, x_f
, y_f
;
401 struct atp
*dev
= urb
->context
;
402 int status
= atp_status_check(urb
);
404 if (status
== ATP_URB_STATUS_ERROR_FATAL
)
406 else if (status
== ATP_URB_STATUS_ERROR
)
409 /* reorder the sensors values */
410 if (dev
->type
== ATP_GEYSER2
) {
411 memset(dev
->xy_cur
, 0, sizeof(dev
->xy_cur
));
414 * The values are laid out like this:
415 * Y1, Y2, -, Y3, Y4, -, ..., X1, X2, -, X3, X4, -, ...
416 * '-' is an unused value.
420 for (i
= 0, j
= 19; i
< 20; i
+= 2, j
+= 3) {
421 dev
->xy_cur
[i
] = dev
->data
[j
];
422 dev
->xy_cur
[i
+ 1] = dev
->data
[j
+ 1];
426 for (i
= 0, j
= 1; i
< 9; i
+= 2, j
+= 3) {
427 dev
->xy_cur
[ATP_XSENSORS
+ i
] = dev
->data
[j
];
428 dev
->xy_cur
[ATP_XSENSORS
+ i
+ 1] = dev
->data
[j
+ 1];
431 for (i
= 0; i
< 8; i
++) {
433 dev
->xy_cur
[i
+ 0] = dev
->data
[5 * i
+ 2];
434 dev
->xy_cur
[i
+ 8] = dev
->data
[5 * i
+ 4];
435 dev
->xy_cur
[i
+ 16] = dev
->data
[5 * i
+ 42];
437 dev
->xy_cur
[i
+ 24] = dev
->data
[5 * i
+ 44];
440 dev
->xy_cur
[i
+ 26] = dev
->data
[5 * i
+ 1];
441 dev
->xy_cur
[i
+ 34] = dev
->data
[5 * i
+ 3];
445 dbg_dump("sample", dev
->xy_cur
);
450 dev
->x_old
= dev
->y_old
= -1;
452 /* Store first sample */
453 memcpy(dev
->xy_old
, dev
->xy_cur
, sizeof(dev
->xy_old
));
455 /* Perform size detection, if not done already */
456 if (!dev
->size_detect_done
) {
458 /* 17" Powerbooks have extra X sensors */
459 for (i
= (dev
->type
== ATP_GEYSER2
? 15 : 16);
460 i
< ATP_XSENSORS
; i
++) {
465 "appletouch: 17\" model detected.\n");
467 if (dev
->type
== ATP_GEYSER2
)
468 input_set_abs_params(dev
->input
, ABS_X
,
474 input_set_abs_params(dev
->input
, ABS_X
,
482 dev
->size_detect_done
= 1;
487 for (i
= 0; i
< ATP_XSENSORS
+ ATP_YSENSORS
; i
++) {
488 /* accumulate the change */
489 signed char change
= dev
->xy_old
[i
] - dev
->xy_cur
[i
];
490 dev
->xy_acc
[i
] -= change
;
492 /* prevent down drifting */
493 if (dev
->xy_acc
[i
] < 0)
497 memcpy(dev
->xy_old
, dev
->xy_cur
, sizeof(dev
->xy_old
));
499 dbg_dump("accumulator", dev
->xy_acc
);
501 x
= atp_calculate_abs(dev
->xy_acc
, ATP_XSENSORS
,
502 ATP_XFACT
, &x_z
, &x_f
);
503 y
= atp_calculate_abs(dev
->xy_acc
+ ATP_XSENSORS
, ATP_YSENSORS
,
504 ATP_YFACT
, &y_z
, &y_f
);
505 key
= dev
->data
[dev
->datalen
- 1] & ATP_STATUS_BUTTON
;
508 if (dev
->x_old
!= -1) {
509 x
= (dev
->x_old
* 3 + x
) >> 2;
510 y
= (dev
->y_old
* 3 + y
) >> 2;
515 printk(KERN_DEBUG
"appletouch: "
516 "X: %3d Y: %3d Xz: %3d Yz: %3d\n",
519 input_report_key(dev
->input
, BTN_TOUCH
, 1);
520 input_report_abs(dev
->input
, ABS_X
, x
);
521 input_report_abs(dev
->input
, ABS_Y
, y
);
522 input_report_abs(dev
->input
, ABS_PRESSURE
,
523 min(ATP_PRESSURE
, x_z
+ y_z
));
524 atp_report_fingers(dev
->input
, max(x_f
, y_f
));
529 } else if (!x
&& !y
) {
531 dev
->x_old
= dev
->y_old
= -1;
532 input_report_key(dev
->input
, BTN_TOUCH
, 0);
533 input_report_abs(dev
->input
, ABS_PRESSURE
, 0);
534 atp_report_fingers(dev
->input
, 0);
536 /* reset the accumulator on release */
537 memset(dev
->xy_acc
, 0, sizeof(dev
->xy_acc
));
540 input_report_key(dev
->input
, BTN_LEFT
, key
);
541 input_sync(dev
->input
);
544 retval
= usb_submit_urb(dev
->urb
, GFP_ATOMIC
);
546 err("atp_complete: usb_submit_urb failed with result %d",
550 /* Interrupt function for older touchpads: GEYSER3/GEYSER4 */
552 static void atp_complete_geyser_3_4(struct urb
*urb
)
554 int x
, y
, x_z
, y_z
, x_f
, y_f
;
557 struct atp
*dev
= urb
->context
;
558 int status
= atp_status_check(urb
);
560 if (status
== ATP_URB_STATUS_ERROR_FATAL
)
562 else if (status
== ATP_URB_STATUS_ERROR
)
565 /* Reorder the sensors values:
567 * The values are laid out like this:
568 * -, Y1, Y2, -, Y3, Y4, -, ..., -, X1, X2, -, X3, X4, ...
569 * '-' is an unused value.
573 for (i
= 0, j
= 19; i
< 20; i
+= 2, j
+= 3) {
574 dev
->xy_cur
[i
] = dev
->data
[j
+ 1];
575 dev
->xy_cur
[i
+ 1] = dev
->data
[j
+ 2];
578 for (i
= 0, j
= 1; i
< 9; i
+= 2, j
+= 3) {
579 dev
->xy_cur
[ATP_XSENSORS
+ i
] = dev
->data
[j
+ 1];
580 dev
->xy_cur
[ATP_XSENSORS
+ i
+ 1] = dev
->data
[j
+ 2];
583 dbg_dump("sample", dev
->xy_cur
);
585 /* Just update the base values (i.e. touchpad in untouched state) */
586 if (dev
->data
[dev
->datalen
- 1] & ATP_STATUS_BASE_UPDATE
) {
588 dprintk(KERN_DEBUG
"appletouch: updated base values\n");
590 memcpy(dev
->xy_old
, dev
->xy_cur
, sizeof(dev
->xy_old
));
594 for (i
= 0; i
< ATP_XSENSORS
+ ATP_YSENSORS
; i
++) {
595 /* calculate the change */
596 dev
->xy_acc
[i
] = dev
->xy_cur
[i
] - dev
->xy_old
[i
];
598 /* this is a round-robin value, so couple with that */
599 if (dev
->xy_acc
[i
] > 127)
600 dev
->xy_acc
[i
] -= 256;
602 if (dev
->xy_acc
[i
] < -127)
603 dev
->xy_acc
[i
] += 256;
605 /* prevent down drifting */
606 if (dev
->xy_acc
[i
] < 0)
610 dbg_dump("accumulator", dev
->xy_acc
);
612 x
= atp_calculate_abs(dev
->xy_acc
, ATP_XSENSORS
,
613 ATP_XFACT
, &x_z
, &x_f
);
614 y
= atp_calculate_abs(dev
->xy_acc
+ ATP_XSENSORS
, ATP_YSENSORS
,
615 ATP_YFACT
, &y_z
, &y_f
);
616 key
= dev
->data
[dev
->datalen
- 1] & ATP_STATUS_BUTTON
;
619 if (dev
->x_old
!= -1) {
620 x
= (dev
->x_old
* 3 + x
) >> 2;
621 y
= (dev
->y_old
* 3 + y
) >> 2;
626 printk(KERN_DEBUG
"appletouch: X: %3d Y: %3d "
630 input_report_key(dev
->input
, BTN_TOUCH
, 1);
631 input_report_abs(dev
->input
, ABS_X
, x
);
632 input_report_abs(dev
->input
, ABS_Y
, y
);
633 input_report_abs(dev
->input
, ABS_PRESSURE
,
634 min(ATP_PRESSURE
, x_z
+ y_z
));
635 atp_report_fingers(dev
->input
, max(x_f
, y_f
));
640 } else if (!x
&& !y
) {
642 dev
->x_old
= dev
->y_old
= -1;
643 input_report_key(dev
->input
, BTN_TOUCH
, 0);
644 input_report_abs(dev
->input
, ABS_PRESSURE
, 0);
645 atp_report_fingers(dev
->input
, 0);
647 /* reset the accumulator on release */
648 memset(dev
->xy_acc
, 0, sizeof(dev
->xy_acc
));
651 input_report_key(dev
->input
, BTN_LEFT
, key
);
652 input_sync(dev
->input
);
655 * Geysers 3/4 will continue to send packets continually after
656 * the first touch unless reinitialised. Do so if it's been
657 * idle for a while in order to avoid waking the kernel up
658 * several hundred times a second.
662 * Button must not be pressed when entering suspend,
663 * otherwise we will never release the button.
665 if (!x
&& !y
&& !key
) {
667 if (dev
->idlecount
== 10) {
668 dev
->x_old
= dev
->y_old
= -1;
670 schedule_work(&dev
->work
);
671 /* Don't resubmit urb here, wait for reinit */
678 retval
= usb_submit_urb(dev
->urb
, GFP_ATOMIC
);
680 err("atp_complete: usb_submit_urb failed with result %d",
684 static int atp_open(struct input_dev
*input
)
686 struct atp
*dev
= input_get_drvdata(input
);
688 if (usb_submit_urb(dev
->urb
, GFP_ATOMIC
))
695 static void atp_close(struct input_dev
*input
)
697 struct atp
*dev
= input_get_drvdata(input
);
699 usb_kill_urb(dev
->urb
);
700 cancel_work_sync(&dev
->work
);
704 static int atp_handle_geyser(struct atp
*dev
)
706 struct usb_device
*udev
= dev
->udev
;
708 if (dev
->type
!= ATP_FOUNTAIN
) {
709 /* switch to raw sensor mode */
710 if (atp_geyser_init(udev
))
713 printk(KERN_INFO
"appletouch: Geyser mode initialized.\n");
719 static int atp_probe(struct usb_interface
*iface
,
720 const struct usb_device_id
*id
)
723 struct input_dev
*input_dev
;
724 struct usb_device
*udev
= interface_to_usbdev(iface
);
725 struct usb_host_interface
*iface_desc
;
726 struct usb_endpoint_descriptor
*endpoint
;
727 int int_in_endpointAddr
= 0;
728 int i
, error
= -ENOMEM
;
730 /* set up the endpoint information */
731 /* use only the first interrupt-in endpoint */
732 iface_desc
= iface
->cur_altsetting
;
733 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; i
++) {
734 endpoint
= &iface_desc
->endpoint
[i
].desc
;
735 if (!int_in_endpointAddr
&& usb_endpoint_is_int_in(endpoint
)) {
736 /* we found an interrupt in endpoint */
737 int_in_endpointAddr
= endpoint
->bEndpointAddress
;
741 if (!int_in_endpointAddr
) {
742 err("Could not find int-in endpoint");
746 /* allocate memory for our device state and initialize it */
747 dev
= kzalloc(sizeof(struct atp
), GFP_KERNEL
);
748 input_dev
= input_allocate_device();
749 if (!dev
|| !input_dev
) {
750 err("Out of memory");
755 dev
->input
= input_dev
;
756 dev
->type
= id
->driver_info
;
757 dev
->overflow_warned
= false;
758 if (dev
->type
== ATP_FOUNTAIN
|| dev
->type
== ATP_GEYSER1
)
763 dev
->urb
= usb_alloc_urb(0, GFP_KERNEL
);
767 dev
->data
= usb_buffer_alloc(dev
->udev
, dev
->datalen
, GFP_KERNEL
,
768 &dev
->urb
->transfer_dma
);
772 /* Select the USB complete (callback) function */
773 if (dev
->type
== ATP_FOUNTAIN
||
774 dev
->type
== ATP_GEYSER1
||
775 dev
->type
== ATP_GEYSER2
)
776 usb_fill_int_urb(dev
->urb
, udev
,
777 usb_rcvintpipe(udev
, int_in_endpointAddr
),
778 dev
->data
, dev
->datalen
,
779 atp_complete_geyser_1_2
, dev
, 1);
781 usb_fill_int_urb(dev
->urb
, udev
,
782 usb_rcvintpipe(udev
, int_in_endpointAddr
),
783 dev
->data
, dev
->datalen
,
784 atp_complete_geyser_3_4
, dev
, 1);
786 error
= atp_handle_geyser(dev
);
788 goto err_free_buffer
;
790 usb_make_path(udev
, dev
->phys
, sizeof(dev
->phys
));
791 strlcat(dev
->phys
, "/input0", sizeof(dev
->phys
));
793 input_dev
->name
= "appletouch";
794 input_dev
->phys
= dev
->phys
;
795 usb_to_input_id(dev
->udev
, &input_dev
->id
);
796 input_dev
->dev
.parent
= &iface
->dev
;
798 input_set_drvdata(input_dev
, dev
);
800 input_dev
->open
= atp_open
;
801 input_dev
->close
= atp_close
;
803 set_bit(EV_ABS
, input_dev
->evbit
);
805 if (dev
->type
== ATP_GEYSER3
|| dev
->type
== ATP_GEYSER4
) {
807 * MacBook have 20 X sensors, 10 Y sensors
809 input_set_abs_params(input_dev
, ABS_X
, 0,
810 ((20 - 1) * ATP_XFACT
) - 1, ATP_FUZZ
, 0);
811 input_set_abs_params(input_dev
, ABS_Y
, 0,
812 ((10 - 1) * ATP_YFACT
) - 1, ATP_FUZZ
, 0);
813 } else if (dev
->type
== ATP_GEYSER2
) {
815 * Oct 2005 15" PowerBooks have 15 X sensors, 17" are detected
818 input_set_abs_params(input_dev
, ABS_X
, 0,
819 ((15 - 1) * ATP_XFACT
) - 1, ATP_FUZZ
, 0);
820 input_set_abs_params(input_dev
, ABS_Y
, 0,
821 ((9 - 1) * ATP_YFACT
) - 1, ATP_FUZZ
, 0);
824 * 12" and 15" Powerbooks only have 16 x sensors,
825 * 17" models are detected later.
827 input_set_abs_params(input_dev
, ABS_X
, 0,
828 (16 - 1) * ATP_XFACT
- 1,
830 input_set_abs_params(input_dev
, ABS_Y
, 0,
831 (ATP_YSENSORS
- 1) * ATP_YFACT
- 1,
834 input_set_abs_params(input_dev
, ABS_PRESSURE
, 0, ATP_PRESSURE
, 0, 0);
836 set_bit(EV_KEY
, input_dev
->evbit
);
837 set_bit(BTN_TOUCH
, input_dev
->keybit
);
838 set_bit(BTN_TOOL_FINGER
, input_dev
->keybit
);
839 set_bit(BTN_TOOL_DOUBLETAP
, input_dev
->keybit
);
840 set_bit(BTN_TOOL_TRIPLETAP
, input_dev
->keybit
);
841 set_bit(BTN_LEFT
, input_dev
->keybit
);
843 error
= input_register_device(dev
->input
);
845 goto err_free_buffer
;
847 /* save our data pointer in this interface device */
848 usb_set_intfdata(iface
, dev
);
850 INIT_WORK(&dev
->work
, atp_reinit
);
855 usb_buffer_free(dev
->udev
, dev
->datalen
,
856 dev
->data
, dev
->urb
->transfer_dma
);
858 usb_free_urb(dev
->urb
);
860 usb_set_intfdata(iface
, NULL
);
862 input_free_device(input_dev
);
866 static void atp_disconnect(struct usb_interface
*iface
)
868 struct atp
*dev
= usb_get_intfdata(iface
);
870 usb_set_intfdata(iface
, NULL
);
872 usb_kill_urb(dev
->urb
);
873 input_unregister_device(dev
->input
);
874 usb_buffer_free(dev
->udev
, dev
->datalen
,
875 dev
->data
, dev
->urb
->transfer_dma
);
876 usb_free_urb(dev
->urb
);
879 printk(KERN_INFO
"input: appletouch disconnected\n");
882 static int atp_recover(struct atp
*dev
)
886 error
= atp_handle_geyser(dev
);
890 if (dev
->open
&& usb_submit_urb(dev
->urb
, GFP_ATOMIC
))
896 static int atp_suspend(struct usb_interface
*iface
, pm_message_t message
)
898 struct atp
*dev
= usb_get_intfdata(iface
);
900 usb_kill_urb(dev
->urb
);
904 static int atp_resume(struct usb_interface
*iface
)
906 struct atp
*dev
= usb_get_intfdata(iface
);
908 if (dev
->open
&& usb_submit_urb(dev
->urb
, GFP_ATOMIC
))
914 static int atp_reset_resume(struct usb_interface
*iface
)
916 struct atp
*dev
= usb_get_intfdata(iface
);
918 return atp_recover(dev
);
921 static struct usb_driver atp_driver
= {
922 .name
= "appletouch",
924 .disconnect
= atp_disconnect
,
925 .suspend
= atp_suspend
,
926 .resume
= atp_resume
,
927 .reset_resume
= atp_reset_resume
,
928 .id_table
= atp_table
,
931 static int __init
atp_init(void)
933 return usb_register(&atp_driver
);
936 static void __exit
atp_exit(void)
938 usb_deregister(&atp_driver
);
941 module_init(atp_init
);
942 module_exit(atp_exit
);