Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/drivers/input/mouse/appletouch.c

  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/slab.h>
 34 #include <linux/module.h>
 35 #include <linux/usb/input.h>
 36 
 37 /*
 38  * Note: We try to keep the touchpad aspect ratio while still doing only
 39  * simple arithmetics:
 40  *      0 <= x <= (xsensors - 1) * xfact
 41  *      0 <= y <= (ysensors - 1) * yfact
 42  */
 43 struct atp_info {
 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 */
 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         .fuzz           = 16,
 66 };
 67 
 68 static const struct atp_info geyser1_info = {
 69         .xsensors       = 16,
 70         .xsensors_17    = 26,
 71         .ysensors       = 16,
 72         .xfact          = 64,
 73         .yfact          = 43,
 74         .datalen        = 81,
 75         .callback       = atp_complete_geyser_1_2,
 76         .fuzz           = 16,
 77 };
 78 
 79 static const struct atp_info geyser2_info = {
 80         .xsensors       = 15,
 81         .xsensors_17    = 20,
 82         .ysensors       = 9,
 83         .xfact          = 64,
 84         .yfact          = 43,
 85         .datalen        = 64,
 86         .callback       = atp_complete_geyser_1_2,
 87         .fuzz           = 0,
 88 };
 89 
 90 static const struct atp_info geyser3_info = {
 91         .xsensors       = 20,
 92         .ysensors       = 10,
 93         .xfact          = 64,
 94         .yfact          = 64,
 95         .datalen        = 64,
 96         .callback       = atp_complete_geyser_3_4,
 97         .fuzz           = 0,
 98 };
 99 
