[media] move soc_camera i2c drivers into its own dir
authorMauro Carvalho Chehab <mchehab@redhat.com>
Tue, 14 Aug 2012 20:15:52 +0000 (17:15 -0300)
committerMauro Carvalho Chehab <mchehab@redhat.com>
Wed, 15 Aug 2012 19:42:46 +0000 (16:42 -0300)
Move all soc_camera i2c drivers into drivers/media/i2c/soc_camera/.

Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
40 files changed:
drivers/media/i2c/Kconfig
drivers/media/i2c/Makefile
drivers/media/i2c/soc_camera/Kconfig [new file with mode: 0644]
drivers/media/i2c/soc_camera/Makefile [new file with mode: 0644]
drivers/media/i2c/soc_camera/imx074.c [new file with mode: 0644]
drivers/media/i2c/soc_camera/mt9m001.c [new file with mode: 0644]
drivers/media/i2c/soc_camera/mt9m111.c [new file with mode: 0644]
drivers/media/i2c/soc_camera/mt9t031.c [new file with mode: 0644]
drivers/media/i2c/soc_camera/mt9t112.c [new file with mode: 0644]
drivers/media/i2c/soc_camera/mt9v022.c [new file with mode: 0644]
drivers/media/i2c/soc_camera/ov2640.c [new file with mode: 0644]
drivers/media/i2c/soc_camera/ov5642.c [new file with mode: 0644]
drivers/media/i2c/soc_camera/ov6650.c [new file with mode: 0644]
drivers/media/i2c/soc_camera/ov772x.c [new file with mode: 0644]
drivers/media/i2c/soc_camera/ov9640.c [new file with mode: 0644]
drivers/media/i2c/soc_camera/ov9640.h [new file with mode: 0644]
drivers/media/i2c/soc_camera/ov9740.c [new file with mode: 0644]
drivers/media/i2c/soc_camera/rj54n1cb0c.c [new file with mode: 0644]
drivers/media/i2c/soc_camera/sh_mobile_csi2.c [new file with mode: 0644]
drivers/media/i2c/soc_camera/soc_camera.c [new file with mode: 0644]
drivers/media/i2c/soc_camera/tw9910.c [new file with mode: 0644]
drivers/media/video/Kconfig
drivers/media/video/Makefile
drivers/media/video/imx074.c [deleted file]
drivers/media/video/mt9m001.c [deleted file]
drivers/media/video/mt9m111.c [deleted file]
drivers/media/video/mt9t031.c [deleted file]
drivers/media/video/mt9t112.c [deleted file]
drivers/media/video/mt9v022.c [deleted file]
drivers/media/video/ov2640.c [deleted file]
drivers/media/video/ov5642.c [deleted file]
drivers/media/video/ov6650.c [deleted file]
drivers/media/video/ov772x.c [deleted file]
drivers/media/video/ov9640.c [deleted file]
drivers/media/video/ov9640.h [deleted file]
drivers/media/video/ov9740.c [deleted file]
drivers/media/video/rj54n1cb0c.c [deleted file]
drivers/media/video/sh_mobile_csi2.c [deleted file]
drivers/media/video/soc_camera.c [deleted file]
drivers/media/video/tw9910.c [deleted file]

index 1c677f5e3a1a9cb07f61374d5636ae21f2117653..7fe4acf2f80bfb0025a693e6013ca437250c22c9 100644 (file)
@@ -562,5 +562,9 @@ config VIDEO_M52790
         To compile this driver as a module, choose M here: the
         module will be called m52790.
 
+if SOC_CAMERA
+       source "drivers/media/i2c/soc_camera/Kconfig"
+endif
+
 endmenu
 endif
index 93e8c1439596644a5f555fd501517ee3bef4b8e4..088a46015605fcd4442b47da52b5103cac5ea123 100644 (file)
@@ -4,6 +4,7 @@ obj-$(CONFIG_VIDEO_MSP3400) += msp3400.o
 obj-$(CONFIG_VIDEO_SMIAPP)     += smiapp/
 obj-$(CONFIG_VIDEO_CX25840) += cx25840/
 obj-$(CONFIG_VIDEO_M5MOLS)     += m5mols/
+obj-y                          += soc_camera/
 
 obj-$(CONFIG_VIDEO_APTINA_PLL) += aptina-pll.o
 obj-$(CONFIG_VIDEO_TVAUDIO) += tvaudio.o
diff --git a/drivers/media/i2c/soc_camera/Kconfig b/drivers/media/i2c/soc_camera/Kconfig
new file mode 100644 (file)
index 0000000..73fe21d
--- /dev/null
@@ -0,0 +1,89 @@
+comment "soc_camera sensor drivers"
+
+config SOC_CAMERA_IMX074
+       tristate "imx074 support"
+       depends on SOC_CAMERA && I2C
+       help
+         This driver supports IMX074 cameras from Sony
+
+config SOC_CAMERA_MT9M001
+       tristate "mt9m001 support"
+       depends on SOC_CAMERA && I2C
+       select GPIO_PCA953X if MT9M001_PCA9536_SWITCH
+       help
+         This driver supports MT9M001 cameras from Micron, monochrome
+         and colour models.
+
+config SOC_CAMERA_MT9M111
+       tristate "mt9m111, mt9m112 and mt9m131 support"
+       depends on SOC_CAMERA && I2C
+       help
+         This driver supports MT9M111, MT9M112 and MT9M131 cameras from
+         Micron/Aptina
+
+config SOC_CAMERA_MT9T031
+       tristate "mt9t031 support"
+       depends on SOC_CAMERA && I2C
+       help
+         This driver supports MT9T031 cameras from Micron.
+
+config SOC_CAMERA_MT9T112
+       tristate "mt9t112 support"
+       depends on SOC_CAMERA && I2C
+       help
+         This driver supports MT9T112 cameras from Aptina.
+
+config SOC_CAMERA_MT9V022
+       tristate "mt9v022 support"
+       depends on SOC_CAMERA && I2C
+       select GPIO_PCA953X if MT9V022_PCA9536_SWITCH
+       help
+         This driver supports MT9V022 cameras from Micron
+
+config SOC_CAMERA_OV2640
+       tristate "ov2640 camera support"
+       depends on SOC_CAMERA && I2C
+       help
+         This is a ov2640 camera driver
+
+config SOC_CAMERA_OV5642
+       tristate "ov5642 camera support"
+       depends on SOC_CAMERA && I2C
+       help
+         This is a V4L2 camera driver for the OmniVision OV5642 sensor
+
+config SOC_CAMERA_OV6650
+       tristate "ov6650 sensor support"
+       depends on SOC_CAMERA && I2C
+       ---help---
+         This is a V4L2 SoC camera driver for the OmniVision OV6650 sensor
+
+config SOC_CAMERA_OV772X
+       tristate "ov772x camera support"
+       depends on SOC_CAMERA && I2C
+       help
+         This is a ov772x camera driver
+
+config SOC_CAMERA_OV9640
+       tristate "ov9640 camera support"
+       depends on SOC_CAMERA && I2C
+       help
+         This is a ov9640 camera driver
+
+config SOC_CAMERA_OV9740
+       tristate "ov9740 camera support"
+       depends on SOC_CAMERA && I2C
+       help
+         This is a ov9740 camera driver
+
+config SOC_CAMERA_RJ54N1
+       tristate "rj54n1cb0c support"
+       depends on SOC_CAMERA && I2C
+       help
+         This is a rj54n1cb0c video driver
+
+config SOC_CAMERA_TW9910
+       tristate "tw9910 support"
+       depends on SOC_CAMERA && I2C
+       help
+         This is a tw9910 video driver
diff --git a/drivers/media/i2c/soc_camera/Makefile b/drivers/media/i2c/soc_camera/Makefile
new file mode 100644 (file)
index 0000000..d0421fe
--- /dev/null
@@ -0,0 +1,14 @@
+obj-$(CONFIG_SOC_CAMERA_IMX074)                += imx074.o
+obj-$(CONFIG_SOC_CAMERA_MT9M001)       += mt9m001.o
+obj-$(CONFIG_SOC_CAMERA_MT9M111)       += mt9m111.o
+obj-$(CONFIG_SOC_CAMERA_MT9T031)       += mt9t031.o
+obj-$(CONFIG_SOC_CAMERA_MT9T112)       += mt9t112.o
+obj-$(CONFIG_SOC_CAMERA_MT9V022)       += mt9v022.o
+obj-$(CONFIG_SOC_CAMERA_OV2640)                += ov2640.o
+obj-$(CONFIG_SOC_CAMERA_OV5642)                += ov5642.o
+obj-$(CONFIG_SOC_CAMERA_OV6650)                += ov6650.o
+obj-$(CONFIG_SOC_CAMERA_OV772X)                += ov772x.o
+obj-$(CONFIG_SOC_CAMERA_OV9640)                += ov9640.o
+obj-$(CONFIG_SOC_CAMERA_OV9740)                += ov9740.o
+obj-$(CONFIG_SOC_CAMERA_RJ54N1)                += rj54n1cb0c.o
+obj-$(CONFIG_SOC_CAMERA_TW9910)                += tw9910.o
diff --git a/drivers/media/i2c/soc_camera/imx074.c b/drivers/media/i2c/soc_camera/imx074.c
new file mode 100644 (file)
index 0000000..351e9ba
--- /dev/null
@@ -0,0 +1,475 @@
+/*
+ * Driver for IMX074 CMOS Image Sensor from Sony
+ *
+ * Copyright (C) 2010, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
+ *
+ * Partially inspired by the IMX074 driver from the Android / MSM tree
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/v4l2-mediabus.h>
+#include <linux/slab.h>
+#include <linux/videodev2.h>
+#include <linux/module.h>
+
+#include <media/soc_camera.h>
+#include <media/v4l2-subdev.h>
+#include <media/v4l2-chip-ident.h>
+
+/* IMX074 registers */
+
+#define MODE_SELECT                    0x0100
+#define IMAGE_ORIENTATION              0x0101
+#define GROUPED_PARAMETER_HOLD         0x0104
+
+/* Integration Time */
+#define COARSE_INTEGRATION_TIME_HI     0x0202
+#define COARSE_INTEGRATION_TIME_LO     0x0203
+/* Gain */
+#define ANALOGUE_GAIN_CODE_GLOBAL_HI   0x0204
+#define ANALOGUE_GAIN_CODE_GLOBAL_LO   0x0205
+
+/* PLL registers */
+#define PRE_PLL_CLK_DIV                        0x0305
+#define PLL_MULTIPLIER                 0x0307
+#define PLSTATIM                       0x302b
+#define VNDMY_ABLMGSHLMT               0x300a
+#define Y_OPBADDR_START_DI             0x3014
+/* mode setting */
+#define FRAME_LENGTH_LINES_HI          0x0340
+#define FRAME_LENGTH_LINES_LO          0x0341
+#define LINE_LENGTH_PCK_HI             0x0342
+#define LINE_LENGTH_PCK_LO             0x0343
+#define YADDR_START                    0x0347
+#define YADDR_END                      0x034b
+#define X_OUTPUT_SIZE_MSB              0x034c
+#define X_OUTPUT_SIZE_LSB              0x034d
+#define Y_OUTPUT_SIZE_MSB              0x034e
+#define Y_OUTPUT_SIZE_LSB              0x034f
+#define X_EVEN_INC                     0x0381
+#define X_ODD_INC                      0x0383
+#define Y_EVEN_INC                     0x0385
+#define Y_ODD_INC                      0x0387
+
+#define HMODEADD                       0x3001
+#define VMODEADD                       0x3016
+#define VAPPLINE_START                 0x3069
+#define VAPPLINE_END                   0x306b
+#define SHUTTER                                0x3086
+#define HADDAVE                                0x30e8
+#define LANESEL                                0x3301
+
+/* IMX074 supported geometry */
+#define IMX074_WIDTH                   1052
+#define IMX074_HEIGHT                  780
+
+/* IMX074 has only one fixed colorspace per pixelcode */
+struct imx074_datafmt {
+       enum v4l2_mbus_pixelcode        code;
+       enum v4l2_colorspace            colorspace;
+};
+
+struct imx074 {
+       struct v4l2_subdev              subdev;
+       const struct imx074_datafmt     *fmt;
+};
+
+static const struct imx074_datafmt imx074_colour_fmts[] = {
+       {V4L2_MBUS_FMT_SBGGR8_1X8, V4L2_COLORSPACE_SRGB},
+};
+
+static struct imx074 *to_imx074(const struct i2c_client *client)
+{
+       return container_of(i2c_get_clientdata(client), struct imx074, subdev);
+}
+
+/* Find a data format by a pixel code in an array */
+static const struct imx074_datafmt *imx074_find_datafmt(enum v4l2_mbus_pixelcode code)
+{
+       int i;
+
+       for (i = 0; i < ARRAY_SIZE(imx074_colour_fmts); i++)
+               if (imx074_colour_fmts[i].code == code)
+                       return imx074_colour_fmts + i;
+
+       return NULL;
+}
+
+static int reg_write(struct i2c_client *client, const u16 addr, const u8 data)
+{
+       struct i2c_adapter *adap = client->adapter;
+       struct i2c_msg msg;
+       unsigned char tx[3];
+       int ret;
+
+       msg.addr = client->addr;
+       msg.buf = tx;
+       msg.len = 3;
+       msg.flags = 0;
+
+       tx[0] = addr >> 8;
+       tx[1] = addr & 0xff;
+       tx[2] = data;
+
+       ret = i2c_transfer(adap, &msg, 1);
+
+       mdelay(2);
+
+       return ret == 1 ? 0 : -EIO;
+}
+
+static int reg_read(struct i2c_client *client, const u16 addr)
+{
+       u8 buf[2] = {addr >> 8, addr & 0xff};
+       int ret;
+       struct i2c_msg msgs[] = {
+               {
+                       .addr  = client->addr,
+                       .flags = 0,
+                       .len   = 2,
+                       .buf   = buf,
+               }, {
+                       .addr  = client->addr,
+                       .flags = I2C_M_RD,
+                       .len   = 2,
+                       .buf   = buf,
+               },
+       };
+
+       ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
+       if (ret < 0) {
+               dev_warn(&client->dev, "Reading register %x from %x failed\n",
+                        addr, client->addr);
+               return ret;
+       }
+
+       return buf[0] & 0xff; /* no sign-extension */
+}
+
+static int imx074_try_fmt(struct v4l2_subdev *sd,
+                         struct v4l2_mbus_framefmt *mf)
+{
+       const struct imx074_datafmt *fmt = imx074_find_datafmt(mf->code);
+
+       dev_dbg(sd->v4l2_dev->dev, "%s(%u)\n", __func__, mf->code);
+
+       if (!fmt) {
+               mf->code        = imx074_colour_fmts[0].code;
+               mf->colorspace  = imx074_colour_fmts[0].colorspace;
+       }
+
+       mf->width       = IMX074_WIDTH;
+       mf->height      = IMX074_HEIGHT;
+       mf->field       = V4L2_FIELD_NONE;
+
+       return 0;
+}
+
+static int imx074_s_fmt(struct v4l2_subdev *sd,
+                       struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct imx074 *priv = to_imx074(client);
+
+       dev_dbg(sd->v4l2_dev->dev, "%s(%u)\n", __func__, mf->code);
+
+       /* MIPI CSI could have changed the format, double-check */
+       if (!imx074_find_datafmt(mf->code))
+               return -EINVAL;
+
+       imx074_try_fmt(sd, mf);
+
+       priv->fmt = imx074_find_datafmt(mf->code);
+
+       return 0;
+}
+
+static int imx074_g_fmt(struct v4l2_subdev *sd,
+                       struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct imx074 *priv = to_imx074(client);
+
+       const struct imx074_datafmt *fmt = priv->fmt;
+
+       mf->code        = fmt->code;
+       mf->colorspace  = fmt->colorspace;
+       mf->width       = IMX074_WIDTH;
+       mf->height      = IMX074_HEIGHT;
+       mf->field       = V4L2_FIELD_NONE;
+
+       return 0;
+}
+
+static int imx074_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+       struct v4l2_rect *rect = &a->c;
+
+       a->type         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+       rect->top       = 0;
+       rect->left      = 0;
+       rect->width     = IMX074_WIDTH;
+       rect->height    = IMX074_HEIGHT;
+
+       return 0;
+}
+
+static int imx074_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
+{
+       a->bounds.left                  = 0;
+       a->bounds.top                   = 0;
+       a->bounds.width                 = IMX074_WIDTH;
+       a->bounds.height                = IMX074_HEIGHT;
+       a->defrect                      = a->bounds;
+       a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+       a->pixelaspect.numerator        = 1;
+       a->pixelaspect.denominator      = 1;
+
+       return 0;
+}
+
+static int imx074_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
+                          enum v4l2_mbus_pixelcode *code)
+{
+       if ((unsigned int)index >= ARRAY_SIZE(imx074_colour_fmts))
+               return -EINVAL;
+
+       *code = imx074_colour_fmts[index].code;
+       return 0;
+}
+
+static int imx074_s_stream(struct v4l2_subdev *sd, int enable)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+       /* MODE_SELECT: stream or standby */
+       return reg_write(client, MODE_SELECT, !!enable);
+}
+
+static int imx074_g_chip_ident(struct v4l2_subdev *sd,
+                              struct v4l2_dbg_chip_ident *id)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+       if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
+               return -EINVAL;
+
+       if (id->match.addr != client->addr)
+               return -ENODEV;
+
+       id->ident       = V4L2_IDENT_IMX074;
+       id->revision    = 0;
+
+       return 0;
+}
+
+static int imx074_g_mbus_config(struct v4l2_subdev *sd,
+                               struct v4l2_mbus_config *cfg)
+{
+       cfg->type = V4L2_MBUS_CSI2;
+       cfg->flags = V4L2_MBUS_CSI2_2_LANE |
+               V4L2_MBUS_CSI2_CHANNEL_0 |
+               V4L2_MBUS_CSI2_CONTINUOUS_CLOCK;
+
+       return 0;
+}
+
+static struct v4l2_subdev_video_ops imx074_subdev_video_ops = {
+       .s_stream       = imx074_s_stream,
+       .s_mbus_fmt     = imx074_s_fmt,
+       .g_mbus_fmt     = imx074_g_fmt,
+       .try_mbus_fmt   = imx074_try_fmt,
+       .enum_mbus_fmt  = imx074_enum_fmt,
+       .g_crop         = imx074_g_crop,
+       .cropcap        = imx074_cropcap,
+       .g_mbus_config  = imx074_g_mbus_config,
+};
+
+static struct v4l2_subdev_core_ops imx074_subdev_core_ops = {
+       .g_chip_ident   = imx074_g_chip_ident,
+};
+
+static struct v4l2_subdev_ops imx074_subdev_ops = {
+       .core   = &imx074_subdev_core_ops,
+       .video  = &imx074_subdev_video_ops,
+};
+
+static int imx074_video_probe(struct i2c_client *client)
+{
+       int ret;
+       u16 id;
+
+       /* Read sensor Model ID */
+       ret = reg_read(client, 0);
+       if (ret < 0)
+               return ret;
+
+       id = ret << 8;
+
+       ret = reg_read(client, 1);
+       if (ret < 0)
+               return ret;
+
+       id |= ret;
+
+       dev_info(&client->dev, "Chip ID 0x%04x detected\n", id);
+
+       if (id != 0x74)
+               return -ENODEV;
+
+       /* PLL Setting EXTCLK=24MHz, 22.5times */
+       reg_write(client, PLL_MULTIPLIER, 0x2D);
+       reg_write(client, PRE_PLL_CLK_DIV, 0x02);
+       reg_write(client, PLSTATIM, 0x4B);
+
+       /* 2-lane mode */
+       reg_write(client, 0x3024, 0x00);
+
+       reg_write(client, IMAGE_ORIENTATION, 0x00);
+
+       /* select RAW mode:
+        * 0x08+0x08 = top 8 bits
+        * 0x0a+0x08 = compressed 8-bits
+        * 0x0a+0x0a = 10 bits
+        */
+       reg_write(client, 0x0112, 0x08);
+       reg_write(client, 0x0113, 0x08);
+
+       /* Base setting for High frame mode */
+       reg_write(client, VNDMY_ABLMGSHLMT, 0x80);
+       reg_write(client, Y_OPBADDR_START_DI, 0x08);
+       reg_write(client, 0x3015, 0x37);
+       reg_write(client, 0x301C, 0x01);
+       reg_write(client, 0x302C, 0x05);
+       reg_write(client, 0x3031, 0x26);
+       reg_write(client, 0x3041, 0x60);
+       reg_write(client, 0x3051, 0x24);
+       reg_write(client, 0x3053, 0x34);
+       reg_write(client, 0x3057, 0xC0);
+       reg_write(client, 0x305C, 0x09);
+       reg_write(client, 0x305D, 0x07);
+       reg_write(client, 0x3060, 0x30);
+       reg_write(client, 0x3065, 0x00);
+       reg_write(client, 0x30AA, 0x08);
+       reg_write(client, 0x30AB, 0x1C);
+       reg_write(client, 0x30B0, 0x32);
+       reg_write(client, 0x30B2, 0x83);
+       reg_write(client, 0x30D3, 0x04);
+       reg_write(client, 0x3106, 0x78);
+       reg_write(client, 0x310C, 0x82);
+       reg_write(client, 0x3304, 0x05);
+       reg_write(client, 0x3305, 0x04);
+       reg_write(client, 0x3306, 0x11);
+       reg_write(client, 0x3307, 0x02);
+       reg_write(client, 0x3308, 0x0C);
+       reg_write(client, 0x3309, 0x06);
+       reg_write(client, 0x330A, 0x08);
+       reg_write(client, 0x330B, 0x04);
+       reg_write(client, 0x330C, 0x08);
+       reg_write(client, 0x330D, 0x06);
+       reg_write(client, 0x330E, 0x01);
+       reg_write(client, 0x3381, 0x00);
+
+       /* V : 1/2V-addition (1,3), H : 1/2H-averaging (1,3) -> Full HD */
+       /* 1608 = 1560 + 48 (black lines) */
+       reg_write(client, FRAME_LENGTH_LINES_HI, 0x06);
+       reg_write(client, FRAME_LENGTH_LINES_LO, 0x48);
+       reg_write(client, YADDR_START, 0x00);
+       reg_write(client, YADDR_END, 0x2F);
+       /* 0x838 == 2104 */
+       reg_write(client, X_OUTPUT_SIZE_MSB, 0x08);
+       reg_write(client, X_OUTPUT_SIZE_LSB, 0x38);
+       /* 0x618 == 1560 */
+       reg_write(client, Y_OUTPUT_SIZE_MSB, 0x06);
+       reg_write(client, Y_OUTPUT_SIZE_LSB, 0x18);
+       reg_write(client, X_EVEN_INC, 0x01);
+       reg_write(client, X_ODD_INC, 0x03);
+       reg_write(client, Y_EVEN_INC, 0x01);
+       reg_write(client, Y_ODD_INC, 0x03);
+       reg_write(client, HMODEADD, 0x00);
+       reg_write(client, VMODEADD, 0x16);
+       reg_write(client, VAPPLINE_START, 0x24);
+       reg_write(client, VAPPLINE_END, 0x53);
+       reg_write(client, SHUTTER, 0x00);
+       reg_write(client, HADDAVE, 0x80);
+
+       reg_write(client, LANESEL, 0x00);
+
+       reg_write(client, GROUPED_PARAMETER_HOLD, 0x00);        /* off */
+
+       return 0;
+}
+
+static int imx074_probe(struct i2c_client *client,
+                       const struct i2c_device_id *did)
+{
+       struct imx074 *priv;
+       struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+       int ret;
+
+       if (!icl) {
+               dev_err(&client->dev, "IMX074: missing platform data!\n");
+               return -EINVAL;
+       }
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
+               dev_warn(&adapter->dev,
+                        "I2C-Adapter doesn't support I2C_FUNC_SMBUS_BYTE\n");
+               return -EIO;
+       }
+
+       priv = kzalloc(sizeof(struct imx074), GFP_KERNEL);
+       if (!priv)
+               return -ENOMEM;
+
+       v4l2_i2c_subdev_init(&priv->subdev, client, &imx074_subdev_ops);
+
+       priv->fmt       = &imx074_colour_fmts[0];
+
+       ret = imx074_video_probe(client);
+       if (ret < 0) {
+               kfree(priv);
+               return ret;
+       }
+
+       return ret;
+}
+
+static int imx074_remove(struct i2c_client *client)
+{
+       struct imx074 *priv = to_imx074(client);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+
+       if (icl->free_bus)
+               icl->free_bus(icl);
+       kfree(priv);
+
+       return 0;
+}
+
+static const struct i2c_device_id imx074_id[] = {
+       { "imx074", 0 },
+       { }
+};
+MODULE_DEVICE_TABLE(i2c, imx074_id);
+
+static struct i2c_driver imx074_i2c_driver = {
+       .driver = {
+               .name = "imx074",
+       },
+       .probe          = imx074_probe,
+       .remove         = imx074_remove,
+       .id_table       = imx074_id,
+};
+
+module_i2c_driver(imx074_i2c_driver);
+
+MODULE_DESCRIPTION("Sony IMX074 Camera driver");
+MODULE_AUTHOR("Guennadi Liakhovetski <g.liakhovetski@gmx.de>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/i2c/soc_camera/mt9m001.c b/drivers/media/i2c/soc_camera/mt9m001.c
new file mode 100644 (file)
index 0000000..00583f5
--- /dev/null
@@ -0,0 +1,737 @@
+/*
+ * Driver for MT9M001 CMOS Image Sensor from Micron
+ *
+ * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/videodev2.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/log2.h>
+#include <linux/module.h>
+
+#include <media/soc_camera.h>
+#include <media/soc_mediabus.h>
+#include <media/v4l2-subdev.h>
+#include <media/v4l2-chip-ident.h>
+#include <media/v4l2-ctrls.h>
+
+/*
+ * mt9m001 i2c address 0x5d
+ * The platform has to define struct i2c_board_info objects and link to them
+ * from struct soc_camera_link
+ */
+
+/* mt9m001 selected register addresses */
+#define MT9M001_CHIP_VERSION           0x00
+#define MT9M001_ROW_START              0x01
+#define MT9M001_COLUMN_START           0x02
+#define MT9M001_WINDOW_HEIGHT          0x03
+#define MT9M001_WINDOW_WIDTH           0x04
+#define MT9M001_HORIZONTAL_BLANKING    0x05
+#define MT9M001_VERTICAL_BLANKING      0x06
+#define MT9M001_OUTPUT_CONTROL         0x07
+#define MT9M001_SHUTTER_WIDTH          0x09
+#define MT9M001_FRAME_RESTART          0x0b
+#define MT9M001_SHUTTER_DELAY          0x0c
+#define MT9M001_RESET                  0x0d
+#define MT9M001_READ_OPTIONS1          0x1e
+#define MT9M001_READ_OPTIONS2          0x20
+#define MT9M001_GLOBAL_GAIN            0x35
+#define MT9M001_CHIP_ENABLE            0xF1
+
+#define MT9M001_MAX_WIDTH              1280
+#define MT9M001_MAX_HEIGHT             1024
+#define MT9M001_MIN_WIDTH              48
+#define MT9M001_MIN_HEIGHT             32
+#define MT9M001_COLUMN_SKIP            20
+#define MT9M001_ROW_SKIP               12
+
+/* MT9M001 has only one fixed colorspace per pixelcode */
+struct mt9m001_datafmt {
+       enum v4l2_mbus_pixelcode        code;
+       enum v4l2_colorspace            colorspace;
+};
+
+/* Find a data format by a pixel code in an array */
+static const struct mt9m001_datafmt *mt9m001_find_datafmt(
+       enum v4l2_mbus_pixelcode code, const struct mt9m001_datafmt *fmt,
+       int n)
+{
+       int i;
+       for (i = 0; i < n; i++)
+               if (fmt[i].code == code)
+                       return fmt + i;
+
+       return NULL;
+}
+
+static const struct mt9m001_datafmt mt9m001_colour_fmts[] = {
+       /*
+        * Order important: first natively supported,
+        * second supported with a GPIO extender
+        */
+       {V4L2_MBUS_FMT_SBGGR10_1X10, V4L2_COLORSPACE_SRGB},
+       {V4L2_MBUS_FMT_SBGGR8_1X8, V4L2_COLORSPACE_SRGB},
+};
+
+static const struct mt9m001_datafmt mt9m001_monochrome_fmts[] = {
+       /* Order important - see above */
+       {V4L2_MBUS_FMT_Y10_1X10, V4L2_COLORSPACE_JPEG},
+       {V4L2_MBUS_FMT_Y8_1X8, V4L2_COLORSPACE_JPEG},
+};
+
+struct mt9m001 {
+       struct v4l2_subdev subdev;
+       struct v4l2_ctrl_handler hdl;
+       struct {
+               /* exposure/auto-exposure cluster */
+               struct v4l2_ctrl *autoexposure;
+               struct v4l2_ctrl *exposure;
+       };
+       struct v4l2_rect rect;  /* Sensor window */
+       const struct mt9m001_datafmt *fmt;
+       const struct mt9m001_datafmt *fmts;
+       int num_fmts;
+       int model;      /* V4L2_IDENT_MT9M001* codes from v4l2-chip-ident.h */
+       unsigned int total_h;
+       unsigned short y_skip_top;      /* Lines to skip at the top */
+};
+
+static struct mt9m001 *to_mt9m001(const struct i2c_client *client)
+{
+       return container_of(i2c_get_clientdata(client), struct mt9m001, subdev);
+}
+
+static int reg_read(struct i2c_client *client, const u8 reg)
+{
+       return i2c_smbus_read_word_swapped(client, reg);
+}
+
+static int reg_write(struct i2c_client *client, const u8 reg,
+                    const u16 data)
+{
+       return i2c_smbus_write_word_swapped(client, reg, data);
+}
+
+static int reg_set(struct i2c_client *client, const u8 reg,
+                  const u16 data)
+{
+       int ret;
+
+       ret = reg_read(client, reg);
+       if (ret < 0)
+               return ret;
+       return reg_write(client, reg, ret | data);
+}
+
+static int reg_clear(struct i2c_client *client, const u8 reg,
+                    const u16 data)
+{
+       int ret;
+
+       ret = reg_read(client, reg);
+       if (ret < 0)
+               return ret;
+       return reg_write(client, reg, ret & ~data);
+}
+
+static int mt9m001_init(struct i2c_client *client)
+{
+       int ret;
+
+       dev_dbg(&client->dev, "%s\n", __func__);
+
+       /*
+        * We don't know, whether platform provides reset, issue a soft reset
+        * too. This returns all registers to their default values.
+        */
+       ret = reg_write(client, MT9M001_RESET, 1);
+       if (!ret)
+               ret = reg_write(client, MT9M001_RESET, 0);
+
+       /* Disable chip, synchronous option update */
+       if (!ret)
+               ret = reg_write(client, MT9M001_OUTPUT_CONTROL, 0);
+
+       return ret;
+}
+
+static int mt9m001_s_stream(struct v4l2_subdev *sd, int enable)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+       /* Switch to master "normal" mode or stop sensor readout */
+       if (reg_write(client, MT9M001_OUTPUT_CONTROL, enable ? 2 : 0) < 0)
+               return -EIO;
+       return 0;
+}
+
+static int mt9m001_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9m001 *mt9m001 = to_mt9m001(client);
+       struct v4l2_rect rect = a->c;
+       int ret;
+       const u16 hblank = 9, vblank = 25;
+
+       if (mt9m001->fmts == mt9m001_colour_fmts)
+               /*
+                * Bayer format - even number of rows for simplicity,
+                * but let the user play with the top row.
+                */
+               rect.height = ALIGN(rect.height, 2);
+
+       /* Datasheet requirement: see register description */
+       rect.width = ALIGN(rect.width, 2);
+       rect.left = ALIGN(rect.left, 2);
+
+       soc_camera_limit_side(&rect.left, &rect.width,
+                    MT9M001_COLUMN_SKIP, MT9M001_MIN_WIDTH, MT9M001_MAX_WIDTH);
+
+       soc_camera_limit_side(&rect.top, &rect.height,
+                    MT9M001_ROW_SKIP, MT9M001_MIN_HEIGHT, MT9M001_MAX_HEIGHT);
+
+       mt9m001->total_h = rect.height + mt9m001->y_skip_top + vblank;
+
+       /* Blanking and start values - default... */
+       ret = reg_write(client, MT9M001_HORIZONTAL_BLANKING, hblank);
+       if (!ret)
+               ret = reg_write(client, MT9M001_VERTICAL_BLANKING, vblank);
+
+       /*
+        * The caller provides a supported format, as verified per
+        * call to .try_mbus_fmt()
+        */
+       if (!ret)
+               ret = reg_write(client, MT9M001_COLUMN_START, rect.left);
+       if (!ret)
+               ret = reg_write(client, MT9M001_ROW_START, rect.top);
+       if (!ret)
+               ret = reg_write(client, MT9M001_WINDOW_WIDTH, rect.width - 1);
+       if (!ret)
+               ret = reg_write(client, MT9M001_WINDOW_HEIGHT,
+                               rect.height + mt9m001->y_skip_top - 1);
+       if (!ret && v4l2_ctrl_g_ctrl(mt9m001->autoexposure) == V4L2_EXPOSURE_AUTO)
+               ret = reg_write(client, MT9M001_SHUTTER_WIDTH, mt9m001->total_h);
+
+       if (!ret)
+               mt9m001->rect = rect;
+
+       return ret;
+}
+
+static int mt9m001_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9m001 *mt9m001 = to_mt9m001(client);
+
+       a->c    = mt9m001->rect;
+       a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+       return 0;
+}
+
+static int mt9m001_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
+{
+       a->bounds.left                  = MT9M001_COLUMN_SKIP;
+       a->bounds.top                   = MT9M001_ROW_SKIP;
+       a->bounds.width                 = MT9M001_MAX_WIDTH;
+       a->bounds.height                = MT9M001_MAX_HEIGHT;
+       a->defrect                      = a->bounds;
+       a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+       a->pixelaspect.numerator        = 1;
+       a->pixelaspect.denominator      = 1;
+
+       return 0;
+}
+
+static int mt9m001_g_fmt(struct v4l2_subdev *sd,
+                        struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9m001 *mt9m001 = to_mt9m001(client);
+
+       mf->width       = mt9m001->rect.width;
+       mf->height      = mt9m001->rect.height;
+       mf->code        = mt9m001->fmt->code;
+       mf->colorspace  = mt9m001->fmt->colorspace;
+       mf->field       = V4L2_FIELD_NONE;
+
+       return 0;
+}
+
+static int mt9m001_s_fmt(struct v4l2_subdev *sd,
+                        struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9m001 *mt9m001 = to_mt9m001(client);
+       struct v4l2_crop a = {
+               .c = {
+                       .left   = mt9m001->rect.left,
+                       .top    = mt9m001->rect.top,
+                       .width  = mf->width,
+                       .height = mf->height,
+               },
+       };
+       int ret;
+
+       /* No support for scaling so far, just crop. TODO: use skipping */
+       ret = mt9m001_s_crop(sd, &a);
+       if (!ret) {
+               mf->width       = mt9m001->rect.width;
+               mf->height      = mt9m001->rect.height;
+               mt9m001->fmt    = mt9m001_find_datafmt(mf->code,
+                                       mt9m001->fmts, mt9m001->num_fmts);
+               mf->colorspace  = mt9m001->fmt->colorspace;
+       }
+
+       return ret;
+}
+
+static int mt9m001_try_fmt(struct v4l2_subdev *sd,
+                          struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9m001 *mt9m001 = to_mt9m001(client);
+       const struct mt9m001_datafmt *fmt;
+
+       v4l_bound_align_image(&mf->width, MT9M001_MIN_WIDTH,
+               MT9M001_MAX_WIDTH, 1,
+               &mf->height, MT9M001_MIN_HEIGHT + mt9m001->y_skip_top,
+               MT9M001_MAX_HEIGHT + mt9m001->y_skip_top, 0, 0);
+
+       if (mt9m001->fmts == mt9m001_colour_fmts)
+               mf->height = ALIGN(mf->height - 1, 2);
+
+       fmt = mt9m001_find_datafmt(mf->code, mt9m001->fmts,
+                                  mt9m001->num_fmts);
+       if (!fmt) {
+               fmt = mt9m001->fmt;
+               mf->code = fmt->code;
+       }
+
+       mf->colorspace  = fmt->colorspace;
+
+       return 0;
+}
+
+static int mt9m001_g_chip_ident(struct v4l2_subdev *sd,
+                               struct v4l2_dbg_chip_ident *id)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9m001 *mt9m001 = to_mt9m001(client);
+
+       if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
+               return -EINVAL;
+
+       if (id->match.addr != client->addr)
+               return -ENODEV;
+
+       id->ident       = mt9m001->model;
+       id->revision    = 0;
+
+       return 0;
+}
+
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+static int mt9m001_g_register(struct v4l2_subdev *sd,
+                             struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+       if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
+               return -EINVAL;
+
+       if (reg->match.addr != client->addr)
+               return -ENODEV;
+
+       reg->size = 2;
+       reg->val = reg_read(client, reg->reg);
+
+       if (reg->val > 0xffff)
+               return -EIO;
+
+       return 0;
+}
+
+static int mt9m001_s_register(struct v4l2_subdev *sd,
+                             struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+       if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
+               return -EINVAL;
+
+       if (reg->match.addr != client->addr)
+               return -ENODEV;
+
+       if (reg_write(client, reg->reg, reg->val) < 0)
+               return -EIO;
+
+       return 0;
+}
+#endif
+
+static int mt9m001_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
+{
+       struct mt9m001 *mt9m001 = container_of(ctrl->handler,
+                                              struct mt9m001, hdl);
+       s32 min, max;
+
+       switch (ctrl->id) {
+       case V4L2_CID_EXPOSURE_AUTO:
+               min = mt9m001->exposure->minimum;
+               max = mt9m001->exposure->maximum;
+               mt9m001->exposure->val =
+                       (524 + (mt9m001->total_h - 1) * (max - min)) / 1048 + min;
+               break;
+       }
+       return 0;
+}
+
+static int mt9m001_s_ctrl(struct v4l2_ctrl *ctrl)
+{
+       struct mt9m001 *mt9m001 = container_of(ctrl->handler,
+                                              struct mt9m001, hdl);
+       struct v4l2_subdev *sd = &mt9m001->subdev;
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct v4l2_ctrl *exp = mt9m001->exposure;
+       int data;
+
+       switch (ctrl->id) {
+       case V4L2_CID_VFLIP:
+               if (ctrl->val)
+                       data = reg_set(client, MT9M001_READ_OPTIONS2, 0x8000);
+               else
+                       data = reg_clear(client, MT9M001_READ_OPTIONS2, 0x8000);
+               if (data < 0)
+                       return -EIO;
+               return 0;
+
+       case V4L2_CID_GAIN:
+               /* See Datasheet Table 7, Gain settings. */
+               if (ctrl->val <= ctrl->default_value) {
+                       /* Pack it into 0..1 step 0.125, register values 0..8 */
+                       unsigned long range = ctrl->default_value - ctrl->minimum;
+                       data = ((ctrl->val - ctrl->minimum) * 8 + range / 2) / range;
+
+                       dev_dbg(&client->dev, "Setting gain %d\n", data);
+                       data = reg_write(client, MT9M001_GLOBAL_GAIN, data);
+                       if (data < 0)
+                               return -EIO;
+               } else {
+                       /* Pack it into 1.125..15 variable step, register values 9..67 */
+                       /* We assume qctrl->maximum - qctrl->default_value - 1 > 0 */
+                       unsigned long range = ctrl->maximum - ctrl->default_value - 1;
+                       unsigned long gain = ((ctrl->val - ctrl->default_value - 1) *
+                                              111 + range / 2) / range + 9;
+
+                       if (gain <= 32)
+                               data = gain;
+                       else if (gain <= 64)
+                               data = ((gain - 32) * 16 + 16) / 32 + 80;
+                       else
+                               data = ((gain - 64) * 7 + 28) / 56 + 96;
+
+                       dev_dbg(&client->dev, "Setting gain from %d to %d\n",
+                                reg_read(client, MT9M001_GLOBAL_GAIN), data);
+                       data = reg_write(client, MT9M001_GLOBAL_GAIN, data);
+                       if (data < 0)
+                               return -EIO;
+               }
+               return 0;
+
+       case V4L2_CID_EXPOSURE_AUTO:
+               if (ctrl->val == V4L2_EXPOSURE_MANUAL) {
+                       unsigned long range = exp->maximum - exp->minimum;
+                       unsigned long shutter = ((exp->val - exp->minimum) * 1048 +
+                                                range / 2) / range + 1;
+
+                       dev_dbg(&client->dev,
+                               "Setting shutter width from %d to %lu\n",
+                               reg_read(client, MT9M001_SHUTTER_WIDTH), shutter);
+                       if (reg_write(client, MT9M001_SHUTTER_WIDTH, shutter) < 0)
+                               return -EIO;
+               } else {
+                       const u16 vblank = 25;
+
+                       mt9m001->total_h = mt9m001->rect.height +
+                               mt9m001->y_skip_top + vblank;
+                       if (reg_write(client, MT9M001_SHUTTER_WIDTH, mt9m001->total_h) < 0)
+                               return -EIO;
+               }
+               return 0;
+       }
+       return -EINVAL;
+}
+
+/*
+ * Interface active, can use i2c. If it fails, it can indeed mean, that
+ * this wasn't our capture interface, so, we wait for the right one
+ */
+static int mt9m001_video_probe(struct soc_camera_link *icl,
+                              struct i2c_client *client)
+{
+       struct mt9m001 *mt9m001 = to_mt9m001(client);
+       s32 data;
+       unsigned long flags;
+       int ret;
+
+       /* Enable the chip */
+       data = reg_write(client, MT9M001_CHIP_ENABLE, 1);
+       dev_dbg(&client->dev, "write: %d\n", data);
+
+       /* Read out the chip version register */
+       data = reg_read(client, MT9M001_CHIP_VERSION);
+
+       /* must be 0x8411 or 0x8421 for colour sensor and 8431 for bw */
+       switch (data) {
+       case 0x8411:
+       case 0x8421:
+               mt9m001->model = V4L2_IDENT_MT9M001C12ST;
+               mt9m001->fmts = mt9m001_colour_fmts;
+               break;
+       case 0x8431:
+               mt9m001->model = V4L2_IDENT_MT9M001C12STM;
+               mt9m001->fmts = mt9m001_monochrome_fmts;
+               break;
+       default:
+               dev_err(&client->dev,
+                       "No MT9M001 chip detected, register read %x\n", data);
+               return -ENODEV;
+       }
+
+       mt9m001->num_fmts = 0;
+
+       /*
+        * This is a 10bit sensor, so by default we only allow 10bit.
+        * The platform may support different bus widths due to
+        * different routing of the data lines.
+        */
+       if (icl->query_bus_param)
+               flags = icl->query_bus_param(icl);
+       else
+               flags = SOCAM_DATAWIDTH_10;
+
+       if (flags & SOCAM_DATAWIDTH_10)
+               mt9m001->num_fmts++;
+       else
+               mt9m001->fmts++;
+
+       if (flags & SOCAM_DATAWIDTH_8)
+               mt9m001->num_fmts++;
+
+       mt9m001->fmt = &mt9m001->fmts[0];
+
+       dev_info(&client->dev, "Detected a MT9M001 chip ID %x (%s)\n", data,
+                data == 0x8431 ? "C12STM" : "C12ST");
+
+       ret = mt9m001_init(client);
+       if (ret < 0)
+               dev_err(&client->dev, "Failed to initialise the camera\n");
+
+       /* mt9m001_init() has reset the chip, returning registers to defaults */
+       return v4l2_ctrl_handler_setup(&mt9m001->hdl);
+}
+
+static void mt9m001_video_remove(struct soc_camera_link *icl)
+{
+       if (icl->free_bus)
+               icl->free_bus(icl);
+}
+
+static int mt9m001_g_skip_top_lines(struct v4l2_subdev *sd, u32 *lines)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9m001 *mt9m001 = to_mt9m001(client);
+
+       *lines = mt9m001->y_skip_top;
+
+       return 0;
+}
+
+static const struct v4l2_ctrl_ops mt9m001_ctrl_ops = {
+       .g_volatile_ctrl = mt9m001_g_volatile_ctrl,
+       .s_ctrl = mt9m001_s_ctrl,
+};
+
+static struct v4l2_subdev_core_ops mt9m001_subdev_core_ops = {
+       .g_chip_ident   = mt9m001_g_chip_ident,
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+       .g_register     = mt9m001_g_register,
+       .s_register     = mt9m001_s_register,
+#endif
+};
+
+static int mt9m001_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
+                           enum v4l2_mbus_pixelcode *code)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9m001 *mt9m001 = to_mt9m001(client);
+
+       if (index >= mt9m001->num_fmts)
+               return -EINVAL;
+
+       *code = mt9m001->fmts[index].code;
+       return 0;
+}
+
+static int mt9m001_g_mbus_config(struct v4l2_subdev *sd,
+                               struct v4l2_mbus_config *cfg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+
+       /* MT9M001 has all capture_format parameters fixed */
+       cfg->flags = V4L2_MBUS_PCLK_SAMPLE_FALLING |
+               V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_HIGH |
+               V4L2_MBUS_DATA_ACTIVE_HIGH | V4L2_MBUS_MASTER;
+       cfg->type = V4L2_MBUS_PARALLEL;
+       cfg->flags = soc_camera_apply_board_flags(icl, cfg);
+
+       return 0;
+}
+
+static int mt9m001_s_mbus_config(struct v4l2_subdev *sd,
+                               const struct v4l2_mbus_config *cfg)
+{
+       const struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+       struct mt9m001 *mt9m001 = to_mt9m001(client);
+       unsigned int bps = soc_mbus_get_fmtdesc(mt9m001->fmt->code)->bits_per_sample;
+
+       if (icl->set_bus_param)
+               return icl->set_bus_param(icl, 1 << (bps - 1));
+
+       /*
+        * Without board specific bus width settings we only support the
+        * sensors native bus width
+        */
+       return bps == 10 ? 0 : -EINVAL;
+}
+
+static struct v4l2_subdev_video_ops mt9m001_subdev_video_ops = {
+       .s_stream       = mt9m001_s_stream,
+       .s_mbus_fmt     = mt9m001_s_fmt,
+       .g_mbus_fmt     = mt9m001_g_fmt,
+       .try_mbus_fmt   = mt9m001_try_fmt,
+       .s_crop         = mt9m001_s_crop,
+       .g_crop         = mt9m001_g_crop,
+       .cropcap        = mt9m001_cropcap,
+       .enum_mbus_fmt  = mt9m001_enum_fmt,
+       .g_mbus_config  = mt9m001_g_mbus_config,
+       .s_mbus_config  = mt9m001_s_mbus_config,
+};
+
+static struct v4l2_subdev_sensor_ops mt9m001_subdev_sensor_ops = {
+       .g_skip_top_lines       = mt9m001_g_skip_top_lines,
+};
+
+static struct v4l2_subdev_ops mt9m001_subdev_ops = {
+       .core   = &mt9m001_subdev_core_ops,
+       .video  = &mt9m001_subdev_video_ops,
+       .sensor = &mt9m001_subdev_sensor_ops,
+};
+
+static int mt9m001_probe(struct i2c_client *client,
+                        const struct i2c_device_id *did)
+{
+       struct mt9m001 *mt9m001;
+       struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+       int ret;
+
+       if (!icl) {
+               dev_err(&client->dev, "MT9M001 driver needs platform data\n");
+               return -EINVAL;
+       }
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
+               dev_warn(&adapter->dev,
+                        "I2C-Adapter doesn't support I2C_FUNC_SMBUS_WORD\n");
+               return -EIO;
+       }
+
+       mt9m001 = kzalloc(sizeof(struct mt9m001), GFP_KERNEL);
+       if (!mt9m001)
+               return -ENOMEM;
+
+       v4l2_i2c_subdev_init(&mt9m001->subdev, client, &mt9m001_subdev_ops);
+       v4l2_ctrl_handler_init(&mt9m001->hdl, 4);
+       v4l2_ctrl_new_std(&mt9m001->hdl, &mt9m001_ctrl_ops,
+                       V4L2_CID_VFLIP, 0, 1, 1, 0);
+       v4l2_ctrl_new_std(&mt9m001->hdl, &mt9m001_ctrl_ops,
+                       V4L2_CID_GAIN, 0, 127, 1, 64);
+       mt9m001->exposure = v4l2_ctrl_new_std(&mt9m001->hdl, &mt9m001_ctrl_ops,
+                       V4L2_CID_EXPOSURE, 1, 255, 1, 255);
+       /*
+        * Simulated autoexposure. If enabled, we calculate shutter width
+        * ourselves in the driver based on vertical blanking and frame width
+        */
+       mt9m001->autoexposure = v4l2_ctrl_new_std_menu(&mt9m001->hdl,
+                       &mt9m001_ctrl_ops, V4L2_CID_EXPOSURE_AUTO, 1, 0,
+                       V4L2_EXPOSURE_AUTO);
+       mt9m001->subdev.ctrl_handler = &mt9m001->hdl;
+       if (mt9m001->hdl.error) {
+               int err = mt9m001->hdl.error;
+
+               kfree(mt9m001);
+               return err;
+       }
+       v4l2_ctrl_auto_cluster(2, &mt9m001->autoexposure,
+                                       V4L2_EXPOSURE_MANUAL, true);
+
+       /* Second stage probe - when a capture adapter is there */
+       mt9m001->y_skip_top     = 0;
+       mt9m001->rect.left      = MT9M001_COLUMN_SKIP;
+       mt9m001->rect.top       = MT9M001_ROW_SKIP;
+       mt9m001->rect.width     = MT9M001_MAX_WIDTH;
+       mt9m001->rect.height    = MT9M001_MAX_HEIGHT;
+
+       ret = mt9m001_video_probe(icl, client);
+       if (ret) {
+               v4l2_ctrl_handler_free(&mt9m001->hdl);
+               kfree(mt9m001);
+       }
+
+       return ret;
+}
+
+static int mt9m001_remove(struct i2c_client *client)
+{
+       struct mt9m001 *mt9m001 = to_mt9m001(client);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+
+       v4l2_device_unregister_subdev(&mt9m001->subdev);
+       v4l2_ctrl_handler_free(&mt9m001->hdl);
+       mt9m001_video_remove(icl);
+       kfree(mt9m001);
+
+       return 0;
+}
+
+static const struct i2c_device_id mt9m001_id[] = {
+       { "mt9m001", 0 },
+       { }
+};
+MODULE_DEVICE_TABLE(i2c, mt9m001_id);
+
+static struct i2c_driver mt9m001_i2c_driver = {
+       .driver = {
+               .name = "mt9m001",
+       },
+       .probe          = mt9m001_probe,
+       .remove         = mt9m001_remove,
+       .id_table       = mt9m001_id,
+};
+
+module_i2c_driver(mt9m001_i2c_driver);
+
+MODULE_DESCRIPTION("Micron MT9M001 Camera driver");
+MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/i2c/soc_camera/mt9m111.c b/drivers/media/i2c/soc_camera/mt9m111.c
new file mode 100644 (file)
index 0000000..863d722
--- /dev/null
@@ -0,0 +1,1014 @@
+/*
+ * Driver for MT9M111/MT9M112/MT9M131 CMOS Image Sensor from Micron/Aptina
+ *
+ * Copyright (C) 2008, Robert Jarzmik <robert.jarzmik@free.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#include <linux/videodev2.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/log2.h>
+#include <linux/gpio.h>
+#include <linux/delay.h>
+#include <linux/v4l2-mediabus.h>
+#include <linux/module.h>
+
+#include <media/soc_camera.h>
+#include <media/v4l2-common.h>
+#include <media/v4l2-ctrls.h>
+#include <media/v4l2-chip-ident.h>
+
+/*
+ * MT9M111, MT9M112 and MT9M131:
+ * i2c address is 0x48 or 0x5d (depending on SADDR pin)
+ * The platform has to define i2c_board_info and call i2c_register_board_info()
+ */
+
+/*
+ * Sensor core register addresses (0x000..0x0ff)
+ */
+#define MT9M111_CHIP_VERSION           0x000
+#define MT9M111_ROW_START              0x001
+#define MT9M111_COLUMN_START           0x002
+#define MT9M111_WINDOW_HEIGHT          0x003
+#define MT9M111_WINDOW_WIDTH           0x004
+#define MT9M111_HORIZONTAL_BLANKING_B  0x005
+#define MT9M111_VERTICAL_BLANKING_B    0x006
+#define MT9M111_HORIZONTAL_BLANKING_A  0x007
+#define MT9M111_VERTICAL_BLANKING_A    0x008
+#define MT9M111_SHUTTER_WIDTH          0x009
+#define MT9M111_ROW_SPEED              0x00a
+#define MT9M111_EXTRA_DELAY            0x00b
+#define MT9M111_SHUTTER_DELAY          0x00c
+#define MT9M111_RESET                  0x00d
+#define MT9M111_READ_MODE_B            0x020
+#define MT9M111_READ_MODE_A            0x021
+#define MT9M111_FLASH_CONTROL          0x023
+#define MT9M111_GREEN1_GAIN            0x02b
+#define MT9M111_BLUE_GAIN              0x02c
+#define MT9M111_RED_GAIN               0x02d
+#define MT9M111_GREEN2_GAIN            0x02e
+#define MT9M111_GLOBAL_GAIN            0x02f
+#define MT9M111_CONTEXT_CONTROL                0x0c8
+#define MT9M111_PAGE_MAP               0x0f0
+#define MT9M111_BYTE_WISE_ADDR         0x0f1
+
+#define MT9M111_RESET_SYNC_CHANGES     (1 << 15)
+#define MT9M111_RESET_RESTART_BAD_FRAME        (1 << 9)
+#define MT9M111_RESET_SHOW_BAD_FRAMES  (1 << 8)
+#define MT9M111_RESET_RESET_SOC                (1 << 5)
+#define MT9M111_RESET_OUTPUT_DISABLE   (1 << 4)
+#define MT9M111_RESET_CHIP_ENABLE      (1 << 3)
+#define MT9M111_RESET_ANALOG_STANDBY   (1 << 2)
+#define MT9M111_RESET_RESTART_FRAME    (1 << 1)
+#define MT9M111_RESET_RESET_MODE       (1 << 0)
+
+#define MT9M111_RM_FULL_POWER_RD       (0 << 10)
+#define MT9M111_RM_LOW_POWER_RD                (1 << 10)
+#define MT9M111_RM_COL_SKIP_4X         (1 << 5)
+#define MT9M111_RM_ROW_SKIP_4X         (1 << 4)
+#define MT9M111_RM_COL_SKIP_2X         (1 << 3)
+#define MT9M111_RM_ROW_SKIP_2X         (1 << 2)
+#define MT9M111_RMB_MIRROR_COLS                (1 << 1)
+#define MT9M111_RMB_MIRROR_ROWS                (1 << 0)
+#define MT9M111_CTXT_CTRL_RESTART      (1 << 15)
+#define MT9M111_CTXT_CTRL_DEFECTCOR_B  (1 << 12)
+#define MT9M111_CTXT_CTRL_RESIZE_B     (1 << 10)
+#define MT9M111_CTXT_CTRL_CTRL2_B      (1 << 9)
+#define MT9M111_CTXT_CTRL_GAMMA_B      (1 << 8)
+#define MT9M111_CTXT_CTRL_XENON_EN     (1 << 7)
+#define MT9M111_CTXT_CTRL_READ_MODE_B  (1 << 3)
+#define MT9M111_CTXT_CTRL_LED_FLASH_EN (1 << 2)
+#define MT9M111_CTXT_CTRL_VBLANK_SEL_B (1 << 1)
+#define MT9M111_CTXT_CTRL_HBLANK_SEL_B (1 << 0)
+
+/*
+ * Colorpipe register addresses (0x100..0x1ff)
+ */
+#define MT9M111_OPER_MODE_CTRL         0x106
+#define MT9M111_OUTPUT_FORMAT_CTRL     0x108
+#define MT9M111_REDUCER_XZOOM_B                0x1a0
+#define MT9M111_REDUCER_XSIZE_B                0x1a1
+#define MT9M111_REDUCER_YZOOM_B                0x1a3
+#define MT9M111_REDUCER_YSIZE_B                0x1a4
+#define MT9M111_REDUCER_XZOOM_A                0x1a6
+#define MT9M111_REDUCER_XSIZE_A                0x1a7
+#define MT9M111_REDUCER_YZOOM_A                0x1a9
+#define MT9M111_REDUCER_YSIZE_A                0x1aa
+
+#define MT9M111_OUTPUT_FORMAT_CTRL2_A  0x13a
+#define MT9M111_OUTPUT_FORMAT_CTRL2_B  0x19b
+
+#define MT9M111_OPMODE_AUTOEXPO_EN     (1 << 14)
+#define MT9M111_OPMODE_AUTOWHITEBAL_EN (1 << 1)
+#define MT9M111_OUTFMT_FLIP_BAYER_COL  (1 << 9)
+#define MT9M111_OUTFMT_FLIP_BAYER_ROW  (1 << 8)
+#define MT9M111_OUTFMT_PROCESSED_BAYER (1 << 14)
+#define MT9M111_OUTFMT_BYPASS_IFP      (1 << 10)
+#define MT9M111_OUTFMT_INV_PIX_CLOCK   (1 << 9)
+#define MT9M111_OUTFMT_RGB             (1 << 8)
+#define MT9M111_OUTFMT_RGB565          (0 << 6)
+#define MT9M111_OUTFMT_RGB555          (1 << 6)
+#define MT9M111_OUTFMT_RGB444x         (2 << 6)
+#define MT9M111_OUTFMT_RGBx444         (3 << 6)
+#define MT9M111_OUTFMT_TST_RAMP_OFF    (0 << 4)
+#define MT9M111_OUTFMT_TST_RAMP_COL    (1 << 4)
+#define MT9M111_OUTFMT_TST_RAMP_ROW    (2 << 4)
+#define MT9M111_OUTFMT_TST_RAMP_FRAME  (3 << 4)
+#define MT9M111_OUTFMT_SHIFT_3_UP      (1 << 3)
+#define MT9M111_OUTFMT_AVG_CHROMA      (1 << 2)
+#define MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN (1 << 1)
+#define MT9M111_OUTFMT_SWAP_YCbCr_Cb_Cr_RGB_R_B        (1 << 0)
+
+/*
+ * Camera control register addresses (0x200..0x2ff not implemented)
+ */
+
+#define reg_read(reg) mt9m111_reg_read(client, MT9M111_##reg)
+#define reg_write(reg, val) mt9m111_reg_write(client, MT9M111_##reg, (val))
+#define reg_set(reg, val) mt9m111_reg_set(client, MT9M111_##reg, (val))
+#define reg_clear(reg, val) mt9m111_reg_clear(client, MT9M111_##reg, (val))
+#define reg_mask(reg, val, mask) mt9m111_reg_mask(client, MT9M111_##reg, \
+               (val), (mask))
+
+#define MT9M111_MIN_DARK_ROWS  8
+#define MT9M111_MIN_DARK_COLS  26
+#define MT9M111_MAX_HEIGHT     1024
+#define MT9M111_MAX_WIDTH      1280
+
+struct mt9m111_context {
+       u16 read_mode;
+       u16 blanking_h;
+       u16 blanking_v;
+       u16 reducer_xzoom;
+       u16 reducer_yzoom;
+       u16 reducer_xsize;
+       u16 reducer_ysize;
+       u16 output_fmt_ctrl2;
+       u16 control;
+};
+
+static struct mt9m111_context context_a = {
+       .read_mode              = MT9M111_READ_MODE_A,
+       .blanking_h             = MT9M111_HORIZONTAL_BLANKING_A,
+       .blanking_v             = MT9M111_VERTICAL_BLANKING_A,
+       .reducer_xzoom          = MT9M111_REDUCER_XZOOM_A,
+       .reducer_yzoom          = MT9M111_REDUCER_YZOOM_A,
+       .reducer_xsize          = MT9M111_REDUCER_XSIZE_A,
+       .reducer_ysize          = MT9M111_REDUCER_YSIZE_A,
+       .output_fmt_ctrl2       = MT9M111_OUTPUT_FORMAT_CTRL2_A,
+       .control                = MT9M111_CTXT_CTRL_RESTART,
+};
+
+static struct mt9m111_context context_b = {
+       .read_mode              = MT9M111_READ_MODE_B,
+       .blanking_h             = MT9M111_HORIZONTAL_BLANKING_B,
+       .blanking_v             = MT9M111_VERTICAL_BLANKING_B,
+       .reducer_xzoom          = MT9M111_REDUCER_XZOOM_B,
+       .reducer_yzoom          = MT9M111_REDUCER_YZOOM_B,
+       .reducer_xsize          = MT9M111_REDUCER_XSIZE_B,
+       .reducer_ysize          = MT9M111_REDUCER_YSIZE_B,
+       .output_fmt_ctrl2       = MT9M111_OUTPUT_FORMAT_CTRL2_B,
+       .control                = MT9M111_CTXT_CTRL_RESTART |
+               MT9M111_CTXT_CTRL_DEFECTCOR_B | MT9M111_CTXT_CTRL_RESIZE_B |
+               MT9M111_CTXT_CTRL_CTRL2_B | MT9M111_CTXT_CTRL_GAMMA_B |
+               MT9M111_CTXT_CTRL_READ_MODE_B | MT9M111_CTXT_CTRL_VBLANK_SEL_B |
+               MT9M111_CTXT_CTRL_HBLANK_SEL_B,
+};
+
+/* MT9M111 has only one fixed colorspace per pixelcode */
+struct mt9m111_datafmt {
+       enum v4l2_mbus_pixelcode        code;
+       enum v4l2_colorspace            colorspace;
+};
+
+static const struct mt9m111_datafmt mt9m111_colour_fmts[] = {
+       {V4L2_MBUS_FMT_YUYV8_2X8, V4L2_COLORSPACE_JPEG},
+       {V4L2_MBUS_FMT_YVYU8_2X8, V4L2_COLORSPACE_JPEG},
+       {V4L2_MBUS_FMT_UYVY8_2X8, V4L2_COLORSPACE_JPEG},
+       {V4L2_MBUS_FMT_VYUY8_2X8, V4L2_COLORSPACE_JPEG},
+       {V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE, V4L2_COLORSPACE_SRGB},
+       {V4L2_MBUS_FMT_RGB555_2X8_PADHI_BE, V4L2_COLORSPACE_SRGB},
+       {V4L2_MBUS_FMT_RGB565_2X8_LE, V4L2_COLORSPACE_SRGB},
+       {V4L2_MBUS_FMT_RGB565_2X8_BE, V4L2_COLORSPACE_SRGB},
+       {V4L2_MBUS_FMT_BGR565_2X8_LE, V4L2_COLORSPACE_SRGB},
+       {V4L2_MBUS_FMT_BGR565_2X8_BE, V4L2_COLORSPACE_SRGB},
+       {V4L2_MBUS_FMT_SBGGR8_1X8, V4L2_COLORSPACE_SRGB},
+       {V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE, V4L2_COLORSPACE_SRGB},
+};
+
+struct mt9m111 {
+       struct v4l2_subdev subdev;
+       struct v4l2_ctrl_handler hdl;
+       struct v4l2_ctrl *gain;
+       int model;      /* V4L2_IDENT_MT9M111 or V4L2_IDENT_MT9M112 code
+                        * from v4l2-chip-ident.h */
+       struct mt9m111_context *ctx;
+       struct v4l2_rect rect;  /* cropping rectangle */
+       int width;              /* output */
+       int height;             /* sizes */
+       struct mutex power_lock; /* lock to protect power_count */
+       int power_count;
+       const struct mt9m111_datafmt *fmt;
+       int lastpage;   /* PageMap cache value */
+};
+
+/* Find a data format by a pixel code */
+static const struct mt9m111_datafmt *mt9m111_find_datafmt(struct mt9m111 *mt9m111,
+                                               enum v4l2_mbus_pixelcode code)
+{
+       int i;
+       for (i = 0; i < ARRAY_SIZE(mt9m111_colour_fmts); i++)
+               if (mt9m111_colour_fmts[i].code == code)
+                       return mt9m111_colour_fmts + i;
+
+       return mt9m111->fmt;
+}
+
+static struct mt9m111 *to_mt9m111(const struct i2c_client *client)
+{
+       return container_of(i2c_get_clientdata(client), struct mt9m111, subdev);
+}
+
+static int reg_page_map_set(struct i2c_client *client, const u16 reg)
+{
+       int ret;
+       u16 page;
+       struct mt9m111 *mt9m111 = to_mt9m111(client);
+
+       page = (reg >> 8);
+       if (page == mt9m111->lastpage)
+               return 0;
+       if (page > 2)
+               return -EINVAL;
+
+       ret = i2c_smbus_write_word_swapped(client, MT9M111_PAGE_MAP, page);
+       if (!ret)
+               mt9m111->lastpage = page;
+       return ret;
+}
+
+static int mt9m111_reg_read(struct i2c_client *client, const u16 reg)
+{
+       int ret;
+
+       ret = reg_page_map_set(client, reg);
+       if (!ret)
+               ret = i2c_smbus_read_word_swapped(client, reg & 0xff);
+
+       dev_dbg(&client->dev, "read  reg.%03x -> %04x\n", reg, ret);
+       return ret;
+}
+
+static int mt9m111_reg_write(struct i2c_client *client, const u16 reg,
+                            const u16 data)
+{
+       int ret;
+
+       ret = reg_page_map_set(client, reg);
+       if (!ret)
+               ret = i2c_smbus_write_word_swapped(client, reg & 0xff, data);
+       dev_dbg(&client->dev, "write reg.%03x = %04x -> %d\n", reg, data, ret);
+       return ret;
+}
+
+static int mt9m111_reg_set(struct i2c_client *client, const u16 reg,
+                          const u16 data)
+{
+       int ret;
+
+       ret = mt9m111_reg_read(client, reg);
+       if (ret >= 0)
+               ret = mt9m111_reg_write(client, reg, ret | data);
+       return ret;
+}
+
+static int mt9m111_reg_clear(struct i2c_client *client, const u16 reg,
+                            const u16 data)
+{
+       int ret;
+
+       ret = mt9m111_reg_read(client, reg);
+       if (ret >= 0)
+               ret = mt9m111_reg_write(client, reg, ret & ~data);
+       return ret;
+}
+
+static int mt9m111_reg_mask(struct i2c_client *client, const u16 reg,
+                           const u16 data, const u16 mask)
+{
+       int ret;
+
+       ret = mt9m111_reg_read(client, reg);
+       if (ret >= 0)
+               ret = mt9m111_reg_write(client, reg, (ret & ~mask) | data);
+       return ret;
+}
+
+static int mt9m111_set_context(struct mt9m111 *mt9m111,
+                              struct mt9m111_context *ctx)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
+       return reg_write(CONTEXT_CONTROL, ctx->control);
+}
+
+static int mt9m111_setup_rect_ctx(struct mt9m111 *mt9m111,
+                       struct mt9m111_context *ctx, struct v4l2_rect *rect,
+                       unsigned int width, unsigned int height)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
+       int ret = mt9m111_reg_write(client, ctx->reducer_xzoom, rect->width);
+       if (!ret)
+               ret = mt9m111_reg_write(client, ctx->reducer_yzoom, rect->height);
+       if (!ret)
+               ret = mt9m111_reg_write(client, ctx->reducer_xsize, width);
+       if (!ret)
+               ret = mt9m111_reg_write(client, ctx->reducer_ysize, height);
+       return ret;
+}
+
+static int mt9m111_setup_geometry(struct mt9m111 *mt9m111, struct v4l2_rect *rect,
+                       int width, int height, enum v4l2_mbus_pixelcode code)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
+       int ret;
+
+       ret = reg_write(COLUMN_START, rect->left);
+       if (!ret)
+               ret = reg_write(ROW_START, rect->top);
+
+       if (!ret)
+               ret = reg_write(WINDOW_WIDTH, rect->width);
+       if (!ret)
+               ret = reg_write(WINDOW_HEIGHT, rect->height);
+
+       if (code != V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE) {
+               /* IFP in use, down-scaling possible */
+               if (!ret)
+                       ret = mt9m111_setup_rect_ctx(mt9m111, &context_b,
+                                                    rect, width, height);
+               if (!ret)
+                       ret = mt9m111_setup_rect_ctx(mt9m111, &context_a,
+                                                    rect, width, height);
+       }
+
+       dev_dbg(&client->dev, "%s(%x): %ux%u@%u:%u -> %ux%u = %d\n",
+               __func__, code, rect->width, rect->height, rect->left, rect->top,
+               width, height, ret);
+
+       return ret;
+}
+
+static int mt9m111_enable(struct mt9m111 *mt9m111)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
+       return reg_write(RESET, MT9M111_RESET_CHIP_ENABLE);
+}
+
+static int mt9m111_reset(struct mt9m111 *mt9m111)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
+       int ret;
+
+       ret = reg_set(RESET, MT9M111_RESET_RESET_MODE);
+       if (!ret)
+               ret = reg_set(RESET, MT9M111_RESET_RESET_SOC);
+       if (!ret)
+               ret = reg_clear(RESET, MT9M111_RESET_RESET_MODE
+                               | MT9M111_RESET_RESET_SOC);
+
+       return ret;
+}
+
+static int mt9m111_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+       struct v4l2_rect rect = a->c;
+       struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
+       int width, height;
+       int ret;
+
+       if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+               return -EINVAL;
+
+       if (mt9m111->fmt->code == V4L2_MBUS_FMT_SBGGR8_1X8 ||
+           mt9m111->fmt->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE) {
+               /* Bayer format - even size lengths */
+               rect.width      = ALIGN(rect.width, 2);
+               rect.height     = ALIGN(rect.height, 2);
+               /* Let the user play with the starting pixel */
+       }
+
+       /* FIXME: the datasheet doesn't specify minimum sizes */
+       soc_camera_limit_side(&rect.left, &rect.width,
+                    MT9M111_MIN_DARK_COLS, 2, MT9M111_MAX_WIDTH);
+
+       soc_camera_limit_side(&rect.top, &rect.height,
+                    MT9M111_MIN_DARK_ROWS, 2, MT9M111_MAX_HEIGHT);
+
+       width = min(mt9m111->width, rect.width);
+       height = min(mt9m111->height, rect.height);
+
+       ret = mt9m111_setup_geometry(mt9m111, &rect, width, height, mt9m111->fmt->code);
+       if (!ret) {
+               mt9m111->rect = rect;
+               mt9m111->width = width;
+               mt9m111->height = height;
+       }
+
+       return ret;
+}
+
+static int mt9m111_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+       struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
+
+       a->c    = mt9m111->rect;
+       a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+       return 0;
+}
+
+static int mt9m111_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
+{
+       if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+               return -EINVAL;
+
+       a->bounds.left                  = MT9M111_MIN_DARK_COLS;
+       a->bounds.top                   = MT9M111_MIN_DARK_ROWS;
+       a->bounds.width                 = MT9M111_MAX_WIDTH;
+       a->bounds.height                = MT9M111_MAX_HEIGHT;
+       a->defrect                      = a->bounds;
+       a->pixelaspect.numerator        = 1;
+       a->pixelaspect.denominator      = 1;
+
+       return 0;
+}
+
+static int mt9m111_g_fmt(struct v4l2_subdev *sd,
+                        struct v4l2_mbus_framefmt *mf)
+{
+       struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
+
+       mf->width       = mt9m111->width;
+       mf->height      = mt9m111->height;
+       mf->code        = mt9m111->fmt->code;
+       mf->colorspace  = mt9m111->fmt->colorspace;
+       mf->field       = V4L2_FIELD_NONE;
+
+       return 0;
+}
+
+static int mt9m111_set_pixfmt(struct mt9m111 *mt9m111,
+                             enum v4l2_mbus_pixelcode code)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
+       u16 data_outfmt2, mask_outfmt2 = MT9M111_OUTFMT_PROCESSED_BAYER |
+               MT9M111_OUTFMT_BYPASS_IFP | MT9M111_OUTFMT_RGB |
+               MT9M111_OUTFMT_RGB565 | MT9M111_OUTFMT_RGB555 |
+               MT9M111_OUTFMT_RGB444x | MT9M111_OUTFMT_RGBx444 |
+               MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN |
+               MT9M111_OUTFMT_SWAP_YCbCr_Cb_Cr_RGB_R_B;
+       int ret;
+
+       switch (code) {
+       case V4L2_MBUS_FMT_SBGGR8_1X8:
+               data_outfmt2 = MT9M111_OUTFMT_PROCESSED_BAYER |
+                       MT9M111_OUTFMT_RGB;
+               break;
+       case V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE:
+               data_outfmt2 = MT9M111_OUTFMT_BYPASS_IFP | MT9M111_OUTFMT_RGB;
+               break;
+       case V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE:
+               data_outfmt2 = MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB555 |
+                       MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN;
+               break;
+       case V4L2_MBUS_FMT_RGB555_2X8_PADHI_BE:
+               data_outfmt2 = MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB555;
+               break;
+       case V4L2_MBUS_FMT_RGB565_2X8_LE:
+               data_outfmt2 = MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB565 |
+                       MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN;
+               break;
+       case V4L2_MBUS_FMT_RGB565_2X8_BE:
+               data_outfmt2 = MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB565;
+               break;
+       case V4L2_MBUS_FMT_BGR565_2X8_BE:
+               data_outfmt2 = MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB565 |
+                       MT9M111_OUTFMT_SWAP_YCbCr_Cb_Cr_RGB_R_B;
+               break;
+       case V4L2_MBUS_FMT_BGR565_2X8_LE:
+               data_outfmt2 = MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB565 |
+                       MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN |
+                       MT9M111_OUTFMT_SWAP_YCbCr_Cb_Cr_RGB_R_B;
+               break;
+       case V4L2_MBUS_FMT_UYVY8_2X8:
+               data_outfmt2 = 0;
+               break;
+       case V4L2_MBUS_FMT_VYUY8_2X8:
+               data_outfmt2 = MT9M111_OUTFMT_SWAP_YCbCr_Cb_Cr_RGB_R_B;
+               break;
+       case V4L2_MBUS_FMT_YUYV8_2X8:
+               data_outfmt2 = MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN;
+               break;
+       case V4L2_MBUS_FMT_YVYU8_2X8:
+               data_outfmt2 = MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN |
+                       MT9M111_OUTFMT_SWAP_YCbCr_Cb_Cr_RGB_R_B;
+               break;
+       default:
+               dev_err(&client->dev, "Pixel format not handled: %x\n", code);
+               return -EINVAL;
+       }
+
+       ret = mt9m111_reg_mask(client, context_a.output_fmt_ctrl2,
+                              data_outfmt2, mask_outfmt2);
+       if (!ret)
+               ret = mt9m111_reg_mask(client, context_b.output_fmt_ctrl2,
+                                      data_outfmt2, mask_outfmt2);
+
+       return ret;
+}
+
+static int mt9m111_try_fmt(struct v4l2_subdev *sd,
+                          struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
+       const struct mt9m111_datafmt *fmt;
+       struct v4l2_rect *rect = &mt9m111->rect;
+       bool bayer;
+
+       fmt = mt9m111_find_datafmt(mt9m111, mf->code);
+
+       bayer = fmt->code == V4L2_MBUS_FMT_SBGGR8_1X8 ||
+               fmt->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE;
+
+       /*
+        * With Bayer format enforce even side lengths, but let the user play
+        * with the starting pixel
+        */
+       if (bayer) {
+               rect->width = ALIGN(rect->width, 2);
+               rect->height = ALIGN(rect->height, 2);
+       }
+
+       if (fmt->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE) {
+               /* IFP bypass mode, no scaling */
+               mf->width = rect->width;
+               mf->height = rect->height;
+       } else {
+               /* No upscaling */
+               if (mf->width > rect->width)
+                       mf->width = rect->width;
+               if (mf->height > rect->height)
+                       mf->height = rect->height;
+       }
+
+       dev_dbg(&client->dev, "%s(): %ux%u, code=%x\n", __func__,
+               mf->width, mf->height, fmt->code);
+
+       mf->code = fmt->code;
+       mf->colorspace = fmt->colorspace;
+
+       return 0;
+}
+
+static int mt9m111_s_fmt(struct v4l2_subdev *sd,
+                        struct v4l2_mbus_framefmt *mf)
+{
+       const struct mt9m111_datafmt *fmt;
+       struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
+       struct v4l2_rect *rect = &mt9m111->rect;
+       int ret;
+
+       mt9m111_try_fmt(sd, mf);
+       fmt = mt9m111_find_datafmt(mt9m111, mf->code);
+       /* try_fmt() guarantees fmt != NULL && fmt->code == mf->code */
+
+       ret = mt9m111_setup_geometry(mt9m111, rect, mf->width, mf->height, mf->code);
+       if (!ret)
+               ret = mt9m111_set_pixfmt(mt9m111, mf->code);
+       if (!ret) {
+               mt9m111->width  = mf->width;
+               mt9m111->height = mf->height;
+               mt9m111->fmt    = fmt;
+       }
+
+       return ret;
+}
+
+static int mt9m111_g_chip_ident(struct v4l2_subdev *sd,
+                               struct v4l2_dbg_chip_ident *id)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
+
+       if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
+               return -EINVAL;
+
+       if (id->match.addr != client->addr)
+               return -ENODEV;
+
+       id->ident       = mt9m111->model;
+       id->revision    = 0;
+
+       return 0;
+}
+
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+static int mt9m111_g_register(struct v4l2_subdev *sd,
+                             struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       int val;
+
+       if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0x2ff)
+               return -EINVAL;
+       if (reg->match.addr != client->addr)
+               return -ENODEV;
+
+       val = mt9m111_reg_read(client, reg->reg);
+       reg->size = 2;
+       reg->val = (u64)val;
+
+       if (reg->val > 0xffff)
+               return -EIO;
+
+       return 0;
+}
+
+static int mt9m111_s_register(struct v4l2_subdev *sd,
+                             struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+       if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0x2ff)
+               return -EINVAL;
+
+       if (reg->match.addr != client->addr)
+               return -ENODEV;
+
+       if (mt9m111_reg_write(client, reg->reg, reg->val) < 0)
+               return -EIO;
+
+       return 0;
+}
+#endif
+
+static int mt9m111_set_flip(struct mt9m111 *mt9m111, int flip, int mask)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
+       int ret;
+
+       if (flip)
+               ret = mt9m111_reg_set(client, mt9m111->ctx->read_mode, mask);
+       else
+               ret = mt9m111_reg_clear(client, mt9m111->ctx->read_mode, mask);
+
+       return ret;
+}
+
+static int mt9m111_get_global_gain(struct mt9m111 *mt9m111)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
+       int data;
+
+       data = reg_read(GLOBAL_GAIN);
+       if (data >= 0)
+               return (data & 0x2f) * (1 << ((data >> 10) & 1)) *
+                       (1 << ((data >> 9) & 1));
+       return data;
+}
+
+static int mt9m111_set_global_gain(struct mt9m111 *mt9m111, int gain)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
+       u16 val;
+
+       if (gain > 63 * 2 * 2)
+               return -EINVAL;
+
+       if ((gain >= 64 * 2) && (gain < 63 * 2 * 2))
+               val = (1 << 10) | (1 << 9) | (gain / 4);
+       else if ((gain >= 64) && (gain < 64 * 2))
+               val = (1 << 9) | (gain / 2);
+       else
+               val = gain;
+
+       return reg_write(GLOBAL_GAIN, val);
+}
+
+static int mt9m111_set_autoexposure(struct mt9m111 *mt9m111, int on)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
+
+       if (on)
+               return reg_set(OPER_MODE_CTRL, MT9M111_OPMODE_AUTOEXPO_EN);
+       return reg_clear(OPER_MODE_CTRL, MT9M111_OPMODE_AUTOEXPO_EN);
+}
+
+static int mt9m111_set_autowhitebalance(struct mt9m111 *mt9m111, int on)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
+
+       if (on)
+               return reg_set(OPER_MODE_CTRL, MT9M111_OPMODE_AUTOWHITEBAL_EN);
+       return reg_clear(OPER_MODE_CTRL, MT9M111_OPMODE_AUTOWHITEBAL_EN);
+}
+
+static int mt9m111_s_ctrl(struct v4l2_ctrl *ctrl)
+{
+       struct mt9m111 *mt9m111 = container_of(ctrl->handler,
+                                              struct mt9m111, hdl);
+
+       switch (ctrl->id) {
+       case V4L2_CID_VFLIP:
+               return mt9m111_set_flip(mt9m111, ctrl->val,
+                                       MT9M111_RMB_MIRROR_ROWS);
+       case V4L2_CID_HFLIP:
+               return mt9m111_set_flip(mt9m111, ctrl->val,
+                                       MT9M111_RMB_MIRROR_COLS);
+       case V4L2_CID_GAIN:
+               return mt9m111_set_global_gain(mt9m111, ctrl->val);
+       case V4L2_CID_EXPOSURE_AUTO:
+               return mt9m111_set_autoexposure(mt9m111, ctrl->val);
+       case V4L2_CID_AUTO_WHITE_BALANCE:
+               return mt9m111_set_autowhitebalance(mt9m111, ctrl->val);
+       }
+
+       return -EINVAL;
+}
+
+static int mt9m111_suspend(struct mt9m111 *mt9m111)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
+       int ret;
+
+       v4l2_ctrl_s_ctrl(mt9m111->gain, mt9m111_get_global_gain(mt9m111));
+
+       ret = reg_set(RESET, MT9M111_RESET_RESET_MODE);
+       if (!ret)
+               ret = reg_set(RESET, MT9M111_RESET_RESET_SOC |
+                             MT9M111_RESET_OUTPUT_DISABLE |
+                             MT9M111_RESET_ANALOG_STANDBY);
+       if (!ret)
+               ret = reg_clear(RESET, MT9M111_RESET_CHIP_ENABLE);
+
+       return ret;
+}
+
+static void mt9m111_restore_state(struct mt9m111 *mt9m111)
+{
+       mt9m111_set_context(mt9m111, mt9m111->ctx);
+       mt9m111_set_pixfmt(mt9m111, mt9m111->fmt->code);
+       mt9m111_setup_geometry(mt9m111, &mt9m111->rect,
+                       mt9m111->width, mt9m111->height, mt9m111->fmt->code);
+       v4l2_ctrl_handler_setup(&mt9m111->hdl);
+}
+
+static int mt9m111_resume(struct mt9m111 *mt9m111)
+{
+       int ret = mt9m111_enable(mt9m111);
+       if (!ret)
+               ret = mt9m111_reset(mt9m111);
+       if (!ret)
+               mt9m111_restore_state(mt9m111);
+
+       return ret;
+}
+
+static int mt9m111_init(struct mt9m111 *mt9m111)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
+       int ret;
+
+       /* Default HIGHPOWER context */
+       mt9m111->ctx = &context_b;
+       ret = mt9m111_enable(mt9m111);
+       if (!ret)
+               ret = mt9m111_reset(mt9m111);
+       if (!ret)
+               ret = mt9m111_set_context(mt9m111, mt9m111->ctx);
+       if (ret)
+               dev_err(&client->dev, "mt9m111 init failed: %d\n", ret);
+       return ret;
+}
+
+/*
+ * Interface active, can use i2c. If it fails, it can indeed mean, that
+ * this wasn't our capture interface, so, we wait for the right one
+ */
+static int mt9m111_video_probe(struct i2c_client *client)
+{
+       struct mt9m111 *mt9m111 = to_mt9m111(client);
+       s32 data;
+       int ret;
+
+       data = reg_read(CHIP_VERSION);
+
+       switch (data) {
+       case 0x143a: /* MT9M111 or MT9M131 */
+               mt9m111->model = V4L2_IDENT_MT9M111;
+               dev_info(&client->dev,
+                       "Detected a MT9M111/MT9M131 chip ID %x\n", data);
+               break;
+       case 0x148c: /* MT9M112 */
+               mt9m111->model = V4L2_IDENT_MT9M112;
+               dev_info(&client->dev, "Detected a MT9M112 chip ID %x\n", data);
+               break;
+       default:
+               dev_err(&client->dev,
+                       "No MT9M111/MT9M112/MT9M131 chip detected register read %x\n",
+                       data);
+               return -ENODEV;
+       }
+
+       ret = mt9m111_init(mt9m111);
+       if (ret)
+               return ret;
+       return v4l2_ctrl_handler_setup(&mt9m111->hdl);
+}
+
+static int mt9m111_s_power(struct v4l2_subdev *sd, int on)
+{
+       struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       int ret = 0;
+
+       mutex_lock(&mt9m111->power_lock);
+
+       /*
+        * If the power count is modified from 0 to != 0 or from != 0 to 0,
+        * update the power state.
+        */
+       if (mt9m111->power_count == !on) {
+               if (on) {
+                       ret = mt9m111_resume(mt9m111);
+                       if (ret) {
+                               dev_err(&client->dev,
+                                       "Failed to resume the sensor: %d\n", ret);
+                               goto out;
+                       }
+               } else {
+                       mt9m111_suspend(mt9m111);
+               }
+       }
+
+       /* Update the power count. */
+       mt9m111->power_count += on ? 1 : -1;
+       WARN_ON(mt9m111->power_count < 0);
+
+out:
+       mutex_unlock(&mt9m111->power_lock);
+       return ret;
+}
+
+static const struct v4l2_ctrl_ops mt9m111_ctrl_ops = {
+       .s_ctrl = mt9m111_s_ctrl,
+};
+
+static struct v4l2_subdev_core_ops mt9m111_subdev_core_ops = {
+       .g_chip_ident   = mt9m111_g_chip_ident,
+       .s_power        = mt9m111_s_power,
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+       .g_register     = mt9m111_g_register,
+       .s_register     = mt9m111_s_register,
+#endif
+};
+
+static int mt9m111_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
+                           enum v4l2_mbus_pixelcode *code)
+{
+       if (index >= ARRAY_SIZE(mt9m111_colour_fmts))
+               return -EINVAL;
+
+       *code = mt9m111_colour_fmts[index].code;
+       return 0;
+}
+
+static int mt9m111_g_mbus_config(struct v4l2_subdev *sd,
+                               struct v4l2_mbus_config *cfg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+
+       cfg->flags = V4L2_MBUS_MASTER | V4L2_MBUS_PCLK_SAMPLE_RISING |
+               V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_HIGH |
+               V4L2_MBUS_DATA_ACTIVE_HIGH;
+       cfg->type = V4L2_MBUS_PARALLEL;
+       cfg->flags = soc_camera_apply_board_flags(icl, cfg);
+
+       return 0;
+}
+
+static struct v4l2_subdev_video_ops mt9m111_subdev_video_ops = {
+       .s_mbus_fmt     = mt9m111_s_fmt,
+       .g_mbus_fmt     = mt9m111_g_fmt,
+       .try_mbus_fmt   = mt9m111_try_fmt,
+       .s_crop         = mt9m111_s_crop,
+       .g_crop         = mt9m111_g_crop,
+       .cropcap        = mt9m111_cropcap,
+       .enum_mbus_fmt  = mt9m111_enum_fmt,
+       .g_mbus_config  = mt9m111_g_mbus_config,
+};
+
+static struct v4l2_subdev_ops mt9m111_subdev_ops = {
+       .core   = &mt9m111_subdev_core_ops,
+       .video  = &mt9m111_subdev_video_ops,
+};
+
+static int mt9m111_probe(struct i2c_client *client,
+                        const struct i2c_device_id *did)
+{
+       struct mt9m111 *mt9m111;
+       struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+       int ret;
+
+       if (!icl) {
+               dev_err(&client->dev, "mt9m111: driver needs platform data\n");
+               return -EINVAL;
+       }
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
+               dev_warn(&adapter->dev,
+                        "I2C-Adapter doesn't support I2C_FUNC_SMBUS_WORD\n");
+               return -EIO;
+       }
+
+       mt9m111 = kzalloc(sizeof(struct mt9m111), GFP_KERNEL);
+       if (!mt9m111)
+               return -ENOMEM;
+
+       v4l2_i2c_subdev_init(&mt9m111->subdev, client, &mt9m111_subdev_ops);
+       v4l2_ctrl_handler_init(&mt9m111->hdl, 5);
+       v4l2_ctrl_new_std(&mt9m111->hdl, &mt9m111_ctrl_ops,
+                       V4L2_CID_VFLIP, 0, 1, 1, 0);
+       v4l2_ctrl_new_std(&mt9m111->hdl, &mt9m111_ctrl_ops,
+                       V4L2_CID_HFLIP, 0, 1, 1, 0);
+       v4l2_ctrl_new_std(&mt9m111->hdl, &mt9m111_ctrl_ops,
+                       V4L2_CID_AUTO_WHITE_BALANCE, 0, 1, 1, 1);
+       mt9m111->gain = v4l2_ctrl_new_std(&mt9m111->hdl, &mt9m111_ctrl_ops,
+                       V4L2_CID_GAIN, 0, 63 * 2 * 2, 1, 32);
+       v4l2_ctrl_new_std_menu(&mt9m111->hdl,
+                       &mt9m111_ctrl_ops, V4L2_CID_EXPOSURE_AUTO, 1, 0,
+                       V4L2_EXPOSURE_AUTO);
+       mt9m111->subdev.ctrl_handler = &mt9m111->hdl;
+       if (mt9m111->hdl.error) {
+               int err = mt9m111->hdl.error;
+
+               kfree(mt9m111);
+               return err;
+       }
+
+       /* Second stage probe - when a capture adapter is there */
+       mt9m111->rect.left      = MT9M111_MIN_DARK_COLS;
+       mt9m111->rect.top       = MT9M111_MIN_DARK_ROWS;
+       mt9m111->rect.width     = MT9M111_MAX_WIDTH;
+       mt9m111->rect.height    = MT9M111_MAX_HEIGHT;
+       mt9m111->fmt            = &mt9m111_colour_fmts[0];
+       mt9m111->lastpage       = -1;
+       mutex_init(&mt9m111->power_lock);
+
+       ret = mt9m111_video_probe(client);
+       if (ret) {
+               v4l2_ctrl_handler_free(&mt9m111->hdl);
+               kfree(mt9m111);
+       }
+
+       return ret;
+}
+
+static int mt9m111_remove(struct i2c_client *client)
+{
+       struct mt9m111 *mt9m111 = to_mt9m111(client);
+
+       v4l2_device_unregister_subdev(&mt9m111->subdev);
+       v4l2_ctrl_handler_free(&mt9m111->hdl);
+       kfree(mt9m111);
+
+       return 0;
+}
+
+static const struct i2c_device_id mt9m111_id[] = {
+       { "mt9m111", 0 },
+       { }
+};
+MODULE_DEVICE_TABLE(i2c, mt9m111_id);
+
+static struct i2c_driver mt9m111_i2c_driver = {
+       .driver = {
+               .name = "mt9m111",
+       },
+       .probe          = mt9m111_probe,
+       .remove         = mt9m111_remove,
+       .id_table       = mt9m111_id,
+};
+
+module_i2c_driver(mt9m111_i2c_driver);
+
+MODULE_DESCRIPTION("Micron/Aptina MT9M111/MT9M112/MT9M131 Camera driver");
+MODULE_AUTHOR("Robert Jarzmik");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/i2c/soc_camera/mt9t031.c b/drivers/media/i2c/soc_camera/mt9t031.c
new file mode 100644 (file)
index 0000000..1415074
--- /dev/null
@@ -0,0 +1,857 @@
+/*
+ * Driver for MT9T031 CMOS Image Sensor from Micron
+ *
+ * Copyright (C) 2008, Guennadi Liakhovetski, DENX Software Engineering <lg@denx.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/device.h>
+#include <linux/i2c.h>
+#include <linux/log2.h>
+#include <linux/pm.h>
+#include <linux/slab.h>
+#include <linux/v4l2-mediabus.h>
+#include <linux/videodev2.h>
+#include <linux/module.h>
+
+#include <media/soc_camera.h>
+#include <media/v4l2-chip-ident.h>
+#include <media/v4l2-subdev.h>
+#include <media/v4l2-ctrls.h>
+
+/*
+ * ATTENTION: this driver still cannot be used outside of the soc-camera
+ * framework because of its PM implementation, using the video_device node.
+ * If hardware becomes available for testing, alternative PM approaches shall
+ * be considered and tested.
+ */
+
+/*
+ * mt9t031 i2c address 0x5d
+ * The platform has to define i2c_board_info and link to it from
+ * struct soc_camera_link
+ */
+
+/* mt9t031 selected register addresses */
+#define MT9T031_CHIP_VERSION           0x00
+#define MT9T031_ROW_START              0x01
+#define MT9T031_COLUMN_START           0x02
+#define MT9T031_WINDOW_HEIGHT          0x03
+#define MT9T031_WINDOW_WIDTH           0x04
+#define MT9T031_HORIZONTAL_BLANKING    0x05
+#define MT9T031_VERTICAL_BLANKING      0x06
+#define MT9T031_OUTPUT_CONTROL         0x07
+#define MT9T031_SHUTTER_WIDTH_UPPER    0x08
+#define MT9T031_SHUTTER_WIDTH          0x09
+#define MT9T031_PIXEL_CLOCK_CONTROL    0x0a
+#define MT9T031_FRAME_RESTART          0x0b
+#define MT9T031_SHUTTER_DELAY          0x0c
+#define MT9T031_RESET                  0x0d
+#define MT9T031_READ_MODE_1            0x1e
+#define MT9T031_READ_MODE_2            0x20
+#define MT9T031_READ_MODE_3            0x21
+#define MT9T031_ROW_ADDRESS_MODE       0x22
+#define MT9T031_COLUMN_ADDRESS_MODE    0x23
+#define MT9T031_GLOBAL_GAIN            0x35
+#define MT9T031_CHIP_ENABLE            0xF8
+
+#define MT9T031_MAX_HEIGHT             1536
+#define MT9T031_MAX_WIDTH              2048
+#define MT9T031_MIN_HEIGHT             2
+#define MT9T031_MIN_WIDTH              18
+#define MT9T031_HORIZONTAL_BLANK       142
+#define MT9T031_VERTICAL_BLANK         25
+#define MT9T031_COLUMN_SKIP            32
+#define MT9T031_ROW_SKIP               20
+
+struct mt9t031 {
+       struct v4l2_subdev subdev;
+       struct v4l2_ctrl_handler hdl;
+       struct {
+               /* exposure/auto-exposure cluster */
+               struct v4l2_ctrl *autoexposure;
+               struct v4l2_ctrl *exposure;
+       };
+       struct v4l2_rect rect;  /* Sensor window */
+       int model;      /* V4L2_IDENT_MT9T031* codes from v4l2-chip-ident.h */
+       u16 xskip;
+       u16 yskip;
+       unsigned int total_h;
+       unsigned short y_skip_top;      /* Lines to skip at the top */
+};
+
+static struct mt9t031 *to_mt9t031(const struct i2c_client *client)
+{
+       return container_of(i2c_get_clientdata(client), struct mt9t031, subdev);
+}
+
+static int reg_read(struct i2c_client *client, const u8 reg)
+{
+       return i2c_smbus_read_word_swapped(client, reg);
+}
+
+static int reg_write(struct i2c_client *client, const u8 reg,
+                    const u16 data)
+{
+       return i2c_smbus_write_word_swapped(client, reg, data);
+}
+
+static int reg_set(struct i2c_client *client, const u8 reg,
+                  const u16 data)
+{
+       int ret;
+
+       ret = reg_read(client, reg);
+       if (ret < 0)
+               return ret;
+       return reg_write(client, reg, ret | data);
+}
+
+static int reg_clear(struct i2c_client *client, const u8 reg,
+                    const u16 data)
+{
+       int ret;
+
+       ret = reg_read(client, reg);
+       if (ret < 0)
+               return ret;
+       return reg_write(client, reg, ret & ~data);
+}
+
+static int set_shutter(struct i2c_client *client, const u32 data)
+{
+       int ret;
+
+       ret = reg_write(client, MT9T031_SHUTTER_WIDTH_UPPER, data >> 16);
+
+       if (ret >= 0)
+               ret = reg_write(client, MT9T031_SHUTTER_WIDTH, data & 0xffff);
+
+       return ret;
+}
+
+static int get_shutter(struct i2c_client *client, u32 *data)
+{
+       int ret;
+
+       ret = reg_read(client, MT9T031_SHUTTER_WIDTH_UPPER);
+       *data = ret << 16;
+
+       if (ret >= 0)
+               ret = reg_read(client, MT9T031_SHUTTER_WIDTH);
+       *data |= ret & 0xffff;
+
+       return ret < 0 ? ret : 0;
+}
+
+static int mt9t031_idle(struct i2c_client *client)
+{
+       int ret;
+
+       /* Disable chip output, synchronous option update */
+       ret = reg_write(client, MT9T031_RESET, 1);
+       if (ret >= 0)
+               ret = reg_write(client, MT9T031_RESET, 0);
+       if (ret >= 0)
+               ret = reg_clear(client, MT9T031_OUTPUT_CONTROL, 2);
+
+       return ret >= 0 ? 0 : -EIO;
+}
+
+static int mt9t031_disable(struct i2c_client *client)
+{
+       /* Disable the chip */
+       reg_clear(client, MT9T031_OUTPUT_CONTROL, 2);
+
+       return 0;
+}
+
+static int mt9t031_s_stream(struct v4l2_subdev *sd, int enable)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       int ret;
+
+       if (enable)
+               /* Switch to master "normal" mode */
+               ret = reg_set(client, MT9T031_OUTPUT_CONTROL, 2);
+       else
+               /* Stop sensor readout */
+               ret = reg_clear(client, MT9T031_OUTPUT_CONTROL, 2);
+
+       if (ret < 0)
+               return -EIO;
+
+       return 0;
+}
+
+/* target must be _even_ */
+static u16 mt9t031_skip(s32 *source, s32 target, s32 max)
+{
+       unsigned int skip;
+
+       if (*source < target + target / 2) {
+               *source = target;
+               return 1;
+       }
+
+       skip = min(max, *source + target / 2) / target;
+       if (skip > 8)
+               skip = 8;
+       *source = target * skip;
+
+       return skip;
+}
+
+/* rect is the sensor rectangle, the caller guarantees parameter validity */
+static int mt9t031_set_params(struct i2c_client *client,
+                             struct v4l2_rect *rect, u16 xskip, u16 yskip)
+{
+       struct mt9t031 *mt9t031 = to_mt9t031(client);
+       int ret;
+       u16 xbin, ybin;
+       const u16 hblank = MT9T031_HORIZONTAL_BLANK,
+               vblank = MT9T031_VERTICAL_BLANK;
+
+       xbin = min(xskip, (u16)3);
+       ybin = min(yskip, (u16)3);
+
+       /*
+        * Could just do roundup(rect->left, [xy]bin * 2); but this is cheaper.
+        * There is always a valid suitably aligned value. The worst case is
+        * xbin = 3, width = 2048. Then we will start at 36, the last read out
+        * pixel will be 2083, which is < 2085 - first black pixel.
+        *
+        * MT9T031 datasheet imposes window left border alignment, depending on
+        * the selected xskip. Failing to conform to this requirement produces
+        * dark horizontal stripes in the image. However, even obeying to this
+        * requirement doesn't eliminate the stripes in all configurations. They
+        * appear "locally reproducibly," but can differ between tests under
+        * different lighting conditions.
+        */
+       switch (xbin) {
+       case 1:
+               rect->left &= ~1;
+               break;
+       case 2:
+               rect->left &= ~3;
+               break;
+       case 3:
+               rect->left = rect->left > roundup(MT9T031_COLUMN_SKIP, 6) ?
+                       (rect->left / 6) * 6 : roundup(MT9T031_COLUMN_SKIP, 6);
+       }
+
+       rect->top &= ~1;
+
+       dev_dbg(&client->dev, "skip %u:%u, rect %ux%u@%u:%u\n",
+               xskip, yskip, rect->width, rect->height, rect->left, rect->top);
+
+       /* Disable register update, reconfigure atomically */
+       ret = reg_set(client, MT9T031_OUTPUT_CONTROL, 1);
+       if (ret < 0)
+               return ret;
+
+       /* Blanking and start values - default... */
+       ret = reg_write(client, MT9T031_HORIZONTAL_BLANKING, hblank);
+       if (ret >= 0)
+               ret = reg_write(client, MT9T031_VERTICAL_BLANKING, vblank);
+
+       if (yskip != mt9t031->yskip || xskip != mt9t031->xskip) {
+               /* Binning, skipping */
+               if (ret >= 0)
+                       ret = reg_write(client, MT9T031_COLUMN_ADDRESS_MODE,
+                                       ((xbin - 1) << 4) | (xskip - 1));
+               if (ret >= 0)
+                       ret = reg_write(client, MT9T031_ROW_ADDRESS_MODE,
+                                       ((ybin - 1) << 4) | (yskip - 1));
+       }
+       dev_dbg(&client->dev, "new physical left %u, top %u\n",
+               rect->left, rect->top);
+
+       /*
+        * The caller provides a supported format, as guaranteed by
+        * .try_mbus_fmt(), soc_camera_s_crop() and soc_camera_cropcap()
+        */
+       if (ret >= 0)
+               ret = reg_write(client, MT9T031_COLUMN_START, rect->left);
+       if (ret >= 0)
+               ret = reg_write(client, MT9T031_ROW_START, rect->top);
+       if (ret >= 0)
+               ret = reg_write(client, MT9T031_WINDOW_WIDTH, rect->width - 1);
+       if (ret >= 0)
+               ret = reg_write(client, MT9T031_WINDOW_HEIGHT,
+                               rect->height + mt9t031->y_skip_top - 1);
+       if (ret >= 0 && v4l2_ctrl_g_ctrl(mt9t031->autoexposure) == V4L2_EXPOSURE_AUTO) {
+               mt9t031->total_h = rect->height + mt9t031->y_skip_top + vblank;
+
+               ret = set_shutter(client, mt9t031->total_h);
+       }
+
+       /* Re-enable register update, commit all changes */
+       if (ret >= 0)
+               ret = reg_clear(client, MT9T031_OUTPUT_CONTROL, 1);
+
+       if (ret >= 0) {
+               mt9t031->rect = *rect;
+               mt9t031->xskip = xskip;
+               mt9t031->yskip = yskip;
+       }
+
+       return ret < 0 ? ret : 0;
+}
+
+static int mt9t031_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+       struct v4l2_rect rect = a->c;
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9t031 *mt9t031 = to_mt9t031(client);
+
+       rect.width = ALIGN(rect.width, 2);
+       rect.height = ALIGN(rect.height, 2);
+
+       soc_camera_limit_side(&rect.left, &rect.width,
+                    MT9T031_COLUMN_SKIP, MT9T031_MIN_WIDTH, MT9T031_MAX_WIDTH);
+
+       soc_camera_limit_side(&rect.top, &rect.height,
+                    MT9T031_ROW_SKIP, MT9T031_MIN_HEIGHT, MT9T031_MAX_HEIGHT);
+
+       return mt9t031_set_params(client, &rect, mt9t031->xskip, mt9t031->yskip);
+}
+
+static int mt9t031_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9t031 *mt9t031 = to_mt9t031(client);
+
+       a->c    = mt9t031->rect;
+       a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+       return 0;
+}
+
+static int mt9t031_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
+{
+       a->bounds.left                  = MT9T031_COLUMN_SKIP;
+       a->bounds.top                   = MT9T031_ROW_SKIP;
+       a->bounds.width                 = MT9T031_MAX_WIDTH;
+       a->bounds.height                = MT9T031_MAX_HEIGHT;
+       a->defrect                      = a->bounds;
+       a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+       a->pixelaspect.numerator        = 1;
+       a->pixelaspect.denominator      = 1;
+
+       return 0;
+}
+
+static int mt9t031_g_fmt(struct v4l2_subdev *sd,
+                        struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9t031 *mt9t031 = to_mt9t031(client);
+
+       mf->width       = mt9t031->rect.width / mt9t031->xskip;
+       mf->height      = mt9t031->rect.height / mt9t031->yskip;
+       mf->code        = V4L2_MBUS_FMT_SBGGR10_1X10;
+       mf->colorspace  = V4L2_COLORSPACE_SRGB;
+       mf->field       = V4L2_FIELD_NONE;
+
+       return 0;
+}
+
+static int mt9t031_s_fmt(struct v4l2_subdev *sd,
+                        struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9t031 *mt9t031 = to_mt9t031(client);
+       u16 xskip, yskip;
+       struct v4l2_rect rect = mt9t031->rect;
+
+       /*
+        * try_fmt has put width and height within limits.
+        * S_FMT: use binning and skipping for scaling
+        */
+       xskip = mt9t031_skip(&rect.width, mf->width, MT9T031_MAX_WIDTH);
+       yskip = mt9t031_skip(&rect.height, mf->height, MT9T031_MAX_HEIGHT);
+
+       mf->code        = V4L2_MBUS_FMT_SBGGR10_1X10;
+       mf->colorspace  = V4L2_COLORSPACE_SRGB;
+
+       /* mt9t031_set_params() doesn't change width and height */
+       return mt9t031_set_params(client, &rect, xskip, yskip);
+}
+
+/*
+ * If a user window larger than sensor window is requested, we'll increase the
+ * sensor window.
+ */
+static int mt9t031_try_fmt(struct v4l2_subdev *sd,
+                          struct v4l2_mbus_framefmt *mf)
+{
+       v4l_bound_align_image(
+               &mf->width, MT9T031_MIN_WIDTH, MT9T031_MAX_WIDTH, 1,
+               &mf->height, MT9T031_MIN_HEIGHT, MT9T031_MAX_HEIGHT, 1, 0);
+
+       mf->code        = V4L2_MBUS_FMT_SBGGR10_1X10;
+       mf->colorspace  = V4L2_COLORSPACE_SRGB;
+
+       return 0;
+}
+
+static int mt9t031_g_chip_ident(struct v4l2_subdev *sd,
+                               struct v4l2_dbg_chip_ident *id)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9t031 *mt9t031 = to_mt9t031(client);
+
+       if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
+               return -EINVAL;
+
+       if (id->match.addr != client->addr)
+               return -ENODEV;
+
+       id->ident       = mt9t031->model;
+       id->revision    = 0;
+
+       return 0;
+}
+
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+static int mt9t031_g_register(struct v4l2_subdev *sd,
+                             struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+       if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
+               return -EINVAL;
+
+       if (reg->match.addr != client->addr)
+               return -ENODEV;
+
+       reg->val = reg_read(client, reg->reg);
+
+       if (reg->val > 0xffff)
+               return -EIO;
+
+       return 0;
+}
+
+static int mt9t031_s_register(struct v4l2_subdev *sd,
+                             struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+       if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
+               return -EINVAL;
+
+       if (reg->match.addr != client->addr)
+               return -ENODEV;
+
+       if (reg_write(client, reg->reg, reg->val) < 0)
+               return -EIO;
+
+       return 0;
+}
+#endif
+
+static int mt9t031_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
+{
+       struct mt9t031 *mt9t031 = container_of(ctrl->handler,
+                                              struct mt9t031, hdl);
+       const u32 shutter_max = MT9T031_MAX_HEIGHT + MT9T031_VERTICAL_BLANK;
+       s32 min, max;
+
+       switch (ctrl->id) {
+       case V4L2_CID_EXPOSURE_AUTO:
+               min = mt9t031->exposure->minimum;
+               max = mt9t031->exposure->maximum;
+               mt9t031->exposure->val =
+                       (shutter_max / 2 + (mt9t031->total_h - 1) * (max - min))
+                               / shutter_max + min;
+               break;
+       }
+       return 0;
+}
+
+static int mt9t031_s_ctrl(struct v4l2_ctrl *ctrl)
+{
+       struct mt9t031 *mt9t031 = container_of(ctrl->handler,
+                                              struct mt9t031, hdl);
+       struct v4l2_subdev *sd = &mt9t031->subdev;
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct v4l2_ctrl *exp = mt9t031->exposure;
+       int data;
+
+       switch (ctrl->id) {
+       case V4L2_CID_VFLIP:
+               if (ctrl->val)
+                       data = reg_set(client, MT9T031_READ_MODE_2, 0x8000);
+               else
+                       data = reg_clear(client, MT9T031_READ_MODE_2, 0x8000);
+               if (data < 0)
+                       return -EIO;
+               return 0;
+       case V4L2_CID_HFLIP:
+               if (ctrl->val)
+                       data = reg_set(client, MT9T031_READ_MODE_2, 0x4000);
+               else
+                       data = reg_clear(client, MT9T031_READ_MODE_2, 0x4000);
+               if (data < 0)
+                       return -EIO;
+               return 0;
+       case V4L2_CID_GAIN:
+               /* See Datasheet Table 7, Gain settings. */
+               if (ctrl->val <= ctrl->default_value) {
+                       /* Pack it into 0..1 step 0.125, register values 0..8 */
+                       unsigned long range = ctrl->default_value - ctrl->minimum;
+                       data = ((ctrl->val - ctrl->minimum) * 8 + range / 2) / range;
+
+                       dev_dbg(&client->dev, "Setting gain %d\n", data);
+                       data = reg_write(client, MT9T031_GLOBAL_GAIN, data);
+                       if (data < 0)
+                               return -EIO;
+               } else {
+                       /* Pack it into 1.125..128 variable step, register values 9..0x7860 */
+                       /* We assume qctrl->maximum - qctrl->default_value - 1 > 0 */
+                       unsigned long range = ctrl->maximum - ctrl->default_value - 1;
+                       /* calculated gain: map 65..127 to 9..1024 step 0.125 */
+                       unsigned long gain = ((ctrl->val - ctrl->default_value - 1) *
+                                              1015 + range / 2) / range + 9;
+
+                       if (gain <= 32)         /* calculated gain 9..32 -> 9..32 */
+                               data = gain;
+                       else if (gain <= 64)    /* calculated gain 33..64 -> 0x51..0x60 */
+                               data = ((gain - 32) * 16 + 16) / 32 + 80;
+                       else
+                               /* calculated gain 65..1024 -> (1..120) << 8 + 0x60 */
+                               data = (((gain - 64 + 7) * 32) & 0xff00) | 0x60;
+
+                       dev_dbg(&client->dev, "Set gain from 0x%x to 0x%x\n",
+                               reg_read(client, MT9T031_GLOBAL_GAIN), data);
+                       data = reg_write(client, MT9T031_GLOBAL_GAIN, data);
+                       if (data < 0)
+                               return -EIO;
+               }
+               return 0;
+
+       case V4L2_CID_EXPOSURE_AUTO:
+               if (ctrl->val == V4L2_EXPOSURE_MANUAL) {
+                       unsigned int range = exp->maximum - exp->minimum;
+                       unsigned int shutter = ((exp->val - exp->minimum) * 1048 +
+                                                range / 2) / range + 1;
+                       u32 old;
+
+                       get_shutter(client, &old);
+                       dev_dbg(&client->dev, "Set shutter from %u to %u\n",
+                               old, shutter);
+                       if (set_shutter(client, shutter) < 0)
+                               return -EIO;
+               } else {
+                       const u16 vblank = MT9T031_VERTICAL_BLANK;
+                       mt9t031->total_h = mt9t031->rect.height +
+                               mt9t031->y_skip_top + vblank;
+
+                       if (set_shutter(client, mt9t031->total_h) < 0)
+                               return -EIO;
+               }
+               return 0;
+       default:
+               return -EINVAL;
+       }
+       return 0;
+}
+
+/*
+ * Power Management:
+ * This function does nothing for now but must be present for pm to work
+ */
+static int mt9t031_runtime_suspend(struct device *dev)
+{
+       return 0;
+}
+
+/*
+ * Power Management:
+ * COLUMN_ADDRESS_MODE and ROW_ADDRESS_MODE are not rewritten if unchanged
+ * they are however changed at reset if the platform hook is present
+ * thus we rewrite them with the values stored by the driver
+ */
+static int mt9t031_runtime_resume(struct device *dev)
+{
+       struct video_device *vdev = to_video_device(dev);
+       struct v4l2_subdev *sd = soc_camera_vdev_to_subdev(vdev);
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9t031 *mt9t031 = to_mt9t031(client);
+
+       int ret;
+       u16 xbin, ybin;
+
+       xbin = min(mt9t031->xskip, (u16)3);
+       ybin = min(mt9t031->yskip, (u16)3);
+
+       ret = reg_write(client, MT9T031_COLUMN_ADDRESS_MODE,
+               ((xbin - 1) << 4) | (mt9t031->xskip - 1));
+       if (ret < 0)
+               return ret;
+
+       ret = reg_write(client, MT9T031_ROW_ADDRESS_MODE,
+               ((ybin - 1) << 4) | (mt9t031->yskip - 1));
+       if (ret < 0)
+               return ret;
+
+       return 0;
+}
+
+static struct dev_pm_ops mt9t031_dev_pm_ops = {
+       .runtime_suspend        = mt9t031_runtime_suspend,
+       .runtime_resume         = mt9t031_runtime_resume,
+};
+
+static struct device_type mt9t031_dev_type = {
+       .name   = "MT9T031",
+       .pm     = &mt9t031_dev_pm_ops,
+};
+
+static int mt9t031_s_power(struct v4l2_subdev *sd, int on)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct video_device *vdev = soc_camera_i2c_to_vdev(client);
+
+       if (on)
+               vdev->dev.type = &mt9t031_dev_type;
+       else
+               vdev->dev.type = NULL;
+
+       return 0;
+}
+
+/*
+ * Interface active, can use i2c. If it fails, it can indeed mean, that
+ * this wasn't our capture interface, so, we wait for the right one
+ */
+static int mt9t031_video_probe(struct i2c_client *client)
+{
+       struct mt9t031 *mt9t031 = to_mt9t031(client);
+       s32 data;
+       int ret;
+
+       /* Enable the chip */
+       data = reg_write(client, MT9T031_CHIP_ENABLE, 1);
+       dev_dbg(&client->dev, "write: %d\n", data);
+
+       /* Read out the chip version register */
+       data = reg_read(client, MT9T031_CHIP_VERSION);
+
+       switch (data) {
+       case 0x1621:
+               mt9t031->model = V4L2_IDENT_MT9T031;
+               break;
+       default:
+               dev_err(&client->dev,
+                       "No MT9T031 chip detected, register read %x\n", data);
+               return -ENODEV;
+       }
+
+       dev_info(&client->dev, "Detected a MT9T031 chip ID %x\n", data);
+
+       ret = mt9t031_idle(client);
+       if (ret < 0)
+               dev_err(&client->dev, "Failed to initialise the camera\n");
+       else
+               v4l2_ctrl_handler_setup(&mt9t031->hdl);
+
+       return ret;
+}
+
+static int mt9t031_g_skip_top_lines(struct v4l2_subdev *sd, u32 *lines)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9t031 *mt9t031 = to_mt9t031(client);
+
+       *lines = mt9t031->y_skip_top;
+
+       return 0;
+}
+
+static const struct v4l2_ctrl_ops mt9t031_ctrl_ops = {
+       .g_volatile_ctrl = mt9t031_g_volatile_ctrl,
+       .s_ctrl = mt9t031_s_ctrl,
+};
+
+static struct v4l2_subdev_core_ops mt9t031_subdev_core_ops = {
+       .g_chip_ident   = mt9t031_g_chip_ident,
+       .s_power        = mt9t031_s_power,
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+       .g_register     = mt9t031_g_register,
+       .s_register     = mt9t031_s_register,
+#endif
+};
+
+static int mt9t031_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
+                           enum v4l2_mbus_pixelcode *code)
+{
+       if (index)
+               return -EINVAL;
+
+       *code = V4L2_MBUS_FMT_SBGGR10_1X10;
+       return 0;
+}
+
+static int mt9t031_g_mbus_config(struct v4l2_subdev *sd,
+                               struct v4l2_mbus_config *cfg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+
+       cfg->flags = V4L2_MBUS_MASTER | V4L2_MBUS_PCLK_SAMPLE_RISING |
+               V4L2_MBUS_PCLK_SAMPLE_FALLING | V4L2_MBUS_HSYNC_ACTIVE_HIGH |
+               V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_DATA_ACTIVE_HIGH;
+       cfg->type = V4L2_MBUS_PARALLEL;
+       cfg->flags = soc_camera_apply_board_flags(icl, cfg);
+
+       return 0;
+}
+
+static int mt9t031_s_mbus_config(struct v4l2_subdev *sd,
+                               const struct v4l2_mbus_config *cfg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+
+       if (soc_camera_apply_board_flags(icl, cfg) &
+           V4L2_MBUS_PCLK_SAMPLE_FALLING)
+               return reg_clear(client, MT9T031_PIXEL_CLOCK_CONTROL, 0x8000);
+       else
+               return reg_set(client, MT9T031_PIXEL_CLOCK_CONTROL, 0x8000);
+}
+
+static struct v4l2_subdev_video_ops mt9t031_subdev_video_ops = {
+       .s_stream       = mt9t031_s_stream,
+       .s_mbus_fmt     = mt9t031_s_fmt,
+       .g_mbus_fmt     = mt9t031_g_fmt,
+       .try_mbus_fmt   = mt9t031_try_fmt,
+       .s_crop         = mt9t031_s_crop,
+       .g_crop         = mt9t031_g_crop,
+       .cropcap        = mt9t031_cropcap,
+       .enum_mbus_fmt  = mt9t031_enum_fmt,
+       .g_mbus_config  = mt9t031_g_mbus_config,
+       .s_mbus_config  = mt9t031_s_mbus_config,
+};
+
+static struct v4l2_subdev_sensor_ops mt9t031_subdev_sensor_ops = {
+       .g_skip_top_lines       = mt9t031_g_skip_top_lines,
+};
+
+static struct v4l2_subdev_ops mt9t031_subdev_ops = {
+       .core   = &mt9t031_subdev_core_ops,
+       .video  = &mt9t031_subdev_video_ops,
+       .sensor = &mt9t031_subdev_sensor_ops,
+};
+
+static int mt9t031_probe(struct i2c_client *client,
+                        const struct i2c_device_id *did)
+{
+       struct mt9t031 *mt9t031;
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+       struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
+       int ret;
+
+       if (!icl) {
+               dev_err(&client->dev, "MT9T031 driver needs platform data\n");
+               return -EINVAL;
+       }
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
+               dev_warn(&adapter->dev,
+                        "I2C-Adapter doesn't support I2C_FUNC_SMBUS_WORD\n");
+               return -EIO;
+       }
+
+       mt9t031 = kzalloc(sizeof(struct mt9t031), GFP_KERNEL);
+       if (!mt9t031)
+               return -ENOMEM;
+
+       v4l2_i2c_subdev_init(&mt9t031->subdev, client, &mt9t031_subdev_ops);
+       v4l2_ctrl_handler_init(&mt9t031->hdl, 5);
+       v4l2_ctrl_new_std(&mt9t031->hdl, &mt9t031_ctrl_ops,
+                       V4L2_CID_VFLIP, 0, 1, 1, 0);
+       v4l2_ctrl_new_std(&mt9t031->hdl, &mt9t031_ctrl_ops,
+                       V4L2_CID_HFLIP, 0, 1, 1, 0);
+       v4l2_ctrl_new_std(&mt9t031->hdl, &mt9t031_ctrl_ops,
+                       V4L2_CID_GAIN, 0, 127, 1, 64);
+
+       /*
+        * Simulated autoexposure. If enabled, we calculate shutter width
+        * ourselves in the driver based on vertical blanking and frame width
+        */
+       mt9t031->autoexposure = v4l2_ctrl_new_std_menu(&mt9t031->hdl,
+                       &mt9t031_ctrl_ops, V4L2_CID_EXPOSURE_AUTO, 1, 0,
+                       V4L2_EXPOSURE_AUTO);
+       mt9t031->exposure = v4l2_ctrl_new_std(&mt9t031->hdl, &mt9t031_ctrl_ops,
+                       V4L2_CID_EXPOSURE, 1, 255, 1, 255);
+
+       mt9t031->subdev.ctrl_handler = &mt9t031->hdl;
+       if (mt9t031->hdl.error) {
+               int err = mt9t031->hdl.error;
+
+               kfree(mt9t031);
+               return err;
+       }
+       v4l2_ctrl_auto_cluster(2, &mt9t031->autoexposure,
+                               V4L2_EXPOSURE_MANUAL, true);
+
+       mt9t031->y_skip_top     = 0;
+       mt9t031->rect.left      = MT9T031_COLUMN_SKIP;
+       mt9t031->rect.top       = MT9T031_ROW_SKIP;
+       mt9t031->rect.width     = MT9T031_MAX_WIDTH;
+       mt9t031->rect.height    = MT9T031_MAX_HEIGHT;
+
+       mt9t031->xskip = 1;
+       mt9t031->yskip = 1;
+
+       mt9t031_idle(client);
+
+       ret = mt9t031_video_probe(client);
+
+       mt9t031_disable(client);
+
+       if (ret) {
+               v4l2_ctrl_handler_free(&mt9t031->hdl);
+               kfree(mt9t031);
+       }
+
+       return ret;
+}
+
+static int mt9t031_remove(struct i2c_client *client)
+{
+       struct mt9t031 *mt9t031 = to_mt9t031(client);
+
+       v4l2_device_unregister_subdev(&mt9t031->subdev);
+       v4l2_ctrl_handler_free(&mt9t031->hdl);
+       kfree(mt9t031);
+
+       return 0;
+}
+
+static const struct i2c_device_id mt9t031_id[] = {
+       { "mt9t031", 0 },
+       { }
+};
+MODULE_DEVICE_TABLE(i2c, mt9t031_id);
+
+static struct i2c_driver mt9t031_i2c_driver = {
+       .driver = {
+               .name = "mt9t031",
+       },
+       .probe          = mt9t031_probe,
+       .remove         = mt9t031_remove,
+       .id_table       = mt9t031_id,
+};
+
+module_i2c_driver(mt9t031_i2c_driver);
+
+MODULE_DESCRIPTION("Micron MT9T031 Camera driver");
+MODULE_AUTHOR("Guennadi Liakhovetski <lg@denx.de>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/i2c/soc_camera/mt9t112.c b/drivers/media/i2c/soc_camera/mt9t112.c
new file mode 100644 (file)
index 0000000..e1ae46a
--- /dev/null
@@ -0,0 +1,1125 @@
+/*
+ * mt9t112 Camera Driver
+ *
+ * Copyright (C) 2009 Renesas Solutions Corp.
+ * Kuninori Morimoto <morimoto.kuninori@renesas.com>
+ *
+ * Based on ov772x driver, mt9m111 driver,
+ *
+ * Copyright (C) 2008 Kuninori Morimoto <morimoto.kuninori@renesas.com>
+ * Copyright (C) 2008, Robert Jarzmik <robert.jarzmik@free.fr>
+ * Copyright 2006-7 Jonathan Corbet <corbet@lwn.net>
+ * Copyright (C) 2008 Magnus Damm
+ * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/v4l2-mediabus.h>
+#include <linux/videodev2.h>
+
+#include <media/mt9t112.h>
+#include <media/soc_camera.h>
+#include <media/v4l2-chip-ident.h>
+#include <media/v4l2-common.h>
+
+/* you can check PLL/clock info */
+/* #define EXT_CLOCK 24000000 */
+
+/************************************************************************
+                       macro
+************************************************************************/
+/*
+ * frame size
+ */
+#define MAX_WIDTH   2048
+#define MAX_HEIGHT  1536
+
+#define VGA_WIDTH   640
+#define VGA_HEIGHT  480
+
+/*
+ * macro of read/write
+ */
+#define ECHECKER(ret, x)               \
+       do {                            \
+               (ret) = (x);            \
+               if ((ret) < 0)          \
+                       return (ret);   \
+       } while (0)
+
+#define mt9t112_reg_write(ret, client, a, b) \
+       ECHECKER(ret, __mt9t112_reg_write(client, a, b))
+#define mt9t112_mcu_write(ret, client, a, b) \
+       ECHECKER(ret, __mt9t112_mcu_write(client, a, b))
+
+#define mt9t112_reg_mask_set(ret, client, a, b, c) \
+       ECHECKER(ret, __mt9t112_reg_mask_set(client, a, b, c))
+#define mt9t112_mcu_mask_set(ret, client, a, b, c) \
+       ECHECKER(ret, __mt9t112_mcu_mask_set(client, a, b, c))
+
+#define mt9t112_reg_read(ret, client, a) \
+       ECHECKER(ret, __mt9t112_reg_read(client, a))
+
+/*
+ * Logical address
+ */
+#define _VAR(id, offset, base) (base | (id & 0x1f) << 10 | (offset & 0x3ff))
+#define VAR(id, offset)  _VAR(id, offset, 0x0000)
+#define VAR8(id, offset) _VAR(id, offset, 0x8000)
+
+/************************************************************************
+                       struct
+************************************************************************/
+struct mt9t112_format {
+       enum v4l2_mbus_pixelcode code;
+       enum v4l2_colorspace colorspace;
+       u16 fmt;
+       u16 order;
+};
+
+struct mt9t112_priv {
+       struct v4l2_subdev               subdev;
+       struct mt9t112_camera_info      *info;
+       struct i2c_client               *client;
+       struct v4l2_rect                 frame;
+       const struct mt9t112_format     *format;
+       int                              model;
+       u32                              flags;
+/* for flags */
+#define INIT_DONE      (1 << 0)
+#define PCLK_RISING    (1 << 1)
+};
+
+/************************************************************************
+                       supported format
+************************************************************************/
+
+static const struct mt9t112_format mt9t112_cfmts[] = {
+       {
+               .code           = V4L2_MBUS_FMT_UYVY8_2X8,
+               .colorspace     = V4L2_COLORSPACE_JPEG,
+               .fmt            = 1,
+               .order          = 0,
+       }, {
+               .code           = V4L2_MBUS_FMT_VYUY8_2X8,
+               .colorspace     = V4L2_COLORSPACE_JPEG,
+               .fmt            = 1,
+               .order          = 1,
+       }, {
+               .code           = V4L2_MBUS_FMT_YUYV8_2X8,
+               .colorspace     = V4L2_COLORSPACE_JPEG,
+               .fmt            = 1,
+               .order          = 2,
+       }, {
+               .code           = V4L2_MBUS_FMT_YVYU8_2X8,
+               .colorspace     = V4L2_COLORSPACE_JPEG,
+               .fmt            = 1,
+               .order          = 3,
+       }, {
+               .code           = V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE,
+               .colorspace     = V4L2_COLORSPACE_SRGB,
+               .fmt            = 8,
+               .order          = 2,
+       }, {
+               .code           = V4L2_MBUS_FMT_RGB565_2X8_LE,
+               .colorspace     = V4L2_COLORSPACE_SRGB,
+               .fmt            = 4,
+               .order          = 2,
+       },
+};
+
+/************************************************************************
+                       general function
+************************************************************************/
+static struct mt9t112_priv *to_mt9t112(const struct i2c_client *client)
+{
+       return container_of(i2c_get_clientdata(client),
+                           struct mt9t112_priv,
+                           subdev);
+}
+
+static int __mt9t112_reg_read(const struct i2c_client *client, u16 command)
+{
+       struct i2c_msg msg[2];
+       u8 buf[2];
+       int ret;
+
+       command = swab16(command);
+
+       msg[0].addr  = client->addr;
+       msg[0].flags = 0;
+       msg[0].len   = 2;
+       msg[0].buf   = (u8 *)&command;
+
+       msg[1].addr  = client->addr;
+       msg[1].flags = I2C_M_RD;
+       msg[1].len   = 2;
+       msg[1].buf   = buf;
+
+       /*
+        * if return value of this function is < 0,
+        * it mean error.
+        * else, under 16bit is valid data.
+        */
+       ret = i2c_transfer(client->adapter, msg, 2);
+       if (ret < 0)
+               return ret;
+
+       memcpy(&ret, buf, 2);
+       return swab16(ret);
+}
+
+static int __mt9t112_reg_write(const struct i2c_client *client,
+                              u16 command, u16 data)
+{
+       struct i2c_msg msg;
+       u8 buf[4];
+       int ret;
+
+       command = swab16(command);
+       data = swab16(data);
+
+       memcpy(buf + 0, &command, 2);
+       memcpy(buf + 2, &data,    2);
+
+       msg.addr  = client->addr;
+       msg.flags = 0;
+       msg.len   = 4;
+       msg.buf   = buf;
+
+       /*
+        * i2c_transfer return message length,
+        * but this function should return 0 if correct case
+        */
+       ret = i2c_transfer(client->adapter, &msg, 1);
+       if (ret >= 0)
+               ret = 0;
+
+       return ret;
+}
+
+static int __mt9t112_reg_mask_set(const struct i2c_client *client,
+                                 u16  command,
+                                 u16  mask,
+                                 u16  set)
+{
+       int val = __mt9t112_reg_read(client, command);
+       if (val < 0)
+               return val;
+
+       val &= ~mask;
+       val |= set & mask;
+
+       return __mt9t112_reg_write(client, command, val);
+}
+
+/* mcu access */
+static int __mt9t112_mcu_read(const struct i2c_client *client, u16 command)
+{
+       int ret;
+
+       ret = __mt9t112_reg_write(client, 0x098E, command);
+       if (ret < 0)
+               return ret;
+
+       return __mt9t112_reg_read(client, 0x0990);
+}
+
+static int __mt9t112_mcu_write(const struct i2c_client *client,
+                              u16 command, u16 data)
+{
+       int ret;
+
+       ret = __mt9t112_reg_write(client, 0x098E, command);
+       if (ret < 0)
+               return ret;
+
+       return __mt9t112_reg_write(client, 0x0990, data);
+}
+
+static int __mt9t112_mcu_mask_set(const struct i2c_client *client,
+                                 u16  command,
+                                 u16  mask,
+                                 u16  set)
+{
+       int val = __mt9t112_mcu_read(client, command);
+       if (val < 0)
+               return val;
+
+       val &= ~mask;
+       val |= set & mask;
+
+       return __mt9t112_mcu_write(client, command, val);
+}
+
+static int mt9t112_reset(const struct i2c_client *client)
+{
+       int ret;
+
+       mt9t112_reg_mask_set(ret, client, 0x001a, 0x0001, 0x0001);
+       msleep(1);
+       mt9t112_reg_mask_set(ret, client, 0x001a, 0x0001, 0x0000);
+
+       return ret;
+}
+
+#ifndef EXT_CLOCK
+#define CLOCK_INFO(a, b)
+#else
+#define CLOCK_INFO(a, b) mt9t112_clock_info(a, b)
+static int mt9t112_clock_info(const struct i2c_client *client, u32 ext)
+{
+       int m, n, p1, p2, p3, p4, p5, p6, p7;
+       u32 vco, clk;
+       char *enable;
+
+       ext /= 1000; /* kbyte order */
+
+       mt9t112_reg_read(n, client, 0x0012);
+       p1 = n & 0x000f;
+       n = n >> 4;
+       p2 = n & 0x000f;
+       n = n >> 4;
+       p3 = n & 0x000f;
+
+       mt9t112_reg_read(n, client, 0x002a);
+       p4 = n & 0x000f;
+       n = n >> 4;
+       p5 = n & 0x000f;
+       n = n >> 4;
+       p6 = n & 0x000f;
+
+       mt9t112_reg_read(n, client, 0x002c);
+       p7 = n & 0x000f;
+
+       mt9t112_reg_read(n, client, 0x0010);
+       m = n & 0x00ff;
+       n = (n >> 8) & 0x003f;
+
+       enable = ((6000 > ext) || (54000 < ext)) ? "X" : "";
+       dev_dbg(&client->dev, "EXTCLK          : %10u K %s\n", ext, enable);
+
+       vco = 2 * m * ext / (n+1);
+       enable = ((384000 > vco) || (768000 < vco)) ? "X" : "";
+       dev_dbg(&client->dev, "VCO             : %10u K %s\n", vco, enable);
+
+       clk = vco / (p1+1) / (p2+1);
+       enable = (96000 < clk) ? "X" : "";
+       dev_dbg(&client->dev, "PIXCLK          : %10u K %s\n", clk, enable);
+
+       clk = vco / (p3+1);
+       enable = (768000 < clk) ? "X" : "";
+       dev_dbg(&client->dev, "MIPICLK         : %10u K %s\n", clk, enable);
+
+       clk = vco / (p6+1);
+       enable = (96000 < clk) ? "X" : "";
+       dev_dbg(&client->dev, "MCU CLK         : %10u K %s\n", clk, enable);
+
+       clk = vco / (p5+1);
+       enable = (54000 < clk) ? "X" : "";
+       dev_dbg(&client->dev, "SOC CLK         : %10u K %s\n", clk, enable);
+
+       clk = vco / (p4+1);
+       enable = (70000 < clk) ? "X" : "";
+       dev_dbg(&client->dev, "Sensor CLK      : %10u K %s\n", clk, enable);
+
+       clk = vco / (p7+1);
+       dev_dbg(&client->dev, "External sensor : %10u K\n", clk);
+
+       clk = ext / (n+1);
+       enable = ((2000 > clk) || (24000 < clk)) ? "X" : "";
+       dev_dbg(&client->dev, "PFD             : %10u K %s\n", clk, enable);
+
+       return 0;
+}
+#endif
+
+static void mt9t112_frame_check(u32 *width, u32 *height, u32 *left, u32 *top)
+{
+       soc_camera_limit_side(left, width, 0, 0, MAX_WIDTH);
+       soc_camera_limit_side(top, height, 0, 0, MAX_HEIGHT);
+}
+
+static int mt9t112_set_a_frame_size(const struct i2c_client *client,
+                                  u16 width,
+                                  u16 height)
+{
+       int ret;
+       u16 wstart = (MAX_WIDTH - width) / 2;
+       u16 hstart = (MAX_HEIGHT - height) / 2;
+
+       /* (Context A) Image Width/Height */
+       mt9t112_mcu_write(ret, client, VAR(26, 0), width);
+       mt9t112_mcu_write(ret, client, VAR(26, 2), height);
+
+       /* (Context A) Output Width/Height */
+       mt9t112_mcu_write(ret, client, VAR(18, 43), 8 + width);
+       mt9t112_mcu_write(ret, client, VAR(18, 45), 8 + height);
+
+       /* (Context A) Start Row/Column */
+       mt9t112_mcu_write(ret, client, VAR(18, 2), 4 + hstart);
+       mt9t112_mcu_write(ret, client, VAR(18, 4), 4 + wstart);
+
+       /* (Context A) End Row/Column */
+       mt9t112_mcu_write(ret, client, VAR(18, 6), 11 + height + hstart);
+       mt9t112_mcu_write(ret, client, VAR(18, 8), 11 + width  + wstart);
+
+       mt9t112_mcu_write(ret, client, VAR8(1, 0), 0x06);
+
+       return ret;
+}
+
+static int mt9t112_set_pll_dividers(const struct i2c_client *client,
+                                   u8 m, u8 n,
+                                   u8 p1, u8 p2, u8 p3,
+                                   u8 p4, u8 p5, u8 p6,
+                                   u8 p7)
+{
+       int ret;
+       u16 val;
+
+       /* N/M */
+       val = (n << 8) |
+             (m << 0);
+       mt9t112_reg_mask_set(ret, client, 0x0010, 0x3fff, val);
+
+       /* P1/P2/P3 */
+       val = ((p3 & 0x0F) << 8) |
+             ((p2 & 0x0F) << 4) |
+             ((p1 & 0x0F) << 0);
+       mt9t112_reg_mask_set(ret, client, 0x0012, 0x0fff, val);
+
+       /* P4/P5/P6 */
+       val = (0x7         << 12) |
+             ((p6 & 0x0F) <<  8) |
+             ((p5 & 0x0F) <<  4) |
+             ((p4 & 0x0F) <<  0);
+       mt9t112_reg_mask_set(ret, client, 0x002A, 0x7fff, val);
+
+       /* P7 */
+       val = (0x1         << 12) |
+             ((p7 & 0x0F) <<  0);
+       mt9t112_reg_mask_set(ret, client, 0x002C, 0x100f, val);
+
+       return ret;
+}
+
+static int mt9t112_init_pll(const struct i2c_client *client)
+{
+       struct mt9t112_priv *priv = to_mt9t112(client);
+       int data, i, ret;
+
+       mt9t112_reg_mask_set(ret, client, 0x0014, 0x003, 0x0001);
+
+       /* PLL control: BYPASS PLL = 8517 */
+       mt9t112_reg_write(ret, client, 0x0014, 0x2145);
+
+       /* Replace these registers when new timing parameters are generated */
+       mt9t112_set_pll_dividers(client,
+                                priv->info->divider.m,
+                                priv->info->divider.n,
+                                priv->info->divider.p1,
+                                priv->info->divider.p2,
+                                priv->info->divider.p3,
+                                priv->info->divider.p4,
+                                priv->info->divider.p5,
+                                priv->info->divider.p6,
+                                priv->info->divider.p7);
+
+       /*
+        * TEST_BYPASS  on
+        * PLL_ENABLE   on
+        * SEL_LOCK_DET on
+        * TEST_BYPASS  off
+        */
+       mt9t112_reg_write(ret, client, 0x0014, 0x2525);
+       mt9t112_reg_write(ret, client, 0x0014, 0x2527);
+       mt9t112_reg_write(ret, client, 0x0014, 0x3427);
+       mt9t112_reg_write(ret, client, 0x0014, 0x3027);
+
+       mdelay(10);
+
+       /*
+        * PLL_BYPASS off
+        * Reference clock count
+        * I2C Master Clock Divider
+        */
+       mt9t112_reg_write(ret, client, 0x0014, 0x3046);
+       mt9t112_reg_write(ret, client, 0x0016, 0x0400); /* JPEG initialization workaround */
+       mt9t112_reg_write(ret, client, 0x0022, 0x0190);
+       mt9t112_reg_write(ret, client, 0x3B84, 0x0212);
+
+       /* External sensor clock is PLL bypass */
+       mt9t112_reg_write(ret, client, 0x002E, 0x0500);
+
+       mt9t112_reg_mask_set(ret, client, 0x0018, 0x0002, 0x0002);
+       mt9t112_reg_mask_set(ret, client, 0x3B82, 0x0004, 0x0004);
+
+       /* MCU disabled */
+       mt9t112_reg_mask_set(ret, client, 0x0018, 0x0004, 0x0004);
+
+       /* out of standby */
+       mt9t112_reg_mask_set(ret, client, 0x0018, 0x0001, 0);
+
+       mdelay(50);
+
+       /*
+        * Standby Workaround
+        * Disable Secondary I2C Pads
+        */
+       mt9t112_reg_write(ret, client, 0x0614, 0x0001);
+       mdelay(1);
+       mt9t112_reg_write(ret, client, 0x0614, 0x0001);
+       mdelay(1);
+       mt9t112_reg_write(ret, client, 0x0614, 0x0001);
+       mdelay(1);
+       mt9t112_reg_write(ret, client, 0x0614, 0x0001);
+       mdelay(1);
+       mt9t112_reg_write(ret, client, 0x0614, 0x0001);
+       mdelay(1);
+       mt9t112_reg_write(ret, client, 0x0614, 0x0001);
+       mdelay(1);
+
+       /* poll to verify out of standby. Must Poll this bit */
+       for (i = 0; i < 100; i++) {
+               mt9t112_reg_read(data, client, 0x0018);
+               if (!(0x4000 & data))
+                       break;
+
+               mdelay(10);
+       }
+
+       return ret;
+}
+
+static int mt9t112_init_setting(const struct i2c_client *client)
+{
+
+       int ret;
+
+       /* Adaptive Output Clock (A) */
+       mt9t112_mcu_mask_set(ret, client, VAR(26, 160), 0x0040, 0x0000);
+
+       /* Read Mode (A) */
+       mt9t112_mcu_write(ret, client, VAR(18, 12), 0x0024);
+
+       /* Fine Correction (A) */
+       mt9t112_mcu_write(ret, client, VAR(18, 15), 0x00CC);
+
+       /* Fine IT Min (A) */
+       mt9t112_mcu_write(ret, client, VAR(18, 17), 0x01f1);
+
+       /* Fine IT Max Margin (A) */
+       mt9t112_mcu_write(ret, client, VAR(18, 19), 0x00fF);
+
+       /* Base Frame Lines (A) */
+       mt9t112_mcu_write(ret, client, VAR(18, 29), 0x032D);
+
+       /* Min Line Length (A) */
+       mt9t112_mcu_write(ret, client, VAR(18, 31), 0x073a);
+
+       /* Line Length (A) */
+       mt9t112_mcu_write(ret, client, VAR(18, 37), 0x07d0);
+
+       /* Adaptive Output Clock (B) */
+       mt9t112_mcu_mask_set(ret, client, VAR(27, 160), 0x0040, 0x0000);
+
+       /* Row Start (B) */
+       mt9t112_mcu_write(ret, client, VAR(18, 74), 0x004);
+
+       /* Column Start (B) */
+       mt9t112_mcu_write(ret, client, VAR(18, 76), 0x004);
+
+       /* Row End (B) */
+       mt9t112_mcu_write(ret, client, VAR(18, 78), 0x60B);
+
+       /* Column End (B) */
+       mt9t112_mcu_write(ret, client, VAR(18, 80), 0x80B);
+
+       /* Fine Correction (B) */
+       mt9t112_mcu_write(ret, client, VAR(18, 87), 0x008C);
+
+       /* Fine IT Min (B) */
+       mt9t112_mcu_write(ret, client, VAR(18, 89), 0x01F1);
+
+       /* Fine IT Max Margin (B) */
+       mt9t112_mcu_write(ret, client, VAR(18, 91), 0x00FF);
+
+       /* Base Frame Lines (B) */
+       mt9t112_mcu_write(ret, client, VAR(18, 101), 0x0668);
+
+       /* Min Line Length (B) */
+       mt9t112_mcu_write(ret, client, VAR(18, 103), 0x0AF0);
+
+       /* Line Length (B) */
+       mt9t112_mcu_write(ret, client, VAR(18, 109), 0x0AF0);
+
+       /*
+        * Flicker Dectection registers
+        * This section should be replaced whenever new Timing file is generated
+        * All the following registers need to be replaced
+        * Following registers are generated from Register Wizard but user can
+        * modify them. For detail see auto flicker detection tuning
+        */
+
+       /* FD_FDPERIOD_SELECT */
+       mt9t112_mcu_write(ret, client, VAR8(8, 5), 0x01);
+
+       /* PRI_B_CONFIG_FD_ALGO_RUN */
+       mt9t112_mcu_write(ret, client, VAR(27, 17), 0x0003);
+
+       /* PRI_A_CONFIG_FD_ALGO_RUN */
+       mt9t112_mcu_write(ret, client, VAR(26, 17), 0x0003);
+
+       /*
+        * AFD range detection tuning registers
+        */
+
+       /* search_f1_50 */
+       mt9t112_mcu_write(ret, client, VAR8(18, 165), 0x25);
+
+       /* search_f2_50 */
+       mt9t112_mcu_write(ret, client, VAR8(18, 166), 0x28);
+
+       /* search_f1_60 */
+       mt9t112_mcu_write(ret, client, VAR8(18, 167), 0x2C);
+
+       /* search_f2_60 */
+       mt9t112_mcu_write(ret, client, VAR8(18, 168), 0x2F);
+
+       /* period_50Hz (A) */
+       mt9t112_mcu_write(ret, client, VAR8(18, 68), 0xBA);
+
+       /* secret register by aptina */
+       /* period_50Hz (A MSB) */
+       mt9t112_mcu_write(ret, client, VAR8(18, 303), 0x00);
+
+       /* period_60Hz (A) */
+       mt9t112_mcu_write(ret, client, VAR8(18, 69), 0x9B);
+
+       /* secret register by aptina */
+       /* period_60Hz (A MSB) */
+       mt9t112_mcu_write(ret, client, VAR8(18, 301), 0x00);
+
+       /* period_50Hz (B) */
+       mt9t112_mcu_write(ret, client, VAR8(18, 140), 0x82);
+
+       /* secret register by aptina */
+       /* period_50Hz (B) MSB */
+       mt9t112_mcu_write(ret, client, VAR8(18, 304), 0x00);
+
+       /* period_60Hz (B) */
+       mt9t112_mcu_write(ret, client, VAR8(18, 141), 0x6D);
+
+       /* secret register by aptina */
+       /* period_60Hz (B) MSB */
+       mt9t112_mcu_write(ret, client, VAR8(18, 302), 0x00);
+
+       /* FD Mode */
+       mt9t112_mcu_write(ret, client, VAR8(8, 2), 0x10);
+
+       /* Stat_min */
+       mt9t112_mcu_write(ret, client, VAR8(8, 9), 0x02);
+
+       /* Stat_max */
+       mt9t112_mcu_write(ret, client, VAR8(8, 10), 0x03);
+
+       /* Min_amplitude */
+       mt9t112_mcu_write(ret, client, VAR8(8, 12), 0x0A);
+
+       /* RX FIFO Watermark (A) */
+       mt9t112_mcu_write(ret, client, VAR(18, 70), 0x0014);
+
+       /* RX FIFO Watermark (B) */
+       mt9t112_mcu_write(ret, client, VAR(18, 142), 0x0014);
+
+       /* MCLK: 16MHz
+        * PCLK: 73MHz
+        * CorePixCLK: 36.5 MHz
+        */
+       mt9t112_mcu_write(ret, client, VAR8(18, 0x0044), 133);
+       mt9t112_mcu_write(ret, client, VAR8(18, 0x0045), 110);
+       mt9t112_mcu_write(ret, client, VAR8(18, 0x008c), 130);
+       mt9t112_mcu_write(ret, client, VAR8(18, 0x008d), 108);
+
+       mt9t112_mcu_write(ret, client, VAR8(18, 0x00A5), 27);
+       mt9t112_mcu_write(ret, client, VAR8(18, 0x00a6), 30);
+       mt9t112_mcu_write(ret, client, VAR8(18, 0x00a7), 32);
+       mt9t112_mcu_write(ret, client, VAR8(18, 0x00a8), 35);
+
+       return ret;
+}
+
+static int mt9t112_auto_focus_setting(const struct i2c_client *client)
+{
+       int ret;
+
+       mt9t112_mcu_write(ret, client, VAR(12, 13),     0x000F);
+       mt9t112_mcu_write(ret, client, VAR(12, 23),     0x0F0F);
+       mt9t112_mcu_write(ret, client, VAR8(1, 0),      0x06);
+
+       mt9t112_reg_write(ret, client, 0x0614, 0x0000);
+
+       mt9t112_mcu_write(ret, client, VAR8(1, 0),      0x05);
+       mt9t112_mcu_write(ret, client, VAR8(12, 2),     0x02);
+       mt9t112_mcu_write(ret, client, VAR(12, 3),      0x0002);
+       mt9t112_mcu_write(ret, client, VAR(17, 3),      0x8001);
+       mt9t112_mcu_write(ret, client, VAR(17, 11),     0x0025);
+       mt9t112_mcu_write(ret, client, VAR(17, 13),     0x0193);
+       mt9t112_mcu_write(ret, client, VAR8(17, 33),    0x18);
+       mt9t112_mcu_write(ret, client, VAR8(1, 0),      0x05);
+
+       return ret;
+}
+
+static int mt9t112_auto_focus_trigger(const struct i2c_client *client)
+{
+       int ret;
+
+       mt9t112_mcu_write(ret, client, VAR8(12, 25), 0x01);
+
+       return ret;
+}
+
+static int mt9t112_init_camera(const struct i2c_client *client)
+{
+       int ret;
+
+       ECHECKER(ret, mt9t112_reset(client));
+
+       ECHECKER(ret, mt9t112_init_pll(client));
+
+       ECHECKER(ret, mt9t112_init_setting(client));
+
+       ECHECKER(ret, mt9t112_auto_focus_setting(client));
+
+       mt9t112_reg_mask_set(ret, client, 0x0018, 0x0004, 0);
+
+       /* Analog setting B */
+       mt9t112_reg_write(ret, client, 0x3084, 0x2409);
+       mt9t112_reg_write(ret, client, 0x3092, 0x0A49);
+       mt9t112_reg_write(ret, client, 0x3094, 0x4949);
+       mt9t112_reg_write(ret, client, 0x3096, 0x4950);
+
+       /*
+        * Disable adaptive clock
+        * PRI_A_CONFIG_JPEG_OB_TX_CONTROL_VAR
+        * PRI_B_CONFIG_JPEG_OB_TX_CONTROL_VAR
+        */
+       mt9t112_mcu_write(ret, client, VAR(26, 160), 0x0A2E);
+       mt9t112_mcu_write(ret, client, VAR(27, 160), 0x0A2E);
+
+       /* Configure STatus in Status_before_length Format and enable header */
+       /* PRI_B_CONFIG_JPEG_OB_TX_CONTROL_VAR */
+       mt9t112_mcu_write(ret, client, VAR(27, 144), 0x0CB4);
+
+       /* Enable JPEG in context B */
+       /* PRI_B_CONFIG_JPEG_OB_TX_CONTROL_VAR */
+       mt9t112_mcu_write(ret, client, VAR8(27, 142), 0x01);
+
+       /* Disable Dac_TXLO */
+       mt9t112_reg_write(ret, client, 0x316C, 0x350F);
+
+       /* Set max slew rates */
+       mt9t112_reg_write(ret, client, 0x1E, 0x777);
+
+       return ret;
+}
+
+/************************************************************************
+                       v4l2_subdev_core_ops
+************************************************************************/
+static int mt9t112_g_chip_ident(struct v4l2_subdev *sd,
+                               struct v4l2_dbg_chip_ident *id)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9t112_priv *priv = to_mt9t112(client);
+
+       id->ident    = priv->model;
+       id->revision = 0;
+
+       return 0;
+}
+
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+static int mt9t112_g_register(struct v4l2_subdev *sd,
+                             struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       int                ret;
+
+       reg->size = 2;
+       mt9t112_reg_read(ret, client, reg->reg);
+
+       reg->val = (__u64)ret;
+
+       return 0;
+}
+
+static int mt9t112_s_register(struct v4l2_subdev *sd,
+                             struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       int ret;
+
+       mt9t112_reg_write(ret, client, reg->reg, reg->val);
+
+       return ret;
+}
+#endif
+
+static struct v4l2_subdev_core_ops mt9t112_subdev_core_ops = {
+       .g_chip_ident   = mt9t112_g_chip_ident,
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+       .g_register     = mt9t112_g_register,
+       .s_register     = mt9t112_s_register,
+#endif
+};
+
+
+/************************************************************************
+                       v4l2_subdev_video_ops
+************************************************************************/
+static int mt9t112_s_stream(struct v4l2_subdev *sd, int enable)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9t112_priv *priv = to_mt9t112(client);
+       int ret = 0;
+
+       if (!enable) {
+               /* FIXME
+                *
+                * If user selected large output size,
+                * and used it long time,
+                * mt9t112 camera will be very warm.
+                *
+                * But current driver can not stop mt9t112 camera.
+                * So, set small size here to solve this problem.
+                */
+               mt9t112_set_a_frame_size(client, VGA_WIDTH, VGA_HEIGHT);
+               return ret;
+       }
+
+       if (!(priv->flags & INIT_DONE)) {
+               u16 param = PCLK_RISING & priv->flags ? 0x0001 : 0x0000;
+
+               ECHECKER(ret, mt9t112_init_camera(client));
+
+               /* Invert PCLK (Data sampled on falling edge of pixclk) */
+               mt9t112_reg_write(ret, client, 0x3C20, param);
+
+               mdelay(5);
+
+               priv->flags |= INIT_DONE;
+       }
+
+       mt9t112_mcu_write(ret, client, VAR(26, 7), priv->format->fmt);
+       mt9t112_mcu_write(ret, client, VAR(26, 9), priv->format->order);
+       mt9t112_mcu_write(ret, client, VAR8(1, 0), 0x06);
+
+       mt9t112_set_a_frame_size(client,
+                                priv->frame.width,
+                                priv->frame.height);
+
+       ECHECKER(ret, mt9t112_auto_focus_trigger(client));
+
+       dev_dbg(&client->dev, "format : %d\n", priv->format->code);
+       dev_dbg(&client->dev, "size   : %d x %d\n",
+               priv->frame.width,
+               priv->frame.height);
+
+       CLOCK_INFO(client, EXT_CLOCK);
+
+       return ret;
+}
+
+static int mt9t112_set_params(struct mt9t112_priv *priv,
+                             const struct v4l2_rect *rect,
+                             enum v4l2_mbus_pixelcode code)
+{
+       int i;
+
+       /*
+        * get color format
+        */
+       for (i = 0; i < ARRAY_SIZE(mt9t112_cfmts); i++)
+               if (mt9t112_cfmts[i].code == code)
+                       break;
+
+       if (i == ARRAY_SIZE(mt9t112_cfmts))
+               return -EINVAL;
+
+       priv->frame  = *rect;
+
+       /*
+        * frame size check
+        */
+       mt9t112_frame_check(&priv->frame.width, &priv->frame.height,
+                           &priv->frame.left, &priv->frame.top);
+
+       priv->format = mt9t112_cfmts + i;
+
+       return 0;
+}
+
+static int mt9t112_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
+{
+       a->bounds.left                  = 0;
+       a->bounds.top                   = 0;
+       a->bounds.width                 = MAX_WIDTH;
+       a->bounds.height                = MAX_HEIGHT;
+       a->defrect.left                 = 0;
+       a->defrect.top                  = 0;
+       a->defrect.width                = VGA_WIDTH;
+       a->defrect.height               = VGA_HEIGHT;
+       a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+       a->pixelaspect.numerator        = 1;
+       a->pixelaspect.denominator      = 1;
+
+       return 0;
+}
+
+static int mt9t112_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9t112_priv *priv = to_mt9t112(client);
+
+       a->c    = priv->frame;
+       a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+       return 0;
+}
+
+static int mt9t112_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9t112_priv *priv = to_mt9t112(client);
+       struct v4l2_rect *rect = &a->c;
+
+       return mt9t112_set_params(priv, rect, priv->format->code);
+}
+
+static int mt9t112_g_fmt(struct v4l2_subdev *sd,
+                        struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9t112_priv *priv = to_mt9t112(client);
+
+       mf->width       = priv->frame.width;
+       mf->height      = priv->frame.height;
+       mf->colorspace  = priv->format->colorspace;
+       mf->code        = priv->format->code;
+       mf->field       = V4L2_FIELD_NONE;
+
+       return 0;
+}
+
+static int mt9t112_s_fmt(struct v4l2_subdev *sd,
+                        struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9t112_priv *priv = to_mt9t112(client);
+       struct v4l2_rect rect = {
+               .width = mf->width,
+               .height = mf->height,
+               .left = priv->frame.left,
+               .top = priv->frame.top,
+       };
+       int ret;
+
+       ret = mt9t112_set_params(priv, &rect, mf->code);
+
+       if (!ret)
+               mf->colorspace = priv->format->colorspace;
+
+       return ret;
+}
+
+static int mt9t112_try_fmt(struct v4l2_subdev *sd,
+                          struct v4l2_mbus_framefmt *mf)
+{
+       unsigned int top, left;
+       int i;
+
+       for (i = 0; i < ARRAY_SIZE(mt9t112_cfmts); i++)
+               if (mt9t112_cfmts[i].code == mf->code)
+                       break;
+
+       if (i == ARRAY_SIZE(mt9t112_cfmts)) {
+               mf->code = V4L2_MBUS_FMT_UYVY8_2X8;
+               mf->colorspace = V4L2_COLORSPACE_JPEG;
+       } else {
+               mf->colorspace  = mt9t112_cfmts[i].colorspace;
+       }
+
+       mt9t112_frame_check(&mf->width, &mf->height, &left, &top);
+
+       mf->field = V4L2_FIELD_NONE;
+
+       return 0;
+}
+
+static int mt9t112_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
+                          enum v4l2_mbus_pixelcode *code)
+{
+       if (index >= ARRAY_SIZE(mt9t112_cfmts))
+               return -EINVAL;
+
+       *code = mt9t112_cfmts[index].code;
+
+       return 0;
+}
+
+static int mt9t112_g_mbus_config(struct v4l2_subdev *sd,
+                                struct v4l2_mbus_config *cfg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+
+       cfg->flags = V4L2_MBUS_MASTER | V4L2_MBUS_VSYNC_ACTIVE_HIGH |
+               V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_DATA_ACTIVE_HIGH |
+               V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_PCLK_SAMPLE_FALLING;
+       cfg->type = V4L2_MBUS_PARALLEL;
+       cfg->flags = soc_camera_apply_board_flags(icl, cfg);
+
+       return 0;
+}
+
+static int mt9t112_s_mbus_config(struct v4l2_subdev *sd,
+                                const struct v4l2_mbus_config *cfg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+       struct mt9t112_priv *priv = to_mt9t112(client);
+
+       if (soc_camera_apply_board_flags(icl, cfg) & V4L2_MBUS_PCLK_SAMPLE_RISING)
+               priv->flags |= PCLK_RISING;
+
+       return 0;
+}
+
+static struct v4l2_subdev_video_ops mt9t112_subdev_video_ops = {
+       .s_stream       = mt9t112_s_stream,
+       .g_mbus_fmt     = mt9t112_g_fmt,
+       .s_mbus_fmt     = mt9t112_s_fmt,
+       .try_mbus_fmt   = mt9t112_try_fmt,
+       .cropcap        = mt9t112_cropcap,
+       .g_crop         = mt9t112_g_crop,
+       .s_crop         = mt9t112_s_crop,
+       .enum_mbus_fmt  = mt9t112_enum_fmt,
+       .g_mbus_config  = mt9t112_g_mbus_config,
+       .s_mbus_config  = mt9t112_s_mbus_config,
+};
+
+/************************************************************************
+                       i2c driver
+************************************************************************/
+static struct v4l2_subdev_ops mt9t112_subdev_ops = {
+       .core   = &mt9t112_subdev_core_ops,
+       .video  = &mt9t112_subdev_video_ops,
+};
+
+static int mt9t112_camera_probe(struct i2c_client *client)
+{
+       struct mt9t112_priv *priv = to_mt9t112(client);
+       const char          *devname;
+       int                  chipid;
+
+       /*
+        * check and show chip ID
+        */
+       mt9t112_reg_read(chipid, client, 0x0000);
+
+       switch (chipid) {
+       case 0x2680:
+               devname = "mt9t111";
+               priv->model = V4L2_IDENT_MT9T111;
+               break;
+       case 0x2682:
+               devname = "mt9t112";
+               priv->model = V4L2_IDENT_MT9T112;
+               break;
+       default:
+               dev_err(&client->dev, "Product ID error %04x\n", chipid);
+               return -ENODEV;
+       }
+
+       dev_info(&client->dev, "%s chip ID %04x\n", devname, chipid);
+
+       return 0;
+}
+
+static int mt9t112_probe(struct i2c_client *client,
+                        const struct i2c_device_id *did)
+{
+       struct mt9t112_priv *priv;
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+       struct v4l2_rect rect = {
+               .width = VGA_WIDTH,
+               .height = VGA_HEIGHT,
+               .left = (MAX_WIDTH - VGA_WIDTH) / 2,
+               .top = (MAX_HEIGHT - VGA_HEIGHT) / 2,
+       };
+       int ret;
+
+       if (!icl || !icl->priv) {
+               dev_err(&client->dev, "mt9t112: missing platform data!\n");
+               return -EINVAL;
+       }
+
+       priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+       if (!priv)
+               return -ENOMEM;
+
+       priv->info = icl->priv;
+
+       v4l2_i2c_subdev_init(&priv->subdev, client, &mt9t112_subdev_ops);
+
+       ret = mt9t112_camera_probe(client);
+       if (ret) {
+               kfree(priv);
+               return ret;
+       }
+
+       /* Cannot fail: using the default supported pixel code */
+       mt9t112_set_params(priv, &rect, V4L2_MBUS_FMT_UYVY8_2X8);
+
+       return ret;
+}
+
+static int mt9t112_remove(struct i2c_client *client)
+{
+       struct mt9t112_priv *priv = to_mt9t112(client);
+
+       kfree(priv);
+       return 0;
+}
+
+static const struct i2c_device_id mt9t112_id[] = {
+       { "mt9t112", 0 },
+       { }
+};
+MODULE_DEVICE_TABLE(i2c, mt9t112_id);
+
+static struct i2c_driver mt9t112_i2c_driver = {
+       .driver = {
+               .name = "mt9t112",
+       },
+       .probe    = mt9t112_probe,
+       .remove   = mt9t112_remove,
+       .id_table = mt9t112_id,
+};
+
+module_i2c_driver(mt9t112_i2c_driver);
+
+MODULE_DESCRIPTION("SoC Camera driver for mt9t112");
+MODULE_AUTHOR("Kuninori Morimoto");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/i2c/soc_camera/mt9v022.c b/drivers/media/i2c/soc_camera/mt9v022.c
new file mode 100644 (file)
index 0000000..7247924
--- /dev/null
@@ -0,0 +1,879 @@
+/*
+ * Driver for MT9V022 CMOS Image Sensor from Micron
+ *
+ * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/videodev2.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/delay.h>
+#include <linux/log2.h>
+#include <linux/module.h>
+
+#include <media/soc_camera.h>
+#include <media/soc_mediabus.h>
+#include <media/v4l2-subdev.h>
+#include <media/v4l2-chip-ident.h>
+#include <media/v4l2-ctrls.h>
+
+/*
+ * mt9v022 i2c address 0x48, 0x4c, 0x58, 0x5c
+ * The platform has to define struct i2c_board_info objects and link to them
+ * from struct soc_camera_link
+ */
+
+static char *sensor_type;
+module_param(sensor_type, charp, S_IRUGO);
+MODULE_PARM_DESC(sensor_type, "Sensor type: \"colour\" or \"monochrome\"");
+
+/* mt9v022 selected register addresses */
+#define MT9V022_CHIP_VERSION           0x00
+#define MT9V022_COLUMN_START           0x01
+#define MT9V022_ROW_START              0x02
+#define MT9V022_WINDOW_HEIGHT          0x03
+#define MT9V022_WINDOW_WIDTH           0x04
+#define MT9V022_HORIZONTAL_BLANKING    0x05
+#define MT9V022_VERTICAL_BLANKING      0x06
+#define MT9V022_CHIP_CONTROL           0x07
+#define MT9V022_SHUTTER_WIDTH1         0x08
+#define MT9V022_SHUTTER_WIDTH2         0x09
+#define MT9V022_SHUTTER_WIDTH_CTRL     0x0a
+#define MT9V022_TOTAL_SHUTTER_WIDTH    0x0b
+#define MT9V022_RESET                  0x0c
+#define MT9V022_READ_MODE              0x0d
+#define MT9V022_MONITOR_MODE           0x0e
+#define MT9V022_PIXEL_OPERATION_MODE   0x0f
+#define MT9V022_LED_OUT_CONTROL                0x1b
+#define MT9V022_ADC_MODE_CONTROL       0x1c
+#define MT9V022_ANALOG_GAIN            0x35
+#define MT9V022_BLACK_LEVEL_CALIB_CTRL 0x47
+#define MT9V022_PIXCLK_FV_LV           0x74
+#define MT9V022_DIGITAL_TEST_PATTERN   0x7f
+#define MT9V022_AEC_AGC_ENABLE         0xAF
+#define MT9V022_MAX_TOTAL_SHUTTER_WIDTH        0xBD
+
+/* Progressive scan, master, defaults */
+#define MT9V022_CHIP_CONTROL_DEFAULT   0x188
+
+#define MT9V022_MAX_WIDTH              752
+#define MT9V022_MAX_HEIGHT             480
+#define MT9V022_MIN_WIDTH              48
+#define MT9V022_MIN_HEIGHT             32
+#define MT9V022_COLUMN_SKIP            1
+#define MT9V022_ROW_SKIP               4
+
+/* MT9V022 has only one fixed colorspace per pixelcode */
+struct mt9v022_datafmt {
+       enum v4l2_mbus_pixelcode        code;
+       enum v4l2_colorspace            colorspace;
+};
+
+/* Find a data format by a pixel code in an array */
+static const struct mt9v022_datafmt *mt9v022_find_datafmt(
+       enum v4l2_mbus_pixelcode code, const struct mt9v022_datafmt *fmt,
+       int n)
+{
+       int i;
+       for (i = 0; i < n; i++)
+               if (fmt[i].code == code)
+                       return fmt + i;
+
+       return NULL;
+}
+
+static const struct mt9v022_datafmt mt9v022_colour_fmts[] = {
+       /*
+        * Order important: first natively supported,
+        * second supported with a GPIO extender
+        */
+       {V4L2_MBUS_FMT_SBGGR10_1X10, V4L2_COLORSPACE_SRGB},
+       {V4L2_MBUS_FMT_SBGGR8_1X8, V4L2_COLORSPACE_SRGB},
+};
+
+static const struct mt9v022_datafmt mt9v022_monochrome_fmts[] = {
+       /* Order important - see above */
+       {V4L2_MBUS_FMT_Y10_1X10, V4L2_COLORSPACE_JPEG},
+       {V4L2_MBUS_FMT_Y8_1X8, V4L2_COLORSPACE_JPEG},
+};
+
+struct mt9v022 {
+       struct v4l2_subdev subdev;
+       struct v4l2_ctrl_handler hdl;
+       struct {
+               /* exposure/auto-exposure cluster */
+               struct v4l2_ctrl *autoexposure;
+               struct v4l2_ctrl *exposure;
+       };
+       struct {
+               /* gain/auto-gain cluster */
+               struct v4l2_ctrl *autogain;
+               struct v4l2_ctrl *gain;
+       };
+       struct v4l2_rect rect;  /* Sensor window */
+       const struct mt9v022_datafmt *fmt;
+       const struct mt9v022_datafmt *fmts;
+       int num_fmts;
+       int model;      /* V4L2_IDENT_MT9V022* codes from v4l2-chip-ident.h */
+       u16 chip_control;
+       unsigned short y_skip_top;      /* Lines to skip at the top */
+};
+
+static struct mt9v022 *to_mt9v022(const struct i2c_client *client)
+{
+       return container_of(i2c_get_clientdata(client), struct mt9v022, subdev);
+}
+
+static int reg_read(struct i2c_client *client, const u8 reg)
+{
+       return i2c_smbus_read_word_swapped(client, reg);
+}
+
+static int reg_write(struct i2c_client *client, const u8 reg,
+                    const u16 data)
+{
+       return i2c_smbus_write_word_swapped(client, reg, data);
+}
+
+static int reg_set(struct i2c_client *client, const u8 reg,
+                  const u16 data)
+{
+       int ret;
+
+       ret = reg_read(client, reg);
+       if (ret < 0)
+               return ret;
+       return reg_write(client, reg, ret | data);
+}
+
+static int reg_clear(struct i2c_client *client, const u8 reg,
+                    const u16 data)
+{
+       int ret;
+
+       ret = reg_read(client, reg);
+       if (ret < 0)
+               return ret;
+       return reg_write(client, reg, ret & ~data);
+}
+
+static int mt9v022_init(struct i2c_client *client)
+{
+       struct mt9v022 *mt9v022 = to_mt9v022(client);
+       int ret;
+
+       /*
+        * Almost the default mode: master, parallel, simultaneous, and an
+        * undocumented bit 0x200, which is present in table 7, but not in 8,
+        * plus snapshot mode to disable scan for now
+        */
+       mt9v022->chip_control |= 0x10;
+       ret = reg_write(client, MT9V022_CHIP_CONTROL, mt9v022->chip_control);
+       if (!ret)
+               ret = reg_write(client, MT9V022_READ_MODE, 0x300);
+
+       /* All defaults */
+       if (!ret)
+               /* AEC, AGC on */
+               ret = reg_set(client, MT9V022_AEC_AGC_ENABLE, 0x3);
+       if (!ret)
+               ret = reg_write(client, MT9V022_ANALOG_GAIN, 16);
+       if (!ret)
+               ret = reg_write(client, MT9V022_TOTAL_SHUTTER_WIDTH, 480);
+       if (!ret)
+               ret = reg_write(client, MT9V022_MAX_TOTAL_SHUTTER_WIDTH, 480);
+       if (!ret)
+               /* default - auto */
+               ret = reg_clear(client, MT9V022_BLACK_LEVEL_CALIB_CTRL, 1);
+       if (!ret)
+               ret = reg_write(client, MT9V022_DIGITAL_TEST_PATTERN, 0);
+       if (!ret)
+               return v4l2_ctrl_handler_setup(&mt9v022->hdl);
+
+       return ret;
+}
+
+static int mt9v022_s_stream(struct v4l2_subdev *sd, int enable)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9v022 *mt9v022 = to_mt9v022(client);
+
+       if (enable)
+               /* Switch to master "normal" mode */
+               mt9v022->chip_control &= ~0x10;
+       else
+               /* Switch to snapshot mode */
+               mt9v022->chip_control |= 0x10;
+
+       if (reg_write(client, MT9V022_CHIP_CONTROL, mt9v022->chip_control) < 0)
+               return -EIO;
+       return 0;
+}
+
+static int mt9v022_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9v022 *mt9v022 = to_mt9v022(client);
+       struct v4l2_rect rect = a->c;
+       int ret;
+
+       /* Bayer format - even size lengths */
+       if (mt9v022->fmts == mt9v022_colour_fmts) {
+               rect.width      = ALIGN(rect.width, 2);
+               rect.height     = ALIGN(rect.height, 2);
+               /* Let the user play with the starting pixel */
+       }
+
+       soc_camera_limit_side(&rect.left, &rect.width,
+                    MT9V022_COLUMN_SKIP, MT9V022_MIN_WIDTH, MT9V022_MAX_WIDTH);
+
+       soc_camera_limit_side(&rect.top, &rect.height,
+                    MT9V022_ROW_SKIP, MT9V022_MIN_HEIGHT, MT9V022_MAX_HEIGHT);
+
+       /* Like in example app. Contradicts the datasheet though */
+       ret = reg_read(client, MT9V022_AEC_AGC_ENABLE);
+       if (ret >= 0) {
+               if (ret & 1) /* Autoexposure */
+                       ret = reg_write(client, MT9V022_MAX_TOTAL_SHUTTER_WIDTH,
+                                       rect.height + mt9v022->y_skip_top + 43);
+               else
+                       ret = reg_write(client, MT9V022_TOTAL_SHUTTER_WIDTH,
+                                       rect.height + mt9v022->y_skip_top + 43);
+       }
+       /* Setup frame format: defaults apart from width and height */
+       if (!ret)
+               ret = reg_write(client, MT9V022_COLUMN_START, rect.left);
+       if (!ret)
+               ret = reg_write(client, MT9V022_ROW_START, rect.top);
+       if (!ret)
+               /*
+                * Default 94, Phytec driver says:
+                * "width + horizontal blank >= 660"
+                */
+               ret = reg_write(client, MT9V022_HORIZONTAL_BLANKING,
+                               rect.width > 660 - 43 ? 43 :
+                               660 - rect.width);
+       if (!ret)
+               ret = reg_write(client, MT9V022_VERTICAL_BLANKING, 45);
+       if (!ret)
+               ret = reg_write(client, MT9V022_WINDOW_WIDTH, rect.width);
+       if (!ret)
+               ret = reg_write(client, MT9V022_WINDOW_HEIGHT,
+                               rect.height + mt9v022->y_skip_top);
+
+       if (ret < 0)
+               return ret;
+
+       dev_dbg(&client->dev, "Frame %dx%d pixel\n", rect.width, rect.height);
+
+       mt9v022->rect = rect;
+
+       return 0;
+}
+
+static int mt9v022_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9v022 *mt9v022 = to_mt9v022(client);
+
+       a->c    = mt9v022->rect;
+       a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+       return 0;
+}
+
+static int mt9v022_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
+{
+       a->bounds.left                  = MT9V022_COLUMN_SKIP;
+       a->bounds.top                   = MT9V022_ROW_SKIP;
+       a->bounds.width                 = MT9V022_MAX_WIDTH;
+       a->bounds.height                = MT9V022_MAX_HEIGHT;
+       a->defrect                      = a->bounds;
+       a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+       a->pixelaspect.numerator        = 1;
+       a->pixelaspect.denominator      = 1;
+
+       return 0;
+}
+
+static int mt9v022_g_fmt(struct v4l2_subdev *sd,
+                        struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9v022 *mt9v022 = to_mt9v022(client);
+
+       mf->width       = mt9v022->rect.width;
+       mf->height      = mt9v022->rect.height;
+       mf->code        = mt9v022->fmt->code;
+       mf->colorspace  = mt9v022->fmt->colorspace;
+       mf->field       = V4L2_FIELD_NONE;
+
+       return 0;
+}
+
+static int mt9v022_s_fmt(struct v4l2_subdev *sd,
+                        struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9v022 *mt9v022 = to_mt9v022(client);
+       struct v4l2_crop a = {
+               .c = {
+                       .left   = mt9v022->rect.left,
+                       .top    = mt9v022->rect.top,
+                       .width  = mf->width,
+                       .height = mf->height,
+               },
+       };
+       int ret;
+
+       /*
+        * The caller provides a supported format, as verified per call to
+        * .try_mbus_fmt(), datawidth is from our supported format list
+        */
+       switch (mf->code) {
+       case V4L2_MBUS_FMT_Y8_1X8:
+       case V4L2_MBUS_FMT_Y10_1X10:
+               if (mt9v022->model != V4L2_IDENT_MT9V022IX7ATM)
+                       return -EINVAL;
+               break;
+       case V4L2_MBUS_FMT_SBGGR8_1X8:
+       case V4L2_MBUS_FMT_SBGGR10_1X10:
+               if (mt9v022->model != V4L2_IDENT_MT9V022IX7ATC)
+                       return -EINVAL;
+               break;
+       default:
+               return -EINVAL;
+       }
+
+       /* No support for scaling on this camera, just crop. */
+       ret = mt9v022_s_crop(sd, &a);
+       if (!ret) {
+               mf->width       = mt9v022->rect.width;
+               mf->height      = mt9v022->rect.height;
+               mt9v022->fmt    = mt9v022_find_datafmt(mf->code,
+                                       mt9v022->fmts, mt9v022->num_fmts);
+               mf->colorspace  = mt9v022->fmt->colorspace;
+       }
+
+       return ret;
+}
+
+static int mt9v022_try_fmt(struct v4l2_subdev *sd,
+                          struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9v022 *mt9v022 = to_mt9v022(client);
+       const struct mt9v022_datafmt *fmt;
+       int align = mf->code == V4L2_MBUS_FMT_SBGGR8_1X8 ||
+               mf->code == V4L2_MBUS_FMT_SBGGR10_1X10;
+
+       v4l_bound_align_image(&mf->width, MT9V022_MIN_WIDTH,
+               MT9V022_MAX_WIDTH, align,
+               &mf->height, MT9V022_MIN_HEIGHT + mt9v022->y_skip_top,
+               MT9V022_MAX_HEIGHT + mt9v022->y_skip_top, align, 0);
+
+       fmt = mt9v022_find_datafmt(mf->code, mt9v022->fmts,
+                                  mt9v022->num_fmts);
+       if (!fmt) {
+               fmt = mt9v022->fmt;
+               mf->code = fmt->code;
+       }
+
+       mf->colorspace  = fmt->colorspace;
+
+       return 0;
+}
+
+static int mt9v022_g_chip_ident(struct v4l2_subdev *sd,
+                               struct v4l2_dbg_chip_ident *id)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9v022 *mt9v022 = to_mt9v022(client);
+
+       if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
+               return -EINVAL;
+
+       if (id->match.addr != client->addr)
+               return -ENODEV;
+
+       id->ident       = mt9v022->model;
+       id->revision    = 0;
+
+       return 0;
+}
+
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+static int mt9v022_g_register(struct v4l2_subdev *sd,
+                             struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+       if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
+               return -EINVAL;
+
+       if (reg->match.addr != client->addr)
+               return -ENODEV;
+
+       reg->size = 2;
+       reg->val = reg_read(client, reg->reg);
+
+       if (reg->val > 0xffff)
+               return -EIO;
+
+       return 0;
+}
+
+static int mt9v022_s_register(struct v4l2_subdev *sd,
+                             struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+       if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
+               return -EINVAL;
+
+       if (reg->match.addr != client->addr)
+               return -ENODEV;
+
+       if (reg_write(client, reg->reg, reg->val) < 0)
+               return -EIO;
+
+       return 0;
+}
+#endif
+
+static int mt9v022_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
+{
+       struct mt9v022 *mt9v022 = container_of(ctrl->handler,
+                                              struct mt9v022, hdl);
+       struct v4l2_subdev *sd = &mt9v022->subdev;
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct v4l2_ctrl *gain = mt9v022->gain;
+       struct v4l2_ctrl *exp = mt9v022->exposure;
+       unsigned long range;
+       int data;
+
+       switch (ctrl->id) {
+       case V4L2_CID_AUTOGAIN:
+               data = reg_read(client, MT9V022_ANALOG_GAIN);
+               if (data < 0)
+                       return -EIO;
+
+               range = gain->maximum - gain->minimum;
+               gain->val = ((data - 16) * range + 24) / 48 + gain->minimum;
+               return 0;
+       case V4L2_CID_EXPOSURE_AUTO:
+               data = reg_read(client, MT9V022_TOTAL_SHUTTER_WIDTH);
+               if (data < 0)
+                       return -EIO;
+
+               range = exp->maximum - exp->minimum;
+               exp->val = ((data - 1) * range + 239) / 479 + exp->minimum;
+               return 0;
+       }
+       return -EINVAL;
+}
+
+static int mt9v022_s_ctrl(struct v4l2_ctrl *ctrl)
+{
+       struct mt9v022 *mt9v022 = container_of(ctrl->handler,
+                                              struct mt9v022, hdl);
+       struct v4l2_subdev *sd = &mt9v022->subdev;
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       int data;
+
+       switch (ctrl->id) {
+       case V4L2_CID_VFLIP:
+               if (ctrl->val)
+                       data = reg_set(client, MT9V022_READ_MODE, 0x10);
+               else
+                       data = reg_clear(client, MT9V022_READ_MODE, 0x10);
+               if (data < 0)
+                       return -EIO;
+               return 0;
+       case V4L2_CID_HFLIP:
+               if (ctrl->val)
+                       data = reg_set(client, MT9V022_READ_MODE, 0x20);
+               else
+                       data = reg_clear(client, MT9V022_READ_MODE, 0x20);
+               if (data < 0)
+                       return -EIO;
+               return 0;
+       case V4L2_CID_AUTOGAIN:
+               if (ctrl->val) {
+                       if (reg_set(client, MT9V022_AEC_AGC_ENABLE, 0x2) < 0)
+                               return -EIO;
+               } else {
+                       struct v4l2_ctrl *gain = mt9v022->gain;
+                       /* mt9v022 has minimum == default */
+                       unsigned long range = gain->maximum - gain->minimum;
+                       /* Valid values 16 to 64, 32 to 64 must be even. */
+                       unsigned long gain_val = ((gain->val - gain->minimum) *
+                                             48 + range / 2) / range + 16;
+
+                       if (gain_val >= 32)
+                               gain_val &= ~1;
+
+                       /*
+                        * The user wants to set gain manually, hope, she
+                        * knows, what she's doing... Switch AGC off.
+                        */
+                       if (reg_clear(client, MT9V022_AEC_AGC_ENABLE, 0x2) < 0)
+                               return -EIO;
+
+                       dev_dbg(&client->dev, "Setting gain from %d to %lu\n",
+                               reg_read(client, MT9V022_ANALOG_GAIN), gain_val);
+                       if (reg_write(client, MT9V022_ANALOG_GAIN, gain_val) < 0)
+                               return -EIO;
+               }
+               return 0;
+       case V4L2_CID_EXPOSURE_AUTO:
+               if (ctrl->val == V4L2_EXPOSURE_AUTO) {
+                       data = reg_set(client, MT9V022_AEC_AGC_ENABLE, 0x1);
+               } else {
+                       struct v4l2_ctrl *exp = mt9v022->exposure;
+                       unsigned long range = exp->maximum - exp->minimum;
+                       unsigned long shutter = ((exp->val - exp->minimum) *
+                                       479 + range / 2) / range + 1;
+
+                       /*
+                        * The user wants to set shutter width manually, hope,
+                        * she knows, what she's doing... Switch AEC off.
+                        */
+                       data = reg_clear(client, MT9V022_AEC_AGC_ENABLE, 0x1);
+                       if (data < 0)
+                               return -EIO;
+                       dev_dbg(&client->dev, "Shutter width from %d to %lu\n",
+                                       reg_read(client, MT9V022_TOTAL_SHUTTER_WIDTH),
+                                       shutter);
+                       if (reg_write(client, MT9V022_TOTAL_SHUTTER_WIDTH,
+                                               shutter) < 0)
+                               return -EIO;
+               }
+               return 0;
+       }
+       return -EINVAL;
+}
+
+/*
+ * Interface active, can use i2c. If it fails, it can indeed mean, that
+ * this wasn't our capture interface, so, we wait for the right one
+ */
+static int mt9v022_video_probe(struct i2c_client *client)
+{
+       struct mt9v022 *mt9v022 = to_mt9v022(client);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+       s32 data;
+       int ret;
+       unsigned long flags;
+
+       /* Read out the chip version register */
+       data = reg_read(client, MT9V022_CHIP_VERSION);
+
+       /* must be 0x1311 or 0x1313 */
+       if (data != 0x1311 && data != 0x1313) {
+               ret = -ENODEV;
+               dev_info(&client->dev, "No MT9V022 found, ID register 0x%x\n",
+                        data);
+               goto ei2c;
+       }
+
+       /* Soft reset */
+       ret = reg_write(client, MT9V022_RESET, 1);
+       if (ret < 0)
+               goto ei2c;
+       /* 15 clock cycles */
+       udelay(200);
+       if (reg_read(client, MT9V022_RESET)) {
+               dev_err(&client->dev, "Resetting MT9V022 failed!\n");
+               if (ret > 0)
+                       ret = -EIO;
+               goto ei2c;
+       }
+
+       /* Set monochrome or colour sensor type */
+       if (sensor_type && (!strcmp("colour", sensor_type) ||
+                           !strcmp("color", sensor_type))) {
+               ret = reg_write(client, MT9V022_PIXEL_OPERATION_MODE, 4 | 0x11);
+               mt9v022->model = V4L2_IDENT_MT9V022IX7ATC;
+               mt9v022->fmts = mt9v022_colour_fmts;
+       } else {
+               ret = reg_write(client, MT9V022_PIXEL_OPERATION_MODE, 0x11);
+               mt9v022->model = V4L2_IDENT_MT9V022IX7ATM;
+               mt9v022->fmts = mt9v022_monochrome_fmts;
+       }
+
+       if (ret < 0)
+               goto ei2c;
+
+       mt9v022->num_fmts = 0;
+
+       /*
+        * This is a 10bit sensor, so by default we only allow 10bit.
+        * The platform may support different bus widths due to
+        * different routing of the data lines.
+        */
+       if (icl->query_bus_param)
+               flags = icl->query_bus_param(icl);
+       else
+               flags = SOCAM_DATAWIDTH_10;
+
+       if (flags & SOCAM_DATAWIDTH_10)
+               mt9v022->num_fmts++;
+       else
+               mt9v022->fmts++;
+
+       if (flags & SOCAM_DATAWIDTH_8)
+               mt9v022->num_fmts++;
+
+       mt9v022->fmt = &mt9v022->fmts[0];
+
+       dev_info(&client->dev, "Detected a MT9V022 chip ID %x, %s sensor\n",
+                data, mt9v022->model == V4L2_IDENT_MT9V022IX7ATM ?
+                "monochrome" : "colour");
+
+       ret = mt9v022_init(client);
+       if (ret < 0)
+               dev_err(&client->dev, "Failed to initialise the camera\n");
+
+ei2c:
+       return ret;
+}
+
+static int mt9v022_g_skip_top_lines(struct v4l2_subdev *sd, u32 *lines)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9v022 *mt9v022 = to_mt9v022(client);
+
+       *lines = mt9v022->y_skip_top;
+
+       return 0;
+}
+
+static const struct v4l2_ctrl_ops mt9v022_ctrl_ops = {
+       .g_volatile_ctrl = mt9v022_g_volatile_ctrl,
+       .s_ctrl = mt9v022_s_ctrl,
+};
+
+static struct v4l2_subdev_core_ops mt9v022_subdev_core_ops = {
+       .g_chip_ident   = mt9v022_g_chip_ident,
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+       .g_register     = mt9v022_g_register,
+       .s_register     = mt9v022_s_register,
+#endif
+};
+
+static int mt9v022_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
+                           enum v4l2_mbus_pixelcode *code)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct mt9v022 *mt9v022 = to_mt9v022(client);
+
+       if (index >= mt9v022->num_fmts)
+               return -EINVAL;
+
+       *code = mt9v022->fmts[index].code;
+       return 0;
+}
+
+static int mt9v022_g_mbus_config(struct v4l2_subdev *sd,
+                               struct v4l2_mbus_config *cfg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+
+       cfg->flags = V4L2_MBUS_MASTER | V4L2_MBUS_SLAVE |
+               V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_PCLK_SAMPLE_FALLING |
+               V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_HSYNC_ACTIVE_LOW |
+               V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_LOW |
+               V4L2_MBUS_DATA_ACTIVE_HIGH;
+       cfg->type = V4L2_MBUS_PARALLEL;
+       cfg->flags = soc_camera_apply_board_flags(icl, cfg);
+
+       return 0;
+}
+
+static int mt9v022_s_mbus_config(struct v4l2_subdev *sd,
+                                const struct v4l2_mbus_config *cfg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+       struct mt9v022 *mt9v022 = to_mt9v022(client);
+       unsigned long flags = soc_camera_apply_board_flags(icl, cfg);
+       unsigned int bps = soc_mbus_get_fmtdesc(mt9v022->fmt->code)->bits_per_sample;
+       int ret;
+       u16 pixclk = 0;
+
+       if (icl->set_bus_param) {
+               ret = icl->set_bus_param(icl, 1 << (bps - 1));
+               if (ret)
+                       return ret;
+       } else if (bps != 10) {
+               /*
+                * Without board specific bus width settings we only support the
+                * sensors native bus width
+                */
+               return -EINVAL;
+       }
+
+       if (flags & V4L2_MBUS_PCLK_SAMPLE_FALLING)
+               pixclk |= 0x10;
+
+       if (!(flags & V4L2_MBUS_HSYNC_ACTIVE_HIGH))
+               pixclk |= 0x1;
+
+       if (!(flags & V4L2_MBUS_VSYNC_ACTIVE_HIGH))
+               pixclk |= 0x2;
+
+       ret = reg_write(client, MT9V022_PIXCLK_FV_LV, pixclk);
+       if (ret < 0)
+               return ret;
+
+       if (!(flags & V4L2_MBUS_MASTER))
+               mt9v022->chip_control &= ~0x8;
+
+       ret = reg_write(client, MT9V022_CHIP_CONTROL, mt9v022->chip_control);
+       if (ret < 0)
+               return ret;
+
+       dev_dbg(&client->dev, "Calculated pixclk 0x%x, chip control 0x%x\n",
+               pixclk, mt9v022->chip_control);
+
+       return 0;
+}
+
+static struct v4l2_subdev_video_ops mt9v022_subdev_video_ops = {
+       .s_stream       = mt9v022_s_stream,
+       .s_mbus_fmt     = mt9v022_s_fmt,
+       .g_mbus_fmt     = mt9v022_g_fmt,
+       .try_mbus_fmt   = mt9v022_try_fmt,
+       .s_crop         = mt9v022_s_crop,
+       .g_crop         = mt9v022_g_crop,
+       .cropcap        = mt9v022_cropcap,
+       .enum_mbus_fmt  = mt9v022_enum_fmt,
+       .g_mbus_config  = mt9v022_g_mbus_config,
+       .s_mbus_config  = mt9v022_s_mbus_config,
+};
+
+static struct v4l2_subdev_sensor_ops mt9v022_subdev_sensor_ops = {
+       .g_skip_top_lines       = mt9v022_g_skip_top_lines,
+};
+
+static struct v4l2_subdev_ops mt9v022_subdev_ops = {
+       .core   = &mt9v022_subdev_core_ops,
+       .video  = &mt9v022_subdev_video_ops,
+       .sensor = &mt9v022_subdev_sensor_ops,
+};
+
+static int mt9v022_probe(struct i2c_client *client,
+                        const struct i2c_device_id *did)
+{
+       struct mt9v022 *mt9v022;
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+       struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
+       int ret;
+
+       if (!icl) {
+               dev_err(&client->dev, "MT9V022 driver needs platform data\n");
+               return -EINVAL;
+       }
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
+               dev_warn(&adapter->dev,
+                        "I2C-Adapter doesn't support I2C_FUNC_SMBUS_WORD\n");
+               return -EIO;
+       }
+
+       mt9v022 = kzalloc(sizeof(struct mt9v022), GFP_KERNEL);
+       if (!mt9v022)
+               return -ENOMEM;
+
+       v4l2_i2c_subdev_init(&mt9v022->subdev, client, &mt9v022_subdev_ops);
+       v4l2_ctrl_handler_init(&mt9v022->hdl, 6);
+       v4l2_ctrl_new_std(&mt9v022->hdl, &mt9v022_ctrl_ops,
+                       V4L2_CID_VFLIP, 0, 1, 1, 0);
+       v4l2_ctrl_new_std(&mt9v022->hdl, &mt9v022_ctrl_ops,
+                       V4L2_CID_HFLIP, 0, 1, 1, 0);
+       mt9v022->autogain = v4l2_ctrl_new_std(&mt9v022->hdl, &mt9v022_ctrl_ops,
+                       V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
+       mt9v022->gain = v4l2_ctrl_new_std(&mt9v022->hdl, &mt9v022_ctrl_ops,
+                       V4L2_CID_GAIN, 0, 127, 1, 64);
+
+       /*
+        * Simulated autoexposure. If enabled, we calculate shutter width
+        * ourselves in the driver based on vertical blanking and frame width
+        */
+       mt9v022->autoexposure = v4l2_ctrl_new_std_menu(&mt9v022->hdl,
+                       &mt9v022_ctrl_ops, V4L2_CID_EXPOSURE_AUTO, 1, 0,
+                       V4L2_EXPOSURE_AUTO);
+       mt9v022->exposure = v4l2_ctrl_new_std(&mt9v022->hdl, &mt9v022_ctrl_ops,
+                       V4L2_CID_EXPOSURE, 1, 255, 1, 255);
+
+       mt9v022->subdev.ctrl_handler = &mt9v022->hdl;
+       if (mt9v022->hdl.error) {
+               int err = mt9v022->hdl.error;
+
+               kfree(mt9v022);
+               return err;
+       }
+       v4l2_ctrl_auto_cluster(2, &mt9v022->autoexposure,
+                               V4L2_EXPOSURE_MANUAL, true);
+       v4l2_ctrl_auto_cluster(2, &mt9v022->autogain, 0, true);
+
+       mt9v022->chip_control = MT9V022_CHIP_CONTROL_DEFAULT;
+
+       /*
+        * MT9V022 _really_ corrupts the first read out line.
+        * TODO: verify on i.MX31
+        */
+       mt9v022->y_skip_top     = 1;
+       mt9v022->rect.left      = MT9V022_COLUMN_SKIP;
+       mt9v022->rect.top       = MT9V022_ROW_SKIP;
+       mt9v022->rect.width     = MT9V022_MAX_WIDTH;
+       mt9v022->rect.height    = MT9V022_MAX_HEIGHT;
+
+       ret = mt9v022_video_probe(client);
+       if (ret) {
+               v4l2_ctrl_handler_free(&mt9v022->hdl);
+               kfree(mt9v022);
+       }
+
+       return ret;
+}
+
+static int mt9v022_remove(struct i2c_client *client)
+{
+       struct mt9v022 *mt9v022 = to_mt9v022(client);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+
+       v4l2_device_unregister_subdev(&mt9v022->subdev);
+       if (icl->free_bus)
+               icl->free_bus(icl);
+       v4l2_ctrl_handler_free(&mt9v022->hdl);
+       kfree(mt9v022);
+
+       return 0;
+}
+static const struct i2c_device_id mt9v022_id[] = {
+       { "mt9v022", 0 },
+       { }
+};
+MODULE_DEVICE_TABLE(i2c, mt9v022_id);
+
+static struct i2c_driver mt9v022_i2c_driver = {
+       .driver = {
+               .name = "mt9v022",
+       },
+       .probe          = mt9v022_probe,
+       .remove         = mt9v022_remove,
+       .id_table       = mt9v022_id,
+};
+
+module_i2c_driver(mt9v022_i2c_driver);
+
+MODULE_DESCRIPTION("Micron MT9V022 Camera driver");
+MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/i2c/soc_camera/ov2640.c b/drivers/media/i2c/soc_camera/ov2640.c
new file mode 100644 (file)
index 0000000..7c44d1f
--- /dev/null
@@ -0,0 +1,1108 @@
+/*
+ * ov2640 Camera Driver
+ *
+ * Copyright (C) 2010 Alberto Panizzo <maramaopercheseimorto@gmail.com>
+ *
+ * Based on ov772x, ov9640 drivers and previous non merged implementations.
+ *
+ * Copyright 2005-2009 Freescale Semiconductor, Inc. All Rights Reserved.
+ * Copyright (C) 2006, OmniVision
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/v4l2-mediabus.h>
+#include <linux/videodev2.h>
+
+#include <media/soc_camera.h>
+#include <media/v4l2-chip-ident.h>
+#include <media/v4l2-subdev.h>
+#include <media/v4l2-ctrls.h>
+
+#define VAL_SET(x, mask, rshift, lshift)  \
+               ((((x) >> rshift) & mask) << lshift)
+/*
+ * DSP registers
+ * register offset for BANK_SEL == BANK_SEL_DSP
+ */
+#define R_BYPASS    0x05 /* Bypass DSP */
+#define   R_BYPASS_DSP_BYPAS    0x01 /* Bypass DSP, sensor out directly */
+#define   R_BYPASS_USE_DSP      0x00 /* Use the internal DSP */
+#define QS          0x44 /* Quantization Scale Factor */
+#define CTRLI       0x50
+#define   CTRLI_LP_DP           0x80
+#define   CTRLI_ROUND           0x40
+#define   CTRLI_V_DIV_SET(x)    VAL_SET(x, 0x3, 0, 3)
+#define   CTRLI_H_DIV_SET(x)    VAL_SET(x, 0x3, 0, 0)
+#define HSIZE       0x51 /* H_SIZE[7:0] (real/4) */
+#define   HSIZE_SET(x)          VAL_SET(x, 0xFF, 2, 0)
+#define VSIZE       0x52 /* V_SIZE[7:0] (real/4) */
+#define   VSIZE_SET(x)          VAL_SET(x, 0xFF, 2, 0)
+#define XOFFL       0x53 /* OFFSET_X[7:0] */
+#define   XOFFL_SET(x)          VAL_SET(x, 0xFF, 0, 0)
+#define YOFFL       0x54 /* OFFSET_Y[7:0] */
+#define   YOFFL_SET(x)          VAL_SET(x, 0xFF, 0, 0)
+#define VHYX        0x55 /* Offset and size completion */
+#define   VHYX_VSIZE_SET(x)     VAL_SET(x, 0x1, (8+2), 7)
+#define   VHYX_HSIZE_SET(x)     VAL_SET(x, 0x1, (8+2), 3)
+#define   VHYX_YOFF_SET(x)      VAL_SET(x, 0x3, 8, 4)
+#define   VHYX_XOFF_SET(x)      VAL_SET(x, 0x3, 8, 0)
+#define DPRP        0x56
+#define TEST        0x57 /* Horizontal size completion */
+#define   TEST_HSIZE_SET(x)     VAL_SET(x, 0x1, (9+2), 7)
+#define ZMOW        0x5A /* Zoom: Out Width  OUTW[7:0] (real/4) */
+#define   ZMOW_OUTW_SET(x)      VAL_SET(x, 0xFF, 2, 0)
+#define ZMOH        0x5B /* Zoom: Out Height OUTH[7:0] (real/4) */
+#define   ZMOH_OUTH_SET(x)      VAL_SET(x, 0xFF, 2, 0)
+#define ZMHH        0x5C /* Zoom: Speed and H&W completion */
+#define   ZMHH_ZSPEED_SET(x)    VAL_SET(x, 0x0F, 0, 4)
+#define   ZMHH_OUTH_SET(x)      VAL_SET(x, 0x1, (8+2), 2)
+#define   ZMHH_OUTW_SET(x)      VAL_SET(x, 0x3, (8+2), 0)
+#define BPADDR      0x7C /* SDE Indirect Register Access: Address */
+#define BPDATA      0x7D /* SDE Indirect Register Access: Data */
+#define CTRL2       0x86 /* DSP Module enable 2 */
+#define   CTRL2_DCW_EN          0x20
+#define   CTRL2_SDE_EN          0x10
+#define   CTRL2_UV_ADJ_EN       0x08
+#define   CTRL2_UV_AVG_EN       0x04
+#define   CTRL2_CMX_EN          0x01
+#define CTRL3       0x87 /* DSP Module enable 3 */
+#define   CTRL3_BPC_EN          0x80
+#define   CTRL3_WPC_EN          0x40
+#define SIZEL       0x8C /* Image Size Completion */
+#define   SIZEL_HSIZE8_11_SET(x) VAL_SET(x, 0x1, 11, 6)
+#define   SIZEL_HSIZE8_SET(x)    VAL_SET(x, 0x7, 0, 3)
+#define   SIZEL_VSIZE8_SET(x)    VAL_SET(x, 0x7, 0, 0)
+#define HSIZE8      0xC0 /* Image Horizontal Size HSIZE[10:3] */
+#define   HSIZE8_SET(x)         VAL_SET(x, 0xFF, 3, 0)
+#define VSIZE8      0xC1 /* Image Vertical Size VSIZE[10:3] */
+#define   VSIZE8_SET(x)         VAL_SET(x, 0xFF, 3, 0)
+#define CTRL0       0xC2 /* DSP Module enable 0 */
+#define   CTRL0_AEC_EN       0x80
+#define   CTRL0_AEC_SEL      0x40
+#define   CTRL0_STAT_SEL     0x20
+#define   CTRL0_VFIRST       0x10
+#define   CTRL0_YUV422       0x08
+#define   CTRL0_YUV_EN       0x04
+#define   CTRL0_RGB_EN       0x02
+#define   CTRL0_RAW_EN       0x01
+#define CTRL1       0xC3 /* DSP Module enable 1 */
+#define   CTRL1_CIP          0x80
+#define   CTRL1_DMY          0x40
+#define   CTRL1_RAW_GMA      0x20
+#define   CTRL1_DG           0x10
+#define   CTRL1_AWB          0x08
+#define   CTRL1_AWB_GAIN     0x04
+#define   CTRL1_LENC         0x02
+#define   CTRL1_PRE          0x01
+#define R_DVP_SP    0xD3 /* DVP output speed control */
+#define   R_DVP_SP_AUTO_MODE 0x80
+#define   R_DVP_SP_DVP_MASK  0x3F /* DVP PCLK = sysclk (48)/[6:0] (YUV0);
+                                  *          = sysclk (48)/(2*[6:0]) (RAW);*/
+#define IMAGE_MODE  0xDA /* Image Output Format Select */
+#define   IMAGE_MODE_Y8_DVP_EN   0x40
+#define   IMAGE_MODE_JPEG_EN     0x10
+#define   IMAGE_MODE_YUV422      0x00
+#define   IMAGE_MODE_RAW10       0x04 /* (DVP) */
+#define   IMAGE_MODE_RGB565      0x08
+#define   IMAGE_MODE_HREF_VSYNC  0x02 /* HREF timing select in DVP JPEG output
+                                      * mode (0 for HREF is same as sensor) */
+#define   IMAGE_MODE_LBYTE_FIRST 0x01 /* Byte swap enable for DVP
+                                      *    1: Low byte first UYVY (C2[4] =0)
+                                      *        VYUY (C2[4] =1)
+                                      *    0: High byte first YUYV (C2[4]=0)
+                                      *        YVYU (C2[4] = 1) */
+#define RESET       0xE0 /* Reset */
+#define   RESET_MICROC       0x40
+#define   RESET_SCCB         0x20
+#define   RESET_JPEG         0x10
+#define   RESET_DVP          0x04
+#define   RESET_IPU          0x02
+#define   RESET_CIF          0x01
+#define REGED       0xED /* Register ED */
+#define   REGED_CLK_OUT_DIS  0x10
+#define MS_SP       0xF0 /* SCCB Master Speed */
+#define SS_ID       0xF7 /* SCCB Slave ID */
+#define SS_CTRL     0xF8 /* SCCB Slave Control */
+#define   SS_CTRL_ADD_AUTO_INC  0x20
+#define   SS_CTRL_EN            0x08
+#define   SS_CTRL_DELAY_CLK     0x04
+#define   SS_CTRL_ACC_EN        0x02
+#define   SS_CTRL_SEN_PASS_THR  0x01
+#define MC_BIST     0xF9 /* Microcontroller misc register */
+#define   MC_BIST_RESET           0x80 /* Microcontroller Reset */
+#define   MC_BIST_BOOT_ROM_SEL    0x40
+#define   MC_BIST_12KB_SEL        0x20
+#define   MC_BIST_12KB_MASK       0x30
+#define   MC_BIST_512KB_SEL       0x08
+#define   MC_BIST_512KB_MASK      0x0C
+#define   MC_BIST_BUSY_BIT_R      0x02
+#define   MC_BIST_MC_RES_ONE_SH_W 0x02
+#define   MC_BIST_LAUNCH          0x01
+#define BANK_SEL    0xFF /* Register Bank Select */
+#define   BANK_SEL_DSP     0x00
+#define   BANK_SEL_SENS    0x01
+
+/*
+ * Sensor registers
+ * register offset for BANK_SEL == BANK_SEL_SENS
+ */
+#define GAIN        0x00 /* AGC - Gain control gain setting */
+#define COM1        0x03 /* Common control 1 */
+#define   COM1_1_DUMMY_FR          0x40
+#define   COM1_3_DUMMY_FR          0x80
+#define   COM1_7_DUMMY_FR          0xC0
+#define   COM1_VWIN_LSB_UXGA       0x0F
+#define   COM1_VWIN_LSB_SVGA       0x0A
+#define   COM1_VWIN_LSB_CIF        0x06
+#define REG04       0x04 /* Register 04 */
+#define   REG04_DEF             0x20 /* Always set */
+#define   REG04_HFLIP_IMG       0x80 /* Horizontal mirror image ON/OFF */
+#define   REG04_VFLIP_IMG       0x40 /* Vertical flip image ON/OFF */
+#define   REG04_VREF_EN         0x10
+#define   REG04_HREF_EN         0x08
+#define   REG04_AEC_SET(x)      VAL_SET(x, 0x3, 0, 0)
+#define REG08       0x08 /* Frame Exposure One-pin Control Pre-charge Row Num */
+#define COM2        0x09 /* Common control 2 */
+#define   COM2_SOFT_SLEEP_MODE  0x10 /* Soft sleep mode */
+                                    /* Output drive capability */
+#define   COM2_OCAP_Nx_SET(N)   (((N) - 1) & 0x03) /* N = [1x .. 4x] */
+#define PID         0x0A /* Product ID Number MSB */
+#define VER         0x0B /* Product ID Number LSB */
+#define COM3        0x0C /* Common control 3 */
+#define   COM3_BAND_50H        0x04 /* 0 For Banding at 60H */
+#define   COM3_BAND_AUTO       0x02 /* Auto Banding */
+#define   COM3_SING_FR_SNAPSH  0x01 /* 0 For enable live video output after the
+                                    * snapshot sequence*/
+#define AEC         0x10 /* AEC[9:2] Exposure Value */
+#define CLKRC       0x11 /* Internal clock */
+#define   CLKRC_EN             0x80
+#define   CLKRC_DIV_SET(x)     (((x) - 1) & 0x1F) /* CLK = XVCLK/(x) */
+#define COM7        0x12 /* Common control 7 */
+#define   COM7_SRST            0x80 /* Initiates system reset. All registers are
+                                    * set to factory default values after which
+                                    * the chip resumes normal operation */
+#define   COM7_RES_UXGA        0x00 /* Resolution selectors for UXGA */
+#define   COM7_RES_SVGA        0x40 /* SVGA */
+#define   COM7_RES_CIF         0x20 /* CIF */
+#define   COM7_ZOOM_EN         0x04 /* Enable Zoom mode */
+#define   COM7_COLOR_BAR_TEST  0x02 /* Enable Color Bar Test Pattern */
+#define COM8        0x13 /* Common control 8 */
+#define   COM8_DEF             0xC0 /* Banding filter ON/OFF */
+#define   COM8_BNDF_EN         0x20 /* Banding filter ON/OFF */
+#define   COM8_AGC_EN          0x04 /* AGC Auto/Manual control selection */
+#define   COM8_AEC_EN          0x01 /* Auto/Manual Exposure control */
+#define COM9        0x14 /* Common control 9
+                         * Automatic gain ceiling - maximum AGC value [7:5]*/
+#define   COM9_AGC_GAIN_2x     0x00 /* 000 :   2x */
+#define   COM9_AGC_GAIN_4x     0x20 /* 001 :   4x */
+#define   COM9_AGC_GAIN_8x     0x40 /* 010 :   8x */
+#define   COM9_AGC_GAIN_16x    0x60 /* 011 :  16x */
+#define   COM9_AGC_GAIN_32x    0x80 /* 100 :  32x */
+#define   COM9_AGC_GAIN_64x    0xA0 /* 101 :  64x */
+#define   COM9_AGC_GAIN_128x   0xC0 /* 110 : 128x */
+#define COM10       0x15 /* Common control 10 */
+#define   COM10_PCLK_HREF      0x20 /* PCLK output qualified by HREF */
+#define   COM10_PCLK_RISE      0x10 /* Data is updated at the rising edge of
+                                    * PCLK (user can latch data at the next
+                                    * falling edge of PCLK).
+                                    * 0 otherwise. */
+#define   COM10_HREF_INV       0x08 /* Invert HREF polarity:
+                                    * HREF negative for valid data*/
+#define   COM10_VSINC_INV      0x02 /* Invert VSYNC polarity */
+#define HSTART      0x17 /* Horizontal Window start MSB 8 bit */
+#define HEND        0x18 /* Horizontal Window end MSB 8 bit */
+#define VSTART      0x19 /* Vertical Window start MSB 8 bit */
+#define VEND        0x1A /* Vertical Window end MSB 8 bit */
+#define MIDH        0x1C /* Manufacturer ID byte - high */
+#define MIDL        0x1D /* Manufacturer ID byte - low  */
+#define AEW         0x24 /* AGC/AEC - Stable operating region (upper limit) */
+#define AEB         0x25 /* AGC/AEC - Stable operating region (lower limit) */
+#define VV          0x26 /* AGC/AEC Fast mode operating region */
+#define   VV_HIGH_TH_SET(x)      VAL_SET(x, 0xF, 0, 4)
+#define   VV_LOW_TH_SET(x)       VAL_SET(x, 0xF, 0, 0)
+#define REG2A       0x2A /* Dummy pixel insert MSB */
+#define FRARL       0x2B /* Dummy pixel insert LSB */
+#define ADDVFL      0x2D /* LSB of insert dummy lines in Vertical direction */
+#define ADDVFH      0x2E /* MSB of insert dummy lines in Vertical direction */
+#define YAVG        0x2F /* Y/G Channel Average value */
+#define REG32       0x32 /* Common Control 32 */
+#define   REG32_PCLK_DIV_2    0x80 /* PCLK freq divided by 2 */
+#define   REG32_PCLK_DIV_4    0xC0 /* PCLK freq divided by 4 */
+#define ARCOM2      0x34 /* Zoom: Horizontal start point */
+#define REG45       0x45 /* Register 45 */
+#define FLL         0x46 /* Frame Length Adjustment LSBs */
+#define FLH         0x47 /* Frame Length Adjustment MSBs */
+#define COM19       0x48 /* Zoom: Vertical start point */
+#define ZOOMS       0x49 /* Zoom: Vertical start point */
+#define COM22       0x4B /* Flash light control */
+#define COM25       0x4E /* For Banding operations */
+#define BD50        0x4F /* 50Hz Banding AEC 8 LSBs */
+#define BD60        0x50 /* 60Hz Banding AEC 8 LSBs */
+#define REG5D       0x5D /* AVGsel[7:0],   16-zone average weight option */
+#define REG5E       0x5E /* AVGsel[15:8],  16-zone average weight option */
+#define REG5F       0x5F /* AVGsel[23:16], 16-zone average weight option */
+#define REG60       0x60 /* AVGsel[31:24], 16-zone average weight option */
+#define HISTO_LOW   0x61 /* Histogram Algorithm Low Level */
+#define HISTO_HIGH  0x62 /* Histogram Algorithm High Level */
+
+/*
+ * ID
+ */
+#define MANUFACTURER_ID        0x7FA2
+#define PID_OV2640     0x2642
+#define VERSION(pid, ver) ((pid << 8) | (ver & 0xFF))
+
+/*
+ * Struct
+ */
+struct regval_list {
+       u8 reg_num;
+       u8 value;
+};
+
+/* Supported resolutions */
+enum ov2640_width {
+       W_QCIF  = 176,
+       W_QVGA  = 320,
+       W_CIF   = 352,
+       W_VGA   = 640,
+       W_SVGA  = 800,
+       W_XGA   = 1024,
+       W_SXGA  = 1280,
+       W_UXGA  = 1600,
+};
+
+enum ov2640_height {
+       H_QCIF  = 144,
+       H_QVGA  = 240,
+       H_CIF   = 288,
+       H_VGA   = 480,
+       H_SVGA  = 600,
+       H_XGA   = 768,
+       H_SXGA  = 1024,
+       H_UXGA  = 1200,
+};
+
+struct ov2640_win_size {
+       char                            *name;
+       enum ov2640_width               width;
+       enum ov2640_height              height;
+       const struct regval_list        *regs;
+};
+
+
+struct ov2640_priv {
+       struct v4l2_subdev              subdev;
+       struct v4l2_ctrl_handler        hdl;
+       enum v4l2_mbus_pixelcode        cfmt_code;
+       const struct ov2640_win_size    *win;
+       int                             model;
+};
+
+/*
+ * Registers settings
+ */
+
+#define ENDMARKER { 0xff, 0xff }
+
+static const struct regval_list ov2640_init_regs[] = {
+       { BANK_SEL, BANK_SEL_DSP },
+       { 0x2c,   0xff },
+       { 0x2e,   0xdf },
+       { BANK_SEL, BANK_SEL_SENS },
+       { 0x3c,   0x32 },
+       { CLKRC, CLKRC_DIV_SET(1) },
+       { COM2, COM2_OCAP_Nx_SET(3) },
+       { REG04, REG04_DEF | REG04_HREF_EN },
+       { COM8,  COM8_DEF | COM8_BNDF_EN | COM8_AGC_EN | COM8_AEC_EN },
+       { COM9, COM9_AGC_GAIN_8x | 0x08},
+       { 0x2c,   0x0c },
+       { 0x33,   0x78 },
+       { 0x3a,   0x33 },
+       { 0x3b,   0xfb },
+       { 0x3e,   0x00 },
+       { 0x43,   0x11 },
+       { 0x16,   0x10 },
+       { 0x39,   0x02 },
+       { 0x35,   0x88 },
+       { 0x22,   0x0a },
+       { 0x37,   0x40 },
+       { 0x23,   0x00 },
+       { ARCOM2, 0xa0 },
+       { 0x06,   0x02 },
+       { 0x06,   0x88 },
+       { 0x07,   0xc0 },
+       { 0x0d,   0xb7 },
+       { 0x0e,   0x01 },
+       { 0x4c,   0x00 },
+       { 0x4a,   0x81 },
+       { 0x21,   0x99 },
+       { AEW,    0x40 },
+       { AEB,    0x38 },
+       { VV,     VV_HIGH_TH_SET(0x08) | VV_LOW_TH_SET(0x02) },
+       { 0x5c,   0x00 },
+       { 0x63,   0x00 },
+       { FLL,    0x22 },
+       { COM3,   0x38 | COM3_BAND_AUTO },
+       { REG5D,  0x55 },
+       { REG5E,  0x7d },
+       { REG5F,  0x7d },
+       { REG60,  0x55 },
+       { HISTO_LOW,   0x70 },
+       { HISTO_HIGH,  0x80 },
+       { 0x7c,   0x05 },
+       { 0x20,   0x80 },
+       { 0x28,   0x30 },
+       { 0x6c,   0x00 },
+       { 0x6d,   0x80 },
+       { 0x6e,   0x00 },
+       { 0x70,   0x02 },
+       { 0x71,   0x94 },
+       { 0x73,   0xc1 },
+       { 0x3d,   0x34 },
+       { COM7, COM7_RES_UXGA | COM7_ZOOM_EN },
+       { 0x5a,   0x57 },
+       { BD50,   0xbb },
+       { BD60,   0x9c },
+       { BANK_SEL, BANK_SEL_DSP },
+       { 0xe5,   0x7f },
+       { MC_BIST, MC_BIST_RESET | MC_BIST_BOOT_ROM_SEL },
+       { 0x41,   0x24 },
+       { RESET, RESET_JPEG | RESET_DVP },
+       { 0x76,   0xff },
+       { 0x33,   0xa0 },
+       { 0x42,   0x20 },
+       { 0x43,   0x18 },
+       { 0x4c,   0x00 },
+       { CTRL3, CTRL3_BPC_EN | CTRL3_WPC_EN | 0x10 },
+       { 0x88,   0x3f },
+       { 0xd7,   0x03 },
+       { 0xd9,   0x10 },
+       { R_DVP_SP , R_DVP_SP_AUTO_MODE | 0x2 },
+       { 0xc8,   0x08 },
+       { 0xc9,   0x80 },
+       { BPADDR, 0x00 },
+       { BPDATA, 0x00 },
+       { BPADDR, 0x03 },
+       { BPDATA, 0x48 },
+       { BPDATA, 0x48 },
+       { BPADDR, 0x08 },
+       { BPDATA, 0x20 },
+       { BPDATA, 0x10 },
+       { BPDATA, 0x0e },
+       { 0x90,   0x00 },
+       { 0x91,   0x0e },
+       { 0x91,   0x1a },
+       { 0x91,   0x31 },
+       { 0x91,   0x5a },
+       { 0x91,   0x69 },
+       { 0x91,   0x75 },
+       { 0x91,   0x7e },
+       { 0x91,   0x88 },
+       { 0x91,   0x8f },
+       { 0x91,   0x96 },
+       { 0x91,   0xa3 },
+       { 0x91,   0xaf },
+       { 0x91,   0xc4 },
+       { 0x91,   0xd7 },
+       { 0x91,   0xe8 },
+       { 0x91,   0x20 },
+       { 0x92,   0x00 },
+       { 0x93,   0x06 },
+       { 0x93,   0xe3 },
+       { 0x93,   0x03 },
+       { 0x93,   0x03 },
+       { 0x93,   0x00 },
+       { 0x93,   0x02 },
+       { 0x93,   0x00 },
+       { 0x93,   0x00 },
+       { 0x93,   0x00 },
+       { 0x93,   0x00 },
+       { 0x93,   0x00 },
+       { 0x93,   0x00 },
+       { 0x93,   0x00 },
+       { 0x96,   0x00 },
+       { 0x97,   0x08 },
+       { 0x97,   0x19 },
+       { 0x97,   0x02 },
+       { 0x97,   0x0c },
+       { 0x97,   0x24 },
+       { 0x97,   0x30 },
+       { 0x97,   0x28 },
+       { 0x97,   0x26 },
+       { 0x97,   0x02 },
+       { 0x97,   0x98 },
+       { 0x97,   0x80 },
+       { 0x97,   0x00 },
+       { 0x97,   0x00 },
+       { 0xa4,   0x00 },
+       { 0xa8,   0x00 },
+       { 0xc5,   0x11 },
+       { 0xc6,   0x51 },
+       { 0xbf,   0x80 },
+       { 0xc7,   0x10 },
+       { 0xb6,   0x66 },
+       { 0xb8,   0xA5 },
+       { 0xb7,   0x64 },
+       { 0xb9,   0x7C },
+       { 0xb3,   0xaf },
+       { 0xb4,   0x97 },
+       { 0xb5,   0xFF },
+       { 0xb0,   0xC5 },
+       { 0xb1,   0x94 },
+       { 0xb2,   0x0f },
+       { 0xc4,   0x5c },
+       { 0xa6,   0x00 },
+       { 0xa7,   0x20 },
+       { 0xa7,   0xd8 },
+       { 0xa7,   0x1b },
+       { 0xa7,   0x31 },
+       { 0xa7,   0x00 },
+       { 0xa7,   0x18 },
+       { 0xa7,   0x20 },
+       { 0xa7,   0xd8 },
+       { 0xa7,   0x19 },
+       { 0xa7,   0x31 },
+       { 0xa7,   0x00 },
+       { 0xa7,   0x18 },
+       { 0xa7,   0x20 },
+       { 0xa7,   0xd8 },
+       { 0xa7,   0x19 },
+       { 0xa7,   0x31 },
+       { 0xa7,   0x00 },
+       { 0xa7,   0x18 },
+       { 0x7f,   0x00 },
+       { 0xe5,   0x1f },
+       { 0xe1,   0x77 },
+       { 0xdd,   0x7f },
+       { CTRL0,  CTRL0_YUV422 | CTRL0_YUV_EN | CTRL0_RGB_EN },
+       ENDMARKER,
+};
+
+/*
+ * Register settings for window size
+ * The preamble, setup the internal DSP to input an UXGA (1600x1200) image.
+ * Then the different zooming configurations will setup the output image size.
+ */
+static const struct regval_list ov2640_size_change_preamble_regs[] = {
+       { BANK_SEL, BANK_SEL_DSP },
+       { RESET, RESET_DVP },
+       { HSIZE8, HSIZE8_SET(W_UXGA) },
+       { VSIZE8, VSIZE8_SET(H_UXGA) },
+       { CTRL2, CTRL2_DCW_EN | CTRL2_SDE_EN |
+                CTRL2_UV_AVG_EN | CTRL2_CMX_EN | CTRL2_UV_ADJ_EN },
+       { HSIZE, HSIZE_SET(W_UXGA) },
+       { VSIZE, VSIZE_SET(H_UXGA) },
+       { XOFFL, XOFFL_SET(0) },
+       { YOFFL, YOFFL_SET(0) },
+       { VHYX, VHYX_HSIZE_SET(W_UXGA) | VHYX_VSIZE_SET(H_UXGA) |
+               VHYX_XOFF_SET(0) | VHYX_YOFF_SET(0)},
+       { TEST, TEST_HSIZE_SET(W_UXGA) },
+       ENDMARKER,
+};
+
+#define PER_SIZE_REG_SEQ(x, y, v_div, h_div, pclk_div) \
+       { CTRLI, CTRLI_LP_DP | CTRLI_V_DIV_SET(v_div) | \
+                CTRLI_H_DIV_SET(h_div)},               \
+       { ZMOW, ZMOW_OUTW_SET(x) },                     \
+       { ZMOH, ZMOH_OUTH_SET(y) },                     \
+       { ZMHH, ZMHH_OUTW_SET(x) | ZMHH_OUTH_SET(y) },  \
+       { R_DVP_SP, pclk_div },                         \
+       { RESET, 0x00}
+
+static const struct regval_list ov2640_qcif_regs[] = {
+       PER_SIZE_REG_SEQ(W_QCIF, H_QCIF, 3, 3, 4),
+       ENDMARKER,
+};
+
+static const struct regval_list ov2640_qvga_regs[] = {
+       PER_SIZE_REG_SEQ(W_QVGA, H_QVGA, 2, 2, 4),
+       ENDMARKER,
+};
+
+static const struct regval_list ov2640_cif_regs[] = {
+       PER_SIZE_REG_SEQ(W_CIF, H_CIF, 2, 2, 8),
+       ENDMARKER,
+};
+
+static const struct regval_list ov2640_vga_regs[] = {
+       PER_SIZE_REG_SEQ(W_VGA, H_VGA, 0, 0, 2),
+       ENDMARKER,
+};
+
+static const struct regval_list ov2640_svga_regs[] = {
+       PER_SIZE_REG_SEQ(W_SVGA, H_SVGA, 1, 1, 2),
+       ENDMARKER,
+};
+
+static const struct regval_list ov2640_xga_regs[] = {
+       PER_SIZE_REG_SEQ(W_XGA, H_XGA, 0, 0, 2),
+       { CTRLI,    0x00},
+       ENDMARKER,
+};
+
+static const struct regval_list ov2640_sxga_regs[] = {
+       PER_SIZE_REG_SEQ(W_SXGA, H_SXGA, 0, 0, 2),
+       { CTRLI,    0x00},
+       { R_DVP_SP, 2 | R_DVP_SP_AUTO_MODE },
+       ENDMARKER,
+};
+
+static const struct regval_list ov2640_uxga_regs[] = {
+       PER_SIZE_REG_SEQ(W_UXGA, H_UXGA, 0, 0, 0),
+       { CTRLI,    0x00},
+       { R_DVP_SP, 0 | R_DVP_SP_AUTO_MODE },
+       ENDMARKER,
+};
+
+#define OV2640_SIZE(n, w, h, r) \
+       {.name = n, .width = w , .height = h, .regs = r }
+
+static const struct ov2640_win_size ov2640_supported_win_sizes[] = {
+       OV2640_SIZE("QCIF", W_QCIF, H_QCIF, ov2640_qcif_regs),
+       OV2640_SIZE("QVGA", W_QVGA, H_QVGA, ov2640_qvga_regs),
+       OV2640_SIZE("CIF", W_CIF, H_CIF, ov2640_cif_regs),
+       OV2640_SIZE("VGA", W_VGA, H_VGA, ov2640_vga_regs),
+       OV2640_SIZE("SVGA", W_SVGA, H_SVGA, ov2640_svga_regs),
+       OV2640_SIZE("XGA", W_XGA, H_XGA, ov2640_xga_regs),
+       OV2640_SIZE("SXGA", W_SXGA, H_SXGA, ov2640_sxga_regs),
+       OV2640_SIZE("UXGA", W_UXGA, H_UXGA, ov2640_uxga_regs),
+};
+
+/*
+ * Register settings for pixel formats
+ */
+static const struct regval_list ov2640_format_change_preamble_regs[] = {
+       { BANK_SEL, BANK_SEL_DSP },
+       { R_BYPASS, R_BYPASS_USE_DSP },
+       ENDMARKER,
+};
+
+static const struct regval_list ov2640_yuv422_regs[] = {
+       { IMAGE_MODE, IMAGE_MODE_LBYTE_FIRST | IMAGE_MODE_YUV422 },
+       { 0xD7, 0x01 },
+       { 0x33, 0xa0 },
+       { 0xe1, 0x67 },
+       { RESET,  0x00 },
+       { R_BYPASS, R_BYPASS_USE_DSP },
+       ENDMARKER,
+};
+
+static const struct regval_list ov2640_rgb565_regs[] = {
+       { IMAGE_MODE, IMAGE_MODE_LBYTE_FIRST | IMAGE_MODE_RGB565 },
+       { 0xd7, 0x03 },
+       { RESET,  0x00 },
+       { R_BYPASS, R_BYPASS_USE_DSP },
+       ENDMARKER,
+};
+
+static enum v4l2_mbus_pixelcode ov2640_codes[] = {
+       V4L2_MBUS_FMT_UYVY8_2X8,
+       V4L2_MBUS_FMT_RGB565_2X8_LE,
+};
+
+/*
+ * General functions
+ */
+static struct ov2640_priv *to_ov2640(const struct i2c_client *client)
+{
+       return container_of(i2c_get_clientdata(client), struct ov2640_priv,
+                           subdev);
+}
+
+static int ov2640_write_array(struct i2c_client *client,
+                             const struct regval_list *vals)
+{
+       int ret;
+
+       while ((vals->reg_num != 0xff) || (vals->value != 0xff)) {
+               ret = i2c_smbus_write_byte_data(client,
+                                               vals->reg_num, vals->value);
+               dev_vdbg(&client->dev, "array: 0x%02x, 0x%02x",
+                        vals->reg_num, vals->value);
+
+               if (ret < 0)
+                       return ret;
+               vals++;
+       }
+       return 0;
+}
+
+static int ov2640_mask_set(struct i2c_client *client,
+                          u8  reg, u8  mask, u8  set)
+{
+       s32 val = i2c_smbus_read_byte_data(client, reg);
+       if (val < 0)
+               return val;
+
+       val &= ~mask;
+       val |= set & mask;
+
+       dev_vdbg(&client->dev, "masks: 0x%02x, 0x%02x", reg, val);
+
+       return i2c_smbus_write_byte_data(client, reg, val);
+}
+
+static int ov2640_reset(struct i2c_client *client)
+{
+       int ret;
+       const struct regval_list reset_seq[] = {
+               {BANK_SEL, BANK_SEL_SENS},
+               {COM7, COM7_SRST},
+               ENDMARKER,
+       };
+
+       ret = ov2640_write_array(client, reset_seq);
+       if (ret)
+               goto err;
+
+       msleep(5);
+err:
+       dev_dbg(&client->dev, "%s: (ret %d)", __func__, ret);
+       return ret;
+}
+
+/*
+ * soc_camera_ops functions
+ */
+static int ov2640_s_stream(struct v4l2_subdev *sd, int enable)
+{
+       return 0;
+}
+
+static int ov2640_s_ctrl(struct v4l2_ctrl *ctrl)
+{
+       struct v4l2_subdev *sd =
+               &container_of(ctrl->handler, struct ov2640_priv, hdl)->subdev;
+       struct i2c_client  *client = v4l2_get_subdevdata(sd);
+       u8 val;
+
+       switch (ctrl->id) {
+       case V4L2_CID_VFLIP:
+               val = ctrl->val ? REG04_VFLIP_IMG : 0x00;
+               return ov2640_mask_set(client, REG04, REG04_VFLIP_IMG, val);
+       case V4L2_CID_HFLIP:
+               val = ctrl->val ? REG04_HFLIP_IMG : 0x00;
+               return ov2640_mask_set(client, REG04, REG04_HFLIP_IMG, val);
+       }
+
+       return -EINVAL;
+}
+
+static int ov2640_g_chip_ident(struct v4l2_subdev *sd,
+                              struct v4l2_dbg_chip_ident *id)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct ov2640_priv *priv = to_ov2640(client);
+
+       id->ident    = priv->model;
+       id->revision = 0;
+
+       return 0;
+}
+
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+static int ov2640_g_register(struct v4l2_subdev *sd,
+                            struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       int ret;
+
+       reg->size = 1;
+       if (reg->reg > 0xff)
+               return -EINVAL;
+
+       ret = i2c_smbus_read_byte_data(client, reg->reg);
+       if (ret < 0)
+               return ret;
+
+       reg->val = ret;
+
+       return 0;
+}
+
+static int ov2640_s_register(struct v4l2_subdev *sd,
+                            struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+       if (reg->reg > 0xff ||
+           reg->val > 0xff)
+               return -EINVAL;
+
+       return i2c_smbus_write_byte_data(client, reg->reg, reg->val);
+}
+#endif
+
+/* Select the nearest higher resolution for capture */
+static const struct ov2640_win_size *ov2640_select_win(u32 *width, u32 *height)
+{
+       int i, default_size = ARRAY_SIZE(ov2640_supported_win_sizes) - 1;
+
+       for (i = 0; i < ARRAY_SIZE(ov2640_supported_win_sizes); i++) {
+               if (ov2640_supported_win_sizes[i].width  >= *width &&
+                   ov2640_supported_win_sizes[i].height >= *height) {
+                       *width = ov2640_supported_win_sizes[i].width;
+                       *height = ov2640_supported_win_sizes[i].height;
+                       return &ov2640_supported_win_sizes[i];
+               }
+       }
+
+       *width = ov2640_supported_win_sizes[default_size].width;
+       *height = ov2640_supported_win_sizes[default_size].height;
+       return &ov2640_supported_win_sizes[default_size];
+}
+
+static int ov2640_set_params(struct i2c_client *client, u32 *width, u32 *height,
+                            enum v4l2_mbus_pixelcode code)
+{
+       struct ov2640_priv       *priv = to_ov2640(client);
+       const struct regval_list *selected_cfmt_regs;
+       int ret;
+
+       /* select win */
+       priv->win = ov2640_select_win(width, height);
+
+       /* select format */
+       priv->cfmt_code = 0;
+       switch (code) {
+       case V4L2_MBUS_FMT_RGB565_2X8_LE:
+               dev_dbg(&client->dev, "%s: Selected cfmt RGB565", __func__);
+               selected_cfmt_regs = ov2640_rgb565_regs;
+               break;
+       default:
+       case V4L2_MBUS_FMT_UYVY8_2X8:
+               dev_dbg(&client->dev, "%s: Selected cfmt YUV422", __func__);
+               selected_cfmt_regs = ov2640_yuv422_regs;
+       }
+
+       /* reset hardware */
+       ov2640_reset(client);
+
+       /* initialize the sensor with default data */
+       dev_dbg(&client->dev, "%s: Init default", __func__);
+       ret = ov2640_write_array(client, ov2640_init_regs);
+       if (ret < 0)
+               goto err;
+
+       /* select preamble */
+       dev_dbg(&client->dev, "%s: Set size to %s", __func__, priv->win->name);
+       ret = ov2640_write_array(client, ov2640_size_change_preamble_regs);
+       if (ret < 0)
+               goto err;
+
+       /* set size win */
+       ret = ov2640_write_array(client, priv->win->regs);
+       if (ret < 0)
+               goto err;
+
+       /* cfmt preamble */
+       dev_dbg(&client->dev, "%s: Set cfmt", __func__);
+       ret = ov2640_write_array(client, ov2640_format_change_preamble_regs);
+       if (ret < 0)
+               goto err;
+
+       /* set cfmt */
+       ret = ov2640_write_array(client, selected_cfmt_regs);
+       if (ret < 0)
+               goto err;
+
+       priv->cfmt_code = code;
+       *width = priv->win->width;
+       *height = priv->win->height;
+
+       return 0;
+
+err:
+       dev_err(&client->dev, "%s: Error %d", __func__, ret);
+       ov2640_reset(client);
+       priv->win = NULL;
+
+       return ret;
+}
+
+static int ov2640_g_fmt(struct v4l2_subdev *sd,
+                       struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client  *client = v4l2_get_subdevdata(sd);
+       struct ov2640_priv *priv = to_ov2640(client);
+
+       if (!priv->win) {
+               u32 width = W_SVGA, height = H_SVGA;
+               priv->win = ov2640_select_win(&width, &height);
+               priv->cfmt_code = V4L2_MBUS_FMT_UYVY8_2X8;
+       }
+
+       mf->width       = priv->win->width;
+       mf->height      = priv->win->height;
+       mf->code        = priv->cfmt_code;
+
+       switch (mf->code) {
+       case V4L2_MBUS_FMT_RGB565_2X8_LE:
+               mf->colorspace = V4L2_COLORSPACE_SRGB;
+               break;
+       default:
+       case V4L2_MBUS_FMT_UYVY8_2X8:
+               mf->colorspace = V4L2_COLORSPACE_JPEG;
+       }
+       mf->field       = V4L2_FIELD_NONE;
+
+       return 0;
+}
+
+static int ov2640_s_fmt(struct v4l2_subdev *sd,
+                       struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       int ret;
+
+
+       switch (mf->code) {
+       case V4L2_MBUS_FMT_RGB565_2X8_LE:
+               mf->colorspace = V4L2_COLORSPACE_SRGB;
+               break;
+       default:
+               mf->code = V4L2_MBUS_FMT_UYVY8_2X8;
+       case V4L2_MBUS_FMT_UYVY8_2X8:
+               mf->colorspace = V4L2_COLORSPACE_JPEG;
+       }
+
+       ret = ov2640_set_params(client, &mf->width, &mf->height, mf->code);
+
+       return ret;
+}
+
+static int ov2640_try_fmt(struct v4l2_subdev *sd,
+                         struct v4l2_mbus_framefmt *mf)
+{
+       const struct ov2640_win_size *win;
+
+       /*
+        * select suitable win
+        */
+       win = ov2640_select_win(&mf->width, &mf->height);
+
+       mf->field       = V4L2_FIELD_NONE;
+
+       switch (mf->code) {
+       case V4L2_MBUS_FMT_RGB565_2X8_LE:
+               mf->colorspace = V4L2_COLORSPACE_SRGB;
+               break;
+       default:
+               mf->code = V4L2_MBUS_FMT_UYVY8_2X8;
+       case V4L2_MBUS_FMT_UYVY8_2X8:
+               mf->colorspace = V4L2_COLORSPACE_JPEG;
+       }
+
+       return 0;
+}
+
+static int ov2640_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
+                          enum v4l2_mbus_pixelcode *code)
+{
+       if (index >= ARRAY_SIZE(ov2640_codes))
+               return -EINVAL;
+
+       *code = ov2640_codes[index];
+       return 0;
+}
+
+static int ov2640_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+       a->c.left       = 0;
+       a->c.top        = 0;
+       a->c.width      = W_UXGA;
+       a->c.height     = H_UXGA;
+       a->type         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+       return 0;
+}
+
+static int ov2640_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
+{
+       a->bounds.left                  = 0;
+       a->bounds.top                   = 0;
+       a->bounds.width                 = W_UXGA;
+       a->bounds.height                = H_UXGA;
+       a->defrect                      = a->bounds;
+       a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+       a->pixelaspect.numerator        = 1;
+       a->pixelaspect.denominator      = 1;
+
+       return 0;
+}
+
+static int ov2640_video_probe(struct i2c_client *client)
+{
+       struct ov2640_priv *priv = to_ov2640(client);
+       u8 pid, ver, midh, midl;
+       const char *devname;
+       int ret;
+
+       /*
+        * check and show product ID and manufacturer ID
+        */
+       i2c_smbus_write_byte_data(client, BANK_SEL, BANK_SEL_SENS);
+       pid  = i2c_smbus_read_byte_data(client, PID);
+       ver  = i2c_smbus_read_byte_data(client, VER);
+       midh = i2c_smbus_read_byte_data(client, MIDH);
+       midl = i2c_smbus_read_byte_data(client, MIDL);
+
+       switch (VERSION(pid, ver)) {
+       case PID_OV2640:
+               devname     = "ov2640";
+               priv->model = V4L2_IDENT_OV2640;
+               break;
+       default:
+               dev_err(&client->dev,
+                       "Product ID error %x:%x\n", pid, ver);
+               ret = -ENODEV;
+               goto err;
+       }
+
+       dev_info(&client->dev,
+                "%s Product ID %0x:%0x Manufacturer ID %x:%x\n",
+                devname, pid, ver, midh, midl);
+
+       return v4l2_ctrl_handler_setup(&priv->hdl);
+
+err:
+       return ret;
+}
+
+static const struct v4l2_ctrl_ops ov2640_ctrl_ops = {
+       .s_ctrl = ov2640_s_ctrl,
+};
+
+static struct v4l2_subdev_core_ops ov2640_subdev_core_ops = {
+       .g_chip_ident   = ov2640_g_chip_ident,
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+       .g_register     = ov2640_g_register,
+       .s_register     = ov2640_s_register,
+#endif
+};
+
+static int ov2640_g_mbus_config(struct v4l2_subdev *sd,
+                               struct v4l2_mbus_config *cfg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+
+       cfg->flags = V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_MASTER |
+               V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_HSYNC_ACTIVE_HIGH |
+               V4L2_MBUS_DATA_ACTIVE_HIGH;
+       cfg->type = V4L2_MBUS_PARALLEL;
+       cfg->flags = soc_camera_apply_board_flags(icl, cfg);
+
+       return 0;
+}
+
+static struct v4l2_subdev_video_ops ov2640_subdev_video_ops = {
+       .s_stream       = ov2640_s_stream,
+       .g_mbus_fmt     = ov2640_g_fmt,
+       .s_mbus_fmt     = ov2640_s_fmt,
+       .try_mbus_fmt   = ov2640_try_fmt,
+       .cropcap        = ov2640_cropcap,
+       .g_crop         = ov2640_g_crop,
+       .enum_mbus_fmt  = ov2640_enum_fmt,
+       .g_mbus_config  = ov2640_g_mbus_config,
+};
+
+static struct v4l2_subdev_ops ov2640_subdev_ops = {
+       .core   = &ov2640_subdev_core_ops,
+       .video  = &ov2640_subdev_video_ops,
+};
+
+/*
+ * i2c_driver functions
+ */
+static int ov2640_probe(struct i2c_client *client,
+                       const struct i2c_device_id *did)
+{
+       struct ov2640_priv      *priv;
+       struct soc_camera_link  *icl = soc_camera_i2c_to_link(client);
+       struct i2c_adapter      *adapter = to_i2c_adapter(client->dev.parent);
+       int                     ret;
+
+       if (!icl) {
+               dev_err(&adapter->dev,
+                       "OV2640: Missing platform_data for driver\n");
+               return -EINVAL;
+       }
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
+               dev_err(&adapter->dev,
+                       "OV2640: I2C-Adapter doesn't support SMBUS\n");
+               return -EIO;
+       }
+
+       priv = kzalloc(sizeof(struct ov2640_priv), GFP_KERNEL);
+       if (!priv) {
+               dev_err(&adapter->dev,
+                       "Failed to allocate memory for private data!\n");
+               return -ENOMEM;
+       }
+
+       v4l2_i2c_subdev_init(&priv->subdev, client, &ov2640_subdev_ops);
+       v4l2_ctrl_handler_init(&priv->hdl, 2);
+       v4l2_ctrl_new_std(&priv->hdl, &ov2640_ctrl_ops,
+                       V4L2_CID_VFLIP, 0, 1, 1, 0);
+       v4l2_ctrl_new_std(&priv->hdl, &ov2640_ctrl_ops,
+                       V4L2_CID_HFLIP, 0, 1, 1, 0);
+       priv->subdev.ctrl_handler = &priv->hdl;
+       if (priv->hdl.error) {
+               int err = priv->hdl.error;
+
+               kfree(priv);
+               return err;
+       }
+
+       ret = ov2640_video_probe(client);
+       if (ret) {
+               v4l2_ctrl_handler_free(&priv->hdl);
+               kfree(priv);
+       } else {
+               dev_info(&adapter->dev, "OV2640 Probed\n");
+       }
+
+       return ret;
+}
+
+static int ov2640_remove(struct i2c_client *client)
+{
+       struct ov2640_priv       *priv = to_ov2640(client);
+
+       v4l2_device_unregister_subdev(&priv->subdev);
+       v4l2_ctrl_handler_free(&priv->hdl);
+       kfree(priv);
+       return 0;
+}
+
+static const struct i2c_device_id ov2640_id[] = {
+       { "ov2640", 0 },
+       { }
+};
+MODULE_DEVICE_TABLE(i2c, ov2640_id);
+
+static struct i2c_driver ov2640_i2c_driver = {
+       .driver = {
+               .name = "ov2640",
+       },
+       .probe    = ov2640_probe,
+       .remove   = ov2640_remove,
+       .id_table = ov2640_id,
+};
+
+module_i2c_driver(ov2640_i2c_driver);
+
+MODULE_DESCRIPTION("SoC Camera driver for Omni Vision 2640 sensor");
+MODULE_AUTHOR("Alberto Panizzo");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/i2c/soc_camera/ov5642.c b/drivers/media/i2c/soc_camera/ov5642.c
new file mode 100644 (file)
index 0000000..0bc9331
--- /dev/null
@@ -0,0 +1,1073 @@
+/*
+ * Driver for OV5642 CMOS Image Sensor from Omnivision
+ *
+ * Copyright (C) 2011, Bastian Hecht <hechtb@gmail.com>
+ *
+ * Based on Sony IMX074 Camera Driver
+ * Copyright (C) 2010, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
+ *
+ * Based on Omnivision OV7670 Camera Driver
+ * Copyright (C) 2006-7 Jonathan Corbet <corbet@lwn.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/bitops.h>
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/videodev2.h>
+#include <linux/module.h>
+#include <linux/v4l2-mediabus.h>
+
+#include <media/soc_camera.h>
+#include <media/v4l2-chip-ident.h>
+#include <media/v4l2-subdev.h>
+
+/* OV5642 registers */
+#define REG_CHIP_ID_HIGH               0x300a
+#define REG_CHIP_ID_LOW                        0x300b
+
+#define REG_WINDOW_START_X_HIGH                0x3800
+#define REG_WINDOW_START_X_LOW         0x3801
+#define REG_WINDOW_START_Y_HIGH                0x3802
+#define REG_WINDOW_START_Y_LOW         0x3803
+#define REG_WINDOW_WIDTH_HIGH          0x3804
+#define REG_WINDOW_WIDTH_LOW           0x3805
+#define REG_WINDOW_HEIGHT_HIGH         0x3806
+#define REG_WINDOW_HEIGHT_LOW          0x3807
+#define REG_OUT_WIDTH_HIGH             0x3808
+#define REG_OUT_WIDTH_LOW              0x3809
+#define REG_OUT_HEIGHT_HIGH            0x380a
+#define REG_OUT_HEIGHT_LOW             0x380b
+#define REG_OUT_TOTAL_WIDTH_HIGH       0x380c
+#define REG_OUT_TOTAL_WIDTH_LOW                0x380d
+#define REG_OUT_TOTAL_HEIGHT_HIGH      0x380e
+#define REG_OUT_TOTAL_HEIGHT_LOW       0x380f
+#define REG_OUTPUT_FORMAT              0x4300
+#define REG_ISP_CTRL_01                        0x5001
+#define REG_AVG_WINDOW_END_X_HIGH      0x5682
+#define REG_AVG_WINDOW_END_X_LOW       0x5683
+#define REG_AVG_WINDOW_END_Y_HIGH      0x5686
+#define REG_AVG_WINDOW_END_Y_LOW       0x5687
+
+/* active pixel array size */
+#define OV5642_SENSOR_SIZE_X   2592
+#define OV5642_SENSOR_SIZE_Y   1944
+
+/*
+ * About OV5642 resolution, cropping and binning:
+ * This sensor supports it all, at least in the feature description.
+ * Unfortunately, no combination of appropriate registers settings could make
+ * the chip work the intended way. As it works with predefined register lists,
+ * some undocumented registers are presumably changed there to achieve their
+ * goals.
+ * This driver currently only works for resolutions up to 720 lines with a
+ * 1:1 scale. Hopefully these restrictions will be removed in the future.
+ */
+#define OV5642_MAX_WIDTH       OV5642_SENSOR_SIZE_X
+#define OV5642_MAX_HEIGHT      720
+
+/* default sizes */
+#define OV5642_DEFAULT_WIDTH   1280
+#define OV5642_DEFAULT_HEIGHT  OV5642_MAX_HEIGHT
+
+/* minimum extra blanking */
+#define BLANKING_EXTRA_WIDTH           500
+#define BLANKING_EXTRA_HEIGHT          20
+
+/*
+ * the sensor's autoexposure is buggy when setting total_height low.
+ * It tries to expose longer than 1 frame period without taking care of it
+ * and this leads to weird output. So we set 1000 lines as minimum.
+ */
+#define BLANKING_MIN_HEIGHT            1000
+
+struct regval_list {
+       u16 reg_num;
+       u8 value;
+};
+
+static struct regval_list ov5642_default_regs_init[] = {
+       { 0x3103, 0x93 },
+       { 0x3008, 0x82 },
+       { 0x3017, 0x7f },
+       { 0x3018, 0xfc },
+       { 0x3810, 0xc2 },
+       { 0x3615, 0xf0 },
+       { 0x3000, 0x0  },
+       { 0x3001, 0x0  },
+       { 0x3002, 0x0  },
+       { 0x3003, 0x0  },
+       { 0x3004, 0xff },
+       { 0x3030, 0x2b },
+       { 0x3011, 0x8  },
+       { 0x3010, 0x10 },
+       { 0x3604, 0x60 },
+       { 0x3622, 0x60 },
+       { 0x3621, 0x9  },
+       { 0x3709, 0x0  },
+       { 0x4000, 0x21 },
+       { 0x401d, 0x22 },
+       { 0x3600, 0x54 },
+       { 0x3605, 0x4  },
+       { 0x3606, 0x3f },
+       { 0x3c01, 0x80 },
+       { 0x300d, 0x22 },
+       { 0x3623, 0x22 },
+       { 0x5000, 0x4f },
+       { 0x5020, 0x4  },
+       { 0x5181, 0x79 },
+       { 0x5182, 0x0  },
+       { 0x5185, 0x22 },
+       { 0x5197, 0x1  },
+       { 0x5500, 0xa  },
+       { 0x5504, 0x0  },
+       { 0x5505, 0x7f },
+       { 0x5080, 0x8  },
+       { 0x300e, 0x18 },
+       { 0x4610, 0x0  },
+       { 0x471d, 0x5  },
+       { 0x4708, 0x6  },
+       { 0x370c, 0xa0 },
+       { 0x5687, 0x94 },
+       { 0x501f, 0x0  },
+       { 0x5000, 0x4f },
+       { 0x5001, 0xcf },
+       { 0x4300, 0x30 },
+       { 0x4300, 0x30 },
+       { 0x460b, 0x35 },
+       { 0x471d, 0x0  },
+       { 0x3002, 0xc  },
+       { 0x3002, 0x0  },
+       { 0x4713, 0x3  },
+       { 0x471c, 0x50 },
+       { 0x4721, 0x2  },
+       { 0x4402, 0x90 },
+       { 0x460c, 0x22 },
+       { 0x3815, 0x44 },
+       { 0x3503, 0x7  },
+       { 0x3501, 0x73 },
+       { 0x3502, 0x80 },
+       { 0x350b, 0x0  },
+       { 0x3818, 0xc8 },
+       { 0x3824, 0x11 },
+       { 0x3a00, 0x78 },
+       { 0x3a1a, 0x4  },
+       { 0x3a13, 0x30 },
+       { 0x3a18, 0x0  },
+       { 0x3a19, 0x7c },
+       { 0x3a08, 0x12 },
+       { 0x3a09, 0xc0 },
+       { 0x3a0a, 0xf  },
+       { 0x3a0b, 0xa0 },
+       { 0x350c, 0x7  },
+       { 0x350d, 0xd0 },
+       { 0x3a0d, 0x8  },
+       { 0x3a0e, 0x6  },
+       { 0x3500, 0x0  },
+       { 0x3501, 0x0  },
+       { 0x3502, 0x0  },
+       { 0x350a, 0x0  },
+       { 0x350b, 0x0  },
+       { 0x3503, 0x0  },
+       { 0x3a0f, 0x3c },
+       { 0x3a10, 0x32 },
+       { 0x3a1b, 0x3c },
+       { 0x3a1e, 0x32 },
+       { 0x3a11, 0x80 },
+       { 0x3a1f, 0x20 },
+       { 0x3030, 0x2b },
+       { 0x3a02, 0x0  },
+       { 0x3a03, 0x7d },
+       { 0x3a04, 0x0  },
+       { 0x3a14, 0x0  },
+       { 0x3a15, 0x7d },
+       { 0x3a16, 0x0  },
+       { 0x3a00, 0x78 },
+       { 0x3a08, 0x9  },
+       { 0x3a09, 0x60 },
+       { 0x3a0a, 0x7  },
+       { 0x3a0b, 0xd0 },
+       { 0x3a0d, 0x10 },
+       { 0x3a0e, 0xd  },
+       { 0x4407, 0x4  },
+       { 0x5193, 0x70 },
+       { 0x589b, 0x0  },
+       { 0x589a, 0xc0 },
+       { 0x401e, 0x20 },
+       { 0x4001, 0x42 },
+       { 0x401c, 0x6  },
+       { 0x3825, 0xac },
+       { 0x3827, 0xc  },
+       { 0x528a, 0x1  },
+       { 0x528b, 0x4  },
+       { 0x528c, 0x8  },
+       { 0x528d, 0x10 },
+       { 0x528e, 0x20 },
+       { 0x528f, 0x28 },
+       { 0x5290, 0x30 },
+       { 0x5292, 0x0  },
+       { 0x5293, 0x1  },
+       { 0x5294, 0x0  },
+       { 0x5295, 0x4  },
+       { 0x5296, 0x0  },
+       { 0x5297, 0x8  },
+       { 0x5298, 0x0  },
+       { 0x5299, 0x10 },
+       { 0x529a, 0x0  },
+       { 0x529b, 0x20 },
+       { 0x529c, 0x0  },
+       { 0x529d, 0x28 },
+       { 0x529e, 0x0  },
+       { 0x529f, 0x30 },
+       { 0x5282, 0x0  },
+       { 0x5300, 0x0  },
+       { 0x5301, 0x20 },
+       { 0x5302, 0x0  },
+       { 0x5303, 0x7c },
+       { 0x530c, 0x0  },
+       { 0x530d, 0xc  },
+       { 0x530e, 0x20 },
+       { 0x530f, 0x80 },
+       { 0x5310, 0x20 },
+       { 0x5311, 0x80 },
+       { 0x5308, 0x20 },
+       { 0x5309, 0x40 },
+       { 0x5304, 0x0  },
+       { 0x5305, 0x30 },
+       { 0x5306, 0x0  },
+       { 0x5307, 0x80 },
+       { 0x5314, 0x8  },
+       { 0x5315, 0x20 },
+       { 0x5319, 0x30 },
+       { 0x5316, 0x10 },
+       { 0x5317, 0x0  },
+       { 0x5318, 0x2  },
+       { 0x5380, 0x1  },
+       { 0x5381, 0x0  },
+       { 0x5382, 0x0  },
+       { 0x5383, 0x4e },
+       { 0x5384, 0x0  },
+       { 0x5385, 0xf  },
+       { 0x5386, 0x0  },
+       { 0x5387, 0x0  },
+       { 0x5388, 0x1  },
+       { 0x5389, 0x15 },
+       { 0x538a, 0x0  },
+       { 0x538b, 0x31 },
+       { 0x538c, 0x0  },
+       { 0x538d, 0x0  },
+       { 0x538e, 0x0  },
+       { 0x538f, 0xf  },
+       { 0x5390, 0x0  },
+       { 0x5391, 0xab },
+       { 0x5392, 0x0  },
+       { 0x5393, 0xa2 },
+       { 0x5394, 0x8  },
+       { 0x5480, 0x14 },
+       { 0x5481, 0x21 },
+       { 0x5482, 0x36 },
+       { 0x5483, 0x57 },
+       { 0x5484, 0x65 },
+       { 0x5485, 0x71 },
+       { 0x5486, 0x7d },
+       { 0x5487, 0x87 },
+       { 0x5488, 0x91 },
+       { 0x5489, 0x9a },
+       { 0x548a, 0xaa },
+       { 0x548b, 0xb8 },
+       { 0x548c, 0xcd },
+       { 0x548d, 0xdd },
+       { 0x548e, 0xea },
+       { 0x548f, 0x1d },
+       { 0x5490, 0x5  },
+       { 0x5491, 0x0  },
+       { 0x5492, 0x4  },
+       { 0x5493, 0x20 },
+       { 0x5494, 0x3  },
+       { 0x5495, 0x60 },
+       { 0x5496, 0x2  },
+       { 0x5497, 0xb8 },
+       { 0x5498, 0x2  },
+       { 0x5499, 0x86 },
+       { 0x549a, 0x2  },
+       { 0x549b, 0x5b },
+       { 0x549c, 0x2  },
+       { 0x549d, 0x3b },
+       { 0x549e, 0x2  },
+       { 0x549f, 0x1c },
+       { 0x54a0, 0x2  },
+       { 0x54a1, 0x4  },
+       { 0x54a2, 0x1  },
+       { 0x54a3, 0xed },
+       { 0x54a4, 0x1  },
+       { 0x54a5, 0xc5 },
+       { 0x54a6, 0x1  },
+       { 0x54a7, 0xa5 },
+       { 0x54a8, 0x1  },
+       { 0x54a9, 0x6c },
+       { 0x54aa, 0x1  },
+       { 0x54ab, 0x41 },
+       { 0x54ac, 0x1  },
+       { 0x54ad, 0x20 },
+       { 0x54ae, 0x0  },
+       { 0x54af, 0x16 },
+       { 0x54b0, 0x1  },
+       { 0x54b1, 0x20 },
+       { 0x54b2, 0x0  },
+       { 0x54b3, 0x10 },
+       { 0x54b4, 0x0  },
+       { 0x54b5, 0xf0 },
+       { 0x54b6, 0x0  },
+       { 0x54b7, 0xdf },
+       { 0x5402, 0x3f },
+       { 0x5403, 0x0  },
+       { 0x3406, 0x0  },
+       { 0x5180, 0xff },
+       { 0x5181, 0x52 },
+       { 0x5182, 0x11 },
+       { 0x5183, 0x14 },
+       { 0x5184, 0x25 },
+       { 0x5185, 0x24 },
+       { 0x5186, 0x6  },
+       { 0x5187, 0x8  },
+       { 0x5188, 0x8  },
+       { 0x5189, 0x7c },
+       { 0x518a, 0x60 },
+       { 0x518b, 0xb2 },
+       { 0x518c, 0xb2 },
+       { 0x518d, 0x44 },
+       { 0x518e, 0x3d },
+       { 0x518f, 0x58 },
+       { 0x5190, 0x46 },
+       { 0x5191, 0xf8 },
+       { 0x5192, 0x4  },
+       { 0x5193, 0x70 },
+       { 0x5194, 0xf0 },
+       { 0x5195, 0xf0 },
+       { 0x5196, 0x3  },
+       { 0x5197, 0x1  },
+       { 0x5198, 0x4  },
+       { 0x5199, 0x12 },
+       { 0x519a, 0x4  },
+       { 0x519b, 0x0  },
+       { 0x519c, 0x6  },
+       { 0x519d, 0x82 },
+       { 0x519e, 0x0  },
+       { 0x5025, 0x80 },
+       { 0x3a0f, 0x38 },
+       { 0x3a10, 0x30 },
+       { 0x3a1b, 0x3a },
+       { 0x3a1e, 0x2e },
+       { 0x3a11, 0x60 },
+       { 0x3a1f, 0x10 },
+       { 0x5688, 0xa6 },
+       { 0x5689, 0x6a },
+       { 0x568a, 0xea },
+       { 0x568b, 0xae },
+       { 0x568c, 0xa6 },
+       { 0x568d, 0x6a },
+       { 0x568e, 0x62 },
+       { 0x568f, 0x26 },
+       { 0x5583, 0x40 },
+       { 0x5584, 0x40 },
+       { 0x5580, 0x2  },
+       { 0x5000, 0xcf },
+       { 0x5800, 0x27 },
+       { 0x5801, 0x19 },
+       { 0x5802, 0x12 },
+       { 0x5803, 0xf  },
+       { 0x5804, 0x10 },
+       { 0x5805, 0x15 },
+       { 0x5806, 0x1e },
+       { 0x5807, 0x2f },
+       { 0x5808, 0x15 },
+       { 0x5809, 0xd  },
+       { 0x580a, 0xa  },
+       { 0x580b, 0x9  },
+       { 0x580c, 0xa  },
+       { 0x580d, 0xc  },
+       { 0x580e, 0x12 },
+       { 0x580f, 0x19 },
+       { 0x5810, 0xb  },
+       { 0x5811, 0x7  },
+       { 0x5812, 0x4  },
+       { 0x5813, 0x3  },
+       { 0x5814, 0x3  },
+       { 0x5815, 0x6  },
+       { 0x5816, 0xa  },
+       { 0x5817, 0xf  },
+       { 0x5818, 0xa  },
+       { 0x5819, 0x5  },
+       { 0x581a, 0x1  },
+       { 0x581b, 0x0  },
+       { 0x581c, 0x0  },
+       { 0x581d, 0x3  },
+       { 0x581e, 0x8  },
+       { 0x581f, 0xc  },
+       { 0x5820, 0xa  },
+       { 0x5821, 0x5  },
+       { 0x5822, 0x1  },
+       { 0x5823, 0x0  },
+       { 0x5824, 0x0  },
+       { 0x5825, 0x3  },
+       { 0x5826, 0x8  },
+       { 0x5827, 0xc  },
+       { 0x5828, 0xe  },
+       { 0x5829, 0x8  },
+       { 0x582a, 0x6  },
+       { 0x582b, 0x4  },
+       { 0x582c, 0x5  },
+       { 0x582d, 0x7  },
+       { 0x582e, 0xb  },
+       { 0x582f, 0x12 },
+       { 0x5830, 0x18 },
+       { 0x5831, 0x10 },
+       { 0x5832, 0xc  },
+       { 0x5833, 0xa  },
+       { 0x5834, 0xb  },
+       { 0x5835, 0xe  },
+       { 0x5836, 0x15 },
+       { 0x5837, 0x19 },
+       { 0x5838, 0x32 },
+       { 0x5839, 0x1f },
+       { 0x583a, 0x18 },
+       { 0x583b, 0x16 },
+       { 0x583c, 0x17 },
+       { 0x583d, 0x1e },
+       { 0x583e, 0x26 },
+       { 0x583f, 0x53 },
+       { 0x5840, 0x10 },
+       { 0x5841, 0xf  },
+       { 0x5842, 0xd  },
+       { 0x5843, 0xc  },
+       { 0x5844, 0xe  },
+       { 0x5845, 0x9  },
+       { 0x5846, 0x11 },
+       { 0x5847, 0x10 },
+       { 0x5848, 0x10 },
+       { 0x5849, 0x10 },
+       { 0x584a, 0x10 },
+       { 0x584b, 0xe  },
+       { 0x584c, 0x10 },
+       { 0x584d, 0x10 },
+       { 0x584e, 0x11 },
+       { 0x584f, 0x10 },
+       { 0x5850, 0xf  },
+       { 0x5851, 0xc  },
+       { 0x5852, 0xf  },
+       { 0x5853, 0x10 },
+       { 0x5854, 0x10 },
+       { 0x5855, 0xf  },
+       { 0x5856, 0xe  },
+       { 0x5857, 0xb  },
+       { 0x5858, 0x10 },
+       { 0x5859, 0xd  },
+       { 0x585a, 0xd  },
+       { 0x585b, 0xc  },
+       { 0x585c, 0xc  },
+       { 0x585d, 0xc  },
+       { 0x585e, 0xb  },
+       { 0x585f, 0xc  },
+       { 0x5860, 0xc  },
+       { 0x5861, 0xc  },
+       { 0x5862, 0xd  },
+       { 0x5863, 0x8  },
+       { 0x5864, 0x11 },
+       { 0x5865, 0x18 },
+       { 0x5866, 0x18 },
+       { 0x5867, 0x19 },
+       { 0x5868, 0x17 },
+       { 0x5869, 0x19 },
+       { 0x586a, 0x16 },
+       { 0x586b, 0x13 },
+       { 0x586c, 0x13 },
+       { 0x586d, 0x12 },
+       { 0x586e, 0x13 },
+       { 0x586f, 0x16 },
+       { 0x5870, 0x14 },
+       { 0x5871, 0x12 },
+       { 0x5872, 0x10 },
+       { 0x5873, 0x11 },
+       { 0x5874, 0x11 },
+       { 0x5875, 0x16 },
+       { 0x5876, 0x14 },
+       { 0x5877, 0x11 },
+       { 0x5878, 0x10 },
+       { 0x5879, 0xf  },
+       { 0x587a, 0x10 },
+       { 0x587b, 0x14 },
+       { 0x587c, 0x13 },
+       { 0x587d, 0x12 },
+       { 0x587e, 0x11 },
+       { 0x587f, 0x11 },
+       { 0x5880, 0x12 },
+       { 0x5881, 0x15 },
+       { 0x5882, 0x14 },
+       { 0x5883, 0x15 },
+       { 0x5884, 0x15 },
+       { 0x5885, 0x15 },
+       { 0x5886, 0x13 },
+       { 0x5887, 0x17 },
+       { 0x3710, 0x10 },
+       { 0x3632, 0x51 },
+       { 0x3702, 0x10 },
+       { 0x3703, 0xb2 },
+       { 0x3704, 0x18 },
+       { 0x370b, 0x40 },
+       { 0x370d, 0x3  },
+       { 0x3631, 0x1  },
+       { 0x3632, 0x52 },
+       { 0x3606, 0x24 },
+       { 0x3620, 0x96 },
+       { 0x5785, 0x7  },
+       { 0x3a13, 0x30 },
+       { 0x3600, 0x52 },
+       { 0x3604, 0x48 },
+       { 0x3606, 0x1b },
+       { 0x370d, 0xb  },
+       { 0x370f, 0xc0 },
+       { 0x3709, 0x1  },
+       { 0x3823, 0x0  },
+       { 0x5007, 0x0  },
+       { 0x5009, 0x0  },
+       { 0x5011, 0x0  },
+       { 0x5013, 0x0  },
+       { 0x519e, 0x0  },
+       { 0x5086, 0x0  },
+       { 0x5087, 0x0  },
+       { 0x5088, 0x0  },
+       { 0x5089, 0x0  },
+       { 0x302b, 0x0  },
+       { 0x3503, 0x7  },
+       { 0x3011, 0x8  },
+       { 0x350c, 0x2  },
+       { 0x350d, 0xe4 },
+       { 0x3621, 0xc9 },
+       { 0x370a, 0x81 },
+       { 0xffff, 0xff },
+};
+
+static struct regval_list ov5642_default_regs_finalise[] = {
+       { 0x3810, 0xc2 },
+       { 0x3818, 0xc9 },
+       { 0x381c, 0x10 },
+       { 0x381d, 0xa0 },
+       { 0x381e, 0x5  },
+       { 0x381f, 0xb0 },
+       { 0x3820, 0x0  },
+       { 0x3821, 0x0  },
+       { 0x3824, 0x11 },
+       { 0x3a08, 0x1b },
+       { 0x3a09, 0xc0 },
+       { 0x3a0a, 0x17 },
+       { 0x3a0b, 0x20 },
+       { 0x3a0d, 0x2  },
+       { 0x3a0e, 0x1  },
+       { 0x401c, 0x4  },
+       { 0x5682, 0x5  },
+       { 0x5683, 0x0  },
+       { 0x5686, 0x2  },
+       { 0x5687, 0xcc },
+       { 0x5001, 0x4f },
+       { 0x589b, 0x6  },
+       { 0x589a, 0xc5 },
+       { 0x3503, 0x0  },
+       { 0x460c, 0x20 },
+       { 0x460b, 0x37 },
+       { 0x471c, 0xd0 },
+       { 0x471d, 0x5  },
+       { 0x3815, 0x1  },
+       { 0x3818, 0xc1 },
+       { 0x501f, 0x0  },
+       { 0x5002, 0xe0 },
+       { 0x4300, 0x32 }, /* UYVY */
+       { 0x3002, 0x1c },
+       { 0x4800, 0x14 },
+       { 0x4801, 0xf  },
+       { 0x3007, 0x3b },
+       { 0x300e, 0x4  },
+       { 0x4803, 0x50 },
+       { 0x3815, 0x1  },
+       { 0x4713, 0x2  },
+       { 0x4842, 0x1  },
+       { 0x300f, 0xe  },
+       { 0x3003, 0x3  },
+       { 0x3003, 0x1  },
+       { 0xffff, 0xff },
+};
+
+struct ov5642_datafmt {
+       enum v4l2_mbus_pixelcode        code;
+       enum v4l2_colorspace            colorspace;
+};
+
+struct ov5642 {
+       struct v4l2_subdev              subdev;
+       const struct ov5642_datafmt     *fmt;
+       struct v4l2_rect                crop_rect;
+
+       /* blanking information */
+       int total_width;
+       int total_height;
+};
+
+static const struct ov5642_datafmt ov5642_colour_fmts[] = {
+       {V4L2_MBUS_FMT_UYVY8_2X8, V4L2_COLORSPACE_JPEG},
+};
+
+static struct ov5642 *to_ov5642(const struct i2c_client *client)
+{
+       return container_of(i2c_get_clientdata(client), struct ov5642, subdev);
+}
+
+/* Find a data format by a pixel code in an array */
+static const struct ov5642_datafmt
+                       *ov5642_find_datafmt(enum v4l2_mbus_pixelcode code)
+{
+       int i;
+
+       for (i = 0; i < ARRAY_SIZE(ov5642_colour_fmts); i++)
+               if (ov5642_colour_fmts[i].code == code)
+                       return ov5642_colour_fmts + i;
+
+       return NULL;
+}
+
+static int reg_read(struct i2c_client *client, u16 reg, u8 *val)
+{
+       int ret;
+       /* We have 16-bit i2c addresses - care for endianess */
+       unsigned char data[2] = { reg >> 8, reg & 0xff };
+
+       ret = i2c_master_send(client, data, 2);
+       if (ret < 2) {
+               dev_err(&client->dev, "%s: i2c read error, reg: %x\n",
+                       __func__, reg);
+               return ret < 0 ? ret : -EIO;
+       }
+
+       ret = i2c_master_recv(client, val, 1);
+       if (ret < 1) {
+               dev_err(&client->dev, "%s: i2c read error, reg: %x\n",
+                               __func__, reg);
+               return ret < 0 ? ret : -EIO;
+       }
+       return 0;
+}
+
+static int reg_write(struct i2c_client *client, u16 reg, u8 val)
+{
+       int ret;
+       unsigned char data[3] = { reg >> 8, reg & 0xff, val };
+
+       ret = i2c_master_send(client, data, 3);
+       if (ret < 3) {
+               dev_err(&client->dev, "%s: i2c write error, reg: %x\n",
+                       __func__, reg);
+               return ret < 0 ? ret : -EIO;
+       }
+
+       return 0;
+}
+
+/*
+ * convenience function to write 16 bit register values that are split up
+ * into two consecutive high and low parts
+ */
+static int reg_write16(struct i2c_client *client, u16 reg, u16 val16)
+{
+       int ret;
+
+       ret = reg_write(client, reg, val16 >> 8);
+       if (ret)
+               return ret;
+       return reg_write(client, reg + 1, val16 & 0x00ff);
+}
+
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+static int ov5642_get_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       int ret;
+       u8 val;
+
+       if (reg->reg & ~0xffff)
+               return -EINVAL;
+
+       reg->size = 1;
+
+       ret = reg_read(client, reg->reg, &val);
+       if (!ret)
+               reg->val = (__u64)val;
+
+       return ret;
+}
+
+static int ov5642_set_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+       if (reg->reg & ~0xffff || reg->val & ~0xff)
+               return -EINVAL;
+
+       return reg_write(client, reg->reg, reg->val);
+}
+#endif
+
+static int ov5642_write_array(struct i2c_client *client,
+                               struct regval_list *vals)
+{
+       while (vals->reg_num != 0xffff || vals->value != 0xff) {
+               int ret = reg_write(client, vals->reg_num, vals->value);
+               if (ret < 0)
+                       return ret;
+               vals++;
+       }
+       dev_dbg(&client->dev, "Register list loaded\n");
+       return 0;
+}
+
+static int ov5642_set_resolution(struct v4l2_subdev *sd)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct ov5642 *priv = to_ov5642(client);
+       int width = priv->crop_rect.width;
+       int height = priv->crop_rect.height;
+       int total_width = priv->total_width;
+       int total_height = priv->total_height;
+       int start_x = (OV5642_SENSOR_SIZE_X - width) / 2;
+       int start_y = (OV5642_SENSOR_SIZE_Y - height) / 2;
+       int ret;
+
+       /*
+        * This should set the starting point for cropping.
+        * Doesn't work so far.
+        */
+       ret = reg_write16(client, REG_WINDOW_START_X_HIGH, start_x);
+       if (!ret)
+               ret = reg_write16(client, REG_WINDOW_START_Y_HIGH, start_y);
+       if (!ret) {
+               priv->crop_rect.left = start_x;
+               priv->crop_rect.top = start_y;
+       }
+
+       if (!ret)
+               ret = reg_write16(client, REG_WINDOW_WIDTH_HIGH, width);
+       if (!ret)
+               ret = reg_write16(client, REG_WINDOW_HEIGHT_HIGH, height);
+       if (ret)
+               return ret;
+       priv->crop_rect.width = width;
+       priv->crop_rect.height = height;
+
+       /* Set the output window size. Only 1:1 scale is supported so far. */
+       ret = reg_write16(client, REG_OUT_WIDTH_HIGH, width);
+       if (!ret)
+               ret = reg_write16(client, REG_OUT_HEIGHT_HIGH, height);
+
+       /* Total width = output size + blanking */
+       if (!ret)
+               ret = reg_write16(client, REG_OUT_TOTAL_WIDTH_HIGH, total_width);
+       if (!ret)
+               ret = reg_write16(client, REG_OUT_TOTAL_HEIGHT_HIGH, total_height);
+
+       /* Sets the window for AWB calculations */
+       if (!ret)
+               ret = reg_write16(client, REG_AVG_WINDOW_END_X_HIGH, width);
+       if (!ret)
+               ret = reg_write16(client, REG_AVG_WINDOW_END_Y_HIGH, height);
+
+       return ret;
+}
+
+static int ov5642_try_fmt(struct v4l2_subdev *sd,
+                         struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct ov5642 *priv = to_ov5642(client);
+       const struct ov5642_datafmt *fmt = ov5642_find_datafmt(mf->code);
+
+       mf->width = priv->crop_rect.width;
+       mf->height = priv->crop_rect.height;
+
+       if (!fmt) {
+               mf->code        = ov5642_colour_fmts[0].code;
+               mf->colorspace  = ov5642_colour_fmts[0].colorspace;
+       }
+
+       mf->field       = V4L2_FIELD_NONE;
+
+       return 0;
+}
+
+static int ov5642_s_fmt(struct v4l2_subdev *sd,
+                       struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct ov5642 *priv = to_ov5642(client);
+
+       /* MIPI CSI could have changed the format, double-check */
+       if (!ov5642_find_datafmt(mf->code))
+               return -EINVAL;
+
+       ov5642_try_fmt(sd, mf);
+       priv->fmt = ov5642_find_datafmt(mf->code);
+
+       return 0;
+}
+
+static int ov5642_g_fmt(struct v4l2_subdev *sd,
+                       struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct ov5642 *priv = to_ov5642(client);
+
+       const struct ov5642_datafmt *fmt = priv->fmt;
+
+       mf->code        = fmt->code;
+       mf->colorspace  = fmt->colorspace;
+       mf->width       = priv->crop_rect.width;
+       mf->height      = priv->crop_rect.height;
+       mf->field       = V4L2_FIELD_NONE;
+
+       return 0;
+}
+
+static int ov5642_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
+                          enum v4l2_mbus_pixelcode *code)
+{
+       if (index >= ARRAY_SIZE(ov5642_colour_fmts))
+               return -EINVAL;
+
+       *code = ov5642_colour_fmts[index].code;
+       return 0;
+}
+
+static int ov5642_g_chip_ident(struct v4l2_subdev *sd,
+                              struct v4l2_dbg_chip_ident *id)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+       if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
+               return -EINVAL;
+
+       if (id->match.addr != client->addr)
+               return -ENODEV;
+
+       id->ident       = V4L2_IDENT_OV5642;
+       id->revision    = 0;
+
+       return 0;
+}
+
+static int ov5642_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct ov5642 *priv = to_ov5642(client);
+       struct v4l2_rect *rect = &a->c;
+       int ret;
+
+       v4l_bound_align_image(&rect->width, 48, OV5642_MAX_WIDTH, 1,
+                             &rect->height, 32, OV5642_MAX_HEIGHT, 1, 0);
+
+       priv->crop_rect.width   = rect->width;
+       priv->crop_rect.height  = rect->height;
+       priv->total_width       = rect->width + BLANKING_EXTRA_WIDTH;
+       priv->total_height      = max_t(int, rect->height +
+                                                       BLANKING_EXTRA_HEIGHT,
+                                                       BLANKING_MIN_HEIGHT);
+       priv->crop_rect.width           = rect->width;
+       priv->crop_rect.height          = rect->height;
+
+       ret = ov5642_write_array(client, ov5642_default_regs_init);
+       if (!ret)
+               ret = ov5642_set_resolution(sd);
+       if (!ret)
+               ret = ov5642_write_array(client, ov5642_default_regs_finalise);
+
+       return ret;
+}
+
+static int ov5642_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct ov5642 *priv = to_ov5642(client);
+       struct v4l2_rect *rect = &a->c;
+
+       if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+               return -EINVAL;
+
+       *rect = priv->crop_rect;
+
+       return 0;
+}
+
+static int ov5642_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
+{
+       a->bounds.left                  = 0;
+       a->bounds.top                   = 0;
+       a->bounds.width                 = OV5642_MAX_WIDTH;
+       a->bounds.height                = OV5642_MAX_HEIGHT;
+       a->defrect                      = a->bounds;
+       a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+       a->pixelaspect.numerator        = 1;
+       a->pixelaspect.denominator      = 1;
+
+       return 0;
+}
+
+static int ov5642_g_mbus_config(struct v4l2_subdev *sd,
+                               struct v4l2_mbus_config *cfg)
+{
+       cfg->type = V4L2_MBUS_CSI2;
+       cfg->flags = V4L2_MBUS_CSI2_2_LANE | V4L2_MBUS_CSI2_CHANNEL_0 |
+                                       V4L2_MBUS_CSI2_CONTINUOUS_CLOCK;
+
+       return 0;
+}
+
+static int ov5642_s_power(struct v4l2_subdev *sd, int on)
+{
+       struct i2c_client *client;
+       int ret;
+
+       if (!on)
+               return 0;
+
+       client = v4l2_get_subdevdata(sd);
+       ret = ov5642_write_array(client, ov5642_default_regs_init);
+       if (!ret)
+               ret = ov5642_set_resolution(sd);
+       if (!ret)
+               ret = ov5642_write_array(client, ov5642_default_regs_finalise);
+
+       return ret;
+}
+
+static struct v4l2_subdev_video_ops ov5642_subdev_video_ops = {
+       .s_mbus_fmt     = ov5642_s_fmt,
+       .g_mbus_fmt     = ov5642_g_fmt,
+       .try_mbus_fmt   = ov5642_try_fmt,
+       .enum_mbus_fmt  = ov5642_enum_fmt,
+       .s_crop         = ov5642_s_crop,
+       .g_crop         = ov5642_g_crop,
+       .cropcap        = ov5642_cropcap,
+       .g_mbus_config  = ov5642_g_mbus_config,
+};
+
+static struct v4l2_subdev_core_ops ov5642_subdev_core_ops = {
+       .s_power        = ov5642_s_power,
+       .g_chip_ident   = ov5642_g_chip_ident,
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+       .g_register     = ov5642_get_register,
+       .s_register     = ov5642_set_register,
+#endif
+};
+
+static struct v4l2_subdev_ops ov5642_subdev_ops = {
+       .core   = &ov5642_subdev_core_ops,
+       .video  = &ov5642_subdev_video_ops,
+};
+
+static int ov5642_video_probe(struct i2c_client *client)
+{
+       int ret;
+       u8 id_high, id_low;
+       u16 id;
+
+       /* Read sensor Model ID */
+       ret = reg_read(client, REG_CHIP_ID_HIGH, &id_high);
+       if (ret < 0)
+               return ret;
+
+       id = id_high << 8;
+
+       ret = reg_read(client, REG_CHIP_ID_LOW, &id_low);
+       if (ret < 0)
+               return ret;
+
+       id |= id_low;
+
+       dev_info(&client->dev, "Chip ID 0x%04x detected\n", id);
+
+       if (id != 0x5642)
+               return -ENODEV;
+
+       return 0;
+}
+
+static int ov5642_probe(struct i2c_client *client,
+                       const struct i2c_device_id *did)
+{
+       struct ov5642 *priv;
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+       int ret;
+
+       if (!icl) {
+               dev_err(&client->dev, "OV5642: missing platform data!\n");
+               return -EINVAL;
+       }
+
+       priv = kzalloc(sizeof(struct ov5642), GFP_KERNEL);
+       if (!priv)
+               return -ENOMEM;
+
+       v4l2_i2c_subdev_init(&priv->subdev, client, &ov5642_subdev_ops);
+
+       priv->fmt               = &ov5642_colour_fmts[0];
+
+       priv->crop_rect.width   = OV5642_DEFAULT_WIDTH;
+       priv->crop_rect.height  = OV5642_DEFAULT_HEIGHT;
+       priv->crop_rect.left    = (OV5642_MAX_WIDTH - OV5642_DEFAULT_WIDTH) / 2;
+       priv->crop_rect.top     = (OV5642_MAX_HEIGHT - OV5642_DEFAULT_HEIGHT) / 2;
+       priv->total_width = OV5642_DEFAULT_WIDTH + BLANKING_EXTRA_WIDTH;
+       priv->total_height = BLANKING_MIN_HEIGHT;
+
+       ret = ov5642_video_probe(client);
+       if (ret < 0)
+               goto error;
+
+       return 0;
+
+error:
+       kfree(priv);
+       return ret;
+}
+
+static int ov5642_remove(struct i2c_client *client)
+{
+       struct ov5642 *priv = to_ov5642(client);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+
+       if (icl->free_bus)
+               icl->free_bus(icl);
+       kfree(priv);
+
+       return 0;
+}
+
+static const struct i2c_device_id ov5642_id[] = {
+       { "ov5642", 0 },
+       { }
+};
+MODULE_DEVICE_TABLE(i2c, ov5642_id);
+
+static struct i2c_driver ov5642_i2c_driver = {
+       .driver = {
+               .name = "ov5642",
+       },
+       .probe          = ov5642_probe,
+       .remove         = ov5642_remove,
+       .id_table       = ov5642_id,
+};
+
+module_i2c_driver(ov5642_i2c_driver);
+
+MODULE_DESCRIPTION("Omnivision OV5642 Camera driver");
+MODULE_AUTHOR("Bastian Hecht <hechtb@gmail.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/i2c/soc_camera/ov6650.c b/drivers/media/i2c/soc_camera/ov6650.c
new file mode 100644 (file)
index 0000000..3e028b1
--- /dev/null
@@ -0,0 +1,1053 @@
+/*
+ * V4L2 SoC Camera driver for OmniVision OV6650 Camera Sensor
+ *
+ * Copyright (C) 2010 Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>
+ *
+ * Based on OmniVision OV96xx Camera Driver
+ * Copyright (C) 2009 Marek Vasut <marek.vasut@gmail.com>
+ *
+ * Based on ov772x camera driver:
+ * Copyright (C) 2008 Renesas Solutions Corp.
+ * Kuninori Morimoto <morimoto.kuninori@renesas.com>
+ *
+ * Based on ov7670 and soc_camera_platform driver,
+ * Copyright 2006-7 Jonathan Corbet <corbet@lwn.net>
+ * Copyright (C) 2008 Magnus Damm
+ * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
+ *
+ * Hardware specific bits initialy based on former work by Matt Callow
+ * drivers/media/video/omap/sensor_ov6650.c
+ * Copyright (C) 2006 Matt Callow
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/bitops.h>
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/slab.h>
+#include <linux/v4l2-mediabus.h>
+#include <linux/module.h>
+
+#include <media/soc_camera.h>
+#include <media/v4l2-chip-ident.h>
+#include <media/v4l2-ctrls.h>
+
+/* Register definitions */
+#define REG_GAIN               0x00    /* range 00 - 3F */
+#define REG_BLUE               0x01
+#define REG_RED                        0x02
+#define REG_SAT                        0x03    /* [7:4] saturation [0:3] reserved */
+#define REG_HUE                        0x04    /* [7:6] rsrvd [5] hue en [4:0] hue */
+
+#define REG_BRT                        0x06
+
+#define REG_PIDH               0x0a
+#define REG_PIDL               0x0b
+
+#define REG_AECH               0x10
+#define REG_CLKRC              0x11    /* Data Format and Internal Clock */
+                                       /* [7:6] Input system clock (MHz)*/
+                                       /*   00=8, 01=12, 10=16, 11=24 */
+                                       /* [5:0]: Internal Clock Pre-Scaler */
+#define REG_COMA               0x12    /* [7] Reset */
+#define REG_COMB               0x13
+#define REG_COMC               0x14
+#define REG_COMD               0x15
+#define REG_COML               0x16
+#define REG_HSTRT              0x17
+#define REG_HSTOP              0x18
+#define REG_VSTRT              0x19
+#define REG_VSTOP              0x1a
+#define REG_PSHFT              0x1b
+#define REG_MIDH               0x1c
+#define REG_MIDL               0x1d
+#define REG_HSYNS              0x1e
+#define REG_HSYNE              0x1f
+#define REG_COME               0x20
+#define REG_YOFF               0x21
+#define REG_UOFF               0x22
+#define REG_VOFF               0x23
+#define REG_AEW                        0x24
+#define REG_AEB                        0x25
+#define REG_COMF               0x26
+#define REG_COMG               0x27
+#define REG_COMH               0x28
+#define REG_COMI               0x29
+
+#define REG_FRARL              0x2b
+#define REG_COMJ               0x2c
+#define REG_COMK               0x2d
+#define REG_AVGY               0x2e
+#define REG_REF0               0x2f
+#define REG_REF1               0x30
+#define REG_REF2               0x31
+#define REG_FRAJH              0x32
+#define REG_FRAJL              0x33
+#define REG_FACT               0x34
+#define REG_L1AEC              0x35
+#define REG_AVGU               0x36
+#define REG_AVGV               0x37
+
+#define REG_SPCB               0x60
+#define REG_SPCC               0x61
+#define REG_GAM1               0x62
+#define REG_GAM2               0x63
+#define REG_GAM3               0x64
+#define REG_SPCD               0x65
+
+#define REG_SPCE               0x68
+#define REG_ADCL               0x69
+
+#define REG_RMCO               0x6c
+#define REG_GMCO               0x6d
+#define REG_BMCO               0x6e
+
+
+/* Register bits, values, etc. */
+#define OV6650_PIDH            0x66    /* high byte of product ID number */
+#define OV6650_PIDL            0x50    /* low byte of product ID number */
+#define OV6650_MIDH            0x7F    /* high byte of mfg ID */
+#define OV6650_MIDL            0xA2    /* low byte of mfg ID */
+
+#define DEF_GAIN               0x00
+#define DEF_BLUE               0x80
+#define DEF_RED                        0x80
+
+#define SAT_SHIFT              4
+#define SAT_MASK               (0xf << SAT_SHIFT)
+#define SET_SAT(x)             (((x) << SAT_SHIFT) & SAT_MASK)
+
+#define HUE_EN                 BIT(5)
+#define HUE_MASK               0x1f
+#define DEF_HUE                        0x10
+#define SET_HUE(x)             (HUE_EN | ((x) & HUE_MASK))
+
+#define DEF_AECH               0x4D
+
+#define CLKRC_6MHz             0x00
+#define CLKRC_12MHz            0x40
+#define CLKRC_16MHz            0x80
+#define CLKRC_24MHz            0xc0
+#define CLKRC_DIV_MASK         0x3f
+#define GET_CLKRC_DIV(x)       (((x) & CLKRC_DIV_MASK) + 1)
+
+#define COMA_RESET             BIT(7)
+#define COMA_QCIF              BIT(5)
+#define COMA_RAW_RGB           BIT(4)
+#define COMA_RGB               BIT(3)
+#define COMA_BW                        BIT(2)
+#define COMA_WORD_SWAP         BIT(1)
+#define COMA_BYTE_SWAP         BIT(0)
+#define DEF_COMA               0x00
+
+#define COMB_FLIP_V            BIT(7)
+#define COMB_FLIP_H            BIT(5)
+#define COMB_BAND_FILTER       BIT(4)
+#define COMB_AWB               BIT(2)
+#define COMB_AGC               BIT(1)
+#define COMB_AEC               BIT(0)
+#define DEF_COMB               0x5f
+
+#define COML_ONE_CHANNEL       BIT(7)
+
+#define DEF_HSTRT              0x24
+#define DEF_HSTOP              0xd4
+#define DEF_VSTRT              0x04
+#define DEF_VSTOP              0x94
+
+#define COMF_HREF_LOW          BIT(4)
+
+#define COMJ_PCLK_RISING       BIT(4)
+#define COMJ_VSYNC_HIGH                BIT(0)
+
+/* supported resolutions */
+#define W_QCIF                 (DEF_HSTOP - DEF_HSTRT)
+#define W_CIF                  (W_QCIF << 1)
+#define H_QCIF                 (DEF_VSTOP - DEF_VSTRT)
+#define H_CIF                  (H_QCIF << 1)
+
+#define FRAME_RATE_MAX         30
+
+
+struct ov6650_reg {
+       u8      reg;
+       u8      val;
+};
+
+struct ov6650 {
+       struct v4l2_subdev      subdev;
+       struct v4l2_ctrl_handler hdl;
+       struct {
+               /* exposure/autoexposure cluster */
+               struct v4l2_ctrl *autoexposure;
+               struct v4l2_ctrl *exposure;
+       };
+       struct {
+               /* gain/autogain cluster */
+               struct v4l2_ctrl *autogain;
+               struct v4l2_ctrl *gain;
+       };
+       struct {
+               /* blue/red/autowhitebalance cluster */
+               struct v4l2_ctrl *autowb;
+               struct v4l2_ctrl *blue;
+               struct v4l2_ctrl *red;
+       };
+       bool                    half_scale;     /* scale down output by 2 */
+       struct v4l2_rect        rect;           /* sensor cropping window */
+       unsigned long           pclk_limit;     /* from host */
+       unsigned long           pclk_max;       /* from resolution and format */
+       struct v4l2_fract       tpf;            /* as requested with s_parm */
+       enum v4l2_mbus_pixelcode code;
+       enum v4l2_colorspace    colorspace;
+};
+
+
+static enum v4l2_mbus_pixelcode ov6650_codes[] = {
+       V4L2_MBUS_FMT_YUYV8_2X8,
+       V4L2_MBUS_FMT_UYVY8_2X8,
+       V4L2_MBUS_FMT_YVYU8_2X8,
+       V4L2_MBUS_FMT_VYUY8_2X8,
+       V4L2_MBUS_FMT_SBGGR8_1X8,
+       V4L2_MBUS_FMT_Y8_1X8,
+};
+
+/* read a register */
+static int ov6650_reg_read(struct i2c_client *client, u8 reg, u8 *val)
+{
+       int ret;
+       u8 data = reg;
+       struct i2c_msg msg = {
+               .addr   = client->addr,
+               .flags  = 0,
+               .len    = 1,
+               .buf    = &data,
+       };
+
+       ret = i2c_transfer(client->adapter, &msg, 1);
+       if (ret < 0)
+               goto err;
+
+       msg.flags = I2C_M_RD;
+       ret = i2c_transfer(client->adapter, &msg, 1);
+       if (ret < 0)
+               goto err;
+
+       *val = data;
+       return 0;
+
+err:
+       dev_err(&client->dev, "Failed reading register 0x%02x!\n", reg);
+       return ret;
+}
+
+/* write a register */
+static int ov6650_reg_write(struct i2c_client *client, u8 reg, u8 val)
+{
+       int ret;
+       unsigned char data[2] = { reg, val };
+       struct i2c_msg msg = {
+               .addr   = client->addr,
+               .flags  = 0,
+               .len    = 2,
+               .buf    = data,
+       };
+
+       ret = i2c_transfer(client->adapter, &msg, 1);
+       udelay(100);
+
+       if (ret < 0) {
+               dev_err(&client->dev, "Failed writing register 0x%02x!\n", reg);
+               return ret;
+       }
+       return 0;
+}
+
+
+/* Read a register, alter its bits, write it back */
+static int ov6650_reg_rmw(struct i2c_client *client, u8 reg, u8 set, u8 mask)
+{
+       u8 val;
+       int ret;
+
+       ret = ov6650_reg_read(client, reg, &val);
+       if (ret) {
+               dev_err(&client->dev,
+                       "[Read]-Modify-Write of register 0x%02x failed!\n",
+                       reg);
+               return ret;
+       }
+
+       val &= ~mask;
+       val |= set;
+
+       ret = ov6650_reg_write(client, reg, val);
+       if (ret)
+               dev_err(&client->dev,
+                       "Read-Modify-[Write] of register 0x%02x failed!\n",
+                       reg);
+
+       return ret;
+}
+
+static struct ov6650 *to_ov6650(const struct i2c_client *client)
+{
+       return container_of(i2c_get_clientdata(client), struct ov6650, subdev);
+}
+
+/* Start/Stop streaming from the device */
+static int ov6650_s_stream(struct v4l2_subdev *sd, int enable)
+{
+       return 0;
+}
+
+/* Get status of additional camera capabilities */
+static int ov6550_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
+{
+       struct ov6650 *priv = container_of(ctrl->handler, struct ov6650, hdl);
+       struct v4l2_subdev *sd = &priv->subdev;
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       uint8_t reg, reg2;
+       int ret;
+
+       switch (ctrl->id) {
+       case V4L2_CID_AUTOGAIN:
+               ret = ov6650_reg_read(client, REG_GAIN, &reg);
+               if (!ret)
+                       priv->gain->val = reg;
+               return ret;
+       case V4L2_CID_AUTO_WHITE_BALANCE:
+               ret = ov6650_reg_read(client, REG_BLUE, &reg);
+               if (!ret)
+                       ret = ov6650_reg_read(client, REG_RED, &reg2);
+               if (!ret) {
+                       priv->blue->val = reg;
+                       priv->red->val = reg2;
+               }
+               return ret;
+       case V4L2_CID_EXPOSURE_AUTO:
+               ret = ov6650_reg_read(client, REG_AECH, &reg);
+               if (!ret)
+                       priv->exposure->val = reg;
+               return ret;
+       }
+       return -EINVAL;
+}
+
+/* Set status of additional camera capabilities */
+static int ov6550_s_ctrl(struct v4l2_ctrl *ctrl)
+{
+       struct ov6650 *priv = container_of(ctrl->handler, struct ov6650, hdl);
+       struct v4l2_subdev *sd = &priv->subdev;
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       int ret;
+
+       switch (ctrl->id) {
+       case V4L2_CID_AUTOGAIN:
+               ret = ov6650_reg_rmw(client, REG_COMB,
+                               ctrl->val ? COMB_AGC : 0, COMB_AGC);
+               if (!ret && !ctrl->val)
+                       ret = ov6650_reg_write(client, REG_GAIN, priv->gain->val);
+               return ret;
+       case V4L2_CID_AUTO_WHITE_BALANCE:
+               ret = ov6650_reg_rmw(client, REG_COMB,
+                               ctrl->val ? COMB_AWB : 0, COMB_AWB);
+               if (!ret && !ctrl->val) {
+                       ret = ov6650_reg_write(client, REG_BLUE, priv->blue->val);
+                       if (!ret)
+                               ret = ov6650_reg_write(client, REG_RED,
+                                                       priv->red->val);
+               }
+               return ret;
+       case V4L2_CID_SATURATION:
+               return ov6650_reg_rmw(client, REG_SAT, SET_SAT(ctrl->val),
+                               SAT_MASK);
+       case V4L2_CID_HUE:
+               return ov6650_reg_rmw(client, REG_HUE, SET_HUE(ctrl->val),
+                               HUE_MASK);
+       case V4L2_CID_BRIGHTNESS:
+               return ov6650_reg_write(client, REG_BRT, ctrl->val);
+       case V4L2_CID_EXPOSURE_AUTO:
+               ret = ov6650_reg_rmw(client, REG_COMB, ctrl->val ==
+                               V4L2_EXPOSURE_AUTO ? COMB_AEC : 0, COMB_AEC);
+               if (!ret && ctrl->val == V4L2_EXPOSURE_MANUAL)
+                       ret = ov6650_reg_write(client, REG_AECH,
+                                               priv->exposure->val);
+               return ret;
+       case V4L2_CID_GAMMA:
+               return ov6650_reg_write(client, REG_GAM1, ctrl->val);
+       case V4L2_CID_VFLIP:
+               return ov6650_reg_rmw(client, REG_COMB,
+                               ctrl->val ? COMB_FLIP_V : 0, COMB_FLIP_V);
+       case V4L2_CID_HFLIP:
+               return ov6650_reg_rmw(client, REG_COMB,
+                               ctrl->val ? COMB_FLIP_H : 0, COMB_FLIP_H);
+       }
+
+       return -EINVAL;
+}
+
+/* Get chip identification */
+static int ov6650_g_chip_ident(struct v4l2_subdev *sd,
+                               struct v4l2_dbg_chip_ident *id)
+{
+       id->ident       = V4L2_IDENT_OV6650;
+       id->revision    = 0;
+
+       return 0;
+}
+
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+static int ov6650_get_register(struct v4l2_subdev *sd,
+                               struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       int ret;
+       u8 val;
+
+       if (reg->reg & ~0xff)
+               return -EINVAL;
+
+       reg->size = 1;
+
+       ret = ov6650_reg_read(client, reg->reg, &val);
+       if (!ret)
+               reg->val = (__u64)val;
+
+       return ret;
+}
+
+static int ov6650_set_register(struct v4l2_subdev *sd,
+                               struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+       if (reg->reg & ~0xff || reg->val & ~0xff)
+               return -EINVAL;
+
+       return ov6650_reg_write(client, reg->reg, reg->val);
+}
+#endif
+
+static int ov6650_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct ov6650 *priv = to_ov6650(client);
+
+       a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+       a->c = priv->rect;
+
+       return 0;
+}
+
+static int ov6650_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct ov6650 *priv = to_ov6650(client);
+       struct v4l2_rect *rect = &a->c;
+       int ret;
+
+       if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+               return -EINVAL;
+
+       rect->left   = ALIGN(rect->left,   2);
+       rect->width  = ALIGN(rect->width,  2);
+       rect->top    = ALIGN(rect->top,    2);
+       rect->height = ALIGN(rect->height, 2);
+       soc_camera_limit_side(&rect->left, &rect->width,
+                       DEF_HSTRT << 1, 2, W_CIF);
+       soc_camera_limit_side(&rect->top, &rect->height,
+                       DEF_VSTRT << 1, 2, H_CIF);
+
+       ret = ov6650_reg_write(client, REG_HSTRT, rect->left >> 1);
+       if (!ret) {
+               priv->rect.left = rect->left;
+               ret = ov6650_reg_write(client, REG_HSTOP,
+                               (rect->left + rect->width) >> 1);
+       }
+       if (!ret) {
+               priv->rect.width = rect->width;
+               ret = ov6650_reg_write(client, REG_VSTRT, rect->top >> 1);
+       }
+       if (!ret) {
+               priv->rect.top = rect->top;
+               ret = ov6650_reg_write(client, REG_VSTOP,
+                               (rect->top + rect->height) >> 1);
+       }
+       if (!ret)
+               priv->rect.height = rect->height;
+
+       return ret;
+}
+
+static int ov6650_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
+{
+       if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+               return -EINVAL;
+
+       a->bounds.left                  = DEF_HSTRT << 1;
+       a->bounds.top                   = DEF_VSTRT << 1;
+       a->bounds.width                 = W_CIF;
+       a->bounds.height                = H_CIF;
+       a->defrect                      = a->bounds;
+       a->pixelaspect.numerator        = 1;
+       a->pixelaspect.denominator      = 1;
+
+       return 0;
+}
+
+static int ov6650_g_fmt(struct v4l2_subdev *sd,
+                        struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct ov6650 *priv = to_ov6650(client);
+
+       mf->width       = priv->rect.width >> priv->half_scale;
+       mf->height      = priv->rect.height >> priv->half_scale;
+       mf->code        = priv->code;
+       mf->colorspace  = priv->colorspace;
+       mf->field       = V4L2_FIELD_NONE;
+
+       return 0;
+}
+
+static bool is_unscaled_ok(int width, int height, struct v4l2_rect *rect)
+{
+       return width > rect->width >> 1 || height > rect->height >> 1;
+}
+
+static u8 to_clkrc(struct v4l2_fract *timeperframe,
+               unsigned long pclk_limit, unsigned long pclk_max)
+{
+       unsigned long pclk;
+
+       if (timeperframe->numerator && timeperframe->denominator)
+               pclk = pclk_max * timeperframe->denominator /
+                               (FRAME_RATE_MAX * timeperframe->numerator);
+       else
+               pclk = pclk_max;
+
+       if (pclk_limit && pclk_limit < pclk)
+               pclk = pclk_limit;
+
+       return (pclk_max - 1) / pclk;
+}
+
+/* set the format we will capture in */
+static int ov6650_s_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct soc_camera_device *icd = v4l2_get_subdev_hostdata(sd);
+       struct soc_camera_sense *sense = icd->sense;
+       struct ov6650 *priv = to_ov6650(client);
+       bool half_scale = !is_unscaled_ok(mf->width, mf->height, &priv->rect);
+       struct v4l2_crop a = {
+               .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+               .c = {
+                       .left   = priv->rect.left + (priv->rect.width >> 1) -
+                                       (mf->width >> (1 - half_scale)),
+                       .top    = priv->rect.top + (priv->rect.height >> 1) -
+                                       (mf->height >> (1 - half_scale)),
+                       .width  = mf->width << half_scale,
+                       .height = mf->height << half_scale,
+               },
+       };
+       enum v4l2_mbus_pixelcode code = mf->code;
+       unsigned long mclk, pclk;
+       u8 coma_set = 0, coma_mask = 0, coml_set, coml_mask, clkrc;
+       int ret;
+
+       /* select color matrix configuration for given color encoding */
+       switch (code) {
+       case V4L2_MBUS_FMT_Y8_1X8:
+               dev_dbg(&client->dev, "pixel format GREY8_1X8\n");
+               coma_mask |= COMA_RGB | COMA_WORD_SWAP | COMA_BYTE_SWAP;
+               coma_set |= COMA_BW;
+               break;
+       case V4L2_MBUS_FMT_YUYV8_2X8:
+               dev_dbg(&client->dev, "pixel format YUYV8_2X8_LE\n");
+               coma_mask |= COMA_RGB | COMA_BW | COMA_BYTE_SWAP;
+               coma_set |= COMA_WORD_SWAP;
+               break;
+       case V4L2_MBUS_FMT_YVYU8_2X8:
+               dev_dbg(&client->dev, "pixel format YVYU8_2X8_LE (untested)\n");
+               coma_mask |= COMA_RGB | COMA_BW | COMA_WORD_SWAP |
+                               COMA_BYTE_SWAP;
+               break;
+       case V4L2_MBUS_FMT_UYVY8_2X8:
+               dev_dbg(&client->dev, "pixel format YUYV8_2X8_BE\n");
+               if (half_scale) {
+                       coma_mask |= COMA_RGB | COMA_BW | COMA_WORD_SWAP;
+                       coma_set |= COMA_BYTE_SWAP;
+               } else {
+                       coma_mask |= COMA_RGB | COMA_BW;
+                       coma_set |= COMA_BYTE_SWAP | COMA_WORD_SWAP;
+               }
+               break;
+       case V4L2_MBUS_FMT_VYUY8_2X8:
+               dev_dbg(&client->dev, "pixel format YVYU8_2X8_BE (untested)\n");
+               if (half_scale) {
+                       coma_mask |= COMA_RGB | COMA_BW;
+                       coma_set |= COMA_BYTE_SWAP | COMA_WORD_SWAP;
+               } else {
+                       coma_mask |= COMA_RGB | COMA_BW | COMA_WORD_SWAP;
+                       coma_set |= COMA_BYTE_SWAP;
+               }
+               break;
+       case V4L2_MBUS_FMT_SBGGR8_1X8:
+               dev_dbg(&client->dev, "pixel format SBGGR8_1X8 (untested)\n");
+               coma_mask |= COMA_BW | COMA_BYTE_SWAP | COMA_WORD_SWAP;
+               coma_set |= COMA_RAW_RGB | COMA_RGB;
+               break;
+       default:
+               dev_err(&client->dev, "Pixel format not handled: 0x%x\n", code);
+               return -EINVAL;
+       }
+       priv->code = code;
+
+       if (code == V4L2_MBUS_FMT_Y8_1X8 ||
+                       code == V4L2_MBUS_FMT_SBGGR8_1X8) {
+               coml_mask = COML_ONE_CHANNEL;
+               coml_set = 0;
+               priv->pclk_max = 4000000;
+       } else {
+               coml_mask = 0;
+               coml_set = COML_ONE_CHANNEL;
+               priv->pclk_max = 8000000;
+       }
+
+       if (code == V4L2_MBUS_FMT_SBGGR8_1X8)
+               priv->colorspace = V4L2_COLORSPACE_SRGB;
+       else if (code != 0)
+               priv->colorspace = V4L2_COLORSPACE_JPEG;
+
+       if (half_scale) {
+               dev_dbg(&client->dev, "max resolution: QCIF\n");
+               coma_set |= COMA_QCIF;
+               priv->pclk_max /= 2;
+       } else {
+               dev_dbg(&client->dev, "max resolution: CIF\n");
+               coma_mask |= COMA_QCIF;
+       }
+       priv->half_scale = half_scale;
+
+       if (sense) {
+               if (sense->master_clock == 8000000) {
+                       dev_dbg(&client->dev, "8MHz input clock\n");
+                       clkrc = CLKRC_6MHz;
+               } else if (sense->master_clock == 12000000) {
+                       dev_dbg(&client->dev, "12MHz input clock\n");
+                       clkrc = CLKRC_12MHz;
+               } else if (sense->master_clock == 16000000) {
+                       dev_dbg(&client->dev, "16MHz input clock\n");
+                       clkrc = CLKRC_16MHz;
+               } else if (sense->master_clock == 24000000) {
+                       dev_dbg(&client->dev, "24MHz input clock\n");
+                       clkrc = CLKRC_24MHz;
+               } else {
+                       dev_err(&client->dev,
+                               "unsupported input clock, check platform data\n");
+                       return -EINVAL;
+               }
+               mclk = sense->master_clock;
+               priv->pclk_limit = sense->pixel_clock_max;
+       } else {
+               clkrc = CLKRC_24MHz;
+               mclk = 24000000;
+               priv->pclk_limit = 0;
+               dev_dbg(&client->dev, "using default 24MHz input clock\n");
+       }
+
+       clkrc |= to_clkrc(&priv->tpf, priv->pclk_limit, priv->pclk_max);
+
+       pclk = priv->pclk_max / GET_CLKRC_DIV(clkrc);
+       dev_dbg(&client->dev, "pixel clock divider: %ld.%ld\n",
+                       mclk / pclk, 10 * mclk % pclk / pclk);
+
+       ret = ov6650_s_crop(sd, &a);
+       if (!ret)
+               ret = ov6650_reg_rmw(client, REG_COMA, coma_set, coma_mask);
+       if (!ret)
+               ret = ov6650_reg_write(client, REG_CLKRC, clkrc);
+       if (!ret)
+               ret = ov6650_reg_rmw(client, REG_COML, coml_set, coml_mask);
+
+       if (!ret) {
+               mf->colorspace  = priv->colorspace;
+               mf->width = priv->rect.width >> half_scale;
+               mf->height = priv->rect.height >> half_scale;
+       }
+
+       return ret;
+}
+
+static int ov6650_try_fmt(struct v4l2_subdev *sd,
+                         struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct ov6650 *priv = to_ov6650(client);
+
+       if (is_unscaled_ok(mf->width, mf->height, &priv->rect))
+               v4l_bound_align_image(&mf->width, 2, W_CIF, 1,
+                               &mf->height, 2, H_CIF, 1, 0);
+
+       mf->field = V4L2_FIELD_NONE;
+
+       switch (mf->code) {
+       case V4L2_MBUS_FMT_Y10_1X10:
+               mf->code = V4L2_MBUS_FMT_Y8_1X8;
+       case V4L2_MBUS_FMT_Y8_1X8:
+       case V4L2_MBUS_FMT_YVYU8_2X8:
+       case V4L2_MBUS_FMT_YUYV8_2X8:
+       case V4L2_MBUS_FMT_VYUY8_2X8:
+       case V4L2_MBUS_FMT_UYVY8_2X8:
+               mf->colorspace = V4L2_COLORSPACE_JPEG;
+               break;
+       default:
+               mf->code = V4L2_MBUS_FMT_SBGGR8_1X8;
+       case V4L2_MBUS_FMT_SBGGR8_1X8:
+               mf->colorspace = V4L2_COLORSPACE_SRGB;
+               break;
+       }
+
+       return 0;
+}
+
+static int ov6650_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
+                          enum v4l2_mbus_pixelcode *code)
+{
+       if (index >= ARRAY_SIZE(ov6650_codes))
+               return -EINVAL;
+
+       *code = ov6650_codes[index];
+       return 0;
+}
+
+static int ov6650_g_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *parms)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct ov6650 *priv = to_ov6650(client);
+       struct v4l2_captureparm *cp = &parms->parm.capture;
+
+       if (parms->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+               return -EINVAL;
+
+       memset(cp, 0, sizeof(*cp));
+       cp->capability = V4L2_CAP_TIMEPERFRAME;
+       cp->timeperframe.numerator = GET_CLKRC_DIV(to_clkrc(&priv->tpf,
+                       priv->pclk_limit, priv->pclk_max));
+       cp->timeperframe.denominator = FRAME_RATE_MAX;
+
+       dev_dbg(&client->dev, "Frame interval: %u/%u s\n",
+               cp->timeperframe.numerator, cp->timeperframe.denominator);
+
+       return 0;
+}
+
+static int ov6650_s_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *parms)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct ov6650 *priv = to_ov6650(client);
+       struct v4l2_captureparm *cp = &parms->parm.capture;
+       struct v4l2_fract *tpf = &cp->timeperframe;
+       int div, ret;
+       u8 clkrc;
+
+       if (parms->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+               return -EINVAL;
+
+       if (cp->extendedmode != 0)
+               return -EINVAL;
+
+       if (tpf->numerator == 0 || tpf->denominator == 0)
+               div = 1;  /* Reset to full rate */
+       else
+               div = (tpf->numerator * FRAME_RATE_MAX) / tpf->denominator;
+
+       if (div == 0)
+               div = 1;
+       else if (div > GET_CLKRC_DIV(CLKRC_DIV_MASK))
+               div = GET_CLKRC_DIV(CLKRC_DIV_MASK);
+
+       /*
+        * Keep result to be used as tpf limit
+        * for subseqent clock divider calculations
+        */
+       priv->tpf.numerator = div;
+       priv->tpf.denominator = FRAME_RATE_MAX;
+
+       clkrc = to_clkrc(&priv->tpf, priv->pclk_limit, priv->pclk_max);
+
+       ret = ov6650_reg_rmw(client, REG_CLKRC, clkrc, CLKRC_DIV_MASK);
+       if (!ret) {
+               tpf->numerator = GET_CLKRC_DIV(clkrc);
+               tpf->denominator = FRAME_RATE_MAX;
+       }
+
+       return ret;
+}
+
+/* Soft reset the camera. This has nothing to do with the RESET pin! */
+static int ov6650_reset(struct i2c_client *client)
+{
+       int ret;
+
+       dev_dbg(&client->dev, "reset\n");
+
+       ret = ov6650_reg_rmw(client, REG_COMA, COMA_RESET, 0);
+       if (ret)
+               dev_err(&client->dev,
+                       "An error occurred while entering soft reset!\n");
+
+       return ret;
+}
+
+/* program default register values */
+static int ov6650_prog_dflt(struct i2c_client *client)
+{
+       int ret;
+
+       dev_dbg(&client->dev, "initializing\n");
+
+       ret = ov6650_reg_write(client, REG_COMA, 0);    /* ~COMA_RESET */
+       if (!ret)
+               ret = ov6650_reg_rmw(client, REG_COMB, 0, COMB_BAND_FILTER);
+
+       return ret;
+}
+
+static int ov6650_video_probe(struct i2c_client *client)
+{
+       u8              pidh, pidl, midh, midl;
+       int             ret = 0;
+
+       /*
+        * check and show product ID and manufacturer ID
+        */
+       ret = ov6650_reg_read(client, REG_PIDH, &pidh);
+       if (!ret)
+               ret = ov6650_reg_read(client, REG_PIDL, &pidl);
+       if (!ret)
+               ret = ov6650_reg_read(client, REG_MIDH, &midh);
+       if (!ret)
+               ret = ov6650_reg_read(client, REG_MIDL, &midl);
+
+       if (ret)
+               return ret;
+
+       if ((pidh != OV6650_PIDH) || (pidl != OV6650_PIDL)) {
+               dev_err(&client->dev, "Product ID error 0x%02x:0x%02x\n",
+                               pidh, pidl);
+               return -ENODEV;
+       }
+
+       dev_info(&client->dev,
+               "ov6650 Product ID 0x%02x:0x%02x Manufacturer ID 0x%02x:0x%02x\n",
+               pidh, pidl, midh, midl);
+
+       ret = ov6650_reset(client);
+       if (!ret)
+               ret = ov6650_prog_dflt(client);
+
+       return ret;
+}
+
+static const struct v4l2_ctrl_ops ov6550_ctrl_ops = {
+       .g_volatile_ctrl = ov6550_g_volatile_ctrl,
+       .s_ctrl = ov6550_s_ctrl,
+};
+
+static struct v4l2_subdev_core_ops ov6650_core_ops = {
+       .g_chip_ident           = ov6650_g_chip_ident,
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+       .g_register             = ov6650_get_register,
+       .s_register             = ov6650_set_register,
+#endif
+};
+
+/* Request bus settings on camera side */
+static int ov6650_g_mbus_config(struct v4l2_subdev *sd,
+                               struct v4l2_mbus_config *cfg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+
+       cfg->flags = V4L2_MBUS_MASTER |
+               V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_PCLK_SAMPLE_FALLING |
+               V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_HSYNC_ACTIVE_LOW |
+               V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_LOW |
+               V4L2_MBUS_DATA_ACTIVE_HIGH;
+       cfg->type = V4L2_MBUS_PARALLEL;
+       cfg->flags = soc_camera_apply_board_flags(icl, cfg);
+
+       return 0;
+}
+
+/* Alter bus settings on camera side */
+static int ov6650_s_mbus_config(struct v4l2_subdev *sd,
+                               const struct v4l2_mbus_config *cfg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+       unsigned long flags = soc_camera_apply_board_flags(icl, cfg);
+       int ret;
+
+       if (flags & V4L2_MBUS_PCLK_SAMPLE_RISING)
+               ret = ov6650_reg_rmw(client, REG_COMJ, COMJ_PCLK_RISING, 0);
+       else
+               ret = ov6650_reg_rmw(client, REG_COMJ, 0, COMJ_PCLK_RISING);
+       if (ret)
+               return ret;
+
+       if (flags & V4L2_MBUS_HSYNC_ACTIVE_LOW)
+               ret = ov6650_reg_rmw(client, REG_COMF, COMF_HREF_LOW, 0);
+       else
+               ret = ov6650_reg_rmw(client, REG_COMF, 0, COMF_HREF_LOW);
+       if (ret)
+               return ret;
+
+       if (flags & V4L2_MBUS_VSYNC_ACTIVE_HIGH)
+               ret = ov6650_reg_rmw(client, REG_COMJ, COMJ_VSYNC_HIGH, 0);
+       else
+               ret = ov6650_reg_rmw(client, REG_COMJ, 0, COMJ_VSYNC_HIGH);
+
+       return ret;
+}
+
+static struct v4l2_subdev_video_ops ov6650_video_ops = {
+       .s_stream       = ov6650_s_stream,
+       .g_mbus_fmt     = ov6650_g_fmt,
+       .s_mbus_fmt     = ov6650_s_fmt,
+       .try_mbus_fmt   = ov6650_try_fmt,
+       .enum_mbus_fmt  = ov6650_enum_fmt,
+       .cropcap        = ov6650_cropcap,
+       .g_crop         = ov6650_g_crop,
+       .s_crop         = ov6650_s_crop,
+       .g_parm         = ov6650_g_parm,
+       .s_parm         = ov6650_s_parm,
+       .g_mbus_config  = ov6650_g_mbus_config,
+       .s_mbus_config  = ov6650_s_mbus_config,
+};
+
+static struct v4l2_subdev_ops ov6650_subdev_ops = {
+       .core   = &ov6650_core_ops,
+       .video  = &ov6650_video_ops,
+};
+
+/*
+ * i2c_driver function
+ */
+static int ov6650_probe(struct i2c_client *client,
+                       const struct i2c_device_id *did)
+{
+       struct ov6650 *priv;
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+       int ret;
+
+       if (!icl) {
+               dev_err(&client->dev, "Missing platform_data for driver\n");
+               return -EINVAL;
+       }
+
+       priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+       if (!priv) {
+               dev_err(&client->dev,
+                       "Failed to allocate memory for private data!\n");
+               return -ENOMEM;
+       }
+
+       v4l2_i2c_subdev_init(&priv->subdev, client, &ov6650_subdev_ops);
+       v4l2_ctrl_handler_init(&priv->hdl, 13);
+       v4l2_ctrl_new_std(&priv->hdl, &ov6550_ctrl_ops,
+                       V4L2_CID_VFLIP, 0, 1, 1, 0);
+       v4l2_ctrl_new_std(&priv->hdl, &ov6550_ctrl_ops,
+                       V4L2_CID_HFLIP, 0, 1, 1, 0);
+       priv->autogain = v4l2_ctrl_new_std(&priv->hdl, &ov6550_ctrl_ops,
+                       V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
+       priv->gain = v4l2_ctrl_new_std(&priv->hdl, &ov6550_ctrl_ops,
+                       V4L2_CID_GAIN, 0, 0x3f, 1, DEF_GAIN);
+       priv->autowb = v4l2_ctrl_new_std(&priv->hdl, &ov6550_ctrl_ops,
+                       V4L2_CID_AUTO_WHITE_BALANCE, 0, 1, 1, 1);
+       priv->blue = v4l2_ctrl_new_std(&priv->hdl, &ov6550_ctrl_ops,
+                       V4L2_CID_BLUE_BALANCE, 0, 0xff, 1, DEF_BLUE);
+       priv->red = v4l2_ctrl_new_std(&priv->hdl, &ov6550_ctrl_ops,
+                       V4L2_CID_RED_BALANCE, 0, 0xff, 1, DEF_RED);
+       v4l2_ctrl_new_std(&priv->hdl, &ov6550_ctrl_ops,
+                       V4L2_CID_SATURATION, 0, 0xf, 1, 0x8);
+       v4l2_ctrl_new_std(&priv->hdl, &ov6550_ctrl_ops,
+                       V4L2_CID_HUE, 0, HUE_MASK, 1, DEF_HUE);
+       v4l2_ctrl_new_std(&priv->hdl, &ov6550_ctrl_ops,
+                       V4L2_CID_BRIGHTNESS, 0, 0xff, 1, 0x80);
+       priv->autoexposure = v4l2_ctrl_new_std_menu(&priv->hdl,
+                       &ov6550_ctrl_ops, V4L2_CID_EXPOSURE_AUTO,
+                       V4L2_EXPOSURE_MANUAL, 0, V4L2_EXPOSURE_AUTO);
+       priv->exposure = v4l2_ctrl_new_std(&priv->hdl, &ov6550_ctrl_ops,
+                       V4L2_CID_EXPOSURE, 0, 0xff, 1, DEF_AECH);
+       v4l2_ctrl_new_std(&priv->hdl, &ov6550_ctrl_ops,
+                       V4L2_CID_GAMMA, 0, 0xff, 1, 0x12);
+
+       priv->subdev.ctrl_handler = &priv->hdl;
+       if (priv->hdl.error) {
+               int err = priv->hdl.error;
+
+               kfree(priv);
+               return err;
+       }
+       v4l2_ctrl_auto_cluster(2, &priv->autogain, 0, true);
+       v4l2_ctrl_auto_cluster(3, &priv->autowb, 0, true);
+       v4l2_ctrl_auto_cluster(2, &priv->autoexposure,
+                               V4L2_EXPOSURE_MANUAL, true);
+
+       priv->rect.left   = DEF_HSTRT << 1;
+       priv->rect.top    = DEF_VSTRT << 1;
+       priv->rect.width  = W_CIF;
+       priv->rect.height = H_CIF;
+       priv->half_scale  = false;
+       priv->code        = V4L2_MBUS_FMT_YUYV8_2X8;
+       priv->colorspace  = V4L2_COLORSPACE_JPEG;
+
+       ret = ov6650_video_probe(client);
+       if (!ret)
+               ret = v4l2_ctrl_handler_setup(&priv->hdl);
+
+       if (ret) {
+               v4l2_ctrl_handler_free(&priv->hdl);
+               kfree(priv);
+       }
+
+       return ret;
+}
+
+static int ov6650_remove(struct i2c_client *client)
+{
+       struct ov6650 *priv = to_ov6650(client);
+
+       v4l2_device_unregister_subdev(&priv->subdev);
+       v4l2_ctrl_handler_free(&priv->hdl);
+       kfree(priv);
+       return 0;
+}
+
+static const struct i2c_device_id ov6650_id[] = {
+       { "ov6650", 0 },
+       { }
+};
+MODULE_DEVICE_TABLE(i2c, ov6650_id);
+
+static struct i2c_driver ov6650_i2c_driver = {
+       .driver = {
+               .name = "ov6650",
+       },
+       .probe    = ov6650_probe,
+       .remove   = ov6650_remove,
+       .id_table = ov6650_id,
+};
+
+module_i2c_driver(ov6650_i2c_driver);
+
+MODULE_DESCRIPTION("SoC Camera driver for OmniVision OV6650");
+MODULE_AUTHOR("Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/i2c/soc_camera/ov772x.c b/drivers/media/i2c/soc_camera/ov772x.c
new file mode 100644 (file)
index 0000000..6d79b89
--- /dev/null
@@ -0,0 +1,1126 @@
+/*
+ * ov772x Camera Driver
+ *
+ * Copyright (C) 2008 Renesas Solutions Corp.
+ * Kuninori Morimoto <morimoto.kuninori@renesas.com>
+ *
+ * Based on ov7670 and soc_camera_platform driver,
+ *
+ * Copyright 2006-7 Jonathan Corbet <corbet@lwn.net>
+ * Copyright (C) 2008 Magnus Damm
+ * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/v4l2-mediabus.h>
+#include <linux/videodev2.h>
+
+#include <media/ov772x.h>
+#include <media/soc_camera.h>
+#include <media/v4l2-ctrls.h>
+#include <media/v4l2-chip-ident.h>
+#include <media/v4l2-subdev.h>
+
+/*
+ * register offset
+ */
+#define GAIN        0x00 /* AGC - Gain control gain setting */
+#define BLUE        0x01 /* AWB - Blue channel gain setting */
+#define RED         0x02 /* AWB - Red   channel gain setting */
+#define GREEN       0x03 /* AWB - Green channel gain setting */
+#define COM1        0x04 /* Common control 1 */
+#define BAVG        0x05 /* U/B Average Level */
+#define GAVG        0x06 /* Y/Gb Average Level */
+#define RAVG        0x07 /* V/R Average Level */
+#define AECH        0x08 /* Exposure Value - AEC MSBs */
+#define COM2        0x09 /* Common control 2 */
+#define PID         0x0A /* Product ID Number MSB */
+#define VER         0x0B /* Product ID Number LSB */
+#define COM3        0x0C /* Common control 3 */
+#define COM4        0x0D /* Common control 4 */
+#define COM5        0x0E /* Common control 5 */
+#define COM6        0x0F /* Common control 6 */
+#define AEC         0x10 /* Exposure Value */
+#define CLKRC       0x11 /* Internal clock */
+#define COM7        0x12 /* Common control 7 */
+#define COM8        0x13 /* Common control 8 */
+#define COM9        0x14 /* Common control 9 */
+#define COM10       0x15 /* Common control 10 */
+#define REG16       0x16 /* Register 16 */
+#define HSTART      0x17 /* Horizontal sensor size */
+#define HSIZE       0x18 /* Horizontal frame (HREF column) end high 8-bit */
+#define VSTART      0x19 /* Vertical frame (row) start high 8-bit */
+#define VSIZE       0x1A /* Vertical sensor size */
+#define PSHFT       0x1B /* Data format - pixel delay select */
+#define MIDH        0x1C /* Manufacturer ID byte - high */
+#define MIDL        0x1D /* Manufacturer ID byte - low  */
+#define LAEC        0x1F /* Fine AEC value */
+#define COM11       0x20 /* Common control 11 */
+#define BDBASE      0x22 /* Banding filter Minimum AEC value */
+#define DBSTEP      0x23 /* Banding filter Maximum Setp */
+#define AEW         0x24 /* AGC/AEC - Stable operating region (upper limit) */
+#define AEB         0x25 /* AGC/AEC - Stable operating region (lower limit) */
+#define VPT         0x26 /* AGC/AEC Fast mode operating region */
+#define REG28       0x28 /* Register 28 */
+#define HOUTSIZE    0x29 /* Horizontal data output size MSBs */
+#define EXHCH       0x2A /* Dummy pixel insert MSB */
+#define EXHCL       0x2B /* Dummy pixel insert LSB */
+#define VOUTSIZE    0x2C /* Vertical data output size MSBs */
+#define ADVFL       0x2D /* LSB of insert dummy lines in Vertical direction */
+#define ADVFH       0x2E /* MSG of insert dummy lines in Vertical direction */
+#define YAVE        0x2F /* Y/G Channel Average value */
+#define LUMHTH      0x30 /* Histogram AEC/AGC Luminance high level threshold */
+#define LUMLTH      0x31 /* Histogram AEC/AGC Luminance low  level threshold */
+#define HREF        0x32 /* Image start and size control */
+#define DM_LNL      0x33 /* Dummy line low  8 bits */
+#define DM_LNH      0x34 /* Dummy line high 8 bits */
+#define ADOFF_B     0x35 /* AD offset compensation value for B  channel */
+#define ADOFF_R     0x36 /* AD offset compensation value for R  channel */
+#define ADOFF_GB    0x37 /* AD offset compensation value for Gb channel */
+#define ADOFF_GR    0x38 /* AD offset compensation value for Gr channel */
+#define OFF_B       0x39 /* Analog process B  channel offset value */
+#define OFF_R       0x3A /* Analog process R  channel offset value */
+#define OFF_GB      0x3B /* Analog process Gb channel offset value */
+#define OFF_GR      0x3C /* Analog process Gr channel offset value */
+#define COM12       0x3D /* Common control 12 */
+#define COM13       0x3E /* Common control 13 */
+#define COM14       0x3F /* Common control 14 */
+#define COM15       0x40 /* Common control 15*/
+#define COM16       0x41 /* Common control 16 */
+#define TGT_B       0x42 /* BLC blue channel target value */
+#define TGT_R       0x43 /* BLC red  channel target value */
+#define TGT_GB      0x44 /* BLC Gb   channel target value */
+#define TGT_GR      0x45 /* BLC Gr   channel target value */
+/* for ov7720 */
+#define LCC0        0x46 /* Lens correction control 0 */
+#define LCC1        0x47 /* Lens correction option 1 - X coordinate */
+#define LCC2        0x48 /* Lens correction option 2 - Y coordinate */
+#define LCC3        0x49 /* Lens correction option 3 */
+#define LCC4        0x4A /* Lens correction option 4 - radius of the circular */
+#define LCC5        0x4B /* Lens correction option 5 */
+#define LCC6        0x4C /* Lens correction option 6 */
+/* for ov7725 */
+#define LC_CTR      0x46 /* Lens correction control */
+#define LC_XC       0x47 /* X coordinate of lens correction center relative */
+#define LC_YC       0x48 /* Y coordinate of lens correction center relative */
+#define LC_COEF     0x49 /* Lens correction coefficient */
+#define LC_RADI     0x4A /* Lens correction radius */
+#define LC_COEFB    0x4B /* Lens B channel compensation coefficient */
+#define LC_COEFR    0x4C /* Lens R channel compensation coefficient */
+
+#define FIXGAIN     0x4D /* Analog fix gain amplifer */
+#define AREF0       0x4E /* Sensor reference control */
+#define AREF1       0x4F /* Sensor reference current control */
+#define AREF2       0x50 /* Analog reference control */
+#define AREF3       0x51 /* ADC    reference control */
+#define AREF4       0x52 /* ADC    reference control */
+#define AREF5       0x53 /* ADC    reference control */
+#define AREF6       0x54 /* Analog reference control */
+#define AREF7       0x55 /* Analog reference control */
+#define UFIX        0x60 /* U channel fixed value output */
+#define VFIX        0x61 /* V channel fixed value output */
+#define AWBB_BLK    0x62 /* AWB option for advanced AWB */
+#define AWB_CTRL0   0x63 /* AWB control byte 0 */
+#define DSP_CTRL1   0x64 /* DSP control byte 1 */
+#define DSP_CTRL2   0x65 /* DSP control byte 2 */
+#define DSP_CTRL3   0x66 /* DSP control byte 3 */
+#define DSP_CTRL4   0x67 /* DSP control byte 4 */
+#define AWB_BIAS    0x68 /* AWB BLC level clip */
+#define AWB_CTRL1   0x69 /* AWB control  1 */
+#define AWB_CTRL2   0x6A /* AWB control  2 */
+#define AWB_CTRL3   0x6B /* AWB control  3 */
+#define AWB_CTRL4   0x6C /* AWB control  4 */
+#define AWB_CTRL5   0x6D /* AWB control  5 */
+#define AWB_CTRL6   0x6E /* AWB control  6 */
+#define AWB_CTRL7   0x6F /* AWB control  7 */
+#define AWB_CTRL8   0x70 /* AWB control  8 */
+#define AWB_CTRL9   0x71 /* AWB control  9 */
+#define AWB_CTRL10  0x72 /* AWB control 10 */
+#define AWB_CTRL11  0x73 /* AWB control 11 */
+#define AWB_CTRL12  0x74 /* AWB control 12 */
+#define AWB_CTRL13  0x75 /* AWB control 13 */
+#define AWB_CTRL14  0x76 /* AWB control 14 */
+#define AWB_CTRL15  0x77 /* AWB control 15 */
+#define AWB_CTRL16  0x78 /* AWB control 16 */
+#define AWB_CTRL17  0x79 /* AWB control 17 */
+#define AWB_CTRL18  0x7A /* AWB control 18 */
+#define AWB_CTRL19  0x7B /* AWB control 19 */
+#define AWB_CTRL20  0x7C /* AWB control 20 */
+#define AWB_CTRL21  0x7D /* AWB control 21 */
+#define GAM1        0x7E /* Gamma Curve  1st segment input end point */
+#define GAM2        0x7F /* Gamma Curve  2nd segment input end point */
+#define GAM3        0x80 /* Gamma Curve  3rd segment input end point */
+#define GAM4        0x81 /* Gamma Curve  4th segment input end point */
+#define GAM5        0x82 /* Gamma Curve  5th segment input end point */
+#define GAM6        0x83 /* Gamma Curve  6th segment input end point */
+#define GAM7        0x84 /* Gamma Curve  7th segment input end point */
+#define GAM8        0x85 /* Gamma Curve  8th segment input end point */
+#define GAM9        0x86 /* Gamma Curve  9th segment input end point */
+#define GAM10       0x87 /* Gamma Curve 10th segment input end point */
+#define GAM11       0x88 /* Gamma Curve 11th segment input end point */
+#define GAM12       0x89 /* Gamma Curve 12th segment input end point */
+#define GAM13       0x8A /* Gamma Curve 13th segment input end point */
+#define GAM14       0x8B /* Gamma Curve 14th segment input end point */
+#define GAM15       0x8C /* Gamma Curve 15th segment input end point */
+#define SLOP        0x8D /* Gamma curve highest segment slope */
+#define DNSTH       0x8E /* De-noise threshold */
+#define EDGE_STRNGT 0x8F /* Edge strength  control when manual mode */
+#define EDGE_TRSHLD 0x90 /* Edge threshold control when manual mode */
+#define DNSOFF      0x91 /* Auto De-noise threshold control */
+#define EDGE_UPPER  0x92 /* Edge strength upper limit when Auto mode */
+#define EDGE_LOWER  0x93 /* Edge strength lower limit when Auto mode */
+#define MTX1        0x94 /* Matrix coefficient 1 */
+#define MTX2        0x95 /* Matrix coefficient 2 */
+#define MTX3        0x96 /* Matrix coefficient 3 */
+#define MTX4        0x97 /* Matrix coefficient 4 */
+#define MTX5        0x98 /* Matrix coefficient 5 */
+#define MTX6        0x99 /* Matrix coefficient 6 */
+#define MTX_CTRL    0x9A /* Matrix control */
+#define BRIGHT      0x9B /* Brightness control */
+#define CNTRST      0x9C /* Contrast contrast */
+#define CNTRST_CTRL 0x9D /* Contrast contrast center */
+#define UVAD_J0     0x9E /* Auto UV adjust contrast 0 */
+#define UVAD_J1     0x9F /* Auto UV adjust contrast 1 */
+#define SCAL0       0xA0 /* Scaling control 0 */
+#define SCAL1       0xA1 /* Scaling control 1 */
+#define SCAL2       0xA2 /* Scaling control 2 */
+#define FIFODLYM    0xA3 /* FIFO manual mode delay control */
+#define FIFODLYA    0xA4 /* FIFO auto   mode delay control */
+#define SDE         0xA6 /* Special digital effect control */
+#define USAT        0xA7 /* U component saturation control */
+#define VSAT        0xA8 /* V component saturation control */
+/* for ov7720 */
+#define HUE0        0xA9 /* Hue control 0 */
+#define HUE1        0xAA /* Hue control 1 */
+/* for ov7725 */
+#define HUECOS      0xA9 /* Cosine value */
+#define HUESIN      0xAA /* Sine value */
+
+#define SIGN        0xAB /* Sign bit for Hue and contrast */
+#define DSPAUTO     0xAC /* DSP auto function ON/OFF control */
+
+/*
+ * register detail
+ */
+
+/* COM2 */
+#define SOFT_SLEEP_MODE 0x10   /* Soft sleep mode */
+                               /* Output drive capability */
+#define OCAP_1x         0x00   /* 1x */
+#define OCAP_2x         0x01   /* 2x */
+#define OCAP_3x         0x02   /* 3x */
+#define OCAP_4x         0x03   /* 4x */
+
+/* COM3 */
+#define SWAP_MASK       (SWAP_RGB | SWAP_YUV | SWAP_ML)
+#define IMG_MASK        (VFLIP_IMG | HFLIP_IMG)
+
+#define VFLIP_IMG       0x80   /* Vertical flip image ON/OFF selection */
+#define HFLIP_IMG       0x40   /* Horizontal mirror image ON/OFF selection */
+#define SWAP_RGB        0x20   /* Swap B/R  output sequence in RGB mode */
+#define SWAP_YUV        0x10   /* Swap Y/UV output sequence in YUV mode */
+#define SWAP_ML         0x08   /* Swap output MSB/LSB */
+                               /* Tri-state option for output clock */
+#define NOTRI_CLOCK     0x04   /*   0: Tri-state    at this period */
+                               /*   1: No tri-state at this period */
+                               /* Tri-state option for output data */
+#define NOTRI_DATA      0x02   /*   0: Tri-state    at this period */
+                               /*   1: No tri-state at this period */
+#define SCOLOR_TEST     0x01   /* Sensor color bar test pattern */
+
+/* COM4 */
+                               /* PLL frequency control */
+#define PLL_BYPASS      0x00   /*  00: Bypass PLL */
+#define PLL_4x          0x40   /*  01: PLL 4x */
+#define PLL_6x          0x80   /*  10: PLL 6x */
+#define PLL_8x          0xc0   /*  11: PLL 8x */
+                               /* AEC evaluate window */
+#define AEC_FULL        0x00   /*  00: Full window */
+#define AEC_1p2         0x10   /*  01: 1/2  window */
+#define AEC_1p4         0x20   /*  10: 1/4  window */
+#define AEC_2p3         0x30   /*  11: Low 2/3 window */
+
+/* COM5 */
+#define AFR_ON_OFF      0x80   /* Auto frame rate control ON/OFF selection */
+#define AFR_SPPED       0x40   /* Auto frame rate control speed selection */
+                               /* Auto frame rate max rate control */
+#define AFR_NO_RATE     0x00   /*     No  reduction of frame rate */
+#define AFR_1p2         0x10   /*     Max reduction to 1/2 frame rate */
+#define AFR_1p4         0x20   /*     Max reduction to 1/4 frame rate */
+#define AFR_1p8         0x30   /* Max reduction to 1/8 frame rate */
+                               /* Auto frame rate active point control */
+#define AF_2x           0x00   /*     Add frame when AGC reaches  2x gain */
+#define AF_4x           0x04   /*     Add frame when AGC reaches  4x gain */
+#define AF_8x           0x08   /*     Add frame when AGC reaches  8x gain */
+#define AF_16x          0x0c   /* Add frame when AGC reaches 16x gain */
+                               /* AEC max step control */
+#define AEC_NO_LIMIT    0x01   /*   0 : AEC incease step has limit */
+                               /*   1 : No limit to AEC increase step */
+
+/* COM7 */
+                               /* SCCB Register Reset */
+#define SCCB_RESET      0x80   /*   0 : No change */
+                               /*   1 : Resets all registers to default */
+                               /* Resolution selection */
+#define SLCT_MASK       0x40   /*   Mask of VGA or QVGA */
+#define SLCT_VGA        0x00   /*   0 : VGA */
+#define SLCT_QVGA       0x40   /*   1 : QVGA */
+#define ITU656_ON_OFF   0x20   /* ITU656 protocol ON/OFF selection */
+                               /* RGB output format control */
+#define FMT_MASK        0x0c   /*      Mask of color format */
+#define FMT_GBR422      0x00   /*      00 : GBR 4:2:2 */
+#define FMT_RGB565      0x04   /*      01 : RGB 565 */
+#define FMT_RGB555      0x08   /*      10 : RGB 555 */
+#define FMT_RGB444      0x0c   /* 11 : RGB 444 */
+                               /* Output format control */
+#define OFMT_MASK       0x03    /*      Mask of output format */
+#define OFMT_YUV        0x00   /*      00 : YUV */
+#define OFMT_P_BRAW     0x01   /*      01 : Processed Bayer RAW */
+#define OFMT_RGB        0x02   /*      10 : RGB */
+#define OFMT_BRAW       0x03   /* 11 : Bayer RAW */
+
+/* COM8 */
+#define FAST_ALGO       0x80   /* Enable fast AGC/AEC algorithm */
+                               /* AEC Setp size limit */
+#define UNLMT_STEP      0x40   /*   0 : Step size is limited */
+                               /*   1 : Unlimited step size */
+#define BNDF_ON_OFF     0x20   /* Banding filter ON/OFF */
+#define AEC_BND         0x10   /* Enable AEC below banding value */
+#define AEC_ON_OFF      0x08   /* Fine AEC ON/OFF control */
+#define AGC_ON          0x04   /* AGC Enable */
+#define AWB_ON          0x02   /* AWB Enable */
+#define AEC_ON          0x01   /* AEC Enable */
+
+/* COM9 */
+#define BASE_AECAGC     0x80   /* Histogram or average based AEC/AGC */
+                               /* Automatic gain ceiling - maximum AGC value */
+#define GAIN_2x         0x00   /*    000 :   2x */
+#define GAIN_4x         0x10   /*    001 :   4x */
+#define GAIN_8x         0x20   /*    010 :   8x */
+#define GAIN_16x        0x30   /*    011 :  16x */
+#define GAIN_32x        0x40   /*    100 :  32x */
+#define GAIN_64x        0x50   /* 101 :  64x */
+#define GAIN_128x       0x60   /* 110 : 128x */
+#define DROP_VSYNC      0x04   /* Drop VSYNC output of corrupt frame */
+#define DROP_HREF       0x02   /* Drop HREF  output of corrupt frame */
+
+/* COM11 */
+#define SGLF_ON_OFF     0x02   /* Single frame ON/OFF selection */
+#define SGLF_TRIG       0x01   /* Single frame transfer trigger */
+
+/* EXHCH */
+#define VSIZE_LSB       0x04   /* Vertical data output size LSB */
+
+/* DSP_CTRL1 */
+#define FIFO_ON         0x80   /* FIFO enable/disable selection */
+#define UV_ON_OFF       0x40   /* UV adjust function ON/OFF selection */
+#define YUV444_2_422    0x20   /* YUV444 to 422 UV channel option selection */
+#define CLR_MTRX_ON_OFF 0x10   /* Color matrix ON/OFF selection */
+#define INTPLT_ON_OFF   0x08   /* Interpolation ON/OFF selection */
+#define GMM_ON_OFF      0x04   /* Gamma function ON/OFF selection */
+#define AUTO_BLK_ON_OFF 0x02   /* Black defect auto correction ON/OFF */
+#define AUTO_WHT_ON_OFF 0x01   /* White define auto correction ON/OFF */
+
+/* DSP_CTRL3 */
+#define UV_MASK         0x80   /* UV output sequence option */
+#define UV_ON           0x80   /*   ON */
+#define UV_OFF          0x00   /*   OFF */
+#define CBAR_MASK       0x20   /* DSP Color bar mask */
+#define CBAR_ON         0x20   /*   ON */
+#define CBAR_OFF        0x00   /*   OFF */
+
+/* HSTART */
+#define HST_VGA         0x23
+#define HST_QVGA        0x3F
+
+/* HSIZE */
+#define HSZ_VGA         0xA0
+#define HSZ_QVGA        0x50
+
+/* VSTART */
+#define VST_VGA         0x07
+#define VST_QVGA        0x03
+
+/* VSIZE */
+#define VSZ_VGA         0xF0
+#define VSZ_QVGA        0x78
+
+/* HOUTSIZE */
+#define HOSZ_VGA        0xA0
+#define HOSZ_QVGA       0x50
+
+/* VOUTSIZE */
+#define VOSZ_VGA        0xF0
+#define VOSZ_QVGA       0x78
+
+/* DSPAUTO (DSP Auto Function ON/OFF Control) */
+#define AWB_ACTRL       0x80 /* AWB auto threshold control */
+#define DENOISE_ACTRL   0x40 /* De-noise auto threshold control */
+#define EDGE_ACTRL      0x20 /* Edge enhancement auto strength control */
+#define UV_ACTRL        0x10 /* UV adjust auto slope control */
+#define SCAL0_ACTRL     0x08 /* Auto scaling factor control */
+#define SCAL1_2_ACTRL   0x04 /* Auto scaling factor control */
+
+/*
+ * ID
+ */
+#define OV7720  0x7720
+#define OV7725  0x7721
+#define VERSION(pid, ver) ((pid<<8)|(ver&0xFF))
+
+/*
+ * struct
+ */
+struct regval_list {
+       unsigned char reg_num;
+       unsigned char value;
+};
+
+struct ov772x_color_format {
+       enum v4l2_mbus_pixelcode code;
+       enum v4l2_colorspace colorspace;
+       u8 dsp3;
+       u8 com3;
+       u8 com7;
+};
+
+struct ov772x_win_size {
+       char                     *name;
+       __u32                     width;
+       __u32                     height;
+       unsigned char             com7_bit;
+       const struct regval_list *regs;
+};
+
+struct ov772x_priv {
+       struct v4l2_subdev                subdev;
+       struct v4l2_ctrl_handler          hdl;
+       struct ov772x_camera_info        *info;
+       const struct ov772x_color_format *cfmt;
+       const struct ov772x_win_size     *win;
+       int                               model;
+       unsigned short                    flag_vflip:1;
+       unsigned short                    flag_hflip:1;
+       /* band_filter = COM8[5] ? 256 - BDBASE : 0 */
+       unsigned short                    band_filter;
+};
+
+#define ENDMARKER { 0xff, 0xff }
+
+/*
+ * register setting for window size
+ */
+static const struct regval_list ov772x_qvga_regs[] = {
+       { HSTART,   HST_QVGA },
+       { HSIZE,    HSZ_QVGA },
+       { VSTART,   VST_QVGA },
+       { VSIZE,    VSZ_QVGA  },
+       { HOUTSIZE, HOSZ_QVGA },
+       { VOUTSIZE, VOSZ_QVGA },
+       ENDMARKER,
+};
+
+static const struct regval_list ov772x_vga_regs[] = {
+       { HSTART,   HST_VGA },
+       { HSIZE,    HSZ_VGA },
+       { VSTART,   VST_VGA },
+       { VSIZE,    VSZ_VGA },
+       { HOUTSIZE, HOSZ_VGA },
+       { VOUTSIZE, VOSZ_VGA },
+       ENDMARKER,
+};
+
+/*
+ * supported color format list
+ */
+static const struct ov772x_color_format ov772x_cfmts[] = {
+       {
+               .code           = V4L2_MBUS_FMT_YUYV8_2X8,
+               .colorspace     = V4L2_COLORSPACE_JPEG,
+               .dsp3           = 0x0,
+               .com3           = SWAP_YUV,
+               .com7           = OFMT_YUV,
+       },
+       {
+               .code           = V4L2_MBUS_FMT_YVYU8_2X8,
+               .colorspace     = V4L2_COLORSPACE_JPEG,
+               .dsp3           = UV_ON,
+               .com3           = SWAP_YUV,
+               .com7           = OFMT_YUV,
+       },
+       {
+               .code           = V4L2_MBUS_FMT_UYVY8_2X8,
+               .colorspace     = V4L2_COLORSPACE_JPEG,
+               .dsp3           = 0x0,
+               .com3           = 0x0,
+               .com7           = OFMT_YUV,
+       },
+       {
+               .code           = V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE,
+               .colorspace     = V4L2_COLORSPACE_SRGB,
+               .dsp3           = 0x0,
+               .com3           = SWAP_RGB,
+               .com7           = FMT_RGB555 | OFMT_RGB,
+       },
+       {
+               .code           = V4L2_MBUS_FMT_RGB555_2X8_PADHI_BE,
+               .colorspace     = V4L2_COLORSPACE_SRGB,
+               .dsp3           = 0x0,
+               .com3           = 0x0,
+               .com7           = FMT_RGB555 | OFMT_RGB,
+       },
+       {
+               .code           = V4L2_MBUS_FMT_RGB565_2X8_LE,
+               .colorspace     = V4L2_COLORSPACE_SRGB,
+               .dsp3           = 0x0,
+               .com3           = SWAP_RGB,
+               .com7           = FMT_RGB565 | OFMT_RGB,
+       },
+       {
+               .code           = V4L2_MBUS_FMT_RGB565_2X8_BE,
+               .colorspace     = V4L2_COLORSPACE_SRGB,
+               .dsp3           = 0x0,
+               .com3           = 0x0,
+               .com7           = FMT_RGB565 | OFMT_RGB,
+       },
+};
+
+
+/*
+ * window size list
+ */
+#define VGA_WIDTH   640
+#define VGA_HEIGHT  480
+#define QVGA_WIDTH  320
+#define QVGA_HEIGHT 240
+#define MAX_WIDTH   VGA_WIDTH
+#define MAX_HEIGHT  VGA_HEIGHT
+
+static const struct ov772x_win_size ov772x_win_vga = {
+       .name     = "VGA",
+       .width    = VGA_WIDTH,
+       .height   = VGA_HEIGHT,
+       .com7_bit = SLCT_VGA,
+       .regs     = ov772x_vga_regs,
+};
+
+static const struct ov772x_win_size ov772x_win_qvga = {
+       .name     = "QVGA",
+       .width    = QVGA_WIDTH,
+       .height   = QVGA_HEIGHT,
+       .com7_bit = SLCT_QVGA,
+       .regs     = ov772x_qvga_regs,
+};
+
+/*
+ * general function
+ */
+
+static struct ov772x_priv *to_ov772x(const struct i2c_client *client)
+{
+       return container_of(i2c_get_clientdata(client), struct ov772x_priv,
+                           subdev);
+}
+
+static int ov772x_write_array(struct i2c_client        *client,
+                             const struct regval_list *vals)
+{
+       while (vals->reg_num != 0xff) {
+               int ret = i2c_smbus_write_byte_data(client,
+                                                   vals->reg_num,
+                                                   vals->value);
+               if (ret < 0)
+                       return ret;
+               vals++;
+       }
+       return 0;
+}
+
+static int ov772x_mask_set(struct i2c_client *client,
+                                         u8  command,
+                                         u8  mask,
+                                         u8  set)
+{
+       s32 val = i2c_smbus_read_byte_data(client, command);
+       if (val < 0)
+               return val;
+
+       val &= ~mask;
+       val |= set & mask;
+
+       return i2c_smbus_write_byte_data(client, command, val);
+}
+
+static int ov772x_reset(struct i2c_client *client)
+{
+       int ret = i2c_smbus_write_byte_data(client, COM7, SCCB_RESET);
+       msleep(1);
+       return ret;
+}
+
+/*
+ * soc_camera_ops function
+ */
+
+static int ov772x_s_stream(struct v4l2_subdev *sd, int enable)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct ov772x_priv *priv = container_of(sd, struct ov772x_priv, subdev);
+
+       if (!enable) {
+               ov772x_mask_set(client, COM2, SOFT_SLEEP_MODE, SOFT_SLEEP_MODE);
+               return 0;
+       }
+
+       if (!priv->win || !priv->cfmt) {
+               dev_err(&client->dev, "norm or win select error\n");
+               return -EPERM;
+       }
+
+       ov772x_mask_set(client, COM2, SOFT_SLEEP_MODE, 0);
+
+       dev_dbg(&client->dev, "format %d, win %s\n",
+               priv->cfmt->code, priv->win->name);
+
+       return 0;
+}
+
+static int ov772x_s_ctrl(struct v4l2_ctrl *ctrl)
+{
+       struct ov772x_priv *priv = container_of(ctrl->handler,
+                                               struct ov772x_priv, hdl);
+       struct v4l2_subdev *sd = &priv->subdev;
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       int ret = 0;
+       u8 val;
+
+       switch (ctrl->id) {
+       case V4L2_CID_VFLIP:
+               val = ctrl->val ? VFLIP_IMG : 0x00;
+               priv->flag_vflip = ctrl->val;
+               if (priv->info->flags & OV772X_FLAG_VFLIP)
+                       val ^= VFLIP_IMG;
+               return ov772x_mask_set(client, COM3, VFLIP_IMG, val);
+       case V4L2_CID_HFLIP:
+               val = ctrl->val ? HFLIP_IMG : 0x00;
+               priv->flag_hflip = ctrl->val;
+               if (priv->info->flags & OV772X_FLAG_HFLIP)
+                       val ^= HFLIP_IMG;
+               return ov772x_mask_set(client, COM3, HFLIP_IMG, val);
+       case V4L2_CID_BAND_STOP_FILTER:
+               if (!ctrl->val) {
+                       /* Switch the filter off, it is on now */
+                       ret = ov772x_mask_set(client, BDBASE, 0xff, 0xff);
+                       if (!ret)
+                               ret = ov772x_mask_set(client, COM8,
+                                                     BNDF_ON_OFF, 0);
+               } else {
+                       /* Switch the filter on, set AEC low limit */
+                       val = 256 - ctrl->val;
+                       ret = ov772x_mask_set(client, COM8,
+                                             BNDF_ON_OFF, BNDF_ON_OFF);
+                       if (!ret)
+                               ret = ov772x_mask_set(client, BDBASE,
+                                                     0xff, val);
+               }
+               if (!ret)
+                       priv->band_filter = ctrl->val;
+               return ret;
+       }
+
+       return -EINVAL;
+}
+
+static int ov772x_g_chip_ident(struct v4l2_subdev *sd,
+                              struct v4l2_dbg_chip_ident *id)
+{
+       struct ov772x_priv *priv = container_of(sd, struct ov772x_priv, subdev);
+
+       id->ident    = priv->model;
+       id->revision = 0;
+
+       return 0;
+}
+
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+static int ov772x_g_register(struct v4l2_subdev *sd,
+                            struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       int ret;
+
+       reg->size = 1;
+       if (reg->reg > 0xff)
+               return -EINVAL;
+
+       ret = i2c_smbus_read_byte_data(client, reg->reg);
+       if (ret < 0)
+               return ret;
+
+       reg->val = (__u64)ret;
+
+       return 0;
+}
+
+static int ov772x_s_register(struct v4l2_subdev *sd,
+                            struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+       if (reg->reg > 0xff ||
+           reg->val > 0xff)
+               return -EINVAL;
+
+       return i2c_smbus_write_byte_data(client, reg->reg, reg->val);
+}
+#endif
+
+static const struct ov772x_win_size *ov772x_select_win(u32 width, u32 height)
+{
+       __u32 diff;
+       const struct ov772x_win_size *win;
+
+       /* default is QVGA */
+       diff = abs(width - ov772x_win_qvga.width) +
+               abs(height - ov772x_win_qvga.height);
+       win = &ov772x_win_qvga;
+
+       /* VGA */
+       if (diff >
+           abs(width  - ov772x_win_vga.width) +
+           abs(height - ov772x_win_vga.height))
+               win = &ov772x_win_vga;
+
+       return win;
+}
+
+static int ov772x_set_params(struct i2c_client *client, u32 *width, u32 *height,
+                            enum v4l2_mbus_pixelcode code)
+{
+       struct ov772x_priv *priv = to_ov772x(client);
+       int ret = -EINVAL;
+       u8  val;
+       int i;
+
+       /*
+        * select format
+        */
+       priv->cfmt = NULL;
+       for (i = 0; i < ARRAY_SIZE(ov772x_cfmts); i++) {
+               if (code == ov772x_cfmts[i].code) {
+                       priv->cfmt = ov772x_cfmts + i;
+                       break;
+               }
+       }
+       if (!priv->cfmt)
+               goto ov772x_set_fmt_error;
+
+       /*
+        * select win
+        */
+       priv->win = ov772x_select_win(*width, *height);
+
+       /*
+        * reset hardware
+        */
+       ov772x_reset(client);
+
+       /*
+        * Edge Ctrl
+        */
+       if (priv->info->edgectrl.strength & OV772X_MANUAL_EDGE_CTRL) {
+
+               /*
+                * Manual Edge Control Mode
+                *
+                * Edge auto strength bit is set by default.
+                * Remove it when manual mode.
+                */
+
+               ret = ov772x_mask_set(client, DSPAUTO, EDGE_ACTRL, 0x00);
+               if (ret < 0)
+                       goto ov772x_set_fmt_error;
+
+               ret = ov772x_mask_set(client,
+                                     EDGE_TRSHLD, OV772X_EDGE_THRESHOLD_MASK,
+                                     priv->info->edgectrl.threshold);
+               if (ret < 0)
+                       goto ov772x_set_fmt_error;
+
+               ret = ov772x_mask_set(client,
+                                     EDGE_STRNGT, OV772X_EDGE_STRENGTH_MASK,
+                                     priv->info->edgectrl.strength);
+               if (ret < 0)
+                       goto ov772x_set_fmt_error;
+
+       } else if (priv->info->edgectrl.upper > priv->info->edgectrl.lower) {
+               /*
+                * Auto Edge Control Mode
+                *
+                * set upper and lower limit
+                */
+               ret = ov772x_mask_set(client,
+                                     EDGE_UPPER, OV772X_EDGE_UPPER_MASK,
+                                     priv->info->edgectrl.upper);
+               if (ret < 0)
+                       goto ov772x_set_fmt_error;
+
+               ret = ov772x_mask_set(client,
+                                     EDGE_LOWER, OV772X_EDGE_LOWER_MASK,
+                                     priv->info->edgectrl.lower);
+               if (ret < 0)
+                       goto ov772x_set_fmt_error;
+       }
+
+       /*
+        * set size format
+        */
+       ret = ov772x_write_array(client, priv->win->regs);
+       if (ret < 0)
+               goto ov772x_set_fmt_error;
+
+       /*
+        * set DSP_CTRL3
+        */
+       val = priv->cfmt->dsp3;
+       if (val) {
+               ret = ov772x_mask_set(client,
+                                     DSP_CTRL3, UV_MASK, val);
+               if (ret < 0)
+                       goto ov772x_set_fmt_error;
+       }
+
+       /*
+        * set COM3
+        */
+       val = priv->cfmt->com3;
+       if (priv->info->flags & OV772X_FLAG_VFLIP)
+               val |= VFLIP_IMG;
+       if (priv->info->flags & OV772X_FLAG_HFLIP)
+               val |= HFLIP_IMG;
+       if (priv->flag_vflip)
+               val ^= VFLIP_IMG;
+       if (priv->flag_hflip)
+               val ^= HFLIP_IMG;
+
+       ret = ov772x_mask_set(client,
+                             COM3, SWAP_MASK | IMG_MASK, val);
+       if (ret < 0)
+               goto ov772x_set_fmt_error;
+
+       /*
+        * set COM7
+        */
+       val = priv->win->com7_bit | priv->cfmt->com7;
+       ret = ov772x_mask_set(client,
+                             COM7, SLCT_MASK | FMT_MASK | OFMT_MASK,
+                             val);
+       if (ret < 0)
+               goto ov772x_set_fmt_error;
+
+       /*
+        * set COM8
+        */
+       if (priv->band_filter) {
+               ret = ov772x_mask_set(client, COM8, BNDF_ON_OFF, 1);
+               if (!ret)
+                       ret = ov772x_mask_set(client, BDBASE,
+                                             0xff, 256 - priv->band_filter);
+               if (ret < 0)
+                       goto ov772x_set_fmt_error;
+       }
+
+       *width = priv->win->width;
+       *height = priv->win->height;
+
+       return ret;
+
+ov772x_set_fmt_error:
+
+       ov772x_reset(client);
+       priv->win = NULL;
+       priv->cfmt = NULL;
+
+       return ret;
+}
+
+static int ov772x_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+       a->c.left       = 0;
+       a->c.top        = 0;
+       a->c.width      = VGA_WIDTH;
+       a->c.height     = VGA_HEIGHT;
+       a->type         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+       return 0;
+}
+
+static int ov772x_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
+{
+       a->bounds.left                  = 0;
+       a->bounds.top                   = 0;
+       a->bounds.width                 = VGA_WIDTH;
+       a->bounds.height                = VGA_HEIGHT;
+       a->defrect                      = a->bounds;
+       a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+       a->pixelaspect.numerator        = 1;
+       a->pixelaspect.denominator      = 1;
+
+       return 0;
+}
+
+static int ov772x_g_fmt(struct v4l2_subdev *sd,
+                       struct v4l2_mbus_framefmt *mf)
+{
+       struct ov772x_priv *priv = container_of(sd, struct ov772x_priv, subdev);
+
+       if (!priv->win || !priv->cfmt) {
+               priv->cfmt = &ov772x_cfmts[0];
+               priv->win = ov772x_select_win(VGA_WIDTH, VGA_HEIGHT);
+       }
+
+       mf->width       = priv->win->width;
+       mf->height      = priv->win->height;
+       mf->code        = priv->cfmt->code;
+       mf->colorspace  = priv->cfmt->colorspace;
+       mf->field       = V4L2_FIELD_NONE;
+
+       return 0;
+}
+
+static int ov772x_s_fmt(struct v4l2_subdev *sd,
+                       struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct ov772x_priv *priv = container_of(sd, struct ov772x_priv, subdev);
+       int ret = ov772x_set_params(client, &mf->width, &mf->height,
+                                   mf->code);
+
+       if (!ret)
+               mf->colorspace = priv->cfmt->colorspace;
+
+       return ret;
+}
+
+static int ov772x_try_fmt(struct v4l2_subdev *sd,
+                         struct v4l2_mbus_framefmt *mf)
+{
+       struct ov772x_priv *priv = container_of(sd, struct ov772x_priv, subdev);
+       const struct ov772x_win_size *win;
+       int i;
+
+       /*
+        * select suitable win
+        */
+       win = ov772x_select_win(mf->width, mf->height);
+
+       mf->width       = win->width;
+       mf->height      = win->height;
+       mf->field       = V4L2_FIELD_NONE;
+
+       for (i = 0; i < ARRAY_SIZE(ov772x_cfmts); i++)
+               if (mf->code == ov772x_cfmts[i].code)
+                       break;
+
+       if (i == ARRAY_SIZE(ov772x_cfmts)) {
+               /* Unsupported format requested. Propose either */
+               if (priv->cfmt) {
+                       /* the current one or */
+                       mf->colorspace = priv->cfmt->colorspace;
+                       mf->code = priv->cfmt->code;
+               } else {
+                       /* the default one */
+                       mf->colorspace = ov772x_cfmts[0].colorspace;
+                       mf->code = ov772x_cfmts[0].code;
+               }
+       } else {
+               /* Also return the colorspace */
+               mf->colorspace  = ov772x_cfmts[i].colorspace;
+       }
+
+       return 0;
+}
+
+static int ov772x_video_probe(struct i2c_client *client)
+{
+       struct ov772x_priv *priv = to_ov772x(client);
+       u8                  pid, ver;
+       const char         *devname;
+
+       /*
+        * check and show product ID and manufacturer ID
+        */
+       pid = i2c_smbus_read_byte_data(client, PID);
+       ver = i2c_smbus_read_byte_data(client, VER);
+
+       switch (VERSION(pid, ver)) {
+       case OV7720:
+               devname     = "ov7720";
+               priv->model = V4L2_IDENT_OV7720;
+               break;
+       case OV7725:
+               devname     = "ov7725";
+               priv->model = V4L2_IDENT_OV7725;
+               break;
+       default:
+               dev_err(&client->dev,
+                       "Product ID error %x:%x\n", pid, ver);
+               return -ENODEV;
+       }
+
+       dev_info(&client->dev,
+                "%s Product ID %0x:%0x Manufacturer ID %x:%x\n",
+                devname,
+                pid,
+                ver,
+                i2c_smbus_read_byte_data(client, MIDH),
+                i2c_smbus_read_byte_data(client, MIDL));
+       return v4l2_ctrl_handler_setup(&priv->hdl);
+}
+
+static const struct v4l2_ctrl_ops ov772x_ctrl_ops = {
+       .s_ctrl = ov772x_s_ctrl,
+};
+
+static struct v4l2_subdev_core_ops ov772x_subdev_core_ops = {
+       .g_chip_ident   = ov772x_g_chip_ident,
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+       .g_register     = ov772x_g_register,
+       .s_register     = ov772x_s_register,
+#endif
+};
+
+static int ov772x_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
+                          enum v4l2_mbus_pixelcode *code)
+{
+       if (index >= ARRAY_SIZE(ov772x_cfmts))
+               return -EINVAL;
+
+       *code = ov772x_cfmts[index].code;
+       return 0;
+}
+
+static int ov772x_g_mbus_config(struct v4l2_subdev *sd,
+                               struct v4l2_mbus_config *cfg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+
+       cfg->flags = V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_MASTER |
+               V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_HSYNC_ACTIVE_HIGH |
+               V4L2_MBUS_DATA_ACTIVE_HIGH;
+       cfg->type = V4L2_MBUS_PARALLEL;
+       cfg->flags = soc_camera_apply_board_flags(icl, cfg);
+
+       return 0;
+}
+
+static struct v4l2_subdev_video_ops ov772x_subdev_video_ops = {
+       .s_stream       = ov772x_s_stream,
+       .g_mbus_fmt     = ov772x_g_fmt,
+       .s_mbus_fmt     = ov772x_s_fmt,
+       .try_mbus_fmt   = ov772x_try_fmt,
+       .cropcap        = ov772x_cropcap,
+       .g_crop         = ov772x_g_crop,
+       .enum_mbus_fmt  = ov772x_enum_fmt,
+       .g_mbus_config  = ov772x_g_mbus_config,
+};
+
+static struct v4l2_subdev_ops ov772x_subdev_ops = {
+       .core   = &ov772x_subdev_core_ops,
+       .video  = &ov772x_subdev_video_ops,
+};
+
+/*
+ * i2c_driver function
+ */
+
+static int ov772x_probe(struct i2c_client *client,
+                       const struct i2c_device_id *did)
+{
+       struct ov772x_priv      *priv;
+       struct soc_camera_link  *icl = soc_camera_i2c_to_link(client);
+       struct i2c_adapter      *adapter = to_i2c_adapter(client->dev.parent);
+       int                     ret;
+
+       if (!icl || !icl->priv) {
+               dev_err(&client->dev, "OV772X: missing platform data!\n");
+               return -EINVAL;
+       }
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
+               dev_err(&adapter->dev,
+                       "I2C-Adapter doesn't support "
+                       "I2C_FUNC_SMBUS_BYTE_DATA\n");
+               return -EIO;
+       }
+
+       priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+       if (!priv)
+               return -ENOMEM;
+
+       priv->info = icl->priv;
+
+       v4l2_i2c_subdev_init(&priv->subdev, client, &ov772x_subdev_ops);
+       v4l2_ctrl_handler_init(&priv->hdl, 3);
+       v4l2_ctrl_new_std(&priv->hdl, &ov772x_ctrl_ops,
+                       V4L2_CID_VFLIP, 0, 1, 1, 0);
+       v4l2_ctrl_new_std(&priv->hdl, &ov772x_ctrl_ops,
+                       V4L2_CID_HFLIP, 0, 1, 1, 0);
+       v4l2_ctrl_new_std(&priv->hdl, &ov772x_ctrl_ops,
+                       V4L2_CID_BAND_STOP_FILTER, 0, 256, 1, 0);
+       priv->subdev.ctrl_handler = &priv->hdl;
+       if (priv->hdl.error) {
+               int err = priv->hdl.error;
+
+               kfree(priv);
+               return err;
+       }
+
+       ret = ov772x_video_probe(client);
+       if (ret) {
+               v4l2_ctrl_handler_free(&priv->hdl);
+               kfree(priv);
+       }
+
+       return ret;
+}
+
+static int ov772x_remove(struct i2c_client *client)
+{
+       struct ov772x_priv *priv = to_ov772x(client);
+
+       v4l2_device_unregister_subdev(&priv->subdev);
+       v4l2_ctrl_handler_free(&priv->hdl);
+       kfree(priv);
+       return 0;
+}
+
+static const struct i2c_device_id ov772x_id[] = {
+       { "ov772x", 0 },
+       { }
+};
+MODULE_DEVICE_TABLE(i2c, ov772x_id);
+
+static struct i2c_driver ov772x_i2c_driver = {
+       .driver = {
+               .name = "ov772x",
+       },
+       .probe    = ov772x_probe,
+       .remove   = ov772x_remove,
+       .id_table = ov772x_id,
+};
+
+module_i2c_driver(ov772x_i2c_driver);
+
+MODULE_DESCRIPTION("SoC Camera driver for ov772x");
+MODULE_AUTHOR("Kuninori Morimoto");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/i2c/soc_camera/ov9640.c b/drivers/media/i2c/soc_camera/ov9640.c
new file mode 100644 (file)
index 0000000..9ed4ba4
--- /dev/null
@@ -0,0 +1,746 @@
+/*
+ * OmniVision OV96xx Camera Driver
+ *
+ * Copyright (C) 2009 Marek Vasut <marek.vasut@gmail.com>
+ *
+ * Based on ov772x camera driver:
+ *
+ * Copyright (C) 2008 Renesas Solutions Corp.
+ * Kuninori Morimoto <morimoto.kuninori@renesas.com>
+ *
+ * Based on ov7670 and soc_camera_platform driver,
+ *
+ * Copyright 2006-7 Jonathan Corbet <corbet@lwn.net>
+ * Copyright (C) 2008 Magnus Damm
+ * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/v4l2-mediabus.h>
+#include <linux/videodev2.h>
+
+#include <media/soc_camera.h>
+#include <media/v4l2-chip-ident.h>
+#include <media/v4l2-common.h>
+#include <media/v4l2-ctrls.h>
+
+#include "ov9640.h"
+
+#define to_ov9640_sensor(sd)   container_of(sd, struct ov9640_priv, subdev)
+
+/* default register setup */
+static const struct ov9640_reg ov9640_regs_dflt[] = {
+       { OV9640_COM5,  OV9640_COM5_SYSCLK | OV9640_COM5_LONGEXP },
+       { OV9640_COM6,  OV9640_COM6_OPT_BLC | OV9640_COM6_ADBLC_BIAS |
+                       OV9640_COM6_FMT_RST | OV9640_COM6_ADBLC_OPTEN },
+       { OV9640_PSHFT, OV9640_PSHFT_VAL(0x01) },
+       { OV9640_ACOM,  OV9640_ACOM_2X_ANALOG | OV9640_ACOM_RSVD },
+       { OV9640_TSLB,  OV9640_TSLB_YUYV_UYVY },
+       { OV9640_COM16, OV9640_COM16_RB_AVG },
+
+       /* Gamma curve P */
+       { 0x6c, 0x40 }, { 0x6d, 0x30 }, { 0x6e, 0x4b }, { 0x6f, 0x60 },
+       { 0x70, 0x70 }, { 0x71, 0x70 }, { 0x72, 0x70 }, { 0x73, 0x70 },
+       { 0x74, 0x60 }, { 0x75, 0x60 }, { 0x76, 0x50 }, { 0x77, 0x48 },
+       { 0x78, 0x3a }, { 0x79, 0x2e }, { 0x7a, 0x28 }, { 0x7b, 0x22 },
+
+       /* Gamma curve T */
+       { 0x7c, 0x04 }, { 0x7d, 0x07 }, { 0x7e, 0x10 }, { 0x7f, 0x28 },
+       { 0x80, 0x36 }, { 0x81, 0x44 }, { 0x82, 0x52 }, { 0x83, 0x60 },
+       { 0x84, 0x6c }, { 0x85, 0x78 }, { 0x86, 0x8c }, { 0x87, 0x9e },
+       { 0x88, 0xbb }, { 0x89, 0xd2 }, { 0x8a, 0xe6 },
+};
+
+/* Configurations
+ * NOTE: for YUV, alter the following registers:
+ *             COM12 |= OV9640_COM12_YUV_AVG
+ *
+ *      for RGB, alter the following registers:
+ *             COM7  |= OV9640_COM7_RGB
+ *             COM13 |= OV9640_COM13_RGB_AVG
+ *             COM15 |= proper RGB color encoding mode
+ */
+static const struct ov9640_reg ov9640_regs_qqcif[] = {
+       { OV9640_CLKRC, OV9640_CLKRC_DPLL_EN | OV9640_CLKRC_DIV(0x0f) },
+       { OV9640_COM1,  OV9640_COM1_QQFMT | OV9640_COM1_HREF_2SKIP },
+       { OV9640_COM4,  OV9640_COM4_QQ_VP | OV9640_COM4_RSVD },
+       { OV9640_COM7,  OV9640_COM7_QCIF },
+       { OV9640_COM12, OV9640_COM12_RSVD },
+       { OV9640_COM13, OV9640_COM13_GAMMA_RAW | OV9640_COM13_MATRIX_EN },
+       { OV9640_COM15, OV9640_COM15_OR_10F0 },
+};
+
+static const struct ov9640_reg ov9640_regs_qqvga[] = {
+       { OV9640_CLKRC, OV9640_CLKRC_DPLL_EN | OV9640_CLKRC_DIV(0x07) },
+       { OV9640_COM1,  OV9640_COM1_QQFMT | OV9640_COM1_HREF_2SKIP },
+       { OV9640_COM4,  OV9640_COM4_QQ_VP | OV9640_COM4_RSVD },
+       { OV9640_COM7,  OV9640_COM7_QVGA },
+       { OV9640_COM12, OV9640_COM12_RSVD },
+       { OV9640_COM13, OV9640_COM13_GAMMA_RAW | OV9640_COM13_MATRIX_EN },
+       { OV9640_COM15, OV9640_COM15_OR_10F0 },
+};
+
+static const struct ov9640_reg ov9640_regs_qcif[] = {
+       { OV9640_CLKRC, OV9640_CLKRC_DPLL_EN | OV9640_CLKRC_DIV(0x07) },
+       { OV9640_COM4,  OV9640_COM4_QQ_VP | OV9640_COM4_RSVD },
+       { OV9640_COM7,  OV9640_COM7_QCIF },
+       { OV9640_COM12, OV9640_COM12_RSVD },
+       { OV9640_COM13, OV9640_COM13_GAMMA_RAW | OV9640_COM13_MATRIX_EN },
+       { OV9640_COM15, OV9640_COM15_OR_10F0 },
+};
+
+static const struct ov9640_reg ov9640_regs_qvga[] = {
+       { OV9640_CLKRC, OV9640_CLKRC_DPLL_EN | OV9640_CLKRC_DIV(0x03) },
+       { OV9640_COM4,  OV9640_COM4_QQ_VP | OV9640_COM4_RSVD },
+       { OV9640_COM7,  OV9640_COM7_QVGA },
+       { OV9640_COM12, OV9640_COM12_RSVD },
+       { OV9640_COM13, OV9640_COM13_GAMMA_RAW | OV9640_COM13_MATRIX_EN },
+       { OV9640_COM15, OV9640_COM15_OR_10F0 },
+};
+
+static const struct ov9640_reg ov9640_regs_cif[] = {
+       { OV9640_CLKRC, OV9640_CLKRC_DPLL_EN | OV9640_CLKRC_DIV(0x03) },
+       { OV9640_COM3,  OV9640_COM3_VP },
+       { OV9640_COM7,  OV9640_COM7_CIF },
+       { OV9640_COM12, OV9640_COM12_RSVD },
+       { OV9640_COM13, OV9640_COM13_GAMMA_RAW | OV9640_COM13_MATRIX_EN },
+       { OV9640_COM15, OV9640_COM15_OR_10F0 },
+};
+
+static const struct ov9640_reg ov9640_regs_vga[] = {
+       { OV9640_CLKRC, OV9640_CLKRC_DPLL_EN | OV9640_CLKRC_DIV(0x01) },
+       { OV9640_COM3,  OV9640_COM3_VP },
+       { OV9640_COM7,  OV9640_COM7_VGA },
+       { OV9640_COM12, OV9640_COM12_RSVD },
+       { OV9640_COM13, OV9640_COM13_GAMMA_RAW | OV9640_COM13_MATRIX_EN },
+       { OV9640_COM15, OV9640_COM15_OR_10F0 },
+};
+
+static const struct ov9640_reg ov9640_regs_sxga[] = {
+       { OV9640_CLKRC, OV9640_CLKRC_DPLL_EN | OV9640_CLKRC_DIV(0x01) },
+       { OV9640_COM3,  OV9640_COM3_VP },
+       { OV9640_COM7,  0 },
+       { OV9640_COM12, OV9640_COM12_RSVD },
+       { OV9640_COM13, OV9640_COM13_GAMMA_RAW | OV9640_COM13_MATRIX_EN },
+       { OV9640_COM15, OV9640_COM15_OR_10F0 },
+};
+
+static const struct ov9640_reg ov9640_regs_yuv[] = {
+       { OV9640_MTX1,  0x58 },
+       { OV9640_MTX2,  0x48 },
+       { OV9640_MTX3,  0x10 },
+       { OV9640_MTX4,  0x28 },
+       { OV9640_MTX5,  0x48 },
+       { OV9640_MTX6,  0x70 },
+       { OV9640_MTX7,  0x40 },
+       { OV9640_MTX8,  0x40 },
+       { OV9640_MTX9,  0x40 },
+       { OV9640_MTXS,  0x0f },
+};
+
+static const struct ov9640_reg ov9640_regs_rgb[] = {
+       { OV9640_MTX1,  0x71 },
+       { OV9640_MTX2,  0x3e },
+       { OV9640_MTX3,  0x0c },
+       { OV9640_MTX4,  0x33 },
+       { OV9640_MTX5,  0x72 },
+       { OV9640_MTX6,  0x00 },
+       { OV9640_MTX7,  0x2b },
+       { OV9640_MTX8,  0x66 },
+       { OV9640_MTX9,  0xd2 },
+       { OV9640_MTXS,  0x65 },
+};
+
+static enum v4l2_mbus_pixelcode ov9640_codes[] = {
+       V4L2_MBUS_FMT_UYVY8_2X8,
+       V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE,
+       V4L2_MBUS_FMT_RGB565_2X8_LE,
+};
+
+/* read a register */
+static int ov9640_reg_read(struct i2c_client *client, u8 reg, u8 *val)
+{
+       int ret;
+       u8 data = reg;
+       struct i2c_msg msg = {
+               .addr   = client->addr,
+               .flags  = 0,
+               .len    = 1,
+               .buf    = &data,
+       };
+
+       ret = i2c_transfer(client->adapter, &msg, 1);
+       if (ret < 0)
+               goto err;
+
+       msg.flags = I2C_M_RD;
+       ret = i2c_transfer(client->adapter, &msg, 1);
+       if (ret < 0)
+               goto err;
+
+       *val = data;
+       return 0;
+
+err:
+       dev_err(&client->dev, "Failed reading register 0x%02x!\n", reg);
+       return ret;
+}
+
+/* write a register */
+static int ov9640_reg_write(struct i2c_client *client, u8 reg, u8 val)
+{
+       int ret;
+       u8 _val;
+       unsigned char data[2] = { reg, val };
+       struct i2c_msg msg = {
+               .addr   = client->addr,
+               .flags  = 0,
+               .len    = 2,
+               .buf    = data,
+       };
+
+       ret = i2c_transfer(client->adapter, &msg, 1);
+       if (ret < 0) {
+               dev_err(&client->dev, "Failed writing register 0x%02x!\n", reg);
+               return ret;
+       }
+
+       /* we have to read the register back ... no idea why, maybe HW bug */
+       ret = ov9640_reg_read(client, reg, &_val);
+       if (ret)
+               dev_err(&client->dev,
+                       "Failed reading back register 0x%02x!\n", reg);
+
+       return 0;
+}
+
+
+/* Read a register, alter its bits, write it back */
+static int ov9640_reg_rmw(struct i2c_client *client, u8 reg, u8 set, u8 unset)
+{
+       u8 val;
+       int ret;
+
+       ret = ov9640_reg_read(client, reg, &val);
+       if (ret) {
+               dev_err(&client->dev,
+                       "[Read]-Modify-Write of register %02x failed!\n", reg);
+               return val;
+       }
+
+       val |= set;
+       val &= ~unset;
+
+       ret = ov9640_reg_write(client, reg, val);
+       if (ret)
+               dev_err(&client->dev,
+                       "Read-Modify-[Write] of register %02x failed!\n", reg);
+
+       return ret;
+}
+
+/* Soft reset the camera. This has nothing to do with the RESET pin! */
+static int ov9640_reset(struct i2c_client *client)
+{
+       int ret;
+
+       ret = ov9640_reg_write(client, OV9640_COM7, OV9640_COM7_SCCB_RESET);
+       if (ret)
+               dev_err(&client->dev,
+                       "An error occurred while entering soft reset!\n");
+
+       return ret;
+}
+
+/* Start/Stop streaming from the device */
+static int ov9640_s_stream(struct v4l2_subdev *sd, int enable)
+{
+       return 0;
+}
+
+/* Set status of additional camera capabilities */
+static int ov9640_s_ctrl(struct v4l2_ctrl *ctrl)
+{
+       struct ov9640_priv *priv = container_of(ctrl->handler, struct ov9640_priv, hdl);
+       struct i2c_client *client = v4l2_get_subdevdata(&priv->subdev);
+
+       switch (ctrl->id) {
+       case V4L2_CID_VFLIP:
+               if (ctrl->val)
+                       return ov9640_reg_rmw(client, OV9640_MVFP,
+                                                       OV9640_MVFP_V, 0);
+               return ov9640_reg_rmw(client, OV9640_MVFP, 0, OV9640_MVFP_V);
+       case V4L2_CID_HFLIP:
+               if (ctrl->val)
+                       return ov9640_reg_rmw(client, OV9640_MVFP,
+                                                       OV9640_MVFP_H, 0);
+               return ov9640_reg_rmw(client, OV9640_MVFP, 0, OV9640_MVFP_H);
+       }
+       return -EINVAL;
+}
+
+/* Get chip identification */
+static int ov9640_g_chip_ident(struct v4l2_subdev *sd,
+                               struct v4l2_dbg_chip_ident *id)
+{
+       struct ov9640_priv *priv = to_ov9640_sensor(sd);
+
+       id->ident       = priv->model;
+       id->revision    = priv->revision;
+
+       return 0;
+}
+
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+static int ov9640_get_register(struct v4l2_subdev *sd,
+                               struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       int ret;
+       u8 val;
+
+       if (reg->reg & ~0xff)
+               return -EINVAL;
+
+       reg->size = 1;
+
+       ret = ov9640_reg_read(client, reg->reg, &val);
+       if (ret)
+               return ret;
+
+       reg->val = (__u64)val;
+
+       return 0;
+}
+
+static int ov9640_set_register(struct v4l2_subdev *sd,
+                               struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+       if (reg->reg & ~0xff || reg->val & ~0xff)
+               return -EINVAL;
+
+       return ov9640_reg_write(client, reg->reg, reg->val);
+}
+#endif
+
+/* select nearest higher resolution for capture */
+static void ov9640_res_roundup(u32 *width, u32 *height)
+{
+       int i;
+       enum { QQCIF, QQVGA, QCIF, QVGA, CIF, VGA, SXGA };
+       int res_x[] = { 88, 160, 176, 320, 352, 640, 1280 };
+       int res_y[] = { 72, 120, 144, 240, 288, 480, 960 };
+
+       for (i = 0; i < ARRAY_SIZE(res_x); i++) {
+               if (res_x[i] >= *width && res_y[i] >= *height) {
+                       *width = res_x[i];
+                       *height = res_y[i];
+                       return;
+               }
+       }
+
+       *width = res_x[SXGA];
+       *height = res_y[SXGA];
+}
+
+/* Prepare necessary register changes depending on color encoding */
+static void ov9640_alter_regs(enum v4l2_mbus_pixelcode code,
+                             struct ov9640_reg_alt *alt)
+{
+       switch (code) {
+       default:
+       case V4L2_MBUS_FMT_UYVY8_2X8:
+               alt->com12      = OV9640_COM12_YUV_AVG;
+               alt->com13      = OV9640_COM13_Y_DELAY_EN |
+                                       OV9640_COM13_YUV_DLY(0x01);
+               break;
+       case V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE:
+               alt->com7       = OV9640_COM7_RGB;
+               alt->com13      = OV9640_COM13_RGB_AVG;
+               alt->com15      = OV9640_COM15_RGB_555;
+               break;
+       case V4L2_MBUS_FMT_RGB565_2X8_LE:
+               alt->com7       = OV9640_COM7_RGB;
+               alt->com13      = OV9640_COM13_RGB_AVG;
+               alt->com15      = OV9640_COM15_RGB_565;
+               break;
+       };
+}
+
+/* Setup registers according to resolution and color encoding */
+static int ov9640_write_regs(struct i2c_client *client, u32 width,
+               enum v4l2_mbus_pixelcode code, struct ov9640_reg_alt *alts)
+{
+       const struct ov9640_reg *ov9640_regs, *matrix_regs;
+       int                     ov9640_regs_len, matrix_regs_len;
+       int                     i, ret;
+       u8                      val;
+
+       /* select register configuration for given resolution */
+       switch (width) {
+       case W_QQCIF:
+               ov9640_regs     = ov9640_regs_qqcif;
+               ov9640_regs_len = ARRAY_SIZE(ov9640_regs_qqcif);
+               break;
+       case W_QQVGA:
+               ov9640_regs     = ov9640_regs_qqvga;
+               ov9640_regs_len = ARRAY_SIZE(ov9640_regs_qqvga);
+               break;
+       case W_QCIF:
+               ov9640_regs     = ov9640_regs_qcif;
+               ov9640_regs_len = ARRAY_SIZE(ov9640_regs_qcif);
+               break;
+       case W_QVGA:
+               ov9640_regs     = ov9640_regs_qvga;
+               ov9640_regs_len = ARRAY_SIZE(ov9640_regs_qvga);
+               break;
+       case W_CIF:
+               ov9640_regs     = ov9640_regs_cif;
+               ov9640_regs_len = ARRAY_SIZE(ov9640_regs_cif);
+               break;
+       case W_VGA:
+               ov9640_regs     = ov9640_regs_vga;
+               ov9640_regs_len = ARRAY_SIZE(ov9640_regs_vga);
+               break;
+       case W_SXGA:
+               ov9640_regs     = ov9640_regs_sxga;
+               ov9640_regs_len = ARRAY_SIZE(ov9640_regs_sxga);
+               break;
+       default:
+               dev_err(&client->dev, "Failed to select resolution!\n");
+               return -EINVAL;
+       }
+
+       /* select color matrix configuration for given color encoding */
+       if (code == V4L2_MBUS_FMT_UYVY8_2X8) {
+               matrix_regs     = ov9640_regs_yuv;
+               matrix_regs_len = ARRAY_SIZE(ov9640_regs_yuv);
+       } else {
+               matrix_regs     = ov9640_regs_rgb;
+               matrix_regs_len = ARRAY_SIZE(ov9640_regs_rgb);
+       }
+
+       /* write register settings into the module */
+       for (i = 0; i < ov9640_regs_len; i++) {
+               val = ov9640_regs[i].val;
+
+               switch (ov9640_regs[i].reg) {
+               case OV9640_COM7:
+                       val |= alts->com7;
+                       break;
+               case OV9640_COM12:
+                       val |= alts->com12;
+                       break;
+               case OV9640_COM13:
+                       val |= alts->com13;
+                       break;
+               case OV9640_COM15:
+                       val |= alts->com15;
+                       break;
+               }
+
+               ret = ov9640_reg_write(client, ov9640_regs[i].reg, val);
+               if (ret)
+                       return ret;
+       }
+
+       /* write color matrix configuration into the module */
+       for (i = 0; i < matrix_regs_len; i++) {
+               ret = ov9640_reg_write(client, matrix_regs[i].reg,
+                                               matrix_regs[i].val);
+               if (ret)
+                       return ret;
+       }
+
+       return 0;
+}
+
+/* program default register values */
+static int ov9640_prog_dflt(struct i2c_client *client)
+{
+       int i, ret;
+
+       for (i = 0; i < ARRAY_SIZE(ov9640_regs_dflt); i++) {
+               ret = ov9640_reg_write(client, ov9640_regs_dflt[i].reg,
+                                               ov9640_regs_dflt[i].val);
+               if (ret)
+                       return ret;
+       }
+
+       /* wait for the changes to actually happen, 140ms are not enough yet */
+       mdelay(150);
+
+       return 0;
+}
+
+/* set the format we will capture in */
+static int ov9640_s_fmt(struct v4l2_subdev *sd,
+                       struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct ov9640_reg_alt alts = {0};
+       enum v4l2_colorspace cspace;
+       enum v4l2_mbus_pixelcode code = mf->code;
+       int ret;
+
+       ov9640_res_roundup(&mf->width, &mf->height);
+       ov9640_alter_regs(mf->code, &alts);
+
+       ov9640_reset(client);
+
+       ret = ov9640_prog_dflt(client);
+       if (ret)
+               return ret;
+
+       switch (code) {
+       case V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE:
+       case V4L2_MBUS_FMT_RGB565_2X8_LE:
+               cspace = V4L2_COLORSPACE_SRGB;
+               break;
+       default:
+               code = V4L2_MBUS_FMT_UYVY8_2X8;
+       case V4L2_MBUS_FMT_UYVY8_2X8:
+               cspace = V4L2_COLORSPACE_JPEG;
+       }
+
+       ret = ov9640_write_regs(client, mf->width, code, &alts);
+       if (!ret) {
+               mf->code        = code;
+               mf->colorspace  = cspace;
+       }
+
+       return ret;
+}
+
+static int ov9640_try_fmt(struct v4l2_subdev *sd,
+                         struct v4l2_mbus_framefmt *mf)
+{
+       ov9640_res_roundup(&mf->width, &mf->height);
+
+       mf->field = V4L2_FIELD_NONE;
+
+       switch (mf->code) {
+       case V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE:
+       case V4L2_MBUS_FMT_RGB565_2X8_LE:
+               mf->colorspace = V4L2_COLORSPACE_SRGB;
+               break;
+       default:
+               mf->code = V4L2_MBUS_FMT_UYVY8_2X8;
+       case V4L2_MBUS_FMT_UYVY8_2X8:
+               mf->colorspace = V4L2_COLORSPACE_JPEG;
+       }
+
+       return 0;
+}
+
+static int ov9640_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
+                          enum v4l2_mbus_pixelcode *code)
+{
+       if (index >= ARRAY_SIZE(ov9640_codes))
+               return -EINVAL;
+
+       *code = ov9640_codes[index];
+       return 0;
+}
+
+static int ov9640_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+       a->c.left       = 0;
+       a->c.top        = 0;
+       a->c.width      = W_SXGA;
+       a->c.height     = H_SXGA;
+       a->type         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+       return 0;
+}
+
+static int ov9640_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
+{
+       a->bounds.left                  = 0;
+       a->bounds.top                   = 0;
+       a->bounds.width                 = W_SXGA;
+       a->bounds.height                = H_SXGA;
+       a->defrect                      = a->bounds;
+       a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+       a->pixelaspect.numerator        = 1;
+       a->pixelaspect.denominator      = 1;
+
+       return 0;
+}
+
+static int ov9640_video_probe(struct i2c_client *client)
+{
+       struct v4l2_subdev *sd = i2c_get_clientdata(client);
+       struct ov9640_priv *priv = to_ov9640_sensor(sd);
+       u8              pid, ver, midh, midl;
+       const char      *devname;
+       int             ret = 0;
+
+       /*
+        * check and show product ID and manufacturer ID
+        */
+
+       ret = ov9640_reg_read(client, OV9640_PID, &pid);
+       if (!ret)
+               ret = ov9640_reg_read(client, OV9640_VER, &ver);
+       if (!ret)
+               ret = ov9640_reg_read(client, OV9640_MIDH, &midh);
+       if (!ret)
+               ret = ov9640_reg_read(client, OV9640_MIDL, &midl);
+       if (ret)
+               return ret;
+
+       switch (VERSION(pid, ver)) {
+       case OV9640_V2:
+               devname         = "ov9640";
+               priv->model     = V4L2_IDENT_OV9640;
+               priv->revision  = 2;
+               break;
+       case OV9640_V3:
+               devname         = "ov9640";
+               priv->model     = V4L2_IDENT_OV9640;
+               priv->revision  = 3;
+               break;
+       default:
+               dev_err(&client->dev, "Product ID error %x:%x\n", pid, ver);
+               return -ENODEV;
+       }
+
+       dev_info(&client->dev, "%s Product ID %0x:%0x Manufacturer ID %x:%x\n",
+                devname, pid, ver, midh, midl);
+
+       return v4l2_ctrl_handler_setup(&priv->hdl);
+}
+
+static const struct v4l2_ctrl_ops ov9640_ctrl_ops = {
+       .s_ctrl = ov9640_s_ctrl,
+};
+
+static struct v4l2_subdev_core_ops ov9640_core_ops = {
+       .g_chip_ident           = ov9640_g_chip_ident,
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+       .g_register             = ov9640_get_register,
+       .s_register             = ov9640_set_register,
+#endif
+
+};
+
+/* Request bus settings on camera side */
+static int ov9640_g_mbus_config(struct v4l2_subdev *sd,
+                               struct v4l2_mbus_config *cfg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+
+       cfg->flags = V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_MASTER |
+               V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_HSYNC_ACTIVE_HIGH |
+               V4L2_MBUS_DATA_ACTIVE_HIGH;
+       cfg->type = V4L2_MBUS_PARALLEL;
+       cfg->flags = soc_camera_apply_board_flags(icl, cfg);
+
+       return 0;
+}
+
+static struct v4l2_subdev_video_ops ov9640_video_ops = {
+       .s_stream       = ov9640_s_stream,
+       .s_mbus_fmt     = ov9640_s_fmt,
+       .try_mbus_fmt   = ov9640_try_fmt,
+       .enum_mbus_fmt  = ov9640_enum_fmt,
+       .cropcap        = ov9640_cropcap,
+       .g_crop         = ov9640_g_crop,
+       .g_mbus_config  = ov9640_g_mbus_config,
+};
+
+static struct v4l2_subdev_ops ov9640_subdev_ops = {
+       .core   = &ov9640_core_ops,
+       .video  = &ov9640_video_ops,
+};
+
+/*
+ * i2c_driver function
+ */
+static int ov9640_probe(struct i2c_client *client,
+                       const struct i2c_device_id *did)
+{
+       struct ov9640_priv *priv;
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+       int ret;
+
+       if (!icl) {
+               dev_err(&client->dev, "Missing platform_data for driver\n");
+               return -EINVAL;
+       }
+
+       priv = kzalloc(sizeof(struct ov9640_priv), GFP_KERNEL);
+       if (!priv) {
+               dev_err(&client->dev,
+                       "Failed to allocate memory for private data!\n");
+               return -ENOMEM;
+       }
+
+       v4l2_i2c_subdev_init(&priv->subdev, client, &ov9640_subdev_ops);
+
+       v4l2_ctrl_handler_init(&priv->hdl, 2);
+       v4l2_ctrl_new_std(&priv->hdl, &ov9640_ctrl_ops,
+                       V4L2_CID_VFLIP, 0, 1, 1, 0);
+       v4l2_ctrl_new_std(&priv->hdl, &ov9640_ctrl_ops,
+                       V4L2_CID_HFLIP, 0, 1, 1, 0);
+       priv->subdev.ctrl_handler = &priv->hdl;
+       if (priv->hdl.error) {
+               int err = priv->hdl.error;
+
+               kfree(priv);
+               return err;
+       }
+
+       ret = ov9640_video_probe(client);
+
+       if (ret) {
+               v4l2_ctrl_handler_free(&priv->hdl);
+               kfree(priv);
+       }
+
+       return ret;
+}
+
+static int ov9640_remove(struct i2c_client *client)
+{
+       struct v4l2_subdev *sd = i2c_get_clientdata(client);
+       struct ov9640_priv *priv = to_ov9640_sensor(sd);
+
+       v4l2_device_unregister_subdev(&priv->subdev);
+       v4l2_ctrl_handler_free(&priv->hdl);
+       kfree(priv);
+       return 0;
+}
+
+static const struct i2c_device_id ov9640_id[] = {
+       { "ov9640", 0 },
+       { }
+};
+MODULE_DEVICE_TABLE(i2c, ov9640_id);
+
+static struct i2c_driver ov9640_i2c_driver = {
+       .driver = {
+               .name = "ov9640",
+       },
+       .probe    = ov9640_probe,
+       .remove   = ov9640_remove,
+       .id_table = ov9640_id,
+};
+
+module_i2c_driver(ov9640_i2c_driver);
+
+MODULE_DESCRIPTION("SoC Camera driver for OmniVision OV96xx");
+MODULE_AUTHOR("Marek Vasut <marek.vasut@gmail.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/i2c/soc_camera/ov9640.h b/drivers/media/i2c/soc_camera/ov9640.h
new file mode 100644 (file)
index 0000000..6b33a97
--- /dev/null
@@ -0,0 +1,207 @@
+/*
+ * OmniVision OV96xx Camera Header File
+ *
+ * Copyright (C) 2009 Marek Vasut <marek.vasut@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef        __DRIVERS_MEDIA_VIDEO_OV9640_H__
+#define        __DRIVERS_MEDIA_VIDEO_OV9640_H__
+
+/* Register definitions */
+#define        OV9640_GAIN     0x00
+#define        OV9640_BLUE     0x01
+#define        OV9640_RED      0x02
+#define        OV9640_VFER     0x03
+#define        OV9640_COM1     0x04
+#define        OV9640_BAVE     0x05
+#define        OV9640_GEAVE    0x06
+#define        OV9640_RSID     0x07
+#define        OV9640_RAVE     0x08
+#define        OV9640_COM2     0x09
+#define        OV9640_PID      0x0a
+#define        OV9640_VER      0x0b
+#define        OV9640_COM3     0x0c
+#define        OV9640_COM4     0x0d
+#define        OV9640_COM5     0x0e
+#define        OV9640_COM6     0x0f
+#define        OV9640_AECH     0x10
+#define        OV9640_CLKRC    0x11
+#define        OV9640_COM7     0x12
+#define        OV9640_COM8     0x13
+#define        OV9640_COM9     0x14
+#define        OV9640_COM10    0x15
+/* 0x16 - RESERVED */
+#define        OV9640_HSTART   0x17
+#define        OV9640_HSTOP    0x18
+#define        OV9640_VSTART   0x19
+#define        OV9640_VSTOP    0x1a
+#define        OV9640_PSHFT    0x1b
+#define        OV9640_MIDH     0x1c
+#define        OV9640_MIDL     0x1d
+#define        OV9640_MVFP     0x1e
+#define        OV9640_LAEC     0x1f
+#define        OV9640_BOS      0x20
+#define        OV9640_GBOS     0x21
+#define        OV9640_GROS     0x22
+#define        OV9640_ROS      0x23
+#define        OV9640_AEW      0x24
+#define        OV9640_AEB      0x25
+#define        OV9640_VPT      0x26
+#define        OV9640_BBIAS    0x27
+#define        OV9640_GBBIAS   0x28
+/* 0x29 - RESERVED */
+#define        OV9640_EXHCH    0x2a
+#define        OV9640_EXHCL    0x2b
+#define        OV9640_RBIAS    0x2c
+#define        OV9640_ADVFL    0x2d
+#define        OV9640_ADVFH    0x2e
+#define        OV9640_YAVE     0x2f
+#define        OV9640_HSYST    0x30
+#define        OV9640_HSYEN    0x31
+#define        OV9640_HREF     0x32
+#define        OV9640_CHLF     0x33
+#define        OV9640_ARBLM    0x34
+/* 0x35..0x36 - RESERVED */
+#define        OV9640_ADC      0x37
+#define        OV9640_ACOM     0x38
+#define        OV9640_OFON     0x39
+#define        OV9640_TSLB     0x3a
+#define        OV9640_COM11    0x3b
+#define        OV9640_COM12    0x3c
+#define        OV9640_COM13    0x3d
+#define        OV9640_COM14    0x3e
+#define        OV9640_EDGE     0x3f
+#define        OV9640_COM15    0x40
+#define        OV9640_COM16    0x41
+#define        OV9640_COM17    0x42
+/* 0x43..0x4e - RESERVED */
+#define        OV9640_MTX1     0x4f
+#define        OV9640_MTX2     0x50
+#define        OV9640_MTX3     0x51
+#define        OV9640_MTX4     0x52
+#define        OV9640_MTX5     0x53
+#define        OV9640_MTX6     0x54
+#define        OV9640_MTX7     0x55
+#define        OV9640_MTX8     0x56
+#define        OV9640_MTX9     0x57
+#define        OV9640_MTXS     0x58
+/* 0x59..0x61 - RESERVED */
+#define        OV9640_LCC1     0x62
+#define        OV9640_LCC2     0x63
+#define        OV9640_LCC3     0x64
+#define        OV9640_LCC4     0x65
+#define        OV9640_LCC5     0x66
+#define        OV9640_MANU     0x67
+#define        OV9640_MANV     0x68
+#define        OV9640_HV       0x69
+#define        OV9640_MBD      0x6a
+#define        OV9640_DBLV     0x6b
+#define        OV9640_GSP      0x6c    /* ... till 0x7b */
+#define        OV9640_GST      0x7c    /* ... till 0x8a */
+
+#define        OV9640_CLKRC_DPLL_EN    0x80
+#define        OV9640_CLKRC_DIRECT     0x40
+#define        OV9640_CLKRC_DIV(x)     ((x) & 0x3f)
+
+#define        OV9640_PSHFT_VAL(x)     ((x) & 0xff)
+
+#define        OV9640_ACOM_2X_ANALOG   0x80
+#define        OV9640_ACOM_RSVD        0x12
+
+#define        OV9640_MVFP_V           0x10
+#define        OV9640_MVFP_H           0x20
+
+#define        OV9640_COM1_HREF_NOSKIP 0x00
+#define        OV9640_COM1_HREF_2SKIP  0x04
+#define        OV9640_COM1_HREF_3SKIP  0x08
+#define        OV9640_COM1_QQFMT       0x20
+
+#define        OV9640_COM2_SSM         0x10
+
+#define        OV9640_COM3_VP          0x04
+
+#define        OV9640_COM4_QQ_VP       0x80
+#define        OV9640_COM4_RSVD        0x40
+
+#define        OV9640_COM5_SYSCLK      0x80
+#define        OV9640_COM5_LONGEXP     0x01
+
+#define        OV9640_COM6_OPT_BLC     0x40
+#define        OV9640_COM6_ADBLC_BIAS  0x08
+#define        OV9640_COM6_FMT_RST     0x82
+#define        OV9640_COM6_ADBLC_OPTEN 0x01
+
+#define        OV9640_COM7_RAW_RGB     0x01
+#define        OV9640_COM7_RGB         0x04
+#define        OV9640_COM7_QCIF        0x08
+#define        OV9640_COM7_QVGA        0x10
+#define        OV9640_COM7_CIF         0x20
+#define        OV9640_COM7_VGA         0x40
+#define        OV9640_COM7_SCCB_RESET  0x80
+
+#define        OV9640_TSLB_YVYU_YUYV   0x04
+#define        OV9640_TSLB_YUYV_UYVY   0x08
+
+#define        OV9640_COM12_YUV_AVG    0x04
+#define        OV9640_COM12_RSVD       0x40
+
+#define        OV9640_COM13_GAMMA_NONE 0x00
+#define        OV9640_COM13_GAMMA_Y    0x40
+#define        OV9640_COM13_GAMMA_RAW  0x80
+#define        OV9640_COM13_RGB_AVG    0x20
+#define        OV9640_COM13_MATRIX_EN  0x10
+#define        OV9640_COM13_Y_DELAY_EN 0x08
+#define        OV9640_COM13_YUV_DLY(x) ((x) & 0x07)
+
+#define        OV9640_COM15_OR_00FF    0x00
+#define        OV9640_COM15_OR_01FE    0x40
+#define        OV9640_COM15_OR_10F0    0xc0
+#define        OV9640_COM15_RGB_NORM   0x00
+#define        OV9640_COM15_RGB_565    0x10
+#define        OV9640_COM15_RGB_555    0x30
+
+#define        OV9640_COM16_RB_AVG     0x01
+
+/* IDs */
+#define        OV9640_V2               0x9648
+#define        OV9640_V3               0x9649
+#define        VERSION(pid, ver)       (((pid) << 8) | ((ver) & 0xFF))
+
+/* supported resolutions */
+enum {
+       W_QQCIF = 88,
+       W_QQVGA = 160,
+       W_QCIF  = 176,
+       W_QVGA  = 320,
+       W_CIF   = 352,
+       W_VGA   = 640,
+       W_SXGA  = 1280
+};
+#define        H_SXGA  960
+
+/* Misc. structures */
+struct ov9640_reg_alt {
+       u8      com7;
+       u8      com12;
+       u8      com13;
+       u8      com15;
+};
+
+struct ov9640_reg {
+       u8      reg;
+       u8      val;
+};
+
+struct ov9640_priv {
+       struct v4l2_subdev              subdev;
+       struct v4l2_ctrl_handler        hdl;
+
+       int                             model;
+       int                             revision;
+};
+
+#endif /* __DRIVERS_MEDIA_VIDEO_OV9640_H__ */
diff --git a/drivers/media/i2c/soc_camera/ov9740.c b/drivers/media/i2c/soc_camera/ov9740.c
new file mode 100644 (file)
index 0000000..3eb07c2
--- /dev/null
@@ -0,0 +1,1005 @@
+/*
+ * OmniVision OV9740 Camera Driver
+ *
+ * Copyright (C) 2011 NVIDIA Corporation
+ *
+ * Based on ov9640 camera driver.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/slab.h>
+#include <linux/v4l2-mediabus.h>
+
+#include <media/soc_camera.h>
+#include <media/v4l2-chip-ident.h>
+#include <media/v4l2-ctrls.h>
+
+#define to_ov9740(sd)          container_of(sd, struct ov9740_priv, subdev)
+
+/* General Status Registers */
+#define OV9740_MODEL_ID_HI             0x0000
+#define OV9740_MODEL_ID_LO             0x0001
+#define OV9740_REVISION_NUMBER         0x0002
+#define OV9740_MANUFACTURER_ID         0x0003
+#define OV9740_SMIA_VERSION            0x0004
+
+/* General Setup Registers */
+#define OV9740_MODE_SELECT             0x0100
+#define OV9740_IMAGE_ORT               0x0101
+#define OV9740_SOFTWARE_RESET          0x0103
+#define OV9740_GRP_PARAM_HOLD          0x0104
+#define OV9740_MSK_CORRUP_FM           0x0105
+
+/* Timing Setting */
+#define OV9740_FRM_LENGTH_LN_HI                0x0340 /* VTS */
+#define OV9740_FRM_LENGTH_LN_LO                0x0341 /* VTS */
+#define OV9740_LN_LENGTH_PCK_HI                0x0342 /* HTS */
+#define OV9740_LN_LENGTH_PCK_LO                0x0343 /* HTS */
+#define OV9740_X_ADDR_START_HI         0x0344
+#define OV9740_X_ADDR_START_LO         0x0345
+#define OV9740_Y_ADDR_START_HI         0x0346
+#define OV9740_Y_ADDR_START_LO         0x0347
+#define OV9740_X_ADDR_END_HI           0x0348
+#define OV9740_X_ADDR_END_LO           0x0349
+#define OV9740_Y_ADDR_END_HI           0x034a
+#define OV9740_Y_ADDR_END_LO           0x034b
+#define OV9740_X_OUTPUT_SIZE_HI                0x034c
+#define OV9740_X_OUTPUT_SIZE_LO                0x034d
+#define OV9740_Y_OUTPUT_SIZE_HI                0x034e
+#define OV9740_Y_OUTPUT_SIZE_LO                0x034f
+
+/* IO Control Registers */
+#define OV9740_IO_CREL00               0x3002
+#define OV9740_IO_CREL01               0x3004
+#define OV9740_IO_CREL02               0x3005
+#define OV9740_IO_OUTPUT_SEL01         0x3026
+#define OV9740_IO_OUTPUT_SEL02         0x3027
+
+/* AWB Registers */
+#define OV9740_AWB_MANUAL_CTRL         0x3406
+
+/* Analog Control Registers */
+#define OV9740_ANALOG_CTRL01           0x3601
+#define OV9740_ANALOG_CTRL02           0x3602
+#define OV9740_ANALOG_CTRL03           0x3603
+#define OV9740_ANALOG_CTRL04           0x3604
+#define OV9740_ANALOG_CTRL10           0x3610
+#define OV9740_ANALOG_CTRL12           0x3612
+#define OV9740_ANALOG_CTRL15           0x3615
+#define OV9740_ANALOG_CTRL20           0x3620
+#define OV9740_ANALOG_CTRL21           0x3621
+#define OV9740_ANALOG_CTRL22           0x3622
+#define OV9740_ANALOG_CTRL30           0x3630
+#define OV9740_ANALOG_CTRL31           0x3631
+#define OV9740_ANALOG_CTRL32           0x3632
+#define OV9740_ANALOG_CTRL33           0x3633
+
+/* Sensor Control */
+#define OV9740_SENSOR_CTRL03           0x3703
+#define OV9740_SENSOR_CTRL04           0x3704
+#define OV9740_SENSOR_CTRL05           0x3705
+#define OV9740_SENSOR_CTRL07           0x3707
+
+/* Timing Control */
+#define OV9740_TIMING_CTRL17           0x3817
+#define OV9740_TIMING_CTRL19           0x3819
+#define OV9740_TIMING_CTRL33           0x3833
+#define OV9740_TIMING_CTRL35           0x3835
+
+/* Banding Filter */
+#define OV9740_AEC_MAXEXPO_60_H                0x3a02
+#define OV9740_AEC_MAXEXPO_60_L                0x3a03
+#define OV9740_AEC_B50_STEP_HI         0x3a08
+#define OV9740_AEC_B50_STEP_LO         0x3a09
+#define OV9740_AEC_B60_STEP_HI         0x3a0a
+#define OV9740_AEC_B60_STEP_LO         0x3a0b
+#define OV9740_AEC_CTRL0D              0x3a0d
+#define OV9740_AEC_CTRL0E              0x3a0e
+#define OV9740_AEC_MAXEXPO_50_H                0x3a14
+#define OV9740_AEC_MAXEXPO_50_L                0x3a15
+
+/* AEC/AGC Control */
+#define OV9740_AEC_ENABLE              0x3503
+#define OV9740_GAIN_CEILING_01         0x3a18
+#define OV9740_GAIN_CEILING_02         0x3a19
+#define OV9740_AEC_HI_THRESHOLD                0x3a11
+#define OV9740_AEC_3A1A                        0x3a1a
+#define OV9740_AEC_CTRL1B_WPT2         0x3a1b
+#define OV9740_AEC_CTRL0F_WPT          0x3a0f
+#define OV9740_AEC_CTRL10_BPT          0x3a10
+#define OV9740_AEC_CTRL1E_BPT2         0x3a1e
+#define OV9740_AEC_LO_THRESHOLD                0x3a1f
+
+/* BLC Control */
+#define OV9740_BLC_AUTO_ENABLE         0x4002
+#define OV9740_BLC_MODE                        0x4005
+
+/* VFIFO */
+#define OV9740_VFIFO_READ_START_HI     0x4608
+#define OV9740_VFIFO_READ_START_LO     0x4609
+
+/* DVP Control */
+#define OV9740_DVP_VSYNC_CTRL02                0x4702
+#define OV9740_DVP_VSYNC_MODE          0x4704
+#define OV9740_DVP_VSYNC_CTRL06                0x4706
+
+/* PLL Setting */
+#define OV9740_PLL_MODE_CTRL01         0x3104
+#define OV9740_PRE_PLL_CLK_DIV         0x0305
+#define OV9740_PLL_MULTIPLIER          0x0307
+#define OV9740_VT_SYS_CLK_DIV          0x0303
+#define OV9740_VT_PIX_CLK_DIV          0x0301
+#define OV9740_PLL_CTRL3010            0x3010
+#define OV9740_VFIFO_CTRL00            0x460e
+
+/* ISP Control */
+#define OV9740_ISP_CTRL00              0x5000
+#define OV9740_ISP_CTRL01              0x5001
+#define OV9740_ISP_CTRL03              0x5003
+#define OV9740_ISP_CTRL05              0x5005
+#define OV9740_ISP_CTRL12              0x5012
+#define OV9740_ISP_CTRL19              0x5019
+#define OV9740_ISP_CTRL1A              0x501a
+#define OV9740_ISP_CTRL1E              0x501e
+#define OV9740_ISP_CTRL1F              0x501f
+#define OV9740_ISP_CTRL20              0x5020
+#define OV9740_ISP_CTRL21              0x5021
+
+/* AWB */
+#define OV9740_AWB_CTRL00              0x5180
+#define OV9740_AWB_CTRL01              0x5181
+#define OV9740_AWB_CTRL02              0x5182
+#define OV9740_AWB_CTRL03              0x5183
+#define OV9740_AWB_ADV_CTRL01          0x5184
+#define OV9740_AWB_ADV_CTRL02          0x5185
+#define OV9740_AWB_ADV_CTRL03          0x5186
+#define OV9740_AWB_ADV_CTRL04          0x5187
+#define OV9740_AWB_ADV_CTRL05          0x5188
+#define OV9740_AWB_ADV_CTRL06          0x5189
+#define OV9740_AWB_ADV_CTRL07          0x518a
+#define OV9740_AWB_ADV_CTRL08          0x518b
+#define OV9740_AWB_ADV_CTRL09          0x518c
+#define OV9740_AWB_ADV_CTRL10          0x518d
+#define OV9740_AWB_ADV_CTRL11          0x518e
+#define OV9740_AWB_CTRL0F              0x518f
+#define OV9740_AWB_CTRL10              0x5190
+#define OV9740_AWB_CTRL11              0x5191
+#define OV9740_AWB_CTRL12              0x5192
+#define OV9740_AWB_CTRL13              0x5193
+#define OV9740_AWB_CTRL14              0x5194
+
+/* MIPI Control */
+#define OV9740_MIPI_CTRL00             0x4800
+#define OV9740_MIPI_3837               0x3837
+#define OV9740_MIPI_CTRL01             0x4801
+#define OV9740_MIPI_CTRL03             0x4803
+#define OV9740_MIPI_CTRL05             0x4805
+#define OV9740_VFIFO_RD_CTRL           0x4601
+#define OV9740_MIPI_CTRL_3012          0x3012
+#define OV9740_SC_CMMM_MIPI_CTR                0x3014
+
+#define OV9740_MAX_WIDTH               1280
+#define OV9740_MAX_HEIGHT              720
+
+/* Misc. structures */
+struct ov9740_reg {
+       u16                             reg;
+       u8                              val;
+};
+
+struct ov9740_priv {
+       struct v4l2_subdev              subdev;
+       struct v4l2_ctrl_handler        hdl;
+
+       int                             ident;
+       u16                             model;
+       u8                              revision;
+       u8                              manid;
+       u8                              smiaver;
+
+       bool                            flag_vflip;
+       bool                            flag_hflip;
+
+       /* For suspend/resume. */
+       struct v4l2_mbus_framefmt       current_mf;
+       bool                            current_enable;
+};
+
+static const struct ov9740_reg ov9740_defaults[] = {
+       /* Software Reset */
+       { OV9740_SOFTWARE_RESET,        0x01 },
+
+       /* Banding Filter */
+       { OV9740_AEC_B50_STEP_HI,       0x00 },
+       { OV9740_AEC_B50_STEP_LO,       0xe8 },
+       { OV9740_AEC_CTRL0E,            0x03 },
+       { OV9740_AEC_MAXEXPO_50_H,      0x15 },
+       { OV9740_AEC_MAXEXPO_50_L,      0xc6 },
+       { OV9740_AEC_B60_STEP_HI,       0x00 },
+       { OV9740_AEC_B60_STEP_LO,       0xc0 },
+       { OV9740_AEC_CTRL0D,            0x04 },
+       { OV9740_AEC_MAXEXPO_60_H,      0x18 },
+       { OV9740_AEC_MAXEXPO_60_L,      0x20 },
+
+       /* LC */
+       { 0x5842, 0x02 }, { 0x5843, 0x5e }, { 0x5844, 0x04 }, { 0x5845, 0x32 },
+       { 0x5846, 0x03 }, { 0x5847, 0x29 }, { 0x5848, 0x02 }, { 0x5849, 0xcc },
+
+       /* Un-documented OV9740 registers */
+       { 0x5800, 0x29 }, { 0x5801, 0x25 }, { 0x5802, 0x20 }, { 0x5803, 0x21 },
+       { 0x5804, 0x26 }, { 0x5805, 0x2e }, { 0x5806, 0x11 }, { 0x5807, 0x0c },
+       { 0x5808, 0x09 }, { 0x5809, 0x0a }, { 0x580a, 0x0e }, { 0x580b, 0x16 },
+       { 0x580c, 0x06 }, { 0x580d, 0x02 }, { 0x580e, 0x00 }, { 0x580f, 0x00 },
+       { 0x5810, 0x04 }, { 0x5811, 0x0a }, { 0x5812, 0x05 }, { 0x5813, 0x02 },
+       { 0x5814, 0x00 }, { 0x5815, 0x00 }, { 0x5816, 0x03 }, { 0x5817, 0x09 },
+       { 0x5818, 0x0f }, { 0x5819, 0x0a }, { 0x581a, 0x07 }, { 0x581b, 0x08 },
+       { 0x581c, 0x0b }, { 0x581d, 0x14 }, { 0x581e, 0x28 }, { 0x581f, 0x23 },
+       { 0x5820, 0x1d }, { 0x5821, 0x1e }, { 0x5822, 0x24 }, { 0x5823, 0x2a },
+       { 0x5824, 0x4f }, { 0x5825, 0x6f }, { 0x5826, 0x5f }, { 0x5827, 0x7f },
+       { 0x5828, 0x9f }, { 0x5829, 0x5f }, { 0x582a, 0x8f }, { 0x582b, 0x9e },
+       { 0x582c, 0x8f }, { 0x582d, 0x9f }, { 0x582e, 0x4f }, { 0x582f, 0x87 },
+       { 0x5830, 0x86 }, { 0x5831, 0x97 }, { 0x5832, 0xae }, { 0x5833, 0x3f },
+       { 0x5834, 0x8e }, { 0x5835, 0x7c }, { 0x5836, 0x7e }, { 0x5837, 0xaf },
+       { 0x5838, 0x8f }, { 0x5839, 0x8f }, { 0x583a, 0x9f }, { 0x583b, 0x7f },
+       { 0x583c, 0x5f },
+
+       /* Y Gamma */
+       { 0x5480, 0x07 }, { 0x5481, 0x18 }, { 0x5482, 0x2c }, { 0x5483, 0x4e },
+       { 0x5484, 0x5e }, { 0x5485, 0x6b }, { 0x5486, 0x77 }, { 0x5487, 0x82 },
+       { 0x5488, 0x8c }, { 0x5489, 0x95 }, { 0x548a, 0xa4 }, { 0x548b, 0xb1 },
+       { 0x548c, 0xc6 }, { 0x548d, 0xd8 }, { 0x548e, 0xe9 },
+
+       /* UV Gamma */
+       { 0x5490, 0x0f }, { 0x5491, 0xff }, { 0x5492, 0x0d }, { 0x5493, 0x05 },
+       { 0x5494, 0x07 }, { 0x5495, 0x1a }, { 0x5496, 0x04 }, { 0x5497, 0x01 },
+       { 0x5498, 0x03 }, { 0x5499, 0x53 }, { 0x549a, 0x02 }, { 0x549b, 0xeb },
+       { 0x549c, 0x02 }, { 0x549d, 0xa0 }, { 0x549e, 0x02 }, { 0x549f, 0x67 },
+       { 0x54a0, 0x02 }, { 0x54a1, 0x3b }, { 0x54a2, 0x02 }, { 0x54a3, 0x18 },
+       { 0x54a4, 0x01 }, { 0x54a5, 0xe7 }, { 0x54a6, 0x01 }, { 0x54a7, 0xc3 },
+       { 0x54a8, 0x01 }, { 0x54a9, 0x94 }, { 0x54aa, 0x01 }, { 0x54ab, 0x72 },
+       { 0x54ac, 0x01 }, { 0x54ad, 0x57 },
+
+       /* AWB */
+       { OV9740_AWB_CTRL00,            0xf0 },
+       { OV9740_AWB_CTRL01,            0x00 },
+       { OV9740_AWB_CTRL02,            0x41 },
+       { OV9740_AWB_CTRL03,            0x42 },
+       { OV9740_AWB_ADV_CTRL01,        0x8a },
+       { OV9740_AWB_ADV_CTRL02,        0x61 },
+       { OV9740_AWB_ADV_CTRL03,        0xce },
+       { OV9740_AWB_ADV_CTRL04,        0xa8 },
+       { OV9740_AWB_ADV_CTRL05,        0x17 },
+       { OV9740_AWB_ADV_CTRL06,        0x1f },
+       { OV9740_AWB_ADV_CTRL07,        0x27 },
+       { OV9740_AWB_ADV_CTRL08,        0x41 },
+       { OV9740_AWB_ADV_CTRL09,        0x34 },
+       { OV9740_AWB_ADV_CTRL10,        0xf0 },
+       { OV9740_AWB_ADV_CTRL11,        0x10 },
+       { OV9740_AWB_CTRL0F,            0xff },
+       { OV9740_AWB_CTRL10,            0x00 },
+       { OV9740_AWB_CTRL11,            0xff },
+       { OV9740_AWB_CTRL12,            0x00 },
+       { OV9740_AWB_CTRL13,            0xff },
+       { OV9740_AWB_CTRL14,            0x00 },
+
+       /* CIP */
+       { 0x530d, 0x12 },
+
+       /* CMX */
+       { 0x5380, 0x01 }, { 0x5381, 0x00 }, { 0x5382, 0x00 }, { 0x5383, 0x17 },
+       { 0x5384, 0x00 }, { 0x5385, 0x01 }, { 0x5386, 0x00 }, { 0x5387, 0x00 },
+       { 0x5388, 0x00 }, { 0x5389, 0xe0 }, { 0x538a, 0x00 }, { 0x538b, 0x20 },
+       { 0x538c, 0x00 }, { 0x538d, 0x00 }, { 0x538e, 0x00 }, { 0x538f, 0x16 },
+       { 0x5390, 0x00 }, { 0x5391, 0x9c }, { 0x5392, 0x00 }, { 0x5393, 0xa0 },
+       { 0x5394, 0x18 },
+
+       /* 50/60 Detection */
+       { 0x3c0a, 0x9c }, { 0x3c0b, 0x3f },
+
+       /* Output Select */
+       { OV9740_IO_OUTPUT_SEL01,       0x00 },
+       { OV9740_IO_OUTPUT_SEL02,       0x00 },
+       { OV9740_IO_CREL00,             0x00 },
+       { OV9740_IO_CREL01,             0x00 },
+       { OV9740_IO_CREL02,             0x00 },
+
+       /* AWB Control */
+       { OV9740_AWB_MANUAL_CTRL,       0x00 },
+
+       /* Analog Control */
+       { OV9740_ANALOG_CTRL03,         0xaa },
+       { OV9740_ANALOG_CTRL32,         0x2f },
+       { OV9740_ANALOG_CTRL20,         0x66 },
+       { OV9740_ANALOG_CTRL21,         0xc0 },
+       { OV9740_ANALOG_CTRL31,         0x52 },
+       { OV9740_ANALOG_CTRL33,         0x50 },
+       { OV9740_ANALOG_CTRL30,         0xca },
+       { OV9740_ANALOG_CTRL04,         0x0c },
+       { OV9740_ANALOG_CTRL01,         0x40 },
+       { OV9740_ANALOG_CTRL02,         0x16 },
+       { OV9740_ANALOG_CTRL10,         0xa1 },
+       { OV9740_ANALOG_CTRL12,         0x24 },
+       { OV9740_ANALOG_CTRL22,         0x9f },
+       { OV9740_ANALOG_CTRL15,         0xf0 },
+
+       /* Sensor Control */
+       { OV9740_SENSOR_CTRL03,         0x42 },
+       { OV9740_SENSOR_CTRL04,         0x10 },
+       { OV9740_SENSOR_CTRL05,         0x45 },
+       { OV9740_SENSOR_CTRL07,         0x14 },
+
+       /* Timing Control */
+       { OV9740_TIMING_CTRL33,         0x04 },
+       { OV9740_TIMING_CTRL35,         0x02 },
+       { OV9740_TIMING_CTRL19,         0x6e },
+       { OV9740_TIMING_CTRL17,         0x94 },
+
+       /* AEC/AGC Control */
+       { OV9740_AEC_ENABLE,            0x10 },
+       { OV9740_GAIN_CEILING_01,       0x00 },
+       { OV9740_GAIN_CEILING_02,       0x7f },
+       { OV9740_AEC_HI_THRESHOLD,      0xa0 },
+       { OV9740_AEC_3A1A,              0x05 },
+       { OV9740_AEC_CTRL1B_WPT2,       0x50 },
+       { OV9740_AEC_CTRL0F_WPT,        0x50 },
+       { OV9740_AEC_CTRL10_BPT,        0x4c },
+       { OV9740_AEC_CTRL1E_BPT2,       0x4c },
+       { OV9740_AEC_LO_THRESHOLD,      0x26 },
+
+       /* BLC Control */
+       { OV9740_BLC_AUTO_ENABLE,       0x45 },
+       { OV9740_BLC_MODE,              0x18 },
+
+       /* DVP Control */
+       { OV9740_DVP_VSYNC_CTRL02,      0x04 },
+       { OV9740_DVP_VSYNC_MODE,        0x00 },
+       { OV9740_DVP_VSYNC_CTRL06,      0x08 },
+
+       /* PLL Setting */
+       { OV9740_PLL_MODE_CTRL01,       0x20 },
+       { OV9740_PRE_PLL_CLK_DIV,       0x03 },
+       { OV9740_PLL_MULTIPLIER,        0x4c },
+       { OV9740_VT_SYS_CLK_DIV,        0x01 },
+       { OV9740_VT_PIX_CLK_DIV,        0x08 },
+       { OV9740_PLL_CTRL3010,          0x01 },
+       { OV9740_VFIFO_CTRL00,          0x82 },
+
+       /* Timing Setting */
+       /* VTS */
+       { OV9740_FRM_LENGTH_LN_HI,      0x03 },
+       { OV9740_FRM_LENGTH_LN_LO,      0x07 },
+       /* HTS */
+       { OV9740_LN_LENGTH_PCK_HI,      0x06 },
+       { OV9740_LN_LENGTH_PCK_LO,      0x62 },
+
+       /* MIPI Control */
+       { OV9740_MIPI_CTRL00,           0x44 }, /* 0x64 for discontinuous clk */
+       { OV9740_MIPI_3837,             0x01 },
+       { OV9740_MIPI_CTRL01,           0x0f },
+       { OV9740_MIPI_CTRL03,           0x05 },
+       { OV9740_MIPI_CTRL05,           0x10 },
+       { OV9740_VFIFO_RD_CTRL,         0x16 },
+       { OV9740_MIPI_CTRL_3012,        0x70 },
+       { OV9740_SC_CMMM_MIPI_CTR,      0x01 },
+
+       /* YUYV order */
+       { OV9740_ISP_CTRL19,            0x02 },
+};
+
+static enum v4l2_mbus_pixelcode ov9740_codes[] = {
+       V4L2_MBUS_FMT_YUYV8_2X8,
+};
+
+/* read a register */
+static int ov9740_reg_read(struct i2c_client *client, u16 reg, u8 *val)
+{
+       int ret;
+       struct i2c_msg msg[] = {
+               {
+                       .addr   = client->addr,
+                       .flags  = 0,
+                       .len    = 2,
+                       .buf    = (u8 *)&reg,
+               },
+               {
+                       .addr   = client->addr,
+                       .flags  = I2C_M_RD,
+                       .len    = 1,
+                       .buf    = val,
+               },
+       };
+
+       reg = swab16(reg);
+
+       ret = i2c_transfer(client->adapter, msg, 2);
+       if (ret < 0) {
+               dev_err(&client->dev, "Failed reading register 0x%04x!\n", reg);
+               return ret;
+       }
+
+       return 0;
+}
+
+/* write a register */
+static int ov9740_reg_write(struct i2c_client *client, u16 reg, u8 val)
+{
+       struct i2c_msg msg;
+       struct {
+               u16 reg;
+               u8 val;
+       } __packed buf;
+       int ret;
+
+       reg = swab16(reg);
+
+       buf.reg = reg;
+       buf.val = val;
+
+       msg.addr        = client->addr;
+       msg.flags       = 0;
+       msg.len         = 3;
+       msg.buf         = (u8 *)&buf;
+
+       ret = i2c_transfer(client->adapter, &msg, 1);
+       if (ret < 0) {
+               dev_err(&client->dev, "Failed writing register 0x%04x!\n", reg);
+               return ret;
+       }
+
+       return 0;
+}
+
+
+/* Read a register, alter its bits, write it back */
+static int ov9740_reg_rmw(struct i2c_client *client, u16 reg, u8 set, u8 unset)
+{
+       u8 val;
+       int ret;
+
+       ret = ov9740_reg_read(client, reg, &val);
+       if (ret < 0) {
+               dev_err(&client->dev,
+                       "[Read]-Modify-Write of register 0x%04x failed!\n",
+                       reg);
+               return ret;
+       }
+
+       val |= set;
+       val &= ~unset;
+
+       ret = ov9740_reg_write(client, reg, val);
+       if (ret < 0) {
+               dev_err(&client->dev,
+                       "Read-Modify-[Write] of register 0x%04x failed!\n",
+                       reg);
+               return ret;
+       }
+
+       return 0;
+}
+
+static int ov9740_reg_write_array(struct i2c_client *client,
+                                 const struct ov9740_reg *regarray,
+                                 int regarraylen)
+{
+       int i;
+       int ret;
+
+       for (i = 0; i < regarraylen; i++) {
+               ret = ov9740_reg_write(client,
+                                      regarray[i].reg, regarray[i].val);
+               if (ret < 0)
+                       return ret;
+       }
+
+       return 0;
+}
+
+/* Start/Stop streaming from the device */
+static int ov9740_s_stream(struct v4l2_subdev *sd, int enable)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct ov9740_priv *priv = to_ov9740(sd);
+       int ret;
+
+       /* Program orientation register. */
+       if (priv->flag_vflip)
+               ret = ov9740_reg_rmw(client, OV9740_IMAGE_ORT, 0x2, 0);
+       else
+               ret = ov9740_reg_rmw(client, OV9740_IMAGE_ORT, 0, 0x2);
+       if (ret < 0)
+               return ret;
+
+       if (priv->flag_hflip)
+               ret = ov9740_reg_rmw(client, OV9740_IMAGE_ORT, 0x1, 0);
+       else
+               ret = ov9740_reg_rmw(client, OV9740_IMAGE_ORT, 0, 0x1);
+       if (ret < 0)
+               return ret;
+
+       if (enable) {
+               dev_dbg(&client->dev, "Enabling Streaming\n");
+               /* Start Streaming */
+               ret = ov9740_reg_write(client, OV9740_MODE_SELECT, 0x01);
+
+       } else {
+               dev_dbg(&client->dev, "Disabling Streaming\n");
+               /* Software Reset */
+               ret = ov9740_reg_write(client, OV9740_SOFTWARE_RESET, 0x01);
+               if (!ret)
+                       /* Setting Streaming to Standby */
+                       ret = ov9740_reg_write(client, OV9740_MODE_SELECT,
+                                              0x00);
+       }
+
+       priv->current_enable = enable;
+
+       return ret;
+}
+
+/* select nearest higher resolution for capture */
+static void ov9740_res_roundup(u32 *width, u32 *height)
+{
+       /* Width must be a multiple of 4 pixels. */
+       *width = ALIGN(*width, 4);
+
+       /* Max resolution is 1280x720 (720p). */
+       if (*width > OV9740_MAX_WIDTH)
+               *width = OV9740_MAX_WIDTH;
+
+       if (*height > OV9740_MAX_HEIGHT)
+               *height = OV9740_MAX_HEIGHT;
+}
+
+/* Setup registers according to resolution and color encoding */
+static int ov9740_set_res(struct i2c_client *client, u32 width, u32 height)
+{
+       u32 x_start;
+       u32 y_start;
+       u32 x_end;
+       u32 y_end;
+       bool scaling = 0;
+       u32 scale_input_x;
+       u32 scale_input_y;
+       int ret;
+
+       if ((width != OV9740_MAX_WIDTH) || (height != OV9740_MAX_HEIGHT))
+               scaling = 1;
+
+       /*
+        * Try to use as much of the sensor area as possible when supporting
+        * smaller resolutions.  Depending on the aspect ratio of the
+        * chosen resolution, we can either use the full width of the sensor,
+        * or the full height of the sensor (or both if the aspect ratio is
+        * the same as 1280x720.
+        */
+       if ((OV9740_MAX_WIDTH * height) > (OV9740_MAX_HEIGHT * width)) {
+               scale_input_x = (OV9740_MAX_HEIGHT * width) / height;
+               scale_input_y = OV9740_MAX_HEIGHT;
+       } else {
+               scale_input_x = OV9740_MAX_WIDTH;
+               scale_input_y = (OV9740_MAX_WIDTH * height) / width;
+       }
+
+       /* These describe the area of the sensor to use. */
+       x_start = (OV9740_MAX_WIDTH - scale_input_x) / 2;
+       y_start = (OV9740_MAX_HEIGHT - scale_input_y) / 2;
+       x_end = x_start + scale_input_x - 1;
+       y_end = y_start + scale_input_y - 1;
+
+       ret = ov9740_reg_write(client, OV9740_X_ADDR_START_HI, x_start >> 8);
+       if (ret)
+               goto done;
+       ret = ov9740_reg_write(client, OV9740_X_ADDR_START_LO, x_start & 0xff);
+       if (ret)
+               goto done;
+       ret = ov9740_reg_write(client, OV9740_Y_ADDR_START_HI, y_start >> 8);
+       if (ret)
+               goto done;
+       ret = ov9740_reg_write(client, OV9740_Y_ADDR_START_LO, y_start & 0xff);
+       if (ret)
+               goto done;
+
+       ret = ov9740_reg_write(client, OV9740_X_ADDR_END_HI, x_end >> 8);
+       if (ret)
+               goto done;
+       ret = ov9740_reg_write(client, OV9740_X_ADDR_END_LO, x_end & 0xff);
+       if (ret)
+               goto done;
+       ret = ov9740_reg_write(client, OV9740_Y_ADDR_END_HI, y_end >> 8);
+       if (ret)
+               goto done;
+       ret = ov9740_reg_write(client, OV9740_Y_ADDR_END_LO, y_end & 0xff);
+       if (ret)
+               goto done;
+
+       ret = ov9740_reg_write(client, OV9740_X_OUTPUT_SIZE_HI, width >> 8);
+       if (ret)
+               goto done;
+       ret = ov9740_reg_write(client, OV9740_X_OUTPUT_SIZE_LO, width & 0xff);
+       if (ret)
+               goto done;
+       ret = ov9740_reg_write(client, OV9740_Y_OUTPUT_SIZE_HI, height >> 8);
+       if (ret)
+               goto done;
+       ret = ov9740_reg_write(client, OV9740_Y_OUTPUT_SIZE_LO, height & 0xff);
+       if (ret)
+               goto done;
+
+       ret = ov9740_reg_write(client, OV9740_ISP_CTRL1E, scale_input_x >> 8);
+       if (ret)
+               goto done;
+       ret = ov9740_reg_write(client, OV9740_ISP_CTRL1F, scale_input_x & 0xff);
+       if (ret)
+               goto done;
+       ret = ov9740_reg_write(client, OV9740_ISP_CTRL20, scale_input_y >> 8);
+       if (ret)
+               goto done;
+       ret = ov9740_reg_write(client, OV9740_ISP_CTRL21, scale_input_y & 0xff);
+       if (ret)
+               goto done;
+
+       ret = ov9740_reg_write(client, OV9740_VFIFO_READ_START_HI,
+                              (scale_input_x - width) >> 8);
+       if (ret)
+               goto done;
+       ret = ov9740_reg_write(client, OV9740_VFIFO_READ_START_LO,
+                              (scale_input_x - width) & 0xff);
+       if (ret)
+               goto done;
+
+       ret = ov9740_reg_write(client, OV9740_ISP_CTRL00, 0xff);
+       if (ret)
+               goto done;
+       ret = ov9740_reg_write(client, OV9740_ISP_CTRL01, 0xef |
+                                                         (scaling << 4));
+       if (ret)
+               goto done;
+       ret = ov9740_reg_write(client, OV9740_ISP_CTRL03, 0xff);
+
+done:
+       return ret;
+}
+
+/* set the format we will capture in */
+static int ov9740_s_fmt(struct v4l2_subdev *sd,
+                       struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct ov9740_priv *priv = to_ov9740(sd);
+       enum v4l2_colorspace cspace;
+       enum v4l2_mbus_pixelcode code = mf->code;
+       int ret;
+
+       ov9740_res_roundup(&mf->width, &mf->height);
+
+       switch (code) {
+       case V4L2_MBUS_FMT_YUYV8_2X8:
+               cspace = V4L2_COLORSPACE_SRGB;
+               break;
+       default:
+               return -EINVAL;
+       }
+
+       ret = ov9740_reg_write_array(client, ov9740_defaults,
+                                    ARRAY_SIZE(ov9740_defaults));
+       if (ret < 0)
+               return ret;
+
+       ret = ov9740_set_res(client, mf->width, mf->height);
+       if (ret < 0)
+               return ret;
+
+       mf->code        = code;
+       mf->colorspace  = cspace;
+
+       memcpy(&priv->current_mf, mf, sizeof(struct v4l2_mbus_framefmt));
+
+       return ret;
+}
+
+static int ov9740_try_fmt(struct v4l2_subdev *sd,
+                         struct v4l2_mbus_framefmt *mf)
+{
+       ov9740_res_roundup(&mf->width, &mf->height);
+
+       mf->field = V4L2_FIELD_NONE;
+       mf->code = V4L2_MBUS_FMT_YUYV8_2X8;
+       mf->colorspace = V4L2_COLORSPACE_SRGB;
+
+       return 0;
+}
+
+static int ov9740_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
+                          enum v4l2_mbus_pixelcode *code)
+{
+       if (index >= ARRAY_SIZE(ov9740_codes))
+               return -EINVAL;
+
+       *code = ov9740_codes[index];
+
+       return 0;
+}
+
+static int ov9740_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
+{
+       a->bounds.left          = 0;
+       a->bounds.top           = 0;
+       a->bounds.width         = OV9740_MAX_WIDTH;
+       a->bounds.height        = OV9740_MAX_HEIGHT;
+       a->defrect              = a->bounds;
+       a->type                 = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+       a->pixelaspect.numerator        = 1;
+       a->pixelaspect.denominator      = 1;
+
+       return 0;
+}
+
+static int ov9740_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+       a->c.left               = 0;
+       a->c.top                = 0;
+       a->c.width              = OV9740_MAX_WIDTH;
+       a->c.height             = OV9740_MAX_HEIGHT;
+       a->type                 = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+       return 0;
+}
+
+/* Set status of additional camera capabilities */
+static int ov9740_s_ctrl(struct v4l2_ctrl *ctrl)
+{
+       struct ov9740_priv *priv =
+               container_of(ctrl->handler, struct ov9740_priv, hdl);
+
+       switch (ctrl->id) {
+       case V4L2_CID_VFLIP:
+               priv->flag_vflip = ctrl->val;
+               break;
+       case V4L2_CID_HFLIP:
+               priv->flag_hflip = ctrl->val;
+               break;
+       default:
+               return -EINVAL;
+       }
+
+       return 0;
+}
+
+/* Get chip identification */
+static int ov9740_g_chip_ident(struct v4l2_subdev *sd,
+                              struct v4l2_dbg_chip_ident *id)
+{
+       struct ov9740_priv *priv = to_ov9740(sd);
+
+       id->ident = priv->ident;
+       id->revision = priv->revision;
+
+       return 0;
+}
+
+static int ov9740_s_power(struct v4l2_subdev *sd, int on)
+{
+       struct ov9740_priv *priv = to_ov9740(sd);
+
+       if (!priv->current_enable)
+               return 0;
+
+       if (on) {
+               ov9740_s_fmt(sd, &priv->current_mf);
+               ov9740_s_stream(sd, priv->current_enable);
+       } else {
+               ov9740_s_stream(sd, 0);
+               priv->current_enable = true;
+       }
+
+       return 0;
+}
+
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+static int ov9740_get_register(struct v4l2_subdev *sd,
+                              struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       int ret;
+       u8 val;
+
+       if (reg->reg & ~0xffff)
+               return -EINVAL;
+
+       reg->size = 2;
+
+       ret = ov9740_reg_read(client, reg->reg, &val);
+       if (ret)
+               return ret;
+
+       reg->val = (__u64)val;
+
+       return ret;
+}
+
+static int ov9740_set_register(struct v4l2_subdev *sd,
+                              struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+       if (reg->reg & ~0xffff || reg->val & ~0xff)
+               return -EINVAL;
+
+       return ov9740_reg_write(client, reg->reg, reg->val);
+}
+#endif
+
+static int ov9740_video_probe(struct i2c_client *client)
+{
+       struct v4l2_subdev *sd = i2c_get_clientdata(client);
+       struct ov9740_priv *priv = to_ov9740(sd);
+       u8 modelhi, modello;
+       int ret;
+
+       /*
+        * check and show product ID and manufacturer ID
+        */
+       ret = ov9740_reg_read(client, OV9740_MODEL_ID_HI, &modelhi);
+       if (ret < 0)
+               goto err;
+
+       ret = ov9740_reg_read(client, OV9740_MODEL_ID_LO, &modello);
+       if (ret < 0)
+               goto err;
+
+       priv->model = (modelhi << 8) | modello;
+
+       ret = ov9740_reg_read(client, OV9740_REVISION_NUMBER, &priv->revision);
+       if (ret < 0)
+               goto err;
+
+       ret = ov9740_reg_read(client, OV9740_MANUFACTURER_ID, &priv->manid);
+       if (ret < 0)
+               goto err;
+
+       ret = ov9740_reg_read(client, OV9740_SMIA_VERSION, &priv->smiaver);
+       if (ret < 0)
+               goto err;
+
+       if (priv->model != 0x9740) {
+               ret = -ENODEV;
+               goto err;
+       }
+
+       priv->ident = V4L2_IDENT_OV9740;
+
+       dev_info(&client->dev, "ov9740 Model ID 0x%04x, Revision 0x%02x, "
+                "Manufacturer 0x%02x, SMIA Version 0x%02x\n",
+                priv->model, priv->revision, priv->manid, priv->smiaver);
+
+err:
+       return ret;
+}
+
+/* Request bus settings on camera side */
+static int ov9740_g_mbus_config(struct v4l2_subdev *sd,
+                               struct v4l2_mbus_config *cfg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+
+       cfg->flags = V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_MASTER |
+               V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_HSYNC_ACTIVE_HIGH |
+               V4L2_MBUS_DATA_ACTIVE_HIGH;
+       cfg->type = V4L2_MBUS_PARALLEL;
+       cfg->flags = soc_camera_apply_board_flags(icl, cfg);
+
+       return 0;
+}
+
+static struct v4l2_subdev_video_ops ov9740_video_ops = {
+       .s_stream       = ov9740_s_stream,
+       .s_mbus_fmt     = ov9740_s_fmt,
+       .try_mbus_fmt   = ov9740_try_fmt,
+       .enum_mbus_fmt  = ov9740_enum_fmt,
+       .cropcap        = ov9740_cropcap,
+       .g_crop         = ov9740_g_crop,
+       .g_mbus_config  = ov9740_g_mbus_config,
+};
+
+static struct v4l2_subdev_core_ops ov9740_core_ops = {
+       .g_chip_ident           = ov9740_g_chip_ident,
+       .s_power                = ov9740_s_power,
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+       .g_register             = ov9740_get_register,
+       .s_register             = ov9740_set_register,
+#endif
+};
+
+static struct v4l2_subdev_ops ov9740_subdev_ops = {
+       .core                   = &ov9740_core_ops,
+       .video                  = &ov9740_video_ops,
+};
+
+static const struct v4l2_ctrl_ops ov9740_ctrl_ops = {
+       .s_ctrl = ov9740_s_ctrl,
+};
+
+/*
+ * i2c_driver function
+ */
+static int ov9740_probe(struct i2c_client *client,
+                       const struct i2c_device_id *did)
+{
+       struct ov9740_priv *priv;
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+       int ret;
+
+       if (!icl) {
+               dev_err(&client->dev, "Missing platform_data for driver\n");
+               return -EINVAL;
+       }
+
+       priv = kzalloc(sizeof(struct ov9740_priv), GFP_KERNEL);
+       if (!priv) {
+               dev_err(&client->dev, "Failed to allocate private data!\n");
+               return -ENOMEM;
+       }
+
+       v4l2_i2c_subdev_init(&priv->subdev, client, &ov9740_subdev_ops);
+       v4l2_ctrl_handler_init(&priv->hdl, 13);
+       v4l2_ctrl_new_std(&priv->hdl, &ov9740_ctrl_ops,
+                       V4L2_CID_VFLIP, 0, 1, 1, 0);
+       v4l2_ctrl_new_std(&priv->hdl, &ov9740_ctrl_ops,
+                       V4L2_CID_HFLIP, 0, 1, 1, 0);
+       priv->subdev.ctrl_handler = &priv->hdl;
+       if (priv->hdl.error) {
+               int err = priv->hdl.error;
+
+               kfree(priv);
+               return err;
+       }
+
+       ret = ov9740_video_probe(client);
+       if (!ret)
+               ret = v4l2_ctrl_handler_setup(&priv->hdl);
+       if (ret < 0) {
+               v4l2_ctrl_handler_free(&priv->hdl);
+               kfree(priv);
+       }
+
+       return ret;
+}
+
+static int ov9740_remove(struct i2c_client *client)
+{
+       struct ov9740_priv *priv = i2c_get_clientdata(client);
+
+       v4l2_device_unregister_subdev(&priv->subdev);
+       v4l2_ctrl_handler_free(&priv->hdl);
+       kfree(priv);
+       return 0;
+}
+
+static const struct i2c_device_id ov9740_id[] = {
+       { "ov9740", 0 },
+       { }
+};
+MODULE_DEVICE_TABLE(i2c, ov9740_id);
+
+static struct i2c_driver ov9740_i2c_driver = {
+       .driver = {
+               .name = "ov9740",
+       },
+       .probe    = ov9740_probe,
+       .remove   = ov9740_remove,
+       .id_table = ov9740_id,
+};
+
+module_i2c_driver(ov9740_i2c_driver);
+
+MODULE_DESCRIPTION("SoC Camera driver for OmniVision OV9740");
+MODULE_AUTHOR("Andrew Chew <achew@nvidia.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/i2c/soc_camera/rj54n1cb0c.c b/drivers/media/i2c/soc_camera/rj54n1cb0c.c
new file mode 100644 (file)
index 0000000..f6419b2
--- /dev/null
@@ -0,0 +1,1414 @@
+/*
+ * Driver for RJ54N1CB0C CMOS Image Sensor from Sharp
+ *
+ * Copyright (C) 2009, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/slab.h>
+#include <linux/v4l2-mediabus.h>
+#include <linux/videodev2.h>
+#include <linux/module.h>
+
+#include <media/rj54n1cb0c.h>
+#include <media/soc_camera.h>
+#include <media/v4l2-subdev.h>
+#include <media/v4l2-chip-ident.h>
+#include <media/v4l2-ctrls.h>
+
+#define RJ54N1_DEV_CODE                        0x0400
+#define RJ54N1_DEV_CODE2               0x0401
+#define RJ54N1_OUT_SEL                 0x0403
+#define RJ54N1_XY_OUTPUT_SIZE_S_H      0x0404
+#define RJ54N1_X_OUTPUT_SIZE_S_L       0x0405
+#define RJ54N1_Y_OUTPUT_SIZE_S_L       0x0406
+#define RJ54N1_XY_OUTPUT_SIZE_P_H      0x0407
+#define RJ54N1_X_OUTPUT_SIZE_P_L       0x0408
+#define RJ54N1_Y_OUTPUT_SIZE_P_L       0x0409
+#define RJ54N1_LINE_LENGTH_PCK_S_H     0x040a
+#define RJ54N1_LINE_LENGTH_PCK_S_L     0x040b
+#define RJ54N1_LINE_LENGTH_PCK_P_H     0x040c
+#define RJ54N1_LINE_LENGTH_PCK_P_L     0x040d
+#define RJ54N1_RESIZE_N                        0x040e
+#define RJ54N1_RESIZE_N_STEP           0x040f
+#define RJ54N1_RESIZE_STEP             0x0410
+#define RJ54N1_RESIZE_HOLD_H           0x0411
+#define RJ54N1_RESIZE_HOLD_L           0x0412
+#define RJ54N1_H_OBEN_OFS              0x0413
+#define RJ54N1_V_OBEN_OFS              0x0414
+#define RJ54N1_RESIZE_CONTROL          0x0415
+#define RJ54N1_STILL_CONTROL           0x0417
+#define RJ54N1_INC_USE_SEL_H           0x0425
+#define RJ54N1_INC_USE_SEL_L           0x0426
+#define RJ54N1_MIRROR_STILL_MODE       0x0427
+#define RJ54N1_INIT_START              0x0428
+#define RJ54N1_SCALE_1_2_LEV           0x0429
+#define RJ54N1_SCALE_4_LEV             0x042a
+#define RJ54N1_Y_GAIN                  0x04d8
+#define RJ54N1_APT_GAIN_UP             0x04fa
+#define RJ54N1_RA_SEL_UL               0x0530
+#define RJ54N1_BYTE_SWAP               0x0531
+#define RJ54N1_OUT_SIGPO               0x053b
+#define RJ54N1_WB_SEL_WEIGHT_I         0x054e
+#define RJ54N1_BIT8_WB                 0x0569
+#define RJ54N1_HCAPS_WB                        0x056a
+#define RJ54N1_VCAPS_WB                        0x056b
+#define RJ54N1_HCAPE_WB                        0x056c
+#define RJ54N1_VCAPE_WB                        0x056d
+#define RJ54N1_EXPOSURE_CONTROL                0x058c
+#define RJ54N1_FRAME_LENGTH_S_H                0x0595
+#define RJ54N1_FRAME_LENGTH_S_L                0x0596
+#define RJ54N1_FRAME_LENGTH_P_H                0x0597
+#define RJ54N1_FRAME_LENGTH_P_L                0x0598
+#define RJ54N1_PEAK_H                  0x05b7
+#define RJ54N1_PEAK_50                 0x05b8
+#define RJ54N1_PEAK_60                 0x05b9
+#define RJ54N1_PEAK_DIFF               0x05ba
+#define RJ54N1_IOC                     0x05ef
+#define RJ54N1_TG_BYPASS               0x0700
+#define RJ54N1_PLL_L                   0x0701
+#define RJ54N1_PLL_N                   0x0702
+#define RJ54N1_PLL_EN                  0x0704
+#define RJ54N1_RATIO_TG                        0x0706
+#define RJ54N1_RATIO_T                 0x0707
+#define RJ54N1_RATIO_R                 0x0708
+#define RJ54N1_RAMP_TGCLK_EN           0x0709
+#define RJ54N1_OCLK_DSP                        0x0710
+#define RJ54N1_RATIO_OP                        0x0711
+#define RJ54N1_RATIO_O                 0x0712
+#define RJ54N1_OCLK_SEL_EN             0x0713
+#define RJ54N1_CLK_RST                 0x0717
+#define RJ54N1_RESET_STANDBY           0x0718
+#define RJ54N1_FWFLG                   0x07fe
+
+#define E_EXCLK                                (1 << 7)
+#define SOFT_STDBY                     (1 << 4)
+#define SEN_RSTX                       (1 << 2)
+#define TG_RSTX                                (1 << 1)
+#define DSP_RSTX                       (1 << 0)
+
+#define RESIZE_HOLD_SEL                        (1 << 2)
+#define RESIZE_GO                      (1 << 1)
+
+/*
+ * When cropping, the camera automatically centers the cropped region, there
+ * doesn't seem to be a way to specify an explicit location of the rectangle.
+ */
+#define RJ54N1_COLUMN_SKIP             0
+#define RJ54N1_ROW_SKIP                        0
+#define RJ54N1_MAX_WIDTH               1600
+#define RJ54N1_MAX_HEIGHT              1200
+
+#define PLL_L                          2
+#define PLL_N                          0x31
+
+/* I2C addresses: 0x50, 0x51, 0x60, 0x61 */
+
+/* RJ54N1CB0C has only one fixed colorspace per pixelcode */
+struct rj54n1_datafmt {
+       enum v4l2_mbus_pixelcode        code;
+       enum v4l2_colorspace            colorspace;
+};
+
+/* Find a data format by a pixel code in an array */
+static const struct rj54n1_datafmt *rj54n1_find_datafmt(
+       enum v4l2_mbus_pixelcode code, const struct rj54n1_datafmt *fmt,
+       int n)
+{
+       int i;
+       for (i = 0; i < n; i++)
+               if (fmt[i].code == code)
+                       return fmt + i;
+
+       return NULL;
+}
+
+static const struct rj54n1_datafmt rj54n1_colour_fmts[] = {
+       {V4L2_MBUS_FMT_YUYV8_2X8, V4L2_COLORSPACE_JPEG},
+       {V4L2_MBUS_FMT_YVYU8_2X8, V4L2_COLORSPACE_JPEG},
+       {V4L2_MBUS_FMT_RGB565_2X8_LE, V4L2_COLORSPACE_SRGB},
+       {V4L2_MBUS_FMT_RGB565_2X8_BE, V4L2_COLORSPACE_SRGB},
+       {V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE, V4L2_COLORSPACE_SRGB},
+       {V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_LE, V4L2_COLORSPACE_SRGB},
+       {V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_BE, V4L2_COLORSPACE_SRGB},
+       {V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_BE, V4L2_COLORSPACE_SRGB},
+       {V4L2_MBUS_FMT_SBGGR10_1X10, V4L2_COLORSPACE_SRGB},
+};
+
+struct rj54n1_clock_div {
+       u8 ratio_tg;    /* can be 0 or an odd number */
+       u8 ratio_t;
+       u8 ratio_r;
+       u8 ratio_op;
+       u8 ratio_o;
+};
+
+struct rj54n1 {
+       struct v4l2_subdev subdev;
+       struct v4l2_ctrl_handler hdl;
+       struct rj54n1_clock_div clk_div;
+       const struct rj54n1_datafmt *fmt;
+       struct v4l2_rect rect;  /* Sensor window */
+       unsigned int tgclk_mhz;
+       bool auto_wb;
+       unsigned short width;   /* Output window */
+       unsigned short height;
+       unsigned short resize;  /* Sensor * 1024 / resize = Output */
+       unsigned short scale;
+       u8 bank;
+};
+
+struct rj54n1_reg_val {
+       u16 reg;
+       u8 val;
+};
+
+static const struct rj54n1_reg_val bank_4[] = {
+       {0x417, 0},
+       {0x42c, 0},
+       {0x42d, 0xf0},
+       {0x42e, 0},
+       {0x42f, 0x50},
+       {0x430, 0xf5},
+       {0x431, 0x16},
+       {0x432, 0x20},
+       {0x433, 0},
+       {0x434, 0xc8},
+       {0x43c, 8},
+       {0x43e, 0x90},
+       {0x445, 0x83},
+       {0x4ba, 0x58},
+       {0x4bb, 4},
+       {0x4bc, 0x20},
+       {0x4db, 4},
+       {0x4fe, 2},
+};
+
+static const struct rj54n1_reg_val bank_5[] = {
+       {0x514, 0},
+       {0x516, 0},
+       {0x518, 0},
+       {0x51a, 0},
+       {0x51d, 0xff},
+       {0x56f, 0x28},
+       {0x575, 0x40},
+       {0x5bc, 0x48},
+       {0x5c1, 6},
+       {0x5e5, 0x11},
+       {0x5e6, 0x43},
+       {0x5e7, 0x33},
+       {0x5e8, 0x21},
+       {0x5e9, 0x30},
+       {0x5ea, 0x0},
+       {0x5eb, 0xa5},
+       {0x5ec, 0xff},
+       {0x5fe, 2},
+};
+
+static const struct rj54n1_reg_val bank_7[] = {
+       {0x70a, 0},
+       {0x714, 0xff},
+       {0x715, 0xff},
+       {0x716, 0x1f},
+       {0x7FE, 2},
+};
+
+static const struct rj54n1_reg_val bank_8[] = {
+       {0x800, 0x00},
+       {0x801, 0x01},
+       {0x802, 0x61},
+       {0x805, 0x00},
+       {0x806, 0x00},
+       {0x807, 0x00},
+       {0x808, 0x00},
+       {0x809, 0x01},
+       {0x80A, 0x61},
+       {0x80B, 0x00},
+       {0x80C, 0x01},
+       {0x80D, 0x00},
+       {0x80E, 0x00},
+       {0x80F, 0x00},
+       {0x810, 0x00},
+       {0x811, 0x01},
+       {0x812, 0x61},
+       {0x813, 0x00},
+       {0x814, 0x11},
+       {0x815, 0x00},
+       {0x816, 0x41},
+       {0x817, 0x00},
+       {0x818, 0x51},
+       {0x819, 0x01},
+       {0x81A, 0x1F},
+       {0x81B, 0x00},
+       {0x81C, 0x01},
+       {0x81D, 0x00},
+       {0x81E, 0x11},
+       {0x81F, 0x00},
+       {0x820, 0x41},
+       {0x821, 0x00},
+       {0x822, 0x51},
+       {0x823, 0x00},
+       {0x824, 0x00},
+       {0x825, 0x00},
+       {0x826, 0x47},
+       {0x827, 0x01},
+       {0x828, 0x4F},
+       {0x829, 0x00},
+       {0x82A, 0x00},
+       {0x82B, 0x00},
+       {0x82C, 0x30},
+       {0x82D, 0x00},
+       {0x82E, 0x40},
+       {0x82F, 0x00},
+       {0x830, 0xB3},
+       {0x831, 0x00},
+       {0x832, 0xE3},
+       {0x833, 0x00},
+       {0x834, 0x00},
+       {0x835, 0x00},
+       {0x836, 0x00},
+       {0x837, 0x00},
+       {0x838, 0x00},
+       {0x839, 0x01},
+       {0x83A, 0x61},
+       {0x83B, 0x00},
+       {0x83C, 0x01},
+       {0x83D, 0x00},
+       {0x83E, 0x00},
+       {0x83F, 0x00},
+       {0x840, 0x00},
+       {0x841, 0x01},
+       {0x842, 0x61},
+       {0x843, 0x00},
+       {0x844, 0x1D},
+       {0x845, 0x00},
+       {0x846, 0x00},
+       {0x847, 0x00},
+       {0x848, 0x00},
+       {0x849, 0x01},
+       {0x84A, 0x1F},
+       {0x84B, 0x00},
+       {0x84C, 0x05},
+       {0x84D, 0x00},
+       {0x84E, 0x19},
+       {0x84F, 0x01},
+       {0x850, 0x21},
+       {0x851, 0x01},
+       {0x852, 0x5D},
+       {0x853, 0x00},
+       {0x854, 0x00},
+       {0x855, 0x00},
+       {0x856, 0x19},
+       {0x857, 0x01},
+       {0x858, 0x21},
+       {0x859, 0x00},
+       {0x85A, 0x00},
+       {0x85B, 0x00},
+       {0x85C, 0x00},
+       {0x85D, 0x00},
+       {0x85E, 0x00},
+       {0x85F, 0x00},
+       {0x860, 0xB3},
+       {0x861, 0x00},
+       {0x862, 0xE3},
+       {0x863, 0x00},
+       {0x864, 0x00},
+       {0x865, 0x00},
+       {0x866, 0x00},
+       {0x867, 0x00},
+       {0x868, 0x00},
+       {0x869, 0xE2},
+       {0x86A, 0x00},
+       {0x86B, 0x01},
+       {0x86C, 0x06},
+       {0x86D, 0x00},
+       {0x86E, 0x00},
+       {0x86F, 0x00},
+       {0x870, 0x60},
+       {0x871, 0x8C},
+       {0x872, 0x10},
+       {0x873, 0x00},
+       {0x874, 0xE0},
+       {0x875, 0x00},
+       {0x876, 0x27},
+       {0x877, 0x01},
+       {0x878, 0x00},
+       {0x879, 0x00},
+       {0x87A, 0x00},
+       {0x87B, 0x03},
+       {0x87C, 0x00},
+       {0x87D, 0x00},
+       {0x87E, 0x00},
+       {0x87F, 0x00},
+       {0x880, 0x00},
+       {0x881, 0x00},
+       {0x882, 0x00},
+       {0x883, 0x00},
+       {0x884, 0x00},
+       {0x885, 0x00},
+       {0x886, 0xF8},
+       {0x887, 0x00},
+       {0x888, 0x03},
+       {0x889, 0x00},
+       {0x88A, 0x64},
+       {0x88B, 0x00},
+       {0x88C, 0x03},
+       {0x88D, 0x00},
+       {0x88E, 0xB1},
+       {0x88F, 0x00},
+       {0x890, 0x03},
+       {0x891, 0x01},
+       {0x892, 0x1D},
+       {0x893, 0x00},
+       {0x894, 0x03},
+       {0x895, 0x01},
+       {0x896, 0x4B},
+       {0x897, 0x00},
+       {0x898, 0xE5},
+       {0x899, 0x00},
+       {0x89A, 0x01},
+       {0x89B, 0x00},
+       {0x89C, 0x01},
+       {0x89D, 0x04},
+       {0x89E, 0xC8},
+       {0x89F, 0x00},
+       {0x8A0, 0x01},
+       {0x8A1, 0x01},
+       {0x8A2, 0x61},
+       {0x8A3, 0x00},
+       {0x8A4, 0x01},
+       {0x8A5, 0x00},
+       {0x8A6, 0x00},
+       {0x8A7, 0x00},
+       {0x8A8, 0x00},
+       {0x8A9, 0x00},
+       {0x8AA, 0x7F},
+       {0x8AB, 0x03},
+       {0x8AC, 0x00},
+       {0x8AD, 0x00},
+       {0x8AE, 0x00},
+       {0x8AF, 0x00},
+       {0x8B0, 0x00},
+       {0x8B1, 0x00},
+       {0x8B6, 0x00},
+       {0x8B7, 0x01},
+       {0x8B8, 0x00},
+       {0x8B9, 0x00},
+       {0x8BA, 0x02},
+       {0x8BB, 0x00},
+       {0x8BC, 0xFF},
+       {0x8BD, 0x00},
+       {0x8FE, 2},
+};
+
+static const struct rj54n1_reg_val bank_10[] = {
+       {0x10bf, 0x69}
+};
+
+/* Clock dividers - these are default register values, divider = register + 1 */
+static const struct rj54n1_clock_div clk_div = {
+       .ratio_tg       = 3 /* default: 5 */,
+       .ratio_t        = 4 /* default: 1 */,
+       .ratio_r        = 4 /* default: 0 */,
+       .ratio_op       = 1 /* default: 5 */,
+       .ratio_o        = 9 /* default: 0 */,
+};
+
+static struct rj54n1 *to_rj54n1(const struct i2c_client *client)
+{
+       return container_of(i2c_get_clientdata(client), struct rj54n1, subdev);
+}
+
+static int reg_read(struct i2c_client *client, const u16 reg)
+{
+       struct rj54n1 *rj54n1 = to_rj54n1(client);
+       int ret;
+
+       /* set bank */
+       if (rj54n1->bank != reg >> 8) {
+               dev_dbg(&client->dev, "[0x%x] = 0x%x\n", 0xff, reg >> 8);
+               ret = i2c_smbus_write_byte_data(client, 0xff, reg >> 8);
+               if (ret < 0)
+                       return ret;
+               rj54n1->bank = reg >> 8;
+       }
+       return i2c_smbus_read_byte_data(client, reg & 0xff);
+}
+
+static int reg_write(struct i2c_client *client, const u16 reg,
+                    const u8 data)
+{
+       struct rj54n1 *rj54n1 = to_rj54n1(client);
+       int ret;
+
+       /* set bank */
+       if (rj54n1->bank != reg >> 8) {
+               dev_dbg(&client->dev, "[0x%x] = 0x%x\n", 0xff, reg >> 8);
+               ret = i2c_smbus_write_byte_data(client, 0xff, reg >> 8);
+               if (ret < 0)
+                       return ret;
+               rj54n1->bank = reg >> 8;
+       }
+       dev_dbg(&client->dev, "[0x%x] = 0x%x\n", reg & 0xff, data);
+       return i2c_smbus_write_byte_data(client, reg & 0xff, data);
+}
+
+static int reg_set(struct i2c_client *client, const u16 reg,
+                  const u8 data, const u8 mask)
+{
+       int ret;
+
+       ret = reg_read(client, reg);
+       if (ret < 0)
+               return ret;
+       return reg_write(client, reg, (ret & ~mask) | (data & mask));
+}
+
+static int reg_write_multiple(struct i2c_client *client,
+                             const struct rj54n1_reg_val *rv, const int n)
+{
+       int i, ret;
+
+       for (i = 0; i < n; i++) {
+               ret = reg_write(client, rv->reg, rv->val);
+               if (ret < 0)
+                       return ret;
+               rv++;
+       }
+
+       return 0;
+}
+
+static int rj54n1_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
+                          enum v4l2_mbus_pixelcode *code)
+{
+       if (index >= ARRAY_SIZE(rj54n1_colour_fmts))
+               return -EINVAL;
+
+       *code = rj54n1_colour_fmts[index].code;
+       return 0;
+}
+
+static int rj54n1_s_stream(struct v4l2_subdev *sd, int enable)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+       /* Switch between preview and still shot modes */
+       return reg_set(client, RJ54N1_STILL_CONTROL, (!enable) << 7, 0x80);
+}
+
+static int rj54n1_set_rect(struct i2c_client *client,
+                          u16 reg_x, u16 reg_y, u16 reg_xy,
+                          u32 width, u32 height)
+{
+       int ret;
+
+       ret = reg_write(client, reg_xy,
+                       ((width >> 4) & 0x70) |
+                       ((height >> 8) & 7));
+
+       if (!ret)
+               ret = reg_write(client, reg_x, width & 0xff);
+       if (!ret)
+               ret = reg_write(client, reg_y, height & 0xff);
+
+       return ret;
+}
+
+/*
+ * Some commands, specifically certain initialisation sequences, require
+ * a commit operation.
+ */
+static int rj54n1_commit(struct i2c_client *client)
+{
+       int ret = reg_write(client, RJ54N1_INIT_START, 1);
+       msleep(10);
+       if (!ret)
+               ret = reg_write(client, RJ54N1_INIT_START, 0);
+       return ret;
+}
+
+static int rj54n1_sensor_scale(struct v4l2_subdev *sd, s32 *in_w, s32 *in_h,
+                              s32 *out_w, s32 *out_h);
+
+static int rj54n1_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct rj54n1 *rj54n1 = to_rj54n1(client);
+       struct v4l2_rect *rect = &a->c;
+       int dummy = 0, output_w, output_h,
+               input_w = rect->width, input_h = rect->height;
+       int ret;
+
+       /* arbitrary minimum width and height, edges unimportant */
+       soc_camera_limit_side(&dummy, &input_w,
+                    RJ54N1_COLUMN_SKIP, 8, RJ54N1_MAX_WIDTH);
+
+       soc_camera_limit_side(&dummy, &input_h,
+                    RJ54N1_ROW_SKIP, 8, RJ54N1_MAX_HEIGHT);
+
+       output_w = (input_w * 1024 + rj54n1->resize / 2) / rj54n1->resize;
+       output_h = (input_h * 1024 + rj54n1->resize / 2) / rj54n1->resize;
+
+       dev_dbg(&client->dev, "Scaling for %dx%d : %u = %dx%d\n",
+               input_w, input_h, rj54n1->resize, output_w, output_h);
+
+       ret = rj54n1_sensor_scale(sd, &input_w, &input_h, &output_w, &output_h);
+       if (ret < 0)
+               return ret;
+
+       rj54n1->width           = output_w;
+       rj54n1->height          = output_h;
+       rj54n1->resize          = ret;
+       rj54n1->rect.width      = input_w;
+       rj54n1->rect.height     = input_h;
+
+       return 0;
+}
+
+static int rj54n1_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct rj54n1 *rj54n1 = to_rj54n1(client);
+
+       a->c    = rj54n1->rect;
+       a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+       return 0;
+}
+
+static int rj54n1_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
+{
+       a->bounds.left                  = RJ54N1_COLUMN_SKIP;
+       a->bounds.top                   = RJ54N1_ROW_SKIP;
+       a->bounds.width                 = RJ54N1_MAX_WIDTH;
+       a->bounds.height                = RJ54N1_MAX_HEIGHT;
+       a->defrect                      = a->bounds;
+       a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+       a->pixelaspect.numerator        = 1;
+       a->pixelaspect.denominator      = 1;
+
+       return 0;
+}
+
+static int rj54n1_g_fmt(struct v4l2_subdev *sd,
+                       struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct rj54n1 *rj54n1 = to_rj54n1(client);
+
+       mf->code        = rj54n1->fmt->code;
+       mf->colorspace  = rj54n1->fmt->colorspace;
+       mf->field       = V4L2_FIELD_NONE;
+       mf->width       = rj54n1->width;
+       mf->height      = rj54n1->height;
+
+       return 0;
+}
+
+/*
+ * The actual geometry configuration routine. It scales the input window into
+ * the output one, updates the window sizes and returns an error or the resize
+ * coefficient on success. Note: we only use the "Fixed Scaling" on this camera.
+ */
+static int rj54n1_sensor_scale(struct v4l2_subdev *sd, s32 *in_w, s32 *in_h,
+                              s32 *out_w, s32 *out_h)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct rj54n1 *rj54n1 = to_rj54n1(client);
+       unsigned int skip, resize, input_w = *in_w, input_h = *in_h,
+               output_w = *out_w, output_h = *out_h;
+       u16 inc_sel, wb_bit8, wb_left, wb_right, wb_top, wb_bottom;
+       unsigned int peak, peak_50, peak_60;
+       int ret;
+
+       /*
+        * We have a problem with crops, where the window is larger than 512x384
+        * and output window is larger than a half of the input one. In this
+        * case we have to either reduce the input window to equal or below
+        * 512x384 or the output window to equal or below 1/2 of the input.
+        */
+       if (output_w > max(512U, input_w / 2)) {
+               if (2 * output_w > RJ54N1_MAX_WIDTH) {
+                       input_w = RJ54N1_MAX_WIDTH;
+                       output_w = RJ54N1_MAX_WIDTH / 2;
+               } else {
+                       input_w = output_w * 2;
+               }
+
+               dev_dbg(&client->dev, "Adjusted output width: in %u, out %u\n",
+                       input_w, output_w);
+       }
+
+       if (output_h > max(384U, input_h / 2)) {
+               if (2 * output_h > RJ54N1_MAX_HEIGHT) {
+                       input_h = RJ54N1_MAX_HEIGHT;
+                       output_h = RJ54N1_MAX_HEIGHT / 2;
+               } else {
+                       input_h = output_h * 2;
+               }
+
+               dev_dbg(&client->dev, "Adjusted output height: in %u, out %u\n",
+                       input_h, output_h);
+       }
+
+       /* Idea: use the read mode for snapshots, handle separate geometries */
+       ret = rj54n1_set_rect(client, RJ54N1_X_OUTPUT_SIZE_S_L,
+                             RJ54N1_Y_OUTPUT_SIZE_S_L,
+                             RJ54N1_XY_OUTPUT_SIZE_S_H, output_w, output_h);
+       if (!ret)
+               ret = rj54n1_set_rect(client, RJ54N1_X_OUTPUT_SIZE_P_L,
+                             RJ54N1_Y_OUTPUT_SIZE_P_L,
+                             RJ54N1_XY_OUTPUT_SIZE_P_H, output_w, output_h);
+
+       if (ret < 0)
+               return ret;
+
+       if (output_w > input_w && output_h > input_h) {
+               input_w = output_w;
+               input_h = output_h;
+
+               resize = 1024;
+       } else {
+               unsigned int resize_x, resize_y;
+               resize_x = (input_w * 1024 + output_w / 2) / output_w;
+               resize_y = (input_h * 1024 + output_h / 2) / output_h;
+
+               /* We want max(resize_x, resize_y), check if it still fits */
+               if (resize_x > resize_y &&
+                   (output_h * resize_x + 512) / 1024 > RJ54N1_MAX_HEIGHT)
+                       resize = (RJ54N1_MAX_HEIGHT * 1024 + output_h / 2) /
+                               output_h;
+               else if (resize_y > resize_x &&
+                        (output_w * resize_y + 512) / 1024 > RJ54N1_MAX_WIDTH)
+                       resize = (RJ54N1_MAX_WIDTH * 1024 + output_w / 2) /
+                               output_w;
+               else
+                       resize = max(resize_x, resize_y);
+
+               /* Prohibited value ranges */
+               switch (resize) {
+               case 2040 ... 2047:
+                       resize = 2039;
+                       break;
+               case 4080 ... 4095:
+                       resize = 4079;
+                       break;
+               case 8160 ... 8191:
+                       resize = 8159;
+                       break;
+               case 16320 ... 16384:
+                       resize = 16319;
+               }
+       }
+
+       /* Set scaling */
+       ret = reg_write(client, RJ54N1_RESIZE_HOLD_L, resize & 0xff);
+       if (!ret)
+               ret = reg_write(client, RJ54N1_RESIZE_HOLD_H, resize >> 8);
+
+       if (ret < 0)
+               return ret;
+
+       /*
+        * Configure a skipping bitmask. The sensor will select a skipping value
+        * among set bits automatically. This is very unclear in the datasheet
+        * too. I was told, in this register one enables all skipping values,
+        * that are required for a specific resize, and the camera selects
+        * automatically, which ones to use. But it is unclear how to identify,
+        * which cropping values are needed. Secondly, why don't we just set all
+        * bits and let the camera choose? Would it increase processing time and
+        * reduce the framerate? Using 0xfffc for INC_USE_SEL doesn't seem to
+        * improve the image quality or stability for larger frames (see comment
+        * above), but I didn't check the framerate.
+        */
+       skip = min(resize / 1024, 15U);
+
+       inc_sel = 1 << skip;
+
+       if (inc_sel <= 2)
+               inc_sel = 0xc;
+       else if (resize & 1023 && skip < 15)
+               inc_sel |= 1 << (skip + 1);
+
+       ret = reg_write(client, RJ54N1_INC_USE_SEL_L, inc_sel & 0xfc);
+       if (!ret)
+               ret = reg_write(client, RJ54N1_INC_USE_SEL_H, inc_sel >> 8);
+
+       if (!rj54n1->auto_wb) {
+               /* Auto white balance window */
+               wb_left   = output_w / 16;
+               wb_right  = (3 * output_w / 4 - 3) / 4;
+               wb_top    = output_h / 16;
+               wb_bottom = (3 * output_h / 4 - 3) / 4;
+               wb_bit8   = ((wb_left >> 2) & 0x40) | ((wb_top >> 4) & 0x10) |
+                       ((wb_right >> 6) & 4) | ((wb_bottom >> 8) & 1);
+
+               if (!ret)
+                       ret = reg_write(client, RJ54N1_BIT8_WB, wb_bit8);
+               if (!ret)
+                       ret = reg_write(client, RJ54N1_HCAPS_WB, wb_left);
+               if (!ret)
+                       ret = reg_write(client, RJ54N1_VCAPS_WB, wb_top);
+               if (!ret)
+                       ret = reg_write(client, RJ54N1_HCAPE_WB, wb_right);
+               if (!ret)
+                       ret = reg_write(client, RJ54N1_VCAPE_WB, wb_bottom);
+       }
+
+       /* Antiflicker */
+       peak = 12 * RJ54N1_MAX_WIDTH * (1 << 14) * resize / rj54n1->tgclk_mhz /
+               10000;
+       peak_50 = peak / 6;
+       peak_60 = peak / 5;
+
+       if (!ret)
+               ret = reg_write(client, RJ54N1_PEAK_H,
+                               ((peak_50 >> 4) & 0xf0) | (peak_60 >> 8));
+       if (!ret)
+               ret = reg_write(client, RJ54N1_PEAK_50, peak_50);
+       if (!ret)
+               ret = reg_write(client, RJ54N1_PEAK_60, peak_60);
+       if (!ret)
+               ret = reg_write(client, RJ54N1_PEAK_DIFF, peak / 150);
+
+       /* Start resizing */
+       if (!ret)
+               ret = reg_write(client, RJ54N1_RESIZE_CONTROL,
+                               RESIZE_HOLD_SEL | RESIZE_GO | 1);
+
+       if (ret < 0)
+               return ret;
+
+       /* Constant taken from manufacturer's example */
+       msleep(230);
+
+       ret = reg_write(client, RJ54N1_RESIZE_CONTROL, RESIZE_HOLD_SEL | 1);
+       if (ret < 0)
+               return ret;
+
+       *in_w = (output_w * resize + 512) / 1024;
+       *in_h = (output_h * resize + 512) / 1024;
+       *out_w = output_w;
+       *out_h = output_h;
+
+       dev_dbg(&client->dev, "Scaled for %dx%d : %u = %ux%u, skip %u\n",
+               *in_w, *in_h, resize, output_w, output_h, skip);
+
+       return resize;
+}
+
+static int rj54n1_set_clock(struct i2c_client *client)
+{
+       struct rj54n1 *rj54n1 = to_rj54n1(client);
+       int ret;
+
+       /* Enable external clock */
+       ret = reg_write(client, RJ54N1_RESET_STANDBY, E_EXCLK | SOFT_STDBY);
+       /* Leave stand-by. Note: use this when implementing suspend / resume */
+       if (!ret)
+               ret = reg_write(client, RJ54N1_RESET_STANDBY, E_EXCLK);
+
+       if (!ret)
+               ret = reg_write(client, RJ54N1_PLL_L, PLL_L);
+       if (!ret)
+               ret = reg_write(client, RJ54N1_PLL_N, PLL_N);
+
+       /* TGCLK dividers */
+       if (!ret)
+               ret = reg_write(client, RJ54N1_RATIO_TG,
+                               rj54n1->clk_div.ratio_tg);
+       if (!ret)
+               ret = reg_write(client, RJ54N1_RATIO_T,
+                               rj54n1->clk_div.ratio_t);
+       if (!ret)
+               ret = reg_write(client, RJ54N1_RATIO_R,
+                               rj54n1->clk_div.ratio_r);
+
+       /* Enable TGCLK & RAMP */
+       if (!ret)
+               ret = reg_write(client, RJ54N1_RAMP_TGCLK_EN, 3);
+
+       /* Disable clock output */
+       if (!ret)
+               ret = reg_write(client, RJ54N1_OCLK_DSP, 0);
+
+       /* Set divisors */
+       if (!ret)
+               ret = reg_write(client, RJ54N1_RATIO_OP,
+                               rj54n1->clk_div.ratio_op);
+       if (!ret)
+               ret = reg_write(client, RJ54N1_RATIO_O,
+                               rj54n1->clk_div.ratio_o);
+
+       /* Enable OCLK */
+       if (!ret)
+               ret = reg_write(client, RJ54N1_OCLK_SEL_EN, 1);
+
+       /* Use PLL for Timing Generator, write 2 to reserved bits */
+       if (!ret)
+               ret = reg_write(client, RJ54N1_TG_BYPASS, 2);
+
+       /* Take sensor out of reset */
+       if (!ret)
+               ret = reg_write(client, RJ54N1_RESET_STANDBY,
+                               E_EXCLK | SEN_RSTX);
+       /* Enable PLL */
+       if (!ret)
+               ret = reg_write(client, RJ54N1_PLL_EN, 1);
+
+       /* Wait for PLL to stabilise */
+       msleep(10);
+
+       /* Enable clock to frequency divider */
+       if (!ret)
+               ret = reg_write(client, RJ54N1_CLK_RST, 1);
+
+       if (!ret)
+               ret = reg_read(client, RJ54N1_CLK_RST);
+       if (ret != 1) {
+               dev_err(&client->dev,
+                       "Resetting RJ54N1CB0C clock failed: %d!\n", ret);
+               return -EIO;
+       }
+
+       /* Start the PLL */
+       ret = reg_set(client, RJ54N1_OCLK_DSP, 1, 1);
+
+       /* Enable OCLK */
+       if (!ret)
+               ret = reg_write(client, RJ54N1_OCLK_SEL_EN, 1);
+
+       return ret;
+}
+
+static int rj54n1_reg_init(struct i2c_client *client)
+{
+       struct rj54n1 *rj54n1 = to_rj54n1(client);
+       int ret = rj54n1_set_clock(client);
+
+       if (!ret)
+               ret = reg_write_multiple(client, bank_7, ARRAY_SIZE(bank_7));
+       if (!ret)
+               ret = reg_write_multiple(client, bank_10, ARRAY_SIZE(bank_10));
+
+       /* Set binning divisors */
+       if (!ret)
+               ret = reg_write(client, RJ54N1_SCALE_1_2_LEV, 3 | (7 << 4));
+       if (!ret)
+               ret = reg_write(client, RJ54N1_SCALE_4_LEV, 0xf);
+
+       /* Switch to fixed resize mode */
+       if (!ret)
+               ret = reg_write(client, RJ54N1_RESIZE_CONTROL,
+                               RESIZE_HOLD_SEL | 1);
+
+       /* Set gain */
+       if (!ret)
+               ret = reg_write(client, RJ54N1_Y_GAIN, 0x84);
+
+       /*
+        * Mirror the image back: default is upside down and left-to-right...
+        * Set manual preview / still shot switching
+        */
+       if (!ret)
+               ret = reg_write(client, RJ54N1_MIRROR_STILL_MODE, 0x27);
+
+       if (!ret)
+               ret = reg_write_multiple(client, bank_4, ARRAY_SIZE(bank_4));
+
+       /* Auto exposure area */
+       if (!ret)
+               ret = reg_write(client, RJ54N1_EXPOSURE_CONTROL, 0x80);
+       /* Check current auto WB config */
+       if (!ret)
+               ret = reg_read(client, RJ54N1_WB_SEL_WEIGHT_I);
+       if (ret >= 0) {
+               rj54n1->auto_wb = ret & 0x80;
+               ret = reg_write_multiple(client, bank_5, ARRAY_SIZE(bank_5));
+       }
+       if (!ret)
+               ret = reg_write_multiple(client, bank_8, ARRAY_SIZE(bank_8));
+
+       if (!ret)
+               ret = reg_write(client, RJ54N1_RESET_STANDBY,
+                               E_EXCLK | DSP_RSTX | SEN_RSTX);
+
+       /* Commit init */
+       if (!ret)
+               ret = rj54n1_commit(client);
+
+       /* Take DSP, TG, sensor out of reset */
+       if (!ret)
+               ret = reg_write(client, RJ54N1_RESET_STANDBY,
+                               E_EXCLK | DSP_RSTX | TG_RSTX | SEN_RSTX);
+
+       /* Start register update? Same register as 0x?FE in many bank_* sets */
+       if (!ret)
+               ret = reg_write(client, RJ54N1_FWFLG, 2);
+
+       /* Constant taken from manufacturer's example */
+       msleep(700);
+
+       return ret;
+}
+
+static int rj54n1_try_fmt(struct v4l2_subdev *sd,
+                         struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct rj54n1 *rj54n1 = to_rj54n1(client);
+       const struct rj54n1_datafmt *fmt;
+       int align = mf->code == V4L2_MBUS_FMT_SBGGR10_1X10 ||
+               mf->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_BE ||
+               mf->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_BE ||
+               mf->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE ||
+               mf->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_LE;
+
+       dev_dbg(&client->dev, "%s: code = %d, width = %u, height = %u\n",
+               __func__, mf->code, mf->width, mf->height);
+
+       fmt = rj54n1_find_datafmt(mf->code, rj54n1_colour_fmts,
+                                 ARRAY_SIZE(rj54n1_colour_fmts));
+       if (!fmt) {
+               fmt = rj54n1->fmt;
+               mf->code = fmt->code;
+       }
+
+       mf->field       = V4L2_FIELD_NONE;
+       mf->colorspace  = fmt->colorspace;
+
+       v4l_bound_align_image(&mf->width, 112, RJ54N1_MAX_WIDTH, align,
+                             &mf->height, 84, RJ54N1_MAX_HEIGHT, align, 0);
+
+       return 0;
+}
+
+static int rj54n1_s_fmt(struct v4l2_subdev *sd,
+                       struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct rj54n1 *rj54n1 = to_rj54n1(client);
+       const struct rj54n1_datafmt *fmt;
+       int output_w, output_h, max_w, max_h,
+               input_w = rj54n1->rect.width, input_h = rj54n1->rect.height;
+       int ret;
+
+       /*
+        * The host driver can call us without .try_fmt(), so, we have to take
+        * care ourseleves
+        */
+       rj54n1_try_fmt(sd, mf);
+
+       /*
+        * Verify if the sensor has just been powered on. TODO: replace this
+        * with proper PM, when a suitable API is available.
+        */
+       ret = reg_read(client, RJ54N1_RESET_STANDBY);
+       if (ret < 0)
+               return ret;
+
+       if (!(ret & E_EXCLK)) {
+               ret = rj54n1_reg_init(client);
+               if (ret < 0)
+                       return ret;
+       }
+
+       dev_dbg(&client->dev, "%s: code = %d, width = %u, height = %u\n",
+               __func__, mf->code, mf->width, mf->height);
+
+       /* RA_SEL_UL is only relevant for raw modes, ignored otherwise. */
+       switch (mf->code) {
+       case V4L2_MBUS_FMT_YUYV8_2X8:
+               ret = reg_write(client, RJ54N1_OUT_SEL, 0);
+               if (!ret)
+                       ret = reg_set(client, RJ54N1_BYTE_SWAP, 8, 8);
+               break;
+       case V4L2_MBUS_FMT_YVYU8_2X8:
+               ret = reg_write(client, RJ54N1_OUT_SEL, 0);
+               if (!ret)
+                       ret = reg_set(client, RJ54N1_BYTE_SWAP, 0, 8);
+               break;
+       case V4L2_MBUS_FMT_RGB565_2X8_LE:
+               ret = reg_write(client, RJ54N1_OUT_SEL, 0x11);
+               if (!ret)
+                       ret = reg_set(client, RJ54N1_BYTE_SWAP, 8, 8);
+               break;
+       case V4L2_MBUS_FMT_RGB565_2X8_BE:
+               ret = reg_write(client, RJ54N1_OUT_SEL, 0x11);
+               if (!ret)
+                       ret = reg_set(client, RJ54N1_BYTE_SWAP, 0, 8);
+               break;
+       case V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_LE:
+               ret = reg_write(client, RJ54N1_OUT_SEL, 4);
+               if (!ret)
+                       ret = reg_set(client, RJ54N1_BYTE_SWAP, 8, 8);
+               if (!ret)
+                       ret = reg_write(client, RJ54N1_RA_SEL_UL, 0);
+               break;
+       case V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE:
+               ret = reg_write(client, RJ54N1_OUT_SEL, 4);
+               if (!ret)
+                       ret = reg_set(client, RJ54N1_BYTE_SWAP, 8, 8);
+               if (!ret)
+                       ret = reg_write(client, RJ54N1_RA_SEL_UL, 8);
+               break;
+       case V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_BE:
+               ret = reg_write(client, RJ54N1_OUT_SEL, 4);
+               if (!ret)
+                       ret = reg_set(client, RJ54N1_BYTE_SWAP, 0, 8);
+               if (!ret)
+                       ret = reg_write(client, RJ54N1_RA_SEL_UL, 0);
+               break;
+       case V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_BE:
+               ret = reg_write(client, RJ54N1_OUT_SEL, 4);
+               if (!ret)
+                       ret = reg_set(client, RJ54N1_BYTE_SWAP, 0, 8);
+               if (!ret)
+                       ret = reg_write(client, RJ54N1_RA_SEL_UL, 8);
+               break;
+       case V4L2_MBUS_FMT_SBGGR10_1X10:
+               ret = reg_write(client, RJ54N1_OUT_SEL, 5);
+               break;
+       default:
+               ret = -EINVAL;
+       }
+
+       /* Special case: a raw mode with 10 bits of data per clock tick */
+       if (!ret)
+               ret = reg_set(client, RJ54N1_OCLK_SEL_EN,
+                             (mf->code == V4L2_MBUS_FMT_SBGGR10_1X10) << 1, 2);
+
+       if (ret < 0)
+               return ret;
+
+       /* Supported scales 1:1 >= scale > 1:16 */
+       max_w = mf->width * (16 * 1024 - 1) / 1024;
+       if (input_w > max_w)
+               input_w = max_w;
+       max_h = mf->height * (16 * 1024 - 1) / 1024;
+       if (input_h > max_h)
+               input_h = max_h;
+
+       output_w = mf->width;
+       output_h = mf->height;
+
+       ret = rj54n1_sensor_scale(sd, &input_w, &input_h, &output_w, &output_h);
+       if (ret < 0)
+               return ret;
+
+       fmt = rj54n1_find_datafmt(mf->code, rj54n1_colour_fmts,
+                                 ARRAY_SIZE(rj54n1_colour_fmts));
+
+       rj54n1->fmt             = fmt;
+       rj54n1->resize          = ret;
+       rj54n1->rect.width      = input_w;
+       rj54n1->rect.height     = input_h;
+       rj54n1->width           = output_w;
+       rj54n1->height          = output_h;
+
+       mf->width               = output_w;
+       mf->height              = output_h;
+       mf->field               = V4L2_FIELD_NONE;
+       mf->colorspace          = fmt->colorspace;
+
+       return 0;
+}
+
+static int rj54n1_g_chip_ident(struct v4l2_subdev *sd,
+                              struct v4l2_dbg_chip_ident *id)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+       if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
+               return -EINVAL;
+
+       if (id->match.addr != client->addr)
+               return -ENODEV;
+
+       id->ident       = V4L2_IDENT_RJ54N1CB0C;
+       id->revision    = 0;
+
+       return 0;
+}
+
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+static int rj54n1_g_register(struct v4l2_subdev *sd,
+                            struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+       if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR ||
+           reg->reg < 0x400 || reg->reg > 0x1fff)
+               /* Registers > 0x0800 are only available from Sharp support */
+               return -EINVAL;
+
+       if (reg->match.addr != client->addr)
+               return -ENODEV;
+
+       reg->size = 1;
+       reg->val = reg_read(client, reg->reg);
+
+       if (reg->val > 0xff)
+               return -EIO;
+
+       return 0;
+}
+
+static int rj54n1_s_register(struct v4l2_subdev *sd,
+                            struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+       if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR ||
+           reg->reg < 0x400 || reg->reg > 0x1fff)
+               /* Registers >= 0x0800 are only available from Sharp support */
+               return -EINVAL;
+
+       if (reg->match.addr != client->addr)
+               return -ENODEV;
+
+       if (reg_write(client, reg->reg, reg->val) < 0)
+               return -EIO;
+
+       return 0;
+}
+#endif
+
+static int rj54n1_s_ctrl(struct v4l2_ctrl *ctrl)
+{
+       struct rj54n1 *rj54n1 = container_of(ctrl->handler, struct rj54n1, hdl);
+       struct v4l2_subdev *sd = &rj54n1->subdev;
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       int data;
+
+       switch (ctrl->id) {
+       case V4L2_CID_VFLIP:
+               if (ctrl->val)
+                       data = reg_set(client, RJ54N1_MIRROR_STILL_MODE, 0, 1);
+               else
+                       data = reg_set(client, RJ54N1_MIRROR_STILL_MODE, 1, 1);
+               if (data < 0)
+                       return -EIO;
+               return 0;
+       case V4L2_CID_HFLIP:
+               if (ctrl->val)
+                       data = reg_set(client, RJ54N1_MIRROR_STILL_MODE, 0, 2);
+               else
+                       data = reg_set(client, RJ54N1_MIRROR_STILL_MODE, 2, 2);
+               if (data < 0)
+                       return -EIO;
+               return 0;
+       case V4L2_CID_GAIN:
+               if (reg_write(client, RJ54N1_Y_GAIN, ctrl->val * 2) < 0)
+                       return -EIO;
+               return 0;
+       case V4L2_CID_AUTO_WHITE_BALANCE:
+               /* Auto WB area - whole image */
+               if (reg_set(client, RJ54N1_WB_SEL_WEIGHT_I, ctrl->val << 7,
+                           0x80) < 0)
+                       return -EIO;
+               rj54n1->auto_wb = ctrl->val;
+               return 0;
+       }
+
+       return -EINVAL;
+}
+
+static const struct v4l2_ctrl_ops rj54n1_ctrl_ops = {
+       .s_ctrl = rj54n1_s_ctrl,
+};
+
+static struct v4l2_subdev_core_ops rj54n1_subdev_core_ops = {
+       .g_chip_ident   = rj54n1_g_chip_ident,
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+       .g_register     = rj54n1_g_register,
+       .s_register     = rj54n1_s_register,
+#endif
+};
+
+static int rj54n1_g_mbus_config(struct v4l2_subdev *sd,
+                               struct v4l2_mbus_config *cfg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+
+       cfg->flags =
+               V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_PCLK_SAMPLE_FALLING |
+               V4L2_MBUS_MASTER | V4L2_MBUS_DATA_ACTIVE_HIGH |
+               V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_HIGH;
+       cfg->type = V4L2_MBUS_PARALLEL;
+       cfg->flags = soc_camera_apply_board_flags(icl, cfg);
+
+       return 0;
+}
+
+static int rj54n1_s_mbus_config(struct v4l2_subdev *sd,
+                               const struct v4l2_mbus_config *cfg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+
+       /* Figures 2.5-1 to 2.5-3 - default falling pixclk edge */
+       if (soc_camera_apply_board_flags(icl, cfg) &
+           V4L2_MBUS_PCLK_SAMPLE_RISING)
+               return reg_write(client, RJ54N1_OUT_SIGPO, 1 << 4);
+       else
+               return reg_write(client, RJ54N1_OUT_SIGPO, 0);
+}
+
+static struct v4l2_subdev_video_ops rj54n1_subdev_video_ops = {
+       .s_stream       = rj54n1_s_stream,
+       .s_mbus_fmt     = rj54n1_s_fmt,
+       .g_mbus_fmt     = rj54n1_g_fmt,
+       .try_mbus_fmt   = rj54n1_try_fmt,
+       .enum_mbus_fmt  = rj54n1_enum_fmt,
+       .g_crop         = rj54n1_g_crop,
+       .s_crop         = rj54n1_s_crop,
+       .cropcap        = rj54n1_cropcap,
+       .g_mbus_config  = rj54n1_g_mbus_config,
+       .s_mbus_config  = rj54n1_s_mbus_config,
+};
+
+static struct v4l2_subdev_ops rj54n1_subdev_ops = {
+       .core   = &rj54n1_subdev_core_ops,
+       .video  = &rj54n1_subdev_video_ops,
+};
+
+/*
+ * Interface active, can use i2c. If it fails, it can indeed mean, that
+ * this wasn't our capture interface, so, we wait for the right one
+ */
+static int rj54n1_video_probe(struct i2c_client *client,
+                             struct rj54n1_pdata *priv)
+{
+       int data1, data2;
+       int ret;
+
+       /* Read out the chip version register */
+       data1 = reg_read(client, RJ54N1_DEV_CODE);
+       data2 = reg_read(client, RJ54N1_DEV_CODE2);
+
+       if (data1 != 0x51 || data2 != 0x10) {
+               ret = -ENODEV;
+               dev_info(&client->dev, "No RJ54N1CB0C found, read 0x%x:0x%x\n",
+                        data1, data2);
+               goto ei2c;
+       }
+
+       /* Configure IOCTL polarity from the platform data: 0 or 1 << 7. */
+       ret = reg_write(client, RJ54N1_IOC, priv->ioctl_high << 7);
+       if (ret < 0)
+               goto ei2c;
+
+       dev_info(&client->dev, "Detected a RJ54N1CB0C chip ID 0x%x:0x%x\n",
+                data1, data2);
+
+ei2c:
+       return ret;
+}
+
+static int rj54n1_probe(struct i2c_client *client,
+                       const struct i2c_device_id *did)
+{
+       struct rj54n1 *rj54n1;
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+       struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
+       struct rj54n1_pdata *rj54n1_priv;
+       int ret;
+
+       if (!icl || !icl->priv) {
+               dev_err(&client->dev, "RJ54N1CB0C: missing platform data!\n");
+               return -EINVAL;
+       }
+
+       rj54n1_priv = icl->priv;
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
+               dev_warn(&adapter->dev,
+                        "I2C-Adapter doesn't support I2C_FUNC_SMBUS_BYTE\n");
+               return -EIO;
+       }
+
+       rj54n1 = kzalloc(sizeof(struct rj54n1), GFP_KERNEL);
+       if (!rj54n1)
+               return -ENOMEM;
+
+       v4l2_i2c_subdev_init(&rj54n1->subdev, client, &rj54n1_subdev_ops);
+       v4l2_ctrl_handler_init(&rj54n1->hdl, 4);
+       v4l2_ctrl_new_std(&rj54n1->hdl, &rj54n1_ctrl_ops,
+                       V4L2_CID_VFLIP, 0, 1, 1, 0);
+       v4l2_ctrl_new_std(&rj54n1->hdl, &rj54n1_ctrl_ops,
+                       V4L2_CID_HFLIP, 0, 1, 1, 0);
+       v4l2_ctrl_new_std(&rj54n1->hdl, &rj54n1_ctrl_ops,
+                       V4L2_CID_GAIN, 0, 127, 1, 66);
+       v4l2_ctrl_new_std(&rj54n1->hdl, &rj54n1_ctrl_ops,
+                       V4L2_CID_AUTO_WHITE_BALANCE, 0, 1, 1, 1);
+       rj54n1->subdev.ctrl_handler = &rj54n1->hdl;
+       if (rj54n1->hdl.error) {
+               int err = rj54n1->hdl.error;
+
+               kfree(rj54n1);
+               return err;
+       }
+
+       rj54n1->clk_div         = clk_div;
+       rj54n1->rect.left       = RJ54N1_COLUMN_SKIP;
+       rj54n1->rect.top        = RJ54N1_ROW_SKIP;
+       rj54n1->rect.width      = RJ54N1_MAX_WIDTH;
+       rj54n1->rect.height     = RJ54N1_MAX_HEIGHT;
+       rj54n1->width           = RJ54N1_MAX_WIDTH;
+       rj54n1->height          = RJ54N1_MAX_HEIGHT;
+       rj54n1->fmt             = &rj54n1_colour_fmts[0];
+       rj54n1->resize          = 1024;
+       rj54n1->tgclk_mhz       = (rj54n1_priv->mclk_freq / PLL_L * PLL_N) /
+               (clk_div.ratio_tg + 1) / (clk_div.ratio_t + 1);
+
+       ret = rj54n1_video_probe(client, rj54n1_priv);
+       if (ret < 0) {
+               v4l2_ctrl_handler_free(&rj54n1->hdl);
+               kfree(rj54n1);
+               return ret;
+       }
+       return v4l2_ctrl_handler_setup(&rj54n1->hdl);
+}
+
+static int rj54n1_remove(struct i2c_client *client)
+{
+       struct rj54n1 *rj54n1 = to_rj54n1(client);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+
+       v4l2_device_unregister_subdev(&rj54n1->subdev);
+       if (icl->free_bus)
+               icl->free_bus(icl);
+       v4l2_ctrl_handler_free(&rj54n1->hdl);
+       kfree(rj54n1);
+
+       return 0;
+}
+
+static const struct i2c_device_id rj54n1_id[] = {
+       { "rj54n1cb0c", 0 },
+       { }
+};
+MODULE_DEVICE_TABLE(i2c, rj54n1_id);
+
+static struct i2c_driver rj54n1_i2c_driver = {
+       .driver = {
+               .name = "rj54n1cb0c",
+       },
+       .probe          = rj54n1_probe,
+       .remove         = rj54n1_remove,
+       .id_table       = rj54n1_id,
+};
+
+module_i2c_driver(rj54n1_i2c_driver);
+
+MODULE_DESCRIPTION("Sharp RJ54N1CB0C Camera driver");
+MODULE_AUTHOR("Guennadi Liakhovetski <g.liakhovetski@gmx.de>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/i2c/soc_camera/sh_mobile_csi2.c b/drivers/media/i2c/soc_camera/sh_mobile_csi2.c
new file mode 100644 (file)
index 0000000..0528650
--- /dev/null
@@ -0,0 +1,398 @@
+/*
+ * Driver for the SH-Mobile MIPI CSI-2 unit
+ *
+ * Copyright (C) 2010, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
+#include <linux/slab.h>
+#include <linux/videodev2.h>
+#include <linux/module.h>
+
+#include <media/sh_mobile_ceu.h>
+#include <media/sh_mobile_csi2.h>
+#include <media/soc_camera.h>
+#include <media/soc_mediabus.h>
+#include <media/v4l2-common.h>
+#include <media/v4l2-dev.h>
+#include <media/v4l2-device.h>
+#include <media/v4l2-mediabus.h>
+#include <media/v4l2-subdev.h>
+
+#define SH_CSI2_TREF   0x00
+#define SH_CSI2_SRST   0x04
+#define SH_CSI2_PHYCNT 0x08
+#define SH_CSI2_CHKSUM 0x0C
+#define SH_CSI2_VCDT   0x10
+
+struct sh_csi2 {
+       struct v4l2_subdev              subdev;
+       struct list_head                list;
+       unsigned int                    irq;
+       unsigned long                   mipi_flags;
+       void __iomem                    *base;
+       struct platform_device          *pdev;
+       struct sh_csi2_client_config    *client;
+};
+
+static int sh_csi2_try_fmt(struct v4l2_subdev *sd,
+                          struct v4l2_mbus_framefmt *mf)
+{
+       struct sh_csi2 *priv = container_of(sd, struct sh_csi2, subdev);
+       struct sh_csi2_pdata *pdata = priv->pdev->dev.platform_data;
+
+       if (mf->width > 8188)
+               mf->width = 8188;
+       else if (mf->width & 1)
+               mf->width &= ~1;
+
+       switch (pdata->type) {
+       case SH_CSI2C:
+               switch (mf->code) {
+               case V4L2_MBUS_FMT_UYVY8_2X8:           /* YUV422 */
+               case V4L2_MBUS_FMT_YUYV8_1_5X8:         /* YUV420 */
+               case V4L2_MBUS_FMT_Y8_1X8:              /* RAW8 */
+               case V4L2_MBUS_FMT_SBGGR8_1X8:
+               case V4L2_MBUS_FMT_SGRBG8_1X8:
+                       break;
+               default:
+                       /* All MIPI CSI-2 devices must support one of primary formats */
+                       mf->code = V4L2_MBUS_FMT_YUYV8_2X8;
+               }
+               break;
+       case SH_CSI2I:
+               switch (mf->code) {
+               case V4L2_MBUS_FMT_Y8_1X8:              /* RAW8 */
+               case V4L2_MBUS_FMT_SBGGR8_1X8:
+               case V4L2_MBUS_FMT_SGRBG8_1X8:
+               case V4L2_MBUS_FMT_SBGGR10_1X10:        /* RAW10 */
+               case V4L2_MBUS_FMT_SBGGR12_1X12:        /* RAW12 */
+                       break;
+               default:
+                       /* All MIPI CSI-2 devices must support one of primary formats */
+                       mf->code = V4L2_MBUS_FMT_SBGGR8_1X8;
+               }
+               break;
+       }
+
+       return 0;
+}
+
+/*
+ * We have done our best in try_fmt to try and tell the sensor, which formats
+ * we support. If now the configuration is unsuitable for us we can only
+ * error out.
+ */
+static int sh_csi2_s_fmt(struct v4l2_subdev *sd,
+                        struct v4l2_mbus_framefmt *mf)
+{
+       struct sh_csi2 *priv = container_of(sd, struct sh_csi2, subdev);
+       u32 tmp = (priv->client->channel & 3) << 8;
+
+       dev_dbg(sd->v4l2_dev->dev, "%s(%u)\n", __func__, mf->code);
+       if (mf->width > 8188 || mf->width & 1)
+               return -EINVAL;
+
+       switch (mf->code) {
+       case V4L2_MBUS_FMT_UYVY8_2X8:
+               tmp |= 0x1e;    /* YUV422 8 bit */
+               break;
+       case V4L2_MBUS_FMT_YUYV8_1_5X8:
+               tmp |= 0x18;    /* YUV420 8 bit */
+               break;
+       case V4L2_MBUS_FMT_RGB555_2X8_PADHI_BE:
+               tmp |= 0x21;    /* RGB555 */
+               break;
+       case V4L2_MBUS_FMT_RGB565_2X8_BE:
+               tmp |= 0x22;    /* RGB565 */
+               break;
+       case V4L2_MBUS_FMT_Y8_1X8:
+       case V4L2_MBUS_FMT_SBGGR8_1X8:
+       case V4L2_MBUS_FMT_SGRBG8_1X8:
+               tmp |= 0x2a;    /* RAW8 */
+               break;
+       default:
+               return -EINVAL;
+       }
+
+       iowrite32(tmp, priv->base + SH_CSI2_VCDT);
+
+       return 0;
+}
+
+static int sh_csi2_g_mbus_config(struct v4l2_subdev *sd,
+                                struct v4l2_mbus_config *cfg)
+{
+       cfg->flags = V4L2_MBUS_PCLK_SAMPLE_RISING |
+               V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_HIGH |
+               V4L2_MBUS_MASTER | V4L2_MBUS_DATA_ACTIVE_HIGH;
+       cfg->type = V4L2_MBUS_PARALLEL;
+
+       return 0;
+}
+
+static int sh_csi2_s_mbus_config(struct v4l2_subdev *sd,
+                                const struct v4l2_mbus_config *cfg)
+{
+       struct sh_csi2 *priv = container_of(sd, struct sh_csi2, subdev);
+       struct soc_camera_device *icd = v4l2_get_subdev_hostdata(sd);
+       struct v4l2_subdev *client_sd = soc_camera_to_subdev(icd);
+       struct v4l2_mbus_config client_cfg = {.type = V4L2_MBUS_CSI2,
+                                             .flags = priv->mipi_flags};
+
+       return v4l2_subdev_call(client_sd, video, s_mbus_config, &client_cfg);
+}
+
+static struct v4l2_subdev_video_ops sh_csi2_subdev_video_ops = {
+       .s_mbus_fmt     = sh_csi2_s_fmt,
+       .try_mbus_fmt   = sh_csi2_try_fmt,
+       .g_mbus_config  = sh_csi2_g_mbus_config,
+       .s_mbus_config  = sh_csi2_s_mbus_config,
+};
+
+static void sh_csi2_hwinit(struct sh_csi2 *priv)
+{
+       struct sh_csi2_pdata *pdata = priv->pdev->dev.platform_data;
+       __u32 tmp = 0x10; /* Enable MIPI CSI clock lane */
+
+       /* Reflect registers immediately */
+       iowrite32(0x00000001, priv->base + SH_CSI2_TREF);
+       /* reset CSI2 harware */
+       iowrite32(0x00000001, priv->base + SH_CSI2_SRST);
+       udelay(5);
+       iowrite32(0x00000000, priv->base + SH_CSI2_SRST);
+
+       switch (pdata->type) {
+       case SH_CSI2C:
+               if (priv->client->lanes == 1)
+                       tmp |= 1;
+               else
+                       /* Default - both lanes */
+                       tmp |= 3;
+               break;
+       case SH_CSI2I:
+               if (!priv->client->lanes || priv->client->lanes > 4)
+                       /* Default - all 4 lanes */
+                       tmp |= 0xf;
+               else
+                       tmp |= (1 << priv->client->lanes) - 1;
+       }
+
+       if (priv->client->phy == SH_CSI2_PHY_MAIN)
+               tmp |= 0x8000;
+
+       iowrite32(tmp, priv->base + SH_CSI2_PHYCNT);
+
+       tmp = 0;
+       if (pdata->flags & SH_CSI2_ECC)
+               tmp |= 2;
+       if (pdata->flags & SH_CSI2_CRC)
+               tmp |= 1;
+       iowrite32(tmp, priv->base + SH_CSI2_CHKSUM);
+}
+
+static int sh_csi2_client_connect(struct sh_csi2 *priv)
+{
+       struct sh_csi2_pdata *pdata = priv->pdev->dev.platform_data;
+       struct soc_camera_device *icd = v4l2_get_subdev_hostdata(&priv->subdev);
+       struct v4l2_subdev *client_sd = soc_camera_to_subdev(icd);
+       struct device *dev = v4l2_get_subdevdata(&priv->subdev);
+       struct v4l2_mbus_config cfg;
+       unsigned long common_flags, csi2_flags;
+       int i, ret;
+
+       if (priv->client)
+               return -EBUSY;
+
+       for (i = 0; i < pdata->num_clients; i++)
+               if (&pdata->clients[i].pdev->dev == icd->pdev)
+                       break;
+
+       dev_dbg(dev, "%s(%p): found #%d\n", __func__, dev, i);
+
+       if (i == pdata->num_clients)
+               return -ENODEV;
+
+       /* Check if we can support this camera */
+       csi2_flags = V4L2_MBUS_CSI2_CONTINUOUS_CLOCK | V4L2_MBUS_CSI2_1_LANE;
+
+       switch (pdata->type) {
+       case SH_CSI2C:
+               if (pdata->clients[i].lanes != 1)
+                       csi2_flags |= V4L2_MBUS_CSI2_2_LANE;
+               break;
+       case SH_CSI2I:
+               switch (pdata->clients[i].lanes) {
+               default:
+                       csi2_flags |= V4L2_MBUS_CSI2_4_LANE;
+               case 3:
+                       csi2_flags |= V4L2_MBUS_CSI2_3_LANE;
+               case 2:
+                       csi2_flags |= V4L2_MBUS_CSI2_2_LANE;
+               }
+       }
+
+       cfg.type = V4L2_MBUS_CSI2;
+       ret = v4l2_subdev_call(client_sd, video, g_mbus_config, &cfg);
+       if (ret == -ENOIOCTLCMD)
+               common_flags = csi2_flags;
+       else if (!ret)
+               common_flags = soc_mbus_config_compatible(&cfg,
+                                                         csi2_flags);
+       else
+               common_flags = 0;
+
+       if (!common_flags)
+               return -EINVAL;
+
+       /* All good: camera MIPI configuration supported */
+       priv->mipi_flags = common_flags;
+       priv->client = pdata->clients + i;
+
+       pm_runtime_get_sync(dev);
+
+       sh_csi2_hwinit(priv);
+
+       return 0;
+}
+
+static void sh_csi2_client_disconnect(struct sh_csi2 *priv)
+{
+       if (!priv->client)
+               return;
+
+       priv->client = NULL;
+
+       pm_runtime_put(v4l2_get_subdevdata(&priv->subdev));
+}
+
+static int sh_csi2_s_power(struct v4l2_subdev *sd, int on)
+{
+       struct sh_csi2 *priv = container_of(sd, struct sh_csi2, subdev);
+
+       if (on)
+               return sh_csi2_client_connect(priv);
+
+       sh_csi2_client_disconnect(priv);
+       return 0;
+}
+
+static struct v4l2_subdev_core_ops sh_csi2_subdev_core_ops = {
+       .s_power        = sh_csi2_s_power,
+};
+
+static struct v4l2_subdev_ops sh_csi2_subdev_ops = {
+       .core   = &sh_csi2_subdev_core_ops,
+       .video  = &sh_csi2_subdev_video_ops,
+};
+
+static __devinit int sh_csi2_probe(struct platform_device *pdev)
+{
+       struct resource *res;
+       unsigned int irq;
+       int ret;
+       struct sh_csi2 *priv;
+       /* Platform data specify the PHY, lanes, ECC, CRC */
+       struct sh_csi2_pdata *pdata = pdev->dev.platform_data;
+
+       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+       /* Interrupt unused so far */
+       irq = platform_get_irq(pdev, 0);
+
+       if (!res || (int)irq <= 0 || !pdata) {
+               dev_err(&pdev->dev, "Not enough CSI2 platform resources.\n");
+               return -ENODEV;
+       }
+
+       /* TODO: Add support for CSI2I. Careful: different register layout! */
+       if (pdata->type != SH_CSI2C) {
+               dev_err(&pdev->dev, "Only CSI2C supported ATM.\n");
+               return -EINVAL;
+       }
+
+       priv = kzalloc(sizeof(struct sh_csi2), GFP_KERNEL);
+       if (!priv)
+               return -ENOMEM;
+
+       priv->irq = irq;
+
+       if (!request_mem_region(res->start, resource_size(res), pdev->name)) {
+               dev_err(&pdev->dev, "CSI2 register region already claimed\n");
+               ret = -EBUSY;
+               goto ereqreg;
+       }
+
+       priv->base = ioremap(res->start, resource_size(res));
+       if (!priv->base) {
+               ret = -ENXIO;
+               dev_err(&pdev->dev, "Unable to ioremap CSI2 registers.\n");
+               goto eremap;
+       }
+
+       priv->pdev = pdev;
+       platform_set_drvdata(pdev, priv);
+
+       v4l2_subdev_init(&priv->subdev, &sh_csi2_subdev_ops);
+       v4l2_set_subdevdata(&priv->subdev, &pdev->dev);
+
+       snprintf(priv->subdev.name, V4L2_SUBDEV_NAME_SIZE, "%s.mipi-csi",
+                dev_name(pdata->v4l2_dev->dev));
+       ret = v4l2_device_register_subdev(pdata->v4l2_dev, &priv->subdev);
+       dev_dbg(&pdev->dev, "%s(%p): ret(register_subdev) = %d\n", __func__, priv, ret);
+       if (ret < 0)
+               goto esdreg;
+
+       pm_runtime_enable(&pdev->dev);
+
+       dev_dbg(&pdev->dev, "CSI2 probed.\n");
+
+       return 0;
+
+esdreg:
+       iounmap(priv->base);
+eremap:
+       release_mem_region(res->start, resource_size(res));
+ereqreg:
+       kfree(priv);
+
+       return ret;
+}
+
+static __devexit int sh_csi2_remove(struct platform_device *pdev)
+{
+       struct sh_csi2 *priv = platform_get_drvdata(pdev);
+       struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+
+       v4l2_device_unregister_subdev(&priv->subdev);
+       pm_runtime_disable(&pdev->dev);
+       iounmap(priv->base);
+       release_mem_region(res->start, resource_size(res));
+       platform_set_drvdata(pdev, NULL);
+       kfree(priv);
+
+       return 0;
+}
+
+static struct platform_driver __refdata sh_csi2_pdrv = {
+       .remove = __devexit_p(sh_csi2_remove),
+       .probe  = sh_csi2_probe,
+       .driver = {
+               .name   = "sh-mobile-csi2",
+               .owner  = THIS_MODULE,
+       },
+};
+
+module_platform_driver(sh_csi2_pdrv);
+
+MODULE_DESCRIPTION("SH-Mobile MIPI CSI-2 driver");
+MODULE_AUTHOR("Guennadi Liakhovetski <g.liakhovetski@gmx.de>");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:sh-mobile-csi2");
diff --git a/drivers/media/i2c/soc_camera/soc_camera.c b/drivers/media/i2c/soc_camera/soc_camera.c
new file mode 100644 (file)
index 0000000..9758217
--- /dev/null
@@ -0,0 +1,1554 @@
+/*
+ * camera image capture (abstract) bus driver
+ *
+ * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
+ *
+ * This driver provides an interface between platform-specific camera
+ * busses and camera devices. It should be used if the camera is
+ * connected not over a "proper" bus like PCI or USB, but over a
+ * special bus, like, for example, the Quick Capture interface on PXA270
+ * SoCs. Later it should also be used for i.MX31 SoCs from Freescale.
+ * It can handle multiple cameras and / or multiple busses, which can
+ * be used, e.g., in stereo-vision applications.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/i2c.h>
+#include <linux/init.h>
+#include <linux/list.h>
+#include <linux/mutex.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/consumer.h>
+#include <linux/slab.h>
+#include <linux/pm_runtime.h>
+#include <linux/vmalloc.h>
+
+#include <media/soc_camera.h>
+#include <media/v4l2-common.h>
+#include <media/v4l2-ioctl.h>
+#include <media/v4l2-dev.h>
+#include <media/videobuf-core.h>
+#include <media/videobuf2-core.h>
+#include <media/soc_mediabus.h>
+
+/* Default to VGA resolution */
+#define DEFAULT_WIDTH  640
+#define DEFAULT_HEIGHT 480
+
+#define is_streaming(ici, icd)                         \
+       (((ici)->ops->init_videobuf) ?                  \
+        (icd)->vb_vidq.streaming :                     \
+        vb2_is_streaming(&(icd)->vb2_vidq))
+
+static LIST_HEAD(hosts);
+static LIST_HEAD(devices);
+static DEFINE_MUTEX(list_lock);                /* Protects the list of hosts */
+
+static int soc_camera_power_on(struct soc_camera_device *icd,
+                              struct soc_camera_link *icl)
+{
+       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+       int ret = regulator_bulk_enable(icl->num_regulators,
+                                       icl->regulators);
+       if (ret < 0) {
+               dev_err(icd->pdev, "Cannot enable regulators\n");
+               return ret;
+       }
+
+       if (icl->power) {
+               ret = icl->power(icd->control, 1);
+               if (ret < 0) {
+                       dev_err(icd->pdev,
+                               "Platform failed to power-on the camera.\n");
+                       goto elinkpwr;
+               }
+       }
+
+       ret = v4l2_subdev_call(sd, core, s_power, 1);
+       if (ret < 0 && ret != -ENOIOCTLCMD && ret != -ENODEV)
+               goto esdpwr;
+
+       return 0;
+
+esdpwr:
+       if (icl->power)
+               icl->power(icd->control, 0);
+elinkpwr:
+       regulator_bulk_disable(icl->num_regulators,
+                              icl->regulators);
+       return ret;
+}
+
+static int soc_camera_power_off(struct soc_camera_device *icd,
+                               struct soc_camera_link *icl)
+{
+       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+       int ret = v4l2_subdev_call(sd, core, s_power, 0);
+
+       if (ret < 0 && ret != -ENOIOCTLCMD && ret != -ENODEV)
+               return ret;
+
+       if (icl->power) {
+               ret = icl->power(icd->control, 0);
+               if (ret < 0) {
+                       dev_err(icd->pdev,
+                               "Platform failed to power-off the camera.\n");
+                       return ret;
+               }
+       }
+
+       ret = regulator_bulk_disable(icl->num_regulators,
+                                    icl->regulators);
+       if (ret < 0)
+               dev_err(icd->pdev, "Cannot disable regulators\n");
+
+       return ret;
+}
+
+const struct soc_camera_format_xlate *soc_camera_xlate_by_fourcc(
+       struct soc_camera_device *icd, unsigned int fourcc)
+{
+       unsigned int i;
+
+       for (i = 0; i < icd->num_user_formats; i++)
+               if (icd->user_formats[i].host_fmt->fourcc == fourcc)
+                       return icd->user_formats + i;
+       return NULL;
+}
+EXPORT_SYMBOL(soc_camera_xlate_by_fourcc);
+
+/**
+ * soc_camera_apply_board_flags() - apply platform SOCAM_SENSOR_INVERT_* flags
+ * @icl:       camera platform parameters
+ * @cfg:       media bus configuration
+ * @return:    resulting flags
+ */
+unsigned long soc_camera_apply_board_flags(struct soc_camera_link *icl,
+                                          const struct v4l2_mbus_config *cfg)
+{
+       unsigned long f, flags = cfg->flags;
+
+       /* If only one of the two polarities is supported, switch to the opposite */
+       if (icl->flags & SOCAM_SENSOR_INVERT_HSYNC) {
+               f = flags & (V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_HSYNC_ACTIVE_LOW);
+               if (f == V4L2_MBUS_HSYNC_ACTIVE_HIGH || f == V4L2_MBUS_HSYNC_ACTIVE_LOW)
+                       flags ^= V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_HSYNC_ACTIVE_LOW;
+       }
+
+       if (icl->flags & SOCAM_SENSOR_INVERT_VSYNC) {
+               f = flags & (V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_LOW);
+               if (f == V4L2_MBUS_VSYNC_ACTIVE_HIGH || f == V4L2_MBUS_VSYNC_ACTIVE_LOW)
+                       flags ^= V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_LOW;
+       }
+
+       if (icl->flags & SOCAM_SENSOR_INVERT_PCLK) {
+               f = flags & (V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_PCLK_SAMPLE_FALLING);
+               if (f == V4L2_MBUS_PCLK_SAMPLE_RISING || f == V4L2_MBUS_PCLK_SAMPLE_FALLING)
+                       flags ^= V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_PCLK_SAMPLE_FALLING;
+       }
+
+       return flags;
+}
+EXPORT_SYMBOL(soc_camera_apply_board_flags);
+
+#define pixfmtstr(x) (x) & 0xff, ((x) >> 8) & 0xff, ((x) >> 16) & 0xff, \
+       ((x) >> 24) & 0xff
+
+static int soc_camera_try_fmt(struct soc_camera_device *icd,
+                             struct v4l2_format *f)
+{
+       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+       const struct soc_camera_format_xlate *xlate;
+       struct v4l2_pix_format *pix = &f->fmt.pix;
+       int ret;
+
+       dev_dbg(icd->pdev, "TRY_FMT(%c%c%c%c, %ux%u)\n",
+               pixfmtstr(pix->pixelformat), pix->width, pix->height);
+
+       if (!(ici->capabilities & SOCAM_HOST_CAP_STRIDE)) {
+               pix->bytesperline = 0;
+               pix->sizeimage = 0;
+       }
+
+       ret = ici->ops->try_fmt(icd, f);
+       if (ret < 0)
+               return ret;
+
+       xlate = soc_camera_xlate_by_fourcc(icd, pix->pixelformat);
+       if (!xlate)
+               return -EINVAL;
+
+       ret = soc_mbus_bytes_per_line(pix->width, xlate->host_fmt);
+       if (ret < 0)
+               return ret;
+
+       pix->bytesperline = max_t(u32, pix->bytesperline, ret);
+
+       ret = soc_mbus_image_size(xlate->host_fmt, pix->bytesperline,
+                                 pix->height);
+       if (ret < 0)
+               return ret;
+
+       pix->sizeimage = max_t(u32, pix->sizeimage, ret);
+
+       return 0;
+}
+
+static int soc_camera_try_fmt_vid_cap(struct file *file, void *priv,
+                                     struct v4l2_format *f)
+{
+       struct soc_camera_device *icd = file->private_data;
+
+       WARN_ON(priv != file->private_data);
+
+       /* Only single-plane capture is supported so far */
+       if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+               return -EINVAL;
+
+       /* limit format to hardware capabilities */
+       return soc_camera_try_fmt(icd, f);
+}
+
+static int soc_camera_enum_input(struct file *file, void *priv,
+                                struct v4l2_input *inp)
+{
+       if (inp->index != 0)
+               return -EINVAL;
+
+       /* default is camera */
+       inp->type = V4L2_INPUT_TYPE_CAMERA;
+       inp->std  = V4L2_STD_UNKNOWN;
+       strcpy(inp->name, "Camera");
+
+       return 0;
+}
+
+static int soc_camera_g_input(struct file *file, void *priv, unsigned int *i)
+{
+       *i = 0;
+
+       return 0;
+}
+
+static int soc_camera_s_input(struct file *file, void *priv, unsigned int i)
+{
+       if (i > 0)
+               return -EINVAL;
+
+       return 0;
+}
+
+static int soc_camera_s_std(struct file *file, void *priv, v4l2_std_id *a)
+{
+       struct soc_camera_device *icd = file->private_data;
+       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+
+       return v4l2_subdev_call(sd, core, s_std, *a);
+}
+
+static int soc_camera_g_std(struct file *file, void *priv, v4l2_std_id *a)
+{
+       struct soc_camera_device *icd = file->private_data;
+       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+
+       return v4l2_subdev_call(sd, core, g_std, a);
+}
+
+static int soc_camera_enum_framesizes(struct file *file, void *fh,
+                                        struct v4l2_frmsizeenum *fsize)
+{
+       struct soc_camera_device *icd = file->private_data;
+       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+
+       return ici->ops->enum_framesizes(icd, fsize);
+}
+
+static int soc_camera_reqbufs(struct file *file, void *priv,
+                             struct v4l2_requestbuffers *p)
+{
+       int ret;
+       struct soc_camera_device *icd = file->private_data;
+       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+
+       WARN_ON(priv != file->private_data);
+
+       if (icd->streamer && icd->streamer != file)
+               return -EBUSY;
+
+       if (ici->ops->init_videobuf) {
+               ret = videobuf_reqbufs(&icd->vb_vidq, p);
+               if (ret < 0)
+                       return ret;
+
+               ret = ici->ops->reqbufs(icd, p);
+       } else {
+               ret = vb2_reqbufs(&icd->vb2_vidq, p);
+       }
+
+       if (!ret && !icd->streamer)
+               icd->streamer = file;
+
+       return ret;
+}
+
+static int soc_camera_querybuf(struct file *file, void *priv,
+                              struct v4l2_buffer *p)
+{
+       struct soc_camera_device *icd = file->private_data;
+       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+
+       WARN_ON(priv != file->private_data);
+
+       if (ici->ops->init_videobuf)
+               return videobuf_querybuf(&icd->vb_vidq, p);
+       else
+               return vb2_querybuf(&icd->vb2_vidq, p);
+}
+
+static int soc_camera_qbuf(struct file *file, void *priv,
+                          struct v4l2_buffer *p)
+{
+       struct soc_camera_device *icd = file->private_data;
+       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+
+       WARN_ON(priv != file->private_data);
+
+       if (icd->streamer != file)
+               return -EBUSY;
+
+       if (ici->ops->init_videobuf)
+               return videobuf_qbuf(&icd->vb_vidq, p);
+       else
+               return vb2_qbuf(&icd->vb2_vidq, p);
+}
+
+static int soc_camera_dqbuf(struct file *file, void *priv,
+                           struct v4l2_buffer *p)
+{
+       struct soc_camera_device *icd = file->private_data;
+       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+
+       WARN_ON(priv != file->private_data);
+
+       if (icd->streamer != file)
+               return -EBUSY;
+
+       if (ici->ops->init_videobuf)
+               return videobuf_dqbuf(&icd->vb_vidq, p, file->f_flags & O_NONBLOCK);
+       else
+               return vb2_dqbuf(&icd->vb2_vidq, p, file->f_flags & O_NONBLOCK);
+}
+
+static int soc_camera_create_bufs(struct file *file, void *priv,
+                           struct v4l2_create_buffers *create)
+{
+       struct soc_camera_device *icd = file->private_data;
+       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+
+       /* videobuf2 only */
+       if (ici->ops->init_videobuf)
+               return -EINVAL;
+       else
+               return vb2_create_bufs(&icd->vb2_vidq, create);
+}
+
+static int soc_camera_prepare_buf(struct file *file, void *priv,
+                                 struct v4l2_buffer *b)
+{
+       struct soc_camera_device *icd = file->private_data;
+       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+
+       /* videobuf2 only */
+       if (ici->ops->init_videobuf)
+               return -EINVAL;
+       else
+               return vb2_prepare_buf(&icd->vb2_vidq, b);
+}
+
+/* Always entered with .video_lock held */
+static int soc_camera_init_user_formats(struct soc_camera_device *icd)
+{
+       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+       unsigned int i, fmts = 0, raw_fmts = 0;
+       int ret;
+       enum v4l2_mbus_pixelcode code;
+
+       while (!v4l2_subdev_call(sd, video, enum_mbus_fmt, raw_fmts, &code))
+               raw_fmts++;
+
+       if (!ici->ops->get_formats)
+               /*
+                * Fallback mode - the host will have to serve all
+                * sensor-provided formats one-to-one to the user
+                */
+               fmts = raw_fmts;
+       else
+               /*
+                * First pass - only count formats this host-sensor
+                * configuration can provide
+                */
+               for (i = 0; i < raw_fmts; i++) {
+                       ret = ici->ops->get_formats(icd, i, NULL);
+                       if (ret < 0)
+                               return ret;
+                       fmts += ret;
+               }
+
+       if (!fmts)
+               return -ENXIO;
+
+       icd->user_formats =
+               vmalloc(fmts * sizeof(struct soc_camera_format_xlate));
+       if (!icd->user_formats)
+               return -ENOMEM;
+
+       dev_dbg(icd->pdev, "Found %d supported formats.\n", fmts);
+
+       /* Second pass - actually fill data formats */
+       fmts = 0;
+       for (i = 0; i < raw_fmts; i++)
+               if (!ici->ops->get_formats) {
+                       v4l2_subdev_call(sd, video, enum_mbus_fmt, i, &code);
+                       icd->user_formats[fmts].host_fmt =
+                               soc_mbus_get_fmtdesc(code);
+                       if (icd->user_formats[fmts].host_fmt)
+                               icd->user_formats[fmts++].code = code;
+               } else {
+                       ret = ici->ops->get_formats(icd, i,
+                                                   &icd->user_formats[fmts]);
+                       if (ret < 0)
+                               goto egfmt;
+                       fmts += ret;
+               }
+
+       icd->num_user_formats = fmts;
+       icd->current_fmt = &icd->user_formats[0];
+
+       return 0;
+
+egfmt:
+       vfree(icd->user_formats);
+       return ret;
+}
+
+/* Always entered with .video_lock held */
+static void soc_camera_free_user_formats(struct soc_camera_device *icd)
+{
+       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+
+       if (ici->ops->put_formats)
+               ici->ops->put_formats(icd);
+       icd->current_fmt = NULL;
+       icd->num_user_formats = 0;
+       vfree(icd->user_formats);
+       icd->user_formats = NULL;
+}
+
+/* Called with .vb_lock held, or from the first open(2), see comment there */
+static int soc_camera_set_fmt(struct soc_camera_device *icd,
+                             struct v4l2_format *f)
+{
+       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+       struct v4l2_pix_format *pix = &f->fmt.pix;
+       int ret;
+
+       dev_dbg(icd->pdev, "S_FMT(%c%c%c%c, %ux%u)\n",
+               pixfmtstr(pix->pixelformat), pix->width, pix->height);
+
+       /* We always call try_fmt() before set_fmt() or set_crop() */
+       ret = soc_camera_try_fmt(icd, f);
+       if (ret < 0)
+               return ret;
+
+       ret = ici->ops->set_fmt(icd, f);
+       if (ret < 0) {
+               return ret;
+       } else if (!icd->current_fmt ||
+                  icd->current_fmt->host_fmt->fourcc != pix->pixelformat) {
+               dev_err(icd->pdev,
+                       "Host driver hasn't set up current format correctly!\n");
+               return -EINVAL;
+       }
+
+       icd->user_width         = pix->width;
+       icd->user_height        = pix->height;
+       icd->bytesperline       = pix->bytesperline;
+       icd->sizeimage          = pix->sizeimage;
+       icd->colorspace         = pix->colorspace;
+       icd->field              = pix->field;
+       if (ici->ops->init_videobuf)
+               icd->vb_vidq.field = pix->field;
+
+       dev_dbg(icd->pdev, "set width: %d height: %d\n",
+               icd->user_width, icd->user_height);
+
+       /* set physical bus parameters */
+       return ici->ops->set_bus_param(icd);
+}
+
+static int soc_camera_open(struct file *file)
+{
+       struct video_device *vdev = video_devdata(file);
+       struct soc_camera_device *icd = dev_get_drvdata(vdev->parent);
+       struct soc_camera_link *icl = to_soc_camera_link(icd);
+       struct soc_camera_host *ici;
+       int ret;
+
+       if (!to_soc_camera_control(icd))
+               /* No device driver attached */
+               return -ENODEV;
+
+       ici = to_soc_camera_host(icd->parent);
+
+       if (mutex_lock_interruptible(&icd->video_lock))
+               return -ERESTARTSYS;
+       if (!try_module_get(ici->ops->owner)) {
+               dev_err(icd->pdev, "Couldn't lock capture bus driver.\n");
+               ret = -EINVAL;
+               goto emodule;
+       }
+
+       icd->use_count++;
+
+       /* Now we really have to activate the camera */
+       if (icd->use_count == 1) {
+               /* Restore parameters before the last close() per V4L2 API */
+               struct v4l2_format f = {
+                       .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+                       .fmt.pix = {
+                               .width          = icd->user_width,
+                               .height         = icd->user_height,
+                               .field          = icd->field,
+                               .colorspace     = icd->colorspace,
+                               .pixelformat    =
+                                       icd->current_fmt->host_fmt->fourcc,
+                       },
+               };
+
+               /* The camera could have been already on, try to reset */
+               if (icl->reset)
+                       icl->reset(icd->pdev);
+
+               /* Don't mess with the host during probe */
+               mutex_lock(&ici->host_lock);
+               ret = ici->ops->add(icd);
+               mutex_unlock(&ici->host_lock);
+               if (ret < 0) {
+                       dev_err(icd->pdev, "Couldn't activate the camera: %d\n", ret);
+                       goto eiciadd;
+               }
+
+               ret = soc_camera_power_on(icd, icl);
+               if (ret < 0)
+                       goto epower;
+
+               pm_runtime_enable(&icd->vdev->dev);
+               ret = pm_runtime_resume(&icd->vdev->dev);
+               if (ret < 0 && ret != -ENOSYS)
+                       goto eresume;
+
+               /*
+                * Try to configure with default parameters. Notice: this is the
+                * very first open, so, we cannot race against other calls,
+                * apart from someone else calling open() simultaneously, but
+                * .video_lock is protecting us against it.
+                */
+               ret = soc_camera_set_fmt(icd, &f);
+               if (ret < 0)
+                       goto esfmt;
+
+               if (ici->ops->init_videobuf) {
+                       ici->ops->init_videobuf(&icd->vb_vidq, icd);
+               } else {
+                       ret = ici->ops->init_videobuf2(&icd->vb2_vidq, icd);
+                       if (ret < 0)
+                               goto einitvb;
+               }
+               v4l2_ctrl_handler_setup(&icd->ctrl_handler);
+       }
+       mutex_unlock(&icd->video_lock);
+
+       file->private_data = icd;
+       dev_dbg(icd->pdev, "camera device open\n");
+
+       return 0;
+
+       /*
+        * First four errors are entered with the .video_lock held
+        * and use_count == 1
+        */
+einitvb:
+esfmt:
+       pm_runtime_disable(&icd->vdev->dev);
+eresume:
+       soc_camera_power_off(icd, icl);
+epower:
+       ici->ops->remove(icd);
+eiciadd:
+       icd->use_count--;
+       module_put(ici->ops->owner);
+emodule:
+       mutex_unlock(&icd->video_lock);
+
+       return ret;
+}
+
+static int soc_camera_close(struct file *file)
+{
+       struct soc_camera_device *icd = file->private_data;
+       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+
+       mutex_lock(&icd->video_lock);
+       icd->use_count--;
+       if (!icd->use_count) {
+               struct soc_camera_link *icl = to_soc_camera_link(icd);
+
+               pm_runtime_suspend(&icd->vdev->dev);
+               pm_runtime_disable(&icd->vdev->dev);
+
+               if (ici->ops->init_videobuf2)
+                       vb2_queue_release(&icd->vb2_vidq);
+               ici->ops->remove(icd);
+
+               soc_camera_power_off(icd, icl);
+       }
+
+       if (icd->streamer == file)
+               icd->streamer = NULL;
+       mutex_unlock(&icd->video_lock);
+
+       module_put(ici->ops->owner);
+
+       dev_dbg(icd->pdev, "camera device close\n");
+
+       return 0;
+}
+
+static ssize_t soc_camera_read(struct file *file, char __user *buf,
+                              size_t count, loff_t *ppos)
+{
+       struct soc_camera_device *icd = file->private_data;
+       int err = -EINVAL;
+
+       dev_err(icd->pdev, "camera device read not implemented\n");
+
+       return err;
+}
+
+static int soc_camera_mmap(struct file *file, struct vm_area_struct *vma)
+{
+       struct soc_camera_device *icd = file->private_data;
+       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+       int err;
+
+       dev_dbg(icd->pdev, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
+
+       if (icd->streamer != file)
+               return -EBUSY;
+
+       if (mutex_lock_interruptible(&icd->video_lock))
+               return -ERESTARTSYS;
+       if (ici->ops->init_videobuf)
+               err = videobuf_mmap_mapper(&icd->vb_vidq, vma);
+       else
+               err = vb2_mmap(&icd->vb2_vidq, vma);
+       mutex_unlock(&icd->video_lock);
+
+       dev_dbg(icd->pdev, "vma start=0x%08lx, size=%ld, ret=%d\n",
+               (unsigned long)vma->vm_start,
+               (unsigned long)vma->vm_end - (unsigned long)vma->vm_start,
+               err);
+
+       return err;
+}
+
+static unsigned int soc_camera_poll(struct file *file, poll_table *pt)
+{
+       struct soc_camera_device *icd = file->private_data;
+       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+       unsigned res = POLLERR;
+
+       if (icd->streamer != file)
+               return POLLERR;
+
+       mutex_lock(&icd->video_lock);
+       if (ici->ops->init_videobuf && list_empty(&icd->vb_vidq.stream))
+               dev_err(icd->pdev, "Trying to poll with no queued buffers!\n");
+       else
+               res = ici->ops->poll(file, pt);
+       mutex_unlock(&icd->video_lock);
+       return res;
+}
+
+void soc_camera_lock(struct vb2_queue *vq)
+{
+       struct soc_camera_device *icd = vb2_get_drv_priv(vq);
+       mutex_lock(&icd->video_lock);
+}
+EXPORT_SYMBOL(soc_camera_lock);
+
+void soc_camera_unlock(struct vb2_queue *vq)
+{
+       struct soc_camera_device *icd = vb2_get_drv_priv(vq);
+       mutex_unlock(&icd->video_lock);
+}
+EXPORT_SYMBOL(soc_camera_unlock);
+
+static struct v4l2_file_operations soc_camera_fops = {
+       .owner          = THIS_MODULE,
+       .open           = soc_camera_open,
+       .release        = soc_camera_close,
+       .unlocked_ioctl = video_ioctl2,
+       .read           = soc_camera_read,
+       .mmap           = soc_camera_mmap,
+       .poll           = soc_camera_poll,
+};
+
+static int soc_camera_s_fmt_vid_cap(struct file *file, void *priv,
+                                   struct v4l2_format *f)
+{
+       struct soc_camera_device *icd = file->private_data;
+       int ret;
+
+       WARN_ON(priv != file->private_data);
+
+       if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
+               dev_warn(icd->pdev, "Wrong buf-type %d\n", f->type);
+               return -EINVAL;
+       }
+
+       if (icd->streamer && icd->streamer != file)
+               return -EBUSY;
+
+       if (is_streaming(to_soc_camera_host(icd->parent), icd)) {
+               dev_err(icd->pdev, "S_FMT denied: queue initialised\n");
+               return -EBUSY;
+       }
+
+       ret = soc_camera_set_fmt(icd, f);
+
+       if (!ret && !icd->streamer)
+               icd->streamer = file;
+
+       return ret;
+}
+
+static int soc_camera_enum_fmt_vid_cap(struct file *file, void  *priv,
+                                      struct v4l2_fmtdesc *f)
+{
+       struct soc_camera_device *icd = file->private_data;
+       const struct soc_mbus_pixelfmt *format;
+
+       WARN_ON(priv != file->private_data);
+
+       if (f->index >= icd->num_user_formats)
+               return -EINVAL;
+
+       format = icd->user_formats[f->index].host_fmt;
+
+       if (format->name)
+               strlcpy(f->description, format->name, sizeof(f->description));
+       f->pixelformat = format->fourcc;
+       return 0;
+}
+
+static int soc_camera_g_fmt_vid_cap(struct file *file, void *priv,
+                                   struct v4l2_format *f)
+{
+       struct soc_camera_device *icd = file->private_data;
+       struct v4l2_pix_format *pix = &f->fmt.pix;
+
+       WARN_ON(priv != file->private_data);
+
+       if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+               return -EINVAL;
+
+       pix->width              = icd->user_width;
+       pix->height             = icd->user_height;
+       pix->bytesperline       = icd->bytesperline;
+       pix->sizeimage          = icd->sizeimage;
+       pix->field              = icd->field;
+       pix->pixelformat        = icd->current_fmt->host_fmt->fourcc;
+       pix->colorspace         = icd->colorspace;
+       dev_dbg(icd->pdev, "current_fmt->fourcc: 0x%08x\n",
+               icd->current_fmt->host_fmt->fourcc);
+       return 0;
+}
+
+static int soc_camera_querycap(struct file *file, void  *priv,
+                              struct v4l2_capability *cap)
+{
+       struct soc_camera_device *icd = file->private_data;
+       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+
+       WARN_ON(priv != file->private_data);
+
+       strlcpy(cap->driver, ici->drv_name, sizeof(cap->driver));
+       return ici->ops->querycap(ici, cap);
+}
+
+static int soc_camera_streamon(struct file *file, void *priv,
+                              enum v4l2_buf_type i)
+{
+       struct soc_camera_device *icd = file->private_data;
+       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+       int ret;
+
+       WARN_ON(priv != file->private_data);
+
+       if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+               return -EINVAL;
+
+       if (icd->streamer != file)
+               return -EBUSY;
+
+       /* This calls buf_queue from host driver's videobuf_queue_ops */
+       if (ici->ops->init_videobuf)
+               ret = videobuf_streamon(&icd->vb_vidq);
+       else
+               ret = vb2_streamon(&icd->vb2_vidq, i);
+
+       if (!ret)
+               v4l2_subdev_call(sd, video, s_stream, 1);
+
+       return ret;
+}
+
+static int soc_camera_streamoff(struct file *file, void *priv,
+                               enum v4l2_buf_type i)
+{
+       struct soc_camera_device *icd = file->private_data;
+       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+
+       WARN_ON(priv != file->private_data);
+
+       if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+               return -EINVAL;
+
+       if (icd->streamer != file)
+               return -EBUSY;
+
+       /*
+        * This calls buf_release from host driver's videobuf_queue_ops for all
+        * remaining buffers. When the last buffer is freed, stop capture
+        */
+       if (ici->ops->init_videobuf)
+               videobuf_streamoff(&icd->vb_vidq);
+       else
+               vb2_streamoff(&icd->vb2_vidq, i);
+
+       v4l2_subdev_call(sd, video, s_stream, 0);
+
+       return 0;
+}
+
+static int soc_camera_cropcap(struct file *file, void *fh,
+                             struct v4l2_cropcap *a)
+{
+       struct soc_camera_device *icd = file->private_data;
+       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+
+       return ici->ops->cropcap(icd, a);
+}
+
+static int soc_camera_g_crop(struct file *file, void *fh,
+                            struct v4l2_crop *a)
+{
+       struct soc_camera_device *icd = file->private_data;
+       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+       int ret;
+
+       ret = ici->ops->get_crop(icd, a);
+
+       return ret;
+}
+
+/*
+ * According to the V4L2 API, drivers shall not update the struct v4l2_crop
+ * argument with the actual geometry, instead, the user shall use G_CROP to
+ * retrieve it.
+ */
+static int soc_camera_s_crop(struct file *file, void *fh,
+                            struct v4l2_crop *a)
+{
+       struct soc_camera_device *icd = file->private_data;
+       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+       struct v4l2_rect *rect = &a->c;
+       struct v4l2_crop current_crop;
+       int ret;
+
+       if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+               return -EINVAL;
+
+       dev_dbg(icd->pdev, "S_CROP(%ux%u@%u:%u)\n",
+               rect->width, rect->height, rect->left, rect->top);
+
+       /* If get_crop fails, we'll let host and / or client drivers decide */
+       ret = ici->ops->get_crop(icd, &current_crop);
+
+       /* Prohibit window size change with initialised buffers */
+       if (ret < 0) {
+               dev_err(icd->pdev,
+                       "S_CROP denied: getting current crop failed\n");
+       } else if ((a->c.width == current_crop.c.width &&
+                   a->c.height == current_crop.c.height) ||
+                  !is_streaming(ici, icd)) {
+               /* same size or not streaming - use .set_crop() */
+               ret = ici->ops->set_crop(icd, a);
+       } else if (ici->ops->set_livecrop) {
+               ret = ici->ops->set_livecrop(icd, a);
+       } else {
+               dev_err(icd->pdev,
+                       "S_CROP denied: queue initialised and sizes differ\n");
+               ret = -EBUSY;
+       }
+
+       return ret;
+}
+
+static int soc_camera_g_parm(struct file *file, void *fh,
+                            struct v4l2_streamparm *a)
+{
+       struct soc_camera_device *icd = file->private_data;
+       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+
+       if (ici->ops->get_parm)
+               return ici->ops->get_parm(icd, a);
+
+       return -ENOIOCTLCMD;
+}
+
+static int soc_camera_s_parm(struct file *file, void *fh,
+                            struct v4l2_streamparm *a)
+{
+       struct soc_camera_device *icd = file->private_data;
+       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+
+       if (ici->ops->set_parm)
+               return ici->ops->set_parm(icd, a);
+
+       return -ENOIOCTLCMD;
+}
+
+static int soc_camera_g_chip_ident(struct file *file, void *fh,
+                                  struct v4l2_dbg_chip_ident *id)
+{
+       struct soc_camera_device *icd = file->private_data;
+       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+
+       return v4l2_subdev_call(sd, core, g_chip_ident, id);
+}
+
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+static int soc_camera_g_register(struct file *file, void *fh,
+                                struct v4l2_dbg_register *reg)
+{
+       struct soc_camera_device *icd = file->private_data;
+       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+
+       return v4l2_subdev_call(sd, core, g_register, reg);
+}
+
+static int soc_camera_s_register(struct file *file, void *fh,
+                                struct v4l2_dbg_register *reg)
+{
+       struct soc_camera_device *icd = file->private_data;
+       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+
+       return v4l2_subdev_call(sd, core, s_register, reg);
+}
+#endif
+
+static int soc_camera_probe(struct soc_camera_device *icd);
+
+/* So far this function cannot fail */
+static void scan_add_host(struct soc_camera_host *ici)
+{
+       struct soc_camera_device *icd;
+
+       mutex_lock(&ici->host_lock);
+
+       list_for_each_entry(icd, &devices, list) {
+               if (icd->iface == ici->nr) {
+                       int ret;
+
+                       icd->parent = ici->v4l2_dev.dev;
+                       ret = soc_camera_probe(icd);
+               }
+       }
+
+       mutex_unlock(&ici->host_lock);
+}
+
+#ifdef CONFIG_I2C_BOARDINFO
+static int soc_camera_init_i2c(struct soc_camera_device *icd,
+                              struct soc_camera_link *icl)
+{
+       struct i2c_client *client;
+       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+       struct i2c_adapter *adap = i2c_get_adapter(icl->i2c_adapter_id);
+       struct v4l2_subdev *subdev;
+
+       if (!adap) {
+               dev_err(icd->pdev, "Cannot get I2C adapter #%d. No driver?\n",
+                       icl->i2c_adapter_id);
+               goto ei2cga;
+       }
+
+       icl->board_info->platform_data = icl;
+
+       subdev = v4l2_i2c_new_subdev_board(&ici->v4l2_dev, adap,
+                               icl->board_info, NULL);
+       if (!subdev)
+               goto ei2cnd;
+
+       client = v4l2_get_subdevdata(subdev);
+
+       /* Use to_i2c_client(dev) to recover the i2c client */
+       icd->control = &client->dev;
+
+       return 0;
+ei2cnd:
+       i2c_put_adapter(adap);
+ei2cga:
+       return -ENODEV;
+}
+
+static void soc_camera_free_i2c(struct soc_camera_device *icd)
+{
+       struct i2c_client *client =
+               to_i2c_client(to_soc_camera_control(icd));
+       struct i2c_adapter *adap = client->adapter;
+
+       icd->control = NULL;
+       v4l2_device_unregister_subdev(i2c_get_clientdata(client));
+       i2c_unregister_device(client);
+       i2c_put_adapter(adap);
+}
+#else
+#define soc_camera_init_i2c(icd, icl)  (-ENODEV)
+#define soc_camera_free_i2c(icd)       do {} while (0)
+#endif
+
+static int soc_camera_video_start(struct soc_camera_device *icd);
+static int video_dev_create(struct soc_camera_device *icd);
+/* Called during host-driver probe */
+static int soc_camera_probe(struct soc_camera_device *icd)
+{
+       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+       struct soc_camera_link *icl = to_soc_camera_link(icd);
+       struct device *control = NULL;
+       struct v4l2_subdev *sd;
+       struct v4l2_mbus_framefmt mf;
+       int ret;
+
+       dev_info(icd->pdev, "Probing %s\n", dev_name(icd->pdev));
+
+       /*
+        * Currently the subdev with the largest number of controls (13) is
+        * ov6550. So let's pick 16 as a hint for the control handler. Note
+        * that this is a hint only: too large and you waste some memory, too
+        * small and there is a (very) small performance hit when looking up
+        * controls in the internal hash.
+        */
+       ret = v4l2_ctrl_handler_init(&icd->ctrl_handler, 16);
+       if (ret < 0)
+               return ret;
+
+       ret = regulator_bulk_get(icd->pdev, icl->num_regulators,
+                                icl->regulators);
+       if (ret < 0)
+               goto ereg;
+
+       /* The camera could have been already on, try to reset */
+       if (icl->reset)
+               icl->reset(icd->pdev);
+
+       ret = ici->ops->add(icd);
+       if (ret < 0)
+               goto eadd;
+
+       /*
+        * This will not yet call v4l2_subdev_core_ops::s_power(1), because the
+        * subdevice has not been initialised yet. We'll have to call it once
+        * again after initialisation, even though it shouldn't be needed, we
+        * don't do any IO here.
+        */
+       ret = soc_camera_power_on(icd, icl);
+       if (ret < 0)
+               goto epower;
+
+       /* Must have icd->vdev before registering the device */
+       ret = video_dev_create(icd);
+       if (ret < 0)
+               goto evdc;
+
+       /* Non-i2c cameras, e.g., soc_camera_platform, have no board_info */
+       if (icl->board_info) {
+               ret = soc_camera_init_i2c(icd, icl);
+               if (ret < 0)
+                       goto eadddev;
+       } else if (!icl->add_device || !icl->del_device) {
+               ret = -EINVAL;
+               goto eadddev;
+       } else {
+               if (icl->module_name)
+                       ret = request_module(icl->module_name);
+
+               ret = icl->add_device(icd);
+               if (ret < 0)
+                       goto eadddev;
+
+               /*
+                * FIXME: this is racy, have to use driver-binding notification,
+                * when it is available
+                */
+               control = to_soc_camera_control(icd);
+               if (!control || !control->driver || !dev_get_drvdata(control) ||
+                   !try_module_get(control->driver->owner)) {
+                       icl->del_device(icd);
+                       ret = -ENODEV;
+                       goto enodrv;
+               }
+       }
+
+       sd = soc_camera_to_subdev(icd);
+       sd->grp_id = soc_camera_grp_id(icd);
+       v4l2_set_subdev_hostdata(sd, icd);
+
+       if (v4l2_ctrl_add_handler(&icd->ctrl_handler, sd->ctrl_handler))
+               goto ectrl;
+
+       /* At this point client .probe() should have run already */
+       ret = soc_camera_init_user_formats(icd);
+       if (ret < 0)
+               goto eiufmt;
+
+       icd->field = V4L2_FIELD_ANY;
+
+       /*
+        * ..._video_start() will create a device node, video_register_device()
+        * itself is protected against concurrent open() calls, but we also have
+        * to protect our data.
+        */
+       mutex_lock(&icd->video_lock);
+
+       ret = soc_camera_video_start(icd);
+       if (ret < 0)
+               goto evidstart;
+
+       ret = v4l2_subdev_call(sd, core, s_power, 1);
+       if (ret < 0 && ret != -ENOIOCTLCMD)
+               goto esdpwr;
+
+       /* Try to improve our guess of a reasonable window format */
+       if (!v4l2_subdev_call(sd, video, g_mbus_fmt, &mf)) {
+               icd->user_width         = mf.width;
+               icd->user_height        = mf.height;
+               icd->colorspace         = mf.colorspace;
+               icd->field              = mf.field;
+       }
+
+       ici->ops->remove(icd);
+
+       soc_camera_power_off(icd, icl);
+
+       mutex_unlock(&icd->video_lock);
+
+       return 0;
+
+esdpwr:
+       video_unregister_device(icd->vdev);
+evidstart:
+       mutex_unlock(&icd->video_lock);
+       soc_camera_free_user_formats(icd);
+eiufmt:
+ectrl:
+       if (icl->board_info) {
+               soc_camera_free_i2c(icd);
+       } else {
+               icl->del_device(icd);
+               module_put(control->driver->owner);
+       }
+enodrv:
+eadddev:
+       video_device_release(icd->vdev);
+       icd->vdev = NULL;
+evdc:
+       soc_camera_power_off(icd, icl);
+epower:
+       ici->ops->remove(icd);
+eadd:
+       regulator_bulk_free(icl->num_regulators, icl->regulators);
+ereg:
+       v4l2_ctrl_handler_free(&icd->ctrl_handler);
+       return ret;
+}
+
+/*
+ * This is called on device_unregister, which only means we have to disconnect
+ * from the host, but not remove ourselves from the device list
+ */
+static int soc_camera_remove(struct soc_camera_device *icd)
+{
+       struct soc_camera_link *icl = to_soc_camera_link(icd);
+       struct video_device *vdev = icd->vdev;
+
+       BUG_ON(!icd->parent);
+
+       v4l2_ctrl_handler_free(&icd->ctrl_handler);
+       if (vdev) {
+               video_unregister_device(vdev);
+               icd->vdev = NULL;
+       }
+
+       if (icl->board_info) {
+               soc_camera_free_i2c(icd);
+       } else {
+               struct device_driver *drv = to_soc_camera_control(icd)->driver;
+               if (drv) {
+                       icl->del_device(icd);
+                       module_put(drv->owner);
+               }
+       }
+       soc_camera_free_user_formats(icd);
+
+       regulator_bulk_free(icl->num_regulators, icl->regulators);
+
+       return 0;
+}
+
+static int default_cropcap(struct soc_camera_device *icd,
+                          struct v4l2_cropcap *a)
+{
+       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+       return v4l2_subdev_call(sd, video, cropcap, a);
+}
+
+static int default_g_crop(struct soc_camera_device *icd, struct v4l2_crop *a)
+{
+       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+       return v4l2_subdev_call(sd, video, g_crop, a);
+}
+
+static int default_s_crop(struct soc_camera_device *icd, struct v4l2_crop *a)
+{
+       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+       return v4l2_subdev_call(sd, video, s_crop, a);
+}
+
+static int default_g_parm(struct soc_camera_device *icd,
+                         struct v4l2_streamparm *parm)
+{
+       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+       return v4l2_subdev_call(sd, video, g_parm, parm);
+}
+
+static int default_s_parm(struct soc_camera_device *icd,
+                         struct v4l2_streamparm *parm)
+{
+       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+       return v4l2_subdev_call(sd, video, s_parm, parm);
+}
+
+static int default_enum_framesizes(struct soc_camera_device *icd,
+                                  struct v4l2_frmsizeenum *fsize)
+{
+       int ret;
+       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+       const struct soc_camera_format_xlate *xlate;
+       __u32 pixfmt = fsize->pixel_format;
+       struct v4l2_frmsizeenum fsize_mbus = *fsize;
+
+       xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
+       if (!xlate)
+               return -EINVAL;
+       /* map xlate-code to pixel_format, sensor only handle xlate-code*/
+       fsize_mbus.pixel_format = xlate->code;
+
+       ret = v4l2_subdev_call(sd, video, enum_framesizes, &fsize_mbus);
+       if (ret < 0)
+               return ret;
+
+       *fsize = fsize_mbus;
+       fsize->pixel_format = pixfmt;
+
+       return 0;
+}
+
+int soc_camera_host_register(struct soc_camera_host *ici)
+{
+       struct soc_camera_host *ix;
+       int ret;
+
+       if (!ici || !ici->ops ||
+           !ici->ops->try_fmt ||
+           !ici->ops->set_fmt ||
+           !ici->ops->set_bus_param ||
+           !ici->ops->querycap ||
+           ((!ici->ops->init_videobuf ||
+             !ici->ops->reqbufs) &&
+            !ici->ops->init_videobuf2) ||
+           !ici->ops->add ||
+           !ici->ops->remove ||
+           !ici->ops->poll ||
+           !ici->v4l2_dev.dev)
+               return -EINVAL;
+
+       if (!ici->ops->set_crop)
+               ici->ops->set_crop = default_s_crop;
+       if (!ici->ops->get_crop)
+               ici->ops->get_crop = default_g_crop;
+       if (!ici->ops->cropcap)
+               ici->ops->cropcap = default_cropcap;
+       if (!ici->ops->set_parm)
+               ici->ops->set_parm = default_s_parm;
+       if (!ici->ops->get_parm)
+               ici->ops->get_parm = default_g_parm;
+       if (!ici->ops->enum_framesizes)
+               ici->ops->enum_framesizes = default_enum_framesizes;
+
+       mutex_lock(&list_lock);
+       list_for_each_entry(ix, &hosts, list) {
+               if (ix->nr == ici->nr) {
+                       ret = -EBUSY;
+                       goto edevreg;
+               }
+       }
+
+       ret = v4l2_device_register(ici->v4l2_dev.dev, &ici->v4l2_dev);
+       if (ret < 0)
+               goto edevreg;
+
+       list_add_tail(&ici->list, &hosts);
+       mutex_unlock(&list_lock);
+
+       mutex_init(&ici->host_lock);
+       scan_add_host(ici);
+
+       return 0;
+
+edevreg:
+       mutex_unlock(&list_lock);
+       return ret;
+}
+EXPORT_SYMBOL(soc_camera_host_register);
+
+/* Unregister all clients! */
+void soc_camera_host_unregister(struct soc_camera_host *ici)
+{
+       struct soc_camera_device *icd;
+
+       mutex_lock(&list_lock);
+
+       list_del(&ici->list);
+       list_for_each_entry(icd, &devices, list)
+               if (icd->iface == ici->nr && to_soc_camera_control(icd))
+                       soc_camera_remove(icd);
+
+       mutex_unlock(&list_lock);
+
+       v4l2_device_unregister(&ici->v4l2_dev);
+}
+EXPORT_SYMBOL(soc_camera_host_unregister);
+
+/* Image capture device */
+static int soc_camera_device_register(struct soc_camera_device *icd)
+{
+       struct soc_camera_device *ix;
+       int num = -1, i;
+
+       for (i = 0; i < 256 && num < 0; i++) {
+               num = i;
+               /* Check if this index is available on this interface */
+               list_for_each_entry(ix, &devices, list) {
+                       if (ix->iface == icd->iface && ix->devnum == i) {
+                               num = -1;
+                               break;
+                       }
+               }
+       }
+
+       if (num < 0)
+               /*
+                * ok, we have 256 cameras on this host...
+                * man, stay reasonable...
+                */
+               return -ENOMEM;
+
+       icd->devnum             = num;
+       icd->use_count          = 0;
+       icd->host_priv          = NULL;
+       mutex_init(&icd->video_lock);
+
+       list_add_tail(&icd->list, &devices);
+
+       return 0;
+}
+
+static const struct v4l2_ioctl_ops soc_camera_ioctl_ops = {
+       .vidioc_querycap         = soc_camera_querycap,
+       .vidioc_try_fmt_vid_cap  = soc_camera_try_fmt_vid_cap,
+       .vidioc_g_fmt_vid_cap    = soc_camera_g_fmt_vid_cap,
+       .vidioc_s_fmt_vid_cap    = soc_camera_s_fmt_vid_cap,
+       .vidioc_enum_fmt_vid_cap = soc_camera_enum_fmt_vid_cap,
+       .vidioc_enum_input       = soc_camera_enum_input,
+       .vidioc_g_input          = soc_camera_g_input,
+       .vidioc_s_input          = soc_camera_s_input,
+       .vidioc_s_std            = soc_camera_s_std,
+       .vidioc_g_std            = soc_camera_g_std,
+       .vidioc_enum_framesizes  = soc_camera_enum_framesizes,
+       .vidioc_reqbufs          = soc_camera_reqbufs,
+       .vidioc_querybuf         = soc_camera_querybuf,
+       .vidioc_qbuf             = soc_camera_qbuf,
+       .vidioc_dqbuf            = soc_camera_dqbuf,
+       .vidioc_create_bufs      = soc_camera_create_bufs,
+       .vidioc_prepare_buf      = soc_camera_prepare_buf,
+       .vidioc_streamon         = soc_camera_streamon,
+       .vidioc_streamoff        = soc_camera_streamoff,
+       .vidioc_cropcap          = soc_camera_cropcap,
+       .vidioc_g_crop           = soc_camera_g_crop,
+       .vidioc_s_crop           = soc_camera_s_crop,
+       .vidioc_g_parm           = soc_camera_g_parm,
+       .vidioc_s_parm           = soc_camera_s_parm,
+       .vidioc_g_chip_ident     = soc_camera_g_chip_ident,
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+       .vidioc_g_register       = soc_camera_g_register,
+       .vidioc_s_register       = soc_camera_s_register,
+#endif
+};
+
+static int video_dev_create(struct soc_camera_device *icd)
+{
+       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+       struct video_device *vdev = video_device_alloc();
+
+       if (!vdev)
+               return -ENOMEM;
+
+       strlcpy(vdev->name, ici->drv_name, sizeof(vdev->name));
+
+       vdev->parent            = icd->pdev;
+       vdev->current_norm      = V4L2_STD_UNKNOWN;
+       vdev->fops              = &soc_camera_fops;
+       vdev->ioctl_ops         = &soc_camera_ioctl_ops;
+       vdev->release           = video_device_release;
+       vdev->tvnorms           = V4L2_STD_UNKNOWN;
+       vdev->ctrl_handler      = &icd->ctrl_handler;
+       vdev->lock              = &icd->video_lock;
+
+       icd->vdev = vdev;
+
+       return 0;
+}
+
+/*
+ * Called from soc_camera_probe() above (with .video_lock held???)
+ */
+static int soc_camera_video_start(struct soc_camera_device *icd)
+{
+       const struct device_type *type = icd->vdev->dev.type;
+       int ret;
+
+       if (!icd->parent)
+               return -ENODEV;
+
+       ret = video_register_device(icd->vdev, VFL_TYPE_GRABBER, -1);
+       if (ret < 0) {
+               dev_err(icd->pdev, "video_register_device failed: %d\n", ret);
+               return ret;
+       }
+
+       /* Restore device type, possibly set by the subdevice driver */
+       icd->vdev->dev.type = type;
+
+       return 0;
+}
+
+static int __devinit soc_camera_pdrv_probe(struct platform_device *pdev)
+{
+       struct soc_camera_link *icl = pdev->dev.platform_data;
+       struct soc_camera_device *icd;
+       int ret;
+
+       if (!icl)
+               return -EINVAL;
+
+       icd = kzalloc(sizeof(*icd), GFP_KERNEL);
+       if (!icd)
+               return -ENOMEM;
+
+       icd->iface = icl->bus_id;
+       icd->link = icl;
+       icd->pdev = &pdev->dev;
+       platform_set_drvdata(pdev, icd);
+
+       ret = soc_camera_device_register(icd);
+       if (ret < 0)
+               goto escdevreg;
+
+       icd->user_width         = DEFAULT_WIDTH;
+       icd->user_height        = DEFAULT_HEIGHT;
+
+       return 0;
+
+escdevreg:
+       kfree(icd);
+
+       return ret;
+}
+
+/*
+ * Only called on rmmod for each platform device, since they are not
+ * hot-pluggable. Now we know, that all our users - hosts and devices have
+ * been unloaded already
+ */
+static int __devexit soc_camera_pdrv_remove(struct platform_device *pdev)
+{
+       struct soc_camera_device *icd = platform_get_drvdata(pdev);
+
+       if (!icd)
+               return -EINVAL;
+
+       list_del(&icd->list);
+
+       kfree(icd);
+
+       return 0;
+}
+
+static struct platform_driver __refdata soc_camera_pdrv = {
+       .probe = soc_camera_pdrv_probe,
+       .remove  = __devexit_p(soc_camera_pdrv_remove),
+       .driver  = {
+               .name   = "soc-camera-pdrv",
+               .owner  = THIS_MODULE,
+       },
+};
+
+static int __init soc_camera_init(void)
+{
+       return platform_driver_register(&soc_camera_pdrv);
+}
+
+static void __exit soc_camera_exit(void)
+{
+       platform_driver_unregister(&soc_camera_pdrv);
+}
+
+module_init(soc_camera_init);
+module_exit(soc_camera_exit);
+
+MODULE_DESCRIPTION("Image capture bus driver");
+MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:soc-camera-pdrv");
diff --git a/drivers/media/i2c/soc_camera/tw9910.c b/drivers/media/i2c/soc_camera/tw9910.c
new file mode 100644 (file)
index 0000000..9f53eac
--- /dev/null
@@ -0,0 +1,956 @@
+/*
+ * tw9910 Video Driver
+ *
+ * Copyright (C) 2008 Renesas Solutions Corp.
+ * Kuninori Morimoto <morimoto.kuninori@renesas.com>
+ *
+ * Based on ov772x driver,
+ *
+ * Copyright (C) 2008 Kuninori Morimoto <morimoto.kuninori@renesas.com>
+ * Copyright 2006-7 Jonathan Corbet <corbet@lwn.net>
+ * Copyright (C) 2008 Magnus Damm
+ * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/slab.h>
+#include <linux/kernel.h>
+#include <linux/delay.h>
+#include <linux/v4l2-mediabus.h>
+#include <linux/videodev2.h>
+
+#include <media/soc_camera.h>
+#include <media/tw9910.h>
+#include <media/v4l2-chip-ident.h>
+#include <media/v4l2-subdev.h>
+
+#define GET_ID(val)  ((val & 0xF8) >> 3)
+#define GET_REV(val) (val & 0x07)
+
+/*
+ * register offset
+ */
+#define ID             0x00 /* Product ID Code Register */
+#define STATUS1                0x01 /* Chip Status Register I */
+#define INFORM         0x02 /* Input Format */
+#define OPFORM         0x03 /* Output Format Control Register */
+#define DLYCTR         0x04 /* Hysteresis and HSYNC Delay Control */
+#define OUTCTR1                0x05 /* Output Control I */
+#define ACNTL1         0x06 /* Analog Control Register 1 */
+#define CROP_HI                0x07 /* Cropping Register, High */
+#define VDELAY_LO      0x08 /* Vertical Delay Register, Low */
+#define VACTIVE_LO     0x09 /* Vertical Active Register, Low */
+#define HDELAY_LO      0x0A /* Horizontal Delay Register, Low */
+#define HACTIVE_LO     0x0B /* Horizontal Active Register, Low */
+#define CNTRL1         0x0C /* Control Register I */
+#define VSCALE_LO      0x0D /* Vertical Scaling Register, Low */
+#define SCALE_HI       0x0E /* Scaling Register, High */
+#define HSCALE_LO      0x0F /* Horizontal Scaling Register, Low */
+#define BRIGHT         0x10 /* BRIGHTNESS Control Register */
+#define CONTRAST       0x11 /* CONTRAST Control Register */
+#define SHARPNESS      0x12 /* SHARPNESS Control Register I */
+#define SAT_U          0x13 /* Chroma (U) Gain Register */
+#define SAT_V          0x14 /* Chroma (V) Gain Register */
+#define HUE            0x15 /* Hue Control Register */
+#define CORING1                0x17
+#define CORING2                0x18 /* Coring and IF compensation */
+#define VBICNTL                0x19 /* VBI Control Register */
+#define ACNTL2         0x1A /* Analog Control 2 */
+#define OUTCTR2                0x1B /* Output Control 2 */
+#define SDT            0x1C /* Standard Selection */
+#define SDTR           0x1D /* Standard Recognition */
+#define TEST           0x1F /* Test Control Register */
+#define CLMPG          0x20 /* Clamping Gain */
+#define IAGC           0x21 /* Individual AGC Gain */
+#define AGCGAIN                0x22 /* AGC Gain */
+#define PEAKWT         0x23 /* White Peak Threshold */
+#define CLMPL          0x24 /* Clamp level */
+#define SYNCT          0x25 /* Sync Amplitude */
+#define MISSCNT                0x26 /* Sync Miss Count Register */
+#define PCLAMP         0x27 /* Clamp Position Register */
+#define VCNTL1         0x28 /* Vertical Control I */
+#define VCNTL2         0x29 /* Vertical Control II */
+#define CKILL          0x2A /* Color Killer Level Control */
+#define COMB           0x2B /* Comb Filter Control */
+#define LDLY           0x2C /* Luma Delay and H Filter Control */
+#define MISC1          0x2D /* Miscellaneous Control I */
+#define LOOP           0x2E /* LOOP Control Register */
+#define MISC2          0x2F /* Miscellaneous Control II */
+#define MVSN           0x30 /* Macrovision Detection */
+#define STATUS2                0x31 /* Chip STATUS II */
+#define HFREF          0x32 /* H monitor */
+#define CLMD           0x33 /* CLAMP MODE */
+#define IDCNTL         0x34 /* ID Detection Control */
+#define CLCNTL1                0x35 /* Clamp Control I */
+#define ANAPLLCTL      0x4C
+#define VBIMIN         0x4D
+#define HSLOWCTL       0x4E
+#define WSS3           0x4F
+#define FILLDATA       0x50
+#define SDID           0x51
+#define DID            0x52
+#define WSS1           0x53
+#define WSS2           0x54
+#define VVBI           0x55
+#define LCTL6          0x56
+#define LCTL7          0x57
+#define LCTL8          0x58
+#define LCTL9          0x59
+#define LCTL10         0x5A
+#define LCTL11         0x5B
+#define LCTL12         0x5C
+#define LCTL13         0x5D
+#define LCTL14         0x5E
+#define LCTL15         0x5F
+#define LCTL16         0x60
+#define LCTL17         0x61
+#define LCTL18         0x62
+#define LCTL19         0x63
+#define LCTL20         0x64
+#define LCTL21         0x65
+#define LCTL22         0x66
+#define LCTL23         0x67
+#define LCTL24         0x68
+#define LCTL25         0x69
+#define LCTL26         0x6A
+#define HSBEGIN                0x6B
+#define HSEND          0x6C
+#define OVSDLY         0x6D
+#define OVSEND         0x6E
+#define VBIDELAY       0x6F
+
+/*
+ * register detail
+ */
+
+/* INFORM */
+#define FC27_ON     0x40 /* 1 : Input crystal clock frequency is 27MHz */
+#define FC27_FF     0x00 /* 0 : Square pixel mode. */
+                        /*     Must use 24.54MHz for 60Hz field rate */
+                        /*     source or 29.5MHz for 50Hz field rate */
+#define IFSEL_S     0x10 /* 01 : S-video decoding */
+#define IFSEL_C     0x00 /* 00 : Composite video decoding */
+                        /* Y input video selection */
+#define YSEL_M0     0x00 /*  00 : Mux0 selected */
+#define YSEL_M1     0x04 /*  01 : Mux1 selected */
+#define YSEL_M2     0x08 /*  10 : Mux2 selected */
+#define YSEL_M3     0x10 /*  11 : Mux3 selected */
+
+/* OPFORM */
+#define MODE        0x80 /* 0 : CCIR601 compatible YCrCb 4:2:2 format */
+                        /* 1 : ITU-R-656 compatible data sequence format */
+#define LEN         0x40 /* 0 : 8-bit YCrCb 4:2:2 output format */
+                        /* 1 : 16-bit YCrCb 4:2:2 output format.*/
+#define LLCMODE     0x20 /* 1 : LLC output mode. */
+                        /* 0 : free-run output mode */
+#define AINC        0x10 /* Serial interface auto-indexing control */
+                        /* 0 : auto-increment */
+                        /* 1 : non-auto */
+#define VSCTL       0x08 /* 1 : Vertical out ctrl by DVALID */
+                        /* 0 : Vertical out ctrl by HACTIVE and DVALID */
+#define OEN_TRI_SEL_MASK       0x07
+#define OEN_TRI_SEL_ALL_ON     0x00 /* Enable output for Rev0/Rev1 */
+#define OEN_TRI_SEL_ALL_OFF_r0 0x06 /* All tri-stated for Rev0 */
+#define OEN_TRI_SEL_ALL_OFF_r1 0x07 /* All tri-stated for Rev1 */
+
+/* OUTCTR1 */
+#define VSP_LO      0x00 /* 0 : VS pin output polarity is active low */
+#define VSP_HI      0x80 /* 1 : VS pin output polarity is active high. */
+                        /* VS pin output control */
+#define VSSL_VSYNC  0x00 /*   0 : VSYNC  */
+#define VSSL_VACT   0x10 /*   1 : VACT   */
+#define VSSL_FIELD  0x20 /*   2 : FIELD  */
+#define VSSL_VVALID 0x30 /*   3 : VVALID */
+#define VSSL_ZERO   0x70 /*   7 : 0      */
+#define HSP_LOW     0x00 /* 0 : HS pin output polarity is active low */
+#define HSP_HI      0x08 /* 1 : HS pin output polarity is active high.*/
+                        /* HS pin output control */
+#define HSSL_HACT   0x00 /*   0 : HACT   */
+#define HSSL_HSYNC  0x01 /*   1 : HSYNC  */
+#define HSSL_DVALID 0x02 /*   2 : DVALID */
+#define HSSL_HLOCK  0x03 /*   3 : HLOCK  */
+#define HSSL_ASYNCW 0x04 /*   4 : ASYNCW */
+#define HSSL_ZERO   0x07 /*   7 : 0      */
+
+/* ACNTL1 */
+#define SRESET      0x80 /* resets the device to its default state
+                         * but all register content remain unchanged.
+                         * This bit is self-resetting.
+                         */
+#define ACNTL1_PDN_MASK        0x0e
+#define CLK_PDN                0x08 /* system clock power down */
+#define Y_PDN          0x04 /* Luma ADC power down */
+#define C_PDN          0x02 /* Chroma ADC power down */
+
+/* ACNTL2 */
+#define ACNTL2_PDN_MASK        0x40
+#define PLL_PDN                0x40 /* PLL power down */
+
+/* VBICNTL */
+
+/* RTSEL : control the real time signal output from the MPOUT pin */
+#define RTSEL_MASK  0x07
+#define RTSEL_VLOSS 0x00 /* 0000 = Video loss */
+#define RTSEL_HLOCK 0x01 /* 0001 = H-lock */
+#define RTSEL_SLOCK 0x02 /* 0010 = S-lock */
+#define RTSEL_VLOCK 0x03 /* 0011 = V-lock */
+#define RTSEL_MONO  0x04 /* 0100 = MONO */
+#define RTSEL_DET50 0x05 /* 0101 = DET50 */
+#define RTSEL_FIELD 0x06 /* 0110 = FIELD */
+#define RTSEL_RTCO  0x07 /* 0111 = RTCO ( Real Time Control ) */
+
+/* HSYNC start and end are constant for now */
+#define HSYNC_START    0x0260
+#define HSYNC_END      0x0300
+
+/*
+ * structure
+ */
+
+struct regval_list {
+       unsigned char reg_num;
+       unsigned char value;
+};
+
+struct tw9910_scale_ctrl {
+       char           *name;
+       unsigned short  width;
+       unsigned short  height;
+       u16             hscale;
+       u16             vscale;
+};
+
+struct tw9910_priv {
+       struct v4l2_subdev              subdev;
+       struct tw9910_video_info        *info;
+       const struct tw9910_scale_ctrl  *scale;
+       v4l2_std_id                     norm;
+       u32                             revision;
+};
+
+static const struct tw9910_scale_ctrl tw9910_ntsc_scales[] = {
+       {
+               .name   = "NTSC SQ",
+               .width  = 640,
+               .height = 480,
+               .hscale = 0x0100,
+               .vscale = 0x0100,
+       },
+       {
+               .name   = "NTSC CCIR601",
+               .width  = 720,
+               .height = 480,
+               .hscale = 0x0100,
+               .vscale = 0x0100,
+       },
+       {
+               .name   = "NTSC SQ (CIF)",
+               .width  = 320,
+               .height = 240,
+               .hscale = 0x0200,
+               .vscale = 0x0200,
+       },
+       {
+               .name   = "NTSC CCIR601 (CIF)",
+               .width  = 360,
+               .height = 240,
+               .hscale = 0x0200,
+               .vscale = 0x0200,
+       },
+       {
+               .name   = "NTSC SQ (QCIF)",
+               .width  = 160,
+               .height = 120,
+               .hscale = 0x0400,
+               .vscale = 0x0400,
+       },
+       {
+               .name   = "NTSC CCIR601 (QCIF)",
+               .width  = 180,
+               .height = 120,
+               .hscale = 0x0400,
+               .vscale = 0x0400,
+       },
+};
+
+static const struct tw9910_scale_ctrl tw9910_pal_scales[] = {
+       {
+               .name   = "PAL SQ",
+               .width  = 768,
+               .height = 576,
+               .hscale = 0x0100,
+               .vscale = 0x0100,
+       },
+       {
+               .name   = "PAL CCIR601",
+               .width  = 720,
+               .height = 576,
+               .hscale = 0x0100,
+               .vscale = 0x0100,
+       },
+       {
+               .name   = "PAL SQ (CIF)",
+               .width  = 384,
+               .height = 288,
+               .hscale = 0x0200,
+               .vscale = 0x0200,
+       },
+       {
+               .name   = "PAL CCIR601 (CIF)",
+               .width  = 360,
+               .height = 288,
+               .hscale = 0x0200,
+               .vscale = 0x0200,
+       },
+       {
+               .name   = "PAL SQ (QCIF)",
+               .width  = 192,
+               .height = 144,
+               .hscale = 0x0400,
+               .vscale = 0x0400,
+       },
+       {
+               .name   = "PAL CCIR601 (QCIF)",
+               .width  = 180,
+               .height = 144,
+               .hscale = 0x0400,
+               .vscale = 0x0400,
+       },
+};
+
+/*
+ * general function
+ */
+static struct tw9910_priv *to_tw9910(const struct i2c_client *client)
+{
+       return container_of(i2c_get_clientdata(client), struct tw9910_priv,
+                           subdev);
+}
+
+static int tw9910_mask_set(struct i2c_client *client, u8 command,
+                          u8 mask, u8 set)
+{
+       s32 val = i2c_smbus_read_byte_data(client, command);
+       if (val < 0)
+               return val;
+
+       val &= ~mask;
+       val |= set & mask;
+
+       return i2c_smbus_write_byte_data(client, command, val);
+}
+
+static int tw9910_set_scale(struct i2c_client *client,
+                           const struct tw9910_scale_ctrl *scale)
+{
+       int ret;
+
+       ret = i2c_smbus_write_byte_data(client, SCALE_HI,
+                                       (scale->vscale & 0x0F00) >> 4 |
+                                       (scale->hscale & 0x0F00) >> 8);
+       if (ret < 0)
+               return ret;
+
+       ret = i2c_smbus_write_byte_data(client, HSCALE_LO,
+                                       scale->hscale & 0x00FF);
+       if (ret < 0)
+               return ret;
+
+       ret = i2c_smbus_write_byte_data(client, VSCALE_LO,
+                                       scale->vscale & 0x00FF);
+
+       return ret;
+}
+
+static int tw9910_set_hsync(struct i2c_client *client)
+{
+       struct tw9910_priv *priv = to_tw9910(client);
+       int ret;
+
+       /* bit 10 - 3 */
+       ret = i2c_smbus_write_byte_data(client, HSBEGIN,
+                                       (HSYNC_START & 0x07F8) >> 3);
+       if (ret < 0)
+               return ret;
+
+       /* bit 10 - 3 */
+       ret = i2c_smbus_write_byte_data(client, HSEND,
+                                       (HSYNC_END & 0x07F8) >> 3);
+       if (ret < 0)
+               return ret;
+
+       /* So far only revisions 0 and 1 have been seen */
+       /* bit 2 - 0 */
+       if (1 == priv->revision)
+               ret = tw9910_mask_set(client, HSLOWCTL, 0x77,
+                                     (HSYNC_START & 0x0007) << 4 |
+                                     (HSYNC_END   & 0x0007));
+
+       return ret;
+}
+
+static void tw9910_reset(struct i2c_client *client)
+{
+       tw9910_mask_set(client, ACNTL1, SRESET, SRESET);
+       msleep(1);
+}
+
+static int tw9910_power(struct i2c_client *client, int enable)
+{
+       int ret;
+       u8 acntl1;
+       u8 acntl2;
+
+       if (enable) {
+               acntl1 = 0;
+               acntl2 = 0;
+       } else {
+               acntl1 = CLK_PDN | Y_PDN | C_PDN;
+               acntl2 = PLL_PDN;
+       }
+
+       ret = tw9910_mask_set(client, ACNTL1, ACNTL1_PDN_MASK, acntl1);
+       if (ret < 0)
+               return ret;
+
+       return tw9910_mask_set(client, ACNTL2, ACNTL2_PDN_MASK, acntl2);
+}
+
+static const struct tw9910_scale_ctrl *tw9910_select_norm(v4l2_std_id norm,
+                                                         u32 width, u32 height)
+{
+       const struct tw9910_scale_ctrl *scale;
+       const struct tw9910_scale_ctrl *ret = NULL;
+       __u32 diff = 0xffffffff, tmp;
+       int size, i;
+
+       if (norm & V4L2_STD_NTSC) {
+               scale = tw9910_ntsc_scales;
+               size = ARRAY_SIZE(tw9910_ntsc_scales);
+       } else if (norm & V4L2_STD_PAL) {
+               scale = tw9910_pal_scales;
+               size = ARRAY_SIZE(tw9910_pal_scales);
+       } else {
+               return NULL;
+       }
+
+       for (i = 0; i < size; i++) {
+               tmp = abs(width - scale[i].width) +
+                       abs(height - scale[i].height);
+               if (tmp < diff) {
+                       diff = tmp;
+                       ret = scale + i;
+               }
+       }
+
+       return ret;
+}
+
+/*
+ * subdevice operations
+ */
+static int tw9910_s_stream(struct v4l2_subdev *sd, int enable)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct tw9910_priv *priv = to_tw9910(client);
+       u8 val;
+       int ret;
+
+       if (!enable) {
+               switch (priv->revision) {
+               case 0:
+                       val = OEN_TRI_SEL_ALL_OFF_r0;
+                       break;
+               case 1:
+                       val = OEN_TRI_SEL_ALL_OFF_r1;
+                       break;
+               default:
+                       dev_err(&client->dev, "un-supported revision\n");
+                       return -EINVAL;
+               }
+       } else {
+               val = OEN_TRI_SEL_ALL_ON;
+
+               if (!priv->scale) {
+                       dev_err(&client->dev, "norm select error\n");
+                       return -EPERM;
+               }
+
+               dev_dbg(&client->dev, "%s %dx%d\n",
+                       priv->scale->name,
+                       priv->scale->width,
+                       priv->scale->height);
+       }
+
+       ret = tw9910_mask_set(client, OPFORM, OEN_TRI_SEL_MASK, val);
+       if (ret < 0)
+               return ret;
+
+       return tw9910_power(client, enable);
+}
+
+static int tw9910_g_std(struct v4l2_subdev *sd, v4l2_std_id *norm)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct tw9910_priv *priv = to_tw9910(client);
+
+       *norm = priv->norm;
+
+       return 0;
+}
+
+static int tw9910_s_std(struct v4l2_subdev *sd, v4l2_std_id norm)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct tw9910_priv *priv = to_tw9910(client);
+
+       if (!(norm & (V4L2_STD_NTSC | V4L2_STD_PAL)))
+               return -EINVAL;
+
+       priv->norm = norm;
+
+       return 0;
+}
+
+static int tw9910_g_chip_ident(struct v4l2_subdev *sd,
+                              struct v4l2_dbg_chip_ident *id)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct tw9910_priv *priv = to_tw9910(client);
+
+       id->ident = V4L2_IDENT_TW9910;
+       id->revision = priv->revision;
+
+       return 0;
+}
+
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+static int tw9910_g_register(struct v4l2_subdev *sd,
+                            struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       int ret;
+
+       if (reg->reg > 0xff)
+               return -EINVAL;
+
+       ret = i2c_smbus_read_byte_data(client, reg->reg);
+       if (ret < 0)
+               return ret;
+
+       /*
+        * ret      = int
+        * reg->val = __u64
+        */
+       reg->val = (__u64)ret;
+
+       return 0;
+}
+
+static int tw9910_s_register(struct v4l2_subdev *sd,
+                            struct v4l2_dbg_register *reg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+       if (reg->reg > 0xff ||
+           reg->val > 0xff)
+               return -EINVAL;
+
+       return i2c_smbus_write_byte_data(client, reg->reg, reg->val);
+}
+#endif
+
+static int tw9910_set_frame(struct v4l2_subdev *sd, u32 *width, u32 *height)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct tw9910_priv *priv = to_tw9910(client);
+       int ret = -EINVAL;
+       u8 val;
+
+       /*
+        * select suitable norm
+        */
+       priv->scale = tw9910_select_norm(priv->norm, *width, *height);
+       if (!priv->scale)
+               goto tw9910_set_fmt_error;
+
+       /*
+        * reset hardware
+        */
+       tw9910_reset(client);
+
+       /*
+        * set bus width
+        */
+       val = 0x00;
+       if (SOCAM_DATAWIDTH_16 == priv->info->buswidth)
+               val = LEN;
+
+       ret = tw9910_mask_set(client, OPFORM, LEN, val);
+       if (ret < 0)
+               goto tw9910_set_fmt_error;
+
+       /*
+        * select MPOUT behavior
+        */
+       switch (priv->info->mpout) {
+       case TW9910_MPO_VLOSS:
+               val = RTSEL_VLOSS; break;
+       case TW9910_MPO_HLOCK:
+               val = RTSEL_HLOCK; break;
+       case TW9910_MPO_SLOCK:
+               val = RTSEL_SLOCK; break;
+       case TW9910_MPO_VLOCK:
+               val = RTSEL_VLOCK; break;
+       case TW9910_MPO_MONO:
+               val = RTSEL_MONO;  break;
+       case TW9910_MPO_DET50:
+               val = RTSEL_DET50; break;
+       case TW9910_MPO_FIELD:
+               val = RTSEL_FIELD; break;
+       case TW9910_MPO_RTCO:
+               val = RTSEL_RTCO;  break;
+       default:
+               val = 0;
+       }
+
+       ret = tw9910_mask_set(client, VBICNTL, RTSEL_MASK, val);
+       if (ret < 0)
+               goto tw9910_set_fmt_error;
+
+       /*
+        * set scale
+        */
+       ret = tw9910_set_scale(client, priv->scale);
+       if (ret < 0)
+               goto tw9910_set_fmt_error;
+
+       /*
+        * set hsync
+        */
+       ret = tw9910_set_hsync(client);
+       if (ret < 0)
+               goto tw9910_set_fmt_error;
+
+       *width = priv->scale->width;
+       *height = priv->scale->height;
+
+       return ret;
+
+tw9910_set_fmt_error:
+
+       tw9910_reset(client);
+       priv->scale = NULL;
+
+       return ret;
+}
+
+static int tw9910_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct tw9910_priv *priv = to_tw9910(client);
+
+       a->c.left       = 0;
+       a->c.top        = 0;
+       if (priv->norm & V4L2_STD_NTSC) {
+               a->c.width      = 640;
+               a->c.height     = 480;
+       } else {
+               a->c.width      = 768;
+               a->c.height     = 576;
+       }
+       a->type         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+       return 0;
+}
+
+static int tw9910_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct tw9910_priv *priv = to_tw9910(client);
+
+       a->bounds.left                  = 0;
+       a->bounds.top                   = 0;
+       if (priv->norm & V4L2_STD_NTSC) {
+               a->bounds.width         = 640;
+               a->bounds.height        = 480;
+       } else {
+               a->bounds.width         = 768;
+               a->bounds.height        = 576;
+       }
+       a->defrect                      = a->bounds;
+       a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+       a->pixelaspect.numerator        = 1;
+       a->pixelaspect.denominator      = 1;
+
+       return 0;
+}
+
+static int tw9910_g_fmt(struct v4l2_subdev *sd,
+                       struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct tw9910_priv *priv = to_tw9910(client);
+
+       if (!priv->scale) {
+               priv->scale = tw9910_select_norm(priv->norm, 640, 480);
+               if (!priv->scale)
+                       return -EINVAL;
+       }
+
+       mf->width       = priv->scale->width;
+       mf->height      = priv->scale->height;
+       mf->code        = V4L2_MBUS_FMT_UYVY8_2X8;
+       mf->colorspace  = V4L2_COLORSPACE_JPEG;
+       mf->field       = V4L2_FIELD_INTERLACED_BT;
+
+       return 0;
+}
+
+static int tw9910_s_fmt(struct v4l2_subdev *sd,
+                       struct v4l2_mbus_framefmt *mf)
+{
+       u32 width = mf->width, height = mf->height;
+       int ret;
+
+       WARN_ON(mf->field != V4L2_FIELD_ANY &&
+               mf->field != V4L2_FIELD_INTERLACED_BT);
+
+       /*
+        * check color format
+        */
+       if (mf->code != V4L2_MBUS_FMT_UYVY8_2X8)
+               return -EINVAL;
+
+       mf->colorspace = V4L2_COLORSPACE_JPEG;
+
+       ret = tw9910_set_frame(sd, &width, &height);
+       if (!ret) {
+               mf->width       = width;
+               mf->height      = height;
+       }
+       return ret;
+}
+
+static int tw9910_try_fmt(struct v4l2_subdev *sd,
+                         struct v4l2_mbus_framefmt *mf)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct tw9910_priv *priv = to_tw9910(client);
+       const struct tw9910_scale_ctrl *scale;
+
+       if (V4L2_FIELD_ANY == mf->field) {
+               mf->field = V4L2_FIELD_INTERLACED_BT;
+       } else if (V4L2_FIELD_INTERLACED_BT != mf->field) {
+               dev_err(&client->dev, "Field type %d invalid.\n", mf->field);
+               return -EINVAL;
+       }
+
+       mf->code = V4L2_MBUS_FMT_UYVY8_2X8;
+       mf->colorspace = V4L2_COLORSPACE_JPEG;
+
+       /*
+        * select suitable norm
+        */
+       scale = tw9910_select_norm(priv->norm, mf->width, mf->height);
+       if (!scale)
+               return -EINVAL;
+
+       mf->width       = scale->width;
+       mf->height      = scale->height;
+
+       return 0;
+}
+
+static int tw9910_video_probe(struct i2c_client *client)
+{
+       struct tw9910_priv *priv = to_tw9910(client);
+       s32 id;
+
+       /*
+        * tw9910 only use 8 or 16 bit bus width
+        */
+       if (SOCAM_DATAWIDTH_16 != priv->info->buswidth &&
+           SOCAM_DATAWIDTH_8  != priv->info->buswidth) {
+               dev_err(&client->dev, "bus width error\n");
+               return -ENODEV;
+       }
+
+       /*
+        * check and show Product ID
+        * So far only revisions 0 and 1 have been seen
+        */
+       id = i2c_smbus_read_byte_data(client, ID);
+       priv->revision = GET_REV(id);
+       id = GET_ID(id);
+
+       if (0x0B != id ||
+           0x01 < priv->revision) {
+               dev_err(&client->dev,
+                       "Product ID error %x:%x\n",
+                       id, priv->revision);
+               return -ENODEV;
+       }
+
+       dev_info(&client->dev,
+                "tw9910 Product ID %0x:%0x\n", id, priv->revision);
+
+       priv->norm = V4L2_STD_NTSC;
+
+       return 0;
+}
+
+static struct v4l2_subdev_core_ops tw9910_subdev_core_ops = {
+       .g_chip_ident   = tw9910_g_chip_ident,
+       .s_std          = tw9910_s_std,
+       .g_std          = tw9910_g_std,
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+       .g_register     = tw9910_g_register,
+       .s_register     = tw9910_s_register,
+#endif
+};
+
+static int tw9910_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
+                          enum v4l2_mbus_pixelcode *code)
+{
+       if (index)
+               return -EINVAL;
+
+       *code = V4L2_MBUS_FMT_UYVY8_2X8;
+       return 0;
+}
+
+static int tw9910_g_mbus_config(struct v4l2_subdev *sd,
+                               struct v4l2_mbus_config *cfg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+
+       cfg->flags = V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_MASTER |
+               V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_LOW |
+               V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_HSYNC_ACTIVE_LOW |
+               V4L2_MBUS_DATA_ACTIVE_HIGH;
+       cfg->type = V4L2_MBUS_PARALLEL;
+       cfg->flags = soc_camera_apply_board_flags(icl, cfg);
+
+       return 0;
+}
+
+static int tw9910_s_mbus_config(struct v4l2_subdev *sd,
+                               const struct v4l2_mbus_config *cfg)
+{
+       struct i2c_client *client = v4l2_get_subdevdata(sd);
+       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
+       u8 val = VSSL_VVALID | HSSL_DVALID;
+       unsigned long flags = soc_camera_apply_board_flags(icl, cfg);
+
+       /*
+        * set OUTCTR1
+        *
+        * We use VVALID and DVALID signals to control VSYNC and HSYNC
+        * outputs, in this mode their polarity is inverted.
+        */
+       if (flags & V4L2_MBUS_HSYNC_ACTIVE_LOW)
+               val |= HSP_HI;
+
+       if (flags & V4L2_MBUS_VSYNC_ACTIVE_LOW)
+               val |= VSP_HI;
+
+       return i2c_smbus_write_byte_data(client, OUTCTR1, val);
+}
+
+static struct v4l2_subdev_video_ops tw9910_subdev_video_ops = {
+       .s_stream       = tw9910_s_stream,
+       .g_mbus_fmt     = tw9910_g_fmt,
+       .s_mbus_fmt     = tw9910_s_fmt,
+       .try_mbus_fmt   = tw9910_try_fmt,
+       .cropcap        = tw9910_cropcap,
+       .g_crop         = tw9910_g_crop,
+       .enum_mbus_fmt  = tw9910_enum_fmt,
+       .g_mbus_config  = tw9910_g_mbus_config,
+       .s_mbus_config  = tw9910_s_mbus_config,
+};
+
+static struct v4l2_subdev_ops tw9910_subdev_ops = {
+       .core   = &tw9910_subdev_core_ops,
+       .video  = &tw9910_subdev_video_ops,
+};
+
+/*
+ * i2c_driver function
+ */
+
+static int tw9910_probe(struct i2c_client *client,
+                       const struct i2c_device_id *did)
+
+{
+       struct tw9910_priv              *priv;
+       struct tw9910_video_info        *info;
+       struct i2c_adapter              *adapter =
+               to_i2c_adapter(client->dev.parent);
+       struct soc_camera_link          *icl = soc_camera_i2c_to_link(client);
+       int                             ret;
+
+       if (!icl || !icl->priv) {
+               dev_err(&client->dev, "TW9910: missing platform data!\n");
+               return -EINVAL;
+       }
+
+       info = icl->priv;
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
+               dev_err(&client->dev,
+                       "I2C-Adapter doesn't support "
+                       "I2C_FUNC_SMBUS_BYTE_DATA\n");
+               return -EIO;
+       }
+
+       priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+       if (!priv)
+               return -ENOMEM;
+
+       priv->info   = info;
+
+       v4l2_i2c_subdev_init(&priv->subdev, client, &tw9910_subdev_ops);
+
+       ret = tw9910_video_probe(client);
+       if (ret)
+               kfree(priv);
+
+       return ret;
+}
+
+static int tw9910_remove(struct i2c_client *client)
+{
+       struct tw9910_priv *priv = to_tw9910(client);
+
+       kfree(priv);
+       return 0;
+}
+
+static const struct i2c_device_id tw9910_id[] = {
+       { "tw9910", 0 },
+       { }
+};
+MODULE_DEVICE_TABLE(i2c, tw9910_id);
+
+static struct i2c_driver tw9910_i2c_driver = {
+       .driver = {
+               .name = "tw9910",
+       },
+       .probe    = tw9910_probe,
+       .remove   = tw9910_remove,
+       .id_table = tw9910_id,
+};
+
+module_i2c_driver(tw9910_i2c_driver);
+
+MODULE_DESCRIPTION("SoC Camera driver for tw9910");
+MODULE_AUTHOR("Kuninori Morimoto");
+MODULE_LICENSE("GPL v2");
index f2171e777dd3d260446c64523837ae2a2d4a2867..28b25bf3580501e57baa8639cd86f78312c2ae9d 100644 (file)
@@ -127,57 +127,6 @@ config SOC_CAMERA
          over a bus like PCI or USB. For example some i2c camera connected
          directly to the data bus of an SoC.
 
-config SOC_CAMERA_IMX074
-       tristate "imx074 support"
-       depends on SOC_CAMERA && I2C
-       help
-         This driver supports IMX074 cameras from Sony
-
-config SOC_CAMERA_MT9M001
-       tristate "mt9m001 support"
-       depends on SOC_CAMERA && I2C
-       select GPIO_PCA953X if MT9M001_PCA9536_SWITCH
-       help
-         This driver supports MT9M001 cameras from Micron, monochrome
-         and colour models.
-
-config SOC_CAMERA_MT9M111
-       tristate "mt9m111, mt9m112 and mt9m131 support"
-       depends on SOC_CAMERA && I2C
-       help
-         This driver supports MT9M111, MT9M112 and MT9M131 cameras from
-         Micron/Aptina
-
-config SOC_CAMERA_MT9T031
-       tristate "mt9t031 support"
-       depends on SOC_CAMERA && I2C
-       help
-         This driver supports MT9T031 cameras from Micron.
-
-config SOC_CAMERA_MT9T112
-       tristate "mt9t112 support"
-       depends on SOC_CAMERA && I2C
-       help
-         This driver supports MT9T112 cameras from Aptina.
-
-config SOC_CAMERA_MT9V022
-       tristate "mt9v022 support"
-       depends on SOC_CAMERA && I2C
-       select GPIO_PCA953X if MT9V022_PCA9536_SWITCH
-       help
-         This driver supports MT9V022 cameras from Micron
-
-config SOC_CAMERA_RJ54N1
-       tristate "rj54n1cb0c support"
-       depends on SOC_CAMERA && I2C
-       help
-         This is a rj54n1cb0c video driver
-
-config SOC_CAMERA_TW9910
-       tristate "tw9910 support"
-       depends on SOC_CAMERA && I2C
-       help
-         This is a tw9910 video driver
 
 config SOC_CAMERA_PLATFORM
        tristate "platform camera support"
@@ -185,42 +134,6 @@ config SOC_CAMERA_PLATFORM
        help
          This is a generic SoC camera platform driver, useful for testing
 
-config SOC_CAMERA_OV2640
-       tristate "ov2640 camera support"
-       depends on SOC_CAMERA && I2C
-       help
-         This is a ov2640 camera driver
-
-config SOC_CAMERA_OV5642
-       tristate "ov5642 camera support"
-       depends on SOC_CAMERA && I2C
-       help
-         This is a V4L2 camera driver for the OmniVision OV5642 sensor
-
-config SOC_CAMERA_OV6650
-       tristate "ov6650 sensor support"
-       depends on SOC_CAMERA && I2C
-       ---help---
-         This is a V4L2 SoC camera driver for the OmniVision OV6650 sensor
-
-config SOC_CAMERA_OV772X
-       tristate "ov772x camera support"
-       depends on SOC_CAMERA && I2C
-       help
-         This is a ov772x camera driver
-
-config SOC_CAMERA_OV9640
-       tristate "ov9640 camera support"
-       depends on SOC_CAMERA && I2C
-       help
-         This is a ov9640 camera driver
-
-config SOC_CAMERA_OV9740
-       tristate "ov9740 camera support"
-       depends on SOC_CAMERA && I2C
-       help
-         This is a ov9740 camera driver
-
 config MX1_VIDEO
        bool
 
index 52a04faa60e837b43d69bb166a174bf24b711027..b3effdc65f76d0c71bf1b2f8446a3232cea44fb2 100644 (file)
@@ -6,21 +6,6 @@ omap2cam-objs  :=      omap24xxcam.o omap24xxcam-dma.o
 
 obj-$(CONFIG_VIDEO_VINO) += indycam.o
 
-obj-$(CONFIG_SOC_CAMERA_IMX074)                += imx074.o
-obj-$(CONFIG_SOC_CAMERA_MT9M001)       += mt9m001.o
-obj-$(CONFIG_SOC_CAMERA_MT9M111)       += mt9m111.o
-obj-$(CONFIG_SOC_CAMERA_MT9T031)       += mt9t031.o
-obj-$(CONFIG_SOC_CAMERA_MT9T112)       += mt9t112.o
-obj-$(CONFIG_SOC_CAMERA_MT9V022)       += mt9v022.o
-obj-$(CONFIG_SOC_CAMERA_OV2640)                += ov2640.o
-obj-$(CONFIG_SOC_CAMERA_OV5642)                += ov5642.o
-obj-$(CONFIG_SOC_CAMERA_OV6650)                += ov6650.o
-obj-$(CONFIG_SOC_CAMERA_OV772X)                += ov772x.o
-obj-$(CONFIG_SOC_CAMERA_OV9640)                += ov9640.o
-obj-$(CONFIG_SOC_CAMERA_OV9740)                += ov9740.o
-obj-$(CONFIG_SOC_CAMERA_RJ54N1)                += rj54n1cb0c.o
-obj-$(CONFIG_SOC_CAMERA_TW9910)                += tw9910.o
-
 obj-$(CONFIG_VIDEO_VINO) += vino.o
 obj-$(CONFIG_VIDEO_TIMBERDALE) += timblogiw.o
 
@@ -78,3 +63,4 @@ obj-$(CONFIG_ARCH_OMAP)       += omap/
 ccflags-y += -I$(srctree)/drivers/media/dvb-core
 ccflags-y += -I$(srctree)/drivers/media/dvb-frontends
 ccflags-y += -I$(srctree)/drivers/media/tuners
+ccflags-y += -I$(srctree)/drivers/media/i2c/soc_camera
diff --git a/drivers/media/video/imx074.c b/drivers/media/video/imx074.c
deleted file mode 100644 (file)
index 351e9ba..0000000
+++ /dev/null
@@ -1,475 +0,0 @@
-/*
- * Driver for IMX074 CMOS Image Sensor from Sony
- *
- * Copyright (C) 2010, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
- *
- * Partially inspired by the IMX074 driver from the Android / MSM tree
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include <linux/delay.h>
-#include <linux/i2c.h>
-#include <linux/v4l2-mediabus.h>
-#include <linux/slab.h>
-#include <linux/videodev2.h>
-#include <linux/module.h>
-
-#include <media/soc_camera.h>
-#include <media/v4l2-subdev.h>
-#include <media/v4l2-chip-ident.h>
-
-/* IMX074 registers */
-
-#define MODE_SELECT                    0x0100
-#define IMAGE_ORIENTATION              0x0101
-#define GROUPED_PARAMETER_HOLD         0x0104
-
-/* Integration Time */
-#define COARSE_INTEGRATION_TIME_HI     0x0202
-#define COARSE_INTEGRATION_TIME_LO     0x0203
-/* Gain */
-#define ANALOGUE_GAIN_CODE_GLOBAL_HI   0x0204
-#define ANALOGUE_GAIN_CODE_GLOBAL_LO   0x0205
-
-/* PLL registers */
-#define PRE_PLL_CLK_DIV                        0x0305
-#define PLL_MULTIPLIER                 0x0307
-#define PLSTATIM                       0x302b
-#define VNDMY_ABLMGSHLMT               0x300a
-#define Y_OPBADDR_START_DI             0x3014
-/* mode setting */
-#define FRAME_LENGTH_LINES_HI          0x0340
-#define FRAME_LENGTH_LINES_LO          0x0341
-#define LINE_LENGTH_PCK_HI             0x0342
-#define LINE_LENGTH_PCK_LO             0x0343
-#define YADDR_START                    0x0347
-#define YADDR_END                      0x034b
-#define X_OUTPUT_SIZE_MSB              0x034c
-#define X_OUTPUT_SIZE_LSB              0x034d
-#define Y_OUTPUT_SIZE_MSB              0x034e
-#define Y_OUTPUT_SIZE_LSB              0x034f
-#define X_EVEN_INC                     0x0381
-#define X_ODD_INC                      0x0383
-#define Y_EVEN_INC                     0x0385
-#define Y_ODD_INC                      0x0387
-
-#define HMODEADD                       0x3001
-#define VMODEADD                       0x3016
-#define VAPPLINE_START                 0x3069
-#define VAPPLINE_END                   0x306b
-#define SHUTTER                                0x3086
-#define HADDAVE                                0x30e8
-#define LANESEL                                0x3301
-
-/* IMX074 supported geometry */
-#define IMX074_WIDTH                   1052
-#define IMX074_HEIGHT                  780
-
-/* IMX074 has only one fixed colorspace per pixelcode */
-struct imx074_datafmt {
-       enum v4l2_mbus_pixelcode        code;
-       enum v4l2_colorspace            colorspace;
-};
-
-struct imx074 {
-       struct v4l2_subdev              subdev;
-       const struct imx074_datafmt     *fmt;
-};
-
-static const struct imx074_datafmt imx074_colour_fmts[] = {
-       {V4L2_MBUS_FMT_SBGGR8_1X8, V4L2_COLORSPACE_SRGB},
-};
-
-static struct imx074 *to_imx074(const struct i2c_client *client)
-{
-       return container_of(i2c_get_clientdata(client), struct imx074, subdev);
-}
-
-/* Find a data format by a pixel code in an array */
-static const struct imx074_datafmt *imx074_find_datafmt(enum v4l2_mbus_pixelcode code)
-{
-       int i;
-
-       for (i = 0; i < ARRAY_SIZE(imx074_colour_fmts); i++)
-               if (imx074_colour_fmts[i].code == code)
-                       return imx074_colour_fmts + i;
-
-       return NULL;
-}
-
-static int reg_write(struct i2c_client *client, const u16 addr, const u8 data)
-{
-       struct i2c_adapter *adap = client->adapter;
-       struct i2c_msg msg;
-       unsigned char tx[3];
-       int ret;
-
-       msg.addr = client->addr;
-       msg.buf = tx;
-       msg.len = 3;
-       msg.flags = 0;
-
-       tx[0] = addr >> 8;
-       tx[1] = addr & 0xff;
-       tx[2] = data;
-
-       ret = i2c_transfer(adap, &msg, 1);
-
-       mdelay(2);
-
-       return ret == 1 ? 0 : -EIO;
-}
-
-static int reg_read(struct i2c_client *client, const u16 addr)
-{
-       u8 buf[2] = {addr >> 8, addr & 0xff};
-       int ret;
-       struct i2c_msg msgs[] = {
-               {
-                       .addr  = client->addr,
-                       .flags = 0,
-                       .len   = 2,
-                       .buf   = buf,
-               }, {
-                       .addr  = client->addr,
-                       .flags = I2C_M_RD,
-                       .len   = 2,
-                       .buf   = buf,
-               },
-       };
-
-       ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
-       if (ret < 0) {
-               dev_warn(&client->dev, "Reading register %x from %x failed\n",
-                        addr, client->addr);
-               return ret;
-       }
-
-       return buf[0] & 0xff; /* no sign-extension */
-}
-
-static int imx074_try_fmt(struct v4l2_subdev *sd,
-                         struct v4l2_mbus_framefmt *mf)
-{
-       const struct imx074_datafmt *fmt = imx074_find_datafmt(mf->code);
-
-       dev_dbg(sd->v4l2_dev->dev, "%s(%u)\n", __func__, mf->code);
-
-       if (!fmt) {
-               mf->code        = imx074_colour_fmts[0].code;
-               mf->colorspace  = imx074_colour_fmts[0].colorspace;
-       }
-
-       mf->width       = IMX074_WIDTH;
-       mf->height      = IMX074_HEIGHT;
-       mf->field       = V4L2_FIELD_NONE;
-
-       return 0;
-}
-
-static int imx074_s_fmt(struct v4l2_subdev *sd,
-                       struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct imx074 *priv = to_imx074(client);
-
-       dev_dbg(sd->v4l2_dev->dev, "%s(%u)\n", __func__, mf->code);
-
-       /* MIPI CSI could have changed the format, double-check */
-       if (!imx074_find_datafmt(mf->code))
-               return -EINVAL;
-
-       imx074_try_fmt(sd, mf);
-
-       priv->fmt = imx074_find_datafmt(mf->code);
-
-       return 0;
-}
-
-static int imx074_g_fmt(struct v4l2_subdev *sd,
-                       struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct imx074 *priv = to_imx074(client);
-
-       const struct imx074_datafmt *fmt = priv->fmt;
-
-       mf->code        = fmt->code;
-       mf->colorspace  = fmt->colorspace;
-       mf->width       = IMX074_WIDTH;
-       mf->height      = IMX074_HEIGHT;
-       mf->field       = V4L2_FIELD_NONE;
-
-       return 0;
-}
-
-static int imx074_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
-{
-       struct v4l2_rect *rect = &a->c;
-
-       a->type         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-       rect->top       = 0;
-       rect->left      = 0;
-       rect->width     = IMX074_WIDTH;
-       rect->height    = IMX074_HEIGHT;
-
-       return 0;
-}
-
-static int imx074_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
-{
-       a->bounds.left                  = 0;
-       a->bounds.top                   = 0;
-       a->bounds.width                 = IMX074_WIDTH;
-       a->bounds.height                = IMX074_HEIGHT;
-       a->defrect                      = a->bounds;
-       a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-       a->pixelaspect.numerator        = 1;
-       a->pixelaspect.denominator      = 1;
-
-       return 0;
-}
-
-static int imx074_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                          enum v4l2_mbus_pixelcode *code)
-{
-       if ((unsigned int)index >= ARRAY_SIZE(imx074_colour_fmts))
-               return -EINVAL;
-
-       *code = imx074_colour_fmts[index].code;
-       return 0;
-}
-
-static int imx074_s_stream(struct v4l2_subdev *sd, int enable)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-
-       /* MODE_SELECT: stream or standby */
-       return reg_write(client, MODE_SELECT, !!enable);
-}
-
-static int imx074_g_chip_ident(struct v4l2_subdev *sd,
-                              struct v4l2_dbg_chip_ident *id)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-
-       if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
-               return -EINVAL;
-
-       if (id->match.addr != client->addr)
-               return -ENODEV;
-
-       id->ident       = V4L2_IDENT_IMX074;
-       id->revision    = 0;
-
-       return 0;
-}
-
-static int imx074_g_mbus_config(struct v4l2_subdev *sd,
-                               struct v4l2_mbus_config *cfg)
-{
-       cfg->type = V4L2_MBUS_CSI2;
-       cfg->flags = V4L2_MBUS_CSI2_2_LANE |
-               V4L2_MBUS_CSI2_CHANNEL_0 |
-               V4L2_MBUS_CSI2_CONTINUOUS_CLOCK;
-
-       return 0;
-}
-
-static struct v4l2_subdev_video_ops imx074_subdev_video_ops = {
-       .s_stream       = imx074_s_stream,
-       .s_mbus_fmt     = imx074_s_fmt,
-       .g_mbus_fmt     = imx074_g_fmt,
-       .try_mbus_fmt   = imx074_try_fmt,
-       .enum_mbus_fmt  = imx074_enum_fmt,
-       .g_crop         = imx074_g_crop,
-       .cropcap        = imx074_cropcap,
-       .g_mbus_config  = imx074_g_mbus_config,
-};
-
-static struct v4l2_subdev_core_ops imx074_subdev_core_ops = {
-       .g_chip_ident   = imx074_g_chip_ident,
-};
-
-static struct v4l2_subdev_ops imx074_subdev_ops = {
-       .core   = &imx074_subdev_core_ops,
-       .video  = &imx074_subdev_video_ops,
-};
-
-static int imx074_video_probe(struct i2c_client *client)
-{
-       int ret;
-       u16 id;
-
-       /* Read sensor Model ID */
-       ret = reg_read(client, 0);
-       if (ret < 0)
-               return ret;
-
-       id = ret << 8;
-
-       ret = reg_read(client, 1);
-       if (ret < 0)
-               return ret;
-
-       id |= ret;
-
-       dev_info(&client->dev, "Chip ID 0x%04x detected\n", id);
-
-       if (id != 0x74)
-               return -ENODEV;
-
-       /* PLL Setting EXTCLK=24MHz, 22.5times */
-       reg_write(client, PLL_MULTIPLIER, 0x2D);
-       reg_write(client, PRE_PLL_CLK_DIV, 0x02);
-       reg_write(client, PLSTATIM, 0x4B);
-
-       /* 2-lane mode */
-       reg_write(client, 0x3024, 0x00);
-
-       reg_write(client, IMAGE_ORIENTATION, 0x00);
-
-       /* select RAW mode:
-        * 0x08+0x08 = top 8 bits
-        * 0x0a+0x08 = compressed 8-bits
-        * 0x0a+0x0a = 10 bits
-        */
-       reg_write(client, 0x0112, 0x08);
-       reg_write(client, 0x0113, 0x08);
-
-       /* Base setting for High frame mode */
-       reg_write(client, VNDMY_ABLMGSHLMT, 0x80);
-       reg_write(client, Y_OPBADDR_START_DI, 0x08);
-       reg_write(client, 0x3015, 0x37);
-       reg_write(client, 0x301C, 0x01);
-       reg_write(client, 0x302C, 0x05);
-       reg_write(client, 0x3031, 0x26);
-       reg_write(client, 0x3041, 0x60);
-       reg_write(client, 0x3051, 0x24);
-       reg_write(client, 0x3053, 0x34);
-       reg_write(client, 0x3057, 0xC0);
-       reg_write(client, 0x305C, 0x09);
-       reg_write(client, 0x305D, 0x07);
-       reg_write(client, 0x3060, 0x30);
-       reg_write(client, 0x3065, 0x00);
-       reg_write(client, 0x30AA, 0x08);
-       reg_write(client, 0x30AB, 0x1C);
-       reg_write(client, 0x30B0, 0x32);
-       reg_write(client, 0x30B2, 0x83);
-       reg_write(client, 0x30D3, 0x04);
-       reg_write(client, 0x3106, 0x78);
-       reg_write(client, 0x310C, 0x82);
-       reg_write(client, 0x3304, 0x05);
-       reg_write(client, 0x3305, 0x04);
-       reg_write(client, 0x3306, 0x11);
-       reg_write(client, 0x3307, 0x02);
-       reg_write(client, 0x3308, 0x0C);
-       reg_write(client, 0x3309, 0x06);
-       reg_write(client, 0x330A, 0x08);
-       reg_write(client, 0x330B, 0x04);
-       reg_write(client, 0x330C, 0x08);
-       reg_write(client, 0x330D, 0x06);
-       reg_write(client, 0x330E, 0x01);
-       reg_write(client, 0x3381, 0x00);
-
-       /* V : 1/2V-addition (1,3), H : 1/2H-averaging (1,3) -> Full HD */
-       /* 1608 = 1560 + 48 (black lines) */
-       reg_write(client, FRAME_LENGTH_LINES_HI, 0x06);
-       reg_write(client, FRAME_LENGTH_LINES_LO, 0x48);
-       reg_write(client, YADDR_START, 0x00);
-       reg_write(client, YADDR_END, 0x2F);
-       /* 0x838 == 2104 */
-       reg_write(client, X_OUTPUT_SIZE_MSB, 0x08);
-       reg_write(client, X_OUTPUT_SIZE_LSB, 0x38);
-       /* 0x618 == 1560 */
-       reg_write(client, Y_OUTPUT_SIZE_MSB, 0x06);
-       reg_write(client, Y_OUTPUT_SIZE_LSB, 0x18);
-       reg_write(client, X_EVEN_INC, 0x01);
-       reg_write(client, X_ODD_INC, 0x03);
-       reg_write(client, Y_EVEN_INC, 0x01);
-       reg_write(client, Y_ODD_INC, 0x03);
-       reg_write(client, HMODEADD, 0x00);
-       reg_write(client, VMODEADD, 0x16);
-       reg_write(client, VAPPLINE_START, 0x24);
-       reg_write(client, VAPPLINE_END, 0x53);
-       reg_write(client, SHUTTER, 0x00);
-       reg_write(client, HADDAVE, 0x80);
-
-       reg_write(client, LANESEL, 0x00);
-
-       reg_write(client, GROUPED_PARAMETER_HOLD, 0x00);        /* off */
-
-       return 0;
-}
-
-static int imx074_probe(struct i2c_client *client,
-                       const struct i2c_device_id *did)
-{
-       struct imx074 *priv;
-       struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-       int ret;
-
-       if (!icl) {
-               dev_err(&client->dev, "IMX074: missing platform data!\n");
-               return -EINVAL;
-       }
-
-       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
-               dev_warn(&adapter->dev,
-                        "I2C-Adapter doesn't support I2C_FUNC_SMBUS_BYTE\n");
-               return -EIO;
-       }
-
-       priv = kzalloc(sizeof(struct imx074), GFP_KERNEL);
-       if (!priv)
-               return -ENOMEM;
-
-       v4l2_i2c_subdev_init(&priv->subdev, client, &imx074_subdev_ops);
-
-       priv->fmt       = &imx074_colour_fmts[0];
-
-       ret = imx074_video_probe(client);
-       if (ret < 0) {
-               kfree(priv);
-               return ret;
-       }
-
-       return ret;
-}
-
-static int imx074_remove(struct i2c_client *client)
-{
-       struct imx074 *priv = to_imx074(client);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-
-       if (icl->free_bus)
-               icl->free_bus(icl);
-       kfree(priv);
-
-       return 0;
-}
-
-static const struct i2c_device_id imx074_id[] = {
-       { "imx074", 0 },
-       { }
-};
-MODULE_DEVICE_TABLE(i2c, imx074_id);
-
-static struct i2c_driver imx074_i2c_driver = {
-       .driver = {
-               .name = "imx074",
-       },
-       .probe          = imx074_probe,
-       .remove         = imx074_remove,
-       .id_table       = imx074_id,
-};
-
-module_i2c_driver(imx074_i2c_driver);
-
-MODULE_DESCRIPTION("Sony IMX074 Camera driver");
-MODULE_AUTHOR("Guennadi Liakhovetski <g.liakhovetski@gmx.de>");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/video/mt9m001.c b/drivers/media/video/mt9m001.c
deleted file mode 100644 (file)
index 00583f5..0000000
+++ /dev/null
@@ -1,737 +0,0 @@
-/*
- * Driver for MT9M001 CMOS Image Sensor from Micron
- *
- * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include <linux/videodev2.h>
-#include <linux/slab.h>
-#include <linux/i2c.h>
-#include <linux/log2.h>
-#include <linux/module.h>
-
-#include <media/soc_camera.h>
-#include <media/soc_mediabus.h>
-#include <media/v4l2-subdev.h>
-#include <media/v4l2-chip-ident.h>
-#include <media/v4l2-ctrls.h>
-
-/*
- * mt9m001 i2c address 0x5d
- * The platform has to define struct i2c_board_info objects and link to them
- * from struct soc_camera_link
- */
-
-/* mt9m001 selected register addresses */
-#define MT9M001_CHIP_VERSION           0x00
-#define MT9M001_ROW_START              0x01
-#define MT9M001_COLUMN_START           0x02
-#define MT9M001_WINDOW_HEIGHT          0x03
-#define MT9M001_WINDOW_WIDTH           0x04
-#define MT9M001_HORIZONTAL_BLANKING    0x05
-#define MT9M001_VERTICAL_BLANKING      0x06
-#define MT9M001_OUTPUT_CONTROL         0x07
-#define MT9M001_SHUTTER_WIDTH          0x09
-#define MT9M001_FRAME_RESTART          0x0b
-#define MT9M001_SHUTTER_DELAY          0x0c
-#define MT9M001_RESET                  0x0d
-#define MT9M001_READ_OPTIONS1          0x1e
-#define MT9M001_READ_OPTIONS2          0x20
-#define MT9M001_GLOBAL_GAIN            0x35
-#define MT9M001_CHIP_ENABLE            0xF1
-
-#define MT9M001_MAX_WIDTH              1280
-#define MT9M001_MAX_HEIGHT             1024
-#define MT9M001_MIN_WIDTH              48
-#define MT9M001_MIN_HEIGHT             32
-#define MT9M001_COLUMN_SKIP            20
-#define MT9M001_ROW_SKIP               12
-
-/* MT9M001 has only one fixed colorspace per pixelcode */
-struct mt9m001_datafmt {
-       enum v4l2_mbus_pixelcode        code;
-       enum v4l2_colorspace            colorspace;
-};
-
-/* Find a data format by a pixel code in an array */
-static const struct mt9m001_datafmt *mt9m001_find_datafmt(
-       enum v4l2_mbus_pixelcode code, const struct mt9m001_datafmt *fmt,
-       int n)
-{
-       int i;
-       for (i = 0; i < n; i++)
-               if (fmt[i].code == code)
-                       return fmt + i;
-
-       return NULL;
-}
-
-static const struct mt9m001_datafmt mt9m001_colour_fmts[] = {
-       /*
-        * Order important: first natively supported,
-        * second supported with a GPIO extender
-        */
-       {V4L2_MBUS_FMT_SBGGR10_1X10, V4L2_COLORSPACE_SRGB},
-       {V4L2_MBUS_FMT_SBGGR8_1X8, V4L2_COLORSPACE_SRGB},
-};
-
-static const struct mt9m001_datafmt mt9m001_monochrome_fmts[] = {
-       /* Order important - see above */
-       {V4L2_MBUS_FMT_Y10_1X10, V4L2_COLORSPACE_JPEG},
-       {V4L2_MBUS_FMT_Y8_1X8, V4L2_COLORSPACE_JPEG},
-};
-
-struct mt9m001 {
-       struct v4l2_subdev subdev;
-       struct v4l2_ctrl_handler hdl;
-       struct {
-               /* exposure/auto-exposure cluster */
-               struct v4l2_ctrl *autoexposure;
-               struct v4l2_ctrl *exposure;
-       };
-       struct v4l2_rect rect;  /* Sensor window */
-       const struct mt9m001_datafmt *fmt;
-       const struct mt9m001_datafmt *fmts;
-       int num_fmts;
-       int model;      /* V4L2_IDENT_MT9M001* codes from v4l2-chip-ident.h */
-       unsigned int total_h;
-       unsigned short y_skip_top;      /* Lines to skip at the top */
-};
-
-static struct mt9m001 *to_mt9m001(const struct i2c_client *client)
-{
-       return container_of(i2c_get_clientdata(client), struct mt9m001, subdev);
-}
-
-static int reg_read(struct i2c_client *client, const u8 reg)
-{
-       return i2c_smbus_read_word_swapped(client, reg);
-}
-
-static int reg_write(struct i2c_client *client, const u8 reg,
-                    const u16 data)
-{
-       return i2c_smbus_write_word_swapped(client, reg, data);
-}
-
-static int reg_set(struct i2c_client *client, const u8 reg,
-                  const u16 data)
-{
-       int ret;
-
-       ret = reg_read(client, reg);
-       if (ret < 0)
-               return ret;
-       return reg_write(client, reg, ret | data);
-}
-
-static int reg_clear(struct i2c_client *client, const u8 reg,
-                    const u16 data)
-{
-       int ret;
-
-       ret = reg_read(client, reg);
-       if (ret < 0)
-               return ret;
-       return reg_write(client, reg, ret & ~data);
-}
-
-static int mt9m001_init(struct i2c_client *client)
-{
-       int ret;
-
-       dev_dbg(&client->dev, "%s\n", __func__);
-
-       /*
-        * We don't know, whether platform provides reset, issue a soft reset
-        * too. This returns all registers to their default values.
-        */
-       ret = reg_write(client, MT9M001_RESET, 1);
-       if (!ret)
-               ret = reg_write(client, MT9M001_RESET, 0);
-
-       /* Disable chip, synchronous option update */
-       if (!ret)
-               ret = reg_write(client, MT9M001_OUTPUT_CONTROL, 0);
-
-       return ret;
-}
-
-static int mt9m001_s_stream(struct v4l2_subdev *sd, int enable)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-
-       /* Switch to master "normal" mode or stop sensor readout */
-       if (reg_write(client, MT9M001_OUTPUT_CONTROL, enable ? 2 : 0) < 0)
-               return -EIO;
-       return 0;
-}
-
-static int mt9m001_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9m001 *mt9m001 = to_mt9m001(client);
-       struct v4l2_rect rect = a->c;
-       int ret;
-       const u16 hblank = 9, vblank = 25;
-
-       if (mt9m001->fmts == mt9m001_colour_fmts)
-               /*
-                * Bayer format - even number of rows for simplicity,
-                * but let the user play with the top row.
-                */
-               rect.height = ALIGN(rect.height, 2);
-
-       /* Datasheet requirement: see register description */
-       rect.width = ALIGN(rect.width, 2);
-       rect.left = ALIGN(rect.left, 2);
-
-       soc_camera_limit_side(&rect.left, &rect.width,
-                    MT9M001_COLUMN_SKIP, MT9M001_MIN_WIDTH, MT9M001_MAX_WIDTH);
-
-       soc_camera_limit_side(&rect.top, &rect.height,
-                    MT9M001_ROW_SKIP, MT9M001_MIN_HEIGHT, MT9M001_MAX_HEIGHT);
-
-       mt9m001->total_h = rect.height + mt9m001->y_skip_top + vblank;
-
-       /* Blanking and start values - default... */
-       ret = reg_write(client, MT9M001_HORIZONTAL_BLANKING, hblank);
-       if (!ret)
-               ret = reg_write(client, MT9M001_VERTICAL_BLANKING, vblank);
-
-       /*
-        * The caller provides a supported format, as verified per
-        * call to .try_mbus_fmt()
-        */
-       if (!ret)
-               ret = reg_write(client, MT9M001_COLUMN_START, rect.left);
-       if (!ret)
-               ret = reg_write(client, MT9M001_ROW_START, rect.top);
-       if (!ret)
-               ret = reg_write(client, MT9M001_WINDOW_WIDTH, rect.width - 1);
-       if (!ret)
-               ret = reg_write(client, MT9M001_WINDOW_HEIGHT,
-                               rect.height + mt9m001->y_skip_top - 1);
-       if (!ret && v4l2_ctrl_g_ctrl(mt9m001->autoexposure) == V4L2_EXPOSURE_AUTO)
-               ret = reg_write(client, MT9M001_SHUTTER_WIDTH, mt9m001->total_h);
-
-       if (!ret)
-               mt9m001->rect = rect;
-
-       return ret;
-}
-
-static int mt9m001_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9m001 *mt9m001 = to_mt9m001(client);
-
-       a->c    = mt9m001->rect;
-       a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-
-       return 0;
-}
-
-static int mt9m001_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
-{
-       a->bounds.left                  = MT9M001_COLUMN_SKIP;
-       a->bounds.top                   = MT9M001_ROW_SKIP;
-       a->bounds.width                 = MT9M001_MAX_WIDTH;
-       a->bounds.height                = MT9M001_MAX_HEIGHT;
-       a->defrect                      = a->bounds;
-       a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-       a->pixelaspect.numerator        = 1;
-       a->pixelaspect.denominator      = 1;
-
-       return 0;
-}
-
-static int mt9m001_g_fmt(struct v4l2_subdev *sd,
-                        struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9m001 *mt9m001 = to_mt9m001(client);
-
-       mf->width       = mt9m001->rect.width;
-       mf->height      = mt9m001->rect.height;
-       mf->code        = mt9m001->fmt->code;
-       mf->colorspace  = mt9m001->fmt->colorspace;
-       mf->field       = V4L2_FIELD_NONE;
-
-       return 0;
-}
-
-static int mt9m001_s_fmt(struct v4l2_subdev *sd,
-                        struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9m001 *mt9m001 = to_mt9m001(client);
-       struct v4l2_crop a = {
-               .c = {
-                       .left   = mt9m001->rect.left,
-                       .top    = mt9m001->rect.top,
-                       .width  = mf->width,
-                       .height = mf->height,
-               },
-       };
-       int ret;
-
-       /* No support for scaling so far, just crop. TODO: use skipping */
-       ret = mt9m001_s_crop(sd, &a);
-       if (!ret) {
-               mf->width       = mt9m001->rect.width;
-               mf->height      = mt9m001->rect.height;
-               mt9m001->fmt    = mt9m001_find_datafmt(mf->code,
-                                       mt9m001->fmts, mt9m001->num_fmts);
-               mf->colorspace  = mt9m001->fmt->colorspace;
-       }
-
-       return ret;
-}
-
-static int mt9m001_try_fmt(struct v4l2_subdev *sd,
-                          struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9m001 *mt9m001 = to_mt9m001(client);
-       const struct mt9m001_datafmt *fmt;
-
-       v4l_bound_align_image(&mf->width, MT9M001_MIN_WIDTH,
-               MT9M001_MAX_WIDTH, 1,
-               &mf->height, MT9M001_MIN_HEIGHT + mt9m001->y_skip_top,
-               MT9M001_MAX_HEIGHT + mt9m001->y_skip_top, 0, 0);
-
-       if (mt9m001->fmts == mt9m001_colour_fmts)
-               mf->height = ALIGN(mf->height - 1, 2);
-
-       fmt = mt9m001_find_datafmt(mf->code, mt9m001->fmts,
-                                  mt9m001->num_fmts);
-       if (!fmt) {
-               fmt = mt9m001->fmt;
-               mf->code = fmt->code;
-       }
-
-       mf->colorspace  = fmt->colorspace;
-
-       return 0;
-}
-
-static int mt9m001_g_chip_ident(struct v4l2_subdev *sd,
-                               struct v4l2_dbg_chip_ident *id)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9m001 *mt9m001 = to_mt9m001(client);
-
-       if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
-               return -EINVAL;
-
-       if (id->match.addr != client->addr)
-               return -ENODEV;
-
-       id->ident       = mt9m001->model;
-       id->revision    = 0;
-
-       return 0;
-}
-
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-static int mt9m001_g_register(struct v4l2_subdev *sd,
-                             struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-
-       if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
-               return -EINVAL;
-
-       if (reg->match.addr != client->addr)
-               return -ENODEV;
-
-       reg->size = 2;
-       reg->val = reg_read(client, reg->reg);
-
-       if (reg->val > 0xffff)
-               return -EIO;
-
-       return 0;
-}
-
-static int mt9m001_s_register(struct v4l2_subdev *sd,
-                             struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-
-       if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
-               return -EINVAL;
-
-       if (reg->match.addr != client->addr)
-               return -ENODEV;
-
-       if (reg_write(client, reg->reg, reg->val) < 0)
-               return -EIO;
-
-       return 0;
-}
-#endif
-
-static int mt9m001_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
-{
-       struct mt9m001 *mt9m001 = container_of(ctrl->handler,
-                                              struct mt9m001, hdl);
-       s32 min, max;
-
-       switch (ctrl->id) {
-       case V4L2_CID_EXPOSURE_AUTO:
-               min = mt9m001->exposure->minimum;
-               max = mt9m001->exposure->maximum;
-               mt9m001->exposure->val =
-                       (524 + (mt9m001->total_h - 1) * (max - min)) / 1048 + min;
-               break;
-       }
-       return 0;
-}
-
-static int mt9m001_s_ctrl(struct v4l2_ctrl *ctrl)
-{
-       struct mt9m001 *mt9m001 = container_of(ctrl->handler,
-                                              struct mt9m001, hdl);
-       struct v4l2_subdev *sd = &mt9m001->subdev;
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct v4l2_ctrl *exp = mt9m001->exposure;
-       int data;
-
-       switch (ctrl->id) {
-       case V4L2_CID_VFLIP:
-               if (ctrl->val)
-                       data = reg_set(client, MT9M001_READ_OPTIONS2, 0x8000);
-               else
-                       data = reg_clear(client, MT9M001_READ_OPTIONS2, 0x8000);
-               if (data < 0)
-                       return -EIO;
-               return 0;
-
-       case V4L2_CID_GAIN:
-               /* See Datasheet Table 7, Gain settings. */
-               if (ctrl->val <= ctrl->default_value) {
-                       /* Pack it into 0..1 step 0.125, register values 0..8 */
-                       unsigned long range = ctrl->default_value - ctrl->minimum;
-                       data = ((ctrl->val - ctrl->minimum) * 8 + range / 2) / range;
-
-                       dev_dbg(&client->dev, "Setting gain %d\n", data);
-                       data = reg_write(client, MT9M001_GLOBAL_GAIN, data);
-                       if (data < 0)
-                               return -EIO;
-               } else {
-                       /* Pack it into 1.125..15 variable step, register values 9..67 */
-                       /* We assume qctrl->maximum - qctrl->default_value - 1 > 0 */
-                       unsigned long range = ctrl->maximum - ctrl->default_value - 1;
-                       unsigned long gain = ((ctrl->val - ctrl->default_value - 1) *
-                                              111 + range / 2) / range + 9;
-
-                       if (gain <= 32)
-                               data = gain;
-                       else if (gain <= 64)
-                               data = ((gain - 32) * 16 + 16) / 32 + 80;
-                       else
-                               data = ((gain - 64) * 7 + 28) / 56 + 96;
-
-                       dev_dbg(&client->dev, "Setting gain from %d to %d\n",
-                                reg_read(client, MT9M001_GLOBAL_GAIN), data);
-                       data = reg_write(client, MT9M001_GLOBAL_GAIN, data);
-                       if (data < 0)
-                               return -EIO;
-               }
-               return 0;
-
-       case V4L2_CID_EXPOSURE_AUTO:
-               if (ctrl->val == V4L2_EXPOSURE_MANUAL) {
-                       unsigned long range = exp->maximum - exp->minimum;
-                       unsigned long shutter = ((exp->val - exp->minimum) * 1048 +
-                                                range / 2) / range + 1;
-
-                       dev_dbg(&client->dev,
-                               "Setting shutter width from %d to %lu\n",
-                               reg_read(client, MT9M001_SHUTTER_WIDTH), shutter);
-                       if (reg_write(client, MT9M001_SHUTTER_WIDTH, shutter) < 0)
-                               return -EIO;
-               } else {
-                       const u16 vblank = 25;
-
-                       mt9m001->total_h = mt9m001->rect.height +
-                               mt9m001->y_skip_top + vblank;
-                       if (reg_write(client, MT9M001_SHUTTER_WIDTH, mt9m001->total_h) < 0)
-                               return -EIO;
-               }
-               return 0;
-       }
-       return -EINVAL;
-}
-
-/*
- * Interface active, can use i2c. If it fails, it can indeed mean, that
- * this wasn't our capture interface, so, we wait for the right one
- */
-static int mt9m001_video_probe(struct soc_camera_link *icl,
-                              struct i2c_client *client)
-{
-       struct mt9m001 *mt9m001 = to_mt9m001(client);
-       s32 data;
-       unsigned long flags;
-       int ret;
-
-       /* Enable the chip */
-       data = reg_write(client, MT9M001_CHIP_ENABLE, 1);
-       dev_dbg(&client->dev, "write: %d\n", data);
-
-       /* Read out the chip version register */
-       data = reg_read(client, MT9M001_CHIP_VERSION);
-
-       /* must be 0x8411 or 0x8421 for colour sensor and 8431 for bw */
-       switch (data) {
-       case 0x8411:
-       case 0x8421:
-               mt9m001->model = V4L2_IDENT_MT9M001C12ST;
-               mt9m001->fmts = mt9m001_colour_fmts;
-               break;
-       case 0x8431:
-               mt9m001->model = V4L2_IDENT_MT9M001C12STM;
-               mt9m001->fmts = mt9m001_monochrome_fmts;
-               break;
-       default:
-               dev_err(&client->dev,
-                       "No MT9M001 chip detected, register read %x\n", data);
-               return -ENODEV;
-       }
-
-       mt9m001->num_fmts = 0;
-
-       /*
-        * This is a 10bit sensor, so by default we only allow 10bit.
-        * The platform may support different bus widths due to
-        * different routing of the data lines.
-        */
-       if (icl->query_bus_param)
-               flags = icl->query_bus_param(icl);
-       else
-               flags = SOCAM_DATAWIDTH_10;
-
-       if (flags & SOCAM_DATAWIDTH_10)
-               mt9m001->num_fmts++;
-       else
-               mt9m001->fmts++;
-
-       if (flags & SOCAM_DATAWIDTH_8)
-               mt9m001->num_fmts++;
-
-       mt9m001->fmt = &mt9m001->fmts[0];
-
-       dev_info(&client->dev, "Detected a MT9M001 chip ID %x (%s)\n", data,
-                data == 0x8431 ? "C12STM" : "C12ST");
-
-       ret = mt9m001_init(client);
-       if (ret < 0)
-               dev_err(&client->dev, "Failed to initialise the camera\n");
-
-       /* mt9m001_init() has reset the chip, returning registers to defaults */
-       return v4l2_ctrl_handler_setup(&mt9m001->hdl);
-}
-
-static void mt9m001_video_remove(struct soc_camera_link *icl)
-{
-       if (icl->free_bus)
-               icl->free_bus(icl);
-}
-
-static int mt9m001_g_skip_top_lines(struct v4l2_subdev *sd, u32 *lines)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9m001 *mt9m001 = to_mt9m001(client);
-
-       *lines = mt9m001->y_skip_top;
-
-       return 0;
-}
-
-static const struct v4l2_ctrl_ops mt9m001_ctrl_ops = {
-       .g_volatile_ctrl = mt9m001_g_volatile_ctrl,
-       .s_ctrl = mt9m001_s_ctrl,
-};
-
-static struct v4l2_subdev_core_ops mt9m001_subdev_core_ops = {
-       .g_chip_ident   = mt9m001_g_chip_ident,
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-       .g_register     = mt9m001_g_register,
-       .s_register     = mt9m001_s_register,
-#endif
-};
-
-static int mt9m001_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                           enum v4l2_mbus_pixelcode *code)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9m001 *mt9m001 = to_mt9m001(client);
-
-       if (index >= mt9m001->num_fmts)
-               return -EINVAL;
-
-       *code = mt9m001->fmts[index].code;
-       return 0;
-}
-
-static int mt9m001_g_mbus_config(struct v4l2_subdev *sd,
-                               struct v4l2_mbus_config *cfg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-
-       /* MT9M001 has all capture_format parameters fixed */
-       cfg->flags = V4L2_MBUS_PCLK_SAMPLE_FALLING |
-               V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_HIGH |
-               V4L2_MBUS_DATA_ACTIVE_HIGH | V4L2_MBUS_MASTER;
-       cfg->type = V4L2_MBUS_PARALLEL;
-       cfg->flags = soc_camera_apply_board_flags(icl, cfg);
-
-       return 0;
-}
-
-static int mt9m001_s_mbus_config(struct v4l2_subdev *sd,
-                               const struct v4l2_mbus_config *cfg)
-{
-       const struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-       struct mt9m001 *mt9m001 = to_mt9m001(client);
-       unsigned int bps = soc_mbus_get_fmtdesc(mt9m001->fmt->code)->bits_per_sample;
-
-       if (icl->set_bus_param)
-               return icl->set_bus_param(icl, 1 << (bps - 1));
-
-       /*
-        * Without board specific bus width settings we only support the
-        * sensors native bus width
-        */
-       return bps == 10 ? 0 : -EINVAL;
-}
-
-static struct v4l2_subdev_video_ops mt9m001_subdev_video_ops = {
-       .s_stream       = mt9m001_s_stream,
-       .s_mbus_fmt     = mt9m001_s_fmt,
-       .g_mbus_fmt     = mt9m001_g_fmt,
-       .try_mbus_fmt   = mt9m001_try_fmt,
-       .s_crop         = mt9m001_s_crop,
-       .g_crop         = mt9m001_g_crop,
-       .cropcap        = mt9m001_cropcap,
-       .enum_mbus_fmt  = mt9m001_enum_fmt,
-       .g_mbus_config  = mt9m001_g_mbus_config,
-       .s_mbus_config  = mt9m001_s_mbus_config,
-};
-
-static struct v4l2_subdev_sensor_ops mt9m001_subdev_sensor_ops = {
-       .g_skip_top_lines       = mt9m001_g_skip_top_lines,
-};
-
-static struct v4l2_subdev_ops mt9m001_subdev_ops = {
-       .core   = &mt9m001_subdev_core_ops,
-       .video  = &mt9m001_subdev_video_ops,
-       .sensor = &mt9m001_subdev_sensor_ops,
-};
-
-static int mt9m001_probe(struct i2c_client *client,
-                        const struct i2c_device_id *did)
-{
-       struct mt9m001 *mt9m001;
-       struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-       int ret;
-
-       if (!icl) {
-               dev_err(&client->dev, "MT9M001 driver needs platform data\n");
-               return -EINVAL;
-       }
-
-       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
-               dev_warn(&adapter->dev,
-                        "I2C-Adapter doesn't support I2C_FUNC_SMBUS_WORD\n");
-               return -EIO;
-       }
-
-       mt9m001 = kzalloc(sizeof(struct mt9m001), GFP_KERNEL);
-       if (!mt9m001)
-               return -ENOMEM;
-
-       v4l2_i2c_subdev_init(&mt9m001->subdev, client, &mt9m001_subdev_ops);
-       v4l2_ctrl_handler_init(&mt9m001->hdl, 4);
-       v4l2_ctrl_new_std(&mt9m001->hdl, &mt9m001_ctrl_ops,
-                       V4L2_CID_VFLIP, 0, 1, 1, 0);
-       v4l2_ctrl_new_std(&mt9m001->hdl, &mt9m001_ctrl_ops,
-                       V4L2_CID_GAIN, 0, 127, 1, 64);
-       mt9m001->exposure = v4l2_ctrl_new_std(&mt9m001->hdl, &mt9m001_ctrl_ops,
-                       V4L2_CID_EXPOSURE, 1, 255, 1, 255);
-       /*
-        * Simulated autoexposure. If enabled, we calculate shutter width
-        * ourselves in the driver based on vertical blanking and frame width
-        */
-       mt9m001->autoexposure = v4l2_ctrl_new_std_menu(&mt9m001->hdl,
-                       &mt9m001_ctrl_ops, V4L2_CID_EXPOSURE_AUTO, 1, 0,
-                       V4L2_EXPOSURE_AUTO);
-       mt9m001->subdev.ctrl_handler = &mt9m001->hdl;
-       if (mt9m001->hdl.error) {
-               int err = mt9m001->hdl.error;
-
-               kfree(mt9m001);
-               return err;
-       }
-       v4l2_ctrl_auto_cluster(2, &mt9m001->autoexposure,
-                                       V4L2_EXPOSURE_MANUAL, true);
-
-       /* Second stage probe - when a capture adapter is there */
-       mt9m001->y_skip_top     = 0;
-       mt9m001->rect.left      = MT9M001_COLUMN_SKIP;
-       mt9m001->rect.top       = MT9M001_ROW_SKIP;
-       mt9m001->rect.width     = MT9M001_MAX_WIDTH;
-       mt9m001->rect.height    = MT9M001_MAX_HEIGHT;
-
-       ret = mt9m001_video_probe(icl, client);
-       if (ret) {
-               v4l2_ctrl_handler_free(&mt9m001->hdl);
-               kfree(mt9m001);
-       }
-
-       return ret;
-}
-
-static int mt9m001_remove(struct i2c_client *client)
-{
-       struct mt9m001 *mt9m001 = to_mt9m001(client);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-
-       v4l2_device_unregister_subdev(&mt9m001->subdev);
-       v4l2_ctrl_handler_free(&mt9m001->hdl);
-       mt9m001_video_remove(icl);
-       kfree(mt9m001);
-
-       return 0;
-}
-
-static const struct i2c_device_id mt9m001_id[] = {
-       { "mt9m001", 0 },
-       { }
-};
-MODULE_DEVICE_TABLE(i2c, mt9m001_id);
-
-static struct i2c_driver mt9m001_i2c_driver = {
-       .driver = {
-               .name = "mt9m001",
-       },
-       .probe          = mt9m001_probe,
-       .remove         = mt9m001_remove,
-       .id_table       = mt9m001_id,
-};
-
-module_i2c_driver(mt9m001_i2c_driver);
-
-MODULE_DESCRIPTION("Micron MT9M001 Camera driver");
-MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>");
-MODULE_LICENSE("GPL");
diff --git a/drivers/media/video/mt9m111.c b/drivers/media/video/mt9m111.c
deleted file mode 100644 (file)
index 863d722..0000000
+++ /dev/null
@@ -1,1014 +0,0 @@
-/*
- * Driver for MT9M111/MT9M112/MT9M131 CMOS Image Sensor from Micron/Aptina
- *
- * Copyright (C) 2008, Robert Jarzmik <robert.jarzmik@free.fr>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-#include <linux/videodev2.h>
-#include <linux/slab.h>
-#include <linux/i2c.h>
-#include <linux/log2.h>
-#include <linux/gpio.h>
-#include <linux/delay.h>
-#include <linux/v4l2-mediabus.h>
-#include <linux/module.h>
-
-#include <media/soc_camera.h>
-#include <media/v4l2-common.h>
-#include <media/v4l2-ctrls.h>
-#include <media/v4l2-chip-ident.h>
-
-/*
- * MT9M111, MT9M112 and MT9M131:
- * i2c address is 0x48 or 0x5d (depending on SADDR pin)
- * The platform has to define i2c_board_info and call i2c_register_board_info()
- */
-
-/*
- * Sensor core register addresses (0x000..0x0ff)
- */
-#define MT9M111_CHIP_VERSION           0x000
-#define MT9M111_ROW_START              0x001
-#define MT9M111_COLUMN_START           0x002
-#define MT9M111_WINDOW_HEIGHT          0x003
-#define MT9M111_WINDOW_WIDTH           0x004
-#define MT9M111_HORIZONTAL_BLANKING_B  0x005
-#define MT9M111_VERTICAL_BLANKING_B    0x006
-#define MT9M111_HORIZONTAL_BLANKING_A  0x007
-#define MT9M111_VERTICAL_BLANKING_A    0x008
-#define MT9M111_SHUTTER_WIDTH          0x009
-#define MT9M111_ROW_SPEED              0x00a
-#define MT9M111_EXTRA_DELAY            0x00b
-#define MT9M111_SHUTTER_DELAY          0x00c
-#define MT9M111_RESET                  0x00d
-#define MT9M111_READ_MODE_B            0x020
-#define MT9M111_READ_MODE_A            0x021
-#define MT9M111_FLASH_CONTROL          0x023
-#define MT9M111_GREEN1_GAIN            0x02b
-#define MT9M111_BLUE_GAIN              0x02c
-#define MT9M111_RED_GAIN               0x02d
-#define MT9M111_GREEN2_GAIN            0x02e
-#define MT9M111_GLOBAL_GAIN            0x02f
-#define MT9M111_CONTEXT_CONTROL                0x0c8
-#define MT9M111_PAGE_MAP               0x0f0
-#define MT9M111_BYTE_WISE_ADDR         0x0f1
-
-#define MT9M111_RESET_SYNC_CHANGES     (1 << 15)
-#define MT9M111_RESET_RESTART_BAD_FRAME        (1 << 9)
-#define MT9M111_RESET_SHOW_BAD_FRAMES  (1 << 8)
-#define MT9M111_RESET_RESET_SOC                (1 << 5)
-#define MT9M111_RESET_OUTPUT_DISABLE   (1 << 4)
-#define MT9M111_RESET_CHIP_ENABLE      (1 << 3)
-#define MT9M111_RESET_ANALOG_STANDBY   (1 << 2)
-#define MT9M111_RESET_RESTART_FRAME    (1 << 1)
-#define MT9M111_RESET_RESET_MODE       (1 << 0)
-
-#define MT9M111_RM_FULL_POWER_RD       (0 << 10)
-#define MT9M111_RM_LOW_POWER_RD                (1 << 10)
-#define MT9M111_RM_COL_SKIP_4X         (1 << 5)
-#define MT9M111_RM_ROW_SKIP_4X         (1 << 4)
-#define MT9M111_RM_COL_SKIP_2X         (1 << 3)
-#define MT9M111_RM_ROW_SKIP_2X         (1 << 2)
-#define MT9M111_RMB_MIRROR_COLS                (1 << 1)
-#define MT9M111_RMB_MIRROR_ROWS                (1 << 0)
-#define MT9M111_CTXT_CTRL_RESTART      (1 << 15)
-#define MT9M111_CTXT_CTRL_DEFECTCOR_B  (1 << 12)
-#define MT9M111_CTXT_CTRL_RESIZE_B     (1 << 10)
-#define MT9M111_CTXT_CTRL_CTRL2_B      (1 << 9)
-#define MT9M111_CTXT_CTRL_GAMMA_B      (1 << 8)
-#define MT9M111_CTXT_CTRL_XENON_EN     (1 << 7)
-#define MT9M111_CTXT_CTRL_READ_MODE_B  (1 << 3)
-#define MT9M111_CTXT_CTRL_LED_FLASH_EN (1 << 2)
-#define MT9M111_CTXT_CTRL_VBLANK_SEL_B (1 << 1)
-#define MT9M111_CTXT_CTRL_HBLANK_SEL_B (1 << 0)
-
-/*
- * Colorpipe register addresses (0x100..0x1ff)
- */
-#define MT9M111_OPER_MODE_CTRL         0x106
-#define MT9M111_OUTPUT_FORMAT_CTRL     0x108
-#define MT9M111_REDUCER_XZOOM_B                0x1a0
-#define MT9M111_REDUCER_XSIZE_B                0x1a1
-#define MT9M111_REDUCER_YZOOM_B                0x1a3
-#define MT9M111_REDUCER_YSIZE_B                0x1a4
-#define MT9M111_REDUCER_XZOOM_A                0x1a6
-#define MT9M111_REDUCER_XSIZE_A                0x1a7
-#define MT9M111_REDUCER_YZOOM_A                0x1a9
-#define MT9M111_REDUCER_YSIZE_A                0x1aa
-
-#define MT9M111_OUTPUT_FORMAT_CTRL2_A  0x13a
-#define MT9M111_OUTPUT_FORMAT_CTRL2_B  0x19b
-
-#define MT9M111_OPMODE_AUTOEXPO_EN     (1 << 14)
-#define MT9M111_OPMODE_AUTOWHITEBAL_EN (1 << 1)
-#define MT9M111_OUTFMT_FLIP_BAYER_COL  (1 << 9)
-#define MT9M111_OUTFMT_FLIP_BAYER_ROW  (1 << 8)
-#define MT9M111_OUTFMT_PROCESSED_BAYER (1 << 14)
-#define MT9M111_OUTFMT_BYPASS_IFP      (1 << 10)
-#define MT9M111_OUTFMT_INV_PIX_CLOCK   (1 << 9)
-#define MT9M111_OUTFMT_RGB             (1 << 8)
-#define MT9M111_OUTFMT_RGB565          (0 << 6)
-#define MT9M111_OUTFMT_RGB555          (1 << 6)
-#define MT9M111_OUTFMT_RGB444x         (2 << 6)
-#define MT9M111_OUTFMT_RGBx444         (3 << 6)
-#define MT9M111_OUTFMT_TST_RAMP_OFF    (0 << 4)
-#define MT9M111_OUTFMT_TST_RAMP_COL    (1 << 4)
-#define MT9M111_OUTFMT_TST_RAMP_ROW    (2 << 4)
-#define MT9M111_OUTFMT_TST_RAMP_FRAME  (3 << 4)
-#define MT9M111_OUTFMT_SHIFT_3_UP      (1 << 3)
-#define MT9M111_OUTFMT_AVG_CHROMA      (1 << 2)
-#define MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN (1 << 1)
-#define MT9M111_OUTFMT_SWAP_YCbCr_Cb_Cr_RGB_R_B        (1 << 0)
-
-/*
- * Camera control register addresses (0x200..0x2ff not implemented)
- */
-
-#define reg_read(reg) mt9m111_reg_read(client, MT9M111_##reg)
-#define reg_write(reg, val) mt9m111_reg_write(client, MT9M111_##reg, (val))
-#define reg_set(reg, val) mt9m111_reg_set(client, MT9M111_##reg, (val))
-#define reg_clear(reg, val) mt9m111_reg_clear(client, MT9M111_##reg, (val))
-#define reg_mask(reg, val, mask) mt9m111_reg_mask(client, MT9M111_##reg, \
-               (val), (mask))
-
-#define MT9M111_MIN_DARK_ROWS  8
-#define MT9M111_MIN_DARK_COLS  26
-#define MT9M111_MAX_HEIGHT     1024
-#define MT9M111_MAX_WIDTH      1280
-
-struct mt9m111_context {
-       u16 read_mode;
-       u16 blanking_h;
-       u16 blanking_v;
-       u16 reducer_xzoom;
-       u16 reducer_yzoom;
-       u16 reducer_xsize;
-       u16 reducer_ysize;
-       u16 output_fmt_ctrl2;
-       u16 control;
-};
-
-static struct mt9m111_context context_a = {
-       .read_mode              = MT9M111_READ_MODE_A,
-       .blanking_h             = MT9M111_HORIZONTAL_BLANKING_A,
-       .blanking_v             = MT9M111_VERTICAL_BLANKING_A,
-       .reducer_xzoom          = MT9M111_REDUCER_XZOOM_A,
-       .reducer_yzoom          = MT9M111_REDUCER_YZOOM_A,
-       .reducer_xsize          = MT9M111_REDUCER_XSIZE_A,
-       .reducer_ysize          = MT9M111_REDUCER_YSIZE_A,
-       .output_fmt_ctrl2       = MT9M111_OUTPUT_FORMAT_CTRL2_A,
-       .control                = MT9M111_CTXT_CTRL_RESTART,
-};
-
-static struct mt9m111_context context_b = {
-       .read_mode              = MT9M111_READ_MODE_B,
-       .blanking_h             = MT9M111_HORIZONTAL_BLANKING_B,
-       .blanking_v             = MT9M111_VERTICAL_BLANKING_B,
-       .reducer_xzoom          = MT9M111_REDUCER_XZOOM_B,
-       .reducer_yzoom          = MT9M111_REDUCER_YZOOM_B,
-       .reducer_xsize          = MT9M111_REDUCER_XSIZE_B,
-       .reducer_ysize          = MT9M111_REDUCER_YSIZE_B,
-       .output_fmt_ctrl2       = MT9M111_OUTPUT_FORMAT_CTRL2_B,
-       .control                = MT9M111_CTXT_CTRL_RESTART |
-               MT9M111_CTXT_CTRL_DEFECTCOR_B | MT9M111_CTXT_CTRL_RESIZE_B |
-               MT9M111_CTXT_CTRL_CTRL2_B | MT9M111_CTXT_CTRL_GAMMA_B |
-               MT9M111_CTXT_CTRL_READ_MODE_B | MT9M111_CTXT_CTRL_VBLANK_SEL_B |
-               MT9M111_CTXT_CTRL_HBLANK_SEL_B,
-};
-
-/* MT9M111 has only one fixed colorspace per pixelcode */
-struct mt9m111_datafmt {
-       enum v4l2_mbus_pixelcode        code;
-       enum v4l2_colorspace            colorspace;
-};
-
-static const struct mt9m111_datafmt mt9m111_colour_fmts[] = {
-       {V4L2_MBUS_FMT_YUYV8_2X8, V4L2_COLORSPACE_JPEG},
-       {V4L2_MBUS_FMT_YVYU8_2X8, V4L2_COLORSPACE_JPEG},
-       {V4L2_MBUS_FMT_UYVY8_2X8, V4L2_COLORSPACE_JPEG},
-       {V4L2_MBUS_FMT_VYUY8_2X8, V4L2_COLORSPACE_JPEG},
-       {V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE, V4L2_COLORSPACE_SRGB},
-       {V4L2_MBUS_FMT_RGB555_2X8_PADHI_BE, V4L2_COLORSPACE_SRGB},
-       {V4L2_MBUS_FMT_RGB565_2X8_LE, V4L2_COLORSPACE_SRGB},
-       {V4L2_MBUS_FMT_RGB565_2X8_BE, V4L2_COLORSPACE_SRGB},
-       {V4L2_MBUS_FMT_BGR565_2X8_LE, V4L2_COLORSPACE_SRGB},
-       {V4L2_MBUS_FMT_BGR565_2X8_BE, V4L2_COLORSPACE_SRGB},
-       {V4L2_MBUS_FMT_SBGGR8_1X8, V4L2_COLORSPACE_SRGB},
-       {V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE, V4L2_COLORSPACE_SRGB},
-};
-
-struct mt9m111 {
-       struct v4l2_subdev subdev;
-       struct v4l2_ctrl_handler hdl;
-       struct v4l2_ctrl *gain;
-       int model;      /* V4L2_IDENT_MT9M111 or V4L2_IDENT_MT9M112 code
-                        * from v4l2-chip-ident.h */
-       struct mt9m111_context *ctx;
-       struct v4l2_rect rect;  /* cropping rectangle */
-       int width;              /* output */
-       int height;             /* sizes */
-       struct mutex power_lock; /* lock to protect power_count */
-       int power_count;
-       const struct mt9m111_datafmt *fmt;
-       int lastpage;   /* PageMap cache value */
-};
-
-/* Find a data format by a pixel code */
-static const struct mt9m111_datafmt *mt9m111_find_datafmt(struct mt9m111 *mt9m111,
-                                               enum v4l2_mbus_pixelcode code)
-{
-       int i;
-       for (i = 0; i < ARRAY_SIZE(mt9m111_colour_fmts); i++)
-               if (mt9m111_colour_fmts[i].code == code)
-                       return mt9m111_colour_fmts + i;
-
-       return mt9m111->fmt;
-}
-
-static struct mt9m111 *to_mt9m111(const struct i2c_client *client)
-{
-       return container_of(i2c_get_clientdata(client), struct mt9m111, subdev);
-}
-
-static int reg_page_map_set(struct i2c_client *client, const u16 reg)
-{
-       int ret;
-       u16 page;
-       struct mt9m111 *mt9m111 = to_mt9m111(client);
-
-       page = (reg >> 8);
-       if (page == mt9m111->lastpage)
-               return 0;
-       if (page > 2)
-               return -EINVAL;
-
-       ret = i2c_smbus_write_word_swapped(client, MT9M111_PAGE_MAP, page);
-       if (!ret)
-               mt9m111->lastpage = page;
-       return ret;
-}
-
-static int mt9m111_reg_read(struct i2c_client *client, const u16 reg)
-{
-       int ret;
-
-       ret = reg_page_map_set(client, reg);
-       if (!ret)
-               ret = i2c_smbus_read_word_swapped(client, reg & 0xff);
-
-       dev_dbg(&client->dev, "read  reg.%03x -> %04x\n", reg, ret);
-       return ret;
-}
-
-static int mt9m111_reg_write(struct i2c_client *client, const u16 reg,
-                            const u16 data)
-{
-       int ret;
-
-       ret = reg_page_map_set(client, reg);
-       if (!ret)
-               ret = i2c_smbus_write_word_swapped(client, reg & 0xff, data);
-       dev_dbg(&client->dev, "write reg.%03x = %04x -> %d\n", reg, data, ret);
-       return ret;
-}
-
-static int mt9m111_reg_set(struct i2c_client *client, const u16 reg,
-                          const u16 data)
-{
-       int ret;
-
-       ret = mt9m111_reg_read(client, reg);
-       if (ret >= 0)
-               ret = mt9m111_reg_write(client, reg, ret | data);
-       return ret;
-}
-
-static int mt9m111_reg_clear(struct i2c_client *client, const u16 reg,
-                            const u16 data)
-{
-       int ret;
-
-       ret = mt9m111_reg_read(client, reg);
-       if (ret >= 0)
-               ret = mt9m111_reg_write(client, reg, ret & ~data);
-       return ret;
-}
-
-static int mt9m111_reg_mask(struct i2c_client *client, const u16 reg,
-                           const u16 data, const u16 mask)
-{
-       int ret;
-
-       ret = mt9m111_reg_read(client, reg);
-       if (ret >= 0)
-               ret = mt9m111_reg_write(client, reg, (ret & ~mask) | data);
-       return ret;
-}
-
-static int mt9m111_set_context(struct mt9m111 *mt9m111,
-                              struct mt9m111_context *ctx)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
-       return reg_write(CONTEXT_CONTROL, ctx->control);
-}
-
-static int mt9m111_setup_rect_ctx(struct mt9m111 *mt9m111,
-                       struct mt9m111_context *ctx, struct v4l2_rect *rect,
-                       unsigned int width, unsigned int height)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
-       int ret = mt9m111_reg_write(client, ctx->reducer_xzoom, rect->width);
-       if (!ret)
-               ret = mt9m111_reg_write(client, ctx->reducer_yzoom, rect->height);
-       if (!ret)
-               ret = mt9m111_reg_write(client, ctx->reducer_xsize, width);
-       if (!ret)
-               ret = mt9m111_reg_write(client, ctx->reducer_ysize, height);
-       return ret;
-}
-
-static int mt9m111_setup_geometry(struct mt9m111 *mt9m111, struct v4l2_rect *rect,
-                       int width, int height, enum v4l2_mbus_pixelcode code)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
-       int ret;
-
-       ret = reg_write(COLUMN_START, rect->left);
-       if (!ret)
-               ret = reg_write(ROW_START, rect->top);
-
-       if (!ret)
-               ret = reg_write(WINDOW_WIDTH, rect->width);
-       if (!ret)
-               ret = reg_write(WINDOW_HEIGHT, rect->height);
-
-       if (code != V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE) {
-               /* IFP in use, down-scaling possible */
-               if (!ret)
-                       ret = mt9m111_setup_rect_ctx(mt9m111, &context_b,
-                                                    rect, width, height);
-               if (!ret)
-                       ret = mt9m111_setup_rect_ctx(mt9m111, &context_a,
-                                                    rect, width, height);
-       }
-
-       dev_dbg(&client->dev, "%s(%x): %ux%u@%u:%u -> %ux%u = %d\n",
-               __func__, code, rect->width, rect->height, rect->left, rect->top,
-               width, height, ret);
-
-       return ret;
-}
-
-static int mt9m111_enable(struct mt9m111 *mt9m111)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
-       return reg_write(RESET, MT9M111_RESET_CHIP_ENABLE);
-}
-
-static int mt9m111_reset(struct mt9m111 *mt9m111)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
-       int ret;
-
-       ret = reg_set(RESET, MT9M111_RESET_RESET_MODE);
-       if (!ret)
-               ret = reg_set(RESET, MT9M111_RESET_RESET_SOC);
-       if (!ret)
-               ret = reg_clear(RESET, MT9M111_RESET_RESET_MODE
-                               | MT9M111_RESET_RESET_SOC);
-
-       return ret;
-}
-
-static int mt9m111_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
-{
-       struct v4l2_rect rect = a->c;
-       struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
-       int width, height;
-       int ret;
-
-       if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-               return -EINVAL;
-
-       if (mt9m111->fmt->code == V4L2_MBUS_FMT_SBGGR8_1X8 ||
-           mt9m111->fmt->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE) {
-               /* Bayer format - even size lengths */
-               rect.width      = ALIGN(rect.width, 2);
-               rect.height     = ALIGN(rect.height, 2);
-               /* Let the user play with the starting pixel */
-       }
-
-       /* FIXME: the datasheet doesn't specify minimum sizes */
-       soc_camera_limit_side(&rect.left, &rect.width,
-                    MT9M111_MIN_DARK_COLS, 2, MT9M111_MAX_WIDTH);
-
-       soc_camera_limit_side(&rect.top, &rect.height,
-                    MT9M111_MIN_DARK_ROWS, 2, MT9M111_MAX_HEIGHT);
-
-       width = min(mt9m111->width, rect.width);
-       height = min(mt9m111->height, rect.height);
-
-       ret = mt9m111_setup_geometry(mt9m111, &rect, width, height, mt9m111->fmt->code);
-       if (!ret) {
-               mt9m111->rect = rect;
-               mt9m111->width = width;
-               mt9m111->height = height;
-       }
-
-       return ret;
-}
-
-static int mt9m111_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
-{
-       struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
-
-       a->c    = mt9m111->rect;
-       a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-
-       return 0;
-}
-
-static int mt9m111_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
-{
-       if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-               return -EINVAL;
-
-       a->bounds.left                  = MT9M111_MIN_DARK_COLS;
-       a->bounds.top                   = MT9M111_MIN_DARK_ROWS;
-       a->bounds.width                 = MT9M111_MAX_WIDTH;
-       a->bounds.height                = MT9M111_MAX_HEIGHT;
-       a->defrect                      = a->bounds;
-       a->pixelaspect.numerator        = 1;
-       a->pixelaspect.denominator      = 1;
-
-       return 0;
-}
-
-static int mt9m111_g_fmt(struct v4l2_subdev *sd,
-                        struct v4l2_mbus_framefmt *mf)
-{
-       struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
-
-       mf->width       = mt9m111->width;
-       mf->height      = mt9m111->height;
-       mf->code        = mt9m111->fmt->code;
-       mf->colorspace  = mt9m111->fmt->colorspace;
-       mf->field       = V4L2_FIELD_NONE;
-
-       return 0;
-}
-
-static int mt9m111_set_pixfmt(struct mt9m111 *mt9m111,
-                             enum v4l2_mbus_pixelcode code)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
-       u16 data_outfmt2, mask_outfmt2 = MT9M111_OUTFMT_PROCESSED_BAYER |
-               MT9M111_OUTFMT_BYPASS_IFP | MT9M111_OUTFMT_RGB |
-               MT9M111_OUTFMT_RGB565 | MT9M111_OUTFMT_RGB555 |
-               MT9M111_OUTFMT_RGB444x | MT9M111_OUTFMT_RGBx444 |
-               MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN |
-               MT9M111_OUTFMT_SWAP_YCbCr_Cb_Cr_RGB_R_B;
-       int ret;
-
-       switch (code) {
-       case V4L2_MBUS_FMT_SBGGR8_1X8:
-               data_outfmt2 = MT9M111_OUTFMT_PROCESSED_BAYER |
-                       MT9M111_OUTFMT_RGB;
-               break;
-       case V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE:
-               data_outfmt2 = MT9M111_OUTFMT_BYPASS_IFP | MT9M111_OUTFMT_RGB;
-               break;
-       case V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE:
-               data_outfmt2 = MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB555 |
-                       MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN;
-               break;
-       case V4L2_MBUS_FMT_RGB555_2X8_PADHI_BE:
-               data_outfmt2 = MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB555;
-               break;
-       case V4L2_MBUS_FMT_RGB565_2X8_LE:
-               data_outfmt2 = MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB565 |
-                       MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN;
-               break;
-       case V4L2_MBUS_FMT_RGB565_2X8_BE:
-               data_outfmt2 = MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB565;
-               break;
-       case V4L2_MBUS_FMT_BGR565_2X8_BE:
-               data_outfmt2 = MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB565 |
-                       MT9M111_OUTFMT_SWAP_YCbCr_Cb_Cr_RGB_R_B;
-               break;
-       case V4L2_MBUS_FMT_BGR565_2X8_LE:
-               data_outfmt2 = MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB565 |
-                       MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN |
-                       MT9M111_OUTFMT_SWAP_YCbCr_Cb_Cr_RGB_R_B;
-               break;
-       case V4L2_MBUS_FMT_UYVY8_2X8:
-               data_outfmt2 = 0;
-               break;
-       case V4L2_MBUS_FMT_VYUY8_2X8:
-               data_outfmt2 = MT9M111_OUTFMT_SWAP_YCbCr_Cb_Cr_RGB_R_B;
-               break;
-       case V4L2_MBUS_FMT_YUYV8_2X8:
-               data_outfmt2 = MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN;
-               break;
-       case V4L2_MBUS_FMT_YVYU8_2X8:
-               data_outfmt2 = MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN |
-                       MT9M111_OUTFMT_SWAP_YCbCr_Cb_Cr_RGB_R_B;
-               break;
-       default:
-               dev_err(&client->dev, "Pixel format not handled: %x\n", code);
-               return -EINVAL;
-       }
-
-       ret = mt9m111_reg_mask(client, context_a.output_fmt_ctrl2,
-                              data_outfmt2, mask_outfmt2);
-       if (!ret)
-               ret = mt9m111_reg_mask(client, context_b.output_fmt_ctrl2,
-                                      data_outfmt2, mask_outfmt2);
-
-       return ret;
-}
-
-static int mt9m111_try_fmt(struct v4l2_subdev *sd,
-                          struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
-       const struct mt9m111_datafmt *fmt;
-       struct v4l2_rect *rect = &mt9m111->rect;
-       bool bayer;
-
-       fmt = mt9m111_find_datafmt(mt9m111, mf->code);
-
-       bayer = fmt->code == V4L2_MBUS_FMT_SBGGR8_1X8 ||
-               fmt->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE;
-
-       /*
-        * With Bayer format enforce even side lengths, but let the user play
-        * with the starting pixel
-        */
-       if (bayer) {
-               rect->width = ALIGN(rect->width, 2);
-               rect->height = ALIGN(rect->height, 2);
-       }
-
-       if (fmt->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE) {
-               /* IFP bypass mode, no scaling */
-               mf->width = rect->width;
-               mf->height = rect->height;
-       } else {
-               /* No upscaling */
-               if (mf->width > rect->width)
-                       mf->width = rect->width;
-               if (mf->height > rect->height)
-                       mf->height = rect->height;
-       }
-
-       dev_dbg(&client->dev, "%s(): %ux%u, code=%x\n", __func__,
-               mf->width, mf->height, fmt->code);
-
-       mf->code = fmt->code;
-       mf->colorspace = fmt->colorspace;
-
-       return 0;
-}
-
-static int mt9m111_s_fmt(struct v4l2_subdev *sd,
-                        struct v4l2_mbus_framefmt *mf)
-{
-       const struct mt9m111_datafmt *fmt;
-       struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
-       struct v4l2_rect *rect = &mt9m111->rect;
-       int ret;
-
-       mt9m111_try_fmt(sd, mf);
-       fmt = mt9m111_find_datafmt(mt9m111, mf->code);
-       /* try_fmt() guarantees fmt != NULL && fmt->code == mf->code */
-
-       ret = mt9m111_setup_geometry(mt9m111, rect, mf->width, mf->height, mf->code);
-       if (!ret)
-               ret = mt9m111_set_pixfmt(mt9m111, mf->code);
-       if (!ret) {
-               mt9m111->width  = mf->width;
-               mt9m111->height = mf->height;
-               mt9m111->fmt    = fmt;
-       }
-
-       return ret;
-}
-
-static int mt9m111_g_chip_ident(struct v4l2_subdev *sd,
-                               struct v4l2_dbg_chip_ident *id)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
-
-       if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
-               return -EINVAL;
-
-       if (id->match.addr != client->addr)
-               return -ENODEV;
-
-       id->ident       = mt9m111->model;
-       id->revision    = 0;
-
-       return 0;
-}
-
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-static int mt9m111_g_register(struct v4l2_subdev *sd,
-                             struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       int val;
-
-       if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0x2ff)
-               return -EINVAL;
-       if (reg->match.addr != client->addr)
-               return -ENODEV;
-
-       val = mt9m111_reg_read(client, reg->reg);
-       reg->size = 2;
-       reg->val = (u64)val;
-
-       if (reg->val > 0xffff)
-               return -EIO;
-
-       return 0;
-}
-
-static int mt9m111_s_register(struct v4l2_subdev *sd,
-                             struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-
-       if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0x2ff)
-               return -EINVAL;
-
-       if (reg->match.addr != client->addr)
-               return -ENODEV;
-
-       if (mt9m111_reg_write(client, reg->reg, reg->val) < 0)
-               return -EIO;
-
-       return 0;
-}
-#endif
-
-static int mt9m111_set_flip(struct mt9m111 *mt9m111, int flip, int mask)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
-       int ret;
-
-       if (flip)
-               ret = mt9m111_reg_set(client, mt9m111->ctx->read_mode, mask);
-       else
-               ret = mt9m111_reg_clear(client, mt9m111->ctx->read_mode, mask);
-
-       return ret;
-}
-
-static int mt9m111_get_global_gain(struct mt9m111 *mt9m111)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
-       int data;
-
-       data = reg_read(GLOBAL_GAIN);
-       if (data >= 0)
-               return (data & 0x2f) * (1 << ((data >> 10) & 1)) *
-                       (1 << ((data >> 9) & 1));
-       return data;
-}
-
-static int mt9m111_set_global_gain(struct mt9m111 *mt9m111, int gain)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
-       u16 val;
-
-       if (gain > 63 * 2 * 2)
-               return -EINVAL;
-
-       if ((gain >= 64 * 2) && (gain < 63 * 2 * 2))
-               val = (1 << 10) | (1 << 9) | (gain / 4);
-       else if ((gain >= 64) && (gain < 64 * 2))
-               val = (1 << 9) | (gain / 2);
-       else
-               val = gain;
-
-       return reg_write(GLOBAL_GAIN, val);
-}
-
-static int mt9m111_set_autoexposure(struct mt9m111 *mt9m111, int on)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
-
-       if (on)
-               return reg_set(OPER_MODE_CTRL, MT9M111_OPMODE_AUTOEXPO_EN);
-       return reg_clear(OPER_MODE_CTRL, MT9M111_OPMODE_AUTOEXPO_EN);
-}
-
-static int mt9m111_set_autowhitebalance(struct mt9m111 *mt9m111, int on)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
-
-       if (on)
-               return reg_set(OPER_MODE_CTRL, MT9M111_OPMODE_AUTOWHITEBAL_EN);
-       return reg_clear(OPER_MODE_CTRL, MT9M111_OPMODE_AUTOWHITEBAL_EN);
-}
-
-static int mt9m111_s_ctrl(struct v4l2_ctrl *ctrl)
-{
-       struct mt9m111 *mt9m111 = container_of(ctrl->handler,
-                                              struct mt9m111, hdl);
-
-       switch (ctrl->id) {
-       case V4L2_CID_VFLIP:
-               return mt9m111_set_flip(mt9m111, ctrl->val,
-                                       MT9M111_RMB_MIRROR_ROWS);
-       case V4L2_CID_HFLIP:
-               return mt9m111_set_flip(mt9m111, ctrl->val,
-                                       MT9M111_RMB_MIRROR_COLS);
-       case V4L2_CID_GAIN:
-               return mt9m111_set_global_gain(mt9m111, ctrl->val);
-       case V4L2_CID_EXPOSURE_AUTO:
-               return mt9m111_set_autoexposure(mt9m111, ctrl->val);
-       case V4L2_CID_AUTO_WHITE_BALANCE:
-               return mt9m111_set_autowhitebalance(mt9m111, ctrl->val);
-       }
-
-       return -EINVAL;
-}
-
-static int mt9m111_suspend(struct mt9m111 *mt9m111)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
-       int ret;
-
-       v4l2_ctrl_s_ctrl(mt9m111->gain, mt9m111_get_global_gain(mt9m111));
-
-       ret = reg_set(RESET, MT9M111_RESET_RESET_MODE);
-       if (!ret)
-               ret = reg_set(RESET, MT9M111_RESET_RESET_SOC |
-                             MT9M111_RESET_OUTPUT_DISABLE |
-                             MT9M111_RESET_ANALOG_STANDBY);
-       if (!ret)
-               ret = reg_clear(RESET, MT9M111_RESET_CHIP_ENABLE);
-
-       return ret;
-}
-
-static void mt9m111_restore_state(struct mt9m111 *mt9m111)
-{
-       mt9m111_set_context(mt9m111, mt9m111->ctx);
-       mt9m111_set_pixfmt(mt9m111, mt9m111->fmt->code);
-       mt9m111_setup_geometry(mt9m111, &mt9m111->rect,
-                       mt9m111->width, mt9m111->height, mt9m111->fmt->code);
-       v4l2_ctrl_handler_setup(&mt9m111->hdl);
-}
-
-static int mt9m111_resume(struct mt9m111 *mt9m111)
-{
-       int ret = mt9m111_enable(mt9m111);
-       if (!ret)
-               ret = mt9m111_reset(mt9m111);
-       if (!ret)
-               mt9m111_restore_state(mt9m111);
-
-       return ret;
-}
-
-static int mt9m111_init(struct mt9m111 *mt9m111)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
-       int ret;
-
-       /* Default HIGHPOWER context */
-       mt9m111->ctx = &context_b;
-       ret = mt9m111_enable(mt9m111);
-       if (!ret)
-               ret = mt9m111_reset(mt9m111);
-       if (!ret)
-               ret = mt9m111_set_context(mt9m111, mt9m111->ctx);
-       if (ret)
-               dev_err(&client->dev, "mt9m111 init failed: %d\n", ret);
-       return ret;
-}
-
-/*
- * Interface active, can use i2c. If it fails, it can indeed mean, that
- * this wasn't our capture interface, so, we wait for the right one
- */
-static int mt9m111_video_probe(struct i2c_client *client)
-{
-       struct mt9m111 *mt9m111 = to_mt9m111(client);
-       s32 data;
-       int ret;
-
-       data = reg_read(CHIP_VERSION);
-
-       switch (data) {
-       case 0x143a: /* MT9M111 or MT9M131 */
-               mt9m111->model = V4L2_IDENT_MT9M111;
-               dev_info(&client->dev,
-                       "Detected a MT9M111/MT9M131 chip ID %x\n", data);
-               break;
-       case 0x148c: /* MT9M112 */
-               mt9m111->model = V4L2_IDENT_MT9M112;
-               dev_info(&client->dev, "Detected a MT9M112 chip ID %x\n", data);
-               break;
-       default:
-               dev_err(&client->dev,
-                       "No MT9M111/MT9M112/MT9M131 chip detected register read %x\n",
-                       data);
-               return -ENODEV;
-       }
-
-       ret = mt9m111_init(mt9m111);
-       if (ret)
-               return ret;
-       return v4l2_ctrl_handler_setup(&mt9m111->hdl);
-}
-
-static int mt9m111_s_power(struct v4l2_subdev *sd, int on)
-{
-       struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       int ret = 0;
-
-       mutex_lock(&mt9m111->power_lock);
-
-       /*
-        * If the power count is modified from 0 to != 0 or from != 0 to 0,
-        * update the power state.
-        */
-       if (mt9m111->power_count == !on) {
-               if (on) {
-                       ret = mt9m111_resume(mt9m111);
-                       if (ret) {
-                               dev_err(&client->dev,
-                                       "Failed to resume the sensor: %d\n", ret);
-                               goto out;
-                       }
-               } else {
-                       mt9m111_suspend(mt9m111);
-               }
-       }
-
-       /* Update the power count. */
-       mt9m111->power_count += on ? 1 : -1;
-       WARN_ON(mt9m111->power_count < 0);
-
-out:
-       mutex_unlock(&mt9m111->power_lock);
-       return ret;
-}
-
-static const struct v4l2_ctrl_ops mt9m111_ctrl_ops = {
-       .s_ctrl = mt9m111_s_ctrl,
-};
-
-static struct v4l2_subdev_core_ops mt9m111_subdev_core_ops = {
-       .g_chip_ident   = mt9m111_g_chip_ident,
-       .s_power        = mt9m111_s_power,
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-       .g_register     = mt9m111_g_register,
-       .s_register     = mt9m111_s_register,
-#endif
-};
-
-static int mt9m111_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                           enum v4l2_mbus_pixelcode *code)
-{
-       if (index >= ARRAY_SIZE(mt9m111_colour_fmts))
-               return -EINVAL;
-
-       *code = mt9m111_colour_fmts[index].code;
-       return 0;
-}
-
-static int mt9m111_g_mbus_config(struct v4l2_subdev *sd,
-                               struct v4l2_mbus_config *cfg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-
-       cfg->flags = V4L2_MBUS_MASTER | V4L2_MBUS_PCLK_SAMPLE_RISING |
-               V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_HIGH |
-               V4L2_MBUS_DATA_ACTIVE_HIGH;
-       cfg->type = V4L2_MBUS_PARALLEL;
-       cfg->flags = soc_camera_apply_board_flags(icl, cfg);
-
-       return 0;
-}
-
-static struct v4l2_subdev_video_ops mt9m111_subdev_video_ops = {
-       .s_mbus_fmt     = mt9m111_s_fmt,
-       .g_mbus_fmt     = mt9m111_g_fmt,
-       .try_mbus_fmt   = mt9m111_try_fmt,
-       .s_crop         = mt9m111_s_crop,
-       .g_crop         = mt9m111_g_crop,
-       .cropcap        = mt9m111_cropcap,
-       .enum_mbus_fmt  = mt9m111_enum_fmt,
-       .g_mbus_config  = mt9m111_g_mbus_config,
-};
-
-static struct v4l2_subdev_ops mt9m111_subdev_ops = {
-       .core   = &mt9m111_subdev_core_ops,
-       .video  = &mt9m111_subdev_video_ops,
-};
-
-static int mt9m111_probe(struct i2c_client *client,
-                        const struct i2c_device_id *did)
-{
-       struct mt9m111 *mt9m111;
-       struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-       int ret;
-
-       if (!icl) {
-               dev_err(&client->dev, "mt9m111: driver needs platform data\n");
-               return -EINVAL;
-       }
-
-       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
-               dev_warn(&adapter->dev,
-                        "I2C-Adapter doesn't support I2C_FUNC_SMBUS_WORD\n");
-               return -EIO;
-       }
-
-       mt9m111 = kzalloc(sizeof(struct mt9m111), GFP_KERNEL);
-       if (!mt9m111)
-               return -ENOMEM;
-
-       v4l2_i2c_subdev_init(&mt9m111->subdev, client, &mt9m111_subdev_ops);
-       v4l2_ctrl_handler_init(&mt9m111->hdl, 5);
-       v4l2_ctrl_new_std(&mt9m111->hdl, &mt9m111_ctrl_ops,
-                       V4L2_CID_VFLIP, 0, 1, 1, 0);
-       v4l2_ctrl_new_std(&mt9m111->hdl, &mt9m111_ctrl_ops,
-                       V4L2_CID_HFLIP, 0, 1, 1, 0);
-       v4l2_ctrl_new_std(&mt9m111->hdl, &mt9m111_ctrl_ops,
-                       V4L2_CID_AUTO_WHITE_BALANCE, 0, 1, 1, 1);
-       mt9m111->gain = v4l2_ctrl_new_std(&mt9m111->hdl, &mt9m111_ctrl_ops,
-                       V4L2_CID_GAIN, 0, 63 * 2 * 2, 1, 32);
-       v4l2_ctrl_new_std_menu(&mt9m111->hdl,
-                       &mt9m111_ctrl_ops, V4L2_CID_EXPOSURE_AUTO, 1, 0,
-                       V4L2_EXPOSURE_AUTO);
-       mt9m111->subdev.ctrl_handler = &mt9m111->hdl;
-       if (mt9m111->hdl.error) {
-               int err = mt9m111->hdl.error;
-
-               kfree(mt9m111);
-               return err;
-       }
-
-       /* Second stage probe - when a capture adapter is there */
-       mt9m111->rect.left      = MT9M111_MIN_DARK_COLS;
-       mt9m111->rect.top       = MT9M111_MIN_DARK_ROWS;
-       mt9m111->rect.width     = MT9M111_MAX_WIDTH;
-       mt9m111->rect.height    = MT9M111_MAX_HEIGHT;
-       mt9m111->fmt            = &mt9m111_colour_fmts[0];
-       mt9m111->lastpage       = -1;
-       mutex_init(&mt9m111->power_lock);
-
-       ret = mt9m111_video_probe(client);
-       if (ret) {
-               v4l2_ctrl_handler_free(&mt9m111->hdl);
-               kfree(mt9m111);
-       }
-
-       return ret;
-}
-
-static int mt9m111_remove(struct i2c_client *client)
-{
-       struct mt9m111 *mt9m111 = to_mt9m111(client);
-
-       v4l2_device_unregister_subdev(&mt9m111->subdev);
-       v4l2_ctrl_handler_free(&mt9m111->hdl);
-       kfree(mt9m111);
-
-       return 0;
-}
-
-static const struct i2c_device_id mt9m111_id[] = {
-       { "mt9m111", 0 },
-       { }
-};
-MODULE_DEVICE_TABLE(i2c, mt9m111_id);
-
-static struct i2c_driver mt9m111_i2c_driver = {
-       .driver = {
-               .name = "mt9m111",
-       },
-       .probe          = mt9m111_probe,
-       .remove         = mt9m111_remove,
-       .id_table       = mt9m111_id,
-};
-
-module_i2c_driver(mt9m111_i2c_driver);
-
-MODULE_DESCRIPTION("Micron/Aptina MT9M111/MT9M112/MT9M131 Camera driver");
-MODULE_AUTHOR("Robert Jarzmik");
-MODULE_LICENSE("GPL");
diff --git a/drivers/media/video/mt9t031.c b/drivers/media/video/mt9t031.c
deleted file mode 100644 (file)
index 1415074..0000000
+++ /dev/null
@@ -1,857 +0,0 @@
-/*
- * Driver for MT9T031 CMOS Image Sensor from Micron
- *
- * Copyright (C) 2008, Guennadi Liakhovetski, DENX Software Engineering <lg@denx.de>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include <linux/device.h>
-#include <linux/i2c.h>
-#include <linux/log2.h>
-#include <linux/pm.h>
-#include <linux/slab.h>
-#include <linux/v4l2-mediabus.h>
-#include <linux/videodev2.h>
-#include <linux/module.h>
-
-#include <media/soc_camera.h>
-#include <media/v4l2-chip-ident.h>
-#include <media/v4l2-subdev.h>
-#include <media/v4l2-ctrls.h>
-
-/*
- * ATTENTION: this driver still cannot be used outside of the soc-camera
- * framework because of its PM implementation, using the video_device node.
- * If hardware becomes available for testing, alternative PM approaches shall
- * be considered and tested.
- */
-
-/*
- * mt9t031 i2c address 0x5d
- * The platform has to define i2c_board_info and link to it from
- * struct soc_camera_link
- */
-
-/* mt9t031 selected register addresses */
-#define MT9T031_CHIP_VERSION           0x00
-#define MT9T031_ROW_START              0x01
-#define MT9T031_COLUMN_START           0x02
-#define MT9T031_WINDOW_HEIGHT          0x03
-#define MT9T031_WINDOW_WIDTH           0x04
-#define MT9T031_HORIZONTAL_BLANKING    0x05
-#define MT9T031_VERTICAL_BLANKING      0x06
-#define MT9T031_OUTPUT_CONTROL         0x07
-#define MT9T031_SHUTTER_WIDTH_UPPER    0x08
-#define MT9T031_SHUTTER_WIDTH          0x09
-#define MT9T031_PIXEL_CLOCK_CONTROL    0x0a
-#define MT9T031_FRAME_RESTART          0x0b
-#define MT9T031_SHUTTER_DELAY          0x0c
-#define MT9T031_RESET                  0x0d
-#define MT9T031_READ_MODE_1            0x1e
-#define MT9T031_READ_MODE_2            0x20
-#define MT9T031_READ_MODE_3            0x21
-#define MT9T031_ROW_ADDRESS_MODE       0x22
-#define MT9T031_COLUMN_ADDRESS_MODE    0x23
-#define MT9T031_GLOBAL_GAIN            0x35
-#define MT9T031_CHIP_ENABLE            0xF8
-
-#define MT9T031_MAX_HEIGHT             1536
-#define MT9T031_MAX_WIDTH              2048
-#define MT9T031_MIN_HEIGHT             2
-#define MT9T031_MIN_WIDTH              18
-#define MT9T031_HORIZONTAL_BLANK       142
-#define MT9T031_VERTICAL_BLANK         25
-#define MT9T031_COLUMN_SKIP            32
-#define MT9T031_ROW_SKIP               20
-
-struct mt9t031 {
-       struct v4l2_subdev subdev;
-       struct v4l2_ctrl_handler hdl;
-       struct {
-               /* exposure/auto-exposure cluster */
-               struct v4l2_ctrl *autoexposure;
-               struct v4l2_ctrl *exposure;
-       };
-       struct v4l2_rect rect;  /* Sensor window */
-       int model;      /* V4L2_IDENT_MT9T031* codes from v4l2-chip-ident.h */
-       u16 xskip;
-       u16 yskip;
-       unsigned int total_h;
-       unsigned short y_skip_top;      /* Lines to skip at the top */
-};
-
-static struct mt9t031 *to_mt9t031(const struct i2c_client *client)
-{
-       return container_of(i2c_get_clientdata(client), struct mt9t031, subdev);
-}
-
-static int reg_read(struct i2c_client *client, const u8 reg)
-{
-       return i2c_smbus_read_word_swapped(client, reg);
-}
-
-static int reg_write(struct i2c_client *client, const u8 reg,
-                    const u16 data)
-{
-       return i2c_smbus_write_word_swapped(client, reg, data);
-}
-
-static int reg_set(struct i2c_client *client, const u8 reg,
-                  const u16 data)
-{
-       int ret;
-
-       ret = reg_read(client, reg);
-       if (ret < 0)
-               return ret;
-       return reg_write(client, reg, ret | data);
-}
-
-static int reg_clear(struct i2c_client *client, const u8 reg,
-                    const u16 data)
-{
-       int ret;
-
-       ret = reg_read(client, reg);
-       if (ret < 0)
-               return ret;
-       return reg_write(client, reg, ret & ~data);
-}
-
-static int set_shutter(struct i2c_client *client, const u32 data)
-{
-       int ret;
-
-       ret = reg_write(client, MT9T031_SHUTTER_WIDTH_UPPER, data >> 16);
-
-       if (ret >= 0)
-               ret = reg_write(client, MT9T031_SHUTTER_WIDTH, data & 0xffff);
-
-       return ret;
-}
-
-static int get_shutter(struct i2c_client *client, u32 *data)
-{
-       int ret;
-
-       ret = reg_read(client, MT9T031_SHUTTER_WIDTH_UPPER);
-       *data = ret << 16;
-
-       if (ret >= 0)
-               ret = reg_read(client, MT9T031_SHUTTER_WIDTH);
-       *data |= ret & 0xffff;
-
-       return ret < 0 ? ret : 0;
-}
-
-static int mt9t031_idle(struct i2c_client *client)
-{
-       int ret;
-
-       /* Disable chip output, synchronous option update */
-       ret = reg_write(client, MT9T031_RESET, 1);
-       if (ret >= 0)
-               ret = reg_write(client, MT9T031_RESET, 0);
-       if (ret >= 0)
-               ret = reg_clear(client, MT9T031_OUTPUT_CONTROL, 2);
-
-       return ret >= 0 ? 0 : -EIO;
-}
-
-static int mt9t031_disable(struct i2c_client *client)
-{
-       /* Disable the chip */
-       reg_clear(client, MT9T031_OUTPUT_CONTROL, 2);
-
-       return 0;
-}
-
-static int mt9t031_s_stream(struct v4l2_subdev *sd, int enable)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       int ret;
-
-       if (enable)
-               /* Switch to master "normal" mode */
-               ret = reg_set(client, MT9T031_OUTPUT_CONTROL, 2);
-       else
-               /* Stop sensor readout */
-               ret = reg_clear(client, MT9T031_OUTPUT_CONTROL, 2);
-
-       if (ret < 0)
-               return -EIO;
-
-       return 0;
-}
-
-/* target must be _even_ */
-static u16 mt9t031_skip(s32 *source, s32 target, s32 max)
-{
-       unsigned int skip;
-
-       if (*source < target + target / 2) {
-               *source = target;
-               return 1;
-       }
-
-       skip = min(max, *source + target / 2) / target;
-       if (skip > 8)
-               skip = 8;
-       *source = target * skip;
-
-       return skip;
-}
-
-/* rect is the sensor rectangle, the caller guarantees parameter validity */
-static int mt9t031_set_params(struct i2c_client *client,
-                             struct v4l2_rect *rect, u16 xskip, u16 yskip)
-{
-       struct mt9t031 *mt9t031 = to_mt9t031(client);
-       int ret;
-       u16 xbin, ybin;
-       const u16 hblank = MT9T031_HORIZONTAL_BLANK,
-               vblank = MT9T031_VERTICAL_BLANK;
-
-       xbin = min(xskip, (u16)3);
-       ybin = min(yskip, (u16)3);
-
-       /*
-        * Could just do roundup(rect->left, [xy]bin * 2); but this is cheaper.
-        * There is always a valid suitably aligned value. The worst case is
-        * xbin = 3, width = 2048. Then we will start at 36, the last read out
-        * pixel will be 2083, which is < 2085 - first black pixel.
-        *
-        * MT9T031 datasheet imposes window left border alignment, depending on
-        * the selected xskip. Failing to conform to this requirement produces
-        * dark horizontal stripes in the image. However, even obeying to this
-        * requirement doesn't eliminate the stripes in all configurations. They
-        * appear "locally reproducibly," but can differ between tests under
-        * different lighting conditions.
-        */
-       switch (xbin) {
-       case 1:
-               rect->left &= ~1;
-               break;
-       case 2:
-               rect->left &= ~3;
-               break;
-       case 3:
-               rect->left = rect->left > roundup(MT9T031_COLUMN_SKIP, 6) ?
-                       (rect->left / 6) * 6 : roundup(MT9T031_COLUMN_SKIP, 6);
-       }
-
-       rect->top &= ~1;
-
-       dev_dbg(&client->dev, "skip %u:%u, rect %ux%u@%u:%u\n",
-               xskip, yskip, rect->width, rect->height, rect->left, rect->top);
-
-       /* Disable register update, reconfigure atomically */
-       ret = reg_set(client, MT9T031_OUTPUT_CONTROL, 1);
-       if (ret < 0)
-               return ret;
-
-       /* Blanking and start values - default... */
-       ret = reg_write(client, MT9T031_HORIZONTAL_BLANKING, hblank);
-       if (ret >= 0)
-               ret = reg_write(client, MT9T031_VERTICAL_BLANKING, vblank);
-
-       if (yskip != mt9t031->yskip || xskip != mt9t031->xskip) {
-               /* Binning, skipping */
-               if (ret >= 0)
-                       ret = reg_write(client, MT9T031_COLUMN_ADDRESS_MODE,
-                                       ((xbin - 1) << 4) | (xskip - 1));
-               if (ret >= 0)
-                       ret = reg_write(client, MT9T031_ROW_ADDRESS_MODE,
-                                       ((ybin - 1) << 4) | (yskip - 1));
-       }
-       dev_dbg(&client->dev, "new physical left %u, top %u\n",
-               rect->left, rect->top);
-
-       /*
-        * The caller provides a supported format, as guaranteed by
-        * .try_mbus_fmt(), soc_camera_s_crop() and soc_camera_cropcap()
-        */
-       if (ret >= 0)
-               ret = reg_write(client, MT9T031_COLUMN_START, rect->left);
-       if (ret >= 0)
-               ret = reg_write(client, MT9T031_ROW_START, rect->top);
-       if (ret >= 0)
-               ret = reg_write(client, MT9T031_WINDOW_WIDTH, rect->width - 1);
-       if (ret >= 0)
-               ret = reg_write(client, MT9T031_WINDOW_HEIGHT,
-                               rect->height + mt9t031->y_skip_top - 1);
-       if (ret >= 0 && v4l2_ctrl_g_ctrl(mt9t031->autoexposure) == V4L2_EXPOSURE_AUTO) {
-               mt9t031->total_h = rect->height + mt9t031->y_skip_top + vblank;
-
-               ret = set_shutter(client, mt9t031->total_h);
-       }
-
-       /* Re-enable register update, commit all changes */
-       if (ret >= 0)
-               ret = reg_clear(client, MT9T031_OUTPUT_CONTROL, 1);
-
-       if (ret >= 0) {
-               mt9t031->rect = *rect;
-               mt9t031->xskip = xskip;
-               mt9t031->yskip = yskip;
-       }
-
-       return ret < 0 ? ret : 0;
-}
-
-static int mt9t031_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
-{
-       struct v4l2_rect rect = a->c;
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9t031 *mt9t031 = to_mt9t031(client);
-
-       rect.width = ALIGN(rect.width, 2);
-       rect.height = ALIGN(rect.height, 2);
-
-       soc_camera_limit_side(&rect.left, &rect.width,
-                    MT9T031_COLUMN_SKIP, MT9T031_MIN_WIDTH, MT9T031_MAX_WIDTH);
-
-       soc_camera_limit_side(&rect.top, &rect.height,
-                    MT9T031_ROW_SKIP, MT9T031_MIN_HEIGHT, MT9T031_MAX_HEIGHT);
-
-       return mt9t031_set_params(client, &rect, mt9t031->xskip, mt9t031->yskip);
-}
-
-static int mt9t031_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9t031 *mt9t031 = to_mt9t031(client);
-
-       a->c    = mt9t031->rect;
-       a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-
-       return 0;
-}
-
-static int mt9t031_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
-{
-       a->bounds.left                  = MT9T031_COLUMN_SKIP;
-       a->bounds.top                   = MT9T031_ROW_SKIP;
-       a->bounds.width                 = MT9T031_MAX_WIDTH;
-       a->bounds.height                = MT9T031_MAX_HEIGHT;
-       a->defrect                      = a->bounds;
-       a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-       a->pixelaspect.numerator        = 1;
-       a->pixelaspect.denominator      = 1;
-
-       return 0;
-}
-
-static int mt9t031_g_fmt(struct v4l2_subdev *sd,
-                        struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9t031 *mt9t031 = to_mt9t031(client);
-
-       mf->width       = mt9t031->rect.width / mt9t031->xskip;
-       mf->height      = mt9t031->rect.height / mt9t031->yskip;
-       mf->code        = V4L2_MBUS_FMT_SBGGR10_1X10;
-       mf->colorspace  = V4L2_COLORSPACE_SRGB;
-       mf->field       = V4L2_FIELD_NONE;
-
-       return 0;
-}
-
-static int mt9t031_s_fmt(struct v4l2_subdev *sd,
-                        struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9t031 *mt9t031 = to_mt9t031(client);
-       u16 xskip, yskip;
-       struct v4l2_rect rect = mt9t031->rect;
-
-       /*
-        * try_fmt has put width and height within limits.
-        * S_FMT: use binning and skipping for scaling
-        */
-       xskip = mt9t031_skip(&rect.width, mf->width, MT9T031_MAX_WIDTH);
-       yskip = mt9t031_skip(&rect.height, mf->height, MT9T031_MAX_HEIGHT);
-
-       mf->code        = V4L2_MBUS_FMT_SBGGR10_1X10;
-       mf->colorspace  = V4L2_COLORSPACE_SRGB;
-
-       /* mt9t031_set_params() doesn't change width and height */
-       return mt9t031_set_params(client, &rect, xskip, yskip);
-}
-
-/*
- * If a user window larger than sensor window is requested, we'll increase the
- * sensor window.
- */
-static int mt9t031_try_fmt(struct v4l2_subdev *sd,
-                          struct v4l2_mbus_framefmt *mf)
-{
-       v4l_bound_align_image(
-               &mf->width, MT9T031_MIN_WIDTH, MT9T031_MAX_WIDTH, 1,
-               &mf->height, MT9T031_MIN_HEIGHT, MT9T031_MAX_HEIGHT, 1, 0);
-
-       mf->code        = V4L2_MBUS_FMT_SBGGR10_1X10;
-       mf->colorspace  = V4L2_COLORSPACE_SRGB;
-
-       return 0;
-}
-
-static int mt9t031_g_chip_ident(struct v4l2_subdev *sd,
-                               struct v4l2_dbg_chip_ident *id)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9t031 *mt9t031 = to_mt9t031(client);
-
-       if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
-               return -EINVAL;
-
-       if (id->match.addr != client->addr)
-               return -ENODEV;
-
-       id->ident       = mt9t031->model;
-       id->revision    = 0;
-
-       return 0;
-}
-
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-static int mt9t031_g_register(struct v4l2_subdev *sd,
-                             struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-
-       if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
-               return -EINVAL;
-
-       if (reg->match.addr != client->addr)
-               return -ENODEV;
-
-       reg->val = reg_read(client, reg->reg);
-
-       if (reg->val > 0xffff)
-               return -EIO;
-
-       return 0;
-}
-
-static int mt9t031_s_register(struct v4l2_subdev *sd,
-                             struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-
-       if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
-               return -EINVAL;
-
-       if (reg->match.addr != client->addr)
-               return -ENODEV;
-
-       if (reg_write(client, reg->reg, reg->val) < 0)
-               return -EIO;
-
-       return 0;
-}
-#endif
-
-static int mt9t031_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
-{
-       struct mt9t031 *mt9t031 = container_of(ctrl->handler,
-                                              struct mt9t031, hdl);
-       const u32 shutter_max = MT9T031_MAX_HEIGHT + MT9T031_VERTICAL_BLANK;
-       s32 min, max;
-
-       switch (ctrl->id) {
-       case V4L2_CID_EXPOSURE_AUTO:
-               min = mt9t031->exposure->minimum;
-               max = mt9t031->exposure->maximum;
-               mt9t031->exposure->val =
-                       (shutter_max / 2 + (mt9t031->total_h - 1) * (max - min))
-                               / shutter_max + min;
-               break;
-       }
-       return 0;
-}
-
-static int mt9t031_s_ctrl(struct v4l2_ctrl *ctrl)
-{
-       struct mt9t031 *mt9t031 = container_of(ctrl->handler,
-                                              struct mt9t031, hdl);
-       struct v4l2_subdev *sd = &mt9t031->subdev;
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct v4l2_ctrl *exp = mt9t031->exposure;
-       int data;
-
-       switch (ctrl->id) {
-       case V4L2_CID_VFLIP:
-               if (ctrl->val)
-                       data = reg_set(client, MT9T031_READ_MODE_2, 0x8000);
-               else
-                       data = reg_clear(client, MT9T031_READ_MODE_2, 0x8000);
-               if (data < 0)
-                       return -EIO;
-               return 0;
-       case V4L2_CID_HFLIP:
-               if (ctrl->val)
-                       data = reg_set(client, MT9T031_READ_MODE_2, 0x4000);
-               else
-                       data = reg_clear(client, MT9T031_READ_MODE_2, 0x4000);
-               if (data < 0)
-                       return -EIO;
-               return 0;
-       case V4L2_CID_GAIN:
-               /* See Datasheet Table 7, Gain settings. */
-               if (ctrl->val <= ctrl->default_value) {
-                       /* Pack it into 0..1 step 0.125, register values 0..8 */
-                       unsigned long range = ctrl->default_value - ctrl->minimum;
-                       data = ((ctrl->val - ctrl->minimum) * 8 + range / 2) / range;
-
-                       dev_dbg(&client->dev, "Setting gain %d\n", data);
-                       data = reg_write(client, MT9T031_GLOBAL_GAIN, data);
-                       if (data < 0)
-                               return -EIO;
-               } else {
-                       /* Pack it into 1.125..128 variable step, register values 9..0x7860 */
-                       /* We assume qctrl->maximum - qctrl->default_value - 1 > 0 */
-                       unsigned long range = ctrl->maximum - ctrl->default_value - 1;
-                       /* calculated gain: map 65..127 to 9..1024 step 0.125 */
-                       unsigned long gain = ((ctrl->val - ctrl->default_value - 1) *
-                                              1015 + range / 2) / range + 9;
-
-                       if (gain <= 32)         /* calculated gain 9..32 -> 9..32 */
-                               data = gain;
-                       else if (gain <= 64)    /* calculated gain 33..64 -> 0x51..0x60 */
-                               data = ((gain - 32) * 16 + 16) / 32 + 80;
-                       else
-                               /* calculated gain 65..1024 -> (1..120) << 8 + 0x60 */
-                               data = (((gain - 64 + 7) * 32) & 0xff00) | 0x60;
-
-                       dev_dbg(&client->dev, "Set gain from 0x%x to 0x%x\n",
-                               reg_read(client, MT9T031_GLOBAL_GAIN), data);
-                       data = reg_write(client, MT9T031_GLOBAL_GAIN, data);
-                       if (data < 0)
-                               return -EIO;
-               }
-               return 0;
-
-       case V4L2_CID_EXPOSURE_AUTO:
-               if (ctrl->val == V4L2_EXPOSURE_MANUAL) {
-                       unsigned int range = exp->maximum - exp->minimum;
-                       unsigned int shutter = ((exp->val - exp->minimum) * 1048 +
-                                                range / 2) / range + 1;
-                       u32 old;
-
-                       get_shutter(client, &old);
-                       dev_dbg(&client->dev, "Set shutter from %u to %u\n",
-                               old, shutter);
-                       if (set_shutter(client, shutter) < 0)
-                               return -EIO;
-               } else {
-                       const u16 vblank = MT9T031_VERTICAL_BLANK;
-                       mt9t031->total_h = mt9t031->rect.height +
-                               mt9t031->y_skip_top + vblank;
-
-                       if (set_shutter(client, mt9t031->total_h) < 0)
-                               return -EIO;
-               }
-               return 0;
-       default:
-               return -EINVAL;
-       }
-       return 0;
-}
-
-/*
- * Power Management:
- * This function does nothing for now but must be present for pm to work
- */
-static int mt9t031_runtime_suspend(struct device *dev)
-{
-       return 0;
-}
-
-/*
- * Power Management:
- * COLUMN_ADDRESS_MODE and ROW_ADDRESS_MODE are not rewritten if unchanged
- * they are however changed at reset if the platform hook is present
- * thus we rewrite them with the values stored by the driver
- */
-static int mt9t031_runtime_resume(struct device *dev)
-{
-       struct video_device *vdev = to_video_device(dev);
-       struct v4l2_subdev *sd = soc_camera_vdev_to_subdev(vdev);
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9t031 *mt9t031 = to_mt9t031(client);
-
-       int ret;
-       u16 xbin, ybin;
-
-       xbin = min(mt9t031->xskip, (u16)3);
-       ybin = min(mt9t031->yskip, (u16)3);
-
-       ret = reg_write(client, MT9T031_COLUMN_ADDRESS_MODE,
-               ((xbin - 1) << 4) | (mt9t031->xskip - 1));
-       if (ret < 0)
-               return ret;
-
-       ret = reg_write(client, MT9T031_ROW_ADDRESS_MODE,
-               ((ybin - 1) << 4) | (mt9t031->yskip - 1));
-       if (ret < 0)
-               return ret;
-
-       return 0;
-}
-
-static struct dev_pm_ops mt9t031_dev_pm_ops = {
-       .runtime_suspend        = mt9t031_runtime_suspend,
-       .runtime_resume         = mt9t031_runtime_resume,
-};
-
-static struct device_type mt9t031_dev_type = {
-       .name   = "MT9T031",
-       .pm     = &mt9t031_dev_pm_ops,
-};
-
-static int mt9t031_s_power(struct v4l2_subdev *sd, int on)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct video_device *vdev = soc_camera_i2c_to_vdev(client);
-
-       if (on)
-               vdev->dev.type = &mt9t031_dev_type;
-       else
-               vdev->dev.type = NULL;
-
-       return 0;
-}
-
-/*
- * Interface active, can use i2c. If it fails, it can indeed mean, that
- * this wasn't our capture interface, so, we wait for the right one
- */
-static int mt9t031_video_probe(struct i2c_client *client)
-{
-       struct mt9t031 *mt9t031 = to_mt9t031(client);
-       s32 data;
-       int ret;
-
-       /* Enable the chip */
-       data = reg_write(client, MT9T031_CHIP_ENABLE, 1);
-       dev_dbg(&client->dev, "write: %d\n", data);
-
-       /* Read out the chip version register */
-       data = reg_read(client, MT9T031_CHIP_VERSION);
-
-       switch (data) {
-       case 0x1621:
-               mt9t031->model = V4L2_IDENT_MT9T031;
-               break;
-       default:
-               dev_err(&client->dev,
-                       "No MT9T031 chip detected, register read %x\n", data);
-               return -ENODEV;
-       }
-
-       dev_info(&client->dev, "Detected a MT9T031 chip ID %x\n", data);
-
-       ret = mt9t031_idle(client);
-       if (ret < 0)
-               dev_err(&client->dev, "Failed to initialise the camera\n");
-       else
-               v4l2_ctrl_handler_setup(&mt9t031->hdl);
-
-       return ret;
-}
-
-static int mt9t031_g_skip_top_lines(struct v4l2_subdev *sd, u32 *lines)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9t031 *mt9t031 = to_mt9t031(client);
-
-       *lines = mt9t031->y_skip_top;
-
-       return 0;
-}
-
-static const struct v4l2_ctrl_ops mt9t031_ctrl_ops = {
-       .g_volatile_ctrl = mt9t031_g_volatile_ctrl,
-       .s_ctrl = mt9t031_s_ctrl,
-};
-
-static struct v4l2_subdev_core_ops mt9t031_subdev_core_ops = {
-       .g_chip_ident   = mt9t031_g_chip_ident,
-       .s_power        = mt9t031_s_power,
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-       .g_register     = mt9t031_g_register,
-       .s_register     = mt9t031_s_register,
-#endif
-};
-
-static int mt9t031_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                           enum v4l2_mbus_pixelcode *code)
-{
-       if (index)
-               return -EINVAL;
-
-       *code = V4L2_MBUS_FMT_SBGGR10_1X10;
-       return 0;
-}
-
-static int mt9t031_g_mbus_config(struct v4l2_subdev *sd,
-                               struct v4l2_mbus_config *cfg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-
-       cfg->flags = V4L2_MBUS_MASTER | V4L2_MBUS_PCLK_SAMPLE_RISING |
-               V4L2_MBUS_PCLK_SAMPLE_FALLING | V4L2_MBUS_HSYNC_ACTIVE_HIGH |
-               V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_DATA_ACTIVE_HIGH;
-       cfg->type = V4L2_MBUS_PARALLEL;
-       cfg->flags = soc_camera_apply_board_flags(icl, cfg);
-
-       return 0;
-}
-
-static int mt9t031_s_mbus_config(struct v4l2_subdev *sd,
-                               const struct v4l2_mbus_config *cfg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-
-       if (soc_camera_apply_board_flags(icl, cfg) &
-           V4L2_MBUS_PCLK_SAMPLE_FALLING)
-               return reg_clear(client, MT9T031_PIXEL_CLOCK_CONTROL, 0x8000);
-       else
-               return reg_set(client, MT9T031_PIXEL_CLOCK_CONTROL, 0x8000);
-}
-
-static struct v4l2_subdev_video_ops mt9t031_subdev_video_ops = {
-       .s_stream       = mt9t031_s_stream,
-       .s_mbus_fmt     = mt9t031_s_fmt,
-       .g_mbus_fmt     = mt9t031_g_fmt,
-       .try_mbus_fmt   = mt9t031_try_fmt,
-       .s_crop         = mt9t031_s_crop,
-       .g_crop         = mt9t031_g_crop,
-       .cropcap        = mt9t031_cropcap,
-       .enum_mbus_fmt  = mt9t031_enum_fmt,
-       .g_mbus_config  = mt9t031_g_mbus_config,
-       .s_mbus_config  = mt9t031_s_mbus_config,
-};
-
-static struct v4l2_subdev_sensor_ops mt9t031_subdev_sensor_ops = {
-       .g_skip_top_lines       = mt9t031_g_skip_top_lines,
-};
-
-static struct v4l2_subdev_ops mt9t031_subdev_ops = {
-       .core   = &mt9t031_subdev_core_ops,
-       .video  = &mt9t031_subdev_video_ops,
-       .sensor = &mt9t031_subdev_sensor_ops,
-};
-
-static int mt9t031_probe(struct i2c_client *client,
-                        const struct i2c_device_id *did)
-{
-       struct mt9t031 *mt9t031;
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-       struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
-       int ret;
-
-       if (!icl) {
-               dev_err(&client->dev, "MT9T031 driver needs platform data\n");
-               return -EINVAL;
-       }
-
-       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
-               dev_warn(&adapter->dev,
-                        "I2C-Adapter doesn't support I2C_FUNC_SMBUS_WORD\n");
-               return -EIO;
-       }
-
-       mt9t031 = kzalloc(sizeof(struct mt9t031), GFP_KERNEL);
-       if (!mt9t031)
-               return -ENOMEM;
-
-       v4l2_i2c_subdev_init(&mt9t031->subdev, client, &mt9t031_subdev_ops);
-       v4l2_ctrl_handler_init(&mt9t031->hdl, 5);
-       v4l2_ctrl_new_std(&mt9t031->hdl, &mt9t031_ctrl_ops,
-                       V4L2_CID_VFLIP, 0, 1, 1, 0);
-       v4l2_ctrl_new_std(&mt9t031->hdl, &mt9t031_ctrl_ops,
-                       V4L2_CID_HFLIP, 0, 1, 1, 0);
-       v4l2_ctrl_new_std(&mt9t031->hdl, &mt9t031_ctrl_ops,
-                       V4L2_CID_GAIN, 0, 127, 1, 64);
-
-       /*
-        * Simulated autoexposure. If enabled, we calculate shutter width
-        * ourselves in the driver based on vertical blanking and frame width
-        */
-       mt9t031->autoexposure = v4l2_ctrl_new_std_menu(&mt9t031->hdl,
-                       &mt9t031_ctrl_ops, V4L2_CID_EXPOSURE_AUTO, 1, 0,
-                       V4L2_EXPOSURE_AUTO);
-       mt9t031->exposure = v4l2_ctrl_new_std(&mt9t031->hdl, &mt9t031_ctrl_ops,
-                       V4L2_CID_EXPOSURE, 1, 255, 1, 255);
-
-       mt9t031->subdev.ctrl_handler = &mt9t031->hdl;
-       if (mt9t031->hdl.error) {
-               int err = mt9t031->hdl.error;
-
-               kfree(mt9t031);
-               return err;
-       }
-       v4l2_ctrl_auto_cluster(2, &mt9t031->autoexposure,
-                               V4L2_EXPOSURE_MANUAL, true);
-
-       mt9t031->y_skip_top     = 0;
-       mt9t031->rect.left      = MT9T031_COLUMN_SKIP;
-       mt9t031->rect.top       = MT9T031_ROW_SKIP;
-       mt9t031->rect.width     = MT9T031_MAX_WIDTH;
-       mt9t031->rect.height    = MT9T031_MAX_HEIGHT;
-
-       mt9t031->xskip = 1;
-       mt9t031->yskip = 1;
-
-       mt9t031_idle(client);
-
-       ret = mt9t031_video_probe(client);
-
-       mt9t031_disable(client);
-
-       if (ret) {
-               v4l2_ctrl_handler_free(&mt9t031->hdl);
-               kfree(mt9t031);
-       }
-
-       return ret;
-}
-
-static int mt9t031_remove(struct i2c_client *client)
-{
-       struct mt9t031 *mt9t031 = to_mt9t031(client);
-
-       v4l2_device_unregister_subdev(&mt9t031->subdev);
-       v4l2_ctrl_handler_free(&mt9t031->hdl);
-       kfree(mt9t031);
-
-       return 0;
-}
-
-static const struct i2c_device_id mt9t031_id[] = {
-       { "mt9t031", 0 },
-       { }
-};
-MODULE_DEVICE_TABLE(i2c, mt9t031_id);
-
-static struct i2c_driver mt9t031_i2c_driver = {
-       .driver = {
-               .name = "mt9t031",
-       },
-       .probe          = mt9t031_probe,
-       .remove         = mt9t031_remove,
-       .id_table       = mt9t031_id,
-};
-
-module_i2c_driver(mt9t031_i2c_driver);
-
-MODULE_DESCRIPTION("Micron MT9T031 Camera driver");
-MODULE_AUTHOR("Guennadi Liakhovetski <lg@denx.de>");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/video/mt9t112.c b/drivers/media/video/mt9t112.c
deleted file mode 100644 (file)
index e1ae46a..0000000
+++ /dev/null
@@ -1,1125 +0,0 @@
-/*
- * mt9t112 Camera Driver
- *
- * Copyright (C) 2009 Renesas Solutions Corp.
- * Kuninori Morimoto <morimoto.kuninori@renesas.com>
- *
- * Based on ov772x driver, mt9m111 driver,
- *
- * Copyright (C) 2008 Kuninori Morimoto <morimoto.kuninori@renesas.com>
- * Copyright (C) 2008, Robert Jarzmik <robert.jarzmik@free.fr>
- * Copyright 2006-7 Jonathan Corbet <corbet@lwn.net>
- * Copyright (C) 2008 Magnus Damm
- * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include <linux/delay.h>
-#include <linux/i2c.h>
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/slab.h>
-#include <linux/v4l2-mediabus.h>
-#include <linux/videodev2.h>
-
-#include <media/mt9t112.h>
-#include <media/soc_camera.h>
-#include <media/v4l2-chip-ident.h>
-#include <media/v4l2-common.h>
-
-/* you can check PLL/clock info */
-/* #define EXT_CLOCK 24000000 */
-
-/************************************************************************
-                       macro
-************************************************************************/
-/*
- * frame size
- */
-#define MAX_WIDTH   2048
-#define MAX_HEIGHT  1536
-
-#define VGA_WIDTH   640
-#define VGA_HEIGHT  480
-
-/*
- * macro of read/write
- */
-#define ECHECKER(ret, x)               \
-       do {                            \
-               (ret) = (x);            \
-               if ((ret) < 0)          \
-                       return (ret);   \
-       } while (0)
-
-#define mt9t112_reg_write(ret, client, a, b) \
-       ECHECKER(ret, __mt9t112_reg_write(client, a, b))
-#define mt9t112_mcu_write(ret, client, a, b) \
-       ECHECKER(ret, __mt9t112_mcu_write(client, a, b))
-
-#define mt9t112_reg_mask_set(ret, client, a, b, c) \
-       ECHECKER(ret, __mt9t112_reg_mask_set(client, a, b, c))
-#define mt9t112_mcu_mask_set(ret, client, a, b, c) \
-       ECHECKER(ret, __mt9t112_mcu_mask_set(client, a, b, c))
-
-#define mt9t112_reg_read(ret, client, a) \
-       ECHECKER(ret, __mt9t112_reg_read(client, a))
-
-/*
- * Logical address
- */
-#define _VAR(id, offset, base) (base | (id & 0x1f) << 10 | (offset & 0x3ff))
-#define VAR(id, offset)  _VAR(id, offset, 0x0000)
-#define VAR8(id, offset) _VAR(id, offset, 0x8000)
-
-/************************************************************************
-                       struct
-************************************************************************/
-struct mt9t112_format {
-       enum v4l2_mbus_pixelcode code;
-       enum v4l2_colorspace colorspace;
-       u16 fmt;
-       u16 order;
-};
-
-struct mt9t112_priv {
-       struct v4l2_subdev               subdev;
-       struct mt9t112_camera_info      *info;
-       struct i2c_client               *client;
-       struct v4l2_rect                 frame;
-       const struct mt9t112_format     *format;
-       int                              model;
-       u32                              flags;
-/* for flags */
-#define INIT_DONE      (1 << 0)
-#define PCLK_RISING    (1 << 1)
-};
-
-/************************************************************************
-                       supported format
-************************************************************************/
-
-static const struct mt9t112_format mt9t112_cfmts[] = {
-       {
-               .code           = V4L2_MBUS_FMT_UYVY8_2X8,
-               .colorspace     = V4L2_COLORSPACE_JPEG,
-               .fmt            = 1,
-               .order          = 0,
-       }, {
-               .code           = V4L2_MBUS_FMT_VYUY8_2X8,
-               .colorspace     = V4L2_COLORSPACE_JPEG,
-               .fmt            = 1,
-               .order          = 1,
-       }, {
-               .code           = V4L2_MBUS_FMT_YUYV8_2X8,
-               .colorspace     = V4L2_COLORSPACE_JPEG,
-               .fmt            = 1,
-               .order          = 2,
-       }, {
-               .code           = V4L2_MBUS_FMT_YVYU8_2X8,
-               .colorspace     = V4L2_COLORSPACE_JPEG,
-               .fmt            = 1,
-               .order          = 3,
-       }, {
-               .code           = V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE,
-               .colorspace     = V4L2_COLORSPACE_SRGB,
-               .fmt            = 8,
-               .order          = 2,
-       }, {
-               .code           = V4L2_MBUS_FMT_RGB565_2X8_LE,
-               .colorspace     = V4L2_COLORSPACE_SRGB,
-               .fmt            = 4,
-               .order          = 2,
-       },
-};
-
-/************************************************************************
-                       general function
-************************************************************************/
-static struct mt9t112_priv *to_mt9t112(const struct i2c_client *client)
-{
-       return container_of(i2c_get_clientdata(client),
-                           struct mt9t112_priv,
-                           subdev);
-}
-
-static int __mt9t112_reg_read(const struct i2c_client *client, u16 command)
-{
-       struct i2c_msg msg[2];
-       u8 buf[2];
-       int ret;
-
-       command = swab16(command);
-
-       msg[0].addr  = client->addr;
-       msg[0].flags = 0;
-       msg[0].len   = 2;
-       msg[0].buf   = (u8 *)&command;
-
-       msg[1].addr  = client->addr;
-       msg[1].flags = I2C_M_RD;
-       msg[1].len   = 2;
-       msg[1].buf   = buf;
-
-       /*
-        * if return value of this function is < 0,
-        * it mean error.
-        * else, under 16bit is valid data.
-        */
-       ret = i2c_transfer(client->adapter, msg, 2);
-       if (ret < 0)
-               return ret;
-
-       memcpy(&ret, buf, 2);
-       return swab16(ret);
-}
-
-static int __mt9t112_reg_write(const struct i2c_client *client,
-                              u16 command, u16 data)
-{
-       struct i2c_msg msg;
-       u8 buf[4];
-       int ret;
-
-       command = swab16(command);
-       data = swab16(data);
-
-       memcpy(buf + 0, &command, 2);
-       memcpy(buf + 2, &data,    2);
-
-       msg.addr  = client->addr;
-       msg.flags = 0;
-       msg.len   = 4;
-       msg.buf   = buf;
-
-       /*
-        * i2c_transfer return message length,
-        * but this function should return 0 if correct case
-        */
-       ret = i2c_transfer(client->adapter, &msg, 1);
-       if (ret >= 0)
-               ret = 0;
-
-       return ret;
-}
-
-static int __mt9t112_reg_mask_set(const struct i2c_client *client,
-                                 u16  command,
-                                 u16  mask,
-                                 u16  set)
-{
-       int val = __mt9t112_reg_read(client, command);
-       if (val < 0)
-               return val;
-
-       val &= ~mask;
-       val |= set & mask;
-
-       return __mt9t112_reg_write(client, command, val);
-}
-
-/* mcu access */
-static int __mt9t112_mcu_read(const struct i2c_client *client, u16 command)
-{
-       int ret;
-
-       ret = __mt9t112_reg_write(client, 0x098E, command);
-       if (ret < 0)
-               return ret;
-
-       return __mt9t112_reg_read(client, 0x0990);
-}
-
-static int __mt9t112_mcu_write(const struct i2c_client *client,
-                              u16 command, u16 data)
-{
-       int ret;
-
-       ret = __mt9t112_reg_write(client, 0x098E, command);
-       if (ret < 0)
-               return ret;
-
-       return __mt9t112_reg_write(client, 0x0990, data);
-}
-
-static int __mt9t112_mcu_mask_set(const struct i2c_client *client,
-                                 u16  command,
-                                 u16  mask,
-                                 u16  set)
-{
-       int val = __mt9t112_mcu_read(client, command);
-       if (val < 0)
-               return val;
-
-       val &= ~mask;
-       val |= set & mask;
-
-       return __mt9t112_mcu_write(client, command, val);
-}
-
-static int mt9t112_reset(const struct i2c_client *client)
-{
-       int ret;
-
-       mt9t112_reg_mask_set(ret, client, 0x001a, 0x0001, 0x0001);
-       msleep(1);
-       mt9t112_reg_mask_set(ret, client, 0x001a, 0x0001, 0x0000);
-
-       return ret;
-}
-
-#ifndef EXT_CLOCK
-#define CLOCK_INFO(a, b)
-#else
-#define CLOCK_INFO(a, b) mt9t112_clock_info(a, b)
-static int mt9t112_clock_info(const struct i2c_client *client, u32 ext)
-{
-       int m, n, p1, p2, p3, p4, p5, p6, p7;
-       u32 vco, clk;
-       char *enable;
-
-       ext /= 1000; /* kbyte order */
-
-       mt9t112_reg_read(n, client, 0x0012);
-       p1 = n & 0x000f;
-       n = n >> 4;
-       p2 = n & 0x000f;
-       n = n >> 4;
-       p3 = n & 0x000f;
-
-       mt9t112_reg_read(n, client, 0x002a);
-       p4 = n & 0x000f;
-       n = n >> 4;
-       p5 = n & 0x000f;
-       n = n >> 4;
-       p6 = n & 0x000f;
-
-       mt9t112_reg_read(n, client, 0x002c);
-       p7 = n & 0x000f;
-
-       mt9t112_reg_read(n, client, 0x0010);
-       m = n & 0x00ff;
-       n = (n >> 8) & 0x003f;
-
-       enable = ((6000 > ext) || (54000 < ext)) ? "X" : "";
-       dev_dbg(&client->dev, "EXTCLK          : %10u K %s\n", ext, enable);
-
-       vco = 2 * m * ext / (n+1);
-       enable = ((384000 > vco) || (768000 < vco)) ? "X" : "";
-       dev_dbg(&client->dev, "VCO             : %10u K %s\n", vco, enable);
-
-       clk = vco / (p1+1) / (p2+1);
-       enable = (96000 < clk) ? "X" : "";
-       dev_dbg(&client->dev, "PIXCLK          : %10u K %s\n", clk, enable);
-
-       clk = vco / (p3+1);
-       enable = (768000 < clk) ? "X" : "";
-       dev_dbg(&client->dev, "MIPICLK         : %10u K %s\n", clk, enable);
-
-       clk = vco / (p6+1);
-       enable = (96000 < clk) ? "X" : "";
-       dev_dbg(&client->dev, "MCU CLK         : %10u K %s\n", clk, enable);
-
-       clk = vco / (p5+1);
-       enable = (54000 < clk) ? "X" : "";
-       dev_dbg(&client->dev, "SOC CLK         : %10u K %s\n", clk, enable);
-
-       clk = vco / (p4+1);
-       enable = (70000 < clk) ? "X" : "";
-       dev_dbg(&client->dev, "Sensor CLK      : %10u K %s\n", clk, enable);
-
-       clk = vco / (p7+1);
-       dev_dbg(&client->dev, "External sensor : %10u K\n", clk);
-
-       clk = ext / (n+1);
-       enable = ((2000 > clk) || (24000 < clk)) ? "X" : "";
-       dev_dbg(&client->dev, "PFD             : %10u K %s\n", clk, enable);
-
-       return 0;
-}
-#endif
-
-static void mt9t112_frame_check(u32 *width, u32 *height, u32 *left, u32 *top)
-{
-       soc_camera_limit_side(left, width, 0, 0, MAX_WIDTH);
-       soc_camera_limit_side(top, height, 0, 0, MAX_HEIGHT);
-}
-
-static int mt9t112_set_a_frame_size(const struct i2c_client *client,
-                                  u16 width,
-                                  u16 height)
-{
-       int ret;
-       u16 wstart = (MAX_WIDTH - width) / 2;
-       u16 hstart = (MAX_HEIGHT - height) / 2;
-
-       /* (Context A) Image Width/Height */
-       mt9t112_mcu_write(ret, client, VAR(26, 0), width);
-       mt9t112_mcu_write(ret, client, VAR(26, 2), height);
-
-       /* (Context A) Output Width/Height */
-       mt9t112_mcu_write(ret, client, VAR(18, 43), 8 + width);
-       mt9t112_mcu_write(ret, client, VAR(18, 45), 8 + height);
-
-       /* (Context A) Start Row/Column */
-       mt9t112_mcu_write(ret, client, VAR(18, 2), 4 + hstart);
-       mt9t112_mcu_write(ret, client, VAR(18, 4), 4 + wstart);
-
-       /* (Context A) End Row/Column */
-       mt9t112_mcu_write(ret, client, VAR(18, 6), 11 + height + hstart);
-       mt9t112_mcu_write(ret, client, VAR(18, 8), 11 + width  + wstart);
-
-       mt9t112_mcu_write(ret, client, VAR8(1, 0), 0x06);
-
-       return ret;
-}
-
-static int mt9t112_set_pll_dividers(const struct i2c_client *client,
-                                   u8 m, u8 n,
-                                   u8 p1, u8 p2, u8 p3,
-                                   u8 p4, u8 p5, u8 p6,
-                                   u8 p7)
-{
-       int ret;
-       u16 val;
-
-       /* N/M */
-       val = (n << 8) |
-             (m << 0);
-       mt9t112_reg_mask_set(ret, client, 0x0010, 0x3fff, val);
-
-       /* P1/P2/P3 */
-       val = ((p3 & 0x0F) << 8) |
-             ((p2 & 0x0F) << 4) |
-             ((p1 & 0x0F) << 0);
-       mt9t112_reg_mask_set(ret, client, 0x0012, 0x0fff, val);
-
-       /* P4/P5/P6 */
-       val = (0x7         << 12) |
-             ((p6 & 0x0F) <<  8) |
-             ((p5 & 0x0F) <<  4) |
-             ((p4 & 0x0F) <<  0);
-       mt9t112_reg_mask_set(ret, client, 0x002A, 0x7fff, val);
-
-       /* P7 */
-       val = (0x1         << 12) |
-             ((p7 & 0x0F) <<  0);
-       mt9t112_reg_mask_set(ret, client, 0x002C, 0x100f, val);
-
-       return ret;
-}
-
-static int mt9t112_init_pll(const struct i2c_client *client)
-{
-       struct mt9t112_priv *priv = to_mt9t112(client);
-       int data, i, ret;
-
-       mt9t112_reg_mask_set(ret, client, 0x0014, 0x003, 0x0001);
-
-       /* PLL control: BYPASS PLL = 8517 */
-       mt9t112_reg_write(ret, client, 0x0014, 0x2145);
-
-       /* Replace these registers when new timing parameters are generated */
-       mt9t112_set_pll_dividers(client,
-                                priv->info->divider.m,
-                                priv->info->divider.n,
-                                priv->info->divider.p1,
-                                priv->info->divider.p2,
-                                priv->info->divider.p3,
-                                priv->info->divider.p4,
-                                priv->info->divider.p5,
-                                priv->info->divider.p6,
-                                priv->info->divider.p7);
-
-       /*
-        * TEST_BYPASS  on
-        * PLL_ENABLE   on
-        * SEL_LOCK_DET on
-        * TEST_BYPASS  off
-        */
-       mt9t112_reg_write(ret, client, 0x0014, 0x2525);
-       mt9t112_reg_write(ret, client, 0x0014, 0x2527);
-       mt9t112_reg_write(ret, client, 0x0014, 0x3427);
-       mt9t112_reg_write(ret, client, 0x0014, 0x3027);
-
-       mdelay(10);
-
-       /*
-        * PLL_BYPASS off
-        * Reference clock count
-        * I2C Master Clock Divider
-        */
-       mt9t112_reg_write(ret, client, 0x0014, 0x3046);
-       mt9t112_reg_write(ret, client, 0x0016, 0x0400); /* JPEG initialization workaround */
-       mt9t112_reg_write(ret, client, 0x0022, 0x0190);
-       mt9t112_reg_write(ret, client, 0x3B84, 0x0212);
-
-       /* External sensor clock is PLL bypass */
-       mt9t112_reg_write(ret, client, 0x002E, 0x0500);
-
-       mt9t112_reg_mask_set(ret, client, 0x0018, 0x0002, 0x0002);
-       mt9t112_reg_mask_set(ret, client, 0x3B82, 0x0004, 0x0004);
-
-       /* MCU disabled */
-       mt9t112_reg_mask_set(ret, client, 0x0018, 0x0004, 0x0004);
-
-       /* out of standby */
-       mt9t112_reg_mask_set(ret, client, 0x0018, 0x0001, 0);
-
-       mdelay(50);
-
-       /*
-        * Standby Workaround
-        * Disable Secondary I2C Pads
-        */
-       mt9t112_reg_write(ret, client, 0x0614, 0x0001);
-       mdelay(1);
-       mt9t112_reg_write(ret, client, 0x0614, 0x0001);
-       mdelay(1);
-       mt9t112_reg_write(ret, client, 0x0614, 0x0001);
-       mdelay(1);
-       mt9t112_reg_write(ret, client, 0x0614, 0x0001);
-       mdelay(1);
-       mt9t112_reg_write(ret, client, 0x0614, 0x0001);
-       mdelay(1);
-       mt9t112_reg_write(ret, client, 0x0614, 0x0001);
-       mdelay(1);
-
-       /* poll to verify out of standby. Must Poll this bit */
-       for (i = 0; i < 100; i++) {
-               mt9t112_reg_read(data, client, 0x0018);
-               if (!(0x4000 & data))
-                       break;
-
-               mdelay(10);
-       }
-
-       return ret;
-}
-
-static int mt9t112_init_setting(const struct i2c_client *client)
-{
-
-       int ret;
-
-       /* Adaptive Output Clock (A) */
-       mt9t112_mcu_mask_set(ret, client, VAR(26, 160), 0x0040, 0x0000);
-
-       /* Read Mode (A) */
-       mt9t112_mcu_write(ret, client, VAR(18, 12), 0x0024);
-
-       /* Fine Correction (A) */
-       mt9t112_mcu_write(ret, client, VAR(18, 15), 0x00CC);
-
-       /* Fine IT Min (A) */
-       mt9t112_mcu_write(ret, client, VAR(18, 17), 0x01f1);
-
-       /* Fine IT Max Margin (A) */
-       mt9t112_mcu_write(ret, client, VAR(18, 19), 0x00fF);
-
-       /* Base Frame Lines (A) */
-       mt9t112_mcu_write(ret, client, VAR(18, 29), 0x032D);
-
-       /* Min Line Length (A) */
-       mt9t112_mcu_write(ret, client, VAR(18, 31), 0x073a);
-
-       /* Line Length (A) */
-       mt9t112_mcu_write(ret, client, VAR(18, 37), 0x07d0);
-
-       /* Adaptive Output Clock (B) */
-       mt9t112_mcu_mask_set(ret, client, VAR(27, 160), 0x0040, 0x0000);
-
-       /* Row Start (B) */
-       mt9t112_mcu_write(ret, client, VAR(18, 74), 0x004);
-
-       /* Column Start (B) */
-       mt9t112_mcu_write(ret, client, VAR(18, 76), 0x004);
-
-       /* Row End (B) */
-       mt9t112_mcu_write(ret, client, VAR(18, 78), 0x60B);
-
-       /* Column End (B) */
-       mt9t112_mcu_write(ret, client, VAR(18, 80), 0x80B);
-
-       /* Fine Correction (B) */
-       mt9t112_mcu_write(ret, client, VAR(18, 87), 0x008C);
-
-       /* Fine IT Min (B) */
-       mt9t112_mcu_write(ret, client, VAR(18, 89), 0x01F1);
-
-       /* Fine IT Max Margin (B) */
-       mt9t112_mcu_write(ret, client, VAR(18, 91), 0x00FF);
-
-       /* Base Frame Lines (B) */
-       mt9t112_mcu_write(ret, client, VAR(18, 101), 0x0668);
-
-       /* Min Line Length (B) */
-       mt9t112_mcu_write(ret, client, VAR(18, 103), 0x0AF0);
-
-       /* Line Length (B) */
-       mt9t112_mcu_write(ret, client, VAR(18, 109), 0x0AF0);
-
-       /*
-        * Flicker Dectection registers
-        * This section should be replaced whenever new Timing file is generated
-        * All the following registers need to be replaced
-        * Following registers are generated from Register Wizard but user can
-        * modify them. For detail see auto flicker detection tuning
-        */
-
-       /* FD_FDPERIOD_SELECT */
-       mt9t112_mcu_write(ret, client, VAR8(8, 5), 0x01);
-
-       /* PRI_B_CONFIG_FD_ALGO_RUN */
-       mt9t112_mcu_write(ret, client, VAR(27, 17), 0x0003);
-
-       /* PRI_A_CONFIG_FD_ALGO_RUN */
-       mt9t112_mcu_write(ret, client, VAR(26, 17), 0x0003);
-
-       /*
-        * AFD range detection tuning registers
-        */
-
-       /* search_f1_50 */
-       mt9t112_mcu_write(ret, client, VAR8(18, 165), 0x25);
-
-       /* search_f2_50 */
-       mt9t112_mcu_write(ret, client, VAR8(18, 166), 0x28);
-
-       /* search_f1_60 */
-       mt9t112_mcu_write(ret, client, VAR8(18, 167), 0x2C);
-
-       /* search_f2_60 */
-       mt9t112_mcu_write(ret, client, VAR8(18, 168), 0x2F);
-
-       /* period_50Hz (A) */
-       mt9t112_mcu_write(ret, client, VAR8(18, 68), 0xBA);
-
-       /* secret register by aptina */
-       /* period_50Hz (A MSB) */
-       mt9t112_mcu_write(ret, client, VAR8(18, 303), 0x00);
-
-       /* period_60Hz (A) */
-       mt9t112_mcu_write(ret, client, VAR8(18, 69), 0x9B);
-
-       /* secret register by aptina */
-       /* period_60Hz (A MSB) */
-       mt9t112_mcu_write(ret, client, VAR8(18, 301), 0x00);
-
-       /* period_50Hz (B) */
-       mt9t112_mcu_write(ret, client, VAR8(18, 140), 0x82);
-
-       /* secret register by aptina */
-       /* period_50Hz (B) MSB */
-       mt9t112_mcu_write(ret, client, VAR8(18, 304), 0x00);
-
-       /* period_60Hz (B) */
-       mt9t112_mcu_write(ret, client, VAR8(18, 141), 0x6D);
-
-       /* secret register by aptina */
-       /* period_60Hz (B) MSB */
-       mt9t112_mcu_write(ret, client, VAR8(18, 302), 0x00);
-
-       /* FD Mode */
-       mt9t112_mcu_write(ret, client, VAR8(8, 2), 0x10);
-
-       /* Stat_min */
-       mt9t112_mcu_write(ret, client, VAR8(8, 9), 0x02);
-
-       /* Stat_max */
-       mt9t112_mcu_write(ret, client, VAR8(8, 10), 0x03);
-
-       /* Min_amplitude */
-       mt9t112_mcu_write(ret, client, VAR8(8, 12), 0x0A);
-
-       /* RX FIFO Watermark (A) */
-       mt9t112_mcu_write(ret, client, VAR(18, 70), 0x0014);
-
-       /* RX FIFO Watermark (B) */
-       mt9t112_mcu_write(ret, client, VAR(18, 142), 0x0014);
-
-       /* MCLK: 16MHz
-        * PCLK: 73MHz
-        * CorePixCLK: 36.5 MHz
-        */
-       mt9t112_mcu_write(ret, client, VAR8(18, 0x0044), 133);
-       mt9t112_mcu_write(ret, client, VAR8(18, 0x0045), 110);
-       mt9t112_mcu_write(ret, client, VAR8(18, 0x008c), 130);
-       mt9t112_mcu_write(ret, client, VAR8(18, 0x008d), 108);
-
-       mt9t112_mcu_write(ret, client, VAR8(18, 0x00A5), 27);
-       mt9t112_mcu_write(ret, client, VAR8(18, 0x00a6), 30);
-       mt9t112_mcu_write(ret, client, VAR8(18, 0x00a7), 32);
-       mt9t112_mcu_write(ret, client, VAR8(18, 0x00a8), 35);
-
-       return ret;
-}
-
-static int mt9t112_auto_focus_setting(const struct i2c_client *client)
-{
-       int ret;
-
-       mt9t112_mcu_write(ret, client, VAR(12, 13),     0x000F);
-       mt9t112_mcu_write(ret, client, VAR(12, 23),     0x0F0F);
-       mt9t112_mcu_write(ret, client, VAR8(1, 0),      0x06);
-
-       mt9t112_reg_write(ret, client, 0x0614, 0x0000);
-
-       mt9t112_mcu_write(ret, client, VAR8(1, 0),      0x05);
-       mt9t112_mcu_write(ret, client, VAR8(12, 2),     0x02);
-       mt9t112_mcu_write(ret, client, VAR(12, 3),      0x0002);
-       mt9t112_mcu_write(ret, client, VAR(17, 3),      0x8001);
-       mt9t112_mcu_write(ret, client, VAR(17, 11),     0x0025);
-       mt9t112_mcu_write(ret, client, VAR(17, 13),     0x0193);
-       mt9t112_mcu_write(ret, client, VAR8(17, 33),    0x18);
-       mt9t112_mcu_write(ret, client, VAR8(1, 0),      0x05);
-
-       return ret;
-}
-
-static int mt9t112_auto_focus_trigger(const struct i2c_client *client)
-{
-       int ret;
-
-       mt9t112_mcu_write(ret, client, VAR8(12, 25), 0x01);
-
-       return ret;
-}
-
-static int mt9t112_init_camera(const struct i2c_client *client)
-{
-       int ret;
-
-       ECHECKER(ret, mt9t112_reset(client));
-
-       ECHECKER(ret, mt9t112_init_pll(client));
-
-       ECHECKER(ret, mt9t112_init_setting(client));
-
-       ECHECKER(ret, mt9t112_auto_focus_setting(client));
-
-       mt9t112_reg_mask_set(ret, client, 0x0018, 0x0004, 0);
-
-       /* Analog setting B */
-       mt9t112_reg_write(ret, client, 0x3084, 0x2409);
-       mt9t112_reg_write(ret, client, 0x3092, 0x0A49);
-       mt9t112_reg_write(ret, client, 0x3094, 0x4949);
-       mt9t112_reg_write(ret, client, 0x3096, 0x4950);
-
-       /*
-        * Disable adaptive clock
-        * PRI_A_CONFIG_JPEG_OB_TX_CONTROL_VAR
-        * PRI_B_CONFIG_JPEG_OB_TX_CONTROL_VAR
-        */
-       mt9t112_mcu_write(ret, client, VAR(26, 160), 0x0A2E);
-       mt9t112_mcu_write(ret, client, VAR(27, 160), 0x0A2E);
-
-       /* Configure STatus in Status_before_length Format and enable header */
-       /* PRI_B_CONFIG_JPEG_OB_TX_CONTROL_VAR */
-       mt9t112_mcu_write(ret, client, VAR(27, 144), 0x0CB4);
-
-       /* Enable JPEG in context B */
-       /* PRI_B_CONFIG_JPEG_OB_TX_CONTROL_VAR */
-       mt9t112_mcu_write(ret, client, VAR8(27, 142), 0x01);
-
-       /* Disable Dac_TXLO */
-       mt9t112_reg_write(ret, client, 0x316C, 0x350F);
-
-       /* Set max slew rates */
-       mt9t112_reg_write(ret, client, 0x1E, 0x777);
-
-       return ret;
-}
-
-/************************************************************************
-                       v4l2_subdev_core_ops
-************************************************************************/
-static int mt9t112_g_chip_ident(struct v4l2_subdev *sd,
-                               struct v4l2_dbg_chip_ident *id)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9t112_priv *priv = to_mt9t112(client);
-
-       id->ident    = priv->model;
-       id->revision = 0;
-
-       return 0;
-}
-
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-static int mt9t112_g_register(struct v4l2_subdev *sd,
-                             struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       int                ret;
-
-       reg->size = 2;
-       mt9t112_reg_read(ret, client, reg->reg);
-
-       reg->val = (__u64)ret;
-
-       return 0;
-}
-
-static int mt9t112_s_register(struct v4l2_subdev *sd,
-                             struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       int ret;
-
-       mt9t112_reg_write(ret, client, reg->reg, reg->val);
-
-       return ret;
-}
-#endif
-
-static struct v4l2_subdev_core_ops mt9t112_subdev_core_ops = {
-       .g_chip_ident   = mt9t112_g_chip_ident,
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-       .g_register     = mt9t112_g_register,
-       .s_register     = mt9t112_s_register,
-#endif
-};
-
-
-/************************************************************************
-                       v4l2_subdev_video_ops
-************************************************************************/
-static int mt9t112_s_stream(struct v4l2_subdev *sd, int enable)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9t112_priv *priv = to_mt9t112(client);
-       int ret = 0;
-
-       if (!enable) {
-               /* FIXME
-                *
-                * If user selected large output size,
-                * and used it long time,
-                * mt9t112 camera will be very warm.
-                *
-                * But current driver can not stop mt9t112 camera.
-                * So, set small size here to solve this problem.
-                */
-               mt9t112_set_a_frame_size(client, VGA_WIDTH, VGA_HEIGHT);
-               return ret;
-       }
-
-       if (!(priv->flags & INIT_DONE)) {
-               u16 param = PCLK_RISING & priv->flags ? 0x0001 : 0x0000;
-
-               ECHECKER(ret, mt9t112_init_camera(client));
-
-               /* Invert PCLK (Data sampled on falling edge of pixclk) */
-               mt9t112_reg_write(ret, client, 0x3C20, param);
-
-               mdelay(5);
-
-               priv->flags |= INIT_DONE;
-       }
-
-       mt9t112_mcu_write(ret, client, VAR(26, 7), priv->format->fmt);
-       mt9t112_mcu_write(ret, client, VAR(26, 9), priv->format->order);
-       mt9t112_mcu_write(ret, client, VAR8(1, 0), 0x06);
-
-       mt9t112_set_a_frame_size(client,
-                                priv->frame.width,
-                                priv->frame.height);
-
-       ECHECKER(ret, mt9t112_auto_focus_trigger(client));
-
-       dev_dbg(&client->dev, "format : %d\n", priv->format->code);
-       dev_dbg(&client->dev, "size   : %d x %d\n",
-               priv->frame.width,
-               priv->frame.height);
-
-       CLOCK_INFO(client, EXT_CLOCK);
-
-       return ret;
-}
-
-static int mt9t112_set_params(struct mt9t112_priv *priv,
-                             const struct v4l2_rect *rect,
-                             enum v4l2_mbus_pixelcode code)
-{
-       int i;
-
-       /*
-        * get color format
-        */
-       for (i = 0; i < ARRAY_SIZE(mt9t112_cfmts); i++)
-               if (mt9t112_cfmts[i].code == code)
-                       break;
-
-       if (i == ARRAY_SIZE(mt9t112_cfmts))
-               return -EINVAL;
-
-       priv->frame  = *rect;
-
-       /*
-        * frame size check
-        */
-       mt9t112_frame_check(&priv->frame.width, &priv->frame.height,
-                           &priv->frame.left, &priv->frame.top);
-
-       priv->format = mt9t112_cfmts + i;
-
-       return 0;
-}
-
-static int mt9t112_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
-{
-       a->bounds.left                  = 0;
-       a->bounds.top                   = 0;
-       a->bounds.width                 = MAX_WIDTH;
-       a->bounds.height                = MAX_HEIGHT;
-       a->defrect.left                 = 0;
-       a->defrect.top                  = 0;
-       a->defrect.width                = VGA_WIDTH;
-       a->defrect.height               = VGA_HEIGHT;
-       a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-       a->pixelaspect.numerator        = 1;
-       a->pixelaspect.denominator      = 1;
-
-       return 0;
-}
-
-static int mt9t112_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9t112_priv *priv = to_mt9t112(client);
-
-       a->c    = priv->frame;
-       a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-
-       return 0;
-}
-
-static int mt9t112_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9t112_priv *priv = to_mt9t112(client);
-       struct v4l2_rect *rect = &a->c;
-
-       return mt9t112_set_params(priv, rect, priv->format->code);
-}
-
-static int mt9t112_g_fmt(struct v4l2_subdev *sd,
-                        struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9t112_priv *priv = to_mt9t112(client);
-
-       mf->width       = priv->frame.width;
-       mf->height      = priv->frame.height;
-       mf->colorspace  = priv->format->colorspace;
-       mf->code        = priv->format->code;
-       mf->field       = V4L2_FIELD_NONE;
-
-       return 0;
-}
-
-static int mt9t112_s_fmt(struct v4l2_subdev *sd,
-                        struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9t112_priv *priv = to_mt9t112(client);
-       struct v4l2_rect rect = {
-               .width = mf->width,
-               .height = mf->height,
-               .left = priv->frame.left,
-               .top = priv->frame.top,
-       };
-       int ret;
-
-       ret = mt9t112_set_params(priv, &rect, mf->code);
-
-       if (!ret)
-               mf->colorspace = priv->format->colorspace;
-
-       return ret;
-}
-
-static int mt9t112_try_fmt(struct v4l2_subdev *sd,
-                          struct v4l2_mbus_framefmt *mf)
-{
-       unsigned int top, left;
-       int i;
-
-       for (i = 0; i < ARRAY_SIZE(mt9t112_cfmts); i++)
-               if (mt9t112_cfmts[i].code == mf->code)
-                       break;
-
-       if (i == ARRAY_SIZE(mt9t112_cfmts)) {
-               mf->code = V4L2_MBUS_FMT_UYVY8_2X8;
-               mf->colorspace = V4L2_COLORSPACE_JPEG;
-       } else {
-               mf->colorspace  = mt9t112_cfmts[i].colorspace;
-       }
-
-       mt9t112_frame_check(&mf->width, &mf->height, &left, &top);
-
-       mf->field = V4L2_FIELD_NONE;
-
-       return 0;
-}
-
-static int mt9t112_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                          enum v4l2_mbus_pixelcode *code)
-{
-       if (index >= ARRAY_SIZE(mt9t112_cfmts))
-               return -EINVAL;
-
-       *code = mt9t112_cfmts[index].code;
-
-       return 0;
-}
-
-static int mt9t112_g_mbus_config(struct v4l2_subdev *sd,
-                                struct v4l2_mbus_config *cfg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-
-       cfg->flags = V4L2_MBUS_MASTER | V4L2_MBUS_VSYNC_ACTIVE_HIGH |
-               V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_DATA_ACTIVE_HIGH |
-               V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_PCLK_SAMPLE_FALLING;
-       cfg->type = V4L2_MBUS_PARALLEL;
-       cfg->flags = soc_camera_apply_board_flags(icl, cfg);
-
-       return 0;
-}
-
-static int mt9t112_s_mbus_config(struct v4l2_subdev *sd,
-                                const struct v4l2_mbus_config *cfg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-       struct mt9t112_priv *priv = to_mt9t112(client);
-
-       if (soc_camera_apply_board_flags(icl, cfg) & V4L2_MBUS_PCLK_SAMPLE_RISING)
-               priv->flags |= PCLK_RISING;
-
-       return 0;
-}
-
-static struct v4l2_subdev_video_ops mt9t112_subdev_video_ops = {
-       .s_stream       = mt9t112_s_stream,
-       .g_mbus_fmt     = mt9t112_g_fmt,
-       .s_mbus_fmt     = mt9t112_s_fmt,
-       .try_mbus_fmt   = mt9t112_try_fmt,
-       .cropcap        = mt9t112_cropcap,
-       .g_crop         = mt9t112_g_crop,
-       .s_crop         = mt9t112_s_crop,
-       .enum_mbus_fmt  = mt9t112_enum_fmt,
-       .g_mbus_config  = mt9t112_g_mbus_config,
-       .s_mbus_config  = mt9t112_s_mbus_config,
-};
-
-/************************************************************************
-                       i2c driver
-************************************************************************/
-static struct v4l2_subdev_ops mt9t112_subdev_ops = {
-       .core   = &mt9t112_subdev_core_ops,
-       .video  = &mt9t112_subdev_video_ops,
-};
-
-static int mt9t112_camera_probe(struct i2c_client *client)
-{
-       struct mt9t112_priv *priv = to_mt9t112(client);
-       const char          *devname;
-       int                  chipid;
-
-       /*
-        * check and show chip ID
-        */
-       mt9t112_reg_read(chipid, client, 0x0000);
-
-       switch (chipid) {
-       case 0x2680:
-               devname = "mt9t111";
-               priv->model = V4L2_IDENT_MT9T111;
-               break;
-       case 0x2682:
-               devname = "mt9t112";
-               priv->model = V4L2_IDENT_MT9T112;
-               break;
-       default:
-               dev_err(&client->dev, "Product ID error %04x\n", chipid);
-               return -ENODEV;
-       }
-
-       dev_info(&client->dev, "%s chip ID %04x\n", devname, chipid);
-
-       return 0;
-}
-
-static int mt9t112_probe(struct i2c_client *client,
-                        const struct i2c_device_id *did)
-{
-       struct mt9t112_priv *priv;
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-       struct v4l2_rect rect = {
-               .width = VGA_WIDTH,
-               .height = VGA_HEIGHT,
-               .left = (MAX_WIDTH - VGA_WIDTH) / 2,
-               .top = (MAX_HEIGHT - VGA_HEIGHT) / 2,
-       };
-       int ret;
-
-       if (!icl || !icl->priv) {
-               dev_err(&client->dev, "mt9t112: missing platform data!\n");
-               return -EINVAL;
-       }
-
-       priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-       if (!priv)
-               return -ENOMEM;
-
-       priv->info = icl->priv;
-
-       v4l2_i2c_subdev_init(&priv->subdev, client, &mt9t112_subdev_ops);
-
-       ret = mt9t112_camera_probe(client);
-       if (ret) {
-               kfree(priv);
-               return ret;
-       }
-
-       /* Cannot fail: using the default supported pixel code */
-       mt9t112_set_params(priv, &rect, V4L2_MBUS_FMT_UYVY8_2X8);
-
-       return ret;
-}
-
-static int mt9t112_remove(struct i2c_client *client)
-{
-       struct mt9t112_priv *priv = to_mt9t112(client);
-
-       kfree(priv);
-       return 0;
-}
-
-static const struct i2c_device_id mt9t112_id[] = {
-       { "mt9t112", 0 },
-       { }
-};
-MODULE_DEVICE_TABLE(i2c, mt9t112_id);
-
-static struct i2c_driver mt9t112_i2c_driver = {
-       .driver = {
-               .name = "mt9t112",
-       },
-       .probe    = mt9t112_probe,
-       .remove   = mt9t112_remove,
-       .id_table = mt9t112_id,
-};
-
-module_i2c_driver(mt9t112_i2c_driver);
-
-MODULE_DESCRIPTION("SoC Camera driver for mt9t112");
-MODULE_AUTHOR("Kuninori Morimoto");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/video/mt9v022.c b/drivers/media/video/mt9v022.c
deleted file mode 100644 (file)
index 7247924..0000000
+++ /dev/null
@@ -1,879 +0,0 @@
-/*
- * Driver for MT9V022 CMOS Image Sensor from Micron
- *
- * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include <linux/videodev2.h>
-#include <linux/slab.h>
-#include <linux/i2c.h>
-#include <linux/delay.h>
-#include <linux/log2.h>
-#include <linux/module.h>
-
-#include <media/soc_camera.h>
-#include <media/soc_mediabus.h>
-#include <media/v4l2-subdev.h>
-#include <media/v4l2-chip-ident.h>
-#include <media/v4l2-ctrls.h>
-
-/*
- * mt9v022 i2c address 0x48, 0x4c, 0x58, 0x5c
- * The platform has to define struct i2c_board_info objects and link to them
- * from struct soc_camera_link
- */
-
-static char *sensor_type;
-module_param(sensor_type, charp, S_IRUGO);
-MODULE_PARM_DESC(sensor_type, "Sensor type: \"colour\" or \"monochrome\"");
-
-/* mt9v022 selected register addresses */
-#define MT9V022_CHIP_VERSION           0x00
-#define MT9V022_COLUMN_START           0x01
-#define MT9V022_ROW_START              0x02
-#define MT9V022_WINDOW_HEIGHT          0x03
-#define MT9V022_WINDOW_WIDTH           0x04
-#define MT9V022_HORIZONTAL_BLANKING    0x05
-#define MT9V022_VERTICAL_BLANKING      0x06
-#define MT9V022_CHIP_CONTROL           0x07
-#define MT9V022_SHUTTER_WIDTH1         0x08
-#define MT9V022_SHUTTER_WIDTH2         0x09
-#define MT9V022_SHUTTER_WIDTH_CTRL     0x0a
-#define MT9V022_TOTAL_SHUTTER_WIDTH    0x0b
-#define MT9V022_RESET                  0x0c
-#define MT9V022_READ_MODE              0x0d
-#define MT9V022_MONITOR_MODE           0x0e
-#define MT9V022_PIXEL_OPERATION_MODE   0x0f
-#define MT9V022_LED_OUT_CONTROL                0x1b
-#define MT9V022_ADC_MODE_CONTROL       0x1c
-#define MT9V022_ANALOG_GAIN            0x35
-#define MT9V022_BLACK_LEVEL_CALIB_CTRL 0x47
-#define MT9V022_PIXCLK_FV_LV           0x74
-#define MT9V022_DIGITAL_TEST_PATTERN   0x7f
-#define MT9V022_AEC_AGC_ENABLE         0xAF
-#define MT9V022_MAX_TOTAL_SHUTTER_WIDTH        0xBD
-
-/* Progressive scan, master, defaults */
-#define MT9V022_CHIP_CONTROL_DEFAULT   0x188
-
-#define MT9V022_MAX_WIDTH              752
-#define MT9V022_MAX_HEIGHT             480
-#define MT9V022_MIN_WIDTH              48
-#define MT9V022_MIN_HEIGHT             32
-#define MT9V022_COLUMN_SKIP            1
-#define MT9V022_ROW_SKIP               4
-
-/* MT9V022 has only one fixed colorspace per pixelcode */
-struct mt9v022_datafmt {
-       enum v4l2_mbus_pixelcode        code;
-       enum v4l2_colorspace            colorspace;
-};
-
-/* Find a data format by a pixel code in an array */
-static const struct mt9v022_datafmt *mt9v022_find_datafmt(
-       enum v4l2_mbus_pixelcode code, const struct mt9v022_datafmt *fmt,
-       int n)
-{
-       int i;
-       for (i = 0; i < n; i++)
-               if (fmt[i].code == code)
-                       return fmt + i;
-
-       return NULL;
-}
-
-static const struct mt9v022_datafmt mt9v022_colour_fmts[] = {
-       /*
-        * Order important: first natively supported,
-        * second supported with a GPIO extender
-        */
-       {V4L2_MBUS_FMT_SBGGR10_1X10, V4L2_COLORSPACE_SRGB},
-       {V4L2_MBUS_FMT_SBGGR8_1X8, V4L2_COLORSPACE_SRGB},
-};
-
-static const struct mt9v022_datafmt mt9v022_monochrome_fmts[] = {
-       /* Order important - see above */
-       {V4L2_MBUS_FMT_Y10_1X10, V4L2_COLORSPACE_JPEG},
-       {V4L2_MBUS_FMT_Y8_1X8, V4L2_COLORSPACE_JPEG},
-};
-
-struct mt9v022 {
-       struct v4l2_subdev subdev;
-       struct v4l2_ctrl_handler hdl;
-       struct {
-               /* exposure/auto-exposure cluster */
-               struct v4l2_ctrl *autoexposure;
-               struct v4l2_ctrl *exposure;
-       };
-       struct {
-               /* gain/auto-gain cluster */
-               struct v4l2_ctrl *autogain;
-               struct v4l2_ctrl *gain;
-       };
-       struct v4l2_rect rect;  /* Sensor window */
-       const struct mt9v022_datafmt *fmt;
-       const struct mt9v022_datafmt *fmts;
-       int num_fmts;
-       int model;      /* V4L2_IDENT_MT9V022* codes from v4l2-chip-ident.h */
-       u16 chip_control;
-       unsigned short y_skip_top;      /* Lines to skip at the top */
-};
-
-static struct mt9v022 *to_mt9v022(const struct i2c_client *client)
-{
-       return container_of(i2c_get_clientdata(client), struct mt9v022, subdev);
-}
-
-static int reg_read(struct i2c_client *client, const u8 reg)
-{
-       return i2c_smbus_read_word_swapped(client, reg);
-}
-
-static int reg_write(struct i2c_client *client, const u8 reg,
-                    const u16 data)
-{
-       return i2c_smbus_write_word_swapped(client, reg, data);
-}
-
-static int reg_set(struct i2c_client *client, const u8 reg,
-                  const u16 data)
-{
-       int ret;
-
-       ret = reg_read(client, reg);
-       if (ret < 0)
-               return ret;
-       return reg_write(client, reg, ret | data);
-}
-
-static int reg_clear(struct i2c_client *client, const u8 reg,
-                    const u16 data)
-{
-       int ret;
-
-       ret = reg_read(client, reg);
-       if (ret < 0)
-               return ret;
-       return reg_write(client, reg, ret & ~data);
-}
-
-static int mt9v022_init(struct i2c_client *client)
-{
-       struct mt9v022 *mt9v022 = to_mt9v022(client);
-       int ret;
-
-       /*
-        * Almost the default mode: master, parallel, simultaneous, and an
-        * undocumented bit 0x200, which is present in table 7, but not in 8,
-        * plus snapshot mode to disable scan for now
-        */
-       mt9v022->chip_control |= 0x10;
-       ret = reg_write(client, MT9V022_CHIP_CONTROL, mt9v022->chip_control);
-       if (!ret)
-               ret = reg_write(client, MT9V022_READ_MODE, 0x300);
-
-       /* All defaults */
-       if (!ret)
-               /* AEC, AGC on */
-               ret = reg_set(client, MT9V022_AEC_AGC_ENABLE, 0x3);
-       if (!ret)
-               ret = reg_write(client, MT9V022_ANALOG_GAIN, 16);
-       if (!ret)
-               ret = reg_write(client, MT9V022_TOTAL_SHUTTER_WIDTH, 480);
-       if (!ret)
-               ret = reg_write(client, MT9V022_MAX_TOTAL_SHUTTER_WIDTH, 480);
-       if (!ret)
-               /* default - auto */
-               ret = reg_clear(client, MT9V022_BLACK_LEVEL_CALIB_CTRL, 1);
-       if (!ret)
-               ret = reg_write(client, MT9V022_DIGITAL_TEST_PATTERN, 0);
-       if (!ret)
-               return v4l2_ctrl_handler_setup(&mt9v022->hdl);
-
-       return ret;
-}
-
-static int mt9v022_s_stream(struct v4l2_subdev *sd, int enable)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9v022 *mt9v022 = to_mt9v022(client);
-
-       if (enable)
-               /* Switch to master "normal" mode */
-               mt9v022->chip_control &= ~0x10;
-       else
-               /* Switch to snapshot mode */
-               mt9v022->chip_control |= 0x10;
-
-       if (reg_write(client, MT9V022_CHIP_CONTROL, mt9v022->chip_control) < 0)
-               return -EIO;
-       return 0;
-}
-
-static int mt9v022_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9v022 *mt9v022 = to_mt9v022(client);
-       struct v4l2_rect rect = a->c;
-       int ret;
-
-       /* Bayer format - even size lengths */
-       if (mt9v022->fmts == mt9v022_colour_fmts) {
-               rect.width      = ALIGN(rect.width, 2);
-               rect.height     = ALIGN(rect.height, 2);
-               /* Let the user play with the starting pixel */
-       }
-
-       soc_camera_limit_side(&rect.left, &rect.width,
-                    MT9V022_COLUMN_SKIP, MT9V022_MIN_WIDTH, MT9V022_MAX_WIDTH);
-
-       soc_camera_limit_side(&rect.top, &rect.height,
-                    MT9V022_ROW_SKIP, MT9V022_MIN_HEIGHT, MT9V022_MAX_HEIGHT);
-
-       /* Like in example app. Contradicts the datasheet though */
-       ret = reg_read(client, MT9V022_AEC_AGC_ENABLE);
-       if (ret >= 0) {
-               if (ret & 1) /* Autoexposure */
-                       ret = reg_write(client, MT9V022_MAX_TOTAL_SHUTTER_WIDTH,
-                                       rect.height + mt9v022->y_skip_top + 43);
-               else
-                       ret = reg_write(client, MT9V022_TOTAL_SHUTTER_WIDTH,
-                                       rect.height + mt9v022->y_skip_top + 43);
-       }
-       /* Setup frame format: defaults apart from width and height */
-       if (!ret)
-               ret = reg_write(client, MT9V022_COLUMN_START, rect.left);
-       if (!ret)
-               ret = reg_write(client, MT9V022_ROW_START, rect.top);
-       if (!ret)
-               /*
-                * Default 94, Phytec driver says:
-                * "width + horizontal blank >= 660"
-                */
-               ret = reg_write(client, MT9V022_HORIZONTAL_BLANKING,
-                               rect.width > 660 - 43 ? 43 :
-                               660 - rect.width);
-       if (!ret)
-               ret = reg_write(client, MT9V022_VERTICAL_BLANKING, 45);
-       if (!ret)
-               ret = reg_write(client, MT9V022_WINDOW_WIDTH, rect.width);
-       if (!ret)
-               ret = reg_write(client, MT9V022_WINDOW_HEIGHT,
-                               rect.height + mt9v022->y_skip_top);
-
-       if (ret < 0)
-               return ret;
-
-       dev_dbg(&client->dev, "Frame %dx%d pixel\n", rect.width, rect.height);
-
-       mt9v022->rect = rect;
-
-       return 0;
-}
-
-static int mt9v022_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9v022 *mt9v022 = to_mt9v022(client);
-
-       a->c    = mt9v022->rect;
-       a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-
-       return 0;
-}
-
-static int mt9v022_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
-{
-       a->bounds.left                  = MT9V022_COLUMN_SKIP;
-       a->bounds.top                   = MT9V022_ROW_SKIP;
-       a->bounds.width                 = MT9V022_MAX_WIDTH;
-       a->bounds.height                = MT9V022_MAX_HEIGHT;
-       a->defrect                      = a->bounds;
-       a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-       a->pixelaspect.numerator        = 1;
-       a->pixelaspect.denominator      = 1;
-
-       return 0;
-}
-
-static int mt9v022_g_fmt(struct v4l2_subdev *sd,
-                        struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9v022 *mt9v022 = to_mt9v022(client);
-
-       mf->width       = mt9v022->rect.width;
-       mf->height      = mt9v022->rect.height;
-       mf->code        = mt9v022->fmt->code;
-       mf->colorspace  = mt9v022->fmt->colorspace;
-       mf->field       = V4L2_FIELD_NONE;
-
-       return 0;
-}
-
-static int mt9v022_s_fmt(struct v4l2_subdev *sd,
-                        struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9v022 *mt9v022 = to_mt9v022(client);
-       struct v4l2_crop a = {
-               .c = {
-                       .left   = mt9v022->rect.left,
-                       .top    = mt9v022->rect.top,
-                       .width  = mf->width,
-                       .height = mf->height,
-               },
-       };
-       int ret;
-
-       /*
-        * The caller provides a supported format, as verified per call to
-        * .try_mbus_fmt(), datawidth is from our supported format list
-        */
-       switch (mf->code) {
-       case V4L2_MBUS_FMT_Y8_1X8:
-       case V4L2_MBUS_FMT_Y10_1X10:
-               if (mt9v022->model != V4L2_IDENT_MT9V022IX7ATM)
-                       return -EINVAL;
-               break;
-       case V4L2_MBUS_FMT_SBGGR8_1X8:
-       case V4L2_MBUS_FMT_SBGGR10_1X10:
-               if (mt9v022->model != V4L2_IDENT_MT9V022IX7ATC)
-                       return -EINVAL;
-               break;
-       default:
-               return -EINVAL;
-       }
-
-       /* No support for scaling on this camera, just crop. */
-       ret = mt9v022_s_crop(sd, &a);
-       if (!ret) {
-               mf->width       = mt9v022->rect.width;
-               mf->height      = mt9v022->rect.height;
-               mt9v022->fmt    = mt9v022_find_datafmt(mf->code,
-                                       mt9v022->fmts, mt9v022->num_fmts);
-               mf->colorspace  = mt9v022->fmt->colorspace;
-       }
-
-       return ret;
-}
-
-static int mt9v022_try_fmt(struct v4l2_subdev *sd,
-                          struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9v022 *mt9v022 = to_mt9v022(client);
-       const struct mt9v022_datafmt *fmt;
-       int align = mf->code == V4L2_MBUS_FMT_SBGGR8_1X8 ||
-               mf->code == V4L2_MBUS_FMT_SBGGR10_1X10;
-
-       v4l_bound_align_image(&mf->width, MT9V022_MIN_WIDTH,
-               MT9V022_MAX_WIDTH, align,
-               &mf->height, MT9V022_MIN_HEIGHT + mt9v022->y_skip_top,
-               MT9V022_MAX_HEIGHT + mt9v022->y_skip_top, align, 0);
-
-       fmt = mt9v022_find_datafmt(mf->code, mt9v022->fmts,
-                                  mt9v022->num_fmts);
-       if (!fmt) {
-               fmt = mt9v022->fmt;
-               mf->code = fmt->code;
-       }
-
-       mf->colorspace  = fmt->colorspace;
-
-       return 0;
-}
-
-static int mt9v022_g_chip_ident(struct v4l2_subdev *sd,
-                               struct v4l2_dbg_chip_ident *id)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9v022 *mt9v022 = to_mt9v022(client);
-
-       if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
-               return -EINVAL;
-
-       if (id->match.addr != client->addr)
-               return -ENODEV;
-
-       id->ident       = mt9v022->model;
-       id->revision    = 0;
-
-       return 0;
-}
-
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-static int mt9v022_g_register(struct v4l2_subdev *sd,
-                             struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-
-       if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
-               return -EINVAL;
-
-       if (reg->match.addr != client->addr)
-               return -ENODEV;
-
-       reg->size = 2;
-       reg->val = reg_read(client, reg->reg);
-
-       if (reg->val > 0xffff)
-               return -EIO;
-
-       return 0;
-}
-
-static int mt9v022_s_register(struct v4l2_subdev *sd,
-                             struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-
-       if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
-               return -EINVAL;
-
-       if (reg->match.addr != client->addr)
-               return -ENODEV;
-
-       if (reg_write(client, reg->reg, reg->val) < 0)
-               return -EIO;
-
-       return 0;
-}
-#endif
-
-static int mt9v022_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
-{
-       struct mt9v022 *mt9v022 = container_of(ctrl->handler,
-                                              struct mt9v022, hdl);
-       struct v4l2_subdev *sd = &mt9v022->subdev;
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct v4l2_ctrl *gain = mt9v022->gain;
-       struct v4l2_ctrl *exp = mt9v022->exposure;
-       unsigned long range;
-       int data;
-
-       switch (ctrl->id) {
-       case V4L2_CID_AUTOGAIN:
-               data = reg_read(client, MT9V022_ANALOG_GAIN);
-               if (data < 0)
-                       return -EIO;
-
-               range = gain->maximum - gain->minimum;
-               gain->val = ((data - 16) * range + 24) / 48 + gain->minimum;
-               return 0;
-       case V4L2_CID_EXPOSURE_AUTO:
-               data = reg_read(client, MT9V022_TOTAL_SHUTTER_WIDTH);
-               if (data < 0)
-                       return -EIO;
-
-               range = exp->maximum - exp->minimum;
-               exp->val = ((data - 1) * range + 239) / 479 + exp->minimum;
-               return 0;
-       }
-       return -EINVAL;
-}
-
-static int mt9v022_s_ctrl(struct v4l2_ctrl *ctrl)
-{
-       struct mt9v022 *mt9v022 = container_of(ctrl->handler,
-                                              struct mt9v022, hdl);
-       struct v4l2_subdev *sd = &mt9v022->subdev;
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       int data;
-
-       switch (ctrl->id) {
-       case V4L2_CID_VFLIP:
-               if (ctrl->val)
-                       data = reg_set(client, MT9V022_READ_MODE, 0x10);
-               else
-                       data = reg_clear(client, MT9V022_READ_MODE, 0x10);
-               if (data < 0)
-                       return -EIO;
-               return 0;
-       case V4L2_CID_HFLIP:
-               if (ctrl->val)
-                       data = reg_set(client, MT9V022_READ_MODE, 0x20);
-               else
-                       data = reg_clear(client, MT9V022_READ_MODE, 0x20);
-               if (data < 0)
-                       return -EIO;
-               return 0;
-       case V4L2_CID_AUTOGAIN:
-               if (ctrl->val) {
-                       if (reg_set(client, MT9V022_AEC_AGC_ENABLE, 0x2) < 0)
-                               return -EIO;
-               } else {
-                       struct v4l2_ctrl *gain = mt9v022->gain;
-                       /* mt9v022 has minimum == default */
-                       unsigned long range = gain->maximum - gain->minimum;
-                       /* Valid values 16 to 64, 32 to 64 must be even. */
-                       unsigned long gain_val = ((gain->val - gain->minimum) *
-                                             48 + range / 2) / range + 16;
-
-                       if (gain_val >= 32)
-                               gain_val &= ~1;
-
-                       /*
-                        * The user wants to set gain manually, hope, she
-                        * knows, what she's doing... Switch AGC off.
-                        */
-                       if (reg_clear(client, MT9V022_AEC_AGC_ENABLE, 0x2) < 0)
-                               return -EIO;
-
-                       dev_dbg(&client->dev, "Setting gain from %d to %lu\n",
-                               reg_read(client, MT9V022_ANALOG_GAIN), gain_val);
-                       if (reg_write(client, MT9V022_ANALOG_GAIN, gain_val) < 0)
-                               return -EIO;
-               }
-               return 0;
-       case V4L2_CID_EXPOSURE_AUTO:
-               if (ctrl->val == V4L2_EXPOSURE_AUTO) {
-                       data = reg_set(client, MT9V022_AEC_AGC_ENABLE, 0x1);
-               } else {
-                       struct v4l2_ctrl *exp = mt9v022->exposure;
-                       unsigned long range = exp->maximum - exp->minimum;
-                       unsigned long shutter = ((exp->val - exp->minimum) *
-                                       479 + range / 2) / range + 1;
-
-                       /*
-                        * The user wants to set shutter width manually, hope,
-                        * she knows, what she's doing... Switch AEC off.
-                        */
-                       data = reg_clear(client, MT9V022_AEC_AGC_ENABLE, 0x1);
-                       if (data < 0)
-                               return -EIO;
-                       dev_dbg(&client->dev, "Shutter width from %d to %lu\n",
-                                       reg_read(client, MT9V022_TOTAL_SHUTTER_WIDTH),
-                                       shutter);
-                       if (reg_write(client, MT9V022_TOTAL_SHUTTER_WIDTH,
-                                               shutter) < 0)
-                               return -EIO;
-               }
-               return 0;
-       }
-       return -EINVAL;
-}
-
-/*
- * Interface active, can use i2c. If it fails, it can indeed mean, that
- * this wasn't our capture interface, so, we wait for the right one
- */
-static int mt9v022_video_probe(struct i2c_client *client)
-{
-       struct mt9v022 *mt9v022 = to_mt9v022(client);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-       s32 data;
-       int ret;
-       unsigned long flags;
-
-       /* Read out the chip version register */
-       data = reg_read(client, MT9V022_CHIP_VERSION);
-
-       /* must be 0x1311 or 0x1313 */
-       if (data != 0x1311 && data != 0x1313) {
-               ret = -ENODEV;
-               dev_info(&client->dev, "No MT9V022 found, ID register 0x%x\n",
-                        data);
-               goto ei2c;
-       }
-
-       /* Soft reset */
-       ret = reg_write(client, MT9V022_RESET, 1);
-       if (ret < 0)
-               goto ei2c;
-       /* 15 clock cycles */
-       udelay(200);
-       if (reg_read(client, MT9V022_RESET)) {
-               dev_err(&client->dev, "Resetting MT9V022 failed!\n");
-               if (ret > 0)
-                       ret = -EIO;
-               goto ei2c;
-       }
-
-       /* Set monochrome or colour sensor type */
-       if (sensor_type && (!strcmp("colour", sensor_type) ||
-                           !strcmp("color", sensor_type))) {
-               ret = reg_write(client, MT9V022_PIXEL_OPERATION_MODE, 4 | 0x11);
-               mt9v022->model = V4L2_IDENT_MT9V022IX7ATC;
-               mt9v022->fmts = mt9v022_colour_fmts;
-       } else {
-               ret = reg_write(client, MT9V022_PIXEL_OPERATION_MODE, 0x11);
-               mt9v022->model = V4L2_IDENT_MT9V022IX7ATM;
-               mt9v022->fmts = mt9v022_monochrome_fmts;
-       }
-
-       if (ret < 0)
-               goto ei2c;
-
-       mt9v022->num_fmts = 0;
-
-       /*
-        * This is a 10bit sensor, so by default we only allow 10bit.
-        * The platform may support different bus widths due to
-        * different routing of the data lines.
-        */
-       if (icl->query_bus_param)
-               flags = icl->query_bus_param(icl);
-       else
-               flags = SOCAM_DATAWIDTH_10;
-
-       if (flags & SOCAM_DATAWIDTH_10)
-               mt9v022->num_fmts++;
-       else
-               mt9v022->fmts++;
-
-       if (flags & SOCAM_DATAWIDTH_8)
-               mt9v022->num_fmts++;
-
-       mt9v022->fmt = &mt9v022->fmts[0];
-
-       dev_info(&client->dev, "Detected a MT9V022 chip ID %x, %s sensor\n",
-                data, mt9v022->model == V4L2_IDENT_MT9V022IX7ATM ?
-                "monochrome" : "colour");
-
-       ret = mt9v022_init(client);
-       if (ret < 0)
-               dev_err(&client->dev, "Failed to initialise the camera\n");
-
-ei2c:
-       return ret;
-}
-
-static int mt9v022_g_skip_top_lines(struct v4l2_subdev *sd, u32 *lines)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9v022 *mt9v022 = to_mt9v022(client);
-
-       *lines = mt9v022->y_skip_top;
-
-       return 0;
-}
-
-static const struct v4l2_ctrl_ops mt9v022_ctrl_ops = {
-       .g_volatile_ctrl = mt9v022_g_volatile_ctrl,
-       .s_ctrl = mt9v022_s_ctrl,
-};
-
-static struct v4l2_subdev_core_ops mt9v022_subdev_core_ops = {
-       .g_chip_ident   = mt9v022_g_chip_ident,
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-       .g_register     = mt9v022_g_register,
-       .s_register     = mt9v022_s_register,
-#endif
-};
-
-static int mt9v022_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                           enum v4l2_mbus_pixelcode *code)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct mt9v022 *mt9v022 = to_mt9v022(client);
-
-       if (index >= mt9v022->num_fmts)
-               return -EINVAL;
-
-       *code = mt9v022->fmts[index].code;
-       return 0;
-}
-
-static int mt9v022_g_mbus_config(struct v4l2_subdev *sd,
-                               struct v4l2_mbus_config *cfg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-
-       cfg->flags = V4L2_MBUS_MASTER | V4L2_MBUS_SLAVE |
-               V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_PCLK_SAMPLE_FALLING |
-               V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_HSYNC_ACTIVE_LOW |
-               V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_LOW |
-               V4L2_MBUS_DATA_ACTIVE_HIGH;
-       cfg->type = V4L2_MBUS_PARALLEL;
-       cfg->flags = soc_camera_apply_board_flags(icl, cfg);
-
-       return 0;
-}
-
-static int mt9v022_s_mbus_config(struct v4l2_subdev *sd,
-                                const struct v4l2_mbus_config *cfg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-       struct mt9v022 *mt9v022 = to_mt9v022(client);
-       unsigned long flags = soc_camera_apply_board_flags(icl, cfg);
-       unsigned int bps = soc_mbus_get_fmtdesc(mt9v022->fmt->code)->bits_per_sample;
-       int ret;
-       u16 pixclk = 0;
-
-       if (icl->set_bus_param) {
-               ret = icl->set_bus_param(icl, 1 << (bps - 1));
-               if (ret)
-                       return ret;
-       } else if (bps != 10) {
-               /*
-                * Without board specific bus width settings we only support the
-                * sensors native bus width
-                */
-               return -EINVAL;
-       }
-
-       if (flags & V4L2_MBUS_PCLK_SAMPLE_FALLING)
-               pixclk |= 0x10;
-
-       if (!(flags & V4L2_MBUS_HSYNC_ACTIVE_HIGH))
-               pixclk |= 0x1;
-
-       if (!(flags & V4L2_MBUS_VSYNC_ACTIVE_HIGH))
-               pixclk |= 0x2;
-
-       ret = reg_write(client, MT9V022_PIXCLK_FV_LV, pixclk);
-       if (ret < 0)
-               return ret;
-
-       if (!(flags & V4L2_MBUS_MASTER))
-               mt9v022->chip_control &= ~0x8;
-
-       ret = reg_write(client, MT9V022_CHIP_CONTROL, mt9v022->chip_control);
-       if (ret < 0)
-               return ret;
-
-       dev_dbg(&client->dev, "Calculated pixclk 0x%x, chip control 0x%x\n",
-               pixclk, mt9v022->chip_control);
-
-       return 0;
-}
-
-static struct v4l2_subdev_video_ops mt9v022_subdev_video_ops = {
-       .s_stream       = mt9v022_s_stream,
-       .s_mbus_fmt     = mt9v022_s_fmt,
-       .g_mbus_fmt     = mt9v022_g_fmt,
-       .try_mbus_fmt   = mt9v022_try_fmt,
-       .s_crop         = mt9v022_s_crop,
-       .g_crop         = mt9v022_g_crop,
-       .cropcap        = mt9v022_cropcap,
-       .enum_mbus_fmt  = mt9v022_enum_fmt,
-       .g_mbus_config  = mt9v022_g_mbus_config,
-       .s_mbus_config  = mt9v022_s_mbus_config,
-};
-
-static struct v4l2_subdev_sensor_ops mt9v022_subdev_sensor_ops = {
-       .g_skip_top_lines       = mt9v022_g_skip_top_lines,
-};
-
-static struct v4l2_subdev_ops mt9v022_subdev_ops = {
-       .core   = &mt9v022_subdev_core_ops,
-       .video  = &mt9v022_subdev_video_ops,
-       .sensor = &mt9v022_subdev_sensor_ops,
-};
-
-static int mt9v022_probe(struct i2c_client *client,
-                        const struct i2c_device_id *did)
-{
-       struct mt9v022 *mt9v022;
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-       struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
-       int ret;
-
-       if (!icl) {
-               dev_err(&client->dev, "MT9V022 driver needs platform data\n");
-               return -EINVAL;
-       }
-
-       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
-               dev_warn(&adapter->dev,
-                        "I2C-Adapter doesn't support I2C_FUNC_SMBUS_WORD\n");
-               return -EIO;
-       }
-
-       mt9v022 = kzalloc(sizeof(struct mt9v022), GFP_KERNEL);
-       if (!mt9v022)
-               return -ENOMEM;
-
-       v4l2_i2c_subdev_init(&mt9v022->subdev, client, &mt9v022_subdev_ops);
-       v4l2_ctrl_handler_init(&mt9v022->hdl, 6);
-       v4l2_ctrl_new_std(&mt9v022->hdl, &mt9v022_ctrl_ops,
-                       V4L2_CID_VFLIP, 0, 1, 1, 0);
-       v4l2_ctrl_new_std(&mt9v022->hdl, &mt9v022_ctrl_ops,
-                       V4L2_CID_HFLIP, 0, 1, 1, 0);
-       mt9v022->autogain = v4l2_ctrl_new_std(&mt9v022->hdl, &mt9v022_ctrl_ops,
-                       V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
-       mt9v022->gain = v4l2_ctrl_new_std(&mt9v022->hdl, &mt9v022_ctrl_ops,
-                       V4L2_CID_GAIN, 0, 127, 1, 64);
-
-       /*
-        * Simulated autoexposure. If enabled, we calculate shutter width
-        * ourselves in the driver based on vertical blanking and frame width
-        */
-       mt9v022->autoexposure = v4l2_ctrl_new_std_menu(&mt9v022->hdl,
-                       &mt9v022_ctrl_ops, V4L2_CID_EXPOSURE_AUTO, 1, 0,
-                       V4L2_EXPOSURE_AUTO);
-       mt9v022->exposure = v4l2_ctrl_new_std(&mt9v022->hdl, &mt9v022_ctrl_ops,
-                       V4L2_CID_EXPOSURE, 1, 255, 1, 255);
-
-       mt9v022->subdev.ctrl_handler = &mt9v022->hdl;
-       if (mt9v022->hdl.error) {
-               int err = mt9v022->hdl.error;
-
-               kfree(mt9v022);
-               return err;
-       }
-       v4l2_ctrl_auto_cluster(2, &mt9v022->autoexposure,
-                               V4L2_EXPOSURE_MANUAL, true);
-       v4l2_ctrl_auto_cluster(2, &mt9v022->autogain, 0, true);
-
-       mt9v022->chip_control = MT9V022_CHIP_CONTROL_DEFAULT;
-
-       /*
-        * MT9V022 _really_ corrupts the first read out line.
-        * TODO: verify on i.MX31
-        */
-       mt9v022->y_skip_top     = 1;
-       mt9v022->rect.left      = MT9V022_COLUMN_SKIP;
-       mt9v022->rect.top       = MT9V022_ROW_SKIP;
-       mt9v022->rect.width     = MT9V022_MAX_WIDTH;
-       mt9v022->rect.height    = MT9V022_MAX_HEIGHT;
-
-       ret = mt9v022_video_probe(client);
-       if (ret) {
-               v4l2_ctrl_handler_free(&mt9v022->hdl);
-               kfree(mt9v022);
-       }
-
-       return ret;
-}
-
-static int mt9v022_remove(struct i2c_client *client)
-{
-       struct mt9v022 *mt9v022 = to_mt9v022(client);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-
-       v4l2_device_unregister_subdev(&mt9v022->subdev);
-       if (icl->free_bus)
-               icl->free_bus(icl);
-       v4l2_ctrl_handler_free(&mt9v022->hdl);
-       kfree(mt9v022);
-
-       return 0;
-}
-static const struct i2c_device_id mt9v022_id[] = {
-       { "mt9v022", 0 },
-       { }
-};
-MODULE_DEVICE_TABLE(i2c, mt9v022_id);
-
-static struct i2c_driver mt9v022_i2c_driver = {
-       .driver = {
-               .name = "mt9v022",
-       },
-       .probe          = mt9v022_probe,
-       .remove         = mt9v022_remove,
-       .id_table       = mt9v022_id,
-};
-
-module_i2c_driver(mt9v022_i2c_driver);
-
-MODULE_DESCRIPTION("Micron MT9V022 Camera driver");
-MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>");
-MODULE_LICENSE("GPL");
diff --git a/drivers/media/video/ov2640.c b/drivers/media/video/ov2640.c
deleted file mode 100644 (file)
index 7c44d1f..0000000
+++ /dev/null
@@ -1,1108 +0,0 @@
-/*
- * ov2640 Camera Driver
- *
- * Copyright (C) 2010 Alberto Panizzo <maramaopercheseimorto@gmail.com>
- *
- * Based on ov772x, ov9640 drivers and previous non merged implementations.
- *
- * Copyright 2005-2009 Freescale Semiconductor, Inc. All Rights Reserved.
- * Copyright (C) 2006, OmniVision
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/i2c.h>
-#include <linux/slab.h>
-#include <linux/delay.h>
-#include <linux/v4l2-mediabus.h>
-#include <linux/videodev2.h>
-
-#include <media/soc_camera.h>
-#include <media/v4l2-chip-ident.h>
-#include <media/v4l2-subdev.h>
-#include <media/v4l2-ctrls.h>
-
-#define VAL_SET(x, mask, rshift, lshift)  \
-               ((((x) >> rshift) & mask) << lshift)
-/*
- * DSP registers
- * register offset for BANK_SEL == BANK_SEL_DSP
- */
-#define R_BYPASS    0x05 /* Bypass DSP */
-#define   R_BYPASS_DSP_BYPAS    0x01 /* Bypass DSP, sensor out directly */
-#define   R_BYPASS_USE_DSP      0x00 /* Use the internal DSP */
-#define QS          0x44 /* Quantization Scale Factor */
-#define CTRLI       0x50
-#define   CTRLI_LP_DP           0x80
-#define   CTRLI_ROUND           0x40
-#define   CTRLI_V_DIV_SET(x)    VAL_SET(x, 0x3, 0, 3)
-#define   CTRLI_H_DIV_SET(x)    VAL_SET(x, 0x3, 0, 0)
-#define HSIZE       0x51 /* H_SIZE[7:0] (real/4) */
-#define   HSIZE_SET(x)          VAL_SET(x, 0xFF, 2, 0)
-#define VSIZE       0x52 /* V_SIZE[7:0] (real/4) */
-#define   VSIZE_SET(x)          VAL_SET(x, 0xFF, 2, 0)
-#define XOFFL       0x53 /* OFFSET_X[7:0] */
-#define   XOFFL_SET(x)          VAL_SET(x, 0xFF, 0, 0)
-#define YOFFL       0x54 /* OFFSET_Y[7:0] */
-#define   YOFFL_SET(x)          VAL_SET(x, 0xFF, 0, 0)
-#define VHYX        0x55 /* Offset and size completion */
-#define   VHYX_VSIZE_SET(x)     VAL_SET(x, 0x1, (8+2), 7)
-#define   VHYX_HSIZE_SET(x)     VAL_SET(x, 0x1, (8+2), 3)
-#define   VHYX_YOFF_SET(x)      VAL_SET(x, 0x3, 8, 4)
-#define   VHYX_XOFF_SET(x)      VAL_SET(x, 0x3, 8, 0)
-#define DPRP        0x56
-#define TEST        0x57 /* Horizontal size completion */
-#define   TEST_HSIZE_SET(x)     VAL_SET(x, 0x1, (9+2), 7)
-#define ZMOW        0x5A /* Zoom: Out Width  OUTW[7:0] (real/4) */
-#define   ZMOW_OUTW_SET(x)      VAL_SET(x, 0xFF, 2, 0)
-#define ZMOH        0x5B /* Zoom: Out Height OUTH[7:0] (real/4) */
-#define   ZMOH_OUTH_SET(x)      VAL_SET(x, 0xFF, 2, 0)
-#define ZMHH        0x5C /* Zoom: Speed and H&W completion */
-#define   ZMHH_ZSPEED_SET(x)    VAL_SET(x, 0x0F, 0, 4)
-#define   ZMHH_OUTH_SET(x)      VAL_SET(x, 0x1, (8+2), 2)
-#define   ZMHH_OUTW_SET(x)      VAL_SET(x, 0x3, (8+2), 0)
-#define BPADDR      0x7C /* SDE Indirect Register Access: Address */
-#define BPDATA      0x7D /* SDE Indirect Register Access: Data */
-#define CTRL2       0x86 /* DSP Module enable 2 */
-#define   CTRL2_DCW_EN          0x20
-#define   CTRL2_SDE_EN          0x10
-#define   CTRL2_UV_ADJ_EN       0x08
-#define   CTRL2_UV_AVG_EN       0x04
-#define   CTRL2_CMX_EN          0x01
-#define CTRL3       0x87 /* DSP Module enable 3 */
-#define   CTRL3_BPC_EN          0x80
-#define   CTRL3_WPC_EN          0x40
-#define SIZEL       0x8C /* Image Size Completion */
-#define   SIZEL_HSIZE8_11_SET(x) VAL_SET(x, 0x1, 11, 6)
-#define   SIZEL_HSIZE8_SET(x)    VAL_SET(x, 0x7, 0, 3)
-#define   SIZEL_VSIZE8_SET(x)    VAL_SET(x, 0x7, 0, 0)
-#define HSIZE8      0xC0 /* Image Horizontal Size HSIZE[10:3] */
-#define   HSIZE8_SET(x)         VAL_SET(x, 0xFF, 3, 0)
-#define VSIZE8      0xC1 /* Image Vertical Size VSIZE[10:3] */
-#define   VSIZE8_SET(x)         VAL_SET(x, 0xFF, 3, 0)
-#define CTRL0       0xC2 /* DSP Module enable 0 */
-#define   CTRL0_AEC_EN       0x80
-#define   CTRL0_AEC_SEL      0x40
-#define   CTRL0_STAT_SEL     0x20
-#define   CTRL0_VFIRST       0x10
-#define   CTRL0_YUV422       0x08
-#define   CTRL0_YUV_EN       0x04
-#define   CTRL0_RGB_EN       0x02
-#define   CTRL0_RAW_EN       0x01
-#define CTRL1       0xC3 /* DSP Module enable 1 */
-#define   CTRL1_CIP          0x80
-#define   CTRL1_DMY          0x40
-#define   CTRL1_RAW_GMA      0x20
-#define   CTRL1_DG           0x10
-#define   CTRL1_AWB          0x08
-#define   CTRL1_AWB_GAIN     0x04
-#define   CTRL1_LENC         0x02
-#define   CTRL1_PRE          0x01
-#define R_DVP_SP    0xD3 /* DVP output speed control */
-#define   R_DVP_SP_AUTO_MODE 0x80
-#define   R_DVP_SP_DVP_MASK  0x3F /* DVP PCLK = sysclk (48)/[6:0] (YUV0);
-                                  *          = sysclk (48)/(2*[6:0]) (RAW);*/
-#define IMAGE_MODE  0xDA /* Image Output Format Select */
-#define   IMAGE_MODE_Y8_DVP_EN   0x40
-#define   IMAGE_MODE_JPEG_EN     0x10
-#define   IMAGE_MODE_YUV422      0x00
-#define   IMAGE_MODE_RAW10       0x04 /* (DVP) */
-#define   IMAGE_MODE_RGB565      0x08
-#define   IMAGE_MODE_HREF_VSYNC  0x02 /* HREF timing select in DVP JPEG output
-                                      * mode (0 for HREF is same as sensor) */
-#define   IMAGE_MODE_LBYTE_FIRST 0x01 /* Byte swap enable for DVP
-                                      *    1: Low byte first UYVY (C2[4] =0)
-                                      *        VYUY (C2[4] =1)
-                                      *    0: High byte first YUYV (C2[4]=0)
-                                      *        YVYU (C2[4] = 1) */
-#define RESET       0xE0 /* Reset */
-#define   RESET_MICROC       0x40
-#define   RESET_SCCB         0x20
-#define   RESET_JPEG         0x10
-#define   RESET_DVP          0x04
-#define   RESET_IPU          0x02
-#define   RESET_CIF          0x01
-#define REGED       0xED /* Register ED */
-#define   REGED_CLK_OUT_DIS  0x10
-#define MS_SP       0xF0 /* SCCB Master Speed */
-#define SS_ID       0xF7 /* SCCB Slave ID */
-#define SS_CTRL     0xF8 /* SCCB Slave Control */
-#define   SS_CTRL_ADD_AUTO_INC  0x20
-#define   SS_CTRL_EN            0x08
-#define   SS_CTRL_DELAY_CLK     0x04
-#define   SS_CTRL_ACC_EN        0x02
-#define   SS_CTRL_SEN_PASS_THR  0x01
-#define MC_BIST     0xF9 /* Microcontroller misc register */
-#define   MC_BIST_RESET           0x80 /* Microcontroller Reset */
-#define   MC_BIST_BOOT_ROM_SEL    0x40
-#define   MC_BIST_12KB_SEL        0x20
-#define   MC_BIST_12KB_MASK       0x30
-#define   MC_BIST_512KB_SEL       0x08
-#define   MC_BIST_512KB_MASK      0x0C
-#define   MC_BIST_BUSY_BIT_R      0x02
-#define   MC_BIST_MC_RES_ONE_SH_W 0x02
-#define   MC_BIST_LAUNCH          0x01
-#define BANK_SEL    0xFF /* Register Bank Select */
-#define   BANK_SEL_DSP     0x00
-#define   BANK_SEL_SENS    0x01
-
-/*
- * Sensor registers
- * register offset for BANK_SEL == BANK_SEL_SENS
- */
-#define GAIN        0x00 /* AGC - Gain control gain setting */
-#define COM1        0x03 /* Common control 1 */
-#define   COM1_1_DUMMY_FR          0x40
-#define   COM1_3_DUMMY_FR          0x80
-#define   COM1_7_DUMMY_FR          0xC0
-#define   COM1_VWIN_LSB_UXGA       0x0F
-#define   COM1_VWIN_LSB_SVGA       0x0A
-#define   COM1_VWIN_LSB_CIF        0x06
-#define REG04       0x04 /* Register 04 */
-#define   REG04_DEF             0x20 /* Always set */
-#define   REG04_HFLIP_IMG       0x80 /* Horizontal mirror image ON/OFF */
-#define   REG04_VFLIP_IMG       0x40 /* Vertical flip image ON/OFF */
-#define   REG04_VREF_EN         0x10
-#define   REG04_HREF_EN         0x08
-#define   REG04_AEC_SET(x)      VAL_SET(x, 0x3, 0, 0)
-#define REG08       0x08 /* Frame Exposure One-pin Control Pre-charge Row Num */
-#define COM2        0x09 /* Common control 2 */
-#define   COM2_SOFT_SLEEP_MODE  0x10 /* Soft sleep mode */
-                                    /* Output drive capability */
-#define   COM2_OCAP_Nx_SET(N)   (((N) - 1) & 0x03) /* N = [1x .. 4x] */
-#define PID         0x0A /* Product ID Number MSB */
-#define VER         0x0B /* Product ID Number LSB */
-#define COM3        0x0C /* Common control 3 */
-#define   COM3_BAND_50H        0x04 /* 0 For Banding at 60H */
-#define   COM3_BAND_AUTO       0x02 /* Auto Banding */
-#define   COM3_SING_FR_SNAPSH  0x01 /* 0 For enable live video output after the
-                                    * snapshot sequence*/
-#define AEC         0x10 /* AEC[9:2] Exposure Value */
-#define CLKRC       0x11 /* Internal clock */
-#define   CLKRC_EN             0x80
-#define   CLKRC_DIV_SET(x)     (((x) - 1) & 0x1F) /* CLK = XVCLK/(x) */
-#define COM7        0x12 /* Common control 7 */
-#define   COM7_SRST            0x80 /* Initiates system reset. All registers are
-                                    * set to factory default values after which
-                                    * the chip resumes normal operation */
-#define   COM7_RES_UXGA        0x00 /* Resolution selectors for UXGA */
-#define   COM7_RES_SVGA        0x40 /* SVGA */
-#define   COM7_RES_CIF         0x20 /* CIF */
-#define   COM7_ZOOM_EN         0x04 /* Enable Zoom mode */
-#define   COM7_COLOR_BAR_TEST  0x02 /* Enable Color Bar Test Pattern */
-#define COM8        0x13 /* Common control 8 */
-#define   COM8_DEF             0xC0 /* Banding filter ON/OFF */
-#define   COM8_BNDF_EN         0x20 /* Banding filter ON/OFF */
-#define   COM8_AGC_EN          0x04 /* AGC Auto/Manual control selection */
-#define   COM8_AEC_EN          0x01 /* Auto/Manual Exposure control */
-#define COM9        0x14 /* Common control 9
-                         * Automatic gain ceiling - maximum AGC value [7:5]*/
-#define   COM9_AGC_GAIN_2x     0x00 /* 000 :   2x */
-#define   COM9_AGC_GAIN_4x     0x20 /* 001 :   4x */
-#define   COM9_AGC_GAIN_8x     0x40 /* 010 :   8x */
-#define   COM9_AGC_GAIN_16x    0x60 /* 011 :  16x */
-#define   COM9_AGC_GAIN_32x    0x80 /* 100 :  32x */
-#define   COM9_AGC_GAIN_64x    0xA0 /* 101 :  64x */
-#define   COM9_AGC_GAIN_128x   0xC0 /* 110 : 128x */
-#define COM10       0x15 /* Common control 10 */
-#define   COM10_PCLK_HREF      0x20 /* PCLK output qualified by HREF */
-#define   COM10_PCLK_RISE      0x10 /* Data is updated at the rising edge of
-                                    * PCLK (user can latch data at the next
-                                    * falling edge of PCLK).
-                                    * 0 otherwise. */
-#define   COM10_HREF_INV       0x08 /* Invert HREF polarity:
-                                    * HREF negative for valid data*/
-#define   COM10_VSINC_INV      0x02 /* Invert VSYNC polarity */
-#define HSTART      0x17 /* Horizontal Window start MSB 8 bit */
-#define HEND        0x18 /* Horizontal Window end MSB 8 bit */
-#define VSTART      0x19 /* Vertical Window start MSB 8 bit */
-#define VEND        0x1A /* Vertical Window end MSB 8 bit */
-#define MIDH        0x1C /* Manufacturer ID byte - high */
-#define MIDL        0x1D /* Manufacturer ID byte - low  */
-#define AEW         0x24 /* AGC/AEC - Stable operating region (upper limit) */
-#define AEB         0x25 /* AGC/AEC - Stable operating region (lower limit) */
-#define VV          0x26 /* AGC/AEC Fast mode operating region */
-#define   VV_HIGH_TH_SET(x)      VAL_SET(x, 0xF, 0, 4)
-#define   VV_LOW_TH_SET(x)       VAL_SET(x, 0xF, 0, 0)
-#define REG2A       0x2A /* Dummy pixel insert MSB */
-#define FRARL       0x2B /* Dummy pixel insert LSB */
-#define ADDVFL      0x2D /* LSB of insert dummy lines in Vertical direction */
-#define ADDVFH      0x2E /* MSB of insert dummy lines in Vertical direction */
-#define YAVG        0x2F /* Y/G Channel Average value */
-#define REG32       0x32 /* Common Control 32 */
-#define   REG32_PCLK_DIV_2    0x80 /* PCLK freq divided by 2 */
-#define   REG32_PCLK_DIV_4    0xC0 /* PCLK freq divided by 4 */
-#define ARCOM2      0x34 /* Zoom: Horizontal start point */
-#define REG45       0x45 /* Register 45 */
-#define FLL         0x46 /* Frame Length Adjustment LSBs */
-#define FLH         0x47 /* Frame Length Adjustment MSBs */
-#define COM19       0x48 /* Zoom: Vertical start point */
-#define ZOOMS       0x49 /* Zoom: Vertical start point */
-#define COM22       0x4B /* Flash light control */
-#define COM25       0x4E /* For Banding operations */
-#define BD50        0x4F /* 50Hz Banding AEC 8 LSBs */
-#define BD60        0x50 /* 60Hz Banding AEC 8 LSBs */
-#define REG5D       0x5D /* AVGsel[7:0],   16-zone average weight option */
-#define REG5E       0x5E /* AVGsel[15:8],  16-zone average weight option */
-#define REG5F       0x5F /* AVGsel[23:16], 16-zone average weight option */
-#define REG60       0x60 /* AVGsel[31:24], 16-zone average weight option */
-#define HISTO_LOW   0x61 /* Histogram Algorithm Low Level */
-#define HISTO_HIGH  0x62 /* Histogram Algorithm High Level */
-
-/*
- * ID
- */
-#define MANUFACTURER_ID        0x7FA2
-#define PID_OV2640     0x2642
-#define VERSION(pid, ver) ((pid << 8) | (ver & 0xFF))
-
-/*
- * Struct
- */
-struct regval_list {
-       u8 reg_num;
-       u8 value;
-};
-
-/* Supported resolutions */
-enum ov2640_width {
-       W_QCIF  = 176,
-       W_QVGA  = 320,
-       W_CIF   = 352,
-       W_VGA   = 640,
-       W_SVGA  = 800,
-       W_XGA   = 1024,
-       W_SXGA  = 1280,
-       W_UXGA  = 1600,
-};
-
-enum ov2640_height {
-       H_QCIF  = 144,
-       H_QVGA  = 240,
-       H_CIF   = 288,
-       H_VGA   = 480,
-       H_SVGA  = 600,
-       H_XGA   = 768,
-       H_SXGA  = 1024,
-       H_UXGA  = 1200,
-};
-
-struct ov2640_win_size {
-       char                            *name;
-       enum ov2640_width               width;
-       enum ov2640_height              height;
-       const struct regval_list        *regs;
-};
-
-
-struct ov2640_priv {
-       struct v4l2_subdev              subdev;
-       struct v4l2_ctrl_handler        hdl;
-       enum v4l2_mbus_pixelcode        cfmt_code;
-       const struct ov2640_win_size    *win;
-       int                             model;
-};
-
-/*
- * Registers settings
- */
-
-#define ENDMARKER { 0xff, 0xff }
-
-static const struct regval_list ov2640_init_regs[] = {
-       { BANK_SEL, BANK_SEL_DSP },
-       { 0x2c,   0xff },
-       { 0x2e,   0xdf },
-       { BANK_SEL, BANK_SEL_SENS },
-       { 0x3c,   0x32 },
-       { CLKRC, CLKRC_DIV_SET(1) },
-       { COM2, COM2_OCAP_Nx_SET(3) },
-       { REG04, REG04_DEF | REG04_HREF_EN },
-       { COM8,  COM8_DEF | COM8_BNDF_EN | COM8_AGC_EN | COM8_AEC_EN },
-       { COM9, COM9_AGC_GAIN_8x | 0x08},
-       { 0x2c,   0x0c },
-       { 0x33,   0x78 },
-       { 0x3a,   0x33 },
-       { 0x3b,   0xfb },
-       { 0x3e,   0x00 },
-       { 0x43,   0x11 },
-       { 0x16,   0x10 },
-       { 0x39,   0x02 },
-       { 0x35,   0x88 },
-       { 0x22,   0x0a },
-       { 0x37,   0x40 },
-       { 0x23,   0x00 },
-       { ARCOM2, 0xa0 },
-       { 0x06,   0x02 },
-       { 0x06,   0x88 },
-       { 0x07,   0xc0 },
-       { 0x0d,   0xb7 },
-       { 0x0e,   0x01 },
-       { 0x4c,   0x00 },
-       { 0x4a,   0x81 },
-       { 0x21,   0x99 },
-       { AEW,    0x40 },
-       { AEB,    0x38 },
-       { VV,     VV_HIGH_TH_SET(0x08) | VV_LOW_TH_SET(0x02) },
-       { 0x5c,   0x00 },
-       { 0x63,   0x00 },
-       { FLL,    0x22 },
-       { COM3,   0x38 | COM3_BAND_AUTO },
-       { REG5D,  0x55 },
-       { REG5E,  0x7d },
-       { REG5F,  0x7d },
-       { REG60,  0x55 },
-       { HISTO_LOW,   0x70 },
-       { HISTO_HIGH,  0x80 },
-       { 0x7c,   0x05 },
-       { 0x20,   0x80 },
-       { 0x28,   0x30 },
-       { 0x6c,   0x00 },
-       { 0x6d,   0x80 },
-       { 0x6e,   0x00 },
-       { 0x70,   0x02 },
-       { 0x71,   0x94 },
-       { 0x73,   0xc1 },
-       { 0x3d,   0x34 },
-       { COM7, COM7_RES_UXGA | COM7_ZOOM_EN },
-       { 0x5a,   0x57 },
-       { BD50,   0xbb },
-       { BD60,   0x9c },
-       { BANK_SEL, BANK_SEL_DSP },
-       { 0xe5,   0x7f },
-       { MC_BIST, MC_BIST_RESET | MC_BIST_BOOT_ROM_SEL },
-       { 0x41,   0x24 },
-       { RESET, RESET_JPEG | RESET_DVP },
-       { 0x76,   0xff },
-       { 0x33,   0xa0 },
-       { 0x42,   0x20 },
-       { 0x43,   0x18 },
-       { 0x4c,   0x00 },
-       { CTRL3, CTRL3_BPC_EN | CTRL3_WPC_EN | 0x10 },
-       { 0x88,   0x3f },
-       { 0xd7,   0x03 },
-       { 0xd9,   0x10 },
-       { R_DVP_SP , R_DVP_SP_AUTO_MODE | 0x2 },
-       { 0xc8,   0x08 },
-       { 0xc9,   0x80 },
-       { BPADDR, 0x00 },
-       { BPDATA, 0x00 },
-       { BPADDR, 0x03 },
-       { BPDATA, 0x48 },
-       { BPDATA, 0x48 },
-       { BPADDR, 0x08 },
-       { BPDATA, 0x20 },
-       { BPDATA, 0x10 },
-       { BPDATA, 0x0e },
-       { 0x90,   0x00 },
-       { 0x91,   0x0e },
-       { 0x91,   0x1a },
-       { 0x91,   0x31 },
-       { 0x91,   0x5a },
-       { 0x91,   0x69 },
-       { 0x91,   0x75 },
-       { 0x91,   0x7e },
-       { 0x91,   0x88 },
-       { 0x91,   0x8f },
-       { 0x91,   0x96 },
-       { 0x91,   0xa3 },
-       { 0x91,   0xaf },
-       { 0x91,   0xc4 },
-       { 0x91,   0xd7 },
-       { 0x91,   0xe8 },
-       { 0x91,   0x20 },
-       { 0x92,   0x00 },
-       { 0x93,   0x06 },
-       { 0x93,   0xe3 },
-       { 0x93,   0x03 },
-       { 0x93,   0x03 },
-       { 0x93,   0x00 },
-       { 0x93,   0x02 },
-       { 0x93,   0x00 },
-       { 0x93,   0x00 },
-       { 0x93,   0x00 },
-       { 0x93,   0x00 },
-       { 0x93,   0x00 },
-       { 0x93,   0x00 },
-       { 0x93,   0x00 },
-       { 0x96,   0x00 },
-       { 0x97,   0x08 },
-       { 0x97,   0x19 },
-       { 0x97,   0x02 },
-       { 0x97,   0x0c },
-       { 0x97,   0x24 },
-       { 0x97,   0x30 },
-       { 0x97,   0x28 },
-       { 0x97,   0x26 },
-       { 0x97,   0x02 },
-       { 0x97,   0x98 },
-       { 0x97,   0x80 },
-       { 0x97,   0x00 },
-       { 0x97,   0x00 },
-       { 0xa4,   0x00 },
-       { 0xa8,   0x00 },
-       { 0xc5,   0x11 },
-       { 0xc6,   0x51 },
-       { 0xbf,   0x80 },
-       { 0xc7,   0x10 },
-       { 0xb6,   0x66 },
-       { 0xb8,   0xA5 },
-       { 0xb7,   0x64 },
-       { 0xb9,   0x7C },
-       { 0xb3,   0xaf },
-       { 0xb4,   0x97 },
-       { 0xb5,   0xFF },
-       { 0xb0,   0xC5 },
-       { 0xb1,   0x94 },
-       { 0xb2,   0x0f },
-       { 0xc4,   0x5c },
-       { 0xa6,   0x00 },
-       { 0xa7,   0x20 },
-       { 0xa7,   0xd8 },
-       { 0xa7,   0x1b },
-       { 0xa7,   0x31 },
-       { 0xa7,   0x00 },
-       { 0xa7,   0x18 },
-       { 0xa7,   0x20 },
-       { 0xa7,   0xd8 },
-       { 0xa7,   0x19 },
-       { 0xa7,   0x31 },
-       { 0xa7,   0x00 },
-       { 0xa7,   0x18 },
-       { 0xa7,   0x20 },
-       { 0xa7,   0xd8 },
-       { 0xa7,   0x19 },
-       { 0xa7,   0x31 },
-       { 0xa7,   0x00 },
-       { 0xa7,   0x18 },
-       { 0x7f,   0x00 },
-       { 0xe5,   0x1f },
-       { 0xe1,   0x77 },
-       { 0xdd,   0x7f },
-       { CTRL0,  CTRL0_YUV422 | CTRL0_YUV_EN | CTRL0_RGB_EN },
-       ENDMARKER,
-};
-
-/*
- * Register settings for window size
- * The preamble, setup the internal DSP to input an UXGA (1600x1200) image.
- * Then the different zooming configurations will setup the output image size.
- */
-static const struct regval_list ov2640_size_change_preamble_regs[] = {
-       { BANK_SEL, BANK_SEL_DSP },
-       { RESET, RESET_DVP },
-       { HSIZE8, HSIZE8_SET(W_UXGA) },
-       { VSIZE8, VSIZE8_SET(H_UXGA) },
-       { CTRL2, CTRL2_DCW_EN | CTRL2_SDE_EN |
-                CTRL2_UV_AVG_EN | CTRL2_CMX_EN | CTRL2_UV_ADJ_EN },
-       { HSIZE, HSIZE_SET(W_UXGA) },
-       { VSIZE, VSIZE_SET(H_UXGA) },
-       { XOFFL, XOFFL_SET(0) },
-       { YOFFL, YOFFL_SET(0) },
-       { VHYX, VHYX_HSIZE_SET(W_UXGA) | VHYX_VSIZE_SET(H_UXGA) |
-               VHYX_XOFF_SET(0) | VHYX_YOFF_SET(0)},
-       { TEST, TEST_HSIZE_SET(W_UXGA) },
-       ENDMARKER,
-};
-
-#define PER_SIZE_REG_SEQ(x, y, v_div, h_div, pclk_div) \
-       { CTRLI, CTRLI_LP_DP | CTRLI_V_DIV_SET(v_div) | \
-                CTRLI_H_DIV_SET(h_div)},               \
-       { ZMOW, ZMOW_OUTW_SET(x) },                     \
-       { ZMOH, ZMOH_OUTH_SET(y) },                     \
-       { ZMHH, ZMHH_OUTW_SET(x) | ZMHH_OUTH_SET(y) },  \
-       { R_DVP_SP, pclk_div },                         \
-       { RESET, 0x00}
-
-static const struct regval_list ov2640_qcif_regs[] = {
-       PER_SIZE_REG_SEQ(W_QCIF, H_QCIF, 3, 3, 4),
-       ENDMARKER,
-};
-
-static const struct regval_list ov2640_qvga_regs[] = {
-       PER_SIZE_REG_SEQ(W_QVGA, H_QVGA, 2, 2, 4),
-       ENDMARKER,
-};
-
-static const struct regval_list ov2640_cif_regs[] = {
-       PER_SIZE_REG_SEQ(W_CIF, H_CIF, 2, 2, 8),
-       ENDMARKER,
-};
-
-static const struct regval_list ov2640_vga_regs[] = {
-       PER_SIZE_REG_SEQ(W_VGA, H_VGA, 0, 0, 2),
-       ENDMARKER,
-};
-
-static const struct regval_list ov2640_svga_regs[] = {
-       PER_SIZE_REG_SEQ(W_SVGA, H_SVGA, 1, 1, 2),
-       ENDMARKER,
-};
-
-static const struct regval_list ov2640_xga_regs[] = {
-       PER_SIZE_REG_SEQ(W_XGA, H_XGA, 0, 0, 2),
-       { CTRLI,    0x00},
-       ENDMARKER,
-};
-
-static const struct regval_list ov2640_sxga_regs[] = {
-       PER_SIZE_REG_SEQ(W_SXGA, H_SXGA, 0, 0, 2),
-       { CTRLI,    0x00},
-       { R_DVP_SP, 2 | R_DVP_SP_AUTO_MODE },
-       ENDMARKER,
-};
-
-static const struct regval_list ov2640_uxga_regs[] = {
-       PER_SIZE_REG_SEQ(W_UXGA, H_UXGA, 0, 0, 0),
-       { CTRLI,    0x00},
-       { R_DVP_SP, 0 | R_DVP_SP_AUTO_MODE },
-       ENDMARKER,
-};
-
-#define OV2640_SIZE(n, w, h, r) \
-       {.name = n, .width = w , .height = h, .regs = r }
-
-static const struct ov2640_win_size ov2640_supported_win_sizes[] = {
-       OV2640_SIZE("QCIF", W_QCIF, H_QCIF, ov2640_qcif_regs),
-       OV2640_SIZE("QVGA", W_QVGA, H_QVGA, ov2640_qvga_regs),
-       OV2640_SIZE("CIF", W_CIF, H_CIF, ov2640_cif_regs),
-       OV2640_SIZE("VGA", W_VGA, H_VGA, ov2640_vga_regs),
-       OV2640_SIZE("SVGA", W_SVGA, H_SVGA, ov2640_svga_regs),
-       OV2640_SIZE("XGA", W_XGA, H_XGA, ov2640_xga_regs),
-       OV2640_SIZE("SXGA", W_SXGA, H_SXGA, ov2640_sxga_regs),
-       OV2640_SIZE("UXGA", W_UXGA, H_UXGA, ov2640_uxga_regs),
-};
-
-/*
- * Register settings for pixel formats
- */
-static const struct regval_list ov2640_format_change_preamble_regs[] = {
-       { BANK_SEL, BANK_SEL_DSP },
-       { R_BYPASS, R_BYPASS_USE_DSP },
-       ENDMARKER,
-};
-
-static const struct regval_list ov2640_yuv422_regs[] = {
-       { IMAGE_MODE, IMAGE_MODE_LBYTE_FIRST | IMAGE_MODE_YUV422 },
-       { 0xD7, 0x01 },
-       { 0x33, 0xa0 },
-       { 0xe1, 0x67 },
-       { RESET,  0x00 },
-       { R_BYPASS, R_BYPASS_USE_DSP },
-       ENDMARKER,
-};
-
-static const struct regval_list ov2640_rgb565_regs[] = {
-       { IMAGE_MODE, IMAGE_MODE_LBYTE_FIRST | IMAGE_MODE_RGB565 },
-       { 0xd7, 0x03 },
-       { RESET,  0x00 },
-       { R_BYPASS, R_BYPASS_USE_DSP },
-       ENDMARKER,
-};
-
-static enum v4l2_mbus_pixelcode ov2640_codes[] = {
-       V4L2_MBUS_FMT_UYVY8_2X8,
-       V4L2_MBUS_FMT_RGB565_2X8_LE,
-};
-
-/*
- * General functions
- */
-static struct ov2640_priv *to_ov2640(const struct i2c_client *client)
-{
-       return container_of(i2c_get_clientdata(client), struct ov2640_priv,
-                           subdev);
-}
-
-static int ov2640_write_array(struct i2c_client *client,
-                             const struct regval_list *vals)
-{
-       int ret;
-
-       while ((vals->reg_num != 0xff) || (vals->value != 0xff)) {
-               ret = i2c_smbus_write_byte_data(client,
-                                               vals->reg_num, vals->value);
-               dev_vdbg(&client->dev, "array: 0x%02x, 0x%02x",
-                        vals->reg_num, vals->value);
-
-               if (ret < 0)
-                       return ret;
-               vals++;
-       }
-       return 0;
-}
-
-static int ov2640_mask_set(struct i2c_client *client,
-                          u8  reg, u8  mask, u8  set)
-{
-       s32 val = i2c_smbus_read_byte_data(client, reg);
-       if (val < 0)
-               return val;
-
-       val &= ~mask;
-       val |= set & mask;
-
-       dev_vdbg(&client->dev, "masks: 0x%02x, 0x%02x", reg, val);
-
-       return i2c_smbus_write_byte_data(client, reg, val);
-}
-
-static int ov2640_reset(struct i2c_client *client)
-{
-       int ret;
-       const struct regval_list reset_seq[] = {
-               {BANK_SEL, BANK_SEL_SENS},
-               {COM7, COM7_SRST},
-               ENDMARKER,
-       };
-
-       ret = ov2640_write_array(client, reset_seq);
-       if (ret)
-               goto err;
-
-       msleep(5);
-err:
-       dev_dbg(&client->dev, "%s: (ret %d)", __func__, ret);
-       return ret;
-}
-
-/*
- * soc_camera_ops functions
- */
-static int ov2640_s_stream(struct v4l2_subdev *sd, int enable)
-{
-       return 0;
-}
-
-static int ov2640_s_ctrl(struct v4l2_ctrl *ctrl)
-{
-       struct v4l2_subdev *sd =
-               &container_of(ctrl->handler, struct ov2640_priv, hdl)->subdev;
-       struct i2c_client  *client = v4l2_get_subdevdata(sd);
-       u8 val;
-
-       switch (ctrl->id) {
-       case V4L2_CID_VFLIP:
-               val = ctrl->val ? REG04_VFLIP_IMG : 0x00;
-               return ov2640_mask_set(client, REG04, REG04_VFLIP_IMG, val);
-       case V4L2_CID_HFLIP:
-               val = ctrl->val ? REG04_HFLIP_IMG : 0x00;
-               return ov2640_mask_set(client, REG04, REG04_HFLIP_IMG, val);
-       }
-
-       return -EINVAL;
-}
-
-static int ov2640_g_chip_ident(struct v4l2_subdev *sd,
-                              struct v4l2_dbg_chip_ident *id)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct ov2640_priv *priv = to_ov2640(client);
-
-       id->ident    = priv->model;
-       id->revision = 0;
-
-       return 0;
-}
-
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-static int ov2640_g_register(struct v4l2_subdev *sd,
-                            struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       int ret;
-
-       reg->size = 1;
-       if (reg->reg > 0xff)
-               return -EINVAL;
-
-       ret = i2c_smbus_read_byte_data(client, reg->reg);
-       if (ret < 0)
-               return ret;
-
-       reg->val = ret;
-
-       return 0;
-}
-
-static int ov2640_s_register(struct v4l2_subdev *sd,
-                            struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-
-       if (reg->reg > 0xff ||
-           reg->val > 0xff)
-               return -EINVAL;
-
-       return i2c_smbus_write_byte_data(client, reg->reg, reg->val);
-}
-#endif
-
-/* Select the nearest higher resolution for capture */
-static const struct ov2640_win_size *ov2640_select_win(u32 *width, u32 *height)
-{
-       int i, default_size = ARRAY_SIZE(ov2640_supported_win_sizes) - 1;
-
-       for (i = 0; i < ARRAY_SIZE(ov2640_supported_win_sizes); i++) {
-               if (ov2640_supported_win_sizes[i].width  >= *width &&
-                   ov2640_supported_win_sizes[i].height >= *height) {
-                       *width = ov2640_supported_win_sizes[i].width;
-                       *height = ov2640_supported_win_sizes[i].height;
-                       return &ov2640_supported_win_sizes[i];
-               }
-       }
-
-       *width = ov2640_supported_win_sizes[default_size].width;
-       *height = ov2640_supported_win_sizes[default_size].height;
-       return &ov2640_supported_win_sizes[default_size];
-}
-
-static int ov2640_set_params(struct i2c_client *client, u32 *width, u32 *height,
-                            enum v4l2_mbus_pixelcode code)
-{
-       struct ov2640_priv       *priv = to_ov2640(client);
-       const struct regval_list *selected_cfmt_regs;
-       int ret;
-
-       /* select win */
-       priv->win = ov2640_select_win(width, height);
-
-       /* select format */
-       priv->cfmt_code = 0;
-       switch (code) {
-       case V4L2_MBUS_FMT_RGB565_2X8_LE:
-               dev_dbg(&client->dev, "%s: Selected cfmt RGB565", __func__);
-               selected_cfmt_regs = ov2640_rgb565_regs;
-               break;
-       default:
-       case V4L2_MBUS_FMT_UYVY8_2X8:
-               dev_dbg(&client->dev, "%s: Selected cfmt YUV422", __func__);
-               selected_cfmt_regs = ov2640_yuv422_regs;
-       }
-
-       /* reset hardware */
-       ov2640_reset(client);
-
-       /* initialize the sensor with default data */
-       dev_dbg(&client->dev, "%s: Init default", __func__);
-       ret = ov2640_write_array(client, ov2640_init_regs);
-       if (ret < 0)
-               goto err;
-
-       /* select preamble */
-       dev_dbg(&client->dev, "%s: Set size to %s", __func__, priv->win->name);
-       ret = ov2640_write_array(client, ov2640_size_change_preamble_regs);
-       if (ret < 0)
-               goto err;
-
-       /* set size win */
-       ret = ov2640_write_array(client, priv->win->regs);
-       if (ret < 0)
-               goto err;
-
-       /* cfmt preamble */
-       dev_dbg(&client->dev, "%s: Set cfmt", __func__);
-       ret = ov2640_write_array(client, ov2640_format_change_preamble_regs);
-       if (ret < 0)
-               goto err;
-
-       /* set cfmt */
-       ret = ov2640_write_array(client, selected_cfmt_regs);
-       if (ret < 0)
-               goto err;
-
-       priv->cfmt_code = code;
-       *width = priv->win->width;
-       *height = priv->win->height;
-
-       return 0;
-
-err:
-       dev_err(&client->dev, "%s: Error %d", __func__, ret);
-       ov2640_reset(client);
-       priv->win = NULL;
-
-       return ret;
-}
-
-static int ov2640_g_fmt(struct v4l2_subdev *sd,
-                       struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client  *client = v4l2_get_subdevdata(sd);
-       struct ov2640_priv *priv = to_ov2640(client);
-
-       if (!priv->win) {
-               u32 width = W_SVGA, height = H_SVGA;
-               priv->win = ov2640_select_win(&width, &height);
-               priv->cfmt_code = V4L2_MBUS_FMT_UYVY8_2X8;
-       }
-
-       mf->width       = priv->win->width;
-       mf->height      = priv->win->height;
-       mf->code        = priv->cfmt_code;
-
-       switch (mf->code) {
-       case V4L2_MBUS_FMT_RGB565_2X8_LE:
-               mf->colorspace = V4L2_COLORSPACE_SRGB;
-               break;
-       default:
-       case V4L2_MBUS_FMT_UYVY8_2X8:
-               mf->colorspace = V4L2_COLORSPACE_JPEG;
-       }
-       mf->field       = V4L2_FIELD_NONE;
-
-       return 0;
-}
-
-static int ov2640_s_fmt(struct v4l2_subdev *sd,
-                       struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       int ret;
-
-
-       switch (mf->code) {
-       case V4L2_MBUS_FMT_RGB565_2X8_LE:
-               mf->colorspace = V4L2_COLORSPACE_SRGB;
-               break;
-       default:
-               mf->code = V4L2_MBUS_FMT_UYVY8_2X8;
-       case V4L2_MBUS_FMT_UYVY8_2X8:
-               mf->colorspace = V4L2_COLORSPACE_JPEG;
-       }
-
-       ret = ov2640_set_params(client, &mf->width, &mf->height, mf->code);
-
-       return ret;
-}
-
-static int ov2640_try_fmt(struct v4l2_subdev *sd,
-                         struct v4l2_mbus_framefmt *mf)
-{
-       const struct ov2640_win_size *win;
-
-       /*
-        * select suitable win
-        */
-       win = ov2640_select_win(&mf->width, &mf->height);
-
-       mf->field       = V4L2_FIELD_NONE;
-
-       switch (mf->code) {
-       case V4L2_MBUS_FMT_RGB565_2X8_LE:
-               mf->colorspace = V4L2_COLORSPACE_SRGB;
-               break;
-       default:
-               mf->code = V4L2_MBUS_FMT_UYVY8_2X8;
-       case V4L2_MBUS_FMT_UYVY8_2X8:
-               mf->colorspace = V4L2_COLORSPACE_JPEG;
-       }
-
-       return 0;
-}
-
-static int ov2640_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                          enum v4l2_mbus_pixelcode *code)
-{
-       if (index >= ARRAY_SIZE(ov2640_codes))
-               return -EINVAL;
-
-       *code = ov2640_codes[index];
-       return 0;
-}
-
-static int ov2640_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
-{
-       a->c.left       = 0;
-       a->c.top        = 0;
-       a->c.width      = W_UXGA;
-       a->c.height     = H_UXGA;
-       a->type         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-
-       return 0;
-}
-
-static int ov2640_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
-{
-       a->bounds.left                  = 0;
-       a->bounds.top                   = 0;
-       a->bounds.width                 = W_UXGA;
-       a->bounds.height                = H_UXGA;
-       a->defrect                      = a->bounds;
-       a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-       a->pixelaspect.numerator        = 1;
-       a->pixelaspect.denominator      = 1;
-
-       return 0;
-}
-
-static int ov2640_video_probe(struct i2c_client *client)
-{
-       struct ov2640_priv *priv = to_ov2640(client);
-       u8 pid, ver, midh, midl;
-       const char *devname;
-       int ret;
-
-       /*
-        * check and show product ID and manufacturer ID
-        */
-       i2c_smbus_write_byte_data(client, BANK_SEL, BANK_SEL_SENS);
-       pid  = i2c_smbus_read_byte_data(client, PID);
-       ver  = i2c_smbus_read_byte_data(client, VER);
-       midh = i2c_smbus_read_byte_data(client, MIDH);
-       midl = i2c_smbus_read_byte_data(client, MIDL);
-
-       switch (VERSION(pid, ver)) {
-       case PID_OV2640:
-               devname     = "ov2640";
-               priv->model = V4L2_IDENT_OV2640;
-               break;
-       default:
-               dev_err(&client->dev,
-                       "Product ID error %x:%x\n", pid, ver);
-               ret = -ENODEV;
-               goto err;
-       }
-
-       dev_info(&client->dev,
-                "%s Product ID %0x:%0x Manufacturer ID %x:%x\n",
-                devname, pid, ver, midh, midl);
-
-       return v4l2_ctrl_handler_setup(&priv->hdl);
-
-err:
-       return ret;
-}
-
-static const struct v4l2_ctrl_ops ov2640_ctrl_ops = {
-       .s_ctrl = ov2640_s_ctrl,
-};
-
-static struct v4l2_subdev_core_ops ov2640_subdev_core_ops = {
-       .g_chip_ident   = ov2640_g_chip_ident,
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-       .g_register     = ov2640_g_register,
-       .s_register     = ov2640_s_register,
-#endif
-};
-
-static int ov2640_g_mbus_config(struct v4l2_subdev *sd,
-                               struct v4l2_mbus_config *cfg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-
-       cfg->flags = V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_MASTER |
-               V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_HSYNC_ACTIVE_HIGH |
-               V4L2_MBUS_DATA_ACTIVE_HIGH;
-       cfg->type = V4L2_MBUS_PARALLEL;
-       cfg->flags = soc_camera_apply_board_flags(icl, cfg);
-
-       return 0;
-}
-
-static struct v4l2_subdev_video_ops ov2640_subdev_video_ops = {
-       .s_stream       = ov2640_s_stream,
-       .g_mbus_fmt     = ov2640_g_fmt,
-       .s_mbus_fmt     = ov2640_s_fmt,
-       .try_mbus_fmt   = ov2640_try_fmt,
-       .cropcap        = ov2640_cropcap,
-       .g_crop         = ov2640_g_crop,
-       .enum_mbus_fmt  = ov2640_enum_fmt,
-       .g_mbus_config  = ov2640_g_mbus_config,
-};
-
-static struct v4l2_subdev_ops ov2640_subdev_ops = {
-       .core   = &ov2640_subdev_core_ops,
-       .video  = &ov2640_subdev_video_ops,
-};
-
-/*
- * i2c_driver functions
- */
-static int ov2640_probe(struct i2c_client *client,
-                       const struct i2c_device_id *did)
-{
-       struct ov2640_priv      *priv;
-       struct soc_camera_link  *icl = soc_camera_i2c_to_link(client);
-       struct i2c_adapter      *adapter = to_i2c_adapter(client->dev.parent);
-       int                     ret;
-
-       if (!icl) {
-               dev_err(&adapter->dev,
-                       "OV2640: Missing platform_data for driver\n");
-               return -EINVAL;
-       }
-
-       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
-               dev_err(&adapter->dev,
-                       "OV2640: I2C-Adapter doesn't support SMBUS\n");
-               return -EIO;
-       }
-
-       priv = kzalloc(sizeof(struct ov2640_priv), GFP_KERNEL);
-       if (!priv) {
-               dev_err(&adapter->dev,
-                       "Failed to allocate memory for private data!\n");
-               return -ENOMEM;
-       }
-
-       v4l2_i2c_subdev_init(&priv->subdev, client, &ov2640_subdev_ops);
-       v4l2_ctrl_handler_init(&priv->hdl, 2);
-       v4l2_ctrl_new_std(&priv->hdl, &ov2640_ctrl_ops,
-                       V4L2_CID_VFLIP, 0, 1, 1, 0);
-       v4l2_ctrl_new_std(&priv->hdl, &ov2640_ctrl_ops,
-                       V4L2_CID_HFLIP, 0, 1, 1, 0);
-       priv->subdev.ctrl_handler = &priv->hdl;
-       if (priv->hdl.error) {
-               int err = priv->hdl.error;
-
-               kfree(priv);
-               return err;
-       }
-
-       ret = ov2640_video_probe(client);
-       if (ret) {
-               v4l2_ctrl_handler_free(&priv->hdl);
-               kfree(priv);
-       } else {
-               dev_info(&adapter->dev, "OV2640 Probed\n");
-       }
-
-       return ret;
-}
-
-static int ov2640_remove(struct i2c_client *client)
-{
-       struct ov2640_priv       *priv = to_ov2640(client);
-
-       v4l2_device_unregister_subdev(&priv->subdev);
-       v4l2_ctrl_handler_free(&priv->hdl);
-       kfree(priv);
-       return 0;
-}
-
-static const struct i2c_device_id ov2640_id[] = {
-       { "ov2640", 0 },
-       { }
-};
-MODULE_DEVICE_TABLE(i2c, ov2640_id);
-
-static struct i2c_driver ov2640_i2c_driver = {
-       .driver = {
-               .name = "ov2640",
-       },
-       .probe    = ov2640_probe,
-       .remove   = ov2640_remove,
-       .id_table = ov2640_id,
-};
-
-module_i2c_driver(ov2640_i2c_driver);
-
-MODULE_DESCRIPTION("SoC Camera driver for Omni Vision 2640 sensor");
-MODULE_AUTHOR("Alberto Panizzo");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/video/ov5642.c b/drivers/media/video/ov5642.c
deleted file mode 100644 (file)
index 0bc9331..0000000
+++ /dev/null
@@ -1,1073 +0,0 @@
-/*
- * Driver for OV5642 CMOS Image Sensor from Omnivision
- *
- * Copyright (C) 2011, Bastian Hecht <hechtb@gmail.com>
- *
- * Based on Sony IMX074 Camera Driver
- * Copyright (C) 2010, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
- *
- * Based on Omnivision OV7670 Camera Driver
- * Copyright (C) 2006-7 Jonathan Corbet <corbet@lwn.net>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include <linux/bitops.h>
-#include <linux/delay.h>
-#include <linux/i2c.h>
-#include <linux/kernel.h>
-#include <linux/slab.h>
-#include <linux/videodev2.h>
-#include <linux/module.h>
-#include <linux/v4l2-mediabus.h>
-
-#include <media/soc_camera.h>
-#include <media/v4l2-chip-ident.h>
-#include <media/v4l2-subdev.h>
-
-/* OV5642 registers */
-#define REG_CHIP_ID_HIGH               0x300a
-#define REG_CHIP_ID_LOW                        0x300b
-
-#define REG_WINDOW_START_X_HIGH                0x3800
-#define REG_WINDOW_START_X_LOW         0x3801
-#define REG_WINDOW_START_Y_HIGH                0x3802
-#define REG_WINDOW_START_Y_LOW         0x3803
-#define REG_WINDOW_WIDTH_HIGH          0x3804
-#define REG_WINDOW_WIDTH_LOW           0x3805
-#define REG_WINDOW_HEIGHT_HIGH         0x3806
-#define REG_WINDOW_HEIGHT_LOW          0x3807
-#define REG_OUT_WIDTH_HIGH             0x3808
-#define REG_OUT_WIDTH_LOW              0x3809
-#define REG_OUT_HEIGHT_HIGH            0x380a
-#define REG_OUT_HEIGHT_LOW             0x380b
-#define REG_OUT_TOTAL_WIDTH_HIGH       0x380c
-#define REG_OUT_TOTAL_WIDTH_LOW                0x380d
-#define REG_OUT_TOTAL_HEIGHT_HIGH      0x380e
-#define REG_OUT_TOTAL_HEIGHT_LOW       0x380f
-#define REG_OUTPUT_FORMAT              0x4300
-#define REG_ISP_CTRL_01                        0x5001
-#define REG_AVG_WINDOW_END_X_HIGH      0x5682
-#define REG_AVG_WINDOW_END_X_LOW       0x5683
-#define REG_AVG_WINDOW_END_Y_HIGH      0x5686
-#define REG_AVG_WINDOW_END_Y_LOW       0x5687
-
-/* active pixel array size */
-#define OV5642_SENSOR_SIZE_X   2592
-#define OV5642_SENSOR_SIZE_Y   1944
-
-/*
- * About OV5642 resolution, cropping and binning:
- * This sensor supports it all, at least in the feature description.
- * Unfortunately, no combination of appropriate registers settings could make
- * the chip work the intended way. As it works with predefined register lists,
- * some undocumented registers are presumably changed there to achieve their
- * goals.
- * This driver currently only works for resolutions up to 720 lines with a
- * 1:1 scale. Hopefully these restrictions will be removed in the future.
- */
-#define OV5642_MAX_WIDTH       OV5642_SENSOR_SIZE_X
-#define OV5642_MAX_HEIGHT      720
-
-/* default sizes */
-#define OV5642_DEFAULT_WIDTH   1280
-#define OV5642_DEFAULT_HEIGHT  OV5642_MAX_HEIGHT
-
-/* minimum extra blanking */
-#define BLANKING_EXTRA_WIDTH           500
-#define BLANKING_EXTRA_HEIGHT          20
-
-/*
- * the sensor's autoexposure is buggy when setting total_height low.
- * It tries to expose longer than 1 frame period without taking care of it
- * and this leads to weird output. So we set 1000 lines as minimum.
- */
-#define BLANKING_MIN_HEIGHT            1000
-
-struct regval_list {
-       u16 reg_num;
-       u8 value;
-};
-
-static struct regval_list ov5642_default_regs_init[] = {
-       { 0x3103, 0x93 },
-       { 0x3008, 0x82 },
-       { 0x3017, 0x7f },
-       { 0x3018, 0xfc },
-       { 0x3810, 0xc2 },
-       { 0x3615, 0xf0 },
-       { 0x3000, 0x0  },
-       { 0x3001, 0x0  },
-       { 0x3002, 0x0  },
-       { 0x3003, 0x0  },
-       { 0x3004, 0xff },
-       { 0x3030, 0x2b },
-       { 0x3011, 0x8  },
-       { 0x3010, 0x10 },
-       { 0x3604, 0x60 },
-       { 0x3622, 0x60 },
-       { 0x3621, 0x9  },
-       { 0x3709, 0x0  },
-       { 0x4000, 0x21 },
-       { 0x401d, 0x22 },
-       { 0x3600, 0x54 },
-       { 0x3605, 0x4  },
-       { 0x3606, 0x3f },
-       { 0x3c01, 0x80 },
-       { 0x300d, 0x22 },
-       { 0x3623, 0x22 },
-       { 0x5000, 0x4f },
-       { 0x5020, 0x4  },
-       { 0x5181, 0x79 },
-       { 0x5182, 0x0  },
-       { 0x5185, 0x22 },
-       { 0x5197, 0x1  },
-       { 0x5500, 0xa  },
-       { 0x5504, 0x0  },
-       { 0x5505, 0x7f },
-       { 0x5080, 0x8  },
-       { 0x300e, 0x18 },
-       { 0x4610, 0x0  },
-       { 0x471d, 0x5  },
-       { 0x4708, 0x6  },
-       { 0x370c, 0xa0 },
-       { 0x5687, 0x94 },
-       { 0x501f, 0x0  },
-       { 0x5000, 0x4f },
-       { 0x5001, 0xcf },
-       { 0x4300, 0x30 },
-       { 0x4300, 0x30 },
-       { 0x460b, 0x35 },
-       { 0x471d, 0x0  },
-       { 0x3002, 0xc  },
-       { 0x3002, 0x0  },
-       { 0x4713, 0x3  },
-       { 0x471c, 0x50 },
-       { 0x4721, 0x2  },
-       { 0x4402, 0x90 },
-       { 0x460c, 0x22 },
-       { 0x3815, 0x44 },
-       { 0x3503, 0x7  },
-       { 0x3501, 0x73 },
-       { 0x3502, 0x80 },
-       { 0x350b, 0x0  },
-       { 0x3818, 0xc8 },
-       { 0x3824, 0x11 },
-       { 0x3a00, 0x78 },
-       { 0x3a1a, 0x4  },
-       { 0x3a13, 0x30 },
-       { 0x3a18, 0x0  },
-       { 0x3a19, 0x7c },
-       { 0x3a08, 0x12 },
-       { 0x3a09, 0xc0 },
-       { 0x3a0a, 0xf  },
-       { 0x3a0b, 0xa0 },
-       { 0x350c, 0x7  },
-       { 0x350d, 0xd0 },
-       { 0x3a0d, 0x8  },
-       { 0x3a0e, 0x6  },
-       { 0x3500, 0x0  },
-       { 0x3501, 0x0  },
-       { 0x3502, 0x0  },
-       { 0x350a, 0x0  },
-       { 0x350b, 0x0  },
-       { 0x3503, 0x0  },
-       { 0x3a0f, 0x3c },
-       { 0x3a10, 0x32 },
-       { 0x3a1b, 0x3c },
-       { 0x3a1e, 0x32 },
-       { 0x3a11, 0x80 },
-       { 0x3a1f, 0x20 },
-       { 0x3030, 0x2b },
-       { 0x3a02, 0x0  },
-       { 0x3a03, 0x7d },
-       { 0x3a04, 0x0  },
-       { 0x3a14, 0x0  },
-       { 0x3a15, 0x7d },
-       { 0x3a16, 0x0  },
-       { 0x3a00, 0x78 },
-       { 0x3a08, 0x9  },
-       { 0x3a09, 0x60 },
-       { 0x3a0a, 0x7  },
-       { 0x3a0b, 0xd0 },
-       { 0x3a0d, 0x10 },
-       { 0x3a0e, 0xd  },
-       { 0x4407, 0x4  },
-       { 0x5193, 0x70 },
-       { 0x589b, 0x0  },
-       { 0x589a, 0xc0 },
-       { 0x401e, 0x20 },
-       { 0x4001, 0x42 },
-       { 0x401c, 0x6  },
-       { 0x3825, 0xac },
-       { 0x3827, 0xc  },
-       { 0x528a, 0x1  },
-       { 0x528b, 0x4  },
-       { 0x528c, 0x8  },
-       { 0x528d, 0x10 },
-       { 0x528e, 0x20 },
-       { 0x528f, 0x28 },
-       { 0x5290, 0x30 },
-       { 0x5292, 0x0  },
-       { 0x5293, 0x1  },
-       { 0x5294, 0x0  },
-       { 0x5295, 0x4  },
-       { 0x5296, 0x0  },
-       { 0x5297, 0x8  },
-       { 0x5298, 0x0  },
-       { 0x5299, 0x10 },
-       { 0x529a, 0x0  },
-       { 0x529b, 0x20 },
-       { 0x529c, 0x0  },
-       { 0x529d, 0x28 },
-       { 0x529e, 0x0  },
-       { 0x529f, 0x30 },
-       { 0x5282, 0x0  },
-       { 0x5300, 0x0  },
-       { 0x5301, 0x20 },
-       { 0x5302, 0x0  },
-       { 0x5303, 0x7c },
-       { 0x530c, 0x0  },
-       { 0x530d, 0xc  },
-       { 0x530e, 0x20 },
-       { 0x530f, 0x80 },
-       { 0x5310, 0x20 },
-       { 0x5311, 0x80 },
-       { 0x5308, 0x20 },
-       { 0x5309, 0x40 },
-       { 0x5304, 0x0  },
-       { 0x5305, 0x30 },
-       { 0x5306, 0x0  },
-       { 0x5307, 0x80 },
-       { 0x5314, 0x8  },
-       { 0x5315, 0x20 },
-       { 0x5319, 0x30 },
-       { 0x5316, 0x10 },
-       { 0x5317, 0x0  },
-       { 0x5318, 0x2  },
-       { 0x5380, 0x1  },
-       { 0x5381, 0x0  },
-       { 0x5382, 0x0  },
-       { 0x5383, 0x4e },
-       { 0x5384, 0x0  },
-       { 0x5385, 0xf  },
-       { 0x5386, 0x0  },
-       { 0x5387, 0x0  },
-       { 0x5388, 0x1  },
-       { 0x5389, 0x15 },
-       { 0x538a, 0x0  },
-       { 0x538b, 0x31 },
-       { 0x538c, 0x0  },
-       { 0x538d, 0x0  },
-       { 0x538e, 0x0  },
-       { 0x538f, 0xf  },
-       { 0x5390, 0x0  },
-       { 0x5391, 0xab },
-       { 0x5392, 0x0  },
-       { 0x5393, 0xa2 },
-       { 0x5394, 0x8  },
-       { 0x5480, 0x14 },
-       { 0x5481, 0x21 },
-       { 0x5482, 0x36 },
-       { 0x5483, 0x57 },
-       { 0x5484, 0x65 },
-       { 0x5485, 0x71 },
-       { 0x5486, 0x7d },
-       { 0x5487, 0x87 },
-       { 0x5488, 0x91 },
-       { 0x5489, 0x9a },
-       { 0x548a, 0xaa },
-       { 0x548b, 0xb8 },
-       { 0x548c, 0xcd },
-       { 0x548d, 0xdd },
-       { 0x548e, 0xea },
-       { 0x548f, 0x1d },
-       { 0x5490, 0x5  },
-       { 0x5491, 0x0  },
-       { 0x5492, 0x4  },
-       { 0x5493, 0x20 },
-       { 0x5494, 0x3  },
-       { 0x5495, 0x60 },
-       { 0x5496, 0x2  },
-       { 0x5497, 0xb8 },
-       { 0x5498, 0x2  },
-       { 0x5499, 0x86 },
-       { 0x549a, 0x2  },
-       { 0x549b, 0x5b },
-       { 0x549c, 0x2  },
-       { 0x549d, 0x3b },
-       { 0x549e, 0x2  },
-       { 0x549f, 0x1c },
-       { 0x54a0, 0x2  },
-       { 0x54a1, 0x4  },
-       { 0x54a2, 0x1  },
-       { 0x54a3, 0xed },
-       { 0x54a4, 0x1  },
-       { 0x54a5, 0xc5 },
-       { 0x54a6, 0x1  },
-       { 0x54a7, 0xa5 },
-       { 0x54a8, 0x1  },
-       { 0x54a9, 0x6c },
-       { 0x54aa, 0x1  },
-       { 0x54ab, 0x41 },
-       { 0x54ac, 0x1  },
-       { 0x54ad, 0x20 },
-       { 0x54ae, 0x0  },
-       { 0x54af, 0x16 },
-       { 0x54b0, 0x1  },
-       { 0x54b1, 0x20 },
-       { 0x54b2, 0x0  },
-       { 0x54b3, 0x10 },
-       { 0x54b4, 0x0  },
-       { 0x54b5, 0xf0 },
-       { 0x54b6, 0x0  },
-       { 0x54b7, 0xdf },
-       { 0x5402, 0x3f },
-       { 0x5403, 0x0  },
-       { 0x3406, 0x0  },
-       { 0x5180, 0xff },
-       { 0x5181, 0x52 },
-       { 0x5182, 0x11 },
-       { 0x5183, 0x14 },
-       { 0x5184, 0x25 },
-       { 0x5185, 0x24 },
-       { 0x5186, 0x6  },
-       { 0x5187, 0x8  },
-       { 0x5188, 0x8  },
-       { 0x5189, 0x7c },
-       { 0x518a, 0x60 },
-       { 0x518b, 0xb2 },
-       { 0x518c, 0xb2 },
-       { 0x518d, 0x44 },
-       { 0x518e, 0x3d },
-       { 0x518f, 0x58 },
-       { 0x5190, 0x46 },
-       { 0x5191, 0xf8 },
-       { 0x5192, 0x4  },
-       { 0x5193, 0x70 },
-       { 0x5194, 0xf0 },
-       { 0x5195, 0xf0 },
-       { 0x5196, 0x3  },
-       { 0x5197, 0x1  },
-       { 0x5198, 0x4  },
-       { 0x5199, 0x12 },
-       { 0x519a, 0x4  },
-       { 0x519b, 0x0  },
-       { 0x519c, 0x6  },
-       { 0x519d, 0x82 },
-       { 0x519e, 0x0  },
-       { 0x5025, 0x80 },
-       { 0x3a0f, 0x38 },
-       { 0x3a10, 0x30 },
-       { 0x3a1b, 0x3a },
-       { 0x3a1e, 0x2e },
-       { 0x3a11, 0x60 },
-       { 0x3a1f, 0x10 },
-       { 0x5688, 0xa6 },
-       { 0x5689, 0x6a },
-       { 0x568a, 0xea },
-       { 0x568b, 0xae },
-       { 0x568c, 0xa6 },
-       { 0x568d, 0x6a },
-       { 0x568e, 0x62 },
-       { 0x568f, 0x26 },
-       { 0x5583, 0x40 },
-       { 0x5584, 0x40 },
-       { 0x5580, 0x2  },
-       { 0x5000, 0xcf },
-       { 0x5800, 0x27 },
-       { 0x5801, 0x19 },
-       { 0x5802, 0x12 },
-       { 0x5803, 0xf  },
-       { 0x5804, 0x10 },
-       { 0x5805, 0x15 },
-       { 0x5806, 0x1e },
-       { 0x5807, 0x2f },
-       { 0x5808, 0x15 },
-       { 0x5809, 0xd  },
-       { 0x580a, 0xa  },
-       { 0x580b, 0x9  },
-       { 0x580c, 0xa  },
-       { 0x580d, 0xc  },
-       { 0x580e, 0x12 },
-       { 0x580f, 0x19 },
-       { 0x5810, 0xb  },
-       { 0x5811, 0x7  },
-       { 0x5812, 0x4  },
-       { 0x5813, 0x3  },
-       { 0x5814, 0x3  },
-       { 0x5815, 0x6  },
-       { 0x5816, 0xa  },
-       { 0x5817, 0xf  },
-       { 0x5818, 0xa  },
-       { 0x5819, 0x5  },
-       { 0x581a, 0x1  },
-       { 0x581b, 0x0  },
-       { 0x581c, 0x0  },
-       { 0x581d, 0x3  },
-       { 0x581e, 0x8  },
-       { 0x581f, 0xc  },
-       { 0x5820, 0xa  },
-       { 0x5821, 0x5  },
-       { 0x5822, 0x1  },
-       { 0x5823, 0x0  },
-       { 0x5824, 0x0  },
-       { 0x5825, 0x3  },
-       { 0x5826, 0x8  },
-       { 0x5827, 0xc  },
-       { 0x5828, 0xe  },
-       { 0x5829, 0x8  },
-       { 0x582a, 0x6  },
-       { 0x582b, 0x4  },
-       { 0x582c, 0x5  },
-       { 0x582d, 0x7  },
-       { 0x582e, 0xb  },
-       { 0x582f, 0x12 },
-       { 0x5830, 0x18 },
-       { 0x5831, 0x10 },
-       { 0x5832, 0xc  },
-       { 0x5833, 0xa  },
-       { 0x5834, 0xb  },
-       { 0x5835, 0xe  },
-       { 0x5836, 0x15 },
-       { 0x5837, 0x19 },
-       { 0x5838, 0x32 },
-       { 0x5839, 0x1f },
-       { 0x583a, 0x18 },
-       { 0x583b, 0x16 },
-       { 0x583c, 0x17 },
-       { 0x583d, 0x1e },
-       { 0x583e, 0x26 },
-       { 0x583f, 0x53 },
-       { 0x5840, 0x10 },
-       { 0x5841, 0xf  },
-       { 0x5842, 0xd  },
-       { 0x5843, 0xc  },
-       { 0x5844, 0xe  },
-       { 0x5845, 0x9  },
-       { 0x5846, 0x11 },
-       { 0x5847, 0x10 },
-       { 0x5848, 0x10 },
-       { 0x5849, 0x10 },
-       { 0x584a, 0x10 },
-       { 0x584b, 0xe  },
-       { 0x584c, 0x10 },
-       { 0x584d, 0x10 },
-       { 0x584e, 0x11 },
-       { 0x584f, 0x10 },
-       { 0x5850, 0xf  },
-       { 0x5851, 0xc  },
-       { 0x5852, 0xf  },
-       { 0x5853, 0x10 },
-       { 0x5854, 0x10 },
-       { 0x5855, 0xf  },
-       { 0x5856, 0xe  },
-       { 0x5857, 0xb  },
-       { 0x5858, 0x10 },
-       { 0x5859, 0xd  },
-       { 0x585a, 0xd  },
-       { 0x585b, 0xc  },
-       { 0x585c, 0xc  },
-       { 0x585d, 0xc  },
-       { 0x585e, 0xb  },
-       { 0x585f, 0xc  },
-       { 0x5860, 0xc  },
-       { 0x5861, 0xc  },
-       { 0x5862, 0xd  },
-       { 0x5863, 0x8  },
-       { 0x5864, 0x11 },
-       { 0x5865, 0x18 },
-       { 0x5866, 0x18 },
-       { 0x5867, 0x19 },
-       { 0x5868, 0x17 },
-       { 0x5869, 0x19 },
-       { 0x586a, 0x16 },
-       { 0x586b, 0x13 },
-       { 0x586c, 0x13 },
-       { 0x586d, 0x12 },
-       { 0x586e, 0x13 },
-       { 0x586f, 0x16 },
-       { 0x5870, 0x14 },
-       { 0x5871, 0x12 },
-       { 0x5872, 0x10 },
-       { 0x5873, 0x11 },
-       { 0x5874, 0x11 },
-       { 0x5875, 0x16 },
-       { 0x5876, 0x14 },
-       { 0x5877, 0x11 },
-       { 0x5878, 0x10 },
-       { 0x5879, 0xf  },
-       { 0x587a, 0x10 },
-       { 0x587b, 0x14 },
-       { 0x587c, 0x13 },
-       { 0x587d, 0x12 },
-       { 0x587e, 0x11 },
-       { 0x587f, 0x11 },
-       { 0x5880, 0x12 },
-       { 0x5881, 0x15 },
-       { 0x5882, 0x14 },
-       { 0x5883, 0x15 },
-       { 0x5884, 0x15 },
-       { 0x5885, 0x15 },
-       { 0x5886, 0x13 },
-       { 0x5887, 0x17 },
-       { 0x3710, 0x10 },
-       { 0x3632, 0x51 },
-       { 0x3702, 0x10 },
-       { 0x3703, 0xb2 },
-       { 0x3704, 0x18 },
-       { 0x370b, 0x40 },
-       { 0x370d, 0x3  },
-       { 0x3631, 0x1  },
-       { 0x3632, 0x52 },
-       { 0x3606, 0x24 },
-       { 0x3620, 0x96 },
-       { 0x5785, 0x7  },
-       { 0x3a13, 0x30 },
-       { 0x3600, 0x52 },
-       { 0x3604, 0x48 },
-       { 0x3606, 0x1b },
-       { 0x370d, 0xb  },
-       { 0x370f, 0xc0 },
-       { 0x3709, 0x1  },
-       { 0x3823, 0x0  },
-       { 0x5007, 0x0  },
-       { 0x5009, 0x0  },
-       { 0x5011, 0x0  },
-       { 0x5013, 0x0  },
-       { 0x519e, 0x0  },
-       { 0x5086, 0x0  },
-       { 0x5087, 0x0  },
-       { 0x5088, 0x0  },
-       { 0x5089, 0x0  },
-       { 0x302b, 0x0  },
-       { 0x3503, 0x7  },
-       { 0x3011, 0x8  },
-       { 0x350c, 0x2  },
-       { 0x350d, 0xe4 },
-       { 0x3621, 0xc9 },
-       { 0x370a, 0x81 },
-       { 0xffff, 0xff },
-};
-
-static struct regval_list ov5642_default_regs_finalise[] = {
-       { 0x3810, 0xc2 },
-       { 0x3818, 0xc9 },
-       { 0x381c, 0x10 },
-       { 0x381d, 0xa0 },
-       { 0x381e, 0x5  },
-       { 0x381f, 0xb0 },
-       { 0x3820, 0x0  },
-       { 0x3821, 0x0  },
-       { 0x3824, 0x11 },
-       { 0x3a08, 0x1b },
-       { 0x3a09, 0xc0 },
-       { 0x3a0a, 0x17 },
-       { 0x3a0b, 0x20 },
-       { 0x3a0d, 0x2  },
-       { 0x3a0e, 0x1  },
-       { 0x401c, 0x4  },
-       { 0x5682, 0x5  },
-       { 0x5683, 0x0  },
-       { 0x5686, 0x2  },
-       { 0x5687, 0xcc },
-       { 0x5001, 0x4f },
-       { 0x589b, 0x6  },
-       { 0x589a, 0xc5 },
-       { 0x3503, 0x0  },
-       { 0x460c, 0x20 },
-       { 0x460b, 0x37 },
-       { 0x471c, 0xd0 },
-       { 0x471d, 0x5  },
-       { 0x3815, 0x1  },
-       { 0x3818, 0xc1 },
-       { 0x501f, 0x0  },
-       { 0x5002, 0xe0 },
-       { 0x4300, 0x32 }, /* UYVY */
-       { 0x3002, 0x1c },
-       { 0x4800, 0x14 },
-       { 0x4801, 0xf  },
-       { 0x3007, 0x3b },
-       { 0x300e, 0x4  },
-       { 0x4803, 0x50 },
-       { 0x3815, 0x1  },
-       { 0x4713, 0x2  },
-       { 0x4842, 0x1  },
-       { 0x300f, 0xe  },
-       { 0x3003, 0x3  },
-       { 0x3003, 0x1  },
-       { 0xffff, 0xff },
-};
-
-struct ov5642_datafmt {
-       enum v4l2_mbus_pixelcode        code;
-       enum v4l2_colorspace            colorspace;
-};
-
-struct ov5642 {
-       struct v4l2_subdev              subdev;
-       const struct ov5642_datafmt     *fmt;
-       struct v4l2_rect                crop_rect;
-
-       /* blanking information */
-       int total_width;
-       int total_height;
-};
-
-static const struct ov5642_datafmt ov5642_colour_fmts[] = {
-       {V4L2_MBUS_FMT_UYVY8_2X8, V4L2_COLORSPACE_JPEG},
-};
-
-static struct ov5642 *to_ov5642(const struct i2c_client *client)
-{
-       return container_of(i2c_get_clientdata(client), struct ov5642, subdev);
-}
-
-/* Find a data format by a pixel code in an array */
-static const struct ov5642_datafmt
-                       *ov5642_find_datafmt(enum v4l2_mbus_pixelcode code)
-{
-       int i;
-
-       for (i = 0; i < ARRAY_SIZE(ov5642_colour_fmts); i++)
-               if (ov5642_colour_fmts[i].code == code)
-                       return ov5642_colour_fmts + i;
-
-       return NULL;
-}
-
-static int reg_read(struct i2c_client *client, u16 reg, u8 *val)
-{
-       int ret;
-       /* We have 16-bit i2c addresses - care for endianess */
-       unsigned char data[2] = { reg >> 8, reg & 0xff };
-
-       ret = i2c_master_send(client, data, 2);
-       if (ret < 2) {
-               dev_err(&client->dev, "%s: i2c read error, reg: %x\n",
-                       __func__, reg);
-               return ret < 0 ? ret : -EIO;
-       }
-
-       ret = i2c_master_recv(client, val, 1);
-       if (ret < 1) {
-               dev_err(&client->dev, "%s: i2c read error, reg: %x\n",
-                               __func__, reg);
-               return ret < 0 ? ret : -EIO;
-       }
-       return 0;
-}
-
-static int reg_write(struct i2c_client *client, u16 reg, u8 val)
-{
-       int ret;
-       unsigned char data[3] = { reg >> 8, reg & 0xff, val };
-
-       ret = i2c_master_send(client, data, 3);
-       if (ret < 3) {
-               dev_err(&client->dev, "%s: i2c write error, reg: %x\n",
-                       __func__, reg);
-               return ret < 0 ? ret : -EIO;
-       }
-
-       return 0;
-}
-
-/*
- * convenience function to write 16 bit register values that are split up
- * into two consecutive high and low parts
- */
-static int reg_write16(struct i2c_client *client, u16 reg, u16 val16)
-{
-       int ret;
-
-       ret = reg_write(client, reg, val16 >> 8);
-       if (ret)
-               return ret;
-       return reg_write(client, reg + 1, val16 & 0x00ff);
-}
-
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-static int ov5642_get_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       int ret;
-       u8 val;
-
-       if (reg->reg & ~0xffff)
-               return -EINVAL;
-
-       reg->size = 1;
-
-       ret = reg_read(client, reg->reg, &val);
-       if (!ret)
-               reg->val = (__u64)val;
-
-       return ret;
-}
-
-static int ov5642_set_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-
-       if (reg->reg & ~0xffff || reg->val & ~0xff)
-               return -EINVAL;
-
-       return reg_write(client, reg->reg, reg->val);
-}
-#endif
-
-static int ov5642_write_array(struct i2c_client *client,
-                               struct regval_list *vals)
-{
-       while (vals->reg_num != 0xffff || vals->value != 0xff) {
-               int ret = reg_write(client, vals->reg_num, vals->value);
-               if (ret < 0)
-                       return ret;
-               vals++;
-       }
-       dev_dbg(&client->dev, "Register list loaded\n");
-       return 0;
-}
-
-static int ov5642_set_resolution(struct v4l2_subdev *sd)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct ov5642 *priv = to_ov5642(client);
-       int width = priv->crop_rect.width;
-       int height = priv->crop_rect.height;
-       int total_width = priv->total_width;
-       int total_height = priv->total_height;
-       int start_x = (OV5642_SENSOR_SIZE_X - width) / 2;
-       int start_y = (OV5642_SENSOR_SIZE_Y - height) / 2;
-       int ret;
-
-       /*
-        * This should set the starting point for cropping.
-        * Doesn't work so far.
-        */
-       ret = reg_write16(client, REG_WINDOW_START_X_HIGH, start_x);
-       if (!ret)
-               ret = reg_write16(client, REG_WINDOW_START_Y_HIGH, start_y);
-       if (!ret) {
-               priv->crop_rect.left = start_x;
-               priv->crop_rect.top = start_y;
-       }
-
-       if (!ret)
-               ret = reg_write16(client, REG_WINDOW_WIDTH_HIGH, width);
-       if (!ret)
-               ret = reg_write16(client, REG_WINDOW_HEIGHT_HIGH, height);
-       if (ret)
-               return ret;
-       priv->crop_rect.width = width;
-       priv->crop_rect.height = height;
-
-       /* Set the output window size. Only 1:1 scale is supported so far. */
-       ret = reg_write16(client, REG_OUT_WIDTH_HIGH, width);
-       if (!ret)
-               ret = reg_write16(client, REG_OUT_HEIGHT_HIGH, height);
-
-       /* Total width = output size + blanking */
-       if (!ret)
-               ret = reg_write16(client, REG_OUT_TOTAL_WIDTH_HIGH, total_width);
-       if (!ret)
-               ret = reg_write16(client, REG_OUT_TOTAL_HEIGHT_HIGH, total_height);
-
-       /* Sets the window for AWB calculations */
-       if (!ret)
-               ret = reg_write16(client, REG_AVG_WINDOW_END_X_HIGH, width);
-       if (!ret)
-               ret = reg_write16(client, REG_AVG_WINDOW_END_Y_HIGH, height);
-
-       return ret;
-}
-
-static int ov5642_try_fmt(struct v4l2_subdev *sd,
-                         struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct ov5642 *priv = to_ov5642(client);
-       const struct ov5642_datafmt *fmt = ov5642_find_datafmt(mf->code);
-
-       mf->width = priv->crop_rect.width;
-       mf->height = priv->crop_rect.height;
-
-       if (!fmt) {
-               mf->code        = ov5642_colour_fmts[0].code;
-               mf->colorspace  = ov5642_colour_fmts[0].colorspace;
-       }
-
-       mf->field       = V4L2_FIELD_NONE;
-
-       return 0;
-}
-
-static int ov5642_s_fmt(struct v4l2_subdev *sd,
-                       struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct ov5642 *priv = to_ov5642(client);
-
-       /* MIPI CSI could have changed the format, double-check */
-       if (!ov5642_find_datafmt(mf->code))
-               return -EINVAL;
-
-       ov5642_try_fmt(sd, mf);
-       priv->fmt = ov5642_find_datafmt(mf->code);
-
-       return 0;
-}
-
-static int ov5642_g_fmt(struct v4l2_subdev *sd,
-                       struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct ov5642 *priv = to_ov5642(client);
-
-       const struct ov5642_datafmt *fmt = priv->fmt;
-
-       mf->code        = fmt->code;
-       mf->colorspace  = fmt->colorspace;
-       mf->width       = priv->crop_rect.width;
-       mf->height      = priv->crop_rect.height;
-       mf->field       = V4L2_FIELD_NONE;
-
-       return 0;
-}
-
-static int ov5642_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                          enum v4l2_mbus_pixelcode *code)
-{
-       if (index >= ARRAY_SIZE(ov5642_colour_fmts))
-               return -EINVAL;
-
-       *code = ov5642_colour_fmts[index].code;
-       return 0;
-}
-
-static int ov5642_g_chip_ident(struct v4l2_subdev *sd,
-                              struct v4l2_dbg_chip_ident *id)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-
-       if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
-               return -EINVAL;
-
-       if (id->match.addr != client->addr)
-               return -ENODEV;
-
-       id->ident       = V4L2_IDENT_OV5642;
-       id->revision    = 0;
-
-       return 0;
-}
-
-static int ov5642_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct ov5642 *priv = to_ov5642(client);
-       struct v4l2_rect *rect = &a->c;
-       int ret;
-
-       v4l_bound_align_image(&rect->width, 48, OV5642_MAX_WIDTH, 1,
-                             &rect->height, 32, OV5642_MAX_HEIGHT, 1, 0);
-
-       priv->crop_rect.width   = rect->width;
-       priv->crop_rect.height  = rect->height;
-       priv->total_width       = rect->width + BLANKING_EXTRA_WIDTH;
-       priv->total_height      = max_t(int, rect->height +
-                                                       BLANKING_EXTRA_HEIGHT,
-                                                       BLANKING_MIN_HEIGHT);
-       priv->crop_rect.width           = rect->width;
-       priv->crop_rect.height          = rect->height;
-
-       ret = ov5642_write_array(client, ov5642_default_regs_init);
-       if (!ret)
-               ret = ov5642_set_resolution(sd);
-       if (!ret)
-               ret = ov5642_write_array(client, ov5642_default_regs_finalise);
-
-       return ret;
-}
-
-static int ov5642_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct ov5642 *priv = to_ov5642(client);
-       struct v4l2_rect *rect = &a->c;
-
-       if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-               return -EINVAL;
-
-       *rect = priv->crop_rect;
-
-       return 0;
-}
-
-static int ov5642_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
-{
-       a->bounds.left                  = 0;
-       a->bounds.top                   = 0;
-       a->bounds.width                 = OV5642_MAX_WIDTH;
-       a->bounds.height                = OV5642_MAX_HEIGHT;
-       a->defrect                      = a->bounds;
-       a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-       a->pixelaspect.numerator        = 1;
-       a->pixelaspect.denominator      = 1;
-
-       return 0;
-}
-
-static int ov5642_g_mbus_config(struct v4l2_subdev *sd,
-                               struct v4l2_mbus_config *cfg)
-{
-       cfg->type = V4L2_MBUS_CSI2;
-       cfg->flags = V4L2_MBUS_CSI2_2_LANE | V4L2_MBUS_CSI2_CHANNEL_0 |
-                                       V4L2_MBUS_CSI2_CONTINUOUS_CLOCK;
-
-       return 0;
-}
-
-static int ov5642_s_power(struct v4l2_subdev *sd, int on)
-{
-       struct i2c_client *client;
-       int ret;
-
-       if (!on)
-               return 0;
-
-       client = v4l2_get_subdevdata(sd);
-       ret = ov5642_write_array(client, ov5642_default_regs_init);
-       if (!ret)
-               ret = ov5642_set_resolution(sd);
-       if (!ret)
-               ret = ov5642_write_array(client, ov5642_default_regs_finalise);
-
-       return ret;
-}
-
-static struct v4l2_subdev_video_ops ov5642_subdev_video_ops = {
-       .s_mbus_fmt     = ov5642_s_fmt,
-       .g_mbus_fmt     = ov5642_g_fmt,
-       .try_mbus_fmt   = ov5642_try_fmt,
-       .enum_mbus_fmt  = ov5642_enum_fmt,
-       .s_crop         = ov5642_s_crop,
-       .g_crop         = ov5642_g_crop,
-       .cropcap        = ov5642_cropcap,
-       .g_mbus_config  = ov5642_g_mbus_config,
-};
-
-static struct v4l2_subdev_core_ops ov5642_subdev_core_ops = {
-       .s_power        = ov5642_s_power,
-       .g_chip_ident   = ov5642_g_chip_ident,
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-       .g_register     = ov5642_get_register,
-       .s_register     = ov5642_set_register,
-#endif
-};
-
-static struct v4l2_subdev_ops ov5642_subdev_ops = {
-       .core   = &ov5642_subdev_core_ops,
-       .video  = &ov5642_subdev_video_ops,
-};
-
-static int ov5642_video_probe(struct i2c_client *client)
-{
-       int ret;
-       u8 id_high, id_low;
-       u16 id;
-
-       /* Read sensor Model ID */
-       ret = reg_read(client, REG_CHIP_ID_HIGH, &id_high);
-       if (ret < 0)
-               return ret;
-
-       id = id_high << 8;
-
-       ret = reg_read(client, REG_CHIP_ID_LOW, &id_low);
-       if (ret < 0)
-               return ret;
-
-       id |= id_low;
-
-       dev_info(&client->dev, "Chip ID 0x%04x detected\n", id);
-
-       if (id != 0x5642)
-               return -ENODEV;
-
-       return 0;
-}
-
-static int ov5642_probe(struct i2c_client *client,
-                       const struct i2c_device_id *did)
-{
-       struct ov5642 *priv;
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-       int ret;
-
-       if (!icl) {
-               dev_err(&client->dev, "OV5642: missing platform data!\n");
-               return -EINVAL;
-       }
-
-       priv = kzalloc(sizeof(struct ov5642), GFP_KERNEL);
-       if (!priv)
-               return -ENOMEM;
-
-       v4l2_i2c_subdev_init(&priv->subdev, client, &ov5642_subdev_ops);
-
-       priv->fmt               = &ov5642_colour_fmts[0];
-
-       priv->crop_rect.width   = OV5642_DEFAULT_WIDTH;
-       priv->crop_rect.height  = OV5642_DEFAULT_HEIGHT;
-       priv->crop_rect.left    = (OV5642_MAX_WIDTH - OV5642_DEFAULT_WIDTH) / 2;
-       priv->crop_rect.top     = (OV5642_MAX_HEIGHT - OV5642_DEFAULT_HEIGHT) / 2;
-       priv->total_width = OV5642_DEFAULT_WIDTH + BLANKING_EXTRA_WIDTH;
-       priv->total_height = BLANKING_MIN_HEIGHT;
-
-       ret = ov5642_video_probe(client);
-       if (ret < 0)
-               goto error;
-
-       return 0;
-
-error:
-       kfree(priv);
-       return ret;
-}
-
-static int ov5642_remove(struct i2c_client *client)
-{
-       struct ov5642 *priv = to_ov5642(client);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-
-       if (icl->free_bus)
-               icl->free_bus(icl);
-       kfree(priv);
-
-       return 0;
-}
-
-static const struct i2c_device_id ov5642_id[] = {
-       { "ov5642", 0 },
-       { }
-};
-MODULE_DEVICE_TABLE(i2c, ov5642_id);
-
-static struct i2c_driver ov5642_i2c_driver = {
-       .driver = {
-               .name = "ov5642",
-       },
-       .probe          = ov5642_probe,
-       .remove         = ov5642_remove,
-       .id_table       = ov5642_id,
-};
-
-module_i2c_driver(ov5642_i2c_driver);
-
-MODULE_DESCRIPTION("Omnivision OV5642 Camera driver");
-MODULE_AUTHOR("Bastian Hecht <hechtb@gmail.com>");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/video/ov6650.c b/drivers/media/video/ov6650.c
deleted file mode 100644 (file)
index 3e028b1..0000000
+++ /dev/null
@@ -1,1053 +0,0 @@
-/*
- * V4L2 SoC Camera driver for OmniVision OV6650 Camera Sensor
- *
- * Copyright (C) 2010 Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>
- *
- * Based on OmniVision OV96xx Camera Driver
- * Copyright (C) 2009 Marek Vasut <marek.vasut@gmail.com>
- *
- * Based on ov772x camera driver:
- * Copyright (C) 2008 Renesas Solutions Corp.
- * Kuninori Morimoto <morimoto.kuninori@renesas.com>
- *
- * Based on ov7670 and soc_camera_platform driver,
- * Copyright 2006-7 Jonathan Corbet <corbet@lwn.net>
- * Copyright (C) 2008 Magnus Damm
- * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
- *
- * Hardware specific bits initialy based on former work by Matt Callow
- * drivers/media/video/omap/sensor_ov6650.c
- * Copyright (C) 2006 Matt Callow
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include <linux/bitops.h>
-#include <linux/delay.h>
-#include <linux/i2c.h>
-#include <linux/slab.h>
-#include <linux/v4l2-mediabus.h>
-#include <linux/module.h>
-
-#include <media/soc_camera.h>
-#include <media/v4l2-chip-ident.h>
-#include <media/v4l2-ctrls.h>
-
-/* Register definitions */
-#define REG_GAIN               0x00    /* range 00 - 3F */
-#define REG_BLUE               0x01
-#define REG_RED                        0x02
-#define REG_SAT                        0x03    /* [7:4] saturation [0:3] reserved */
-#define REG_HUE                        0x04    /* [7:6] rsrvd [5] hue en [4:0] hue */
-
-#define REG_BRT                        0x06
-
-#define REG_PIDH               0x0a
-#define REG_PIDL               0x0b
-
-#define REG_AECH               0x10
-#define REG_CLKRC              0x11    /* Data Format and Internal Clock */
-                                       /* [7:6] Input system clock (MHz)*/
-                                       /*   00=8, 01=12, 10=16, 11=24 */
-                                       /* [5:0]: Internal Clock Pre-Scaler */
-#define REG_COMA               0x12    /* [7] Reset */
-#define REG_COMB               0x13
-#define REG_COMC               0x14
-#define REG_COMD               0x15
-#define REG_COML               0x16
-#define REG_HSTRT              0x17
-#define REG_HSTOP              0x18
-#define REG_VSTRT              0x19
-#define REG_VSTOP              0x1a
-#define REG_PSHFT              0x1b
-#define REG_MIDH               0x1c
-#define REG_MIDL               0x1d
-#define REG_HSYNS              0x1e
-#define REG_HSYNE              0x1f
-#define REG_COME               0x20
-#define REG_YOFF               0x21
-#define REG_UOFF               0x22
-#define REG_VOFF               0x23
-#define REG_AEW                        0x24
-#define REG_AEB                        0x25
-#define REG_COMF               0x26
-#define REG_COMG               0x27
-#define REG_COMH               0x28
-#define REG_COMI               0x29
-
-#define REG_FRARL              0x2b
-#define REG_COMJ               0x2c
-#define REG_COMK               0x2d
-#define REG_AVGY               0x2e
-#define REG_REF0               0x2f
-#define REG_REF1               0x30
-#define REG_REF2               0x31
-#define REG_FRAJH              0x32
-#define REG_FRAJL              0x33
-#define REG_FACT               0x34
-#define REG_L1AEC              0x35
-#define REG_AVGU               0x36
-#define REG_AVGV               0x37
-
-#define REG_SPCB               0x60
-#define REG_SPCC               0x61
-#define REG_GAM1               0x62
-#define REG_GAM2               0x63
-#define REG_GAM3               0x64
-#define REG_SPCD               0x65
-
-#define REG_SPCE               0x68
-#define REG_ADCL               0x69
-
-#define REG_RMCO               0x6c
-#define REG_GMCO               0x6d
-#define REG_BMCO               0x6e
-
-
-/* Register bits, values, etc. */
-#define OV6650_PIDH            0x66    /* high byte of product ID number */
-#define OV6650_PIDL            0x50    /* low byte of product ID number */
-#define OV6650_MIDH            0x7F    /* high byte of mfg ID */
-#define OV6650_MIDL            0xA2    /* low byte of mfg ID */
-
-#define DEF_GAIN               0x00
-#define DEF_BLUE               0x80
-#define DEF_RED                        0x80
-
-#define SAT_SHIFT              4
-#define SAT_MASK               (0xf << SAT_SHIFT)
-#define SET_SAT(x)             (((x) << SAT_SHIFT) & SAT_MASK)
-
-#define HUE_EN                 BIT(5)
-#define HUE_MASK               0x1f
-#define DEF_HUE                        0x10
-#define SET_HUE(x)             (HUE_EN | ((x) & HUE_MASK))
-
-#define DEF_AECH               0x4D
-
-#define CLKRC_6MHz             0x00
-#define CLKRC_12MHz            0x40
-#define CLKRC_16MHz            0x80
-#define CLKRC_24MHz            0xc0
-#define CLKRC_DIV_MASK         0x3f
-#define GET_CLKRC_DIV(x)       (((x) & CLKRC_DIV_MASK) + 1)
-
-#define COMA_RESET             BIT(7)
-#define COMA_QCIF              BIT(5)
-#define COMA_RAW_RGB           BIT(4)
-#define COMA_RGB               BIT(3)
-#define COMA_BW                        BIT(2)
-#define COMA_WORD_SWAP         BIT(1)
-#define COMA_BYTE_SWAP         BIT(0)
-#define DEF_COMA               0x00
-
-#define COMB_FLIP_V            BIT(7)
-#define COMB_FLIP_H            BIT(5)
-#define COMB_BAND_FILTER       BIT(4)
-#define COMB_AWB               BIT(2)
-#define COMB_AGC               BIT(1)
-#define COMB_AEC               BIT(0)
-#define DEF_COMB               0x5f
-
-#define COML_ONE_CHANNEL       BIT(7)
-
-#define DEF_HSTRT              0x24
-#define DEF_HSTOP              0xd4
-#define DEF_VSTRT              0x04
-#define DEF_VSTOP              0x94
-
-#define COMF_HREF_LOW          BIT(4)
-
-#define COMJ_PCLK_RISING       BIT(4)
-#define COMJ_VSYNC_HIGH                BIT(0)
-
-/* supported resolutions */
-#define W_QCIF                 (DEF_HSTOP - DEF_HSTRT)
-#define W_CIF                  (W_QCIF << 1)
-#define H_QCIF                 (DEF_VSTOP - DEF_VSTRT)
-#define H_CIF                  (H_QCIF << 1)
-
-#define FRAME_RATE_MAX         30
-
-
-struct ov6650_reg {
-       u8      reg;
-       u8      val;
-};
-
-struct ov6650 {
-       struct v4l2_subdev      subdev;
-       struct v4l2_ctrl_handler hdl;
-       struct {
-               /* exposure/autoexposure cluster */
-               struct v4l2_ctrl *autoexposure;
-               struct v4l2_ctrl *exposure;
-       };
-       struct {
-               /* gain/autogain cluster */
-               struct v4l2_ctrl *autogain;
-               struct v4l2_ctrl *gain;
-       };
-       struct {
-               /* blue/red/autowhitebalance cluster */
-               struct v4l2_ctrl *autowb;
-               struct v4l2_ctrl *blue;
-               struct v4l2_ctrl *red;
-       };
-       bool                    half_scale;     /* scale down output by 2 */
-       struct v4l2_rect        rect;           /* sensor cropping window */
-       unsigned long           pclk_limit;     /* from host */
-       unsigned long           pclk_max;       /* from resolution and format */
-       struct v4l2_fract       tpf;            /* as requested with s_parm */
-       enum v4l2_mbus_pixelcode code;
-       enum v4l2_colorspace    colorspace;
-};
-
-
-static enum v4l2_mbus_pixelcode ov6650_codes[] = {
-       V4L2_MBUS_FMT_YUYV8_2X8,
-       V4L2_MBUS_FMT_UYVY8_2X8,
-       V4L2_MBUS_FMT_YVYU8_2X8,
-       V4L2_MBUS_FMT_VYUY8_2X8,
-       V4L2_MBUS_FMT_SBGGR8_1X8,
-       V4L2_MBUS_FMT_Y8_1X8,
-};
-
-/* read a register */
-static int ov6650_reg_read(struct i2c_client *client, u8 reg, u8 *val)
-{
-       int ret;
-       u8 data = reg;
-       struct i2c_msg msg = {
-               .addr   = client->addr,
-               .flags  = 0,
-               .len    = 1,
-               .buf    = &data,
-       };
-
-       ret = i2c_transfer(client->adapter, &msg, 1);
-       if (ret < 0)
-               goto err;
-
-       msg.flags = I2C_M_RD;
-       ret = i2c_transfer(client->adapter, &msg, 1);
-       if (ret < 0)
-               goto err;
-
-       *val = data;
-       return 0;
-
-err:
-       dev_err(&client->dev, "Failed reading register 0x%02x!\n", reg);
-       return ret;
-}
-
-/* write a register */
-static int ov6650_reg_write(struct i2c_client *client, u8 reg, u8 val)
-{
-       int ret;
-       unsigned char data[2] = { reg, val };
-       struct i2c_msg msg = {
-               .addr   = client->addr,
-               .flags  = 0,
-               .len    = 2,
-               .buf    = data,
-       };
-
-       ret = i2c_transfer(client->adapter, &msg, 1);
-       udelay(100);
-
-       if (ret < 0) {
-               dev_err(&client->dev, "Failed writing register 0x%02x!\n", reg);
-               return ret;
-       }
-       return 0;
-}
-
-
-/* Read a register, alter its bits, write it back */
-static int ov6650_reg_rmw(struct i2c_client *client, u8 reg, u8 set, u8 mask)
-{
-       u8 val;
-       int ret;
-
-       ret = ov6650_reg_read(client, reg, &val);
-       if (ret) {
-               dev_err(&client->dev,
-                       "[Read]-Modify-Write of register 0x%02x failed!\n",
-                       reg);
-               return ret;
-       }
-
-       val &= ~mask;
-       val |= set;
-
-       ret = ov6650_reg_write(client, reg, val);
-       if (ret)
-               dev_err(&client->dev,
-                       "Read-Modify-[Write] of register 0x%02x failed!\n",
-                       reg);
-
-       return ret;
-}
-
-static struct ov6650 *to_ov6650(const struct i2c_client *client)
-{
-       return container_of(i2c_get_clientdata(client), struct ov6650, subdev);
-}
-
-/* Start/Stop streaming from the device */
-static int ov6650_s_stream(struct v4l2_subdev *sd, int enable)
-{
-       return 0;
-}
-
-/* Get status of additional camera capabilities */
-static int ov6550_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
-{
-       struct ov6650 *priv = container_of(ctrl->handler, struct ov6650, hdl);
-       struct v4l2_subdev *sd = &priv->subdev;
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       uint8_t reg, reg2;
-       int ret;
-
-       switch (ctrl->id) {
-       case V4L2_CID_AUTOGAIN:
-               ret = ov6650_reg_read(client, REG_GAIN, &reg);
-               if (!ret)
-                       priv->gain->val = reg;
-               return ret;
-       case V4L2_CID_AUTO_WHITE_BALANCE:
-               ret = ov6650_reg_read(client, REG_BLUE, &reg);
-               if (!ret)
-                       ret = ov6650_reg_read(client, REG_RED, &reg2);
-               if (!ret) {
-                       priv->blue->val = reg;
-                       priv->red->val = reg2;
-               }
-               return ret;
-       case V4L2_CID_EXPOSURE_AUTO:
-               ret = ov6650_reg_read(client, REG_AECH, &reg);
-               if (!ret)
-                       priv->exposure->val = reg;
-               return ret;
-       }
-       return -EINVAL;
-}
-
-/* Set status of additional camera capabilities */
-static int ov6550_s_ctrl(struct v4l2_ctrl *ctrl)
-{
-       struct ov6650 *priv = container_of(ctrl->handler, struct ov6650, hdl);
-       struct v4l2_subdev *sd = &priv->subdev;
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       int ret;
-
-       switch (ctrl->id) {
-       case V4L2_CID_AUTOGAIN:
-               ret = ov6650_reg_rmw(client, REG_COMB,
-                               ctrl->val ? COMB_AGC : 0, COMB_AGC);
-               if (!ret && !ctrl->val)
-                       ret = ov6650_reg_write(client, REG_GAIN, priv->gain->val);
-               return ret;
-       case V4L2_CID_AUTO_WHITE_BALANCE:
-               ret = ov6650_reg_rmw(client, REG_COMB,
-                               ctrl->val ? COMB_AWB : 0, COMB_AWB);
-               if (!ret && !ctrl->val) {
-                       ret = ov6650_reg_write(client, REG_BLUE, priv->blue->val);
-                       if (!ret)
-                               ret = ov6650_reg_write(client, REG_RED,
-                                                       priv->red->val);
-               }
-               return ret;
-       case V4L2_CID_SATURATION:
-               return ov6650_reg_rmw(client, REG_SAT, SET_SAT(ctrl->val),
-                               SAT_MASK);
-       case V4L2_CID_HUE:
-               return ov6650_reg_rmw(client, REG_HUE, SET_HUE(ctrl->val),
-                               HUE_MASK);
-       case V4L2_CID_BRIGHTNESS:
-               return ov6650_reg_write(client, REG_BRT, ctrl->val);
-       case V4L2_CID_EXPOSURE_AUTO:
-               ret = ov6650_reg_rmw(client, REG_COMB, ctrl->val ==
-                               V4L2_EXPOSURE_AUTO ? COMB_AEC : 0, COMB_AEC);
-               if (!ret && ctrl->val == V4L2_EXPOSURE_MANUAL)
-                       ret = ov6650_reg_write(client, REG_AECH,
-                                               priv->exposure->val);
-               return ret;
-       case V4L2_CID_GAMMA:
-               return ov6650_reg_write(client, REG_GAM1, ctrl->val);
-       case V4L2_CID_VFLIP:
-               return ov6650_reg_rmw(client, REG_COMB,
-                               ctrl->val ? COMB_FLIP_V : 0, COMB_FLIP_V);
-       case V4L2_CID_HFLIP:
-               return ov6650_reg_rmw(client, REG_COMB,
-                               ctrl->val ? COMB_FLIP_H : 0, COMB_FLIP_H);
-       }
-
-       return -EINVAL;
-}
-
-/* Get chip identification */
-static int ov6650_g_chip_ident(struct v4l2_subdev *sd,
-                               struct v4l2_dbg_chip_ident *id)
-{
-       id->ident       = V4L2_IDENT_OV6650;
-       id->revision    = 0;
-
-       return 0;
-}
-
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-static int ov6650_get_register(struct v4l2_subdev *sd,
-                               struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       int ret;
-       u8 val;
-
-       if (reg->reg & ~0xff)
-               return -EINVAL;
-
-       reg->size = 1;
-
-       ret = ov6650_reg_read(client, reg->reg, &val);
-       if (!ret)
-               reg->val = (__u64)val;
-
-       return ret;
-}
-
-static int ov6650_set_register(struct v4l2_subdev *sd,
-                               struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-
-       if (reg->reg & ~0xff || reg->val & ~0xff)
-               return -EINVAL;
-
-       return ov6650_reg_write(client, reg->reg, reg->val);
-}
-#endif
-
-static int ov6650_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct ov6650 *priv = to_ov6650(client);
-
-       a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-       a->c = priv->rect;
-
-       return 0;
-}
-
-static int ov6650_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct ov6650 *priv = to_ov6650(client);
-       struct v4l2_rect *rect = &a->c;
-       int ret;
-
-       if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-               return -EINVAL;
-
-       rect->left   = ALIGN(rect->left,   2);
-       rect->width  = ALIGN(rect->width,  2);
-       rect->top    = ALIGN(rect->top,    2);
-       rect->height = ALIGN(rect->height, 2);
-       soc_camera_limit_side(&rect->left, &rect->width,
-                       DEF_HSTRT << 1, 2, W_CIF);
-       soc_camera_limit_side(&rect->top, &rect->height,
-                       DEF_VSTRT << 1, 2, H_CIF);
-
-       ret = ov6650_reg_write(client, REG_HSTRT, rect->left >> 1);
-       if (!ret) {
-               priv->rect.left = rect->left;
-               ret = ov6650_reg_write(client, REG_HSTOP,
-                               (rect->left + rect->width) >> 1);
-       }
-       if (!ret) {
-               priv->rect.width = rect->width;
-               ret = ov6650_reg_write(client, REG_VSTRT, rect->top >> 1);
-       }
-       if (!ret) {
-               priv->rect.top = rect->top;
-               ret = ov6650_reg_write(client, REG_VSTOP,
-                               (rect->top + rect->height) >> 1);
-       }
-       if (!ret)
-               priv->rect.height = rect->height;
-
-       return ret;
-}
-
-static int ov6650_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
-{
-       if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-               return -EINVAL;
-
-       a->bounds.left                  = DEF_HSTRT << 1;
-       a->bounds.top                   = DEF_VSTRT << 1;
-       a->bounds.width                 = W_CIF;
-       a->bounds.height                = H_CIF;
-       a->defrect                      = a->bounds;
-       a->pixelaspect.numerator        = 1;
-       a->pixelaspect.denominator      = 1;
-
-       return 0;
-}
-
-static int ov6650_g_fmt(struct v4l2_subdev *sd,
-                        struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct ov6650 *priv = to_ov6650(client);
-
-       mf->width       = priv->rect.width >> priv->half_scale;
-       mf->height      = priv->rect.height >> priv->half_scale;
-       mf->code        = priv->code;
-       mf->colorspace  = priv->colorspace;
-       mf->field       = V4L2_FIELD_NONE;
-
-       return 0;
-}
-
-static bool is_unscaled_ok(int width, int height, struct v4l2_rect *rect)
-{
-       return width > rect->width >> 1 || height > rect->height >> 1;
-}
-
-static u8 to_clkrc(struct v4l2_fract *timeperframe,
-               unsigned long pclk_limit, unsigned long pclk_max)
-{
-       unsigned long pclk;
-
-       if (timeperframe->numerator && timeperframe->denominator)
-               pclk = pclk_max * timeperframe->denominator /
-                               (FRAME_RATE_MAX * timeperframe->numerator);
-       else
-               pclk = pclk_max;
-
-       if (pclk_limit && pclk_limit < pclk)
-               pclk = pclk_limit;
-
-       return (pclk_max - 1) / pclk;
-}
-
-/* set the format we will capture in */
-static int ov6650_s_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct soc_camera_device *icd = v4l2_get_subdev_hostdata(sd);
-       struct soc_camera_sense *sense = icd->sense;
-       struct ov6650 *priv = to_ov6650(client);
-       bool half_scale = !is_unscaled_ok(mf->width, mf->height, &priv->rect);
-       struct v4l2_crop a = {
-               .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
-               .c = {
-                       .left   = priv->rect.left + (priv->rect.width >> 1) -
-                                       (mf->width >> (1 - half_scale)),
-                       .top    = priv->rect.top + (priv->rect.height >> 1) -
-                                       (mf->height >> (1 - half_scale)),
-                       .width  = mf->width << half_scale,
-                       .height = mf->height << half_scale,
-               },
-       };
-       enum v4l2_mbus_pixelcode code = mf->code;
-       unsigned long mclk, pclk;
-       u8 coma_set = 0, coma_mask = 0, coml_set, coml_mask, clkrc;
-       int ret;
-
-       /* select color matrix configuration for given color encoding */
-       switch (code) {
-       case V4L2_MBUS_FMT_Y8_1X8:
-               dev_dbg(&client->dev, "pixel format GREY8_1X8\n");
-               coma_mask |= COMA_RGB | COMA_WORD_SWAP | COMA_BYTE_SWAP;
-               coma_set |= COMA_BW;
-               break;
-       case V4L2_MBUS_FMT_YUYV8_2X8:
-               dev_dbg(&client->dev, "pixel format YUYV8_2X8_LE\n");
-               coma_mask |= COMA_RGB | COMA_BW | COMA_BYTE_SWAP;
-               coma_set |= COMA_WORD_SWAP;
-               break;
-       case V4L2_MBUS_FMT_YVYU8_2X8:
-               dev_dbg(&client->dev, "pixel format YVYU8_2X8_LE (untested)\n");
-               coma_mask |= COMA_RGB | COMA_BW | COMA_WORD_SWAP |
-                               COMA_BYTE_SWAP;
-               break;
-       case V4L2_MBUS_FMT_UYVY8_2X8:
-               dev_dbg(&client->dev, "pixel format YUYV8_2X8_BE\n");
-               if (half_scale) {
-                       coma_mask |= COMA_RGB | COMA_BW | COMA_WORD_SWAP;
-                       coma_set |= COMA_BYTE_SWAP;
-               } else {
-                       coma_mask |= COMA_RGB | COMA_BW;
-                       coma_set |= COMA_BYTE_SWAP | COMA_WORD_SWAP;
-               }
-               break;
-       case V4L2_MBUS_FMT_VYUY8_2X8:
-               dev_dbg(&client->dev, "pixel format YVYU8_2X8_BE (untested)\n");
-               if (half_scale) {
-                       coma_mask |= COMA_RGB | COMA_BW;
-                       coma_set |= COMA_BYTE_SWAP | COMA_WORD_SWAP;
-               } else {
-                       coma_mask |= COMA_RGB | COMA_BW | COMA_WORD_SWAP;
-                       coma_set |= COMA_BYTE_SWAP;
-               }
-               break;
-       case V4L2_MBUS_FMT_SBGGR8_1X8:
-               dev_dbg(&client->dev, "pixel format SBGGR8_1X8 (untested)\n");
-               coma_mask |= COMA_BW | COMA_BYTE_SWAP | COMA_WORD_SWAP;
-               coma_set |= COMA_RAW_RGB | COMA_RGB;
-               break;
-       default:
-               dev_err(&client->dev, "Pixel format not handled: 0x%x\n", code);
-               return -EINVAL;
-       }
-       priv->code = code;
-
-       if (code == V4L2_MBUS_FMT_Y8_1X8 ||
-                       code == V4L2_MBUS_FMT_SBGGR8_1X8) {
-               coml_mask = COML_ONE_CHANNEL;
-               coml_set = 0;
-               priv->pclk_max = 4000000;
-       } else {
-               coml_mask = 0;
-               coml_set = COML_ONE_CHANNEL;
-               priv->pclk_max = 8000000;
-       }
-
-       if (code == V4L2_MBUS_FMT_SBGGR8_1X8)
-               priv->colorspace = V4L2_COLORSPACE_SRGB;
-       else if (code != 0)
-               priv->colorspace = V4L2_COLORSPACE_JPEG;
-
-       if (half_scale) {
-               dev_dbg(&client->dev, "max resolution: QCIF\n");
-               coma_set |= COMA_QCIF;
-               priv->pclk_max /= 2;
-       } else {
-               dev_dbg(&client->dev, "max resolution: CIF\n");
-               coma_mask |= COMA_QCIF;
-       }
-       priv->half_scale = half_scale;
-
-       if (sense) {
-               if (sense->master_clock == 8000000) {
-                       dev_dbg(&client->dev, "8MHz input clock\n");
-                       clkrc = CLKRC_6MHz;
-               } else if (sense->master_clock == 12000000) {
-                       dev_dbg(&client->dev, "12MHz input clock\n");
-                       clkrc = CLKRC_12MHz;
-               } else if (sense->master_clock == 16000000) {
-                       dev_dbg(&client->dev, "16MHz input clock\n");
-                       clkrc = CLKRC_16MHz;
-               } else if (sense->master_clock == 24000000) {
-                       dev_dbg(&client->dev, "24MHz input clock\n");
-                       clkrc = CLKRC_24MHz;
-               } else {
-                       dev_err(&client->dev,
-                               "unsupported input clock, check platform data\n");
-                       return -EINVAL;
-               }
-               mclk = sense->master_clock;
-               priv->pclk_limit = sense->pixel_clock_max;
-       } else {
-               clkrc = CLKRC_24MHz;
-               mclk = 24000000;
-               priv->pclk_limit = 0;
-               dev_dbg(&client->dev, "using default 24MHz input clock\n");
-       }
-
-       clkrc |= to_clkrc(&priv->tpf, priv->pclk_limit, priv->pclk_max);
-
-       pclk = priv->pclk_max / GET_CLKRC_DIV(clkrc);
-       dev_dbg(&client->dev, "pixel clock divider: %ld.%ld\n",
-                       mclk / pclk, 10 * mclk % pclk / pclk);
-
-       ret = ov6650_s_crop(sd, &a);
-       if (!ret)
-               ret = ov6650_reg_rmw(client, REG_COMA, coma_set, coma_mask);
-       if (!ret)
-               ret = ov6650_reg_write(client, REG_CLKRC, clkrc);
-       if (!ret)
-               ret = ov6650_reg_rmw(client, REG_COML, coml_set, coml_mask);
-
-       if (!ret) {
-               mf->colorspace  = priv->colorspace;
-               mf->width = priv->rect.width >> half_scale;
-               mf->height = priv->rect.height >> half_scale;
-       }
-
-       return ret;
-}
-
-static int ov6650_try_fmt(struct v4l2_subdev *sd,
-                         struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct ov6650 *priv = to_ov6650(client);
-
-       if (is_unscaled_ok(mf->width, mf->height, &priv->rect))
-               v4l_bound_align_image(&mf->width, 2, W_CIF, 1,
-                               &mf->height, 2, H_CIF, 1, 0);
-
-       mf->field = V4L2_FIELD_NONE;
-
-       switch (mf->code) {
-       case V4L2_MBUS_FMT_Y10_1X10:
-               mf->code = V4L2_MBUS_FMT_Y8_1X8;
-       case V4L2_MBUS_FMT_Y8_1X8:
-       case V4L2_MBUS_FMT_YVYU8_2X8:
-       case V4L2_MBUS_FMT_YUYV8_2X8:
-       case V4L2_MBUS_FMT_VYUY8_2X8:
-       case V4L2_MBUS_FMT_UYVY8_2X8:
-               mf->colorspace = V4L2_COLORSPACE_JPEG;
-               break;
-       default:
-               mf->code = V4L2_MBUS_FMT_SBGGR8_1X8;
-       case V4L2_MBUS_FMT_SBGGR8_1X8:
-               mf->colorspace = V4L2_COLORSPACE_SRGB;
-               break;
-       }
-
-       return 0;
-}
-
-static int ov6650_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                          enum v4l2_mbus_pixelcode *code)
-{
-       if (index >= ARRAY_SIZE(ov6650_codes))
-               return -EINVAL;
-
-       *code = ov6650_codes[index];
-       return 0;
-}
-
-static int ov6650_g_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *parms)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct ov6650 *priv = to_ov6650(client);
-       struct v4l2_captureparm *cp = &parms->parm.capture;
-
-       if (parms->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-               return -EINVAL;
-
-       memset(cp, 0, sizeof(*cp));
-       cp->capability = V4L2_CAP_TIMEPERFRAME;
-       cp->timeperframe.numerator = GET_CLKRC_DIV(to_clkrc(&priv->tpf,
-                       priv->pclk_limit, priv->pclk_max));
-       cp->timeperframe.denominator = FRAME_RATE_MAX;
-
-       dev_dbg(&client->dev, "Frame interval: %u/%u s\n",
-               cp->timeperframe.numerator, cp->timeperframe.denominator);
-
-       return 0;
-}
-
-static int ov6650_s_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *parms)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct ov6650 *priv = to_ov6650(client);
-       struct v4l2_captureparm *cp = &parms->parm.capture;
-       struct v4l2_fract *tpf = &cp->timeperframe;
-       int div, ret;
-       u8 clkrc;
-
-       if (parms->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-               return -EINVAL;
-
-       if (cp->extendedmode != 0)
-               return -EINVAL;
-
-       if (tpf->numerator == 0 || tpf->denominator == 0)
-               div = 1;  /* Reset to full rate */
-       else
-               div = (tpf->numerator * FRAME_RATE_MAX) / tpf->denominator;
-
-       if (div == 0)
-               div = 1;
-       else if (div > GET_CLKRC_DIV(CLKRC_DIV_MASK))
-               div = GET_CLKRC_DIV(CLKRC_DIV_MASK);
-
-       /*
-        * Keep result to be used as tpf limit
-        * for subseqent clock divider calculations
-        */
-       priv->tpf.numerator = div;
-       priv->tpf.denominator = FRAME_RATE_MAX;
-
-       clkrc = to_clkrc(&priv->tpf, priv->pclk_limit, priv->pclk_max);
-
-       ret = ov6650_reg_rmw(client, REG_CLKRC, clkrc, CLKRC_DIV_MASK);
-       if (!ret) {
-               tpf->numerator = GET_CLKRC_DIV(clkrc);
-               tpf->denominator = FRAME_RATE_MAX;
-       }
-
-       return ret;
-}
-
-/* Soft reset the camera. This has nothing to do with the RESET pin! */
-static int ov6650_reset(struct i2c_client *client)
-{
-       int ret;
-
-       dev_dbg(&client->dev, "reset\n");
-
-       ret = ov6650_reg_rmw(client, REG_COMA, COMA_RESET, 0);
-       if (ret)
-               dev_err(&client->dev,
-                       "An error occurred while entering soft reset!\n");
-
-       return ret;
-}
-
-/* program default register values */
-static int ov6650_prog_dflt(struct i2c_client *client)
-{
-       int ret;
-
-       dev_dbg(&client->dev, "initializing\n");
-
-       ret = ov6650_reg_write(client, REG_COMA, 0);    /* ~COMA_RESET */
-       if (!ret)
-               ret = ov6650_reg_rmw(client, REG_COMB, 0, COMB_BAND_FILTER);
-
-       return ret;
-}
-
-static int ov6650_video_probe(struct i2c_client *client)
-{
-       u8              pidh, pidl, midh, midl;
-       int             ret = 0;
-
-       /*
-        * check and show product ID and manufacturer ID
-        */
-       ret = ov6650_reg_read(client, REG_PIDH, &pidh);
-       if (!ret)
-               ret = ov6650_reg_read(client, REG_PIDL, &pidl);
-       if (!ret)
-               ret = ov6650_reg_read(client, REG_MIDH, &midh);
-       if (!ret)
-               ret = ov6650_reg_read(client, REG_MIDL, &midl);
-
-       if (ret)
-               return ret;
-
-       if ((pidh != OV6650_PIDH) || (pidl != OV6650_PIDL)) {
-               dev_err(&client->dev, "Product ID error 0x%02x:0x%02x\n",
-                               pidh, pidl);
-               return -ENODEV;
-       }
-
-       dev_info(&client->dev,
-               "ov6650 Product ID 0x%02x:0x%02x Manufacturer ID 0x%02x:0x%02x\n",
-               pidh, pidl, midh, midl);
-
-       ret = ov6650_reset(client);
-       if (!ret)
-               ret = ov6650_prog_dflt(client);
-
-       return ret;
-}
-
-static const struct v4l2_ctrl_ops ov6550_ctrl_ops = {
-       .g_volatile_ctrl = ov6550_g_volatile_ctrl,
-       .s_ctrl = ov6550_s_ctrl,
-};
-
-static struct v4l2_subdev_core_ops ov6650_core_ops = {
-       .g_chip_ident           = ov6650_g_chip_ident,
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-       .g_register             = ov6650_get_register,
-       .s_register             = ov6650_set_register,
-#endif
-};
-
-/* Request bus settings on camera side */
-static int ov6650_g_mbus_config(struct v4l2_subdev *sd,
-                               struct v4l2_mbus_config *cfg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-
-       cfg->flags = V4L2_MBUS_MASTER |
-               V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_PCLK_SAMPLE_FALLING |
-               V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_HSYNC_ACTIVE_LOW |
-               V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_LOW |
-               V4L2_MBUS_DATA_ACTIVE_HIGH;
-       cfg->type = V4L2_MBUS_PARALLEL;
-       cfg->flags = soc_camera_apply_board_flags(icl, cfg);
-
-       return 0;
-}
-
-/* Alter bus settings on camera side */
-static int ov6650_s_mbus_config(struct v4l2_subdev *sd,
-                               const struct v4l2_mbus_config *cfg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-       unsigned long flags = soc_camera_apply_board_flags(icl, cfg);
-       int ret;
-
-       if (flags & V4L2_MBUS_PCLK_SAMPLE_RISING)
-               ret = ov6650_reg_rmw(client, REG_COMJ, COMJ_PCLK_RISING, 0);
-       else
-               ret = ov6650_reg_rmw(client, REG_COMJ, 0, COMJ_PCLK_RISING);
-       if (ret)
-               return ret;
-
-       if (flags & V4L2_MBUS_HSYNC_ACTIVE_LOW)
-               ret = ov6650_reg_rmw(client, REG_COMF, COMF_HREF_LOW, 0);
-       else
-               ret = ov6650_reg_rmw(client, REG_COMF, 0, COMF_HREF_LOW);
-       if (ret)
-               return ret;
-
-       if (flags & V4L2_MBUS_VSYNC_ACTIVE_HIGH)
-               ret = ov6650_reg_rmw(client, REG_COMJ, COMJ_VSYNC_HIGH, 0);
-       else
-               ret = ov6650_reg_rmw(client, REG_COMJ, 0, COMJ_VSYNC_HIGH);
-
-       return ret;
-}
-
-static struct v4l2_subdev_video_ops ov6650_video_ops = {
-       .s_stream       = ov6650_s_stream,
-       .g_mbus_fmt     = ov6650_g_fmt,
-       .s_mbus_fmt     = ov6650_s_fmt,
-       .try_mbus_fmt   = ov6650_try_fmt,
-       .enum_mbus_fmt  = ov6650_enum_fmt,
-       .cropcap        = ov6650_cropcap,
-       .g_crop         = ov6650_g_crop,
-       .s_crop         = ov6650_s_crop,
-       .g_parm         = ov6650_g_parm,
-       .s_parm         = ov6650_s_parm,
-       .g_mbus_config  = ov6650_g_mbus_config,
-       .s_mbus_config  = ov6650_s_mbus_config,
-};
-
-static struct v4l2_subdev_ops ov6650_subdev_ops = {
-       .core   = &ov6650_core_ops,
-       .video  = &ov6650_video_ops,
-};
-
-/*
- * i2c_driver function
- */
-static int ov6650_probe(struct i2c_client *client,
-                       const struct i2c_device_id *did)
-{
-       struct ov6650 *priv;
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-       int ret;
-
-       if (!icl) {
-               dev_err(&client->dev, "Missing platform_data for driver\n");
-               return -EINVAL;
-       }
-
-       priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-       if (!priv) {
-               dev_err(&client->dev,
-                       "Failed to allocate memory for private data!\n");
-               return -ENOMEM;
-       }
-
-       v4l2_i2c_subdev_init(&priv->subdev, client, &ov6650_subdev_ops);
-       v4l2_ctrl_handler_init(&priv->hdl, 13);
-       v4l2_ctrl_new_std(&priv->hdl, &ov6550_ctrl_ops,
-                       V4L2_CID_VFLIP, 0, 1, 1, 0);
-       v4l2_ctrl_new_std(&priv->hdl, &ov6550_ctrl_ops,
-                       V4L2_CID_HFLIP, 0, 1, 1, 0);
-       priv->autogain = v4l2_ctrl_new_std(&priv->hdl, &ov6550_ctrl_ops,
-                       V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
-       priv->gain = v4l2_ctrl_new_std(&priv->hdl, &ov6550_ctrl_ops,
-                       V4L2_CID_GAIN, 0, 0x3f, 1, DEF_GAIN);
-       priv->autowb = v4l2_ctrl_new_std(&priv->hdl, &ov6550_ctrl_ops,
-                       V4L2_CID_AUTO_WHITE_BALANCE, 0, 1, 1, 1);
-       priv->blue = v4l2_ctrl_new_std(&priv->hdl, &ov6550_ctrl_ops,
-                       V4L2_CID_BLUE_BALANCE, 0, 0xff, 1, DEF_BLUE);
-       priv->red = v4l2_ctrl_new_std(&priv->hdl, &ov6550_ctrl_ops,
-                       V4L2_CID_RED_BALANCE, 0, 0xff, 1, DEF_RED);
-       v4l2_ctrl_new_std(&priv->hdl, &ov6550_ctrl_ops,
-                       V4L2_CID_SATURATION, 0, 0xf, 1, 0x8);
-       v4l2_ctrl_new_std(&priv->hdl, &ov6550_ctrl_ops,
-                       V4L2_CID_HUE, 0, HUE_MASK, 1, DEF_HUE);
-       v4l2_ctrl_new_std(&priv->hdl, &ov6550_ctrl_ops,
-                       V4L2_CID_BRIGHTNESS, 0, 0xff, 1, 0x80);
-       priv->autoexposure = v4l2_ctrl_new_std_menu(&priv->hdl,
-                       &ov6550_ctrl_ops, V4L2_CID_EXPOSURE_AUTO,
-                       V4L2_EXPOSURE_MANUAL, 0, V4L2_EXPOSURE_AUTO);
-       priv->exposure = v4l2_ctrl_new_std(&priv->hdl, &ov6550_ctrl_ops,
-                       V4L2_CID_EXPOSURE, 0, 0xff, 1, DEF_AECH);
-       v4l2_ctrl_new_std(&priv->hdl, &ov6550_ctrl_ops,
-                       V4L2_CID_GAMMA, 0, 0xff, 1, 0x12);
-
-       priv->subdev.ctrl_handler = &priv->hdl;
-       if (priv->hdl.error) {
-               int err = priv->hdl.error;
-
-               kfree(priv);
-               return err;
-       }
-       v4l2_ctrl_auto_cluster(2, &priv->autogain, 0, true);
-       v4l2_ctrl_auto_cluster(3, &priv->autowb, 0, true);
-       v4l2_ctrl_auto_cluster(2, &priv->autoexposure,
-                               V4L2_EXPOSURE_MANUAL, true);
-
-       priv->rect.left   = DEF_HSTRT << 1;
-       priv->rect.top    = DEF_VSTRT << 1;
-       priv->rect.width  = W_CIF;
-       priv->rect.height = H_CIF;
-       priv->half_scale  = false;
-       priv->code        = V4L2_MBUS_FMT_YUYV8_2X8;
-       priv->colorspace  = V4L2_COLORSPACE_JPEG;
-
-       ret = ov6650_video_probe(client);
-       if (!ret)
-               ret = v4l2_ctrl_handler_setup(&priv->hdl);
-
-       if (ret) {
-               v4l2_ctrl_handler_free(&priv->hdl);
-               kfree(priv);
-       }
-
-       return ret;
-}
-
-static int ov6650_remove(struct i2c_client *client)
-{
-       struct ov6650 *priv = to_ov6650(client);
-
-       v4l2_device_unregister_subdev(&priv->subdev);
-       v4l2_ctrl_handler_free(&priv->hdl);
-       kfree(priv);
-       return 0;
-}
-
-static const struct i2c_device_id ov6650_id[] = {
-       { "ov6650", 0 },
-       { }
-};
-MODULE_DEVICE_TABLE(i2c, ov6650_id);
-
-static struct i2c_driver ov6650_i2c_driver = {
-       .driver = {
-               .name = "ov6650",
-       },
-       .probe    = ov6650_probe,
-       .remove   = ov6650_remove,
-       .id_table = ov6650_id,
-};
-
-module_i2c_driver(ov6650_i2c_driver);
-
-MODULE_DESCRIPTION("SoC Camera driver for OmniVision OV6650");
-MODULE_AUTHOR("Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/video/ov772x.c b/drivers/media/video/ov772x.c
deleted file mode 100644 (file)
index 6d79b89..0000000
+++ /dev/null
@@ -1,1126 +0,0 @@
-/*
- * ov772x Camera Driver
- *
- * Copyright (C) 2008 Renesas Solutions Corp.
- * Kuninori Morimoto <morimoto.kuninori@renesas.com>
- *
- * Based on ov7670 and soc_camera_platform driver,
- *
- * Copyright 2006-7 Jonathan Corbet <corbet@lwn.net>
- * Copyright (C) 2008 Magnus Damm
- * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/i2c.h>
-#include <linux/slab.h>
-#include <linux/delay.h>
-#include <linux/v4l2-mediabus.h>
-#include <linux/videodev2.h>
-
-#include <media/ov772x.h>
-#include <media/soc_camera.h>
-#include <media/v4l2-ctrls.h>
-#include <media/v4l2-chip-ident.h>
-#include <media/v4l2-subdev.h>
-
-/*
- * register offset
- */
-#define GAIN        0x00 /* AGC - Gain control gain setting */
-#define BLUE        0x01 /* AWB - Blue channel gain setting */
-#define RED         0x02 /* AWB - Red   channel gain setting */
-#define GREEN       0x03 /* AWB - Green channel gain setting */
-#define COM1        0x04 /* Common control 1 */
-#define BAVG        0x05 /* U/B Average Level */
-#define GAVG        0x06 /* Y/Gb Average Level */
-#define RAVG        0x07 /* V/R Average Level */
-#define AECH        0x08 /* Exposure Value - AEC MSBs */
-#define COM2        0x09 /* Common control 2 */
-#define PID         0x0A /* Product ID Number MSB */
-#define VER         0x0B /* Product ID Number LSB */
-#define COM3        0x0C /* Common control 3 */
-#define COM4        0x0D /* Common control 4 */
-#define COM5        0x0E /* Common control 5 */
-#define COM6        0x0F /* Common control 6 */
-#define AEC         0x10 /* Exposure Value */
-#define CLKRC       0x11 /* Internal clock */
-#define COM7        0x12 /* Common control 7 */
-#define COM8        0x13 /* Common control 8 */
-#define COM9        0x14 /* Common control 9 */
-#define COM10       0x15 /* Common control 10 */
-#define REG16       0x16 /* Register 16 */
-#define HSTART      0x17 /* Horizontal sensor size */
-#define HSIZE       0x18 /* Horizontal frame (HREF column) end high 8-bit */
-#define VSTART      0x19 /* Vertical frame (row) start high 8-bit */
-#define VSIZE       0x1A /* Vertical sensor size */
-#define PSHFT       0x1B /* Data format - pixel delay select */
-#define MIDH        0x1C /* Manufacturer ID byte - high */
-#define MIDL        0x1D /* Manufacturer ID byte - low  */
-#define LAEC        0x1F /* Fine AEC value */
-#define COM11       0x20 /* Common control 11 */
-#define BDBASE      0x22 /* Banding filter Minimum AEC value */
-#define DBSTEP      0x23 /* Banding filter Maximum Setp */
-#define AEW         0x24 /* AGC/AEC - Stable operating region (upper limit) */
-#define AEB         0x25 /* AGC/AEC - Stable operating region (lower limit) */
-#define VPT         0x26 /* AGC/AEC Fast mode operating region */
-#define REG28       0x28 /* Register 28 */
-#define HOUTSIZE    0x29 /* Horizontal data output size MSBs */
-#define EXHCH       0x2A /* Dummy pixel insert MSB */
-#define EXHCL       0x2B /* Dummy pixel insert LSB */
-#define VOUTSIZE    0x2C /* Vertical data output size MSBs */
-#define ADVFL       0x2D /* LSB of insert dummy lines in Vertical direction */
-#define ADVFH       0x2E /* MSG of insert dummy lines in Vertical direction */
-#define YAVE        0x2F /* Y/G Channel Average value */
-#define LUMHTH      0x30 /* Histogram AEC/AGC Luminance high level threshold */
-#define LUMLTH      0x31 /* Histogram AEC/AGC Luminance low  level threshold */
-#define HREF        0x32 /* Image start and size control */
-#define DM_LNL      0x33 /* Dummy line low  8 bits */
-#define DM_LNH      0x34 /* Dummy line high 8 bits */
-#define ADOFF_B     0x35 /* AD offset compensation value for B  channel */
-#define ADOFF_R     0x36 /* AD offset compensation value for R  channel */
-#define ADOFF_GB    0x37 /* AD offset compensation value for Gb channel */
-#define ADOFF_GR    0x38 /* AD offset compensation value for Gr channel */
-#define OFF_B       0x39 /* Analog process B  channel offset value */
-#define OFF_R       0x3A /* Analog process R  channel offset value */
-#define OFF_GB      0x3B /* Analog process Gb channel offset value */
-#define OFF_GR      0x3C /* Analog process Gr channel offset value */
-#define COM12       0x3D /* Common control 12 */
-#define COM13       0x3E /* Common control 13 */
-#define COM14       0x3F /* Common control 14 */
-#define COM15       0x40 /* Common control 15*/
-#define COM16       0x41 /* Common control 16 */
-#define TGT_B       0x42 /* BLC blue channel target value */
-#define TGT_R       0x43 /* BLC red  channel target value */
-#define TGT_GB      0x44 /* BLC Gb   channel target value */
-#define TGT_GR      0x45 /* BLC Gr   channel target value */
-/* for ov7720 */
-#define LCC0        0x46 /* Lens correction control 0 */
-#define LCC1        0x47 /* Lens correction option 1 - X coordinate */
-#define LCC2        0x48 /* Lens correction option 2 - Y coordinate */
-#define LCC3        0x49 /* Lens correction option 3 */
-#define LCC4        0x4A /* Lens correction option 4 - radius of the circular */
-#define LCC5        0x4B /* Lens correction option 5 */
-#define LCC6        0x4C /* Lens correction option 6 */
-/* for ov7725 */
-#define LC_CTR      0x46 /* Lens correction control */
-#define LC_XC       0x47 /* X coordinate of lens correction center relative */
-#define LC_YC       0x48 /* Y coordinate of lens correction center relative */
-#define LC_COEF     0x49 /* Lens correction coefficient */
-#define LC_RADI     0x4A /* Lens correction radius */
-#define LC_COEFB    0x4B /* Lens B channel compensation coefficient */
-#define LC_COEFR    0x4C /* Lens R channel compensation coefficient */
-
-#define FIXGAIN     0x4D /* Analog fix gain amplifer */
-#define AREF0       0x4E /* Sensor reference control */
-#define AREF1       0x4F /* Sensor reference current control */
-#define AREF2       0x50 /* Analog reference control */
-#define AREF3       0x51 /* ADC    reference control */
-#define AREF4       0x52 /* ADC    reference control */
-#define AREF5       0x53 /* ADC    reference control */
-#define AREF6       0x54 /* Analog reference control */
-#define AREF7       0x55 /* Analog reference control */
-#define UFIX        0x60 /* U channel fixed value output */
-#define VFIX        0x61 /* V channel fixed value output */
-#define AWBB_BLK    0x62 /* AWB option for advanced AWB */
-#define AWB_CTRL0   0x63 /* AWB control byte 0 */
-#define DSP_CTRL1   0x64 /* DSP control byte 1 */
-#define DSP_CTRL2   0x65 /* DSP control byte 2 */
-#define DSP_CTRL3   0x66 /* DSP control byte 3 */
-#define DSP_CTRL4   0x67 /* DSP control byte 4 */
-#define AWB_BIAS    0x68 /* AWB BLC level clip */
-#define AWB_CTRL1   0x69 /* AWB control  1 */
-#define AWB_CTRL2   0x6A /* AWB control  2 */
-#define AWB_CTRL3   0x6B /* AWB control  3 */
-#define AWB_CTRL4   0x6C /* AWB control  4 */
-#define AWB_CTRL5   0x6D /* AWB control  5 */
-#define AWB_CTRL6   0x6E /* AWB control  6 */
-#define AWB_CTRL7   0x6F /* AWB control  7 */
-#define AWB_CTRL8   0x70 /* AWB control  8 */
-#define AWB_CTRL9   0x71 /* AWB control  9 */
-#define AWB_CTRL10  0x72 /* AWB control 10 */
-#define AWB_CTRL11  0x73 /* AWB control 11 */
-#define AWB_CTRL12  0x74 /* AWB control 12 */
-#define AWB_CTRL13  0x75 /* AWB control 13 */
-#define AWB_CTRL14  0x76 /* AWB control 14 */
-#define AWB_CTRL15  0x77 /* AWB control 15 */
-#define AWB_CTRL16  0x78 /* AWB control 16 */
-#define AWB_CTRL17  0x79 /* AWB control 17 */
-#define AWB_CTRL18  0x7A /* AWB control 18 */
-#define AWB_CTRL19  0x7B /* AWB control 19 */
-#define AWB_CTRL20  0x7C /* AWB control 20 */
-#define AWB_CTRL21  0x7D /* AWB control 21 */
-#define GAM1        0x7E /* Gamma Curve  1st segment input end point */
-#define GAM2        0x7F /* Gamma Curve  2nd segment input end point */
-#define GAM3        0x80 /* Gamma Curve  3rd segment input end point */
-#define GAM4        0x81 /* Gamma Curve  4th segment input end point */
-#define GAM5        0x82 /* Gamma Curve  5th segment input end point */
-#define GAM6        0x83 /* Gamma Curve  6th segment input end point */
-#define GAM7        0x84 /* Gamma Curve  7th segment input end point */
-#define GAM8        0x85 /* Gamma Curve  8th segment input end point */
-#define GAM9        0x86 /* Gamma Curve  9th segment input end point */
-#define GAM10       0x87 /* Gamma Curve 10th segment input end point */
-#define GAM11       0x88 /* Gamma Curve 11th segment input end point */
-#define GAM12       0x89 /* Gamma Curve 12th segment input end point */
-#define GAM13       0x8A /* Gamma Curve 13th segment input end point */
-#define GAM14       0x8B /* Gamma Curve 14th segment input end point */
-#define GAM15       0x8C /* Gamma Curve 15th segment input end point */
-#define SLOP        0x8D /* Gamma curve highest segment slope */
-#define DNSTH       0x8E /* De-noise threshold */
-#define EDGE_STRNGT 0x8F /* Edge strength  control when manual mode */
-#define EDGE_TRSHLD 0x90 /* Edge threshold control when manual mode */
-#define DNSOFF      0x91 /* Auto De-noise threshold control */
-#define EDGE_UPPER  0x92 /* Edge strength upper limit when Auto mode */
-#define EDGE_LOWER  0x93 /* Edge strength lower limit when Auto mode */
-#define MTX1        0x94 /* Matrix coefficient 1 */
-#define MTX2        0x95 /* Matrix coefficient 2 */
-#define MTX3        0x96 /* Matrix coefficient 3 */
-#define MTX4        0x97 /* Matrix coefficient 4 */
-#define MTX5        0x98 /* Matrix coefficient 5 */
-#define MTX6        0x99 /* Matrix coefficient 6 */
-#define MTX_CTRL    0x9A /* Matrix control */
-#define BRIGHT      0x9B /* Brightness control */
-#define CNTRST      0x9C /* Contrast contrast */
-#define CNTRST_CTRL 0x9D /* Contrast contrast center */
-#define UVAD_J0     0x9E /* Auto UV adjust contrast 0 */
-#define UVAD_J1     0x9F /* Auto UV adjust contrast 1 */
-#define SCAL0       0xA0 /* Scaling control 0 */
-#define SCAL1       0xA1 /* Scaling control 1 */
-#define SCAL2       0xA2 /* Scaling control 2 */
-#define FIFODLYM    0xA3 /* FIFO manual mode delay control */
-#define FIFODLYA    0xA4 /* FIFO auto   mode delay control */
-#define SDE         0xA6 /* Special digital effect control */
-#define USAT        0xA7 /* U component saturation control */
-#define VSAT        0xA8 /* V component saturation control */
-/* for ov7720 */
-#define HUE0        0xA9 /* Hue control 0 */
-#define HUE1        0xAA /* Hue control 1 */
-/* for ov7725 */
-#define HUECOS      0xA9 /* Cosine value */
-#define HUESIN      0xAA /* Sine value */
-
-#define SIGN        0xAB /* Sign bit for Hue and contrast */
-#define DSPAUTO     0xAC /* DSP auto function ON/OFF control */
-
-/*
- * register detail
- */
-
-/* COM2 */
-#define SOFT_SLEEP_MODE 0x10   /* Soft sleep mode */
-                               /* Output drive capability */
-#define OCAP_1x         0x00   /* 1x */
-#define OCAP_2x         0x01   /* 2x */
-#define OCAP_3x         0x02   /* 3x */
-#define OCAP_4x         0x03   /* 4x */
-
-/* COM3 */
-#define SWAP_MASK       (SWAP_RGB | SWAP_YUV | SWAP_ML)
-#define IMG_MASK        (VFLIP_IMG | HFLIP_IMG)
-
-#define VFLIP_IMG       0x80   /* Vertical flip image ON/OFF selection */
-#define HFLIP_IMG       0x40   /* Horizontal mirror image ON/OFF selection */
-#define SWAP_RGB        0x20   /* Swap B/R  output sequence in RGB mode */
-#define SWAP_YUV        0x10   /* Swap Y/UV output sequence in YUV mode */
-#define SWAP_ML         0x08   /* Swap output MSB/LSB */
-                               /* Tri-state option for output clock */
-#define NOTRI_CLOCK     0x04   /*   0: Tri-state    at this period */
-                               /*   1: No tri-state at this period */
-                               /* Tri-state option for output data */
-#define NOTRI_DATA      0x02   /*   0: Tri-state    at this period */
-                               /*   1: No tri-state at this period */
-#define SCOLOR_TEST     0x01   /* Sensor color bar test pattern */
-
-/* COM4 */
-                               /* PLL frequency control */
-#define PLL_BYPASS      0x00   /*  00: Bypass PLL */
-#define PLL_4x          0x40   /*  01: PLL 4x */
-#define PLL_6x          0x80   /*  10: PLL 6x */
-#define PLL_8x          0xc0   /*  11: PLL 8x */
-                               /* AEC evaluate window */
-#define AEC_FULL        0x00   /*  00: Full window */
-#define AEC_1p2         0x10   /*  01: 1/2  window */
-#define AEC_1p4         0x20   /*  10: 1/4  window */
-#define AEC_2p3         0x30   /*  11: Low 2/3 window */
-
-/* COM5 */
-#define AFR_ON_OFF      0x80   /* Auto frame rate control ON/OFF selection */
-#define AFR_SPPED       0x40   /* Auto frame rate control speed selection */
-                               /* Auto frame rate max rate control */
-#define AFR_NO_RATE     0x00   /*     No  reduction of frame rate */
-#define AFR_1p2         0x10   /*     Max reduction to 1/2 frame rate */
-#define AFR_1p4         0x20   /*     Max reduction to 1/4 frame rate */
-#define AFR_1p8         0x30   /* Max reduction to 1/8 frame rate */
-                               /* Auto frame rate active point control */
-#define AF_2x           0x00   /*     Add frame when AGC reaches  2x gain */
-#define AF_4x           0x04   /*     Add frame when AGC reaches  4x gain */
-#define AF_8x           0x08   /*     Add frame when AGC reaches  8x gain */
-#define AF_16x          0x0c   /* Add frame when AGC reaches 16x gain */
-                               /* AEC max step control */
-#define AEC_NO_LIMIT    0x01   /*   0 : AEC incease step has limit */
-                               /*   1 : No limit to AEC increase step */
-
-/* COM7 */
-                               /* SCCB Register Reset */
-#define SCCB_RESET      0x80   /*   0 : No change */
-                               /*   1 : Resets all registers to default */
-                               /* Resolution selection */
-#define SLCT_MASK       0x40   /*   Mask of VGA or QVGA */
-#define SLCT_VGA        0x00   /*   0 : VGA */
-#define SLCT_QVGA       0x40   /*   1 : QVGA */
-#define ITU656_ON_OFF   0x20   /* ITU656 protocol ON/OFF selection */
-                               /* RGB output format control */
-#define FMT_MASK        0x0c   /*      Mask of color format */
-#define FMT_GBR422      0x00   /*      00 : GBR 4:2:2 */
-#define FMT_RGB565      0x04   /*      01 : RGB 565 */
-#define FMT_RGB555      0x08   /*      10 : RGB 555 */
-#define FMT_RGB444      0x0c   /* 11 : RGB 444 */
-                               /* Output format control */
-#define OFMT_MASK       0x03    /*      Mask of output format */
-#define OFMT_YUV        0x00   /*      00 : YUV */
-#define OFMT_P_BRAW     0x01   /*      01 : Processed Bayer RAW */
-#define OFMT_RGB        0x02   /*      10 : RGB */
-#define OFMT_BRAW       0x03   /* 11 : Bayer RAW */
-
-/* COM8 */
-#define FAST_ALGO       0x80   /* Enable fast AGC/AEC algorithm */
-                               /* AEC Setp size limit */
-#define UNLMT_STEP      0x40   /*   0 : Step size is limited */
-                               /*   1 : Unlimited step size */
-#define BNDF_ON_OFF     0x20   /* Banding filter ON/OFF */
-#define AEC_BND         0x10   /* Enable AEC below banding value */
-#define AEC_ON_OFF      0x08   /* Fine AEC ON/OFF control */
-#define AGC_ON          0x04   /* AGC Enable */
-#define AWB_ON          0x02   /* AWB Enable */
-#define AEC_ON          0x01   /* AEC Enable */
-
-/* COM9 */
-#define BASE_AECAGC     0x80   /* Histogram or average based AEC/AGC */
-                               /* Automatic gain ceiling - maximum AGC value */
-#define GAIN_2x         0x00   /*    000 :   2x */
-#define GAIN_4x         0x10   /*    001 :   4x */
-#define GAIN_8x         0x20   /*    010 :   8x */
-#define GAIN_16x        0x30   /*    011 :  16x */
-#define GAIN_32x        0x40   /*    100 :  32x */
-#define GAIN_64x        0x50   /* 101 :  64x */
-#define GAIN_128x       0x60   /* 110 : 128x */
-#define DROP_VSYNC      0x04   /* Drop VSYNC output of corrupt frame */
-#define DROP_HREF       0x02   /* Drop HREF  output of corrupt frame */
-
-/* COM11 */
-#define SGLF_ON_OFF     0x02   /* Single frame ON/OFF selection */
-#define SGLF_TRIG       0x01   /* Single frame transfer trigger */
-
-/* EXHCH */
-#define VSIZE_LSB       0x04   /* Vertical data output size LSB */
-
-/* DSP_CTRL1 */
-#define FIFO_ON         0x80   /* FIFO enable/disable selection */
-#define UV_ON_OFF       0x40   /* UV adjust function ON/OFF selection */
-#define YUV444_2_422    0x20   /* YUV444 to 422 UV channel option selection */
-#define CLR_MTRX_ON_OFF 0x10   /* Color matrix ON/OFF selection */
-#define INTPLT_ON_OFF   0x08   /* Interpolation ON/OFF selection */
-#define GMM_ON_OFF      0x04   /* Gamma function ON/OFF selection */
-#define AUTO_BLK_ON_OFF 0x02   /* Black defect auto correction ON/OFF */
-#define AUTO_WHT_ON_OFF 0x01   /* White define auto correction ON/OFF */
-
-/* DSP_CTRL3 */
-#define UV_MASK         0x80   /* UV output sequence option */
-#define UV_ON           0x80   /*   ON */
-#define UV_OFF          0x00   /*   OFF */
-#define CBAR_MASK       0x20   /* DSP Color bar mask */
-#define CBAR_ON         0x20   /*   ON */
-#define CBAR_OFF        0x00   /*   OFF */
-
-/* HSTART */
-#define HST_VGA         0x23
-#define HST_QVGA        0x3F
-
-/* HSIZE */
-#define HSZ_VGA         0xA0
-#define HSZ_QVGA        0x50
-
-/* VSTART */
-#define VST_VGA         0x07
-#define VST_QVGA        0x03
-
-/* VSIZE */
-#define VSZ_VGA         0xF0
-#define VSZ_QVGA        0x78
-
-/* HOUTSIZE */
-#define HOSZ_VGA        0xA0
-#define HOSZ_QVGA       0x50
-
-/* VOUTSIZE */
-#define VOSZ_VGA        0xF0
-#define VOSZ_QVGA       0x78
-
-/* DSPAUTO (DSP Auto Function ON/OFF Control) */
-#define AWB_ACTRL       0x80 /* AWB auto threshold control */
-#define DENOISE_ACTRL   0x40 /* De-noise auto threshold control */
-#define EDGE_ACTRL      0x20 /* Edge enhancement auto strength control */
-#define UV_ACTRL        0x10 /* UV adjust auto slope control */
-#define SCAL0_ACTRL     0x08 /* Auto scaling factor control */
-#define SCAL1_2_ACTRL   0x04 /* Auto scaling factor control */
-
-/*
- * ID
- */
-#define OV7720  0x7720
-#define OV7725  0x7721
-#define VERSION(pid, ver) ((pid<<8)|(ver&0xFF))
-
-/*
- * struct
- */
-struct regval_list {
-       unsigned char reg_num;
-       unsigned char value;
-};
-
-struct ov772x_color_format {
-       enum v4l2_mbus_pixelcode code;
-       enum v4l2_colorspace colorspace;
-       u8 dsp3;
-       u8 com3;
-       u8 com7;
-};
-
-struct ov772x_win_size {
-       char                     *name;
-       __u32                     width;
-       __u32                     height;
-       unsigned char             com7_bit;
-       const struct regval_list *regs;
-};
-
-struct ov772x_priv {
-       struct v4l2_subdev                subdev;
-       struct v4l2_ctrl_handler          hdl;
-       struct ov772x_camera_info        *info;
-       const struct ov772x_color_format *cfmt;
-       const struct ov772x_win_size     *win;
-       int                               model;
-       unsigned short                    flag_vflip:1;
-       unsigned short                    flag_hflip:1;
-       /* band_filter = COM8[5] ? 256 - BDBASE : 0 */
-       unsigned short                    band_filter;
-};
-
-#define ENDMARKER { 0xff, 0xff }
-
-/*
- * register setting for window size
- */
-static const struct regval_list ov772x_qvga_regs[] = {
-       { HSTART,   HST_QVGA },
-       { HSIZE,    HSZ_QVGA },
-       { VSTART,   VST_QVGA },
-       { VSIZE,    VSZ_QVGA  },
-       { HOUTSIZE, HOSZ_QVGA },
-       { VOUTSIZE, VOSZ_QVGA },
-       ENDMARKER,
-};
-
-static const struct regval_list ov772x_vga_regs[] = {
-       { HSTART,   HST_VGA },
-       { HSIZE,    HSZ_VGA },
-       { VSTART,   VST_VGA },
-       { VSIZE,    VSZ_VGA },
-       { HOUTSIZE, HOSZ_VGA },
-       { VOUTSIZE, VOSZ_VGA },
-       ENDMARKER,
-};
-
-/*
- * supported color format list
- */
-static const struct ov772x_color_format ov772x_cfmts[] = {
-       {
-               .code           = V4L2_MBUS_FMT_YUYV8_2X8,
-               .colorspace     = V4L2_COLORSPACE_JPEG,
-               .dsp3           = 0x0,
-               .com3           = SWAP_YUV,
-               .com7           = OFMT_YUV,
-       },
-       {
-               .code           = V4L2_MBUS_FMT_YVYU8_2X8,
-               .colorspace     = V4L2_COLORSPACE_JPEG,
-               .dsp3           = UV_ON,
-               .com3           = SWAP_YUV,
-               .com7           = OFMT_YUV,
-       },
-       {
-               .code           = V4L2_MBUS_FMT_UYVY8_2X8,
-               .colorspace     = V4L2_COLORSPACE_JPEG,
-               .dsp3           = 0x0,
-               .com3           = 0x0,
-               .com7           = OFMT_YUV,
-       },
-       {
-               .code           = V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE,
-               .colorspace     = V4L2_COLORSPACE_SRGB,
-               .dsp3           = 0x0,
-               .com3           = SWAP_RGB,
-               .com7           = FMT_RGB555 | OFMT_RGB,
-       },
-       {
-               .code           = V4L2_MBUS_FMT_RGB555_2X8_PADHI_BE,
-               .colorspace     = V4L2_COLORSPACE_SRGB,
-               .dsp3           = 0x0,
-               .com3           = 0x0,
-               .com7           = FMT_RGB555 | OFMT_RGB,
-       },
-       {
-               .code           = V4L2_MBUS_FMT_RGB565_2X8_LE,
-               .colorspace     = V4L2_COLORSPACE_SRGB,
-               .dsp3           = 0x0,
-               .com3           = SWAP_RGB,
-               .com7           = FMT_RGB565 | OFMT_RGB,
-       },
-       {
-               .code           = V4L2_MBUS_FMT_RGB565_2X8_BE,
-               .colorspace     = V4L2_COLORSPACE_SRGB,
-               .dsp3           = 0x0,
-               .com3           = 0x0,
-               .com7           = FMT_RGB565 | OFMT_RGB,
-       },
-};
-
-
-/*
- * window size list
- */
-#define VGA_WIDTH   640
-#define VGA_HEIGHT  480
-#define QVGA_WIDTH  320
-#define QVGA_HEIGHT 240
-#define MAX_WIDTH   VGA_WIDTH
-#define MAX_HEIGHT  VGA_HEIGHT
-
-static const struct ov772x_win_size ov772x_win_vga = {
-       .name     = "VGA",
-       .width    = VGA_WIDTH,
-       .height   = VGA_HEIGHT,
-       .com7_bit = SLCT_VGA,
-       .regs     = ov772x_vga_regs,
-};
-
-static const struct ov772x_win_size ov772x_win_qvga = {
-       .name     = "QVGA",
-       .width    = QVGA_WIDTH,
-       .height   = QVGA_HEIGHT,
-       .com7_bit = SLCT_QVGA,
-       .regs     = ov772x_qvga_regs,
-};
-
-/*
- * general function
- */
-
-static struct ov772x_priv *to_ov772x(const struct i2c_client *client)
-{
-       return container_of(i2c_get_clientdata(client), struct ov772x_priv,
-                           subdev);
-}
-
-static int ov772x_write_array(struct i2c_client        *client,
-                             const struct regval_list *vals)
-{
-       while (vals->reg_num != 0xff) {
-               int ret = i2c_smbus_write_byte_data(client,
-                                                   vals->reg_num,
-                                                   vals->value);
-               if (ret < 0)
-                       return ret;
-               vals++;
-       }
-       return 0;
-}
-
-static int ov772x_mask_set(struct i2c_client *client,
-                                         u8  command,
-                                         u8  mask,
-                                         u8  set)
-{
-       s32 val = i2c_smbus_read_byte_data(client, command);
-       if (val < 0)
-               return val;
-
-       val &= ~mask;
-       val |= set & mask;
-
-       return i2c_smbus_write_byte_data(client, command, val);
-}
-
-static int ov772x_reset(struct i2c_client *client)
-{
-       int ret = i2c_smbus_write_byte_data(client, COM7, SCCB_RESET);
-       msleep(1);
-       return ret;
-}
-
-/*
- * soc_camera_ops function
- */
-
-static int ov772x_s_stream(struct v4l2_subdev *sd, int enable)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct ov772x_priv *priv = container_of(sd, struct ov772x_priv, subdev);
-
-       if (!enable) {
-               ov772x_mask_set(client, COM2, SOFT_SLEEP_MODE, SOFT_SLEEP_MODE);
-               return 0;
-       }
-
-       if (!priv->win || !priv->cfmt) {
-               dev_err(&client->dev, "norm or win select error\n");
-               return -EPERM;
-       }
-
-       ov772x_mask_set(client, COM2, SOFT_SLEEP_MODE, 0);
-
-       dev_dbg(&client->dev, "format %d, win %s\n",
-               priv->cfmt->code, priv->win->name);
-
-       return 0;
-}
-
-static int ov772x_s_ctrl(struct v4l2_ctrl *ctrl)
-{
-       struct ov772x_priv *priv = container_of(ctrl->handler,
-                                               struct ov772x_priv, hdl);
-       struct v4l2_subdev *sd = &priv->subdev;
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       int ret = 0;
-       u8 val;
-
-       switch (ctrl->id) {
-       case V4L2_CID_VFLIP:
-               val = ctrl->val ? VFLIP_IMG : 0x00;
-               priv->flag_vflip = ctrl->val;
-               if (priv->info->flags & OV772X_FLAG_VFLIP)
-                       val ^= VFLIP_IMG;
-               return ov772x_mask_set(client, COM3, VFLIP_IMG, val);
-       case V4L2_CID_HFLIP:
-               val = ctrl->val ? HFLIP_IMG : 0x00;
-               priv->flag_hflip = ctrl->val;
-               if (priv->info->flags & OV772X_FLAG_HFLIP)
-                       val ^= HFLIP_IMG;
-               return ov772x_mask_set(client, COM3, HFLIP_IMG, val);
-       case V4L2_CID_BAND_STOP_FILTER:
-               if (!ctrl->val) {
-                       /* Switch the filter off, it is on now */
-                       ret = ov772x_mask_set(client, BDBASE, 0xff, 0xff);
-                       if (!ret)
-                               ret = ov772x_mask_set(client, COM8,
-                                                     BNDF_ON_OFF, 0);
-               } else {
-                       /* Switch the filter on, set AEC low limit */
-                       val = 256 - ctrl->val;
-                       ret = ov772x_mask_set(client, COM8,
-                                             BNDF_ON_OFF, BNDF_ON_OFF);
-                       if (!ret)
-                               ret = ov772x_mask_set(client, BDBASE,
-                                                     0xff, val);
-               }
-               if (!ret)
-                       priv->band_filter = ctrl->val;
-               return ret;
-       }
-
-       return -EINVAL;
-}
-
-static int ov772x_g_chip_ident(struct v4l2_subdev *sd,
-                              struct v4l2_dbg_chip_ident *id)
-{
-       struct ov772x_priv *priv = container_of(sd, struct ov772x_priv, subdev);
-
-       id->ident    = priv->model;
-       id->revision = 0;
-
-       return 0;
-}
-
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-static int ov772x_g_register(struct v4l2_subdev *sd,
-                            struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       int ret;
-
-       reg->size = 1;
-       if (reg->reg > 0xff)
-               return -EINVAL;
-
-       ret = i2c_smbus_read_byte_data(client, reg->reg);
-       if (ret < 0)
-               return ret;
-
-       reg->val = (__u64)ret;
-
-       return 0;
-}
-
-static int ov772x_s_register(struct v4l2_subdev *sd,
-                            struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-
-       if (reg->reg > 0xff ||
-           reg->val > 0xff)
-               return -EINVAL;
-
-       return i2c_smbus_write_byte_data(client, reg->reg, reg->val);
-}
-#endif
-
-static const struct ov772x_win_size *ov772x_select_win(u32 width, u32 height)
-{
-       __u32 diff;
-       const struct ov772x_win_size *win;
-
-       /* default is QVGA */
-       diff = abs(width - ov772x_win_qvga.width) +
-               abs(height - ov772x_win_qvga.height);
-       win = &ov772x_win_qvga;
-
-       /* VGA */
-       if (diff >
-           abs(width  - ov772x_win_vga.width) +
-           abs(height - ov772x_win_vga.height))
-               win = &ov772x_win_vga;
-
-       return win;
-}
-
-static int ov772x_set_params(struct i2c_client *client, u32 *width, u32 *height,
-                            enum v4l2_mbus_pixelcode code)
-{
-       struct ov772x_priv *priv = to_ov772x(client);
-       int ret = -EINVAL;
-       u8  val;
-       int i;
-
-       /*
-        * select format
-        */
-       priv->cfmt = NULL;
-       for (i = 0; i < ARRAY_SIZE(ov772x_cfmts); i++) {
-               if (code == ov772x_cfmts[i].code) {
-                       priv->cfmt = ov772x_cfmts + i;
-                       break;
-               }
-       }
-       if (!priv->cfmt)
-               goto ov772x_set_fmt_error;
-
-       /*
-        * select win
-        */
-       priv->win = ov772x_select_win(*width, *height);
-
-       /*
-        * reset hardware
-        */
-       ov772x_reset(client);
-
-       /*
-        * Edge Ctrl
-        */
-       if (priv->info->edgectrl.strength & OV772X_MANUAL_EDGE_CTRL) {
-
-               /*
-                * Manual Edge Control Mode
-                *
-                * Edge auto strength bit is set by default.
-                * Remove it when manual mode.
-                */
-
-               ret = ov772x_mask_set(client, DSPAUTO, EDGE_ACTRL, 0x00);
-               if (ret < 0)
-                       goto ov772x_set_fmt_error;
-
-               ret = ov772x_mask_set(client,
-                                     EDGE_TRSHLD, OV772X_EDGE_THRESHOLD_MASK,
-                                     priv->info->edgectrl.threshold);
-               if (ret < 0)
-                       goto ov772x_set_fmt_error;
-
-               ret = ov772x_mask_set(client,
-                                     EDGE_STRNGT, OV772X_EDGE_STRENGTH_MASK,
-                                     priv->info->edgectrl.strength);
-               if (ret < 0)
-                       goto ov772x_set_fmt_error;
-
-       } else if (priv->info->edgectrl.upper > priv->info->edgectrl.lower) {
-               /*
-                * Auto Edge Control Mode
-                *
-                * set upper and lower limit
-                */
-               ret = ov772x_mask_set(client,
-                                     EDGE_UPPER, OV772X_EDGE_UPPER_MASK,
-                                     priv->info->edgectrl.upper);
-               if (ret < 0)
-                       goto ov772x_set_fmt_error;
-
-               ret = ov772x_mask_set(client,
-                                     EDGE_LOWER, OV772X_EDGE_LOWER_MASK,
-                                     priv->info->edgectrl.lower);
-               if (ret < 0)
-                       goto ov772x_set_fmt_error;
-       }
-
-       /*
-        * set size format
-        */
-       ret = ov772x_write_array(client, priv->win->regs);
-       if (ret < 0)
-               goto ov772x_set_fmt_error;
-
-       /*
-        * set DSP_CTRL3
-        */
-       val = priv->cfmt->dsp3;
-       if (val) {
-               ret = ov772x_mask_set(client,
-                                     DSP_CTRL3, UV_MASK, val);
-               if (ret < 0)
-                       goto ov772x_set_fmt_error;
-       }
-
-       /*
-        * set COM3
-        */
-       val = priv->cfmt->com3;
-       if (priv->info->flags & OV772X_FLAG_VFLIP)
-               val |= VFLIP_IMG;
-       if (priv->info->flags & OV772X_FLAG_HFLIP)
-               val |= HFLIP_IMG;
-       if (priv->flag_vflip)
-               val ^= VFLIP_IMG;
-       if (priv->flag_hflip)
-               val ^= HFLIP_IMG;
-
-       ret = ov772x_mask_set(client,
-                             COM3, SWAP_MASK | IMG_MASK, val);
-       if (ret < 0)
-               goto ov772x_set_fmt_error;
-
-       /*
-        * set COM7
-        */
-       val = priv->win->com7_bit | priv->cfmt->com7;
-       ret = ov772x_mask_set(client,
-                             COM7, SLCT_MASK | FMT_MASK | OFMT_MASK,
-                             val);
-       if (ret < 0)
-               goto ov772x_set_fmt_error;
-
-       /*
-        * set COM8
-        */
-       if (priv->band_filter) {
-               ret = ov772x_mask_set(client, COM8, BNDF_ON_OFF, 1);
-               if (!ret)
-                       ret = ov772x_mask_set(client, BDBASE,
-                                             0xff, 256 - priv->band_filter);
-               if (ret < 0)
-                       goto ov772x_set_fmt_error;
-       }
-
-       *width = priv->win->width;
-       *height = priv->win->height;
-
-       return ret;
-
-ov772x_set_fmt_error:
-
-       ov772x_reset(client);
-       priv->win = NULL;
-       priv->cfmt = NULL;
-
-       return ret;
-}
-
-static int ov772x_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
-{
-       a->c.left       = 0;
-       a->c.top        = 0;
-       a->c.width      = VGA_WIDTH;
-       a->c.height     = VGA_HEIGHT;
-       a->type         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-
-       return 0;
-}
-
-static int ov772x_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
-{
-       a->bounds.left                  = 0;
-       a->bounds.top                   = 0;
-       a->bounds.width                 = VGA_WIDTH;
-       a->bounds.height                = VGA_HEIGHT;
-       a->defrect                      = a->bounds;
-       a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-       a->pixelaspect.numerator        = 1;
-       a->pixelaspect.denominator      = 1;
-
-       return 0;
-}
-
-static int ov772x_g_fmt(struct v4l2_subdev *sd,
-                       struct v4l2_mbus_framefmt *mf)
-{
-       struct ov772x_priv *priv = container_of(sd, struct ov772x_priv, subdev);
-
-       if (!priv->win || !priv->cfmt) {
-               priv->cfmt = &ov772x_cfmts[0];
-               priv->win = ov772x_select_win(VGA_WIDTH, VGA_HEIGHT);
-       }
-
-       mf->width       = priv->win->width;
-       mf->height      = priv->win->height;
-       mf->code        = priv->cfmt->code;
-       mf->colorspace  = priv->cfmt->colorspace;
-       mf->field       = V4L2_FIELD_NONE;
-
-       return 0;
-}
-
-static int ov772x_s_fmt(struct v4l2_subdev *sd,
-                       struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct ov772x_priv *priv = container_of(sd, struct ov772x_priv, subdev);
-       int ret = ov772x_set_params(client, &mf->width, &mf->height,
-                                   mf->code);
-
-       if (!ret)
-               mf->colorspace = priv->cfmt->colorspace;
-
-       return ret;
-}
-
-static int ov772x_try_fmt(struct v4l2_subdev *sd,
-                         struct v4l2_mbus_framefmt *mf)
-{
-       struct ov772x_priv *priv = container_of(sd, struct ov772x_priv, subdev);
-       const struct ov772x_win_size *win;
-       int i;
-
-       /*
-        * select suitable win
-        */
-       win = ov772x_select_win(mf->width, mf->height);
-
-       mf->width       = win->width;
-       mf->height      = win->height;
-       mf->field       = V4L2_FIELD_NONE;
-
-       for (i = 0; i < ARRAY_SIZE(ov772x_cfmts); i++)
-               if (mf->code == ov772x_cfmts[i].code)
-                       break;
-
-       if (i == ARRAY_SIZE(ov772x_cfmts)) {
-               /* Unsupported format requested. Propose either */
-               if (priv->cfmt) {
-                       /* the current one or */
-                       mf->colorspace = priv->cfmt->colorspace;
-                       mf->code = priv->cfmt->code;
-               } else {
-                       /* the default one */
-                       mf->colorspace = ov772x_cfmts[0].colorspace;
-                       mf->code = ov772x_cfmts[0].code;
-               }
-       } else {
-               /* Also return the colorspace */
-               mf->colorspace  = ov772x_cfmts[i].colorspace;
-       }
-
-       return 0;
-}
-
-static int ov772x_video_probe(struct i2c_client *client)
-{
-       struct ov772x_priv *priv = to_ov772x(client);
-       u8                  pid, ver;
-       const char         *devname;
-
-       /*
-        * check and show product ID and manufacturer ID
-        */
-       pid = i2c_smbus_read_byte_data(client, PID);
-       ver = i2c_smbus_read_byte_data(client, VER);
-
-       switch (VERSION(pid, ver)) {
-       case OV7720:
-               devname     = "ov7720";
-               priv->model = V4L2_IDENT_OV7720;
-               break;
-       case OV7725:
-               devname     = "ov7725";
-               priv->model = V4L2_IDENT_OV7725;
-               break;
-       default:
-               dev_err(&client->dev,
-                       "Product ID error %x:%x\n", pid, ver);
-               return -ENODEV;
-       }
-
-       dev_info(&client->dev,
-                "%s Product ID %0x:%0x Manufacturer ID %x:%x\n",
-                devname,
-                pid,
-                ver,
-                i2c_smbus_read_byte_data(client, MIDH),
-                i2c_smbus_read_byte_data(client, MIDL));
-       return v4l2_ctrl_handler_setup(&priv->hdl);
-}
-
-static const struct v4l2_ctrl_ops ov772x_ctrl_ops = {
-       .s_ctrl = ov772x_s_ctrl,
-};
-
-static struct v4l2_subdev_core_ops ov772x_subdev_core_ops = {
-       .g_chip_ident   = ov772x_g_chip_ident,
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-       .g_register     = ov772x_g_register,
-       .s_register     = ov772x_s_register,
-#endif
-};
-
-static int ov772x_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                          enum v4l2_mbus_pixelcode *code)
-{
-       if (index >= ARRAY_SIZE(ov772x_cfmts))
-               return -EINVAL;
-
-       *code = ov772x_cfmts[index].code;
-       return 0;
-}
-
-static int ov772x_g_mbus_config(struct v4l2_subdev *sd,
-                               struct v4l2_mbus_config *cfg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-
-       cfg->flags = V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_MASTER |
-               V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_HSYNC_ACTIVE_HIGH |
-               V4L2_MBUS_DATA_ACTIVE_HIGH;
-       cfg->type = V4L2_MBUS_PARALLEL;
-       cfg->flags = soc_camera_apply_board_flags(icl, cfg);
-
-       return 0;
-}
-
-static struct v4l2_subdev_video_ops ov772x_subdev_video_ops = {
-       .s_stream       = ov772x_s_stream,
-       .g_mbus_fmt     = ov772x_g_fmt,
-       .s_mbus_fmt     = ov772x_s_fmt,
-       .try_mbus_fmt   = ov772x_try_fmt,
-       .cropcap        = ov772x_cropcap,
-       .g_crop         = ov772x_g_crop,
-       .enum_mbus_fmt  = ov772x_enum_fmt,
-       .g_mbus_config  = ov772x_g_mbus_config,
-};
-
-static struct v4l2_subdev_ops ov772x_subdev_ops = {
-       .core   = &ov772x_subdev_core_ops,
-       .video  = &ov772x_subdev_video_ops,
-};
-
-/*
- * i2c_driver function
- */
-
-static int ov772x_probe(struct i2c_client *client,
-                       const struct i2c_device_id *did)
-{
-       struct ov772x_priv      *priv;
-       struct soc_camera_link  *icl = soc_camera_i2c_to_link(client);
-       struct i2c_adapter      *adapter = to_i2c_adapter(client->dev.parent);
-       int                     ret;
-
-       if (!icl || !icl->priv) {
-               dev_err(&client->dev, "OV772X: missing platform data!\n");
-               return -EINVAL;
-       }
-
-       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
-               dev_err(&adapter->dev,
-                       "I2C-Adapter doesn't support "
-                       "I2C_FUNC_SMBUS_BYTE_DATA\n");
-               return -EIO;
-       }
-
-       priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-       if (!priv)
-               return -ENOMEM;
-
-       priv->info = icl->priv;
-
-       v4l2_i2c_subdev_init(&priv->subdev, client, &ov772x_subdev_ops);
-       v4l2_ctrl_handler_init(&priv->hdl, 3);
-       v4l2_ctrl_new_std(&priv->hdl, &ov772x_ctrl_ops,
-                       V4L2_CID_VFLIP, 0, 1, 1, 0);
-       v4l2_ctrl_new_std(&priv->hdl, &ov772x_ctrl_ops,
-                       V4L2_CID_HFLIP, 0, 1, 1, 0);
-       v4l2_ctrl_new_std(&priv->hdl, &ov772x_ctrl_ops,
-                       V4L2_CID_BAND_STOP_FILTER, 0, 256, 1, 0);
-       priv->subdev.ctrl_handler = &priv->hdl;
-       if (priv->hdl.error) {
-               int err = priv->hdl.error;
-
-               kfree(priv);
-               return err;
-       }
-
-       ret = ov772x_video_probe(client);
-       if (ret) {
-               v4l2_ctrl_handler_free(&priv->hdl);
-               kfree(priv);
-       }
-
-       return ret;
-}
-
-static int ov772x_remove(struct i2c_client *client)
-{
-       struct ov772x_priv *priv = to_ov772x(client);
-
-       v4l2_device_unregister_subdev(&priv->subdev);
-       v4l2_ctrl_handler_free(&priv->hdl);
-       kfree(priv);
-       return 0;
-}
-
-static const struct i2c_device_id ov772x_id[] = {
-       { "ov772x", 0 },
-       { }
-};
-MODULE_DEVICE_TABLE(i2c, ov772x_id);
-
-static struct i2c_driver ov772x_i2c_driver = {
-       .driver = {
-               .name = "ov772x",
-       },
-       .probe    = ov772x_probe,
-       .remove   = ov772x_remove,
-       .id_table = ov772x_id,
-};
-
-module_i2c_driver(ov772x_i2c_driver);
-
-MODULE_DESCRIPTION("SoC Camera driver for ov772x");
-MODULE_AUTHOR("Kuninori Morimoto");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/video/ov9640.c b/drivers/media/video/ov9640.c
deleted file mode 100644 (file)
index 9ed4ba4..0000000
+++ /dev/null
@@ -1,746 +0,0 @@
-/*
- * OmniVision OV96xx Camera Driver
- *
- * Copyright (C) 2009 Marek Vasut <marek.vasut@gmail.com>
- *
- * Based on ov772x camera driver:
- *
- * Copyright (C) 2008 Renesas Solutions Corp.
- * Kuninori Morimoto <morimoto.kuninori@renesas.com>
- *
- * Based on ov7670 and soc_camera_platform driver,
- *
- * Copyright 2006-7 Jonathan Corbet <corbet@lwn.net>
- * Copyright (C) 2008 Magnus Damm
- * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/i2c.h>
-#include <linux/slab.h>
-#include <linux/delay.h>
-#include <linux/v4l2-mediabus.h>
-#include <linux/videodev2.h>
-
-#include <media/soc_camera.h>
-#include <media/v4l2-chip-ident.h>
-#include <media/v4l2-common.h>
-#include <media/v4l2-ctrls.h>
-
-#include "ov9640.h"
-
-#define to_ov9640_sensor(sd)   container_of(sd, struct ov9640_priv, subdev)
-
-/* default register setup */
-static const struct ov9640_reg ov9640_regs_dflt[] = {
-       { OV9640_COM5,  OV9640_COM5_SYSCLK | OV9640_COM5_LONGEXP },
-       { OV9640_COM6,  OV9640_COM6_OPT_BLC | OV9640_COM6_ADBLC_BIAS |
-                       OV9640_COM6_FMT_RST | OV9640_COM6_ADBLC_OPTEN },
-       { OV9640_PSHFT, OV9640_PSHFT_VAL(0x01) },
-       { OV9640_ACOM,  OV9640_ACOM_2X_ANALOG | OV9640_ACOM_RSVD },
-       { OV9640_TSLB,  OV9640_TSLB_YUYV_UYVY },
-       { OV9640_COM16, OV9640_COM16_RB_AVG },
-
-       /* Gamma curve P */
-       { 0x6c, 0x40 }, { 0x6d, 0x30 }, { 0x6e, 0x4b }, { 0x6f, 0x60 },
-       { 0x70, 0x70 }, { 0x71, 0x70 }, { 0x72, 0x70 }, { 0x73, 0x70 },
-       { 0x74, 0x60 }, { 0x75, 0x60 }, { 0x76, 0x50 }, { 0x77, 0x48 },
-       { 0x78, 0x3a }, { 0x79, 0x2e }, { 0x7a, 0x28 }, { 0x7b, 0x22 },
-
-       /* Gamma curve T */
-       { 0x7c, 0x04 }, { 0x7d, 0x07 }, { 0x7e, 0x10 }, { 0x7f, 0x28 },
-       { 0x80, 0x36 }, { 0x81, 0x44 }, { 0x82, 0x52 }, { 0x83, 0x60 },
-       { 0x84, 0x6c }, { 0x85, 0x78 }, { 0x86, 0x8c }, { 0x87, 0x9e },
-       { 0x88, 0xbb }, { 0x89, 0xd2 }, { 0x8a, 0xe6 },
-};
-
-/* Configurations
- * NOTE: for YUV, alter the following registers:
- *             COM12 |= OV9640_COM12_YUV_AVG
- *
- *      for RGB, alter the following registers:
- *             COM7  |= OV9640_COM7_RGB
- *             COM13 |= OV9640_COM13_RGB_AVG
- *             COM15 |= proper RGB color encoding mode
- */
-static const struct ov9640_reg ov9640_regs_qqcif[] = {
-       { OV9640_CLKRC, OV9640_CLKRC_DPLL_EN | OV9640_CLKRC_DIV(0x0f) },
-       { OV9640_COM1,  OV9640_COM1_QQFMT | OV9640_COM1_HREF_2SKIP },
-       { OV9640_COM4,  OV9640_COM4_QQ_VP | OV9640_COM4_RSVD },
-       { OV9640_COM7,  OV9640_COM7_QCIF },
-       { OV9640_COM12, OV9640_COM12_RSVD },
-       { OV9640_COM13, OV9640_COM13_GAMMA_RAW | OV9640_COM13_MATRIX_EN },
-       { OV9640_COM15, OV9640_COM15_OR_10F0 },
-};
-
-static const struct ov9640_reg ov9640_regs_qqvga[] = {
-       { OV9640_CLKRC, OV9640_CLKRC_DPLL_EN | OV9640_CLKRC_DIV(0x07) },
-       { OV9640_COM1,  OV9640_COM1_QQFMT | OV9640_COM1_HREF_2SKIP },
-       { OV9640_COM4,  OV9640_COM4_QQ_VP | OV9640_COM4_RSVD },
-       { OV9640_COM7,  OV9640_COM7_QVGA },
-       { OV9640_COM12, OV9640_COM12_RSVD },
-       { OV9640_COM13, OV9640_COM13_GAMMA_RAW | OV9640_COM13_MATRIX_EN },
-       { OV9640_COM15, OV9640_COM15_OR_10F0 },
-};
-
-static const struct ov9640_reg ov9640_regs_qcif[] = {
-       { OV9640_CLKRC, OV9640_CLKRC_DPLL_EN | OV9640_CLKRC_DIV(0x07) },
-       { OV9640_COM4,  OV9640_COM4_QQ_VP | OV9640_COM4_RSVD },
-       { OV9640_COM7,  OV9640_COM7_QCIF },
-       { OV9640_COM12, OV9640_COM12_RSVD },
-       { OV9640_COM13, OV9640_COM13_GAMMA_RAW | OV9640_COM13_MATRIX_EN },
-       { OV9640_COM15, OV9640_COM15_OR_10F0 },
-};
-
-static const struct ov9640_reg ov9640_regs_qvga[] = {
-       { OV9640_CLKRC, OV9640_CLKRC_DPLL_EN | OV9640_CLKRC_DIV(0x03) },
-       { OV9640_COM4,  OV9640_COM4_QQ_VP | OV9640_COM4_RSVD },
-       { OV9640_COM7,  OV9640_COM7_QVGA },
-       { OV9640_COM12, OV9640_COM12_RSVD },
-       { OV9640_COM13, OV9640_COM13_GAMMA_RAW | OV9640_COM13_MATRIX_EN },
-       { OV9640_COM15, OV9640_COM15_OR_10F0 },
-};
-
-static const struct ov9640_reg ov9640_regs_cif[] = {
-       { OV9640_CLKRC, OV9640_CLKRC_DPLL_EN | OV9640_CLKRC_DIV(0x03) },
-       { OV9640_COM3,  OV9640_COM3_VP },
-       { OV9640_COM7,  OV9640_COM7_CIF },
-       { OV9640_COM12, OV9640_COM12_RSVD },
-       { OV9640_COM13, OV9640_COM13_GAMMA_RAW | OV9640_COM13_MATRIX_EN },
-       { OV9640_COM15, OV9640_COM15_OR_10F0 },
-};
-
-static const struct ov9640_reg ov9640_regs_vga[] = {
-       { OV9640_CLKRC, OV9640_CLKRC_DPLL_EN | OV9640_CLKRC_DIV(0x01) },
-       { OV9640_COM3,  OV9640_COM3_VP },
-       { OV9640_COM7,  OV9640_COM7_VGA },
-       { OV9640_COM12, OV9640_COM12_RSVD },
-       { OV9640_COM13, OV9640_COM13_GAMMA_RAW | OV9640_COM13_MATRIX_EN },
-       { OV9640_COM15, OV9640_COM15_OR_10F0 },
-};
-
-static const struct ov9640_reg ov9640_regs_sxga[] = {
-       { OV9640_CLKRC, OV9640_CLKRC_DPLL_EN | OV9640_CLKRC_DIV(0x01) },
-       { OV9640_COM3,  OV9640_COM3_VP },
-       { OV9640_COM7,  0 },
-       { OV9640_COM12, OV9640_COM12_RSVD },
-       { OV9640_COM13, OV9640_COM13_GAMMA_RAW | OV9640_COM13_MATRIX_EN },
-       { OV9640_COM15, OV9640_COM15_OR_10F0 },
-};
-
-static const struct ov9640_reg ov9640_regs_yuv[] = {
-       { OV9640_MTX1,  0x58 },
-       { OV9640_MTX2,  0x48 },
-       { OV9640_MTX3,  0x10 },
-       { OV9640_MTX4,  0x28 },
-       { OV9640_MTX5,  0x48 },
-       { OV9640_MTX6,  0x70 },
-       { OV9640_MTX7,  0x40 },
-       { OV9640_MTX8,  0x40 },
-       { OV9640_MTX9,  0x40 },
-       { OV9640_MTXS,  0x0f },
-};
-
-static const struct ov9640_reg ov9640_regs_rgb[] = {
-       { OV9640_MTX1,  0x71 },
-       { OV9640_MTX2,  0x3e },
-       { OV9640_MTX3,  0x0c },
-       { OV9640_MTX4,  0x33 },
-       { OV9640_MTX5,  0x72 },
-       { OV9640_MTX6,  0x00 },
-       { OV9640_MTX7,  0x2b },
-       { OV9640_MTX8,  0x66 },
-       { OV9640_MTX9,  0xd2 },
-       { OV9640_MTXS,  0x65 },
-};
-
-static enum v4l2_mbus_pixelcode ov9640_codes[] = {
-       V4L2_MBUS_FMT_UYVY8_2X8,
-       V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE,
-       V4L2_MBUS_FMT_RGB565_2X8_LE,
-};
-
-/* read a register */
-static int ov9640_reg_read(struct i2c_client *client, u8 reg, u8 *val)
-{
-       int ret;
-       u8 data = reg;
-       struct i2c_msg msg = {
-               .addr   = client->addr,
-               .flags  = 0,
-               .len    = 1,
-               .buf    = &data,
-       };
-
-       ret = i2c_transfer(client->adapter, &msg, 1);
-       if (ret < 0)
-               goto err;
-
-       msg.flags = I2C_M_RD;
-       ret = i2c_transfer(client->adapter, &msg, 1);
-       if (ret < 0)
-               goto err;
-
-       *val = data;
-       return 0;
-
-err:
-       dev_err(&client->dev, "Failed reading register 0x%02x!\n", reg);
-       return ret;
-}
-
-/* write a register */
-static int ov9640_reg_write(struct i2c_client *client, u8 reg, u8 val)
-{
-       int ret;
-       u8 _val;
-       unsigned char data[2] = { reg, val };
-       struct i2c_msg msg = {
-               .addr   = client->addr,
-               .flags  = 0,
-               .len    = 2,
-               .buf    = data,
-       };
-
-       ret = i2c_transfer(client->adapter, &msg, 1);
-       if (ret < 0) {
-               dev_err(&client->dev, "Failed writing register 0x%02x!\n", reg);
-               return ret;
-       }
-
-       /* we have to read the register back ... no idea why, maybe HW bug */
-       ret = ov9640_reg_read(client, reg, &_val);
-       if (ret)
-               dev_err(&client->dev,
-                       "Failed reading back register 0x%02x!\n", reg);
-
-       return 0;
-}
-
-
-/* Read a register, alter its bits, write it back */
-static int ov9640_reg_rmw(struct i2c_client *client, u8 reg, u8 set, u8 unset)
-{
-       u8 val;
-       int ret;
-
-       ret = ov9640_reg_read(client, reg, &val);
-       if (ret) {
-               dev_err(&client->dev,
-                       "[Read]-Modify-Write of register %02x failed!\n", reg);
-               return val;
-       }
-
-       val |= set;
-       val &= ~unset;
-
-       ret = ov9640_reg_write(client, reg, val);
-       if (ret)
-               dev_err(&client->dev,
-                       "Read-Modify-[Write] of register %02x failed!\n", reg);
-
-       return ret;
-}
-
-/* Soft reset the camera. This has nothing to do with the RESET pin! */
-static int ov9640_reset(struct i2c_client *client)
-{
-       int ret;
-
-       ret = ov9640_reg_write(client, OV9640_COM7, OV9640_COM7_SCCB_RESET);
-       if (ret)
-               dev_err(&client->dev,
-                       "An error occurred while entering soft reset!\n");
-
-       return ret;
-}
-
-/* Start/Stop streaming from the device */
-static int ov9640_s_stream(struct v4l2_subdev *sd, int enable)
-{
-       return 0;
-}
-
-/* Set status of additional camera capabilities */
-static int ov9640_s_ctrl(struct v4l2_ctrl *ctrl)
-{
-       struct ov9640_priv *priv = container_of(ctrl->handler, struct ov9640_priv, hdl);
-       struct i2c_client *client = v4l2_get_subdevdata(&priv->subdev);
-
-       switch (ctrl->id) {
-       case V4L2_CID_VFLIP:
-               if (ctrl->val)
-                       return ov9640_reg_rmw(client, OV9640_MVFP,
-                                                       OV9640_MVFP_V, 0);
-               return ov9640_reg_rmw(client, OV9640_MVFP, 0, OV9640_MVFP_V);
-       case V4L2_CID_HFLIP:
-               if (ctrl->val)
-                       return ov9640_reg_rmw(client, OV9640_MVFP,
-                                                       OV9640_MVFP_H, 0);
-               return ov9640_reg_rmw(client, OV9640_MVFP, 0, OV9640_MVFP_H);
-       }
-       return -EINVAL;
-}
-
-/* Get chip identification */
-static int ov9640_g_chip_ident(struct v4l2_subdev *sd,
-                               struct v4l2_dbg_chip_ident *id)
-{
-       struct ov9640_priv *priv = to_ov9640_sensor(sd);
-
-       id->ident       = priv->model;
-       id->revision    = priv->revision;
-
-       return 0;
-}
-
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-static int ov9640_get_register(struct v4l2_subdev *sd,
-                               struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       int ret;
-       u8 val;
-
-       if (reg->reg & ~0xff)
-               return -EINVAL;
-
-       reg->size = 1;
-
-       ret = ov9640_reg_read(client, reg->reg, &val);
-       if (ret)
-               return ret;
-
-       reg->val = (__u64)val;
-
-       return 0;
-}
-
-static int ov9640_set_register(struct v4l2_subdev *sd,
-                               struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-
-       if (reg->reg & ~0xff || reg->val & ~0xff)
-               return -EINVAL;
-
-       return ov9640_reg_write(client, reg->reg, reg->val);
-}
-#endif
-
-/* select nearest higher resolution for capture */
-static void ov9640_res_roundup(u32 *width, u32 *height)
-{
-       int i;
-       enum { QQCIF, QQVGA, QCIF, QVGA, CIF, VGA, SXGA };
-       int res_x[] = { 88, 160, 176, 320, 352, 640, 1280 };
-       int res_y[] = { 72, 120, 144, 240, 288, 480, 960 };
-
-       for (i = 0; i < ARRAY_SIZE(res_x); i++) {
-               if (res_x[i] >= *width && res_y[i] >= *height) {
-                       *width = res_x[i];
-                       *height = res_y[i];
-                       return;
-               }
-       }
-
-       *width = res_x[SXGA];
-       *height = res_y[SXGA];
-}
-
-/* Prepare necessary register changes depending on color encoding */
-static void ov9640_alter_regs(enum v4l2_mbus_pixelcode code,
-                             struct ov9640_reg_alt *alt)
-{
-       switch (code) {
-       default:
-       case V4L2_MBUS_FMT_UYVY8_2X8:
-               alt->com12      = OV9640_COM12_YUV_AVG;
-               alt->com13      = OV9640_COM13_Y_DELAY_EN |
-                                       OV9640_COM13_YUV_DLY(0x01);
-               break;
-       case V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE:
-               alt->com7       = OV9640_COM7_RGB;
-               alt->com13      = OV9640_COM13_RGB_AVG;
-               alt->com15      = OV9640_COM15_RGB_555;
-               break;
-       case V4L2_MBUS_FMT_RGB565_2X8_LE:
-               alt->com7       = OV9640_COM7_RGB;
-               alt->com13      = OV9640_COM13_RGB_AVG;
-               alt->com15      = OV9640_COM15_RGB_565;
-               break;
-       };
-}
-
-/* Setup registers according to resolution and color encoding */
-static int ov9640_write_regs(struct i2c_client *client, u32 width,
-               enum v4l2_mbus_pixelcode code, struct ov9640_reg_alt *alts)
-{
-       const struct ov9640_reg *ov9640_regs, *matrix_regs;
-       int                     ov9640_regs_len, matrix_regs_len;
-       int                     i, ret;
-       u8                      val;
-
-       /* select register configuration for given resolution */
-       switch (width) {
-       case W_QQCIF:
-               ov9640_regs     = ov9640_regs_qqcif;
-               ov9640_regs_len = ARRAY_SIZE(ov9640_regs_qqcif);
-               break;
-       case W_QQVGA:
-               ov9640_regs     = ov9640_regs_qqvga;
-               ov9640_regs_len = ARRAY_SIZE(ov9640_regs_qqvga);
-               break;
-       case W_QCIF:
-               ov9640_regs     = ov9640_regs_qcif;
-               ov9640_regs_len = ARRAY_SIZE(ov9640_regs_qcif);
-               break;
-       case W_QVGA:
-               ov9640_regs     = ov9640_regs_qvga;
-               ov9640_regs_len = ARRAY_SIZE(ov9640_regs_qvga);
-               break;
-       case W_CIF:
-               ov9640_regs     = ov9640_regs_cif;
-               ov9640_regs_len = ARRAY_SIZE(ov9640_regs_cif);
-               break;
-       case W_VGA:
-               ov9640_regs     = ov9640_regs_vga;
-               ov9640_regs_len = ARRAY_SIZE(ov9640_regs_vga);
-               break;
-       case W_SXGA:
-               ov9640_regs     = ov9640_regs_sxga;
-               ov9640_regs_len = ARRAY_SIZE(ov9640_regs_sxga);
-               break;
-       default:
-               dev_err(&client->dev, "Failed to select resolution!\n");
-               return -EINVAL;
-       }
-
-       /* select color matrix configuration for given color encoding */
-       if (code == V4L2_MBUS_FMT_UYVY8_2X8) {
-               matrix_regs     = ov9640_regs_yuv;
-               matrix_regs_len = ARRAY_SIZE(ov9640_regs_yuv);
-       } else {
-               matrix_regs     = ov9640_regs_rgb;
-               matrix_regs_len = ARRAY_SIZE(ov9640_regs_rgb);
-       }
-
-       /* write register settings into the module */
-       for (i = 0; i < ov9640_regs_len; i++) {
-               val = ov9640_regs[i].val;
-
-               switch (ov9640_regs[i].reg) {
-               case OV9640_COM7:
-                       val |= alts->com7;
-                       break;
-               case OV9640_COM12:
-                       val |= alts->com12;
-                       break;
-               case OV9640_COM13:
-                       val |= alts->com13;
-                       break;
-               case OV9640_COM15:
-                       val |= alts->com15;
-                       break;
-               }
-
-               ret = ov9640_reg_write(client, ov9640_regs[i].reg, val);
-               if (ret)
-                       return ret;
-       }
-
-       /* write color matrix configuration into the module */
-       for (i = 0; i < matrix_regs_len; i++) {
-               ret = ov9640_reg_write(client, matrix_regs[i].reg,
-                                               matrix_regs[i].val);
-               if (ret)
-                       return ret;
-       }
-
-       return 0;
-}
-
-/* program default register values */
-static int ov9640_prog_dflt(struct i2c_client *client)
-{
-       int i, ret;
-
-       for (i = 0; i < ARRAY_SIZE(ov9640_regs_dflt); i++) {
-               ret = ov9640_reg_write(client, ov9640_regs_dflt[i].reg,
-                                               ov9640_regs_dflt[i].val);
-               if (ret)
-                       return ret;
-       }
-
-       /* wait for the changes to actually happen, 140ms are not enough yet */
-       mdelay(150);
-
-       return 0;
-}
-
-/* set the format we will capture in */
-static int ov9640_s_fmt(struct v4l2_subdev *sd,
-                       struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct ov9640_reg_alt alts = {0};
-       enum v4l2_colorspace cspace;
-       enum v4l2_mbus_pixelcode code = mf->code;
-       int ret;
-
-       ov9640_res_roundup(&mf->width, &mf->height);
-       ov9640_alter_regs(mf->code, &alts);
-
-       ov9640_reset(client);
-
-       ret = ov9640_prog_dflt(client);
-       if (ret)
-               return ret;
-
-       switch (code) {
-       case V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE:
-       case V4L2_MBUS_FMT_RGB565_2X8_LE:
-               cspace = V4L2_COLORSPACE_SRGB;
-               break;
-       default:
-               code = V4L2_MBUS_FMT_UYVY8_2X8;
-       case V4L2_MBUS_FMT_UYVY8_2X8:
-               cspace = V4L2_COLORSPACE_JPEG;
-       }
-
-       ret = ov9640_write_regs(client, mf->width, code, &alts);
-       if (!ret) {
-               mf->code        = code;
-               mf->colorspace  = cspace;
-       }
-
-       return ret;
-}
-
-static int ov9640_try_fmt(struct v4l2_subdev *sd,
-                         struct v4l2_mbus_framefmt *mf)
-{
-       ov9640_res_roundup(&mf->width, &mf->height);
-
-       mf->field = V4L2_FIELD_NONE;
-
-       switch (mf->code) {
-       case V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE:
-       case V4L2_MBUS_FMT_RGB565_2X8_LE:
-               mf->colorspace = V4L2_COLORSPACE_SRGB;
-               break;
-       default:
-               mf->code = V4L2_MBUS_FMT_UYVY8_2X8;
-       case V4L2_MBUS_FMT_UYVY8_2X8:
-               mf->colorspace = V4L2_COLORSPACE_JPEG;
-       }
-
-       return 0;
-}
-
-static int ov9640_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                          enum v4l2_mbus_pixelcode *code)
-{
-       if (index >= ARRAY_SIZE(ov9640_codes))
-               return -EINVAL;
-
-       *code = ov9640_codes[index];
-       return 0;
-}
-
-static int ov9640_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
-{
-       a->c.left       = 0;
-       a->c.top        = 0;
-       a->c.width      = W_SXGA;
-       a->c.height     = H_SXGA;
-       a->type         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-
-       return 0;
-}
-
-static int ov9640_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
-{
-       a->bounds.left                  = 0;
-       a->bounds.top                   = 0;
-       a->bounds.width                 = W_SXGA;
-       a->bounds.height                = H_SXGA;
-       a->defrect                      = a->bounds;
-       a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-       a->pixelaspect.numerator        = 1;
-       a->pixelaspect.denominator      = 1;
-
-       return 0;
-}
-
-static int ov9640_video_probe(struct i2c_client *client)
-{
-       struct v4l2_subdev *sd = i2c_get_clientdata(client);
-       struct ov9640_priv *priv = to_ov9640_sensor(sd);
-       u8              pid, ver, midh, midl;
-       const char      *devname;
-       int             ret = 0;
-
-       /*
-        * check and show product ID and manufacturer ID
-        */
-
-       ret = ov9640_reg_read(client, OV9640_PID, &pid);
-       if (!ret)
-               ret = ov9640_reg_read(client, OV9640_VER, &ver);
-       if (!ret)
-               ret = ov9640_reg_read(client, OV9640_MIDH, &midh);
-       if (!ret)
-               ret = ov9640_reg_read(client, OV9640_MIDL, &midl);
-       if (ret)
-               return ret;
-
-       switch (VERSION(pid, ver)) {
-       case OV9640_V2:
-               devname         = "ov9640";
-               priv->model     = V4L2_IDENT_OV9640;
-               priv->revision  = 2;
-               break;
-       case OV9640_V3:
-               devname         = "ov9640";
-               priv->model     = V4L2_IDENT_OV9640;
-               priv->revision  = 3;
-               break;
-       default:
-               dev_err(&client->dev, "Product ID error %x:%x\n", pid, ver);
-               return -ENODEV;
-       }
-
-       dev_info(&client->dev, "%s Product ID %0x:%0x Manufacturer ID %x:%x\n",
-                devname, pid, ver, midh, midl);
-
-       return v4l2_ctrl_handler_setup(&priv->hdl);
-}
-
-static const struct v4l2_ctrl_ops ov9640_ctrl_ops = {
-       .s_ctrl = ov9640_s_ctrl,
-};
-
-static struct v4l2_subdev_core_ops ov9640_core_ops = {
-       .g_chip_ident           = ov9640_g_chip_ident,
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-       .g_register             = ov9640_get_register,
-       .s_register             = ov9640_set_register,
-#endif
-
-};
-
-/* Request bus settings on camera side */
-static int ov9640_g_mbus_config(struct v4l2_subdev *sd,
-                               struct v4l2_mbus_config *cfg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-
-       cfg->flags = V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_MASTER |
-               V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_HSYNC_ACTIVE_HIGH |
-               V4L2_MBUS_DATA_ACTIVE_HIGH;
-       cfg->type = V4L2_MBUS_PARALLEL;
-       cfg->flags = soc_camera_apply_board_flags(icl, cfg);
-
-       return 0;
-}
-
-static struct v4l2_subdev_video_ops ov9640_video_ops = {
-       .s_stream       = ov9640_s_stream,
-       .s_mbus_fmt     = ov9640_s_fmt,
-       .try_mbus_fmt   = ov9640_try_fmt,
-       .enum_mbus_fmt  = ov9640_enum_fmt,
-       .cropcap        = ov9640_cropcap,
-       .g_crop         = ov9640_g_crop,
-       .g_mbus_config  = ov9640_g_mbus_config,
-};
-
-static struct v4l2_subdev_ops ov9640_subdev_ops = {
-       .core   = &ov9640_core_ops,
-       .video  = &ov9640_video_ops,
-};
-
-/*
- * i2c_driver function
- */
-static int ov9640_probe(struct i2c_client *client,
-                       const struct i2c_device_id *did)
-{
-       struct ov9640_priv *priv;
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-       int ret;
-
-       if (!icl) {
-               dev_err(&client->dev, "Missing platform_data for driver\n");
-               return -EINVAL;
-       }
-
-       priv = kzalloc(sizeof(struct ov9640_priv), GFP_KERNEL);
-       if (!priv) {
-               dev_err(&client->dev,
-                       "Failed to allocate memory for private data!\n");
-               return -ENOMEM;
-       }
-
-       v4l2_i2c_subdev_init(&priv->subdev, client, &ov9640_subdev_ops);
-
-       v4l2_ctrl_handler_init(&priv->hdl, 2);
-       v4l2_ctrl_new_std(&priv->hdl, &ov9640_ctrl_ops,
-                       V4L2_CID_VFLIP, 0, 1, 1, 0);
-       v4l2_ctrl_new_std(&priv->hdl, &ov9640_ctrl_ops,
-                       V4L2_CID_HFLIP, 0, 1, 1, 0);
-       priv->subdev.ctrl_handler = &priv->hdl;
-       if (priv->hdl.error) {
-               int err = priv->hdl.error;
-
-               kfree(priv);
-               return err;
-       }
-
-       ret = ov9640_video_probe(client);
-
-       if (ret) {
-               v4l2_ctrl_handler_free(&priv->hdl);
-               kfree(priv);
-       }
-
-       return ret;
-}
-
-static int ov9640_remove(struct i2c_client *client)
-{
-       struct v4l2_subdev *sd = i2c_get_clientdata(client);
-       struct ov9640_priv *priv = to_ov9640_sensor(sd);
-
-       v4l2_device_unregister_subdev(&priv->subdev);
-       v4l2_ctrl_handler_free(&priv->hdl);
-       kfree(priv);
-       return 0;
-}
-
-static const struct i2c_device_id ov9640_id[] = {
-       { "ov9640", 0 },
-       { }
-};
-MODULE_DEVICE_TABLE(i2c, ov9640_id);
-
-static struct i2c_driver ov9640_i2c_driver = {
-       .driver = {
-               .name = "ov9640",
-       },
-       .probe    = ov9640_probe,
-       .remove   = ov9640_remove,
-       .id_table = ov9640_id,
-};
-
-module_i2c_driver(ov9640_i2c_driver);
-
-MODULE_DESCRIPTION("SoC Camera driver for OmniVision OV96xx");
-MODULE_AUTHOR("Marek Vasut <marek.vasut@gmail.com>");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/video/ov9640.h b/drivers/media/video/ov9640.h
deleted file mode 100644 (file)
index 6b33a97..0000000
+++ /dev/null
@@ -1,207 +0,0 @@
-/*
- * OmniVision OV96xx Camera Header File
- *
- * Copyright (C) 2009 Marek Vasut <marek.vasut@gmail.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#ifndef        __DRIVERS_MEDIA_VIDEO_OV9640_H__
-#define        __DRIVERS_MEDIA_VIDEO_OV9640_H__
-
-/* Register definitions */
-#define        OV9640_GAIN     0x00
-#define        OV9640_BLUE     0x01
-#define        OV9640_RED      0x02
-#define        OV9640_VFER     0x03
-#define        OV9640_COM1     0x04
-#define        OV9640_BAVE     0x05
-#define        OV9640_GEAVE    0x06
-#define        OV9640_RSID     0x07
-#define        OV9640_RAVE     0x08
-#define        OV9640_COM2     0x09
-#define        OV9640_PID      0x0a
-#define        OV9640_VER      0x0b
-#define        OV9640_COM3     0x0c
-#define        OV9640_COM4     0x0d
-#define        OV9640_COM5     0x0e
-#define        OV9640_COM6     0x0f
-#define        OV9640_AECH     0x10
-#define        OV9640_CLKRC    0x11
-#define        OV9640_COM7     0x12
-#define        OV9640_COM8     0x13
-#define        OV9640_COM9     0x14
-#define        OV9640_COM10    0x15
-/* 0x16 - RESERVED */
-#define        OV9640_HSTART   0x17
-#define        OV9640_HSTOP    0x18
-#define        OV9640_VSTART   0x19
-#define        OV9640_VSTOP    0x1a
-#define        OV9640_PSHFT    0x1b
-#define        OV9640_MIDH     0x1c
-#define        OV9640_MIDL     0x1d
-#define        OV9640_MVFP     0x1e
-#define        OV9640_LAEC     0x1f
-#define        OV9640_BOS      0x20
-#define        OV9640_GBOS     0x21
-#define        OV9640_GROS     0x22
-#define        OV9640_ROS      0x23
-#define        OV9640_AEW      0x24
-#define        OV9640_AEB      0x25
-#define        OV9640_VPT      0x26
-#define        OV9640_BBIAS    0x27
-#define        OV9640_GBBIAS   0x28
-/* 0x29 - RESERVED */
-#define        OV9640_EXHCH    0x2a
-#define        OV9640_EXHCL    0x2b
-#define        OV9640_RBIAS    0x2c
-#define        OV9640_ADVFL    0x2d
-#define        OV9640_ADVFH    0x2e
-#define        OV9640_YAVE     0x2f
-#define        OV9640_HSYST    0x30
-#define        OV9640_HSYEN    0x31
-#define        OV9640_HREF     0x32
-#define        OV9640_CHLF     0x33
-#define        OV9640_ARBLM    0x34
-/* 0x35..0x36 - RESERVED */
-#define        OV9640_ADC      0x37
-#define        OV9640_ACOM     0x38
-#define        OV9640_OFON     0x39
-#define        OV9640_TSLB     0x3a
-#define        OV9640_COM11    0x3b
-#define        OV9640_COM12    0x3c
-#define        OV9640_COM13    0x3d
-#define        OV9640_COM14    0x3e
-#define        OV9640_EDGE     0x3f
-#define        OV9640_COM15    0x40
-#define        OV9640_COM16    0x41
-#define        OV9640_COM17    0x42
-/* 0x43..0x4e - RESERVED */
-#define        OV9640_MTX1     0x4f
-#define        OV9640_MTX2     0x50
-#define        OV9640_MTX3     0x51
-#define        OV9640_MTX4     0x52
-#define        OV9640_MTX5     0x53
-#define        OV9640_MTX6     0x54
-#define        OV9640_MTX7     0x55
-#define        OV9640_MTX8     0x56
-#define        OV9640_MTX9     0x57
-#define        OV9640_MTXS     0x58
-/* 0x59..0x61 - RESERVED */
-#define        OV9640_LCC1     0x62
-#define        OV9640_LCC2     0x63
-#define        OV9640_LCC3     0x64
-#define        OV9640_LCC4     0x65
-#define        OV9640_LCC5     0x66
-#define        OV9640_MANU     0x67
-#define        OV9640_MANV     0x68
-#define        OV9640_HV       0x69
-#define        OV9640_MBD      0x6a
-#define        OV9640_DBLV     0x6b
-#define        OV9640_GSP      0x6c    /* ... till 0x7b */
-#define        OV9640_GST      0x7c    /* ... till 0x8a */
-
-#define        OV9640_CLKRC_DPLL_EN    0x80
-#define        OV9640_CLKRC_DIRECT     0x40
-#define        OV9640_CLKRC_DIV(x)     ((x) & 0x3f)
-
-#define        OV9640_PSHFT_VAL(x)     ((x) & 0xff)
-
-#define        OV9640_ACOM_2X_ANALOG   0x80
-#define        OV9640_ACOM_RSVD        0x12
-
-#define        OV9640_MVFP_V           0x10
-#define        OV9640_MVFP_H           0x20
-
-#define        OV9640_COM1_HREF_NOSKIP 0x00
-#define        OV9640_COM1_HREF_2SKIP  0x04
-#define        OV9640_COM1_HREF_3SKIP  0x08
-#define        OV9640_COM1_QQFMT       0x20
-
-#define        OV9640_COM2_SSM         0x10
-
-#define        OV9640_COM3_VP          0x04
-
-#define        OV9640_COM4_QQ_VP       0x80
-#define        OV9640_COM4_RSVD        0x40
-
-#define        OV9640_COM5_SYSCLK      0x80
-#define        OV9640_COM5_LONGEXP     0x01
-
-#define        OV9640_COM6_OPT_BLC     0x40
-#define        OV9640_COM6_ADBLC_BIAS  0x08
-#define        OV9640_COM6_FMT_RST     0x82
-#define        OV9640_COM6_ADBLC_OPTEN 0x01
-
-#define        OV9640_COM7_RAW_RGB     0x01
-#define        OV9640_COM7_RGB         0x04
-#define        OV9640_COM7_QCIF        0x08
-#define        OV9640_COM7_QVGA        0x10
-#define        OV9640_COM7_CIF         0x20
-#define        OV9640_COM7_VGA         0x40
-#define        OV9640_COM7_SCCB_RESET  0x80
-
-#define        OV9640_TSLB_YVYU_YUYV   0x04
-#define        OV9640_TSLB_YUYV_UYVY   0x08
-
-#define        OV9640_COM12_YUV_AVG    0x04
-#define        OV9640_COM12_RSVD       0x40
-
-#define        OV9640_COM13_GAMMA_NONE 0x00
-#define        OV9640_COM13_GAMMA_Y    0x40
-#define        OV9640_COM13_GAMMA_RAW  0x80
-#define        OV9640_COM13_RGB_AVG    0x20
-#define        OV9640_COM13_MATRIX_EN  0x10
-#define        OV9640_COM13_Y_DELAY_EN 0x08
-#define        OV9640_COM13_YUV_DLY(x) ((x) & 0x07)
-
-#define        OV9640_COM15_OR_00FF    0x00
-#define        OV9640_COM15_OR_01FE    0x40
-#define        OV9640_COM15_OR_10F0    0xc0
-#define        OV9640_COM15_RGB_NORM   0x00
-#define        OV9640_COM15_RGB_565    0x10
-#define        OV9640_COM15_RGB_555    0x30
-
-#define        OV9640_COM16_RB_AVG     0x01
-
-/* IDs */
-#define        OV9640_V2               0x9648
-#define        OV9640_V3               0x9649
-#define        VERSION(pid, ver)       (((pid) << 8) | ((ver) & 0xFF))
-
-/* supported resolutions */
-enum {
-       W_QQCIF = 88,
-       W_QQVGA = 160,
-       W_QCIF  = 176,
-       W_QVGA  = 320,
-       W_CIF   = 352,
-       W_VGA   = 640,
-       W_SXGA  = 1280
-};
-#define        H_SXGA  960
-
-/* Misc. structures */
-struct ov9640_reg_alt {
-       u8      com7;
-       u8      com12;
-       u8      com13;
-       u8      com15;
-};
-
-struct ov9640_reg {
-       u8      reg;
-       u8      val;
-};
-
-struct ov9640_priv {
-       struct v4l2_subdev              subdev;
-       struct v4l2_ctrl_handler        hdl;
-
-       int                             model;
-       int                             revision;
-};
-
-#endif /* __DRIVERS_MEDIA_VIDEO_OV9640_H__ */
diff --git a/drivers/media/video/ov9740.c b/drivers/media/video/ov9740.c
deleted file mode 100644 (file)
index 3eb07c2..0000000
+++ /dev/null
@@ -1,1005 +0,0 @@
-/*
- * OmniVision OV9740 Camera Driver
- *
- * Copyright (C) 2011 NVIDIA Corporation
- *
- * Based on ov9640 camera driver.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/i2c.h>
-#include <linux/slab.h>
-#include <linux/v4l2-mediabus.h>
-
-#include <media/soc_camera.h>
-#include <media/v4l2-chip-ident.h>
-#include <media/v4l2-ctrls.h>
-
-#define to_ov9740(sd)          container_of(sd, struct ov9740_priv, subdev)
-
-/* General Status Registers */
-#define OV9740_MODEL_ID_HI             0x0000
-#define OV9740_MODEL_ID_LO             0x0001
-#define OV9740_REVISION_NUMBER         0x0002
-#define OV9740_MANUFACTURER_ID         0x0003
-#define OV9740_SMIA_VERSION            0x0004
-
-/* General Setup Registers */
-#define OV9740_MODE_SELECT             0x0100
-#define OV9740_IMAGE_ORT               0x0101
-#define OV9740_SOFTWARE_RESET          0x0103
-#define OV9740_GRP_PARAM_HOLD          0x0104
-#define OV9740_MSK_CORRUP_FM           0x0105
-
-/* Timing Setting */
-#define OV9740_FRM_LENGTH_LN_HI                0x0340 /* VTS */
-#define OV9740_FRM_LENGTH_LN_LO                0x0341 /* VTS */
-#define OV9740_LN_LENGTH_PCK_HI                0x0342 /* HTS */
-#define OV9740_LN_LENGTH_PCK_LO                0x0343 /* HTS */
-#define OV9740_X_ADDR_START_HI         0x0344
-#define OV9740_X_ADDR_START_LO         0x0345
-#define OV9740_Y_ADDR_START_HI         0x0346
-#define OV9740_Y_ADDR_START_LO         0x0347
-#define OV9740_X_ADDR_END_HI           0x0348
-#define OV9740_X_ADDR_END_LO           0x0349
-#define OV9740_Y_ADDR_END_HI           0x034a
-#define OV9740_Y_ADDR_END_LO           0x034b
-#define OV9740_X_OUTPUT_SIZE_HI                0x034c
-#define OV9740_X_OUTPUT_SIZE_LO                0x034d
-#define OV9740_Y_OUTPUT_SIZE_HI                0x034e
-#define OV9740_Y_OUTPUT_SIZE_LO                0x034f
-
-/* IO Control Registers */
-#define OV9740_IO_CREL00               0x3002
-#define OV9740_IO_CREL01               0x3004
-#define OV9740_IO_CREL02               0x3005
-#define OV9740_IO_OUTPUT_SEL01         0x3026
-#define OV9740_IO_OUTPUT_SEL02         0x3027
-
-/* AWB Registers */
-#define OV9740_AWB_MANUAL_CTRL         0x3406
-
-/* Analog Control Registers */
-#define OV9740_ANALOG_CTRL01           0x3601
-#define OV9740_ANALOG_CTRL02           0x3602
-#define OV9740_ANALOG_CTRL03           0x3603
-#define OV9740_ANALOG_CTRL04           0x3604
-#define OV9740_ANALOG_CTRL10           0x3610
-#define OV9740_ANALOG_CTRL12           0x3612
-#define OV9740_ANALOG_CTRL15           0x3615
-#define OV9740_ANALOG_CTRL20           0x3620
-#define OV9740_ANALOG_CTRL21           0x3621
-#define OV9740_ANALOG_CTRL22           0x3622
-#define OV9740_ANALOG_CTRL30           0x3630
-#define OV9740_ANALOG_CTRL31           0x3631
-#define OV9740_ANALOG_CTRL32           0x3632
-#define OV9740_ANALOG_CTRL33           0x3633
-
-/* Sensor Control */
-#define OV9740_SENSOR_CTRL03           0x3703
-#define OV9740_SENSOR_CTRL04           0x3704
-#define OV9740_SENSOR_CTRL05           0x3705
-#define OV9740_SENSOR_CTRL07           0x3707
-
-/* Timing Control */
-#define OV9740_TIMING_CTRL17           0x3817
-#define OV9740_TIMING_CTRL19           0x3819
-#define OV9740_TIMING_CTRL33           0x3833
-#define OV9740_TIMING_CTRL35           0x3835
-
-/* Banding Filter */
-#define OV9740_AEC_MAXEXPO_60_H                0x3a02
-#define OV9740_AEC_MAXEXPO_60_L                0x3a03
-#define OV9740_AEC_B50_STEP_HI         0x3a08
-#define OV9740_AEC_B50_STEP_LO         0x3a09
-#define OV9740_AEC_B60_STEP_HI         0x3a0a
-#define OV9740_AEC_B60_STEP_LO         0x3a0b
-#define OV9740_AEC_CTRL0D              0x3a0d
-#define OV9740_AEC_CTRL0E              0x3a0e
-#define OV9740_AEC_MAXEXPO_50_H                0x3a14
-#define OV9740_AEC_MAXEXPO_50_L                0x3a15
-
-/* AEC/AGC Control */
-#define OV9740_AEC_ENABLE              0x3503
-#define OV9740_GAIN_CEILING_01         0x3a18
-#define OV9740_GAIN_CEILING_02         0x3a19
-#define OV9740_AEC_HI_THRESHOLD                0x3a11
-#define OV9740_AEC_3A1A                        0x3a1a
-#define OV9740_AEC_CTRL1B_WPT2         0x3a1b
-#define OV9740_AEC_CTRL0F_WPT          0x3a0f
-#define OV9740_AEC_CTRL10_BPT          0x3a10
-#define OV9740_AEC_CTRL1E_BPT2         0x3a1e
-#define OV9740_AEC_LO_THRESHOLD                0x3a1f
-
-/* BLC Control */
-#define OV9740_BLC_AUTO_ENABLE         0x4002
-#define OV9740_BLC_MODE                        0x4005
-
-/* VFIFO */
-#define OV9740_VFIFO_READ_START_HI     0x4608
-#define OV9740_VFIFO_READ_START_LO     0x4609
-
-/* DVP Control */
-#define OV9740_DVP_VSYNC_CTRL02                0x4702
-#define OV9740_DVP_VSYNC_MODE          0x4704
-#define OV9740_DVP_VSYNC_CTRL06                0x4706
-
-/* PLL Setting */
-#define OV9740_PLL_MODE_CTRL01         0x3104
-#define OV9740_PRE_PLL_CLK_DIV         0x0305
-#define OV9740_PLL_MULTIPLIER          0x0307
-#define OV9740_VT_SYS_CLK_DIV          0x0303
-#define OV9740_VT_PIX_CLK_DIV          0x0301
-#define OV9740_PLL_CTRL3010            0x3010
-#define OV9740_VFIFO_CTRL00            0x460e
-
-/* ISP Control */
-#define OV9740_ISP_CTRL00              0x5000
-#define OV9740_ISP_CTRL01              0x5001
-#define OV9740_ISP_CTRL03              0x5003
-#define OV9740_ISP_CTRL05              0x5005
-#define OV9740_ISP_CTRL12              0x5012
-#define OV9740_ISP_CTRL19              0x5019
-#define OV9740_ISP_CTRL1A              0x501a
-#define OV9740_ISP_CTRL1E              0x501e
-#define OV9740_ISP_CTRL1F              0x501f
-#define OV9740_ISP_CTRL20              0x5020
-#define OV9740_ISP_CTRL21              0x5021
-
-/* AWB */
-#define OV9740_AWB_CTRL00              0x5180
-#define OV9740_AWB_CTRL01              0x5181
-#define OV9740_AWB_CTRL02              0x5182
-#define OV9740_AWB_CTRL03              0x5183
-#define OV9740_AWB_ADV_CTRL01          0x5184
-#define OV9740_AWB_ADV_CTRL02          0x5185
-#define OV9740_AWB_ADV_CTRL03          0x5186
-#define OV9740_AWB_ADV_CTRL04          0x5187
-#define OV9740_AWB_ADV_CTRL05          0x5188
-#define OV9740_AWB_ADV_CTRL06          0x5189
-#define OV9740_AWB_ADV_CTRL07          0x518a
-#define OV9740_AWB_ADV_CTRL08          0x518b
-#define OV9740_AWB_ADV_CTRL09          0x518c
-#define OV9740_AWB_ADV_CTRL10          0x518d
-#define OV9740_AWB_ADV_CTRL11          0x518e
-#define OV9740_AWB_CTRL0F              0x518f
-#define OV9740_AWB_CTRL10              0x5190
-#define OV9740_AWB_CTRL11              0x5191
-#define OV9740_AWB_CTRL12              0x5192
-#define OV9740_AWB_CTRL13              0x5193
-#define OV9740_AWB_CTRL14              0x5194
-
-/* MIPI Control */
-#define OV9740_MIPI_CTRL00             0x4800
-#define OV9740_MIPI_3837               0x3837
-#define OV9740_MIPI_CTRL01             0x4801
-#define OV9740_MIPI_CTRL03             0x4803
-#define OV9740_MIPI_CTRL05             0x4805
-#define OV9740_VFIFO_RD_CTRL           0x4601
-#define OV9740_MIPI_CTRL_3012          0x3012
-#define OV9740_SC_CMMM_MIPI_CTR                0x3014
-
-#define OV9740_MAX_WIDTH               1280
-#define OV9740_MAX_HEIGHT              720
-
-/* Misc. structures */
-struct ov9740_reg {
-       u16                             reg;
-       u8                              val;
-};
-
-struct ov9740_priv {
-       struct v4l2_subdev              subdev;
-       struct v4l2_ctrl_handler        hdl;
-
-       int                             ident;
-       u16                             model;
-       u8                              revision;
-       u8                              manid;
-       u8                              smiaver;
-
-       bool                            flag_vflip;
-       bool                            flag_hflip;
-
-       /* For suspend/resume. */
-       struct v4l2_mbus_framefmt       current_mf;
-       bool                            current_enable;
-};
-
-static const struct ov9740_reg ov9740_defaults[] = {
-       /* Software Reset */
-       { OV9740_SOFTWARE_RESET,        0x01 },
-
-       /* Banding Filter */
-       { OV9740_AEC_B50_STEP_HI,       0x00 },
-       { OV9740_AEC_B50_STEP_LO,       0xe8 },
-       { OV9740_AEC_CTRL0E,            0x03 },
-       { OV9740_AEC_MAXEXPO_50_H,      0x15 },
-       { OV9740_AEC_MAXEXPO_50_L,      0xc6 },
-       { OV9740_AEC_B60_STEP_HI,       0x00 },
-       { OV9740_AEC_B60_STEP_LO,       0xc0 },
-       { OV9740_AEC_CTRL0D,            0x04 },
-       { OV9740_AEC_MAXEXPO_60_H,      0x18 },
-       { OV9740_AEC_MAXEXPO_60_L,      0x20 },
-
-       /* LC */
-       { 0x5842, 0x02 }, { 0x5843, 0x5e }, { 0x5844, 0x04 }, { 0x5845, 0x32 },
-       { 0x5846, 0x03 }, { 0x5847, 0x29 }, { 0x5848, 0x02 }, { 0x5849, 0xcc },
-
-       /* Un-documented OV9740 registers */
-       { 0x5800, 0x29 }, { 0x5801, 0x25 }, { 0x5802, 0x20 }, { 0x5803, 0x21 },
-       { 0x5804, 0x26 }, { 0x5805, 0x2e }, { 0x5806, 0x11 }, { 0x5807, 0x0c },
-       { 0x5808, 0x09 }, { 0x5809, 0x0a }, { 0x580a, 0x0e }, { 0x580b, 0x16 },
-       { 0x580c, 0x06 }, { 0x580d, 0x02 }, { 0x580e, 0x00 }, { 0x580f, 0x00 },
-       { 0x5810, 0x04 }, { 0x5811, 0x0a }, { 0x5812, 0x05 }, { 0x5813, 0x02 },
-       { 0x5814, 0x00 }, { 0x5815, 0x00 }, { 0x5816, 0x03 }, { 0x5817, 0x09 },
-       { 0x5818, 0x0f }, { 0x5819, 0x0a }, { 0x581a, 0x07 }, { 0x581b, 0x08 },
-       { 0x581c, 0x0b }, { 0x581d, 0x14 }, { 0x581e, 0x28 }, { 0x581f, 0x23 },
-       { 0x5820, 0x1d }, { 0x5821, 0x1e }, { 0x5822, 0x24 }, { 0x5823, 0x2a },
-       { 0x5824, 0x4f }, { 0x5825, 0x6f }, { 0x5826, 0x5f }, { 0x5827, 0x7f },
-       { 0x5828, 0x9f }, { 0x5829, 0x5f }, { 0x582a, 0x8f }, { 0x582b, 0x9e },
-       { 0x582c, 0x8f }, { 0x582d, 0x9f }, { 0x582e, 0x4f }, { 0x582f, 0x87 },
-       { 0x5830, 0x86 }, { 0x5831, 0x97 }, { 0x5832, 0xae }, { 0x5833, 0x3f },
-       { 0x5834, 0x8e }, { 0x5835, 0x7c }, { 0x5836, 0x7e }, { 0x5837, 0xaf },
-       { 0x5838, 0x8f }, { 0x5839, 0x8f }, { 0x583a, 0x9f }, { 0x583b, 0x7f },
-       { 0x583c, 0x5f },
-
-       /* Y Gamma */
-       { 0x5480, 0x07 }, { 0x5481, 0x18 }, { 0x5482, 0x2c }, { 0x5483, 0x4e },
-       { 0x5484, 0x5e }, { 0x5485, 0x6b }, { 0x5486, 0x77 }, { 0x5487, 0x82 },
-       { 0x5488, 0x8c }, { 0x5489, 0x95 }, { 0x548a, 0xa4 }, { 0x548b, 0xb1 },
-       { 0x548c, 0xc6 }, { 0x548d, 0xd8 }, { 0x548e, 0xe9 },
-
-       /* UV Gamma */
-       { 0x5490, 0x0f }, { 0x5491, 0xff }, { 0x5492, 0x0d }, { 0x5493, 0x05 },
-       { 0x5494, 0x07 }, { 0x5495, 0x1a }, { 0x5496, 0x04 }, { 0x5497, 0x01 },
-       { 0x5498, 0x03 }, { 0x5499, 0x53 }, { 0x549a, 0x02 }, { 0x549b, 0xeb },
-       { 0x549c, 0x02 }, { 0x549d, 0xa0 }, { 0x549e, 0x02 }, { 0x549f, 0x67 },
-       { 0x54a0, 0x02 }, { 0x54a1, 0x3b }, { 0x54a2, 0x02 }, { 0x54a3, 0x18 },
-       { 0x54a4, 0x01 }, { 0x54a5, 0xe7 }, { 0x54a6, 0x01 }, { 0x54a7, 0xc3 },
-       { 0x54a8, 0x01 }, { 0x54a9, 0x94 }, { 0x54aa, 0x01 }, { 0x54ab, 0x72 },
-       { 0x54ac, 0x01 }, { 0x54ad, 0x57 },
-
-       /* AWB */
-       { OV9740_AWB_CTRL00,            0xf0 },
-       { OV9740_AWB_CTRL01,            0x00 },
-       { OV9740_AWB_CTRL02,            0x41 },
-       { OV9740_AWB_CTRL03,            0x42 },
-       { OV9740_AWB_ADV_CTRL01,        0x8a },
-       { OV9740_AWB_ADV_CTRL02,        0x61 },
-       { OV9740_AWB_ADV_CTRL03,        0xce },
-       { OV9740_AWB_ADV_CTRL04,        0xa8 },
-       { OV9740_AWB_ADV_CTRL05,        0x17 },
-       { OV9740_AWB_ADV_CTRL06,        0x1f },
-       { OV9740_AWB_ADV_CTRL07,        0x27 },
-       { OV9740_AWB_ADV_CTRL08,        0x41 },
-       { OV9740_AWB_ADV_CTRL09,        0x34 },
-       { OV9740_AWB_ADV_CTRL10,        0xf0 },
-       { OV9740_AWB_ADV_CTRL11,        0x10 },
-       { OV9740_AWB_CTRL0F,            0xff },
-       { OV9740_AWB_CTRL10,            0x00 },
-       { OV9740_AWB_CTRL11,            0xff },
-       { OV9740_AWB_CTRL12,            0x00 },
-       { OV9740_AWB_CTRL13,            0xff },
-       { OV9740_AWB_CTRL14,            0x00 },
-
-       /* CIP */
-       { 0x530d, 0x12 },
-
-       /* CMX */
-       { 0x5380, 0x01 }, { 0x5381, 0x00 }, { 0x5382, 0x00 }, { 0x5383, 0x17 },
-       { 0x5384, 0x00 }, { 0x5385, 0x01 }, { 0x5386, 0x00 }, { 0x5387, 0x00 },
-       { 0x5388, 0x00 }, { 0x5389, 0xe0 }, { 0x538a, 0x00 }, { 0x538b, 0x20 },
-       { 0x538c, 0x00 }, { 0x538d, 0x00 }, { 0x538e, 0x00 }, { 0x538f, 0x16 },
-       { 0x5390, 0x00 }, { 0x5391, 0x9c }, { 0x5392, 0x00 }, { 0x5393, 0xa0 },
-       { 0x5394, 0x18 },
-
-       /* 50/60 Detection */
-       { 0x3c0a, 0x9c }, { 0x3c0b, 0x3f },
-
-       /* Output Select */
-       { OV9740_IO_OUTPUT_SEL01,       0x00 },
-       { OV9740_IO_OUTPUT_SEL02,       0x00 },
-       { OV9740_IO_CREL00,             0x00 },
-       { OV9740_IO_CREL01,             0x00 },
-       { OV9740_IO_CREL02,             0x00 },
-
-       /* AWB Control */
-       { OV9740_AWB_MANUAL_CTRL,       0x00 },
-
-       /* Analog Control */
-       { OV9740_ANALOG_CTRL03,         0xaa },
-       { OV9740_ANALOG_CTRL32,         0x2f },
-       { OV9740_ANALOG_CTRL20,         0x66 },
-       { OV9740_ANALOG_CTRL21,         0xc0 },
-       { OV9740_ANALOG_CTRL31,         0x52 },
-       { OV9740_ANALOG_CTRL33,         0x50 },
-       { OV9740_ANALOG_CTRL30,         0xca },
-       { OV9740_ANALOG_CTRL04,         0x0c },
-       { OV9740_ANALOG_CTRL01,         0x40 },
-       { OV9740_ANALOG_CTRL02,         0x16 },
-       { OV9740_ANALOG_CTRL10,         0xa1 },
-       { OV9740_ANALOG_CTRL12,         0x24 },
-       { OV9740_ANALOG_CTRL22,         0x9f },
-       { OV9740_ANALOG_CTRL15,         0xf0 },
-
-       /* Sensor Control */
-       { OV9740_SENSOR_CTRL03,         0x42 },
-       { OV9740_SENSOR_CTRL04,         0x10 },
-       { OV9740_SENSOR_CTRL05,         0x45 },
-       { OV9740_SENSOR_CTRL07,         0x14 },
-
-       /* Timing Control */
-       { OV9740_TIMING_CTRL33,         0x04 },
-       { OV9740_TIMING_CTRL35,         0x02 },
-       { OV9740_TIMING_CTRL19,         0x6e },
-       { OV9740_TIMING_CTRL17,         0x94 },
-
-       /* AEC/AGC Control */
-       { OV9740_AEC_ENABLE,            0x10 },
-       { OV9740_GAIN_CEILING_01,       0x00 },
-       { OV9740_GAIN_CEILING_02,       0x7f },
-       { OV9740_AEC_HI_THRESHOLD,      0xa0 },
-       { OV9740_AEC_3A1A,              0x05 },
-       { OV9740_AEC_CTRL1B_WPT2,       0x50 },
-       { OV9740_AEC_CTRL0F_WPT,        0x50 },
-       { OV9740_AEC_CTRL10_BPT,        0x4c },
-       { OV9740_AEC_CTRL1E_BPT2,       0x4c },
-       { OV9740_AEC_LO_THRESHOLD,      0x26 },
-
-       /* BLC Control */
-       { OV9740_BLC_AUTO_ENABLE,       0x45 },
-       { OV9740_BLC_MODE,              0x18 },
-
-       /* DVP Control */
-       { OV9740_DVP_VSYNC_CTRL02,      0x04 },
-       { OV9740_DVP_VSYNC_MODE,        0x00 },
-       { OV9740_DVP_VSYNC_CTRL06,      0x08 },
-
-       /* PLL Setting */
-       { OV9740_PLL_MODE_CTRL01,       0x20 },
-       { OV9740_PRE_PLL_CLK_DIV,       0x03 },
-       { OV9740_PLL_MULTIPLIER,        0x4c },
-       { OV9740_VT_SYS_CLK_DIV,        0x01 },
-       { OV9740_VT_PIX_CLK_DIV,        0x08 },
-       { OV9740_PLL_CTRL3010,          0x01 },
-       { OV9740_VFIFO_CTRL00,          0x82 },
-
-       /* Timing Setting */
-       /* VTS */
-       { OV9740_FRM_LENGTH_LN_HI,      0x03 },
-       { OV9740_FRM_LENGTH_LN_LO,      0x07 },
-       /* HTS */
-       { OV9740_LN_LENGTH_PCK_HI,      0x06 },
-       { OV9740_LN_LENGTH_PCK_LO,      0x62 },
-
-       /* MIPI Control */
-       { OV9740_MIPI_CTRL00,           0x44 }, /* 0x64 for discontinuous clk */
-       { OV9740_MIPI_3837,             0x01 },
-       { OV9740_MIPI_CTRL01,           0x0f },
-       { OV9740_MIPI_CTRL03,           0x05 },
-       { OV9740_MIPI_CTRL05,           0x10 },
-       { OV9740_VFIFO_RD_CTRL,         0x16 },
-       { OV9740_MIPI_CTRL_3012,        0x70 },
-       { OV9740_SC_CMMM_MIPI_CTR,      0x01 },
-
-       /* YUYV order */
-       { OV9740_ISP_CTRL19,            0x02 },
-};
-
-static enum v4l2_mbus_pixelcode ov9740_codes[] = {
-       V4L2_MBUS_FMT_YUYV8_2X8,
-};
-
-/* read a register */
-static int ov9740_reg_read(struct i2c_client *client, u16 reg, u8 *val)
-{
-       int ret;
-       struct i2c_msg msg[] = {
-               {
-                       .addr   = client->addr,
-                       .flags  = 0,
-                       .len    = 2,
-                       .buf    = (u8 *)&reg,
-               },
-               {
-                       .addr   = client->addr,
-                       .flags  = I2C_M_RD,
-                       .len    = 1,
-                       .buf    = val,
-               },
-       };
-
-       reg = swab16(reg);
-
-       ret = i2c_transfer(client->adapter, msg, 2);
-       if (ret < 0) {
-               dev_err(&client->dev, "Failed reading register 0x%04x!\n", reg);
-               return ret;
-       }
-
-       return 0;
-}
-
-/* write a register */
-static int ov9740_reg_write(struct i2c_client *client, u16 reg, u8 val)
-{
-       struct i2c_msg msg;
-       struct {
-               u16 reg;
-               u8 val;
-       } __packed buf;
-       int ret;
-
-       reg = swab16(reg);
-
-       buf.reg = reg;
-       buf.val = val;
-
-       msg.addr        = client->addr;
-       msg.flags       = 0;
-       msg.len         = 3;
-       msg.buf         = (u8 *)&buf;
-
-       ret = i2c_transfer(client->adapter, &msg, 1);
-       if (ret < 0) {
-               dev_err(&client->dev, "Failed writing register 0x%04x!\n", reg);
-               return ret;
-       }
-
-       return 0;
-}
-
-
-/* Read a register, alter its bits, write it back */
-static int ov9740_reg_rmw(struct i2c_client *client, u16 reg, u8 set, u8 unset)
-{
-       u8 val;
-       int ret;
-
-       ret = ov9740_reg_read(client, reg, &val);
-       if (ret < 0) {
-               dev_err(&client->dev,
-                       "[Read]-Modify-Write of register 0x%04x failed!\n",
-                       reg);
-               return ret;
-       }
-
-       val |= set;
-       val &= ~unset;
-
-       ret = ov9740_reg_write(client, reg, val);
-       if (ret < 0) {
-               dev_err(&client->dev,
-                       "Read-Modify-[Write] of register 0x%04x failed!\n",
-                       reg);
-               return ret;
-       }
-
-       return 0;
-}
-
-static int ov9740_reg_write_array(struct i2c_client *client,
-                                 const struct ov9740_reg *regarray,
-                                 int regarraylen)
-{
-       int i;
-       int ret;
-
-       for (i = 0; i < regarraylen; i++) {
-               ret = ov9740_reg_write(client,
-                                      regarray[i].reg, regarray[i].val);
-               if (ret < 0)
-                       return ret;
-       }
-
-       return 0;
-}
-
-/* Start/Stop streaming from the device */
-static int ov9740_s_stream(struct v4l2_subdev *sd, int enable)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct ov9740_priv *priv = to_ov9740(sd);
-       int ret;
-
-       /* Program orientation register. */
-       if (priv->flag_vflip)
-               ret = ov9740_reg_rmw(client, OV9740_IMAGE_ORT, 0x2, 0);
-       else
-               ret = ov9740_reg_rmw(client, OV9740_IMAGE_ORT, 0, 0x2);
-       if (ret < 0)
-               return ret;
-
-       if (priv->flag_hflip)
-               ret = ov9740_reg_rmw(client, OV9740_IMAGE_ORT, 0x1, 0);
-       else
-               ret = ov9740_reg_rmw(client, OV9740_IMAGE_ORT, 0, 0x1);
-       if (ret < 0)
-               return ret;
-
-       if (enable) {
-               dev_dbg(&client->dev, "Enabling Streaming\n");
-               /* Start Streaming */
-               ret = ov9740_reg_write(client, OV9740_MODE_SELECT, 0x01);
-
-       } else {
-               dev_dbg(&client->dev, "Disabling Streaming\n");
-               /* Software Reset */
-               ret = ov9740_reg_write(client, OV9740_SOFTWARE_RESET, 0x01);
-               if (!ret)
-                       /* Setting Streaming to Standby */
-                       ret = ov9740_reg_write(client, OV9740_MODE_SELECT,
-                                              0x00);
-       }
-
-       priv->current_enable = enable;
-
-       return ret;
-}
-
-/* select nearest higher resolution for capture */
-static void ov9740_res_roundup(u32 *width, u32 *height)
-{
-       /* Width must be a multiple of 4 pixels. */
-       *width = ALIGN(*width, 4);
-
-       /* Max resolution is 1280x720 (720p). */
-       if (*width > OV9740_MAX_WIDTH)
-               *width = OV9740_MAX_WIDTH;
-
-       if (*height > OV9740_MAX_HEIGHT)
-               *height = OV9740_MAX_HEIGHT;
-}
-
-/* Setup registers according to resolution and color encoding */
-static int ov9740_set_res(struct i2c_client *client, u32 width, u32 height)
-{
-       u32 x_start;
-       u32 y_start;
-       u32 x_end;
-       u32 y_end;
-       bool scaling = 0;
-       u32 scale_input_x;
-       u32 scale_input_y;
-       int ret;
-
-       if ((width != OV9740_MAX_WIDTH) || (height != OV9740_MAX_HEIGHT))
-               scaling = 1;
-
-       /*
-        * Try to use as much of the sensor area as possible when supporting
-        * smaller resolutions.  Depending on the aspect ratio of the
-        * chosen resolution, we can either use the full width of the sensor,
-        * or the full height of the sensor (or both if the aspect ratio is
-        * the same as 1280x720.
-        */
-       if ((OV9740_MAX_WIDTH * height) > (OV9740_MAX_HEIGHT * width)) {
-               scale_input_x = (OV9740_MAX_HEIGHT * width) / height;
-               scale_input_y = OV9740_MAX_HEIGHT;
-       } else {
-               scale_input_x = OV9740_MAX_WIDTH;
-               scale_input_y = (OV9740_MAX_WIDTH * height) / width;
-       }
-
-       /* These describe the area of the sensor to use. */
-       x_start = (OV9740_MAX_WIDTH - scale_input_x) / 2;
-       y_start = (OV9740_MAX_HEIGHT - scale_input_y) / 2;
-       x_end = x_start + scale_input_x - 1;
-       y_end = y_start + scale_input_y - 1;
-
-       ret = ov9740_reg_write(client, OV9740_X_ADDR_START_HI, x_start >> 8);
-       if (ret)
-               goto done;
-       ret = ov9740_reg_write(client, OV9740_X_ADDR_START_LO, x_start & 0xff);
-       if (ret)
-               goto done;
-       ret = ov9740_reg_write(client, OV9740_Y_ADDR_START_HI, y_start >> 8);
-       if (ret)
-               goto done;
-       ret = ov9740_reg_write(client, OV9740_Y_ADDR_START_LO, y_start & 0xff);
-       if (ret)
-               goto done;
-
-       ret = ov9740_reg_write(client, OV9740_X_ADDR_END_HI, x_end >> 8);
-       if (ret)
-               goto done;
-       ret = ov9740_reg_write(client, OV9740_X_ADDR_END_LO, x_end & 0xff);
-       if (ret)
-               goto done;
-       ret = ov9740_reg_write(client, OV9740_Y_ADDR_END_HI, y_end >> 8);
-       if (ret)
-               goto done;
-       ret = ov9740_reg_write(client, OV9740_Y_ADDR_END_LO, y_end & 0xff);
-       if (ret)
-               goto done;
-
-       ret = ov9740_reg_write(client, OV9740_X_OUTPUT_SIZE_HI, width >> 8);
-       if (ret)
-               goto done;
-       ret = ov9740_reg_write(client, OV9740_X_OUTPUT_SIZE_LO, width & 0xff);
-       if (ret)
-               goto done;
-       ret = ov9740_reg_write(client, OV9740_Y_OUTPUT_SIZE_HI, height >> 8);
-       if (ret)
-               goto done;
-       ret = ov9740_reg_write(client, OV9740_Y_OUTPUT_SIZE_LO, height & 0xff);
-       if (ret)
-               goto done;
-
-       ret = ov9740_reg_write(client, OV9740_ISP_CTRL1E, scale_input_x >> 8);
-       if (ret)
-               goto done;
-       ret = ov9740_reg_write(client, OV9740_ISP_CTRL1F, scale_input_x & 0xff);
-       if (ret)
-               goto done;
-       ret = ov9740_reg_write(client, OV9740_ISP_CTRL20, scale_input_y >> 8);
-       if (ret)
-               goto done;
-       ret = ov9740_reg_write(client, OV9740_ISP_CTRL21, scale_input_y & 0xff);
-       if (ret)
-               goto done;
-
-       ret = ov9740_reg_write(client, OV9740_VFIFO_READ_START_HI,
-                              (scale_input_x - width) >> 8);
-       if (ret)
-               goto done;
-       ret = ov9740_reg_write(client, OV9740_VFIFO_READ_START_LO,
-                              (scale_input_x - width) & 0xff);
-       if (ret)
-               goto done;
-
-       ret = ov9740_reg_write(client, OV9740_ISP_CTRL00, 0xff);
-       if (ret)
-               goto done;
-       ret = ov9740_reg_write(client, OV9740_ISP_CTRL01, 0xef |
-                                                         (scaling << 4));
-       if (ret)
-               goto done;
-       ret = ov9740_reg_write(client, OV9740_ISP_CTRL03, 0xff);
-
-done:
-       return ret;
-}
-
-/* set the format we will capture in */
-static int ov9740_s_fmt(struct v4l2_subdev *sd,
-                       struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct ov9740_priv *priv = to_ov9740(sd);
-       enum v4l2_colorspace cspace;
-       enum v4l2_mbus_pixelcode code = mf->code;
-       int ret;
-
-       ov9740_res_roundup(&mf->width, &mf->height);
-
-       switch (code) {
-       case V4L2_MBUS_FMT_YUYV8_2X8:
-               cspace = V4L2_COLORSPACE_SRGB;
-               break;
-       default:
-               return -EINVAL;
-       }
-
-       ret = ov9740_reg_write_array(client, ov9740_defaults,
-                                    ARRAY_SIZE(ov9740_defaults));
-       if (ret < 0)
-               return ret;
-
-       ret = ov9740_set_res(client, mf->width, mf->height);
-       if (ret < 0)
-               return ret;
-
-       mf->code        = code;
-       mf->colorspace  = cspace;
-
-       memcpy(&priv->current_mf, mf, sizeof(struct v4l2_mbus_framefmt));
-
-       return ret;
-}
-
-static int ov9740_try_fmt(struct v4l2_subdev *sd,
-                         struct v4l2_mbus_framefmt *mf)
-{
-       ov9740_res_roundup(&mf->width, &mf->height);
-
-       mf->field = V4L2_FIELD_NONE;
-       mf->code = V4L2_MBUS_FMT_YUYV8_2X8;
-       mf->colorspace = V4L2_COLORSPACE_SRGB;
-
-       return 0;
-}
-
-static int ov9740_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                          enum v4l2_mbus_pixelcode *code)
-{
-       if (index >= ARRAY_SIZE(ov9740_codes))
-               return -EINVAL;
-
-       *code = ov9740_codes[index];
-
-       return 0;
-}
-
-static int ov9740_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
-{
-       a->bounds.left          = 0;
-       a->bounds.top           = 0;
-       a->bounds.width         = OV9740_MAX_WIDTH;
-       a->bounds.height        = OV9740_MAX_HEIGHT;
-       a->defrect              = a->bounds;
-       a->type                 = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-       a->pixelaspect.numerator        = 1;
-       a->pixelaspect.denominator      = 1;
-
-       return 0;
-}
-
-static int ov9740_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
-{
-       a->c.left               = 0;
-       a->c.top                = 0;
-       a->c.width              = OV9740_MAX_WIDTH;
-       a->c.height             = OV9740_MAX_HEIGHT;
-       a->type                 = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-
-       return 0;
-}
-
-/* Set status of additional camera capabilities */
-static int ov9740_s_ctrl(struct v4l2_ctrl *ctrl)
-{
-       struct ov9740_priv *priv =
-               container_of(ctrl->handler, struct ov9740_priv, hdl);
-
-       switch (ctrl->id) {
-       case V4L2_CID_VFLIP:
-               priv->flag_vflip = ctrl->val;
-               break;
-       case V4L2_CID_HFLIP:
-               priv->flag_hflip = ctrl->val;
-               break;
-       default:
-               return -EINVAL;
-       }
-
-       return 0;
-}
-
-/* Get chip identification */
-static int ov9740_g_chip_ident(struct v4l2_subdev *sd,
-                              struct v4l2_dbg_chip_ident *id)
-{
-       struct ov9740_priv *priv = to_ov9740(sd);
-
-       id->ident = priv->ident;
-       id->revision = priv->revision;
-
-       return 0;
-}
-
-static int ov9740_s_power(struct v4l2_subdev *sd, int on)
-{
-       struct ov9740_priv *priv = to_ov9740(sd);
-
-       if (!priv->current_enable)
-               return 0;
-
-       if (on) {
-               ov9740_s_fmt(sd, &priv->current_mf);
-               ov9740_s_stream(sd, priv->current_enable);
-       } else {
-               ov9740_s_stream(sd, 0);
-               priv->current_enable = true;
-       }
-
-       return 0;
-}
-
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-static int ov9740_get_register(struct v4l2_subdev *sd,
-                              struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       int ret;
-       u8 val;
-
-       if (reg->reg & ~0xffff)
-               return -EINVAL;
-
-       reg->size = 2;
-
-       ret = ov9740_reg_read(client, reg->reg, &val);
-       if (ret)
-               return ret;
-
-       reg->val = (__u64)val;
-
-       return ret;
-}
-
-static int ov9740_set_register(struct v4l2_subdev *sd,
-                              struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-
-       if (reg->reg & ~0xffff || reg->val & ~0xff)
-               return -EINVAL;
-
-       return ov9740_reg_write(client, reg->reg, reg->val);
-}
-#endif
-
-static int ov9740_video_probe(struct i2c_client *client)
-{
-       struct v4l2_subdev *sd = i2c_get_clientdata(client);
-       struct ov9740_priv *priv = to_ov9740(sd);
-       u8 modelhi, modello;
-       int ret;
-
-       /*
-        * check and show product ID and manufacturer ID
-        */
-       ret = ov9740_reg_read(client, OV9740_MODEL_ID_HI, &modelhi);
-       if (ret < 0)
-               goto err;
-
-       ret = ov9740_reg_read(client, OV9740_MODEL_ID_LO, &modello);
-       if (ret < 0)
-               goto err;
-
-       priv->model = (modelhi << 8) | modello;
-
-       ret = ov9740_reg_read(client, OV9740_REVISION_NUMBER, &priv->revision);
-       if (ret < 0)
-               goto err;
-
-       ret = ov9740_reg_read(client, OV9740_MANUFACTURER_ID, &priv->manid);
-       if (ret < 0)
-               goto err;
-
-       ret = ov9740_reg_read(client, OV9740_SMIA_VERSION, &priv->smiaver);
-       if (ret < 0)
-               goto err;
-
-       if (priv->model != 0x9740) {
-               ret = -ENODEV;
-               goto err;
-       }
-
-       priv->ident = V4L2_IDENT_OV9740;
-
-       dev_info(&client->dev, "ov9740 Model ID 0x%04x, Revision 0x%02x, "
-                "Manufacturer 0x%02x, SMIA Version 0x%02x\n",
-                priv->model, priv->revision, priv->manid, priv->smiaver);
-
-err:
-       return ret;
-}
-
-/* Request bus settings on camera side */
-static int ov9740_g_mbus_config(struct v4l2_subdev *sd,
-                               struct v4l2_mbus_config *cfg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-
-       cfg->flags = V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_MASTER |
-               V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_HSYNC_ACTIVE_HIGH |
-               V4L2_MBUS_DATA_ACTIVE_HIGH;
-       cfg->type = V4L2_MBUS_PARALLEL;
-       cfg->flags = soc_camera_apply_board_flags(icl, cfg);
-
-       return 0;
-}
-
-static struct v4l2_subdev_video_ops ov9740_video_ops = {
-       .s_stream       = ov9740_s_stream,
-       .s_mbus_fmt     = ov9740_s_fmt,
-       .try_mbus_fmt   = ov9740_try_fmt,
-       .enum_mbus_fmt  = ov9740_enum_fmt,
-       .cropcap        = ov9740_cropcap,
-       .g_crop         = ov9740_g_crop,
-       .g_mbus_config  = ov9740_g_mbus_config,
-};
-
-static struct v4l2_subdev_core_ops ov9740_core_ops = {
-       .g_chip_ident           = ov9740_g_chip_ident,
-       .s_power                = ov9740_s_power,
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-       .g_register             = ov9740_get_register,
-       .s_register             = ov9740_set_register,
-#endif
-};
-
-static struct v4l2_subdev_ops ov9740_subdev_ops = {
-       .core                   = &ov9740_core_ops,
-       .video                  = &ov9740_video_ops,
-};
-
-static const struct v4l2_ctrl_ops ov9740_ctrl_ops = {
-       .s_ctrl = ov9740_s_ctrl,
-};
-
-/*
- * i2c_driver function
- */
-static int ov9740_probe(struct i2c_client *client,
-                       const struct i2c_device_id *did)
-{
-       struct ov9740_priv *priv;
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-       int ret;
-
-       if (!icl) {
-               dev_err(&client->dev, "Missing platform_data for driver\n");
-               return -EINVAL;
-       }
-
-       priv = kzalloc(sizeof(struct ov9740_priv), GFP_KERNEL);
-       if (!priv) {
-               dev_err(&client->dev, "Failed to allocate private data!\n");
-               return -ENOMEM;
-       }
-
-       v4l2_i2c_subdev_init(&priv->subdev, client, &ov9740_subdev_ops);
-       v4l2_ctrl_handler_init(&priv->hdl, 13);
-       v4l2_ctrl_new_std(&priv->hdl, &ov9740_ctrl_ops,
-                       V4L2_CID_VFLIP, 0, 1, 1, 0);
-       v4l2_ctrl_new_std(&priv->hdl, &ov9740_ctrl_ops,
-                       V4L2_CID_HFLIP, 0, 1, 1, 0);
-       priv->subdev.ctrl_handler = &priv->hdl;
-       if (priv->hdl.error) {
-               int err = priv->hdl.error;
-
-               kfree(priv);
-               return err;
-       }
-
-       ret = ov9740_video_probe(client);
-       if (!ret)
-               ret = v4l2_ctrl_handler_setup(&priv->hdl);
-       if (ret < 0) {
-               v4l2_ctrl_handler_free(&priv->hdl);
-               kfree(priv);
-       }
-
-       return ret;
-}
-
-static int ov9740_remove(struct i2c_client *client)
-{
-       struct ov9740_priv *priv = i2c_get_clientdata(client);
-
-       v4l2_device_unregister_subdev(&priv->subdev);
-       v4l2_ctrl_handler_free(&priv->hdl);
-       kfree(priv);
-       return 0;
-}
-
-static const struct i2c_device_id ov9740_id[] = {
-       { "ov9740", 0 },
-       { }
-};
-MODULE_DEVICE_TABLE(i2c, ov9740_id);
-
-static struct i2c_driver ov9740_i2c_driver = {
-       .driver = {
-               .name = "ov9740",
-       },
-       .probe    = ov9740_probe,
-       .remove   = ov9740_remove,
-       .id_table = ov9740_id,
-};
-
-module_i2c_driver(ov9740_i2c_driver);
-
-MODULE_DESCRIPTION("SoC Camera driver for OmniVision OV9740");
-MODULE_AUTHOR("Andrew Chew <achew@nvidia.com>");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/video/rj54n1cb0c.c b/drivers/media/video/rj54n1cb0c.c
deleted file mode 100644 (file)
index f6419b2..0000000
+++ /dev/null
@@ -1,1414 +0,0 @@
-/*
- * Driver for RJ54N1CB0C CMOS Image Sensor from Sharp
- *
- * Copyright (C) 2009, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include <linux/delay.h>
-#include <linux/i2c.h>
-#include <linux/slab.h>
-#include <linux/v4l2-mediabus.h>
-#include <linux/videodev2.h>
-#include <linux/module.h>
-
-#include <media/rj54n1cb0c.h>
-#include <media/soc_camera.h>
-#include <media/v4l2-subdev.h>
-#include <media/v4l2-chip-ident.h>
-#include <media/v4l2-ctrls.h>
-
-#define RJ54N1_DEV_CODE                        0x0400
-#define RJ54N1_DEV_CODE2               0x0401
-#define RJ54N1_OUT_SEL                 0x0403
-#define RJ54N1_XY_OUTPUT_SIZE_S_H      0x0404
-#define RJ54N1_X_OUTPUT_SIZE_S_L       0x0405
-#define RJ54N1_Y_OUTPUT_SIZE_S_L       0x0406
-#define RJ54N1_XY_OUTPUT_SIZE_P_H      0x0407
-#define RJ54N1_X_OUTPUT_SIZE_P_L       0x0408
-#define RJ54N1_Y_OUTPUT_SIZE_P_L       0x0409
-#define RJ54N1_LINE_LENGTH_PCK_S_H     0x040a
-#define RJ54N1_LINE_LENGTH_PCK_S_L     0x040b
-#define RJ54N1_LINE_LENGTH_PCK_P_H     0x040c
-#define RJ54N1_LINE_LENGTH_PCK_P_L     0x040d
-#define RJ54N1_RESIZE_N                        0x040e
-#define RJ54N1_RESIZE_N_STEP           0x040f
-#define RJ54N1_RESIZE_STEP             0x0410
-#define RJ54N1_RESIZE_HOLD_H           0x0411
-#define RJ54N1_RESIZE_HOLD_L           0x0412
-#define RJ54N1_H_OBEN_OFS              0x0413
-#define RJ54N1_V_OBEN_OFS              0x0414
-#define RJ54N1_RESIZE_CONTROL          0x0415
-#define RJ54N1_STILL_CONTROL           0x0417
-#define RJ54N1_INC_USE_SEL_H           0x0425
-#define RJ54N1_INC_USE_SEL_L           0x0426
-#define RJ54N1_MIRROR_STILL_MODE       0x0427
-#define RJ54N1_INIT_START              0x0428
-#define RJ54N1_SCALE_1_2_LEV           0x0429
-#define RJ54N1_SCALE_4_LEV             0x042a
-#define RJ54N1_Y_GAIN                  0x04d8
-#define RJ54N1_APT_GAIN_UP             0x04fa
-#define RJ54N1_RA_SEL_UL               0x0530
-#define RJ54N1_BYTE_SWAP               0x0531
-#define RJ54N1_OUT_SIGPO               0x053b
-#define RJ54N1_WB_SEL_WEIGHT_I         0x054e
-#define RJ54N1_BIT8_WB                 0x0569
-#define RJ54N1_HCAPS_WB                        0x056a
-#define RJ54N1_VCAPS_WB                        0x056b
-#define RJ54N1_HCAPE_WB                        0x056c
-#define RJ54N1_VCAPE_WB                        0x056d
-#define RJ54N1_EXPOSURE_CONTROL                0x058c
-#define RJ54N1_FRAME_LENGTH_S_H                0x0595
-#define RJ54N1_FRAME_LENGTH_S_L                0x0596
-#define RJ54N1_FRAME_LENGTH_P_H                0x0597
-#define RJ54N1_FRAME_LENGTH_P_L                0x0598
-#define RJ54N1_PEAK_H                  0x05b7
-#define RJ54N1_PEAK_50                 0x05b8
-#define RJ54N1_PEAK_60                 0x05b9
-#define RJ54N1_PEAK_DIFF               0x05ba
-#define RJ54N1_IOC                     0x05ef
-#define RJ54N1_TG_BYPASS               0x0700
-#define RJ54N1_PLL_L                   0x0701
-#define RJ54N1_PLL_N                   0x0702
-#define RJ54N1_PLL_EN                  0x0704
-#define RJ54N1_RATIO_TG                        0x0706
-#define RJ54N1_RATIO_T                 0x0707
-#define RJ54N1_RATIO_R                 0x0708
-#define RJ54N1_RAMP_TGCLK_EN           0x0709
-#define RJ54N1_OCLK_DSP                        0x0710
-#define RJ54N1_RATIO_OP                        0x0711
-#define RJ54N1_RATIO_O                 0x0712
-#define RJ54N1_OCLK_SEL_EN             0x0713
-#define RJ54N1_CLK_RST                 0x0717
-#define RJ54N1_RESET_STANDBY           0x0718
-#define RJ54N1_FWFLG                   0x07fe
-
-#define E_EXCLK                                (1 << 7)
-#define SOFT_STDBY                     (1 << 4)
-#define SEN_RSTX                       (1 << 2)
-#define TG_RSTX                                (1 << 1)
-#define DSP_RSTX                       (1 << 0)
-
-#define RESIZE_HOLD_SEL                        (1 << 2)
-#define RESIZE_GO                      (1 << 1)
-
-/*
- * When cropping, the camera automatically centers the cropped region, there
- * doesn't seem to be a way to specify an explicit location of the rectangle.
- */
-#define RJ54N1_COLUMN_SKIP             0
-#define RJ54N1_ROW_SKIP                        0
-#define RJ54N1_MAX_WIDTH               1600
-#define RJ54N1_MAX_HEIGHT              1200
-
-#define PLL_L                          2
-#define PLL_N                          0x31
-
-/* I2C addresses: 0x50, 0x51, 0x60, 0x61 */
-
-/* RJ54N1CB0C has only one fixed colorspace per pixelcode */
-struct rj54n1_datafmt {
-       enum v4l2_mbus_pixelcode        code;
-       enum v4l2_colorspace            colorspace;
-};
-
-/* Find a data format by a pixel code in an array */
-static const struct rj54n1_datafmt *rj54n1_find_datafmt(
-       enum v4l2_mbus_pixelcode code, const struct rj54n1_datafmt *fmt,
-       int n)
-{
-       int i;
-       for (i = 0; i < n; i++)
-               if (fmt[i].code == code)
-                       return fmt + i;
-
-       return NULL;
-}
-
-static const struct rj54n1_datafmt rj54n1_colour_fmts[] = {
-       {V4L2_MBUS_FMT_YUYV8_2X8, V4L2_COLORSPACE_JPEG},
-       {V4L2_MBUS_FMT_YVYU8_2X8, V4L2_COLORSPACE_JPEG},
-       {V4L2_MBUS_FMT_RGB565_2X8_LE, V4L2_COLORSPACE_SRGB},
-       {V4L2_MBUS_FMT_RGB565_2X8_BE, V4L2_COLORSPACE_SRGB},
-       {V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE, V4L2_COLORSPACE_SRGB},
-       {V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_LE, V4L2_COLORSPACE_SRGB},
-       {V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_BE, V4L2_COLORSPACE_SRGB},
-       {V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_BE, V4L2_COLORSPACE_SRGB},
-       {V4L2_MBUS_FMT_SBGGR10_1X10, V4L2_COLORSPACE_SRGB},
-};
-
-struct rj54n1_clock_div {
-       u8 ratio_tg;    /* can be 0 or an odd number */
-       u8 ratio_t;
-       u8 ratio_r;
-       u8 ratio_op;
-       u8 ratio_o;
-};
-
-struct rj54n1 {
-       struct v4l2_subdev subdev;
-       struct v4l2_ctrl_handler hdl;
-       struct rj54n1_clock_div clk_div;
-       const struct rj54n1_datafmt *fmt;
-       struct v4l2_rect rect;  /* Sensor window */
-       unsigned int tgclk_mhz;
-       bool auto_wb;
-       unsigned short width;   /* Output window */
-       unsigned short height;
-       unsigned short resize;  /* Sensor * 1024 / resize = Output */
-       unsigned short scale;
-       u8 bank;
-};
-
-struct rj54n1_reg_val {
-       u16 reg;
-       u8 val;
-};
-
-static const struct rj54n1_reg_val bank_4[] = {
-       {0x417, 0},
-       {0x42c, 0},
-       {0x42d, 0xf0},
-       {0x42e, 0},
-       {0x42f, 0x50},
-       {0x430, 0xf5},
-       {0x431, 0x16},
-       {0x432, 0x20},
-       {0x433, 0},
-       {0x434, 0xc8},
-       {0x43c, 8},
-       {0x43e, 0x90},
-       {0x445, 0x83},
-       {0x4ba, 0x58},
-       {0x4bb, 4},
-       {0x4bc, 0x20},
-       {0x4db, 4},
-       {0x4fe, 2},
-};
-
-static const struct rj54n1_reg_val bank_5[] = {
-       {0x514, 0},
-       {0x516, 0},
-       {0x518, 0},
-       {0x51a, 0},
-       {0x51d, 0xff},
-       {0x56f, 0x28},
-       {0x575, 0x40},
-       {0x5bc, 0x48},
-       {0x5c1, 6},
-       {0x5e5, 0x11},
-       {0x5e6, 0x43},
-       {0x5e7, 0x33},
-       {0x5e8, 0x21},
-       {0x5e9, 0x30},
-       {0x5ea, 0x0},
-       {0x5eb, 0xa5},
-       {0x5ec, 0xff},
-       {0x5fe, 2},
-};
-
-static const struct rj54n1_reg_val bank_7[] = {
-       {0x70a, 0},
-       {0x714, 0xff},
-       {0x715, 0xff},
-       {0x716, 0x1f},
-       {0x7FE, 2},
-};
-
-static const struct rj54n1_reg_val bank_8[] = {
-       {0x800, 0x00},
-       {0x801, 0x01},
-       {0x802, 0x61},
-       {0x805, 0x00},
-       {0x806, 0x00},
-       {0x807, 0x00},
-       {0x808, 0x00},
-       {0x809, 0x01},
-       {0x80A, 0x61},
-       {0x80B, 0x00},
-       {0x80C, 0x01},
-       {0x80D, 0x00},
-       {0x80E, 0x00},
-       {0x80F, 0x00},
-       {0x810, 0x00},
-       {0x811, 0x01},
-       {0x812, 0x61},
-       {0x813, 0x00},
-       {0x814, 0x11},
-       {0x815, 0x00},
-       {0x816, 0x41},
-       {0x817, 0x00},
-       {0x818, 0x51},
-       {0x819, 0x01},
-       {0x81A, 0x1F},
-       {0x81B, 0x00},
-       {0x81C, 0x01},
-       {0x81D, 0x00},
-       {0x81E, 0x11},
-       {0x81F, 0x00},
-       {0x820, 0x41},
-       {0x821, 0x00},
-       {0x822, 0x51},
-       {0x823, 0x00},
-       {0x824, 0x00},
-       {0x825, 0x00},
-       {0x826, 0x47},
-       {0x827, 0x01},
-       {0x828, 0x4F},
-       {0x829, 0x00},
-       {0x82A, 0x00},
-       {0x82B, 0x00},
-       {0x82C, 0x30},
-       {0x82D, 0x00},
-       {0x82E, 0x40},
-       {0x82F, 0x00},
-       {0x830, 0xB3},
-       {0x831, 0x00},
-       {0x832, 0xE3},
-       {0x833, 0x00},
-       {0x834, 0x00},
-       {0x835, 0x00},
-       {0x836, 0x00},
-       {0x837, 0x00},
-       {0x838, 0x00},
-       {0x839, 0x01},
-       {0x83A, 0x61},
-       {0x83B, 0x00},
-       {0x83C, 0x01},
-       {0x83D, 0x00},
-       {0x83E, 0x00},
-       {0x83F, 0x00},
-       {0x840, 0x00},
-       {0x841, 0x01},
-       {0x842, 0x61},
-       {0x843, 0x00},
-       {0x844, 0x1D},
-       {0x845, 0x00},
-       {0x846, 0x00},
-       {0x847, 0x00},
-       {0x848, 0x00},
-       {0x849, 0x01},
-       {0x84A, 0x1F},
-       {0x84B, 0x00},
-       {0x84C, 0x05},
-       {0x84D, 0x00},
-       {0x84E, 0x19},
-       {0x84F, 0x01},
-       {0x850, 0x21},
-       {0x851, 0x01},
-       {0x852, 0x5D},
-       {0x853, 0x00},
-       {0x854, 0x00},
-       {0x855, 0x00},
-       {0x856, 0x19},
-       {0x857, 0x01},
-       {0x858, 0x21},
-       {0x859, 0x00},
-       {0x85A, 0x00},
-       {0x85B, 0x00},
-       {0x85C, 0x00},
-       {0x85D, 0x00},
-       {0x85E, 0x00},
-       {0x85F, 0x00},
-       {0x860, 0xB3},
-       {0x861, 0x00},
-       {0x862, 0xE3},
-       {0x863, 0x00},
-       {0x864, 0x00},
-       {0x865, 0x00},
-       {0x866, 0x00},
-       {0x867, 0x00},
-       {0x868, 0x00},
-       {0x869, 0xE2},
-       {0x86A, 0x00},
-       {0x86B, 0x01},
-       {0x86C, 0x06},
-       {0x86D, 0x00},
-       {0x86E, 0x00},
-       {0x86F, 0x00},
-       {0x870, 0x60},
-       {0x871, 0x8C},
-       {0x872, 0x10},
-       {0x873, 0x00},
-       {0x874, 0xE0},
-       {0x875, 0x00},
-       {0x876, 0x27},
-       {0x877, 0x01},
-       {0x878, 0x00},
-       {0x879, 0x00},
-       {0x87A, 0x00},
-       {0x87B, 0x03},
-       {0x87C, 0x00},
-       {0x87D, 0x00},
-       {0x87E, 0x00},
-       {0x87F, 0x00},
-       {0x880, 0x00},
-       {0x881, 0x00},
-       {0x882, 0x00},
-       {0x883, 0x00},
-       {0x884, 0x00},
-       {0x885, 0x00},
-       {0x886, 0xF8},
-       {0x887, 0x00},
-       {0x888, 0x03},
-       {0x889, 0x00},
-       {0x88A, 0x64},
-       {0x88B, 0x00},
-       {0x88C, 0x03},
-       {0x88D, 0x00},
-       {0x88E, 0xB1},
-       {0x88F, 0x00},
-       {0x890, 0x03},
-       {0x891, 0x01},
-       {0x892, 0x1D},
-       {0x893, 0x00},
-       {0x894, 0x03},
-       {0x895, 0x01},
-       {0x896, 0x4B},
-       {0x897, 0x00},
-       {0x898, 0xE5},
-       {0x899, 0x00},
-       {0x89A, 0x01},
-       {0x89B, 0x00},
-       {0x89C, 0x01},
-       {0x89D, 0x04},
-       {0x89E, 0xC8},
-       {0x89F, 0x00},
-       {0x8A0, 0x01},
-       {0x8A1, 0x01},
-       {0x8A2, 0x61},
-       {0x8A3, 0x00},
-       {0x8A4, 0x01},
-       {0x8A5, 0x00},
-       {0x8A6, 0x00},
-       {0x8A7, 0x00},
-       {0x8A8, 0x00},
-       {0x8A9, 0x00},
-       {0x8AA, 0x7F},
-       {0x8AB, 0x03},
-       {0x8AC, 0x00},
-       {0x8AD, 0x00},
-       {0x8AE, 0x00},
-       {0x8AF, 0x00},
-       {0x8B0, 0x00},
-       {0x8B1, 0x00},
-       {0x8B6, 0x00},
-       {0x8B7, 0x01},
-       {0x8B8, 0x00},
-       {0x8B9, 0x00},
-       {0x8BA, 0x02},
-       {0x8BB, 0x00},
-       {0x8BC, 0xFF},
-       {0x8BD, 0x00},
-       {0x8FE, 2},
-};
-
-static const struct rj54n1_reg_val bank_10[] = {
-       {0x10bf, 0x69}
-};
-
-/* Clock dividers - these are default register values, divider = register + 1 */
-static const struct rj54n1_clock_div clk_div = {
-       .ratio_tg       = 3 /* default: 5 */,
-       .ratio_t        = 4 /* default: 1 */,
-       .ratio_r        = 4 /* default: 0 */,
-       .ratio_op       = 1 /* default: 5 */,
-       .ratio_o        = 9 /* default: 0 */,
-};
-
-static struct rj54n1 *to_rj54n1(const struct i2c_client *client)
-{
-       return container_of(i2c_get_clientdata(client), struct rj54n1, subdev);
-}
-
-static int reg_read(struct i2c_client *client, const u16 reg)
-{
-       struct rj54n1 *rj54n1 = to_rj54n1(client);
-       int ret;
-
-       /* set bank */
-       if (rj54n1->bank != reg >> 8) {
-               dev_dbg(&client->dev, "[0x%x] = 0x%x\n", 0xff, reg >> 8);
-               ret = i2c_smbus_write_byte_data(client, 0xff, reg >> 8);
-               if (ret < 0)
-                       return ret;
-               rj54n1->bank = reg >> 8;
-       }
-       return i2c_smbus_read_byte_data(client, reg & 0xff);
-}
-
-static int reg_write(struct i2c_client *client, const u16 reg,
-                    const u8 data)
-{
-       struct rj54n1 *rj54n1 = to_rj54n1(client);
-       int ret;
-
-       /* set bank */
-       if (rj54n1->bank != reg >> 8) {
-               dev_dbg(&client->dev, "[0x%x] = 0x%x\n", 0xff, reg >> 8);
-               ret = i2c_smbus_write_byte_data(client, 0xff, reg >> 8);
-               if (ret < 0)
-                       return ret;
-               rj54n1->bank = reg >> 8;
-       }
-       dev_dbg(&client->dev, "[0x%x] = 0x%x\n", reg & 0xff, data);
-       return i2c_smbus_write_byte_data(client, reg & 0xff, data);
-}
-
-static int reg_set(struct i2c_client *client, const u16 reg,
-                  const u8 data, const u8 mask)
-{
-       int ret;
-
-       ret = reg_read(client, reg);
-       if (ret < 0)
-               return ret;
-       return reg_write(client, reg, (ret & ~mask) | (data & mask));
-}
-
-static int reg_write_multiple(struct i2c_client *client,
-                             const struct rj54n1_reg_val *rv, const int n)
-{
-       int i, ret;
-
-       for (i = 0; i < n; i++) {
-               ret = reg_write(client, rv->reg, rv->val);
-               if (ret < 0)
-                       return ret;
-               rv++;
-       }
-
-       return 0;
-}
-
-static int rj54n1_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                          enum v4l2_mbus_pixelcode *code)
-{
-       if (index >= ARRAY_SIZE(rj54n1_colour_fmts))
-               return -EINVAL;
-
-       *code = rj54n1_colour_fmts[index].code;
-       return 0;
-}
-
-static int rj54n1_s_stream(struct v4l2_subdev *sd, int enable)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-
-       /* Switch between preview and still shot modes */
-       return reg_set(client, RJ54N1_STILL_CONTROL, (!enable) << 7, 0x80);
-}
-
-static int rj54n1_set_rect(struct i2c_client *client,
-                          u16 reg_x, u16 reg_y, u16 reg_xy,
-                          u32 width, u32 height)
-{
-       int ret;
-
-       ret = reg_write(client, reg_xy,
-                       ((width >> 4) & 0x70) |
-                       ((height >> 8) & 7));
-
-       if (!ret)
-               ret = reg_write(client, reg_x, width & 0xff);
-       if (!ret)
-               ret = reg_write(client, reg_y, height & 0xff);
-
-       return ret;
-}
-
-/*
- * Some commands, specifically certain initialisation sequences, require
- * a commit operation.
- */
-static int rj54n1_commit(struct i2c_client *client)
-{
-       int ret = reg_write(client, RJ54N1_INIT_START, 1);
-       msleep(10);
-       if (!ret)
-               ret = reg_write(client, RJ54N1_INIT_START, 0);
-       return ret;
-}
-
-static int rj54n1_sensor_scale(struct v4l2_subdev *sd, s32 *in_w, s32 *in_h,
-                              s32 *out_w, s32 *out_h);
-
-static int rj54n1_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct rj54n1 *rj54n1 = to_rj54n1(client);
-       struct v4l2_rect *rect = &a->c;
-       int dummy = 0, output_w, output_h,
-               input_w = rect->width, input_h = rect->height;
-       int ret;
-
-       /* arbitrary minimum width and height, edges unimportant */
-       soc_camera_limit_side(&dummy, &input_w,
-                    RJ54N1_COLUMN_SKIP, 8, RJ54N1_MAX_WIDTH);
-
-       soc_camera_limit_side(&dummy, &input_h,
-                    RJ54N1_ROW_SKIP, 8, RJ54N1_MAX_HEIGHT);
-
-       output_w = (input_w * 1024 + rj54n1->resize / 2) / rj54n1->resize;
-       output_h = (input_h * 1024 + rj54n1->resize / 2) / rj54n1->resize;
-
-       dev_dbg(&client->dev, "Scaling for %dx%d : %u = %dx%d\n",
-               input_w, input_h, rj54n1->resize, output_w, output_h);
-
-       ret = rj54n1_sensor_scale(sd, &input_w, &input_h, &output_w, &output_h);
-       if (ret < 0)
-               return ret;
-
-       rj54n1->width           = output_w;
-       rj54n1->height          = output_h;
-       rj54n1->resize          = ret;
-       rj54n1->rect.width      = input_w;
-       rj54n1->rect.height     = input_h;
-
-       return 0;
-}
-
-static int rj54n1_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct rj54n1 *rj54n1 = to_rj54n1(client);
-
-       a->c    = rj54n1->rect;
-       a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-
-       return 0;
-}
-
-static int rj54n1_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
-{
-       a->bounds.left                  = RJ54N1_COLUMN_SKIP;
-       a->bounds.top                   = RJ54N1_ROW_SKIP;
-       a->bounds.width                 = RJ54N1_MAX_WIDTH;
-       a->bounds.height                = RJ54N1_MAX_HEIGHT;
-       a->defrect                      = a->bounds;
-       a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-       a->pixelaspect.numerator        = 1;
-       a->pixelaspect.denominator      = 1;
-
-       return 0;
-}
-
-static int rj54n1_g_fmt(struct v4l2_subdev *sd,
-                       struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct rj54n1 *rj54n1 = to_rj54n1(client);
-
-       mf->code        = rj54n1->fmt->code;
-       mf->colorspace  = rj54n1->fmt->colorspace;
-       mf->field       = V4L2_FIELD_NONE;
-       mf->width       = rj54n1->width;
-       mf->height      = rj54n1->height;
-
-       return 0;
-}
-
-/*
- * The actual geometry configuration routine. It scales the input window into
- * the output one, updates the window sizes and returns an error or the resize
- * coefficient on success. Note: we only use the "Fixed Scaling" on this camera.
- */
-static int rj54n1_sensor_scale(struct v4l2_subdev *sd, s32 *in_w, s32 *in_h,
-                              s32 *out_w, s32 *out_h)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct rj54n1 *rj54n1 = to_rj54n1(client);
-       unsigned int skip, resize, input_w = *in_w, input_h = *in_h,
-               output_w = *out_w, output_h = *out_h;
-       u16 inc_sel, wb_bit8, wb_left, wb_right, wb_top, wb_bottom;
-       unsigned int peak, peak_50, peak_60;
-       int ret;
-
-       /*
-        * We have a problem with crops, where the window is larger than 512x384
-        * and output window is larger than a half of the input one. In this
-        * case we have to either reduce the input window to equal or below
-        * 512x384 or the output window to equal or below 1/2 of the input.
-        */
-       if (output_w > max(512U, input_w / 2)) {
-               if (2 * output_w > RJ54N1_MAX_WIDTH) {
-                       input_w = RJ54N1_MAX_WIDTH;
-                       output_w = RJ54N1_MAX_WIDTH / 2;
-               } else {
-                       input_w = output_w * 2;
-               }
-
-               dev_dbg(&client->dev, "Adjusted output width: in %u, out %u\n",
-                       input_w, output_w);
-       }
-
-       if (output_h > max(384U, input_h / 2)) {
-               if (2 * output_h > RJ54N1_MAX_HEIGHT) {
-                       input_h = RJ54N1_MAX_HEIGHT;
-                       output_h = RJ54N1_MAX_HEIGHT / 2;
-               } else {
-                       input_h = output_h * 2;
-               }
-
-               dev_dbg(&client->dev, "Adjusted output height: in %u, out %u\n",
-                       input_h, output_h);
-       }
-
-       /* Idea: use the read mode for snapshots, handle separate geometries */
-       ret = rj54n1_set_rect(client, RJ54N1_X_OUTPUT_SIZE_S_L,
-                             RJ54N1_Y_OUTPUT_SIZE_S_L,
-                             RJ54N1_XY_OUTPUT_SIZE_S_H, output_w, output_h);
-       if (!ret)
-               ret = rj54n1_set_rect(client, RJ54N1_X_OUTPUT_SIZE_P_L,
-                             RJ54N1_Y_OUTPUT_SIZE_P_L,
-                             RJ54N1_XY_OUTPUT_SIZE_P_H, output_w, output_h);
-
-       if (ret < 0)
-               return ret;
-
-       if (output_w > input_w && output_h > input_h) {
-               input_w = output_w;
-               input_h = output_h;
-
-               resize = 1024;
-       } else {
-               unsigned int resize_x, resize_y;
-               resize_x = (input_w * 1024 + output_w / 2) / output_w;
-               resize_y = (input_h * 1024 + output_h / 2) / output_h;
-
-               /* We want max(resize_x, resize_y), check if it still fits */
-               if (resize_x > resize_y &&
-                   (output_h * resize_x + 512) / 1024 > RJ54N1_MAX_HEIGHT)
-                       resize = (RJ54N1_MAX_HEIGHT * 1024 + output_h / 2) /
-                               output_h;
-               else if (resize_y > resize_x &&
-                        (output_w * resize_y + 512) / 1024 > RJ54N1_MAX_WIDTH)
-                       resize = (RJ54N1_MAX_WIDTH * 1024 + output_w / 2) /
-                               output_w;
-               else
-                       resize = max(resize_x, resize_y);
-
-               /* Prohibited value ranges */
-               switch (resize) {
-               case 2040 ... 2047:
-                       resize = 2039;
-                       break;
-               case 4080 ... 4095:
-                       resize = 4079;
-                       break;
-               case 8160 ... 8191:
-                       resize = 8159;
-                       break;
-               case 16320 ... 16384:
-                       resize = 16319;
-               }
-       }
-
-       /* Set scaling */
-       ret = reg_write(client, RJ54N1_RESIZE_HOLD_L, resize & 0xff);
-       if (!ret)
-               ret = reg_write(client, RJ54N1_RESIZE_HOLD_H, resize >> 8);
-
-       if (ret < 0)
-               return ret;
-
-       /*
-        * Configure a skipping bitmask. The sensor will select a skipping value
-        * among set bits automatically. This is very unclear in the datasheet
-        * too. I was told, in this register one enables all skipping values,
-        * that are required for a specific resize, and the camera selects
-        * automatically, which ones to use. But it is unclear how to identify,
-        * which cropping values are needed. Secondly, why don't we just set all
-        * bits and let the camera choose? Would it increase processing time and
-        * reduce the framerate? Using 0xfffc for INC_USE_SEL doesn't seem to
-        * improve the image quality or stability for larger frames (see comment
-        * above), but I didn't check the framerate.
-        */
-       skip = min(resize / 1024, 15U);
-
-       inc_sel = 1 << skip;
-
-       if (inc_sel <= 2)
-               inc_sel = 0xc;
-       else if (resize & 1023 && skip < 15)
-               inc_sel |= 1 << (skip + 1);
-
-       ret = reg_write(client, RJ54N1_INC_USE_SEL_L, inc_sel & 0xfc);
-       if (!ret)
-               ret = reg_write(client, RJ54N1_INC_USE_SEL_H, inc_sel >> 8);
-
-       if (!rj54n1->auto_wb) {
-               /* Auto white balance window */
-               wb_left   = output_w / 16;
-               wb_right  = (3 * output_w / 4 - 3) / 4;
-               wb_top    = output_h / 16;
-               wb_bottom = (3 * output_h / 4 - 3) / 4;
-               wb_bit8   = ((wb_left >> 2) & 0x40) | ((wb_top >> 4) & 0x10) |
-                       ((wb_right >> 6) & 4) | ((wb_bottom >> 8) & 1);
-
-               if (!ret)
-                       ret = reg_write(client, RJ54N1_BIT8_WB, wb_bit8);
-               if (!ret)
-                       ret = reg_write(client, RJ54N1_HCAPS_WB, wb_left);
-               if (!ret)
-                       ret = reg_write(client, RJ54N1_VCAPS_WB, wb_top);
-               if (!ret)
-                       ret = reg_write(client, RJ54N1_HCAPE_WB, wb_right);
-               if (!ret)
-                       ret = reg_write(client, RJ54N1_VCAPE_WB, wb_bottom);
-       }
-
-       /* Antiflicker */
-       peak = 12 * RJ54N1_MAX_WIDTH * (1 << 14) * resize / rj54n1->tgclk_mhz /
-               10000;
-       peak_50 = peak / 6;
-       peak_60 = peak / 5;
-
-       if (!ret)
-               ret = reg_write(client, RJ54N1_PEAK_H,
-                               ((peak_50 >> 4) & 0xf0) | (peak_60 >> 8));
-       if (!ret)
-               ret = reg_write(client, RJ54N1_PEAK_50, peak_50);
-       if (!ret)
-               ret = reg_write(client, RJ54N1_PEAK_60, peak_60);
-       if (!ret)
-               ret = reg_write(client, RJ54N1_PEAK_DIFF, peak / 150);
-
-       /* Start resizing */
-       if (!ret)
-               ret = reg_write(client, RJ54N1_RESIZE_CONTROL,
-                               RESIZE_HOLD_SEL | RESIZE_GO | 1);
-
-       if (ret < 0)
-               return ret;
-
-       /* Constant taken from manufacturer's example */
-       msleep(230);
-
-       ret = reg_write(client, RJ54N1_RESIZE_CONTROL, RESIZE_HOLD_SEL | 1);
-       if (ret < 0)
-               return ret;
-
-       *in_w = (output_w * resize + 512) / 1024;
-       *in_h = (output_h * resize + 512) / 1024;
-       *out_w = output_w;
-       *out_h = output_h;
-
-       dev_dbg(&client->dev, "Scaled for %dx%d : %u = %ux%u, skip %u\n",
-               *in_w, *in_h, resize, output_w, output_h, skip);
-
-       return resize;
-}
-
-static int rj54n1_set_clock(struct i2c_client *client)
-{
-       struct rj54n1 *rj54n1 = to_rj54n1(client);
-       int ret;
-
-       /* Enable external clock */
-       ret = reg_write(client, RJ54N1_RESET_STANDBY, E_EXCLK | SOFT_STDBY);
-       /* Leave stand-by. Note: use this when implementing suspend / resume */
-       if (!ret)
-               ret = reg_write(client, RJ54N1_RESET_STANDBY, E_EXCLK);
-
-       if (!ret)
-               ret = reg_write(client, RJ54N1_PLL_L, PLL_L);
-       if (!ret)
-               ret = reg_write(client, RJ54N1_PLL_N, PLL_N);
-
-       /* TGCLK dividers */
-       if (!ret)
-               ret = reg_write(client, RJ54N1_RATIO_TG,
-                               rj54n1->clk_div.ratio_tg);
-       if (!ret)
-               ret = reg_write(client, RJ54N1_RATIO_T,
-                               rj54n1->clk_div.ratio_t);
-       if (!ret)
-               ret = reg_write(client, RJ54N1_RATIO_R,
-                               rj54n1->clk_div.ratio_r);
-
-       /* Enable TGCLK & RAMP */
-       if (!ret)
-               ret = reg_write(client, RJ54N1_RAMP_TGCLK_EN, 3);
-
-       /* Disable clock output */
-       if (!ret)
-               ret = reg_write(client, RJ54N1_OCLK_DSP, 0);
-
-       /* Set divisors */
-       if (!ret)
-               ret = reg_write(client, RJ54N1_RATIO_OP,
-                               rj54n1->clk_div.ratio_op);
-       if (!ret)
-               ret = reg_write(client, RJ54N1_RATIO_O,
-                               rj54n1->clk_div.ratio_o);
-
-       /* Enable OCLK */
-       if (!ret)
-               ret = reg_write(client, RJ54N1_OCLK_SEL_EN, 1);
-
-       /* Use PLL for Timing Generator, write 2 to reserved bits */
-       if (!ret)
-               ret = reg_write(client, RJ54N1_TG_BYPASS, 2);
-
-       /* Take sensor out of reset */
-       if (!ret)
-               ret = reg_write(client, RJ54N1_RESET_STANDBY,
-                               E_EXCLK | SEN_RSTX);
-       /* Enable PLL */
-       if (!ret)
-               ret = reg_write(client, RJ54N1_PLL_EN, 1);
-
-       /* Wait for PLL to stabilise */
-       msleep(10);
-
-       /* Enable clock to frequency divider */
-       if (!ret)
-               ret = reg_write(client, RJ54N1_CLK_RST, 1);
-
-       if (!ret)
-               ret = reg_read(client, RJ54N1_CLK_RST);
-       if (ret != 1) {
-               dev_err(&client->dev,
-                       "Resetting RJ54N1CB0C clock failed: %d!\n", ret);
-               return -EIO;
-       }
-
-       /* Start the PLL */
-       ret = reg_set(client, RJ54N1_OCLK_DSP, 1, 1);
-
-       /* Enable OCLK */
-       if (!ret)
-               ret = reg_write(client, RJ54N1_OCLK_SEL_EN, 1);
-
-       return ret;
-}
-
-static int rj54n1_reg_init(struct i2c_client *client)
-{
-       struct rj54n1 *rj54n1 = to_rj54n1(client);
-       int ret = rj54n1_set_clock(client);
-
-       if (!ret)
-               ret = reg_write_multiple(client, bank_7, ARRAY_SIZE(bank_7));
-       if (!ret)
-               ret = reg_write_multiple(client, bank_10, ARRAY_SIZE(bank_10));
-
-       /* Set binning divisors */
-       if (!ret)
-               ret = reg_write(client, RJ54N1_SCALE_1_2_LEV, 3 | (7 << 4));
-       if (!ret)
-               ret = reg_write(client, RJ54N1_SCALE_4_LEV, 0xf);
-
-       /* Switch to fixed resize mode */
-       if (!ret)
-               ret = reg_write(client, RJ54N1_RESIZE_CONTROL,
-                               RESIZE_HOLD_SEL | 1);
-
-       /* Set gain */
-       if (!ret)
-               ret = reg_write(client, RJ54N1_Y_GAIN, 0x84);
-
-       /*
-        * Mirror the image back: default is upside down and left-to-right...
-        * Set manual preview / still shot switching
-        */
-       if (!ret)
-               ret = reg_write(client, RJ54N1_MIRROR_STILL_MODE, 0x27);
-
-       if (!ret)
-               ret = reg_write_multiple(client, bank_4, ARRAY_SIZE(bank_4));
-
-       /* Auto exposure area */
-       if (!ret)
-               ret = reg_write(client, RJ54N1_EXPOSURE_CONTROL, 0x80);
-       /* Check current auto WB config */
-       if (!ret)
-               ret = reg_read(client, RJ54N1_WB_SEL_WEIGHT_I);
-       if (ret >= 0) {
-               rj54n1->auto_wb = ret & 0x80;
-               ret = reg_write_multiple(client, bank_5, ARRAY_SIZE(bank_5));
-       }
-       if (!ret)
-               ret = reg_write_multiple(client, bank_8, ARRAY_SIZE(bank_8));
-
-       if (!ret)
-               ret = reg_write(client, RJ54N1_RESET_STANDBY,
-                               E_EXCLK | DSP_RSTX | SEN_RSTX);
-
-       /* Commit init */
-       if (!ret)
-               ret = rj54n1_commit(client);
-
-       /* Take DSP, TG, sensor out of reset */
-       if (!ret)
-               ret = reg_write(client, RJ54N1_RESET_STANDBY,
-                               E_EXCLK | DSP_RSTX | TG_RSTX | SEN_RSTX);
-
-       /* Start register update? Same register as 0x?FE in many bank_* sets */
-       if (!ret)
-               ret = reg_write(client, RJ54N1_FWFLG, 2);
-
-       /* Constant taken from manufacturer's example */
-       msleep(700);
-
-       return ret;
-}
-
-static int rj54n1_try_fmt(struct v4l2_subdev *sd,
-                         struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct rj54n1 *rj54n1 = to_rj54n1(client);
-       const struct rj54n1_datafmt *fmt;
-       int align = mf->code == V4L2_MBUS_FMT_SBGGR10_1X10 ||
-               mf->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_BE ||
-               mf->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_BE ||
-               mf->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE ||
-               mf->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_LE;
-
-       dev_dbg(&client->dev, "%s: code = %d, width = %u, height = %u\n",
-               __func__, mf->code, mf->width, mf->height);
-
-       fmt = rj54n1_find_datafmt(mf->code, rj54n1_colour_fmts,
-                                 ARRAY_SIZE(rj54n1_colour_fmts));
-       if (!fmt) {
-               fmt = rj54n1->fmt;
-               mf->code = fmt->code;
-       }
-
-       mf->field       = V4L2_FIELD_NONE;
-       mf->colorspace  = fmt->colorspace;
-
-       v4l_bound_align_image(&mf->width, 112, RJ54N1_MAX_WIDTH, align,
-                             &mf->height, 84, RJ54N1_MAX_HEIGHT, align, 0);
-
-       return 0;
-}
-
-static int rj54n1_s_fmt(struct v4l2_subdev *sd,
-                       struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct rj54n1 *rj54n1 = to_rj54n1(client);
-       const struct rj54n1_datafmt *fmt;
-       int output_w, output_h, max_w, max_h,
-               input_w = rj54n1->rect.width, input_h = rj54n1->rect.height;
-       int ret;
-
-       /*
-        * The host driver can call us without .try_fmt(), so, we have to take
-        * care ourseleves
-        */
-       rj54n1_try_fmt(sd, mf);
-
-       /*
-        * Verify if the sensor has just been powered on. TODO: replace this
-        * with proper PM, when a suitable API is available.
-        */
-       ret = reg_read(client, RJ54N1_RESET_STANDBY);
-       if (ret < 0)
-               return ret;
-
-       if (!(ret & E_EXCLK)) {
-               ret = rj54n1_reg_init(client);
-               if (ret < 0)
-                       return ret;
-       }
-
-       dev_dbg(&client->dev, "%s: code = %d, width = %u, height = %u\n",
-               __func__, mf->code, mf->width, mf->height);
-
-       /* RA_SEL_UL is only relevant for raw modes, ignored otherwise. */
-       switch (mf->code) {
-       case V4L2_MBUS_FMT_YUYV8_2X8:
-               ret = reg_write(client, RJ54N1_OUT_SEL, 0);
-               if (!ret)
-                       ret = reg_set(client, RJ54N1_BYTE_SWAP, 8, 8);
-               break;
-       case V4L2_MBUS_FMT_YVYU8_2X8:
-               ret = reg_write(client, RJ54N1_OUT_SEL, 0);
-               if (!ret)
-                       ret = reg_set(client, RJ54N1_BYTE_SWAP, 0, 8);
-               break;
-       case V4L2_MBUS_FMT_RGB565_2X8_LE:
-               ret = reg_write(client, RJ54N1_OUT_SEL, 0x11);
-               if (!ret)
-                       ret = reg_set(client, RJ54N1_BYTE_SWAP, 8, 8);
-               break;
-       case V4L2_MBUS_FMT_RGB565_2X8_BE:
-               ret = reg_write(client, RJ54N1_OUT_SEL, 0x11);
-               if (!ret)
-                       ret = reg_set(client, RJ54N1_BYTE_SWAP, 0, 8);
-               break;
-       case V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_LE:
-               ret = reg_write(client, RJ54N1_OUT_SEL, 4);
-               if (!ret)
-                       ret = reg_set(client, RJ54N1_BYTE_SWAP, 8, 8);
-               if (!ret)
-                       ret = reg_write(client, RJ54N1_RA_SEL_UL, 0);
-               break;
-       case V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE:
-               ret = reg_write(client, RJ54N1_OUT_SEL, 4);
-               if (!ret)
-                       ret = reg_set(client, RJ54N1_BYTE_SWAP, 8, 8);
-               if (!ret)
-                       ret = reg_write(client, RJ54N1_RA_SEL_UL, 8);
-               break;
-       case V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_BE:
-               ret = reg_write(client, RJ54N1_OUT_SEL, 4);
-               if (!ret)
-                       ret = reg_set(client, RJ54N1_BYTE_SWAP, 0, 8);
-               if (!ret)
-                       ret = reg_write(client, RJ54N1_RA_SEL_UL, 0);
-               break;
-       case V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_BE:
-               ret = reg_write(client, RJ54N1_OUT_SEL, 4);
-               if (!ret)
-                       ret = reg_set(client, RJ54N1_BYTE_SWAP, 0, 8);
-               if (!ret)
-                       ret = reg_write(client, RJ54N1_RA_SEL_UL, 8);
-               break;
-       case V4L2_MBUS_FMT_SBGGR10_1X10:
-               ret = reg_write(client, RJ54N1_OUT_SEL, 5);
-               break;
-       default:
-               ret = -EINVAL;
-       }
-
-       /* Special case: a raw mode with 10 bits of data per clock tick */
-       if (!ret)
-               ret = reg_set(client, RJ54N1_OCLK_SEL_EN,
-                             (mf->code == V4L2_MBUS_FMT_SBGGR10_1X10) << 1, 2);
-
-       if (ret < 0)
-               return ret;
-
-       /* Supported scales 1:1 >= scale > 1:16 */
-       max_w = mf->width * (16 * 1024 - 1) / 1024;
-       if (input_w > max_w)
-               input_w = max_w;
-       max_h = mf->height * (16 * 1024 - 1) / 1024;
-       if (input_h > max_h)
-               input_h = max_h;
-
-       output_w = mf->width;
-       output_h = mf->height;
-
-       ret = rj54n1_sensor_scale(sd, &input_w, &input_h, &output_w, &output_h);
-       if (ret < 0)
-               return ret;
-
-       fmt = rj54n1_find_datafmt(mf->code, rj54n1_colour_fmts,
-                                 ARRAY_SIZE(rj54n1_colour_fmts));
-
-       rj54n1->fmt             = fmt;
-       rj54n1->resize          = ret;
-       rj54n1->rect.width      = input_w;
-       rj54n1->rect.height     = input_h;
-       rj54n1->width           = output_w;
-       rj54n1->height          = output_h;
-
-       mf->width               = output_w;
-       mf->height              = output_h;
-       mf->field               = V4L2_FIELD_NONE;
-       mf->colorspace          = fmt->colorspace;
-
-       return 0;
-}
-
-static int rj54n1_g_chip_ident(struct v4l2_subdev *sd,
-                              struct v4l2_dbg_chip_ident *id)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-
-       if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
-               return -EINVAL;
-
-       if (id->match.addr != client->addr)
-               return -ENODEV;
-
-       id->ident       = V4L2_IDENT_RJ54N1CB0C;
-       id->revision    = 0;
-
-       return 0;
-}
-
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-static int rj54n1_g_register(struct v4l2_subdev *sd,
-                            struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-
-       if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR ||
-           reg->reg < 0x400 || reg->reg > 0x1fff)
-               /* Registers > 0x0800 are only available from Sharp support */
-               return -EINVAL;
-
-       if (reg->match.addr != client->addr)
-               return -ENODEV;
-
-       reg->size = 1;
-       reg->val = reg_read(client, reg->reg);
-
-       if (reg->val > 0xff)
-               return -EIO;
-
-       return 0;
-}
-
-static int rj54n1_s_register(struct v4l2_subdev *sd,
-                            struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-
-       if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR ||
-           reg->reg < 0x400 || reg->reg > 0x1fff)
-               /* Registers >= 0x0800 are only available from Sharp support */
-               return -EINVAL;
-
-       if (reg->match.addr != client->addr)
-               return -ENODEV;
-
-       if (reg_write(client, reg->reg, reg->val) < 0)
-               return -EIO;
-
-       return 0;
-}
-#endif
-
-static int rj54n1_s_ctrl(struct v4l2_ctrl *ctrl)
-{
-       struct rj54n1 *rj54n1 = container_of(ctrl->handler, struct rj54n1, hdl);
-       struct v4l2_subdev *sd = &rj54n1->subdev;
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       int data;
-
-       switch (ctrl->id) {
-       case V4L2_CID_VFLIP:
-               if (ctrl->val)
-                       data = reg_set(client, RJ54N1_MIRROR_STILL_MODE, 0, 1);
-               else
-                       data = reg_set(client, RJ54N1_MIRROR_STILL_MODE, 1, 1);
-               if (data < 0)
-                       return -EIO;
-               return 0;
-       case V4L2_CID_HFLIP:
-               if (ctrl->val)
-                       data = reg_set(client, RJ54N1_MIRROR_STILL_MODE, 0, 2);
-               else
-                       data = reg_set(client, RJ54N1_MIRROR_STILL_MODE, 2, 2);
-               if (data < 0)
-                       return -EIO;
-               return 0;
-       case V4L2_CID_GAIN:
-               if (reg_write(client, RJ54N1_Y_GAIN, ctrl->val * 2) < 0)
-                       return -EIO;
-               return 0;
-       case V4L2_CID_AUTO_WHITE_BALANCE:
-               /* Auto WB area - whole image */
-               if (reg_set(client, RJ54N1_WB_SEL_WEIGHT_I, ctrl->val << 7,
-                           0x80) < 0)
-                       return -EIO;
-               rj54n1->auto_wb = ctrl->val;
-               return 0;
-       }
-
-       return -EINVAL;
-}
-
-static const struct v4l2_ctrl_ops rj54n1_ctrl_ops = {
-       .s_ctrl = rj54n1_s_ctrl,
-};
-
-static struct v4l2_subdev_core_ops rj54n1_subdev_core_ops = {
-       .g_chip_ident   = rj54n1_g_chip_ident,
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-       .g_register     = rj54n1_g_register,
-       .s_register     = rj54n1_s_register,
-#endif
-};
-
-static int rj54n1_g_mbus_config(struct v4l2_subdev *sd,
-                               struct v4l2_mbus_config *cfg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-
-       cfg->flags =
-               V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_PCLK_SAMPLE_FALLING |
-               V4L2_MBUS_MASTER | V4L2_MBUS_DATA_ACTIVE_HIGH |
-               V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_HIGH;
-       cfg->type = V4L2_MBUS_PARALLEL;
-       cfg->flags = soc_camera_apply_board_flags(icl, cfg);
-
-       return 0;
-}
-
-static int rj54n1_s_mbus_config(struct v4l2_subdev *sd,
-                               const struct v4l2_mbus_config *cfg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-
-       /* Figures 2.5-1 to 2.5-3 - default falling pixclk edge */
-       if (soc_camera_apply_board_flags(icl, cfg) &
-           V4L2_MBUS_PCLK_SAMPLE_RISING)
-               return reg_write(client, RJ54N1_OUT_SIGPO, 1 << 4);
-       else
-               return reg_write(client, RJ54N1_OUT_SIGPO, 0);
-}
-
-static struct v4l2_subdev_video_ops rj54n1_subdev_video_ops = {
-       .s_stream       = rj54n1_s_stream,
-       .s_mbus_fmt     = rj54n1_s_fmt,
-       .g_mbus_fmt     = rj54n1_g_fmt,
-       .try_mbus_fmt   = rj54n1_try_fmt,
-       .enum_mbus_fmt  = rj54n1_enum_fmt,
-       .g_crop         = rj54n1_g_crop,
-       .s_crop         = rj54n1_s_crop,
-       .cropcap        = rj54n1_cropcap,
-       .g_mbus_config  = rj54n1_g_mbus_config,
-       .s_mbus_config  = rj54n1_s_mbus_config,
-};
-
-static struct v4l2_subdev_ops rj54n1_subdev_ops = {
-       .core   = &rj54n1_subdev_core_ops,
-       .video  = &rj54n1_subdev_video_ops,
-};
-
-/*
- * Interface active, can use i2c. If it fails, it can indeed mean, that
- * this wasn't our capture interface, so, we wait for the right one
- */
-static int rj54n1_video_probe(struct i2c_client *client,
-                             struct rj54n1_pdata *priv)
-{
-       int data1, data2;
-       int ret;
-
-       /* Read out the chip version register */
-       data1 = reg_read(client, RJ54N1_DEV_CODE);
-       data2 = reg_read(client, RJ54N1_DEV_CODE2);
-
-       if (data1 != 0x51 || data2 != 0x10) {
-               ret = -ENODEV;
-               dev_info(&client->dev, "No RJ54N1CB0C found, read 0x%x:0x%x\n",
-                        data1, data2);
-               goto ei2c;
-       }
-
-       /* Configure IOCTL polarity from the platform data: 0 or 1 << 7. */
-       ret = reg_write(client, RJ54N1_IOC, priv->ioctl_high << 7);
-       if (ret < 0)
-               goto ei2c;
-
-       dev_info(&client->dev, "Detected a RJ54N1CB0C chip ID 0x%x:0x%x\n",
-                data1, data2);
-
-ei2c:
-       return ret;
-}
-
-static int rj54n1_probe(struct i2c_client *client,
-                       const struct i2c_device_id *did)
-{
-       struct rj54n1 *rj54n1;
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-       struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
-       struct rj54n1_pdata *rj54n1_priv;
-       int ret;
-
-       if (!icl || !icl->priv) {
-               dev_err(&client->dev, "RJ54N1CB0C: missing platform data!\n");
-               return -EINVAL;
-       }
-
-       rj54n1_priv = icl->priv;
-
-       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
-               dev_warn(&adapter->dev,
-                        "I2C-Adapter doesn't support I2C_FUNC_SMBUS_BYTE\n");
-               return -EIO;
-       }
-
-       rj54n1 = kzalloc(sizeof(struct rj54n1), GFP_KERNEL);
-       if (!rj54n1)
-               return -ENOMEM;
-
-       v4l2_i2c_subdev_init(&rj54n1->subdev, client, &rj54n1_subdev_ops);
-       v4l2_ctrl_handler_init(&rj54n1->hdl, 4);
-       v4l2_ctrl_new_std(&rj54n1->hdl, &rj54n1_ctrl_ops,
-                       V4L2_CID_VFLIP, 0, 1, 1, 0);
-       v4l2_ctrl_new_std(&rj54n1->hdl, &rj54n1_ctrl_ops,
-                       V4L2_CID_HFLIP, 0, 1, 1, 0);
-       v4l2_ctrl_new_std(&rj54n1->hdl, &rj54n1_ctrl_ops,
-                       V4L2_CID_GAIN, 0, 127, 1, 66);
-       v4l2_ctrl_new_std(&rj54n1->hdl, &rj54n1_ctrl_ops,
-                       V4L2_CID_AUTO_WHITE_BALANCE, 0, 1, 1, 1);
-       rj54n1->subdev.ctrl_handler = &rj54n1->hdl;
-       if (rj54n1->hdl.error) {
-               int err = rj54n1->hdl.error;
-
-               kfree(rj54n1);
-               return err;
-       }
-
-       rj54n1->clk_div         = clk_div;
-       rj54n1->rect.left       = RJ54N1_COLUMN_SKIP;
-       rj54n1->rect.top        = RJ54N1_ROW_SKIP;
-       rj54n1->rect.width      = RJ54N1_MAX_WIDTH;
-       rj54n1->rect.height     = RJ54N1_MAX_HEIGHT;
-       rj54n1->width           = RJ54N1_MAX_WIDTH;
-       rj54n1->height          = RJ54N1_MAX_HEIGHT;
-       rj54n1->fmt             = &rj54n1_colour_fmts[0];
-       rj54n1->resize          = 1024;
-       rj54n1->tgclk_mhz       = (rj54n1_priv->mclk_freq / PLL_L * PLL_N) /
-               (clk_div.ratio_tg + 1) / (clk_div.ratio_t + 1);
-
-       ret = rj54n1_video_probe(client, rj54n1_priv);
-       if (ret < 0) {
-               v4l2_ctrl_handler_free(&rj54n1->hdl);
-               kfree(rj54n1);
-               return ret;
-       }
-       return v4l2_ctrl_handler_setup(&rj54n1->hdl);
-}
-
-static int rj54n1_remove(struct i2c_client *client)
-{
-       struct rj54n1 *rj54n1 = to_rj54n1(client);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-
-       v4l2_device_unregister_subdev(&rj54n1->subdev);
-       if (icl->free_bus)
-               icl->free_bus(icl);
-       v4l2_ctrl_handler_free(&rj54n1->hdl);
-       kfree(rj54n1);
-
-       return 0;
-}
-
-static const struct i2c_device_id rj54n1_id[] = {
-       { "rj54n1cb0c", 0 },
-       { }
-};
-MODULE_DEVICE_TABLE(i2c, rj54n1_id);
-
-static struct i2c_driver rj54n1_i2c_driver = {
-       .driver = {
-               .name = "rj54n1cb0c",
-       },
-       .probe          = rj54n1_probe,
-       .remove         = rj54n1_remove,
-       .id_table       = rj54n1_id,
-};
-
-module_i2c_driver(rj54n1_i2c_driver);
-
-MODULE_DESCRIPTION("Sharp RJ54N1CB0C Camera driver");
-MODULE_AUTHOR("Guennadi Liakhovetski <g.liakhovetski@gmx.de>");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/video/sh_mobile_csi2.c b/drivers/media/video/sh_mobile_csi2.c
deleted file mode 100644 (file)
index 0528650..0000000
+++ /dev/null
@@ -1,398 +0,0 @@
-/*
- * Driver for the SH-Mobile MIPI CSI-2 unit
- *
- * Copyright (C) 2010, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include <linux/delay.h>
-#include <linux/i2c.h>
-#include <linux/io.h>
-#include <linux/platform_device.h>
-#include <linux/pm_runtime.h>
-#include <linux/slab.h>
-#include <linux/videodev2.h>
-#include <linux/module.h>
-
-#include <media/sh_mobile_ceu.h>
-#include <media/sh_mobile_csi2.h>
-#include <media/soc_camera.h>
-#include <media/soc_mediabus.h>
-#include <media/v4l2-common.h>
-#include <media/v4l2-dev.h>
-#include <media/v4l2-device.h>
-#include <media/v4l2-mediabus.h>
-#include <media/v4l2-subdev.h>
-
-#define SH_CSI2_TREF   0x00
-#define SH_CSI2_SRST   0x04
-#define SH_CSI2_PHYCNT 0x08
-#define SH_CSI2_CHKSUM 0x0C
-#define SH_CSI2_VCDT   0x10
-
-struct sh_csi2 {
-       struct v4l2_subdev              subdev;
-       struct list_head                list;
-       unsigned int                    irq;
-       unsigned long                   mipi_flags;
-       void __iomem                    *base;
-       struct platform_device          *pdev;
-       struct sh_csi2_client_config    *client;
-};
-
-static int sh_csi2_try_fmt(struct v4l2_subdev *sd,
-                          struct v4l2_mbus_framefmt *mf)
-{
-       struct sh_csi2 *priv = container_of(sd, struct sh_csi2, subdev);
-       struct sh_csi2_pdata *pdata = priv->pdev->dev.platform_data;
-
-       if (mf->width > 8188)
-               mf->width = 8188;
-       else if (mf->width & 1)
-               mf->width &= ~1;
-
-       switch (pdata->type) {
-       case SH_CSI2C:
-               switch (mf->code) {
-               case V4L2_MBUS_FMT_UYVY8_2X8:           /* YUV422 */
-               case V4L2_MBUS_FMT_YUYV8_1_5X8:         /* YUV420 */
-               case V4L2_MBUS_FMT_Y8_1X8:              /* RAW8 */
-               case V4L2_MBUS_FMT_SBGGR8_1X8:
-               case V4L2_MBUS_FMT_SGRBG8_1X8:
-                       break;
-               default:
-                       /* All MIPI CSI-2 devices must support one of primary formats */
-                       mf->code = V4L2_MBUS_FMT_YUYV8_2X8;
-               }
-               break;
-       case SH_CSI2I:
-               switch (mf->code) {
-               case V4L2_MBUS_FMT_Y8_1X8:              /* RAW8 */
-               case V4L2_MBUS_FMT_SBGGR8_1X8:
-               case V4L2_MBUS_FMT_SGRBG8_1X8:
-               case V4L2_MBUS_FMT_SBGGR10_1X10:        /* RAW10 */
-               case V4L2_MBUS_FMT_SBGGR12_1X12:        /* RAW12 */
-                       break;
-               default:
-                       /* All MIPI CSI-2 devices must support one of primary formats */
-                       mf->code = V4L2_MBUS_FMT_SBGGR8_1X8;
-               }
-               break;
-       }
-
-       return 0;
-}
-
-/*
- * We have done our best in try_fmt to try and tell the sensor, which formats
- * we support. If now the configuration is unsuitable for us we can only
- * error out.
- */
-static int sh_csi2_s_fmt(struct v4l2_subdev *sd,
-                        struct v4l2_mbus_framefmt *mf)
-{
-       struct sh_csi2 *priv = container_of(sd, struct sh_csi2, subdev);
-       u32 tmp = (priv->client->channel & 3) << 8;
-
-       dev_dbg(sd->v4l2_dev->dev, "%s(%u)\n", __func__, mf->code);
-       if (mf->width > 8188 || mf->width & 1)
-               return -EINVAL;
-
-       switch (mf->code) {
-       case V4L2_MBUS_FMT_UYVY8_2X8:
-               tmp |= 0x1e;    /* YUV422 8 bit */
-               break;
-       case V4L2_MBUS_FMT_YUYV8_1_5X8:
-               tmp |= 0x18;    /* YUV420 8 bit */
-               break;
-       case V4L2_MBUS_FMT_RGB555_2X8_PADHI_BE:
-               tmp |= 0x21;    /* RGB555 */
-               break;
-       case V4L2_MBUS_FMT_RGB565_2X8_BE:
-               tmp |= 0x22;    /* RGB565 */
-               break;
-       case V4L2_MBUS_FMT_Y8_1X8:
-       case V4L2_MBUS_FMT_SBGGR8_1X8:
-       case V4L2_MBUS_FMT_SGRBG8_1X8:
-               tmp |= 0x2a;    /* RAW8 */
-               break;
-       default:
-               return -EINVAL;
-       }
-
-       iowrite32(tmp, priv->base + SH_CSI2_VCDT);
-
-       return 0;
-}
-
-static int sh_csi2_g_mbus_config(struct v4l2_subdev *sd,
-                                struct v4l2_mbus_config *cfg)
-{
-       cfg->flags = V4L2_MBUS_PCLK_SAMPLE_RISING |
-               V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_HIGH |
-               V4L2_MBUS_MASTER | V4L2_MBUS_DATA_ACTIVE_HIGH;
-       cfg->type = V4L2_MBUS_PARALLEL;
-
-       return 0;
-}
-
-static int sh_csi2_s_mbus_config(struct v4l2_subdev *sd,
-                                const struct v4l2_mbus_config *cfg)
-{
-       struct sh_csi2 *priv = container_of(sd, struct sh_csi2, subdev);
-       struct soc_camera_device *icd = v4l2_get_subdev_hostdata(sd);
-       struct v4l2_subdev *client_sd = soc_camera_to_subdev(icd);
-       struct v4l2_mbus_config client_cfg = {.type = V4L2_MBUS_CSI2,
-                                             .flags = priv->mipi_flags};
-
-       return v4l2_subdev_call(client_sd, video, s_mbus_config, &client_cfg);
-}
-
-static struct v4l2_subdev_video_ops sh_csi2_subdev_video_ops = {
-       .s_mbus_fmt     = sh_csi2_s_fmt,
-       .try_mbus_fmt   = sh_csi2_try_fmt,
-       .g_mbus_config  = sh_csi2_g_mbus_config,
-       .s_mbus_config  = sh_csi2_s_mbus_config,
-};
-
-static void sh_csi2_hwinit(struct sh_csi2 *priv)
-{
-       struct sh_csi2_pdata *pdata = priv->pdev->dev.platform_data;
-       __u32 tmp = 0x10; /* Enable MIPI CSI clock lane */
-
-       /* Reflect registers immediately */
-       iowrite32(0x00000001, priv->base + SH_CSI2_TREF);
-       /* reset CSI2 harware */
-       iowrite32(0x00000001, priv->base + SH_CSI2_SRST);
-       udelay(5);
-       iowrite32(0x00000000, priv->base + SH_CSI2_SRST);
-
-       switch (pdata->type) {
-       case SH_CSI2C:
-               if (priv->client->lanes == 1)
-                       tmp |= 1;
-               else
-                       /* Default - both lanes */
-                       tmp |= 3;
-               break;
-       case SH_CSI2I:
-               if (!priv->client->lanes || priv->client->lanes > 4)
-                       /* Default - all 4 lanes */
-                       tmp |= 0xf;
-               else
-                       tmp |= (1 << priv->client->lanes) - 1;
-       }
-
-       if (priv->client->phy == SH_CSI2_PHY_MAIN)
-               tmp |= 0x8000;
-
-       iowrite32(tmp, priv->base + SH_CSI2_PHYCNT);
-
-       tmp = 0;
-       if (pdata->flags & SH_CSI2_ECC)
-               tmp |= 2;
-       if (pdata->flags & SH_CSI2_CRC)
-               tmp |= 1;
-       iowrite32(tmp, priv->base + SH_CSI2_CHKSUM);
-}
-
-static int sh_csi2_client_connect(struct sh_csi2 *priv)
-{
-       struct sh_csi2_pdata *pdata = priv->pdev->dev.platform_data;
-       struct soc_camera_device *icd = v4l2_get_subdev_hostdata(&priv->subdev);
-       struct v4l2_subdev *client_sd = soc_camera_to_subdev(icd);
-       struct device *dev = v4l2_get_subdevdata(&priv->subdev);
-       struct v4l2_mbus_config cfg;
-       unsigned long common_flags, csi2_flags;
-       int i, ret;
-
-       if (priv->client)
-               return -EBUSY;
-
-       for (i = 0; i < pdata->num_clients; i++)
-               if (&pdata->clients[i].pdev->dev == icd->pdev)
-                       break;
-
-       dev_dbg(dev, "%s(%p): found #%d\n", __func__, dev, i);
-
-       if (i == pdata->num_clients)
-               return -ENODEV;
-
-       /* Check if we can support this camera */
-       csi2_flags = V4L2_MBUS_CSI2_CONTINUOUS_CLOCK | V4L2_MBUS_CSI2_1_LANE;
-
-       switch (pdata->type) {
-       case SH_CSI2C:
-               if (pdata->clients[i].lanes != 1)
-                       csi2_flags |= V4L2_MBUS_CSI2_2_LANE;
-               break;
-       case SH_CSI2I:
-               switch (pdata->clients[i].lanes) {
-               default:
-                       csi2_flags |= V4L2_MBUS_CSI2_4_LANE;
-               case 3:
-                       csi2_flags |= V4L2_MBUS_CSI2_3_LANE;
-               case 2:
-                       csi2_flags |= V4L2_MBUS_CSI2_2_LANE;
-               }
-       }
-
-       cfg.type = V4L2_MBUS_CSI2;
-       ret = v4l2_subdev_call(client_sd, video, g_mbus_config, &cfg);
-       if (ret == -ENOIOCTLCMD)
-               common_flags = csi2_flags;
-       else if (!ret)
-               common_flags = soc_mbus_config_compatible(&cfg,
-                                                         csi2_flags);
-       else
-               common_flags = 0;
-
-       if (!common_flags)
-               return -EINVAL;
-
-       /* All good: camera MIPI configuration supported */
-       priv->mipi_flags = common_flags;
-       priv->client = pdata->clients + i;
-
-       pm_runtime_get_sync(dev);
-
-       sh_csi2_hwinit(priv);
-
-       return 0;
-}
-
-static void sh_csi2_client_disconnect(struct sh_csi2 *priv)
-{
-       if (!priv->client)
-               return;
-
-       priv->client = NULL;
-
-       pm_runtime_put(v4l2_get_subdevdata(&priv->subdev));
-}
-
-static int sh_csi2_s_power(struct v4l2_subdev *sd, int on)
-{
-       struct sh_csi2 *priv = container_of(sd, struct sh_csi2, subdev);
-
-       if (on)
-               return sh_csi2_client_connect(priv);
-
-       sh_csi2_client_disconnect(priv);
-       return 0;
-}
-
-static struct v4l2_subdev_core_ops sh_csi2_subdev_core_ops = {
-       .s_power        = sh_csi2_s_power,
-};
-
-static struct v4l2_subdev_ops sh_csi2_subdev_ops = {
-       .core   = &sh_csi2_subdev_core_ops,
-       .video  = &sh_csi2_subdev_video_ops,
-};
-
-static __devinit int sh_csi2_probe(struct platform_device *pdev)
-{
-       struct resource *res;
-       unsigned int irq;
-       int ret;
-       struct sh_csi2 *priv;
-       /* Platform data specify the PHY, lanes, ECC, CRC */
-       struct sh_csi2_pdata *pdata = pdev->dev.platform_data;
-
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       /* Interrupt unused so far */
-       irq = platform_get_irq(pdev, 0);
-
-       if (!res || (int)irq <= 0 || !pdata) {
-               dev_err(&pdev->dev, "Not enough CSI2 platform resources.\n");
-               return -ENODEV;
-       }
-
-       /* TODO: Add support for CSI2I. Careful: different register layout! */
-       if (pdata->type != SH_CSI2C) {
-               dev_err(&pdev->dev, "Only CSI2C supported ATM.\n");
-               return -EINVAL;
-       }
-
-       priv = kzalloc(sizeof(struct sh_csi2), GFP_KERNEL);
-       if (!priv)
-               return -ENOMEM;
-
-       priv->irq = irq;
-
-       if (!request_mem_region(res->start, resource_size(res), pdev->name)) {
-               dev_err(&pdev->dev, "CSI2 register region already claimed\n");
-               ret = -EBUSY;
-               goto ereqreg;
-       }
-
-       priv->base = ioremap(res->start, resource_size(res));
-       if (!priv->base) {
-               ret = -ENXIO;
-               dev_err(&pdev->dev, "Unable to ioremap CSI2 registers.\n");
-               goto eremap;
-       }
-
-       priv->pdev = pdev;
-       platform_set_drvdata(pdev, priv);
-
-       v4l2_subdev_init(&priv->subdev, &sh_csi2_subdev_ops);
-       v4l2_set_subdevdata(&priv->subdev, &pdev->dev);
-
-       snprintf(priv->subdev.name, V4L2_SUBDEV_NAME_SIZE, "%s.mipi-csi",
-                dev_name(pdata->v4l2_dev->dev));
-       ret = v4l2_device_register_subdev(pdata->v4l2_dev, &priv->subdev);
-       dev_dbg(&pdev->dev, "%s(%p): ret(register_subdev) = %d\n", __func__, priv, ret);
-       if (ret < 0)
-               goto esdreg;
-
-       pm_runtime_enable(&pdev->dev);
-
-       dev_dbg(&pdev->dev, "CSI2 probed.\n");
-
-       return 0;
-
-esdreg:
-       iounmap(priv->base);
-eremap:
-       release_mem_region(res->start, resource_size(res));
-ereqreg:
-       kfree(priv);
-
-       return ret;
-}
-
-static __devexit int sh_csi2_remove(struct platform_device *pdev)
-{
-       struct sh_csi2 *priv = platform_get_drvdata(pdev);
-       struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-
-       v4l2_device_unregister_subdev(&priv->subdev);
-       pm_runtime_disable(&pdev->dev);
-       iounmap(priv->base);
-       release_mem_region(res->start, resource_size(res));
-       platform_set_drvdata(pdev, NULL);
-       kfree(priv);
-
-       return 0;
-}
-
-static struct platform_driver __refdata sh_csi2_pdrv = {
-       .remove = __devexit_p(sh_csi2_remove),
-       .probe  = sh_csi2_probe,
-       .driver = {
-               .name   = "sh-mobile-csi2",
-               .owner  = THIS_MODULE,
-       },
-};
-
-module_platform_driver(sh_csi2_pdrv);
-
-MODULE_DESCRIPTION("SH-Mobile MIPI CSI-2 driver");
-MODULE_AUTHOR("Guennadi Liakhovetski <g.liakhovetski@gmx.de>");
-MODULE_LICENSE("GPL v2");
-MODULE_ALIAS("platform:sh-mobile-csi2");
diff --git a/drivers/media/video/soc_camera.c b/drivers/media/video/soc_camera.c
deleted file mode 100644 (file)
index 9758217..0000000
+++ /dev/null
@@ -1,1554 +0,0 @@
-/*
- * camera image capture (abstract) bus driver
- *
- * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
- *
- * This driver provides an interface between platform-specific camera
- * busses and camera devices. It should be used if the camera is
- * connected not over a "proper" bus like PCI or USB, but over a
- * special bus, like, for example, the Quick Capture interface on PXA270
- * SoCs. Later it should also be used for i.MX31 SoCs from Freescale.
- * It can handle multiple cameras and / or multiple busses, which can
- * be used, e.g., in stereo-vision applications.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include <linux/device.h>
-#include <linux/err.h>
-#include <linux/i2c.h>
-#include <linux/init.h>
-#include <linux/list.h>
-#include <linux/mutex.h>
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/regulator/consumer.h>
-#include <linux/slab.h>
-#include <linux/pm_runtime.h>
-#include <linux/vmalloc.h>
-
-#include <media/soc_camera.h>
-#include <media/v4l2-common.h>
-#include <media/v4l2-ioctl.h>
-#include <media/v4l2-dev.h>
-#include <media/videobuf-core.h>
-#include <media/videobuf2-core.h>
-#include <media/soc_mediabus.h>
-
-/* Default to VGA resolution */
-#define DEFAULT_WIDTH  640
-#define DEFAULT_HEIGHT 480
-
-#define is_streaming(ici, icd)                         \
-       (((ici)->ops->init_videobuf) ?                  \
-        (icd)->vb_vidq.streaming :                     \
-        vb2_is_streaming(&(icd)->vb2_vidq))
-
-static LIST_HEAD(hosts);
-static LIST_HEAD(devices);
-static DEFINE_MUTEX(list_lock);                /* Protects the list of hosts */
-
-static int soc_camera_power_on(struct soc_camera_device *icd,
-                              struct soc_camera_link *icl)
-{
-       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
-       int ret = regulator_bulk_enable(icl->num_regulators,
-                                       icl->regulators);
-       if (ret < 0) {
-               dev_err(icd->pdev, "Cannot enable regulators\n");
-               return ret;
-       }
-
-       if (icl->power) {
-               ret = icl->power(icd->control, 1);
-               if (ret < 0) {
-                       dev_err(icd->pdev,
-                               "Platform failed to power-on the camera.\n");
-                       goto elinkpwr;
-               }
-       }
-
-       ret = v4l2_subdev_call(sd, core, s_power, 1);
-       if (ret < 0 && ret != -ENOIOCTLCMD && ret != -ENODEV)
-               goto esdpwr;
-
-       return 0;
-
-esdpwr:
-       if (icl->power)
-               icl->power(icd->control, 0);
-elinkpwr:
-       regulator_bulk_disable(icl->num_regulators,
-                              icl->regulators);
-       return ret;
-}
-
-static int soc_camera_power_off(struct soc_camera_device *icd,
-                               struct soc_camera_link *icl)
-{
-       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
-       int ret = v4l2_subdev_call(sd, core, s_power, 0);
-
-       if (ret < 0 && ret != -ENOIOCTLCMD && ret != -ENODEV)
-               return ret;
-
-       if (icl->power) {
-               ret = icl->power(icd->control, 0);
-               if (ret < 0) {
-                       dev_err(icd->pdev,
-                               "Platform failed to power-off the camera.\n");
-                       return ret;
-               }
-       }
-
-       ret = regulator_bulk_disable(icl->num_regulators,
-                                    icl->regulators);
-       if (ret < 0)
-               dev_err(icd->pdev, "Cannot disable regulators\n");
-
-       return ret;
-}
-
-const struct soc_camera_format_xlate *soc_camera_xlate_by_fourcc(
-       struct soc_camera_device *icd, unsigned int fourcc)
-{
-       unsigned int i;
-
-       for (i = 0; i < icd->num_user_formats; i++)
-               if (icd->user_formats[i].host_fmt->fourcc == fourcc)
-                       return icd->user_formats + i;
-       return NULL;
-}
-EXPORT_SYMBOL(soc_camera_xlate_by_fourcc);
-
-/**
- * soc_camera_apply_board_flags() - apply platform SOCAM_SENSOR_INVERT_* flags
- * @icl:       camera platform parameters
- * @cfg:       media bus configuration
- * @return:    resulting flags
- */
-unsigned long soc_camera_apply_board_flags(struct soc_camera_link *icl,
-                                          const struct v4l2_mbus_config *cfg)
-{
-       unsigned long f, flags = cfg->flags;
-
-       /* If only one of the two polarities is supported, switch to the opposite */
-       if (icl->flags & SOCAM_SENSOR_INVERT_HSYNC) {
-               f = flags & (V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_HSYNC_ACTIVE_LOW);
-               if (f == V4L2_MBUS_HSYNC_ACTIVE_HIGH || f == V4L2_MBUS_HSYNC_ACTIVE_LOW)
-                       flags ^= V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_HSYNC_ACTIVE_LOW;
-       }
-
-       if (icl->flags & SOCAM_SENSOR_INVERT_VSYNC) {
-               f = flags & (V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_LOW);
-               if (f == V4L2_MBUS_VSYNC_ACTIVE_HIGH || f == V4L2_MBUS_VSYNC_ACTIVE_LOW)
-                       flags ^= V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_LOW;
-       }
-
-       if (icl->flags & SOCAM_SENSOR_INVERT_PCLK) {
-               f = flags & (V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_PCLK_SAMPLE_FALLING);
-               if (f == V4L2_MBUS_PCLK_SAMPLE_RISING || f == V4L2_MBUS_PCLK_SAMPLE_FALLING)
-                       flags ^= V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_PCLK_SAMPLE_FALLING;
-       }
-
-       return flags;
-}
-EXPORT_SYMBOL(soc_camera_apply_board_flags);
-
-#define pixfmtstr(x) (x) & 0xff, ((x) >> 8) & 0xff, ((x) >> 16) & 0xff, \
-       ((x) >> 24) & 0xff
-
-static int soc_camera_try_fmt(struct soc_camera_device *icd,
-                             struct v4l2_format *f)
-{
-       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-       const struct soc_camera_format_xlate *xlate;
-       struct v4l2_pix_format *pix = &f->fmt.pix;
-       int ret;
-
-       dev_dbg(icd->pdev, "TRY_FMT(%c%c%c%c, %ux%u)\n",
-               pixfmtstr(pix->pixelformat), pix->width, pix->height);
-
-       if (!(ici->capabilities & SOCAM_HOST_CAP_STRIDE)) {
-               pix->bytesperline = 0;
-               pix->sizeimage = 0;
-       }
-
-       ret = ici->ops->try_fmt(icd, f);
-       if (ret < 0)
-               return ret;
-
-       xlate = soc_camera_xlate_by_fourcc(icd, pix->pixelformat);
-       if (!xlate)
-               return -EINVAL;
-
-       ret = soc_mbus_bytes_per_line(pix->width, xlate->host_fmt);
-       if (ret < 0)
-               return ret;
-
-       pix->bytesperline = max_t(u32, pix->bytesperline, ret);
-
-       ret = soc_mbus_image_size(xlate->host_fmt, pix->bytesperline,
-                                 pix->height);
-       if (ret < 0)
-               return ret;
-
-       pix->sizeimage = max_t(u32, pix->sizeimage, ret);
-
-       return 0;
-}
-
-static int soc_camera_try_fmt_vid_cap(struct file *file, void *priv,
-                                     struct v4l2_format *f)
-{
-       struct soc_camera_device *icd = file->private_data;
-
-       WARN_ON(priv != file->private_data);
-
-       /* Only single-plane capture is supported so far */
-       if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-               return -EINVAL;
-
-       /* limit format to hardware capabilities */
-       return soc_camera_try_fmt(icd, f);
-}
-
-static int soc_camera_enum_input(struct file *file, void *priv,
-                                struct v4l2_input *inp)
-{
-       if (inp->index != 0)
-               return -EINVAL;
-
-       /* default is camera */
-       inp->type = V4L2_INPUT_TYPE_CAMERA;
-       inp->std  = V4L2_STD_UNKNOWN;
-       strcpy(inp->name, "Camera");
-
-       return 0;
-}
-
-static int soc_camera_g_input(struct file *file, void *priv, unsigned int *i)
-{
-       *i = 0;
-
-       return 0;
-}
-
-static int soc_camera_s_input(struct file *file, void *priv, unsigned int i)
-{
-       if (i > 0)
-               return -EINVAL;
-
-       return 0;
-}
-
-static int soc_camera_s_std(struct file *file, void *priv, v4l2_std_id *a)
-{
-       struct soc_camera_device *icd = file->private_data;
-       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
-
-       return v4l2_subdev_call(sd, core, s_std, *a);
-}
-
-static int soc_camera_g_std(struct file *file, void *priv, v4l2_std_id *a)
-{
-       struct soc_camera_device *icd = file->private_data;
-       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
-
-       return v4l2_subdev_call(sd, core, g_std, a);
-}
-
-static int soc_camera_enum_framesizes(struct file *file, void *fh,
-                                        struct v4l2_frmsizeenum *fsize)
-{
-       struct soc_camera_device *icd = file->private_data;
-       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-
-       return ici->ops->enum_framesizes(icd, fsize);
-}
-
-static int soc_camera_reqbufs(struct file *file, void *priv,
-                             struct v4l2_requestbuffers *p)
-{
-       int ret;
-       struct soc_camera_device *icd = file->private_data;
-       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-
-       WARN_ON(priv != file->private_data);
-
-       if (icd->streamer && icd->streamer != file)
-               return -EBUSY;
-
-       if (ici->ops->init_videobuf) {
-               ret = videobuf_reqbufs(&icd->vb_vidq, p);
-               if (ret < 0)
-                       return ret;
-
-               ret = ici->ops->reqbufs(icd, p);
-       } else {
-               ret = vb2_reqbufs(&icd->vb2_vidq, p);
-       }
-
-       if (!ret && !icd->streamer)
-               icd->streamer = file;
-
-       return ret;
-}
-
-static int soc_camera_querybuf(struct file *file, void *priv,
-                              struct v4l2_buffer *p)
-{
-       struct soc_camera_device *icd = file->private_data;
-       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-
-       WARN_ON(priv != file->private_data);
-
-       if (ici->ops->init_videobuf)
-               return videobuf_querybuf(&icd->vb_vidq, p);
-       else
-               return vb2_querybuf(&icd->vb2_vidq, p);
-}
-
-static int soc_camera_qbuf(struct file *file, void *priv,
-                          struct v4l2_buffer *p)
-{
-       struct soc_camera_device *icd = file->private_data;
-       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-
-       WARN_ON(priv != file->private_data);
-
-       if (icd->streamer != file)
-               return -EBUSY;
-
-       if (ici->ops->init_videobuf)
-               return videobuf_qbuf(&icd->vb_vidq, p);
-       else
-               return vb2_qbuf(&icd->vb2_vidq, p);
-}
-
-static int soc_camera_dqbuf(struct file *file, void *priv,
-                           struct v4l2_buffer *p)
-{
-       struct soc_camera_device *icd = file->private_data;
-       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-
-       WARN_ON(priv != file->private_data);
-
-       if (icd->streamer != file)
-               return -EBUSY;
-
-       if (ici->ops->init_videobuf)
-               return videobuf_dqbuf(&icd->vb_vidq, p, file->f_flags & O_NONBLOCK);
-       else
-               return vb2_dqbuf(&icd->vb2_vidq, p, file->f_flags & O_NONBLOCK);
-}
-
-static int soc_camera_create_bufs(struct file *file, void *priv,
-                           struct v4l2_create_buffers *create)
-{
-       struct soc_camera_device *icd = file->private_data;
-       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-
-       /* videobuf2 only */
-       if (ici->ops->init_videobuf)
-               return -EINVAL;
-       else
-               return vb2_create_bufs(&icd->vb2_vidq, create);
-}
-
-static int soc_camera_prepare_buf(struct file *file, void *priv,
-                                 struct v4l2_buffer *b)
-{
-       struct soc_camera_device *icd = file->private_data;
-       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-
-       /* videobuf2 only */
-       if (ici->ops->init_videobuf)
-               return -EINVAL;
-       else
-               return vb2_prepare_buf(&icd->vb2_vidq, b);
-}
-
-/* Always entered with .video_lock held */
-static int soc_camera_init_user_formats(struct soc_camera_device *icd)
-{
-       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
-       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-       unsigned int i, fmts = 0, raw_fmts = 0;
-       int ret;
-       enum v4l2_mbus_pixelcode code;
-
-       while (!v4l2_subdev_call(sd, video, enum_mbus_fmt, raw_fmts, &code))
-               raw_fmts++;
-
-       if (!ici->ops->get_formats)
-               /*
-                * Fallback mode - the host will have to serve all
-                * sensor-provided formats one-to-one to the user
-                */
-               fmts = raw_fmts;
-       else
-               /*
-                * First pass - only count formats this host-sensor
-                * configuration can provide
-                */
-               for (i = 0; i < raw_fmts; i++) {
-                       ret = ici->ops->get_formats(icd, i, NULL);
-                       if (ret < 0)
-                               return ret;
-                       fmts += ret;
-               }
-
-       if (!fmts)
-               return -ENXIO;
-
-       icd->user_formats =
-               vmalloc(fmts * sizeof(struct soc_camera_format_xlate));
-       if (!icd->user_formats)
-               return -ENOMEM;
-
-       dev_dbg(icd->pdev, "Found %d supported formats.\n", fmts);
-
-       /* Second pass - actually fill data formats */
-       fmts = 0;
-       for (i = 0; i < raw_fmts; i++)
-               if (!ici->ops->get_formats) {
-                       v4l2_subdev_call(sd, video, enum_mbus_fmt, i, &code);
-                       icd->user_formats[fmts].host_fmt =
-                               soc_mbus_get_fmtdesc(code);
-                       if (icd->user_formats[fmts].host_fmt)
-                               icd->user_formats[fmts++].code = code;
-               } else {
-                       ret = ici->ops->get_formats(icd, i,
-                                                   &icd->user_formats[fmts]);
-                       if (ret < 0)
-                               goto egfmt;
-                       fmts += ret;
-               }
-
-       icd->num_user_formats = fmts;
-       icd->current_fmt = &icd->user_formats[0];
-
-       return 0;
-
-egfmt:
-       vfree(icd->user_formats);
-       return ret;
-}
-
-/* Always entered with .video_lock held */
-static void soc_camera_free_user_formats(struct soc_camera_device *icd)
-{
-       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-
-       if (ici->ops->put_formats)
-               ici->ops->put_formats(icd);
-       icd->current_fmt = NULL;
-       icd->num_user_formats = 0;
-       vfree(icd->user_formats);
-       icd->user_formats = NULL;
-}
-
-/* Called with .vb_lock held, or from the first open(2), see comment there */
-static int soc_camera_set_fmt(struct soc_camera_device *icd,
-                             struct v4l2_format *f)
-{
-       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-       struct v4l2_pix_format *pix = &f->fmt.pix;
-       int ret;
-
-       dev_dbg(icd->pdev, "S_FMT(%c%c%c%c, %ux%u)\n",
-               pixfmtstr(pix->pixelformat), pix->width, pix->height);
-
-       /* We always call try_fmt() before set_fmt() or set_crop() */
-       ret = soc_camera_try_fmt(icd, f);
-       if (ret < 0)
-               return ret;
-
-       ret = ici->ops->set_fmt(icd, f);
-       if (ret < 0) {
-               return ret;
-       } else if (!icd->current_fmt ||
-                  icd->current_fmt->host_fmt->fourcc != pix->pixelformat) {
-               dev_err(icd->pdev,
-                       "Host driver hasn't set up current format correctly!\n");
-               return -EINVAL;
-       }
-
-       icd->user_width         = pix->width;
-       icd->user_height        = pix->height;
-       icd->bytesperline       = pix->bytesperline;
-       icd->sizeimage          = pix->sizeimage;
-       icd->colorspace         = pix->colorspace;
-       icd->field              = pix->field;
-       if (ici->ops->init_videobuf)
-               icd->vb_vidq.field = pix->field;
-
-       dev_dbg(icd->pdev, "set width: %d height: %d\n",
-               icd->user_width, icd->user_height);
-
-       /* set physical bus parameters */
-       return ici->ops->set_bus_param(icd);
-}
-
-static int soc_camera_open(struct file *file)
-{
-       struct video_device *vdev = video_devdata(file);
-       struct soc_camera_device *icd = dev_get_drvdata(vdev->parent);
-       struct soc_camera_link *icl = to_soc_camera_link(icd);
-       struct soc_camera_host *ici;
-       int ret;
-
-       if (!to_soc_camera_control(icd))
-               /* No device driver attached */
-               return -ENODEV;
-
-       ici = to_soc_camera_host(icd->parent);
-
-       if (mutex_lock_interruptible(&icd->video_lock))
-               return -ERESTARTSYS;
-       if (!try_module_get(ici->ops->owner)) {
-               dev_err(icd->pdev, "Couldn't lock capture bus driver.\n");
-               ret = -EINVAL;
-               goto emodule;
-       }
-
-       icd->use_count++;
-
-       /* Now we really have to activate the camera */
-       if (icd->use_count == 1) {
-               /* Restore parameters before the last close() per V4L2 API */
-               struct v4l2_format f = {
-                       .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
-                       .fmt.pix = {
-                               .width          = icd->user_width,
-                               .height         = icd->user_height,
-                               .field          = icd->field,
-                               .colorspace     = icd->colorspace,
-                               .pixelformat    =
-                                       icd->current_fmt->host_fmt->fourcc,
-                       },
-               };
-
-               /* The camera could have been already on, try to reset */
-               if (icl->reset)
-                       icl->reset(icd->pdev);
-
-               /* Don't mess with the host during probe */
-               mutex_lock(&ici->host_lock);
-               ret = ici->ops->add(icd);
-               mutex_unlock(&ici->host_lock);
-               if (ret < 0) {
-                       dev_err(icd->pdev, "Couldn't activate the camera: %d\n", ret);
-                       goto eiciadd;
-               }
-
-               ret = soc_camera_power_on(icd, icl);
-               if (ret < 0)
-                       goto epower;
-
-               pm_runtime_enable(&icd->vdev->dev);
-               ret = pm_runtime_resume(&icd->vdev->dev);
-               if (ret < 0 && ret != -ENOSYS)
-                       goto eresume;
-
-               /*
-                * Try to configure with default parameters. Notice: this is the
-                * very first open, so, we cannot race against other calls,
-                * apart from someone else calling open() simultaneously, but
-                * .video_lock is protecting us against it.
-                */
-               ret = soc_camera_set_fmt(icd, &f);
-               if (ret < 0)
-                       goto esfmt;
-
-               if (ici->ops->init_videobuf) {
-                       ici->ops->init_videobuf(&icd->vb_vidq, icd);
-               } else {
-                       ret = ici->ops->init_videobuf2(&icd->vb2_vidq, icd);
-                       if (ret < 0)
-                               goto einitvb;
-               }
-               v4l2_ctrl_handler_setup(&icd->ctrl_handler);
-       }
-       mutex_unlock(&icd->video_lock);
-
-       file->private_data = icd;
-       dev_dbg(icd->pdev, "camera device open\n");
-
-       return 0;
-
-       /*
-        * First four errors are entered with the .video_lock held
-        * and use_count == 1
-        */
-einitvb:
-esfmt:
-       pm_runtime_disable(&icd->vdev->dev);
-eresume:
-       soc_camera_power_off(icd, icl);
-epower:
-       ici->ops->remove(icd);
-eiciadd:
-       icd->use_count--;
-       module_put(ici->ops->owner);
-emodule:
-       mutex_unlock(&icd->video_lock);
-
-       return ret;
-}
-
-static int soc_camera_close(struct file *file)
-{
-       struct soc_camera_device *icd = file->private_data;
-       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-
-       mutex_lock(&icd->video_lock);
-       icd->use_count--;
-       if (!icd->use_count) {
-               struct soc_camera_link *icl = to_soc_camera_link(icd);
-
-               pm_runtime_suspend(&icd->vdev->dev);
-               pm_runtime_disable(&icd->vdev->dev);
-
-               if (ici->ops->init_videobuf2)
-                       vb2_queue_release(&icd->vb2_vidq);
-               ici->ops->remove(icd);
-
-               soc_camera_power_off(icd, icl);
-       }
-
-       if (icd->streamer == file)
-               icd->streamer = NULL;
-       mutex_unlock(&icd->video_lock);
-
-       module_put(ici->ops->owner);
-
-       dev_dbg(icd->pdev, "camera device close\n");
-
-       return 0;
-}
-
-static ssize_t soc_camera_read(struct file *file, char __user *buf,
-                              size_t count, loff_t *ppos)
-{
-       struct soc_camera_device *icd = file->private_data;
-       int err = -EINVAL;
-
-       dev_err(icd->pdev, "camera device read not implemented\n");
-
-       return err;
-}
-
-static int soc_camera_mmap(struct file *file, struct vm_area_struct *vma)
-{
-       struct soc_camera_device *icd = file->private_data;
-       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-       int err;
-
-       dev_dbg(icd->pdev, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
-
-       if (icd->streamer != file)
-               return -EBUSY;
-
-       if (mutex_lock_interruptible(&icd->video_lock))
-               return -ERESTARTSYS;
-       if (ici->ops->init_videobuf)
-               err = videobuf_mmap_mapper(&icd->vb_vidq, vma);
-       else
-               err = vb2_mmap(&icd->vb2_vidq, vma);
-       mutex_unlock(&icd->video_lock);
-
-       dev_dbg(icd->pdev, "vma start=0x%08lx, size=%ld, ret=%d\n",
-               (unsigned long)vma->vm_start,
-               (unsigned long)vma->vm_end - (unsigned long)vma->vm_start,
-               err);
-
-       return err;
-}
-
-static unsigned int soc_camera_poll(struct file *file, poll_table *pt)
-{
-       struct soc_camera_device *icd = file->private_data;
-       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-       unsigned res = POLLERR;
-
-       if (icd->streamer != file)
-               return POLLERR;
-
-       mutex_lock(&icd->video_lock);
-       if (ici->ops->init_videobuf && list_empty(&icd->vb_vidq.stream))
-               dev_err(icd->pdev, "Trying to poll with no queued buffers!\n");
-       else
-               res = ici->ops->poll(file, pt);
-       mutex_unlock(&icd->video_lock);
-       return res;
-}
-
-void soc_camera_lock(struct vb2_queue *vq)
-{
-       struct soc_camera_device *icd = vb2_get_drv_priv(vq);
-       mutex_lock(&icd->video_lock);
-}
-EXPORT_SYMBOL(soc_camera_lock);
-
-void soc_camera_unlock(struct vb2_queue *vq)
-{
-       struct soc_camera_device *icd = vb2_get_drv_priv(vq);
-       mutex_unlock(&icd->video_lock);
-}
-EXPORT_SYMBOL(soc_camera_unlock);
-
-static struct v4l2_file_operations soc_camera_fops = {
-       .owner          = THIS_MODULE,
-       .open           = soc_camera_open,
-       .release        = soc_camera_close,
-       .unlocked_ioctl = video_ioctl2,
-       .read           = soc_camera_read,
-       .mmap           = soc_camera_mmap,
-       .poll           = soc_camera_poll,
-};
-
-static int soc_camera_s_fmt_vid_cap(struct file *file, void *priv,
-                                   struct v4l2_format *f)
-{
-       struct soc_camera_device *icd = file->private_data;
-       int ret;
-
-       WARN_ON(priv != file->private_data);
-
-       if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
-               dev_warn(icd->pdev, "Wrong buf-type %d\n", f->type);
-               return -EINVAL;
-       }
-
-       if (icd->streamer && icd->streamer != file)
-               return -EBUSY;
-
-       if (is_streaming(to_soc_camera_host(icd->parent), icd)) {
-               dev_err(icd->pdev, "S_FMT denied: queue initialised\n");
-               return -EBUSY;
-       }
-
-       ret = soc_camera_set_fmt(icd, f);
-
-       if (!ret && !icd->streamer)
-               icd->streamer = file;
-
-       return ret;
-}
-
-static int soc_camera_enum_fmt_vid_cap(struct file *file, void  *priv,
-                                      struct v4l2_fmtdesc *f)
-{
-       struct soc_camera_device *icd = file->private_data;
-       const struct soc_mbus_pixelfmt *format;
-
-       WARN_ON(priv != file->private_data);
-
-       if (f->index >= icd->num_user_formats)
-               return -EINVAL;
-
-       format = icd->user_formats[f->index].host_fmt;
-
-       if (format->name)
-               strlcpy(f->description, format->name, sizeof(f->description));
-       f->pixelformat = format->fourcc;
-       return 0;
-}
-
-static int soc_camera_g_fmt_vid_cap(struct file *file, void *priv,
-                                   struct v4l2_format *f)
-{
-       struct soc_camera_device *icd = file->private_data;
-       struct v4l2_pix_format *pix = &f->fmt.pix;
-
-       WARN_ON(priv != file->private_data);
-
-       if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-               return -EINVAL;
-
-       pix->width              = icd->user_width;
-       pix->height             = icd->user_height;
-       pix->bytesperline       = icd->bytesperline;
-       pix->sizeimage          = icd->sizeimage;
-       pix->field              = icd->field;
-       pix->pixelformat        = icd->current_fmt->host_fmt->fourcc;
-       pix->colorspace         = icd->colorspace;
-       dev_dbg(icd->pdev, "current_fmt->fourcc: 0x%08x\n",
-               icd->current_fmt->host_fmt->fourcc);
-       return 0;
-}
-
-static int soc_camera_querycap(struct file *file, void  *priv,
-                              struct v4l2_capability *cap)
-{
-       struct soc_camera_device *icd = file->private_data;
-       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-
-       WARN_ON(priv != file->private_data);
-
-       strlcpy(cap->driver, ici->drv_name, sizeof(cap->driver));
-       return ici->ops->querycap(ici, cap);
-}
-
-static int soc_camera_streamon(struct file *file, void *priv,
-                              enum v4l2_buf_type i)
-{
-       struct soc_camera_device *icd = file->private_data;
-       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
-       int ret;
-
-       WARN_ON(priv != file->private_data);
-
-       if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-               return -EINVAL;
-
-       if (icd->streamer != file)
-               return -EBUSY;
-
-       /* This calls buf_queue from host driver's videobuf_queue_ops */
-       if (ici->ops->init_videobuf)
-               ret = videobuf_streamon(&icd->vb_vidq);
-       else
-               ret = vb2_streamon(&icd->vb2_vidq, i);
-
-       if (!ret)
-               v4l2_subdev_call(sd, video, s_stream, 1);
-
-       return ret;
-}
-
-static int soc_camera_streamoff(struct file *file, void *priv,
-                               enum v4l2_buf_type i)
-{
-       struct soc_camera_device *icd = file->private_data;
-       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
-       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-
-       WARN_ON(priv != file->private_data);
-
-       if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-               return -EINVAL;
-
-       if (icd->streamer != file)
-               return -EBUSY;
-
-       /*
-        * This calls buf_release from host driver's videobuf_queue_ops for all
-        * remaining buffers. When the last buffer is freed, stop capture
-        */
-       if (ici->ops->init_videobuf)
-               videobuf_streamoff(&icd->vb_vidq);
-       else
-               vb2_streamoff(&icd->vb2_vidq, i);
-
-       v4l2_subdev_call(sd, video, s_stream, 0);
-
-       return 0;
-}
-
-static int soc_camera_cropcap(struct file *file, void *fh,
-                             struct v4l2_cropcap *a)
-{
-       struct soc_camera_device *icd = file->private_data;
-       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-
-       return ici->ops->cropcap(icd, a);
-}
-
-static int soc_camera_g_crop(struct file *file, void *fh,
-                            struct v4l2_crop *a)
-{
-       struct soc_camera_device *icd = file->private_data;
-       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-       int ret;
-
-       ret = ici->ops->get_crop(icd, a);
-
-       return ret;
-}
-
-/*
- * According to the V4L2 API, drivers shall not update the struct v4l2_crop
- * argument with the actual geometry, instead, the user shall use G_CROP to
- * retrieve it.
- */
-static int soc_camera_s_crop(struct file *file, void *fh,
-                            struct v4l2_crop *a)
-{
-       struct soc_camera_device *icd = file->private_data;
-       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-       struct v4l2_rect *rect = &a->c;
-       struct v4l2_crop current_crop;
-       int ret;
-
-       if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-               return -EINVAL;
-
-       dev_dbg(icd->pdev, "S_CROP(%ux%u@%u:%u)\n",
-               rect->width, rect->height, rect->left, rect->top);
-
-       /* If get_crop fails, we'll let host and / or client drivers decide */
-       ret = ici->ops->get_crop(icd, &current_crop);
-
-       /* Prohibit window size change with initialised buffers */
-       if (ret < 0) {
-               dev_err(icd->pdev,
-                       "S_CROP denied: getting current crop failed\n");
-       } else if ((a->c.width == current_crop.c.width &&
-                   a->c.height == current_crop.c.height) ||
-                  !is_streaming(ici, icd)) {
-               /* same size or not streaming - use .set_crop() */
-               ret = ici->ops->set_crop(icd, a);
-       } else if (ici->ops->set_livecrop) {
-               ret = ici->ops->set_livecrop(icd, a);
-       } else {
-               dev_err(icd->pdev,
-                       "S_CROP denied: queue initialised and sizes differ\n");
-               ret = -EBUSY;
-       }
-
-       return ret;
-}
-
-static int soc_camera_g_parm(struct file *file, void *fh,
-                            struct v4l2_streamparm *a)
-{
-       struct soc_camera_device *icd = file->private_data;
-       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-
-       if (ici->ops->get_parm)
-               return ici->ops->get_parm(icd, a);
-
-       return -ENOIOCTLCMD;
-}
-
-static int soc_camera_s_parm(struct file *file, void *fh,
-                            struct v4l2_streamparm *a)
-{
-       struct soc_camera_device *icd = file->private_data;
-       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-
-       if (ici->ops->set_parm)
-               return ici->ops->set_parm(icd, a);
-
-       return -ENOIOCTLCMD;
-}
-
-static int soc_camera_g_chip_ident(struct file *file, void *fh,
-                                  struct v4l2_dbg_chip_ident *id)
-{
-       struct soc_camera_device *icd = file->private_data;
-       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
-
-       return v4l2_subdev_call(sd, core, g_chip_ident, id);
-}
-
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-static int soc_camera_g_register(struct file *file, void *fh,
-                                struct v4l2_dbg_register *reg)
-{
-       struct soc_camera_device *icd = file->private_data;
-       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
-
-       return v4l2_subdev_call(sd, core, g_register, reg);
-}
-
-static int soc_camera_s_register(struct file *file, void *fh,
-                                struct v4l2_dbg_register *reg)
-{
-       struct soc_camera_device *icd = file->private_data;
-       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
-
-       return v4l2_subdev_call(sd, core, s_register, reg);
-}
-#endif
-
-static int soc_camera_probe(struct soc_camera_device *icd);
-
-/* So far this function cannot fail */
-static void scan_add_host(struct soc_camera_host *ici)
-{
-       struct soc_camera_device *icd;
-
-       mutex_lock(&ici->host_lock);
-
-       list_for_each_entry(icd, &devices, list) {
-               if (icd->iface == ici->nr) {
-                       int ret;
-
-                       icd->parent = ici->v4l2_dev.dev;
-                       ret = soc_camera_probe(icd);
-               }
-       }
-
-       mutex_unlock(&ici->host_lock);
-}
-
-#ifdef CONFIG_I2C_BOARDINFO
-static int soc_camera_init_i2c(struct soc_camera_device *icd,
-                              struct soc_camera_link *icl)
-{
-       struct i2c_client *client;
-       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-       struct i2c_adapter *adap = i2c_get_adapter(icl->i2c_adapter_id);
-       struct v4l2_subdev *subdev;
-
-       if (!adap) {
-               dev_err(icd->pdev, "Cannot get I2C adapter #%d. No driver?\n",
-                       icl->i2c_adapter_id);
-               goto ei2cga;
-       }
-
-       icl->board_info->platform_data = icl;
-
-       subdev = v4l2_i2c_new_subdev_board(&ici->v4l2_dev, adap,
-                               icl->board_info, NULL);
-       if (!subdev)
-               goto ei2cnd;
-
-       client = v4l2_get_subdevdata(subdev);
-
-       /* Use to_i2c_client(dev) to recover the i2c client */
-       icd->control = &client->dev;
-
-       return 0;
-ei2cnd:
-       i2c_put_adapter(adap);
-ei2cga:
-       return -ENODEV;
-}
-
-static void soc_camera_free_i2c(struct soc_camera_device *icd)
-{
-       struct i2c_client *client =
-               to_i2c_client(to_soc_camera_control(icd));
-       struct i2c_adapter *adap = client->adapter;
-
-       icd->control = NULL;
-       v4l2_device_unregister_subdev(i2c_get_clientdata(client));
-       i2c_unregister_device(client);
-       i2c_put_adapter(adap);
-}
-#else
-#define soc_camera_init_i2c(icd, icl)  (-ENODEV)
-#define soc_camera_free_i2c(icd)       do {} while (0)
-#endif
-
-static int soc_camera_video_start(struct soc_camera_device *icd);
-static int video_dev_create(struct soc_camera_device *icd);
-/* Called during host-driver probe */
-static int soc_camera_probe(struct soc_camera_device *icd)
-{
-       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-       struct soc_camera_link *icl = to_soc_camera_link(icd);
-       struct device *control = NULL;
-       struct v4l2_subdev *sd;
-       struct v4l2_mbus_framefmt mf;
-       int ret;
-
-       dev_info(icd->pdev, "Probing %s\n", dev_name(icd->pdev));
-
-       /*
-        * Currently the subdev with the largest number of controls (13) is
-        * ov6550. So let's pick 16 as a hint for the control handler. Note
-        * that this is a hint only: too large and you waste some memory, too
-        * small and there is a (very) small performance hit when looking up
-        * controls in the internal hash.
-        */
-       ret = v4l2_ctrl_handler_init(&icd->ctrl_handler, 16);
-       if (ret < 0)
-               return ret;
-
-       ret = regulator_bulk_get(icd->pdev, icl->num_regulators,
-                                icl->regulators);
-       if (ret < 0)
-               goto ereg;
-
-       /* The camera could have been already on, try to reset */
-       if (icl->reset)
-               icl->reset(icd->pdev);
-
-       ret = ici->ops->add(icd);
-       if (ret < 0)
-               goto eadd;
-
-       /*
-        * This will not yet call v4l2_subdev_core_ops::s_power(1), because the
-        * subdevice has not been initialised yet. We'll have to call it once
-        * again after initialisation, even though it shouldn't be needed, we
-        * don't do any IO here.
-        */
-       ret = soc_camera_power_on(icd, icl);
-       if (ret < 0)
-               goto epower;
-
-       /* Must have icd->vdev before registering the device */
-       ret = video_dev_create(icd);
-       if (ret < 0)
-               goto evdc;
-
-       /* Non-i2c cameras, e.g., soc_camera_platform, have no board_info */
-       if (icl->board_info) {
-               ret = soc_camera_init_i2c(icd, icl);
-               if (ret < 0)
-                       goto eadddev;
-       } else if (!icl->add_device || !icl->del_device) {
-               ret = -EINVAL;
-               goto eadddev;
-       } else {
-               if (icl->module_name)
-                       ret = request_module(icl->module_name);
-
-               ret = icl->add_device(icd);
-               if (ret < 0)
-                       goto eadddev;
-
-               /*
-                * FIXME: this is racy, have to use driver-binding notification,
-                * when it is available
-                */
-               control = to_soc_camera_control(icd);
-               if (!control || !control->driver || !dev_get_drvdata(control) ||
-                   !try_module_get(control->driver->owner)) {
-                       icl->del_device(icd);
-                       ret = -ENODEV;
-                       goto enodrv;
-               }
-       }
-
-       sd = soc_camera_to_subdev(icd);
-       sd->grp_id = soc_camera_grp_id(icd);
-       v4l2_set_subdev_hostdata(sd, icd);
-
-       if (v4l2_ctrl_add_handler(&icd->ctrl_handler, sd->ctrl_handler))
-               goto ectrl;
-
-       /* At this point client .probe() should have run already */
-       ret = soc_camera_init_user_formats(icd);
-       if (ret < 0)
-               goto eiufmt;
-
-       icd->field = V4L2_FIELD_ANY;
-
-       /*
-        * ..._video_start() will create a device node, video_register_device()
-        * itself is protected against concurrent open() calls, but we also have
-        * to protect our data.
-        */
-       mutex_lock(&icd->video_lock);
-
-       ret = soc_camera_video_start(icd);
-       if (ret < 0)
-               goto evidstart;
-
-       ret = v4l2_subdev_call(sd, core, s_power, 1);
-       if (ret < 0 && ret != -ENOIOCTLCMD)
-               goto esdpwr;
-
-       /* Try to improve our guess of a reasonable window format */
-       if (!v4l2_subdev_call(sd, video, g_mbus_fmt, &mf)) {
-               icd->user_width         = mf.width;
-               icd->user_height        = mf.height;
-               icd->colorspace         = mf.colorspace;
-               icd->field              = mf.field;
-       }
-
-       ici->ops->remove(icd);
-
-       soc_camera_power_off(icd, icl);
-
-       mutex_unlock(&icd->video_lock);
-
-       return 0;
-
-esdpwr:
-       video_unregister_device(icd->vdev);
-evidstart:
-       mutex_unlock(&icd->video_lock);
-       soc_camera_free_user_formats(icd);
-eiufmt:
-ectrl:
-       if (icl->board_info) {
-               soc_camera_free_i2c(icd);
-       } else {
-               icl->del_device(icd);
-               module_put(control->driver->owner);
-       }
-enodrv:
-eadddev:
-       video_device_release(icd->vdev);
-       icd->vdev = NULL;
-evdc:
-       soc_camera_power_off(icd, icl);
-epower:
-       ici->ops->remove(icd);
-eadd:
-       regulator_bulk_free(icl->num_regulators, icl->regulators);
-ereg:
-       v4l2_ctrl_handler_free(&icd->ctrl_handler);
-       return ret;
-}
-
-/*
- * This is called on device_unregister, which only means we have to disconnect
- * from the host, but not remove ourselves from the device list
- */
-static int soc_camera_remove(struct soc_camera_device *icd)
-{
-       struct soc_camera_link *icl = to_soc_camera_link(icd);
-       struct video_device *vdev = icd->vdev;
-
-       BUG_ON(!icd->parent);
-
-       v4l2_ctrl_handler_free(&icd->ctrl_handler);
-       if (vdev) {
-               video_unregister_device(vdev);
-               icd->vdev = NULL;
-       }
-
-       if (icl->board_info) {
-               soc_camera_free_i2c(icd);
-       } else {
-               struct device_driver *drv = to_soc_camera_control(icd)->driver;
-               if (drv) {
-                       icl->del_device(icd);
-                       module_put(drv->owner);
-               }
-       }
-       soc_camera_free_user_formats(icd);
-
-       regulator_bulk_free(icl->num_regulators, icl->regulators);
-
-       return 0;
-}
-
-static int default_cropcap(struct soc_camera_device *icd,
-                          struct v4l2_cropcap *a)
-{
-       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
-       return v4l2_subdev_call(sd, video, cropcap, a);
-}
-
-static int default_g_crop(struct soc_camera_device *icd, struct v4l2_crop *a)
-{
-       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
-       return v4l2_subdev_call(sd, video, g_crop, a);
-}
-
-static int default_s_crop(struct soc_camera_device *icd, struct v4l2_crop *a)
-{
-       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
-       return v4l2_subdev_call(sd, video, s_crop, a);
-}
-
-static int default_g_parm(struct soc_camera_device *icd,
-                         struct v4l2_streamparm *parm)
-{
-       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
-       return v4l2_subdev_call(sd, video, g_parm, parm);
-}
-
-static int default_s_parm(struct soc_camera_device *icd,
-                         struct v4l2_streamparm *parm)
-{
-       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
-       return v4l2_subdev_call(sd, video, s_parm, parm);
-}
-
-static int default_enum_framesizes(struct soc_camera_device *icd,
-                                  struct v4l2_frmsizeenum *fsize)
-{
-       int ret;
-       struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
-       const struct soc_camera_format_xlate *xlate;
-       __u32 pixfmt = fsize->pixel_format;
-       struct v4l2_frmsizeenum fsize_mbus = *fsize;
-
-       xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
-       if (!xlate)
-               return -EINVAL;
-       /* map xlate-code to pixel_format, sensor only handle xlate-code*/
-       fsize_mbus.pixel_format = xlate->code;
-
-       ret = v4l2_subdev_call(sd, video, enum_framesizes, &fsize_mbus);
-       if (ret < 0)
-               return ret;
-
-       *fsize = fsize_mbus;
-       fsize->pixel_format = pixfmt;
-
-       return 0;
-}
-
-int soc_camera_host_register(struct soc_camera_host *ici)
-{
-       struct soc_camera_host *ix;
-       int ret;
-
-       if (!ici || !ici->ops ||
-           !ici->ops->try_fmt ||
-           !ici->ops->set_fmt ||
-           !ici->ops->set_bus_param ||
-           !ici->ops->querycap ||
-           ((!ici->ops->init_videobuf ||
-             !ici->ops->reqbufs) &&
-            !ici->ops->init_videobuf2) ||
-           !ici->ops->add ||
-           !ici->ops->remove ||
-           !ici->ops->poll ||
-           !ici->v4l2_dev.dev)
-               return -EINVAL;
-
-       if (!ici->ops->set_crop)
-               ici->ops->set_crop = default_s_crop;
-       if (!ici->ops->get_crop)
-               ici->ops->get_crop = default_g_crop;
-       if (!ici->ops->cropcap)
-               ici->ops->cropcap = default_cropcap;
-       if (!ici->ops->set_parm)
-               ici->ops->set_parm = default_s_parm;
-       if (!ici->ops->get_parm)
-               ici->ops->get_parm = default_g_parm;
-       if (!ici->ops->enum_framesizes)
-               ici->ops->enum_framesizes = default_enum_framesizes;
-
-       mutex_lock(&list_lock);
-       list_for_each_entry(ix, &hosts, list) {
-               if (ix->nr == ici->nr) {
-                       ret = -EBUSY;
-                       goto edevreg;
-               }
-       }
-
-       ret = v4l2_device_register(ici->v4l2_dev.dev, &ici->v4l2_dev);
-       if (ret < 0)
-               goto edevreg;
-
-       list_add_tail(&ici->list, &hosts);
-       mutex_unlock(&list_lock);
-
-       mutex_init(&ici->host_lock);
-       scan_add_host(ici);
-
-       return 0;
-
-edevreg:
-       mutex_unlock(&list_lock);
-       return ret;
-}
-EXPORT_SYMBOL(soc_camera_host_register);
-
-/* Unregister all clients! */
-void soc_camera_host_unregister(struct soc_camera_host *ici)
-{
-       struct soc_camera_device *icd;
-
-       mutex_lock(&list_lock);
-
-       list_del(&ici->list);
-       list_for_each_entry(icd, &devices, list)
-               if (icd->iface == ici->nr && to_soc_camera_control(icd))
-                       soc_camera_remove(icd);
-
-       mutex_unlock(&list_lock);
-
-       v4l2_device_unregister(&ici->v4l2_dev);
-}
-EXPORT_SYMBOL(soc_camera_host_unregister);
-
-/* Image capture device */
-static int soc_camera_device_register(struct soc_camera_device *icd)
-{
-       struct soc_camera_device *ix;
-       int num = -1, i;
-
-       for (i = 0; i < 256 && num < 0; i++) {
-               num = i;
-               /* Check if this index is available on this interface */
-               list_for_each_entry(ix, &devices, list) {
-                       if (ix->iface == icd->iface && ix->devnum == i) {
-                               num = -1;
-                               break;
-                       }
-               }
-       }
-
-       if (num < 0)
-               /*
-                * ok, we have 256 cameras on this host...
-                * man, stay reasonable...
-                */
-               return -ENOMEM;
-
-       icd->devnum             = num;
-       icd->use_count          = 0;
-       icd->host_priv          = NULL;
-       mutex_init(&icd->video_lock);
-
-       list_add_tail(&icd->list, &devices);
-
-       return 0;
-}
-
-static const struct v4l2_ioctl_ops soc_camera_ioctl_ops = {
-       .vidioc_querycap         = soc_camera_querycap,
-       .vidioc_try_fmt_vid_cap  = soc_camera_try_fmt_vid_cap,
-       .vidioc_g_fmt_vid_cap    = soc_camera_g_fmt_vid_cap,
-       .vidioc_s_fmt_vid_cap    = soc_camera_s_fmt_vid_cap,
-       .vidioc_enum_fmt_vid_cap = soc_camera_enum_fmt_vid_cap,
-       .vidioc_enum_input       = soc_camera_enum_input,
-       .vidioc_g_input          = soc_camera_g_input,
-       .vidioc_s_input          = soc_camera_s_input,
-       .vidioc_s_std            = soc_camera_s_std,
-       .vidioc_g_std            = soc_camera_g_std,
-       .vidioc_enum_framesizes  = soc_camera_enum_framesizes,
-       .vidioc_reqbufs          = soc_camera_reqbufs,
-       .vidioc_querybuf         = soc_camera_querybuf,
-       .vidioc_qbuf             = soc_camera_qbuf,
-       .vidioc_dqbuf            = soc_camera_dqbuf,
-       .vidioc_create_bufs      = soc_camera_create_bufs,
-       .vidioc_prepare_buf      = soc_camera_prepare_buf,
-       .vidioc_streamon         = soc_camera_streamon,
-       .vidioc_streamoff        = soc_camera_streamoff,
-       .vidioc_cropcap          = soc_camera_cropcap,
-       .vidioc_g_crop           = soc_camera_g_crop,
-       .vidioc_s_crop           = soc_camera_s_crop,
-       .vidioc_g_parm           = soc_camera_g_parm,
-       .vidioc_s_parm           = soc_camera_s_parm,
-       .vidioc_g_chip_ident     = soc_camera_g_chip_ident,
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-       .vidioc_g_register       = soc_camera_g_register,
-       .vidioc_s_register       = soc_camera_s_register,
-#endif
-};
-
-static int video_dev_create(struct soc_camera_device *icd)
-{
-       struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-       struct video_device *vdev = video_device_alloc();
-
-       if (!vdev)
-               return -ENOMEM;
-
-       strlcpy(vdev->name, ici->drv_name, sizeof(vdev->name));
-
-       vdev->parent            = icd->pdev;
-       vdev->current_norm      = V4L2_STD_UNKNOWN;
-       vdev->fops              = &soc_camera_fops;
-       vdev->ioctl_ops         = &soc_camera_ioctl_ops;
-       vdev->release           = video_device_release;
-       vdev->tvnorms           = V4L2_STD_UNKNOWN;
-       vdev->ctrl_handler      = &icd->ctrl_handler;
-       vdev->lock              = &icd->video_lock;
-
-       icd->vdev = vdev;
-
-       return 0;
-}
-
-/*
- * Called from soc_camera_probe() above (with .video_lock held???)
- */
-static int soc_camera_video_start(struct soc_camera_device *icd)
-{
-       const struct device_type *type = icd->vdev->dev.type;
-       int ret;
-
-       if (!icd->parent)
-               return -ENODEV;
-
-       ret = video_register_device(icd->vdev, VFL_TYPE_GRABBER, -1);
-       if (ret < 0) {
-               dev_err(icd->pdev, "video_register_device failed: %d\n", ret);
-               return ret;
-       }
-
-       /* Restore device type, possibly set by the subdevice driver */
-       icd->vdev->dev.type = type;
-
-       return 0;
-}
-
-static int __devinit soc_camera_pdrv_probe(struct platform_device *pdev)
-{
-       struct soc_camera_link *icl = pdev->dev.platform_data;
-       struct soc_camera_device *icd;
-       int ret;
-
-       if (!icl)
-               return -EINVAL;
-
-       icd = kzalloc(sizeof(*icd), GFP_KERNEL);
-       if (!icd)
-               return -ENOMEM;
-
-       icd->iface = icl->bus_id;
-       icd->link = icl;
-       icd->pdev = &pdev->dev;
-       platform_set_drvdata(pdev, icd);
-
-       ret = soc_camera_device_register(icd);
-       if (ret < 0)
-               goto escdevreg;
-
-       icd->user_width         = DEFAULT_WIDTH;
-       icd->user_height        = DEFAULT_HEIGHT;
-
-       return 0;
-
-escdevreg:
-       kfree(icd);
-
-       return ret;
-}
-
-/*
- * Only called on rmmod for each platform device, since they are not
- * hot-pluggable. Now we know, that all our users - hosts and devices have
- * been unloaded already
- */
-static int __devexit soc_camera_pdrv_remove(struct platform_device *pdev)
-{
-       struct soc_camera_device *icd = platform_get_drvdata(pdev);
-
-       if (!icd)
-               return -EINVAL;
-
-       list_del(&icd->list);
-
-       kfree(icd);
-
-       return 0;
-}
-
-static struct platform_driver __refdata soc_camera_pdrv = {
-       .probe = soc_camera_pdrv_probe,
-       .remove  = __devexit_p(soc_camera_pdrv_remove),
-       .driver  = {
-               .name   = "soc-camera-pdrv",
-               .owner  = THIS_MODULE,
-       },
-};
-
-static int __init soc_camera_init(void)
-{
-       return platform_driver_register(&soc_camera_pdrv);
-}
-
-static void __exit soc_camera_exit(void)
-{
-       platform_driver_unregister(&soc_camera_pdrv);
-}
-
-module_init(soc_camera_init);
-module_exit(soc_camera_exit);
-
-MODULE_DESCRIPTION("Image capture bus driver");
-MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:soc-camera-pdrv");
diff --git a/drivers/media/video/tw9910.c b/drivers/media/video/tw9910.c
deleted file mode 100644 (file)
index 9f53eac..0000000
+++ /dev/null
@@ -1,956 +0,0 @@
-/*
- * tw9910 Video Driver
- *
- * Copyright (C) 2008 Renesas Solutions Corp.
- * Kuninori Morimoto <morimoto.kuninori@renesas.com>
- *
- * Based on ov772x driver,
- *
- * Copyright (C) 2008 Kuninori Morimoto <morimoto.kuninori@renesas.com>
- * Copyright 2006-7 Jonathan Corbet <corbet@lwn.net>
- * Copyright (C) 2008 Magnus Damm
- * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/i2c.h>
-#include <linux/slab.h>
-#include <linux/kernel.h>
-#include <linux/delay.h>
-#include <linux/v4l2-mediabus.h>
-#include <linux/videodev2.h>
-
-#include <media/soc_camera.h>
-#include <media/tw9910.h>
-#include <media/v4l2-chip-ident.h>
-#include <media/v4l2-subdev.h>
-
-#define GET_ID(val)  ((val & 0xF8) >> 3)
-#define GET_REV(val) (val & 0x07)
-
-/*
- * register offset
- */
-#define ID             0x00 /* Product ID Code Register */
-#define STATUS1                0x01 /* Chip Status Register I */
-#define INFORM         0x02 /* Input Format */
-#define OPFORM         0x03 /* Output Format Control Register */
-#define DLYCTR         0x04 /* Hysteresis and HSYNC Delay Control */
-#define OUTCTR1                0x05 /* Output Control I */
-#define ACNTL1         0x06 /* Analog Control Register 1 */
-#define CROP_HI                0x07 /* Cropping Register, High */
-#define VDELAY_LO      0x08 /* Vertical Delay Register, Low */
-#define VACTIVE_LO     0x09 /* Vertical Active Register, Low */
-#define HDELAY_LO      0x0A /* Horizontal Delay Register, Low */
-#define HACTIVE_LO     0x0B /* Horizontal Active Register, Low */
-#define CNTRL1         0x0C /* Control Register I */
-#define VSCALE_LO      0x0D /* Vertical Scaling Register, Low */
-#define SCALE_HI       0x0E /* Scaling Register, High */
-#define HSCALE_LO      0x0F /* Horizontal Scaling Register, Low */
-#define BRIGHT         0x10 /* BRIGHTNESS Control Register */
-#define CONTRAST       0x11 /* CONTRAST Control Register */
-#define SHARPNESS      0x12 /* SHARPNESS Control Register I */
-#define SAT_U          0x13 /* Chroma (U) Gain Register */
-#define SAT_V          0x14 /* Chroma (V) Gain Register */
-#define HUE            0x15 /* Hue Control Register */
-#define CORING1                0x17
-#define CORING2                0x18 /* Coring and IF compensation */
-#define VBICNTL                0x19 /* VBI Control Register */
-#define ACNTL2         0x1A /* Analog Control 2 */
-#define OUTCTR2                0x1B /* Output Control 2 */
-#define SDT            0x1C /* Standard Selection */
-#define SDTR           0x1D /* Standard Recognition */
-#define TEST           0x1F /* Test Control Register */
-#define CLMPG          0x20 /* Clamping Gain */
-#define IAGC           0x21 /* Individual AGC Gain */
-#define AGCGAIN                0x22 /* AGC Gain */
-#define PEAKWT         0x23 /* White Peak Threshold */
-#define CLMPL          0x24 /* Clamp level */
-#define SYNCT          0x25 /* Sync Amplitude */
-#define MISSCNT                0x26 /* Sync Miss Count Register */
-#define PCLAMP         0x27 /* Clamp Position Register */
-#define VCNTL1         0x28 /* Vertical Control I */
-#define VCNTL2         0x29 /* Vertical Control II */
-#define CKILL          0x2A /* Color Killer Level Control */
-#define COMB           0x2B /* Comb Filter Control */
-#define LDLY           0x2C /* Luma Delay and H Filter Control */
-#define MISC1          0x2D /* Miscellaneous Control I */
-#define LOOP           0x2E /* LOOP Control Register */
-#define MISC2          0x2F /* Miscellaneous Control II */
-#define MVSN           0x30 /* Macrovision Detection */
-#define STATUS2                0x31 /* Chip STATUS II */
-#define HFREF          0x32 /* H monitor */
-#define CLMD           0x33 /* CLAMP MODE */
-#define IDCNTL         0x34 /* ID Detection Control */
-#define CLCNTL1                0x35 /* Clamp Control I */
-#define ANAPLLCTL      0x4C
-#define VBIMIN         0x4D
-#define HSLOWCTL       0x4E
-#define WSS3           0x4F
-#define FILLDATA       0x50
-#define SDID           0x51
-#define DID            0x52
-#define WSS1           0x53
-#define WSS2           0x54
-#define VVBI           0x55
-#define LCTL6          0x56
-#define LCTL7          0x57
-#define LCTL8          0x58
-#define LCTL9          0x59
-#define LCTL10         0x5A
-#define LCTL11         0x5B
-#define LCTL12         0x5C
-#define LCTL13         0x5D
-#define LCTL14         0x5E
-#define LCTL15         0x5F
-#define LCTL16         0x60
-#define LCTL17         0x61
-#define LCTL18         0x62
-#define LCTL19         0x63
-#define LCTL20         0x64
-#define LCTL21         0x65
-#define LCTL22         0x66
-#define LCTL23         0x67
-#define LCTL24         0x68
-#define LCTL25         0x69
-#define LCTL26         0x6A
-#define HSBEGIN                0x6B
-#define HSEND          0x6C
-#define OVSDLY         0x6D
-#define OVSEND         0x6E
-#define VBIDELAY       0x6F
-
-/*
- * register detail
- */
-
-/* INFORM */
-#define FC27_ON     0x40 /* 1 : Input crystal clock frequency is 27MHz */
-#define FC27_FF     0x00 /* 0 : Square pixel mode. */
-                        /*     Must use 24.54MHz for 60Hz field rate */
-                        /*     source or 29.5MHz for 50Hz field rate */
-#define IFSEL_S     0x10 /* 01 : S-video decoding */
-#define IFSEL_C     0x00 /* 00 : Composite video decoding */
-                        /* Y input video selection */
-#define YSEL_M0     0x00 /*  00 : Mux0 selected */
-#define YSEL_M1     0x04 /*  01 : Mux1 selected */
-#define YSEL_M2     0x08 /*  10 : Mux2 selected */
-#define YSEL_M3     0x10 /*  11 : Mux3 selected */
-
-/* OPFORM */
-#define MODE        0x80 /* 0 : CCIR601 compatible YCrCb 4:2:2 format */
-                        /* 1 : ITU-R-656 compatible data sequence format */
-#define LEN         0x40 /* 0 : 8-bit YCrCb 4:2:2 output format */
-                        /* 1 : 16-bit YCrCb 4:2:2 output format.*/
-#define LLCMODE     0x20 /* 1 : LLC output mode. */
-                        /* 0 : free-run output mode */
-#define AINC        0x10 /* Serial interface auto-indexing control */
-                        /* 0 : auto-increment */
-                        /* 1 : non-auto */
-#define VSCTL       0x08 /* 1 : Vertical out ctrl by DVALID */
-                        /* 0 : Vertical out ctrl by HACTIVE and DVALID */
-#define OEN_TRI_SEL_MASK       0x07
-#define OEN_TRI_SEL_ALL_ON     0x00 /* Enable output for Rev0/Rev1 */
-#define OEN_TRI_SEL_ALL_OFF_r0 0x06 /* All tri-stated for Rev0 */
-#define OEN_TRI_SEL_ALL_OFF_r1 0x07 /* All tri-stated for Rev1 */
-
-/* OUTCTR1 */
-#define VSP_LO      0x00 /* 0 : VS pin output polarity is active low */
-#define VSP_HI      0x80 /* 1 : VS pin output polarity is active high. */
-                        /* VS pin output control */
-#define VSSL_VSYNC  0x00 /*   0 : VSYNC  */
-#define VSSL_VACT   0x10 /*   1 : VACT   */
-#define VSSL_FIELD  0x20 /*   2 : FIELD  */
-#define VSSL_VVALID 0x30 /*   3 : VVALID */
-#define VSSL_ZERO   0x70 /*   7 : 0      */
-#define HSP_LOW     0x00 /* 0 : HS pin output polarity is active low */
-#define HSP_HI      0x08 /* 1 : HS pin output polarity is active high.*/
-                        /* HS pin output control */
-#define HSSL_HACT   0x00 /*   0 : HACT   */
-#define HSSL_HSYNC  0x01 /*   1 : HSYNC  */
-#define HSSL_DVALID 0x02 /*   2 : DVALID */
-#define HSSL_HLOCK  0x03 /*   3 : HLOCK  */
-#define HSSL_ASYNCW 0x04 /*   4 : ASYNCW */
-#define HSSL_ZERO   0x07 /*   7 : 0      */
-
-/* ACNTL1 */
-#define SRESET      0x80 /* resets the device to its default state
-                         * but all register content remain unchanged.
-                         * This bit is self-resetting.
-                         */
-#define ACNTL1_PDN_MASK        0x0e
-#define CLK_PDN                0x08 /* system clock power down */
-#define Y_PDN          0x04 /* Luma ADC power down */
-#define C_PDN          0x02 /* Chroma ADC power down */
-
-/* ACNTL2 */
-#define ACNTL2_PDN_MASK        0x40
-#define PLL_PDN                0x40 /* PLL power down */
-
-/* VBICNTL */
-
-/* RTSEL : control the real time signal output from the MPOUT pin */
-#define RTSEL_MASK  0x07
-#define RTSEL_VLOSS 0x00 /* 0000 = Video loss */
-#define RTSEL_HLOCK 0x01 /* 0001 = H-lock */
-#define RTSEL_SLOCK 0x02 /* 0010 = S-lock */
-#define RTSEL_VLOCK 0x03 /* 0011 = V-lock */
-#define RTSEL_MONO  0x04 /* 0100 = MONO */
-#define RTSEL_DET50 0x05 /* 0101 = DET50 */
-#define RTSEL_FIELD 0x06 /* 0110 = FIELD */
-#define RTSEL_RTCO  0x07 /* 0111 = RTCO ( Real Time Control ) */
-
-/* HSYNC start and end are constant for now */
-#define HSYNC_START    0x0260
-#define HSYNC_END      0x0300
-
-/*
- * structure
- */
-
-struct regval_list {
-       unsigned char reg_num;
-       unsigned char value;
-};
-
-struct tw9910_scale_ctrl {
-       char           *name;
-       unsigned short  width;
-       unsigned short  height;
-       u16             hscale;
-       u16             vscale;
-};
-
-struct tw9910_priv {
-       struct v4l2_subdev              subdev;
-       struct tw9910_video_info        *info;
-       const struct tw9910_scale_ctrl  *scale;
-       v4l2_std_id                     norm;
-       u32                             revision;
-};
-
-static const struct tw9910_scale_ctrl tw9910_ntsc_scales[] = {
-       {
-               .name   = "NTSC SQ",
-               .width  = 640,
-               .height = 480,
-               .hscale = 0x0100,
-               .vscale = 0x0100,
-       },
-       {
-               .name   = "NTSC CCIR601",
-               .width  = 720,
-               .height = 480,
-               .hscale = 0x0100,
-               .vscale = 0x0100,
-       },
-       {
-               .name   = "NTSC SQ (CIF)",
-               .width  = 320,
-               .height = 240,
-               .hscale = 0x0200,
-               .vscale = 0x0200,
-       },
-       {
-               .name   = "NTSC CCIR601 (CIF)",
-               .width  = 360,
-               .height = 240,
-               .hscale = 0x0200,
-               .vscale = 0x0200,
-       },
-       {
-               .name   = "NTSC SQ (QCIF)",
-               .width  = 160,
-               .height = 120,
-               .hscale = 0x0400,
-               .vscale = 0x0400,
-       },
-       {
-               .name   = "NTSC CCIR601 (QCIF)",
-               .width  = 180,
-               .height = 120,
-               .hscale = 0x0400,
-               .vscale = 0x0400,
-       },
-};
-
-static const struct tw9910_scale_ctrl tw9910_pal_scales[] = {
-       {
-               .name   = "PAL SQ",
-               .width  = 768,
-               .height = 576,
-               .hscale = 0x0100,
-               .vscale = 0x0100,
-       },
-       {
-               .name   = "PAL CCIR601",
-               .width  = 720,
-               .height = 576,
-               .hscale = 0x0100,
-               .vscale = 0x0100,
-       },
-       {
-               .name   = "PAL SQ (CIF)",
-               .width  = 384,
-               .height = 288,
-               .hscale = 0x0200,
-               .vscale = 0x0200,
-       },
-       {
-               .name   = "PAL CCIR601 (CIF)",
-               .width  = 360,
-               .height = 288,
-               .hscale = 0x0200,
-               .vscale = 0x0200,
-       },
-       {
-               .name   = "PAL SQ (QCIF)",
-               .width  = 192,
-               .height = 144,
-               .hscale = 0x0400,
-               .vscale = 0x0400,
-       },
-       {
-               .name   = "PAL CCIR601 (QCIF)",
-               .width  = 180,
-               .height = 144,
-               .hscale = 0x0400,
-               .vscale = 0x0400,
-       },
-};
-
-/*
- * general function
- */
-static struct tw9910_priv *to_tw9910(const struct i2c_client *client)
-{
-       return container_of(i2c_get_clientdata(client), struct tw9910_priv,
-                           subdev);
-}
-
-static int tw9910_mask_set(struct i2c_client *client, u8 command,
-                          u8 mask, u8 set)
-{
-       s32 val = i2c_smbus_read_byte_data(client, command);
-       if (val < 0)
-               return val;
-
-       val &= ~mask;
-       val |= set & mask;
-
-       return i2c_smbus_write_byte_data(client, command, val);
-}
-
-static int tw9910_set_scale(struct i2c_client *client,
-                           const struct tw9910_scale_ctrl *scale)
-{
-       int ret;
-
-       ret = i2c_smbus_write_byte_data(client, SCALE_HI,
-                                       (scale->vscale & 0x0F00) >> 4 |
-                                       (scale->hscale & 0x0F00) >> 8);
-       if (ret < 0)
-               return ret;
-
-       ret = i2c_smbus_write_byte_data(client, HSCALE_LO,
-                                       scale->hscale & 0x00FF);
-       if (ret < 0)
-               return ret;
-
-       ret = i2c_smbus_write_byte_data(client, VSCALE_LO,
-                                       scale->vscale & 0x00FF);
-
-       return ret;
-}
-
-static int tw9910_set_hsync(struct i2c_client *client)
-{
-       struct tw9910_priv *priv = to_tw9910(client);
-       int ret;
-
-       /* bit 10 - 3 */
-       ret = i2c_smbus_write_byte_data(client, HSBEGIN,
-                                       (HSYNC_START & 0x07F8) >> 3);
-       if (ret < 0)
-               return ret;
-
-       /* bit 10 - 3 */
-       ret = i2c_smbus_write_byte_data(client, HSEND,
-                                       (HSYNC_END & 0x07F8) >> 3);
-       if (ret < 0)
-               return ret;
-
-       /* So far only revisions 0 and 1 have been seen */
-       /* bit 2 - 0 */
-       if (1 == priv->revision)
-               ret = tw9910_mask_set(client, HSLOWCTL, 0x77,
-                                     (HSYNC_START & 0x0007) << 4 |
-                                     (HSYNC_END   & 0x0007));
-
-       return ret;
-}
-
-static void tw9910_reset(struct i2c_client *client)
-{
-       tw9910_mask_set(client, ACNTL1, SRESET, SRESET);
-       msleep(1);
-}
-
-static int tw9910_power(struct i2c_client *client, int enable)
-{
-       int ret;
-       u8 acntl1;
-       u8 acntl2;
-
-       if (enable) {
-               acntl1 = 0;
-               acntl2 = 0;
-       } else {
-               acntl1 = CLK_PDN | Y_PDN | C_PDN;
-               acntl2 = PLL_PDN;
-       }
-
-       ret = tw9910_mask_set(client, ACNTL1, ACNTL1_PDN_MASK, acntl1);
-       if (ret < 0)
-               return ret;
-
-       return tw9910_mask_set(client, ACNTL2, ACNTL2_PDN_MASK, acntl2);
-}
-
-static const struct tw9910_scale_ctrl *tw9910_select_norm(v4l2_std_id norm,
-                                                         u32 width, u32 height)
-{
-       const struct tw9910_scale_ctrl *scale;
-       const struct tw9910_scale_ctrl *ret = NULL;
-       __u32 diff = 0xffffffff, tmp;
-       int size, i;
-
-       if (norm & V4L2_STD_NTSC) {
-               scale = tw9910_ntsc_scales;
-               size = ARRAY_SIZE(tw9910_ntsc_scales);
-       } else if (norm & V4L2_STD_PAL) {
-               scale = tw9910_pal_scales;
-               size = ARRAY_SIZE(tw9910_pal_scales);
-       } else {
-               return NULL;
-       }
-
-       for (i = 0; i < size; i++) {
-               tmp = abs(width - scale[i].width) +
-                       abs(height - scale[i].height);
-               if (tmp < diff) {
-                       diff = tmp;
-                       ret = scale + i;
-               }
-       }
-
-       return ret;
-}
-
-/*
- * subdevice operations
- */
-static int tw9910_s_stream(struct v4l2_subdev *sd, int enable)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct tw9910_priv *priv = to_tw9910(client);
-       u8 val;
-       int ret;
-
-       if (!enable) {
-               switch (priv->revision) {
-               case 0:
-                       val = OEN_TRI_SEL_ALL_OFF_r0;
-                       break;
-               case 1:
-                       val = OEN_TRI_SEL_ALL_OFF_r1;
-                       break;
-               default:
-                       dev_err(&client->dev, "un-supported revision\n");
-                       return -EINVAL;
-               }
-       } else {
-               val = OEN_TRI_SEL_ALL_ON;
-
-               if (!priv->scale) {
-                       dev_err(&client->dev, "norm select error\n");
-                       return -EPERM;
-               }
-
-               dev_dbg(&client->dev, "%s %dx%d\n",
-                       priv->scale->name,
-                       priv->scale->width,
-                       priv->scale->height);
-       }
-
-       ret = tw9910_mask_set(client, OPFORM, OEN_TRI_SEL_MASK, val);
-       if (ret < 0)
-               return ret;
-
-       return tw9910_power(client, enable);
-}
-
-static int tw9910_g_std(struct v4l2_subdev *sd, v4l2_std_id *norm)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct tw9910_priv *priv = to_tw9910(client);
-
-       *norm = priv->norm;
-
-       return 0;
-}
-
-static int tw9910_s_std(struct v4l2_subdev *sd, v4l2_std_id norm)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct tw9910_priv *priv = to_tw9910(client);
-
-       if (!(norm & (V4L2_STD_NTSC | V4L2_STD_PAL)))
-               return -EINVAL;
-
-       priv->norm = norm;
-
-       return 0;
-}
-
-static int tw9910_g_chip_ident(struct v4l2_subdev *sd,
-                              struct v4l2_dbg_chip_ident *id)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct tw9910_priv *priv = to_tw9910(client);
-
-       id->ident = V4L2_IDENT_TW9910;
-       id->revision = priv->revision;
-
-       return 0;
-}
-
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-static int tw9910_g_register(struct v4l2_subdev *sd,
-                            struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       int ret;
-
-       if (reg->reg > 0xff)
-               return -EINVAL;
-
-       ret = i2c_smbus_read_byte_data(client, reg->reg);
-       if (ret < 0)
-               return ret;
-
-       /*
-        * ret      = int
-        * reg->val = __u64
-        */
-       reg->val = (__u64)ret;
-
-       return 0;
-}
-
-static int tw9910_s_register(struct v4l2_subdev *sd,
-                            struct v4l2_dbg_register *reg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-
-       if (reg->reg > 0xff ||
-           reg->val > 0xff)
-               return -EINVAL;
-
-       return i2c_smbus_write_byte_data(client, reg->reg, reg->val);
-}
-#endif
-
-static int tw9910_set_frame(struct v4l2_subdev *sd, u32 *width, u32 *height)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct tw9910_priv *priv = to_tw9910(client);
-       int ret = -EINVAL;
-       u8 val;
-
-       /*
-        * select suitable norm
-        */
-       priv->scale = tw9910_select_norm(priv->norm, *width, *height);
-       if (!priv->scale)
-               goto tw9910_set_fmt_error;
-
-       /*
-        * reset hardware
-        */
-       tw9910_reset(client);
-
-       /*
-        * set bus width
-        */
-       val = 0x00;
-       if (SOCAM_DATAWIDTH_16 == priv->info->buswidth)
-               val = LEN;
-
-       ret = tw9910_mask_set(client, OPFORM, LEN, val);
-       if (ret < 0)
-               goto tw9910_set_fmt_error;
-
-       /*
-        * select MPOUT behavior
-        */
-       switch (priv->info->mpout) {
-       case TW9910_MPO_VLOSS:
-               val = RTSEL_VLOSS; break;
-       case TW9910_MPO_HLOCK:
-               val = RTSEL_HLOCK; break;
-       case TW9910_MPO_SLOCK:
-               val = RTSEL_SLOCK; break;
-       case TW9910_MPO_VLOCK:
-               val = RTSEL_VLOCK; break;
-       case TW9910_MPO_MONO:
-               val = RTSEL_MONO;  break;
-       case TW9910_MPO_DET50:
-               val = RTSEL_DET50; break;
-       case TW9910_MPO_FIELD:
-               val = RTSEL_FIELD; break;
-       case TW9910_MPO_RTCO:
-               val = RTSEL_RTCO;  break;
-       default:
-               val = 0;
-       }
-
-       ret = tw9910_mask_set(client, VBICNTL, RTSEL_MASK, val);
-       if (ret < 0)
-               goto tw9910_set_fmt_error;
-
-       /*
-        * set scale
-        */
-       ret = tw9910_set_scale(client, priv->scale);
-       if (ret < 0)
-               goto tw9910_set_fmt_error;
-
-       /*
-        * set hsync
-        */
-       ret = tw9910_set_hsync(client);
-       if (ret < 0)
-               goto tw9910_set_fmt_error;
-
-       *width = priv->scale->width;
-       *height = priv->scale->height;
-
-       return ret;
-
-tw9910_set_fmt_error:
-
-       tw9910_reset(client);
-       priv->scale = NULL;
-
-       return ret;
-}
-
-static int tw9910_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct tw9910_priv *priv = to_tw9910(client);
-
-       a->c.left       = 0;
-       a->c.top        = 0;
-       if (priv->norm & V4L2_STD_NTSC) {
-               a->c.width      = 640;
-               a->c.height     = 480;
-       } else {
-               a->c.width      = 768;
-               a->c.height     = 576;
-       }
-       a->type         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-
-       return 0;
-}
-
-static int tw9910_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct tw9910_priv *priv = to_tw9910(client);
-
-       a->bounds.left                  = 0;
-       a->bounds.top                   = 0;
-       if (priv->norm & V4L2_STD_NTSC) {
-               a->bounds.width         = 640;
-               a->bounds.height        = 480;
-       } else {
-               a->bounds.width         = 768;
-               a->bounds.height        = 576;
-       }
-       a->defrect                      = a->bounds;
-       a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-       a->pixelaspect.numerator        = 1;
-       a->pixelaspect.denominator      = 1;
-
-       return 0;
-}
-
-static int tw9910_g_fmt(struct v4l2_subdev *sd,
-                       struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct tw9910_priv *priv = to_tw9910(client);
-
-       if (!priv->scale) {
-               priv->scale = tw9910_select_norm(priv->norm, 640, 480);
-               if (!priv->scale)
-                       return -EINVAL;
-       }
-
-       mf->width       = priv->scale->width;
-       mf->height      = priv->scale->height;
-       mf->code        = V4L2_MBUS_FMT_UYVY8_2X8;
-       mf->colorspace  = V4L2_COLORSPACE_JPEG;
-       mf->field       = V4L2_FIELD_INTERLACED_BT;
-
-       return 0;
-}
-
-static int tw9910_s_fmt(struct v4l2_subdev *sd,
-                       struct v4l2_mbus_framefmt *mf)
-{
-       u32 width = mf->width, height = mf->height;
-       int ret;
-
-       WARN_ON(mf->field != V4L2_FIELD_ANY &&
-               mf->field != V4L2_FIELD_INTERLACED_BT);
-
-       /*
-        * check color format
-        */
-       if (mf->code != V4L2_MBUS_FMT_UYVY8_2X8)
-               return -EINVAL;
-
-       mf->colorspace = V4L2_COLORSPACE_JPEG;
-
-       ret = tw9910_set_frame(sd, &width, &height);
-       if (!ret) {
-               mf->width       = width;
-               mf->height      = height;
-       }
-       return ret;
-}
-
-static int tw9910_try_fmt(struct v4l2_subdev *sd,
-                         struct v4l2_mbus_framefmt *mf)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct tw9910_priv *priv = to_tw9910(client);
-       const struct tw9910_scale_ctrl *scale;
-
-       if (V4L2_FIELD_ANY == mf->field) {
-               mf->field = V4L2_FIELD_INTERLACED_BT;
-       } else if (V4L2_FIELD_INTERLACED_BT != mf->field) {
-               dev_err(&client->dev, "Field type %d invalid.\n", mf->field);
-               return -EINVAL;
-       }
-
-       mf->code = V4L2_MBUS_FMT_UYVY8_2X8;
-       mf->colorspace = V4L2_COLORSPACE_JPEG;
-
-       /*
-        * select suitable norm
-        */
-       scale = tw9910_select_norm(priv->norm, mf->width, mf->height);
-       if (!scale)
-               return -EINVAL;
-
-       mf->width       = scale->width;
-       mf->height      = scale->height;
-
-       return 0;
-}
-
-static int tw9910_video_probe(struct i2c_client *client)
-{
-       struct tw9910_priv *priv = to_tw9910(client);
-       s32 id;
-
-       /*
-        * tw9910 only use 8 or 16 bit bus width
-        */
-       if (SOCAM_DATAWIDTH_16 != priv->info->buswidth &&
-           SOCAM_DATAWIDTH_8  != priv->info->buswidth) {
-               dev_err(&client->dev, "bus width error\n");
-               return -ENODEV;
-       }
-
-       /*
-        * check and show Product ID
-        * So far only revisions 0 and 1 have been seen
-        */
-       id = i2c_smbus_read_byte_data(client, ID);
-       priv->revision = GET_REV(id);
-       id = GET_ID(id);
-
-       if (0x0B != id ||
-           0x01 < priv->revision) {
-               dev_err(&client->dev,
-                       "Product ID error %x:%x\n",
-                       id, priv->revision);
-               return -ENODEV;
-       }
-
-       dev_info(&client->dev,
-                "tw9910 Product ID %0x:%0x\n", id, priv->revision);
-
-       priv->norm = V4L2_STD_NTSC;
-
-       return 0;
-}
-
-static struct v4l2_subdev_core_ops tw9910_subdev_core_ops = {
-       .g_chip_ident   = tw9910_g_chip_ident,
-       .s_std          = tw9910_s_std,
-       .g_std          = tw9910_g_std,
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-       .g_register     = tw9910_g_register,
-       .s_register     = tw9910_s_register,
-#endif
-};
-
-static int tw9910_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                          enum v4l2_mbus_pixelcode *code)
-{
-       if (index)
-               return -EINVAL;
-
-       *code = V4L2_MBUS_FMT_UYVY8_2X8;
-       return 0;
-}
-
-static int tw9910_g_mbus_config(struct v4l2_subdev *sd,
-                               struct v4l2_mbus_config *cfg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-
-       cfg->flags = V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_MASTER |
-               V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_LOW |
-               V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_HSYNC_ACTIVE_LOW |
-               V4L2_MBUS_DATA_ACTIVE_HIGH;
-       cfg->type = V4L2_MBUS_PARALLEL;
-       cfg->flags = soc_camera_apply_board_flags(icl, cfg);
-
-       return 0;
-}
-
-static int tw9910_s_mbus_config(struct v4l2_subdev *sd,
-                               const struct v4l2_mbus_config *cfg)
-{
-       struct i2c_client *client = v4l2_get_subdevdata(sd);
-       struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
-       u8 val = VSSL_VVALID | HSSL_DVALID;
-       unsigned long flags = soc_camera_apply_board_flags(icl, cfg);
-
-       /*
-        * set OUTCTR1
-        *
-        * We use VVALID and DVALID signals to control VSYNC and HSYNC
-        * outputs, in this mode their polarity is inverted.
-        */
-       if (flags & V4L2_MBUS_HSYNC_ACTIVE_LOW)
-               val |= HSP_HI;
-
-       if (flags & V4L2_MBUS_VSYNC_ACTIVE_LOW)
-               val |= VSP_HI;
-
-       return i2c_smbus_write_byte_data(client, OUTCTR1, val);
-}
-
-static struct v4l2_subdev_video_ops tw9910_subdev_video_ops = {
-       .s_stream       = tw9910_s_stream,
-       .g_mbus_fmt     = tw9910_g_fmt,
-       .s_mbus_fmt     = tw9910_s_fmt,
-       .try_mbus_fmt   = tw9910_try_fmt,
-       .cropcap        = tw9910_cropcap,
-       .g_crop         = tw9910_g_crop,
-       .enum_mbus_fmt  = tw9910_enum_fmt,
-       .g_mbus_config  = tw9910_g_mbus_config,
-       .s_mbus_config  = tw9910_s_mbus_config,
-};
-
-static struct v4l2_subdev_ops tw9910_subdev_ops = {
-       .core   = &tw9910_subdev_core_ops,
-       .video  = &tw9910_subdev_video_ops,
-};
-
-/*
- * i2c_driver function
- */
-
-static int tw9910_probe(struct i2c_client *client,
-                       const struct i2c_device_id *did)
-
-{
-       struct tw9910_priv              *priv;
-       struct tw9910_video_info        *info;
-       struct i2c_adapter              *adapter =
-               to_i2c_adapter(client->dev.parent);
-       struct soc_camera_link          *icl = soc_camera_i2c_to_link(client);
-       int                             ret;
-
-       if (!icl || !icl->priv) {
-               dev_err(&client->dev, "TW9910: missing platform data!\n");
-               return -EINVAL;
-       }
-
-       info = icl->priv;
-
-       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
-               dev_err(&client->dev,
-                       "I2C-Adapter doesn't support "
-                       "I2C_FUNC_SMBUS_BYTE_DATA\n");
-               return -EIO;
-       }
-
-       priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-       if (!priv)
-               return -ENOMEM;
-
-       priv->info   = info;
-
-       v4l2_i2c_subdev_init(&priv->subdev, client, &tw9910_subdev_ops);
-
-       ret = tw9910_video_probe(client);
-       if (ret)
-               kfree(priv);
-
-       return ret;
-}
-
-static int tw9910_remove(struct i2c_client *client)
-{
-       struct tw9910_priv *priv = to_tw9910(client);
-
-       kfree(priv);
-       return 0;
-}
-
-static const struct i2c_device_id tw9910_id[] = {
-       { "tw9910", 0 },
-       { }
-};
-MODULE_DEVICE_TABLE(i2c, tw9910_id);
-
-static struct i2c_driver tw9910_i2c_driver = {
-       .driver = {
-               .name = "tw9910",
-       },
-       .probe    = tw9910_probe,
-       .remove   = tw9910_remove,
-       .id_table = tw9910_id,
-};
-
-module_i2c_driver(tw9910_i2c_driver);
-
-MODULE_DESCRIPTION("SoC Camera driver for tw9910");
-MODULE_AUTHOR("Kuninori Morimoto");
-MODULE_LICENSE("GPL v2");