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

This driver adds basic support for Aptina mt9p031 sensor.

Signed-off-by: Javier Martin <javier.martin@vista-silicon.com>

isp.h file has to be included as a temporal measure
since clocks of the isp are not exposed yet.

Signed-off-by: Javier Martin <javier.martin@vista-silicon.com>

Javier,

In previous patch sets we put that in a seperate file (omap3beagle-camera.c) so we don't clutter up the board file with all the different sensor drivers. Would it make sense to do the same with the current patches? It looks like MCF cuts down a lot on the boilerplace needed already.

regards,

Koen

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).

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

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

Hi Javier,

linux-omap should be CC'ed - added.

In addition to Koen's comments, some comments below.

isp.h file has to be included as a temporal measure
since clocks of the isp are not exposed yet.

Signed-off-by: Javier Martin <javier.martin@vista-silicon.com>
---
arch/arm/mach-omap2/board-omap3beagle.c | 127 ++++++++++++++++++++++++++++++-
1 files changed, 123 insertions(+), 4 deletions(-)

diff --git a/arch/arm/mach-omap2/board-omap3beagle.c b/arch/arm/mach-omap2/board-omap3beagle.c
index 33007fd..f52e6ae 100644
--- a/arch/arm/mach-omap2/board-omap3beagle.c
+++ b/arch/arm/mach-omap2/board-omap3beagle.c
@@ -24,15 +24,20 @@
#include <linux/input.h>
#include <linux/gpio_keys.h>
#include <linux/opp.h>
+#include <linux/i2c.h>
+#include <linux/mm.h>
+#include <linux/videodev2.h>

#include <linux/mtd/mtd.h>
#include <linux/mtd/partitions.h>
#include <linux/mtd/nand.h>
#include <linux/mmc/host.h>
-
+#include <linux/gpio.h>

Why include this for second time?

#include <linux/regulator/machine.h>
#include <linux/i2c/twl.h>

+#include <media/mt9p031.h>
+
#include <mach/hardware.h>
#include <asm/mach-types.h>
#include <asm/mach/arch.h>
@@ -47,12 +52,17 @@
#include <plat/nand.h>
#include <plat/usb.h>
#include <plat/omap_device.h>
+#include <plat/i2c.h>

#include "mux.h"
#include "hsmmc.h"
#include "timer-gp.h"
#include "pm.h"
+#include "devices.h"
+#include "../../../drivers/media/video/omap3isp/isp.h"

+#define MT9P031_RESET_GPIO 98
+#define MT9P031_XCLK ISP_XCLK_A
#define NAND_BLOCK_SIZE SZ_128K

/*
@@ -273,6 +283,44 @@ static struct regulator_consumer_supply beagle_vsim_supply = {

static struct gpio_led gpio_leds[];

+static struct regulator_consumer_supply beagle_vaux3_supply = {
+ .supply = "cam_1v8",
+};
+
+static struct regulator_consumer_supply beagle_vaux4_supply = {
+ .supply = "cam_2v8",
+};
+
+/* VAUX3 for CAM_1V8 */
+static struct regulator_init_data beagle_vaux3 = {
+ .constraints = {
+ .min_uV = 1800000,
+ .max_uV = 1800000,
+ .apply_uV = true,
+ .valid_modes_mask = REGULATOR_MODE_NORMAL
+ | REGULATOR_MODE_STANDBY,
+ .valid_ops_mask = REGULATOR_CHANGE_MODE
+ | REGULATOR_CHANGE_STATUS,
+ },
+ .num_consumer_supplies = 1,
+ .consumer_supplies = &beagle_vaux3_supply,
+};
+
+/* VAUX4 for CAM_2V8 */
+static struct regulator_init_data beagle_vaux4 = {
+ .constraints = {
+ .min_uV = 1800000,
+ .max_uV = 1800000,
+ .apply_uV = true,
+ .valid_modes_mask = REGULATOR_MODE_NORMAL
+ | REGULATOR_MODE_STANDBY,
+ .valid_ops_mask = REGULATOR_CHANGE_MODE
+ | REGULATOR_CHANGE_STATUS,
+ },
+ .num_consumer_supplies = 1,
+ .consumer_supplies = &beagle_vaux4_supply,
+};
+
static int beagle_twl_gpio_setup(struct device *dev,
     unsigned gpio, unsigned ngpio)
{
@@ -309,6 +357,15 @@ static int beagle_twl_gpio_setup(struct device *dev,
       pr_err("%s: unable to configure EHCI_nOC\n", __func__);
   }

+ if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM) {
+ /*
+ * Power on camera interface - only on pre-production, not
+ * needed on production boards
+ */
+ gpio_request(gpio + 2, "CAM_EN");
+ gpio_direction_output(gpio + 2, 1);

Why not gpio_request_one()?

+ }
+
   /*
    * TWL4030_GPIO_MAX + 0 == ledA, EHCI nEN_USB_PWR (out, XM active
    * high / others active low)
@@ -451,6 +508,8 @@ static struct twl4030_platform_data beagle_twldata = {
   .vsim = &beagle_vsim,
   .vdac = &beagle_vdac,
   .vpll2 = &beagle_vpll2,
+ .vaux3 = &beagle_vaux3,
+ .vaux4 = &beagle_vaux4,
};

static struct i2c_board_info __initdata beagle_i2c_boardinfo[] = {
@@ -463,15 +522,16 @@ static struct i2c_board_info __initdata beagle_i2c_boardinfo[] = {
};

static struct i2c_board_info __initdata beagle_i2c_eeprom[] = {
- {
- I2C_BOARD_INFO("eeprom", 0x50),
- },
+ {
+ I2C_BOARD_INFO("eeprom", 0x50),
+ },
};

This part of the hunk is not related to the patch
and should be in a separate (cleanup) patch.

static int __init omap3_beagle_i2c_init(void)
{
   omap_register_i2c_bus(1, 2600, beagle_i2c_boardinfo,
       ARRAY_SIZE(beagle_i2c_boardinfo));
+ omap_register_i2c_bus(2, 100, NULL, 0); /* Enable I2C2 for camera */
   /* Bus 3 is attached to the DVI port where devices like the pico DLP
    * projector don't work reliably with 400kHz */
   omap_register_i2c_bus(3, 100, beagle_i2c_eeprom, ARRAY_SIZE(beagle_i2c_eeprom));
