mhi: core: add support to enable MHI burst mode per channel basis

Not all MHI hardware channels support burst mode, add
support to enable burst mode per channel basis.

CRs-Fixed: 1027069
Change-Id: Icd3061f1a1a4b4b3dab8f9fe3b989a8afefd18b2
Signed-off-by: Sujeev Dias <sdias@codeaurora.org>

8 files changed, 189 insertions, 55 deletions

diff --git a/drivers/platform/msm/mhi/mhi.h b/drivers/platform/msm/mhi/mhi.h
index 6919a97116ab..a85ba0a9b93e 100644
--- a/drivers/platform/msm/mhi/mhi.h
+++ b/drivers/platform/msm/mhi/mhi.h
@@ -29,6 +29,7 @@
 #include <linux/dma-mapping.h>
 
 extern struct mhi_pcie_devices mhi_devices;
+struct mhi_device_ctxt;
 
 enum MHI_DEBUG_LEVEL {
 	MHI_MSG_RAW = 0x1,
@@ -125,6 +126,14 @@ enum MHI_STATE {
 	MHI_STATE_reserved = 0x80000000
 };
 
+enum MHI_BRSTMODE {
+	/* BRST Mode Enable for HW Channels, SW Channel Disabled */
+	MHI_BRSTMODE_DEFAULT = 0x0,
+	MHI_BRSTMODE_RESERVED = 0x1,
+	MHI_BRSTMODE_DISABLE = 0x2,
+	MHI_BRSTMODE_ENABLE = 0x3
+};
+
 struct __packed mhi_event_ctxt {
 	u32 mhi_intmodt;
 	u32 mhi_event_er_type;
@@ -136,8 +145,11 @@ struct __packed mhi_event_ctxt {
 };
 
 struct __packed mhi_chan_ctxt {
-	enum MHI_CHAN_STATE mhi_chan_state;
-	enum MHI_CHAN_DIR mhi_chan_type;
+	u32 chstate : 8;
+	u32 brstmode : 2;
+	u32 pollcfg : 6;
+	u32 reserved : 16;
+	u32 chtype;
 	u32 mhi_event_ring_index;
 	u64 mhi_trb_ring_base_addr;
 	u64 mhi_trb_ring_len;
@@ -265,6 +277,11 @@ struct db_mode {
 	/* if set do not reset DB_Mode during M0 resume */
 	u32 preserve_db_state : 1;
 	u32 db_mode : 1;
+	enum MHI_BRSTMODE brstmode;
+	void (*process_db)(struct mhi_device_ctxt *mhi_dev_ctxt,
+			   void __iomem *io_addr,
+			   uintptr_t chan,
+			   u32 val);
 };
 
 struct mhi_ring {
@@ -414,7 +431,6 @@ struct mhi_flags {
 	u32 ssr;
 	u32 ev_thread_stopped;
 	u32 st_thread_stopped;
-	u32 uldl_enabled;
 };
 
 struct mhi_wait_queues {
@@ -578,7 +594,8 @@ int mhi_init_chan_ctxt(struct mhi_chan_ctxt *cc_list,
 				   u32 event_ring,
 				   struct mhi_ring *ring,
 				   enum MHI_CHAN_STATE chan_state,
-				   bool preserve_db_state);
+				   bool preserve_db_state,
+				   enum MHI_BRSTMODE brstmode);
 int mhi_populate_event_cfg(struct mhi_device_ctxt *mhi_dev_ctxt);
 int mhi_get_event_ring_for_channel(struct mhi_device_ctxt *mhi_dev_ctxt,
 					      u32 chan);
@@ -636,6 +653,14 @@ int mhi_initiate_m3(struct mhi_device_ctxt *mhi_dev_ctxt);
 int mhi_set_bus_request(struct mhi_device_ctxt *mhi_dev_ctxt,
 					int index);
 int start_chan_sync(struct mhi_client_handle *client_handle);
+void mhi_process_db_brstmode(struct mhi_device_ctxt *mhi_dev_ctxt,
+			     void __iomem *io_addr,
+			     uintptr_t chan,
+			     u32 val);
+void mhi_process_db_brstmode_disable(struct mhi_device_ctxt *mhi_dev_ctxt,
+				     void __iomem *io_addr,
+				     uintptr_t chan,
+				     u32 val);
 void mhi_process_db(struct mhi_device_ctxt *mhi_dev_ctxt, void __iomem *io_addr,
 		  uintptr_t io_offset, u32 val);
 void mhi_reg_write_field(struct mhi_device_ctxt *mhi_dev_ctxt,
diff --git a/drivers/platform/msm/mhi/mhi_event.c b/drivers/platform/msm/mhi/mhi_event.c
index aa8500d277cd..e9d79ee4e750 100644
--- a/drivers/platform/msm/mhi/mhi_event.c
+++ b/drivers/platform/msm/mhi/mhi_event.c
@@ -129,13 +129,18 @@ void ring_ev_db(struct mhi_device_ctxt *mhi_dev_ctxt, u32 event_ring_index)
 	db_value = mhi_v2p_addr(mhi_dev_ctxt, MHI_RING_TYPE_EVENT_RING,
 						event_ring_index,
 						(uintptr_t) event_ctxt->wp);
-	mhi_process_db(mhi_dev_ctxt, mhi_dev_ctxt->mmio_info.event_db_addr,
-					event_ring_index, db_value);
+	event_ctxt->db_mode.process_db(mhi_dev_ctxt,
+				    mhi_dev_ctxt->mmio_info.event_db_addr,
+				    event_ring_index,
+				    db_value);
 }
 
 static int mhi_event_ring_init(struct mhi_event_ctxt *ev_list,
-				struct mhi_ring *ring, u32 el_per_ring,
-				u32 intmodt_val, u32 msi_vec)
+			       struct mhi_ring *ring,
+			       u32 el_per_ring,
+			       u32 intmodt_val,
+			       u32 msi_vec,
+			       enum MHI_BRSTMODE brstmode)
 {
 	ev_list->mhi_event_er_type  = MHI_EVENT_RING_TYPE_VALID;
 	ev_list->mhi_msi_vector     = msi_vec;
@@ -144,6 +149,20 @@ static int mhi_event_ring_init(struct mhi_event_ctxt *ev_list,
 	ring->len = ((size_t)(el_per_ring)*sizeof(union mhi_event_pkt));
 	ring->el_size = sizeof(union mhi_event_pkt);
 	ring->overwrite_en = 0;
+
+	ring->db_mode.db_mode = 1;
+	ring->db_mode.brstmode = brstmode;
+	switch (ring->db_mode.brstmode) {
+	case MHI_BRSTMODE_ENABLE:
+		ring->db_mode.process_db = mhi_process_db_brstmode;
+		break;
+	case MHI_BRSTMODE_DISABLE:
+		ring->db_mode.process_db = mhi_process_db_brstmode_disable;
+		break;
+	default:
+		ring->db_mode.process_db = mhi_process_db;
+	}
+
 	/* Flush writes to MMIO */
 	wmb();
 	return 0;
@@ -159,9 +178,12 @@ void init_event_ctxt_array(struct mhi_device_ctxt *mhi_dev_ctxt)
 		event_ctxt = &mhi_dev_ctxt->dev_space.ring_ctxt.ec_list[i];
 		mhi_local_event_ctxt = &mhi_dev_ctxt->mhi_local_event_ctxt[i];
 		mhi_event_ring_init(event_ctxt, mhi_local_event_ctxt,
-			mhi_dev_ctxt->ev_ring_props[i].nr_desc,
-			mhi_dev_ctxt->ev_ring_props[i].intmod,
-			mhi_dev_ctxt->ev_ring_props[i].msi_vec);
+				    mhi_dev_ctxt->ev_ring_props[i].nr_desc,
+				    mhi_dev_ctxt->ev_ring_props[i].intmod,
+				    mhi_dev_ctxt->ev_ring_props[i].msi_vec,
+				    GET_EV_PROPS(EV_BRSTMODE,
+						 mhi_dev_ctxt->
+						 ev_ring_props[i].flags));
 	}
 }
 
diff --git a/drivers/platform/msm/mhi/mhi_init.c b/drivers/platform/msm/mhi/mhi_init.c
index 2982bd0831c7..fd75d4912805 100644
--- a/drivers/platform/msm/mhi/mhi_init.c
+++ b/drivers/platform/msm/mhi/mhi_init.c
@@ -115,7 +115,7 @@ void init_dev_chan_ctxt(struct mhi_chan_ctxt *chan_ctxt,
 	chan_ctxt->mhi_trb_write_ptr = p_base_addr;
 	chan_ctxt->mhi_trb_ring_len = len;
 	/* Prepulate the channel ctxt */
-	chan_ctxt->mhi_chan_state = MHI_CHAN_STATE_ENABLED;
+	chan_ctxt->chstate = MHI_CHAN_STATE_ENABLED;
 	chan_ctxt->mhi_event_ring_index = ev_index;
 }
 
@@ -173,6 +173,8 @@ static int mhi_cmd_ring_init(struct mhi_cmd_ctxt *cmd_ctxt,
 	ring[PRIMARY_CMD_RING].len = ring_size;
 	ring[PRIMARY_CMD_RING].el_size = sizeof(union mhi_cmd_pkt);
 	ring[PRIMARY_CMD_RING].overwrite_en = 0;
+	ring[PRIMARY_CMD_RING].db_mode.process_db =
+		mhi_process_db_brstmode_disable;
 	return 0;
 }
 
@@ -601,10 +603,12 @@ int mhi_init_chan_ctxt(struct mhi_chan_ctxt *cc_list,
 		       u64 el_per_ring, enum MHI_CHAN_DIR chan_type,
 		       u32 event_ring, struct mhi_ring *ring,
 		       enum MHI_CHAN_STATE chan_state,
-		       bool preserve_db_state)
+		       bool preserve_db_state,
+		       enum MHI_BRSTMODE brstmode)
 {
-	cc_list->mhi_chan_state = chan_state;
-	cc_list->mhi_chan_type = chan_type;
+	cc_list->brstmode = brstmode;
+	cc_list->chstate = chan_state;
+	cc_list->chtype = chan_type;
 	cc_list->mhi_event_ring_index = event_ring;
 	cc_list->mhi_trb_ring_base_addr = trb_list_phy;
 	cc_list->mhi_trb_ring_len =
@@ -621,6 +625,19 @@ int mhi_init_chan_ctxt(struct mhi_chan_ctxt *cc_list,
 	ring->dir = chan_type;
 	ring->db_mode.db_mode = 1;
 	ring->db_mode.preserve_db_state = (preserve_db_state) ? 1 : 0;
+	ring->db_mode.brstmode = brstmode;
+
+	switch (ring->db_mode.brstmode) {
+	case MHI_BRSTMODE_ENABLE:
+		ring->db_mode.process_db = mhi_process_db_brstmode;
+		break;
+	case MHI_BRSTMODE_DISABLE:
+		ring->db_mode.process_db = mhi_process_db_brstmode_disable;
+		break;
+	default:
+		ring->db_mode.process_db = mhi_process_db;
+	}
+
 	/* Flush writes to MMIO */
 	wmb();
 	return 0;
diff --git a/drivers/platform/msm/mhi/mhi_macros.h b/drivers/platform/msm/mhi/mhi_macros.h
index 6f9ed293e6dd..133c0eeb034e 100644
--- a/drivers/platform/msm/mhi/mhi_macros.h
+++ b/drivers/platform/msm/mhi/mhi_macros.h
@@ -247,9 +247,17 @@
 #define MHI_PRESERVE_DB_STATE__MASK (1)
 #define MHI_PRESERVE_DB_STATE__SHIFT (8)
 
+#define BRSTMODE
+#define MHI_BRSTMODE__MASK (3)
+#define MHI_BRSTMODE__SHIFT (9)
+
 #define GET_CHAN_PROPS(_FIELD, _VAL) \
 	(((_VAL) >> MHI_##_FIELD ## __SHIFT) & MHI_##_FIELD ## __MASK)
 
+#define EV_BRSTMODE
+#define MHI_EV_BRSTMODE__MASK (3)
+#define MHI_EV_BRSTMODE__SHIFT (5)
+
 #define EV_TYPE
 #define MHI_EV_TYPE__MASK (3)
 #define MHI_EV_TYPE__SHIFT (3)
diff --git a/drivers/platform/msm/mhi/mhi_main.c b/drivers/platform/msm/mhi/mhi_main.c
index 6da133ce8e04..5a34dd0bb973 100644
--- a/drivers/platform/msm/mhi/mhi_main.c
+++ b/drivers/platform/msm/mhi/mhi_main.c
@@ -212,7 +212,9 @@ int mhi_release_chan_ctxt(struct mhi_device_ctxt *mhi_dev_ctxt,
 			ring->len, ring->base,
 			 cc_list->mhi_trb_ring_base_addr);
 	mhi_init_chan_ctxt(cc_list, 0, 0, 0, 0, 0, ring,
-			   MHI_CHAN_STATE_DISABLED, false);
+			   MHI_CHAN_STATE_DISABLED,
+			   false,
+			   MHI_BRSTMODE_DEFAULT);
 	return 0;
 }
 
@@ -261,7 +263,9 @@ static int populate_tre_ring(struct mhi_client_handle *client_handle)
 			   &mhi_dev_ctxt->mhi_local_chan_ctxt[chan],
 			   MHI_CHAN_STATE_ENABLED,
 			   GET_CHAN_PROPS(PRESERVE_DB_STATE,
-				client_handle->chan_info.flags));
+					  client_handle->chan_info.flags),
+			   GET_CHAN_PROPS(BRSTMODE,
+					  client_handle->chan_info.flags));
 	mhi_log(MHI_MSG_INFO, "Exited\n");
 	return 0;
 }
