V4L/DVB (12528): sh_mobile_ceu_camera: implement host-side image scaling
Guennadi Liakhovetski [Tue, 25 Aug 2009 14:46:54 +0000 (11:46 -0300)]
Use host-side image scaling when the client fails to set the requested format.
We also have to take scaling into account when performing host-side cropping.
Similar to cropping we try to use client-side scaling as much as possible to
preserve bus bandwidth and optimise the frame-rate.

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

drivers/media/video/sh_mobile_ceu_camera.c

index 3fee7c0..499d1a2 100644 (file)
@@ -95,6 +95,8 @@ struct sh_mobile_ceu_dev {
 
        struct sh_mobile_ceu_info *pdata;
 
+       u32 cflcr;
+
        unsigned int is_interlaced:1;
        unsigned int image_mode:1;
        unsigned int is_16bit:1;
@@ -102,6 +104,7 @@ struct sh_mobile_ceu_dev {
 
 struct sh_mobile_ceu_cam {
        struct v4l2_rect camera_rect;
+       struct v4l2_rect camera_max;
        const struct soc_camera_data_format *extra_fmt;
        const struct soc_camera_data_format *camera_fmt;
 };
@@ -435,54 +438,119 @@ static void sh_mobile_ceu_remove_device(struct soc_camera_device *icd)
        pcdev->icd = NULL;
 }
 
+/*
+ * See chapter 29.4.12 "Capture Filter Control Register (CFLCR)"
+ * in SH7722 Hardware Manual
+ */
+static unsigned int size_dst(unsigned int src, unsigned int scale)
+{
+       unsigned int mant_pre = scale >> 12;
+       if (!src || !scale)
+               return src;
+       return ((mant_pre + 2 * (src - 1)) / (2 * mant_pre) - 1) *
+               mant_pre * 4096 / scale + 1;
+}
+
+static unsigned int size_src(unsigned int dst, unsigned int scale)
+{
+       unsigned int mant_pre = scale >> 12, tmp;
+       if (!dst || !scale)
+               return dst;
+       for (tmp = ((dst - 1) * scale + 2048 * mant_pre) / 4096 + 1;
+            size_dst(tmp, scale) < dst;
+            tmp++)
+               ;
+       return tmp;
+}
+
+static u16 calc_scale(unsigned int src, unsigned int *dst)
+{
+       u16 scale;
+
+       if (src == *dst)
+               return 0;
+
+       scale = (src * 4096 / *dst) & ~7;
+
+       while (scale > 4096 && size_dst(src, scale) < *dst)
+               scale -= 8;
+
+       *dst = size_dst(src, scale);
+
+       return scale;
+}
+
+/* rect is guaranteed to not exceed the scaled camera rectangle */
 static void sh_mobile_ceu_set_rect(struct soc_camera_device *icd,
                                   struct v4l2_rect *rect)
 {
        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
        struct sh_mobile_ceu_cam *cam = icd->host_priv;
        struct sh_mobile_ceu_dev *pcdev = ici->priv;
-       int width, height, cfszr_width, cdwdr_width;
-       unsigned int left_offset, top_offset;
+       int width, height, cfszr_width, cdwdr_width, in_width, in_height;
+       unsigned int left_offset, top_offset, left, top;
+       unsigned int hscale = pcdev->cflcr & 0xffff;
+       unsigned int vscale = (pcdev->cflcr >> 16) & 0xffff;
        u32 camor;
 
-       if (rect->left > cam->camera_rect.left) {
-               left_offset = rect->left - cam->camera_rect.left;
+       /* Switch to the camera scale */
+       left = size_src(rect->left, hscale);
+       top = size_src(rect->top, vscale);
+
+       dev_dbg(&icd->dev, "Left %u * 0x%x = %u, top %u * 0x%x = %u\n",
+               rect->left, hscale, left, rect->top, vscale, top);
+
+       if (left > cam->camera_rect.left) {
+               left_offset = left - cam->camera_rect.left;
        } else {
                left_offset = 0;
-               rect->left = cam->camera_rect.left;
+               left = cam->camera_rect.left;
        }
 
-       if (rect->top > cam->camera_rect.top) {
-               top_offset = rect->top - cam->camera_rect.top;
+       if (top > cam->camera_rect.top) {
+               top_offset = top - cam->camera_rect.top;
        } else {
                top_offset = 0;
-               rect->top = cam->camera_rect.top;
+               top = cam->camera_rect.top;
        }
 
-       dev_dbg(&icd->dev, "Offsets %u:%u\n", left_offset, top_offset);
+       dev_dbg(&icd->dev, "New left %u, top %u, offsets %u:%u\n",
+               rect->left, rect->top, left_offset, top_offset);
 
        if (pcdev->image_mode) {
                width = rect->width;
-               if (!pcdev->is_16bit)
+               in_width = cam->camera_rect.width;
+               if (!pcdev->is_16bit) {
                        width *= 2;
+                       in_width *= 2;
+                       left_offset *= 2;
+               }
                cfszr_width = cdwdr_width = rect->width;
        } else {
-               width = rect->width *
-                       ((icd->current_fmt->depth + 7) >> 3);
-               width = pcdev->is_16bit ? width / 2 : width;
+               unsigned int w_factor = (icd->current_fmt->depth + 7) >> 3;
+               if (!pcdev->is_16bit)
+                       w_factor *= 2;
+
+               width = rect->width * w_factor / 2;
+               in_width = cam->camera_rect.width * w_factor / 2;
+               left_offset = left_offset * w_factor / 2;
+
                cfszr_width = pcdev->is_16bit ? width : width / 2;
                cdwdr_width = pcdev->is_16bit ? width * 2 : width;
        }
 
        height = rect->height;
+       in_height = cam->camera_rect.height;
        if (pcdev->is_interlaced) {
                height /= 2;
+               in_height /= 2;
+               top_offset /= 2;
                cdwdr_width *= 2;
        }
 
        camor = left_offset | (top_offset << 16);
        ceu_write(pcdev, CAMOR, camor);
-       ceu_write(pcdev, CAPWR, (height << 16) | width);
+       ceu_write(pcdev, CAPWR, (in_height << 16) | in_width);
        ceu_write(pcdev, CFSZR, (height << 16) | cfszr_width);
        ceu_write(pcdev, CDWDR, cdwdr_width);
 }
@@ -556,7 +624,7 @@ static int sh_mobile_ceu_set_bus_param(struct soc_camera_device *icd,
        ceu_write(pcdev, CRCMPR, 0);
 
        value = 0x00000010; /* data fetch by default */
-       pcdev->image_mode = yuv_lineskip = 0;
+       yuv_lineskip = 0;
 
        switch (icd->current_fmt->fourcc) {
        case V4L2_PIX_FMT_NV12:
@@ -565,7 +633,6 @@ static int sh_mobile_ceu_set_bus_param(struct soc_camera_device *icd,
                /* fall-through */
        case V4L2_PIX_FMT_NV16:
        case V4L2_PIX_FMT_NV61:
-               pcdev->image_mode = 1;
                switch (cam->camera_fmt->fourcc) {
                case V4L2_PIX_FMT_UYVY:
                        value = 0x00000000; /* Cb0, Y0, Cr0, Y1 */
@@ -599,7 +666,7 @@ static int sh_mobile_ceu_set_bus_param(struct soc_camera_device *icd,
        mdelay(1);
        sh_mobile_ceu_set_rect(icd, &icd->rect_current);
 
-       ceu_write(pcdev, CFLCR, 0); /* no scaling */
+       ceu_write(pcdev, CFLCR, pcdev->cflcr);
 
        /* A few words about byte order (observed in Big Endian mode)
         *
@@ -620,7 +687,7 @@ static int sh_mobile_ceu_set_bus_param(struct soc_camera_device *icd,
        ceu_write(pcdev, CDOCR, value);
        ceu_write(pcdev, CFWCR, 0); /* keep "datafetch firewall" disabled */
 
-       dev_dbg(&icd->dev, "S_FMT successful for %c%c%c%c %ux%u@%u.%u\n",
+       dev_dbg(&icd->dev, "S_FMT successful for %c%c%c%c %ux%u@%u:%u\n",
                pixfmt & 0xff, (pixfmt >> 8) & 0xff,
                (pixfmt >> 16) & 0xff, (pixfmt >> 24) & 0xff,
                icd->rect_current.width, icd->rect_current.height,
@@ -692,6 +759,7 @@ static int sh_mobile_ceu_get_formats(struct soc_camera_device *icd, int idx,
                        return -ENOMEM;
 
                icd->host_priv = cam;
+               cam->camera_max = icd->rect_max;
        } else {
                cam = icd->host_priv;
        }
@@ -754,86 +822,150 @@ static void sh_mobile_ceu_put_formats(struct soc_camera_device *icd)
        icd->host_priv = NULL;
 }
 
+/* Check if any dimension of r1 is smaller than respective one of r2 */
 static bool is_smaller(struct v4l2_rect *r1, struct v4l2_rect *r2)
 {
        return r1->width < r2->width || r1->height < r2->height;
 }
 
+/* Check if r1 fails to cover r2 */
+static bool is_inside(struct v4l2_rect *r1, struct v4l2_rect *r2)
+{
+       return r1->left > r2->left || r1->top > r2->top ||
+               r1->left + r1->width < r2->left + r2->width ||
+               r1->top + r1->height < r2->top + r2->height;
+}
+
+/*
+ * CEU can scale and crop, but we don't want to waste bandwidth and kill the
+ * framerate by always requesting the maximum image from the client. For
+ * cropping we also have to take care of the current scale. The common for both
+ * scaling and cropping approach is:
+ * 1. try if the client can produce exactly what requested by the user
+ * 2. if (1) failed, try to double the client image until we get one big enough
+ * 3. if (2) failed, try to request the maximum image
+ */
 static int sh_mobile_ceu_set_crop(struct soc_camera_device *icd,
                                  struct v4l2_rect *rect)
 {
        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
        struct sh_mobile_ceu_dev *pcdev = ici->priv;
-       struct v4l2_rect cam_rect = *rect;
+       struct v4l2_rect cam_rect, target, cam_max;
        struct sh_mobile_ceu_cam *cam = icd->host_priv;
+       unsigned int hscale = pcdev->cflcr & 0xffff;
+       unsigned int vscale = (pcdev->cflcr >> 16) & 0xffff;
        unsigned short width, height;
        u32 capsr;
        int ret;
 
+       /* Scale back up into client units */
+       cam_rect.left   = size_src(rect->left, hscale);
+       cam_rect.width  = size_src(rect->width, hscale);
+       cam_rect.top    = size_src(rect->top, vscale);
+       cam_rect.height = size_src(rect->height, vscale);
+
+       target = cam_rect;
+
        capsr = capture_save_reset(pcdev);
-       dev_dbg(&icd->dev, "CAPSR %x\n", capsr);
+       dev_dbg(&icd->dev, "CAPSR 0x%x, CFLCR 0x%x\n", capsr, pcdev->cflcr);
 
+       /* First attempt - see if the client can deliver a perfect result */
        ret = icd->ops->set_crop(icd, &cam_rect);
-       if (!ret && !memcmp(rect, &cam_rect, sizeof(*rect))) {
-               dev_dbg(&icd->dev, "Camera S_CROP successful for %ux%u@%u.%u\n",
+       if (!ret && !memcmp(&target, &cam_rect, sizeof(target))) {
+               dev_dbg(&icd->dev, "Camera S_CROP successful for %ux%u@%u:%u\n",
                        cam_rect.width, cam_rect.height,
                        cam_rect.left, cam_rect.top);
                goto ceu_set_rect;
        }
 
        /* Try to fix cropping, that camera hasn't managed to do */
-       dev_dbg(&icd->dev, "Fix camera S_CROP %d for %ux%u@%u.%u\n",
+       dev_dbg(&icd->dev, "Fix camera S_CROP %d for %ux%u@%u:%u"
+               " to %ux%u@%u:%u\n",
                ret, cam_rect.width, cam_rect.height,
-               cam_rect.left, cam_rect.top);
+               cam_rect.left, cam_rect.top,
+               target.width, target.height, target.left, target.top);
 
        /*
         * Popular special case - some cameras can only handle fixed sizes like
         * QVGA, VGA,... Take care to avoid infinite loop.
         */
-       width = max(cam_rect.width, 1) * 2;
-       height = max(cam_rect.height, 1) * 2;
-       while (!ret && is_smaller(&cam_rect, rect) &&
-              (icd->rect_max.width >= width &&
-               icd->rect_max.height >= height)) {
+       width = max(cam_rect.width, 1);
+       height = max(cam_rect.height, 1);
+       cam_max.width = size_src(icd->rect_max.width, hscale);
+       cam_max.left = size_src(icd->rect_max.left, hscale);
+       cam_max.height = size_src(icd->rect_max.height, vscale);
+       cam_max.top = size_src(icd->rect_max.top, vscale);
+       while (!ret && (is_smaller(&cam_rect, &target) ||
+                       is_inside(&cam_rect, &target)) &&
+              cam_max.width >= width && cam_max.height >= height) {
+
+               width *= 2;
+               height *= 2;
                cam_rect.width = width;
                cam_rect.height = height;
 
+               /* We do not know what the camera is capable of, play safe */
+               if (cam_rect.left > target.left)
+                       cam_rect.left = cam_max.left;
+
+               if (cam_rect.left + cam_rect.width < target.left + target.width)
+                       cam_rect.width = target.left + target.width -
+                               cam_rect.left;
+
+               if (cam_rect.top > target.top)
+                       cam_rect.top = cam_max.top;
+
+               if (cam_rect.top + cam_rect.height < target.top + target.height)
+                       cam_rect.height = target.top + target.height -
+                               cam_rect.top;
+
                if (cam_rect.width + cam_rect.left >
-                   icd->rect_max.width + icd->rect_max.left)
-                       cam_rect.left = icd->rect_max.width +
-                               icd->rect_max.left - cam_rect.width;
+                   cam_max.width + cam_max.left)
+                       cam_rect.left = max(cam_max.width + cam_max.left -
+                                           cam_rect.width, cam_max.left);
 
                if (cam_rect.height + cam_rect.top >
-                   icd->rect_max.height + icd->rect_max.top)
-                       cam_rect.top = icd->rect_max.height +
-                               icd->rect_max.top - cam_rect.height;
+                   cam_max.height + cam_max.top)
+                       cam_rect.top = max(cam_max.height + cam_max.top -
+                                          cam_rect.height, cam_max.top);
 
                ret = icd->ops->set_crop(icd, &cam_rect);
-               dev_dbg(&icd->dev, "Camera S_CROP %d for %ux%u@%u.%u\n",
+               dev_dbg(&icd->dev, "Camera S_CROP %d for %ux%u@%u:%u\n",
                        ret, cam_rect.width, cam_rect.height,
                        cam_rect.left, cam_rect.top);
-               width *= 2;
-               height *= 2;
        }
 
        /*
         * If the camera failed to configure cropping, it should not modify the
         * rectangle
         */
-       if ((ret < 0 && is_smaller(&icd->rect_current, rect)) ||
-           is_smaller(&cam_rect, rect)) {
+       if ((ret < 0 && (is_smaller(&icd->rect_current, rect) ||
+                        is_inside(&icd->rect_current, rect))) ||
+           is_smaller(&cam_rect, &target) || is_inside(&cam_rect, &target)) {
                /*
                 * The camera failed to configure a suitable cropping,
                 * we cannot use the current rectangle, set to max
                 */
-               cam_rect = icd->rect_max;
+               cam_rect = cam_max;
                ret = icd->ops->set_crop(icd, &cam_rect);
-               dev_dbg(&icd->dev, "Camera S_CROP %d for max %ux%u@%u.%u\n",
+               dev_dbg(&icd->dev, "Camera S_CROP %d for max %ux%u@%u:%u\n",
                        ret, cam_rect.width, cam_rect.height,
                        cam_rect.left, cam_rect.top);
                if (ret < 0)
                        /* All failed, hopefully resume current capture */
                        goto resume_capture;
+
+               /* Finally, adjust the target rectangle */
+               if (target.width > cam_rect.width)
+                       target.width = cam_rect.width;
+               if (target.height > cam_rect.height)
+                       target.height = cam_rect.height;
+               if (target.left + target.width > cam_rect.left + cam_rect.width)
+                       target.left = cam_rect.left + cam_rect.width -
+                               target.width;
+               if (target.top + target.height > cam_rect.top + cam_rect.height)
+                       target.top = cam_rect.top + cam_rect.height -
+                               target.height;
        }
 
        /* We now have a rectangle, larger than requested, let's crop */
@@ -844,8 +976,10 @@ static int sh_mobile_ceu_set_crop(struct soc_camera_device *icd,
         * last before last close() _user_ rectangle, which can be different
         * from camera rectangle.
         */
-       dev_dbg(&icd->dev, "SH S_CROP from %ux%u@%u.%u to %ux%u@%u.%u\n",
+       dev_dbg(&icd->dev,
+               "SH S_CROP from %ux%u@%u:%u to %ux%u@%u:%u, scale to %ux%u@%u:%u\n",
                cam_rect.width, cam_rect.height, cam_rect.left, cam_rect.top,
+               target.width, target.height, target.left, target.top,
                rect->width, rect->height, rect->left, rect->top);
 
        ret = 0;
@@ -853,27 +987,49 @@ static int sh_mobile_ceu_set_crop(struct soc_camera_device *icd,
 ceu_set_rect:
        cam->camera_rect = cam_rect;
 
+       rect->width     = size_dst(target.width, hscale);
+       rect->left      = size_dst(target.left, hscale);
+       rect->height    = size_dst(target.height, vscale);
+       rect->top       = size_dst(target.top, vscale);
+
+       sh_mobile_ceu_set_rect(icd, rect);
+
+resume_capture:
        /* Set CAMOR, CAPWR, CFSZR, take care of CDWDR */
        if (pcdev->active)
                capsr |= 1;
-       sh_mobile_ceu_set_rect(icd, rect);
        capture_restore(pcdev, capsr);
 
-resume_capture:
-
        /* Even if only camera cropping succeeded */
        return ret;
 }
 
+/* Similar to set_crop multistage iterative algorithm */
 static int sh_mobile_ceu_set_fmt(struct soc_camera_device *icd,
                                 struct v4l2_format *f)
 {
        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
+       struct sh_mobile_ceu_dev *pcdev = ici->priv;
        struct sh_mobile_ceu_cam *cam = icd->host_priv;
        struct v4l2_pix_format *pix = &f->fmt.pix;
        __u32 pixfmt = pix->pixelformat;
        const struct soc_camera_format_xlate *xlate;
-       int ret;
+       unsigned int width = pix->width, height = pix->height, tmp_w, tmp_h;
+       u16 vscale, hscale;
+       int ret, is_interlaced;
+
+       switch (pix->field) {
+       case V4L2_FIELD_INTERLACED:
+               is_interlaced = 1;
+               break;
+       case V4L2_FIELD_ANY:
+       default:
+               pix->field = V4L2_FIELD_NONE;
+               /* fall-through */
+       case V4L2_FIELD_NONE:
+               is_interlaced = 0;
+               break;
+       }
 
        xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
        if (!xlate) {
@@ -884,27 +1040,104 @@ static int sh_mobile_ceu_set_fmt(struct soc_camera_device *icd,
        pix->pixelformat = xlate->cam_fmt->fourcc;
        ret = v4l2_device_call_until_err(&ici->v4l2_dev, (__u32)icd, video, s_fmt, f);
        pix->pixelformat = pixfmt;
-       if (!ret) {
-               icd->buswidth = xlate->buswidth;
-               icd->current_fmt = xlate->host_fmt;
-               cam->camera_fmt = xlate->cam_fmt;
-               cam->camera_rect.width = pix->width;
-               cam->camera_rect.height = pix->height;
-               cam->camera_rect.left = icd->rect_current.left;
-               cam->camera_rect.top = icd->rect_current.top;
+       dev_dbg(&icd->dev, "Camera %d fmt %ux%u, requested %ux%u, max %ux%u\n",
+               ret, pix->width, pix->height, width, height,
+               icd->rect_max.width, icd->rect_max.height);
+       if (ret < 0)
+               return ret;
+
+       switch (pixfmt) {
+       case V4L2_PIX_FMT_NV12:
+       case V4L2_PIX_FMT_NV21:
+       case V4L2_PIX_FMT_NV16:
+       case V4L2_PIX_FMT_NV61:
+               pcdev->image_mode = 1;
+               break;
+       default:
+               pcdev->image_mode = 0;
        }
 
-       return ret;
+       if ((abs(width - pix->width) < 4 && abs(height - pix->height) < 4) ||
+           !pcdev->image_mode || is_interlaced) {
+               hscale = 0;
+               vscale = 0;
+               goto out;
+       }
+
+       /* Camera set a format, but geometry is not precise, try to improve */
+       /*
+        * FIXME: when soc-camera is converted to implement traditional S_FMT
+        * and S_CROP semantics, replace CEU limits with camera maxima
+        */
+       tmp_w = pix->width;
+       tmp_h = pix->height;
+       while ((width > tmp_w || height > tmp_h) &&
+              tmp_w < 2560 && tmp_h < 1920) {
+               tmp_w = min(2 * tmp_w, (__u32)2560);
+               tmp_h = min(2 * tmp_h, (__u32)1920);
+               pix->width = tmp_w;
+               pix->height = tmp_h;
+               pix->pixelformat = xlate->cam_fmt->fourcc;
+               ret = v4l2_device_call_until_err(&ici->v4l2_dev, (__u32)icd,
+                                                video, s_fmt, f);
+               pix->pixelformat = pixfmt;
+               dev_dbg(&icd->dev, "Camera scaled to %ux%u\n",
+                       pix->width, pix->height);
+               if (ret < 0) {
+                       /* This shouldn't happen */
+                       dev_err(&icd->dev, "Client failed to set format: %d\n",
+                               ret);
+                       return ret;
+               }
+       }
+
+       /* We cannot scale up */
+       if (width > pix->width)
+               width = pix->width;
+
+       if (height > pix->height)
+               height = pix->height;
+
+       /* Let's rock: scale pix->{width x height} down to width x height */
+       hscale = calc_scale(pix->width, &width);
+       vscale = calc_scale(pix->height, &height);
+
+       dev_dbg(&icd->dev, "W: %u : 0x%x = %u, H: %u : 0x%x = %u\n",
+               pix->width, hscale, width, pix->height, vscale, height);
+
+out:
+       pcdev->cflcr = hscale | (vscale << 16);
+
+       icd->buswidth = xlate->buswidth;
+       icd->current_fmt = xlate->host_fmt;
+       cam->camera_fmt = xlate->cam_fmt;
+       cam->camera_rect.width = pix->width;
+       cam->camera_rect.height = pix->height;
+
+       icd->rect_max.left = size_dst(cam->camera_max.left, hscale);
+       icd->rect_max.width = size_dst(cam->camera_max.width, hscale);
+       icd->rect_max.top = size_dst(cam->camera_max.top, vscale);
+       icd->rect_max.height = size_dst(cam->camera_max.height, vscale);
+
+       icd->rect_current.left = icd->rect_max.left;
+       icd->rect_current.top = icd->rect_max.top;
+
+       pcdev->is_interlaced = is_interlaced;
+
+       pix->width = width;
+       pix->height = height;
+
+       return 0;
 }
 
 static int sh_mobile_ceu_try_fmt(struct soc_camera_device *icd,
                                 struct v4l2_format *f)
 {
        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
-       struct sh_mobile_ceu_dev *pcdev = ici->priv;
        const struct soc_camera_format_xlate *xlate;
        struct v4l2_pix_format *pix = &f->fmt.pix;
        __u32 pixfmt = pix->pixelformat;
+       int width, height;
        int ret;
 
        xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
@@ -918,6 +1151,9 @@ static int sh_mobile_ceu_try_fmt(struct soc_camera_device *icd,
        v4l_bound_align_image(&pix->width, 2, 2560, 1,
                              &pix->height, 4, 1920, 2, 0);
 
+       width = pix->width;
+       height = pix->height;
+
        pix->bytesperline = pix->width *
                DIV_ROUND_UP(xlate->host_fmt->depth, 8);
        pix->sizeimage = pix->height * pix->bytesperline;
@@ -925,24 +1161,38 @@ static int sh_mobile_ceu_try_fmt(struct soc_camera_device *icd,
        pix->pixelformat = xlate->cam_fmt->fourcc;
 
        /* limit to sensor capabilities */
-       ret = v4l2_device_call_until_err(&ici->v4l2_dev, (__u32)icd, video, try_fmt, f);
+       ret = v4l2_device_call_until_err(&ici->v4l2_dev, (__u32)icd, video,
+                                        try_fmt, f);
        pix->pixelformat = pixfmt;
        if (ret < 0)
                return ret;
 
-       switch (pix->field) {
-       case V4L2_FIELD_INTERLACED:
-               pcdev->is_interlaced = 1;
-               break;
-       case V4L2_FIELD_ANY:
-               pix->field = V4L2_FIELD_NONE;
-               /* fall-through */
-       case V4L2_FIELD_NONE:
-               pcdev->is_interlaced = 0;
-               break;
-       default:
-               ret = -EINVAL;
-               break;
+       switch (pixfmt) {
+       case V4L2_PIX_FMT_NV12:
+       case V4L2_PIX_FMT_NV21:
+       case V4L2_PIX_FMT_NV16:
+       case V4L2_PIX_FMT_NV61:
+               /* FIXME: check against rect_max after converting soc-camera */
+               /* We can scale precisely, need a bigger image from camera */
+               if (pix->width < width || pix->height < height) {
+                       int tmp_w = pix->width, tmp_h = pix->height;
+                       pix->width = 2560;
+                       pix->height = 1920;
+                       ret = v4l2_device_call_until_err(&ici->v4l2_dev,
+                                                        (__u32)icd, video,
+                                                        try_fmt, f);
+                       if (ret < 0) {
+                               /* Shouldn't actually happen... */
+                               dev_err(&icd->dev,
+                                       "FIXME: try_fmt() returned %d\n", ret);
+                               pix->width = tmp_w;
+                               pix->height = tmp_h;
+                       }
+               }
+               if (pix->width > width)
+                       pix->width = width;
+               if (pix->height > height)
+                       pix->height = height;
        }
 
        return ret;