100 static const struct atp_info geyser4_info = {
101         .xsensors       = 20,
102         .ysensors       = 10,
103         .xfact          = 64,
104         .yfact          = 64,
105         .datalen        = 64,
106         .callback       = atp_complete_geyser_3_4,
107         .fuzz           = 0,
108 };
109 
110 #define ATP_DEVICE(prod, info)                                  \
111 {                                                               \
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,                   \
120 }
121 
122 /*
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.)
126  */
127 
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 */
134 
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 */
139 
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 */
144 
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 */
149 
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 */
154 
155         /* Terminating entry */
156         { }
157 };
158 MODULE_DEVICE_TABLE(usb, atp_table);
159 
160 /* maximum number of sensors */
161 #define ATP_XSENSORS    26
162 #define ATP_YSENSORS    16
163 
164 /*
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.
167  */
168 #define ATP_SMOOTHSIZE  34
169 
170 /* maximum pressure this driver will report */
171 #define ATP_PRESSURE    300
172 
173 /*
174  * Threshold for the touchpad sensors. Any change less than ATP_THRESHOLD is
175  * ignored.
176  */
177 #define ATP_THRESHOLD   5
178 
179 /*
180  * How far we'll bitshift our sensor values before averaging them. Mitigates
181  * rounding errors.
182  */
183 #define ATP_SCALE       12
184 
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
191 
192 /**
193  * enum atp_status_bits - status bit meanings
194  *
195  * These constants represent the meaning of the status bits.
196  * (only Geyser 3/4)
197  *
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
201  */
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),
206 };
207 
208 /* Structure to hold all of our device specific stuff */
209 struct atp {
210         char                    phys[64];
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 */
217         bool                    open;
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;
231 };
232 
233 #define dbg_dump(msg, tab) \
234         if (debug > 1) {                                                \
235                 int __i;                                                \
236                 printk(KERN_DEBUG "appletouch: %s", msg);               \
237                 for (__i = 0; __i < ATP_XSENSORS + ATP_YSENSORS; __i++) \
238                         printk(" %02x", tab[__i]);                      \
239                 printk("\n");                                           \
240         }
241 
242 #define dprintk(format, a...)                                           \
243         do {                                                            \
244                 if (debug)                                              \
245                         printk(KERN_DEBUG format, ##a);                 \
246         } while (0)
247 
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");
255 
256 /*
257  * Make the threshold a module parameter
258  */
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.");
264 
265 static int debug;
266 module_param(debug, int, 0644);
267 MODULE_PARM_DESC(debug, "Activate debugging output");
268 
269 /*
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).
273  */
274 static int atp_geyser_init(struct atp *dev)
275 {
276         struct usb_device *udev = dev->udev;
277         char *data;
278         int size;
279         int i;
280         int ret;
281 
282         data = kmalloc(8, GFP_KERNEL);
283         if (!data) {
284                 dev_err(&dev->intf->dev, "Out of memory\n");
285                 return -ENOMEM;
286         }
287 
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);
293 
294         if (size != 8) {
295                 dprintk("atp_geyser_init: read error\n");
296                 for (i = 0; i < 8; i++)
297                         dprintk("appletouch[%d]: %d\n", i, data[i]);
298 
299                 dev_err(&dev->intf->dev, "Failed to read mode from device.\n");
300                 ret = -EIO;
301                 goto out_free;
302         }
303 
304         /* Apply the mode switch */
305         data[0] = ATP_GEYSER_MODE_VENDOR_VALUE;
306 
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);
312 
313         if (size != 8) {
314                 dprintk("atp_geyser_init: write error\n");
315                 for (i = 0; i < 8; i++)
316                         dprintk("appletouch[%d]: %d\n", i, data[i]);
317 
318                 dev_err(&dev->intf->dev, "Failed to request geyser raw mode\n");
319                 ret = -EIO;
320                 goto out_free;
321         }
322         ret = 0;
323 out_free:
324         kfree(data);
325         return ret;
326 }
327 
328 /*
329  * Reinitialise the device. This usually stops stream of empty packets
330  * coming from it.
331  */
332 static void atp_reinit(struct work_struct *work)
333 {
334         struct atp *dev = container_of(work, struct atp, work);
335         int retval;
336 
337         dprintk("appletouch: putting appletouch to sleep (reinit)\n");
338         atp_geyser_init(dev);
339 
340         retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
341         if (retval)
342                 dev_err(&dev->intf->dev,
343                         "atp_reinit: usb_submit_urb failed with error %d\n",
344                         retval);
345 }
346 
347 static int atp_calculate_abs(struct atp *dev, int offset, int nb_sensors,
348                              int fact, int *z, int *fingers)
349 {
350         int i, pass;
351 
352         /*
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.
355          */
356         int *xy_sensors = dev->xy_acc + offset;
357 
358         /* values to calculate mean */
359         int pcum = 0, psum = 0;
360         int is_increasing = 0;
361 
362         *fingers = 0;
363 
364         for (i = 0; i < nb_sensors; i++) {
365                 if (xy_sensors[i] < threshold) {
366                         if (is_increasing)
367                                 is_increasing = 0;
368 
369                 /*
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).
374                  *
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
379                  * sensor)
380                  *
381                  * - Jason Parekh <jasonparekh@gmail.com>
382                  */
383 
384                 } else if (i < 1 ||
385                     (!is_increasing && xy_sensors[i - 1] < xy_sensors[i])) {
386                         (*fingers)++;
387                         is_increasing = 1;
388                 } else if (i > 0 && (xy_sensors[i - 1] - xy_sensors[i] > threshold)) {
389                         is_increasing = 0;
390                 }
391         }
392 
393         if (*fingers < 1)     /* No need to continue if no fingers are found. */
394                 return 0;
395 
396         /*
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.
400          *
401          * The smoothed array is bigger than the original so that the smoothing
402          * doesn't result in edge values being truncated.
403          */
404 
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]));
410 
411         for (pass = 0; pass < 4; pass++) {
412                 /* Handle edge. */
413                 dev->smooth_tmp[0] = (dev->smooth[0] + dev->smooth[1]) / 2;
414 
415                 /* Average values with neighbors. */
416                 for (i = 1; i < nb_sensors + 7; i++)
417                         dev->smooth_tmp[i] = (dev->smooth[i - 1] +
418                                               dev->smooth[i] * 2 +
419                                               dev->smooth[i + 1]) / 4;
420 
421                 /* Handle other edge. */
422                 dev->smooth_tmp[i] = (dev->smooth[i - 1] + dev->smooth[i]) / 2;
423 
424                 memcpy(dev->smooth, dev->smooth_tmp, sizeof(dev->smooth));
425         }
426 
427         for (i = 0; i < nb_sensors + 8; i++) {
428                 /*
429                  * Skip values if they're small enough to be truncated to 0
430                  * by scale. Mostly noise.
431                  */
432                 if ((dev->smooth[i] >> ATP_SCALE) > 0) {
433                         pcum += dev->smooth[i] * i;
434                         psum += dev->smooth[i];
435                 }
436         }
437 
438         if (psum > 0) {
439                 *z = psum >> ATP_SCALE;        /* Scale down pressure output. */
440                 return pcum * fact / psum;
441         }
442 
443         return 0;
444 }
445 
446 static inline void atp_report_fingers(struct input_dev *input, int fingers)
447 {
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);
451 }
452 
453 /* Check URB status and for correct length of data package */
454 
455 #define ATP_URB_STATUS_SUCCESS          0
456 #define ATP_URB_STATUS_ERROR            1
457 #define ATP_URB_STATUS_ERROR_FATAL      2
458 
459 static int atp_status_check(struct urb *urb)
460 {
461         struct atp *dev = urb->context;
462         struct usb_interface *intf = dev->intf;
463 
464         switch (urb->status) {
465         case 0:
466                 /* success */
467                 break;
468         case -EOVERFLOW:
469                 if (!dev->overflow_warned) {
470                         dev_warn(&intf->dev,
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;
474                 }
475         case -ECONNRESET:
476         case -ENOENT:
477         case -ESHUTDOWN:
478                 /* This urb is terminated, clean up */
479                 dev_dbg(&intf->dev,
480                         "atp_complete: urb shutting down with status: %d\n",
481                         urb->status);
482                 return ATP_URB_STATUS_ERROR_FATAL;
483 
484         default:
485                 dev_dbg(&intf->dev,
486                         "atp_complete: nonzero urb status received: %d\n",
487                         urb->status);
488                 return ATP_URB_STATUS_ERROR;
489         }
490 
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;
497         }
498 
499         return ATP_URB_STATUS_SUCCESS;
500 }
501 
502 static void atp_detect_size(struct atp *dev)
503 {
504         int i;
505 
506         /* 17" Powerbooks have extra X sensors */
507         for (i = dev->info->xsensors; i < ATP_XSENSORS; i++) {
508                 if (dev->xy_cur[i]) {
509 
510                         dev_info(&dev->intf->dev,
511                                 "appletouch: 17\" model detected.\n");
512 
513                         input_set_abs_params(dev->input, ABS_X, 0,
514                                              (dev->info->xsensors_17 - 1) *
515                                                         dev->info->xfact - 1,
516                                              dev->info->fuzz, 0);
517                         break;
518                 }
519         }
520 }
521 
522 /*
523  * USB interrupt callback functions
524  */
525 
526 /* Interrupt function for older touchpads: FOUNTAIN/GEYSER1/GEYSER2 */
527 
528 static void atp_complete_geyser_1_2(struct urb *urb)
529 {
530         int x, y, x_z, y_z, x_f, y_f;
531         int retval, i, j;
532         int key, fingers;
533         struct atp *dev = urb->context;
534         int status = atp_status_check(urb);
535 
536         if (status == ATP_URB_STATUS_ERROR_FATAL)
537                 return;
538         else if (status == ATP_URB_STATUS_ERROR)
539                 goto exit;
540 
541         /* reorder the sensors values */
542         if (dev->info == &geyser2_info) {
543                 memset(dev->xy_cur, 0, sizeof(dev->xy_cur));
544 
545                 /*
546                  * The values are laid out like this:
547                  * Y1, Y2, -, Y3, Y4, -, ..., X1, X2, -, X3, X4, -, ...
548                  * '-' is an unused value.
549                  */
550 
551                 /* read X values */
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];
555                 }
556 
557                 /* read Y values */
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];
561                 }
562         } else {
563                 for (i = 0; i < 8; i++) {
564                         /* X values */
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];
568                         if (i < 2)
569                                 dev->xy_cur[i + 24] = dev->data[5 * i + 44];
570 
571                         /* Y values */
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];
574                 }
575         }
576 
577         dbg_dump("sample", dev->xy_cur);
578 
579         if (!dev->valid) {
580                 /* first sample */
581                 dev->valid = true;
582                 dev->x_old = dev->y_old = -1;
583 
584                 /* Store first sample */
585                 memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
586 
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;
591                         goto exit;
592                 }
593         }
594 
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;
599 
600                 /* prevent down drifting */
601                 if (dev->xy_acc[i] < 0)
602                         dev->xy_acc[i] = 0;
603         }
604 
605         memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
606 
607         dbg_dump("accumulator", dev->xy_acc);
608 
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;
614 
615         fingers = max(x_f, y_f);
616 
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;
621                         dev->x_old = x;
622                         dev->y_old = y;
623 
624                         if (debug > 1)
625                                 printk(KERN_DEBUG "appletouch: "
626                                         "X: %3d Y: %3d Xz: %3d Yz: %3d\n",
627                                         x, y, x_z, y_z);
628 
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);
635                 }
636                 dev->x_old = x;
637                 dev->y_old = y;
638 
639         } else if (!x && !y) {
640 
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);
646 
647                 /* reset the accumulator on release */
648                 memset(dev->xy_acc, 0, sizeof(dev->xy_acc));
649         }
650 
651         if (fingers != dev->fingers_old)
652                 dev->x_old = dev->y_old = -1;
653         dev->fingers_old = fingers;
654 
655         input_report_key(dev->input, BTN_LEFT, key);
656         input_sync(dev->input);
657 
658  exit:
659         retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
660         if (retval)
661                 dev_err(&dev->intf->dev,
662                         "atp_complete: usb_submit_urb failed with result %d\n",
663                         retval);
664 }
665 
666 /* Interrupt function for older touchpads: GEYSER3/GEYSER4 */
667 
668 static void atp_complete_geyser_3_4(struct urb *urb)
669 {
670         int x, y, x_z, y_z, x_f, y_f;
671         int retval, i, j;
672         int key, fingers;
673         struct atp *dev = urb->context;
674         int status = atp_status_check(urb);
675 
676         if (status == ATP_URB_STATUS_ERROR_FATAL)
677                 return;
678         else if (status == ATP_URB_STATUS_ERROR)
679                 goto exit;
680 
681         /* Reorder the sensors values:
682          *
683          * The values are laid out like this:
684          * -, Y1, Y2, -, Y3, Y4, -, ..., -, X1, X2, -, X3, X4, ...
685          * '-' is an unused value.
686          */
687 
688         /* read X values */
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];
692         }
693         /* read Y values */
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];
697         }
698 
699         dbg_dump("sample", dev->xy_cur);
700 
701         /* Just update the base values (i.e. touchpad in untouched state) */
702         if (dev->data[dev->info->datalen - 1] & ATP_STATUS_BASE_UPDATE) {
703 
704                 dprintk("appletouch: updated base values\n");
705 
706                 memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
707                 goto exit;
708         }
709 
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];
713 
714                 /* this is a round-robin value, so couple with that */
715                 if (dev->xy_acc[i] > 127)
716                         dev->xy_acc[i] -= 256;
717 
718                 if (dev->xy_acc[i] < -127)
719                         dev->xy_acc[i] += 256;
720 
721                 /* prevent down drifting */
722                 if (dev->xy_acc[i] < 0)
723                         dev->xy_acc[i] = 0;
724         }
725 
726         dbg_dump("accumulator", dev->xy_acc);
727 
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);
732 
733         key = dev->data[dev->info->datalen - 1] & ATP_STATUS_BUTTON;
734 
735         fingers = max(x_f, y_f);
736 
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;
741                         dev->x_old = x;
742                         dev->y_old = y;
743 
744                         if (debug > 1)
745                                 printk(KERN_DEBUG "appletouch: X: %3d Y: %3d "
746                                        "Xz: %3d Yz: %3d\n",
747                                        x, y, x_z, y_z);
748 
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);
755                 }
756                 dev->x_old = x;
757                 dev->y_old = y;
758 
759         } else if (!x && !y) {
760 
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);
766 
767                 /* reset the accumulator on release */
768                 memset(dev->xy_acc, 0, sizeof(dev->xy_acc));
769         }
770 
771         if (fingers != dev->fingers_old)
772                 dev->x_old = dev->y_old = -1;
773         dev->fingers_old = fingers;
774 
775         input_report_key(dev->input, BTN_LEFT, key);
776         input_sync(dev->input);
777 
778         /*
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.
783          */
784 
785         /*
786          * Button must not be pressed when entering suspend,
787          * otherwise we will never release the button.
788          */
789         if (!x && !y && !key) {
790                 dev->idlecount++;
791                 if (dev->idlecount == 10) {
792                         dev->x_old = dev->y_old = -1;
793                         dev->idlecount = 0;
794                         schedule_work(&dev->work);
795                         /* Don't resubmit urb here, wait for reinit */
796                         return;
797                 }
798         } else
799                 dev->idlecount = 0;
800 
801  exit:
802         retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
803         if (retval)
804                 dev_err(&dev->intf->dev,
805                         "atp_complete: usb_submit_urb failed with result %d\n",
806                         retval);
807 }
808 
809 static int atp_open(struct input_dev *input)
810 {
811         struct atp *dev = input_get_drvdata(input);
812 
813         if (usb_submit_urb(dev->urb, GFP_ATOMIC))
814                 return -EIO;
815 
816         dev->open = 1;
817         return 0;
818 }
819 
820 static void atp_close(struct input_dev *input)
821 {
822         struct atp *dev = input_get_drvdata(input);
823 
824         usb_kill_urb(dev->urb);
825         cancel_work_sync(&dev->work);
826         dev->open = 0;
827 }
828 
829 static int atp_handle_geyser(struct atp *dev)
830 {
831         if (dev->info != &fountain_info) {
832                 /* switch to raw sensor mode */
833                 if (atp_geyser_init(dev))
834                         return -EIO;
835 
836                 dev_info(&dev->intf->dev, "Geyser mode initialized.\n");
837         }
838 
839         return 0;
840 }
841 
842 static int atp_probe(struct usb_interface *iface,
843                      const struct usb_device_id *id)
844 {
845         struct atp *dev;
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;
853 
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;
862                         break;
863                 }
864         }
865         if (!int_in_endpointAddr) {
866                 dev_err(&iface->dev, "Could not find int-in endpoint\n");
867                 return -EIO;
868         }
869 
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");
875                 goto err_free_devs;
876         }
877 
878         dev->udev = udev;
879         dev->intf = iface;
880         dev->input = input_dev;
881         dev->info = info;
882         dev->overflow_warned = false;
883 
884         dev->urb = usb_alloc_urb(0, GFP_KERNEL);
885         if (!dev->urb)
886                 goto err_free_devs;
887 
888         dev->data = usb_alloc_coherent(dev->udev, dev->info->datalen, GFP_KERNEL,
889                                        &dev->urb->transfer_dma);
890         if (!dev->data)
891                 goto err_free_urb;
892 
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);
897 
898         error = atp_handle_geyser(dev);
899         if (error)
900                 goto err_free_buffer;
901 
902         usb_make_path(udev, dev->phys, sizeof(dev->phys));
903         strlcat(dev->phys, "/input0", sizeof(dev->phys));
904 
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;
909 
910         input_set_drvdata(input_dev, dev);
911 
912         input_dev->open = atp_open;
913         input_dev->close = atp_close;
914 
915         set_bit(EV_ABS, input_dev->evbit);
916 
917         input_set_abs_params(input_dev, ABS_X, 0,
918                              (dev->info->xsensors - 1) * dev->info->xfact - 1,
919                              dev->info->fuzz, 0);
920         input_set_abs_params(input_dev, ABS_Y, 0,
921                              (dev->info->ysensors - 1) * dev->info->yfact - 1,
922                              dev->info->fuzz, 0);
923         input_set_abs_params(input_dev, ABS_PRESSURE, 0, ATP_PRESSURE, 0, 0);
924 
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);
931 
932         error = input_register_device(dev->input);
933         if (error)
934                 goto err_free_buffer;
935 
936         /* save our data pointer in this interface device */
937         usb_set_intfdata(iface, dev);
938 
939         INIT_WORK(&dev->work, atp_reinit);
940 
941         return 0;
942 
943  err_free_buffer:
944         usb_free_coherent(dev->udev, dev->info->datalen,
945                           dev->data, dev->urb->transfer_dma);
946  err_free_urb:
947         usb_free_urb(dev->urb);
948  err_free_devs:
949         usb_set_intfdata(iface, NULL);
950         kfree(dev);
951         input_free_device(input_dev);
952         return error;
953 }
954 
955 static void atp_disconnect(struct usb_interface *iface)
956 {
957         struct atp *dev = usb_get_intfdata(iface);
958 
959         usb_set_intfdata(iface, NULL);
960         if (dev) {
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);
966                 kfree(dev);
967         }
968         dev_info(&iface->dev, "input: appletouch disconnected\n");
969 }
970 
971 static int atp_recover(struct atp *dev)
972 {
973         int error;
974 
975         error = atp_handle_geyser(dev);
976         if (error)
977                 return error;
978 
979         if (dev->open && usb_submit_urb(dev->urb, GFP_ATOMIC))
980                 return -EIO;
981 
982         return 0;
983 }
984 
985 static int atp_suspend(struct usb_interface *iface, pm_message_t message)
986 {
987         struct atp *dev = usb_get_intfdata(iface);
988 
989         usb_kill_urb(dev->urb);
990         return 0;
991 }
992 
993 static int atp_resume(struct usb_interface *iface)
994 {
995         struct atp *dev = usb_get_intfdata(iface);
996 
997         if (dev->open && usb_submit_urb(dev->urb, GFP_ATOMIC))
998                 return -EIO;
999 
1000         return 0;
1001 }
1002 
1003 static int atp_reset_resume(struct usb_interface *iface)
1004 {
1005         struct atp *dev = usb_get_intfdata(iface);
1006 
1007         return atp_recover(dev);
1008 }
1009 
1010 static struct usb_driver atp_driver = {
1011         .name           = "appletouch",
1012         .probe          = atp_probe,
1013         .disconnect     = atp_disconnect,
1014         .suspend        = atp_suspend,
1015         .resume         = atp_resume,
1016         .reset_resume   = atp_reset_resume,
1017         .id_table       = atp_table,
1018 };
1019 
1020 module_usb_driver(atp_driver);
1021 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us