Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 30c6a704 authored by Andrei Danaila's avatar Andrei Danaila Committed by Matt Wagantall
Browse files

mhi: core: Replace dma APIs 



Replace dma_to_virt and virt_to_dma with mhi_p2v_addr and mhi_v2p_addr

Change-Id: Ibda473254040cbd1f5fdf9eb463c14996d5fe12a
Signed-off-by: default avatarAndrei Danaila <adanaila@codeaurora.org>
parent e9806a3d

drivers/platform/msm/mhi/mhi.h

+5 −4
Original line number Diff line number Diff line
@@ -556,11 +556,12 @@ enum MHI_STATUS get_element_index(struct mhi_ring *ring, void *address, 
enum MHI_STATUS recycle_trb_and_ring(struct mhi_device_ctxt *mhi_dev_ctxt,

	struct mhi_ring *ring, enum MHI_RING_TYPE ring_type, u32 ring_index);

enum MHI_STATUS parse_xfer_event(struct mhi_device_ctxt *ctxt,

					union mhi_event_pkt *event);

enum MHI_EVENT_CCS get_cmd_pkt(union mhi_event_pkt *ev_pkt,

			       union mhi_cmd_pkt **cmd_pkt);

				union mhi_event_pkt *event, u32 event_id);

enum MHI_EVENT_CCS get_cmd_pkt(struct mhi_device_ctxt *mhi_dev_ctxt,

				union mhi_event_pkt *ev_pkt,

				union mhi_cmd_pkt **cmd_pkt, u32 event_index);

enum MHI_STATUS parse_cmd_event(struct mhi_device_ctxt *ctxt,

					union mhi_event_pkt *event);

				union mhi_event_pkt *event, u32 event_index);

int parse_event_thread(void *ctxt);

enum MHI_STATUS mhi_test_for_device_ready(

					struct mhi_device_ctxt *mhi_dev_ctxt);

drivers/platform/msm/mhi/mhi_event.c

+4 −2
Original line number Diff line number Diff line
@@ -180,7 +180,9 @@ void ring_ev_db(struct mhi_device_ctxt *mhi_dev_ctxt, u32 event_ring_index) 
	u64 db_value = 0;

	event_ctxt =

		&mhi_dev_ctxt->mhi_local_event_ctxt[event_ring_index];

	db_value = virt_to_dma(NULL, event_ctxt->wp);

	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);

}

drivers/platform/msm/mhi/mhi_init.c

