Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 979ea1dd authored by Guennadi Liakhovetski's avatar Guennadi Liakhovetski Committed by Mauro Carvalho Chehab
Browse files

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: default avatarGuennadi Liakhovetski <g.liakhovetski@gmx.de>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@redhat.com>
parent 0bab829d

drivers/media/video/mt9m001.c

+68 −89
Original line number Diff line number Diff line
@@ -13,13 +13,13 @@ 
#include <linux/i2c.h>

#include <linux/log2.h>



#include <media/v4l2-common.h>

#include <media/v4l2-subdev.h>

#include <media/v4l2-chip-ident.h>

#include <media/soc_camera.h>



/* mt9m001 i2c address 0x5d

 * The platform has to define i2c_board_info

 * and call i2c_register_board_info() */

 * The platform has to define ctruct i2c_board_info objects and link to them

 * from struct soc_camera_link */



/* mt9m001 selected register addresses */

#define MT9M001_CHIP_VERSION		0x00
@@ -69,10 +69,16 @@ static const struct soc_camera_data_format mt9m001_monochrome_formats[] = { 
};



struct mt9m001 {

	struct v4l2_subdev subdev;

	int model;	/* V4L2_IDENT_MT9M001* codes from v4l2-chip-ident.h */

	unsigned char autoexposure;

};



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)

{

	s32 data = i2c_smbus_read_word_data(client, reg);
@@ -110,32 +116,18 @@ static int reg_clear(struct i2c_client *client, const u8 reg, 
static int mt9m001_init(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);

	int ret;



	dev_dbg(&icd->dev, "%s\n", __func__);



	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;

		}

	}



	/* The camera could have been already on, we reset it additionally */

	if (icl->reset)

		ret = icl->reset(&client->dev);

	else

		ret = -ENODEV;



	if (ret < 0) {

		/* Either no platform reset, or platform reset failed */

	/*

	 * We don't know, whether platform provides reset,

	 * issue a soft reset too

	 */

	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);
@@ -146,33 +138,19 @@ static int mt9m001_init(struct soc_camera_device *icd) 
static int mt9m001_release(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);



	/* Disable the chip */

	reg_write(client, MT9M001_OUTPUT_CONTROL, 0);



	if (icl->power)

		icl->power(&client->dev, 0);



	return 0;

}



static int mt9m001_start_capture(struct soc_camera_device *icd)

{

	struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));



	/* Switch to master "normal" mode */

	if (reg_write(client, MT9M001_OUTPUT_CONTROL, 2) < 0)

		return -EIO;

	return 0;

}



static int mt9m001_stop_capture(struct soc_camera_device *icd)

static int mt9m001_s_stream(struct v4l2_subdev *sd, int enable)

{

	struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));

	struct i2c_client *client = sd->priv;



	/* Stop sensor readout */

	if (reg_write(client, MT9M001_OUTPUT_CONTROL, 0) < 0)

	/* Switch to master "normal" mode or stop sensor readout */

	if (reg_write(client, MT9M001_OUTPUT_CONTROL, enable ? 2 : 0) < 0)

		return -EIO;

	return 0;

}
@@ -220,7 +198,7 @@ static int mt9m001_set_crop(struct soc_camera_device *icd, 
			    struct v4l2_rect *rect)

{

	struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));

	struct mt9m001 *mt9m001 = i2c_get_clientdata(client);

	struct mt9m001 *mt9m001 = to_mt9m001(client);

	int ret;

	const u16 hblank = 9, vblank = 25;
@@ -257,9 +235,10 @@ static int mt9m001_set_crop(struct soc_camera_device *icd, 
	return ret;

}



static int mt9m001_set_fmt(struct soc_camera_device *icd,

			   struct v4l2_format *f)

static int mt9m001_s_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)

