Merge branch 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media

Pull second set of media updates from Mauro Carvalho Chehab:
 "Despite its size, most of the stuff here is trivial.  This series
  contains:

   - s5p-mfc: additions at the driver and at the core to support H.264
     hardware codec;
   - Some improvements at s5p and davinci embedded drivers;
   - Some V4L2 compliance fixes applied on a few drivers;
   - Several random trivial patches, including several fixes and a few
     new board support additions;

  Notes:

   1) Some Exynos media patches were dependent on some -arm fixes that
      got merged on changeset 782cd9e.  That's why this pull request is
      based that changeset.

   2) As promised, I reviewed the pending VB2 DMABUF series.

      While setting a test environment, it was noticed that the upstream
      support for Samsung Exynos 4 boards (smdk310 and Origen) are
      broken upstream, likely due to regressions: both defconfigs are
      wrong and regulator settings for both boards are broken.  That,
      allied with some bug at the dummy regulator driver, causes OOPSes
      during boot time.

      Long story short: even fixing the above, the proposed patches
      OOPSed when running the DMABUF test.  Not sure yet if the OOPSes
      are due to some other undetected regressions, or due to some bug
      on the patches.

      Due to the above, DMABUF patches for vb2 got NACKed for 3.7."

* 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media: (109 commits)
  [media] m5mols: Add missing #include <linux/sizes.h>
  [media] stk1160: Add support for S-Video input
  Revert "[media] omap3isp: Replace cpu_is_omap3630() with ISP revision check"
  [media]  dvb: LNA implementation changes
  [media] v4l2-ioctl: fix W=1 warnings
  [media] v4l2-ioctl: add blocks check for VIDIOC_SUBDEV_G/S_EDID
  [media] omap3isp: Fix compilation error in ispreg.h
  [media] rc-msi-digivox-ii: Add full scan keycodes
  [media] cx25821: testing the wrong variable
  [media] tda18271-common: hold the I2C adapter during write transfers
  [media] ds3000: add module parameter to force firmware upload
  [media] drivers/media: Remove unnecessary semicolon
  [media] winbond: remove space from driver name
  [media] iguanair: cannot send data from the stack
  [media] omap3isp: Replace cpu_is_omap3630() with ISP revision check
  [media] dvb-usb: print small buffers via %*ph
  [media] uvc: Add return code check at vb2_queue_init()
  [media] em28xx: Replace memcpy with struct assignment
  [media] bt8xx: Add video4linux control V4L2_CID_COLOR_KILLER
  [media] mem2mem_testdev: Use devm_kzalloc() in probe
  ...

Conflicts:
	arch/arm/mach-davinci/include/mach/da8xx.h

3 files changed, 119 insertions, 42 deletions

diff --git a/drivers/media/v4l2-core/v4l2-ctrls.c b/drivers/media/v4l2-core/v4l2-ctrls.c
index 631cdc0e0bda..f6ee201d9347 100644
--- a/drivers/media/v4l2-core/v4l2-ctrls.c
+++ b/drivers/media/v4l2-core/v4l2-ctrls.c
@@ -384,6 +384,25 @@ const char * const *v4l2_ctrl_get_menu(u32 id)
                 "Extended SAR",
                 NULL,
         };
