[media] media: i2c: ADV7604: Migrate to regmap (f862f57d) · Commits · e / devices / android_kernel_teracube_2e

drivers/media/i2c/adv7604.c

+256 −95

Original line number	Original line	Diff line number	Diff line
	@@ -37,6 +37,7 @@
	#include <linux/v4l2-dv-timings.h>		#include <linux/v4l2-dv-timings.h>
	#include <linux/videodev2.h>		#include <linux/videodev2.h>
	#include <linux/workqueue.h>		#include <linux/workqueue.h>
			#include <linux/regmap.h>

	#include <media/adv7604.h>		#include <media/adv7604.h>
	#include <media/v4l2-ctrls.h>		#include <media/v4l2-ctrls.h>
	@@ -188,6 +189,9 @@ struct adv76xx_state {
	/* i2c clients */		/* i2c clients */
	struct i2c_client *i2c_clients[ADV76XX_PAGE_MAX];		struct i2c_client *i2c_clients[ADV76XX_PAGE_MAX];

			/* Regmaps */
			struct regmap *regmap[ADV76XX_PAGE_MAX];

	/* controls */		/* controls */
	struct v4l2_ctrl *detect_tx_5v_ctrl;		struct v4l2_ctrl *detect_tx_5v_ctrl;
	struct v4l2_ctrl *analog_sampling_phase_ctrl;		struct v4l2_ctrl *analog_sampling_phase_ctrl;
	@@ -373,66 +377,39 @@ static inline unsigned vtotal(const struct v4l2_bt_timings *t)

	/* ----------------------------------------------------------------------- */		/* ----------------------------------------------------------------------- */

	static s32 adv_smbus_read_byte_data_check(struct i2c_client *client,		static int adv76xx_read_check(struct adv76xx_state *state,
	u8 command, bool check)		int client_page, u8 reg)
	{		{
	union i2c_smbus_data data;		struct i2c_client *client = state->i2c_clients[client_page];
			int err;
			unsigned int val;

	if (!i2c_smbus_xfer(client->adapter, client->addr, client->flags,		err = regmap_read(state->regmap[client_page], reg, &val);
	I2C_SMBUS_READ, command,
	I2C_SMBUS_BYTE_DATA, &data))		if (err) {
	return data.byte;
	if (check)
	v4l_err(client, "error reading %02x, %02x\n",		v4l_err(client, "error reading %02x, %02x\n",
	client->addr, command);		client->addr, reg);
	return -EIO;		return err;
	}		}
			return val;
	static s32 adv_smbus_read_byte_data(struct adv76xx_state *state,
	enum adv76xx_page page, u8 command)
	{
	return adv_smbus_read_byte_data_check(state->i2c_clients[page],
	command, true);
	}		}

	static s32 adv_smbus_write_byte_data(struct adv76xx_state *state,		/* adv76xx_write_block(): Write raw data with a maximum of I2C_SMBUS_BLOCK_MAX
	enum adv76xx_page page, u8 command,		* size to one or more registers.
	u8 value)		*
			* A value of zero will be returned on success, a negative errno will
			* be returned in error cases.
			*/
			static int adv76xx_write_block(struct adv76xx_state *state, int client_page,
			unsigned int init_reg, const void *val,
			size_t val_len)
	{		{
	struct i2c_client *client = state->i2c_clients[page];		struct regmap *regmap = state->regmap[client_page];
	union i2c_smbus_data data;
	int err;
	int i;

	data.byte = value;
	for (i = 0; i < 3; i++) {
	err = i2c_smbus_xfer(client->adapter, client->addr,
	client->flags,
	I2C_SMBUS_WRITE, command,
	I2C_SMBUS_BYTE_DATA, &data);
	if (!err)
	break;
	}
	if (err < 0)
	v4l_err(client, "error writing %02x, %02x, %02x\n",
	client->addr, command, value);
	return err;
	}

	static s32 adv_smbus_write_i2c_block_data(struct adv76xx_state *state,		if (val_len > I2C_SMBUS_BLOCK_MAX)
	enum adv76xx_page page, u8 command,		val_len = I2C_SMBUS_BLOCK_MAX;
	unsigned length, const u8 *values)
	{
	struct i2c_client *client = state->i2c_clients[page];
	union i2c_smbus_data data;

	if (length > I2C_SMBUS_BLOCK_MAX)		return regmap_raw_write(regmap, init_reg, val, val_len);
	length = I2C_SMBUS_BLOCK_MAX;
	data.block[0] = length;
	memcpy(data.block + 1, values, length);
	return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
	I2C_SMBUS_WRITE, command,
	I2C_SMBUS_I2C_BLOCK_DATA, &data);
	}		}

	/* ----------------------------------------------------------------------- */		/* ----------------------------------------------------------------------- */
	@@ -441,14 +418,14 @@ static inline int io_read(struct v4l2_subdev *sd, u8 reg)
	{		{
	struct adv76xx_state *state = to_state(sd);		struct adv76xx_state *state = to_state(sd);

	return adv_smbus_read_byte_data(state, ADV76XX_PAGE_IO, reg);		return adv76xx_read_check(state, ADV76XX_PAGE_IO, reg);
	}		}

	static inline int io_write(struct v4l2_subdev *sd, u8 reg, u8 val)		static inline int io_write(struct v4l2_subdev *sd, u8 reg, u8 val)
	{		{
	struct adv76xx_state *state = to_state(sd);		struct adv76xx_state *state = to_state(sd);

	return adv_smbus_write_byte_data(state, ADV76XX_PAGE_IO, reg, val);		return regmap_write(state->regmap[ADV76XX_PAGE_IO], reg, val);
	}		}

	static inline int io_write_clr_set(struct v4l2_subdev *sd, u8 reg, u8 mask, u8 val)		static inline int io_write_clr_set(struct v4l2_subdev *sd, u8 reg, u8 mask, u8 val)
	@@ -460,71 +437,70 @@ static inline int avlink_read(struct v4l2_subdev *sd, u8 reg)
	{		{
	struct adv76xx_state *state = to_state(sd);		struct adv76xx_state *state = to_state(sd);

	return adv_smbus_read_byte_data(state, ADV7604_PAGE_AVLINK, reg);		return adv76xx_read_check(state, ADV7604_PAGE_AVLINK, reg);
	}		}

	static inline int avlink_write(struct v4l2_subdev *sd, u8 reg, u8 val)		static inline int avlink_write(struct v4l2_subdev *sd, u8 reg, u8 val)
	{		{
	struct adv76xx_state *state = to_state(sd);		struct adv76xx_state *state = to_state(sd);

	return adv_smbus_write_byte_data(state, ADV7604_PAGE_AVLINK, reg, val);		return regmap_write(state->regmap[ADV7604_PAGE_AVLINK], reg, val);
	}		}

	static inline int cec_read(struct v4l2_subdev *sd, u8 reg)		static inline int cec_read(struct v4l2_subdev *sd, u8 reg)
	{		{
	struct adv76xx_state *state = to_state(sd);		struct adv76xx_state *state = to_state(sd);

	return adv_smbus_read_byte_data(state, ADV76XX_PAGE_CEC, reg);		return adv76xx_read_check(state, ADV76XX_PAGE_CEC, reg);
	}		}

	static inline int cec_write(struct v4l2_subdev *sd, u8 reg, u8 val)		static inline int cec_write(struct v4l2_subdev *sd, u8 reg, u8 val)
	{		{
	struct adv76xx_state *state = to_state(sd);		struct adv76xx_state *state = to_state(sd);

	return adv_smbus_write_byte_data(state, ADV76XX_PAGE_CEC, reg, val);		return regmap_write(state->regmap[ADV76XX_PAGE_CEC], reg, val);
	}		}

	static inline int infoframe_read(struct v4l2_subdev *sd, u8 reg)		static inline int infoframe_read(struct v4l2_subdev *sd, u8 reg)
	{		{
	struct adv76xx_state *state = to_state(sd);		struct adv76xx_state *state = to_state(sd);

	return adv_smbus_read_byte_data(state, ADV76XX_PAGE_INFOFRAME, reg);		return adv76xx_read_check(state, ADV76XX_PAGE_INFOFRAME, reg);
	}		}

	static inline int infoframe_write(struct v4l2_subdev *sd, u8 reg, u8 val)		static inline int infoframe_write(struct v4l2_subdev *sd, u8 reg, u8 val)
	{		{
	struct adv76xx_state *state = to_state(sd);		struct adv76xx_state *state = to_state(sd);

	return adv_smbus_write_byte_data(state, ADV76XX_PAGE_INFOFRAME,		return regmap_write(state->regmap[ADV76XX_PAGE_INFOFRAME], reg, val);
	reg, val);
	}		}

	static inline int afe_read(struct v4l2_subdev *sd, u8 reg)		static inline int afe_read(struct v4l2_subdev *sd, u8 reg)
	{		{
	struct adv76xx_state *state = to_state(sd);		struct adv76xx_state *state = to_state(sd);

	return adv_smbus_read_byte_data(state, ADV76XX_PAGE_AFE, reg);		return adv76xx_read_check(state, ADV76XX_PAGE_AFE, reg);
	}		}

	static inline int afe_write(struct v4l2_subdev *sd, u8 reg, u8 val)		static inline int afe_write(struct v4l2_subdev *sd, u8 reg, u8 val)
	{		{
	struct adv76xx_state *state = to_state(sd);		struct adv76xx_state *state = to_state(sd);

	return adv_smbus_write_byte_data(state, ADV76XX_PAGE_AFE, reg, val);		return regmap_write(state->regmap[ADV76XX_PAGE_AFE], reg, val);
	}		}

	static inline int rep_read(struct v4l2_subdev *sd, u8 reg)		static inline int rep_read(struct v4l2_subdev *sd, u8 reg)
	{		{
	struct adv76xx_state *state = to_state(sd);		struct adv76xx_state *state = to_state(sd);

	return adv_smbus_read_byte_data(state, ADV76XX_PAGE_REP, reg);		return adv76xx_read_check(state, ADV76XX_PAGE_REP, reg);
	}		}

	static inline int rep_write(struct v4l2_subdev *sd, u8 reg, u8 val)		static inline int rep_write(struct v4l2_subdev *sd, u8 reg, u8 val)
	{		{
	struct adv76xx_state *state = to_state(sd);		struct adv76xx_state *state = to_state(sd);

	return adv_smbus_write_byte_data(state, ADV76XX_PAGE_REP, reg, val);		return regmap_write(state->regmap[ADV76XX_PAGE_REP], reg, val);
	}		}

	static inline int rep_write_clr_set(struct v4l2_subdev *sd, u8 reg, u8 mask, u8 val)		static inline int rep_write_clr_set(struct v4l2_subdev *sd, u8 reg, u8 mask, u8 val)
	@@ -536,28 +512,37 @@ static inline int edid_read(struct v4l2_subdev *sd, u8 reg)
	{		{
	struct adv76xx_state *state = to_state(sd);		struct adv76xx_state *state = to_state(sd);

	return adv_smbus_read_byte_data(state, ADV76XX_PAGE_EDID, reg);		return adv76xx_read_check(state, ADV76XX_PAGE_EDID, reg);
	}		}

	static inline int edid_write(struct v4l2_subdev *sd, u8 reg, u8 val)		static inline int edid_write(struct v4l2_subdev *sd, u8 reg, u8 val)
	{		{
	struct adv76xx_state *state = to_state(sd);		struct adv76xx_state *state = to_state(sd);

	return adv_smbus_write_byte_data(state, ADV76XX_PAGE_EDID, reg, val);		return regmap_write(state->regmap[ADV76XX_PAGE_EDID], reg, val);
	}		}

	static inline int edid_write_block(struct v4l2_subdev *sd,		static inline int edid_write_block(struct v4l2_subdev *sd,
	unsigned len, const u8 *val)		unsigned int total_len, const u8 *val)
	{		{
	struct adv76xx_state *state = to_state(sd);		struct adv76xx_state *state = to_state(sd);
	int err = 0;		int err = 0;
	int i;		int i = 0;
			int len = 0;

			v4l2_dbg(2, debug, sd, "%s: write EDID block (%d byte)\n",
			__func__, total_len);

	v4l2_dbg(2, debug, sd, "%s: write EDID block (%d byte)\n", __func__, len);		while (!err && i < total_len) {
			len = (total_len - i) > I2C_SMBUS_BLOCK_MAX ?
			I2C_SMBUS_BLOCK_MAX :
			(total_len - i);

			err = adv76xx_write_block(state, ADV76XX_PAGE_EDID,
			i, val + i, len);
			i += len;
			}

	for (i = 0; !err && i < len; i += I2C_SMBUS_BLOCK_MAX)
	err = adv_smbus_write_i2c_block_data(state, ADV76XX_PAGE_EDID,
	i, I2C_SMBUS_BLOCK_MAX, val + i);
	return err;		return err;
	}		}

	@@ -587,7 +572,7 @@ static inline int hdmi_read(struct v4l2_subdev *sd, u8 reg)
	{		{
	struct adv76xx_state *state = to_state(sd);		struct adv76xx_state *state = to_state(sd);

	return adv_smbus_read_byte_data(state, ADV76XX_PAGE_HDMI, reg);		return adv76xx_read_check(state, ADV76XX_PAGE_HDMI, reg);
	}		}

	static u16 hdmi_read16(struct v4l2_subdev *sd, u8 reg, u16 mask)		static u16 hdmi_read16(struct v4l2_subdev *sd, u8 reg, u16 mask)
	@@ -599,7 +584,7 @@ static inline int hdmi_write(struct v4l2_subdev *sd, u8 reg, u8 val)
	{		{
	struct adv76xx_state *state = to_state(sd);		struct adv76xx_state *state = to_state(sd);

	return adv_smbus_write_byte_data(state, ADV76XX_PAGE_HDMI, reg, val);		return regmap_write(state->regmap[ADV76XX_PAGE_HDMI], reg, val);
	}		}

	static inline int hdmi_write_clr_set(struct v4l2_subdev *sd, u8 reg, u8 mask, u8 val)		static inline int hdmi_write_clr_set(struct v4l2_subdev *sd, u8 reg, u8 mask, u8 val)
	@@ -611,14 +596,14 @@ static inline int test_write(struct v4l2_subdev *sd, u8 reg, u8 val)
	{		{
	struct adv76xx_state *state = to_state(sd);		struct adv76xx_state *state = to_state(sd);

	return adv_smbus_write_byte_data(state, ADV76XX_PAGE_TEST, reg, val);		return regmap_write(state->regmap[ADV76XX_PAGE_TEST], reg, val);
	}		}

	static inline int cp_read(struct v4l2_subdev *sd, u8 reg)		static inline int cp_read(struct v4l2_subdev *sd, u8 reg)
	{		{
	struct adv76xx_state *state = to_state(sd);		struct adv76xx_state *state = to_state(sd);

	return adv_smbus_read_byte_data(state, ADV76XX_PAGE_CP, reg);		return adv76xx_read_check(state, ADV76XX_PAGE_CP, reg);
	}		}

	static u16 cp_read16(struct v4l2_subdev *sd, u8 reg, u16 mask)		static u16 cp_read16(struct v4l2_subdev *sd, u8 reg, u16 mask)
	@@ -630,7 +615,7 @@ static inline int cp_write(struct v4l2_subdev *sd, u8 reg, u8 val)
	{		{
	struct adv76xx_state *state = to_state(sd);		struct adv76xx_state *state = to_state(sd);

	return adv_smbus_write_byte_data(state, ADV76XX_PAGE_CP, reg, val);		return regmap_write(state->regmap[ADV76XX_PAGE_CP], reg, val);
	}		}

	static inline int cp_write_clr_set(struct v4l2_subdev *sd, u8 reg, u8 mask, u8 val)		static inline int cp_write_clr_set(struct v4l2_subdev *sd, u8 reg, u8 mask, u8 val)
	@@ -642,14 +627,14 @@ static inline int vdp_read(struct v4l2_subdev *sd, u8 reg)
	{		{
	struct adv76xx_state *state = to_state(sd);		struct adv76xx_state *state = to_state(sd);

	return adv_smbus_read_byte_data(state, ADV7604_PAGE_VDP, reg);		return adv76xx_read_check(state, ADV7604_PAGE_VDP, reg);
	}		}

	static inline int vdp_write(struct v4l2_subdev *sd, u8 reg, u8 val)		static inline int vdp_write(struct v4l2_subdev *sd, u8 reg, u8 val)
	{		{
	struct adv76xx_state *state = to_state(sd);		struct adv76xx_state *state = to_state(sd);

	return adv_smbus_write_byte_data(state, ADV7604_PAGE_VDP, reg, val);		return regmap_write(state->regmap[ADV7604_PAGE_VDP], reg, val);
	}		}

	#define ADV76XX_REG(page, offset) (((page) << 8) \| (offset))		#define ADV76XX_REG(page, offset) (((page) << 8) \| (offset))
	@@ -660,13 +645,16 @@ static int adv76xx_read_reg(struct v4l2_subdev *sd, unsigned int reg)
	{		{
	struct adv76xx_state *state = to_state(sd);		struct adv76xx_state *state = to_state(sd);
	unsigned int page = reg >> 8;		unsigned int page = reg >> 8;
			unsigned int val;
			int err;

	if (!(BIT(page) & state->info->page_mask))		if (!(BIT(page) & state->info->page_mask))
	return -EINVAL;		return -EINVAL;

	reg &= 0xff;		reg &= 0xff;
			err = regmap_read(state->regmap[page], reg, &val);

	return adv_smbus_read_byte_data(state, page, reg);		return err ? err : val;
	}		}
	#endif		#endif

	@@ -680,7 +668,7 @@ static int adv76xx_write_reg(struct v4l2_subdev *sd, unsigned int reg, u8 val)

	reg &= 0xff;		reg &= 0xff;

	return adv_smbus_write_byte_data(state, page, reg, val);		return regmap_write(state->regmap[page], reg, val);
	}		}

	static void adv76xx_write_reg_seq(struct v4l2_subdev *sd,		static void adv76xx_write_reg_seq(struct v4l2_subdev *sd,
	@@ -976,8 +964,8 @@ static void configure_custom_video_timings(struct v4l2_subdev *sd,
	/* Should only be set in auto-graphics mode [REF_02, p. 91-92] */		/* Should only be set in auto-graphics mode [REF_02, p. 91-92] */
	/* setup PLL_DIV_MAN_EN and PLL_DIV_RATIO */		/* setup PLL_DIV_MAN_EN and PLL_DIV_RATIO */
	/* IO-map reg. 0x16 and 0x17 should be written in sequence */		/* IO-map reg. 0x16 and 0x17 should be written in sequence */
	if (adv_smbus_write_i2c_block_data(state, ADV76XX_PAGE_IO,		if (regmap_raw_write(state->regmap[ADV76XX_PAGE_IO],
	0x16, 2, pll))		0x16, pll, 2))
	v4l2_err(sd, "writing to reg 0x16 and 0x17 failed\n");		v4l2_err(sd, "writing to reg 0x16 and 0x17 failed\n");

	/* active video - horizontal timing */		/* active video - horizontal timing */
	@@ -1028,8 +1016,8 @@ static void adv76xx_set_offset(struct v4l2_subdev *sd, bool auto_offset, u16 off
	offset_buf[3] = offset_c & 0x0ff;		offset_buf[3] = offset_c & 0x0ff;

	/* Registers must be written in this order with no i2c access in between */		/* Registers must be written in this order with no i2c access in between */
	if (adv_smbus_write_i2c_block_data(state, ADV76XX_PAGE_CP,		if (regmap_raw_write(state->regmap[ADV76XX_PAGE_CP],
	0x77, 4, offset_buf))		0x77, offset_buf, 4))
	v4l2_err(sd, "%s: i2c error writing to CP reg 0x77, 0x78, 0x79, 0x7a\n", __func__);		v4l2_err(sd, "%s: i2c error writing to CP reg 0x77, 0x78, 0x79, 0x7a\n", __func__);
	}		}

	@@ -1058,8 +1046,8 @@ static void adv76xx_set_gain(struct v4l2_subdev *sd, bool auto_gain, u16 gain_a,
	gain_buf[3] = ((gain_c & 0x0ff));		gain_buf[3] = ((gain_c & 0x0ff));

	/* Registers must be written in this order with no i2c access in between */		/* Registers must be written in this order with no i2c access in between */
	if (adv_smbus_write_i2c_block_data(state, ADV76XX_PAGE_CP,		if (regmap_raw_write(state->regmap[ADV76XX_PAGE_CP],
	0x73, 4, gain_buf))		0x73, gain_buf, 4))
	v4l2_err(sd, "%s: i2c error writing to CP reg 0x73, 0x74, 0x75, 0x76\n", __func__);		v4l2_err(sd, "%s: i2c error writing to CP reg 0x73, 0x74, 0x75, 0x76\n", __func__);
	}		}

	@@ -2762,6 +2750,148 @@ static int adv76xx_parse_dt(struct adv76xx_state *state)
	return 0;		return 0;
	}		}

			static const struct regmap_config adv76xx_regmap_cnf[] = {
			{
			.name = "io",
			.reg_bits = 8,
			.val_bits = 8,

			.max_register = 0xff,
			.cache_type = REGCACHE_NONE,
			},
			{
			.name = "avlink",
			.reg_bits = 8,
			.val_bits = 8,

			.max_register = 0xff,
			.cache_type = REGCACHE_NONE,
			},
			{
			.name = "cec",
			.reg_bits = 8,
			.val_bits = 8,

			.max_register = 0xff,
			.cache_type = REGCACHE_NONE,
			},
			{
			.name = "infoframe",
			.reg_bits = 8,
			.val_bits = 8,

			.max_register = 0xff,
			.cache_type = REGCACHE_NONE,
			},
			{
			.name = "esdp",
			.reg_bits = 8,
			.val_bits = 8,

			.max_register = 0xff,
			.cache_type = REGCACHE_NONE,
			},
			{
			.name = "epp",
			.reg_bits = 8,
			.val_bits = 8,

			.max_register = 0xff,
			.cache_type = REGCACHE_NONE,
			},
			{
			.name = "afe",
			.reg_bits = 8,
			.val_bits = 8,

			.max_register = 0xff,
			.cache_type = REGCACHE_NONE,
			},
			{
			.name = "rep",
			.reg_bits = 8,
			.val_bits = 8,

			.max_register = 0xff,
			.cache_type = REGCACHE_NONE,
			},
			{
			.name = "edid",
			.reg_bits = 8,
			.val_bits = 8,

			.max_register = 0xff,
			.cache_type = REGCACHE_NONE,
			},

			{
			.name = "hdmi",
			.reg_bits = 8,
			.val_bits = 8,

			.max_register = 0xff,
			.cache_type = REGCACHE_NONE,
			},
			{
			.name = "test",
			.reg_bits = 8,
			.val_bits = 8,

			.max_register = 0xff,
			.cache_type = REGCACHE_NONE,
			},
			{
			.name = "cp",
			.reg_bits = 8,
			.val_bits = 8,

			.max_register = 0xff,
			.cache_type = REGCACHE_NONE,
			},
			{
			.name = "vdp",
			.reg_bits = 8,
			.val_bits = 8,

			.max_register = 0xff,
			.cache_type = REGCACHE_NONE,
			},
			};

			static int configure_regmap(struct adv76xx_state *state, int region)
			{
			int err;

			if (!state->i2c_clients[region])
			return -ENODEV;

			state->regmap[region] =
			devm_regmap_init_i2c(state->i2c_clients[region],
			&adv76xx_regmap_cnf[region]);

			if (IS_ERR(state->regmap[region])) {
			err = PTR_ERR(state->regmap[region]);
			v4l_err(state->i2c_clients[region],
			"Error initializing regmap %d with error %d\n",
			region, err);
			return -EINVAL;
			}

			return 0;
			}

			static int configure_regmaps(struct adv76xx_state *state)
			{
			int i, err;

			for (i = ADV7604_PAGE_AVLINK ; i < ADV76XX_PAGE_MAX; i++) {
			err = configure_regmap(state, i);
			if (err && (err != -ENODEV))
			return err;
			}
			return 0;
			}

	static int adv76xx_probe(struct i2c_client *client,		static int adv76xx_probe(struct i2c_client *client,
	const struct i2c_device_id *id)		const struct i2c_device_id *id)
	{		{
	@@ -2771,7 +2901,7 @@ static int adv76xx_probe(struct i2c_client *client,
	struct v4l2_ctrl_handler *hdl;		struct v4l2_ctrl_handler *hdl;
	struct v4l2_subdev *sd;		struct v4l2_subdev *sd;
	unsigned int i;		unsigned int i;
	u16 val;		unsigned int val, val2;
	int err;		int err;

	/* Check if the adapter supports the needed features */		/* Check if the adapter supports the needed features */
	@@ -2835,23 +2965,49 @@ static int adv76xx_probe(struct i2c_client *client,
	client->addr);		client->addr);
	sd->flags \|= V4L2_SUBDEV_FL_HAS_DEVNODE;		sd->flags \|= V4L2_SUBDEV_FL_HAS_DEVNODE;

			/* Configure IO Regmap region */
			err = configure_regmap(state, ADV76XX_PAGE_IO);

			if (err) {
			v4l2_err(sd, "Error configuring IO regmap region\n");
			return -ENODEV;
			}

	/*		/*
	* Verify that the chip is present. On ADV7604 the RD_INFO register only		* Verify that the chip is present. On ADV7604 the RD_INFO register only
	* identifies the revision, while on ADV7611 it identifies the model as		* identifies the revision, while on ADV7611 it identifies the model as
	* well. Use the HDMI slave address on ADV7604 and RD_INFO on ADV7611.		* well. Use the HDMI slave address on ADV7604 and RD_INFO on ADV7611.
	*/		*/
	if (state->info->type == ADV7604) {		if (state->info->type == ADV7604) {
	val = adv_smbus_read_byte_data_check(client, 0xfb, false);		err = regmap_read(state->regmap[ADV76XX_PAGE_IO], 0xfb, &val);
			if (err) {
			v4l2_err(sd, "Error %d reading IO Regmap\n", err);
			return -ENODEV;
			}
	if (val != 0x68) {		if (val != 0x68) {
	v4l2_info(sd, "not an adv7604 on address 0x%x\n",		v4l2_err(sd, "not an adv7604 on address 0x%x\n",
	client->addr << 1);		client->addr << 1);
	return -ENODEV;		return -ENODEV;
	}		}
	} else {		} else {
	val = (adv_smbus_read_byte_data_check(client, 0xea, false) << 8)		err = regmap_read(state->regmap[ADV76XX_PAGE_IO],
	\| (adv_smbus_read_byte_data_check(client, 0xeb, false) << 0);		0xea,
	if (val != 0x2051) {		&val);
	v4l2_info(sd, "not an adv7611 on address 0x%x\n",		if (err) {
			v4l2_err(sd, "Error %d reading IO Regmap\n", err);
			return -ENODEV;
			}
			val2 = val << 8;
			err = regmap_read(state->regmap[ADV76XX_PAGE_IO],
			0xeb,
			&val);
			if (err) {
			v4l2_err(sd, "Error %d reading IO Regmap\n", err);
			return -ENODEV;
			}
			val2 \|= val;
			if (val2 != 0x2051) {
			v4l2_err(sd, "not an adv7611 on address 0x%x\n",
	client->addr << 1);		client->addr << 1);
	return -ENODEV;		return -ENODEV;
	}		}
	@@ -2941,6 +3097,11 @@ static int adv76xx_probe(struct i2c_client *client,
	if (err)		if (err)
	goto err_work_queues;		goto err_work_queues;

			/* Configure regmaps */
			err = configure_regmaps(state);
			if (err)
			goto err_entity;

	err = adv76xx_core_init(sd);		err = adv76xx_core_init(sd);
	if (err)		if (err)
	goto err_entity;		goto err_entity;