redonkable/alistair23-linux
redonkable/alistair23-linux
1
0
Fork 0
Code Releases Activity

usb: gadget: uvc: rename functions to avoid conflicts with host uvc

Browse source 
Prepare for separate compilation of uvc function's components.
Some symbols will have to be exported, so rename to avoid
conflicts with functions of the same name in host uvc.

Signed-off-by: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
Tested-by: Michael Grzeschik <m.grzeschik@pengutronix.de>
[Rename uvc_video_pump and uvc_queue_head as well]
[Rename forgotten uvc_queue_cancel instance in a comment]
Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Acked-by: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
Signed-off-by: Felipe Balbi <balbi@ti.com>
This commit is contained in:
Andrzej Pietrasiewicz 2014-09-09 02:02:08 +03:00 committed by Felipe Balbi
parent 70aacc5777
commit 7ea95b1108
4 changed files with 56 additions and 55 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
drivers/usb/gadget/function/f_uvc.c
View file

@ -693,7 +693,7 @@ uvc_function_bind(struct usb_configuration *c, struct usb_function *f)
} }
/* Initialise video. */ /* Initialise video. */
ret = uvc_video_init(&uvc->video); ret = uvcg_video_init(&uvc->video);
if (ret < 0) if (ret < 0)
goto error; goto error;

49
drivers/usb/gadget/function/uvc_queue.c
View file

