drivers/usb/input/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      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/config.h>
  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 /* Apple has powerbooks which have the keyboard with different Product IDs */
  39 #define APPLE_VENDOR_ID         0x05AC
  40
  41 /* These names come from Info.plist in AppleUSBTrackpad.kext */
  42 #define GEYSER_ANSI_PRODUCT_ID  0x0214
  43 #define GEYSER_ISO_PRODUCT_ID   0x0215
  44 #define GEYSER_JIS_PRODUCT_ID   0x0216
  45
  46 /* MacBook devices */
  47 #define GEYSER3_ANSI_PRODUCT_ID 0x0217
  48 #define GEYSER3_ISO_PRODUCT_ID  0x0218
  49 #define GEYSER3_JIS_PRODUCT_ID  0x0219
  50
  51 #define ATP_DEVICE(prod)                                        \
  52         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |             \
  53                        USB_DEVICE_ID_MATCH_INT_CLASS |          \
  54                        USB_DEVICE_ID_MATCH_INT_PROTOCOL,        \
  55         .idVendor = APPLE_VENDOR_ID,                            \
  56         .idProduct = (prod),                                    \
  57         .bInterfaceClass = 0x03,                                \
  58         .bInterfaceProtocol = 0x02
  59
  60 /* table of devices that work with this driver */
  61 static struct usb_device_id atp_table [] = {
  62         { ATP_DEVICE(0x020E) },
  63         { ATP_DEVICE(0x020F) },
  64         { ATP_DEVICE(0x030A) },
  65         { ATP_DEVICE(0x030B) },
  66
  67         /* PowerBooks Oct 2005 */
  68         { ATP_DEVICE(GEYSER_ANSI_PRODUCT_ID) },
  69         { ATP_DEVICE(GEYSER_ISO_PRODUCT_ID) },
  70         { ATP_DEVICE(GEYSER_JIS_PRODUCT_ID) },
  71
  72         { ATP_DEVICE(GEYSER3_ANSI_PRODUCT_ID) },
  73         { ATP_DEVICE(GEYSER3_ISO_PRODUCT_ID) },
  74         { ATP_DEVICE(GEYSER3_JIS_PRODUCT_ID) },
  75
  76         /* Terminating entry */
  77         { }
  78 };
  79 MODULE_DEVICE_TABLE (usb, atp_table);
  80
  81 /*
  82  * number of sensors. Note that only 16 instead of 26 X (horizontal)
  83  * sensors exist on 12" and 15" PowerBooks. All models have 16 Y
  84  * (vertical) sensors.
  85  */
  86 #define ATP_XSENSORS    26
  87 #define ATP_YSENSORS    16
  88
  89 /* amount of fuzz this touchpad generates */
  90 #define ATP_FUZZ        16
  91
  92 /* maximum pressure this driver will report */
  93 #define ATP_PRESSURE    300
  94 /*
  95  * multiplication factor for the X and Y coordinates.
  96  * We try to keep the touchpad aspect ratio while still doing only simple
  97  * arithmetics.
  98  * The factors below give coordinates like:
  99  *      0 <= x <  960 on 12" and 15" Powerbooks
 100  *      0 <= x < 1600 on 17" Powerbooks
 101  *      0 <= y <  646
 102  */
 103 #define ATP_XFACT       64
 104 #define ATP_YFACT       43
 105
 106 /*
 107  * Threshold for the touchpad sensors. Any change less than ATP_THRESHOLD is
 108  * ignored.
 109  */
 110 #define ATP_THRESHOLD    5
 111
 112 /* MacBook Pro (Geyser 3) initialization constants */
 113 #define ATP_GEYSER3_MODE_READ_REQUEST_ID 1
 114 #define ATP_GEYSER3_MODE_WRITE_REQUEST_ID 9
 115 #define ATP_GEYSER3_MODE_REQUEST_VALUE 0x300
 116 #define ATP_GEYSER3_MODE_REQUEST_INDEX 0
 117 #define ATP_GEYSER3_MODE_VENDOR_VALUE 0x04
 118
 119 /* Structure to hold all of our device specific stuff */
 120 struct atp {
 121         char                    phys[64];
 122         struct usb_device *     udev;           /* usb device */
 123         struct urb *            urb;            /* usb request block */
 124         signed char *           data;           /* transferred data */
 125         int                     open;           /* non-zero if opened */
 126         struct input_dev        *input;         /* input dev */
 127         int                     valid;          /* are the sensors valid ? */
 128         int                     x_old;          /* last reported x/y, */
 129         int                     y_old;          /* used for smoothing */
 130                                                 /* current value of the sensors */
 131         signed char             xy_cur[ATP_XSENSORS + ATP_YSENSORS];
 132                                                 /* last value of the sensors */
 133         signed char             xy_old[ATP_XSENSORS + ATP_YSENSORS];
 134                                                 /* accumulated sensors */
 135         int                     xy_acc[ATP_XSENSORS + ATP_YSENSORS];
 136         int                     overflowwarn;   /* overflow warning printed? */
 137         int                     datalen;        /* size of an USB urb transfer */
 138 };
 139
 140 #define dbg_dump(msg, tab) \
 141         if (debug > 1) {                                                \
 142                 int i;                                                  \
 143                 printk("appletouch: %s %lld", msg, (long long)jiffies); \
 144                 for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++)       \
 145                         printk(" %02x", tab[i]);                        \
 146                 printk("\n");                                           \
 147         }
 148
 149 #define dprintk(format, a...)                                           \
 150         do {                                                            \
 151                 if (debug) printk(format, ##a);                         \
 152         } while (0)
 153
 154 MODULE_AUTHOR("Johannes Berg, Stelian Pop, Frank Arnold, Michael Hanselmann");
 155 MODULE_DESCRIPTION("Apple PowerBooks USB touchpad driver");
 156 MODULE_LICENSE("GPL");
 157
 158 static int debug = 1;
 159 module_param(debug, int, 0644);
 160 MODULE_PARM_DESC(debug, "Activate debugging output");
 161
 162 /* Checks if the device a Geyser 2 (ANSI, ISO, JIS) */
 163 static inline int atp_is_geyser_2(struct atp *dev)
 164 {
 165         u16 productId = le16_to_cpu(dev->udev->descriptor.idProduct);
 166
 167         return (productId == GEYSER_ANSI_PRODUCT_ID) ||
 168                 (productId == GEYSER_ISO_PRODUCT_ID) ||
 169                 (productId == GEYSER_JIS_PRODUCT_ID);
 170 }
 171
 172 static inline int atp_is_geyser_3(struct atp *dev)
 173 {
 174         u16 productId = le16_to_cpu(dev->udev->descriptor.idProduct);
 175
 176         return (productId == GEYSER3_ANSI_PRODUCT_ID) ||
 177                 (productId == GEYSER3_ISO_PRODUCT_ID) ||
 178                 (productId == GEYSER3_JIS_PRODUCT_ID);
 179 }
 180
 181 static int atp_calculate_abs(int *xy_sensors, int nb_sensors, int fact,
 182                              int *z, int *fingers)
 183 {
 184         int i;
 185         /* values to calculate mean */
 186         int pcum = 0, psum = 0;
 187
 188         *fingers = 0;
 189
 190         for (i = 0; i < nb_sensors; i++) {
 191                 if (xy_sensors[i] < ATP_THRESHOLD)
 192                         continue;
 193                 if ((i - 1 < 0) || (xy_sensors[i - 1] < ATP_THRESHOLD))
 194                         (*fingers)++;
 195                 pcum += xy_sensors[i] * i;
 196                 psum += xy_sensors[i];
 197         }
 198
 199         if (psum > 0) {
 200                 *z = psum;
 201                 return pcum * fact / psum;
 202         }
 203
 204         return 0;
 205 }
 206
 207 static inline void atp_report_fingers(struct input_dev *input, int fingers)
 208 {
 209         input_report_key(input, BTN_TOOL_FINGER, fingers == 1);
 210         input_report_key(input, BTN_TOOL_DOUBLETAP, fingers == 2);
 211         input_report_key(input, BTN_TOOL_TRIPLETAP, fingers > 2);
 212 }
 213
 214 static void atp_complete(struct urb* urb, struct pt_regs* regs)
 215 {
 216         int x, y, x_z, y_z, x_f, y_f;
 217         int retval, i, j;
 218         struct atp *dev = urb->context;
 219
 220         switch (urb->status) {
 221         case 0:
 222                 /* success */
 223                 break;
 224         case -EOVERFLOW:
 225                 if(!dev->overflowwarn) {
 226                         printk("appletouch: OVERFLOW with data "
 227                                 "length %d, actual length is %d\n",
 228                                 dev->datalen, dev->urb->actual_length);
 229                         dev->overflowwarn = 1;
 230                 }
 231         case -ECONNRESET:
 232         case -ENOENT:
 233         case -ESHUTDOWN:
 234                 /* This urb is terminated, clean up */
 235                 dbg("%s - urb shutting down with status: %d",
 236                     __FUNCTION__, urb->status);
 237                 return;
 238         default:
 239                 dbg("%s - nonzero urb status received: %d",
 240                     __FUNCTION__, urb->status);
 241                 goto exit;
 242         }
 243
 244         /* drop incomplete datasets */
 245         if (dev->urb->actual_length != dev->datalen) {
 246                 dprintk("appletouch: incomplete data package"
 247                         " (first byte: %d, length: %d).\n",
 248                         dev->data[0], dev->urb->actual_length);
 249                 goto exit;
 250         }
 251
 252         /* reorder the sensors values */
 253         if (atp_is_geyser_3(dev)) {
 254                 memset(dev->xy_cur, 0, sizeof(dev->xy_cur));
 255
 256                 /*
 257                  * The values are laid out like this:
 258                  * -, Y1, Y2, -, Y3, Y4, -, ..., -, X1, X2, -, X3, X4, ...
 259                  * '-' is an unused value.
 260                  */
 261
 262                 /* read X values */
 263                 for (i = 0, j = 19; i < 20; i += 2, j += 3) {
 264                         dev->xy_cur[i] = dev->data[j + 1];
 265                         dev->xy_cur[i + 1] = dev->data[j + 2];
 266                 }
 267                 /* read Y values */
 268                 for (i = 0, j = 1; i < 9; i += 2, j += 3) {
 269                         dev->xy_cur[ATP_XSENSORS + i] = dev->data[j + 1];
 270                         dev->xy_cur[ATP_XSENSORS + i + 1] = dev->data[j + 2];
 271                 }
 272         } else if (atp_is_geyser_2(dev)) {
 273                 memset(dev->xy_cur, 0, sizeof(dev->xy_cur));
 274
 275                 /*
 276                  * The values are laid out like this:
 277                  * Y1, Y2, -, Y3, Y4, -, ..., X1, X2, -, X3, X4, -, ...
 278                  * '-' is an unused value.
 279                  */
 280
 281                 /* read X values */
 282                 for (i = 0, j = 19; i < 20; i += 2, j += 3) {
 283                         dev->xy_cur[i] = dev->data[j];
 284                         dev->xy_cur[i + 1] = dev->data[j + 1];
 285                 }
 286
 287                 /* read Y values */
 288                 for (i = 0, j = 1; i < 9; i += 2, j += 3) {
 289                         dev->xy_cur[ATP_XSENSORS + i] = dev->data[j];
 290                         dev->xy_cur[ATP_XSENSORS + i + 1] = dev->data[j + 1];
 291                 }
 292         } else {
 293                 for (i = 0; i < 8; i++) {
 294                         /* X values */
 295                         dev->xy_cur[i     ] = dev->data[5 * i +  2];
 296                         dev->xy_cur[i +  8] = dev->data[5 * i +  4];
 297                         dev->xy_cur[i + 16] = dev->data[5 * i + 42];
 298                         if (i < 2)
 299                                 dev->xy_cur[i + 24] = dev->data[5 * i + 44];
 300
 301                         /* Y values */
 302                         dev->xy_cur[i + 26] = dev->data[5 * i +  1];
 303                         dev->xy_cur[i + 34] = dev->data[5 * i +  3];
 304                 }
 305         }
 306
 307         dbg_dump("sample", dev->xy_cur);
 308
 309         if (!dev->valid) {
 310                 /* first sample */
 311                 dev->valid = 1;
 312                 dev->x_old = dev->y_old = -1;
 313                 memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
 314
 315                 if (atp_is_geyser_3(dev)) /* No 17" Macbooks (yet) */
 316                         goto exit;
 317
 318                 /* 17" Powerbooks have extra X sensors */
 319                 for (i = (atp_is_geyser_2(dev)?15:16); i < ATP_XSENSORS; i++) {
 320                         if (!dev->xy_cur[i]) continue;
 321
 322                         printk("appletouch: 17\" model detected.\n");
 323                         if(atp_is_geyser_2(dev))
 324                                 input_set_abs_params(dev->input, ABS_X, 0,
 325                                                      (20 - 1) *
 326                                                      ATP_XFACT - 1,
 327                                                      ATP_FUZZ, 0);
 328                         else
 329                                 input_set_abs_params(dev->input, ABS_X, 0,
 330                                                      (ATP_XSENSORS - 1) *
 331                                                      ATP_XFACT - 1,
 332                                                      ATP_FUZZ, 0);
 333
 334                         break;
 335                 }
 336
 337                 goto exit;
 338         }
 339
 340         for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) {
 341                 /* accumulate the change */
 342                 signed char change = dev->xy_old[i] - dev->xy_cur[i];
 343                 dev->xy_acc[i] -= change;
 344
 345                 /* prevent down drifting */
 346                 if (dev->xy_acc[i] < 0)
 347                         dev->xy_acc[i] = 0;
 348         }
 349
 350         memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
 351
 352         dbg_dump("accumulator", dev->xy_acc);
 353
 354         x = atp_calculate_abs(dev->xy_acc, ATP_XSENSORS,
 355                               ATP_XFACT, &x_z, &x_f);
 356         y = atp_calculate_abs(dev->xy_acc + ATP_XSENSORS, ATP_YSENSORS,
 357                               ATP_YFACT, &y_z, &y_f);
 358
 359         if (x && y) {
 360                 if (dev->x_old != -1) {
 361                         x = (dev->x_old * 3 + x) >> 2;
 362                         y = (dev->y_old * 3 + y) >> 2;
 363                         dev->x_old = x;
 364                         dev->y_old = y;
 365
 366                         if (debug > 1)
 367                                 printk("appletouch: X: %3d Y: %3d "
 368                                        "Xz: %3d Yz: %3d\n",
 369                                        x, y, x_z, y_z);
 370
 371                         input_report_key(dev->input, BTN_TOUCH, 1);
 372                         input_report_abs(dev->input, ABS_X, x);
 373                         input_report_abs(dev->input, ABS_Y, y);
 374                         input_report_abs(dev->input, ABS_PRESSURE,
 375                                          min(ATP_PRESSURE, x_z + y_z));
 376                         atp_report_fingers(dev->input, max(x_f, y_f));
 377                 }
 378                 dev->x_old = x;
 379                 dev->y_old = y;
 380         }
 381         else if (!x && !y) {
 382
 383                 dev->x_old = dev->y_old = -1;
 384                 input_report_key(dev->input, BTN_TOUCH, 0);
 385                 input_report_abs(dev->input, ABS_PRESSURE, 0);
 386                 atp_report_fingers(dev->input, 0);
 387
 388                 /* reset the accumulator on release */
 389                 memset(dev->xy_acc, 0, sizeof(dev->xy_acc));
 390         }
 391
 392         input_report_key(dev->input, BTN_LEFT,
 393                          !!dev->data[dev->datalen - 1]);
 394
 395         input_sync(dev->input);
 396
 397 exit:
 398         retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
 399         if (retval) {
 400                 err("%s - usb_submit_urb failed with result %d",
 401                     __FUNCTION__, retval);
 402         }
 403 }
 404
 405 static int atp_open(struct input_dev *input)
 406 {
 407         struct atp *dev = input->private;
 408
 409         if (usb_submit_urb(dev->urb, GFP_ATOMIC))
 410                 return -EIO;
 411
 412         dev->open = 1;
 413         return 0;
 414 }
 415
 416 static void atp_close(struct input_dev *input)
 417 {
 418         struct atp *dev = input->private;
 419
 420         usb_kill_urb(dev->urb);
 421         dev->open = 0;
 422 }
 423
 424 static int atp_probe(struct usb_interface *iface, const struct usb_device_id *id)
 425 {
 426         struct atp *dev;
 427         struct input_dev *input_dev;
 428         struct usb_device *udev = interface_to_usbdev(iface);
 429         struct usb_host_interface *iface_desc;
 430         struct usb_endpoint_descriptor *endpoint;
 431         int int_in_endpointAddr = 0;
 432         int i, retval = -ENOMEM;
 433
 434
 435         /* set up the endpoint information */
 436         /* use only the first interrupt-in endpoint */
 437         iface_desc = iface->cur_altsetting;
 438         for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
 439                 endpoint = &iface_desc->endpoint[i].desc;
 440                 if (!int_in_endpointAddr &&
 441                     (endpoint->bEndpointAddress & USB_DIR_IN) &&
 442                     ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
 443                                         == USB_ENDPOINT_XFER_INT)) {
 444                         /* we found an interrupt in endpoint */
 445                         int_in_endpointAddr = endpoint->bEndpointAddress;
 446                         break;
 447                 }
 448         }
 449         if (!int_in_endpointAddr) {
 450                 err("Could not find int-in endpoint");
 451                 return -EIO;
 452         }
 453
 454         /* allocate memory for our device state and initialize it */
 455         dev = kzalloc(sizeof(struct atp), GFP_KERNEL);
 456         input_dev = input_allocate_device();
 457         if (!dev || !input_dev) {
 458                 err("Out of memory");
 459                 goto err_free_devs;
 460         }
 461
 462         dev->udev = udev;
 463         dev->input = input_dev;
 464         dev->overflowwarn = 0;
 465         if (atp_is_geyser_3(dev))
 466                 dev->datalen = 64;
 467         else if (atp_is_geyser_2(dev))
 468                 dev->datalen = 64;
 469         else
 470                 dev->datalen = 81;
 471
 472         if (atp_is_geyser_3(dev)) {
 473                 /*
 474                  * By default Geyser 3 device sends standard USB HID mouse
 475                  * packets (Report ID 2). This code changes device mode, so it
 476                  * sends raw sensor reports (Report ID 5).
 477                  */
 478                 char data[8];
 479                 int size;
 480
 481                 size = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
 482                         ATP_GEYSER3_MODE_READ_REQUEST_ID,
 483                         USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 484                         ATP_GEYSER3_MODE_REQUEST_VALUE,
 485                         ATP_GEYSER3_MODE_REQUEST_INDEX, &data, 8, 5000);
 486
 487                 if (size != 8) {
 488                         err("Could not do mode read request from device"
 489                                                         " (Geyser 3 mode)");
 490                         goto err_free_devs;
 491                 }
 492
 493                 /* Apply the mode switch */
 494                 data[0] = ATP_GEYSER3_MODE_VENDOR_VALUE;
 495
 496                 size = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
 497                         ATP_GEYSER3_MODE_WRITE_REQUEST_ID,
 498                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 499                         ATP_GEYSER3_MODE_REQUEST_VALUE,
 500                         ATP_GEYSER3_MODE_REQUEST_INDEX, &data, 8, 5000);
 501
 502                 if (size != 8) {
 503                         err("Could not do mode write request to device"
 504                                                         " (Geyser 3 mode)");
 505                         goto err_free_devs;
 506                 }
 507                 printk("appletouch Geyser 3 inited.\n");
 508         }
 509
 510         dev->urb = usb_alloc_urb(0, GFP_KERNEL);
 511         if (!dev->urb) {
 512                 retval = -ENOMEM;
 513                 goto err_free_devs;
 514         }
 515
 516         dev->data = usb_buffer_alloc(dev->udev, dev->datalen, GFP_KERNEL,
 517                                      &dev->urb->transfer_dma);
 518         if (!dev->data) {
 519                 retval = -ENOMEM;
 520                 goto err_free_urb;
 521         }
 522
 523         usb_fill_int_urb(dev->urb, udev,
 524                          usb_rcvintpipe(udev, int_in_endpointAddr),
 525                          dev->data, dev->datalen, atp_complete, dev, 1);
 526
 527         usb_make_path(udev, dev->phys, sizeof(dev->phys));
 528         strlcat(dev->phys, "/input0", sizeof(dev->phys));
 529
 530         input_dev->name = "appletouch";
 531         input_dev->phys = dev->phys;
 532         usb_to_input_id(dev->udev, &input_dev->id);
 533         input_dev->cdev.dev = &iface->dev;
 534
 535         input_dev->private = dev;
 536         input_dev->open = atp_open;
 537         input_dev->close = atp_close;
 538
 539         set_bit(EV_ABS, input_dev->evbit);
 540
 541         if (atp_is_geyser_3(dev)) {
 542                 /*
 543                  * MacBook have 20 X sensors, 10 Y sensors
 544                  */
 545                 input_set_abs_params(input_dev, ABS_X, 0,
 546                                      ((20 - 1) * ATP_XFACT) - 1, ATP_FUZZ, 0);
 547                 input_set_abs_params(input_dev, ABS_Y, 0,
 548                                      ((10 - 1) * ATP_YFACT) - 1, ATP_FUZZ, 0);
 549         } else if (atp_is_geyser_2(dev)) {
 550                 /*
 551                  * Oct 2005 15" PowerBooks have 15 X sensors, 17" are detected
 552                  * later.
 553                  */
 554                 input_set_abs_params(input_dev, ABS_X, 0,
 555                                      ((15 - 1) * ATP_XFACT) - 1, ATP_FUZZ, 0);
 556                 input_set_abs_params(input_dev, ABS_Y, 0,
 557                                      ((9 - 1) * ATP_YFACT) - 1, ATP_FUZZ, 0);
 558         } else {
 559                 /*
 560                  * 12" and 15" Powerbooks only have 16 x sensors,
 561                  * 17" models are detected later.
 562                  */
 563                 input_set_abs_params(input_dev, ABS_X, 0,
 564                                      (16 - 1) * ATP_XFACT - 1, ATP_FUZZ, 0);
 565                 input_set_abs_params(input_dev, ABS_Y, 0,
 566                                      (ATP_YSENSORS - 1) * ATP_YFACT - 1, ATP_FUZZ, 0);
 567         }
 568         input_set_abs_params(input_dev, ABS_PRESSURE, 0, ATP_PRESSURE, 0, 0);
 569
 570         set_bit(EV_KEY, input_dev->evbit);
 571         set_bit(BTN_TOUCH, input_dev->keybit);
 572         set_bit(BTN_TOOL_FINGER, input_dev->keybit);
 573         set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit);
 574         set_bit(BTN_TOOL_TRIPLETAP, input_dev->keybit);
 575         set_bit(BTN_LEFT, input_dev->keybit);
 576
 577         input_register_device(dev->input);
 578
 579         /* save our data pointer in this interface device */
 580         usb_set_intfdata(iface, dev);
 581
 582         return 0;
 583
 584  err_free_urb:
 585         usb_free_urb(dev->urb);
 586  err_free_devs:
 587         usb_set_intfdata(iface, NULL);
 588         kfree(dev);
 589         input_free_device(input_dev);
 590         return retval;
 591 }
 592
 593 static void atp_disconnect(struct usb_interface *iface)
 594 {
 595         struct atp *dev = usb_get_intfdata(iface);
 596
 597         usb_set_intfdata(iface, NULL);
 598         if (dev) {
 599                 usb_kill_urb(dev->urb);
 600                 input_unregister_device(dev->input);
 601                 usb_free_urb(dev->urb);
 602                 usb_buffer_free(dev->udev, dev->datalen,
 603                                 dev->data, dev->urb->transfer_dma);
 604                 kfree(dev);
 605         }
 606         printk(KERN_INFO "input: appletouch disconnected\n");
 607 }
 608
 609 static int atp_suspend(struct usb_interface *iface, pm_message_t message)
 610 {
 611         struct atp *dev = usb_get_intfdata(iface);
 612         usb_kill_urb(dev->urb);
 613         dev->valid = 0;
 614         return 0;
 615 }
 616
 617 static int atp_resume(struct usb_interface *iface)
 618 {
 619         struct atp *dev = usb_get_intfdata(iface);
 620         if (dev->open && usb_submit_urb(dev->urb, GFP_ATOMIC))
 621                 return -EIO;
 622
 623         return 0;
 624 }
 625
 626 static struct usb_driver atp_driver = {
 627         .name           = "appletouch",
 628         .probe          = atp_probe,
 629         .disconnect     = atp_disconnect,
 630         .suspend        = atp_suspend,
 631         .resume         = atp_resume,
 632         .id_table       = atp_table,
 633 };
 634
 635 static int __init atp_init(void)
 636 {
 637         return usb_register(&atp_driver);
 638 }
 639
 640 static void __exit atp_exit(void)
 641 {
 642         usb_deregister(&atp_driver);
 643 }
 644
 645 module_init(atp_init);
 646 module_exit(atp_exit);