+        static const char * const h264_fp_arrangement_type[] = {
+                "Checkerboard",
+                "Column",
+                "Row",
+                "Side by Side",
+                "Top Bottom",
+                "Temporal",
+                NULL,
+        };
+        static const char * const h264_fmo_map_type[] = {
+                "Interleaved Slices",
+                "Scattered Slices",
+                "Foreground with Leftover",
+                "Box Out",
+                "Raster Scan",
+                "Wipe Scan",
+                "Explicit",
+                NULL,
+        };
         static const char * const mpeg_mpeg4_level[] = {
                 "0",
                 "0b",
@@ -508,6 +527,10 @@ const char * const *v4l2_ctrl_get_menu(u32 id)
                 return h264_profile;
         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
                 return vui_sar_idc;
+        case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:
+                return h264_fp_arrangement_type;
+        case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:
+                return h264_fmo_map_type;
         case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
                 return mpeg_mpeg4_level;
         case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
@@ -643,6 +666,22 @@ const char *v4l2_ctrl_get_name(u32 id)
         case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH:        return "Horizontal Size of SAR";
         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE:           return "Aspect Ratio VUI Enable";
         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:              return "VUI Aspect Ratio IDC";
+        case V4L2_CID_MPEG_VIDEO_H264_SEI_FRAME_PACKING:        return "H264 Enable Frame Packing SEI";
+        case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_CURRENT_FRAME_0:   return "H264 Set Curr. Frame as Frame0";
+        case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:  return "H264 FP Arrangement Type";
+        case V4L2_CID_MPEG_VIDEO_H264_FMO:                      return "H264 Flexible MB Ordering";
+        case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:             return "H264 Map Type for FMO";
+        case V4L2_CID_MPEG_VIDEO_H264_FMO_SLICE_GROUP:          return "H264 FMO Number of Slice Groups";
+        case V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_DIRECTION:     return "H264 FMO Direction of Change";
+        case V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_RATE:          return "H264 FMO Size of 1st Slice Grp";
+        case V4L2_CID_MPEG_VIDEO_H264_FMO_RUN_LENGTH:           return "H264 FMO No. of Consecutive MBs";
+        case V4L2_CID_MPEG_VIDEO_H264_ASO:                      return "H264 Arbitrary Slice Ordering";
+        case V4L2_CID_MPEG_VIDEO_H264_ASO_SLICE_ORDER:          return "H264 ASO Slice Order";
+        case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING:      return "Enable H264 Hierarchical Coding";
+        case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_TYPE: return "H264 Hierarchical Coding Type";
+        case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER:return "H264 Number of HC Layers";
+        case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER_QP:
+                                                                return "H264 Set QP Value for HC Layers";
         case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP:              return "MPEG4 I-Frame QP Value";
         case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP:              return "MPEG4 P-Frame QP Value";
         case V4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QP:              return "MPEG4 B-Frame QP Value";
@@ -657,6 +696,7 @@ const char *v4l2_ctrl_get_name(u32 id)
         case V4L2_CID_MPEG_VIDEO_VBV_SIZE:                      return "VBV Buffer Size";
         case V4L2_CID_MPEG_VIDEO_DEC_PTS:                       return "Video Decoder PTS";
         case V4L2_CID_MPEG_VIDEO_DEC_FRAME:                     return "Video Decoder Frame Count";
+        case V4L2_CID_MPEG_VIDEO_VBV_DELAY:                     return "Initial Delay for VBV Control";
 
         /* CAMERA controls */
         /* Keep the order of the 'case's the same as in videodev2.h! */
@@ -749,6 +789,7 @@ const char *v4l2_ctrl_get_name(u32 id)
         case V4L2_CID_IMAGE_PROC_CLASS:         return "Image Processing Controls";
         case V4L2_CID_LINK_FREQ:                return "Link Frequency";
         case V4L2_CID_PIXEL_RATE:               return "Pixel Rate";
+        case V4L2_CID_TEST_PATTERN:             return "Test Pattern";
 
         /* DV controls */
         case V4L2_CID_DV_CLASS:                 return "Digital Video Controls";
@@ -853,6 +894,8 @@ void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type,
         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
         case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
+        case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:
+        case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:
         case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
         case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
         case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
@@ -862,6 +905,7 @@ void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type,
         case V4L2_CID_DV_TX_MODE:
         case V4L2_CID_DV_TX_RGB_RANGE:
         case V4L2_CID_DV_RX_RGB_RANGE:
+        case V4L2_CID_TEST_PATTERN:
                 *type = V4L2_CTRL_TYPE_MENU;
                 break;
         case V4L2_CID_LINK_FREQ:
@@ -1648,6 +1692,36 @@ struct v4l2_ctrl *v4l2_ctrl_new_std_menu(struct v4l2_ctrl_handler *hdl,
 }
 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu);
 
