From f472340bf77bf6d86f9a7a4aa0a4104979cea8d1 Mon Sep 17 00:00:00 2001
From: Sandeep Panda <spanda@codeaurora.org>
Date: Sat, 7 Nov 2015 00:49:57 +0530
Subject: [PATCH] msm: mdss: separate out DBA and CEC functionality from DSI

Currently, DBA (Display Bridge Abstract) related functionality
is being used in DSI files. Carve out DBA related functionality
into a new file which serves as a utility module and can be used
by any MDSS driver.

Define CEC on/enable functions in DBA (Display Bridge Abstract) so that
clients can enable disable CEC based on other dependent CEC modules.
Separate out CEC abstract data with CEC driver data and initialize and
release corresponding modules properly.

Change-Id: I84f53d99547dcd4ce0b8275401b03ed8e96e14d5
Signed-off-by: Ajay Singh Parmar <aparmar@codeaurora.org>
Signed-off-by: Sandeep Panda <spanda@codeaurora.org>
---
 .../devicetree/bindings/fb/adv7533.txt        |   13 +-
 .../devicetree/bindings/fb/mdss-dsi-panel.txt |    3 +
 drivers/video/fbdev/msm/Makefile              |    1 +
 drivers/video/fbdev/msm/mdss_dba_utils.c      |  768 ++++++++
 drivers/video/fbdev/msm/mdss_dba_utils.h      |   47 +
 drivers/video/fbdev/msm/mdss_dsi.c            |   87 +-
 drivers/video/fbdev/msm/mdss_dsi.h            |   17 +-
 drivers/video/fbdev/msm/mdss_dsi_panel.c      |  182 +-
 drivers/video/fbdev/msm/mdss_fb.c             |    6 +-
 drivers/video/fbdev/msm/mdss_hdmi_cec.c       |    8 +
 drivers/video/fbdev/msm/mdss_hdmi_cec.h       |   28 +
 drivers/video/fbdev/msm/mdss_hdmi_edid.c      |    8 +-
 drivers/video/fbdev/msm/mdss_hdmi_edid.h      |    2 +-
 drivers/video/fbdev/msm/mdss_hdmi_tx.c        |   56 +-
 drivers/video/fbdev/msm/mdss_hdmi_tx.h        |    4 +
 drivers/video/fbdev/msm/mdss_panel.h          |    4 +
 drivers/video/fbdev/msm/msm_dba/adv7533.c     | 1731 +++++++++++++----
 include/video/msm_dba.h                       |   17 +-
 18 files changed, 2376 insertions(+), 606 deletions(-)
 create mode 100644 drivers/video/fbdev/msm/mdss_dba_utils.c
 create mode 100644 drivers/video/fbdev/msm/mdss_dba_utils.h

diff --git a/Documentation/devicetree/bindings/fb/adv7533.txt b/Documentation/devicetree/bindings/fb/adv7533.txt
index 33dd1dd73f1c..8b85fcd730cb 100644
--- a/Documentation/devicetree/bindings/fb/adv7533.txt
+++ b/Documentation/devicetree/bindings/fb/adv7533.txt
@@ -15,9 +15,14 @@ Required properties:
 Optional properties:
 - adi,enable-audio:
 - adi,disable-gpios:
-- adi,irq-gpio:			Main IRQ gpio mapping
+- adi,irq-gpio:				Main IRQ gpio mapping
 - adi,hpd-irq-gpio:			HPD IRQ gpio mapping
 - adi,switch-gpio:			DSI switch gpio mapping
+- qcom,supply-names:			Regulator names that supply 5v to bridge chip
+- qcom,min-voltage-level		Minimum voltage level to be supplied to bridge chip
+- qcom,max-voltage-level		Maximum voltage level to be supplied to bridge chip
+- qcom,enable-load			Load current to bridge chip when enabled
+- qcom,disable-load			Load current to bridge chip when disabled
 
 Example:
 &soc {
@@ -35,6 +40,12 @@ Example:
 			adi,irq-gpio = <&msm_gpio 31 0x2002>;
 			adi,hpd-irq-gpio = <&msm_gpio 20 0x2003>;
 			adi,switch-gpio = <&msm_gpio 32 0x0>;
+			hpd-5v-en-supply = <&adv_vreg>;
+			qcom,supply-names = "hpd-5v-en";
+			qcom,min-voltage-level = <0>;
+			qcom,max-voltage-level = <0>;
+			qcom,enable-load = <0>;
+			qcom,disable-load = <0>;
 		};
 	};
 };
diff --git a/Documentation/devicetree/bindings/fb/mdss-dsi-panel.txt b/Documentation/devicetree/bindings/fb/mdss-dsi-panel.txt
index bee2b8f3c2c6..439898534996 100644
--- a/Documentation/devicetree/bindings/fb/mdss-dsi-panel.txt
+++ b/Documentation/devicetree/bindings/fb/mdss-dsi-panel.txt
@@ -446,6 +446,8 @@ Optional properites:
 - qcom,mdss-dsc-block-prediction-enable: A boolean value to enable/disable the block prediction at decoder.
 - qcom,mdss-dsc-config-by-manufacture-cmd: A boolean to indicates panel use manufacture command to setup pps
 					instead of standard dcs type 0x0A.
+- qcom,dba-panel:	Indicates whether the current panel is used as a display bridge
+					to a non-DSI interface.
 - qcom,adjust-timer-wakeup-ms:		An integer value to indicate the timer delay(in ms) to accommodate
 					s/w delay while configuring the event timer wakeup logic.
 
@@ -661,6 +663,7 @@ Example:
 		};
 
 		qcom,config-select = <&dsi_sim_vid_config0>;
