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

Commit d089640b authored by Govind Singh's avatar Govind Singh Committed by Gerrit - the friendly Code Review server
Browse files

ath10k: Add host/target CE config and services for WCN3990 



WCN3990 target uses following CE config.
[CE0] :host->target control and raw streams
[CE1] :target->host HTT
[CE2] :target->host WMI
[CE3] :host->target WMI
[CE4] :host->target HTT
[CE5] :ipa_uc->target control msg
[CE6] :Target autonomous HIF_memcpy
[CE7] :ce_diag, the Diagnostic Window
[CE8] :Target to uMC
[CE9] :target->host HTT
[CE10] :target->host HTT
[CE11] :target -> host PKTLOG

Add host/target CE config and services and
associated host to target callbacks.

CRs-Fixed: 1116442
Change-Id: I2ae997b4d3f2b8028fe0deaae24b19dbf178aa5a
Signed-off-by: default avatarGovind Singh <govinds@codeaurora.org>
Signed-off-by: default avatarSarada Prasanna Garnayak <sgarna@codeaurora.org>
parent 3a276152

drivers/net/wireless/ath/ath10k/htc.c

+8 −0
Original line number Diff line number Diff line
@@ -451,8 +451,16 @@ static const char *htc_service_name(enum ath10k_htc_svc_id id) 
		return "NMI Data";

	case ATH10K_HTC_SVC_ID_HTT_DATA_MSG:

		return "HTT Data";

	case ATH10K_HTC_SVC_ID_HTT_DATA2_MSG:

		return "HTT Data";

	case ATH10K_HTC_SVC_ID_HTT_DATA3_MSG:

		return "HTT Data";

	case ATH10K_HTC_SVC_ID_HTT_IPA_MSG:

		return "IPA";

	case ATH10K_HTC_SVC_ID_TEST_RAW_STREAMS:

		return "RAW";

	case ATH10K_HTC_SVC_ID_HTT_LOG_MSG:

		return "PKTLOG";

	}



	return "Unknown";

drivers/net/wireless/ath/ath10k/htc.h

+6 −2
Original line number Diff line number Diff line
@@ -222,7 +222,8 @@ enum ath10k_htc_svc_gid { 
	ATH10K_HTC_SVC_GRP_WMI = 1,

	ATH10K_HTC_SVC_GRP_NMI = 2,

	ATH10K_HTC_SVC_GRP_HTT = 3,



	ATH10K_IPA_SERVICE_GROUP = 5,

	ATH10K_LOG_SERVICE_GROUP = 6,

	ATH10K_HTC_SVC_GRP_TEST = 254,

	ATH10K_HTC_SVC_GRP_LAST = 255,

};
@@ -246,7 +247,10 @@ enum ath10k_htc_svc_id { 
	ATH10K_HTC_SVC_ID_NMI_DATA	= SVC(ATH10K_HTC_SVC_GRP_NMI, 1),



	ATH10K_HTC_SVC_ID_HTT_DATA_MSG	= SVC(ATH10K_HTC_SVC_GRP_HTT, 0),



	ATH10K_HTC_SVC_ID_HTT_DATA2_MSG = SVC(ATH10K_HTC_SVC_GRP_HTT, 1),

	ATH10K_HTC_SVC_ID_HTT_DATA3_MSG = SVC(ATH10K_HTC_SVC_GRP_HTT, 2),

	ATH10K_HTC_SVC_ID_HTT_IPA_MSG = SVC(ATH10K_IPA_SERVICE_GROUP, 0),

	ATH10K_HTC_SVC_ID_HTT_LOG_MSG = SVC(ATH10K_LOG_SERVICE_GROUP, 0),

	/* raw stream service (i.e. flash, tcmd, calibration apps) */

	ATH10K_HTC_SVC_ID_TEST_RAW_STREAMS = SVC(ATH10K_HTC_SVC_GRP_TEST, 0),

};

drivers/net/wireless/ath/ath10k/snoc.c

+535 −0
Original line number Diff line number Diff line
@@ -21,6 +21,351 @@ 
#include <linux/of.h>

#include <linux/platform_device.h>



static void ath10k_snoc_htc_tx_cb(struct ath10k_ce_pipe *ce_state);

