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

Commit bf6c965f authored by Skylar Chang's avatar Skylar Chang
Browse files

msm: ipa3: recycle skb for lan data path 



For IPA LAN data path and exception path IPA driver allocates 8KB
buffers to be used as credits for IPA. When a packet is available for
a client, IPA driver allocates a new skb and copies the data to it
prior giving the skb to the client. This change is adding skb recycling
of the 8KB skb for performance improvement as these skbs are internal to
IPA driver.

Change-Id: I6f653add7b9886ba775ecfe0b9cc4e96390dade9
CRs-Fixed: 968045
Acked by: Ady Abraham <adya@qti.qualcomm.com>
Signed-off-by: default avatarSkylar Chang <chiaweic@codeaurora.org>
parent 27c8b456

drivers/platform/msm/ipa/ipa_v3/ipa_dp.c

+148 −11
Original line number Diff line number Diff line
@@ -59,6 +59,7 @@ static struct sk_buff *ipa3_get_skb_ipa_rx(unsigned int len, gfp_t flags); 
static void ipa3_replenish_wlan_rx_cache(struct ipa3_sys_context *sys);

static void ipa3_replenish_rx_cache(struct ipa3_sys_context *sys);

static void ipa3_replenish_rx_work_func(struct work_struct *work);

static void ipa3_fast_replenish_rx_cache(struct ipa3_sys_context *sys);

static void ipa3_wq_handle_rx(struct work_struct *work);

static void ipa3_wq_handle_tx(struct work_struct *work);

static void ipa3_wq_rx_common(struct ipa3_sys_context *sys, u32 size);
@@ -1111,6 +1112,7 @@ int ipa3_setup_sys_pipe(struct ipa_sys_connect_params *sys_in, u32 *clnt_hdl) 
		}



		INIT_LIST_HEAD(&ep->sys->head_desc_list);

		INIT_LIST_HEAD(&ep->sys->rcycl_list);

		spin_lock_init(&ep->sys->spinlock);

	} else {

		memset(ep->sys, 0, offsetof(struct ipa3_sys_context, ep));
@@ -1255,9 +1257,7 @@ int ipa3_setup_sys_pipe(struct ipa_sys_connect_params *sys_in, u32 *clnt_hdl) 
		atomic_inc(&ipa3_ctx->wc_memb.active_clnt_cnt);

	}



	if (nr_cpu_ids > 1 &&

		(sys_in->client == IPA_CLIENT_APPS_LAN_CONS ||

		 sys_in->client == IPA_CLIENT_APPS_WAN_CONS)) {

	if (ep->sys->repl_hdlr == ipa3_fast_replenish_rx_cache) {

		ep->sys->repl.capacity = ep->sys->rx_pool_sz + 1;

		ep->sys->repl.cache = kzalloc(ep->sys->repl.capacity *

				sizeof(void *), GFP_KERNEL);
@@ -1953,6 +1953,113 @@ fail_kmem_cache_alloc: 
				msecs_to_jiffies(1));

}



static void ipa3_replenish_rx_cache_recycle(struct ipa3_sys_context *sys)

