wifi: rtw88: preparations for RTL8723B/RTL8723BS

From: Luka Gejak <[email protected]>

The RTL8723B is a 802.11n combo chip whose SDIO variant, RTL8723BS, runs a Realtek vendor firmware that differs from the firmware used by the other rtw88 8723 family devices. Supporting it needs a number of small adjustments spread across the shared core, all of which have to be restricted to this one chip and bus combination.

Add the chip type and a helper that tests for it, so the changes that follow can be gated without repeating the chip and bus comparison.

Signed-off-by Luka Gejak <[email protected]>

---
 drivers/net/wireless/realtek/rtw88/main.h | 7 +++++++
 1 file changed, 7 insertions(+)

drivers/net/wireless/realtek/rtw88/main.h +1 -0

index c6e981ba7986..8f86f7c12de5 100644
@@ -194,6 +194,7 @@ enum rtw_chip_type {
        RTW_CHIP_TYPE_8723D,
        RTW_CHIP_TYPE_8821C,
        RTW_CHIP_TYPE_8703B,
+       RTW_CHIP_TYPE_8723B,
        RTW_CHIP_TYPE_8821A,
        RTW_CHIP_TYPE_8812A,
        RTW_CHIP_TYPE_8814A,

drivers/net/wireless/realtek/rtw88/main.h +5 -1

+{
+       return rtwdev->chip->id == RTW_CHIP_TYPE_8723B &&
+              rtwdev->hci.type == RTW_HCI_TYPE_SDIO;
+}
+
 static inline u8 rtw_acquire_macid(struct rtw_dev *rtwdev)
 {
        unsigned long mac_id;
--

2.55.0

Quoted 1 line · [email protected] mailto:[email protected] <[email protected]> wrote:

Quoted 8 lines

From: Luka Gejak <[email protected]>

The RTL8723B is a 802.11n combo chip whose SDIO variant, RTL8723BS, runs a Realtek vendor firmware that differs from the firmware used by the other rtw88 8723 family devices. Supporting it needs a number of small adjustments spread across the shared core, all of which have to be restricted to this one chip and bus combination.

...

Hi everyone,
I apologize for the sudden silence. I have run into unexpected offline circumstances and will be completely away from my development setup for the next few weeks, due to family reasons.
I see all the review comments coming in and I appreciate the thorough feedback. I will address every single one of them and get v3 out as soon as I am back online.
Thank you for your patience!
Best regards,
Luka Gejak

Thank you for patiently waiting and sorry for the delay and hopefully there will be no such delays anymore.

Quoted 1 line

+static inline bool rtw_is_8723bs(struct rtw_dev *rtwdev)

As RTL8723B generation is very different from other chips, you need to add this to deliver different flow. I'd think if we need a set of ops to make code clearer.

it would be four callbacks (free page check, page accounting, output queue wait, transfer sizing) and I did not want to introduce that structure without asking first.

Quoted 3 lines · [email protected] <[email protected]> wrote:

it would be four callbacks (free page check, page accounting, output queue wait, transfer sizing) and I did not want to introduce that structure without asking first.

If these are called from sdio.c, just check chip ID in sdio.c.

If they are used by common flow like coex.c, I prefer to implement them by chip_ops.

Quoted 5 lines · Ping-Ke Shih

Quoted 3 lines · [email protected] <[email protected]> wrote:

it would be four callbacks (free page check, page accounting, output queue wait, transfer sizing) and I did not want to introduce that structure without asking first.

If these are called from sdio.c, just check chip ID in sdio.c.

That is what v3 already does, so nothing changes there. All four are reached from sdio.c only.

Quoted 2 lines

If they are used by common flow like coex.c, I prefer to implement them by chip_ops.

Let me list them all so you can rule on all of them at once rather than a file at a time.

Two go regardless of your answer: the chip test inside rtw8723bs_apply_basic_rates() and rtw8723bs_apply_bss_cap() is redundant, both callers already establish the chip. In the second one the NL80211_IFTYPE_STATION half of the same guard is still needed, so only the chip half goes there.

That leaves the following outside sdio.c.

coex.c, 2 sites:

rtw_coex_scan_notify() -> rtw_coex_8723bs_scan_notify()
rtw_coex_connect_notify() -> rtw_coex_8723bs_connect_notify()

Each tests the chip and bt_disabled once and returns true when it has handled the notification; everything below them assumes both.

mac80211.c, 6 sites in rtw_ops_bss_info_changed(): the receive filter

on assoc and on disassoc, BSSID change bookkeeping, and the BSS_CHANGED_ERP_PREAMBLE and BSS_CHANGED_ERP_SLOT handlers.

mac80211.c, 2 sites in rtw_ops_set_key(): enabling and disabling default key search for group keys.

rx.c, 1 site in rtw_rx_fill_rx_status(), the zero length packet test. This one runs per received frame, so an indirect call there looks like the wrong trade to me. I would keep it inline unless you disagree.

fw.c, 1 site in rtw_fw_write_data_rsvd_page(), two register save/restore blocks interleaved with the generic ones. I do not see how to lift those into an op without restructuring the whole function, so I would keep that inline too.

For coex.c and the two mac80211.c callbacks I am happy to add ops. One constraint on coex.c: the 8723BS code calls rtw_coex_set_ant_path() and rtw_coex_set_table(), which are static in coex.c. Implementing the ops in rtw8723b.c would mean making those two non-static, which seems worse than the chip test it replaces. What I had in mind is leaving the functions in coex.c, declaring them in coex.h, and having rtw8723b.c point the ops at them, the same shape as the chip_ops::prepare_tx that v3 adds for the association sequence. The generic helpers stay static that way.

Tell me which of those you want as ops and I will do it.

Quoted 26 lines · Luka Gejak

Quoted 5 lines · Ping-Ke Shih

Quoted 3 lines · [email protected] <[email protected]> wrote:

it would be four callbacks (free page check, page accounting, output queue wait, transfer sizing) and I did not want to introduce that structure without asking first.

If these are called from sdio.c, just check chip ID in sdio.c.

That is what v3 already does, so nothing changes there. All four are reached from sdio.c only.

Quoted 2 lines

If they are used by common flow like coex.c, I prefer to implement them by chip_ops.

Let me list them all so you can rule on all of them at once rather than a file at a time.

Two go regardless of your answer: the chip test inside rtw8723bs_apply_basic_rates() and rtw8723bs_apply_bss_cap() is redundant, both callers already establish the chip. In the second one the NL80211_IFTYPE_STATION half of the same guard is still needed, so only the chip half goes there.

That leaves the following outside sdio.c.

coex.c, 2 sites:

Quoted 7 lines

rtw_coex_scan_notify() -> rtw_coex_8723bs_scan_notify()
rtw_coex_connect_notify() -> rtw_coex_8723bs_connect_notify()

Each tests the chip and bt_disabled once and returns true when it has handled the notification; everything below them assumes both.

mac80211.c, 6 sites in rtw_ops_bss_info_changed(): the receive filter

Should receive filter implement in rtw_ops_configure_filter()?

Please check existing codes related to sec->default_key_search to see how to support RTL8723BS by the same flow.

I don't object this. More, I'm considering if no need to check chips, just be a common flow.

That looks fine. I remember I don't have comments on this part, no?

Did you mean callees of rtw_coex_8723bs_scan_workaround() ? I think you can go with your mind.

I'd say the version copy many stuffs from vendor driver. However, we should rewrite and consider the proper places, and if it is actually necessary. The vendor driver is based on cfg80211, and many stuffs have been done by mac80211, so we don't need to implement them in rtw88.

Quoted 1 line · Ping-Ke Shih

Should receive filter implement in rtw_ops_configure_filter()?

Moot now, the receive filter handling goes with the patch I am dropping. For the record you were pointing at something real, although not quite where I first placed it.

rtw8723b.c does seed hal.rcr in mac_init, so it is not the problem. The asymmetry is in rtw_ops_configure_filter() itself: entering promiscuous clears BIT_CBSSID_BCN and BIT_CBSSID_DATA together, but leaving it restores only BIT_CBSSID_BCN. CBSSID_DATA is therefore gone from hal.rcr for good after the first scan, on any chip, until the next mac_init. That is what the per-association forcing was compensating for.

There is a second one next to it: rtw8723x.c writes WLAN_RCR_CFG straight to REG_RCR in mac_init without putting it into hal.rcr, so on 8723D and 8703B the first configure_filter() call replaces it with the core default from rtw_core_init(), which carries neither CBSSID bit nor AMF.

Both look worth fixing on their own and I am happy to send that separately if you agree with the reading. It is unrelated to this series.

Happy to try that. Dropping the chip test would make the zero length check apply to every chip, so I would rather measure it on the 8703B path than assume; I do not have that hardware. If you are comfortable with it on inspection I will send it as a separate patch that removes the test entirely rather than fold it in here.

From: Luka Gejak <[email protected]>

Like the RTL8703B, the RTL8723BS reports receive descriptors with a zero packet length, which the vendor driver drops outright. rtw88 already flags these as having no PSDU for the RTL8703B, so extend the same handling rather than passing an empty frame up.

This is gated on the SDIO interface rather than the chip id, because it has only been observed there; the USB variant is not known to do it.

Signed-off-by Luka Gejak <[email protected]>

---
 drivers/net/wireless/realtek/rtw88/rx.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

drivers/net/wireless/realtek/rtw88/rx.c +0 -0

index 01fd299abb7f..5303975d00a2 100644
@@ -253,10 +253,12 @@ static void rtw_rx_fill_rx_status(struct rtw_dev *rtwdev,
 

drivers/net/wireless/realtek/rtw88/rx.c +1 -1

+           pkt_stat->pkt_len == 0) {
                rx_status->flag |= RX_FLAG_NO_PSDU;
                rtw_dbg(rtwdev, RTW_DBG_RX, "zero length packet");
        }
--

2.55.0

drivers/net/wireless/realtek/rtw88/rx.c static void rtw_rx_fill_rx_status(struct rtw_dev *rtwdev, · line 260

Quoted 2 lines

drivers/net/wireless/realtek/rtw88/rx.c +2 -0

+       if ((rtwdev->chip->id == RTW_CHIP_TYPE_8703B ||
+            rtw_is_8723bs(rtwdev)) &&

Straighten it. Though it is over 80 characters, but still acceptable.

drivers/net/wireless/realtek/rtw88/fw.c +8 -2

+
 int rtw_fw_write_data_rsvd_page(struct rtw_dev *rtwdev, u16 pg_addr,
                                u8 *buf, u32 size)
 {
-       u8 bckp[3];
+       const bool is_8723bs_sdio = rtw_is_8723bs(rtwdev);
+       u8 bckp[4];
        u8 val;
        u16 rsvd_pg_head;
        u32 bcn_valid_addr;

@@ -1510,13 +1514,28 @@ int rtw_fw_write_data_rsvd_page(struct rtw_dev *rtwdev, u16 pg_addr,
        rtw_write8(rtwdev, REG_BCN_CTRL,
                   (bckp[2] & ~BIT_EN_BCN_FUNCTION) | BIT_DIS_TSF_UDT);
 
-       if (rtw_hci_type(rtwdev) == RTW_HCI_TYPE_PCIE) {
+       /* Clear BIT_EN_BCNQ_DL so the chip does not treat the reserved-page
+        * upload as a real beacon; otherwise BIT_BCN_VALID never asserts. The
+        * vendor rtl8723bs driver does this unconditionally; rtw88 only did it
+        * for PCIe, which left 8723BS SDIO's BCN_VALID handshake failing.
+        */

drivers/net/wireless/realtek/rtw88/fw.c +3 -0

+               rtw_write8(rtwdev, REG_DWBCN1_CTRL + 2, val);
+       }
+
        ret = rtw_hci_write_data_rsvd_page(rtwdev, buf, size);
        if (ret) {
                rtw_err(rtwdev, "failed to write data to rsvd page\n");

drivers/net/wireless/realtek/rtw88/fw.c void rtw_add_rsvd_page_sta(struct rtw_dev *rtwdev, · line 1481

Quoted 2 lines

drivers/net/wireless/realtek/rtw88/fw.c +2 -0

+/* REG_DWBCN1_CTRL bit 20 (SW_BCN_SEL for port 0), relative to byte +2 */
+#define BIT_OFFSET_DWBCN1_SW_BCN_SEL_PORT0     (20 - 16)

define along its register REG_DWBCN1_CTRL

Currently, not use networking specific comment style anymore

/*
* first line
* second
*/

From: Luka Gejak <[email protected]>

On the RTL8723BS the PTA antenna path has to be programmed directly during scan. The vendor driver keeps its own scan-time antenna state and does not run the generic coexistence algorithm on boards where BT is disabled, and following it is necessary here: without the antenna and CCK priority setup applied at scan start, the site survey does not hear the AP reliably.

Detect the BT-disabled case, replay the vendor BT_MP and BT_INFO queries once the firmware has been up long enough for RX DMA to be stable, then establish the scan path antenna configuration and skip the generic run.

Signed-off-by Luka Gejak <[email protected]>

---
 drivers/net/wireless/realtek/rtw88/coex.c | 179 +++++++++++++++++++++-
 drivers/net/wireless/realtek/rtw88/coex.h |   2 +
 drivers/net/wireless/realtek/rtw88/reg.h  |   1 +
 3 files changed, 181 insertions(+), 1 deletion(-)

drivers/net/wireless/realtek/rtw88/coex.c +0 -0

index 37c336def419..daba6082f850 100644

drivers/net/wireless/realtek/rtw88/coex.c +9 -0

+
+static bool rtw_coex_8723bs_ant_is_aux(struct rtw_dev *rtwdev)
+{
+       return !!(rtwdev->efuse.bt_setting & BIT(6));
+}
+
+static bool rtw_coex_8723bs_bt_disabled(struct rtw_dev *rtwdev)
+{
+       return rtw_is_8723bs(rtwdev) && rtwdev->coex.stat.bt_disabled;

drivers/net/wireless/realtek/rtw88/coex.c +9 -0

+               usleep_range(10, 11);
+       }
+
+       rtw_write32(rtwdev, REG_BB_SEL_BTG_8723B, value);
+       readback = rtw_read32(rtwdev, REG_BB_SEL_BTG_8723B);
+       if (readback == value)
+               return readback;
+
+       usleep_range(10, 11);

drivers/net/wireless/realtek/rtw88/coex.c +24 -0

+}
+
+static void rtw_coex_8723bs_set_cck_pri(struct rtw_dev *rtwdev, bool high)
+{
+       if (!rtw_coex_8723bs_bt_disabled(rtwdev))
+               return;
+
+       if (high) {
+               rtw_write32(rtwdev, REG_BT_COEX_TABLE_H,
+                           RTW8723BS_COEX_H_WLAN_ACTIVE);
+       } else {
+               rtw_coex_set_wl_pri_mask(rtwdev, COEX_WLPRI_TX_CCK, false);
+               rtw_coex_set_wl_pri_mask(rtwdev, COEX_WLPRI_RX_CCK, false);
+       }
+}
+
+static void rtw_coex_8723bs_restore_pad_ctrl(struct rtw_dev *rtwdev,
+                                            bool keep_pta_owner)
+{
+       u32 before, after;
+
+       before = rtw_read32(rtwdev, REG_PAD_CTRL1);
+       after = before & ~(BIT_LNAON_WLBT_SEL | BIT_SW_DPDT_SEL_DATA);
+       if (keep_pta_owner)

drivers/net/wireless/realtek/rtw88/coex.c +5 -0

+               return;
+
+       if (rtw_read8(rtwdev, REG_GNT_BT) == 0x00 &&
+           rtw_read8(rtwdev, REG_BT_COEX_ENH_INTR_CTRL) == 0x0c)
+               return;

drivers/net/wireless/realtek/rtw88/coex.c +15 -0

+               rtw_write8_set(rtwdev, REG_SYS_FUNC_EN, BIT(0) | BIT(1));
+               usleep_range(10, 11);
+       }
+
+       rtw_write8_mask(rtwdev, REG_8723BS_BT_COEX_CTRL, BIT(3), 0x1);
+       rtw_write8(rtwdev, REG_8723BS_BB_ANT_BUF, 0xff);
+       rtw_write8_mask(rtwdev, REG_8723BS_BB_ANT_CFG1, 0x3, 0x3);
+       rtw_write8(rtwdev, REG_8723BS_BB_ANT_CFG, 0x77);
+}
+
+static void rtw_coex_8723bs_apply_scan_table(struct rtw_dev *rtwdev)
+{
+       rtwdev->coex.dm.cur_table = 2;
+       rtw_coex_set_table(rtwdev, true, 0x5a5a5a5a, 0x5a5a5a5a);
+}

drivers/net/wireless/realtek/rtw88/coex.c +6 -0

+               return;
+
+       coex_dm->cur_ps_tdma_on = false;
+       coex_dm->cur_ps_tdma = 8;
+       coex_dm->ps_tdma_para[0] = 0x08;
+       coex_dm->ps_tdma_para[1] = 0x00;

drivers/net/wireless/realtek/rtw88/coex.c +11 -1

+}
+
 static const char *rtw_coex_get_algo_string(u8 algo)
 {
        switch (algo) {

@@ -2770,7 +2920,7 @@ void rtw_coex_power_on_setting(struct rtw_dev *rtwdev)
        coex->stop_dm = true;
        coex->wl_rf_off = false;
 
-       /* enable BB, we can write 0x948 */
+       /* enable BB, so BB_SEL_BTG is writable */
        rtw_write8_set(rtwdev, REG_SYS_FUNC_EN,
                       BIT_FEN_BB_GLB_RST | BIT_FEN_BB_RSTB);
 

@@ -2877,6 +3027,33 @@ void rtw_coex_scan_notify(struct rtw_dev *rtwdev, u8 type)
        coex->freeze = false;
        rtw_coex_write_scbd(rtwdev, COEX_SCBD_ACTIVE | COEX_SCBD_ONOFF, true);
 
+       /* 8723BS SDIO BT-disabled: keep the scan/auth PTA antenna state the
+        * vendor uses and skip the generic coex run. At scan start (firmware
+        * has been up long enough for stable RX DMA) replay the vendor BT_MP /
+        * BT_INFO queries, then re-establish the scan-path PTA setup.
+        */
+       if (rtw_coex_8723bs_bt_disabled(rtwdev)) {
+               if (type == COEX_SCAN_START_2G || type == COEX_SCAN_START) {
+                       struct rtw_coex_info_req req = {};

drivers/net/wireless/realtek/rtw88/coex.c +2 -0

+       }
+
        if (type == COEX_SCAN_START_5G) {
                rtw_dbg(rtwdev, RTW_DBG_COEX,
                        "[BTCoex], SCAN START notify (5G)\n");

drivers/net/wireless/realtek/rtw88/coex.h +0 -0

index c398be8391f7..72b1353c9313 100644

drivers/net/wireless/realtek/rtw88/coex.h +0 -0

 #endif

Quoted 1 line

+/* 8723BS SDIO WiFi/BT coexistence antenna handling. On BT-disabled boards the

comment style.

drivers/net/wireless/realtek/rtw88/coex.c static void rtw_coex_set_ant_path(struct rtw_dev *rtwdev, bool force, u8 phase) · line 1454

Quoted 5 lines

drivers/net/wireless/realtek/rtw88/coex.c +5 -0

+#define REG_8723BS_BT_COEX_CTRL                0x0039
+#define REG_8723BS_BB_ANT_CFG          0x0930
+#define REG_8723BS_BB_ANT_CFG1         0x0944
+#define REG_8723BS_BB_ANT_BUF          0x0974
+#define RTW8723BS_COEX_H_WLAN_ACTIVE   0x1800101b

define these in reg.h

Quoted 1 line

+/* Write BB_SEL_BTG, retrying once with SYS_FUNC BB reset if the first

With the given name, this comment seems not necessary.

Review

Quoted 2 lines

(quoted diff) +2 -0

+       if ((sys_func_before & (BIT(0) | BIT(1))) != (BIT(0) | BIT(1)))
+               rtw_write8_set(rtwdev, REG_SYS_FUNC_EN, BIT(0) | BIT(1));

Use given names for BIT 0/1.

Quoted 1 line

+static u32 rtw_coex_8723bs_reassert_pta_ant(struct rtw_dev *rtwdev)

Just call rtw_coex_8723bs_write_bb_sel_btg() ?

drivers/net/wireless/realtek/rtw88/coex.c static void rtw_coex_set_ant_path(struct rtw_dev *rtwdev, bool force, u8 phase) · line 1534

Quoted 3 lines

drivers/net/wireless/realtek/rtw88/coex.c +3 -0

+static void rtw_coex_8723bs_fw_gnt_bt_low(struct rtw_dev *rtwdev)
+{
+       if (!rtw_coex_8723bs_bt_disabled(rtwdev))

Please review your calling path. I think callers should ensure RTL8723BS before calling. (But here needs additional condition bt_disabled though)

Quoted 1 line

+ if (!rtw_is_8723bs(rtwdev))

Caller check this already.

Quoted 1 line

+ if (coex_stat->bt_disabled)

It looks like callers check this already.

I wonder how you can make this workaround? There are so many arguments.

drivers/net/wireless/realtek/rtw88/coex.c void rtw_coex_scan_notify(struct rtw_dev *rtwdev, u8 type) · line 3047

Quoted 4 lines

drivers/net/wireless/realtek/rtw88/coex.c +4 -0

+                       req.op_code = BT_MP_INFO_OP_SUPP_VER;
+                       rtw_fw_query_bt_mp_info(rtwdev, &req);
+                       req.op_code = BT_MP_INFO_OP_PATCH_VER;
+                       rtw_fw_query_bt_mp_info(rtwdev, &req);

These two are debug purpose. When you cat debugfs, it will try to query the version, won't it?

Quoted 1 line

+ rtw_fw_query_bt_info(rtwdev);

It seems to be called at initial. Is it necessary?

Since RTL8723BS does special handle, just move all into a function, but put in common flow.

Quoted 1 line

+void rtw_coex_8723bs_scan_workaround(struct rtw_dev *rtwdev);

Just static no need to export.

+/* Replayed immediately before start_clnt_join()/auth: BT_INFO + PS-TDMA type 8
+ * then the forced WiFi PTA antenna path, so the auth window is clean.
+ */

drivers/net/wireless/realtek/rtw88/coex.c +26 -0

+void rtw_coex_8723bs_pre_auth_h2c(struct rtw_dev *rtwdev)
+{
+       lockdep_assert_held(&rtwdev->mutex);
+
+       if (!rtw_coex_8723bs_bt_disabled(rtwdev))
+               return;
+
+       rtw_fw_query_bt_info(rtwdev);
+       rtw_fw_coex_tdma_type(rtwdev, 0x08, 0x00, 0x00, 0x00, 0x00);
+       rtw_fw_coex_tdma_type(rtwdev, 0x08, 0x00, 0x00, 0x00, 0x00);
+       rtw_fw_coex_tdma_type(rtwdev, 0x08, 0x00, 0x00, 0x00, 0x00);
+       rtw_coex_8723bs_fw_gnt_bt_low(rtwdev);
+       rtw_coex_8723bs_force_assoc_pta_ant(rtwdev);
+}
+
 static const char *rtw_coex_get_algo_string(u8 algo)
 {
        switch (algo) {

@@ -3115,6 +3150,17 @@ void rtw_coex_connect_notify(struct rtw_dev *rtwdev, u8 type)
        if (coex->manual_control || coex->stop_dm)
                return;
 
+       /* 8723BS SDIO BT-disabled: the vendor ConnectNotify() early-returns
+        * without sending H2Cs; scan_workaround already established the PTA
+        * path / coex table / PS-TDMA. Keep only the register-level PTA
+        * reassertion at associate-start.
+        */
+       if (rtw_coex_8723bs_bt_disabled(rtwdev)) {
+               if (type == COEX_ASSOCIATE_START)
+                       rtw_coex_8723bs_force_assoc_pta_ant(rtwdev);
+               return;
+       }
+
        rtw_coex_write_scbd(rtwdev, COEX_SCBD_ACTIVE | COEX_SCBD_ONOFF, true);
 
        if (type == COEX_ASSOCIATE_5G_START) {

Quoted 3 lines

+/* Replayed immediately before start_clnt_join()/auth: BT_INFO + PS-TDMA type 8
+ * then the forced WiFi PTA antenna path, so the auth window is clean.
+ */

Comment style.

From: Luka Gejak <[email protected]>

The RTL8723BS reports free TX page counts that the generic 8051 path reads back from the chip on every transfer, which is both slow over SDIO and unreliable on this part: the register frequently reads back zero while pages are in fact available. It also gates transmission on an output queue token count that rtw88 does not track at all.

Mirror the vendor driver and keep the per-queue and public page counts in software, seeded at start and resynchronised from the chip only when the cached counts say there is not enough room. Wait for an OQT credit

before writing, and account for the pages consumed after a successful transfer.

Transfers also have to be padded up to the SDIO block size for this chip rather than using the generic alignment, so size the write separately from the frame and trim the skb back afterwards.

Signed-off-by Luka Gejak <[email protected]>

---
 drivers/net/wireless/realtek/rtw88/sdio.c | 220 ++++++++++++++++++++--
 drivers/net/wireless/realtek/rtw88/sdio.h |   6 +
 2 files changed, 215 insertions(+), 11 deletions(-)

drivers/net/wireless/realtek/rtw88/sdio.c +1 -0

index 5b40d74b16ee..adf0b509e2cc 100644
@@ -20,6 +20,7 @@
 #include "tx.h"
 
 #define RTW_SDIO_INDIRECT_RW_RETRIES                   50
+#define RTW_SDIO_OQT_TIMEOUT_MS                                1000
 
 static bool rtw_sdio_is_bus_addr(u32 addr)
 {

drivers/net/wireless/realtek/rtw88/sdio.c +20 -0

+{
+       struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv;
+       const struct rtw_page_table *pg_tbl;
+       u32 free_txpg;
+       u16 pubq_num;
+
+       if (!rtw_is_8723bs(rtwdev))
+               return;
+
+       pg_tbl = &rtwdev->chip->page_table[0];
+       pubq_num = rtwdev->fifo.acq_pg_num - pg_tbl->hq_num - pg_tbl->lq_num -
+                  pg_tbl->nq_num - pg_tbl->exq_num - pg_tbl->gapq_num;
+       free_txpg = rtw_read32(rtwdev, REG_SDIO_FREE_TXPG);
+       if (free_txpg) {
+               atomic_set(&rtwsdio->free_pg_high, free_txpg & 0xff);
+               atomic_set(&rtwsdio->free_pg_normal, (free_txpg >> 8) & 0xff);
+               atomic_set(&rtwsdio->free_pg_low, (free_txpg >> 16) & 0xff);
+               atomic_set(&rtwsdio->free_pg_pub, (free_txpg >> 24) & 0xff);
+       } else {
+               atomic_set(&rtwsdio->free_pg_high, pg_tbl->hq_num);

drivers/net/wireless/realtek/rtw88/sdio.c +26 -1

+}
+
+static int rtw_sdio_8723bs_free_txpg(struct rtw_dev *rtwdev, u8 queue)
+{
+       struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv;
+
+       switch (queue) {
+       case RTW_TX_QUEUE_BCN:
+       case RTW_TX_QUEUE_H2C:
+       case RTW_TX_QUEUE_HI0:
+       case RTW_TX_QUEUE_MGMT:
+       case RTW_TX_QUEUE_VO:
+               return atomic_read(&rtwsdio->free_pg_high);
+       case RTW_TX_QUEUE_VI:
+               return atomic_read(&rtwsdio->free_pg_normal);
+       case RTW_TX_QUEUE_BE:
+       case RTW_TX_QUEUE_BK:
+               return atomic_read(&rtwsdio->free_pg_low);
+       default:
+               return -EINVAL;
+       }
+}
+
 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_8051(rtwdev)) {
+       if (rtw_is_8723bs(rtwdev)) {
+               struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv;
+               int dedicated = rtw_sdio_8723bs_free_txpg(rtwdev, queue);

drivers/net/wireless/realtek/rtw88/sdio.c +51 -0

+               pages_free = dedicated + atomic_read(&rtwsdio->free_pg_pub);
+       } else if (rtw_chip_wcpu_8051(rtwdev)) {
                u32 free_txpg;
 
                free_txpg = rtw_sdio_read32(rtwdev, REG_SDIO_FREE_TXPG);

@@ -632,44 +712,131 @@ static int rtw_sdio_check_free_txpg(struct rtw_dev *rtwdev, u8 queue,
        return 0;
 }
 
+static int rtw_sdio_wait_tx_oqt(struct rtw_dev *rtwdev)
+{
+       struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv;
+       int i;
+       u8 free;
+
+       if (!rtw_is_8723bs(rtwdev))
+               return 0;
+
+       if (atomic_add_unless(&rtwsdio->tx_oqt_free, -1, 0))
+               return 0;
+
+       for (i = 0; i < RTW_SDIO_OQT_TIMEOUT_MS; i++) {
+               free = rtw_read8(rtwdev, REG_SDIO_OQT_FREE_PG);
+               if (free) {
+                       atomic_set(&rtwsdio->tx_oqt_free, free - 1);
+                       return 0;
+               }
+               usleep_range(1000, 2000);
+       }
+
+       return -EBUSY;
+}
+
+static void rtw_sdio_8723bs_consume_txpg(struct rtw_dev *rtwdev, u8 queue,
+                                        unsigned int pages)
+{
+       struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv;
+       atomic_t *dedicated;
+       int free;
+
+       switch (queue) {
+       case RTW_TX_QUEUE_VI:
+               dedicated = &rtwsdio->free_pg_normal;
+               break;
+       case RTW_TX_QUEUE_BE:
+       case RTW_TX_QUEUE_BK:
+               dedicated = &rtwsdio->free_pg_low;
+               break;
+       default:
+               dedicated = &rtwsdio->free_pg_high;
+               break;
+       }
+
+       free = atomic_read(dedicated);
+       if (pages <= free) {
+               atomic_sub(pages, dedicated);
+       } else {
+               atomic_set(dedicated, 0);

drivers/net/wireless/realtek/rtw88/sdio.c +32 -8

+       unsigned int pages;
        bool bus_claim;
        size_t txsize;
+       size_t write_size;
        u32 txaddr;
        int ret;
 
-       txaddr = rtw_sdio_get_tx_addr(rtwdev, skb->len, queue);
-       if (!txaddr)
-               return -EINVAL;
+       if (rtl8723bs) {
+               txsize = round_up(orig_len, 4);
+               write_size = txsize > RTW_SDIO_BLOCK_SIZE ?
+                            round_up(txsize, RTW_SDIO_BLOCK_SIZE) : txsize;
+       } else {
+               txsize = sdio_align_size(rtwsdio->sdio_func, orig_len);
+               write_size = txsize;
+       }
+
+       if (write_size > orig_len) {
+               unsigned int padding = write_size - orig_len;
+
+               if (skb_tailroom(skb) < padding) {
+                       ret = pskb_expand_head(skb, 0,
+                                              padding - skb_tailroom(skb),
+                                              GFP_KERNEL);
+                       if (ret)
+                               return ret;
+               }
+               skb_put_zero(skb, padding);
+       }
 
-       txsize = sdio_align_size(rtwsdio->sdio_func, skb->len);
+       txaddr = rtw_sdio_get_tx_addr(rtwdev, txsize, queue);
+       if (!txaddr) {
+               ret = -EINVAL;
+               goto out_trim;
+       }
 
        ret = rtw_sdio_check_free_txpg(rtwdev, queue, txsize);
        if (ret)
-               return ret;
+               goto out_trim;
+       ret = rtw_sdio_wait_tx_oqt(rtwdev);
+       if (ret)
+               goto out_trim;
 
        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);

drivers/net/wireless/realtek/rtw88/sdio.c +12 -0

+out_trim:
+       if (write_size > orig_len)
+               skb_trim(skb, orig_len);
        return ret;
 }
 

@@ -749,8 +916,39 @@ static int rtw_sdio_setup(struct rtw_dev *rtwdev)
        return 0;
 }
 
+static void rtw_sdio_8723bs_check_rqpn(struct rtw_dev *rtwdev)
+{
+       const struct rtw_chip_info *chip = rtwdev->chip;
+       struct rtw_fifo_conf *fifo = &rtwdev->fifo;
+       const struct rtw_page_table *pg_tbl;
+       u32 free_txpg;
+       u16 pubq_num;
+
+       if (!rtw_is_8723bs(rtwdev))

drivers/net/wireless/realtek/rtw88/sdio.c +0 -0

        rtw_sdio_enable_rx_aggregation(rtwdev);
        rtw_sdio_enable_interrupt(rtwdev);
 

drivers/net/wireless/realtek/rtw88/sdio.h +0 -0

index 457e8b02380e..12086f1aa280 100644

drivers/net/wireless/realtek/rtw88/sdio.h +0 -1

 };
 
 extern const struct dev_pm_ops rtw_sdio_pm_ops;
--

2.55.0

Quoted 1 line

output queue token count that rtw88 does not track at all.

Does OQT mean Output Queue Token? Could you explain a little bit?

I think this can largely improve SDIO. Please share the performance numbers before/after this patch.

drivers/net/wireless/realtek/rtw88/sdio.c static int rtw_sdio_read_port(struct rtw_dev *rtwdev, u8 *buf, size_t count) · line 582

Quoted 2 lines

drivers/net/wireless/realtek/rtw88/sdio.c +2 -0

+static void rtw_sdio_init_free_txpg(struct rtw_dev *rtwdev)
+static void rtw_sdio_sync_free_txpg(struct rtw_dev *rtwdev)

_8723bs_ specific so add to the function name

It is clear that bit masks of REG_SDIO_FREE_TXPG are PG_{HIGH, NORMAL, LOW, PUB}. Let's define them in reg.h, and use u32_get_bits() to read out the values.

Quoted 1 line

+ dedicated = rtw_sdio_8723bs_free_txpg(rtwdev, queue);

Why do you check dedicated < 0 for this case?

Quoted 1 line

+ bool rtl8723bs = rtw_is_8723bs(rtwdev);

reverse X'mas tree

Quoted 1 line

+ if (!ret && rtl8723bs) {

move to else-branch below?

Quoted 1 line

+ if (fifo->acq_pg_num <= pg_tbl->hq_num + pg_tbl->lq_num +

second and third lines don't align.

Quoted 1 line

+ rtw_sdio_8723bs_check_rqpn(rtwdev);

Should we check chip is RTL8723BS before calling? I'd have consistent the calling rule -- callers check?

Quoted 1 line

+ atomic_t free_pg_high;

Could I know the reason why these should be atomic_t? Which context are they running?

From: Luka Gejak <[email protected]>

Enable the existing RX aggregation setup for this chip and select the larger DMA aggregation mode it needs. The RTL8723BS does not raise CPWM1, so leave that source out of its interrupt mask, and set the SDIO TX control bit the vendor driver uses to have transfers always recognised.

The chip also keeps raising the interrupt after resume if undefined status bits are written back when acknowledging, so acknowledge only the defined and unmasked bits. That is scoped to this chip; the other SDIO parts keep writing the status word back unchanged.

Signed-off-by Luka Gejak <[email protected]>

---
 drivers/net/wireless/realtek/rtw88/sdio.c | 28 ++++++++++++++++++++++-
 drivers/net/wireless/realtek/rtw88/sdio.h |  9 ++++++++
 2 files changed, 36 insertions(+), 1 deletion(-)

drivers/net/wireless/realtek/rtw88/sdio.c +0 -0

index adf0b509e2cc..37d1d58fa55e 100644

drivers/net/wireless/realtek/rtw88/sdio.c +1 -0

 }
 
 static void rtw_sdio_enable_rx_aggregation(struct rtw_dev *rtwdev)

@@ -852,6 +856,7 @@ static void rtw_sdio_enable_rx_aggregation(struct rtw_dev *rtwdev)
        u8 size, timeout;
 
        switch (rtwdev->chip->id) {
+       case RTW_CHIP_TYPE_8723B:
        case RTW_CHIP_TYPE_8703B:
        case RTW_CHIP_TYPE_8821A:
        case RTW_CHIP_TYPE_8812A:

drivers/net/wireless/realtek/rtw88/sdio.c +12 -0

 }
 
 static void rtw_sdio_enable_interrupt(struct rtw_dev *rtwdev)

@@ -947,9 +954,19 @@ static void rtw_sdio_8723bs_check_rqpn(struct rtw_dev *rtwdev)
 
 static int rtw_sdio_start(struct rtw_dev *rtwdev)
 {
+       u32 clear;
+
        rtw_sdio_8723bs_check_rqpn(rtwdev);
        rtw_sdio_init_free_txpg(rtwdev);
        rtw_sdio_enable_rx_aggregation(rtwdev);
+
+       if (rtw_is_8723bs(rtwdev)) {
+               clear = rtw_read32(rtwdev, REG_SDIO_HISR) &
+                       RTW_SDIO_HISR_CLEAR_MASK;
+               if (clear)
+                       rtw_write32(rtwdev, REG_SDIO_HISR, clear);
+       }
+
        rtw_sdio_enable_interrupt(rtwdev);
 
        return 0;

@@ -1029,6 +1046,8 @@ static void rtw_sdio_interface_cfg(struct rtw_dev *rtwdev)
 
        val = rtw_read32(rtwdev, REG_SDIO_TX_CTRL);
        val &= 0xfff8;
+       if (rtw_is_8723bs(rtwdev))
+               val |= BIT_SDIO_TX_CTRL_ALWAYS_RECOGNIZE;
        rtw_write32(rtwdev, REG_SDIO_TX_CTRL, val);
 }
 

drivers/net/wireless/realtek/rtw88/sdio.c +3 -0

+       if (rtw_is_8723bs(rtwdev))
+               hisr &= rtwsdio->irq_mask & RTW_SDIO_HISR_CLEAR_MASK;
+
        rtw_write32(rtwdev, REG_SDIO_HISR, hisr);
 
        rtwsdio->irq_thread = NULL;

drivers/net/wireless/realtek/rtw88/sdio.c static void rtw_sdio_init(struct rtw_dev *rtwdev) · line 851

Quoted 2 lines

drivers/net/wireless/realtek/rtw88/sdio.c +2 -0

+               rtwsdio->irq_mask = REG_SDIO_HIMR_RX_REQUEST |
+                                      REG_SDIO_HIMR_CPWM1;

align the REG_*

drivers/net/wireless/realtek/rtw88/sdio.c static void rtw_sdio_enable_rx_aggregation(struct rtw_dev *rtwdev) · line 888

Quoted 2 lines

drivers/net/wireless/realtek/rtw88/sdio.c +2 -0

+       if (rtw_is_8723bs(rtwdev))
+               rtw_write8_set(rtwdev, REG_RXDMA_MODE, 3 << 2);

I think you are setting burst count? rtw_write8_mask()?

#define BIT_DMA_BURST_CNT GENMASK(3, 2)

Quoted 1 line

+ /* RTL8723BS keeps raising the interrupt after resume if undefined

comment style

From: Luka Gejak <[email protected]>

Two problems show up on RTL8723BS uplink. The per-AC software FIFO is unbounded, so mac80211 keeps handing frames down until latency collapses under load. And when the chip runs out of free TX pages the queue is simply abandoned for that pass, which stalls the AC until something else kicks the worker.

Stop the mac80211 queue once a data AC fills past a high watermark and wake it from the drain path when it falls back to a low one. Convert the TX work item to a delayed work so a temporary page shortage can be retried shortly afterwards instead of stalling, and cancel it on teardown.

Measured on RTL8723BS hardware, uplink goes from 11.9 Mbit/s with 204 TCP retransmits to 20.1 Mbit/s with 2.

Signed-off-by Luka Gejak <[email protected]>

---
 drivers/net/wireless/realtek/rtw88/sdio.c | 75 ++++++++++++++++++++---
 drivers/net/wireless/realtek/rtw88/sdio.h |  3 +-
 2 files changed, 68 insertions(+), 10 deletions(-)

drivers/net/wireless/realtek/rtw88/sdio.c +0 -0

index 37d1d58fa55e..572b791249ed 100644

drivers/net/wireless/realtek/rtw88/sdio.c +17 -2

 }
 
 static void rtw_sdio_link_ps(struct rtw_dev *rtwdev, bool enter)

@@ -1154,6 +1163,18 @@ static int rtw_sdio_tx_write(struct rtw_dev *rtwdev,
 
        skb_queue_tail(&rtwsdio->tx_queue[queue], skb);
 
+       /* Back-pressure on the data ACs (BK/BE/VI/VO): once the FIFO fills past
+        * the high watermark, stop the corresponding mac80211 queue so it stops
+        * handing us frames, bounding the queueing latency. Resumed from the TX
+        * drain path once the FIFO drains below the low watermark.
+        */
+       if (rtw_is_8723bs(rtwdev) && queue < RTW_TX_QUEUE_BCN &&
+           !rtwsdio->queue_stopped[queue] &&
+           skb_queue_len(&rtwsdio->tx_queue[queue]) >= RTW_SDIO_TX_FIFO_HIWATER) {
+               rtwsdio->queue_stopped[queue] = true;
+               ieee80211_stop_queue(rtwdev->hw, skb_get_queue_mapping(skb));
+       }
+
        return 0;
 }
 

@@ -1455,32 +1476,48 @@ static void rtw_sdio_indicate_tx_status(struct rtw_dev *rtwdev,
        ieee80211_tx_status_irqsafe(hw, skb);
 }
 
-static void rtw_sdio_process_tx_queue(struct rtw_dev *rtwdev,
-                                     enum rtw_tx_queue_type queue)
+static int rtw_sdio_process_tx_queue(struct rtw_dev *rtwdev,
+                                    enum rtw_tx_queue_type queue,
+                                    bool *processed)
 {
        struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv;
        struct sk_buff *skb;
+       u16 q_map;
        int ret;
 
+       *processed = false;

drivers/net/wireless/realtek/rtw88/sdio.c +21 -3

-               return;
+               return ret;
        }
 
        rtw_sdio_indicate_tx_status(rtwdev, skb);
+
+       if (rtw_is_8723bs(rtwdev) && queue < RTW_TX_QUEUE_BCN &&
+           rtwsdio->queue_stopped[queue] &&
+           skb_queue_len(&rtwsdio->tx_queue[queue]) <= RTW_SDIO_TX_FIFO_LOWATER) {
+               rtwsdio->queue_stopped[queue] = false;
+               ieee80211_wake_queue(rtwdev->hw, q_map);
+       }
+
+       return 0;
 }
 
 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);
+               container_of(to_delayed_work(work), struct rtw_sdio_work_data,
+                            work);
        struct rtw_sdio *rtwsdio;
        struct rtw_dev *rtwdev;
+       bool processed;
        int limit, queue;
 
        rtwdev = work_data->rtwdev;

@@ -1491,7 +1528,24 @@ static void rtw_sdio_tx_handler(struct work_struct *work)
 
        for (queue = RTK_MAX_TX_QUEUE_NUM - 1; queue >= 0; queue--) {
                for (limit = 0; limit < 1000; limit++) {
-                       rtw_sdio_process_tx_queue(rtwdev, queue);
+                       int ret;
+
+                       ret = rtw_sdio_process_tx_queue(rtwdev, queue, &processed);
+                       if (ret) {
+                               if (rtw_is_8723bs(rtwdev) && ret == -EBUSY) {
+                                       mod_delayed_work(rtwsdio->txwq,
+                                                        &work_data->work,
+                                                        RTW_SDIO_TX_RETRY_DELAY);

drivers/net/wireless/realtek/rtw88/sdio.c +5 -2

                        if (skb_queue_empty(&rtwsdio->tx_queue[queue]))
                                break;

@@ -1518,14 +1572,16 @@ static int rtw_sdio_init_tx(struct rtw_dev *rtwdev)
                return -ENOMEM;
        }
 
-       for (i = 0; i < RTK_MAX_TX_QUEUE_NUM; i++)
+       for (i = 0; i < RTK_MAX_TX_QUEUE_NUM; i++) {
                skb_queue_head_init(&rtwsdio->tx_queue[i]);
+               rtwsdio->queue_stopped[i] = false;
+       }
        rtwsdio->tx_handler_data = kmalloc_obj(*rtwsdio->tx_handler_data);
        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);
+       INIT_DELAYED_WORK(&rtwsdio->tx_handler_data->work, rtw_sdio_tx_handler);
 
        return 0;
 

@@ -1539,6 +1595,7 @@ static void rtw_sdio_deinit_tx(struct rtw_dev *rtwdev)
        struct rtw_sdio *rtwsdio = (struct rtw_sdio *)rtwdev->priv;
        int i;
 
+       cancel_delayed_work_sync(&rtwsdio->tx_handler_data->work);
        destroy_workqueue(rtwsdio->txwq);
        kfree(rtwsdio->tx_handler_data);
 

drivers/net/wireless/realtek/rtw88/sdio.h +2 -2

index 541d4302ec6b..f1f59f8301b8 100644
@@ -152,7 +152,7 @@ struct rtw_sdio_tx_data {
 };
 
 struct rtw_sdio_work_data {
-       struct work_struct work;
+       struct delayed_work work;
        struct rtw_dev *rtwdev;
 };
 

@@ -168,6 +168,7 @@ struct rtw_sdio {
        struct workqueue_struct *txwq;
        struct rtw_sdio_work_data *tx_handler_data;
        struct sk_buff_head tx_queue[RTK_MAX_TX_QUEUE_NUM];
+       bool queue_stopped[RTK_MAX_TX_QUEUE_NUM];
 
        atomic_t free_pg_high;
        atomic_t free_pg_normal;
--

2.55.0

Quoted 1 line

+/* 8723BS SDIO TX FIFO back-pressure watermarks: stop the mac80211 queue once

comment style.

Review

Quoted 3 lines

(quoted diff) +2 -1

-       queue_work(rtwsdio->txwq, &rtwsdio->tx_handler_data->work);
+       mod_delayed_work(rtwsdio->txwq,
+                        &rtwsdio->tx_handler_data->work, 0);

queue_delayed_work()?

Quoted 2 lines

        if (ret) {
                skb_queue_head(&rtwsdio->tx_queue[queue], skb);

This case is also processed = true?

Can you cleanup the handlers of return value and processed? The logic isn't clear to me.

Quoted 5 lines · Ping-Ke Shih

Review

Quoted 3 lines

(quoted diff) +2 -1

-       queue_work(rtwsdio->txwq, &rtwsdio->tx_handler_data->work);
+       mod_delayed_work(rtwsdio->txwq,
+                        &rtwsdio->tx_handler_data->work, 0);

queue_delayed_work()?

Changed inside the TX handler, where the work is not pending and queue_delayed_work() is the right call.

I kept mod_delayed_work() in rtw_sdio_tx_kick_off() on purpose, because there it can race with a pending retry. If a page shortage has already armed the work with RTW_SDIO_TX_RETRY_DELAY, queue_delayed_work() would see it pending and do nothing, so a newly queued frame would sit for up to a millisecond for no reason. mod_delayed_work() re-arms it to fire immediately. I have added a comment saying so.

From: Luka Gejak <[email protected]>

The vendor start_clnt_join() does not begin authentication until it has seen a beacon or probe response from the target BSSID, and the RTL8723BS firmware depends on that ordering: authenticating earlier leaves the firmware without the BSS parameters it needs and the exchange times out.

Record such frames from the receive path so the join sequence can wait for one. The recording is gated on the chip and only active during the pre-authentication window, so it costs other chips a single test per frame.

Signed-off-by Luka Gejak <[email protected]>

---
 drivers/net/wireless/realtek/rtw88/mac80211.c | 31 +++++++++++++++++++
 drivers/net/wireless/realtek/rtw88/main.c     |  2 ++
 drivers/net/wireless/realtek/rtw88/main.h     | 20 ++++++++++++
 drivers/net/wireless/realtek/rtw88/sdio.c     |  5 +++
 4 files changed, 58 insertions(+)

drivers/net/wireless/realtek/rtw88/mac80211.c +0 -0

index b01b98d24b0a..ff0f4f0bdc7b 100644

drivers/net/wireless/realtek/rtw88/mac80211.c +17 -0

+           test_bit(RTW_FLAG_SCANNING, rtwdev->flags) ||
+           pkt_stat->crc_err || pkt_stat->icv_err)
+               return;
+
+       if (!ieee80211_is_beacon(fc) && !ieee80211_is_probe_resp(fc))
+               return;
+
+       spin_lock_irqsave(&sync->lock, flags);
+       if (sync->active && ether_addr_equal(hdr->addr3, sync->bssid)) {
+               sync->seen = true;
+               sync->seen_count++;
+               wake_up(&sync->wait);
+       }
+       spin_unlock_irqrestore(&sync->lock, flags);
+}
+EXPORT_SYMBOL(rtw8723bs_auth_sync_rx);
+
 static void rtw_ops_tx(struct ieee80211_hw *hw,
                       struct ieee80211_tx_control *control,
                       struct sk_buff *skb)

drivers/net/wireless/realtek/rtw88/main.c +2 -0

index cd9254370fcc..16228cae252e 100644
@@ -2174,11 +2174,13 @@ int rtw_core_init(struct rtw_dev *rtwdev)
 
        spin_lock_init(&rtwdev->txq_lock);
        spin_lock_init(&rtwdev->tx_report.q_lock);
+       spin_lock_init(&rtwdev->auth_sync.lock);
 
        mutex_init(&rtwdev->mutex);
        mutex_init(&rtwdev->hal.tx_power_mutex);
 
        init_waitqueue_head(&rtwdev->coex.wait);
+       init_waitqueue_head(&rtwdev->auth_sync.wait);
        init_completion(&rtwdev->lps_leave_check);
        init_completion(&rtwdev->fw_scan_density);
 

drivers/net/wireless/realtek/rtw88/main.h +0 -0

index 8f86f7c12de5..4d3d1d99e305 100644
@@ -2058,6 +2058,20 @@ struct rtw_hw_scan_info {
        u8 op_bw;

drivers/net/wireless/realtek/rtw88/main.h +12 -0

+       u8 bssid[ETH_ALEN];
+       bool active;
+       bool seen;
+       u32 seen_count;
+};
+
 struct rtw_dev {
        struct ieee80211_hw *hw;
        struct device *dev;

@@ -2134,6 +2148,8 @@ struct rtw_dev {
        struct completion fw_scan_density;
        bool ap_active;
 
+       struct rtw_auth_sync auth_sync;
+
        bool led_registered;
        char led_name[32];
        struct led_classdev led_cdev;

@@ -2291,4 +2307,8 @@ bool rtw_core_check_sta_active(struct rtw_dev *rtwdev);
 void rtw_core_enable_beacon(struct rtw_dev *rtwdev, bool enable);
 void rtw_set_ampdu_factor(struct rtw_dev *rtwdev, struct ieee80211_vif *vif,
                          struct ieee80211_bss_conf *bss_conf);
+void rtw8723bs_auth_sync_rx(struct rtw_dev *rtwdev,
+                           const struct ieee80211_hdr *hdr, u32 len,
+                           const struct rtw_rx_pkt_stat *pkt_stat,
+                           const struct ieee80211_rx_status *rx_status);
 #endif

drivers/net/wireless/realtek/rtw88/sdio.c +5 -1

index 572b791249ed..b294bcc4d828 100644
@@ -1203,6 +1203,11 @@ static void rtw_sdio_rx_skb(struct rtw_dev *rtwdev, struct sk_buff *skb,
        rtw_update_rx_freq_for_invalid(rtwdev, skb, rx_status, pkt_stat);
        rtw_rx_stats(rtwdev, pkt_stat->vif, skb);
 
+       if (skb->len >= sizeof(struct ieee80211_hdr_3addr))
+               rtw8723bs_auth_sync_rx(rtwdev,
+                                      (struct ieee80211_hdr *)skb->data,
+                                      skb->len, pkt_stat, rx_status);
+
        ieee80211_rx_irqsafe(rtwdev->hw, skb);
 }
 
--

2.55.0

I know vendor driver does wait for a beacon, but I don't think this can affect connection. Could you confirm this again?