static void ath10k_snoc_htc_rx_cb(struct ath10k_ce_pipe *ce_state);

static void ath10k_snoc_htt_tx_cb(struct ath10k_ce_pipe *ce_state);

static void ath10k_snoc_htt_rx_cb(struct ath10k_ce_pipe *ce_state);

static void ath10k_snoc_htt_htc_rx_cb(struct ath10k_ce_pipe *ce_state);



static struct ce_attr host_ce_config_wlan[] = {

	/* CE0: host->target HTC control streams */

	{

		.flags = CE_ATTR_FLAGS,

		.src_nentries = 16,

		.src_sz_max = 2048,

		.dest_nentries = 0,

		.send_cb = ath10k_snoc_htc_tx_cb,

	},



	/* CE1: target->host HTT + HTC control */

	{

		.flags = CE_ATTR_FLAGS,

		.src_nentries = 0,

		.src_sz_max = 2048,

		.dest_nentries = 512,

		.recv_cb = ath10k_snoc_htt_htc_rx_cb,

	},



	/* CE2: target->host WMI */

	{

		.flags = CE_ATTR_FLAGS,

		.src_nentries = 0,

		.src_sz_max = 2048,

		.dest_nentries = 64,

		.recv_cb = ath10k_snoc_htc_rx_cb,

	},



	/* CE3: host->target WMI */

	{

		.flags = CE_ATTR_FLAGS,

		.src_nentries = 32,

		.src_sz_max = 2048,

		.dest_nentries = 0,

		.send_cb = ath10k_snoc_htc_tx_cb,

	},



	/* CE4: host->target HTT */

	{

		.flags = CE_ATTR_FLAGS | CE_ATTR_DIS_INTR,

		.src_nentries = 256,

		.src_sz_max = 256,

		.dest_nentries = 0,

		.send_cb = ath10k_snoc_htt_tx_cb,

	},



	/* CE5: target->host HTT (ipa_uc->target ) */

	{

		.flags = CE_ATTR_FLAGS,

		.src_nentries = 0,

		.src_sz_max = 512,

		.dest_nentries = 512,

		.recv_cb = ath10k_snoc_htt_rx_cb,

	},



	/* CE6: target autonomous hif_memcpy */

	{

		.flags = CE_ATTR_FLAGS,

		.src_nentries = 0,

		.src_sz_max = 0,

		.dest_nentries = 0,

	},



	/* CE7: ce_diag, the Diagnostic Window */

	{

		.flags = CE_ATTR_FLAGS,

		.src_nentries = 2,

		.src_sz_max = 2048,

		.dest_nentries = 2,

	},



	/* CE8: Target to uMC */

	{

		.flags = CE_ATTR_FLAGS,

		.src_nentries = 0,

		.src_sz_max = 2048,

		.dest_nentries = 128,

	},



	/* CE9 target->host HTT */

	{

		.flags = CE_ATTR_FLAGS,

		.src_nentries = 0,

		.src_sz_max = 2048,

		.dest_nentries = 512,

		.recv_cb = ath10k_snoc_htt_htc_rx_cb,

	},



	/* CE10: target->host HTT */

	{

		.flags = CE_ATTR_FLAGS,

		.src_nentries = 0,

		.src_sz_max = 2048,

		.dest_nentries = 512,

		.recv_cb = ath10k_snoc_htt_htc_rx_cb,

	},



	/* CE11: target -> host PKTLOG */

	{

		.flags = CE_ATTR_FLAGS,

		.src_nentries = 0,

		.src_sz_max = 2048,

		.dest_nentries = 512,

		.recv_cb = ath10k_snoc_htt_htc_rx_cb,

	},

};



static struct ce_pipe_config target_ce_config_wlan[] = {

	/* CE0: host->target HTC control and raw streams */

	{

		.pipenum = __cpu_to_le32(0),

		.pipedir = __cpu_to_le32(PIPEDIR_OUT),

		.nentries = __cpu_to_le32(32),

		.nbytes_max = __cpu_to_le32(2048),

		.flags = __cpu_to_le32(CE_ATTR_FLAGS),

		.reserved = __cpu_to_le32(0),

	},



	/* CE1: target->host HTT + HTC control */

