4 files changed, 56 insertions, 55 deletions

diff --git a/drivers/usb/gadget/function/f_uvc.c b/drivers/usb/gadget/function/f_uvc.c
index 187c3a04cf70..ae5bcb49dddb 100644
--- a/drivers/usb/gadget/function/f_uvc.c
+++ b/drivers/usb/gadget/function/f_uvc.c
@@ -693,7 +693,7 @@ uvc_function_bind(struct usb_configuration *c, struct usb_function *f)
         }
 
         /* Initialise video. */
-        ret = uvc_video_init(&uvc->video);
+        ret = uvcg_video_init(&uvc->video);
         if (ret < 0)
                 goto error;
 
diff --git a/drivers/usb/gadget/function/uvc_queue.c b/drivers/usb/gadget/function/uvc_queue.c
index 8590f9ff0849..1e1bc73dba1f 100644
--- a/drivers/usb/gadget/function/uvc_queue.c
+++ b/drivers/usb/gadget/function/uvc_queue.c
@@ -28,7 +28,7 @@
 /* ------------------------------------------------------------------------
  * 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.
  *
  * 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,
 };
 
-static int uvc_queue_init(struct uvc_video_queue *queue,
-                          enum v4l2_buf_type type)
+static int uvcg_queue_init(struct uvc_video_queue *queue,
+                           enum v4l2_buf_type type)
 {
         int ret;
 
@@ -154,7 +154,7 @@ static int uvc_queue_init(struct uvc_video_queue *queue,
 /*
  * 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);
         vb2_queue_release(&queue->queue);
@@ -164,8 +164,8 @@ static void uvc_free_buffers(struct uvc_video_queue *queue)
 /*
  * Allocate the video buffers.
  */
