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-2008 Stelian Pop (stelian@popies.net)
7 * Copyright (C) 2005 Frank Arnold (frank@scirocco-5v-turbo.de)
8 * Copyright (C) 2005 Peter Osterlund (petero2@telia.com)
9 * Copyright (C) 2005 Michael Hanselmann (linux-kernel@hansmi.ch)
10 * Copyright (C) 2006 Nicolas Boichat (nicolas@boichat.ch)
11 * Copyright (C) 2007-2008 Sven Anders (anders@anduras.de)
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/slab.h>
34 #include <linux/module.h>
35 #include <linux/usb/input.h>
38 * Note: We try to keep the touchpad aspect ratio while still doing only
40 * 0 <= x <= (xsensors - 1) * xfact
41 * 0 <= y <= (ysensors - 1) * yfact
44 int xsensors
; /* number of X sensors */
45 int xsensors_17
; /* 17" models have more sensors */
46 int ysensors
; /* number of Y sensors */
47 int xfact
; /* X multiplication factor */
48 int yfact
; /* Y multiplication factor */
49 int datalen
; /* size of USB transfers */
50 void (*callback
)(struct urb
*); /* callback function */
51 int fuzz
; /* fuzz touchpad generates */
54 static void atp_complete_geyser_1_2(struct urb
*urb
);
55 static void atp_complete_geyser_3_4(struct urb
*urb
);
57 static const struct atp_info fountain_info
= {
64 .callback
= atp_complete_geyser_1_2
,
68 static const struct atp_info geyser1_info
= {
75 .callback
= atp_complete_geyser_1_2
,
79 static const struct atp_info geyser2_info
= {
86 .callback
= atp_complete_geyser_1_2
,
90 static const struct atp_info geyser3_info
= {
96 .callback
= atp_complete_geyser_3_4
,
100 static const struct atp_info geyser4_info
= {
106 .callback
= atp_complete_geyser_3_4
,
110 #define ATP_DEVICE(prod, info) \
112 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
113 USB_DEVICE_ID_MATCH_INT_CLASS | \
114 USB_DEVICE_ID_MATCH_INT_PROTOCOL, \
115 .idVendor = 0x05ac, /* Apple */ \
116 .idProduct = (prod), \
117 .bInterfaceClass = 0x03, \
118 .bInterfaceProtocol = 0x02, \
119 .driver_info = (unsigned long) &info, \
123 * Table of devices (Product IDs) that work with this driver.
124 * (The names come from Info.plist in AppleUSBTrackpad.kext,
125 * According to Info.plist Geyser IV is the same as Geyser III.)
128 static struct usb_device_id atp_table
[] = {
129 /* PowerBooks Feb 2005, iBooks G4 */
130 ATP_DEVICE(0x020e, fountain_info
), /* FOUNTAIN ANSI */
131 ATP_DEVICE(0x020f, fountain_info
), /* FOUNTAIN ISO */
132 ATP_DEVICE(0x030a, fountain_info
), /* FOUNTAIN TP ONLY */
133 ATP_DEVICE(0x030b, geyser1_info
), /* GEYSER 1 TP ONLY */
135 /* PowerBooks Oct 2005 */
136 ATP_DEVICE(0x0214, geyser2_info
), /* GEYSER 2 ANSI */
137 ATP_DEVICE(0x0215, geyser2_info
), /* GEYSER 2 ISO */
138 ATP_DEVICE(0x0216, geyser2_info
), /* GEYSER 2 JIS */
140 /* Core Duo MacBook & MacBook Pro */
141 ATP_DEVICE(0x0217, geyser3_info
), /* GEYSER 3 ANSI */
142 ATP_DEVICE(0x0218, geyser3_info
), /* GEYSER 3 ISO */
143 ATP_DEVICE(0x0219, geyser3_info
), /* GEYSER 3 JIS */
145 /* Core2 Duo MacBook & MacBook Pro */
146 ATP_DEVICE(0x021a, geyser4_info
), /* GEYSER 4 ANSI */
147 ATP_DEVICE(0x021b, geyser4_info
), /* GEYSER 4 ISO */
148 ATP_DEVICE(0x021c, geyser4_info
), /* GEYSER 4 JIS */
150 /* Core2 Duo MacBook3,1 */
151 ATP_DEVICE(0x0229, geyser4_info
), /* GEYSER 4 HF ANSI */
152 ATP_DEVICE(0x022a, geyser4_info
), /* GEYSER 4 HF ISO */
153 ATP_DEVICE(0x022b, geyser4_info
), /* GEYSER 4 HF JIS */
155 /* Terminating entry */
158 MODULE_DEVICE_TABLE(usb
, atp_table
);
160 /* maximum number of sensors */
161 #define ATP_XSENSORS 26
162 #define ATP_YSENSORS 16
165 * The largest possible bank of sensors with additional buffer of 4 extra values
166 * on either side, for an array of smoothed sensor values.
168 #define ATP_SMOOTHSIZE 34
170 /* maximum pressure this driver will report */
171 #define ATP_PRESSURE 300
174 * Threshold for the touchpad sensors. Any change less than ATP_THRESHOLD is
177 #define ATP_THRESHOLD 5
180 * How far we'll bitshift our sensor values before averaging them. Mitigates
185 /* Geyser initialization constants */
186 #define ATP_GEYSER_MODE_READ_REQUEST_ID 1
187 #define ATP_GEYSER_MODE_WRITE_REQUEST_ID 9
188 #define ATP_GEYSER_MODE_REQUEST_VALUE 0x300
189 #define ATP_GEYSER_MODE_REQUEST_INDEX 0
190 #define ATP_GEYSER_MODE_VENDOR_VALUE 0x04
193 * enum atp_status_bits - status bit meanings
195 * These constants represent the meaning of the status bits.
198 * @ATP_STATUS_BUTTON: The button was pressed
199 * @ATP_STATUS_BASE_UPDATE: Update of the base values (untouched pad)
200 * @ATP_STATUS_FROM_RESET: Reset previously performed
202 enum atp_status_bits
{
203 ATP_STATUS_BUTTON
= BIT(0),
204 ATP_STATUS_BASE_UPDATE
= BIT(2),
205 ATP_STATUS_FROM_RESET
= BIT(4),
208 /* Structure to hold all of our device specific stuff */
211 struct usb_device
*udev
; /* usb device */
212 struct usb_interface
*intf
; /* usb interface */
213 struct urb
*urb
; /* usb request block */
214 u8
*data
; /* transferred data */
215 struct input_dev
*input
; /* input dev */
216 const struct atp_info
*info
; /* touchpad model */
218 bool valid
; /* are the samples valid? */
219 bool size_detect_done
;
220 bool overflow_warned
;
221 int fingers_old
; /* last reported finger count */
222 int x_old
; /* last reported x/y, */
223 int y_old
; /* used for smoothing */
224 signed char xy_cur
[ATP_XSENSORS
+ ATP_YSENSORS
];
225 signed char xy_old
[ATP_XSENSORS
+ ATP_YSENSORS
];
226 int xy_acc
[ATP_XSENSORS
+ ATP_YSENSORS
];
227 int smooth
[ATP_SMOOTHSIZE
];
228 int smooth_tmp
[ATP_SMOOTHSIZE
];
229 int idlecount
; /* number of empty packets */
230 struct work_struct work
;
233 #define dbg_dump(msg, tab) \
236 printk(KERN_DEBUG "appletouch: %s", msg); \
237 for (__i = 0; __i < ATP_XSENSORS + ATP_YSENSORS; __i++) \
238 printk(" %02x", tab[__i]); \
242 #define dprintk(format, a...) \
245 printk(KERN_DEBUG format, ##a); \
248 MODULE_AUTHOR("Johannes Berg");
249 MODULE_AUTHOR("Stelian Pop");
250 MODULE_AUTHOR("Frank Arnold");
251 MODULE_AUTHOR("Michael Hanselmann");
252 MODULE_AUTHOR("Sven Anders");
253 MODULE_DESCRIPTION("Apple PowerBook and MacBook USB touchpad driver");
254 MODULE_LICENSE("GPL");
257 * Make the threshold a module parameter
259 static int threshold
= ATP_THRESHOLD
;
260 module_param(threshold
, int, 0644);
261 MODULE_PARM_DESC(threshold
, "Discard any change in data from a sensor"
262 " (the trackpad has many of these sensors)"
263 " less than this value.");
266 module_param(debug
, int, 0644);
267 MODULE_PARM_DESC(debug
, "Activate debugging output");
270 * By default newer Geyser devices send standard USB HID mouse
271 * packets (Report ID 2). This code changes device mode, so it
272 * sends raw sensor reports (Report ID 5).
274 static int atp_geyser_init(struct atp
*dev
)
276 struct usb_device
*udev
= dev
->udev
;
282 data
= kmalloc(8, GFP_KERNEL
);
284 dev_err(&dev
->intf
->dev
, "Out of memory\n");
288 size
= usb_control_msg(udev
, usb_rcvctrlpipe(udev
, 0),
289 ATP_GEYSER_MODE_READ_REQUEST_ID
,
290 USB_DIR_IN
| USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
291 ATP_GEYSER_MODE_REQUEST_VALUE
,
292 ATP_GEYSER_MODE_REQUEST_INDEX
, data
, 8, 5000);
295 dprintk("atp_geyser_init: read error\n");
296 for (i
= 0; i
< 8; i
++)
297 dprintk("appletouch[%d]: %d\n", i
, data
[i
]);
299 dev_err(&dev
->intf
->dev
, "Failed to read mode from device.\n");
304 /* Apply the mode switch */
305 data
[0] = ATP_GEYSER_MODE_VENDOR_VALUE
;
307 size
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0),
308 ATP_GEYSER_MODE_WRITE_REQUEST_ID
,
309 USB_DIR_OUT
| USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
310 ATP_GEYSER_MODE_REQUEST_VALUE
,
311 ATP_GEYSER_MODE_REQUEST_INDEX
, data
, 8, 5000);
314 dprintk("atp_geyser_init: write error\n");
315 for (i
= 0; i
< 8; i
++)
316 dprintk("appletouch[%d]: %d\n", i
, data
[i
]);
318 dev_err(&dev
->intf
->dev
, "Failed to request geyser raw mode\n");
329 * Reinitialise the device. This usually stops stream of empty packets
332 static void atp_reinit(struct work_struct
*work
)
334 struct atp
*dev
= container_of(work
, struct atp
, work
);
337 dprintk("appletouch: putting appletouch to sleep (reinit)\n");
338 atp_geyser_init(dev
);
340 retval
= usb_submit_urb(dev
->urb
, GFP_ATOMIC
);
342 dev_err(&dev
->intf
->dev
,
343 "atp_reinit: usb_submit_urb failed with error %d\n",
347 static int atp_calculate_abs(struct atp
*dev
, int offset
, int nb_sensors
,
348 int fact
, int *z
, int *fingers
)
353 * Use offset to point xy_sensors at the first value in dev->xy_acc
354 * for whichever dimension we're looking at this particular go-round.
356 int *xy_sensors
= dev
->xy_acc
+ offset
;
358 /* values to calculate mean */
359 int pcum
= 0, psum
= 0;
360 int is_increasing
= 0;
364 for (i
= 0; i
< nb_sensors
; i
++) {
365 if (xy_sensors
[i
] < threshold
) {
370 * Makes the finger detection more versatile. For example,
371 * two fingers with no gap will be detected. Also, my
372 * tests show it less likely to have intermittent loss
373 * of multiple finger readings while moving around (scrolling).
375 * Changes the multiple finger detection to counting humps on
376 * sensors (transitions from nonincreasing to increasing)
377 * instead of counting transitions from low sensors (no
378 * finger reading) to high sensors (finger above
381 * - Jason Parekh <jasonparekh@gmail.com>
385 (!is_increasing
&& xy_sensors
[i
- 1] < xy_sensors
[i
])) {
388 } else if (i
> 0 && (xy_sensors
[i
- 1] - xy_sensors
[i
] > threshold
)) {
393 if (*fingers
< 1) /* No need to continue if no fingers are found. */
397 * Use a smoothed version of sensor data for movement calculations, to
398 * combat noise without needing to rely so heavily on a threshold.
399 * This improves tracking.
401 * The smoothed array is bigger than the original so that the smoothing
402 * doesn't result in edge values being truncated.
405 memset(dev
->smooth
, 0, 4 * sizeof(dev
->smooth
[0]));
406 /* Pull base values, scaled up to help avoid truncation errors. */
407 for (i
= 0; i
< nb_sensors
; i
++)
408 dev
->smooth
[i
+ 4] = xy_sensors
[i
] << ATP_SCALE
;
409 memset(&dev
->smooth
[nb_sensors
+ 4], 0, 4 * sizeof(dev
->smooth
[0]));
411 for (pass
= 0; pass
< 4; pass
++) {
413 dev
->smooth_tmp
[0] = (dev
->smooth
[0] + dev
->smooth
[1]) / 2;
415 /* Average values with neighbors. */
416 for (i
= 1; i
< nb_sensors
+ 7; i
++)
417 dev
->smooth_tmp
[i
] = (dev
->smooth
[i
- 1] +
419 dev
->smooth
[i
+ 1]) / 4;
421 /* Handle other edge. */
422 dev
->smooth_tmp
[i
] = (dev
->smooth
[i
- 1] + dev
->smooth
[i
]) / 2;
424 memcpy(dev
->smooth
, dev
->smooth_tmp
, sizeof(dev
->smooth
));
427 for (i
= 0; i
< nb_sensors
+ 8; i
++) {
429 * Skip values if they're small enough to be truncated to 0
430 * by scale. Mostly noise.
432 if ((dev
->smooth
[i
] >> ATP_SCALE
) > 0) {
433 pcum
+= dev
->smooth
[i
] * i
;
434 psum
+= dev
->smooth
[i
];
439 *z
= psum
>> ATP_SCALE
; /* Scale down pressure output. */
440 return pcum
* fact
/ psum
;
446 static inline void atp_report_fingers(struct input_dev
*input
, int fingers
)
448 input_report_key(input
, BTN_TOOL_FINGER
, fingers
== 1);
449 input_report_key(input
, BTN_TOOL_DOUBLETAP
, fingers
== 2);
450 input_report_key(input
, BTN_TOOL_TRIPLETAP
, fingers
> 2);
453 /* Check URB status and for correct length of data package */
455 #define ATP_URB_STATUS_SUCCESS 0
456 #define ATP_URB_STATUS_ERROR 1
457 #define ATP_URB_STATUS_ERROR_FATAL 2
459 static int atp_status_check(struct urb
*urb
)
461 struct atp
*dev
= urb
->context
;
462 struct usb_interface
*intf
= dev
->intf
;
464 switch (urb
->status
) {
469 if (!dev
->overflow_warned
) {
471 "appletouch: OVERFLOW with data length %d, actual length is %d\n",
472 dev
->info
->datalen
, dev
->urb
->actual_length
);
473 dev
->overflow_warned
= true;
478 /* This urb is terminated, clean up */
480 "atp_complete: urb shutting down with status: %d\n",
482 return ATP_URB_STATUS_ERROR_FATAL
;
486 "atp_complete: nonzero urb status received: %d\n",
488 return ATP_URB_STATUS_ERROR
;
491 /* drop incomplete datasets */
492 if (dev
->urb
->actual_length
!= dev
->info
->datalen
) {
493 dprintk("appletouch: incomplete data package"
494 " (first byte: %d, length: %d).\n",
495 dev
->data
[0], dev
->urb
->actual_length
);
496 return ATP_URB_STATUS_ERROR
;
499 return ATP_URB_STATUS_SUCCESS
;
502 static void atp_detect_size(struct atp
*dev
)
506 /* 17" Powerbooks have extra X sensors */
507 for (i
= dev
->info
->xsensors
; i
< ATP_XSENSORS
; i
++) {
508 if (dev
->xy_cur
[i
]) {
510 dev_info(&dev
->intf
->dev
,
511 "appletouch: 17\" model detected.\n");
513 input_set_abs_params(dev
->input
, ABS_X
, 0,
514 (dev
->info
->xsensors_17
- 1) *
515 dev
->info
->xfact
- 1,
523 * USB interrupt callback functions
526 /* Interrupt function for older touchpads: FOUNTAIN/GEYSER1/GEYSER2 */
528 static void atp_complete_geyser_1_2(struct urb
*urb
)
530 int x
, y
, x_z
, y_z
, x_f
, y_f
;
533 struct atp
*dev
= urb
->context
;
534 int status
= atp_status_check(urb
);
536 if (status
== ATP_URB_STATUS_ERROR_FATAL
)
538 else if (status
== ATP_URB_STATUS_ERROR
)
541 /* reorder the sensors values */
542 if (dev
->info
== &geyser2_info
) {
543 memset(dev
->xy_cur
, 0, sizeof(dev
->xy_cur
));
546 * The values are laid out like this:
547 * Y1, Y2, -, Y3, Y4, -, ..., X1, X2, -, X3, X4, -, ...
548 * '-' is an unused value.
552 for (i
= 0, j
= 19; i
< 20; i
+= 2, j
+= 3) {
553 dev
->xy_cur
[i
] = dev
->data
[j
];
554 dev
->xy_cur
[i
+ 1] = dev
->data
[j
+ 1];
558 for (i
= 0, j
= 1; i
< 9; i
+= 2, j
+= 3) {
559 dev
->xy_cur
[ATP_XSENSORS
+ i
] = dev
->data
[j
];
560 dev
->xy_cur
[ATP_XSENSORS
+ i
+ 1] = dev
->data
[j
+ 1];
563 for (i
= 0; i
< 8; i
++) {
565 dev
->xy_cur
[i
+ 0] = dev
->data
[5 * i
+ 2];
566 dev
->xy_cur
[i
+ 8] = dev
->data
[5 * i
+ 4];
567 dev
->xy_cur
[i
+ 16] = dev
->data
[5 * i
+ 42];
569 dev
->xy_cur
[i
+ 24] = dev
->data
[5 * i
+ 44];
572 dev
->xy_cur
[ATP_XSENSORS
+ i
] = dev
->data
[5 * i
+ 1];
573 dev
->xy_cur
[ATP_XSENSORS
+ i
+ 8] = dev
->data
[5 * i
+ 3];
577 dbg_dump("sample", dev
->xy_cur
);
582 dev
->x_old
= dev
->y_old
= -1;
584 /* Store first sample */
585 memcpy(dev
->xy_old
, dev
->xy_cur
, sizeof(dev
->xy_old
));
587 /* Perform size detection, if not done already */
588 if (unlikely(!dev
->size_detect_done
)) {
589 atp_detect_size(dev
);
590 dev
->size_detect_done
= 1;
595 for (i
= 0; i
< ATP_XSENSORS
+ ATP_YSENSORS
; i
++) {
596 /* accumulate the change */
597 signed char change
= dev
->xy_old
[i
] - dev
->xy_cur
[i
];
598 dev
->xy_acc
[i
] -= change
;
600 /* prevent down drifting */
601 if (dev
->xy_acc
[i
] < 0)
605 memcpy(dev
->xy_old
, dev
->xy_cur
, sizeof(dev
->xy_old
));
607 dbg_dump("accumulator", dev
->xy_acc
);
609 x
= atp_calculate_abs(dev
, 0, ATP_XSENSORS
,
610 dev
->info
->xfact
, &x_z
, &x_f
);
611 y
= atp_calculate_abs(dev
, ATP_XSENSORS
, ATP_YSENSORS
,
612 dev
->info
->yfact
, &y_z
, &y_f
);
613 key
= dev
->data
[dev
->info
->datalen
- 1] & ATP_STATUS_BUTTON
;
615 fingers
= max(x_f
, y_f
);
617 if (x
&& y
&& fingers
== dev
->fingers_old
) {
618 if (dev
->x_old
!= -1) {
619 x
= (dev
->x_old
* 7 + x
) >> 3;
620 y
= (dev
->y_old
* 7 + y
) >> 3;
625 printk(KERN_DEBUG
"appletouch: "
626 "X: %3d Y: %3d Xz: %3d Yz: %3d\n",
629 input_report_key(dev
->input
, BTN_TOUCH
, 1);
630 input_report_abs(dev
->input
, ABS_X
, x
);
631 input_report_abs(dev
->input
, ABS_Y
, y
);
632 input_report_abs(dev
->input
, ABS_PRESSURE
,
633 min(ATP_PRESSURE
, x_z
+ y_z
));
634 atp_report_fingers(dev
->input
, fingers
);
639 } else if (!x
&& !y
) {
641 dev
->x_old
= dev
->y_old
= -1;
642 dev
->fingers_old
= 0;
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 if (fingers
!= dev
->fingers_old
)
652 dev
->x_old
= dev
->y_old
= -1;
653 dev
->fingers_old
= fingers
;
655 input_report_key(dev
->input
, BTN_LEFT
, key
);
656 input_sync(dev
->input
);
659 retval
= usb_submit_urb(dev
->urb
, GFP_ATOMIC
);
661 dev_err(&dev
->intf
->dev
,
662 "atp_complete: usb_submit_urb failed with result %d\n",
666 /* Interrupt function for older touchpads: GEYSER3/GEYSER4 */
668 static void atp_complete_geyser_3_4(struct urb
*urb
)
670 int x
, y
, x_z
, y_z
, x_f
, y_f
;
673 struct atp
*dev
= urb
->context
;
674 int status
= atp_status_check(urb
);
676 if (status
== ATP_URB_STATUS_ERROR_FATAL
)
678 else if (status
== ATP_URB_STATUS_ERROR
)
681 /* Reorder the sensors values:
683 * The values are laid out like this:
684 * -, Y1, Y2, -, Y3, Y4, -, ..., -, X1, X2, -, X3, X4, ...
685 * '-' is an unused value.
689 for (i
= 0, j
= 19; i
< 20; i
+= 2, j
+= 3) {
690 dev
->xy_cur
[i
] = dev
->data
[j
+ 1];
691 dev
->xy_cur
[i
+ 1] = dev
->data
[j
+ 2];
694 for (i
= 0, j
= 1; i
< 9; i
+= 2, j
+= 3) {
695 dev
->xy_cur
[ATP_XSENSORS
+ i
] = dev
->data
[j
+ 1];
696 dev
->xy_cur
[ATP_XSENSORS
+ i
+ 1] = dev
->data
[j
+ 2];
699 dbg_dump("sample", dev
->xy_cur
);
701 /* Just update the base values (i.e. touchpad in untouched state) */
702 if (dev
->data
[dev
->info
->datalen
- 1] & ATP_STATUS_BASE_UPDATE
) {
704 dprintk("appletouch: updated base values\n");
706 memcpy(dev
->xy_old
, dev
->xy_cur
, sizeof(dev
->xy_old
));
710 for (i
= 0; i
< ATP_XSENSORS
+ ATP_YSENSORS
; i
++) {
711 /* calculate the change */
712 dev
->xy_acc
[i
] = dev
->xy_cur
[i
] - dev
->xy_old
[i
];
714 /* this is a round-robin value, so couple with that */
715 if (dev
->xy_acc
[i
] > 127)
716 dev
->xy_acc
[i
] -= 256;
718 if (dev
->xy_acc
[i
] < -127)
719 dev
->xy_acc
[i
] += 256;
721 /* prevent down drifting */
722 if (dev
->xy_acc
[i
] < 0)
726 dbg_dump("accumulator", dev
->xy_acc
);
728 x
= atp_calculate_abs(dev
, 0, ATP_XSENSORS
,
729 dev
->info
->xfact
, &x_z
, &x_f
);
730 y
= atp_calculate_abs(dev
, ATP_XSENSORS
, ATP_YSENSORS
,
731 dev
->info
->yfact
, &y_z
, &y_f
);
733 key
= dev
->data
[dev
->info
->datalen
- 1] & ATP_STATUS_BUTTON
;
735 fingers
= max(x_f
, y_f
);
737 if (x
&& y
&& fingers
== dev
->fingers_old
) {
738 if (dev
->x_old
!= -1) {
739 x
= (dev
->x_old
* 7 + x
) >> 3;
740 y
= (dev
->y_old
* 7 + y
) >> 3;
745 printk(KERN_DEBUG
"appletouch: X: %3d Y: %3d "
749 input_report_key(dev
->input
, BTN_TOUCH
, 1);
750 input_report_abs(dev
->input
, ABS_X
, x
);
751 input_report_abs(dev
->input
, ABS_Y
, y
);
752 input_report_abs(dev
->input
, ABS_PRESSURE
,
753 min(ATP_PRESSURE
, x_z
+ y_z
));
754 atp_report_fingers(dev
->input
, fingers
);
759 } else if (!x
&& !y
) {
761 dev
->x_old
= dev
->y_old
= -1;
762 dev
->fingers_old
= 0;
763 input_report_key(dev
->input
, BTN_TOUCH
, 0);
764 input_report_abs(dev
->input
, ABS_PRESSURE
, 0);
765 atp_report_fingers(dev
->input
, 0);
767 /* reset the accumulator on release */
768 memset(dev
->xy_acc
, 0, sizeof(dev
->xy_acc
));
771 if (fingers
!= dev
->fingers_old
)
772 dev
->x_old
= dev
->y_old
= -1;
773 dev
->fingers_old
= fingers
;
775 input_report_key(dev
->input
, BTN_LEFT
, key
);
776 input_sync(dev
->input
);
779 * Geysers 3/4 will continue to send packets continually after
780 * the first touch unless reinitialised. Do so if it's been
781 * idle for a while in order to avoid waking the kernel up
782 * several hundred times a second.
786 * Button must not be pressed when entering suspend,
787 * otherwise we will never release the button.
789 if (!x
&& !y
&& !key
) {
791 if (dev
->idlecount
== 10) {
792 dev
->x_old
= dev
->y_old
= -1;
794 schedule_work(&dev
->work
);
795 /* Don't resubmit urb here, wait for reinit */
802 retval
= usb_submit_urb(dev
->urb
, GFP_ATOMIC
);
804 dev_err(&dev
->intf
->dev
,
805 "atp_complete: usb_submit_urb failed with result %d\n",
809 static int atp_open(struct input_dev
*input
)
811 struct atp
*dev
= input_get_drvdata(input
);
813 if (usb_submit_urb(dev
->urb
, GFP_ATOMIC
))
820 static void atp_close(struct input_dev
*input
)
822 struct atp
*dev
= input_get_drvdata(input
);
824 usb_kill_urb(dev
->urb
);
825 cancel_work_sync(&dev
->work
);
829 static int atp_handle_geyser(struct atp
*dev
)
831 if (dev
->info
!= &fountain_info
) {
832 /* switch to raw sensor mode */
833 if (atp_geyser_init(dev
))
836 dev_info(&dev
->intf
->dev
, "Geyser mode initialized.\n");
842 static int atp_probe(struct usb_interface
*iface
,
843 const struct usb_device_id
*id
)
846 struct input_dev
*input_dev
;
847 struct usb_device
*udev
= interface_to_usbdev(iface
);
848 struct usb_host_interface
*iface_desc
;
849 struct usb_endpoint_descriptor
*endpoint
;
850 int int_in_endpointAddr
= 0;
851 int i
, error
= -ENOMEM
;
852 const struct atp_info
*info
= (const struct atp_info
*)id
->driver_info
;
854 /* set up the endpoint information */
855 /* use only the first interrupt-in endpoint */
856 iface_desc
= iface
->cur_altsetting
;
857 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; i
++) {
858 endpoint
= &iface_desc
->endpoint
[i
].desc
;
859 if (!int_in_endpointAddr
&& usb_endpoint_is_int_in(endpoint
)) {
860 /* we found an interrupt in endpoint */
861 int_in_endpointAddr
= endpoint
->bEndpointAddress
;
865 if (!int_in_endpointAddr
) {
866 dev_err(&iface
->dev
, "Could not find int-in endpoint\n");
870 /* allocate memory for our device state and initialize it */
871 dev
= kzalloc(sizeof(struct atp
), GFP_KERNEL
);
872 input_dev
= input_allocate_device();
873 if (!dev
|| !input_dev
) {
874 dev_err(&iface
->dev
, "Out of memory\n");
880 dev
->input
= input_dev
;
882 dev
->overflow_warned
= false;
884 dev
->urb
= usb_alloc_urb(0, GFP_KERNEL
);
888 dev
->data
= usb_alloc_coherent(dev
->udev
, dev
->info
->datalen
, GFP_KERNEL
,
889 &dev
->urb
->transfer_dma
);
893 usb_fill_int_urb(dev
->urb
, udev
,
894 usb_rcvintpipe(udev
, int_in_endpointAddr
),
895 dev
->data
, dev
->info
->datalen
,
896 dev
->info
->callback
, dev
, 1);
898 error
= atp_handle_geyser(dev
);
900 goto err_free_buffer
;
902 usb_make_path(udev
, dev
->phys
, sizeof(dev
->phys
));
903 strlcat(dev
->phys
, "/input0", sizeof(dev
->phys
));
905 input_dev
->name
= "appletouch";
906 input_dev
->phys
= dev
->phys
;
907 usb_to_input_id(dev
->udev
, &input_dev
->id
);
908 input_dev
->dev
.parent
= &iface
->dev
;
910 input_set_drvdata(input_dev
, dev
);
912 input_dev
->open
= atp_open
;
913 input_dev
->close
= atp_close
;
915 set_bit(EV_ABS
, input_dev
->evbit
);
917 input_set_abs_params(input_dev
, ABS_X
, 0,
918 (dev
->info
->xsensors
- 1) * dev
->info
->xfact
- 1,
920 input_set_abs_params(input_dev
, ABS_Y
, 0,
921 (dev
->info
->ysensors
- 1) * dev
->info
->yfact
- 1,
923 input_set_abs_params(input_dev
, ABS_PRESSURE
, 0, ATP_PRESSURE
, 0, 0);
925 set_bit(EV_KEY
, input_dev
->evbit
);
926 set_bit(BTN_TOUCH
, input_dev
->keybit
);
927 set_bit(BTN_TOOL_FINGER
, input_dev
->keybit
);
928 set_bit(BTN_TOOL_DOUBLETAP
, input_dev
->keybit
);
929 set_bit(BTN_TOOL_TRIPLETAP
, input_dev
->keybit
);
930 set_bit(BTN_LEFT
, input_dev
->keybit
);
932 error
= input_register_device(dev
->input
);
934 goto err_free_buffer
;
936 /* save our data pointer in this interface device */
937 usb_set_intfdata(iface
, dev
);
939 INIT_WORK(&dev
->work
, atp_reinit
);
944 usb_free_coherent(dev
->udev
, dev
->info
->datalen
,
945 dev
->data
, dev
->urb
->transfer_dma
);
947 usb_free_urb(dev
->urb
);
949 usb_set_intfdata(iface
, NULL
);
951 input_free_device(input_dev
);
955 static void atp_disconnect(struct usb_interface
*iface
)
957 struct atp
*dev
= usb_get_intfdata(iface
);
959 usb_set_intfdata(iface
, NULL
);
961 usb_kill_urb(dev
->urb
);
962 input_unregister_device(dev
->input
);
963 usb_free_coherent(dev
->udev
, dev
->info
->datalen
,
964 dev
->data
, dev
->urb
->transfer_dma
);
965 usb_free_urb(dev
->urb
);
968 dev_info(&iface
->dev
, "input: appletouch disconnected\n");
971 static int atp_recover(struct atp
*dev
)
975 error
= atp_handle_geyser(dev
);
979 if (dev
->open
&& usb_submit_urb(dev
->urb
, GFP_ATOMIC
))
985 static int atp_suspend(struct usb_interface
*iface
, pm_message_t message
)
987 struct atp
*dev
= usb_get_intfdata(iface
);
989 usb_kill_urb(dev
->urb
);
993 static int atp_resume(struct usb_interface
*iface
)
995 struct atp
*dev
= usb_get_intfdata(iface
);
997 if (dev
->open
&& usb_submit_urb(dev
->urb
, GFP_ATOMIC
))
1003 static int atp_reset_resume(struct usb_interface
*iface
)
1005 struct atp
*dev
= usb_get_intfdata(iface
);
1007 return atp_recover(dev
);
1010 static struct usb_driver atp_driver
= {
1011 .name
= "appletouch",
1013 .disconnect
= atp_disconnect
,
1014 .suspend
= atp_suspend
,
1015 .resume
= atp_resume
,
1016 .reset_resume
= atp_reset_resume
,
1017 .id_table
= atp_table
,
1020 module_usb_driver(atp_driver
);