	{

		.pipenum = __cpu_to_le32(1),

		.pipedir = __cpu_to_le32(PIPEDIR_IN),

		.nentries = __cpu_to_le32(32),

		.nbytes_max = __cpu_to_le32(2048),

		.flags = __cpu_to_le32(CE_ATTR_FLAGS),

		.reserved = __cpu_to_le32(0),

	},



	/* CE2: target->host WMI */

	{

		.pipenum = __cpu_to_le32(2),

		.pipedir = __cpu_to_le32(PIPEDIR_IN),

		.nentries = __cpu_to_le32(64),

		.nbytes_max = __cpu_to_le32(2048),

		.flags = __cpu_to_le32(CE_ATTR_FLAGS),

		.reserved = __cpu_to_le32(0),

	},



	/* CE3: host->target WMI */

	{

		.pipenum = __cpu_to_le32(3),

		.pipedir = __cpu_to_le32(PIPEDIR_OUT),

		.nentries = __cpu_to_le32(32),

		.nbytes_max = __cpu_to_le32(2048),

		.flags = __cpu_to_le32(CE_ATTR_FLAGS),

		.reserved = __cpu_to_le32(0),

	},



	/* CE4: host->target HTT */

	{

		.pipenum = __cpu_to_le32(4),

		.pipedir = __cpu_to_le32(PIPEDIR_OUT),

		.nentries = __cpu_to_le32(256),

		.nbytes_max = __cpu_to_le32(256),

		.flags = __cpu_to_le32(CE_ATTR_FLAGS | CE_ATTR_DIS_INTR),

		.reserved = __cpu_to_le32(0),

	},



	/* CE5: target->host HTT (HIF->HTT) */

	{

		.pipenum = __cpu_to_le32(5),

		.pipedir = __cpu_to_le32(PIPEDIR_OUT),

		.nentries = __cpu_to_le32(1024),

		.nbytes_max = __cpu_to_le32(64),

		.flags = __cpu_to_le32(CE_ATTR_FLAGS | CE_ATTR_DIS_INTR),

		.reserved = __cpu_to_le32(0),

	},



	/* CE6: Reserved for target autonomous hif_memcpy */

	{

		.pipenum = __cpu_to_le32(6),

		.pipedir = __cpu_to_le32(PIPEDIR_INOUT),

		.nentries = __cpu_to_le32(32),

		.nbytes_max = __cpu_to_le32(16384),

		.flags = __cpu_to_le32(CE_ATTR_FLAGS),

		.reserved = __cpu_to_le32(0),

	},



	/* CE7 used only by Host */

	{

		.pipenum = __cpu_to_le32(7),

		.pipedir = __cpu_to_le32(4),

		.nentries = __cpu_to_le32(0),

		.nbytes_max = __cpu_to_le32(0),

		.flags = __cpu_to_le32(CE_ATTR_FLAGS | CE_ATTR_DIS_INTR),

		.reserved = __cpu_to_le32(0),

	},



	/* CE8 Target to uMC */

	{

		.pipenum = __cpu_to_le32(8),

		.pipedir = __cpu_to_le32(PIPEDIR_IN),

		.nentries = __cpu_to_le32(32),

		.nbytes_max = __cpu_to_le32(2048),

		.flags = __cpu_to_le32(0),

		.reserved = __cpu_to_le32(0),

	},



	/* CE9 target->host HTT */

	{

		.pipenum = __cpu_to_le32(9),

		.pipedir = __cpu_to_le32(PIPEDIR_IN),

		.nentries = __cpu_to_le32(32),

		.nbytes_max = __cpu_to_le32(2048),

		.flags = __cpu_to_le32(CE_ATTR_FLAGS),

		.reserved = __cpu_to_le32(0),

	},



	/* CE10 target->host HTT */

	{

		.pipenum = __cpu_to_le32(10),

		.pipedir = __cpu_to_le32(PIPEDIR_IN),

		.nentries = __cpu_to_le32(32),

		.nbytes_max = __cpu_to_le32(2048),

		.flags = __cpu_to_le32(CE_ATTR_FLAGS),

		.reserved = __cpu_to_le32(0),

	},



	/* CE11 target autonomous qcache memcpy */

