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.