drivers/media/video/uvc/uvc_status.c

   1 /*
   2  *      uvc_status.c  --  USB Video Class driver - Status endpoint
   3  *
   4  *      Copyright (C) 2007-2009
   5  *          Laurent Pinchart (laurent.pinchart@skynet.be)
   6  *
   7  *      This program is free software; you can redistribute it and/or modify
   8  *      it under the terms of the GNU General Public License as published by
   9  *      the Free Software Foundation; either version 2 of the License, or
  10  *      (at your option) any later version.
  11  *
  12  */
  13
  14 #include <linux/kernel.h>
  15 #include <linux/input.h>
  16 #include <linux/usb.h>
  17 #include <linux/usb/input.h>
  18
  19 #include "uvcvideo.h"
  20
  21 /* --------------------------------------------------------------------------
  22  * Input device
  23  */
  24 #ifdef CONFIG_USB_VIDEO_CLASS_INPUT_EVDEV
  25 static int uvc_input_init(struct uvc_device *dev)
  26 {
  27         struct usb_device *udev = dev->udev;
  28         struct input_dev *input;
  29         char *phys = NULL;
  30         int ret;
  31
  32         input = input_allocate_device();
  33         if (input == NULL)
  34                 return -ENOMEM;
  35
  36         phys = kmalloc(6 + strlen(udev->bus->bus_name) + strlen(udev->devpath),
  37                         GFP_KERNEL);
  38         if (phys == NULL) {
  39                 ret = -ENOMEM;
  40                 goto error;
  41         }
  42         sprintf(phys, "usb-%s-%s", udev->bus->bus_name, udev->devpath);
  43
  44         input->name = dev->name;
  45         input->phys = phys;
  46         usb_to_input_id(udev, &input->id);
  47         input->dev.parent = &dev->intf->dev;
  48
  49         set_bit(EV_KEY, input->evbit);
  50         set_bit(BTN_0, input->keybit);
  51
  52         if ((ret = input_register_device(input)) < 0)
  53                 goto error;
  54
  55         dev->input = input;
  56         return 0;
  57
  58 error:
  59         input_free_device(input);
  60         kfree(phys);
  61         return ret;
  62 }
  63
  64 static void uvc_input_cleanup(struct uvc_device *dev)
  65 {
  66         if (dev->input)
  67                 input_unregister_device(dev->input);
  68 }
  69
  70 static void uvc_input_report_key(struct uvc_device *dev, unsigned int code,
  71         int value)
  72 {
  73         if (dev->input)
  74                 input_report_key(dev->input, code, value);
  75 }
  76
  77 #else
  78 #define uvc_input_init(dev)
  79 #define uvc_input_cleanup(dev)
  80 #define uvc_input_report_key(dev, code, value)
  81 #endif /* CONFIG_USB_VIDEO_CLASS_INPUT_EVDEV */
  82
  83 /* --------------------------------------------------------------------------
  84  * Status interrupt endpoint
  85  */
  86 static void uvc_event_streaming(struct uvc_device *dev, __u8 *data, int len)
  87 {
  88         if (len < 3) {
  89                 uvc_trace(UVC_TRACE_STATUS, "Invalid streaming status event "
  90                                 "received.\n");
  91                 return;
  92         }
  93
  94         if (data[2] == 0) {
  95                 if (len < 4)
  96                         return;
  97                 uvc_trace(UVC_TRACE_STATUS, "Button (intf %u) %s len %d\n",
  98                         data[1], data[3] ? "pressed" : "released", len);
  99                 uvc_input_report_key(dev, BTN_0, data[3]);
 100         } else {
 101                 uvc_trace(UVC_TRACE_STATUS, "Stream %u error event %02x %02x "
 102                         "len %d.\n", data[1], data[2], data[3], len);
 103         }
 104 }
 105
 106 static void uvc_event_control(struct uvc_device *dev, __u8 *data, int len)
 107 {
 108         char *attrs[3] = { "value", "info", "failure" };
 109
 110         if (len < 6 || data[2] != 0 || data[4] > 2) {
 111                 uvc_trace(UVC_TRACE_STATUS, "Invalid control status event "
 112                                 "received.\n");
 113                 return;
 114         }
 115
 116         uvc_trace(UVC_TRACE_STATUS, "Control %u/%u %s change len %d.\n",
 117                 data[1], data[3], attrs[data[4]], len);
 118 }
 119
 120 static void uvc_status_complete(struct urb *urb)
 121 {
 122         struct uvc_device *dev = urb->context;
 123         int len, ret;
 124
 125         switch (urb->status) {
 126         case 0:
 127                 break;
 128
 129         case -ENOENT:           /* usb_kill_urb() called. */
 130         case -ECONNRESET:       /* usb_unlink_urb() called. */
 131         case -ESHUTDOWN:        /* The endpoint is being disabled. */
 132         case -EPROTO:           /* Device is disconnected (reported by some
 133                                  * host controller). */
 134                 return;
 135
 136         default:
 137                 uvc_printk(KERN_WARNING, "Non-zero status (%d) in status "
 138                         "completion handler.\n", urb->status);
 139                 return;
 140         }
 141
 142         len = urb->actual_length;
 143         if (len > 0) {
 144                 switch (dev->status[0] & 0x0f) {
 145                 case UVC_STATUS_TYPE_CONTROL:
 146                         uvc_event_control(dev, dev->status, len);
 147                         break;
 148
 149                 case UVC_STATUS_TYPE_STREAMING:
 150                         uvc_event_streaming(dev, dev->status, len);
 151                         break;
 152
 153                 default:
 154                         uvc_printk(KERN_INFO, "unknown event type %u.\n",
 155                                 dev->status[0]);
 156                         break;
 157                 }
 158         }
 159
 160         /* Resubmit the URB. */
 161         urb->interval = dev->int_ep->desc.bInterval;
 162         if ((ret = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
 163                 uvc_printk(KERN_ERR, "Failed to resubmit status URB (%d).\n",
 164                         ret);
 165         }
 166 }
 167
 168 int uvc_status_init(struct uvc_device *dev)
 169 {
 170         struct usb_host_endpoint *ep = dev->int_ep;
 171         unsigned int pipe;
 172         int interval;
 173
 174         if (ep == NULL)
 175                 return 0;
 176
 177         uvc_input_init(dev);
 178
 179         dev->status = kzalloc(UVC_MAX_STATUS_SIZE, GFP_KERNEL);
 180         if (dev->status == NULL)
 181                 return -ENOMEM;
 182
 183         dev->int_urb = usb_alloc_urb(0, GFP_KERNEL);
 184         if (dev->int_urb == NULL) {
 185                 kfree(dev->status);
 186                 return -ENOMEM;
 187         }
 188
 189         pipe = usb_rcvintpipe(dev->udev, ep->desc.bEndpointAddress);
 190
 191         /* For high-speed interrupt endpoints, the bInterval value is used as
 192          * an exponent of two. Some developers forgot about it.
 193          */
 194         interval = ep->desc.bInterval;
 195         if (interval > 16 && dev->udev->speed == USB_SPEED_HIGH &&
 196             (dev->quirks & UVC_QUIRK_STATUS_INTERVAL))
 197                 interval = fls(interval) - 1;
 198
 199         usb_fill_int_urb(dev->int_urb, dev->udev, pipe,
 200                 dev->status, UVC_MAX_STATUS_SIZE, uvc_status_complete,
 201                 dev, interval);
 202
 203         return usb_submit_urb(dev->int_urb, GFP_KERNEL);
 204 }
 205
 206 void uvc_status_cleanup(struct uvc_device *dev)
 207 {
 208         usb_kill_urb(dev->int_urb);
 209         usb_free_urb(dev->int_urb);
 210         kfree(dev->status);
 211         uvc_input_cleanup(dev);
 212 }
 213
 214 int uvc_status_suspend(struct uvc_device *dev)
 215 {
 216         usb_kill_urb(dev->int_urb);
 217         return 0;
 218 }
 219
 220 int uvc_status_resume(struct uvc_device *dev)
 221 {
 222         if (dev->int_urb == NULL)
 223                 return 0;
 224
 225         return usb_submit_urb(dev->int_urb, GFP_NOIO);
 226 }
 227