diff --git a/package/kernel/mac80211/patches/rtl/001-wifi-rtw88-fix-race-condition-when-doing-H2C-command.patch b/package/kernel/mac80211/patches/rtl/001-wifi-rtw88-fix-race-condition-when-doing-H2C-command.patch new file mode 100644 index 0000000000..2c7cdf8523 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/001-wifi-rtw88-fix-race-condition-when-doing-H2C-command.patch @@ -0,0 +1,73 @@ +From dee121b45dd1eef42b5da093bf1ebeb80a7955bb Mon Sep 17 00:00:00 2001 +From: Ji-Pin Jou +Date: Thu, 24 Nov 2022 14:44:42 +0800 +Subject: [PATCH 01/13] wifi: rtw88: fix race condition when doing H2C command + +For SDIO/USB interface, since the tranferring speed is slower than +that in PCIE, it may have race condition when the driver sets down +H2C command to the FW. + +In the function rtw_fw_send_h2c_command, before the patch, box_reg +is written first, then box_ex_reg is written. FW starts to work and +fetch the value of box_ex_reg, when the most significant byte of +box_reg(4 bytes) is written. Meanwhile, for SDIO/USB interface, +since the transferring speed is slow, the driver is still in writing +the new value of box_ex_reg through the bus, and FW may get the +wrong value of box_ex_reg at the moment. + +To prevent the above driver/FW racing situation, box_ex_reg is +written first then box_reg. Furthermore, it is written in 4 bytes at +a time, instead of written in one byte one by one. It can increase +the speed for SDIO/USB interface. + +Signed-off-by: Ji-Pin Jou +Signed-off-by: Ping-Ke Shih +Tested-by: Sascha Hauer +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20221124064442.28042-1-pkshih@realtek.com +--- + drivers/net/wireless/realtek/rtw88/fw.c | 8 +++----- + drivers/net/wireless/realtek/rtw88/fw.h | 5 +++++ + 2 files changed, 8 insertions(+), 5 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/fw.c ++++ b/drivers/net/wireless/realtek/rtw88/fw.c +@@ -311,10 +311,10 @@ EXPORT_SYMBOL(rtw_fw_c2h_cmd_isr); + static void rtw_fw_send_h2c_command(struct rtw_dev *rtwdev, + u8 *h2c) + { ++ struct rtw_h2c_cmd *h2c_cmd = (struct rtw_h2c_cmd *)h2c; + u8 box; + u8 box_state; + u32 box_reg, box_ex_reg; +- int idx; + int ret; + + rtw_dbg(rtwdev, RTW_DBG_FW, +@@ -356,10 +356,8 @@ static void rtw_fw_send_h2c_command(stru + goto out; + } + +- for (idx = 0; idx < 4; idx++) +- rtw_write8(rtwdev, box_reg + idx, h2c[idx]); +- for (idx = 0; idx < 4; idx++) +- rtw_write8(rtwdev, box_ex_reg + idx, h2c[idx + 4]); ++ rtw_write32(rtwdev, box_ex_reg, le32_to_cpu(h2c_cmd->msg_ext)); ++ rtw_write32(rtwdev, box_reg, le32_to_cpu(h2c_cmd->msg)); + + if (++rtwdev->h2c.last_box_num >= 4) + rtwdev->h2c.last_box_num = 0; +--- a/drivers/net/wireless/realtek/rtw88/fw.h ++++ b/drivers/net/wireless/realtek/rtw88/fw.h +@@ -81,6 +81,11 @@ struct rtw_c2h_adaptivity { + u8 option; + } __packed; + ++struct rtw_h2c_cmd { ++ __le32 msg; ++ __le32 msg_ext; ++} __packed; ++ + enum rtw_rsvd_packet_type { + RSVD_BEACON, + RSVD_DUMMY, diff --git a/package/kernel/mac80211/patches/rtl/002-wifi-rtw88-8821c-enable-BT-device-recovery-mechanism.patch b/package/kernel/mac80211/patches/rtl/002-wifi-rtw88-8821c-enable-BT-device-recovery-mechanism.patch new file mode 100644 index 0000000000..9149e989d5 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/002-wifi-rtw88-8821c-enable-BT-device-recovery-mechanism.patch @@ -0,0 +1,100 @@ +From 91759247856dc65b69f71812a0903f59680f9890 Mon Sep 17 00:00:00 2001 +From: Ping-Ke Shih +Date: Mon, 28 Nov 2022 15:56:53 +0800 +Subject: [PATCH 02/13] wifi: rtw88: 8821c: enable BT device recovery mechanism + +8821ce is a combo card, and BT is a USB device that could get card lost +during stress test, and need WiFi firmware to detect and recover it, so +driver sends a H2C to enable this mechanism. + +Signed-off-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20221128075653.5221-1-pkshih@realtek.com +--- + drivers/net/wireless/realtek/rtw88/fw.c | 10 ++++++++++ + drivers/net/wireless/realtek/rtw88/fw.h | 6 ++++++ + drivers/net/wireless/realtek/rtw88/mac.c | 18 +++++++++++++++++- + 3 files changed, 33 insertions(+), 1 deletion(-) + +--- a/drivers/net/wireless/realtek/rtw88/fw.c ++++ b/drivers/net/wireless/realtek/rtw88/fw.c +@@ -822,6 +822,16 @@ void rtw_fw_set_nlo_info(struct rtw_dev + rtw_fw_send_h2c_command(rtwdev, h2c_pkt); + } + ++void rtw_fw_set_recover_bt_device(struct rtw_dev *rtwdev) ++{ ++ u8 h2c_pkt[H2C_PKT_SIZE] = {0}; ++ ++ SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_RECOVER_BT_DEV); ++ SET_RECOVER_BT_DEV_EN(h2c_pkt, 1); ++ ++ rtw_fw_send_h2c_command(rtwdev, h2c_pkt); ++} ++ + void rtw_fw_set_pg_info(struct rtw_dev *rtwdev) + { + struct rtw_lps_conf *conf = &rtwdev->lps_conf; +--- a/drivers/net/wireless/realtek/rtw88/fw.h ++++ b/drivers/net/wireless/realtek/rtw88/fw.h +@@ -555,6 +555,8 @@ static inline void rtw_h2c_pkt_set_heade + #define H2C_CMD_AOAC_GLOBAL_INFO 0x82 + #define H2C_CMD_NLO_INFO 0x8C + ++#define H2C_CMD_RECOVER_BT_DEV 0xD1 ++ + #define SET_H2C_CMD_ID_CLASS(h2c_pkt, value) \ + le32p_replace_bits((__le32 *)(h2c_pkt) + 0x00, value, GENMASK(7, 0)) + +@@ -754,6 +756,9 @@ static inline void rtw_h2c_pkt_set_heade + #define SET_NLO_LOC_NLO_INFO(h2c_pkt, value) \ + le32p_replace_bits((__le32 *)(h2c_pkt) + 0x00, value, GENMASK(23, 16)) + ++#define SET_RECOVER_BT_DEV_EN(h2c_pkt, value) \ ++ le32p_replace_bits((__le32 *)(h2c_pkt) + 0x00, value, BIT(8)) ++ + #define GET_FW_DUMP_LEN(_header) \ + le32_get_bits(*((__le32 *)(_header) + 0x00), GENMASK(15, 0)) + #define GET_FW_DUMP_SEQ(_header) \ +@@ -843,6 +848,7 @@ void rtw_fw_set_aoac_global_info_cmd(str + u8 group_key_enc); + + void rtw_fw_set_nlo_info(struct rtw_dev *rtwdev, bool enable); ++void rtw_fw_set_recover_bt_device(struct rtw_dev *rtwdev); + void rtw_fw_update_pkt_probe_req(struct rtw_dev *rtwdev, + struct cfg80211_ssid *ssid); + void rtw_fw_channel_switch(struct rtw_dev *rtwdev, bool enable); +--- a/drivers/net/wireless/realtek/rtw88/mac.c ++++ b/drivers/net/wireless/realtek/rtw88/mac.c +@@ -916,7 +916,8 @@ out: + return ret; + } + +-int rtw_download_firmware(struct rtw_dev *rtwdev, struct rtw_fw_state *fw) ++static ++int _rtw_download_firmware(struct rtw_dev *rtwdev, struct rtw_fw_state *fw) + { + if (rtw_chip_wcpu_11n(rtwdev)) + return __rtw_download_firmware_legacy(rtwdev, fw); +@@ -924,6 +925,21 @@ int rtw_download_firmware(struct rtw_dev + return __rtw_download_firmware(rtwdev, fw); + } + ++int rtw_download_firmware(struct rtw_dev *rtwdev, struct rtw_fw_state *fw) ++{ ++ int ret; ++ ++ ret = _rtw_download_firmware(rtwdev, fw); ++ if (ret) ++ return ret; ++ ++ if (rtw_hci_type(rtwdev) == RTW_HCI_TYPE_PCIE && ++ rtwdev->chip->id == RTW_CHIP_TYPE_8821C) ++ rtw_fw_set_recover_bt_device(rtwdev); ++ ++ return 0; ++} ++ + static u32 get_priority_queues(struct rtw_dev *rtwdev, u32 queues) + { + const struct rtw_rqpn *rqpn = rtwdev->fifo.rqpn; diff --git a/package/kernel/mac80211/patches/rtl/003-wifi-rtw88-print-firmware-type-in-info-message.patch b/package/kernel/mac80211/patches/rtl/003-wifi-rtw88-print-firmware-type-in-info-message.patch new file mode 100644 index 0000000000..2bc94f3536 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/003-wifi-rtw88-print-firmware-type-in-info-message.patch @@ -0,0 +1,56 @@ +From a02233a1346132efe6dda33237a0b07771fbb09b Mon Sep 17 00:00:00 2001 +From: Sascha Hauer +Date: Fri, 2 Dec 2022 09:12:14 +0100 +Subject: [PATCH 03/13] wifi: rtw88: print firmware type in info message + +It's confusing to read two different firmware versions in the syslog +for the same device: + +rtw_8822cu 2-1:1.2: Firmware version 9.9.4, H2C version 15 +rtw_8822cu 2-1:1.2: Firmware version 9.9.11, H2C version 15 + +Print the firmware type in this message to make clear these are really +two different firmwares for different purposes: + +rtw_8822cu 1-1.4:1.2: WOW Firmware version 9.9.4, H2C version 15 +rtw_8822cu 1-1.4:1.2: Firmware version 9.9.11, H2C version 15 + +Signed-off-by: Sascha Hauer +Reviewed-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20221202081224.2779981-2-s.hauer@pengutronix.de +--- + drivers/net/wireless/realtek/rtw88/main.c | 4 +++- + drivers/net/wireless/realtek/rtw88/main.h | 1 + + 2 files changed, 4 insertions(+), 1 deletion(-) + +--- a/drivers/net/wireless/realtek/rtw88/main.c ++++ b/drivers/net/wireless/realtek/rtw88/main.c +@@ -1731,7 +1731,8 @@ static void rtw_load_firmware_cb(const s + update_firmware_info(rtwdev, fw); + complete_all(&fw->completion); + +- rtw_info(rtwdev, "Firmware version %u.%u.%u, H2C version %u\n", ++ rtw_info(rtwdev, "%sFirmware version %u.%u.%u, H2C version %u\n", ++ fw->type == RTW_WOWLAN_FW ? "WOW " : "", + fw->version, fw->sub_version, fw->sub_index, fw->h2c_version); + } + +@@ -1757,6 +1758,7 @@ static int rtw_load_firmware(struct rtw_ + return -ENOENT; + } + ++ fw->type = type; + fw->rtwdev = rtwdev; + init_completion(&fw->completion); + +--- a/drivers/net/wireless/realtek/rtw88/main.h ++++ b/drivers/net/wireless/realtek/rtw88/main.h +@@ -1851,6 +1851,7 @@ struct rtw_fw_state { + u16 h2c_version; + u32 feature; + u32 feature_ext; ++ enum rtw_fw_type type; + }; + + enum rtw_sar_sources { diff --git a/package/kernel/mac80211/patches/rtl/004-wifi-rtw88-Call-rtw_fw_beacon_filter_config-with-rtw.patch b/package/kernel/mac80211/patches/rtl/004-wifi-rtw88-Call-rtw_fw_beacon_filter_config-with-rtw.patch new file mode 100644 index 0000000000..cb78356f74 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/004-wifi-rtw88-Call-rtw_fw_beacon_filter_config-with-rtw.patch @@ -0,0 +1,30 @@ +From ca6f02262c480ed49c5c6e41a0634c75b9a47dca Mon Sep 17 00:00:00 2001 +From: Sascha Hauer +Date: Fri, 2 Dec 2022 09:12:15 +0100 +Subject: [PATCH 04/13] wifi: rtw88: Call rtw_fw_beacon_filter_config() with + rtwdev->mutex held + +rtw_fw_beacon_filter_config() is called once with rtwdev->mutex held +and once without the mutex held. Call it consistently with rtwdev->mutex +held. + +Signed-off-by: Sascha Hauer +Reviewed-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20221202081224.2779981-3-s.hauer@pengutronix.de +--- + drivers/net/wireless/realtek/rtw88/mac80211.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +--- a/drivers/net/wireless/realtek/rtw88/mac80211.c ++++ b/drivers/net/wireless/realtek/rtw88/mac80211.c +@@ -487,8 +487,8 @@ static int rtw_ops_sta_remove(struct iee + { + struct rtw_dev *rtwdev = hw->priv; + +- rtw_fw_beacon_filter_config(rtwdev, false, vif); + mutex_lock(&rtwdev->mutex); ++ rtw_fw_beacon_filter_config(rtwdev, false, vif); + rtw_sta_remove(rtwdev, sta, true); + mutex_unlock(&rtwdev->mutex); + diff --git a/package/kernel/mac80211/patches/rtl/005-wifi-rtw88-Drop-rf_lock.patch b/package/kernel/mac80211/patches/rtl/005-wifi-rtw88-Drop-rf_lock.patch new file mode 100644 index 0000000000..2c0ffd8f2b --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/005-wifi-rtw88-Drop-rf_lock.patch @@ -0,0 +1,132 @@ +From 293a0c7587a4dbfa700e23bc93f80dd2ad40ed59 Mon Sep 17 00:00:00 2001 +From: Sascha Hauer +Date: Fri, 2 Dec 2022 09:12:16 +0100 +Subject: [PATCH 05/13] wifi: rtw88: Drop rf_lock + +The rtwdev->rf_lock spinlock protects the rf register accesses in +rtw_read_rf() and rtw_write_rf(). Most callers of these functions hold +rtwdev->mutex already with the exception of the callsites in the debugfs +code. The debugfs code doesn't justify an extra lock, so acquire the mutex +there as well before calling rf register accessors and drop the now +unnecessary spinlock. + +Signed-off-by: Sascha Hauer +Reviewed-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20221202081224.2779981-4-s.hauer@pengutronix.de +--- + drivers/net/wireless/realtek/rtw88/debug.c | 11 +++++++++++ + drivers/net/wireless/realtek/rtw88/hci.h | 9 +++------ + drivers/net/wireless/realtek/rtw88/main.c | 1 - + drivers/net/wireless/realtek/rtw88/main.h | 3 --- + 4 files changed, 14 insertions(+), 10 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/debug.c ++++ b/drivers/net/wireless/realtek/rtw88/debug.c +@@ -144,7 +144,9 @@ static int rtw_debugfs_get_rf_read(struc + addr = debugfs_priv->rf_addr; + mask = debugfs_priv->rf_mask; + ++ mutex_lock(&rtwdev->mutex); + val = rtw_read_rf(rtwdev, path, addr, mask); ++ mutex_unlock(&rtwdev->mutex); + + seq_printf(m, "rf_read path:%d addr:0x%08x mask:0x%08x val=0x%08x\n", + path, addr, mask, val); +@@ -414,7 +416,9 @@ static ssize_t rtw_debugfs_set_rf_write( + return count; + } + ++ mutex_lock(&rtwdev->mutex); + rtw_write_rf(rtwdev, path, addr, mask, val); ++ mutex_unlock(&rtwdev->mutex); + rtw_dbg(rtwdev, RTW_DBG_DEBUGFS, + "write_rf path:%d addr:0x%08x mask:0x%08x, val:0x%08x\n", + path, addr, mask, val); +@@ -519,6 +523,8 @@ static int rtw_debug_get_rf_dump(struct + u32 addr, offset, data; + u8 path; + ++ mutex_lock(&rtwdev->mutex); ++ + for (path = 0; path < rtwdev->hal.rf_path_num; path++) { + seq_printf(m, "RF path:%d\n", path); + for (addr = 0; addr < 0x100; addr += 4) { +@@ -533,6 +539,8 @@ static int rtw_debug_get_rf_dump(struct + seq_puts(m, "\n"); + } + ++ mutex_unlock(&rtwdev->mutex); ++ + return 0; + } + +@@ -1026,6 +1034,8 @@ static void dump_gapk_status(struct rtw_ + dm_info->dm_flags & BIT(RTW_DM_CAP_TXGAPK) ? '-' : '+', + rtw_dm_cap_strs[RTW_DM_CAP_TXGAPK]); + ++ mutex_lock(&rtwdev->mutex); ++ + for (path = 0; path < rtwdev->hal.rf_path_num; path++) { + val = rtw_read_rf(rtwdev, path, RF_GAINTX, RFREG_MASK); + seq_printf(m, "path %d:\n0x%x = 0x%x\n", path, RF_GAINTX, val); +@@ -1035,6 +1045,7 @@ static void dump_gapk_status(struct rtw_ + txgapk->rf3f_fs[path][i], i); + seq_puts(m, "\n"); + } ++ mutex_unlock(&rtwdev->mutex); + } + + static int rtw_debugfs_get_dm_cap(struct seq_file *m, void *v) +--- a/drivers/net/wireless/realtek/rtw88/hci.h ++++ b/drivers/net/wireless/realtek/rtw88/hci.h +@@ -166,12 +166,11 @@ static inline u32 + rtw_read_rf(struct rtw_dev *rtwdev, enum rtw_rf_path rf_path, + u32 addr, u32 mask) + { +- unsigned long flags; + u32 val; + +- spin_lock_irqsave(&rtwdev->rf_lock, flags); ++ lockdep_assert_held(&rtwdev->mutex); ++ + val = rtwdev->chip->ops->read_rf(rtwdev, rf_path, addr, mask); +- spin_unlock_irqrestore(&rtwdev->rf_lock, flags); + + return val; + } +@@ -180,11 +179,9 @@ static inline void + rtw_write_rf(struct rtw_dev *rtwdev, enum rtw_rf_path rf_path, + u32 addr, u32 mask, u32 data) + { +- unsigned long flags; ++ lockdep_assert_held(&rtwdev->mutex); + +- spin_lock_irqsave(&rtwdev->rf_lock, flags); + rtwdev->chip->ops->write_rf(rtwdev, rf_path, addr, mask, data); +- spin_unlock_irqrestore(&rtwdev->rf_lock, flags); + } + + static inline u32 +--- a/drivers/net/wireless/realtek/rtw88/main.c ++++ b/drivers/net/wireless/realtek/rtw88/main.c +@@ -2067,7 +2067,6 @@ int rtw_core_init(struct rtw_dev *rtwdev + skb_queue_head_init(&rtwdev->coex.queue); + skb_queue_head_init(&rtwdev->tx_report.queue); + +- spin_lock_init(&rtwdev->rf_lock); + spin_lock_init(&rtwdev->h2c.lock); + spin_lock_init(&rtwdev->txq_lock); + spin_lock_init(&rtwdev->tx_report.q_lock); +--- a/drivers/net/wireless/realtek/rtw88/main.h ++++ b/drivers/net/wireless/realtek/rtw88/main.h +@@ -1995,9 +1995,6 @@ struct rtw_dev { + /* ensures exclusive access from mac80211 callbacks */ + struct mutex mutex; + +- /* read/write rf register */ +- spinlock_t rf_lock; +- + /* watch dog every 2 sec */ + struct delayed_work watch_dog_work; + u32 watch_dog_cnt; diff --git a/package/kernel/mac80211/patches/rtl/006-wifi-rtw88-Drop-h2c.lock.patch b/package/kernel/mac80211/patches/rtl/006-wifi-rtw88-Drop-h2c.lock.patch new file mode 100644 index 0000000000..9363596c09 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/006-wifi-rtw88-Drop-h2c.lock.patch @@ -0,0 +1,110 @@ +From 0c42222e7ba7fc209474ade5f8e082360ba17d13 Mon Sep 17 00:00:00 2001 +From: Sascha Hauer +Date: Fri, 2 Dec 2022 09:12:17 +0100 +Subject: [PATCH 06/13] wifi: rtw88: Drop h2c.lock + +The h2c.lock spinlock is used in rtw_fw_send_h2c_command() and +rtw_fw_send_h2c_packet(). Most callers call this with rtwdev->mutex +held, except from one callsite in the debugfs code. The debugfs code +alone doesn't justify the extra lock, so acquire rtwdev->mutex in +debugfs and drop the now unnecessary spinlock. + +Signed-off-by: Sascha Hauer +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20221202081224.2779981-5-s.hauer@pengutronix.de +--- + drivers/net/wireless/realtek/rtw88/debug.c | 2 ++ + drivers/net/wireless/realtek/rtw88/fw.c | 13 ++++--------- + drivers/net/wireless/realtek/rtw88/main.c | 1 - + drivers/net/wireless/realtek/rtw88/main.h | 2 -- + 4 files changed, 6 insertions(+), 12 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/debug.c ++++ b/drivers/net/wireless/realtek/rtw88/debug.c +@@ -392,7 +392,9 @@ static ssize_t rtw_debugfs_set_h2c(struc + return -EINVAL; + } + ++ mutex_lock(&rtwdev->mutex); + rtw_fw_h2c_cmd_dbg(rtwdev, param); ++ mutex_unlock(&rtwdev->mutex); + + return count; + } +--- a/drivers/net/wireless/realtek/rtw88/fw.c ++++ b/drivers/net/wireless/realtek/rtw88/fw.c +@@ -322,7 +322,7 @@ static void rtw_fw_send_h2c_command(stru + h2c[3], h2c[2], h2c[1], h2c[0], + h2c[7], h2c[6], h2c[5], h2c[4]); + +- spin_lock(&rtwdev->h2c.lock); ++ lockdep_assert_held(&rtwdev->mutex); + + box = rtwdev->h2c.last_box_num; + switch (box) { +@@ -344,7 +344,7 @@ static void rtw_fw_send_h2c_command(stru + break; + default: + WARN(1, "invalid h2c mail box number\n"); +- goto out; ++ return; + } + + ret = read_poll_timeout_atomic(rtw_read8, box_state, +@@ -353,7 +353,7 @@ static void rtw_fw_send_h2c_command(stru + + if (ret) { + rtw_err(rtwdev, "failed to send h2c command\n"); +- goto out; ++ return; + } + + rtw_write32(rtwdev, box_ex_reg, le32_to_cpu(h2c_cmd->msg_ext)); +@@ -361,9 +361,6 @@ static void rtw_fw_send_h2c_command(stru + + if (++rtwdev->h2c.last_box_num >= 4) + rtwdev->h2c.last_box_num = 0; +- +-out: +- spin_unlock(&rtwdev->h2c.lock); + } + + void rtw_fw_h2c_cmd_dbg(struct rtw_dev *rtwdev, u8 *h2c) +@@ -375,15 +372,13 @@ static void rtw_fw_send_h2c_packet(struc + { + int ret; + +- spin_lock(&rtwdev->h2c.lock); ++ lockdep_assert_held(&rtwdev->mutex); + + FW_OFFLOAD_H2C_SET_SEQ_NUM(h2c_pkt, rtwdev->h2c.seq); + ret = rtw_hci_write_data_h2c(rtwdev, h2c_pkt, H2C_PKT_SIZE); + if (ret) + rtw_err(rtwdev, "failed to send h2c packet\n"); + rtwdev->h2c.seq++; +- +- spin_unlock(&rtwdev->h2c.lock); + } + + void +--- a/drivers/net/wireless/realtek/rtw88/main.c ++++ b/drivers/net/wireless/realtek/rtw88/main.c +@@ -2067,7 +2067,6 @@ int rtw_core_init(struct rtw_dev *rtwdev + skb_queue_head_init(&rtwdev->coex.queue); + skb_queue_head_init(&rtwdev->tx_report.queue); + +- spin_lock_init(&rtwdev->h2c.lock); + spin_lock_init(&rtwdev->txq_lock); + spin_lock_init(&rtwdev->tx_report.q_lock); + +--- a/drivers/net/wireless/realtek/rtw88/main.h ++++ b/drivers/net/wireless/realtek/rtw88/main.h +@@ -2020,8 +2020,6 @@ struct rtw_dev { + struct { + /* incicate the mail box to use with fw */ + u8 last_box_num; +- /* protect to send h2c to fw */ +- spinlock_t lock; + u32 seq; + } h2c; + diff --git a/package/kernel/mac80211/patches/rtl/007-wifi-rtw88-Drop-coex-mutex.patch b/package/kernel/mac80211/patches/rtl/007-wifi-rtw88-Drop-coex-mutex.patch new file mode 100644 index 0000000000..f2bdaaf20b --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/007-wifi-rtw88-Drop-coex-mutex.patch @@ -0,0 +1,81 @@ +From aa3b7995ddabf832581c542fc198d1f2e7afac28 Mon Sep 17 00:00:00 2001 +From: Sascha Hauer +Date: Fri, 2 Dec 2022 09:12:18 +0100 +Subject: [PATCH 07/13] wifi: rtw88: Drop coex mutex + +coex->mutex is used in rtw_coex_info_request() only. Most callers of this +function hold rtwdev->mutex already, except for one callsite in the +debugfs code. The debugfs code alone doesn't justify the extra lock, so +acquire rtwdev->mutex there as well and drop the now unnecessary +spinlock. + +Signed-off-by: Sascha Hauer +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20221202081224.2779981-6-s.hauer@pengutronix.de +--- + drivers/net/wireless/realtek/rtw88/coex.c | 3 +-- + drivers/net/wireless/realtek/rtw88/debug.c | 2 ++ + drivers/net/wireless/realtek/rtw88/main.c | 2 -- + drivers/net/wireless/realtek/rtw88/main.h | 2 -- + 4 files changed, 3 insertions(+), 6 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/coex.c ++++ b/drivers/net/wireless/realtek/rtw88/coex.c +@@ -633,7 +633,7 @@ static struct sk_buff *rtw_coex_info_req + struct rtw_coex *coex = &rtwdev->coex; + struct sk_buff *skb_resp = NULL; + +- mutex_lock(&coex->mutex); ++ lockdep_assert_held(&rtwdev->mutex); + + rtw_fw_query_bt_mp_info(rtwdev, req); + +@@ -650,7 +650,6 @@ static struct sk_buff *rtw_coex_info_req + } + + out: +- mutex_unlock(&coex->mutex); + return skb_resp; + } + +--- a/drivers/net/wireless/realtek/rtw88/debug.c ++++ b/drivers/net/wireless/realtek/rtw88/debug.c +@@ -841,7 +841,9 @@ static int rtw_debugfs_get_coex_info(str + struct rtw_debugfs_priv *debugfs_priv = m->private; + struct rtw_dev *rtwdev = debugfs_priv->rtwdev; + ++ mutex_lock(&rtwdev->mutex); + rtw_coex_display_coex_info(rtwdev, m); ++ mutex_unlock(&rtwdev->mutex); + + return 0; + } +--- a/drivers/net/wireless/realtek/rtw88/main.c ++++ b/drivers/net/wireless/realtek/rtw88/main.c +@@ -2071,7 +2071,6 @@ int rtw_core_init(struct rtw_dev *rtwdev + spin_lock_init(&rtwdev->tx_report.q_lock); + + mutex_init(&rtwdev->mutex); +- mutex_init(&rtwdev->coex.mutex); + mutex_init(&rtwdev->hal.tx_power_mutex); + + init_waitqueue_head(&rtwdev->coex.wait); +@@ -2143,7 +2142,6 @@ void rtw_core_deinit(struct rtw_dev *rtw + } + + mutex_destroy(&rtwdev->mutex); +- mutex_destroy(&rtwdev->coex.mutex); + mutex_destroy(&rtwdev->hal.tx_power_mutex); + } + EXPORT_SYMBOL(rtw_core_deinit); +--- a/drivers/net/wireless/realtek/rtw88/main.h ++++ b/drivers/net/wireless/realtek/rtw88/main.h +@@ -1501,8 +1501,6 @@ struct rtw_coex_stat { + }; + + struct rtw_coex { +- /* protects coex info request section */ +- struct mutex mutex; + struct sk_buff_head queue; + wait_queue_head_t wait; + diff --git a/package/kernel/mac80211/patches/rtl/008-wifi-rtw88-iterate-over-vif-sta-list-non-atomically.patch b/package/kernel/mac80211/patches/rtl/008-wifi-rtw88-iterate-over-vif-sta-list-non-atomically.patch new file mode 100644 index 0000000000..a55ce7614e --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/008-wifi-rtw88-iterate-over-vif-sta-list-non-atomically.patch @@ -0,0 +1,204 @@ +From 392cb1f93f3b5bf702ac3b6b110bb4e33df7ae32 Mon Sep 17 00:00:00 2001 +From: Sascha Hauer +Date: Fri, 2 Dec 2022 09:12:19 +0100 +Subject: [PATCH 08/13] wifi: rtw88: iterate over vif/sta list non-atomically + +The driver uses ieee80211_iterate_active_interfaces_atomic() +and ieee80211_iterate_stations_atomic() in several places and does +register accesses in the iterators. This doesn't cope with upcoming +USB support as registers can only be accessed non-atomically. + +Split these into a two stage process: First use the atomic iterator +functions to collect all active interfaces or stations on a list, then +iterate over the list non-atomically and call the iterator on each +entry. + +Signed-off-by: Sascha Hauer +Suggested-by: Ping-Ke shih +Reviewed-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20221202081224.2779981-7-s.hauer@pengutronix.de +--- + drivers/net/wireless/realtek/rtw88/phy.c | 6 +- + drivers/net/wireless/realtek/rtw88/ps.c | 2 +- + drivers/net/wireless/realtek/rtw88/util.c | 103 ++++++++++++++++++++++ + drivers/net/wireless/realtek/rtw88/util.h | 12 ++- + 4 files changed, 116 insertions(+), 7 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/phy.c ++++ b/drivers/net/wireless/realtek/rtw88/phy.c +@@ -300,7 +300,7 @@ static void rtw_phy_stat_rssi(struct rtw + + data.rtwdev = rtwdev; + data.min_rssi = U8_MAX; +- rtw_iterate_stas_atomic(rtwdev, rtw_phy_stat_rssi_iter, &data); ++ rtw_iterate_stas(rtwdev, rtw_phy_stat_rssi_iter, &data); + + dm_info->pre_min_rssi = dm_info->min_rssi; + dm_info->min_rssi = data.min_rssi; +@@ -544,7 +544,7 @@ static void rtw_phy_ra_info_update(struc + if (rtwdev->watch_dog_cnt & 0x3) + return; + +- rtw_iterate_stas_atomic(rtwdev, rtw_phy_ra_info_update_iter, rtwdev); ++ rtw_iterate_stas(rtwdev, rtw_phy_ra_info_update_iter, rtwdev); + } + + static u32 rtw_phy_get_rrsr_mask(struct rtw_dev *rtwdev, u8 rate_idx) +@@ -597,7 +597,7 @@ static void rtw_phy_rrsr_update(struct r + struct rtw_dm_info *dm_info = &rtwdev->dm_info; + + dm_info->rrsr_mask_min = RRSR_RATE_ORDER_MAX; +- rtw_iterate_stas_atomic(rtwdev, rtw_phy_rrsr_mask_min_iter, rtwdev); ++ rtw_iterate_stas(rtwdev, rtw_phy_rrsr_mask_min_iter, rtwdev); + rtw_write32(rtwdev, REG_RRSR, dm_info->rrsr_val_init & dm_info->rrsr_mask_min); + } + +--- a/drivers/net/wireless/realtek/rtw88/ps.c ++++ b/drivers/net/wireless/realtek/rtw88/ps.c +@@ -61,7 +61,7 @@ int rtw_leave_ips(struct rtw_dev *rtwdev + return ret; + } + +- rtw_iterate_vifs_atomic(rtwdev, rtw_restore_port_cfg_iter, rtwdev); ++ rtw_iterate_vifs(rtwdev, rtw_restore_port_cfg_iter, rtwdev); + + rtw_coex_ips_notify(rtwdev, COEX_IPS_LEAVE); + +--- a/drivers/net/wireless/realtek/rtw88/util.c ++++ b/drivers/net/wireless/realtek/rtw88/util.c +@@ -105,3 +105,106 @@ void rtw_desc_to_mcsrate(u16 rate, u8 *m + *mcs = rate - DESC_RATEMCS0; + } + } ++ ++struct rtw_stas_entry { ++ struct list_head list; ++ struct ieee80211_sta *sta; ++}; ++ ++struct rtw_iter_stas_data { ++ struct rtw_dev *rtwdev; ++ struct list_head list; ++}; ++ ++static void rtw_collect_sta_iter(void *data, struct ieee80211_sta *sta) ++{ ++ struct rtw_iter_stas_data *iter_stas = data; ++ struct rtw_stas_entry *stas_entry; ++ ++ stas_entry = kmalloc(sizeof(*stas_entry), GFP_ATOMIC); ++ if (!stas_entry) ++ return; ++ ++ stas_entry->sta = sta; ++ list_add_tail(&stas_entry->list, &iter_stas->list); ++} ++ ++void rtw_iterate_stas(struct rtw_dev *rtwdev, ++ void (*iterator)(void *data, ++ struct ieee80211_sta *sta), ++ void *data) ++{ ++ struct rtw_iter_stas_data iter_data; ++ struct rtw_stas_entry *sta_entry, *tmp; ++ ++ /* &rtwdev->mutex makes sure no stations can be removed between ++ * collecting the stations and iterating over them. ++ */ ++ lockdep_assert_held(&rtwdev->mutex); ++ ++ iter_data.rtwdev = rtwdev; ++ INIT_LIST_HEAD(&iter_data.list); ++ ++ ieee80211_iterate_stations_atomic(rtwdev->hw, rtw_collect_sta_iter, ++ &iter_data); ++ ++ list_for_each_entry_safe(sta_entry, tmp, &iter_data.list, ++ list) { ++ list_del_init(&sta_entry->list); ++ iterator(data, sta_entry->sta); ++ kfree(sta_entry); ++ } ++} ++ ++struct rtw_vifs_entry { ++ struct list_head list; ++ struct ieee80211_vif *vif; ++ u8 mac[ETH_ALEN]; ++}; ++ ++struct rtw_iter_vifs_data { ++ struct rtw_dev *rtwdev; ++ struct list_head list; ++}; ++ ++static void rtw_collect_vif_iter(void *data, u8 *mac, struct ieee80211_vif *vif) ++{ ++ struct rtw_iter_vifs_data *iter_stas = data; ++ struct rtw_vifs_entry *vifs_entry; ++ ++ vifs_entry = kmalloc(sizeof(*vifs_entry), GFP_ATOMIC); ++ if (!vifs_entry) ++ return; ++ ++ vifs_entry->vif = vif; ++ ether_addr_copy(vifs_entry->mac, mac); ++ list_add_tail(&vifs_entry->list, &iter_stas->list); ++} ++ ++void rtw_iterate_vifs(struct rtw_dev *rtwdev, ++ void (*iterator)(void *data, u8 *mac, ++ struct ieee80211_vif *vif), ++ void *data) ++{ ++ struct rtw_iter_vifs_data iter_data; ++ struct rtw_vifs_entry *vif_entry, *tmp; ++ ++ /* &rtwdev->mutex makes sure no interfaces can be removed between ++ * collecting the interfaces and iterating over them. ++ */ ++ lockdep_assert_held(&rtwdev->mutex); ++ ++ iter_data.rtwdev = rtwdev; ++ INIT_LIST_HEAD(&iter_data.list); ++ ++ ieee80211_iterate_active_interfaces_atomic(rtwdev->hw, ++ IEEE80211_IFACE_ITER_NORMAL, ++ rtw_collect_vif_iter, &iter_data); ++ ++ list_for_each_entry_safe(vif_entry, tmp, &iter_data.list, ++ list) { ++ list_del_init(&vif_entry->list); ++ iterator(data, vif_entry->mac, vif_entry->vif); ++ kfree(vif_entry); ++ } ++} +--- a/drivers/net/wireless/realtek/rtw88/util.h ++++ b/drivers/net/wireless/realtek/rtw88/util.h +@@ -7,9 +7,6 @@ + + struct rtw_dev; + +-#define rtw_iterate_vifs(rtwdev, iterator, data) \ +- ieee80211_iterate_active_interfaces(rtwdev->hw, \ +- IEEE80211_IFACE_ITER_NORMAL, iterator, data) + #define rtw_iterate_vifs_atomic(rtwdev, iterator, data) \ + ieee80211_iterate_active_interfaces_atomic(rtwdev->hw, \ + IEEE80211_IFACE_ITER_NORMAL, iterator, data) +@@ -20,6 +17,15 @@ struct rtw_dev; + #define rtw_iterate_keys_rcu(rtwdev, vif, iterator, data) \ + ieee80211_iter_keys_rcu((rtwdev)->hw, vif, iterator, data) + ++void rtw_iterate_vifs(struct rtw_dev *rtwdev, ++ void (*iterator)(void *data, u8 *mac, ++ struct ieee80211_vif *vif), ++ void *data); ++void rtw_iterate_stas(struct rtw_dev *rtwdev, ++ void (*iterator)(void *data, ++ struct ieee80211_sta *sta), ++ void *data); ++ + static inline u8 *get_hdr_bssid(struct ieee80211_hdr *hdr) + { + __le16 fc = hdr->frame_control; diff --git a/package/kernel/mac80211/patches/rtl/009-wifi-rtw88-Add-common-USB-chip-support.patch b/package/kernel/mac80211/patches/rtl/009-wifi-rtw88-Add-common-USB-chip-support.patch new file mode 100644 index 0000000000..0f59424827 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/009-wifi-rtw88-Add-common-USB-chip-support.patch @@ -0,0 +1,1155 @@ +From 173bc31bc0189616c8b09edbbd919493632070ed Mon Sep 17 00:00:00 2001 +From: Sascha Hauer +Date: Fri, 2 Dec 2022 09:12:20 +0100 +Subject: [PATCH 09/13] wifi: rtw88: Add common USB chip support + +Add the common bits and pieces to add USB support to the RTW88 driver. +This is based on https://github.com/ulli-kroll/rtw88-usb.git which +itself is first written by Neo Jou. + +Signed-off-by: neo_jou +Signed-off-by: Hans Ulli Kroll +Signed-off-by: Sascha Hauer +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20221202081224.2779981-8-s.hauer@pengutronix.de +--- + drivers/net/wireless/realtek/rtw88/Kconfig | 4 + + drivers/net/wireless/realtek/rtw88/Makefile | 3 + + drivers/net/wireless/realtek/rtw88/mac.c | 3 + + drivers/net/wireless/realtek/rtw88/main.c | 4 + + drivers/net/wireless/realtek/rtw88/main.h | 4 + + drivers/net/wireless/realtek/rtw88/reg.h | 1 + + drivers/net/wireless/realtek/rtw88/tx.h | 31 + + drivers/net/wireless/realtek/rtw88/usb.c | 911 ++++++++++++++++++++ + drivers/net/wireless/realtek/rtw88/usb.h | 107 +++ + 9 files changed, 1068 insertions(+) + create mode 100644 drivers/net/wireless/realtek/rtw88/usb.c + create mode 100644 drivers/net/wireless/realtek/rtw88/usb.h + +--- a/drivers/net/wireless/realtek/rtw88/Kconfig ++++ b/drivers/net/wireless/realtek/rtw88/Kconfig +@@ -19,6 +19,10 @@ config RTW88_PCI + tristate + depends on m + ++config RTW88_USB ++ tristate ++ depends on m ++ + config RTW88_8822B + tristate + depends on m +--- a/drivers/net/wireless/realtek/rtw88/Makefile ++++ b/drivers/net/wireless/realtek/rtw88/Makefile +@@ -46,3 +46,6 @@ rtw88_8821ce-objs := rtw8821ce.o + + obj-$(CPTCFG_RTW88_PCI) += rtw88_pci.o + rtw88_pci-objs := pci.o ++ ++obj-$(CPTCFG_RTW88_USB) += rtw88_usb.o ++rtw88_usb-objs := usb.o +--- a/drivers/net/wireless/realtek/rtw88/mac.c ++++ b/drivers/net/wireless/realtek/rtw88/mac.c +@@ -1058,6 +1058,9 @@ static int txdma_queue_mapping(struct rt + if (rtw_chip_wcpu_11ac(rtwdev)) + rtw_write32(rtwdev, REG_H2CQ_CSR, BIT_H2CQ_FULL); + ++ if (rtw_hci_type(rtwdev) == RTW_HCI_TYPE_USB) ++ rtw_write8_set(rtwdev, REG_TXDMA_PQ_MAP, BIT_RXDMA_ARBBW_EN); ++ + return 0; + } + +--- a/drivers/net/wireless/realtek/rtw88/main.c ++++ b/drivers/net/wireless/realtek/rtw88/main.c +@@ -1783,6 +1783,10 @@ static int rtw_chip_parameter_setup(stru + rtwdev->hci.rpwm_addr = 0x03d9; + rtwdev->hci.cpwm_addr = 0x03da; + break; ++ case RTW_HCI_TYPE_USB: ++ rtwdev->hci.rpwm_addr = 0xfe58; ++ rtwdev->hci.cpwm_addr = 0xfe57; ++ break; + default: + rtw_err(rtwdev, "unsupported hci type\n"); + return -EINVAL; +--- a/drivers/net/wireless/realtek/rtw88/main.h ++++ b/drivers/net/wireless/realtek/rtw88/main.h +@@ -871,6 +871,10 @@ struct rtw_chip_ops { + bool is_tx2_path); + void (*config_txrx_mode)(struct rtw_dev *rtwdev, u8 tx_path, + u8 rx_path, bool is_tx2_path); ++ /* for USB/SDIO only */ ++ void (*fill_txdesc_checksum)(struct rtw_dev *rtwdev, ++ struct rtw_tx_pkt_info *pkt_info, ++ u8 *txdesc); + + /* for coex */ + void (*coex_set_init)(struct rtw_dev *rtwdev); +--- a/drivers/net/wireless/realtek/rtw88/reg.h ++++ b/drivers/net/wireless/realtek/rtw88/reg.h +@@ -184,6 +184,7 @@ + #define BIT_TXDMA_VIQ_MAP(x) \ + (((x) & BIT_MASK_TXDMA_VIQ_MAP) << BIT_SHIFT_TXDMA_VIQ_MAP) + #define REG_TXDMA_PQ_MAP 0x010C ++#define BIT_RXDMA_ARBBW_EN BIT(0) + #define BIT_SHIFT_TXDMA_BEQ_MAP 8 + #define BIT_MASK_TXDMA_BEQ_MAP 0x3 + #define BIT_TXDMA_BEQ_MAP(x) \ +--- a/drivers/net/wireless/realtek/rtw88/tx.h ++++ b/drivers/net/wireless/realtek/rtw88/tx.h +@@ -71,6 +71,14 @@ + le32p_replace_bits((__le32 *)(txdesc) + 0x03, value, BIT(15)) + #define SET_TX_DESC_BT_NULL(txdesc, value) \ + le32p_replace_bits((__le32 *)(txdesc) + 0x02, value, BIT(23)) ++#define SET_TX_DESC_TXDESC_CHECKSUM(txdesc, value) \ ++ le32p_replace_bits((__le32 *)(txdesc) + 0x07, value, GENMASK(15, 0)) ++#define SET_TX_DESC_DMA_TXAGG_NUM(txdesc, value) \ ++ le32p_replace_bits((__le32 *)(txdesc) + 0x07, value, GENMASK(31, 24)) ++#define GET_TX_DESC_PKT_OFFSET(txdesc) \ ++ le32_get_bits(*((__le32 *)(txdesc) + 0x01), GENMASK(28, 24)) ++#define GET_TX_DESC_QSEL(txdesc) \ ++ le32_get_bits(*((__le32 *)(txdesc) + 0x01), GENMASK(12, 8)) + + enum rtw_tx_desc_queue_select { + TX_DESC_QSEL_TID0 = 0, +@@ -123,4 +131,27 @@ rtw_tx_write_data_h2c_get(struct rtw_dev + struct rtw_tx_pkt_info *pkt_info, + u8 *buf, u32 size); + ++static inline ++void fill_txdesc_checksum_common(u8 *txdesc, size_t words) ++{ ++ __le16 chksum = 0; ++ __le16 *data = (__le16 *)(txdesc); ++ ++ SET_TX_DESC_TXDESC_CHECKSUM(txdesc, 0x0000); ++ ++ while (words--) ++ chksum ^= *data++; ++ ++ SET_TX_DESC_TXDESC_CHECKSUM(txdesc, __le16_to_cpu(chksum)); ++} ++ ++static inline void rtw_tx_fill_txdesc_checksum(struct rtw_dev *rtwdev, ++ struct rtw_tx_pkt_info *pkt_info, ++ u8 *txdesc) ++{ ++ const struct rtw_chip_info *chip = rtwdev->chip; ++ ++ chip->ops->fill_txdesc_checksum(rtwdev, pkt_info, txdesc); ++} ++ + #endif +--- /dev/null ++++ b/drivers/net/wireless/realtek/rtw88/usb.c +@@ -0,0 +1,899 @@ ++// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause ++/* Copyright(c) 2018-2019 Realtek Corporation ++ */ ++ ++#include ++#include ++#include ++#include "main.h" ++#include "debug.h" ++#include "reg.h" ++#include "tx.h" ++#include "rx.h" ++#include "fw.h" ++#include "ps.h" ++#include "usb.h" ++ ++#define RTW_USB_MAX_RXQ_LEN 512 ++ ++struct rtw_usb_txcb { ++ struct rtw_dev *rtwdev; ++ struct sk_buff_head tx_ack_queue; ++}; ++ ++static void rtw_usb_fill_tx_checksum(struct rtw_usb *rtwusb, ++ struct sk_buff *skb, int agg_num) ++{ ++ struct rtw_dev *rtwdev = rtwusb->rtwdev; ++ struct rtw_tx_pkt_info pkt_info; ++ ++ SET_TX_DESC_DMA_TXAGG_NUM(skb->data, agg_num); ++ pkt_info.pkt_offset = GET_TX_DESC_PKT_OFFSET(skb->data); ++ rtw_tx_fill_txdesc_checksum(rtwdev, &pkt_info, skb->data); ++} ++ ++static u32 rtw_usb_read(struct rtw_dev *rtwdev, u32 addr, u16 len) ++{ ++ struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); ++ struct usb_device *udev = rtwusb->udev; ++ __le32 *data; ++ unsigned long flags; ++ int idx, ret; ++ static int count; ++ ++ spin_lock_irqsave(&rtwusb->usb_lock, flags); ++ ++ idx = rtwusb->usb_data_index; ++ rtwusb->usb_data_index = (idx + 1) & (RTW_USB_MAX_RXTX_COUNT - 1); ++ ++ spin_unlock_irqrestore(&rtwusb->usb_lock, flags); ++ ++ data = &rtwusb->usb_data[idx]; ++ ++ ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), ++ RTW_USB_CMD_REQ, RTW_USB_CMD_READ, addr, ++ RTW_USB_VENQT_CMD_IDX, data, len, 1000); ++ if (ret < 0 && ret != -ENODEV && count++ < 4) ++ rtw_err(rtwdev, "read register 0x%x failed with %d\n", ++ addr, ret); ++ ++ return le32_to_cpu(*data); ++} ++ ++static u8 rtw_usb_read8(struct rtw_dev *rtwdev, u32 addr) ++{ ++ return (u8)rtw_usb_read(rtwdev, addr, 1); ++} ++ ++static u16 rtw_usb_read16(struct rtw_dev *rtwdev, u32 addr) ++{ ++ return (u16)rtw_usb_read(rtwdev, addr, 2); ++} ++ ++static u32 rtw_usb_read32(struct rtw_dev *rtwdev, u32 addr) ++{ ++ return (u32)rtw_usb_read(rtwdev, addr, 4); ++} ++ ++static void rtw_usb_write(struct rtw_dev *rtwdev, u32 addr, u32 val, int len) ++{ ++ struct rtw_usb *rtwusb = (struct rtw_usb *)rtwdev->priv; ++ struct usb_device *udev = rtwusb->udev; ++ unsigned long flags; ++ __le32 *data; ++ int idx, ret; ++ static int count; ++ ++ spin_lock_irqsave(&rtwusb->usb_lock, flags); ++ ++ idx = rtwusb->usb_data_index; ++ rtwusb->usb_data_index = (idx + 1) & (RTW_USB_MAX_RXTX_COUNT - 1); ++ ++ spin_unlock_irqrestore(&rtwusb->usb_lock, flags); ++ ++ data = &rtwusb->usb_data[idx]; ++ ++ *data = cpu_to_le32(val); ++ ++ ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), ++ RTW_USB_CMD_REQ, RTW_USB_CMD_WRITE, ++ addr, 0, data, len, 30000); ++ if (ret < 0 && ret != -ENODEV && count++ < 4) ++ rtw_err(rtwdev, "write register 0x%x failed with %d\n", ++ addr, ret); ++} ++ ++static void rtw_usb_write8(struct rtw_dev *rtwdev, u32 addr, u8 val) ++{ ++ rtw_usb_write(rtwdev, addr, val, 1); ++} ++ ++static void rtw_usb_write16(struct rtw_dev *rtwdev, u32 addr, u16 val) ++{ ++ rtw_usb_write(rtwdev, addr, val, 2); ++} ++ ++static void rtw_usb_write32(struct rtw_dev *rtwdev, u32 addr, u32 val) ++{ ++ rtw_usb_write(rtwdev, addr, val, 4); ++} ++ ++static int rtw_usb_parse(struct rtw_dev *rtwdev, ++ struct usb_interface *interface) ++{ ++ struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); ++ struct usb_host_interface *host_interface = &interface->altsetting[0]; ++ struct usb_interface_descriptor *interface_desc = &host_interface->desc; ++ struct usb_endpoint_descriptor *endpoint; ++ struct usb_device *usbd = interface_to_usbdev(interface); ++ int num_out_pipes = 0; ++ int i; ++ u8 num; ++ ++ for (i = 0; i < interface_desc->bNumEndpoints; i++) { ++ endpoint = &host_interface->endpoint[i].desc; ++ num = usb_endpoint_num(endpoint); ++ ++ if (usb_endpoint_dir_in(endpoint) && ++ usb_endpoint_xfer_bulk(endpoint)) { ++ if (rtwusb->pipe_in) { ++ rtw_err(rtwdev, "IN pipes overflow\n"); ++ return -EINVAL; ++ } ++ ++ rtwusb->pipe_in = num; ++ } ++ ++ if (usb_endpoint_dir_in(endpoint) && ++ usb_endpoint_xfer_int(endpoint)) { ++ if (rtwusb->pipe_interrupt) { ++ rtw_err(rtwdev, "INT pipes overflow\n"); ++ return -EINVAL; ++ } ++ ++ rtwusb->pipe_interrupt = num; ++ } ++ ++ if (usb_endpoint_dir_out(endpoint) && ++ usb_endpoint_xfer_bulk(endpoint)) { ++ if (num_out_pipes >= ARRAY_SIZE(rtwusb->out_ep)) { ++ rtw_err(rtwdev, "OUT pipes overflow\n"); ++ return -EINVAL; ++ } ++ ++ rtwusb->out_ep[num_out_pipes++] = num; ++ } ++ } ++ ++ switch (usbd->speed) { ++ case USB_SPEED_LOW: ++ case USB_SPEED_FULL: ++ rtwusb->bulkout_size = RTW_USB_FULL_SPEED_BULK_SIZE; ++ break; ++ case USB_SPEED_HIGH: ++ rtwusb->bulkout_size = RTW_USB_HIGH_SPEED_BULK_SIZE; ++ break; ++ case USB_SPEED_SUPER: ++ rtwusb->bulkout_size = RTW_USB_SUPER_SPEED_BULK_SIZE; ++ break; ++ default: ++ rtw_err(rtwdev, "failed to detect usb speed\n"); ++ return -EINVAL; ++ } ++ ++ rtwdev->hci.bulkout_num = num_out_pipes; ++ ++ switch (num_out_pipes) { ++ case 4: ++ case 3: ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID0] = 2; ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID1] = 2; ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID2] = 2; ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID3] = 2; ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID4] = 1; ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID5] = 1; ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID6] = 0; ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID7] = 0; ++ break; ++ case 2: ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID0] = 1; ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID1] = 1; ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID2] = 1; ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID3] = 1; ++ break; ++ case 1: ++ break; ++ default: ++ rtw_err(rtwdev, "failed to get out_pipes(%d)\n", num_out_pipes); ++ return -EINVAL; ++ } ++ ++ return 0; ++} ++ ++static void rtw_usb_write_port_tx_complete(struct urb *urb) ++{ ++ struct rtw_usb_txcb *txcb = urb->context; ++ struct rtw_dev *rtwdev = txcb->rtwdev; ++ struct ieee80211_hw *hw = rtwdev->hw; ++ ++ while (true) { ++ struct sk_buff *skb = skb_dequeue(&txcb->tx_ack_queue); ++ struct ieee80211_tx_info *info; ++ struct rtw_usb_tx_data *tx_data; ++ ++ if (!skb) ++ break; ++ ++ info = IEEE80211_SKB_CB(skb); ++ tx_data = rtw_usb_get_tx_data(skb); ++ ++ /* enqueue to wait for tx report */ ++ if (info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS) { ++ rtw_tx_report_enqueue(rtwdev, skb, tx_data->sn); ++ continue; ++ } ++ ++ /* always ACK for others, then they won't be marked as drop */ ++ ieee80211_tx_info_clear_status(info); ++ if (info->flags & IEEE80211_TX_CTL_NO_ACK) ++ info->flags |= IEEE80211_TX_STAT_NOACK_TRANSMITTED; ++ else ++ info->flags |= IEEE80211_TX_STAT_ACK; ++ ++ ieee80211_tx_status_irqsafe(hw, skb); ++ } ++ ++ kfree(txcb); ++} ++ ++static int qsel_to_ep(struct rtw_usb *rtwusb, unsigned int qsel) ++{ ++ if (qsel >= ARRAY_SIZE(rtwusb->qsel_to_ep)) ++ return 0; ++ ++ return rtwusb->qsel_to_ep[qsel]; ++} ++ ++static int rtw_usb_write_port(struct rtw_dev *rtwdev, u8 qsel, struct sk_buff *skb, ++ usb_complete_t cb, void *context) ++{ ++ struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); ++ struct usb_device *usbd = rtwusb->udev; ++ struct urb *urb; ++ unsigned int pipe; ++ int ret; ++ int ep = qsel_to_ep(rtwusb, qsel); ++ ++ pipe = usb_sndbulkpipe(usbd, rtwusb->out_ep[ep]); ++ urb = usb_alloc_urb(0, GFP_ATOMIC); ++ if (!urb) ++ return -ENOMEM; ++ ++ usb_fill_bulk_urb(urb, usbd, pipe, skb->data, skb->len, cb, context); ++ urb->transfer_flags |= URB_ZERO_PACKET; ++ ret = usb_submit_urb(urb, GFP_ATOMIC); ++ ++ usb_free_urb(urb); ++ ++ return ret; ++} ++ ++static bool rtw_usb_tx_agg_skb(struct rtw_usb *rtwusb, struct sk_buff_head *list) ++{ ++ struct rtw_dev *rtwdev = rtwusb->rtwdev; ++ struct rtw_usb_txcb *txcb; ++ struct sk_buff *skb_head; ++ struct sk_buff *skb_iter; ++ int agg_num = 0; ++ unsigned int align_next = 0; ++ ++ if (skb_queue_empty(list)) ++ return false; ++ ++ txcb = kmalloc(sizeof(*txcb), GFP_ATOMIC); ++ if (!txcb) ++ return false; ++ ++ txcb->rtwdev = rtwdev; ++ skb_queue_head_init(&txcb->tx_ack_queue); ++ ++ skb_iter = skb_dequeue(list); ++ ++ if (skb_queue_empty(list)) { ++ skb_head = skb_iter; ++ goto queue; ++ } ++ ++ skb_head = dev_alloc_skb(RTW_USB_MAX_XMITBUF_SZ); ++ if (!skb_head) { ++ skb_head = skb_iter; ++ goto queue; ++ } ++ ++ while (skb_iter) { ++ unsigned long flags; ++ ++ skb_put(skb_head, align_next); ++ skb_put_data(skb_head, skb_iter->data, skb_iter->len); ++ ++ align_next = ALIGN(skb_iter->len, 8) - skb_iter->len; ++ ++ agg_num++; ++ ++ skb_queue_tail(&txcb->tx_ack_queue, skb_iter); ++ ++ spin_lock_irqsave(&list->lock, flags); ++ ++ skb_iter = skb_peek(list); ++ ++ if (skb_iter && skb_iter->len + skb_head->len <= RTW_USB_MAX_XMITBUF_SZ) ++ __skb_unlink(skb_iter, list); ++ else ++ skb_iter = NULL; ++ spin_unlock_irqrestore(&list->lock, flags); ++ } ++ ++ if (agg_num > 1) ++ rtw_usb_fill_tx_checksum(rtwusb, skb_head, agg_num); ++ ++queue: ++ skb_queue_tail(&txcb->tx_ack_queue, skb_head); ++ ++ rtw_usb_write_port(rtwdev, GET_TX_DESC_QSEL(skb_head->data), skb_head, ++ rtw_usb_write_port_tx_complete, txcb); ++ ++ return true; ++} ++ ++static void rtw_usb_tx_handler(struct work_struct *work) ++{ ++ struct rtw_usb *rtwusb = container_of(work, struct rtw_usb, tx_work); ++ int i, limit; ++ ++ for (i = ARRAY_SIZE(rtwusb->tx_queue) - 1; i >= 0; i--) { ++ for (limit = 0; limit < 200; limit++) { ++ struct sk_buff_head *list = &rtwusb->tx_queue[i]; ++ ++ if (!rtw_usb_tx_agg_skb(rtwusb, list)) ++ break; ++ } ++ } ++} ++ ++static void rtw_usb_tx_queue_purge(struct rtw_usb *rtwusb) ++{ ++ int i; ++ ++ for (i = 0; i < ARRAY_SIZE(rtwusb->tx_queue); i++) ++ skb_queue_purge(&rtwusb->tx_queue[i]); ++} ++ ++static void rtw_usb_write_port_complete(struct urb *urb) ++{ ++ struct sk_buff *skb = urb->context; ++ ++ dev_kfree_skb_any(skb); ++} ++ ++static int rtw_usb_write_data(struct rtw_dev *rtwdev, ++ struct rtw_tx_pkt_info *pkt_info, ++ u8 *buf) ++{ ++ const struct rtw_chip_info *chip = rtwdev->chip; ++ struct sk_buff *skb; ++ unsigned int desclen, headsize, size; ++ u8 qsel; ++ int ret = 0; ++ ++ size = pkt_info->tx_pkt_size; ++ qsel = pkt_info->qsel; ++ desclen = chip->tx_pkt_desc_sz; ++ headsize = pkt_info->offset ? pkt_info->offset : desclen; ++ ++ skb = dev_alloc_skb(headsize + size); ++ if (unlikely(!skb)) ++ return -ENOMEM; ++ ++ skb_reserve(skb, headsize); ++ skb_put_data(skb, buf, size); ++ skb_push(skb, headsize); ++ memset(skb->data, 0, headsize); ++ rtw_tx_fill_tx_desc(pkt_info, skb); ++ rtw_tx_fill_txdesc_checksum(rtwdev, pkt_info, skb->data); ++ ++ ret = rtw_usb_write_port(rtwdev, qsel, skb, ++ rtw_usb_write_port_complete, skb); ++ if (unlikely(ret)) ++ rtw_err(rtwdev, "failed to do USB write, ret=%d\n", ret); ++ ++ return ret; ++} ++ ++static int rtw_usb_write_data_rsvd_page(struct rtw_dev *rtwdev, u8 *buf, ++ u32 size) ++{ ++ const struct rtw_chip_info *chip = rtwdev->chip; ++ struct rtw_tx_pkt_info pkt_info = {0}; ++ ++ pkt_info.tx_pkt_size = size; ++ pkt_info.qsel = TX_DESC_QSEL_BEACON; ++ pkt_info.offset = chip->tx_pkt_desc_sz; ++ ++ return rtw_usb_write_data(rtwdev, &pkt_info, buf); ++} ++ ++static int rtw_usb_write_data_h2c(struct rtw_dev *rtwdev, u8 *buf, u32 size) ++{ ++ struct rtw_tx_pkt_info pkt_info = {0}; ++ ++ pkt_info.tx_pkt_size = size; ++ pkt_info.qsel = TX_DESC_QSEL_H2C; ++ ++ return rtw_usb_write_data(rtwdev, &pkt_info, buf); ++} ++ ++static u8 rtw_usb_tx_queue_mapping_to_qsel(struct sk_buff *skb) ++{ ++ struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; ++ __le16 fc = hdr->frame_control; ++ u8 qsel; ++ ++ if (unlikely(ieee80211_is_mgmt(fc) || ieee80211_is_ctl(fc))) ++ qsel = TX_DESC_QSEL_MGMT; ++ else if (skb_get_queue_mapping(skb) <= IEEE80211_AC_BK) ++ qsel = skb->priority; ++ else ++ qsel = TX_DESC_QSEL_BEACON; ++ ++ return qsel; ++} ++ ++static int rtw_usb_tx_write(struct rtw_dev *rtwdev, ++ struct rtw_tx_pkt_info *pkt_info, ++ struct sk_buff *skb) ++{ ++ struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); ++ const struct rtw_chip_info *chip = rtwdev->chip; ++ struct rtw_usb_tx_data *tx_data; ++ u8 *pkt_desc; ++ int ep; ++ ++ pkt_info->qsel = rtw_usb_tx_queue_mapping_to_qsel(skb); ++ pkt_desc = skb_push(skb, chip->tx_pkt_desc_sz); ++ memset(pkt_desc, 0, chip->tx_pkt_desc_sz); ++ ep = qsel_to_ep(rtwusb, pkt_info->qsel); ++ rtw_tx_fill_tx_desc(pkt_info, skb); ++ rtw_tx_fill_txdesc_checksum(rtwdev, pkt_info, skb->data); ++ tx_data = rtw_usb_get_tx_data(skb); ++ tx_data->sn = pkt_info->sn; ++ ++ skb_queue_tail(&rtwusb->tx_queue[ep], skb); ++ ++ return 0; ++} ++ ++static void rtw_usb_tx_kick_off(struct rtw_dev *rtwdev) ++{ ++ struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); ++ ++ queue_work(rtwusb->txwq, &rtwusb->tx_work); ++} ++ ++static void rtw_usb_rx_handler(struct work_struct *work) ++{ ++ struct rtw_usb *rtwusb = container_of(work, struct rtw_usb, rx_work); ++ struct rtw_dev *rtwdev = rtwusb->rtwdev; ++ const struct rtw_chip_info *chip = rtwdev->chip; ++ struct rtw_rx_pkt_stat pkt_stat; ++ struct ieee80211_rx_status rx_status; ++ struct sk_buff *skb; ++ u32 pkt_desc_sz = chip->rx_pkt_desc_sz; ++ u32 pkt_offset; ++ u8 *rx_desc; ++ int limit; ++ ++ for (limit = 0; limit < 200; limit++) { ++ skb = skb_dequeue(&rtwusb->rx_queue); ++ if (!skb) ++ break; ++ ++ rx_desc = skb->data; ++ chip->ops->query_rx_desc(rtwdev, rx_desc, &pkt_stat, ++ &rx_status); ++ pkt_offset = pkt_desc_sz + pkt_stat.drv_info_sz + ++ pkt_stat.shift; ++ ++ if (pkt_stat.is_c2h) { ++ skb_put(skb, pkt_stat.pkt_len + pkt_offset); ++ rtw_fw_c2h_cmd_rx_irqsafe(rtwdev, pkt_offset, skb); ++ continue; ++ } ++ ++ if (skb_queue_len(&rtwusb->rx_queue) >= RTW_USB_MAX_RXQ_LEN) { ++ rtw_err(rtwdev, "failed to get rx_queue, overflow\n"); ++ dev_kfree_skb_any(skb); ++ continue; ++ } ++ ++ skb_put(skb, pkt_stat.pkt_len); ++ skb_reserve(skb, pkt_offset); ++ memcpy(skb->cb, &rx_status, sizeof(rx_status)); ++ ieee80211_rx_irqsafe(rtwdev->hw, skb); ++ } ++} ++ ++static void rtw_usb_read_port_complete(struct urb *urb); ++ ++static void rtw_usb_rx_resubmit(struct rtw_usb *rtwusb, struct rx_usb_ctrl_block *rxcb) ++{ ++ struct rtw_dev *rtwdev = rtwusb->rtwdev; ++ int error; ++ ++ rxcb->rx_skb = alloc_skb(RTW_USB_MAX_RECVBUF_SZ, GFP_ATOMIC); ++ if (!rxcb->rx_skb) ++ return; ++ ++ usb_fill_bulk_urb(rxcb->rx_urb, rtwusb->udev, ++ usb_rcvbulkpipe(rtwusb->udev, rtwusb->pipe_in), ++ rxcb->rx_skb->data, RTW_USB_MAX_RECVBUF_SZ, ++ rtw_usb_read_port_complete, rxcb); ++ ++ error = usb_submit_urb(rxcb->rx_urb, GFP_ATOMIC); ++ if (error) { ++ kfree_skb(rxcb->rx_skb); ++ if (error != -ENODEV) ++ rtw_err(rtwdev, "Err sending rx data urb %d\n", ++ error); ++ } ++} ++ ++static void rtw_usb_read_port_complete(struct urb *urb) ++{ ++ struct rx_usb_ctrl_block *rxcb = urb->context; ++ struct rtw_dev *rtwdev = rxcb->rtwdev; ++ struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); ++ struct sk_buff *skb = rxcb->rx_skb; ++ ++ if (urb->status == 0) { ++ if (urb->actual_length >= RTW_USB_MAX_RECVBUF_SZ || ++ urb->actual_length < 24) { ++ rtw_err(rtwdev, "failed to get urb length:%d\n", ++ urb->actual_length); ++ if (skb) ++ dev_kfree_skb_any(skb); ++ } else { ++ skb_queue_tail(&rtwusb->rx_queue, skb); ++ queue_work(rtwusb->rxwq, &rtwusb->rx_work); ++ } ++ rtw_usb_rx_resubmit(rtwusb, rxcb); ++ } else { ++ switch (urb->status) { ++ case -EINVAL: ++ case -EPIPE: ++ case -ENODEV: ++ case -ESHUTDOWN: ++ case -ENOENT: ++ case -EPROTO: ++ case -EILSEQ: ++ case -ETIME: ++ case -ECOMM: ++ case -EOVERFLOW: ++ case -EINPROGRESS: ++ break; ++ default: ++ rtw_err(rtwdev, "status %d\n", urb->status); ++ break; ++ } ++ if (skb) ++ dev_kfree_skb_any(skb); ++ } ++} ++ ++static void rtw_usb_cancel_rx_bufs(struct rtw_usb *rtwusb) ++{ ++ struct rx_usb_ctrl_block *rxcb; ++ int i; ++ ++ for (i = 0; i < RTW_USB_RXCB_NUM; i++) { ++ rxcb = &rtwusb->rx_cb[i]; ++ if (rxcb->rx_urb) ++ usb_kill_urb(rxcb->rx_urb); ++ } ++} ++ ++static void rtw_usb_free_rx_bufs(struct rtw_usb *rtwusb) ++{ ++ struct rx_usb_ctrl_block *rxcb; ++ int i; ++ ++ for (i = 0; i < RTW_USB_RXCB_NUM; i++) { ++ rxcb = &rtwusb->rx_cb[i]; ++ if (rxcb->rx_urb) { ++ usb_kill_urb(rxcb->rx_urb); ++ usb_free_urb(rxcb->rx_urb); ++ } ++ } ++} ++ ++static int rtw_usb_alloc_rx_bufs(struct rtw_usb *rtwusb) ++{ ++ int i; ++ ++ for (i = 0; i < RTW_USB_RXCB_NUM; i++) { ++ struct rx_usb_ctrl_block *rxcb = &rtwusb->rx_cb[i]; ++ ++ rxcb->n = i; ++ rxcb->rtwdev = rtwusb->rtwdev; ++ rxcb->rx_urb = usb_alloc_urb(0, GFP_KERNEL); ++ if (!rxcb->rx_urb) ++ goto err; ++ } ++ ++ return 0; ++err: ++ rtw_usb_free_rx_bufs(rtwusb); ++ return -ENOMEM; ++} ++ ++static int rtw_usb_setup(struct rtw_dev *rtwdev) ++{ ++ /* empty function for rtw_hci_ops */ ++ return 0; ++} ++ ++static int rtw_usb_start(struct rtw_dev *rtwdev) ++{ ++ return 0; ++} ++ ++static void rtw_usb_stop(struct rtw_dev *rtwdev) ++{ ++} ++ ++static void rtw_usb_deep_ps(struct rtw_dev *rtwdev, bool enter) ++{ ++ /* empty function for rtw_hci_ops */ ++} ++ ++static void rtw_usb_link_ps(struct rtw_dev *rtwdev, bool enter) ++{ ++ /* empty function for rtw_hci_ops */ ++} ++ ++static void rtw_usb_interface_cfg(struct rtw_dev *rtwdev) ++{ ++ /* empty function for rtw_hci_ops */ ++} ++ ++static struct rtw_hci_ops rtw_usb_ops = { ++ .tx_write = rtw_usb_tx_write, ++ .tx_kick_off = rtw_usb_tx_kick_off, ++ .setup = rtw_usb_setup, ++ .start = rtw_usb_start, ++ .stop = rtw_usb_stop, ++ .deep_ps = rtw_usb_deep_ps, ++ .link_ps = rtw_usb_link_ps, ++ .interface_cfg = rtw_usb_interface_cfg, ++ ++ .write8 = rtw_usb_write8, ++ .write16 = rtw_usb_write16, ++ .write32 = rtw_usb_write32, ++ .read8 = rtw_usb_read8, ++ .read16 = rtw_usb_read16, ++ .read32 = rtw_usb_read32, ++ ++ .write_data_rsvd_page = rtw_usb_write_data_rsvd_page, ++ .write_data_h2c = rtw_usb_write_data_h2c, ++}; ++ ++static int rtw_usb_init_rx(struct rtw_dev *rtwdev) ++{ ++ struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); ++ int i; ++ ++ rtwusb->rxwq = create_singlethread_workqueue("rtw88_usb: rx wq"); ++ if (!rtwusb->rxwq) { ++ rtw_err(rtwdev, "failed to create RX work queue\n"); ++ return -ENOMEM; ++ } ++ ++ skb_queue_head_init(&rtwusb->rx_queue); ++ ++ INIT_WORK(&rtwusb->rx_work, rtw_usb_rx_handler); ++ ++ for (i = 0; i < RTW_USB_RXCB_NUM; i++) { ++ struct rx_usb_ctrl_block *rxcb = &rtwusb->rx_cb[i]; ++ ++ rtw_usb_rx_resubmit(rtwusb, rxcb); ++ } ++ ++ return 0; ++} ++ ++static void rtw_usb_deinit_rx(struct rtw_dev *rtwdev) ++{ ++ struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); ++ ++ skb_queue_purge(&rtwusb->rx_queue); ++ ++ flush_workqueue(rtwusb->rxwq); ++ destroy_workqueue(rtwusb->rxwq); ++} ++ ++static int rtw_usb_init_tx(struct rtw_dev *rtwdev) ++{ ++ struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); ++ int i; ++ ++ rtwusb->txwq = create_singlethread_workqueue("rtw88_usb: tx wq"); ++ if (!rtwusb->txwq) { ++ rtw_err(rtwdev, "failed to create TX work queue\n"); ++ return -ENOMEM; ++ } ++ ++ for (i = 0; i < ARRAY_SIZE(rtwusb->tx_queue); i++) ++ skb_queue_head_init(&rtwusb->tx_queue[i]); ++ ++ INIT_WORK(&rtwusb->tx_work, rtw_usb_tx_handler); ++ ++ return 0; ++} ++ ++static void rtw_usb_deinit_tx(struct rtw_dev *rtwdev) ++{ ++ struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); ++ ++ rtw_usb_tx_queue_purge(rtwusb); ++ flush_workqueue(rtwusb->txwq); ++ destroy_workqueue(rtwusb->txwq); ++} ++ ++static int rtw_usb_intf_init(struct rtw_dev *rtwdev, ++ struct usb_interface *intf) ++{ ++ struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); ++ struct usb_device *udev = usb_get_dev(interface_to_usbdev(intf)); ++ int ret; ++ ++ rtwusb->udev = udev; ++ ret = rtw_usb_parse(rtwdev, intf); ++ if (ret) ++ return ret; ++ ++ rtwusb->usb_data = kcalloc(RTW_USB_MAX_RXTX_COUNT, sizeof(u32), ++ GFP_KERNEL); ++ if (!rtwusb->usb_data) ++ return -ENOMEM; ++ ++ usb_set_intfdata(intf, rtwdev->hw); ++ ++ SET_IEEE80211_DEV(rtwdev->hw, &intf->dev); ++ spin_lock_init(&rtwusb->usb_lock); ++ ++ return 0; ++} ++ ++static void rtw_usb_intf_deinit(struct rtw_dev *rtwdev, ++ struct usb_interface *intf) ++{ ++ struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); ++ ++ usb_put_dev(rtwusb->udev); ++ usb_set_intfdata(intf, NULL); ++} ++ ++int rtw_usb_probe(struct usb_interface *intf, const struct usb_device_id *id) ++{ ++ struct rtw_dev *rtwdev; ++ struct ieee80211_hw *hw; ++ struct rtw_usb *rtwusb; ++ int drv_data_size; ++ int ret; ++ ++ drv_data_size = sizeof(struct rtw_dev) + sizeof(struct rtw_usb); ++ hw = ieee80211_alloc_hw(drv_data_size, &rtw_ops); ++ if (!hw) ++ return -ENOMEM; ++ ++ rtwdev = hw->priv; ++ rtwdev->hw = hw; ++ rtwdev->dev = &intf->dev; ++ rtwdev->chip = (struct rtw_chip_info *)id->driver_info; ++ rtwdev->hci.ops = &rtw_usb_ops; ++ rtwdev->hci.type = RTW_HCI_TYPE_USB; ++ ++ rtwusb = rtw_get_usb_priv(rtwdev); ++ rtwusb->rtwdev = rtwdev; ++ ++ ret = rtw_usb_alloc_rx_bufs(rtwusb); ++ if (ret) ++ return ret; ++ ++ ret = rtw_core_init(rtwdev); ++ if (ret) ++ goto err_release_hw; ++ ++ ret = rtw_usb_intf_init(rtwdev, intf); ++ if (ret) { ++ rtw_err(rtwdev, "failed to init USB interface\n"); ++ goto err_deinit_core; ++ } ++ ++ ret = rtw_usb_init_tx(rtwdev); ++ if (ret) { ++ rtw_err(rtwdev, "failed to init USB TX\n"); ++ goto err_destroy_usb; ++ } ++ ++ ret = rtw_usb_init_rx(rtwdev); ++ if (ret) { ++ rtw_err(rtwdev, "failed to init USB RX\n"); ++ goto err_destroy_txwq; ++ } ++ ++ ret = rtw_chip_info_setup(rtwdev); ++ if (ret) { ++ rtw_err(rtwdev, "failed to setup chip information\n"); ++ goto err_destroy_rxwq; ++ } ++ ++ ret = rtw_register_hw(rtwdev, rtwdev->hw); ++ if (ret) { ++ rtw_err(rtwdev, "failed to register hw\n"); ++ goto err_destroy_rxwq; ++ } ++ ++ return 0; ++ ++err_destroy_rxwq: ++ rtw_usb_deinit_rx(rtwdev); ++ ++err_destroy_txwq: ++ rtw_usb_deinit_tx(rtwdev); ++ ++err_destroy_usb: ++ rtw_usb_intf_deinit(rtwdev, intf); ++ ++err_deinit_core: ++ rtw_core_deinit(rtwdev); ++ ++err_release_hw: ++ ieee80211_free_hw(hw); ++ ++ return ret; ++} ++EXPORT_SYMBOL(rtw_usb_probe); ++ ++void rtw_usb_disconnect(struct usb_interface *intf) ++{ ++ struct ieee80211_hw *hw = usb_get_intfdata(intf); ++ struct rtw_dev *rtwdev; ++ struct rtw_usb *rtwusb; ++ ++ if (!hw) ++ return; ++ ++ rtwdev = hw->priv; ++ rtwusb = rtw_get_usb_priv(rtwdev); ++ ++ rtw_usb_cancel_rx_bufs(rtwusb); ++ ++ rtw_unregister_hw(rtwdev, hw); ++ rtw_usb_deinit_tx(rtwdev); ++ rtw_usb_deinit_rx(rtwdev); ++ ++ if (rtwusb->udev->state != USB_STATE_NOTATTACHED) ++ usb_reset_device(rtwusb->udev); ++ ++ rtw_usb_free_rx_bufs(rtwusb); ++ ++ rtw_usb_intf_deinit(rtwdev, intf); ++ rtw_core_deinit(rtwdev); ++ ieee80211_free_hw(hw); ++} ++EXPORT_SYMBOL(rtw_usb_disconnect); ++ ++MODULE_AUTHOR("Realtek Corporation"); ++MODULE_DESCRIPTION("Realtek 802.11ac wireless USB driver"); ++MODULE_LICENSE("Dual BSD/GPL"); +--- /dev/null ++++ b/drivers/net/wireless/realtek/rtw88/usb.h +@@ -0,0 +1,107 @@ ++/* SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause */ ++/* Copyright(c) 2018-2019 Realtek Corporation ++ */ ++ ++#ifndef __RTW_USB_H_ ++#define __RTW_USB_H_ ++ ++#define FW_8192C_START_ADDRESS 0x1000 ++#define FW_8192C_END_ADDRESS 0x5fff ++ ++#define RTW_USB_MAX_RXTX_COUNT 128 ++#define RTW_USB_VENQT_MAX_BUF_SIZE 254 ++#define MAX_USBCTRL_VENDORREQ_TIMES 10 ++ ++#define RTW_USB_CMD_READ 0xc0 ++#define RTW_USB_CMD_WRITE 0x40 ++#define RTW_USB_CMD_REQ 0x05 ++ ++#define RTW_USB_VENQT_CMD_IDX 0x00 ++ ++#define RTW_USB_SUPER_SPEED_BULK_SIZE 1024 ++#define RTW_USB_HIGH_SPEED_BULK_SIZE 512 ++#define RTW_USB_FULL_SPEED_BULK_SIZE 64 ++ ++#define RTW_USB_TX_SEL_HQ BIT(0) ++#define RTW_USB_TX_SEL_LQ BIT(1) ++#define RTW_USB_TX_SEL_NQ BIT(2) ++#define RTW_USB_TX_SEL_EQ BIT(3) ++ ++#define RTW_USB_BULK_IN_ADDR 0x80 ++#define RTW_USB_INT_IN_ADDR 0x81 ++ ++#define RTW_USB_HW_QUEUE_ENTRY 8 ++ ++#define RTW_USB_PACKET_OFFSET_SZ 8 ++#define RTW_USB_MAX_XMITBUF_SZ (1024 * 20) ++#define RTW_USB_MAX_RECVBUF_SZ 32768 ++ ++#define RTW_USB_RECVBUFF_ALIGN_SZ 8 ++ ++#define RTW_USB_RXAGG_SIZE 6 ++#define RTW_USB_RXAGG_TIMEOUT 10 ++ ++#define RTW_USB_RXCB_NUM 4 ++ ++#define RTW_USB_EP_MAX 4 ++ ++#define TX_DESC_QSEL_MAX 20 ++ ++#define RTW_USB_VENDOR_ID_REALTEK 0x0bda ++ ++static inline struct rtw_usb *rtw_get_usb_priv(struct rtw_dev *rtwdev) ++{ ++ return (struct rtw_usb *)rtwdev->priv; ++} ++ ++struct rx_usb_ctrl_block { ++ struct rtw_dev *rtwdev; ++ struct urb *rx_urb; ++ struct sk_buff *rx_skb; ++ int n; ++}; ++ ++struct rtw_usb_tx_data { ++ u8 sn; ++}; ++ ++struct rtw_usb { ++ struct rtw_dev *rtwdev; ++ struct usb_device *udev; ++ ++ /* protects usb_data_index */ ++ spinlock_t usb_lock; ++ __le32 *usb_data; ++ unsigned int usb_data_index; ++ ++ u32 bulkout_size; ++ u8 pipe_interrupt; ++ u8 pipe_in; ++ u8 out_ep[RTW_USB_EP_MAX]; ++ u8 qsel_to_ep[TX_DESC_QSEL_MAX]; ++ u8 usb_txagg_num; ++ ++ struct workqueue_struct *txwq, *rxwq; ++ ++ struct sk_buff_head tx_queue[RTW_USB_EP_MAX]; ++ struct work_struct tx_work; ++ ++ struct rx_usb_ctrl_block rx_cb[RTW_USB_RXCB_NUM]; ++ struct sk_buff_head rx_queue; ++ struct work_struct rx_work; ++}; ++ ++static inline struct rtw_usb_tx_data *rtw_usb_get_tx_data(struct sk_buff *skb) ++{ ++ struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); ++ ++ BUILD_BUG_ON(sizeof(struct rtw_usb_tx_data) > ++ sizeof(info->status.status_driver_data)); ++ ++ return (struct rtw_usb_tx_data *)info->status.status_driver_data; ++} ++ ++int rtw_usb_probe(struct usb_interface *intf, const struct usb_device_id *id); ++void rtw_usb_disconnect(struct usb_interface *intf); ++ ++#endif diff --git a/package/kernel/mac80211/patches/rtl/010-wifi-rtw88-Add-rtw8821cu-chipset-support.patch b/package/kernel/mac80211/patches/rtl/010-wifi-rtw88-Add-rtw8821cu-chipset-support.patch new file mode 100644 index 0000000000..17c9bb16b3 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/010-wifi-rtw88-Add-rtw8821cu-chipset-support.patch @@ -0,0 +1,197 @@ +From ee542f62f5ba5cf88a21e638b387c9a3b85687a5 Mon Sep 17 00:00:00 2001 +From: Sascha Hauer +Date: Fri, 2 Dec 2022 09:12:21 +0100 +Subject: [PATCH 10/13] wifi: rtw88: Add rtw8821cu chipset support + +Add support for the rtw8821cu chipset based on +https://github.com/ulli-kroll/rtw88-usb.git + +Signed-off-by: Sascha Hauer +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20221202081224.2779981-9-s.hauer@pengutronix.de +--- + drivers/net/wireless/realtek/rtw88/Kconfig | 11 ++++ + drivers/net/wireless/realtek/rtw88/Makefile | 3 ++ + drivers/net/wireless/realtek/rtw88/rtw8821c.c | 18 +++++++ + drivers/net/wireless/realtek/rtw88/rtw8821c.h | 21 ++++++++ + .../net/wireless/realtek/rtw88/rtw8821cu.c | 50 +++++++++++++++++++ + 5 files changed, 103 insertions(+) + create mode 100644 drivers/net/wireless/realtek/rtw88/rtw8821cu.c + +--- a/drivers/net/wireless/realtek/rtw88/Kconfig ++++ b/drivers/net/wireless/realtek/rtw88/Kconfig +@@ -87,6 +87,17 @@ config RTW88_8821CE + + 802.11ac PCIe wireless network adapter + ++config RTW88_8821CU ++ tristate "Realtek 8821CU USB wireless network adapter" ++ depends on USB ++ select RTW88_CORE ++ select RTW88_USB ++ select RTW88_8821C ++ help ++ Select this option will enable support for 8821CU chipset ++ ++ 802.11ac USB wireless network adapter ++ + config RTW88_DEBUG + bool "Realtek rtw88 debug support" + depends on RTW88_CORE +--- a/drivers/net/wireless/realtek/rtw88/Makefile ++++ b/drivers/net/wireless/realtek/rtw88/Makefile +@@ -44,6 +44,9 @@ rtw88_8821c-objs := rtw8821c.o rtw8821c + obj-$(CPTCFG_RTW88_8821CE) += rtw88_8821ce.o + rtw88_8821ce-objs := rtw8821ce.o + ++obj-$(CPTCFG_RTW88_8821CU) += rtw88_8821cu.o ++rtw88_8821cu-objs := rtw8821cu.o ++ + obj-$(CPTCFG_RTW88_PCI) += rtw88_pci.o + rtw88_pci-objs := pci.o + +--- a/drivers/net/wireless/realtek/rtw88/rtw8821c.c ++++ b/drivers/net/wireless/realtek/rtw88/rtw8821c.c +@@ -26,6 +26,12 @@ static void rtw8821ce_efuse_parsing(stru + ether_addr_copy(efuse->addr, map->e.mac_addr); + } + ++static void rtw8821cu_efuse_parsing(struct rtw_efuse *efuse, ++ struct rtw8821c_efuse *map) ++{ ++ ether_addr_copy(efuse->addr, map->u.mac_addr); ++} ++ + enum rtw8821ce_rf_set { + SWITCH_TO_BTG, + SWITCH_TO_WLG, +@@ -68,6 +74,9 @@ static int rtw8821c_read_efuse(struct rt + case RTW_HCI_TYPE_PCIE: + rtw8821ce_efuse_parsing(efuse, map); + break; ++ case RTW_HCI_TYPE_USB: ++ rtw8821cu_efuse_parsing(efuse, map); ++ break; + default: + /* unsupported now */ + return -ENOTSUPP; +@@ -1148,6 +1157,13 @@ static void rtw8821c_phy_cck_pd_set(stru + dm_info->cck_pd_default + new_lvl * 2); + } + ++static void rtw8821c_fill_txdesc_checksum(struct rtw_dev *rtwdev, ++ struct rtw_tx_pkt_info *pkt_info, ++ u8 *txdesc) ++{ ++ fill_txdesc_checksum_common(txdesc, 16); ++} ++ + static struct rtw_pwr_seq_cmd trans_carddis_to_cardemu_8821c[] = { + {0x0086, + RTW_PWR_CUT_ALL_MSK, +@@ -1521,6 +1537,7 @@ static const struct rtw_rfe_def rtw8821c + [2] = RTW_DEF_RFE_EXT(8821c, 0, 0, 2), + [4] = RTW_DEF_RFE_EXT(8821c, 0, 0, 2), + [6] = RTW_DEF_RFE(8821c, 0, 0), ++ [34] = RTW_DEF_RFE(8821c, 0, 0), + }; + + static struct rtw_hw_reg rtw8821c_dig[] = { +@@ -1595,6 +1612,7 @@ static struct rtw_chip_ops rtw8821c_ops + .config_bfee = rtw8821c_bf_config_bfee, + .set_gid_table = rtw_bf_set_gid_table, + .cfg_csi_rate = rtw_bf_cfg_csi_rate, ++ .fill_txdesc_checksum = rtw8821c_fill_txdesc_checksum, + + .coex_set_init = rtw8821c_coex_cfg_init, + .coex_set_ant_switch = rtw8821c_coex_cfg_ant_switch, +--- a/drivers/net/wireless/realtek/rtw88/rtw8821c.h ++++ b/drivers/net/wireless/realtek/rtw88/rtw8821c.h +@@ -9,6 +9,26 @@ + + #define RCR_VHT_ACK BIT(26) + ++struct rtw8821cu_efuse { ++ u8 res4[4]; /* 0xd0 */ ++ u8 usb_optional_function; ++ u8 res5[0x1e]; ++ u8 res6[2]; ++ u8 serial[0x0b]; /* 0xf5 */ ++ u8 vid; /* 0x100 */ ++ u8 res7; ++ u8 pid; ++ u8 res8[4]; ++ u8 mac_addr[ETH_ALEN]; /* 0x107 */ ++ u8 res9[2]; ++ u8 vendor_name[0x07]; ++ u8 res10[2]; ++ u8 device_name[0x14]; ++ u8 res11[0xcf]; ++ u8 package_type; /* 0x1fb */ ++ u8 res12[0x4]; ++}; ++ + struct rtw8821ce_efuse { + u8 mac_addr[ETH_ALEN]; /* 0xd0 */ + u8 vender_id[2]; +@@ -73,6 +93,7 @@ struct rtw8821c_efuse { + u8 res[3]; + union { + struct rtw8821ce_efuse e; ++ struct rtw8821cu_efuse u; + }; + }; + +--- /dev/null ++++ b/drivers/net/wireless/realtek/rtw88/rtw8821cu.c +@@ -0,0 +1,50 @@ ++// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause ++/* Copyright(c) 2018-2019 Realtek Corporation ++ */ ++ ++#include ++#include ++#include "main.h" ++#include "rtw8821c.h" ++#include "usb.h" ++ ++static const struct usb_device_id rtw_8821cu_id_table[] = { ++ { USB_DEVICE_AND_INTERFACE_INFO(RTW_USB_VENDOR_ID_REALTEK, 0xb82b, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8821c_hw_spec) }, /* 8821CU */ ++ { USB_DEVICE_AND_INTERFACE_INFO(RTW_USB_VENDOR_ID_REALTEK, 0xb820, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8821c_hw_spec) }, /* 8821CU */ ++ { USB_DEVICE_AND_INTERFACE_INFO(RTW_USB_VENDOR_ID_REALTEK, 0xc821, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8821c_hw_spec) }, /* 8821CU */ ++ { USB_DEVICE_AND_INTERFACE_INFO(RTW_USB_VENDOR_ID_REALTEK, 0xc820, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8821c_hw_spec) }, /* 8821CU */ ++ { USB_DEVICE_AND_INTERFACE_INFO(RTW_USB_VENDOR_ID_REALTEK, 0xc82a, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8821c_hw_spec) }, /* 8821CU */ ++ { USB_DEVICE_AND_INTERFACE_INFO(RTW_USB_VENDOR_ID_REALTEK, 0xc82b, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8821c_hw_spec) }, /* 8821CU */ ++ { USB_DEVICE_AND_INTERFACE_INFO(RTW_USB_VENDOR_ID_REALTEK, 0xc811, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8821c_hw_spec) }, /* 8811CU */ ++ { USB_DEVICE_AND_INTERFACE_INFO(RTW_USB_VENDOR_ID_REALTEK, 0x8811, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8821c_hw_spec) }, /* 8811CU */ ++ { USB_DEVICE_AND_INTERFACE_INFO(RTW_USB_VENDOR_ID_REALTEK, 0x2006, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8821c_hw_spec) }, /* TOTOLINK A650UA v3 */ ++ {}, ++}; ++MODULE_DEVICE_TABLE(usb, rtw_8821cu_id_table); ++ ++static int rtw_8821cu_probe(struct usb_interface *intf, ++ const struct usb_device_id *id) ++{ ++ return rtw_usb_probe(intf, id); ++} ++ ++static struct usb_driver rtw_8821cu_driver = { ++ .name = "rtw_8821cu", ++ .id_table = rtw_8821cu_id_table, ++ .probe = rtw_8821cu_probe, ++ .disconnect = rtw_usb_disconnect, ++}; ++module_usb_driver(rtw_8821cu_driver); ++ ++MODULE_AUTHOR("Hans Ulli Kroll "); ++MODULE_DESCRIPTION("Realtek 802.11ac wireless 8821cu driver"); ++MODULE_LICENSE("Dual BSD/GPL"); diff --git a/package/kernel/mac80211/patches/rtl/011-wifi-rtw88-Add-rtw8822bu-chipset-support.patch b/package/kernel/mac80211/patches/rtl/011-wifi-rtw88-Add-rtw8822bu-chipset-support.patch new file mode 100644 index 0000000000..6fe4e9749c --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/011-wifi-rtw88-Add-rtw8822bu-chipset-support.patch @@ -0,0 +1,194 @@ +From 02fbb82275b164606edd12fa03e10a3e5a070b02 Mon Sep 17 00:00:00 2001 +From: Sascha Hauer +Date: Fri, 2 Dec 2022 09:12:22 +0100 +Subject: [PATCH 11/13] wifi: rtw88: Add rtw8822bu chipset support + +Add support for the rtw8822bu chipset based on +https://github.com/ulli-kroll/rtw88-usb.git + +Signed-off-by: Sascha Hauer +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20221202081224.2779981-10-s.hauer@pengutronix.de +--- + drivers/net/wireless/realtek/rtw88/Kconfig | 12 +++ + drivers/net/wireless/realtek/rtw88/Makefile | 3 + + drivers/net/wireless/realtek/rtw88/rtw8822b.c | 19 ++++ + .../net/wireless/realtek/rtw88/rtw8822bu.c | 90 +++++++++++++++++++ + 4 files changed, 124 insertions(+) + create mode 100644 drivers/net/wireless/realtek/rtw88/rtw8822bu.c + +--- a/drivers/net/wireless/realtek/rtw88/Kconfig ++++ b/drivers/net/wireless/realtek/rtw88/Kconfig +@@ -51,6 +51,18 @@ config RTW88_8822BE + + 802.11ac PCIe wireless network adapter + ++config RTW88_8822BU ++ tristate "Realtek 8822BU USB wireless network adapter" ++ depends on m ++ depends on USB ++ select RTW88_CORE ++ select RTW88_USB ++ select RTW88_8822B ++ help ++ Select this option will enable support for 8822BU chipset ++ ++ 802.11ac USB wireless network adapter ++ + config RTW88_8822CE + tristate "Realtek 8822CE PCI wireless network adapter" + depends on m +--- a/drivers/net/wireless/realtek/rtw88/Makefile ++++ b/drivers/net/wireless/realtek/rtw88/Makefile +@@ -26,6 +26,9 @@ rtw88_8822b-objs := rtw8822b.o rtw8822b + obj-$(CPTCFG_RTW88_8822BE) += rtw88_8822be.o + rtw88_8822be-objs := rtw8822be.o + ++obj-$(CPTCFG_RTW88_8822BU) += rtw88_8822bu.o ++rtw88_8822bu-objs := rtw8822bu.o ++ + obj-$(CPTCFG_RTW88_8822C) += rtw88_8822c.o + rtw88_8822c-objs := rtw8822c.o rtw8822c_table.o + +--- a/drivers/net/wireless/realtek/rtw88/rtw8822b.c ++++ b/drivers/net/wireless/realtek/rtw88/rtw8822b.c +@@ -26,6 +26,12 @@ static void rtw8822be_efuse_parsing(stru + ether_addr_copy(efuse->addr, map->e.mac_addr); + } + ++static void rtw8822bu_efuse_parsing(struct rtw_efuse *efuse, ++ struct rtw8822b_efuse *map) ++{ ++ ether_addr_copy(efuse->addr, map->u.mac_addr); ++} ++ + static int rtw8822b_read_efuse(struct rtw_dev *rtwdev, u8 *log_map) + { + struct rtw_efuse *efuse = &rtwdev->efuse; +@@ -56,6 +62,9 @@ static int rtw8822b_read_efuse(struct rt + case RTW_HCI_TYPE_PCIE: + rtw8822be_efuse_parsing(efuse, map); + break; ++ case RTW_HCI_TYPE_USB: ++ rtw8822bu_efuse_parsing(efuse, map); ++ break; + default: + /* unsupported now */ + return -ENOTSUPP; +@@ -1588,6 +1597,15 @@ static void rtw8822b_adaptivity(struct r + rtw_phy_set_edcca_th(rtwdev, l2h, h2l); + } + ++static void rtw8822b_fill_txdesc_checksum(struct rtw_dev *rtwdev, ++ struct rtw_tx_pkt_info *pkt_info, ++ u8 *txdesc) ++{ ++ size_t words = 32 / 2; /* calculate the first 32 bytes (16 words) */ ++ ++ fill_txdesc_checksum_common(txdesc, words); ++} ++ + static const struct rtw_pwr_seq_cmd trans_carddis_to_cardemu_8822b[] = { + {0x0086, + RTW_PWR_CUT_ALL_MSK, +@@ -2163,6 +2181,7 @@ static struct rtw_chip_ops rtw8822b_ops + .cfg_csi_rate = rtw_bf_cfg_csi_rate, + .adaptivity_init = rtw8822b_adaptivity_init, + .adaptivity = rtw8822b_adaptivity, ++ .fill_txdesc_checksum = rtw8822b_fill_txdesc_checksum, + + .coex_set_init = rtw8822b_coex_cfg_init, + .coex_set_ant_switch = rtw8822b_coex_cfg_ant_switch, +--- /dev/null ++++ b/drivers/net/wireless/realtek/rtw88/rtw8822bu.c +@@ -0,0 +1,90 @@ ++// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause ++/* Copyright(c) 2018-2019 Realtek Corporation ++ */ ++ ++#include ++#include ++#include "main.h" ++#include "rtw8822b.h" ++#include "usb.h" ++ ++static const struct usb_device_id rtw_8822bu_id_table[] = { ++ { USB_DEVICE_AND_INTERFACE_INFO(RTW_USB_VENDOR_ID_REALTEK, 0xb812, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(RTW_USB_VENDOR_ID_REALTEK, 0xb82c, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(RTW_USB_VENDOR_ID_REALTEK, 0x2102, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* CCNC */ ++ { USB_DEVICE_AND_INTERFACE_INFO(0x7392, 0xb822, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* Edimax EW-7822ULC */ ++ { USB_DEVICE_AND_INTERFACE_INFO(0x7392, 0xc822, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* Edimax EW-7822UTC */ ++ { USB_DEVICE_AND_INTERFACE_INFO(0x7392, 0xd822, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* Edimax */ ++ { USB_DEVICE_AND_INTERFACE_INFO(0x7392, 0xe822, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* Edimax */ ++ { USB_DEVICE_AND_INTERFACE_INFO(0x7392, 0xf822, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* Edimax EW-7822UAD */ ++ { USB_DEVICE_AND_INTERFACE_INFO(RTW_USB_VENDOR_ID_REALTEK, 0xb81a, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* Default ID */ ++ { USB_DEVICE_AND_INTERFACE_INFO(0x0b05, 0x1841, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* ASUS AC1300 USB-AC55 B1 */ ++ { USB_DEVICE_AND_INTERFACE_INFO(0x0b05, 0x184c, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* ASUS U2 */ ++ { USB_DEVICE_AND_INTERFACE_INFO(0x0B05, 0x19aa, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* ASUS - USB-AC58 rev A1 */ ++ { USB_DEVICE_AND_INTERFACE_INFO(0x0B05, 0x1870, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* ASUS */ ++ { USB_DEVICE_AND_INTERFACE_INFO(0x0B05, 0x1874, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* ASUS */ ++ { USB_DEVICE_AND_INTERFACE_INFO(0x2001, 0x331e, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* Dlink - DWA-181 */ ++ { USB_DEVICE_AND_INTERFACE_INFO(0x2001, 0x331c, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* Dlink - DWA-182 - D1 */ ++ {USB_DEVICE_AND_INTERFACE_INFO(0x2001, 0x331f, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec)}, /* Dlink - DWA-183 D Ver */ ++ { USB_DEVICE_AND_INTERFACE_INFO(0x13b1, 0x0043, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* Linksys WUSB6400M */ ++ { USB_DEVICE_AND_INTERFACE_INFO(0x13b1, 0x0045, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* Linksys WUSB3600 v2 */ ++ { USB_DEVICE_AND_INTERFACE_INFO(0x2357, 0x012d, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* TP-Link Archer T3U v1 */ ++ { USB_DEVICE_AND_INTERFACE_INFO(0x2357, 0x0138, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* TP-Link Archer T3U Plus v1 */ ++ { USB_DEVICE_AND_INTERFACE_INFO(0x2357, 0x0115, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* TP-Link Archer T4U V3 */ ++ { USB_DEVICE_AND_INTERFACE_INFO(0x2357, 0x012e, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* TP-LINK */ ++ { USB_DEVICE_AND_INTERFACE_INFO(0x2357, 0x0116, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* TP-LINK */ ++ { USB_DEVICE_AND_INTERFACE_INFO(0x2357, 0x0117, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* TP-LINK */ ++ { USB_DEVICE_AND_INTERFACE_INFO(0x0846, 0x9055, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* Netgear A6150 */ ++ { USB_DEVICE_AND_INTERFACE_INFO(0x0e66, 0x0025, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* Hawking HW12ACU */ ++ { USB_DEVICE_AND_INTERFACE_INFO(0x04ca, 0x8602, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* LiteOn */ ++ { USB_DEVICE_AND_INTERFACE_INFO(0x20f4, 0x808a, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822b_hw_spec) }, /* TRENDnet TEW-808UBM */ ++ {}, ++}; ++MODULE_DEVICE_TABLE(usb, rtw_8822bu_id_table); ++ ++static int rtw8822bu_probe(struct usb_interface *intf, ++ const struct usb_device_id *id) ++{ ++ return rtw_usb_probe(intf, id); ++} ++ ++static struct usb_driver rtw_8822bu_driver = { ++ .name = "rtw_8822bu", ++ .id_table = rtw_8822bu_id_table, ++ .probe = rtw8822bu_probe, ++ .disconnect = rtw_usb_disconnect, ++}; ++module_usb_driver(rtw_8822bu_driver); ++ ++MODULE_AUTHOR("Realtek Corporation"); ++MODULE_DESCRIPTION("Realtek 802.11ac wireless 8822bu driver"); ++MODULE_LICENSE("Dual BSD/GPL"); diff --git a/package/kernel/mac80211/patches/rtl/012-wifi-rtw88-Add-rtw8822cu-chipset-support.patch b/package/kernel/mac80211/patches/rtl/012-wifi-rtw88-Add-rtw8822cu-chipset-support.patch new file mode 100644 index 0000000000..438127b9da --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/012-wifi-rtw88-Add-rtw8822cu-chipset-support.patch @@ -0,0 +1,160 @@ +From 39c7486c66bd76d182c0ad02d440d7207bccb89e Mon Sep 17 00:00:00 2001 +From: Sascha Hauer +Date: Fri, 2 Dec 2022 09:12:23 +0100 +Subject: [PATCH 12/13] wifi: rtw88: Add rtw8822cu chipset support + +Add support for the rtw8822cu chipset based on +https://github.com/ulli-kroll/rtw88-usb.git + +Signed-off-by: Sascha Hauer +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20221202081224.2779981-11-s.hauer@pengutronix.de +--- + drivers/net/wireless/realtek/rtw88/Kconfig | 12 +++++ + drivers/net/wireless/realtek/rtw88/Makefile | 3 ++ + drivers/net/wireless/realtek/rtw88/rtw8822c.c | 24 ++++++++++ + .../net/wireless/realtek/rtw88/rtw8822cu.c | 44 +++++++++++++++++++ + 4 files changed, 83 insertions(+) + create mode 100644 drivers/net/wireless/realtek/rtw88/rtw8822cu.c + +--- a/drivers/net/wireless/realtek/rtw88/Kconfig ++++ b/drivers/net/wireless/realtek/rtw88/Kconfig +@@ -75,6 +75,18 @@ config RTW88_8822CE + + 802.11ac PCIe wireless network adapter + ++config RTW88_8822CU ++ tristate "Realtek 8822CU USB wireless network adapter" ++ depends on m ++ depends on USB ++ select RTW88_CORE ++ select RTW88_USB ++ select RTW88_8822C ++ help ++ Select this option will enable support for 8822CU chipset ++ ++ 802.11ac USB wireless network adapter ++ + config RTW88_8723DE + tristate "Realtek 8723DE PCI wireless network adapter" + depends on m +--- a/drivers/net/wireless/realtek/rtw88/Makefile ++++ b/drivers/net/wireless/realtek/rtw88/Makefile +@@ -35,6 +35,9 @@ rtw88_8822c-objs := rtw8822c.o rtw8822c + obj-$(CPTCFG_RTW88_8822CE) += rtw88_8822ce.o + rtw88_8822ce-objs := rtw8822ce.o + ++obj-$(CPTCFG_RTW88_8822CU) += rtw88_8822cu.o ++rtw88_8822cu-objs := rtw8822cu.o ++ + obj-$(CPTCFG_RTW88_8723D) += rtw88_8723d.o + rtw88_8723d-objs := rtw8723d.o rtw8723d_table.o + +--- a/drivers/net/wireless/realtek/rtw88/rtw8822c.c ++++ b/drivers/net/wireless/realtek/rtw88/rtw8822c.c +@@ -29,6 +29,12 @@ static void rtw8822ce_efuse_parsing(stru + ether_addr_copy(efuse->addr, map->e.mac_addr); + } + ++static void rtw8822cu_efuse_parsing(struct rtw_efuse *efuse, ++ struct rtw8822c_efuse *map) ++{ ++ ether_addr_copy(efuse->addr, map->u.mac_addr); ++} ++ + static int rtw8822c_read_efuse(struct rtw_dev *rtwdev, u8 *log_map) + { + struct rtw_efuse *efuse = &rtwdev->efuse; +@@ -58,6 +64,9 @@ static int rtw8822c_read_efuse(struct rt + case RTW_HCI_TYPE_PCIE: + rtw8822ce_efuse_parsing(efuse, map); + break; ++ case RTW_HCI_TYPE_USB: ++ rtw8822cu_efuse_parsing(efuse, map); ++ break; + default: + /* unsupported now */ + return -ENOTSUPP; +@@ -4557,6 +4566,18 @@ static void rtw8822c_adaptivity(struct r + rtw_phy_set_edcca_th(rtwdev, l2h, h2l); + } + ++static void rtw8822c_fill_txdesc_checksum(struct rtw_dev *rtwdev, ++ struct rtw_tx_pkt_info *pkt_info, ++ u8 *txdesc) ++{ ++ const struct rtw_chip_info *chip = rtwdev->chip; ++ size_t words; ++ ++ words = (pkt_info->pkt_offset * 8 + chip->tx_pkt_desc_sz) / 2; ++ ++ fill_txdesc_checksum_common(txdesc, words); ++} ++ + static const struct rtw_pwr_seq_cmd trans_carddis_to_cardemu_8822c[] = { + {0x0086, + RTW_PWR_CUT_ALL_MSK, +@@ -4895,6 +4916,8 @@ static const struct rtw_rfe_def rtw8822c + [0] = RTW_DEF_RFE(8822c, 0, 0), + [1] = RTW_DEF_RFE(8822c, 0, 0), + [2] = RTW_DEF_RFE(8822c, 0, 0), ++ [3] = RTW_DEF_RFE(8822c, 0, 0), ++ [4] = RTW_DEF_RFE(8822c, 0, 0), + [5] = RTW_DEF_RFE(8822c, 0, 5), + [6] = RTW_DEF_RFE(8822c, 0, 0), + }; +@@ -4978,6 +5001,7 @@ static struct rtw_chip_ops rtw8822c_ops + .cfo_track = rtw8822c_cfo_track, + .config_tx_path = rtw8822c_config_tx_path, + .config_txrx_mode = rtw8822c_config_trx_mode, ++ .fill_txdesc_checksum = rtw8822c_fill_txdesc_checksum, + + .coex_set_init = rtw8822c_coex_cfg_init, + .coex_set_ant_switch = NULL, +--- /dev/null ++++ b/drivers/net/wireless/realtek/rtw88/rtw8822cu.c +@@ -0,0 +1,44 @@ ++// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause ++/* Copyright(c) 2018-2019 Realtek Corporation ++ */ ++ ++#include ++#include ++#include "main.h" ++#include "rtw8822c.h" ++#include "usb.h" ++ ++static const struct usb_device_id rtw_8822cu_id_table[] = { ++ { USB_DEVICE_AND_INTERFACE_INFO(RTW_USB_VENDOR_ID_REALTEK, 0xc82c, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822c_hw_spec) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(RTW_USB_VENDOR_ID_REALTEK, 0xc812, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822c_hw_spec) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(RTW_USB_VENDOR_ID_REALTEK, 0xc82e, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822c_hw_spec) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(RTW_USB_VENDOR_ID_REALTEK, 0xd820, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822c_hw_spec) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(RTW_USB_VENDOR_ID_REALTEK, 0xd82b, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822c_hw_spec) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(0x13b1, 0x0043, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8822c_hw_spec) }, /* Alpha - Alpha */ ++ {}, ++}; ++MODULE_DEVICE_TABLE(usb, rtw_8822cu_id_table); ++ ++static int rtw8822bu_probe(struct usb_interface *intf, ++ const struct usb_device_id *id) ++{ ++ return rtw_usb_probe(intf, id); ++} ++ ++static struct usb_driver rtw_8822cu_driver = { ++ .name = "rtw_8822cu", ++ .id_table = rtw_8822cu_id_table, ++ .probe = rtw8822bu_probe, ++ .disconnect = rtw_usb_disconnect, ++}; ++module_usb_driver(rtw_8822cu_driver); ++ ++MODULE_AUTHOR("Realtek Corporation"); ++MODULE_DESCRIPTION("Realtek 802.11ac wireless 8822cu driver"); ++MODULE_LICENSE("Dual BSD/GPL"); diff --git a/package/kernel/mac80211/patches/rtl/013-wifi-rtw88-Add-rtw8723du-chipset-support.patch b/package/kernel/mac80211/patches/rtl/013-wifi-rtw88-Add-rtw8723du-chipset-support.patch new file mode 100644 index 0000000000..b1ebdb3d8b --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/013-wifi-rtw88-Add-rtw8723du-chipset-support.patch @@ -0,0 +1,187 @@ +From 8f9245f0ac82177554d990f12d5a9071db6305e4 Mon Sep 17 00:00:00 2001 +From: Sascha Hauer +Date: Fri, 2 Dec 2022 09:12:24 +0100 +Subject: [PATCH 13/13] wifi: rtw88: Add rtw8723du chipset support + +Add support for the rtw8723du chipset based on +https://github.com/ulli-kroll/rtw88-usb.git + +Signed-off-by: Sascha Hauer +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20221202081224.2779981-12-s.hauer@pengutronix.de +--- + drivers/net/wireless/realtek/rtw88/Kconfig | 13 +++++++ + drivers/net/wireless/realtek/rtw88/Makefile | 3 ++ + drivers/net/wireless/realtek/rtw88/rtw8723d.c | 28 +++++++++++++++ + drivers/net/wireless/realtek/rtw88/rtw8723d.h | 13 ++++++- + .../net/wireless/realtek/rtw88/rtw8723du.c | 36 +++++++++++++++++++ + 5 files changed, 92 insertions(+), 1 deletion(-) + create mode 100644 drivers/net/wireless/realtek/rtw88/rtw8723du.c + +--- a/drivers/net/wireless/realtek/rtw88/Kconfig ++++ b/drivers/net/wireless/realtek/rtw88/Kconfig +@@ -99,6 +99,18 @@ config RTW88_8723DE + + 802.11n PCIe wireless network adapter + ++config RTW88_8723DU ++ tristate "Realtek 8723DU USB wireless network adapter" ++ depends on m ++ depends on USB ++ select RTW88_CORE ++ select RTW88_USB ++ select RTW88_8723D ++ help ++ Select this option will enable support for 8723DU chipset ++ ++ 802.11n USB wireless network adapter ++ + config RTW88_8821CE + tristate "Realtek 8821CE PCI wireless network adapter" + depends on m +@@ -113,6 +125,7 @@ config RTW88_8821CE + + config RTW88_8821CU + tristate "Realtek 8821CU USB wireless network adapter" ++ depends on m + depends on USB + select RTW88_CORE + select RTW88_USB +--- a/drivers/net/wireless/realtek/rtw88/Makefile ++++ b/drivers/net/wireless/realtek/rtw88/Makefile +@@ -44,6 +44,9 @@ rtw88_8723d-objs := rtw8723d.o rtw8723d + obj-$(CPTCFG_RTW88_8723DE) += rtw88_8723de.o + rtw88_8723de-objs := rtw8723de.o + ++obj-$(CPTCFG_RTW88_8723DU) += rtw88_8723du.o ++rtw88_8723du-objs := rtw8723du.o ++ + obj-$(CPTCFG_RTW88_8821C) += rtw88_8821c.o + rtw88_8821c-objs := rtw8821c.o rtw8821c_table.o + +--- a/drivers/net/wireless/realtek/rtw88/rtw8723d.c ++++ b/drivers/net/wireless/realtek/rtw88/rtw8723d.c +@@ -210,6 +210,12 @@ static void rtw8723de_efuse_parsing(stru + ether_addr_copy(efuse->addr, map->e.mac_addr); + } + ++static void rtw8723du_efuse_parsing(struct rtw_efuse *efuse, ++ struct rtw8723d_efuse *map) ++{ ++ ether_addr_copy(efuse->addr, map->u.mac_addr); ++} ++ + static int rtw8723d_read_efuse(struct rtw_dev *rtwdev, u8 *log_map) + { + struct rtw_efuse *efuse = &rtwdev->efuse; +@@ -239,6 +245,9 @@ static int rtw8723d_read_efuse(struct rt + case RTW_HCI_TYPE_PCIE: + rtw8723de_efuse_parsing(efuse, map); + break; ++ case RTW_HCI_TYPE_USB: ++ rtw8723du_efuse_parsing(efuse, map); ++ break; + default: + /* unsupported now */ + return -ENOTSUPP; +@@ -1945,6 +1954,24 @@ static void rtw8723d_pwr_track(struct rt + dm_info->pwr_trk_triggered = false; + } + ++static void rtw8723d_fill_txdesc_checksum(struct rtw_dev *rtwdev, ++ struct rtw_tx_pkt_info *pkt_info, ++ u8 *txdesc) ++{ ++ size_t words = 32 / 2; /* calculate the first 32 bytes (16 words) */ ++ __le16 chksum = 0; ++ __le16 *data = (__le16 *)(txdesc); ++ ++ SET_TX_DESC_TXDESC_CHECKSUM(txdesc, 0x0000); ++ ++ while (words--) ++ chksum ^= *data++; ++ ++ chksum = ~chksum; ++ ++ SET_TX_DESC_TXDESC_CHECKSUM(txdesc, __le16_to_cpu(chksum)); ++} ++ + static struct rtw_chip_ops rtw8723d_ops = { + .phy_set_param = rtw8723d_phy_set_param, + .read_efuse = rtw8723d_read_efuse, +@@ -1965,6 +1992,7 @@ static struct rtw_chip_ops rtw8723d_ops + .config_bfee = NULL, + .set_gid_table = NULL, + .cfg_csi_rate = NULL, ++ .fill_txdesc_checksum = rtw8723d_fill_txdesc_checksum, + + .coex_set_init = rtw8723d_coex_cfg_init, + .coex_set_ant_switch = NULL, +--- a/drivers/net/wireless/realtek/rtw88/rtw8723d.h ++++ b/drivers/net/wireless/realtek/rtw88/rtw8723d.h +@@ -41,6 +41,14 @@ struct rtw8723de_efuse { + u8 sub_device_id[2]; + }; + ++struct rtw8723du_efuse { ++ u8 res4[48]; /* 0xd0 */ ++ u8 vender_id[2]; /* 0x100 */ ++ u8 product_id[2]; /* 0x102 */ ++ u8 usb_option; /* 0x104 */ ++ u8 mac_addr[ETH_ALEN]; /* 0x107 */ ++}; ++ + struct rtw8723d_efuse { + __le16 rtl_id; + u8 rsvd[2]; +@@ -69,7 +77,10 @@ struct rtw8723d_efuse { + u8 rfe_option; + u8 country_code[2]; + u8 res[3]; +- struct rtw8723de_efuse e; ++ union { ++ struct rtw8723de_efuse e; ++ struct rtw8723du_efuse u; ++ }; + }; + + extern const struct rtw_chip_info rtw8723d_hw_spec; +--- /dev/null ++++ b/drivers/net/wireless/realtek/rtw88/rtw8723du.c +@@ -0,0 +1,36 @@ ++// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause ++/* Copyright(c) 2018-2019 Realtek Corporation ++ */ ++ ++#include ++#include ++#include "main.h" ++#include "rtw8723d.h" ++#include "usb.h" ++ ++static const struct usb_device_id rtw_8723du_id_table[] = { ++ { USB_DEVICE_AND_INTERFACE_INFO(RTW_USB_VENDOR_ID_REALTEK, 0xd723, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8723d_hw_spec) }, /* 8723DU 1*1 */ ++ { USB_DEVICE_AND_INTERFACE_INFO(0x7392, 0xd611, 0xff, 0xff, 0xff), ++ .driver_info = (kernel_ulong_t)&(rtw8723d_hw_spec) }, /* Edimax EW-7611ULB V2 */ ++ { }, ++}; ++MODULE_DEVICE_TABLE(usb, rtw_8723du_id_table); ++ ++static int rtw8723du_probe(struct usb_interface *intf, ++ const struct usb_device_id *id) ++{ ++ return rtw_usb_probe(intf, id); ++} ++ ++static struct usb_driver rtw_8723du_driver = { ++ .name = "rtw_8723du", ++ .id_table = rtw_8723du_id_table, ++ .probe = rtw8723du_probe, ++ .disconnect = rtw_usb_disconnect, ++}; ++module_usb_driver(rtw_8723du_driver); ++ ++MODULE_AUTHOR("Hans Ulli Kroll "); ++MODULE_DESCRIPTION("Realtek 802.11n wireless 8723du driver"); ++MODULE_LICENSE("Dual BSD/GPL"); diff --git a/package/kernel/mac80211/patches/rtl/014-backports-rtw88-21cu-22cu-22bu-8723du.patch b/package/kernel/mac80211/patches/rtl/014-backports-rtw88-21cu-22cu-22bu-8723du.patch new file mode 100644 index 0000000000..d453f05adc --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/014-backports-rtw88-21cu-22cu-22bu-8723du.patch @@ -0,0 +1,70 @@ +--- a/Kconfig.local ++++ b/Kconfig.local +@@ -1135,15 +1135,30 @@ config BACKPORTED_RTW88_CORE + config BACKPORTED_RTW88_PCI + tristate + default RTW88_PCI ++config BACKPORTED_RTW88_USB ++ tristate ++ default RTW88_USB ++config BACKPORTED_RTW88_8821CU ++ tristate ++ default RTW88_8821CU + config BACKPORTED_RTW88_8822B + tristate + default RTW88_8822B ++config BACKPORTED_RTW88_8822BU ++ tristate ++ default RTW88_8822BU + config BACKPORTED_RTW88_8822C + tristate + default RTW88_8822C ++config BACKPORTED_RTW88_8822CU ++ tristate ++ default RTW88_8822CU + config BACKPORTED_RTW88_8723D + tristate + default RTW88_8723D ++config BACKPORTED_RTW88_8723DU ++ tristate ++ default RTW88_8723DU + config BACKPORTED_RTW88_8821C + tristate + default RTW88_8821C +--- a/defconfigs/wifi ++++ b/defconfigs/wifi +@@ -120,9 +120,13 @@ CPTCFG_RTL8821AE=m + CPTCFG_RTL8XXXU=m + CPTCFG_RTLWIFI=m + CPTCFG_RTW88_8723DE=m ++CPTCFG_RTW88_8723DU=m + CPTCFG_RTW88_8821CE=m ++CPTCFG_RTW88_8821CU=m + CPTCFG_RTW88_8822BE=m ++CPTCFG_RTW88_8822BU=m + CPTCFG_RTW88_8822CE=m ++CPTCFG_RTW88_8822CU=m + CPTCFG_RTW88=m + CPTCFG_SSB=m + CPTCFG_SSB_PCMCIAHOST=y +--- a/local-symbols ++++ b/local-symbols +@@ -375,13 +375,18 @@ RTL8XXXU_UNTESTED= + RTW88= + RTW88_CORE= + RTW88_PCI= ++RTW88_USB= + RTW88_8822B= + RTW88_8822C= + RTW88_8723D= + RTW88_8821C= ++RTW88_8821CU= + RTW88_8822BE= ++RTW88_8822BU= + RTW88_8822CE= ++RTW88_8822CU= + RTW88_8723DE= ++RTW88_8723DU= + RTW88_8821CE= + RTW88_DEBUG= + RTW88_DEBUGFS= diff --git a/package/kernel/mac80211/patches/rtl/015-wifi-rtw88-Move-register-access-from-rtw_bf_assoc-ou.patch b/package/kernel/mac80211/patches/rtl/015-wifi-rtw88-Move-register-access-from-rtw_bf_assoc-ou.patch new file mode 100644 index 0000000000..e3edfe98d7 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/015-wifi-rtw88-Move-register-access-from-rtw_bf_assoc-ou.patch @@ -0,0 +1,72 @@ +From 8a1e2fd8e2da5c8b8c438e20ebffef6881cc9ab8 Mon Sep 17 00:00:00 2001 +From: Martin Blumenstingl +Date: Sun, 8 Jan 2023 22:13:22 +0100 +Subject: [PATCH] wifi: rtw88: Move register access from rtw_bf_assoc() outside + the RCU + +USB and (upcoming) SDIO support may sleep in the read/write handlers. +Shrink the RCU critical section so it only cover the call to +ieee80211_find_sta() and finding the ic_vht_cap/vht_cap based on the +found station. This moves the chip's BFEE configuration outside the +rcu_read_lock section and thus prevent "scheduling while atomic" or +"Voluntary context switch within RCU read-side critical section!" +warnings when accessing the registers using an SDIO card (which is +where this issue has been spotted in the real world - but it also +affects USB cards). + +Reviewed-by: Ping-Ke Shih +Tested-by: Sascha Hauer +Signed-off-by: Martin Blumenstingl +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230108211324.442823-2-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/bf.c | 13 +++++++------ + 1 file changed, 7 insertions(+), 6 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/bf.c ++++ b/drivers/net/wireless/realtek/rtw88/bf.c +@@ -49,19 +49,23 @@ void rtw_bf_assoc(struct rtw_dev *rtwdev + + sta = ieee80211_find_sta(vif, bssid); + if (!sta) { ++ rcu_read_unlock(); ++ + rtw_warn(rtwdev, "failed to find station entry for bss %pM\n", + bssid); +- goto out_unlock; ++ return; + } + + ic_vht_cap = &hw->wiphy->bands[NL80211_BAND_5GHZ]->vht_cap; + vht_cap = &sta->deflink.vht_cap; + ++ rcu_read_unlock(); ++ + if ((ic_vht_cap->cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE) && + (vht_cap->cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) { + if (bfinfo->bfer_mu_cnt >= chip->bfer_mu_max_num) { + rtw_dbg(rtwdev, RTW_DBG_BF, "mu bfer number over limit\n"); +- goto out_unlock; ++ return; + } + + ether_addr_copy(bfee->mac_addr, bssid); +@@ -75,7 +79,7 @@ void rtw_bf_assoc(struct rtw_dev *rtwdev + (vht_cap->cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)) { + if (bfinfo->bfer_su_cnt >= chip->bfer_su_max_num) { + rtw_dbg(rtwdev, RTW_DBG_BF, "su bfer number over limit\n"); +- goto out_unlock; ++ return; + } + + sound_dim = vht_cap->cap & +@@ -98,9 +102,6 @@ void rtw_bf_assoc(struct rtw_dev *rtwdev + + rtw_chip_config_bfee(rtwdev, rtwvif, bfee, true); + } +- +-out_unlock: +- rcu_read_unlock(); + } + + void rtw_bf_init_bfer_entry_mu(struct rtw_dev *rtwdev, diff --git a/package/kernel/mac80211/patches/rtl/016-wifi-rtw88-Use-rtw_iterate_vifs-for-rtw_vif_watch_do.patch b/package/kernel/mac80211/patches/rtl/016-wifi-rtw88-Use-rtw_iterate_vifs-for-rtw_vif_watch_do.patch new file mode 100644 index 0000000000..f9a6fff21a --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/016-wifi-rtw88-Use-rtw_iterate_vifs-for-rtw_vif_watch_do.patch @@ -0,0 +1,39 @@ +From 313f6dc7c5ed723d0c5691553eff4c0090f16bb8 Mon Sep 17 00:00:00 2001 +From: Martin Blumenstingl +Date: Sun, 8 Jan 2023 22:13:23 +0100 +Subject: [PATCH] wifi: rtw88: Use rtw_iterate_vifs() for + rtw_vif_watch_dog_iter() + +USB and (upcoming) SDIO support may sleep in the read/write handlers. +Make rtw_watch_dog_work() use rtw_iterate_vifs() to prevent "scheduling +while atomic" or "Voluntary context switch within RCU read-side +critical section!" warnings when accessing the registers using an SDIO +card (which is where this issue has been spotted in the real world but +it also affects USB cards). + +Fixes: 78d5bf925f30 ("wifi: rtw88: iterate over vif/sta list non-atomically") +Suggested-by: Ping-Ke Shih +Reviewed-by: Ping-Ke Shih +Tested-by: Sascha Hauer +Signed-off-by: Martin Blumenstingl +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230108211324.442823-3-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/main.c | 6 ++++-- + 1 file changed, 4 insertions(+), 2 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/main.c ++++ b/drivers/net/wireless/realtek/rtw88/main.c +@@ -241,8 +241,10 @@ static void rtw_watch_dog_work(struct wo + rtw_phy_dynamic_mechanism(rtwdev); + + data.rtwdev = rtwdev; +- /* use atomic version to avoid taking local->iflist_mtx mutex */ +- rtw_iterate_vifs_atomic(rtwdev, rtw_vif_watch_dog_iter, &data); ++ /* rtw_iterate_vifs internally uses an atomic iterator which is needed ++ * to avoid taking local->iflist_mtx mutex ++ */ ++ rtw_iterate_vifs(rtwdev, rtw_vif_watch_dog_iter, &data); + + /* fw supports only one station associated to enter lps, if there are + * more than two stations associated to the AP, then we can not enter diff --git a/package/kernel/mac80211/patches/rtl/017-wifi-rtw88-Use-non-atomic-sta-iterator-in-rtw_ra_mas.patch b/package/kernel/mac80211/patches/rtl/017-wifi-rtw88-Use-non-atomic-sta-iterator-in-rtw_ra_mas.patch new file mode 100644 index 0000000000..240742382f --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/017-wifi-rtw88-Use-non-atomic-sta-iterator-in-rtw_ra_mas.patch @@ -0,0 +1,47 @@ +From 2931978cd74f4a643deeea5b211523001d95aa44 Mon Sep 17 00:00:00 2001 +From: Martin Blumenstingl +Date: Sun, 8 Jan 2023 22:13:24 +0100 +Subject: [PATCH] wifi: rtw88: Use non-atomic sta iterator in + rtw_ra_mask_info_update() + +USB and (upcoming) SDIO support may sleep in the read/write handlers. +Use non-atomic rtw_iterate_stas() in rtw_ra_mask_info_update() because +the iterator function rtw_ra_mask_info_update_iter() needs to read and +write registers from within rtw_update_sta_info(). Using the non-atomic +iterator ensures that we can sleep during USB and SDIO register reads +and writes. This fixes "scheduling while atomic" or "Voluntary context +switch within RCU read-side critical section!" warnings as seen by SDIO +card users (but it also affects USB cards). + +Fixes: 78d5bf925f30 ("wifi: rtw88: iterate over vif/sta list non-atomically") +Suggested-by: Ping-Ke Shih +Reviewed-by: Ping-Ke Shih +Tested-by: Sascha Hauer +Signed-off-by: Martin Blumenstingl +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230108211324.442823-4-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/mac80211.c | 4 +++- + 1 file changed, 3 insertions(+), 1 deletion(-) + +--- a/drivers/net/wireless/realtek/rtw88/mac80211.c ++++ b/drivers/net/wireless/realtek/rtw88/mac80211.c +@@ -737,7 +737,7 @@ static void rtw_ra_mask_info_update(stru + br_data.rtwdev = rtwdev; + br_data.vif = vif; + br_data.mask = mask; +- rtw_iterate_stas_atomic(rtwdev, rtw_ra_mask_info_update_iter, &br_data); ++ rtw_iterate_stas(rtwdev, rtw_ra_mask_info_update_iter, &br_data); + } + + static int rtw_ops_set_bitrate_mask(struct ieee80211_hw *hw, +@@ -746,7 +746,9 @@ static int rtw_ops_set_bitrate_mask(stru + { + struct rtw_dev *rtwdev = hw->priv; + ++ mutex_lock(&rtwdev->mutex); + rtw_ra_mask_info_update(rtwdev, vif, mask); ++ mutex_unlock(&rtwdev->mutex); + + return 0; + } diff --git a/package/kernel/mac80211/patches/rtl/018-wifi-rtw88-pci-Use-enum-type-for-rtw_hw_queue_mappin.patch b/package/kernel/mac80211/patches/rtl/018-wifi-rtw88-pci-Use-enum-type-for-rtw_hw_queue_mappin.patch new file mode 100644 index 0000000000..4cbd371d2f --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/018-wifi-rtw88-pci-Use-enum-type-for-rtw_hw_queue_mappin.patch @@ -0,0 +1,48 @@ +From 6152b649a70861e72220de9f9abf2fe570967493 Mon Sep 17 00:00:00 2001 +From: Martin Blumenstingl +Date: Sun, 5 Feb 2023 00:29:58 +0100 +Subject: [PATCH] wifi: rtw88: pci: Use enum type for rtw_hw_queue_mapping() + and ac_to_hwq + +rtw_hw_queue_mapping() and ac_to_hwq[] hold values of type enum +rtw_tx_queue_type. Change their types to reflect this to make it easier +to understand this part of the code. + +While here, also change the array to be static const as it is not +supposed to be modified at runtime. + +Signed-off-by: Martin Blumenstingl +Reviewed-by: Simon Horman +Reviewed-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230204233001.1511643-2-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/pci.c | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/pci.c ++++ b/drivers/net/wireless/realtek/rtw88/pci.c +@@ -669,7 +669,7 @@ static void rtw_pci_deep_ps(struct rtw_d + spin_unlock_bh(&rtwpci->irq_lock); + } + +-static u8 ac_to_hwq[] = { ++static const enum rtw_tx_queue_type ac_to_hwq[] = { + [IEEE80211_AC_VO] = RTW_TX_QUEUE_VO, + [IEEE80211_AC_VI] = RTW_TX_QUEUE_VI, + [IEEE80211_AC_BE] = RTW_TX_QUEUE_BE, +@@ -678,12 +678,12 @@ static u8 ac_to_hwq[] = { + + static_assert(ARRAY_SIZE(ac_to_hwq) == IEEE80211_NUM_ACS); + +-static u8 rtw_hw_queue_mapping(struct sk_buff *skb) ++static enum rtw_tx_queue_type rtw_hw_queue_mapping(struct sk_buff *skb) + { + struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; + __le16 fc = hdr->frame_control; + u8 q_mapping = skb_get_queue_mapping(skb); +- u8 queue; ++ enum rtw_tx_queue_type queue; + + if (unlikely(ieee80211_is_beacon(fc))) + queue = RTW_TX_QUEUE_BCN; diff --git a/package/kernel/mac80211/patches/rtl/019-wifi-rtw88-pci-Change-queue-datatype-to-enum-rtw_tx_.patch b/package/kernel/mac80211/patches/rtl/019-wifi-rtw88-pci-Change-queue-datatype-to-enum-rtw_tx_.patch new file mode 100644 index 0000000000..0dba4d8d1a --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/019-wifi-rtw88-pci-Change-queue-datatype-to-enum-rtw_tx_.patch @@ -0,0 +1,89 @@ +From c90897960c19f5bad59fcd391901ac1b7787c50b Mon Sep 17 00:00:00 2001 +From: Martin Blumenstingl +Date: Sun, 5 Feb 2023 00:29:59 +0100 +Subject: [PATCH] wifi: rtw88: pci: Change queue datatype to enum + rtw_tx_queue_type + +This makes it easier to understand which values are allowed for the +"queue" variable when using the enum instead of an u8. + +Acked-by: Ping-Ke Shih +Signed-off-by: Martin Blumenstingl +Reviewed-by: Simon Horman +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230204233001.1511643-3-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/pci.c | 17 ++++++++++------- + 1 file changed, 10 insertions(+), 7 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/pci.c ++++ b/drivers/net/wireless/realtek/rtw88/pci.c +@@ -30,7 +30,8 @@ static u32 rtw_pci_tx_queue_idx_addr[] = + [RTW_TX_QUEUE_H2C] = RTK_PCI_TXBD_IDX_H2CQ, + }; + +-static u8 rtw_pci_get_tx_qsel(struct sk_buff *skb, u8 queue) ++static u8 rtw_pci_get_tx_qsel(struct sk_buff *skb, ++ enum rtw_tx_queue_type queue) + { + switch (queue) { + case RTW_TX_QUEUE_BCN: +@@ -542,7 +543,7 @@ static int rtw_pci_setup(struct rtw_dev + static void rtw_pci_dma_release(struct rtw_dev *rtwdev, struct rtw_pci *rtwpci) + { + struct rtw_pci_tx_ring *tx_ring; +- u8 queue; ++ enum rtw_tx_queue_type queue; + + rtw_pci_reset_trx_ring(rtwdev); + for (queue = 0; queue < RTK_MAX_TX_QUEUE_NUM; queue++) { +@@ -608,8 +609,8 @@ static void rtw_pci_deep_ps_enter(struct + { + struct rtw_pci *rtwpci = (struct rtw_pci *)rtwdev->priv; + struct rtw_pci_tx_ring *tx_ring; ++ enum rtw_tx_queue_type queue; + bool tx_empty = true; +- u8 queue; + + if (rtw_fw_feature_check(&rtwdev->fw, FW_FEATURE_TX_WAKE)) + goto enter_deep_ps; +@@ -803,7 +804,8 @@ static void rtw_pci_flush_queues(struct + __rtw_pci_flush_queues(rtwdev, pci_queues, drop); + } + +-static void rtw_pci_tx_kick_off_queue(struct rtw_dev *rtwdev, u8 queue) ++static void rtw_pci_tx_kick_off_queue(struct rtw_dev *rtwdev, ++ enum rtw_tx_queue_type queue) + { + struct rtw_pci *rtwpci = (struct rtw_pci *)rtwdev->priv; + struct rtw_pci_tx_ring *ring; +@@ -822,7 +824,7 @@ static void rtw_pci_tx_kick_off_queue(st + static void rtw_pci_tx_kick_off(struct rtw_dev *rtwdev) + { + struct rtw_pci *rtwpci = (struct rtw_pci *)rtwdev->priv; +- u8 queue; ++ enum rtw_tx_queue_type queue; + + for (queue = 0; queue < RTK_MAX_TX_QUEUE_NUM; queue++) + if (test_and_clear_bit(queue, rtwpci->tx_queued)) +@@ -831,7 +833,8 @@ static void rtw_pci_tx_kick_off(struct r + + static int rtw_pci_tx_write_data(struct rtw_dev *rtwdev, + struct rtw_tx_pkt_info *pkt_info, +- struct sk_buff *skb, u8 queue) ++ struct sk_buff *skb, ++ enum rtw_tx_queue_type queue) + { + struct rtw_pci *rtwpci = (struct rtw_pci *)rtwdev->priv; + const struct rtw_chip_info *chip = rtwdev->chip; +@@ -949,9 +952,9 @@ static int rtw_pci_tx_write(struct rtw_d + struct rtw_tx_pkt_info *pkt_info, + struct sk_buff *skb) + { ++ enum rtw_tx_queue_type queue = rtw_hw_queue_mapping(skb); + struct rtw_pci *rtwpci = (struct rtw_pci *)rtwdev->priv; + struct rtw_pci_tx_ring *ring; +- u8 queue = rtw_hw_queue_mapping(skb); + int ret; + + ret = rtw_pci_tx_write_data(rtwdev, pkt_info, skb, queue); diff --git a/package/kernel/mac80211/patches/rtl/020-wifi-rtw88-Move-enum-rtw_tx_queue_type-mapping-code-.patch b/package/kernel/mac80211/patches/rtl/020-wifi-rtw88-Move-enum-rtw_tx_queue_type-mapping-code-.patch new file mode 100644 index 0000000000..1bed8f4547 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/020-wifi-rtw88-Move-enum-rtw_tx_queue_type-mapping-code-.patch @@ -0,0 +1,140 @@ +From 7b6e9df91133e13ce7d980fcdb55cc7f26099106 Mon Sep 17 00:00:00 2001 +From: Martin Blumenstingl +Date: Sun, 5 Feb 2023 00:30:00 +0100 +Subject: [PATCH] wifi: rtw88: Move enum rtw_tx_queue_type mapping code to + tx.{c,h} + +This code is not specific to the PCIe bus type but can be re-used by USB +and SDIO bus types. Move it to tx.{c,h} to avoid code-duplication in the +future. While here, add checking of the ac argument in +rtw_tx_ac_to_hwq() so we're not accessing entries beyond the end of the +array. + +Signed-off-by: Martin Blumenstingl +Reviewed-by: Simon Horman +Reviewed-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230204233001.1511643-4-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/pci.c | 35 ++------------------ + drivers/net/wireless/realtek/rtw88/tx.c | 41 ++++++++++++++++++++++++ + drivers/net/wireless/realtek/rtw88/tx.h | 3 ++ + 3 files changed, 46 insertions(+), 33 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/pci.c ++++ b/drivers/net/wireless/realtek/rtw88/pci.c +@@ -670,37 +670,6 @@ static void rtw_pci_deep_ps(struct rtw_d + spin_unlock_bh(&rtwpci->irq_lock); + } + +-static const enum rtw_tx_queue_type ac_to_hwq[] = { +- [IEEE80211_AC_VO] = RTW_TX_QUEUE_VO, +- [IEEE80211_AC_VI] = RTW_TX_QUEUE_VI, +- [IEEE80211_AC_BE] = RTW_TX_QUEUE_BE, +- [IEEE80211_AC_BK] = RTW_TX_QUEUE_BK, +-}; +- +-static_assert(ARRAY_SIZE(ac_to_hwq) == IEEE80211_NUM_ACS); +- +-static enum rtw_tx_queue_type rtw_hw_queue_mapping(struct sk_buff *skb) +-{ +- struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; +- __le16 fc = hdr->frame_control; +- u8 q_mapping = skb_get_queue_mapping(skb); +- enum rtw_tx_queue_type queue; +- +- if (unlikely(ieee80211_is_beacon(fc))) +- queue = RTW_TX_QUEUE_BCN; +- else if (unlikely(ieee80211_is_mgmt(fc) || ieee80211_is_ctl(fc))) +- queue = RTW_TX_QUEUE_MGMT; +- else if (is_broadcast_ether_addr(hdr->addr1) || +- is_multicast_ether_addr(hdr->addr1)) +- queue = RTW_TX_QUEUE_HI0; +- else if (WARN_ON_ONCE(q_mapping >= ARRAY_SIZE(ac_to_hwq))) +- queue = ac_to_hwq[IEEE80211_AC_BE]; +- else +- queue = ac_to_hwq[q_mapping]; +- +- return queue; +-} +- + static void rtw_pci_release_rsvd_page(struct rtw_pci *rtwpci, + struct rtw_pci_tx_ring *ring) + { +@@ -798,7 +767,7 @@ static void rtw_pci_flush_queues(struct + } else { + for (i = 0; i < rtwdev->hw->queues; i++) + if (queues & BIT(i)) +- pci_queues |= BIT(ac_to_hwq[i]); ++ pci_queues |= BIT(rtw_tx_ac_to_hwq(i)); + } + + __rtw_pci_flush_queues(rtwdev, pci_queues, drop); +@@ -952,7 +921,7 @@ static int rtw_pci_tx_write(struct rtw_d + struct rtw_tx_pkt_info *pkt_info, + struct sk_buff *skb) + { +- enum rtw_tx_queue_type queue = rtw_hw_queue_mapping(skb); ++ enum rtw_tx_queue_type queue = rtw_tx_queue_mapping(skb); + struct rtw_pci *rtwpci = (struct rtw_pci *)rtwdev->priv; + struct rtw_pci_tx_ring *ring; + int ret; +--- a/drivers/net/wireless/realtek/rtw88/tx.c ++++ b/drivers/net/wireless/realtek/rtw88/tx.c +@@ -682,3 +682,44 @@ void rtw_txq_cleanup(struct rtw_dev *rtw + list_del_init(&rtwtxq->list); + spin_unlock_bh(&rtwdev->txq_lock); + } ++ ++static const enum rtw_tx_queue_type ac_to_hwq[] = { ++ [IEEE80211_AC_VO] = RTW_TX_QUEUE_VO, ++ [IEEE80211_AC_VI] = RTW_TX_QUEUE_VI, ++ [IEEE80211_AC_BE] = RTW_TX_QUEUE_BE, ++ [IEEE80211_AC_BK] = RTW_TX_QUEUE_BK, ++}; ++ ++static_assert(ARRAY_SIZE(ac_to_hwq) == IEEE80211_NUM_ACS); ++ ++enum rtw_tx_queue_type rtw_tx_ac_to_hwq(enum ieee80211_ac_numbers ac) ++{ ++ if (WARN_ON(unlikely(ac >= IEEE80211_NUM_ACS))) ++ return RTW_TX_QUEUE_BE; ++ ++ return ac_to_hwq[ac]; ++} ++EXPORT_SYMBOL(rtw_tx_ac_to_hwq); ++ ++enum rtw_tx_queue_type rtw_tx_queue_mapping(struct sk_buff *skb) ++{ ++ struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; ++ __le16 fc = hdr->frame_control; ++ u8 q_mapping = skb_get_queue_mapping(skb); ++ enum rtw_tx_queue_type queue; ++ ++ if (unlikely(ieee80211_is_beacon(fc))) ++ queue = RTW_TX_QUEUE_BCN; ++ else if (unlikely(ieee80211_is_mgmt(fc) || ieee80211_is_ctl(fc))) ++ queue = RTW_TX_QUEUE_MGMT; ++ else if (is_broadcast_ether_addr(hdr->addr1) || ++ is_multicast_ether_addr(hdr->addr1)) ++ queue = RTW_TX_QUEUE_HI0; ++ else if (WARN_ON_ONCE(q_mapping >= ARRAY_SIZE(ac_to_hwq))) ++ queue = ac_to_hwq[IEEE80211_AC_BE]; ++ else ++ queue = ac_to_hwq[q_mapping]; ++ ++ return queue; ++} ++EXPORT_SYMBOL(rtw_tx_queue_mapping); +--- a/drivers/net/wireless/realtek/rtw88/tx.h ++++ b/drivers/net/wireless/realtek/rtw88/tx.h +@@ -131,6 +131,9 @@ rtw_tx_write_data_h2c_get(struct rtw_dev + struct rtw_tx_pkt_info *pkt_info, + u8 *buf, u32 size); + ++enum rtw_tx_queue_type rtw_tx_ac_to_hwq(enum ieee80211_ac_numbers ac); ++enum rtw_tx_queue_type rtw_tx_queue_mapping(struct sk_buff *skb); ++ + static inline + void fill_txdesc_checksum_common(u8 *txdesc, size_t words) + { diff --git a/package/kernel/mac80211/patches/rtl/021-49-wifi-rtw88-mac-Use-existing-macros-in-rtw_pwr_seq_pa.patch b/package/kernel/mac80211/patches/rtl/021-49-wifi-rtw88-mac-Use-existing-macros-in-rtw_pwr_seq_pa.patch new file mode 100644 index 0000000000..1770d70dc9 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/021-49-wifi-rtw88-mac-Use-existing-macros-in-rtw_pwr_seq_pa.patch @@ -0,0 +1,34 @@ +From 24d54855ff36c7c6256cb48b735a927090142a51 Mon Sep 17 00:00:00 2001 +From: Martin Blumenstingl +Date: Sun, 5 Feb 2023 00:30:01 +0100 +Subject: [PATCH 49/85] wifi: rtw88: mac: Use existing macros in + rtw_pwr_seq_parser() + +Replace the magic numbers for the intf_mask with their existing +RTW_PWR_INTF_PCI_MSK and RTW_PWR_INTF_USB_MSK macros to make the code +easier to understand. + +Acked-by: Ping-Ke Shih +Signed-off-by: Martin Blumenstingl +Reviewed-by: Simon Horman +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230204233001.1511643-5-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/mac.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/mac.c ++++ b/drivers/net/wireless/realtek/rtw88/mac.c +@@ -217,10 +217,10 @@ static int rtw_pwr_seq_parser(struct rtw + cut_mask = cut_version_to_mask(cut); + switch (rtw_hci_type(rtwdev)) { + case RTW_HCI_TYPE_PCIE: +- intf_mask = BIT(2); ++ intf_mask = RTW_PWR_INTF_PCI_MSK; + break; + case RTW_HCI_TYPE_USB: +- intf_mask = BIT(1); ++ intf_mask = RTW_PWR_INTF_USB_MSK; + break; + default: + return -EINVAL; diff --git a/package/kernel/mac80211/patches/rtl/021-54-wifi-rtw88-mac-Add-support-for-the-SDIO-HCI-in-rtw_p.patch b/package/kernel/mac80211/patches/rtl/021-54-wifi-rtw88-mac-Add-support-for-the-SDIO-HCI-in-rtw_p.patch new file mode 100644 index 0000000000..0549207dbf --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/021-54-wifi-rtw88-mac-Add-support-for-the-SDIO-HCI-in-rtw_p.patch @@ -0,0 +1,29 @@ +From 96c79da2e4d1a25e73916c656fe4ccf7fc8176ae Mon Sep 17 00:00:00 2001 +From: Martin Blumenstingl +Date: Sat, 18 Feb 2023 16:29:40 +0100 +Subject: [PATCH 54/85] wifi: rtw88: mac: Add support for the SDIO HCI in + rtw_pwr_seq_parser() + +rtw_pwr_seq_parser() needs to know about the HCI bus interface mask for +the SDIO bus so it can parse the chip state change sequences. + +Signed-off-by: Martin Blumenstingl +Reviewed-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230218152944.48842-2-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/mac.c | 3 +++ + 1 file changed, 3 insertions(+) + +--- a/drivers/net/wireless/realtek/rtw88/mac.c ++++ b/drivers/net/wireless/realtek/rtw88/mac.c +@@ -222,6 +222,9 @@ static int rtw_pwr_seq_parser(struct rtw + case RTW_HCI_TYPE_USB: + intf_mask = RTW_PWR_INTF_USB_MSK; + break; ++ case RTW_HCI_TYPE_SDIO: ++ intf_mask = RTW_PWR_INTF_SDIO_MSK; ++ break; + default: + return -EINVAL; + } diff --git a/package/kernel/mac80211/patches/rtl/021-55-wifi-rtw88-mac-Add-SDIO-HCI-support-in-the-TX-page-t.patch b/package/kernel/mac80211/patches/rtl/021-55-wifi-rtw88-mac-Add-SDIO-HCI-support-in-the-TX-page-t.patch new file mode 100644 index 0000000000..074fcdc826 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/021-55-wifi-rtw88-mac-Add-SDIO-HCI-support-in-the-TX-page-t.patch @@ -0,0 +1,40 @@ +From 8599ea40582d49afe437badde76e31bd7429c607 Mon Sep 17 00:00:00 2001 +From: Martin Blumenstingl +Date: Sat, 18 Feb 2023 16:29:41 +0100 +Subject: [PATCH 55/85] wifi: rtw88: mac: Add SDIO HCI support in the TX/page + table setup + +txdma_queue_mapping() and priority_queue_cfg() can use the first entry +of each chip's rqpn_table and page_table. Add this mapping so data +transmission is possible on SDIO based chipsets. + +Signed-off-by: Martin Blumenstingl +Reviewed-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230218152944.48842-3-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/mac.c | 6 ++++++ + 1 file changed, 6 insertions(+) + +--- a/drivers/net/wireless/realtek/rtw88/mac.c ++++ b/drivers/net/wireless/realtek/rtw88/mac.c +@@ -1043,6 +1043,9 @@ static int txdma_queue_mapping(struct rt + else + return -EINVAL; + break; ++ case RTW_HCI_TYPE_SDIO: ++ rqpn = &chip->rqpn_table[0]; ++ break; + default: + return -EINVAL; + } +@@ -1205,6 +1208,9 @@ static int priority_queue_cfg(struct rtw + else + return -EINVAL; + break; ++ case RTW_HCI_TYPE_SDIO: ++ pg_tbl = &chip->page_table[0]; ++ break; + default: + return -EINVAL; + } diff --git a/package/kernel/mac80211/patches/rtl/021-56-wifi-rtw88-rtw8821c-Implement-RTL8821CS-SDIO-efuse-p.patch b/package/kernel/mac80211/patches/rtl/021-56-wifi-rtw88-rtw8821c-Implement-RTL8821CS-SDIO-efuse-p.patch new file mode 100644 index 0000000000..c8f6f3c9d3 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/021-56-wifi-rtw88-rtw8821c-Implement-RTL8821CS-SDIO-efuse-p.patch @@ -0,0 +1,66 @@ +From 64e9d564653566812dfade36d20f1794407e6ca1 Mon Sep 17 00:00:00 2001 +From: Martin Blumenstingl +Date: Sat, 18 Feb 2023 16:29:42 +0100 +Subject: [PATCH 56/85] wifi: rtw88: rtw8821c: Implement RTL8821CS (SDIO) efuse + parsing + +The efuse of the SDIO RTL8821CS chip has only one known member: the mac +address is at offset 0x11a. Add a struct rtw8821cs_efuse describing this +and use it for copying the mac address when the SDIO bus is used. + +Signed-off-by: Martin Blumenstingl +Reviewed-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230218152944.48842-4-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/rtw8821c.c | 9 +++++++++ + drivers/net/wireless/realtek/rtw88/rtw8821c.h | 6 ++++++ + 2 files changed, 15 insertions(+) + +--- a/drivers/net/wireless/realtek/rtw88/rtw8821c.c ++++ b/drivers/net/wireless/realtek/rtw88/rtw8821c.c +@@ -32,6 +32,12 @@ static void rtw8821cu_efuse_parsing(stru + ether_addr_copy(efuse->addr, map->u.mac_addr); + } + ++static void rtw8821cs_efuse_parsing(struct rtw_efuse *efuse, ++ struct rtw8821c_efuse *map) ++{ ++ ether_addr_copy(efuse->addr, map->s.mac_addr); ++} ++ + enum rtw8821ce_rf_set { + SWITCH_TO_BTG, + SWITCH_TO_WLG, +@@ -77,6 +83,9 @@ static int rtw8821c_read_efuse(struct rt + case RTW_HCI_TYPE_USB: + rtw8821cu_efuse_parsing(efuse, map); + break; ++ case RTW_HCI_TYPE_SDIO: ++ rtw8821cs_efuse_parsing(efuse, map); ++ break; + default: + /* unsupported now */ + return -ENOTSUPP; +--- a/drivers/net/wireless/realtek/rtw88/rtw8821c.h ++++ b/drivers/net/wireless/realtek/rtw88/rtw8821c.h +@@ -65,6 +65,11 @@ struct rtw8821ce_efuse { + u8 res7; + }; + ++struct rtw8821cs_efuse { ++ u8 res4[0x4a]; /* 0xd0 */ ++ u8 mac_addr[ETH_ALEN]; /* 0x11a */ ++} __packed; ++ + struct rtw8821c_efuse { + __le16 rtl_id; + u8 res0[0x0e]; +@@ -94,6 +99,7 @@ struct rtw8821c_efuse { + union { + struct rtw8821ce_efuse e; + struct rtw8821cu_efuse u; ++ struct rtw8821cs_efuse s; + }; + }; + diff --git a/package/kernel/mac80211/patches/rtl/021-57-wifi-rtw88-rtw8822b-Implement-RTL8822BS-SDIO-efuse-p.patch b/package/kernel/mac80211/patches/rtl/021-57-wifi-rtw88-rtw8822b-Implement-RTL8822BS-SDIO-efuse-p.patch new file mode 100644 index 0000000000..62704ac825 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/021-57-wifi-rtw88-rtw8822b-Implement-RTL8822BS-SDIO-efuse-p.patch @@ -0,0 +1,69 @@ +From 9e688784b8a13515ee186d0ee1cfab12b6d05241 Mon Sep 17 00:00:00 2001 +From: Martin Blumenstingl +Date: Sat, 18 Feb 2023 16:29:43 +0100 +Subject: [PATCH 57/85] wifi: rtw88: rtw8822b: Implement RTL8822BS (SDIO) efuse + parsing + +The efuse of the SDIO RTL8822BS chip has only one known member: the mac +address is at offset 0x11a. Add a struct rtw8822bs_efuse describing this +and use it for copying the mac address when the SDIO bus is used. + +Signed-off-by: Martin Blumenstingl +Reviewed-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230218152944.48842-5-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/rtw8822b.c | 9 +++++++++ + drivers/net/wireless/realtek/rtw88/rtw8822b.h | 8 +++++++- + 2 files changed, 16 insertions(+), 1 deletion(-) + +--- a/drivers/net/wireless/realtek/rtw88/rtw8822b.c ++++ b/drivers/net/wireless/realtek/rtw88/rtw8822b.c +@@ -32,6 +32,12 @@ static void rtw8822bu_efuse_parsing(stru + ether_addr_copy(efuse->addr, map->u.mac_addr); + } + ++static void rtw8822bs_efuse_parsing(struct rtw_efuse *efuse, ++ struct rtw8822b_efuse *map) ++{ ++ ether_addr_copy(efuse->addr, map->s.mac_addr); ++} ++ + static int rtw8822b_read_efuse(struct rtw_dev *rtwdev, u8 *log_map) + { + struct rtw_efuse *efuse = &rtwdev->efuse; +@@ -65,6 +71,9 @@ static int rtw8822b_read_efuse(struct rt + case RTW_HCI_TYPE_USB: + rtw8822bu_efuse_parsing(efuse, map); + break; ++ case RTW_HCI_TYPE_SDIO: ++ rtw8822bs_efuse_parsing(efuse, map); ++ break; + default: + /* unsupported now */ + return -ENOTSUPP; +--- a/drivers/net/wireless/realtek/rtw88/rtw8822b.h ++++ b/drivers/net/wireless/realtek/rtw88/rtw8822b.h +@@ -65,6 +65,11 @@ struct rtw8822be_efuse { + u8 res7; + }; + ++struct rtw8822bs_efuse { ++ u8 res4[0x4a]; /* 0xd0 */ ++ u8 mac_addr[ETH_ALEN]; /* 0x11a */ ++} __packed; ++ + struct rtw8822b_efuse { + __le16 rtl_id; + u8 res0[0x0e]; +@@ -92,8 +97,9 @@ struct rtw8822b_efuse { + u8 country_code[2]; + u8 res[3]; + union { +- struct rtw8822bu_efuse u; + struct rtw8822be_efuse e; ++ struct rtw8822bu_efuse u; ++ struct rtw8822bs_efuse s; + }; + }; + diff --git a/package/kernel/mac80211/patches/rtl/021-58-wifi-rtw88-rtw8822c-Implement-RTL8822CS-SDIO-efuse-p.patch b/package/kernel/mac80211/patches/rtl/021-58-wifi-rtw88-rtw8822c-Implement-RTL8822CS-SDIO-efuse-p.patch new file mode 100644 index 0000000000..b09f16d9bd --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/021-58-wifi-rtw88-rtw8822c-Implement-RTL8822CS-SDIO-efuse-p.patch @@ -0,0 +1,69 @@ +From ad0a677bce20c7fa2e8af3fd7f23c0686018202b Mon Sep 17 00:00:00 2001 +From: Martin Blumenstingl +Date: Sat, 18 Feb 2023 16:29:44 +0100 +Subject: [PATCH 58/85] wifi: rtw88: rtw8822c: Implement RTL8822CS (SDIO) efuse + parsing + +The efuse of the SDIO RTL8822CS chip has only one known member: the mac +address is at offset 0x16a. Add a struct rtw8822cs_efuse describing this +and use it for copying the mac address when the SDIO bus is used. + +Signed-off-by: Martin Blumenstingl +Reviewed-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230218152944.48842-6-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/rtw8822c.c | 9 +++++++++ + drivers/net/wireless/realtek/rtw88/rtw8822c.h | 8 +++++++- + 2 files changed, 16 insertions(+), 1 deletion(-) + +--- a/drivers/net/wireless/realtek/rtw88/rtw8822c.c ++++ b/drivers/net/wireless/realtek/rtw88/rtw8822c.c +@@ -35,6 +35,12 @@ static void rtw8822cu_efuse_parsing(stru + ether_addr_copy(efuse->addr, map->u.mac_addr); + } + ++static void rtw8822cs_efuse_parsing(struct rtw_efuse *efuse, ++ struct rtw8822c_efuse *map) ++{ ++ ether_addr_copy(efuse->addr, map->s.mac_addr); ++} ++ + static int rtw8822c_read_efuse(struct rtw_dev *rtwdev, u8 *log_map) + { + struct rtw_efuse *efuse = &rtwdev->efuse; +@@ -67,6 +73,9 @@ static int rtw8822c_read_efuse(struct rt + case RTW_HCI_TYPE_USB: + rtw8822cu_efuse_parsing(efuse, map); + break; ++ case RTW_HCI_TYPE_SDIO: ++ rtw8822cs_efuse_parsing(efuse, map); ++ break; + default: + /* unsupported now */ + return -ENOTSUPP; +--- a/drivers/net/wireless/realtek/rtw88/rtw8822c.h ++++ b/drivers/net/wireless/realtek/rtw88/rtw8822c.h +@@ -16,6 +16,11 @@ struct rtw8822cu_efuse { + u8 res2[0x3d]; + }; + ++struct rtw8822cs_efuse { ++ u8 res0[0x4a]; /* 0x120 */ ++ u8 mac_addr[ETH_ALEN]; /* 0x16a */ ++} __packed; ++ + struct rtw8822ce_efuse { + u8 mac_addr[ETH_ALEN]; /* 0x120 */ + u8 vender_id[2]; +@@ -91,8 +96,9 @@ struct rtw8822c_efuse { + u8 res9; + u8 res10[0x42]; + union { +- struct rtw8822cu_efuse u; + struct rtw8822ce_efuse e; ++ struct rtw8822cu_efuse u; ++ struct rtw8822cs_efuse s; + }; + }; + diff --git a/package/kernel/mac80211/patches/rtl/021-59-wifi-rtw88-mac-Return-the-original-error-from-rtw_pw.patch b/package/kernel/mac80211/patches/rtl/021-59-wifi-rtw88-mac-Return-the-original-error-from-rtw_pw.patch new file mode 100644 index 0000000000..6417ea8ef5 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/021-59-wifi-rtw88-mac-Return-the-original-error-from-rtw_pw.patch @@ -0,0 +1,30 @@ +From b7ed9fa2cb76ca7a3c3cd4a6d35748fe1fbda9f6 Mon Sep 17 00:00:00 2001 +From: Martin Blumenstingl +Date: Sun, 26 Feb 2023 23:10:03 +0100 +Subject: [PATCH 59/85] wifi: rtw88: mac: Return the original error from + rtw_pwr_seq_parser() + +rtw_pwr_seq_parser() calls rtw_sub_pwr_seq_parser() which can either +return -EBUSY, -EINVAL or 0. Propagate the original error code instead +of unconditionally returning -EBUSY in case of an error. + +Fixes: e3037485c68e ("rtw88: new Realtek 802.11ac driver") +Signed-off-by: Martin Blumenstingl +Reviewed-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230226221004.138331-2-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/mac.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +--- a/drivers/net/wireless/realtek/rtw88/mac.c ++++ b/drivers/net/wireless/realtek/rtw88/mac.c +@@ -236,7 +236,7 @@ static int rtw_pwr_seq_parser(struct rtw + + ret = rtw_sub_pwr_seq_parser(rtwdev, intf_mask, cut_mask, cmd); + if (ret) +- return -EBUSY; ++ return ret; + + idx++; + } while (1); diff --git a/package/kernel/mac80211/patches/rtl/021-60-wifi-rtw88-mac-Return-the-original-error-from-rtw_ma.patch b/package/kernel/mac80211/patches/rtl/021-60-wifi-rtw88-mac-Return-the-original-error-from-rtw_ma.patch new file mode 100644 index 0000000000..c867fc4039 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/021-60-wifi-rtw88-mac-Return-the-original-error-from-rtw_ma.patch @@ -0,0 +1,41 @@ +From 15c8e267dfa62f207ee1db666c822324e3362b84 Mon Sep 17 00:00:00 2001 +From: Martin Blumenstingl +Date: Sun, 26 Feb 2023 23:10:04 +0100 +Subject: [PATCH 60/85] wifi: rtw88: mac: Return the original error from + rtw_mac_power_switch() + +rtw_mac_power_switch() calls rtw_pwr_seq_parser() which can return +-EINVAL, -EBUSY or 0. Propagate the original error code instead of +unconditionally returning -EINVAL in case of an error. + +Fixes: e3037485c68e ("rtw88: new Realtek 802.11ac driver") +Signed-off-by: Martin Blumenstingl +Reviewed-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230226221004.138331-3-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/mac.c | 6 ++++-- + 1 file changed, 4 insertions(+), 2 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/mac.c ++++ b/drivers/net/wireless/realtek/rtw88/mac.c +@@ -250,6 +250,7 @@ static int rtw_mac_power_switch(struct r + const struct rtw_pwr_seq_cmd **pwr_seq; + u8 rpwm; + bool cur_pwr; ++ int ret; + + if (rtw_chip_wcpu_11ac(rtwdev)) { + rpwm = rtw_read8(rtwdev, rtwdev->hci.rpwm_addr); +@@ -273,8 +274,9 @@ static int rtw_mac_power_switch(struct r + return -EALREADY; + + pwr_seq = pwr_on ? chip->pwr_on_seq : chip->pwr_off_seq; +- if (rtw_pwr_seq_parser(rtwdev, pwr_seq)) +- return -EINVAL; ++ ret = rtw_pwr_seq_parser(rtwdev, pwr_seq); ++ if (ret) ++ return ret; + + if (pwr_on) + set_bit(RTW_FLAG_POWERON, rtwdev->flags); diff --git a/package/kernel/mac80211/patches/rtl/022-wifi-rtw88-remove-unused-rtw_pci_get_tx_desc-functio.patch b/package/kernel/mac80211/patches/rtl/022-wifi-rtw88-remove-unused-rtw_pci_get_tx_desc-functio.patch new file mode 100644 index 0000000000..1d1cf9d97e --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/022-wifi-rtw88-remove-unused-rtw_pci_get_tx_desc-functio.patch @@ -0,0 +1,36 @@ +From c9b6111a6f94bd186d1f0f7a04a9b37030a27738 Mon Sep 17 00:00:00 2001 +From: Tom Rix +Date: Mon, 20 Mar 2023 19:34:48 -0400 +Subject: [PATCH 22/45] wifi: rtw88: remove unused rtw_pci_get_tx_desc function + +clang with W=1 reports +drivers/net/wireless/realtek/rtw88/pci.c:92:21: error: + unused function 'rtw_pci_get_tx_desc' [-Werror,-Wunused-function] +static inline void *rtw_pci_get_tx_desc(struct rtw_pci_tx_ring *tx_ring, u8 idx) + ^ +This function is not used, so remove it. + +Signed-off-by: Tom Rix +Reviewed-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230320233448.1729899-1-trix@redhat.com +--- + drivers/net/wireless/realtek/rtw88/pci.c | 7 ------- + 1 file changed, 7 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/pci.c ++++ b/drivers/net/wireless/realtek/rtw88/pci.c +@@ -89,13 +89,6 @@ static void rtw_pci_write32(struct rtw_d + writel(val, rtwpci->mmap + addr); + } + +-static inline void *rtw_pci_get_tx_desc(struct rtw_pci_tx_ring *tx_ring, u8 idx) +-{ +- int offset = tx_ring->r.desc_size * idx; +- +- return tx_ring->r.head + offset; +-} +- + static void rtw_pci_free_tx_ring_skbs(struct rtw_dev *rtwdev, + struct rtw_pci_tx_ring *tx_ring) + { diff --git a/package/kernel/mac80211/patches/rtl/023-wifi-rtw88-Remove-redundant-pci_clear_master.patch b/package/kernel/mac80211/patches/rtl/023-wifi-rtw88-Remove-redundant-pci_clear_master.patch new file mode 100644 index 0000000000..790581b9fb --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/023-wifi-rtw88-Remove-redundant-pci_clear_master.patch @@ -0,0 +1,42 @@ +From e665c6d67e541ac7520fa8c5175ad2c0213f247e Mon Sep 17 00:00:00 2001 +From: Cai Huoqing +Date: Thu, 23 Mar 2023 19:26:12 +0800 +Subject: [PATCH 23/45] wifi: rtw88: Remove redundant pci_clear_master + +Remove pci_clear_master to simplify the code, +the bus-mastering is also cleared in do_pci_disable_device, +like this: +./drivers/pci/pci.c:2197 +static void do_pci_disable_device(struct pci_dev *dev) +{ + u16 pci_command; + + pci_read_config_word(dev, PCI_COMMAND, &pci_command); + if (pci_command & PCI_COMMAND_MASTER) { + pci_command &= ~PCI_COMMAND_MASTER; + pci_write_config_word(dev, PCI_COMMAND, pci_command); + } + + pcibios_disable_device(dev); +}. +And dev->is_busmaster is set to 0 in pci_disable_device. + +Signed-off-by: Cai Huoqing +Reviewed-by: Simon Horman +Reviewed-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230323112613.7550-4-cai.huoqing@linux.dev +--- + drivers/net/wireless/realtek/rtw88/pci.c | 1 - + 1 file changed, 1 deletion(-) + +--- a/drivers/net/wireless/realtek/rtw88/pci.c ++++ b/drivers/net/wireless/realtek/rtw88/pci.c +@@ -1545,7 +1545,6 @@ static int rtw_pci_claim(struct rtw_dev + + static void rtw_pci_declaim(struct rtw_dev *rtwdev, struct pci_dev *pdev) + { +- pci_clear_master(pdev); + pci_disable_device(pdev); + } + diff --git a/package/kernel/mac80211/patches/rtl/024-wifi-rtw88-Clear-RTW_FLAG_POWERON-early-in-rtw_mac_p.patch b/package/kernel/mac80211/patches/rtl/024-wifi-rtw88-Clear-RTW_FLAG_POWERON-early-in-rtw_mac_p.patch new file mode 100644 index 0000000000..9df21636b7 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/024-wifi-rtw88-Clear-RTW_FLAG_POWERON-early-in-rtw_mac_p.patch @@ -0,0 +1,60 @@ +From 6a92566088b1a37c1cf2c4b6b5fb733dc5bdc6a6 Mon Sep 17 00:00:00 2001 +From: Martin Blumenstingl +Date: Wed, 5 Apr 2023 22:07:21 +0200 +Subject: [PATCH 24/45] wifi: rtw88: Clear RTW_FLAG_POWERON early in + rtw_mac_power_switch() + +The SDIO HCI implementation needs to know when the MAC is powered on. +This is needed because 32-bit register access has to be split into 4x +8-bit register access when the MAC is not fully powered on or while +powering off. When the MAC is powered on 32-bit register access can be +used to reduce the number of transfers but splitting into 4x 8-bit +register access still works in that case. + +During the power on sequence is how RTW_FLAG_POWERON is only set when +the power on sequence has completed successfully. During power off +however RTW_FLAG_POWERON is set. This means that the upcoming SDIO HCI +implementation does not know that it has to use 4x 8-bit register +accessors. Clear the RTW_FLAG_POWERON flag early when powering off the +MAC so the whole power off sequence is processed with RTW_FLAG_POWERON +unset. This will make it possible to use the RTW_FLAG_POWERON flag in +the upcoming SDIO HCI implementation. + +Note that a failure in rtw_pwr_seq_parser() while applying +chip->pwr_off_seq can theoretically result in the RTW_FLAG_POWERON +flag being cleared while the chip is still powered on. However, +depending on when the failure occurs in the power off sequence the +chip may be on or off. Even the original approach of clearing +RTW_FLAG_POWERON only when the power off sequence has been applied +successfully could end up in some corner case where the chip is +powered off but RTW_FLAG_POWERON was not cleared. + +Reviewed-by: Ping-Ke Shih +Signed-off-by: Martin Blumenstingl +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230405200729.632435-2-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/mac.c | 5 +++-- + 1 file changed, 3 insertions(+), 2 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/mac.c ++++ b/drivers/net/wireless/realtek/rtw88/mac.c +@@ -273,6 +273,9 @@ static int rtw_mac_power_switch(struct r + if (pwr_on == cur_pwr) + return -EALREADY; + ++ if (!pwr_on) ++ clear_bit(RTW_FLAG_POWERON, rtwdev->flags); ++ + pwr_seq = pwr_on ? chip->pwr_on_seq : chip->pwr_off_seq; + ret = rtw_pwr_seq_parser(rtwdev, pwr_seq); + if (ret) +@@ -280,8 +283,6 @@ static int rtw_mac_power_switch(struct r + + if (pwr_on) + set_bit(RTW_FLAG_POWERON, rtwdev->flags); +- else +- clear_bit(RTW_FLAG_POWERON, rtwdev->flags); + + return 0; + } diff --git a/package/kernel/mac80211/patches/rtl/025-wifi-rtw88-sdio-Add-HCI-implementation-for-SDIO-base.patch b/package/kernel/mac80211/patches/rtl/025-wifi-rtw88-sdio-Add-HCI-implementation-for-SDIO-base.patch new file mode 100644 index 0000000000..9401f20ad3 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/025-wifi-rtw88-sdio-Add-HCI-implementation-for-SDIO-base.patch @@ -0,0 +1,1719 @@ +From 65371a3f14e73979958aea0db1e3bb456a296149 Mon Sep 17 00:00:00 2001 +From: Martin Blumenstingl +Date: Wed, 5 Apr 2023 22:07:22 +0200 +Subject: [PATCH 25/45] wifi: rtw88: sdio: Add HCI implementation for SDIO + based chipsets + +Add a sub-driver for SDIO based chipsets which implements the following +functionality: +- register accessors for 8, 16 and 32 bits for all states of the card + (including usage of 4x 8 bit access for one 32 bit buffer if the card + is not fully powered on yet - or if it's fully powered on then 1x 32 + bit access is used) +- checking whether there's space in the TX FIFO queue to transmit data +- transfers from the host to the device for actual network traffic, + reserved pages (for firmware download) and H2C (host-to-card) + transfers +- receiving data from the device +- deep power saving state + +The transmit path is optimized so DMA-capable SDIO host controllers can +directly use the buffers provided because the buffer's physical +addresses are 8 byte aligned. + +The receive path is prepared to support RX aggregation where the +chipset combines multiple MAC frames into one bigger buffer to reduce +SDIO transfer overhead. + +Co-developed-by: Jernej Skrabec +Signed-off-by: Jernej Skrabec +Reviewed-by: Ulf Hansson +Signed-off-by: Martin Blumenstingl +Reviewed-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230405200729.632435-3-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/Kconfig | 3 + + drivers/net/wireless/realtek/rtw88/Makefile | 3 + + drivers/net/wireless/realtek/rtw88/debug.h | 1 + + drivers/net/wireless/realtek/rtw88/mac.c | 1 + + drivers/net/wireless/realtek/rtw88/mac.h | 1 - + drivers/net/wireless/realtek/rtw88/reg.h | 12 + + drivers/net/wireless/realtek/rtw88/sdio.c | 1394 +++++++++++++++++++ + drivers/net/wireless/realtek/rtw88/sdio.h | 178 +++ + 8 files changed, 1592 insertions(+), 1 deletion(-) + create mode 100644 drivers/net/wireless/realtek/rtw88/sdio.c + create mode 100644 drivers/net/wireless/realtek/rtw88/sdio.h + +--- a/drivers/net/wireless/realtek/rtw88/Kconfig ++++ b/drivers/net/wireless/realtek/rtw88/Kconfig +@@ -19,6 +19,11 @@ config RTW88_PCI + tristate + depends on m + ++config RTW88_SDIO ++ tristate ++ depends on m ++ ++ + config RTW88_USB + tristate + depends on m +--- a/drivers/net/wireless/realtek/rtw88/Makefile ++++ b/drivers/net/wireless/realtek/rtw88/Makefile +@@ -59,5 +59,8 @@ rtw88_8821cu-objs := rtw8821cu.o + obj-$(CPTCFG_RTW88_PCI) += rtw88_pci.o + rtw88_pci-objs := pci.o + ++obj-$(CPTCFG_RTW88_SDIO) += rtw88_sdio.o ++rtw88_sdio-objs := sdio.o ++ + obj-$(CPTCFG_RTW88_USB) += rtw88_usb.o + rtw88_usb-objs := usb.o +--- a/drivers/net/wireless/realtek/rtw88/debug.h ++++ b/drivers/net/wireless/realtek/rtw88/debug.h +@@ -24,6 +24,7 @@ enum rtw_debug_mask { + RTW_DBG_ADAPTIVITY = 0x00008000, + RTW_DBG_HW_SCAN = 0x00010000, + RTW_DBG_STATE = 0x00020000, ++ RTW_DBG_SDIO = 0x00040000, + + RTW_DBG_ALL = 0xffffffff + }; +--- a/drivers/net/wireless/realtek/rtw88/mac.c ++++ b/drivers/net/wireless/realtek/rtw88/mac.c +@@ -7,6 +7,7 @@ + #include "reg.h" + #include "fw.h" + #include "debug.h" ++#include "sdio.h" + + void rtw_set_channel_mac(struct rtw_dev *rtwdev, u8 channel, u8 bw, + u8 primary_ch_idx) +--- a/drivers/net/wireless/realtek/rtw88/mac.h ++++ b/drivers/net/wireless/realtek/rtw88/mac.h +@@ -7,7 +7,6 @@ + + #define RTW_HW_PORT_NUM 5 + #define cut_version_to_mask(cut) (0x1 << ((cut) + 1)) +-#define SDIO_LOCAL_OFFSET 0x10250000 + #define DDMA_POLLING_COUNT 1000 + #define C2H_PKT_BUF 256 + #define REPORT_BUF 128 +--- a/drivers/net/wireless/realtek/rtw88/reg.h ++++ b/drivers/net/wireless/realtek/rtw88/reg.h +@@ -87,6 +87,7 @@ + #define BIT_LTE_MUX_CTRL_PATH BIT(26) + #define REG_HCI_OPT_CTRL 0x0074 + #define BIT_USB_SUS_DIS BIT(8) ++#define BIT_SDIO_PAD_E5 BIT(18) + + #define REG_AFE_CTRL_4 0x0078 + #define BIT_CK320M_AFE_EN BIT(4) +@@ -185,6 +186,9 @@ + (((x) & BIT_MASK_TXDMA_VIQ_MAP) << BIT_SHIFT_TXDMA_VIQ_MAP) + #define REG_TXDMA_PQ_MAP 0x010C + #define BIT_RXDMA_ARBBW_EN BIT(0) ++#define BIT_RXSHFT_EN BIT(1) ++#define BIT_RXDMA_AGG_EN BIT(2) ++#define BIT_TXDMA_BW_EN BIT(3) + #define BIT_SHIFT_TXDMA_BEQ_MAP 8 + #define BIT_MASK_TXDMA_BEQ_MAP 0x3 + #define BIT_TXDMA_BEQ_MAP(x) \ +@@ -283,10 +287,18 @@ + #define REG_H2C_TAIL 0x0248 + #define REG_H2C_READ_ADDR 0x024C + #define REG_H2C_INFO 0x0254 ++#define REG_RXDMA_AGG_PG_TH 0x0280 ++#define BIT_RXDMA_AGG_PG_TH GENMASK(7, 0) ++#define BIT_DMA_AGG_TO_V1 GENMASK(15, 8) ++#define BIT_EN_PRE_CALC BIT(29) + #define REG_RXPKT_NUM 0x0284 + #define BIT_RXDMA_REQ BIT(19) + #define BIT_RW_RELEASE BIT(18) + #define BIT_RXDMA_IDLE BIT(17) ++#define REG_RXDMA_STATUS 0x0288 ++#define REG_RXDMA_DPR 0x028C ++#define REG_RXDMA_MODE 0x0290 ++#define BIT_DMA_MODE BIT(1) + #define REG_RXPKTNUM 0x02B0 + + #define REG_INT_MIG 0x0304 +--- /dev/null ++++ b/drivers/net/wireless/realtek/rtw88/sdio.c +@@ -0,0 +1,1394 @@ ++// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause ++/* Copyright (C) 2021 Martin Blumenstingl ++ * Copyright (C) 2021 Jernej Skrabec ++ * ++ * Based on rtw88/pci.c: ++ * Copyright(c) 2018-2019 Realtek Corporation ++ */ ++ ++#include ++#include ++#include ++#include "main.h" ++#include "debug.h" ++#include "fw.h" ++#include "ps.h" ++#include "reg.h" ++#include "rx.h" ++#include "sdio.h" ++#include "tx.h" ++ ++#define RTW_SDIO_INDIRECT_RW_RETRIES 50 ++ ++static bool rtw_sdio_is_bus_addr(u32 addr) ++{ ++ return !!(addr & RTW_SDIO_BUS_MSK); ++} ++ ++static bool rtw_sdio_bus_claim_needed(struct rtw_sdio *rtwsdio) ++{ ++ return !rtwsdio->irq_thread || ++ rtwsdio->irq_thread != current; ++} ++ ++static u32 rtw_sdio_to_bus_offset(struct rtw_dev *rtwdev, u32 addr) ++{ ++ switch (addr & RTW_SDIO_BUS_MSK) { ++ case WLAN_IOREG_OFFSET: ++ addr &= WLAN_IOREG_REG_MSK; ++ addr |= FIELD_PREP(REG_SDIO_CMD_ADDR_MSK, ++ REG_SDIO_CMD_ADDR_MAC_REG); ++ break; ++ case SDIO_LOCAL_OFFSET: ++ addr &= SDIO_LOCAL_REG_MSK; ++ addr |= FIELD_PREP(REG_SDIO_CMD_ADDR_MSK, ++ REG_SDIO_CMD_ADDR_SDIO_REG); ++ break; ++ default: ++ rtw_warn(rtwdev, "Cannot convert addr 0x%08x to bus offset", ++ addr); ++ } ++ ++ return addr; ++} ++ ++static bool rtw_sdio_use_memcpy_io(struct rtw_dev *rtwdev, u32 addr, ++ u8 alignment) ++{ ++ return IS_ALIGNED(addr, alignment) && ++ test_bit(RTW_FLAG_POWERON, rtwdev->flags); ++} ++ ++static void rtw_sdio_writel(struct rtw_dev *rtwdev, u32 val, u32 addr, ++ int *err_ret) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ u8 buf[4]; ++ int i; ++ ++ if (rtw_sdio_use_memcpy_io(rtwdev, addr, 4)) { ++ sdio_writel(rtwsdio->sdio_func, val, addr, err_ret); ++ return; ++ } ++ ++ *(__le32 *)buf = cpu_to_le32(val); ++ ++ for (i = 0; i < 4; i++) { ++ sdio_writeb(rtwsdio->sdio_func, buf[i], addr + i, err_ret); ++ if (*err_ret) ++ return; ++ } ++} ++ ++static void rtw_sdio_writew(struct rtw_dev *rtwdev, u16 val, u32 addr, ++ int *err_ret) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ u8 buf[2]; ++ int i; ++ ++ if (rtw_sdio_use_memcpy_io(rtwdev, addr, 2)) { ++ sdio_writew(rtwsdio->sdio_func, val, addr, err_ret); ++ return; ++ } ++ ++ *(__le16 *)buf = cpu_to_le16(val); ++ ++ for (i = 0; i < 2; i++) { ++ sdio_writeb(rtwsdio->sdio_func, buf[i], addr + i, err_ret); ++ if (*err_ret) ++ return; ++ } ++} ++ ++static u32 rtw_sdio_readl(struct rtw_dev *rtwdev, u32 addr, int *err_ret) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ u8 buf[4]; ++ int i; ++ ++ if (rtw_sdio_use_memcpy_io(rtwdev, addr, 4)) ++ return sdio_readl(rtwsdio->sdio_func, addr, err_ret); ++ ++ for (i = 0; i < 4; i++) { ++ buf[i] = sdio_readb(rtwsdio->sdio_func, addr + i, err_ret); ++ if (*err_ret) ++ return 0; ++ } ++ ++ return le32_to_cpu(*(__le32 *)buf); ++} ++ ++static u16 rtw_sdio_readw(struct rtw_dev *rtwdev, u32 addr, int *err_ret) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ u8 buf[2]; ++ int i; ++ ++ if (rtw_sdio_use_memcpy_io(rtwdev, addr, 2)) ++ return sdio_readw(rtwsdio->sdio_func, addr, err_ret); ++ ++ for (i = 0; i < 2; i++) { ++ buf[i] = sdio_readb(rtwsdio->sdio_func, addr + i, err_ret); ++ if (*err_ret) ++ return 0; ++ } ++ ++ return le16_to_cpu(*(__le16 *)buf); ++} ++ ++static u32 rtw_sdio_to_io_address(struct rtw_dev *rtwdev, u32 addr, ++ bool direct) ++{ ++ if (!direct) ++ return addr; ++ ++ if (!rtw_sdio_is_bus_addr(addr)) ++ addr |= WLAN_IOREG_OFFSET; ++ ++ return rtw_sdio_to_bus_offset(rtwdev, addr); ++} ++ ++static bool rtw_sdio_use_direct_io(struct rtw_dev *rtwdev, u32 addr) ++{ ++ return !rtw_sdio_is_sdio30_supported(rtwdev) || ++ rtw_sdio_is_bus_addr(addr); ++} ++ ++static int rtw_sdio_indirect_reg_cfg(struct rtw_dev *rtwdev, u32 addr, u32 cfg) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ unsigned int retry; ++ u32 reg_cfg; ++ int ret; ++ u8 tmp; ++ ++ reg_cfg = rtw_sdio_to_bus_offset(rtwdev, REG_SDIO_INDIRECT_REG_CFG); ++ ++ rtw_sdio_writel(rtwdev, addr | cfg | BIT_SDIO_INDIRECT_REG_CFG_UNK20, ++ reg_cfg, &ret); ++ if (ret) ++ return ret; ++ ++ for (retry = 0; retry < RTW_SDIO_INDIRECT_RW_RETRIES; retry++) { ++ tmp = sdio_readb(rtwsdio->sdio_func, reg_cfg + 2, &ret); ++ if (!ret && (tmp & BIT(4))) ++ return 0; ++ } ++ ++ return -ETIMEDOUT; ++} ++ ++static u8 rtw_sdio_indirect_read8(struct rtw_dev *rtwdev, u32 addr, ++ int *err_ret) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ u32 reg_data; ++ ++ *err_ret = rtw_sdio_indirect_reg_cfg(rtwdev, addr, ++ BIT_SDIO_INDIRECT_REG_CFG_READ); ++ if (*err_ret) ++ return 0; ++ ++ reg_data = rtw_sdio_to_bus_offset(rtwdev, REG_SDIO_INDIRECT_REG_DATA); ++ return sdio_readb(rtwsdio->sdio_func, reg_data, err_ret); ++} ++ ++static int rtw_sdio_indirect_read_bytes(struct rtw_dev *rtwdev, u32 addr, ++ u8 *buf, int count) ++{ ++ int i, ret = 0; ++ ++ for (i = 0; i < count; i++) { ++ buf[i] = rtw_sdio_indirect_read8(rtwdev, addr + i, &ret); ++ if (ret) ++ break; ++ } ++ ++ return ret; ++} ++ ++static u16 rtw_sdio_indirect_read16(struct rtw_dev *rtwdev, u32 addr, ++ int *err_ret) ++{ ++ u32 reg_data; ++ u8 buf[2]; ++ ++ if (!IS_ALIGNED(addr, 2)) { ++ *err_ret = rtw_sdio_indirect_read_bytes(rtwdev, addr, buf, 2); ++ if (*err_ret) ++ return 0; ++ ++ return le16_to_cpu(*(__le16 *)buf); ++ } ++ ++ *err_ret = rtw_sdio_indirect_reg_cfg(rtwdev, addr, ++ BIT_SDIO_INDIRECT_REG_CFG_READ); ++ if (*err_ret) ++ return 0; ++ ++ reg_data = rtw_sdio_to_bus_offset(rtwdev, REG_SDIO_INDIRECT_REG_DATA); ++ return rtw_sdio_readw(rtwdev, reg_data, err_ret); ++} ++ ++static u32 rtw_sdio_indirect_read32(struct rtw_dev *rtwdev, u32 addr, ++ int *err_ret) ++{ ++ u32 reg_data; ++ u8 buf[4]; ++ ++ if (!IS_ALIGNED(addr, 4)) { ++ *err_ret = rtw_sdio_indirect_read_bytes(rtwdev, addr, buf, 4); ++ if (*err_ret) ++ return 0; ++ ++ return le32_to_cpu(*(__le32 *)buf); ++ } ++ ++ *err_ret = rtw_sdio_indirect_reg_cfg(rtwdev, addr, ++ BIT_SDIO_INDIRECT_REG_CFG_READ); ++ if (*err_ret) ++ return 0; ++ ++ reg_data = rtw_sdio_to_bus_offset(rtwdev, REG_SDIO_INDIRECT_REG_DATA); ++ return rtw_sdio_readl(rtwdev, reg_data, err_ret); ++} ++ ++static u8 rtw_sdio_read8(struct rtw_dev *rtwdev, u32 addr) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ bool direct, bus_claim; ++ int ret; ++ u8 val; ++ ++ direct = rtw_sdio_use_direct_io(rtwdev, addr); ++ addr = rtw_sdio_to_io_address(rtwdev, addr, direct); ++ bus_claim = rtw_sdio_bus_claim_needed(rtwsdio); ++ ++ if (bus_claim) ++ sdio_claim_host(rtwsdio->sdio_func); ++ ++ if (direct) ++ val = sdio_readb(rtwsdio->sdio_func, addr, &ret); ++ else ++ val = rtw_sdio_indirect_read8(rtwdev, addr, &ret); ++ ++ if (bus_claim) ++ sdio_release_host(rtwsdio->sdio_func); ++ ++ if (ret) ++ rtw_warn(rtwdev, "sdio read8 failed (0x%x): %d", addr, ret); ++ ++ return val; ++} ++ ++static u16 rtw_sdio_read16(struct rtw_dev *rtwdev, u32 addr) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ bool direct, bus_claim; ++ int ret; ++ u16 val; ++ ++ direct = rtw_sdio_use_direct_io(rtwdev, addr); ++ addr = rtw_sdio_to_io_address(rtwdev, addr, direct); ++ bus_claim = rtw_sdio_bus_claim_needed(rtwsdio); ++ ++ if (bus_claim) ++ sdio_claim_host(rtwsdio->sdio_func); ++ ++ if (direct) ++ val = rtw_sdio_readw(rtwdev, addr, &ret); ++ else ++ val = rtw_sdio_indirect_read16(rtwdev, addr, &ret); ++ ++ if (bus_claim) ++ sdio_release_host(rtwsdio->sdio_func); ++ ++ if (ret) ++ rtw_warn(rtwdev, "sdio read16 failed (0x%x): %d", addr, ret); ++ ++ return val; ++} ++ ++static u32 rtw_sdio_read32(struct rtw_dev *rtwdev, u32 addr) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ bool direct, bus_claim; ++ u32 val; ++ int ret; ++ ++ direct = rtw_sdio_use_direct_io(rtwdev, addr); ++ addr = rtw_sdio_to_io_address(rtwdev, addr, direct); ++ bus_claim = rtw_sdio_bus_claim_needed(rtwsdio); ++ ++ if (bus_claim) ++ sdio_claim_host(rtwsdio->sdio_func); ++ ++ if (direct) ++ val = rtw_sdio_readl(rtwdev, addr, &ret); ++ else ++ val = rtw_sdio_indirect_read32(rtwdev, addr, &ret); ++ ++ if (bus_claim) ++ sdio_release_host(rtwsdio->sdio_func); ++ ++ if (ret) ++ rtw_warn(rtwdev, "sdio read32 failed (0x%x): %d", addr, ret); ++ ++ return val; ++} ++ ++static void rtw_sdio_indirect_write8(struct rtw_dev *rtwdev, u8 val, u32 addr, ++ int *err_ret) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ u32 reg_data; ++ ++ reg_data = rtw_sdio_to_bus_offset(rtwdev, REG_SDIO_INDIRECT_REG_DATA); ++ sdio_writeb(rtwsdio->sdio_func, val, reg_data, err_ret); ++ if (*err_ret) ++ return; ++ ++ *err_ret = rtw_sdio_indirect_reg_cfg(rtwdev, addr, ++ BIT_SDIO_INDIRECT_REG_CFG_WRITE); ++} ++ ++static void rtw_sdio_indirect_write16(struct rtw_dev *rtwdev, u16 val, u32 addr, ++ int *err_ret) ++{ ++ u32 reg_data; ++ ++ if (!IS_ALIGNED(addr, 2)) { ++ addr = rtw_sdio_to_io_address(rtwdev, addr, true); ++ rtw_sdio_writew(rtwdev, val, addr, err_ret); ++ return; ++ } ++ ++ reg_data = rtw_sdio_to_bus_offset(rtwdev, REG_SDIO_INDIRECT_REG_DATA); ++ rtw_sdio_writew(rtwdev, val, reg_data, err_ret); ++ if (*err_ret) ++ return; ++ ++ *err_ret = rtw_sdio_indirect_reg_cfg(rtwdev, addr, ++ BIT_SDIO_INDIRECT_REG_CFG_WRITE | ++ BIT_SDIO_INDIRECT_REG_CFG_WORD); ++} ++ ++static void rtw_sdio_indirect_write32(struct rtw_dev *rtwdev, u32 val, ++ u32 addr, int *err_ret) ++{ ++ u32 reg_data; ++ ++ if (!IS_ALIGNED(addr, 4)) { ++ addr = rtw_sdio_to_io_address(rtwdev, addr, true); ++ rtw_sdio_writel(rtwdev, val, addr, err_ret); ++ return; ++ } ++ ++ reg_data = rtw_sdio_to_bus_offset(rtwdev, REG_SDIO_INDIRECT_REG_DATA); ++ rtw_sdio_writel(rtwdev, val, reg_data, err_ret); ++ ++ *err_ret = rtw_sdio_indirect_reg_cfg(rtwdev, addr, ++ BIT_SDIO_INDIRECT_REG_CFG_WRITE | ++ BIT_SDIO_INDIRECT_REG_CFG_DWORD); ++} ++ ++static void rtw_sdio_write8(struct rtw_dev *rtwdev, u32 addr, u8 val) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ bool direct, bus_claim; ++ int ret; ++ ++ direct = rtw_sdio_use_direct_io(rtwdev, addr); ++ addr = rtw_sdio_to_io_address(rtwdev, addr, direct); ++ bus_claim = rtw_sdio_bus_claim_needed(rtwsdio); ++ ++ if (bus_claim) ++ sdio_claim_host(rtwsdio->sdio_func); ++ ++ if (direct) ++ sdio_writeb(rtwsdio->sdio_func, val, addr, &ret); ++ else ++ rtw_sdio_indirect_write8(rtwdev, val, addr, &ret); ++ ++ if (bus_claim) ++ sdio_release_host(rtwsdio->sdio_func); ++ ++ if (ret) ++ rtw_warn(rtwdev, "sdio write8 failed (0x%x): %d", addr, ret); ++} ++ ++static void rtw_sdio_write16(struct rtw_dev *rtwdev, u32 addr, u16 val) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ bool direct, bus_claim; ++ int ret; ++ ++ direct = rtw_sdio_use_direct_io(rtwdev, addr); ++ addr = rtw_sdio_to_io_address(rtwdev, addr, direct); ++ bus_claim = rtw_sdio_bus_claim_needed(rtwsdio); ++ ++ if (bus_claim) ++ sdio_claim_host(rtwsdio->sdio_func); ++ ++ if (direct) ++ rtw_sdio_writew(rtwdev, val, addr, &ret); ++ else ++ rtw_sdio_indirect_write16(rtwdev, val, addr, &ret); ++ ++ if (bus_claim) ++ sdio_release_host(rtwsdio->sdio_func); ++ ++ if (ret) ++ rtw_warn(rtwdev, "sdio write16 failed (0x%x): %d", addr, ret); ++} ++ ++static void rtw_sdio_write32(struct rtw_dev *rtwdev, u32 addr, u32 val) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ bool direct, bus_claim; ++ int ret; ++ ++ direct = rtw_sdio_use_direct_io(rtwdev, addr); ++ addr = rtw_sdio_to_io_address(rtwdev, addr, direct); ++ bus_claim = rtw_sdio_bus_claim_needed(rtwsdio); ++ ++ if (bus_claim) ++ sdio_claim_host(rtwsdio->sdio_func); ++ ++ if (direct) ++ rtw_sdio_writel(rtwdev, val, addr, &ret); ++ else ++ rtw_sdio_indirect_write32(rtwdev, val, addr, &ret); ++ ++ if (bus_claim) ++ sdio_release_host(rtwsdio->sdio_func); ++ ++ if (ret) ++ rtw_warn(rtwdev, "sdio write32 failed (0x%x): %d", addr, ret); ++} ++ ++static u32 rtw_sdio_get_tx_addr(struct rtw_dev *rtwdev, size_t size, ++ enum rtw_tx_queue_type queue) ++{ ++ u32 txaddr; ++ ++ switch (queue) { ++ case RTW_TX_QUEUE_BCN: ++ case RTW_TX_QUEUE_H2C: ++ case RTW_TX_QUEUE_HI0: ++ txaddr = FIELD_PREP(REG_SDIO_CMD_ADDR_MSK, ++ REG_SDIO_CMD_ADDR_TXFF_HIGH); ++ break; ++ case RTW_TX_QUEUE_VI: ++ case RTW_TX_QUEUE_VO: ++ txaddr = FIELD_PREP(REG_SDIO_CMD_ADDR_MSK, ++ REG_SDIO_CMD_ADDR_TXFF_NORMAL); ++ break; ++ case RTW_TX_QUEUE_BE: ++ case RTW_TX_QUEUE_BK: ++ txaddr = FIELD_PREP(REG_SDIO_CMD_ADDR_MSK, ++ REG_SDIO_CMD_ADDR_TXFF_LOW); ++ break; ++ case RTW_TX_QUEUE_MGMT: ++ txaddr = FIELD_PREP(REG_SDIO_CMD_ADDR_MSK, ++ REG_SDIO_CMD_ADDR_TXFF_EXTRA); ++ break; ++ default: ++ rtw_warn(rtwdev, "Unsupported queue for TX addr: 0x%02x\n", ++ queue); ++ return 0; ++ } ++ ++ txaddr += DIV_ROUND_UP(size, 4); ++ ++ return txaddr; ++}; ++ ++static int rtw_sdio_read_port(struct rtw_dev *rtwdev, u8 *buf, size_t count) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ bool bus_claim = rtw_sdio_bus_claim_needed(rtwsdio); ++ u32 rxaddr = rtwsdio->rx_addr++; ++ int ret; ++ ++ if (bus_claim) ++ sdio_claim_host(rtwsdio->sdio_func); ++ ++ ret = sdio_memcpy_fromio(rtwsdio->sdio_func, buf, ++ RTW_SDIO_ADDR_RX_RX0FF_GEN(rxaddr), count); ++ if (ret) ++ rtw_warn(rtwdev, ++ "Failed to read %zu byte(s) from SDIO port 0x%08x", ++ count, rxaddr); ++ ++ if (bus_claim) ++ sdio_release_host(rtwsdio->sdio_func); ++ ++ return ret; ++} ++ ++static int rtw_sdio_check_free_txpg(struct rtw_dev *rtwdev, u8 queue, ++ size_t count) ++{ ++ unsigned int pages_free, pages_needed; ++ ++ if (rtw_chip_wcpu_11n(rtwdev)) { ++ u32 free_txpg; ++ ++ free_txpg = rtw_sdio_read32(rtwdev, REG_SDIO_FREE_TXPG); ++ ++ switch (queue) { ++ case RTW_TX_QUEUE_BCN: ++ case RTW_TX_QUEUE_H2C: ++ case RTW_TX_QUEUE_HI0: ++ case RTW_TX_QUEUE_MGMT: ++ /* high */ ++ pages_free = free_txpg & 0xff; ++ break; ++ case RTW_TX_QUEUE_VI: ++ case RTW_TX_QUEUE_VO: ++ /* normal */ ++ pages_free = (free_txpg >> 8) & 0xff; ++ break; ++ case RTW_TX_QUEUE_BE: ++ case RTW_TX_QUEUE_BK: ++ /* low */ ++ pages_free = (free_txpg >> 16) & 0xff; ++ break; ++ default: ++ rtw_warn(rtwdev, "Unknown mapping for queue %u\n", queue); ++ return -EINVAL; ++ } ++ ++ /* add the pages from the public queue */ ++ pages_free += (free_txpg >> 24) & 0xff; ++ } else { ++ u32 free_txpg[3]; ++ ++ free_txpg[0] = rtw_sdio_read32(rtwdev, REG_SDIO_FREE_TXPG); ++ free_txpg[1] = rtw_sdio_read32(rtwdev, REG_SDIO_FREE_TXPG + 4); ++ free_txpg[2] = rtw_sdio_read32(rtwdev, REG_SDIO_FREE_TXPG + 8); ++ ++ switch (queue) { ++ case RTW_TX_QUEUE_BCN: ++ case RTW_TX_QUEUE_H2C: ++ case RTW_TX_QUEUE_HI0: ++ /* high */ ++ pages_free = free_txpg[0] & 0xfff; ++ break; ++ case RTW_TX_QUEUE_VI: ++ case RTW_TX_QUEUE_VO: ++ /* normal */ ++ pages_free = (free_txpg[0] >> 16) & 0xfff; ++ break; ++ case RTW_TX_QUEUE_BE: ++ case RTW_TX_QUEUE_BK: ++ /* low */ ++ pages_free = free_txpg[1] & 0xfff; ++ break; ++ case RTW_TX_QUEUE_MGMT: ++ /* extra */ ++ pages_free = free_txpg[2] & 0xfff; ++ break; ++ default: ++ rtw_warn(rtwdev, "Unknown mapping for queue %u\n", queue); ++ return -EINVAL; ++ } ++ ++ /* add the pages from the public queue */ ++ pages_free += (free_txpg[1] >> 16) & 0xfff; ++ } ++ ++ pages_needed = DIV_ROUND_UP(count, rtwdev->chip->page_size); ++ ++ if (pages_needed > pages_free) { ++ rtw_dbg(rtwdev, RTW_DBG_SDIO, ++ "Not enough free pages (%u needed, %u free) in queue %u for %zu bytes\n", ++ pages_needed, pages_free, queue, count); ++ return -EBUSY; ++ } ++ ++ return 0; ++} ++ ++static int rtw_sdio_write_port(struct rtw_dev *rtwdev, struct sk_buff *skb, ++ enum rtw_tx_queue_type queue) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ bool bus_claim; ++ size_t txsize; ++ u32 txaddr; ++ int ret; ++ ++ txaddr = rtw_sdio_get_tx_addr(rtwdev, skb->len, queue); ++ if (!txaddr) ++ return -EINVAL; ++ ++ txsize = sdio_align_size(rtwsdio->sdio_func, skb->len); ++ ++ ret = rtw_sdio_check_free_txpg(rtwdev, queue, txsize); ++ if (ret) ++ return ret; ++ ++ if (!IS_ALIGNED((unsigned long)skb->data, RTW_SDIO_DATA_PTR_ALIGN)) ++ rtw_warn(rtwdev, "Got unaligned SKB in %s() for queue %u\n", ++ __func__, queue); ++ ++ bus_claim = rtw_sdio_bus_claim_needed(rtwsdio); ++ ++ if (bus_claim) ++ sdio_claim_host(rtwsdio->sdio_func); ++ ++ ret = sdio_memcpy_toio(rtwsdio->sdio_func, txaddr, skb->data, txsize); ++ ++ if (bus_claim) ++ sdio_release_host(rtwsdio->sdio_func); ++ ++ if (ret) ++ rtw_warn(rtwdev, ++ "Failed to write %zu byte(s) to SDIO port 0x%08x", ++ txsize, txaddr); ++ ++ return ret; ++} ++ ++static void rtw_sdio_init(struct rtw_dev *rtwdev) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ ++ rtwsdio->irq_mask = REG_SDIO_HIMR_RX_REQUEST | REG_SDIO_HIMR_CPWM1; ++} ++ ++static void rtw_sdio_enable_rx_aggregation(struct rtw_dev *rtwdev) ++{ ++ u8 size, timeout; ++ ++ if (rtw_chip_wcpu_11n(rtwdev)) { ++ size = 0x6; ++ timeout = 0x6; ++ } else { ++ size = 0xff; ++ timeout = 0x1; ++ } ++ ++ /* Make the firmware honor the size limit configured below */ ++ rtw_write32_set(rtwdev, REG_RXDMA_AGG_PG_TH, BIT_EN_PRE_CALC); ++ ++ rtw_write8_set(rtwdev, REG_TXDMA_PQ_MAP, BIT_RXDMA_AGG_EN); ++ ++ rtw_write16(rtwdev, REG_RXDMA_AGG_PG_TH, ++ FIELD_PREP(BIT_RXDMA_AGG_PG_TH, size) | ++ FIELD_PREP(BIT_DMA_AGG_TO_V1, timeout)); ++ ++ rtw_write8_set(rtwdev, REG_RXDMA_MODE, BIT_DMA_MODE); ++} ++ ++static void rtw_sdio_enable_interrupt(struct rtw_dev *rtwdev) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ ++ rtw_write32(rtwdev, REG_SDIO_HIMR, rtwsdio->irq_mask); ++} ++ ++static void rtw_sdio_disable_interrupt(struct rtw_dev *rtwdev) ++{ ++ rtw_write32(rtwdev, REG_SDIO_HIMR, 0x0); ++} ++ ++static u8 rtw_sdio_get_tx_qsel(struct rtw_dev *rtwdev, struct sk_buff *skb, ++ u8 queue) ++{ ++ switch (queue) { ++ case RTW_TX_QUEUE_BCN: ++ return TX_DESC_QSEL_BEACON; ++ case RTW_TX_QUEUE_H2C: ++ return TX_DESC_QSEL_H2C; ++ case RTW_TX_QUEUE_MGMT: ++ if (rtw_chip_wcpu_11n(rtwdev)) ++ return TX_DESC_QSEL_HIGH; ++ else ++ return TX_DESC_QSEL_MGMT; ++ case RTW_TX_QUEUE_HI0: ++ return TX_DESC_QSEL_HIGH; ++ default: ++ return skb->priority; ++ } ++} ++ ++static int rtw_sdio_setup(struct rtw_dev *rtwdev) ++{ ++ /* nothing to do */ ++ return 0; ++} ++ ++static int rtw_sdio_start(struct rtw_dev *rtwdev) ++{ ++ rtw_sdio_enable_rx_aggregation(rtwdev); ++ rtw_sdio_enable_interrupt(rtwdev); ++ ++ return 0; ++} ++ ++static void rtw_sdio_stop(struct rtw_dev *rtwdev) ++{ ++ rtw_sdio_disable_interrupt(rtwdev); ++} ++ ++static void rtw_sdio_deep_ps_enter(struct rtw_dev *rtwdev) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ bool tx_empty = true; ++ u8 queue; ++ ++ if (!rtw_fw_feature_check(&rtwdev->fw, FW_FEATURE_TX_WAKE)) { ++ /* Deep PS state is not allowed to TX-DMA */ ++ for (queue = 0; queue < RTK_MAX_TX_QUEUE_NUM; queue++) { ++ /* BCN queue is rsvd page, does not have DMA interrupt ++ * H2C queue is managed by firmware ++ */ ++ if (queue == RTW_TX_QUEUE_BCN || ++ queue == RTW_TX_QUEUE_H2C) ++ continue; ++ ++ /* check if there is any skb DMAing */ ++ if (skb_queue_len(&rtwsdio->tx_queue[queue])) { ++ tx_empty = false; ++ break; ++ } ++ } ++ } ++ ++ if (!tx_empty) { ++ rtw_dbg(rtwdev, RTW_DBG_PS, ++ "TX path not empty, cannot enter deep power save state\n"); ++ return; ++ } ++ ++ set_bit(RTW_FLAG_LEISURE_PS_DEEP, rtwdev->flags); ++ rtw_power_mode_change(rtwdev, true); ++} ++ ++static void rtw_sdio_deep_ps_leave(struct rtw_dev *rtwdev) ++{ ++ if (test_and_clear_bit(RTW_FLAG_LEISURE_PS_DEEP, rtwdev->flags)) ++ rtw_power_mode_change(rtwdev, false); ++} ++ ++static void rtw_sdio_deep_ps(struct rtw_dev *rtwdev, bool enter) ++{ ++ if (enter && !test_bit(RTW_FLAG_LEISURE_PS_DEEP, rtwdev->flags)) ++ rtw_sdio_deep_ps_enter(rtwdev); ++ ++ if (!enter && test_bit(RTW_FLAG_LEISURE_PS_DEEP, rtwdev->flags)) ++ rtw_sdio_deep_ps_leave(rtwdev); ++} ++ ++static void rtw_sdio_tx_kick_off(struct rtw_dev *rtwdev) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ ++ queue_work(rtwsdio->txwq, &rtwsdio->tx_handler_data->work); ++} ++ ++static void rtw_sdio_link_ps(struct rtw_dev *rtwdev, bool enter) ++{ ++ /* nothing to do */ ++} ++ ++static void rtw_sdio_interface_cfg(struct rtw_dev *rtwdev) ++{ ++ u32 val; ++ ++ rtw_read32(rtwdev, REG_SDIO_FREE_TXPG); ++ ++ val = rtw_read32(rtwdev, REG_SDIO_TX_CTRL); ++ val &= 0xfff8; ++ rtw_write32(rtwdev, REG_SDIO_TX_CTRL, val); ++} ++ ++static struct rtw_sdio_tx_data *rtw_sdio_get_tx_data(struct sk_buff *skb) ++{ ++ struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); ++ ++ BUILD_BUG_ON(sizeof(struct rtw_sdio_tx_data) > ++ sizeof(info->status.status_driver_data)); ++ ++ return (struct rtw_sdio_tx_data *)info->status.status_driver_data; ++} ++ ++static void rtw_sdio_tx_skb_prepare(struct rtw_dev *rtwdev, ++ struct rtw_tx_pkt_info *pkt_info, ++ struct sk_buff *skb, ++ enum rtw_tx_queue_type queue) ++{ ++ const struct rtw_chip_info *chip = rtwdev->chip; ++ unsigned long data_addr, aligned_addr; ++ size_t offset; ++ u8 *pkt_desc; ++ ++ pkt_desc = skb_push(skb, chip->tx_pkt_desc_sz); ++ ++ data_addr = (unsigned long)pkt_desc; ++ aligned_addr = ALIGN(data_addr, RTW_SDIO_DATA_PTR_ALIGN); ++ ++ if (data_addr != aligned_addr) { ++ /* Ensure that the start of the pkt_desc is always aligned at ++ * RTW_SDIO_DATA_PTR_ALIGN. ++ */ ++ offset = RTW_SDIO_DATA_PTR_ALIGN - (aligned_addr - data_addr); ++ ++ pkt_desc = skb_push(skb, offset); ++ ++ /* By inserting padding to align the start of the pkt_desc we ++ * need to inform the firmware that the actual data starts at ++ * a different offset than normal. ++ */ ++ pkt_info->offset += offset; ++ } ++ ++ memset(pkt_desc, 0, chip->tx_pkt_desc_sz); ++ ++ pkt_info->qsel = rtw_sdio_get_tx_qsel(rtwdev, skb, queue); ++ ++ rtw_tx_fill_tx_desc(pkt_info, skb); ++ rtw_tx_fill_txdesc_checksum(rtwdev, pkt_info, pkt_desc); ++} ++ ++static int rtw_sdio_write_data(struct rtw_dev *rtwdev, ++ struct rtw_tx_pkt_info *pkt_info, ++ struct sk_buff *skb, ++ enum rtw_tx_queue_type queue) ++{ ++ int ret; ++ ++ rtw_sdio_tx_skb_prepare(rtwdev, pkt_info, skb, queue); ++ ++ ret = rtw_sdio_write_port(rtwdev, skb, queue); ++ dev_kfree_skb_any(skb); ++ ++ return ret; ++} ++ ++static int rtw_sdio_write_data_rsvd_page(struct rtw_dev *rtwdev, u8 *buf, ++ u32 size) ++{ ++ struct rtw_tx_pkt_info pkt_info = {}; ++ struct sk_buff *skb; ++ ++ skb = rtw_tx_write_data_rsvd_page_get(rtwdev, &pkt_info, buf, size); ++ if (!skb) ++ return -ENOMEM; ++ ++ return rtw_sdio_write_data(rtwdev, &pkt_info, skb, RTW_TX_QUEUE_BCN); ++} ++ ++static int rtw_sdio_write_data_h2c(struct rtw_dev *rtwdev, u8 *buf, u32 size) ++{ ++ struct rtw_tx_pkt_info pkt_info = {}; ++ struct sk_buff *skb; ++ ++ skb = rtw_tx_write_data_h2c_get(rtwdev, &pkt_info, buf, size); ++ if (!skb) ++ return -ENOMEM; ++ ++ return rtw_sdio_write_data(rtwdev, &pkt_info, skb, RTW_TX_QUEUE_H2C); ++} ++ ++static int rtw_sdio_tx_write(struct rtw_dev *rtwdev, ++ struct rtw_tx_pkt_info *pkt_info, ++ struct sk_buff *skb) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ enum rtw_tx_queue_type queue = rtw_tx_queue_mapping(skb); ++ struct rtw_sdio_tx_data *tx_data; ++ ++ rtw_sdio_tx_skb_prepare(rtwdev, pkt_info, skb, queue); ++ ++ tx_data = rtw_sdio_get_tx_data(skb); ++ tx_data->sn = pkt_info->sn; ++ ++ skb_queue_tail(&rtwsdio->tx_queue[queue], skb); ++ ++ return 0; ++} ++ ++static void rtw_sdio_tx_err_isr(struct rtw_dev *rtwdev) ++{ ++ u32 val = rtw_read32(rtwdev, REG_TXDMA_STATUS); ++ ++ rtw_write32(rtwdev, REG_TXDMA_STATUS, val); ++} ++ ++static void rtw_sdio_rx_skb(struct rtw_dev *rtwdev, struct sk_buff *skb, ++ u32 pkt_offset, struct rtw_rx_pkt_stat *pkt_stat, ++ struct ieee80211_rx_status *rx_status) ++{ ++ *IEEE80211_SKB_RXCB(skb) = *rx_status; ++ ++ if (pkt_stat->is_c2h) { ++ skb_put(skb, pkt_stat->pkt_len + pkt_offset); ++ rtw_fw_c2h_cmd_rx_irqsafe(rtwdev, pkt_offset, skb); ++ return; ++ } ++ ++ skb_put(skb, pkt_stat->pkt_len); ++ skb_reserve(skb, pkt_offset); ++ ++ rtw_rx_stats(rtwdev, pkt_stat->vif, skb); ++ ++ ieee80211_rx_irqsafe(rtwdev->hw, skb); ++} ++ ++static void rtw_sdio_rxfifo_recv(struct rtw_dev *rtwdev, u32 rx_len) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ const struct rtw_chip_info *chip = rtwdev->chip; ++ u32 pkt_desc_sz = chip->rx_pkt_desc_sz; ++ struct ieee80211_rx_status rx_status; ++ struct rtw_rx_pkt_stat pkt_stat; ++ struct sk_buff *skb, *split_skb; ++ u32 pkt_offset, curr_pkt_len; ++ size_t bufsz; ++ u8 *rx_desc; ++ int ret; ++ ++ bufsz = sdio_align_size(rtwsdio->sdio_func, rx_len); ++ ++ skb = dev_alloc_skb(bufsz); ++ if (!skb) ++ return; ++ ++ ret = rtw_sdio_read_port(rtwdev, skb->data, bufsz); ++ if (ret) { ++ dev_kfree_skb_any(skb); ++ return; ++ } ++ ++ while (true) { ++ rx_desc = skb->data; ++ chip->ops->query_rx_desc(rtwdev, rx_desc, &pkt_stat, ++ &rx_status); ++ pkt_offset = pkt_desc_sz + pkt_stat.drv_info_sz + ++ pkt_stat.shift; ++ ++ curr_pkt_len = ALIGN(pkt_offset + pkt_stat.pkt_len, ++ RTW_SDIO_DATA_PTR_ALIGN); ++ ++ if ((curr_pkt_len + pkt_desc_sz) >= rx_len) { ++ /* Use the original skb (with it's adjusted offset) ++ * when processing the last (or even the only) entry to ++ * have it's memory freed automatically. ++ */ ++ rtw_sdio_rx_skb(rtwdev, skb, pkt_offset, &pkt_stat, ++ &rx_status); ++ break; ++ } ++ ++ split_skb = dev_alloc_skb(curr_pkt_len); ++ if (!split_skb) { ++ rtw_sdio_rx_skb(rtwdev, skb, pkt_offset, &pkt_stat, ++ &rx_status); ++ break; ++ } ++ ++ skb_copy_header(split_skb, skb); ++ memcpy(split_skb->data, skb->data, curr_pkt_len); ++ ++ rtw_sdio_rx_skb(rtwdev, split_skb, pkt_offset, &pkt_stat, ++ &rx_status); ++ ++ /* Move to the start of the next RX descriptor */ ++ skb_reserve(skb, curr_pkt_len); ++ rx_len -= curr_pkt_len; ++ } ++} ++ ++static void rtw_sdio_rx_isr(struct rtw_dev *rtwdev) ++{ ++ u32 rx_len, total_rx_bytes = 0; ++ ++ while (total_rx_bytes < SZ_64K) { ++ if (rtw_chip_wcpu_11n(rtwdev)) ++ rx_len = rtw_read16(rtwdev, REG_SDIO_RX0_REQ_LEN); ++ else ++ rx_len = rtw_read32(rtwdev, REG_SDIO_RX0_REQ_LEN); ++ ++ if (!rx_len) ++ break; ++ ++ rtw_sdio_rxfifo_recv(rtwdev, rx_len); ++ ++ total_rx_bytes += rx_len; ++ } ++} ++ ++static void rtw_sdio_handle_interrupt(struct sdio_func *sdio_func) ++{ ++ struct ieee80211_hw *hw = sdio_get_drvdata(sdio_func); ++ struct rtw_sdio *rtwsdio; ++ struct rtw_dev *rtwdev; ++ u32 hisr; ++ ++ rtwdev = hw->priv; ++ rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ ++ rtwsdio->irq_thread = current; ++ ++ hisr = rtw_read32(rtwdev, REG_SDIO_HISR); ++ ++ if (hisr & REG_SDIO_HISR_TXERR) ++ rtw_sdio_tx_err_isr(rtwdev); ++ if (hisr & REG_SDIO_HISR_RX_REQUEST) { ++ hisr &= ~REG_SDIO_HISR_RX_REQUEST; ++ rtw_sdio_rx_isr(rtwdev); ++ } ++ ++ rtw_write32(rtwdev, REG_SDIO_HISR, hisr); ++ ++ rtwsdio->irq_thread = NULL; ++} ++ ++static int __maybe_unused rtw_sdio_suspend(struct device *dev) ++{ ++ struct sdio_func *func = dev_to_sdio_func(dev); ++ struct ieee80211_hw *hw = dev_get_drvdata(dev); ++ struct rtw_dev *rtwdev = hw->priv; ++ int ret; ++ ++ ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER); ++ if (ret) ++ rtw_err(rtwdev, "Failed to host PM flag MMC_PM_KEEP_POWER"); ++ ++ return ret; ++} ++ ++static int __maybe_unused rtw_sdio_resume(struct device *dev) ++{ ++ return 0; ++} ++ ++SIMPLE_DEV_PM_OPS(rtw_sdio_pm_ops, rtw_sdio_suspend, rtw_sdio_resume); ++EXPORT_SYMBOL(rtw_sdio_pm_ops); ++ ++static int rtw_sdio_claim(struct rtw_dev *rtwdev, struct sdio_func *sdio_func) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ int ret; ++ ++ sdio_claim_host(sdio_func); ++ ++ ret = sdio_enable_func(sdio_func); ++ if (ret) { ++ rtw_err(rtwdev, "Failed to enable SDIO func"); ++ goto err_release_host; ++ } ++ ++ ret = sdio_set_block_size(sdio_func, RTW_SDIO_BLOCK_SIZE); ++ if (ret) { ++ rtw_err(rtwdev, "Failed to set SDIO block size to 512"); ++ goto err_disable_func; ++ } ++ ++ rtwsdio->sdio_func = sdio_func; ++ ++ rtwsdio->sdio3_bus_mode = mmc_card_uhs(sdio_func->card); ++ ++ sdio_set_drvdata(sdio_func, rtwdev->hw); ++ SET_IEEE80211_DEV(rtwdev->hw, &sdio_func->dev); ++ ++ sdio_release_host(sdio_func); ++ ++ return 0; ++ ++err_disable_func: ++ sdio_disable_func(sdio_func); ++err_release_host: ++ sdio_release_host(sdio_func); ++ return ret; ++} ++ ++static void rtw_sdio_declaim(struct rtw_dev *rtwdev, ++ struct sdio_func *sdio_func) ++{ ++ sdio_claim_host(sdio_func); ++ sdio_disable_func(sdio_func); ++ sdio_release_host(sdio_func); ++} ++ ++static struct rtw_hci_ops rtw_sdio_ops = { ++ .tx_write = rtw_sdio_tx_write, ++ .tx_kick_off = rtw_sdio_tx_kick_off, ++ .setup = rtw_sdio_setup, ++ .start = rtw_sdio_start, ++ .stop = rtw_sdio_stop, ++ .deep_ps = rtw_sdio_deep_ps, ++ .link_ps = rtw_sdio_link_ps, ++ .interface_cfg = rtw_sdio_interface_cfg, ++ ++ .read8 = rtw_sdio_read8, ++ .read16 = rtw_sdio_read16, ++ .read32 = rtw_sdio_read32, ++ .write8 = rtw_sdio_write8, ++ .write16 = rtw_sdio_write16, ++ .write32 = rtw_sdio_write32, ++ .write_data_rsvd_page = rtw_sdio_write_data_rsvd_page, ++ .write_data_h2c = rtw_sdio_write_data_h2c, ++}; ++ ++static int rtw_sdio_request_irq(struct rtw_dev *rtwdev, ++ struct sdio_func *sdio_func) ++{ ++ int ret; ++ ++ sdio_claim_host(sdio_func); ++ ret = sdio_claim_irq(sdio_func, &rtw_sdio_handle_interrupt); ++ sdio_release_host(sdio_func); ++ ++ if (ret) { ++ rtw_err(rtwdev, "failed to claim SDIO IRQ"); ++ return ret; ++ } ++ ++ return 0; ++} ++ ++static void rtw_sdio_indicate_tx_status(struct rtw_dev *rtwdev, ++ struct sk_buff *skb) ++{ ++ struct rtw_sdio_tx_data *tx_data = rtw_sdio_get_tx_data(skb); ++ struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); ++ struct ieee80211_hw *hw = rtwdev->hw; ++ ++ /* enqueue to wait for tx report */ ++ if (info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS) { ++ rtw_tx_report_enqueue(rtwdev, skb, tx_data->sn); ++ return; ++ } ++ ++ /* always ACK for others, then they won't be marked as drop */ ++ ieee80211_tx_info_clear_status(info); ++ if (info->flags & IEEE80211_TX_CTL_NO_ACK) ++ info->flags |= IEEE80211_TX_STAT_NOACK_TRANSMITTED; ++ else ++ info->flags |= IEEE80211_TX_STAT_ACK; ++ ++ ieee80211_tx_status_irqsafe(hw, skb); ++} ++ ++static void rtw_sdio_process_tx_queue(struct rtw_dev *rtwdev, ++ enum rtw_tx_queue_type queue) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ struct sk_buff *skb; ++ int ret; ++ ++ skb = skb_dequeue(&rtwsdio->tx_queue[queue]); ++ if (!skb) ++ return; ++ ++ ret = rtw_sdio_write_port(rtwdev, skb, queue); ++ if (ret) { ++ skb_queue_head(&rtwsdio->tx_queue[queue], skb); ++ return; ++ } ++ ++ if (queue <= RTW_TX_QUEUE_VO) ++ rtw_sdio_indicate_tx_status(rtwdev, skb); ++ else ++ dev_kfree_skb_any(skb); ++} ++ ++static void rtw_sdio_tx_handler(struct work_struct *work) ++{ ++ struct rtw_sdio_work_data *work_data = ++ container_of(work, struct rtw_sdio_work_data, work); ++ struct rtw_sdio *rtwsdio; ++ struct rtw_dev *rtwdev; ++ int limit, queue; ++ ++ rtwdev = work_data->rtwdev; ++ rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ ++ if (!rtw_fw_feature_check(&rtwdev->fw, FW_FEATURE_TX_WAKE)) ++ rtw_sdio_deep_ps_leave(rtwdev); ++ ++ for (queue = RTK_MAX_TX_QUEUE_NUM - 1; queue >= 0; queue--) { ++ for (limit = 0; limit < 1000; limit++) { ++ rtw_sdio_process_tx_queue(rtwdev, queue); ++ ++ if (skb_queue_empty(&rtwsdio->tx_queue[queue])) ++ break; ++ } ++ } ++} ++ ++static void rtw_sdio_free_irq(struct rtw_dev *rtwdev, ++ struct sdio_func *sdio_func) ++{ ++ sdio_claim_host(sdio_func); ++ sdio_release_irq(sdio_func); ++ sdio_release_host(sdio_func); ++} ++ ++static int rtw_sdio_init_tx(struct rtw_dev *rtwdev) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ int i; ++ ++ rtwsdio->txwq = create_singlethread_workqueue("rtw88_sdio: tx wq"); ++ if (!rtwsdio->txwq) { ++ rtw_err(rtwdev, "failed to create TX work queue\n"); ++ return -ENOMEM; ++ } ++ ++ for (i = 0; i < RTK_MAX_TX_QUEUE_NUM; i++) ++ skb_queue_head_init(&rtwsdio->tx_queue[i]); ++ rtwsdio->tx_handler_data = kmalloc(sizeof(*rtwsdio->tx_handler_data), ++ GFP_KERNEL); ++ if (!rtwsdio->tx_handler_data) ++ goto err_destroy_wq; ++ ++ rtwsdio->tx_handler_data->rtwdev = rtwdev; ++ INIT_WORK(&rtwsdio->tx_handler_data->work, rtw_sdio_tx_handler); ++ ++ return 0; ++ ++err_destroy_wq: ++ destroy_workqueue(rtwsdio->txwq); ++ return -ENOMEM; ++} ++ ++static void rtw_sdio_deinit_tx(struct rtw_dev *rtwdev) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ int i; ++ ++ for (i = 0; i < RTK_MAX_TX_QUEUE_NUM; i++) ++ skb_queue_purge(&rtwsdio->tx_queue[i]); ++ ++ flush_workqueue(rtwsdio->txwq); ++ destroy_workqueue(rtwsdio->txwq); ++ kfree(rtwsdio->tx_handler_data); ++} ++ ++int rtw_sdio_probe(struct sdio_func *sdio_func, ++ const struct sdio_device_id *id) ++{ ++ struct ieee80211_hw *hw; ++ struct rtw_dev *rtwdev; ++ int drv_data_size; ++ int ret; ++ ++ drv_data_size = sizeof(struct rtw_dev) + sizeof(struct rtw_sdio); ++ hw = ieee80211_alloc_hw(drv_data_size, &rtw_ops); ++ if (!hw) { ++ dev_err(&sdio_func->dev, "failed to allocate hw"); ++ return -ENOMEM; ++ } ++ ++ rtwdev = hw->priv; ++ rtwdev->hw = hw; ++ rtwdev->dev = &sdio_func->dev; ++ rtwdev->chip = (struct rtw_chip_info *)id->driver_data; ++ rtwdev->hci.ops = &rtw_sdio_ops; ++ rtwdev->hci.type = RTW_HCI_TYPE_SDIO; ++ ++ ret = rtw_core_init(rtwdev); ++ if (ret) ++ goto err_release_hw; ++ ++ rtw_dbg(rtwdev, RTW_DBG_SDIO, ++ "rtw88 SDIO probe: vendor=0x%04x device=%04x class=%02x", ++ id->vendor, id->device, id->class); ++ ++ ret = rtw_sdio_claim(rtwdev, sdio_func); ++ if (ret) { ++ rtw_err(rtwdev, "failed to claim SDIO device"); ++ goto err_deinit_core; ++ } ++ ++ rtw_sdio_init(rtwdev); ++ ++ ret = rtw_sdio_init_tx(rtwdev); ++ if (ret) { ++ rtw_err(rtwdev, "failed to init SDIO TX queue\n"); ++ goto err_sdio_declaim; ++ } ++ ++ ret = rtw_chip_info_setup(rtwdev); ++ if (ret) { ++ rtw_err(rtwdev, "failed to setup chip information"); ++ goto err_destroy_txwq; ++ } ++ ++ ret = rtw_sdio_request_irq(rtwdev, sdio_func); ++ if (ret) ++ goto err_destroy_txwq; ++ ++ ret = rtw_register_hw(rtwdev, hw); ++ if (ret) { ++ rtw_err(rtwdev, "failed to register hw"); ++ goto err_free_irq; ++ } ++ ++ return 0; ++ ++err_free_irq: ++ rtw_sdio_free_irq(rtwdev, sdio_func); ++err_destroy_txwq: ++ rtw_sdio_deinit_tx(rtwdev); ++err_sdio_declaim: ++ rtw_sdio_declaim(rtwdev, sdio_func); ++err_deinit_core: ++ rtw_core_deinit(rtwdev); ++err_release_hw: ++ ieee80211_free_hw(hw); ++ ++ return ret; ++} ++EXPORT_SYMBOL(rtw_sdio_probe); ++ ++void rtw_sdio_remove(struct sdio_func *sdio_func) ++{ ++ struct ieee80211_hw *hw = sdio_get_drvdata(sdio_func); ++ struct rtw_dev *rtwdev; ++ ++ if (!hw) ++ return; ++ ++ rtwdev = hw->priv; ++ ++ rtw_unregister_hw(rtwdev, hw); ++ rtw_sdio_disable_interrupt(rtwdev); ++ rtw_sdio_free_irq(rtwdev, sdio_func); ++ rtw_sdio_declaim(rtwdev, sdio_func); ++ rtw_sdio_deinit_tx(rtwdev); ++ rtw_core_deinit(rtwdev); ++ ieee80211_free_hw(hw); ++} ++EXPORT_SYMBOL(rtw_sdio_remove); ++ ++void rtw_sdio_shutdown(struct device *dev) ++{ ++ struct sdio_func *sdio_func = dev_to_sdio_func(dev); ++ const struct rtw_chip_info *chip; ++ struct ieee80211_hw *hw; ++ struct rtw_dev *rtwdev; ++ ++ hw = sdio_get_drvdata(sdio_func); ++ if (!hw) ++ return; ++ ++ rtwdev = hw->priv; ++ chip = rtwdev->chip; ++ ++ if (chip->ops->shutdown) ++ chip->ops->shutdown(rtwdev); ++} ++EXPORT_SYMBOL(rtw_sdio_shutdown); ++ ++MODULE_AUTHOR("Martin Blumenstingl"); ++MODULE_AUTHOR("Jernej Skrabec"); ++MODULE_DESCRIPTION("Realtek 802.11ac wireless SDIO driver"); ++MODULE_LICENSE("Dual BSD/GPL"); +--- /dev/null ++++ b/drivers/net/wireless/realtek/rtw88/sdio.h +@@ -0,0 +1,178 @@ ++/* SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause */ ++/* Copyright (C) 2021 Martin Blumenstingl ++ * Copyright (C) 2021 Jernej Skrabec ++ */ ++ ++#ifndef __REG_SDIO_H_ ++#define __REG_SDIO_H_ ++ ++/* I/O bus domain address mapping */ ++#define SDIO_LOCAL_OFFSET 0x10250000 ++#define WLAN_IOREG_OFFSET 0x10260000 ++#define FIRMWARE_FIFO_OFFSET 0x10270000 ++#define TX_HIQ_OFFSET 0x10310000 ++#define TX_MIQ_OFFSET 0x10320000 ++#define TX_LOQ_OFFSET 0x10330000 ++#define TX_EPQ_OFFSET 0x10350000 ++#define RX_RX0FF_OFFSET 0x10340000 ++ ++#define RTW_SDIO_BUS_MSK 0xffff0000 ++#define SDIO_LOCAL_REG_MSK 0x00000fff ++#define WLAN_IOREG_REG_MSK 0x0000ffff ++ ++/* SDIO Tx Control */ ++#define REG_SDIO_TX_CTRL (SDIO_LOCAL_OFFSET + 0x0000) ++ ++/*SDIO status timeout*/ ++#define REG_SDIO_TIMEOUT (SDIO_LOCAL_OFFSET + 0x0002) ++ ++/* SDIO Host Interrupt Mask */ ++#define REG_SDIO_HIMR (SDIO_LOCAL_OFFSET + 0x0014) ++#define REG_SDIO_HIMR_RX_REQUEST BIT(0) ++#define REG_SDIO_HIMR_AVAL BIT(1) ++#define REG_SDIO_HIMR_TXERR BIT(2) ++#define REG_SDIO_HIMR_RXERR BIT(3) ++#define REG_SDIO_HIMR_TXFOVW BIT(4) ++#define REG_SDIO_HIMR_RXFOVW BIT(5) ++#define REG_SDIO_HIMR_TXBCNOK BIT(6) ++#define REG_SDIO_HIMR_TXBCNERR BIT(7) ++#define REG_SDIO_HIMR_BCNERLY_INT BIT(16) ++#define REG_SDIO_HIMR_C2HCMD BIT(17) ++#define REG_SDIO_HIMR_CPWM1 BIT(18) ++#define REG_SDIO_HIMR_CPWM2 BIT(19) ++#define REG_SDIO_HIMR_HSISR_IND BIT(20) ++#define REG_SDIO_HIMR_GTINT3_IND BIT(21) ++#define REG_SDIO_HIMR_GTINT4_IND BIT(22) ++#define REG_SDIO_HIMR_PSTIMEOUT BIT(23) ++#define REG_SDIO_HIMR_OCPINT BIT(24) ++#define REG_SDIO_HIMR_ATIMEND BIT(25) ++#define REG_SDIO_HIMR_ATIMEND_E BIT(26) ++#define REG_SDIO_HIMR_CTWEND BIT(27) ++/* the following two are RTL8188 SDIO Specific */ ++#define REG_SDIO_HIMR_MCU_ERR BIT(28) ++#define REG_SDIO_HIMR_TSF_BIT32_TOGGLE BIT(29) ++ ++/* SDIO Host Interrupt Service Routine */ ++#define REG_SDIO_HISR (SDIO_LOCAL_OFFSET + 0x0018) ++#define REG_SDIO_HISR_RX_REQUEST BIT(0) ++#define REG_SDIO_HISR_AVAL BIT(1) ++#define REG_SDIO_HISR_TXERR BIT(2) ++#define REG_SDIO_HISR_RXERR BIT(3) ++#define REG_SDIO_HISR_TXFOVW BIT(4) ++#define REG_SDIO_HISR_RXFOVW BIT(5) ++#define REG_SDIO_HISR_TXBCNOK BIT(6) ++#define REG_SDIO_HISR_TXBCNERR BIT(7) ++#define REG_SDIO_HISR_BCNERLY_INT BIT(16) ++#define REG_SDIO_HISR_C2HCMD BIT(17) ++#define REG_SDIO_HISR_CPWM1 BIT(18) ++#define REG_SDIO_HISR_CPWM2 BIT(19) ++#define REG_SDIO_HISR_HSISR_IND BIT(20) ++#define REG_SDIO_HISR_GTINT3_IND BIT(21) ++#define REG_SDIO_HISR_GTINT4_IND BIT(22) ++#define REG_SDIO_HISR_PSTIMEOUT BIT(23) ++#define REG_SDIO_HISR_OCPINT BIT(24) ++#define REG_SDIO_HISR_ATIMEND BIT(25) ++#define REG_SDIO_HISR_ATIMEND_E BIT(26) ++#define REG_SDIO_HISR_CTWEND BIT(27) ++/* the following two are RTL8188 SDIO Specific */ ++#define REG_SDIO_HISR_MCU_ERR BIT(28) ++#define REG_SDIO_HISR_TSF_BIT32_TOGGLE BIT(29) ++ ++/* HCI Current Power Mode */ ++#define REG_SDIO_HCPWM (SDIO_LOCAL_OFFSET + 0x0019) ++/* RXDMA Request Length */ ++#define REG_SDIO_RX0_REQ_LEN (SDIO_LOCAL_OFFSET + 0x001C) ++/* OQT Free Page */ ++#define REG_SDIO_OQT_FREE_PG (SDIO_LOCAL_OFFSET + 0x001E) ++/* Free Tx Buffer Page */ ++#define REG_SDIO_FREE_TXPG (SDIO_LOCAL_OFFSET + 0x0020) ++/* HCI Current Power Mode 1 */ ++#define REG_SDIO_HCPWM1 (SDIO_LOCAL_OFFSET + 0x0024) ++/* HCI Current Power Mode 2 */ ++#define REG_SDIO_HCPWM2 (SDIO_LOCAL_OFFSET + 0x0026) ++/* Free Tx Page Sequence */ ++#define REG_SDIO_FREE_TXPG_SEQ (SDIO_LOCAL_OFFSET + 0x0028) ++/* HTSF Information */ ++#define REG_SDIO_HTSFR_INFO (SDIO_LOCAL_OFFSET + 0x0030) ++#define REG_SDIO_HCPWM1_V2 (SDIO_LOCAL_OFFSET + 0x0038) ++/* H2C */ ++#define REG_SDIO_H2C (SDIO_LOCAL_OFFSET + 0x0060) ++/* HCI Request Power Mode 1 */ ++#define REG_SDIO_HRPWM1 (SDIO_LOCAL_OFFSET + 0x0080) ++/* HCI Request Power Mode 2 */ ++#define REG_SDIO_HRPWM2 (SDIO_LOCAL_OFFSET + 0x0082) ++/* HCI Power Save Clock */ ++#define REG_SDIO_HPS_CLKR (SDIO_LOCAL_OFFSET + 0x0084) ++/* SDIO HCI Suspend Control */ ++#define REG_SDIO_HSUS_CTRL (SDIO_LOCAL_OFFSET + 0x0086) ++#define BIT_HCI_SUS_REQ BIT(0) ++#define BIT_HCI_RESUME_RDY BIT(1) ++/* SDIO Host Extension Interrupt Mask Always */ ++#define REG_SDIO_HIMR_ON (SDIO_LOCAL_OFFSET + 0x0090) ++/* SDIO Host Extension Interrupt Status Always */ ++#define REG_SDIO_HISR_ON (SDIO_LOCAL_OFFSET + 0x0091) ++ ++#define REG_SDIO_INDIRECT_REG_CFG (SDIO_LOCAL_OFFSET + 0x0040) ++#define BIT_SDIO_INDIRECT_REG_CFG_WORD BIT(16) ++#define BIT_SDIO_INDIRECT_REG_CFG_DWORD BIT(17) ++#define BIT_SDIO_INDIRECT_REG_CFG_WRITE BIT(18) ++#define BIT_SDIO_INDIRECT_REG_CFG_READ BIT(19) ++#define BIT_SDIO_INDIRECT_REG_CFG_UNK20 BIT(20) ++#define REG_SDIO_INDIRECT_REG_DATA (SDIO_LOCAL_OFFSET + 0x0044) ++ ++/* Sdio Address for SDIO Local Reg, TRX FIFO, MAC Reg */ ++#define REG_SDIO_CMD_ADDR_MSK GENMASK(16, 13) ++#define REG_SDIO_CMD_ADDR_SDIO_REG 0 ++#define REG_SDIO_CMD_ADDR_MAC_REG 8 ++#define REG_SDIO_CMD_ADDR_TXFF_HIGH 4 ++#define REG_SDIO_CMD_ADDR_TXFF_LOW 6 ++#define REG_SDIO_CMD_ADDR_TXFF_NORMAL 5 ++#define REG_SDIO_CMD_ADDR_TXFF_EXTRA 7 ++#define REG_SDIO_CMD_ADDR_RXFF 7 ++ ++#define RTW_SDIO_BLOCK_SIZE 512 ++#define RTW_SDIO_ADDR_RX_RX0FF_GEN(_id) (0x0e000 | ((_id) & 0x3)) ++ ++#define RTW_SDIO_DATA_PTR_ALIGN 8 ++ ++struct sdio_func; ++struct sdio_device_id; ++ ++struct rtw_sdio_tx_data { ++ u8 sn; ++}; ++ ++struct rtw_sdio_work_data { ++ struct work_struct work; ++ struct rtw_dev *rtwdev; ++}; ++ ++struct rtw_sdio { ++ struct sdio_func *sdio_func; ++ ++ u32 irq_mask; ++ u8 rx_addr; ++ bool sdio3_bus_mode; ++ ++ void *irq_thread; ++ ++ struct workqueue_struct *txwq; ++ struct rtw_sdio_work_data *tx_handler_data; ++ struct sk_buff_head tx_queue[RTK_MAX_TX_QUEUE_NUM]; ++}; ++ ++extern const struct dev_pm_ops rtw_sdio_pm_ops; ++ ++int rtw_sdio_probe(struct sdio_func *sdio_func, ++ const struct sdio_device_id *id); ++void rtw_sdio_remove(struct sdio_func *sdio_func); ++void rtw_sdio_shutdown(struct device *dev); ++ ++static inline bool rtw_sdio_is_sdio30_supported(struct rtw_dev *rtwdev) ++{ ++ struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv; ++ ++ return rtwsdio->sdio3_bus_mode; ++} ++ ++#endif diff --git a/package/kernel/mac80211/patches/rtl/026-wifi-rtw88-mac-Support-SDIO-specific-bits-in-the-pow.patch b/package/kernel/mac80211/patches/rtl/026-wifi-rtw88-mac-Support-SDIO-specific-bits-in-the-pow.patch new file mode 100644 index 0000000000..534836590c --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/026-wifi-rtw88-mac-Support-SDIO-specific-bits-in-the-pow.patch @@ -0,0 +1,119 @@ +From b722e5b130bcaa8224c93c6625685d8276742cbd Mon Sep 17 00:00:00 2001 +From: Martin Blumenstingl +Date: Wed, 5 Apr 2023 22:07:23 +0200 +Subject: [PATCH 26/45] wifi: rtw88: mac: Support SDIO specific bits in the + power on sequence + +Add the code specific to SDIO HCI in the MAC power on sequence. This is +based on the RTL8822BS and RTL8822CS vendor drivers. + +Co-developed-by: Jernej Skrabec +Signed-off-by: Jernej Skrabec +Reviewed-by: Ping-Ke Shih +Signed-off-by: Martin Blumenstingl +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230405200729.632435-4-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/mac.c | 47 +++++++++++++++++++++--- + 1 file changed, 42 insertions(+), 5 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/mac.c ++++ b/drivers/net/wireless/realtek/rtw88/mac.c +@@ -61,6 +61,7 @@ EXPORT_SYMBOL(rtw_set_channel_mac); + + static int rtw_mac_pre_system_cfg(struct rtw_dev *rtwdev) + { ++ unsigned int retry; + u32 value32; + u8 value8; + +@@ -78,6 +79,28 @@ static int rtw_mac_pre_system_cfg(struct + case RTW_HCI_TYPE_PCIE: + rtw_write32_set(rtwdev, REG_HCI_OPT_CTRL, BIT_USB_SUS_DIS); + break; ++ case RTW_HCI_TYPE_SDIO: ++ rtw_write8_clr(rtwdev, REG_SDIO_HSUS_CTRL, BIT_HCI_SUS_REQ); ++ ++ for (retry = 0; retry < RTW_PWR_POLLING_CNT; retry++) { ++ if (rtw_read8(rtwdev, REG_SDIO_HSUS_CTRL) & BIT_HCI_RESUME_RDY) ++ break; ++ ++ usleep_range(10, 50); ++ } ++ ++ if (retry == RTW_PWR_POLLING_CNT) { ++ rtw_err(rtwdev, "failed to poll REG_SDIO_HSUS_CTRL[1]"); ++ return -ETIMEDOUT; ++ } ++ ++ if (rtw_sdio_is_sdio30_supported(rtwdev)) ++ rtw_write8_set(rtwdev, REG_HCI_OPT_CTRL + 2, ++ BIT_SDIO_PAD_E5 >> 16); ++ else ++ rtw_write8_clr(rtwdev, REG_HCI_OPT_CTRL + 2, ++ BIT_SDIO_PAD_E5 >> 16); ++ break; + case RTW_HCI_TYPE_USB: + break; + default: +@@ -249,6 +272,7 @@ static int rtw_mac_power_switch(struct r + { + const struct rtw_chip_info *chip = rtwdev->chip; + const struct rtw_pwr_seq_cmd **pwr_seq; ++ u32 imr = 0; + u8 rpwm; + bool cur_pwr; + int ret; +@@ -274,18 +298,24 @@ static int rtw_mac_power_switch(struct r + if (pwr_on == cur_pwr) + return -EALREADY; + ++ if (rtw_hci_type(rtwdev) == RTW_HCI_TYPE_SDIO) { ++ imr = rtw_read32(rtwdev, REG_SDIO_HIMR); ++ rtw_write32(rtwdev, REG_SDIO_HIMR, 0); ++ } ++ + if (!pwr_on) + clear_bit(RTW_FLAG_POWERON, rtwdev->flags); + + pwr_seq = pwr_on ? chip->pwr_on_seq : chip->pwr_off_seq; + ret = rtw_pwr_seq_parser(rtwdev, pwr_seq); +- if (ret) +- return ret; + +- if (pwr_on) ++ if (rtw_hci_type(rtwdev) == RTW_HCI_TYPE_SDIO) ++ rtw_write32(rtwdev, REG_SDIO_HIMR, imr); ++ ++ if (!ret && pwr_on) + set_bit(RTW_FLAG_POWERON, rtwdev->flags); + +- return 0; ++ return ret; + } + + static int __rtw_mac_init_system_cfg(struct rtw_dev *rtwdev) +@@ -456,6 +486,9 @@ static void download_firmware_reg_backup + rtw_write16(rtwdev, REG_FIFOPAGE_INFO_1, 0x200); + rtw_write32(rtwdev, REG_RQPN_CTRL_2, bckp[bckp_idx - 1].val); + ++ if (rtw_hci_type(rtwdev) == RTW_HCI_TYPE_SDIO) ++ rtw_read32(rtwdev, REG_SDIO_FREE_TXPG); ++ + /* Disable beacon related functions */ + tmp = rtw_read8(rtwdev, REG_BCN_CTRL); + bckp[bckp_idx].len = 1; +@@ -1068,8 +1101,12 @@ static int txdma_queue_mapping(struct rt + if (rtw_chip_wcpu_11ac(rtwdev)) + rtw_write32(rtwdev, REG_H2CQ_CSR, BIT_H2CQ_FULL); + +- if (rtw_hci_type(rtwdev) == RTW_HCI_TYPE_USB) ++ if (rtw_hci_type(rtwdev) == RTW_HCI_TYPE_SDIO) { ++ rtw_read32(rtwdev, REG_SDIO_FREE_TXPG); ++ rtw_write32(rtwdev, REG_SDIO_TX_CTRL, 0); ++ } else if (rtw_hci_type(rtwdev) == RTW_HCI_TYPE_USB) { + rtw_write8_set(rtwdev, REG_TXDMA_PQ_MAP, BIT_RXDMA_ARBBW_EN); ++ } + + return 0; + } diff --git a/package/kernel/mac80211/patches/rtl/027-wifi-rtw88-main-Add-the-cpwm-rpwm-_addr-for-SDIO-bas.patch b/package/kernel/mac80211/patches/rtl/027-wifi-rtw88-main-Add-the-cpwm-rpwm-_addr-for-SDIO-bas.patch new file mode 100644 index 0000000000..4f7fe2fa9d --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/027-wifi-rtw88-main-Add-the-cpwm-rpwm-_addr-for-SDIO-bas.patch @@ -0,0 +1,38 @@ +From a5d25f9ff91831f3a87aca96480a8b080546ccb8 Mon Sep 17 00:00:00 2001 +From: Martin Blumenstingl +Date: Wed, 5 Apr 2023 22:07:24 +0200 +Subject: [PATCH 27/45] wifi: rtw88: main: Add the {cpwm,rpwm}_addr for SDIO + based chipsets + +Initialize the rpwm_addr and cpwm_addr for power-saving support on SDIO +based chipsets. + +Reviewed-by: Ping-Ke Shih +Signed-off-by: Martin Blumenstingl +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230405200729.632435-5-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/main.c | 5 +++++ + 1 file changed, 5 insertions(+) + +--- a/drivers/net/wireless/realtek/rtw88/main.c ++++ b/drivers/net/wireless/realtek/rtw88/main.c +@@ -18,6 +18,7 @@ + #include "debug.h" + #include "bf.h" + #include "sar.h" ++#include "sdio.h" + + bool rtw_disable_lps_deep_mode; + EXPORT_SYMBOL(rtw_disable_lps_deep_mode); +@@ -1785,6 +1786,10 @@ static int rtw_chip_parameter_setup(stru + rtwdev->hci.rpwm_addr = 0x03d9; + rtwdev->hci.cpwm_addr = 0x03da; + break; ++ case RTW_HCI_TYPE_SDIO: ++ rtwdev->hci.rpwm_addr = REG_SDIO_HRPWM1; ++ rtwdev->hci.cpwm_addr = REG_SDIO_HCPWM1_V2; ++ break; + case RTW_HCI_TYPE_USB: + rtwdev->hci.rpwm_addr = 0xfe58; + rtwdev->hci.cpwm_addr = 0xfe57; diff --git a/package/kernel/mac80211/patches/rtl/028-wifi-rtw88-main-Reserve-8-bytes-of-extra-TX-headroom.patch b/package/kernel/mac80211/patches/rtl/028-wifi-rtw88-main-Reserve-8-bytes-of-extra-TX-headroom.patch new file mode 100644 index 0000000000..9fb6dedea6 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/028-wifi-rtw88-main-Reserve-8-bytes-of-extra-TX-headroom.patch @@ -0,0 +1,38 @@ +From 02461d9368c59510ef51cc8a1db1f0f31cfbf9ad Mon Sep 17 00:00:00 2001 +From: Martin Blumenstingl +Date: Wed, 5 Apr 2023 22:07:25 +0200 +Subject: [PATCH 28/45] wifi: rtw88: main: Reserve 8 bytes of extra TX headroom + for SDIO cards + +For SDIO host controllers with DMA support the TX buffer physical memory +address need to be aligned at an 8-byte boundary. Reserve 8 bytes of +extra TX headroom so we can align the data without re-allocating the +transmit buffer. + +While here, also remove the TODO comment regarding extra headroom for +USB and SDIO. For SDIO the extra headroom is now handled and for USB it +was not needed so far. + +Reviewed-by: Ping-Ke Shih +Signed-off-by: Martin Blumenstingl +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230405200729.632435-6-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/main.c | 4 +++- + 1 file changed, 3 insertions(+), 1 deletion(-) + +--- a/drivers/net/wireless/realtek/rtw88/main.c ++++ b/drivers/net/wireless/realtek/rtw88/main.c +@@ -2163,9 +2163,11 @@ int rtw_register_hw(struct rtw_dev *rtwd + int max_tx_headroom = 0; + int ret; + +- /* TODO: USB & SDIO may need extra room? */ + max_tx_headroom = rtwdev->chip->tx_pkt_desc_sz; + ++ if (rtw_hci_type(rtwdev) == RTW_HCI_TYPE_SDIO) ++ max_tx_headroom += RTW_SDIO_DATA_PTR_ALIGN; ++ + hw->extra_tx_headroom = max_tx_headroom; + hw->queues = IEEE80211_NUM_ACS; + hw->txq_data_size = sizeof(struct rtw_txq); diff --git a/package/kernel/mac80211/patches/rtl/029-wifi-rtw88-Add-support-for-the-SDIO-based-RTL8822BS-.patch b/package/kernel/mac80211/patches/rtl/029-wifi-rtw88-Add-support-for-the-SDIO-based-RTL8822BS-.patch new file mode 100644 index 0000000000..b924751b85 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/029-wifi-rtw88-Add-support-for-the-SDIO-based-RTL8822BS-.patch @@ -0,0 +1,94 @@ +From 095e62dd74276dd801c04d9a2a9afcd922811218 Mon Sep 17 00:00:00 2001 +From: Jernej Skrabec +Date: Wed, 5 Apr 2023 22:07:27 +0200 +Subject: [PATCH 29/45] wifi: rtw88: Add support for the SDIO based RTL8822BS + chipset + +Wire up RTL8822BS chipset support using the new rtw88 SDIO HCI code as +well as the existing RTL8822B chipset code. + +Signed-off-by: Jernej Skrabec +Reviewed-by: Ping-Ke Shih +Signed-off-by: Martin Blumenstingl +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230405200729.632435-8-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/Kconfig | 11 ++++++ + drivers/net/wireless/realtek/rtw88/Makefile | 3 ++ + .../net/wireless/realtek/rtw88/rtw8822bs.c | 36 +++++++++++++++++++ + 3 files changed, 50 insertions(+) + create mode 100644 drivers/net/wireless/realtek/rtw88/rtw8822bs.c + +--- a/drivers/net/wireless/realtek/rtw88/Kconfig ++++ b/drivers/net/wireless/realtek/rtw88/Kconfig +@@ -56,6 +56,19 @@ config RTW88_8822BE + + 802.11ac PCIe wireless network adapter + ++config RTW88_8822BS ++ tristate "Realtek 8822BS SDIO wireless network adapter" ++ depends on m ++ depends on MMC ++ select RTW88_CORE ++ select RTW88_SDIO ++ select RTW88_8822B ++ help ++ Select this option will enable support for 8822BS chipset ++ ++ 802.11ac SDIO wireless network adapter ++ ++ + config RTW88_8822BU + tristate "Realtek 8822BU USB wireless network adapter" + depends on m +--- a/drivers/net/wireless/realtek/rtw88/Makefile ++++ b/drivers/net/wireless/realtek/rtw88/Makefile +@@ -26,6 +26,9 @@ rtw88_8822b-objs := rtw8822b.o rtw8822b + obj-$(CPTCFG_RTW88_8822BE) += rtw88_8822be.o + rtw88_8822be-objs := rtw8822be.o + ++obj-$(CPTCFG_RTW88_8822BS) += rtw88_8822bs.o ++rtw88_8822bs-objs := rtw8822bs.o ++ + obj-$(CPTCFG_RTW88_8822BU) += rtw88_8822bu.o + rtw88_8822bu-objs := rtw8822bu.o + +--- /dev/null ++++ b/drivers/net/wireless/realtek/rtw88/rtw8822bs.c +@@ -0,0 +1,36 @@ ++// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause ++/* Copyright(c) Jernej Skrabec ++ */ ++ ++#include ++#include ++#include ++#include "main.h" ++#include "rtw8822b.h" ++#include "sdio.h" ++ ++static const struct sdio_device_id rtw_8822bs_id_table[] = { ++ { ++ SDIO_DEVICE(SDIO_VENDOR_ID_REALTEK, ++ SDIO_DEVICE_ID_REALTEK_RTW8822BS), ++ .driver_data = (kernel_ulong_t)&rtw8822b_hw_spec, ++ }, ++ {} ++}; ++MODULE_DEVICE_TABLE(sdio, rtw_8822bs_id_table); ++ ++static struct sdio_driver rtw_8822bs_driver = { ++ .name = "rtw_8822bs", ++ .probe = rtw_sdio_probe, ++ .remove = rtw_sdio_remove, ++ .id_table = rtw_8822bs_id_table, ++ .drv = { ++ .pm = &rtw_sdio_pm_ops, ++ .shutdown = rtw_sdio_shutdown, ++ } ++}; ++module_sdio_driver(rtw_8822bs_driver); ++ ++MODULE_AUTHOR("Jernej Skrabec "); ++MODULE_DESCRIPTION("Realtek 802.11ac wireless 8822bs driver"); ++MODULE_LICENSE("Dual BSD/GPL"); diff --git a/package/kernel/mac80211/patches/rtl/030-wifi-rtw88-Add-support-for-the-SDIO-based-RTL8822CS-.patch b/package/kernel/mac80211/patches/rtl/030-wifi-rtw88-Add-support-for-the-SDIO-based-RTL8822CS-.patch new file mode 100644 index 0000000000..0d8fbc7859 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/030-wifi-rtw88-Add-support-for-the-SDIO-based-RTL8822CS-.patch @@ -0,0 +1,92 @@ +From 6fdacb78f7999f5c14d9dae10d47de50959297d9 Mon Sep 17 00:00:00 2001 +From: Martin Blumenstingl +Date: Wed, 5 Apr 2023 22:07:28 +0200 +Subject: [PATCH 30/45] wifi: rtw88: Add support for the SDIO based RTL8822CS + chipset + +Wire up RTL8822CS chipset support using the new rtw88 SDIO HCI code as +well as the existing RTL8822C chipset code. + +Reviewed-by: Ping-Ke Shih +Signed-off-by: Martin Blumenstingl +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230405200729.632435-9-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/Kconfig | 11 ++++++ + drivers/net/wireless/realtek/rtw88/Makefile | 3 ++ + .../net/wireless/realtek/rtw88/rtw8822cs.c | 36 +++++++++++++++++++ + 3 files changed, 50 insertions(+) + create mode 100644 drivers/net/wireless/realtek/rtw88/rtw8822cs.c + +--- a/drivers/net/wireless/realtek/rtw88/Kconfig ++++ b/drivers/net/wireless/realtek/rtw88/Kconfig +@@ -93,6 +93,18 @@ config RTW88_8822CE + + 802.11ac PCIe wireless network adapter + ++config RTW88_8822CS ++ tristate "Realtek 8822CS SDIO wireless network adapter" ++ depends on m ++ depends on MMC ++ select RTW88_CORE ++ select RTW88_SDIO ++ select RTW88_8822C ++ help ++ Select this option will enable support for 8822CS chipset ++ ++ 802.11ac SDIO wireless network adapter ++ + config RTW88_8822CU + tristate "Realtek 8822CU USB wireless network adapter" + depends on m +--- a/drivers/net/wireless/realtek/rtw88/Makefile ++++ b/drivers/net/wireless/realtek/rtw88/Makefile +@@ -38,6 +38,9 @@ rtw88_8822c-objs := rtw8822c.o rtw8822c + obj-$(CPTCFG_RTW88_8822CE) += rtw88_8822ce.o + rtw88_8822ce-objs := rtw8822ce.o + ++obj-$(CPTCFG_RTW88_8822CS) += rtw88_8822cs.o ++rtw88_8822cs-objs := rtw8822cs.o ++ + obj-$(CPTCFG_RTW88_8822CU) += rtw88_8822cu.o + rtw88_8822cu-objs := rtw8822cu.o + +--- /dev/null ++++ b/drivers/net/wireless/realtek/rtw88/rtw8822cs.c +@@ -0,0 +1,36 @@ ++// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause ++/* Copyright(c) Martin Blumenstingl ++ */ ++ ++#include ++#include ++#include ++#include "main.h" ++#include "rtw8822c.h" ++#include "sdio.h" ++ ++static const struct sdio_device_id rtw_8822cs_id_table[] = { ++ { ++ SDIO_DEVICE(SDIO_VENDOR_ID_REALTEK, ++ SDIO_DEVICE_ID_REALTEK_RTW8822CS), ++ .driver_data = (kernel_ulong_t)&rtw8822c_hw_spec, ++ }, ++ {} ++}; ++MODULE_DEVICE_TABLE(sdio, rtw_8822cs_id_table); ++ ++static struct sdio_driver rtw_8822cs_driver = { ++ .name = "rtw_8822cs", ++ .probe = rtw_sdio_probe, ++ .remove = rtw_sdio_remove, ++ .id_table = rtw_8822cs_id_table, ++ .drv = { ++ .pm = &rtw_sdio_pm_ops, ++ .shutdown = rtw_sdio_shutdown, ++ } ++}; ++module_sdio_driver(rtw_8822cs_driver); ++ ++MODULE_AUTHOR("Martin Blumenstingl "); ++MODULE_DESCRIPTION("Realtek 802.11ac wireless 8822cs driver"); ++MODULE_LICENSE("Dual BSD/GPL"); diff --git a/package/kernel/mac80211/patches/rtl/031-wifi-rtw88-Add-support-for-the-SDIO-based-RTL8821CS-.patch b/package/kernel/mac80211/patches/rtl/031-wifi-rtw88-Add-support-for-the-SDIO-based-RTL8821CS-.patch new file mode 100644 index 0000000000..abd708efe5 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/031-wifi-rtw88-Add-support-for-the-SDIO-based-RTL8821CS-.patch @@ -0,0 +1,93 @@ +From b2a777d68434375dc05a6fda5fec34a474bbf21f Mon Sep 17 00:00:00 2001 +From: Martin Blumenstingl +Date: Wed, 5 Apr 2023 22:07:29 +0200 +Subject: [PATCH 31/45] wifi: rtw88: Add support for the SDIO based RTL8821CS + chipset + +Wire up RTL8821CS chipset support using the new rtw88 SDIO HCI code as +well as the existing RTL8821C chipset code. + +Reviewed-by: Ping-Ke Shih +Tested-by: Chris Morgan +Signed-off-by: Martin Blumenstingl +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230405200729.632435-10-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/Kconfig | 11 ++++++ + drivers/net/wireless/realtek/rtw88/Makefile | 3 ++ + .../net/wireless/realtek/rtw88/rtw8821cs.c | 36 +++++++++++++++++++ + 3 files changed, 50 insertions(+) + create mode 100644 drivers/net/wireless/realtek/rtw88/rtw8821cs.c + +--- a/drivers/net/wireless/realtek/rtw88/Kconfig ++++ b/drivers/net/wireless/realtek/rtw88/Kconfig +@@ -153,6 +153,18 @@ config RTW88_8821CE + + 802.11ac PCIe wireless network adapter + ++config RTW88_8821CS ++ tristate "Realtek 8821CS SDIO wireless network adapter" ++ depends on m ++ depends on MMC ++ select RTW88_CORE ++ select RTW88_SDIO ++ select RTW88_8821C ++ help ++ Select this option will enable support for 8821CS chipset ++ ++ 802.11ac SDIO wireless network adapter ++ + config RTW88_8821CU + tristate "Realtek 8821CU USB wireless network adapter" + depends on m +--- a/drivers/net/wireless/realtek/rtw88/Makefile ++++ b/drivers/net/wireless/realtek/rtw88/Makefile +@@ -59,6 +59,9 @@ rtw88_8821c-objs := rtw8821c.o rtw8821c + obj-$(CPTCFG_RTW88_8821CE) += rtw88_8821ce.o + rtw88_8821ce-objs := rtw8821ce.o + ++obj-$(CPTCFG_RTW88_8821CS) += rtw88_8821cs.o ++rtw88_8821cs-objs := rtw8821cs.o ++ + obj-$(CPTCFG_RTW88_8821CU) += rtw88_8821cu.o + rtw88_8821cu-objs := rtw8821cu.o + +--- /dev/null ++++ b/drivers/net/wireless/realtek/rtw88/rtw8821cs.c +@@ -0,0 +1,36 @@ ++// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause ++/* Copyright(c) Martin Blumenstingl ++ */ ++ ++#include ++#include ++#include ++#include "main.h" ++#include "rtw8821c.h" ++#include "sdio.h" ++ ++static const struct sdio_device_id rtw_8821cs_id_table[] = { ++ { ++ SDIO_DEVICE(SDIO_VENDOR_ID_REALTEK, ++ SDIO_DEVICE_ID_REALTEK_RTW8821CS), ++ .driver_data = (kernel_ulong_t)&rtw8821c_hw_spec, ++ }, ++ {} ++}; ++MODULE_DEVICE_TABLE(sdio, rtw_8821cs_id_table); ++ ++static struct sdio_driver rtw_8821cs_driver = { ++ .name = "rtw_8821cs", ++ .probe = rtw_sdio_probe, ++ .remove = rtw_sdio_remove, ++ .id_table = rtw_8821cs_id_table, ++ .drv = { ++ .pm = &rtw_sdio_pm_ops, ++ .shutdown = rtw_sdio_shutdown, ++ } ++}; ++module_sdio_driver(rtw_8821cs_driver); ++ ++MODULE_AUTHOR("Martin Blumenstingl "); ++MODULE_DESCRIPTION("Realtek 802.11ac wireless 8821cs driver"); ++MODULE_LICENSE("Dual BSD/GPL"); diff --git a/package/kernel/mac80211/patches/rtl/032-wifi-rtw88-add-bitmap-for-dynamic-port-settings.patch b/package/kernel/mac80211/patches/rtl/032-wifi-rtw88-add-bitmap-for-dynamic-port-settings.patch new file mode 100644 index 0000000000..e84e977875 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/032-wifi-rtw88-add-bitmap-for-dynamic-port-settings.patch @@ -0,0 +1,108 @@ +From f0e741e4ddbc01610ca87167a123702b3fdac51f Mon Sep 17 00:00:00 2001 +From: Po-Hao Huang +Date: Fri, 14 Apr 2023 20:11:28 +0800 +Subject: [PATCH 32/45] wifi: rtw88: add bitmap for dynamic port settings + +In order to support multiple interfaces, multiple port settings will +be required. Current code always uses port 0 and should be changed. +Declare a bitmap with size equal to hardware port number to record +the current usage. + +Signed-off-by: Po-Hao Huang +Signed-off-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230414121135.17828-2-pkshih@realtek.com +--- + drivers/net/wireless/realtek/rtw88/mac80211.c | 13 ++++++++++--- + drivers/net/wireless/realtek/rtw88/main.c | 1 + + drivers/net/wireless/realtek/rtw88/main.h | 10 ++++++++++ + 3 files changed, 21 insertions(+), 3 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/mac80211.c ++++ b/drivers/net/wireless/realtek/rtw88/mac80211.c +@@ -155,25 +155,30 @@ static int rtw_ops_add_interface(struct + struct rtw_vif *rtwvif = (struct rtw_vif *)vif->drv_priv; + enum rtw_net_type net_type; + u32 config = 0; +- u8 port = 0; ++ u8 port; + u8 bcn_ctrl = 0; + + if (rtw_fw_feature_check(&rtwdev->fw, FW_FEATURE_BCN_FILTER)) + vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER | + IEEE80211_VIF_SUPPORTS_CQM_RSSI; +- rtwvif->port = port; + rtwvif->stats.tx_unicast = 0; + rtwvif->stats.rx_unicast = 0; + rtwvif->stats.tx_cnt = 0; + rtwvif->stats.rx_cnt = 0; + rtwvif->scan_req = NULL; + memset(&rtwvif->bfee, 0, sizeof(struct rtw_bfee)); +- rtwvif->conf = &rtw_vif_port[port]; + rtw_txq_init(rtwdev, vif->txq); + INIT_LIST_HEAD(&rtwvif->rsvd_page_list); + + mutex_lock(&rtwdev->mutex); + ++ port = find_first_zero_bit(rtwdev->hw_port, RTW_PORT_NUM); ++ if (port >= RTW_PORT_NUM) ++ return -EINVAL; ++ set_bit(port, rtwdev->hw_port); ++ ++ rtwvif->port = port; ++ rtwvif->conf = &rtw_vif_port[port]; + rtw_leave_lps_deep(rtwdev); + + switch (vif->type) { +@@ -195,6 +200,7 @@ static int rtw_ops_add_interface(struct + break; + default: + WARN_ON(1); ++ clear_bit(rtwvif->port, rtwdev->hw_port); + mutex_unlock(&rtwdev->mutex); + return -EINVAL; + } +@@ -236,6 +242,7 @@ static void rtw_ops_remove_interface(str + rtwvif->bcn_ctrl = 0; + config |= PORT_SET_BCN_CTRL; + rtw_vif_port_config(rtwdev, rtwvif, config); ++ clear_bit(rtwvif->port, rtwdev->hw_port); + + mutex_unlock(&rtwdev->mutex); + } +--- a/drivers/net/wireless/realtek/rtw88/main.c ++++ b/drivers/net/wireless/realtek/rtw88/main.c +@@ -610,6 +610,7 @@ free: + rcu_read_unlock(); + rtw_iterate_stas_atomic(rtwdev, rtw_reset_sta_iter, rtwdev); + rtw_iterate_vifs_atomic(rtwdev, rtw_reset_vif_iter, rtwdev); ++ bitmap_zero(rtwdev->hw_port, RTW_PORT_NUM); + rtw_enter_ips(rtwdev); + } + +--- a/drivers/net/wireless/realtek/rtw88/main.h ++++ b/drivers/net/wireless/realtek/rtw88/main.h +@@ -395,6 +395,15 @@ enum rtw_snr { + RTW_SNR_NUM + }; + ++enum rtw_port { ++ RTW_PORT_0 = 0, ++ RTW_PORT_1 = 1, ++ RTW_PORT_2 = 2, ++ RTW_PORT_3 = 3, ++ RTW_PORT_4 = 4, ++ RTW_PORT_NUM ++}; ++ + enum rtw_wow_flags { + RTW_WOW_FLAG_EN_MAGIC_PKT, + RTW_WOW_FLAG_EN_REKEY_PKT, +@@ -2036,6 +2045,7 @@ struct rtw_dev { + u8 sta_cnt; + u32 rts_threshold; + ++ DECLARE_BITMAP(hw_port, RTW_PORT_NUM); + DECLARE_BITMAP(mac_id_map, RTW_MAX_MAC_ID_NUM); + DECLARE_BITMAP(flags, NUM_OF_RTW_FLAGS); + diff --git a/package/kernel/mac80211/patches/rtl/033-wifi-rtw88-add-port-switch-for-AP-mode.patch b/package/kernel/mac80211/patches/rtl/033-wifi-rtw88-add-port-switch-for-AP-mode.patch new file mode 100644 index 0000000000..4467c77acb --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/033-wifi-rtw88-add-port-switch-for-AP-mode.patch @@ -0,0 +1,126 @@ +From ccf73f6e69c0244a979e97eb6c38f80cd6cbc116 Mon Sep 17 00:00:00 2001 +From: Po-Hao Huang +Date: Fri, 14 Apr 2023 20:11:29 +0800 +Subject: [PATCH 33/45] wifi: rtw88: add port switch for AP mode + +Switch port settings if AP mode does not start on port 0 because of +hardware limitation. For some ICs, beacons on ports other than zero +could misbehave and do not issue properly, to fix this we change AP +VIFs to port zero when multiple interfaces is active. + +Signed-off-by: Po-Hao Huang +Signed-off-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230414121135.17828-3-pkshih@realtek.com +--- + drivers/net/wireless/realtek/rtw88/mac80211.c | 1 + + drivers/net/wireless/realtek/rtw88/main.c | 79 +++++++++++++++++++ + drivers/net/wireless/realtek/rtw88/main.h | 1 + + 3 files changed, 81 insertions(+) + +--- a/drivers/net/wireless/realtek/rtw88/mac80211.c ++++ b/drivers/net/wireless/realtek/rtw88/mac80211.c +@@ -212,6 +212,7 @@ static int rtw_ops_add_interface(struct + rtwvif->bcn_ctrl = bcn_ctrl; + config |= PORT_SET_BCN_CTRL; + rtw_vif_port_config(rtwdev, rtwvif, config); ++ rtw_core_port_switch(rtwdev, vif); + + mutex_unlock(&rtwdev->mutex); + +--- a/drivers/net/wireless/realtek/rtw88/main.c ++++ b/drivers/net/wireless/realtek/rtw88/main.c +@@ -2251,6 +2251,85 @@ void rtw_unregister_hw(struct rtw_dev *r + } + EXPORT_SYMBOL(rtw_unregister_hw); + ++static ++void rtw_swap_reg_nbytes(struct rtw_dev *rtwdev, const struct rtw_hw_reg *reg1, ++ const struct rtw_hw_reg *reg2, u8 nbytes) ++{ ++ u8 i; ++ ++ for (i = 0; i < nbytes; i++) { ++ u8 v1 = rtw_read8(rtwdev, reg1->addr + i); ++ u8 v2 = rtw_read8(rtwdev, reg2->addr + i); ++ ++ rtw_write8(rtwdev, reg1->addr + i, v2); ++ rtw_write8(rtwdev, reg2->addr + i, v1); ++ } ++} ++ ++static ++void rtw_swap_reg_mask(struct rtw_dev *rtwdev, const struct rtw_hw_reg *reg1, ++ const struct rtw_hw_reg *reg2) ++{ ++ u32 v1, v2; ++ ++ v1 = rtw_read32_mask(rtwdev, reg1->addr, reg1->mask); ++ v2 = rtw_read32_mask(rtwdev, reg2->addr, reg2->mask); ++ rtw_write32_mask(rtwdev, reg2->addr, reg2->mask, v1); ++ rtw_write32_mask(rtwdev, reg1->addr, reg1->mask, v2); ++} ++ ++struct rtw_iter_port_switch_data { ++ struct rtw_dev *rtwdev; ++ struct rtw_vif *rtwvif_ap; ++}; ++ ++static void rtw_port_switch_iter(void *data, u8 *mac, struct ieee80211_vif *vif) ++{ ++ struct rtw_iter_port_switch_data *iter_data = data; ++ struct rtw_dev *rtwdev = iter_data->rtwdev; ++ struct rtw_vif *rtwvif_target = (struct rtw_vif *)vif->drv_priv; ++ struct rtw_vif *rtwvif_ap = iter_data->rtwvif_ap; ++ const struct rtw_hw_reg *reg1, *reg2; ++ ++ if (rtwvif_target->port != RTW_PORT_0) ++ return; ++ ++ rtw_dbg(rtwdev, RTW_DBG_STATE, "AP port switch from %d -> %d\n", ++ rtwvif_ap->port, rtwvif_target->port); ++ ++ reg1 = &rtwvif_ap->conf->net_type; ++ reg2 = &rtwvif_target->conf->net_type; ++ rtw_swap_reg_mask(rtwdev, reg1, reg2); ++ ++ reg1 = &rtwvif_ap->conf->mac_addr; ++ reg2 = &rtwvif_target->conf->mac_addr; ++ rtw_swap_reg_nbytes(rtwdev, reg1, reg2, ETH_ALEN); ++ ++ reg1 = &rtwvif_ap->conf->bssid; ++ reg2 = &rtwvif_target->conf->bssid; ++ rtw_swap_reg_nbytes(rtwdev, reg1, reg2, ETH_ALEN); ++ ++ reg1 = &rtwvif_ap->conf->bcn_ctrl; ++ reg2 = &rtwvif_target->conf->bcn_ctrl; ++ rtw_swap_reg_nbytes(rtwdev, reg1, reg2, 1); ++ ++ swap(rtwvif_target->port, rtwvif_ap->port); ++ swap(rtwvif_target->conf, rtwvif_ap->conf); ++} ++ ++void rtw_core_port_switch(struct rtw_dev *rtwdev, struct ieee80211_vif *vif) ++{ ++ struct rtw_vif *rtwvif = (struct rtw_vif *)vif->drv_priv; ++ struct rtw_iter_port_switch_data iter_data; ++ ++ if (vif->type != NL80211_IFTYPE_AP || rtwvif->port == RTW_PORT_0) ++ return; ++ ++ iter_data.rtwdev = rtwdev; ++ iter_data.rtwvif_ap = rtwvif; ++ rtw_iterate_vifs(rtwdev, rtw_port_switch_iter, &iter_data); ++} ++ + MODULE_AUTHOR("Realtek Corporation"); + MODULE_DESCRIPTION("Realtek 802.11ac wireless core module"); + MODULE_LICENSE("Dual BSD/GPL"); +--- a/drivers/net/wireless/realtek/rtw88/main.h ++++ b/drivers/net/wireless/realtek/rtw88/main.h +@@ -2198,4 +2198,5 @@ void rtw_set_txrx_1ss(struct rtw_dev *rt + void rtw_update_channel(struct rtw_dev *rtwdev, u8 center_channel, + u8 primary_channel, enum rtw_supported_band band, + enum rtw_bandwidth bandwidth); ++void rtw_core_port_switch(struct rtw_dev *rtwdev, struct ieee80211_vif *vif); + #endif diff --git a/package/kernel/mac80211/patches/rtl/034-wifi-rtw88-8822c-extend-reserved-page-number.patch b/package/kernel/mac80211/patches/rtl/034-wifi-rtw88-8822c-extend-reserved-page-number.patch new file mode 100644 index 0000000000..cc4eef3184 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/034-wifi-rtw88-8822c-extend-reserved-page-number.patch @@ -0,0 +1,84 @@ +From ffa71c5477793f41bc7537a60aa54ac40275ab78 Mon Sep 17 00:00:00 2001 +From: Po-Hao Huang +Date: Fri, 14 Apr 2023 20:11:30 +0800 +Subject: [PATCH 34/45] wifi: rtw88: 8822c: extend reserved page number + +Extend 8822c's reserved page number to accommodate additional required +pages. Reserved page is an area of memory in the FIFO dedicated for +special purposes. Previously only one interface is supported so 8 pages +should suffice, extend it so we can support 2 interfaces concurrently. + +Signed-off-by: Po-Hao Huang +Signed-off-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230414121135.17828-4-pkshih@realtek.com +--- + drivers/net/wireless/realtek/rtw88/mac.c | 2 +- + drivers/net/wireless/realtek/rtw88/main.h | 1 + + drivers/net/wireless/realtek/rtw88/rtw8723d.c | 1 + + drivers/net/wireless/realtek/rtw88/rtw8821c.c | 1 + + drivers/net/wireless/realtek/rtw88/rtw8822b.c | 1 + + drivers/net/wireless/realtek/rtw88/rtw8822c.c | 1 + + 6 files changed, 6 insertions(+), 1 deletion(-) + +--- a/drivers/net/wireless/realtek/rtw88/mac.c ++++ b/drivers/net/wireless/realtek/rtw88/mac.c +@@ -1119,7 +1119,7 @@ static int set_trx_fifo_info(struct rtw_ + u8 csi_buf_pg_num = chip->csi_buf_pg_num; + + /* config rsvd page num */ +- fifo->rsvd_drv_pg_num = 8; ++ fifo->rsvd_drv_pg_num = chip->rsvd_drv_pg_num; + fifo->txff_pg_num = chip->txff_size >> 7; + if (rtw_chip_wcpu_11n(rtwdev)) + fifo->rsvd_pg_num = fifo->rsvd_drv_pg_num; +--- a/drivers/net/wireless/realtek/rtw88/main.h ++++ b/drivers/net/wireless/realtek/rtw88/main.h +@@ -1177,6 +1177,7 @@ struct rtw_chip_info { + u32 txff_size; + u32 rxff_size; + u32 fw_rxff_size; ++ u16 rsvd_drv_pg_num; + u8 band; + u8 page_size; + u8 csi_buf_pg_num; +--- a/drivers/net/wireless/realtek/rtw88/rtw8723d.c ++++ b/drivers/net/wireless/realtek/rtw88/rtw8723d.c +@@ -2743,6 +2743,7 @@ const struct rtw_chip_info rtw8723d_hw_s + .ptct_efuse_size = 96 + 1, + .txff_size = 32768, + .rxff_size = 16384, ++ .rsvd_drv_pg_num = 8, + .txgi_factor = 1, + .is_pwr_by_rate_dec = true, + .max_power_index = 0x3f, +--- a/drivers/net/wireless/realtek/rtw88/rtw8821c.c ++++ b/drivers/net/wireless/realtek/rtw88/rtw8821c.c +@@ -1920,6 +1920,7 @@ const struct rtw_chip_info rtw8821c_hw_s + .ptct_efuse_size = 96, + .txff_size = 65536, + .rxff_size = 16384, ++ .rsvd_drv_pg_num = 8, + .txgi_factor = 1, + .is_pwr_by_rate_dec = true, + .max_power_index = 0x3f, +--- a/drivers/net/wireless/realtek/rtw88/rtw8822b.c ++++ b/drivers/net/wireless/realtek/rtw88/rtw8822b.c +@@ -2540,6 +2540,7 @@ const struct rtw_chip_info rtw8822b_hw_s + .txff_size = 262144, + .rxff_size = 24576, + .fw_rxff_size = 12288, ++ .rsvd_drv_pg_num = 8, + .txgi_factor = 1, + .is_pwr_by_rate_dec = true, + .max_power_index = 0x3f, +--- a/drivers/net/wireless/realtek/rtw88/rtw8822c.c ++++ b/drivers/net/wireless/realtek/rtw88/rtw8822c.c +@@ -5358,6 +5358,7 @@ const struct rtw_chip_info rtw8822c_hw_s + .txff_size = 262144, + .rxff_size = 24576, + .fw_rxff_size = 12288, ++ .rsvd_drv_pg_num = 16, + .txgi_factor = 2, + .is_pwr_by_rate_dec = false, + .max_power_index = 0x7f, diff --git a/package/kernel/mac80211/patches/rtl/035-wifi-rtw88-disallow-PS-during-AP-mode.patch b/package/kernel/mac80211/patches/rtl/035-wifi-rtw88-disallow-PS-during-AP-mode.patch new file mode 100644 index 0000000000..060600f00a --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/035-wifi-rtw88-disallow-PS-during-AP-mode.patch @@ -0,0 +1,73 @@ +From 5ec69129f195f340acb15b8535cb372ccdbcf5d7 Mon Sep 17 00:00:00 2001 +From: Po-Hao Huang +Date: Fri, 14 Apr 2023 20:11:31 +0800 +Subject: [PATCH 35/45] wifi: rtw88: disallow PS during AP mode + +Firmware can't support PS mode during AP mode, so disallow this case. + +Signed-off-by: Po-Hao Huang +Signed-off-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230414121135.17828-5-pkshih@realtek.com +--- + drivers/net/wireless/realtek/rtw88/mac80211.c | 13 +++++++++++++ + drivers/net/wireless/realtek/rtw88/main.c | 2 +- + drivers/net/wireless/realtek/rtw88/main.h | 1 + + 3 files changed, 15 insertions(+), 1 deletion(-) + +--- a/drivers/net/wireless/realtek/rtw88/mac80211.c ++++ b/drivers/net/wireless/realtek/rtw88/mac80211.c +@@ -449,12 +449,24 @@ static int rtw_ops_start_ap(struct ieee8 + const struct rtw_chip_info *chip = rtwdev->chip; + + mutex_lock(&rtwdev->mutex); ++ rtwdev->ap_active = true; + chip->ops->phy_calibration(rtwdev); + mutex_unlock(&rtwdev->mutex); + + return 0; + } + ++static void rtw_ops_stop_ap(struct ieee80211_hw *hw, ++ struct ieee80211_vif *vif, ++ struct ieee80211_bss_conf *link_conf) ++{ ++ struct rtw_dev *rtwdev = hw->priv; ++ ++ mutex_lock(&rtwdev->mutex); ++ rtwdev->ap_active = false; ++ mutex_unlock(&rtwdev->mutex); ++} ++ + static int rtw_ops_conf_tx(struct ieee80211_hw *hw, + struct ieee80211_vif *vif, + unsigned int link_id, u16 ac, +@@ -916,6 +928,7 @@ const struct ieee80211_ops rtw_ops = { + .configure_filter = rtw_ops_configure_filter, + .bss_info_changed = rtw_ops_bss_info_changed, + .start_ap = rtw_ops_start_ap, ++ .stop_ap = rtw_ops_stop_ap, + .conf_tx = rtw_ops_conf_tx, + .sta_add = rtw_ops_sta_add, + .sta_remove = rtw_ops_sta_remove, +--- a/drivers/net/wireless/realtek/rtw88/main.c ++++ b/drivers/net/wireless/realtek/rtw88/main.c +@@ -257,7 +257,7 @@ static void rtw_watch_dog_work(struct wo + * threshold. + */ + if (rtwdev->ps_enabled && data.rtwvif && !ps_active && +- !rtwdev->beacon_loss) ++ !rtwdev->beacon_loss && !rtwdev->ap_active) + rtw_enter_lps(rtwdev, data.rtwvif->port); + + rtwdev->watch_dog_cnt++; +--- a/drivers/net/wireless/realtek/rtw88/main.h ++++ b/drivers/net/wireless/realtek/rtw88/main.h +@@ -2058,6 +2058,7 @@ struct rtw_dev { + + bool need_rfk; + struct completion fw_scan_density; ++ bool ap_active; + + /* hci related data, must be last */ + u8 priv[] __aligned(sizeof(void *)); diff --git a/package/kernel/mac80211/patches/rtl/036-wifi-rtw88-refine-reserved-page-flow-for-AP-mode.patch b/package/kernel/mac80211/patches/rtl/036-wifi-rtw88-refine-reserved-page-flow-for-AP-mode.patch new file mode 100644 index 0000000000..8820e3adfa --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/036-wifi-rtw88-refine-reserved-page-flow-for-AP-mode.patch @@ -0,0 +1,50 @@ +From 982f4a2004f712ce7aed7f7e69fa64e4c06eee7d Mon Sep 17 00:00:00 2001 +From: Po-Hao Huang +Date: Fri, 14 Apr 2023 20:13:00 +0800 +Subject: [PATCH 36/45] wifi: rtw88: refine reserved page flow for AP mode + +Only gather reserved pages from AP interface after it has started. Or +else ieee80211_beacon_get_*() returns NULL and causes other VIFs' +reserved pages fail to download. Update location of current reserved page +after beacon renews so offsets changed by beacon can be recognized. + +Signed-off-by: Po-Hao Huang +Signed-off-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230414121300.17900-1-pkshih@realtek.com +--- + drivers/net/wireless/realtek/rtw88/fw.c | 5 +++++ + drivers/net/wireless/realtek/rtw88/mac80211.c | 1 + + 2 files changed, 6 insertions(+) + +--- a/drivers/net/wireless/realtek/rtw88/fw.c ++++ b/drivers/net/wireless/realtek/rtw88/fw.c +@@ -1393,6 +1393,10 @@ static void rtw_build_rsvd_page_iter(voi + struct rtw_vif *rtwvif = (struct rtw_vif *)vif->drv_priv; + struct rtw_rsvd_page *rsvd_pkt; + ++ /* AP not yet started, don't gather its rsvd pages */ ++ if (vif->type == NL80211_IFTYPE_AP && !rtwdev->ap_active) ++ return; ++ + list_for_each_entry(rsvd_pkt, &rtwvif->rsvd_page_list, vif_list) { + if (rsvd_pkt->type == RSVD_BEACON) + list_add(&rsvd_pkt->build_list, +@@ -1614,6 +1618,7 @@ void rtw_fw_update_beacon_work(struct wo + + mutex_lock(&rtwdev->mutex); + rtw_fw_download_rsvd_page(rtwdev); ++ rtw_send_rsvd_page_h2c(rtwdev); + mutex_unlock(&rtwdev->mutex); + } + +--- a/drivers/net/wireless/realtek/rtw88/mac80211.c ++++ b/drivers/net/wireless/realtek/rtw88/mac80211.c +@@ -417,6 +417,7 @@ static void rtw_ops_bss_info_changed(str + if (changed & BSS_CHANGED_BEACON) { + rtw_set_dtim_period(rtwdev, conf->dtim_period); + rtw_fw_download_rsvd_page(rtwdev); ++ rtw_send_rsvd_page_h2c(rtwdev); + } + + if (changed & BSS_CHANGED_BEACON_ENABLED) { diff --git a/package/kernel/mac80211/patches/rtl/037-wifi-rtw88-prevent-scan-abort-with-other-VIFs.patch b/package/kernel/mac80211/patches/rtl/037-wifi-rtw88-prevent-scan-abort-with-other-VIFs.patch new file mode 100644 index 0000000000..9263bde937 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/037-wifi-rtw88-prevent-scan-abort-with-other-VIFs.patch @@ -0,0 +1,73 @@ +From a1b8015da57a783b3ceebd8e114afbe07536bd54 Mon Sep 17 00:00:00 2001 +From: Po-Hao Huang +Date: Fri, 14 Apr 2023 20:13:12 +0800 +Subject: [PATCH 37/45] wifi: rtw88: prevent scan abort with other VIFs + +Only abort scan with current scanning VIF. If we have more than one +interface, we could call rtw_hw_scan_abort() with the wrong VIF as +input. This avoids potential null pointer being accessed when actually +the other VIF is scanning. + +Signed-off-by: Po-Hao Huang +Signed-off-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230414121312.17954-1-pkshih@realtek.com +--- + drivers/net/wireless/realtek/rtw88/fw.c | 4 +++- + drivers/net/wireless/realtek/rtw88/fw.h | 2 +- + drivers/net/wireless/realtek/rtw88/mac80211.c | 7 ++++--- + 3 files changed, 8 insertions(+), 5 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/fw.c ++++ b/drivers/net/wireless/realtek/rtw88/fw.c +@@ -2163,8 +2163,10 @@ out: + return ret; + } + +-void rtw_hw_scan_abort(struct rtw_dev *rtwdev, struct ieee80211_vif *vif) ++void rtw_hw_scan_abort(struct rtw_dev *rtwdev) + { ++ struct ieee80211_vif *vif = rtwdev->scan_info.scanning_vif; ++ + if (!rtw_fw_feature_check(&rtwdev->fw, FW_FEATURE_SCAN_OFFLOAD)) + return; + +--- a/drivers/net/wireless/realtek/rtw88/fw.h ++++ b/drivers/net/wireless/realtek/rtw88/fw.h +@@ -868,5 +868,5 @@ int rtw_hw_scan_offload(struct rtw_dev * + bool enable); + void rtw_hw_scan_status_report(struct rtw_dev *rtwdev, struct sk_buff *skb); + void rtw_hw_scan_chan_switch(struct rtw_dev *rtwdev, struct sk_buff *skb); +-void rtw_hw_scan_abort(struct rtw_dev *rtwdev, struct ieee80211_vif *vif); ++void rtw_hw_scan_abort(struct rtw_dev *rtwdev); + #endif +--- a/drivers/net/wireless/realtek/rtw88/mac80211.c ++++ b/drivers/net/wireless/realtek/rtw88/mac80211.c +@@ -393,7 +393,8 @@ static void rtw_ops_bss_info_changed(str + * when disconnected by peer + */ + if (test_bit(RTW_FLAG_SCANNING, rtwdev->flags)) +- rtw_hw_scan_abort(rtwdev, vif); ++ rtw_hw_scan_abort(rtwdev); ++ + } + + config |= PORT_SET_NET_TYPE; +@@ -870,7 +871,7 @@ static int rtw_ops_hw_scan(struct ieee80 + rtw_hw_scan_start(rtwdev, vif, req); + ret = rtw_hw_scan_offload(rtwdev, vif, true); + if (ret) { +- rtw_hw_scan_abort(rtwdev, vif); ++ rtw_hw_scan_abort(rtwdev); + rtw_err(rtwdev, "HW scan failed with status: %d\n", ret); + } + mutex_unlock(&rtwdev->mutex); +@@ -890,7 +891,7 @@ static void rtw_ops_cancel_hw_scan(struc + return; + + mutex_lock(&rtwdev->mutex); +- rtw_hw_scan_abort(rtwdev, vif); ++ rtw_hw_scan_abort(rtwdev); + mutex_unlock(&rtwdev->mutex); + } + diff --git a/package/kernel/mac80211/patches/rtl/038-wifi-rtw88-handle-station-mode-concurrent-scan-with-.patch b/package/kernel/mac80211/patches/rtl/038-wifi-rtw88-handle-station-mode-concurrent-scan-with-.patch new file mode 100644 index 0000000000..d0a1315e45 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/038-wifi-rtw88-handle-station-mode-concurrent-scan-with-.patch @@ -0,0 +1,154 @@ +From 96fbb84de4ffce76d54de8656efe0a580081c037 Mon Sep 17 00:00:00 2001 +From: Po-Hao Huang +Date: Fri, 14 Apr 2023 20:13:23 +0800 +Subject: [PATCH 38/45] wifi: rtw88: handle station mode concurrent scan with + AP mode + +This patch allows vifs sharing same hardware with the AP mode vif to +do scan, do note that this could lead to packet loss or disconnection +of the AP's clients. Since we don't have chanctx, update scan info +upon set channel so bandwidth changes won't go unnoticed and get +misconfigured after scan. Download beacon just before scan starts to +allow hardware to get proper content to do beaconing. Last, beacons +should only be transmitted in AP's operating channel. Turn related +beacon functions off while we're in other channels so the receiving +stations won't get confused. + +Signed-off-by: Po-Hao Huang +Signed-off-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230414121323.18008-1-pkshih@realtek.com +--- + drivers/net/wireless/realtek/rtw88/fw.c | 11 +++++- + drivers/net/wireless/realtek/rtw88/mac80211.c | 5 ++- + drivers/net/wireless/realtek/rtw88/main.c | 39 +++++++++++++++++++ + drivers/net/wireless/realtek/rtw88/main.h | 2 + + 4 files changed, 55 insertions(+), 2 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/fw.c ++++ b/drivers/net/wireless/realtek/rtw88/fw.c +@@ -2160,6 +2160,12 @@ int rtw_hw_scan_offload(struct rtw_dev * + } + rtw_fw_set_scan_offload(rtwdev, &cs_option, rtwvif, &chan_list); + out: ++ if (rtwdev->ap_active) { ++ ret = rtw_download_beacon(rtwdev); ++ if (ret) ++ rtw_err(rtwdev, "HW scan download beacon failed\n"); ++ } ++ + return ret; + } + +@@ -2251,6 +2257,7 @@ void rtw_hw_scan_chan_switch(struct rtw_ + if (rtw_is_op_chan(rtwdev, chan)) { + rtw_store_op_chan(rtwdev, false); + ieee80211_wake_queues(rtwdev->hw); ++ rtw_core_enable_beacon(rtwdev, true); + } + } else if (id == RTW_SCAN_NOTIFY_ID_PRESWITCH) { + if (IS_CH_5G_BAND(chan)) { +@@ -2269,8 +2276,10 @@ void rtw_hw_scan_chan_switch(struct rtw_ + * if next channel is non-op channel. + */ + if (!rtw_is_op_chan(rtwdev, chan) && +- rtw_is_op_chan(rtwdev, hal->current_channel)) ++ rtw_is_op_chan(rtwdev, hal->current_channel)) { ++ rtw_core_enable_beacon(rtwdev, false); + ieee80211_stop_queues(rtwdev->hw); ++ } + } + + rtw_dbg(rtwdev, RTW_DBG_HW_SCAN, +--- a/drivers/net/wireless/realtek/rtw88/mac80211.c ++++ b/drivers/net/wireless/realtek/rtw88/mac80211.c +@@ -404,7 +404,7 @@ static void rtw_ops_bss_info_changed(str + if (changed & BSS_CHANGED_BSSID) { + ether_addr_copy(rtwvif->bssid, conf->bssid); + config |= PORT_SET_BSSID; +- if (is_zero_ether_addr(rtwvif->bssid)) ++ if (!rtw_core_check_sta_active(rtwdev)) + rtw_clear_op_chan(rtwdev); + else + rtw_store_op_chan(rtwdev, true); +@@ -452,6 +452,7 @@ static int rtw_ops_start_ap(struct ieee8 + + mutex_lock(&rtwdev->mutex); + rtwdev->ap_active = true; ++ rtw_store_op_chan(rtwdev, true); + chip->ops->phy_calibration(rtwdev); + mutex_unlock(&rtwdev->mutex); + +@@ -466,6 +467,8 @@ static void rtw_ops_stop_ap(struct ieee8 + + mutex_lock(&rtwdev->mutex); + rtwdev->ap_active = false; ++ if (!rtw_core_check_sta_active(rtwdev)) ++ rtw_clear_op_chan(rtwdev); + mutex_unlock(&rtwdev->mutex); + } + +--- a/drivers/net/wireless/realtek/rtw88/main.c ++++ b/drivers/net/wireless/realtek/rtw88/main.c +@@ -830,6 +830,9 @@ void rtw_set_channel(struct rtw_dev *rtw + + rtw_update_channel(rtwdev, center_chan, primary_chan, band, bandwidth); + ++ if (rtwdev->scan_info.op_chan) ++ rtw_store_op_chan(rtwdev, true); ++ + chip->ops->set_channel(rtwdev, center_chan, bandwidth, + hal->current_primary_channel_index); + +@@ -2330,6 +2333,42 @@ void rtw_core_port_switch(struct rtw_dev + rtw_iterate_vifs(rtwdev, rtw_port_switch_iter, &iter_data); + } + ++static void rtw_check_sta_active_iter(void *data, u8 *mac, ++ struct ieee80211_vif *vif) ++{ ++ struct rtw_vif *rtwvif = (struct rtw_vif *)vif->drv_priv; ++ bool *active = data; ++ ++ if (*active) ++ return; ++ ++ if (vif->type != NL80211_IFTYPE_STATION) ++ return; ++ ++ if (vif->cfg.assoc || !is_zero_ether_addr(rtwvif->bssid)) ++ *active = true; ++} ++ ++bool rtw_core_check_sta_active(struct rtw_dev *rtwdev) ++{ ++ bool sta_active = false; ++ ++ rtw_iterate_vifs(rtwdev, rtw_check_sta_active_iter, &sta_active); ++ ++ return rtwdev->ap_active || sta_active; ++} ++ ++void rtw_core_enable_beacon(struct rtw_dev *rtwdev, bool enable) ++{ ++ if (!rtwdev->ap_active) ++ return; ++ ++ if (enable) ++ rtw_write32_set(rtwdev, REG_BCN_CTRL, BIT_EN_BCN_FUNCTION); ++ else ++ rtw_write32_clr(rtwdev, REG_BCN_CTRL, BIT_EN_BCN_FUNCTION); ++} ++ + MODULE_AUTHOR("Realtek Corporation"); + MODULE_DESCRIPTION("Realtek 802.11ac wireless core module"); + MODULE_LICENSE("Dual BSD/GPL"); +--- a/drivers/net/wireless/realtek/rtw88/main.h ++++ b/drivers/net/wireless/realtek/rtw88/main.h +@@ -2201,4 +2201,6 @@ void rtw_update_channel(struct rtw_dev * + u8 primary_channel, enum rtw_supported_band band, + enum rtw_bandwidth bandwidth); + void rtw_core_port_switch(struct rtw_dev *rtwdev, struct ieee80211_vif *vif); ++bool rtw_core_check_sta_active(struct rtw_dev *rtwdev); ++void rtw_core_enable_beacon(struct rtw_dev *rtwdev, bool enable); + #endif diff --git a/package/kernel/mac80211/patches/rtl/039-wifi-rtw88-8822c-add-iface-combination.patch b/package/kernel/mac80211/patches/rtl/039-wifi-rtw88-8822c-add-iface-combination.patch new file mode 100644 index 0000000000..ddea655167 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/039-wifi-rtw88-8822c-add-iface-combination.patch @@ -0,0 +1,58 @@ +From d16836cdcc3b17734f6aae165268d2f1777a4f74 Mon Sep 17 00:00:00 2001 +From: Po-Hao Huang +Date: Fri, 14 Apr 2023 20:13:31 +0800 +Subject: [PATCH 39/45] wifi: rtw88: 8822c: add iface combination + +Allow 8822c to operate two interface concurrently, only 1 AP mode plus +1 station mode under same frequency is supported. Combination of other +types will not be added until requested. + +Signed-off-by: Po-Hao Huang +Signed-off-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230414121331.18062-1-pkshih@realtek.com +--- + drivers/net/wireless/realtek/rtw88/main.c | 25 +++++++++++++++++++++++ + 1 file changed, 25 insertions(+) + +--- a/drivers/net/wireless/realtek/rtw88/main.c ++++ b/drivers/net/wireless/realtek/rtw88/main.c +@@ -103,6 +103,26 @@ static struct ieee80211_rate rtw_ratetab + {.bitrate = 540, .hw_value = 0x0b,}, + }; + ++static const struct ieee80211_iface_limit rtw_iface_limits[] = { ++ { ++ .max = 1, ++ .types = BIT(NL80211_IFTYPE_STATION), ++ }, ++ { ++ .max = 1, ++ .types = BIT(NL80211_IFTYPE_AP), ++ } ++}; ++ ++static const struct ieee80211_iface_combination rtw_iface_combs[] = { ++ { ++ .limits = rtw_iface_limits, ++ .n_limits = ARRAY_SIZE(rtw_iface_limits), ++ .max_interfaces = 2, ++ .num_different_channels = 1, ++ } ++}; ++ + u16 rtw_desc_to_bitrate(u8 desc_rate) + { + struct ieee80211_rate rate; +@@ -2205,6 +2225,11 @@ int rtw_register_hw(struct rtw_dev *rtwd + hw->wiphy->max_scan_ssids = RTW_SCAN_MAX_SSIDS; + hw->wiphy->max_scan_ie_len = rtw_get_max_scan_ie_len(rtwdev); + ++ if (rtwdev->chip->id == RTW_CHIP_TYPE_8822C) { ++ hw->wiphy->iface_combinations = rtw_iface_combs; ++ hw->wiphy->n_iface_combinations = ARRAY_SIZE(rtw_iface_combs); ++ } ++ + wiphy_ext_feature_set(hw->wiphy, NL80211_EXT_FEATURE_CAN_REPLACE_PTK0); + wiphy_ext_feature_set(hw->wiphy, NL80211_EXT_FEATURE_SCAN_RANDOM_SN); + wiphy_ext_feature_set(hw->wiphy, NL80211_EXT_FEATURE_SET_SCAN_DWELL); diff --git a/package/kernel/mac80211/patches/rtl/040-wifi-rtw88-usb-fix-priority-queue-to-endpoint-mappin.patch b/package/kernel/mac80211/patches/rtl/040-wifi-rtw88-usb-fix-priority-queue-to-endpoint-mappin.patch new file mode 100644 index 0000000000..9ac3e61ad4 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/040-wifi-rtw88-usb-fix-priority-queue-to-endpoint-mappin.patch @@ -0,0 +1,140 @@ +From a6f187f92bcc2b17821538b4a11d61764e68b091 Mon Sep 17 00:00:00 2001 +From: Sascha Hauer +Date: Mon, 17 Apr 2023 16:03:55 +0200 +Subject: [PATCH 40/45] wifi: rtw88: usb: fix priority queue to endpoint + mapping + +The RTW88 chipsets have four different priority queues in hardware. For +the USB type chipsets the packets destined for a specific priority queue +must be sent through the endpoint corresponding to the queue. This was +not fully understood when porting from the RTW88 USB out of tree driver +and thus violated. + +This patch implements the qsel to endpoint mapping as in +get_usb_bulkout_id_88xx() in the downstream driver. + +Without this the driver often issues "timed out to flush queue 3" +warnings and often TX stalls completely. + +Signed-off-by: Sascha Hauer +Tested-by: ValdikSS +Tested-by: Alexandru gagniuc +Tested-by: Larry Finger +Cc: stable@vger.kernel.org +Reviewed-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230417140358.2240429-2-s.hauer@pengutronix.de +--- + drivers/net/wireless/realtek/rtw88/usb.c | 70 ++++++++++++++++-------- + 1 file changed, 47 insertions(+), 23 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/usb.c ++++ b/drivers/net/wireless/realtek/rtw88/usb.c +@@ -118,6 +118,22 @@ static void rtw_usb_write32(struct rtw_d + rtw_usb_write(rtwdev, addr, val, 4); + } + ++static int dma_mapping_to_ep(enum rtw_dma_mapping dma_mapping) ++{ ++ switch (dma_mapping) { ++ case RTW_DMA_MAPPING_HIGH: ++ return 0; ++ case RTW_DMA_MAPPING_NORMAL: ++ return 1; ++ case RTW_DMA_MAPPING_LOW: ++ return 2; ++ case RTW_DMA_MAPPING_EXTRA: ++ return 3; ++ default: ++ return -EINVAL; ++ } ++} ++ + static int rtw_usb_parse(struct rtw_dev *rtwdev, + struct usb_interface *interface) + { +@@ -129,6 +145,8 @@ static int rtw_usb_parse(struct rtw_dev + int num_out_pipes = 0; + int i; + u8 num; ++ const struct rtw_chip_info *chip = rtwdev->chip; ++ const struct rtw_rqpn *rqpn; + + for (i = 0; i < interface_desc->bNumEndpoints; i++) { + endpoint = &host_interface->endpoint[i].desc; +@@ -183,31 +201,34 @@ static int rtw_usb_parse(struct rtw_dev + + rtwdev->hci.bulkout_num = num_out_pipes; + +- switch (num_out_pipes) { +- case 4: +- case 3: +- rtwusb->qsel_to_ep[TX_DESC_QSEL_TID0] = 2; +- rtwusb->qsel_to_ep[TX_DESC_QSEL_TID1] = 2; +- rtwusb->qsel_to_ep[TX_DESC_QSEL_TID2] = 2; +- rtwusb->qsel_to_ep[TX_DESC_QSEL_TID3] = 2; +- rtwusb->qsel_to_ep[TX_DESC_QSEL_TID4] = 1; +- rtwusb->qsel_to_ep[TX_DESC_QSEL_TID5] = 1; +- rtwusb->qsel_to_ep[TX_DESC_QSEL_TID6] = 0; +- rtwusb->qsel_to_ep[TX_DESC_QSEL_TID7] = 0; +- break; +- case 2: +- rtwusb->qsel_to_ep[TX_DESC_QSEL_TID0] = 1; +- rtwusb->qsel_to_ep[TX_DESC_QSEL_TID1] = 1; +- rtwusb->qsel_to_ep[TX_DESC_QSEL_TID2] = 1; +- rtwusb->qsel_to_ep[TX_DESC_QSEL_TID3] = 1; +- break; +- case 1: +- break; +- default: +- rtw_err(rtwdev, "failed to get out_pipes(%d)\n", num_out_pipes); ++ if (num_out_pipes < 1 || num_out_pipes > 4) { ++ rtw_err(rtwdev, "invalid number of endpoints %d\n", num_out_pipes); + return -EINVAL; + } + ++ rqpn = &chip->rqpn_table[num_out_pipes]; ++ ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID0] = dma_mapping_to_ep(rqpn->dma_map_be); ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID1] = dma_mapping_to_ep(rqpn->dma_map_bk); ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID2] = dma_mapping_to_ep(rqpn->dma_map_bk); ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID3] = dma_mapping_to_ep(rqpn->dma_map_be); ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID4] = dma_mapping_to_ep(rqpn->dma_map_vi); ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID5] = dma_mapping_to_ep(rqpn->dma_map_vi); ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID6] = dma_mapping_to_ep(rqpn->dma_map_vo); ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID7] = dma_mapping_to_ep(rqpn->dma_map_vo); ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID8] = -EINVAL; ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID9] = -EINVAL; ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID10] = -EINVAL; ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID11] = -EINVAL; ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID12] = -EINVAL; ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID13] = -EINVAL; ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID14] = -EINVAL; ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_TID15] = -EINVAL; ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_BEACON] = dma_mapping_to_ep(rqpn->dma_map_hi); ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_HIGH] = dma_mapping_to_ep(rqpn->dma_map_hi); ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_MGMT] = dma_mapping_to_ep(rqpn->dma_map_mg); ++ rtwusb->qsel_to_ep[TX_DESC_QSEL_H2C] = dma_mapping_to_ep(rqpn->dma_map_hi); ++ + return 0; + } + +@@ -250,7 +271,7 @@ static void rtw_usb_write_port_tx_comple + static int qsel_to_ep(struct rtw_usb *rtwusb, unsigned int qsel) + { + if (qsel >= ARRAY_SIZE(rtwusb->qsel_to_ep)) +- return 0; ++ return -EINVAL; + + return rtwusb->qsel_to_ep[qsel]; + } +@@ -265,6 +286,9 @@ static int rtw_usb_write_port(struct rtw + int ret; + int ep = qsel_to_ep(rtwusb, qsel); + ++ if (ep < 0) ++ return ep; ++ + pipe = usb_sndbulkpipe(usbd, rtwusb->out_ep[ep]); + urb = usb_alloc_urb(0, GFP_ATOMIC); + if (!urb) diff --git a/package/kernel/mac80211/patches/rtl/041-wifi-rtw88-rtw8821c-Fix-rfe_option-field-width.patch b/package/kernel/mac80211/patches/rtl/041-wifi-rtw88-rtw8821c-Fix-rfe_option-field-width.patch new file mode 100644 index 0000000000..c140b4b058 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/041-wifi-rtw88-rtw8821c-Fix-rfe_option-field-width.patch @@ -0,0 +1,58 @@ +From 14705f969d98187a1cc2682e0c9bd2e230b8098f Mon Sep 17 00:00:00 2001 +From: Sascha Hauer +Date: Mon, 17 Apr 2023 16:03:56 +0200 +Subject: [PATCH 41/45] wifi: rtw88: rtw8821c: Fix rfe_option field width + +On my RTW8821CU chipset rfe_option reads as 0x22. Looking at the +vendor driver suggests that the field width of rfe_option is 5 bit, +so rfe_option should be masked with 0x1f. + +Without this the rfe_option comparisons with 2 further down the +driver evaluate as false when they should really evaluate as true. +The effect is that 2G channels do not work. + +rfe_option is also used as an array index into rtw8821c_rfe_defs[]. +rtw8821c_rfe_defs[34] (0x22) was added as part of adding USB support, +likely because rfe_option reads as 0x22. As this now becomes 0x2, +rtw8821c_rfe_defs[34] is no longer used and can be removed. + +Note that this might not be the whole truth. In the vendor driver +there are indeed places where the unmasked rfe_option value is used. +However, the driver has several places where rfe_option is tested +with the pattern if (rfe_option == 2 || rfe_option == 0x22) or +if (rfe_option == 4 || rfe_option == 0x24), so that rfe_option BIT(5) +has no influence on the code path taken. We therefore mask BIT(5) +out from rfe_option entirely until this assumption is proved wrong +by some chip variant we do not know yet. + +Signed-off-by: Sascha Hauer +Tested-by: Alexandru gagniuc +Tested-by: Larry Finger +Tested-by: ValdikSS +Cc: stable@vger.kernel.org +Reviewed-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230417140358.2240429-3-s.hauer@pengutronix.de +--- + drivers/net/wireless/realtek/rtw88/rtw8821c.c | 3 +-- + 1 file changed, 1 insertion(+), 2 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/rtw8821c.c ++++ b/drivers/net/wireless/realtek/rtw88/rtw8821c.c +@@ -53,7 +53,7 @@ static int rtw8821c_read_efuse(struct rt + + map = (struct rtw8821c_efuse *)log_map; + +- efuse->rfe_option = map->rfe_option; ++ efuse->rfe_option = map->rfe_option & 0x1f; + efuse->rf_board_option = map->rf_board_option; + efuse->crystal_cap = map->xtal_k; + efuse->pa_type_2g = map->pa_type; +@@ -1546,7 +1546,6 @@ static const struct rtw_rfe_def rtw8821c + [2] = RTW_DEF_RFE_EXT(8821c, 0, 0, 2), + [4] = RTW_DEF_RFE_EXT(8821c, 0, 0, 2), + [6] = RTW_DEF_RFE(8821c, 0, 0), +- [34] = RTW_DEF_RFE(8821c, 0, 0), + }; + + static struct rtw_hw_reg rtw8821c_dig[] = { diff --git a/package/kernel/mac80211/patches/rtl/042-wifi-rtw88-set-pkg_type-correctly-for-specific-rtw88.patch b/package/kernel/mac80211/patches/rtl/042-wifi-rtw88-set-pkg_type-correctly-for-specific-rtw88.patch new file mode 100644 index 0000000000..e9954c515a --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/042-wifi-rtw88-set-pkg_type-correctly-for-specific-rtw88.patch @@ -0,0 +1,66 @@ +From 97c75e1adeda78b3794936c617d8b86e9ebd54f5 Mon Sep 17 00:00:00 2001 +From: Sascha Hauer +Date: Mon, 17 Apr 2023 16:03:57 +0200 +Subject: [PATCH 42/45] wifi: rtw88: set pkg_type correctly for specific + rtw8821c variants + +According to the vendor driver the pkg_type has to be set to '1' +for some rtw8821c variants. As the pkg_type has been hardcoded to +'0', add a field for it in struct rtw_hal and set this correctly +in the rtw8821c part. +With this parsing of a rtw_table is influenced and check_positive() +in phy.c returns true for some cases here. The same is done in the +vendor driver. However, this has no visible effect on the driver +here. + +Signed-off-by: Sascha Hauer +Reviewed-by: Ping-Ke Shih +Signed-off-by: Sascha Hauer +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230417140358.2240429-4-s.hauer@pengutronix.de +--- + drivers/net/wireless/realtek/rtw88/main.c | 2 +- + drivers/net/wireless/realtek/rtw88/main.h | 1 + + drivers/net/wireless/realtek/rtw88/rtw8821c.c | 3 +++ + 3 files changed, 5 insertions(+), 1 deletion(-) + +--- a/drivers/net/wireless/realtek/rtw88/main.c ++++ b/drivers/net/wireless/realtek/rtw88/main.c +@@ -2008,7 +2008,7 @@ static int rtw_chip_board_info_setup(str + if (!rfe_def) + return -ENODEV; + +- rtw_phy_setup_phy_cond(rtwdev, 0); ++ rtw_phy_setup_phy_cond(rtwdev, hal->pkg_type); + + rtw_phy_init_tx_power(rtwdev); + if (rfe_def->agc_btg_tbl) +--- a/drivers/net/wireless/realtek/rtw88/main.h ++++ b/drivers/net/wireless/realtek/rtw88/main.h +@@ -1900,6 +1900,7 @@ struct rtw_hal { + u8 cut_version; + u8 mp_chip; + u8 oem_id; ++ u8 pkg_type; + struct rtw_phy_cond phy_cond; + + u8 ps_mode; +--- a/drivers/net/wireless/realtek/rtw88/rtw8821c.c ++++ b/drivers/net/wireless/realtek/rtw88/rtw8821c.c +@@ -47,6 +47,7 @@ enum rtw8821ce_rf_set { + + static int rtw8821c_read_efuse(struct rtw_dev *rtwdev, u8 *log_map) + { ++ struct rtw_hal *hal = &rtwdev->hal; + struct rtw_efuse *efuse = &rtwdev->efuse; + struct rtw8821c_efuse *map; + int i; +@@ -70,6 +71,8 @@ static int rtw8821c_read_efuse(struct rt + efuse->tx_bb_swing_setting_2g = map->tx_bb_swing_setting_2g; + efuse->tx_bb_swing_setting_5g = map->tx_bb_swing_setting_5g; + ++ hal->pkg_type = map->rfe_option & BIT(5) ? 1 : 0; ++ + for (i = 0; i < 4; i++) + efuse->txpwr_idx_table[i] = map->txpwr_idx_table[i]; + diff --git a/package/kernel/mac80211/patches/rtl/043-wifi-rtw88-call-rtw8821c_switch_rf_set-according-to-.patch b/package/kernel/mac80211/patches/rtl/043-wifi-rtw88-call-rtw8821c_switch_rf_set-according-to-.patch new file mode 100644 index 0000000000..da34691f35 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/043-wifi-rtw88-call-rtw8821c_switch_rf_set-according-to-.patch @@ -0,0 +1,73 @@ +From 172591baa2cc1ec04869a0d798821a6ca9a2f4b4 Mon Sep 17 00:00:00 2001 +From: Sascha Hauer +Date: Mon, 17 Apr 2023 16:03:58 +0200 +Subject: [PATCH 43/45] wifi: rtw88: call rtw8821c_switch_rf_set() according to + chip variant + +We have to call rtw8821c_switch_rf_set() with SWITCH_TO_WLG or +SWITCH_TO_BTG according to the chip variant as denoted in rfe_option. +The information which argument to use for which variant has been +taken from the vendor driver. + +Signed-off-by: Sascha Hauer +Reviewed-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230417140358.2240429-5-s.hauer@pengutronix.de +--- + drivers/net/wireless/realtek/rtw88/main.h | 1 + + drivers/net/wireless/realtek/rtw88/rtw8821c.c | 19 +++++++++++++++---- + 2 files changed, 16 insertions(+), 4 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/main.h ++++ b/drivers/net/wireless/realtek/rtw88/main.h +@@ -1902,6 +1902,7 @@ struct rtw_hal { + u8 oem_id; + u8 pkg_type; + struct rtw_phy_cond phy_cond; ++ bool rfe_btg; + + u8 ps_mode; + u8 current_channel; +--- a/drivers/net/wireless/realtek/rtw88/rtw8821c.c ++++ b/drivers/net/wireless/realtek/rtw88/rtw8821c.c +@@ -73,6 +73,17 @@ static int rtw8821c_read_efuse(struct rt + + hal->pkg_type = map->rfe_option & BIT(5) ? 1 : 0; + ++ switch (efuse->rfe_option) { ++ case 0x2: ++ case 0x4: ++ case 0x7: ++ case 0xa: ++ case 0xc: ++ case 0xf: ++ hal->rfe_btg = true; ++ break; ++ } ++ + for (i = 0; i < 4; i++) + efuse->txpwr_idx_table[i] = map->txpwr_idx_table[i]; + +@@ -298,6 +309,7 @@ static void rtw8821c_switch_rf_set(struc + + static void rtw8821c_set_channel_rf(struct rtw_dev *rtwdev, u8 channel, u8 bw) + { ++ struct rtw_hal *hal = &rtwdev->hal; + u32 rf_reg18; + + rf_reg18 = rtw_read_rf(rtwdev, RF_PATH_A, 0x18, RFREG_MASK); +@@ -329,11 +341,10 @@ static void rtw8821c_set_channel_rf(stru + } + + if (channel <= 14) { +- if (rtwdev->efuse.rfe_option == 0) +- rtw8821c_switch_rf_set(rtwdev, SWITCH_TO_WLG); +- else if (rtwdev->efuse.rfe_option == 2 || +- rtwdev->efuse.rfe_option == 4) ++ if (hal->rfe_btg) + rtw8821c_switch_rf_set(rtwdev, SWITCH_TO_BTG); ++ else ++ rtw8821c_switch_rf_set(rtwdev, SWITCH_TO_WLG); + rtw_write_rf(rtwdev, RF_PATH_A, RF_LUTDBG, BIT(6), 0x1); + rtw_write_rf(rtwdev, RF_PATH_A, 0x64, 0xf, 0xf); + } else { diff --git a/package/kernel/mac80211/patches/rtl/044-wifi-rtw88-Fix-memory-leak-in-rtw88_usb.patch b/package/kernel/mac80211/patches/rtl/044-wifi-rtw88-Fix-memory-leak-in-rtw88_usb.patch new file mode 100644 index 0000000000..aa2439e35c --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/044-wifi-rtw88-Fix-memory-leak-in-rtw88_usb.patch @@ -0,0 +1,56 @@ +From 59a3a312009723e3e5082899655fdcc420e2b47a Mon Sep 17 00:00:00 2001 +From: Larry Finger +Date: Mon, 17 Apr 2023 11:03:31 -0500 +Subject: [PATCH 44/45] wifi: rtw88: Fix memory leak in rtw88_usb + +Kmemleak shows the following leak arising from routine in the usb +probe routine: + +unreferenced object 0xffff895cb29bba00 (size 512): + comm "(udev-worker)", pid 534, jiffies 4294903932 (age 102751.088s) + hex dump (first 32 bytes): + 77 30 30 30 00 00 00 00 02 2f 2d 2b 30 00 00 00 w000...../-+0... + 02 00 2a 28 00 00 00 00 ff 55 ff ff ff 00 00 00 ..*(.....U...... + backtrace: + [] kmalloc_trace+0x26/0x90 + [] rtw_usb_probe+0x2f1/0x680 [rtw_usb] + [] usb_probe_interface+0xdd/0x2e0 [usbcore] + [] really_probe+0x18e/0x3d0 + [] __driver_probe_device+0x78/0x160 + [] driver_probe_device+0x1f/0x90 + [] __driver_attach+0xbf/0x1b0 + [] bus_for_each_dev+0x70/0xc0 + [] bus_add_driver+0x10e/0x210 + [] driver_register+0x55/0xf0 + [] usb_register_driver+0x88/0x140 [usbcore] + [] do_one_initcall+0x43/0x210 + [] do_init_module+0x4a/0x200 + [] __do_sys_finit_module+0xac/0x120 + [] do_syscall_64+0x56/0x80 + [] entry_SYSCALL_64_after_hwframe+0x46/0xb0 + +The leak was verified to be real by unloading the driver, which resulted +in a dangling pointer to the allocation. + +The allocated memory is freed in rtw_usb_intf_deinit(). + +Signed-off-by: Larry Finger +Cc: Sascha Hauer +Cc: Ping-Ke Shih +Reviewed-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230417160331.23071-1-Larry.Finger@lwfinger.net +--- + drivers/net/wireless/realtek/rtw88/usb.c | 1 + + 1 file changed, 1 insertion(+) + +--- a/drivers/net/wireless/realtek/rtw88/usb.c ++++ b/drivers/net/wireless/realtek/rtw88/usb.c +@@ -804,6 +804,7 @@ static void rtw_usb_intf_deinit(struct r + struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); + + usb_put_dev(rtwusb->udev); ++ kfree(rtwusb->usb_data); + usb_set_intfdata(intf, NULL); + } + diff --git a/package/kernel/mac80211/patches/rtl/045-wifi-rtw88-Update-spelling-in-main.h.patch b/package/kernel/mac80211/patches/rtl/045-wifi-rtw88-Update-spelling-in-main.h.patch new file mode 100644 index 0000000000..534ae86e06 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/045-wifi-rtw88-Update-spelling-in-main.h.patch @@ -0,0 +1,46 @@ +From 6c6d62ae8271bd4b55dd2ba4b7ed552162823880 Mon Sep 17 00:00:00 2001 +From: Simon Horman +Date: Tue, 18 Apr 2023 13:29:22 +0200 +Subject: [PATCH 45/45] wifi: rtw88: Update spelling in main.h + +Update spelling in comments in main.h + +Found by inspection. + +Signed-off-by: Simon Horman +Reviewed-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230418-rtw88-starspell-v1-1-70e52a23979b@kernel.org +--- + drivers/net/wireless/realtek/rtw88/main.h | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/main.h ++++ b/drivers/net/wireless/realtek/rtw88/main.h +@@ -88,7 +88,7 @@ enum rtw_supported_band { + RTW_BAND_60G = BIT(NL80211_BAND_60GHZ), + }; + +-/* now, support upto 80M bw */ ++/* now, support up to 80M bw */ + #define RTW_MAX_CHANNEL_WIDTH RTW_CHANNEL_WIDTH_80 + + enum rtw_bandwidth { +@@ -1881,7 +1881,7 @@ enum rtw_sar_bands { + RTW_SAR_BAND_NR, + }; + +-/* the union is reserved for other knids of SAR sources ++/* the union is reserved for other kinds of SAR sources + * which might not re-use same format with array common. + */ + union rtw_sar_cfg { +@@ -2032,7 +2032,7 @@ struct rtw_dev { + struct rtw_tx_report tx_report; + + struct { +- /* incicate the mail box to use with fw */ ++ /* indicate the mail box to use with fw */ + u8 last_box_num; + u32 seq; + } h2c; diff --git a/package/kernel/mac80211/patches/rtl/046-wifi-rtw88-fix-incorrect-error-codes-in-rtw_debugfs_.patch b/package/kernel/mac80211/patches/rtl/046-wifi-rtw88-fix-incorrect-error-codes-in-rtw_debugfs_.patch new file mode 100644 index 0000000000..4552d856a5 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/046-wifi-rtw88-fix-incorrect-error-codes-in-rtw_debugfs_.patch @@ -0,0 +1,35 @@ +From 225622256b1b7156624e281e1c0251c292ea24cd Mon Sep 17 00:00:00 2001 +From: Zhang Shurong +Date: Thu, 27 Apr 2023 01:02:20 +0800 +Subject: [PATCH 01/12] wifi: rtw88: fix incorrect error codes in + rtw_debugfs_copy_from_user + +If there is a failure during copy_from_user or user-provided data +buffer is invalid, rtw_debugfs_copy_from_user should return negative +error code instead of a positive value count. + +Fix this bug by returning correct error code. Moreover, the check +of buffer against null is removed since it will be handled by +copy_from_user. + +Signed-off-by: Zhang Shurong +Reviewed-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/tencent_D2EB102CC7435C0110154E62ECA6A7D67505@qq.com +--- + drivers/net/wireless/realtek/rtw88/debug.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/debug.c ++++ b/drivers/net/wireless/realtek/rtw88/debug.c +@@ -183,8 +183,8 @@ static int rtw_debugfs_copy_from_user(ch + + tmp_len = (count > size - 1 ? size - 1 : count); + +- if (!buffer || copy_from_user(tmp, buffer, tmp_len)) +- return count; ++ if (copy_from_user(tmp, buffer, tmp_len)) ++ return -EFAULT; + + tmp[tmp_len] = '\0'; + diff --git a/package/kernel/mac80211/patches/rtl/047-wifi-rtw88-fix-incorrect-error-codes-in-rtw_debugfs_.patch b/package/kernel/mac80211/patches/rtl/047-wifi-rtw88-fix-incorrect-error-codes-in-rtw_debugfs_.patch new file mode 100644 index 0000000000..02638f3cf4 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/047-wifi-rtw88-fix-incorrect-error-codes-in-rtw_debugfs_.patch @@ -0,0 +1,173 @@ +From 77005533777267736fca64fa376b8a835cb8806b Mon Sep 17 00:00:00 2001 +From: Zhang Shurong +Date: Thu, 27 Apr 2023 01:02:21 +0800 +Subject: [PATCH 02/12] wifi: rtw88: fix incorrect error codes in + rtw_debugfs_set_* + +If there is a failure during copy_from_user or user-provided data +buffer is invalid, rtw_debugfs_set_* should return negative +error code instead of a positive value count. + +Fix this bug by returning correct error code. + +Signed-off-by: Zhang Shurong +Reviewed-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/tencent_53140CC2A3468101955F02EB66AA96780B05@qq.com +--- + drivers/net/wireless/realtek/rtw88/debug.c | 55 ++++++++++++++++------ + 1 file changed, 41 insertions(+), 14 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/debug.c ++++ b/drivers/net/wireless/realtek/rtw88/debug.c +@@ -201,13 +201,16 @@ static ssize_t rtw_debugfs_set_read_reg( + char tmp[32 + 1]; + u32 addr, len; + int num; ++ int ret; + +- rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 2); ++ ret = rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 2); ++ if (ret) ++ return ret; + + num = sscanf(tmp, "%x %x", &addr, &len); + + if (num != 2) +- return count; ++ return -EINVAL; + + if (len != 1 && len != 2 && len != 4) { + rtw_warn(rtwdev, "read reg setting wrong len\n"); +@@ -288,8 +291,11 @@ static ssize_t rtw_debugfs_set_rsvd_page + char tmp[32 + 1]; + u32 offset, page_num; + int num; ++ int ret; + +- rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 2); ++ ret = rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 2); ++ if (ret) ++ return ret; + + num = sscanf(tmp, "%d %d", &offset, &page_num); + +@@ -314,8 +320,11 @@ static ssize_t rtw_debugfs_set_single_in + char tmp[32 + 1]; + u32 input; + int num; ++ int ret; + +- rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 1); ++ ret = rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 1); ++ if (ret) ++ return ret; + + num = kstrtoint(tmp, 0, &input); + +@@ -338,14 +347,17 @@ static ssize_t rtw_debugfs_set_write_reg + char tmp[32 + 1]; + u32 addr, val, len; + int num; ++ int ret; + +- rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 3); ++ ret = rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 3); ++ if (ret) ++ return ret; + + /* write BB/MAC register */ + num = sscanf(tmp, "%x %x %x", &addr, &val, &len); + + if (num != 3) +- return count; ++ return -EINVAL; + + switch (len) { + case 1: +@@ -381,8 +393,11 @@ static ssize_t rtw_debugfs_set_h2c(struc + char tmp[32 + 1]; + u8 param[8]; + int num; ++ int ret; + +- rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 3); ++ ret = rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 3); ++ if (ret) ++ return ret; + + num = sscanf(tmp, "%hhx,%hhx,%hhx,%hhx,%hhx,%hhx,%hhx,%hhx", + ¶m[0], ¶m[1], ¶m[2], ¶m[3], +@@ -408,14 +423,17 @@ static ssize_t rtw_debugfs_set_rf_write( + char tmp[32 + 1]; + u32 path, addr, mask, val; + int num; ++ int ret; + +- rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 4); ++ ret = rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 4); ++ if (ret) ++ return ret; + + num = sscanf(tmp, "%x %x %x %x", &path, &addr, &mask, &val); + + if (num != 4) { + rtw_warn(rtwdev, "invalid args, [path] [addr] [mask] [val]\n"); +- return count; ++ return -EINVAL; + } + + mutex_lock(&rtwdev->mutex); +@@ -438,14 +456,17 @@ static ssize_t rtw_debugfs_set_rf_read(s + char tmp[32 + 1]; + u32 path, addr, mask; + int num; ++ int ret; + +- rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 3); ++ ret = rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 3); ++ if (ret) ++ return ret; + + num = sscanf(tmp, "%x %x %x", &path, &addr, &mask); + + if (num != 3) { + rtw_warn(rtwdev, "invalid args, [path] [addr] [mask] [val]\n"); +- return count; ++ return -EINVAL; + } + + debugfs_priv->rf_path = path; +@@ -467,7 +488,9 @@ static ssize_t rtw_debugfs_set_fix_rate( + char tmp[32 + 1]; + int ret; + +- rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 1); ++ ret = rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 1); ++ if (ret) ++ return ret; + + ret = kstrtou8(tmp, 0, &fix_rate); + if (ret) { +@@ -860,7 +883,9 @@ static ssize_t rtw_debugfs_set_coex_enab + bool enable; + int ret; + +- rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 1); ++ ret = rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 1); ++ if (ret) ++ return ret; + + ret = kstrtobool(tmp, &enable); + if (ret) { +@@ -930,7 +955,9 @@ static ssize_t rtw_debugfs_set_fw_crash( + bool input; + int ret; + +- rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 1); ++ ret = rtw_debugfs_copy_from_user(tmp, sizeof(tmp), buffer, count, 1); ++ if (ret) ++ return ret; + + ret = kstrtobool(tmp, &input); + if (ret) diff --git a/package/kernel/mac80211/patches/rtl/048-wifi-rtw88-unlock-on-error-path-in-rtw_ops_add_inter.patch b/package/kernel/mac80211/patches/rtl/048-wifi-rtw88-unlock-on-error-path-in-rtw_ops_add_inter.patch new file mode 100644 index 0000000000..d067162caa --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/048-wifi-rtw88-unlock-on-error-path-in-rtw_ops_add_inter.patch @@ -0,0 +1,31 @@ +From e2ff1181b3d48257aab26bfd2165f3c7d271499f Mon Sep 17 00:00:00 2001 +From: Dan Carpenter +Date: Wed, 3 May 2023 18:09:55 +0300 +Subject: [PATCH 03/12] wifi: rtw88: unlock on error path in + rtw_ops_add_interface() + +Call mutex_unlock(&rtwdev->mutex); before returning on this error path. + +Fixes: f0e741e4ddbc ("wifi: rtw88: add bitmap for dynamic port settings") +Signed-off-by: Dan Carpenter +Reviewed-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/ddd10a74-5982-4f65-8c59-c1cca558d239@kili.mountain +--- + drivers/net/wireless/realtek/rtw88/mac80211.c | 4 +++- + 1 file changed, 3 insertions(+), 1 deletion(-) + +--- a/drivers/net/wireless/realtek/rtw88/mac80211.c ++++ b/drivers/net/wireless/realtek/rtw88/mac80211.c +@@ -173,8 +173,10 @@ static int rtw_ops_add_interface(struct + mutex_lock(&rtwdev->mutex); + + port = find_first_zero_bit(rtwdev->hw_port, RTW_PORT_NUM); +- if (port >= RTW_PORT_NUM) ++ if (port >= RTW_PORT_NUM) { ++ mutex_unlock(&rtwdev->mutex); + return -EINVAL; ++ } + set_bit(port, rtwdev->hw_port); + + rtwvif->port = port; diff --git a/package/kernel/mac80211/patches/rtl/049-wifi-rtw88-use-work-to-update-rate-to-avoid-RCU-warn.patch b/package/kernel/mac80211/patches/rtl/049-wifi-rtw88-use-work-to-update-rate-to-avoid-RCU-warn.patch new file mode 100644 index 0000000000..e629593d17 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/049-wifi-rtw88-use-work-to-update-rate-to-avoid-RCU-warn.patch @@ -0,0 +1,132 @@ +From bcafcb959a57a6890e900199690c5fc47da1a304 Mon Sep 17 00:00:00 2001 +From: Ping-Ke Shih +Date: Mon, 8 May 2023 16:54:29 +0800 +Subject: [PATCH 04/12] wifi: rtw88: use work to update rate to avoid RCU + warning + +The ieee80211_ops::sta_rc_update must be atomic, because +ieee80211_chan_bw_change() holds rcu_read lock while calling +drv_sta_rc_update(), so create a work to do original things. + + Voluntary context switch within RCU read-side critical section! + WARNING: CPU: 0 PID: 4621 at kernel/rcu/tree_plugin.h:318 + rcu_note_context_switch+0x571/0x5d0 + CPU: 0 PID: 4621 Comm: kworker/u16:2 Tainted: G W OE + Workqueue: phy3 ieee80211_chswitch_work [mac80211] + RIP: 0010:rcu_note_context_switch+0x571/0x5d0 + Call Trace: + + __schedule+0xb0/0x1460 + ? __mod_timer+0x116/0x360 + schedule+0x5a/0xc0 + schedule_timeout+0x87/0x150 + ? trace_raw_output_tick_stop+0x60/0x60 + wait_for_completion_timeout+0x7b/0x140 + usb_start_wait_urb+0x82/0x160 [usbcore + usb_control_msg+0xe3/0x140 [usbcore + rtw_usb_read+0x88/0xe0 [rtw_usb + rtw_usb_read8+0xf/0x10 [rtw_usb + rtw_fw_send_h2c_command+0xa0/0x170 [rtw_core + rtw_fw_send_ra_info+0xc9/0xf0 [rtw_core + drv_sta_rc_update+0x7c/0x160 [mac80211 + ieee80211_chan_bw_change+0xfb/0x110 [mac80211 + ieee80211_change_chanctx+0x38/0x130 [mac80211 + ieee80211_vif_use_reserved_switch+0x34e/0x900 [mac80211 + ieee80211_link_use_reserved_context+0x88/0xe0 [mac80211 + ieee80211_chswitch_work+0x95/0x170 [mac80211 + process_one_work+0x201/0x410 + worker_thread+0x4a/0x3b0 + ? process_one_work+0x410/0x410 + kthread+0xe1/0x110 + ? kthread_complete_and_exit+0x20/0x20 + ret_from_fork+0x1f/0x30 + + +Cc: stable@vger.kernel.org +Fixes: c1edc86472fc ("rtw88: add ieee80211:sta_rc_update ops") +Reported-by: Larry Finger +Link: https://lore.kernel.org/linux-wireless/f1e31e8e-f84e-3791-50fb-663a83c5c6e9@lwfinger.net/T/#t +Signed-off-by: Ping-Ke Shih +Tested-by: Larry Finger +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230508085429.46653-1-pkshih@realtek.com +--- + drivers/net/wireless/realtek/rtw88/mac80211.c | 2 +- + drivers/net/wireless/realtek/rtw88/main.c | 15 +++++++++++++++ + drivers/net/wireless/realtek/rtw88/main.h | 3 +++ + 3 files changed, 19 insertions(+), 1 deletion(-) + +--- a/drivers/net/wireless/realtek/rtw88/mac80211.c ++++ b/drivers/net/wireless/realtek/rtw88/mac80211.c +@@ -920,7 +920,7 @@ static void rtw_ops_sta_rc_update(struct + struct rtw_sta_info *si = (struct rtw_sta_info *)sta->drv_priv; + + if (changed & IEEE80211_RC_BW_CHANGED) +- rtw_update_sta_info(rtwdev, si, true); ++ ieee80211_queue_work(rtwdev->hw, &si->rc_work); + } + + const struct ieee80211_ops rtw_ops = { +--- a/drivers/net/wireless/realtek/rtw88/main.c ++++ b/drivers/net/wireless/realtek/rtw88/main.c +@@ -319,6 +319,17 @@ static u8 rtw_acquire_macid(struct rtw_d + return mac_id; + } + ++static void rtw_sta_rc_work(struct work_struct *work) ++{ ++ struct rtw_sta_info *si = container_of(work, struct rtw_sta_info, ++ rc_work); ++ struct rtw_dev *rtwdev = si->rtwdev; ++ ++ mutex_lock(&rtwdev->mutex); ++ rtw_update_sta_info(rtwdev, si, true); ++ mutex_unlock(&rtwdev->mutex); ++} ++ + int rtw_sta_add(struct rtw_dev *rtwdev, struct ieee80211_sta *sta, + struct ieee80211_vif *vif) + { +@@ -329,12 +340,14 @@ int rtw_sta_add(struct rtw_dev *rtwdev, + if (si->mac_id >= RTW_MAX_MAC_ID_NUM) + return -ENOSPC; + ++ si->rtwdev = rtwdev; + si->sta = sta; + si->vif = vif; + si->init_ra_lv = 1; + ewma_rssi_init(&si->avg_rssi); + for (i = 0; i < ARRAY_SIZE(sta->txq); i++) + rtw_txq_init(rtwdev, sta->txq[i]); ++ INIT_WORK(&si->rc_work, rtw_sta_rc_work); + + rtw_update_sta_info(rtwdev, si, true); + rtw_fw_media_status_report(rtwdev, si->mac_id, true); +@@ -353,6 +366,8 @@ void rtw_sta_remove(struct rtw_dev *rtwd + struct rtw_sta_info *si = (struct rtw_sta_info *)sta->drv_priv; + int i; + ++ cancel_work_sync(&si->rc_work); ++ + rtw_release_macid(rtwdev, si->mac_id); + if (fw_exist) + rtw_fw_media_status_report(rtwdev, si->mac_id, false); +--- a/drivers/net/wireless/realtek/rtw88/main.h ++++ b/drivers/net/wireless/realtek/rtw88/main.h +@@ -743,6 +743,7 @@ struct rtw_txq { + DECLARE_EWMA(rssi, 10, 16); + + struct rtw_sta_info { ++ struct rtw_dev *rtwdev; + struct ieee80211_sta *sta; + struct ieee80211_vif *vif; + +@@ -767,6 +768,8 @@ struct rtw_sta_info { + + bool use_cfg_mask; + struct cfg80211_bitrate_mask *mask; ++ ++ struct work_struct rc_work; + }; + + enum rtw_bfee_role { diff --git a/package/kernel/mac80211/patches/rtl/050-wifi-rtw88-correct-qsel_to_ep-type-as-int.patch b/package/kernel/mac80211/patches/rtl/050-wifi-rtw88-correct-qsel_to_ep-type-as-int.patch new file mode 100644 index 0000000000..d27af4739e --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/050-wifi-rtw88-correct-qsel_to_ep-type-as-int.patch @@ -0,0 +1,35 @@ +From 8e4942db5f5ed7b7d9690d93235b3ca49c5c59ce Mon Sep 17 00:00:00 2001 +From: Ping-Ke Shih +Date: Mon, 8 May 2023 16:55:39 +0800 +Subject: [PATCH 05/12] wifi: rtw88: correct qsel_to_ep[] type as int + +qsel_to_ep[] can be assigned negative value, so change type from 'u8' to +'int'. Otherwise, Smatch static checker warns: + drivers/net/wireless/realtek/rtw88/usb.c:219 rtw_usb_parse() warn: + assigning (-22) to unsigned variable 'rtwusb->qsel_to_ep[8]' + +Cc: stable@vger.kernel.org +Fixes: a6f187f92bcc ("wifi: rtw88: usb: fix priority queue to endpoint mapping") +Reported-by: Dan Carpenter +Link: https://lore.kernel.org/linux-wireless/c3f70197-829d-48ed-ae15-66a9de80fa90@kili.mountain/ +Cc: Sascha Hauer +Signed-off-by: Ping-Ke Shih +Acked-by: Sascha Hauer +Tested-by: Larry Finger +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230508085539.46795-1-pkshih@realtek.com +--- + drivers/net/wireless/realtek/rtw88/usb.h | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +--- a/drivers/net/wireless/realtek/rtw88/usb.h ++++ b/drivers/net/wireless/realtek/rtw88/usb.h +@@ -78,7 +78,7 @@ struct rtw_usb { + u8 pipe_interrupt; + u8 pipe_in; + u8 out_ep[RTW_USB_EP_MAX]; +- u8 qsel_to_ep[TX_DESC_QSEL_MAX]; ++ int qsel_to_ep[TX_DESC_QSEL_MAX]; + u8 usb_txagg_num; + + struct workqueue_struct *txwq, *rxwq; diff --git a/package/kernel/mac80211/patches/rtl/051-wifi-rtw88-sdio-Always-use-two-consecutive-bytes-for.patch b/package/kernel/mac80211/patches/rtl/051-wifi-rtw88-sdio-Always-use-two-consecutive-bytes-for.patch new file mode 100644 index 0000000000..3697343fa3 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/051-wifi-rtw88-sdio-Always-use-two-consecutive-bytes-for.patch @@ -0,0 +1,60 @@ +From cb0ddaaa5db09d7d216fcbf0e68779be223a1128 Mon Sep 17 00:00:00 2001 +From: Martin Blumenstingl +Date: Mon, 15 May 2023 21:50:43 +0200 +Subject: [PATCH 06/12] wifi: rtw88: sdio: Always use two consecutive bytes for + word operations + +The Allwinner sunxi-mmc controller cannot handle word (16 bit) +transfers. So and sdio_{read,write}w fails with messages like the +following example using an RTL8822BS (but the same problems were also +observed with RTL8822CS and RTL8723DS chips): + rtw_8822bs mmc1:0001:1: Firmware version 27.2.0, H2C version 13 + sunxi-mmc 4021000.mmc: unaligned scatterlist: os f80 length 2 + sunxi-mmc 4021000.mmc: map DMA failed + rtw_8822bs mmc1:0001:1: sdio read16 failed (0x10230): -22 + +Use two consecutive single byte accesses for word operations instead. It +turns out that upon closer inspection this is also what the vendor +driver does, even though it does have support for sdio_{read,write}w. So +we can conclude that the rtw88 chips do support word access but only on +SDIO controllers that also support it. Since there's no way to detect if +the controller supports word access or not the rtw88 sdio driver +switches to the easiest approach: avoiding word access. + +Reported-by: Larry Finger +Closes: https://lore.kernel.org/linux-wireless/527585e5-9cdd-66ed-c3af-6da162f4b720@lwfinger.net/ +Reported-by: Rudi Heitbaum +Link: https://github.com/LibreELEC/LibreELEC.tv/pull/7837#issue-1708469467 +Fixes: 65371a3f14e7 ("wifi: rtw88: sdio: Add HCI implementation for SDIO based chipsets") +Reviewed-by: Ping-Ke Shih +Signed-off-by: Martin Blumenstingl +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230515195043.572375-1-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/sdio.c | 8 -------- + 1 file changed, 8 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/sdio.c ++++ b/drivers/net/wireless/realtek/rtw88/sdio.c +@@ -87,11 +87,6 @@ static void rtw_sdio_writew(struct rtw_d + u8 buf[2]; + int i; + +- if (rtw_sdio_use_memcpy_io(rtwdev, addr, 2)) { +- sdio_writew(rtwsdio->sdio_func, val, addr, err_ret); +- return; +- } +- + *(__le16 *)buf = cpu_to_le16(val); + + for (i = 0; i < 2; i++) { +@@ -125,9 +120,6 @@ static u16 rtw_sdio_readw(struct rtw_dev + u8 buf[2]; + int i; + +- if (rtw_sdio_use_memcpy_io(rtwdev, addr, 2)) +- return sdio_readw(rtwsdio->sdio_func, addr, err_ret); +- + for (i = 0; i < 2; i++) { + buf[i] = sdio_readb(rtwsdio->sdio_func, addr + i, err_ret); + if (*err_ret) diff --git a/package/kernel/mac80211/patches/rtl/052-wifi-rtw88-sdio-Check-the-HISR-RX_REQUEST-bit-in-rtw.patch b/package/kernel/mac80211/patches/rtl/052-wifi-rtw88-sdio-Check-the-HISR-RX_REQUEST-bit-in-rtw.patch new file mode 100644 index 0000000000..d3216ede46 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/052-wifi-rtw88-sdio-Check-the-HISR-RX_REQUEST-bit-in-rtw.patch @@ -0,0 +1,84 @@ +From e967229ead0e6c5047a1cfd5a0db58ceb930800b Mon Sep 17 00:00:00 2001 +From: Martin Blumenstingl +Date: Mon, 22 May 2023 22:24:22 +0200 +Subject: [PATCH 07/12] wifi: rtw88: sdio: Check the HISR RX_REQUEST bit in + rtw_sdio_rx_isr() + +rtw_sdio_rx_isr() is responsible for receiving data from the wifi chip +and is called from the SDIO interrupt handler when the interrupt status +register (HISR) has the RX_REQUEST bit set. After the first batch of +data has been processed by the driver the wifi chip may have more data +ready to be read, which is managed by a loop in rtw_sdio_rx_isr(). + +It turns out that there are cases where the RX buffer length (from the +REG_SDIO_RX0_REQ_LEN register) does not match the data we receive. The +following two cases were observed with a RTL8723DS card: +- RX length is smaller than the total packet length including overhead + and actual data bytes (whose length is part of the buffer we read from + the wifi chip and is stored in rtw_rx_pkt_stat.pkt_len). This can + result in errors like: + skbuff: skb_over_panic: text:ffff8000011924ac len:3341 put:3341 + (one case observed was: RX buffer length = 1536 bytes but + rtw_rx_pkt_stat.pkt_len = 1546 bytes, this is not valid as it means + we need to read beyond the end of the buffer) +- RX length looks valid but rtw_rx_pkt_stat.pkt_len is zero + +Check if the RX_REQUEST is set in the HISR register for each iteration +inside rtw_sdio_rx_isr(). This mimics what the RTL8723DS vendor driver +does and makes the driver only read more data if the RX_REQUEST bit is +set (which seems to be a way for the card's hardware or firmware to +tell the host that data is ready to be processed). + +For RTW_WCPU_11AC chips this check is not needed. The RTL8822BS vendor +driver for example states that this check is unnecessary (but still uses +it) and the RTL8822CS drops this check entirely. + +Reviewed-by: Ping-Ke Shih +Signed-off-by: Martin Blumenstingl +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230522202425.1827005-2-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/sdio.c | 24 ++++++++++++++++++++--- + 1 file changed, 21 insertions(+), 3 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/sdio.c ++++ b/drivers/net/wireless/realtek/rtw88/sdio.c +@@ -998,9 +998,9 @@ static void rtw_sdio_rxfifo_recv(struct + + static void rtw_sdio_rx_isr(struct rtw_dev *rtwdev) + { +- u32 rx_len, total_rx_bytes = 0; ++ u32 rx_len, hisr, total_rx_bytes = 0; + +- while (total_rx_bytes < SZ_64K) { ++ do { + if (rtw_chip_wcpu_11n(rtwdev)) + rx_len = rtw_read16(rtwdev, REG_SDIO_RX0_REQ_LEN); + else +@@ -1012,7 +1012,25 @@ static void rtw_sdio_rx_isr(struct rtw_d + rtw_sdio_rxfifo_recv(rtwdev, rx_len); + + total_rx_bytes += rx_len; +- } ++ ++ if (rtw_chip_wcpu_11n(rtwdev)) { ++ /* Stop if no more RX requests are pending, even if ++ * rx_len could be greater than zero in the next ++ * iteration. This is needed because the RX buffer may ++ * already contain data while either HW or FW are not ++ * done filling that buffer yet. Still reading the ++ * buffer can result in packets where ++ * rtw_rx_pkt_stat.pkt_len is zero or points beyond the ++ * end of the buffer. ++ */ ++ hisr = rtw_read32(rtwdev, REG_SDIO_HISR); ++ } else { ++ /* RTW_WCPU_11AC chips have improved hardware or ++ * firmware and can use rx_len unconditionally. ++ */ ++ hisr = REG_SDIO_HISR_RX_REQUEST; ++ } ++ } while (total_rx_bytes < SZ_64K && hisr & REG_SDIO_HISR_RX_REQUEST); + } + + static void rtw_sdio_handle_interrupt(struct sdio_func *sdio_func) diff --git a/package/kernel/mac80211/patches/rtl/053-wifi-rtw88-rtw8723d-Implement-RTL8723DS-SDIO-efuse-p.patch b/package/kernel/mac80211/patches/rtl/053-wifi-rtw88-rtw8723d-Implement-RTL8723DS-SDIO-efuse-p.patch new file mode 100644 index 0000000000..d15854fb73 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/053-wifi-rtw88-rtw8723d-Implement-RTL8723DS-SDIO-efuse-p.patch @@ -0,0 +1,66 @@ +From 9be20a82232779c59979527dfc8febca3182fee2 Mon Sep 17 00:00:00 2001 +From: Martin Blumenstingl +Date: Mon, 22 May 2023 22:24:23 +0200 +Subject: [PATCH 08/12] wifi: rtw88: rtw8723d: Implement RTL8723DS (SDIO) efuse + parsing + +The efuse of the SDIO RTL8723DS chip has only one known member: the mac +address is at offset 0x11a. Add a struct rtw8723ds_efuse describing this +and use it for copying the mac address when the SDIO bus is used. + +Reviewed-by: Ping-Ke Shih +Signed-off-by: Martin Blumenstingl +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230522202425.1827005-3-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/rtw8723d.c | 9 +++++++++ + drivers/net/wireless/realtek/rtw88/rtw8723d.h | 6 ++++++ + 2 files changed, 15 insertions(+) + +--- a/drivers/net/wireless/realtek/rtw88/rtw8723d.c ++++ b/drivers/net/wireless/realtek/rtw88/rtw8723d.c +@@ -216,6 +216,12 @@ static void rtw8723du_efuse_parsing(stru + ether_addr_copy(efuse->addr, map->u.mac_addr); + } + ++static void rtw8723ds_efuse_parsing(struct rtw_efuse *efuse, ++ struct rtw8723d_efuse *map) ++{ ++ ether_addr_copy(efuse->addr, map->s.mac_addr); ++} ++ + static int rtw8723d_read_efuse(struct rtw_dev *rtwdev, u8 *log_map) + { + struct rtw_efuse *efuse = &rtwdev->efuse; +@@ -248,6 +254,9 @@ static int rtw8723d_read_efuse(struct rt + case RTW_HCI_TYPE_USB: + rtw8723du_efuse_parsing(efuse, map); + break; ++ case RTW_HCI_TYPE_SDIO: ++ rtw8723ds_efuse_parsing(efuse, map); ++ break; + default: + /* unsupported now */ + return -ENOTSUPP; +--- a/drivers/net/wireless/realtek/rtw88/rtw8723d.h ++++ b/drivers/net/wireless/realtek/rtw88/rtw8723d.h +@@ -49,6 +49,11 @@ struct rtw8723du_efuse { + u8 mac_addr[ETH_ALEN]; /* 0x107 */ + }; + ++struct rtw8723ds_efuse { ++ u8 res4[0x4a]; /* 0xd0 */ ++ u8 mac_addr[ETH_ALEN]; /* 0x11a */ ++}; ++ + struct rtw8723d_efuse { + __le16 rtl_id; + u8 rsvd[2]; +@@ -80,6 +85,7 @@ struct rtw8723d_efuse { + union { + struct rtw8723de_efuse e; + struct rtw8723du_efuse u; ++ struct rtw8723ds_efuse s; + }; + }; + diff --git a/package/kernel/mac80211/patches/rtl/054-wifi-rtw88-Add-support-for-the-SDIO-based-RTL8723DS-.patch b/package/kernel/mac80211/patches/rtl/054-wifi-rtw88-Add-support-for-the-SDIO-based-RTL8723DS-.patch new file mode 100644 index 0000000000..56a88f8411 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/054-wifi-rtw88-Add-support-for-the-SDIO-based-RTL8723DS-.patch @@ -0,0 +1,96 @@ +From a3b125ceb45e1acd21c9bcb6d3a5c52897d536e6 Mon Sep 17 00:00:00 2001 +From: Martin Blumenstingl +Date: Mon, 22 May 2023 22:24:25 +0200 +Subject: [PATCH 09/12] wifi: rtw88: Add support for the SDIO based RTL8723DS + chipset + +Wire up RTL8723DS chipset support using the rtw88 SDIO HCI code as well +as the existing RTL8723D chipset code. + +Reviewed-by: Ping-Ke Shih +Signed-off-by: Martin Blumenstingl +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230522202425.1827005-5-martin.blumenstingl@googlemail.com +--- + drivers/net/wireless/realtek/rtw88/Kconfig | 11 +++++ + drivers/net/wireless/realtek/rtw88/Makefile | 3 ++ + .../net/wireless/realtek/rtw88/rtw8723ds.c | 41 +++++++++++++++++++ + 3 files changed, 55 insertions(+) + create mode 100644 drivers/net/wireless/realtek/rtw88/rtw8723ds.c + +--- a/drivers/net/wireless/realtek/rtw88/Kconfig ++++ b/drivers/net/wireless/realtek/rtw88/Kconfig +@@ -129,6 +129,17 @@ config RTW88_8723DE + + 802.11n PCIe wireless network adapter + ++config RTW88_8723DS ++ tristate "Realtek 8723DS SDIO wireless network adapter" ++ depends on MMC ++ select RTW88_CORE ++ select RTW88_SDIO ++ select RTW88_8723D ++ help ++ Select this option will enable support for 8723DS chipset ++ ++ 802.11n SDIO wireless network adapter ++ + config RTW88_8723DU + tristate "Realtek 8723DU USB wireless network adapter" + depends on m +--- a/drivers/net/wireless/realtek/rtw88/Makefile ++++ b/drivers/net/wireless/realtek/rtw88/Makefile +@@ -50,6 +50,9 @@ rtw88_8723d-objs := rtw8723d.o rtw8723d + obj-$(CPTCFG_RTW88_8723DE) += rtw88_8723de.o + rtw88_8723de-objs := rtw8723de.o + ++obj-$(CPTCFG_RTW88_8723DS) += rtw88_8723ds.o ++rtw88_8723ds-objs := rtw8723ds.o ++ + obj-$(CPTCFG_RTW88_8723DU) += rtw88_8723du.o + rtw88_8723du-objs := rtw8723du.o + +--- /dev/null ++++ b/drivers/net/wireless/realtek/rtw88/rtw8723ds.c +@@ -0,0 +1,41 @@ ++// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause ++/* Copyright(c) Martin Blumenstingl ++ */ ++ ++#include ++#include ++#include ++#include "main.h" ++#include "rtw8723d.h" ++#include "sdio.h" ++ ++static const struct sdio_device_id rtw_8723ds_id_table[] = { ++ { ++ SDIO_DEVICE(SDIO_VENDOR_ID_REALTEK, ++ SDIO_DEVICE_ID_REALTEK_RTW8723DS_1ANT), ++ .driver_data = (kernel_ulong_t)&rtw8723d_hw_spec, ++ }, ++ { ++ SDIO_DEVICE(SDIO_VENDOR_ID_REALTEK, ++ SDIO_DEVICE_ID_REALTEK_RTW8723DS_2ANT), ++ .driver_data = (kernel_ulong_t)&rtw8723d_hw_spec, ++ }, ++ {} ++}; ++MODULE_DEVICE_TABLE(sdio, rtw_8723ds_id_table); ++ ++static struct sdio_driver rtw_8723ds_driver = { ++ .name = "rtw_8723ds", ++ .probe = rtw_sdio_probe, ++ .remove = rtw_sdio_remove, ++ .id_table = rtw_8723ds_id_table, ++ .drv = { ++ .pm = &rtw_sdio_pm_ops, ++ .shutdown = rtw_sdio_shutdown, ++ } ++}; ++module_sdio_driver(rtw_8723ds_driver); ++ ++MODULE_AUTHOR("Martin Blumenstingl "); ++MODULE_DESCRIPTION("Realtek 802.11n wireless 8723ds driver"); ++MODULE_LICENSE("Dual BSD/GPL"); diff --git a/package/kernel/mac80211/patches/rtl/055-wifi-rtw88-usb-silence-log-flooding-error-message.patch b/package/kernel/mac80211/patches/rtl/055-wifi-rtw88-usb-silence-log-flooding-error-message.patch new file mode 100644 index 0000000000..f5e4d40bc0 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/055-wifi-rtw88-usb-silence-log-flooding-error-message.patch @@ -0,0 +1,41 @@ +From 1f1784a59caf3eefd127908a1a3cf224017ff9c7 Mon Sep 17 00:00:00 2001 +From: Sascha Hauer +Date: Wed, 24 May 2023 12:39:34 +0200 +Subject: [PATCH 10/12] wifi: rtw88: usb: silence log flooding error message + +When receiving more rx packets than the kernel can handle the driver +drops the packets and issues an error message. This is bad for two +reasons. The logs are flooded with myriads of messages, but then time +consumed for printing messages in that critical code path brings down +the device. After some time of excessive rx load the driver responds +with: + +rtw_8822cu 1-1:1.2: failed to get tx report from firmware +rtw_8822cu 1-1:1.2: firmware failed to report density after scan +rtw_8822cu 1-1:1.2: firmware failed to report density after scan + +The device stops working until being replugged. + +Fix this by lowering the priority to debug level and also by +ratelimiting it. + +Fixes: a82dfd33d1237 ("wifi: rtw88: Add common USB chip support") +Signed-off-by: Sascha Hauer +Reviewed-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230524103934.1019096-1-s.hauer@pengutronix.de +--- + drivers/net/wireless/realtek/rtw88/usb.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +--- a/drivers/net/wireless/realtek/rtw88/usb.c ++++ b/drivers/net/wireless/realtek/rtw88/usb.c +@@ -535,7 +535,7 @@ static void rtw_usb_rx_handler(struct wo + } + + if (skb_queue_len(&rtwusb->rx_queue) >= RTW_USB_MAX_RXQ_LEN) { +- rtw_err(rtwdev, "failed to get rx_queue, overflow\n"); ++ dev_dbg_ratelimited(rtwdev->dev, "failed to get rx_queue, overflow\n"); + dev_kfree_skb_any(skb); + continue; + } diff --git a/package/kernel/mac80211/patches/rtl/056-wifi-rtw88-correct-PS-calculation-for-SUPPORTS_DYNAM.patch b/package/kernel/mac80211/patches/rtl/056-wifi-rtw88-correct-PS-calculation-for-SUPPORTS_DYNAM.patch new file mode 100644 index 0000000000..5d15e8da86 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/056-wifi-rtw88-correct-PS-calculation-for-SUPPORTS_DYNAM.patch @@ -0,0 +1,145 @@ +From 3918dd0177ee08970683a2c22a3388825d82fd79 Mon Sep 17 00:00:00 2001 +From: Ping-Ke Shih +Date: Sat, 27 May 2023 16:29:37 +0800 +Subject: [PATCH 11/12] wifi: rtw88: correct PS calculation for + SUPPORTS_DYNAMIC_PS + +This driver relies on IEEE80211_CONF_PS of hw->conf.flags to turn off PS or +turn on dynamic PS controlled by driver and firmware. Though this would be +incorrect, it did work before because the flag is always recalculated until +the commit 28977e790b5d ("wifi: mac80211: skip powersave recalc if driver SUPPORTS_DYNAMIC_PS") +is introduced by kernel 5.20 to skip to recalculate IEEE80211_CONF_PS +of hw->conf.flags if driver sets SUPPORTS_DYNAMIC_PS. + +Correct this by doing recalculation while BSS_CHANGED_PS is changed and +interface is added or removed. It is allowed to enter PS only if single +one station vif is working. Without this fix, driver doesn't enter PS +anymore that causes higher power consumption. + +Fixes: bcde60e599fb ("rtw88: remove misleading module parameter rtw_fw_support_lps") +Cc: stable@vger.kernel.org # 6.1+ +Signed-off-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230527082939.11206-2-pkshih@realtek.com +--- + drivers/net/wireless/realtek/rtw88/mac80211.c | 14 +++--- + drivers/net/wireless/realtek/rtw88/main.c | 4 +- + drivers/net/wireless/realtek/rtw88/ps.c | 43 +++++++++++++++++++ + drivers/net/wireless/realtek/rtw88/ps.h | 2 + + 4 files changed, 52 insertions(+), 11 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/mac80211.c ++++ b/drivers/net/wireless/realtek/rtw88/mac80211.c +@@ -88,15 +88,6 @@ static int rtw_ops_config(struct ieee802 + } + } + +- if (changed & IEEE80211_CONF_CHANGE_PS) { +- if (hw->conf.flags & IEEE80211_CONF_PS) { +- rtwdev->ps_enabled = true; +- } else { +- rtwdev->ps_enabled = false; +- rtw_leave_lps(rtwdev); +- } +- } +- + if (changed & IEEE80211_CONF_CHANGE_CHANNEL) + rtw_set_channel(rtwdev); + +@@ -215,6 +206,7 @@ static int rtw_ops_add_interface(struct + config |= PORT_SET_BCN_CTRL; + rtw_vif_port_config(rtwdev, rtwvif, config); + rtw_core_port_switch(rtwdev, vif); ++ rtw_recalc_lps(rtwdev, vif); + + mutex_unlock(&rtwdev->mutex); + +@@ -246,6 +238,7 @@ static void rtw_ops_remove_interface(str + config |= PORT_SET_BCN_CTRL; + rtw_vif_port_config(rtwdev, rtwvif, config); + clear_bit(rtwvif->port, rtwdev->hw_port); ++ rtw_recalc_lps(rtwdev, NULL); + + mutex_unlock(&rtwdev->mutex); + } +@@ -440,6 +433,9 @@ static void rtw_ops_bss_info_changed(str + if (changed & BSS_CHANGED_ERP_SLOT) + rtw_conf_tx(rtwdev, rtwvif); + ++ if (changed & BSS_CHANGED_PS) ++ rtw_recalc_lps(rtwdev, NULL); ++ + rtw_vif_port_config(rtwdev, rtwvif, config); + + mutex_unlock(&rtwdev->mutex); +--- a/drivers/net/wireless/realtek/rtw88/main.c ++++ b/drivers/net/wireless/realtek/rtw88/main.c +@@ -271,8 +271,8 @@ static void rtw_watch_dog_work(struct wo + * more than two stations associated to the AP, then we can not enter + * lps, because fw does not handle the overlapped beacon interval + * +- * mac80211 should iterate vifs and determine if driver can enter +- * ps by passing IEEE80211_CONF_PS to us, all we need to do is to ++ * rtw_recalc_lps() iterate vifs and determine if driver can enter ++ * ps by vif->type and vif->cfg.ps, all we need to do here is to + * get that vif and check if device is having traffic more than the + * threshold. + */ +--- a/drivers/net/wireless/realtek/rtw88/ps.c ++++ b/drivers/net/wireless/realtek/rtw88/ps.c +@@ -299,3 +299,46 @@ void rtw_leave_lps_deep(struct rtw_dev * + + __rtw_leave_lps_deep(rtwdev); + } ++ ++struct rtw_vif_recalc_lps_iter_data { ++ struct rtw_dev *rtwdev; ++ struct ieee80211_vif *found_vif; ++ int count; ++}; ++ ++static void __rtw_vif_recalc_lps(struct rtw_vif_recalc_lps_iter_data *data, ++ struct ieee80211_vif *vif) ++{ ++ if (data->count < 0) ++ return; ++ ++ if (vif->type != NL80211_IFTYPE_STATION) { ++ data->count = -1; ++ return; ++ } ++ ++ data->count++; ++ data->found_vif = vif; ++} ++ ++static void rtw_vif_recalc_lps_iter(void *data, u8 *mac, ++ struct ieee80211_vif *vif) ++{ ++ __rtw_vif_recalc_lps(data, vif); ++} ++ ++void rtw_recalc_lps(struct rtw_dev *rtwdev, struct ieee80211_vif *new_vif) ++{ ++ struct rtw_vif_recalc_lps_iter_data data = { .rtwdev = rtwdev }; ++ ++ if (new_vif) ++ __rtw_vif_recalc_lps(&data, new_vif); ++ rtw_iterate_vifs(rtwdev, rtw_vif_recalc_lps_iter, &data); ++ ++ if (data.count == 1 && data.found_vif->cfg.ps) { ++ rtwdev->ps_enabled = true; ++ } else { ++ rtwdev->ps_enabled = false; ++ rtw_leave_lps(rtwdev); ++ } ++} +--- a/drivers/net/wireless/realtek/rtw88/ps.h ++++ b/drivers/net/wireless/realtek/rtw88/ps.h +@@ -23,4 +23,6 @@ void rtw_enter_lps(struct rtw_dev *rtwde + void rtw_leave_lps(struct rtw_dev *rtwdev); + void rtw_leave_lps_deep(struct rtw_dev *rtwdev); + enum rtw_lps_deep_mode rtw_get_lps_deep_mode(struct rtw_dev *rtwdev); ++void rtw_recalc_lps(struct rtw_dev *rtwdev, struct ieee80211_vif *new_vif); ++ + #endif diff --git a/package/kernel/mac80211/patches/rtl/057-wifi-rtw88-add-missing-unwind-goto-for-__rtw_downloa.patch b/package/kernel/mac80211/patches/rtl/057-wifi-rtw88-add-missing-unwind-goto-for-__rtw_downloa.patch new file mode 100644 index 0000000000..b3f650b41d --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/057-wifi-rtw88-add-missing-unwind-goto-for-__rtw_downloa.patch @@ -0,0 +1,41 @@ +From 91ccdbb94feadb0d8bf3b35c841b33ac95f2f45f Mon Sep 17 00:00:00 2001 +From: Ping-Ke Shih +Date: Wed, 7 Jun 2023 09:27:41 +0800 +Subject: [PATCH 12/12] wifi: rtw88: add missing unwind goto for + __rtw_download_firmware() + +This flaw is detected by smatch: + drivers/net/wireless/realtek/rtw88/mac.c:748 __rtw_download_firmware() + warn: missing unwind goto? + +Though most things of dlfw_fail have been done by +download_firmware_end_flow() and wlan_cpu_enable(), an exception is that +download_firmware_end_flow() clear BIT_MCUFWDL_EN bit conditionally. +So, make this change to clear the bit. + +Reported-by: kernel test robot +Reported-by: Dan Carpenter +Closes: https://lore.kernel.org/r/202306052310.OVhcUjZ3-lkp@intel.com/ +Cc: Sascha Hauer +Signed-off-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230607012741.10353-1-pkshih@realtek.com +--- + drivers/net/wireless/realtek/rtw88/mac.c | 6 ++++-- + 1 file changed, 4 insertions(+), 2 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/mac.c ++++ b/drivers/net/wireless/realtek/rtw88/mac.c +@@ -794,8 +794,10 @@ static int __rtw_download_firmware(struc + + wlan_cpu_enable(rtwdev, true); + +- if (!ltecoex_reg_write(rtwdev, 0x38, ltecoex_bckp)) +- return -EBUSY; ++ if (!ltecoex_reg_write(rtwdev, 0x38, ltecoex_bckp)) { ++ ret = -EBUSY; ++ goto dlfw_fail; ++ } + + ret = download_firmware_validate(rtwdev); + if (ret) diff --git a/package/kernel/mac80211/patches/rtl/058-wifi-rtw88-Fix-action-frame-transmission-fail-before.patch b/package/kernel/mac80211/patches/rtl/058-wifi-rtw88-Fix-action-frame-transmission-fail-before.patch new file mode 100644 index 0000000000..28dfaed179 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/058-wifi-rtw88-Fix-action-frame-transmission-fail-before.patch @@ -0,0 +1,40 @@ +From 2ce9a91fe8bfb0c8e647a6b7b88055881faf7502 Mon Sep 17 00:00:00 2001 +From: Po-Hao Huang +Date: Thu, 15 Jun 2023 19:43:48 +0800 +Subject: [PATCH 1/8] wifi: rtw88: Fix action frame transmission fail before + association + +For combo chips, antennas were controlled by bluetooth only during +power on. If WiFi wish to do transmission, notification to the coexistence +module are required. Previously we only do this before authentication. +To allow transmission before auth, such as management TX, now we start +the initiation of coexistence earlier so antennas are shared between +WiFi and bluetooth after set_channel(), and frames could then be sent. + +Signed-off-by: Po-Hao Huang +Signed-off-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230615114348.7193-1-pkshih@realtek.com +--- + drivers/net/wireless/realtek/rtw88/ps.c | 3 +-- + 1 file changed, 1 insertion(+), 2 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/ps.c ++++ b/drivers/net/wireless/realtek/rtw88/ps.c +@@ -18,6 +18,7 @@ static int rtw_ips_pwr_up(struct rtw_dev + if (ret) + rtw_err(rtwdev, "leave idle state failed\n"); + ++ rtw_coex_ips_notify(rtwdev, COEX_IPS_LEAVE); + rtw_set_channel(rtwdev); + + return ret; +@@ -63,8 +64,6 @@ int rtw_leave_ips(struct rtw_dev *rtwdev + + rtw_iterate_vifs(rtwdev, rtw_restore_port_cfg_iter, rtwdev); + +- rtw_coex_ips_notify(rtwdev, COEX_IPS_LEAVE); +- + return 0; + } + diff --git a/package/kernel/mac80211/patches/rtl/059-wifi-rtw88-process-VO-packets-without-workqueue-to-a.patch b/package/kernel/mac80211/patches/rtl/059-wifi-rtw88-process-VO-packets-without-workqueue-to-a.patch new file mode 100644 index 0000000000..e750903ed4 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/059-wifi-rtw88-process-VO-packets-without-workqueue-to-a.patch @@ -0,0 +1,85 @@ +From 67d7f24b194e6e8e82540aa4fe97580f6cfa0902 Mon Sep 17 00:00:00 2001 +From: Chih-Kang Chang +Date: Fri, 16 Jun 2023 11:17:13 +0800 +Subject: [PATCH 2/8] wifi: rtw88: process VO packets without workqueue to + avoid PTK rekey failed + +In the wpa_supplicant rekey flow, it sends an EAPOL packet 4/4 through +nl80211_tx_control_port() and triggers wake_tx_queue() in the driver. +Then, it sends nl80211_new_key() to configure a new key in mac80211. +However, in wake_tx_queue(), a workqueue is used to process the tx packet, +which might cause the driver to process the EAPOL packet later than +nl80211_new_key(). As a result, the EAPOL 4/4 packet is dropped by mac80211 +due to the rekey configuration being finished. The EAPOL packets belongs to +VO packets that need high priority. Therefore, we process VO packets +directly without workqueue to ensure that packets can process immediately. + +VO is normally used by voice application that is low traffic load and low +latency, that doesn't affect user experience. +We test iperf with VO packets(iperf3 -P4 -u -b 10000M -S 0xdf) + before after +TX throughput 162M 162M +ping RTT 3.8ms 3.7ms + +Signed-off-by: Chih-Kang Chang +Signed-off-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230616031713.16769-1-pkshih@realtek.com +--- + drivers/net/wireless/realtek/rtw88/mac80211.c | 6 +++++- + drivers/net/wireless/realtek/rtw88/tx.c | 10 ++++++++-- + drivers/net/wireless/realtek/rtw88/tx.h | 1 + + 3 files changed, 14 insertions(+), 3 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/mac80211.c ++++ b/drivers/net/wireless/realtek/rtw88/mac80211.c +@@ -43,7 +43,11 @@ static void rtw_ops_wake_tx_queue(struct + list_add_tail(&rtwtxq->list, &rtwdev->txqs); + spin_unlock_bh(&rtwdev->txq_lock); + +- queue_work(rtwdev->tx_wq, &rtwdev->tx_work); ++ /* ensure to dequeue EAPOL (4/4) at the right time */ ++ if (txq->ac == IEEE80211_AC_VO) ++ __rtw_tx_work(rtwdev); ++ else ++ queue_work(rtwdev->tx_wq, &rtwdev->tx_work); + } + + static int rtw_ops_start(struct ieee80211_hw *hw) +--- a/drivers/net/wireless/realtek/rtw88/tx.c ++++ b/drivers/net/wireless/realtek/rtw88/tx.c +@@ -635,9 +635,8 @@ static void rtw_txq_push(struct rtw_dev + rcu_read_unlock(); + } + +-void rtw_tx_work(struct work_struct *w) ++void __rtw_tx_work(struct rtw_dev *rtwdev) + { +- struct rtw_dev *rtwdev = container_of(w, struct rtw_dev, tx_work); + struct rtw_txq *rtwtxq, *tmp; + + spin_lock_bh(&rtwdev->txq_lock); +@@ -658,6 +657,13 @@ void rtw_tx_work(struct work_struct *w) + spin_unlock_bh(&rtwdev->txq_lock); + } + ++void rtw_tx_work(struct work_struct *w) ++{ ++ struct rtw_dev *rtwdev = container_of(w, struct rtw_dev, tx_work); ++ ++ __rtw_tx_work(rtwdev); ++} ++ + void rtw_txq_init(struct rtw_dev *rtwdev, struct ieee80211_txq *txq) + { + struct rtw_txq *rtwtxq; +--- a/drivers/net/wireless/realtek/rtw88/tx.h ++++ b/drivers/net/wireless/realtek/rtw88/tx.h +@@ -111,6 +111,7 @@ void rtw_tx(struct rtw_dev *rtwdev, + void rtw_txq_init(struct rtw_dev *rtwdev, struct ieee80211_txq *txq); + void rtw_txq_cleanup(struct rtw_dev *rtwdev, struct ieee80211_txq *txq); + void rtw_tx_work(struct work_struct *w); ++void __rtw_tx_work(struct rtw_dev *rtwdev); + void rtw_tx_pkt_info_update(struct rtw_dev *rtwdev, + struct rtw_tx_pkt_info *pkt_info, + struct ieee80211_sta *sta, diff --git a/package/kernel/mac80211/patches/rtl/060-wifi-rtw88-use-struct-instead-of-macros-to-set-TX-de.patch b/package/kernel/mac80211/patches/rtl/060-wifi-rtw88-use-struct-instead-of-macros-to-set-TX-de.patch new file mode 100644 index 0000000000..7712882417 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/060-wifi-rtw88-use-struct-instead-of-macros-to-set-TX-de.patch @@ -0,0 +1,317 @@ +From 88b9d8e6cf9cf89be50ca2ee6cb9b3180b432172 Mon Sep 17 00:00:00 2001 +From: Po-Hao Huang +Date: Fri, 16 Jun 2023 20:55:35 +0800 +Subject: [PATCH 3/8] wifi: rtw88: use struct instead of macros to set TX desc + +Remove macros that set TX descriptors. Use struct and +le32_encode_bits() with mask definitions. + +Signed-off-by: Po-Hao Huang +Signed-off-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230616125540.36877-2-pkshih@realtek.com +--- + drivers/net/wireless/realtek/rtw88/rtw8723d.c | 6 +- + drivers/net/wireless/realtek/rtw88/tx.c | 79 +++++++----- + drivers/net/wireless/realtek/rtw88/tx.h | 122 +++++++----------- + drivers/net/wireless/realtek/rtw88/usb.c | 12 +- + 4 files changed, 106 insertions(+), 113 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/rtw8723d.c ++++ b/drivers/net/wireless/realtek/rtw88/rtw8723d.c +@@ -1970,15 +1970,17 @@ static void rtw8723d_fill_txdesc_checksu + size_t words = 32 / 2; /* calculate the first 32 bytes (16 words) */ + __le16 chksum = 0; + __le16 *data = (__le16 *)(txdesc); ++ struct rtw_tx_desc *tx_desc = (struct rtw_tx_desc *)txdesc; + +- SET_TX_DESC_TXDESC_CHECKSUM(txdesc, 0x0000); ++ le32p_replace_bits(&tx_desc->w7, 0, RTW_TX_DESC_W7_TXDESC_CHECKSUM); + + while (words--) + chksum ^= *data++; + + chksum = ~chksum; + +- SET_TX_DESC_TXDESC_CHECKSUM(txdesc, __le16_to_cpu(chksum)); ++ le32p_replace_bits(&tx_desc->w7, __le16_to_cpu(chksum), ++ RTW_TX_DESC_W7_TXDESC_CHECKSUM); + } + + static struct rtw_chip_ops rtw8723d_ops = { +--- a/drivers/net/wireless/realtek/rtw88/tx.c ++++ b/drivers/net/wireless/realtek/rtw88/tx.c +@@ -34,43 +34,52 @@ void rtw_tx_stats(struct rtw_dev *rtwdev + + void rtw_tx_fill_tx_desc(struct rtw_tx_pkt_info *pkt_info, struct sk_buff *skb) + { +- __le32 *txdesc = (__le32 *)skb->data; ++ struct rtw_tx_desc *tx_desc = (struct rtw_tx_desc *)skb->data; ++ ++ tx_desc->w0 = le32_encode_bits(pkt_info->tx_pkt_size, RTW_TX_DESC_W0_TXPKTSIZE) | ++ le32_encode_bits(pkt_info->offset, RTW_TX_DESC_W0_OFFSET) | ++ le32_encode_bits(pkt_info->bmc, RTW_TX_DESC_W0_BMC) | ++ le32_encode_bits(pkt_info->ls, RTW_TX_DESC_W0_LS) | ++ le32_encode_bits(pkt_info->dis_qselseq, RTW_TX_DESC_W0_DISQSELSEQ); ++ ++ tx_desc->w1 = le32_encode_bits(pkt_info->qsel, RTW_TX_DESC_W1_QSEL) | ++ le32_encode_bits(pkt_info->rate_id, RTW_TX_DESC_W1_RATE_ID) | ++ le32_encode_bits(pkt_info->sec_type, RTW_TX_DESC_W1_SEC_TYPE) | ++ le32_encode_bits(pkt_info->pkt_offset, RTW_TX_DESC_W1_PKT_OFFSET); ++ ++ tx_desc->w2 = le32_encode_bits(pkt_info->ampdu_en, RTW_TX_DESC_W2_AGG_EN) | ++ le32_encode_bits(pkt_info->report, RTW_TX_DESC_W2_SPE_RPT) | ++ le32_encode_bits(pkt_info->ampdu_density, RTW_TX_DESC_W2_AMPDU_DEN) | ++ le32_encode_bits(pkt_info->bt_null, RTW_TX_DESC_W2_BT_NULL); ++ ++ tx_desc->w3 = le32_encode_bits(pkt_info->hw_ssn_sel, RTW_TX_DESC_W3_HW_SSN_SEL) | ++ le32_encode_bits(pkt_info->use_rate, RTW_TX_DESC_W3_USE_RATE) | ++ le32_encode_bits(pkt_info->dis_rate_fallback, RTW_TX_DESC_W3_DISDATAFB) | ++ le32_encode_bits(pkt_info->rts, RTW_TX_DESC_W3_USE_RTS) | ++ le32_encode_bits(pkt_info->nav_use_hdr, RTW_TX_DESC_W3_NAVUSEHDR) | ++ le32_encode_bits(pkt_info->ampdu_factor, RTW_TX_DESC_W3_MAX_AGG_NUM); ++ ++ tx_desc->w4 = le32_encode_bits(pkt_info->rate, RTW_TX_DESC_W4_DATARATE); ++ ++ tx_desc->w5 = le32_encode_bits(pkt_info->short_gi, RTW_TX_DESC_W5_DATA_SHORT) | ++ le32_encode_bits(pkt_info->bw, RTW_TX_DESC_W5_DATA_BW) | ++ le32_encode_bits(pkt_info->ldpc, RTW_TX_DESC_W5_DATA_LDPC) | ++ le32_encode_bits(pkt_info->stbc, RTW_TX_DESC_W5_DATA_STBC); ++ ++ tx_desc->w6 = le32_encode_bits(pkt_info->sn, RTW_TX_DESC_W6_SW_DEFINE); ++ ++ tx_desc->w8 = le32_encode_bits(pkt_info->en_hwseq, RTW_TX_DESC_W8_EN_HWSEQ); ++ ++ tx_desc->w9 = le32_encode_bits(pkt_info->seq, RTW_TX_DESC_W9_SW_SEQ); + +- SET_TX_DESC_TXPKTSIZE(txdesc, pkt_info->tx_pkt_size); +- SET_TX_DESC_OFFSET(txdesc, pkt_info->offset); +- SET_TX_DESC_PKT_OFFSET(txdesc, pkt_info->pkt_offset); +- SET_TX_DESC_QSEL(txdesc, pkt_info->qsel); +- SET_TX_DESC_BMC(txdesc, pkt_info->bmc); +- SET_TX_DESC_RATE_ID(txdesc, pkt_info->rate_id); +- SET_TX_DESC_DATARATE(txdesc, pkt_info->rate); +- SET_TX_DESC_DISDATAFB(txdesc, pkt_info->dis_rate_fallback); +- SET_TX_DESC_USE_RATE(txdesc, pkt_info->use_rate); +- SET_TX_DESC_SEC_TYPE(txdesc, pkt_info->sec_type); +- SET_TX_DESC_DATA_BW(txdesc, pkt_info->bw); +- SET_TX_DESC_SW_SEQ(txdesc, pkt_info->seq); +- SET_TX_DESC_MAX_AGG_NUM(txdesc, pkt_info->ampdu_factor); +- SET_TX_DESC_AMPDU_DENSITY(txdesc, pkt_info->ampdu_density); +- SET_TX_DESC_DATA_STBC(txdesc, pkt_info->stbc); +- SET_TX_DESC_DATA_LDPC(txdesc, pkt_info->ldpc); +- SET_TX_DESC_AGG_EN(txdesc, pkt_info->ampdu_en); +- SET_TX_DESC_LS(txdesc, pkt_info->ls); +- SET_TX_DESC_DATA_SHORT(txdesc, pkt_info->short_gi); +- SET_TX_DESC_SPE_RPT(txdesc, pkt_info->report); +- SET_TX_DESC_SW_DEFINE(txdesc, pkt_info->sn); +- SET_TX_DESC_USE_RTS(txdesc, pkt_info->rts); + if (pkt_info->rts) { +- SET_TX_DESC_RTSRATE(txdesc, DESC_RATE24M); +- SET_TX_DESC_DATA_RTS_SHORT(txdesc, 1); +- } +- SET_TX_DESC_DISQSELSEQ(txdesc, pkt_info->dis_qselseq); +- SET_TX_DESC_EN_HWSEQ(txdesc, pkt_info->en_hwseq); +- SET_TX_DESC_HW_SSN_SEL(txdesc, pkt_info->hw_ssn_sel); +- SET_TX_DESC_NAVUSEHDR(txdesc, pkt_info->nav_use_hdr); +- SET_TX_DESC_BT_NULL(txdesc, pkt_info->bt_null); +- if (pkt_info->tim_offset) { +- SET_TX_DESC_TIM_EN(txdesc, 1); +- SET_TX_DESC_TIM_OFFSET(txdesc, pkt_info->tim_offset); ++ tx_desc->w4 |= le32_encode_bits(DESC_RATE24M, RTW_TX_DESC_W4_RTSRATE); ++ tx_desc->w5 |= le32_encode_bits(1, RTW_TX_DESC_W5_DATA_RTS_SHORT); + } ++ ++ if (pkt_info->tim_offset) ++ tx_desc->w9 |= le32_encode_bits(1, RTW_TX_DESC_W9_TIM_EN) | ++ le32_encode_bits(pkt_info->tim_offset, RTW_TX_DESC_W9_TIM_OFFSET); + } + EXPORT_SYMBOL(rtw_tx_fill_tx_desc); + +--- a/drivers/net/wireless/realtek/rtw88/tx.h ++++ b/drivers/net/wireless/realtek/rtw88/tx.h +@@ -9,76 +9,52 @@ + + #define RTW_TX_PROBE_TIMEOUT msecs_to_jiffies(500) + +-#define SET_TX_DESC_TXPKTSIZE(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x00, value, GENMASK(15, 0)) +-#define SET_TX_DESC_OFFSET(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x00, value, GENMASK(23, 16)) +-#define SET_TX_DESC_PKT_OFFSET(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x01, value, GENMASK(28, 24)) +-#define SET_TX_DESC_QSEL(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x01, value, GENMASK(12, 8)) +-#define SET_TX_DESC_BMC(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x00, value, BIT(24)) +-#define SET_TX_DESC_RATE_ID(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x01, value, GENMASK(20, 16)) +-#define SET_TX_DESC_DATARATE(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x04, value, GENMASK(6, 0)) +-#define SET_TX_DESC_DISDATAFB(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x03, value, BIT(10)) +-#define SET_TX_DESC_USE_RATE(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x03, value, BIT(8)) +-#define SET_TX_DESC_SEC_TYPE(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x01, value, GENMASK(23, 22)) +-#define SET_TX_DESC_DATA_BW(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x05, value, GENMASK(6, 5)) +-#define SET_TX_DESC_SW_SEQ(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x09, value, GENMASK(23, 12)) +-#define SET_TX_DESC_TIM_EN(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x09, value, BIT(7)) +-#define SET_TX_DESC_TIM_OFFSET(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x09, value, GENMASK(6, 0)) +-#define SET_TX_DESC_MAX_AGG_NUM(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x03, value, GENMASK(21, 17)) +-#define SET_TX_DESC_USE_RTS(tx_desc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x03, value, BIT(12)) +-#define SET_TX_DESC_RTSRATE(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x04, value, GENMASK(28, 24)) +-#define SET_TX_DESC_DATA_RTS_SHORT(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x05, value, BIT(12)) +-#define SET_TX_DESC_AMPDU_DENSITY(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x02, value, GENMASK(22, 20)) +-#define SET_TX_DESC_DATA_STBC(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x05, value, GENMASK(9, 8)) +-#define SET_TX_DESC_DATA_LDPC(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x05, value, BIT(7)) +-#define SET_TX_DESC_AGG_EN(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x02, value, BIT(12)) +-#define SET_TX_DESC_LS(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x00, value, BIT(26)) +-#define SET_TX_DESC_DATA_SHORT(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x05, value, BIT(4)) +-#define SET_TX_DESC_SPE_RPT(tx_desc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x02, value, BIT(19)) +-#define SET_TX_DESC_SW_DEFINE(tx_desc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x06, value, GENMASK(11, 0)) +-#define SET_TX_DESC_DISQSELSEQ(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x00, value, BIT(31)) +-#define SET_TX_DESC_EN_HWSEQ(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x08, value, BIT(15)) +-#define SET_TX_DESC_HW_SSN_SEL(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x03, value, GENMASK(7, 6)) +-#define SET_TX_DESC_NAVUSEHDR(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x03, value, BIT(15)) +-#define SET_TX_DESC_BT_NULL(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x02, value, BIT(23)) +-#define SET_TX_DESC_TXDESC_CHECKSUM(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x07, value, GENMASK(15, 0)) +-#define SET_TX_DESC_DMA_TXAGG_NUM(txdesc, value) \ +- le32p_replace_bits((__le32 *)(txdesc) + 0x07, value, GENMASK(31, 24)) +-#define GET_TX_DESC_PKT_OFFSET(txdesc) \ +- le32_get_bits(*((__le32 *)(txdesc) + 0x01), GENMASK(28, 24)) +-#define GET_TX_DESC_QSEL(txdesc) \ +- le32_get_bits(*((__le32 *)(txdesc) + 0x01), GENMASK(12, 8)) ++struct rtw_tx_desc { ++ __le32 w0; ++ __le32 w1; ++ __le32 w2; ++ __le32 w3; ++ __le32 w4; ++ __le32 w5; ++ __le32 w6; ++ __le32 w7; ++ __le32 w8; ++ __le32 w9; ++} __packed; ++ ++#define RTW_TX_DESC_W0_TXPKTSIZE GENMASK(15, 0) ++#define RTW_TX_DESC_W0_OFFSET GENMASK(23, 16) ++#define RTW_TX_DESC_W0_BMC BIT(24) ++#define RTW_TX_DESC_W0_LS BIT(26) ++#define RTW_TX_DESC_W0_DISQSELSEQ BIT(31) ++#define RTW_TX_DESC_W1_QSEL GENMASK(12, 8) ++#define RTW_TX_DESC_W1_RATE_ID GENMASK(20, 16) ++#define RTW_TX_DESC_W1_SEC_TYPE GENMASK(23, 22) ++#define RTW_TX_DESC_W1_PKT_OFFSET GENMASK(28, 24) ++#define RTW_TX_DESC_W2_AGG_EN BIT(12) ++#define RTW_TX_DESC_W2_SPE_RPT BIT(19) ++#define RTW_TX_DESC_W2_AMPDU_DEN GENMASK(22, 20) ++#define RTW_TX_DESC_W2_BT_NULL BIT(23) ++#define RTW_TX_DESC_W3_HW_SSN_SEL GENMASK(7, 6) ++#define RTW_TX_DESC_W3_USE_RATE BIT(8) ++#define RTW_TX_DESC_W3_DISDATAFB BIT(10) ++#define RTW_TX_DESC_W3_USE_RTS BIT(12) ++#define RTW_TX_DESC_W3_NAVUSEHDR BIT(15) ++#define RTW_TX_DESC_W3_MAX_AGG_NUM GENMASK(21, 17) ++#define RTW_TX_DESC_W4_DATARATE GENMASK(6, 0) ++#define RTW_TX_DESC_W4_RTSRATE GENMASK(28, 24) ++#define RTW_TX_DESC_W5_DATA_SHORT BIT(4) ++#define RTW_TX_DESC_W5_DATA_BW GENMASK(6, 5) ++#define RTW_TX_DESC_W5_DATA_LDPC BIT(7) ++#define RTW_TX_DESC_W5_DATA_STBC GENMASK(9, 8) ++#define RTW_TX_DESC_W5_DATA_RTS_SHORT BIT(12) ++#define RTW_TX_DESC_W6_SW_DEFINE GENMASK(11, 0) ++#define RTW_TX_DESC_W7_TXDESC_CHECKSUM GENMASK(15, 0) ++#define RTW_TX_DESC_W7_DMA_TXAGG_NUM GENMASK(31, 24) ++#define RTW_TX_DESC_W8_EN_HWSEQ BIT(15) ++#define RTW_TX_DESC_W9_SW_SEQ GENMASK(23, 12) ++#define RTW_TX_DESC_W9_TIM_EN BIT(7) ++#define RTW_TX_DESC_W9_TIM_OFFSET GENMASK(6, 0) + + enum rtw_tx_desc_queue_select { + TX_DESC_QSEL_TID0 = 0, +@@ -140,13 +116,15 @@ void fill_txdesc_checksum_common(u8 *txd + { + __le16 chksum = 0; + __le16 *data = (__le16 *)(txdesc); ++ struct rtw_tx_desc *tx_desc = (struct rtw_tx_desc *)txdesc; + +- SET_TX_DESC_TXDESC_CHECKSUM(txdesc, 0x0000); ++ le32p_replace_bits(&tx_desc->w7, 0, RTW_TX_DESC_W7_TXDESC_CHECKSUM); + + while (words--) + chksum ^= *data++; + +- SET_TX_DESC_TXDESC_CHECKSUM(txdesc, __le16_to_cpu(chksum)); ++ le32p_replace_bits(&tx_desc->w7, __le16_to_cpu(chksum), ++ RTW_TX_DESC_W7_TXDESC_CHECKSUM); + } + + static inline void rtw_tx_fill_txdesc_checksum(struct rtw_dev *rtwdev, +--- a/drivers/net/wireless/realtek/rtw88/usb.c ++++ b/drivers/net/wireless/realtek/rtw88/usb.c +@@ -24,11 +24,12 @@ struct rtw_usb_txcb { + static void rtw_usb_fill_tx_checksum(struct rtw_usb *rtwusb, + struct sk_buff *skb, int agg_num) + { ++ struct rtw_tx_desc *tx_desc = (struct rtw_tx_desc *)skb->data; + struct rtw_dev *rtwdev = rtwusb->rtwdev; + struct rtw_tx_pkt_info pkt_info; + +- SET_TX_DESC_DMA_TXAGG_NUM(skb->data, agg_num); +- pkt_info.pkt_offset = GET_TX_DESC_PKT_OFFSET(skb->data); ++ le32p_replace_bits(&tx_desc->w7, agg_num, RTW_TX_DESC_W7_DMA_TXAGG_NUM); ++ pkt_info.pkt_offset = le32_get_bits(tx_desc->w1, RTW_TX_DESC_W1_PKT_OFFSET); + rtw_tx_fill_txdesc_checksum(rtwdev, &pkt_info, skb->data); + } + +@@ -306,11 +307,13 @@ static int rtw_usb_write_port(struct rtw + static bool rtw_usb_tx_agg_skb(struct rtw_usb *rtwusb, struct sk_buff_head *list) + { + struct rtw_dev *rtwdev = rtwusb->rtwdev; ++ struct rtw_tx_desc *tx_desc; + struct rtw_usb_txcb *txcb; + struct sk_buff *skb_head; + struct sk_buff *skb_iter; + int agg_num = 0; + unsigned int align_next = 0; ++ u8 qsel; + + if (skb_queue_empty(list)) + return false; +@@ -363,9 +366,10 @@ static bool rtw_usb_tx_agg_skb(struct rt + + queue: + skb_queue_tail(&txcb->tx_ack_queue, skb_head); ++ tx_desc = (struct rtw_tx_desc *)skb_head->data; ++ qsel = le32_get_bits(tx_desc->w1, RTW_TX_DESC_W1_QSEL); + +- rtw_usb_write_port(rtwdev, GET_TX_DESC_QSEL(skb_head->data), skb_head, +- rtw_usb_write_port_tx_complete, txcb); ++ rtw_usb_write_port(rtwdev, qsel, skb_head, rtw_usb_write_port_tx_complete, txcb); + + return true; + } diff --git a/package/kernel/mac80211/patches/rtl/061-wifi-rtw88-Fix-AP-mode-incorrect-DTIM-behavior.patch b/package/kernel/mac80211/patches/rtl/061-wifi-rtw88-Fix-AP-mode-incorrect-DTIM-behavior.patch new file mode 100644 index 0000000000..8bb49133e3 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/061-wifi-rtw88-Fix-AP-mode-incorrect-DTIM-behavior.patch @@ -0,0 +1,96 @@ +From 076f786a0ae14a81f40314b96a2d815e264bc213 Mon Sep 17 00:00:00 2001 +From: Po-Hao Huang +Date: Fri, 16 Jun 2023 20:55:36 +0800 +Subject: [PATCH 4/8] wifi: rtw88: Fix AP mode incorrect DTIM behavior + +Broadcast and multicast packets in high queue should be transmitted +all at once during DTIM. But without proper settings, hardware fails +to recognize that there are multiple packets and fetches only one. +Fix this by signaling hardware with more data bit set when there are +packets in the high queue. + +Signed-off-by: Po-Hao Huang +Signed-off-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230616125540.36877-3-pkshih@realtek.com +--- + drivers/net/wireless/realtek/rtw88/mac80211.c | 2 ++ + drivers/net/wireless/realtek/rtw88/reg.h | 1 + + drivers/net/wireless/realtek/rtw88/tx.c | 7 ++++++- + drivers/net/wireless/realtek/rtw88/tx.h | 1 + + drivers/net/wireless/realtek/rtw88/usb.c | 3 +++ + 5 files changed, 13 insertions(+), 1 deletion(-) + +--- a/drivers/net/wireless/realtek/rtw88/mac80211.c ++++ b/drivers/net/wireless/realtek/rtw88/mac80211.c +@@ -453,6 +453,7 @@ static int rtw_ops_start_ap(struct ieee8 + const struct rtw_chip_info *chip = rtwdev->chip; + + mutex_lock(&rtwdev->mutex); ++ rtw_write32_set(rtwdev, REG_TCR, BIT_TCR_UPDATE_HGQMD); + rtwdev->ap_active = true; + rtw_store_op_chan(rtwdev, true); + chip->ops->phy_calibration(rtwdev); +@@ -468,6 +469,7 @@ static void rtw_ops_stop_ap(struct ieee8 + struct rtw_dev *rtwdev = hw->priv; + + mutex_lock(&rtwdev->mutex); ++ rtw_write32_clr(rtwdev, REG_TCR, BIT_TCR_UPDATE_HGQMD); + rtwdev->ap_active = false; + if (!rtw_core_check_sta_active(rtwdev)) + rtw_clear_op_chan(rtwdev); +--- a/drivers/net/wireless/realtek/rtw88/reg.h ++++ b/drivers/net/wireless/realtek/rtw88/reg.h +@@ -410,6 +410,7 @@ + #define REG_TCR 0x0604 + #define BIT_PWRMGT_HWDATA_EN BIT(7) + #define BIT_TCR_UPDATE_TIMIE BIT(5) ++#define BIT_TCR_UPDATE_HGQMD BIT(4) + #define REG_RCR 0x0608 + #define BIT_APP_FCS BIT(31) + #define BIT_APP_MIC BIT(30) +--- a/drivers/net/wireless/realtek/rtw88/tx.c ++++ b/drivers/net/wireless/realtek/rtw88/tx.c +@@ -35,6 +35,10 @@ void rtw_tx_stats(struct rtw_dev *rtwdev + void rtw_tx_fill_tx_desc(struct rtw_tx_pkt_info *pkt_info, struct sk_buff *skb) + { + struct rtw_tx_desc *tx_desc = (struct rtw_tx_desc *)skb->data; ++ bool more_data = false; ++ ++ if (pkt_info->qsel == TX_DESC_QSEL_HIGH) ++ more_data = true; + + tx_desc->w0 = le32_encode_bits(pkt_info->tx_pkt_size, RTW_TX_DESC_W0_TXPKTSIZE) | + le32_encode_bits(pkt_info->offset, RTW_TX_DESC_W0_OFFSET) | +@@ -45,7 +49,8 @@ void rtw_tx_fill_tx_desc(struct rtw_tx_p + tx_desc->w1 = le32_encode_bits(pkt_info->qsel, RTW_TX_DESC_W1_QSEL) | + le32_encode_bits(pkt_info->rate_id, RTW_TX_DESC_W1_RATE_ID) | + le32_encode_bits(pkt_info->sec_type, RTW_TX_DESC_W1_SEC_TYPE) | +- le32_encode_bits(pkt_info->pkt_offset, RTW_TX_DESC_W1_PKT_OFFSET); ++ le32_encode_bits(pkt_info->pkt_offset, RTW_TX_DESC_W1_PKT_OFFSET) | ++ le32_encode_bits(more_data, RTW_TX_DESC_W1_MORE_DATA); + + tx_desc->w2 = le32_encode_bits(pkt_info->ampdu_en, RTW_TX_DESC_W2_AGG_EN) | + le32_encode_bits(pkt_info->report, RTW_TX_DESC_W2_SPE_RPT) | +--- a/drivers/net/wireless/realtek/rtw88/tx.h ++++ b/drivers/net/wireless/realtek/rtw88/tx.h +@@ -31,6 +31,7 @@ struct rtw_tx_desc { + #define RTW_TX_DESC_W1_RATE_ID GENMASK(20, 16) + #define RTW_TX_DESC_W1_SEC_TYPE GENMASK(23, 22) + #define RTW_TX_DESC_W1_PKT_OFFSET GENMASK(28, 24) ++#define RTW_TX_DESC_W1_MORE_DATA BIT(29) + #define RTW_TX_DESC_W2_AGG_EN BIT(12) + #define RTW_TX_DESC_W2_SPE_RPT BIT(19) + #define RTW_TX_DESC_W2_AMPDU_DEN GENMASK(22, 20) +--- a/drivers/net/wireless/realtek/rtw88/usb.c ++++ b/drivers/net/wireless/realtek/rtw88/usb.c +@@ -469,6 +469,9 @@ static u8 rtw_usb_tx_queue_mapping_to_qs + + if (unlikely(ieee80211_is_mgmt(fc) || ieee80211_is_ctl(fc))) + qsel = TX_DESC_QSEL_MGMT; ++ else if (is_broadcast_ether_addr(hdr->addr1) || ++ is_multicast_ether_addr(hdr->addr1)) ++ qsel = TX_DESC_QSEL_HIGH; + else if (skb_get_queue_mapping(skb) <= IEEE80211_AC_BK) + qsel = skb->priority; + else diff --git a/package/kernel/mac80211/patches/rtl/062-wifi-rtw88-Skip-high-queue-in-hci_flush.patch b/package/kernel/mac80211/patches/rtl/062-wifi-rtw88-Skip-high-queue-in-hci_flush.patch new file mode 100644 index 0000000000..4f8b31a899 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/062-wifi-rtw88-Skip-high-queue-in-hci_flush.patch @@ -0,0 +1,32 @@ +From 9e09fbc5e90247fc6e77fb6ba72dcbf8088cf59a Mon Sep 17 00:00:00 2001 +From: Po-Hao Huang +Date: Fri, 16 Jun 2023 20:55:37 +0800 +Subject: [PATCH 5/8] wifi: rtw88: Skip high queue in hci_flush + +The flush period may not always intersect with DTIM and when that +happens, an error log "timed out to flush pci TX ring[6]" is shown. +Bypass this since hardware will do proper transmission on the next +DTIM period for broadcast/multicast packets in high queue. + +Signed-off-by: Po-Hao Huang +Signed-off-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230616125540.36877-4-pkshih@realtek.com +--- + drivers/net/wireless/realtek/rtw88/pci.c | 5 +++-- + 1 file changed, 3 insertions(+), 2 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/pci.c ++++ b/drivers/net/wireless/realtek/rtw88/pci.c +@@ -738,8 +738,9 @@ static void __rtw_pci_flush_queues(struc + u8 q; + + for (q = 0; q < RTK_MAX_TX_QUEUE_NUM; q++) { +- /* It may be not necessary to flush BCN and H2C tx queues. */ +- if (q == RTW_TX_QUEUE_BCN || q == RTW_TX_QUEUE_H2C) ++ /* Unnecessary to flush BCN, H2C and HI tx queues. */ ++ if (q == RTW_TX_QUEUE_BCN || q == RTW_TX_QUEUE_H2C || ++ q == RTW_TX_QUEUE_HI0) + continue; + + if (pci_queues & BIT(q)) diff --git a/package/kernel/mac80211/patches/rtl/063-wifi-rtw88-Stop-high-queue-during-scan.patch b/package/kernel/mac80211/patches/rtl/063-wifi-rtw88-Stop-high-queue-during-scan.patch new file mode 100644 index 0000000000..68c28a72ae --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/063-wifi-rtw88-Stop-high-queue-during-scan.patch @@ -0,0 +1,46 @@ +From ad6741b1e0449ba8f4eb41dc28e269dc20ab9219 Mon Sep 17 00:00:00 2001 +From: Po-Hao Huang +Date: Fri, 16 Jun 2023 20:55:38 +0800 +Subject: [PATCH 6/8] wifi: rtw88: Stop high queue during scan + +When traversing channel list, TX in high queue should be disabled +along with beacon function, so packets won't be sent to incorrect +channels. + +Signed-off-by: Po-Hao Huang +Signed-off-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230616125540.36877-5-pkshih@realtek.com +--- + drivers/net/wireless/realtek/rtw88/main.c | 7 +++++-- + drivers/net/wireless/realtek/rtw88/reg.h | 1 + + 2 files changed, 6 insertions(+), 2 deletions(-) + +--- a/drivers/net/wireless/realtek/rtw88/main.c ++++ b/drivers/net/wireless/realtek/rtw88/main.c +@@ -2403,10 +2403,13 @@ void rtw_core_enable_beacon(struct rtw_d + if (!rtwdev->ap_active) + return; + +- if (enable) ++ if (enable) { + rtw_write32_set(rtwdev, REG_BCN_CTRL, BIT_EN_BCN_FUNCTION); +- else ++ rtw_write32_clr(rtwdev, REG_TXPAUSE, BIT_HIGH_QUEUE); ++ } else { + rtw_write32_clr(rtwdev, REG_BCN_CTRL, BIT_EN_BCN_FUNCTION); ++ rtw_write32_set(rtwdev, REG_TXPAUSE, BIT_HIGH_QUEUE); ++ } + } + + MODULE_AUTHOR("Realtek Corporation"); +--- a/drivers/net/wireless/realtek/rtw88/reg.h ++++ b/drivers/net/wireless/realtek/rtw88/reg.h +@@ -378,6 +378,7 @@ + #define BIT_SIFS_BK_EN BIT(12) + #define REG_TXPAUSE 0x0522 + #define BIT_AC_QUEUE GENMASK(7, 0) ++#define BIT_HIGH_QUEUE BIT(5) + #define REG_RD_CTRL 0x0524 + #define BIT_EDCCA_MSK_CNTDOWN_EN BIT(11) + #define BIT_DIS_TXOP_CFE BIT(10) diff --git a/package/kernel/mac80211/patches/rtl/064-wifi-rtw88-refine-register-based-H2C-command.patch b/package/kernel/mac80211/patches/rtl/064-wifi-rtw88-refine-register-based-H2C-command.patch new file mode 100644 index 0000000000..29564e3570 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/064-wifi-rtw88-refine-register-based-H2C-command.patch @@ -0,0 +1,93 @@ +From 455afa45edb3f1dbc1371201c5ee486bb9a8cd1a Mon Sep 17 00:00:00 2001 +From: Po-Hao Huang +Date: Fri, 16 Jun 2023 20:55:39 +0800 +Subject: [PATCH 7/8] wifi: rtw88: refine register based H2C command + +Since register based H2C commands don't need endian conversion. +Introduce a new API that don't do conversion and send it directly. +New caller are expected to encode with cpu order and gradually +replace the old ones. + +Signed-off-by: Po-Hao Huang +Signed-off-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230616125540.36877-6-pkshih@realtek.com +--- + drivers/net/wireless/realtek/rtw88/fw.c | 51 +++++++++++++++++++++++++ + drivers/net/wireless/realtek/rtw88/fw.h | 5 +++ + 2 files changed, 56 insertions(+) + +--- a/drivers/net/wireless/realtek/rtw88/fw.c ++++ b/drivers/net/wireless/realtek/rtw88/fw.c +@@ -308,6 +308,57 @@ void rtw_fw_c2h_cmd_isr(struct rtw_dev * + } + EXPORT_SYMBOL(rtw_fw_c2h_cmd_isr); + ++static void rtw_fw_send_h2c_command_register(struct rtw_dev *rtwdev, ++ struct rtw_h2c_register *h2c) ++{ ++ u32 box_reg, box_ex_reg; ++ u8 box_state, box; ++ int ret; ++ ++ rtw_dbg(rtwdev, RTW_DBG_FW, "send H2C content %08x %08x\n", h2c->w0, ++ h2c->w1); ++ ++ lockdep_assert_held(&rtwdev->mutex); ++ ++ box = rtwdev->h2c.last_box_num; ++ switch (box) { ++ case 0: ++ box_reg = REG_HMEBOX0; ++ box_ex_reg = REG_HMEBOX0_EX; ++ break; ++ case 1: ++ box_reg = REG_HMEBOX1; ++ box_ex_reg = REG_HMEBOX1_EX; ++ break; ++ case 2: ++ box_reg = REG_HMEBOX2; ++ box_ex_reg = REG_HMEBOX2_EX; ++ break; ++ case 3: ++ box_reg = REG_HMEBOX3; ++ box_ex_reg = REG_HMEBOX3_EX; ++ break; ++ default: ++ WARN(1, "invalid h2c mail box number\n"); ++ return; ++ } ++ ++ ret = read_poll_timeout_atomic(rtw_read8, box_state, ++ !((box_state >> box) & 0x1), 100, 3000, ++ false, rtwdev, REG_HMETFR); ++ ++ if (ret) { ++ rtw_err(rtwdev, "failed to send h2c command\n"); ++ return; ++ } ++ ++ rtw_write32(rtwdev, box_ex_reg, h2c->w1); ++ rtw_write32(rtwdev, box_reg, h2c->w0); ++ ++ if (++rtwdev->h2c.last_box_num >= 4) ++ rtwdev->h2c.last_box_num = 0; ++} ++ + static void rtw_fw_send_h2c_command(struct rtw_dev *rtwdev, + u8 *h2c) + { +--- a/drivers/net/wireless/realtek/rtw88/fw.h ++++ b/drivers/net/wireless/realtek/rtw88/fw.h +@@ -81,6 +81,11 @@ struct rtw_c2h_adaptivity { + u8 option; + } __packed; + ++struct rtw_h2c_register { ++ u32 w0; ++ u32 w1; ++} __packed; ++ + struct rtw_h2c_cmd { + __le32 msg; + __le32 msg_ext; diff --git a/package/kernel/mac80211/patches/rtl/065-wifi-rtw88-fix-not-entering-PS-mode-after-AP-stops.patch b/package/kernel/mac80211/patches/rtl/065-wifi-rtw88-fix-not-entering-PS-mode-after-AP-stops.patch new file mode 100644 index 0000000000..0508a19c42 --- /dev/null +++ b/package/kernel/mac80211/patches/rtl/065-wifi-rtw88-fix-not-entering-PS-mode-after-AP-stops.patch @@ -0,0 +1,139 @@ +From 28c11c29494f1b34e39641eead9c60a8bd26170d Mon Sep 17 00:00:00 2001 +From: Po-Hao Huang +Date: Fri, 16 Jun 2023 20:55:40 +0800 +Subject: [PATCH 8/8] wifi: rtw88: fix not entering PS mode after AP stops + +Without this patch, firmware only track beacons for port 0 and since +we will always start AP on port 0, this results in misbehavior of +power saving mode on other ports after AP stops. + +The "default port" H2C command is used to notify which port should +firmware track. Update the correct settings to firmware so power +saving mode can work properly. + +Signed-off-by: Po-Hao Huang +Signed-off-by: Ping-Ke Shih +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230616125540.36877-7-pkshih@realtek.com +--- + drivers/net/wireless/realtek/rtw88/fw.c | 17 +++++++++++++++++ + drivers/net/wireless/realtek/rtw88/fw.h | 8 ++++++++ + drivers/net/wireless/realtek/rtw88/mac80211.c | 1 + + drivers/net/wireless/realtek/rtw88/main.c | 8 ++++++++ + drivers/net/wireless/realtek/rtw88/main.h | 1 + + 5 files changed, 35 insertions(+) + +--- a/drivers/net/wireless/realtek/rtw88/fw.c ++++ b/drivers/net/wireless/realtek/rtw88/fw.c +@@ -519,6 +519,23 @@ void rtw_fw_query_bt_info(struct rtw_dev + rtw_fw_send_h2c_command(rtwdev, h2c_pkt); + } + ++void rtw_fw_default_port(struct rtw_dev *rtwdev, struct rtw_vif *rtwvif) ++{ ++ struct rtw_h2c_register h2c = {}; ++ ++ if (rtwvif->net_type != RTW_NET_MGD_LINKED) ++ return; ++ ++ /* Leave LPS before default port H2C so FW timer is correct */ ++ rtw_leave_lps(rtwdev); ++ ++ h2c.w0 = u32_encode_bits(H2C_CMD_DEFAULT_PORT, RTW_H2C_W0_CMDID) | ++ u32_encode_bits(rtwvif->port, RTW_H2C_DEFAULT_PORT_W0_PORTID) | ++ u32_encode_bits(rtwvif->mac_id, RTW_H2C_DEFAULT_PORT_W0_MACID); ++ ++ rtw_fw_send_h2c_command_register(rtwdev, &h2c); ++} ++ + void rtw_fw_wl_ch_info(struct rtw_dev *rtwdev, u8 link, u8 ch, u8 bw) + { + u8 h2c_pkt[H2C_PKT_SIZE] = {0}; +--- a/drivers/net/wireless/realtek/rtw88/fw.h ++++ b/drivers/net/wireless/realtek/rtw88/fw.h +@@ -86,6 +86,12 @@ struct rtw_h2c_register { + u32 w1; + } __packed; + ++#define RTW_H2C_W0_CMDID GENMASK(7, 0) ++ ++/* H2C_CMD_DEFAULT_PORT command */ ++#define RTW_H2C_DEFAULT_PORT_W0_PORTID GENMASK(15, 8) ++#define RTW_H2C_DEFAULT_PORT_W0_MACID GENMASK(23, 16) ++ + struct rtw_h2c_cmd { + __le32 msg; + __le32 msg_ext; +@@ -535,6 +541,7 @@ static inline void rtw_h2c_pkt_set_heade + #define H2C_CMD_MEDIA_STATUS_RPT 0x01 + #define H2C_CMD_SET_PWR_MODE 0x20 + #define H2C_CMD_LPS_PG_INFO 0x2b ++#define H2C_CMD_DEFAULT_PORT 0x2c + #define H2C_CMD_RA_INFO 0x40 + #define H2C_CMD_RSSI_MONITOR 0x42 + #define H2C_CMD_BCN_FILTER_OFFLOAD_P0 0x56 +@@ -806,6 +813,7 @@ void rtw_fw_c2h_cmd_rx_irqsafe(struct rt + void rtw_fw_c2h_cmd_handle(struct rtw_dev *rtwdev, struct sk_buff *skb); + void rtw_fw_send_general_info(struct rtw_dev *rtwdev); + void rtw_fw_send_phydm_info(struct rtw_dev *rtwdev); ++void rtw_fw_default_port(struct rtw_dev *rtwdev, struct rtw_vif *rtwvif); + + void rtw_fw_do_iqk(struct rtw_dev *rtwdev, struct rtw_iqk_para *para); + void rtw_fw_inform_rfk_status(struct rtw_dev *rtwdev, bool start); +--- a/drivers/net/wireless/realtek/rtw88/mac80211.c ++++ b/drivers/net/wireless/realtek/rtw88/mac80211.c +@@ -382,6 +382,7 @@ static void rtw_ops_bss_info_changed(str + + rtw_fw_download_rsvd_page(rtwdev); + rtw_send_rsvd_page_h2c(rtwdev); ++ rtw_fw_default_port(rtwdev, rtwvif); + rtw_coex_media_status_notify(rtwdev, vif->cfg.assoc); + if (rtw_bf_support) + rtw_bf_assoc(rtwdev, vif, conf); +--- a/drivers/net/wireless/realtek/rtw88/main.c ++++ b/drivers/net/wireless/realtek/rtw88/main.c +@@ -334,12 +334,15 @@ int rtw_sta_add(struct rtw_dev *rtwdev, + struct ieee80211_vif *vif) + { + struct rtw_sta_info *si = (struct rtw_sta_info *)sta->drv_priv; ++ struct rtw_vif *rtwvif = (struct rtw_vif *)vif->drv_priv; + int i; + + si->mac_id = rtw_acquire_macid(rtwdev); + if (si->mac_id >= RTW_MAX_MAC_ID_NUM) + return -ENOSPC; + ++ if (vif->type == NL80211_IFTYPE_STATION && vif->cfg.assoc == 0) ++ rtwvif->mac_id = si->mac_id; + si->rtwdev = rtwdev; + si->sta = sta; + si->vif = vif; +@@ -2340,6 +2343,9 @@ static void rtw_port_switch_iter(void *d + rtw_dbg(rtwdev, RTW_DBG_STATE, "AP port switch from %d -> %d\n", + rtwvif_ap->port, rtwvif_target->port); + ++ /* Leave LPS so the value swapped are not in PS mode */ ++ rtw_leave_lps(rtwdev); ++ + reg1 = &rtwvif_ap->conf->net_type; + reg2 = &rtwvif_target->conf->net_type; + rtw_swap_reg_mask(rtwdev, reg1, reg2); +@@ -2358,6 +2364,8 @@ static void rtw_port_switch_iter(void *d + + swap(rtwvif_target->port, rtwvif_ap->port); + swap(rtwvif_target->conf, rtwvif_ap->conf); ++ ++ rtw_fw_default_port(rtwdev, rtwvif_target); + } + + void rtw_core_port_switch(struct rtw_dev *rtwdev, struct ieee80211_vif *vif) +--- a/drivers/net/wireless/realtek/rtw88/main.h ++++ b/drivers/net/wireless/realtek/rtw88/main.h +@@ -803,6 +803,7 @@ struct rtw_bf_info { + struct rtw_vif { + enum rtw_net_type net_type; + u16 aid; ++ u8 mac_id; /* for STA mode only */ + u8 mac_addr[ETH_ALEN]; + u8 bssid[ETH_ALEN]; + u8 port;