{

	void *ptr;

	struct ipa3_rx_pkt_wrapper *rx_pkt;

	int ret;

	int rx_len_cached = 0;

	struct gsi_xfer_elem gsi_xfer_elem_one;

	gfp_t flag = GFP_NOWAIT | __GFP_NOWARN;



	rx_len_cached = sys->len;



	while (rx_len_cached < sys->rx_pool_sz) {

		if (list_empty(&sys->rcycl_list)) {

			rx_pkt = kmem_cache_zalloc(

				ipa3_ctx->rx_pkt_wrapper_cache, flag);

			if (!rx_pkt) {

				IPAERR("failed to alloc rx wrapper\n");

				goto fail_kmem_cache_alloc;

			}



			INIT_LIST_HEAD(&rx_pkt->link);

			INIT_WORK(&rx_pkt->work, ipa3_wq_rx_avail);

			rx_pkt->sys = sys;



			rx_pkt->data.skb = sys->get_skb(sys->rx_buff_sz, flag);

			if (rx_pkt->data.skb == NULL) {

				IPAERR("failed to alloc skb\n");

				kmem_cache_free(ipa3_ctx->rx_pkt_wrapper_cache,

					rx_pkt);

				goto fail_kmem_cache_alloc;

			}

			ptr = skb_put(rx_pkt->data.skb, sys->rx_buff_sz);

			rx_pkt->data.dma_addr = dma_map_single(ipa3_ctx->pdev,

				ptr, sys->rx_buff_sz, DMA_FROM_DEVICE);

			if (rx_pkt->data.dma_addr == 0 ||

				rx_pkt->data.dma_addr == ~0) {

				IPAERR("dma_map_single failure %p for %p\n",

					(void *)rx_pkt->data.dma_addr, ptr);

				goto fail_dma_mapping;

			}

		} else {

			spin_lock_bh(&sys->spinlock);

			rx_pkt = list_first_entry(&sys->rcycl_list,

				struct ipa3_rx_pkt_wrapper, link);

			list_del(&rx_pkt->link);

			spin_unlock_bh(&sys->spinlock);

			INIT_LIST_HEAD(&rx_pkt->link);

			ptr = skb_put(rx_pkt->data.skb, sys->rx_buff_sz);

			rx_pkt->data.dma_addr = dma_map_single(ipa3_ctx->pdev,

				ptr, sys->rx_buff_sz, DMA_FROM_DEVICE);

			if (rx_pkt->data.dma_addr == 0 ||

				rx_pkt->data.dma_addr == ~0) {

				IPAERR("dma_map_single failure %p for %p\n",

					(void *)rx_pkt->data.dma_addr, ptr);

				goto fail_dma_mapping;

			}

		}



		list_add_tail(&rx_pkt->link, &sys->head_desc_list);

		rx_len_cached = ++sys->len;

		if (ipa3_ctx->transport_prototype ==

				IPA_TRANSPORT_TYPE_GSI) {

			memset(&gsi_xfer_elem_one, 0,

				sizeof(gsi_xfer_elem_one));

			gsi_xfer_elem_one.addr = rx_pkt->data.dma_addr;

			gsi_xfer_elem_one.len = sys->rx_buff_sz;

			gsi_xfer_elem_one.flags |= GSI_XFER_FLAG_EOT;

			gsi_xfer_elem_one.type = GSI_XFER_ELEM_DATA;

			gsi_xfer_elem_one.xfer_user_data = rx_pkt;



			ret = gsi_queue_xfer(sys->ep->gsi_chan_hdl,

					1, &gsi_xfer_elem_one, true);

			if (ret != GSI_STATUS_SUCCESS) {

				IPAERR("failed to provide buffer: %d\n",

					ret);

				goto fail_provide_rx_buffer;

			}

		} else {

			ret = sps_transfer_one(sys->ep->ep_hdl,

				rx_pkt->data.dma_addr, sys->rx_buff_sz,

				rx_pkt, 0);



			if (ret) {

				IPAERR("sps_transfer_one failed %d\n", ret);

				goto fail_provide_rx_buffer;

			}

		}

	}



	return;

fail_provide_rx_buffer:

	rx_len_cached = --sys->len;

	list_del(&rx_pkt->link);

	INIT_LIST_HEAD(&rx_pkt->link);

	dma_unmap_single(ipa3_ctx->pdev, rx_pkt->data.dma_addr,

		sys->rx_buff_sz, DMA_FROM_DEVICE);

fail_dma_mapping:

	spin_lock_bh(&sys->spinlock);

	list_add_tail(&rx_pkt->link, &sys->rcycl_list);

	INIT_LIST_HEAD(&rx_pkt->link);

	spin_unlock_bh(&sys->spinlock);

fail_kmem_cache_alloc:

	if (rx_len_cached == 0)

		queue_delayed_work(sys->wq, &sys->replenish_rx_work,

		msecs_to_jiffies(1));

}



static void ipa3_fast_replenish_rx_cache(struct ipa3_sys_context *sys)

{

	struct ipa3_rx_pkt_wrapper *rx_pkt;
@@ -2052,6 +2159,15 @@ static void ipa3_cleanup_rx(struct ipa3_sys_context *sys) 
		kmem_cache_free(ipa3_ctx->rx_pkt_wrapper_cache, rx_pkt);

	}



	list_for_each_entry_safe(rx_pkt, r,

				 &sys->rcycl_list, link) {

		list_del(&rx_pkt->link);

		dma_unmap_single(ipa3_ctx->pdev, rx_pkt->data.dma_addr,

			sys->rx_buff_sz, DMA_FROM_DEVICE);

		sys->free_skb(rx_pkt->data.skb);

		kmem_cache_free(ipa3_ctx->rx_pkt_wrapper_cache, rx_pkt);

	}



	if (sys->repl.cache) {

		head = atomic_read(&sys->repl.head_idx);

		tail = atomic_read(&sys->repl.tail_idx);
@@ -2335,7 +2451,6 @@ begin: 
		}

	};



	sys->free_skb(skb);

	return rc;

}
@@ -2590,6 +2705,16 @@ void ipa3_lan_rx_cb(void *priv, enum ipa_dp_evt_type evt, unsigned long data) 
	ep->client_notify(ep->priv, IPA_RECEIVE, (unsigned long)(rx_skb));

}



static void ipa3_recycle_rx_wrapper(struct ipa3_rx_pkt_wrapper *rx_pkt)

{

	rx_pkt->data.dma_addr = 0;

	ipa3_skb_recycle(rx_pkt->data.skb);

	INIT_LIST_HEAD(&rx_pkt->link);

	spin_lock_bh(&rx_pkt->sys->spinlock);

	list_add_tail(&rx_pkt->link, &rx_pkt->sys->rcycl_list);

	spin_unlock_bh(&rx_pkt->sys->spinlock);

}



static void ipa3_wq_rx_common(struct ipa3_sys_context *sys, u32 size)