{

	struct i2c_client *client = sd->priv;

	struct soc_camera_device *icd = client->dev.platform_data;

	struct v4l2_rect rect = {

		.left	= icd->x_current,

		.top	= icd->y_current,
@@ -271,9 +250,10 @@ static int mt9m001_set_fmt(struct soc_camera_device *icd, 
	return mt9m001_set_crop(icd, &rect);

}



static int mt9m001_try_fmt(struct soc_camera_device *icd,

			   struct v4l2_format *f)

static int mt9m001_try_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)

{

	struct i2c_client *client = sd->priv;

	struct soc_camera_device *icd = client->dev.platform_data;

	struct v4l2_pix_format *pix = &f->fmt.pix;



	v4l_bound_align_image(&pix->width, 48, 1280, 1,
@@ -283,11 +263,11 @@ static int mt9m001_try_fmt(struct soc_camera_device *icd, 
	return 0;

}



static int mt9m001_get_chip_id(struct soc_camera_device *icd,

static int mt9m001_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 mt9m001 *mt9m001 = i2c_get_clientdata(client);

	struct i2c_client *client = sd->priv;

	struct mt9m001 *mt9m001 = to_mt9m001(client);



	if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)

		return -EINVAL;
@@ -302,10 +282,10 @@ static int mt9m001_get_chip_id(struct soc_camera_device *icd, 
}



#ifdef CONFIG_VIDEO_ADV_DEBUG

static int mt9m001_get_register(struct soc_camera_device *icd,

static int mt9m001_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;



	if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)

		return -EINVAL;
@@ -322,10 +302,10 @@ static int mt9m001_get_register(struct soc_camera_device *icd, 
	return 0;

}



static int mt9m001_set_register(struct soc_camera_device *icd,

static int mt9m001_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 > 0xff)

		return -EINVAL;
@@ -378,35 +358,20 @@ static const struct v4l2_queryctrl mt9m001_controls[] = { 
	}

};



static int mt9m001_get_control(struct soc_camera_device *, struct v4l2_control *);

static int mt9m001_set_control(struct soc_camera_device *, struct v4l2_control *);



static struct soc_camera_ops mt9m001_ops = {

	.owner			= THIS_MODULE,

	.init			= mt9m001_init,

	.release		= mt9m001_release,

	.start_capture		= mt9m001_start_capture,

	.stop_capture		= mt9m001_stop_capture,

	.set_crop		= mt9m001_set_crop,

	.set_fmt		= mt9m001_set_fmt,

	.try_fmt		= mt9m001_try_fmt,

	.set_bus_param		= mt9m001_set_bus_param,

	.query_bus_param	= mt9m001_query_bus_param,

	.controls		= mt9m001_controls,

	.num_controls		= ARRAY_SIZE(mt9m001_controls),

	.get_control		= mt9m001_get_control,

	.set_control		= mt9m001_set_control,

	.get_chip_id		= mt9m001_get_chip_id,

#ifdef CONFIG_VIDEO_ADV_DEBUG

	.get_register		= mt9m001_get_register,

	.set_register		= mt9m001_set_register,

#endif

};



static int mt9m001_get_control(struct soc_camera_device *icd, struct v4l2_control *ctrl)

static int mt9m001_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)

{

	struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));

	struct mt9m001 *mt9m001 = i2c_get_clientdata(client);

	struct i2c_client *client = sd->priv;

	struct mt9m001 *mt9m001 = to_mt9m001(client);

	int data;



	switch (ctrl->id) {
@@ -423,10 +388,11 @@ static int mt9m001_get_control(struct soc_camera_device *icd, struct v4l2_contro 
	return 0;

}



static int mt9m001_set_control(struct soc_camera_device *icd, struct v4l2_control *ctrl)

static int mt9m001_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)

{

	struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));

	struct mt9m001 *mt9m001 = i2c_get_clientdata(client);

	struct i2c_client *client = sd->priv;

	struct mt9m001 *mt9m001 = to_mt9m001(client);

	struct soc_camera_device *icd = client->dev.platform_data;

	const struct v4l2_queryctrl *qctrl;

	int data;