	{

		.pipenum = __cpu_to_le32(11),

		.pipedir = __cpu_to_le32(PIPEDIR_IN),

		.nentries = __cpu_to_le32(32),

		.nbytes_max = __cpu_to_le32(2048),

		.flags = __cpu_to_le32(CE_ATTR_FLAGS),

		.reserved = __cpu_to_le32(0),

	},

};



static struct service_to_pipe target_service_to_ce_map_wlan[] = {

	{

		__cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_VO),

		__cpu_to_le32(PIPEDIR_OUT),	/* out = UL = host -> target */

		__cpu_to_le32(3),

	},

	{

		__cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_VO),

		__cpu_to_le32(PIPEDIR_IN),	/* in = DL = target -> host */

		__cpu_to_le32(2),

	},

	{

		__cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_BK),

		__cpu_to_le32(PIPEDIR_OUT),	/* out = UL = host -> target */

		__cpu_to_le32(3),

	},

	{

		__cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_BK),

		__cpu_to_le32(PIPEDIR_IN),	/* in = DL = target -> host */

		__cpu_to_le32(2),

	},

	{

		__cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_BE),

		__cpu_to_le32(PIPEDIR_OUT),	/* out = UL = host -> target */

		__cpu_to_le32(3),

	},

	{

		__cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_BE),

		__cpu_to_le32(PIPEDIR_IN),	/* in = DL = target -> host */

		__cpu_to_le32(2),

	},

	{

		__cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_VI),

		__cpu_to_le32(PIPEDIR_OUT),	/* out = UL = host -> target */

		__cpu_to_le32(3),

	},

	{

		__cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_VI),

		__cpu_to_le32(PIPEDIR_IN),	/* in = DL = target -> host */

		__cpu_to_le32(2),

	},

	{

		__cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_CONTROL),

		__cpu_to_le32(PIPEDIR_OUT),	/* out = UL = host -> target */

		__cpu_to_le32(3),

	},

	{

		__cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_CONTROL),

		__cpu_to_le32(PIPEDIR_IN),	/* in = DL = target -> host */

		__cpu_to_le32(2),

	},

	{

		__cpu_to_le32(ATH10K_HTC_SVC_ID_RSVD_CTRL),

		__cpu_to_le32(PIPEDIR_OUT),	/* out = UL = host -> target */

		__cpu_to_le32(0),

	},

	{

		__cpu_to_le32(ATH10K_HTC_SVC_ID_RSVD_CTRL),

		__cpu_to_le32(PIPEDIR_IN),	/* in = DL = target -> host */

		__cpu_to_le32(2),

	},

	{ /* not used */

		__cpu_to_le32(ATH10K_HTC_SVC_ID_TEST_RAW_STREAMS),

		__cpu_to_le32(PIPEDIR_OUT),	/* out = UL = host -> target */

		__cpu_to_le32(0),

	},

	{ /* not used */

		__cpu_to_le32(ATH10K_HTC_SVC_ID_TEST_RAW_STREAMS),

		__cpu_to_le32(PIPEDIR_IN),	/* in = DL = target -> host */

		__cpu_to_le32(2),

	},

	{

		__cpu_to_le32(ATH10K_HTC_SVC_ID_HTT_DATA_MSG),

		__cpu_to_le32(PIPEDIR_OUT),	/* out = UL = host -> target */

		__cpu_to_le32(4),

	},

	{

		__cpu_to_le32(ATH10K_HTC_SVC_ID_HTT_DATA_MSG),

		__cpu_to_le32(PIPEDIR_IN),	/* in = DL = target -> host */

		__cpu_to_le32(1),

	},

	{

		__cpu_to_le32(ATH10K_HTC_SVC_ID_HTT_IPA_MSG),

		__cpu_to_le32(PIPEDIR_OUT),/* IPA service */

		__cpu_to_le32(5),

	},

	{ /* in = DL = target -> host */

		__cpu_to_le32(ATH10K_HTC_SVC_ID_HTT_DATA2_MSG),

		__cpu_to_le32(PIPEDIR_IN),	/* in = DL = target -> host */

		__cpu_to_le32(9),

	},

	{ /* in = DL = target -> host */

		__cpu_to_le32(ATH10K_HTC_SVC_ID_HTT_DATA3_MSG),

		__cpu_to_le32(PIPEDIR_IN),	/* in = DL = target -> host */

		__cpu_to_le32(10),

	},

	{ /* in = DL = target -> host pktlog */

		__cpu_to_le32(ATH10K_HTC_SVC_ID_HTT_LOG_MSG),

		__cpu_to_le32(PIPEDIR_IN),	/* in = DL = target -> host */

		__cpu_to_le32(11),

	},

	/* (Additions here) */



	{ /* must be last */

		__cpu_to_le32(0),

		__cpu_to_le32(0),

		__cpu_to_le32(0),

	},

};



