Re: [PATCH v3 13/25] bus: mhi: ep: Add support for sending events to the host

[Alex Elder <elder@linaro.org>]

On 2/12/22 12:21 PM, Manivannan Sadhasivam wrote:
> Add support for sending the events to the host over MHI bus from the
> endpoint. Following events are supported:
> 
> 1. Transfer completion event
> 2. Command completion event
> 3. State change event
> 4. Execution Environment (EE) change event
> 
> An event is sent whenever an operation has been completed in the MHI EP
> device. Event is sent using the MHI event ring and additionally the host
> is notified using an IRQ if required.
> 
> Signed-off-by: Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>

A few things can be simplified here.

					-Alex

> ---
>   drivers/bus/mhi/common.h      |  15 ++++
>   drivers/bus/mhi/ep/internal.h |   8 ++-
>   drivers/bus/mhi/ep/main.c     | 126 ++++++++++++++++++++++++++++++++++
>   include/linux/mhi_ep.h        |   8 +++
>   4 files changed, 155 insertions(+), 2 deletions(-)
> 
> diff --git a/drivers/bus/mhi/common.h b/drivers/bus/mhi/common.h
> index 728c82928d8d..26d94ed52b34 100644
> --- a/drivers/bus/mhi/common.h
> +++ b/drivers/bus/mhi/common.h
> @@ -176,6 +176,21 @@
>   #define MHI_TRE_GET_EV_LINKSPEED(tre)			((MHI_TRE_GET_DWORD(tre, 1) >> 24) & 0xFF)
>   #define MHI_TRE_GET_EV_LINKWIDTH(tre)			(MHI_TRE_GET_DWORD(tre, 0) & 0xFF)
>   
> +/* State change event */
> +#define MHI_SC_EV_PTR					0
> +#define MHI_SC_EV_DWORD0(state)				cpu_to_le32(state << 24)
> +#define MHI_SC_EV_DWORD1(type)				cpu_to_le32(type << 16)
> +
> +/* EE event */
> +#define MHI_EE_EV_PTR					0
> +#define MHI_EE_EV_DWORD0(ee)				cpu_to_le32(ee << 24)
> +#define MHI_EE_EV_DWORD1(type)				cpu_to_le32(type << 16)
> +
> +/* Command Completion event */
> +#define MHI_CC_EV_PTR(ptr)				cpu_to_le64(ptr)
> +#define MHI_CC_EV_DWORD0(code)				cpu_to_le32(code << 24)
> +#define MHI_CC_EV_DWORD1(type)				cpu_to_le32(type << 16)
> +
>   /* Transfer descriptor macros */
>   #define MHI_TRE_DATA_PTR(ptr)				cpu_to_le64(ptr)
>   #define MHI_TRE_DATA_DWORD0(len)			cpu_to_le32(len & MHI_MAX_MTU)
> diff --git a/drivers/bus/mhi/ep/internal.h b/drivers/bus/mhi/ep/internal.h
> index 48d6e9667d55..fd63f79c6aec 100644
> --- a/drivers/bus/mhi/ep/internal.h
> +++ b/drivers/bus/mhi/ep/internal.h
> @@ -131,8 +131,8 @@ enum mhi_ep_ring_type {
>   };
>   
>   struct mhi_ep_ring_element {
> -	u64 ptr;
> -	u32 dword[2];
> +	__le64 ptr;
> +	__le32 dword[2];

Yay!

>   };
>   
>   /* Ring element */
> @@ -227,4 +227,8 @@ void mhi_ep_mmio_get_mhi_state(struct mhi_ep_cntrl *mhi_cntrl, enum mhi_state *s
>   void mhi_ep_mmio_init(struct mhi_ep_cntrl *mhi_cntrl);
>   void mhi_ep_mmio_update_ner(struct mhi_ep_cntrl *mhi_cntrl);
>   
> +/* MHI EP core functions */
> +int mhi_ep_send_state_change_event(struct mhi_ep_cntrl *mhi_cntrl, enum mhi_state state);
> +int mhi_ep_send_ee_event(struct mhi_ep_cntrl *mhi_cntrl, enum mhi_ep_execenv exec_env);
> +
>   #endif
> diff --git a/drivers/bus/mhi/ep/main.c b/drivers/bus/mhi/ep/main.c
> index 2c8045766292..61f066c6286b 100644
> --- a/drivers/bus/mhi/ep/main.c
> +++ b/drivers/bus/mhi/ep/main.c
> @@ -18,6 +18,131 @@
>   
>   static DEFINE_IDA(mhi_ep_cntrl_ida);
>   
> +static int mhi_ep_send_event(struct mhi_ep_cntrl *mhi_cntrl, u32 ring_idx,
> +			     struct mhi_ep_ring_element *el)
> +{
> +	struct device *dev = &mhi_cntrl->mhi_dev->dev;
> +	union mhi_ep_ring_ctx *ctx;
> +	struct mhi_ep_ring *ring;
> +	int ret;
> +
> +	mutex_lock(&mhi_cntrl->event_lock);
> +	ring = &mhi_cntrl->mhi_event[ring_idx].ring;
> +	ctx = (union mhi_ep_ring_ctx *)&mhi_cntrl->ev_ctx_cache[ring_idx];
> +	if (!ring->started) {
> +		ret = mhi_ep_ring_start(mhi_cntrl, ring, ctx);
> +		if (ret) {
> +			dev_err(dev, "Error starting event ring (%d)\n", ring_idx);
> +			goto err_unlock;
> +		}
> +	}
> +
> +	/* Add element to the event ring */
> +	ret = mhi_ep_ring_add_element(ring, el);
> +	if (ret) {
> +		dev_err(dev, "Error adding element to event ring (%d)\n", ring_idx);
> +		goto err_unlock;
> +	}
> +
> +	/* Ensure that the ring pointer gets updated in host memory before triggering IRQ */
> +	smp_wmb();

I think the barrier might already be provided by the mutex_unlock().

> +
> +	mutex_unlock(&mhi_cntrl->event_lock);
> +
> +	/*
> +	 * Raise IRQ to host only if the BEI flag is not set in TRE. Host might
> +	 * set this flag for interrupt moderation as per MHI protocol.
> +	 */

I don't think the BEI flag is meaningful in an event ring element.
You'd want to determine if it was present in the *transfer* ring
element for which this event is signaling the completion.

> +	if (!MHI_EP_TRE_GET_BEI(el))
> +		mhi_cntrl->raise_irq(mhi_cntrl, ring->irq_vector);
> +
> +	return 0;
> +
> +err_unlock:
> +	mutex_unlock(&mhi_cntrl->event_lock);
> +
> +	return ret;
> +}
> +
> +static int mhi_ep_send_completion_event(struct mhi_ep_cntrl *mhi_cntrl,
> +					struct mhi_ep_ring *ring, u32 len,
> +					enum mhi_ev_ccs code)
> +{
> +	struct mhi_ep_ring_element event = {};
> +	__le32 tmp;
> +
> +	event.ptr = le64_to_cpu(ring->ring_ctx->generic.rbase) +
> +			ring->rd_offset * sizeof(struct mhi_ep_ring_element);

I'm not sure at the moment where this will be called.  But
it might be easier to pass in the transfer channel pointer
rather than compute its address here.

> +
> +	tmp = event.dword[0];

You already know event.dword[0] is zero.  No need to read
its value here (or that of dword[1] below).

> +	tmp |= MHI_TRE_EV_DWORD0(code, len);
> +	event.dword[0] = tmp;
> +
> +	tmp = event.dword[1];
> +	tmp |= MHI_TRE_EV_DWORD1(ring->ch_id, MHI_PKT_TYPE_TX_EVENT);
> +	event.dword[1] = tmp;
> +
> +	return mhi_ep_send_event(mhi_cntrl, ring->er_index, &event);
> +}
> +
> +int mhi_ep_send_state_change_event(struct mhi_ep_cntrl *mhi_cntrl, enum mhi_state state)
> +{
> +	struct mhi_ep_ring_element event = {};
> +	__le32 tmp;
> +
> +	tmp = event.dword[0];

No need to read a known zero value.  (Fix this througout.)

> +	tmp |= MHI_SC_EV_DWORD0(state);
> +	event.dword[0] = tmp;
> +
> +	tmp = event.dword[1];
> +	tmp |= MHI_SC_EV_DWORD1(MHI_PKT_TYPE_STATE_CHANGE_EVENT);
> +	event.dword[1] = tmp;
> +
> +	return mhi_ep_send_event(mhi_cntrl, 0, &event);
> +}
> +
> +int mhi_ep_send_ee_event(struct mhi_ep_cntrl *mhi_cntrl, enum mhi_ep_execenv exec_env)
> +{
> +	struct mhi_ep_ring_element event = {};
> +	__le32 tmp;
> +
> +	tmp = event.dword[0];
> +	tmp |= MHI_EE_EV_DWORD0(exec_env);
> +	event.dword[0] = tmp;
> +
> +	tmp = event.dword[1];
> +	tmp |= MHI_SC_EV_DWORD1(MHI_PKT_TYPE_EE_EVENT);
> +	event.dword[1] = tmp;
> +
> +	return mhi_ep_send_event(mhi_cntrl, 0, &event);
> +}
> +
> +static int mhi_ep_send_cmd_comp_event(struct mhi_ep_cntrl *mhi_cntrl, enum mhi_ev_ccs code)
> +{
> +	struct device *dev = &mhi_cntrl->mhi_dev->dev;
> +	struct mhi_ep_ring_element event = {};
> +	__le32 tmp;
> +
> +	if (code > MHI_EV_CC_BAD_TRE) {

I think you can probably guarantee this won't ever happen

> +		dev_err(dev, "Invalid command completion code (%d)\n", code);
> +		return -EINVAL;
> +	}
> +
> +	event.ptr = le64_to_cpu(mhi_cntrl->cmd_ctx_cache->rbase)
> +			+ (mhi_cntrl->mhi_cmd->ring.rd_offset *
> +			(sizeof(struct mhi_ep_ring_element)));

No need for the parentheses around the sizeof() call.  Here too
it might be easier and clearer to pass in the command ring element
this event is signaling the completion of.

> +
> +	tmp = event.dword[0];
> +	tmp |= MHI_CC_EV_DWORD0(code);
> +	event.dword[0] = tmp;
> +
> +	tmp = event.dword[1];
> +	tmp |= MHI_CC_EV_DWORD1(MHI_PKT_TYPE_CMD_COMPLETION_EVENT);
> +	event.dword[1] = tmp;
> +
> +	return mhi_ep_send_event(mhi_cntrl, 0, &event);
> +}
> +
>   static void mhi_ep_ring_worker(struct work_struct *work)
>   {
>   	struct mhi_ep_cntrl *mhi_cntrl = container_of(work,
> @@ -270,6 +395,7 @@ int mhi_ep_register_controller(struct mhi_ep_cntrl *mhi_cntrl,
>   
>   	INIT_LIST_HEAD(&mhi_cntrl->ch_db_list);
>   	spin_lock_init(&mhi_cntrl->list_lock);
> +	mutex_init(&mhi_cntrl->event_lock);
>   
>   	/* Set MHI version and AMSS EE before enumeration */
>   	mhi_ep_mmio_write(mhi_cntrl, MHIVER, config->mhi_version);
> diff --git a/include/linux/mhi_ep.h b/include/linux/mhi_ep.h
> index 33828a6c4e63..062133a68118 100644
> --- a/include/linux/mhi_ep.h
> +++ b/include/linux/mhi_ep.h
> @@ -59,6 +59,9 @@ struct mhi_ep_db_info {
>    * @mhi_event: Points to the event ring configurations table
>    * @mhi_cmd: Points to the command ring configurations table
>    * @sm: MHI Endpoint state machine
> + * @ch_ctx_cache: Cache of host channel context data structure
> + * @ev_ctx_cache: Cache of host event context data structure
> + * @cmd_ctx_cache: Cache of host command context data structure
>    * @ch_ctx_host_pa: Physical address of host channel context data structure
>    * @ev_ctx_host_pa: Physical address of host event context data structure
>    * @cmd_ctx_host_pa: Physical address of host command context data structure
> @@ -67,6 +70,7 @@ struct mhi_ep_db_info {
>    * @ch_db_list: List of queued channel doorbells
>    * @st_transition_list: List of state transitions
>    * @list_lock: Lock for protecting state transition and channel doorbell lists
> + * @event_lock: Lock for protecting event rings
>    * @chdb: Array of channel doorbell interrupt info
>    * @raise_irq: CB function for raising IRQ to the host
>    * @alloc_addr: CB function for allocating memory in endpoint for storing host context
> @@ -94,6 +98,9 @@ struct mhi_ep_cntrl {
>   	struct mhi_ep_cmd *mhi_cmd;
>   	struct mhi_ep_sm *sm;
>   
> +	struct mhi_chan_ctxt *ch_ctx_cache;
> +	struct mhi_event_ctxt *ev_ctx_cache;
> +	struct mhi_cmd_ctxt *cmd_ctx_cache;
>   	u64 ch_ctx_host_pa;
>   	u64 ev_ctx_host_pa;
>   	u64 cmd_ctx_host_pa;
> @@ -104,6 +111,7 @@ struct mhi_ep_cntrl {
>   	struct list_head ch_db_list;
>   	struct list_head st_transition_list;
>   	spinlock_t list_lock;
> +	struct mutex event_lock;
>   	struct mhi_ep_db_info chdb[4];
>   
>   	void (*raise_irq)(struct mhi_ep_cntrl *mhi_cntrl, u32 vector);