?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86: cpa: move clflush_cache_range()
[wrt350n-kernel.git] / drivers / input / mouse / appletouch.c
blobb4423a471f027e03d8e94499b81b72ed935fcd12
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 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 *
12 * Thanks to Alex Harper <basilisk@foobox.net> for his inputs.
13 *
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.
18 *
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.
23 *
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.
27 *
28 */
29
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>
36
37 /* Apple has powerbooks which have the keyboard with different Product IDs */
38 #define APPLE_VENDOR_ID 0x05AC
39
40 /* These names come from Info.plist in AppleUSBTrackpad.kext */
41 #define FOUNTAIN_ANSI_PRODUCT_ID 0x020E
42 #define FOUNTAIN_ISO_PRODUCT_ID 0x020F
43
44 #define FOUNTAIN_TP_ONLY_PRODUCT_ID 0x030A
45
46 #define GEYSER1_TP_ONLY_PRODUCT_ID 0x030B
47
48 #define GEYSER_ANSI_PRODUCT_ID 0x0214
49 #define GEYSER_ISO_PRODUCT_ID 0x0215
50 #define GEYSER_JIS_PRODUCT_ID 0x0216
51
52 /* MacBook devices */
53 #define GEYSER3_ANSI_PRODUCT_ID 0x0217
54 #define GEYSER3_ISO_PRODUCT_ID 0x0218
55 #define GEYSER3_JIS_PRODUCT_ID 0x0219
56
57 /*
58 * Geyser IV: same as Geyser III according to Info.plist in AppleUSBTrackpad.kext
59 * -> same IOClass (AppleUSBGrIIITrackpad), same acceleration tables
60 */
61 #define GEYSER4_ANSI_PRODUCT_ID 0x021A
62 #define GEYSER4_ISO_PRODUCT_ID 0x021B
63 #define GEYSER4_JIS_PRODUCT_ID 0x021C
64
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
73
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) },
80
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) },
85
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) },
90
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) },
95
96 /* Terminating entry */
97 { }
98 };
99 MODULE_DEVICE_TABLE (usb, atp_table);
100
101 /*
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.
105 */
106 #define ATP_XSENSORS 26
107 #define ATP_YSENSORS 16
108
109 /* amount of fuzz this touchpad generates */
110 #define ATP_FUZZ 16
111
112 /* maximum pressure this driver will report */
113 #define ATP_PRESSURE 300
114 /*
115 * multiplication factor for the X and Y coordinates.
116 * We try to keep the touchpad aspect ratio while still doing only simple
117 * arithmetics.
118 * The factors below give coordinates like:
119 * 0 <= x < 960 on 12" and 15" Powerbooks
120 * 0 <= x < 1600 on 17" Powerbooks
121 * 0 <= y < 646
122 */
123 #define ATP_XFACT 64
124 #define ATP_YFACT 43
125
126 /*
127 * Threshold for the touchpad sensors. Any change less than ATP_THRESHOLD is
128 * ignored.
129 */
130 #define ATP_THRESHOLD 5
131
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
138
139 /* Structure to hold all of our device specific stuff */
140 struct atp {
141 char phys[64];
142 struct usb_device * udev; /* usb device */
143 struct urb * urb; /* usb request block */
144 signed char * data; /* transferred data */
145 struct input_dev * input; /* input dev */
146 unsigned char open; /* non-zero if opened */
147 unsigned char valid; /* are the sensors valid ? */
148 unsigned char size_detect_done;
149 unsigned char overflowwarn; /* overflow warning printed? */
150 int x_old; /* last reported x/y, */
151 int y_old; /* used for smoothing */
152 /* current value of the sensors */
153 signed char xy_cur[ATP_XSENSORS + ATP_YSENSORS];
154 /* last value of the sensors */
155 signed char xy_old[ATP_XSENSORS + ATP_YSENSORS];
156 /* accumulated sensors */
157 int xy_acc[ATP_XSENSORS + ATP_YSENSORS];
158 int datalen; /* size of an USB urb transfer */
159 int idlecount; /* number of empty packets */
160 struct work_struct work;
161 };
162
163 #define dbg_dump(msg, tab) \
164 if (debug > 1) { \
165 int i; \
166 printk("appletouch: %s %lld", msg, (long long)jiffies); \
167 for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) \
168 printk(" %02x", tab[i]); \
169 printk("\n"); \
170 }
171
172 #define dprintk(format, a...) \
173 do { \
174 if (debug) printk(KERN_DEBUG format, ##a); \
175 } while (0)
176
177 MODULE_AUTHOR("Johannes Berg, Stelian Pop, Frank Arnold, Michael Hanselmann");
178 MODULE_DESCRIPTION("Apple PowerBooks USB touchpad driver");
179 MODULE_LICENSE("GPL");
180
181 /*
182 * Make the threshold a module parameter
183 */
184 static int threshold = ATP_THRESHOLD;
185 module_param(threshold, int, 0644);
186 MODULE_PARM_DESC(threshold, "Discards any change in data from a sensor (trackpad has hundreds of these sensors) less than this value");
187
188 static int debug = 1;
189 module_param(debug, int, 0644);
190 MODULE_PARM_DESC(debug, "Activate debugging output");
191
192 static inline int atp_is_fountain(struct atp *dev)
193 {
194 u16 productId = le16_to_cpu(dev->udev->descriptor.idProduct);
195
196 return productId == FOUNTAIN_ANSI_PRODUCT_ID ||
197 productId == FOUNTAIN_ISO_PRODUCT_ID ||
198 productId == FOUNTAIN_TP_ONLY_PRODUCT_ID;
199 }
200
201 /* Checks if the device a Geyser 2 (ANSI, ISO, JIS) */
202 static inline int atp_is_geyser_2(struct atp *dev)
203 {
204 u16 productId = le16_to_cpu(dev->udev->descriptor.idProduct);
205
206 return (productId == GEYSER_ANSI_PRODUCT_ID) ||
207 (productId == GEYSER_ISO_PRODUCT_ID) ||
208 (productId == GEYSER_JIS_PRODUCT_ID);
209 }
210
211 static inline int atp_is_geyser_3(struct atp *dev)
212 {
213 u16 productId = le16_to_cpu(dev->udev->descriptor.idProduct);
214
215 return (productId == GEYSER3_ANSI_PRODUCT_ID) ||
216 (productId == GEYSER3_ISO_PRODUCT_ID) ||
217 (productId == GEYSER3_JIS_PRODUCT_ID) ||
218 (productId == GEYSER4_ANSI_PRODUCT_ID) ||
219 (productId == GEYSER4_ISO_PRODUCT_ID) ||
220 (productId == GEYSER4_JIS_PRODUCT_ID);
221 }
222
223 /*
224 * By default newer Geyser devices send standard USB HID mouse
225 * packets (Report ID 2). This code changes device mode, so it
226 * sends raw sensor reports (Report ID 5).
227 */
228 static int atp_geyser_init(struct usb_device *udev)
229 {
230 char data[8];
231 int size;
232
233 size = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
234 ATP_GEYSER_MODE_READ_REQUEST_ID,
235 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
236 ATP_GEYSER_MODE_REQUEST_VALUE,
237 ATP_GEYSER_MODE_REQUEST_INDEX, &data, 8, 5000);
238
239 if (size != 8) {
240 err("Could not do mode read request from device"
241 " (Geyser Raw mode)");
242 return -EIO;
243 }
244
245 /* Apply the mode switch */
246 data[0] = ATP_GEYSER_MODE_VENDOR_VALUE;
247
248 size = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
249 ATP_GEYSER_MODE_WRITE_REQUEST_ID,
250 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
251 ATP_GEYSER_MODE_REQUEST_VALUE,
252 ATP_GEYSER_MODE_REQUEST_INDEX, &data, 8, 5000);
253
254 if (size != 8) {
255 err("Could not do mode write request to device"
256 " (Geyser Raw mode)");
257 return -EIO;
258 }
259 return 0;
260 }
261
262 /*
263 * Reinitialise the device. This usually stops stream of empty packets
264 * coming from it.
265 */
266 static void atp_reinit(struct work_struct *work)
267 {
268 struct atp *dev = container_of(work, struct atp, work);
269 struct usb_device *udev = dev->udev;
270 int retval;
271
272 dev->idlecount = 0;
273
274 atp_geyser_init(udev);
275
276 retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
277 if (retval) {
278 err("%s - usb_submit_urb failed with result %d",
279 __FUNCTION__, retval);
280 }
281 }
282
283 static int atp_calculate_abs(int *xy_sensors, int nb_sensors, int fact,
284 int *z, int *fingers)
285 {
286 int i;
287 /* values to calculate mean */
288 int pcum = 0, psum = 0;
289 int is_increasing = 0;
290
291 *fingers = 0;
292
293 for (i = 0; i < nb_sensors; i++) {
294 if (xy_sensors[i] < threshold) {
295 if (is_increasing)
296 is_increasing = 0;
297
298 continue;
299 }
300
301 /*
302 * Makes the finger detection more versatile. For example,
303 * two fingers with no gap will be detected. Also, my
304 * tests show it less likely to have intermittent loss
305 * of multiple finger readings while moving around (scrolling).
306 *
307 * Changes the multiple finger detection to counting humps on
308 * sensors (transitions from nonincreasing to increasing)
309 * instead of counting transitions from low sensors (no
310 * finger reading) to high sensors (finger above
311 * sensor)
312 *
313 * - Jason Parekh <jasonparekh@gmail.com>
314 */
315 if (i < 1 || (!is_increasing && xy_sensors[i - 1] < xy_sensors[i])) {
316 (*fingers)++;
317 is_increasing = 1;
318 } else if (i > 0 && xy_sensors[i - 1] >= xy_sensors[i]) {
319 is_increasing = 0;
320 }
321
322 /*
323 * Subtracts threshold so a high sensor that just passes the threshold
324 * won't skew the calculated absolute coordinate. Fixes an issue
325 * where slowly moving the mouse would occassionaly jump a number of
326 * pixels (let me restate--slowly moving the mouse makes this issue
327 * most apparent).
328 */
329 pcum += (xy_sensors[i] - threshold) * i;
330 psum += (xy_sensors[i] - threshold);
331 }
332
333 if (psum > 0) {
334 *z = psum;
335 return pcum * fact / psum;
336 }
337
338 return 0;
339 }
340
341 static inline void atp_report_fingers(struct input_dev *input, int fingers)
342 {
343 input_report_key(input, BTN_TOOL_FINGER, fingers == 1);
344 input_report_key(input, BTN_TOOL_DOUBLETAP, fingers == 2);
345 input_report_key(input, BTN_TOOL_TRIPLETAP, fingers > 2);
346 }
347
348 static void atp_complete(struct urb* urb)
349 {
350 int x, y, x_z, y_z, x_f, y_f;
351 int retval, i, j;
352 int key;
353 struct atp *dev = urb->context;
354
355 switch (urb->status) {
356 case 0:
357 /* success */
358 break;
359 case -EOVERFLOW:
360 if(!dev->overflowwarn) {
361 printk(KERN_WARNING "appletouch: OVERFLOW with data "
362 "length %d, actual length is %d\n",
363 dev->datalen, dev->urb->actual_length);
364 dev->overflowwarn = 1;
365 }
366 case -ECONNRESET:
367 case -ENOENT:
368 case -ESHUTDOWN:
369 /* This urb is terminated, clean up */
370 dbg("%s - urb shutting down with status: %d",
371 __FUNCTION__, urb->status);
372 return;
373 default:
374 dbg("%s - nonzero urb status received: %d",
375 __FUNCTION__, urb->status);
376 goto exit;
377 }
378
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 goto exit;
385 }
386
387 /* reorder the sensors values */
388 if (atp_is_geyser_3(dev)) {
389 memset(dev->xy_cur, 0, sizeof(dev->xy_cur));
390
391 /*
392 * The values are laid out like this:
393 * -, Y1, Y2, -, Y3, Y4, -, ..., -, X1, X2, -, X3, X4, ...
394 * '-' is an unused value.
395 */
396
397 /* read X values */
398 for (i = 0, j = 19; i < 20; i += 2, j += 3) {
399 dev->xy_cur[i] = dev->data[j + 1];
400 dev->xy_cur[i + 1] = dev->data[j + 2];
401 }
402 /* read Y values */
403 for (i = 0, j = 1; i < 9; i += 2, j += 3) {
404 dev->xy_cur[ATP_XSENSORS + i] = dev->data[j + 1];
405 dev->xy_cur[ATP_XSENSORS + i + 1] = dev->data[j + 2];
406 }
407 } else if (atp_is_geyser_2(dev)) {
408 memset(dev->xy_cur, 0, sizeof(dev->xy_cur));
409
410 /*
411 * The values are laid out like this:
412 * Y1, Y2, -, Y3, Y4, -, ..., X1, X2, -, X3, X4, -, ...
413 * '-' is an unused value.
414 */
415
416 /* read X values */
417 for (i = 0, j = 19; i < 20; i += 2, j += 3) {
418 dev->xy_cur[i] = dev->data[j];
419 dev->xy_cur[i + 1] = dev->data[j + 1];
420 }
421
422 /* read Y values */
423 for (i = 0, j = 1; i < 9; i += 2, j += 3) {
424 dev->xy_cur[ATP_XSENSORS + i] = dev->data[j];
425 dev->xy_cur[ATP_XSENSORS + i + 1] = dev->data[j + 1];
426 }
427 } else {
428 for (i = 0; i < 8; i++) {
429 /* X values */
430 dev->xy_cur[i ] = dev->data[5 * i + 2];
431 dev->xy_cur[i + 8] = dev->data[5 * i + 4];
432 dev->xy_cur[i + 16] = dev->data[5 * i + 42];
433 if (i < 2)
434 dev->xy_cur[i + 24] = dev->data[5 * i + 44];
435
436 /* Y values */
437 dev->xy_cur[i + 26] = dev->data[5 * i + 1];
438 dev->xy_cur[i + 34] = dev->data[5 * i + 3];
439 }
440 }
441
442 dbg_dump("sample", dev->xy_cur);
443
444 if (!dev->valid) {
445 /* first sample */
446 dev->valid = 1;
447 dev->x_old = dev->y_old = -1;
448 memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
449
450 if (dev->size_detect_done ||
451 atp_is_geyser_3(dev)) /* No 17" Macbooks (yet) */
452 goto exit;
453
454 /* 17" Powerbooks have extra X sensors */
455 for (i = (atp_is_geyser_2(dev) ? 15 : 16); i < ATP_XSENSORS; i++) {
456 if (!dev->xy_cur[i])
457 continue;
458
459 printk(KERN_INFO "appletouch: 17\" model detected.\n");
460 if (atp_is_geyser_2(dev))
461 input_set_abs_params(dev->input, ABS_X, 0,
462 (20 - 1) *
463 ATP_XFACT - 1,
464 ATP_FUZZ, 0);
465 else
466 input_set_abs_params(dev->input, ABS_X, 0,
467 (ATP_XSENSORS - 1) *
468 ATP_XFACT - 1,
469 ATP_FUZZ, 0);
470 break;
471 }
472
473 dev->size_detect_done = 1;
474 goto exit;
475 }
476
477 for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) {
478 /* accumulate the change */
479 signed char change = dev->xy_old[i] - dev->xy_cur[i];
480 dev->xy_acc[i] -= change;
481
482 /* prevent down drifting */
483 if (dev->xy_acc[i] < 0)
484 dev->xy_acc[i] = 0;
485 }
486
487 memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
488
489 dbg_dump("accumulator", dev->xy_acc);
490
491 x = atp_calculate_abs(dev->xy_acc, ATP_XSENSORS,
492 ATP_XFACT, &x_z, &x_f);
493 y = atp_calculate_abs(dev->xy_acc + ATP_XSENSORS, ATP_YSENSORS,
494 ATP_YFACT, &y_z, &y_f);
495 key = dev->data[dev->datalen - 1] & 1;
496
497 if (x && y) {
498 if (dev->x_old != -1) {
499 x = (dev->x_old * 3 + x) >> 2;
500 y = (dev->y_old * 3 + y) >> 2;
501 dev->x_old = x;
502 dev->y_old = y;
503
504 if (debug > 1)
505 printk(KERN_DEBUG "appletouch: X: %3d Y: %3d "
506 "Xz: %3d Yz: %3d\n",
507 x, y, x_z, y_z);
508
509 input_report_key(dev->input, BTN_TOUCH, 1);
510 input_report_abs(dev->input, ABS_X, x);
511 input_report_abs(dev->input, ABS_Y, y);
512 input_report_abs(dev->input, ABS_PRESSURE,
513 min(ATP_PRESSURE, x_z + y_z));
514 atp_report_fingers(dev->input, max(x_f, y_f));
515 }
516 dev->x_old = x;
517 dev->y_old = y;
518
519 } else if (!x && !y) {
520
521 dev->x_old = dev->y_old = -1;
522 input_report_key(dev->input, BTN_TOUCH, 0);
523 input_report_abs(dev->input, ABS_PRESSURE, 0);
524 atp_report_fingers(dev->input, 0);
525
526 /* reset the accumulator on release */
527 memset(dev->xy_acc, 0, sizeof(dev->xy_acc));
528 }
529
530 input_report_key(dev->input, BTN_LEFT, key);
531 input_sync(dev->input);
532
533 /*
534 * Many Geysers will continue to send packets continually after
535 * the first touch unless reinitialised. Do so if it's been
536 * idle for a while in order to avoid waking the kernel up
537 * several hundred times a second. Re-initialization does not
538 * work on Fountain touchpads.
539 */
540 if (!atp_is_fountain(dev)) {
541 if (!x && !y && !key) {
542 dev->idlecount++;
543 if (dev->idlecount == 10) {
544 dev->valid = 0;
545 schedule_work(&dev->work);
546 /* Don't resubmit urb here, wait for reinit */
547 return;
548 }
549 } else
550 dev->idlecount = 0;
551 }
552
553 exit:
554 retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
555 if (retval) {
556 err("%s - usb_submit_urb failed with result %d",
557 __FUNCTION__, retval);
558 }
559 }
560
561 static int atp_open(struct input_dev *input)
562 {
563 struct atp *dev = input_get_drvdata(input);
564
565 if (usb_submit_urb(dev->urb, GFP_ATOMIC))
566 return -EIO;
567
568 dev->open = 1;
569 return 0;
570 }
571
572 static void atp_close(struct input_dev *input)
573 {
574 struct atp *dev = input_get_drvdata(input);
575
576 usb_kill_urb(dev->urb);
577 cancel_work_sync(&dev->work);
578 dev->open = 0;
579 }
580
581 static int atp_probe(struct usb_interface *iface, const struct usb_device_id *id)
582 {
583 struct atp *dev;
584 struct input_dev *input_dev;
585 struct usb_device *udev = interface_to_usbdev(iface);
586 struct usb_host_interface *iface_desc;
587 struct usb_endpoint_descriptor *endpoint;
588 int int_in_endpointAddr = 0;
589 int i, error = -ENOMEM;
590
591 /* set up the endpoint information */
592 /* use only the first interrupt-in endpoint */
593 iface_desc = iface->cur_altsetting;
594 for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
595 endpoint = &iface_desc->endpoint[i].desc;
596 if (!int_in_endpointAddr && usb_endpoint_is_int_in(endpoint)) {
597 /* we found an interrupt in endpoint */
598 int_in_endpointAddr = endpoint->bEndpointAddress;
599 break;
600 }
601 }
602 if (!int_in_endpointAddr) {
603 err("Could not find int-in endpoint");
604 return -EIO;
605 }
606
607 /* allocate memory for our device state and initialize it */
608 dev = kzalloc(sizeof(struct atp), GFP_KERNEL);
609 input_dev = input_allocate_device();
610 if (!dev || !input_dev) {
611 err("Out of memory");
612 goto err_free_devs;
613 }
614
615 dev->udev = udev;
616 dev->input = input_dev;
617 dev->overflowwarn = 0;
618 if (atp_is_geyser_3(dev))
619 dev->datalen = 64;
620 else if (atp_is_geyser_2(dev))
621 dev->datalen = 64;
622 else
623 dev->datalen = 81;
624
625 if (!atp_is_fountain(dev)) {
626 /* switch to raw sensor mode */
627 if (atp_geyser_init(udev))
628 goto err_free_devs;
629
630 printk(KERN_INFO "appletouch: Geyser mode initialized.\n");
631 }
632
633 dev->urb = usb_alloc_urb(0, GFP_KERNEL);
634 if (!dev->urb)
635 goto err_free_devs;
636
637 dev->data = usb_buffer_alloc(dev->udev, dev->datalen, GFP_KERNEL,
638 &dev->urb->transfer_dma);
639 if (!dev->data)
640 goto err_free_urb;
641
642 usb_fill_int_urb(dev->urb, udev,
643 usb_rcvintpipe(udev, int_in_endpointAddr),
644 dev->data, dev->datalen, atp_complete, dev, 1);
645
646 usb_make_path(udev, dev->phys, sizeof(dev->phys));
647 strlcat(dev->phys, "/input0", sizeof(dev->phys));
648
649 input_dev->name = "appletouch";
650 input_dev->phys = dev->phys;
651 usb_to_input_id(dev->udev, &input_dev->id);
652 input_dev->dev.parent = &iface->dev;
653
654 input_set_drvdata(input_dev, dev);
655
656 input_dev->open = atp_open;
657 input_dev->close = atp_close;
658
659 set_bit(EV_ABS, input_dev->evbit);
660
661 if (atp_is_geyser_3(dev)) {
662 /*
663 * MacBook have 20 X sensors, 10 Y sensors
664 */
665 input_set_abs_params(input_dev, ABS_X, 0,
666 ((20 - 1) * ATP_XFACT) - 1, ATP_FUZZ, 0);
667 input_set_abs_params(input_dev, ABS_Y, 0,
668 ((10 - 1) * ATP_YFACT) - 1, ATP_FUZZ, 0);
669 } else if (atp_is_geyser_2(dev)) {
670 /*
671 * Oct 2005 15" PowerBooks have 15 X sensors, 17" are detected
672 * later.
673 */
674 input_set_abs_params(input_dev, ABS_X, 0,
675 ((15 - 1) * ATP_XFACT) - 1, ATP_FUZZ, 0);
676 input_set_abs_params(input_dev, ABS_Y, 0,
677 ((9 - 1) * ATP_YFACT) - 1, ATP_FUZZ, 0);
678 } else {
679 /*
680 * 12" and 15" Powerbooks only have 16 x sensors,
681 * 17" models are detected later.
682 */
683 input_set_abs_params(input_dev, ABS_X, 0,
684 (16 - 1) * ATP_XFACT - 1, ATP_FUZZ, 0);
685 input_set_abs_params(input_dev, ABS_Y, 0,
686 (ATP_YSENSORS - 1) * ATP_YFACT - 1, ATP_FUZZ, 0);
687 }
688 input_set_abs_params(input_dev, ABS_PRESSURE, 0, ATP_PRESSURE, 0, 0);
689
690 set_bit(EV_KEY, input_dev->evbit);
691 set_bit(BTN_TOUCH, input_dev->keybit);
692 set_bit(BTN_TOOL_FINGER, input_dev->keybit);
693 set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit);
694 set_bit(BTN_TOOL_TRIPLETAP, input_dev->keybit);
695 set_bit(BTN_LEFT, input_dev->keybit);
696
697 error = input_register_device(dev->input);
698 if (error)
699 goto err_free_buffer;
700
701 /* save our data pointer in this interface device */
702 usb_set_intfdata(iface, dev);
703
704 INIT_WORK(&dev->work, atp_reinit);
705
706 return 0;
707
708 err_free_buffer:
709 usb_buffer_free(dev->udev, dev->datalen,
710 dev->data, dev->urb->transfer_dma);
711 err_free_urb:
712 usb_free_urb(dev->urb);
713 err_free_devs:
714 usb_set_intfdata(iface, NULL);
715 kfree(dev);
716 input_free_device(input_dev);
717 return error;
718 }
719
720 static void atp_disconnect(struct usb_interface *iface)
721 {
722 struct atp *dev = usb_get_intfdata(iface);
723
724 usb_set_intfdata(iface, NULL);
725 if (dev) {
726 usb_kill_urb(dev->urb);
727 input_unregister_device(dev->input);
728 usb_buffer_free(dev->udev, dev->datalen,
729 dev->data, dev->urb->transfer_dma);
730 usb_free_urb(dev->urb);
731 kfree(dev);
732 }
733 printk(KERN_INFO "input: appletouch disconnected\n");
734 }
735
736 static int atp_suspend(struct usb_interface *iface, pm_message_t message)
737 {
738 struct atp *dev = usb_get_intfdata(iface);
739
740 usb_kill_urb(dev->urb);
741 dev->valid = 0;
742
743 return 0;
744 }
745
746 static int atp_resume(struct usb_interface *iface)
747 {
748 struct atp *dev = usb_get_intfdata(iface);
749
750 if (dev->open && usb_submit_urb(dev->urb, GFP_ATOMIC))
751 return -EIO;
752
753 return 0;
754 }
755
756 static struct usb_driver atp_driver = {
757 .name = "appletouch",
758 .probe = atp_probe,
759 .disconnect = atp_disconnect,
760 .suspend = atp_suspend,
761 .resume = atp_resume,
762 .id_table = atp_table,
763 };
764
765 static int __init atp_init(void)
766 {
767 return usb_register(&atp_driver);
768 }
769
770 static void __exit atp_exit(void)
771 {
772 usb_deregister(&atp_driver);
773 }
774
775 module_init(atp_init);
776 module_exit(atp_exit);
WRT350N Kernel Patches