void ath10k_snoc_write32(void *ar, u32 offset, u32 value)

{

}
@@ -31,6 +376,196 @@ u32 ath10k_snoc_read32(void *ar, u32 offset) 
	return val;

}



static int __ath10k_snoc_rx_post_buf(struct ath10k_snoc_pipe *pipe)

{

	struct ath10k *ar = pipe->hif_ce_state;

	struct ath10k_snoc *ar_snoc = ath10k_snoc_priv(ar);

	struct ath10k_ce_pipe *ce_pipe = pipe->ce_hdl;

	struct sk_buff *skb;

	dma_addr_t paddr;

	int ret;



	skb = dev_alloc_skb(pipe->buf_sz);

	if (!skb)

		return -ENOMEM;



	WARN_ONCE((unsigned long)skb->data & 3, "unaligned skb");



	paddr = dma_map_single(ar->dev, skb->data,

			       skb->len + skb_tailroom(skb),

			       DMA_FROM_DEVICE);

	if (unlikely(dma_mapping_error(ar->dev, paddr))) {

		ath10k_warn(ar, "failed to dma map snoc rx buf\n");

		dev_kfree_skb_any(skb);

		return -EIO;

	}



	ATH10K_SKB_RXCB(skb)->paddr = paddr;



	spin_lock_bh(&ar_snoc->ce_lock);

	ret = __ath10k_ce_rx_post_buf(ce_pipe, skb, paddr);

	spin_unlock_bh(&ar_snoc->ce_lock);

	if (ret) {

		dma_unmap_single(ar->dev, paddr, skb->len + skb_tailroom(skb),

				 DMA_FROM_DEVICE);

		dev_kfree_skb_any(skb);

		return ret;

	}



	return 0;

}



static void ath10k_snoc_rx_post_pipe(struct ath10k_snoc_pipe *pipe)

{

	struct ath10k *ar = pipe->hif_ce_state;

	struct ath10k_snoc *ar_snoc = ath10k_snoc_priv(ar);

	struct ath10k_ce_pipe *ce_pipe = pipe->ce_hdl;

	int ret, num;



	if (pipe->buf_sz == 0)

		return;



	if (!ce_pipe->dest_ring)

		return;



	spin_lock_bh(&ar_snoc->ce_lock);

	num = __ath10k_ce_rx_num_free_bufs(ce_pipe);

	spin_unlock_bh(&ar_snoc->ce_lock);

	while (num--) {

		ret = __ath10k_snoc_rx_post_buf(pipe);

		if (ret) {

			if (ret == -ENOSPC)

				break;

			ath10k_warn(ar, "failed to post rx buf: %d\n", ret);

			mod_timer(&ar_snoc->rx_post_retry, jiffies +

				  ATH10K_SNOC_RX_POST_RETRY_MS);

			break;

		}

	}

}



static void ath10k_snoc_rx_post(struct ath10k *ar)

{

	struct ath10k_snoc *ar_snoc = ath10k_snoc_priv(ar);

	int i;



	for (i = 0; i < CE_COUNT; i++)

		ath10k_snoc_rx_post_pipe(&ar_snoc->pipe_info[i]);

}



static void ath10k_snoc_rx_replenish_retry(unsigned long ptr)

{

	struct ath10k *ar = (void *)ptr;



	ath10k_snoc_rx_post(ar);

}



static void ath10k_snoc_htc_tx_cb(struct ath10k_ce_pipe *ce_state)

{

	struct ath10k *ar = ce_state->ar;

	struct sk_buff_head list;

	struct sk_buff *skb;



	__skb_queue_head_init(&list);

	while (ath10k_ce_completed_send_next(ce_state, (void **)&skb) == 0) {

		if (!skb)

			continue;



		__skb_queue_tail(&list, skb);

	}



	while ((skb = __skb_dequeue(&list)))

		ath10k_htc_tx_completion_handler(ar, skb);

}



