Commit 225060c4 authored by Kalle Valo's avatar Kalle Valo
Browse files

Merge tag 'mt76-for-kvalo-2020-09-23' of https://github.com/nbd168/wireless 

mt76 patches for 5.10

* mt7663 runtime power management improvements
* performance improvements
* sdio support fixes
* testmode fixes
* mt7622 fixes
* 7915 A-MSDU offload
* cleanups

# gpg: Signature made Thu 24 Sep 2020 07:10:25 PM EEST using DSA key ID 02A76EF5
# gpg: Good signature from "Felix Fietkau <nbd@nbd.name>"
# gpg: WARNING: This key is not certified with a trusted signature!
# gpg:          There is no indication that the signature belongs to the owner.
# Primary key fingerprint: 75D1 1A7D 91A7 710F 4900  42EF D77D 141D 02A7 6EF5
parents 5acbf34e b9b852b9

drivers/net/wireless/mediatek/mt76/debugfs.c

+4 −5
Original line number Diff line number Diff line
@@ -31,15 +31,14 @@ int mt76_queues_read(struct seq_file *s, void *data) 
	int i;



	for (i = 0; i < ARRAY_SIZE(dev->q_tx); i++) {

		struct mt76_sw_queue *q = &dev->q_tx[i];

		struct mt76_queue *q = dev->q_tx[i];



		if (!q->q)

		if (!q)

			continue;



		seq_printf(s,

			   "%d:	queued=%d head=%d tail=%d swq_queued=%d\n",

			   i, q->q->queued, q->q->head, q->q->tail,

			   q->swq_queued);

			   "%d:	queued=%d head=%d tail=%d\n",

			   i, q->queued, q->head, q->tail);

	}



	return 0;

drivers/net/wireless/mediatek/mt76/dma.c

+106 −56
Original line number Diff line number Diff line
@@ -7,6 +7,76 @@ 
#include "mt76.h"

#include "dma.h"



static struct mt76_txwi_cache *

mt76_alloc_txwi(struct mt76_dev *dev)

{

	struct mt76_txwi_cache *t;

	dma_addr_t addr;

	u8 *txwi;

	int size;



	size = L1_CACHE_ALIGN(dev->drv->txwi_size + sizeof(*t));

	txwi = devm_kzalloc(dev->dev, size, GFP_ATOMIC);

	if (!txwi)

		return NULL;



	addr = dma_map_single(dev->dev, txwi, dev->drv->txwi_size,

			      DMA_TO_DEVICE);

	t = (struct mt76_txwi_cache *)(txwi + dev->drv->txwi_size);

	t->dma_addr = addr;



	return t;

}



static struct mt76_txwi_cache *

__mt76_get_txwi(struct mt76_dev *dev)

{

	struct mt76_txwi_cache *t = NULL;



	spin_lock(&dev->lock);

	if (!list_empty(&dev->txwi_cache)) {

		t = list_first_entry(&dev->txwi_cache, struct mt76_txwi_cache,

				     list);

		list_del(&t->list);

	}

	spin_unlock(&dev->lock);



	return t;

}



static struct mt76_txwi_cache *

mt76_get_txwi(struct mt76_dev *dev)

{

	struct mt76_txwi_cache *t = __mt76_get_txwi(dev);



	if (t)

		return t;



	return mt76_alloc_txwi(dev);

}



void

mt76_put_txwi(struct mt76_dev *dev, struct mt76_txwi_cache *t)

{

	if (!t)

		return;



	spin_lock(&dev->lock);

	list_add(&t->list, &dev->txwi_cache);

	spin_unlock(&dev->lock);

}

EXPORT_SYMBOL_GPL(mt76_put_txwi);



static void

mt76_free_pending_txwi(struct mt76_dev *dev)

{

	struct mt76_txwi_cache *t;



	while ((t = __mt76_get_txwi(dev)) != NULL)

		dma_unmap_single(dev->dev, t->dma_addr, dev->drv->txwi_size,

				 DMA_TO_DEVICE);

}



static int