@ -28,7 +28,7 @@
/* ------------------------------------------------------------------------ /* ------------------------------------------------------------------------
* Video buffers queue management. * Video buffers queue management.
* *
* Video queues is initialized by uvc_queue_init(). The function performs * Video queues is initialized by uvcg_queue_init(). The function performs
* basic initialization of the uvc_video_queue struct and never fails. * basic initialization of the uvc_video_queue struct and never fails.
* *
* Video buffers are managed by videobuf2. The driver uses a mutex to protect * Video buffers are managed by videobuf2. The driver uses a mutex to protect
@ -126,8 +126,8 @@ static struct vb2_ops uvc_queue_qops = {
.wait_finish = uvc_wait_finish, .wait_finish = uvc_wait_finish,
}; };
static int uvc_queue_init(struct uvc_video_queue *queue, static int uvcg_queue_init(struct uvc_video_queue *queue,
enum v4l2_buf_type type) enum v4l2_buf_type type)
{ {
int ret; int ret;
@ -154,7 +154,7 @@ static int uvc_queue_init(struct uvc_video_queue *queue,
/* /*
* Free the video buffers. * Free the video buffers.
*/ */
static void uvc_free_buffers(struct uvc_video_queue *queue) static void uvcg_free_buffers(struct uvc_video_queue *queue)
{ {
mutex_lock(&queue->mutex); mutex_lock(&queue->mutex);
vb2_queue_release(&queue->queue); vb2_queue_release(&queue->queue);
@ -164,8 +164,8 @@ static void uvc_free_buffers(struct uvc_video_queue *queue)
/* /*
* Allocate the video buffers. * Allocate the video buffers.
*/ */
static int uvc_alloc_buffers(struct uvc_video_queue *queue, static int uvcg_alloc_buffers(struct uvc_video_queue *queue,
struct v4l2_requestbuffers *rb) struct v4l2_requestbuffers *rb)
{ {
int ret; int ret;
@ -176,8 +176,8 @@ static int uvc_alloc_buffers(struct uvc_video_queue *queue,
return ret ? ret : rb->count; return ret ? ret : rb->count;
} }
static int uvc_query_buffer(struct uvc_video_queue *queue, static int uvcg_query_buffer(struct uvc_video_queue *queue,
struct v4l2_buffer *buf) struct v4l2_buffer *buf)
{ {
int ret; int ret;
@ -188,8 +188,8 @@ static int uvc_query_buffer(struct uvc_video_queue *queue,
return ret; return ret;
} }
static int uvc_queue_buffer(struct uvc_video_queue *queue, static int uvcg_queue_buffer(struct uvc_video_queue *queue,
struct v4l2_buffer *buf) struct v4l2_buffer *buf)
{ {
unsigned long flags; unsigned long flags;
int ret; int ret;
@ -213,8 +213,8 @@ done:
* Dequeue a video buffer. If nonblocking is false, block until a buffer is * Dequeue a video buffer. If nonblocking is false, block until a buffer is
* available. * available.
*/ */
static int uvc_dequeue_buffer(struct uvc_video_queue *queue, static int uvcg_dequeue_buffer(struct uvc_video_queue *queue,
struct v4l2_buffer *buf, int nonblocking) struct v4l2_buffer *buf, int nonblocking)
{ {
int ret; int ret;
@ -231,8 +231,8 @@ static int uvc_dequeue_buffer(struct uvc_video_queue *queue,
* This function implements video queue polling and is intended to be used by * This function implements video queue polling and is intended to be used by
* the device poll handler. * the device poll handler.
*/ */
static unsigned int uvc_queue_poll(struct uvc_video_queue *queue, static unsigned int uvcg_queue_poll(struct uvc_video_queue *queue,
struct file *file, poll_table *wait) struct file *file, poll_table *wait)
{ {
unsigned int ret; unsigned int ret;
@ -243,8 +243,8 @@ static unsigned int uvc_queue_poll(struct uvc_video_queue *queue,
return ret; return ret;
} }
static int uvc_queue_mmap(struct uvc_video_queue *queue, static int uvcg_queue_mmap(struct uvc_video_queue *queue,
struct vm_area_struct *vma) struct vm_area_struct *vma)
{ {
int ret; int ret;
@ -261,8 +261,9 @@ static int uvc_queue_mmap(struct uvc_video_queue *queue,
* *
* NO-MMU arch need this function to make mmap() work correctly. * NO-MMU arch need this function to make mmap() work correctly.
*/ */
static unsigned long uvc_queue_get_unmapped_area(struct uvc_video_queue *queue, static unsigned long uvcg_queue_get_unmapped_area(
unsigned long pgoff) struct uvc_video_queue *queue,
unsigned long pgoff)
{ {
unsigned long ret; unsigned long ret;
@ -285,7 +286,7 @@ static unsigned long uvc_queue_get_unmapped_area(struct uvc_video_queue *queue,
* This function acquires the irq spinlock and can be called from interrupt * This function acquires the irq spinlock and can be called from interrupt
* context. * context.
*/ */
static void uvc_queue_cancel(struct uvc_video_queue *queue, int disconnect) static void uvcg_queue_cancel(struct uvc_video_queue *queue, int disconnect)
{ {
struct uvc_buffer *buf; struct uvc_buffer *buf;
unsigned long flags; unsigned long flags;
@ -324,9 +325,9 @@ static void uvc_queue_cancel(struct uvc_video_queue *queue, int disconnect)
* the main queue. * the main queue.
* *
* This function can't be called from interrupt context. Use * This function can't be called from interrupt context. Use
* uvc_queue_cancel() instead. * uvcg_queue_cancel() instead.
*/ */
static int uvc_queue_enable(struct uvc_video_queue *queue, int enable) static int uvcg_queue_enable(struct uvc_video_queue *queue, int enable)
{ {
unsigned long flags; unsigned long flags;
int ret = 0; int ret = 0;
@ -363,8 +364,8 @@ done:
} }
/* called with &queue_irqlock held.. */ /* called with &queue_irqlock held.. */
static struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue, static struct uvc_buffer *uvcg_queue_next_buffer(struct uvc_video_queue *queue,
struct uvc_buffer *buf) struct uvc_buffer *buf)
{ {
struct uvc_buffer *nextbuf; struct uvc_buffer *nextbuf;
@ -392,7 +393,7 @@ static struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue,
return nextbuf; return nextbuf;
} }
static struct uvc_buffer *uvc_queue_head(struct uvc_video_queue *queue) static struct uvc_buffer *uvcg_queue_head(struct uvc_video_queue *queue)
{ {
struct uvc_buffer *buf = NULL; struct uvc_buffer *buf = NULL;

26
drivers/usb/gadget/function/uvc_v4l2.c
View file

@ -149,7 +149,7 @@ uvc_v4l2_reqbufs(struct file *file, void *fh, struct v4l2_requestbuffers *b)
if (b->type != video->queue.queue.type) if (b->type != video->queue.queue.type)
return -EINVAL; return -EINVAL;
return uvc_alloc_buffers(&video->queue, b); return uvcg_alloc_buffers(&video->queue, b);
} }
static int static int
@ -159,7 +159,7 @@ uvc_v4l2_querybuf(struct file *file, void *fh, struct v4l2_buffer *b)
struct uvc_device *uvc = video_get_drvdata(vdev); struct uvc_device *uvc = video_get_drvdata(vdev);
struct uvc_video *video = &uvc->video; struct uvc_video *video = &uvc->video;
return uvc_query_buffer(&video->queue, b); return uvcg_query_buffer(&video->queue, b);
} }
static int static int
@ -170,11 +170,11 @@ uvc_v4l2_qbuf(struct file *file, void *fh, struct v4l2_buffer *b)
struct uvc_video *video = &uvc->video; struct uvc_video *video = &uvc->video;
int ret; int ret;
ret = uvc_queue_buffer(&video->queue, b); ret = uvcg_queue_buffer(&video->queue, b);
if (ret < 0) if (ret < 0)
return ret; return ret;
return uvc_video_pump(video); return uvcg_video_pump(video);
} }
static int static int
@ -184,7 +184,7 @@ uvc_v4l2_dqbuf(struct file *file, void *fh, struct v4l2_buffer *b)
struct uvc_device *uvc = video_get_drvdata(vdev); struct uvc_device *uvc = video_get_drvdata(vdev);
struct uvc_video *video = &uvc->video; struct uvc_video *video = &uvc->video;
return uvc_dequeue_buffer(&video->queue, b, file->f_flags & O_NONBLOCK); return uvcg_dequeue_buffer(&video->queue, b, file->f_flags & O_NONBLOCK);
} }
static int static int
@ -199,7 +199,7 @@ uvc_v4l2_streamon(struct file *file, void *fh, enum v4l2_buf_type type)
return -EINVAL; return -EINVAL;
/* Enable UVC video. */ /* Enable UVC video. */
ret = uvc_video_enable(video, 1); ret = uvcg_video_enable(video, 1);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -223,7 +223,7 @@ uvc_v4l2_streamoff(struct file *file, void *fh, enum v4l2_buf_type type)
if (type != video->queue.queue.type) if (type != video->queue.queue.type)
return -EINVAL; return -EINVAL;
return uvc_video_enable(video, 0); return uvcg_video_enable(video, 0);
} }
static int static int
@ -309,8 +309,8 @@ uvc_v4l2_release(struct file *file)
uvc_function_disconnect(uvc); uvc_function_disconnect(uvc);
uvc_video_enable(video, 0); uvcg_video_enable(video, 0);
uvc_free_buffers(&video->queue); uvcg_free_buffers(&video->queue);
file->private_data = NULL; file->private_data = NULL;
v4l2_fh_del(&handle->vfh); v4l2_fh_del(&handle->vfh);
@ -326,7 +326,7 @@ uvc_v4l2_mmap(struct file *file, struct vm_area_struct *vma)
struct video_device *vdev = video_devdata(file); struct video_device *vdev = video_devdata(file);
struct uvc_device *uvc = video_get_drvdata(vdev); struct uvc_device *uvc = video_get_drvdata(vdev);
return uvc_queue_mmap(&uvc->video.queue, vma); return uvcg_queue_mmap(&uvc->video.queue, vma);
} }
static unsigned int static unsigned int
@ -335,7 +335,7 @@ uvc_v4l2_poll(struct file *file, poll_table *wait)
struct video_device *vdev = video_devdata(file); struct video_device *vdev = video_devdata(file);
struct uvc_device *uvc = video_get_drvdata(vdev); struct uvc_device *uvc = video_get_drvdata(vdev);
return uvc_queue_poll(&uvc->video.queue, file, wait); return uvcg_queue_poll(&uvc->video.queue, file, wait);
} }
#ifndef CONFIG_MMU #ifndef CONFIG_MMU
@ -346,7 +346,7 @@ static unsigned long uvc_v4l2_get_unmapped_area(struct file *file,
struct video_device *vdev = video_devdata(file); struct video_device *vdev = video_devdata(file);
struct uvc_device *uvc = video_get_drvdata(vdev); struct uvc_device *uvc = video_get_drvdata(vdev);
return uvc_queue_get_unmapped_area(&uvc->video.queue, pgoff); return uvcg_queue_get_unmapped_area(&uvc->video.queue, pgoff);
} }
#endif #endif
@ -358,7 +358,7 @@ static struct v4l2_file_operations uvc_v4l2_fops = {
.mmap = uvc_v4l2_mmap, .mmap = uvc_v4l2_mmap,
.poll = uvc_v4l2_poll, .poll = uvc_v4l2_poll,
#ifndef CONFIG_MMU #ifndef CONFIG_MMU
.get_unmapped_area = uvc_v4l2_get_unmapped_area, .get_unmapped_area = uvcg_v4l2_get_unmapped_area,
#endif #endif
}; };

34
drivers/usb/gadget/function/uvc_video.c
View file

@ -85,7 +85,7 @@ uvc_video_encode_bulk(struct usb_request *req, struct uvc_video *video,
if (buf->bytesused == video->queue.buf_used) { if (buf->bytesused == video->queue.buf_used) {
video->queue.buf_used = 0; video->queue.buf_used = 0;
buf->state = UVC_BUF_STATE_DONE; buf->state = UVC_BUF_STATE_DONE;
uvc_queue_next_buffer(&video->queue, buf); uvcg_queue_next_buffer(&video->queue, buf);
video->fid ^= UVC_STREAM_FID; video->fid ^= UVC_STREAM_FID;
video->payload_size = 0; video->payload_size = 0;
@ -118,7 +118,7 @@ uvc_video_encode_isoc(struct usb_request *req, struct uvc_video *video,
if (buf->bytesused == video->queue.buf_used) { if (buf->bytesused == video->queue.buf_used) {
video->queue.buf_used = 0; video->queue.buf_used = 0;
buf->state = UVC_BUF_STATE_DONE; buf->state = UVC_BUF_STATE_DONE;
uvc_queue_next_buffer(&video->queue, buf); uvcg_queue_next_buffer(&video->queue, buf);
video->fid ^= UVC_STREAM_FID; video->fid ^= UVC_STREAM_FID;
} }
} }
@ -172,18 +172,18 @@ uvc_video_complete(struct usb_ep *ep, struct usb_request *req)
case -ESHUTDOWN: /* disconnect from host. */ case -ESHUTDOWN: /* disconnect from host. */
printk(KERN_DEBUG "VS request cancelled.\n"); printk(KERN_DEBUG "VS request cancelled.\n");
uvc_queue_cancel(queue, 1); uvcg_queue_cancel(queue, 1);
goto requeue; goto requeue;
default: default:
printk(KERN_INFO "VS request completed with status %d.\n", printk(KERN_INFO "VS request completed with status %d.\n",
req->status); req->status);
uvc_queue_cancel(queue, 0); uvcg_queue_cancel(queue, 0);
goto requeue; goto requeue;
} }
spin_lock_irqsave(&video->queue.irqlock, flags); spin_lock_irqsave(&video->queue.irqlock, flags);
buf = uvc_queue_head(&video->queue); buf = uvcg_queue_head(&video->queue);
if (buf == NULL) { if (buf == NULL) {
spin_unlock_irqrestore(&video->queue.irqlock, flags); spin_unlock_irqrestore(&video->queue.irqlock, flags);
goto requeue; goto requeue;
@ -195,7 +195,7 @@ uvc_video_complete(struct usb_ep *ep, struct usb_request *req)
printk(KERN_INFO "Failed to queue request (%d).\n", ret); printk(KERN_INFO "Failed to queue request (%d).\n", ret);
usb_ep_set_halt(ep); usb_ep_set_halt(ep);
spin_unlock_irqrestore(&video->queue.irqlock, flags); spin_unlock_irqrestore(&video->queue.irqlock, flags);
uvc_queue_cancel(queue, 0); uvcg_queue_cancel(queue, 0);
goto requeue; goto requeue;
} }
spin_unlock_irqrestore(&video->queue.irqlock, flags); spin_unlock_irqrestore(&video->queue.irqlock, flags);
@ -274,13 +274,13 @@ error:
*/ */
/* /*
* uvc_video_pump - Pump video data into the USB requests * uvcg_video_pump - Pump video data into the USB requests
* *
* This function fills the available USB requests (listed in req_free) with * This function fills the available USB requests (listed in req_free) with
* video data from the queued buffers. * video data from the queued buffers.
*/ */
static int static int
uvc_video_pump(struct uvc_video *video) uvcg_video_pump(struct uvc_video *video)
{ {
struct uvc_video_queue *queue = &video->queue; struct uvc_video_queue *queue = &video->queue;
struct usb_request *req; struct usb_request *req;
@ -288,7 +288,7 @@ uvc_video_pump(struct uvc_video *video)
unsigned long flags; unsigned long flags;
int ret; int ret;
/* FIXME TODO Race between uvc_video_pump and requests completion /* FIXME TODO Race between uvcg_video_pump and requests completion
* handler ??? * handler ???
*/ */
@ -310,7 +310,7 @@ uvc_video_pump(struct uvc_video *video)
* request, protected by the video queue irqlock. * request, protected by the video queue irqlock.
*/ */
spin_lock_irqsave(&video->queue.irqlock, flags); spin_lock_irqsave(&video->queue.irqlock, flags);
buf = uvc_queue_head(&video->queue); buf = uvcg_queue_head(&video->queue);
if (buf == NULL) { if (buf == NULL) {
spin_unlock_irqrestore(&video->queue.irqlock, flags); spin_unlock_irqrestore(&video->queue.irqlock, flags);
break; break;
@ -324,7 +324,7 @@ uvc_video_pump(struct uvc_video *video)
printk(KERN_INFO "Failed to queue request (%d)\n", ret); printk(KERN_INFO "Failed to queue request (%d)\n", ret);
usb_ep_set_halt(video->ep); usb_ep_set_halt(video->ep);
spin_unlock_irqrestore(&video->queue.irqlock, flags); spin_unlock_irqrestore(&video->queue.irqlock, flags);
uvc_queue_cancel(queue, 0); uvcg_queue_cancel(queue, 0);
break; break;
} }
spin_unlock_irqrestore(&video->queue.irqlock, flags); spin_unlock_irqrestore(&video->queue.irqlock, flags);
@ -340,7 +340,7 @@ uvc_video_pump(struct uvc_video *video)
* Enable or disable the video stream. * Enable or disable the video stream.
*/ */
static int static int
uvc_video_enable(struct uvc_video *video, int enable) uvcg_video_enable(struct uvc_video *video, int enable)
{ {
unsigned int i; unsigned int i;
int ret; int ret;
@ -356,11 +356,11 @@ uvc_video_enable(struct uvc_video *video, int enable)
usb_ep_dequeue(video->ep, video->req[i]); usb_ep_dequeue(video->ep, video->req[i]);
uvc_video_free_requests(video); uvc_video_free_requests(video);
uvc_queue_enable(&video->queue, 0); uvcg_queue_enable(&video->queue, 0);
return 0; return 0;
} }
if ((ret = uvc_queue_enable(&video->queue, 1)) < 0) if ((ret = uvcg_queue_enable(&video->queue, 1)) < 0)
return ret; return ret;
if ((ret = uvc_video_alloc_requests(video)) < 0) if ((ret = uvc_video_alloc_requests(video)) < 0)
@ -372,14 +372,14 @@ uvc_video_enable(struct uvc_video *video, int enable)
} else } else
video->encode = uvc_video_encode_isoc; video->encode = uvc_video_encode_isoc;
return uvc_video_pump(video); return uvcg_video_pump(video);
} }
/* /*
* Initialize the UVC video stream. * Initialize the UVC video stream.
*/ */
static int static int
uvc_video_init(struct uvc_video *video) uvcg_video_init(struct uvc_video *video)
{ {
INIT_LIST_HEAD(&video->req_free); INIT_LIST_HEAD(&video->req_free);
spin_lock_init(&video->req_lock); spin_lock_init(&video->req_lock);
@ -391,7 +391,7 @@ uvc_video_init(struct uvc_video *video)
video->imagesize = 320 * 240 * 2; video->imagesize = 320 * 240 * 2;
/* Initialize the video buffers queue. */ /* Initialize the video buffers queue. */
uvc_queue_init(&video->queue, V4L2_BUF_TYPE_VIDEO_OUTPUT); uvcg_queue_init(&video->queue, V4L2_BUF_TYPE_VIDEO_OUTPUT);
return 0; return 0;
} }