-static int uvc_alloc_buffers(struct uvc_video_queue *queue,
-                             struct v4l2_requestbuffers *rb)
+static int uvcg_alloc_buffers(struct uvc_video_queue *queue,
+                              struct v4l2_requestbuffers *rb)
 {
         int ret;
 
@@ -176,8 +176,8 @@ static int uvc_alloc_buffers(struct uvc_video_queue *queue,
         return ret ? ret : rb->count;
 }
 
-static int uvc_query_buffer(struct uvc_video_queue *queue,
-                            struct v4l2_buffer *buf)
+static int uvcg_query_buffer(struct uvc_video_queue *queue,
+                             struct v4l2_buffer *buf)
 {
         int ret;
 
@@ -188,8 +188,8 @@ static int uvc_query_buffer(struct uvc_video_queue *queue,
         return ret;
 }
 
-static int uvc_queue_buffer(struct uvc_video_queue *queue,
-                            struct v4l2_buffer *buf)
+static int uvcg_queue_buffer(struct uvc_video_queue *queue,
+                             struct v4l2_buffer *buf)
 {
         unsigned long flags;
         int ret;
@@ -213,8 +213,8 @@ done:
  * Dequeue a video buffer. If nonblocking is false, block until a buffer is
  * available.
  */
-static int uvc_dequeue_buffer(struct uvc_video_queue *queue,
-                              struct v4l2_buffer *buf, int nonblocking)
+static int uvcg_dequeue_buffer(struct uvc_video_queue *queue,
+                               struct v4l2_buffer *buf, int nonblocking)
 {
         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
  * the device poll handler.
  */
-static unsigned int uvc_queue_poll(struct uvc_video_queue *queue,
-                                   struct file *file, poll_table *wait)
+static unsigned int uvcg_queue_poll(struct uvc_video_queue *queue,
+                                    struct file *file, poll_table *wait)
 {
         unsigned int ret;
 
@@ -243,8 +243,8 @@ static unsigned int uvc_queue_poll(struct uvc_video_queue *queue,
         return ret;
 }
 
-static int uvc_queue_mmap(struct uvc_video_queue *queue,
-                          struct vm_area_struct *vma)
+static int uvcg_queue_mmap(struct uvc_video_queue *queue,
+                           struct vm_area_struct *vma)
 {
         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.
  */
-static unsigned long uvc_queue_get_unmapped_area(struct uvc_video_queue *queue,
-                unsigned long pgoff)
+static unsigned long uvcg_queue_get_unmapped_area(
+                                struct uvc_video_queue *queue,
+                                unsigned long pgoff)
 {
         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
  * 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;
         unsigned long flags;
@@ -324,9 +325,9 @@ static void uvc_queue_cancel(struct uvc_video_queue *queue, int disconnect)
  * the main queue.
  *
  * 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;
         int ret = 0;
@@ -363,8 +364,8 @@ done:
 }
 
 /* called with &queue_irqlock held.. */
-static struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue,
-                                                struct uvc_buffer *buf)
+static struct uvc_buffer *uvcg_queue_next_buffer(struct uvc_video_queue *queue,
+                                                 struct uvc_buffer *buf)
 {
         struct uvc_buffer *nextbuf;
 
@@ -392,7 +393,7 @@ static struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue,
         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;
 
diff --git a/drivers/usb/gadget/function/uvc_v4l2.c b/drivers/usb/gadget/function/uvc_v4l2.c
index 14c3a3734b95..c85730eb36dd 100644
--- a/drivers/usb/gadget/function/uvc_v4l2.c
+++ b/drivers/usb/gadget/function/uvc_v4l2.c
@@ -149,7 +149,7 @@ uvc_v4l2_reqbufs(struct file *file, void *fh, struct v4l2_requestbuffers *b)
         if (b->type != video->queue.queue.type)
                 return -EINVAL;
 
-        return uvc_alloc_buffers(&video->queue, b);
+        return uvcg_alloc_buffers(&video->queue, b);
 }
 
 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_video *video = &uvc->video;
 
-        return uvc_query_buffer(&video->queue, b);
+        return uvcg_query_buffer(&video->queue, b);
 }
 
 static int
@@ -170,11 +170,11 @@ uvc_v4l2_qbuf(struct file *file, void *fh, struct v4l2_buffer *b)
         struct uvc_video *video = &uvc->video;
         int ret;
 
-        ret = uvc_queue_buffer(&video->queue, b);
+        ret = uvcg_queue_buffer(&video->queue, b);
         if (ret < 0)
                 return ret;
 
-        return uvc_video_pump(video);
+        return uvcg_video_pump(video);
 }
 
 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_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
@@ -199,7 +199,7 @@ uvc_v4l2_streamon(struct file *file, void *fh, enum v4l2_buf_type type)
                 return -EINVAL;
 
         /* Enable UVC video. */
-        ret = uvc_video_enable(video, 1);
+        ret = uvcg_video_enable(video, 1);
         if (ret < 0)
                 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)
                 return -EINVAL;
 
-        return uvc_video_enable(video, 0);
+        return uvcg_video_enable(video, 0);
 }
 
 static int
@@ -309,8 +309,8 @@ uvc_v4l2_release(struct file *file)
 
         uvc_function_disconnect(uvc);
 
-        uvc_video_enable(video, 0);
-        uvc_free_buffers(&video->queue);
+        uvcg_video_enable(video, 0);
+        uvcg_free_buffers(&video->queue);
 
         file->private_data = NULL;
         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 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
@@ -335,7 +335,7 @@ uvc_v4l2_poll(struct file *file, poll_table *wait)
         struct video_device *vdev = video_devdata(file);
         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
@@ -346,7 +346,7 @@ static unsigned long uvc_v4l2_get_unmapped_area(struct file *file,
         struct video_device *vdev = video_devdata(file);
         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
 
@@ -358,7 +358,7 @@ static struct v4l2_file_operations uvc_v4l2_fops = {
         .mmap           = uvc_v4l2_mmap,
         .poll           = uvc_v4l2_poll,
 #ifndef CONFIG_MMU
-        .get_unmapped_area = uvc_v4l2_get_unmapped_area,
+        .get_unmapped_area = uvcg_v4l2_get_unmapped_area,
 #endif
 };
 
diff --git a/drivers/usb/gadget/function/uvc_video.c b/drivers/usb/gadget/function/uvc_video.c
index 1ff478a961a6..be6749ec6a9d 100644
--- a/drivers/usb/gadget/function/uvc_video.c
+++ b/drivers/usb/gadget/function/uvc_video.c
@@ -85,7 +85,7 @@ uvc_video_encode_bulk(struct usb_request *req, struct uvc_video *video,
         if (buf->bytesused == video->queue.buf_used) {
                 video->queue.buf_used = 0;
                 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->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) {
                 video->queue.buf_used = 0;
                 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;
         }
 }
@@ -172,18 +172,18 @@ uvc_video_complete(struct usb_ep *ep, struct usb_request *req)
 
         case -ESHUTDOWN:        /* disconnect from host. */
                 printk(KERN_DEBUG "VS request cancelled.\n");
-                uvc_queue_cancel(queue, 1);
+                uvcg_queue_cancel(queue, 1);
                 goto requeue;
 
         default:
                 printk(KERN_INFO "VS request completed with status %d.\n",
                         req->status);
-                uvc_queue_cancel(queue, 0);
+                uvcg_queue_cancel(queue, 0);
                 goto requeue;
         }
 
         spin_lock_irqsave(&video->queue.irqlock, flags);
-        buf = uvc_queue_head(&video->queue);
+        buf = uvcg_queue_head(&video->queue);
         if (buf == NULL) {
                 spin_unlock_irqrestore(&video->queue.irqlock, flags);
                 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);
                 usb_ep_set_halt(ep);
                 spin_unlock_irqrestore(&video->queue.irqlock, flags);
-                uvc_queue_cancel(queue, 0);
+                uvcg_queue_cancel(queue, 0);
                 goto requeue;
         }
         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
  * video data from the queued buffers.
  */
 static int
