[v2,1/2] MT9P031: Add support for Aptina mt9p031 sensor.

Commit Message

Javier Martin May 20, 2011, 1:47 p.m. UTC

This driver adds basic support for Aptina mt9p031 sensor.

Signed-off-by: Javier Martin <[e-mail]>
---
 drivers/media/video/Kconfig   |    8 +
 drivers/media/video/Makefile  |    1 +
 drivers/media/video/mt9p031.c |  751 +++++++++++++++++++++++++++++++++++++++++
 include/media/mt9p031.h       |   11 +
 4 files changed, 771 insertions(+), 0 deletions(-)
 create mode 100644 drivers/media/video/mt9p031.c
 create mode 100644 include/media/mt9p031.h

Comments

Mauro Carvalho Chehab May 21, 2011, 12:55 p.m. UTC | #1

Hi Laurent,

Despite all those changes at Nokia side, I'm still assuming that you're handling the
omap3 patches. So, I'm just marking those two patches as RFC until I receive a pull
request from you.

Anyway, in this specific case, Koen made some comments, so we should wait for Javier
answer before moving ahead.

Thanks,
Mauro

PS. If you're not keep doing it anymore for omap3, please point me to another
    maintainer that would be taking it. I just need to know whom is responsible 
    to send me patches for each driver(s).

