1 files changed, 90 insertions, 51 deletions

diff --git a/drivers/media/usb/uvc/uvc_v4l2.c b/drivers/media/usb/uvc/uvc_v4l2.c
index a13ad4e178be..bd32914259ae 100644
--- a/drivers/media/usb/uvc/uvc_v4l2.c
+++ b/drivers/media/usb/uvc/uvc_v4l2.c
@@ -40,13 +40,13 @@ static int uvc_ioctl_ctrl_map(struct uvc_video_chain *chain,
         unsigned int size;
         int ret;
 
-        map = kzalloc(sizeof *map, GFP_KERNEL);
+        map = kzalloc(sizeof(*map), GFP_KERNEL);
         if (map == NULL)
                 return -ENOMEM;
 
         map->id = xmap->id;
-        memcpy(map->name, xmap->name, sizeof map->name);
-        memcpy(map->entity, xmap->entity, sizeof map->entity);
+        memcpy(map->name, xmap->name, sizeof(map->name));
+        memcpy(map->entity, xmap->entity, sizeof(map->entity));
         map->selector = xmap->selector;
         map->size = xmap->size;
         map->offset = xmap->offset;
@@ -105,12 +105,12 @@ free_map:
  * the Video Probe and Commit negotiation, but some hardware don't implement
  * that feature.
  */
-static __u32 uvc_try_frame_interval(struct uvc_frame *frame, __u32 interval)
+static u32 uvc_try_frame_interval(struct uvc_frame *frame, u32 interval)
 {
         unsigned int i;
 
         if (frame->bFrameIntervalType) {
-                __u32 best = -1, dist;
+                u32 best = -1, dist;
 
                 for (i = 0; i < frame->bFrameIntervalType; ++i) {
                         dist = interval > frame->dwFrameInterval[i]
@@ -125,9 +125,9 @@ static __u32 uvc_try_frame_interval(struct uvc_frame *frame, __u32 interval)
 
                 interval = frame->dwFrameInterval[i-1];
         } else {
-                const __u32 min = frame->dwFrameInterval[0];
-                const __u32 max = frame->dwFrameInterval[1];
-                const __u32 step = frame->dwFrameInterval[2];
+                const u32 min = frame->dwFrameInterval[0];
+                const u32 max = frame->dwFrameInterval[1];
+                const u32 step = frame->dwFrameInterval[2];
 
                 interval = min + (interval - min + step/2) / step * step;
                 if (interval > max)
@@ -137,7 +137,7 @@ static __u32 uvc_try_frame_interval(struct uvc_frame *frame, __u32 interval)
         return interval;
 }
 
-static __u32 uvc_v4l2_get_bytesperline(const struct uvc_format *format,
+static u32 uvc_v4l2_get_bytesperline(const struct uvc_format *format,
         const struct uvc_frame *frame)
 {
         switch (format->fcc) {
@@ -158,17 +158,17 @@ static int uvc_v4l2_try_format(struct uvc_streaming *stream,
 {
         struct uvc_format *format = NULL;
         struct uvc_frame *frame = NULL;
-        __u16 rw, rh;
+        u16 rw, rh;
         unsigned int d, maxd;
         unsigned int i;
-        __u32 interval;
+        u32 interval;
         int ret = 0;
-        __u8 *fcc;
+        u8 *fcc;
 
         if (fmt->type != stream->type)
                 return -EINVAL;
 
-        fcc = (__u8 *)&fmt->fmt.pix.pixelformat;
+        fcc = (u8 *)&fmt->fmt.pix.pixelformat;
         uvc_trace(UVC_TRACE_FORMAT, "Trying format 0x%08x (%c%c%c%c): %ux%u.\n",
                         fmt->fmt.pix.pixelformat,
                         fcc[0], fcc[1], fcc[2], fcc[3],
@@ -197,8 +197,8 @@ static int uvc_v4l2_try_format(struct uvc_streaming *stream,
         maxd = (unsigned int)-1;
 
         for (i = 0; i < format->nframes; ++i) {
-                __u16 w = format->frame[i].wWidth;
-                __u16 h = format->frame[i].wHeight;
+                u16 w = format->frame[i].wWidth;
+                u16 h = format->frame[i].wHeight;
 
                 d = min(w, rw) * min(h, rh);
                 d = w*h + rw*rh - 2*d;
@@ -224,7 +224,7 @@ static int uvc_v4l2_try_format(struct uvc_streaming *stream,
                 (100000000/interval)%10);
 
         /* Set the format index, frame index and frame interval. */
-        memset(probe, 0, sizeof *probe);
+        memset(probe, 0, sizeof(*probe));
         probe->bmHint = 1;      /* dwFrameInterval */
         probe->bFormatIndex = format->index;
         probe->bFrameIndex = frame->bFrameIndex;
@@ -336,7 +336,7 @@ done:
 static int uvc_v4l2_get_streamparm(struct uvc_streaming *stream,
                 struct v4l2_streamparm *parm)
 {
-        uint32_t numerator, denominator;
+        u32 numerator, denominator;
 
         if (parm->type != stream->type)
                 return -EINVAL;
@@ -348,7 +348,7 @@ static int uvc_v4l2_get_streamparm(struct uvc_streaming *stream,
         denominator = 10000000;
         uvc_simplify_fraction(&numerator, &denominator, 8, 333);
 
-        memset(parm, 0, sizeof *parm);
+        memset(parm, 0, sizeof(*parm));
         parm->type = stream->type;
 
         if (stream->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
@@ -373,7 +373,10 @@ static int uvc_v4l2_set_streamparm(struct uvc_streaming *stream,
 {
         struct uvc_streaming_control probe;
         struct v4l2_fract timeperframe;
-        uint32_t interval;
+        struct uvc_format *format;
+        struct uvc_frame *frame;
+        u32 interval, maxd;
+        unsigned int i;
         int ret;
 
         if (parm->type != stream->type)
@@ -396,9 +399,33 @@ static int uvc_v4l2_set_streamparm(struct uvc_streaming *stream,
                 return -EBUSY;
         }
 
+        format = stream->cur_format;
+        frame = stream->cur_frame;
         probe = stream->ctrl;
-        probe.dwFrameInterval =
-                uvc_try_frame_interval(stream->cur_frame, interval);
+        probe.dwFrameInterval = uvc_try_frame_interval(frame, interval);
+        maxd = abs((s32)probe.dwFrameInterval - interval);
+
+        /* Try frames with matching size to find the best frame interval. */
+        for (i = 0; i < format->nframes && maxd != 0; i++) {
+                u32 d, ival;
+
+                if (&format->frame[i] == stream->cur_frame)
+                        continue;
+
+                if (format->frame[i].wWidth != stream->cur_frame->wWidth ||
+                    format->frame[i].wHeight != stream->cur_frame->wHeight)
+                        continue;
+
+                ival = uvc_try_frame_interval(&format->frame[i], interval);
+                d = abs((s32)ival - interval);
+                if (d >= maxd)
+                        continue;
+
+                frame = &format->frame[i];
+                probe.bFrameIndex = frame->bFrameIndex;
+                probe.dwFrameInterval = ival;
+                maxd = d;
+        }
 
         /* Probe the device with the new settings. */
         ret = uvc_probe_video(stream, &probe);
@@ -408,6 +435,7 @@ static int uvc_v4l2_set_streamparm(struct uvc_streaming *stream,
         }
 
         stream->ctrl = probe;
+        stream->cur_frame = frame;
         mutex_unlock(&stream->mutex);
 
         /* Return the actual frame period. */
@@ -498,7 +526,7 @@ static int uvc_v4l2_open(struct file *file)
                 return ret;
 
         /* Create the device handle. */
-        handle = kzalloc(sizeof *handle, GFP_KERNEL);
+        handle = kzalloc(sizeof(*handle), GFP_KERNEL);
         if (handle == NULL) {
                 usb_autopm_put_interface(stream->dev->intf);
                 return -ENOMEM;
@@ -577,7 +605,7 @@ static int uvc_ioctl_enum_fmt(struct uvc_streaming *stream,
 {
         struct uvc_format *format;
         enum v4l2_buf_type type = fmt->type;
-        __u32 index = fmt->index;
+        u32 index = fmt->index;
 
         if (fmt->type != stream->type || fmt->index >= stream->nformats)
                 return -EINVAL;
@@ -1145,8 +1173,9 @@ static int uvc_ioctl_enum_framesizes(struct file *file, void *fh,
         struct uvc_fh *handle = fh;
         struct uvc_streaming *stream = handle->stream;
         struct uvc_format *format = NULL;
-        struct uvc_frame *frame;
-        int i;
+        struct uvc_frame *frame = NULL;
+        unsigned int index;
+        unsigned int i;
 
         /* Look for the given pixel format */
         for (i = 0; i < stream->nformats; i++) {
@@ -1158,10 +1187,20 @@ static int uvc_ioctl_enum_framesizes(struct file *file, void *fh,
         if (format == NULL)
                 return -EINVAL;
 
-        if (fsize->index >= format->nframes)
+        /* Skip duplicate frame sizes */
+        for (i = 0, index = 0; i < format->nframes; i++) {
+                if (frame && frame->wWidth == format->frame[i].wWidth &&
+                    frame->wHeight == format->frame[i].wHeight)
+                        continue;
+                frame = &format->frame[i];
+                if (index == fsize->index)
+                        break;
+                index++;
+        }
+
+        if (i == format->nframes)
                 return -EINVAL;
 
-        frame = &format->frame[fsize->index];
         fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
         fsize->discrete.width = frame->wWidth;
         fsize->discrete.height = frame->wHeight;
@@ -1175,7 +1214,9 @@ static int uvc_ioctl_enum_frameintervals(struct file *file, void *fh,
         struct uvc_streaming *stream = handle->stream;
         struct uvc_format *format = NULL;
         struct uvc_frame *frame = NULL;
-        int i;
+        unsigned int nintervals;
+        unsigned int index;
+        unsigned int i;
 
         /* Look for the given pixel format and frame size */
         for (i = 0; i < stream->nformats; i++) {
@@ -1187,30 +1228,28 @@ static int uvc_ioctl_enum_frameintervals(struct file *file, void *fh,
         if (format == NULL)
                 return -EINVAL;
 
+        index = fival->index;
         for (i = 0; i < format->nframes; i++) {
                 if (format->frame[i].wWidth == fival->width &&
                     format->frame[i].wHeight == fival->height) {
                         frame = &format->frame[i];
-                        break;
+                        nintervals = frame->bFrameIntervalType ?: 1;
+                        if (index < nintervals)
+                                break;
+                        index -= nintervals;
                 }
         }
-        if (frame == NULL)
+        if (i == format->nframes)
                 return -EINVAL;
 
         if (frame->bFrameIntervalType) {
-                if (fival->index >= frame->bFrameIntervalType)
-                        return -EINVAL;
-
                 fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
                 fival->discrete.numerator =
-                        frame->dwFrameInterval[fival->index];
+                        frame->dwFrameInterval[index];
                 fival->discrete.denominator = 10000000;
                 uvc_simplify_fraction(&fival->discrete.numerator,
                         &fival->discrete.denominator, 8, 333);
         } else {
-                if (fival->index)
-                        return -EINVAL;
-
                 fival->type = V4L2_FRMIVAL_TYPE_STEPWISE;
                 fival->stepwise.min.numerator = frame->dwFrameInterval[0];
                 fival->stepwise.min.denominator = 10000000;
@@ -1261,20 +1300,20 @@ static long uvc_ioctl_default(struct file *file, void *fh, bool valid_prio,
 
 #ifdef CONFIG_COMPAT
 struct uvc_xu_control_mapping32 {
-        __u32 id;
-        __u8 name[32];
-        __u8 entity[16];
-        __u8 selector;
+        u32 id;
+        u8 name[32];
+        u8 entity[16];
+        u8 selector;
 
-        __u8 size;
-        __u8 offset;
-        __u32 v4l2_type;
-        __u32 data_type;
+        u8 size;
+        u8 offset;
+        u32 v4l2_type;
+        u32 data_type;
 
         compat_caddr_t menu_info;
-        __u32 menu_count;
+        u32 menu_count;
 
-        __u32 reserved[4];
+        u32 reserved[4];
 };
 
 static int uvc_v4l2_get_xu_mapping(struct uvc_xu_control_mapping *kp,
@@ -1310,10 +1349,10 @@ static int uvc_v4l2_put_xu_mapping(const struct uvc_xu_control_mapping *kp,
 }
 
 struct uvc_xu_control_query32 {
-        __u8 unit;
-        __u8 selector;
-        __u8 query;
-        __u16 size;
+        u8 unit;
+        u8 selector;
+        u8 query;
+        u16 size;
         compat_caddr_t data;
 };