?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
rt2x00: Simplify rt2x00_check_rev
[linux/fpc-iii.git] / drivers / input / mouse / appletouch.c
blob454b96112f03187b5e5c9ea042af86c166902332
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-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)
12 *
13 * Thanks to Alex Harper <basilisk@foobox.net> for his inputs.
14 *
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.
19 *
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.
24 *
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.
28 *
29 */
30
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>
37
38 /*
39 * Note: We try to keep the touchpad aspect ratio while still doing only
40 * simple arithmetics:
41 * 0 <= x <= (xsensors - 1) * xfact
42 * 0 <= y <= (ysensors - 1) * yfact
43 */
44 struct atp_info {
45 int xsensors; /* number of X sensors */
46 int xsensors_17; /* 17" models have more sensors */
47 int ysensors; /* number of Y sensors */
48 int xfact; /* X multiplication factor */
49 int yfact; /* Y multiplication factor */
50 int datalen; /* size of USB transfers */
51 void (*callback)(struct urb *); /* callback function */
52 };
53
54 static void atp_complete_geyser_1_2(struct urb *urb);
55 static void atp_complete_geyser_3_4(struct urb *urb);
56
57 static const struct atp_info fountain_info = {
58 .xsensors = 16,
59 .xsensors_17 = 26,
60 .ysensors = 16,
61 .xfact = 64,
62 .yfact = 43,
63 .datalen = 81,
64 .callback = atp_complete_geyser_1_2,
65 };
66
67 static const struct atp_info geyser1_info = {
68 .xsensors = 16,
69 .xsensors_17 = 26,
70 .ysensors = 16,
71 .xfact = 64,
72 .yfact = 43,
73 .datalen = 81,
74 .callback = atp_complete_geyser_1_2,
75 };
76
77 static const struct atp_info geyser2_info = {
78 .xsensors = 15,
79 .xsensors_17 = 20,
80 .ysensors = 9,
81 .xfact = 64,
82 .yfact = 43,
83 .datalen = 64,
84 .callback = atp_complete_geyser_1_2,
85 };
86
87 static const struct atp_info geyser3_info = {
88 .xsensors = 20,
89 .ysensors = 10,
90 .xfact = 64,
91 .yfact = 64,
92 .datalen = 64,
93 .callback = atp_complete_geyser_3_4,
94 };
95
96 static const struct atp_info geyser4_info = {
97 .xsensors = 20,
98 .ysensors = 10,
99 .xfact = 64,
100 .yfact = 64,
101 .datalen = 64,
102 .callback = atp_complete_geyser_3_4,
103 };
104
105 #define ATP_DEVICE(prod, info) \
106 { \
107 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
108 USB_DEVICE_ID_MATCH_INT_CLASS | \
109 USB_DEVICE_ID_MATCH_INT_PROTOCOL, \
110 .idVendor = 0x05ac, /* Apple */ \
111 .idProduct = (prod), \
112 .bInterfaceClass = 0x03, \
113 .bInterfaceProtocol = 0x02, \
114 .driver_info = (unsigned long) &info, \
115 }
116
117 /*
118 * Table of devices (Product IDs) that work with this driver.
119 * (The names come from Info.plist in AppleUSBTrackpad.kext,
120 * According to Info.plist Geyser IV is the same as Geyser III.)
121 */
122
123 static struct usb_device_id atp_table[] = {
124 /* PowerBooks Feb 2005, iBooks G4 */
125 ATP_DEVICE(0x020e, fountain_info), /* FOUNTAIN ANSI */
126 ATP_DEVICE(0x020f, fountain_info), /* FOUNTAIN ISO */
127 ATP_DEVICE(0x030a, fountain_info), /* FOUNTAIN TP ONLY */
128 ATP_DEVICE(0x030b, geyser1_info), /* GEYSER 1 TP ONLY */
129
130 /* PowerBooks Oct 2005 */
131 ATP_DEVICE(0x0214, geyser2_info), /* GEYSER 2 ANSI */
132 ATP_DEVICE(0x0215, geyser2_info), /* GEYSER 2 ISO */
133 ATP_DEVICE(0x0216, geyser2_info), /* GEYSER 2 JIS */
134
135 /* Core Duo MacBook & MacBook Pro */
136 ATP_DEVICE(0x0217, geyser3_info), /* GEYSER 3 ANSI */
137 ATP_DEVICE(0x0218, geyser3_info), /* GEYSER 3 ISO */
138 ATP_DEVICE(0x0219, geyser3_info), /* GEYSER 3 JIS */
139
140 /* Core2 Duo MacBook & MacBook Pro */
141 ATP_DEVICE(0x021a, geyser4_info), /* GEYSER 4 ANSI */
142 ATP_DEVICE(0x021b, geyser4_info), /* GEYSER 4 ISO */
143 ATP_DEVICE(0x021c, geyser4_info), /* GEYSER 4 JIS */
144
145 /* Core2 Duo MacBook3,1 */
146 ATP_DEVICE(0x0229, geyser4_info), /* GEYSER 4 HF ANSI */
147 ATP_DEVICE(0x022a, geyser4_info), /* GEYSER 4 HF ISO */
148 ATP_DEVICE(0x022b, geyser4_info), /* GEYSER 4 HF JIS */
149
150 /* Terminating entry */
151 { }
152 };
153 MODULE_DEVICE_TABLE(usb, atp_table);
154
155 /* maximum number of sensors */
156 #define ATP_XSENSORS 26
157 #define ATP_YSENSORS 16
158
159 /* amount of fuzz this touchpad generates */
160 #define ATP_FUZZ 16
161
162 /* maximum pressure this driver will report */
163 #define ATP_PRESSURE 300
164
165 /*
166 * Threshold for the touchpad sensors. Any change less than ATP_THRESHOLD is
167 * ignored.
168 */
169 #define ATP_THRESHOLD 5
170
171 /* Geyser initialization constants */
172 #define ATP_GEYSER_MODE_READ_REQUEST_ID 1
173 #define ATP_GEYSER_MODE_WRITE_REQUEST_ID 9
174 #define ATP_GEYSER_MODE_REQUEST_VALUE 0x300
175 #define ATP_GEYSER_MODE_REQUEST_INDEX 0
176 #define ATP_GEYSER_MODE_VENDOR_VALUE 0x04
177
178 /**
179 * enum atp_status_bits - status bit meanings
180 *
181 * These constants represent the meaning of the status bits.
182 * (only Geyser 3/4)
183 *
184 * @ATP_STATUS_BUTTON: The button was pressed
185 * @ATP_STATUS_BASE_UPDATE: Update of the base values (untouched pad)
186 * @ATP_STATUS_FROM_RESET: Reset previously performed
187 */
188 enum atp_status_bits {
189 ATP_STATUS_BUTTON = BIT(0),
190 ATP_STATUS_BASE_UPDATE = BIT(2),
191 ATP_STATUS_FROM_RESET = BIT(4),
192 };
193
194 /* Structure to hold all of our device specific stuff */
195 struct atp {
196 char phys[64];
197 struct usb_device *udev; /* usb device */
198 struct urb *urb; /* usb request block */
199 u8 *data; /* transferred data */
200 struct input_dev *input; /* input dev */
201 const struct atp_info *info; /* touchpad model */
202 bool open;
203 bool valid; /* are the samples valid? */
204 bool size_detect_done;
205 bool overflow_warned;
206 int x_old; /* last reported x/y, */
207 int y_old; /* used for smoothing */
208 signed char xy_cur[ATP_XSENSORS + ATP_YSENSORS];
209 signed char xy_old[ATP_XSENSORS + ATP_YSENSORS];
210 int xy_acc[ATP_XSENSORS + ATP_YSENSORS];
211 int idlecount; /* number of empty packets */
212 struct work_struct work;
213 };
214
215 #define dbg_dump(msg, tab) \
216 if (debug > 1) { \
217 int __i; \
218 printk(KERN_DEBUG "appletouch: %s", msg); \
219 for (__i = 0; __i < ATP_XSENSORS + ATP_YSENSORS; __i++) \
220 printk(" %02x", tab[__i]); \
221 printk("\n"); \
222 }
223
224 #define dprintk(format, a...) \
225 do { \
226 if (debug) \
227 printk(KERN_DEBUG format, ##a); \
228 } while (0)
229
230 MODULE_AUTHOR("Johannes Berg");
231 MODULE_AUTHOR("Stelian Pop");
232 MODULE_AUTHOR("Frank Arnold");
233 MODULE_AUTHOR("Michael Hanselmann");
234 MODULE_AUTHOR("Sven Anders");
235 MODULE_DESCRIPTION("Apple PowerBook and MacBook USB touchpad driver");
236 MODULE_LICENSE("GPL");
237
238 /*
239 * Make the threshold a module parameter
240 */
241 static int threshold = ATP_THRESHOLD;
242 module_param(threshold, int, 0644);
243 MODULE_PARM_DESC(threshold, "Discard any change in data from a sensor"
244 " (the trackpad has many of these sensors)"
245 " less than this value.");
246
247 static int debug;
248 module_param(debug, int, 0644);
249 MODULE_PARM_DESC(debug, "Activate debugging output");
250
251 /*
252 * By default newer Geyser devices send standard USB HID mouse
253 * packets (Report ID 2). This code changes device mode, so it
254 * sends raw sensor reports (Report ID 5).
255 */
256 static int atp_geyser_init(struct usb_device *udev)
257 {
258 char data[8];
259 int size;
260 int i;
261
262 size = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
263 ATP_GEYSER_MODE_READ_REQUEST_ID,
264 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
265 ATP_GEYSER_MODE_REQUEST_VALUE,
266 ATP_GEYSER_MODE_REQUEST_INDEX, &data, 8, 5000);
267
268 if (size != 8) {
269 dprintk("atp_geyser_init: read error\n");
270 for (i = 0; i < 8; i++)
271 dprintk("appletouch[%d]: %d\n", i, data[i]);
272
273 err("Failed to read mode from device.");
274 return -EIO;
275 }
276
277 /* Apply the mode switch */
278 data[0] = ATP_GEYSER_MODE_VENDOR_VALUE;
279
280 size = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
281 ATP_GEYSER_MODE_WRITE_REQUEST_ID,
282 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
283 ATP_GEYSER_MODE_REQUEST_VALUE,
284 ATP_GEYSER_MODE_REQUEST_INDEX, &data, 8, 5000);
285
286 if (size != 8) {
287 dprintk("atp_geyser_init: write error\n");
288 for (i = 0; i < 8; i++)
289 dprintk("appletouch[%d]: %d\n", i, data[i]);
290
291 err("Failed to request geyser raw mode");
292 return -EIO;
293 }
294 return 0;
295 }
296
297 /*
298 * Reinitialise the device. This usually stops stream of empty packets
299 * coming from it.
300 */
301 static void atp_reinit(struct work_struct *work)
302 {
303 struct atp *dev = container_of(work, struct atp, work);
304 struct usb_device *udev = dev->udev;
305 int retval;
306
307 dprintk("appletouch: putting appletouch to sleep (reinit)\n");
308 atp_geyser_init(udev);
309
310 retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
311 if (retval)
312 err("atp_reinit: usb_submit_urb failed with error %d",
313 retval);
314 }
315
316 static int atp_calculate_abs(int *xy_sensors, int nb_sensors, int fact,
317 int *z, int *fingers)
318 {
319 int i;
320 /* values to calculate mean */
321 int pcum = 0, psum = 0;
322 int is_increasing = 0;
323
324 *fingers = 0;
325
326 for (i = 0; i < nb_sensors; i++) {
327 if (xy_sensors[i] < threshold) {
328 if (is_increasing)
329 is_increasing = 0;
330
331 continue;
332 }
333
334 /*
335 * Makes the finger detection more versatile. For example,
336 * two fingers with no gap will be detected. Also, my
337 * tests show it less likely to have intermittent loss
338 * of multiple finger readings while moving around (scrolling).
339 *
340 * Changes the multiple finger detection to counting humps on
341 * sensors (transitions from nonincreasing to increasing)
342 * instead of counting transitions from low sensors (no
343 * finger reading) to high sensors (finger above
344 * sensor)
345 *
346 * - Jason Parekh <jasonparekh@gmail.com>
347 */
348 if (i < 1 ||
349 (!is_increasing && xy_sensors[i - 1] < xy_sensors[i])) {
350 (*fingers)++;
351 is_increasing = 1;
352 } else if (i > 0 && xy_sensors[i - 1] >= xy_sensors[i]) {
353 is_increasing = 0;
354 }
355
356 /*
357 * Subtracts threshold so a high sensor that just passes the
358 * threshold won't skew the calculated absolute coordinate.
359 * Fixes an issue where slowly moving the mouse would
360 * occasionally jump a number of pixels (slowly moving the
361 * finger makes this issue most apparent.)
362 */
363 pcum += (xy_sensors[i] - threshold) * i;
364 psum += (xy_sensors[i] - threshold);
365 }
366
367 if (psum > 0) {
368 *z = psum;
369 return pcum * fact / psum;
370 }
371
372 return 0;
373 }
374
375 static inline void atp_report_fingers(struct input_dev *input, int fingers)
376 {
377 input_report_key(input, BTN_TOOL_FINGER, fingers == 1);
378 input_report_key(input, BTN_TOOL_DOUBLETAP, fingers == 2);
379 input_report_key(input, BTN_TOOL_TRIPLETAP, fingers > 2);
380 }
381
382 /* Check URB status and for correct length of data package */
383
384 #define ATP_URB_STATUS_SUCCESS 0
385 #define ATP_URB_STATUS_ERROR 1
386 #define ATP_URB_STATUS_ERROR_FATAL 2
387
388 static int atp_status_check(struct urb *urb)
389 {
390 struct atp *dev = urb->context;
391
392 switch (urb->status) {
393 case 0:
394 /* success */
395 break;
396 case -EOVERFLOW:
397 if (!dev->overflow_warned) {
398 printk(KERN_WARNING "appletouch: OVERFLOW with data "
399 "length %d, actual length is %d\n",
400 dev->info->datalen, dev->urb->actual_length);
401 dev->overflow_warned = true;
402 }
403 case -ECONNRESET:
404 case -ENOENT:
405 case -ESHUTDOWN:
406 /* This urb is terminated, clean up */
407 dbg("atp_complete: urb shutting down with status: %d",
408 urb->status);
409 return ATP_URB_STATUS_ERROR_FATAL;
410
411 default:
412 dbg("atp_complete: nonzero urb status received: %d",
413 urb->status);
414 return ATP_URB_STATUS_ERROR;
415 }
416
417 /* drop incomplete datasets */
418 if (dev->urb->actual_length != dev->info->datalen) {
419 dprintk("appletouch: incomplete data package"
420 " (first byte: %d, length: %d).\n",
421 dev->data[0], dev->urb->actual_length);
422 return ATP_URB_STATUS_ERROR;
423 }
424
425 return ATP_URB_STATUS_SUCCESS;
426 }
427
428 static void atp_detect_size(struct atp *dev)
429 {
430 int i;
431
432 /* 17" Powerbooks have extra X sensors */
433 for (i = dev->info->xsensors; i < ATP_XSENSORS; i++) {
434 if (dev->xy_cur[i]) {
435
436 printk(KERN_INFO "appletouch: 17\" model detected.\n");
437
438 input_set_abs_params(dev->input, ABS_X, 0,
439 (dev->info->xsensors_17 - 1) *
440 dev->info->xfact - 1,
441 ATP_FUZZ, 0);
442 break;
443 }
444 }
445 }
446
447 /*
448 * USB interrupt callback functions
449 */
450
451 /* Interrupt function for older touchpads: FOUNTAIN/GEYSER1/GEYSER2 */
452
453 static void atp_complete_geyser_1_2(struct urb *urb)
454 {
455 int x, y, x_z, y_z, x_f, y_f;
456 int retval, i, j;
457 int key;
458 struct atp *dev = urb->context;
459 int status = atp_status_check(urb);
460
461 if (status == ATP_URB_STATUS_ERROR_FATAL)
462 return;
463 else if (status == ATP_URB_STATUS_ERROR)
464 goto exit;
465
466 /* reorder the sensors values */
467 if (dev->info == &geyser2_info) {
468 memset(dev->xy_cur, 0, sizeof(dev->xy_cur));
469
470 /*
471 * The values are laid out like this:
472 * Y1, Y2, -, Y3, Y4, -, ..., X1, X2, -, X3, X4, -, ...
473 * '-' is an unused value.
474 */
475
476 /* read X values */
477 for (i = 0, j = 19; i < 20; i += 2, j += 3) {
478 dev->xy_cur[i] = dev->data[j];
479 dev->xy_cur[i + 1] = dev->data[j + 1];
480 }
481
482 /* read Y values */
483 for (i = 0, j = 1; i < 9; i += 2, j += 3) {
484 dev->xy_cur[ATP_XSENSORS + i] = dev->data[j];
485 dev->xy_cur[ATP_XSENSORS + i + 1] = dev->data[j + 1];
486 }
487 } else {
488 for (i = 0; i < 8; i++) {
489 /* X values */
490 dev->xy_cur[i + 0] = dev->data[5 * i + 2];
491 dev->xy_cur[i + 8] = dev->data[5 * i + 4];
492 dev->xy_cur[i + 16] = dev->data[5 * i + 42];
493 if (i < 2)
494 dev->xy_cur[i + 24] = dev->data[5 * i + 44];
495
496 /* Y values */
497 dev->xy_cur[ATP_XSENSORS + i] = dev->data[5 * i + 1];
498 dev->xy_cur[ATP_XSENSORS + i + 8] = dev->data[5 * i + 3];
499 }
500 }
501
502 dbg_dump("sample", dev->xy_cur);
503
504 if (!dev->valid) {
505 /* first sample */
506 dev->valid = true;
507 dev->x_old = dev->y_old = -1;
508
509 /* Store first sample */
510 memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
511
512 /* Perform size detection, if not done already */
513 if (unlikely(!dev->size_detect_done)) {
514 atp_detect_size(dev);
515 dev->size_detect_done = 1;
516 goto exit;
517 }
518 }
519
520 for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) {
521 /* accumulate the change */
522 signed char change = dev->xy_old[i] - dev->xy_cur[i];
523 dev->xy_acc[i] -= change;
524
525 /* prevent down drifting */
526 if (dev->xy_acc[i] < 0)
527 dev->xy_acc[i] = 0;
528 }
529
530 memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
531
532 dbg_dump("accumulator", dev->xy_acc);
533
534 x = atp_calculate_abs(dev->xy_acc, ATP_XSENSORS,
535 dev->info->xfact, &x_z, &x_f);
536 y = atp_calculate_abs(dev->xy_acc + ATP_XSENSORS, ATP_YSENSORS,
537 dev->info->yfact, &y_z, &y_f);
538 key = dev->data[dev->info->datalen - 1] & ATP_STATUS_BUTTON;
539
540 if (x && y) {
541 if (dev->x_old != -1) {
542 x = (dev->x_old * 3 + x) >> 2;
543 y = (dev->y_old * 3 + y) >> 2;
544 dev->x_old = x;
545 dev->y_old = y;
546
547 if (debug > 1)
548 printk(KERN_DEBUG "appletouch: "
549 "X: %3d Y: %3d Xz: %3d Yz: %3d\n",
550 x, y, x_z, y_z);
551
552 input_report_key(dev->input, BTN_TOUCH, 1);
553 input_report_abs(dev->input, ABS_X, x);
554 input_report_abs(dev->input, ABS_Y, y);
555 input_report_abs(dev->input, ABS_PRESSURE,
556 min(ATP_PRESSURE, x_z + y_z));
557 atp_report_fingers(dev->input, max(x_f, y_f));
558 }
559 dev->x_old = x;
560 dev->y_old = y;
561
562 } else if (!x && !y) {
563
564 dev->x_old = dev->y_old = -1;
565 input_report_key(dev->input, BTN_TOUCH, 0);
566 input_report_abs(dev->input, ABS_PRESSURE, 0);
567 atp_report_fingers(dev->input, 0);
568
569 /* reset the accumulator on release */
570 memset(dev->xy_acc, 0, sizeof(dev->xy_acc));
571 }
572
573 input_report_key(dev->input, BTN_LEFT, key);
574 input_sync(dev->input);
575
576 exit:
577 retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
578 if (retval)
579 err("atp_complete: usb_submit_urb failed with result %d",
580 retval);
581 }
582
583 /* Interrupt function for older touchpads: GEYSER3/GEYSER4 */
584
585 static void atp_complete_geyser_3_4(struct urb *urb)
586 {
587 int x, y, x_z, y_z, x_f, y_f;
588 int retval, i, j;
589 int key;
590 struct atp *dev = urb->context;
591 int status = atp_status_check(urb);
592
593 if (status == ATP_URB_STATUS_ERROR_FATAL)
594 return;
595 else if (status == ATP_URB_STATUS_ERROR)
596 goto exit;
597
598 /* Reorder the sensors values:
599 *
600 * The values are laid out like this:
601 * -, Y1, Y2, -, Y3, Y4, -, ..., -, X1, X2, -, X3, X4, ...
602 * '-' is an unused value.
603 */
604
605 /* read X values */
606 for (i = 0, j = 19; i < 20; i += 2, j += 3) {
607 dev->xy_cur[i] = dev->data[j + 1];
608 dev->xy_cur[i + 1] = dev->data[j + 2];
609 }
610 /* read Y values */
611 for (i = 0, j = 1; i < 9; i += 2, j += 3) {
612 dev->xy_cur[ATP_XSENSORS + i] = dev->data[j + 1];
613 dev->xy_cur[ATP_XSENSORS + i + 1] = dev->data[j + 2];
614 }
615
616 dbg_dump("sample", dev->xy_cur);
617
618 /* Just update the base values (i.e. touchpad in untouched state) */
619 if (dev->data[dev->info->datalen - 1] & ATP_STATUS_BASE_UPDATE) {
620
621 dprintk(KERN_DEBUG "appletouch: updated base values\n");
622
623 memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
624 goto exit;
625 }
626
627 for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) {
628 /* calculate the change */
629 dev->xy_acc[i] = dev->xy_cur[i] - dev->xy_old[i];
630
631 /* this is a round-robin value, so couple with that */
632 if (dev->xy_acc[i] > 127)
633 dev->xy_acc[i] -= 256;
634
635 if (dev->xy_acc[i] < -127)
636 dev->xy_acc[i] += 256;
637
638 /* prevent down drifting */
639 if (dev->xy_acc[i] < 0)
640 dev->xy_acc[i] = 0;
641 }
642
643 dbg_dump("accumulator", dev->xy_acc);
644
645 x = atp_calculate_abs(dev->xy_acc, ATP_XSENSORS,
646 dev->info->xfact, &x_z, &x_f);
647 y = atp_calculate_abs(dev->xy_acc + ATP_XSENSORS, ATP_YSENSORS,
648 dev->info->yfact, &y_z, &y_f);
649 key = dev->data[dev->info->datalen - 1] & ATP_STATUS_BUTTON;
650
651 if (x && y) {
652 if (dev->x_old != -1) {
653 x = (dev->x_old * 3 + x) >> 2;
654 y = (dev->y_old * 3 + y) >> 2;
655 dev->x_old = x;
656 dev->y_old = y;
657
658 if (debug > 1)
659 printk(KERN_DEBUG "appletouch: X: %3d Y: %3d "
660 "Xz: %3d Yz: %3d\n",
661 x, y, x_z, y_z);
662
663 input_report_key(dev->input, BTN_TOUCH, 1);
664 input_report_abs(dev->input, ABS_X, x);
665 input_report_abs(dev->input, ABS_Y, y);
666 input_report_abs(dev->input, ABS_PRESSURE,
667 min(ATP_PRESSURE, x_z + y_z));
668 atp_report_fingers(dev->input, max(x_f, y_f));
669 }
670 dev->x_old = x;
671 dev->y_old = y;
672
673 } else if (!x && !y) {
674
675 dev->x_old = dev->y_old = -1;
676 input_report_key(dev->input, BTN_TOUCH, 0);
677 input_report_abs(dev->input, ABS_PRESSURE, 0);
678 atp_report_fingers(dev->input, 0);
679
680 /* reset the accumulator on release */
681 memset(dev->xy_acc, 0, sizeof(dev->xy_acc));
682 }
683
684 input_report_key(dev->input, BTN_LEFT, key);
685 input_sync(dev->input);
686
687 /*
688 * Geysers 3/4 will continue to send packets continually after
689 * the first touch unless reinitialised. Do so if it's been
690 * idle for a while in order to avoid waking the kernel up
691 * several hundred times a second.
692 */
693
694 /*
695 * Button must not be pressed when entering suspend,
696 * otherwise we will never release the button.
697 */
698 if (!x && !y && !key) {
699 dev->idlecount++;
700 if (dev->idlecount == 10) {
701 dev->x_old = dev->y_old = -1;
702 dev->idlecount = 0;
703 schedule_work(&dev->work);
704 /* Don't resubmit urb here, wait for reinit */
705 return;
706 }
707 } else
708 dev->idlecount = 0;
709
710 exit:
711 retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
712 if (retval)
713 err("atp_complete: usb_submit_urb failed with result %d",
714 retval);
715 }
716
717 static int atp_open(struct input_dev *input)
718 {
719 struct atp *dev = input_get_drvdata(input);
720
721 if (usb_submit_urb(dev->urb, GFP_ATOMIC))
722 return -EIO;
723
724 dev->open = 1;
725 return 0;
726 }
727
728 static void atp_close(struct input_dev *input)
729 {
730 struct atp *dev = input_get_drvdata(input);
731
732 usb_kill_urb(dev->urb);
733 cancel_work_sync(&dev->work);
734 dev->open = 0;
735 }
736
737 static int atp_handle_geyser(struct atp *dev)
738 {
739 struct usb_device *udev = dev->udev;
740
741 if (dev->info != &fountain_info) {
742 /* switch to raw sensor mode */
743 if (atp_geyser_init(udev))
744 return -EIO;
745
746 printk(KERN_INFO "appletouch: Geyser mode initialized.\n");
747 }
748
749 return 0;
750 }
751
752 static int atp_probe(struct usb_interface *iface,
753 const struct usb_device_id *id)
754 {
755 struct atp *dev;
756 struct input_dev *input_dev;
757 struct usb_device *udev = interface_to_usbdev(iface);
758 struct usb_host_interface *iface_desc;
759 struct usb_endpoint_descriptor *endpoint;
760 int int_in_endpointAddr = 0;
761 int i, error = -ENOMEM;
762 const struct atp_info *info = (const struct atp_info *)id->driver_info;
763
764 /* set up the endpoint information */
765 /* use only the first interrupt-in endpoint */
766 iface_desc = iface->cur_altsetting;
767 for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
768 endpoint = &iface_desc->endpoint[i].desc;
769 if (!int_in_endpointAddr && usb_endpoint_is_int_in(endpoint)) {
770 /* we found an interrupt in endpoint */
771 int_in_endpointAddr = endpoint->bEndpointAddress;
772 break;
773 }
774 }
775 if (!int_in_endpointAddr) {
776 err("Could not find int-in endpoint");
777 return -EIO;
778 }
779
780 /* allocate memory for our device state and initialize it */
781 dev = kzalloc(sizeof(struct atp), GFP_KERNEL);
782 input_dev = input_allocate_device();
783 if (!dev || !input_dev) {
784 err("Out of memory");
785 goto err_free_devs;
786 }
787
788 dev->udev = udev;
789 dev->input = input_dev;
790 dev->info = info;
791 dev->overflow_warned = false;
792
793 dev->urb = usb_alloc_urb(0, GFP_KERNEL);
794 if (!dev->urb)
795 goto err_free_devs;
796
797 dev->data = usb_buffer_alloc(dev->udev, dev->info->datalen, GFP_KERNEL,
798 &dev->urb->transfer_dma);
799 if (!dev->data)
800 goto err_free_urb;
801
802 usb_fill_int_urb(dev->urb, udev,
803 usb_rcvintpipe(udev, int_in_endpointAddr),
804 dev->data, dev->info->datalen,
805 dev->info->callback, dev, 1);
806
807 error = atp_handle_geyser(dev);
808 if (error)
809 goto err_free_buffer;
810
811 usb_make_path(udev, dev->phys, sizeof(dev->phys));
812 strlcat(dev->phys, "/input0", sizeof(dev->phys));
813
814 input_dev->name = "appletouch";
815 input_dev->phys = dev->phys;
816 usb_to_input_id(dev->udev, &input_dev->id);
817 input_dev->dev.parent = &iface->dev;
818
819 input_set_drvdata(input_dev, dev);
820
821 input_dev->open = atp_open;
822 input_dev->close = atp_close;
823
824 set_bit(EV_ABS, input_dev->evbit);
825
826 input_set_abs_params(input_dev, ABS_X, 0,
827 (dev->info->xsensors - 1) * dev->info->xfact - 1,
828 ATP_FUZZ, 0);
829 input_set_abs_params(input_dev, ABS_Y, 0,
830 (dev->info->ysensors - 1) * dev->info->yfact - 1,
831 ATP_FUZZ, 0);
832 input_set_abs_params(input_dev, ABS_PRESSURE, 0, ATP_PRESSURE, 0, 0);
833
834 set_bit(EV_KEY, input_dev->evbit);
835 set_bit(BTN_TOUCH, input_dev->keybit);
836 set_bit(BTN_TOOL_FINGER, input_dev->keybit);
837 set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit);
838 set_bit(BTN_TOOL_TRIPLETAP, input_dev->keybit);
839 set_bit(BTN_LEFT, input_dev->keybit);
840
841 error = input_register_device(dev->input);
842 if (error)
843 goto err_free_buffer;
844
845 /* save our data pointer in this interface device */
846 usb_set_intfdata(iface, dev);
847
848 INIT_WORK(&dev->work, atp_reinit);
849
850 return 0;
851
852 err_free_buffer:
853 usb_buffer_free(dev->udev, dev->info->datalen,
854 dev->data, dev->urb->transfer_dma);
855 err_free_urb:
856 usb_free_urb(dev->urb);
857 err_free_devs:
858 usb_set_intfdata(iface, NULL);
859 kfree(dev);
860 input_free_device(input_dev);
861 return error;
862 }
863
864 static void atp_disconnect(struct usb_interface *iface)
865 {
866 struct atp *dev = usb_get_intfdata(iface);
867
868 usb_set_intfdata(iface, NULL);
869 if (dev) {
870 usb_kill_urb(dev->urb);
871 input_unregister_device(dev->input);
872 usb_buffer_free(dev->udev, dev->info->datalen,
873 dev->data, dev->urb->transfer_dma);
874 usb_free_urb(dev->urb);
875 kfree(dev);
876 }
877 printk(KERN_INFO "input: appletouch disconnected\n");
878 }
879
880 static int atp_recover(struct atp *dev)
881 {
882 int error;
883
884 error = atp_handle_geyser(dev);
885 if (error)
886 return error;
887
888 if (dev->open && usb_submit_urb(dev->urb, GFP_ATOMIC))
889 return -EIO;
890
891 return 0;
892 }
893
894 static int atp_suspend(struct usb_interface *iface, pm_message_t message)
895 {
896 struct atp *dev = usb_get_intfdata(iface);
897
898 usb_kill_urb(dev->urb);
899 return 0;
900 }
901
902 static int atp_resume(struct usb_interface *iface)
903 {
904 struct atp *dev = usb_get_intfdata(iface);
905
906 if (dev->open && usb_submit_urb(dev->urb, GFP_ATOMIC))
907 return -EIO;
908
909 return 0;
910 }
911
912 static int atp_reset_resume(struct usb_interface *iface)
913 {
914 struct atp *dev = usb_get_intfdata(iface);
915
916 return atp_recover(dev);
917 }
918
919 static struct usb_driver atp_driver = {
920 .name = "appletouch",
921 .probe = atp_probe,
922 .disconnect = atp_disconnect,
923 .suspend = atp_suspend,
924 .resume = atp_resume,
925 .reset_resume = atp_reset_resume,
926 .id_table = atp_table,
927 };
928
929 static int __init atp_init(void)
930 {
931 return usb_register(&atp_driver);
932 }
933
934 static void __exit atp_exit(void)
935 {
936 usb_deregister(&atp_driver);
937 }
938
939 module_init(atp_init);
940 module_exit(atp_exit);
Linux with added FPC-III support