{

	struct ipa3_rx_pkt_wrapper *rx_pkt_expected;
@@ -2614,9 +2739,8 @@ static void ipa3_wq_rx_common(struct ipa3_sys_context *sys, u32 size) 
	*(unsigned int *)rx_skb->cb = rx_skb->len;

	rx_skb->truesize = rx_pkt_expected->len + sizeof(struct sk_buff);

	sys->pyld_hdlr(rx_skb, sys);

	sys->free_rx_wrapper(rx_pkt_expected);

	sys->repl_hdlr(sys);

	kmem_cache_free(ipa3_ctx->rx_pkt_wrapper_cache, rx_pkt_expected);



}



static void ipa3_wlan_wq_rx_common(struct ipa3_sys_context *sys, u32 size)
@@ -2721,6 +2845,11 @@ static int ipa3_odu_rx_pyld_hdlr(struct sk_buff *rx_skb, 
	return 0;

}



static void ipa3_free_rx_wrapper(struct ipa3_rx_pkt_wrapper *rk_pkt)

{

	kmem_cache_free(ipa3_ctx->rx_pkt_wrapper_cache, rk_pkt);

}



static int ipa3_assign_policy(struct ipa_sys_connect_params *in,

		struct ipa3_sys_context *sys)

{
@@ -2784,19 +2913,25 @@ static int ipa3_assign_policy(struct ipa_sys_connect_params *in, 
				IPA_GENERIC_AGGR_PKT_LIMIT;

			if (in->client == IPA_CLIENT_APPS_LAN_CONS) {

				sys->pyld_hdlr = ipa3_lan_rx_pyld_hdlr;

				sys->repl_hdlr =

					ipa3_replenish_rx_cache_recycle;

				sys->free_rx_wrapper =

					ipa3_recycle_rx_wrapper;

				sys->rx_pool_sz =

					IPA_GENERIC_RX_POOL_SZ;

			} else if (in->client ==

					IPA_CLIENT_APPS_WAN_CONS) {

				sys->pyld_hdlr = ipa3_wan_rx_pyld_hdlr;

				sys->rx_pool_sz =

					ipa3_ctx->wan_rx_ring_size;

			}

				sys->free_rx_wrapper = ipa3_free_rx_wrapper;

				if (nr_cpu_ids > 1)

					sys->repl_hdlr =

						ipa3_fast_replenish_rx_cache;

				else

				sys->repl_hdlr = ipa3_replenish_rx_cache;

					sys->repl_hdlr =

						ipa3_replenish_rx_cache;

				sys->rx_pool_sz =

					ipa3_ctx->wan_rx_ring_size;

			}

		} else if (IPA_CLIENT_IS_WLAN_CONS(in->client)) {

			IPADBG("assigning policy to client:%d",

				in->client);
@@ -2819,6 +2954,7 @@ static int ipa3_assign_policy(struct ipa_sys_connect_params *in, 
			sys->pyld_hdlr = NULL;

			sys->get_skb = ipa3_get_skb_ipa_rx;

			sys->free_skb = ipa3_free_skb_rx;

			sys->free_rx_wrapper = ipa3_free_rx_wrapper;

			in->ipa_ep_cfg.aggr.aggr_en = IPA_BYPASS_AGGR;

		} else if (IPA_CLIENT_IS_ODU_CONS(in->client)) {

			IPADBG("assigning policy to client:%d",
@@ -2842,6 +2978,7 @@ static int ipa3_assign_policy(struct ipa_sys_connect_params *in, 
			sys->pyld_hdlr = ipa3_odu_rx_pyld_hdlr;

			sys->get_skb = ipa3_get_skb_ipa_rx;

			sys->free_skb = ipa3_free_skb_rx;

			sys->free_rx_wrapper = ipa3_free_rx_wrapper;

			sys->repl_hdlr = ipa3_replenish_rx_cache;

		} else if (in->client ==

				IPA_CLIENT_MEMCPY_DMA_ASYNC_CONS) {

drivers/platform/msm/ipa/ipa_v3/ipa_i.h

+2 −0
Original line number Diff line number Diff line
@@ -812,6 +812,7 @@ struct ipa3_sys_context { 
	int (*pyld_hdlr)(struct sk_buff *skb, struct ipa3_sys_context *sys);

	struct sk_buff * (*get_skb)(unsigned int len, gfp_t flags);

	void (*free_skb)(struct sk_buff *skb);

	void (*free_rx_wrapper)(struct ipa3_rx_pkt_wrapper *rk_pkt);

	u32 rx_buff_sz;

	u32 rx_pool_sz;

	struct sk_buff *prev_skb;
@@ -829,6 +830,7 @@ struct ipa3_sys_context { 
	/* ordering is important - mutable fields go above */

	struct ipa3_ep_context *ep;

	struct list_head head_desc_list;

	struct list_head rcycl_list;

	spinlock_t spinlock;

	struct workqueue_struct *wq;

	struct workqueue_struct *repl_wq;