V4L/DVB (12510): soc-camera: (partially) convert to v4l2-(sub)dev API

Convert the soc-camera framework to use the v4l2-(sub)dev API. Start using
v4l2-subdev operations. Only a part of the interface between the
soc_camera core, soc_camera host drivers on one side and soc_camera device
drivers on the other side is replaced so far. The rest of the interface
will be replaced in incremental steps, and will require extensions and,
possibly, modifications to the v4l2-subdev code.

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

1 files changed, 129 insertions, 180 deletions

diff --git a/drivers/media/video/mt9m111.c b/drivers/media/video/mt9m111.c
index 95c2f089605..29f976afd46 100644
--- a/drivers/media/video/mt9m111.c
+++ b/drivers/media/video/mt9m111.c
@@ -148,6 +148,7 @@ enum mt9m111_context {
 };
 
 struct mt9m111 {
+        struct v4l2_subdev subdev;
         int model;      /* V4L2_IDENT_MT9M11x* codes from v4l2-chip-ident.h */
         enum mt9m111_context context;
         struct v4l2_rect rect;
@@ -164,6 +165,11 @@ struct mt9m111 {
         unsigned int autowhitebalance:1;
 };
 
+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;
@@ -227,10 +233,9 @@ static int mt9m111_reg_clear(struct i2c_client *client, const u16 reg,
         return mt9m111_reg_write(client, reg, ret & ~data);
 }
 
-static int mt9m111_set_context(struct soc_camera_device *icd,
+static int mt9m111_set_context(struct i2c_client *client,
                                enum mt9m111_context ctxt)
 {
-        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
         int valB = 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
@@ -244,11 +249,10 @@ static int mt9m111_set_context(struct soc_camera_device *icd,
                 return reg_write(CONTEXT_CONTROL, valA);
 }
 
-static int mt9m111_setup_rect(struct soc_camera_device *icd,
+static int mt9m111_setup_rect(struct i2c_client *client,
                               struct v4l2_rect *rect)
 {
-        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
-        struct mt9m111 *mt9m111 = i2c_get_clientdata(client);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int ret, is_raw_format;
         int width = rect->width;
         int height = rect->height;
@@ -290,9 +294,8 @@ static int mt9m111_setup_rect(struct soc_camera_device *icd,
         return ret;
 }
 
-static int mt9m111_setup_pixfmt(struct soc_camera_device *icd, u16 outfmt)
+static int mt9m111_setup_pixfmt(struct i2c_client *client, u16 outfmt)
 {
-        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
         int ret;
 
         ret = reg_write(OUTPUT_FORMAT_CTRL2_A, outfmt);
@@ -301,20 +304,19 @@ static int mt9m111_setup_pixfmt(struct soc_camera_device *icd, u16 outfmt)
         return ret;
 }
 
-static int mt9m111_setfmt_bayer8(struct soc_camera_device *icd)
+static int mt9m111_setfmt_bayer8(struct i2c_client *client)
 {
-        return mt9m111_setup_pixfmt(icd, MT9M111_OUTFMT_PROCESSED_BAYER);
+        return mt9m111_setup_pixfmt(client, MT9M111_OUTFMT_PROCESSED_BAYER);
 }
 
-static int mt9m111_setfmt_bayer10(struct soc_camera_device *icd)
+static int mt9m111_setfmt_bayer10(struct i2c_client *client)
 {
-        return mt9m111_setup_pixfmt(icd, MT9M111_OUTFMT_BYPASS_IFP);
+        return mt9m111_setup_pixfmt(client, MT9M111_OUTFMT_BYPASS_IFP);
 }
 
-static int mt9m111_setfmt_rgb565(struct soc_camera_device *icd)
+static int mt9m111_setfmt_rgb565(struct i2c_client *client)
 {
-        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
-        struct mt9m111 *mt9m111 = i2c_get_clientdata(client);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int val = 0;
 
         if (mt9m111->swap_rgb_red_blue)
@@ -323,13 +325,12 @@ static int mt9m111_setfmt_rgb565(struct soc_camera_device *icd)
                 val |= MT9M111_OUTFMT_SWAP_RGB_EVEN;
         val |= MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB565;
 
-        return mt9m111_setup_pixfmt(icd, val);
+        return mt9m111_setup_pixfmt(client, val);
 }
 
-static int mt9m111_setfmt_rgb555(struct soc_camera_device *icd)
+static int mt9m111_setfmt_rgb555(struct i2c_client *client)
 {
-        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
-        struct mt9m111 *mt9m111 = i2c_get_clientdata(client);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int val = 0;
 
         if (mt9m111->swap_rgb_red_blue)
@@ -338,13 +339,12 @@ static int mt9m111_setfmt_rgb555(struct soc_camera_device *icd)
                 val |= MT9M111_OUTFMT_SWAP_RGB_EVEN;
         val |= MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB555;
 
-        return mt9m111_setup_pixfmt(icd, val);
+        return mt9m111_setup_pixfmt(client, val);
 }
 
-static int mt9m111_setfmt_yuv(struct soc_camera_device *icd)
+static int mt9m111_setfmt_yuv(struct i2c_client *client)
 {
-        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
-        struct mt9m111 *mt9m111 = i2c_get_clientdata(client);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int val = 0;
 
         if (mt9m111->swap_yuv_cb_cr)
@@ -352,52 +352,22 @@ static int mt9m111_setfmt_yuv(struct soc_camera_device *icd)
         if (mt9m111->swap_yuv_y_chromas)
                 val |= MT9M111_OUTFMT_SWAP_YCbCr_C_Y;
 
-        return mt9m111_setup_pixfmt(icd, val);
+        return mt9m111_setup_pixfmt(client, val);
 }
 
-static int mt9m111_enable(struct soc_camera_device *icd)
+static int mt9m111_enable(struct i2c_client *client)
 {
-        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
-        struct soc_camera_link *icl = to_soc_camera_link(icd);
-        struct mt9m111 *mt9m111 = i2c_get_clientdata(client);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int ret;
 
-        if (icl->power) {
-                ret = icl->power(&client->dev, 1);
-                if (ret < 0) {
-                        dev_err(icd->vdev->parent,
-                                "Platform failed to power-on the camera.\n");
-                        return ret;
-                }
-        }
-
         ret = reg_set(RESET, MT9M111_RESET_CHIP_ENABLE);
         if (!ret)
                 mt9m111->powered = 1;
         return ret;
 }
 
-static int mt9m111_disable(struct soc_camera_device *icd)
-{
-        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
-        struct soc_camera_link *icl = to_soc_camera_link(icd);
-        struct mt9m111 *mt9m111 = i2c_get_clientdata(client);
-        int ret;
-
-        ret = reg_clear(RESET, MT9M111_RESET_CHIP_ENABLE);
-        if (!ret)
-                mt9m111->powered = 0;
-
-        if (icl->power)
-                icl->power(&client->dev, 0);
-
-        return ret;
-}
-
-static int mt9m111_reset(struct soc_camera_device *icd)
+static int mt9m111_reset(struct i2c_client *client)
 {
-        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
-        struct soc_camera_link *icl = to_soc_camera_link(icd);
         int ret;
 
         ret = reg_set(RESET, MT9M111_RESET_RESET_MODE);
@@ -407,22 +377,9 @@ static int mt9m111_reset(struct soc_camera_device *icd)
                 ret = reg_clear(RESET, MT9M111_RESET_RESET_MODE
                                 | MT9M111_RESET_RESET_SOC);
 
-        if (icl->reset)
-                icl->reset(&client->dev);
-
         return ret;
 }
 
-static int mt9m111_start_capture(struct soc_camera_device *icd)
-{
-        return 0;
-}
-
-static int mt9m111_stop_capture(struct soc_camera_device *icd)
-{
-        return 0;
-}
-
 static unsigned long mt9m111_query_bus_param(struct soc_camera_device *icd)
 {
         struct soc_camera_link *icl = to_soc_camera_link(icd);
@@ -442,60 +399,59 @@ static int mt9m111_set_crop(struct soc_camera_device *icd,
                             struct v4l2_rect *rect)
 {
         struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
-        struct mt9m111 *mt9m111 = i2c_get_clientdata(client);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int ret;
 
         dev_dbg(&icd->dev, "%s left=%d, top=%d, width=%d, height=%d\n",
                 __func__, rect->left, rect->top, rect->width,
                 rect->height);
 
-        ret = mt9m111_setup_rect(icd, rect);
+        ret = mt9m111_setup_rect(client, rect);
         if (!ret)
                 mt9m111->rect = *rect;
         return ret;
 }
 
-static int mt9m111_set_pixfmt(struct soc_camera_device *icd, u32 pixfmt)
+static int mt9m111_set_pixfmt(struct i2c_client *client, u32 pixfmt)
 {
-        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
-        struct mt9m111 *mt9m111 = i2c_get_clientdata(client);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int ret;
 
         switch (pixfmt) {
         case V4L2_PIX_FMT_SBGGR8:
-                ret = mt9m111_setfmt_bayer8(icd);
+                ret = mt9m111_setfmt_bayer8(client);
                 break;
         case V4L2_PIX_FMT_SBGGR16:
-                ret = mt9m111_setfmt_bayer10(icd);
+                ret = mt9m111_setfmt_bayer10(client);
                 break;
         case V4L2_PIX_FMT_RGB555:
-                ret = mt9m111_setfmt_rgb555(icd);
+                ret = mt9m111_setfmt_rgb555(client);
                 break;
         case V4L2_PIX_FMT_RGB565:
-                ret = mt9m111_setfmt_rgb565(icd);
+                ret = mt9m111_setfmt_rgb565(client);
                 break;
         case V4L2_PIX_FMT_UYVY:
                 mt9m111->swap_yuv_y_chromas = 0;
                 mt9m111->swap_yuv_cb_cr = 0;
-                ret = mt9m111_setfmt_yuv(icd);
+                ret = mt9m111_setfmt_yuv(client);
                 break;
         case V4L2_PIX_FMT_VYUY:
                 mt9m111->swap_yuv_y_chromas = 0;
                 mt9m111->swap_yuv_cb_cr = 1;
-                ret = mt9m111_setfmt_yuv(icd);
+                ret = mt9m111_setfmt_yuv(client);
                 break;
         case V4L2_PIX_FMT_YUYV:
                 mt9m111->swap_yuv_y_chromas = 1;
                 mt9m111->swap_yuv_cb_cr = 0;
-                ret = mt9m111_setfmt_yuv(icd);
+                ret = mt9m111_setfmt_yuv(client);
                 break;
         case V4L2_PIX_FMT_YVYU:
                 mt9m111->swap_yuv_y_chromas = 1;
                 mt9m111->swap_yuv_cb_cr = 1;
-                ret = mt9m111_setfmt_yuv(icd);
+                ret = mt9m111_setfmt_yuv(client);
                 break;
         default:
-                dev_err(&icd->dev, "Pixel format not handled : %x\n", pixfmt);
+                dev_err(&client->dev, "Pixel format not handled : %x\n", pixfmt);
                 ret = -EINVAL;
         }
 
@@ -505,11 +461,10 @@ static int mt9m111_set_pixfmt(struct soc_camera_device *icd, u32 pixfmt)
         return ret;
 }
 
-static int mt9m111_set_fmt(struct soc_camera_device *icd,
-                           struct v4l2_format *f)
+static int mt9m111_s_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
 {
-        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
-        struct mt9m111 *mt9m111 = i2c_get_clientdata(client);
+        struct i2c_client *client = sd->priv;
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         struct v4l2_pix_format *pix = &f->fmt.pix;
         struct v4l2_rect rect = {
                 .left   = mt9m111->rect.left,
@@ -519,20 +474,19 @@ static int mt9m111_set_fmt(struct soc_camera_device *icd,
         };
         int ret;
 
-        dev_dbg(&icd->dev, "%s fmt=%x left=%d, top=%d, width=%d, height=%d\n",
+        dev_dbg(&client->dev, "%s fmt=%x left=%d, top=%d, width=%d, height=%d\n",
                 __func__, pix->pixelformat, rect.left, rect.top, rect.width,
                 rect.height);
 
-        ret = mt9m111_setup_rect(icd, &rect);
+        ret = mt9m111_setup_rect(client, &rect);
         if (!ret)
-                ret = mt9m111_set_pixfmt(icd, pix->pixelformat);
+                ret = mt9m111_set_pixfmt(client, pix->pixelformat);
         if (!ret)
                 mt9m111->rect = rect;
         return ret;
 }
 
-static int mt9m111_try_fmt(struct soc_camera_device *icd,
-                           struct v4l2_format *f)
+static int mt9m111_try_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
 {
         struct v4l2_pix_format *pix = &f->fmt.pix;
 
@@ -544,11 +498,11 @@ static int mt9m111_try_fmt(struct soc_camera_device *icd,
         return 0;
 }
 
-static int mt9m111_get_chip_id(struct soc_camera_device *icd,
-                               struct v4l2_dbg_chip_ident *id)
+static int mt9m111_g_chip_ident(struct v4l2_subdev *sd,
+                                struct v4l2_dbg_chip_ident *id)
 {
-        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
-        struct mt9m111 *mt9m111 = i2c_get_clientdata(client);
+        struct i2c_client *client = sd->priv;
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
 
         if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
                 return -EINVAL;
@@ -563,10 +517,10 @@ static int mt9m111_get_chip_id(struct soc_camera_device *icd,
 }
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
-static int mt9m111_get_register(struct soc_camera_device *icd,
-                                struct v4l2_dbg_register *reg)
+static int mt9m111_g_register(struct v4l2_subdev *sd,
+                              struct v4l2_dbg_register *reg)
 {
-        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
+        struct i2c_client *client = sd->priv;
         int val;
 
         if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0x2ff)
@@ -584,10 +538,10 @@ static int mt9m111_get_register(struct soc_camera_device *icd,
         return 0;
 }
 
-static int mt9m111_set_register(struct soc_camera_device *icd,
-                                struct v4l2_dbg_register *reg)
+static int mt9m111_s_register(struct v4l2_subdev *sd,
+                              struct v4l2_dbg_register *reg)
 {
-        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
+        struct i2c_client *client = sd->priv;
 
         if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0x2ff)
                 return -EINVAL;
@@ -639,41 +593,24 @@ static const struct v4l2_queryctrl mt9m111_controls[] = {
         }
 };
 
-static int mt9m111_get_control(struct soc_camera_device *,
-                               struct v4l2_control *);
-static int mt9m111_set_control(struct soc_camera_device *,
-                               struct v4l2_control *);
 static int mt9m111_resume(struct soc_camera_device *icd);
 static int mt9m111_init(struct soc_camera_device *icd);
 static int mt9m111_release(struct soc_camera_device *icd);
 
 static struct soc_camera_ops mt9m111_ops = {
-        .owner                  = THIS_MODULE,
         .init                   = mt9m111_init,
         .resume                 = mt9m111_resume,
         .release                = mt9m111_release,
-        .start_capture          = mt9m111_start_capture,
-        .stop_capture           = mt9m111_stop_capture,
         .set_crop               = mt9m111_set_crop,
-        .set_fmt                = mt9m111_set_fmt,
-        .try_fmt                = mt9m111_try_fmt,
         .query_bus_param        = mt9m111_query_bus_param,
         .set_bus_param          = mt9m111_set_bus_param,
         .controls               = mt9m111_controls,
         .num_controls           = ARRAY_SIZE(mt9m111_controls),
-        .get_control            = mt9m111_get_control,
-        .set_control            = mt9m111_set_control,
-        .get_chip_id            = mt9m111_get_chip_id,
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-        .get_register           = mt9m111_get_register,
-        .set_register           = mt9m111_set_register,
-#endif
 };
 
-static int mt9m111_set_flip(struct soc_camera_device *icd, int flip, int mask)
+static int mt9m111_set_flip(struct i2c_client *client, int flip, int mask)
 {
-        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
-        struct mt9m111 *mt9m111 = i2c_get_clientdata(client);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int ret;
 
         if (mt9m111->context == HIGHPOWER) {
@@ -691,9 +628,8 @@ static int mt9m111_set_flip(struct soc_camera_device *icd, int flip, int mask)
         return ret;
 }
 
-static int mt9m111_get_global_gain(struct soc_camera_device *icd)
+static int mt9m111_get_global_gain(struct i2c_client *client)
 {
-        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
         int data;
 
         data = reg_read(GLOBAL_GAIN);
@@ -703,9 +639,9 @@ static int mt9m111_get_global_gain(struct soc_camera_device *icd)
         return data;
 }
 
-static int mt9m111_set_global_gain(struct soc_camera_device *icd, int gain)
+static int mt9m111_set_global_gain(struct i2c_client *client, int gain)
 {
-        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
+        struct soc_camera_device *icd = client->dev.platform_data;
         u16 val;
 
         if (gain > 63 * 2 * 2)
@@ -722,10 +658,9 @@ static int mt9m111_set_global_gain(struct soc_camera_device *icd, int gain)
         return reg_write(GLOBAL_GAIN, val);
 }
 
-static int mt9m111_set_autoexposure(struct soc_camera_device *icd, int on)
+static int mt9m111_set_autoexposure(struct i2c_client *client, int on)
 {
-        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
-        struct mt9m111 *mt9m111 = i2c_get_clientdata(client);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int ret;
 
         if (on)
@@ -739,10 +674,9 @@ static int mt9m111_set_autoexposure(struct soc_camera_device *icd, int on)
         return ret;
 }
 
-static int mt9m111_set_autowhitebalance(struct soc_camera_device *icd, int on)
+static int mt9m111_set_autowhitebalance(struct i2c_client *client, int on)
 {
-        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
-        struct mt9m111 *mt9m111 = i2c_get_clientdata(client);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int ret;
 
         if (on)
@@ -756,11 +690,10 @@ static int mt9m111_set_autowhitebalance(struct soc_camera_device *icd, int on)
         return ret;
 }
 
-static int mt9m111_get_control(struct soc_camera_device *icd,
-                               struct v4l2_control *ctrl)
+static int mt9m111_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
 {
-        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
-        struct mt9m111 *mt9m111 = i2c_get_clientdata(client);
+        struct i2c_client *client = sd->priv;
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int data;
 
         switch (ctrl->id) {
@@ -785,7 +718,7 @@ static int mt9m111_get_control(struct soc_camera_device *icd,
                 ctrl->value = !!(data & MT9M111_RMB_MIRROR_COLS);
                 break;
         case V4L2_CID_GAIN:
-                data = mt9m111_get_global_gain(icd);
+                data = mt9m111_get_global_gain(client);
                 if (data < 0)
                         return data;
                 ctrl->value = data;
@@ -800,38 +733,36 @@ static int mt9m111_get_control(struct soc_camera_device *icd,
         return 0;
 }
 
-static int mt9m111_set_control(struct soc_camera_device *icd,
-                               struct v4l2_control *ctrl)
+static int mt9m111_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
 {
-        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
-        struct mt9m111 *mt9m111 = i2c_get_clientdata(client);
+        struct i2c_client *client = sd->priv;
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         const struct v4l2_queryctrl *qctrl;
         int ret;
 
         qctrl = soc_camera_find_qctrl(&mt9m111_ops, ctrl->id);
-
         if (!qctrl)
                 return -EINVAL;
 
         switch (ctrl->id) {
         case V4L2_CID_VFLIP:
                 mt9m111->vflip = ctrl->value;
-                ret = mt9m111_set_flip(icd, ctrl->value,
+                ret = mt9m111_set_flip(client, ctrl->value,
                                         MT9M111_RMB_MIRROR_ROWS);
                 break;
         case V4L2_CID_HFLIP:
                 mt9m111->hflip = ctrl->value;
-                ret = mt9m111_set_flip(icd, ctrl->value,
+                ret = mt9m111_set_flip(client, ctrl->value,
                                         MT9M111_RMB_MIRROR_COLS);
                 break;
         case V4L2_CID_GAIN:
-                ret = mt9m111_set_global_gain(icd, ctrl->value);
+                ret = mt9m111_set_global_gain(client, ctrl->value);
                 break;
         case V4L2_CID_EXPOSURE_AUTO:
-                ret =  mt9m111_set_autoexposure(icd, ctrl->value);
+                ret =  mt9m111_set_autoexposure(client, ctrl->value);
                 break;
         case V4L2_CID_AUTO_WHITE_BALANCE:
-                ret =  mt9m111_set_autowhitebalance(icd, ctrl->value);
+                ret =  mt9m111_set_autowhitebalance(client, ctrl->value);
                 break;
         default:
                 ret = -EINVAL;
@@ -840,34 +771,34 @@ static int mt9m111_set_control(struct soc_camera_device *icd,
         return ret;
 }
 
-static int mt9m111_restore_state(struct soc_camera_device *icd)
+static int mt9m111_restore_state(struct i2c_client *client)
 {
-        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
-        struct mt9m111 *mt9m111 = i2c_get_clientdata(client);
-
-        mt9m111_set_context(icd, mt9m111->context);
-        mt9m111_set_pixfmt(icd, mt9m111->pixfmt);
-        mt9m111_setup_rect(icd, &mt9m111->rect);
-        mt9m111_set_flip(icd, mt9m111->hflip, MT9M111_RMB_MIRROR_COLS);
-        mt9m111_set_flip(icd, mt9m111->vflip, MT9M111_RMB_MIRROR_ROWS);
-        mt9m111_set_global_gain(icd, icd->gain);
-        mt9m111_set_autoexposure(icd, mt9m111->autoexposure);
-        mt9m111_set_autowhitebalance(icd, mt9m111->autowhitebalance);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
+        struct soc_camera_device *icd = client->dev.platform_data;
+
+        mt9m111_set_context(client, mt9m111->context);
+        mt9m111_set_pixfmt(client, mt9m111->pixfmt);
+        mt9m111_setup_rect(client, &mt9m111->rect);
+        mt9m111_set_flip(client, mt9m111->hflip, MT9M111_RMB_MIRROR_COLS);
+        mt9m111_set_flip(client, mt9m111->vflip, MT9M111_RMB_MIRROR_ROWS);
+        mt9m111_set_global_gain(client, icd->gain);
+        mt9m111_set_autoexposure(client, mt9m111->autoexposure);
+        mt9m111_set_autowhitebalance(client, mt9m111->autowhitebalance);
         return 0;
 }
 
 static int mt9m111_resume(struct soc_camera_device *icd)
 {
         struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
-        struct mt9m111 *mt9m111 = i2c_get_clientdata(client);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int ret = 0;
 
         if (mt9m111->powered) {
-                ret = mt9m111_enable(icd);
+                ret = mt9m111_enable(client);
                 if (!ret)
-                        ret = mt9m111_reset(icd);
+                        ret = mt9m111_reset(client);
                 if (!ret)
-                        ret = mt9m111_restore_state(icd);
+                        ret = mt9m111_restore_state(client);
         }
         return ret;
 }
@@ -875,17 +806,17 @@ static int mt9m111_resume(struct soc_camera_device *icd)
 static int mt9m111_init(struct soc_camera_device *icd)
 {
         struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
-        struct mt9m111 *mt9m111 = i2c_get_clientdata(client);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int ret;
 
         mt9m111->context = HIGHPOWER;
-        ret = mt9m111_enable(icd);
+        ret = mt9m111_enable(client);
         if (!ret)
-                ret = mt9m111_reset(icd);
+                ret = mt9m111_reset(client);
         if (!ret)
-                ret = mt9m111_set_context(icd, mt9m111->context);
+                ret = mt9m111_set_context(client, mt9m111->context);
         if (!ret)
-                ret = mt9m111_set_autoexposure(icd, mt9m111->autoexposure);
+                ret = mt9m111_set_autoexposure(client, mt9m111->autoexposure);
         if (ret)
                 dev_err(&icd->dev, "mt9m11x init failed: %d\n", ret);
         return ret;
@@ -893,9 +824,14 @@ static int mt9m111_init(struct soc_camera_device *icd)
 
 static int mt9m111_release(struct soc_camera_device *icd)
 {
+        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int ret;
 
-        ret = mt9m111_disable(icd);
+        ret = reg_clear(RESET, MT9M111_RESET_CHIP_ENABLE);
+        if (!ret)
+                mt9m111->powered = 0;
+
         if (ret < 0)
                 dev_err(&icd->dev, "mt9m11x release failed: %d\n", ret);
 
@@ -909,7 +845,7 @@ static int mt9m111_release(struct soc_camera_device *icd)
 static int mt9m111_video_probe(struct soc_camera_device *icd,
                                struct i2c_client *client)
 {
-        struct mt9m111 *mt9m111 = i2c_get_clientdata(client);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         s32 data;
         int ret;
 
@@ -921,15 +857,10 @@ static int mt9m111_video_probe(struct soc_camera_device *icd,
             to_soc_camera_host(icd->dev.parent)->nr != icd->iface)
                 return -ENODEV;
 
-        /* Switch master clock on */
-        ret = soc_camera_video_start(icd, &client->dev);
-        if (ret)
-                goto evstart;
-
-        ret = mt9m111_enable(icd);
+        ret = mt9m111_enable(client);
         if (ret)
                 goto ei2c;
-        ret = mt9m111_reset(icd);
+        ret = mt9m111_reset(client);
         if (ret)
                 goto ei2c;
 
@@ -961,11 +892,29 @@ static int mt9m111_video_probe(struct soc_camera_device *icd,
         mt9m111->swap_rgb_red_blue = 1;
 
 ei2c:
-        soc_camera_video_stop(icd);
-evstart:
         return ret;
 }
 
+static struct v4l2_subdev_core_ops mt9m111_subdev_core_ops = {
+        .g_ctrl         = mt9m111_g_ctrl,
+        .s_ctrl         = mt9m111_s_ctrl,
+        .g_chip_ident   = mt9m111_g_chip_ident,
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+        .g_register     = mt9m111_g_register,
+        .s_register     = mt9m111_s_register,
+#endif
+};
+
+static struct v4l2_subdev_video_ops mt9m111_subdev_video_ops = {
+        .s_fmt          = mt9m111_s_fmt,
+        .try_fmt        = mt9m111_try_fmt,
+};
+
+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)
 {
@@ -996,7 +945,7 @@ static int mt9m111_probe(struct i2c_client *client,
         if (!mt9m111)
                 return -ENOMEM;
 
-        i2c_set_clientdata(client, mt9m111);
+        v4l2_i2c_subdev_init(&mt9m111->subdev, client, &mt9m111_subdev_ops);
 
         /* Second stage probe - when a capture adapter is there */
         icd->ops        = &mt9m111_ops;
@@ -1022,7 +971,7 @@ static int mt9m111_probe(struct i2c_client *client,
 
 static int mt9m111_remove(struct i2c_client *client)
 {
-        struct mt9m111 *mt9m111 = i2c_get_clientdata(client);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         struct soc_camera_device *icd = client->dev.platform_data;
 
         icd->ops = NULL;