Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6.git] / 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 input_dev *input;
28         int ret;
29
30         input = input_allocate_device();
31         if (input == NULL)
32                 return -ENOMEM;
33
34         usb_make_path(dev->udev, dev->input_phys, sizeof(dev->input_phys));
35         strlcat(dev->input_phys, "/button", sizeof(dev->input_phys));
36
37         input->name = dev->name;
38         input->phys = dev->input_phys;
39         usb_to_input_id(dev->udev, &input->id);
40         input->dev.parent = &dev->intf->dev;
41
42         __set_bit(EV_KEY, input->evbit);
43         __set_bit(KEY_CAMERA, input->keybit);
44
45         if ((ret = input_register_device(input)) < 0)
46                 goto error;
47
48         dev->input = input;
49         return 0;
50
51 error:
52         input_free_device(input);
53         return ret;
54 }
55
56 static void uvc_input_cleanup(struct uvc_device *dev)
57 {
58         if (dev->input)
59                 input_unregister_device(dev->input);
60 }
61
62 static void uvc_input_report_key(struct uvc_device *dev, unsigned int code,
63         int value)
64 {
65         if (dev->input) {
66                 input_report_key(dev->input, code, value);
67                 input_sync(dev->input);
68         }
69 }
70
71 #else
72 #define uvc_input_init(dev)
73 #define uvc_input_cleanup(dev)
74 #define uvc_input_report_key(dev, code, value)
75 #endif /* CONFIG_USB_VIDEO_CLASS_INPUT_EVDEV */
76
77 /* --------------------------------------------------------------------------
78  * Status interrupt endpoint
79  */
80 static void uvc_event_streaming(struct uvc_device *dev, __u8 *data, int len)
81 {
82         if (len < 3) {
83                 uvc_trace(UVC_TRACE_STATUS, "Invalid streaming status event "
84                                 "received.\n");
85                 return;
86         }
87
88         if (data[2] == 0) {
89                 if (len < 4)
90                         return;
91                 uvc_trace(UVC_TRACE_STATUS, "Button (intf %u) %s len %d\n",
92                         data[1], data[3] ? "pressed" : "released", len);
93                 uvc_input_report_key(dev, KEY_CAMERA, data[3]);
94         } else {
95                 uvc_trace(UVC_TRACE_STATUS, "Stream %u error event %02x %02x "
96                         "len %d.\n", data[1], data[2], data[3], len);
97         }
98 }
99
100 static void uvc_event_control(struct uvc_device *dev, __u8 *data, int len)
101 {
102         char *attrs[3] = { "value", "info", "failure" };
103
104         if (len < 6 || data[2] != 0 || data[4] > 2) {
105                 uvc_trace(UVC_TRACE_STATUS, "Invalid control status event "
106                                 "received.\n");
107                 return;
108         }
109
110         uvc_trace(UVC_TRACE_STATUS, "Control %u/%u %s change len %d.\n",
111                 data[1], data[3], attrs[data[4]], len);
112 }
113
114 static void uvc_status_complete(struct urb *urb)
115 {
116         struct uvc_device *dev = urb->context;
117         int len, ret;
118
119         switch (urb->status) {
120         case 0:
121                 break;
122
123         case -ENOENT:           /* usb_kill_urb() called. */
124         case -ECONNRESET:       /* usb_unlink_urb() called. */
125         case -ESHUTDOWN:        /* The endpoint is being disabled. */
126         case -EPROTO:           /* Device is disconnected (reported by some
127                                  * host controller). */
128                 return;
129
130         default:
131                 uvc_printk(KERN_WARNING, "Non-zero status (%d) in status "
132                         "completion handler.\n", urb->status);
133                 return;
134         }
135
136         len = urb->actual_length;
137         if (len > 0) {
138                 switch (dev->status[0] & 0x0f) {
139                 case UVC_STATUS_TYPE_CONTROL:
140                         uvc_event_control(dev, dev->status, len);
141                         break;
142
143                 case UVC_STATUS_TYPE_STREAMING:
144                         uvc_event_streaming(dev, dev->status, len);
145                         break;
146
147                 default:
148                         uvc_trace(UVC_TRACE_STATUS, "Unknown status event "
149                                 "type %u.\n", dev->status[0]);
150                         break;
151                 }
152         }
153
154         /* Resubmit the URB. */
155         urb->interval = dev->int_ep->desc.bInterval;
156         if ((ret = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
157                 uvc_printk(KERN_ERR, "Failed to resubmit status URB (%d).\n",
158                         ret);
159         }
160 }
161
162 int uvc_status_init(struct uvc_device *dev)
163 {
164         struct usb_host_endpoint *ep = dev->int_ep;
165         unsigned int pipe;
166         int interval;
167
168         if (ep == NULL)
169                 return 0;
170
171         uvc_input_init(dev);
172
173         dev->status = kzalloc(UVC_MAX_STATUS_SIZE, GFP_KERNEL);
174         if (dev->status == NULL)
175                 return -ENOMEM;
176
177         dev->int_urb = usb_alloc_urb(0, GFP_KERNEL);
178         if (dev->int_urb == NULL) {
179                 kfree(dev->status);
180                 return -ENOMEM;
181         }
182
183         pipe = usb_rcvintpipe(dev->udev, ep->desc.bEndpointAddress);
184
185         /* For high-speed interrupt endpoints, the bInterval value is used as
186          * an exponent of two. Some developers forgot about it.
187          */
188         interval = ep->desc.bInterval;
189         if (interval > 16 && dev->udev->speed == USB_SPEED_HIGH &&
190             (dev->quirks & UVC_QUIRK_STATUS_INTERVAL))
191                 interval = fls(interval) - 1;
192
193         usb_fill_int_urb(dev->int_urb, dev->udev, pipe,
194                 dev->status, UVC_MAX_STATUS_SIZE, uvc_status_complete,
195                 dev, interval);
196
197         return 0;
198 }
199
200 void uvc_status_cleanup(struct uvc_device *dev)
201 {
202         usb_kill_urb(dev->int_urb);
203         usb_free_urb(dev->int_urb);
204         kfree(dev->status);
205         uvc_input_cleanup(dev);
206 }
207
208 int uvc_status_start(struct uvc_device *dev)
209 {
210         if (dev->int_urb == NULL)
211                 return 0;
212
213         return usb_submit_urb(dev->int_urb, GFP_KERNEL);
214 }
215
216 void uvc_status_stop(struct uvc_device *dev)
217 {
218         usb_kill_urb(dev->int_urb);
219 }
220
221 int uvc_status_suspend(struct uvc_device *dev)
222 {
223         if (atomic_read(&dev->users))
224                 usb_kill_urb(dev->int_urb);
225
226         return 0;
227 }
228
229 int uvc_status_resume(struct uvc_device *dev)
230 {
231         if (dev->int_urb == NULL || atomic_read(&dev->users) == 0)
232                 return 0;
233
234         return usb_submit_urb(dev->int_urb, GFP_NOIO);
235 }
236