-uvc_video_pump(struct uvc_video *video)
+uvcg_video_pump(struct uvc_video *video)
 {
         struct uvc_video_queue *queue = &video->queue;
         struct usb_request *req;
@@ -288,7 +288,7 @@ uvc_video_pump(struct uvc_video *video)
         unsigned long flags;
         int ret;
 
-        /* FIXME TODO Race between uvc_video_pump and requests completion
+        /* FIXME TODO Race between uvcg_video_pump and requests completion
          * handler ???
          */
 
@@ -310,7 +310,7 @@ uvc_video_pump(struct uvc_video *video)
                  * request, protected by the video queue irqlock.
                  */
                 spin_lock_irqsave(&video->queue.irqlock, flags);
-                buf = uvc_queue_head(&video->queue);
+                buf = uvcg_queue_head(&video->queue);
                 if (buf == NULL) {
                         spin_unlock_irqrestore(&video->queue.irqlock, flags);
                         break;
@@ -324,7 +324,7 @@ uvc_video_pump(struct uvc_video *video)
                         printk(KERN_INFO "Failed to queue request (%d)\n", ret);
                         usb_ep_set_halt(video->ep);
                         spin_unlock_irqrestore(&video->queue.irqlock, flags);
-                        uvc_queue_cancel(queue, 0);
+                        uvcg_queue_cancel(queue, 0);
                         break;
                 }
                 spin_unlock_irqrestore(&video->queue.irqlock, flags);
@@ -340,7 +340,7 @@ uvc_video_pump(struct uvc_video *video)
  * Enable or disable the video stream.
  */
 static int
-uvc_video_enable(struct uvc_video *video, int enable)
+uvcg_video_enable(struct uvc_video *video, int enable)
 {
         unsigned int i;
         int ret;
@@ -356,11 +356,11 @@ uvc_video_enable(struct uvc_video *video, int enable)
                         usb_ep_dequeue(video->ep, video->req[i]);
 
                 uvc_video_free_requests(video);
-                uvc_queue_enable(&video->queue, 0);
+                uvcg_queue_enable(&video->queue, 0);
                 return 0;
         }
 
-        if ((ret = uvc_queue_enable(&video->queue, 1)) < 0)
+        if ((ret = uvcg_queue_enable(&video->queue, 1)) < 0)
                 return ret;
 
         if ((ret = uvc_video_alloc_requests(video)) < 0)
@@ -372,14 +372,14 @@ uvc_video_enable(struct uvc_video *video, int enable)
         } else
                 video->encode = uvc_video_encode_isoc;
 
-        return uvc_video_pump(video);
+        return uvcg_video_pump(video);
 }
 
 /*
  * Initialize the UVC video stream.
  */
 static int
-uvc_video_init(struct uvc_video *video)
+uvcg_video_init(struct uvc_video *video)
 {
         INIT_LIST_HEAD(&video->req_free);
         spin_lock_init(&video->req_lock);
@@ -391,7 +391,7 @@ uvc_video_init(struct uvc_video *video)
         video->imagesize = 320 * 240 * 2;
 
         /* 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;
 }