@@ -654,6 +714,60 @@ static void __init beagle_opp_init(void)
   return;
}

+static int beagle_cam_set_xclk(struct v4l2_subdev *subdev, int hz)
+{
+ struct isp_device *isp = v4l2_dev_to_isp_device(subdev->v4l2_dev);
+ int ret;
+
+ ret = isp->platform_cb.set_xclk(isp, hz, MT9P031_XCLK);
+ return 0;
+}

Why do you need ret variable here, if you always return zero?

+
+static int beagle_cam_reset(struct v4l2_subdev *subdev, int active)
+{
+ /* Set RESET_BAR to !active */
+ gpio_set_value(MT9P031_RESET_GPIO, !active);
+
+ return 0;
+}
+
+static struct mt9p031_platform_data beagle_mt9p031_platform_data = {
+ .set_xclk = beagle_cam_set_xclk,
+ .reset = beagle_cam_reset,
+};
+
+static struct i2c_board_info mt9p031_camera_i2c_device = {
+ I2C_BOARD_INFO("mt9p031", 0x48),
+ .platform_data = &beagle_mt9p031_platform_data,
+};
+
+static struct isp_subdev_i2c_board_info mt9p031_camera_subdevs[] = {
+ {
+ .board_info = &mt9p031_camera_i2c_device,
+ .i2c_adapter_id = 2,
+ },
+ { NULL, 0, },
+};
+
+static struct isp_v4l2_subdevs_group beagle_camera_subdevs[] = {
+ {
+ .subdevs = mt9p031_camera_subdevs,
+ .interface = ISP_INTERFACE_PARALLEL,
+ .bus = {
+ .parallel = {
+ .data_lane_shift = 0,
+ .clk_pol = 1,
+ .bridge = ISPCTRL_PAR_BRIDGE_DISABLE,
+ }
+ },
+ },
+ { },
+};
+
+static struct isp_platform_data beagle_isp_platform_data = {
+ .subdevs = beagle_camera_subdevs,
+};
+
static void __init omap3_beagle_init(void)
{
   omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
@@ -679,6 +793,11 @@ static void __init omap3_beagle_init(void)

   beagle_display_init();
   beagle_opp_init();
+
+ /* Enable camera */
+ gpio_request(MT9P031_RESET_GPIO, "cam_rst");
+ gpio_direction_output(MT9P031_RESET_GPIO, 0);

gpio_request_one()?

Hi Mauro,

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 :slight_smile: 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.

I sent my first patch using that approach but I was told to move it to
the board code.
Please, don't make undo the changes. Or at least, let's discuss this
seriously so that we all agree on what is the best way of doing it and
I don't have to change it every time.

Hi Javier,

linux-omap should be CC'ed - added.

In addition to Koen's comments, some comments below.

isp.h file has to be included as a temporal measure
since clocks of the isp are not exposed yet.

Signed-off-by: Javier Martin <javier.martin@vista-silicon.com>
---
arch/arm/mach-omap2/board-omap3beagle.c | 127 ++++++++++++++++++++++++++++++-
1 files changed, 123 insertions(+), 4 deletions(-)

diff --git a/arch/arm/mach-omap2/board-omap3beagle.c b/arch/arm/mach-omap2/board-omap3beagle.c
index 33007fd..f52e6ae 100644
--- a/arch/arm/mach-omap2/board-omap3beagle.c
+++ b/arch/arm/mach-omap2/board-omap3beagle.c
@@ -24,15 +24,20 @@
#include <linux/input.h>
#include <linux/gpio_keys.h>
#include <linux/opp.h>
+#include <linux/i2c.h>
+#include <linux/mm.h>
+#include <linux/videodev2.h>

#include <linux/mtd/mtd.h>
#include <linux/mtd/partitions.h>
#include <linux/mtd/nand.h>
#include <linux/mmc/host.h>
-
+#include <linux/gpio.h>

Why include this for second time?

Good catch, I'll fix it.

[snip]

@@ -309,6 +357,15 @@ static int beagle_twl_gpio_setup(struct device *dev,
pr_err("%s: unable to configure EHCI_nOC\n", __func__);
}

+ if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM) {
+ /*
+ * Power on camera interface - only on pre-production, not
+ * needed on production boards
+ */
+ gpio_request(gpio + 2, "CAM_EN");
+ gpio_direction_output(gpio + 2, 1);

Why not gpio_request_one()?

Just to follow the same approach as in the rest of the code.
Maybe a further patch could change all "gpio_request()" uses to
"gpio_request_one()".

+ }
+
/*
* TWL4030_GPIO_MAX + 0 == ledA, EHCI nEN_USB_PWR (out, XM active
* high / others active low)
@@ -451,6 +508,8 @@ static struct twl4030_platform_data beagle_twldata = {
.vsim = &beagle_vsim,
.vdac = &beagle_vdac,
.vpll2 = &beagle_vpll2,
+ .vaux3 = &beagle_vaux3,
+ .vaux4 = &beagle_vaux4,
};

static struct i2c_board_info __initdata beagle_i2c_boardinfo[] = {
@@ -463,15 +522,16 @@ static struct i2c_board_info __initdata beagle_i2c_boardinfo[] = {
};

static struct i2c_board_info __initdata beagle_i2c_eeprom[] = {
- {
- I2C_BOARD_INFO("eeprom", 0x50),
- },
+ {
+ I2C_BOARD_INFO("eeprom", 0x50),
+ },
};

This part of the hunk is not related to the patch
and should be in a separate (cleanup) patch.

Sure, I'll fix it.

static int __init omap3_beagle_i2c_init(void)
{
omap_register_i2c_bus(1, 2600, beagle_i2c_boardinfo,
ARRAY_SIZE(beagle_i2c_boardinfo));
+ omap_register_i2c_bus(2, 100, NULL, 0); /* Enable I2C2 for camera */
/* Bus 3 is attached to the DVI port where devices like the pico DLP
* projector don't work reliably with 400kHz */
omap_register_i2c_bus(3, 100, beagle_i2c_eeprom, ARRAY_SIZE(beagle_i2c_eeprom));
@@ -654,6 +714,60 @@ static void __init beagle_opp_init(void)
return;
}

