V4L/DVB (12528): sh_mobile_ceu_camera: implement host-side image scaling

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

@@ -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;