xref: /openbmc/linux/drivers/media/usb/uvc/uvc_status.c (revision b02a9a0c) 
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *      uvc_status.c  --  USB Video Class driver - Status endpoint
4  *
5  *      Copyright (C) 2005-2009
6  *          Laurent Pinchart (laurent.pinchart@ideasonboard.com)
7  */
8 
9 #include <asm/barrier.h>
10 #include <linux/kernel.h>
11 #include <linux/input.h>
12 #include <linux/slab.h>
13 #include <linux/usb.h>
14 #include <linux/usb/input.h>
15 
16 #include "uvcvideo.h"
17 
18 /* --------------------------------------------------------------------------
19  * Input device
20  */
21 #ifdef CONFIG_USB_VIDEO_CLASS_INPUT_EVDEV
22 
23 static bool uvc_input_has_button(struct uvc_device *dev)
24 {
25 	struct uvc_streaming *stream;
26 
27 	/*
28 	 * The device has button events if both bTriggerSupport and
29 	 * bTriggerUsage are one. Otherwise the camera button does not
30 	 * exist or is handled automatically by the camera without host
31 	 * driver or client application intervention.
32 	 */
33 	list_for_each_entry(stream, &dev->streams, list) {
34 		if (stream->header.bTriggerSupport == 1 &&
35 		    stream->header.bTriggerUsage == 1)
36 			return true;
37 	}
38 
39 	return false;
40 }
41 
42 static int uvc_input_init(struct uvc_device *dev)
43 {
44 	struct input_dev *input;
45 	int ret;
46 
47 	if (!uvc_input_has_button(dev))
48 		return 0;
49 
50 	input = input_allocate_device();
51 	if (input == NULL)
52 		return -ENOMEM;
53 
54 	usb_make_path(dev->udev, dev->input_phys, sizeof(dev->input_phys));
55 	strlcat(dev->input_phys, "/button", sizeof(dev->input_phys));
56 
57 	input->name = dev->name;
58 	input->phys = dev->input_phys;
59 	usb_to_input_id(dev->udev, &input->id);
60 	input->dev.parent = &dev->intf->dev;
61 
62 	__set_bit(EV_KEY, input->evbit);
63 	__set_bit(KEY_CAMERA, input->keybit);
64 
65 	if ((ret = input_register_device(input)) < 0)
66 		goto error;
67 
68 	dev->input = input;
69 	return 0;
70 
71 error:
72 	input_free_device(input);
73 	return ret;
74 }
75 
76 static void uvc_input_unregister(struct uvc_device *dev)
77 {
78 	if (dev->input)
79 		input_unregister_device(dev->input);
80 }
81 
82 static void uvc_input_report_key(struct uvc_device *dev, unsigned int code,
83 	int value)
84 {
85 	if (dev->input) {
86 		input_report_key(dev->input, code, value);
87 		input_sync(dev->input);
88 	}
89 }
90 
91 #else
92 #define uvc_input_init(dev)
93 #define uvc_input_unregister(dev)
94 #define uvc_input_report_key(dev, code, value)
95 #endif /* CONFIG_USB_VIDEO_CLASS_INPUT_EVDEV */
96 
97 /* --------------------------------------------------------------------------
98  * Status interrupt endpoint
99  */
100 static void uvc_event_streaming(struct uvc_device *dev,
101 				struct uvc_status *status, int len)
102 {
103 	if (len <= offsetof(struct uvc_status, bEvent)) {
104 		uvc_dbg(dev, STATUS,
105 			"Invalid streaming status event received\n");
106 		return;
107 	}
108 
109 	if (status->bEvent == 0) {
110 		if (len <= offsetof(struct uvc_status, streaming))
111 			return;
112 
113 		uvc_dbg(dev, STATUS, "Button (intf %u) %s len %d\n",
114 			status->bOriginator,
115 			status->streaming.button ? "pressed" : "released", len);
116 		uvc_input_report_key(dev, KEY_CAMERA, status->streaming.button);
117 	} else {
118 		uvc_dbg(dev, STATUS, "Stream %u error event %02x len %d\n",
119 			status->bOriginator, status->bEvent, len);
120 	}
121 }
122 
123 #define UVC_CTRL_VALUE_CHANGE	0
124 #define UVC_CTRL_INFO_CHANGE	1
125 #define UVC_CTRL_FAILURE_CHANGE	2
126 #define UVC_CTRL_MIN_CHANGE	3
127 #define UVC_CTRL_MAX_CHANGE	4
128 
129 static struct uvc_control *uvc_event_entity_find_ctrl(struct uvc_entity *entity,
130 						      u8 selector)
131 {
132 	struct uvc_control *ctrl;
133 	unsigned int i;
134 
135 	for (i = 0, ctrl = entity->controls; i < entity->ncontrols; i++, ctrl++)
136 		if (ctrl->info.selector == selector)
137 			return ctrl;
138 
139 	return NULL;
140 }
141 
142 static struct uvc_control *uvc_event_find_ctrl(struct uvc_device *dev,
143 					const struct uvc_status *status,
144 					struct uvc_video_chain **chain)
145 {
146 	list_for_each_entry((*chain), &dev->chains, list) {
147 		struct uvc_entity *entity;
148 		struct uvc_control *ctrl;
149 
150 		list_for_each_entry(entity, &(*chain)->entities, chain) {
151 			if (entity->id != status->bOriginator)
152 				continue;
153 
154 			ctrl = uvc_event_entity_find_ctrl(entity,
155 						     status->control.bSelector);
156 			if (ctrl)
157 				return ctrl;
158 		}
159 	}
160 
161 	return NULL;
162 }
163 
164 static bool uvc_event_control(struct urb *urb,
165 			      const struct uvc_status *status, int len)
166 {
167 	static const char *attrs[] = { "value", "info", "failure", "min", "max" };
168 	struct uvc_device *dev = urb->context;
169 	struct uvc_video_chain *chain;
170 	struct uvc_control *ctrl;
171 
172 	if (len < 6 || status->bEvent != 0 ||
173 	    status->control.bAttribute >= ARRAY_SIZE(attrs)) {
174 		uvc_dbg(dev, STATUS, "Invalid control status event received\n");
175 		return false;
176 	}
177 
178 	uvc_dbg(dev, STATUS, "Control %u/%u %s change len %d\n",
179 		status->bOriginator, status->control.bSelector,
180 		attrs[status->control.bAttribute], len);
181 
182 	/* Find the control. */
183 	ctrl = uvc_event_find_ctrl(dev, status, &chain);
184 	if (!ctrl)
185 		return false;
186 
187 	switch (status->control.bAttribute) {
188 	case UVC_CTRL_VALUE_CHANGE:
189 		return uvc_ctrl_status_event_async(urb, chain, ctrl,
190 						   status->control.bValue);
191 
192 	case UVC_CTRL_INFO_CHANGE:
193 	case UVC_CTRL_FAILURE_CHANGE:
194 	case UVC_CTRL_MIN_CHANGE:
195 	case UVC_CTRL_MAX_CHANGE:
196 		break;
197 	}
198 
199 	return false;
200 }
201 
202 static void uvc_status_complete(struct urb *urb)
203 {
204 	struct uvc_device *dev = urb->context;
205 	int len, ret;
206 
207 	switch (urb->status) {
208 	case 0:
209 		break;
210 
211 	case -ENOENT:		/* usb_kill_urb() called. */
212 	case -ECONNRESET:	/* usb_unlink_urb() called. */
213 	case -ESHUTDOWN:	/* The endpoint is being disabled. */
214 	case -EPROTO:		/* Device is disconnected (reported by some host controllers). */
215 		return;
216 
217 	default:
218 		dev_warn(&dev->udev->dev,
219 			 "Non-zero status (%d) in status completion handler.\n",
220 			 urb->status);
221 		return;
222 	}
223 
224 	len = urb->actual_length;
225 	if (len > 0) {
226 		switch (dev->status->bStatusType & 0x0f) {
227 		case UVC_STATUS_TYPE_CONTROL: {
228 			if (uvc_event_control(urb, dev->status, len))
229 				/* The URB will be resubmitted in work context. */
230 				return;
231 			break;
232 		}
233 
234 		case UVC_STATUS_TYPE_STREAMING: {
235 			uvc_event_streaming(dev, dev->status, len);
236 			break;
237 		}
238 
239 		default:
240 			uvc_dbg(dev, STATUS, "Unknown status event type %u\n",
241 				dev->status->bStatusType);
242 			break;
243 		}
244 	}
245 
246 	/* Resubmit the URB. */
247 	urb->interval = dev->int_ep->desc.bInterval;
248 	ret = usb_submit_urb(urb, GFP_ATOMIC);
249 	if (ret < 0)
250 		dev_err(&dev->udev->dev,
251 			"Failed to resubmit status URB (%d).\n", ret);
252 }
253 
254 int uvc_status_init(struct uvc_device *dev)
255 {
256 	struct usb_host_endpoint *ep = dev->int_ep;
257 	unsigned int pipe;
258 	int interval;
259 
260 	if (ep == NULL)
261 		return 0;
262 
263 	uvc_input_init(dev);
264 
265 	dev->status = kzalloc(sizeof(*dev->status), GFP_KERNEL);
266 	if (!dev->status)
267 		return -ENOMEM;
268 
269 	dev->int_urb = usb_alloc_urb(0, GFP_KERNEL);
270 	if (!dev->int_urb) {
271 		kfree(dev->status);
272 		return -ENOMEM;
273 	}
274 
275 	pipe = usb_rcvintpipe(dev->udev, ep->desc.bEndpointAddress);
276 
277 	/*
278 	 * For high-speed interrupt endpoints, the bInterval value is used as
279 	 * an exponent of two. Some developers forgot about it.
280 	 */
281 	interval = ep->desc.bInterval;
282 	if (interval > 16 && dev->udev->speed == USB_SPEED_HIGH &&
283 	    (dev->quirks & UVC_QUIRK_STATUS_INTERVAL))
284 		interval = fls(interval) - 1;
285 
286 	usb_fill_int_urb(dev->int_urb, dev->udev, pipe,
287 		dev->status, sizeof(*dev->status), uvc_status_complete,
288 		dev, interval);
289 
290 	return 0;
291 }
292 
293 void uvc_status_unregister(struct uvc_device *dev)
294 {
295 	usb_kill_urb(dev->int_urb);
296 	uvc_input_unregister(dev);
297 }
298 
299 void uvc_status_cleanup(struct uvc_device *dev)
300 {
301 	usb_free_urb(dev->int_urb);
302 	kfree(dev->status);
303 }
304 
305 int uvc_status_start(struct uvc_device *dev, gfp_t flags)
306 {
307 	if (dev->int_urb == NULL)
308 		return 0;
309 
310 	return usb_submit_urb(dev->int_urb, flags);
311 }
312 
313 void uvc_status_stop(struct uvc_device *dev)
314 {
315 	struct uvc_ctrl_work *w = &dev->async_ctrl;
316 
317 	/*
318 	 * Prevent the asynchronous control handler from requeing the URB. The
319 	 * barrier is needed so the flush_status change is visible to other
320 	 * CPUs running the asynchronous handler before usb_kill_urb() is
321 	 * called below.
322 	 */
323 	smp_store_release(&dev->flush_status, true);
324 
325 	/*
326 	 * Cancel any pending asynchronous work. If any status event was queued,
327 	 * process it synchronously.
328 	 */
329 	if (cancel_work_sync(&w->work))
330 		uvc_ctrl_status_event(w->chain, w->ctrl, w->data);
331 
332 	/* Kill the urb. */
333 	usb_kill_urb(dev->int_urb);
334 
335 	/*
336 	 * The URB completion handler may have queued asynchronous work. This
337 	 * won't resubmit the URB as flush_status is set, but it needs to be
338 	 * cancelled before returning or it could then race with a future
339 	 * uvc_status_start() call.
340 	 */
341 	if (cancel_work_sync(&w->work))
342 		uvc_ctrl_status_event(w->chain, w->ctrl, w->data);
343 
344 	/*
345 	 * From this point, there are no events on the queue and the status URB
346 	 * is dead. No events will be queued until uvc_status_start() is called.
347 	 * The barrier is needed to make sure that flush_status is visible to
348 	 * uvc_ctrl_status_event_work() when uvc_status_start() will be called
349 	 * again.
350 	 */
351 	smp_store_release(&dev->flush_status, false);
352 }
353