1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/kernel.h>
15#include <linux/input.h>
16#include <linux/slab.h>
17#include <linux/usb.h>
18#include <linux/usb/input.h>
19
20#include "uvcvideo.h"
21
22
23
24
25#ifdef CONFIG_USB_VIDEO_CLASS_INPUT_EVDEV
26static int uvc_input_init(struct uvc_device *dev)
27{
28 struct input_dev *input;
29 int ret;
30
31 input = input_allocate_device();
32 if (input == NULL)
33 return -ENOMEM;
34
35 usb_make_path(dev->udev, dev->input_phys, sizeof(dev->input_phys));
36 strlcat(dev->input_phys, "/button", sizeof(dev->input_phys));
37
38 input->name = dev->name;
39 input->phys = dev->input_phys;
40 usb_to_input_id(dev->udev, &input->id);
41 input->dev.parent = &dev->intf->dev;
42
43 __set_bit(EV_KEY, input->evbit);
44 __set_bit(KEY_CAMERA, input->keybit);
45
46 if ((ret = input_register_device(input)) < 0)
47 goto error;
48
49 dev->input = input;
50 return 0;
51
52error:
53 input_free_device(input);
54 return ret;
55}
56
57static void uvc_input_cleanup(struct uvc_device *dev)
58{
59 if (dev->input)
60 input_unregister_device(dev->input);
61}
62
63static void uvc_input_report_key(struct uvc_device *dev, unsigned int code,
64 int value)
65{
66 if (dev->input) {
67 input_report_key(dev->input, code, value);
68 input_sync(dev->input);
69 }
70}
71
72#else
73#define uvc_input_init(dev)
74#define uvc_input_cleanup(dev)
75#define uvc_input_report_key(dev, code, value)
76#endif
77
78
79
80
81static void uvc_event_streaming(struct uvc_device *dev, __u8 *data, int len)
82{
83 if (len < 3) {
84 uvc_trace(UVC_TRACE_STATUS, "Invalid streaming status event "
85 "received.\n");
86 return;
87 }
88
89 if (data[2] == 0) {
90 if (len < 4)
91 return;
92 uvc_trace(UVC_TRACE_STATUS, "Button (intf %u) %s len %d\n",
93 data[1], data[3] ? "pressed" : "released", len);
94 uvc_input_report_key(dev, KEY_CAMERA, data[3]);
95 } else {
96 uvc_trace(UVC_TRACE_STATUS, "Stream %u error event %02x %02x "
97 "len %d.\n", data[1], data[2], data[3], len);
98 }
99}
100
101static void uvc_event_control(struct uvc_device *dev, __u8 *data, int len)
102{
103 char *attrs[3] = { "value", "info", "failure" };
104
105 if (len < 6 || data[2] != 0 || data[4] > 2) {
106 uvc_trace(UVC_TRACE_STATUS, "Invalid control status event "
107 "received.\n");
108 return;
109 }
110
111 uvc_trace(UVC_TRACE_STATUS, "Control %u/%u %s change len %d.\n",
112 data[1], data[3], attrs[data[4]], len);
113}
114
115static void uvc_status_complete(struct urb *urb)
116{
117 struct uvc_device *dev = urb->context;
118 int len, ret;
119
120 switch (urb->status) {
121 case 0:
122 break;
123
124 case -ENOENT:
125 case -ECONNRESET:
126 case -ESHUTDOWN:
127 case -EPROTO:
128
129 return;
130
131 default:
132 uvc_printk(KERN_WARNING, "Non-zero status (%d) in status "
133 "completion handler.\n", urb->status);
134 return;
135 }
136
137 len = urb->actual_length;
138 if (len > 0) {
139 switch (dev->status[0] & 0x0f) {
140 case UVC_STATUS_TYPE_CONTROL:
141 uvc_event_control(dev, dev->status, len);
142 break;
143
144 case UVC_STATUS_TYPE_STREAMING:
145 uvc_event_streaming(dev, dev->status, len);
146 break;
147
148 default:
149 uvc_trace(UVC_TRACE_STATUS, "Unknown status event "
150 "type %u.\n", dev->status[0]);
151 break;
152 }
153 }
154
155
156 urb->interval = dev->int_ep->desc.bInterval;
157 if ((ret = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
158 uvc_printk(KERN_ERR, "Failed to resubmit status URB (%d).\n",
159 ret);
160 }
161}
162
163int uvc_status_init(struct uvc_device *dev)
164{
165 struct usb_host_endpoint *ep = dev->int_ep;
166 unsigned int pipe;
167 int interval;
168
169 if (ep == NULL)
170 return 0;
171
172 uvc_input_init(dev);
173
174 dev->status = kzalloc(UVC_MAX_STATUS_SIZE, GFP_KERNEL);
175 if (dev->status == NULL)
176 return -ENOMEM;
177
178 dev->int_urb = usb_alloc_urb(0, GFP_KERNEL);
179 if (dev->int_urb == NULL) {
180 kfree(dev->status);
181 return -ENOMEM;
182 }
183
184 pipe = usb_rcvintpipe(dev->udev, ep->desc.bEndpointAddress);
185
186
187
188
189 interval = ep->desc.bInterval;
190 if (interval > 16 && dev->udev->speed == USB_SPEED_HIGH &&
191 (dev->quirks & UVC_QUIRK_STATUS_INTERVAL))
192 interval = fls(interval) - 1;
193
194 usb_fill_int_urb(dev->int_urb, dev->udev, pipe,
195 dev->status, UVC_MAX_STATUS_SIZE, uvc_status_complete,
196 dev, interval);
197
198 return 0;
199}
200
201void uvc_status_cleanup(struct uvc_device *dev)
202{
203 usb_kill_urb(dev->int_urb);
204 usb_free_urb(dev->int_urb);
205 kfree(dev->status);
206 uvc_input_cleanup(dev);
207}
208
209int uvc_status_start(struct uvc_device *dev, gfp_t flags)
210{
211 if (dev->int_urb == NULL)
212 return 0;
213
214 return usb_submit_urb(dev->int_urb, flags);
215}
216
217void uvc_status_stop(struct uvc_device *dev)
218{
219 usb_kill_urb(dev->int_urb);
220}
221