xref: /linux/drivers/media/usb/uvc/uvc_video.c (revision e5c86679d5e864947a52fb31e45a425dea3e7fa9)
1 /*
2  *      uvc_video.c  --  USB Video Class driver - Video handling
3  *
4  *      Copyright (C) 2005-2010
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/list.h>
16 #include <linux/module.h>
17 #include <linux/slab.h>
18 #include <linux/usb.h>
19 #include <linux/videodev2.h>
20 #include <linux/vmalloc.h>
21 #include <linux/wait.h>
22 #include <linux/atomic.h>
23 #include <asm/unaligned.h>
24 
25 #include <media/v4l2-common.h>
26 
27 #include "uvcvideo.h"
28 
29 /* ------------------------------------------------------------------------
30  * UVC Controls
31  */
32 
33 static int __uvc_query_ctrl(struct uvc_device *dev, __u8 query, __u8 unit,
34 			__u8 intfnum, __u8 cs, void *data, __u16 size,
35 			int timeout)
36 {
37 	__u8 type = USB_TYPE_CLASS | USB_RECIP_INTERFACE;
38 	unsigned int pipe;
39 
40 	pipe = (query & 0x80) ? usb_rcvctrlpipe(dev->udev, 0)
41 			      : usb_sndctrlpipe(dev->udev, 0);
42 	type |= (query & 0x80) ? USB_DIR_IN : USB_DIR_OUT;
43 
44 	return usb_control_msg(dev->udev, pipe, query, type, cs << 8,
45 			unit << 8 | intfnum, data, size, timeout);
46 }
47 
48 static const char *uvc_query_name(__u8 query)
49 {
50 	switch (query) {
51 	case UVC_SET_CUR:
52 		return "SET_CUR";
53 	case UVC_GET_CUR:
54 		return "GET_CUR";
55 	case UVC_GET_MIN:
56 		return "GET_MIN";
57 	case UVC_GET_MAX:
58 		return "GET_MAX";
59 	case UVC_GET_RES:
60 		return "GET_RES";
61 	case UVC_GET_LEN:
62 		return "GET_LEN";
63 	case UVC_GET_INFO:
64 		return "GET_INFO";
65 	case UVC_GET_DEF:
66 		return "GET_DEF";
67 	default:
68 		return "<invalid>";
69 	}
70 }
71 
72 int uvc_query_ctrl(struct uvc_device *dev, __u8 query, __u8 unit,
73 			__u8 intfnum, __u8 cs, void *data, __u16 size)
74 {
75 	int ret;
76 
77 	ret = __uvc_query_ctrl(dev, query, unit, intfnum, cs, data, size,
78 				UVC_CTRL_CONTROL_TIMEOUT);
79 	if (ret != size) {
80 		uvc_printk(KERN_ERR, "Failed to query (%s) UVC control %u on "
81 			"unit %u: %d (exp. %u).\n", uvc_query_name(query), cs,
82 			unit, ret, size);
83 		return -EIO;
84 	}
85 
86 	return 0;
87 }
88 
89 static void uvc_fixup_video_ctrl(struct uvc_streaming *stream,
90 	struct uvc_streaming_control *ctrl)
91 {
92 	struct uvc_format *format = NULL;
93 	struct uvc_frame *frame = NULL;
94 	unsigned int i;
95 
96 	for (i = 0; i < stream->nformats; ++i) {
97 		if (stream->format[i].index == ctrl->bFormatIndex) {
98 			format = &stream->format[i];
99 			break;
100 		}
101 	}
102 
103 	if (format == NULL)
104 		return;
105 
106 	for (i = 0; i < format->nframes; ++i) {
107 		if (format->frame[i].bFrameIndex == ctrl->bFrameIndex) {
108 			frame = &format->frame[i];
109 			break;
110 		}
111 	}
112 
113 	if (frame == NULL)
114 		return;
115 
116 	if (!(format->flags & UVC_FMT_FLAG_COMPRESSED) ||
117 	     (ctrl->dwMaxVideoFrameSize == 0 &&
118 	      stream->dev->uvc_version < 0x0110))
119 		ctrl->dwMaxVideoFrameSize =
120 			frame->dwMaxVideoFrameBufferSize;
121 
122 	/* The "TOSHIBA Web Camera - 5M" Chicony device (04f2:b50b) seems to
123 	 * compute the bandwidth on 16 bits and erroneously sign-extend it to
124 	 * 32 bits, resulting in a huge bandwidth value. Detect and fix that
125 	 * condition by setting the 16 MSBs to 0 when they're all equal to 1.
126 	 */
127 	if ((ctrl->dwMaxPayloadTransferSize & 0xffff0000) == 0xffff0000)
128 		ctrl->dwMaxPayloadTransferSize &= ~0xffff0000;
129 
130 	if (!(format->flags & UVC_FMT_FLAG_COMPRESSED) &&
131 	    stream->dev->quirks & UVC_QUIRK_FIX_BANDWIDTH &&
132 	    stream->intf->num_altsetting > 1) {
133 		u32 interval;
134 		u32 bandwidth;
135 
136 		interval = (ctrl->dwFrameInterval > 100000)
137 			 ? ctrl->dwFrameInterval
138 			 : frame->dwFrameInterval[0];
139 
140 		/* Compute a bandwidth estimation by multiplying the frame
141 		 * size by the number of video frames per second, divide the
142 		 * result by the number of USB frames (or micro-frames for
143 		 * high-speed devices) per second and add the UVC header size
144 		 * (assumed to be 12 bytes long).
145 		 */
146 		bandwidth = frame->wWidth * frame->wHeight / 8 * format->bpp;
147 		bandwidth *= 10000000 / interval + 1;
148 		bandwidth /= 1000;
149 		if (stream->dev->udev->speed == USB_SPEED_HIGH)
150 			bandwidth /= 8;
151 		bandwidth += 12;
152 
153 		/* The bandwidth estimate is too low for many cameras. Don't use
154 		 * maximum packet sizes lower than 1024 bytes to try and work
155 		 * around the problem. According to measurements done on two
156 		 * different camera models, the value is high enough to get most
157 		 * resolutions working while not preventing two simultaneous
158 		 * VGA streams at 15 fps.
159 		 */
160 		bandwidth = max_t(u32, bandwidth, 1024);
161 
162 		ctrl->dwMaxPayloadTransferSize = bandwidth;
163 	}
164 }
165 
166 static int uvc_get_video_ctrl(struct uvc_streaming *stream,
167 	struct uvc_streaming_control *ctrl, int probe, __u8 query)
168 {
169 	__u8 *data;
170 	__u16 size;
171 	int ret;
172 
173 	size = stream->dev->uvc_version >= 0x0110 ? 34 : 26;
174 	if ((stream->dev->quirks & UVC_QUIRK_PROBE_DEF) &&
175 			query == UVC_GET_DEF)
176 		return -EIO;
177 
178 	data = kmalloc(size, GFP_KERNEL);
179 	if (data == NULL)
180 		return -ENOMEM;
181 
182 	ret = __uvc_query_ctrl(stream->dev, query, 0, stream->intfnum,
183 		probe ? UVC_VS_PROBE_CONTROL : UVC_VS_COMMIT_CONTROL, data,
184 		size, uvc_timeout_param);
185 
186 	if ((query == UVC_GET_MIN || query == UVC_GET_MAX) && ret == 2) {
187 		/* Some cameras, mostly based on Bison Electronics chipsets,
188 		 * answer a GET_MIN or GET_MAX request with the wCompQuality
189 		 * field only.
190 		 */
191 		uvc_warn_once(stream->dev, UVC_WARN_MINMAX, "UVC non "
192 			"compliance - GET_MIN/MAX(PROBE) incorrectly "
193 			"supported. Enabling workaround.\n");
194 		memset(ctrl, 0, sizeof *ctrl);
195 		ctrl->wCompQuality = le16_to_cpup((__le16 *)data);
196 		ret = 0;
197 		goto out;
198 	} else if (query == UVC_GET_DEF && probe == 1 && ret != size) {
199 		/* Many cameras don't support the GET_DEF request on their
200 		 * video probe control. Warn once and return, the caller will
201 		 * fall back to GET_CUR.
202 		 */
203 		uvc_warn_once(stream->dev, UVC_WARN_PROBE_DEF, "UVC non "
204 			"compliance - GET_DEF(PROBE) not supported. "
205 			"Enabling workaround.\n");
206 		ret = -EIO;
207 		goto out;
208 	} else if (ret != size) {
209 		uvc_printk(KERN_ERR, "Failed to query (%u) UVC %s control : "
210 			"%d (exp. %u).\n", query, probe ? "probe" : "commit",
211 			ret, size);
212 		ret = -EIO;
213 		goto out;
214 	}
215 
216 	ctrl->bmHint = le16_to_cpup((__le16 *)&data[0]);
217 	ctrl->bFormatIndex = data[2];
218 	ctrl->bFrameIndex = data[3];
219 	ctrl->dwFrameInterval = le32_to_cpup((__le32 *)&data[4]);
220 	ctrl->wKeyFrameRate = le16_to_cpup((__le16 *)&data[8]);
221 	ctrl->wPFrameRate = le16_to_cpup((__le16 *)&data[10]);
222 	ctrl->wCompQuality = le16_to_cpup((__le16 *)&data[12]);
223 	ctrl->wCompWindowSize = le16_to_cpup((__le16 *)&data[14]);
224 	ctrl->wDelay = le16_to_cpup((__le16 *)&data[16]);
225 	ctrl->dwMaxVideoFrameSize = get_unaligned_le32(&data[18]);
226 	ctrl->dwMaxPayloadTransferSize = get_unaligned_le32(&data[22]);
227 
228 	if (size == 34) {
229 		ctrl->dwClockFrequency = get_unaligned_le32(&data[26]);
230 		ctrl->bmFramingInfo = data[30];
231 		ctrl->bPreferedVersion = data[31];
232 		ctrl->bMinVersion = data[32];
233 		ctrl->bMaxVersion = data[33];
234 	} else {
235 		ctrl->dwClockFrequency = stream->dev->clock_frequency;
236 		ctrl->bmFramingInfo = 0;
237 		ctrl->bPreferedVersion = 0;
238 		ctrl->bMinVersion = 0;
239 		ctrl->bMaxVersion = 0;
240 	}
241 
242 	/* Some broken devices return null or wrong dwMaxVideoFrameSize and
243 	 * dwMaxPayloadTransferSize fields. Try to get the value from the
244 	 * format and frame descriptors.
245 	 */
246 	uvc_fixup_video_ctrl(stream, ctrl);
247 	ret = 0;
248 
249 out:
250 	kfree(data);
251 	return ret;
252 }
253 
254 static int uvc_set_video_ctrl(struct uvc_streaming *stream,
255 	struct uvc_streaming_control *ctrl, int probe)
256 {
257 	__u8 *data;
258 	__u16 size;
259 	int ret;
260 
261 	size = stream->dev->uvc_version >= 0x0110 ? 34 : 26;
262 	data = kzalloc(size, GFP_KERNEL);
263 	if (data == NULL)
264 		return -ENOMEM;
265 
266 	*(__le16 *)&data[0] = cpu_to_le16(ctrl->bmHint);
267 	data[2] = ctrl->bFormatIndex;
268 	data[3] = ctrl->bFrameIndex;
269 	*(__le32 *)&data[4] = cpu_to_le32(ctrl->dwFrameInterval);
270 	*(__le16 *)&data[8] = cpu_to_le16(ctrl->wKeyFrameRate);
271 	*(__le16 *)&data[10] = cpu_to_le16(ctrl->wPFrameRate);
272 	*(__le16 *)&data[12] = cpu_to_le16(ctrl->wCompQuality);
273 	*(__le16 *)&data[14] = cpu_to_le16(ctrl->wCompWindowSize);
274 	*(__le16 *)&data[16] = cpu_to_le16(ctrl->wDelay);
275 	put_unaligned_le32(ctrl->dwMaxVideoFrameSize, &data[18]);
276 	put_unaligned_le32(ctrl->dwMaxPayloadTransferSize, &data[22]);
277 
278 	if (size == 34) {
279 		put_unaligned_le32(ctrl->dwClockFrequency, &data[26]);
280 		data[30] = ctrl->bmFramingInfo;
281 		data[31] = ctrl->bPreferedVersion;
282 		data[32] = ctrl->bMinVersion;
283 		data[33] = ctrl->bMaxVersion;
284 	}
285 
286 	ret = __uvc_query_ctrl(stream->dev, UVC_SET_CUR, 0, stream->intfnum,
287 		probe ? UVC_VS_PROBE_CONTROL : UVC_VS_COMMIT_CONTROL, data,
288 		size, uvc_timeout_param);
289 	if (ret != size) {
290 		uvc_printk(KERN_ERR, "Failed to set UVC %s control : "
291 			"%d (exp. %u).\n", probe ? "probe" : "commit",
292 			ret, size);
293 		ret = -EIO;
294 	}
295 
296 	kfree(data);
297 	return ret;
298 }
299 
300 int uvc_probe_video(struct uvc_streaming *stream,
301 	struct uvc_streaming_control *probe)
302 {
303 	struct uvc_streaming_control probe_min, probe_max;
304 	__u16 bandwidth;
305 	unsigned int i;
306 	int ret;
307 
308 	/* Perform probing. The device should adjust the requested values
309 	 * according to its capabilities. However, some devices, namely the
310 	 * first generation UVC Logitech webcams, don't implement the Video
311 	 * Probe control properly, and just return the needed bandwidth. For
312 	 * that reason, if the needed bandwidth exceeds the maximum available
313 	 * bandwidth, try to lower the quality.
314 	 */
315 	ret = uvc_set_video_ctrl(stream, probe, 1);
316 	if (ret < 0)
317 		goto done;
318 
319 	/* Get the minimum and maximum values for compression settings. */
320 	if (!(stream->dev->quirks & UVC_QUIRK_PROBE_MINMAX)) {
321 		ret = uvc_get_video_ctrl(stream, &probe_min, 1, UVC_GET_MIN);
322 		if (ret < 0)
323 			goto done;
324 		ret = uvc_get_video_ctrl(stream, &probe_max, 1, UVC_GET_MAX);
325 		if (ret < 0)
326 			goto done;
327 
328 		probe->wCompQuality = probe_max.wCompQuality;
329 	}
330 
331 	for (i = 0; i < 2; ++i) {
332 		ret = uvc_set_video_ctrl(stream, probe, 1);
333 		if (ret < 0)
334 			goto done;
335 		ret = uvc_get_video_ctrl(stream, probe, 1, UVC_GET_CUR);
336 		if (ret < 0)
337 			goto done;
338 
339 		if (stream->intf->num_altsetting == 1)
340 			break;
341 
342 		bandwidth = probe->dwMaxPayloadTransferSize;
343 		if (bandwidth <= stream->maxpsize)
344 			break;
345 
346 		if (stream->dev->quirks & UVC_QUIRK_PROBE_MINMAX) {
347 			ret = -ENOSPC;
348 			goto done;
349 		}
350 
351 		/* TODO: negotiate compression parameters */
352 		probe->wKeyFrameRate = probe_min.wKeyFrameRate;
353 		probe->wPFrameRate = probe_min.wPFrameRate;
354 		probe->wCompQuality = probe_max.wCompQuality;
355 		probe->wCompWindowSize = probe_min.wCompWindowSize;
356 	}
357 
358 done:
359 	return ret;
360 }
361 
362 static int uvc_commit_video(struct uvc_streaming *stream,
363 			    struct uvc_streaming_control *probe)
364 {
365 	return uvc_set_video_ctrl(stream, probe, 0);
366 }
367 
368 /* -----------------------------------------------------------------------------
369  * Clocks and timestamps
370  */
371 
372 static inline void uvc_video_get_ts(struct timespec *ts)
373 {
374 	if (uvc_clock_param == CLOCK_MONOTONIC)
375 		ktime_get_ts(ts);
376 	else
377 		ktime_get_real_ts(ts);
378 }
379 
380 static void
381 uvc_video_clock_decode(struct uvc_streaming *stream, struct uvc_buffer *buf,
382 		       const __u8 *data, int len)
383 {
384 	struct uvc_clock_sample *sample;
385 	unsigned int header_size;
386 	bool has_pts = false;
387 	bool has_scr = false;
388 	unsigned long flags;
389 	struct timespec ts;
390 	u16 host_sof;
391 	u16 dev_sof;
392 
393 	switch (data[1] & (UVC_STREAM_PTS | UVC_STREAM_SCR)) {
394 	case UVC_STREAM_PTS | UVC_STREAM_SCR:
395 		header_size = 12;
396 		has_pts = true;
397 		has_scr = true;
398 		break;
399 	case UVC_STREAM_PTS:
400 		header_size = 6;
401 		has_pts = true;
402 		break;
403 	case UVC_STREAM_SCR:
404 		header_size = 8;
405 		has_scr = true;
406 		break;
407 	default:
408 		header_size = 2;
409 		break;
410 	}
411 
412 	/* Check for invalid headers. */
413 	if (len < header_size)
414 		return;
415 
416 	/* Extract the timestamps:
417 	 *
418 	 * - store the frame PTS in the buffer structure
419 	 * - if the SCR field is present, retrieve the host SOF counter and
420 	 *   kernel timestamps and store them with the SCR STC and SOF fields
421 	 *   in the ring buffer
422 	 */
423 	if (has_pts && buf != NULL)
424 		buf->pts = get_unaligned_le32(&data[2]);
425 
426 	if (!has_scr)
427 		return;
428 
429 	/* To limit the amount of data, drop SCRs with an SOF identical to the
430 	 * previous one.
431 	 */
432 	dev_sof = get_unaligned_le16(&data[header_size - 2]);
433 	if (dev_sof == stream->clock.last_sof)
434 		return;
435 
436 	stream->clock.last_sof = dev_sof;
437 
438 	host_sof = usb_get_current_frame_number(stream->dev->udev);
439 	uvc_video_get_ts(&ts);
440 
441 	/* The UVC specification allows device implementations that can't obtain
442 	 * the USB frame number to keep their own frame counters as long as they
443 	 * match the size and frequency of the frame number associated with USB
444 	 * SOF tokens. The SOF values sent by such devices differ from the USB
445 	 * SOF tokens by a fixed offset that needs to be estimated and accounted
446 	 * for to make timestamp recovery as accurate as possible.
447 	 *
448 	 * The offset is estimated the first time a device SOF value is received
449 	 * as the difference between the host and device SOF values. As the two
450 	 * SOF values can differ slightly due to transmission delays, consider
451 	 * that the offset is null if the difference is not higher than 10 ms
452 	 * (negative differences can not happen and are thus considered as an
453 	 * offset). The video commit control wDelay field should be used to
454 	 * compute a dynamic threshold instead of using a fixed 10 ms value, but
455 	 * devices don't report reliable wDelay values.
456 	 *
457 	 * See uvc_video_clock_host_sof() for an explanation regarding why only
458 	 * the 8 LSBs of the delta are kept.
459 	 */
460 	if (stream->clock.sof_offset == (u16)-1) {
461 		u16 delta_sof = (host_sof - dev_sof) & 255;
462 		if (delta_sof >= 10)
463 			stream->clock.sof_offset = delta_sof;
464 		else
465 			stream->clock.sof_offset = 0;
466 	}
467 
468 	dev_sof = (dev_sof + stream->clock.sof_offset) & 2047;
469 
470 	spin_lock_irqsave(&stream->clock.lock, flags);
471 
472 	sample = &stream->clock.samples[stream->clock.head];
473 	sample->dev_stc = get_unaligned_le32(&data[header_size - 6]);
474 	sample->dev_sof = dev_sof;
475 	sample->host_sof = host_sof;
476 	sample->host_ts = ts;
477 
478 	/* Update the sliding window head and count. */
479 	stream->clock.head = (stream->clock.head + 1) % stream->clock.size;
480 
481 	if (stream->clock.count < stream->clock.size)
482 		stream->clock.count++;
483 
484 	spin_unlock_irqrestore(&stream->clock.lock, flags);
485 }
486 
487 static void uvc_video_clock_reset(struct uvc_streaming *stream)
488 {
489 	struct uvc_clock *clock = &stream->clock;
490 
491 	clock->head = 0;
492 	clock->count = 0;
493 	clock->last_sof = -1;
494 	clock->sof_offset = -1;
495 }
496 
497 static int uvc_video_clock_init(struct uvc_streaming *stream)
498 {
499 	struct uvc_clock *clock = &stream->clock;
500 
501 	spin_lock_init(&clock->lock);
502 	clock->size = 32;
503 
504 	clock->samples = kmalloc(clock->size * sizeof(*clock->samples),
505 				 GFP_KERNEL);
506 	if (clock->samples == NULL)
507 		return -ENOMEM;
508 
509 	uvc_video_clock_reset(stream);
510 
511 	return 0;
512 }
513 
514 static void uvc_video_clock_cleanup(struct uvc_streaming *stream)
515 {
516 	kfree(stream->clock.samples);
517 	stream->clock.samples = NULL;
518 }
519 
520 /*
521  * uvc_video_clock_host_sof - Return the host SOF value for a clock sample
522  *
523  * Host SOF counters reported by usb_get_current_frame_number() usually don't
524  * cover the whole 11-bits SOF range (0-2047) but are limited to the HCI frame
525  * schedule window. They can be limited to 8, 9 or 10 bits depending on the host
526  * controller and its configuration.
527  *
528  * We thus need to recover the SOF value corresponding to the host frame number.
529  * As the device and host frame numbers are sampled in a short interval, the
530  * difference between their values should be equal to a small delta plus an
531  * integer multiple of 256 caused by the host frame number limited precision.
532  *
533  * To obtain the recovered host SOF value, compute the small delta by masking
534  * the high bits of the host frame counter and device SOF difference and add it
535  * to the device SOF value.
536  */
537 static u16 uvc_video_clock_host_sof(const struct uvc_clock_sample *sample)
538 {
539 	/* The delta value can be negative. */
540 	s8 delta_sof;
541 
542 	delta_sof = (sample->host_sof - sample->dev_sof) & 255;
543 
544 	return (sample->dev_sof + delta_sof) & 2047;
545 }
546 
547 /*
548  * uvc_video_clock_update - Update the buffer timestamp
549  *
550  * This function converts the buffer PTS timestamp to the host clock domain by
551  * going through the USB SOF clock domain and stores the result in the V4L2
552  * buffer timestamp field.
553  *
554  * The relationship between the device clock and the host clock isn't known.
555  * However, the device and the host share the common USB SOF clock which can be
556  * used to recover that relationship.
557  *
558  * The relationship between the device clock and the USB SOF clock is considered
559  * to be linear over the clock samples sliding window and is given by
560  *
561  * SOF = m * PTS + p
562  *
563  * Several methods to compute the slope (m) and intercept (p) can be used. As
564  * the clock drift should be small compared to the sliding window size, we
565  * assume that the line that goes through the points at both ends of the window
566  * is a good approximation. Naming those points P1 and P2, we get
567  *
568  * SOF = (SOF2 - SOF1) / (STC2 - STC1) * PTS
569  *     + (SOF1 * STC2 - SOF2 * STC1) / (STC2 - STC1)
570  *
571  * or
572  *
573  * SOF = ((SOF2 - SOF1) * PTS + SOF1 * STC2 - SOF2 * STC1) / (STC2 - STC1)   (1)
574  *
575  * to avoid losing precision in the division. Similarly, the host timestamp is
576  * computed with
577  *
578  * TS = ((TS2 - TS1) * PTS + TS1 * SOF2 - TS2 * SOF1) / (SOF2 - SOF1)	     (2)
579  *
580  * SOF values are coded on 11 bits by USB. We extend their precision with 16
581  * decimal bits, leading to a 11.16 coding.
582  *
583  * TODO: To avoid surprises with device clock values, PTS/STC timestamps should
584  * be normalized using the nominal device clock frequency reported through the
585  * UVC descriptors.
586  *
587  * Both the PTS/STC and SOF counters roll over, after a fixed but device
588  * specific amount of time for PTS/STC and after 2048ms for SOF. As long as the
589  * sliding window size is smaller than the rollover period, differences computed
590  * on unsigned integers will produce the correct result. However, the p term in
591  * the linear relations will be miscomputed.
592  *
593  * To fix the issue, we subtract a constant from the PTS and STC values to bring
594  * PTS to half the 32 bit STC range. The sliding window STC values then fit into
595  * the 32 bit range without any rollover.
596  *
597  * Similarly, we add 2048 to the device SOF values to make sure that the SOF
598  * computed by (1) will never be smaller than 0. This offset is then compensated
599  * by adding 2048 to the SOF values used in (2). However, this doesn't prevent
600  * rollovers between (1) and (2): the SOF value computed by (1) can be slightly
601  * lower than 4096, and the host SOF counters can have rolled over to 2048. This
602  * case is handled by subtracting 2048 from the SOF value if it exceeds the host
603  * SOF value at the end of the sliding window.
604  *
605  * Finally we subtract a constant from the host timestamps to bring the first
606  * timestamp of the sliding window to 1s.
607  */
608 void uvc_video_clock_update(struct uvc_streaming *stream,
609 			    struct vb2_v4l2_buffer *vbuf,
610 			    struct uvc_buffer *buf)
611 {
612 	struct uvc_clock *clock = &stream->clock;
613 	struct uvc_clock_sample *first;
614 	struct uvc_clock_sample *last;
615 	unsigned long flags;
616 	struct timespec ts;
617 	u32 delta_stc;
618 	u32 y1, y2;
619 	u32 x1, x2;
620 	u32 mean;
621 	u32 sof;
622 	u32 div;
623 	u32 rem;
624 	u64 y;
625 
626 	if (!uvc_hw_timestamps_param)
627 		return;
628 
629 	spin_lock_irqsave(&clock->lock, flags);
630 
631 	if (clock->count < clock->size)
632 		goto done;
633 
634 	first = &clock->samples[clock->head];
635 	last = &clock->samples[(clock->head - 1) % clock->size];
636 
637 	/* First step, PTS to SOF conversion. */
638 	delta_stc = buf->pts - (1UL << 31);
639 	x1 = first->dev_stc - delta_stc;
640 	x2 = last->dev_stc - delta_stc;
641 	if (x1 == x2)
642 		goto done;
643 
644 	y1 = (first->dev_sof + 2048) << 16;
645 	y2 = (last->dev_sof + 2048) << 16;
646 	if (y2 < y1)
647 		y2 += 2048 << 16;
648 
649 	y = (u64)(y2 - y1) * (1ULL << 31) + (u64)y1 * (u64)x2
650 	  - (u64)y2 * (u64)x1;
651 	y = div_u64(y, x2 - x1);
652 
653 	sof = y;
654 
655 	uvc_trace(UVC_TRACE_CLOCK, "%s: PTS %u y %llu.%06llu SOF %u.%06llu "
656 		  "(x1 %u x2 %u y1 %u y2 %u SOF offset %u)\n",
657 		  stream->dev->name, buf->pts,
658 		  y >> 16, div_u64((y & 0xffff) * 1000000, 65536),
659 		  sof >> 16, div_u64(((u64)sof & 0xffff) * 1000000LLU, 65536),
660 		  x1, x2, y1, y2, clock->sof_offset);
661 
662 	/* Second step, SOF to host clock conversion. */
663 	x1 = (uvc_video_clock_host_sof(first) + 2048) << 16;
664 	x2 = (uvc_video_clock_host_sof(last) + 2048) << 16;
665 	if (x2 < x1)
666 		x2 += 2048 << 16;
667 	if (x1 == x2)
668 		goto done;
669 
670 	ts = timespec_sub(last->host_ts, first->host_ts);
671 	y1 = NSEC_PER_SEC;
672 	y2 = (ts.tv_sec + 1) * NSEC_PER_SEC + ts.tv_nsec;
673 
674 	/* Interpolated and host SOF timestamps can wrap around at slightly
675 	 * different times. Handle this by adding or removing 2048 to or from
676 	 * the computed SOF value to keep it close to the SOF samples mean
677 	 * value.
678 	 */
679 	mean = (x1 + x2) / 2;
680 	if (mean - (1024 << 16) > sof)
681 		sof += 2048 << 16;
682 	else if (sof > mean + (1024 << 16))
683 		sof -= 2048 << 16;
684 
685 	y = (u64)(y2 - y1) * (u64)sof + (u64)y1 * (u64)x2
686 	  - (u64)y2 * (u64)x1;
687 	y = div_u64(y, x2 - x1);
688 
689 	div = div_u64_rem(y, NSEC_PER_SEC, &rem);
690 	ts.tv_sec = first->host_ts.tv_sec - 1 + div;
691 	ts.tv_nsec = first->host_ts.tv_nsec + rem;
692 	if (ts.tv_nsec >= NSEC_PER_SEC) {
693 		ts.tv_sec++;
694 		ts.tv_nsec -= NSEC_PER_SEC;
695 	}
696 
697 	uvc_trace(UVC_TRACE_CLOCK, "%s: SOF %u.%06llu y %llu ts %llu "
698 		  "buf ts %llu (x1 %u/%u/%u x2 %u/%u/%u y1 %u y2 %u)\n",
699 		  stream->dev->name,
700 		  sof >> 16, div_u64(((u64)sof & 0xffff) * 1000000LLU, 65536),
701 		  y, timespec_to_ns(&ts), vbuf->vb2_buf.timestamp,
702 		  x1, first->host_sof, first->dev_sof,
703 		  x2, last->host_sof, last->dev_sof, y1, y2);
704 
705 	/* Update the V4L2 buffer. */
706 	vbuf->vb2_buf.timestamp = timespec_to_ns(&ts);
707 
708 done:
709 	spin_unlock_irqrestore(&clock->lock, flags);
710 }
711 
712 /* ------------------------------------------------------------------------
713  * Stream statistics
714  */
715 
716 static void uvc_video_stats_decode(struct uvc_streaming *stream,
717 		const __u8 *data, int len)
718 {
719 	unsigned int header_size;
720 	bool has_pts = false;
721 	bool has_scr = false;
722 	u16 uninitialized_var(scr_sof);
723 	u32 uninitialized_var(scr_stc);
724 	u32 uninitialized_var(pts);
725 
726 	if (stream->stats.stream.nb_frames == 0 &&
727 	    stream->stats.frame.nb_packets == 0)
728 		ktime_get_ts(&stream->stats.stream.start_ts);
729 
730 	switch (data[1] & (UVC_STREAM_PTS | UVC_STREAM_SCR)) {
731 	case UVC_STREAM_PTS | UVC_STREAM_SCR:
732 		header_size = 12;
733 		has_pts = true;
734 		has_scr = true;
735 		break;
736 	case UVC_STREAM_PTS:
737 		header_size = 6;
738 		has_pts = true;
739 		break;
740 	case UVC_STREAM_SCR:
741 		header_size = 8;
742 		has_scr = true;
743 		break;
744 	default:
745 		header_size = 2;
746 		break;
747 	}
748 
749 	/* Check for invalid headers. */
750 	if (len < header_size || data[0] < header_size) {
751 		stream->stats.frame.nb_invalid++;
752 		return;
753 	}
754 
755 	/* Extract the timestamps. */
756 	if (has_pts)
757 		pts = get_unaligned_le32(&data[2]);
758 
759 	if (has_scr) {
760 		scr_stc = get_unaligned_le32(&data[header_size - 6]);
761 		scr_sof = get_unaligned_le16(&data[header_size - 2]);
762 	}
763 
764 	/* Is PTS constant through the whole frame ? */
765 	if (has_pts && stream->stats.frame.nb_pts) {
766 		if (stream->stats.frame.pts != pts) {
767 			stream->stats.frame.nb_pts_diffs++;
768 			stream->stats.frame.last_pts_diff =
769 				stream->stats.frame.nb_packets;
770 		}
771 	}
772 
773 	if (has_pts) {
774 		stream->stats.frame.nb_pts++;
775 		stream->stats.frame.pts = pts;
776 	}
777 
778 	/* Do all frames have a PTS in their first non-empty packet, or before
779 	 * their first empty packet ?
780 	 */
781 	if (stream->stats.frame.size == 0) {
782 		if (len > header_size)
783 			stream->stats.frame.has_initial_pts = has_pts;
784 		if (len == header_size && has_pts)
785 			stream->stats.frame.has_early_pts = true;
786 	}
787 
788 	/* Do the SCR.STC and SCR.SOF fields vary through the frame ? */
789 	if (has_scr && stream->stats.frame.nb_scr) {
790 		if (stream->stats.frame.scr_stc != scr_stc)
791 			stream->stats.frame.nb_scr_diffs++;
792 	}
793 
794 	if (has_scr) {
795 		/* Expand the SOF counter to 32 bits and store its value. */
796 		if (stream->stats.stream.nb_frames > 0 ||
797 		    stream->stats.frame.nb_scr > 0)
798 			stream->stats.stream.scr_sof_count +=
799 				(scr_sof - stream->stats.stream.scr_sof) % 2048;
800 		stream->stats.stream.scr_sof = scr_sof;
801 
802 		stream->stats.frame.nb_scr++;
803 		stream->stats.frame.scr_stc = scr_stc;
804 		stream->stats.frame.scr_sof = scr_sof;
805 
806 		if (scr_sof < stream->stats.stream.min_sof)
807 			stream->stats.stream.min_sof = scr_sof;
808 		if (scr_sof > stream->stats.stream.max_sof)
809 			stream->stats.stream.max_sof = scr_sof;
810 	}
811 
812 	/* Record the first non-empty packet number. */
813 	if (stream->stats.frame.size == 0 && len > header_size)
814 		stream->stats.frame.first_data = stream->stats.frame.nb_packets;
815 
816 	/* Update the frame size. */
817 	stream->stats.frame.size += len - header_size;
818 
819 	/* Update the packets counters. */
820 	stream->stats.frame.nb_packets++;
821 	if (len > header_size)
822 		stream->stats.frame.nb_empty++;
823 
824 	if (data[1] & UVC_STREAM_ERR)
825 		stream->stats.frame.nb_errors++;
826 }
827 
828 static void uvc_video_stats_update(struct uvc_streaming *stream)
829 {
830 	struct uvc_stats_frame *frame = &stream->stats.frame;
831 
832 	uvc_trace(UVC_TRACE_STATS, "frame %u stats: %u/%u/%u packets, "
833 		  "%u/%u/%u pts (%searly %sinitial), %u/%u scr, "
834 		  "last pts/stc/sof %u/%u/%u\n",
835 		  stream->sequence, frame->first_data,
836 		  frame->nb_packets - frame->nb_empty, frame->nb_packets,
837 		  frame->nb_pts_diffs, frame->last_pts_diff, frame->nb_pts,
838 		  frame->has_early_pts ? "" : "!",
839 		  frame->has_initial_pts ? "" : "!",
840 		  frame->nb_scr_diffs, frame->nb_scr,
841 		  frame->pts, frame->scr_stc, frame->scr_sof);
842 
843 	stream->stats.stream.nb_frames++;
844 	stream->stats.stream.nb_packets += stream->stats.frame.nb_packets;
845 	stream->stats.stream.nb_empty += stream->stats.frame.nb_empty;
846 	stream->stats.stream.nb_errors += stream->stats.frame.nb_errors;
847 	stream->stats.stream.nb_invalid += stream->stats.frame.nb_invalid;
848 
849 	if (frame->has_early_pts)
850 		stream->stats.stream.nb_pts_early++;
851 	if (frame->has_initial_pts)
852 		stream->stats.stream.nb_pts_initial++;
853 	if (frame->last_pts_diff <= frame->first_data)
854 		stream->stats.stream.nb_pts_constant++;
855 	if (frame->nb_scr >= frame->nb_packets - frame->nb_empty)
856 		stream->stats.stream.nb_scr_count_ok++;
857 	if (frame->nb_scr_diffs + 1 == frame->nb_scr)
858 		stream->stats.stream.nb_scr_diffs_ok++;
859 
860 	memset(&stream->stats.frame, 0, sizeof(stream->stats.frame));
861 }
862 
863 size_t uvc_video_stats_dump(struct uvc_streaming *stream, char *buf,
864 			    size_t size)
865 {
866 	unsigned int scr_sof_freq;
867 	unsigned int duration;
868 	struct timespec ts;
869 	size_t count = 0;
870 
871 	ts.tv_sec = stream->stats.stream.stop_ts.tv_sec
872 		  - stream->stats.stream.start_ts.tv_sec;
873 	ts.tv_nsec = stream->stats.stream.stop_ts.tv_nsec
874 		   - stream->stats.stream.start_ts.tv_nsec;
875 	if (ts.tv_nsec < 0) {
876 		ts.tv_sec--;
877 		ts.tv_nsec += 1000000000;
878 	}
879 
880 	/* Compute the SCR.SOF frequency estimate. At the nominal 1kHz SOF
881 	 * frequency this will not overflow before more than 1h.
882 	 */
883 	duration = ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
884 	if (duration != 0)
885 		scr_sof_freq = stream->stats.stream.scr_sof_count * 1000
886 			     / duration;
887 	else
888 		scr_sof_freq = 0;
889 
890 	count += scnprintf(buf + count, size - count,
891 			   "frames:  %u\npackets: %u\nempty:   %u\n"
892 			   "errors:  %u\ninvalid: %u\n",
893 			   stream->stats.stream.nb_frames,
894 			   stream->stats.stream.nb_packets,
895 			   stream->stats.stream.nb_empty,
896 			   stream->stats.stream.nb_errors,
897 			   stream->stats.stream.nb_invalid);
898 	count += scnprintf(buf + count, size - count,
899 			   "pts: %u early, %u initial, %u ok\n",
900 			   stream->stats.stream.nb_pts_early,
901 			   stream->stats.stream.nb_pts_initial,
902 			   stream->stats.stream.nb_pts_constant);
903 	count += scnprintf(buf + count, size - count,
904 			   "scr: %u count ok, %u diff ok\n",
905 			   stream->stats.stream.nb_scr_count_ok,
906 			   stream->stats.stream.nb_scr_diffs_ok);
907 	count += scnprintf(buf + count, size - count,
908 			   "sof: %u <= sof <= %u, freq %u.%03u kHz\n",
909 			   stream->stats.stream.min_sof,
910 			   stream->stats.stream.max_sof,
911 			   scr_sof_freq / 1000, scr_sof_freq % 1000);
912 
913 	return count;
914 }
915 
916 static void uvc_video_stats_start(struct uvc_streaming *stream)
917 {
918 	memset(&stream->stats, 0, sizeof(stream->stats));
919 	stream->stats.stream.min_sof = 2048;
920 }
921 
922 static void uvc_video_stats_stop(struct uvc_streaming *stream)
923 {
924 	ktime_get_ts(&stream->stats.stream.stop_ts);
925 }
926 
927 /* ------------------------------------------------------------------------
928  * Video codecs
929  */
930 
931 /* Video payload decoding is handled by uvc_video_decode_start(),
932  * uvc_video_decode_data() and uvc_video_decode_end().
933  *
934  * uvc_video_decode_start is called with URB data at the start of a bulk or
935  * isochronous payload. It processes header data and returns the header size
936  * in bytes if successful. If an error occurs, it returns a negative error
937  * code. The following error codes have special meanings.
938  *
939  * - EAGAIN informs the caller that the current video buffer should be marked
940  *   as done, and that the function should be called again with the same data
941  *   and a new video buffer. This is used when end of frame conditions can be
942  *   reliably detected at the beginning of the next frame only.
943  *
944  * If an error other than -EAGAIN is returned, the caller will drop the current
945  * payload. No call to uvc_video_decode_data and uvc_video_decode_end will be
946  * made until the next payload. -ENODATA can be used to drop the current
947  * payload if no other error code is appropriate.
948  *
949  * uvc_video_decode_data is called for every URB with URB data. It copies the
950  * data to the video buffer.
951  *
952  * uvc_video_decode_end is called with header data at the end of a bulk or
953  * isochronous payload. It performs any additional header data processing and
954  * returns 0 or a negative error code if an error occurred. As header data have
955  * already been processed by uvc_video_decode_start, this functions isn't
956  * required to perform sanity checks a second time.
957  *
958  * For isochronous transfers where a payload is always transferred in a single
959  * URB, the three functions will be called in a row.
960  *
961  * To let the decoder process header data and update its internal state even
962  * when no video buffer is available, uvc_video_decode_start must be prepared
963  * to be called with a NULL buf parameter. uvc_video_decode_data and
964  * uvc_video_decode_end will never be called with a NULL buffer.
965  */
966 static int uvc_video_decode_start(struct uvc_streaming *stream,
967 		struct uvc_buffer *buf, const __u8 *data, int len)
968 {
969 	__u8 fid;
970 
971 	/* Sanity checks:
972 	 * - packet must be at least 2 bytes long
973 	 * - bHeaderLength value must be at least 2 bytes (see above)
974 	 * - bHeaderLength value can't be larger than the packet size.
975 	 */
976 	if (len < 2 || data[0] < 2 || data[0] > len) {
977 		stream->stats.frame.nb_invalid++;
978 		return -EINVAL;
979 	}
980 
981 	fid = data[1] & UVC_STREAM_FID;
982 
983 	/* Increase the sequence number regardless of any buffer states, so
984 	 * that discontinuous sequence numbers always indicate lost frames.
985 	 */
986 	if (stream->last_fid != fid) {
987 		stream->sequence++;
988 		if (stream->sequence)
989 			uvc_video_stats_update(stream);
990 	}
991 
992 	uvc_video_clock_decode(stream, buf, data, len);
993 	uvc_video_stats_decode(stream, data, len);
994 
995 	/* Store the payload FID bit and return immediately when the buffer is
996 	 * NULL.
997 	 */
998 	if (buf == NULL) {
999 		stream->last_fid = fid;
1000 		return -ENODATA;
1001 	}
1002 
1003 	/* Mark the buffer as bad if the error bit is set. */
1004 	if (data[1] & UVC_STREAM_ERR) {
1005 		uvc_trace(UVC_TRACE_FRAME, "Marking buffer as bad (error bit "
1006 			  "set).\n");
1007 		buf->error = 1;
1008 	}
1009 
1010 	/* Synchronize to the input stream by waiting for the FID bit to be
1011 	 * toggled when the the buffer state is not UVC_BUF_STATE_ACTIVE.
1012 	 * stream->last_fid is initialized to -1, so the first isochronous
1013 	 * frame will always be in sync.
1014 	 *
1015 	 * If the device doesn't toggle the FID bit, invert stream->last_fid
1016 	 * when the EOF bit is set to force synchronisation on the next packet.
1017 	 */
1018 	if (buf->state != UVC_BUF_STATE_ACTIVE) {
1019 		struct timespec ts;
1020 
1021 		if (fid == stream->last_fid) {
1022 			uvc_trace(UVC_TRACE_FRAME, "Dropping payload (out of "
1023 				"sync).\n");
1024 			if ((stream->dev->quirks & UVC_QUIRK_STREAM_NO_FID) &&
1025 			    (data[1] & UVC_STREAM_EOF))
1026 				stream->last_fid ^= UVC_STREAM_FID;
1027 			return -ENODATA;
1028 		}
1029 
1030 		uvc_video_get_ts(&ts);
1031 
1032 		buf->buf.field = V4L2_FIELD_NONE;
1033 		buf->buf.sequence = stream->sequence;
1034 		buf->buf.vb2_buf.timestamp = timespec_to_ns(&ts);
1035 
1036 		/* TODO: Handle PTS and SCR. */
1037 		buf->state = UVC_BUF_STATE_ACTIVE;
1038 	}
1039 
1040 	/* Mark the buffer as done if we're at the beginning of a new frame.
1041 	 * End of frame detection is better implemented by checking the EOF
1042 	 * bit (FID bit toggling is delayed by one frame compared to the EOF
1043 	 * bit), but some devices don't set the bit at end of frame (and the
1044 	 * last payload can be lost anyway). We thus must check if the FID has
1045 	 * been toggled.
1046 	 *
1047 	 * stream->last_fid is initialized to -1, so the first isochronous
1048 	 * frame will never trigger an end of frame detection.
1049 	 *
1050 	 * Empty buffers (bytesused == 0) don't trigger end of frame detection
1051 	 * as it doesn't make sense to return an empty buffer. This also
1052 	 * avoids detecting end of frame conditions at FID toggling if the
1053 	 * previous payload had the EOF bit set.
1054 	 */
1055 	if (fid != stream->last_fid && buf->bytesused != 0) {
1056 		uvc_trace(UVC_TRACE_FRAME, "Frame complete (FID bit "
1057 				"toggled).\n");
1058 		buf->state = UVC_BUF_STATE_READY;
1059 		return -EAGAIN;
1060 	}
1061 
1062 	stream->last_fid = fid;
1063 
1064 	return data[0];
1065 }
1066 
1067 static void uvc_video_decode_data(struct uvc_streaming *stream,
1068 		struct uvc_buffer *buf, const __u8 *data, int len)
1069 {
1070 	unsigned int maxlen, nbytes;
1071 	void *mem;
1072 
1073 	if (len <= 0)
1074 		return;
1075 
1076 	/* Copy the video data to the buffer. */
1077 	maxlen = buf->length - buf->bytesused;
1078 	mem = buf->mem + buf->bytesused;
1079 	nbytes = min((unsigned int)len, maxlen);
1080 	memcpy(mem, data, nbytes);
1081 	buf->bytesused += nbytes;
1082 
1083 	/* Complete the current frame if the buffer size was exceeded. */
1084 	if (len > maxlen) {
1085 		uvc_trace(UVC_TRACE_FRAME, "Frame complete (overflow).\n");
1086 		buf->state = UVC_BUF_STATE_READY;
1087 	}
1088 }
1089 
1090 static void uvc_video_decode_end(struct uvc_streaming *stream,
1091 		struct uvc_buffer *buf, const __u8 *data, int len)
1092 {
1093 	/* Mark the buffer as done if the EOF marker is set. */
1094 	if (data[1] & UVC_STREAM_EOF && buf->bytesused != 0) {
1095 		uvc_trace(UVC_TRACE_FRAME, "Frame complete (EOF found).\n");
1096 		if (data[0] == len)
1097 			uvc_trace(UVC_TRACE_FRAME, "EOF in empty payload.\n");
1098 		buf->state = UVC_BUF_STATE_READY;
1099 		if (stream->dev->quirks & UVC_QUIRK_STREAM_NO_FID)
1100 			stream->last_fid ^= UVC_STREAM_FID;
1101 	}
1102 }
1103 
1104 /* Video payload encoding is handled by uvc_video_encode_header() and
1105  * uvc_video_encode_data(). Only bulk transfers are currently supported.
1106  *
1107  * uvc_video_encode_header is called at the start of a payload. It adds header
1108  * data to the transfer buffer and returns the header size. As the only known
1109  * UVC output device transfers a whole frame in a single payload, the EOF bit
1110  * is always set in the header.
1111  *
1112  * uvc_video_encode_data is called for every URB and copies the data from the
1113  * video buffer to the transfer buffer.
1114  */
1115 static int uvc_video_encode_header(struct uvc_streaming *stream,
1116 		struct uvc_buffer *buf, __u8 *data, int len)
1117 {
1118 	data[0] = 2;	/* Header length */
1119 	data[1] = UVC_STREAM_EOH | UVC_STREAM_EOF
1120 		| (stream->last_fid & UVC_STREAM_FID);
1121 	return 2;
1122 }
1123 
1124 static int uvc_video_encode_data(struct uvc_streaming *stream,
1125 		struct uvc_buffer *buf, __u8 *data, int len)
1126 {
1127 	struct uvc_video_queue *queue = &stream->queue;
1128 	unsigned int nbytes;
1129 	void *mem;
1130 
1131 	/* Copy video data to the URB buffer. */
1132 	mem = buf->mem + queue->buf_used;
1133 	nbytes = min((unsigned int)len, buf->bytesused - queue->buf_used);
1134 	nbytes = min(stream->bulk.max_payload_size - stream->bulk.payload_size,
1135 			nbytes);
1136 	memcpy(data, mem, nbytes);
1137 
1138 	queue->buf_used += nbytes;
1139 
1140 	return nbytes;
1141 }
1142 
1143 /* ------------------------------------------------------------------------
1144  * URB handling
1145  */
1146 
1147 /*
1148  * Set error flag for incomplete buffer.
1149  */
1150 static void uvc_video_validate_buffer(const struct uvc_streaming *stream,
1151 				      struct uvc_buffer *buf)
1152 {
1153 	if (stream->ctrl.dwMaxVideoFrameSize != buf->bytesused &&
1154 	    !(stream->cur_format->flags & UVC_FMT_FLAG_COMPRESSED))
1155 		buf->error = 1;
1156 }
1157 
1158 /*
1159  * Completion handler for video URBs.
1160  */
1161 static void uvc_video_decode_isoc(struct urb *urb, struct uvc_streaming *stream,
1162 	struct uvc_buffer *buf)
1163 {
1164 	u8 *mem;
1165 	int ret, i;
1166 
1167 	for (i = 0; i < urb->number_of_packets; ++i) {
1168 		if (urb->iso_frame_desc[i].status < 0) {
1169 			uvc_trace(UVC_TRACE_FRAME, "USB isochronous frame "
1170 				"lost (%d).\n", urb->iso_frame_desc[i].status);
1171 			/* Mark the buffer as faulty. */
1172 			if (buf != NULL)
1173 				buf->error = 1;
1174 			continue;
1175 		}
1176 
1177 		/* Decode the payload header. */
1178 		mem = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
1179 		do {
1180 			ret = uvc_video_decode_start(stream, buf, mem,
1181 				urb->iso_frame_desc[i].actual_length);
1182 			if (ret == -EAGAIN) {
1183 				uvc_video_validate_buffer(stream, buf);
1184 				buf = uvc_queue_next_buffer(&stream->queue,
1185 							    buf);
1186 			}
1187 		} while (ret == -EAGAIN);
1188 
1189 		if (ret < 0)
1190 			continue;
1191 
1192 		/* Decode the payload data. */
1193 		uvc_video_decode_data(stream, buf, mem + ret,
1194 			urb->iso_frame_desc[i].actual_length - ret);
1195 
1196 		/* Process the header again. */
1197 		uvc_video_decode_end(stream, buf, mem,
1198 			urb->iso_frame_desc[i].actual_length);
1199 
1200 		if (buf->state == UVC_BUF_STATE_READY) {
1201 			uvc_video_validate_buffer(stream, buf);
1202 			buf = uvc_queue_next_buffer(&stream->queue, buf);
1203 		}
1204 	}
1205 }
1206 
1207 static void uvc_video_decode_bulk(struct urb *urb, struct uvc_streaming *stream,
1208 	struct uvc_buffer *buf)
1209 {
1210 	u8 *mem;
1211 	int len, ret;
1212 
1213 	/*
1214 	 * Ignore ZLPs if they're not part of a frame, otherwise process them
1215 	 * to trigger the end of payload detection.
1216 	 */
1217 	if (urb->actual_length == 0 && stream->bulk.header_size == 0)
1218 		return;
1219 
1220 	mem = urb->transfer_buffer;
1221 	len = urb->actual_length;
1222 	stream->bulk.payload_size += len;
1223 
1224 	/* If the URB is the first of its payload, decode and save the
1225 	 * header.
1226 	 */
1227 	if (stream->bulk.header_size == 0 && !stream->bulk.skip_payload) {
1228 		do {
1229 			ret = uvc_video_decode_start(stream, buf, mem, len);
1230 			if (ret == -EAGAIN)
1231 				buf = uvc_queue_next_buffer(&stream->queue,
1232 							    buf);
1233 		} while (ret == -EAGAIN);
1234 
1235 		/* If an error occurred skip the rest of the payload. */
1236 		if (ret < 0 || buf == NULL) {
1237 			stream->bulk.skip_payload = 1;
1238 		} else {
1239 			memcpy(stream->bulk.header, mem, ret);
1240 			stream->bulk.header_size = ret;
1241 
1242 			mem += ret;
1243 			len -= ret;
1244 		}
1245 	}
1246 
1247 	/* The buffer queue might have been cancelled while a bulk transfer
1248 	 * was in progress, so we can reach here with buf equal to NULL. Make
1249 	 * sure buf is never dereferenced if NULL.
1250 	 */
1251 
1252 	/* Process video data. */
1253 	if (!stream->bulk.skip_payload && buf != NULL)
1254 		uvc_video_decode_data(stream, buf, mem, len);
1255 
1256 	/* Detect the payload end by a URB smaller than the maximum size (or
1257 	 * a payload size equal to the maximum) and process the header again.
1258 	 */
1259 	if (urb->actual_length < urb->transfer_buffer_length ||
1260 	    stream->bulk.payload_size >= stream->bulk.max_payload_size) {
1261 		if (!stream->bulk.skip_payload && buf != NULL) {
1262 			uvc_video_decode_end(stream, buf, stream->bulk.header,
1263 				stream->bulk.payload_size);
1264 			if (buf->state == UVC_BUF_STATE_READY)
1265 				uvc_queue_next_buffer(&stream->queue, buf);
1266 		}
1267 
1268 		stream->bulk.header_size = 0;
1269 		stream->bulk.skip_payload = 0;
1270 		stream->bulk.payload_size = 0;
1271 	}
1272 }
1273 
1274 static void uvc_video_encode_bulk(struct urb *urb, struct uvc_streaming *stream,
1275 	struct uvc_buffer *buf)
1276 {
1277 	u8 *mem = urb->transfer_buffer;
1278 	int len = stream->urb_size, ret;
1279 
1280 	if (buf == NULL) {
1281 		urb->transfer_buffer_length = 0;
1282 		return;
1283 	}
1284 
1285 	/* If the URB is the first of its payload, add the header. */
1286 	if (stream->bulk.header_size == 0) {
1287 		ret = uvc_video_encode_header(stream, buf, mem, len);
1288 		stream->bulk.header_size = ret;
1289 		stream->bulk.payload_size += ret;
1290 		mem += ret;
1291 		len -= ret;
1292 	}
1293 
1294 	/* Process video data. */
1295 	ret = uvc_video_encode_data(stream, buf, mem, len);
1296 
1297 	stream->bulk.payload_size += ret;
1298 	len -= ret;
1299 
1300 	if (buf->bytesused == stream->queue.buf_used ||
1301 	    stream->bulk.payload_size == stream->bulk.max_payload_size) {
1302 		if (buf->bytesused == stream->queue.buf_used) {
1303 			stream->queue.buf_used = 0;
1304 			buf->state = UVC_BUF_STATE_READY;
1305 			buf->buf.sequence = ++stream->sequence;
1306 			uvc_queue_next_buffer(&stream->queue, buf);
1307 			stream->last_fid ^= UVC_STREAM_FID;
1308 		}
1309 
1310 		stream->bulk.header_size = 0;
1311 		stream->bulk.payload_size = 0;
1312 	}
1313 
1314 	urb->transfer_buffer_length = stream->urb_size - len;
1315 }
1316 
1317 static void uvc_video_complete(struct urb *urb)
1318 {
1319 	struct uvc_streaming *stream = urb->context;
1320 	struct uvc_video_queue *queue = &stream->queue;
1321 	struct uvc_buffer *buf = NULL;
1322 	unsigned long flags;
1323 	int ret;
1324 
1325 	switch (urb->status) {
1326 	case 0:
1327 		break;
1328 
1329 	default:
1330 		uvc_printk(KERN_WARNING, "Non-zero status (%d) in video "
1331 			"completion handler.\n", urb->status);
1332 
1333 	case -ENOENT:		/* usb_kill_urb() called. */
1334 		if (stream->frozen)
1335 			return;
1336 
1337 	case -ECONNRESET:	/* usb_unlink_urb() called. */
1338 	case -ESHUTDOWN:	/* The endpoint is being disabled. */
1339 		uvc_queue_cancel(queue, urb->status == -ESHUTDOWN);
1340 		return;
1341 	}
1342 
1343 	spin_lock_irqsave(&queue->irqlock, flags);
1344 	if (!list_empty(&queue->irqqueue))
1345 		buf = list_first_entry(&queue->irqqueue, struct uvc_buffer,
1346 				       queue);
1347 	spin_unlock_irqrestore(&queue->irqlock, flags);
1348 
1349 	stream->decode(urb, stream, buf);
1350 
1351 	if ((ret = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
1352 		uvc_printk(KERN_ERR, "Failed to resubmit video URB (%d).\n",
1353 			ret);
1354 	}
1355 }
1356 
1357 /*
1358  * Free transfer buffers.
1359  */
1360 static void uvc_free_urb_buffers(struct uvc_streaming *stream)
1361 {
1362 	unsigned int i;
1363 
1364 	for (i = 0; i < UVC_URBS; ++i) {
1365 		if (stream->urb_buffer[i]) {
1366 #ifndef CONFIG_DMA_NONCOHERENT
1367 			usb_free_coherent(stream->dev->udev, stream->urb_size,
1368 				stream->urb_buffer[i], stream->urb_dma[i]);
1369 #else
1370 			kfree(stream->urb_buffer[i]);
1371 #endif
1372 			stream->urb_buffer[i] = NULL;
1373 		}
1374 	}
1375 
1376 	stream->urb_size = 0;
1377 }
1378 
1379 /*
1380  * Allocate transfer buffers. This function can be called with buffers
1381  * already allocated when resuming from suspend, in which case it will
1382  * return without touching the buffers.
1383  *
1384  * Limit the buffer size to UVC_MAX_PACKETS bulk/isochronous packets. If the
1385  * system is too low on memory try successively smaller numbers of packets
1386  * until allocation succeeds.
1387  *
1388  * Return the number of allocated packets on success or 0 when out of memory.
1389  */
1390 static int uvc_alloc_urb_buffers(struct uvc_streaming *stream,
1391 	unsigned int size, unsigned int psize, gfp_t gfp_flags)
1392 {
1393 	unsigned int npackets;
1394 	unsigned int i;
1395 
1396 	/* Buffers are already allocated, bail out. */
1397 	if (stream->urb_size)
1398 		return stream->urb_size / psize;
1399 
1400 	/* Compute the number of packets. Bulk endpoints might transfer UVC
1401 	 * payloads across multiple URBs.
1402 	 */
1403 	npackets = DIV_ROUND_UP(size, psize);
1404 	if (npackets > UVC_MAX_PACKETS)
1405 		npackets = UVC_MAX_PACKETS;
1406 
1407 	/* Retry allocations until one succeed. */
1408 	for (; npackets > 1; npackets /= 2) {
1409 		for (i = 0; i < UVC_URBS; ++i) {
1410 			stream->urb_size = psize * npackets;
1411 #ifndef CONFIG_DMA_NONCOHERENT
1412 			stream->urb_buffer[i] = usb_alloc_coherent(
1413 				stream->dev->udev, stream->urb_size,
1414 				gfp_flags | __GFP_NOWARN, &stream->urb_dma[i]);
1415 #else
1416 			stream->urb_buffer[i] =
1417 			    kmalloc(stream->urb_size, gfp_flags | __GFP_NOWARN);
1418 #endif
1419 			if (!stream->urb_buffer[i]) {
1420 				uvc_free_urb_buffers(stream);
1421 				break;
1422 			}
1423 		}
1424 
1425 		if (i == UVC_URBS) {
1426 			uvc_trace(UVC_TRACE_VIDEO, "Allocated %u URB buffers "
1427 				"of %ux%u bytes each.\n", UVC_URBS, npackets,
1428 				psize);
1429 			return npackets;
1430 		}
1431 	}
1432 
1433 	uvc_trace(UVC_TRACE_VIDEO, "Failed to allocate URB buffers (%u bytes "
1434 		"per packet).\n", psize);
1435 	return 0;
1436 }
1437 
1438 /*
1439  * Uninitialize isochronous/bulk URBs and free transfer buffers.
1440  */
1441 static void uvc_uninit_video(struct uvc_streaming *stream, int free_buffers)
1442 {
1443 	struct urb *urb;
1444 	unsigned int i;
1445 
1446 	uvc_video_stats_stop(stream);
1447 
1448 	for (i = 0; i < UVC_URBS; ++i) {
1449 		urb = stream->urb[i];
1450 		if (urb == NULL)
1451 			continue;
1452 
1453 		usb_kill_urb(urb);
1454 		usb_free_urb(urb);
1455 		stream->urb[i] = NULL;
1456 	}
1457 
1458 	if (free_buffers)
1459 		uvc_free_urb_buffers(stream);
1460 }
1461 
1462 /*
1463  * Compute the maximum number of bytes per interval for an endpoint.
1464  */
1465 static unsigned int uvc_endpoint_max_bpi(struct usb_device *dev,
1466 					 struct usb_host_endpoint *ep)
1467 {
1468 	u16 psize;
1469 	u16 mult;
1470 
1471 	switch (dev->speed) {
1472 	case USB_SPEED_SUPER:
1473 	case USB_SPEED_SUPER_PLUS:
1474 		return le16_to_cpu(ep->ss_ep_comp.wBytesPerInterval);
1475 	case USB_SPEED_HIGH:
1476 		psize = usb_endpoint_maxp(&ep->desc);
1477 		mult = usb_endpoint_maxp_mult(&ep->desc);
1478 		return (psize & 0x07ff) * mult;
1479 	case USB_SPEED_WIRELESS:
1480 		psize = usb_endpoint_maxp(&ep->desc);
1481 		return psize;
1482 	default:
1483 		psize = usb_endpoint_maxp(&ep->desc);
1484 		return psize & 0x07ff;
1485 	}
1486 }
1487 
1488 /*
1489  * Initialize isochronous URBs and allocate transfer buffers. The packet size
1490  * is given by the endpoint.
1491  */
1492 static int uvc_init_video_isoc(struct uvc_streaming *stream,
1493 	struct usb_host_endpoint *ep, gfp_t gfp_flags)
1494 {
1495 	struct urb *urb;
1496 	unsigned int npackets, i, j;
1497 	u16 psize;
1498 	u32 size;
1499 
1500 	psize = uvc_endpoint_max_bpi(stream->dev->udev, ep);
1501 	size = stream->ctrl.dwMaxVideoFrameSize;
1502 
1503 	npackets = uvc_alloc_urb_buffers(stream, size, psize, gfp_flags);
1504 	if (npackets == 0)
1505 		return -ENOMEM;
1506 
1507 	size = npackets * psize;
1508 
1509 	for (i = 0; i < UVC_URBS; ++i) {
1510 		urb = usb_alloc_urb(npackets, gfp_flags);
1511 		if (urb == NULL) {
1512 			uvc_uninit_video(stream, 1);
1513 			return -ENOMEM;
1514 		}
1515 
1516 		urb->dev = stream->dev->udev;
1517 		urb->context = stream;
1518 		urb->pipe = usb_rcvisocpipe(stream->dev->udev,
1519 				ep->desc.bEndpointAddress);
1520 #ifndef CONFIG_DMA_NONCOHERENT
1521 		urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
1522 		urb->transfer_dma = stream->urb_dma[i];
1523 #else
1524 		urb->transfer_flags = URB_ISO_ASAP;
1525 #endif
1526 		urb->interval = ep->desc.bInterval;
1527 		urb->transfer_buffer = stream->urb_buffer[i];
1528 		urb->complete = uvc_video_complete;
1529 		urb->number_of_packets = npackets;
1530 		urb->transfer_buffer_length = size;
1531 
1532 		for (j = 0; j < npackets; ++j) {
1533 			urb->iso_frame_desc[j].offset = j * psize;
1534 			urb->iso_frame_desc[j].length = psize;
1535 		}
1536 
1537 		stream->urb[i] = urb;
1538 	}
1539 
1540 	return 0;
1541 }
1542 
1543 /*
1544  * Initialize bulk URBs and allocate transfer buffers. The packet size is
1545  * given by the endpoint.
1546  */
1547 static int uvc_init_video_bulk(struct uvc_streaming *stream,
1548 	struct usb_host_endpoint *ep, gfp_t gfp_flags)
1549 {
1550 	struct urb *urb;
1551 	unsigned int npackets, pipe, i;
1552 	u16 psize;
1553 	u32 size;
1554 
1555 	psize = usb_endpoint_maxp(&ep->desc);
1556 	size = stream->ctrl.dwMaxPayloadTransferSize;
1557 	stream->bulk.max_payload_size = size;
1558 
1559 	npackets = uvc_alloc_urb_buffers(stream, size, psize, gfp_flags);
1560 	if (npackets == 0)
1561 		return -ENOMEM;
1562 
1563 	size = npackets * psize;
1564 
1565 	if (usb_endpoint_dir_in(&ep->desc))
1566 		pipe = usb_rcvbulkpipe(stream->dev->udev,
1567 				       ep->desc.bEndpointAddress);
1568 	else
1569 		pipe = usb_sndbulkpipe(stream->dev->udev,
1570 				       ep->desc.bEndpointAddress);
1571 
1572 	if (stream->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
1573 		size = 0;
1574 
1575 	for (i = 0; i < UVC_URBS; ++i) {
1576 		urb = usb_alloc_urb(0, gfp_flags);
1577 		if (urb == NULL) {
1578 			uvc_uninit_video(stream, 1);
1579 			return -ENOMEM;
1580 		}
1581 
1582 		usb_fill_bulk_urb(urb, stream->dev->udev, pipe,
1583 			stream->urb_buffer[i], size, uvc_video_complete,
1584 			stream);
1585 #ifndef CONFIG_DMA_NONCOHERENT
1586 		urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
1587 		urb->transfer_dma = stream->urb_dma[i];
1588 #endif
1589 
1590 		stream->urb[i] = urb;
1591 	}
1592 
1593 	return 0;
1594 }
1595 
1596 /*
1597  * Initialize isochronous/bulk URBs and allocate transfer buffers.
1598  */
1599 static int uvc_init_video(struct uvc_streaming *stream, gfp_t gfp_flags)
1600 {
1601 	struct usb_interface *intf = stream->intf;
1602 	struct usb_host_endpoint *ep;
1603 	unsigned int i;
1604 	int ret;
1605 
1606 	stream->sequence = -1;
1607 	stream->last_fid = -1;
1608 	stream->bulk.header_size = 0;
1609 	stream->bulk.skip_payload = 0;
1610 	stream->bulk.payload_size = 0;
1611 
1612 	uvc_video_stats_start(stream);
1613 
1614 	if (intf->num_altsetting > 1) {
1615 		struct usb_host_endpoint *best_ep = NULL;
1616 		unsigned int best_psize = UINT_MAX;
1617 		unsigned int bandwidth;
1618 		unsigned int uninitialized_var(altsetting);
1619 		int intfnum = stream->intfnum;
1620 
1621 		/* Isochronous endpoint, select the alternate setting. */
1622 		bandwidth = stream->ctrl.dwMaxPayloadTransferSize;
1623 
1624 		if (bandwidth == 0) {
1625 			uvc_trace(UVC_TRACE_VIDEO, "Device requested null "
1626 				"bandwidth, defaulting to lowest.\n");
1627 			bandwidth = 1;
1628 		} else {
1629 			uvc_trace(UVC_TRACE_VIDEO, "Device requested %u "
1630 				"B/frame bandwidth.\n", bandwidth);
1631 		}
1632 
1633 		for (i = 0; i < intf->num_altsetting; ++i) {
1634 			struct usb_host_interface *alts;
1635 			unsigned int psize;
1636 
1637 			alts = &intf->altsetting[i];
1638 			ep = uvc_find_endpoint(alts,
1639 				stream->header.bEndpointAddress);
1640 			if (ep == NULL)
1641 				continue;
1642 
1643 			/* Check if the bandwidth is high enough. */
1644 			psize = uvc_endpoint_max_bpi(stream->dev->udev, ep);
1645 			if (psize >= bandwidth && psize <= best_psize) {
1646 				altsetting = alts->desc.bAlternateSetting;
1647 				best_psize = psize;
1648 				best_ep = ep;
1649 			}
1650 		}
1651 
1652 		if (best_ep == NULL) {
1653 			uvc_trace(UVC_TRACE_VIDEO, "No fast enough alt setting "
1654 				"for requested bandwidth.\n");
1655 			return -EIO;
1656 		}
1657 
1658 		uvc_trace(UVC_TRACE_VIDEO, "Selecting alternate setting %u "
1659 			"(%u B/frame bandwidth).\n", altsetting, best_psize);
1660 
1661 		ret = usb_set_interface(stream->dev->udev, intfnum, altsetting);
1662 		if (ret < 0)
1663 			return ret;
1664 
1665 		ret = uvc_init_video_isoc(stream, best_ep, gfp_flags);
1666 	} else {
1667 		/* Bulk endpoint, proceed to URB initialization. */
1668 		ep = uvc_find_endpoint(&intf->altsetting[0],
1669 				stream->header.bEndpointAddress);
1670 		if (ep == NULL)
1671 			return -EIO;
1672 
1673 		ret = uvc_init_video_bulk(stream, ep, gfp_flags);
1674 	}
1675 
1676 	if (ret < 0)
1677 		return ret;
1678 
1679 	/* Submit the URBs. */
1680 	for (i = 0; i < UVC_URBS; ++i) {
1681 		ret = usb_submit_urb(stream->urb[i], gfp_flags);
1682 		if (ret < 0) {
1683 			uvc_printk(KERN_ERR, "Failed to submit URB %u "
1684 					"(%d).\n", i, ret);
1685 			uvc_uninit_video(stream, 1);
1686 			return ret;
1687 		}
1688 	}
1689 
1690 	/* The Logitech C920 temporarily forgets that it should not be adjusting
1691 	 * Exposure Absolute during init so restore controls to stored values.
1692 	 */
1693 	if (stream->dev->quirks & UVC_QUIRK_RESTORE_CTRLS_ON_INIT)
1694 		uvc_ctrl_restore_values(stream->dev);
1695 
1696 	return 0;
1697 }
1698 
1699 /* --------------------------------------------------------------------------
1700  * Suspend/resume
1701  */
1702 
1703 /*
1704  * Stop streaming without disabling the video queue.
1705  *
1706  * To let userspace applications resume without trouble, we must not touch the
1707  * video buffers in any way. We mark the device as frozen to make sure the URB
1708  * completion handler won't try to cancel the queue when we kill the URBs.
1709  */
1710 int uvc_video_suspend(struct uvc_streaming *stream)
1711 {
1712 	if (!uvc_queue_streaming(&stream->queue))
1713 		return 0;
1714 
1715 	stream->frozen = 1;
1716 	uvc_uninit_video(stream, 0);
1717 	usb_set_interface(stream->dev->udev, stream->intfnum, 0);
1718 	return 0;
1719 }
1720 
1721 /*
1722  * Reconfigure the video interface and restart streaming if it was enabled
1723  * before suspend.
1724  *
1725  * If an error occurs, disable the video queue. This will wake all pending
1726  * buffers, making sure userspace applications are notified of the problem
1727  * instead of waiting forever.
1728  */
1729 int uvc_video_resume(struct uvc_streaming *stream, int reset)
1730 {
1731 	int ret;
1732 
1733 	/* If the bus has been reset on resume, set the alternate setting to 0.
1734 	 * This should be the default value, but some devices crash or otherwise
1735 	 * misbehave if they don't receive a SET_INTERFACE request before any
1736 	 * other video control request.
1737 	 */
1738 	if (reset)
1739 		usb_set_interface(stream->dev->udev, stream->intfnum, 0);
1740 
1741 	stream->frozen = 0;
1742 
1743 	uvc_video_clock_reset(stream);
1744 
1745 	if (!uvc_queue_streaming(&stream->queue))
1746 		return 0;
1747 
1748 	ret = uvc_commit_video(stream, &stream->ctrl);
1749 	if (ret < 0)
1750 		return ret;
1751 
1752 	return uvc_init_video(stream, GFP_NOIO);
1753 }
1754 
1755 /* ------------------------------------------------------------------------
1756  * Video device
1757  */
1758 
1759 /*
1760  * Initialize the UVC video device by switching to alternate setting 0 and
1761  * retrieve the default format.
1762  *
1763  * Some cameras (namely the Fuji Finepix) set the format and frame
1764  * indexes to zero. The UVC standard doesn't clearly make this a spec
1765  * violation, so try to silently fix the values if possible.
1766  *
1767  * This function is called before registering the device with V4L.
1768  */
1769 int uvc_video_init(struct uvc_streaming *stream)
1770 {
1771 	struct uvc_streaming_control *probe = &stream->ctrl;
1772 	struct uvc_format *format = NULL;
1773 	struct uvc_frame *frame = NULL;
1774 	unsigned int i;
1775 	int ret;
1776 
1777 	if (stream->nformats == 0) {
1778 		uvc_printk(KERN_INFO, "No supported video formats found.\n");
1779 		return -EINVAL;
1780 	}
1781 
1782 	atomic_set(&stream->active, 0);
1783 
1784 	/* Alternate setting 0 should be the default, yet the XBox Live Vision
1785 	 * Cam (and possibly other devices) crash or otherwise misbehave if
1786 	 * they don't receive a SET_INTERFACE request before any other video
1787 	 * control request.
1788 	 */
1789 	usb_set_interface(stream->dev->udev, stream->intfnum, 0);
1790 
1791 	/* Set the streaming probe control with default streaming parameters
1792 	 * retrieved from the device. Webcams that don't suport GET_DEF
1793 	 * requests on the probe control will just keep their current streaming
1794 	 * parameters.
1795 	 */
1796 	if (uvc_get_video_ctrl(stream, probe, 1, UVC_GET_DEF) == 0)
1797 		uvc_set_video_ctrl(stream, probe, 1);
1798 
1799 	/* Initialize the streaming parameters with the probe control current
1800 	 * value. This makes sure SET_CUR requests on the streaming commit
1801 	 * control will always use values retrieved from a successful GET_CUR
1802 	 * request on the probe control, as required by the UVC specification.
1803 	 */
1804 	ret = uvc_get_video_ctrl(stream, probe, 1, UVC_GET_CUR);
1805 	if (ret < 0)
1806 		return ret;
1807 
1808 	/* Check if the default format descriptor exists. Use the first
1809 	 * available format otherwise.
1810 	 */
1811 	for (i = stream->nformats; i > 0; --i) {
1812 		format = &stream->format[i-1];
1813 		if (format->index == probe->bFormatIndex)
1814 			break;
1815 	}
1816 
1817 	if (format->nframes == 0) {
1818 		uvc_printk(KERN_INFO, "No frame descriptor found for the "
1819 			"default format.\n");
1820 		return -EINVAL;
1821 	}
1822 
1823 	/* Zero bFrameIndex might be correct. Stream-based formats (including
1824 	 * MPEG-2 TS and DV) do not support frames but have a dummy frame
1825 	 * descriptor with bFrameIndex set to zero. If the default frame
1826 	 * descriptor is not found, use the first available frame.
1827 	 */
1828 	for (i = format->nframes; i > 0; --i) {
1829 		frame = &format->frame[i-1];
1830 		if (frame->bFrameIndex == probe->bFrameIndex)
1831 			break;
1832 	}
1833 
1834 	probe->bFormatIndex = format->index;
1835 	probe->bFrameIndex = frame->bFrameIndex;
1836 
1837 	stream->def_format = format;
1838 	stream->cur_format = format;
1839 	stream->cur_frame = frame;
1840 
1841 	/* Select the video decoding function */
1842 	if (stream->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1843 		if (stream->dev->quirks & UVC_QUIRK_BUILTIN_ISIGHT)
1844 			stream->decode = uvc_video_decode_isight;
1845 		else if (stream->intf->num_altsetting > 1)
1846 			stream->decode = uvc_video_decode_isoc;
1847 		else
1848 			stream->decode = uvc_video_decode_bulk;
1849 	} else {
1850 		if (stream->intf->num_altsetting == 1)
1851 			stream->decode = uvc_video_encode_bulk;
1852 		else {
1853 			uvc_printk(KERN_INFO, "Isochronous endpoints are not "
1854 				"supported for video output devices.\n");
1855 			return -EINVAL;
1856 		}
1857 	}
1858 
1859 	return 0;
1860 }
1861 
1862 /*
1863  * Enable or disable the video stream.
1864  */
1865 int uvc_video_enable(struct uvc_streaming *stream, int enable)
1866 {
1867 	int ret;
1868 
1869 	if (!enable) {
1870 		uvc_uninit_video(stream, 1);
1871 		if (stream->intf->num_altsetting > 1) {
1872 			usb_set_interface(stream->dev->udev,
1873 					  stream->intfnum, 0);
1874 		} else {
1875 			/* UVC doesn't specify how to inform a bulk-based device
1876 			 * when the video stream is stopped. Windows sends a
1877 			 * CLEAR_FEATURE(HALT) request to the video streaming
1878 			 * bulk endpoint, mimic the same behaviour.
1879 			 */
1880 			unsigned int epnum = stream->header.bEndpointAddress
1881 					   & USB_ENDPOINT_NUMBER_MASK;
1882 			unsigned int dir = stream->header.bEndpointAddress
1883 					 & USB_ENDPOINT_DIR_MASK;
1884 			unsigned int pipe;
1885 
1886 			pipe = usb_sndbulkpipe(stream->dev->udev, epnum) | dir;
1887 			usb_clear_halt(stream->dev->udev, pipe);
1888 		}
1889 
1890 		uvc_video_clock_cleanup(stream);
1891 		return 0;
1892 	}
1893 
1894 	ret = uvc_video_clock_init(stream);
1895 	if (ret < 0)
1896 		return ret;
1897 
1898 	/* Commit the streaming parameters. */
1899 	ret = uvc_commit_video(stream, &stream->ctrl);
1900 	if (ret < 0)
1901 		goto error_commit;
1902 
1903 	ret = uvc_init_video(stream, GFP_KERNEL);
1904 	if (ret < 0)
1905 		goto error_video;
1906 
1907 	return 0;
1908 
1909 error_video:
1910 	usb_set_interface(stream->dev->udev, stream->intfnum, 0);
1911 error_commit:
1912 	uvc_video_clock_cleanup(stream);
1913 
1914 	return ret;
1915 }
1916