mt76_dma_alloc_queue(struct mt76_dev *dev, struct mt76_queue *q,

		     int idx, int n_desc, int bufsize,
@@ -49,6 +119,7 @@ mt76_dma_add_buf(struct mt76_dev *dev, struct mt76_queue *q, 
		 struct mt76_queue_buf *buf, int nbufs, u32 info,

		 struct sk_buff *skb, void *txwi)

{

	struct mt76_queue_entry *entry;

	struct mt76_desc *desc;

	u32 ctrl;

	int i, idx = -1;
@@ -61,10 +132,27 @@ mt76_dma_add_buf(struct mt76_dev *dev, struct mt76_queue *q, 
	for (i = 0; i < nbufs; i += 2, buf += 2) {

		u32 buf0 = buf[0].addr, buf1 = 0;



		idx = q->head;

		q->head = (q->head + 1) % q->ndesc;



		desc = &q->desc[idx];

		entry = &q->entry[idx];



		if (buf[0].skip_unmap)

			entry->skip_buf0 = true;

		entry->skip_buf1 = i == nbufs - 1;



		entry->dma_addr[0] = buf[0].addr;

		entry->dma_len[0] = buf[0].len;



		ctrl = FIELD_PREP(MT_DMA_CTL_SD_LEN0, buf[0].len);

		if (i < nbufs - 1) {

			entry->dma_addr[1] = buf[1].addr;

			entry->dma_len[1] = buf[1].len;

			buf1 = buf[1].addr;

			ctrl |= FIELD_PREP(MT_DMA_CTL_SD_LEN1, buf[1].len);

			if (buf[1].skip_unmap)

				entry->skip_buf1 = true;

		}



		if (i == nbufs - 1)
@@ -72,11 +160,6 @@ mt76_dma_add_buf(struct mt76_dev *dev, struct mt76_queue *q, 
		else if (i == nbufs - 2)

			ctrl |= MT_DMA_CTL_LAST_SEC1;



		idx = q->head;

		q->head = (q->head + 1) % q->ndesc;



		desc = &q->desc[idx];



		WRITE_ONCE(desc->buf0, cpu_to_le32(buf0));

		WRITE_ONCE(desc->buf1, cpu_to_le32(buf1));

		WRITE_ONCE(desc->info, cpu_to_le32(info));
@@ -96,24 +179,14 @@ mt76_dma_tx_cleanup_idx(struct mt76_dev *dev, struct mt76_queue *q, int idx, 
			struct mt76_queue_entry *prev_e)

{

	struct mt76_queue_entry *e = &q->entry[idx];

	__le32 __ctrl = READ_ONCE(q->desc[idx].ctrl);

	u32 ctrl = le32_to_cpu(__ctrl);



	if (!e->skip_buf0) {

		__le32 addr = READ_ONCE(q->desc[idx].buf0);

		u32 len = FIELD_GET(MT_DMA_CTL_SD_LEN0, ctrl);



		dma_unmap_single(dev->dev, le32_to_cpu(addr), len,

	if (!e->skip_buf0)

		dma_unmap_single(dev->dev, e->dma_addr[0], e->dma_len[0],

				 DMA_TO_DEVICE);

	}



	if (!(ctrl & MT_DMA_CTL_LAST_SEC0)) {

		__le32 addr = READ_ONCE(q->desc[idx].buf1);

		u32 len = FIELD_GET(MT_DMA_CTL_SD_LEN1, ctrl);



		dma_unmap_single(dev->dev, le32_to_cpu(addr), len,

	if (!e->skip_buf1)

		dma_unmap_single(dev->dev, e->dma_addr[1], e->dma_len[1],

				 DMA_TO_DEVICE);

	}



	if (e->txwi == DMA_DUMMY_DATA)

		e->txwi = NULL;
@@ -137,19 +210,17 @@ mt76_dma_sync_idx(struct mt76_dev *dev, struct mt76_queue *q) 
static void

mt76_dma_kick_queue(struct mt76_dev *dev, struct mt76_queue *q)

{

	wmb();

	writel(q->head, &q->regs->cpu_idx);

}



static void

mt76_dma_tx_cleanup(struct mt76_dev *dev, enum mt76_txq_id qid, bool flush)

{

	struct mt76_sw_queue *sq = &dev->q_tx[qid];

	struct mt76_queue *q = sq->q;

	struct mt76_queue *q = dev->q_tx[qid];

	struct mt76_queue_entry entry;

	unsigned int n_swq_queued[8] = {};

	unsigned int n_queued = 0;

	bool wake = false;

	int i, last;

	int last;



	if (!q)

		return;
@@ -159,16 +230,9 @@ mt76_dma_tx_cleanup(struct mt76_dev *dev, enum mt76_txq_id qid, bool flush) 
	else

		last = readl(&q->regs->dma_idx);



	while ((q->queued > n_queued) && q->tail != last) {

	while (q->queued > 0 && q->tail != last) {

		mt76_dma_tx_cleanup_idx(dev, q, q->tail, &entry);

		if (entry.schedule)

			n_swq_queued[entry.qid]++;



		q->tail = (q->tail + 1) % q->ndesc;

		n_queued++;



		if (entry.skb)

			dev->drv->tx_complete_skb(dev, qid, &entry);

		mt76_queue_tx_complete(dev, q, &entry);



		if (entry.txwi) {

			if (!(dev->drv->drv_flags & MT_DRV_TXWI_NO_FREE))
@@ -178,29 +242,14 @@ mt76_dma_tx_cleanup(struct mt76_dev *dev, enum mt76_txq_id qid, bool flush) 


		if (!flush && q->tail == last)

			last = readl(&q->regs->dma_idx);

	}



	spin_lock_bh(&q->lock);



	q->queued -= n_queued;

	for (i = 0; i < 4; i++) {

		if (!n_swq_queued[i])

			continue;



		dev->q_tx[i].swq_queued -= n_swq_queued[i];

	}



	/* ext PHY */

	for (i = 0; i < 4; i++) {

		if (!n_swq_queued[i])

			continue;



		dev->q_tx[__MT_TXQ_MAX + i].swq_queued -= n_swq_queued[4 + i];

	}



	if (flush) {

		spin_lock_bh(&q->lock);

		mt76_dma_sync_idx(dev, q);

		mt76_dma_kick_queue(dev, q);

		spin_unlock_bh(&q->lock);

	}



	wake = wake && q->stopped &&
@@ -211,8 +260,6 @@ mt76_dma_tx_cleanup(struct mt76_dev *dev, enum mt76_txq_id qid, bool flush) 
	if (!q->queued)

		wake_up(&dev->tx_wait);



	spin_unlock_bh(&q->lock);



	if (wake)

		ieee80211_wake_queue(dev->hw, qid);

}
@@ -227,7 +274,7 @@ mt76_dma_get_buf(struct mt76_dev *dev, struct mt76_queue *q, int idx, 
	void *buf = e->buf;

	int buf_len = SKB_WITH_OVERHEAD(q->buf_size);



	buf_addr = le32_to_cpu(READ_ONCE(desc->buf0));

	buf_addr = e->dma_addr[0];

	if (len) {

		u32 ctl = le32_to_cpu(READ_ONCE(desc->ctrl));

		*len = FIELD_GET(MT_DMA_CTL_SD_LEN0, ctl);
@@ -268,7 +315,7 @@ static int 
mt76_dma_tx_queue_skb_raw(struct mt76_dev *dev, enum mt76_txq_id qid,

			  struct sk_buff *skb, u32 tx_info)

{

	struct mt76_queue *q = dev->q_tx[qid].q;

	struct mt76_queue *q = dev->q_tx[qid];

	struct mt76_queue_buf buf;

	dma_addr_t addr;
@@ -300,7 +347,7 @@ mt76_dma_tx_queue_skb(struct mt76_dev *dev, enum mt76_txq_id qid, 
		      struct sk_buff *skb, struct mt76_wcid *wcid,

		      struct ieee80211_sta *sta)

{

	struct mt76_queue *q = dev->q_tx[qid].q;

	struct mt76_queue *q = dev->q_tx[qid];

	struct mt76_tx_info tx_info = {

		.skb = skb,

	};
@@ -378,7 +425,7 @@ mt76_dma_tx_queue_skb(struct mt76_dev *dev, enum mt76_txq_id qid, 


	e.skb = tx_info.skb;

	e.txwi = t;

	dev->drv->tx_complete_skb(dev, qid, &e);

	dev->drv->tx_complete_skb(dev, &e);

	mt76_put_txwi(dev, t);

	return ret;

}
@@ -612,6 +659,7 @@ void mt76_dma_cleanup(struct mt76_dev *dev) 
{

	int i;



	mt76_worker_disable(&dev->tx_worker);

	netif_napi_del(&dev->tx_napi);

	for (i = 0; i < ARRAY_SIZE(dev->q_tx); i++)

		mt76_dma_tx_cleanup(dev, i, true);
@@ -620,5 +668,7 @@ void mt76_dma_cleanup(struct mt76_dev *dev) 
		netif_napi_del(&dev->napi[i]);

		mt76_dma_rx_cleanup(dev, &dev->q_rx[i]);

	}



	mt76_free_pending_txwi(dev);

}

EXPORT_SYMBOL_GPL(mt76_dma_cleanup);

drivers/net/wireless/mediatek/mt76/mac80211.c

+15 −28
Original line number Diff line number Diff line
@@ -2,6 +2,7 @@ 
/*

 * Copyright (C) 2016 Felix Fietkau <nbd@nbd.name>

 */

#include <linux/sched.h>

#include <linux/of.h>

#include "mt76.h"
@@ -304,11 +305,11 @@ mt76_phy_init(struct mt76_dev *dev, struct ieee80211_hw *hw) 
	ieee80211_hw_set(hw, SUPPORT_FAST_XMIT);

	ieee80211_hw_set(hw, SUPPORTS_CLONED_SKBS);

	ieee80211_hw_set(hw, SUPPORTS_AMSDU_IN_AMPDU);

	ieee80211_hw_set(hw, TX_AMSDU);



	/* TODO: avoid linearization for SDIO */

	if (!mt76_is_sdio(dev))

	if (!(dev->drv->drv_flags & MT_DRV_AMSDU_OFFLOAD)) {

		ieee80211_hw_set(hw, TX_AMSDU);

		ieee80211_hw_set(hw, TX_FRAG_LIST);

	}



	ieee80211_hw_set(hw, MFP_CAPABLE);

	ieee80211_hw_set(hw, AP_LINK_PS);
@@ -433,14 +434,13 @@ mt76_alloc_device(struct device *pdev, unsigned int size, 
	skb_queue_head_init(&dev->mcu.res_q);

	init_waitqueue_head(&dev->mcu.wait);

	mutex_init(&dev->mcu.mutex);

	dev->tx_worker.fn = mt76_tx_worker;



	INIT_LIST_HEAD(&dev->txwi_cache);



	for (i = 0; i < ARRAY_SIZE(dev->q_rx); i++)

		skb_queue_head_init(&dev->rx_skb[i]);



	tasklet_init(&dev->tx_tasklet, mt76_tx_tasklet, (unsigned long)dev);



	dev->wq = alloc_ordered_workqueue("mt76", 0);

	if (!dev->wq) {

		ieee80211_free_hw(hw);
@@ -483,7 +483,14 @@ int mt76_register_device(struct mt76_dev *dev, bool vht, 
			return ret;

	}



	return ieee80211_register_hw(hw);

	ret = ieee80211_register_hw(hw);

	if (ret)

		return ret;



	WARN_ON(mt76_worker_setup(hw, &dev->tx_worker, NULL, "tx"));

	sched_set_fifo_low(dev->tx_worker.task);



	return 0;

}

EXPORT_SYMBOL_GPL(mt76_register_device);
@@ -500,12 +507,11 @@ EXPORT_SYMBOL_GPL(mt76_unregister_device); 


void mt76_free_device(struct mt76_dev *dev)

{

	mt76_worker_teardown(&dev->tx_worker);

	if (dev->wq) {

		destroy_workqueue(dev->wq);

		dev->wq = NULL;

	}

	if (mt76_is_mmio(dev))

		mt76_tx_free(dev);

	ieee80211_free_hw(dev->hw);

}

EXPORT_SYMBOL_GPL(mt76_free_device);
@@ -540,7 +546,7 @@ bool mt76_has_tx_pending(struct mt76_phy *phy) 
	offset = __MT_TXQ_MAX * (phy != &dev->phy);



	for (i = 0; i < __MT_TXQ_MAX; i++) {

		q = dev->q_tx[offset + i].q;

		q = dev->q_tx[offset + i];

		if (q && q->queued)

			return true;

	}
@@ -870,7 +876,6 @@ mt76_check_sta(struct mt76_dev *dev, struct sk_buff *skb) 
	struct ieee80211_hw *hw;

	struct mt76_wcid *wcid = status->wcid;

	bool ps;

	int i;



	hw = mt76_phy_hw(dev, status->ext_phy);

	if (ieee80211_is_pspoll(hdr->frame_control) && !wcid) {
@@ -920,20 +925,6 @@ mt76_check_sta(struct mt76_dev *dev, struct sk_buff *skb) 


	dev->drv->sta_ps(dev, sta, ps);

	ieee80211_sta_ps_transition(sta, ps);



	if (ps)

		return;



	for (i = 0; i < ARRAY_SIZE(sta->txq); i++) {

		struct mt76_txq *mtxq;



		if (!sta->txq[i])

			continue;



		mtxq = (struct mt76_txq *)sta->txq[i]->drv_priv;

		if (!skb_queue_empty(&mtxq->retry_q))

			ieee80211_schedule_txq(hw, sta->txq[i]);

	}

}



void mt76_rx_complete(struct mt76_dev *dev, struct sk_buff_head *frames,
@@ -995,8 +986,6 @@ mt76_sta_add(struct mt76_dev *dev, struct ieee80211_vif *vif, 


		mtxq = (struct mt76_txq *)sta->txq[i]->drv_priv;

		mtxq->wcid = wcid;



		mt76_txq_init(dev, sta->txq[i]);

	}



	ewma_signal_init(&wcid->rssi);
@@ -1024,8 +1013,6 @@ void __mt76_sta_remove(struct mt76_dev *dev, struct ieee80211_vif *vif, 
		dev->drv->sta_remove(dev, vif, sta);



	mt76_tx_status_check(dev, wcid, true);

	for (i = 0; i < ARRAY_SIZE(sta->txq); i++)

		mt76_txq_remove(dev, sta->txq[i]);

	mt76_wcid_mask_clear(dev->wcid_mask, idx);

	mt76_wcid_mask_clear(dev->wcid_phy_mask, idx);

}

drivers/net/wireless/mediatek/mt76/mt76.h

+34 −27
Original line number Diff line number Diff line
@@ -17,11 +17,13 @@ 
#include "util.h"

#include "testmode.h"



#define MT_TX_RING_SIZE     256

#define MT_MCU_RING_SIZE    32

#define MT_RX_BUF_SIZE      2048

#define MT_SKB_HEAD_LEN     128



#define MT_MAX_NON_AQL_PKT  16

#define MT_TXQ_FREE_THR     32



struct mt76_dev;

struct mt76_phy;

struct mt76_wcid;
@@ -79,7 +81,8 @@ enum mt76_rxq_id { 


struct mt76_queue_buf {

	dma_addr_t addr;

	int len;

	u16 len;

	bool skip_unmap;

};



struct mt76_tx_info {
@@ -99,9 +102,11 @@ struct mt76_queue_entry { 
		struct urb *urb;

		int buf_sz;

	};

	enum mt76_txq_id qid;

	u32 dma_addr[2];

	u16 dma_len[2];

	u16 wcid;

	bool skip_buf0:1;

	bool schedule:1;

	bool skip_buf1:1;

	bool done:1;

};
@@ -135,13 +140,6 @@ struct mt76_queue { 
	struct page_frag_cache rx_page;

};



struct mt76_sw_queue {

	struct mt76_queue *q;



	struct list_head swq;

	int swq_queued;

};



struct mt76_mcu_ops {

	u32 headroom;

	u32 tailroom;
@@ -204,6 +202,7 @@ DECLARE_EWMA(signal, 10, 8); 
struct mt76_wcid {

	struct mt76_rx_tid __rcu *aggr[IEEE80211_NUM_TIDS];



	atomic_t non_aql_packets;

	unsigned long flags;



	struct ewma_signal rssi;
@@ -214,6 +213,7 @@ struct mt76_wcid { 


	u8 sta:1;

	u8 ext_phy:1;

	u8 amsdu:1;



	u8 rx_check_pn;

	u8 rx_key_pn[IEEE80211_NUM_TIDS][6];
@@ -226,11 +226,8 @@ struct mt76_wcid { 
};



struct mt76_txq {

	struct mt76_sw_queue *swq;

	struct mt76_wcid *wcid;



	struct sk_buff_head retry_q;



	u16 agg_ssn;

	bool send_bar;

	bool aggr;
@@ -309,6 +306,7 @@ struct mt76_hw_cap { 
#define MT_DRV_SW_RX_AIRTIME		BIT(2)

#define MT_DRV_RX_DMA_HDR		BIT(3)

#define MT_DRV_HW_MGMT_TXQ		BIT(4)

#define MT_DRV_AMSDU_OFFLOAD		BIT(5)



struct mt76_driver_ops {

	u32 drv_flags;
@@ -322,7 +320,7 @@ struct mt76_driver_ops { 
			      struct ieee80211_sta *sta,

			      struct mt76_tx_info *tx_info);



	void (*tx_complete_skb)(struct mt76_dev *dev, enum mt76_txq_id qid,

	void (*tx_complete_skb)(struct mt76_dev *dev,

				struct mt76_queue_entry *e);



	bool (*tx_status_data)(struct mt76_dev *dev, u8 *update);
@@ -445,14 +443,24 @@ struct mt76_usb { 
	} mcu;

};



#define MT76S_XMIT_BUF_SZ	(16 * PAGE_SIZE)

struct mt76_sdio {

	struct task_struct *tx_kthread;

	struct task_struct *kthread;

	struct workqueue_struct *txrx_wq;

	struct {

		struct work_struct xmit_work;

		struct work_struct status_work;

	} tx;

	struct {

		struct work_struct recv_work;

		struct work_struct net_work;

	} rx;



	struct work_struct stat_work;



	unsigned long state;

	u8 *xmit_buf[MT_TXQ_MCU_WA];



	struct sdio_func *func;

	void *intr_data;



	struct {

		struct mutex lock;
@@ -593,12 +601,12 @@ struct mt76_dev { 
	struct sk_buff_head rx_skb[__MT_RXQ_MAX];



	struct list_head txwi_cache;

	struct mt76_sw_queue q_tx[2 * __MT_TXQ_MAX];

	struct mt76_queue *q_tx[2 * __MT_TXQ_MAX];

	struct mt76_queue q_rx[__MT_RXQ_MAX];

	const struct mt76_queue_ops *queue_ops;

	int tx_dma_idx[4];



	struct tasklet_struct tx_tasklet;

	struct mt76_worker tx_worker;

	struct napi_struct tx_napi;

	struct delayed_work mac_work;
@@ -892,14 +900,13 @@ static inline bool mt76_testmode_enabled(struct mt76_dev *dev) 
void mt76_rx(struct mt76_dev *dev, enum mt76_rxq_id q, struct sk_buff *skb);

void mt76_tx(struct mt76_phy *dev, struct ieee80211_sta *sta,

	     struct mt76_wcid *wcid, struct sk_buff *skb);

void mt76_txq_init(struct mt76_dev *dev, struct ieee80211_txq *txq);

void mt76_txq_remove(struct mt76_dev *dev, struct ieee80211_txq *txq);

void mt76_wake_tx_queue(struct ieee80211_hw *hw, struct ieee80211_txq *txq);

void mt76_stop_tx_queues(struct mt76_dev *dev, struct ieee80211_sta *sta,

			 bool send_bar);

void mt76_tx_check_agg_ssn(struct ieee80211_sta *sta, struct sk_buff *skb);

void mt76_txq_schedule(struct mt76_phy *phy, enum mt76_txq_id qid);

void mt76_txq_schedule_all(struct mt76_phy *phy);

void mt76_tx_tasklet(unsigned long data);

void mt76_tx_worker(struct mt76_worker *w);

void mt76_release_buffered_frames(struct ieee80211_hw *hw,

				  struct ieee80211_sta *sta,

				  u16 tids, int nframes,
@@ -932,7 +939,7 @@ struct sk_buff *mt76_tx_status_skb_get(struct mt76_dev *dev, 
				       struct sk_buff_head *list);

void mt76_tx_status_skb_done(struct mt76_dev *dev, struct sk_buff *skb,

			     struct sk_buff_head *list);

void mt76_tx_complete_skb(struct mt76_dev *dev, struct sk_buff *skb);

void mt76_tx_complete_skb(struct mt76_dev *dev, u16 wcid, struct sk_buff *skb);

void mt76_tx_status_check(struct mt76_dev *dev, struct mt76_wcid *wcid,

			  bool flush);

int mt76_sta_state(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
@@ -996,8 +1003,6 @@ mt76_tx_status_get_hw(struct mt76_dev *dev, struct sk_buff *skb) 
	return hw;

}



void mt76_tx_free(struct mt76_dev *dev);

struct mt76_txwi_cache *mt76_get_txwi(struct mt76_dev *dev);

void mt76_put_txwi(struct mt76_dev *dev, struct mt76_txwi_cache *t);

void mt76_rx_complete(struct mt76_dev *dev, struct sk_buff_head *frames,

		      struct napi_struct *napi);
@@ -1005,6 +1010,8 @@ void mt76_rx_poll_complete(struct mt76_dev *dev, enum mt76_rxq_id q, 
			   struct napi_struct *napi);

void mt76_rx_aggr_reorder(struct sk_buff *skb, struct sk_buff_head *frames);

void mt76_testmode_tx_pending(struct mt76_dev *dev);

void mt76_queue_tx_complete(struct mt76_dev *dev, struct mt76_queue *q,

			    struct mt76_queue_entry *e);



/* usb */

static inline bool mt76u_urb_error(struct urb *urb)
@@ -1039,7 +1046,7 @@ mt76u_bulk_msg(struct mt76_dev *dev, void *data, int len, int *actual_len, 
	return usb_bulk_msg(udev, pipe, data, len, actual_len, timeout);

}



int mt76_skb_adjust_pad(struct sk_buff *skb);

int mt76_skb_adjust_pad(struct sk_buff *skb, int pad);

int mt76u_vendor_request(struct mt76_dev *dev, u8 req,

			 u8 req_type, u16 val, u16 offset,

			 void *buf, size_t len);

drivers/net/wireless/mediatek/mt76/mt7603/beacon.c

+4 −4
Original line number Diff line number Diff line
@@ -29,7 +29,7 @@ mt7603_update_beacon_iter(void *priv, u8 *mac, struct ieee80211_vif *vif) 
	mt76_wr(dev, MT_DMA_FQCR0, MT_DMA_FQCR0_BUSY |

		FIELD_PREP(MT_DMA_FQCR0_TARGET_WCID, mvif->sta.wcid.idx) |

		FIELD_PREP(MT_DMA_FQCR0_TARGET_QID,

			   dev->mt76.q_tx[MT_TXQ_CAB].q->hw_idx) |

			   dev->mt76.q_tx[MT_TXQ_CAB]->hw_idx) |

		FIELD_PREP(MT_DMA_FQCR0_DEST_PORT_ID, 3) |

		FIELD_PREP(MT_DMA_FQCR0_DEST_QUEUE_ID, 8));
@@ -78,7 +78,7 @@ void mt7603_pre_tbtt_tasklet(unsigned long arg) 
	data.dev = dev;

	__skb_queue_head_init(&data.q);



	q = dev->mt76.q_tx[MT_TXQ_BEACON].q;

	q = dev->mt76.q_tx[MT_TXQ_BEACON];

	spin_lock_bh(&q->lock);

	ieee80211_iterate_active_interfaces_atomic(mt76_hw(dev),

		IEEE80211_IFACE_ITER_RESUME_ALL,
@@ -95,7 +95,7 @@ void mt7603_pre_tbtt_tasklet(unsigned long arg) 
	if (dev->mt76.csa_complete)

		goto out;



	q = dev->mt76.q_tx[MT_TXQ_CAB].q;

	q = dev->mt76.q_tx[MT_TXQ_CAB];

	do {

		nframes = skb_queue_len(&data.q);

		ieee80211_iterate_active_interfaces_atomic(mt76_hw(dev),
@@ -136,7 +136,7 @@ void mt7603_pre_tbtt_tasklet(unsigned long arg) 


out:

	mt76_queue_tx_cleanup(dev, MT_TXQ_BEACON, false);

	if (dev->mt76.q_tx[MT_TXQ_BEACON].q->queued >

	if (dev->mt76.q_tx[MT_TXQ_BEACON]->queued >

	    hweight8(dev->mt76.beacon_mask))

		dev->beacon_check++;

}