Em 20-05-2011 10:47, Javier Martin escreveu:
> This driver adds basic support for Aptina mt9p031 sensor.
> 
> Signed-off-by: Javier Martin <[e-mail]>
> ---
>  drivers/media/video/Kconfig   |    8 +
>  drivers/media/video/Makefile  |    1 +
>  drivers/media/video/mt9p031.c |  751 +++++++++++++++++++++++++++++++++++++++++
>  include/media/mt9p031.h       |   11 +
>  4 files changed, 771 insertions(+), 0 deletions(-)
>  create mode 100644 drivers/media/video/mt9p031.c
>  create mode 100644 include/media/mt9p031.h
> 
> diff --git a/drivers/media/video/Kconfig b/drivers/media/video/Kconfig
> index 00f51dd..5c96b89 100644
> --- a/drivers/media/video/Kconfig
> +++ b/drivers/media/video/Kconfig
> @@ -329,6 +329,14 @@ config VIDEO_OV7670
>  	  OV7670 VGA camera.  It currently only works with the M88ALP01
>  	  controller.
>  
> +config VIDEO_MT9P031
> +	tristate "Aptina MT9P031 support"
> +	depends on I2C && VIDEO_V4L2
> +	---help---
> +	  This driver supports MT9P031 cameras from Micron
> +	  This is a Video4Linux2 sensor-level driver for the Micron
> +	  mt0p031 5 Mpixel camera.
> +
>  config VIDEO_MT9V011
>  	tristate "Micron mt9v011 sensor support"
>  	depends on I2C && VIDEO_V4L2
> diff --git a/drivers/media/video/Makefile b/drivers/media/video/Makefile
> index ace5d8b..912b29b 100644
> --- a/drivers/media/video/Makefile
> +++ b/drivers/media/video/Makefile
> @@ -65,6 +65,7 @@ obj-$(CONFIG_VIDEO_UPD64083) += upd64083.o
>  obj-$(CONFIG_VIDEO_OV7670) 	+= ov7670.o
>  obj-$(CONFIG_VIDEO_TCM825X) += tcm825x.o
>  obj-$(CONFIG_VIDEO_TVEEPROM) += tveeprom.o
> +obj-$(CONFIG_VIDEO_MT9P031) += mt9p031.o
>  obj-$(CONFIG_VIDEO_MT9V011) += mt9v011.o
>  obj-$(CONFIG_VIDEO_SR030PC30)	+= sr030pc30.o
>  obj-$(CONFIG_VIDEO_NOON010PC30)	+= noon010pc30.o
> diff --git a/drivers/media/video/mt9p031.c b/drivers/media/video/mt9p031.c
> new file mode 100644
> index 0000000..e406b64
> --- /dev/null
> +++ b/drivers/media/video/mt9p031.c
> @@ -0,0 +1,751 @@
> +/*
> + * Driver for MT9P031 CMOS Image Sensor from Aptina
> + *
> + * Copyright (C) 2011, Javier Martin <[e-mail]>
> + *
> + * Copyright (C) 2011, Guennadi Liakhovetski <[e-mail]>
> + *
> + * Based on the MT9V032 driver and Bastian Hecht's code.
> + *
> + * 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/device.h>
> +#include <linux/i2c.h>
> +#include <linux/log2.h>
> +#include <linux/pm.h>
> +#include <linux/regulator/consumer.h>
> +#include <linux/slab.h>
> +#include <media/v4l2-subdev.h>
> +#include <linux/videodev2.h>
> +
> +#include <media/mt9p031.h>
> +#include <media/v4l2-chip-ident.h>
> +#include <media/v4l2-subdev.h>
> +#include <media/v4l2-device.h>
> +
> +/* mt9p031 selected register addresses */
> +#define MT9P031_CHIP_VERSION			0x00
> +#define		MT9P031_CHIP_VERSION_VALUE	0x1801
> +#define MT9P031_ROW_START			0x01
> +#define		MT9P031_ROW_START_SKIP		54
> +#define MT9P031_COLUMN_START			0x02
> +#define		MT9P031_COLUMN_START_SKIP	16
> +#define MT9P031_WINDOW_HEIGHT			0x03
> +#define MT9P031_WINDOW_WIDTH			0x04
> +#define MT9P031_H_BLANKING			0x05
> +#define		MT9P031_H_BLANKING_VALUE	0
> +#define MT9P031_V_BLANKING			0x06
> +#define		MT9P031_V_BLANKING_VALUE	25
> +#define MT9P031_OUTPUT_CONTROL			0x07
> +#define		MT9P031_OUTPUT_CONTROL_CEN	2
> +#define		MT9P031_OUTPUT_CONTROL_SYN	1
> +#define MT9P031_SHUTTER_WIDTH_UPPER		0x08
> +#define MT9P031_SHUTTER_WIDTH			0x09
> +#define MT9P031_PIXEL_CLOCK_CONTROL		0x0a
> +#define MT9P031_FRAME_RESTART			0x0b
> +#define MT9P031_SHUTTER_DELAY			0x0c
> +#define MT9P031_RST				0x0d
> +#define		MT9P031_RST_ENABLE		1
> +#define		MT9P031_RST_DISABLE		0
> +#define MT9P031_READ_MODE_1			0x1e
> +#define MT9P031_READ_MODE_2			0x20
> +#define		MT9P031_READ_MODE_2_ROW_MIR	0x8000
> +#define		MT9P031_READ_MODE_2_COL_MIR	0x4000
> +#define MT9P031_ROW_ADDRESS_MODE		0x22
> +#define MT9P031_COLUMN_ADDRESS_MODE		0x23
> +#define MT9P031_GLOBAL_GAIN			0x35
> +
> +#define MT9P031_MAX_HEIGHT			1944
> +#define MT9P031_MAX_WIDTH			2592
> +#define MT9P031_MIN_HEIGHT			2
> +#define MT9P031_MIN_WIDTH			18
> +
> +struct mt9p031 {
> +	struct v4l2_subdev subdev;
> +	struct media_pad pad;
> +	struct v4l2_rect rect;	/* Sensor window */
> +	struct v4l2_mbus_framefmt format;
> +	struct mt9p031_platform_data *pdata;
> +	struct mutex power_lock;
> +	int power_count;
> +	u16 xskip;
> +	u16 yskip;
> +	u16 output_control;
> +	struct regulator *reg_1v8;
> +	struct regulator *reg_2v8;
> +};
> +
> +static struct mt9p031 *to_mt9p031(const struct i2c_client *client)
> +{
> +	return container_of(i2c_get_clientdata(client), struct mt9p031, subdev);
> +}
> +
> +static int reg_read(struct i2c_client *client, const u8 reg)
> +{
> +	s32 data = i2c_smbus_read_word_data(client, reg);
> +	return data < 0 ? data : swab16(data);
> +}
> +	
> +static int reg_write(struct i2c_client *client, const u8 reg,
> +			const u16 data)
> +{
> +	return i2c_smbus_write_word_data(client, reg, swab16(data));
> +}
> +
> +static int mt9p031_set_output_control(struct mt9p031 *mt9p031, u16 clear,
> +				      u16 set)
> +{
> +	struct i2c_client *client = v4l2_get_subdevdata(&mt9p031->subdev);
> +	u16 value = (mt9p031->output_control & ~clear) | set;
> +	int ret;
> +
> +	ret = reg_write(client, MT9P031_OUTPUT_CONTROL, value);
> +	if (ret < 0)
> +		return ret;
> +
> +	mt9p031->output_control = value;
> +	return 0;
> +}
> +
> +static int mt9p031_reset(struct i2c_client *client)
> +{
> +	struct mt9p031 *mt9p031 = to_mt9p031(client);
> +	int ret;
> +
> +	/* Disable chip output, synchronous option update */
> +	ret = reg_write(client, MT9P031_RST, MT9P031_RST_ENABLE);
> +	if (ret < 0)
> +		return -EIO;
> +	ret = reg_write(client, MT9P031_RST, MT9P031_RST_DISABLE);
> +	if (ret < 0)
> +		return -EIO;
> +	ret = mt9p031_set_output_control(mt9p031, MT9P031_OUTPUT_CONTROL_CEN, 0);
> +	if (ret < 0)
> +		return -EIO;
> +	return 0;
> +}
> +
> +static int mt9p031_power_on(struct mt9p031 *mt9p031)
> +{
> +	int ret;
> +
> +	/* turn on VDD_IO */
> +	ret = regulator_enable(mt9p031->reg_2v8);
> +	if (ret) {
> +		pr_err("Failed to enable 2.8v regulator: %d\n", ret);
> +		return ret;
> +	}
> +	if (mt9p031->pdata->set_xclk)
> +		mt9p031->pdata->set_xclk(&mt9p031->subdev, 54000000);
> +
> +	return 0;
> +}
> +
> +static void mt9p031_power_off(struct mt9p031 *mt9p031)
> +{
> +	if (mt9p031->pdata->set_xclk)
> +		mt9p031->pdata->set_xclk(&mt9p031->subdev, 0);
> +	regulator_disable(mt9p031->reg_2v8);
> +}
> +
> +static int mt9p031_enum_mbus_code(struct v4l2_subdev *sd,
> +				struct v4l2_subdev_fh *fh,
> +				struct v4l2_subdev_mbus_code_enum *code)
> +{
> +	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
> +
> +	if (code->pad || code->index)
> +		return -EINVAL;
> +
> +	code->code = mt9p031->format.code;
> +
> +	return 0;
> +}
> +
> +static struct v4l2_mbus_framefmt *mt9p031_get_pad_format(
> +			struct mt9p031 *mt9p031,
> +			struct v4l2_subdev_fh *fh,
> +			unsigned int pad, u32 which)
> +{
> +	switch (which) {
> +	case V4L2_SUBDEV_FORMAT_TRY:
> +		return v4l2_subdev_get_try_format(fh, pad);
> +	case V4L2_SUBDEV_FORMAT_ACTIVE:
> +		return &mt9p031->format;
> +	default:
> +		return NULL;
> +	}
> +}
> +
> +static struct v4l2_rect *mt9p031_get_pad_crop(struct mt9p031 *mt9p031,
> +			struct v4l2_subdev_fh *fh, unsigned int pad, u32 which)
> +{
> +	switch (which) {
> +	case V4L2_SUBDEV_FORMAT_TRY:
> +		return v4l2_subdev_get_try_crop(fh, pad);
> +	case V4L2_SUBDEV_FORMAT_ACTIVE:
> +		return &mt9p031->rect;
> +	default:
> +		return NULL;
> +	}
> +}
> +
> +static int mt9p031_get_crop(struct v4l2_subdev *sd,
> +				struct v4l2_subdev_fh *fh,
> +				struct v4l2_subdev_crop *crop)
> +{
> +	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
> +	struct v4l2_rect *rect = mt9p031_get_pad_crop(mt9p031, fh, crop->pad,
> +							crop->which);
> +	if (!rect)
> +		return -EINVAL;
> +
> +	crop->rect = *rect;
> +
> +	return 0;
> +}
> +
> +static u16 mt9p031_skip_for_crop(s32 source, s32 *target, s32 max_skip)
> +{
> +	unsigned int skip;
> +
> +	if (source - source / 4 < *target) {
> +		*target = source;
> +		return 1;
> +	}
> +
> +	skip = DIV_ROUND_CLOSEST(source, *target);
> +	if (skip > max_skip)
> +		skip = max_skip;
> +	*target = 2 * DIV_ROUND_UP(source, 2 * skip);
> +
> +	return skip;
> +}
> +
> +static int mt9p031_set_params(struct i2c_client *client,
> +			      struct v4l2_rect *rect, u16 xskip, u16 yskip)
> +{
> +	struct mt9p031 *mt9p031 = to_mt9p031(client);
> +	int ret;
> +	u16 xbin, ybin;
> +	const u16 hblank = MT9P031_H_BLANKING_VALUE,
> +		vblank = MT9P031_V_BLANKING_VALUE;
> +	/*
> +	 * TODO: Attention! When implementing horizontal flipping, adjust
> +	 * alignment according to R2 "Column Start" description in the datasheet
> +	 */
> +	if (xskip & 1) {
> +		xbin = 1;
> +		rect->left &= ~3;
> +	} else if (xskip & 2) {
> +		xbin = 2;
> +		rect->left &= ~7;
> +	} else {
> +		xbin = 4;
> +		rect->left &= ~15;
> +	}
> +
> +	ybin = min(yskip, (u16)4);
> +
> +	rect->top &= ~1;
> +
> +	/* Disable register update, reconfigure atomically */
> +	ret = mt9p031_set_output_control(mt9p031, 0, MT9P031_OUTPUT_CONTROL_SYN);
> +	if (ret < 0)
> +		return ret;
> +
> +	dev_dbg(&client->dev, "skip %u:%u, rect %ux%u@%u:%u\n",
> +		xskip, yskip, rect->width, rect->height, rect->left, rect->top);
> +
> +	/* Blanking and start values - default... */
> +	ret = reg_write(client, MT9P031_H_BLANKING, hblank);
> +	if (ret < 0)
> +		return ret;
> +	ret = reg_write(client, MT9P031_V_BLANKING, vblank);
> +	if (ret < 0)
> +		return ret;
> +
> +	ret = reg_write(client, MT9P031_COLUMN_ADDRESS_MODE,
> +				((xbin - 1) << 4) | (xskip - 1));
> +	if (ret < 0)
> +		return ret;
> +	ret = reg_write(client, MT9P031_ROW_ADDRESS_MODE,
> +				((ybin - 1) << 4) | (yskip - 1));
> +	if (ret < 0)
> +		return ret;
> +
> +	dev_dbg(&client->dev, "new physical left %u, top %u\n",
> +		rect->left, rect->top);
> +
> +	ret = reg_write(client, MT9P031_COLUMN_START,
> +				rect->left + MT9P031_COLUMN_START_SKIP);
> +	if (ret < 0)
> +		return ret;
> +	ret = reg_write(client, MT9P031_ROW_START,
> +				rect->top + MT9P031_ROW_START_SKIP);
> +	if (ret < 0)
> +		return ret;
> +	ret = reg_write(client, MT9P031_WINDOW_WIDTH,
> +				rect->width - 1);
> +	if (ret < 0)
> +		return ret;
> +	ret = reg_write(client, MT9P031_WINDOW_HEIGHT,
> +				rect->height - 1);
> +	if (ret < 0)
> +		return ret;
> +
> +	/* Re-enable register update, commit all changes */
> +	ret = mt9p031_set_output_control(mt9p031, MT9P031_OUTPUT_CONTROL_SYN, 0);
> +	if (ret < 0)
> +		return ret;
> +
> +	mt9p031->xskip = xskip;
> +	mt9p031->yskip = yskip;
> +	return ret;
> +}
> +
> +static int mt9p031_set_crop(struct v4l2_subdev *sd,
> +				struct v4l2_subdev_fh *fh,
> +				struct v4l2_subdev_crop *crop)
> +{
> +	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
> +	struct v4l2_mbus_framefmt *f;
> +	struct v4l2_rect *c;
> +	struct v4l2_rect rect;
> +	u16 xskip, yskip;
> +	s32 width, height;
> +
> +	pr_info("%s(%ux%u@%u:%u : %u)\n", __func__,
> +			crop->rect.width, crop->rect.height,
> +			crop->rect.left, crop->rect.top, crop->which);
> +
> +	/*
> +	 * Clamp the crop rectangle boundaries and align them to a multiple of 2
> +	 * pixels.
> +	 */
> +	rect.width = ALIGN(clamp(crop->rect.width,
> +				 MT9P031_MIN_WIDTH, MT9P031_MAX_WIDTH), 2);
> +	rect.height = ALIGN(clamp(crop->rect.height,
> +				  MT9P031_MIN_HEIGHT, MT9P031_MAX_HEIGHT), 2);
> +	rect.left = ALIGN(clamp(crop->rect.left,
> +				0, MT9P031_MAX_WIDTH - rect.width), 2);
> +	rect.top = ALIGN(clamp(crop->rect.top,
> +			       0, MT9P031_MAX_HEIGHT - rect.height), 2);
> +
> +	c = mt9p031_get_pad_crop(mt9p031, fh, crop->pad, crop->which);
> +
> +	if (rect.width != c->width || rect.height != c->height) {
> +		/*
> +		 * Reset the output image size if the crop rectangle size has
> +		 * been modified.
> +		 */
> +		f = mt9p031_get_pad_format(mt9p031, fh, crop->pad,
> +						    crop->which);
> +		width = f->width;
> +		height = f->height;
> +
> +		xskip = mt9p031_skip_for_crop(rect.width, &width, 7);
> +		yskip = mt9p031_skip_for_crop(rect.height, &height, 8);
> +	} else {
> +		xskip = mt9p031->xskip;
> +		yskip = mt9p031->yskip;
> +		f = NULL;
> +	}
> +	if (f) {
> +		f->width = width;
> +		f->height = height;
> +	}
> +
> +	*c = rect;
> +	crop->rect = rect;
> +
> +	mt9p031->xskip = xskip;
> +	mt9p031->yskip = yskip;
> +	mt9p031->rect = *c;
> +	return 0;
> +}
> +
> +static int mt9p031_get_format(struct v4l2_subdev *sd,
> +				struct v4l2_subdev_fh *fh,
> +				struct v4l2_subdev_format *fmt)
> +{
> +	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
> +
> +	fmt->format =
> +		*mt9p031_get_pad_format(mt9p031, fh, fmt->pad, fmt->which);
> +	return 0;
> +}
> +
> +static u16 mt9p031_skip_for_scale(s32 *source, s32 target,
> +					s32 max_skip, s32 max)
> +{
> +	unsigned int skip;
> +
> +	if (*source - *source / 4 < target) {
> +		*source = target;
> +		return 1;
> +	}
> +
> +	skip = min(max, *source + target / 2) / target;
> +	if (skip > max_skip)
> +		skip = max_skip;
> +	*source = target * skip;
> +
> +	return skip;
> +}
> +
> +static int mt9p031_fmt_validate(struct v4l2_subdev *sd,
> +				struct v4l2_subdev_format *fmt)
> +{
> +	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
> +	struct v4l2_mbus_framefmt *format = &fmt->format;
> +
> +	if (format->code != mt9p031->format.code || fmt->pad)
> +		return -EINVAL;
> +
> +	format->colorspace = V4L2_COLORSPACE_SRGB;
> +	format->width = clamp_t(int, ALIGN(format->width, 2), 2,
> +						MT9P031_MAX_WIDTH);
> +	format->height = clamp_t(int, ALIGN(format->height, 2), 2,
> +						MT9P031_MAX_HEIGHT);
> +	format->field = V4L2_FIELD_NONE;
> +
> +	return 0;
> +}
> +
> +static int mt9p031_set_format(struct v4l2_subdev *sd,
> +				struct v4l2_subdev_fh *fh,
> +				struct v4l2_subdev_format *fmt)
> +{
> +	struct v4l2_subdev_format sdf = *fmt;
> +	struct v4l2_mbus_framefmt *f, *format = &sdf.format;
> +	struct v4l2_rect *c, rect;
> +	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
> +	u16 xskip, yskip;
> +	int ret;
> +
> +	ret = mt9p031_fmt_validate(sd, &sdf);
> +	if (ret < 0)
> +		return ret;
> +
> +	f = mt9p031_get_pad_format(mt9p031, fh, fmt->pad, fmt->which);
> +
> +	if (f->width == format->width && f->height == format->height)
> +		return 0;
> +
> +
> +	c = mt9p031_get_pad_crop(mt9p031, fh, fmt->pad, fmt->which);
> +
> +	rect.width = c->width;
> +	rect.height = c->height;
> +
> +	xskip = mt9p031_skip_for_scale(&rect.width, format->width, 7,
> +				       MT9P031_MAX_WIDTH);
> +	if (rect.width + c->left > MT9P031_MAX_WIDTH)
> +		rect.left = (MT9P031_MAX_WIDTH - rect.width) / 2;
> +	else
> +		rect.left = c->left;
> +	yskip = mt9p031_skip_for_scale(&rect.height, format->height, 8,
> +				       MT9P031_MAX_HEIGHT);
> +	if (rect.height + c->top > MT9P031_MAX_HEIGHT)
> +		rect.top = (MT9P031_MAX_HEIGHT - rect.height) / 2;
> +	else
> +		rect.top = c->top;
> +
> +
> +	pr_info("%s(%ux%u : %u)\n", __func__,
> +		format->width, format->height, fmt->which);
> +	if (c)
> +		*c = rect;
> +
> +	*f = *format;
> +	fmt->format = *format;
> +
> +	mt9p031->xskip = xskip;
> +	mt9p031->yskip = yskip;
> +	mt9p031->rect = *c;
> +	return 0;
> +}
> +
> +static int mt9p031_s_stream(struct v4l2_subdev *sd, int enable)
> +{
> +	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
> +	struct i2c_client *client = v4l2_get_subdevdata(&mt9p031->subdev);
> +	struct v4l2_rect rect = mt9p031->rect;
> +	u16 xskip = mt9p031->xskip;
> +	u16 yskip = mt9p031->yskip;
> +	int ret;
> +
> +	if (enable) {
> +		ret = mt9p031_set_params(client, &rect, xskip, yskip);
> +		if (ret < 0)
> +			return ret;
> +		/* Switch to master "normal" mode */
> +		ret = mt9p031_set_output_control(mt9p031, 0, MT9P031_OUTPUT_CONTROL_CEN);
> +	} else {
> +		/* Stop sensor readout */
> +		ret = mt9p031_set_output_control(mt9p031, MT9P031_OUTPUT_CONTROL_CEN, 0);
> +	}
> +	if (ret < 0)
> +		return -EIO;
> +
> +	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 mt9p031_video_probe(struct i2c_client *client)
> +{
> +	s32 data;
> +	int ret;
> +
> +	/* Read out the chip version register */
> +	data = reg_read(client, MT9P031_CHIP_VERSION);
> +	if (data != MT9P031_CHIP_VERSION_VALUE) {
> +		dev_err(&client->dev,
> +			"No MT9P031 chip detected, register read %x\n", data);
> +		return -ENODEV;
> +	}
> +
> +	dev_info(&client->dev, "Detected a MT9P031 chip ID %x\n", data);
> +
> +	ret = mt9p031_reset(client);
> +	if (ret < 0)
> +		dev_err(&client->dev, "Failed to initialise the camera\n");
> +
> +	return ret;
> +}
> +
> +static int mt9p031_set_power(struct v4l2_subdev *sd, int on)
> +{
> +	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
> +	int ret = 0;
> +
> +	mutex_lock(&mt9p031->power_lock);
> +
> +	/* If the power count is modified from 0 to != 0 or from != 0 to 0,
> +	 * update the power state.
> +	 */
> +	if (mt9p031->power_count == !on) {
> +		if (on) {
> +			ret = mt9p031_power_on(mt9p031);
> +			if (ret) {
> +				pr_err("Failed to enable 2.8v regulator: %d\n", ret);
> +				goto out;
> +			}
> +		} else {
> +			mt9p031_power_off(mt9p031);
> +		}
> +	}
> +
> +	/* Update the power count. */
> +	mt9p031->power_count +=on ? 1: -1;
> +	WARN_ON(mt9p031->power_count < 0);
> +
> +out:
> +	mutex_unlock(&mt9p031->power_lock);
> +	return ret;
> +}
> +
> +static int mt9p031_registered(struct v4l2_subdev *sd)
> +{
> +	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
> +	struct i2c_client *client = v4l2_get_subdevdata(&mt9p031->subdev);
> +	int ret;
> +
> +	ret = mt9p031_set_power(&mt9p031->subdev, 1);
> +	if (ret) {
> +		pr_err("Failed to power on device: %d\n", ret);
> +		goto pwron;
> +	}
> +	if (mt9p031->pdata->reset)
> +		mt9p031->pdata->reset(&mt9p031->subdev, 1);
> +	msleep(50);
> +	if (mt9p031->pdata->reset)
> +		mt9p031->pdata->reset(&mt9p031->subdev, 0);
> +	msleep(50);
> +
> +	ret = mt9p031_video_probe(client);
> +	if (ret)
> +		goto evprobe;
> +
> +	mt9p031->pad.flags = MEDIA_PAD_FL_SOURCE;
> +	ret = media_entity_init(&mt9p031->subdev.entity, 1, &mt9p031->pad, 0);
> +	if (ret)
> +		goto evprobe;
> +
> +	mt9p031->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
> +	mt9p031_set_power(&mt9p031->subdev, 0);
> +
> +	return 0;
> +evprobe:
> +	mt9p031_set_power(&mt9p031->subdev, 0);
> +pwron:
> +	return ret;
> +}
> +
> +static int mt9p031_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
> +{
> +	struct mt9p031 *mt9p031;
> +	mt9p031 = container_of(sd, struct mt9p031, subdev);
> +
> +	return mt9p031_set_power(sd, 1);
> +}
> +
> +static int mt9p031_close(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
> +{
> +	struct mt9p031 *mt9p031;
> +
> +	mt9p031 = container_of(sd, struct mt9p031, subdev);
> +
> +	mt9p031_set_power(sd, 0);
> +	return 0;
> +}
> +
> +static struct v4l2_subdev_core_ops mt9p031_subdev_core_ops = {
> +	.s_power	= mt9p031_set_power,
> +};
> +
> +static struct v4l2_subdev_video_ops mt9p031_subdev_video_ops = {
> +	.s_stream	= mt9p031_s_stream,
> +};
> +
> +static struct v4l2_subdev_pad_ops mt9p031_subdev_pad_ops = {
> +	.enum_mbus_code = mt9p031_enum_mbus_code,
> +	.get_fmt = mt9p031_get_format,
> +	.set_fmt = mt9p031_set_format,
> +	.get_crop = mt9p031_get_crop,
> +	.set_crop = mt9p031_set_crop,
> +};
> +
> +static struct v4l2_subdev_ops mt9p031_subdev_ops = {
> +	.core	= &mt9p031_subdev_core_ops,
> +	.video	= &mt9p031_subdev_video_ops,
> +	.pad	= &mt9p031_subdev_pad_ops,
> +};
> +
> +static const struct v4l2_subdev_internal_ops mt9p031_subdev_internal_ops = {
> +	.registered = mt9p031_registered,
> +	.open = mt9p031_open,
> +	.close = mt9p031_close,
> +};
> +
> +static int mt9p031_probe(struct i2c_client *client,
> +			 const struct i2c_device_id *did)
> +{
> +	struct mt9p031 *mt9p031;
> +	struct mt9p031_platform_data *pdata = client->dev.platform_data;
> +	struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
> +	int ret;
> +
> +	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;
> +	}
> +
> +	mt9p031 = kzalloc(sizeof(struct mt9p031), GFP_KERNEL);
> +	if (!mt9p031)
> +		return -ENOMEM;
> +
> +	mutex_init(&mt9p031->power_lock);
> +	v4l2_i2c_subdev_init(&mt9p031->subdev, client, &mt9p031_subdev_ops);
> +	mt9p031->subdev.internal_ops = &mt9p031_subdev_internal_ops;
> +
> +	mt9p031->pdata		= pdata;
> +	mt9p031->rect.left	= 0;
> +	mt9p031->rect.top	= 0;
> +	mt9p031->rect.width	= MT9P031_MAX_WIDTH;
> +	mt9p031->rect.height	= MT9P031_MAX_HEIGHT;
> +
> +	mt9p031->format.code = V4L2_MBUS_FMT_SGRBG12_1X12;
> +
> +	mt9p031->format.width = MT9P031_MAX_WIDTH;
> +	mt9p031->format.height = MT9P031_MAX_HEIGHT;
> +	mt9p031->format.field = V4L2_FIELD_NONE;
> +	mt9p031->format.colorspace = V4L2_COLORSPACE_SRGB;
> +
> +	mt9p031->xskip = 1;
> +	mt9p031->yskip = 1;
> +
> +	mt9p031->reg_1v8 = regulator_get(NULL, "cam_1v8");
> +	if (IS_ERR(mt9p031->reg_1v8)) {
> +		ret = PTR_ERR(mt9p031->reg_1v8);
> +		pr_err("Failed 1.8v regulator: %d\n", ret);
> +		goto e1v8;
> +	}
> +
> +	mt9p031->reg_2v8 = regulator_get(NULL, "cam_2v8");
> +	if (IS_ERR(mt9p031->reg_2v8)) {
> +		ret = PTR_ERR(mt9p031->reg_2v8);
> +		pr_err("Failed 2.8v regulator: %d\n", ret);
> +		goto e2v8;
> +	}
> +	/* turn on core */
> +	ret = regulator_enable(mt9p031->reg_1v8);
> +	if (ret) {
> +		pr_err("Failed to enable 1.8v regulator: %d\n", ret);
> +		goto e1v8en;
> +	}
> +	return 0;
> +e1v8en:
> +	regulator_put(mt9p031->reg_2v8);
> +e2v8:
> +	regulator_put(mt9p031->reg_1v8);
> +e1v8:
> +	kfree(mt9p031);
> +	return ret;
> +}
> +
> +static int mt9p031_remove(struct i2c_client *client)
> +{
> +	struct v4l2_subdev *sd = i2c_get_clientdata(client);
> +	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
> +
> +	v4l2_device_unregister_subdev(sd);
> +	media_entity_cleanup(&sd->entity);
> +	regulator_disable(mt9p031->reg_1v8);
> +	regulator_put(mt9p031->reg_2v8);
> +	regulator_put(mt9p031->reg_1v8);
> +	kfree(mt9p031);
> +
> +	return 0;
> +}
> +
> +static const struct i2c_device_id mt9p031_id[] = {
> +	{ "mt9p031", 0 },
> +	{ }
> +};
> +MODULE_DEVICE_TABLE(i2c, mt9p031_id);
> +
> +static struct i2c_driver mt9p031_i2c_driver = {
> +	.driver = {
> +		.name = "mt9p031",
> +	},
> +	.probe		= mt9p031_probe,
> +	.remove		= mt9p031_remove,
> +	.id_table	= mt9p031_id,
> +};
> +
> +static int __init mt9p031_mod_init(void)
> +{
> +	return i2c_add_driver(&mt9p031_i2c_driver);
> +}
> +
> +static void __exit mt9p031_mod_exit(void)
> +{
> +	i2c_del_driver(&mt9p031_i2c_driver);
> +}
> +
> +module_init(mt9p031_mod_init);
> +module_exit(mt9p031_mod_exit);
> +
> +MODULE_DESCRIPTION("Aptina MT9P031 Camera driver");
> +MODULE_AUTHOR("Bastian Hecht <[e-mail]>");
> +MODULE_LICENSE("GPL v2");
> diff --git a/include/media/mt9p031.h b/include/media/mt9p031.h
> new file mode 100644
> index 0000000..ad37eb3
> --- /dev/null
> +++ b/include/media/mt9p031.h
> @@ -0,0 +1,11 @@
> +#ifndef MT9P031_H
> +#define MT9P031_H
> +
> +struct v4l2_subdev;
> +
> +struct mt9p031_platform_data {
> +	int (*set_xclk)(struct v4l2_subdev *subdev, int hz);
> +	int (*reset)(struct v4l2_subdev *subdev, int active);
> +};
> +
> +#endif

--
To unsubscribe from this list: send the line "unsubscribe linux-media" in
the body of a message to [e-mail]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Guennadi Liakhovetski May 21, 2011, 3:29 p.m. UTC | #2

On Fri, 20 May 2011, Javier Martin wrote:

> This driver adds basic support for Aptina mt9p031 sensor.
> 
> Signed-off-by: Javier Martin <[e-mail]>
> ---
>  drivers/media/video/Kconfig   |    8 +
>  drivers/media/video/Makefile  |    1 +
>  drivers/media/video/mt9p031.c |  751 +++++++++++++++++++++++++++++++++++++++++
>  include/media/mt9p031.h       |   11 +
>  4 files changed, 771 insertions(+), 0 deletions(-)
>  create mode 100644 drivers/media/video/mt9p031.c
>  create mode 100644 include/media/mt9p031.h
> 
> diff --git a/drivers/media/video/Kconfig b/drivers/media/video/Kconfig
> index 00f51dd..5c96b89 100644
> --- a/drivers/media/video/Kconfig
> +++ b/drivers/media/video/Kconfig
> @@ -329,6 +329,14 @@ config VIDEO_OV7670
>  	  OV7670 VGA camera.  It currently only works with the M88ALP01
>  	  controller.
>  
> +config VIDEO_MT9P031
> +	tristate "Aptina MT9P031 support"
> +	depends on I2C && VIDEO_V4L2
> +	---help---
> +	  This driver supports MT9P031 cameras from Micron
> +	  This is a Video4Linux2 sensor-level driver for the Micron
> +	  mt0p031 5 Mpixel camera.

Two sentences seem to repeat the same with other words, and it's better to 
stay consistent: just use Aptina everywhere, maybe put Micron in brackets 
at one location.

> +
>  config VIDEO_MT9V011
>  	tristate "Micron mt9v011 sensor support"
>  	depends on I2C && VIDEO_V4L2
> diff --git a/drivers/media/video/Makefile b/drivers/media/video/Makefile
> index ace5d8b..912b29b 100644
> --- a/drivers/media/video/Makefile
> +++ b/drivers/media/video/Makefile
> @@ -65,6 +65,7 @@ obj-$(CONFIG_VIDEO_UPD64083) += upd64083.o
>  obj-$(CONFIG_VIDEO_OV7670) 	+= ov7670.o
>  obj-$(CONFIG_VIDEO_TCM825X) += tcm825x.o
>  obj-$(CONFIG_VIDEO_TVEEPROM) += tveeprom.o
> +obj-$(CONFIG_VIDEO_MT9P031) += mt9p031.o
>  obj-$(CONFIG_VIDEO_MT9V011) += mt9v011.o
>  obj-$(CONFIG_VIDEO_SR030PC30)	+= sr030pc30.o
>  obj-$(CONFIG_VIDEO_NOON010PC30)	+= noon010pc30.o
> diff --git a/drivers/media/video/mt9p031.c b/drivers/media/video/mt9p031.c
> new file mode 100644
> index 0000000..e406b64
> --- /dev/null
> +++ b/drivers/media/video/mt9p031.c
> @@ -0,0 +1,751 @@
> +/*
> + * Driver for MT9P031 CMOS Image Sensor from Aptina
> + *
> + * Copyright (C) 2011, Javier Martin <[e-mail]>
> + *
> + * Copyright (C) 2011, Guennadi Liakhovetski <[e-mail]>
> + *
> + * Based on the MT9V032 driver and Bastian Hecht's code.
> + *
> + * 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/device.h>
> +#include <linux/i2c.h>
> +#include <linux/log2.h>
> +#include <linux/pm.h>
> +#include <linux/regulator/consumer.h>
> +#include <linux/slab.h>
> +#include <media/v4l2-subdev.h>
> +#include <linux/videodev2.h>
> +
> +#include <media/mt9p031.h>
> +#include <media/v4l2-chip-ident.h>
> +#include <media/v4l2-subdev.h>
> +#include <media/v4l2-device.h>
> +
> +/* mt9p031 selected register addresses */
> +#define MT9P031_CHIP_VERSION			0x00
> +#define		MT9P031_CHIP_VERSION_VALUE	0x1801
> +#define MT9P031_ROW_START			0x01

Don't mix spaces and TABs between "#define" and the macro - just use one 
space everywhere.

> +#define		MT9P031_ROW_START_SKIP		54
> +#define MT9P031_COLUMN_START			0x02
> +#define		MT9P031_COLUMN_START_SKIP	16
> +#define MT9P031_WINDOW_HEIGHT			0x03
> +#define MT9P031_WINDOW_WIDTH			0x04
> +#define MT9P031_H_BLANKING			0x05
> +#define		MT9P031_H_BLANKING_VALUE	0
> +#define MT9P031_V_BLANKING			0x06
> +#define		MT9P031_V_BLANKING_VALUE	25
> +#define MT9P031_OUTPUT_CONTROL			0x07
> +#define		MT9P031_OUTPUT_CONTROL_CEN	2
> +#define		MT9P031_OUTPUT_CONTROL_SYN	1
> +#define MT9P031_SHUTTER_WIDTH_UPPER		0x08
> +#define MT9P031_SHUTTER_WIDTH			0x09
> +#define MT9P031_PIXEL_CLOCK_CONTROL		0x0a
> +#define MT9P031_FRAME_RESTART			0x0b
> +#define MT9P031_SHUTTER_DELAY			0x0c
> +#define MT9P031_RST				0x0d
> +#define		MT9P031_RST_ENABLE		1
> +#define		MT9P031_RST_DISABLE		0
> +#define MT9P031_READ_MODE_1			0x1e
> +#define MT9P031_READ_MODE_2			0x20
> +#define		MT9P031_READ_MODE_2_ROW_MIR	0x8000
> +#define		MT9P031_READ_MODE_2_COL_MIR	0x4000
> +#define MT9P031_ROW_ADDRESS_MODE		0x22
> +#define MT9P031_COLUMN_ADDRESS_MODE		0x23
> +#define MT9P031_GLOBAL_GAIN			0x35
> +
> +#define MT9P031_MAX_HEIGHT			1944
> +#define MT9P031_MAX_WIDTH			2592
> +#define MT9P031_MIN_HEIGHT			2
> +#define MT9P031_MIN_WIDTH			18
> +
> +struct mt9p031 {
> +	struct v4l2_subdev subdev;
> +	struct media_pad pad;
> +	struct v4l2_rect rect;	/* Sensor window */
> +	struct v4l2_mbus_framefmt format;
> +	struct mt9p031_platform_data *pdata;
> +	struct mutex power_lock;

Don't locks _always_ have to be documented? And this one: you only protect 
set_power() with it, Laurent, is this correct?

> +	int power_count;
> +	u16 xskip;
> +	u16 yskip;
> +	u16 output_control;
> +	struct regulator *reg_1v8;
> +	struct regulator *reg_2v8;
> +};
> +
> +static struct mt9p031 *to_mt9p031(const struct i2c_client *client)
> +{
> +	return container_of(i2c_get_clientdata(client), struct mt9p031, subdev);
> +}
> +
> +static int reg_read(struct i2c_client *client, const u8 reg)
> +{
> +	s32 data = i2c_smbus_read_word_data(client, reg);
> +	return data < 0 ? data : swab16(data);
> +}
> +	
> +static int reg_write(struct i2c_client *client, const u8 reg,
> +			const u16 data)
> +{
> +	return i2c_smbus_write_word_data(client, reg, swab16(data));
> +}
> +
> +static int mt9p031_set_output_control(struct mt9p031 *mt9p031, u16 clear,
> +				      u16 set)
> +{
> +	struct i2c_client *client = v4l2_get_subdevdata(&mt9p031->subdev);
> +	u16 value = (mt9p031->output_control & ~clear) | set;
> +	int ret;
> +
> +	ret = reg_write(client, MT9P031_OUTPUT_CONTROL, value);
> +	if (ret < 0)
> +		return ret;
> +
> +	mt9p031->output_control = value;
> +	return 0;
> +}
> +
> +static int mt9p031_reset(struct i2c_client *client)
> +{
> +	struct mt9p031 *mt9p031 = to_mt9p031(client);
> +	int ret;
> +
> +	/* Disable chip output, synchronous option update */
> +	ret = reg_write(client, MT9P031_RST, MT9P031_RST_ENABLE);
> +	if (ret < 0)
> +		return -EIO;
> +	ret = reg_write(client, MT9P031_RST, MT9P031_RST_DISABLE);
> +	if (ret < 0)
> +		return -EIO;
> +	ret = mt9p031_set_output_control(mt9p031, MT9P031_OUTPUT_CONTROL_CEN, 0);
> +	if (ret < 0)
> +		return -EIO;
> +	return 0;


I think, a sequence like

	ret = fn();
	if (!ret)
		ret = fn();
	if (!ret)
		ret = fn();
	return ret;

is a better way to achieve the same.

> +}
> +
> +static int mt9p031_power_on(struct mt9p031 *mt9p031)
> +{
> +	int ret;
> +
> +	/* turn on VDD_IO */
> +	ret = regulator_enable(mt9p031->reg_2v8);
> +	if (ret) {
> +		pr_err("Failed to enable 2.8v regulator: %d\n", ret);

dev_err()

> +		return ret;
> +	}
> +	if (mt9p031->pdata->set_xclk)
> +		mt9p031->pdata->set_xclk(&mt9p031->subdev, 54000000);
> +
> +	return 0;
> +}
> +
> +static void mt9p031_power_off(struct mt9p031 *mt9p031)
> +{
> +	if (mt9p031->pdata->set_xclk)
> +		mt9p031->pdata->set_xclk(&mt9p031->subdev, 0);
> +	regulator_disable(mt9p031->reg_2v8);
> +}
> +
> +static int mt9p031_enum_mbus_code(struct v4l2_subdev *sd,
> +				struct v4l2_subdev_fh *fh,
> +				struct v4l2_subdev_mbus_code_enum *code)
> +{
> +	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
> +
> +	if (code->pad || code->index)
> +		return -EINVAL;
> +
> +	code->code = mt9p031->format.code;
> +
> +	return 0;
> +}
> +
> +static struct v4l2_mbus_framefmt *mt9p031_get_pad_format(
> +			struct mt9p031 *mt9p031,
> +			struct v4l2_subdev_fh *fh,
> +			unsigned int pad, u32 which)
> +{
> +	switch (which) {
> +	case V4L2_SUBDEV_FORMAT_TRY:
> +		return v4l2_subdev_get_try_format(fh, pad);
> +	case V4L2_SUBDEV_FORMAT_ACTIVE:
> +		return &mt9p031->format;
> +	default:
> +		return NULL;
> +	}
> +}
> +
> +static struct v4l2_rect *mt9p031_get_pad_crop(struct mt9p031 *mt9p031,
> +			struct v4l2_subdev_fh *fh, unsigned int pad, u32 which)
> +{
> +	switch (which) {
> +	case V4L2_SUBDEV_FORMAT_TRY:
> +		return v4l2_subdev_get_try_crop(fh, pad);
> +	case V4L2_SUBDEV_FORMAT_ACTIVE:
> +		return &mt9p031->rect;
> +	default:
> +		return NULL;
> +	}
> +}
> +
> +static int mt9p031_get_crop(struct v4l2_subdev *sd,
> +				struct v4l2_subdev_fh *fh,
> +				struct v4l2_subdev_crop *crop)
> +{
> +	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
> +	struct v4l2_rect *rect = mt9p031_get_pad_crop(mt9p031, fh, crop->pad,
> +							crop->which);
> +	if (!rect)
> +		return -EINVAL;
> +
> +	crop->rect = *rect;
> +
> +	return 0;
> +}
> +
> +static u16 mt9p031_skip_for_crop(s32 source, s32 *target, s32 max_skip)
> +{
> +	unsigned int skip;
> +
> +	if (source - source / 4 < *target) {
> +		*target = source;
> +		return 1;
> +	}
> +
> +	skip = DIV_ROUND_CLOSEST(source, *target);
> +	if (skip > max_skip)
> +		skip = max_skip;
> +	*target = 2 * DIV_ROUND_UP(source, 2 * skip);
> +
> +	return skip;
> +}
> +
> +static int mt9p031_set_params(struct i2c_client *client,
> +			      struct v4l2_rect *rect, u16 xskip, u16 yskip)
> +{
> +	struct mt9p031 *mt9p031 = to_mt9p031(client);
> +	int ret;
> +	u16 xbin, ybin;
> +	const u16 hblank = MT9P031_H_BLANKING_VALUE,
> +		vblank = MT9P031_V_BLANKING_VALUE;
> +	/*
> +	 * TODO: Attention! When implementing horizontal flipping, adjust
> +	 * alignment according to R2 "Column Start" description in the datasheet
> +	 */
> +	if (xskip & 1) {
> +		xbin = 1;
> +		rect->left &= ~3;
> +	} else if (xskip & 2) {
> +		xbin = 2;
> +		rect->left &= ~7;
> +	} else {
> +		xbin = 4;
> +		rect->left &= ~15;
> +	}
> +
> +	ybin = min(yskip, (u16)4);
> +
> +	rect->top &= ~1;
> +
> +	/* Disable register update, reconfigure atomically */
> +	ret = mt9p031_set_output_control(mt9p031, 0, MT9P031_OUTPUT_CONTROL_SYN);
> +	if (ret < 0)
> +		return ret;
> +
> +	dev_dbg(&client->dev, "skip %u:%u, rect %ux%u@%u:%u\n",
> +		xskip, yskip, rect->width, rect->height, rect->left, rect->top);
> +
> +	/* Blanking and start values - default... */
> +	ret = reg_write(client, MT9P031_H_BLANKING, hblank);
> +	if (ret < 0)
> +		return ret;
> +	ret = reg_write(client, MT9P031_V_BLANKING, vblank);
> +	if (ret < 0)
> +		return ret;
> +
> +	ret = reg_write(client, MT9P031_COLUMN_ADDRESS_MODE,
> +				((xbin - 1) << 4) | (xskip - 1));
> +	if (ret < 0)
> +		return ret;
> +	ret = reg_write(client, MT9P031_ROW_ADDRESS_MODE,
> +				((ybin - 1) << 4) | (yskip - 1));
> +	if (ret < 0)
> +		return ret;
> +
> +	dev_dbg(&client->dev, "new physical left %u, top %u\n",
> +		rect->left, rect->top);
> +
> +	ret = reg_write(client, MT9P031_COLUMN_START,
> +				rect->left + MT9P031_COLUMN_START_SKIP);
> +	if (ret < 0)
> +		return ret;
> +	ret = reg_write(client, MT9P031_ROW_START,
> +				rect->top + MT9P031_ROW_START_SKIP);
> +	if (ret < 0)
> +		return ret;
> +	ret = reg_write(client, MT9P031_WINDOW_WIDTH,
> +				rect->width - 1);
> +	if (ret < 0)
> +		return ret;
> +	ret = reg_write(client, MT9P031_WINDOW_HEIGHT,
> +				rect->height - 1);
> +	if (ret < 0)
> +		return ret;
> +
> +	/* Re-enable register update, commit all changes */
> +	ret = mt9p031_set_output_control(mt9p031, MT9P031_OUTPUT_CONTROL_SYN, 0);
> +	if (ret < 0)
> +		return ret;
> +

Ditto with "ret = fn();"

> +	mt9p031->xskip = xskip;
> +	mt9p031->yskip = yskip;
> +	return ret;
> +}
> +
> +static int mt9p031_set_crop(struct v4l2_subdev *sd,
> +				struct v4l2_subdev_fh *fh,
> +				struct v4l2_subdev_crop *crop)
> +{
> +	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
> +	struct v4l2_mbus_framefmt *f;
> +	struct v4l2_rect *c;
> +	struct v4l2_rect rect;
> +	u16 xskip, yskip;
> +	s32 width, height;
> +
> +	pr_info("%s(%ux%u@%u:%u : %u)\n", __func__,
> +			crop->rect.width, crop->rect.height,
> +			crop->rect.left, crop->rect.top, crop->which);

dev_dbg()

> +
> +	/*
> +	 * Clamp the crop rectangle boundaries and align them to a multiple of 2
> +	 * pixels.
> +	 */
> +	rect.width = ALIGN(clamp(crop->rect.width,
> +				 MT9P031_MIN_WIDTH, MT9P031_MAX_WIDTH), 2);
> +	rect.height = ALIGN(clamp(crop->rect.height,
> +				  MT9P031_MIN_HEIGHT, MT9P031_MAX_HEIGHT), 2);
> +	rect.left = ALIGN(clamp(crop->rect.left,
> +				0, MT9P031_MAX_WIDTH - rect.width), 2);
> +	rect.top = ALIGN(clamp(crop->rect.top,
> +			       0, MT9P031_MAX_HEIGHT - rect.height), 2);
> +
> +	c = mt9p031_get_pad_crop(mt9p031, fh, crop->pad, crop->which);
> +
> +	if (rect.width != c->width || rect.height != c->height) {
> +		/*
> +		 * Reset the output image size if the crop rectangle size has
> +		 * been modified.
> +		 */
> +		f = mt9p031_get_pad_format(mt9p031, fh, crop->pad,
> +						    crop->which);
> +		width = f->width;
> +		height = f->height;
> +
> +		xskip = mt9p031_skip_for_crop(rect.width, &width, 7);
> +		yskip = mt9p031_skip_for_crop(rect.height, &height, 8);
> +	} else {
> +		xskip = mt9p031->xskip;
> +		yskip = mt9p031->yskip;
> +		f = NULL;
> +	}

Hm, looks like something is missing here: you dropped

	if (crop->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
		ret = mt9p031_set_params(client, &rect, xskip, yskip);
		if (ret < 0)
			return ret;
	}

from my version, without which no cropping is actually taking place. Or 
have you also switched to the convention of only configuring the hardware 
on set_stream(1)?

> +	if (f) {
> +		f->width = width;
> +		f->height = height;
> +	}
> +
> +	*c = rect;
> +	crop->rect = rect;
> +
> +	mt9p031->xskip = xskip;
> +	mt9p031->yskip = yskip;
> +	mt9p031->rect = *c;
> +	return 0;
> +}
> +
> +static int mt9p031_get_format(struct v4l2_subdev *sd,
> +				struct v4l2_subdev_fh *fh,
> +				struct v4l2_subdev_format *fmt)
> +{
> +	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
> +
> +	fmt->format =
> +		*mt9p031_get_pad_format(mt9p031, fh, fmt->pad, fmt->which);
> +	return 0;
> +}
> +
> +static u16 mt9p031_skip_for_scale(s32 *source, s32 target,
> +					s32 max_skip, s32 max)
> +{
> +	unsigned int skip;
> +
> +	if (*source - *source / 4 < target) {
> +		*source = target;
> +		return 1;
> +	}
> +
> +	skip = min(max, *source + target / 2) / target;
> +	if (skip > max_skip)
> +		skip = max_skip;
> +	*source = target * skip;
> +
> +	return skip;
> +}
> +
> +static int mt9p031_fmt_validate(struct v4l2_subdev *sd,
> +				struct v4l2_subdev_format *fmt)
> +{
> +	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
> +	struct v4l2_mbus_framefmt *format = &fmt->format;
> +
> +	if (format->code != mt9p031->format.code || fmt->pad)
> +		return -EINVAL;
> +
> +	format->colorspace = V4L2_COLORSPACE_SRGB;
> +	format->width = clamp_t(int, ALIGN(format->width, 2), 2,
> +						MT9P031_MAX_WIDTH);
> +	format->height = clamp_t(int, ALIGN(format->height, 2), 2,
> +						MT9P031_MAX_HEIGHT);
> +	format->field = V4L2_FIELD_NONE;
> +
> +	return 0;
> +}
> +
> +static int mt9p031_set_format(struct v4l2_subdev *sd,
> +				struct v4l2_subdev_fh *fh,
> +				struct v4l2_subdev_format *fmt)
> +{
> +	struct v4l2_subdev_format sdf = *fmt;
> +	struct v4l2_mbus_framefmt *f, *format = &sdf.format;
> +	struct v4l2_rect *c, rect;
> +	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
> +	u16 xskip, yskip;
> +	int ret;
> +
> +	ret = mt9p031_fmt_validate(sd, &sdf);
> +	if (ret < 0)
> +		return ret;
> +
> +	f = mt9p031_get_pad_format(mt9p031, fh, fmt->pad, fmt->which);
> +
> +	if (f->width == format->width && f->height == format->height)
> +		return 0;
> +
> +

One empty line is usually enough, especially inside a function.

> +	c = mt9p031_get_pad_crop(mt9p031, fh, fmt->pad, fmt->which);
> +
> +	rect.width = c->width;
> +	rect.height = c->height;
> +
> +	xskip = mt9p031_skip_for_scale(&rect.width, format->width, 7,
> +				       MT9P031_MAX_WIDTH);
> +	if (rect.width + c->left > MT9P031_MAX_WIDTH)
> +		rect.left = (MT9P031_MAX_WIDTH - rect.width) / 2;
> +	else
> +		rect.left = c->left;
> +	yskip = mt9p031_skip_for_scale(&rect.height, format->height, 8,
> +				       MT9P031_MAX_HEIGHT);
> +	if (rect.height + c->top > MT9P031_MAX_HEIGHT)
> +		rect.top = (MT9P031_MAX_HEIGHT - rect.height) / 2;
> +	else
> +		rect.top = c->top;
> +
> +
> +	pr_info("%s(%ux%u : %u)\n", __func__,
> +		format->width, format->height, fmt->which);

dev_dbg()

> +	if (c)
> +		*c = rect;
> +
> +	*f = *format;
> +	fmt->format = *format;
> +
> +	mt9p031->xskip = xskip;
> +	mt9p031->yskip = yskip;
> +	mt9p031->rect = *c;
> +	return 0;
> +}
> +
> +static int mt9p031_s_stream(struct v4l2_subdev *sd, int enable)
> +{
> +	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
> +	struct i2c_client *client = v4l2_get_subdevdata(&mt9p031->subdev);
> +	struct v4l2_rect rect = mt9p031->rect;
> +	u16 xskip = mt9p031->xskip;
> +	u16 yskip = mt9p031->yskip;
> +	int ret;
> +
> +	if (enable) {
> +		ret = mt9p031_set_params(client, &rect, xskip, yskip);
> +		if (ret < 0)
> +			return ret;
> +		/* Switch to master "normal" mode */
> +		ret = mt9p031_set_output_control(mt9p031, 0, MT9P031_OUTPUT_CONTROL_CEN);
> +	} else {
> +		/* Stop sensor readout */
> +		ret = mt9p031_set_output_control(mt9p031, MT9P031_OUTPUT_CONTROL_CEN, 0);
> +	}
> +	if (ret < 0)
> +		return -EIO;
> +
> +	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 mt9p031_video_probe(struct i2c_client *client)
> +{
> +	s32 data;
> +	int ret;
> +
> +	/* Read out the chip version register */
> +	data = reg_read(client, MT9P031_CHIP_VERSION);
> +	if (data != MT9P031_CHIP_VERSION_VALUE) {
> +		dev_err(&client->dev,
> +			"No MT9P031 chip detected, register read %x\n", data);
> +		return -ENODEV;
> +	}
> +
> +	dev_info(&client->dev, "Detected a MT9P031 chip ID %x\n", data);
> +
> +	ret = mt9p031_reset(client);
> +	if (ret < 0)
> +		dev_err(&client->dev, "Failed to initialise the camera\n");
> +
> +	return ret;
> +}
> +
> +static int mt9p031_set_power(struct v4l2_subdev *sd, int on)
> +{
> +	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
> +	int ret = 0;
> +
> +	mutex_lock(&mt9p031->power_lock);
> +
> +	/* If the power count is modified from 0 to != 0 or from != 0 to 0,
> +	 * update the power state.
> +	 */

Multi-line comment style

> +	if (mt9p031->power_count == !on) {
> +		if (on) {
> +			ret = mt9p031_power_on(mt9p031);
> +			if (ret) {
> +				pr_err("Failed to enable 2.8v regulator: %d\n", ret);

dev_err

> +				goto out;
> +			}
> +		} else {
> +			mt9p031_power_off(mt9p031);
> +		}
> +	}
> +
> +	/* Update the power count. */
> +	mt9p031->power_count +=on ? 1: -1;
> +	WARN_ON(mt9p031->power_count < 0);
> +
> +out:
> +	mutex_unlock(&mt9p031->power_lock);
> +	return ret;
> +}
> +
> +static int mt9p031_registered(struct v4l2_subdev *sd)
> +{
> +	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
> +	struct i2c_client *client = v4l2_get_subdevdata(&mt9p031->subdev);
> +	int ret;
> +
> +	ret = mt9p031_set_power(&mt9p031->subdev, 1);
> +	if (ret) {
> +		pr_err("Failed to power on device: %d\n", ret);

dev_err()

> +		goto pwron;
> +	}
> +	if (mt9p031->pdata->reset)
> +		mt9p031->pdata->reset(&mt9p031->subdev, 1);
> +	msleep(50);
> +	if (mt9p031->pdata->reset)
> +		mt9p031->pdata->reset(&mt9p031->subdev, 0);
> +	msleep(50);
> +
> +	ret = mt9p031_video_probe(client);
> +	if (ret)
> +		goto evprobe;
> +
> +	mt9p031->pad.flags = MEDIA_PAD_FL_SOURCE;
> +	ret = media_entity_init(&mt9p031->subdev.entity, 1, &mt9p031->pad, 0);
> +	if (ret)
> +		goto evprobe;
> +
> +	mt9p031->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
> +	mt9p031_set_power(&mt9p031->subdev, 0);
> +
> +	return 0;
> +evprobe:
> +	mt9p031_set_power(&mt9p031->subdev, 0);
> +pwron:
> +	return ret;
> +}
> +
> +static int mt9p031_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
> +{
> +	struct mt9p031 *mt9p031;
> +	mt9p031 = container_of(sd, struct mt9p031, subdev);
> +
> +	return mt9p031_set_power(sd, 1);

Is open() called only for the first open, or for each one? If for each, 
you'll want to reference count yourself. Besides, isn't 
core_ops::s_power() called anyway, maybe you don't need these open() / 
close() at all?

> +}
> +
> +static int mt9p031_close(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
> +{
> +	struct mt9p031 *mt9p031;
> +
> +	mt9p031 = container_of(sd, struct mt9p031, subdev);
> +
> +	mt9p031_set_power(sd, 0);
> +	return 0;
> +}
> +
> +static struct v4l2_subdev_core_ops mt9p031_subdev_core_ops = {
> +	.s_power	= mt9p031_set_power,
> +};
> +
> +static struct v4l2_subdev_video_ops mt9p031_subdev_video_ops = {
> +	.s_stream	= mt9p031_s_stream,
> +};
> +
> +static struct v4l2_subdev_pad_ops mt9p031_subdev_pad_ops = {
> +	.enum_mbus_code = mt9p031_enum_mbus_code,
> +	.get_fmt = mt9p031_get_format,
> +	.set_fmt = mt9p031_set_format,
> +	.get_crop = mt9p031_get_crop,
> +	.set_crop = mt9p031_set_crop,
> +};
> +
> +static struct v4l2_subdev_ops mt9p031_subdev_ops = {
> +	.core	= &mt9p031_subdev_core_ops,
> +	.video	= &mt9p031_subdev_video_ops,
> +	.pad	= &mt9p031_subdev_pad_ops,
> +};
> +
> +static const struct v4l2_subdev_internal_ops mt9p031_subdev_internal_ops = {
> +	.registered = mt9p031_registered,
> +	.open = mt9p031_open,
> +	.close = mt9p031_close,
> +};
> +
> +static int mt9p031_probe(struct i2c_client *client,
> +			 const struct i2c_device_id *did)
> +{
> +	struct mt9p031 *mt9p031;
> +	struct mt9p031_platform_data *pdata = client->dev.platform_data;
> +	struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
> +	int ret;
> +
> +	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;
> +	}
> +
> +	mt9p031 = kzalloc(sizeof(struct mt9p031), GFP_KERNEL);
> +	if (!mt9p031)
> +		return -ENOMEM;
> +
> +	mutex_init(&mt9p031->power_lock);
> +	v4l2_i2c_subdev_init(&mt9p031->subdev, client, &mt9p031_subdev_ops);
> +	mt9p031->subdev.internal_ops = &mt9p031_subdev_internal_ops;
> +
> +	mt9p031->pdata		= pdata;
> +	mt9p031->rect.left	= 0;
> +	mt9p031->rect.top	= 0;

No need - kzalloc() has nullified it for you.

> +	mt9p031->rect.width	= MT9P031_MAX_WIDTH;
> +	mt9p031->rect.height	= MT9P031_MAX_HEIGHT;
> +
> +	mt9p031->format.code = V4L2_MBUS_FMT_SGRBG12_1X12;
> +
> +	mt9p031->format.width = MT9P031_MAX_WIDTH;
> +	mt9p031->format.height = MT9P031_MAX_HEIGHT;
> +	mt9p031->format.field = V4L2_FIELD_NONE;
> +	mt9p031->format.colorspace = V4L2_COLORSPACE_SRGB;
> +
> +	mt9p031->xskip = 1;
> +	mt9p031->yskip = 1;
> +
> +	mt9p031->reg_1v8 = regulator_get(NULL, "cam_1v8");
> +	if (IS_ERR(mt9p031->reg_1v8)) {
> +		ret = PTR_ERR(mt9p031->reg_1v8);
> +		pr_err("Failed 1.8v regulator: %d\n", ret);

dev_err()

> +		goto e1v8;
> +	}
> +
> +	mt9p031->reg_2v8 = regulator_get(NULL, "cam_2v8");
> +	if (IS_ERR(mt9p031->reg_2v8)) {
> +		ret = PTR_ERR(mt9p031->reg_2v8);
> +		pr_err("Failed 2.8v regulator: %d\n", ret);

ditto

> +		goto e2v8;
> +	}
> +	/* turn on core */
> +	ret = regulator_enable(mt9p031->reg_1v8);
> +	if (ret) {
> +		pr_err("Failed to enable 1.8v regulator: %d\n", ret);

ditto

> +		goto e1v8en;
> +	}
> +	return 0;
> +e1v8en:
> +	regulator_put(mt9p031->reg_2v8);
> +e2v8:
> +	regulator_put(mt9p031->reg_1v8);
> +e1v8:
> +	kfree(mt9p031);
> +	return ret;
> +}
> +
> +static int mt9p031_remove(struct i2c_client *client)
> +{
> +	struct v4l2_subdev *sd = i2c_get_clientdata(client);
> +	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
> +
> +	v4l2_device_unregister_subdev(sd);
> +	media_entity_cleanup(&sd->entity);
> +	regulator_disable(mt9p031->reg_1v8);
> +	regulator_put(mt9p031->reg_2v8);
> +	regulator_put(mt9p031->reg_1v8);
> +	kfree(mt9p031);
> +
> +	return 0;
> +}
> +
> +static const struct i2c_device_id mt9p031_id[] = {
> +	{ "mt9p031", 0 },
> +	{ }
> +};
> +MODULE_DEVICE_TABLE(i2c, mt9p031_id);
> +
> +static struct i2c_driver mt9p031_i2c_driver = {
> +	.driver = {
> +		.name = "mt9p031",
> +	},
> +	.probe		= mt9p031_probe,
> +	.remove		= mt9p031_remove,
> +	.id_table	= mt9p031_id,
> +};
> +
> +static int __init mt9p031_mod_init(void)
> +{
> +	return i2c_add_driver(&mt9p031_i2c_driver);
> +}
> +
> +static void __exit mt9p031_mod_exit(void)
> +{
> +	i2c_del_driver(&mt9p031_i2c_driver);
> +}
> +
> +module_init(mt9p031_mod_init);
> +module_exit(mt9p031_mod_exit);
> +
> +MODULE_DESCRIPTION("Aptina MT9P031 Camera driver");
> +MODULE_AUTHOR("Bastian Hecht <[e-mail]>");
> +MODULE_LICENSE("GPL v2");
> diff --git a/include/media/mt9p031.h b/include/media/mt9p031.h
> new file mode 100644
> index 0000000..ad37eb3
> --- /dev/null
> +++ b/include/media/mt9p031.h
> @@ -0,0 +1,11 @@
> +#ifndef MT9P031_H
> +#define MT9P031_H
> +
> +struct v4l2_subdev;
> +
> +struct mt9p031_platform_data {
> +	int (*set_xclk)(struct v4l2_subdev *subdev, int hz);
> +	int (*reset)(struct v4l2_subdev *subdev, int active);
> +};
> +
> +#endif
> -- 
> 1.7.0.4
> 

Thanks
Guennadi
---
Guennadi Liakhovetski, Ph.D.
Freelance Open-Source Software Developer
http://www.open-technology.de/
--
To unsubscribe from this list: send the line "unsubscribe linux-media" in
the body of a message to [e-mail]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Laurent Pinchart May 22, 2011, 8:41 p.m. UTC | #3

Hi Mauro,

On Saturday 21 May 2011 14:55:12 Mauro Carvalho Chehab wrote:
> Hi Laurent,
> 
> Despite all those changes at Nokia side, I'm still assuming that you're
> handling the omap3 patches.

That's correct. I maintain (with Sakari) the OMAP3 ISP driver. For practical 
reason I'm the one who sends the pull requests.

> So, I'm just marking those two patches as RFC until I receive a pull request
> from you.

Note that this patch is not strictly tied to the OMAP3 ISP, as it adds support 
for a sensor that can be used with any media controller-enabled ISP. In 
practice we don't have many of such ISPs :-) I'll thus take the patch in my 
tree.

> Anyway, in this specific case, Koen made some comments, so we should wait
> for Javier answer before moving ahead.

Guennadi also sent comments. I'll wait for the next version of the patch.

Please note that I will probably apply patch 1/2 only at first, as we still 
have no proper solution to support sensors on pluggable expansion modules in a 
modular way. More work is needed in that area before patch 2/2 (or rather a 
patch set that will provide the same functionality) can be applied.

Javier Martin May 23, 2011, 8:20 a.m. UTC | #4

On 21 May 2011 17:29, Guennadi Liakhovetski <[e-mail]> wrote:
> On Fri, 20 May 2011, Javier Martin wrote:
>
>> This driver adds basic support for Aptina mt9p031 sensor.
>>
>> Signed-off-by: Javier Martin <[e-mail]>
>> ---
>>  drivers/media/video/Kconfig   |    8 +
>>  drivers/media/video/Makefile  |    1 +
>>  drivers/media/video/mt9p031.c |  751 +++++++++++++++++++++++++++++++++++++++++
>>  include/media/mt9p031.h       |   11 +
>>  4 files changed, 771 insertions(+), 0 deletions(-)
>>  create mode 100644 drivers/media/video/mt9p031.c
>>  create mode 100644 include/media/mt9p031.h
>>
>> diff --git a/drivers/media/video/Kconfig b/drivers/media/video/Kconfig
>> index 00f51dd..5c96b89 100644
>> --- a/drivers/media/video/Kconfig
>> +++ b/drivers/media/video/Kconfig
>> @@ -329,6 +329,14 @@ config VIDEO_OV7670
>>         OV7670 VGA camera.  It currently only works with the M88ALP01
>>         controller.
>>
>> +config VIDEO_MT9P031
>> +     tristate "Aptina MT9P031 support"
>> +     depends on I2C && VIDEO_V4L2
>> +     ---help---
>> +       This driver supports MT9P031 cameras from Micron
>> +       This is a Video4Linux2 sensor-level driver for the Micron
>> +       mt0p031 5 Mpixel camera.
>
> Two sentences seem to repeat the same with other words, and it's better to
> stay consistent: just use Aptina everywhere, maybe put Micron in brackets
> at one location.
>

OK, I will fix it.

>> +
>>  config VIDEO_MT9V011
>>       tristate "Micron mt9v011 sensor support"
>>       depends on I2C && VIDEO_V4L2
>> diff --git a/drivers/media/video/Makefile b/drivers/media/video/Makefile
>> index ace5d8b..912b29b 100644
>> --- a/drivers/media/video/Makefile
>> +++ b/drivers/media/video/Makefile
>> @@ -65,6 +65,7 @@ obj-$(CONFIG_VIDEO_UPD64083) += upd64083.o
>>  obj-$(CONFIG_VIDEO_OV7670)   += ov7670.o
>>  obj-$(CONFIG_VIDEO_TCM825X) += tcm825x.o
>>  obj-$(CONFIG_VIDEO_TVEEPROM) += tveeprom.o
>> +obj-$(CONFIG_VIDEO_MT9P031) += mt9p031.o
>>  obj-$(CONFIG_VIDEO_MT9V011) += mt9v011.o
>>  obj-$(CONFIG_VIDEO_SR030PC30)        += sr030pc30.o
>>  obj-$(CONFIG_VIDEO_NOON010PC30)      += noon010pc30.o
>> diff --git a/drivers/media/video/mt9p031.c b/drivers/media/video/mt9p031.c
>> new file mode 100644
>> index 0000000..e406b64
>> --- /dev/null
>> +++ b/drivers/media/video/mt9p031.c
>> @@ -0,0 +1,751 @@
>> +/*
>> + * Driver for MT9P031 CMOS Image Sensor from Aptina
>> + *
>> + * Copyright (C) 2011, Javier Martin <[e-mail]>
>> + *
>> + * Copyright (C) 2011, Guennadi Liakhovetski <[e-mail]>
>> + *
>> + * Based on the MT9V032 driver and Bastian Hecht's code.
>> + *
>> + * 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/device.h>
>> +#include <linux/i2c.h>
>> +#include <linux/log2.h>
>> +#include <linux/pm.h>
>> +#include <linux/regulator/consumer.h>
>> +#include <linux/slab.h>
>> +#include <media/v4l2-subdev.h>
>> +#include <linux/videodev2.h>
>> +
>> +#include <media/mt9p031.h>
>> +#include <media/v4l2-chip-ident.h>
>> +#include <media/v4l2-subdev.h>
>> +#include <media/v4l2-device.h>
>> +
>> +/* mt9p031 selected register addresses */
>> +#define MT9P031_CHIP_VERSION                 0x00
>> +#define              MT9P031_CHIP_VERSION_VALUE      0x1801
>> +#define MT9P031_ROW_START                    0x01
>
> Don't mix spaces and TABs between "#define" and the macro - just use one
> space everywhere.
>

I've done this in order to follow Laurent's directions. He does the
same in mt9v032 driver.
So, unless Laurent and you agree I think I won't change it.

>
>> +#define              MT9P031_ROW_START_SKIP          54
>> +#define MT9P031_COLUMN_START                 0x02
>> +#define              MT9P031_COLUMN_START_SKIP       16
>> +#define MT9P031_WINDOW_HEIGHT                        0x03
>> +#define MT9P031_WINDOW_WIDTH                 0x04
>> +#define MT9P031_H_BLANKING                   0x05
>> +#define              MT9P031_H_BLANKING_VALUE        0
>> +#define MT9P031_V_BLANKING                   0x06
>> +#define              MT9P031_V_BLANKING_VALUE        25
>> +#define MT9P031_OUTPUT_CONTROL                       0x07
>> +#define              MT9P031_OUTPUT_CONTROL_CEN      2
>> +#define              MT9P031_OUTPUT_CONTROL_SYN      1
>> +#define MT9P031_SHUTTER_WIDTH_UPPER          0x08
>> +#define MT9P031_SHUTTER_WIDTH                        0x09
>> +#define MT9P031_PIXEL_CLOCK_CONTROL          0x0a
>> +#define MT9P031_FRAME_RESTART                        0x0b
>> +#define MT9P031_SHUTTER_DELAY                        0x0c
>> +#define MT9P031_RST                          0x0d
>> +#define              MT9P031_RST_ENABLE              1
>> +#define              MT9P031_RST_DISABLE             0
>> +#define MT9P031_READ_MODE_1                  0x1e
>> +#define MT9P031_READ_MODE_2                  0x20
>> +#define              MT9P031_READ_MODE_2_ROW_MIR     0x8000
>> +#define              MT9P031_READ_MODE_2_COL_MIR     0x4000
>> +#define MT9P031_ROW_ADDRESS_MODE             0x22
>> +#define MT9P031_COLUMN_ADDRESS_MODE          0x23
>> +#define MT9P031_GLOBAL_GAIN                  0x35
>> +
>> +#define MT9P031_MAX_HEIGHT                   1944
>> +#define MT9P031_MAX_WIDTH                    2592
>> +#define MT9P031_MIN_HEIGHT                   2
>> +#define MT9P031_MIN_WIDTH                    18
>> +
>> +struct mt9p031 {
>> +     struct v4l2_subdev subdev;
>> +     struct media_pad pad;
>> +     struct v4l2_rect rect;  /* Sensor window */
>> +     struct v4l2_mbus_framefmt format;
>> +     struct mt9p031_platform_data *pdata;
>> +     struct mutex power_lock;
>
> Don't locks _always_ have to be documented? And this one: you only protect
> set_power() with it, Laurent, is this correct?
>

Just following the model Laurent applies in mt9v032. Let's see what he
has to say about this.

>
>> +     int power_count;
>> +     u16 xskip;
>> +     u16 yskip;
>> +     u16 output_control;
>> +     struct regulator *reg_1v8;
>> +     struct regulator *reg_2v8;
>> +};
>> +
>> +static struct mt9p031 *to_mt9p031(const struct i2c_client *client)
>> +{
>> +     return container_of(i2c_get_clientdata(client), struct mt9p031, subdev);
>> +}
>> +
>> +static int reg_read(struct i2c_client *client, const u8 reg)
>> +{
>> +     s32 data = i2c_smbus_read_word_data(client, reg);
>> +     return data < 0 ? data : swab16(data);
>> +}
>> +
>> +static int reg_write(struct i2c_client *client, const u8 reg,
>> +                     const u16 data)
>> +{
>> +     return i2c_smbus_write_word_data(client, reg, swab16(data));
>> +}
>> +
>> +static int mt9p031_set_output_control(struct mt9p031 *mt9p031, u16 clear,
>> +                                   u16 set)
>> +{
>> +     struct i2c_client *client = v4l2_get_subdevdata(&mt9p031->subdev);
>> +     u16 value = (mt9p031->output_control & ~clear) | set;
>> +     int ret;
>> +
>> +     ret = reg_write(client, MT9P031_OUTPUT_CONTROL, value);
>> +     if (ret < 0)
>> +             return ret;
>> +
>> +     mt9p031->output_control = value;
>> +     return 0;
>> +}
>> +
>> +static int mt9p031_reset(struct i2c_client *client)
>> +{
>> +     struct mt9p031 *mt9p031 = to_mt9p031(client);
>> +     int ret;
>> +
>> +     /* Disable chip output, synchronous option update */
>> +     ret = reg_write(client, MT9P031_RST, MT9P031_RST_ENABLE);
>> +     if (ret < 0)
>> +             return -EIO;
>> +     ret = reg_write(client, MT9P031_RST, MT9P031_RST_DISABLE);
>> +     if (ret < 0)
>> +             return -EIO;
>> +     ret = mt9p031_set_output_control(mt9p031, MT9P031_OUTPUT_CONTROL_CEN, 0);
>> +     if (ret < 0)
>> +             return -EIO;
>> +     return 0;
>
>
> I think, a sequence like
>
>        ret = fn();
>        if (!ret)
>                ret = fn();
>        if (!ret)
>                ret = fn();
>        return ret;
>
> is a better way to achieve the same.
>

Sorry, but I have to disagree. I understand what you want to achieve
but this seems quite tricky to me.
I explicitly changed parts of the code that were written using that
style because I think It was better understandable.


>> +}
>> +
>> +static int mt9p031_power_on(struct mt9p031 *mt9p031)
>> +{
>> +     int ret;
>> +
>> +     /* turn on VDD_IO */
>> +     ret = regulator_enable(mt9p031->reg_2v8);
>> +     if (ret) {
>> +             pr_err("Failed to enable 2.8v regulator: %d\n", ret);
>
> dev_err()

ok

>> +             return ret;
>> +     }

[snip]

>> +
>> +     pr_info("%s(%ux%u@%u:%u : %u)\n", __func__,
>> +                     crop->rect.width, crop->rect.height,
>> +                     crop->rect.left, crop->rect.top, crop->which);
>
> dev_dbg()

ok

>> +
>> +     /*
>> +      * Clamp the crop rectangle boundaries and align them to a multiple of 2
>> +      * pixels.
>> +      */
>> +     rect.width = ALIGN(clamp(crop->rect.width,
>> +                              MT9P031_MIN_WIDTH, MT9P031_MAX_WIDTH), 2);
>> +     rect.height = ALIGN(clamp(crop->rect.height,
>> +                               MT9P031_MIN_HEIGHT, MT9P031_MAX_HEIGHT), 2);
>> +     rect.left = ALIGN(clamp(crop->rect.left,
>> +                             0, MT9P031_MAX_WIDTH - rect.width), 2);
>> +     rect.top = ALIGN(clamp(crop->rect.top,
>> +                            0, MT9P031_MAX_HEIGHT - rect.height), 2);
>> +
>> +     c = mt9p031_get_pad_crop(mt9p031, fh, crop->pad, crop->which);
>> +
>> +     if (rect.width != c->width || rect.height != c->height) {
>> +             /*
>> +              * Reset the output image size if the crop rectangle size has
>> +              * been modified.
>> +              */
>> +             f = mt9p031_get_pad_format(mt9p031, fh, crop->pad,
>> +                                                 crop->which);
>> +             width = f->width;
>> +             height = f->height;
>> +
>> +             xskip = mt9p031_skip_for_crop(rect.width, &width, 7);
>> +             yskip = mt9p031_skip_for_crop(rect.height, &height, 8);
>> +     } else {
>> +             xskip = mt9p031->xskip;
>> +             yskip = mt9p031->yskip;
>> +             f = NULL;
>> +     }
>
> Hm, looks like something is missing here: you dropped
>
>        if (crop->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
>                ret = mt9p031_set_params(client, &rect, xskip, yskip);
>                if (ret < 0)
>                        return ret;
>        }
>
> from my version, without which no cropping is actually taking place. Or
> have you also switched to the convention of only configuring the hardware
> on set_stream(1)?
>

Yes I did, following Laurent's directions.

[snip]
>> +
>> +     f = mt9p031_get_pad_format(mt9p031, fh, fmt->pad, fmt->which);
>> +
>> +     if (f->width == format->width && f->height == format->height)
>> +             return 0;
>> +
>> +
>
> One empty line is usually enough, especially inside a function.
>
ok, I'll fix.

>> +     c = mt9p031_get_pad_crop(mt9p031, fh, fmt->pad, fmt->which);
>> +
>> +     rect.width = c->width;
>> +     rect.height = c->height;
>> +
>> +     xskip = mt9p031_skip_for_scale(&rect.width, format->width, 7,
>> +                                    MT9P031_MAX_WIDTH);
>> +     if (rect.width + c->left > MT9P031_MAX_WIDTH)
>> +             rect.left = (MT9P031_MAX_WIDTH - rect.width) / 2;
>> +     else
>> +             rect.left = c->left;
>> +     yskip = mt9p031_skip_for_scale(&rect.height, format->height, 8,
>> +                                    MT9P031_MAX_HEIGHT);
>> +     if (rect.height + c->top > MT9P031_MAX_HEIGHT)
>> +             rect.top = (MT9P031_MAX_HEIGHT - rect.height) / 2;
>> +     else
>> +             rect.top = c->top;
>> +
>> +
>> +     pr_info("%s(%ux%u : %u)\n", __func__,
>> +             format->width, format->height, fmt->which);
>
> dev_dbg()

ok

>
>> +     if (c)
>> +             *c = rect;
>> +
>> +     *f = *format;
>> +     fmt->format = *format;
>> +
>> +     mt9p031->xskip = xskip;
>> +     mt9p031->yskip = yskip;
>> +     mt9p031->rect = *c;
>> +     return 0;
>> +}
>> +
>> +static int mt9p031_s_stream(struct v4l2_subdev *sd, int enable)
>> +{
>> +     struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
>> +     struct i2c_client *client = v4l2_get_subdevdata(&mt9p031->subdev);
>> +     struct v4l2_rect rect = mt9p031->rect;
>> +     u16 xskip = mt9p031->xskip;
>> +     u16 yskip = mt9p031->yskip;
>> +     int ret;
>> +
>> +     if (enable) {
>> +             ret = mt9p031_set_params(client, &rect, xskip, yskip);
>> +             if (ret < 0)
>> +                     return ret;
>> +             /* Switch to master "normal" mode */
>> +             ret = mt9p031_set_output_control(mt9p031, 0, MT9P031_OUTPUT_CONTROL_CEN);
>> +     } else {
>> +             /* Stop sensor readout */
>> +             ret = mt9p031_set_output_control(mt9p031, MT9P031_OUTPUT_CONTROL_CEN, 0);
>> +     }
>> +     if (ret < 0)
>> +             return -EIO;
>> +
>> +     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 mt9p031_video_probe(struct i2c_client *client)
>> +{
>> +     s32 data;
>> +     int ret;
>> +
>> +     /* Read out the chip version register */
>> +     data = reg_read(client, MT9P031_CHIP_VERSION);
>> +     if (data != MT9P031_CHIP_VERSION_VALUE) {
>> +             dev_err(&client->dev,
>> +                     "No MT9P031 chip detected, register read %x\n", data);
>> +             return -ENODEV;
>> +     }
>> +
>> +     dev_info(&client->dev, "Detected a MT9P031 chip ID %x\n", data);
>> +
>> +     ret = mt9p031_reset(client);
>> +     if (ret < 0)
>> +             dev_err(&client->dev, "Failed to initialise the camera\n");
>> +
>> +     return ret;
>> +}
>> +
>> +static int mt9p031_set_power(struct v4l2_subdev *sd, int on)
>> +{
>> +     struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
>> +     int ret = 0;
>> +
>> +     mutex_lock(&mt9p031->power_lock);
>> +
>> +     /* If the power count is modified from 0 to != 0 or from != 0 to 0,
>> +      * update the power state.
>> +      */
>
> Multi-line comment style
>

Sure, let me fix that.

>> +     if (mt9p031->power_count == !on) {
>> +             if (on) {
>> +                     ret = mt9p031_power_on(mt9p031);
>> +                     if (ret) {
>> +                             pr_err("Failed to enable 2.8v regulator: %d\n", ret);
>
> dev_err

ok

>
>> +                             goto out;
>> +                     }
>> +             } else {
>> +                     mt9p031_power_off(mt9p031);
>> +             }
>> +     }
>> +
>> +     /* Update the power count. */
>> +     mt9p031->power_count +=on ? 1: -1;
>> +     WARN_ON(mt9p031->power_count < 0);
>> +
>> +out:
>> +     mutex_unlock(&mt9p031->power_lock);
>> +     return ret;
>> +}
>> +
>> +static int mt9p031_registered(struct v4l2_subdev *sd)
>> +{
>> +     struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
>> +     struct i2c_client *client = v4l2_get_subdevdata(&mt9p031->subdev);
>> +     int ret;
>> +
>> +     ret = mt9p031_set_power(&mt9p031->subdev, 1);
>> +     if (ret) {
>> +             pr_err("Failed to power on device: %d\n", ret);
>
> dev_err()
>

ok

>> +             goto pwron;
>> +     }
>> +     if (mt9p031->pdata->reset)
>> +             mt9p031->pdata->reset(&mt9p031->subdev, 1);
>> +     msleep(50);
>> +     if (mt9p031->pdata->reset)
>> +             mt9p031->pdata->reset(&mt9p031->subdev, 0);
>> +     msleep(50);
>> +
>> +     ret = mt9p031_video_probe(client);
>> +     if (ret)
>> +             goto evprobe;
>> +
>> +     mt9p031->pad.flags = MEDIA_PAD_FL_SOURCE;
>> +     ret = media_entity_init(&mt9p031->subdev.entity, 1, &mt9p031->pad, 0);
>> +     if (ret)
>> +             goto evprobe;
>> +
>> +     mt9p031->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
>> +     mt9p031_set_power(&mt9p031->subdev, 0);
>> +
>> +     return 0;
>> +evprobe:
>> +     mt9p031_set_power(&mt9p031->subdev, 0);
>> +pwron:
>> +     return ret;
>> +}
>> +
>> +static int mt9p031_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
>> +{
>> +     struct mt9p031 *mt9p031;
>> +     mt9p031 = container_of(sd, struct mt9p031, subdev);
>> +
>> +     return mt9p031_set_power(sd, 1);
>
> Is open() called only for the first open, or for each one? If for each,
> you'll want to reference count yourself. Besides, isn't
> core_ops::s_power() called anyway, maybe you don't need these open() /
> close() at all?
>

Yes, you are right. As I only enable/disable power in open/close, they
can be safely removed.

[snip]
>> +     mt9p031 = kzalloc(sizeof(struct mt9p031), GFP_KERNEL);
>> +     if (!mt9p031)
>> +             return -ENOMEM;
>> +
>> +     mutex_init(&mt9p031->power_lock);
>> +     v4l2_i2c_subdev_init(&mt9p031->subdev, client, &mt9p031_subdev_ops);
>> +     mt9p031->subdev.internal_ops = &mt9p031_subdev_internal_ops;
>> +
>> +     mt9p031->pdata          = pdata;
>> +     mt9p031->rect.left      = 0;
>> +     mt9p031->rect.top       = 0;
>
> No need - kzalloc() has nullified it for you.

OK, I'll remove this.

Guennadi Liakhovetski May 23, 2011, 8:48 a.m. UTC | #5

On Mon, 23 May 2011, javier Martin wrote:

> On 21 May 2011 17:29, Guennadi Liakhovetski <[e-mail]> wrote:
> > On Fri, 20 May 2011, Javier Martin wrote:
> >
> >> This driver adds basic support for Aptina mt9p031 sensor.
> >>
> >> Signed-off-by: Javier Martin <[e-mail]>
> >> ---
> >>  drivers/media/video/Kconfig   |    8 +
> >>  drivers/media/video/Makefile  |    1 +
> >>  drivers/media/video/mt9p031.c |  751 +++++++++++++++++++++++++++++++++++++++++
> >>  include/media/mt9p031.h       |   11 +
> >>  4 files changed, 771 insertions(+), 0 deletions(-)
> >>  create mode 100644 drivers/media/video/mt9p031.c
> >>  create mode 100644 include/media/mt9p031.h
> >>
> >> diff --git a/drivers/media/video/mt9p031.c b/drivers/media/video/mt9p031.c
> >> new file mode 100644
> >> index 0000000..e406b64
> >> --- /dev/null
> >> +++ b/drivers/media/video/mt9p031.c
> >> @@ -0,0 +1,751 @@
> >> +/*
> >> + * Driver for MT9P031 CMOS Image Sensor from Aptina
> >> + *
> >> + * Copyright (C) 2011, Javier Martin <[e-mail]>
> >> + *
> >> + * Copyright (C) 2011, Guennadi Liakhovetski <[e-mail]>
> >> + *
> >> + * Based on the MT9V032 driver and Bastian Hecht's code.
> >> + *
> >> + * 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/device.h>
> >> +#include <linux/i2c.h>
> >> +#include <linux/log2.h>
> >> +#include <linux/pm.h>
> >> +#include <linux/regulator/consumer.h>
> >> +#include <linux/slab.h>
> >> +#include <media/v4l2-subdev.h>
> >> +#include <linux/videodev2.h>
> >> +
> >> +#include <media/mt9p031.h>
> >> +#include <media/v4l2-chip-ident.h>
> >> +#include <media/v4l2-subdev.h>
> >> +#include <media/v4l2-device.h>
> >> +
> >> +/* mt9p031 selected register addresses */
> >> +#define MT9P031_CHIP_VERSION                 0x00
> >> +#define              MT9P031_CHIP_VERSION_VALUE      0x1801
> >> +#define MT9P031_ROW_START                    0x01
> >
> > Don't mix spaces and TABs between "#define" and the macro - just use one
> > space everywhere.
> >
> 
> I've done this in order to follow Laurent's directions. He does the
> same in mt9v032 driver.
> So, unless Laurent and you agree I think I won't change it.

Ah, so, you use a space for registers and TABs for their values, ok then.

> >> +struct mt9p031 {
> >> +     struct v4l2_subdev subdev;
> >> +     struct media_pad pad;
> >> +     struct v4l2_rect rect;  /* Sensor window */
> >> +     struct v4l2_mbus_framefmt format;
> >> +     struct mt9p031_platform_data *pdata;
> >> +     struct mutex power_lock;
> >
> > Don't locks _always_ have to be documented? And this one: you only protect
> > set_power() with it, Laurent, is this correct?
> >
> 
> Just following the model Laurent applies in mt9v032. Let's see what he
> has to say about this.

Try running scripts/checkpatch.pl on your patch. I think, it will complain 
about this. And in general it's a good idea to run it before submission;)

> >> +static int mt9p031_reset(struct i2c_client *client)
> >> +{
> >> +     struct mt9p031 *mt9p031 = to_mt9p031(client);
> >> +     int ret;
> >> +
> >> +     /* Disable chip output, synchronous option update */
> >> +     ret = reg_write(client, MT9P031_RST, MT9P031_RST_ENABLE);
> >> +     if (ret < 0)
> >> +             return -EIO;
> >> +     ret = reg_write(client, MT9P031_RST, MT9P031_RST_DISABLE);
> >> +     if (ret < 0)
> >> +             return -EIO;
> >> +     ret = mt9p031_set_output_control(mt9p031, MT9P031_OUTPUT_CONTROL_CEN, 0);
> >> +     if (ret < 0)
> >> +             return -EIO;
> >> +     return 0;
> >
> >
> > I think, a sequence like
> >
> >        ret = fn();
> >        if (!ret)
> >                ret = fn();
> >        if (!ret)
> >                ret = fn();
> >        return ret;
> >
> > is a better way to achieve the same.
> >
> 
> Sorry, but I have to disagree. I understand what you want to achieve
> but this seems quite tricky to me.
> I explicitly changed parts of the code that were written using that
> style because I think It was better understandable.

Well, that was my opinion. Since Laurent will be taking this patch via his 
tree, his decision will be final, of course. But I think, he'll agree, 
that at least you have to be consistent across the driver. And at least 
you'd want to propagate your error code up to the caller instead of 
replacing it with "-EIO."

Thanks
Guennadi
---
Guennadi Liakhovetski, Ph.D.
Freelance Open-Source Software Developer
http://www.open-technology.de/
--
To unsubscribe from this list: send the line "unsubscribe linux-media" in
the body of a message to [e-mail]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Laurent Pinchart May 23, 2011, 9:03 a.m. UTC | #6

Hi Guennadi and Javier,

On Saturday 21 May 2011 17:29:18 Guennadi Liakhovetski wrote:
> On Fri, 20 May 2011, Javier Martin wrote:

[snip]

> > diff --git a/drivers/media/video/mt9p031.c
> > b/drivers/media/video/mt9p031.c new file mode 100644
> > index 0000000..e406b64
> > --- /dev/null
> > +++ b/drivers/media/video/mt9p031.c

[snip]

> > +#define MT9P031_ROW_START			0x01
> 
> Don't mix spaces and TABs between "#define" and the macro - just use one
> space everywhere.
> 
> > +#define		MT9P031_ROW_START_SKIP		54

That should be MT9P031_ROW_START_DEF. You should define MT9P031_ROW_START_MIN 
and MT9P031_ROW_START_MAX as well, you will need them. Same for column start, 
window height and window width.

> > +#define MT9P031_COLUMN_START			0x02
> > +#define		MT9P031_COLUMN_START_SKIP	16
> > +#define MT9P031_WINDOW_HEIGHT			0x03
> > +#define MT9P031_WINDOW_WIDTH			0x04
> > +#define MT9P031_H_BLANKING			0x05
> > +#define		MT9P031_H_BLANKING_VALUE	0
> > +#define MT9P031_V_BLANKING			0x06
> > +#define		MT9P031_V_BLANKING_VALUE	25
> > +#define MT9P031_OUTPUT_CONTROL			0x07
> > +#define		MT9P031_OUTPUT_CONTROL_CEN	2
> > +#define		MT9P031_OUTPUT_CONTROL_SYN	1
> > +#define MT9P031_SHUTTER_WIDTH_UPPER		0x08
> > +#define MT9P031_SHUTTER_WIDTH			0x09
> > +#define MT9P031_PIXEL_CLOCK_CONTROL		0x0a
> > +#define MT9P031_FRAME_RESTART			0x0b
> > +#define MT9P031_SHUTTER_DELAY			0x0c
> > +#define MT9P031_RST				0x0d
> > +#define		MT9P031_RST_ENABLE		1
> > +#define		MT9P031_RST_DISABLE		0
> > +#define MT9P031_READ_MODE_1			0x1e
> > +#define MT9P031_READ_MODE_2			0x20
> > +#define		MT9P031_READ_MODE_2_ROW_MIR	0x8000
> > +#define		MT9P031_READ_MODE_2_COL_MIR	0x4000
> > +#define MT9P031_ROW_ADDRESS_MODE		0x22
> > +#define MT9P031_COLUMN_ADDRESS_MODE		0x23
> > +#define MT9P031_GLOBAL_GAIN			0x35
> > +
> > +#define MT9P031_MAX_HEIGHT			1944
> > +#define MT9P031_MAX_WIDTH			2592
> > +#define MT9P031_MIN_HEIGHT			2
> > +#define MT9P031_MIN_WIDTH			18

You can get rid of those 4 #define's and use MT9P031_WINDOW_(HEIGHT|
WIDTH)_(MIN|MAX) instead.

> > +struct mt9p031 {
> > +	struct v4l2_subdev subdev;
> > +	struct media_pad pad;
> > +	struct v4l2_rect rect;	/* Sensor window */
> > +	struct v4l2_mbus_framefmt format;
> > +	struct mt9p031_platform_data *pdata;
> > +	struct mutex power_lock;
> 
> Don't locks _always_ have to be documented? And this one: you only protect
> set_power() with it, Laurent, is this correct?

You're right, locks have to always be documented, either inline or in a 
comment block above the structure. A small comment such as /* Protects 
power_count */ is enough.

> > +	int power_count;
> > +	u16 xskip;
> > +	u16 yskip;
> > +	u16 output_control;
> > +	struct regulator *reg_1v8;
> > +	struct regulator *reg_2v8;
> > +};

[snip]

> > +static int mt9p031_reset(struct i2c_client *client)
> > +{
> > +	struct mt9p031 *mt9p031 = to_mt9p031(client);
> > +	int ret;
> > +
> > +	/* Disable chip output, synchronous option update */
> > +	ret = reg_write(client, MT9P031_RST, MT9P031_RST_ENABLE);
> > +	if (ret < 0)
> > +		return -EIO;
> > +	ret = reg_write(client, MT9P031_RST, MT9P031_RST_DISABLE);
> > +	if (ret < 0)
> > +		return -EIO;
> > +	ret = mt9p031_set_output_control(mt9p031, MT9P031_OUTPUT_CONTROL_CEN,
> > 0); +	if (ret < 0)
> > +		return -EIO;
> > +	return 0;
> 
> I think, a sequence like
> 
> 	ret = fn();
> 	if (!ret)
> 		ret = fn();
> 	if (!ret)
> 		ret = fn();
> 	return ret;
> 
> is a better way to achieve the same.

I disagree with you on that :-) I find code sequences that return as soon as 
an error occurs, using the main code path for the error-free case, easier to 
read. It can be a matter of personal taste though.

This being said, the function can end with

	return mt9p031_set_output_control(mt9p031, MT9P031_OUTPUT_CONTROL_CEN, 0);

instead of

	ret = mt9p031_set_output_control(mt9p031, MT9P031_OUTPUT_CONTROL_CEN, 0);
	if (ret < 0)
		return -EIO;
	return 0;
 
> > +}
> > +
> > +static int mt9p031_power_on(struct mt9p031 *mt9p031)
> > +{
> > +	int ret;
> > +
> > +	/* turn on VDD_IO */
> > +	ret = regulator_enable(mt9p031->reg_2v8);
> > +	if (ret) {
> > +		pr_err("Failed to enable 2.8v regulator: %d\n", ret);
> 
> dev_err()
> 
> > +		return ret;
> > +	}
> > +	if (mt9p031->pdata->set_xclk)
> > +		mt9p031->pdata->set_xclk(&mt9p031->subdev, 54000000);

Can you make 54000000 a #define at the beginning of the file ?

You should soft-reset the chip here by calling mt9p031_reset().

> > +
> > +	return 0;
> > +}

[snip]

> > +static u16 mt9p031_skip_for_crop(s32 source, s32 *target, s32 max_skip)
> > +{
> > +	unsigned int skip;
> > +
> > +	if (source - source / 4 < *target) {
> > +		*target = source;
> > +		return 1;
> > +	}
> > +
> > +	skip = DIV_ROUND_CLOSEST(source, *target);
> > +	if (skip > max_skip)
> > +		skip = max_skip;
> > +	*target = 2 * DIV_ROUND_UP(source, 2 * skip);
> > +
> > +	return skip;
> > +}
> > +
> > +static int mt9p031_set_params(struct i2c_client *client,
> > +			      struct v4l2_rect *rect, u16 xskip, u16 yskip)
> > +{
> > +	struct mt9p031 *mt9p031 = to_mt9p031(client);
> > +	int ret;
> > +	u16 xbin, ybin;
> > +	const u16 hblank = MT9P031_H_BLANKING_VALUE,
> > +		vblank = MT9P031_V_BLANKING_VALUE;
> > +	/*
> > +	 * TODO: Attention! When implementing horizontal flipping, adjust
> > +	 * alignment according to R2 "Column Start" description in the
> > datasheet +	 */
> > +	if (xskip & 1) {
> > +		xbin = 1;
> > +		rect->left &= ~3;
> > +	} else if (xskip & 2) {
> > +		xbin = 2;
> > +		rect->left &= ~7;
> > +	} else {
> > +		xbin = 4;
> > +		rect->left &= ~15;
> > +	}

Please don't modify the rectangle here. It needs to have been properly 
validated and/or modified before mt9p031_set_params() is called. This function 
should *only* apply parameters to the chip (possibly computing some of them on 
the fly). It must not modify any parameter.

> > +
> > +	ybin = min(yskip, (u16)4);
> > +
> > +	rect->top &= ~1;
> > +
> > +	/* Disable register update, reconfigure atomically */
> > +	ret = mt9p031_set_output_control(mt9p031, 0,
> > MT9P031_OUTPUT_CONTROL_SYN); +	if (ret < 0)
> > +		return ret;
> > +
> > +	dev_dbg(&client->dev, "skip %u:%u, rect %ux%u@%u:%u\n",
> > +		xskip, yskip, rect->width, rect->height, rect->left, rect->top);
> > +
> > +	/* Blanking and start values - default... */
> > +	ret = reg_write(client, MT9P031_H_BLANKING, hblank);
> > +	if (ret < 0)
> > +		return ret;
> > +	ret = reg_write(client, MT9P031_V_BLANKING, vblank);
> > +	if (ret < 0)
> > +		return ret;
> > +
> > +	ret = reg_write(client, MT9P031_COLUMN_ADDRESS_MODE,
> > +				((xbin - 1) << 4) | (xskip - 1));
> > +	if (ret < 0)
> > +		return ret;
> > +	ret = reg_write(client, MT9P031_ROW_ADDRESS_MODE,
> > +				((ybin - 1) << 4) | (yskip - 1));
> > +	if (ret < 0)
> > +		return ret;
> > +
> > +	dev_dbg(&client->dev, "new physical left %u, top %u\n",
> > +		rect->left, rect->top);
> > +
> > +	ret = reg_write(client, MT9P031_COLUMN_START,
> > +				rect->left + MT9P031_COLUMN_START_SKIP);
> > +	if (ret < 0)
> > +		return ret;
> > +	ret = reg_write(client, MT9P031_ROW_START,
> > +				rect->top + MT9P031_ROW_START_SKIP);
> > +	if (ret < 0)
> > +		return ret;
> > +	ret = reg_write(client, MT9P031_WINDOW_WIDTH,
> > +				rect->width - 1);
> > +	if (ret < 0)
> > +		return ret;
> > +	ret = reg_write(client, MT9P031_WINDOW_HEIGHT,
> > +				rect->height - 1);
> > +	if (ret < 0)
> > +		return ret;
> > +
> > +	/* Re-enable register update, commit all changes */
> > +	ret = mt9p031_set_output_control(mt9p031, MT9P031_OUTPUT_CONTROL_SYN,
> > 0); +	if (ret < 0)
> > +		return ret;
> > +
> 
> Ditto with "ret = fn();"
> 
> > +	mt9p031->xskip = xskip;
> > +	mt9p031->yskip = yskip;
> > +	return ret;
> > +}
> > +
> > +static int mt9p031_set_crop(struct v4l2_subdev *sd,
> > +				struct v4l2_subdev_fh *fh,
> > +				struct v4l2_subdev_crop *crop)
> > +{
> > +	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
> > +	struct v4l2_mbus_framefmt *f;
> > +	struct v4l2_rect *c;
> > +	struct v4l2_rect rect;
> > +	u16 xskip, yskip;
> > +	s32 width, height;
> > +
> > +	pr_info("%s(%ux%u@%u:%u : %u)\n", __func__,
> > +			crop->rect.width, crop->rect.height,
> > +			crop->rect.left, crop->rect.top, crop->which);
> 
> dev_dbg()
> 
> > +
> > +	/*
> > +	 * Clamp the crop rectangle boundaries and align them to a multiple of
> > 2 +	 * pixels.
> > +	 */
> > +	rect.width = ALIGN(clamp(crop->rect.width,
> > +				 MT9P031_MIN_WIDTH, MT9P031_MAX_WIDTH), 2);
> > +	rect.height = ALIGN(clamp(crop->rect.height,
> > +				  MT9P031_MIN_HEIGHT, MT9P031_MAX_HEIGHT), 2);
> > +	rect.left = ALIGN(clamp(crop->rect.left,
> > +				0, MT9P031_MAX_WIDTH - rect.width), 2);
> > +	rect.top = ALIGN(clamp(crop->rect.top,
> > +			       0, MT9P031_MAX_HEIGHT - rect.height), 2);
> > +
> > +	c = mt9p031_get_pad_crop(mt9p031, fh, crop->pad, crop->which);
> > +
> > +	if (rect.width != c->width || rect.height != c->height) {
> > +		/*
> > +		 * Reset the output image size if the crop rectangle size has
> > +		 * been modified.
> > +		 */
> > +		f = mt9p031_get_pad_format(mt9p031, fh, crop->pad,
> > +						    crop->which);
> > +		width = f->width;
> > +		height = f->height;
> > +
> > +		xskip = mt9p031_skip_for_crop(rect.width, &width, 7);
> > +		yskip = mt9p031_skip_for_crop(rect.height, &height, 8);
> > +	} else {
> > +		xskip = mt9p031->xskip;
> > +		yskip = mt9p031->yskip;
> > +		f = NULL;
> > +	}
> 
> Hm, looks like something is missing here: you dropped
> 
> 	if (crop->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
> 		ret = mt9p031_set_params(client, &rect, xskip, yskip);
> 		if (ret < 0)
> 			return ret;
> 	}
> 
> from my version, without which no cropping is actually taking place. Or
> have you also switched to the convention of only configuring the hardware
> on set_stream(1)?

I think it's fine to configure formats at set_stream(1) time only, but crop 
rectangles should be settable when the stream is running. Their size can't 
change though. The mt9v032 driver doesn't support that, I need to fix it to 
provide a (hopefully) clean example of how to implement his.

> > +	if (f) {
> > +		f->width = width;
> > +		f->height = height;
> > +	}
> > +
> > +	*c = rect;
> > +	crop->rect = rect;
> > +
> > +	mt9p031->xskip = xskip;
> > +	mt9p031->yskip = yskip;
> > +	mt9p031->rect = *c;
> > +	return 0;
> > +}

[snip]

> > +static u16 mt9p031_skip_for_scale(s32 *source, s32 target,
> > +					s32 max_skip, s32 max)
> > +{
> > +	unsigned int skip;
> > +
> > +	if (*source - *source / 4 < target) {
> > +		*source = target;
> > +		return 1;
> > +	}
> > +
> > +	skip = min(max, *source + target / 2) / target;
> > +	if (skip > max_skip)
> > +		skip = max_skip;
> > +	*source = target * skip;
> > +
> > +	return skip;
> > +}
> > +
> > +static int mt9p031_fmt_validate(struct v4l2_subdev *sd,
> > +				struct v4l2_subdev_format *fmt)
> > +{
> > +	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
> > +	struct v4l2_mbus_framefmt *format = &fmt->format;
> > +
> > +	if (format->code != mt9p031->format.code || fmt->pad)
> > +		return -EINVAL;

There's no need to check pad->fmt, it has already been validated by 
subdev_do_ioctl().

You should also not return an error when the code is invalid. As the MT9P031 
only supports one code, you can just hardcode it

	format->code = V4L2_MBUS_FMT_SGRBG12_1X12;

> > +
> > +	format->colorspace = V4L2_COLORSPACE_SRGB;
> > +	format->width = clamp_t(int, ALIGN(format->width, 2), 2,
> > +						MT9P031_MAX_WIDTH);
> > +	format->height = clamp_t(int, ALIGN(format->height, 2), 2,
> > +						MT9P031_MAX_HEIGHT);
> > +	format->field = V4L2_FIELD_NONE;
> > +
> > +	return 0;
> > +}
> > +
> > +static int mt9p031_set_format(struct v4l2_subdev *sd,
> > +				struct v4l2_subdev_fh *fh,
> > +				struct v4l2_subdev_format *fmt)
> > +{
> > +	struct v4l2_subdev_format sdf = *fmt;
> > +	struct v4l2_mbus_framefmt *f, *format = &sdf.format;

Do you really need to make a copy of the requested format and work on it here 
? Can't you instead take the only fmt members that are configurable (width and 
height), clamp/mangle them, copy them to the mt9p031_get_pad_format() return 
pointer, and copy back the whole format structure to userspace ? Have a look 
at the mt9v032_set_format() function, I think it's easier to understand than 
what mt9p031_set_format() does.

> > +	struct v4l2_rect *c, rect;
> > +	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
> > +	u16 xskip, yskip;
> > +	int ret;
> > +
> > +	ret = mt9p031_fmt_validate(sd, &sdf);
> > +	if (ret < 0)
> > +		return ret;
> > +
> > +	f = mt9p031_get_pad_format(mt9p031, fh, fmt->pad, fmt->which);
> > +
> > +	if (f->width == format->width && f->height == format->height)
> > +		return 0;

If width and height match, the other fields won't be copied back to userspace.

Please consider copying the mt9v032_set_format() code, unless you think it's 
not applicable for the mt9p031.

> > +
> > +
> 
> One empty line is usually enough, especially inside a function.
> 
> > +	c = mt9p031_get_pad_crop(mt9p031, fh, fmt->pad, fmt->which);
> > +
> > +	rect.width = c->width;
> > +	rect.height = c->height;
> > +
> > +	xskip = mt9p031_skip_for_scale(&rect.width, format->width, 7,
> > +				       MT9P031_MAX_WIDTH);
> > +	if (rect.width + c->left > MT9P031_MAX_WIDTH)
> > +		rect.left = (MT9P031_MAX_WIDTH - rect.width) / 2;
> > +	else
> > +		rect.left = c->left;
> > +	yskip = mt9p031_skip_for_scale(&rect.height, format->height, 8,
> > +				       MT9P031_MAX_HEIGHT);
> > +	if (rect.height + c->top > MT9P031_MAX_HEIGHT)
> > +		rect.top = (MT9P031_MAX_HEIGHT - rect.height) / 2;
> > +	else
> > +		rect.top = c->top;
> > +
> > +
> > +	pr_info("%s(%ux%u : %u)\n", __func__,
> > +		format->width, format->height, fmt->which);
> 
> dev_dbg()
> 
> > +	if (c)
> > +		*c = rect;
> > +
> > +	*f = *format;
> > +	fmt->format = *format;
> > +
> > +	mt9p031->xskip = xskip;
> > +	mt9p031->yskip = yskip;
> > +	mt9p031->rect = *c;
> > +	return 0;
> > +}
> > +
> > +static int mt9p031_s_stream(struct v4l2_subdev *sd, int enable)
> > +{
> > +	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
> > +	struct i2c_client *client = v4l2_get_subdevdata(&mt9p031->subdev);
> > +	struct v4l2_rect rect = mt9p031->rect;
> > +	u16 xskip = mt9p031->xskip;
> > +	u16 yskip = mt9p031->yskip;
> > +	int ret;
> > +
> > +	if (enable) {
> > +		ret = mt9p031_set_params(client, &rect, xskip, yskip);

mt9p031_set_params() is only called here. Why don't you pass it the mt9p031 
pointer instead of the client pointer, and have it access the rectangle, xskip 
and yskip members directly ?

> > +		if (ret < 0)
> > +			return ret;
> > +		/* Switch to master "normal" mode */
> > +		ret = mt9p031_set_output_control(mt9p031, 0,
> > MT9P031_OUTPUT_CONTROL_CEN);
> > +	} else {
> > +		/* Stop sensor readout */
> > +		ret = mt9p031_set_output_control(mt9p031, MT9P031_OUTPUT_CONTROL_CEN,
> > 0);
> > +	}
> > +	if (ret < 0)
> > +		return -EIO;
> > +
> > +	return 0;

Just replace those 4 lines by return ret; or, even better, return the result 
of the above mt9p031_set_output_control() calls directly.

> > +}
> > +
> > +/*
> > + * 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

I'm not sure to see where/how you wait for the right one :-)

> > + */
> > +static int mt9p031_video_probe(struct i2c_client *client)
> > +{
> > +	s32 data;
> > +	int ret;
> > +
> > +	/* Read out the chip version register */
> > +	data = reg_read(client, MT9P031_CHIP_VERSION);
> > +	if (data != MT9P031_CHIP_VERSION_VALUE) {
> > +		dev_err(&client->dev,
> > +			"No MT9P031 chip detected, register read %x\n", data);
> > +		return -ENODEV;
> > +	}
> > +
> > +	dev_info(&client->dev, "Detected a MT9P031 chip ID %x\n", data);
> > +
> > +	ret = mt9p031_reset(client);
> > +	if (ret < 0)
> > +		dev_err(&client->dev, "Failed to initialise the camera\n");

If you move the soft-reset operation to mt9p031_power_on(), you don't need to 
call it here.

> > +	return ret;
> > +}

[snip]

> > +static int mt9p031_registered(struct v4l2_subdev *sd)
> > +{
> > +	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
> > +	struct i2c_client *client = v4l2_get_subdevdata(&mt9p031->subdev);
> > +	int ret;
> > +
> > +	ret = mt9p031_set_power(&mt9p031->subdev, 1);
> > +	if (ret) {
> > +		pr_err("Failed to power on device: %d\n", ret);
> 
> dev_err()
> 
> > +		goto pwron;

I would rename the goto labels to start with err_ or error_.

> > +	}
> > +	if (mt9p031->pdata->reset)
> > +		mt9p031->pdata->reset(&mt9p031->subdev, 1);
> > +	msleep(50);
> > +	if (mt9p031->pdata->reset)
> > +		mt9p031->pdata->reset(&mt9p031->subdev, 0);
> > +	msleep(50);

If there's no reset operation you don't need to msleep(), so something like

	if (mt9p031->pdata->reset) {
		mt9p031->pdata->reset(&mt9p031->subdev, 1);
		msleep(50);
		mt9p031->pdata->reset(&mt9p031->subdev, 0);
		msleep(50);
	}

is better. Where does the 50ms value come from ? It sounds quite long to me.

> > +
> > +	ret = mt9p031_video_probe(client);
> > +	if (ret)
> > +		goto evprobe;
> > +
> > +	mt9p031->pad.flags = MEDIA_PAD_FL_SOURCE;
> > +	ret = media_entity_init(&mt9p031->subdev.entity, 1, &mt9p031->pad, 0);
> > +	if (ret)
> > +		goto evprobe;
> > +
> > +	mt9p031->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
> > +	mt9p031_set_power(&mt9p031->subdev, 0);
> > +
> > +	return 0;
> > +evprobe:
> > +	mt9p031_set_power(&mt9p031->subdev, 0);
> > +pwron:
> > +	return ret;
> > +}
> > +
> > +static int mt9p031_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh
> > *fh) +{
> > +	struct mt9p031 *mt9p031;
> > +	mt9p031 = container_of(sd, struct mt9p031, subdev);
> > +
> > +	return mt9p031_set_power(sd, 1);
> 
> Is open() called only for the first open, or for each one? If for each,
> you'll want to reference count yourself. Besides, isn't
> core_ops::s_power() called anyway, maybe you don't need these open() /
> close() at all?

It's called for each open. mt9p031_set_power() includes reference counting, so 
this should be safe.

core_ops::s_power() isn't called on open().

Javier, you should also initialize the crop and format settings in 
v4l2_subdev_fh to default values. Please see the mt9v032 driver.

> > +}

[snip]

> > +static int mt9p031_probe(struct i2c_client *client,
> > +			 const struct i2c_device_id *did)
> > +{
> > +	struct mt9p031 *mt9p031;
> > +	struct mt9p031_platform_data *pdata = client->dev.platform_data;
> > +	struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
> > +	int ret;
> > +
> > +	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;
> > +	}
> > +
> > +	mt9p031 = kzalloc(sizeof(struct mt9p031), GFP_KERNEL);
> > +	if (!mt9p031)
> > +		return -ENOMEM;
> > +
> > +	mutex_init(&mt9p031->power_lock);
> > +	v4l2_i2c_subdev_init(&mt9p031->subdev, client, &mt9p031_subdev_ops);
> > +	mt9p031->subdev.internal_ops = &mt9p031_subdev_internal_ops;
> > +
> > +	mt9p031->pdata		= pdata;
> > +	mt9p031->rect.left	= 0;
> > +	mt9p031->rect.top	= 0;
> 
> No need - kzalloc() has nullified it for you.

According to the datasheet, the Row Start and Column Start default values are 
54 and 16. You should use them instead of 0 (and add #define's for them at the 
beginning of the file). You should expose the real sensor coordinates through 
the crop operations, don't try to add/subtract offsets internally in the 
driver.

> > +	mt9p031->rect.width	= MT9P031_MAX_WIDTH;
> > +	mt9p031->rect.height	= MT9P031_MAX_HEIGHT;
> > +
> > +	mt9p031->format.code = V4L2_MBUS_FMT_SGRBG12_1X12;
> > +
> > +	mt9p031->format.width = MT9P031_MAX_WIDTH;
> > +	mt9p031->format.height = MT9P031_MAX_HEIGHT;
> > +	mt9p031->format.field = V4L2_FIELD_NONE;
> > +	mt9p031->format.colorspace = V4L2_COLORSPACE_SRGB;
> > +
> > +	mt9p031->xskip = 1;
> > +	mt9p031->yskip = 1;
> > +
> > +	mt9p031->reg_1v8 = regulator_get(NULL, "cam_1v8");
> > +	if (IS_ERR(mt9p031->reg_1v8)) {
> > +		ret = PTR_ERR(mt9p031->reg_1v8);
> > +		pr_err("Failed 1.8v regulator: %d\n", ret);
> 
> dev_err()
> 
> > +		goto e1v8;
> > +	}

The driver can be used with boards where either or both of the 1.8V and 2.8V 
supplies are always on, thus not connected to any regulator. I'm not sure how 
that's usually handled, if board code should define an "always-on" power 
supply, or if the driver shouldn't fail when no regulator is present. In any 
case, this must be handled.

> > +
> > +	mt9p031->reg_2v8 = regulator_get(NULL, "cam_2v8");
> > +	if (IS_ERR(mt9p031->reg_2v8)) {
> > +		ret = PTR_ERR(mt9p031->reg_2v8);
> > +		pr_err("Failed 2.8v regulator: %d\n", ret);
> 
> ditto
> 
> > +		goto e2v8;
> > +	}
> > +	/* turn on core */
> > +	ret = regulator_enable(mt9p031->reg_1v8);
> > +	if (ret) {
> > +		pr_err("Failed to enable 1.8v regulator: %d\n", ret);
> 
> ditto
> 
> > +		goto e1v8en;
> > +	}
> > +	return 0;

Why do you leave core power on at the end of probe() ? You should only turn it 
on when needed.

> > +e1v8en:
> > +	regulator_put(mt9p031->reg_2v8);
> > +e2v8:
> > +	regulator_put(mt9p031->reg_1v8);
> > +e1v8:
> > +	kfree(mt9p031);
> > +	return ret;
> > +}

Laurent Pinchart May 23, 2011, 9:08 a.m. UTC | #7

Hi Guennadi,

On Monday 23 May 2011 10:48:36 Guennadi Liakhovetski wrote:
> On Mon, 23 May 2011, javier Martin wrote:
> > On 21 May 2011 17:29, Guennadi Liakhovetski <[e-mail]> wrote:
> > > On Fri, 20 May 2011, Javier Martin wrote:
> > >> This driver adds basic support for Aptina mt9p031 sensor.
> > >> 
> > >> Signed-off-by: Javier Martin <[e-mail]>
> > >> ---
> > >>  drivers/media/video/Kconfig   |    8 +
> > >>  drivers/media/video/Makefile  |    1 +
> > >>  drivers/media/video/mt9p031.c |  751
> > >> +++++++++++++++++++++++++++++++++++++++++ include/media/mt9p031.h    
> > >>   |   11 +
> > >>  4 files changed, 771 insertions(+), 0 deletions(-)
> > >>  create mode 100644 drivers/media/video/mt9p031.c
> > >>  create mode 100644 include/media/mt9p031.h
> > >> 
> > >> diff --git a/drivers/media/video/mt9p031.c
> > >> b/drivers/media/video/mt9p031.c new file mode 100644
> > >> index 0000000..e406b64
> > >> --- /dev/null
> > >> +++ b/drivers/media/video/mt9p031.c
> > >> @@ -0,0 +1,751 @@
> > >> +/*
> > >> + * Driver for MT9P031 CMOS Image Sensor from Aptina
> > >> + *
> > >> + * Copyright (C) 2011, Javier Martin
> > >> <[e-mail]> + *
> > >> + * Copyright (C) 2011, Guennadi Liakhovetski <[e-mail]>
> > >> + *
> > >> + * Based on the MT9V032 driver and Bastian Hecht's code.
> > >> + *
> > >> + * 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/device.h>
> > >> +#include <linux/i2c.h>
> > >> +#include <linux/log2.h>
> > >> +#include <linux/pm.h>
> > >> +#include <linux/regulator/consumer.h>
> > >> +#include <linux/slab.h>
> > >> +#include <media/v4l2-subdev.h>
> > >> +#include <linux/videodev2.h>
> > >> +
> > >> +#include <media/mt9p031.h>
> > >> +#include <media/v4l2-chip-ident.h>
> > >> +#include <media/v4l2-subdev.h>
> > >> +#include <media/v4l2-device.h>
> > >> +
> > >> +/* mt9p031 selected register addresses */
> > >> +#define MT9P031_CHIP_VERSION                 0x00
> > >> +#define              MT9P031_CHIP_VERSION_VALUE      0x1801
> > >> +#define MT9P031_ROW_START                    0x01
> > > 
> > > Don't mix spaces and TABs between "#define" and the macro - just use
> > > one space everywhere.
> > 
> > I've done this in order to follow Laurent's directions. He does the
> > same in mt9v032 driver.
> > So, unless Laurent and you agree I think I won't change it.
> 
> Ah, so, you use a space for registers and TABs for their values, ok then.
> 
> > >> +struct mt9p031 {
> > >> +     struct v4l2_subdev subdev;
> > >> +     struct media_pad pad;
> > >> +     struct v4l2_rect rect;  /* Sensor window */
> > >> +     struct v4l2_mbus_framefmt format;
> > >> +     struct mt9p031_platform_data *pdata;
> > >> +     struct mutex power_lock;
> > > 
> > > Don't locks _always_ have to be documented? And this one: you only
> > > protect set_power() with it, Laurent, is this correct?
> > 
> > Just following the model Laurent applies in mt9v032. Let's see what he
> > has to say about this.
> 
> Try running scripts/checkpatch.pl on your patch. I think, it will complain
> about this. And in general it's a good idea to run it before submission;)
> 
> > >> +static int mt9p031_reset(struct i2c_client *client)
> > >> +{
> > >> +     struct mt9p031 *mt9p031 = to_mt9p031(client);
> > >> +     int ret;
> > >> +
> > >> +     /* Disable chip output, synchronous option update */
> > >> +     ret = reg_write(client, MT9P031_RST, MT9P031_RST_ENABLE);
> > >> +     if (ret < 0)
> > >> +             return -EIO;
> > >> +     ret = reg_write(client, MT9P031_RST, MT9P031_RST_DISABLE);
> > >> +     if (ret < 0)
> > >> +             return -EIO;
> > >> +     ret = mt9p031_set_output_control(mt9p031,
> > >> MT9P031_OUTPUT_CONTROL_CEN, 0); +     if (ret < 0)
> > >> +             return -EIO;
> > >> +     return 0;
> > > 
> > > I think, a sequence like
> > > 
> > >        ret = fn();
> > >        if (!ret)
> > >                ret = fn();
> > >        if (!ret)
> > >                ret = fn();
> > >        return ret;
> > > 
> > > is a better way to achieve the same.
> > 
> > Sorry, but I have to disagree. I understand what you want to achieve
> > but this seems quite tricky to me.
> > I explicitly changed parts of the code that were written using that
> > style because I think It was better understandable.
> 
> Well, that was my opinion. Since Laurent will be taking this patch via his
> tree, his decision will be final, of course. But I think, he'll agree,
> that at least you have to be consistent across the driver. And at least
> you'd want to propagate your error code up to the caller instead of
> replacing it with "-EIO."

To follow up on my previous answer on this, I agree that the return value 
should be propagated instead of replacing it with -EIO.

Guennadi Liakhovetski May 23, 2011, 9:26 a.m. UTC | #8

On Mon, 23 May 2011, Laurent Pinchart wrote:

> > > +{
> > > +	struct mt9p031 *mt9p031 = to_mt9p031(client);
> > > +	int ret;
> > > +
> > > +	/* Disable chip output, synchronous option update */
> > > +	ret = reg_write(client, MT9P031_RST, MT9P031_RST_ENABLE);
> > > +	if (ret < 0)
> > > +		return -EIO;
> > > +	ret = reg_write(client, MT9P031_RST, MT9P031_RST_DISABLE);
> > > +	if (ret < 0)
> > > +		return -EIO;
> > > +	ret = mt9p031_set_output_control(mt9p031, MT9P031_OUTPUT_CONTROL_CEN,
> > > 0); +	if (ret < 0)
> > > +		return -EIO;
> > > +	return 0;
> > 
> > I think, a sequence like
> > 
> > 	ret = fn();
> > 	if (!ret)
> > 		ret = fn();
> > 	if (!ret)
> > 		ret = fn();
> > 	return ret;
> > 
> > is a better way to achieve the same.
> 
> I disagree with you on that :-) I find code sequences that return as soon as 
> an error occurs, using the main code path for the error-free case, easier to 
> read. It can be a matter of personal taste though.

Whichever way, but it should be consistent, IMHO.

Thanks
Guennadi
---
Guennadi Liakhovetski, Ph.D.
Freelance Open-Source Software Developer
http://www.open-technology.de/
--
To unsubscribe from this list: send the line "unsubscribe linux-media" in
the body of a message to [e-mail]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Javier Martin May 24, 2011, 8:31 a.m. UTC | #9

Hi, Laurent, Guennadi,
thank you for your review. I've already fixed most of the issues.

On 23 May 2011 11:03, Laurent Pinchart
<[e-mail]> wrote:
> Hi Guennadi and Javier,
>
> On Saturday 21 May 2011 17:29:18 Guennadi Liakhovetski wrote:
>> On Fri, 20 May 2011, Javier Martin wrote:
>
> [snip]
>
>> > diff --git a/drivers/media/video/mt9p031.c
>> > b/drivers/media/video/mt9p031.c new file mode 100644
>> > index 0000000..e406b64
>> > --- /dev/null
>> > +++ b/drivers/media/video/mt9p031.c
>
> [snip]
>> > +}
>> > +
>> > +static int mt9p031_power_on(struct mt9p031 *mt9p031)
>> > +{
>> > +   int ret;
>> > +
>> > +   /* turn on VDD_IO */
>> > +   ret = regulator_enable(mt9p031->reg_2v8);
>> > +   if (ret) {
>> > +           pr_err("Failed to enable 2.8v regulator: %d\n", ret);
>>
>> dev_err()
>>
>> > +           return ret;
>> > +   }
>> > +   if (mt9p031->pdata->set_xclk)
>> > +           mt9p031->pdata->set_xclk(&mt9p031->subdev, 54000000);
>
> Can you make 54000000 a #define at the beginning of the file ?
>
> You should soft-reset the chip here by calling mt9p031_reset().
>

If I do this, I would be force to cache some registers and restart
them. I've tried to do this but I don't know what is failing that
there are some artifacts consisting on horizontal black lines in the
image.
Please, let me push this to mainline without this feature as a first
step, since I'll have to spend some assigned to another project.

[snip]
>> > + */
>> > +static int mt9p031_video_probe(struct i2c_client *client)
>> > +{
>> > +   s32 data;
>> > +   int ret;
>> > +
>> > +   /* Read out the chip version register */
>> > +   data = reg_read(client, MT9P031_CHIP_VERSION);
>> > +   if (data != MT9P031_CHIP_VERSION_VALUE) {
>> > +           dev_err(&client->dev,
>> > +                   "No MT9P031 chip detected, register read %x\n", data);
>> > +           return -ENODEV;
>> > +   }
>> > +
>> > +   dev_info(&client->dev, "Detected a MT9P031 chip ID %x\n", data);
>> > +
>> > +   ret = mt9p031_reset(client);
>> > +   if (ret < 0)
>> > +           dev_err(&client->dev, "Failed to initialise the camera\n");
>
> If you move the soft-reset operation to mt9p031_power_on(), you don't need to
> call it here.
>

The reason for this is the same as before. I haven't still been able
to success on restarting registers and getting everything to work
fine.
It would be great if you allowed me to push this as it is as an
intermediate step.

[snip]
>
>> > +   mt9p031->rect.width     = MT9P031_MAX_WIDTH;
>> > +   mt9p031->rect.height    = MT9P031_MAX_HEIGHT;
>> > +
>> > +   mt9p031->format.code = V4L2_MBUS_FMT_SGRBG12_1X12;
>> > +
>> > +   mt9p031->format.width = MT9P031_MAX_WIDTH;
>> > +   mt9p031->format.height = MT9P031_MAX_HEIGHT;
>> > +   mt9p031->format.field = V4L2_FIELD_NONE;
>> > +   mt9p031->format.colorspace = V4L2_COLORSPACE_SRGB;
>> > +
>> > +   mt9p031->xskip = 1;
>> > +   mt9p031->yskip = 1;
>> > +
>> > +   mt9p031->reg_1v8 = regulator_get(NULL, "cam_1v8");
>> > +   if (IS_ERR(mt9p031->reg_1v8)) {
>> > +           ret = PTR_ERR(mt9p031->reg_1v8);
>> > +           pr_err("Failed 1.8v regulator: %d\n", ret);
>>
>> dev_err()
>>
>> > +           goto e1v8;
>> > +   }
>
> The driver can be used with boards where either or both of the 1.8V and 2.8V
> supplies are always on, thus not connected to any regulator. I'm not sure how
> that's usually handled, if board code should define an "always-on" power
> supply, or if the driver shouldn't fail when no regulator is present. In any
> case, this must be handled.
>

I think board code should define an "always-on" power supply.

>> > +
>> > +   mt9p031->reg_2v8 = regulator_get(NULL, "cam_2v8");
>> > +   if (IS_ERR(mt9p031->reg_2v8)) {
>> > +           ret = PTR_ERR(mt9p031->reg_2v8);
>> > +           pr_err("Failed 2.8v regulator: %d\n", ret);
>>
>> ditto
>>
>> > +           goto e2v8;
>> > +   }
>> > +   /* turn on core */
>> > +   ret = regulator_enable(mt9p031->reg_1v8);
>> > +   if (ret) {
>> > +           pr_err("Failed to enable 1.8v regulator: %d\n", ret);
>>
>> ditto
>>
>> > +           goto e1v8en;
>> > +   }
>> > +   return 0;
>
> Why do you leave core power on at the end of probe() ? You should only turn it
> on when needed.
>

Just as I said, because restarting registers does not work yet.

Laurent Pinchart May 24, 2011, 8:39 a.m. UTC | #10

Hi Javier,

On Tuesday 24 May 2011 10:31:46 javier Martin wrote:
> On 23 May 2011 11:03, Laurent Pinchart wrote:
> > On Saturday 21 May 2011 17:29:18 Guennadi Liakhovetski wrote:
> >> On Fri, 20 May 2011, Javier Martin wrote:
> > [snip]
> > 
> >> > diff --git a/drivers/media/video/mt9p031.c
> >> > b/drivers/media/video/mt9p031.c new file mode 100644
> >> > index 0000000..e406b64
> >> > --- /dev/null
> >> > +++ b/drivers/media/video/mt9p031.c
> > 
> > [snip]
> > 
> >> > +}
> >> > +
> >> > +static int mt9p031_power_on(struct mt9p031 *mt9p031)
> >> > +{
> >> > +   int ret;
> >> > +
> >> > +   /* turn on VDD_IO */
> >> > +   ret = regulator_enable(mt9p031->reg_2v8);
> >> > +   if (ret) {
> >> > +           pr_err("Failed to enable 2.8v regulator: %d\n", ret);
> >> 
> >> dev_err()
> >> 
> >> > +           return ret;
> >> > +   }
> >> > +   if (mt9p031->pdata->set_xclk)
> >> > +           mt9p031->pdata->set_xclk(&mt9p031->subdev, 54000000);
> > 
> > Can you make 54000000 a #define at the beginning of the file ?
> > 
> > You should soft-reset the chip here by calling mt9p031_reset().
> 
> If I do this, I would be force to cache some registers and restart
> them. I've tried to do this but I don't know what is failing that
> there are some artifacts consisting on horizontal black lines in the
> image.

You need to cache registers anyway, as the chip will be reset to default 
values by the core power cycling. And as I'm writing those lines I realize 
that you don't power cycle reg_1v8. This needs to be done to save power.

> Please, let me push this to mainline without this feature as a first
> step, since I'll have to spend some assigned to another project.

Power handling is an important feature. I don't think the driver is ready 
without it. 

> [snip]
> 
> >> > + */
> >> > +static int mt9p031_video_probe(struct i2c_client *client)
> >> > +{
> >> > +   s32 data;
> >> > +   int ret;
> >> > +
> >> > +   /* Read out the chip version register */
> >> > +   data = reg_read(client, MT9P031_CHIP_VERSION);
> >> > +   if (data != MT9P031_CHIP_VERSION_VALUE) {
> >> > +           dev_err(&client->dev,
> >> > +                   "No MT9P031 chip detected, register read %x\n",
> >> > data); +           return -ENODEV;
> >> > +   }
> >> > +
> >> > +   dev_info(&client->dev, "Detected a MT9P031 chip ID %x\n", data);
> >> > +
> >> > +   ret = mt9p031_reset(client);
> >> > +   if (ret < 0)
> >> > +           dev_err(&client->dev, "Failed to initialise the
> >> > camera\n");
> > 
> > If you move the soft-reset operation to mt9p031_power_on(), you don't
> > need to call it here.
> 
> The reason for this is the same as before. I haven't still been able
> to success on restarting registers and getting everything to work
> fine.
> It would be great if you allowed me to push this as it is as an
> intermediate step.

Sorry, but I'd like to see power management properly implemented before the 
driver hits mainline. Other less important features (such as exposure/gain 
controls for instance) can be missing, but proper power management is 
important.

> [snip]
> 
> >> > +   mt9p031->rect.width     = MT9P031_MAX_WIDTH;
> >> > +   mt9p031->rect.height    = MT9P031_MAX_HEIGHT;
> >> > +
> >> > +   mt9p031->format.code = V4L2_MBUS_FMT_SGRBG12_1X12;
> >> > +
> >> > +   mt9p031->format.width = MT9P031_MAX_WIDTH;
> >> > +   mt9p031->format.height = MT9P031_MAX_HEIGHT;
> >> > +   mt9p031->format.field = V4L2_FIELD_NONE;
> >> > +   mt9p031->format.colorspace = V4L2_COLORSPACE_SRGB;
> >> > +
> >> > +   mt9p031->xskip = 1;
> >> > +   mt9p031->yskip = 1;
> >> > +
> >> > +   mt9p031->reg_1v8 = regulator_get(NULL, "cam_1v8");
> >> > +   if (IS_ERR(mt9p031->reg_1v8)) {
> >> > +           ret = PTR_ERR(mt9p031->reg_1v8);
> >> > +           pr_err("Failed 1.8v regulator: %d\n", ret);
> >> 
> >> dev_err()
> >> 
> >> > +           goto e1v8;
> >> > +   }
> > 
> > The driver can be used with boards where either or both of the 1.8V and
> > 2.8V supplies are always on, thus not connected to any regulator. I'm
> > not sure how that's usually handled, if board code should define an
> > "always-on" power supply, or if the driver shouldn't fail when no
> > regulator is present. In any case, this must be handled.
> 
> I think board code should define an "always-on" power supply.

Fine with me. How is that done BTW ?

> >> > +
> >> > +   mt9p031->reg_2v8 = regulator_get(NULL, "cam_2v8");
> >> > +   if (IS_ERR(mt9p031->reg_2v8)) {
> >> > +           ret = PTR_ERR(mt9p031->reg_2v8);
> >> > +           pr_err("Failed 2.8v regulator: %d\n", ret);
> >> 
> >> ditto
> >> 
> >> > +           goto e2v8;
> >> > +   }
> >> > +   /* turn on core */
> >> > +   ret = regulator_enable(mt9p031->reg_1v8);
> >> > +   if (ret) {
> >> > +           pr_err("Failed to enable 1.8v regulator: %d\n", ret);
> >> 
> >> ditto
> >> 
> >> > +           goto e1v8en;
> >> > +   }
> >> > +   return 0;
> > 
> > Why do you leave core power on at the end of probe() ? You should only
> > turn it on when needed.
> 
> Just as I said, because restarting registers does not work yet.

Javier Martin May 24, 2011, 8:56 a.m. UTC | #11

On 24 May 2011 10:39, Laurent Pinchart
<[e-mail]> wrote:
> Hi Javier,
>
> On Tuesday 24 May 2011 10:31:46 javier Martin wrote:
>> On 23 May 2011 11:03, Laurent Pinchart wrote:
>> > On Saturday 21 May 2011 17:29:18 Guennadi Liakhovetski wrote:
>> >> On Fri, 20 May 2011, Javier Martin wrote:
>> > [snip]
>> >
>> >> > diff --git a/drivers/media/video/mt9p031.c
>> >> > b/drivers/media/video/mt9p031.c new file mode 100644
>> >> > index 0000000..e406b64
>> >> > --- /dev/null
>> >> > +++ b/drivers/media/video/mt9p031.c
>> >
>> > [snip]
>> >
>> >> > +}
>> >> > +
>> >> > +static int mt9p031_power_on(struct mt9p031 *mt9p031)
>> >> > +{
>> >> > +   int ret;
>> >> > +
>> >> > +   /* turn on VDD_IO */
>> >> > +   ret = regulator_enable(mt9p031->reg_2v8);
>> >> > +   if (ret) {
>> >> > +           pr_err("Failed to enable 2.8v regulator: %d\n", ret);
>> >>
>> >> dev_err()
>> >>
>> >> > +           return ret;
>> >> > +   }
>> >> > +   if (mt9p031->pdata->set_xclk)
>> >> > +           mt9p031->pdata->set_xclk(&mt9p031->subdev, 54000000);
>> >
>> > Can you make 54000000 a #define at the beginning of the file ?
>> >
>> > You should soft-reset the chip here by calling mt9p031_reset().
>>
>> If I do this, I would be force to cache some registers and restart
>> them. I've tried to do this but I don't know what is failing that
>> there are some artifacts consisting on horizontal black lines in the
>> image.
>
> You need to cache registers anyway, as the chip will be reset to default
> values by the core power cycling. And as I'm writing those lines I realize
> that you don't power cycle reg_1v8. This needs to be done to save power.
>
>> Please, let me push this to mainline without this feature as a first
>> step, since I'll have to spend some assigned to another project.
>
> Power handling is an important feature. I don't think the driver is ready
> without it.
>
>> [snip]
>>
>> >> > + */
>> >> > +static int mt9p031_video_probe(struct i2c_client *client)
>> >> > +{
>> >> > +   s32 data;
>> >> > +   int ret;
>> >> > +
>> >> > +   /* Read out the chip version register */
>> >> > +   data = reg_read(client, MT9P031_CHIP_VERSION);
>> >> > +   if (data != MT9P031_CHIP_VERSION_VALUE) {
>> >> > +           dev_err(&client->dev,
>> >> > +                   "No MT9P031 chip detected, register read %x\n",
>> >> > data); +           return -ENODEV;
>> >> > +   }
>> >> > +
>> >> > +   dev_info(&client->dev, "Detected a MT9P031 chip ID %x\n", data);
>> >> > +
>> >> > +   ret = mt9p031_reset(client);
>> >> > +   if (ret < 0)
>> >> > +           dev_err(&client->dev, "Failed to initialise the
>> >> > camera\n");
>> >
>> > If you move the soft-reset operation to mt9p031_power_on(), you don't
>> > need to call it here.
>>
>> The reason for this is the same as before. I haven't still been able
>> to success on restarting registers and getting everything to work
>> fine.
>> It would be great if you allowed me to push this as it is as an
>> intermediate step.
>
> Sorry, but I'd like to see power management properly implemented before the
> driver hits mainline. Other less important features (such as exposure/gain
> controls for instance) can be missing, but proper power management is
> important.
>

OK, I'll focus on this feature from now on. However, I can't guarantee
that I won't be removed from the project in the process. If that
happens I will send my current patches to the community and someone
else will have to complete the job.
>> [snip]
>>
>> >> > +   mt9p031->rect.width     = MT9P031_MAX_WIDTH;
>> >> > +   mt9p031->rect.height    = MT9P031_MAX_HEIGHT;
>> >> > +
>> >> > +   mt9p031->format.code = V4L2_MBUS_FMT_SGRBG12_1X12;
>> >> > +
>> >> > +   mt9p031->format.width = MT9P031_MAX_WIDTH;
>> >> > +   mt9p031->format.height = MT9P031_MAX_HEIGHT;
>> >> > +   mt9p031->format.field = V4L2_FIELD_NONE;
>> >> > +   mt9p031->format.colorspace = V4L2_COLORSPACE_SRGB;
>> >> > +
>> >> > +   mt9p031->xskip = 1;
>> >> > +   mt9p031->yskip = 1;
>> >> > +
>> >> > +   mt9p031->reg_1v8 = regulator_get(NULL, "cam_1v8");
>> >> > +   if (IS_ERR(mt9p031->reg_1v8)) {
>> >> > +           ret = PTR_ERR(mt9p031->reg_1v8);
>> >> > +           pr_err("Failed 1.8v regulator: %d\n", ret);
>> >>
>> >> dev_err()
>> >>
>> >> > +           goto e1v8;
>> >> > +   }
>> >
>> > The driver can be used with boards where either or both of the 1.8V and
>> > 2.8V supplies are always on, thus not connected to any regulator. I'm
>> > not sure how that's usually handled, if board code should define an
>> > "always-on" power supply, or if the driver shouldn't fail when no
>> > regulator is present. In any case, this must be handled.
>>
>> I think board code should define an "always-on" power supply.
>
> Fine with me. How is that done BTW ?
>

You can use a fixed regulator for that purpose:
http://lxr.linux.no/#linux+v2.6.37.2/include/linux/regulator/fixed.h

Laurent Pinchart May 24, 2011, 8:58 a.m. UTC | #12

Hi Javier,

On Tuesday 24 May 2011 10:56:22 javier Martin wrote:
> On 24 May 2011 10:39, Laurent Pinchart wrote:
> > On Tuesday 24 May 2011 10:31:46 javier Martin wrote:
> >> On 23 May 2011 11:03, Laurent Pinchart wrote:
> >> > On Saturday 21 May 2011 17:29:18 Guennadi Liakhovetski wrote:
> >> >> On Fri, 20 May 2011, Javier Martin wrote:
> >> > [snip]
> >> > 
> >> >> > diff --git a/drivers/media/video/mt9p031.c
> >> >> > b/drivers/media/video/mt9p031.c new file mode 100644
> >> >> > index 0000000..e406b64
> >> >> > --- /dev/null
> >> >> > +++ b/drivers/media/video/mt9p031.c
> >> > 
> >> > [snip]
> >> > 
> >> >> > +}
> >> >> > +
> >> >> > +static int mt9p031_power_on(struct mt9p031 *mt9p031)
> >> >> > +{
> >> >> > +   int ret;
> >> >> > +
> >> >> > +   /* turn on VDD_IO */
> >> >> > +   ret = regulator_enable(mt9p031->reg_2v8);
> >> >> > +   if (ret) {
> >> >> > +           pr_err("Failed to enable 2.8v regulator: %d\n", ret);
> >> >> 
> >> >> dev_err()
> >> >> 
> >> >> > +           return ret;
> >> >> > +   }
> >> >> > +   if (mt9p031->pdata->set_xclk)
> >> >> > +           mt9p031->pdata->set_xclk(&mt9p031->subdev, 54000000);
> >> > 
> >> > Can you make 54000000 a #define at the beginning of the file ?
> >> > 
> >> > You should soft-reset the chip here by calling mt9p031_reset().
> >> 
> >> If I do this, I would be force to cache some registers and restart
> >> them. I've tried to do this but I don't know what is failing that
> >> there are some artifacts consisting on horizontal black lines in the
> >> image.
> > 
> > You need to cache registers anyway, as the chip will be reset to default
> > values by the core power cycling. And as I'm writing those lines I
> > realize that you don't power cycle reg_1v8. This needs to be done to
> > save power.
> > 
> >> Please, let me push this to mainline without this feature as a first
> >> step, since I'll have to spend some assigned to another project.
> > 
> > Power handling is an important feature. I don't think the driver is ready
> > without it.
> > 
> >> [snip]
> >> 
> >> >> > + */
> >> >> > +static int mt9p031_video_probe(struct i2c_client *client)
> >> >> > +{
> >> >> > +   s32 data;
> >> >> > +   int ret;
> >> >> > +
> >> >> > +   /* Read out the chip version register */
> >> >> > +   data = reg_read(client, MT9P031_CHIP_VERSION);
> >> >> > +   if (data != MT9P031_CHIP_VERSION_VALUE) {
> >> >> > +           dev_err(&client->dev,
> >> >> > +                   "No MT9P031 chip detected, register read %x\n",
> >> >> > data); +           return -ENODEV;
> >> >> > +   }
> >> >> > +
> >> >> > +   dev_info(&client->dev, "Detected a MT9P031 chip ID %x\n",
> >> >> > data); +
> >> >> > +   ret = mt9p031_reset(client);
> >> >> > +   if (ret < 0)
> >> >> > +           dev_err(&client->dev, "Failed to initialise the
> >> >> > camera\n");
> >> > 
> >> > If you move the soft-reset operation to mt9p031_power_on(), you don't
> >> > need to call it here.
> >> 
> >> The reason for this is the same as before. I haven't still been able
> >> to success on restarting registers and getting everything to work
> >> fine.
> >> It would be great if you allowed me to push this as it is as an
> >> intermediate step.
> > 
> > Sorry, but I'd like to see power management properly implemented before
> > the driver hits mainline. Other less important features (such as
> > exposure/gain controls for instance) can be missing, but proper power
> > management is important.
> 
> OK, I'll focus on this feature from now on. However, I can't guarantee
> that I won't be removed from the project in the process. If that
> happens I will send my current patches to the community and someone
> else will have to complete the job.

I understand. I could take over but I don't have an MT9P031 hardware :-S

> >> [snip]
> >> 
> >> >> > +   mt9p031->rect.width     = MT9P031_MAX_WIDTH;
> >> >> > +   mt9p031->rect.height    = MT9P031_MAX_HEIGHT;
> >> >> > +
> >> >> > +   mt9p031->format.code = V4L2_MBUS_FMT_SGRBG12_1X12;
> >> >> > +
> >> >> > +   mt9p031->format.width = MT9P031_MAX_WIDTH;
> >> >> > +   mt9p031->format.height = MT9P031_MAX_HEIGHT;
> >> >> > +   mt9p031->format.field = V4L2_FIELD_NONE;
> >> >> > +   mt9p031->format.colorspace = V4L2_COLORSPACE_SRGB;
> >> >> > +
> >> >> > +   mt9p031->xskip = 1;
> >> >> > +   mt9p031->yskip = 1;
> >> >> > +
> >> >> > +   mt9p031->reg_1v8 = regulator_get(NULL, "cam_1v8");
> >> >> > +   if (IS_ERR(mt9p031->reg_1v8)) {
> >> >> > +           ret = PTR_ERR(mt9p031->reg_1v8);
> >> >> > +           pr_err("Failed 1.8v regulator: %d\n", ret);
> >> >> 
> >> >> dev_err()
> >> >> 
> >> >> > +           goto e1v8;
> >> >> > +   }
> >> > 
> >> > The driver can be used with boards where either or both of the 1.8V
> >> > and 2.8V supplies are always on, thus not connected to any regulator.
> >> > I'm not sure how that's usually handled, if board code should define
> >> > an "always-on" power supply, or if the driver shouldn't fail when no
> >> > regulator is present. In any case, this must be handled.
> >> 
> >> I think board code should define an "always-on" power supply.
> > 
> > Fine with me. How is that done BTW ?
> 
> You can use a fixed regulator for that purpose:
> http://lxr.linux.no/#linux+v2.6.37.2/include/linux/regulator/fixed.h

struct fixed_voltage_config is meant to be passed to drivers through platform 
data. It doesn't declare an "always-on" regulator.

Patch

diff --git a/drivers/media/video/Kconfig b/drivers/media/video/Kconfig
index 00f51dd..5c96b89 100644
--- a/drivers/media/video/Kconfig
+++ b/drivers/media/video/Kconfig
@@ -329,6 +329,14 @@  config VIDEO_OV7670
 	  OV7670 VGA camera.  It currently only works with the M88ALP01
 	  controller.
 
+config VIDEO_MT9P031
+	tristate "Aptina MT9P031 support"
+	depends on I2C && VIDEO_V4L2
+	---help---
+	  This driver supports MT9P031 cameras from Micron
+	  This is a Video4Linux2 sensor-level driver for the Micron
+	  mt0p031 5 Mpixel camera.
+
 config VIDEO_MT9V011
 	tristate "Micron mt9v011 sensor support"
 	depends on I2C && VIDEO_V4L2
diff --git a/drivers/media/video/Makefile b/drivers/media/video/Makefile
index ace5d8b..912b29b 100644
--- a/drivers/media/video/Makefile
+++ b/drivers/media/video/Makefile
@@ -65,6 +65,7 @@  obj-$(CONFIG_VIDEO_UPD64083) += upd64083.o
 obj-$(CONFIG_VIDEO_OV7670) 	+= ov7670.o
 obj-$(CONFIG_VIDEO_TCM825X) += tcm825x.o
 obj-$(CONFIG_VIDEO_TVEEPROM) += tveeprom.o
+obj-$(CONFIG_VIDEO_MT9P031) += mt9p031.o
 obj-$(CONFIG_VIDEO_MT9V011) += mt9v011.o
 obj-$(CONFIG_VIDEO_SR030PC30)	+= sr030pc30.o
 obj-$(CONFIG_VIDEO_NOON010PC30)	+= noon010pc30.o
diff --git a/drivers/media/video/mt9p031.c b/drivers/media/video/mt9p031.c
new file mode 100644
index 0000000..e406b64
--- /dev/null
+++ b/drivers/media/video/mt9p031.c
@@ -0,0 +1,751 @@ 
+/*
+ * Driver for MT9P031 CMOS Image Sensor from Aptina
+ *
+ * Copyright (C) 2011, Javier Martin <[e-mail]>
+ *
+ * Copyright (C) 2011, Guennadi Liakhovetski <[e-mail]>
+ *
+ * Based on the MT9V032 driver and Bastian Hecht's code.
+ *
+ * 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/device.h>
+#include <linux/i2c.h>
+#include <linux/log2.h>
+#include <linux/pm.h>
+#include <linux/regulator/consumer.h>
+#include <linux/slab.h>
+#include <media/v4l2-subdev.h>
+#include <linux/videodev2.h>
+
+#include <media/mt9p031.h>
+#include <media/v4l2-chip-ident.h>
+#include <media/v4l2-subdev.h>
+#include <media/v4l2-device.h>
+
+/* mt9p031 selected register addresses */
+#define MT9P031_CHIP_VERSION			0x00
+#define		MT9P031_CHIP_VERSION_VALUE	0x1801
+#define MT9P031_ROW_START			0x01
+#define		MT9P031_ROW_START_SKIP		54
+#define MT9P031_COLUMN_START			0x02
+#define		MT9P031_COLUMN_START_SKIP	16
+#define MT9P031_WINDOW_HEIGHT			0x03
+#define MT9P031_WINDOW_WIDTH			0x04
+#define MT9P031_H_BLANKING			0x05
+#define		MT9P031_H_BLANKING_VALUE	0
+#define MT9P031_V_BLANKING			0x06
+#define		MT9P031_V_BLANKING_VALUE	25
+#define MT9P031_OUTPUT_CONTROL			0x07
+#define		MT9P031_OUTPUT_CONTROL_CEN	2
+#define		MT9P031_OUTPUT_CONTROL_SYN	1
+#define MT9P031_SHUTTER_WIDTH_UPPER		0x08
+#define MT9P031_SHUTTER_WIDTH			0x09
+#define MT9P031_PIXEL_CLOCK_CONTROL		0x0a
+#define MT9P031_FRAME_RESTART			0x0b
+#define MT9P031_SHUTTER_DELAY			0x0c
+#define MT9P031_RST				0x0d
+#define		MT9P031_RST_ENABLE		1
+#define		MT9P031_RST_DISABLE		0
+#define MT9P031_READ_MODE_1			0x1e
+#define MT9P031_READ_MODE_2			0x20
+#define		MT9P031_READ_MODE_2_ROW_MIR	0x8000
+#define		MT9P031_READ_MODE_2_COL_MIR	0x4000
+#define MT9P031_ROW_ADDRESS_MODE		0x22
+#define MT9P031_COLUMN_ADDRESS_MODE		0x23
+#define MT9P031_GLOBAL_GAIN			0x35
+
+#define MT9P031_MAX_HEIGHT			1944
+#define MT9P031_MAX_WIDTH			2592
+#define MT9P031_MIN_HEIGHT			2
+#define MT9P031_MIN_WIDTH			18
+
+struct mt9p031 {
+	struct v4l2_subdev subdev;
+	struct media_pad pad;
+	struct v4l2_rect rect;	/* Sensor window */
+	struct v4l2_mbus_framefmt format;
+	struct mt9p031_platform_data *pdata;
+	struct mutex power_lock;
+	int power_count;
+	u16 xskip;
+	u16 yskip;
+	u16 output_control;
+	struct regulator *reg_1v8;
+	struct regulator *reg_2v8;
+};
+
+static struct mt9p031 *to_mt9p031(const struct i2c_client *client)
+{
+	return container_of(i2c_get_clientdata(client), struct mt9p031, subdev);
+}
+
+static int reg_read(struct i2c_client *client, const u8 reg)
+{
+	s32 data = i2c_smbus_read_word_data(client, reg);
+	return data < 0 ? data : swab16(data);
+}
+	
+static int reg_write(struct i2c_client *client, const u8 reg,
+			const u16 data)
+{
+	return i2c_smbus_write_word_data(client, reg, swab16(data));
+}
+
+static int mt9p031_set_output_control(struct mt9p031 *mt9p031, u16 clear,
+				      u16 set)
+{
+	struct i2c_client *client = v4l2_get_subdevdata(&mt9p031->subdev);
+	u16 value = (mt9p031->output_control & ~clear) | set;
+	int ret;
+
+	ret = reg_write(client, MT9P031_OUTPUT_CONTROL, value);
+	if (ret < 0)
+		return ret;
+
+	mt9p031->output_control = value;
+	return 0;
+}
+
+static int mt9p031_reset(struct i2c_client *client)
+{
+	struct mt9p031 *mt9p031 = to_mt9p031(client);
+	int ret;
+
+	/* Disable chip output, synchronous option update */
+	ret = reg_write(client, MT9P031_RST, MT9P031_RST_ENABLE);
+	if (ret < 0)
+		return -EIO;
+	ret = reg_write(client, MT9P031_RST, MT9P031_RST_DISABLE);
+	if (ret < 0)
+		return -EIO;
+	ret = mt9p031_set_output_control(mt9p031, MT9P031_OUTPUT_CONTROL_CEN, 0);
+	if (ret < 0)
+		return -EIO;
+	return 0;
+}
+
+static int mt9p031_power_on(struct mt9p031 *mt9p031)
+{
+	int ret;
+
+	/* turn on VDD_IO */
+	ret = regulator_enable(mt9p031->reg_2v8);
+	if (ret) {
+		pr_err("Failed to enable 2.8v regulator: %d\n", ret);
+		return ret;
+	}
+	if (mt9p031->pdata->set_xclk)
+		mt9p031->pdata->set_xclk(&mt9p031->subdev, 54000000);
+
+	return 0;
+}
+
+static void mt9p031_power_off(struct mt9p031 *mt9p031)
+{
+	if (mt9p031->pdata->set_xclk)
+		mt9p031->pdata->set_xclk(&mt9p031->subdev, 0);
+	regulator_disable(mt9p031->reg_2v8);
+}
+
+static int mt9p031_enum_mbus_code(struct v4l2_subdev *sd,
+				struct v4l2_subdev_fh *fh,
+				struct v4l2_subdev_mbus_code_enum *code)
+{
+	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
+
+	if (code->pad || code->index)
+		return -EINVAL;
+
+	code->code = mt9p031->format.code;
+
+	return 0;
+}
+
+static struct v4l2_mbus_framefmt *mt9p031_get_pad_format(
+			struct mt9p031 *mt9p031,
+			struct v4l2_subdev_fh *fh,
+			unsigned int pad, u32 which)
+{
+	switch (which) {
+	case V4L2_SUBDEV_FORMAT_TRY:
+		return v4l2_subdev_get_try_format(fh, pad);
+	case V4L2_SUBDEV_FORMAT_ACTIVE:
+		return &mt9p031->format;
+	default:
+		return NULL;
+	}
+}
+
+static struct v4l2_rect *mt9p031_get_pad_crop(struct mt9p031 *mt9p031,
+			struct v4l2_subdev_fh *fh, unsigned int pad, u32 which)
+{
+	switch (which) {
+	case V4L2_SUBDEV_FORMAT_TRY:
+		return v4l2_subdev_get_try_crop(fh, pad);
+	case V4L2_SUBDEV_FORMAT_ACTIVE:
+		return &mt9p031->rect;
+	default:
+		return NULL;
+	}
+}
+
+static int mt9p031_get_crop(struct v4l2_subdev *sd,
+				struct v4l2_subdev_fh *fh,
+				struct v4l2_subdev_crop *crop)
+{
+	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
+	struct v4l2_rect *rect = mt9p031_get_pad_crop(mt9p031, fh, crop->pad,
+							crop->which);
+	if (!rect)
+		return -EINVAL;
+
+	crop->rect = *rect;
+
+	return 0;
+}
+
+static u16 mt9p031_skip_for_crop(s32 source, s32 *target, s32 max_skip)
+{
+	unsigned int skip;
+
+	if (source - source / 4 < *target) {
+		*target = source;
+		return 1;
+	}
+
+	skip = DIV_ROUND_CLOSEST(source, *target);
+	if (skip > max_skip)
+		skip = max_skip;
+	*target = 2 * DIV_ROUND_UP(source, 2 * skip);
+
+	return skip;
+}
+
+static int mt9p031_set_params(struct i2c_client *client,
+			      struct v4l2_rect *rect, u16 xskip, u16 yskip)
+{
+	struct mt9p031 *mt9p031 = to_mt9p031(client);
+	int ret;
+	u16 xbin, ybin;
+	const u16 hblank = MT9P031_H_BLANKING_VALUE,
+		vblank = MT9P031_V_BLANKING_VALUE;
+	/*
+	 * TODO: Attention! When implementing horizontal flipping, adjust
+	 * alignment according to R2 "Column Start" description in the datasheet
+	 */
+	if (xskip & 1) {
+		xbin = 1;
+		rect->left &= ~3;
+	} else if (xskip & 2) {
+		xbin = 2;
+		rect->left &= ~7;
+	} else {
+		xbin = 4;
+		rect->left &= ~15;
+	}
+
+	ybin = min(yskip, (u16)4);
+
+	rect->top &= ~1;
+
+	/* Disable register update, reconfigure atomically */
+	ret = mt9p031_set_output_control(mt9p031, 0, MT9P031_OUTPUT_CONTROL_SYN);
+	if (ret < 0)
+		return ret;
+
+	dev_dbg(&client->dev, "skip %u:%u, rect %ux%u@%u:%u\n",
+		xskip, yskip, rect->width, rect->height, rect->left, rect->top);
+
+	/* Blanking and start values - default... */
+	ret = reg_write(client, MT9P031_H_BLANKING, hblank);
+	if (ret < 0)
+		return ret;
+	ret = reg_write(client, MT9P031_V_BLANKING, vblank);
+	if (ret < 0)
+		return ret;
+
+	ret = reg_write(client, MT9P031_COLUMN_ADDRESS_MODE,
+				((xbin - 1) << 4) | (xskip - 1));
+	if (ret < 0)
+		return ret;
+	ret = reg_write(client, MT9P031_ROW_ADDRESS_MODE,
+				((ybin - 1) << 4) | (yskip - 1));
+	if (ret < 0)
+		return ret;
+
+	dev_dbg(&client->dev, "new physical left %u, top %u\n",
+		rect->left, rect->top);
+
+	ret = reg_write(client, MT9P031_COLUMN_START,
+				rect->left + MT9P031_COLUMN_START_SKIP);
+	if (ret < 0)
+		return ret;
+	ret = reg_write(client, MT9P031_ROW_START,
+				rect->top + MT9P031_ROW_START_SKIP);
+	if (ret < 0)
+		return ret;
+	ret = reg_write(client, MT9P031_WINDOW_WIDTH,
+				rect->width - 1);
+	if (ret < 0)
+		return ret;
+	ret = reg_write(client, MT9P031_WINDOW_HEIGHT,
+				rect->height - 1);
+	if (ret < 0)
+		return ret;
+
+	/* Re-enable register update, commit all changes */
+	ret = mt9p031_set_output_control(mt9p031, MT9P031_OUTPUT_CONTROL_SYN, 0);
+	if (ret < 0)
+		return ret;
+
+	mt9p031->xskip = xskip;
+	mt9p031->yskip = yskip;
+	return ret;
+}
+
+static int mt9p031_set_crop(struct v4l2_subdev *sd,
+				struct v4l2_subdev_fh *fh,
+				struct v4l2_subdev_crop *crop)
+{
+	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
+	struct v4l2_mbus_framefmt *f;
+	struct v4l2_rect *c;
+	struct v4l2_rect rect;
+	u16 xskip, yskip;
+	s32 width, height;
+
+	pr_info("%s(%ux%u@%u:%u : %u)\n", __func__,
+			crop->rect.width, crop->rect.height,
+			crop->rect.left, crop->rect.top, crop->which);
+
+	/*
+	 * Clamp the crop rectangle boundaries and align them to a multiple of 2
+	 * pixels.
+	 */
+	rect.width = ALIGN(clamp(crop->rect.width,
+				 MT9P031_MIN_WIDTH, MT9P031_MAX_WIDTH), 2);
+	rect.height = ALIGN(clamp(crop->rect.height,
+				  MT9P031_MIN_HEIGHT, MT9P031_MAX_HEIGHT), 2);
+	rect.left = ALIGN(clamp(crop->rect.left,
+				0, MT9P031_MAX_WIDTH - rect.width), 2);
+	rect.top = ALIGN(clamp(crop->rect.top,
+			       0, MT9P031_MAX_HEIGHT - rect.height), 2);
+
+	c = mt9p031_get_pad_crop(mt9p031, fh, crop->pad, crop->which);
+
+	if (rect.width != c->width || rect.height != c->height) {
+		/*
+		 * Reset the output image size if the crop rectangle size has
+		 * been modified.
+		 */
+		f = mt9p031_get_pad_format(mt9p031, fh, crop->pad,
+						    crop->which);
+		width = f->width;
+		height = f->height;
+
+		xskip = mt9p031_skip_for_crop(rect.width, &width, 7);
+		yskip = mt9p031_skip_for_crop(rect.height, &height, 8);
+	} else {
+		xskip = mt9p031->xskip;
+		yskip = mt9p031->yskip;
+		f = NULL;
+	}
+	if (f) {
+		f->width = width;
+		f->height = height;
+	}
+
+	*c = rect;
+	crop->rect = rect;
+
+	mt9p031->xskip = xskip;
+	mt9p031->yskip = yskip;
+	mt9p031->rect = *c;
+	return 0;
+}
+
+static int mt9p031_get_format(struct v4l2_subdev *sd,
+				struct v4l2_subdev_fh *fh,
+				struct v4l2_subdev_format *fmt)
+{
+	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
+
+	fmt->format =
+		*mt9p031_get_pad_format(mt9p031, fh, fmt->pad, fmt->which);
+	return 0;
+}
+
+static u16 mt9p031_skip_for_scale(s32 *source, s32 target,
+					s32 max_skip, s32 max)
+{
+	unsigned int skip;
+
+	if (*source - *source / 4 < target) {
+		*source = target;
+		return 1;
+	}
+
+	skip = min(max, *source + target / 2) / target;
+	if (skip > max_skip)
+		skip = max_skip;
+	*source = target * skip;
+
+	return skip;
+}
+
+static int mt9p031_fmt_validate(struct v4l2_subdev *sd,
+				struct v4l2_subdev_format *fmt)
+{
+	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
+	struct v4l2_mbus_framefmt *format = &fmt->format;
+
+	if (format->code != mt9p031->format.code || fmt->pad)
+		return -EINVAL;
+
+	format->colorspace = V4L2_COLORSPACE_SRGB;
+	format->width = clamp_t(int, ALIGN(format->width, 2), 2,
+						MT9P031_MAX_WIDTH);
+	format->height = clamp_t(int, ALIGN(format->height, 2), 2,
+						MT9P031_MAX_HEIGHT);
+	format->field = V4L2_FIELD_NONE;
+
+	return 0;
+}
+
+static int mt9p031_set_format(struct v4l2_subdev *sd,
+				struct v4l2_subdev_fh *fh,
+				struct v4l2_subdev_format *fmt)
+{
+	struct v4l2_subdev_format sdf = *fmt;
+	struct v4l2_mbus_framefmt *f, *format = &sdf.format;
+	struct v4l2_rect *c, rect;
+	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
+	u16 xskip, yskip;
+	int ret;
+
+	ret = mt9p031_fmt_validate(sd, &sdf);
+	if (ret < 0)
+		return ret;
+
+	f = mt9p031_get_pad_format(mt9p031, fh, fmt->pad, fmt->which);
+
+	if (f->width == format->width && f->height == format->height)
+		return 0;
+
+
+	c = mt9p031_get_pad_crop(mt9p031, fh, fmt->pad, fmt->which);
+
+	rect.width = c->width;
+	rect.height = c->height;
+
+	xskip = mt9p031_skip_for_scale(&rect.width, format->width, 7,
+				       MT9P031_MAX_WIDTH);
+	if (rect.width + c->left > MT9P031_MAX_WIDTH)
+		rect.left = (MT9P031_MAX_WIDTH - rect.width) / 2;
+	else
+		rect.left = c->left;
+	yskip = mt9p031_skip_for_scale(&rect.height, format->height, 8,
+				       MT9P031_MAX_HEIGHT);
+	if (rect.height + c->top > MT9P031_MAX_HEIGHT)
+		rect.top = (MT9P031_MAX_HEIGHT - rect.height) / 2;
+	else
+		rect.top = c->top;
+
+
+	pr_info("%s(%ux%u : %u)\n", __func__,
+		format->width, format->height, fmt->which);
+	if (c)
+		*c = rect;
+
+	*f = *format;
+	fmt->format = *format;
+
+	mt9p031->xskip = xskip;
+	mt9p031->yskip = yskip;
+	mt9p031->rect = *c;
+	return 0;
+}
+
+static int mt9p031_s_stream(struct v4l2_subdev *sd, int enable)
+{
+	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
+	struct i2c_client *client = v4l2_get_subdevdata(&mt9p031->subdev);
+	struct v4l2_rect rect = mt9p031->rect;
+	u16 xskip = mt9p031->xskip;
+	u16 yskip = mt9p031->yskip;
+	int ret;
+
+	if (enable) {
+		ret = mt9p031_set_params(client, &rect, xskip, yskip);
+		if (ret < 0)
+			return ret;
+		/* Switch to master "normal" mode */
+		ret = mt9p031_set_output_control(mt9p031, 0, MT9P031_OUTPUT_CONTROL_CEN);
+	} else {
+		/* Stop sensor readout */
+		ret = mt9p031_set_output_control(mt9p031, MT9P031_OUTPUT_CONTROL_CEN, 0);
+	}
+	if (ret < 0)
+		return -EIO;
+
+	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 mt9p031_video_probe(struct i2c_client *client)
+{
+	s32 data;
+	int ret;
+
+	/* Read out the chip version register */
+	data = reg_read(client, MT9P031_CHIP_VERSION);
+	if (data != MT9P031_CHIP_VERSION_VALUE) {
+		dev_err(&client->dev,
+			"No MT9P031 chip detected, register read %x\n", data);
+		return -ENODEV;
+	}
+
+	dev_info(&client->dev, "Detected a MT9P031 chip ID %x\n", data);
+
+	ret = mt9p031_reset(client);
+	if (ret < 0)
+		dev_err(&client->dev, "Failed to initialise the camera\n");
+
+	return ret;
+}
+
+static int mt9p031_set_power(struct v4l2_subdev *sd, int on)
+{
+	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
+	int ret = 0;
+
+	mutex_lock(&mt9p031->power_lock);
+
+	/* If the power count is modified from 0 to != 0 or from != 0 to 0,
+	 * update the power state.
+	 */
+	if (mt9p031->power_count == !on) {
+		if (on) {
+			ret = mt9p031_power_on(mt9p031);
+			if (ret) {
+				pr_err("Failed to enable 2.8v regulator: %d\n", ret);
+				goto out;
+			}
+		} else {
+			mt9p031_power_off(mt9p031);
+		}
+	}
+
+	/* Update the power count. */
+	mt9p031->power_count +=on ? 1: -1;
+	WARN_ON(mt9p031->power_count < 0);
+
+out:
+	mutex_unlock(&mt9p031->power_lock);
+	return ret;
+}
+
+static int mt9p031_registered(struct v4l2_subdev *sd)
+{
+	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
+	struct i2c_client *client = v4l2_get_subdevdata(&mt9p031->subdev);
+	int ret;
+
+	ret = mt9p031_set_power(&mt9p031->subdev, 1);
+	if (ret) {
+		pr_err("Failed to power on device: %d\n", ret);
+		goto pwron;
+	}
+	if (mt9p031->pdata->reset)
+		mt9p031->pdata->reset(&mt9p031->subdev, 1);
+	msleep(50);
+	if (mt9p031->pdata->reset)
+		mt9p031->pdata->reset(&mt9p031->subdev, 0);
+	msleep(50);
+
+	ret = mt9p031_video_probe(client);
+	if (ret)
+		goto evprobe;
+
+	mt9p031->pad.flags = MEDIA_PAD_FL_SOURCE;
+	ret = media_entity_init(&mt9p031->subdev.entity, 1, &mt9p031->pad, 0);
+	if (ret)
+		goto evprobe;
+
+	mt9p031->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
+	mt9p031_set_power(&mt9p031->subdev, 0);
+
+	return 0;
+evprobe:
+	mt9p031_set_power(&mt9p031->subdev, 0);
+pwron:
+	return ret;
+}
+
+static int mt9p031_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
+{
+	struct mt9p031 *mt9p031;
+	mt9p031 = container_of(sd, struct mt9p031, subdev);
+
+	return mt9p031_set_power(sd, 1);
+}
+
+static int mt9p031_close(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
+{
+	struct mt9p031 *mt9p031;
+
+	mt9p031 = container_of(sd, struct mt9p031, subdev);
+
+	mt9p031_set_power(sd, 0);
+	return 0;
+}
+
+static struct v4l2_subdev_core_ops mt9p031_subdev_core_ops = {
+	.s_power	= mt9p031_set_power,
+};
+
+static struct v4l2_subdev_video_ops mt9p031_subdev_video_ops = {
+	.s_stream	= mt9p031_s_stream,
+};
+
+static struct v4l2_subdev_pad_ops mt9p031_subdev_pad_ops = {
+	.enum_mbus_code = mt9p031_enum_mbus_code,
+	.get_fmt = mt9p031_get_format,
+	.set_fmt = mt9p031_set_format,
+	.get_crop = mt9p031_get_crop,
+	.set_crop = mt9p031_set_crop,
+};
+
+static struct v4l2_subdev_ops mt9p031_subdev_ops = {
+	.core	= &mt9p031_subdev_core_ops,
+	.video	= &mt9p031_subdev_video_ops,
+	.pad	= &mt9p031_subdev_pad_ops,
+};
+
+static const struct v4l2_subdev_internal_ops mt9p031_subdev_internal_ops = {
+	.registered = mt9p031_registered,
+	.open = mt9p031_open,
+	.close = mt9p031_close,
+};
+
+static int mt9p031_probe(struct i2c_client *client,
+			 const struct i2c_device_id *did)
+{
+	struct mt9p031 *mt9p031;
+	struct mt9p031_platform_data *pdata = client->dev.platform_data;
+	struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
+	int ret;
+
+	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;
+	}
+
+	mt9p031 = kzalloc(sizeof(struct mt9p031), GFP_KERNEL);
+	if (!mt9p031)
+		return -ENOMEM;
+
+	mutex_init(&mt9p031->power_lock);
+	v4l2_i2c_subdev_init(&mt9p031->subdev, client, &mt9p031_subdev_ops);
+	mt9p031->subdev.internal_ops = &mt9p031_subdev_internal_ops;
+
+	mt9p031->pdata		= pdata;
+	mt9p031->rect.left	= 0;
+	mt9p031->rect.top	= 0;
+	mt9p031->rect.width	= MT9P031_MAX_WIDTH;
+	mt9p031->rect.height	= MT9P031_MAX_HEIGHT;
+
+	mt9p031->format.code = V4L2_MBUS_FMT_SGRBG12_1X12;
+
+	mt9p031->format.width = MT9P031_MAX_WIDTH;
+	mt9p031->format.height = MT9P031_MAX_HEIGHT;
+	mt9p031->format.field = V4L2_FIELD_NONE;
+	mt9p031->format.colorspace = V4L2_COLORSPACE_SRGB;
+
+	mt9p031->xskip = 1;
+	mt9p031->yskip = 1;
+
+	mt9p031->reg_1v8 = regulator_get(NULL, "cam_1v8");
+	if (IS_ERR(mt9p031->reg_1v8)) {
+		ret = PTR_ERR(mt9p031->reg_1v8);
+		pr_err("Failed 1.8v regulator: %d\n", ret);
+		goto e1v8;
+	}
+
+	mt9p031->reg_2v8 = regulator_get(NULL, "cam_2v8");
+	if (IS_ERR(mt9p031->reg_2v8)) {
+		ret = PTR_ERR(mt9p031->reg_2v8);
+		pr_err("Failed 2.8v regulator: %d\n", ret);
+		goto e2v8;
+	}
+	/* turn on core */
+	ret = regulator_enable(mt9p031->reg_1v8);
+	if (ret) {
+		pr_err("Failed to enable 1.8v regulator: %d\n", ret);
+		goto e1v8en;
+	}
+	return 0;
+e1v8en:
+	regulator_put(mt9p031->reg_2v8);
+e2v8:
+	regulator_put(mt9p031->reg_1v8);
+e1v8:
+	kfree(mt9p031);
+	return ret;
+}
+
+static int mt9p031_remove(struct i2c_client *client)
+{
+	struct v4l2_subdev *sd = i2c_get_clientdata(client);
+	struct mt9p031 *mt9p031 = container_of(sd, struct mt9p031, subdev);
+
+	v4l2_device_unregister_subdev(sd);
+	media_entity_cleanup(&sd->entity);
+	regulator_disable(mt9p031->reg_1v8);
+	regulator_put(mt9p031->reg_2v8);
+	regulator_put(mt9p031->reg_1v8);
+	kfree(mt9p031);
+
+	return 0;
+}
+
+static const struct i2c_device_id mt9p031_id[] = {
+	{ "mt9p031", 0 },
+	{ }
+};
+MODULE_DEVICE_TABLE(i2c, mt9p031_id);
+
+static struct i2c_driver mt9p031_i2c_driver = {
+	.driver = {
+		.name = "mt9p031",
+	},
+	.probe		= mt9p031_probe,
+	.remove		= mt9p031_remove,
+	.id_table	= mt9p031_id,
+};
+
+static int __init mt9p031_mod_init(void)
+{
+	return i2c_add_driver(&mt9p031_i2c_driver);
+}
+
+static void __exit mt9p031_mod_exit(void)
+{
+	i2c_del_driver(&mt9p031_i2c_driver);
+}
+
+module_init(mt9p031_mod_init);
+module_exit(mt9p031_mod_exit);
+
+MODULE_DESCRIPTION("Aptina MT9P031 Camera driver");
+MODULE_AUTHOR("Bastian Hecht <[e-mail]>");
+MODULE_LICENSE("GPL v2");
diff --git a/include/media/mt9p031.h b/include/media/mt9p031.h
new file mode 100644
index 0000000..ad37eb3
--- /dev/null
+++ b/include/media/mt9p031.h
@@ -0,0 +1,11 @@ 
+#ifndef MT9P031_H
+#define MT9P031_H
+
+struct v4l2_subdev;
+
+struct mt9p031_platform_data {
+	int (*set_xclk)(struct v4l2_subdev *subdev, int hz);
+	int (*reset)(struct v4l2_subdev *subdev, int active);
+};
+
+#endif