Merge "wil6210: add support for enhanced DMA RX data flows" into msm-4.14 (db4ffdf8) · Commits · e / devices / android_kernel_oneplus_sm8150

drivers/net/wireless/ath/wil6210/interrupt.c

+82 −4

Original line number	Diff line number	Diff line
		@@ -45,6 +45,7 @@
		#define WIL6210_IMC_TX (BIT_DMA_EP_TX_ICR_TX_DONE \| \
		BIT_DMA_EP_TX_ICR_TX_DONE_N(0))
		#define WIL6210_IMC_TX_EDMA BIT_TX_STATUS_IRQ
		#define WIL6210_IMC_RX_EDMA BIT_RX_STATUS_IRQ
		#define WIL6210_IMC_MISC_NO_HALP (ISR_MISC_FW_READY \| \
		ISR_MISC_MBOX_EVT \| \
		ISR_MISC_FW_ERROR)
		@@ -100,6 +101,12 @@ static void wil6210_mask_irq_rx(struct wil6210_priv *wil)
		WIL6210_IRQ_DISABLE);
		}

		static void wil6210_mask_irq_rx_edma(struct wil6210_priv *wil)
		{
		wil_w(wil, RGF_INT_GEN_RX_ICR + offsetof(struct RGF_ICR, IMS),
		WIL6210_IRQ_DISABLE);
		}

		static void wil6210_mask_irq_misc(struct wil6210_priv *wil, bool mask_halp)
		{
		wil_dbg_irq(wil, "mask_irq_misc: mask_halp(%s)\n",
		@@ -146,6 +153,12 @@ void wil6210_unmask_irq_rx(struct wil6210_priv *wil)
		unmask_rx_htrsh ? WIL6210_IMC_RX : WIL6210_IMC_RX_NO_RX_HTRSH);
		}

		void wil6210_unmask_irq_rx_edma(struct wil6210_priv *wil)
		{
		wil_w(wil, RGF_INT_GEN_RX_ICR + offsetof(struct RGF_ICR, IMC),
		WIL6210_IMC_RX_EDMA);
		}

		static void wil6210_unmask_irq_misc(struct wil6210_priv *wil, bool unmask_halp)
		{
		wil_dbg_irq(wil, "unmask_irq_misc: unmask_halp(%s)\n",
		@@ -179,6 +192,7 @@ void wil_mask_irq(struct wil6210_priv *wil)
		wil6210_mask_irq_tx(wil);
		wil6210_mask_irq_tx_edma(wil);
		wil6210_mask_irq_rx(wil);
		wil6210_mask_irq_rx_edma(wil);
		wil6210_mask_irq_misc(wil, true);
		wil6210_mask_irq_pseudo(wil);
		}
		@@ -195,10 +209,13 @@ void wil_unmask_irq(struct wil6210_priv *wil)
		WIL_ICR_ICC_MISC_VALUE);
		wil_w(wil, RGF_INT_GEN_TX_ICR + offsetof(struct RGF_ICR, ICC),
		WIL_ICR_ICC_VALUE);
		wil_w(wil, RGF_INT_GEN_RX_ICR + offsetof(struct RGF_ICR, ICC),
		WIL_ICR_ICC_VALUE);

		wil6210_unmask_irq_pseudo(wil);
		if (wil->use_enhanced_dma_hw) {
		wil6210_unmask_irq_tx_edma(wil);
		wil6210_unmask_irq_rx_edma(wil);
		} else {
		wil6210_unmask_irq_tx(wil);
		wil6210_unmask_irq_rx(wil);
		@@ -335,6 +352,54 @@ static irqreturn_t wil6210_irq_rx(int irq, void *cookie)
		return IRQ_HANDLED;
		}

		static irqreturn_t wil6210_irq_rx_edma(int irq, void *cookie)
		{
		struct wil6210_priv *wil = cookie;
		u32 isr = wil_ioread32_and_clear(wil->csr +
		HOSTADDR(RGF_INT_GEN_RX_ICR) +
		offsetof(struct RGF_ICR, ICR));
		bool need_unmask = true;

		trace_wil6210_irq_rx(isr);
		wil_dbg_irq(wil, "ISR RX 0x%08x\n", isr);

		if (unlikely(!isr)) {
		wil_err(wil, "spurious IRQ: RX\n");
		return IRQ_NONE;
		}

		wil6210_mask_irq_rx_edma(wil);

		if (likely(isr & BIT_RX_STATUS_IRQ)) {
		wil_dbg_irq(wil, "RX status ring\n");
		isr &= ~BIT_RX_STATUS_IRQ;
		if (likely(test_bit(wil_status_fwready, wil->status))) {
		if (likely(test_bit(wil_status_napi_en, wil->status))) {
		wil_dbg_txrx(wil, "NAPI(Rx) schedule\n");
		need_unmask = false;
		napi_schedule(&wil->napi_rx);
		} else {
		wil_err(wil,
		"Got Rx interrupt while stopping interface\n");
		}
		} else {
		wil_err(wil, "Got Rx interrupt while in reset\n");
		}
		}

		if (unlikely(isr))
		wil_err(wil, "un-handled RX ISR bits 0x%08x\n", isr);

		/* Rx IRQ will be enabled when NAPI processing finished */

		atomic_inc(&wil->isr_count_rx);

		if (unlikely(need_unmask))
		wil6210_unmask_irq_rx_edma(wil);

		return IRQ_HANDLED;
		}

		static irqreturn_t wil6210_irq_tx_edma(int irq, void *cookie)
		{
		struct wil6210_priv *wil = cookie;
		@@ -594,12 +659,20 @@ static irqreturn_t wil6210_thread_irq(int irq, void *cookie)
		*/
		static int wil6210_debug_irq_mask(struct wil6210_priv *wil, u32 pseudo_cause)
		{
		u32 icm_rx = 0, icr_rx = 0, imv_rx = 0;
		u32 icm_rx, icr_rx, imv_rx;
		u32 icm_tx, icr_tx, imv_tx;
		u32 icm_misc, icr_misc, imv_misc;

		if (!test_bit(wil_status_irqen, wil->status)) {
		if (wil->use_enhanced_dma_hw) {
		icm_rx = wil_ioread32_and_clear(wil->csr +
		HOSTADDR(RGF_INT_GEN_RX_ICR) +
		offsetof(struct RGF_ICR, ICM));
		icr_rx = wil_ioread32_and_clear(wil->csr +
		HOSTADDR(RGF_INT_GEN_RX_ICR) +
		offsetof(struct RGF_ICR, ICR));
		imv_rx = wil_r(wil, RGF_INT_GEN_RX_ICR +
		offsetof(struct RGF_ICR, IMV));
		icm_tx = wil_ioread32_and_clear(wil->csr +
		HOSTADDR(RGF_INT_GEN_TX_ICR) +
		offsetof(struct RGF_ICR, ICM));
		@@ -691,7 +764,7 @@ static irqreturn_t wil6210_hardirq(int irq, void *cookie)
		* voting for wake thread - need at least 1 vote
		*/
		if ((pseudo_cause & BIT_DMA_PSEUDO_CAUSE_RX) &&
		(wil6210_irq_rx(irq, cookie) == IRQ_WAKE_THREAD))
		(wil->txrx_ops.irq_rx(irq, cookie) == IRQ_WAKE_THREAD))
		rc = IRQ_WAKE_THREAD;

		if ((pseudo_cause & BIT_DMA_PSEUDO_CAUSE_TX) &&
		@@ -723,6 +796,8 @@ void wil6210_clear_irq(struct wil6210_priv *wil)
		offsetof(struct RGF_ICR, ICR));
		wil_clear32(wil->csr + HOSTADDR(RGF_DMA_EP_TX_ICR) +
		offsetof(struct RGF_ICR, ICR));
		wil_clear32(wil->csr + HOSTADDR(RGF_INT_GEN_RX_ICR) +
		offsetof(struct RGF_ICR, ICR));
		wil_clear32(wil->csr + HOSTADDR(RGF_INT_GEN_TX_ICR) +
		offsetof(struct RGF_ICR, ICR));
		wil_clear32(wil->csr + HOSTADDR(RGF_DMA_EP_MISC_ICR) +
		@@ -753,10 +828,13 @@ int wil6210_init_irq(struct wil6210_priv *wil, int irq, bool use_msi)

		wil_dbg_misc(wil, "init_irq: %s\n", use_msi ? "MSI" : "INTx");

		if (wil->use_enhanced_dma_hw)
		if (wil->use_enhanced_dma_hw) {
		wil->txrx_ops.irq_tx = wil6210_irq_tx_edma;
		else
		wil->txrx_ops.irq_rx = wil6210_irq_rx_edma;
		} else {
		wil->txrx_ops.irq_tx = wil6210_irq_tx;
		wil->txrx_ops.irq_rx = wil6210_irq_rx;
		}
		rc = request_threaded_irq(irq, wil6210_hardirq,
		wil6210_thread_irq,
		use_msi ? 0 : IRQF_SHARED,

drivers/net/wireless/ath/wil6210/netdev.c

+30 −5

Original line number	Diff line number	Diff line
		@@ -133,6 +133,27 @@ static int wil6210_netdev_poll_rx(struct napi_struct *napi, int budget)
		return done;
		}

		static int wil6210_netdev_poll_rx_edma(struct napi_struct *napi, int budget)
		{
		struct wil6210_priv *wil = container_of(napi, struct wil6210_priv,
		napi_rx);
		int quota = budget;
		int done;

		wil_rx_handle_edma(wil, &quota);
		done = budget - quota;

		if (done < budget) {
		napi_complete_done(napi, done);
		wil6210_unmask_irq_rx_edma(wil);
		wil_dbg_txrx(wil, "NAPI RX complete\n");
		}

		wil_dbg_txrx(wil, "NAPI RX poll(%d) done %d\n", budget, done);

		return done;
		}

		static int wil6210_netdev_poll_tx(struct napi_struct *napi, int budget)
		{
		struct wil6210_priv *wil = container_of(napi, struct wil6210_priv,
		@@ -459,17 +480,21 @@ int wil_if_add(struct wil6210_priv *wil)
		}

		init_dummy_netdev(&wil->napi_ndev);
		netif_napi_add(&wil->napi_ndev, &wil->napi_rx, wil6210_netdev_poll_rx,
		if (wil->use_enhanced_dma_hw) {
		netif_napi_add(&wil->napi_ndev, &wil->napi_rx,
		wil6210_netdev_poll_rx_edma,
		WIL6210_NAPI_BUDGET);
		if (wil->use_enhanced_dma_hw)
		netif_tx_napi_add(&wil->napi_ndev,
		&wil->napi_tx, wil6210_netdev_poll_tx_edma,
		WIL6210_NAPI_BUDGET);
		else
		} else {
		netif_napi_add(&wil->napi_ndev, &wil->napi_rx,
		wil6210_netdev_poll_rx,
		WIL6210_NAPI_BUDGET);
		netif_tx_napi_add(&wil->napi_ndev,
		&wil->napi_tx, wil6210_netdev_poll_tx,
		WIL6210_NAPI_BUDGET);

		}

		wil_update_net_queues_bh(wil, vif, NULL, true);

drivers/net/wireless/ath/wil6210/pm.c

+3 −3

Original line number	Diff line number	Diff line
		@@ -207,7 +207,7 @@ static int wil_suspend_keep_radio_on(struct wil6210_priv *wil)
		goto reject_suspend;
		}

		if (!wil_is_rx_idle(wil)) {
		if (!wil->txrx_ops.is_rx_idle(wil)) {
		wil_dbg_pm(wil, "Pending RX data, reject suspend\n");
		wil->suspend_stats.rejected_by_host++;
		goto reject_suspend;
		@@ -231,9 +231,9 @@ static int wil_suspend_keep_radio_on(struct wil6210_priv *wil)
		start = jiffies;
		data_comp_to = jiffies + msecs_to_jiffies(WIL_DATA_COMPLETION_TO_MS);
		if (test_bit(wil_status_napi_en, wil->status)) {
		while (!wil_is_rx_idle(wil)) {
		while (!wil->txrx_ops.is_rx_idle(wil)) {
		if (time_after(jiffies, data_comp_to)) {
		if (wil_is_rx_idle(wil))
		if (wil->txrx_ops.is_rx_idle(wil))
		break;
		wil_err(wil,
		"TO waiting for idle RX, suspend failed\n");

drivers/net/wireless/ath/wil6210/rx_reorder.c

+9 −9

Original line number	Diff line number	Diff line
		@@ -95,17 +95,16 @@ __acquires(&sta->tid_rx_lock) __releases(&sta->tid_rx_lock)
		{
		struct wil6210_vif *vif;
		struct net_device *ndev;
		struct vring_rx_desc *d = wil_skb_rxdesc(skb);
		int tid = wil_rxdesc_tid(d);
		int cid = wil_rxdesc_cid(d);
		int mid = wil_rxdesc_mid(d);
		u16 seq = wil_rxdesc_seq(d);
		int mcast = wil_rxdesc_mcast(d);
		struct wil_sta_info *sta = &wil->sta[cid];
		int tid, cid, mid, mcast;
		u16 seq;
		struct wil_sta_info *sta;
		struct wil_tid_ampdu_rx *r;
		u16 hseq;
		int index;

		wil->txrx_ops.get_reorder_params(skb, &tid, &cid, &mid, &seq, &mcast);
		sta = &wil->sta[cid];

		wil_dbg_txrx(wil, "MID %d CID %d TID %d Seq 0x%03x mcast %01x\n",
		mid, cid, tid, seq, mcast);

		@@ -365,8 +364,9 @@ __acquires(&sta->tid_rx_lock) __releases(&sta->tid_rx_lock)
		}
		}

		rc = wmi_addba_rx_resp(wil, mid, cid, tid, dialog_token, status,
		agg_amsdu, agg_wsize, agg_timeout);
		rc = wil->txrx_ops.wmi_addba_rx_resp(wil, mid, cid, tid, dialog_token,
		status, agg_amsdu, agg_wsize,
		agg_timeout);
		if (rc \|\| (status != WLAN_STATUS_SUCCESS)) {
		wil_err(wil, "do not apply ba, rc(%d), status(%d)\n", rc,
		status);

drivers/net/wireless/ath/wil6210/trace.h

+32 −0

Original line number	Diff line number	Diff line
		@@ -187,6 +187,38 @@ TRACE_EVENT(wil6210_rx,
		__entry->seq, __entry->type, __entry->subtype)
		);

		TRACE_EVENT(wil6210_rx_status,
		TP_PROTO(u8 use_compressed, u16 buff_id, void *msg),
		TP_ARGS(use_compressed, buff_id, msg),
		TP_STRUCT__entry(__field(u8, use_compressed)
		__field(u16, buff_id)
		__field(unsigned int, len)
		__field(u8, mid)
		__field(u8, cid)
		__field(u8, tid)
		__field(u8, type)
		__field(u8, subtype)
		__field(u16, seq)
		__field(u8, mcs)
		),
		TP_fast_assign(__entry->use_compressed = use_compressed;
		__entry->buff_id = buff_id;
		__entry->len = wil_rx_status_get_length(msg);
		__entry->mid = wil_rx_status_get_mid(msg);
		__entry->cid = wil_rx_status_get_cid(msg);
		__entry->tid = wil_rx_status_get_tid(msg);
		__entry->type = wil_rx_status_get_frame_type(msg);
		__entry->subtype = wil_rx_status_get_fc1(msg);
		__entry->seq = wil_rx_status_get_seq(msg);
		__entry->mcs = wil_rx_status_get_mcs(msg);
		),
		TP_printk(
		"compressed %d buff_id %d len %d mid %d cid %d tid %d mcs %d seq 0x%03x type 0x%1x subtype 0x%1x",
		__entry->use_compressed, __entry->buff_id, __entry->len,
		__entry->mid, __entry->cid, __entry->tid, __entry->mcs,
		__entry->seq, __entry->type, __entry->subtype)
		);

		TRACE_EVENT(wil6210_tx,
		TP_PROTO(u8 vring, u16 index, unsigned int len, u8 frags),
		TP_ARGS(vring, index, len, frags),