+/* Helper function for standard menu controls with driver defined menu */
+struct v4l2_ctrl *v4l2_ctrl_new_std_menu_items(struct v4l2_ctrl_handler *hdl,
+                        const struct v4l2_ctrl_ops *ops, u32 id, s32 max,
+                        s32 mask, s32 def, const char * const *qmenu)
+{
+        enum v4l2_ctrl_type type;
+        const char *name;
+        u32 flags;
+        s32 step;
+        s32 min;
+
+        /* v4l2_ctrl_new_std_menu_items() should only be called for
+         * standard controls without a standard menu.
+         */
+        if (v4l2_ctrl_get_menu(id)) {
+                handler_set_err(hdl, -EINVAL);
+                return NULL;
+        }
+
+        v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
+        if (type != V4L2_CTRL_TYPE_MENU || qmenu == NULL) {
+                handler_set_err(hdl, -EINVAL);
+                return NULL;
+        }
+        return v4l2_ctrl_new(hdl, ops, id, name, type, 0, max, mask, def,
+                             flags, qmenu, NULL, NULL);
+
+}
+EXPORT_SYMBOL(v4l2_ctrl_new_std_menu_items);
+
 /* Helper function for standard integer menu controls */
 struct v4l2_ctrl *v4l2_ctrl_new_int_menu(struct v4l2_ctrl_handler *hdl,
                         const struct v4l2_ctrl_ops *ops,
diff --git a/drivers/media/v4l2-core/v4l2-ioctl.c b/drivers/media/v4l2-core/v4l2-ioctl.c
index 9d3e46c446ad..8f388ff31ebb 100644
--- a/drivers/media/v4l2-core/v4l2-ioctl.c
+++ b/drivers/media/v4l2-core/v4l2-ioctl.c
@@ -157,8 +157,7 @@ static const char *v4l2_memory_names[] = {
         [V4L2_MEMORY_OVERLAY] = "overlay",
 };
 
-#define prt_names(a, arr) ((((a) >= 0) && ((a) < ARRAY_SIZE(arr))) ? \
-                           arr[a] : "unknown")
+#define prt_names(a, arr) (((unsigned)(a)) < ARRAY_SIZE(arr) ? arr[a] : "unknown")
 
 /* ------------------------------------------------------------------ */
 /* debug help functions                                               */