@@ -521,10 +487,9 @@ static int mt9m001_set_control(struct soc_camera_device *icd, struct v4l2_contro 
static int mt9m001_video_probe(struct soc_camera_device *icd,

			       struct i2c_client *client)

{

	struct mt9m001 *mt9m001 = i2c_get_clientdata(client);

	struct mt9m001 *mt9m001 = to_mt9m001(client);

	struct soc_camera_link *icl = to_soc_camera_link(icd);

	s32 data;

	int ret;

	unsigned long flags;



	/* We must have a parent by now. And it cannot be a wrong one.
@@ -533,11 +498,6 @@ static int mt9m001_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)

		return ret;



	/* Enable the chip */

	data = reg_write(client, MT9M001_CHIP_ENABLE, 1);

	dev_dbg(&icd->dev, "write: %d\n", data);
@@ -545,8 +505,6 @@ static int mt9m001_video_probe(struct soc_camera_device *icd, 
	/* Read out the chip version register */

	data = reg_read(client, MT9M001_CHIP_VERSION);



	soc_camera_video_stop(icd);



	/* must be 0x8411 or 0x8421 for colour sensor and 8431 for bw */

	switch (data) {

	case 0x8411:
@@ -601,6 +559,27 @@ static void mt9m001_video_remove(struct soc_camera_device *icd) 
		icl->free_bus(icl);

}



static struct v4l2_subdev_core_ops mt9m001_subdev_core_ops = {

	.g_ctrl		= mt9m001_g_ctrl,

	.s_ctrl		= mt9m001_s_ctrl,

	.g_chip_ident	= mt9m001_g_chip_ident,

#ifdef CONFIG_VIDEO_ADV_DEBUG

	.g_register	= mt9m001_g_register,

	.s_register	= mt9m001_s_register,

#endif

};



static struct v4l2_subdev_video_ops mt9m001_subdev_video_ops = {

	.s_stream	= mt9m001_s_stream,

	.s_fmt		= mt9m001_s_fmt,

	.try_fmt	= mt9m001_try_fmt,

};



static struct v4l2_subdev_ops mt9m001_subdev_ops = {

	.core	= &mt9m001_subdev_core_ops,

	.video	= &mt9m001_subdev_video_ops,

};



static int mt9m001_probe(struct i2c_client *client,

			 const struct i2c_device_id *did)

{
@@ -631,7 +610,7 @@ static int mt9m001_probe(struct i2c_client *client, 
	if (!mt9m001)

		return -ENOMEM;



	i2c_set_clientdata(client, mt9m001);

	v4l2_i2c_subdev_init(&mt9m001->subdev, client, &mt9m001_subdev_ops);



	/* Second stage probe - when a capture adapter is there */

	icd->ops	= &mt9m001_ops;
@@ -660,7 +639,7 @@ static int mt9m001_probe(struct i2c_client *client, 


static int mt9m001_remove(struct i2c_client *client)

{

	struct mt9m001 *mt9m001 = i2c_get_clientdata(client);

	struct mt9m001 *mt9m001 = to_mt9m001(client);

	struct soc_camera_device *icd = client->dev.platform_data;



	icd->ops = NULL;

drivers/media/video/mt9m111.c

+129 −180

File changed.

Preview size limit exceeded, changes collapsed.

drivers/media/video/mt9t031.c

+87 −86
Original line number Diff line number Diff line
@@ -13,13 +13,13 @@ 
#include <linux/i2c.h>

#include <linux/log2.h>



#include <media/v4l2-common.h>

#include <media/v4l2-subdev.h>

#include <media/v4l2-chip-ident.h>

#include <media/soc_camera.h>



/* mt9t031 i2c address 0x5d

 * The platform has to define i2c_board_info

 * and call i2c_register_board_info() */

 * 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
@@ -68,12 +68,18 @@ static const struct soc_camera_data_format mt9t031_colour_formats[] = { 
};



struct mt9t031 {

	struct v4l2_subdev subdev;

	int model;	/* V4L2_IDENT_MT9T031* codes from v4l2-chip-ident.h */

	unsigned char autoexposure;

	u16 xskip;

	u16 yskip;

};



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)

{

	s32 data = i2c_smbus_read_word_data(client, reg);
@@ -134,21 +140,10 @@ static int get_shutter(struct i2c_client *client, u32 *data) 
	return ret < 0 ? ret : 0;

}



static int mt9t031_init(struct soc_camera_device *icd)

static int mt9t031_idle(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;



	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;

		}

	}



	/* Disable chip output, synchronous option update */

	ret = reg_write(client, MT9T031_RESET, 1);

	if (ret >= 0)
@@ -156,43 +151,46 @@ static int mt9t031_init(struct soc_camera_device *icd) 
	if (ret >= 0)

		ret = reg_clear(client, MT9T031_OUTPUT_CONTROL, 2);



	if (ret < 0 && icl->power)

		icl->power(&client->dev, 0);



	return ret >= 0 ? 0 : -EIO;

}



static int mt9t031_release(struct soc_camera_device *icd)

static int mt9t031_disable(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);



	/* Disable the chip */

	reg_clear(client, MT9T031_OUTPUT_CONTROL, 2);



	if (icl->power)

		icl->power(&client->dev, 0);



	return 0;

}



static int mt9t031_start_capture(struct soc_camera_device *icd)

static int mt9t031_init(struct soc_camera_device *icd)

{

	struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));



	/* Switch to master "normal" mode */

	if (reg_set(client, MT9T031_OUTPUT_CONTROL, 2) < 0)

		return -EIO;

	return 0;

	return mt9t031_idle(client);

}



static int mt9t031_stop_capture(struct soc_camera_device *icd)

static int mt9t031_release(struct soc_camera_device *icd)

{

	struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));



	return mt9t031_disable(client);

}



