[v2,1/2] MT9P031: Add support for Aptina mt9p031 sensor.
Commit Message
This driver adds basic support for Aptina mt9p031 sensor.
Signed-off-by: Javier Martin <javier.martin@vista-silicon.com>
---
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
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 <javier.martin@vista-silicon.com>
> ---
> 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 <javier.martin@vista-silicon.com>
> + *
> + * Copyright (C) 2011, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
> + *
> + * 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 <hechtb@gmail.com>");
> +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 majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
On Fri, 20 May 2011, Javier Martin wrote:
> This driver adds basic support for Aptina mt9p031 sensor.
>
> Signed-off-by: Javier Martin <javier.martin@vista-silicon.com>
> ---
> 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 <javier.martin@vista-silicon.com>
> + *
> + * Copyright (C) 2011, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
> + *
> + * 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 <hechtb@gmail.com>");
> +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 majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
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.
On 21 May 2011 17:29, Guennadi Liakhovetski <g.liakhovetski@gmx.de> wrote:
> On Fri, 20 May 2011, Javier Martin wrote:
>
>> This driver adds basic support for Aptina mt9p031 sensor.
>>
>> Signed-off-by: Javier Martin <javier.martin@vista-silicon.com>
>> ---
>> 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 <javier.martin@vista-silicon.com>
>> + *
>> + * Copyright (C) 2011, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
>> + *
>> + * 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.
On Mon, 23 May 2011, javier Martin wrote:
> On 21 May 2011 17:29, Guennadi Liakhovetski <g.liakhovetski@gmx.de> wrote:
> > On Fri, 20 May 2011, Javier Martin wrote:
> >
> >> This driver adds basic support for Aptina mt9p031 sensor.
> >>
> >> Signed-off-by: Javier Martin <javier.martin@vista-silicon.com>
> >> ---
> >> 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 <javier.martin@vista-silicon.com>
> >> + *
> >> + * Copyright (C) 2011, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
> >> + *
> >> + * 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 majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
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;
> > +}
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 <g.liakhovetski@gmx.de> wrote:
> > > On Fri, 20 May 2011, Javier Martin wrote:
> > >> This driver adds basic support for Aptina mt9p031 sensor.
> > >>
> > >> Signed-off-by: Javier Martin <javier.martin@vista-silicon.com>
> > >> ---
> > >> 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
> > >> <javier.martin@vista-silicon.com> + *
> > >> + * Copyright (C) 2011, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
> > >> + *
> > >> + * 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.
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 majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Hi, Laurent, Guennadi,
thank you for your review. I've already fixed most of the issues.
On 23 May 2011 11:03, Laurent Pinchart
<laurent.pinchart@ideasonboard.com> 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.
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.
On 24 May 2011 10:39, Laurent Pinchart
<laurent.pinchart@ideasonboard.com> 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
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.
@@ -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
@@ -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
new file mode 100644
@@ -0,0 +1,751 @@
+/*
+ * Driver for MT9P031 CMOS Image Sensor from Aptina
+ *
+ * Copyright (C) 2011, Javier Martin <javier.martin@vista-silicon.com>
+ *
+ * Copyright (C) 2011, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
+ *
+ * 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 <hechtb@gmail.com>");
+MODULE_LICENSE("GPL v2");
new file mode 100644
@@ -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