+static int beagle_cam_set_xclk(struct v4l2_subdev *subdev, int hz)
+{
+ struct isp_device *isp = v4l2_dev_to_isp_device(subdev->v4l2_dev);
+ int ret;
+
+ ret = isp->platform_cb.set_xclk(isp, hz, MT9P031_XCLK);
+ return 0;
+}

Why do you need ret variable here, if you always return zero?

You are right, it's not needed any longer.

+
+static int beagle_cam_reset(struct v4l2_subdev *subdev, int active)
+{
+ /* Set RESET_BAR to !active */
+ gpio_set_value(MT9P031_RESET_GPIO, !active);
+
+ return 0;
+}
+
+static struct mt9p031_platform_data beagle_mt9p031_platform_data = {
+ .set_xclk = beagle_cam_set_xclk,
+ .reset = beagle_cam_reset,
+};
+
+static struct i2c_board_info mt9p031_camera_i2c_device = {
+ I2C_BOARD_INFO("mt9p031", 0x48),
+ .platform_data = &beagle_mt9p031_platform_data,
+};
+
+static struct isp_subdev_i2c_board_info mt9p031_camera_subdevs[] = {
+ {
+ .board_info = &mt9p031_camera_i2c_device,
+ .i2c_adapter_id = 2,
+ },
+ { NULL, 0, },
+};
+
+static struct isp_v4l2_subdevs_group beagle_camera_subdevs[] = {
+ {
+ .subdevs = mt9p031_camera_subdevs,
+ .interface = ISP_INTERFACE_PARALLEL,
+ .bus = {
+ .parallel = {
+ .data_lane_shift = 0,
+ .clk_pol = 1,
+ .bridge = ISPCTRL_PAR_BRIDGE_DISABLE,
+ }
+ },
+ },
+ { },
+};
+
+static struct isp_platform_data beagle_isp_platform_data = {
+ .subdevs = beagle_camera_subdevs,
+};
+
static void __init omap3_beagle_init(void)
{
omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
@@ -679,6 +793,11 @@ static void __init omap3_beagle_init(void)

  beagle\_display\_init\(\);
  beagle\_opp\_init\(\);

+
+ /* Enable camera */
+ gpio_request(MT9P031_RESET_GPIO, "cam_rst");
+ gpio_direction_output(MT9P031_RESET_GPIO, 0);

gpio_request_one()?

ditto

Hi Javier,

[snip]

>> @@ -309,6 +357,15 @@ static int beagle_twl_gpio_setup(struct device
>> *dev, pr_err("%s: unable to configure EHCI_nOC\n", __func__); }
>>
>> + if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM) {
>> + /*
>> + * Power on camera interface - only on pre-production, not
>> + * needed on production boards
>> + */
>> + gpio_request(gpio + 2, "CAM_EN");
>> + gpio_direction_output(gpio + 2, 1);
>
> Why not gpio_request_one()?

Just to follow the same approach as in the rest of the code.
Maybe a further patch could change all "gpio_request()" uses to
"gpio_request_one()".

Please do it the other way around. Replace calls to gpio_request() +
gpio_direction_output() with a call to gpio_request_one(), and then modify
this patch to use gpio_request_one().

If you want to learn how to use coccinelle (http://coccinelle.lip6.fr/), now
would be a good time. You could use it to replace gpio_request() +
gpio_direction_output() through the whole kernel.

Hi Javier,

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
+ *
+ *
+ *
+ * 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\-&gt;which == V4L2\_SUBDEV\_FORMAT\_ACTIVE\) \{
           ret = mt9p031\_set\_params\(client, &amp;rect, xskip, yskip\);
           if \(ret &lt; 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.

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

Well, they are runtime detectable, you just need to read the ID register on the sensor and they all share the same I2C address. Once you have the sensor ID you can (re)setup the I2C. But doing that in linux seems to be impossible with the current I2C infrastructure.

What we (beagleboard.org) are doing now:

1) set a bootarg in uboot e.g. camera=llbcm5mp
2) read bootarg in linux boardfile and setup i2c

What we are going to do medium term:

1) read ID in uboot, set bootarg
2) read bootarg in linux boardfile

