Re: [PATCH v4] media: Driver for Toshiba et8ek8 5MP sensor

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Hi!

> Thanks, this answered half of my questions already. ;-)

:-).

I'll have to go through the patches, et8ek8 driver is probably not
enough to get useful video. platform/video-bus-switch.c is needed for
camera switching, then some omap3isp patches to bind flash and
autofocus into the subdevice.

Then, device tree support on n900 can be added.

> Do all the modes work for you currently btw.?

I don't think I got 5MP mode to work. Even 2.5MP mode is tricky (needs
a lot of continuous memory).

Anyway, I have to start somewhere, and I believe this is a good
starting place; I'd like to get the code cleaned up and merged, then
move to the next parts.

Best regards,
								Pavel


> On Sun, Oct 23, 2016 at 10:03:55PM +0200, Pavel Machek wrote:
> > 
> > Add driver for et8ek8 sensor, found in Nokia N900 main camera. Can be
> > used for taking photos in 2.5MP resolution with fcam-dev.
> > 
> > Signed-off-by: Ivaylo Dimitrov <ivo.g.dimitrov.75@xxxxxxxxx>
> > Signed-off-by: Pavel Machek <pavel@xxxxxx>
> > 
> > ---
> > From v4 I did cleanups to coding style and removed various oddities.
> > 
> > diff --git a/drivers/media/i2c/Kconfig b/drivers/media/i2c/Kconfig
> > index 2669b4b..6d01e15 100644
> > --- a/drivers/media/i2c/Kconfig
> > +++ b/drivers/media/i2c/Kconfig
> > @@ -667,6 +667,7 @@ config VIDEO_S5K5BAF
> >  	  camera sensor with an embedded SoC image signal processor.
> >  
> >  source "drivers/media/i2c/smiapp/Kconfig"
> > +source "drivers/media/i2c/et8ek8/Kconfig"
> >  
> >  config VIDEO_S5C73M3
> >  	tristate "Samsung S5C73M3 sensor support"
> > diff --git a/drivers/media/i2c/Makefile b/drivers/media/i2c/Makefile
> > index 92773b2..5bc7bbe 100644
> > --- a/drivers/media/i2c/Makefile
> > +++ b/drivers/media/i2c/Makefile
> > @@ -2,6 +2,7 @@ msp3400-objs	:=	msp3400-driver.o msp3400-kthreads.o
> >  obj-$(CONFIG_VIDEO_MSP3400) += msp3400.o
> >  
> >  obj-$(CONFIG_VIDEO_SMIAPP)	+= smiapp/
> > +obj-$(CONFIG_VIDEO_ET8EK8)	+= et8ek8/
> >  obj-$(CONFIG_VIDEO_CX25840) += cx25840/
> >  obj-$(CONFIG_VIDEO_M5MOLS)	+= m5mols/
> >  obj-y				+= soc_camera/
> > diff --git a/drivers/media/i2c/et8ek8/Kconfig b/drivers/media/i2c/et8ek8/Kconfig
> > new file mode 100644
> > index 0000000..1439936
> > --- /dev/null
> > +++ b/drivers/media/i2c/et8ek8/Kconfig
> > @@ -0,0 +1,6 @@
> > +config VIDEO_ET8EK8
> > +	tristate "ET8EK8 camera sensor support"
> > +	depends on I2C && VIDEO_V4L2 && VIDEO_V4L2_SUBDEV_API
> > +	---help---
> > +	  This is a driver for the Toshiba ET8EK8 5 MP camera sensor.
> > +	  It is used for example in Nokia N900 (RX-51).
> > diff --git a/drivers/media/i2c/et8ek8/Makefile b/drivers/media/i2c/et8ek8/Makefile
> > new file mode 100644
> > index 0000000..66d1b7d
> > --- /dev/null
> > +++ b/drivers/media/i2c/et8ek8/Makefile
> > @@ -0,0 +1,2 @@
> > +et8ek8-objs			+= et8ek8_mode.o et8ek8_driver.o
> > +obj-$(CONFIG_VIDEO_ET8EK8)	+= et8ek8.o
> > diff --git a/drivers/media/i2c/et8ek8/et8ek8_driver.c b/drivers/media/i2c/et8ek8/et8ek8_driver.c
> > new file mode 100644
> > index 0000000..0301e81
> > --- /dev/null
> > +++ b/drivers/media/i2c/et8ek8/et8ek8_driver.c
> > @@ -0,0 +1,1588 @@
> > +/*
> > + * et8ek8_driver.c
> > + *
> > + * Copyright (C) 2008 Nokia Corporation
> > + *
> > + * Contact: Sakari Ailus <sakari.ailus@xxxxxx>
> > + *          Tuukka Toivonen <tuukkat76@xxxxxxxxx>
> > + *
> > + * Based on code from Toni Leinonen <toni.leinonen@xxxxxxxxxx>.
> > + *
> > + * This driver is based on the Micron MT9T012 camera imager driver
> > + * (C) Texas Instruments.
> > + *
> > + * 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.
> > + *
> > + * This program is distributed in the hope that it will be useful, but
> > + * WITHOUT ANY WARRANTY; without even the implied warranty of
> > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
> > + * General Public License for more details.
> > + */
> > +
> > +#include <linux/clk.h>
> > +#include <linux/delay.h>
> > +#include <linux/gpio/consumer.h>
> > +#include <linux/i2c.h>
> > +#include <linux/kernel.h>
> > +#include <linux/module.h>
> > +#include <linux/mutex.h>
> > +#include <linux/regulator/consumer.h>
> > +#include <linux/slab.h>
> > +#include <linux/sort.h>
> > +#include <linux/v4l2-mediabus.h>
> > +
> > +#include <media/media-entity.h>
> > +#include <media/v4l2-ctrls.h>
> > +#include <media/v4l2-device.h>
> > +#include <media/v4l2-subdev.h>
> > +
> > +#include "et8ek8_reg.h"
> > +
> > +#define ET8EK8_NAME		"et8ek8"
> > +#define ET8EK8_PRIV_MEM_SIZE	128
> > +#define ET8EK8_MAX_MSG		48
> > +
> > +struct et8ek8_sensor {
> > +	struct v4l2_subdev subdev;
> > +	struct media_pad pad;
> > +	struct v4l2_mbus_framefmt format;
> > +	struct gpio_desc *reset;
> > +	struct regulator *vana;
> > +	struct clk *ext_clk;
> > +	u32 xclk_freq;
> > +
> > +	u16 version;
> > +
> > +	struct v4l2_ctrl_handler ctrl_handler;
> > +	struct v4l2_ctrl *exposure;
> > +	struct v4l2_ctrl *pixel_rate;
> > +	struct et8ek8_reglist *current_reglist;
> > +
> > +	u8 priv_mem[ET8EK8_PRIV_MEM_SIZE];
> > +
> > +	struct mutex power_lock;
> > +	int power_count;
> > +};
> > +
> > +#define to_et8ek8_sensor(sd)	container_of(sd, struct et8ek8_sensor, subdev)
> > +
> > +enum et8ek8_versions {
> > +	ET8EK8_REV_1 = 0x0001,
> > +	ET8EK8_REV_2,
> > +};
> > +
> > +/*
> > + * This table describes what should be written to the sensor register
> > + * for each gain value. The gain(index in the table) is in terms of
> > + * 0.1EV, i.e. 10 indexes in the table give 2 time more gain [0] in
> > + * the *analog gain, [1] in the digital gain
> > + *
> > + * Analog gain [dB] = 20*log10(regvalue/32); 0x20..0x100
> > + */
> > +static struct et8ek8_gain {
> > +	u16 analog;
> > +	u16 digital;
> > +} const et8ek8_gain_table[] = {
> > +	{ 32,    0},  /* x1 */
> > +	{ 34,    0},
> > +	{ 37,    0},
> > +	{ 39,    0},
> > +	{ 42,    0},
> > +	{ 45,    0},
> > +	{ 49,    0},
> > +	{ 52,    0},
> > +	{ 56,    0},
> > +	{ 60,    0},
> > +	{ 64,    0},  /* x2 */
> > +	{ 69,    0},
> > +	{ 74,    0},
> > +	{ 79,    0},
> > +	{ 84,    0},
> > +	{ 91,    0},
> > +	{ 97,    0},
> > +	{104,    0},
> > +	{111,    0},
> > +	{119,    0},
> > +	{128,    0},  /* x4 */
> > +	{137,    0},
> > +	{147,    0},
> > +	{158,    0},
> > +	{169,    0},
> > +	{181,    0},
> > +	{194,    0},
> > +	{208,    0},
> > +	{223,    0},
> > +	{239,    0},
> > +	{256,    0},  /* x8 */
> > +	{256,   73},
> > +	{256,  152},
> > +	{256,  236},
> > +	{256,  327},
> > +	{256,  424},
> > +	{256,  528},
> > +	{256,  639},
> > +	{256,  758},
> > +	{256,  886},
> > +	{256, 1023},  /* x16 */
> > +};
> > +
> > +/* Register definitions */
> > +#define REG_REVISION_NUMBER_L	0x1200
> > +#define REG_REVISION_NUMBER_H	0x1201
> > +
> > +#define PRIV_MEM_START_REG	0x0008
> > +#define PRIV_MEM_WIN_SIZE	8
> > +
> > +#define ET8EK8_I2C_DELAY	3	/* msec delay b/w accesses */
> > +
> > +#define USE_CRC			1
> > +
> > +/*
> > + * Register access helpers
> > + *
> > + * Read a 8/16/32-bit i2c register.  The value is returned in 'val'.
> > + * Returns zero if successful, or non-zero otherwise.
> > + */
> > +static int et8ek8_i2c_read_reg(struct i2c_client *client, u16 data_length,
> > +			       u16 reg, u32 *val)
> > +{
> > +	int r;
> > +	struct i2c_msg msg;
> > +	unsigned char data[4];
> > +
> > +	if (!client->adapter)
> > +		return -ENODEV;
> > +	if (data_length != ET8EK8_REG_8BIT && data_length != ET8EK8_REG_16BIT)
> > +		return -EINVAL;
> > +
> > +	msg.addr = client->addr;
> > +	msg.flags = 0;
> > +	msg.len = 2;
> > +	msg.buf = data;
> > +
> > +	/* high byte goes out first */
> > +	data[0] = (u8) (reg >> 8);
> > +	data[1] = (u8) (reg & 0xff);
> > +	r = i2c_transfer(client->adapter, &msg, 1);
> > +	if (r < 0)
> > +		goto err;
> > +
> > +	msg.len = data_length;
> > +	msg.flags = I2C_M_RD;
> > +	r = i2c_transfer(client->adapter, &msg, 1);
> > +	if (r < 0)
> > +		goto err;
> > +
> > +	*val = 0;
> > +	/* high byte comes first */
> > +	if (data_length == ET8EK8_REG_8BIT)
> > +		*val = data[0];
> > +	else
> > +		*val = (data[0] << 8) + data[1];
> > +
> > +	return 0;
> > +
> > +err:
> > +	dev_err(&client->dev, "read from offset 0x%x error %d\n", reg, r);
> > +
> > +	return r;
> > +}
> > +
> > +static void et8ek8_i2c_create_msg(struct i2c_client *client, u16 len, u16 reg,
> > +				  u32 val, struct i2c_msg *msg,
> > +				  unsigned char *buf)
> > +{
> > +	msg->addr = client->addr;
> > +	msg->flags = 0; /* Write */
> > +	msg->len = 2 + len;
> > +	msg->buf = buf;
> > +
> > +	/* high byte goes out first */
> > +	buf[0] = (u8) (reg >> 8);
> > +	buf[1] = (u8) (reg & 0xff);
> > +
> > +	switch (len) {
> > +	case ET8EK8_REG_8BIT:
> > +		buf[2] = (u8) (val) & 0xff;
> > +		break;
> > +	case ET8EK8_REG_16BIT:
> > +		buf[2] = (u8) (val >> 8) & 0xff;
> > +		buf[3] = (u8) (val & 0xff);
> > +		break;
> > +	default:
> > +		WARN_ONCE(1, ET8EK8_NAME ": %s: invalid message length.\n",
> > +			  __func__);
> > +	}
> > +}
> > +
> > +/*
> > + * A buffered write method that puts the wanted register write
> > + * commands in a message list and passes the list to the i2c framework
> > + */
> > +static int et8ek8_i2c_buffered_write_regs(struct i2c_client *client,
> > +					  const struct et8ek8_reg *wnext,
> > +					  int cnt)
> > +{
> > +	struct i2c_msg msg[ET8EK8_MAX_MSG];
> > +	unsigned char data[ET8EK8_MAX_MSG][6];
> > +	int wcnt = 0;
> > +	u16 reg, data_length;
> > +	u32 val;
> > +
> > +	if (WARN_ONCE(cnt > ET8EK8_MAX_MSG,
> > +		      ET8EK8_NAME ": %s: too many messages.\n", __func__)) {
> > +		return -EINVAL;
> > +	}
> > +
> > +	/* Create new write messages for all writes */
> > +	while (wcnt < cnt) {
> > +		data_length = wnext->type;
> > +		reg = wnext->reg;
> > +		val = wnext->val;
> > +		wnext++;
> > +
> > +		et8ek8_i2c_create_msg(client, data_length, reg,
> > +				    val, &msg[wcnt], &data[wcnt][0]);
> > +
> > +		/* Update write count */
> > +		wcnt++;
> > +	}
> > +
> > +	/* Now we send everything ... */
> > +	return i2c_transfer(client->adapter, msg, wcnt);
> > +}
> > +
> > +/*
> > + * Write a list of registers to i2c device.
> > + *
> > + * The list of registers is terminated by ET8EK8_REG_TERM.
> > + * Returns zero if successful, or non-zero otherwise.
> > + */
> > +static int et8ek8_i2c_write_regs(struct i2c_client *client,
> > +				 const struct et8ek8_reg *regs)
> > +{
> > +	int r, cnt = 0;
> > +	const struct et8ek8_reg *next;
> > +
> > +	if (!client->adapter)
> > +		return -ENODEV;
> > +
> > +	if (!regs)
> > +		return -EINVAL;
> > +
> > +	/* Initialize list pointers to the start of the list */
> > +	next = regs;
> > +
> > +	do {
> > +		/*
> > +		 * We have to go through the list to figure out how
> > +		 * many regular writes we have in a row
> > +		 */
> > +		while (next->type != ET8EK8_REG_TERM &&
> > +		       next->type != ET8EK8_REG_DELAY) {
> > +			/*
> > +			 * Here we check that the actual length fields
> > +			 * are valid
> > +			 */
> > +			if (WARN(next->type != ET8EK8_REG_8BIT &&
> > +				 next->type != ET8EK8_REG_16BIT,
> > +				 "Invalid type = %d", next->type)) {
> > +				return -EINVAL;
> > +			}
> > +			/*
> > +			 * Increment count of successive writes and
> > +			 * read pointer
> > +			 */
> > +			cnt++;
> > +			next++;
> > +		}
> > +
> > +		/* Now we start writing ... */
> > +		r = et8ek8_i2c_buffered_write_regs(client, regs, cnt);
> > +
> > +		/* ... and then check that everything was OK */
> > +		if (r < 0) {
> > +			dev_err(&client->dev, "i2c transfer error!\n");
> > +			return r;
> > +		}
> > +
> > +		/*
> > +		 * If we ran into a sleep statement when going through
> > +		 * the list, this is where we snooze for the required time
> > +		 */
> > +		if (next->type == ET8EK8_REG_DELAY) {
> > +			msleep(next->val);
> > +			/*
> > +			 * ZZZ ...
> > +			 * Update list pointers and cnt and start over ...
> > +			 */
> > +			next++;
> > +			regs = next;
> > +			cnt = 0;
> > +		}
> > +	} while (next->type != ET8EK8_REG_TERM);
> > +
> > +	return 0;
> > +}
> > +
> > +/*
> > + * Write to a 8/16-bit register.
> > + * Returns zero if successful, or non-zero otherwise.
> > + */
> > +static int et8ek8_i2c_write_reg(struct i2c_client *client, u16 data_length,
> > +				u16 reg, u32 val)
> > +{
> > +	int r;
> > +	struct i2c_msg msg;
> > +	unsigned char data[6];
> > +
> > +	if (!client->adapter)
> > +		return -ENODEV;
> > +	if (data_length != ET8EK8_REG_8BIT && data_length != ET8EK8_REG_16BIT)
> > +		return -EINVAL;
> > +
> > +	et8ek8_i2c_create_msg(client, data_length, reg, val, &msg, data);
> > +
> > +	r = i2c_transfer(client->adapter, &msg, 1);
> > +	if (r < 0)
> > +		dev_err(&client->dev,
> > +			"wrote 0x%x to offset 0x%x error %d\n", val, reg, r);
> > +	else
> > +		r = 0; /* on success i2c_transfer() returns messages trasfered */
> > +
> > +	return r;
> > +}
> > +
> > +static struct et8ek8_reglist *et8ek8_reglist_find_type(
> > +		struct et8ek8_meta_reglist *meta,
> > +		u16 type)
> > +{
> > +	struct et8ek8_reglist **next = &meta->reglist[0].ptr;
> > +
> > +	while (*next) {
> > +		if ((*next)->type == type)
> > +			return *next;
> > +
> > +		next++;
> > +	}
> > +
> > +	return NULL;
> > +}
> > +
> > +static int et8ek8_i2c_reglist_find_write(struct i2c_client *client,
> > +					 struct et8ek8_meta_reglist *meta,
> > +					 u16 type)
> > +{
> > +	struct et8ek8_reglist *reglist;
> > +
> > +	reglist = et8ek8_reglist_find_type(meta, type);
> > +	if (!reglist)
> > +		return -EINVAL;
> > +
> > +	return et8ek8_i2c_write_regs(client, reglist->regs);
> > +}
> > +
> > +static struct et8ek8_reglist **et8ek8_reglist_first(
> > +		struct et8ek8_meta_reglist *meta)
> > +{
> > +	return &meta->reglist[0].ptr;
> > +}
> > +
> > +static void et8ek8_reglist_to_mbus(const struct et8ek8_reglist *reglist,
> > +				   struct v4l2_mbus_framefmt *fmt)
> > +{
> > +	fmt->width = reglist->mode.window_width;
> > +	fmt->height = reglist->mode.window_height;
> > +
> > +	if (reglist->mode.pixel_format == V4L2_PIX_FMT_SGRBG10DPCM8)
> > +		fmt->code = MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8;
> > +	else
> > +		fmt->code = MEDIA_BUS_FMT_SGRBG10_1X10;
> > +}
> > +
> > +static struct et8ek8_reglist *et8ek8_reglist_find_mode_fmt(
> > +		struct et8ek8_meta_reglist *meta,
> > +		struct v4l2_mbus_framefmt *fmt)
> > +{
> > +	struct et8ek8_reglist **list = et8ek8_reglist_first(meta);
> > +	struct et8ek8_reglist *best_match = NULL;
> > +	struct et8ek8_reglist *best_other = NULL;
> > +	struct v4l2_mbus_framefmt format;
> > +	unsigned int max_dist_match = (unsigned int)-1;
> > +	unsigned int max_dist_other = (unsigned int)-1;
> > +
> > +	/*
> > +	 * Find the mode with the closest image size. The distance between
> > +	 * image sizes is the size in pixels of the non-overlapping regions
> > +	 * between the requested size and the frame-specified size.
> > +	 *
> > +	 * Store both the closest mode that matches the requested format, and
> > +	 * the closest mode for all other formats. The best match is returned
> > +	 * if found, otherwise the best mode with a non-matching format is
> > +	 * returned.
> > +	 */
> > +	for (; *list; list++) {
> > +		unsigned int dist;
> > +
> > +		if ((*list)->type != ET8EK8_REGLIST_MODE)
> > +			continue;
> > +
> > +		et8ek8_reglist_to_mbus(*list, &format);
> > +
> > +		dist = min(fmt->width, format.width)
> > +		     * min(fmt->height, format.height);
> > +		dist = format.width * format.height
> > +		     + fmt->width * fmt->height - 2 * dist;
> > +
> > +
> > +		if (fmt->code == format.code) {
> > +			if (dist < max_dist_match || !best_match) {
> > +				best_match = *list;
> > +				max_dist_match = dist;
> > +			}
> > +		} else {
> > +			if (dist < max_dist_other || !best_other) {
> > +				best_other = *list;
> > +				max_dist_other = dist;
> > +			}
> > +		}
> > +	}
> > +
> > +	return best_match ? best_match : best_other;
> > +}
> > +
> > +#define TIMEPERFRAME_AVG_FPS(t)						\
> > +	(((t).denominator + ((t).numerator >> 1)) / (t).numerator)
> > +
> > +static struct et8ek8_reglist *et8ek8_reglist_find_mode_ival(
> > +		struct et8ek8_meta_reglist *meta,
> > +		struct et8ek8_reglist *current_reglist,
> > +		struct v4l2_fract *timeperframe)
> > +{
> > +	int fps = TIMEPERFRAME_AVG_FPS(*timeperframe);
> > +	struct et8ek8_reglist **list = et8ek8_reglist_first(meta);
> > +	struct et8ek8_mode *current_mode = &current_reglist->mode;
> > +
> > +	for (; *list; list++) {
> > +		struct et8ek8_mode *mode = &(*list)->mode;
> > +
> > +		if ((*list)->type != ET8EK8_REGLIST_MODE)
> > +			continue;
> > +
> > +		if (mode->window_width != current_mode->window_width ||
> > +		    mode->window_height != current_mode->window_height)
> > +			continue;
> > +
> > +		if (TIMEPERFRAME_AVG_FPS(mode->timeperframe) == fps)
> > +			return *list;
> > +	}
> > +
> > +	return NULL;
> > +}
> > +
> > +static int et8ek8_reglist_cmp(const void *a, const void *b)
> > +{
> > +	const struct et8ek8_reglist **list1 = (const struct et8ek8_reglist **)a,
> > +		**list2 = (const struct et8ek8_reglist **)b;
> > +
> > +	/* Put real modes in the beginning. */
> > +	if ((*list1)->type == ET8EK8_REGLIST_MODE &&
> > +	    (*list2)->type != ET8EK8_REGLIST_MODE)
> > +		return -1;
> > +	if ((*list1)->type != ET8EK8_REGLIST_MODE &&
> > +	    (*list2)->type == ET8EK8_REGLIST_MODE)
> > +		return 1;
> > +
> > +	/* Descending width. */
> > +	if ((*list1)->mode.window_width > (*list2)->mode.window_width)
> > +		return -1;
> > +	if ((*list1)->mode.window_width < (*list2)->mode.window_width)
> > +		return 1;
> > +
> > +	if ((*list1)->mode.window_height > (*list2)->mode.window_height)
> > +		return -1;
> > +	if ((*list1)->mode.window_height < (*list2)->mode.window_height)
> > +		return 1;
> > +
> > +	return 0;
> > +}
> > +
> > +static int et8ek8_reglist_import(struct i2c_client *client,
> > +				 struct et8ek8_meta_reglist *meta)
> > +{
> > +	int nlists = 0, i;
> > +
> > +	dev_info(&client->dev, "meta_reglist version %s\n", meta->version);
> > +
> > +	while (meta->reglist[nlists].ptr)
> > +		nlists++;
> > +
> > +	if (!nlists)
> > +		return -EINVAL;
> > +
> > +	sort(&meta->reglist[0].ptr, nlists, sizeof(meta->reglist[0].ptr),
> > +	     et8ek8_reglist_cmp, NULL);
> > +
> > +	i = nlists;
> > +	nlists = 0;
> > +
> > +	while (i--) {
> > +		struct et8ek8_reglist *list;
> > +
> > +		list = meta->reglist[nlists].ptr;
> > +
> > +		dev_dbg(&client->dev,
> > +		       "%s: type %d\tw %d\th %d\tfmt %x\tival %d/%d\tptr %p\n",
> > +		       __func__,
> > +		       list->type,
> > +		       list->mode.window_width, list->mode.window_height,
> > +		       list->mode.pixel_format,
> > +		       list->mode.timeperframe.numerator,
> > +		       list->mode.timeperframe.denominator,
> > +		       (void *)meta->reglist[nlists].ptr);
> > +
> > +		nlists++;
> > +	}
> > +
> > +	return 0;
> > +}
> > +
> > +typedef unsigned int fixpoint8; /* .8 fixed point format. */
> > +
> > +/*
> > + * Return time of one row in microseconds
> > + * If the sensor is not set to any mode, return zero.
> > + */
> > +fixpoint8 et8ek8_get_row_time(struct et8ek8_sensor *sensor)
> > +{
> > +	unsigned int clock;	/* Pixel clock in Hz>>10 fixed point */
> > +	fixpoint8 rt;	/* Row time in .8 fixed point */
> > +
> > +	if (!sensor->current_reglist)
> > +		return 0;
> > +
> > +	clock = sensor->current_reglist->mode.pixel_clock;
> > +	clock = (clock + (1 << 9)) >> 10;
> > +	rt = sensor->current_reglist->mode.width * (1000000 >> 2);
> > +	rt = (rt + (clock >> 1)) / clock;
> > +
> > +	return rt;
> > +}
> > +
> > +/*
> > + * Convert exposure time `us' to rows. Modify `us' to make it to
> > + * correspond to the actual exposure time.
> > + */
> > +static int et8ek8_exposure_us_to_rows(struct et8ek8_sensor *sensor, u32 *us)
> 
> Should a driver do something like this to begin with?
> 
> The smiapp driver does use the native unit of exposure (lines) for the
> control and I think the et8ek8 driver should do so as well.
> 
> The HBLANK, VBLANK and PIXEL_RATE controls are used to provide the user with
> enough information to perform the conversion (if necessary).
> 
> > +{
> > +	unsigned int rows;	/* Exposure value as written to HW (ie. rows) */
> > +	fixpoint8 rt;	/* Row time in .8 fixed point */
> > +
> > +	/* Assume that the maximum exposure time is at most ~8 s,
> > +	 * and the maximum width (with blanking) ~8000 pixels.
> > +	 * The formula here is in principle as simple as
> > +	 *    rows = exptime / 1e6 / width * pixel_clock
> > +	 * but to get accurate results while coping with value ranges,
> > +	 * have to do some fixed point math.
> > +	 */
> > +
> > +	rt = et8ek8_get_row_time(sensor);
> > +	rows = ((*us << 8) + (rt >> 1)) / rt;
> > +
> > +	if (rows > sensor->current_reglist->mode.max_exp)
> > +		rows = sensor->current_reglist->mode.max_exp;
> > +
> > +	/* Set the exposure time to the rounded value */
> > +	*us = (rt * rows + (1 << 7)) >> 8;
> > +
> > +	return rows;
> > +}
> > +
> > +/*
> > + * Convert exposure time in rows to microseconds
> > + */
> > +static int et8ek8_exposure_rows_to_us(struct et8ek8_sensor *sensor, int rows)
> > +{
> > +	return (et8ek8_get_row_time(sensor) * rows + (1 << 7)) >> 8;
> > +}
> > +
> > +/* Called to change the V4L2 gain control value. This function
> > + * rounds and clamps the given value and updates the V4L2 control value.
> > + * If power is on, also updates the sensor analog and digital gains.
> > + * gain is in 0.1 EV (exposure value) units.
> > + */
> > +static int et8ek8_set_gain(struct et8ek8_sensor *sensor, s32 gain)
> > +{
> > +	struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
> > +	struct et8ek8_gain new;
> > +	int r;
> > +
> > +	new = et8ek8_gain_table[gain];
> > +
> > +	/* FIXME: optimise I2C writes! */
> > +	r = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT,
> > +				0x124a, new.analog >> 8);
> > +	if (r)
> > +		return r;
> > +	r = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT,
> > +				0x1249, new.analog & 0xff);
> > +	if (r)
> > +		return r;
> > +
> > +	r = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT,
> > +				0x124d, new.digital >> 8);
> > +	if (r)
> > +		return r;
> > +	r = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT,
> > +				0x124c, new.digital & 0xff);
> > +
> > +	return r;
> > +}
> > +
> > +static int et8ek8_set_test_pattern(struct et8ek8_sensor *sensor, s32 mode)
> > +{
> > +	struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
> > +	int cbh_mode, cbv_mode, tp_mode, din_sw, r1420, rval;
> > +
> > +	/* Values for normal mode */
> > +	cbh_mode = 0;
> > +	cbv_mode = 0;
> > +	tp_mode  = 0;
> > +	din_sw   = 0x00;
> > +	r1420    = 0xF0;
> > +
> > +	if (mode) {
> > +		/* Test pattern mode */
> > +		if (mode < 5) {
> > +			cbh_mode = 1;
> > +			cbv_mode = 1;
> > +			tp_mode  = mode + 3;
> > +		} else {
> > +			cbh_mode = 0;
> > +			cbv_mode = 0;
> > +			tp_mode  = mode - 4 + 3;
> > +		}
> > +
> > +		din_sw   = 0x01;
> > +		r1420    = 0xE0;
> > +	}
> > +
> > +	rval = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x111B,
> > +				    tp_mode << 4);
> > +	if (rval)
> > +		return rval;
> > +
> > +	rval = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x1121,
> > +				    cbh_mode << 7);
> > +	if (rval)
> > +		return rval;
> > +
> > +	rval = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x1124,
> > +				    cbv_mode << 7);
> > +	if (rval)
> > +		return rval;		
> > +
> > +	rval = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x112C, din_sw);
> > +	if (rval)
> > +		return rval;
> > +
> > +	rval = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x1420, r1420);
> > +	return rval;
> > +}
> > +
> > +/* -----------------------------------------------------------------------------
> > + * V4L2 controls
> > + */
> > +
> > +static int et8ek8_set_ctrl(struct v4l2_ctrl *ctrl)
> > +{
> > +	struct et8ek8_sensor *sensor =
> > +		container_of(ctrl->handler, struct et8ek8_sensor, ctrl_handler);
> > +	struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
> > +	int uninitialized_var(rows);
> > +
> > +	if (ctrl->id == V4L2_CID_EXPOSURE)
> > +		rows = et8ek8_exposure_us_to_rows(sensor, (u32 *)&ctrl->val);
> > +
> > +	switch (ctrl->id) {
> > +	case V4L2_CID_GAIN:
> > +		return et8ek8_set_gain(sensor, ctrl->val);
> > +
> > +	case V4L2_CID_EXPOSURE:
> > +		return et8ek8_i2c_write_reg(client, ET8EK8_REG_16BIT, 0x1243,
> > +					    swab16(rows));
> > +
> > +	case V4L2_CID_TEST_PATTERN:
> > +		return et8ek8_set_test_pattern(sensor, ctrl->val);
> > +
> > +	case V4L2_CID_PIXEL_RATE:
> > +		/* For v4l2_ctrl_s_ctrl_int64() used internally. */
> > +		return 0;
> > +
> > +	default:
> > +		return -EINVAL;
> > +	}
> > +}
> > +
> > +static const struct v4l2_ctrl_ops et8ek8_ctrl_ops = {
> > +	.s_ctrl = et8ek8_set_ctrl,
> > +};
> > +
> > +static const char * const et8ek8_test_pattern_menu[] = {
> > +	"Normal",
> > +	"Vertical colorbar",
> > +	"Horizontal colorbar",
> > +	"Scale",
> > +	"Ramp",
> > +	"Small vertical colorbar",
> > +	"Small horizontal colorbar",
> > +	"Small scale",
> > +	"Small ramp",
> > +};
> > +
> > +static int et8ek8_init_controls(struct et8ek8_sensor *sensor)
> > +{
> > +	u32 min, max;
> > +
> > +	v4l2_ctrl_handler_init(&sensor->ctrl_handler, 4);
> > +
> > +	/* V4L2_CID_GAIN */
> > +	v4l2_ctrl_new_std(&sensor->ctrl_handler, &et8ek8_ctrl_ops,
> > +			  V4L2_CID_GAIN, 0, ARRAY_SIZE(et8ek8_gain_table) - 1,
> > +			  1, 0);
> > +
> > +	/* V4L2_CID_EXPOSURE */
> > +	min = et8ek8_exposure_rows_to_us(sensor, 1);
> > +	max = et8ek8_exposure_rows_to_us(sensor,
> > +				sensor->current_reglist->mode.max_exp);
> > +	sensor->exposure =
> > +		v4l2_ctrl_new_std(&sensor->ctrl_handler, &et8ek8_ctrl_ops,
> > +				  V4L2_CID_EXPOSURE, min, max, min, max);
> > +
> > +	/* V4L2_CID_PIXEL_RATE */
> > +	sensor->pixel_rate =
> > +		v4l2_ctrl_new_std(&sensor->ctrl_handler, &et8ek8_ctrl_ops,
> > +		V4L2_CID_PIXEL_RATE, 1, INT_MAX, 1, 1);
> > +
> > +	/* V4L2_CID_TEST_PATTERN */
> > +	v4l2_ctrl_new_std_menu_items(&sensor->ctrl_handler,
> > +				     &et8ek8_ctrl_ops, V4L2_CID_TEST_PATTERN,
> > +				     ARRAY_SIZE(et8ek8_test_pattern_menu) - 1,
> > +				     0, 0, et8ek8_test_pattern_menu);
> > +
> > +	if (sensor->ctrl_handler.error)
> > +		return sensor->ctrl_handler.error;
> > +
> > +	sensor->subdev.ctrl_handler = &sensor->ctrl_handler;
> > +
> > +	return 0;
> > +}
> > +
> > +static void et8ek8_update_controls(struct et8ek8_sensor *sensor)
> > +{
> > +	struct v4l2_ctrl *ctrl = sensor->exposure;
> > +	struct et8ek8_mode *mode = &sensor->current_reglist->mode;
> > +	u32 min, max, pixel_rate;
> > +	static const int S = 8;
> > +
> > +	min = et8ek8_exposure_rows_to_us(sensor, 1);
> > +	max = et8ek8_exposure_rows_to_us(sensor, mode->max_exp);
> > +
> > +	/*
> > +	 * Calculate average pixel clock per line. Assume buffers can spread
> > +	 * the data over horizontal blanking time. Rounding upwards.
> > +	 * Formula taken from stock Nokia N900 kernel.
> > +	 */
> > +	pixel_rate = ((mode->pixel_clock + (1 << S) - 1) >> S) + mode->width;
> > +	pixel_rate = mode->window_width * (pixel_rate - 1) / mode->width;
> > +
> > +	v4l2_ctrl_lock(ctrl);
> > +	ctrl->minimum = min;
> > +	ctrl->maximum = max;
> > +	ctrl->step = min;
> > +	ctrl->default_value = max;
> > +	ctrl->val = max;
> > +	ctrl->cur.val = max;
> > +	__v4l2_ctrl_s_ctrl_int64(sensor->pixel_rate, pixel_rate << S);
> > +	v4l2_ctrl_unlock(ctrl);
> > +}
> > +
> > +static int et8ek8_configure(struct et8ek8_sensor *sensor)
> > +{
> > +	struct v4l2_subdev *subdev = &sensor->subdev;
> > +	struct i2c_client *client = v4l2_get_subdevdata(subdev);
> > +	int rval;
> > +
> > +	rval = et8ek8_i2c_write_regs(client, sensor->current_reglist->regs);
> > +	if (rval)
> > +		goto fail;
> > +
> > +	/* Controls set while the power to the sensor is turned off are saved
> > +	 * but not applied to the hardware. Now that we're about to start
> > +	 * streaming apply all the current values to the hardware.
> > +	 */
> > +	rval = v4l2_ctrl_handler_setup(&sensor->ctrl_handler);
> > +	if (rval)
> > +		goto fail;
> > +
> > +	return 0;
> > +
> > +fail:
> > +	dev_err(&client->dev, "sensor configuration failed\n");
> > +
> > +	return rval;
> > +}
> > +
> > +static int et8ek8_stream_on(struct et8ek8_sensor *sensor)
> > +{
> > +	struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
> > +
> > +	return et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x1252, 0xb0);
> > +}
> > +
> > +static int et8ek8_stream_off(struct et8ek8_sensor *sensor)
> > +{
> > +	struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
> > +
> > +	return et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x1252, 0x30);
> > +}
> > +
> > +static int et8ek8_s_stream(struct v4l2_subdev *subdev, int streaming)
> > +{
> > +	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
> > +	int ret;
> > +
> > +	if (!streaming)
> > +		return et8ek8_stream_off(sensor);
> > +
> > +	ret = et8ek8_configure(sensor);
> > +	if (ret < 0)
> > +		return ret;
> > +
> > +	return et8ek8_stream_on(sensor);
> > +}
> > +
> > +/* --------------------------------------------------------------------------
> > + * V4L2 subdev operations
> > + */
> > +
> > +static int et8ek8_power_off(struct et8ek8_sensor *sensor)
> > +{
> > +	gpiod_set_value(sensor->reset, 0);
> > +	udelay(1);
> > +
> > +	clk_disable_unprepare(sensor->ext_clk);
> > +
> > +	return regulator_disable(sensor->vana);
> > +}
> > +
> > +static int et8ek8_power_on(struct et8ek8_sensor *sensor)
> > +{
> > +	struct v4l2_subdev *subdev = &sensor->subdev;
> > +	struct i2c_client *client = v4l2_get_subdevdata(subdev);
> > +	unsigned int xclk_freq;
> > +	int val, rval;
> > +
> > +	rval = regulator_enable(sensor->vana);
> > +	if (rval) {
> > +		dev_err(&client->dev, "failed to enable vana regulator\n");
> > +		return rval;
> > +	}
> > +
> > +	if (sensor->current_reglist)
> > +		xclk_freq = sensor->current_reglist->mode.ext_clock;
> > +	else
> > +		xclk_freq = sensor->xclk_freq;
> > +
> > +	rval = clk_set_rate(sensor->ext_clk, xclk_freq);
> > +	if (rval < 0) {
> > +		dev_err(&client->dev, "unable to set extclk clock freq to %u\n",
> > +			xclk_freq);
> > +		goto out;
> > +	}
> > +	rval = clk_prepare_enable(sensor->ext_clk);
> > +	if (rval < 0) {
> > +		dev_err(&client->dev, "failed to enable extclk\n");
> > +		goto out;
> > +	}
> > +
> > +	if (rval)
> > +		goto out;
> > +
> > +	udelay(10); /* I wish this is a good value */
> > +
> > +	gpiod_set_value(sensor->reset, 1);
> > +
> > +	msleep(5000 * 1000 / xclk_freq + 1); /* Wait 5000 cycles */
> > +
> > +	rval = et8ek8_i2c_reglist_find_write(client, &meta_reglist,
> > +					     ET8EK8_REGLIST_POWERON);
> > +	if (rval)
> > +		goto out;
> > +
> > +#ifdef USE_CRC
> > +	rval = et8ek8_i2c_read_reg(client, ET8EK8_REG_8BIT, 0x1263, &val);
> > +	if (rval)
> > +		goto out;
> > +#if USE_CRC /* TODO get crc setting from DT */
> > +	val |= BIT(4);
> > +#else
> > +	val &= ~BIT(4);
> > +#endif
> > +	rval = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x1263, val);
> > +	if (rval)
> > +		goto out;
> > +#endif
> > +
> > +out:
> > +	if (rval)
> > +		et8ek8_power_off(sensor);
> > +
> > +	return rval;
> > +}
> > +
> > +/* --------------------------------------------------------------------------
> > + * V4L2 subdev video operations
> > + */
> > +#define MAX_FMTS 4
> > +static int et8ek8_enum_mbus_code(struct v4l2_subdev *subdev,
> > +				 struct v4l2_subdev_pad_config *cfg,
> > +				 struct v4l2_subdev_mbus_code_enum *code)
> > +{
> > +	struct et8ek8_reglist **list =
> > +			et8ek8_reglist_first(&meta_reglist);
> > +	u32 pixelformat[MAX_FMTS];
> > +	int npixelformat = 0;
> > +
> > +	if (code->index >= MAX_FMTS)
> > +		return -EINVAL;
> > +
> > +	for (; *list; list++) {
> > +		struct et8ek8_mode *mode = &(*list)->mode;
> > +		int i;
> > +
> > +		if ((*list)->type != ET8EK8_REGLIST_MODE)
> > +			continue;
> > +
> > +		for (i = 0; i < npixelformat; i++) {
> > +			if (pixelformat[i] == mode->pixel_format)
> > +				break;
> > +		}
> > +		if (i != npixelformat)
> > +			continue;
> > +
> > +		if (code->index == npixelformat) {
> > +			if (mode->pixel_format == V4L2_PIX_FMT_SGRBG10DPCM8)
> > +				code->code = MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8;
> > +			else
> > +				code->code = MEDIA_BUS_FMT_SGRBG10_1X10;
> > +			return 0;
> > +		}
> > +
> > +		pixelformat[npixelformat] = mode->pixel_format;
> > +		npixelformat++;
> > +	}
> > +
> > +	return -EINVAL;
> > +}
> > +
> > +static int et8ek8_enum_frame_size(struct v4l2_subdev *subdev,
> > +				  struct v4l2_subdev_pad_config *cfg,
> > +				  struct v4l2_subdev_frame_size_enum *fse)
> > +{
> > +	struct et8ek8_reglist **list =
> > +			et8ek8_reglist_first(&meta_reglist);
> > +	struct v4l2_mbus_framefmt format;
> > +	int cmp_width = INT_MAX;
> > +	int cmp_height = INT_MAX;
> > +	int index = fse->index;
> > +
> > +	for (; *list; list++) {
> > +		if ((*list)->type != ET8EK8_REGLIST_MODE)
> > +			continue;
> > +
> > +		et8ek8_reglist_to_mbus(*list, &format);
> > +		if (fse->code != format.code)
> > +			continue;
> > +
> > +		/* Assume that the modes are grouped by frame size. */
> > +		if (format.width == cmp_width && format.height == cmp_height)
> > +			continue;
> > +
> > +		cmp_width = format.width;
> > +		cmp_height = format.height;
> > +
> > +		if (index-- == 0) {
> > +			fse->min_width = format.width;
> > +			fse->min_height = format.height;
> > +			fse->max_width = format.width;
> > +			fse->max_height = format.height;
> > +			return 0;
> > +		}
> > +	}
> > +
> > +	return -EINVAL;
> > +}
> > +
> > +static int et8ek8_enum_frame_ival(struct v4l2_subdev *subdev,
> > +				  struct v4l2_subdev_pad_config *cfg,
> > +				  struct v4l2_subdev_frame_interval_enum *fie)
> > +{
> > +	struct et8ek8_reglist **list =
> > +			et8ek8_reglist_first(&meta_reglist);
> > +	struct v4l2_mbus_framefmt format;
> > +	int index = fie->index;
> > +
> > +	for (; *list; list++) {
> > +		struct et8ek8_mode *mode = &(*list)->mode;
> > +
> > +		if ((*list)->type != ET8EK8_REGLIST_MODE)
> > +			continue;
> > +
> > +		et8ek8_reglist_to_mbus(*list, &format);
> > +		if (fie->code != format.code)
> > +			continue;
> > +
> > +		if (fie->width != format.width || fie->height != format.height)
> > +			continue;
> > +
> > +		if (index-- == 0) {
> > +			fie->interval = mode->timeperframe;
> > +			return 0;
> > +		}
> > +	}
> > +
> > +	return -EINVAL;
> > +}
> > +
> > +static struct v4l2_mbus_framefmt *
> > +__et8ek8_get_pad_format(struct et8ek8_sensor *sensor,
> > +			struct v4l2_subdev_pad_config *cfg,
> > +			unsigned int pad, enum v4l2_subdev_format_whence which)
> > +{
> > +	switch (which) {
> > +	case V4L2_SUBDEV_FORMAT_TRY:
> > +		return v4l2_subdev_get_try_format(&sensor->subdev, cfg, pad);
> > +	case V4L2_SUBDEV_FORMAT_ACTIVE:
> > +		return &sensor->format;
> > +	default:
> > +		return NULL;
> > +	}
> > +}
> > +
> > +static int et8ek8_get_pad_format(struct v4l2_subdev *subdev,
> > +				 struct v4l2_subdev_pad_config *cfg,
> > +				 struct v4l2_subdev_format *fmt)
> > +{
> > +	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
> > +	struct v4l2_mbus_framefmt *format;
> > +
> > +	format = __et8ek8_get_pad_format(sensor, cfg, fmt->pad, fmt->which);
> > +	if (!format)
> > +		return -EINVAL;
> > +
> > +	fmt->format = *format;
> > +
> > +	return 0;
> > +}
> > +
> > +static int et8ek8_set_pad_format(struct v4l2_subdev *subdev,
> > +				 struct v4l2_subdev_pad_config *cfg,
> > +				 struct v4l2_subdev_format *fmt)
> > +{
> > +	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
> > +	struct v4l2_mbus_framefmt *format;
> > +	struct et8ek8_reglist *reglist;
> > +
> > +	format = __et8ek8_get_pad_format(sensor, cfg, fmt->pad, fmt->which);
> > +	if (!format)
> > +		return -EINVAL;
> > +
> > +	reglist = et8ek8_reglist_find_mode_fmt(&meta_reglist, &fmt->format);
> > +	et8ek8_reglist_to_mbus(reglist, &fmt->format);
> > +	*format = fmt->format;
> > +
> > +	if (fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
> > +		sensor->current_reglist = reglist;
> > +		et8ek8_update_controls(sensor);
> > +	}
> > +
> > +	return 0;
> > +}
> > +
> > +static int et8ek8_get_frame_interval(struct v4l2_subdev *subdev,
> > +				     struct v4l2_subdev_frame_interval *fi)
> > +{
> > +	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
> > +
> > +	memset(fi, 0, sizeof(*fi));
> > +	fi->interval = sensor->current_reglist->mode.timeperframe;
> > +
> > +	return 0;
> > +}
> > +
> > +static int et8ek8_set_frame_interval(struct v4l2_subdev *subdev,
> > +				     struct v4l2_subdev_frame_interval *fi)
> > +{
> > +	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
> > +	struct et8ek8_reglist *reglist;
> > +
> > +	reglist = et8ek8_reglist_find_mode_ival(&meta_reglist,
> > +						sensor->current_reglist,
> > +						&fi->interval);
> > +
> > +	if (!reglist)
> > +		return -EINVAL;
> > +
> > +	if (sensor->current_reglist->mode.ext_clock != reglist->mode.ext_clock)
> > +		return -EINVAL;
> > +
> > +	sensor->current_reglist = reglist;
> > +	et8ek8_update_controls(sensor);
> > +
> > +	return 0;
> > +}
> > +
> > +static int et8ek8_g_priv_mem(struct v4l2_subdev *subdev)
> > +{
> > +	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
> > +	struct i2c_client *client = v4l2_get_subdevdata(subdev);
> > +	unsigned int length = ET8EK8_PRIV_MEM_SIZE;
> > +	unsigned int offset = 0;
> > +	u8 *ptr  = sensor->priv_mem;
> > +	int rval = 0;
> > +
> > +	/* Read the EEPROM window-by-window, each window 8 bytes */
> > +	do {
> > +		u8 buffer[PRIV_MEM_WIN_SIZE];
> > +		struct i2c_msg msg;
> > +		int bytes, i;
> > +		int ofs;
> > +
> > +		/* Set the current window */
> > +		rval = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x0001,
> > +					    0xe0 | (offset >> 3));
> > +		if (rval < 0)
> > +			return rval;
> > +
> > +		/* Wait for status bit */
> > +		for (i = 0; i < 1000; ++i) {
> > +			u32 status;
> > +
> > +			rval = et8ek8_i2c_read_reg(client, ET8EK8_REG_8BIT,
> > +						   0x0003, &status);
> > +			if (rval < 0)
> > +				return rval;
> > +			if (!(status & 0x08))
> > +				break;
> > +			usleep_range(1000, 2000);
> > +		};
> > +
> > +		if (i == 1000)
> > +			return -EIO;
> > +
> > +		/* Read window, 8 bytes at once, and copy to user space */
> > +		ofs = offset & 0x07;	/* Offset within this window */
> > +		bytes = length + ofs > 8 ? 8-ofs : length;
> > +		msg.addr = client->addr;
> > +		msg.flags = 0;
> > +		msg.len = 2;
> > +		msg.buf = buffer;
> > +		ofs += PRIV_MEM_START_REG;
> > +		buffer[0] = (u8)(ofs >> 8);
> > +		buffer[1] = (u8)(ofs & 0xFF);
> > +
> > +		rval = i2c_transfer(client->adapter, &msg, 1);
> > +		if (rval < 0)
> > +			return rval;
> > +
> > +		mdelay(ET8EK8_I2C_DELAY);
> > +		msg.addr = client->addr;
> > +		msg.len = bytes;
> > +		msg.flags = I2C_M_RD;
> > +		msg.buf = buffer;
> > +		memset(buffer, 0, sizeof(buffer));
> > +
> > +		rval = i2c_transfer(client->adapter, &msg, 1);
> > +		if (rval < 0)
> > +			return rval;
> > +
> > +		rval = 0;
> > +		memcpy(ptr, buffer, bytes);
> > +
> > +		length -= bytes;
> > +		offset += bytes;
> > +		ptr += bytes;
> > +	} while (length > 0);
> > +
> > +	return rval;
> > +}
> > +
> > +static int et8ek8_dev_init(struct v4l2_subdev *subdev)
> > +{
> > +	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
> > +	struct i2c_client *client = v4l2_get_subdevdata(subdev);
> > +	int rval, rev_l, rev_h;
> > +
> > +	rval = et8ek8_power_on(sensor);
> > +	if (rval) {
> > +		dev_err(&client->dev, "could not power on\n");
> > +		return rval;
> > +	}
> > +
> > +	rval = et8ek8_i2c_read_reg(client, ET8EK8_REG_8BIT,
> > +				   REG_REVISION_NUMBER_L, &rev_l);
> > +	if (!rval)
> > +		rval = et8ek8_i2c_read_reg(client, ET8EK8_REG_8BIT,
> > +					   REG_REVISION_NUMBER_H, &rev_h);
> > +	if (rval) {
> > +		dev_err(&client->dev, "no et8ek8 sensor detected\n");
> > +		goto out_poweroff;
> > +	}
> > +
> > +	sensor->version = (rev_h << 8) + rev_l;
> > +	if (sensor->version != ET8EK8_REV_1 && sensor->version != ET8EK8_REV_2)
> > +		dev_info(&client->dev,
> > +			 "unknown version 0x%x detected, continuing anyway\n",
> > +			 sensor->version);
> > +
> > +	rval = et8ek8_reglist_import(client, &meta_reglist);
> > +	if (rval) {
> > +		dev_err(&client->dev,
> > +			"invalid register list %s, import failed\n",
> > +			ET8EK8_NAME);
> > +		goto out_poweroff;
> > +	}
> > +
> > +	sensor->current_reglist = et8ek8_reglist_find_type(&meta_reglist,
> > +							   ET8EK8_REGLIST_MODE);
> > +	if (!sensor->current_reglist) {
> > +		dev_err(&client->dev,
> > +			"invalid register list %s, no mode found\n",
> > +			ET8EK8_NAME);
> > +		rval = -ENODEV;
> > +		goto out_poweroff;
> > +	}
> > +
> > +	et8ek8_reglist_to_mbus(sensor->current_reglist, &sensor->format);
> > +
> > +	rval = et8ek8_i2c_reglist_find_write(client, &meta_reglist,
> > +					     ET8EK8_REGLIST_POWERON);
> > +	if (rval) {
> > +		dev_err(&client->dev,
> > +			"invalid register list %s, no POWERON mode found\n",
> > +			ET8EK8_NAME);
> > +		goto out_poweroff;
> > +	}
> > +	rval = et8ek8_stream_on(sensor); /* Needed to be able to read EEPROM */
> > +	if (rval)
> > +		goto out_poweroff;
> > +	rval = et8ek8_g_priv_mem(subdev);
> > +	if (rval)
> > +		dev_warn(&client->dev,
> > +			"can not read OTP (EEPROM) memory from sensor\n");
> > +	rval = et8ek8_stream_off(sensor);
> > +	if (rval)
> > +		goto out_poweroff;
> > +
> > +	rval = et8ek8_power_off(sensor);
> > +	if (rval)
> > +		goto out_poweroff;
> > +
> > +	return 0;
> > +
> > +out_poweroff:
> > +	et8ek8_power_off(sensor);
> > +
> > +	return rval;
> > +}
> > +
> > +/* --------------------------------------------------------------------------
> > + * sysfs attributes
> > + */
> > +static ssize_t
> > +et8ek8_priv_mem_read(struct device *dev, struct device_attribute *attr,
> > +		     char *buf)
> > +{
> > +	struct v4l2_subdev *subdev = i2c_get_clientdata(to_i2c_client(dev));
> > +	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
> > +
> > +#if PAGE_SIZE < ET8EK8_PRIV_MEM_SIZE
> > +#error PAGE_SIZE too small!
> > +#endif
> > +
> > +	memcpy(buf, sensor->priv_mem, ET8EK8_PRIV_MEM_SIZE);
> > +
> > +	return ET8EK8_PRIV_MEM_SIZE;
> > +}
> > +static DEVICE_ATTR(priv_mem, S_IRUGO, et8ek8_priv_mem_read, NULL);
> > +
> > +/* --------------------------------------------------------------------------
> > + * V4L2 subdev core operations
> > + */
> > +
> > +static int
> > +et8ek8_registered(struct v4l2_subdev *subdev)
> > +{
> > +	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
> > +	struct i2c_client *client = v4l2_get_subdevdata(subdev);
> > +	struct v4l2_mbus_framefmt *format;
> > +	int rval;
> > +
> > +	dev_dbg(&client->dev, "registered!");
> > +
> > +	rval = device_create_file(&client->dev, &dev_attr_priv_mem);
> > +	if (rval) {
> > +		dev_err(&client->dev, "could not register sysfs entry\n");
> > +		return rval;
> > +	}
> > +
> > +	rval = et8ek8_dev_init(subdev);
> > +	if (rval)
> > +		goto err_file;
> > +
> > +	rval = et8ek8_init_controls(sensor);
> > +	if (rval) {
> > +		dev_err(&client->dev, "controls initialization failed\n");
> > +		goto err_file;
> > +	}
> > +
> > +	format = __et8ek8_get_pad_format(sensor, NULL, 0,
> > +					 V4L2_SUBDEV_FORMAT_ACTIVE);
> > +	return 0;
> > +
> > +err_file:
> > +	device_remove_file(&client->dev, &dev_attr_priv_mem);
> > +
> > +	return rval;
> > +}
> > +
> > +static int __et8ek8_set_power(struct et8ek8_sensor *sensor, bool on)
> > +{
> > +	return on ? et8ek8_power_on(sensor) : et8ek8_power_off(sensor);
> > +}
> > +
> > +static int et8ek8_set_power(struct v4l2_subdev *subdev, int on)
> > +{
> > +	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
> > +	int ret = 0;
> > +
> > +	mutex_lock(&sensor->power_lock);
> > +
> > +	/* If the power count is modified from 0 to != 0 or from != 0 to 0,
> > +	 * update the power state.
> > +	 */
> > +	if (sensor->power_count == !on) {
> > +		ret = __et8ek8_set_power(sensor, !!on);
> > +		if (ret < 0)
> > +			goto done;
> > +	}
> > +
> > +	/* Update the power count. */
> > +	sensor->power_count += on ? 1 : -1;
> > +	WARN_ON(sensor->power_count < 0);
> > +
> > +done:
> > +	mutex_unlock(&sensor->power_lock);
> > +
> > +	return ret;
> > +}
> > +
> > +static int et8ek8_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
> > +{
> > +	struct et8ek8_sensor *sensor = to_et8ek8_sensor(sd);
> > +	struct v4l2_mbus_framefmt *format;
> > +	struct et8ek8_reglist *reglist;
> > +
> > +	reglist = et8ek8_reglist_find_type(&meta_reglist, ET8EK8_REGLIST_MODE);
> > +	format = __et8ek8_get_pad_format(sensor, fh->pad, 0,
> > +					 V4L2_SUBDEV_FORMAT_TRY);
> > +	et8ek8_reglist_to_mbus(reglist, format);
> > +
> > +	return et8ek8_set_power(sd, true);
> > +}
> > +
> > +static int et8ek8_close(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
> > +{
> > +	return et8ek8_set_power(sd, false);
> > +}
> > +
> > +static const struct v4l2_subdev_video_ops et8ek8_video_ops = {
> > +	.s_stream = et8ek8_s_stream,
> > +	.g_frame_interval = et8ek8_get_frame_interval,
> > +	.s_frame_interval = et8ek8_set_frame_interval,
> > +};
> > +
> > +static const struct v4l2_subdev_core_ops et8ek8_core_ops = {
> > +	.s_power = et8ek8_set_power,
> > +};
> > +
> > +static const struct v4l2_subdev_pad_ops et8ek8_pad_ops = {
> > +	.enum_mbus_code = et8ek8_enum_mbus_code,
> > +	.enum_frame_size = et8ek8_enum_frame_size,
> > +	.enum_frame_interval = et8ek8_enum_frame_ival,
> > +	.get_fmt = et8ek8_get_pad_format,
> > +	.set_fmt = et8ek8_set_pad_format,
> > +};
> > +
> > +static const struct v4l2_subdev_ops et8ek8_ops = {
> > +	.core = &et8ek8_core_ops,
> > +	.video = &et8ek8_video_ops,
> > +	.pad = &et8ek8_pad_ops,
> > +};
> > +
> > +static const struct v4l2_subdev_internal_ops et8ek8_internal_ops = {
> > +	.registered = et8ek8_registered,
> > +	.open = et8ek8_open,
> > +	.close = et8ek8_close,
> > +};
> > +
> > +/* --------------------------------------------------------------------------
> > + * I2C driver
> > + */
> > +#ifdef CONFIG_PM
> > +
> > +static int et8ek8_suspend(struct device *dev)
> > +{
> > +	struct i2c_client *client = to_i2c_client(dev);
> > +	struct v4l2_subdev *subdev = i2c_get_clientdata(client);
> > +	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
> > +
> > +	if (!sensor->power_count)
> > +		return 0;
> > +
> > +	return __et8ek8_set_power(sensor, false);
> > +}
> > +
> > +static int et8ek8_resume(struct device *dev)
> > +{
> > +	struct i2c_client *client = to_i2c_client(dev);
> > +	struct v4l2_subdev *subdev = i2c_get_clientdata(client);
> > +	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
> > +
> > +	if (!sensor->power_count)
> > +		return 0;
> > +
> > +	return __et8ek8_set_power(sensor, true);
> > +}
> > +
> > +#else
> > +
> > +#define et8ek8_suspend NULL
> > +#define et8ek8_resume NULL
> > +
> > +#endif /* CONFIG_PM */
> > +
> > +static int et8ek8_probe(struct i2c_client *client,
> > +			const struct i2c_device_id *devid)
> > +{
> > +	struct et8ek8_sensor *sensor;
> > +	struct device *dev = &client->dev;
> > +	int ret;
> > +
> > +	sensor = devm_kzalloc(&client->dev, sizeof(*sensor), GFP_KERNEL);
> > +	if (!sensor)
> > +		return -ENOMEM;
> > +
> > +	sensor->reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_LOW);
> > +	if (IS_ERR(sensor->reset)) {
> > +		dev_dbg(&client->dev, "could not request reset gpio\n");
> > +		return PTR_ERR(sensor->reset);
> > +	}
> > +
> > +	sensor->vana = devm_regulator_get(dev, "vana");
> > +	if (IS_ERR(sensor->vana)) {
> > +		dev_err(&client->dev, "could not get regulator for vana\n");
> > +		return PTR_ERR(sensor->vana);
> > +	}
> > +
> > +	sensor->ext_clk = devm_clk_get(dev, NULL);
> > +	if (IS_ERR(sensor->ext_clk)) {
> > +		dev_err(&client->dev, "could not get clock\n");
> > +		return PTR_ERR(sensor->ext_clk);
> > +	}
> > +
> > +	ret = of_property_read_u32(dev->of_node, "clock-frequency",
> > +				   &sensor->xclk_freq);
> > +	if (ret) {
> > +		dev_warn(dev, "can't get clock-frequency\n");
> > +		return ret;
> > +	}
> > +
> > +	mutex_init(&sensor->power_lock);
> 
> mutex_destroy() should be called on the mutex if probe fails after this and
> in remove().
> 
> > +
> > +	v4l2_i2c_subdev_init(&sensor->subdev, client, &et8ek8_ops);
> > +	sensor->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
> > +	sensor->subdev.internal_ops = &et8ek8_internal_ops;
> > +
> > +	sensor->pad.flags = MEDIA_PAD_FL_SOURCE;
> > +	ret = media_entity_pads_init(&sensor->subdev.entity, 1, &sensor->pad);
> > +	if (ret < 0) {
> > +		dev_err(&client->dev, "media entity init failed!\n");
> > +		return ret;
> > +	}
> > +
> > +	ret = v4l2_async_register_subdev(&sensor->subdev);
> > +	if (ret < 0) {
> > +		media_entity_cleanup(&sensor->subdev.entity);
> > +		return ret;
> > +	}
> > +
> > +	dev_dbg(dev, "initialized!\n");
> > +
> > +	return 0;
> > +}
> > +
> > +static int __exit et8ek8_remove(struct i2c_client *client)
> > +{
> > +	struct v4l2_subdev *subdev = i2c_get_clientdata(client);
> > +	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
> > +
> > +	if (sensor->power_count) {
> > +		gpiod_set_value(sensor->reset, 0);
> > +		clk_disable_unprepare(sensor->ext_clk);
> 
> How about the regulator? Could you call et8ek8_power_off() instead?
> 
> > +		sensor->power_count = 0;
> > +	}
> > +
> > +	v4l2_device_unregister_subdev(&sensor->subdev);
> > +	device_remove_file(&client->dev, &dev_attr_priv_mem);
> > +	v4l2_ctrl_handler_free(&sensor->ctrl_handler);
> > +	media_entity_cleanup(&sensor->subdev.entity);
> > +
> > +	return 0;
> > +}
> > +
> > +static const struct of_device_id et8ek8_of_table[] = {
> > +	{ .compatible = "toshiba,et8ek8" },
> > +	{ },
> > +};
> > +
> > +static const struct i2c_device_id et8ek8_id_table[] = {
> > +	{ ET8EK8_NAME, 0 },
> > +	{ }
> > +};
> > +MODULE_DEVICE_TABLE(i2c, et8ek8_id_table);
> > +
> > +static const struct dev_pm_ops et8ek8_pm_ops = {
> > +	.suspend	= et8ek8_suspend,
> > +	.resume		= et8ek8_resume,
> > +};
> > +
> > +static struct i2c_driver et8ek8_i2c_driver = {
> > +	.driver		= {
> > +		.name	= ET8EK8_NAME,
> > +		.pm	= &et8ek8_pm_ops,
> > +		.of_match_table	= et8ek8_of_table,
> > +	},
> > +	.probe		= et8ek8_probe,
> > +	.remove		= __exit_p(et8ek8_remove),
> > +	.id_table	= et8ek8_id_table,
> > +};
> > +
> > +module_i2c_driver(et8ek8_i2c_driver);
> > +
> > +MODULE_AUTHOR("Sakari Ailus <sakari.ailus@xxxxxx>");
> > +MODULE_DESCRIPTION("Toshiba ET8EK8 camera sensor driver");
> > +MODULE_LICENSE("GPL");
> > diff --git a/drivers/media/i2c/et8ek8/et8ek8_mode.c b/drivers/media/i2c/et8ek8/et8ek8_mode.c
> > new file mode 100644
> > index 0000000..956fc60
> > --- /dev/null
> > +++ b/drivers/media/i2c/et8ek8/et8ek8_mode.c
> > @@ -0,0 +1,587 @@
> > +/*
> > + * et8ek8_mode.c
> > + *
> > + * Copyright (C) 2008 Nokia Corporation
> > + *
> > + * Contact: Sakari Ailus <sakari.ailus@xxxxxx>
> > + *          Tuukka Toivonen <tuukka.o.toivonen@xxxxxxxxx>
> > + *
> > + * 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.
> > + *
> > + * This program is distributed in the hope that it will be useful, but
> > + * WITHOUT ANY WARRANTY; without even the implied warranty of
> > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
> > + * General Public License for more details.
> > + */
> > +
> > +#include "et8ek8_reg.h"
> > +
> > +/*
> > + * Stingray sensor mode settings for Scooby
> > + */
> > +
> > +/* Mode1_poweron_Mode2_16VGA_2592x1968_12.07fps */
> > +static struct et8ek8_reglist mode1_poweron_mode2_16vga_2592x1968_12_07fps = {
> > +/* (without the +1)
> > + * SPCK       = 80 MHz
> > + * CCP2       = 640 MHz
> > + * VCO        = 640 MHz
> > + * VCOUNT     = 84 (2016)
> > + * HCOUNT     = 137 (3288)
> > + * CKREF_DIV  = 2
> > + * CKVAR_DIV  = 200
> > + * VCO_DIV    = 0
> > + * SPCK_DIV   = 7
> > + * MRCK_DIV   = 7
> > + * LVDSCK_DIV = 0
> > + */
> > +	.type = ET8EK8_REGLIST_POWERON,
> > +	.mode = {
> > +		.sensor_width = 2592,
> > +		.sensor_height = 1968,
> > +		.sensor_window_origin_x = 0,
> > +		.sensor_window_origin_y = 0,
> > +		.sensor_window_width = 2592,
> > +		.sensor_window_height = 1968,
> > +		.width = 3288,
> > +		.height = 2016,
> > +		.window_origin_x = 0,
> > +		.window_origin_y = 0,
> > +		.window_width = 2592,
> > +		.window_height = 1968,
> > +		.pixel_clock = 80000000,
> > +		.ext_clock = 9600000,
> > +		.timeperframe = {
> > +			.numerator = 100,
> > +			.denominator = 1207
> > +		},
> > +		.max_exp = 2012,
> > +		/* .max_gain = 0, */
> > +		.pixel_format = V4L2_PIX_FMT_SGRBG10,
> > +		.sensitivity = 65536
> > +	},
> > +	.regs = {
> > +		/* Need to set firstly */
> > +		{ ET8EK8_REG_8BIT, 0x126C, 0xCC },
> > +		/* Strobe and Data of CCP2 delay are minimized. */
> > +		{ ET8EK8_REG_8BIT, 0x1269, 0x00 },
> > +		/* Refined value of Min H_COUNT  */
> > +		{ ET8EK8_REG_8BIT, 0x1220, 0x89 },
> > +		/* Frequency of SPCK setting (SPCK=MRCK) */
> > +		{ ET8EK8_REG_8BIT, 0x123A, 0x07 },
> > +		{ ET8EK8_REG_8BIT, 0x1241, 0x94 },
> > +		{ ET8EK8_REG_8BIT, 0x1242, 0x02 },
> > +		{ ET8EK8_REG_8BIT, 0x124B, 0x00 },
> > +		{ ET8EK8_REG_8BIT, 0x1255, 0xFF },
> > +		{ ET8EK8_REG_8BIT, 0x1256, 0x9F },
> > +		{ ET8EK8_REG_8BIT, 0x1258, 0x00 },
> > +		/* From parallel out to serial out */
> > +		{ ET8EK8_REG_8BIT, 0x125D, 0x88 },
> > +		/* From w/ embeded data to w/o embeded data */
> > +		{ ET8EK8_REG_8BIT, 0x125E, 0xC0 },
> > +		/* CCP2 out is from STOP to ACTIVE */
> > +		{ ET8EK8_REG_8BIT, 0x1263, 0x98 },
> > +		{ ET8EK8_REG_8BIT, 0x1268, 0xC6 },
> > +		{ ET8EK8_REG_8BIT, 0x1434, 0x00 },
> > +		{ ET8EK8_REG_8BIT, 0x1163, 0x44 },
> > +		{ ET8EK8_REG_8BIT, 0x1166, 0x29 },
> > +		{ ET8EK8_REG_8BIT, 0x1140, 0x02 },
> > +		{ ET8EK8_REG_8BIT, 0x1011, 0x24 },
> > +		{ ET8EK8_REG_8BIT, 0x1151, 0x80 },
> > +		{ ET8EK8_REG_8BIT, 0x1152, 0x23 },
> > +		/* Initial setting for improvement2 of lower frequency noise */
> > +		{ ET8EK8_REG_8BIT, 0x1014, 0x05 },
> > +		{ ET8EK8_REG_8BIT, 0x1033, 0x06 },
> > +		{ ET8EK8_REG_8BIT, 0x1034, 0x79 },
> > +		{ ET8EK8_REG_8BIT, 0x1423, 0x3F },
> > +		{ ET8EK8_REG_8BIT, 0x1424, 0x3F },
> > +		{ ET8EK8_REG_8BIT, 0x1426, 0x00 },
> > +		/* Switch of Preset-White-balance (0d:disable / 1d:enable) */
> > +		{ ET8EK8_REG_8BIT, 0x1439, 0x00 },
> > +		/* Switch of blemish correction (0d:disable / 1d:enable) */
> > +		{ ET8EK8_REG_8BIT, 0x161F, 0x60 },
> > +		/* Switch of auto noise correction (0d:disable / 1d:enable) */
> > +		{ ET8EK8_REG_8BIT, 0x1634, 0x00 },
> > +		{ ET8EK8_REG_8BIT, 0x1646, 0x00 },
> > +		{ ET8EK8_REG_8BIT, 0x1648, 0x00 },
> > +		{ ET8EK8_REG_8BIT, 0x113E, 0x01 },
> > +		{ ET8EK8_REG_8BIT, 0x113F, 0x22 },
> > +		{ ET8EK8_REG_8BIT, 0x1239, 0x64 },
> > +		{ ET8EK8_REG_8BIT, 0x1238, 0x02 },
> > +		{ ET8EK8_REG_8BIT, 0x123B, 0x70 },
> > +		{ ET8EK8_REG_8BIT, 0x123A, 0x07 },
> > +		{ ET8EK8_REG_8BIT, 0x121B, 0x64 },
> > +		{ ET8EK8_REG_8BIT, 0x121D, 0x64 },
> > +		{ ET8EK8_REG_8BIT, 0x1221, 0x00 },
> > +		{ ET8EK8_REG_8BIT, 0x1220, 0x89 },
> > +		{ ET8EK8_REG_8BIT, 0x1223, 0x00 },
> > +		{ ET8EK8_REG_8BIT, 0x1222, 0x54 },
> > +		{ ET8EK8_REG_8BIT, 0x125D, 0x88 }, /* CCP_LVDS_MODE/  */
> > +		{ ET8EK8_REG_TERM, 0, 0}
> > +	}
> > +};
> > +
> > +/* Mode1_16VGA_2592x1968_13.12fps_DPCM10-8 */
> > +static struct et8ek8_reglist mode1_16vga_2592x1968_13_12fps_dpcm10_8 = {
> > +/* (without the +1)
> > + * SPCK       = 80 MHz
> > + * CCP2       = 560 MHz
> > + * VCO        = 560 MHz
> > + * VCOUNT     = 84 (2016)
> > + * HCOUNT     = 128 (3072)
> > + * CKREF_DIV  = 2
> > + * CKVAR_DIV  = 175
> > + * VCO_DIV    = 0
> > + * SPCK_DIV   = 6
> > + * MRCK_DIV   = 7
> > + * LVDSCK_DIV = 0
> > + */
> > +	.type = ET8EK8_REGLIST_MODE,
> > +	.mode = {
> > +		.sensor_width = 2592,
> > +		.sensor_height = 1968,
> > +		.sensor_window_origin_x = 0,
> > +		.sensor_window_origin_y = 0,
> > +		.sensor_window_width = 2592,
> > +		.sensor_window_height = 1968,
> > +		.width = 3072,
> > +		.height = 2016,
> > +		.window_origin_x = 0,
> > +		.window_origin_y = 0,
> > +		.window_width = 2592,
> > +		.window_height = 1968,
> > +		.pixel_clock = 80000000,
> > +		.ext_clock = 9600000,
> > +		.timeperframe = {
> > +			.numerator = 100,
> > +			.denominator = 1292
> > +		},
> > +		.max_exp = 2012,
> > +		/* .max_gain = 0, */
> > +		.pixel_format = V4L2_PIX_FMT_SGRBG10DPCM8,
> > +		.sensitivity = 65536
> > +	},
> > +	.regs = {
> > +		{ ET8EK8_REG_8BIT, 0x1239, 0x57 },
> > +		{ ET8EK8_REG_8BIT, 0x1238, 0x82 },
> > +		{ ET8EK8_REG_8BIT, 0x123B, 0x70 },
> > +		{ ET8EK8_REG_8BIT, 0x123A, 0x06 },
> > +		{ ET8EK8_REG_8BIT, 0x121B, 0x64 },
> > +		{ ET8EK8_REG_8BIT, 0x121D, 0x64 },
> > +		{ ET8EK8_REG_8BIT, 0x1221, 0x00 },
> > +		{ ET8EK8_REG_8BIT, 0x1220, 0x80 }, /* <-changed to v14 7E->80 */
> > +		{ ET8EK8_REG_8BIT, 0x1223, 0x00 },
> > +		{ ET8EK8_REG_8BIT, 0x1222, 0x54 },
> > +		{ ET8EK8_REG_8BIT, 0x125D, 0x83 }, /* CCP_LVDS_MODE/  */
> > +		{ ET8EK8_REG_TERM, 0, 0}
> > +	}
> > +};
> > +
> > +/* Mode3_4VGA_1296x984_29.99fps_DPCM10-8 */
> > +static struct et8ek8_reglist mode3_4vga_1296x984_29_99fps_dpcm10_8 = {
> > +/* (without the +1)
> > + * SPCK       = 96.5333333333333 MHz
> > + * CCP2       = 579.2 MHz
> > + * VCO        = 579.2 MHz
> > + * VCOUNT     = 84 (2016)
> > + * HCOUNT     = 133 (3192)
> > + * CKREF_DIV  = 2
> > + * CKVAR_DIV  = 181
> > + * VCO_DIV    = 0
> > + * SPCK_DIV   = 5
> > + * MRCK_DIV   = 7
> > + * LVDSCK_DIV = 0
> > + */
> > +	.type = ET8EK8_REGLIST_MODE,
> > +	.mode = {
> > +		.sensor_width = 2592,
> > +		.sensor_height = 1968,
> > +		.sensor_window_origin_x = 0,
> > +		.sensor_window_origin_y = 0,
> > +		.sensor_window_width = 2592,
> > +		.sensor_window_height = 1968,
> > +		.width = 3192,
> > +		.height = 1008,
> > +		.window_origin_x = 0,
> > +		.window_origin_y = 0,
> > +		.window_width = 1296,
> > +		.window_height = 984,
> > +		.pixel_clock = 96533333,
> > +		.ext_clock = 9600000,
> > +		.timeperframe = {
> > +			.numerator = 100,
> > +			.denominator = 3000
> > +		},
> > +		.max_exp = 1004,
> > +		/* .max_gain = 0, */
> > +		.pixel_format = V4L2_PIX_FMT_SGRBG10DPCM8,
> > +		.sensitivity = 65536
> > +	},
> > +	.regs = {
> > +		{ ET8EK8_REG_8BIT, 0x1239, 0x5A },
> > +		{ ET8EK8_REG_8BIT, 0x1238, 0x82 },
> > +		{ ET8EK8_REG_8BIT, 0x123B, 0x70 },
> > +		{ ET8EK8_REG_8BIT, 0x123A, 0x05 },
> > +		{ ET8EK8_REG_8BIT, 0x121B, 0x63 },
> > +		{ ET8EK8_REG_8BIT, 0x1220, 0x85 },
> > +		{ ET8EK8_REG_8BIT, 0x1221, 0x00 },
> > +		{ ET8EK8_REG_8BIT, 0x1222, 0x54 },
> > +		{ ET8EK8_REG_8BIT, 0x1223, 0x00 },
> > +		{ ET8EK8_REG_8BIT, 0x121D, 0x63 },
> > +		{ ET8EK8_REG_8BIT, 0x125D, 0x83 }, /* CCP_LVDS_MODE/  */
> > +		{ ET8EK8_REG_TERM, 0, 0}
> > +	}
> > +};
> > +
> > +/* Mode4_SVGA_864x656_29.88fps */
> > +static struct et8ek8_reglist mode4_svga_864x656_29_88fps = {
> > +/* (without the +1)
> > + * SPCK       = 80 MHz
> > + * CCP2       = 320 MHz
> > + * VCO        = 640 MHz
> > + * VCOUNT     = 84 (2016)
> > + * HCOUNT     = 166 (3984)
> > + * CKREF_DIV  = 2
> > + * CKVAR_DIV  = 200
> > + * VCO_DIV    = 0
> > + * SPCK_DIV   = 7
> > + * MRCK_DIV   = 7
> > + * LVDSCK_DIV = 1
> > + */
> > +	.type = ET8EK8_REGLIST_MODE,
> > +	.mode = {
> > +		.sensor_width = 2592,
> > +		.sensor_height = 1968,
> > +		.sensor_window_origin_x = 0,
> > +		.sensor_window_origin_y = 0,
> > +		.sensor_window_width = 2592,
> > +		.sensor_window_height = 1968,
> > +		.width = 3984,
> > +		.height = 672,
> > +		.window_origin_x = 0,
> > +		.window_origin_y = 0,
> > +		.window_width = 864,
> > +		.window_height = 656,
> > +		.pixel_clock = 80000000,
> > +		.ext_clock = 9600000,
> > +		.timeperframe = {
> > +			.numerator = 100,
> > +			.denominator = 2988
> > +		},
> > +		.max_exp = 668,
> > +		/* .max_gain = 0, */
> > +		.pixel_format = V4L2_PIX_FMT_SGRBG10,
> > +		.sensitivity = 65536
> > +	},
> > +	.regs = {
> > +		{ ET8EK8_REG_8BIT, 0x1239, 0x64 },
> > +		{ ET8EK8_REG_8BIT, 0x1238, 0x02 },
> > +		{ ET8EK8_REG_8BIT, 0x123B, 0x71 },
> > +		{ ET8EK8_REG_8BIT, 0x123A, 0x07 },
> > +		{ ET8EK8_REG_8BIT, 0x121B, 0x62 },
> > +		{ ET8EK8_REG_8BIT, 0x121D, 0x62 },
> > +		{ ET8EK8_REG_8BIT, 0x1221, 0x00 },
> > +		{ ET8EK8_REG_8BIT, 0x1220, 0xA6 },
> > +		{ ET8EK8_REG_8BIT, 0x1223, 0x00 },
> > +		{ ET8EK8_REG_8BIT, 0x1222, 0x54 },
> > +		{ ET8EK8_REG_8BIT, 0x125D, 0x88 }, /* CCP_LVDS_MODE/  */
> > +		{ ET8EK8_REG_TERM, 0, 0}
> > +	}
> > +};
> > +
> > +/* Mode5_VGA_648x492_29.93fps */
> > +static struct et8ek8_reglist mode5_vga_648x492_29_93fps = {
> > +/* (without the +1)
> > + * SPCK       = 80 MHz
> > + * CCP2       = 320 MHz
> > + * VCO        = 640 MHz
> > + * VCOUNT     = 84 (2016)
> > + * HCOUNT     = 221 (5304)
> > + * CKREF_DIV  = 2
> > + * CKVAR_DIV  = 200
> > + * VCO_DIV    = 0
> > + * SPCK_DIV   = 7
> > + * MRCK_DIV   = 7
> > + * LVDSCK_DIV = 1
> > + */
> > +	.type = ET8EK8_REGLIST_MODE,
> > +	.mode = {
> > +		.sensor_width = 2592,
> > +		.sensor_height = 1968,
> > +		.sensor_window_origin_x = 0,
> > +		.sensor_window_origin_y = 0,
> > +		.sensor_window_width = 2592,
> > +		.sensor_window_height = 1968,
> > +		.width = 5304,
> > +		.height = 504,
> > +		.window_origin_x = 0,
> > +		.window_origin_y = 0,
> > +		.window_width = 648,
> > +		.window_height = 492,
> > +		.pixel_clock = 80000000,
> > +		.ext_clock = 9600000,
> > +		.timeperframe = {
> > +			.numerator = 100,
> > +			.denominator = 2993
> > +		},
> > +		.max_exp = 500,
> > +		/* .max_gain = 0, */
> > +		.pixel_format = V4L2_PIX_FMT_SGRBG10,
> > +		.sensitivity = 65536
> > +	},
> > +	.regs = {
> > +		{ ET8EK8_REG_8BIT, 0x1239, 0x64 },
> > +		{ ET8EK8_REG_8BIT, 0x1238, 0x02 },
> > +		{ ET8EK8_REG_8BIT, 0x123B, 0x71 },
> > +		{ ET8EK8_REG_8BIT, 0x123A, 0x07 },
> > +		{ ET8EK8_REG_8BIT, 0x121B, 0x61 },
> > +		{ ET8EK8_REG_8BIT, 0x121D, 0x61 },
> > +		{ ET8EK8_REG_8BIT, 0x1221, 0x00 },
> > +		{ ET8EK8_REG_8BIT, 0x1220, 0xDD },
> > +		{ ET8EK8_REG_8BIT, 0x1223, 0x00 },
> > +		{ ET8EK8_REG_8BIT, 0x1222, 0x54 },
> > +		{ ET8EK8_REG_8BIT, 0x125D, 0x88 }, /* CCP_LVDS_MODE/  */
> > +		{ ET8EK8_REG_TERM, 0, 0}
> > +	}
> > +};
> > +
> > +/* Mode2_16VGA_2592x1968_3.99fps */
> > +static struct et8ek8_reglist mode2_16vga_2592x1968_3_99fps = {
> > +/* (without the +1)
> > + * SPCK       = 80 MHz
> > + * CCP2       = 640 MHz
> > + * VCO        = 640 MHz
> > + * VCOUNT     = 254 (6096)
> > + * HCOUNT     = 137 (3288)
> > + * CKREF_DIV  = 2
> > + * CKVAR_DIV  = 200
> > + * VCO_DIV    = 0
> > + * SPCK_DIV   = 7
> > + * MRCK_DIV   = 7
> > + * LVDSCK_DIV = 0
> > + */
> > +	.type = ET8EK8_REGLIST_MODE,
> > +	.mode = {
> > +		.sensor_width = 2592,
> > +		.sensor_height = 1968,
> > +		.sensor_window_origin_x = 0,
> > +		.sensor_window_origin_y = 0,
> > +		.sensor_window_width = 2592,
> > +		.sensor_window_height = 1968,
> > +		.width = 3288,
> > +		.height = 6096,
> > +		.window_origin_x = 0,
> > +		.window_origin_y = 0,
> > +		.window_width = 2592,
> > +		.window_height = 1968,
> > +		.pixel_clock = 80000000,
> > +		.ext_clock = 9600000,
> > +		.timeperframe = {
> > +			.numerator = 100,
> > +			.denominator = 399
> > +		},
> > +		.max_exp = 6092,
> > +		/* .max_gain = 0, */
> > +		.pixel_format = V4L2_PIX_FMT_SGRBG10,
> > +		.sensitivity = 65536
> > +	},
> > +	.regs = {
> > +		{ ET8EK8_REG_8BIT, 0x1239, 0x64 },
> > +		{ ET8EK8_REG_8BIT, 0x1238, 0x02 },
> > +		{ ET8EK8_REG_8BIT, 0x123B, 0x70 },
> > +		{ ET8EK8_REG_8BIT, 0x123A, 0x07 },
> > +		{ ET8EK8_REG_8BIT, 0x121B, 0x64 },
> > +		{ ET8EK8_REG_8BIT, 0x121D, 0x64 },
> > +		{ ET8EK8_REG_8BIT, 0x1221, 0x00 },
> > +		{ ET8EK8_REG_8BIT, 0x1220, 0x89 },
> > +		{ ET8EK8_REG_8BIT, 0x1223, 0x00 },
> > +		{ ET8EK8_REG_8BIT, 0x1222, 0xFE },
> > +		{ ET8EK8_REG_TERM, 0, 0}
> > +	}
> > +};
> > +
> > +/* Mode_648x492_5fps */
> > +static struct et8ek8_reglist mode_648x492_5fps = {
> > +/* (without the +1)
> > + * SPCK       = 13.3333333333333 MHz
> > + * CCP2       = 53.3333333333333 MHz
> > + * VCO        = 640 MHz
> > + * VCOUNT     = 84 (2016)
> > + * HCOUNT     = 221 (5304)
> > + * CKREF_DIV  = 2
> > + * CKVAR_DIV  = 200
> > + * VCO_DIV    = 5
> > + * SPCK_DIV   = 7
> > + * MRCK_DIV   = 7
> > + * LVDSCK_DIV = 1
> > + */
> > +	.type = ET8EK8_REGLIST_MODE,
> > +	.mode = {
> > +		.sensor_width = 2592,
> > +		.sensor_height = 1968,
> > +		.sensor_window_origin_x = 0,
> > +		.sensor_window_origin_y = 0,
> > +		.sensor_window_width = 2592,
> > +		.sensor_window_height = 1968,
> > +		.width = 5304,
> > +		.height = 504,
> > +		.window_origin_x = 0,
> > +		.window_origin_y = 0,
> > +		.window_width = 648,
> > +		.window_height = 492,
> > +		.pixel_clock = 13333333,
> > +		.ext_clock = 9600000,
> > +		.timeperframe = {
> > +			.numerator = 100,
> > +			.denominator = 499
> > +		},
> > +		.max_exp = 500,
> > +		/* .max_gain = 0, */
> > +		.pixel_format = V4L2_PIX_FMT_SGRBG10,
> > +		.sensitivity = 65536
> > +	},
> > +	.regs = {
> > +		{ ET8EK8_REG_8BIT, 0x1239, 0x64 },
> > +		{ ET8EK8_REG_8BIT, 0x1238, 0x02 },
> > +		{ ET8EK8_REG_8BIT, 0x123B, 0x71 },
> > +		{ ET8EK8_REG_8BIT, 0x123A, 0x57 },
> > +		{ ET8EK8_REG_8BIT, 0x121B, 0x61 },
> > +		{ ET8EK8_REG_8BIT, 0x121D, 0x61 },
> > +		{ ET8EK8_REG_8BIT, 0x1221, 0x00 },
> > +		{ ET8EK8_REG_8BIT, 0x1220, 0xDD },
> > +		{ ET8EK8_REG_8BIT, 0x1223, 0x00 },
> > +		{ ET8EK8_REG_8BIT, 0x1222, 0x54 },
> > +		{ ET8EK8_REG_8BIT, 0x125D, 0x88 }, /* CCP_LVDS_MODE/  */
> > +		{ ET8EK8_REG_TERM, 0, 0}
> > +	}
> > +};
> > +
> > +/* Mode3_4VGA_1296x984_5fps */
> > +static struct et8ek8_reglist mode3_4vga_1296x984_5fps = {
> > +/* (without the +1)
> > + * SPCK       = 49.4 MHz
> > + * CCP2       = 395.2 MHz
> > + * VCO        = 790.4 MHz
> > + * VCOUNT     = 250 (6000)
> > + * HCOUNT     = 137 (3288)
> > + * CKREF_DIV  = 2
> > + * CKVAR_DIV  = 247
> > + * VCO_DIV    = 1
> > + * SPCK_DIV   = 7
> > + * MRCK_DIV   = 7
> > + * LVDSCK_DIV = 0
> > + */
> > +	.type = ET8EK8_REGLIST_MODE,
> > +	.mode = {
> > +		.sensor_width = 2592,
> > +		.sensor_height = 1968,
> > +		.sensor_window_origin_x = 0,
> > +		.sensor_window_origin_y = 0,
> > +		.sensor_window_width = 2592,
> > +		.sensor_window_height = 1968,
> > +		.width = 3288,
> > +		.height = 3000,
> > +		.window_origin_x = 0,
> > +		.window_origin_y = 0,
> > +		.window_width = 1296,
> > +		.window_height = 984,
> > +		.pixel_clock = 49400000,
> > +		.ext_clock = 9600000,
> > +		.timeperframe = {
> > +			.numerator = 100,
> > +			.denominator = 501
> > +		},
> > +		.max_exp = 2996,
> > +		/* .max_gain = 0, */
> > +		.pixel_format = V4L2_PIX_FMT_SGRBG10,
> > +		.sensitivity = 65536
> > +	},
> > +	.regs = {
> > +		{ ET8EK8_REG_8BIT, 0x1239, 0x7B },
> > +		{ ET8EK8_REG_8BIT, 0x1238, 0x82 },
> > +		{ ET8EK8_REG_8BIT, 0x123B, 0x70 },
> > +		{ ET8EK8_REG_8BIT, 0x123A, 0x17 },
> > +		{ ET8EK8_REG_8BIT, 0x121B, 0x63 },
> > +		{ ET8EK8_REG_8BIT, 0x121D, 0x63 },
> > +		{ ET8EK8_REG_8BIT, 0x1221, 0x00 },
> > +		{ ET8EK8_REG_8BIT, 0x1220, 0x89 },
> > +		{ ET8EK8_REG_8BIT, 0x1223, 0x00 },
> > +		{ ET8EK8_REG_8BIT, 0x1222, 0xFA },
> > +		{ ET8EK8_REG_8BIT, 0x125D, 0x88 }, /* CCP_LVDS_MODE/  */
> > +		{ ET8EK8_REG_TERM, 0, 0}
> > +	}
> > +};
> > +
> > +/* Mode_4VGA_1296x984_25fps_DPCM10-8 */
> > +static struct et8ek8_reglist mode_4vga_1296x984_25fps_dpcm10_8 = {
> > +/* (without the +1)
> > + * SPCK       = 84.2666666666667 MHz
> > + * CCP2       = 505.6 MHz
> > + * VCO        = 505.6 MHz
> > + * VCOUNT     = 88 (2112)
> > + * HCOUNT     = 133 (3192)
> > + * CKREF_DIV  = 2
> > + * CKVAR_DIV  = 158
> > + * VCO_DIV    = 0
> > + * SPCK_DIV   = 5
> > + * MRCK_DIV   = 7
> > + * LVDSCK_DIV = 0
> > + */
> > +	.type = ET8EK8_REGLIST_MODE,
> > +	.mode = {
> > +		.sensor_width = 2592,
> > +		.sensor_height = 1968,
> > +		.sensor_window_origin_x = 0,
> > +		.sensor_window_origin_y = 0,
> > +		.sensor_window_width = 2592,
> > +		.sensor_window_height = 1968,
> > +		.width = 3192,
> > +		.height = 1056,
> > +		.window_origin_x = 0,
> > +		.window_origin_y = 0,
> > +		.window_width = 1296,
> > +		.window_height = 984,
> > +		.pixel_clock = 84266667,
> > +		.ext_clock = 9600000,
> > +		.timeperframe = {
> > +			.numerator = 100,
> > +			.denominator = 2500
> > +		},
> > +		.max_exp = 1052,
> > +		/* .max_gain = 0, */
> > +		.pixel_format = V4L2_PIX_FMT_SGRBG10DPCM8,
> > +		.sensitivity = 65536
> > +	},
> > +	.regs = {
> > +		{ ET8EK8_REG_8BIT, 0x1239, 0x4F },
> > +		{ ET8EK8_REG_8BIT, 0x1238, 0x02 },
> > +		{ ET8EK8_REG_8BIT, 0x123B, 0x70 },
> > +		{ ET8EK8_REG_8BIT, 0x123A, 0x05 },
> > +		{ ET8EK8_REG_8BIT, 0x121B, 0x63 },
> > +		{ ET8EK8_REG_8BIT, 0x1220, 0x85 },
> > +		{ ET8EK8_REG_8BIT, 0x1221, 0x00 },
> > +		{ ET8EK8_REG_8BIT, 0x1222, 0x58 },
> > +		{ ET8EK8_REG_8BIT, 0x1223, 0x00 },
> > +		{ ET8EK8_REG_8BIT, 0x121D, 0x63 },
> > +		{ ET8EK8_REG_8BIT, 0x125D, 0x83 },
> > +		{ ET8EK8_REG_TERM, 0, 0}
> > +	}
> > +};
> > +
> > +struct et8ek8_meta_reglist meta_reglist = {
> > +	.version = "V14 03-June-2008",
> > +	.reglist = {
> > +		{ .ptr = &mode1_poweron_mode2_16vga_2592x1968_12_07fps },
> > +		{ .ptr = &mode1_16vga_2592x1968_13_12fps_dpcm10_8 },
> > +		{ .ptr = &mode3_4vga_1296x984_29_99fps_dpcm10_8 },
> > +		{ .ptr = &mode4_svga_864x656_29_88fps },
> > +		{ .ptr = &mode5_vga_648x492_29_93fps },
> > +		{ .ptr = &mode2_16vga_2592x1968_3_99fps },
> > +		{ .ptr = &mode_648x492_5fps },
> > +		{ .ptr = &mode3_4vga_1296x984_5fps },
> > +		{ .ptr = &mode_4vga_1296x984_25fps_dpcm10_8 },
> > +		{ .ptr = NULL }
> > +	}
> > +};
> > diff --git a/drivers/media/i2c/et8ek8/et8ek8_reg.h b/drivers/media/i2c/et8ek8/et8ek8_reg.h
> > new file mode 100644
> > index 0000000..9970bff
> > --- /dev/null
> > +++ b/drivers/media/i2c/et8ek8/et8ek8_reg.h
> > @@ -0,0 +1,96 @@
> > +/*
> > + * et8ek8.h
> 
> et8ek8_reg.h
> 
> > + *
> > + * Copyright (C) 2008 Nokia Corporation
> > + *
> > + * Contact: Sakari Ailus <sakari.ailus@xxxxxx>
> > + *          Tuukka Toivonen <tuukkat76@xxxxxxxxx>
> > + *
> > + * 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.
> > + *
> > + * This program is distributed in the hope that it will be useful, but
> > + * WITHOUT ANY WARRANTY; without even the implied warranty of
> > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
> > + * General Public License for more details.
> > + */
> > +
> > +#ifndef ET8EK8REGS_H
> > +#define ET8EK8REGS_H
> > +
> > +#include <linux/i2c.h>
> > +#include <linux/types.h>
> > +#include <linux/videodev2.h>
> > +#include <linux/v4l2-subdev.h>
> > +
> > +struct v4l2_mbus_framefmt;
> > +struct v4l2_subdev_pad_mbus_code_enum;
> > +
> > +struct et8ek8_mode {
> > +	/* Physical sensor resolution and current image window */
> > +	u16 sensor_width;
> > +	u16 sensor_height;
> > +	u16 sensor_window_origin_x;
> > +	u16 sensor_window_origin_y;
> > +	u16 sensor_window_width;
> > +	u16 sensor_window_height;
> > +
> > +	/* Image data coming from sensor (after scaling) */
> > +	u16 width;
> > +	u16 height;
> > +	u16 window_origin_x;
> > +	u16 window_origin_y;
> > +	u16 window_width;
> > +	u16 window_height;
> > +
> > +	u32 pixel_clock;		/* in Hz */
> > +	u32 ext_clock;			/* in Hz */
> > +	struct v4l2_fract timeperframe;
> > +	u32 max_exp;			/* Maximum exposure value */
> > +	u32 pixel_format;		/* V4L2_PIX_FMT_xxx */
> > +	u32 sensitivity;		/* 16.16 fixed point */
> > +};
> > +
> > +#define ET8EK8_REG_8BIT			1
> > +#define ET8EK8_REG_16BIT		2
> > +#define ET8EK8_REG_DELAY		100
> > +#define ET8EK8_REG_TERM			0xff
> > +struct et8ek8_reg {
> > +	u16 type;
> > +	u16 reg;			/* 16-bit offset */
> > +	u32 val;			/* 8/16/32-bit value */
> > +};
> > +
> > +/* Possible struct smia_reglist types. */
> > +#define ET8EK8_REGLIST_STANDBY		0
> > +#define ET8EK8_REGLIST_POWERON		1
> > +#define ET8EK8_REGLIST_RESUME		2
> > +#define ET8EK8_REGLIST_STREAMON		3
> > +#define ET8EK8_REGLIST_STREAMOFF	4
> > +#define ET8EK8_REGLIST_DISABLED		5
> > +
> > +#define ET8EK8_REGLIST_MODE		10
> > +
> > +#define ET8EK8_REGLIST_LSC_ENABLE	100
> > +#define ET8EK8_REGLIST_LSC_DISABLE	101
> > +#define ET8EK8_REGLIST_ANR_ENABLE	102
> > +#define ET8EK8_REGLIST_ANR_DISABLE	103
> > +
> > +struct et8ek8_reglist {
> > +	u32 type;
> > +	struct et8ek8_mode mode;
> > +	struct et8ek8_reg regs[];
> > +};
> > +
> > +#define ET8EK8_MAX_LEN			32
> > +struct et8ek8_meta_reglist {
> > +	char version[ET8EK8_MAX_LEN];
> > +	union {
> > +		struct et8ek8_reglist *ptr;
> > +	} reglist[];
> > +};
> > +
> > +extern struct et8ek8_meta_reglist meta_reglist;
> > +
> > +#endif /* ET8EK8REGS */
> > 
> 

-- 
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html

Attachment: signature.asc
Description: Digital signature


[Index of Archives]     [Linux Input]     [Video for Linux]     [Gstreamer Embedded]     [Mplayer Users]     [Linux USB Devel]     [Linux Audio Users]     [Linux Kernel]     [Linux SCSI]     [Yosemite Backpacking]
  Powered by Linux