static void ath10k_snoc_process_rx_cb(struct ath10k_ce_pipe *ce_state,

				      void (*callback)(struct ath10k *ar,

						       struct sk_buff *skb))

{

	struct ath10k *ar = ce_state->ar;

	struct ath10k_snoc *ar_snoc = ath10k_snoc_priv(ar);

	struct ath10k_snoc_pipe *pipe_info =  &ar_snoc->pipe_info[ce_state->id];

	struct sk_buff *skb;

	struct sk_buff_head list;

	void *transfer_context;

	unsigned int nbytes, max_nbytes;



	__skb_queue_head_init(&list);

	while (ath10k_ce_completed_recv_next(ce_state, &transfer_context,

					     &nbytes) == 0) {

		skb = transfer_context;

		max_nbytes = skb->len + skb_tailroom(skb);

		dma_unmap_single(ar->dev, ATH10K_SKB_RXCB(skb)->paddr,

				 max_nbytes, DMA_FROM_DEVICE);



		if (unlikely(max_nbytes < nbytes)) {

			ath10k_warn(ar, "rxed more than expected (nbytes %d, max %d)",

				    nbytes, max_nbytes);

			dev_kfree_skb_any(skb);

			continue;

		}



		skb_put(skb, nbytes);

		__skb_queue_tail(&list, skb);

	}



	while ((skb = __skb_dequeue(&list))) {

		ath10k_dbg(ar, ATH10K_DBG_SNOC, "snoc rx ce pipe %d len %d\n",

			   ce_state->id, skb->len);



		callback(ar, skb);

	}



	ath10k_snoc_rx_post_pipe(pipe_info);

}



static void ath10k_snoc_htc_rx_cb(struct ath10k_ce_pipe *ce_state)

{

	ath10k_snoc_process_rx_cb(ce_state, ath10k_htc_rx_completion_handler);

}



static void ath10k_snoc_htt_htc_rx_cb(struct ath10k_ce_pipe *ce_state)

{

	/* CE4 polling needs to be done whenever CE pipe which transports

	 * HTT Rx (target->host) is processed.

	 */

	ath10k_ce_per_engine_service(ce_state->ar, CE_POLL_PIPE);



	ath10k_snoc_process_rx_cb(ce_state, ath10k_htc_rx_completion_handler);

}



static void ath10k_snoc_htt_tx_cb(struct ath10k_ce_pipe *ce_state)

{

	struct ath10k *ar = ce_state->ar;

	struct sk_buff *skb;



	while (ath10k_ce_completed_send_next(ce_state, (void **)&skb) == 0) {

		/* no need to call tx completion for NULL pointers */

		if (!skb)

			continue;



		dma_unmap_single(ar->dev, ATH10K_SKB_CB(skb)->paddr,

				 skb->len, DMA_TO_DEVICE);

		ath10k_htt_hif_tx_complete(ar, skb);

	}

}



static void ath10k_snoc_htt_rx_deliver(struct ath10k *ar, struct sk_buff *skb)

{

	skb_pull(skb, sizeof(struct ath10k_htc_hdr));

	ath10k_htt_t2h_msg_handler(ar, skb);

}



static void ath10k_snoc_htt_rx_cb(struct ath10k_ce_pipe *ce_state)

{

	/* CE4 polling needs to be done whenever CE pipe which transports

	 * HTT Rx (target->host) is processed.

	 */

	ath10k_ce_per_engine_service(ce_state->ar, CE_POLL_PIPE);



	ath10k_snoc_process_rx_cb(ce_state, ath10k_snoc_htt_rx_deliver);

}



static int ath10k_snoc_hif_tx_sg(struct ath10k *ar, u8 pipe_id,

				 struct ath10k_hif_sg_item *items, int n_items)

{

drivers/net/wireless/ath/ath10k/snoc.h

+1 −0
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
#include "ce.h"

#include "pci.h"

#define ATH10K_SNOC_RX_POST_RETRY_MS 50

#define CE_POLL_PIPE 4



/* struct snoc_state: SNOC target state

 * @pipe_cfg_addr: pipe configuration address