Lines Matching refs:video
14 #include <linux/usb/video.h>
28 uvc_video_encode_header(struct uvc_video *video, struct uvc_buffer *buf,
31 struct uvc_device *uvc = container_of(video, struct uvc_device, video);
36 data[1] = UVC_STREAM_EOH | video->fid;
38 if (video->queue.buf_used == 0 && ts.tv_sec) {
62 if (buf->bytesused - video->queue.buf_used <= len - pos)
69 uvc_video_encode_data(struct uvc_video *video, struct uvc_buffer *buf,
72 struct uvc_video_queue *queue = &video->queue;
76 /* Copy video data to the USB buffer. */
87 uvc_video_encode_bulk(struct usb_request *req, struct uvc_video *video,
92 int len = video->req_size;
96 if (video->payload_size == 0) {
97 ret = uvc_video_encode_header(video, buf, mem, len);
98 video->payload_size += ret;
103 /* Process video data. */
104 len = min((int)(video->max_payload_size - video->payload_size), len);
105 ret = uvc_video_encode_data(video, buf, mem, len);
107 video->payload_size += ret;
110 req->length = video->req_size - len;
111 req->zero = video->payload_size == video->max_payload_size;
113 if (buf->bytesused == video->queue.buf_used) {
114 video->queue.buf_used = 0;
117 video->fid ^= UVC_STREAM_FID;
120 video->payload_size = 0;
123 if (video->payload_size == video->max_payload_size ||
124 video->queue.flags & UVC_QUEUE_DROP_INCOMPLETE ||
125 buf->bytesused == video->queue.buf_used)
126 video->payload_size = 0;
130 uvc_video_encode_isoc_sg(struct usb_request *req, struct uvc_video *video,
133 unsigned int pending = buf->bytesused - video->queue.buf_used;
136 unsigned int len = video->req_size;
145 header_len = uvc_video_encode_header(video, buf, ureq->header,
146 video->req_size);
154 len + header_len : video->req_size;
177 /* Assign the video data with header. */
183 video->queue.buf_used += req->length - header_len;
185 if (buf->bytesused == video->queue.buf_used || !buf->sg ||
186 video->queue.flags & UVC_QUEUE_DROP_INCOMPLETE) {
187 video->queue.buf_used = 0;
191 video->fid ^= UVC_STREAM_FID;
197 uvc_video_encode_isoc(struct usb_request *req, struct uvc_video *video,
202 int len = video->req_size;
206 ret = uvc_video_encode_header(video, buf, mem, len);
210 /* Process video data. */
211 ret = uvc_video_encode_data(video, buf, mem, len);
214 req->length = video->req_size - len;
216 if (buf->bytesused == video->queue.buf_used ||
217 video->queue.flags & UVC_QUEUE_DROP_INCOMPLETE) {
218 video->queue.buf_used = 0;
221 video->fid ^= UVC_STREAM_FID;
230 static int uvcg_video_ep_queue(struct uvc_video *video, struct usb_request *req)
234 ret = usb_ep_queue(video->ep, req, GFP_ATOMIC);
236 uvcg_err(&video->uvc->func, "Failed to queue request (%d).\n",
240 if (video->ep->desc) {
242 if (usb_endpoint_xfer_bulk(video->ep->desc))
243 usb_ep_set_halt(video->ep);
254 struct uvc_video *video = ureq->video;
255 struct uvc_video_queue *queue = &video->queue;
256 struct uvc_device *uvc = video->uvc;
264 uvcg_dbg(&video->uvc->func, "VS request missed xfer.\n");
269 uvcg_dbg(&video->uvc->func, "VS request cancelled.\n");
274 uvcg_warn(&video->uvc->func,
281 uvcg_complete_buffer(&video->queue, ureq->last_buf);
285 spin_lock_irqsave(&video->req_lock, flags);
286 list_add_tail(&req->list, &video->req_free);
287 spin_unlock_irqrestore(&video->req_lock, flags);
290 queue_work(video->async_wq, &video->pump);
294 uvc_video_free_requests(struct uvc_video *video)
298 if (video->ureq) {
299 for (i = 0; i < video->uvc_num_requests; ++i) {
300 sg_free_table(&video->ureq[i].sgt);
302 if (video->ureq[i].req) {
303 usb_ep_free_request(video->ep, video->ureq[i].req);
304 video->ureq[i].req = NULL;
307 if (video->ureq[i].req_buffer) {
308 kfree(video->ureq[i].req_buffer);
309 video->ureq[i].req_buffer = NULL;
313 kfree(video->ureq);
314 video->ureq = NULL;
317 INIT_LIST_HEAD(&video->req_free);
318 video->req_size = 0;
323 uvc_video_alloc_requests(struct uvc_video *video)
329 BUG_ON(video->req_size);
331 req_size = video->ep->maxpacket
332 * max_t(unsigned int, video->ep->maxburst, 1)
333 * (video->ep->mult);
335 video->ureq = kcalloc(video->uvc_num_requests, sizeof(struct uvc_request), GFP_KERNEL);
336 if (video->ureq == NULL)
339 for (i = 0; i < video->uvc_num_requests; ++i) {
340 video->ureq[i].req_buffer = kmalloc(req_size, GFP_KERNEL);
341 if (video->ureq[i].req_buffer == NULL)
344 video->ureq[i].req = usb_ep_alloc_request(video->ep, GFP_KERNEL);
345 if (video->ureq[i].req == NULL)
348 video->ureq[i].req->buf = video->ureq[i].req_buffer;
349 video->ureq[i].req->length = 0;
350 video->ureq[i].req->complete = uvc_video_complete;
351 video->ureq[i].req->context = &video->ureq[i];
352 video->ureq[i].video = video;
353 video->ureq[i].last_buf = NULL;
355 list_add_tail(&video->ureq[i].req->list, &video->req_free);
357 sg_alloc_table(&video->ureq[i].sgt,
362 video->req_size = req_size;
367 uvc_video_free_requests(video);
376 * uvcg_video_pump - Pump video data into the USB requests
379 * video data from the queued buffers.
383 struct uvc_video *video = container_of(work, struct uvc_video, pump);
384 struct uvc_video_queue *queue = &video->queue;
385 /* video->max_payload_size is only set when using bulk transfer */
386 bool is_bulk = video->max_payload_size;
393 while (video->ep->enabled) {
398 spin_lock_irqsave(&video->req_lock, flags);
399 if (list_empty(&video->req_free)) {
400 spin_unlock_irqrestore(&video->req_lock, flags);
403 req = list_first_entry(&video->req_free, struct usb_request,
406 spin_unlock_irqrestore(&video->req_lock, flags);
409 * Retrieve the first available video buffer and fill the
410 * request, protected by the video queue irqlock.
416 video->encode(req, video, buf);
420 * No video buffer available; the queue is still connected and
428 * Either the queue has been disconnected or no video buffer
445 * - When this is request is the last request for the video
446 * buffer, as we want to start sending the next video buffer
451 * indicated by video->uvc_num_requests), as a trade-off
454 if (list_empty(&video->req_free) || buf_done ||
455 !(video->req_int_count %
456 DIV_ROUND_UP(video->uvc_num_requests, 4))) {
457 video->req_int_count = 0;
464 ret = uvcg_video_ep_queue(video, req);
474 video->req_int_count++;
480 spin_lock_irqsave(&video->req_lock, flags);
481 list_add_tail(&req->list, &video->req_free);
482 spin_unlock_irqrestore(&video->req_lock, flags);
487 * Enable or disable the video stream.
489 int uvcg_video_enable(struct uvc_video *video, int enable)
494 if (video->ep == NULL) {
495 uvcg_info(&video->uvc->func,
501 cancel_work_sync(&video->pump);
502 uvcg_queue_cancel(&video->queue, 0);
504 for (i = 0; i < video->uvc_num_requests; ++i)
505 if (video->ureq && video->ureq[i].req)
506 usb_ep_dequeue(video->ep, video->ureq[i].req);
508 uvc_video_free_requests(video);
509 uvcg_queue_enable(&video->queue, 0);
513 if ((ret = uvcg_queue_enable(&video->queue, 1)) < 0)
516 if ((ret = uvc_video_alloc_requests(video)) < 0)
519 if (video->max_payload_size) {
520 video->encode = uvc_video_encode_bulk;
521 video->payload_size = 0;
523 video->encode = video->queue.use_sg ?
526 video->req_int_count = 0;
528 queue_work(video->async_wq, &video->pump);
534 * Initialize the UVC video stream.
536 int uvcg_video_init(struct uvc_video *video, struct uvc_device *uvc)
538 INIT_LIST_HEAD(&video->req_free);
539 spin_lock_init(&video->req_lock);
540 INIT_WORK(&video->pump, uvcg_video_pump);
542 /* Allocate a work queue for asynchronous video pump handler. */
543 video->async_wq = alloc_workqueue("uvcgadget", WQ_UNBOUND | WQ_HIGHPRI, 0);
544 if (!video->async_wq)
547 video->uvc = uvc;
548 video->fcc = V4L2_PIX_FMT_YUYV;
549 video->bpp = 16;
550 video->width = 320;
551 video->height = 240;
552 video->imagesize = 320 * 240 * 2;
554 /* Initialize the video buffers queue. */
555 uvcg_queue_init(&video->queue, uvc->v4l2_dev.dev->parent,
556 V4L2_BUF_TYPE_VIDEO_OUTPUT, &video->mutex);