static int mt9t031_s_stream(struct v4l2_subdev *sd, int enable)

{

	struct i2c_client *client = sd->priv;

	int ret;



	if (enable)

		/* Switch to master "normal" mode */

		ret = reg_set(client, MT9T031_OUTPUT_CONTROL, 2);

	else

		/* Stop sensor readout */

	if (reg_clear(client, MT9T031_OUTPUT_CONTROL, 2) < 0)

		ret = reg_clear(client, MT9T031_OUTPUT_CONTROL, 2);



	if (ret < 0)

		return -EIO;



	return 0;

}
@@ -236,7 +234,7 @@ static int mt9t031_set_params(struct soc_camera_device *icd, 
			      struct v4l2_rect *rect, u16 xskip, u16 yskip)

{

	struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));

	struct mt9t031 *mt9t031 = i2c_get_clientdata(client);

	struct mt9t031 *mt9t031 = to_mt9t031(client);

	int ret;

	u16 xbin, ybin, width, height, left, top;

	const u16 hblank = MT9T031_HORIZONTAL_BLANK,
@@ -334,17 +332,17 @@ static int mt9t031_set_crop(struct soc_camera_device *icd, 
			    struct v4l2_rect *rect)

{

	struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));

	struct mt9t031 *mt9t031 = i2c_get_clientdata(client);

	struct mt9t031 *mt9t031 = to_mt9t031(client);



	/* CROP - no change in scaling, or in limits */

	return mt9t031_set_params(icd, rect, mt9t031->xskip, mt9t031->yskip);

}



static int mt9t031_set_fmt(struct soc_camera_device *icd,

			   struct v4l2_format *f)

static int mt9t031_s_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)

{

	struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));

	struct mt9t031 *mt9t031 = i2c_get_clientdata(client);

	struct i2c_client *client = sd->priv;

	struct mt9t031 *mt9t031 = to_mt9t031(client);

	struct soc_camera_device *icd = client->dev.platform_data;

	int ret;

	u16 xskip, yskip;

	struct v4l2_rect rect = {
@@ -379,8 +377,7 @@ static int mt9t031_set_fmt(struct soc_camera_device *icd, 
	return ret;

}



static int mt9t031_try_fmt(struct soc_camera_device *icd,

			   struct v4l2_format *f)

static int mt9t031_try_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)

{

	struct v4l2_pix_format *pix = &f->fmt.pix;
@@ -391,11 +388,11 @@ static int mt9t031_try_fmt(struct soc_camera_device *icd, 
	return 0;

}



static int mt9t031_get_chip_id(struct soc_camera_device *icd,

static int mt9t031_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 mt9t031 *mt9t031 = i2c_get_clientdata(client);

	struct i2c_client *client = sd->priv;

	struct mt9t031 *mt9t031 = to_mt9t031(client);



	if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)

		return -EINVAL;
@@ -410,10 +407,10 @@ static int mt9t031_get_chip_id(struct soc_camera_device *icd, 
}



#ifdef CONFIG_VIDEO_ADV_DEBUG

static int mt9t031_get_register(struct soc_camera_device *icd,

static int mt9t031_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;



	if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)

		return -EINVAL;
@@ -429,10 +426,10 @@ static int mt9t031_get_register(struct soc_camera_device *icd, 
	return 0;

}



static int mt9t031_set_register(struct soc_camera_device *icd,

static int mt9t031_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 > 0xff)

		return -EINVAL;
@@ -493,35 +490,20 @@ static const struct v4l2_queryctrl mt9t031_controls[] = { 
	}

};