Long term 1) will probably do some devicetree magic. The goal is to plug in a sensor and boot, no manual modprobing, it just works.

regards,

Koen

Hi Guennadi and Javier,

[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 :slight_smile: 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 :slight_smile:

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

Hi Guennadi,

Hi Koen,

>>> In previous patch sets we put that in a seperate file
>>> (omap3beagle-camera.c) so we don't clutter up the board file with all
>>> the different sensor drivers. Would it make sense to do the same with
>>> the current patches? It looks like MCF cuts down a lot on the
>>> boilerplace needed already.
>>
>> I sent my first patch using that approach but I was told to move it to
>> the board code.
>> Please, don't make undo the changes. Or at least, let's discuss this
>> seriously so that we all agree on what is the best way of doing it and
>> I don't have to change it every time.
>
> What we really need here is a modular way to support sensors on pluggable
> expansion boards. Not all Beagleboard users will have an MT9P031
> connected to the OMAP3 ISP, so that must not be hardcoded in board code.
> As the sensor boards are not runtime detectable

Well, they are runtime detectable, you just need to read the ID register on
the sensor and they all share the same I2C address. Once you have the
sensor ID you can (re)setup the I2C.

I don't think we can guarantee that all sensor boards that will ever be
plugged into the Beagleboard will have a sensor ID register readable from a
single I2C address at a single register offset.

But doing that in linux seems to be impossible with the current I2C
infrastructure.

What we (beagleboard.org) are doing now:

1) set a bootarg in uboot e.g. camera=llbcm5mp
2) read bootarg in linux boardfile and setup i2c

What we are going to do medium term:

1) read ID in uboot, set bootarg
2) read bootarg in linux boardfile

Long term 1) will probably do some devicetree magic. The goal is to plug in
a sensor and boot, no manual modprobing, it just works.

Device tree is definitely the way to go. using the camera parameter in board
code to register the correct camera sounds good to me.

Whichever way, but it should be consistent, IMHO.

Thanks
Guennadi

Well, this is done already, you need to follow Tony's linux-next branch...
So, just changing this patch would do...
Also, good practice is to base patches on maintainer's appropriate branch,
so it would be easier to apply.

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

Hi Guennadi and Javier,

[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.