@@ -442,9 +446,10 @@ void mhi_update_chan_db(struct mhi_device_ctxt *mhi_dev_ctxt,
 	db_value = mhi_v2p_addr(mhi_dev_ctxt, MHI_RING_TYPE_XFER_RING, chan,
 						(uintptr_t) chan_ctxt->wp);
 	mhi_dev_ctxt->mhi_chan_db_order[chan]++;
-		mhi_process_db(mhi_dev_ctxt,
-				mhi_dev_ctxt->mmio_info.chan_db_addr,
-				chan, db_value);
+	chan_ctxt->db_mode.process_db(mhi_dev_ctxt,
+				      mhi_dev_ctxt->mmio_info.chan_db_addr,
+				      chan,
+				      db_value);
 }
 
 int mhi_check_m2_transition(struct mhi_device_ctxt *mhi_dev_ctxt)
@@ -490,7 +495,7 @@ static inline int mhi_queue_tre(struct mhi_device_ctxt
 	if (likely(((ret_val == 0) &&
 	    (((mhi_dev_ctxt->mhi_state == MHI_STATE_M0) ||
 	      (mhi_dev_ctxt->mhi_state == MHI_STATE_M1))) &&
-	    (chan_ctxt->mhi_chan_state != MHI_CHAN_STATE_ERROR)) &&
+	    (chan_ctxt->chstate != MHI_CHAN_STATE_ERROR)) &&
 	    (!mhi_dev_ctxt->flags.pending_M3))) {
 		if (likely(type == MHI_RING_TYPE_XFER_RING)) {
 			spin_lock_irqsave(&mhi_dev_ctxt->db_write_lock[chan],
@@ -506,15 +511,18 @@ static inline int mhi_queue_tre(struct mhi_device_ctxt
 			spin_unlock_irqrestore(
 			   &mhi_dev_ctxt->db_write_lock[chan], flags);
 		} else if (type == MHI_RING_TYPE_CMD_RING) {
+			struct mhi_ring *cmd_ring = &mhi_dev_ctxt->
+				mhi_local_cmd_ctxt[PRIMARY_CMD_RING];
 			db_value = mhi_v2p_addr(mhi_dev_ctxt,
 						MHI_RING_TYPE_CMD_RING,
 						PRIMARY_CMD_RING,
 						(uintptr_t)
-			mhi_dev_ctxt->mhi_local_cmd_ctxt[PRIMARY_CMD_RING].wp);
+			cmd_ring->wp);
 			mhi_dev_ctxt->cmd_ring_order++;
-			mhi_process_db(mhi_dev_ctxt,
+			cmd_ring->db_mode.process_db(mhi_dev_ctxt,
 				mhi_dev_ctxt->mmio_info.cmd_db_addr,
-				0, db_value);
+				0,
+				db_value);
 		} else {
 			mhi_log(MHI_MSG_VERBOSE,
 			"Wrong type of packet = %d\n", type);
@@ -524,7 +532,7 @@ static inline int mhi_queue_tre(struct mhi_device_ctxt
 		mhi_log(MHI_MSG_VERBOSE,
 			"Wakeup, pending data state %s chan state %d\n",
 			TO_MHI_STATE_STR(mhi_dev_ctxt->mhi_state),
-			chan_ctxt->mhi_chan_state);
+			chan_ctxt->chstate);
 			ret_val = 0;
 	}
 	return ret_val;
@@ -787,7 +795,7 @@ int mhi_send_cmd(struct mhi_device_ctxt *mhi_dev_ctxt,
 
 	atomic_inc(&mhi_dev_ctxt->flags.data_pending);
 	from_state =
-	    mhi_dev_ctxt->dev_space.ring_ctxt.cc_list[chan].mhi_chan_state;
+	    mhi_dev_ctxt->dev_space.ring_ctxt.cc_list[chan].chstate;
 
 	switch (cmd) {
 		break;
@@ -1170,7 +1178,6 @@ int parse_xfer_event(struct mhi_device_ctxt *ctxt,
 		u64 db_value = 0;
 		unsigned long flags;
 
-		mhi_dev_ctxt->flags.uldl_enabled = 1;
 		chan = MHI_EV_READ_CHID(EV_CHID, event);
 		chan_ctxt =
 			&mhi_dev_ctxt->mhi_local_chan_ctxt[chan];
@@ -1183,7 +1190,7 @@ int parse_xfer_event(struct mhi_device_ctxt *ctxt,
 			db_value = mhi_v2p_addr(mhi_dev_ctxt,
 						MHI_RING_TYPE_XFER_RING, chan,
 						(uintptr_t) chan_ctxt->wp);
-			mhi_process_db(mhi_dev_ctxt,
+			chan_ctxt->db_mode.process_db(mhi_dev_ctxt,
 				     mhi_dev_ctxt->mmio_info.chan_db_addr, chan,
 				     db_value);
 		}
@@ -1274,13 +1281,14 @@ int recycle_trb_and_ring(struct mhi_device_ctxt *mhi_dev_ctxt,
 		case MHI_RING_TYPE_CMD_RING:
 		{
 			struct mutex *cmd_mutex = NULL;
-
+			struct mhi_ring *mhi_ring = &mhi_dev_ctxt->
+				mhi_local_cmd_ctxt[PRIMARY_CMD_RING];
 			cmd_mutex =
 				&mhi_dev_ctxt->
 				mhi_cmd_mutex_list[PRIMARY_CMD_RING];
 			mutex_lock(cmd_mutex);
 			mhi_dev_ctxt->cmd_ring_order = 1;
-			mhi_process_db(mhi_dev_ctxt,
+			mhi_ring->db_mode.process_db(mhi_dev_ctxt,
 				mhi_dev_ctxt->mmio_info.cmd_db_addr,
 				ring_index, db_value);
 			mutex_unlock(cmd_mutex);
@@ -1290,7 +1298,8 @@ int recycle_trb_and_ring(struct mhi_device_ctxt *mhi_dev_ctxt,
 		{
 			spinlock_t *lock = NULL;
 			unsigned long flags = 0;
-
+			struct mhi_ring *mhi_ring = &mhi_dev_ctxt->
+				mhi_local_event_ctxt[ring_index];
 			lock = &mhi_dev_ctxt->mhi_ev_spinlock_list[ring_index];
 			spin_lock_irqsave(lock, flags);
 			mhi_dev_ctxt->mhi_ev_db_order[ring_index] = 1;
@@ -1299,7 +1308,7 @@ int recycle_trb_and_ring(struct mhi_device_ctxt *mhi_dev_ctxt,
 				db_value = mhi_v2p_addr(mhi_dev_ctxt, ring_type,
 							ring_index,
 							(uintptr_t) ring->wp);
-				mhi_process_db(mhi_dev_ctxt,
+				mhi_ring->db_mode.process_db(mhi_dev_ctxt,
 					mhi_dev_ctxt->mmio_info.event_db_addr,
 					ring_index, db_value);
 			}
@@ -1309,12 +1318,13 @@ int recycle_trb_and_ring(struct mhi_device_ctxt *mhi_dev_ctxt,
 		case MHI_RING_TYPE_XFER_RING:
 		{
 			unsigned long flags = 0;
-
+			struct mhi_ring *mhi_ring = &mhi_dev_ctxt->
+				mhi_local_chan_ctxt[ring_index];
 			spin_lock_irqsave(
 				&mhi_dev_ctxt->db_write_lock[ring_index],
 				flags);
 			mhi_dev_ctxt->mhi_chan_db_order[ring_index] = 1;
-			mhi_process_db(mhi_dev_ctxt,
+			mhi_ring->db_mode.process_db(mhi_dev_ctxt,
 					mhi_dev_ctxt->mmio_info.chan_db_addr,
 					ring_index, db_value);
 			spin_unlock_irqrestore(
@@ -1380,7 +1390,7 @@ static int reset_chan_cmd(struct mhi_device_ctxt *mhi_dev_ctxt,
 	local_chan_ctxt->ack_rp = local_chan_ctxt->base;
 
 	/* Reset the mhi channel context */
-	chan_ctxt->mhi_chan_state = MHI_CHAN_STATE_DISABLED;
+	chan_ctxt->chstate = MHI_CHAN_STATE_DISABLED;
 	chan_ctxt->mhi_trb_read_ptr = chan_ctxt->mhi_trb_ring_base_addr;
 	chan_ctxt->mhi_trb_write_ptr = chan_ctxt->mhi_trb_ring_base_addr;
 
@@ -1658,11 +1668,56 @@ int mhi_deregister_channel(struct mhi_client_handle
 }
 EXPORT_SYMBOL(mhi_deregister_channel);
 
+void mhi_process_db_brstmode(struct mhi_device_ctxt *mhi_dev_ctxt,
+			     void __iomem *io_addr,
+			     uintptr_t chan,
+			     u32 val)
+{
+	struct mhi_ring *ring_ctxt =
+		&mhi_dev_ctxt->mhi_local_chan_ctxt[chan];
+
+	if (io_addr == mhi_dev_ctxt->mmio_info.chan_db_addr)
+		ring_ctxt = &mhi_dev_ctxt->
+			mhi_local_chan_ctxt[chan];
+	else
+		ring_ctxt = &mhi_dev_ctxt->
+			mhi_local_event_ctxt[chan];
+
+	mhi_log(MHI_MSG_VERBOSE,
+			"db.set addr: %p io_offset 0x%lx val:0x%x\n",
+			io_addr, chan, val);
+
+	mhi_update_ctxt(mhi_dev_ctxt, io_addr, chan, val);
+
+	if (ring_ctxt->db_mode.db_mode) {
+		mhi_write_db(mhi_dev_ctxt, io_addr, chan, val);
+		ring_ctxt->db_mode.db_mode = 0;
+	} else {
+		mhi_log(MHI_MSG_INFO,
+			"Not ringing xfer db, chan %ld, brstmode %d db_mode %d\n",
+			chan,
+			ring_ctxt->db_mode.brstmode,
+			ring_ctxt->db_mode.db_mode);
+	}
+}
+
+void mhi_process_db_brstmode_disable(struct mhi_device_ctxt *mhi_dev_ctxt,
+			     void __iomem *io_addr,
+			     uintptr_t chan,
+			     u32 val)
+{
+	mhi_log(MHI_MSG_VERBOSE,
+			"db.set addr: %p io_offset 0x%lx val:0x%x\n",
+			io_addr, chan, val);
+
+	mhi_update_ctxt(mhi_dev_ctxt, io_addr, chan, val);
+	mhi_write_db(mhi_dev_ctxt, io_addr, chan, val);
+}
+
 void mhi_process_db(struct mhi_device_ctxt *mhi_dev_ctxt,
 		  void __iomem *io_addr,
 		  uintptr_t chan, u32 val)
 {
-	struct mhi_ring *chan_ctxt = &mhi_dev_ctxt->mhi_local_chan_ctxt[chan];
 
 	mhi_log(MHI_MSG_VERBOSE,
 			"db.set addr: %p io_offset 0x%lx val:0x%x\n",
@@ -1672,22 +1727,25 @@ void mhi_process_db(struct mhi_device_ctxt *mhi_dev_ctxt,
 
 	/* Channel Doorbell and Polling Mode Disabled or Software Channel*/
 	if (io_addr == mhi_dev_ctxt->mmio_info.chan_db_addr) {
+		struct mhi_ring *chan_ctxt =
+			&mhi_dev_ctxt->mhi_local_chan_ctxt[chan];
 		if (!(IS_HARDWARE_CHANNEL(chan) &&
-		    mhi_dev_ctxt->flags.uldl_enabled &&
 		    !chan_ctxt->db_mode.db_mode)) {
 			mhi_write_db(mhi_dev_ctxt, io_addr, chan, val);
 			chan_ctxt->db_mode.db_mode = 0;
 		} else {
 			mhi_log(MHI_MSG_INFO,
-				"Not ringing xfer db, chan %ld, ul_dl %d db_mode %d\n",
-				chan, mhi_dev_ctxt->flags.uldl_enabled,
+				"Not ringing xfer db, chan %ld, brstmode %d db_mode %d\n",
+				chan, chan_ctxt->db_mode.brstmode,
 				chan_ctxt->db_mode.db_mode);
 		}
 	/* Event Doorbell and Polling mode Disabled */
 	} else if (io_addr == mhi_dev_ctxt->mmio_info.event_db_addr) {
-		/* Only ring for software channel */
-		if (IS_SW_EV_RING(mhi_dev_ctxt, chan) ||
-		    !mhi_dev_ctxt->flags.uldl_enabled) {
+		struct mhi_ring *ev_ctxt =
+			&mhi_dev_ctxt->mhi_local_event_ctxt[chan];
+		/* Only ring for software channel or db mode*/
+		if (!(IS_HW_EV_RING(mhi_dev_ctxt, chan) &&
+		    !ev_ctxt->db_mode.db_mode)) {
 			mhi_write_db(mhi_dev_ctxt, io_addr, chan, val);
 		}
 	} else {
diff --git a/drivers/platform/msm/mhi/mhi_mmio_ops.c b/drivers/platform/msm/mhi/mhi_mmio_ops.c
index 6f56587a172b..9d4ff60ad6f1 100644
--- a/drivers/platform/msm/mhi/mhi_mmio_ops.c
+++ b/drivers/platform/msm/mhi/mhi_mmio_ops.c
@@ -114,9 +114,9 @@ int mhi_init_mmio(struct mhi_device_ctxt *mhi_dev_ctxt)
 			struct mhi_chan_ctxt *chan_ctxt =
 				&mhi_dev_ctxt->dev_space.ring_ctxt.cc_list[i];
 		if (VALID_CHAN_NR(i))
-			chan_ctxt->mhi_chan_state = MHI_CHAN_STATE_ENABLED;
+			chan_ctxt->chstate = MHI_CHAN_STATE_ENABLED;
 		else
-			chan_ctxt->mhi_chan_state = MHI_CHAN_STATE_DISABLED;
+			chan_ctxt->chstate = MHI_CHAN_STATE_DISABLED;
 	}
 	mhi_log(MHI_MSG_INFO,
 			"Read back MMIO Ready bit successfully. Moving on..\n");
diff --git a/drivers/platform/msm/mhi/mhi_states.c b/drivers/platform/msm/mhi/mhi_states.c
index f0404da98cf7..4a304a4c5bd7 100644
--- a/drivers/platform/msm/mhi/mhi_states.c
+++ b/drivers/platform/msm/mhi/mhi_states.c
@@ -64,7 +64,7 @@ static void conditional_chan_db_write(
 {
 	u64 db_value;
 	unsigned long flags;
-
+	struct mhi_ring *mhi_ring = &mhi_dev_ctxt->mhi_local_chan_ctxt[chan];
 	mhi_dev_ctxt->mhi_chan_db_order[chan] = 0;
 	spin_lock_irqsave(&mhi_dev_ctxt->db_write_lock[chan], flags);
 	if (0 == mhi_dev_ctxt->mhi_chan_db_order[chan]) {
@@ -72,9 +72,9 @@ static void conditional_chan_db_write(
 		mhi_v2p_addr(mhi_dev_ctxt,
 			MHI_RING_TYPE_XFER_RING, chan,
 			(uintptr_t)mhi_dev_ctxt->mhi_local_chan_ctxt[chan].wp);
-		mhi_process_db(mhi_dev_ctxt,
-			       mhi_dev_ctxt->mmio_info.chan_db_addr,
-			       chan, db_value);
+		mhi_ring->db_mode.process_db(mhi_dev_ctxt,
+				mhi_dev_ctxt->mmio_info.chan_db_addr,
+				chan, db_value);
 	}
 	mhi_dev_ctxt->mhi_chan_db_order[chan] = 0;
 	spin_unlock_irqrestore(&mhi_dev_ctxt->db_write_lock[chan], flags);
@@ -121,9 +121,10 @@ static void ring_all_cmd_dbs(struct mhi_device_ctxt *mhi_dev_ctxt)
 			PRIMARY_CMD_RING,
 			(uintptr_t)mhi_dev_ctxt->mhi_local_cmd_ctxt[0].wp);
 	if (0 == mhi_dev_ctxt->cmd_ring_order && rp != db_value)
-		mhi_process_db(mhi_dev_ctxt,
-			       mhi_dev_ctxt->mmio_info.cmd_db_addr,
-							0, db_value);
+		local_ctxt->db_mode.process_db(mhi_dev_ctxt,
+				mhi_dev_ctxt->mmio_info.cmd_db_addr,
+				0,
+				db_value);
 	mhi_dev_ctxt->cmd_ring_order = 0;
 	mutex_unlock(cmd_mutex);
 }
@@ -133,11 +134,13 @@ static void ring_all_ev_dbs(struct mhi_device_ctxt *mhi_dev_ctxt)
 	u32 i;
 	u64 db_value = 0;
 	struct mhi_event_ctxt *event_ctxt = NULL;
+	struct mhi_ring *mhi_ring;
 	spinlock_t *lock = NULL;
 	unsigned long flags;
 
 	for (i = 0; i < mhi_dev_ctxt->mmio_info.nr_event_rings; ++i) {
 		lock = &mhi_dev_ctxt->mhi_ev_spinlock_list[i];
+		mhi_ring = &mhi_dev_ctxt->mhi_local_event_ctxt[i];
 		mhi_dev_ctxt->mhi_ev_db_order[i] = 0;
 		spin_lock_irqsave(lock, flags);
 		event_ctxt = &mhi_dev_ctxt->dev_space.ring_ctxt.ec_list[i];
@@ -146,9 +149,10 @@ static void ring_all_ev_dbs(struct mhi_device_ctxt *mhi_dev_ctxt)
 			i,
 			(uintptr_t)mhi_dev_ctxt->mhi_local_event_ctxt[i].wp);
 		if (0 == mhi_dev_ctxt->mhi_ev_db_order[i]) {
-			mhi_process_db(mhi_dev_ctxt,
-				       mhi_dev_ctxt->mmio_info.event_db_addr,
-				       i, db_value);
+			mhi_ring->db_mode.process_db(mhi_dev_ctxt,
+				mhi_dev_ctxt->mmio_info.event_db_addr,
+				i,
+				db_value);
 		}
 		mhi_dev_ctxt->mhi_ev_db_order[i] = 0;
 		spin_unlock_irqrestore(lock, flags);
diff --git a/drivers/platform/msm/mhi/mhi_sys.c b/drivers/platform/msm/mhi/mhi_sys.c
index 3316b2694896..c7e7334ea163 100644
--- a/drivers/platform/msm/mhi/mhi_sys.c
+++ b/drivers/platform/msm/mhi/mhi_sys.c
@@ -95,7 +95,7 @@ static ssize_t mhi_dbgfs_chan_read(struct file *fp, char __user *buf,
 		"pkts from dev:",
 		mhi_dev_ctxt->counters.chan_pkts_xferd[*offp],
 		"state:",
-		chan_ctxt->mhi_chan_state,
+		chan_ctxt->chstate,
 		"p_base:",
 		chan_ctxt->mhi_trb_ring_base_addr,
 		"v_base:",