static int mt9t031_get_control(struct soc_camera_device *, struct v4l2_control *);

static int mt9t031_set_control(struct soc_camera_device *, struct v4l2_control *);



static struct soc_camera_ops mt9t031_ops = {

	.owner			= THIS_MODULE,

	.init			= mt9t031_init,

	.release		= mt9t031_release,

	.start_capture		= mt9t031_start_capture,

	.stop_capture		= mt9t031_stop_capture,

	.set_crop		= mt9t031_set_crop,

	.set_fmt		= mt9t031_set_fmt,

	.try_fmt		= mt9t031_try_fmt,

	.set_bus_param		= mt9t031_set_bus_param,

	.query_bus_param	= mt9t031_query_bus_param,

	.controls		= mt9t031_controls,

	.num_controls		= ARRAY_SIZE(mt9t031_controls),

	.get_control		= mt9t031_get_control,

	.set_control		= mt9t031_set_control,

	.get_chip_id		= mt9t031_get_chip_id,

#ifdef CONFIG_VIDEO_ADV_DEBUG

	.get_register		= mt9t031_get_register,

	.set_register		= mt9t031_set_register,

#endif

};



static int mt9t031_get_control(struct soc_camera_device *icd, struct v4l2_control *ctrl)

static int mt9t031_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)

{

	struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));

	struct mt9t031 *mt9t031 = i2c_get_clientdata(client);

	struct i2c_client *client = sd->priv;

	struct mt9t031 *mt9t031 = to_mt9t031(client);

	int data;



	switch (ctrl->id) {
@@ -544,10 +526,11 @@ static int mt9t031_get_control(struct soc_camera_device *icd, struct v4l2_contro 
	return 0;

}



static int mt9t031_set_control(struct soc_camera_device *icd, struct v4l2_control *ctrl)

static int mt9t031_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)

{

	struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));

	struct mt9t031 *mt9t031 = i2c_get_clientdata(client);

	struct i2c_client *client = sd->priv;

	struct mt9t031 *mt9t031 = to_mt9t031(client);

	struct soc_camera_device *icd = client->dev.platform_data;

	const struct v4l2_queryctrl *qctrl;

	int data;
@@ -653,12 +636,11 @@ static int mt9t031_set_control(struct soc_camera_device *icd, struct v4l2_contro 


/* 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 soc_camera_device *icd,

			       struct i2c_client *client)

static int mt9t031_video_probe(struct i2c_client *client)

{

	struct mt9t031 *mt9t031 = i2c_get_clientdata(client);

	struct soc_camera_device *icd = client->dev.platform_data;

	struct mt9t031 *mt9t031 = to_mt9t031(client);

	s32 data;

	int ret;



	/* We must have a parent by now. And it cannot be a wrong one.

	 * So this entire test is completely redundant. */
@@ -666,11 +648,6 @@ static int mt9t031_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)

		return ret;



	/* Enable the chip */

	data = reg_write(client, MT9T031_CHIP_ENABLE, 1);

	dev_dbg(&icd->dev, "write: %d\n", data);
