xref: /linux/drivers/media/usb/uvc/uvc_status.c (revision e9f0878c4b2004ac19581274c1ae4c61ae3ca70e)
1 /*
2  *      uvc_status.c  --  USB Video Class driver - Status endpoint
3  *
4  *      Copyright (C) 2005-2009
5  *          Laurent Pinchart (laurent.pinchart@ideasonboard.com)
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/slab.h>
17 #include <linux/usb.h>
18 #include <linux/usb/input.h>
19 
20 #include "uvcvideo.h"
21 
22 /* --------------------------------------------------------------------------
23  * Input device
24  */
25 #ifdef CONFIG_USB_VIDEO_CLASS_INPUT_EVDEV
26 static 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 
52 error:
53 	input_free_device(input);
54 	return ret;
55 }
56 
57 static void uvc_input_cleanup(struct uvc_device *dev)
58 {
59 	if (dev->input)
60 		input_unregister_device(dev->input);
61 }
62 
63 static 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 /* CONFIG_USB_VIDEO_CLASS_INPUT_EVDEV */
77 
78 /* --------------------------------------------------------------------------
79  * Status interrupt endpoint
80  */
81 struct uvc_streaming_status {
82 	u8	bStatusType;
83 	u8	bOriginator;
84 	u8	bEvent;
85 	u8	bValue[];
86 } __packed;
87 
88 struct uvc_control_status {
89 	u8	bStatusType;
90 	u8	bOriginator;
91 	u8	bEvent;
92 	u8	bSelector;
93 	u8	bAttribute;
94 	u8	bValue[];
95 } __packed;
96 
97 static void uvc_event_streaming(struct uvc_device *dev,
98 				struct uvc_streaming_status *status, int len)
99 {
100 	if (len < 3) {
101 		uvc_trace(UVC_TRACE_STATUS, "Invalid streaming status event "
102 				"received.\n");
103 		return;
104 	}
105 
106 	if (status->bEvent == 0) {
107 		if (len < 4)
108 			return;
109 		uvc_trace(UVC_TRACE_STATUS, "Button (intf %u) %s len %d\n",
110 			  status->bOriginator,
111 			  status->bValue[0] ? "pressed" : "released", len);
112 		uvc_input_report_key(dev, KEY_CAMERA, status->bValue[0]);
113 	} else {
114 		uvc_trace(UVC_TRACE_STATUS,
115 			  "Stream %u error event %02x len %d.\n",
116 			  status->bOriginator, status->bEvent, len);
117 	}
118 }
119 
120 #define UVC_CTRL_VALUE_CHANGE	0
121 #define UVC_CTRL_INFO_CHANGE	1
122 #define UVC_CTRL_FAILURE_CHANGE	2
123 #define UVC_CTRL_MIN_CHANGE	3
124 #define UVC_CTRL_MAX_CHANGE	4
125 
126 static struct uvc_control *uvc_event_entity_find_ctrl(struct uvc_entity *entity,
127 						      u8 selector)
128 {
129 	struct uvc_control *ctrl;
130 	unsigned int i;
131 
132 	for (i = 0, ctrl = entity->controls; i < entity->ncontrols; i++, ctrl++)
133 		if (ctrl->info.selector == selector)
134 			return ctrl;
135 
136 	return NULL;
137 }
138 
139 static struct uvc_control *uvc_event_find_ctrl(struct uvc_device *dev,
140 					const struct uvc_control_status *status,
141 					struct uvc_video_chain **chain)
142 {
143 	list_for_each_entry((*chain), &dev->chains, list) {
144 		struct uvc_entity *entity;
145 		struct uvc_control *ctrl;
146 
147 		list_for_each_entry(entity, &(*chain)->entities, chain) {
148 			if (entity->id != status->bOriginator)
149 				continue;
150 
151 			ctrl = uvc_event_entity_find_ctrl(entity,
152 							  status->bSelector);
153 			if (ctrl)
154 				return ctrl;
155 		}
156 	}
157 
158 	return NULL;
159 }
160 
161 static bool uvc_event_control(struct urb *urb,
162 			      const struct uvc_control_status *status, int len)
163 {
164 	static const char *attrs[] = { "value", "info", "failure", "min", "max" };
165 	struct uvc_device *dev = urb->context;
166 	struct uvc_video_chain *chain;
167 	struct uvc_control *ctrl;
168 
169 	if (len < 6 || status->bEvent != 0 ||
170 	    status->bAttribute >= ARRAY_SIZE(attrs)) {
171 		uvc_trace(UVC_TRACE_STATUS, "Invalid control status event "
172 				"received.\n");
173 		return false;
174 	}
175 
176 	uvc_trace(UVC_TRACE_STATUS, "Control %u/%u %s change len %d.\n",
177 		  status->bOriginator, status->bSelector,
178 		  attrs[status->bAttribute], len);
179 
180 	/* Find the control. */
181 	ctrl = uvc_event_find_ctrl(dev, status, &chain);
182 	if (!ctrl)
183 		return false;
184 
185 	switch (status->bAttribute) {
186 	case UVC_CTRL_VALUE_CHANGE:
187 		return uvc_ctrl_status_event(urb, chain, ctrl, status->bValue);
188 
189 	case UVC_CTRL_INFO_CHANGE:
190 	case UVC_CTRL_FAILURE_CHANGE:
191 	case UVC_CTRL_MIN_CHANGE:
192 	case UVC_CTRL_MAX_CHANGE:
193 		break;
194 	}
195 
196 	return false;
197 }
198 
199 static void uvc_status_complete(struct urb *urb)
200 {
201 	struct uvc_device *dev = urb->context;
202 	int len, ret;
203 
204 	switch (urb->status) {
205 	case 0:
206 		break;
207 
208 	case -ENOENT:		/* usb_kill_urb() called. */
209 	case -ECONNRESET:	/* usb_unlink_urb() called. */
210 	case -ESHUTDOWN:	/* The endpoint is being disabled. */
211 	case -EPROTO:		/* Device is disconnected (reported by some
212 				 * host controller). */
213 		return;
214 
215 	default:
216 		uvc_printk(KERN_WARNING, "Non-zero status (%d) in status "
217 			"completion handler.\n", urb->status);
218 		return;
219 	}
220 
221 	len = urb->actual_length;
222 	if (len > 0) {
223 		switch (dev->status[0] & 0x0f) {
224 		case UVC_STATUS_TYPE_CONTROL: {
225 			struct uvc_control_status *status =
226 				(struct uvc_control_status *)dev->status;
227 
228 			if (uvc_event_control(urb, status, len))
229 				/* The URB will be resubmitted in work context. */
230 				return;
231 			break;
232 		}
233 
234 		case UVC_STATUS_TYPE_STREAMING: {
235 			struct uvc_streaming_status *status =
236 				(struct uvc_streaming_status *)dev->status;
237 
238 			uvc_event_streaming(dev, status, len);
239 			break;
240 		}
241 
242 		default:
243 			uvc_trace(UVC_TRACE_STATUS, "Unknown status event "
244 				"type %u.\n", dev->status[0]);
245 			break;
246 		}
247 	}
248 
249 	/* Resubmit the URB. */
250 	urb->interval = dev->int_ep->desc.bInterval;
251 	if ((ret = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
252 		uvc_printk(KERN_ERR, "Failed to resubmit status URB (%d).\n",
253 			ret);
254 	}
255 }
256 
257 int uvc_status_init(struct uvc_device *dev)
258 {
259 	struct usb_host_endpoint *ep = dev->int_ep;
260 	unsigned int pipe;
261 	int interval;
262 
263 	if (ep == NULL)
264 		return 0;
265 
266 	uvc_input_init(dev);
267 
268 	dev->status = kzalloc(UVC_MAX_STATUS_SIZE, GFP_KERNEL);
269 	if (dev->status == NULL)
270 		return -ENOMEM;
271 
272 	dev->int_urb = usb_alloc_urb(0, GFP_KERNEL);
273 	if (dev->int_urb == NULL) {
274 		kfree(dev->status);
275 		return -ENOMEM;
276 	}
277 
278 	pipe = usb_rcvintpipe(dev->udev, ep->desc.bEndpointAddress);
279 
280 	/* For high-speed interrupt endpoints, the bInterval value is used as
281 	 * an exponent of two. Some developers forgot about it.
282 	 */
283 	interval = ep->desc.bInterval;
284 	if (interval > 16 && dev->udev->speed == USB_SPEED_HIGH &&
285 	    (dev->quirks & UVC_QUIRK_STATUS_INTERVAL))
286 		interval = fls(interval) - 1;
287 
288 	usb_fill_int_urb(dev->int_urb, dev->udev, pipe,
289 		dev->status, UVC_MAX_STATUS_SIZE, uvc_status_complete,
290 		dev, interval);
291 
292 	return 0;
293 }
294 
295 void uvc_status_cleanup(struct uvc_device *dev)
296 {
297 	usb_kill_urb(dev->int_urb);
298 	usb_free_urb(dev->int_urb);
299 	kfree(dev->status);
300 	uvc_input_cleanup(dev);
301 }
302 
303 int uvc_status_start(struct uvc_device *dev, gfp_t flags)
304 {
305 	if (dev->int_urb == NULL)
306 		return 0;
307 
308 	return usb_submit_urb(dev->int_urb, flags);
309 }
310 
311 void uvc_status_stop(struct uvc_device *dev)
312 {
313 	usb_kill_urb(dev->int_urb);
314 }
315