Skip to contentSkip to conversation

mt76: add driver callback for when a sta is associated

PATCH Superseded Felix Fietkau 5 participants 6 messages Jan 30, 2019 – Feb 25, 2019 2 messages not in the archive

Subsystems (4)

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore

Felix Fietkau

author maintainer
#0 lore raw

PATCH 1/3 mt76: add driver callback for when a sta is associated

MT7603 needs this to update the HT/VHT capabilities

---
 drivers/net/wireless/mediatek/mt76/mac80211.c | 5 +++++
 drivers/net/wireless/mediatek/mt76/mt76.h     | 3 +++
 2 files changed, 8 insertions(+)
drivers/net/wireless/mediatek/mt76/mac80211.c +5 -0
index ee3b65a14870..489953a47646 100644
@@ -709,6 +709,11 @@ int mt76_sta_state(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
 	    new_state == IEEE80211_STA_NONE)
 		return mt76_sta_add(dev, vif, sta);
 
+	if (old_state == IEEE80211_STA_AUTH &&
+	    new_state == IEEE80211_STA_ASSOC &&
+	    dev->drv->sta_assoc)
+		dev->drv->sta_assoc(dev, vif, sta);
+
 	if (old_state == IEEE80211_STA_NONE &&
 		 new_state == IEEE80211_STA_NOTEXIST)
 		mt76_sta_remove(dev, vif, sta);
drivers/net/wireless/mediatek/mt76/mt76.h +3 -0
index 2bb9db4ed80a..71708b111120 100644
@@ -300,6 +300,9 @@ struct mt76_driver_ops {
 	int (*sta_add)(struct mt76_dev *dev, struct ieee80211_vif *vif,
 		       struct ieee80211_sta *sta);
 
+	void (*sta_assoc)(struct mt76_dev *dev, struct ieee80211_vif *vif,
+			  struct ieee80211_sta *sta);
+
 	void (*sta_remove)(struct mt76_dev *dev, struct ieee80211_vif *vif,
 			   struct ieee80211_sta *sta);
 };
Signature · 1 line
2.17.0

A message that is not in the archive (sent off-list or not yet received): [email protected]

#2 lore raw

PATCH 2/3 dt-bindings: net: mt76: update binding for mt7603 driver

In addition to MT7603E PCI devices, the driver supports the WLAN core on MT7628/MT7688, which needs to be defined in DT.

---
 .../bindings/net/wireless/mediatek,mt76.txt   | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
Documentation/devicetree/bindings/net/wireless/mediatek,mt76.txt +19 -0
index 0c17a0ec9b7b..7b9a776230c0 100644
@@ -4,6 +4,13 @@ This node provides properties for configuring the MediaTek mt76xx wireless
 device. The node is expected to be specified as a child node of the PCI
 controller to which the wireless chip is connected.
 
+Alternatively, it can specify the wireless part of the MT7628/MT7688 SoC.
+For SoC, use the compatible string "mediatek,mt7628-wmac" and the following
+properties:
+
+- reg: Address and length of the register set for the device.
+- interrupts: Main device interrupt
+
 Optional properties:
 
 - mac-address: See ethernet.txt in the parent directory
@@ -30,3 +37,15 @@ Optional nodes:
 		};
 	};
 };
+
+MT7628 example:
+
+wmac: wmac@10300000 {
+	compatible = "mediatek,mt7628-wmac";
+	reg = <0x10300000 0x100000>;
+
+	interrupt-parent = <&cpuintc>;
+	interrupts = <6>;
+
+	mediatek,mtd-eeprom = <&factory 0x0000>;
+};
Signature · 1 line
2.17.0

A message that is not in the archive (sent off-list or not yet received): [email protected]

Reviewed-by
#4 lore raw

Re: [PATCH 2/3] dt-bindings: net: mt76: update binding for mt7603 driver

Quoted 8 lines · Felix Fietkau

In addition to MT7603E PCI devices, the driver supports the WLAN core on MT7628/MT7688, which needs to be defined in DT.

---
 .../bindings/net/wireless/mediatek,mt76.txt   | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
author maintainer
#5 lore raw

PATCH 3/3 mt76: add driver for MT7603E and MT7628/7688

In reply to Felix Fietkau

This driver is for a newer generation of 2x2 MediaTek 802.11n chipsets. MT7603E is a PCIe chip.
MT7628 and MT7688 are MIPS SoC devices with built-in WLAN. MT7688 is limited to 1x1

This driver fully supports AP, station, mesh, ad-hoc and monitor mode.

---
 drivers/net/wireless/mediatek/mt76/Kconfig    |    1 +
 drivers/net/wireless/mediatek/mt76/Makefile   |    1 +
 .../net/wireless/mediatek/mt76/mt7603/Kconfig |    9 +
 .../wireless/mediatek/mt76/mt7603/Makefile    |    6 +
 .../wireless/mediatek/mt76/mt7603/beacon.c    |  201 ++
 .../net/wireless/mediatek/mt76/mt7603/core.c  |   88 +
 .../wireless/mediatek/mt76/mt7603/debugfs.c   |   71 +
 .../net/wireless/mediatek/mt76/mt7603/dma.c   |  253 +++
 .../wireless/mediatek/mt76/mt7603/eeprom.c    |  183 ++
 .../wireless/mediatek/mt76/mt7603/eeprom.h    |  101 +
 .../net/wireless/mediatek/mt76/mt7603/init.c  |  608 ++++++
 .../net/wireless/mediatek/mt76/mt7603/mac.c   | 1764 +++++++++++++++++
 .../net/wireless/mediatek/mt76/mt7603/mac.h   |  257 +++
 .../net/wireless/mediatek/mt76/mt7603/main.c  |  730 +++++++
 .../net/wireless/mediatek/mt76/mt7603/mcu.c   |  536 +++++
 .../net/wireless/mediatek/mt76/mt7603/mcu.h   |  118 ++
 .../wireless/mediatek/mt76/mt7603/mt7603.h    |  271 +++
 .../net/wireless/mediatek/mt76/mt7603/pci.c   |   92 +
 .../net/wireless/mediatek/mt76/mt7603/regs.h  |  789 ++++++++
 .../net/wireless/mediatek/mt76/mt7603/soc.c   |   97 +
 20 files changed, 6176 insertions(+)
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/Kconfig
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/Makefile
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/beacon.c
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/core.c
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/debugfs.c
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/dma.c
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/eeprom.c
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/eeprom.h
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/init.c
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/mac.c
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/mac.h
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/main.c
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/mcu.c
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/mcu.h
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/mt7603.h
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/pci.c
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/regs.h
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/soc.c
drivers/net/wireless/mediatek/mt76/Kconfig +1 -0
index c30d8f5bbf2a..dbe8c70a8f73 100644
@@ -21,3 +21,4 @@ config MT76x02_USB
 
 source "drivers/net/wireless/mediatek/mt76/mt76x0/Kconfig"
 source "drivers/net/wireless/mediatek/mt76/mt76x2/Kconfig"
+source "drivers/net/wireless/mediatek/mt76/mt7603/Kconfig"
drivers/net/wireless/mediatek/mt76/Makefile +1 -0
index 1a45cb30f39f..40615327ab68 100644
@@ -21,3 +21,4 @@ mt76x02-usb-y := mt76x02_usb_mcu.o mt76x02_usb_core.o
 
 obj-$(CONFIG_MT76x0_COMMON) += mt76x0/
 obj-$(CONFIG_MT76x2_COMMON) += mt76x2/
+obj-$(CONFIG_MT7603E) += mt7603/
drivers/net/wireless/mediatek/mt76/mt7603/Kconfig new file +9 -0
new file mode 100644
index 000000000000..087945c3d8f3
@@ -0,0 +1,9 @@
+config MT7603E
+	tristate "MediaTek MT7603E (PCIe) and MT76x8 WLAN support"
+	select MT76_CORE
+	depends on MAC80211
+	depends on PCI
+	help
+	  This adds support for MT7603E wireless PCIe devices and the WLAN core on
+	  MT7628/MT7688 SoC devices
+
drivers/net/wireless/mediatek/mt76/mt7603/Makefile new file +6 -0
new file mode 100644
index 000000000000..d95a30421c62
@@ -0,0 +1,6 @@
+obj-$(CONFIG_MT7603E) += mt7603e.o
+
+mt7603e-y := \
+	pci.o soc.o main.o init.o mcu.o \
+	core.o dma.o mac.o eeprom.o \
+	beacon.o debugfs.o
drivers/net/wireless/mediatek/mt76/mt7603/beacon.c new file +201 -0

201 lines not on this page · raw message

drivers/net/wireless/mediatek/mt76/mt7603/core.c new file +88 -0

88 lines not on this page · raw message

drivers/net/wireless/mediatek/mt76/mt7603/debugfs.c new file +71 -0

71 lines not on this page · raw message

drivers/net/wireless/mediatek/mt76/mt7603/dma.c new file +253 -0

253 lines not on this page · raw message

drivers/net/wireless/mediatek/mt76/mt7603/eeprom.c new file +183 -0

183 lines not on this page · raw message

drivers/net/wireless/mediatek/mt76/mt7603/eeprom.h new file +101 -0

101 lines not on this page · raw message

drivers/net/wireless/mediatek/mt76/mt7603/init.c new file +608 -0

608 lines not on this page · raw message

drivers/net/wireless/mediatek/mt76/mt7603/mac.c new file +1764 -0

1,472 lines not on this page · raw message

drivers/net/wireless/mediatek/mt76/mt7603/mac.h new file +257 -0

257 lines not on this page · raw message

drivers/net/wireless/mediatek/mt76/mt7603/main.c new file +730 -0

730 lines not on this page · raw message

drivers/net/wireless/mediatek/mt76/mt7603/mcu.c new file +536 -0

536 lines not on this page · raw message

drivers/net/wireless/mediatek/mt76/mt7603/mcu.h new file +118 -0

118 lines not on this page · raw message

drivers/net/wireless/mediatek/mt76/mt7603/mt7603.h new file +271 -0

271 lines not on this page · raw message

drivers/net/wireless/mediatek/mt76/mt7603/pci.c new file +92 -0

92 lines not on this page · raw message

drivers/net/wireless/mediatek/mt76/mt7603/regs.h new file +789 -0

789 lines not on this page · raw message

drivers/net/wireless/mediatek/mt76/mt7603/soc.c new file +97 -0

97 lines not on this page · raw message

The rest of this diff is not shown. View the raw message.

Signature · 1 line
2.17.0

Part of the diff is not shown here. View the raw message.

Tested-by on v1 3/3
#6 lore raw

Re: [PATCH 3/3] mt76: add driver for MT7603E and MT7628/7688

Quoted 10 lines

This driver is for a newer generation of 2x2 MediaTek 802.11n chipsets. MT7603E is a PCIe chip.
MT7628 and MT7688 are MIPS SoC devices with built-in WLAN. MT7688 is limited to 1x1

This driver fully supports AP, station, mesh, ad-hoc and monitor mode.

---

Quoted 6,343 lines
 drivers/net/wireless/mediatek/mt76/Kconfig    |    1 +
 drivers/net/wireless/mediatek/mt76/Makefile   |    1 +
 .../net/wireless/mediatek/mt76/mt7603/Kconfig |    9 +
 .../wireless/mediatek/mt76/mt7603/Makefile    |    6 +
 .../wireless/mediatek/mt76/mt7603/beacon.c    |  201 ++
 .../net/wireless/mediatek/mt76/mt7603/core.c  |   88 +
 .../wireless/mediatek/mt76/mt7603/debugfs.c   |   71 +
 .../net/wireless/mediatek/mt76/mt7603/dma.c   |  253 +++
 .../wireless/mediatek/mt76/mt7603/eeprom.c    |  183 ++
 .../wireless/mediatek/mt76/mt7603/eeprom.h    |  101 +
 .../net/wireless/mediatek/mt76/mt7603/init.c  |  608 ++++++
 .../net/wireless/mediatek/mt76/mt7603/mac.c   | 1764 +++++++++++++++++
 .../net/wireless/mediatek/mt76/mt7603/mac.h   |  257 +++
 .../net/wireless/mediatek/mt76/mt7603/main.c  |  730 +++++++
 .../net/wireless/mediatek/mt76/mt7603/mcu.c   |  536 +++++
 .../net/wireless/mediatek/mt76/mt7603/mcu.h   |  118 ++
 .../wireless/mediatek/mt76/mt7603/mt7603.h    |  271 +++
 .../net/wireless/mediatek/mt76/mt7603/pci.c   |   92 +
 .../net/wireless/mediatek/mt76/mt7603/regs.h  |  789 ++++++++
 .../net/wireless/mediatek/mt76/mt7603/soc.c   |   97 +
 20 files changed, 6176 insertions(+)
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/Kconfig
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/Makefile
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/beacon.c
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/core.c
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/debugfs.c
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/dma.c
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/eeprom.c
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/eeprom.h
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/init.c
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/mac.c
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/mac.h
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/main.c
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/mcu.c
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/mcu.h
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/mt7603.h
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/pci.c
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/regs.h
 create mode 100644 drivers/net/wireless/mediatek/mt76/mt7603/soc.c
drivers/net/wireless/mediatek/mt76/Kconfig +1 -0
index c30d8f5bbf2a..dbe8c70a8f73 100644
@@ -21,3 +21,4 @@ config MT76x02_USB
 
 source "drivers/net/wireless/mediatek/mt76/mt76x0/Kconfig"
 source "drivers/net/wireless/mediatek/mt76/mt76x2/Kconfig"
+source "drivers/net/wireless/mediatek/mt76/mt7603/Kconfig"
drivers/net/wireless/mediatek/mt76/Makefile +1 -0
index 1a45cb30f39f..40615327ab68 100644
@@ -21,3 +21,4 @@ mt76x02-usb-y := mt76x02_usb_mcu.o mt76x02_usb_core.o
 
 obj-$(CONFIG_MT76x0_COMMON) += mt76x0/
 obj-$(CONFIG_MT76x2_COMMON) += mt76x2/