@@ -2188,6 +2187,7 @@ static int check_array_args(unsigned int cmd, void *parg, size_t *array_size,
         int ret = 0;
 
         switch (cmd) {
+        case VIDIOC_PREPARE_BUF:
         case VIDIOC_QUERYBUF:
         case VIDIOC_QBUF:
         case VIDIOC_DQBUF: {
@@ -2211,6 +2211,10 @@ static int check_array_args(unsigned int cmd, void *parg, size_t *array_size,
                 struct v4l2_subdev_edid *edid = parg;
 
                 if (edid->blocks) {
+                        if (edid->blocks > 256) {
+                                ret = -EINVAL;
+                                break;
+                        }
                         *user_ptr = (void __user *)edid->edid;
                         *kernel_ptr = (void *)&edid->edid;
                         *array_size = edid->blocks * 128;
diff --git a/drivers/media/v4l2-core/videobuf2-core.c b/drivers/media/v4l2-core/videobuf2-core.c
index e6a26b433e87..432df119af27 100644
--- a/drivers/media/v4l2-core/videobuf2-core.c
+++ b/drivers/media/v4l2-core/videobuf2-core.c
@@ -276,6 +276,9 @@ static void __vb2_queue_free(struct vb2_queue *q, unsigned int buffers)
  */
 static int __verify_planes_array(struct vb2_buffer *vb, const struct v4l2_buffer *b)
 {
+        if (!V4L2_TYPE_IS_MULTIPLANAR(b->type))
+                return 0;
+
         /* Is memory for copying plane information present? */
         if (NULL == b->m.planes) {
                 dprintk(1, "Multi-planar buffer passed but "
@@ -331,10 +334,9 @@ static bool __buffers_in_use(struct vb2_queue *q)
  * __fill_v4l2_buffer() - fill in a struct v4l2_buffer with information to be
  * returned to userspace
  */
-static int __fill_v4l2_buffer(struct vb2_buffer *vb, struct v4l2_buffer *b)
+static void __fill_v4l2_buffer(struct vb2_buffer *vb, struct v4l2_buffer *b)
 {
         struct vb2_queue *q = vb->vb2_queue;
-        int ret;
 
         /* Copy back data such as timestamp, flags, etc. */
         memcpy(b, &vb->v4l2_buf, offsetof(struct v4l2_buffer, m));
@@ -342,14 +344,11 @@ static int __fill_v4l2_buffer(struct vb2_buffer *vb, struct v4l2_buffer *b)
         b->reserved = vb->v4l2_buf.reserved;
 
         if (V4L2_TYPE_IS_MULTIPLANAR(q->type)) {
-                ret = __verify_planes_array(vb, b);
-                if (ret)
-                        return ret;
-
                 /*
                  * Fill in plane-related data if userspace provided an array
-                 * for it. The memory and size is verified above.
+                 * for it. The caller has already verified memory and size.
                  */
+                b->length = vb->num_planes;
                 memcpy(b->m.planes, vb->v4l2_planes,
                         b->length * sizeof(struct v4l2_plane));
         } else {
@@ -391,8 +390,6 @@ static int __fill_v4l2_buffer(struct vb2_buffer *vb, struct v4l2_buffer *b)
 
         if (__buffer_in_use(q, vb))
                 b->flags |= V4L2_BUF_FLAG_MAPPED;
-
-        return 0;
 }
 
 /**
@@ -411,6 +408,7 @@ static int __fill_v4l2_buffer(struct vb2_buffer *vb, struct v4l2_buffer *b)
 int vb2_querybuf(struct vb2_queue *q, struct v4l2_buffer *b)
 {
         struct vb2_buffer *vb;
+        int ret;
 
         if (b->type != q->type) {
                 dprintk(1, "querybuf: wrong buffer type\n");
@@ -422,8 +420,10 @@ int vb2_querybuf(struct vb2_queue *q, struct v4l2_buffer *b)
                 return -EINVAL;
         }
         vb = q->bufs[b->index];
-
-        return __fill_v4l2_buffer(vb, b);
+        ret = __verify_planes_array(vb, b);
+        if (!ret)
+                __fill_v4l2_buffer(vb, b);
+        return ret;
 }
 EXPORT_SYMBOL(vb2_querybuf);
 
@@ -813,24 +813,16 @@ void vb2_buffer_done(struct vb2_buffer *vb, enum vb2_buffer_state state)
 EXPORT_SYMBOL_GPL(vb2_buffer_done);
 
 /**
- * __fill_vb2_buffer() - fill a vb2_buffer with information provided in
- * a v4l2_buffer by the userspace
+ * __fill_vb2_buffer() - fill a vb2_buffer with information provided in a
+ * v4l2_buffer by the userspace. The caller has already verified that struct
+ * v4l2_buffer has a valid number of planes.
  */
-static int __fill_vb2_buffer(struct vb2_buffer *vb, const struct v4l2_buffer *b,
+static void __fill_vb2_buffer(struct vb2_buffer *vb, const struct v4l2_buffer *b,
                                 struct v4l2_plane *v4l2_planes)
 {
         unsigned int plane;
-        int ret;
 
         if (V4L2_TYPE_IS_MULTIPLANAR(b->type)) {
-                /*
-                 * Verify that the userspace gave us a valid array for
-                 * plane information.
-                 */
-                ret = __verify_planes_array(vb, b);
-                if (ret)
-                        return ret;
-
                 /* Fill in driver-provided information for OUTPUT types */
                 if (V4L2_TYPE_IS_OUTPUT(b->type)) {
                         /*
@@ -872,8 +864,6 @@ static int __fill_vb2_buffer(struct vb2_buffer *vb, const struct v4l2_buffer *b,
         vb->v4l2_buf.field = b->field;
         vb->v4l2_buf.timestamp = b->timestamp;
         vb->v4l2_buf.flags = b->flags & ~V4L2_BUFFER_STATE_FLAGS;
-
-        return 0;
 }
 
 /**
@@ -888,10 +878,8 @@ static int __qbuf_userptr(struct vb2_buffer *vb, const struct v4l2_buffer *b)
         int ret;
         int write = !V4L2_TYPE_IS_OUTPUT(q->type);
 
-        /* Verify and copy relevant information provided by the userspace */
-        ret = __fill_vb2_buffer(vb, b, planes);
-        if (ret)
-                return ret;
+        /* Copy relevant information provided by the userspace */
+        __fill_vb2_buffer(vb, b, planes);
 
         for (plane = 0; plane < vb->num_planes; ++plane) {
                 /* Skip the plane if already verified */
@@ -966,7 +954,8 @@ err:
  */
 static int __qbuf_mmap(struct vb2_buffer *vb, const struct v4l2_buffer *b)
 {
-        return __fill_vb2_buffer(vb, b, vb->v4l2_planes);
+        __fill_vb2_buffer(vb, b, vb->v4l2_planes);
+        return 0;
 }
 
 /**
@@ -1059,7 +1048,9 @@ int vb2_prepare_buf(struct vb2_queue *q, struct v4l2_buffer *b)
                 dprintk(1, "%s(): invalid buffer state %d\n", __func__, vb->state);
                 return -EINVAL;
         }
-
+        ret = __verify_planes_array(vb, b);
+        if (ret < 0)
+                return ret;
         ret = __buf_prepare(vb, b);
         if (ret < 0)
                 return ret;
@@ -1147,6 +1138,9 @@ int vb2_qbuf(struct vb2_queue *q, struct v4l2_buffer *b)
                 ret = -EINVAL;
                 goto unlock;
         }
+        ret = __verify_planes_array(vb, b);
+        if (ret)
+                goto unlock;
 
         switch (vb->state) {
         case VB2_BUF_STATE_DEQUEUED:
@@ -1243,8 +1237,10 @@ static int __vb2_wait_for_done_vb(struct vb2_queue *q, int nonblocking)
                  * the locks or return an error if one occurred.
                  */
                 call_qop(q, wait_finish, q);
-                if (ret)
+                if (ret) {
+                        dprintk(1, "Sleep was interrupted\n");
                         return ret;
+                }
         }
         return 0;
 }
@@ -1255,7 +1251,7 @@ static int __vb2_wait_for_done_vb(struct vb2_queue *q, int nonblocking)
  * Will sleep if required for nonblocking == false.
  */
 static int __vb2_get_done_vb(struct vb2_queue *q, struct vb2_buffer **vb,
-                                int nonblocking)
+                                struct v4l2_buffer *b, int nonblocking)
 {
         unsigned long flags;
         int ret;
@@ -1273,10 +1269,16 @@ static int __vb2_get_done_vb(struct vb2_queue *q, struct vb2_buffer **vb,
          */
         spin_lock_irqsave(&q->done_lock, flags);
         *vb = list_first_entry(&q->done_list, struct vb2_buffer, done_entry);
-        list_del(&(*vb)->done_entry);
+        /*
+         * Only remove the buffer from done_list if v4l2_buffer can handle all
+         * the planes.
+         */
+        ret = __verify_planes_array(*vb, b);
+        if (!ret)
+                list_del(&(*vb)->done_entry);
         spin_unlock_irqrestore(&q->done_lock, flags);
 
-        return 0;
+        return ret;
 }
 
 /**
@@ -1335,12 +1337,9 @@ int vb2_dqbuf(struct vb2_queue *q, struct v4l2_buffer *b, bool nonblocking)
                 dprintk(1, "dqbuf: invalid buffer type\n");
                 return -EINVAL;
         }
-
-        ret = __vb2_get_done_vb(q, &vb, nonblocking);
-        if (ret < 0) {
-                dprintk(1, "dqbuf: error getting next done buffer\n");
+        ret = __vb2_get_done_vb(q, &vb, b, nonblocking);
+        if (ret < 0)
                 return ret;
-        }
 
         ret = call_qop(q, buf_finish, vb);
         if (ret) {