drivers/input/mouse/synaptics_usb.c

   1 /*
   2  * USB Synaptics device driver
   3  *
   4  *  Copyright (c) 2002 Rob Miller (rob@inpharmatica . co . uk)
   5  *  Copyright (c) 2003 Ron Lee (ron@debian.org)
   6  *      cPad driver for kernel 2.4
   7  *
   8  *  Copyright (c) 2004 Jan Steinhoff (cpad@jan-steinhoff . de)
   9  *  Copyright (c) 2004 Ron Lee (ron@debian.org)
  10  *      rewritten for kernel 2.6
  11  *
  12  *  cPad display character device part is not included. It can be found at
  13  *  http://jan-steinhoff.de/linux/synaptics-usb.html
  14  *
  15  * Bases on:    usb_skeleton.c v2.2 by Greg Kroah-Hartman
  16  *              drivers/hid/usbhid/usbmouse.c by Vojtech Pavlik
  17  *              drivers/input/mouse/synaptics.c by Peter Osterlund
  18  *
  19  * This program is free software; you can redistribute it and/or modify it
  20  * under the terms of the GNU General Public License as published by the Free
  21  * Software Foundation; either version 2 of the License, or (at your option)
  22  * any later version.
  23  *
  24  * Trademarks are the property of their respective owners.
  25  */
  26
  27 /*
  28  * There are three different types of Synaptics USB devices: Touchpads,
  29  * touchsticks (or trackpoints), and touchscreens. Touchpads are well supported
  30  * by this driver, touchstick support has not been tested much yet, and
  31  * touchscreens have not been tested at all.
  32  *
  33  * Up to three alternate settings are possible:
  34  *      setting 0: one int endpoint for relative movement (used by usbhid.ko)
  35  *      setting 1: one int endpoint for absolute finger position
  36  *      setting 2 (cPad only): one int endpoint for absolute finger position and
  37  *                 two bulk endpoints for the display (in/out)
  38  * This driver uses setting 1.
  39  */
  40
  41 #include <linux/kernel.h>
  42 #include <linux/slab.h>
  43 #include <linux/module.h>
  44 #include <linux/moduleparam.h>
  45 #include <linux/usb.h>
  46 #include <linux/input.h>
  47 #include <linux/usb/input.h>
  48
  49 #define USB_VENDOR_ID_SYNAPTICS 0x06cb
  50 #define USB_DEVICE_ID_SYNAPTICS_TP      0x0001  /* Synaptics USB TouchPad */
  51 #define USB_DEVICE_ID_SYNAPTICS_INT_TP  0x0002  /* Integrated USB TouchPad */
  52 #define USB_DEVICE_ID_SYNAPTICS_CPAD    0x0003  /* Synaptics cPad */
  53 #define USB_DEVICE_ID_SYNAPTICS_TS      0x0006  /* Synaptics TouchScreen */
  54 #define USB_DEVICE_ID_SYNAPTICS_STICK   0x0007  /* Synaptics USB Styk */
  55 #define USB_DEVICE_ID_SYNAPTICS_WP      0x0008  /* Synaptics USB WheelPad */
  56 #define USB_DEVICE_ID_SYNAPTICS_COMP_TP 0x0009  /* Composite USB TouchPad */
  57 #define USB_DEVICE_ID_SYNAPTICS_WTP     0x0010  /* Wireless TouchPad */
  58 #define USB_DEVICE_ID_SYNAPTICS_DPAD    0x0013  /* DisplayPad */
  59
  60 #define SYNUSB_TOUCHPAD                 (1 << 0)
  61 #define SYNUSB_STICK                    (1 << 1)
  62 #define SYNUSB_TOUCHSCREEN              (1 << 2)
  63 #define SYNUSB_AUXDISPLAY               (1 << 3) /* For cPad */
  64 #define SYNUSB_COMBO                    (1 << 4) /* Composite device (TP + stick) */
  65 #define SYNUSB_IO_ALWAYS                (1 << 5)
  66
  67 #define USB_DEVICE_SYNAPTICS(prod, kind)                \
  68         USB_DEVICE(USB_VENDOR_ID_SYNAPTICS,             \
  69                    USB_DEVICE_ID_SYNAPTICS_##prod),     \
  70         .driver_info = (kind),
  71
  72 #define SYNUSB_RECV_SIZE        8
  73
  74 #define XMIN_NOMINAL            1472
  75 #define XMAX_NOMINAL            5472
  76 #define YMIN_NOMINAL            1408
  77 #define YMAX_NOMINAL            4448
  78
  79 struct synusb {
  80         struct usb_device *udev;
  81         struct usb_interface *intf;
  82         struct urb *urb;
  83         unsigned char *data;
  84
  85         /* serialize access to open/suspend */
  86         struct mutex pm_mutex;
  87         bool is_open;
  88
  89         /* input device related data structures */
  90         struct input_dev *input;
  91         char name[128];
  92         char phys[64];
  93
  94         /* characteristics of the device */
  95         unsigned long flags;
  96 };
  97
  98 static void synusb_report_buttons(struct synusb *synusb)
  99 {
 100         struct input_dev *input_dev = synusb->input;
 101
 102         input_report_key(input_dev, BTN_LEFT, synusb->data[1] & 0x04);
 103         input_report_key(input_dev, BTN_RIGHT, synusb->data[1] & 0x01);
 104         input_report_key(input_dev, BTN_MIDDLE, synusb->data[1] & 0x02);
 105 }
 106
 107 static void synusb_report_stick(struct synusb *synusb)
 108 {
 109         struct input_dev *input_dev = synusb->input;
 110         int x, y;
 111         unsigned int pressure;
 112
 113         pressure = synusb->data[6];
 114         x = (s16)(be16_to_cpup((__be16 *)&synusb->data[2]) << 3) >> 7;
 115         y = (s16)(be16_to_cpup((__be16 *)&synusb->data[4]) << 3) >> 7;
 116
 117         if (pressure > 0) {
 118                 input_report_rel(input_dev, REL_X, x);
 119                 input_report_rel(input_dev, REL_Y, -y);
 120         }
 121
 122         input_report_abs(input_dev, ABS_PRESSURE, pressure);
 123
 124         synusb_report_buttons(synusb);
 125
 126         input_sync(input_dev);
 127 }
 128
 129 static void synusb_report_touchpad(struct synusb *synusb)
 130 {
 131         struct input_dev *input_dev = synusb->input;
 132         unsigned int num_fingers, tool_width;
 133         unsigned int x, y;
 134         unsigned int pressure, w;
 135
 136         pressure = synusb->data[6];
 137         x = be16_to_cpup((__be16 *)&synusb->data[2]);
 138         y = be16_to_cpup((__be16 *)&synusb->data[4]);
 139         w = synusb->data[0] & 0x0f;
 140
 141         if (pressure > 0) {
 142                 num_fingers = 1;
 143                 tool_width = 5;
 144                 switch (w) {
 145                 case 0 ... 1:
 146                         num_fingers = 2 + w;
 147                         break;
 148
 149                 case 2:                 /* pen, pretend its a finger */
 150                         break;
 151
 152                 case 4 ... 15:
 153                         tool_width = w;
 154                         break;
 155                 }
 156         } else {
 157                 num_fingers = 0;
 158                 tool_width = 0;
 159         }
 160
 161         /*
 162          * Post events
 163          * BTN_TOUCH has to be first as mousedev relies on it when doing
 164          * absolute -> relative conversion
 165          */
 166
 167         if (pressure > 30)
 168                 input_report_key(input_dev, BTN_TOUCH, 1);
 169         if (pressure < 25)
 170                 input_report_key(input_dev, BTN_TOUCH, 0);
 171
 172         if (num_fingers > 0) {
 173                 input_report_abs(input_dev, ABS_X, x);
 174                 input_report_abs(input_dev, ABS_Y,
 175                                  YMAX_NOMINAL + YMIN_NOMINAL - y);
 176         }
 177
 178         input_report_abs(input_dev, ABS_PRESSURE, pressure);
 179         input_report_abs(input_dev, ABS_TOOL_WIDTH, tool_width);
 180
 181         input_report_key(input_dev, BTN_TOOL_FINGER, num_fingers == 1);
 182         input_report_key(input_dev, BTN_TOOL_DOUBLETAP, num_fingers == 2);
 183         input_report_key(input_dev, BTN_TOOL_TRIPLETAP, num_fingers == 3);
 184
 185         synusb_report_buttons(synusb);
 186         if (synusb->flags & SYNUSB_AUXDISPLAY)
 187                 input_report_key(input_dev, BTN_MIDDLE, synusb->data[1] & 0x08);
 188
 189         input_sync(input_dev);
 190 }
 191
 192 static void synusb_irq(struct urb *urb)
 193 {
 194         struct synusb *synusb = urb->context;
 195         int error;
 196
 197         /* Check our status in case we need to bail out early. */
 198         switch (urb->status) {
 199         case 0:
 200                 usb_mark_last_busy(synusb->udev);
 201                 break;
 202
 203         /* Device went away so don't keep trying to read from it. */
 204         case -ECONNRESET:
 205         case -ENOENT:
 206         case -ESHUTDOWN:
 207                 return;
 208
 209         default:
 210                 goto resubmit;
 211                 break;
 212         }
 213
 214         if (synusb->flags & SYNUSB_STICK)
 215                 synusb_report_stick(synusb);
 216         else
 217                 synusb_report_touchpad(synusb);
 218
 219 resubmit:
 220         error = usb_submit_urb(urb, GFP_ATOMIC);
 221         if (error && error != -EPERM)
 222                 dev_err(&synusb->intf->dev,
 223                         "%s - usb_submit_urb failed with result: %d",
 224                         __func__, error);
 225 }
 226
 227 static struct usb_endpoint_descriptor *
 228 synusb_get_in_endpoint(struct usb_host_interface *iface)
 229 {
 230
 231         struct usb_endpoint_descriptor *endpoint;
 232         int i;
 233
 234         for (i = 0; i < iface->desc.bNumEndpoints; ++i) {
 235                 endpoint = &iface->endpoint[i].desc;
 236
 237                 if (usb_endpoint_is_int_in(endpoint)) {
 238                         /* we found our interrupt in endpoint */
 239                         return endpoint;
 240                 }
 241         }
 242
 243         return NULL;
 244 }
 245
 246 static int synusb_open(struct input_dev *dev)
 247 {
 248         struct synusb *synusb = input_get_drvdata(dev);
 249         int retval;
 250
 251         retval = usb_autopm_get_interface(synusb->intf);
 252         if (retval) {
 253                 dev_err(&synusb->intf->dev,
 254                         "%s - usb_autopm_get_interface failed, error: %d\n",
 255                         __func__, retval);
 256                 return retval;
 257         }
 258
 259         mutex_lock(&synusb->pm_mutex);
 260         retval = usb_submit_urb(synusb->urb, GFP_KERNEL);
 261         if (retval) {
 262                 dev_err(&synusb->intf->dev,
 263                         "%s - usb_submit_urb failed, error: %d\n",
 264                         __func__, retval);
 265                 retval = -EIO;
 266                 goto out;
 267         }
 268
 269         synusb->intf->needs_remote_wakeup = 1;
 270         synusb->is_open = true;
 271
 272 out:
 273         mutex_unlock(&synusb->pm_mutex);
 274         usb_autopm_put_interface(synusb->intf);
 275         return retval;
 276 }
 277
 278 static void synusb_close(struct input_dev *dev)
 279 {
 280         struct synusb *synusb = input_get_drvdata(dev);
 281         int autopm_error;
 282
 283         autopm_error = usb_autopm_get_interface(synusb->intf);
 284
 285         mutex_lock(&synusb->pm_mutex);
 286         usb_kill_urb(synusb->urb);
 287         synusb->intf->needs_remote_wakeup = 0;
 288         synusb->is_open = false;
 289         mutex_unlock(&synusb->pm_mutex);
 290
 291         if (!autopm_error)
 292                 usb_autopm_put_interface(synusb->intf);
 293 }
 294
 295 static int synusb_probe(struct usb_interface *intf,
 296                         const struct usb_device_id *id)
 297 {
 298         struct usb_device *udev = interface_to_usbdev(intf);
 299         struct usb_endpoint_descriptor *ep;
 300         struct synusb *synusb;
 301         struct input_dev *input_dev;
 302         unsigned int intf_num = intf->cur_altsetting->desc.bInterfaceNumber;
 303         unsigned int altsetting = min(intf->num_altsetting, 1U);
 304         int error;
 305
 306         error = usb_set_interface(udev, intf_num, altsetting);
 307         if (error) {
 308                 dev_err(&udev->dev,
 309                         "Can not set alternate setting to %i, error: %i",
 310                         altsetting, error);
 311                 return error;
 312         }
 313
 314         ep = synusb_get_in_endpoint(intf->cur_altsetting);
 315         if (!ep)
 316                 return -ENODEV;
 317
 318         synusb = kzalloc(sizeof(*synusb), GFP_KERNEL);
 319         input_dev = input_allocate_device();
 320         if (!synusb || !input_dev) {
 321                 error = -ENOMEM;
 322                 goto err_free_mem;
 323         }
 324
 325         synusb->udev = udev;
 326         synusb->intf = intf;
 327         synusb->input = input_dev;
 328         mutex_init(&synusb->pm_mutex);
 329
 330         synusb->flags = id->driver_info;
 331         if (synusb->flags & SYNUSB_COMBO) {
 332                 /*
 333                  * This is a combo device, we need to set proper
 334                  * capability, depending on the interface.
 335                  */
 336                 synusb->flags |= intf_num == 1 ?
 337                                         SYNUSB_STICK : SYNUSB_TOUCHPAD;
 338         }
 339
 340         synusb->urb = usb_alloc_urb(0, GFP_KERNEL);
 341         if (!synusb->urb) {
 342                 error = -ENOMEM;
 343                 goto err_free_mem;
 344         }
 345
 346         synusb->data = usb_alloc_coherent(udev, SYNUSB_RECV_SIZE, GFP_KERNEL,
 347                                           &synusb->urb->transfer_dma);
 348         if (!synusb->data) {
 349                 error = -ENOMEM;
 350                 goto err_free_urb;
 351         }
 352
 353         usb_fill_int_urb(synusb->urb, udev,
 354                          usb_rcvintpipe(udev, ep->bEndpointAddress),
 355                          synusb->data, SYNUSB_RECV_SIZE,
 356                          synusb_irq, synusb,
 357                          ep->bInterval);
 358         synusb->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 359
 360         if (udev->manufacturer)
 361                 strlcpy(synusb->name, udev->manufacturer,
 362                         sizeof(synusb->name));
 363
 364         if (udev->product) {
 365                 if (udev->manufacturer)
 366                         strlcat(synusb->name, " ", sizeof(synusb->name));
 367                 strlcat(synusb->name, udev->product, sizeof(synusb->name));
 368         }
 369
 370         if (!strlen(synusb->name))
 371                 snprintf(synusb->name, sizeof(synusb->name),
 372                          "USB Synaptics Device %04x:%04x",
 373                          le16_to_cpu(udev->descriptor.idVendor),
 374                          le16_to_cpu(udev->descriptor.idProduct));
 375
 376         if (synusb->flags & SYNUSB_STICK)
 377                 strlcat(synusb->name, " (Stick)", sizeof(synusb->name));
 378
 379         usb_make_path(udev, synusb->phys, sizeof(synusb->phys));
 380         strlcat(synusb->phys, "/input0", sizeof(synusb->phys));
 381
 382         input_dev->name = synusb->name;
 383         input_dev->phys = synusb->phys;
 384         usb_to_input_id(udev, &input_dev->id);
 385         input_dev->dev.parent = &synusb->intf->dev;
 386
 387         if (!(synusb->flags & SYNUSB_IO_ALWAYS)) {
 388                 input_dev->open = synusb_open;
 389                 input_dev->close = synusb_close;
 390         }
 391
 392         input_set_drvdata(input_dev, synusb);
 393
 394         __set_bit(EV_ABS, input_dev->evbit);
 395         __set_bit(EV_KEY, input_dev->evbit);
 396
 397         if (synusb->flags & SYNUSB_STICK) {
 398                 __set_bit(EV_REL, input_dev->evbit);
 399                 __set_bit(REL_X, input_dev->relbit);
 400                 __set_bit(REL_Y, input_dev->relbit);
 401                 __set_bit(INPUT_PROP_POINTING_STICK, input_dev->propbit);
 402                 input_set_abs_params(input_dev, ABS_PRESSURE, 0, 127, 0, 0);
 403         } else {
 404                 input_set_abs_params(input_dev, ABS_X,
 405                                      XMIN_NOMINAL, XMAX_NOMINAL, 0, 0);
 406                 input_set_abs_params(input_dev, ABS_Y,
 407                                      YMIN_NOMINAL, YMAX_NOMINAL, 0, 0);
 408                 input_set_abs_params(input_dev, ABS_PRESSURE, 0, 255, 0, 0);
 409                 input_set_abs_params(input_dev, ABS_TOOL_WIDTH, 0, 15, 0, 0);
 410                 __set_bit(BTN_TOUCH, input_dev->keybit);
 411                 __set_bit(BTN_TOOL_FINGER, input_dev->keybit);
 412                 __set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit);
 413                 __set_bit(BTN_TOOL_TRIPLETAP, input_dev->keybit);
 414         }
 415
 416         if (synusb->flags & SYNUSB_TOUCHSCREEN)
 417                 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
 418         else
 419                 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
 420
 421         __set_bit(BTN_LEFT, input_dev->keybit);
 422         __set_bit(BTN_RIGHT, input_dev->keybit);
 423         __set_bit(BTN_MIDDLE, input_dev->keybit);
 424
 425         usb_set_intfdata(intf, synusb);
 426
 427         if (synusb->flags & SYNUSB_IO_ALWAYS) {
 428                 error = synusb_open(input_dev);
 429                 if (error)
 430                         goto err_free_dma;
 431         }
 432
 433         error = input_register_device(input_dev);
 434         if (error) {
 435                 dev_err(&udev->dev,
 436                         "Failed to register input device, error %d\n",
 437                         error);
 438                 goto err_stop_io;
 439         }
 440
 441         return 0;
 442
 443 err_stop_io:
 444         if (synusb->flags & SYNUSB_IO_ALWAYS)
 445                 synusb_close(synusb->input);
 446 err_free_dma:
 447         usb_free_coherent(udev, SYNUSB_RECV_SIZE, synusb->data,
 448                           synusb->urb->transfer_dma);
 449 err_free_urb:
 450         usb_free_urb(synusb->urb);
 451 err_free_mem:
 452         input_free_device(input_dev);
 453         kfree(synusb);
 454         usb_set_intfdata(intf, NULL);
 455
 456         return error;
 457 }
 458
 459 static void synusb_disconnect(struct usb_interface *intf)
 460 {
 461         struct synusb *synusb = usb_get_intfdata(intf);
 462         struct usb_device *udev = interface_to_usbdev(intf);
 463
 464         if (synusb->flags & SYNUSB_IO_ALWAYS)
 465                 synusb_close(synusb->input);
 466
 467         input_unregister_device(synusb->input);
 468
 469         usb_free_coherent(udev, SYNUSB_RECV_SIZE, synusb->data,
 470                           synusb->urb->transfer_dma);
 471         usb_free_urb(synusb->urb);
 472         kfree(synusb);
 473
 474         usb_set_intfdata(intf, NULL);
 475 }
 476
 477 static int synusb_suspend(struct usb_interface *intf, pm_message_t message)
 478 {
 479         struct synusb *synusb = usb_get_intfdata(intf);
 480
 481         mutex_lock(&synusb->pm_mutex);
 482         usb_kill_urb(synusb->urb);
 483         mutex_unlock(&synusb->pm_mutex);
 484
 485         return 0;
 486 }
 487
 488 static int synusb_resume(struct usb_interface *intf)
 489 {
 490         struct synusb *synusb = usb_get_intfdata(intf);
 491         int retval = 0;
 492
 493         mutex_lock(&synusb->pm_mutex);
 494
 495         if ((synusb->is_open || (synusb->flags & SYNUSB_IO_ALWAYS)) &&
 496             usb_submit_urb(synusb->urb, GFP_NOIO) < 0) {
 497                 retval = -EIO;
 498         }
 499
 500         mutex_unlock(&synusb->pm_mutex);
 501
 502         return retval;
 503 }
 504
 505 static int synusb_pre_reset(struct usb_interface *intf)
 506 {
 507         struct synusb *synusb = usb_get_intfdata(intf);
 508
 509         mutex_lock(&synusb->pm_mutex);
 510         usb_kill_urb(synusb->urb);
 511
 512         return 0;
 513 }
 514
 515 static int synusb_post_reset(struct usb_interface *intf)
 516 {
 517         struct synusb *synusb = usb_get_intfdata(intf);
 518         int retval = 0;
 519
 520         if ((synusb->is_open || (synusb->flags & SYNUSB_IO_ALWAYS)) &&
 521             usb_submit_urb(synusb->urb, GFP_NOIO) < 0) {
 522                 retval = -EIO;
 523         }
 524
 525         mutex_unlock(&synusb->pm_mutex);
 526
 527         return retval;
 528 }
 529
 530 static int synusb_reset_resume(struct usb_interface *intf)
 531 {
 532         return synusb_resume(intf);
 533 }
 534
 535 static const struct usb_device_id synusb_idtable[] = {
 536         { USB_DEVICE_SYNAPTICS(TP, SYNUSB_TOUCHPAD) },
 537         { USB_DEVICE_SYNAPTICS(INT_TP, SYNUSB_TOUCHPAD) },
 538         { USB_DEVICE_SYNAPTICS(CPAD,
 539                 SYNUSB_TOUCHPAD | SYNUSB_AUXDISPLAY | SYNUSB_IO_ALWAYS) },
 540         { USB_DEVICE_SYNAPTICS(TS, SYNUSB_TOUCHSCREEN) },
 541         { USB_DEVICE_SYNAPTICS(STICK, SYNUSB_STICK) },
 542         { USB_DEVICE_SYNAPTICS(WP, SYNUSB_TOUCHPAD) },
 543         { USB_DEVICE_SYNAPTICS(COMP_TP, SYNUSB_COMBO) },
 544         { USB_DEVICE_SYNAPTICS(WTP, SYNUSB_TOUCHPAD) },
 545         { USB_DEVICE_SYNAPTICS(DPAD, SYNUSB_TOUCHPAD) },
 546         { }
 547 };
 548 MODULE_DEVICE_TABLE(usb, synusb_idtable);
 549
 550 static struct usb_driver synusb_driver = {
 551         .name           = "synaptics_usb",
 552         .probe          = synusb_probe,
 553         .disconnect     = synusb_disconnect,
 554         .id_table       = synusb_idtable,
 555         .suspend        = synusb_suspend,
 556         .resume         = synusb_resume,
 557         .pre_reset      = synusb_pre_reset,
 558         .post_reset     = synusb_post_reset,
 559         .reset_resume   = synusb_reset_resume,
 560         .supports_autosuspend = 1,
 561 };
 562
 563 module_usb_driver(synusb_driver);
 564
 565 MODULE_AUTHOR("Rob Miller <rob@inpharmatica.co.uk>, "
 566               "Ron Lee <ron@debian.org>, "
 567               "Jan Steinhoff <cpad@jan-steinhoff.de>");
 568 MODULE_DESCRIPTION("Synaptics USB device driver");
 569 MODULE_LICENSE("GPL");