V4L/DVB (12534): soc-camera: V4L2 API compliant scaling (S_FMT) and cropping (S_CROP)

The initial soc-camera scaling and cropping implementation turned out to be
incompliant with the V4L2 API, e.g., it expected the user to specify cropping
in output window pixels, instead of input window pixels. This patch converts
the soc-camera core and all drivers to comply with the standard.

Signed-off-by: Guennadi Liakhovetski <g.liakhovetski@gmx.de>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>

1 files changed, 77 insertions, 37 deletions

diff --git a/drivers/media/video/mx3_camera.c b/drivers/media/video/mx3_camera.c
index d5b51e9900bb..dff2e5e2d8c6 100644
--- a/drivers/media/video/mx3_camera.c
+++ b/drivers/media/video/mx3_camera.c
@@ -220,7 +220,7 @@ static int mx3_videobuf_setup(struct videobuf_queue *vq, unsigned int *count,
         if (!mx3_cam->idmac_channel[0])
                 return -EINVAL;
 
-        *size = icd->rect_current.width * icd->rect_current.height * bpp;
+        *size = icd->user_width * icd->user_height * bpp;
 
         if (!*count)
                 *count = 32;
@@ -241,7 +241,7 @@ static int mx3_videobuf_prepare(struct videobuf_queue *vq,
         struct mx3_camera_buffer *buf =
                 container_of(vb, struct mx3_camera_buffer, vb);
         /* current_fmt _must_ always be set */
-        size_t new_size = icd->rect_current.width * icd->rect_current.height *
+        size_t new_size = icd->user_width * icd->user_height *
                 ((icd->current_fmt->depth + 7) >> 3);
         int ret;
 
@@ -251,12 +251,12 @@ static int mx3_videobuf_prepare(struct videobuf_queue *vq,
          */
 
         if (buf->fmt    != icd->current_fmt ||
-            vb->width   != icd->rect_current.width ||
-            vb->height  != icd->rect_current.height ||
+            vb->width   != icd->user_width ||
+            vb->height  != icd->user_height ||
             vb->field   != field) {
                 buf->fmt        = icd->current_fmt;
-                vb->width       = icd->rect_current.width;
-                vb->height      = icd->rect_current.height;
+                vb->width       = icd->user_width;
+                vb->height      = icd->user_height;
                 vb->field       = field;
                 if (vb->state != VIDEOBUF_NEEDS_INIT)
                         free_buffer(vq, buf);
@@ -354,9 +354,9 @@ static void mx3_videobuf_queue(struct videobuf_queue *vq,
 
         /* This is the configuration of one sg-element */
         video->out_pixel_fmt    = fourcc_to_ipu_pix(data_fmt->fourcc);
-        video->out_width        = icd->rect_current.width;
-        video->out_height       = icd->rect_current.height;
-        video->out_stride       = icd->rect_current.width;
+        video->out_width        = icd->user_width;
+        video->out_height       = icd->user_height;
+        video->out_stride       = icd->user_width;
 
 #ifdef DEBUG
         /* helps to see what DMA actually has written */
@@ -541,7 +541,7 @@ static bool channel_change_requested(struct soc_camera_device *icd,
 
         /* Do buffers have to be re-allocated or channel re-configured? */
         return ichan && rect->width * rect->height >
-                icd->rect_current.width * icd->rect_current.height;
+                icd->user_width * icd->user_height;
 }
 
 static int test_platform_param(struct mx3_camera_dev *mx3_cam,
@@ -589,8 +589,8 @@ static int test_platform_param(struct mx3_camera_dev *mx3_cam,
                 *flags |= SOCAM_DATAWIDTH_4;
                 break;
         default:
-                dev_info(mx3_cam->soc_host.v4l2_dev.dev, "Unsupported bus width %d\n",
-                         buswidth);
+                dev_warn(mx3_cam->soc_host.v4l2_dev.dev,
+                         "Unsupported bus width %d\n", buswidth);
                 return -EINVAL;
         }
 
@@ -605,8 +605,7 @@ static int mx3_camera_try_bus_param(struct soc_camera_device *icd,
         unsigned long bus_flags, camera_flags;
         int ret = test_platform_param(mx3_cam, depth, &bus_flags);
 
-        dev_dbg(icd->dev.parent, "requested bus width %d bit: %d\n",
-                depth, ret);
+        dev_dbg(icd->dev.parent, "request bus width %d bit: %d\n", depth, ret);
 
         if (ret < 0)
                 return ret;
@@ -727,13 +726,13 @@ passthrough:
 }
 
 static void configure_geometry(struct mx3_camera_dev *mx3_cam,
-                               struct v4l2_rect *rect)
+                               unsigned int width, unsigned int height)
 {
         u32 ctrl, width_field, height_field;
 
         /* Setup frame size - this cannot be changed on-the-fly... */
-        width_field = rect->width - 1;
-        height_field = rect->height - 1;
+        width_field = width - 1;
+        height_field = height - 1;
         csi_reg_write(mx3_cam, width_field | (height_field << 16), CSI_SENS_FRM_SIZE);
 
         csi_reg_write(mx3_cam, width_field << 16, CSI_FLASH_STROBE_1);
@@ -745,11 +744,6 @@ static void configure_geometry(struct mx3_camera_dev *mx3_cam,
         ctrl = csi_reg_read(mx3_cam, CSI_OUT_FRM_CTRL) & 0xffff0000;
         /* Sensor does the cropping */
         csi_reg_write(mx3_cam, ctrl | 0 | (0 << 8), CSI_OUT_FRM_CTRL);
-
-        /*
-         * No need to free resources here if we fail, we'll see if we need to
-         * do this next time we are called
-         */
 }
 
 static int acquire_dma_channel(struct mx3_camera_dev *mx3_cam)
@@ -786,6 +780,22 @@ static int acquire_dma_channel(struct mx3_camera_dev *mx3_cam)
         return 0;
 }
 
+/*
+ * FIXME: learn to use stride != width, then we can keep stride properly aligned
+ * and support arbitrary (even) widths.
+ */
+static inline void stride_align(__s32 *width)
+{
+        if (((*width + 7) &  ~7) < 4096)
+                *width = (*width + 7) &  ~7;
+        else
+                *width = *width &  ~7;
+}
+
+/*
+ * As long as we don't implement host-side cropping and scaling, we can use
+ * default g_crop and cropcap from soc_camera.c
+ */
 static int mx3_camera_set_crop(struct soc_camera_device *icd,
                                struct v4l2_crop *a)
 {
@@ -793,20 +803,51 @@ static int mx3_camera_set_crop(struct soc_camera_device *icd,
         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
         struct mx3_camera_dev *mx3_cam = ici->priv;
         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+        struct v4l2_format f = {.type = V4L2_BUF_TYPE_VIDEO_CAPTURE};
+        struct v4l2_pix_format *pix = &f.fmt.pix;
+        int ret;
 
-        /*
-         * We now know pixel formats and can decide upon DMA-channel(s)
-         * So far only direct camera-to-memory is supported
-         */
-        if (channel_change_requested(icd, rect)) {
-                int ret = acquire_dma_channel(mx3_cam);
+        soc_camera_limit_side(&rect->left, &rect->width, 0, 2, 4096);
+        soc_camera_limit_side(&rect->top, &rect->height, 0, 2, 4096);
+
+        ret = v4l2_subdev_call(sd, video, s_crop, a);
+        if (ret < 0)
+                return ret;
+
+        /* The capture device might have changed its output  */
+        ret = v4l2_subdev_call(sd, video, g_fmt, &f);
+        if (ret < 0)
+                return ret;
+
+        if (pix->width & 7) {
+                /* Ouch! We can only handle 8-byte aligned width... */
+                stride_align(&pix->width);
+                ret = v4l2_subdev_call(sd, video, s_fmt, &f);
                 if (ret < 0)
                         return ret;
         }
 
-        configure_geometry(mx3_cam, rect);
+        if (pix->width != icd->user_width || pix->height != icd->user_height) {
+                /*
+                 * We now know pixel formats and can decide upon DMA-channel(s)
+                 * So far only direct camera-to-memory is supported
+                 */
+                if (channel_change_requested(icd, rect)) {
+                        int ret = acquire_dma_channel(mx3_cam);
+                        if (ret < 0)
+                                return ret;
+                }
 
-        return v4l2_subdev_call(sd, video, s_crop, a);
+                configure_geometry(mx3_cam, pix->width, pix->height);
+        }
+
+        dev_dbg(icd->dev.parent, "Sensor cropped %dx%d\n",
+                pix->width, pix->height);
+
+        icd->user_width = pix->width;
+        icd->user_height = pix->height;
+
+        return ret;
 }
 
 static int mx3_camera_set_fmt(struct soc_camera_device *icd,
@@ -817,12 +858,6 @@ static int mx3_camera_set_fmt(struct soc_camera_device *icd,
         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         const struct soc_camera_format_xlate *xlate;
         struct v4l2_pix_format *pix = &f->fmt.pix;
-        struct v4l2_rect rect = {
-                .left   = icd->rect_current.left,
-                .top    = icd->rect_current.top,
-                .width  = pix->width,
-                .height = pix->height,
-        };
         int ret;
 
         xlate = soc_camera_xlate_by_fourcc(icd, pix->pixelformat);
@@ -832,6 +867,9 @@ static int mx3_camera_set_fmt(struct soc_camera_device *icd,
                 return -EINVAL;
         }
 
+        stride_align(&pix->width);
+        dev_dbg(icd->dev.parent, "Set format %dx%d\n", pix->width, pix->height);
+
         ret = acquire_dma_channel(mx3_cam);
         if (ret < 0)
                 return ret;
@@ -842,7 +880,7 @@ static int mx3_camera_set_fmt(struct soc_camera_device *icd,
          * mxc_v4l2_s_fmt()
          */
 
-        configure_geometry(mx3_cam, &rect);
+        configure_geometry(mx3_cam, pix->width, pix->height);
 
         ret = v4l2_subdev_call(sd, video, s_fmt, f);
         if (!ret) {
@@ -850,6 +888,8 @@ static int mx3_camera_set_fmt(struct soc_camera_device *icd,
                 icd->current_fmt = xlate->host_fmt;
         }
 
+        dev_dbg(icd->dev.parent, "Sensor set %dx%d\n", pix->width, pix->height);
+
         return ret;
 }