1 files changed, 129 insertions, 180 deletions

diff --git a/drivers/media/video/mt9m111.c b/drivers/media/video/mt9m111.c
index 95c2f089605f..29f976afd465 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;