Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
appletouch.c
Go to the documentation of this file.
1 /*
2  * Apple USB Touchpad (for post-February 2005 PowerBooks and MacBooks) driver
3  *
4  * Copyright (C) 2001-2004 Greg Kroah-Hartman ([email protected])
5  * Copyright (C) 2005-2008 Johannes Berg ([email protected])
6  * Copyright (C) 2005-2008 Stelian Pop ([email protected])
7  * Copyright (C) 2005 Frank Arnold ([email protected])
8  * Copyright (C) 2005 Peter Osterlund ([email protected])
9  * Copyright (C) 2005 Michael Hanselmann ([email protected])
10  * Copyright (C) 2006 Nicolas Boichat ([email protected])
11  * Copyright (C) 2007-2008 Sven Anders ([email protected])
12  *
13  * Thanks to Alex Harper <[email protected]> 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 
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 usb_interface *intf; /* usb interface */
199  struct urb *urb; /* usb request block */
200  u8 *data; /* transferred data */
201  struct input_dev *input; /* input dev */
202  const struct atp_info *info; /* touchpad model */
203  bool open;
204  bool valid; /* are the samples valid? */
207  int x_old; /* last reported x/y, */
208  int y_old; /* used for smoothing */
212  int idlecount; /* number of empty packets */
214 };
215 
216 #define dbg_dump(msg, tab) \
217  if (debug > 1) { \
218  int __i; \
219  printk(KERN_DEBUG "appletouch: %s", msg); \
220  for (__i = 0; __i < ATP_XSENSORS + ATP_YSENSORS; __i++) \
221  printk(" %02x", tab[__i]); \
222  printk("\n"); \
223  }
224 
225 #define dprintk(format, a...) \
226  do { \
227  if (debug) \
228  printk(KERN_DEBUG format, ##a); \
229  } while (0)
230 
231 MODULE_AUTHOR("Johannes Berg");
232 MODULE_AUTHOR("Stelian Pop");
233 MODULE_AUTHOR("Frank Arnold");
234 MODULE_AUTHOR("Michael Hanselmann");
235 MODULE_AUTHOR("Sven Anders");
236 MODULE_DESCRIPTION("Apple PowerBook and MacBook USB touchpad driver");
237 MODULE_LICENSE("GPL");
238 
239 /*
240  * Make the threshold a module parameter
241  */
242 static int threshold = ATP_THRESHOLD;
243 module_param(threshold, int, 0644);
244 MODULE_PARM_DESC(threshold, "Discard any change in data from a sensor"
245  " (the trackpad has many of these sensors)"
246  " less than this value.");
247 
248 static int debug;
249 module_param(debug, int, 0644);
250 MODULE_PARM_DESC(debug, "Activate debugging output");
251 
252 /*
253  * By default newer Geyser devices send standard USB HID mouse
254  * packets (Report ID 2). This code changes device mode, so it
255  * sends raw sensor reports (Report ID 5).
256  */
257 static int atp_geyser_init(struct atp *dev)
258 {
259  struct usb_device *udev = dev->udev;
260  char *data;
261  int size;
262  int i;
263  int ret;
264 
265  data = kmalloc(8, GFP_KERNEL);
266  if (!data) {
267  dev_err(&dev->intf->dev, "Out of memory\n");
268  return -ENOMEM;
269  }
270 
271  size = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
275  ATP_GEYSER_MODE_REQUEST_INDEX, data, 8, 5000);
276 
277  if (size != 8) {
278  dprintk("atp_geyser_init: read error\n");
279  for (i = 0; i < 8; i++)
280  dprintk("appletouch[%d]: %d\n", i, data[i]);
281 
282  dev_err(&dev->intf->dev, "Failed to read mode from device.\n");
283  ret = -EIO;
284  goto out_free;
285  }
286 
287  /* Apply the mode switch */
289 
290  size = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
294  ATP_GEYSER_MODE_REQUEST_INDEX, data, 8, 5000);
295 
296  if (size != 8) {
297  dprintk("atp_geyser_init: write error\n");
298  for (i = 0; i < 8; i++)
299  dprintk("appletouch[%d]: %d\n", i, data[i]);
300 
301  dev_err(&dev->intf->dev, "Failed to request geyser raw mode\n");
302  ret = -EIO;
303  goto out_free;
304  }
305  ret = 0;
306 out_free:
307  kfree(data);
308  return ret;
309 }
310 
311 /*
312  * Reinitialise the device. This usually stops stream of empty packets
313  * coming from it.
314  */
315 static void atp_reinit(struct work_struct *work)
316 {
317  struct atp *dev = container_of(work, struct atp, work);
318  int retval;
319 
320  dprintk("appletouch: putting appletouch to sleep (reinit)\n");
321  atp_geyser_init(dev);
322 
323  retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
324  if (retval)
325  dev_err(&dev->intf->dev,
326  "atp_reinit: usb_submit_urb failed with error %d\n",
327  retval);
328 }
329 
330 static int atp_calculate_abs(int *xy_sensors, int nb_sensors, int fact,
331  int *z, int *fingers)
332 {
333  int i;
334  /* values to calculate mean */
335  int pcum = 0, psum = 0;
336  int is_increasing = 0;
337 
338  *fingers = 0;
339 
340  for (i = 0; i < nb_sensors; i++) {
341  if (xy_sensors[i] < threshold) {
342  if (is_increasing)
343  is_increasing = 0;
344 
345  continue;
346  }
347 
348  /*
349  * Makes the finger detection more versatile. For example,
350  * two fingers with no gap will be detected. Also, my
351  * tests show it less likely to have intermittent loss
352  * of multiple finger readings while moving around (scrolling).
353  *
354  * Changes the multiple finger detection to counting humps on
355  * sensors (transitions from nonincreasing to increasing)
356  * instead of counting transitions from low sensors (no
357  * finger reading) to high sensors (finger above
358  * sensor)
359  *
360  * - Jason Parekh <[email protected]>
361  */
362  if (i < 1 ||
363  (!is_increasing && xy_sensors[i - 1] < xy_sensors[i])) {
364  (*fingers)++;
365  is_increasing = 1;
366  } else if (i > 0 && (xy_sensors[i - 1] - xy_sensors[i] > threshold)) {
367  is_increasing = 0;
368  }
369 
370  /*
371  * Subtracts threshold so a high sensor that just passes the
372  * threshold won't skew the calculated absolute coordinate.
373  * Fixes an issue where slowly moving the mouse would
374  * occasionally jump a number of pixels (slowly moving the
375  * finger makes this issue most apparent.)
376  */
377  pcum += (xy_sensors[i] - threshold) * i;
378  psum += (xy_sensors[i] - threshold);
379  }
380 
381  if (psum > 0) {
382  *z = psum;
383  return pcum * fact / psum;
384  }
385 
386  return 0;
387 }
388 
389 static inline void atp_report_fingers(struct input_dev *input, int fingers)
390 {
391  input_report_key(input, BTN_TOOL_FINGER, fingers == 1);
392  input_report_key(input, BTN_TOOL_DOUBLETAP, fingers == 2);
393  input_report_key(input, BTN_TOOL_TRIPLETAP, fingers > 2);
394 }
395 
396 /* Check URB status and for correct length of data package */
397 
398 #define ATP_URB_STATUS_SUCCESS 0
399 #define ATP_URB_STATUS_ERROR 1
400 #define ATP_URB_STATUS_ERROR_FATAL 2
401 
402 static int atp_status_check(struct urb *urb)
403 {
404  struct atp *dev = urb->context;
405  struct usb_interface *intf = dev->intf;
406 
407  switch (urb->status) {
408  case 0:
409  /* success */
410  break;
411  case -EOVERFLOW:
412  if (!dev->overflow_warned) {
413  dev_warn(&intf->dev,
414  "appletouch: OVERFLOW with data length %d, actual length is %d\n",
415  dev->info->datalen, dev->urb->actual_length);
416  dev->overflow_warned = true;
417  }
418  case -ECONNRESET:
419  case -ENOENT:
420  case -ESHUTDOWN:
421  /* This urb is terminated, clean up */
422  dev_dbg(&intf->dev,
423  "atp_complete: urb shutting down with status: %d\n",
424  urb->status);
426 
427  default:
428  dev_dbg(&intf->dev,
429  "atp_complete: nonzero urb status received: %d\n",
430  urb->status);
431  return ATP_URB_STATUS_ERROR;
432  }
433 
434  /* drop incomplete datasets */
435  if (dev->urb->actual_length != dev->info->datalen) {
436  dprintk("appletouch: incomplete data package"
437  " (first byte: %d, length: %d).\n",
438  dev->data[0], dev->urb->actual_length);
439  return ATP_URB_STATUS_ERROR;
440  }
441 
442  return ATP_URB_STATUS_SUCCESS;
443 }
444 
445 static void atp_detect_size(struct atp *dev)
446 {
447  int i;
448 
449  /* 17" Powerbooks have extra X sensors */
450  for (i = dev->info->xsensors; i < ATP_XSENSORS; i++) {
451  if (dev->xy_cur[i]) {
452 
453  dev_info(&dev->intf->dev,
454  "appletouch: 17\" model detected.\n");
455 
456  input_set_abs_params(dev->input, ABS_X, 0,
457  (dev->info->xsensors_17 - 1) *
458  dev->info->xfact - 1,
459  ATP_FUZZ, 0);
460  break;
461  }
462  }
463 }
464 
465 /*
466  * USB interrupt callback functions
467  */
468 
469 /* Interrupt function for older touchpads: FOUNTAIN/GEYSER1/GEYSER2 */
470 
471 static void atp_complete_geyser_1_2(struct urb *urb)
472 {
473  int x, y, x_z, y_z, x_f, y_f;
474  int retval, i, j;
475  int key;
476  struct atp *dev = urb->context;
477  int status = atp_status_check(urb);
478 
479  if (status == ATP_URB_STATUS_ERROR_FATAL)
480  return;
481  else if (status == ATP_URB_STATUS_ERROR)
482  goto exit;
483 
484  /* reorder the sensors values */
485  if (dev->info == &geyser2_info) {
486  memset(dev->xy_cur, 0, sizeof(dev->xy_cur));
487 
488  /*
489  * The values are laid out like this:
490  * Y1, Y2, -, Y3, Y4, -, ..., X1, X2, -, X3, X4, -, ...
491  * '-' is an unused value.
492  */
493 
494  /* read X values */
495  for (i = 0, j = 19; i < 20; i += 2, j += 3) {
496  dev->xy_cur[i] = dev->data[j];
497  dev->xy_cur[i + 1] = dev->data[j + 1];
498  }
499 
500  /* read Y values */
501  for (i = 0, j = 1; i < 9; i += 2, j += 3) {
502  dev->xy_cur[ATP_XSENSORS + i] = dev->data[j];
503  dev->xy_cur[ATP_XSENSORS + i + 1] = dev->data[j + 1];
504  }
505  } else {
506  for (i = 0; i < 8; i++) {
507  /* X values */
508  dev->xy_cur[i + 0] = dev->data[5 * i + 2];
509  dev->xy_cur[i + 8] = dev->data[5 * i + 4];
510  dev->xy_cur[i + 16] = dev->data[5 * i + 42];
511  if (i < 2)
512  dev->xy_cur[i + 24] = dev->data[5 * i + 44];
513 
514  /* Y values */
515  dev->xy_cur[ATP_XSENSORS + i] = dev->data[5 * i + 1];
516  dev->xy_cur[ATP_XSENSORS + i + 8] = dev->data[5 * i + 3];
517  }
518  }
519 
520  dbg_dump("sample", dev->xy_cur);
521 
522  if (!dev->valid) {
523  /* first sample */
524  dev->valid = true;
525  dev->x_old = dev->y_old = -1;
526 
527  /* Store first sample */
528  memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
529 
530  /* Perform size detection, if not done already */
531  if (unlikely(!dev->size_detect_done)) {
532  atp_detect_size(dev);
533  dev->size_detect_done = 1;
534  goto exit;
535  }
536  }
537 
538  for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) {
539  /* accumulate the change */
540  signed char change = dev->xy_old[i] - dev->xy_cur[i];
541  dev->xy_acc[i] -= change;
542 
543  /* prevent down drifting */
544  if (dev->xy_acc[i] < 0)
545  dev->xy_acc[i] = 0;
546  }
547 
548  memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
549 
550  dbg_dump("accumulator", dev->xy_acc);
551 
552  x = atp_calculate_abs(dev->xy_acc, ATP_XSENSORS,
553  dev->info->xfact, &x_z, &x_f);
554  y = atp_calculate_abs(dev->xy_acc + ATP_XSENSORS, ATP_YSENSORS,
555  dev->info->yfact, &y_z, &y_f);
556  key = dev->data[dev->info->datalen - 1] & ATP_STATUS_BUTTON;
557 
558  if (x && y) {
559  if (dev->x_old != -1) {
560  x = (dev->x_old * 3 + x) >> 2;
561  y = (dev->y_old * 3 + y) >> 2;
562  dev->x_old = x;
563  dev->y_old = y;
564 
565  if (debug > 1)
566  printk(KERN_DEBUG "appletouch: "
567  "X: %3d Y: %3d Xz: %3d Yz: %3d\n",
568  x, y, x_z, y_z);
569 
570  input_report_key(dev->input, BTN_TOUCH, 1);
571  input_report_abs(dev->input, ABS_X, x);
572  input_report_abs(dev->input, ABS_Y, y);
573  input_report_abs(dev->input, ABS_PRESSURE,
574  min(ATP_PRESSURE, x_z + y_z));
575  atp_report_fingers(dev->input, max(x_f, y_f));
576  }
577  dev->x_old = x;
578  dev->y_old = y;
579 
580  } else if (!x && !y) {
581 
582  dev->x_old = dev->y_old = -1;
583  input_report_key(dev->input, BTN_TOUCH, 0);
584  input_report_abs(dev->input, ABS_PRESSURE, 0);
585  atp_report_fingers(dev->input, 0);
586 
587  /* reset the accumulator on release */
588  memset(dev->xy_acc, 0, sizeof(dev->xy_acc));
589  }
590 
591  input_report_key(dev->input, BTN_LEFT, key);
592  input_sync(dev->input);
593 
594  exit:
595  retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
596  if (retval)
597  dev_err(&dev->intf->dev,
598  "atp_complete: usb_submit_urb failed with result %d\n",
599  retval);
600 }
601 
602 /* Interrupt function for older touchpads: GEYSER3/GEYSER4 */
603 
604 static void atp_complete_geyser_3_4(struct urb *urb)
605 {
606  int x, y, x_z, y_z, x_f, y_f;
607  int retval, i, j;
608  int key;
609  struct atp *dev = urb->context;
610  int status = atp_status_check(urb);
611 
612  if (status == ATP_URB_STATUS_ERROR_FATAL)
613  return;
614  else if (status == ATP_URB_STATUS_ERROR)
615  goto exit;
616 
617  /* Reorder the sensors values:
618  *
619  * The values are laid out like this:
620  * -, Y1, Y2, -, Y3, Y4, -, ..., -, X1, X2, -, X3, X4, ...
621  * '-' is an unused value.
622  */
623 
624  /* read X values */
625  for (i = 0, j = 19; i < 20; i += 2, j += 3) {
626  dev->xy_cur[i] = dev->data[j + 1];
627  dev->xy_cur[i + 1] = dev->data[j + 2];
628  }
629  /* read Y values */
630  for (i = 0, j = 1; i < 9; i += 2, j += 3) {
631  dev->xy_cur[ATP_XSENSORS + i] = dev->data[j + 1];
632  dev->xy_cur[ATP_XSENSORS + i + 1] = dev->data[j + 2];
633  }
634 
635  dbg_dump("sample", dev->xy_cur);
636 
637  /* Just update the base values (i.e. touchpad in untouched state) */
638  if (dev->data[dev->info->datalen - 1] & ATP_STATUS_BASE_UPDATE) {
639 
640  dprintk("appletouch: updated base values\n");
641 
642  memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
643  goto exit;
644  }
645 
646  for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) {
647  /* calculate the change */
648  dev->xy_acc[i] = dev->xy_cur[i] - dev->xy_old[i];
649 
650  /* this is a round-robin value, so couple with that */
651  if (dev->xy_acc[i] > 127)
652  dev->xy_acc[i] -= 256;
653 
654  if (dev->xy_acc[i] < -127)
655  dev->xy_acc[i] += 256;
656 
657  /* prevent down drifting */
658  if (dev->xy_acc[i] < 0)
659  dev->xy_acc[i] = 0;
660  }
661 
662  dbg_dump("accumulator", dev->xy_acc);
663 
664  x = atp_calculate_abs(dev->xy_acc, ATP_XSENSORS,
665  dev->info->xfact, &x_z, &x_f);
666  y = atp_calculate_abs(dev->xy_acc + ATP_XSENSORS, ATP_YSENSORS,
667  dev->info->yfact, &y_z, &y_f);
668  key = dev->data[dev->info->datalen - 1] & ATP_STATUS_BUTTON;
669 
670  if (x && y) {
671  if (dev->x_old != -1) {
672  x = (dev->x_old * 3 + x) >> 2;
673  y = (dev->y_old * 3 + y) >> 2;
674  dev->x_old = x;
675  dev->y_old = y;
676 
677  if (debug > 1)
678  printk(KERN_DEBUG "appletouch: X: %3d Y: %3d "
679  "Xz: %3d Yz: %3d\n",
680  x, y, x_z, y_z);
681 
682  input_report_key(dev->input, BTN_TOUCH, 1);
683  input_report_abs(dev->input, ABS_X, x);
684  input_report_abs(dev->input, ABS_Y, y);
685  input_report_abs(dev->input, ABS_PRESSURE,
686  min(ATP_PRESSURE, x_z + y_z));
687  atp_report_fingers(dev->input, max(x_f, y_f));
688  }
689  dev->x_old = x;
690  dev->y_old = y;
691 
692  } else if (!x && !y) {
693 
694  dev->x_old = dev->y_old = -1;
695  input_report_key(dev->input, BTN_TOUCH, 0);
696  input_report_abs(dev->input, ABS_PRESSURE, 0);
697  atp_report_fingers(dev->input, 0);
698 
699  /* reset the accumulator on release */
700  memset(dev->xy_acc, 0, sizeof(dev->xy_acc));
701  }
702 
703  input_report_key(dev->input, BTN_LEFT, key);
704  input_sync(dev->input);
705 
706  /*
707  * Geysers 3/4 will continue to send packets continually after
708  * the first touch unless reinitialised. Do so if it's been
709  * idle for a while in order to avoid waking the kernel up
710  * several hundred times a second.
711  */
712 
713  /*
714  * Button must not be pressed when entering suspend,
715  * otherwise we will never release the button.
716  */
717  if (!x && !y && !key) {
718  dev->idlecount++;
719  if (dev->idlecount == 10) {
720  dev->x_old = dev->y_old = -1;
721  dev->idlecount = 0;
722  schedule_work(&dev->work);
723  /* Don't resubmit urb here, wait for reinit */
724  return;
725  }
726  } else
727  dev->idlecount = 0;
728 
729  exit:
730  retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
731  if (retval)
732  dev_err(&dev->intf->dev,
733  "atp_complete: usb_submit_urb failed with result %d\n",
734  retval);
735 }
736 
737 static int atp_open(struct input_dev *input)
738 {
739  struct atp *dev = input_get_drvdata(input);
740 
741  if (usb_submit_urb(dev->urb, GFP_ATOMIC))
742  return -EIO;
743 
744  dev->open = 1;
745  return 0;
746 }
747 
748 static void atp_close(struct input_dev *input)
749 {
750  struct atp *dev = input_get_drvdata(input);
751 
752  usb_kill_urb(dev->urb);
753  cancel_work_sync(&dev->work);
754  dev->open = 0;
755 }
756 
757 static int atp_handle_geyser(struct atp *dev)
758 {
759  if (dev->info != &fountain_info) {
760  /* switch to raw sensor mode */
761  if (atp_geyser_init(dev))
762  return -EIO;
763 
764  dev_info(&dev->intf->dev, "Geyser mode initialized.\n");
765  }
766 
767  return 0;
768 }
769 
770 static int atp_probe(struct usb_interface *iface,
771  const struct usb_device_id *id)
772 {
773  struct atp *dev;
774  struct input_dev *input_dev;
775  struct usb_device *udev = interface_to_usbdev(iface);
776  struct usb_host_interface *iface_desc;
778  int int_in_endpointAddr = 0;
779  int i, error = -ENOMEM;
780  const struct atp_info *info = (const struct atp_info *)id->driver_info;
781 
782  /* set up the endpoint information */
783  /* use only the first interrupt-in endpoint */
784  iface_desc = iface->cur_altsetting;
785  for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
786  endpoint = &iface_desc->endpoint[i].desc;
787  if (!int_in_endpointAddr && usb_endpoint_is_int_in(endpoint)) {
788  /* we found an interrupt in endpoint */
789  int_in_endpointAddr = endpoint->bEndpointAddress;
790  break;
791  }
792  }
793  if (!int_in_endpointAddr) {
794  dev_err(&iface->dev, "Could not find int-in endpoint\n");
795  return -EIO;
796  }
797 
798  /* allocate memory for our device state and initialize it */
799  dev = kzalloc(sizeof(struct atp), GFP_KERNEL);
800  input_dev = input_allocate_device();
801  if (!dev || !input_dev) {
802  dev_err(&iface->dev, "Out of memory\n");
803  goto err_free_devs;
804  }
805 
806  dev->udev = udev;
807  dev->intf = iface;
808  dev->input = input_dev;
809  dev->info = info;
810  dev->overflow_warned = false;
811 
812  dev->urb = usb_alloc_urb(0, GFP_KERNEL);
813  if (!dev->urb)
814  goto err_free_devs;
815 
816  dev->data = usb_alloc_coherent(dev->udev, dev->info->datalen, GFP_KERNEL,
817  &dev->urb->transfer_dma);
818  if (!dev->data)
819  goto err_free_urb;
820 
821  usb_fill_int_urb(dev->urb, udev,
822  usb_rcvintpipe(udev, int_in_endpointAddr),
823  dev->data, dev->info->datalen,
824  dev->info->callback, dev, 1);
825 
826  error = atp_handle_geyser(dev);
827  if (error)
828  goto err_free_buffer;
829 
830  usb_make_path(udev, dev->phys, sizeof(dev->phys));
831  strlcat(dev->phys, "/input0", sizeof(dev->phys));
832 
833  input_dev->name = "appletouch";
834  input_dev->phys = dev->phys;
835  usb_to_input_id(dev->udev, &input_dev->id);
836  input_dev->dev.parent = &iface->dev;
837 
838  input_set_drvdata(input_dev, dev);
839 
840  input_dev->open = atp_open;
841  input_dev->close = atp_close;
842 
843  set_bit(EV_ABS, input_dev->evbit);
844 
845  input_set_abs_params(input_dev, ABS_X, 0,
846  (dev->info->xsensors - 1) * dev->info->xfact - 1,
847  ATP_FUZZ, 0);
848  input_set_abs_params(input_dev, ABS_Y, 0,
849  (dev->info->ysensors - 1) * dev->info->yfact - 1,
850  ATP_FUZZ, 0);
851  input_set_abs_params(input_dev, ABS_PRESSURE, 0, ATP_PRESSURE, 0, 0);
852 
853  set_bit(EV_KEY, input_dev->evbit);
854  set_bit(BTN_TOUCH, input_dev->keybit);
855  set_bit(BTN_TOOL_FINGER, input_dev->keybit);
856  set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit);
857  set_bit(BTN_TOOL_TRIPLETAP, input_dev->keybit);
858  set_bit(BTN_LEFT, input_dev->keybit);
859 
860  error = input_register_device(dev->input);
861  if (error)
862  goto err_free_buffer;
863 
864  /* save our data pointer in this interface device */
865  usb_set_intfdata(iface, dev);
866 
867  INIT_WORK(&dev->work, atp_reinit);
868 
869  return 0;
870 
871  err_free_buffer:
872  usb_free_coherent(dev->udev, dev->info->datalen,
873  dev->data, dev->urb->transfer_dma);
874  err_free_urb:
875  usb_free_urb(dev->urb);
876  err_free_devs:
877  usb_set_intfdata(iface, NULL);
878  kfree(dev);
879  input_free_device(input_dev);
880  return error;
881 }
882 
883 static void atp_disconnect(struct usb_interface *iface)
884 {
885  struct atp *dev = usb_get_intfdata(iface);
886 
887  usb_set_intfdata(iface, NULL);
888  if (dev) {
889  usb_kill_urb(dev->urb);
890  input_unregister_device(dev->input);
891  usb_free_coherent(dev->udev, dev->info->datalen,
892  dev->data, dev->urb->transfer_dma);
893  usb_free_urb(dev->urb);
894  kfree(dev);
895  }
896  dev_info(&iface->dev, "input: appletouch disconnected\n");
897 }
898 
899 static int atp_recover(struct atp *dev)
900 {
901  int error;
902 
903  error = atp_handle_geyser(dev);
904  if (error)
905  return error;
906 
907  if (dev->open && usb_submit_urb(dev->urb, GFP_ATOMIC))
908  return -EIO;
909 
910  return 0;
911 }
912 
913 static int atp_suspend(struct usb_interface *iface, pm_message_t message)
914 {
915  struct atp *dev = usb_get_intfdata(iface);
916 
917  usb_kill_urb(dev->urb);
918  return 0;
919 }
920 
921 static int atp_resume(struct usb_interface *iface)
922 {
923  struct atp *dev = usb_get_intfdata(iface);
924 
925  if (dev->open && usb_submit_urb(dev->urb, GFP_ATOMIC))
926  return -EIO;
927 
928  return 0;
929 }
930 
931 static int atp_reset_resume(struct usb_interface *iface)
932 {
933  struct atp *dev = usb_get_intfdata(iface);
934 
935  return atp_recover(dev);
936 }
937 
938 static struct usb_driver atp_driver = {
939  .name = "appletouch",
940  .probe = atp_probe,
941  .disconnect = atp_disconnect,
942  .suspend = atp_suspend,
943  .resume = atp_resume,
944  .reset_resume = atp_reset_resume,
945  .id_table = atp_table,
946 };
947 
948 module_usb_driver(atp_driver);