+obj-$(CONFIG_MT7603E) += mt7603/
drivers/net/wireless/mediatek/mt76/mt7603/Kconfig new file +9 -0
new file mode 100644
index 000000000000..087945c3d8f3
@@ -0,0 +1,9 @@
+config MT7603E
+       tristate "MediaTek MT7603E (PCIe) and MT76x8 WLAN support"
+       select MT76_CORE
+       depends on MAC80211
+       depends on PCI
+       help
+         This adds support for MT7603E wireless PCIe devices and the WLAN core on
+         MT7628/MT7688 SoC devices
+
drivers/net/wireless/mediatek/mt76/mt7603/Makefile new file +6 -0
new file mode 100644
index 000000000000..d95a30421c62
@@ -0,0 +1,6 @@
+obj-$(CONFIG_MT7603E) += mt7603e.o
+
+mt7603e-y := \
+       pci.o soc.o main.o init.o mcu.o \
+       core.o dma.o mac.o eeprom.o \
+       beacon.o debugfs.o
drivers/net/wireless/mediatek/mt76/mt7603/beacon.c new file +201 -0
new file mode 100644
index 000000000000..0f6f679bbe73
@@ -0,0 +1,201 @@
+/* SPDX-License-Identifier: ISC */
+/*
+ * Copyright (C) 2016 Felix Fietkau <[email protected]>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "mt7603.h"
+
+struct beacon_bc_data {
+       struct mt7603_dev *dev;
+       struct sk_buff_head q;
+       struct sk_buff *tail[MT7603_MAX_INTERFACES];
+       int count[MT7603_MAX_INTERFACES];
+};
+
+static void
+mt7603_update_beacon_iter(void *priv, u8 *mac, struct ieee80211_vif *vif)
+{
+       struct mt7603_dev *dev = (struct mt7603_dev *)priv;
+       struct mt7603_vif *mvif = (struct mt7603_vif *)vif->drv_priv;
+       struct sk_buff *skb = NULL;
+
+       if (!(dev->beacon_mask & BIT(mvif->idx)))
+               return;
+
+       skb = ieee80211_beacon_get(mt76_hw(dev), vif);
+       if (!skb)
+               return;
+
+       mt76_dma_tx_queue_skb(&dev->mt76, &dev->mt76.q_tx[MT_TXQ_BEACON], skb,
+                             &mvif->sta.wcid, NULL);
+
+       spin_lock_bh(&dev->ps_lock);
+       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].hw_idx) |
+               FIELD_PREP(MT_DMA_FQCR0_DEST_PORT_ID, 3) |
+               FIELD_PREP(MT_DMA_FQCR0_DEST_QUEUE_ID, 8));
+
+       if (!mt76_poll(dev, MT_DMA_FQCR0, MT_DMA_FQCR0_BUSY, 0, 5000))
+               dev->beacon_check = MT7603_WATCHDOG_TIMEOUT;
+
+       spin_unlock_bh(&dev->ps_lock);
+}
+
+static void
+mt7603_add_buffered_bc(void *priv, u8 *mac, struct ieee80211_vif *vif)
+{
+       struct beacon_bc_data *data = priv;
+       struct mt7603_dev *dev = data->dev;
+       struct mt7603_vif *mvif = (struct mt7603_vif *)vif->drv_priv;
+       struct ieee80211_tx_info *info;
+       struct sk_buff *skb;
+
+       if (!(dev->beacon_mask & BIT(mvif->idx)))
+               return;
+
+       skb = ieee80211_get_buffered_bc(mt76_hw(dev), vif);
+       if (!skb)
+               return;
+
+       info = IEEE80211_SKB_CB(skb);
+       info->control.vif = vif;
+       info->flags |= IEEE80211_TX_CTL_ASSIGN_SEQ;
+       mt76_skb_set_moredata(skb, true);
+       __skb_queue_tail(&data->q, skb);
+       data->tail[mvif->idx] = skb;
+       data->count[mvif->idx]++;
+}
+
+void mt7603_pre_tbtt_tasklet(unsigned long arg)
+{
+       struct mt7603_dev *dev = (struct mt7603_dev *)arg;
+       struct mt76_queue *q;
+       struct beacon_bc_data data = {};
+       struct sk_buff *skb;
+       int i, nframes;
+
+       data.dev = dev;
+       __skb_queue_head_init(&data.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,
+               mt7603_update_beacon_iter, dev);
+       mt76_queue_kick(dev, q);
+       spin_unlock_bh(&q->lock);
+
+       /* Flush all previous CAB queue packets */
+       mt76_wr(dev, MT_WF_ARB_CAB_FLUSH, GENMASK(30, 16) | BIT(0));
+
+       mt76_queue_tx_cleanup(dev, MT_TXQ_CAB, false);
+
+       mt76_csa_check(&dev->mt76);
+       if (dev->mt76.csa_complete)
+               goto out;
+
+       q = &dev->mt76.q_tx[MT_TXQ_CAB];
+       do {
+               nframes = skb_queue_len(&data.q);
+               ieee80211_iterate_active_interfaces_atomic(mt76_hw(dev),
+                       IEEE80211_IFACE_ITER_RESUME_ALL,
+                       mt7603_add_buffered_bc, &data);
+       } while (nframes != skb_queue_len(&data.q) &&
+                skb_queue_len(&data.q) < 8);
+
+       if (skb_queue_empty(&data.q))
+               goto out;
+
+       for (i = 0; i < ARRAY_SIZE(data.tail); i++) {
+               if (!data.tail[i])
+                       continue;
+
+               mt76_skb_set_moredata(data.tail[i], false);
+       }
+
+       spin_lock_bh(&q->lock);
+       while ((skb = __skb_dequeue(&data.q)) != NULL) {
+               struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+               struct ieee80211_vif *vif = info->control.vif;
+               struct mt7603_vif *mvif = (struct mt7603_vif *)vif->drv_priv;
+
+               mt76_dma_tx_queue_skb(&dev->mt76, q, skb, &mvif->sta.wcid,
+                                     NULL);
+       }
+       mt76_queue_kick(dev, q);
+       spin_unlock_bh(&q->lock);
+
+       for (i = 0; i < ARRAY_SIZE(data.count); i++)
+               mt76_wr(dev, MT_WF_ARB_CAB_COUNT_B0_REG(i),
+                       data.count[i] << MT_WF_ARB_CAB_COUNT_B0_SHIFT(i));
+
+       mt76_wr(dev, MT_WF_ARB_CAB_START,
+               MT_WF_ARB_CAB_START_BSSn(0) |
+               (MT_WF_ARB_CAB_START_BSS0n(1) *
+                ((1 << (MT7603_MAX_INTERFACES - 1)) - 1)));
+
+out:
+       mt76_queue_tx_cleanup(dev, MT_TXQ_BEACON, false);
+       if (dev->mt76.q_tx[MT_TXQ_BEACON].queued >
+           __sw_hweight8(dev->beacon_mask))
+               dev->beacon_check++;
+}
+
+void mt7603_beacon_set_timer(struct mt7603_dev *dev, int idx, int intval)
+{
+       u32 pre_tbtt = MT7603_PRE_TBTT_TIME / 64;
+
+       if (idx >= 0) {
+               if (intval)
+                       dev->beacon_mask |= BIT(idx);
+               else
+                       dev->beacon_mask &= ~BIT(idx);
+       }
+
+       if (!dev->beacon_mask || (!intval && idx < 0)) {
+               mt7603_irq_disable(dev, MT_INT_MAC_IRQ3);
+               mt76_clear(dev, MT_ARB_SCR, MT_ARB_SCR_BCNQ_OPMODE_MASK);
+               mt76_wr(dev, MT_HW_INT_MASK(3), 0);
+               return;
+       }
+
+       dev->beacon_int = intval;
+       mt76_wr(dev, MT_TBTT,
+               FIELD_PREP(MT_TBTT_PERIOD, intval) | MT_TBTT_CAL_ENABLE);
+
+       mt76_wr(dev, MT_TBTT_TIMER_CFG, 0x99); /* start timer */
+
+       mt76_rmw_field(dev, MT_ARB_SCR, MT_ARB_SCR_BCNQ_OPMODE_MASK,
+                      MT_BCNQ_OPMODE_AP);
+       mt76_clear(dev, MT_ARB_SCR, MT_ARB_SCR_TBTT_BCN_PRIO);
+       mt76_set(dev, MT_ARB_SCR, MT_ARB_SCR_TBTT_BCAST_PRIO);
+
+       mt76_wr(dev, MT_PRE_TBTT, pre_tbtt);
+
+       mt76_set(dev, MT_HW_INT_MASK(3),
+                MT_HW_INT3_PRE_TBTT0 | MT_HW_INT3_TBTT0);
+
+       mt76_set(dev, MT_WF_ARB_BCN_START,
+                MT_WF_ARB_BCN_START_BSSn(0) |
+                ((dev->beacon_mask >> 1) * MT_WF_ARB_BCN_START_BSS0n(1)));
+       mt7603_irq_enable(dev, MT_INT_MAC_IRQ3);
+
+       if (dev->beacon_mask & ~BIT(0))
+               mt76_set(dev, MT_LPON_SBTOR(0), MT_LPON_SBTOR_SUB_BSS_EN);
+       else
+               mt76_clear(dev, MT_LPON_SBTOR(0), MT_LPON_SBTOR_SUB_BSS_EN);
+}
drivers/net/wireless/mediatek/mt76/mt7603/core.c new file +88 -0
new file mode 100644
index 000000000000..30ffc68b0208
@@ -0,0 +1,88 @@
+/* SPDX-License-Identifier: ISC */
+/*
+ * Copyright (C) 2016 Felix Fietkau <[email protected]>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "mt7603.h"
+
+void mt7603_set_irq_mask(struct mt7603_dev *dev, u32 clear, u32 set)
+{
+       unsigned long flags;
+
+       spin_lock_irqsave(&dev->mt76.mmio.irq_lock, flags);
+       dev->mt76.mmio.irqmask &= ~clear;
+       dev->mt76.mmio.irqmask |= set;
+       mt76_wr(dev, MT_INT_MASK_CSR, dev->mt76.mmio.irqmask);
+       spin_unlock_irqrestore(&dev->mt76.mmio.irq_lock, flags);
+}
+
+void mt7603_rx_poll_complete(struct mt76_dev *mdev, enum mt76_rxq_id q)
+{
+       struct mt7603_dev *dev = container_of(mdev, struct mt7603_dev, mt76);
+
+       mt7603_irq_enable(dev, MT_INT_RX_DONE(q));
+}
+
+irqreturn_t mt7603_irq_handler(int irq, void *dev_instance)
+{
+       struct mt7603_dev *dev = dev_instance;
+       u32 intr;
+
+       intr = mt76_rr(dev, MT_INT_SOURCE_CSR);
+       mt76_wr(dev, MT_INT_SOURCE_CSR, intr);
+
+       if (!test_bit(MT76_STATE_INITIALIZED, &dev->mt76.state))
+               return IRQ_NONE;
+
+       intr &= dev->mt76.mmio.irqmask;
+
+       if (intr & MT_INT_MAC_IRQ3) {
+               u32 hwintr = mt76_rr(dev, MT_HW_INT_STATUS(3));
+
+               mt76_wr(dev, MT_HW_INT_STATUS(3), hwintr);
+               if (hwintr & MT_HW_INT3_PRE_TBTT0)
+                       tasklet_schedule(&dev->pre_tbtt_tasklet);
+
+               if ((hwintr & MT_HW_INT3_TBTT0) && dev->mt76.csa_complete)
+                       mt76_csa_finish(&dev->mt76);
+       }
+
+       if (intr & MT_INT_TX_DONE_ALL) {
+               mt7603_irq_disable(dev, MT_INT_TX_DONE_ALL);
+               tasklet_schedule(&dev->tx_tasklet);
+       }
+
+       if (intr & MT_INT_RX_DONE(0)) {
+               mt7603_irq_disable(dev, MT_INT_RX_DONE(0));
+               napi_schedule(&dev->mt76.napi[0]);
+       }
+
+       if (intr & MT_INT_RX_DONE(1)) {
+               mt7603_irq_disable(dev, MT_INT_RX_DONE(1));
+               napi_schedule(&dev->mt76.napi[1]);
+       }
+
+       return IRQ_HANDLED;
+}
+
+u32 mt7603_reg_map(struct mt7603_dev *dev, u32 addr)
+{
+       u32 base = addr & GENMASK(31, 19);
+       u32 offset = addr & GENMASK(18, 0);
+
+       dev->bus_ops->wr(&dev->mt76, MT_MCU_PCIE_REMAP_2, base);
+
+       return MT_PCIE_REMAP_BASE_2 + offset;
+}
drivers/net/wireless/mediatek/mt76/mt7603/debugfs.c new file +71 -0
new file mode 100644
index 000000000000..ca7b109c78a6
@@ -0,0 +1,71 @@
+/* SPDX-License-Identifier: ISC */
+/*
+ * Copyright (C) 2016 Felix Fietkau <[email protected]>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "mt7603.h"
+
+static int
+mt7603_reset_read(struct seq_file *s, void *data)
+{
+       struct mt7603_dev *dev = dev_get_drvdata(s->private);
+       static const char * const reset_cause_str[] = {
+               [RESET_CAUSE_TX_HANG] = "TX hang",
+               [RESET_CAUSE_TX_BUSY] = "TX DMA busy stuck",
+               [RESET_CAUSE_RX_BUSY] = "RX DMA busy stuck",
+               [RESET_CAUSE_RX_PSE_BUSY] = "RX PSE busy stuck",
+               [RESET_CAUSE_BEACON_STUCK] = "Beacon stuck",
+               [RESET_CAUSE_MCU_HANG] = "MCU hang",
+               [RESET_CAUSE_RESET_FAILED] = "PSE reset failed",
+       };
+       int i;
+
+       for (i = 0; i < ARRAY_SIZE(reset_cause_str); i++) {
+               if (!reset_cause_str[i])
+                       continue;
+
+               seq_printf(s, "%20s: %u\n", reset_cause_str[i],
+                          dev->reset_cause[i]);
+       }
+
+       return 0;
+}
+
+static int
+mt7603_radio_read(struct seq_file *s, void *data)
+{
+       struct mt7603_dev *dev = dev_get_drvdata(s->private);
+
+       seq_printf(s, "Sensitivity: %d\n", dev->sensitivity);
+       seq_printf(s, "False CCA: ofdm=%d cck=%d\n",
+                  dev->false_cca_ofdm, dev->false_cca_cck);
+
+       return 0;
+}
+
+void mt7603_init_debugfs(struct mt7603_dev *dev)
+{
+       struct dentry *dir;
+
+       dir = mt76_register_debugfs(&dev->mt76);
+       if (!dir)
+               return;
+
+       debugfs_create_u32("reset_test", 0600, dir, &dev->reset_test);
+       debugfs_create_devm_seqfile(dev->mt76.dev, "reset", dir,
+                                   mt7603_reset_read);
+       debugfs_create_devm_seqfile(dev->mt76.dev, "radio", dir,
+                                   mt7603_radio_read);
+}
drivers/net/wireless/mediatek/mt76/mt7603/dma.c new file +253 -0
new file mode 100644
index 000000000000..75ec077d8d74
@@ -0,0 +1,253 @@
+/* SPDX-License-Identifier: ISC */
+/*
+ * Copyright (C) 2016 Felix Fietkau <[email protected]>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "mt7603.h"
+#include "mac.h"
+#include "../dma.h"
+
+int
+mt7603_tx_queue_mcu(struct mt7603_dev *dev, enum mt76_txq_id qid,
+                   struct sk_buff *skb)
+{
+       struct mt76_queue *q = &dev->mt76.q_tx[qid];
+       struct mt76_queue_buf buf;
+       dma_addr_t addr;
+
+       addr = dma_map_single(dev->mt76.dev, skb->data, skb->len,
+                             DMA_TO_DEVICE);
+       if (dma_mapping_error(dev->mt76.dev, addr))
+               return -ENOMEM;
+
+       buf.addr = addr;
+       buf.len = skb->len;
+       spin_lock_bh(&q->lock);
+       mt76_queue_add_buf(dev, q, &buf, 1, 0, skb, NULL);
+       mt76_queue_kick(dev, q);
+       spin_unlock_bh(&q->lock);
+
+       return 0;
+}
+
+static int
+mt7603_init_tx_queue(struct mt7603_dev *dev, struct mt76_queue *q,
+                    int idx, int n_desc)
+{
+       int ret;
+
+       q->hw_idx = idx;
+       q->regs = dev->mt76.mmio.regs + MT_TX_RING_BASE + idx * MT_RING_SIZE;
+       q->ndesc = n_desc;
+
+       ret = mt76_queue_alloc(dev, q);
+       if (ret)
+               return ret;
+
+       mt7603_irq_enable(dev, MT_INT_TX_DONE(idx));
+
+       return 0;
+}
+
+static void
+mt7603_rx_loopback_skb(struct mt7603_dev *dev, struct sk_buff *skb)
+{
+       __le32 *txd = (__le32 *)skb->data;
+       struct mt7603_sta *msta;
+       struct mt76_wcid *wcid;
+       int idx;
+       u32 val;
+
+       if (skb->len < sizeof(MT_TXD_SIZE) + sizeof(struct ieee80211_hdr))
+               goto free;
+
+       val = le32_to_cpu(txd[1]);
+       idx = FIELD_GET(MT_TXD1_WLAN_IDX, val);
+       skb->priority = FIELD_GET(MT_TXD1_TID, val);
+
+       if (idx >= MT7603_WTBL_STA - 1)
+               goto free;
+
+       wcid = rcu_dereference(dev->mt76.wcid[idx]);
+       if (!wcid)
+               goto free;
+
+       msta = container_of(wcid, struct mt7603_sta, wcid);
+       val = le32_to_cpu(txd[0]);
+       skb_set_queue_mapping(skb, FIELD_GET(MT_TXD0_Q_IDX, val));
+
+       spin_lock_bh(&dev->ps_lock);
+       __skb_queue_tail(&msta->psq, skb);
+       if (skb_queue_len(&msta->psq) >= 64) {
+               skb = __skb_dequeue(&msta->psq);
+               dev_kfree_skb(skb);
+       }
+       spin_unlock_bh(&dev->ps_lock);
+       return;
+
+free:
+       dev_kfree_skb(skb);
+}
+
+void mt7603_queue_rx_skb(struct mt76_dev *mdev, enum mt76_rxq_id q,
+                        struct sk_buff *skb)
+{
+       struct mt7603_dev *dev = container_of(mdev, struct mt7603_dev, mt76);
+       __le32 *rxd = (__le32 *)skb->data;
+       __le32 *end = (__le32 *)&skb->data[skb->len];
+       enum rx_pkt_type type;
+
+       type = FIELD_GET(MT_RXD0_PKT_TYPE, le32_to_cpu(rxd[0]));
+
+       if (q == MT_RXQ_MCU) {
+               if (type == PKT_TYPE_RX_EVENT)
+                       mt7603_mcu_rx_event(dev, skb);
+               else
+                       mt7603_rx_loopback_skb(dev, skb);
+               return;
+       }
+
+       switch (type) {
+       case PKT_TYPE_TXS:
+               for (rxd++; rxd + 5 <= end; rxd += 5)
+                       mt7603_mac_add_txs(dev, rxd);
+               dev_kfree_skb(skb);
+               break;
+       case PKT_TYPE_RX_EVENT:
+               mt7603_mcu_rx_event(dev, skb);
+               return;
+       case PKT_TYPE_NORMAL:
+               if (mt7603_mac_fill_rx(dev, skb) == 0) {
+                       mt76_rx(&dev->mt76, q, skb);
+                       return;
+               }
+               /* fall through */
+       default:
+               dev_kfree_skb(skb);
+               break;
+       }
+}
+
+static int
+mt7603_init_rx_queue(struct mt7603_dev *dev, struct mt76_queue *q,
+                    int idx, int n_desc, int bufsize)
+{
+       int ret;
+
+       q->regs = dev->mt76.mmio.regs + MT_RX_RING_BASE + idx * MT_RING_SIZE;
+       q->ndesc = n_desc;
+       q->buf_size = bufsize;
+
+       ret = mt76_queue_alloc(dev, q);
+       if (ret)
+               return ret;
+
+       mt7603_irq_enable(dev, MT_INT_RX_DONE(idx));
+
+       return 0;
+}
+
+static void
+mt7603_tx_tasklet(unsigned long data)
+{
+       struct mt7603_dev *dev = (struct mt7603_dev *)data;
+       int i;
+
+       dev->tx_dma_check = 0;
+       for (i = MT_TXQ_MCU; i >= 0; i--)
+               mt76_queue_tx_cleanup(dev, i, false);
+
+       mt7603_irq_enable(dev, MT_INT_TX_DONE_ALL);
+}
+
+int mt7603_dma_init(struct mt7603_dev *dev)
+{
+       static const u8 wmm_queue_map[] = {
+               [IEEE80211_AC_BK] = 0,
+               [IEEE80211_AC_BE] = 1,
+               [IEEE80211_AC_VI] = 2,
+               [IEEE80211_AC_VO] = 3,
+       };
+       int ret;
+       int i;
+
+       mt76_dma_attach(&dev->mt76);
+
+       init_waitqueue_head(&dev->mt76.mmio.mcu.wait);
+       skb_queue_head_init(&dev->mt76.mmio.mcu.res_q);
+
+       tasklet_init(&dev->tx_tasklet, mt7603_tx_tasklet, (unsigned long)dev);
+
+       mt76_clear(dev, MT_WPDMA_GLO_CFG,
+                  MT_WPDMA_GLO_CFG_TX_DMA_EN |
+                  MT_WPDMA_GLO_CFG_RX_DMA_EN |
+                  MT_WPDMA_GLO_CFG_DMA_BURST_SIZE |
+                  MT_WPDMA_GLO_CFG_TX_WRITEBACK_DONE);
+
+       mt76_wr(dev, MT_WPDMA_RST_IDX, ~0);
+       mt7603_pse_client_reset(dev);
+
+       for (i = 0; i < ARRAY_SIZE(wmm_queue_map); i++) {
+               ret = mt7603_init_tx_queue(dev, &dev->mt76.q_tx[i],
+                                          wmm_queue_map[i],
+                                          MT_TX_RING_SIZE);
+               if (ret)
+                       return ret;
+       }
+
+       ret = mt7603_init_tx_queue(dev, &dev->mt76.q_tx[MT_TXQ_PSD],
+                                  MT_TX_HW_QUEUE_MGMT, MT_TX_RING_SIZE);
+       if (ret)
+               return ret;
+
+       ret = mt7603_init_tx_queue(dev, &dev->mt76.q_tx[MT_TXQ_MCU],
+                                  MT_TX_HW_QUEUE_MCU, MT_MCU_RING_SIZE);
+       if (ret)
+               return ret;
+
+       ret = mt7603_init_tx_queue(dev, &dev->mt76.q_tx[MT_TXQ_BEACON],
+                                  MT_TX_HW_QUEUE_BCN, MT_MCU_RING_SIZE);
+       if (ret)
+               return ret;
+
+       ret = mt7603_init_tx_queue(dev, &dev->mt76.q_tx[MT_TXQ_CAB],
+                                  MT_TX_HW_QUEUE_BMC, MT_MCU_RING_SIZE);
+       if (ret)
+               return ret;
+
+       ret = mt7603_init_rx_queue(dev, &dev->mt76.q_rx[MT_RXQ_MCU], 1,
+                                  MT_MCU_RING_SIZE, MT_RX_BUF_SIZE);
+       if (ret)
+               return ret;
+
+       ret = mt7603_init_rx_queue(dev, &dev->mt76.q_rx[MT_RXQ_MAIN], 0,
+                                  MT7603_RX_RING_SIZE, MT_RX_BUF_SIZE);
+       if (ret)
+               return ret;
+
+       mt76_wr(dev, MT_DELAY_INT_CFG, 0);
+       return mt76_init_queues(dev);
+}
+
+void mt7603_dma_cleanup(struct mt7603_dev *dev)
+{
+       mt76_clear(dev, MT_WPDMA_GLO_CFG,
+                  MT_WPDMA_GLO_CFG_TX_DMA_EN |
+                  MT_WPDMA_GLO_CFG_RX_DMA_EN |
+                  MT_WPDMA_GLO_CFG_TX_WRITEBACK_DONE);
+
+       tasklet_kill(&dev->tx_tasklet);
+       mt76_dma_cleanup(&dev->mt76);
+}
drivers/net/wireless/mediatek/mt76/mt7603/eeprom.c new file +183 -0
new file mode 100644
index 000000000000..6d7df67de494
@@ -0,0 +1,183 @@
+/* SPDX-License-Identifier: ISC */
+/*
+ * Copyright (C) 2016 Felix Fietkau <[email protected]>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "mt7603.h"
+#include "eeprom.h"
+
+static int
+mt7603_efuse_read(struct mt7603_dev *dev, u32 base, u16 addr, u8 *data)
+{
+       u32 val;
+       int i;
+
+       val = mt76_rr(dev, base + MT_EFUSE_CTRL);
+       val &= ~(MT_EFUSE_CTRL_AIN |
+                MT_EFUSE_CTRL_MODE);
+       val |= FIELD_PREP(MT_EFUSE_CTRL_AIN, addr & ~0xf);
+       val |= MT_EFUSE_CTRL_KICK;
+       mt76_wr(dev, base + MT_EFUSE_CTRL, val);
+
+       if (!mt76_poll(dev, base + MT_EFUSE_CTRL, MT_EFUSE_CTRL_KICK, 0, 1000))
+               return -ETIMEDOUT;
+
+       udelay(2);
+
+       val = mt76_rr(dev, base + MT_EFUSE_CTRL);
+       if ((val & MT_EFUSE_CTRL_AOUT) == MT_EFUSE_CTRL_AOUT ||
+           WARN_ON_ONCE(!(val & MT_EFUSE_CTRL_VALID))) {
+               memset(data, 0xff, 16);
+               return 0;
+       }
+
+       for (i = 0; i < 4; i++) {
+               val = mt76_rr(dev, base + MT_EFUSE_RDATA(i));
+               put_unaligned_le32(val, data + 4 * i);
+       }
+
+       return 0;
+}
+
+static int
+mt7603_efuse_init(struct mt7603_dev *dev)
+{
+       u32 base = mt7603_reg_map(dev, MT_EFUSE_BASE);
+       int len = MT7603_EEPROM_SIZE;
+       void *buf;
+       int ret, i;
+
+       if (mt76_rr(dev, base + MT_EFUSE_BASE_CTRL) & MT_EFUSE_BASE_CTRL_EMPTY)
+               return 0;
+
+       dev->mt76.otp.data = devm_kzalloc(dev->mt76.dev, len, GFP_KERNEL);
+       dev->mt76.otp.size = len;
+       if (!dev->mt76.otp.data)
+               return -ENOMEM;
+
+       buf = dev->mt76.otp.data;
+       for (i = 0; i + 16 <= len; i += 16) {
+               ret = mt7603_efuse_read(dev, base, i, buf + i);
+               if (ret)
+                       return ret;
+       }
+
+       return 0;
+}
+
+static bool
+mt7603_has_cal_free_data(struct mt7603_dev *dev, u8 *efuse)
+{
+       if (!efuse[MT_EE_TEMP_SENSOR_CAL])
+               return false;
+
+       if (get_unaligned_le16(efuse + MT_EE_TX_POWER_0_START_2G) == 0)
+               return false;
+
+       if (get_unaligned_le16(efuse + MT_EE_TX_POWER_1_START_2G) == 0)
+               return false;
+
+       if (!efuse[MT_EE_CP_FT_VERSION])
+               return false;
+
+       if (!efuse[MT_EE_XTAL_FREQ_OFFSET])
+               return false;
+
+       if (!efuse[MT_EE_XTAL_WF_RFCAL])
+               return false;
+
+       return true;
+}
+
+static void
+mt7603_apply_cal_free_data(struct mt7603_dev *dev, u8 *efuse)
+{
+       static const u8 cal_free_bytes[] = {
+               MT_EE_TEMP_SENSOR_CAL,
+               MT_EE_CP_FT_VERSION,
+               MT_EE_XTAL_FREQ_OFFSET,
+               MT_EE_XTAL_WF_RFCAL,
+               /* Skip for MT7628 */
+               MT_EE_TX_POWER_0_START_2G,
+               MT_EE_TX_POWER_0_START_2G + 1,
+               MT_EE_TX_POWER_1_START_2G,
+               MT_EE_TX_POWER_1_START_2G + 1,
+       };
+       u8 *eeprom = dev->mt76.eeprom.data;
+       int n = ARRAY_SIZE(cal_free_bytes);
+       int i;
+
+       if (!mt7603_has_cal_free_data(dev, efuse))
+               return;
+
+       if (is_mt7628(dev))
+               n -= 4;
+
+       for (i = 0; i < n; i++) {
+               int offset = cal_free_bytes[i];
+
+               eeprom[offset] = efuse[offset];
+       }
+}
+
+static int
+mt7603_eeprom_load(struct mt7603_dev *dev)
+{
+       int ret;
+
+       ret = mt76_eeprom_init(&dev->mt76, MT7603_EEPROM_SIZE);
+       if (ret < 0)
+               return ret;
+
+       return mt7603_efuse_init(dev);
+}
+
+static int mt7603_check_eeprom(struct mt76_dev *dev)
+{
+       u16 val = get_unaligned_le16(dev->eeprom.data);
+
+       switch (val) {
+       case 0x7628:
+       case 0x7603:
+               return 0;
+       default:
+               return -EINVAL;
+       }
+}
+
+int mt7603_eeprom_init(struct mt7603_dev *dev)
+{
+       int ret;
+
+       ret = mt7603_eeprom_load(dev);
+       if (ret < 0)
+               return ret;
+
+       if (dev->mt76.otp.data) {
+               if (mt7603_check_eeprom(&dev->mt76) == 0)
+                       mt7603_apply_cal_free_data(dev, dev->mt76.otp.data);
+               else
+                       memcpy(dev->mt76.eeprom.data, dev->mt76.otp.data,
+                              MT7603_EEPROM_SIZE);
+       }
+
+       dev->mt76.cap.has_2ghz = true;
+       memcpy(dev->mt76.macaddr, dev->mt76.eeprom.data + MT_EE_MAC_ADDR,
+              ETH_ALEN);
+
+       mt76_eeprom_override(&dev->mt76);
+
+       return 0;
+}
drivers/net/wireless/mediatek/mt76/mt7603/eeprom.h new file +101 -0
new file mode 100644
index 000000000000..18e649493bfd
@@ -0,0 +1,101 @@
+/* SPDX-License-Identifier: ISC */
+/*
+ * Copyright (C) 2016 Felix Fietkau <[email protected]>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef __MT7603_EEPROM_H
+#define __MT7603_EEPROM_H
+
+#include "mt7603.h"
+
+enum mt7603_eeprom_field {
+       MT_EE_CHIP_ID =                         0x000,
+       MT_EE_VERSION =                         0x002,
+       MT_EE_MAC_ADDR =                        0x004,
+       MT_EE_NIC_CONF_0 =                      0x034,
+       MT_EE_NIC_CONF_1 =                      0x036,
+       MT_EE_NIC_CONF_2 =                      0x042,
+
+       MT_EE_XTAL_TRIM_1 =                     0x03a,
+
+       MT_EE_RSSI_OFFSET_2G =                  0x046,
+       MT_EE_WIFI_RF_SETTING =                 0x048,
+       MT_EE_RSSI_OFFSET_5G =                  0x04a,
+
+       MT_EE_TX_POWER_DELTA_BW40 =             0x050,
+       MT_EE_TX_POWER_DELTA_BW80 =             0x052,
+
+       MT_EE_TX_POWER_EXT_PA_5G =              0x054,
+
+       MT_EE_TEMP_SENSOR_CAL =                 0x055,
+
+       MT_EE_TX_POWER_0_START_2G =             0x056,
+       MT_EE_TX_POWER_1_START_2G =             0x05c,
+
+       /* used as byte arrays */
+#define MT_TX_POWER_GROUP_SIZE_5G              5
+#define MT_TX_POWER_GROUPS_5G                  6
+       MT_EE_TX_POWER_0_START_5G =             0x062,
+
+       MT_EE_TX_POWER_0_GRP3_TX_POWER_DELTA =  0x074,
+       MT_EE_TX_POWER_0_GRP4_TSSI_SLOPE =      0x076,
+
+       MT_EE_TX_POWER_1_START_5G =             0x080,
+
+       MT_EE_TX_POWER_CCK =                    0x0a0,
+       MT_EE_TX_POWER_OFDM_2G_6M =             0x0a2,
+       MT_EE_TX_POWER_OFDM_2G_24M =            0x0a4,
+       MT_EE_TX_POWER_OFDM_2G_54M =            0x0a6,
+       MT_EE_TX_POWER_HT_BPSK_QPSK =           0x0a8,
+       MT_EE_TX_POWER_HT_16_64_QAM =           0x0aa,
+       MT_EE_TX_POWER_HT_64_QAM =              0x0ac,
+
+       MT_EE_ELAN_RX_MODE_GAIN =               0x0c0,
+       MT_EE_ELAN_RX_MODE_NF =                 0x0c1,
+       MT_EE_ELAN_RX_MODE_P1DB =               0x0c2,
+
+       MT_EE_ELAN_BYPASS_MODE_GAIN =           0x0c3,
+       MT_EE_ELAN_BYPASS_MODE_NF =             0x0c4,
+       MT_EE_ELAN_BYPASS_MODE_P1DB =           0x0c5,
+
+       MT_EE_STEP_NUM_NEG_6_7 =                0x0c6,
+       MT_EE_STEP_NUM_NEG_4_5 =                0x0c8,
+       MT_EE_STEP_NUM_NEG_2_3 =                0x0ca,
+       MT_EE_STEP_NUM_NEG_0_1 =                0x0cc,
+
+       MT_EE_REF_STEP_24G =                    0x0ce,
+
+       MT_EE_STEP_NUM_PLUS_1_2 =               0x0d0,
+       MT_EE_STEP_NUM_PLUS_3_4 =               0x0d2,
+       MT_EE_STEP_NUM_PLUS_5_6 =               0x0d4,
+       MT_EE_STEP_NUM_PLUS_7 =                 0x0d6,
+
+       MT_EE_CP_FT_VERSION =                   0x0f0,
+
+       MT_EE_XTAL_FREQ_OFFSET =                0x0f4,
+       MT_EE_XTAL_TRIM_2_COMP =                0x0f5,
+       MT_EE_XTAL_TRIM_3_COMP =                0x0f6,
+       MT_EE_XTAL_WF_RFCAL =                   0x0f7,
+
+       __MT_EE_MAX
+};
+
+enum mt7603_eeprom_source {
+       MT_EE_SRC_PROM,
+       MT_EE_SRC_EFUSE,
+       MT_EE_SRC_FLASH,
+};
+
+#endif
drivers/net/wireless/mediatek/mt76/mt7603/init.c new file +608 -0
new file mode 100644
index 000000000000..41d92fb9c280
@@ -0,0 +1,608 @@
+/* SPDX-License-Identifier: ISC */
+/*
+ * Copyright (C) 2016 Felix Fietkau <[email protected]>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <linux/etherdevice.h>
+#include "mt7603.h"
+#include "mac.h"
+#include "eeprom.h"
+
+struct mt7603_dev *mt7603_alloc_device(struct device *pdev)
+{
+       static const struct mt76_driver_ops drv_ops = {
+               .txwi_size = MT_TXD_SIZE,
+               .tx_prepare_skb = mt7603_tx_prepare_skb,
+               .tx_complete_skb = mt7603_tx_complete_skb,
+               .rx_skb = mt7603_queue_rx_skb,
+               .rx_poll_complete = mt7603_rx_poll_complete,
+               .sta_ps = mt7603_sta_ps,
+               .sta_add = mt7603_sta_add,
+               .sta_assoc = mt7603_sta_assoc,
+               .sta_remove = mt7603_sta_remove,
+               .update_survey = mt7603_update_channel,
+       };
+       struct mt7603_dev *dev;
+       struct mt76_dev *mdev;
+
+       mdev = mt76_alloc_device(sizeof(*dev), &mt7603_ops);
+       if (!mdev)
+               return NULL;
+
+       dev = container_of(mdev, struct mt7603_dev, mt76);
+       mdev->dev = pdev;
+       mdev->drv = &drv_ops;
+
+       return dev;
+}
+
+static void
+mt7603_set_tmac_template(struct mt7603_dev *dev)
+{
+       u32 desc[5] = {
+               [1] = FIELD_PREP(MT_TXD3_REM_TX_COUNT, 0xf),
+               [3] = MT_TXD5_SW_POWER_MGMT
+       };
+       u32 addr;
+       int i;
+
+       addr = mt7603_reg_map(dev, MT_CLIENT_BASE_PHYS_ADDR);
+       addr += MT_CLIENT_TMAC_INFO_TEMPLATE;
+       for (i = 0; i < ARRAY_SIZE(desc); i++)
+               mt76_wr(dev, addr + 4 * i, desc[i]);
+}
+
+static void
+mt7603_dma_sched_init(struct mt7603_dev *dev)
+{
+       int page_size = 128;
+       int page_count;
+       int max_len = 1792;
+       int max_amsdu_pages = 4096 / page_size;
+       int max_mcu_len = 4096;
+       int max_beacon_len = 512 * 4 + max_len;
+       int max_mcast_pages = 4 * max_len / page_size;
+       int reserved_count = 0;
+       int beacon_pages;
+       int mcu_pages;
+       int i;
+
+       page_count = mt76_get_field(dev, MT_PSE_FC_P0,
+                                   MT_PSE_FC_P0_MAX_QUOTA);
+       beacon_pages = 4 * (max_beacon_len / page_size);
+       mcu_pages = max_mcu_len / page_size;
+
+       mt76_wr(dev, MT_PSE_FRP,
+               FIELD_PREP(MT_PSE_FRP_P0, 7) |
+               FIELD_PREP(MT_PSE_FRP_P1, 6) |
+               FIELD_PREP(MT_PSE_FRP_P2_RQ2, 4));
+
+       mt76_wr(dev, MT_HIGH_PRIORITY_1, 0x55555553);
+       mt76_wr(dev, MT_HIGH_PRIORITY_2, 0x78555555);
+
+       mt76_wr(dev, MT_QUEUE_PRIORITY_1, 0x2b1a096e);
+       mt76_wr(dev, MT_QUEUE_PRIORITY_2, 0x785f4d3c);
+
+       mt76_wr(dev, MT_PRIORITY_MASK, 0xffffffff);
+
+       mt76_wr(dev, MT_SCH_1, page_count | (2 << 28));
+       mt76_wr(dev, MT_SCH_2, max_amsdu_pages);
+
+       for (i = 0; i <= 4; i++)
+               mt76_wr(dev, MT_PAGE_COUNT(i), max_amsdu_pages);
+       reserved_count += 5 * max_amsdu_pages;
+
+       mt76_wr(dev, MT_PAGE_COUNT(5), mcu_pages);
+       reserved_count += mcu_pages;
+
+       mt76_wr(dev, MT_PAGE_COUNT(7), beacon_pages);
+       reserved_count += beacon_pages;
+
+       mt76_wr(dev, MT_PAGE_COUNT(8), max_mcast_pages);
+       reserved_count += max_mcast_pages;
+
+       if (is_mt7603(dev))
+               reserved_count = 0;
+
+       mt76_wr(dev, MT_RSV_MAX_THRESH, page_count - reserved_count);
+
+       if (is_mt7603(dev) && mt76xx_rev(dev) >= MT7603_REV_E2) {
+               mt76_wr(dev, MT_GROUP_THRESH(0),
+                       page_count - beacon_pages - mcu_pages);
+               mt76_wr(dev, MT_GROUP_THRESH(1), beacon_pages);
+               mt76_wr(dev, MT_BMAP_0, 0x0080ff5f);
+               mt76_wr(dev, MT_GROUP_THRESH(2), mcu_pages);
+               mt76_wr(dev, MT_BMAP_1, 0x00000020);
+       } else {
+               mt76_wr(dev, MT_GROUP_THRESH(0), page_count);
+               mt76_wr(dev, MT_BMAP_0, 0xffff);
+       }
+
+       mt76_wr(dev, MT_SCH_4, 0);
+
+       for (i = 0; i <= 15; i++)
+               mt76_wr(dev, MT_TXTIME_THRESH(i), 0xfffff);
+
+       mt76_set(dev, MT_SCH_4, BIT(6));
+}
+
+static void
+mt7603_phy_init(struct mt7603_dev *dev)
+{
+       int rx_chains = dev->mt76.antenna_mask;
+       int tx_chains = __sw_hweight8(rx_chains) - 1;
+
+       mt76_rmw(dev, MT_WF_RMAC_RMCR,
+                (MT_WF_RMAC_RMCR_SMPS_MODE |
+                 MT_WF_RMAC_RMCR_RX_STREAMS),
+                (FIELD_PREP(MT_WF_RMAC_RMCR_SMPS_MODE, 3) |
+                 FIELD_PREP(MT_WF_RMAC_RMCR_RX_STREAMS, rx_chains)));
+
+       mt76_rmw_field(dev, MT_TMAC_TCR, MT_TMAC_TCR_TX_STREAMS,
+                      tx_chains);
+
+       dev->agc0 = mt76_rr(dev, MT_AGC(0));
+       dev->agc3 = mt76_rr(dev, MT_AGC(3));
+}
+
+static void
+mt7603_mac_init(struct mt7603_dev *dev)
+{
+       u8 bc_addr[ETH_ALEN];
+       u32 addr;
+       int i;
+
+       mt76_wr(dev, MT_AGG_BA_SIZE_LIMIT_0,
+               (MT_AGG_SIZE_LIMIT(0) << 0 * MT_AGG_BA_SIZE_LIMIT_SHIFT) |
+               (MT_AGG_SIZE_LIMIT(1) << 1 * MT_AGG_BA_SIZE_LIMIT_SHIFT) |
+               (MT_AGG_SIZE_LIMIT(2) << 2 * MT_AGG_BA_SIZE_LIMIT_SHIFT) |
+               (MT_AGG_SIZE_LIMIT(3) << 3 * MT_AGG_BA_SIZE_LIMIT_SHIFT));
+
+       mt76_wr(dev, MT_AGG_BA_SIZE_LIMIT_1,
+               (MT_AGG_SIZE_LIMIT(4) << 0 * MT_AGG_BA_SIZE_LIMIT_SHIFT) |
+               (MT_AGG_SIZE_LIMIT(5) << 1 * MT_AGG_BA_SIZE_LIMIT_SHIFT) |
+               (MT_AGG_SIZE_LIMIT(6) << 2 * MT_AGG_BA_SIZE_LIMIT_SHIFT) |
+               (MT_AGG_SIZE_LIMIT(7) << 3 * MT_AGG_BA_SIZE_LIMIT_SHIFT));
+
+       mt76_wr(dev, MT_AGG_LIMIT,
+               FIELD_PREP(MT_AGG_LIMIT_AC(0), 24) |
+               FIELD_PREP(MT_AGG_LIMIT_AC(1), 24) |
+               FIELD_PREP(MT_AGG_LIMIT_AC(2), 24) |
+               FIELD_PREP(MT_AGG_LIMIT_AC(3), 24));
+
+       mt76_wr(dev, MT_AGG_LIMIT_1,
+               FIELD_PREP(MT_AGG_LIMIT_AC(0), 24) |
+               FIELD_PREP(MT_AGG_LIMIT_AC(1), 24) |
+               FIELD_PREP(MT_AGG_LIMIT_AC(2), 24) |
+               FIELD_PREP(MT_AGG_LIMIT_AC(3), 24));
+
+       mt76_wr(dev, MT_AGG_CONTROL,
+               FIELD_PREP(MT_AGG_CONTROL_BAR_RATE, 0x4b) |
+               FIELD_PREP(MT_AGG_CONTROL_CFEND_RATE, 0x69) |
+               MT_AGG_CONTROL_NO_BA_AR_RULE);
+
+       mt76_wr(dev, MT_AGG_RETRY_CONTROL,
+               FIELD_PREP(MT_AGG_RETRY_CONTROL_BAR_LIMIT, 1) |
+               FIELD_PREP(MT_AGG_RETRY_CONTROL_RTS_LIMIT, 15));
+
+       mt76_rmw(dev, MT_DMA_DCR0, ~0xfffc, 4096);
+
+       mt76_rmw(dev, MT_DMA_VCFR0, BIT(0), BIT(13));
+       mt76_rmw(dev, MT_DMA_TMCFR0, BIT(0) | BIT(1), BIT(13));
+
+       mt76_clear(dev, MT_WF_RMAC_TMR_PA, BIT(31));
+
+       mt76_set(dev, MT_WF_RMACDR, MT_WF_RMACDR_MAXLEN_20BIT);
+       mt76_rmw(dev, MT_WF_RMAC_MAXMINLEN, 0xffffff, 0x19000);
+
+       mt76_wr(dev, MT_WF_RFCR1, 0);
+
+       mt76_set(dev, MT_TMAC_TCR, MT_TMAC_TCR_RX_RIFS_MODE);
+
+       mt7603_set_tmac_template(dev);
+
+       /* Enable RX group to HIF */
+       addr = mt7603_reg_map(dev, MT_CLIENT_BASE_PHYS_ADDR);
+       mt76_set(dev, addr + MT_CLIENT_RXINF, MT_CLIENT_RXINF_RXSH_GROUPS);
+
+       /* Enable RX group to MCU */
+       mt76_set(dev, MT_DMA_DCR1, GENMASK(13, 11));
+
+       mt76_rmw_field(dev, MT_AGG_PCR_RTS, MT_AGG_PCR_RTS_PKT_THR, 3);
+       mt76_set(dev, MT_TMAC_PCR, MT_TMAC_PCR_SPE_EN);
+
+       /* include preamble detection in CCA trigger signal */
+       mt76_rmw_field(dev, MT_TXREQ, MT_TXREQ_CCA_SRC_SEL, 2);
+
+       mt76_wr(dev, MT_RXREQ, 4);
+
+       /* Configure all rx packets to HIF */
+       mt76_wr(dev, MT_DMA_RCFR0, 0xc0000000);
+
+       /* Configure MCU txs selection with aggregation */
+       mt76_wr(dev, MT_DMA_TCFR0,
+               FIELD_PREP(MT_DMA_TCFR_TXS_AGGR_TIMEOUT, 1) | /* 32 us */
+               MT_DMA_TCFR_TXS_AGGR_COUNT);
+
+       /* Configure HIF txs selection with aggregation */
+       mt76_wr(dev, MT_DMA_TCFR1,
+               FIELD_PREP(MT_DMA_TCFR_TXS_AGGR_TIMEOUT, 1) | /* 32 us */
+               MT_DMA_TCFR_TXS_AGGR_COUNT | /* Maximum count */
+               MT_DMA_TCFR_TXS_BIT_MAP);
+
+       mt76_wr(dev, MT_MCU_PCIE_REMAP_1, MT_PSE_WTBL_2_PHYS_ADDR);
+
+       for (i = 0; i < MT7603_WTBL_SIZE; i++)
+               mt7603_wtbl_clear(dev, i);
+
+       eth_broadcast_addr(bc_addr);
+       mt7603_wtbl_init(dev, MT7603_WTBL_RESERVED, -1, bc_addr);
+       dev->global_sta.wcid.idx = MT7603_WTBL_RESERVED;
+       rcu_assign_pointer(dev->mt76.wcid[MT7603_WTBL_RESERVED],
+                          &dev->global_sta.wcid);
+
+       mt76_rmw_field(dev, MT_LPON_BTEIR, MT_LPON_BTEIR_MBSS_MODE, 2);
+       mt76_rmw_field(dev, MT_WF_RMACDR, MT_WF_RMACDR_MBSSID_MASK, 2);
+
+       mt76_wr(dev, MT_AGG_ARUCR, FIELD_PREP(MT_AGG_ARxCR_LIMIT(0), 7));
+       mt76_wr(dev, MT_AGG_ARDCR,
+               FIELD_PREP(MT_AGG_ARxCR_LIMIT(0), 0) |
+               FIELD_PREP(MT_AGG_ARxCR_LIMIT(1),
+                          max_t(int, 0, MT7603_RATE_RETRY - 2)) |
+               FIELD_PREP(MT_AGG_ARxCR_LIMIT(2), MT7603_RATE_RETRY - 1) |
+               FIELD_PREP(MT_AGG_ARxCR_LIMIT(3), MT7603_RATE_RETRY - 1) |
+               FIELD_PREP(MT_AGG_ARxCR_LIMIT(4), MT7603_RATE_RETRY - 1) |
+               FIELD_PREP(MT_AGG_ARxCR_LIMIT(5), MT7603_RATE_RETRY - 1) |
+               FIELD_PREP(MT_AGG_ARxCR_LIMIT(6), MT7603_RATE_RETRY - 1) |
+               FIELD_PREP(MT_AGG_ARxCR_LIMIT(7), MT7603_RATE_RETRY - 1));
+
+       mt76_wr(dev, MT_AGG_ARCR,
+               (MT_AGG_ARCR_INIT_RATE1 |
+                FIELD_PREP(MT_AGG_ARCR_RTS_RATE_THR, 2) |
+                MT_AGG_ARCR_RATE_DOWN_RATIO_EN |
+                FIELD_PREP(MT_AGG_ARCR_RATE_DOWN_RATIO, 1) |
+                FIELD_PREP(MT_AGG_ARCR_RATE_UP_EXTRA_TH, 4)));
+
+       mt76_set(dev, MT_WTBL_RMVTCR, MT_WTBL_RMVTCR_RX_MV_MODE);
+
+       mt76_clear(dev, MT_SEC_SCR, MT_SEC_SCR_MASK_ORDER);
+       mt76_clear(dev, MT_SEC_SCR, BIT(18));
+
+       /* Set secondary beacon time offsets */
+       for (i = 0; i <= 4; i++)
+               mt76_rmw_field(dev, MT_LPON_SBTOR(i), MT_LPON_SBTOR_TIME_OFFSET,
+                              (i + 1) * (20 + 4096));
+}
+
+static int
+mt7603_init_hardware(struct mt7603_dev *dev)
+{
+       int i, ret;
+
+       mt76_wr(dev, MT_INT_SOURCE_CSR, ~0);
+
+       ret = mt7603_eeprom_init(dev);
+       if (ret < 0)
+               return ret;
+
+       ret = mt7603_dma_init(dev);
+       if (ret)
+               return ret;
+
+       mt76_wr(dev, MT_WPDMA_GLO_CFG, 0x52000850);
+       mt7603_mac_dma_start(dev);
+       dev->rxfilter = mt76_rr(dev, MT_WF_RFCR);
+       set_bit(MT76_STATE_INITIALIZED, &dev->mt76.state);
+
+       for (i = 0; i < MT7603_WTBL_SIZE; i++) {
+               mt76_wr(dev, MT_PSE_RTA, MT_PSE_RTA_BUSY | MT_PSE_RTA_WRITE |
+                       FIELD_PREP(MT_PSE_RTA_TAG_ID, i));
+               mt76_poll(dev, MT_PSE_RTA, MT_PSE_RTA_BUSY, 0, 5000);
+       }
+
+       ret = mt7603_mcu_init(dev);
+       if (ret)
+               return ret;
+
+       mt7603_dma_sched_init(dev);
+       mt7603_mcu_set_eeprom(dev);
+       mt7603_phy_init(dev);
+       mt7603_mac_init(dev);
+
+       return 0;
+}
+
+#define CCK_RATE(_idx, _rate) {                                        \
+       .bitrate = _rate,                                       \
+       .flags = IEEE80211_RATE_SHORT_PREAMBLE,                 \
+       .hw_value = (MT_PHY_TYPE_CCK << 8) | (_idx),            \
+       .hw_value_short = (MT_PHY_TYPE_CCK << 8) | (4 + _idx),  \
+}
+
+#define OFDM_RATE(_idx, _rate) {                               \
+       .bitrate = _rate,                                       \
+       .hw_value = (MT_PHY_TYPE_OFDM << 8) | (_idx),           \
+       .hw_value_short = (MT_PHY_TYPE_OFDM << 8) | (_idx),     \
+}
+
+static struct ieee80211_rate mt7603_rates[] = {
+       CCK_RATE(0, 10),
+       CCK_RATE(1, 20),
+       CCK_RATE(2, 55),
+       CCK_RATE(3, 110),
+       OFDM_RATE(11, 60),
+       OFDM_RATE(15, 90),
+       OFDM_RATE(10, 120),
+       OFDM_RATE(14, 180),
+       OFDM_RATE(9,  240),
+       OFDM_RATE(13, 360),
+       OFDM_RATE(8,  480),
+       OFDM_RATE(12, 540),
+};
+
+static const struct ieee80211_iface_limit if_limits[] = {
+       {
+               .max = 1,
+               .types = BIT(NL80211_IFTYPE_ADHOC)
+       }, {
+               .max = MT7603_MAX_INTERFACES,
+               .types = BIT(NL80211_IFTYPE_STATION) |
+#ifdef CONFIG_MAC80211_MESH
+                        BIT(NL80211_IFTYPE_MESH_POINT) |
+#endif
+                        BIT(NL80211_IFTYPE_AP)
+        },
+};
+
+static const struct ieee80211_iface_combination if_comb[] = {
+       {
+               .limits = if_limits,
+               .n_limits = ARRAY_SIZE(if_limits),
+               .max_interfaces = 4,
+               .num_different_channels = 1,
+               .beacon_int_infra_match = true,
+       }
+};
+
+static void mt7603_led_set_config(struct mt76_dev *mt76, u8 delay_on,
+                                 u8 delay_off)
+{
+       struct mt7603_dev *dev = container_of(mt76, struct mt7603_dev,
+                                             mt76);
+       u32 val, addr;
+
+       val = MT_LED_STATUS_DURATION(0xffff) |
+             MT_LED_STATUS_OFF(delay_off) |
+             MT_LED_STATUS_ON(delay_on);
+
+       addr = mt7603_reg_map(dev, MT_LED_STATUS_0(mt76->led_pin));
+       mt76_wr(dev, addr, val);
+       addr = mt7603_reg_map(dev, MT_LED_STATUS_1(mt76->led_pin));
+       mt76_wr(dev, addr, val);
+
+       val = MT_LED_CTRL_REPLAY(mt76->led_pin) |
+             MT_LED_CTRL_KICK(mt76->led_pin);
+       if (mt76->led_al)
+               val |= MT_LED_CTRL_POLARITY(mt76->led_pin);
+       addr = mt7603_reg_map(dev, MT_LED_CTRL);
+       mt76_wr(dev, addr, val);
+}
+
+static int mt7603_led_set_blink(struct led_classdev *led_cdev,
+                               unsigned long *delay_on,
+                               unsigned long *delay_off)
+{
+       struct mt76_dev *mt76 = container_of(led_cdev, struct mt76_dev,
+                                            led_cdev);
+       u8 delta_on, delta_off;
+
+       delta_off = max_t(u8, *delay_off / 10, 1);
+       delta_on = max_t(u8, *delay_on / 10, 1);
+
+       mt7603_led_set_config(mt76, delta_on, delta_off);
+       return 0;
+}
+
+static void mt7603_led_set_brightness(struct led_classdev *led_cdev,
+                                     enum led_brightness brightness)
+{
+       struct mt76_dev *mt76 = container_of(led_cdev, struct mt76_dev,
+                                            led_cdev);
+
+       if (!brightness)
+               mt7603_led_set_config(mt76, 0, 0xff);
+       else
+               mt7603_led_set_config(mt76, 0xff, 0);
+}
+
+static u32 __mt7603_reg_addr(struct mt7603_dev *dev, u32 addr)
+{
+       if (addr < 0x100000)
+               return addr;
+
+       return mt7603_reg_map(dev, addr);
+}
+
+static u32 mt7603_rr(struct mt76_dev *mdev, u32 offset)
+{
+       struct mt7603_dev *dev = container_of(mdev, struct mt7603_dev, mt76);
+       u32 addr = __mt7603_reg_addr(dev, offset);
+
+       return dev->bus_ops->rr(mdev, addr);
+}
+
+static void mt7603_wr(struct mt76_dev *mdev, u32 offset, u32 val)
+{
+       struct mt7603_dev *dev = container_of(mdev, struct mt7603_dev, mt76);
+       u32 addr = __mt7603_reg_addr(dev, offset);
+
+       dev->bus_ops->wr(mdev, addr, val);
+}
+
+static u32 mt7603_rmw(struct mt76_dev *mdev, u32 offset, u32 mask, u32 val)
+{
+       struct mt7603_dev *dev = container_of(mdev, struct mt7603_dev, mt76);
+       u32 addr = __mt7603_reg_addr(dev, offset);
+
+       return dev->bus_ops->rmw(mdev, addr, mask, val);
+}
+
+static void
+mt7603_regd_notifier(struct wiphy *wiphy,
+                    struct regulatory_request *request)
+{
+       struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
+       struct mt7603_dev *dev = hw->priv;
+
+       dev->ed_monitor = request->dfs_region == NL80211_DFS_ETSI;
+}
+
+static int
+mt7603_txpower_signed(int val)
+{
+       bool sign = val & BIT(6);
+
+       if (!(val & BIT(7)))
+               return 0;
+
+       val &= GENMASK(5, 0);
+       if (!sign)
+               val = -val;
+
+       return val;
+}
+
+static void
+mt7603_init_txpower(struct mt7603_dev *dev,
+                   struct ieee80211_supported_band *sband)
+{
+       struct ieee80211_channel *chan;
+       u8 *eeprom = (u8 *)dev->mt76.eeprom.data;
+       int target_power = eeprom[MT_EE_TX_POWER_0_START_2G + 2] & ~BIT(7);
+       u8 *rate_power = &eeprom[MT_EE_TX_POWER_CCK];
+       int max_offset, cur_offset;
+       int i;
+
+       if (target_power & BIT(6))
+               target_power = -(target_power & GENMASK(5, 0));
+
+       max_offset = 0;
+       for (i = 0; i < 14; i++) {
+               cur_offset = mt7603_txpower_signed(rate_power[i]);
+               max_offset = max(max_offset, cur_offset);
+       }
+
+       target_power += max_offset;
+
+       dev->tx_power_limit = target_power;
+       dev->mt76.txpower_cur = target_power;
+
+       target_power = DIV_ROUND_UP(target_power, 2);
+
+       /* add 3 dBm for 2SS devices (combined output) */
+       if (dev->mt76.antenna_mask & BIT(1))
+               target_power += 3;
+
+       for (i = 0; i < sband->n_channels; i++) {
+               chan = &sband->channels[i];
+               chan->max_power = target_power;
+       }
+}
+
+
+int mt7603_register_device(struct mt7603_dev *dev)
+{
+       struct mt76_bus_ops *bus_ops;
+       struct ieee80211_hw *hw = mt76_hw(dev);
+       struct wiphy *wiphy = hw->wiphy;
+       int ret;
+
+       dev->bus_ops = dev->mt76.bus;
+       bus_ops = devm_kmemdup(dev->mt76.dev, dev->bus_ops, sizeof(*bus_ops),
+                              GFP_KERNEL);
+       if (!bus_ops)
+               return -ENOMEM;
+
+       bus_ops->rr = mt7603_rr;
+       bus_ops->wr = mt7603_wr;
+       bus_ops->rmw = mt7603_rmw;
+       dev->mt76.bus = bus_ops;
+
+       INIT_DELAYED_WORK(&dev->mac_work, mt7603_mac_work);
+       tasklet_init(&dev->pre_tbtt_tasklet, mt7603_pre_tbtt_tasklet,
+                    (unsigned long)dev);
+
+       /* Check for 7688, which only has 1SS */
+       dev->mt76.antenna_mask = 3;
+       if (mt76_rr(dev, MT_EFUSE_BASE + 0x64) & BIT(4))
+               dev->mt76.antenna_mask = 1;
+
+       dev->slottime = 9;
+
+       ret = mt7603_init_hardware(dev);
+       if (ret)
+               return ret;
+
+       hw->queues = 4;
+       hw->max_rates = 3;
+       hw->max_report_rates = 7;
+       hw->max_rate_tries = 11;
+
+       hw->sta_data_size = sizeof(struct mt7603_sta);
+       hw->vif_data_size = sizeof(struct mt7603_vif);
+
+       wiphy->iface_combinations = if_comb;
+       wiphy->n_iface_combinations = ARRAY_SIZE(if_comb);
+
+       ieee80211_hw_set(hw, SUPPORTS_REORDERING_BUFFER);
+       ieee80211_hw_set(hw, TX_STATUS_NO_AMPDU_LEN);
+
+       /* init led callbacks */
+       if (IS_ENABLED(CONFIG_MT76_LEDS)) {
+               dev->mt76.led_cdev.brightness_set = mt7603_led_set_brightness;
+               dev->mt76.led_cdev.blink_set = mt7603_led_set_blink;
+       }
+
+       wiphy->interface_modes =
+               BIT(NL80211_IFTYPE_STATION) |
+               BIT(NL80211_IFTYPE_AP) |
+#ifdef CONFIG_MAC80211_MESH
+               BIT(NL80211_IFTYPE_MESH_POINT) |
+#endif
+               BIT(NL80211_IFTYPE_ADHOC);
+
+       wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
+
+       wiphy->reg_notifier = mt7603_regd_notifier;
+
+       ret = mt76_register_device(&dev->mt76, true, mt7603_rates,
+                                  ARRAY_SIZE(mt7603_rates));
+       if (ret)
+               return ret;
+
+       mt7603_init_debugfs(dev);
+       mt7603_init_txpower(dev, &dev->mt76.sband_2g.sband);
+
+       return 0;
+}
+
+void mt7603_unregister_device(struct mt7603_dev *dev)
+{
+       tasklet_disable(&dev->pre_tbtt_tasklet);
+       mt76_unregister_device(&dev->mt76);
+       mt7603_mcu_exit(dev);
+       mt7603_dma_cleanup(dev);
+       ieee80211_free_hw(mt76_hw(dev));
+}
drivers/net/wireless/mediatek/mt76/mt7603/mac.c new file +1764 -0
new file mode 100644
index 000000000000..d1ea0e32b2ca
@@ -0,0 +1,1764 @@
+/* SPDX-License-Identifier: ISC */
+/*
+ * Copyright (C) 2016 Felix Fietkau <[email protected]>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <linux/etherdevice.h>
+#include <linux/timekeeping.h>
+#include "mt7603.h"
+#include "mac.h"
+
+#define MT_PSE_PAGE_SIZE       128
+
+static u32
+mt7603_ac_queue_mask0(u32 mask)
+{
+       u32 ret = 0;
+
+       ret |= GENMASK(3, 0) * !!(mask & BIT(0));
+       ret |= GENMASK(8, 5) * !!(mask & BIT(1));
+       ret |= GENMASK(13, 10) * !!(mask & BIT(2));
+       ret |= GENMASK(19, 16) * !!(mask & BIT(3));
+       return ret;
+}
+
+static void
+mt76_stop_tx_ac(struct mt7603_dev *dev, u32 mask)
+{
+       mt76_set(dev, MT_WF_ARB_TX_STOP_0, mt7603_ac_queue_mask0(mask));
+}
+
+static void
+mt76_start_tx_ac(struct mt7603_dev *dev, u32 mask)
+{
+       mt76_set(dev, MT_WF_ARB_TX_START_0, mt7603_ac_queue_mask0(mask));
+}
+
+void mt7603_mac_set_timing(struct mt7603_dev *dev)
+{
+       u32 cck = FIELD_PREP(MT_TIMEOUT_VAL_PLCP, 231) |
+                 FIELD_PREP(MT_TIMEOUT_VAL_CCA, 48);
+       u32 ofdm = FIELD_PREP(MT_TIMEOUT_VAL_PLCP, 60) |
+                  FIELD_PREP(MT_TIMEOUT_VAL_CCA, 24);
+       int offset = 3 * dev->coverage_class;
+       u32 reg_offset = FIELD_PREP(MT_TIMEOUT_VAL_PLCP, offset) |
+                        FIELD_PREP(MT_TIMEOUT_VAL_CCA, offset);
+       int sifs;
+       u32 val;
+
+       if (dev->mt76.chandef.chan->band == NL80211_BAND_5GHZ)
+               sifs = 16;
+       else
+               sifs = 10;
+
+       mt76_set(dev, MT_ARB_SCR,
+                MT_ARB_SCR_TX_DISABLE | MT_ARB_SCR_RX_DISABLE);
+       udelay(1);
+
+       mt76_wr(dev, MT_TIMEOUT_CCK, cck + reg_offset);
+       mt76_wr(dev, MT_TIMEOUT_OFDM, ofdm + reg_offset);
+       mt76_wr(dev, MT_IFS,
+               FIELD_PREP(MT_IFS_EIFS, 360) |
+               FIELD_PREP(MT_IFS_RIFS, 2) |
+               FIELD_PREP(MT_IFS_SIFS, sifs) |
+               FIELD_PREP(MT_IFS_SLOT, dev->slottime));
+
+       if (dev->slottime < 20)
+               val = MT7603_CFEND_RATE_DEFAULT;
+       else
+               val = MT7603_CFEND_RATE_11B;
+
+       mt76_rmw_field(dev, MT_AGG_CONTROL, MT_AGG_CONTROL_CFEND_RATE, val);
+
+       mt76_clear(dev, MT_ARB_SCR,
+                  MT_ARB_SCR_TX_DISABLE | MT_ARB_SCR_RX_DISABLE);
+}
+
+static void
+mt7603_wtbl_update(struct mt7603_dev *dev, int idx, u32 mask)
+{
+       mt76_rmw(dev, MT_WTBL_UPDATE, MT_WTBL_UPDATE_WLAN_IDX,
+                FIELD_PREP(MT_WTBL_UPDATE_WLAN_IDX, idx) | mask);
+
+       mt76_poll(dev, MT_WTBL_UPDATE, MT_WTBL_UPDATE_BUSY, 0, 5000);
+}
+
+static u32
+mt7603_wtbl1_addr(int idx)
+{
+       return MT_WTBL1_BASE + idx * MT_WTBL1_SIZE;
+}
+
+static u32
+mt7603_wtbl2_addr(int idx)
+{
+       /* Mapped to WTBL2 */
+       return MT_PCIE_REMAP_BASE_1 + idx * MT_WTBL2_SIZE;
+}
+
+static u32
+mt7603_wtbl3_addr(int idx)
+{
+       u32 base = mt7603_wtbl2_addr(MT7603_WTBL_SIZE);
+
+       return base + idx * MT_WTBL3_SIZE;
+}
+
+static u32
+mt7603_wtbl4_addr(int idx)
+{
+       u32 base = mt7603_wtbl3_addr(MT7603_WTBL_SIZE);
+
+       return base + idx * MT_WTBL4_SIZE;
+}
+
+void mt7603_wtbl_init(struct mt7603_dev *dev, int idx, int vif,
+                     const u8 *mac_addr)
+{
+       const void *_mac = mac_addr;
+       u32 addr = mt7603_wtbl1_addr(idx);
+       u32 w0 = 0, w1 = 0;
+       int i;
+
+       if (_mac) {
+               w0 = FIELD_PREP(MT_WTBL1_W0_ADDR_HI,
+                               get_unaligned_le16(_mac + 4));
+               w1 = FIELD_PREP(MT_WTBL1_W1_ADDR_LO,
+                               get_unaligned_le32(_mac));
+       }
+
+       if (vif < 0)
+               vif = 0;
+       else
+               w0 |= MT_WTBL1_W0_RX_CHECK_A1;
+       w0 |= FIELD_PREP(MT_WTBL1_W0_MUAR_IDX, vif);
+
+       mt76_poll(dev, MT_WTBL_UPDATE, MT_WTBL_UPDATE_BUSY, 0, 5000);
+
+       mt76_set(dev, addr + 0 * 4, w0);
+       mt76_set(dev, addr + 1 * 4, w1);
+       mt76_set(dev, addr + 2 * 4, MT_WTBL1_W2_ADMISSION_CONTROL);
+
+       mt76_stop_tx_ac(dev, GENMASK(3, 0));
+       addr = mt7603_wtbl2_addr(idx);
+       for (i = 0; i < MT_WTBL2_SIZE; i += 4)
+               mt76_wr(dev, addr + i, 0);
+       mt7603_wtbl_update(dev, idx, MT_WTBL_UPDATE_WTBL2);
+       mt76_start_tx_ac(dev, GENMASK(3, 0));
+
+       addr = mt7603_wtbl3_addr(idx);
+       for (i = 0; i < MT_WTBL3_SIZE; i += 4)
+               mt76_wr(dev, addr + i, 0);
+
+       addr = mt7603_wtbl4_addr(idx);
+       for (i = 0; i < MT_WTBL4_SIZE; i += 4)
+               mt76_wr(dev, addr + i, 0);
+}
+
+static void
+mt7603_wtbl_set_skip_tx(struct mt7603_dev *dev, int idx, bool enabled)
+{
+       u32 addr = mt7603_wtbl1_addr(idx);
+       u32 val = mt76_rr(dev, addr + 3 * 4);
+
+       val &= ~MT_WTBL1_W3_SKIP_TX;
+       val |= enabled * MT_WTBL1_W3_SKIP_TX;
+
+       mt76_wr(dev, addr + 3 * 4, val);
+}
+
+void mt7603_filter_tx(struct mt7603_dev *dev, int idx, bool abort)
+{
+       int i, port, queue;
+
+       if (abort) {
+               port = 3; /* PSE */
+               queue = 8; /* free queue */
+       } else {
+               port = 0; /* HIF */
+               queue = 1; /* MCU queue */
+       }
+
+       mt7603_wtbl_set_skip_tx(dev, idx, true);
+
+       mt76_wr(dev, MT_TX_ABORT, MT_TX_ABORT_EN |
+                       FIELD_PREP(MT_TX_ABORT_WCID, idx));
+
+       for (i = 0; i < 4; i++) {
+               mt76_wr(dev, MT_DMA_FQCR0, MT_DMA_FQCR0_BUSY |
+                       FIELD_PREP(MT_DMA_FQCR0_TARGET_WCID, idx) |
+                       FIELD_PREP(MT_DMA_FQCR0_TARGET_QID, i) |
+                       FIELD_PREP(MT_DMA_FQCR0_DEST_PORT_ID, port) |
+                       FIELD_PREP(MT_DMA_FQCR0_DEST_QUEUE_ID, queue));
+
+               WARN_ON_ONCE(!mt76_poll(dev, MT_DMA_FQCR0, MT_DMA_FQCR0_BUSY,
+                                       0, 5000));
+       }
+
+       mt76_wr(dev, MT_TX_ABORT, 0);
+
+       mt7603_wtbl_set_skip_tx(dev, idx, false);
+}
+
+void mt7603_wtbl_set_smps(struct mt7603_dev *dev, struct mt7603_sta *sta,
+                         bool enabled)
+{
+       u32 addr = mt7603_wtbl1_addr(sta->wcid.idx);
+
+       if (sta->smps == enabled)
+               return;
+
+       mt76_rmw_field(dev, addr + 2 * 4, MT_WTBL1_W2_SMPS, enabled);
+       sta->smps = enabled;
+}
+
+void mt7603_wtbl_set_ps(struct mt7603_dev *dev, struct mt7603_sta *sta,
+                       bool enabled)
+{
+       int idx = sta->wcid.idx;
+       u32 addr;
+
+       spin_lock_bh(&dev->ps_lock);
+
+       if (sta->ps == enabled)
+               goto out;
+
+       mt76_wr(dev, MT_PSE_RTA,
+               FIELD_PREP(MT_PSE_RTA_TAG_ID, idx) |
+               FIELD_PREP(MT_PSE_RTA_PORT_ID, 0) |
+               FIELD_PREP(MT_PSE_RTA_QUEUE_ID, 1) |
+               FIELD_PREP(MT_PSE_RTA_REDIRECT_EN, enabled) |
+               MT_PSE_RTA_WRITE | MT_PSE_RTA_BUSY);
+
+       mt76_poll(dev, MT_PSE_RTA, MT_PSE_RTA_BUSY, 0, 5000);
+
+       if (enabled)
+               mt7603_filter_tx(dev, idx, false);
+
+       addr = mt7603_wtbl1_addr(idx);
+       mt76_set(dev, MT_WTBL1_OR, MT_WTBL1_OR_PSM_WRITE);
+       mt76_rmw(dev, addr + 3 * 4, MT_WTBL1_W3_POWER_SAVE,
+                enabled * MT_WTBL1_W3_POWER_SAVE);
+       mt76_clear(dev, MT_WTBL1_OR, MT_WTBL1_OR_PSM_WRITE);
+       sta->ps = enabled;
+
+out:
+       spin_unlock_bh(&dev->ps_lock);
+}
+
+void mt7603_wtbl_clear(struct mt7603_dev *dev, int idx)
+{
+       int wtbl2_frame_size = MT_PSE_PAGE_SIZE / MT_WTBL2_SIZE;
+       int wtbl2_frame = idx / wtbl2_frame_size;
+       int wtbl2_entry = idx % wtbl2_frame_size;
+
+       int wtbl3_base_frame = MT_WTBL3_OFFSET / MT_PSE_PAGE_SIZE;
+       int wtbl3_frame_size = MT_PSE_PAGE_SIZE / MT_WTBL3_SIZE;
+       int wtbl3_frame = wtbl3_base_frame + idx / wtbl3_frame_size;
+       int wtbl3_entry = (idx % wtbl3_frame_size) * 2;
+
+       int wtbl4_base_frame = MT_WTBL4_OFFSET / MT_PSE_PAGE_SIZE;
+       int wtbl4_frame_size = MT_PSE_PAGE_SIZE / MT_WTBL4_SIZE;
+       int wtbl4_frame = wtbl4_base_frame + idx / wtbl4_frame_size;
+       int wtbl4_entry = idx % wtbl4_frame_size;
+
+       u32 addr = MT_WTBL1_BASE + idx * MT_WTBL1_SIZE;
+       int i;
+
+       mt76_poll(dev, MT_WTBL_UPDATE, MT_WTBL_UPDATE_BUSY, 0, 5000);
+
+       mt76_wr(dev, addr + 0 * 4,
+               MT_WTBL1_W0_RX_CHECK_A1 |
+               MT_WTBL1_W0_RX_CHECK_A2 |
+               MT_WTBL1_W0_RX_VALID);
+       mt76_wr(dev, addr + 1 * 4, 0);
+       mt76_wr(dev, addr + 2 * 4, 0);
+
+       mt76_set(dev, MT_WTBL1_OR, MT_WTBL1_OR_PSM_WRITE);
+
+       mt76_wr(dev, addr + 3 * 4,
+               FIELD_PREP(MT_WTBL1_W3_WTBL2_FRAME_ID, wtbl2_frame) |
+               FIELD_PREP(MT_WTBL1_W3_WTBL2_ENTRY_ID, wtbl2_entry) |
+               FIELD_PREP(MT_WTBL1_W3_WTBL4_FRAME_ID, wtbl4_frame) |
+               MT_WTBL1_W3_I_PSM | MT_WTBL1_W3_KEEP_I_PSM);
+       mt76_wr(dev, addr + 4 * 4,
+               FIELD_PREP(MT_WTBL1_W4_WTBL3_FRAME_ID, wtbl3_frame) |
+               FIELD_PREP(MT_WTBL1_W4_WTBL3_ENTRY_ID, wtbl3_entry) |
+               FIELD_PREP(MT_WTBL1_W4_WTBL4_ENTRY_ID, wtbl4_entry));
+
+       mt76_clear(dev, MT_WTBL1_OR, MT_WTBL1_OR_PSM_WRITE);
+
+       addr = mt7603_wtbl2_addr(idx);
+
+       /* Clear BA information */
+       mt76_wr(dev, addr + (15 * 4), 0);
+
+       mt76_stop_tx_ac(dev, GENMASK(3, 0));
+       for (i = 2; i <= 4; i++)
+               mt76_wr(dev, addr + (i * 4), 0);
+       mt7603_wtbl_update(dev, idx, MT_WTBL_UPDATE_WTBL2);
+       mt76_start_tx_ac(dev, GENMASK(3, 0));
+
+       mt7603_wtbl_update(dev, idx, MT_WTBL_UPDATE_RX_COUNT_CLEAR);
+       mt7603_wtbl_update(dev, idx, MT_WTBL_UPDATE_TX_COUNT_CLEAR);
+       mt7603_wtbl_update(dev, idx, MT_WTBL_UPDATE_ADM_COUNT_CLEAR);
+}
+
+void mt7603_wtbl_update_cap(struct mt7603_dev *dev, struct ieee80211_sta *sta)
+{
+       struct mt7603_sta *msta = (struct mt7603_sta *)sta->drv_priv;
+       int idx = msta->wcid.idx;
+       u32 addr;
+       u32 val;
+
+       addr = mt7603_wtbl1_addr(idx);
+
+       val = mt76_rr(dev, addr + 2 * 4);
+       val &= MT_WTBL1_W2_KEY_TYPE | MT_WTBL1_W2_ADMISSION_CONTROL;
+       val |= FIELD_PREP(MT_WTBL1_W2_AMPDU_FACTOR, sta->ht_cap.ampdu_factor) |
+              FIELD_PREP(MT_WTBL1_W2_MPDU_DENSITY, sta->ht_cap.ampdu_density) |
+              MT_WTBL1_W2_TXS_BAF_REPORT;
+
+       if (sta->ht_cap.cap)
+               val |= MT_WTBL1_W2_HT;
+       if (sta->vht_cap.cap)
+               val |= MT_WTBL1_W2_VHT;
+
+       mt76_wr(dev, addr + 2 * 4, val);
+
+       addr = mt7603_wtbl2_addr(idx);
+       val = mt76_rr(dev, addr + 9 * 4);
+       val &= ~(MT_WTBL2_W9_SHORT_GI_20 | MT_WTBL2_W9_SHORT_GI_40 |
+                MT_WTBL2_W9_SHORT_GI_80);
+       if (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_20)
+               val |= MT_WTBL2_W9_SHORT_GI_20;
+       if (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_40)
+               val |= MT_WTBL2_W9_SHORT_GI_40;
+       mt76_wr(dev, addr + 9 * 4, val);
+}
+
+void mt7603_mac_rx_ba_reset(struct mt7603_dev *dev, void *addr, u8 tid)
+{
+       mt76_wr(dev, MT_BA_CONTROL_0, get_unaligned_le32(addr));
+       mt76_wr(dev, MT_BA_CONTROL_1,
+               (get_unaligned_le16(addr + 4) |
+                FIELD_PREP(MT_BA_CONTROL_1_TID, tid) |
+                MT_BA_CONTROL_1_RESET));
+}
+
+void mt7603_mac_tx_ba_reset(struct mt7603_dev *dev, int wcid, int tid, int ssn,
+                           int ba_size)
+{
+       u32 addr = mt7603_wtbl2_addr(wcid);
+       u32 tid_mask = FIELD_PREP(MT_WTBL2_W15_BA_EN_TIDS, BIT(tid)) |
+                      (MT_WTBL2_W15_BA_WIN_SIZE <<
+                       (tid * MT_WTBL2_W15_BA_WIN_SIZE_SHIFT));
+       u32 tid_val;
+       int i;
+
+       if (ba_size < 0) {
+               /* disable */
+               mt76_clear(dev, addr + (15 * 4), tid_mask);
+               return;
+       }
+       mt76_poll(dev, MT_WTBL_UPDATE, MT_WTBL_UPDATE_BUSY, 0, 5000);
+
+       mt7603_mac_stop(dev);
+       switch (tid) {
+       case 0:
+               mt76_rmw_field(dev, addr + (2 * 4), MT_WTBL2_W2_TID0_SN, ssn);
+               break;
+       case 1:
+               mt76_rmw_field(dev, addr + (2 * 4), MT_WTBL2_W2_TID1_SN, ssn);
+               break;
+       case 2:
+               mt76_rmw_field(dev, addr + (2 * 4), MT_WTBL2_W2_TID2_SN_LO,
+                              ssn);
+               mt76_rmw_field(dev, addr + (3 * 4), MT_WTBL2_W3_TID2_SN_HI,
+                              ssn >> 8);
+               break;
+       case 3:
+               mt76_rmw_field(dev, addr + (3 * 4), MT_WTBL2_W3_TID3_SN, ssn);
+               break;
+       case 4:
+               mt76_rmw_field(dev, addr + (3 * 4), MT_WTBL2_W3_TID4_SN, ssn);
+               break;
+       case 5:
+               mt76_rmw_field(dev, addr + (3 * 4), MT_WTBL2_W3_TID5_SN_LO,
+                              ssn);
+               mt76_rmw_field(dev, addr + (4 * 4), MT_WTBL2_W4_TID5_SN_HI,
+                              ssn >> 4);
+               break;
+       case 6:
+               mt76_rmw_field(dev, addr + (4 * 4), MT_WTBL2_W4_TID6_SN, ssn);
+               break;
+       case 7:
+               mt76_rmw_field(dev, addr + (4 * 4), MT_WTBL2_W4_TID7_SN, ssn);
+               break;
+       }
+       mt7603_wtbl_update(dev, wcid, MT_WTBL_UPDATE_WTBL2);
+       mt7603_mac_start(dev);
+
+       for (i = 7; i > 0; i--) {
+               if (ba_size < MT_AGG_SIZE_LIMIT(i))
+                       break;
+       }
+
+       tid_val = FIELD_PREP(MT_WTBL2_W15_BA_EN_TIDS, BIT(tid)) |
+                 i << (tid * MT_WTBL2_W15_BA_WIN_SIZE_SHIFT);
+
+       mt76_rmw(dev, addr + (15 * 4), tid_mask, tid_val);
+}
+
+static int
+mt7603_get_rate(struct mt7603_dev *dev, struct ieee80211_supported_band *sband,
+               int idx, bool cck)
+{
+       int offset = 0;
+       int len = sband->n_bitrates;
+       int i;
+
+       if (cck) {
+               if (sband == &dev->mt76.sband_5g.sband)
+                       return 0;
+
+               idx &= ~BIT(2); /* short preamble */
+       } else if (sband == &dev->mt76.sband_2g.sband) {
+               offset = 4;
+       }
+
+       for (i = offset; i < len; i++) {
+               if ((sband->bitrates[i].hw_value & GENMASK(7, 0)) == idx)
+                       return i;
+       }
+
+       return 0;
+}
+
+static struct mt76_wcid *
+mt7603_rx_get_wcid(struct mt7603_dev *dev, u8 idx, bool unicast)
+{
+       struct mt7603_sta *sta;
+       struct mt76_wcid *wcid;
+
+       if (idx >= ARRAY_SIZE(dev->mt76.wcid))
+               return NULL;
+
+       wcid = rcu_dereference(dev->mt76.wcid[idx]);
+       if (unicast || !wcid)
+               return wcid;
+
+       if (!wcid->sta)
+               return NULL;
+
+       sta = container_of(wcid, struct mt7603_sta, wcid);
+       if (!sta->vif)
+               return NULL;
+
+       return &sta->vif->sta.wcid;
+}
+
+static void
+mt7603_insert_ccmp_hdr(struct sk_buff *skb, u8 key_id)
+{
+       struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb;
+       int hdr_len = ieee80211_get_hdrlen_from_skb(skb);
+       u8 *pn = status->iv;
+       u8 *hdr;
+
+       __skb_push(skb, 8);
+       memmove(skb->data, skb->data + 8, hdr_len);
+       hdr = skb->data + hdr_len;
+
+       hdr[0] = pn[5];
+       hdr[1] = pn[4];
+       hdr[2] = 0;
+       hdr[3] = 0x20 | (key_id << 6);
+       hdr[4] = pn[3];
+       hdr[5] = pn[2];
+       hdr[6] = pn[1];
+       hdr[7] = pn[0];
+
+       status->flag &= ~RX_FLAG_IV_STRIPPED;
+}
+
+int
+mt7603_mac_fill_rx(struct mt7603_dev *dev, struct sk_buff *skb)
+{
+       struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb;
+       struct ieee80211_supported_band *sband;
+       struct ieee80211_hdr *hdr;
+       __le32 *rxd = (__le32 *)skb->data;
+       u32 rxd0 = le32_to_cpu(rxd[0]);
+       u32 rxd1 = le32_to_cpu(rxd[1]);
+       u32 rxd2 = le32_to_cpu(rxd[2]);
+       bool unicast = rxd1 & MT_RXD1_NORMAL_U2M;
+       bool insert_ccmp_hdr = false;
+       bool remove_pad;
+       int idx;
+       int i;
+
+       memset(status, 0, sizeof(*status));
+
+       i = FIELD_GET(MT_RXD1_NORMAL_CH_FREQ, rxd1);
+       sband = (i & 1) ? &dev->mt76.sband_5g.sband : &dev->mt76.sband_2g.sband;
+       i >>= 1;
+
+       idx = FIELD_GET(MT_RXD2_NORMAL_WLAN_IDX, rxd2);
+       status->wcid = mt7603_rx_get_wcid(dev, idx, unicast);
+
+       status->band = sband->band;
+       if (i < sband->n_channels)
+               status->freq = sband->channels[i].center_freq;
+
+       if (rxd2 & MT_RXD2_NORMAL_FCS_ERR)
+               status->flag |= RX_FLAG_FAILED_FCS_CRC;
+
+       if (rxd2 & MT_RXD2_NORMAL_TKIP_MIC_ERR)
+               status->flag |= RX_FLAG_MMIC_ERROR;
+
+       if (FIELD_GET(MT_RXD2_NORMAL_SEC_MODE, rxd2) != 0 &&
+           !(rxd2 & (MT_RXD2_NORMAL_CLM | MT_RXD2_NORMAL_CM))) {
+               status->flag |= RX_FLAG_DECRYPTED;
+               status->flag |= RX_FLAG_IV_STRIPPED;
+               status->flag |= RX_FLAG_MMIC_STRIPPED | RX_FLAG_MIC_STRIPPED;
+       }
+
+       remove_pad = rxd1 & MT_RXD1_NORMAL_HDR_OFFSET;
+
+       if (rxd2 & MT_RXD2_NORMAL_MAX_LEN_ERROR)
+               return -EINVAL;
+
+       if (!sband->channels)
+               return -EINVAL;
+
+       rxd += 4;
+       if (rxd0 & MT_RXD0_NORMAL_GROUP_4) {
+               rxd += 4;
+               if ((u8 *)rxd - skb->data >= skb->len)
+                       return -EINVAL;
+       }
+       if (rxd0 & MT_RXD0_NORMAL_GROUP_1) {
+               u8 *data = (u8 *)rxd;
+
+               if (status->flag & RX_FLAG_DECRYPTED) {
+                       status->iv[0] = data[5];
+                       status->iv[1] = data[4];
+                       status->iv[2] = data[3];
+                       status->iv[3] = data[2];
+                       status->iv[4] = data[1];
+                       status->iv[5] = data[0];
+
+                       insert_ccmp_hdr = FIELD_GET(MT_RXD2_NORMAL_FRAG, rxd2);
+               }
+
+               rxd += 4;
+               if ((u8 *)rxd - skb->data >= skb->len)
+                       return -EINVAL;
+       }
+       if (rxd0 & MT_RXD0_NORMAL_GROUP_2) {
+               rxd += 2;
+               if ((u8 *)rxd - skb->data >= skb->len)
+                       return -EINVAL;
+       }
+       if (rxd0 & MT_RXD0_NORMAL_GROUP_3) {
+               u32 rxdg0 = le32_to_cpu(rxd[0]);
+               u32 rxdg3 = le32_to_cpu(rxd[3]);
+               bool cck = false;
+
+               i = FIELD_GET(MT_RXV1_TX_RATE, rxdg0);
+               switch (FIELD_GET(MT_RXV1_TX_MODE, rxdg0)) {
+               case MT_PHY_TYPE_CCK:
+                       cck = true;
+                       /* fall through */
+               case MT_PHY_TYPE_OFDM:
+                       i = mt7603_get_rate(dev, sband, i, cck);
+                       break;
+               case MT_PHY_TYPE_HT_GF:
+               case MT_PHY_TYPE_HT:
+                       status->encoding = RX_ENC_HT;
+                       if (i > 15)
+                               return -EINVAL;
+                       break;
+               default:
+                       return -EINVAL;
+               }
+
+               if (rxdg0 & MT_RXV1_HT_SHORT_GI)
+                       status->enc_flags |= RX_ENC_FLAG_SHORT_GI;
+               if (rxdg0 & MT_RXV1_HT_AD_CODE)
+                       status->enc_flags |= RX_ENC_FLAG_LDPC;
+
+               status->enc_flags |= RX_ENC_FLAG_STBC_MASK *
+                                   FIELD_GET(MT_RXV1_HT_STBC, rxdg0);
+
+               status->rate_idx = i;
+
+               status->chains = dev->mt76.antenna_mask;
+               status->chain_signal[0] = FIELD_GET(MT_RXV4_IB_RSSI0, rxdg3) +
+                                         dev->rssi_offset[0];
+               status->chain_signal[1] = FIELD_GET(MT_RXV4_IB_RSSI1, rxdg3) +
+                                         dev->rssi_offset[1];
+
+               status->signal = status->chain_signal[0];
+               if (status->chains & BIT(1))
+                       status->signal = max(status->signal,
+                                            status->chain_signal[1]);
+
+               if (FIELD_GET(MT_RXV1_FRAME_MODE, rxdg0) == 1)
+                       status->bw = RATE_INFO_BW_40;
+
+               rxd += 6;
+               if ((u8 *)rxd - skb->data >= skb->len)
+                       return -EINVAL;
+       } else {
+               return -EINVAL;
+       }
+
+       skb_pull(skb, (u8 *)rxd - skb->data + 2 * remove_pad);
+
+       if (insert_ccmp_hdr) {
+               u8 key_id = FIELD_GET(MT_RXD1_NORMAL_KEY_ID, rxd1);
+
+               mt7603_insert_ccmp_hdr(skb, key_id);
+       }
+
+       hdr = (struct ieee80211_hdr *)skb->data;
+       if (!status->wcid || !ieee80211_is_data_qos(hdr->frame_control))
+               return 0;
+
+       status->aggr = unicast &&
+                      !ieee80211_is_qos_nullfunc(hdr->frame_control);
+       status->tid = *ieee80211_get_qos_ctl(hdr) & IEEE80211_QOS_CTL_TID_MASK;
+       status->seqno = hdr->seq_ctrl >> 4;
+
+       return 0;
+}
+
+static u16
+mt7603_mac_tx_rate_val(struct mt7603_dev *dev,
+                      const struct ieee80211_tx_rate *rate, bool stbc, u8 *bw)
+{
+       u8 phy, nss, rate_idx;
+       u16 rateval;
+
+       *bw = 0;
+       if (rate->flags & IEEE80211_TX_RC_MCS) {
+               rate_idx = rate->idx;
+               nss = 1 + (rate->idx >> 3);
+               phy = MT_PHY_TYPE_HT;
+               if (rate->flags & IEEE80211_TX_RC_GREEN_FIELD)
+                       phy = MT_PHY_TYPE_HT_GF;
+               if (rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
+                       *bw = 1;
+       } else {
+               const struct ieee80211_rate *r;
+               int band = dev->mt76.chandef.chan->band;
+               u16 val;
+
+               nss = 1;
+               r = &mt76_hw(dev)->wiphy->bands[band]->bitrates[rate->idx];
+               if (rate->flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
+                       val = r->hw_value_short;
+               else
+                       val = r->hw_value;
+
+               phy = val >> 8;
+               rate_idx = val & 0xff;
+       }
+
+       rateval = (FIELD_PREP(MT_TX_RATE_IDX, rate_idx) |
+                  FIELD_PREP(MT_TX_RATE_MODE, phy));
+
+       if (stbc && nss == 1)
+               rateval |= MT_TX_RATE_STBC;
+
+       return rateval;
+}
+
+void mt7603_wtbl_set_rates(struct mt7603_dev *dev, struct mt7603_sta *sta,
+                          struct ieee80211_tx_rate *probe_rate,
+                          struct ieee80211_tx_rate *rates)
+{
+       int wcid = sta->wcid.idx;
+       u32 addr = mt7603_wtbl2_addr(wcid);
+       bool stbc = false;
+       int n_rates = sta->n_rates;
+       u8 bw, bw_prev, bw_idx = 0;
+       u16 val[4];
+       u16 probe_val;
+       u32 w9 = mt76_rr(dev, addr + 9 * 4);
+       int i;
+
+       if (!mt76_poll(dev, MT_WTBL_UPDATE, MT_WTBL_UPDATE_BUSY, 0, 5000))
+               return;
+
+       for (i = n_rates; i < 4; i++)
+               rates[i] = rates[n_rates - 1];
+
+       w9 &= MT_WTBL2_W9_SHORT_GI_20 | MT_WTBL2_W9_SHORT_GI_40 |
+             MT_WTBL2_W9_SHORT_GI_80;
+
+       val[0] = mt7603_mac_tx_rate_val(dev, &rates[0], stbc, &bw);
+       bw_prev = bw;
+
+       if (probe_rate) {
+               probe_val = mt7603_mac_tx_rate_val(dev, probe_rate, stbc, &bw);
+               if (bw)
+                       bw_idx = 1;
+               else
+                       bw_prev = 0;
+       } else {
+               probe_val = val[0];
+       }
+
+       w9 |= FIELD_PREP(MT_WTBL2_W9_CC_BW_SEL, bw);
+       w9 |= FIELD_PREP(MT_WTBL2_W9_BW_CAP, bw);
+
+       val[1] = mt7603_mac_tx_rate_val(dev, &rates[1], stbc, &bw);
+       if (bw_prev) {
+               bw_idx = 3;
+               bw_prev = bw;
+       }
+
+       val[2] = mt7603_mac_tx_rate_val(dev, &rates[2], stbc, &bw);
+       if (bw_prev) {
+               bw_idx = 5;
+               bw_prev = bw;
+       }
+
+       val[3] = mt7603_mac_tx_rate_val(dev, &rates[3], stbc, &bw);
+       if (bw_prev)
+               bw_idx = 7;
+
+       w9 |= FIELD_PREP(MT_WTBL2_W9_CHANGE_BW_RATE,
+                      bw_idx ? bw_idx - 1 : 7);
+
+       mt76_wr(dev, MT_WTBL_RIUCR0, w9);
+
+       mt76_wr(dev, MT_WTBL_RIUCR1,
+               FIELD_PREP(MT_WTBL_RIUCR1_RATE0, probe_val) |
+               FIELD_PREP(MT_WTBL_RIUCR1_RATE1, val[0]) |
+               FIELD_PREP(MT_WTBL_RIUCR1_RATE2_LO, val[0]));
+
+       mt76_wr(dev, MT_WTBL_RIUCR2,
+               FIELD_PREP(MT_WTBL_RIUCR2_RATE2_HI, val[0] >> 8) |
+               FIELD_PREP(MT_WTBL_RIUCR2_RATE3, val[1]) |
+               FIELD_PREP(MT_WTBL_RIUCR2_RATE4, val[1]) |
+               FIELD_PREP(MT_WTBL_RIUCR2_RATE5_LO, val[2]));
+
+       mt76_wr(dev, MT_WTBL_RIUCR3,
+               FIELD_PREP(MT_WTBL_RIUCR3_RATE5_HI, val[2] >> 4) |
+               FIELD_PREP(MT_WTBL_RIUCR3_RATE6, val[2]) |
+               FIELD_PREP(MT_WTBL_RIUCR3_RATE7, val[3]));
+
+       mt76_wr(dev, MT_WTBL_UPDATE,
+               FIELD_PREP(MT_WTBL_UPDATE_WLAN_IDX, wcid) |
+               MT_WTBL_UPDATE_RATE_UPDATE |
+               MT_WTBL_UPDATE_TX_COUNT_CLEAR);
+
+       if (!sta->wcid.tx_rate_set)
+               mt76_poll(dev, MT_WTBL_UPDATE, MT_WTBL_UPDATE_BUSY, 0, 5000);
+
+       sta->rate_count = 2 * MT7603_RATE_RETRY * n_rates;
+       sta->wcid.tx_rate_set = true;
+}
+
+static enum mt7603_cipher_type
+mt7603_mac_get_key_info(struct ieee80211_key_conf *key, u8 *key_data)
+{
+       memset(key_data, 0, 32);
+       if (!key)
+               return MT_CIPHER_NONE;
+
+       if (key->keylen > 32)
+               return MT_CIPHER_NONE;
+
+       memcpy(key_data, key->key, key->keylen);
+
+       switch (key->cipher) {
+       case WLAN_CIPHER_SUITE_WEP40:
+               return MT_CIPHER_WEP40;
+       case WLAN_CIPHER_SUITE_WEP104:
+               return MT_CIPHER_WEP104;
+       case WLAN_CIPHER_SUITE_TKIP:
+               /* Rx/Tx MIC keys are swapped */
+               memcpy(key_data + 16, key->key + 24, 8);
+               memcpy(key_data + 24, key->key + 16, 8);
+               return MT_CIPHER_TKIP;
+       case WLAN_CIPHER_SUITE_CCMP:
+               return MT_CIPHER_AES_CCMP;
+       default:
+               return MT_CIPHER_NONE;
+       }
+}
+
+int mt7603_wtbl_set_key(struct mt7603_dev *dev, int wcid,
+                       struct ieee80211_key_conf *key)
+{
+       enum mt7603_cipher_type cipher;
+       u32 addr = mt7603_wtbl3_addr(wcid);
+       u8 key_data[32];
+       int key_len = sizeof(key_data);
+
+       cipher = mt7603_mac_get_key_info(key, key_data);
+       if (cipher == MT_CIPHER_NONE && key)
+               return -EOPNOTSUPP;
+
+       if (key && (cipher == MT_CIPHER_WEP40 || cipher == MT_CIPHER_WEP104)) {
+               addr += key->keyidx * 16;
+               key_len = 16;
+       }
+
+       mt76_wr_copy(dev, addr, key_data, key_len);
+
+       addr = mt7603_wtbl1_addr(wcid);
+       mt76_rmw_field(dev, addr + 2 * 4, MT_WTBL1_W2_KEY_TYPE, cipher);
+       if (key)
+               mt76_rmw_field(dev, addr, MT_WTBL1_W0_KEY_IDX, key->keyidx);
+       mt76_rmw_field(dev, addr, MT_WTBL1_W0_RX_KEY_VALID, !!key);
+
+       return 0;
+}
+
+static int
+mt7603_mac_write_txwi(struct mt7603_dev *dev, __le32 *txwi,
+                     struct sk_buff *skb, struct mt76_queue *q,
+                     struct mt76_wcid *wcid, struct ieee80211_sta *sta,
+                     int pid, struct ieee80211_key_conf *key)
+{
+       struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+       struct ieee80211_tx_rate *rate = &info->control.rates[0];
+       struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
+       struct ieee80211_vif *vif = info->control.vif;
+       struct mt7603_vif *mvif;
+       int wlan_idx;
+       int hdr_len = ieee80211_get_hdrlen_from_skb(skb);
+       int tx_count = 8;
+       u8 frame_type, frame_subtype;
+       u16 fc = le16_to_cpu(hdr->frame_control);
+       u8 vif_idx = 0;
+       u32 val;
+       u8 bw;
+
+       if (vif) {
+               mvif = (struct mt7603_vif *)vif->drv_priv;
+               vif_idx = mvif->idx;
+               if (vif_idx && q >= &dev->mt76.q_tx[MT_TXQ_BEACON])
+                       vif_idx += 0x10;
+       }
+
+       if (sta) {
+               struct mt7603_sta *msta = (struct mt7603_sta *)sta->drv_priv;
+
+               tx_count = msta->rate_count;
+       }
+
+       if (wcid)
+               wlan_idx = wcid->idx;
+       else
+               wlan_idx = MT7603_WTBL_RESERVED;
+
+       frame_type = (fc & IEEE80211_FCTL_FTYPE) >> 2;
+       frame_subtype = (fc & IEEE80211_FCTL_STYPE) >> 4;
+
+       val = FIELD_PREP(MT_TXD0_TX_BYTES, skb->len + MT_TXD_SIZE) |
+             FIELD_PREP(MT_TXD0_Q_IDX, q->hw_idx);
+       txwi[0] = cpu_to_le32(val);
+
+       val = MT_TXD1_LONG_FORMAT |
+             FIELD_PREP(MT_TXD1_OWN_MAC, vif_idx) |
+             FIELD_PREP(MT_TXD1_TID,
+                        skb->priority & IEEE80211_QOS_CTL_TID_MASK) |
+             FIELD_PREP(MT_TXD1_HDR_FORMAT, MT_HDR_FORMAT_802_11) |
+             FIELD_PREP(MT_TXD1_HDR_INFO, hdr_len / 2) |
+             FIELD_PREP(MT_TXD1_WLAN_IDX, wlan_idx) |
+             FIELD_PREP(MT_TXD1_PROTECTED, !!key);
+       txwi[1] = cpu_to_le32(val);
+
+       if (info->flags & IEEE80211_TX_CTL_NO_ACK)
+               txwi[1] |= cpu_to_le32(MT_TXD1_NO_ACK);
+
+       val = FIELD_PREP(MT_TXD2_FRAME_TYPE, frame_type) |
+             FIELD_PREP(MT_TXD2_SUB_TYPE, frame_subtype) |
+             FIELD_PREP(MT_TXD2_MULTICAST,
+                        is_multicast_ether_addr(hdr->addr1));
+       txwi[2] = cpu_to_le32(val);
+
+       if (!(info->flags & IEEE80211_TX_CTL_AMPDU))
+               txwi[2] |= cpu_to_le32(MT_TXD2_BA_DISABLE);
+
+       txwi[4] = 0;
+
+       val = MT_TXD5_TX_STATUS_HOST | MT_TXD5_SW_POWER_MGMT |
+             FIELD_PREP(MT_TXD5_PID, pid);
+       txwi[5] = cpu_to_le32(val);
+
+       txwi[6] = 0;
+
+       if (rate->idx >= 0 && rate->count &&
+           !(info->flags & IEEE80211_TX_CTL_RATE_CTRL_PROBE)) {
+               bool stbc = info->flags & IEEE80211_TX_CTL_STBC;
+               u16 rateval = mt7603_mac_tx_rate_val(dev, rate, stbc, &bw);
+
+               txwi[2] |= cpu_to_le32(MT_TXD2_FIX_RATE);
+
+               val = MT_TXD6_FIXED_BW |
+                     FIELD_PREP(MT_TXD6_BW, bw) |
+                     FIELD_PREP(MT_TXD6_TX_RATE, rateval);
+               txwi[6] |= cpu_to_le32(val);
+
+               if (rate->flags & IEEE80211_TX_RC_SHORT_GI)
+                       txwi[6] |= cpu_to_le32(MT_TXD6_SGI);
+
+               if (!(rate->flags & IEEE80211_TX_RC_MCS))
+                       txwi[2] |= cpu_to_le32(MT_TXD2_BA_DISABLE);
+
+               tx_count = rate->count;
+       }
+
+       /* use maximum tx count for beacons and buffered multicast */
+       if (q >= &dev->mt76.q_tx[MT_TXQ_BEACON])
+               tx_count = 0x1f;
+
+       val = FIELD_PREP(MT_TXD3_REM_TX_COUNT, tx_count) |
+             FIELD_PREP(MT_TXD3_SEQ, le16_to_cpu(hdr->seq_ctrl));
+       txwi[3] = cpu_to_le32(val);
+
+       if (key) {
+               u64 pn = atomic64_inc_return(&key->tx_pn);
+
+               txwi[3] |= cpu_to_le32(MT_TXD3_PN_VALID);
+               txwi[4] = cpu_to_le32(pn & GENMASK(31, 0));
+               txwi[5] |= cpu_to_le32(FIELD_PREP(MT_TXD5_PN_HIGH, pn >> 32));
+       }
+
+       txwi[7] = 0;
+
+       return 0;
+}
+
+int mt7603_tx_prepare_skb(struct mt76_dev *mdev, void *txwi_ptr,
+                         struct sk_buff *skb, struct mt76_queue *q,
+                         struct mt76_wcid *wcid, struct ieee80211_sta *sta,
+                         u32 *tx_info)
+{
+       struct mt7603_dev *dev = container_of(mdev, struct mt7603_dev, mt76);
+       struct mt7603_sta *msta = container_of(wcid, struct mt7603_sta, wcid);
+       struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+       struct ieee80211_key_conf *key = info->control.hw_key;
+       int pid;
+
+       if (!wcid)
+               wcid = &dev->global_sta.wcid;
+
+       if (sta) {
+               msta = (struct mt7603_sta *)sta->drv_priv;
+
+               if ((info->flags & (IEEE80211_TX_CTL_NO_PS_BUFFER |
+                                   IEEE80211_TX_CTL_CLEAR_PS_FILT)) ||
+                   (info->control.flags & IEEE80211_TX_CTRL_PS_RESPONSE))
+                       mt7603_wtbl_set_ps(dev, msta, false);
+       }
+
+       pid = mt76_tx_status_skb_add(mdev, wcid, skb);
+
+       if (info->flags & IEEE80211_TX_CTL_RATE_CTRL_PROBE) {
+               spin_lock_bh(&dev->mt76.lock);
+               msta->rate_probe = true;
+               mt7603_wtbl_set_rates(dev, msta, &info->control.rates[0],
+                                     msta->rates);
+               spin_unlock_bh(&dev->mt76.lock);
+       }
+
+       mt7603_mac_write_txwi(dev, txwi_ptr, skb, q, wcid, sta, pid, key);
+
+       return 0;
+}
+
+static bool
+mt7603_fill_txs(struct mt7603_dev *dev, struct mt7603_sta *sta,
+               struct ieee80211_tx_info *info, __le32 *txs_data)
+{
+       struct ieee80211_supported_band *sband;
+       int final_idx = 0;
+       u32 final_rate;
+       u32 final_rate_flags;
+       bool final_mpdu;
+       bool ack_timeout;
+       bool fixed_rate;
+       bool probe;
+       bool ampdu;
+       bool cck = false;
+       int count;
+       u32 txs;
+       u8 pid;
+       int idx;
+       int i;
+
+       fixed_rate = info->status.rates[0].count;
+       probe = !!(info->flags & IEEE80211_TX_CTL_RATE_CTRL_PROBE);
+
+       txs = le32_to_cpu(txs_data[4]);
+       final_mpdu = txs & MT_TXS4_ACKED_MPDU;
+       ampdu = !fixed_rate && (txs & MT_TXS4_AMPDU);
+       pid = FIELD_GET(MT_TXS4_PID, txs);
+       count = FIELD_GET(MT_TXS4_TX_COUNT, txs);
+
+       txs = le32_to_cpu(txs_data[0]);
+       final_rate = FIELD_GET(MT_TXS0_TX_RATE, txs);
+       ack_timeout = txs & MT_TXS0_ACK_TIMEOUT;
+
+       if (!ampdu && (txs & MT_TXS0_RTS_TIMEOUT))
+               return false;
+
+       if (txs & MT_TXS0_QUEUE_TIMEOUT)
+               return false;
+
+       if (!ack_timeout)
+               info->flags |= IEEE80211_TX_STAT_ACK;
+
+       info->status.ampdu_len = 1;
+       info->status.ampdu_ack_len = !!(info->flags &
+                                       IEEE80211_TX_STAT_ACK);
+
+       if (ampdu || (info->flags & IEEE80211_TX_CTL_AMPDU))
+               info->flags |= IEEE80211_TX_STAT_AMPDU | IEEE80211_TX_CTL_AMPDU;
+
+       if (fixed_rate && !probe) {
+               info->status.rates[0].count = count;
+               goto out;
+       }
+
+       for (i = 0, idx = 0; i < ARRAY_SIZE(info->status.rates); i++) {
+               int cur_count = min_t(int, count, 2 * MT7603_RATE_RETRY);
+
+               if (!i && probe) {
+                       cur_count = 1;
+               } else {
+                       info->status.rates[i] = sta->rates[idx];
+                       idx++;
+               }
+
+               if (i && info->status.rates[i].idx < 0) {
+                       info->status.rates[i - 1].count += count;
+                       break;
+               }
+
+               if (!count) {
+                       info->status.rates[i].idx = -1;
+                       break;
+               }
+
+               info->status.rates[i].count = cur_count;
+               final_idx = i;
+               count -= cur_count;
+       }
+
+out:
+       final_rate_flags = info->status.rates[final_idx].flags;
+
+       switch (FIELD_GET(MT_TX_RATE_MODE, final_rate)) {
+       case MT_PHY_TYPE_CCK:
+               cck = true;
+               /* fall through */
+       case MT_PHY_TYPE_OFDM:
+               if (dev->mt76.chandef.chan->band == NL80211_BAND_5GHZ)
+                       sband = &dev->mt76.sband_5g.sband;
+               else
+                       sband = &dev->mt76.sband_2g.sband;
+               final_rate &= GENMASK(5, 0);
+               final_rate = mt7603_get_rate(dev, sband, final_rate, cck);
+               final_rate_flags = 0;
+               break;
+       case MT_PHY_TYPE_HT_GF:
+       case MT_PHY_TYPE_HT:
+               final_rate_flags |= IEEE80211_TX_RC_MCS;
+               final_rate &= GENMASK(5, 0);
+               if (i > 15)
+                       return false;
+               break;
+       default:
+               return false;
+       }
+
+       info->status.rates[final_idx].idx = final_rate;
+       info->status.rates[final_idx].flags = final_rate_flags;
+
+       return true;
+}
+
+static bool
+mt7603_mac_add_txs_skb(struct mt7603_dev *dev, struct mt7603_sta *sta, int pid,
+                      __le32 *txs_data)
+{
+       struct mt76_dev *mdev = &dev->mt76;
+       struct sk_buff_head list;
+       struct sk_buff *skb;
+
+       if (pid < MT_PACKET_ID_FIRST)
+               return false;
+
+       mt76_tx_status_lock(mdev, &list);
+       skb = mt76_tx_status_skb_get(mdev, &sta->wcid, pid, &list);
+       if (skb) {
+               struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+
+               if (info->flags & IEEE80211_TX_CTL_RATE_CTRL_PROBE) {
+                       spin_lock_bh(&dev->mt76.lock);
+                       if (sta->rate_probe) {
+                               mt7603_wtbl_set_rates(dev, sta, NULL,
+                                                     sta->rates);
+                               sta->rate_probe = false;
+                       }
+                       spin_unlock_bh(&dev->mt76.lock);
+               }
+
+               if (!mt7603_fill_txs(dev, sta, info, txs_data)) {
+                       ieee80211_tx_info_clear_status(info);
+                       info->status.rates[0].idx = -1;
+               }
+
+               mt76_tx_status_skb_done(mdev, skb, &list);
+       }
+       mt76_tx_status_unlock(mdev, &list);
+
+       return !!skb;
+}
+
+void mt7603_mac_add_txs(struct mt7603_dev *dev, void *data)
+{
+       struct ieee80211_tx_info info = {};
+       struct ieee80211_sta *sta = NULL;
+       struct mt7603_sta *msta = NULL;
+       struct mt76_wcid *wcid;
+       __le32 *txs_data = data;
+       u32 txs;
+       u8 wcidx;
+       u8 pid;
+
+       txs = le32_to_cpu(txs_data[4]);
+       pid = FIELD_GET(MT_TXS4_PID, txs);
+       txs = le32_to_cpu(txs_data[3]);
+       wcidx = FIELD_GET(MT_TXS3_WCID, txs);
+
+       if (pid == MT_PACKET_ID_NO_ACK)
+               return;
+
+       if (wcidx >= ARRAY_SIZE(dev->mt76.wcid))
+               return;
+
+       rcu_read_lock();
+
+       wcid = rcu_dereference(dev->mt76.wcid[wcidx]);
+       if (!wcid)
+               goto out;
+
+       msta = container_of(wcid, struct mt7603_sta, wcid);
+       sta = wcid_to_sta(wcid);
+
+       if (mt7603_mac_add_txs_skb(dev, msta, pid, txs_data))
+               goto out;
+
+       if (wcidx >= MT7603_WTBL_STA || !sta)
+               goto out;
+
+       if (mt7603_fill_txs(dev, msta, &info, txs_data))
+               ieee80211_tx_status_noskb(mt76_hw(dev), sta, &info);
+
+out:
+       rcu_read_unlock();
+}
+
+void mt7603_tx_complete_skb(struct mt76_dev *mdev, struct mt76_queue *q,
+                           struct mt76_queue_entry *e, bool flush)
+{
+       struct mt7603_dev *dev = container_of(mdev, struct mt7603_dev, mt76);
+       struct sk_buff *skb = e->skb;
+
+       if (!e->txwi) {
+               dev_kfree_skb_any(skb);
+               return;
+       }
+
+       if (q - dev->mt76.q_tx < 4)
+               dev->tx_hang_check = 0;
+
+       mt76_tx_complete_skb(mdev, skb);
+}
+
+static bool
+wait_for_wpdma(struct mt7603_dev *dev)
+{
+       return mt76_poll(dev, MT_WPDMA_GLO_CFG,
+                        MT_WPDMA_GLO_CFG_TX_DMA_BUSY |
+                        MT_WPDMA_GLO_CFG_RX_DMA_BUSY,
+                        0, 1000);
+}
+
+static void mt7603_pse_reset(struct mt7603_dev *dev)
+{
+       /* Clear previous reset result */
+       if (!dev->reset_cause[RESET_CAUSE_RESET_FAILED])
+               mt76_clear(dev, MT_MCU_DEBUG_RESET, MT_MCU_DEBUG_RESET_PSE_S);
+
+       /* Reset PSE */
+       mt76_set(dev, MT_MCU_DEBUG_RESET, MT_MCU_DEBUG_RESET_PSE);
+
+       if (!mt76_poll_msec(dev, MT_MCU_DEBUG_RESET,
+                           MT_MCU_DEBUG_RESET_PSE_S,
+                           MT_MCU_DEBUG_RESET_PSE_S, 500)) {
+               dev->reset_cause[RESET_CAUSE_RESET_FAILED]++;
+               mt76_clear(dev, MT_MCU_DEBUG_RESET, MT_MCU_DEBUG_RESET_PSE);
+       } else {
+               dev->reset_cause[RESET_CAUSE_RESET_FAILED] = 0;
+               mt76_clear(dev, MT_MCU_DEBUG_RESET, MT_MCU_DEBUG_RESET_QUEUES);
+       }
+
+       if (dev->reset_cause[RESET_CAUSE_RESET_FAILED] >= 3)
+               dev->reset_cause[RESET_CAUSE_RESET_FAILED] = 0;
+}
+
+void mt7603_mac_dma_start(struct mt7603_dev *dev)
+{
+       mt7603_mac_start(dev);
+
+       wait_for_wpdma(dev);
+       usleep_range(50, 100);
+
+       mt76_set(dev, MT_WPDMA_GLO_CFG,
+                (MT_WPDMA_GLO_CFG_TX_DMA_EN |
+                 MT_WPDMA_GLO_CFG_RX_DMA_EN |
+                 FIELD_PREP(MT_WPDMA_GLO_CFG_DMA_BURST_SIZE, 3) |
+                 MT_WPDMA_GLO_CFG_TX_WRITEBACK_DONE));
+
+       mt7603_irq_enable(dev, MT_INT_RX_DONE_ALL | MT_INT_TX_DONE_ALL);
+}
+
+void mt7603_mac_start(struct mt7603_dev *dev)
+{
+       mt76_clear(dev, MT_ARB_SCR,
+                  MT_ARB_SCR_TX_DISABLE | MT_ARB_SCR_RX_DISABLE);
+       mt76_wr(dev, MT_WF_ARB_TX_START_0, ~0);
+       mt76_set(dev, MT_WF_ARB_RQCR, MT_WF_ARB_RQCR_RX_START);
+}
+
+void mt7603_mac_stop(struct mt7603_dev *dev)
+{
+       mt76_set(dev, MT_ARB_SCR,
+                MT_ARB_SCR_TX_DISABLE | MT_ARB_SCR_RX_DISABLE);
+       mt76_wr(dev, MT_WF_ARB_TX_START_0, 0);
+       mt76_clear(dev, MT_WF_ARB_RQCR, MT_WF_ARB_RQCR_RX_START);
+}
+
+void mt7603_pse_client_reset(struct mt7603_dev *dev)
+{
+       u32 addr;
+
+       addr = mt7603_reg_map(dev, MT_CLIENT_BASE_PHYS_ADDR +
+                                  MT_CLIENT_RESET_TX);
+
+       /* Clear previous reset state */
+       mt76_clear(dev, addr,
+                  MT_CLIENT_RESET_TX_R_E_1 |
+                  MT_CLIENT_RESET_TX_R_E_2 |
+                  MT_CLIENT_RESET_TX_R_E_1_S |
+                  MT_CLIENT_RESET_TX_R_E_2_S);
+
+       /* Start PSE client TX abort */
+       mt76_set(dev, addr, MT_CLIENT_RESET_TX_R_E_1);
+       mt76_poll_msec(dev, addr, MT_CLIENT_RESET_TX_R_E_1_S,
+                      MT_CLIENT_RESET_TX_R_E_1_S, 500);
+
+       mt76_set(dev, addr, MT_CLIENT_RESET_TX_R_E_2);
+       mt76_set(dev, MT_WPDMA_GLO_CFG, MT_WPDMA_GLO_CFG_SW_RESET);
+
+       /* Wait for PSE client to clear TX FIFO */
+       mt76_poll_msec(dev, addr, MT_CLIENT_RESET_TX_R_E_2_S,
+                      MT_CLIENT_RESET_TX_R_E_2_S, 500);
+
+       /* Clear PSE client TX abort state */
+       mt76_clear(dev, addr,
+                  MT_CLIENT_RESET_TX_R_E_1 |
+                  MT_CLIENT_RESET_TX_R_E_2);
+}
+
+static void mt7603_dma_sched_reset(struct mt7603_dev *dev)
+{
+       if (!is_mt7628(dev))
+               return;
+
+       mt76_set(dev, MT_SCH_4, MT_SCH_4_RESET);
+       mt76_clear(dev, MT_SCH_4, MT_SCH_4_RESET);
+}
+
+static void mt7603_mac_watchdog_reset(struct mt7603_dev *dev)
+{
+       int beacon_int = dev->beacon_int;
+       u32 mask = dev->mt76.mmio.irqmask;
+       int i;
+
+       ieee80211_stop_queues(dev->mt76.hw);
+       set_bit(MT76_RESET, &dev->mt76.state);
+
+       /* lock/unlock all queues to ensure that no tx is pending */
+       mt76_txq_schedule_all(&dev->mt76);
+
+       tasklet_disable(&dev->tx_tasklet);
+       tasklet_disable(&dev->pre_tbtt_tasklet);
+       napi_disable(&dev->mt76.napi[0]);
+       napi_disable(&dev->mt76.napi[1]);
+
+       mutex_lock(&dev->mt76.mutex);
+
+       mt7603_beacon_set_timer(dev, -1, 0);
+
+       if (dev->reset_cause[RESET_CAUSE_RESET_FAILED] ||
+           dev->cur_reset_cause == RESET_CAUSE_RX_PSE_BUSY ||
+           dev->cur_reset_cause == RESET_CAUSE_BEACON_STUCK ||
+           dev->cur_reset_cause == RESET_CAUSE_TX_HANG)
+               mt7603_pse_reset(dev);
+
+       if (dev->reset_cause[RESET_CAUSE_RESET_FAILED])
+               goto skip_dma_reset;
+
+       mt7603_mac_stop(dev);
+
+       mt76_clear(dev, MT_WPDMA_GLO_CFG,
+                  MT_WPDMA_GLO_CFG_RX_DMA_EN | MT_WPDMA_GLO_CFG_TX_DMA_EN |
+                  MT_WPDMA_GLO_CFG_TX_WRITEBACK_DONE);
+       usleep_range(1000, 2000);
+
+       mt7603_irq_disable(dev, mask);
+
+       mt76_set(dev, MT_WPDMA_GLO_CFG, MT_WPDMA_GLO_CFG_FORCE_TX_EOF);
+
+       mt7603_pse_client_reset(dev);
+
+       for (i = 0; i < ARRAY_SIZE(dev->mt76.q_tx); i++)
+               mt76_queue_tx_cleanup(dev, i, true);
+
+       for (i = 0; i < ARRAY_SIZE(dev->mt76.q_rx); i++)
+               mt76_queue_rx_reset(dev, i);
+
+       mt7603_dma_sched_reset(dev);
+
+       mt7603_mac_dma_start(dev);
+
+       mt7603_irq_enable(dev, mask);
+
+skip_dma_reset:
+       clear_bit(MT76_RESET, &dev->mt76.state);
+       mutex_unlock(&dev->mt76.mutex);
+
+       tasklet_enable(&dev->tx_tasklet);
+       tasklet_schedule(&dev->tx_tasklet);
+
+       tasklet_enable(&dev->pre_tbtt_tasklet);
+       mt7603_beacon_set_timer(dev, -1, beacon_int);
+
+       napi_enable(&dev->mt76.napi[0]);
+       napi_schedule(&dev->mt76.napi[0]);
+
+       napi_enable(&dev->mt76.napi[1]);
+       napi_schedule(&dev->mt76.napi[1]);
+
+       ieee80211_wake_queues(dev->mt76.hw);
+       mt76_txq_schedule_all(&dev->mt76);
+}
+
+static u32 mt7603_dma_debug(struct mt7603_dev *dev, u8 index)
+{
+       u32 val;
+
+       mt76_wr(dev, MT_WPDMA_DEBUG,
+               FIELD_PREP(MT_WPDMA_DEBUG_IDX, index) |
+               MT_WPDMA_DEBUG_SEL);
+
+       val = mt76_rr(dev, MT_WPDMA_DEBUG);
+       return FIELD_GET(MT_WPDMA_DEBUG_VALUE, val);
+}
+
+static bool mt7603_rx_fifo_busy(struct mt7603_dev *dev)
+{
+       if (is_mt7628(dev))
+               return mt7603_dma_debug(dev, 9) & BIT(9);
+
+       return mt7603_dma_debug(dev, 2) & BIT(8);
+}
+
+static bool mt7603_rx_dma_busy(struct mt7603_dev *dev)
+{
+       if (!(mt76_rr(dev, MT_WPDMA_GLO_CFG) & MT_WPDMA_GLO_CFG_RX_DMA_BUSY))
+               return false;
+
+       return mt7603_rx_fifo_busy(dev);
+}
+
+static bool mt7603_tx_dma_busy(struct mt7603_dev *dev)
+{
+       u32 val;
+
+       if (!(mt76_rr(dev, MT_WPDMA_GLO_CFG) & MT_WPDMA_GLO_CFG_TX_DMA_BUSY))
+               return false;
+
+       val = mt7603_dma_debug(dev, 9);
+       return (val & BIT(8)) && (val & 0xf) != 0xf;
+}
+
+static bool mt7603_tx_hang(struct mt7603_dev *dev)
+{
+       struct mt76_queue *q;
+       u32 dma_idx, prev_dma_idx;
+       int i;
+
+       for (i = 0; i < 4; i++) {
+               q = &dev->mt76.q_tx[i];
+
+               if (!q->queued)
+                       continue;
+
+               prev_dma_idx = dev->tx_dma_idx[i];
+               dma_idx = ioread32(&q->regs->dma_idx);
+               dev->tx_dma_idx[i] = dma_idx;
+
+               if (dma_idx == prev_dma_idx &&
+                   dma_idx != ioread32(&q->regs->cpu_idx))
+                       break;
+       }
+
+       return i < 4;
+}
+
+static bool mt7603_rx_pse_busy(struct mt7603_dev *dev)
+{
+       u32 addr, val;
+
+       if (mt76_rr(dev, MT_MCU_DEBUG_RESET) & MT_MCU_DEBUG_RESET_QUEUES)
+               return true;
+
+       if (mt7603_rx_fifo_busy(dev))
+               return false;
+
+       addr = mt7603_reg_map(dev, MT_CLIENT_BASE_PHYS_ADDR + MT_CLIENT_STATUS);
+       mt76_wr(dev, addr, 3);
+       val = mt76_rr(dev, addr) >> 16;
+
+       if (is_mt7628(dev) && (val & 0x4001) == 0x4001)
+               return true;
+
+       return (val & 0x8001) == 0x8001 || (val & 0xe001) == 0xe001;
+}
+
+static bool
+mt7603_watchdog_check(struct mt7603_dev *dev, u8 *counter,
+                     enum mt7603_reset_cause cause,
+                     bool (*check)(struct mt7603_dev *dev))
+{
+       if (dev->reset_test == cause + 1) {
+               dev->reset_test = 0;
+               goto trigger;
[… more lines in the raw message]

Lines of this file are not shown. View the raw message.

drivers/net/wireless/mediatek/mt76/mt7603/mac.h new file +257 -0
new file mode 100644
index 000000000000..1704e6f932a3

Lines of this file are not shown. View the raw message.

drivers/net/wireless/mediatek/mt76/mt7603/main.c new file +730 -0
new file mode 100644
index 000000000000..74ccd6edbb9f

Lines of this file are not shown. View the raw message.

drivers/net/wireless/mediatek/mt76/mt7603/mcu.c new file +536 -0
new file mode 100644
index 000000000000..bd5b60ac7a24

Lines of this file are not shown. View the raw message.

drivers/net/wireless/mediatek/mt76/mt7603/mcu.h new file +118 -0
new file mode 100644
index 000000000000..3cdb4e6e0c9d

Lines of this file are not shown. View the raw message.

drivers/net/wireless/mediatek/mt76/mt7603/mt7603.h new file +271 -0
new file mode 100644
index 000000000000..8b9297d0ec89

Lines of this file are not shown. View the raw message.

drivers/net/wireless/mediatek/mt76/mt7603/pci.c new file +92 -0
new file mode 100644
index 000000000000..cc740bcf1e07

Lines of this file are not shown. View the raw message.

drivers/net/wireless/mediatek/mt76/mt7603/regs.h new file +789 -0
new file mode 100644
index 000000000000..5d61e222f227

Lines of this file are not shown. View the raw message.

drivers/net/wireless/mediatek/mt76/mt7603/soc.c new file +97 -1
new file mode 100644
index 000000000000..5d19b4e7edc6

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

2.17.0

Signature · 3 lines
UNIX is Sexy: who | grep -i blonde | talk; cd ~; wine; talk; touch;
unzip; touch; strip; gasp; finger; gasp; mount; fsck; more; yes; gasp;
umount; make clean; sleep

Part of the diff is not shown here. View the raw message.

#7 lore raw

Re: [PATCH 3/3] mt76: add driver for MT7603E and MT7628/7688

In reply to Felix Fietkau
Quoted 8 lines · Felix Fietkau

This driver is for a newer generation of 2x2 MediaTek 802.11n chipsets. MT7603E is a PCIe chip.
MT7628 and MT7688 are MIPS SoC devices with built-in WLAN. MT7688 is limited to 1x1

This driver fully supports AP, station, mesh, ad-hoc and monitor mode.

[...]

Quoted 9 lines
drivers/net/wireless/mediatek/mt76/mt7603/beacon.c new file +6 -0
@@ -0,0 +1,201 @@
+/* SPDX-License-Identifier: ISC */
+/*
+ * Copyright (C) 2016 Felix Fietkau <[email protected]>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above

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

Quoted 10 lines
drivers/net/wireless/mediatek/mt76/mt7603/beacon.c new file +10 -0
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */

If you have the SPDX tag I don't think you need to have the license text anymore. My understanding is that the SPDX identifier and copyright is enough.

This comment is for all files in this patch.

Signature · 1 line
Kalle Valo