1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/kernel.h>
15#include <linux/list.h>
16#include <linux/module.h>
17#include <linux/usb.h>
18#include <linux/videodev2.h>
19#include <linux/vmalloc.h>
20#include <linux/wait.h>
21#include <asm/atomic.h>
22#include <asm/unaligned.h>
23
24#include <media/v4l2-common.h>
25
26#include "uvcvideo.h"
27
28
29
30
31
32static int __uvc_query_ctrl(struct uvc_device *dev, __u8 query, __u8 unit,
33 __u8 intfnum, __u8 cs, void *data, __u16 size,
34 int timeout)
35{
36 __u8 type = USB_TYPE_CLASS | USB_RECIP_INTERFACE;
37 unsigned int pipe;
38
39 pipe = (query & 0x80) ? usb_rcvctrlpipe(dev->udev, 0)
40 : usb_sndctrlpipe(dev->udev, 0);
41 type |= (query & 0x80) ? USB_DIR_IN : USB_DIR_OUT;
42
43 return usb_control_msg(dev->udev, pipe, query, type, cs << 8,
44 unit << 8 | intfnum, data, size, timeout);
45}
46
47int uvc_query_ctrl(struct uvc_device *dev, __u8 query, __u8 unit,
48 __u8 intfnum, __u8 cs, void *data, __u16 size)
49{
50 int ret;
51
52 ret = __uvc_query_ctrl(dev, query, unit, intfnum, cs, data, size,
53 UVC_CTRL_CONTROL_TIMEOUT);
54 if (ret != size) {
55 uvc_printk(KERN_ERR, "Failed to query (%u) UVC control %u "
56 "(unit %u) : %d (exp. %u).\n", query, cs, unit, ret,
57 size);
58 return -EIO;
59 }
60
61 return 0;
62}
63
64static void uvc_fixup_video_ctrl(struct uvc_streaming *stream,
65 struct uvc_streaming_control *ctrl)
66{
67 struct uvc_format *format;
68 struct uvc_frame *frame = NULL;
69 unsigned int i;
70
71 if (ctrl->bFormatIndex <= 0 ||
72 ctrl->bFormatIndex > stream->nformats)
73 return;
74
75 format = &stream->format[ctrl->bFormatIndex - 1];
76
77 for (i = 0; i < format->nframes; ++i) {
78 if (format->frame[i].bFrameIndex == ctrl->bFrameIndex) {
79 frame = &format->frame[i];
80 break;
81 }
82 }
83
84 if (frame == NULL)
85 return;
86
87 if (!(format->flags & UVC_FMT_FLAG_COMPRESSED) ||
88 (ctrl->dwMaxVideoFrameSize == 0 &&
89 stream->dev->uvc_version < 0x0110))
90 ctrl->dwMaxVideoFrameSize =
91 frame->dwMaxVideoFrameBufferSize;
92
93 if (!(format->flags & UVC_FMT_FLAG_COMPRESSED) &&
94 stream->dev->quirks & UVC_QUIRK_FIX_BANDWIDTH &&
95 stream->intf->num_altsetting > 1) {
96 u32 interval;
97 u32 bandwidth;
98
99 interval = (ctrl->dwFrameInterval > 100000)
100 ? ctrl->dwFrameInterval
101 : frame->dwFrameInterval[0];
102
103
104
105
106
107
108
109 bandwidth = frame->wWidth * frame->wHeight / 8 * format->bpp;
110 bandwidth *= 10000000 / interval + 1;
111 bandwidth /= 1000;
112 if (stream->dev->udev->speed == USB_SPEED_HIGH)
113 bandwidth /= 8;
114 bandwidth += 12;
115
116 ctrl->dwMaxPayloadTransferSize = bandwidth;
117 }
118}
119
120static int uvc_get_video_ctrl(struct uvc_streaming *stream,
121 struct uvc_streaming_control *ctrl, int probe, __u8 query)
122{
123 __u8 *data;
124 __u16 size;
125 int ret;
126
127 size = stream->dev->uvc_version >= 0x0110 ? 34 : 26;
128 if ((stream->dev->quirks & UVC_QUIRK_PROBE_DEF) &&
129 query == UVC_GET_DEF)
130 return -EIO;
131
132 data = kmalloc(size, GFP_KERNEL);
133 if (data == NULL)
134 return -ENOMEM;
135
136 ret = __uvc_query_ctrl(stream->dev, query, 0, stream->intfnum,
137 probe ? UVC_VS_PROBE_CONTROL : UVC_VS_COMMIT_CONTROL, data,
138 size, UVC_CTRL_STREAMING_TIMEOUT);
139
140 if ((query == UVC_GET_MIN || query == UVC_GET_MAX) && ret == 2) {
141
142
143
144
145 uvc_warn_once(stream->dev, UVC_WARN_MINMAX, "UVC non "
146 "compliance - GET_MIN/MAX(PROBE) incorrectly "
147 "supported. Enabling workaround.\n");
148 memset(ctrl, 0, sizeof ctrl);
149 ctrl->wCompQuality = le16_to_cpup((__le16 *)data);
150 ret = 0;
151 goto out;
152 } else if (query == UVC_GET_DEF && probe == 1 && ret != size) {
153
154
155
156
157 uvc_warn_once(stream->dev, UVC_WARN_PROBE_DEF, "UVC non "
158 "compliance - GET_DEF(PROBE) not supported. "
159 "Enabling workaround.\n");
160 ret = -EIO;
161 goto out;
162 } else if (ret != size) {
163 uvc_printk(KERN_ERR, "Failed to query (%u) UVC %s control : "
164 "%d (exp. %u).\n", query, probe ? "probe" : "commit",
165 ret, size);
166 ret = -EIO;
167 goto out;
168 }
169
170 ctrl->bmHint = le16_to_cpup((__le16 *)&data[0]);
171 ctrl->bFormatIndex = data[2];
172 ctrl->bFrameIndex = data[3];
173 ctrl->dwFrameInterval = le32_to_cpup((__le32 *)&data[4]);
174 ctrl->wKeyFrameRate = le16_to_cpup((__le16 *)&data[8]);
175 ctrl->wPFrameRate = le16_to_cpup((__le16 *)&data[10]);
176 ctrl->wCompQuality = le16_to_cpup((__le16 *)&data[12]);
177 ctrl->wCompWindowSize = le16_to_cpup((__le16 *)&data[14]);
178 ctrl->wDelay = le16_to_cpup((__le16 *)&data[16]);
179 ctrl->dwMaxVideoFrameSize = get_unaligned_le32(&data[18]);
180 ctrl->dwMaxPayloadTransferSize = get_unaligned_le32(&data[22]);
181
182 if (size == 34) {
183 ctrl->dwClockFrequency = get_unaligned_le32(&data[26]);
184 ctrl->bmFramingInfo = data[30];
185 ctrl->bPreferedVersion = data[31];
186 ctrl->bMinVersion = data[32];
187 ctrl->bMaxVersion = data[33];
188 } else {
189 ctrl->dwClockFrequency = stream->dev->clock_frequency;
190 ctrl->bmFramingInfo = 0;
191 ctrl->bPreferedVersion = 0;
192 ctrl->bMinVersion = 0;
193 ctrl->bMaxVersion = 0;
194 }
195
196
197
198
199
200 uvc_fixup_video_ctrl(stream, ctrl);
201 ret = 0;
202
203out:
204 kfree(data);
205 return ret;
206}
207
208static int uvc_set_video_ctrl(struct uvc_streaming *stream,
209 struct uvc_streaming_control *ctrl, int probe)
210{
211 __u8 *data;
212 __u16 size;
213 int ret;
214
215 size = stream->dev->uvc_version >= 0x0110 ? 34 : 26;
216 data = kzalloc(size, GFP_KERNEL);
217 if (data == NULL)
218 return -ENOMEM;
219
220 *(__le16 *)&data[0] = cpu_to_le16(ctrl->bmHint);
221 data[2] = ctrl->bFormatIndex;
222 data[3] = ctrl->bFrameIndex;
223 *(__le32 *)&data[4] = cpu_to_le32(ctrl->dwFrameInterval);
224 *(__le16 *)&data[8] = cpu_to_le16(ctrl->wKeyFrameRate);
225 *(__le16 *)&data[10] = cpu_to_le16(ctrl->wPFrameRate);
226 *(__le16 *)&data[12] = cpu_to_le16(ctrl->wCompQuality);
227 *(__le16 *)&data[14] = cpu_to_le16(ctrl->wCompWindowSize);
228 *(__le16 *)&data[16] = cpu_to_le16(ctrl->wDelay);
229 put_unaligned_le32(ctrl->dwMaxVideoFrameSize, &data[18]);
230 put_unaligned_le32(ctrl->dwMaxPayloadTransferSize, &data[22]);
231
232 if (size == 34) {
233 put_unaligned_le32(ctrl->dwClockFrequency, &data[26]);
234 data[30] = ctrl->bmFramingInfo;
235 data[31] = ctrl->bPreferedVersion;
236 data[32] = ctrl->bMinVersion;
237 data[33] = ctrl->bMaxVersion;
238 }
239
240 ret = __uvc_query_ctrl(stream->dev, UVC_SET_CUR, 0, stream->intfnum,
241 probe ? UVC_VS_PROBE_CONTROL : UVC_VS_COMMIT_CONTROL, data,
242 size, UVC_CTRL_STREAMING_TIMEOUT);
243 if (ret != size) {
244 uvc_printk(KERN_ERR, "Failed to set UVC %s control : "
245 "%d (exp. %u).\n", probe ? "probe" : "commit",
246 ret, size);
247 ret = -EIO;
248 }
249
250 kfree(data);
251 return ret;
252}
253
254int uvc_probe_video(struct uvc_streaming *stream,
255 struct uvc_streaming_control *probe)
256{
257 struct uvc_streaming_control probe_min, probe_max;
258 __u16 bandwidth;
259 unsigned int i;
260 int ret;
261
262 mutex_lock(&stream->mutex);
263
264
265
266
267
268
269
270
271 ret = uvc_set_video_ctrl(stream, probe, 1);
272 if (ret < 0)
273 goto done;
274
275
276 if (!(stream->dev->quirks & UVC_QUIRK_PROBE_MINMAX)) {
277 ret = uvc_get_video_ctrl(stream, &probe_min, 1, UVC_GET_MIN);
278 if (ret < 0)
279 goto done;
280 ret = uvc_get_video_ctrl(stream, &probe_max, 1, UVC_GET_MAX);
281 if (ret < 0)
282 goto done;
283
284 probe->wCompQuality = probe_max.wCompQuality;
285 }
286
287 for (i = 0; i < 2; ++i) {
288 ret = uvc_set_video_ctrl(stream, probe, 1);
289 if (ret < 0)
290 goto done;
291 ret = uvc_get_video_ctrl(stream, probe, 1, UVC_GET_CUR);
292 if (ret < 0)
293 goto done;
294
295 if (stream->intf->num_altsetting == 1)
296 break;
297
298 bandwidth = probe->dwMaxPayloadTransferSize;
299 if (bandwidth <= stream->maxpsize)
300 break;
301
302 if (stream->dev->quirks & UVC_QUIRK_PROBE_MINMAX) {
303 ret = -ENOSPC;
304 goto done;
305 }
306
307
308 probe->wKeyFrameRate = probe_min.wKeyFrameRate;
309 probe->wPFrameRate = probe_min.wPFrameRate;
310 probe->wCompQuality = probe_max.wCompQuality;
311 probe->wCompWindowSize = probe_min.wCompWindowSize;
312 }
313
314done:
315 mutex_unlock(&stream->mutex);
316 return ret;
317}
318
319int uvc_commit_video(struct uvc_streaming *stream,
320 struct uvc_streaming_control *probe)
321{
322 return uvc_set_video_ctrl(stream, probe, 0);
323}
324
325
326
327
328
329
330#define UVC_STREAM_EOH (1 << 7)
331#define UVC_STREAM_ERR (1 << 6)
332#define UVC_STREAM_STI (1 << 5)
333#define UVC_STREAM_RES (1 << 4)
334#define UVC_STREAM_SCR (1 << 3)
335#define UVC_STREAM_PTS (1 << 2)
336#define UVC_STREAM_EOF (1 << 1)
337#define UVC_STREAM_FID (1 << 0)
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374static int uvc_video_decode_start(struct uvc_streaming *stream,
375 struct uvc_buffer *buf, const __u8 *data, int len)
376{
377 __u8 fid;
378
379
380
381
382
383
384 if (len < 2 || data[0] < 2 || data[0] > len)
385 return -EINVAL;
386
387
388 if (data[1] & UVC_STREAM_ERR) {
389 uvc_trace(UVC_TRACE_FRAME, "Dropping payload (error bit "
390 "set).\n");
391 return -ENODATA;
392 }
393
394 fid = data[1] & UVC_STREAM_FID;
395
396
397
398
399 if (buf == NULL) {
400 stream->last_fid = fid;
401 return -ENODATA;
402 }
403
404
405
406
407
408
409
410
411
412 if (buf->state != UVC_BUF_STATE_ACTIVE) {
413 if (fid == stream->last_fid) {
414 uvc_trace(UVC_TRACE_FRAME, "Dropping payload (out of "
415 "sync).\n");
416 if ((stream->dev->quirks & UVC_QUIRK_STREAM_NO_FID) &&
417 (data[1] & UVC_STREAM_EOF))
418 stream->last_fid ^= UVC_STREAM_FID;
419 return -ENODATA;
420 }
421
422
423 buf->state = UVC_BUF_STATE_ACTIVE;
424 }
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441 if (fid != stream->last_fid && buf->buf.bytesused != 0) {
442 uvc_trace(UVC_TRACE_FRAME, "Frame complete (FID bit "
443 "toggled).\n");
444 buf->state = UVC_BUF_STATE_DONE;
445 return -EAGAIN;
446 }
447
448 stream->last_fid = fid;
449
450 return data[0];
451}
452
453static void uvc_video_decode_data(struct uvc_streaming *stream,
454 struct uvc_buffer *buf, const __u8 *data, int len)
455{
456 struct uvc_video_queue *queue = &stream->queue;
457 unsigned int maxlen, nbytes;
458 void *mem;
459
460 if (len <= 0)
461 return;
462
463
464 maxlen = buf->buf.length - buf->buf.bytesused;
465 mem = queue->mem + buf->buf.m.offset + buf->buf.bytesused;
466 nbytes = min((unsigned int)len, maxlen);
467 memcpy(mem, data, nbytes);
468 buf->buf.bytesused += nbytes;
469
470
471 if (len > maxlen) {
472 uvc_trace(UVC_TRACE_FRAME, "Frame complete (overflow).\n");
473 buf->state = UVC_BUF_STATE_DONE;
474 }
475}
476
477static void uvc_video_decode_end(struct uvc_streaming *stream,
478 struct uvc_buffer *buf, const __u8 *data, int len)
479{
480
481 if (data[1] & UVC_STREAM_EOF && buf->buf.bytesused != 0) {
482 uvc_trace(UVC_TRACE_FRAME, "Frame complete (EOF found).\n");
483 if (data[0] == len)
484 uvc_trace(UVC_TRACE_FRAME, "EOF in empty payload.\n");
485 buf->state = UVC_BUF_STATE_DONE;
486 if (stream->dev->quirks & UVC_QUIRK_STREAM_NO_FID)
487 stream->last_fid ^= UVC_STREAM_FID;
488 }
489}
490
491
492
493
494
495
496
497
498
499
500
501
502static int uvc_video_encode_header(struct uvc_streaming *stream,
503 struct uvc_buffer *buf, __u8 *data, int len)
504{
505 data[0] = 2;
506 data[1] = UVC_STREAM_EOH | UVC_STREAM_EOF
507 | (stream->last_fid & UVC_STREAM_FID);
508 return 2;
509}
510
511static int uvc_video_encode_data(struct uvc_streaming *stream,
512 struct uvc_buffer *buf, __u8 *data, int len)
513{
514 struct uvc_video_queue *queue = &stream->queue;
515 unsigned int nbytes;
516 void *mem;
517
518
519 mem = queue->mem + buf->buf.m.offset + queue->buf_used;
520 nbytes = min((unsigned int)len, buf->buf.bytesused - queue->buf_used);
521 nbytes = min(stream->bulk.max_payload_size - stream->bulk.payload_size,
522 nbytes);
523 memcpy(data, mem, nbytes);
524
525 queue->buf_used += nbytes;
526
527 return nbytes;
528}
529
530
531
532
533
534
535
536
537static void uvc_video_decode_isoc(struct urb *urb, struct uvc_streaming *stream,
538 struct uvc_buffer *buf)
539{
540 u8 *mem;
541 int ret, i;
542
543 for (i = 0; i < urb->number_of_packets; ++i) {
544 if (urb->iso_frame_desc[i].status < 0) {
545 uvc_trace(UVC_TRACE_FRAME, "USB isochronous frame "
546 "lost (%d).\n", urb->iso_frame_desc[i].status);
547 continue;
548 }
549
550
551 mem = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
552 do {
553 ret = uvc_video_decode_start(stream, buf, mem,
554 urb->iso_frame_desc[i].actual_length);
555 if (ret == -EAGAIN)
556 buf = uvc_queue_next_buffer(&stream->queue,
557 buf);
558 } while (ret == -EAGAIN);
559
560 if (ret < 0)
561 continue;
562
563
564 uvc_video_decode_data(stream, buf, mem + ret,
565 urb->iso_frame_desc[i].actual_length - ret);
566
567
568 uvc_video_decode_end(stream, buf, mem,
569 urb->iso_frame_desc[i].actual_length);
570
571 if (buf->state == UVC_BUF_STATE_DONE ||
572 buf->state == UVC_BUF_STATE_ERROR)
573 buf = uvc_queue_next_buffer(&stream->queue, buf);
574 }
575}
576
577static void uvc_video_decode_bulk(struct urb *urb, struct uvc_streaming *stream,
578 struct uvc_buffer *buf)
579{
580 u8 *mem;
581 int len, ret;
582
583 if (urb->actual_length == 0)
584 return;
585
586 mem = urb->transfer_buffer;
587 len = urb->actual_length;
588 stream->bulk.payload_size += len;
589
590
591
592
593 if (stream->bulk.header_size == 0 && !stream->bulk.skip_payload) {
594 do {
595 ret = uvc_video_decode_start(stream, buf, mem, len);
596 if (ret == -EAGAIN)
597 buf = uvc_queue_next_buffer(&stream->queue,
598 buf);
599 } while (ret == -EAGAIN);
600
601
602 if (ret < 0 || buf == NULL) {
603 stream->bulk.skip_payload = 1;
604 } else {
605 memcpy(stream->bulk.header, mem, ret);
606 stream->bulk.header_size = ret;
607
608 mem += ret;
609 len -= ret;
610 }
611 }
612
613
614
615
616
617
618
619 if (!stream->bulk.skip_payload && buf != NULL)
620 uvc_video_decode_data(stream, buf, mem, len);
621
622
623
624
625 if (urb->actual_length < urb->transfer_buffer_length ||
626 stream->bulk.payload_size >= stream->bulk.max_payload_size) {
627 if (!stream->bulk.skip_payload && buf != NULL) {
628 uvc_video_decode_end(stream, buf, stream->bulk.header,
629 stream->bulk.payload_size);
630 if (buf->state == UVC_BUF_STATE_DONE ||
631 buf->state == UVC_BUF_STATE_ERROR)
632 buf = uvc_queue_next_buffer(&stream->queue,
633 buf);
634 }
635
636 stream->bulk.header_size = 0;
637 stream->bulk.skip_payload = 0;
638 stream->bulk.payload_size = 0;
639 }
640}
641
642static void uvc_video_encode_bulk(struct urb *urb, struct uvc_streaming *stream,
643 struct uvc_buffer *buf)
644{
645 u8 *mem = urb->transfer_buffer;
646 int len = stream->urb_size, ret;
647
648 if (buf == NULL) {
649 urb->transfer_buffer_length = 0;
650 return;
651 }
652
653
654 if (stream->bulk.header_size == 0) {
655 ret = uvc_video_encode_header(stream, buf, mem, len);
656 stream->bulk.header_size = ret;
657 stream->bulk.payload_size += ret;
658 mem += ret;
659 len -= ret;
660 }
661
662
663 ret = uvc_video_encode_data(stream, buf, mem, len);
664
665 stream->bulk.payload_size += ret;
666 len -= ret;
667
668 if (buf->buf.bytesused == stream->queue.buf_used ||
669 stream->bulk.payload_size == stream->bulk.max_payload_size) {
670 if (buf->buf.bytesused == stream->queue.buf_used) {
671 stream->queue.buf_used = 0;
672 buf->state = UVC_BUF_STATE_DONE;
673 uvc_queue_next_buffer(&stream->queue, buf);
674 stream->last_fid ^= UVC_STREAM_FID;
675 }
676
677 stream->bulk.header_size = 0;
678 stream->bulk.payload_size = 0;
679 }
680
681 urb->transfer_buffer_length = stream->urb_size - len;
682}
683
684static void uvc_video_complete(struct urb *urb)
685{
686 struct uvc_streaming *stream = urb->context;
687 struct uvc_video_queue *queue = &stream->queue;
688 struct uvc_buffer *buf = NULL;
689 unsigned long flags;
690 int ret;
691
692 switch (urb->status) {
693 case 0:
694 break;
695
696 default:
697 uvc_printk(KERN_WARNING, "Non-zero status (%d) in video "
698 "completion handler.\n", urb->status);
699
700 case -ENOENT:
701 if (stream->frozen)
702 return;
703
704 case -ECONNRESET:
705 case -ESHUTDOWN:
706 uvc_queue_cancel(queue, urb->status == -ESHUTDOWN);
707 return;
708 }
709
710 spin_lock_irqsave(&queue->irqlock, flags);
711 if (!list_empty(&queue->irqqueue))
712 buf = list_first_entry(&queue->irqqueue, struct uvc_buffer,
713 queue);
714 spin_unlock_irqrestore(&queue->irqlock, flags);
715
716 stream->decode(urb, stream, buf);
717
718 if ((ret = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
719 uvc_printk(KERN_ERR, "Failed to resubmit video URB (%d).\n",
720 ret);
721 }
722}
723
724
725
726
727static void uvc_free_urb_buffers(struct uvc_streaming *stream)
728{
729 unsigned int i;
730
731 for (i = 0; i < UVC_URBS; ++i) {
732 if (stream->urb_buffer[i]) {
733 usb_buffer_free(stream->dev->udev, stream->urb_size,
734 stream->urb_buffer[i], stream->urb_dma[i]);
735 stream->urb_buffer[i] = NULL;
736 }
737 }
738
739 stream->urb_size = 0;
740}
741
742
743
744
745
746
747
748
749
750
751
752
753static int uvc_alloc_urb_buffers(struct uvc_streaming *stream,
754 unsigned int size, unsigned int psize, gfp_t gfp_flags)
755{
756 unsigned int npackets;
757 unsigned int i;
758
759
760 if (stream->urb_size)
761 return stream->urb_size / psize;
762
763
764
765
766 npackets = DIV_ROUND_UP(size, psize);
767 if (npackets > UVC_MAX_PACKETS)
768 npackets = UVC_MAX_PACKETS;
769
770
771 for (; npackets > 1; npackets /= 2) {
772 for (i = 0; i < UVC_URBS; ++i) {
773 stream->urb_buffer[i] = usb_buffer_alloc(
774 stream->dev->udev, psize * npackets,
775 gfp_flags | __GFP_NOWARN, &stream->urb_dma[i]);
776 if (!stream->urb_buffer[i]) {
777 uvc_free_urb_buffers(stream);
778 break;
779 }
780 }
781
782 if (i == UVC_URBS) {
783 stream->urb_size = psize * npackets;
784 return npackets;
785 }
786 }
787
788 return 0;
789}
790
791
792
793
794static void uvc_uninit_video(struct uvc_streaming *stream, int free_buffers)
795{
796 struct urb *urb;
797 unsigned int i;
798
799 for (i = 0; i < UVC_URBS; ++i) {
800 urb = stream->urb[i];
801 if (urb == NULL)
802 continue;
803
804 usb_kill_urb(urb);
805 usb_free_urb(urb);
806 stream->urb[i] = NULL;
807 }
808
809 if (free_buffers)
810 uvc_free_urb_buffers(stream);
811}
812
813
814
815
816
817static int uvc_init_video_isoc(struct uvc_streaming *stream,
818 struct usb_host_endpoint *ep, gfp_t gfp_flags)
819{
820 struct urb *urb;
821 unsigned int npackets, i, j;
822 u16 psize;
823 u32 size;
824
825 psize = le16_to_cpu(ep->desc.wMaxPacketSize);
826 psize = (psize & 0x07ff) * (1 + ((psize >> 11) & 3));
827 size = stream->ctrl.dwMaxVideoFrameSize;
828
829 npackets = uvc_alloc_urb_buffers(stream, size, psize, gfp_flags);
830 if (npackets == 0)
831 return -ENOMEM;
832
833 size = npackets * psize;
834
835 for (i = 0; i < UVC_URBS; ++i) {
836 urb = usb_alloc_urb(npackets, gfp_flags);
837 if (urb == NULL) {
838 uvc_uninit_video(stream, 1);
839 return -ENOMEM;
840 }
841
842 urb->dev = stream->dev->udev;
843 urb->context = stream;
844 urb->pipe = usb_rcvisocpipe(stream->dev->udev,
845 ep->desc.bEndpointAddress);
846 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
847 urb->interval = ep->desc.bInterval;
848 urb->transfer_buffer = stream->urb_buffer[i];
849 urb->transfer_dma = stream->urb_dma[i];
850 urb->complete = uvc_video_complete;
851 urb->number_of_packets = npackets;
852 urb->transfer_buffer_length = size;
853
854 for (j = 0; j < npackets; ++j) {
855 urb->iso_frame_desc[j].offset = j * psize;
856 urb->iso_frame_desc[j].length = psize;
857 }
858
859 stream->urb[i] = urb;
860 }
861
862 return 0;
863}
864
865
866
867
868
869static int uvc_init_video_bulk(struct uvc_streaming *stream,
870 struct usb_host_endpoint *ep, gfp_t gfp_flags)
871{
872 struct urb *urb;
873 unsigned int npackets, pipe, i;
874 u16 psize;
875 u32 size;
876
877 psize = le16_to_cpu(ep->desc.wMaxPacketSize) & 0x07ff;
878 size = stream->ctrl.dwMaxPayloadTransferSize;
879 stream->bulk.max_payload_size = size;
880
881 npackets = uvc_alloc_urb_buffers(stream, size, psize, gfp_flags);
882 if (npackets == 0)
883 return -ENOMEM;
884
885 size = npackets * psize;
886
887 if (usb_endpoint_dir_in(&ep->desc))
888 pipe = usb_rcvbulkpipe(stream->dev->udev,
889 ep->desc.bEndpointAddress);
890 else
891 pipe = usb_sndbulkpipe(stream->dev->udev,
892 ep->desc.bEndpointAddress);
893
894 if (stream->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
895 size = 0;
896
897 for (i = 0; i < UVC_URBS; ++i) {
898 urb = usb_alloc_urb(0, gfp_flags);
899 if (urb == NULL) {
900 uvc_uninit_video(stream, 1);
901 return -ENOMEM;
902 }
903
904 usb_fill_bulk_urb(urb, stream->dev->udev, pipe,
905 stream->urb_buffer[i], size, uvc_video_complete,
906 stream);
907 urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
908 urb->transfer_dma = stream->urb_dma[i];
909
910 stream->urb[i] = urb;
911 }
912
913 return 0;
914}
915
916
917
918
919static int uvc_init_video(struct uvc_streaming *stream, gfp_t gfp_flags)
920{
921 struct usb_interface *intf = stream->intf;
922 struct usb_host_interface *alts;
923 struct usb_host_endpoint *ep = NULL;
924 int intfnum = stream->intfnum;
925 unsigned int bandwidth, psize, i;
926 int ret;
927
928 stream->last_fid = -1;
929 stream->bulk.header_size = 0;
930 stream->bulk.skip_payload = 0;
931 stream->bulk.payload_size = 0;
932
933 if (intf->num_altsetting > 1) {
934
935 bandwidth = stream->ctrl.dwMaxPayloadTransferSize;
936
937 if (bandwidth == 0) {
938 uvc_printk(KERN_WARNING, "device %s requested null "
939 "bandwidth, defaulting to lowest.\n",
940 stream->dev->name);
941 bandwidth = 1;
942 }
943
944 for (i = 0; i < intf->num_altsetting; ++i) {
945 alts = &intf->altsetting[i];
946 ep = uvc_find_endpoint(alts,
947 stream->header.bEndpointAddress);
948 if (ep == NULL)
949 continue;
950
951
952 psize = le16_to_cpu(ep->desc.wMaxPacketSize);
953 psize = (psize & 0x07ff) * (1 + ((psize >> 11) & 3));
954 if (psize >= bandwidth)
955 break;
956 }
957
958 if (i >= intf->num_altsetting)
959 return -EIO;
960
961 ret = usb_set_interface(stream->dev->udev, intfnum, i);
962 if (ret < 0)
963 return ret;
964
965 ret = uvc_init_video_isoc(stream, ep, gfp_flags);
966 } else {
967
968 ep = uvc_find_endpoint(&intf->altsetting[0],
969 stream->header.bEndpointAddress);
970 if (ep == NULL)
971 return -EIO;
972
973 ret = uvc_init_video_bulk(stream, ep, gfp_flags);
974 }
975
976 if (ret < 0)
977 return ret;
978
979
980 for (i = 0; i < UVC_URBS; ++i) {
981 ret = usb_submit_urb(stream->urb[i], gfp_flags);
982 if (ret < 0) {
983 uvc_printk(KERN_ERR, "Failed to submit URB %u "
984 "(%d).\n", i, ret);
985 uvc_uninit_video(stream, 1);
986 return ret;
987 }
988 }
989
990 return 0;
991}
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004int uvc_video_suspend(struct uvc_streaming *stream)
1005{
1006 if (!uvc_queue_streaming(&stream->queue))
1007 return 0;
1008
1009 stream->frozen = 1;
1010 uvc_uninit_video(stream, 0);
1011 usb_set_interface(stream->dev->udev, stream->intfnum, 0);
1012 return 0;
1013}
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023int uvc_video_resume(struct uvc_streaming *stream)
1024{
1025 int ret;
1026
1027 stream->frozen = 0;
1028
1029 ret = uvc_commit_video(stream, &stream->ctrl);
1030 if (ret < 0) {
1031 uvc_queue_enable(&stream->queue, 0);
1032 return ret;
1033 }
1034
1035 if (!uvc_queue_streaming(&stream->queue))
1036 return 0;
1037
1038 ret = uvc_init_video(stream, GFP_NOIO);
1039 if (ret < 0)
1040 uvc_queue_enable(&stream->queue, 0);
1041
1042 return ret;
1043}
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059int uvc_video_init(struct uvc_streaming *stream)
1060{
1061 struct uvc_streaming_control *probe = &stream->ctrl;
1062 struct uvc_format *format = NULL;
1063 struct uvc_frame *frame = NULL;
1064 unsigned int i;
1065 int ret;
1066
1067 if (stream->nformats == 0) {
1068 uvc_printk(KERN_INFO, "No supported video formats found.\n");
1069 return -EINVAL;
1070 }
1071
1072 atomic_set(&stream->active, 0);
1073
1074
1075 uvc_queue_init(&stream->queue, stream->type);
1076
1077
1078
1079
1080
1081
1082 usb_set_interface(stream->dev->udev, stream->intfnum, 0);
1083
1084
1085
1086
1087
1088
1089 if (uvc_get_video_ctrl(stream, probe, 1, UVC_GET_DEF) == 0)
1090 uvc_set_video_ctrl(stream, probe, 1);
1091
1092
1093
1094
1095
1096
1097 ret = uvc_get_video_ctrl(stream, probe, 1, UVC_GET_CUR);
1098 if (ret < 0)
1099 return ret;
1100
1101
1102
1103
1104 for (i = stream->nformats; i > 0; --i) {
1105 format = &stream->format[i-1];
1106 if (format->index == probe->bFormatIndex)
1107 break;
1108 }
1109
1110 if (format->nframes == 0) {
1111 uvc_printk(KERN_INFO, "No frame descriptor found for the "
1112 "default format.\n");
1113 return -EINVAL;
1114 }
1115
1116
1117
1118
1119
1120
1121 for (i = format->nframes; i > 0; --i) {
1122 frame = &format->frame[i-1];
1123 if (frame->bFrameIndex == probe->bFrameIndex)
1124 break;
1125 }
1126
1127 probe->bFormatIndex = format->index;
1128 probe->bFrameIndex = frame->bFrameIndex;
1129
1130 stream->cur_format = format;
1131 stream->cur_frame = frame;
1132
1133
1134 if (stream->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1135 if (stream->dev->quirks & UVC_QUIRK_BUILTIN_ISIGHT)
1136 stream->decode = uvc_video_decode_isight;
1137 else if (stream->intf->num_altsetting > 1)
1138 stream->decode = uvc_video_decode_isoc;
1139 else
1140 stream->decode = uvc_video_decode_bulk;
1141 } else {
1142 if (stream->intf->num_altsetting == 1)
1143 stream->decode = uvc_video_encode_bulk;
1144 else {
1145 uvc_printk(KERN_INFO, "Isochronous endpoints are not "
1146 "supported for video output devices.\n");
1147 return -EINVAL;
1148 }
1149 }
1150
1151 return 0;
1152}
1153
1154
1155
1156
1157int uvc_video_enable(struct uvc_streaming *stream, int enable)
1158{
1159 int ret;
1160
1161 if (!enable) {
1162 uvc_uninit_video(stream, 1);
1163 usb_set_interface(stream->dev->udev, stream->intfnum, 0);
1164 uvc_queue_enable(&stream->queue, 0);
1165 return 0;
1166 }
1167
1168 if ((stream->cur_format->flags & UVC_FMT_FLAG_COMPRESSED) ||
1169 uvc_no_drop_param)
1170 stream->queue.flags &= ~UVC_QUEUE_DROP_INCOMPLETE;
1171 else
1172 stream->queue.flags |= UVC_QUEUE_DROP_INCOMPLETE;
1173
1174 ret = uvc_queue_enable(&stream->queue, 1);
1175 if (ret < 0)
1176 return ret;
1177
1178
1179 ret = uvc_commit_video(stream, &stream->ctrl);
1180 if (ret < 0)
1181 return ret;
1182
1183 return uvc_init_video(stream, GFP_KERNEL);
1184}
1185
1186