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/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         /* input device related data structures */
 86         struct input_dev *input;
 87         char name[128];
 88         char phys[64];
 89 
 90         /* characteristics of the device */
 91         unsigned long flags;
 92 };
 93 
 94 static void synusb_report_buttons(struct synusb *synusb)
 95 {
 96         struct input_dev *input_dev = synusb->input;
 97 
 98         input_report_key(input_dev, BTN_LEFT, synusb->data[1] & 0x04);
 99         input_report_key(input_dev, BTN_RIGHT, synusb->data[1] & 0x01);
100         input_report_key(input_dev, BTN_MIDDLE, synusb->data[1] & 0x02);
101 }
102 
103 static void synusb_report_stick(struct synusb *synusb)
104 {
105         struct input_dev *input_dev = synusb->input;
106         int x, y;
107         unsigned int pressure;
108 
109         pressure = synusb->data[6];
110         x = (s16)(be16_to_cpup((__be16 *)&synusb->data[2]) << 3) >> 7;
111         y = (s16)(be16_to_cpup((__be16 *)&synusb->data[4]) << 3) >> 7;
112 
113         if (pressure > 0) {
114                 input_report_rel(input_dev, REL_X, x);
115                 input_report_rel(input_dev, REL_Y, -y);
116         }
117 
118         input_report_abs(input_dev, ABS_PRESSURE, pressure);
119 
120         synusb_report_buttons(synusb);
121 
122         input_sync(input_dev);
123 }
124 
125 static void synusb_report_touchpad(struct synusb *synusb)
126 {
127         struct input_dev *input_dev = synusb->input;
128         unsigned int num_fingers, tool_width;
129         unsigned int x, y;
130         unsigned int pressure, w;
131 
132         pressure = synusb->data[6];
133         x = be16_to_cpup((__be16 *)&synusb->data[2]);
134         y = be16_to_cpup((__be16 *)&synusb->data[4]);
135         w = synusb->data[0] & 0x0f;
136 
137         if (pressure > 0) {
138                 num_fingers = 1;
139                 tool_width = 5;
140                 switch (w) {
141                 case 0 ... 1:
142                         num_fingers = 2 + w;
143                         break;
144 
145                 case 2:                 /* pen, pretend its a finger */
146                         break;
147 
148                 case 4 ... 15:
149                         tool_width = w;
150                         break;
151                 }
152         } else {
153                 num_fingers = 0;
154                 tool_width = 0;
155         }
156 
157         /*
158          * Post events
159          * BTN_TOUCH has to be first as mousedev relies on it when doing
160          * absolute -> relative conversion
161          */
162 
163         if (pressure > 30)
164                 input_report_key(input_dev, BTN_TOUCH, 1);
165         if (pressure < 25)
166                 input_report_key(input_dev, BTN_TOUCH, 0);
167 
168         if (num_fingers > 0) {
169                 input_report_abs(input_dev, ABS_X, x);
170                 input_report_abs(input_dev, ABS_Y,
171                                  YMAX_NOMINAL + YMIN_NOMINAL - y);
172         }
173 
174         input_report_abs(input_dev, ABS_PRESSURE, pressure);
175         input_report_abs(input_dev, ABS_TOOL_WIDTH, tool_width);
176 
177         input_report_key(input_dev, BTN_TOOL_FINGER, num_fingers == 1);
178         input_report_key(input_dev, BTN_TOOL_DOUBLETAP, num_fingers == 2);
179         input_report_key(input_dev, BTN_TOOL_TRIPLETAP, num_fingers == 3);
180 
181         synusb_report_buttons(synusb);
182         if (synusb->flags & SYNUSB_AUXDISPLAY)
183                 input_report_key(input_dev, BTN_MIDDLE, synusb->data[1] & 0x08);
184 
185         input_sync(input_dev);
186 }
187 
188 static void synusb_irq(struct urb *urb)
189 {
190         struct synusb *synusb = urb->context;
191         int error;
192 
193         /* Check our status in case we need to bail out early. */
194         switch (urb->status) {
195         case 0:
196                 usb_mark_last_busy(synusb->udev);
197                 break;
198 
199         /* Device went away so don't keep trying to read from it. */
200         case -ECONNRESET:
201         case -ENOENT:
202         case -ESHUTDOWN:
203                 return;
204 
205         default:
206                 goto resubmit;
207                 break;
208         }
209 
210         if (synusb->flags & SYNUSB_STICK)
211                 synusb_report_stick(synusb);
212         else
213                 synusb_report_touchpad(synusb);
214 
215 resubmit:
216         error = usb_submit_urb(urb, GFP_ATOMIC);
217         if (error && error != -EPERM)
218                 dev_err(&synusb->intf->dev,
219                         "%s - usb_submit_urb failed with result: %d",
220                         __func__, error);
221 }
222 
223 static struct usb_endpoint_descriptor *
224 synusb_get_in_endpoint(struct usb_host_interface *iface)
225 {
226 
227         struct usb_endpoint_descriptor *endpoint;
228         int i;
229 
230         for (i = 0; i < iface->desc.bNumEndpoints; ++i) {
231                 endpoint = &iface->endpoint[i].desc;
232 
233                 if (usb_endpoint_is_int_in(endpoint)) {
234                         /* we found our interrupt in endpoint */
235                         return endpoint;
236                 }
237         }
238 
239         return NULL;
240 }
241 
242 static int synusb_open(struct input_dev *dev)
243 {
244         struct synusb *synusb = input_get_drvdata(dev);
245         int retval;
246 
247         retval = usb_autopm_get_interface(synusb->intf);
248         if (retval) {
249                 dev_err(&synusb->intf->dev,
250                         "%s - usb_autopm_get_interface failed, error: %d\n",
251                         __func__, retval);
252                 return retval;
253         }
254 
255         retval = usb_submit_urb(synusb->urb, GFP_KERNEL);
256         if (retval) {
257                 dev_err(&synusb->intf->dev,
258                         "%s - usb_submit_urb failed, error: %d\n",
259                         __func__, retval);
260                 retval = -EIO;
261                 goto out;
262         }
263 
264         synusb->intf->needs_remote_wakeup = 1;
265 
266 out:
267         usb_autopm_put_interface(synusb->intf);
268         return retval;
269 }
270 
271 static void synusb_close(struct input_dev *dev)
272 {
273         struct synusb *synusb = input_get_drvdata(dev);
274         int autopm_error;
275 
276         autopm_error = usb_autopm_get_interface(synusb->intf);
277 
278         usb_kill_urb(synusb->urb);
279         synusb->intf->needs_remote_wakeup = 0;
280 
281         if (!autopm_error)
282                 usb_autopm_put_interface(synusb->intf);
283 }
284 
285 static int synusb_probe(struct usb_interface *intf,
286                         const struct usb_device_id *id)
287 {
288         struct usb_device *udev = interface_to_usbdev(intf);
289         struct usb_endpoint_descriptor *ep;
290         struct synusb *synusb;
291         struct input_dev *input_dev;
292         unsigned int intf_num = intf->cur_altsetting->desc.bInterfaceNumber;
293         unsigned int altsetting = min(intf->num_altsetting, 1U);
294         int error;
295 
296         error = usb_set_interface(udev, intf_num, altsetting);
297         if (error) {
298                 dev_err(&udev->dev,
299                         "Can not set alternate setting to %i, error: %i",
300                         altsetting, error);
301                 return error;
302         }
303 
304         ep = synusb_get_in_endpoint(intf->cur_altsetting);
305         if (!ep)
306                 return -ENODEV;
307 
308         synusb = kzalloc(sizeof(*synusb), GFP_KERNEL);
309         input_dev = input_allocate_device();
310         if (!synusb || !input_dev) {
311                 error = -ENOMEM;
312                 goto err_free_mem;
313         }
314 
315         synusb->udev = udev;
316         synusb->intf = intf;
317         synusb->input = input_dev;
318 
319         synusb->flags = id->driver_info;
320         if (synusb->flags & SYNUSB_COMBO) {
321                 /*
322                  * This is a combo device, we need to set proper
323                  * capability, depending on the interface.
324                  */
325                 synusb->flags |= intf_num == 1 ?
326                                         SYNUSB_STICK : SYNUSB_TOUCHPAD;
327         }
328 
329         synusb->urb = usb_alloc_urb(0, GFP_KERNEL);
330         if (!synusb->urb) {
331                 error = -ENOMEM;
332                 goto err_free_mem;
333         }
334 
335         synusb->data = usb_alloc_coherent(udev, SYNUSB_RECV_SIZE, GFP_KERNEL,
336                                           &synusb->urb->transfer_dma);
337         if (!synusb->data) {
338                 error = -ENOMEM;
339                 goto err_free_urb;
340         }
341 
342         usb_fill_int_urb(synusb->urb, udev,
343                          usb_rcvintpipe(udev, ep->bEndpointAddress),
344                          synusb->data, SYNUSB_RECV_SIZE,
345                          synusb_irq, synusb,
346                          ep->bInterval);
347         synusb->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
348 
349         if (udev->manufacturer)
350                 strlcpy(synusb->name, udev->manufacturer,
351                         sizeof(synusb->name));
352 
353         if (udev->product) {
354                 if (udev->manufacturer)
355                         strlcat(synusb->name, " ", sizeof(synusb->name));
356                 strlcat(synusb->name, udev->product, sizeof(synusb->name));
357         }
358 
359         if (!strlen(synusb->name))
360                 snprintf(synusb->name, sizeof(synusb->name),
361                          "USB Synaptics Device %04x:%04x",
362                          le16_to_cpu(udev->descriptor.idVendor),
363                          le16_to_cpu(udev->descriptor.idProduct));
364 
365         if (synusb->flags & SYNUSB_STICK)
366                 strlcat(synusb->name, " (Stick)", sizeof(synusb->name));
367 
368         usb_make_path(udev, synusb->phys, sizeof(synusb->phys));
369         strlcat(synusb->phys, "/input0", sizeof(synusb->phys));
370 
371         input_dev->name = synusb->name;
372         input_dev->phys = synusb->phys;
373         usb_to_input_id(udev, &input_dev->id);
374         input_dev->dev.parent = &synusb->intf->dev;
375 
376         if (!(synusb->flags & SYNUSB_IO_ALWAYS)) {
377                 input_dev->open = synusb_open;
378                 input_dev->close = synusb_close;
379         }
380 
381         input_set_drvdata(input_dev, synusb);
382 
383         __set_bit(EV_ABS, input_dev->evbit);
384         __set_bit(EV_KEY, input_dev->evbit);
385 
386         if (synusb->flags & SYNUSB_STICK) {
387                 __set_bit(EV_REL, input_dev->evbit);
388                 __set_bit(REL_X, input_dev->relbit);
389                 __set_bit(REL_Y, input_dev->relbit);
390                 input_set_abs_params(input_dev, ABS_PRESSURE, 0, 127, 0, 0);
391         } else {
392                 input_set_abs_params(input_dev, ABS_X,
393                                      XMIN_NOMINAL, XMAX_NOMINAL, 0, 0);
394                 input_set_abs_params(input_dev, ABS_Y,
395                                      YMIN_NOMINAL, YMAX_NOMINAL, 0, 0);
396                 input_set_abs_params(input_dev, ABS_PRESSURE, 0, 255, 0, 0);
397                 input_set_abs_params(input_dev, ABS_TOOL_WIDTH, 0, 15, 0, 0);
398                 __set_bit(BTN_TOUCH, input_dev->keybit);
399                 __set_bit(BTN_TOOL_FINGER, input_dev->keybit);
400                 __set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit);
401                 __set_bit(BTN_TOOL_TRIPLETAP, input_dev->keybit);
402         }
403 
404         __set_bit(BTN_LEFT, input_dev->keybit);
405         __set_bit(BTN_RIGHT, input_dev->keybit);
406         __set_bit(BTN_MIDDLE, input_dev->keybit);
407 
408         usb_set_intfdata(intf, synusb);
409 
410         if (synusb->flags & SYNUSB_IO_ALWAYS) {
411                 error = synusb_open(input_dev);
412                 if (error)
413                         goto err_free_dma;
414         }
415 
416         error = input_register_device(input_dev);
417         if (error) {
418                 dev_err(&udev->dev,
419                         "Failed to register input device, error %d\n",
420                         error);
421                 goto err_stop_io;
422         }
423 
424         return 0;
425 
426 err_stop_io:
427         if (synusb->flags & SYNUSB_IO_ALWAYS)
428                 synusb_close(synusb->input);
429 err_free_dma:
430         usb_free_coherent(udev, SYNUSB_RECV_SIZE, synusb->data,
431                           synusb->urb->transfer_dma);
432 err_free_urb:
433         usb_free_urb(synusb->urb);
434 err_free_mem:
435         input_free_device(input_dev);
436         kfree(synusb);
437         usb_set_intfdata(intf, NULL);
438 
439         return error;
440 }
441 
442 static void synusb_disconnect(struct usb_interface *intf)
443 {
444         struct synusb *synusb = usb_get_intfdata(intf);
445         struct usb_device *udev = interface_to_usbdev(intf);
446 
447         if (synusb->flags & SYNUSB_IO_ALWAYS)
448                 synusb_close(synusb->input);
449 
450         input_unregister_device(synusb->input);
451 
452         usb_free_coherent(udev, SYNUSB_RECV_SIZE, synusb->data,
453                           synusb->urb->transfer_dma);
454         usb_free_urb(synusb->urb);
455         kfree(synusb);
456 
457         usb_set_intfdata(intf, NULL);
458 }
459 
460 static int synusb_suspend(struct usb_interface *intf, pm_message_t message)
461 {
462         struct synusb *synusb = usb_get_intfdata(intf);
463         struct input_dev *input_dev = synusb->input;
464 
465         mutex_lock(&input_dev->mutex);
466         usb_kill_urb(synusb->urb);
467         mutex_unlock(&input_dev->mutex);
468 
469         return 0;
470 }
471 
472 static int synusb_resume(struct usb_interface *intf)
473 {
474         struct synusb *synusb = usb_get_intfdata(intf);
475         struct input_dev *input_dev = synusb->input;
476         int retval = 0;
477 
478         mutex_lock(&input_dev->mutex);
479 
480         if ((input_dev->users || (synusb->flags & SYNUSB_IO_ALWAYS)) &&
481             usb_submit_urb(synusb->urb, GFP_NOIO) < 0) {
482                 retval = -EIO;
483         }
484 
485         mutex_unlock(&input_dev->mutex);
486 
487         return retval;
488 }
489 
490 static int synusb_pre_reset(struct usb_interface *intf)
491 {
492         struct synusb *synusb = usb_get_intfdata(intf);
493         struct input_dev *input_dev = synusb->input;
494 
495         mutex_lock(&input_dev->mutex);
496         usb_kill_urb(synusb->urb);
497 
498         return 0;
499 }
500 
501 static int synusb_post_reset(struct usb_interface *intf)
502 {
503         struct synusb *synusb = usb_get_intfdata(intf);
504         struct input_dev *input_dev = synusb->input;
505         int retval = 0;
506 
507         if ((input_dev->users || (synusb->flags & SYNUSB_IO_ALWAYS)) &&
508             usb_submit_urb(synusb->urb, GFP_NOIO) < 0) {
509                 retval = -EIO;
510         }
511 
512         mutex_unlock(&input_dev->mutex);
513 
514         return retval;
515 }
516 
517 static int synusb_reset_resume(struct usb_interface *intf)
518 {
519         return synusb_resume(intf);
520 }
521 
522 static struct usb_device_id synusb_idtable[] = {
523         { USB_DEVICE_SYNAPTICS(TP, SYNUSB_TOUCHPAD) },
524         { USB_DEVICE_SYNAPTICS(INT_TP, SYNUSB_TOUCHPAD) },
525         { USB_DEVICE_SYNAPTICS(CPAD,
526                 SYNUSB_TOUCHPAD | SYNUSB_AUXDISPLAY | SYNUSB_IO_ALWAYS) },
527         { USB_DEVICE_SYNAPTICS(TS, SYNUSB_TOUCHSCREEN) },
528         { USB_DEVICE_SYNAPTICS(STICK, SYNUSB_STICK) },
529         { USB_DEVICE_SYNAPTICS(WP, SYNUSB_TOUCHPAD) },
530         { USB_DEVICE_SYNAPTICS(COMP_TP, SYNUSB_COMBO) },
531         { USB_DEVICE_SYNAPTICS(WTP, SYNUSB_TOUCHPAD) },
532         { USB_DEVICE_SYNAPTICS(DPAD, SYNUSB_TOUCHPAD) },
533         { }
534 };
535 MODULE_DEVICE_TABLE(usb, synusb_idtable);
536 
537 static struct usb_driver synusb_driver = {
538         .name           = "synaptics_usb",
539         .probe          = synusb_probe,
540         .disconnect     = synusb_disconnect,
541         .id_table       = synusb_idtable,
542         .suspend        = synusb_suspend,
543         .resume         = synusb_resume,
544         .pre_reset      = synusb_pre_reset,
545         .post_reset     = synusb_post_reset,
546         .reset_resume   = synusb_reset_resume,
547         .supports_autosuspend = 1,
548 };
549 
550 module_usb_driver(synusb_driver);
551 
552 MODULE_AUTHOR("Rob Miller <rob@inpharmatica.co.uk>, "
553               "Ron Lee <ron@debian.org>, "
554               "Jan Steinhoff <cpad@jan-steinhoff.de>");
555 MODULE_DESCRIPTION("Synaptics USB device driver");
556 MODULE_LICENSE("GPL");
557 

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