@@ -678,8 +655,6 @@ static int mt9t031_video_probe(struct soc_camera_device *icd, 
	/* Read out the chip version register */

	data = reg_read(client, MT9T031_CHIP_VERSION);



	soc_camera_video_stop(icd);



	switch (data) {

	case 0x1621:

		mt9t031->model = V4L2_IDENT_MT9T031;
@@ -697,6 +672,27 @@ static int mt9t031_video_probe(struct soc_camera_device *icd, 
	return 0;

}



static struct v4l2_subdev_core_ops mt9t031_subdev_core_ops = {

	.g_ctrl		= mt9t031_g_ctrl,

	.s_ctrl		= mt9t031_s_ctrl,

	.g_chip_ident	= mt9t031_g_chip_ident,

#ifdef CONFIG_VIDEO_ADV_DEBUG

	.g_register	= mt9t031_g_register,

	.s_register	= mt9t031_s_register,

#endif

};



static struct v4l2_subdev_video_ops mt9t031_subdev_video_ops = {

	.s_stream	= mt9t031_s_stream,

	.s_fmt		= mt9t031_s_fmt,

	.try_fmt	= mt9t031_try_fmt,

};



static struct v4l2_subdev_ops mt9t031_subdev_ops = {

	.core	= &mt9t031_subdev_core_ops,

	.video	= &mt9t031_subdev_video_ops,

};



static int mt9t031_probe(struct i2c_client *client,

			 const struct i2c_device_id *did)

{
@@ -727,7 +723,7 @@ static int mt9t031_probe(struct i2c_client *client, 
	if (!mt9t031)

		return -ENOMEM;



	i2c_set_clientdata(client, mt9t031);

	v4l2_i2c_subdev_init(&mt9t031->subdev, client, &mt9t031_subdev_ops);



	/* Second stage probe - when a capture adapter is there */

	icd->ops	= &mt9t031_ops;
@@ -747,7 +743,12 @@ static int mt9t031_probe(struct i2c_client *client, 
	mt9t031->xskip = 1;

	mt9t031->yskip = 1;



	ret = mt9t031_video_probe(icd, client);

	mt9t031_idle(client);



	ret = mt9t031_video_probe(client);



	mt9t031_disable(client);



	if (ret) {

		icd->ops = NULL;

		i2c_set_clientdata(client, NULL);
@@ -759,7 +760,7 @@ static int mt9t031_probe(struct i2c_client *client, 


static int mt9t031_remove(struct i2c_client *client)

{

	struct mt9t031 *mt9t031 = i2c_get_clientdata(client);

	struct mt9t031 *mt9t031 = to_mt9t031(client);

	struct soc_camera_device *icd = client->dev.platform_data;



	icd->ops = NULL;

drivers/media/video/mt9v022.c

+68 −99

File changed.

Preview size limit exceeded, changes collapsed.

drivers/media/video/mx1_camera.c

+14 −17
Original line number Diff line number Diff line
@@ -219,7 +219,7 @@ static int mx1_camera_setup_dma(struct mx1_camera_dev *pcdev) 
	int ret;



	if (unlikely(!pcdev->active)) {

		dev_err(pcdev->soc_host.dev, "DMA End IRQ with no active buffer\n");

		dev_err(pcdev->icd->dev.parent, "DMA End IRQ with no active buffer\n");

		return -EFAULT;

	}
@@ -229,7 +229,7 @@ static int mx1_camera_setup_dma(struct mx1_camera_dev *pcdev) 
		vbuf->size, pcdev->res->start +

		CSIRXR, DMA_MODE_READ);

	if (unlikely(ret))

		dev_err(pcdev->soc_host.dev, "Failed to setup DMA sg list\n");

		dev_err(pcdev->icd->dev.parent, "Failed to setup DMA sg list\n");



	return ret;

}
@@ -334,14 +334,14 @@ static void mx1_camera_dma_irq(int channel, void *data) 
	imx_dma_disable(channel);



	if (unlikely(!pcdev->active)) {

		dev_err(pcdev->soc_host.dev, "DMA End IRQ with no active buffer\n");

		dev_err(pcdev->icd->dev.parent, "DMA End IRQ with no active buffer\n");

		goto out;

	}



	vb = &pcdev->active->vb;

	buf = container_of(vb, struct mx1_buffer, vb);

	WARN_ON(buf->inwork || list_empty(&vb->queue));

	dev_dbg(pcdev->soc_host.dev, "%s (vb=0x%p) 0x%08lx %d\n", __func__,

	dev_dbg(pcdev->icd->dev.parent, "%s (vb=0x%p) 0x%08lx %d\n", __func__,

		vb, vb->baddr, vb->bsize);



	mx1_camera_wakeup(pcdev, vb, buf);
@@ -362,7 +362,7 @@ static void mx1_camera_init_videobuf(struct videobuf_queue *q, 
	struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);

	struct mx1_camera_dev *pcdev = ici->priv;



	videobuf_queue_dma_contig_init(q, &mx1_videobuf_ops, ici->dev,

	videobuf_queue_dma_contig_init(q, &mx1_videobuf_ops, icd->dev.parent,

					&pcdev->lock,

					V4L2_BUF_TYPE_VIDEO_CAPTURE,

					V4L2_FIELD_NONE,
@@ -381,7 +381,7 @@ static int mclk_get_divisor(struct mx1_camera_dev *pcdev) 
	 * they get a nice Oops */

	div = (lcdclk + 2 * mclk - 1) / (2 * mclk) - 1;



	dev_dbg(pcdev->soc_host.dev, "System clock %lukHz, target freq %dkHz, "

	dev_dbg(pcdev->icd->dev.parent, "System clock %lukHz, target freq %dkHz, "

		"divisor %lu\n", lcdclk / 1000, mclk / 1000, div);



	return div;
@@ -391,7 +391,7 @@ static void mx1_camera_activate(struct mx1_camera_dev *pcdev) 
{

	unsigned int csicr1 = CSICR1_EN;



	dev_dbg(pcdev->soc_host.dev, "Activate device\n");

	dev_dbg(pcdev->icd->dev.parent, "Activate device\n");



	clk_enable(pcdev->clk);
@@ -407,7 +407,7 @@ static void mx1_camera_activate(struct mx1_camera_dev *pcdev) 


static void mx1_camera_deactivate(struct mx1_camera_dev *pcdev)

{

	dev_dbg(pcdev->soc_host.dev, "Deactivate device\n");

	dev_dbg(pcdev->icd->dev.parent, "Deactivate device\n");



	/* Disable all CSI interface */

	__raw_writel(0x00, pcdev->base + CSICR1);
@@ -432,9 +432,7 @@ static int mx1_camera_add_device(struct soc_camera_device *icd) 
		 icd->devnum);



	mx1_camera_activate(pcdev);

	ret = icd->ops->init(icd);



	if (!ret)

	pcdev->icd = icd;



ebusy:
@@ -459,8 +457,6 @@ static void mx1_camera_remove_device(struct soc_camera_device *icd) 
	dev_info(&icd->dev, "MX1 Camera driver detached from camera %d\n",

		 icd->devnum);



	icd->ops->release(icd);



	mx1_camera_deactivate(pcdev);



	pcdev->icd = NULL;
@@ -546,11 +542,11 @@ static int mx1_camera_set_fmt(struct soc_camera_device *icd, 


	xlate = soc_camera_xlate_by_fourcc(icd, pix->pixelformat);

	if (!xlate) {

		dev_warn(ici->dev, "Format %x not found\n", pix->pixelformat);

		dev_warn(icd->dev.parent, "Format %x not found\n", pix->pixelformat);

		return -EINVAL;

	}



	ret = icd->ops->set_fmt(icd, f);

	ret = v4l2_device_call_until_err(&ici->v4l2_dev, 0, video, s_fmt, f);

	if (!ret) {

		icd->buswidth = xlate->buswidth;

		icd->current_fmt = xlate->host_fmt;
@@ -562,10 +558,11 @@ static int mx1_camera_set_fmt(struct soc_camera_device *icd, 
static int mx1_camera_try_fmt(struct soc_camera_device *icd,

			      struct v4l2_format *f)

{

	struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);

	/* TODO: limit to mx1 hardware capabilities */



	/* limit to sensor capabilities */

	return icd->ops->try_fmt(icd, f);

	return v4l2_device_call_until_err(&ici->v4l2_dev, 0, video, try_fmt, f);

}



static int mx1_camera_reqbufs(struct soc_camera_file *icf,
@@ -737,7 +734,7 @@ static int __init mx1_camera_probe(struct platform_device *pdev) 
	pcdev->soc_host.drv_name	= DRIVER_NAME;

	pcdev->soc_host.ops		= &mx1_soc_camera_host_ops;

	pcdev->soc_host.priv		= pcdev;

	pcdev->soc_host.dev		= &pdev->dev;

	pcdev->soc_host.v4l2_dev.dev	= &pdev->dev;

	pcdev->soc_host.nr		= pdev->id;

	err = soc_camera_host_register(&pcdev->soc_host);

	if (err)