+7 −3
Original line number Diff line number Diff line
@@ -286,15 +286,19 @@ static enum MHI_STATUS mhi_init_contexts(struct mhi_device_ctxt *mhi_dev_ctxt) 
{

	int r = 0;

	struct mhi_control_seg *mhi_ctrl = mhi_dev_ctxt->mhi_ctrl_seg;



	r = init_event_ctxt_array(mhi_dev_ctxt);

	if (r)

		return MHI_STATUS_ERROR;



	u64 phy_cmd_trb_addr;

	init_ecabap(mhi_dev_ctxt);

	/* Init Command Ring */

	phy_cmd_trb_addr =

	((uintptr_t)mhi_dev_ctxt->mhi_ctrl_seg->cmd_trb_list[PRIMARY_CMD_RING] -

		mhi_dev_ctxt->mhi_ctrl_seg_info->va_aligned)+

	    mhi_dev_ctxt->mhi_ctrl_seg_info->pa_aligned;

	mhi_cmd_ring_init(&mhi_ctrl->mhi_cmd_ctxt_list[PRIMARY_CMD_RING],

			virt_to_dma(NULL,

				mhi_ctrl->cmd_trb_list[PRIMARY_CMD_RING]),

			phy_cmd_trb_addr,

			(uintptr_t)mhi_ctrl->cmd_trb_list[PRIMARY_CMD_RING],

			CMD_EL_PER_RING,

			&mhi_dev_ctxt->mhi_local_cmd_ctxt[PRIMARY_CMD_RING]);

drivers/platform/msm/mhi/mhi_isr.c

+16 −7
Original line number Diff line number Diff line
@@ -82,8 +82,11 @@ static enum MHI_STATUS mhi_process_event_ring( 
	u32 event_code;



	ev_ctxt = &mhi_dev_ctxt->mhi_ctrl_seg->mhi_ec_list[ev_index];



	device_rp = dma_to_virt(NULL, ev_ctxt->mhi_event_read_ptr);

	device_rp = (union mhi_event_pkt *)mhi_p2v_addr(

						mhi_dev_ctxt,

						MHI_RING_TYPE_EVENT_RING,

						ev_index,

						ev_ctxt->mhi_event_read_ptr);

	local_rp = (union mhi_event_pkt *)local_ev_ctxt->rp;



	BUG_ON(validate_ev_el_addr(local_ev_ctxt, (uintptr_t)device_rp));
@@ -91,7 +94,8 @@ static enum MHI_STATUS mhi_process_event_ring( 
			(device_rp != NULL) && (local_rp != NULL)) {

		event_to_process = *local_rp;

		ev_ptr = &event_to_process;

		event_code = get_cmd_pkt(ev_ptr, &cmd_pkt);

		event_code = get_cmd_pkt(mhi_dev_ctxt,

					ev_ptr, &cmd_pkt, ev_index);

		if (((MHI_TRB_READ_INFO(EV_TRB_TYPE, (&event_to_process)) ==

		    MHI_PKT_TYPE_CMD_COMPLETION_EVENT)) &&

		    (event_code == MHI_EVENT_CC_SUCCESS)) {
@@ -125,11 +129,12 @@ static enum MHI_STATUS mhi_process_event_ring( 
			__pm_stay_awake(&mhi_dev_ctxt->w_lock);

			__pm_relax(&mhi_dev_ctxt->w_lock);

			ret_val = parse_cmd_event(mhi_dev_ctxt,

					&event_to_process);

					&event_to_process, ev_index);

			break;

		case MHI_PKT_TYPE_TX_EVENT:

			__pm_stay_awake(&mhi_dev_ctxt->w_lock);

			parse_xfer_event(mhi_dev_ctxt, &event_to_process);

			parse_xfer_event(mhi_dev_ctxt,

						&event_to_process, ev_index);

			__pm_relax(&mhi_dev_ctxt->w_lock);

			break;

		case MHI_PKT_TYPE_STATE_CHANGE_EVENT:
@@ -179,7 +184,11 @@ static enum MHI_STATUS mhi_process_event_ring( 
			break;

		}

		local_rp = (union mhi_event_pkt *)local_ev_ctxt->rp;

		device_rp = dma_to_virt(NULL, ev_ctxt->mhi_event_read_ptr);

		device_rp = (union mhi_event_pkt *)mhi_p2v_addr(

						mhi_dev_ctxt,

						MHI_RING_TYPE_EVENT_RING,

						ev_index,

						ev_ctxt->mhi_event_read_ptr);

		ret_val = MHI_STATUS_SUCCESS;

		--event_quota;

	}

drivers/platform/msm/mhi/mhi_main.c

+44 −25
Original line number Diff line number Diff line
@@ -293,7 +293,6 @@ static int populate_tre_ring(struct mhi_client_handle *client_handle) 
			   client_handle->chan_info.ev_ring,

			   &mhi_dev_ctxt->mhi_local_chan_ctxt[chan],

			   MHI_CHAN_STATE_ENABLED);



	mhi_log(MHI_MSG_INFO, "Exited\n");

	return 0;

}
@@ -461,7 +460,8 @@ void mhi_update_chan_db(struct mhi_device_ctxt *mhi_dev_ctxt, 
	u64 db_value;



	chan_ctxt = &mhi_dev_ctxt->mhi_local_chan_ctxt[chan];

	db_value = virt_to_dma(NULL, chan_ctxt->wp);

	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]++;

	if (IS_HARDWARE_CHANNEL(chan) && chan_ctxt->dir == MHI_IN) {

		if ((mhi_dev_ctxt->counters.chan_pkts_xferd[chan] %
@@ -524,15 +524,23 @@ static inline enum MHI_STATUS mhi_queue_tre(struct mhi_device_ctxt 
		if (likely(type == MHI_RING_TYPE_XFER_RING)) {

			spin_lock_irqsave(&mhi_dev_ctxt->db_write_lock[chan],

					   flags);

			db_value = virt_to_dma(NULL,

				mhi_dev_ctxt->mhi_local_chan_ctxt[chan].wp);

			db_value =

			 mhi_v2p_addr(

				mhi_dev_ctxt,

				MHI_RING_TYPE_XFER_RING,

				chan,

			(uintptr_t)mhi_dev_ctxt->mhi_local_chan_ctxt[chan].wp);

			mhi_dev_ctxt->mhi_chan_db_order[chan]++;

			mhi_update_chan_db(mhi_dev_ctxt, chan);

			spin_unlock_irqrestore(

			   &mhi_dev_ctxt->db_write_lock[chan], flags);

		} else if (type == MHI_RING_TYPE_CMD_RING) {

			db_value = virt_to_dma(NULL,

				mhi_dev_ctxt->mhi_local_cmd_ctxt->wp);

			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);

			mhi_dev_ctxt->cmd_ring_order++;

			mhi_process_db(mhi_dev_ctxt,

				mhi_dev_ctxt->mmio_info.cmd_db_addr,
@@ -599,7 +607,6 @@ enum MHI_STATUS mhi_queue_xfer(struct mhi_client_handle *client_handle, 
				"Failed to insert trb in xfer ring\n");

		goto error;

	}



	read_lock_irqsave(&mhi_dev_ctxt->xfer_lock, flags);

	atomic_inc(&mhi_dev_ctxt->flags.data_pending);

	if (MHI_OUT ==
@@ -808,7 +815,7 @@ static enum MHI_STATUS validate_xfer_el_addr(struct mhi_chan_ctxt *ring, 
}



enum MHI_STATUS parse_xfer_event(struct mhi_device_ctxt *ctxt,

					union mhi_event_pkt *event)

				union mhi_event_pkt *event, u32 event_id)

{

	struct mhi_device_ctxt *mhi_dev_ctxt = (struct mhi_device_ctxt *)ctxt;

	struct mhi_result *result;
@@ -865,7 +872,11 @@ enum MHI_STATUS parse_xfer_event(struct mhi_device_ctxt *ctxt, 
		}



		/* Get the TRB this event points to */

		local_ev_trb_loc = dma_to_virt(NULL, phy_ev_trb_loc);

		local_ev_trb_loc = (void *)mhi_p2v_addr(mhi_dev_ctxt,

					MHI_RING_TYPE_EVENT_RING, event_id,

					phy_ev_trb_loc);

		mhi_log(MHI_MSG_CRITICAL, "mhi_p2v_addr = %p\n",

						 local_ev_trb_loc);

		local_trb_loc = (union mhi_xfer_pkt *)local_chan_ctxt->rp;



		trace_mhi_tre(local_trb_loc, chan, 1);
@@ -938,7 +949,9 @@ enum MHI_STATUS parse_xfer_event(struct mhi_device_ctxt *ctxt, 
			&mhi_dev_ctxt->mhi_local_chan_ctxt[chan];

		mhi_log(MHI_MSG_INFO, "DB_MODE/OOB Detected chan %d.\n", chan);

		if (chan_ctxt->wp != chan_ctxt->rp) {

			db_value = virt_to_dma(NULL, chan_ctxt->wp);

			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,

				     mhi_dev_ctxt->mmio_info.chan_db_addr, chan,

				     db_value);
@@ -977,7 +990,8 @@ enum MHI_STATUS recycle_trb_and_ring(struct mhi_device_ctxt *mhi_dev_ctxt, 
	ret_val = ctxt_add_element(ring, &added_element);

	if (MHI_STATUS_SUCCESS != ret_val)

		mhi_log(MHI_MSG_ERROR, "Could not add element to ring\n");

	db_value = virt_to_dma(NULL, ring->wp);

	db_value = mhi_v2p_addr(mhi_dev_ctxt, ring_type, ring_index,

							(uintptr_t) ring->wp);

	if (MHI_STATUS_SUCCESS != ret_val)

		return ret_val;

	if (MHI_RING_TYPE_XFER_RING == ring_type) {
@@ -998,11 +1012,11 @@ enum MHI_STATUS recycle_trb_and_ring(struct mhi_device_ctxt *mhi_dev_ctxt, 


		lock = &mhi_dev_ctxt->mhi_ev_spinlock_list[ring_index];

		spin_lock_irqsave(lock, flags);

		db_value = virt_to_dma(NULL, ring->wp);

		db_value = mhi_v2p_addr(mhi_dev_ctxt, ring_type, ring_index,

							(uintptr_t) ring->wp);

		mhi_update_ctxt(mhi_dev_ctxt,

				mhi_dev_ctxt->mmio_info.event_db_addr,

				ring_index, db_value);



		mhi_dev_ctxt->mhi_ev_db_order[ring_index] = 1;

		mhi_dev_ctxt->counters.ev_counter[ring_index]++;

		spin_unlock_irqrestore(lock, flags);
@@ -1036,7 +1050,9 @@ enum MHI_STATUS recycle_trb_and_ring(struct mhi_device_ctxt *mhi_dev_ctxt, 
			mhi_dev_ctxt->mhi_ev_db_order[ring_index] = 1;

			if ((mhi_dev_ctxt->counters.ev_counter[ring_index] %

						MHI_EV_DB_INTERVAL) == 0) {

				db_value = virt_to_dma(NULL, ring->wp);

				db_value = mhi_v2p_addr(mhi_dev_ctxt, ring_type,

							ring_index,

							(uintptr_t) ring->wp);

				mhi_process_db(mhi_dev_ctxt,

					mhi_dev_ctxt->mmio_info.event_db_addr,

					ring_index, db_value);
@@ -1078,9 +1094,9 @@ static enum MHI_STATUS reset_chan_cmd(struct mhi_device_ctxt *mhi_dev_ctxt, 
	struct mutex *chan_mutex;

	int pending_el = 0;

	struct mhi_ring *ring;



	MHI_TRB_GET_INFO(CMD_TRB_CHID, cmd_pkt, chan);





	if (!VALID_CHAN_NR(chan)) {

		mhi_log(MHI_MSG_ERROR,

			"Bad channel number for CCE\n");
@@ -1101,7 +1117,6 @@ static enum MHI_STATUS reset_chan_cmd(struct mhi_device_ctxt *mhi_dev_ctxt, 
	ring = &mhi_dev_ctxt->mhi_local_chan_ctxt[chan];

	if (ring->dir == MHI_OUT)

		get_nr_enclosed_el(ring, ring->rp, ring->wp, &pending_el);



	mhi_log(MHI_MSG_INFO, "Decrementing chan %d out acks by %d.\n",

				chan, pending_el);
@@ -1140,9 +1155,10 @@ static enum MHI_STATUS start_chan_cmd(struct mhi_device_ctxt *mhi_dev_ctxt, 
		&mhi_dev_ctxt->client_handle_list[chan]->chan_open_complete);

	return MHI_STATUS_SUCCESS;

}



enum MHI_EVENT_CCS get_cmd_pkt(union mhi_event_pkt *ev_pkt,

			       union mhi_cmd_pkt **cmd_pkt)

enum MHI_EVENT_CCS get_cmd_pkt(struct mhi_device_ctxt *mhi_dev_ctxt,

				union mhi_event_pkt *ev_pkt,

				union mhi_cmd_pkt **cmd_pkt,

				u32 event_index)

{

	uintptr_t phy_trb_loc = 0;

	if (NULL != ev_pkt)
@@ -1150,17 +1166,20 @@ enum MHI_EVENT_CCS get_cmd_pkt(union mhi_event_pkt *ev_pkt, 
							ev_pkt);

	else

		return MHI_STATUS_ERROR;

	*cmd_pkt = dma_to_virt(NULL, phy_trb_loc);

	*cmd_pkt = (union mhi_cmd_pkt *)mhi_p2v_addr(mhi_dev_ctxt,

					MHI_RING_TYPE_CMD_RING, event_index,

					 phy_trb_loc);

	mhi_log(MHI_MSG_INFO, "mhi_p2v_addr %p\n", (void *)(*cmd_pkt));

	return MHI_EV_READ_CODE(EV_TRB_CODE, ev_pkt);

}



enum MHI_STATUS parse_cmd_event(struct mhi_device_ctxt *mhi_dev_ctxt,

						union mhi_event_pkt *ev_pkt)

				union mhi_event_pkt *ev_pkt, u32 event_index)

{

	enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;

	union mhi_cmd_pkt *cmd_pkt = NULL;

	u32 event_code;

	event_code = get_cmd_pkt(ev_pkt, &cmd_pkt);

	event_code = get_cmd_pkt(mhi_dev_ctxt, ev_pkt, &cmd_pkt, event_index);

	switch (event_code) {

	case MHI_EVENT_CC_SUCCESS:

	{
@@ -1238,8 +1257,9 @@ int mhi_poll_inbound(struct mhi_client_handle *client_handle, 
					&local_chan_ctxt->ack_rp,

					&local_chan_ctxt->rp, NULL);

		if (ret_val != MHI_STATUS_SUCCESS) {

			mhi_log(MHI_MSG_ERROR,

				"Internal Failure, inconsistent ring state, ret %d chan %d\n",

			mhi_log(

			MHI_MSG_ERROR,

			"Internal Failure,inconsistent ring,ret %d chan %d\n",

				ret_val, chan);

			result->payload_buf = 0;

			result->bytes_xferd = 0;
@@ -1367,7 +1387,6 @@ enum MHI_STATUS mhi_deregister_channel(struct mhi_client_handle 
	kfree(client_handle);

	return ret_val;

}



EXPORT_SYMBOL(mhi_deregister_channel);



void mhi_process_db(struct mhi_device_ctxt *mhi_dev_ctxt,