+		qcom,dba-panel;
 
 		dsi_sim_vid_config0: config0 {
 			qcom,lm-split = <360 360>;
diff --git a/drivers/video/fbdev/msm/Makefile b/drivers/video/fbdev/msm/Makefile
index 01bbad3653e7..5cd23218245a 100644
--- a/drivers/video/fbdev/msm/Makefile
+++ b/drivers/video/fbdev/msm/Makefile
@@ -44,6 +44,7 @@ obj-$(CONFIG_FB_MSM_MDSS) += mdss_panel.o
 obj-$(CONFIG_FB_MSM_MDSS) += mdss_hdmi_util.o
 obj-$(CONFIG_FB_MSM_MDSS) += mdss_hdmi_edid.o
 obj-$(CONFIG_FB_MSM_MDSS) += mdss_cec_core.o
+obj-$(CONFIG_FB_MSM_MDSS) += mdss_dba_utils.o
 obj-$(CONFIG_FB_MSM_MDSS_EDP_PANEL) += mdss_edp.o
 obj-$(CONFIG_FB_MSM_MDSS_EDP_PANEL) += mdss_edp_aux.o
 
diff --git a/drivers/video/fbdev/msm/mdss_dba_utils.c b/drivers/video/fbdev/msm/mdss_dba_utils.c
new file mode 100644
index 000000000000..775d8e0518cb
--- /dev/null
+++ b/drivers/video/fbdev/msm/mdss_dba_utils.c
@@ -0,0 +1,768 @@
+/* Copyright (c) 2015, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only 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.
+ *
+ */
+
+#define pr_fmt(fmt)	"%s: " fmt, __func__
+
+#include <video/msm_dba.h>
+#include <linux/switch.h>
+
+#include "mdss_dba_utils.h"
+#include "mdss_hdmi_edid.h"
+#include "mdss_cec_core.h"
+#include "mdss_fb.h"
+
+/* standard cec buf size + 1 byte specific to driver */
+#define CEC_BUF_SIZE    (MAX_CEC_FRAME_SIZE + 1)
+#define MAX_SWITCH_NAME_SIZE        5
+#define MSM_DBA_MAX_PCLK 148500
+
+struct mdss_dba_utils_data {
+	struct msm_dba_ops ops;
+	bool hpd_state;
+	bool audio_switch_registered;
+	bool display_switch_registered;
+	struct switch_dev sdev_display;
+	struct switch_dev sdev_audio;
+	struct kobject *kobj;
+	struct mdss_panel_info *pinfo;
+	void *dba_data;
+	void *edid_data;
+	void *cec_abst_data;
+	u8 *edid_buf;
+	u32 edid_buf_size;
+	u8 cec_buf[CEC_BUF_SIZE];
+	struct cec_ops cops;
+	struct cec_cbs ccbs;
+	char disp_switch_name[MAX_SWITCH_NAME_SIZE];
+	u32 current_vic;
+};
+
+static struct mdss_dba_utils_data *mdss_dba_utils_get_data(
+	struct device *device)
+{
+	struct msm_fb_data_type *mfd;
+	struct mdss_panel_info *pinfo;
+	struct fb_info *fbi;
+	struct mdss_dba_utils_data *udata = NULL;
+
+	if (!device) {
+		pr_err("Invalid device data\n");
+		goto end;
+	}
+
+	fbi = dev_get_drvdata(device);
+	if (!fbi) {
+		pr_err("Invalid fbi data\n");
+		goto end;
+	}
+
+	mfd = (struct msm_fb_data_type *)fbi->par;
+	if (!mfd) {
+		pr_err("Invalid mfd data\n");
+		goto end;
+	}
+
+	pinfo = mfd->panel_info;
+	if (!pinfo) {
+		pr_err("Invalid pinfo data\n");
+		goto end;
+	}
+
+	udata = pinfo->dba_data;
+end:
+	return udata;
+}
+
+static void mdss_dba_utils_send_display_notification(
+	struct mdss_dba_utils_data *udata, int val)
+{
+	int state = 0;
+
+	if (!udata) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	if (!udata->display_switch_registered) {
+		pr_err("display switch not registered\n");
+		return;
+	}
+
+	state = udata->sdev_display.state;
+
+	switch_set_state(&udata->sdev_display, val);
+
+	pr_debug("cable state %s %d\n",
+		udata->sdev_display.state == state ?
+		"is same" : "switched to",
+		udata->sdev_display.state);
+}
+
+static void mdss_dba_utils_send_audio_notification(
+	struct mdss_dba_utils_data *udata, int val)
+{
+	int state = 0;
+
+	if (!udata) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	if (!udata->audio_switch_registered) {
+		pr_err("audio switch not registered\n");
+		return;
+	}
+
+	state = udata->sdev_audio.state;
+
+	switch_set_state(&udata->sdev_audio, val);
+
+	pr_debug("audio state %s %d\n",
+		udata->sdev_audio.state == state ?
+		"is same" : "switched to",
+		udata->sdev_audio.state);
+}
+
+static ssize_t mdss_dba_utils_sysfs_rda_connected(struct device *dev,
+	struct device_attribute *attr, char *buf)
+{
+	ssize_t ret;
+	struct mdss_dba_utils_data *udata = NULL;
+
+	if (!dev) {
+		pr_err("invalid device\n");
+		return -EINVAL;
+	}
+
+	udata = mdss_dba_utils_get_data(dev);
+
+	if (!udata) {
+		pr_err("invalid input\n");
+		return -EINVAL;
+	}
+
+	ret = snprintf(buf, PAGE_SIZE, "%d\n", udata->hpd_state);
+	pr_debug("'%d'\n", udata->hpd_state);
+
+	return ret;
+}
+
+static ssize_t mdss_dba_utils_sysfs_rda_video_mode(struct device *dev,
+	struct device_attribute *attr, char *buf)
+{
+	ssize_t ret;
+	struct mdss_dba_utils_data *udata = NULL;
+
+	if (!dev) {
+		pr_debug("invalid device\n");
+		return -EINVAL;
+	}
+
+	udata = mdss_dba_utils_get_data(dev);
+
+	if (!udata) {
+		pr_debug("invalid input\n");
+		return -EINVAL;
+	}
+
+	ret = snprintf(buf, PAGE_SIZE, "%d\n", udata->current_vic);
+	pr_debug("'%d'\n", udata->current_vic);
+
+	return ret;
+}
+
+static ssize_t mdss_dba_utils_sysfs_wta_hpd(struct device *dev,
+	struct device_attribute *attr, const char *buf, size_t count)
+{
+	struct mdss_dba_utils_data *udata = NULL;
+	int rc, hpd;
+
+	udata = mdss_dba_utils_get_data(dev);
+	if (!udata) {
+		pr_debug("%s: invalid input\n", __func__);
+		return -EINVAL;
+	}
+
+	rc = kstrtoint(buf, 10, &hpd);
+	if (rc) {
+		pr_debug("%s: kstrtoint failed\n", __func__);
+		return -EINVAL;
+	}
+
+	pr_debug("%s: set value: %d hpd state: %d\n", __func__,
+					hpd, udata->hpd_state);
+	if (!hpd) {
+		if (udata->ops.power_on)
+			udata->ops.power_on(udata->dba_data, false, 0);
+		return count;
+	}
+
+	/* power on downstream device */
+	if (udata->ops.power_on)
+		udata->ops.power_on(udata->dba_data, true, 0);
+
+	/* check if cable is connected to bridge chip */
+	if (udata->ops.check_hpd)
+		udata->ops.check_hpd(udata->dba_data, 0);
+
+	return count;
+}
+
+static DEVICE_ATTR(connected, S_IRUGO,
+		mdss_dba_utils_sysfs_rda_connected, NULL);
+
+static DEVICE_ATTR(video_mode, S_IRUGO,
+		mdss_dba_utils_sysfs_rda_video_mode, NULL);
+
+static DEVICE_ATTR(hpd, S_IRUGO | S_IWUSR, NULL,
+		mdss_dba_utils_sysfs_wta_hpd);
+
+static struct attribute *mdss_dba_utils_fs_attrs[] = {
+	&dev_attr_connected.attr,
+	&dev_attr_video_mode.attr,
+	&dev_attr_hpd.attr,
+	NULL,
+};
+
+static struct attribute_group mdss_dba_utils_fs_attrs_group = {
+	.attrs = mdss_dba_utils_fs_attrs,
+};
+
+static int mdss_dba_utils_sysfs_create(struct kobject *kobj)
+{
+	int rc;
+
+	if (!kobj) {
+		pr_err("invalid input\n");
+		return -ENODEV;
+	}
+
+	rc = sysfs_create_group(kobj, &mdss_dba_utils_fs_attrs_group);
+	if (rc) {
+		pr_err("failed, rc=%d\n", rc);
+		return rc;
+	}
+
+	return 0;
+}
+
+static void mdss_dba_utils_sysfs_remove(struct kobject *kobj)
+{
+	if (!kobj) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	sysfs_remove_group(kobj, &mdss_dba_utils_fs_attrs_group);
+}
+
+static void mdss_dba_utils_dba_cb(void *data, enum msm_dba_callback_event event)
+{
+	int ret = -EINVAL;
+	struct mdss_dba_utils_data *udata = data;
+	struct cec_msg msg = {0};
+	bool pluggable = false;
+	bool operands_present = false;
+	u32 no_of_operands, size, i;
+	u32 operands_offset = MAX_CEC_FRAME_SIZE - MAX_OPERAND_SIZE;
+
+	if (!udata) {
+		pr_err("Invalid data\n");
+		return;
+	}
+
+	pr_debug("event: %d\n", event);
+
+	if (udata->pinfo)
+		pluggable = udata->pinfo->is_pluggable;
+
+	switch (event) {
+	case MSM_DBA_CB_HPD_CONNECT:
+		if (udata->hpd_state)
+			break;
+		if (udata->ops.get_raw_edid) {
+			ret = udata->ops.get_raw_edid(udata->dba_data,
+				udata->edid_buf_size, udata->edid_buf, 0);
+
+			if (!ret)
+				hdmi_edid_parser(udata->edid_data);
+			else
+				pr_err("failed to get edid%d\n", ret);
+		}
+
+		if (pluggable) {
+			mdss_dba_utils_send_display_notification(udata, 1);
+			mdss_dba_utils_send_audio_notification(udata, 1);
+		} else {
+			mdss_dba_utils_video_on(udata, udata->pinfo);
+		}
+
+		udata->hpd_state = true;
+		break;
+
+	case MSM_DBA_CB_HPD_DISCONNECT:
+		if (!udata->hpd_state)
+			break;
+		if (pluggable) {
+			mdss_dba_utils_send_audio_notification(udata, 0);
+			mdss_dba_utils_send_display_notification(udata, 0);
+		} else {
+			mdss_dba_utils_video_off(udata);
+		}
+
+		udata->hpd_state = false;
+		break;
+
+	case MSM_DBA_CB_CEC_READ_PENDING:
+		if (udata->ops.hdmi_cec_read) {
+			ret = udata->ops.hdmi_cec_read(
+				udata->dba_data,
+				&size,
+				udata->cec_buf, 0);
+
+			if (ret || !size || size > CEC_BUF_SIZE) {
+				pr_err("%s: cec read failed\n", __func__);
+				return;
+			}
+		}
+
+		/* prepare cec msg */
+		msg.recvr_id   = udata->cec_buf[0] & 0x0F;
+		msg.sender_id  = (udata->cec_buf[0] & 0xF0) >> 4;
+		msg.opcode     = udata->cec_buf[1];
+		msg.frame_size = (udata->cec_buf[MAX_CEC_FRAME_SIZE] & 0x1F);
+
+		operands_present = (msg.frame_size > operands_offset) &&
+			(msg.frame_size <= MAX_CEC_FRAME_SIZE);
+
+		if (operands_present) {
+			no_of_operands = msg.frame_size - operands_offset;
+
+			for (i = 0; i < no_of_operands; i++)
+				msg.operand[i] =
+					udata->cec_buf[operands_offset + i];
+		}
+
+		ret = udata->ccbs.msg_recv_notify(udata->ccbs.data, &msg);
+		if (ret)
+			pr_err("%s: failed to notify cec msg\n", __func__);
+		break;
+
+	default:
+		break;
+	}
+}
+
+static int mdss_dba_utils_cec_enable(void *data, bool enable)
+{
+	int ret = -EINVAL;
+	struct mdss_dba_utils_data *udata = data;
+
+	if (!udata) {
+		pr_err("%s: Invalid data\n", __func__);
+		return -EINVAL;
+	}
+
+	if (udata->ops.hdmi_cec_on)
+		ret = udata->ops.hdmi_cec_on(udata->dba_data, enable, 0);
+
+	return ret;
+}
+
+static int mdss_dba_utils_send_cec_msg(void *data, struct cec_msg *msg)
+{
+	int ret = -EINVAL, i;
+	u32 operands_offset = MAX_CEC_FRAME_SIZE - MAX_OPERAND_SIZE;
+	struct mdss_dba_utils_data *udata = data;
+
+	u8 buf[MAX_CEC_FRAME_SIZE];
+
+	if (!udata || !msg) {
+		pr_err("%s: Invalid data\n", __func__);
+		return -EINVAL;
+	}
+
+	buf[0] = (msg->sender_id << 4) | msg->recvr_id;
+	buf[1] = msg->opcode;
+
+	for (i = 0; i < MAX_OPERAND_SIZE &&
+		i < msg->frame_size - operands_offset; i++)
+		buf[operands_offset + i] = msg->operand[i];
+
+	if (udata->ops.hdmi_cec_write)
+		ret = udata->ops.hdmi_cec_write(udata->dba_data,
+			msg->frame_size, (char *)buf, 0);
+
+	return ret;
+}
+
+static int mdss_dba_utils_init_switch_dev(struct mdss_dba_utils_data *udata,
+	u32 fb_node)
+{
+	int rc = -EINVAL, ret;
+
+	if (!udata) {
+		pr_err("invalid input\n");
+		goto end;
+	}
+
+	/* create switch device to update display modules */
+	udata->sdev_display.name = "hdmi";
+	rc = switch_dev_register(&udata->sdev_display);
+	if (rc) {
+		pr_err("display switch registration failed\n");
+		goto end;
+	}
+
+	udata->display_switch_registered = true;
+
+	/* create switch device to update audio modules */
+	udata->sdev_audio.name = "hdmi_audio";
+	ret = switch_dev_register(&udata->sdev_audio);
+	if (ret) {
+		pr_err("audio switch registration failed\n");
+		goto end;
+	}
+
+	udata->audio_switch_registered = true;
+end:
+	return rc;
+}
+
+static int mdss_dba_get_vic_panel_info(struct mdss_dba_utils_data *udata,
+					struct mdss_panel_info *pinfo)
+{
+	struct msm_hdmi_mode_timing_info timing;
+	struct hdmi_util_ds_data ds_data;
+	u32 h_total, v_total, vic = 0;
+
+	if (!udata || !pinfo) {
+		pr_err("%s: invalid input\n", __func__);
+		return 0;
+	}
+
+	timing.active_h = pinfo->xres;
+	timing.back_porch_h = pinfo->lcdc.h_back_porch;
+	timing.front_porch_h = pinfo->lcdc.h_front_porch;
+	timing.pulse_width_h = pinfo->lcdc.h_pulse_width;
+	h_total = (timing.active_h + timing.back_porch_h +
+		timing.front_porch_h + timing.pulse_width_h);
+
+	timing.active_v = pinfo->yres;
+	timing.back_porch_v = pinfo->lcdc.v_back_porch;
+	timing.front_porch_v = pinfo->lcdc.v_front_porch;
+	timing.pulse_width_v = pinfo->lcdc.v_pulse_width;
+	v_total = (timing.active_v + timing.back_porch_v +
+		timing.front_porch_v + timing.pulse_width_v);
+
+	timing.refresh_rate = pinfo->mipi.frame_rate * 1000;
+	timing.pixel_freq = (h_total * v_total *
+				pinfo->mipi.frame_rate) / 1000;
+
+	ds_data.ds_registered = true;
+	ds_data.ds_max_clk = MSM_DBA_MAX_PCLK;
+
+	vic = hdmi_get_video_id_code(&timing, &ds_data);
+	pr_debug("%s: current vic code is %d\n", __func__, vic);
+
+	return vic;
+}
+
+/**
+ * mdss_dba_utils_video_on() - Allow clients to switch on the video
+ * @data: DBA utils instance which was allocated during registration
+ * @pinfo: detailed panel information like x, y, porch values etc
+ *
+ * This API is used to power on the video on device registered
+ * with DBA.
+ *
+ * Return: returns the result of the video on call on device.
+ */
+int mdss_dba_utils_video_on(void *data, struct mdss_panel_info *pinfo)
+{
+	struct mdss_dba_utils_data *ud = data;
+	struct msm_dba_video_cfg video_cfg;
+	int ret = -EINVAL;
+
+	if (!ud || !pinfo) {
+		pr_err("invalid input\n");
+		goto end;
+	}
+
+	memset(&video_cfg, 0, sizeof(video_cfg));
+
+	video_cfg.h_active = pinfo->xres;
+	video_cfg.v_active = pinfo->yres;
+	video_cfg.h_front_porch = pinfo->lcdc.h_front_porch;
+	video_cfg.v_front_porch = pinfo->lcdc.v_front_porch;
+	video_cfg.h_back_porch = pinfo->lcdc.h_back_porch;
+	video_cfg.v_back_porch = pinfo->lcdc.v_back_porch;
+	video_cfg.h_pulse_width = pinfo->lcdc.h_pulse_width;
+	video_cfg.v_pulse_width = pinfo->lcdc.v_pulse_width;
+	video_cfg.pclk_khz = (unsigned long)pinfo->clk_rate / 1000;
+	video_cfg.hdmi_mode = hdmi_edid_get_sink_mode(ud->edid_data);
+
+	/* Calculate number of DSI lanes configured */
+	video_cfg.num_of_input_lanes = 0;
+	if (pinfo->mipi.data_lane0)
+		video_cfg.num_of_input_lanes++;
+	if (pinfo->mipi.data_lane1)
+		video_cfg.num_of_input_lanes++;
+	if (pinfo->mipi.data_lane2)
+		video_cfg.num_of_input_lanes++;
+	if (pinfo->mipi.data_lane3)
+		video_cfg.num_of_input_lanes++;
+
+	/* Get scan information from EDID */
+	video_cfg.vic = mdss_dba_get_vic_panel_info(ud, pinfo);
+	ud->current_vic = video_cfg.vic;
+	video_cfg.scaninfo = hdmi_edid_get_sink_scaninfo(ud->edid_data,
+							video_cfg.vic);
+	if (ud->ops.video_on)
+		ret = ud->ops.video_on(ud->dba_data, true, &video_cfg, 0);
+
+end:
+	return ret;
+}
+
+/**
+ * mdss_dba_utils_video_off() - Allow clients to switch off the video
+ * @data: DBA utils instance which was allocated during registration
+ *
+ * This API is used to power off the video on device registered
+ * with DBA.
+ *
+ * Return: returns the result of the video off call on device.
+ */
+int mdss_dba_utils_video_off(void *data)
+{
+	struct mdss_dba_utils_data *ud = data;
+	int ret = -EINVAL;
+
+	if (!ud) {
+		pr_err("invalid input\n");
+		goto end;
+	}
+
+	if (ud->ops.video_on)
+		ret = ud->ops.video_on(ud->dba_data, false, NULL, 0);
+
+end:
+	return ret;
+}
+
+/**
+ * mdss_dba_utils_hdcp_enable() - Allow clients to switch on HDCP.
+ * @data: DBA utils instance which was allocated during registration
+ * @enable: flag to enable or disable HDCP authentication
+ *
+ * This API is used to start the HDCP authentication process with the
+ * device registered with DBA.
+ */
+void mdss_dba_utils_hdcp_enable(void *data, bool enable)
+{
+	struct mdss_dba_utils_data *ud = data;
+
+	if (!ud) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	if (ud->ops.hdcp_enable)
+		ud->ops.hdcp_enable(ud->dba_data, enable, enable, 0);
+}
+
+/**
+ * mdss_dba_utils_init() - Allow clients to register with DBA utils
+ * @uid: Initialization data for registration.
+ *
+ * This API lets the client to register with DBA Utils module.
+ * This allocate utils' instance and register with DBA (Display
+ * Bridge Abstract). Creates sysfs nodes and switch nodes to interact
+ * with other modules. Also registers with EDID parser to parse
+ * the EDID buffer.
+ *
+ * Return: Instance of DBA utils which needs to be sent as parameter
+ * when calling DBA utils APIs.
+ */
+void *mdss_dba_utils_init(struct mdss_dba_utils_init_data *uid)
+{
+	struct hdmi_edid_init_data edid_init_data;
+	struct mdss_dba_utils_data *udata = NULL;
+	struct msm_dba_reg_info info;
+	struct cec_abstract_init_data cec_abst_init_data;
+	void *cec_abst_data;
+	int ret = 0;
+
+	if (!uid) {
+		pr_err("invalid input\n");
+		ret = -EINVAL;
+		goto error;
+	}
+
+	udata = kzalloc(sizeof(*udata), GFP_KERNEL);
+	if (!udata) {
+		ret = -ENOMEM;
+		goto error;
+	}
+
+	memset(&edid_init_data, 0, sizeof(edid_init_data));
+	memset(&info, 0, sizeof(info));
+
+	/* initialize DBA registration data */
+	strlcpy(info.client_name, uid->client_name, MSM_DBA_CLIENT_NAME_LEN);
+	strlcpy(info.chip_name, uid->chip_name, MSM_DBA_CHIP_NAME_MAX_LEN);
+	info.instance_id = uid->instance_id;
+	info.cb = mdss_dba_utils_dba_cb;
+	info.cb_data = udata;
+
+	/* register client with DBA and get device's ops*/
+	if (IS_ENABLED(CONFIG_MSM_DBA)) {
+		udata->dba_data = msm_dba_register_client(&info, &udata->ops);
+		if (IS_ERR_OR_NULL(udata->dba_data)) {
+			pr_err("ds not configured\n");
+			ret = PTR_ERR(udata->dba_data);
+			goto error;
+		}
+	} else {
+		pr_err("DBA not enabled\n");
+		ret = -ENODEV;
+		goto error;
+	}
+
+	/* create sysfs nodes for other modules to intract with utils */
+	ret = mdss_dba_utils_sysfs_create(uid->kobj);
+	if (ret) {
+		pr_err("sysfs creation failed\n");
+		goto error;
+	}
+
+	/* keep init data for future use */
+	udata->kobj = uid->kobj;
+	udata->pinfo = uid->pinfo;
+
+	/* register display and audio switch devices */
+	ret = mdss_dba_utils_init_switch_dev(udata, uid->fb_node);
+	if (ret) {
+		pr_err("switch dev registration failed\n");
+		goto error;
+	}
+
+	/* Initialize EDID feature */
+	edid_init_data.kobj = uid->kobj;
+	edid_init_data.ds_data.ds_registered = true;
+	edid_init_data.ds_data.ds_max_clk = MSM_DBA_MAX_PCLK;
+	edid_init_data.max_pclk_khz = MSM_DBA_MAX_PCLK;
+
+	/* register with edid module for parsing edid buffer */
+	udata->edid_data = hdmi_edid_init(&edid_init_data);
+	if (!udata->edid_data) {
+		pr_err("edid parser init failed\n");
+		ret = -ENODEV;
+		goto error;
+	}
+
+	/* update edid data to retrieve it back in edid parser */
+	if (uid->pinfo)
+		uid->pinfo->edid_data = udata->edid_data;
+
+	/* get edid buffer from edid parser */
+	udata->edid_buf = edid_init_data.buf;
+	udata->edid_buf_size = edid_init_data.buf_size;
+
+	/* Initialize cec abstract layer and get callbacks */
+	udata->cops.send_msg = mdss_dba_utils_send_cec_msg;
+	udata->cops.enable   = mdss_dba_utils_cec_enable;
+	udata->cops.data     = udata;
+
+	/* initialize cec abstraction module */
+	cec_abst_init_data.kobj = uid->kobj;
+	cec_abst_init_data.ops  = &udata->cops;
+	cec_abst_init_data.cbs  = &udata->ccbs;
+
+	udata->cec_abst_data = cec_abstract_init(&cec_abst_init_data);
+	if (IS_ERR_OR_NULL(udata->cec_abst_data)) {
+		pr_err("error initializing cec abstract module\n");
+		ret = PTR_ERR(cec_abst_data);
+		goto error;
+	}
+
+	/* update cec data to retrieve it back in cec abstract module */
+	if (uid->pinfo) {
+		uid->pinfo->is_cec_supported = true;
+		uid->pinfo->cec_data = udata->cec_abst_data;
+
+		/*
+		 * TODO: Currently there is no support from HAL to send
+		 * HPD events to driver for usecase where bridge chip
+		 * is used as primary panel. Once support is added remove
+		 * this explicit calls to bridge chip driver.
+		 */
+		if (!uid->pinfo->is_pluggable) {
+			if (udata->ops.power_on)
+				udata->ops.power_on(udata->dba_data, true, 0);
+			if (udata->ops.check_hpd)
+				udata->ops.check_hpd(udata->dba_data, 0);
+		}
+	}
+
+	return udata;
+
+error:
+	mdss_dba_utils_deinit(udata);
+	return ERR_PTR(ret);
+}
+
+/**
+ * mdss_dba_utils_deinit() - Allow clients to de-register with DBA utils
+ * @data: DBA utils data that was allocated during registration.
+ *
+ * This API will release all the resources allocated during registration
+ * and delete the DBA utils instance.
+ */
+void mdss_dba_utils_deinit(void *data)
+{
+	struct mdss_dba_utils_data *udata = data;
+
+	if (!udata) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	if (!IS_ERR_OR_NULL(udata->cec_abst_data))
+		cec_abstract_deinit(udata->cec_abst_data);
+
+	if (udata->edid_data)
+		hdmi_edid_deinit(udata->edid_data);
+
+	if (udata->pinfo) {
+		udata->pinfo->edid_data = NULL;
+		udata->pinfo->is_cec_supported = false;
+	}
+
+	if (udata->audio_switch_registered)
+		switch_dev_unregister(&udata->sdev_audio);
+
+	if (udata->display_switch_registered)
+		switch_dev_unregister(&udata->sdev_display);
+
+	if (udata->kobj)
+		mdss_dba_utils_sysfs_remove(udata->kobj);
+
+	if (IS_ENABLED(CONFIG_MSM_DBA)) {
+		if (!IS_ERR_OR_NULL(udata->dba_data))
+			msm_dba_deregister_client(udata->dba_data);
+	}
+
+	kfree(udata);
+}
diff --git a/drivers/video/fbdev/msm/mdss_dba_utils.h b/drivers/video/fbdev/msm/mdss_dba_utils.h
new file mode 100644
index 000000000000..cf43d2def7c3
--- /dev/null
+++ b/drivers/video/fbdev/msm/mdss_dba_utils.h
@@ -0,0 +1,47 @@
+/* Copyright (c) 2015, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only 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 __MDSS_DBA_UTILS__
+#define __MDSS_DBA_UTILS__
+
+#include <linux/types.h>
+
+#include "mdss_panel.h"
+
+/**
+ * struct mdss_dba_utils_init_data - Init data for registering with DBA utils.
+ * @kobj: An instance of Kobject for sysfs creation
+ * @instance_id: Instance ID of device registered with DBA
+ * @chip_name: Name of the device registered with DBA
+ * @client_name: Name of the client registering with DBA
+ * @pinfo: Detailed panel information
+ *
+ * This structure's instance is needed to be passed as parameter
+ * to register API to let the DBA utils module configure and
+ * allocate an instance of DBA utils for the client.
+ */
+struct mdss_dba_utils_init_data {
+	struct kobject *kobj;
+	u32 instance_id;
+	u32 fb_node;
+	char *chip_name;
+	char *client_name;
+	struct mdss_panel_info *pinfo;
+};
+
+int mdss_dba_utils_video_on(void *data, struct mdss_panel_info *pinfo);
+int mdss_dba_utils_video_off(void *data);
+void mdss_dba_utils_hdcp_enable(void *data, bool enable);
+
+void *mdss_dba_utils_init(struct mdss_dba_utils_init_data *init_data);
+void mdss_dba_utils_deinit(void *data);
+#endif /* __MDSS_DBA_UTILS__ */
diff --git a/drivers/video/fbdev/msm/mdss_dsi.c b/drivers/video/fbdev/msm/mdss_dsi.c
index 248de476bcf9..2bd8a47a04be 100644
--- a/drivers/video/fbdev/msm/mdss_dsi.c
+++ b/drivers/video/fbdev/msm/mdss_dsi.c
@@ -32,6 +32,7 @@
 #include "mdss_dsi.h"
 #include "mdss_debug.h"
 #include "mdss_dsi_phy.h"
+#include "mdss_dba_utils.h"
 
 #define XO_CLK_RATE	19200000
 #define CMDLINE_DSI_CTL_NUM_STRING_LEN 2
@@ -1359,13 +1360,16 @@ static int mdss_dsi_pinctrl_set_state(
 	bool active)
 {
 	struct pinctrl_state *pin_state;
+	struct mdss_panel_info *pinfo = NULL;
 	int rc = -EFAULT;
 
 	if (IS_ERR_OR_NULL(ctrl_pdata->pin_res.pinctrl))
 		return PTR_ERR(ctrl_pdata->pin_res.pinctrl);
 
-	if (mdss_dsi_is_right_ctrl(ctrl_pdata) &&
-		mdss_dsi_is_hw_config_split(ctrl_pdata->shared_data)) {
+	pinfo = &ctrl_pdata->panel_data.panel_info;
+	if ((mdss_dsi_is_right_ctrl(ctrl_pdata) &&
+		mdss_dsi_is_hw_config_split(ctrl_pdata->shared_data)) ||
+			pinfo->is_dba_panel) {
 		pr_debug("%s:%d, right ctrl pinctrl config not needed\n",
 			__func__, __LINE__);
 		return 0;
@@ -2216,6 +2220,45 @@ static int mdss_dsi_set_stream_size(struct mdss_panel_data *pdata)
 	return 0;
 }
 
+static void mdss_dsi_dba_work(struct work_struct *work)
+{
+	struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL;
+	struct delayed_work *dw = to_delayed_work(work);
+	struct mdss_dba_utils_init_data utils_init_data;
+	struct mdss_panel_info *pinfo;
+
+	ctrl_pdata = container_of(dw, struct mdss_dsi_ctrl_pdata, dba_work);
+	if (!ctrl_pdata) {
+		pr_err("%s: invalid ctrl data\n", __func__);
+		return;
+	}
+
+	pinfo = &ctrl_pdata->panel_data.panel_info;
+	if (!pinfo) {
+		pr_err("%s: invalid ctrl data\n", __func__);
+		return;
+	}
+
+	memset(&utils_init_data, 0, sizeof(utils_init_data));
+
+	utils_init_data.chip_name = "adv7533";
+	utils_init_data.client_name = "dsi";
+	utils_init_data.instance_id = 0;
+	utils_init_data.fb_node = ctrl_pdata->fb_node;
+	utils_init_data.kobj = ctrl_pdata->kobj;
+	utils_init_data.pinfo = pinfo;
+
+	pinfo->dba_data = mdss_dba_utils_init(&utils_init_data);
+
+	if (!IS_ERR_OR_NULL(pinfo->dba_data)) {
+		ctrl_pdata->ds_registered = true;
+	} else {
+		pr_debug("%s: dba device not ready, queue again\n", __func__);
+		queue_delayed_work(ctrl_pdata->workq,
+				&ctrl_pdata->dba_work, HZ);
+	}
+}
+
 static int mdss_dsi_reset_write_ptr(struct mdss_panel_data *pdata)
 {
 
@@ -2311,6 +2354,7 @@ static int mdss_dsi_event_handler(struct mdss_panel_data *pdata,
 {
 	int rc = 0;
 	struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL;
+	struct fb_info *fbi;
 	int power_state;
 	u32 mode;
 	struct mdss_panel_info *pinfo;
@@ -2440,6 +2484,19 @@ static int mdss_dsi_event_handler(struct mdss_panel_data *pdata,
 		break;
 	case MDSS_EVENT_FB_REGISTERED:
 		mdss_dsi_debugfs_init(ctrl_pdata);
+
+		fbi = (struct fb_info *)arg;
+		if (!fbi || !fbi->dev)
+			break;
+
+		ctrl_pdata->kobj = &fbi->dev->kobj;
+		ctrl_pdata->fb_node = fbi->node;
+
+		if (IS_ENABLED(CONFIG_MSM_DBA) &&
+			pdata->panel_info.is_dba_panel) {
+				queue_delayed_work(ctrl_pdata->workq,
+					&ctrl_pdata->dba_work, HZ);
+		}
 		break;
 	default:
 		pr_debug("%s: unhandled event=%d\n", __func__, event);
@@ -2946,6 +3003,16 @@ static int mdss_dsi_ctrl_probe(struct platform_device *pdev)
 		}
 		disable_irq(gpio_to_irq(ctrl_pdata->disp_te_gpio));
 	}
+
+	ctrl_pdata->workq = create_workqueue("mdss_dsi_dba");
+	if (!ctrl_pdata->workq) {
+		pr_err("%s: Error creating workqueue\n", __func__);
+		rc = -EPERM;
+		goto error_pan_node;
+	}
+
+	INIT_DELAYED_WORK(&ctrl_pdata->dba_work, mdss_dsi_dba_work);
+
 	pr_debug("%s: Dsi Ctrl->%d initialized\n", __func__, index);
 
 	if (index == 0)
@@ -3036,8 +3103,18 @@ static void mdss_dsi_res_deinit(struct platform_device *pdev)
 	}
 
 	for (i = 0; i < DSI_CTRL_MAX; i++) {
-		if (dsi_res->ctrl_pdata[i])
+		if (dsi_res->ctrl_pdata[i]) {
+			if (dsi_res->ctrl_pdata[i]->ds_registered) {
+				struct mdss_panel_info *pinfo =
+					&dsi_res->ctrl_pdata[i]->
+						panel_data.panel_info;
+
+				if (pinfo)
+					mdss_dba_utils_deinit(pinfo->dba_data);
+			}
+
 			devm_kfree(&pdev->dev, dsi_res->ctrl_pdata[i]);
+		}
 	}
 
 	sdata = dsi_res->shared_data;
@@ -3425,6 +3502,10 @@ static int mdss_dsi_ctrl_remove(struct platform_device *pdev)
 	msm_dss_iounmap(&ctrl_pdata->phy_io);
 	msm_dss_iounmap(&ctrl_pdata->ctrl_io);
 	mdss_dsi_debugfs_cleanup(ctrl_pdata);
+
+	if (ctrl_pdata->workq)
+		destroy_workqueue(ctrl_pdata->workq);
+
 	return 0;
 }
 
diff --git a/drivers/video/fbdev/msm/mdss_dsi.h b/drivers/video/fbdev/msm/mdss_dsi.h
index 6c9706b232e2..64ea161a72fe 100644
--- a/drivers/video/fbdev/msm/mdss_dsi.h
+++ b/drivers/video/fbdev/msm/mdss_dsi.h
@@ -19,13 +19,10 @@
 #include <linux/irqreturn.h>
 #include <linux/pinctrl/consumer.h>
 #include <linux/gpio.h>
-#include <linux/switch.h>
-#include <video/msm_dba.h>
 
 #include "mdss_panel.h"
 #include "mdss_dsi_cmd.h"
 #include "mdss_dsi_clk.h"
-#include "mdss_hdmi_edid.h"
 
 #define MMSS_SERDES_BASE_PHY 0x04f01000 /* mmss (De)Serializer CFG */
 
@@ -516,19 +513,11 @@ struct mdss_dsi_ctrl_pdata {
 
 	struct dsi_err_container err_cont;
 
-	struct switch_dev sdev;
-	bool hpd_state;
+
 	bool ds_registered;
 
-	struct msm_dba_reg_info dba_info;
-	struct msm_dba_ops dba_ops;
-	struct msm_dba_video_cfg dba_video_cfg;
-	void *dba_data;
-
-	void *edid_data;
-	u8 edid_buf[EDID_BLOCK_SIZE * 2];
-
-	struct fb_info *fbi;
+	struct kobject *kobj;
+	int fb_node;
 
 	struct workqueue_struct *workq;
 	struct delayed_work dba_work;
diff --git a/drivers/video/fbdev/msm/mdss_dsi_panel.c b/drivers/video/fbdev/msm/mdss_dsi_panel.c
index 9b6a8f705ef5..02150ac29755 100644
--- a/drivers/video/fbdev/msm/mdss_dsi_panel.c
+++ b/drivers/video/fbdev/msm/mdss_dsi_panel.c
@@ -24,6 +24,7 @@
 #include <linux/string.h>
 
 #include "mdss_dsi.h"
+#include "mdss_dba_utils.h"
 
 #define DT_CMD_HDR 6
 #define MIN_REFRESH_RATE 48
@@ -284,8 +285,10 @@ int mdss_dsi_panel_reset(struct mdss_panel_data *pdata, int enable)
 	ctrl_pdata = container_of(pdata, struct mdss_dsi_ctrl_pdata,
 				panel_data);
 
-	if (mdss_dsi_is_right_ctrl(ctrl_pdata) &&
-		mdss_dsi_is_hw_config_split(ctrl_pdata->shared_data)) {
+	pinfo = &(ctrl_pdata->panel_data.panel_info);
+	if ((mdss_dsi_is_right_ctrl(ctrl_pdata) &&
+		mdss_dsi_is_hw_config_split(ctrl_pdata->shared_data)) ||
+			pinfo->is_dba_panel) {
 		pr_debug("%s:%d, right ctrl gpio configuration not needed\n",
 			__func__, __LINE__);
 		return rc;
@@ -303,7 +306,6 @@ int mdss_dsi_panel_reset(struct mdss_panel_data *pdata, int enable)
 	}
 
 	pr_debug("%s: enable = %d\n", __func__, enable);
-	pinfo = &(ctrl_pdata->panel_data.panel_info);
 
 	if (enable) {
 		rc = mdss_dsi_request_gpios(ctrl_pdata);
@@ -695,17 +697,8 @@ static int mdss_dsi_panel_on(struct mdss_panel_data *pdata)
 	if (pinfo->compression_mode == COMPRESSION_DSC)
 		mdss_dsi_panel_dsc_pps_send(ctrl, pinfo);
 
-	if (ctrl->ds_registered) {
-		if (ctrl->dba_ops.video_on)
-			ret = ctrl->dba_ops.video_on(
-				ctrl->dba_data, true,
-				&ctrl->dba_video_cfg, 0);
-			if (ret) {
-				pr_err("%s: video on failed for chip %s\n",
-					__func__, ctrl->dba_info.chip_name);
-			}
-	}
-
+	if (ctrl->ds_registered && pinfo->is_pluggable)
+		mdss_dba_utils_video_on(pinfo->dba_data, pinfo);
 end:
 	pinfo->blank_state = MDSS_PANEL_BLANK_UNBLANK;
 	pr_debug("%s:-\n", __func__);
@@ -717,6 +710,7 @@ static int mdss_dsi_post_panel_on(struct mdss_panel_data *pdata)
 	struct mdss_dsi_ctrl_pdata *ctrl = NULL;
 	struct mdss_panel_info *pinfo;
 	struct dsi_panel_cmds *cmds;
+	u32 vsync_period = 0;
 
 	if (pdata == NULL) {
 		pr_err("%s: Invalid input data\n", __func__);
@@ -738,6 +732,13 @@ static int mdss_dsi_post_panel_on(struct mdss_panel_data *pdata)
 		mdss_dsi_panel_cmds_send(ctrl, cmds, CMD_REQ_COMMIT);
 	}
 
+	if (pinfo->is_dba_panel && pinfo->is_pluggable) {
+		/* ensure at least 1 frame transfers to down stream device */
+		vsync_period = (MSEC_PER_SEC / pinfo->mipi.frame_rate) + 1;
+		msleep(vsync_period);
+		mdss_dba_utils_hdcp_enable(pinfo->dba_data, true);
+	}
+
 end:
 	pr_debug("%s:-\n", __func__);
 	return 0;
@@ -767,6 +768,11 @@ static int mdss_dsi_panel_off(struct mdss_panel_data *pdata)
 	if (ctrl->off_cmds.cmd_cnt)
 		mdss_dsi_panel_cmds_send(ctrl, &ctrl->off_cmds, CMD_REQ_COMMIT);
 
+	if (ctrl->ds_registered && pinfo->is_pluggable) {
+		mdss_dba_utils_video_off(pinfo->dba_data);
+		mdss_dba_utils_hdcp_enable(pinfo->dba_data, false);
+	}
+
 end:
 	pinfo->blank_state = MDSS_PANEL_BLANK_BLANK;
 	pr_debug("%s:-\n", __func__);
@@ -1853,7 +1859,7 @@ static int mdss_dsi_panel_timing_from_dt(struct device_node *np,
 {
 	u32 tmp;
 	u64 tmp64;
-	int rc, i, len, num_lanes;
+	int rc, i, len;
 	const char *data;
 	struct mdss_dsi_ctrl_pdata *ctrl_pdata;
 	struct mdss_panel_info *pinfo;
@@ -1921,35 +1927,6 @@ static int mdss_dsi_panel_timing_from_dt(struct device_node *np,
 			"qcom,mdss-dsi-panel-clockrate", (u32 *)&tmp64);
 	pt->timing.clk_rate = !rc ? tmp64 : 0;
 
-	/* Update timing parameter to DBA structure*/
-	ctrl_pdata->dba_video_cfg.h_active      =
-		pt->timing.xres;
-	ctrl_pdata->dba_video_cfg.h_front_porch =
-		pt->timing.h_front_porch;
-	ctrl_pdata->dba_video_cfg.h_back_porch  =
-		pt->timing.h_back_porch;
-	ctrl_pdata->dba_video_cfg.h_pulse_width =
-		pt->timing.h_pulse_width;
-	ctrl_pdata->dba_video_cfg.v_active      =
-		pt->timing.yres;
-	ctrl_pdata->dba_video_cfg.v_front_porch =
-		pt->timing.v_front_porch;
-	ctrl_pdata->dba_video_cfg.v_back_porch  =
-		pt->timing.v_back_porch;
-	ctrl_pdata->dba_video_cfg.v_pulse_width =
-		pt->timing.v_pulse_width;
-
-	num_lanes = 0;
-	if (pinfo->mipi.data_lane0)
-		num_lanes++;
-	if (pinfo->mipi.data_lane1)
-		num_lanes++;
-	if (pinfo->mipi.data_lane2)
-		num_lanes++;
-	if (pinfo->mipi.data_lane3)
-		num_lanes++;
-	ctrl_pdata->dba_video_cfg.num_of_input_lanes = num_lanes;
-
 	data = of_get_property(np, "qcom,mdss-dsi-panel-timings", &len);
 	if ((!data) || (len != 12)) {
 		pr_debug("%s:%d, Unable to read Phy timing settings",
@@ -2304,124 +2281,15 @@ static int mdss_panel_parse_dt(struct device_node *np,
 
 	mdss_dsi_parse_dfps_config(np, ctrl_pdata);
 
+	pinfo->is_dba_panel = of_property_read_bool(np,
+			"qcom,dba-panel");
+
 	return 0;
 
 error:
 	return -EINVAL;
 }
 
-static inline void mdss_dsi_send_cable_notification(
-	struct mdss_dsi_ctrl_pdata *ctrl_pdata, int val)
-{
-	int state = 0;
-
-	if (!ctrl_pdata) {
-		DEV_ERR("%s: invalid input\n", __func__);
-		return;
-	}
-	state = ctrl_pdata->sdev.state;
-
-	switch_set_state(&ctrl_pdata->sdev, val);
-
-	DEV_INFO("%s: cable state %s %d\n", __func__,
-		ctrl_pdata->sdev.state == state ?
-			"is same" : "switched to",
-		ctrl_pdata->sdev.state);
-}
-
-static void mdss_dsi_dba_cb(void *data, enum msm_dba_callback_event event)
-{
-	int ret = -EINVAL;
-	struct mdss_dsi_ctrl_pdata *ctrl_pdata =
-		(struct mdss_dsi_ctrl_pdata *) data;
-
-	if (!ctrl_pdata) {
-		pr_err("%s: Invalid data\n", __func__);
-		return;
-	}
-
-	switch (event) {
-	case MSM_DBA_CB_HPD_CONNECT:
-		ctrl_pdata->hpd_state = true;
-
-		if (ctrl_pdata->dba_ops.get_raw_edid)
-			ret = ctrl_pdata->dba_ops.get_raw_edid(
-				ctrl_pdata->dba_data,
-				sizeof(ctrl_pdata->edid_buf),
-				ctrl_pdata->edid_buf, 0);
-
-		if (!ret)
-			hdmi_edid_parser(ctrl_pdata->edid_data);
-
-		mdss_dsi_send_cable_notification(ctrl_pdata, 1);
-		break;
-
-	case MSM_DBA_CB_HPD_DISCONNECT:
-		mdss_dsi_send_cable_notification(ctrl_pdata, 0);
-		ctrl_pdata->hpd_state = false;
-		break;
-
-	default:
-		break;
-	}
-}
-
-static void mdss_dsi_ctrl_init_dba(struct mdss_dsi_ctrl_pdata *ctrl_pdata,
-	int ndx)
-{
-	struct hdmi_edid_init_data edid_init_data;
-	msm_dba_cb dba_cb = mdss_dsi_dba_cb;
-
-	if (!ctrl_pdata) {
-		pr_err("%s: Invalid ctrl data\n", __func__);
-		goto end;
-	}
-
-	snprintf(ctrl_pdata->dba_info.client_name, MSM_DBA_CLIENT_NAME_LEN,
-		"dsi-%d", ndx);
-
-	strlcpy(ctrl_pdata->dba_info.chip_name, "adv7533",
-		MSM_DBA_CHIP_NAME_MAX_LEN);
-
-	ctrl_pdata->dba_info.instance_id = ndx;
-	ctrl_pdata->dba_info.cb = dba_cb;
-	ctrl_pdata->dba_info.cb_data = ctrl_pdata;
-
-	ctrl_pdata->dba_data = msm_dba_register_client(
-		&ctrl_pdata->dba_info,
-		&ctrl_pdata->dba_ops);
-
-	if (IS_ERR_OR_NULL(ctrl_pdata->dba_data)) {
-		pr_err("%s: ds not configured, %p\n", __func__,
-			ctrl_pdata->dba_data);
-		goto end;
-	}
-
-	ctrl_pdata->sdev.name = ctrl_pdata->dba_info.client_name;
-	if (switch_dev_register(&ctrl_pdata->sdev) < 0) {
-		pr_err("%s: DSI switch registration failed\n",
-			__func__);
-		goto end;
-	}
-
-	memset(&edid_init_data, 0x00, sizeof(edid_init_data));
-	ctrl_pdata->edid_data = hdmi_edid_init(&edid_init_data);
-	if (!ctrl_pdata->edid_data) {
-		pr_err("%s: edid parser init failed\n", __func__);
-		goto end;
-	}
-
-	if (ctrl_pdata->dba_ops.power_on)
-		ctrl_pdata->dba_ops.power_on(ctrl_pdata->dba_data,
-			true, 0);
-
-	ctrl_pdata->ds_registered = true;
-	ctrl_pdata->hpd_state = true;
-	mdss_dsi_send_cable_notification(ctrl_pdata, 1);
-end:
-	return;
-}
-
 int mdss_dsi_panel_init(struct device_node *node,
 	struct mdss_dsi_ctrl_pdata *ctrl_pdata,
 	int ndx)
@@ -2464,7 +2332,5 @@ int mdss_dsi_panel_init(struct device_node *node,
 	ctrl_pdata->panel_data.set_backlight = mdss_dsi_panel_bl_ctrl;
 	ctrl_pdata->switch_mode = mdss_dsi_panel_switch_mode;
 
-	mdss_dsi_ctrl_init_dba(ctrl_pdata, ndx);
-
 	return 0;
 }
diff --git a/drivers/video/fbdev/msm/mdss_fb.c b/drivers/video/fbdev/msm/mdss_fb.c
index 344d1e5d758a..0e97cdc24b41 100644
--- a/drivers/video/fbdev/msm/mdss_fb.c
+++ b/drivers/video/fbdev/msm/mdss_fb.c
@@ -541,14 +541,16 @@ static ssize_t mdss_fb_get_panel_info(struct device *dev,
 			"pu_en=%d\nxstart=%d\nwalign=%d\nystart=%d\nhalign=%d\n"
 			"min_w=%d\nmin_h=%d\nroi_merge=%d\ndyn_fps_en=%d\n"
 			"min_fps=%d\nmax_fps=%d\npanel_name=%s\n"
-			"primary_panel=%d\nis_pluggable=%d\ndisplay_id=%s\n",
+			"primary_panel=%d\nis_pluggable=%d\ndisplay_id=%s\n"
+			"is_cec_supported=%d\n",
 			pinfo->partial_update_enabled, pinfo->xstart_pix_align,
 			pinfo->width_pix_align, pinfo->ystart_pix_align,
 			pinfo->height_pix_align, pinfo->min_width,
 			pinfo->min_height, pinfo->partial_update_roi_merge,
 			pinfo->dynamic_fps, pinfo->min_fps, pinfo->max_fps,
 			pinfo->panel_name, pinfo->is_prim_panel,
-			pinfo->is_pluggable, pinfo->display_id);
+			pinfo->is_pluggable, pinfo->display_id,
+			pinfo->is_cec_supported);
 
 	return ret;
 }
diff --git a/drivers/video/fbdev/msm/mdss_hdmi_cec.c b/drivers/video/fbdev/msm/mdss_hdmi_cec.c
index 3ddbf8bc7ee6..3799216aa5ad 100644
--- a/drivers/video/fbdev/msm/mdss_hdmi_cec.c
+++ b/drivers/video/fbdev/msm/mdss_hdmi_cec.c
@@ -18,6 +18,7 @@
 #include <linux/device.h>
 
 #include "mdss_hdmi_cec.h"
+#include "mdss_panel.h"
 
 #define CEC_STATUS_WR_ERROR	BIT(0)
 #define CEC_STATUS_WR_DONE	BIT(1)
@@ -260,6 +261,7 @@ static int hdmi_cec_enable(void *input, bool enable)
 	u32 hdmi_hw_version, reg_val;
 	struct dss_io_data *io = NULL;
 	struct hdmi_cec_ctrl *cec_ctrl = (struct hdmi_cec_ctrl *)input;
+	struct mdss_panel_info *pinfo;
 
 	if (!cec_ctrl || !cec_ctrl->init_data.io) {
 		DEV_ERR("%s: Invalid input\n", __func__);
@@ -268,6 +270,12 @@ static int hdmi_cec_enable(void *input, bool enable)
 	}
 
 	io = cec_ctrl->init_data.io;
+	pinfo = cec_ctrl->init_data.pinfo;
+
+	if (!pinfo) {
+		DEV_ERR("%s: invalid pinfo\n", __func__);
+		goto end;
+	}
 
 	if (enable) {
 		/* 19.2Mhz * 0.00005 us = 950 = 0x3B6 */
diff --git a/drivers/video/fbdev/msm/mdss_hdmi_cec.h b/drivers/video/fbdev/msm/mdss_hdmi_cec.h
index a653ae3578ba..a197ce2a605f 100644
--- a/drivers/video/fbdev/msm/mdss_hdmi_cec.h
+++ b/drivers/video/fbdev/msm/mdss_hdmi_cec.h
@@ -31,11 +31,39 @@
 struct hdmi_cec_init_data {
 	struct workqueue_struct *workq;
 	struct dss_io_data *io;
+	struct mdss_panel_info *pinfo;
 	struct cec_cbs *cbs;
 	struct cec_ops *ops;
 };
 
+/**
+ * hdmi_cec_isr() - interrupt handler for cec hw module
+ * @cec_ctrl: pointer to cec hw module's data
+ *
+ * Return: irq error code
+ *
+ * The API can be called by HDMI Tx driver on receiving hw interrupts
+ * to let the CEC related interrupts handled by this module.
+ */
 int hdmi_cec_isr(void *cec_ctrl);
+
+/**
+ * hdmi_cec_init() - Initialize the CEC hw module
+ * @init_data: data needed to initialize the cec hw module
+ *
+ * Return: pointer to cec hw modules data that needs to be passed when
+ * calling cec hw modules API or error code.
+ *
+ * The API registers CEC HW modules with the client and provides HW
+ * specific operations.
+ */
 void *hdmi_cec_init(struct hdmi_cec_init_data *init_data);
+
+/**
+ * hdmi_cec_deinit() - de-initialize CEC HW module
+ * @data: CEC HW module data
+ *
+ * This API release all resources allocated.
+ */
 void hdmi_cec_deinit(void *data);
 #endif /* __MDSS_HDMI_CEC_H__ */
diff --git a/drivers/video/fbdev/msm/mdss_hdmi_edid.c b/drivers/video/fbdev/msm/mdss_hdmi_edid.c
index e6dee010ba05..26c63ec417a6 100644
--- a/drivers/video/fbdev/msm/mdss_hdmi_edid.c
+++ b/drivers/video/fbdev/msm/mdss_hdmi_edid.c
@@ -348,7 +348,7 @@ static ssize_t hdmi_edid_sysfs_wta_modes(struct device *dev,
 	}
 
 	rc = hdmi_get_supported_mode(&info,
-		edid_ctrl->init_data.ds_data, vic);
+		&edid_ctrl->init_data.ds_data, vic);
 	if (rc) {
 		DEV_ERR("%s: error getting res details\n", __func__);
 		ret = -EINVAL;
@@ -479,7 +479,7 @@ static ssize_t hdmi_edid_sysfs_rda_res_info(struct device *dev,
 
 	for (; i < no_of_elem && size_to_write < PAGE_SIZE; i++) {
 		ret = hdmi_get_supported_mode(&info,
-			edid_ctrl->init_data.ds_data,
+			&edid_ctrl->init_data.ds_data,
 			minfo->video_format);
 
 		info.pixel_formats =
@@ -800,7 +800,7 @@ static void hdmi_edid_add_sink_y420_format(struct hdmi_edid_ctrl *edid_ctrl,
 {
 	struct msm_hdmi_mode_timing_info timing = {0};
 	u32 ret = hdmi_get_supported_mode(&timing,
-				edid_ctrl->init_data.ds_data,
+				&edid_ctrl->init_data.ds_data,
 				video_format);
 	u32 supported = hdmi_edid_is_mode_supported(edid_ctrl, &timing);
 	struct hdmi_edid_sink_data *sink = &edid_ctrl->sink_data;
@@ -1471,7 +1471,7 @@ static void hdmi_edid_add_sink_video_format(struct hdmi_edid_ctrl *edid_ctrl,
 {
 	struct msm_hdmi_mode_timing_info timing = {0};
 	u32 ret = hdmi_get_supported_mode(&timing,
-				edid_ctrl->init_data.ds_data,
+				&edid_ctrl->init_data.ds_data,
 				video_format);
 	u32 supported = hdmi_edid_is_mode_supported(edid_ctrl, &timing);
 	struct hdmi_edid_sink_data *sink_data = &edid_ctrl->sink_data;
diff --git a/drivers/video/fbdev/msm/mdss_hdmi_edid.h b/drivers/video/fbdev/msm/mdss_hdmi_edid.h
index 9dc9dbd9400b..d485e370d3aa 100644
--- a/drivers/video/fbdev/msm/mdss_hdmi_edid.h
+++ b/drivers/video/fbdev/msm/mdss_hdmi_edid.h
@@ -22,7 +22,7 @@
 
 struct hdmi_edid_init_data {
 	struct kobject *kobj;
-	struct hdmi_util_ds_data *ds_data;
+	struct hdmi_util_ds_data ds_data;
 	u32 max_pclk_khz;
 	u8 *buf;
 	u32 buf_size;
diff --git a/drivers/video/fbdev/msm/mdss_hdmi_tx.c b/drivers/video/fbdev/msm/mdss_hdmi_tx.c
index 59cd18f091f6..df35c2ceb565 100644
--- a/drivers/video/fbdev/msm/mdss_hdmi_tx.c
+++ b/drivers/video/fbdev/msm/mdss_hdmi_tx.c
@@ -1662,7 +1662,7 @@ static int hdmi_tx_init_features(struct hdmi_tx_ctrl *hdmi_ctrl,
 
 	/* Initialize EDID feature */
 	edid_init_data.kobj = hdmi_ctrl->kobj;
-	edid_init_data.ds_data = &hdmi_ctrl->ds_data;
+	edid_init_data.ds_data = hdmi_ctrl->ds_data;
 	edid_init_data.max_pclk_khz = hdmi_ctrl->max_pclk_khz;
 
 	fd = hdmi_edid_init(&edid_init_data);
@@ -1733,6 +1733,7 @@ static int hdmi_tx_init_features(struct hdmi_tx_ctrl *hdmi_ctrl,
 	/* initialize cec hw feature and get ops */
 	cec_init_data.io = &hdmi_ctrl->pdata.io[HDMI_TX_CORE_IO];
 	cec_init_data.workq = hdmi_ctrl->workq;
+	cec_init_data.pinfo = &hdmi_ctrl->panel_data.panel_info;
 	cec_init_data.ops = &hdmi_ctrl->hdmi_cec_ops;
 	cec_init_data.cbs = &hdmi_ctrl->hdmi_cec_cbs;
 
@@ -1742,6 +1743,7 @@ static int hdmi_tx_init_features(struct hdmi_tx_ctrl *hdmi_ctrl,
 		goto err_cec_hw;
 	}
 
+	hdmi_ctrl->panel_data.panel_info.is_cec_supported = true;
 	hdmi_ctrl->feature_data[HDMI_TX_FEAT_CEC_HW] = cec_hw_data;
 
 	/* initialize cec abstract layer and get callbacks */
@@ -1763,6 +1765,7 @@ static int hdmi_tx_init_features(struct hdmi_tx_ctrl *hdmi_ctrl,
 
 err_cec_abst:
 	hdmi_cec_deinit(hdmi_ctrl->feature_data[HDMI_TX_FEAT_CEC_HW]);
+	hdmi_ctrl->panel_data.panel_info.is_cec_supported = false;
 err_cec_hw:
 	if (hdmi_ctrl->feature_data[HDMI_TX_FEAT_HDCP2P2]) {
 		hdmi_hdcp2p2_deinit(
@@ -4181,6 +4184,7 @@ static void hdmi_tx_dev_deinit(struct hdmi_tx_ctrl *hdmi_ctrl)
 	if (hdmi_ctrl->feature_data[HDMI_TX_FEAT_CEC_HW]) {
 		hdmi_cec_deinit(hdmi_ctrl->feature_data[HDMI_TX_FEAT_CEC_HW]);
 		hdmi_ctrl->feature_data[HDMI_TX_FEAT_CEC_HW] = NULL;
+		hdmi_ctrl->panel_data.panel_info.is_cec_supported = false;
 	}
 
 	if (hdmi_ctrl->feature_data[HDMI_TX_FEAT_HDCP]) {
@@ -4270,25 +4274,8 @@ static int hdmi_tx_dev_init(struct hdmi_tx_ctrl *hdmi_ctrl)
 	hdmi_ctrl->audio_data.sample_rate_hz = AUDIO_SAMPLE_RATE_48KHZ;
 	hdmi_ctrl->audio_data.num_of_channels = MSM_HDMI_AUDIO_CHANNEL_2;
 
-	hdmi_ctrl->sdev.name = "hdmi";
-	if (switch_dev_register(&hdmi_ctrl->sdev) < 0) {
-		DEV_ERR("%s: Hdmi switch registration failed\n", __func__);
-		rc = -ENODEV;
-		goto fail_create_workq;
-	}
-
-	hdmi_ctrl->audio_sdev.name = "hdmi_audio";
-	if (switch_dev_register(&hdmi_ctrl->audio_sdev) < 0) {
-		DEV_ERR("%s: hdmi_audio switch registration failed\n",
-			__func__);
-		rc = -ENODEV;
-		goto fail_audio_switch_dev;
-	}
-
 	return 0;
 
-fail_audio_switch_dev:
-	switch_dev_unregister(&hdmi_ctrl->sdev);
 fail_create_workq:
 	if (hdmi_ctrl->workq)
 		destroy_workqueue(hdmi_ctrl->workq);
@@ -4326,6 +4313,31 @@ static int hdmi_tx_start_hdcp(struct hdmi_tx_ctrl *hdmi_ctrl)
 	return rc;
 }
 
+static int hdmi_tx_init_switch_dev(struct hdmi_tx_ctrl *hdmi_ctrl)
+{
+	int rc = -EINVAL;
+
+	if (!hdmi_ctrl) {
+		DEV_ERR("%s: invalid input\n", __func__);
+		goto end;
+	}
+
+	hdmi_ctrl->sdev.name = "hdmi";
+	rc = switch_dev_register(&hdmi_ctrl->sdev);
+	if (rc) {
+		DEV_ERR("%s: display switch registration failed\n", __func__);
+		goto end;
+	}
+
+	hdmi_ctrl->audio_sdev.name = "hdmi_audio";
+	rc = switch_dev_register(&hdmi_ctrl->audio_sdev);
+	if (rc)
+		DEV_ERR("%s: audio switch registration failed\n", __func__);
+
+end:
+	return rc;
+}
+
 static int hdmi_tx_panel_event_handler(struct mdss_panel_data *panel_data,
 	int event, void *arg)
 {
@@ -4357,6 +4369,14 @@ static int hdmi_tx_panel_event_handler(struct mdss_panel_data *panel_data,
 			return rc;
 		}
 
+		rc = hdmi_tx_init_switch_dev(hdmi_ctrl);
+		if (rc) {
+			DEV_ERR("%s: init switch dev failed.rc=%d\n",
+				__func__, rc);
+			hdmi_tx_sysfs_remove(hdmi_ctrl);
+			return rc;
+		}
+
 		if (hdmi_ctrl->pdata.primary || !hdmi_ctrl->pdata.pluggable) {
 			reinit_completion(&hdmi_ctrl->hpd_int_done);
 			rc = hdmi_tx_sysfs_enable_hpd(hdmi_ctrl, true);
diff --git a/drivers/video/fbdev/msm/mdss_hdmi_tx.h b/drivers/video/fbdev/msm/mdss_hdmi_tx.h
index 22868ee8d8e3..ad787dec2a6e 100644
--- a/drivers/video/fbdev/msm/mdss_hdmi_tx.h
+++ b/drivers/video/fbdev/msm/mdss_hdmi_tx.h
@@ -17,6 +17,8 @@
 #include "mdss_hdmi_util.h"
 #include "mdss_cec_core.h"
 
+#define MAX_SWITCH_NAME_SIZE        5
+
 enum hdmi_tx_io_type {
 	HDMI_TX_CORE_IO,
 	HDMI_TX_QFPROM_IO,
@@ -195,6 +197,8 @@ struct hdmi_tx_ctrl {
 
 	struct cec_ops hdmi_cec_ops;
 	struct cec_cbs hdmi_cec_cbs;
+
+	char disp_switch_name[MAX_SWITCH_NAME_SIZE];
 };
 
 #endif /* __MDSS_HDMI_TX_H__ */
diff --git a/drivers/video/fbdev/msm/mdss_panel.h b/drivers/video/fbdev/msm/mdss_panel.h
index f450d0e3dbf6..83949d821fdb 100644
--- a/drivers/video/fbdev/msm/mdss_panel.h
+++ b/drivers/video/fbdev/msm/mdss_panel.h
@@ -630,11 +630,13 @@ struct mdss_panel_info {
 	bool is_prim_panel;
 	bool is_pluggable;
 	char display_id[MDSS_DISPLAY_ID_MAX_LEN];
+	bool is_cec_supported;
 
 	/* refer sim_panel_modes enum for different modes */
 	u8 sim_panel_mode;
 
 	void *edid_data;
+	void *dba_data;
 	void *cec_data;
 
 	char panel_name[MDSS_MAX_PANEL_LEN];
@@ -654,6 +656,8 @@ struct mdss_panel_info {
 	struct lvds_panel_info lvds;
 	struct edp_panel_info edp;
 
+	bool is_dba_panel;
+
 	/*
 	 * Delay(in ms) to accommodate s/w delay while
 	 * configuring the event timer wakeup logic.
diff --git a/drivers/video/fbdev/msm/msm_dba/adv7533.c b/drivers/video/fbdev/msm/msm_dba/adv7533.c
index ef2cbd399fb3..e2b60663244a 100644
--- a/drivers/video/fbdev/msm/msm_dba/adv7533.c
+++ b/drivers/video/fbdev/msm/msm_dba/adv7533.c
@@ -27,6 +27,7 @@
 #include <linux/pm.h>
 #include <linux/pm_runtime.h>
 #include "msm_dba_internal.h"
+#include <linux/mdss_io_util.h>
 
 #define ADV7533_REG_CHIP_REVISION (0x00)
 #define ADV7533_DSI_CEC_I2C_ADDR_REG (0xE1)
@@ -38,23 +39,59 @@
 #define MDSS_MAX_PANEL_LEN      256
 #define EDID_SEG_SIZE 0x100
 
+/* 0x94 interrupts */
 #define HPD_INT_ENABLE           BIT(7)
 #define MONITOR_SENSE_INT_ENABLE BIT(6)
+#define ACTIVE_VSYNC_EDGE        BIT(5)
+#define AUDIO_FIFO_FULL          BIT(4)
 #define EDID_READY_INT_ENABLE    BIT(2)
+#define HDCP_AUTHENTICATED       BIT(1)
+#define HDCP_RI_READY            BIT(0)
 
 #define MAX_WAIT_TIME (100)
 #define MAX_RW_TRIES (3)
 
+/* 0x95 interrupts */
+#define HDCP_ERROR               BIT(7)
+#define HDCP_BKSV_FLAG           BIT(6)
+#define CEC_TX_READY             BIT(5)
+#define CEC_TX_ARB_LOST          BIT(4)
+#define CEC_TX_RETRY_TIMEOUT     BIT(3)
+#define CEC_TX_RX_BUF3_READY     BIT(2)
+#define CEC_TX_RX_BUF2_READY     BIT(1)
+#define CEC_TX_RX_BUF1_READY     BIT(0)
+
+#define HPD_INTERRUPTS           (HPD_INT_ENABLE | \
+					MONITOR_SENSE_INT_ENABLE)
+#define EDID_INTERRUPTS          EDID_READY_INT_ENABLE
+#define HDCP_INTERRUPTS1         HDCP_AUTHENTICATED
+#define HDCP_INTERRUPTS2         (HDCP_BKSV_FLAG | \
+					HDCP_ERROR)
+#define CEC_INTERRUPTS           (CEC_TX_READY | \
+					CEC_TX_ARB_LOST | \
+					CEC_TX_RETRY_TIMEOUT | \
+					CEC_TX_RX_BUF3_READY | \
+					CEC_TX_RX_BUF2_READY | \
+					CEC_TX_RX_BUF1_READY)
+
+#define CFG_HPD_INTERRUPTS       BIT(0)
+#define CFG_EDID_INTERRUPTS      BIT(1)
+#define CFG_HDCP_INTERRUPTS      BIT(2)
+#define CFG_CEC_INTERRUPTS       BIT(3)
+
+#define MAX_OPERAND_SIZE	14
+#define CEC_MSG_SIZE            (MAX_OPERAND_SIZE + 2)
+
 enum adv7533_i2c_addr {
-	ADV7533_MAIN = 0x3D,
-	ADV7533_CEC_DSI = 0x3C,
+	I2C_ADDR_MAIN = 0x3D,
+	I2C_ADDR_CEC_DSI = 0x3C,
 };
 
-enum adv7533_video_mode {
-	ADV7533_VIDEO_PATTERN,
-	ADV7533_VIDEO_480P,
-	ADV7533_VIDEO_720P,
-	ADV7533_VIDEO_1080P,
+enum adv7533_cec_buf {
+	ADV7533_CEC_BUF1,
+	ADV7533_CEC_BUF2,
+	ADV7533_CEC_BUF3,
+	ADV7533_CEC_BUF_MAX,
 };
 
 struct adv7533_reg_cfg {
@@ -64,7 +101,13 @@ struct adv7533_reg_cfg {
 	int sleep_in_ms;
 };
 
-struct adv7533_platform_data {
+struct adv7533_cec_msg {
+	u8 buf[CEC_MSG_SIZE];
+	u8 timestamp;
+	bool pending;
+};
+
+struct adv7533 {
 	u8 main_i2c_addr;
 	u8 cec_dsi_i2c_addr;
 	u8 video_mode;
@@ -80,222 +123,186 @@ struct adv7533_platform_data {
 	struct pinctrl_state *pinctrl_state_suspend;
 	bool audio;
 	bool disable_gpios;
-	bool adv_output;
+	struct dss_module_power power_data;
+	bool hdcp_enabled;
+	bool cec_enabled;
+	bool is_power_on;
 	void *edid_data;
 	u8 edid_buf[EDID_SEG_SIZE];
 	struct workqueue_struct *workq;
 	struct delayed_work adv7533_intr_work_id;
 	struct msm_dba_device_info dev_info;
-	msm_dba_cb client_cb;
-	void *client_cb_data;
+	struct adv7533_cec_msg cec_msg[ADV7533_CEC_BUF_MAX];
+	struct i2c_client *i2c_client;
+	struct mutex ops_mutex;
 };
 
+static char mdss_mdp_panel[MDSS_MAX_PANEL_LEN];
+
 static struct adv7533_reg_cfg adv7533_init_setup[] = {
-	/* HPD override */
-	{ADV7533_MAIN, 0xD6, 0x48, 5},
 	/* power down */
-	{ADV7533_MAIN, 0x41, 0x50, 5},
+	{I2C_ADDR_MAIN, 0x41, 0x50, 5},
+	/* HPD override */
+	{I2C_ADDR_MAIN, 0xD6, 0x48, 5},
 	/* color space */
-	{ADV7533_MAIN, 0x16, 0x20, 0},
+	{I2C_ADDR_MAIN, 0x16, 0x20, 0},
 	/* Fixed */
-	{ADV7533_MAIN, 0x9A, 0xE0, 0},
+	{I2C_ADDR_MAIN, 0x9A, 0xE0, 0},
 	/* HDCP */
-	{ADV7533_MAIN, 0xBA, 0x70, 0},
+	{I2C_ADDR_MAIN, 0xBA, 0x70, 0},
 	/* Fixed */
-	{ADV7533_MAIN, 0xDE, 0x82, 0},
+	{I2C_ADDR_MAIN, 0xDE, 0x82, 0},
 	/* V1P2 */
-	{ADV7533_MAIN, 0xE4, 0x40, 0},
+	{I2C_ADDR_MAIN, 0xE4, 0x40, 0},
 	/* Fixed */
-	{ADV7533_MAIN, 0xE5, 0x80, 0},
+	{I2C_ADDR_MAIN, 0xE5, 0x80, 0},
 	/* Fixed */
-	{ADV7533_CEC_DSI, 0x15, 0xD0, 0},
+	{I2C_ADDR_CEC_DSI, 0x15, 0xD0, 0},
 	/* Fixed */
-	{ADV7533_CEC_DSI, 0x17, 0xD0, 0},
+	{I2C_ADDR_CEC_DSI, 0x17, 0xD0, 0},
 	/* Fixed */
-	{ADV7533_CEC_DSI, 0x24, 0x20, 0},
+	{I2C_ADDR_CEC_DSI, 0x24, 0x20, 0},
 	/* Fixed */
-	{ADV7533_CEC_DSI, 0x57, 0x11, 0},
+	{I2C_ADDR_CEC_DSI, 0x57, 0x11, 0},
 };
 
-static struct adv7533_reg_cfg adv7533_video_setup[] = {
+static struct adv7533_reg_cfg adv7533_video_en[] = {
+	 /* Timing Generator Enable */
+	{I2C_ADDR_CEC_DSI, 0x27, 0xCB, 0},
+	{I2C_ADDR_CEC_DSI, 0x27, 0x8B, 0},
+	{I2C_ADDR_CEC_DSI, 0x27, 0xCB, 0},
 	/* power up */
-	{ADV7533_MAIN, 0x41, 0x10, 0},
+	{I2C_ADDR_MAIN, 0x41, 0x10, 0},
 	/* hdmi enable */
-	{ADV7533_CEC_DSI, 0x03, 0x89, 0},
-	/* hdmi mode, hdcp */
-	{ADV7533_MAIN, 0xAF, 0x06, 0},
+	{I2C_ADDR_CEC_DSI, 0x03, 0x89, 0},
 	/* color depth */
-	{ADV7533_MAIN, 0x4C, 0x04, 0},
+	{I2C_ADDR_MAIN, 0x4C, 0x04, 0},
 	/* down dither */
-	{ADV7533_MAIN, 0x49, 0x02, 0},
+	{I2C_ADDR_MAIN, 0x49, 0x02, 0},
+	/* Audio and CEC clock gate */
+	{I2C_ADDR_CEC_DSI, 0x05, 0xC8, 0},
+	/* GC packet enable */
+	{I2C_ADDR_MAIN, 0x40, 0x80, 0},
+};
+
+static struct adv7533_reg_cfg adv7533_cec_en[] = {
+	/* Fixed, clock gate disable */
+	{I2C_ADDR_CEC_DSI, 0x05, 0xC8, 0},
+	/* read divider(7:2) from calc */
+	{I2C_ADDR_CEC_DSI, 0xBE, 0x01, 0},
+};
+
+static struct adv7533_reg_cfg adv7533_cec_tg_init[] = {
+	/* TG programming for 19.2MHz, divider 25 */
+	{I2C_ADDR_CEC_DSI, 0xBE, 0x61, 0},
+	{I2C_ADDR_CEC_DSI, 0xC1, 0x0D, 0},
+	{I2C_ADDR_CEC_DSI, 0xC2, 0x80, 0},
+	{I2C_ADDR_CEC_DSI, 0xC3, 0x0C, 0},
+	{I2C_ADDR_CEC_DSI, 0xC4, 0x9A, 0},
+	{I2C_ADDR_CEC_DSI, 0xC5, 0x0E, 0},
+	{I2C_ADDR_CEC_DSI, 0xC6, 0x66, 0},
+	{I2C_ADDR_CEC_DSI, 0xC7, 0x0B, 0},
+	{I2C_ADDR_CEC_DSI, 0xC8, 0x1A, 0},
+	{I2C_ADDR_CEC_DSI, 0xC9, 0x0A, 0},
+	{I2C_ADDR_CEC_DSI, 0xCA, 0x33, 0},
+	{I2C_ADDR_CEC_DSI, 0xCB, 0x0C, 0},
+	{I2C_ADDR_CEC_DSI, 0xCC, 0x00, 0},
+	{I2C_ADDR_CEC_DSI, 0xCD, 0x07, 0},
+	{I2C_ADDR_CEC_DSI, 0xCE, 0x33, 0},
+	{I2C_ADDR_CEC_DSI, 0xCF, 0x05, 0},
+	{I2C_ADDR_CEC_DSI, 0xD0, 0xDA, 0},
+	{I2C_ADDR_CEC_DSI, 0xD1, 0x08, 0},
+	{I2C_ADDR_CEC_DSI, 0xD2, 0x8D, 0},
+	{I2C_ADDR_CEC_DSI, 0xD3, 0x01, 0},
+	{I2C_ADDR_CEC_DSI, 0xD4, 0xCD, 0},
+	{I2C_ADDR_CEC_DSI, 0xD5, 0x04, 0},
+	{I2C_ADDR_CEC_DSI, 0xD6, 0x80, 0},
+	{I2C_ADDR_CEC_DSI, 0xD7, 0x05, 0},
+	{I2C_ADDR_CEC_DSI, 0xD8, 0x66, 0},
+	{I2C_ADDR_CEC_DSI, 0xD9, 0x03, 0},
+	{I2C_ADDR_CEC_DSI, 0xDA, 0x26, 0},
+	{I2C_ADDR_CEC_DSI, 0xDB, 0x0A, 0},
+	{I2C_ADDR_CEC_DSI, 0xDC, 0xCD, 0},
+	{I2C_ADDR_CEC_DSI, 0xDE, 0x00, 0},
+	{I2C_ADDR_CEC_DSI, 0xDF, 0xC0, 0},
+	{I2C_ADDR_CEC_DSI, 0xE1, 0x00, 0},
+	{I2C_ADDR_CEC_DSI, 0xE2, 0xE6, 0},
+	{I2C_ADDR_CEC_DSI, 0xE3, 0x02, 0},
+	{I2C_ADDR_CEC_DSI, 0xE4, 0xB3, 0},
+	{I2C_ADDR_CEC_DSI, 0xE5, 0x03, 0},
+	{I2C_ADDR_CEC_DSI, 0xE6, 0x9A, 0},
+};
+
+static struct adv7533_reg_cfg adv7533_cec_power[] = {
+	/* cec power up */
+	{I2C_ADDR_MAIN, 0xE2, 0x00, 0},
+	/* hpd override */
+	{I2C_ADDR_MAIN, 0xD6, 0x48, 0},
+	/* edid reread */
+	{I2C_ADDR_MAIN, 0xC9, 0x13, 0},
+	/* read all CEC Rx Buffers */
+	{I2C_ADDR_CEC_DSI, 0xBA, 0x08, 0},
+	/* logical address0 0x04 */
+	{I2C_ADDR_CEC_DSI, 0xBC, 0x04, 0},
+	/* select logical address0 */
+	{I2C_ADDR_CEC_DSI, 0xBB, 0x10, 0},
 };
 
 static struct adv7533_reg_cfg I2S_cfg[] = {
-	{ADV7533_MAIN, 0x0D, 0x18},	/* Bit width = 16Bits*/
-	{ADV7533_MAIN, 0x15, 0x20},	/* Sampling Frequency = 48kHz*/
-	{ADV7533_MAIN, 0x02, 0x18},	/* N value 6144 --> 0x1800*/
-	{ADV7533_MAIN, 0x14, 0x02},	/* Word Length = 16Bits*/
-	{ADV7533_MAIN, 0x73, 0x01},	/* Channel Count = 2 channels */
+	{I2C_ADDR_MAIN, 0x0D, 0x18, 0},	/* Bit width = 16Bits*/
+	{I2C_ADDR_MAIN, 0x15, 0x20, 0},	/* Sampling Frequency = 48kHz*/
+	{I2C_ADDR_MAIN, 0x02, 0x18, 0},	/* N value 6144 --> 0x1800*/
+	{I2C_ADDR_MAIN, 0x14, 0x02, 0},	/* Word Length = 16Bits*/
+	{I2C_ADDR_MAIN, 0x73, 0x01, 0},	/* Channel Count = 2 channels */
 };
 
-static struct adv7533_reg_cfg irq_config[] = {
-	{ADV7533_CEC_DSI, 0x38, BIT(6)},
-	{ADV7533_MAIN, 0x94, HPD_INT_ENABLE |
-		MONITOR_SENSE_INT_ENABLE |
-		EDID_READY_INT_ENABLE},
-};
-
-static struct i2c_client *client;
-static struct adv7533_platform_data *pdata;
-static char mdss_mdp_panel[MDSS_MAX_PANEL_LEN];
-
-static int adv7533_read(u8 addr, u8 reg, u8 *buf, u8 len)
+static int adv7533_write(struct adv7533 *pdata, u8 offset, u8 reg, u8 val)
 {
-	int ret = 0, i = 0;
-	struct i2c_msg msg[2];
-
-	if (!client) {
-		pr_err("%s: no adv7533 i2c client\n", __func__);
-		ret = -ENODEV;
-		goto r_err;
-	}
-
-	if (NULL == buf) {
-		pr_err("%s: no adv7533 i2c client\n", __func__);
-		ret = -EINVAL;
-		goto r_err;
-	}
-
-	client->addr = addr;
-
-	msg[0].addr = addr;
-	msg[0].flags = 0;
-	msg[0].len = 1;
-	msg[0].buf = &reg;
-
-	msg[1].addr = addr;
-	msg[1].flags = I2C_M_RD;
-	msg[1].len = len;
-	msg[1].buf = buf;
-
-	do {
-		if (i2c_transfer(client->adapter, msg, 2) == 2) {
-			ret = 0;
-			goto r_err;
-		}
-		msleep(MAX_WAIT_TIME);
-	} while (++i < MAX_RW_TRIES);
-
-	ret = -EIO;
-	pr_err("%s adv7533 i2c read failed after %d tries\n", __func__,
-		MAX_RW_TRIES);
-
-r_err:
-	return ret;
-}
-
-int adv7533_read_byte(u8 addr, u8 reg, u8 *buf)
-{
-	return adv7533_read(addr, reg, buf, 1);
-}
-
-static int adv7533_write_byte(u8 addr, u8 reg, u8 val)
-{
-	int ret = 0, i = 0;
-	u8 buf[2] = {reg, val};
-	struct i2c_msg msg[1];
-
-	if (!client) {
-		pr_err("%s: no adv7533 i2c client\n", __func__);
-		ret = -ENODEV;
-		goto w_err;
-	}
-
-	client->addr = addr;
-
-	msg[0].addr = addr;
-	msg[0].flags = 0;
-	msg[0].len = 2;
-	msg[0].buf = buf;
-
-	do {
-		if (i2c_transfer(client->adapter, msg, 1) >= 1) {
-			ret = 0;
-			goto w_err;
-		}
-		msleep(MAX_WAIT_TIME);
-	} while (++i < MAX_RW_TRIES);
-
-	ret = -EIO;
-	pr_err("%s: adv7533 i2c write failed after %d tries\n", __func__,
-		MAX_RW_TRIES);
-
-w_err:
-	if (ret != 0)
-		pr_err("%s: Exiting with ret = %d after %d retries\n",
-			__func__, ret, i);
-	else
-		pr_debug("[%s,%d] I2C write(0x%02x) [0x%02x]=0x%02x\n",
-			__func__, __LINE__, addr, reg, val);
-	return ret;
-}
-
-static int adv7533_read_reg(struct msm_dba_device_info *dev, u32 reg, u32 *val)
-{
-	int rc = 0;
-	u8 byte_val = 0, addr = 0;
-	struct adv7533_platform_data *pdata = NULL;
-
-	if (!dev) {
-		pr_err("%s: dev is NULL\n", __func__);
-		return -EINVAL;
-	}
-	pdata = container_of(dev, struct adv7533_platform_data, dev_info);
-	if (!pdata) {
-		pr_err("%s: pdata is NULL\n", __func__);
-		return -EINVAL;
-	}
-
-	addr = (reg & 0x0100)?(pdata->cec_dsi_i2c_addr):(pdata->main_i2c_addr);
-	rc = adv7533_read_byte(addr, (reg & 0xff), &byte_val);
-	if (rc) {
-		pr_err("%s: read reg=0x%02x failed @ addr=0x%02x\n",
-			__func__, reg, addr);
-	} else {
-		pr_debug("%s: read reg=0x%02x ok value=0x%02x @ addr=0x%02x\n",
-			__func__, reg, byte_val, addr);
-		*val = (u32)byte_val;
-	}
-
-	return rc;
-}
-
-static int adv7533_write_reg(struct msm_dba_device_info *dev, u32 reg, u32 val)
-{
-	int rc = 0;
 	u8 addr = 0;
-	struct adv7533_platform_data *pdata = NULL;
+	int ret = 0;
 
-	if (!dev) {
-		pr_err("%s: dev is NULL\n", __func__);
-		return -EINVAL;
-	}
-	pdata = container_of(dev, struct adv7533_platform_data, dev_info);
 	if (!pdata) {
-		pr_err("%s: pdata is NULL\n", __func__);
+		pr_debug("%s: Invalid argument\n", __func__);
 		return -EINVAL;
 	}
 
-	addr = (reg & 0x0100)?(pdata->cec_dsi_i2c_addr):(pdata->main_i2c_addr);
-	rc = adv7533_write_byte(addr, (reg & 0xff), val);
-	if (rc)
-		pr_err("%s: write reg=0x%02x failed @ addr=0x%02x\n",
-			__func__, reg, pdata->main_i2c_addr);
+	if (offset == I2C_ADDR_MAIN)
+		addr = pdata->main_i2c_addr;
+	else if (offset == I2C_ADDR_CEC_DSI)
+		addr = pdata->cec_dsi_i2c_addr;
 	else
-		pr_debug("%s: write reg=0x%02x ok value=0x%02x @ addr=0x%02x\n",
-			__func__, reg, val, pdata->main_i2c_addr);
+		addr = offset;
 
-	return rc;
+	ret = msm_dba_helper_i2c_write_byte(pdata->i2c_client, addr, reg, val);
+	if (ret)
+		pr_err_ratelimited("%s: wr err: addr 0x%x, reg 0x%x, val 0x%x\n",
+				__func__, addr, reg, val);
+	return ret;
+}
+
+static int adv7533_read(struct adv7533 *pdata, u8 offset,
+		u8 reg, char *buf, u32 size)
+{
+	u8 addr = 0;
+	int ret = 0;
+
+	if (!pdata) {
+		pr_debug("%s: Invalid argument\n", __func__);
+		return -EINVAL;
+	}
+
+	if (offset == I2C_ADDR_MAIN)
+		addr = pdata->main_i2c_addr;
+	else if (offset == I2C_ADDR_CEC_DSI)
+		addr = pdata->cec_dsi_i2c_addr;
+	else
+		addr = offset;
+
+	ret = msm_dba_helper_i2c_read(pdata->i2c_client, addr, reg, buf, size);
+	if (ret)
+		pr_err_ratelimited("%s: read err: addr 0x%x, reg 0x%x, size 0x%x\n",
+				__func__, addr, reg, size);
+	return ret;
 }
 
 static int adv7533_dump_debug_info(struct msm_dba_device_info *dev, u32 flags)
@@ -303,13 +310,13 @@ static int adv7533_dump_debug_info(struct msm_dba_device_info *dev, u32 flags)
 	int rc = 0;
 	u8 byte_val = 0;
 	u16 addr = 0;
-	struct adv7533_platform_data *pdata = NULL;
+	struct adv7533 *pdata = NULL;
 
 	if (!dev) {
 		pr_err("%s: dev is NULL\n", __func__);
 		return -EINVAL;
 	}
-	pdata = container_of(dev, struct adv7533_platform_data, dev_info);
+	pdata = container_of(dev, struct adv7533, dev_info);
 	if (!pdata) {
 		pr_err("%s: pdata is NULL\n", __func__);
 		return -EINVAL;
@@ -319,8 +326,8 @@ static int adv7533_dump_debug_info(struct msm_dba_device_info *dev, u32 flags)
 	pr_err("========Main I2C=0x%02x Start==========\n",
 		pdata->main_i2c_addr);
 	for (addr = 0; addr <= 0xFF; addr++) {
-		rc = adv7533_read_byte(pdata->main_i2c_addr,
-			(u8)addr, &byte_val);
+		rc = adv7533_read(pdata, I2C_ADDR_MAIN,
+			(u8)addr, &byte_val, 1);
 		if (rc)
 			pr_err("%s: read reg=0x%02x failed @ addr=0x%02x\n",
 				__func__, addr, pdata->main_i2c_addr);
@@ -333,8 +340,8 @@ static int adv7533_dump_debug_info(struct msm_dba_device_info *dev, u32 flags)
 	pr_err("=======CEC I2C=0x%02x Start=========\n",
 		pdata->cec_dsi_i2c_addr);
 	for (addr = 0; addr <= 0xFF; addr++) {
-		rc = adv7533_read_byte(pdata->cec_dsi_i2c_addr,
-			(u8)addr, &byte_val);
+		rc = adv7533_read(pdata, I2C_ADDR_CEC_DSI,
+			(u8)addr, &byte_val, 1);
 		if (rc)
 			pr_err("%s: read reg=0x%02x failed @ addr=0x%02x\n",
 				__func__, addr, pdata->cec_dsi_i2c_addr);
@@ -347,23 +354,24 @@ static int adv7533_dump_debug_info(struct msm_dba_device_info *dev, u32 flags)
 	return rc;
 }
 
-static int adv7533_write_regs(struct adv7533_platform_data *pdata,
+static int adv7533_write_array(struct adv7533 *pdata,
 	struct adv7533_reg_cfg *cfg, int size)
 {
 	int ret = 0;
 	int i;
 
+	size = size / sizeof(struct adv7533_reg_cfg);
 	for (i = 0; i < size; i++) {
 		switch (cfg[i].i2c_addr) {
-		case ADV7533_MAIN:
-			ret = adv7533_write_byte(pdata->main_i2c_addr,
+		case I2C_ADDR_MAIN:
+			ret = adv7533_write(pdata, I2C_ADDR_MAIN,
 				cfg[i].reg, cfg[i].val);
 			if (ret != 0)
 				pr_err("%s: adv7533_write_byte returned %d\n",
 					__func__, ret);
 			break;
-		case ADV7533_CEC_DSI:
-			ret = adv7533_write_byte(pdata->cec_dsi_i2c_addr,
+		case I2C_ADDR_CEC_DSI:
+			ret = adv7533_write(pdata, I2C_ADDR_CEC_DSI,
 				cfg[i].reg, cfg[i].val);
 			if (ret != 0)
 				pr_err("%s: adv7533_write_byte returned %d\n",
@@ -391,29 +399,27 @@ w_regs_fail:
 	return ret;
 }
 
-static int adv7533_read_device_rev(struct adv7533_platform_data *pdata)
+static void adv7533_read_device_rev(struct adv7533 *pdata)
 {
 	u8 rev = 0;
 	int ret;
 
-	ret = adv7533_read_byte(pdata->main_i2c_addr, ADV7533_REG_CHIP_REVISION,
-							&rev);
+	ret = adv7533_read(pdata, I2C_ADDR_MAIN, ADV7533_REG_CHIP_REVISION,
+							&rev, 1);
 
 	if (!ret)
 		pr_debug("%s: adv7533 revision 0x%X\n", __func__, rev);
 	else
 		pr_err("%s: adv7533 rev error\n", __func__);
-
-	return ret;
 }
 
-static int adv7533_program_i2c_addr(struct adv7533_platform_data *pdata)
+static int adv7533_program_i2c_addr(struct adv7533 *pdata)
 {
 	u8 i2c_8bits = pdata->cec_dsi_i2c_addr << 1;
 	int ret = 0;
 
-	if (pdata->cec_dsi_i2c_addr != ADV7533_CEC_DSI) {
-		ret = adv7533_write_byte(pdata->main_i2c_addr,
+	if (pdata->cec_dsi_i2c_addr != I2C_ADDR_CEC_DSI) {
+		ret = adv7533_write(pdata, I2C_ADDR_MAIN,
 					ADV7533_DSI_CEC_I2C_ADDR_REG,
 					i2c_8bits);
 
@@ -426,8 +432,116 @@ static int adv7533_program_i2c_addr(struct adv7533_platform_data *pdata)
 	return ret;
 }
 
+static void adv7533_parse_vreg_dt(struct device *dev,
+				struct dss_module_power *mp)
+{
+	int i, rc = 0;
+	int dt_vreg_total = 0;
+	struct device_node *of_node = NULL;
+	u32 *val_array = NULL;
+
+	of_node = dev->of_node;
+
+	dt_vreg_total = of_property_count_strings(of_node, "qcom,supply-names");
+	if (dt_vreg_total <= 0) {
+		pr_warn("%s: vreg not found. rc=%d\n", __func__,
+					dt_vreg_total);
+		goto end;
+	}
+	mp->num_vreg = dt_vreg_total;
+	mp->vreg_config = devm_kzalloc(dev, sizeof(struct dss_vreg) *
+			dt_vreg_total, GFP_KERNEL);
+	if (!mp->vreg_config)
+		goto end;
+
+	val_array = devm_kzalloc(dev, sizeof(u32) * dt_vreg_total, GFP_KERNEL);
+	if (!val_array)
+		goto end;
+
+	for (i = 0; i < dt_vreg_total; i++) {
+		const char *st = NULL;
+		/* vreg-name */
+		rc = of_property_read_string_index(of_node,
+				"qcom,supply-names", i, &st);
+		if (rc) {
+			pr_warn("%s: error reading name. i=%d, rc=%d\n",
+				__func__, i, rc);
+			goto end;
+		}
+		snprintf(mp->vreg_config[i].vreg_name, 32, "%s", st);
+
+		/* vreg-min-voltage */
+		memset(val_array, 0, sizeof(u32) * dt_vreg_total);
+		rc = of_property_read_u32_array(of_node,
+			"qcom,min-voltage-level", val_array,
+					dt_vreg_total);
+		if (rc) {
+			pr_warn("%s: error read min volt. rc=%d\n",
+						__func__, rc);
+			goto end;
+		}
+		mp->vreg_config[i].min_voltage = val_array[i];
+
+		/* vreg-max-voltage */
+		memset(val_array, 0, sizeof(u32) * dt_vreg_total);
+		rc = of_property_read_u32_array(of_node,
+				"qcom,max-voltage-level", val_array,
+						dt_vreg_total);
+		if (rc) {
+			pr_warn("%s: error read max volt. rc=%d\n",
+					__func__, rc);
+			goto end;
+		}
+		mp->vreg_config[i].max_voltage = val_array[i];
+
+		/* vreg-op-mode */
+		memset(val_array, 0, sizeof(u32) * dt_vreg_total);
+		rc = of_property_read_u32_array(of_node,
+				"qcom,enable-load", val_array,
+					dt_vreg_total);
+		if (rc) {
+			pr_warn("%s: error read enable load. rc=%d\n",
+				__func__, rc);
+			goto end;
+		}
+		mp->vreg_config[i].enable_load = val_array[i];
+
+		memset(val_array, 0, sizeof(u32) * dt_vreg_total);
+		rc = of_property_read_u32_array(of_node,
+			"qcom,disable-load", val_array,
+			dt_vreg_total);
+		if (rc) {
+			pr_warn("%s: error read disable load. rc=%d\n",
+				__func__, rc);
+			goto end;
+		}
+		mp->vreg_config[i].disable_load = val_array[i];
+
+		pr_debug("%s: %s min=%d, max=%d, enable=%d disable=%d\n",
+			__func__,
+			mp->vreg_config[i].vreg_name,
+			mp->vreg_config[i].min_voltage,
+			mp->vreg_config[i].max_voltage,
+			mp->vreg_config[i].enable_load,
+			mp->vreg_config[i].disable_load);
+	}
+
+	devm_kfree(dev, val_array);
+	return;
+
+end:
+	if (mp->vreg_config) {
+		devm_kfree(dev, mp->vreg_config);
+		mp->vreg_config = NULL;
+	}
+	mp->num_vreg = 0;
+
+	if (val_array)
+		devm_kfree(dev, val_array);
+}
+
 static int adv7533_parse_dt(struct device *dev,
-	struct adv7533_platform_data *pdata)
+	struct adv7533 *pdata)
 {
 	struct device_node *np = dev->of_node;
 	u32 temp_val = 0;
@@ -463,6 +577,8 @@ static int adv7533_parse_dt(struct device *dev,
 
 	pdata->audio = of_property_read_bool(np, "adi,enable-audio");
 
+	adv7533_parse_vreg_dt(dev, &pdata->power_data);
+
 	/* Get pinctrl if target uses pinctrl */
 	pdata->ts_pinctrl = devm_pinctrl_get(dev);
 	if (IS_ERR_OR_NULL(pdata->ts_pinctrl)) {
@@ -506,8 +622,7 @@ end:
 	return ret;
 }
 
-static int adv7533_gpio_configure(struct adv7533_platform_data *pdata,
-	bool on)
+static int adv7533_gpio_configure(struct adv7533 *pdata, bool on)
 {
 	int ret = 0;
 
@@ -533,6 +648,24 @@ static int adv7533_gpio_configure(struct adv7533_platform_data *pdata,
 			goto err_none;
 		}
 
+		if (gpio_is_valid(pdata->hpd_irq_gpio)) {
+			ret = gpio_request(pdata->hpd_irq_gpio,
+				"adv7533_hpd_irq_gpio");
+			if (ret) {
+				pr_err("unable to request gpio [%d]\n",
+					pdata->hpd_irq_gpio);
+				goto err_irq_gpio;
+			}
+			ret = gpio_direction_input(pdata->hpd_irq_gpio);
+			if (ret) {
+				pr_err("unable to set dir for gpio[%d]\n",
+					pdata->hpd_irq_gpio);
+				goto err_hpd_irq_gpio;
+			}
+		} else {
+			pr_warn("hpd irq gpio not provided\n");
+		}
+
 		if (gpio_is_valid(pdata->switch_gpio)) {
 			ret = gpio_request(pdata->switch_gpio,
 				"adv7533_switch_gpio");
@@ -554,7 +687,7 @@ static int adv7533_gpio_configure(struct adv7533_platform_data *pdata,
 			msleep(ADV7533_RESET_DELAY);
 		}
 
-		 goto err_none;
+		return 0;
 	} else {
 		if (gpio_is_valid(pdata->irq_gpio))
 			gpio_free(pdata->irq_gpio);
@@ -563,7 +696,7 @@ static int adv7533_gpio_configure(struct adv7533_platform_data *pdata,
 		if (gpio_is_valid(pdata->switch_gpio))
 			gpio_free(pdata->switch_gpio);
 
-		goto err_none;
+		return 0;
 	}
 
 err_switch_gpio:
@@ -579,121 +712,505 @@ err_none:
 	return ret;
 }
 
-u32 adv7533_read_edid(struct adv7533_platform_data *pdata,
-	u32 size, char *edid_buf)
+static void adv7533_notify_clients(struct msm_dba_device_info *dev,
+		enum msm_dba_callback_event event)
 {
-	u32 ret = 0, ndx;
-	u8 edid_addr;
-	u32 read_size = size / 2;
+	struct msm_dba_client_info *c;
+	struct list_head *pos = NULL;
 
-	if (!edid_buf)
+	if (!dev) {
+		pr_err("%s: invalid input\n", __func__);
+		return;
+	}
+
+	list_for_each(pos, &dev->client_list) {
+		c = list_entry(pos, struct msm_dba_client_info, list);
+
+		pr_debug("%s: notifying event %d to client %s\n", __func__,
+			event, c->client_name);
+
+		if (c && c->cb)
+			c->cb(c->cb_data, event);
+	}
+}
+
+u32 adv7533_read_edid(struct adv7533 *pdata, u32 size, char *edid_buf)
+{
+	u32 ret = 0, read_size = size / 2;
+	u8 edid_addr;
+	int ndx;
+
+	if (!pdata || !edid_buf)
 		return 0;
 
 	pr_debug("%s: size %d\n", __func__, size);
 
-	ret = adv7533_read(pdata->main_i2c_addr, 0x43, &edid_addr, 1);
-	if (ret) {
-		pr_err("%s: Error reading edid addr\n", __func__);
-		goto end;
-	}
+	adv7533_read(pdata, I2C_ADDR_MAIN, 0x43, &edid_addr, 1);
 
 	pr_debug("%s: edid address 0x%x\n", __func__, edid_addr);
 
-	ret = adv7533_read(edid_addr >> 1, 0x00, edid_buf, read_size);
-	if (ret) {
-		pr_err("%s: Error reading edid 0\n", __func__);
-		goto end;
-	}
+	adv7533_read(pdata, edid_addr >> 1, 0x00, edid_buf, read_size);
 
-	ret = adv7533_read(edid_addr >> 1, read_size,
+	adv7533_read(pdata, edid_addr >> 1, read_size,
 		edid_buf + read_size, read_size);
-	if (ret) {
-		pr_err("%s: Error reading edid 1\n", __func__);
-		goto end;
-	}
 
 	for (ndx = 0; ndx < size; ndx += 4)
-		pr_info("%s: EDID[%02x-%02x] %02x %02x %02x %02x\n",
+		pr_debug("%s: EDID[%02x-%02x] %02x %02x %02x %02x\n",
 			__func__, ndx, ndx + 3,
 			edid_buf[ndx + 0], edid_buf[ndx + 1],
 			edid_buf[ndx + 2], edid_buf[ndx + 3]);
+
+	return ret;
+}
+
+static int adv7533_cec_prepare_msg(struct adv7533 *pdata, u8 *msg, u32 size)
+{
+	int i, ret = -EINVAL;
+	int op_sz;
+
+	if (!pdata || !msg) {
+		pr_err("%s: invalid input\n", __func__);
+		goto end;
+	}
+
+	if (size <= 0 || size > CEC_MSG_SIZE) {
+		pr_err("%s: ERROR: invalid msg size\n", __func__);
+		goto end;
+	}
+
+	/* operand size = total size - header size - opcode size */
+	op_sz = size - 2;
+
+	/* write header */
+	adv7533_write(pdata, I2C_ADDR_CEC_DSI, 0x70, msg[0]);
+
+	/* write opcode */
+	adv7533_write(pdata, I2C_ADDR_CEC_DSI, 0x71, msg[1]);
+
+	/* write operands */
+	for (i = 0; i < op_sz && i < MAX_OPERAND_SIZE; i++) {
+		pr_debug("%s: writing operands\n", __func__);
+		adv7533_write(pdata, I2C_ADDR_CEC_DSI, 0x72 + i, msg[i + 2]);
+	}
+
+	adv7533_write(pdata, I2C_ADDR_CEC_DSI, 0x80, size);
+
+end:
+	return ret;
+}
+
+static int adv7533_rd_cec_msg(struct adv7533 *pdata, u8 *cec_buf, int msg_num)
+{
+	int ret = -EINVAL;
+	u8 reg = 0;
+
+	if (!pdata || !cec_buf) {
+		pr_err("%s: Invalid input\n", __func__);
+		goto end;
+	}
+
+	if (msg_num == ADV7533_CEC_BUF1)
+		reg = 0x85;
+	else if (msg_num == ADV7533_CEC_BUF2)
+		reg = 0x97;
+	else if (msg_num == ADV7533_CEC_BUF3)
+		reg = 0xA8;
+	else
+		pr_err("%s: Invalid msg_num %d\n", __func__, msg_num);
+
+	if (!reg)
+		goto end;
+
+	adv7533_read(pdata, I2C_ADDR_CEC_DSI, reg, cec_buf, CEC_MSG_SIZE);
+end:
+	return ret;
+}
+
+static void adv7533_handle_hdcp_intr(struct adv7533 *pdata, u8 hdcp_status)
+{
+	u8 ddc_status = 0;
+
+	if (!pdata) {
+		pr_err("%s: Invalid input\n", __func__);
+		goto end;
+	}
+
+	/* HDCP ready for read */
+	if (hdcp_status & BIT(6))
+		pr_debug("%s: BKSV FLAG\n", __func__);
+
+	/* check for HDCP error */
+	if (hdcp_status & BIT(7)) {
+		pr_err("%s: HDCP ERROR\n", __func__);
+
+		/* get error details */
+		adv7533_read(pdata, I2C_ADDR_MAIN, 0xC8, &ddc_status, 1);
+
+		switch (ddc_status & 0xF0 >> 4) {
+		case 0:
+			pr_debug("%s: DDC: NO ERROR\n", __func__);
+			break;
+		case 1:
+			pr_err("%s: DDC: BAD RX BKSV\n", __func__);
+			break;
+		case 2:
+			pr_err("%s: DDC: Ri MISMATCH\n", __func__);
+			break;
+		case 3:
+			pr_err("%s: DDC: Pj MISMATCH\n", __func__);
+			break;
+		case 4:
+			pr_err("%s: DDC: I2C ERROR\n", __func__);
+			break;
+		case 5:
+			pr_err("%s: DDC: TIMED OUT DS DONE\n", __func__);
+			break;
+		case 6:
+			pr_err("%s: DDC: MAX CAS EXC\n", __func__);
+			break;
+		default:
+			pr_debug("%s: DDC: UNKNOWN ERROR\n", __func__);
+		}
+	}
+end:
+	return;
+}
+
+static void adv7533_handle_cec_intr(struct adv7533 *pdata, u8 cec_status)
+{
+	u8 cec_int_clear = 0x08;
+	bool cec_rx_intr = false;
+	u8 cec_rx_ready;
+	u8 cec_rx_timestamp;
+
+	if (!pdata) {
+		pr_err("%s: Invalid input\n", __func__);
+		goto end;
+	}
+
+	if (cec_status & 0x07) {
+		cec_rx_intr = true;
+		adv7533_read(pdata, I2C_ADDR_CEC_DSI, 0xBA, &cec_int_clear, 1);
+	}
+
+	if (cec_status & BIT(5))
+		pr_debug("%s: CEC TX READY\n", __func__);
+
+	if (cec_status & BIT(4))
+		pr_debug("%s: CEC TX Arbitration lost\n", __func__);
+
+	if (cec_status & BIT(3))
+		pr_debug("%s: CEC TX retry timout\n", __func__);
+
+	if (!cec_rx_intr)
+		return;
+
+
+	adv7533_read(pdata, I2C_ADDR_CEC_DSI, 0xB9, &cec_rx_ready, 1);
+
+	adv7533_read(pdata, I2C_ADDR_CEC_DSI, 0x96, &cec_rx_timestamp, 1);
+
+	if (cec_rx_ready & BIT(0)) {
+		pr_debug("%s: CEC Rx buffer 1 ready\n", __func__);
+		adv7533_rd_cec_msg(pdata,
+			pdata->cec_msg[ADV7533_CEC_BUF1].buf,
+			ADV7533_CEC_BUF1);
+
+		pdata->cec_msg[ADV7533_CEC_BUF1].pending = true;
+
+		pdata->cec_msg[ADV7533_CEC_BUF1].timestamp =
+			cec_rx_timestamp & (BIT(0) | BIT(1));
+
+		adv7533_notify_clients(&pdata->dev_info,
+			MSM_DBA_CB_CEC_READ_PENDING);
+	}
+
+	if (cec_rx_ready & BIT(1)) {
+		pr_debug("%s: CEC Rx buffer 2 ready\n", __func__);
+		adv7533_rd_cec_msg(pdata,
+			pdata->cec_msg[ADV7533_CEC_BUF2].buf,
+			ADV7533_CEC_BUF2);
+
+		pdata->cec_msg[ADV7533_CEC_BUF2].pending = true;
+
+		pdata->cec_msg[ADV7533_CEC_BUF2].timestamp =
+			cec_rx_timestamp & (BIT(2) | BIT(3));
+
+		adv7533_notify_clients(&pdata->dev_info,
+			MSM_DBA_CB_CEC_READ_PENDING);
+	}
+
+	if (cec_rx_ready & BIT(2)) {
+		pr_debug("%s: CEC Rx buffer 3 ready\n", __func__);
+		adv7533_rd_cec_msg(pdata,
+			pdata->cec_msg[ADV7533_CEC_BUF3].buf,
+			ADV7533_CEC_BUF3);
+
+		pdata->cec_msg[ADV7533_CEC_BUF3].pending = true;
+
+		pdata->cec_msg[ADV7533_CEC_BUF3].timestamp =
+			cec_rx_timestamp & (BIT(4) | BIT(5));
+
+		adv7533_notify_clients(&pdata->dev_info,
+			MSM_DBA_CB_CEC_READ_PENDING);
+	}
+
+	adv7533_write(pdata, I2C_ADDR_CEC_DSI, 0xBA,
+		cec_int_clear | (cec_status & 0x07));
+
+	adv7533_write(pdata, I2C_ADDR_CEC_DSI, 0xBA, cec_int_clear & ~0x07);
+
+end:
+	return;
+}
+
+static int adv7533_edid_read_init(struct adv7533 *pdata)
+{
+	int ret = -EINVAL;
+
+	if (!pdata) {
+		pr_err("%s: invalid pdata\n", __func__);
+		goto end;
+	}
+
+	/* initiate edid read in adv7533 */
+	adv7533_write(pdata, I2C_ADDR_MAIN, 0x41, 0x10);
+	adv7533_write(pdata, I2C_ADDR_MAIN, 0xC9, 0x13);
+
+end:
+	return ret;
+}
+
+static void *adv7533_handle_hpd_intr(struct adv7533 *pdata)
+{
+	int ret;
+	u8 hpd_state;
+	u8 connected = 0, disconnected = 0;
+
+	if (!pdata) {
+		pr_err("%s: invalid pdata\n", __func__);
+		goto end;
+	}
+
+	adv7533_read(pdata, I2C_ADDR_MAIN, 0x42, &hpd_state, 1);
+
+	connected = (hpd_state & BIT(5)) && (hpd_state & BIT(6));
+	disconnected = !(hpd_state & (BIT(5) | BIT(6)));
+
+	if (connected) {
+		pr_debug("%s: Rx CONNECTED\n", __func__);
+	} else if (disconnected) {
+		pr_debug("%s: Rx DISCONNECTED\n", __func__);
+
+		adv7533_notify_clients(&pdata->dev_info,
+			MSM_DBA_CB_HPD_DISCONNECT);
+	} else {
+		pr_debug("%s: HPD Intermediate state\n", __func__);
+	}
+
+	ret = connected ? 1 : 0;
+end:
+	return ERR_PTR(ret);
+}
+
+static int adv7533_enable_interrupts(struct adv7533 *pdata, int interrupts)
+{
+	int ret = 0;
+	u8 reg_val, init_reg_val;
+
+	if (!pdata) {
+		pr_err("%s: invalid input\n", __func__);
+		goto end;
+	}
+
+	adv7533_read(pdata, I2C_ADDR_MAIN, 0x94, &reg_val, 1);
+
+	init_reg_val = reg_val;
+
+	if (interrupts & CFG_HPD_INTERRUPTS)
+		reg_val |= HPD_INTERRUPTS;
+
+	if (interrupts & CFG_EDID_INTERRUPTS)
+		reg_val |= EDID_INTERRUPTS;
+
+	if (interrupts & CFG_HDCP_INTERRUPTS)
+		reg_val |= HDCP_INTERRUPTS1;
+
+	if (reg_val != init_reg_val) {
+		pr_debug("%s: enabling 0x94 interrupts\n", __func__);
+		adv7533_write(pdata, I2C_ADDR_MAIN, 0x94, reg_val);
+	}
+
+	adv7533_read(pdata, I2C_ADDR_MAIN, 0x95, &reg_val, 1);
+
+	init_reg_val = reg_val;
+
+	if (interrupts & CFG_HDCP_INTERRUPTS)
+		reg_val |= HDCP_INTERRUPTS2;
+
+	if (interrupts & CFG_CEC_INTERRUPTS)
+		reg_val |= CEC_INTERRUPTS;
+
+	if (reg_val != init_reg_val) {
+		pr_debug("%s: enabling 0x95 interrupts\n", __func__);
+		adv7533_write(pdata, I2C_ADDR_MAIN, 0x95, reg_val);
+	}
+end:
+	return ret;
+}
+
+static int adv7533_disable_interrupts(struct adv7533 *pdata, int interrupts)
+{
+	int ret = 0;
+	u8 reg_val, init_reg_val;
+
+	if (!pdata) {
+		pr_err("%s: invalid input\n", __func__);
+		goto end;
+	}
+
+	adv7533_read(pdata, I2C_ADDR_MAIN, 0x94, &reg_val, 1);
+
+	init_reg_val = reg_val;
+
+	if (interrupts & CFG_HPD_INTERRUPTS)
+		reg_val &= ~HPD_INTERRUPTS;
+
+	if (interrupts & CFG_EDID_INTERRUPTS)
+		reg_val &= ~EDID_INTERRUPTS;
+
+	if (interrupts & CFG_HDCP_INTERRUPTS)
+		reg_val &= ~HDCP_INTERRUPTS1;
+
+	if (reg_val != init_reg_val) {
+		pr_debug("%s: disabling 0x94 interrupts\n", __func__);
+		adv7533_write(pdata, I2C_ADDR_MAIN, 0x94, reg_val);
+	}
+
+	adv7533_read(pdata, I2C_ADDR_MAIN, 0x95, &reg_val, 1);
+
+	init_reg_val = reg_val;
+
+	if (interrupts & CFG_HDCP_INTERRUPTS)
+		reg_val &= ~HDCP_INTERRUPTS2;
+
+	if (interrupts & CFG_CEC_INTERRUPTS)
+		reg_val &= ~CEC_INTERRUPTS;
+
+	if (reg_val != init_reg_val) {
+		pr_debug("%s: disabling 0x95 interrupts\n", __func__);
+		adv7533_write(pdata, I2C_ADDR_MAIN, 0x95, reg_val);
+	}
 end:
 	return ret;
 }
 
 static void adv7533_intr_work(struct work_struct *work)
 {
-	u8 int_status;
-	u8 int_state;
 	int ret;
-	struct adv7533_platform_data *pdata;
+	u8 int_status  = 0xFF;
+	u8 hdcp_cec_status = 0xFF;
+	u32 interrupts = 0;
+	int connected = false;
+	struct adv7533 *pdata;
 	struct delayed_work *dw = to_delayed_work(work);
 
-	pdata = container_of(dw, struct adv7533_platform_data,
+	pdata = container_of(dw, struct adv7533,
 			adv7533_intr_work_id);
 	if (!pdata) {
 		pr_err("%s: invalid input\n", __func__);
-		return;
+		goto reset;
 	}
 
 	/* READ Interrupt registers */
-	adv7533_read_byte(pdata->main_i2c_addr, 0x96, &int_status);
-	adv7533_read_byte(pdata->main_i2c_addr, 0x42, &int_state);
+	adv7533_read(pdata, I2C_ADDR_MAIN, 0x96, &int_status, 1);
+	adv7533_read(pdata, I2C_ADDR_MAIN, 0x97, &hdcp_cec_status, 1);
 
-	if (int_status & BIT(6)) {
-		if (int_state & BIT(5)) {
-			pr_info("%s: Rx SENSE CABLE CONNECTED\n", __func__);
+	if (int_status & (BIT(6) | BIT(7))) {
+		void *ptr_val = adv7533_handle_hpd_intr(pdata);
 
-			/* initiate edid read in adv7533 */
-			ret = adv7533_write_byte(pdata->main_i2c_addr,
-				0xC9, 0x13);
-			if (ret) {
-				pr_err("%s: Failed: edid read adv %d\n",
-					__func__, ret);
-				pdata->client_cb(pdata->client_cb_data,
-					MSM_DBA_CB_HPD_CONNECT);
-			}
-
-		} else {
-			pr_info("%s: NO Rx SENSE CABLE DISCONNECTED\n",
-				__func__);
-			pdata->client_cb(pdata->client_cb_data,
-				MSM_DBA_CB_HPD_DISCONNECT);
+		ret = PTR_ERR(ptr_val);
+		if (IS_ERR(ptr_val)) {
+			pr_err("%s: error in hpd handing: %d\n",
+				__func__, ret);
+			goto reset;
 		}
+		connected = ret;
 	}
 
 	/* EDID ready for read */
-	if (int_status & BIT(2)) {
-		pr_info("%s: EDID READY\n", __func__);
+	if ((int_status & BIT(2)) && pdata->is_power_on) {
+		pr_debug("%s: EDID READY\n", __func__);
 
 		ret = adv7533_read_edid(pdata, sizeof(pdata->edid_buf),
 			pdata->edid_buf);
 		if (ret)
 			pr_err("%s: edid read failed\n", __func__);
 
-		pdata->client_cb(pdata->client_cb_data,
+		adv7533_notify_clients(&pdata->dev_info,
 			MSM_DBA_CB_HPD_CONNECT);
 	}
 
-	/* Clear interrupts */
-	ret = adv7533_write_byte(pdata->main_i2c_addr, 0x96, int_status);
-	if (ret)
-		pr_err("%s: Failed: clear interrupts %d\n", __func__, ret);
+	if (pdata->hdcp_enabled)
+		adv7533_handle_hdcp_intr(pdata, hdcp_cec_status);
 
-	ret = adv7533_write_regs(pdata, irq_config, ARRAY_SIZE(irq_config));
-	if (ret)
-		pr_err("%s: Failed: irq config %d\n", __func__, ret);
+	if (pdata->cec_enabled)
+		adv7533_handle_cec_intr(pdata, hdcp_cec_status);
+reset:
+	/* Clear HPD/EDID interrupts */
+	adv7533_write(pdata, I2C_ADDR_MAIN, 0x96, int_status);
+
+	/* Clear HDCP/CEC interrupts */
+	adv7533_write(pdata, I2C_ADDR_MAIN, 0x97, hdcp_cec_status);
+
+	/* Re-enable HPD interrupts */
+	interrupts |= CFG_HPD_INTERRUPTS;
+
+	/* Re-enable EDID interrupts */
+	interrupts |= CFG_EDID_INTERRUPTS;
+
+	/* Re-enable HDCP interrupts */
+	if (pdata->hdcp_enabled)
+		interrupts |= CFG_HDCP_INTERRUPTS;
+
+	/* Re-enable CEC interrupts */
+	if (pdata->cec_enabled)
+		interrupts |= CFG_CEC_INTERRUPTS;
+
+	if (adv7533_enable_interrupts(pdata, interrupts))
+		pr_err("%s: err enabling interrupts\n", __func__);
+
+	/* initialize EDID read after cable connected */
+	if (connected)
+		adv7533_edid_read_init(pdata);
 }
 
 static irqreturn_t adv7533_irq(int irq, void *data)
 {
-	int ret;
+	struct adv7533 *pdata = data;
+	u32 interrupts = 0;
 
-	/* disable interrupts */
-	ret = adv7533_write_byte(pdata->main_i2c_addr, 0x94, 0x00);
-	if (ret)
-		pr_err("%s: Failed: disable interrupts %d\n",
-			__func__, ret);
+	if (!pdata) {
+		pr_err("%s: invalid input\n", __func__);
+		return IRQ_HANDLED;
+	}
+
+	/* disable HPD interrupts */
+	interrupts |= CFG_HPD_INTERRUPTS;
+
+	/* disable EDID interrupts */
+	interrupts |= CFG_EDID_INTERRUPTS;
+
+	/* disable HDCP interrupts */
+	if (pdata->hdcp_enabled)
+		interrupts |= CFG_HDCP_INTERRUPTS;
+
+	/* disable CEC interrupts */
+	if (pdata->cec_enabled)
+		interrupts |= CFG_CEC_INTERRUPTS;
+
+	if (adv7533_disable_interrupts(pdata, interrupts))
+		pr_err("%s: err disabling interrupts\n", __func__);
 
 	queue_delayed_work(pdata->workq, &pdata->adv7533_intr_work_id, 0);
 
@@ -705,9 +1222,9 @@ static struct i2c_device_id adv7533_id[] = {
 	{}
 };
 
-static struct adv7533_platform_data *adv7533_get_platform_data(void *client)
+static struct adv7533 *adv7533_get_platform_data(void *client)
 {
-	struct adv7533_platform_data *pdata = NULL;
+	struct adv7533 *pdata = NULL;
 	struct msm_dba_device_info *dev;
 	struct msm_dba_client_info *cinfo =
 		(struct msm_dba_client_info *)client;
@@ -723,7 +1240,7 @@ static struct adv7533_platform_data *adv7533_get_platform_data(void *client)
 		goto end;
 	}
 
-	pdata = container_of(dev, struct adv7533_platform_data, dev_info);
+	pdata = container_of(dev, struct adv7533, dev_info);
 	if (!pdata)
 		pr_err("%s: invalid platform data\n", __func__);
 
@@ -731,47 +1248,115 @@ end:
 	return pdata;
 }
 
-/* Device Operations */
-static int adv7533_power_on(void *client, bool on, u32 flags)
+static int adv7533_cec_enable(void *client, bool cec_on, u32 flags)
 {
-	int ret = 0;
-	struct adv7533_platform_data *pdata =
-		adv7533_get_platform_data(client);
+	int ret = -EINVAL;
+	struct adv7533 *pdata = adv7533_get_platform_data(client);
 
 	if (!pdata) {
 		pr_err("%s: invalid platform data\n", __func__);
 		goto end;
 	}
 
-	ret = adv7533_write_regs(pdata, adv7533_init_setup,
-		ARRAY_SIZE(adv7533_init_setup));
-	if (ret) {
-		pr_err("%s: Failed to write common config\n",
-			__func__);
-		goto end;
+	if (cec_on) {
+		adv7533_write_array(pdata, adv7533_cec_en,
+					sizeof(adv7533_cec_en));
+		adv7533_write_array(pdata, adv7533_cec_tg_init,
+					sizeof(adv7533_cec_tg_init));
+		adv7533_write_array(pdata, adv7533_cec_power,
+					sizeof(adv7533_cec_power));
+
+		pdata->cec_enabled = true;
+
+		ret = adv7533_enable_interrupts(pdata, CFG_CEC_INTERRUPTS);
+
+	} else {
+		pdata->cec_enabled = false;
+		ret = adv7533_disable_interrupts(pdata, CFG_CEC_INTERRUPTS);
 	}
-
-	ret = adv7533_write_regs(pdata, irq_config, ARRAY_SIZE(irq_config));
-	if (ret) {
-		pr_err("%s: Failed: irq config %d\n", __func__, ret);
-		goto end;
-	}
-
-	if (pdata->workq)
-		queue_delayed_work(pdata->workq, &pdata->adv7533_intr_work_id,
-					HZ/2);
-
 end:
 	return ret;
 }
 
-static void adv7533_video_timing_setup(struct adv7533_platform_data *pdata,
+static int adv7533_check_hpd(void *client, u32 flags)
+{
+	struct adv7533 *pdata = adv7533_get_platform_data(client);
+	u8 reg_val = 0;
+	u8 intr_status;
+	int connected = 0;
+
+	if (!pdata) {
+		pr_err("%s: invalid platform data\n", __func__);
+		return -EINVAL;
+	}
+
+	/* Check if cable is already connected.
+	 * Since adv7533_irq line is edge triggered,
+	 * if cable is already connected by this time
+	 * it won't trigger HPD interrupt.
+	 */
+	mutex_lock(&pdata->ops_mutex);
+	adv7533_read(pdata, I2C_ADDR_MAIN, 0x42, &reg_val, 1);
+
+	connected  = (reg_val & BIT(6));
+	if (connected) {
+		pr_debug("%s: cable is connected\n", __func__);
+		/* Clear the interrupts before initiating EDID read */
+		adv7533_read(pdata, I2C_ADDR_MAIN, 0x96, &intr_status, 1);
+		adv7533_write(pdata, I2C_ADDR_MAIN, 0x96, intr_status);
+		adv7533_enable_interrupts(pdata, (CFG_EDID_INTERRUPTS |
+				CFG_HPD_INTERRUPTS));
+
+		adv7533_edid_read_init(pdata);
+	}
+	mutex_unlock(&pdata->ops_mutex);
+
+	return connected;
+}
+
+/* Device Operations */
+static int adv7533_power_on(void *client, bool on, u32 flags)
+{
+	int ret = -EINVAL;
+	struct adv7533 *pdata = adv7533_get_platform_data(client);
+
+	if (!pdata) {
+		pr_err("%s: invalid platform data\n", __func__);
+		return ret;
+	}
+
+	pr_debug("%s: %d\n", __func__, on);
+	mutex_lock(&pdata->ops_mutex);
+
+	if (on && !pdata->is_power_on) {
+		adv7533_write_array(pdata, adv7533_init_setup,
+					sizeof(adv7533_init_setup));
+
+		ret = adv7533_enable_interrupts(pdata, CFG_HPD_INTERRUPTS);
+		if (ret) {
+			pr_err("%s: Failed: enable HPD intr %d\n",
+				__func__, ret);
+			goto end;
+		}
+		pdata->is_power_on = true;
+	} else if (!on) {
+		/* power down hdmi */
+		adv7533_write(pdata, I2C_ADDR_MAIN, 0x41, 0x50);
+		pdata->is_power_on = false;
+
+		adv7533_notify_clients(&pdata->dev_info,
+			MSM_DBA_CB_HPD_DISCONNECT);
+	}
+end:
+	mutex_unlock(&pdata->ops_mutex);
+	return ret;
+}
+
+static void adv7533_video_setup(struct adv7533 *pdata,
 	struct msm_dba_video_cfg *cfg)
 {
 	u32 h_total, hpw, hfp, hbp;
 	u32 v_total, vpw, vfp, vbp;
-	u32 num_lanes;
-	u8 addr = 0;
 
 	if (!pdata || !cfg) {
 		pr_err("%s: invalid input\n", __func__);
@@ -790,8 +1375,6 @@ static void adv7533_video_timing_setup(struct adv7533_platform_data *pdata,
 	vpw = cfg->v_pulse_width;
 	vfp = cfg->v_front_porch;
 	vbp = cfg->v_back_porch;
-	addr = pdata->cec_dsi_i2c_addr;
-	num_lanes = cfg->num_of_input_lanes;
 
 	pr_debug("h_total 0x%x, h_active 0x%x, hfp 0x%d, hpw 0x%x, hbp 0x%x\n",
 		h_total, cfg->h_active, cfg->h_front_porch,
@@ -801,68 +1384,325 @@ static void adv7533_video_timing_setup(struct adv7533_platform_data *pdata,
 		v_total, cfg->v_active, cfg->v_front_porch,
 		cfg->v_pulse_width, cfg->v_back_porch);
 
-	/* lane setup */
-	adv7533_write_byte(addr, 0x1C, ((num_lanes & 0xF) << 4));
 
 	/* h_width */
-	adv7533_write_byte(addr, 0x28, ((h_total & 0xFF0) >> 4));
-	adv7533_write_byte(addr, 0x29, ((h_total & 0xF) << 4));
+	adv7533_write(pdata, I2C_ADDR_CEC_DSI, 0x28, ((h_total & 0xFF0) >> 4));
+	adv7533_write(pdata, I2C_ADDR_CEC_DSI, 0x29, ((h_total & 0xF) << 4));
 
 	/* hsync_width */
-	adv7533_write_byte(addr, 0x2A, ((hpw & 0xFF0) >> 4));
-	adv7533_write_byte(addr, 0x2B, ((hpw & 0xF) << 4));
+	adv7533_write(pdata, I2C_ADDR_CEC_DSI, 0x2A, ((hpw & 0xFF0) >> 4));
+	adv7533_write(pdata, I2C_ADDR_CEC_DSI, 0x2B, ((hpw & 0xF) << 4));
 
 	/* hfp */
-	adv7533_write_byte(addr, 0x2C, ((hfp & 0xFF0) >> 4));
-	adv7533_write_byte(addr, 0x2D, ((hfp & 0xF) << 4));
+	adv7533_write(pdata, I2C_ADDR_CEC_DSI, 0x2C, ((hfp & 0xFF0) >> 4));
+	adv7533_write(pdata, I2C_ADDR_CEC_DSI, 0x2D, ((hfp & 0xF) << 4));
 
 	/* hbp */
-	adv7533_write_byte(addr, 0x2E, ((hbp & 0xFF0) >> 4));
-	adv7533_write_byte(addr, 0x2F, ((hbp & 0xF) << 4));
+	adv7533_write(pdata, I2C_ADDR_CEC_DSI, 0x2E, ((hbp & 0xFF0) >> 4));
+	adv7533_write(pdata, I2C_ADDR_CEC_DSI, 0x2F, ((hbp & 0xF) << 4));
 
 	/* v_total */
-	adv7533_write_byte(addr, 0x30, ((v_total & 0xFF0) >> 4));
-	adv7533_write_byte(addr, 0x31, ((v_total & 0xF) << 4));
+	adv7533_write(pdata, I2C_ADDR_CEC_DSI, 0x30, ((v_total & 0xFF0) >> 4));
+	adv7533_write(pdata, I2C_ADDR_CEC_DSI, 0x31, ((v_total & 0xF) << 4));
 
 	/* vsync_width */
-	adv7533_write_byte(addr, 0x32, ((vpw & 0xFF0) >> 4));
-	adv7533_write_byte(addr, 0x33, ((vpw & 0xF) << 4));
+	adv7533_write(pdata, I2C_ADDR_CEC_DSI, 0x32, ((vpw & 0xFF0) >> 4));
+	adv7533_write(pdata, I2C_ADDR_CEC_DSI, 0x33, ((vpw & 0xF) << 4));
 
 	/* vfp */
-	adv7533_write_byte(addr, 0x34, ((vfp & 0xFF0) >> 4));
-	adv7533_write_byte(addr, 0x35, ((vfp & 0xF) << 4));
+	adv7533_write(pdata, I2C_ADDR_CEC_DSI, 0x34, ((vfp & 0xFF0) >> 4));
+	adv7533_write(pdata, I2C_ADDR_CEC_DSI, 0x35, ((vfp & 0xF) << 4));
 
 	/* vbp */
-	adv7533_write_byte(addr, 0x36, ((vbp & 0xFF0) >> 4));
-	adv7533_write_byte(addr, 0x37, ((vbp & 0xF) << 4));
+	adv7533_write(pdata, I2C_ADDR_CEC_DSI, 0x36, ((vbp & 0xFF0) >> 4));
+	adv7533_write(pdata, I2C_ADDR_CEC_DSI, 0x37, ((vbp & 0xF) << 4));
 }
 
 static int adv7533_video_on(void *client, bool on,
 	struct msm_dba_video_cfg *cfg, u32 flags)
 {
-	int ret = 0;
-	struct adv7533_platform_data *pdata =
+	int ret = -EINVAL;
+	u8 lanes;
+	u8 reg_val = 0;
+	struct adv7533 *pdata = adv7533_get_platform_data(client);
+
+	if (!pdata || !cfg) {
+		pr_err("%s: invalid platform data\n", __func__);
+		return ret;
+	}
+
+	mutex_lock(&pdata->ops_mutex);
+
+	/* DSI lane configuration */
+	lanes = (cfg->num_of_input_lanes << 4);
+	adv7533_write(pdata, I2C_ADDR_CEC_DSI, 0x1C, lanes);
+
+	adv7533_video_setup(pdata, cfg);
+
+	/* hdmi/dvi mode */
+	if (cfg->hdmi_mode)
+		adv7533_write(pdata, I2C_ADDR_MAIN, 0xAF, 0x06);
+	else
+		adv7533_write(pdata, I2C_ADDR_MAIN, 0xAF, 0x04);
+
+	/* set scan info for AVI Infoframe*/
+	if (cfg->scaninfo) {
+		adv7533_read(pdata, I2C_ADDR_MAIN, 0x55, &reg_val, 1);
+		reg_val |= cfg->scaninfo & (BIT(1) | BIT(0));
+		adv7533_write(pdata, I2C_ADDR_MAIN, 0x55, reg_val);
+	}
+
+	/*
+	 * aspect ratio and sync polarity set up.
+	 * Currently adv only supports 16:9 or 4:3 aspect ratio
+	 * configuration.
+	 */
+	if (cfg->h_active * 3 - cfg->v_active * 4) {
+		adv7533_write(pdata, I2C_ADDR_MAIN, 0x17, 0x02);
+		adv7533_write(pdata, I2C_ADDR_MAIN, 0x56, 0x28);
+	} else {
+		/* 4:3 aspect ratio */
+		adv7533_write(pdata, I2C_ADDR_MAIN, 0x17, 0x00);
+		adv7533_write(pdata, I2C_ADDR_MAIN, 0x56, 0x18);
+	}
+
+	adv7533_write_array(pdata, adv7533_video_en,
+				sizeof(adv7533_video_en));
+
+	mutex_unlock(&pdata->ops_mutex);
+	return ret;
+}
+
+static int adv7533_hdcp_enable(void *client, bool hdcp_on,
+	bool enc_on, u32 flags)
+{
+	int ret = -EINVAL;
+	u8 reg_val;
+	struct adv7533 *pdata =
 		adv7533_get_platform_data(client);
 
 	if (!pdata) {
 		pr_err("%s: invalid platform data\n", __func__);
-		goto end;
+		return ret;
 	}
 
-	adv7533_video_timing_setup(pdata, cfg);
+	mutex_lock(&pdata->ops_mutex);
 
-	ret = adv7533_write_regs(pdata, adv7533_video_setup,
-		ARRAY_SIZE(adv7533_video_setup));
-	if (ret)
-		pr_err("%s: Failed: video setup\n", __func__);
-end:
+	adv7533_read(pdata, I2C_ADDR_MAIN, 0xAF, &reg_val, 1);
+
+	if (hdcp_on)
+		reg_val |= BIT(7);
+	else
+		reg_val &= ~BIT(7);
+
+	if (enc_on)
+		reg_val |= BIT(4);
+	else
+		reg_val &= ~BIT(4);
+
+	adv7533_write(pdata, I2C_ADDR_MAIN, 0xAF, reg_val);
+
+	pdata->hdcp_enabled = hdcp_on;
+
+	if (pdata->hdcp_enabled)
+		adv7533_enable_interrupts(pdata, CFG_HDCP_INTERRUPTS);
+	else
+		adv7533_disable_interrupts(pdata, CFG_HDCP_INTERRUPTS);
+
+	mutex_unlock(&pdata->ops_mutex);
 	return ret;
 }
 
-static int adv7533_get_edid_size(void *client,
-	u32 *size, u32 flags)
+static int adv7533_configure_audio(void *client,
+	struct msm_dba_audio_cfg *cfg, u32 flags)
+{
+	int ret = -EINVAL;
+	int sampling_rate = 0;
+	struct adv7533 *pdata =
+		adv7533_get_platform_data(client);
+	struct adv7533_reg_cfg reg_cfg[] = {
+		{I2C_ADDR_MAIN, 0x12, 0x00, 0},
+		{I2C_ADDR_MAIN, 0x13, 0x00, 0},
+		{I2C_ADDR_MAIN, 0x14, 0x00, 0},
+		{I2C_ADDR_MAIN, 0x15, 0x00, 0},
+		{I2C_ADDR_MAIN, 0x0A, 0x00, 0},
+		{I2C_ADDR_MAIN, 0x0C, 0x00, 0},
+		{I2C_ADDR_MAIN, 0x0D, 0x00, 0},
+		{I2C_ADDR_MAIN, 0x03, 0x00, 0},
+		{I2C_ADDR_MAIN, 0x02, 0x00, 0},
+		{I2C_ADDR_MAIN, 0x01, 0x00, 0},
+		{I2C_ADDR_MAIN, 0x09, 0x00, 0},
+		{I2C_ADDR_MAIN, 0x08, 0x00, 0},
+		{I2C_ADDR_MAIN, 0x07, 0x00, 0},
+		{I2C_ADDR_MAIN, 0x73, 0x00, 0},
+		{I2C_ADDR_MAIN, 0x76, 0x00, 0},
+	};
+
+	if (!pdata || !cfg) {
+		pr_err("%s: invalid data\n", __func__);
+		return ret;
+	}
+
+	mutex_lock(&pdata->ops_mutex);
+
+	if (cfg->copyright == MSM_DBA_AUDIO_COPYRIGHT_NOT_PROTECTED)
+		reg_cfg[0].val |= BIT(5);
+
+	if (cfg->pre_emphasis == MSM_DBA_AUDIO_PRE_EMPHASIS_50_15us)
+		reg_cfg[0].val |= BIT(2);
+
+	if (cfg->clock_accuracy == MSM_DBA_AUDIO_CLOCK_ACCURACY_LVL1)
+		reg_cfg[0].val |= BIT(0);
+	else if (cfg->clock_accuracy == MSM_DBA_AUDIO_CLOCK_ACCURACY_LVL3)
+		reg_cfg[0].val |= BIT(1);
+
+	reg_cfg[1].val = cfg->channel_status_category_code;
+
+	reg_cfg[2].val = (cfg->channel_status_word_length & 0xF) << 0 |
+		(cfg->channel_status_source_number & 0xF) << 4;
+
+	if (cfg->sampling_rate == MSM_DBA_AUDIO_32KHZ)
+		sampling_rate = 0x3;
+	else if (cfg->sampling_rate == MSM_DBA_AUDIO_44P1KHZ)
+		sampling_rate = 0x0;
+	else if (cfg->sampling_rate == MSM_DBA_AUDIO_48KHZ)
+		sampling_rate = 0x2;
+	else if (cfg->sampling_rate == MSM_DBA_AUDIO_88P2KHZ)
+		sampling_rate = 0x8;
+	else if (cfg->sampling_rate == MSM_DBA_AUDIO_96KHZ)
+		sampling_rate = 0xA;
+	else if (cfg->sampling_rate == MSM_DBA_AUDIO_176P4KHZ)
+		sampling_rate = 0xC;
+	else if (cfg->sampling_rate == MSM_DBA_AUDIO_192KHZ)
+		sampling_rate = 0xE;
+
+	reg_cfg[3].val = (sampling_rate & 0xF) << 4;
+
+	if (cfg->mode == MSM_DBA_AUDIO_MODE_MANUAL)
+		reg_cfg[4].val |= BIT(7);
+
+	if (cfg->interface == MSM_DBA_AUDIO_SPDIF_INTERFACE)
+		reg_cfg[4].val |= BIT(4);
+
+	if (cfg->interface == MSM_DBA_AUDIO_I2S_INTERFACE) {
+		/* i2s enable */
+		reg_cfg[5].val |= BIT(2);
+
+		/* audio samp freq select */
+		reg_cfg[5].val |= BIT(7);
+	}
+
+	/* format */
+	reg_cfg[5].val |= cfg->i2s_fmt & 0x3;
+
+	/* channel status override */
+	reg_cfg[5].val |= (cfg->channel_status_source & 0x1) << 6;
+
+	/* sample word lengths, default 24 */
+	reg_cfg[6].val |= 0x18;
+
+	/* endian order of incoming I2S data */
+	if (cfg->word_endianness == MSM_DBA_AUDIO_WORD_LITTLE_ENDIAN)
+		reg_cfg[6].val |= 0x1 << 7;
+
+	/* compressed audio v - bit */
+	reg_cfg[6].val |= (cfg->channel_status_v_bit & 0x1) << 5;
+
+	/* ACR - N */
+	reg_cfg[7].val |= (cfg->n & 0x000FF) >> 0;
+	reg_cfg[8].val |= (cfg->n & 0x0FF00) >> 8;
+	reg_cfg[9].val |= (cfg->n & 0xF0000) >> 16;
+
+	/* ACR - CTS */
+	reg_cfg[10].val |= (cfg->cts & 0x000FF) >> 0;
+	reg_cfg[11].val |= (cfg->cts & 0x0FF00) >> 8;
+	reg_cfg[12].val |= (cfg->cts & 0xF0000) >> 16;
+
+	/* channel count */
+	reg_cfg[13].val |= (cfg->channels & 0x3);
+
+	/* CA */
+	reg_cfg[14].val = cfg->channel_allocation;
+
+	adv7533_write_array(pdata, reg_cfg, sizeof(reg_cfg));
+
+	mutex_unlock(&pdata->ops_mutex);
+	return ret;
+}
+
+static int adv7533_hdmi_cec_write(void *client, u32 size,
+	char *buf, u32 flags)
+{
+	int ret = -EINVAL;
+	struct adv7533 *pdata =
+		adv7533_get_platform_data(client);
+
+	if (!pdata) {
+		pr_err("%s: invalid platform data\n", __func__);
+		return ret;
+	}
+
+	mutex_lock(&pdata->ops_mutex);
+
+	ret = adv7533_cec_prepare_msg(pdata, buf, size);
+	if (ret)
+		goto end;
+
+	/* Enable CEC msg tx with NACK 3 retries */
+	adv7533_write(pdata, I2C_ADDR_CEC_DSI, 0x81, 0x07);
+end:
+	mutex_unlock(&pdata->ops_mutex);
+	return ret;
+}
+
+static int adv7533_hdmi_cec_read(void *client, u32 *size, char *buf, u32 flags)
+{
+	int ret = -EINVAL;
+	int i;
+	struct adv7533 *pdata =
+		adv7533_get_platform_data(client);
+
+	if (!pdata) {
+		pr_err("%s: invalid platform data\n", __func__);
+		return ret;
+	}
+
+	mutex_lock(&pdata->ops_mutex);
+
+	for (i = 0; i < ADV7533_CEC_BUF_MAX; i++) {
+		struct adv7533_cec_msg *msg = &pdata->cec_msg[i];
+
+		if (msg->pending && msg->timestamp) {
+			memcpy(buf, msg->buf, CEC_MSG_SIZE);
+			msg->pending = false;
+			break;
+		}
+	}
+
+	if (i < ADV7533_CEC_BUF_MAX) {
+		*size = CEC_MSG_SIZE;
+		ret = 0;
+	} else {
+		pr_err("%s: no pending cec msg\n", __func__);
+		*size = 0;
+	}
+
+	mutex_unlock(&pdata->ops_mutex);
+	return ret;
+}
+
+static int adv7533_get_edid_size(void *client, u32 *size, u32 flags)
 {
 	int ret = 0;
+	struct adv7533 *pdata =
+		adv7533_get_platform_data(client);
+
+	if (!pdata) {
+		pr_err("%s: invalid platform data\n", __func__);
+		return ret;
+	}
+
+	mutex_lock(&pdata->ops_mutex);
 
 	if (!size) {
 		ret = -EINVAL;
@@ -870,15 +1710,15 @@ static int adv7533_get_edid_size(void *client,
 	}
 
 	*size = EDID_SEG_SIZE;
-
 end:
+	mutex_unlock(&pdata->ops_mutex);
 	return ret;
 }
 
 static int adv7533_get_raw_edid(void *client,
 	u32 size, char *buf, u32 flags)
 {
-	struct adv7533_platform_data *pdata =
+	struct adv7533 *pdata =
 		adv7533_get_platform_data(client);
 
 	if (!pdata || !buf) {
@@ -886,52 +1726,92 @@ static int adv7533_get_raw_edid(void *client,
 		goto end;
 	}
 
-	size = size > sizeof(pdata->edid_buf) ? sizeof(pdata->edid_buf) : size;
+	mutex_lock(&pdata->ops_mutex);
+
+	size = min_t(u32, size, sizeof(pdata->edid_buf));
 
 	memcpy(buf, pdata->edid_buf, size);
 end:
+	mutex_unlock(&pdata->ops_mutex);
 	return 0;
 }
 
-static int adv7533_reg_fxn(struct msm_dba_client_info *cinfo)
+static int adv7533_write_reg(struct msm_dba_device_info *dev,
+		u32 reg, u32 val)
+{
+	struct adv7533 *pdata;
+	int ret = -EINVAL;
+	u8 i2ca = 0;
+
+	if (!dev)
+		goto end;
+
+	pdata = container_of(dev, struct adv7533, dev_info);
+	if (!pdata)
+		goto end;
+
+	i2ca = ((reg & 0x100) ? pdata->cec_dsi_i2c_addr : pdata->main_i2c_addr);
+
+	adv7533_write(pdata, i2ca, (u8)(reg & 0xFF), (u8)(val & 0xFF));
+end:
+	return ret;
+}
+
+static int adv7533_read_reg(struct msm_dba_device_info *dev,
+		u32 reg, u32 *val)
 {
 	int ret = 0;
-	struct adv7533_platform_data *pdata =
-		adv7533_get_platform_data((void *)cinfo);
+	u8 byte_val = 0;
+	u8 i2ca = 0;
+	struct adv7533 *pdata;
 
-	if (!pdata) {
-		pr_err("%s: invalid platform data\n", __func__);
+	if (!dev)
 		goto end;
-	}
 
-	pdata->client_cb = cinfo->cb;
-	pdata->client_cb_data = cinfo->cb_data;
+	pdata = container_of(dev, struct adv7533, dev_info);
+	if (!pdata)
+		goto end;
+
+	i2ca = ((reg & 0x100) ? pdata->cec_dsi_i2c_addr : pdata->main_i2c_addr);
+
+	adv7533_read(pdata, i2ca, (u8)(reg & 0xFF), &byte_val, 1);
+
+	*val = (u32)byte_val;
 
 end:
 	return ret;
 }
 
-static int adv7533_register_dba(struct adv7533_platform_data *pdata)
+static int adv7533_register_dba(struct adv7533 *pdata)
 {
 	struct msm_dba_ops *client_ops;
+	struct msm_dba_device_ops *dev_ops;
 
 	if (!pdata)
 		return -EINVAL;
 
 	client_ops = &pdata->dev_info.client_ops;
+	dev_ops = &pdata->dev_info.dev_ops;
 
-	client_ops->power_on = adv7533_power_on;
-	client_ops->video_on = adv7533_video_on;
-	client_ops->get_edid_size = adv7533_get_edid_size;
-	client_ops->get_raw_edid = adv7533_get_raw_edid;
-	pdata->dev_info.dev_ops.read_reg = adv7533_read_reg;
-	pdata->dev_info.dev_ops.write_reg = adv7533_write_reg;
-	pdata->dev_info.dev_ops.dump_debug_info = adv7533_dump_debug_info;
+	client_ops->power_on        = adv7533_power_on;
+	client_ops->video_on        = adv7533_video_on;
+	client_ops->configure_audio = adv7533_configure_audio;
+	client_ops->hdcp_enable     = adv7533_hdcp_enable;
+	client_ops->hdmi_cec_on     = adv7533_cec_enable;
+	client_ops->hdmi_cec_write  = adv7533_hdmi_cec_write;
+	client_ops->hdmi_cec_read   = adv7533_hdmi_cec_read;
+	client_ops->get_edid_size   = adv7533_get_edid_size;
+	client_ops->get_raw_edid    = adv7533_get_raw_edid;
+	client_ops->check_hpd	    = adv7533_check_hpd;
+
+	dev_ops->write_reg = adv7533_write_reg;
+	dev_ops->read_reg = adv7533_read_reg;
+	dev_ops->dump_debug_info = adv7533_dump_debug_info;
 
 	strlcpy(pdata->dev_info.chip_name, "adv7533",
 		sizeof(pdata->dev_info.chip_name));
 
-	pdata->dev_info.reg_fxn = adv7533_reg_fxn;
+	pdata->dev_info.instance_id = 0;
 
 	mutex_init(&pdata->dev_info.dev_mutex);
 
@@ -940,7 +1820,7 @@ static int adv7533_register_dba(struct adv7533_platform_data *pdata)
 	return msm_dba_add_probed_device(&pdata->dev_info);
 }
 
-static void adv7533_unregister_dba(struct adv7533_platform_data *pdata)
+static void adv7533_unregister_dba(struct adv7533 *pdata)
 {
 	if (!pdata)
 		return;
@@ -948,31 +1828,81 @@ static void adv7533_unregister_dba(struct adv7533_platform_data *pdata)
 	msm_dba_remove_probed_device(&pdata->dev_info);
 }
 
-static int adv7533_probe(struct i2c_client *client_,
-	 const struct i2c_device_id *id)
+static int adv7533_config_vreg(struct adv7533 *pdata, int enable)
 {
-	int ret = 0;
+	int rc = 0;
+	struct dss_module_power *power_data = NULL;
 
-	client = client_;
-	if (client->dev.of_node) {
-		pdata = devm_kzalloc(&client->dev,
-			sizeof(struct adv7533_platform_data), GFP_KERNEL);
-		if (!pdata)
-			return -ENOMEM;
+	if (!pdata) {
+		pr_err("invalid input\n");
+		rc = -EINVAL;
+		goto exit;
+	}
 
-		ret = adv7533_parse_dt(&client->dev, pdata);
-		if (ret) {
-			pr_err("%s: Failed to parse DT\n", __func__);
-			goto err_dt_parse;
+	power_data = &pdata->power_data;
+	if (!power_data || !power_data->num_vreg) {
+		pr_warn("%s: Error: invalid power data\n", __func__);
+		return 0;
+	}
+
+	if (enable) {
+		rc = msm_dss_config_vreg(&pdata->i2c_client->dev,
+					power_data->vreg_config,
+					power_data->num_vreg, 1);
+		if (rc) {
+			pr_err("%s: Failed to config vreg. Err=%d\n",
+				__func__, rc);
+			goto exit;
+		}
+	} else {
+		rc = msm_dss_config_vreg(&pdata->i2c_client->dev,
+					power_data->vreg_config,
+					power_data->num_vreg, 0);
+		if (rc) {
+			pr_err("%s: Failed to config vreg. Err=%d\n",
+				__func__, rc);
+			goto exit;
 		}
 	}
+exit:
+	return rc;
 
-	ret = adv7533_read_device_rev(pdata);
-	if (ret != 0) {
-		pr_err("%s: Failed to read revision\n", __func__);
+}
+
+static int adv7533_probe(struct i2c_client *client,
+	 const struct i2c_device_id *id)
+{
+	static struct adv7533 *pdata;
+	int ret = 0;
+
+	if (!client || !client->dev.of_node) {
+		pr_err("%s: invalid input\n", __func__);
+		return -EINVAL;
+	}
+
+	pdata = devm_kzalloc(&client->dev,
+		sizeof(struct adv7533), GFP_KERNEL);
+	if (!pdata)
+		return -ENOMEM;
+
+	ret = adv7533_parse_dt(&client->dev, pdata);
+	if (ret) {
+		pr_err("%s: Failed to parse DT\n", __func__);
 		goto err_dt_parse;
 	}
 
+	pdata->i2c_client = client;
+
+	ret = adv7533_config_vreg(pdata, 1);
+	if (ret) {
+		pr_err("%s: Failed to config vreg\n", __func__);
+		return -EPROBE_DEFER;
+	}
+
+	mutex_init(&pdata->ops_mutex);
+
+	adv7533_read_device_rev(pdata);
+
 	ret = adv7533_program_i2c_addr(pdata);
 	if (ret != 0) {
 		pr_err("%s: Failed to program i2c addr\n", __func__);
@@ -988,29 +1918,18 @@ static int adv7533_probe(struct i2c_client *client_,
 
 	ret = pinctrl_select_state(pdata->ts_pinctrl,
 		pdata->pinctrl_state_active);
-	if (ret < 0) {
+	if (ret < 0)
 		pr_err("%s: Failed to select %s pinstate %d\n",
 			__func__, PINCTRL_STATE_ACTIVE, ret);
-		goto err_dba_reg;
+
+	ret = adv7533_gpio_configure(pdata, true);
+	if (ret) {
+		pr_err("%s: Failed to configure GPIOs\n", __func__);
+		goto err_gpio_cfg;
 	}
 
-	pdata->adv_output = true;
-
-	if (!(pdata->disable_gpios)) {
-		ret = adv7533_gpio_configure(pdata, true);
-		if (ret) {
-			pr_err("%s: Failed to configure GPIOs\n", __func__);
-			goto err_gpio_cfg;
-		}
-
-		if (pdata->adv_output) {
-			gpio_set_value(pdata->switch_gpio, pdata->switch_flags);
-		} else {
-			gpio_set_value(pdata->switch_gpio,
-				!pdata->switch_flags);
-			goto err_gpio_cfg;
-		}
-	}
+	if (gpio_is_valid(pdata->switch_gpio))
+		gpio_set_value(pdata->switch_gpio, pdata->switch_flags);
 
 	pdata->irq = gpio_to_irq(pdata->irq_gpio);
 
@@ -1022,15 +1941,6 @@ static int adv7533_probe(struct i2c_client *client_,
 		goto err_irq;
 	}
 
-	if (pdata->audio) {
-		ret = adv7533_write_regs(pdata, I2S_cfg, ARRAY_SIZE(I2S_cfg));
-		if (ret != 0) {
-			pr_err("%s: I2S configuration fail = %d!\n",
-				__func__, ret);
-			goto err_dba_helper;
-		}
-	}
-
 	dev_set_drvdata(&client->dev, &pdata->dev_info);
 	ret = msm_dba_helper_sysfs_init(&client->dev);
 	if (ret) {
@@ -1045,13 +1955,21 @@ static int adv7533_probe(struct i2c_client *client_,
 		goto err_workqueue;
 	}
 
+	if (pdata->audio) {
+		pr_debug("%s: enabling default audio configs\n", __func__);
+		if (adv7533_write_array(pdata, I2S_cfg, sizeof(I2S_cfg)))
+			goto end;
+	}
+
 	INIT_DELAYED_WORK(&pdata->adv7533_intr_work_id, adv7533_intr_work);
 
 	pm_runtime_enable(&client->dev);
 	pm_runtime_set_active(&client->dev);
 
 	return 0;
-
+end:
+	if (pdata->workq)
+		destroy_workqueue(pdata->workq);
 err_workqueue:
 	msm_dba_helper_sysfs_remove(&client->dev);
 err_dba_helper:
@@ -1069,7 +1987,20 @@ err_dt_parse:
 
 static int adv7533_remove(struct i2c_client *client)
 {
-	int ret = 0;
+	int ret = -EINVAL;
+	struct msm_dba_device_info *dev;
+	struct adv7533 *pdata;
+
+	if (!client)
+		goto end;
+
+	dev = dev_get_drvdata(&client->dev);
+	if (!dev)
+		goto end;
+
+	pdata = container_of(dev, struct adv7533, dev_info);
+	if (!pdata)
+		goto end;
 
 	pm_runtime_disable(&client->dev);
 	disable_irq(pdata->irq);
@@ -1077,7 +2008,11 @@ static int adv7533_remove(struct i2c_client *client)
 
 	ret = adv7533_gpio_configure(pdata, false);
 
+	mutex_destroy(&pdata->ops_mutex);
+
 	devm_kfree(&client->dev, pdata);
+
+end:
 	return ret;
 }
 
diff --git a/include/video/msm_dba.h b/include/video/msm_dba.h
index 7cc346ee0d33..57f418b93bf8 100644
--- a/include/video/msm_dba.h
+++ b/include/video/msm_dba.h
@@ -286,6 +286,7 @@ struct msm_dba_video_cfg {
 	bool hdmi_mode;
 	enum msm_dba_video_aspect_ratio ar;
 	u32  num_of_input_lanes;
+	u8 scaninfo;
 };
 
 /**
@@ -338,6 +339,8 @@ struct msm_dba_video_cfg {
  *		       hdcp_get_ksv_list_size first and then allocate 40*size
  *		       bytes to hold all the KSVs.
  *		       DEFER and ASYNC flags are not supported.
+ * @hdmi_cec_on: enable or disable cec module. Clients need to enable CEC
+ *		 feature before they do read or write CEC messages.
  * @hdmi_cec_write: perform a CEC write. For bridges with HDMI as output
  *		    interface, this function allows clients to send a CEC
  *		    message. Client should pack the data according to the CEC
@@ -381,6 +384,8 @@ struct msm_dba_video_cfg {
  *		 have been applied so far after the reset is complete. In case
  *		 of multiple clients, driver will issue a reset callback.
  * @dump_debug_info: dumps debug information to dmesg.
+ * @check_hpd: Check if cable is connected or not. if cable is connected we
+ *		send notification to display framework.
  *
  * The msm_dba_ops structure represents a set of operations that can be
  * supported by each bridge chip. Depending on the functionality supported by a
@@ -441,6 +446,10 @@ struct msm_dba_ops {
 				 char *buf,
 				 u32 flags);
 
+	int (*hdmi_cec_on)(void *client,
+			      bool enable,
+			      u32 flags);
+
 	int (*hdmi_cec_write)(void *client,
 			      u32 size,
 			      char *buf,
@@ -474,6 +483,7 @@ struct msm_dba_ops {
 
 	int (*force_reset)(void *client, u32 flags);
 	int (*dump_debug_info)(void *client, u32 flags);
+	int (*check_hpd)(void *client, u32 flags);
 };
 
 /**
@@ -487,15 +497,8 @@ struct msm_dba_ops {
  * chip. If Successful, this will return a pointer that should be used as a
  * handle for all subsequent function calls.
  */
-#ifdef CONFIG_MSM_DBA
 void *msm_dba_register_client(struct msm_dba_reg_info *info,
 			      struct msm_dba_ops *ops);
-#else
-static inline void *msm_dba_register_client(struct msm_dba_reg_info *info,
-			      struct msm_dba_ops *ops) {
-	return NULL;
-}
-#endif
 
 /**
  * msm_dba_deregister_client() - Allows client to de-register with the driver.