* [PATCH v3 1/8] wifi: ath12k: add ATH12K_DBG_WOW log level
2024-05-30 7:27 [PATCH v3 0/8] wifi: ath12k: add support for WoW Baochen Qiang
@ 2024-05-30 7:27 ` Baochen Qiang
2024-05-30 17:55 ` Jeff Johnson
2024-05-30 7:27 ` [PATCH v3 2/8] wifi: ath12k: implement WoW enable and wakeup commands Baochen Qiang
` (7 subsequent siblings)
8 siblings, 1 reply; 25+ messages in thread
From: Baochen Qiang @ 2024-05-30 7:27 UTC (permalink / raw)
To: ath12k; +Cc: linux-wireless, quic_bqiang
Currently there is no dedicated log level for WoW, so create it for future use.
Tested-on: WCN7850 hw2.0 PCI WLAN.HMT.1.0-03427-QCAHMTSWPL_V1.0_V2.0_SILICONZ-1.15378.4
Signed-off-by: Baochen Qiang <quic_bqiang@quicinc.com>
---
drivers/net/wireless/ath/ath12k/debug.h | 1 +
1 file changed, 1 insertion(+)
diff --git a/drivers/net/wireless/ath/ath12k/debug.h b/drivers/net/wireless/ath/ath12k/debug.h
index aa685295f8a4..3855b770772f 100644
--- a/drivers/net/wireless/ath/ath12k/debug.h
+++ b/drivers/net/wireless/ath/ath12k/debug.h
@@ -25,6 +25,7 @@ enum ath12k_debug_mask {
ATH12K_DBG_PCI = 0x00001000,
ATH12K_DBG_DP_TX = 0x00002000,
ATH12K_DBG_DP_RX = 0x00004000,
+ ATH12K_DBG_WOW = 0x00008000,
ATH12K_DBG_ANY = 0xffffffff,
};
--
2.25.1
^ permalink raw reply related [flat|nested] 25+ messages in thread* [PATCH v3 2/8] wifi: ath12k: implement WoW enable and wakeup commands
2024-05-30 7:27 [PATCH v3 0/8] wifi: ath12k: add support for WoW Baochen Qiang
2024-05-30 7:27 ` [PATCH v3 1/8] wifi: ath12k: add ATH12K_DBG_WOW log level Baochen Qiang
@ 2024-05-30 7:27 ` Baochen Qiang
2024-05-30 7:27 ` [PATCH v3 3/8] wifi: ath12k: add basic WoW functionalities Baochen Qiang
` (6 subsequent siblings)
8 siblings, 0 replies; 25+ messages in thread
From: Baochen Qiang @ 2024-05-30 7:27 UTC (permalink / raw)
To: ath12k; +Cc: linux-wireless, quic_bqiang
Implement WoW enable and WoW wakeup commands which are needed
for suspend/resume.
Tested-on: WCN7850 hw2.0 PCI WLAN.HMT.1.0-03427-QCAHMTSWPL_V1.0_V2.0_SILICONZ-1.15378.4
Signed-off-by: Baochen Qiang <quic_bqiang@quicinc.com>
Acked-by: Jeff Johnson <quic_jjohnson@quicinc.com>
---
drivers/net/wireless/ath/ath12k/Makefile | 1 +
drivers/net/wireless/ath/ath12k/core.c | 2 +
drivers/net/wireless/ath/ath12k/core.h | 4 +
drivers/net/wireless/ath/ath12k/wmi.c | 104 ++++++++++++++
drivers/net/wireless/ath/ath12k/wmi.h | 174 +++++++++++++++++++++++
drivers/net/wireless/ath/ath12k/wow.c | 74 ++++++++++
drivers/net/wireless/ath/ath12k/wow.h | 30 ++++
7 files changed, 389 insertions(+)
create mode 100644 drivers/net/wireless/ath/ath12k/wow.c
create mode 100644 drivers/net/wireless/ath/ath12k/wow.h
diff --git a/drivers/net/wireless/ath/ath12k/Makefile b/drivers/net/wireless/ath/ath12k/Makefile
index d42480db7463..f0dcc933aa95 100644
--- a/drivers/net/wireless/ath/ath12k/Makefile
+++ b/drivers/net/wireless/ath/ath12k/Makefile
@@ -26,6 +26,7 @@ ath12k-y += core.o \
ath12k-$(CONFIG_ATH12K_DEBUGFS) += debugfs.o
ath12k-$(CONFIG_ACPI) += acpi.o
ath12k-$(CONFIG_ATH12K_TRACING) += trace.o
+ath12k-$(CONFIG_PM) += wow.o
# for tracing framework to find trace.h
CFLAGS_trace.o := -I$(src)
diff --git a/drivers/net/wireless/ath/ath12k/core.c b/drivers/net/wireless/ath/ath12k/core.c
index e7f628e935e4..3b1ad175a36a 100644
--- a/drivers/net/wireless/ath/ath12k/core.c
+++ b/drivers/net/wireless/ath/ath12k/core.c
@@ -16,6 +16,7 @@
#include "hif.h"
#include "fw.h"
#include "debugfs.h"
+#include "wow.h"
unsigned int ath12k_debug_mask;
module_param_named(debug_mask, ath12k_debug_mask, uint, 0644);
@@ -1259,6 +1260,7 @@ struct ath12k_base *ath12k_core_alloc(struct device *dev, size_t priv_size,
timer_setup(&ab->rx_replenish_retry, ath12k_ce_rx_replenish_retry, 0);
init_completion(&ab->htc_suspend);
init_completion(&ab->restart_completed);
+ init_completion(&ab->wow.wakeup_completed);
ab->dev = dev;
ab->hif.bus = bus;
diff --git a/drivers/net/wireless/ath/ath12k/core.h b/drivers/net/wireless/ath/ath12k/core.h
index 7d20b09c52e6..d94d1527b276 100644
--- a/drivers/net/wireless/ath/ath12k/core.h
+++ b/drivers/net/wireless/ath/ath12k/core.h
@@ -764,6 +764,10 @@ struct ath12k_base {
const struct ath12k_hif_ops *ops;
} hif;
+ struct {
+ struct completion wakeup_completed;
+ } wow;
+
struct ath12k_ce ce;
struct timer_list rx_replenish_retry;
struct ath12k_hal hal;
diff --git a/drivers/net/wireless/ath/ath12k/wmi.c b/drivers/net/wireless/ath/ath12k/wmi.c
index 99106b088311..7142d71de5f0 100644
--- a/drivers/net/wireless/ath/ath12k/wmi.c
+++ b/drivers/net/wireless/ath/ath12k/wmi.c
@@ -7029,6 +7029,65 @@ static void ath12k_wmi_twt_disable_event(struct ath12k_base *ab,
kfree(tb);
}
+static int ath12k_wmi_wow_wakeup_host_parse(struct ath12k_base *ab,
+ u16 tag, u16 len,
+ const void *ptr, void *data)
+{
+ const struct wmi_wow_ev_pg_fault_param *pf_param;
+ const struct wmi_wow_ev_param *param;
+ struct wmi_wow_ev_arg *arg = data;
+ int pf_len;
+
+ switch (tag) {
+ case WMI_TAG_WOW_EVENT_INFO:
+ param = ptr;
+ arg->wake_reason = le32_to_cpu(param->wake_reason);
+ ath12k_dbg(ab, ATH12K_DBG_WMI, "wow wakeup host reason %d %s\n",
+ arg->wake_reason, wow_reason(arg->wake_reason));
+ break;
+
+ case WMI_TAG_ARRAY_BYTE:
+ if (arg && arg->wake_reason == WOW_REASON_PAGE_FAULT) {
+ pf_param = ptr;
+ pf_len = le32_to_cpu(pf_param->len);
+ if (pf_len > len - sizeof(pf_len) ||
+ pf_len < 0) {
+ ath12k_warn(ab, "invalid page fault buffer len %d\n",
+ pf_len);
+ return -EINVAL;
+ }
+ ath12k_dbg(ab, ATH12K_DBG_WMI, "wow data_len = %d\n",
+ pf_len);
+ ath12k_dbg_dump(ab, ATH12K_DBG_WMI,
+ "wow_event_info_type packet present",
+ "wow_pg_fault ",
+ pf_param->data,
+ pf_len);
+ }
+ break;
+ default:
+ break;
+ }
+
+ return 0;
+}
+
+static void ath12k_wmi_event_wow_wakeup_host(struct ath12k_base *ab, struct sk_buff *skb)
+{
+ struct wmi_wow_ev_arg arg = { };
+ int ret;
+
+ ret = ath12k_wmi_tlv_iter(ab, skb->data, skb->len,
+ ath12k_wmi_wow_wakeup_host_parse,
+ &arg);
+ if (ret) {
+ ath12k_warn(ab, "failed to parse wmi wow tlv: %d\n", ret);
+ return;
+ }
+
+ complete(&ab->wow.wakeup_completed);
+}
+
static void ath12k_wmi_op_rx(struct ath12k_base *ab, struct sk_buff *skb)
{
struct wmi_cmd_hdr *cmd_hdr;
@@ -7149,6 +7208,9 @@ static void ath12k_wmi_op_rx(struct ath12k_base *ab, struct sk_buff *skb)
case WMI_DIAG_EVENTID:
ath12k_wmi_diag_event(ab, skb);
break;
+ case WMI_WOW_WAKEUP_HOST_EVENTID:
+ ath12k_wmi_event_wow_wakeup_host(ab, skb);
+ break;
/* TODO: Add remaining events */
default:
ath12k_dbg(ab, ATH12K_DBG_WMI, "Unknown eventid: 0x%x\n", id);
@@ -7358,3 +7420,45 @@ void ath12k_wmi_detach(struct ath12k_base *ab)
ath12k_wmi_free_dbring_caps(ab);
}
+
+int ath12k_wmi_wow_host_wakeup_ind(struct ath12k *ar)
+{
+ struct wmi_wow_host_wakeup_cmd *cmd;
+ struct sk_buff *skb;
+ size_t len;
+
+ len = sizeof(*cmd);
+ skb = ath12k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
+ if (!skb)
+ return -ENOMEM;
+
+ cmd = (struct wmi_wow_host_wakeup_cmd *)skb->data;
+ cmd->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_WOW_HOSTWAKEUP_FROM_SLEEP_CMD,
+ sizeof(*cmd));
+
+ ath12k_dbg(ar->ab, ATH12K_DBG_WMI, "wmi tlv wow host wakeup ind\n");
+
+ return ath12k_wmi_cmd_send(ar->wmi, skb, WMI_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID);
+}
+
+int ath12k_wmi_wow_enable(struct ath12k *ar)
+{
+ struct wmi_wow_enable_cmd *cmd;
+ struct sk_buff *skb;
+ int len;
+
+ len = sizeof(*cmd);
+ skb = ath12k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
+ if (!skb)
+ return -ENOMEM;
+
+ cmd = (struct wmi_wow_enable_cmd *)skb->data;
+ cmd->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_WOW_ENABLE_CMD,
+ sizeof(*cmd));
+
+ cmd->enable = cpu_to_le32(1);
+ cmd->pause_iface_config = cpu_to_le32(WOW_IFACE_PAUSE_ENABLED);
+ ath12k_dbg(ar->ab, ATH12K_DBG_WMI, "wmi tlv wow enable\n");
+
+ return ath12k_wmi_cmd_send(ar->wmi, skb, WMI_WOW_ENABLE_CMDID);
+}
diff --git a/drivers/net/wireless/ath/ath12k/wmi.h b/drivers/net/wireless/ath/ath12k/wmi.h
index c2b86e187a03..9cee3a114645 100644
--- a/drivers/net/wireless/ath/ath12k/wmi.h
+++ b/drivers/net/wireless/ath/ath12k/wmi.h
@@ -4902,6 +4902,178 @@ struct wmi_twt_disable_event {
__le32 status;
} __packed;
+/* WOW structures */
+enum wmi_wow_wakeup_event {
+ WOW_BMISS_EVENT = 0,
+ WOW_BETTER_AP_EVENT,
+ WOW_DEAUTH_RECVD_EVENT,
+ WOW_MAGIC_PKT_RECVD_EVENT,
+ WOW_GTK_ERR_EVENT,
+ WOW_FOURWAY_HSHAKE_EVENT,
+ WOW_EAPOL_RECVD_EVENT,
+ WOW_NLO_DETECTED_EVENT,
+ WOW_DISASSOC_RECVD_EVENT,
+ WOW_PATTERN_MATCH_EVENT,
+ WOW_CSA_IE_EVENT,
+ WOW_PROBE_REQ_WPS_IE_EVENT,
+ WOW_AUTH_REQ_EVENT,
+ WOW_ASSOC_REQ_EVENT,
+ WOW_HTT_EVENT,
+ WOW_RA_MATCH_EVENT,
+ WOW_HOST_AUTO_SHUTDOWN_EVENT,
+ WOW_IOAC_MAGIC_EVENT,
+ WOW_IOAC_SHORT_EVENT,
+ WOW_IOAC_EXTEND_EVENT,
+ WOW_IOAC_TIMER_EVENT,
+ WOW_DFS_PHYERR_RADAR_EVENT,
+ WOW_BEACON_EVENT,
+ WOW_CLIENT_KICKOUT_EVENT,
+ WOW_EVENT_MAX,
+};
+
+enum wmi_wow_interface_cfg {
+ WOW_IFACE_PAUSE_ENABLED,
+ WOW_IFACE_PAUSE_DISABLED
+};
+
+#define C2S(x) case x: return #x
+
+static inline const char *wow_wakeup_event(enum wmi_wow_wakeup_event ev)
+{
+ switch (ev) {
+ C2S(WOW_BMISS_EVENT);
+ C2S(WOW_BETTER_AP_EVENT);
+ C2S(WOW_DEAUTH_RECVD_EVENT);
+ C2S(WOW_MAGIC_PKT_RECVD_EVENT);
+ C2S(WOW_GTK_ERR_EVENT);
+ C2S(WOW_FOURWAY_HSHAKE_EVENT);
+ C2S(WOW_EAPOL_RECVD_EVENT);
+ C2S(WOW_NLO_DETECTED_EVENT);
+ C2S(WOW_DISASSOC_RECVD_EVENT);
+ C2S(WOW_PATTERN_MATCH_EVENT);
+ C2S(WOW_CSA_IE_EVENT);
+ C2S(WOW_PROBE_REQ_WPS_IE_EVENT);
+ C2S(WOW_AUTH_REQ_EVENT);
+ C2S(WOW_ASSOC_REQ_EVENT);
+ C2S(WOW_HTT_EVENT);
+ C2S(WOW_RA_MATCH_EVENT);
+ C2S(WOW_HOST_AUTO_SHUTDOWN_EVENT);
+ C2S(WOW_IOAC_MAGIC_EVENT);
+ C2S(WOW_IOAC_SHORT_EVENT);
+ C2S(WOW_IOAC_EXTEND_EVENT);
+ C2S(WOW_IOAC_TIMER_EVENT);
+ C2S(WOW_DFS_PHYERR_RADAR_EVENT);
+ C2S(WOW_BEACON_EVENT);
+ C2S(WOW_CLIENT_KICKOUT_EVENT);
+ C2S(WOW_EVENT_MAX);
+ default:
+ return NULL;
+ }
+}
+
+enum wmi_wow_wake_reason {
+ WOW_REASON_UNSPECIFIED = -1,
+ WOW_REASON_NLOD = 0,
+ WOW_REASON_AP_ASSOC_LOST,
+ WOW_REASON_LOW_RSSI,
+ WOW_REASON_DEAUTH_RECVD,
+ WOW_REASON_DISASSOC_RECVD,
+ WOW_REASON_GTK_HS_ERR,
+ WOW_REASON_EAP_REQ,
+ WOW_REASON_FOURWAY_HS_RECV,
+ WOW_REASON_TIMER_INTR_RECV,
+ WOW_REASON_PATTERN_MATCH_FOUND,
+ WOW_REASON_RECV_MAGIC_PATTERN,
+ WOW_REASON_P2P_DISC,
+ WOW_REASON_WLAN_HB,
+ WOW_REASON_CSA_EVENT,
+ WOW_REASON_PROBE_REQ_WPS_IE_RECV,
+ WOW_REASON_AUTH_REQ_RECV,
+ WOW_REASON_ASSOC_REQ_RECV,
+ WOW_REASON_HTT_EVENT,
+ WOW_REASON_RA_MATCH,
+ WOW_REASON_HOST_AUTO_SHUTDOWN,
+ WOW_REASON_IOAC_MAGIC_EVENT,
+ WOW_REASON_IOAC_SHORT_EVENT,
+ WOW_REASON_IOAC_EXTEND_EVENT,
+ WOW_REASON_IOAC_TIMER_EVENT,
+ WOW_REASON_ROAM_HO,
+ WOW_REASON_DFS_PHYERR_RADADR_EVENT,
+ WOW_REASON_BEACON_RECV,
+ WOW_REASON_CLIENT_KICKOUT_EVENT,
+ WOW_REASON_PAGE_FAULT = 0x3a,
+ WOW_REASON_DEBUG_TEST = 0xFF,
+};
+
+static inline const char *wow_reason(enum wmi_wow_wake_reason reason)
+{
+ switch (reason) {
+ C2S(WOW_REASON_UNSPECIFIED);
+ C2S(WOW_REASON_NLOD);
+ C2S(WOW_REASON_AP_ASSOC_LOST);
+ C2S(WOW_REASON_LOW_RSSI);
+ C2S(WOW_REASON_DEAUTH_RECVD);
+ C2S(WOW_REASON_DISASSOC_RECVD);
+ C2S(WOW_REASON_GTK_HS_ERR);
+ C2S(WOW_REASON_EAP_REQ);
+ C2S(WOW_REASON_FOURWAY_HS_RECV);
+ C2S(WOW_REASON_TIMER_INTR_RECV);
+ C2S(WOW_REASON_PATTERN_MATCH_FOUND);
+ C2S(WOW_REASON_RECV_MAGIC_PATTERN);
+ C2S(WOW_REASON_P2P_DISC);
+ C2S(WOW_REASON_WLAN_HB);
+ C2S(WOW_REASON_CSA_EVENT);
+ C2S(WOW_REASON_PROBE_REQ_WPS_IE_RECV);
+ C2S(WOW_REASON_AUTH_REQ_RECV);
+ C2S(WOW_REASON_ASSOC_REQ_RECV);
+ C2S(WOW_REASON_HTT_EVENT);
+ C2S(WOW_REASON_RA_MATCH);
+ C2S(WOW_REASON_HOST_AUTO_SHUTDOWN);
+ C2S(WOW_REASON_IOAC_MAGIC_EVENT);
+ C2S(WOW_REASON_IOAC_SHORT_EVENT);
+ C2S(WOW_REASON_IOAC_EXTEND_EVENT);
+ C2S(WOW_REASON_IOAC_TIMER_EVENT);
+ C2S(WOW_REASON_ROAM_HO);
+ C2S(WOW_REASON_DFS_PHYERR_RADADR_EVENT);
+ C2S(WOW_REASON_BEACON_RECV);
+ C2S(WOW_REASON_CLIENT_KICKOUT_EVENT);
+ C2S(WOW_REASON_PAGE_FAULT);
+ C2S(WOW_REASON_DEBUG_TEST);
+ default:
+ return NULL;
+ }
+}
+
+#undef C2S
+
+struct wmi_wow_enable_cmd {
+ __le32 tlv_header;
+ __le32 enable;
+ __le32 pause_iface_config;
+ __le32 flags;
+} __packed;
+
+struct wmi_wow_host_wakeup_cmd {
+ __le32 tlv_header;
+ __le32 reserved;
+} __packed;
+
+struct wmi_wow_ev_param {
+ __le32 vdev_id;
+ __le32 flag;
+ __le32 wake_reason;
+ __le32 data_len;
+} __packed;
+
+struct wmi_wow_ev_pg_fault_param {
+ __le32 len;
+ u8 data[];
+} __packed;
+
+struct wmi_wow_ev_arg {
+ enum wmi_wow_wake_reason wake_reason;
+};
+
void ath12k_wmi_init_qcn9274(struct ath12k_base *ab,
struct ath12k_wmi_resource_config_arg *config);
void ath12k_wmi_init_wcn7850(struct ath12k_base *ab,
@@ -5054,4 +5226,6 @@ ath12k_wmi_mac_phy_get_hw_link_id(const struct ath12k_wmi_mac_phy_caps_params *p
WMI_CAPS_PARAMS_HW_LINK_ID);
}
+int ath12k_wmi_wow_host_wakeup_ind(struct ath12k *ar);
+int ath12k_wmi_wow_enable(struct ath12k *ar);
#endif
diff --git a/drivers/net/wireless/ath/ath12k/wow.c b/drivers/net/wireless/ath/ath12k/wow.c
new file mode 100644
index 000000000000..98e36fc87fa6
--- /dev/null
+++ b/drivers/net/wireless/ath/ath12k/wow.c
@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: BSD-3-Clause-Clear
+/*
+ * Copyright (c) 2020 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2022-2024 Qualcomm Innovation Center, Inc. All rights reserved.
+ */
+
+#include <linux/delay.h>
+
+#include "mac.h"
+#include "core.h"
+#include "hif.h"
+#include "debug.h"
+#include "wmi.h"
+#include "wow.h"
+
+int ath12k_wow_enable(struct ath12k *ar)
+{
+ struct ath12k_base *ab = ar->ab;
+ int i, ret;
+
+ clear_bit(ATH12K_FLAG_HTC_SUSPEND_COMPLETE, &ab->dev_flags);
+
+ for (i = 0; i < ATH12K_WOW_RETRY_NUM; i++) {
+ reinit_completion(&ab->htc_suspend);
+
+ ret = ath12k_wmi_wow_enable(ar);
+ if (ret) {
+ ath12k_warn(ab, "failed to issue wow enable: %d\n", ret);
+ return ret;
+ }
+
+ ret = wait_for_completion_timeout(&ab->htc_suspend, 3 * HZ);
+ if (ret == 0) {
+ ath12k_warn(ab,
+ "timed out while waiting for htc suspend completion\n");
+ return -ETIMEDOUT;
+ }
+
+ if (test_bit(ATH12K_FLAG_HTC_SUSPEND_COMPLETE, &ab->dev_flags))
+ /* success, suspend complete received */
+ return 0;
+
+ ath12k_warn(ab, "htc suspend not complete, retrying (try %d)\n",
+ i);
+ msleep(ATH12K_WOW_RETRY_WAIT_MS);
+ }
+
+ ath12k_warn(ab, "htc suspend not complete, failing after %d tries\n", i);
+
+ return -ETIMEDOUT;
+}
+
+int ath12k_wow_wakeup(struct ath12k *ar)
+{
+ struct ath12k_base *ab = ar->ab;
+ int ret;
+
+ reinit_completion(&ab->wow.wakeup_completed);
+
+ ret = ath12k_wmi_wow_host_wakeup_ind(ar);
+ if (ret) {
+ ath12k_warn(ab, "failed to send wow wakeup indication: %d\n",
+ ret);
+ return ret;
+ }
+
+ ret = wait_for_completion_timeout(&ab->wow.wakeup_completed, 3 * HZ);
+ if (ret == 0) {
+ ath12k_warn(ab, "timed out while waiting for wow wakeup completion\n");
+ return -ETIMEDOUT;
+ }
+
+ return 0;
+}
diff --git a/drivers/net/wireless/ath/ath12k/wow.h b/drivers/net/wireless/ath/ath12k/wow.h
new file mode 100644
index 000000000000..6817ceaa4cfe
--- /dev/null
+++ b/drivers/net/wireless/ath/ath12k/wow.h
@@ -0,0 +1,30 @@
+/* SPDX-License-Identifier: BSD-3-Clause-Clear */
+/*
+ * Copyright (c) 2020 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2022, 2024 Qualcomm Innovation Center, Inc. All rights reserved.
+ */
+
+#ifndef ATH12K_WOW_H
+#define ATH12K_WOW_H
+
+#define ATH12K_WOW_RETRY_NUM 10
+#define ATH12K_WOW_RETRY_WAIT_MS 200
+
+#ifdef CONFIG_PM
+
+int ath12k_wow_enable(struct ath12k *ar);
+int ath12k_wow_wakeup(struct ath12k *ar);
+
+#else
+
+static inline int ath12k_wow_enable(struct ath12k *ar)
+{
+ return 0;
+}
+
+static inline int ath12k_wow_wakeup(struct ath12k *ar)
+{
+ return 0;
+}
+#endif /* CONFIG_PM */
+#endif /* ATH12K_WOW_H */
--
2.25.1
^ permalink raw reply related [flat|nested] 25+ messages in thread* [PATCH v3 3/8] wifi: ath12k: add basic WoW functionalities
2024-05-30 7:27 [PATCH v3 0/8] wifi: ath12k: add support for WoW Baochen Qiang
2024-05-30 7:27 ` [PATCH v3 1/8] wifi: ath12k: add ATH12K_DBG_WOW log level Baochen Qiang
2024-05-30 7:27 ` [PATCH v3 2/8] wifi: ath12k: implement WoW enable and wakeup commands Baochen Qiang
@ 2024-05-30 7:27 ` Baochen Qiang
2024-05-30 7:27 ` [PATCH v3 4/8] wifi: ath12k: add WoW net-detect functionality Baochen Qiang
` (5 subsequent siblings)
8 siblings, 0 replies; 25+ messages in thread
From: Baochen Qiang @ 2024-05-30 7:27 UTC (permalink / raw)
To: ath12k; +Cc: linux-wireless, quic_bqiang
Implement basic WoW functionalities such as magic-packet, disconnect
and pattern. The logic is very similar to ath11k.
When WoW is configured, ath12k_core_suspend and ath12k_core_resume
are skipped (by checking ar->state) as we are not allowed to power
cycle firmware.
Tested-on: WCN7850 hw2.0 PCI WLAN.HMT.1.0-03427-QCAHMTSWPL_V1.0_V2.0_SILICONZ-1.15378.4
Signed-off-by: Baochen Qiang <quic_bqiang@quicinc.com>
Acked-by: Jeff Johnson <quic_jjohnson@quicinc.com>
---
drivers/net/wireless/ath/ath12k/core.c | 46 ++-
drivers/net/wireless/ath/ath12k/core.h | 5 +
drivers/net/wireless/ath/ath12k/htc.c | 6 +
drivers/net/wireless/ath/ath12k/mac.c | 14 +
drivers/net/wireless/ath/ath12k/wmi.c | 143 +++++++++
drivers/net/wireless/ath/ath12k/wmi.h | 63 ++++
drivers/net/wireless/ath/ath12k/wow.c | 416 +++++++++++++++++++++++++
drivers/net/wireless/ath/ath12k/wow.h | 32 ++
8 files changed, 717 insertions(+), 8 deletions(-)
diff --git a/drivers/net/wireless/ath/ath12k/core.c b/drivers/net/wireless/ath/ath12k/core.c
index 3b1ad175a36a..9a7a18825562 100644
--- a/drivers/net/wireless/ath/ath12k/core.c
+++ b/drivers/net/wireless/ath/ath12k/core.c
@@ -43,14 +43,38 @@ static int ath12k_core_rfkill_config(struct ath12k_base *ab)
return ret;
}
-int ath12k_core_suspend(struct ath12k_base *ab)
+/* Check if we need to continue with suspend/resume operation.
+ * Return:
+ * a negative value: error happens and don't continue.
+ * 0: no error but don't continue.
+ * positive value: no error and do continue.
+ */
+static int ath12k_core_continue_suspend_resume(struct ath12k_base *ab)
{
struct ath12k *ar;
- int ret, i;
if (!ab->hw_params->supports_suspend)
return -EOPNOTSUPP;
+ /* so far single_pdev_only chips have supports_suspend as true
+ * so pass 0 as a dummy pdev_id here.
+ */
+ ar = ab->pdevs[0].ar;
+ if (!ar || !ar->ah || ar->ah->state != ATH12K_HW_STATE_OFF)
+ return 0;
+
+ return 1;
+}
+
+int ath12k_core_suspend(struct ath12k_base *ab)
+{
+ struct ath12k *ar;
+ int ret, i;
+
+ ret = ath12k_core_continue_suspend_resume(ab);
+ if (ret <= 0)
+ return ret;
+
for (i = 0; i < ab->num_radios; i++) {
ar = ab->pdevs[i].ar;
if (!ar)
@@ -81,8 +105,11 @@ EXPORT_SYMBOL(ath12k_core_suspend);
int ath12k_core_suspend_late(struct ath12k_base *ab)
{
- if (!ab->hw_params->supports_suspend)
- return -EOPNOTSUPP;
+ int ret;
+
+ ret = ath12k_core_continue_suspend_resume(ab);
+ if (ret <= 0)
+ return ret;
ath12k_hif_irq_disable(ab);
ath12k_hif_ce_irq_disable(ab);
@@ -97,8 +124,9 @@ int ath12k_core_resume_early(struct ath12k_base *ab)
{
int ret;
- if (!ab->hw_params->supports_suspend)
- return -EOPNOTSUPP;
+ ret = ath12k_core_continue_suspend_resume(ab);
+ if (ret <= 0)
+ return ret;
reinit_completion(&ab->restart_completed);
ret = ath12k_hif_power_up(ab);
@@ -112,9 +140,11 @@ EXPORT_SYMBOL(ath12k_core_resume_early);
int ath12k_core_resume(struct ath12k_base *ab)
{
long time_left;
+ int ret;
- if (!ab->hw_params->supports_suspend)
- return -EOPNOTSUPP;
+ ret = ath12k_core_continue_suspend_resume(ab);
+ if (ret <= 0)
+ return ret;
time_left = wait_for_completion_timeout(&ab->restart_completed,
ATH12K_RESET_TIMEOUT_HZ);
diff --git a/drivers/net/wireless/ath/ath12k/core.h b/drivers/net/wireless/ath/ath12k/core.h
index d94d1527b276..40b4f9b4d570 100644
--- a/drivers/net/wireless/ath/ath12k/core.h
+++ b/drivers/net/wireless/ath/ath12k/core.h
@@ -27,6 +27,7 @@
#include "dbring.h"
#include "fw.h"
#include "acpi.h"
+#include "wow.h"
#define SM(_v, _f) (((_v) << _f##_LSB) & _f##_MASK)
@@ -605,6 +606,9 @@ struct ath12k {
struct work_struct wmi_mgmt_tx_work;
struct sk_buff_head wmi_mgmt_tx_queue;
+ struct ath12k_wow wow;
+ struct completion target_suspend;
+ bool target_suspend_ack;
struct ath12k_per_peer_tx_stats peer_tx_stats;
struct list_head ppdu_stats_info;
u32 ppdu_stat_list_depth;
@@ -766,6 +770,7 @@ struct ath12k_base {
struct {
struct completion wakeup_completed;
+ u32 wmi_conf_rx_decap_mode;
} wow;
struct ath12k_ce ce;
diff --git a/drivers/net/wireless/ath/ath12k/htc.c b/drivers/net/wireless/ath/ath12k/htc.c
index 2f2230f565bb..d13616bf07f4 100644
--- a/drivers/net/wireless/ath/ath12k/htc.c
+++ b/drivers/net/wireless/ath/ath12k/htc.c
@@ -244,6 +244,11 @@ static void ath12k_htc_suspend_complete(struct ath12k_base *ab, bool ack)
complete(&ab->htc_suspend);
}
+static void ath12k_htc_wakeup_from_suspend(struct ath12k_base *ab)
+{
+ ath12k_dbg(ab, ATH12K_DBG_BOOT, "boot wakeup from suspend is received\n");
+}
+
void ath12k_htc_rx_completion_handler(struct ath12k_base *ab,
struct sk_buff *skb)
{
@@ -349,6 +354,7 @@ void ath12k_htc_rx_completion_handler(struct ath12k_base *ab,
ath12k_htc_suspend_complete(ab, false);
break;
case ATH12K_HTC_MSG_WAKEUP_FROM_SUSPEND_ID:
+ ath12k_htc_wakeup_from_suspend(ab);
break;
default:
ath12k_warn(ab, "ignoring unsolicited htc ep0 event %u\n",
diff --git a/drivers/net/wireless/ath/ath12k/mac.c b/drivers/net/wireless/ath/ath12k/mac.c
index 784964ae03ec..43ee52524b3d 100644
--- a/drivers/net/wireless/ath/ath12k/mac.c
+++ b/drivers/net/wireless/ath/ath12k/mac.c
@@ -15,6 +15,8 @@
#include "dp_rx.h"
#include "peer.h"
#include "debugfs.h"
+#include "hif.h"
+#include "wow.h"
#define CHAN2G(_channel, _freq, _flags) { \
.band = NL80211_BAND_2GHZ, \
@@ -8539,6 +8541,12 @@ static const struct ieee80211_ops ath12k_ops = {
.sta_statistics = ath12k_mac_op_sta_statistics,
.remain_on_channel = ath12k_mac_op_remain_on_channel,
.cancel_remain_on_channel = ath12k_mac_op_cancel_remain_on_channel,
+
+#ifdef CONFIG_PM
+ .suspend = ath12k_wow_op_suspend,
+ .resume = ath12k_wow_op_resume,
+ .set_wakeup = ath12k_wow_op_set_wakeup,
+#endif
};
static void ath12k_mac_update_ch_list(struct ath12k *ar,
@@ -9056,6 +9064,12 @@ static int ath12k_mac_hw_register(struct ath12k_hw *ah)
ieee80211_hw_set(hw, SUPPORT_FAST_XMIT);
}
+ ret = ath12k_wow_init(ar);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to init wow: %d\n", ret);
+ goto err_free_if_combs;
+ }
+
ret = ieee80211_register_hw(hw);
if (ret) {
ath12k_err(ab, "ieee80211 registration failed: %d\n", ret);
diff --git a/drivers/net/wireless/ath/ath12k/wmi.c b/drivers/net/wireless/ath/ath12k/wmi.c
index 7142d71de5f0..7f3d4ce93cb4 100644
--- a/drivers/net/wireless/ath/ath12k/wmi.c
+++ b/drivers/net/wireless/ath/ath12k/wmi.c
@@ -3716,6 +3716,7 @@ int ath12k_wmi_cmd_init(struct ath12k_base *ab)
arg.res_cfg.is_reg_cc_ext_event_supported = true;
ab->hw_params->wmi_init(ab, &arg.res_cfg);
+ ab->wow.wmi_conf_rx_decap_mode = arg.res_cfg.rx_decap_mode;
arg.num_mem_chunks = wmi_ab->num_mem_chunks;
arg.hw_mode_id = wmi_ab->preferred_hw_mode;
@@ -7462,3 +7463,145 @@ int ath12k_wmi_wow_enable(struct ath12k *ar)
return ath12k_wmi_cmd_send(ar->wmi, skb, WMI_WOW_ENABLE_CMDID);
}
+
+int ath12k_wmi_wow_add_wakeup_event(struct ath12k *ar, u32 vdev_id,
+ enum wmi_wow_wakeup_event event,
+ u32 enable)
+{
+ struct wmi_wow_add_del_event_cmd *cmd;
+ struct sk_buff *skb;
+ size_t len;
+
+ len = sizeof(*cmd);
+ skb = ath12k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
+ if (!skb)
+ return -ENOMEM;
+
+ cmd = (struct wmi_wow_add_del_event_cmd *)skb->data;
+ cmd->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_WOW_ADD_DEL_EVT_CMD,
+ sizeof(*cmd));
+ cmd->vdev_id = cpu_to_le32(vdev_id);
+ cmd->is_add = cpu_to_le32(enable);
+ cmd->event_bitmap = cpu_to_le32((1 << event));
+
+ ath12k_dbg(ar->ab, ATH12K_DBG_WMI, "wmi tlv wow add wakeup event %s enable %d vdev_id %d\n",
+ wow_wakeup_event(event), enable, vdev_id);
+
+ return ath12k_wmi_cmd_send(ar->wmi, skb, WMI_WOW_ENABLE_DISABLE_WAKE_EVENT_CMDID);
+}
+
+int ath12k_wmi_wow_add_pattern(struct ath12k *ar, u32 vdev_id, u32 pattern_id,
+ const u8 *pattern, const u8 *mask,
+ int pattern_len, int pattern_offset)
+{
+ struct wmi_wow_add_pattern_cmd *cmd;
+ struct wmi_wow_bitmap_pattern_params *bitmap;
+ struct wmi_tlv *tlv;
+ struct sk_buff *skb;
+ void *ptr;
+ size_t len;
+
+ len = sizeof(*cmd) +
+ sizeof(*tlv) + /* array struct */
+ sizeof(*bitmap) + /* bitmap */
+ sizeof(*tlv) + /* empty ipv4 sync */
+ sizeof(*tlv) + /* empty ipv6 sync */
+ sizeof(*tlv) + /* empty magic */
+ sizeof(*tlv) + /* empty info timeout */
+ sizeof(*tlv) + sizeof(u32); /* ratelimit interval */
+
+ skb = ath12k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
+ if (!skb)
+ return -ENOMEM;
+
+ /* cmd */
+ ptr = skb->data;
+ cmd = ptr;
+ cmd->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_WOW_ADD_PATTERN_CMD,
+ sizeof(*cmd));
+ cmd->vdev_id = cpu_to_le32(vdev_id);
+ cmd->pattern_id = cpu_to_le32(pattern_id);
+ cmd->pattern_type = cpu_to_le32(WOW_BITMAP_PATTERN);
+
+ ptr += sizeof(*cmd);
+
+ /* bitmap */
+ tlv = ptr;
+ tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_STRUCT, sizeof(*bitmap));
+
+ ptr += sizeof(*tlv);
+
+ bitmap = ptr;
+ bitmap->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_WOW_BITMAP_PATTERN_T,
+ sizeof(*bitmap));
+ memcpy(bitmap->patternbuf, pattern, pattern_len);
+ memcpy(bitmap->bitmaskbuf, mask, pattern_len);
+ bitmap->pattern_offset = cpu_to_le32(pattern_offset);
+ bitmap->pattern_len = cpu_to_le32(pattern_len);
+ bitmap->bitmask_len = cpu_to_le32(pattern_len);
+ bitmap->pattern_id = cpu_to_le32(pattern_id);
+
+ ptr += sizeof(*bitmap);
+
+ /* ipv4 sync */
+ tlv = ptr;
+ tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_STRUCT, 0);
+
+ ptr += sizeof(*tlv);
+
+ /* ipv6 sync */
+ tlv = ptr;
+ tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_STRUCT, 0);
+
+ ptr += sizeof(*tlv);
+
+ /* magic */
+ tlv = ptr;
+ tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_STRUCT, 0);
+
+ ptr += sizeof(*tlv);
+
+ /* pattern info timeout */
+ tlv = ptr;
+ tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_UINT32, 0);
+
+ ptr += sizeof(*tlv);
+
+ /* ratelimit interval */
+ tlv = ptr;
+ tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_UINT32, sizeof(u32));
+
+ ath12k_dbg(ar->ab, ATH12K_DBG_WMI, "wmi tlv wow add pattern vdev_id %d pattern_id %d pattern_offset %d pattern_len %d\n",
+ vdev_id, pattern_id, pattern_offset, pattern_len);
+
+ ath12k_dbg_dump(ar->ab, ATH12K_DBG_WMI, NULL, "wow pattern: ",
+ bitmap->patternbuf, pattern_len);
+ ath12k_dbg_dump(ar->ab, ATH12K_DBG_WMI, NULL, "wow bitmask: ",
+ bitmap->bitmaskbuf, pattern_len);
+
+ return ath12k_wmi_cmd_send(ar->wmi, skb, WMI_WOW_ADD_WAKE_PATTERN_CMDID);
+}
+
+int ath12k_wmi_wow_del_pattern(struct ath12k *ar, u32 vdev_id, u32 pattern_id)
+{
+ struct wmi_wow_del_pattern_cmd *cmd;
+ struct sk_buff *skb;
+ size_t len;
+
+ len = sizeof(*cmd);
+ skb = ath12k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
+ if (!skb)
+ return -ENOMEM;
+
+ cmd = (struct wmi_wow_del_pattern_cmd *)skb->data;
+ cmd->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_WOW_DEL_PATTERN_CMD,
+ sizeof(*cmd));
+ cmd->vdev_id = cpu_to_le32(vdev_id);
+ cmd->pattern_id = cpu_to_le32(pattern_id);
+ cmd->pattern_type = cpu_to_le32(WOW_BITMAP_PATTERN);
+
+ ath12k_dbg(ar->ab, ATH12K_DBG_WMI, "wmi tlv wow del pattern vdev_id %d pattern_id %d\n",
+ vdev_id, pattern_id);
+
+ return ath12k_wmi_cmd_send(ar->wmi, skb, WMI_WOW_DEL_WAKE_PATTERN_CMDID);
+}
diff --git a/drivers/net/wireless/ath/ath12k/wmi.h b/drivers/net/wireless/ath/ath12k/wmi.h
index 9cee3a114645..6cb06f6f7df4 100644
--- a/drivers/net/wireless/ath/ath12k/wmi.h
+++ b/drivers/net/wireless/ath/ath12k/wmi.h
@@ -5046,6 +5046,62 @@ static inline const char *wow_reason(enum wmi_wow_wake_reason reason)
#undef C2S
+#define WOW_DEFAULT_BITMAP_PATTERN_SIZE 148
+#define WOW_DEFAULT_BITMASK_SIZE 148
+
+#define WOW_MIN_PATTERN_SIZE 1
+#define WOW_MAX_PATTERN_SIZE 148
+#define WOW_MAX_PKT_OFFSET 128
+#define WOW_HDR_LEN (sizeof(struct ieee80211_hdr_3addr) + \
+ sizeof(struct rfc1042_hdr))
+#define WOW_MAX_REDUCE (WOW_HDR_LEN - sizeof(struct ethhdr) - \
+ offsetof(struct ieee80211_hdr_3addr, addr1))
+
+struct wmi_wow_bitmap_pattern_params {
+ __le32 tlv_header;
+ u8 patternbuf[WOW_DEFAULT_BITMAP_PATTERN_SIZE];
+ u8 bitmaskbuf[WOW_DEFAULT_BITMASK_SIZE];
+ __le32 pattern_offset;
+ __le32 pattern_len;
+ __le32 bitmask_len;
+ __le32 pattern_id;
+} __packed;
+
+struct wmi_wow_add_pattern_cmd {
+ __le32 tlv_header;
+ __le32 vdev_id;
+ __le32 pattern_id;
+ __le32 pattern_type;
+} __packed;
+
+struct wmi_wow_del_pattern_cmd {
+ __le32 tlv_header;
+ __le32 vdev_id;
+ __le32 pattern_id;
+ __le32 pattern_type;
+} __packed;
+
+enum wmi_tlv_pattern_type {
+ WOW_PATTERN_MIN = 0,
+ WOW_BITMAP_PATTERN = WOW_PATTERN_MIN,
+ WOW_IPV4_SYNC_PATTERN,
+ WOW_IPV6_SYNC_PATTERN,
+ WOW_WILD_CARD_PATTERN,
+ WOW_TIMER_PATTERN,
+ WOW_MAGIC_PATTERN,
+ WOW_IPV6_RA_PATTERN,
+ WOW_IOAC_PKT_PATTERN,
+ WOW_IOAC_TMR_PATTERN,
+ WOW_PATTERN_MAX
+};
+
+struct wmi_wow_add_del_event_cmd {
+ __le32 tlv_header;
+ __le32 vdev_id;
+ __le32 is_add;
+ __le32 event_bitmap;
+} __packed;
+
struct wmi_wow_enable_cmd {
__le32 tlv_header;
__le32 enable;
@@ -5228,4 +5284,11 @@ ath12k_wmi_mac_phy_get_hw_link_id(const struct ath12k_wmi_mac_phy_caps_params *p
int ath12k_wmi_wow_host_wakeup_ind(struct ath12k *ar);
int ath12k_wmi_wow_enable(struct ath12k *ar);
+int ath12k_wmi_wow_del_pattern(struct ath12k *ar, u32 vdev_id, u32 pattern_id);
+int ath12k_wmi_wow_add_pattern(struct ath12k *ar, u32 vdev_id, u32 pattern_id,
+ const u8 *pattern, const u8 *mask,
+ int pattern_len, int pattern_offset);
+int ath12k_wmi_wow_add_wakeup_event(struct ath12k *ar, u32 vdev_id,
+ enum wmi_wow_wakeup_event event,
+ u32 enable);
#endif
diff --git a/drivers/net/wireless/ath/ath12k/wow.c b/drivers/net/wireless/ath/ath12k/wow.c
index 98e36fc87fa6..2965c9ad2462 100644
--- a/drivers/net/wireless/ath/ath12k/wow.c
+++ b/drivers/net/wireless/ath/ath12k/wow.c
@@ -7,12 +7,22 @@
#include <linux/delay.h>
#include "mac.h"
+
+#include <net/mac80211.h>
#include "core.h"
#include "hif.h"
#include "debug.h"
#include "wmi.h"
#include "wow.h"
+static const struct wiphy_wowlan_support ath12k_wowlan_support = {
+ .flags = WIPHY_WOWLAN_DISCONNECT |
+ WIPHY_WOWLAN_MAGIC_PKT,
+ .pattern_min_len = WOW_MIN_PATTERN_SIZE,
+ .pattern_max_len = WOW_MAX_PATTERN_SIZE,
+ .max_pkt_offset = WOW_MAX_PKT_OFFSET,
+};
+
int ath12k_wow_enable(struct ath12k *ar)
{
struct ath12k_base *ab = ar->ab;
@@ -72,3 +82,409 @@ int ath12k_wow_wakeup(struct ath12k *ar)
return 0;
}
+
+static int ath12k_wow_vif_cleanup(struct ath12k_vif *arvif)
+{
+ struct ath12k *ar = arvif->ar;
+ int i, ret;
+
+ for (i = 0; i < WOW_EVENT_MAX; i++) {
+ ret = ath12k_wmi_wow_add_wakeup_event(ar, arvif->vdev_id, i, 0);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to issue wow wakeup for event %s on vdev %i: %d\n",
+ wow_wakeup_event(i), arvif->vdev_id, ret);
+ return ret;
+ }
+ }
+
+ for (i = 0; i < ar->wow.max_num_patterns; i++) {
+ ret = ath12k_wmi_wow_del_pattern(ar, arvif->vdev_id, i);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to delete wow pattern %d for vdev %i: %d\n",
+ i, arvif->vdev_id, ret);
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
+static int ath12k_wow_cleanup(struct ath12k *ar)
+{
+ struct ath12k_vif *arvif;
+ int ret;
+
+ lockdep_assert_held(&ar->conf_mutex);
+
+ list_for_each_entry(arvif, &ar->arvifs, list) {
+ ret = ath12k_wow_vif_cleanup(arvif);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to clean wow wakeups on vdev %i: %d\n",
+ arvif->vdev_id, ret);
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
+/* Convert a 802.3 format to a 802.11 format.
+ * +------------+-----------+--------+----------------+
+ * 802.3: |dest mac(6B)|src mac(6B)|type(2B)| body... |
+ * +------------+-----------+--------+----------------+
+ * |__ |_______ |____________ |________
+ * | | | |
+ * +--+------------+----+-----------+---------------+-----------+
+ * 802.11: |4B|dest mac(6B)| 6B |src mac(6B)| 8B |type(2B)| body... |
+ * +--+------------+----+-----------+---------------+-----------+
+ */
+static void
+ath12k_wow_convert_8023_to_80211(struct ath12k *ar,
+ const struct cfg80211_pkt_pattern *eth_pattern,
+ struct ath12k_pkt_pattern *i80211_pattern)
+{
+ size_t r1042_eth_ofs = offsetof(struct rfc1042_hdr, eth_type);
+ size_t a1_ofs = offsetof(struct ieee80211_hdr_3addr, addr1);
+ size_t a3_ofs = offsetof(struct ieee80211_hdr_3addr, addr3);
+ size_t i80211_hdr_len = sizeof(struct ieee80211_hdr_3addr);
+ size_t prot_ofs = offsetof(struct ethhdr, h_proto);
+ size_t src_ofs = offsetof(struct ethhdr, h_source);
+ u8 eth_bytemask[WOW_MAX_PATTERN_SIZE] = {};
+ const u8 *eth_pat = eth_pattern->pattern;
+ size_t eth_pat_len = eth_pattern->pattern_len;
+ size_t eth_pkt_ofs = eth_pattern->pkt_offset;
+ u8 *bytemask = i80211_pattern->bytemask;
+ u8 *pat = i80211_pattern->pattern;
+ size_t pat_len = 0;
+ size_t pkt_ofs = 0;
+ size_t delta;
+ int i;
+
+ /* convert bitmask to bytemask */
+ for (i = 0; i < eth_pat_len; i++)
+ if (eth_pattern->mask[i / 8] & BIT(i % 8))
+ eth_bytemask[i] = 0xff;
+
+ if (eth_pkt_ofs < ETH_ALEN) {
+ pkt_ofs = eth_pkt_ofs + a1_ofs;
+
+ if (eth_pkt_ofs + eth_pat_len < ETH_ALEN) {
+ memcpy(pat, eth_pat, eth_pat_len);
+ memcpy(bytemask, eth_bytemask, eth_pat_len);
+
+ pat_len = eth_pat_len;
+ } else if (eth_pkt_ofs + eth_pat_len < prot_ofs) {
+ memcpy(pat, eth_pat, ETH_ALEN - eth_pkt_ofs);
+ memcpy(bytemask, eth_bytemask, ETH_ALEN - eth_pkt_ofs);
+
+ delta = eth_pkt_ofs + eth_pat_len - src_ofs;
+ memcpy(pat + a3_ofs - pkt_ofs,
+ eth_pat + ETH_ALEN - eth_pkt_ofs,
+ delta);
+ memcpy(bytemask + a3_ofs - pkt_ofs,
+ eth_bytemask + ETH_ALEN - eth_pkt_ofs,
+ delta);
+
+ pat_len = a3_ofs - pkt_ofs + delta;
+ } else {
+ memcpy(pat, eth_pat, ETH_ALEN - eth_pkt_ofs);
+ memcpy(bytemask, eth_bytemask, ETH_ALEN - eth_pkt_ofs);
+
+ memcpy(pat + a3_ofs - pkt_ofs,
+ eth_pat + ETH_ALEN - eth_pkt_ofs,
+ ETH_ALEN);
+ memcpy(bytemask + a3_ofs - pkt_ofs,
+ eth_bytemask + ETH_ALEN - eth_pkt_ofs,
+ ETH_ALEN);
+
+ delta = eth_pkt_ofs + eth_pat_len - prot_ofs;
+ memcpy(pat + i80211_hdr_len + r1042_eth_ofs - pkt_ofs,
+ eth_pat + prot_ofs - eth_pkt_ofs,
+ delta);
+ memcpy(bytemask + i80211_hdr_len + r1042_eth_ofs - pkt_ofs,
+ eth_bytemask + prot_ofs - eth_pkt_ofs,
+ delta);
+
+ pat_len = i80211_hdr_len + r1042_eth_ofs - pkt_ofs + delta;
+ }
+ } else if (eth_pkt_ofs < prot_ofs) {
+ pkt_ofs = eth_pkt_ofs - ETH_ALEN + a3_ofs;
+
+ if (eth_pkt_ofs + eth_pat_len < prot_ofs) {
+ memcpy(pat, eth_pat, eth_pat_len);
+ memcpy(bytemask, eth_bytemask, eth_pat_len);
+
+ pat_len = eth_pat_len;
+ } else {
+ memcpy(pat, eth_pat, prot_ofs - eth_pkt_ofs);
+ memcpy(bytemask, eth_bytemask, prot_ofs - eth_pkt_ofs);
+
+ delta = eth_pkt_ofs + eth_pat_len - prot_ofs;
+ memcpy(pat + i80211_hdr_len + r1042_eth_ofs - pkt_ofs,
+ eth_pat + prot_ofs - eth_pkt_ofs,
+ delta);
+ memcpy(bytemask + i80211_hdr_len + r1042_eth_ofs - pkt_ofs,
+ eth_bytemask + prot_ofs - eth_pkt_ofs,
+ delta);
+
+ pat_len = i80211_hdr_len + r1042_eth_ofs - pkt_ofs + delta;
+ }
+ } else {
+ pkt_ofs = eth_pkt_ofs - prot_ofs + i80211_hdr_len + r1042_eth_ofs;
+
+ memcpy(pat, eth_pat, eth_pat_len);
+ memcpy(bytemask, eth_bytemask, eth_pat_len);
+
+ pat_len = eth_pat_len;
+ }
+
+ i80211_pattern->pattern_len = pat_len;
+ i80211_pattern->pkt_offset = pkt_ofs;
+}
+
+static int ath12k_vif_wow_set_wakeups(struct ath12k_vif *arvif,
+ struct cfg80211_wowlan *wowlan)
+{
+ const struct cfg80211_pkt_pattern *patterns = wowlan->patterns;
+ struct ath12k *ar = arvif->ar;
+ unsigned long wow_mask = 0;
+ int pattern_id = 0;
+ int ret, i;
+
+ /* Setup requested WOW features */
+ switch (arvif->vdev_type) {
+ case WMI_VDEV_TYPE_IBSS:
+ __set_bit(WOW_BEACON_EVENT, &wow_mask);
+ fallthrough;
+ case WMI_VDEV_TYPE_AP:
+ __set_bit(WOW_DEAUTH_RECVD_EVENT, &wow_mask);
+ __set_bit(WOW_DISASSOC_RECVD_EVENT, &wow_mask);
+ __set_bit(WOW_PROBE_REQ_WPS_IE_EVENT, &wow_mask);
+ __set_bit(WOW_AUTH_REQ_EVENT, &wow_mask);
+ __set_bit(WOW_ASSOC_REQ_EVENT, &wow_mask);
+ __set_bit(WOW_HTT_EVENT, &wow_mask);
+ __set_bit(WOW_RA_MATCH_EVENT, &wow_mask);
+ break;
+ case WMI_VDEV_TYPE_STA:
+ if (wowlan->disconnect) {
+ __set_bit(WOW_DEAUTH_RECVD_EVENT, &wow_mask);
+ __set_bit(WOW_DISASSOC_RECVD_EVENT, &wow_mask);
+ __set_bit(WOW_BMISS_EVENT, &wow_mask);
+ __set_bit(WOW_CSA_IE_EVENT, &wow_mask);
+ }
+
+ if (wowlan->magic_pkt)
+ __set_bit(WOW_MAGIC_PKT_RECVD_EVENT, &wow_mask);
+ break;
+ default:
+ break;
+ }
+
+ for (i = 0; i < wowlan->n_patterns; i++) {
+ const struct cfg80211_pkt_pattern *eth_pattern = &patterns[i];
+ struct ath12k_pkt_pattern new_pattern = {};
+
+ if (WARN_ON(eth_pattern->pattern_len > WOW_MAX_PATTERN_SIZE))
+ return -EINVAL;
+
+ if (ar->ab->wow.wmi_conf_rx_decap_mode ==
+ ATH12K_HW_TXRX_NATIVE_WIFI) {
+ ath12k_wow_convert_8023_to_80211(ar, eth_pattern,
+ &new_pattern);
+
+ if (WARN_ON(new_pattern.pattern_len > WOW_MAX_PATTERN_SIZE))
+ return -EINVAL;
+ } else {
+ memcpy(new_pattern.pattern, eth_pattern->pattern,
+ eth_pattern->pattern_len);
+
+ /* convert bitmask to bytemask */
+ for (i = 0; i < eth_pattern->pattern_len; i++)
+ if (eth_pattern->mask[i / 8] & BIT(i % 8))
+ new_pattern.bytemask[i] = 0xff;
+
+ new_pattern.pattern_len = eth_pattern->pattern_len;
+ new_pattern.pkt_offset = eth_pattern->pkt_offset;
+ }
+
+ ret = ath12k_wmi_wow_add_pattern(ar, arvif->vdev_id,
+ pattern_id,
+ new_pattern.pattern,
+ new_pattern.bytemask,
+ new_pattern.pattern_len,
+ new_pattern.pkt_offset);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to add pattern %i to vdev %i: %d\n",
+ pattern_id,
+ arvif->vdev_id, ret);
+ return ret;
+ }
+
+ pattern_id++;
+ __set_bit(WOW_PATTERN_MATCH_EVENT, &wow_mask);
+ }
+
+ for (i = 0; i < WOW_EVENT_MAX; i++) {
+ if (!test_bit(i, &wow_mask))
+ continue;
+ ret = ath12k_wmi_wow_add_wakeup_event(ar, arvif->vdev_id, i, 1);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to enable wakeup event %s on vdev %i: %d\n",
+ wow_wakeup_event(i), arvif->vdev_id, ret);
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
+static int ath12k_wow_set_wakeups(struct ath12k *ar,
+ struct cfg80211_wowlan *wowlan)
+{
+ struct ath12k_vif *arvif;
+ int ret;
+
+ lockdep_assert_held(&ar->conf_mutex);
+
+ list_for_each_entry(arvif, &ar->arvifs, list) {
+ ret = ath12k_vif_wow_set_wakeups(arvif, wowlan);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to set wow wakeups on vdev %i: %d\n",
+ arvif->vdev_id, ret);
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
+int ath12k_wow_op_suspend(struct ieee80211_hw *hw,
+ struct cfg80211_wowlan *wowlan)
+{
+ struct ath12k_hw *ah = ath12k_hw_to_ah(hw);
+ struct ath12k *ar = ath12k_ah_to_ar(ah, 0);
+ int ret;
+
+ mutex_lock(&ar->conf_mutex);
+
+ ret = ath12k_wow_cleanup(ar);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to clear wow wakeup events: %d\n",
+ ret);
+ goto exit;
+ }
+
+ ret = ath12k_wow_set_wakeups(ar, wowlan);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to set wow wakeup events: %d\n",
+ ret);
+ goto cleanup;
+ }
+
+ ret = ath12k_mac_wait_tx_complete(ar);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to wait tx complete: %d\n", ret);
+ goto cleanup;
+ }
+
+ ret = ath12k_wow_enable(ar);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to start wow: %d\n", ret);
+ goto cleanup;
+ }
+
+ ath12k_hif_irq_disable(ar->ab);
+ ath12k_hif_ce_irq_disable(ar->ab);
+
+ ret = ath12k_hif_suspend(ar->ab);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to suspend hif: %d\n", ret);
+ goto wakeup;
+ }
+
+ goto exit;
+
+wakeup:
+ ath12k_wow_wakeup(ar);
+
+cleanup:
+ ath12k_wow_cleanup(ar);
+
+exit:
+ mutex_unlock(&ar->conf_mutex);
+ return ret ? 1 : 0;
+}
+
+void ath12k_wow_op_set_wakeup(struct ieee80211_hw *hw, bool enabled)
+{
+ struct ath12k_hw *ah = ath12k_hw_to_ah(hw);
+ struct ath12k *ar = ath12k_ah_to_ar(ah, 0);
+
+ mutex_lock(&ar->conf_mutex);
+ device_set_wakeup_enable(ar->ab->dev, enabled);
+ mutex_unlock(&ar->conf_mutex);
+}
+
+int ath12k_wow_op_resume(struct ieee80211_hw *hw)
+{
+ struct ath12k_hw *ah = ath12k_hw_to_ah(hw);
+ struct ath12k *ar = ath12k_ah_to_ar(ah, 0);
+ int ret;
+
+ mutex_lock(&ar->conf_mutex);
+
+ ret = ath12k_hif_resume(ar->ab);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to resume hif: %d\n", ret);
+ goto exit;
+ }
+
+ ath12k_hif_ce_irq_enable(ar->ab);
+ ath12k_hif_irq_enable(ar->ab);
+
+ ret = ath12k_wow_wakeup(ar);
+ if (ret)
+ ath12k_warn(ar->ab, "failed to wakeup from wow: %d\n", ret);
+
+exit:
+ if (ret) {
+ switch (ah->state) {
+ case ATH12K_HW_STATE_ON:
+ ah->state = ATH12K_HW_STATE_RESTARTING;
+ ret = 1;
+ break;
+ case ATH12K_HW_STATE_OFF:
+ case ATH12K_HW_STATE_RESTARTING:
+ case ATH12K_HW_STATE_RESTARTED:
+ case ATH12K_HW_STATE_WEDGED:
+ ath12k_warn(ar->ab, "encountered unexpected device state %d on resume, cannot recover\n",
+ ah->state);
+ ret = -EIO;
+ break;
+ }
+ }
+
+ mutex_unlock(&ar->conf_mutex);
+ return ret;
+}
+
+int ath12k_wow_init(struct ath12k *ar)
+{
+ if (WARN_ON(!test_bit(WMI_TLV_SERVICE_WOW, ar->wmi->wmi_ab->svc_map)))
+ return -EINVAL;
+
+ ar->wow.wowlan_support = ath12k_wowlan_support;
+
+ if (ar->ab->wow.wmi_conf_rx_decap_mode == ATH12K_HW_TXRX_NATIVE_WIFI) {
+ ar->wow.wowlan_support.pattern_max_len -= WOW_MAX_REDUCE;
+ ar->wow.wowlan_support.max_pkt_offset -= WOW_MAX_REDUCE;
+ }
+
+ ar->wow.max_num_patterns = ATH12K_WOW_PATTERNS;
+ ar->wow.wowlan_support.n_patterns = ar->wow.max_num_patterns;
+ ar->ah->hw->wiphy->wowlan = &ar->wow.wowlan_support;
+
+ device_set_wakeup_capable(ar->ab->dev, true);
+
+ return 0;
+}
diff --git a/drivers/net/wireless/ath/ath12k/wow.h b/drivers/net/wireless/ath/ath12k/wow.h
index 6817ceaa4cfe..af9be5fadcc3 100644
--- a/drivers/net/wireless/ath/ath12k/wow.h
+++ b/drivers/net/wireless/ath/ath12k/wow.h
@@ -9,14 +9,46 @@
#define ATH12K_WOW_RETRY_NUM 10
#define ATH12K_WOW_RETRY_WAIT_MS 200
+#define ATH12K_WOW_PATTERNS 22
+
+struct ath12k_wow {
+ u32 max_num_patterns;
+ struct completion wakeup_completed;
+ struct wiphy_wowlan_support wowlan_support;
+};
+
+struct ath12k_pkt_pattern {
+ u8 pattern[WOW_MAX_PATTERN_SIZE];
+ u8 bytemask[WOW_MAX_PATTERN_SIZE];
+ int pattern_len;
+ int pkt_offset;
+};
+
+struct rfc1042_hdr {
+ u8 llc_dsap;
+ u8 llc_ssap;
+ u8 llc_ctrl;
+ u8 snap_oui[3];
+ __be16 eth_type;
+} __packed;
#ifdef CONFIG_PM
+int ath12k_wow_init(struct ath12k *ar);
+int ath12k_wow_op_suspend(struct ieee80211_hw *hw,
+ struct cfg80211_wowlan *wowlan);
+int ath12k_wow_op_resume(struct ieee80211_hw *hw);
+void ath12k_wow_op_set_wakeup(struct ieee80211_hw *hw, bool enabled);
int ath12k_wow_enable(struct ath12k *ar);
int ath12k_wow_wakeup(struct ath12k *ar);
#else
+static inline int ath12k_wow_init(struct ath12k *ar)
+{
+ return 0;
+}
+
static inline int ath12k_wow_enable(struct ath12k *ar)
{
return 0;
--
2.25.1
^ permalink raw reply related [flat|nested] 25+ messages in thread* [PATCH v3 4/8] wifi: ath12k: add WoW net-detect functionality
2024-05-30 7:27 [PATCH v3 0/8] wifi: ath12k: add support for WoW Baochen Qiang
` (2 preceding siblings ...)
2024-05-30 7:27 ` [PATCH v3 3/8] wifi: ath12k: add basic WoW functionalities Baochen Qiang
@ 2024-05-30 7:27 ` Baochen Qiang
2024-06-20 11:10 ` Kalle Valo
2024-05-30 7:27 ` [PATCH v3 5/8] wifi: ath12k: implement hardware data filter Baochen Qiang
` (4 subsequent siblings)
8 siblings, 1 reply; 25+ messages in thread
From: Baochen Qiang @ 2024-05-30 7:27 UTC (permalink / raw)
To: ath12k; +Cc: linux-wireless, quic_bqiang
Implement net-detect feature by setting flag
WIPHY_WOWLAN_NET_DETECT if firmware supports this
feature. Driver sets the related PNO configuration
to firmware before entering WoW and firmware then
scans periodically and wakes up host if a specific
SSID is found.
Note that firmware crashes if we enable it for both
P2P vdev and station vdev simultaneously because
firmware can only support one vdev at a time. Since
there is rare scenario for a P2P vdev to do net-detect,
skip it for P2P vdevs.
Tested-on: WCN7850 hw2.0 PCI WLAN.HMT.1.0-03427-QCAHMTSWPL_V1.0_V2.0_SILICONZ-1.15378.4
Signed-off-by: Baochen Qiang <quic_bqiang@quicinc.com>
Acked-by: Jeff Johnson <quic_jjohnson@quicinc.com>
---
drivers/net/wireless/ath/ath12k/core.h | 2 +
drivers/net/wireless/ath/ath12k/mac.c | 12 ++
drivers/net/wireless/ath/ath12k/wmi.c | 144 ++++++++++++++++++
drivers/net/wireless/ath/ath12k/wmi.h | 169 +++++++++++++++++++++
drivers/net/wireless/ath/ath12k/wow.c | 199 ++++++++++++++++++++++++-
5 files changed, 523 insertions(+), 3 deletions(-)
diff --git a/drivers/net/wireless/ath/ath12k/core.h b/drivers/net/wireless/ath/ath12k/core.h
index 40b4f9b4d570..af5c489b9fd2 100644
--- a/drivers/net/wireless/ath/ath12k/core.h
+++ b/drivers/net/wireless/ath/ath12k/core.h
@@ -628,6 +628,8 @@ struct ath12k {
u32 freq_low;
u32 freq_high;
+
+ bool nlo_enabled;
};
struct ath12k_hw {
diff --git a/drivers/net/wireless/ath/ath12k/mac.c b/drivers/net/wireless/ath/ath12k/mac.c
index 43ee52524b3d..1d45692c3102 100644
--- a/drivers/net/wireless/ath/ath12k/mac.c
+++ b/drivers/net/wireless/ath/ath12k/mac.c
@@ -9064,6 +9064,18 @@ static int ath12k_mac_hw_register(struct ath12k_hw *ah)
ieee80211_hw_set(hw, SUPPORT_FAST_XMIT);
}
+ if (test_bit(WMI_TLV_SERVICE_NLO, ar->wmi->wmi_ab->svc_map)) {
+ wiphy->max_sched_scan_ssids = WMI_PNO_MAX_SUPP_NETWORKS;
+ wiphy->max_match_sets = WMI_PNO_MAX_SUPP_NETWORKS;
+ wiphy->max_sched_scan_ie_len = WMI_PNO_MAX_IE_LENGTH;
+ wiphy->max_sched_scan_plans = WMI_PNO_MAX_SCHED_SCAN_PLANS;
+ wiphy->max_sched_scan_plan_interval =
+ WMI_PNO_MAX_SCHED_SCAN_PLAN_INT;
+ wiphy->max_sched_scan_plan_iterations =
+ WMI_PNO_MAX_SCHED_SCAN_PLAN_ITRNS;
+ wiphy->features |= NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
+ }
+
ret = ath12k_wow_init(ar);
if (ret) {
ath12k_warn(ar->ab, "failed to init wow: %d\n", ret);
diff --git a/drivers/net/wireless/ath/ath12k/wmi.c b/drivers/net/wireless/ath/ath12k/wmi.c
index 7f3d4ce93cb4..63ce1c76b82c 100644
--- a/drivers/net/wireless/ath/ath12k/wmi.c
+++ b/drivers/net/wireless/ath/ath12k/wmi.c
@@ -7605,3 +7605,147 @@ int ath12k_wmi_wow_del_pattern(struct ath12k *ar, u32 vdev_id, u32 pattern_id)
return ath12k_wmi_cmd_send(ar->wmi, skb, WMI_WOW_DEL_WAKE_PATTERN_CMDID);
}
+
+static struct sk_buff *
+ath12k_wmi_op_gen_config_pno_start(struct ath12k *ar, u32 vdev_id,
+ struct wmi_pno_scan_req_arg *pno)
+{
+ struct nlo_configured_params *nlo_list;
+ size_t len, nlo_list_len, channel_list_len;
+ struct wmi_wow_nlo_config_cmd *cmd;
+ __le32 *channel_list;
+ struct wmi_tlv *tlv;
+ struct sk_buff *skb;
+ void *ptr;
+ u32 i;
+
+ len = sizeof(*cmd) +
+ sizeof(*tlv) +
+ /* TLV place holder for array of structures
+ * nlo_configured_params(nlo_list)
+ */
+ sizeof(*tlv);
+ /* TLV place holder for array of uint32 channel_list */
+
+ channel_list_len = sizeof(u32) * pno->a_networks[0].channel_count;
+ len += channel_list_len;
+
+ nlo_list_len = sizeof(*nlo_list) * pno->uc_networks_count;
+ len += nlo_list_len;
+
+ skb = ath12k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
+ if (!skb)
+ return ERR_PTR(-ENOMEM);
+
+ ptr = skb->data;
+ cmd = ptr;
+ cmd->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_NLO_CONFIG_CMD, sizeof(*cmd));
+
+ cmd->vdev_id = cpu_to_le32(pno->vdev_id);
+ cmd->flags = cpu_to_le32(WMI_NLO_CONFIG_START | WMI_NLO_CONFIG_SSID_HIDE_EN);
+
+ /* current FW does not support min-max range for dwell time */
+ cmd->active_dwell_time = cpu_to_le32(pno->active_max_time);
+ cmd->passive_dwell_time = cpu_to_le32(pno->passive_max_time);
+
+ if (pno->do_passive_scan)
+ cmd->flags |= cpu_to_le32(WMI_NLO_CONFIG_SCAN_PASSIVE);
+
+ cmd->fast_scan_period = cpu_to_le32(pno->fast_scan_period);
+ cmd->slow_scan_period = cpu_to_le32(pno->slow_scan_period);
+ cmd->fast_scan_max_cycles = cpu_to_le32(pno->fast_scan_max_cycles);
+ cmd->delay_start_time = cpu_to_le32(pno->delay_start_time);
+
+ if (pno->enable_pno_scan_randomization) {
+ cmd->flags |= cpu_to_le32(WMI_NLO_CONFIG_SPOOFED_MAC_IN_PROBE_REQ |
+ WMI_NLO_CONFIG_RANDOM_SEQ_NO_IN_PROBE_REQ);
+ ether_addr_copy(cmd->mac_addr.addr, pno->mac_addr);
+ ether_addr_copy(cmd->mac_mask.addr, pno->mac_addr_mask);
+ }
+
+ ptr += sizeof(*cmd);
+
+ /* nlo_configured_params(nlo_list) */
+ cmd->no_of_ssids = cpu_to_le32(pno->uc_networks_count);
+ tlv = ptr;
+ tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_STRUCT, nlo_list_len);
+
+ ptr += sizeof(*tlv);
+ nlo_list = ptr;
+ for (i = 0; i < pno->uc_networks_count; i++) {
+ tlv = (struct wmi_tlv *)(&nlo_list[i].tlv_header);
+ tlv->header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_ARRAY_BYTE,
+ sizeof(*nlo_list));
+
+ nlo_list[i].ssid.valid = cpu_to_le32(1);
+ nlo_list[i].ssid.ssid.ssid_len =
+ cpu_to_le32(pno->a_networks[i].ssid.ssid_len);
+ memcpy(nlo_list[i].ssid.ssid.ssid,
+ pno->a_networks[i].ssid.ssid,
+ le32_to_cpu(nlo_list[i].ssid.ssid.ssid_len));
+
+ if (pno->a_networks[i].rssi_threshold &&
+ pno->a_networks[i].rssi_threshold > -300) {
+ nlo_list[i].rssi_cond.valid = cpu_to_le32(1);
+ nlo_list[i].rssi_cond.rssi =
+ cpu_to_le32(pno->a_networks[i].rssi_threshold);
+ }
+
+ nlo_list[i].bcast_nw_type.valid = cpu_to_le32(1);
+ nlo_list[i].bcast_nw_type.bcast_nw_type =
+ cpu_to_le32(pno->a_networks[i].bcast_nw_type);
+ }
+
+ ptr += nlo_list_len;
+ cmd->num_of_channels = cpu_to_le32(pno->a_networks[0].channel_count);
+ tlv = ptr;
+ tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_UINT32, channel_list_len);
+ ptr += sizeof(*tlv);
+ channel_list = ptr;
+ for (i = 0; i < pno->a_networks[0].channel_count; i++)
+ channel_list[i] = cpu_to_le32(pno->a_networks[0].channels[i]);
+
+ ath12k_dbg(ar->ab, ATH12K_DBG_WMI, "wmi tlv start pno config vdev_id %d\n",
+ vdev_id);
+
+ return skb;
+}
+
+static struct sk_buff *ath12k_wmi_op_gen_config_pno_stop(struct ath12k *ar,
+ u32 vdev_id)
+{
+ struct wmi_wow_nlo_config_cmd *cmd;
+ struct sk_buff *skb;
+ size_t len;
+
+ len = sizeof(*cmd);
+ skb = ath12k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
+ if (!skb)
+ return ERR_PTR(-ENOMEM);
+
+ cmd = (struct wmi_wow_nlo_config_cmd *)skb->data;
+ cmd->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_NLO_CONFIG_CMD, len);
+
+ cmd->vdev_id = cpu_to_le32(vdev_id);
+ cmd->flags = cpu_to_le32(WMI_NLO_CONFIG_STOP);
+
+ ath12k_dbg(ar->ab, ATH12K_DBG_WMI,
+ "wmi tlv stop pno config vdev_id %d\n", vdev_id);
+ return skb;
+}
+
+int ath12k_wmi_wow_config_pno(struct ath12k *ar, u32 vdev_id,
+ struct wmi_pno_scan_req_arg *pno_scan)
+{
+ struct sk_buff *skb;
+
+ if (pno_scan->enable)
+ skb = ath12k_wmi_op_gen_config_pno_start(ar, vdev_id, pno_scan);
+ else
+ skb = ath12k_wmi_op_gen_config_pno_stop(ar, vdev_id);
+
+ if (IS_ERR_OR_NULL(skb))
+ return -ENOMEM;
+
+ return ath12k_wmi_cmd_send(ar->wmi, skb, WMI_NETWORK_LIST_OFFLOAD_CONFIG_CMDID);
+}
diff --git a/drivers/net/wireless/ath/ath12k/wmi.h b/drivers/net/wireless/ath/ath12k/wmi.h
index 6cb06f6f7df4..6e5d9a25255e 100644
--- a/drivers/net/wireless/ath/ath12k/wmi.h
+++ b/drivers/net/wireless/ath/ath12k/wmi.h
@@ -5130,6 +5130,173 @@ struct wmi_wow_ev_arg {
enum wmi_wow_wake_reason wake_reason;
};
+#define WMI_PNO_MAX_SCHED_SCAN_PLANS 2
+#define WMI_PNO_MAX_SCHED_SCAN_PLAN_INT 7200
+#define WMI_PNO_MAX_SCHED_SCAN_PLAN_ITRNS 100
+#define WMI_PNO_MAX_NETW_CHANNELS 26
+#define WMI_PNO_MAX_NETW_CHANNELS_EX 60
+#define WMI_PNO_MAX_SUPP_NETWORKS WLAN_SCAN_PARAMS_MAX_SSID
+#define WMI_PNO_MAX_IE_LENGTH WLAN_SCAN_PARAMS_MAX_IE_LEN
+
+/* size based of dot11 declaration without extra IEs as we will not carry those for PNO */
+#define WMI_PNO_MAX_PB_REQ_SIZE 450
+
+#define WMI_PNO_24GHZ_DEFAULT_CH 1
+#define WMI_PNO_5GHZ_DEFAULT_CH 36
+
+#define WMI_ACTIVE_MAX_CHANNEL_TIME 40
+#define WMI_PASSIVE_MAX_CHANNEL_TIME 110
+
+/* SSID broadcast type */
+enum wmi_ssid_bcast_type {
+ BCAST_UNKNOWN = 0,
+ BCAST_NORMAL = 1,
+ BCAST_HIDDEN = 2,
+};
+
+#define WMI_NLO_MAX_SSIDS 16
+#define WMI_NLO_MAX_CHAN 48
+
+#define WMI_NLO_CONFIG_STOP BIT(0)
+#define WMI_NLO_CONFIG_START BIT(1)
+#define WMI_NLO_CONFIG_RESET BIT(2)
+#define WMI_NLO_CONFIG_SLOW_SCAN BIT(4)
+#define WMI_NLO_CONFIG_FAST_SCAN BIT(5)
+#define WMI_NLO_CONFIG_SSID_HIDE_EN BIT(6)
+
+/* This bit is used to indicate if EPNO or supplicant PNO is enabled.
+ * Only one of them can be enabled at a given time
+ */
+#define WMI_NLO_CONFIG_ENLO BIT(7)
+#define WMI_NLO_CONFIG_SCAN_PASSIVE BIT(8)
+#define WMI_NLO_CONFIG_ENLO_RESET BIT(9)
+#define WMI_NLO_CONFIG_SPOOFED_MAC_IN_PROBE_REQ BIT(10)
+#define WMI_NLO_CONFIG_RANDOM_SEQ_NO_IN_PROBE_REQ BIT(11)
+#define WMI_NLO_CONFIG_ENABLE_IE_WHITELIST_IN_PROBE_REQ BIT(12)
+#define WMI_NLO_CONFIG_ENABLE_CNLO_RSSI_CONFIG BIT(13)
+
+struct wmi_nlo_ssid_params {
+ __le32 valid;
+ struct ath12k_wmi_ssid_params ssid;
+} __packed;
+
+struct wmi_nlo_enc_params {
+ __le32 valid;
+ __le32 enc_type;
+} __packed;
+
+struct wmi_nlo_auth_params {
+ __le32 valid;
+ __le32 auth_type;
+} __packed;
+
+struct wmi_nlo_bcast_nw_params {
+ __le32 valid;
+ __le32 bcast_nw_type;
+} __packed;
+
+struct wmi_nlo_rssi_params {
+ __le32 valid;
+ __le32 rssi;
+} __packed;
+
+struct nlo_configured_params {
+ /* TLV tag and len;*/
+ __le32 tlv_header;
+ struct wmi_nlo_ssid_params ssid;
+ struct wmi_nlo_enc_params enc_type;
+ struct wmi_nlo_auth_params auth_type;
+ struct wmi_nlo_rssi_params rssi_cond;
+
+ /* indicates if the SSID is hidden or not */
+ struct wmi_nlo_bcast_nw_params bcast_nw_type;
+} __packed;
+
+struct wmi_network_type_arg {
+ struct cfg80211_ssid ssid;
+ u32 authentication;
+ u32 encryption;
+ u32 bcast_nw_type;
+ u8 channel_count;
+ u16 channels[WMI_PNO_MAX_NETW_CHANNELS_EX];
+ s32 rssi_threshold;
+};
+
+struct wmi_pno_scan_req_arg {
+ u8 enable;
+ u8 vdev_id;
+ u8 uc_networks_count;
+ struct wmi_network_type_arg a_networks[WMI_PNO_MAX_SUPP_NETWORKS];
+ u32 fast_scan_period;
+ u32 slow_scan_period;
+ u8 fast_scan_max_cycles;
+
+ bool do_passive_scan;
+
+ u32 delay_start_time;
+ u32 active_min_time;
+ u32 active_max_time;
+ u32 passive_min_time;
+ u32 passive_max_time;
+
+ /* mac address randomization attributes */
+ u32 enable_pno_scan_randomization;
+ u8 mac_addr[ETH_ALEN];
+ u8 mac_addr_mask[ETH_ALEN];
+};
+
+struct wmi_wow_nlo_config_cmd {
+ __le32 tlv_header;
+ __le32 flags;
+ __le32 vdev_id;
+ __le32 fast_scan_max_cycles;
+ __le32 active_dwell_time;
+ __le32 passive_dwell_time;
+ __le32 probe_bundle_size;
+
+ /* ART = IRT */
+ __le32 rest_time;
+
+ /* Max value that can be reached after SBM */
+ __le32 max_rest_time;
+
+ /* SBM */
+ __le32 scan_backoff_multiplier;
+
+ /* SCBM */
+ __le32 fast_scan_period;
+
+ /* specific to windows */
+ __le32 slow_scan_period;
+
+ __le32 no_of_ssids;
+
+ __le32 num_of_channels;
+
+ /* NLO scan start delay time in milliseconds */
+ __le32 delay_start_time;
+
+ /* MAC Address to use in Probe Req as SA */
+ struct ath12k_wmi_mac_addr_params mac_addr;
+
+ /* Mask on which MAC has to be randomized */
+ struct ath12k_wmi_mac_addr_params mac_mask;
+
+ /* IE bitmap to use in Probe Req */
+ __le32 ie_bitmap[8];
+
+ /* Number of vendor OUIs. In the TLV vendor_oui[] */
+ __le32 num_vendor_oui;
+
+ /* Number of connected NLO band preferences */
+ __le32 num_cnlo_band_pref;
+
+ /* The TLVs will follow.
+ * nlo_configured_params nlo_list[];
+ * u32 channel_list[num_of_channels];
+ */
+} __packed;
+
void ath12k_wmi_init_qcn9274(struct ath12k_base *ab,
struct ath12k_wmi_resource_config_arg *config);
void ath12k_wmi_init_wcn7850(struct ath12k_base *ab,
@@ -5291,4 +5458,6 @@ int ath12k_wmi_wow_add_pattern(struct ath12k *ar, u32 vdev_id, u32 pattern_id,
int ath12k_wmi_wow_add_wakeup_event(struct ath12k *ar, u32 vdev_id,
enum wmi_wow_wakeup_event event,
u32 enable);
+int ath12k_wmi_wow_config_pno(struct ath12k *ar, u32 vdev_id,
+ struct wmi_pno_scan_req_arg *pno_scan);
#endif
diff --git a/drivers/net/wireless/ath/ath12k/wow.c b/drivers/net/wireless/ath/ath12k/wow.c
index 2965c9ad2462..330bd39f75c0 100644
--- a/drivers/net/wireless/ath/ath12k/wow.c
+++ b/drivers/net/wireless/ath/ath12k/wow.c
@@ -23,6 +23,13 @@ static const struct wiphy_wowlan_support ath12k_wowlan_support = {
.max_pkt_offset = WOW_MAX_PKT_OFFSET,
};
+static inline bool ath12k_wow_is_p2p_vdev(struct ath12k_vif *arvif)
+{
+ return (arvif->vdev_subtype == WMI_VDEV_SUBTYPE_P2P_DEVICE ||
+ arvif->vdev_subtype == WMI_VDEV_SUBTYPE_P2P_CLIENT ||
+ arvif->vdev_subtype == WMI_VDEV_SUBTYPE_P2P_GO);
+}
+
int ath12k_wow_enable(struct ath12k *ar)
{
struct ath12k_base *ab = ar->ab;
@@ -242,7 +249,103 @@ ath12k_wow_convert_8023_to_80211(struct ath12k *ar,
i80211_pattern->pkt_offset = pkt_ofs;
}
-static int ath12k_vif_wow_set_wakeups(struct ath12k_vif *arvif,
+static int
+ath12k_wow_pno_check_and_convert(struct ath12k *ar, u32 vdev_id,
+ const struct cfg80211_sched_scan_request *nd_config,
+ struct wmi_pno_scan_req_arg *pno)
+{
+ int i, j;
+ u8 ssid_len;
+
+ pno->enable = 1;
+ pno->vdev_id = vdev_id;
+ pno->uc_networks_count = nd_config->n_match_sets;
+
+ if (!pno->uc_networks_count ||
+ pno->uc_networks_count > WMI_PNO_MAX_SUPP_NETWORKS)
+ return -EINVAL;
+
+ if (nd_config->n_channels > WMI_PNO_MAX_NETW_CHANNELS_EX)
+ return -EINVAL;
+
+ /* Filling per profile params */
+ for (i = 0; i < pno->uc_networks_count; i++) {
+ ssid_len = nd_config->match_sets[i].ssid.ssid_len;
+
+ if (ssid_len == 0 || ssid_len > 32)
+ return -EINVAL;
+
+ pno->a_networks[i].ssid.ssid_len = ssid_len;
+
+ memcpy(pno->a_networks[i].ssid.ssid,
+ nd_config->match_sets[i].ssid.ssid,
+ ssid_len);
+ pno->a_networks[i].authentication = 0;
+ pno->a_networks[i].encryption = 0;
+ pno->a_networks[i].bcast_nw_type = 0;
+
+ /* Copying list of valid channel into request */
+ pno->a_networks[i].channel_count = nd_config->n_channels;
+ pno->a_networks[i].rssi_threshold = nd_config->match_sets[i].rssi_thold;
+
+ for (j = 0; j < nd_config->n_channels; j++) {
+ pno->a_networks[i].channels[j] =
+ nd_config->channels[j]->center_freq;
+ }
+ }
+
+ /* set scan to passive if no SSIDs are specified in the request */
+ if (nd_config->n_ssids == 0)
+ pno->do_passive_scan = true;
+ else
+ pno->do_passive_scan = false;
+
+ for (i = 0; i < nd_config->n_ssids; i++) {
+ j = 0;
+ while (j < pno->uc_networks_count) {
+ if (pno->a_networks[j].ssid.ssid_len ==
+ nd_config->ssids[i].ssid_len &&
+ !memcmp(pno->a_networks[j].ssid.ssid,
+ nd_config->ssids[i].ssid,
+ pno->a_networks[j].ssid.ssid_len)) {
+ pno->a_networks[j].bcast_nw_type = BCAST_HIDDEN;
+ break;
+ }
+ j++;
+ }
+ }
+
+ if (nd_config->n_scan_plans == 2) {
+ pno->fast_scan_period = nd_config->scan_plans[0].interval * MSEC_PER_SEC;
+ pno->fast_scan_max_cycles = nd_config->scan_plans[0].iterations;
+ pno->slow_scan_period =
+ nd_config->scan_plans[1].interval * MSEC_PER_SEC;
+ } else if (nd_config->n_scan_plans == 1) {
+ pno->fast_scan_period = nd_config->scan_plans[0].interval * MSEC_PER_SEC;
+ pno->fast_scan_max_cycles = 1;
+ pno->slow_scan_period = nd_config->scan_plans[0].interval * MSEC_PER_SEC;
+ } else {
+ ath12k_warn(ar->ab, "Invalid number of scan plans %d !!",
+ nd_config->n_scan_plans);
+ }
+
+ if (nd_config->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
+ /* enable mac randomization */
+ pno->enable_pno_scan_randomization = 1;
+ memcpy(pno->mac_addr, nd_config->mac_addr, ETH_ALEN);
+ memcpy(pno->mac_addr_mask, nd_config->mac_addr_mask, ETH_ALEN);
+ }
+
+ pno->delay_start_time = nd_config->delay;
+
+ /* Current FW does not support min-max range for dwell time */
+ pno->active_max_time = WMI_ACTIVE_MAX_CHANNEL_TIME;
+ pno->passive_max_time = WMI_PASSIVE_MAX_CHANNEL_TIME;
+
+ return 0;
+}
+
+static int ath12k_wow_vif_set_wakeups(struct ath12k_vif *arvif,
struct cfg80211_wowlan *wowlan)
{
const struct cfg80211_pkt_pattern *patterns = wowlan->patterns;
@@ -275,6 +378,26 @@ static int ath12k_vif_wow_set_wakeups(struct ath12k_vif *arvif,
if (wowlan->magic_pkt)
__set_bit(WOW_MAGIC_PKT_RECVD_EVENT, &wow_mask);
+
+ if (wowlan->nd_config) {
+ struct wmi_pno_scan_req_arg *pno;
+ int ret;
+
+ pno = kzalloc(sizeof(*pno), GFP_KERNEL);
+ if (!pno)
+ return -ENOMEM;
+
+ ar->nlo_enabled = true;
+
+ ret = ath12k_wow_pno_check_and_convert(ar, arvif->vdev_id,
+ wowlan->nd_config, pno);
+ if (!ret) {
+ ath12k_wmi_wow_config_pno(ar, arvif->vdev_id, pno);
+ __set_bit(WOW_NLO_DETECTED_EVENT, &wow_mask);
+ }
+
+ kfree(pno);
+ }
break;
default:
break;
@@ -347,7 +470,9 @@ static int ath12k_wow_set_wakeups(struct ath12k *ar,
lockdep_assert_held(&ar->conf_mutex);
list_for_each_entry(arvif, &ar->arvifs, list) {
- ret = ath12k_vif_wow_set_wakeups(arvif, wowlan);
+ if (ath12k_wow_is_p2p_vdev(arvif))
+ continue;
+ ret = ath12k_wow_vif_set_wakeups(arvif, wowlan);
if (ret) {
ath12k_warn(ar->ab, "failed to set wow wakeups on vdev %i: %d\n",
arvif->vdev_id, ret);
@@ -358,6 +483,61 @@ static int ath12k_wow_set_wakeups(struct ath12k *ar,
return 0;
}
+static int ath12k_wow_vdev_clean_nlo(struct ath12k *ar, u32 vdev_id)
+{
+ int ret = 0;
+
+ if (ar->nlo_enabled) {
+ struct wmi_pno_scan_req_arg *pno =
+ kzalloc(sizeof(*pno), GFP_KERNEL);
+ if (!pno)
+ return -ENOMEM;
+
+ pno->enable = 0;
+ ar->nlo_enabled = false;
+ ret = ath12k_wmi_wow_config_pno(ar, vdev_id, pno);
+ kfree(pno);
+ }
+
+ return ret;
+}
+
+static int ath12k_wow_vif_clean_nlo(struct ath12k_vif *arvif)
+{
+ struct ath12k *ar = arvif->ar;
+ int ret = 0;
+
+ switch (arvif->vdev_type) {
+ case WMI_VDEV_TYPE_STA:
+ ret = ath12k_wow_vdev_clean_nlo(ar, arvif->vdev_id);
+ break;
+ default:
+ break;
+ }
+ return ret;
+}
+
+static int ath12k_wow_nlo_cleanup(struct ath12k *ar)
+{
+ struct ath12k_vif *arvif;
+ int ret;
+
+ lockdep_assert_held(&ar->conf_mutex);
+
+ list_for_each_entry(arvif, &ar->arvifs, list) {
+ if (ath12k_wow_is_p2p_vdev(arvif))
+ continue;
+ ret = ath12k_wow_vif_clean_nlo(arvif);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to clean nlo settings on vdev %i: %d\n",
+ arvif->vdev_id, ret);
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
int ath12k_wow_op_suspend(struct ieee80211_hw *hw,
struct cfg80211_wowlan *wowlan)
{
@@ -443,8 +623,16 @@ int ath12k_wow_op_resume(struct ieee80211_hw *hw)
ath12k_hif_irq_enable(ar->ab);
ret = ath12k_wow_wakeup(ar);
- if (ret)
+ if (ret) {
ath12k_warn(ar->ab, "failed to wakeup from wow: %d\n", ret);
+ goto exit;
+ }
+
+ ret = ath12k_wow_nlo_cleanup(ar);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to cleanup nlo: %d\n", ret);
+ goto exit;
+ }
exit:
if (ret) {
@@ -480,6 +668,11 @@ int ath12k_wow_init(struct ath12k *ar)
ar->wow.wowlan_support.max_pkt_offset -= WOW_MAX_REDUCE;
}
+ if (test_bit(WMI_TLV_SERVICE_NLO, ar->wmi->wmi_ab->svc_map)) {
+ ar->wow.wowlan_support.flags |= WIPHY_WOWLAN_NET_DETECT;
+ ar->wow.wowlan_support.max_nd_match_sets = WMI_PNO_MAX_SUPP_NETWORKS;
+ }
+
ar->wow.max_num_patterns = ATH12K_WOW_PATTERNS;
ar->wow.wowlan_support.n_patterns = ar->wow.max_num_patterns;
ar->ah->hw->wiphy->wowlan = &ar->wow.wowlan_support;
--
2.25.1
^ permalink raw reply related [flat|nested] 25+ messages in thread* Re: [PATCH v3 4/8] wifi: ath12k: add WoW net-detect functionality
2024-05-30 7:27 ` [PATCH v3 4/8] wifi: ath12k: add WoW net-detect functionality Baochen Qiang
@ 2024-06-20 11:10 ` Kalle Valo
2024-06-21 5:26 ` Baochen Qiang
0 siblings, 1 reply; 25+ messages in thread
From: Kalle Valo @ 2024-06-20 11:10 UTC (permalink / raw)
To: Baochen Qiang; +Cc: ath12k, linux-wireless
Baochen Qiang <quic_bqiang@quicinc.com> writes:
> Implement net-detect feature by setting flag
> WIPHY_WOWLAN_NET_DETECT if firmware supports this
> feature. Driver sets the related PNO configuration
> to firmware before entering WoW and firmware then
> scans periodically and wakes up host if a specific
> SSID is found.
>
> Note that firmware crashes if we enable it for both
> P2P vdev and station vdev simultaneously because
> firmware can only support one vdev at a time. Since
> there is rare scenario for a P2P vdev to do net-detect,
> skip it for P2P vdevs.
>
> Tested-on: WCN7850 hw2.0 PCI
> WLAN.HMT.1.0-03427-QCAHMTSWPL_V1.0_V2.0_SILICONZ-1.15378.4
>
> Signed-off-by: Baochen Qiang <quic_bqiang@quicinc.com>
[...]
> +struct wmi_wow_nlo_config_cmd {
> + __le32 tlv_header;
> + __le32 flags;
> + __le32 vdev_id;
> + __le32 fast_scan_max_cycles;
> + __le32 active_dwell_time;
> + __le32 passive_dwell_time;
> + __le32 probe_bundle_size;
> +
> + /* ART = IRT */
> + __le32 rest_time;
What's ART and IRT in this context? The comments are supposed to answer
to questions but this is just adding more questions.
> +
> + /* Max value that can be reached after SBM */
> + __le32 max_rest_time;
It's good to avoid acronyms so I changed this to:
/* max value that can be reached after scan_backoff_multiplier */
__le32 max_rest_time;
> + /* SBM */
> + __le32 scan_backoff_multiplier;
> +
> + /* SCBM */
> + __le32 fast_scan_period;
These two comments are not really providing any extra information I
removed them.
> +static int
> +ath12k_wow_pno_check_and_convert(struct ath12k *ar, u32 vdev_id,
> + const struct cfg80211_sched_scan_request *nd_config,
> + struct wmi_pno_scan_req_arg *pno)
> +{
> + int i, j;
> + u8 ssid_len;
> +
> + pno->enable = 1;
> + pno->vdev_id = vdev_id;
> + pno->uc_networks_count = nd_config->n_match_sets;
> +
> + if (!pno->uc_networks_count ||
> + pno->uc_networks_count > WMI_PNO_MAX_SUPP_NETWORKS)
> + return -EINVAL;
> +
> + if (nd_config->n_channels > WMI_PNO_MAX_NETW_CHANNELS_EX)
> + return -EINVAL;
> +
> + /* Filling per profile params */
> + for (i = 0; i < pno->uc_networks_count; i++) {
> + ssid_len = nd_config->match_sets[i].ssid.ssid_len;
> +
> + if (ssid_len == 0 || ssid_len > 32)
> + return -EINVAL;
> +
> + pno->a_networks[i].ssid.ssid_len = ssid_len;
> +
> + memcpy(pno->a_networks[i].ssid.ssid,
> + nd_config->match_sets[i].ssid.ssid,
> + ssid_len);
> + pno->a_networks[i].authentication = 0;
> + pno->a_networks[i].encryption = 0;
> + pno->a_networks[i].bcast_nw_type = 0;
> +
> + /* Copying list of valid channel into request */
> + pno->a_networks[i].channel_count = nd_config->n_channels;
> + pno->a_networks[i].rssi_threshold = nd_config->match_sets[i].rssi_thold;
> +
> + for (j = 0; j < nd_config->n_channels; j++) {
> + pno->a_networks[i].channels[j] =
> + nd_config->channels[j]->center_freq;
> + }
> + }
> +
> + /* set scan to passive if no SSIDs are specified in the request */
> + if (nd_config->n_ssids == 0)
> + pno->do_passive_scan = true;
> + else
> + pno->do_passive_scan = false;
> +
> + for (i = 0; i < nd_config->n_ssids; i++) {
> + j = 0;
> + while (j < pno->uc_networks_count) {
> + if (pno->a_networks[j].ssid.ssid_len ==
> + nd_config->ssids[i].ssid_len &&
> + !memcmp(pno->a_networks[j].ssid.ssid,
> + nd_config->ssids[i].ssid,
> + pno->a_networks[j].ssid.ssid_len)) {
> + pno->a_networks[j].bcast_nw_type = BCAST_HIDDEN;
> + break;
> + }
> + j++;
> + }
> + }
The while loop is just a simple for loop so I changed it to use for statement.
> +
> + if (nd_config->n_scan_plans == 2) {
> + pno->fast_scan_period = nd_config->scan_plans[0].interval * MSEC_PER_SEC;
> + pno->fast_scan_max_cycles = nd_config->scan_plans[0].iterations;
> + pno->slow_scan_period =
> + nd_config->scan_plans[1].interval * MSEC_PER_SEC;
> + } else if (nd_config->n_scan_plans == 1) {
> + pno->fast_scan_period = nd_config->scan_plans[0].interval * MSEC_PER_SEC;
> + pno->fast_scan_max_cycles = 1;
> + pno->slow_scan_period = nd_config->scan_plans[0].interval * MSEC_PER_SEC;
> + } else {
> + ath12k_warn(ar->ab, "Invalid number of scan plans %d !!",
> + nd_config->n_scan_plans);
> + }
I cleaned up the error message here.
> +static int ath12k_wow_vdev_clean_nlo(struct ath12k *ar, u32 vdev_id)
> +{
> + int ret = 0;
> +
> + if (ar->nlo_enabled) {
> + struct wmi_pno_scan_req_arg *pno =
> + kzalloc(sizeof(*pno), GFP_KERNEL);
> + if (!pno)
> + return -ENOMEM;
> +
> + pno->enable = 0;
> + ar->nlo_enabled = false;
> + ret = ath12k_wmi_wow_config_pno(ar, vdev_id, pno);
> + kfree(pno);
> + }
> +
> + return ret;
> +}
Avoid initialising ret variables and minimise the indentation. I changed
this to:
static int ath12k_wow_vdev_clean_nlo(struct ath12k *ar, u32 vdev_id)
{
struct wmi_pno_scan_req_arg *pno;
int ret;
if (!ar->nlo_enabled)
return 0;
pno = kzalloc(sizeof(*pno), GFP_KERNEL);
if (!pno)
return -ENOMEM;
pno->enable = 0;
ret = ath12k_wmi_wow_config_pno(ar, vdev_id, pno);
if (ret) {
ath12k_warn(ar->ab, "failed to disable PNO: %d", ret);
goto out;
}
ar->nlo_enabled = false;
out:
kfree(pno);
return ret;
}
> +static int ath12k_wow_vif_clean_nlo(struct ath12k_vif *arvif)
> +{
> + struct ath12k *ar = arvif->ar;
> + int ret = 0;
> +
> + switch (arvif->vdev_type) {
> + case WMI_VDEV_TYPE_STA:
> + ret = ath12k_wow_vdev_clean_nlo(ar, arvif->vdev_id);
> + break;
> + default:
> + break;
> + }
> + return ret;
> +}
ret variable is not really needed:
static int ath12k_wow_vif_clean_nlo(struct ath12k_vif *arvif)
{
struct ath12k *ar = arvif->ar;
switch (arvif->vdev_type) {
case WMI_VDEV_TYPE_STA:
return ath12k_wow_vdev_clean_nlo(ar, arvif->vdev_id);
default:
return 0;
}
}
In the pending branch I did also some minor cosmetic changes to this and
earlier patches, too many to list here.
--
https://patchwork.kernel.org/project/linux-wireless/list/
https://wireless.wiki.kernel.org/en/developers/documentation/submittingpatches
^ permalink raw reply [flat|nested] 25+ messages in thread* Re: [PATCH v3 4/8] wifi: ath12k: add WoW net-detect functionality
2024-06-20 11:10 ` Kalle Valo
@ 2024-06-21 5:26 ` Baochen Qiang
0 siblings, 0 replies; 25+ messages in thread
From: Baochen Qiang @ 2024-06-21 5:26 UTC (permalink / raw)
To: Kalle Valo; +Cc: ath12k, linux-wireless
On 6/20/2024 7:10 PM, Kalle Valo wrote:
> Baochen Qiang <quic_bqiang@quicinc.com> writes:
>
>> Implement net-detect feature by setting flag
>> WIPHY_WOWLAN_NET_DETECT if firmware supports this
>> feature. Driver sets the related PNO configuration
>> to firmware before entering WoW and firmware then
>> scans periodically and wakes up host if a specific
>> SSID is found.
>>
>> Note that firmware crashes if we enable it for both
>> P2P vdev and station vdev simultaneously because
>> firmware can only support one vdev at a time. Since
>> there is rare scenario for a P2P vdev to do net-detect,
>> skip it for P2P vdevs.
>>
>> Tested-on: WCN7850 hw2.0 PCI
>> WLAN.HMT.1.0-03427-QCAHMTSWPL_V1.0_V2.0_SILICONZ-1.15378.4
>>
>> Signed-off-by: Baochen Qiang <quic_bqiang@quicinc.com>
>
> [...]
>
>> +struct wmi_wow_nlo_config_cmd {
>> + __le32 tlv_header;
>> + __le32 flags;
>> + __le32 vdev_id;
>> + __le32 fast_scan_max_cycles;
>> + __le32 active_dwell_time;
>> + __le32 passive_dwell_time;
>> + __le32 probe_bundle_size;
>> +
>> + /* ART = IRT */
>> + __le32 rest_time;
>
> What's ART and IRT in this context? The comments are supposed to answer
> to questions but this is just adding more questions.
>
>> +
>> + /* Max value that can be reached after SBM */
>> + __le32 max_rest_time;
>
> It's good to avoid acronyms so I changed this to:
>
> /* max value that can be reached after scan_backoff_multiplier */
> __le32 max_rest_time;
>
>> + /* SBM */
>> + __le32 scan_backoff_multiplier;
>> +
>> + /* SCBM */
>> + __le32 fast_scan_period;
>
> These two comments are not really providing any extra information I
> removed them.
>
>> +static int
>> +ath12k_wow_pno_check_and_convert(struct ath12k *ar, u32 vdev_id,
>> + const struct cfg80211_sched_scan_request *nd_config,
>> + struct wmi_pno_scan_req_arg *pno)
>> +{
>> + int i, j;
>> + u8 ssid_len;
>> +
>> + pno->enable = 1;
>> + pno->vdev_id = vdev_id;
>> + pno->uc_networks_count = nd_config->n_match_sets;
>> +
>> + if (!pno->uc_networks_count ||
>> + pno->uc_networks_count > WMI_PNO_MAX_SUPP_NETWORKS)
>> + return -EINVAL;
>> +
>> + if (nd_config->n_channels > WMI_PNO_MAX_NETW_CHANNELS_EX)
>> + return -EINVAL;
>> +
>> + /* Filling per profile params */
>> + for (i = 0; i < pno->uc_networks_count; i++) {
>> + ssid_len = nd_config->match_sets[i].ssid.ssid_len;
>> +
>> + if (ssid_len == 0 || ssid_len > 32)
>> + return -EINVAL;
>> +
>> + pno->a_networks[i].ssid.ssid_len = ssid_len;
>> +
>> + memcpy(pno->a_networks[i].ssid.ssid,
>> + nd_config->match_sets[i].ssid.ssid,
>> + ssid_len);
>> + pno->a_networks[i].authentication = 0;
>> + pno->a_networks[i].encryption = 0;
>> + pno->a_networks[i].bcast_nw_type = 0;
>> +
>> + /* Copying list of valid channel into request */
>> + pno->a_networks[i].channel_count = nd_config->n_channels;
>> + pno->a_networks[i].rssi_threshold = nd_config->match_sets[i].rssi_thold;
>> +
>> + for (j = 0; j < nd_config->n_channels; j++) {
>> + pno->a_networks[i].channels[j] =
>> + nd_config->channels[j]->center_freq;
>> + }
>> + }
>> +
>> + /* set scan to passive if no SSIDs are specified in the request */
>> + if (nd_config->n_ssids == 0)
>> + pno->do_passive_scan = true;
>> + else
>> + pno->do_passive_scan = false;
>> +
>> + for (i = 0; i < nd_config->n_ssids; i++) {
>> + j = 0;
>> + while (j < pno->uc_networks_count) {
>> + if (pno->a_networks[j].ssid.ssid_len ==
>> + nd_config->ssids[i].ssid_len &&
>> + !memcmp(pno->a_networks[j].ssid.ssid,
>> + nd_config->ssids[i].ssid,
>> + pno->a_networks[j].ssid.ssid_len)) {
>> + pno->a_networks[j].bcast_nw_type = BCAST_HIDDEN;
>> + break;
>> + }
>> + j++;
>> + }
>> + }
>
> The while loop is just a simple for loop so I changed it to use for statement.
>
>> +
>> + if (nd_config->n_scan_plans == 2) {
>> + pno->fast_scan_period = nd_config->scan_plans[0].interval * MSEC_PER_SEC;
>> + pno->fast_scan_max_cycles = nd_config->scan_plans[0].iterations;
>> + pno->slow_scan_period =
>> + nd_config->scan_plans[1].interval * MSEC_PER_SEC;
>> + } else if (nd_config->n_scan_plans == 1) {
>> + pno->fast_scan_period = nd_config->scan_plans[0].interval * MSEC_PER_SEC;
>> + pno->fast_scan_max_cycles = 1;
>> + pno->slow_scan_period = nd_config->scan_plans[0].interval * MSEC_PER_SEC;
>> + } else {
>> + ath12k_warn(ar->ab, "Invalid number of scan plans %d !!",
>> + nd_config->n_scan_plans);
>> + }
>
> I cleaned up the error message here.
>
>> +static int ath12k_wow_vdev_clean_nlo(struct ath12k *ar, u32 vdev_id)
>> +{
>> + int ret = 0;
>> +
>> + if (ar->nlo_enabled) {
>> + struct wmi_pno_scan_req_arg *pno =
>> + kzalloc(sizeof(*pno), GFP_KERNEL);
>> + if (!pno)
>> + return -ENOMEM;
>> +
>> + pno->enable = 0;
>> + ar->nlo_enabled = false;
>> + ret = ath12k_wmi_wow_config_pno(ar, vdev_id, pno);
>> + kfree(pno);
>> + }
>> +
>> + return ret;
>> +}
>
> Avoid initialising ret variables and minimise the indentation. I changed
> this to:
>
> static int ath12k_wow_vdev_clean_nlo(struct ath12k *ar, u32 vdev_id)
> {
> struct wmi_pno_scan_req_arg *pno;
> int ret;
>
> if (!ar->nlo_enabled)
> return 0;
>
> pno = kzalloc(sizeof(*pno), GFP_KERNEL);
> if (!pno)
> return -ENOMEM;
>
> pno->enable = 0;
> ret = ath12k_wmi_wow_config_pno(ar, vdev_id, pno);
> if (ret) {
> ath12k_warn(ar->ab, "failed to disable PNO: %d", ret);
> goto out;
> }
>
> ar->nlo_enabled = false;
>
> out:
> kfree(pno);
> return ret;
> }
>
>> +static int ath12k_wow_vif_clean_nlo(struct ath12k_vif *arvif)
>> +{
>> + struct ath12k *ar = arvif->ar;
>> + int ret = 0;
>> +
>> + switch (arvif->vdev_type) {
>> + case WMI_VDEV_TYPE_STA:
>> + ret = ath12k_wow_vdev_clean_nlo(ar, arvif->vdev_id);
>> + break;
>> + default:
>> + break;
>> + }
>> + return ret;
>> +}
>
> ret variable is not really needed:
>
> static int ath12k_wow_vif_clean_nlo(struct ath12k_vif *arvif)
> {
> struct ath12k *ar = arvif->ar;
>
> switch (arvif->vdev_type) {
> case WMI_VDEV_TYPE_STA:
> return ath12k_wow_vdev_clean_nlo(ar, arvif->vdev_id);
> default:
> return 0;
> }
> }
>
> In the pending branch I did also some minor cosmetic changes to this and
> earlier patches, too many to list here.
Thanks. All these changes look OK to me.
>
^ permalink raw reply [flat|nested] 25+ messages in thread
* [PATCH v3 5/8] wifi: ath12k: implement hardware data filter
2024-05-30 7:27 [PATCH v3 0/8] wifi: ath12k: add support for WoW Baochen Qiang
` (3 preceding siblings ...)
2024-05-30 7:27 ` [PATCH v3 4/8] wifi: ath12k: add WoW net-detect functionality Baochen Qiang
@ 2024-05-30 7:27 ` Baochen Qiang
2024-05-30 7:27 ` [PATCH v3 6/8] wifi: ath12k: support ARP and NS offload Baochen Qiang
` (3 subsequent siblings)
8 siblings, 0 replies; 25+ messages in thread
From: Baochen Qiang @ 2024-05-30 7:27 UTC (permalink / raw)
To: ath12k; +Cc: linux-wireless, quic_bqiang
Host needs to set hardware data filter before entering WoW to
let firmware drop needless broadcast/multicast frames to avoid
frequent wakeup. Host clears hardware data filter when leaving WoW.
Tested-on: WCN7850 hw2.0 PCI WLAN.HMT.1.0-03427-QCAHMTSWPL_V1.0_V2.0_SILICONZ-1.15378.4
Signed-off-by: Baochen Qiang <quic_bqiang@quicinc.com>
Acked-by: Jeff Johnson <quic_jjohnson@quicinc.com>
---
drivers/net/wireless/ath/ath12k/wmi.c | 31 +++++++++++++
drivers/net/wireless/ath/ath12k/wmi.h | 21 +++++++++
drivers/net/wireless/ath/ath12k/wow.c | 66 +++++++++++++++++++++++++++
3 files changed, 118 insertions(+)
diff --git a/drivers/net/wireless/ath/ath12k/wmi.c b/drivers/net/wireless/ath/ath12k/wmi.c
index 63ce1c76b82c..851f320e73c7 100644
--- a/drivers/net/wireless/ath/ath12k/wmi.c
+++ b/drivers/net/wireless/ath/ath12k/wmi.c
@@ -7422,6 +7422,37 @@ void ath12k_wmi_detach(struct ath12k_base *ab)
ath12k_wmi_free_dbring_caps(ab);
}
+int ath12k_wmi_hw_data_filter_cmd(struct ath12k *ar, struct wmi_hw_data_filter_arg *arg)
+{
+ struct wmi_hw_data_filter_cmd *cmd;
+ struct sk_buff *skb;
+ int len;
+
+ len = sizeof(*cmd);
+ skb = ath12k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
+
+ if (!skb)
+ return -ENOMEM;
+
+ cmd = (struct wmi_hw_data_filter_cmd *)skb->data;
+ cmd->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_HW_DATA_FILTER_CMD,
+ sizeof(*cmd));
+ cmd->vdev_id = cpu_to_le32(arg->vdev_id);
+ cmd->enable = cpu_to_le32(arg->enable ? 1 : 0);
+
+ /* Set all modes in case of disable */
+ if (arg->enable)
+ cmd->hw_filter_bitmap = cpu_to_le32(arg->hw_filter_bitmap);
+ else
+ cmd->hw_filter_bitmap = cpu_to_le32((u32)~0U);
+
+ ath12k_dbg(ar->ab, ATH12K_DBG_WMI,
+ "wmi hw data filter enable %d filter_bitmap 0x%x\n",
+ arg->enable, arg->hw_filter_bitmap);
+
+ return ath12k_wmi_cmd_send(ar->wmi, skb, WMI_HW_DATA_FILTER_CMDID);
+}
+
int ath12k_wmi_wow_host_wakeup_ind(struct ath12k *ar)
{
struct wmi_wow_host_wakeup_cmd *cmd;
diff --git a/drivers/net/wireless/ath/ath12k/wmi.h b/drivers/net/wireless/ath/ath12k/wmi.h
index 6e5d9a25255e..477e2a37eb9c 100644
--- a/drivers/net/wireless/ath/ath12k/wmi.h
+++ b/drivers/net/wireless/ath/ath12k/wmi.h
@@ -5297,6 +5297,25 @@ struct wmi_wow_nlo_config_cmd {
*/
} __packed;
+/* Definition of HW data filtering */
+enum hw_data_filter_type {
+ WMI_HW_DATA_FILTER_DROP_NON_ARP_BC = BIT(0),
+ WMI_HW_DATA_FILTER_DROP_NON_ICMPV6_MC = BIT(1),
+};
+
+struct wmi_hw_data_filter_cmd {
+ __le32 tlv_header;
+ __le32 vdev_id;
+ __le32 enable;
+ __le32 hw_filter_bitmap;
+} __packed;
+
+struct wmi_hw_data_filter_arg {
+ u32 vdev_id;
+ bool enable;
+ u32 hw_filter_bitmap;
+};
+
void ath12k_wmi_init_qcn9274(struct ath12k_base *ab,
struct ath12k_wmi_resource_config_arg *config);
void ath12k_wmi_init_wcn7850(struct ath12k_base *ab,
@@ -5460,4 +5479,6 @@ int ath12k_wmi_wow_add_wakeup_event(struct ath12k *ar, u32 vdev_id,
u32 enable);
int ath12k_wmi_wow_config_pno(struct ath12k *ar, u32 vdev_id,
struct wmi_pno_scan_req_arg *pno_scan);
+int ath12k_wmi_hw_data_filter_cmd(struct ath12k *ar,
+ struct wmi_hw_data_filter_arg *arg);
#endif
diff --git a/drivers/net/wireless/ath/ath12k/wow.c b/drivers/net/wireless/ath/ath12k/wow.c
index 330bd39f75c0..77658a01bb41 100644
--- a/drivers/net/wireless/ath/ath12k/wow.c
+++ b/drivers/net/wireless/ath/ath12k/wow.c
@@ -538,6 +538,59 @@ static int ath12k_wow_nlo_cleanup(struct ath12k *ar)
return 0;
}
+static int ath12k_wow_set_hw_filter(struct ath12k *ar)
+{
+ struct wmi_hw_data_filter_arg arg;
+ struct ath12k_vif *arvif;
+ int ret;
+
+ lockdep_assert_held(&ar->conf_mutex);
+
+ list_for_each_entry(arvif, &ar->arvifs, list) {
+ if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
+ continue;
+
+ arg.vdev_id = arvif->vdev_id;
+ arg.enable = true;
+ arg.hw_filter_bitmap = WMI_HW_DATA_FILTER_DROP_NON_ICMPV6_MC;
+ ret = ath12k_wmi_hw_data_filter_cmd(ar, &arg);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to set hw data filter on vdev %i: %d\n",
+ arvif->vdev_id, ret);
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
+static int ath12k_wow_clear_hw_filter(struct ath12k *ar)
+{
+ struct wmi_hw_data_filter_arg arg;
+ struct ath12k_vif *arvif;
+ int ret;
+
+ lockdep_assert_held(&ar->conf_mutex);
+
+ list_for_each_entry(arvif, &ar->arvifs, list) {
+ if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
+ continue;
+
+ arg.vdev_id = arvif->vdev_id;
+ arg.enable = false;
+ arg.hw_filter_bitmap = 0;
+ ret = ath12k_wmi_hw_data_filter_cmd(ar, &arg);
+
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to clear hw data filter on vdev %i: %d\n",
+ arvif->vdev_id, ret);
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
int ath12k_wow_op_suspend(struct ieee80211_hw *hw,
struct cfg80211_wowlan *wowlan)
{
@@ -567,6 +620,13 @@ int ath12k_wow_op_suspend(struct ieee80211_hw *hw,
goto cleanup;
}
+ ret = ath12k_wow_set_hw_filter(ar);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to set hw filter: %d\n",
+ ret);
+ goto cleanup;
+ }
+
ret = ath12k_wow_enable(ar);
if (ret) {
ath12k_warn(ar->ab, "failed to start wow: %d\n", ret);
@@ -634,6 +694,12 @@ int ath12k_wow_op_resume(struct ieee80211_hw *hw)
goto exit;
}
+ ret = ath12k_wow_clear_hw_filter(ar);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to clear hw filter: %d\n", ret);
+ goto exit;
+ }
+
exit:
if (ret) {
switch (ah->state) {
--
2.25.1
^ permalink raw reply related [flat|nested] 25+ messages in thread* [PATCH v3 6/8] wifi: ath12k: support ARP and NS offload
2024-05-30 7:27 [PATCH v3 0/8] wifi: ath12k: add support for WoW Baochen Qiang
` (4 preceding siblings ...)
2024-05-30 7:27 ` [PATCH v3 5/8] wifi: ath12k: implement hardware data filter Baochen Qiang
@ 2024-05-30 7:27 ` Baochen Qiang
2024-05-30 18:26 ` Jeff Johnson
2024-05-30 7:27 ` [PATCH v3 7/8] wifi: ath12k: support GTK rekey offload Baochen Qiang
` (2 subsequent siblings)
8 siblings, 1 reply; 25+ messages in thread
From: Baochen Qiang @ 2024-05-30 7:27 UTC (permalink / raw)
To: ath12k; +Cc: linux-wireless, quic_bqiang
Support ARP and NS offload in WoW state.
Tested this way: put machine A with QCA6390 to WoW state,
ping/ping6 machine A from another machine B, check sniffer to see
any ARP response and Neighbor Advertisement from machine A.
Tested-on: WCN7850 hw2.0 PCI WLAN.HMT.1.0-03427-QCAHMTSWPL_V1.0_V2.0_SILICONZ-1.15378.4
Signed-off-by: Baochen Qiang <quic_bqiang@quicinc.com>
---
drivers/net/wireless/ath/ath12k/core.h | 1 +
drivers/net/wireless/ath/ath12k/mac.c | 15 ++
drivers/net/wireless/ath/ath12k/wmi.c | 148 ++++++++++++++++++++
drivers/net/wireless/ath/ath12k/wmi.h | 66 +++++++++
drivers/net/wireless/ath/ath12k/wow.c | 185 +++++++++++++++++++++++++
5 files changed, 415 insertions(+)
diff --git a/drivers/net/wireless/ath/ath12k/core.h b/drivers/net/wireless/ath/ath12k/core.h
index af5c489b9fd2..f98c3e7c413e 100644
--- a/drivers/net/wireless/ath/ath12k/core.h
+++ b/drivers/net/wireless/ath/ath12k/core.h
@@ -285,6 +285,7 @@ struct ath12k_vif {
u32 punct_bitmap;
bool ps;
struct ath12k_vif_cache *cache;
+ struct inet6_dev *idev;
};
struct ath12k_vif_iter {
diff --git a/drivers/net/wireless/ath/ath12k/mac.c b/drivers/net/wireless/ath/ath12k/mac.c
index 1d45692c3102..70311b94fef8 100644
--- a/drivers/net/wireless/ath/ath12k/mac.c
+++ b/drivers/net/wireless/ath/ath12k/mac.c
@@ -6,6 +6,7 @@
#include <net/mac80211.h>
#include <linux/etherdevice.h>
+
#include "mac.h"
#include "core.h"
#include "debug.h"
@@ -8505,6 +8506,16 @@ static int ath12k_mac_op_remain_on_channel(struct ieee80211_hw *hw,
return ret;
}
+static __maybe_unused void ath12k_mac_op_ipv6_changed(struct ieee80211_hw *hw,
+ struct ieee80211_vif *vif,
+ struct inet6_dev *idev)
+{
+ struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif);
+
+ /* just cache here, would revisit it during WoW offload */
+ arvif->idev = idev;
+}
+
static const struct ieee80211_ops ath12k_ops = {
.tx = ath12k_mac_op_tx,
.wake_tx_queue = ieee80211_handle_wake_tx_queue,
@@ -8547,6 +8558,10 @@ static const struct ieee80211_ops ath12k_ops = {
.resume = ath12k_wow_op_resume,
.set_wakeup = ath12k_wow_op_set_wakeup,
#endif
+
+#if IS_ENABLED(CONFIG_IPV6)
+ .ipv6_addr_change = ath12k_mac_op_ipv6_changed,
+#endif
};
static void ath12k_mac_update_ch_list(struct ath12k *ar,
diff --git a/drivers/net/wireless/ath/ath12k/wmi.c b/drivers/net/wireless/ath/ath12k/wmi.c
index 851f320e73c7..8148e518969e 100644
--- a/drivers/net/wireless/ath/ath12k/wmi.c
+++ b/drivers/net/wireless/ath/ath12k/wmi.c
@@ -7780,3 +7780,151 @@ int ath12k_wmi_wow_config_pno(struct ath12k *ar, u32 vdev_id,
return ath12k_wmi_cmd_send(ar->wmi, skb, WMI_NETWORK_LIST_OFFLOAD_CONFIG_CMDID);
}
+
+static void ath12k_wmi_fill_ns_offload(struct ath12k *ar,
+ struct wmi_arp_ns_offload_arg *offload,
+ void **ptr,
+ bool enable,
+ bool ext)
+{
+ struct wmi_ns_offload_params *ns;
+ struct wmi_tlv *tlv;
+ void *buf_ptr = *ptr;
+ u32 ns_cnt, ns_ext_tuples;
+ int i, max_offloads;
+
+ ns_cnt = offload->ipv6_count;
+
+ tlv = buf_ptr;
+
+ if (ext) {
+ ns_ext_tuples = offload->ipv6_count - WMI_MAX_NS_OFFLOADS;
+ tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_STRUCT,
+ ns_ext_tuples * sizeof(*ns));
+ i = WMI_MAX_NS_OFFLOADS;
+ max_offloads = offload->ipv6_count;
+ } else {
+ tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_STRUCT,
+ WMI_MAX_NS_OFFLOADS * sizeof(*ns));
+ i = 0;
+ max_offloads = WMI_MAX_NS_OFFLOADS;
+ }
+
+ buf_ptr += sizeof(*tlv);
+
+ for (; i < max_offloads; i++) {
+ ns = buf_ptr;
+ ns->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_NS_OFFLOAD_TUPLE,
+ sizeof(*ns));
+
+ if (enable) {
+ if (i < ns_cnt)
+ ns->flags |= cpu_to_le32(WMI_NSOL_FLAGS_VALID);
+
+ memcpy(ns->target_ipaddr[0], offload->ipv6_addr[i], 16);
+ memcpy(ns->solicitation_ipaddr, offload->self_ipv6_addr[i], 16);
+
+ if (offload->ipv6_type[i])
+ ns->flags |= cpu_to_le32(WMI_NSOL_FLAGS_IS_IPV6_ANYCAST);
+
+ memcpy(ns->target_mac.addr, offload->mac_addr, ETH_ALEN);
+
+ if (!is_zero_ether_addr(ns->target_mac.addr))
+ ns->flags |= cpu_to_le32(WMI_NSOL_FLAGS_MAC_VALID);
+
+ ath12k_dbg(ar->ab, ATH12K_DBG_WMI,
+ "wmi index %d ns_solicited %pI6 target %pI6",
+ i, ns->solicitation_ipaddr,
+ ns->target_ipaddr[0]);
+ }
+
+ buf_ptr += sizeof(*ns);
+ }
+
+ *ptr = buf_ptr;
+}
+
+static void ath12k_wmi_fill_arp_offload(struct ath12k *ar,
+ struct wmi_arp_ns_offload_arg *offload,
+ void **ptr,
+ bool enable)
+{
+ struct wmi_arp_offload_params *arp;
+ struct wmi_tlv *tlv;
+ void *buf_ptr = *ptr;
+ int i;
+
+ /* fill arp tuple */
+ tlv = buf_ptr;
+ tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_STRUCT,
+ WMI_MAX_ARP_OFFLOADS * sizeof(*arp));
+ buf_ptr += sizeof(*tlv);
+
+ for (i = 0; i < WMI_MAX_ARP_OFFLOADS; i++) {
+ arp = buf_ptr;
+ arp->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_ARP_OFFLOAD_TUPLE,
+ sizeof(*arp));
+
+ if (enable && i < offload->ipv4_count) {
+ /* Copy the target ip addr and flags */
+ arp->flags = cpu_to_le32(WMI_ARPOL_FLAGS_VALID);
+ memcpy(arp->target_ipaddr, offload->ipv4_addr[i], 4);
+
+ ath12k_dbg(ar->ab, ATH12K_DBG_WMI, "wmi arp offload address %pI4",
+ arp->target_ipaddr);
+ }
+
+ buf_ptr += sizeof(*arp);
+ }
+
+ *ptr = buf_ptr;
+}
+
+int ath12k_wmi_arp_ns_offload(struct ath12k *ar,
+ struct ath12k_vif *arvif,
+ struct wmi_arp_ns_offload_arg *offload,
+ bool enable)
+{
+ struct wmi_set_arp_ns_offload_cmd *cmd;
+ struct wmi_tlv *tlv;
+ struct sk_buff *skb;
+ void *buf_ptr;
+ size_t len;
+ u8 ns_cnt, ns_ext_tuples = 0;
+
+ ns_cnt = offload->ipv6_count;
+
+ len = sizeof(*cmd) +
+ sizeof(*tlv) +
+ WMI_MAX_NS_OFFLOADS * sizeof(struct wmi_ns_offload_params) +
+ sizeof(*tlv) +
+ WMI_MAX_ARP_OFFLOADS * sizeof(struct wmi_arp_offload_params);
+
+ if (ns_cnt > WMI_MAX_NS_OFFLOADS) {
+ ns_ext_tuples = ns_cnt - WMI_MAX_NS_OFFLOADS;
+ len += sizeof(*tlv) +
+ ns_ext_tuples * sizeof(struct wmi_ns_offload_params);
+ }
+
+ skb = ath12k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
+ if (!skb)
+ return -ENOMEM;
+
+ buf_ptr = skb->data;
+ cmd = buf_ptr;
+ cmd->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_SET_ARP_NS_OFFLOAD_CMD,
+ sizeof(*cmd));
+ cmd->flags = cpu_to_le32(0);
+ cmd->vdev_id = cpu_to_le32(arvif->vdev_id);
+ cmd->num_ns_ext_tuples = cpu_to_le32(ns_ext_tuples);
+
+ buf_ptr += sizeof(*cmd);
+
+ ath12k_wmi_fill_ns_offload(ar, offload, &buf_ptr, enable, 0);
+ ath12k_wmi_fill_arp_offload(ar, offload, &buf_ptr, enable);
+
+ if (ns_ext_tuples)
+ ath12k_wmi_fill_ns_offload(ar, offload, &buf_ptr, enable, 1);
+
+ return ath12k_wmi_cmd_send(ar->wmi, skb, WMI_SET_ARP_NS_OFFLOAD_CMDID);
+}
diff --git a/drivers/net/wireless/ath/ath12k/wmi.h b/drivers/net/wireless/ath/ath12k/wmi.h
index 477e2a37eb9c..0542d599d33d 100644
--- a/drivers/net/wireless/ath/ath12k/wmi.h
+++ b/drivers/net/wireless/ath/ath12k/wmi.h
@@ -24,6 +24,7 @@
struct ath12k_base;
struct ath12k;
+struct ath12k_vif;
/* There is no signed version of __le32, so for a temporary solution come
* up with our own version. The idea is from fs/ntfs/endian.h.
@@ -5316,6 +5317,66 @@ struct wmi_hw_data_filter_arg {
u32 hw_filter_bitmap;
};
+#define WMI_IPV6_UC_TYPE 0
+#define WMI_IPV6_AC_TYPE 1
+
+#define WMI_IPV6_MAX_COUNT 16
+#define WMI_IPV4_MAX_COUNT 2
+
+struct wmi_arp_ns_offload_arg {
+ u8 ipv4_addr[WMI_IPV4_MAX_COUNT][4];
+ u32 ipv4_count;
+ u32 ipv6_count;
+ u8 ipv6_addr[WMI_IPV6_MAX_COUNT][16];
+ u8 self_ipv6_addr[WMI_IPV6_MAX_COUNT][16];
+ u8 ipv6_type[WMI_IPV6_MAX_COUNT];
+ bool ipv6_valid[WMI_IPV6_MAX_COUNT];
+ u8 mac_addr[ETH_ALEN];
+};
+
+#define WMI_MAX_NS_OFFLOADS 2
+#define WMI_MAX_ARP_OFFLOADS 2
+
+#define WMI_ARPOL_FLAGS_VALID BIT(0)
+#define WMI_ARPOL_FLAGS_MAC_VALID BIT(1)
+#define WMI_ARPOL_FLAGS_REMOTE_IP_VALID BIT(2)
+
+struct wmi_arp_offload_params {
+ __le32 tlv_header;
+ __le32 flags;
+ u8 target_ipaddr[4];
+ u8 remote_ipaddr[4];
+ struct ath12k_wmi_mac_addr_params target_mac;
+} __packed;
+
+#define WMI_NSOL_FLAGS_VALID BIT(0)
+#define WMI_NSOL_FLAGS_MAC_VALID BIT(1)
+#define WMI_NSOL_FLAGS_REMOTE_IP_VALID BIT(2)
+#define WMI_NSOL_FLAGS_IS_IPV6_ANYCAST BIT(3)
+
+#define WMI_NSOL_MAX_TARGET_IPS 2
+
+struct wmi_ns_offload_params {
+ __le32 tlv_header;
+ __le32 flags;
+ u8 target_ipaddr[WMI_NSOL_MAX_TARGET_IPS][16];
+ u8 solicitation_ipaddr[16];
+ u8 remote_ipaddr[16];
+ struct ath12k_wmi_mac_addr_params target_mac;
+} __packed;
+
+struct wmi_set_arp_ns_offload_cmd {
+ __le32 tlv_header;
+ __le32 flags;
+ __le32 vdev_id;
+ __le32 num_ns_ext_tuples;
+ /* The TLVs follow:
+ * wmi_ns_offload_params ns[WMI_MAX_NS_OFFLOADS];
+ * wmi_arp_offload_params arp[WMI_MAX_ARP_OFFLOADS];
+ * wmi_ns_offload_params ns_ext[num_ns_ext_tuples];
+ */
+} __packed;
+
void ath12k_wmi_init_qcn9274(struct ath12k_base *ab,
struct ath12k_wmi_resource_config_arg *config);
void ath12k_wmi_init_wcn7850(struct ath12k_base *ab,
@@ -5481,4 +5542,9 @@ int ath12k_wmi_wow_config_pno(struct ath12k *ar, u32 vdev_id,
struct wmi_pno_scan_req_arg *pno_scan);
int ath12k_wmi_hw_data_filter_cmd(struct ath12k *ar,
struct wmi_hw_data_filter_arg *arg);
+int ath12k_wmi_arp_ns_offload(struct ath12k *ar,
+ struct ath12k_vif *arvif,
+ struct wmi_arp_ns_offload_arg *offload,
+ bool enable);
+
#endif
diff --git a/drivers/net/wireless/ath/ath12k/wow.c b/drivers/net/wireless/ath/ath12k/wow.c
index 77658a01bb41..92bcafd517e7 100644
--- a/drivers/net/wireless/ath/ath12k/wow.c
+++ b/drivers/net/wireless/ath/ath12k/wow.c
@@ -5,6 +5,9 @@
*/
#include <linux/delay.h>
+#include <linux/inetdevice.h>
+#include <net/if_inet6.h>
+#include <net/ipv6.h>
#include "mac.h"
@@ -591,6 +594,174 @@ static int ath12k_wow_clear_hw_filter(struct ath12k *ar)
return 0;
}
+static void ath12k_wow_generate_ns_mc_addr(struct ath12k_base *ab,
+ struct wmi_arp_ns_offload_arg *offload)
+{
+ int i;
+
+ for (i = 0; i < offload->ipv6_count; i++) {
+ offload->self_ipv6_addr[i][0] = 0xff;
+ offload->self_ipv6_addr[i][1] = 0x02;
+ offload->self_ipv6_addr[i][11] = 0x01;
+ offload->self_ipv6_addr[i][12] = 0xff;
+ offload->self_ipv6_addr[i][13] =
+ offload->ipv6_addr[i][13];
+ offload->self_ipv6_addr[i][14] =
+ offload->ipv6_addr[i][14];
+ offload->self_ipv6_addr[i][15] =
+ offload->ipv6_addr[i][15];
+ ath12k_dbg(ab, ATH12K_DBG_WOW, "NS solicited addr %pI6\n",
+ offload->self_ipv6_addr[i]);
+ }
+}
+
+static void ath12k_wow_prepare_ns_offload(struct ath12k_vif *arvif,
+ struct wmi_arp_ns_offload_arg *offload)
+{
+ struct inet6_dev *idev = arvif->idev;
+ struct ath12k_base *ab = arvif->ar->ab;
+ struct inet6_ifaddr *ifa6;
+ struct ifacaddr6 *ifaca6;
+ u32 count = 0, scope;
+ struct list_head *p;
+
+ if (!idev)
+ return;
+
+ ath12k_dbg(ab, ATH12K_DBG_WOW, "wow prepare ns offload\n");
+
+ read_lock_bh(&idev->lock);
+
+ /* get unicast address */
+ list_for_each(p, &idev->addr_list) {
+ if (count >= WMI_IPV6_MAX_COUNT)
+ goto unlock;
+
+ ifa6 = list_entry(p, struct inet6_ifaddr, if_list);
+ if (ifa6->flags & IFA_F_DADFAILED)
+ continue;
+
+ scope = ipv6_addr_src_scope(&ifa6->addr);
+ if (scope != IPV6_ADDR_SCOPE_LINKLOCAL &&
+ scope != IPV6_ADDR_SCOPE_GLOBAL) {
+ ath12k_dbg(ab, ATH12K_DBG_WOW,
+ "Unsupported ipv6 scope: %d\n", scope);
+ continue;
+ }
+
+ memcpy(offload->ipv6_addr[count], &ifa6->addr.s6_addr,
+ sizeof(ifa6->addr.s6_addr));
+ offload->ipv6_type[count] = WMI_IPV6_UC_TYPE;
+ ath12k_dbg(ab, ATH12K_DBG_WOW, "mac count %d ipv6 uc %pI6 scope %d\n",
+ count, offload->ipv6_addr[count],
+ scope);
+ count++;
+ }
+
+ /* get anycast address */
+ rcu_read_lock();
+
+ for (ifaca6 = rcu_dereference(idev->ac_list); ifaca6;
+ ifaca6 = rcu_dereference(ifaca6->aca_next)) {
+ if (count >= WMI_IPV6_MAX_COUNT) {
+ rcu_read_unlock();
+ goto unlock;
+ }
+
+ scope = ipv6_addr_src_scope(&ifaca6->aca_addr);
+ if (scope != IPV6_ADDR_SCOPE_LINKLOCAL &&
+ scope != IPV6_ADDR_SCOPE_GLOBAL) {
+ ath12k_dbg(ab, ATH12K_DBG_WOW,
+ "Unsupported ipv scope: %d\n", scope);
+ continue;
+ }
+
+ memcpy(offload->ipv6_addr[count], &ifaca6->aca_addr,
+ sizeof(ifaca6->aca_addr));
+ offload->ipv6_type[count] = WMI_IPV6_AC_TYPE;
+ ath12k_dbg(ab, ATH12K_DBG_WOW, "mac count %d ipv6 ac %pI6 scope %d\n",
+ count, offload->ipv6_addr[count],
+ scope);
+ count++;
+ }
+
+ rcu_read_unlock();
+
+unlock:
+ read_unlock_bh(&idev->lock);
+
+ offload->ipv6_count = count;
+ ath12k_wow_generate_ns_mc_addr(ab, offload);
+}
+
+static void ath12k_wow_prepare_arp_offload(struct ath12k_vif *arvif,
+ struct wmi_arp_ns_offload_arg *offload)
+{
+ struct ieee80211_vif *vif = arvif->vif;
+ struct ieee80211_vif_cfg vif_cfg = vif->cfg;
+ struct ath12k_base *ab = arvif->ar->ab;
+ u32 ipv4_cnt;
+
+ ath12k_dbg(ab, ATH12K_DBG_WOW, "wow prepare arp offload\n");
+
+ ipv4_cnt = min(vif_cfg.arp_addr_cnt, WMI_IPV4_MAX_COUNT);
+ memcpy(offload->ipv4_addr, vif_cfg.arp_addr_list, ipv4_cnt * sizeof(u32));
+ offload->ipv4_count = ipv4_cnt;
+
+ ath12k_dbg(ab, ATH12K_DBG_WOW,
+ "wow arp_addr_cnt %d vif->addr %pM, offload_addr %pI4\n",
+ vif_cfg.arp_addr_cnt, vif->addr, offload->ipv4_addr);
+}
+
+static int ath12k_wow_arp_ns_offload(struct ath12k *ar, bool enable)
+{
+ struct wmi_arp_ns_offload_arg *offload;
+ struct ath12k_vif *arvif;
+ int ret;
+
+ lockdep_assert_held(&ar->conf_mutex);
+
+ offload = kmalloc(sizeof(*offload), GFP_KERNEL);
+ if (!offload)
+ return -ENOMEM;
+
+ list_for_each_entry(arvif, &ar->arvifs, list) {
+ if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
+ continue;
+
+ memset(offload, 0, sizeof(*offload));
+
+ memcpy(offload->mac_addr, arvif->vif->addr, ETH_ALEN);
+ ath12k_wow_prepare_ns_offload(arvif, offload);
+ ath12k_wow_prepare_arp_offload(arvif, offload);
+
+ ret = ath12k_wmi_arp_ns_offload(ar, arvif, offload, enable);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to set arp ns offload vdev %i: enable %d, ret %d\n",
+ arvif->vdev_id, enable, ret);
+ return ret;
+ }
+ }
+
+ kfree(offload);
+
+ return 0;
+}
+
+static int ath12k_wow_protocol_offload(struct ath12k *ar, bool enable)
+{
+ int ret;
+
+ ret = ath12k_wow_arp_ns_offload(ar, enable);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to offload ARP and NS %d %d\n",
+ enable, ret);
+ return ret;
+ }
+
+ return 0;
+}
+
int ath12k_wow_op_suspend(struct ieee80211_hw *hw,
struct cfg80211_wowlan *wowlan)
{
@@ -614,6 +785,13 @@ int ath12k_wow_op_suspend(struct ieee80211_hw *hw,
goto cleanup;
}
+ ret = ath12k_wow_protocol_offload(ar, true);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to set wow protocol offload events: %d\n",
+ ret);
+ goto cleanup;
+ }
+
ret = ath12k_mac_wait_tx_complete(ar);
if (ret) {
ath12k_warn(ar->ab, "failed to wait tx complete: %d\n", ret);
@@ -700,6 +878,13 @@ int ath12k_wow_op_resume(struct ieee80211_hw *hw)
goto exit;
}
+ ret = ath12k_wow_protocol_offload(ar, false);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to clear wow protocol offload events: %d\n",
+ ret);
+ goto exit;
+ }
+
exit:
if (ret) {
switch (ah->state) {
--
2.25.1
^ permalink raw reply related [flat|nested] 25+ messages in thread* Re: [PATCH v3 6/8] wifi: ath12k: support ARP and NS offload
2024-05-30 7:27 ` [PATCH v3 6/8] wifi: ath12k: support ARP and NS offload Baochen Qiang
@ 2024-05-30 18:26 ` Jeff Johnson
2024-05-31 3:42 ` Baochen Qiang
0 siblings, 1 reply; 25+ messages in thread
From: Jeff Johnson @ 2024-05-30 18:26 UTC (permalink / raw)
To: Baochen Qiang, ath12k; +Cc: linux-wireless
On 5/30/2024 12:27 AM, Baochen Qiang wrote:
> Support ARP and NS offload in WoW state.
>
> Tested this way: put machine A with QCA6390 to WoW state,
> ping/ping6 machine A from another machine B, check sniffer to see
> any ARP response and Neighbor Advertisement from machine A.
>
> Tested-on: WCN7850 hw2.0 PCI WLAN.HMT.1.0-03427-QCAHMTSWPL_V1.0_V2.0_SILICONZ-1.15378.4
>
> Signed-off-by: Baochen Qiang <quic_bqiang@quicinc.com>
> ---
> drivers/net/wireless/ath/ath12k/core.h | 1 +
> drivers/net/wireless/ath/ath12k/mac.c | 15 ++
> drivers/net/wireless/ath/ath12k/wmi.c | 148 ++++++++++++++++++++
> drivers/net/wireless/ath/ath12k/wmi.h | 66 +++++++++
> drivers/net/wireless/ath/ath12k/wow.c | 185 +++++++++++++++++++++++++
> 5 files changed, 415 insertions(+)
>
> diff --git a/drivers/net/wireless/ath/ath12k/core.h b/drivers/net/wireless/ath/ath12k/core.h
> index af5c489b9fd2..f98c3e7c413e 100644
> --- a/drivers/net/wireless/ath/ath12k/core.h
> +++ b/drivers/net/wireless/ath/ath12k/core.h
> @@ -285,6 +285,7 @@ struct ath12k_vif {
> u32 punct_bitmap;
> bool ps;
> struct ath12k_vif_cache *cache;
> + struct inet6_dev *idev;
> };
>
> struct ath12k_vif_iter {
> diff --git a/drivers/net/wireless/ath/ath12k/mac.c b/drivers/net/wireless/ath/ath12k/mac.c
> index 1d45692c3102..70311b94fef8 100644
> --- a/drivers/net/wireless/ath/ath12k/mac.c
> +++ b/drivers/net/wireless/ath/ath12k/mac.c
> @@ -6,6 +6,7 @@
>
> #include <net/mac80211.h>
> #include <linux/etherdevice.h>
> +
> #include "mac.h"
> #include "core.h"
> #include "debug.h"
> @@ -8505,6 +8506,16 @@ static int ath12k_mac_op_remain_on_channel(struct ieee80211_hw *hw,
> return ret;
> }
>
> +static __maybe_unused void ath12k_mac_op_ipv6_changed(struct ieee80211_hw *hw,
> + struct ieee80211_vif *vif,
> + struct inet6_dev *idev)
> +{
> + struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif);
> +
> + /* just cache here, would revisit it during WoW offload */
> + arvif->idev = idev;
so there is no possibility that this can later disappear, leaving us with a
dangling pointer? if so, suggest you enhance the comment to describe why this
is safe
But alternately, if we no longer act upon this immediately when it changes,
why do we need to cache this? Can we just get to this by back referencing the
netdev from the arvif?
> +}
> +
> static const struct ieee80211_ops ath12k_ops = {
> .tx = ath12k_mac_op_tx,
> .wake_tx_queue = ieee80211_handle_wake_tx_queue,
> @@ -8547,6 +8558,10 @@ static const struct ieee80211_ops ath12k_ops = {
> .resume = ath12k_wow_op_resume,
> .set_wakeup = ath12k_wow_op_set_wakeup,
> #endif
> +
> +#if IS_ENABLED(CONFIG_IPV6)
> + .ipv6_addr_change = ath12k_mac_op_ipv6_changed,
> +#endif
> };
>
> static void ath12k_mac_update_ch_list(struct ath12k *ar,
> diff --git a/drivers/net/wireless/ath/ath12k/wmi.c b/drivers/net/wireless/ath/ath12k/wmi.c
> index 851f320e73c7..8148e518969e 100644
> --- a/drivers/net/wireless/ath/ath12k/wmi.c
> +++ b/drivers/net/wireless/ath/ath12k/wmi.c
> @@ -7780,3 +7780,151 @@ int ath12k_wmi_wow_config_pno(struct ath12k *ar, u32 vdev_id,
>
> return ath12k_wmi_cmd_send(ar->wmi, skb, WMI_NETWORK_LIST_OFFLOAD_CONFIG_CMDID);
> }
> +
> +static void ath12k_wmi_fill_ns_offload(struct ath12k *ar,
> + struct wmi_arp_ns_offload_arg *offload,
> + void **ptr,
> + bool enable,
> + bool ext)
> +{
> + struct wmi_ns_offload_params *ns;
> + struct wmi_tlv *tlv;
> + void *buf_ptr = *ptr;
> + u32 ns_cnt, ns_ext_tuples;
> + int i, max_offloads;
> +
> + ns_cnt = offload->ipv6_count;
> +
> + tlv = buf_ptr;
> +
> + if (ext) {
> + ns_ext_tuples = offload->ipv6_count - WMI_MAX_NS_OFFLOADS;
> + tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_STRUCT,
> + ns_ext_tuples * sizeof(*ns));
> + i = WMI_MAX_NS_OFFLOADS;
> + max_offloads = offload->ipv6_count;
> + } else {
> + tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_STRUCT,
> + WMI_MAX_NS_OFFLOADS * sizeof(*ns));
> + i = 0;
> + max_offloads = WMI_MAX_NS_OFFLOADS;
> + }
> +
> + buf_ptr += sizeof(*tlv);
> +
> + for (; i < max_offloads; i++) {
> + ns = buf_ptr;
> + ns->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_NS_OFFLOAD_TUPLE,
> + sizeof(*ns));
> +
> + if (enable) {
> + if (i < ns_cnt)
> + ns->flags |= cpu_to_le32(WMI_NSOL_FLAGS_VALID);
> +
> + memcpy(ns->target_ipaddr[0], offload->ipv6_addr[i], 16);
> + memcpy(ns->solicitation_ipaddr, offload->self_ipv6_addr[i], 16);
> +
> + if (offload->ipv6_type[i])
> + ns->flags |= cpu_to_le32(WMI_NSOL_FLAGS_IS_IPV6_ANYCAST);
> +
> + memcpy(ns->target_mac.addr, offload->mac_addr, ETH_ALEN);
> +
> + if (!is_zero_ether_addr(ns->target_mac.addr))
> + ns->flags |= cpu_to_le32(WMI_NSOL_FLAGS_MAC_VALID);
> +
> + ath12k_dbg(ar->ab, ATH12K_DBG_WMI,
> + "wmi index %d ns_solicited %pI6 target %pI6",
> + i, ns->solicitation_ipaddr,
> + ns->target_ipaddr[0]);
> + }
> +
> + buf_ptr += sizeof(*ns);
> + }
> +
> + *ptr = buf_ptr;
> +}
> +
> +static void ath12k_wmi_fill_arp_offload(struct ath12k *ar,
> + struct wmi_arp_ns_offload_arg *offload,
> + void **ptr,
> + bool enable)
> +{
> + struct wmi_arp_offload_params *arp;
> + struct wmi_tlv *tlv;
> + void *buf_ptr = *ptr;
> + int i;
> +
> + /* fill arp tuple */
> + tlv = buf_ptr;
> + tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_STRUCT,
> + WMI_MAX_ARP_OFFLOADS * sizeof(*arp));
> + buf_ptr += sizeof(*tlv);
> +
> + for (i = 0; i < WMI_MAX_ARP_OFFLOADS; i++) {
> + arp = buf_ptr;
> + arp->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_ARP_OFFLOAD_TUPLE,
> + sizeof(*arp));
> +
> + if (enable && i < offload->ipv4_count) {
> + /* Copy the target ip addr and flags */
> + arp->flags = cpu_to_le32(WMI_ARPOL_FLAGS_VALID);
> + memcpy(arp->target_ipaddr, offload->ipv4_addr[i], 4);
> +
> + ath12k_dbg(ar->ab, ATH12K_DBG_WMI, "wmi arp offload address %pI4",
> + arp->target_ipaddr);
> + }
> +
> + buf_ptr += sizeof(*arp);
> + }
> +
> + *ptr = buf_ptr;
> +}
> +
> +int ath12k_wmi_arp_ns_offload(struct ath12k *ar,
> + struct ath12k_vif *arvif,
> + struct wmi_arp_ns_offload_arg *offload,
> + bool enable)
> +{
> + struct wmi_set_arp_ns_offload_cmd *cmd;
> + struct wmi_tlv *tlv;
> + struct sk_buff *skb;
> + void *buf_ptr;
> + size_t len;
> + u8 ns_cnt, ns_ext_tuples = 0;
> +
> + ns_cnt = offload->ipv6_count;
> +
> + len = sizeof(*cmd) +
> + sizeof(*tlv) +
> + WMI_MAX_NS_OFFLOADS * sizeof(struct wmi_ns_offload_params) +
> + sizeof(*tlv) +
> + WMI_MAX_ARP_OFFLOADS * sizeof(struct wmi_arp_offload_params);
> +
> + if (ns_cnt > WMI_MAX_NS_OFFLOADS) {
> + ns_ext_tuples = ns_cnt - WMI_MAX_NS_OFFLOADS;
> + len += sizeof(*tlv) +
> + ns_ext_tuples * sizeof(struct wmi_ns_offload_params);
> + }
> +
> + skb = ath12k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
> + if (!skb)
> + return -ENOMEM;
> +
> + buf_ptr = skb->data;
> + cmd = buf_ptr;
> + cmd->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_SET_ARP_NS_OFFLOAD_CMD,
> + sizeof(*cmd));
> + cmd->flags = cpu_to_le32(0);
> + cmd->vdev_id = cpu_to_le32(arvif->vdev_id);
> + cmd->num_ns_ext_tuples = cpu_to_le32(ns_ext_tuples);
> +
> + buf_ptr += sizeof(*cmd);
> +
> + ath12k_wmi_fill_ns_offload(ar, offload, &buf_ptr, enable, 0);
> + ath12k_wmi_fill_arp_offload(ar, offload, &buf_ptr, enable);
> +
> + if (ns_ext_tuples)
> + ath12k_wmi_fill_ns_offload(ar, offload, &buf_ptr, enable, 1);
> +
> + return ath12k_wmi_cmd_send(ar->wmi, skb, WMI_SET_ARP_NS_OFFLOAD_CMDID);
> +}
> diff --git a/drivers/net/wireless/ath/ath12k/wmi.h b/drivers/net/wireless/ath/ath12k/wmi.h
> index 477e2a37eb9c..0542d599d33d 100644
> --- a/drivers/net/wireless/ath/ath12k/wmi.h
> +++ b/drivers/net/wireless/ath/ath12k/wmi.h
> @@ -24,6 +24,7 @@
>
> struct ath12k_base;
> struct ath12k;
> +struct ath12k_vif;
>
> /* There is no signed version of __le32, so for a temporary solution come
> * up with our own version. The idea is from fs/ntfs/endian.h.
> @@ -5316,6 +5317,66 @@ struct wmi_hw_data_filter_arg {
> u32 hw_filter_bitmap;
> };
>
> +#define WMI_IPV6_UC_TYPE 0
> +#define WMI_IPV6_AC_TYPE 1
> +
> +#define WMI_IPV6_MAX_COUNT 16
> +#define WMI_IPV4_MAX_COUNT 2
> +
> +struct wmi_arp_ns_offload_arg {
> + u8 ipv4_addr[WMI_IPV4_MAX_COUNT][4];
> + u32 ipv4_count;
> + u32 ipv6_count;
> + u8 ipv6_addr[WMI_IPV6_MAX_COUNT][16];
> + u8 self_ipv6_addr[WMI_IPV6_MAX_COUNT][16];
> + u8 ipv6_type[WMI_IPV6_MAX_COUNT];
> + bool ipv6_valid[WMI_IPV6_MAX_COUNT];
> + u8 mac_addr[ETH_ALEN];
> +};
> +
> +#define WMI_MAX_NS_OFFLOADS 2
> +#define WMI_MAX_ARP_OFFLOADS 2
> +
> +#define WMI_ARPOL_FLAGS_VALID BIT(0)
> +#define WMI_ARPOL_FLAGS_MAC_VALID BIT(1)
> +#define WMI_ARPOL_FLAGS_REMOTE_IP_VALID BIT(2)
> +
> +struct wmi_arp_offload_params {
> + __le32 tlv_header;
> + __le32 flags;
> + u8 target_ipaddr[4];
> + u8 remote_ipaddr[4];
> + struct ath12k_wmi_mac_addr_params target_mac;
> +} __packed;
> +
> +#define WMI_NSOL_FLAGS_VALID BIT(0)
> +#define WMI_NSOL_FLAGS_MAC_VALID BIT(1)
> +#define WMI_NSOL_FLAGS_REMOTE_IP_VALID BIT(2)
> +#define WMI_NSOL_FLAGS_IS_IPV6_ANYCAST BIT(3)
> +
> +#define WMI_NSOL_MAX_TARGET_IPS 2
> +
> +struct wmi_ns_offload_params {
> + __le32 tlv_header;
> + __le32 flags;
> + u8 target_ipaddr[WMI_NSOL_MAX_TARGET_IPS][16];
> + u8 solicitation_ipaddr[16];
> + u8 remote_ipaddr[16];
> + struct ath12k_wmi_mac_addr_params target_mac;
> +} __packed;
> +
> +struct wmi_set_arp_ns_offload_cmd {
> + __le32 tlv_header;
> + __le32 flags;
> + __le32 vdev_id;
> + __le32 num_ns_ext_tuples;
> + /* The TLVs follow:
> + * wmi_ns_offload_params ns[WMI_MAX_NS_OFFLOADS];
> + * wmi_arp_offload_params arp[WMI_MAX_ARP_OFFLOADS];
> + * wmi_ns_offload_params ns_ext[num_ns_ext_tuples];
> + */
> +} __packed;
> +
> void ath12k_wmi_init_qcn9274(struct ath12k_base *ab,
> struct ath12k_wmi_resource_config_arg *config);
> void ath12k_wmi_init_wcn7850(struct ath12k_base *ab,
> @@ -5481,4 +5542,9 @@ int ath12k_wmi_wow_config_pno(struct ath12k *ar, u32 vdev_id,
> struct wmi_pno_scan_req_arg *pno_scan);
> int ath12k_wmi_hw_data_filter_cmd(struct ath12k *ar,
> struct wmi_hw_data_filter_arg *arg);
> +int ath12k_wmi_arp_ns_offload(struct ath12k *ar,
> + struct ath12k_vif *arvif,
> + struct wmi_arp_ns_offload_arg *offload,
> + bool enable);
> +
> #endif
> diff --git a/drivers/net/wireless/ath/ath12k/wow.c b/drivers/net/wireless/ath/ath12k/wow.c
> index 77658a01bb41..92bcafd517e7 100644
> --- a/drivers/net/wireless/ath/ath12k/wow.c
> +++ b/drivers/net/wireless/ath/ath12k/wow.c
> @@ -5,6 +5,9 @@
> */
>
> #include <linux/delay.h>
> +#include <linux/inetdevice.h>
> +#include <net/if_inet6.h>
> +#include <net/ipv6.h>
>
> #include "mac.h"
>
> @@ -591,6 +594,174 @@ static int ath12k_wow_clear_hw_filter(struct ath12k *ar)
> return 0;
> }
>
> +static void ath12k_wow_generate_ns_mc_addr(struct ath12k_base *ab,
> + struct wmi_arp_ns_offload_arg *offload)
> +{
> + int i;
> +
> + for (i = 0; i < offload->ipv6_count; i++) {
> + offload->self_ipv6_addr[i][0] = 0xff;
> + offload->self_ipv6_addr[i][1] = 0x02;
> + offload->self_ipv6_addr[i][11] = 0x01;
> + offload->self_ipv6_addr[i][12] = 0xff;
> + offload->self_ipv6_addr[i][13] =
> + offload->ipv6_addr[i][13];
> + offload->self_ipv6_addr[i][14] =
> + offload->ipv6_addr[i][14];
> + offload->self_ipv6_addr[i][15] =
> + offload->ipv6_addr[i][15];
> + ath12k_dbg(ab, ATH12K_DBG_WOW, "NS solicited addr %pI6\n",
> + offload->self_ipv6_addr[i]);
> + }
> +}
> +
> +static void ath12k_wow_prepare_ns_offload(struct ath12k_vif *arvif,
> + struct wmi_arp_ns_offload_arg *offload)
> +{
> + struct inet6_dev *idev = arvif->idev;
as noted above does it make more sense to get the netdev associated with the
arvif and then use in6_dev_get(net_device) to get the inet6_dev rather than
caching the pointer from the ipv6_addr_changed() callback?
> + struct ath12k_base *ab = arvif->ar->ab;
> + struct inet6_ifaddr *ifa6;
> + struct ifacaddr6 *ifaca6;
> + u32 count = 0, scope;
> + struct list_head *p;
> +
> + if (!idev)
> + return;
> +
> + ath12k_dbg(ab, ATH12K_DBG_WOW, "wow prepare ns offload\n");
> +
> + read_lock_bh(&idev->lock);
> +
> + /* get unicast address */
> + list_for_each(p, &idev->addr_list) {
> + if (count >= WMI_IPV6_MAX_COUNT)
> + goto unlock;
> +
> + ifa6 = list_entry(p, struct inet6_ifaddr, if_list);
> + if (ifa6->flags & IFA_F_DADFAILED)
> + continue;
> +
> + scope = ipv6_addr_src_scope(&ifa6->addr);
> + if (scope != IPV6_ADDR_SCOPE_LINKLOCAL &&
> + scope != IPV6_ADDR_SCOPE_GLOBAL) {
> + ath12k_dbg(ab, ATH12K_DBG_WOW,
> + "Unsupported ipv6 scope: %d\n", scope);
> + continue;
> + }
> +
> + memcpy(offload->ipv6_addr[count], &ifa6->addr.s6_addr,
> + sizeof(ifa6->addr.s6_addr));
> + offload->ipv6_type[count] = WMI_IPV6_UC_TYPE;
> + ath12k_dbg(ab, ATH12K_DBG_WOW, "mac count %d ipv6 uc %pI6 scope %d\n",
> + count, offload->ipv6_addr[count],
> + scope);
> + count++;
> + }
> +
> + /* get anycast address */
> + rcu_read_lock();
> +
> + for (ifaca6 = rcu_dereference(idev->ac_list); ifaca6;
> + ifaca6 = rcu_dereference(ifaca6->aca_next)) {
> + if (count >= WMI_IPV6_MAX_COUNT) {
> + rcu_read_unlock();
> + goto unlock;
> + }
> +
> + scope = ipv6_addr_src_scope(&ifaca6->aca_addr);
> + if (scope != IPV6_ADDR_SCOPE_LINKLOCAL &&
> + scope != IPV6_ADDR_SCOPE_GLOBAL) {
> + ath12k_dbg(ab, ATH12K_DBG_WOW,
> + "Unsupported ipv scope: %d\n", scope);
> + continue;
> + }
> +
> + memcpy(offload->ipv6_addr[count], &ifaca6->aca_addr,
> + sizeof(ifaca6->aca_addr));
> + offload->ipv6_type[count] = WMI_IPV6_AC_TYPE;
> + ath12k_dbg(ab, ATH12K_DBG_WOW, "mac count %d ipv6 ac %pI6 scope %d\n",
> + count, offload->ipv6_addr[count],
> + scope);
> + count++;
> + }
> +
> + rcu_read_unlock();
> +
> +unlock:
> + read_unlock_bh(&idev->lock);
> +
> + offload->ipv6_count = count;
> + ath12k_wow_generate_ns_mc_addr(ab, offload);
> +}
> +
> +static void ath12k_wow_prepare_arp_offload(struct ath12k_vif *arvif,
> + struct wmi_arp_ns_offload_arg *offload)
> +{
> + struct ieee80211_vif *vif = arvif->vif;
> + struct ieee80211_vif_cfg vif_cfg = vif->cfg;
> + struct ath12k_base *ab = arvif->ar->ab;
> + u32 ipv4_cnt;
> +
> + ath12k_dbg(ab, ATH12K_DBG_WOW, "wow prepare arp offload\n");
> +
> + ipv4_cnt = min(vif_cfg.arp_addr_cnt, WMI_IPV4_MAX_COUNT);
> + memcpy(offload->ipv4_addr, vif_cfg.arp_addr_list, ipv4_cnt * sizeof(u32));
> + offload->ipv4_count = ipv4_cnt;
> +
> + ath12k_dbg(ab, ATH12K_DBG_WOW,
> + "wow arp_addr_cnt %d vif->addr %pM, offload_addr %pI4\n",
> + vif_cfg.arp_addr_cnt, vif->addr, offload->ipv4_addr);
> +}
> +
> +static int ath12k_wow_arp_ns_offload(struct ath12k *ar, bool enable)
> +{
> + struct wmi_arp_ns_offload_arg *offload;
> + struct ath12k_vif *arvif;
> + int ret;
> +
> + lockdep_assert_held(&ar->conf_mutex);
> +
> + offload = kmalloc(sizeof(*offload), GFP_KERNEL);
> + if (!offload)
> + return -ENOMEM;
> +
> + list_for_each_entry(arvif, &ar->arvifs, list) {
> + if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
> + continue;
> +
> + memset(offload, 0, sizeof(*offload));
> +
> + memcpy(offload->mac_addr, arvif->vif->addr, ETH_ALEN);
> + ath12k_wow_prepare_ns_offload(arvif, offload);
> + ath12k_wow_prepare_arp_offload(arvif, offload);
> +
> + ret = ath12k_wmi_arp_ns_offload(ar, arvif, offload, enable);
> + if (ret) {
> + ath12k_warn(ar->ab, "failed to set arp ns offload vdev %i: enable %d, ret %d\n",
> + arvif->vdev_id, enable, ret);
> + return ret;
> + }
> + }
> +
> + kfree(offload);
> +
> + return 0;
> +}
> +
> +static int ath12k_wow_protocol_offload(struct ath12k *ar, bool enable)
> +{
> + int ret;
> +
> + ret = ath12k_wow_arp_ns_offload(ar, enable);
> + if (ret) {
> + ath12k_warn(ar->ab, "failed to offload ARP and NS %d %d\n",
> + enable, ret);
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> int ath12k_wow_op_suspend(struct ieee80211_hw *hw,
> struct cfg80211_wowlan *wowlan)
> {
> @@ -614,6 +785,13 @@ int ath12k_wow_op_suspend(struct ieee80211_hw *hw,
> goto cleanup;
> }
>
> + ret = ath12k_wow_protocol_offload(ar, true);
> + if (ret) {
> + ath12k_warn(ar->ab, "failed to set wow protocol offload events: %d\n",
> + ret);
> + goto cleanup;
> + }
> +
> ret = ath12k_mac_wait_tx_complete(ar);
> if (ret) {
> ath12k_warn(ar->ab, "failed to wait tx complete: %d\n", ret);
> @@ -700,6 +878,13 @@ int ath12k_wow_op_resume(struct ieee80211_hw *hw)
> goto exit;
> }
>
> + ret = ath12k_wow_protocol_offload(ar, false);
> + if (ret) {
> + ath12k_warn(ar->ab, "failed to clear wow protocol offload events: %d\n",
> + ret);
> + goto exit;
> + }
> +
> exit:
> if (ret) {
> switch (ah->state) {
^ permalink raw reply [flat|nested] 25+ messages in thread* Re: [PATCH v3 6/8] wifi: ath12k: support ARP and NS offload
2024-05-30 18:26 ` Jeff Johnson
@ 2024-05-31 3:42 ` Baochen Qiang
2024-05-31 3:49 ` Baochen Qiang
2024-05-31 5:11 ` Baochen Qiang
0 siblings, 2 replies; 25+ messages in thread
From: Baochen Qiang @ 2024-05-31 3:42 UTC (permalink / raw)
To: Jeff Johnson, ath12k; +Cc: linux-wireless
On 5/31/2024 2:26 AM, Jeff Johnson wrote:
> On 5/30/2024 12:27 AM, Baochen Qiang wrote:
>> Support ARP and NS offload in WoW state.
>>
>> Tested this way: put machine A with QCA6390 to WoW state,
>> ping/ping6 machine A from another machine B, check sniffer to see
>> any ARP response and Neighbor Advertisement from machine A.
>>
>> Tested-on: WCN7850 hw2.0 PCI WLAN.HMT.1.0-03427-QCAHMTSWPL_V1.0_V2.0_SILICONZ-1.15378.4
>>
>> Signed-off-by: Baochen Qiang <quic_bqiang@quicinc.com>
>> ---
>> drivers/net/wireless/ath/ath12k/core.h | 1 +
>> drivers/net/wireless/ath/ath12k/mac.c | 15 ++
>> drivers/net/wireless/ath/ath12k/wmi.c | 148 ++++++++++++++++++++
>> drivers/net/wireless/ath/ath12k/wmi.h | 66 +++++++++
>> drivers/net/wireless/ath/ath12k/wow.c | 185 +++++++++++++++++++++++++
>> 5 files changed, 415 insertions(+)
>>
>> diff --git a/drivers/net/wireless/ath/ath12k/core.h b/drivers/net/wireless/ath/ath12k/core.h
>> index af5c489b9fd2..f98c3e7c413e 100644
>> --- a/drivers/net/wireless/ath/ath12k/core.h
>> +++ b/drivers/net/wireless/ath/ath12k/core.h
>> @@ -285,6 +285,7 @@ struct ath12k_vif {
>> u32 punct_bitmap;
>> bool ps;
>> struct ath12k_vif_cache *cache;
>> + struct inet6_dev *idev;
>> };
>>
>> struct ath12k_vif_iter {
>> diff --git a/drivers/net/wireless/ath/ath12k/mac.c b/drivers/net/wireless/ath/ath12k/mac.c
>> index 1d45692c3102..70311b94fef8 100644
>> --- a/drivers/net/wireless/ath/ath12k/mac.c
>> +++ b/drivers/net/wireless/ath/ath12k/mac.c
>> @@ -6,6 +6,7 @@
>>
>> #include <net/mac80211.h>
>> #include <linux/etherdevice.h>
>> +
>> #include "mac.h"
>> #include "core.h"
>> #include "debug.h"
>> @@ -8505,6 +8506,16 @@ static int ath12k_mac_op_remain_on_channel(struct ieee80211_hw *hw,
>> return ret;
>> }
>>
>> +static __maybe_unused void ath12k_mac_op_ipv6_changed(struct ieee80211_hw *hw,
>> + struct ieee80211_vif *vif,
>> + struct inet6_dev *idev)
>> +{
>> + struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif);
>> +
>> + /* just cache here, would revisit it during WoW offload */
>> + arvif->idev = idev;
>
> so there is no possibility that this can later disappear, leaving us with a
> dangling pointer? if so, suggest you enhance the comment to describe why this
> is safe
>
> But alternately, if we no longer act upon this immediately when it changes,
> why do we need to cache this? Can we just get to this by back referencing the
> netdev from the arvif?
makes sense. will remove this callback in next version.
>
>> +}
>> +
>> static const struct ieee80211_ops ath12k_ops = {
>> .tx = ath12k_mac_op_tx,
>> .wake_tx_queue = ieee80211_handle_wake_tx_queue,
>> @@ -8547,6 +8558,10 @@ static const struct ieee80211_ops ath12k_ops = {
>> .resume = ath12k_wow_op_resume,
>> .set_wakeup = ath12k_wow_op_set_wakeup,
>> #endif
>> +
>> +#if IS_ENABLED(CONFIG_IPV6)
>> + .ipv6_addr_change = ath12k_mac_op_ipv6_changed,
>> +#endif
>> };
>>
>> static void ath12k_mac_update_ch_list(struct ath12k *ar,
>> diff --git a/drivers/net/wireless/ath/ath12k/wmi.c b/drivers/net/wireless/ath/ath12k/wmi.c
>> index 851f320e73c7..8148e518969e 100644
>> --- a/drivers/net/wireless/ath/ath12k/wmi.c
>> +++ b/drivers/net/wireless/ath/ath12k/wmi.c
>> @@ -7780,3 +7780,151 @@ int ath12k_wmi_wow_config_pno(struct ath12k *ar, u32 vdev_id,
>>
>> return ath12k_wmi_cmd_send(ar->wmi, skb, WMI_NETWORK_LIST_OFFLOAD_CONFIG_CMDID);
>> }
>> +
>> +static void ath12k_wmi_fill_ns_offload(struct ath12k *ar,
>> + struct wmi_arp_ns_offload_arg *offload,
>> + void **ptr,
>> + bool enable,
>> + bool ext)
>> +{
>> + struct wmi_ns_offload_params *ns;
>> + struct wmi_tlv *tlv;
>> + void *buf_ptr = *ptr;
>> + u32 ns_cnt, ns_ext_tuples;
>> + int i, max_offloads;
>> +
>> + ns_cnt = offload->ipv6_count;
>> +
>> + tlv = buf_ptr;
>> +
>> + if (ext) {
>> + ns_ext_tuples = offload->ipv6_count - WMI_MAX_NS_OFFLOADS;
>> + tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_STRUCT,
>> + ns_ext_tuples * sizeof(*ns));
>> + i = WMI_MAX_NS_OFFLOADS;
>> + max_offloads = offload->ipv6_count;
>> + } else {
>> + tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_STRUCT,
>> + WMI_MAX_NS_OFFLOADS * sizeof(*ns));
>> + i = 0;
>> + max_offloads = WMI_MAX_NS_OFFLOADS;
>> + }
>> +
>> + buf_ptr += sizeof(*tlv);
>> +
>> + for (; i < max_offloads; i++) {
>> + ns = buf_ptr;
>> + ns->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_NS_OFFLOAD_TUPLE,
>> + sizeof(*ns));
>> +
>> + if (enable) {
>> + if (i < ns_cnt)
>> + ns->flags |= cpu_to_le32(WMI_NSOL_FLAGS_VALID);
>> +
>> + memcpy(ns->target_ipaddr[0], offload->ipv6_addr[i], 16);
>> + memcpy(ns->solicitation_ipaddr, offload->self_ipv6_addr[i], 16);
>> +
>> + if (offload->ipv6_type[i])
>> + ns->flags |= cpu_to_le32(WMI_NSOL_FLAGS_IS_IPV6_ANYCAST);
>> +
>> + memcpy(ns->target_mac.addr, offload->mac_addr, ETH_ALEN);
>> +
>> + if (!is_zero_ether_addr(ns->target_mac.addr))
>> + ns->flags |= cpu_to_le32(WMI_NSOL_FLAGS_MAC_VALID);
>> +
>> + ath12k_dbg(ar->ab, ATH12K_DBG_WMI,
>> + "wmi index %d ns_solicited %pI6 target %pI6",
>> + i, ns->solicitation_ipaddr,
>> + ns->target_ipaddr[0]);
>> + }
>> +
>> + buf_ptr += sizeof(*ns);
>> + }
>> +
>> + *ptr = buf_ptr;
>> +}
>> +
>> +static void ath12k_wmi_fill_arp_offload(struct ath12k *ar,
>> + struct wmi_arp_ns_offload_arg *offload,
>> + void **ptr,
>> + bool enable)
>> +{
>> + struct wmi_arp_offload_params *arp;
>> + struct wmi_tlv *tlv;
>> + void *buf_ptr = *ptr;
>> + int i;
>> +
>> + /* fill arp tuple */
>> + tlv = buf_ptr;
>> + tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_STRUCT,
>> + WMI_MAX_ARP_OFFLOADS * sizeof(*arp));
>> + buf_ptr += sizeof(*tlv);
>> +
>> + for (i = 0; i < WMI_MAX_ARP_OFFLOADS; i++) {
>> + arp = buf_ptr;
>> + arp->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_ARP_OFFLOAD_TUPLE,
>> + sizeof(*arp));
>> +
>> + if (enable && i < offload->ipv4_count) {
>> + /* Copy the target ip addr and flags */
>> + arp->flags = cpu_to_le32(WMI_ARPOL_FLAGS_VALID);
>> + memcpy(arp->target_ipaddr, offload->ipv4_addr[i], 4);
>> +
>> + ath12k_dbg(ar->ab, ATH12K_DBG_WMI, "wmi arp offload address %pI4",
>> + arp->target_ipaddr);
>> + }
>> +
>> + buf_ptr += sizeof(*arp);
>> + }
>> +
>> + *ptr = buf_ptr;
>> +}
>> +
>> +int ath12k_wmi_arp_ns_offload(struct ath12k *ar,
>> + struct ath12k_vif *arvif,
>> + struct wmi_arp_ns_offload_arg *offload,
>> + bool enable)
>> +{
>> + struct wmi_set_arp_ns_offload_cmd *cmd;
>> + struct wmi_tlv *tlv;
>> + struct sk_buff *skb;
>> + void *buf_ptr;
>> + size_t len;
>> + u8 ns_cnt, ns_ext_tuples = 0;
>> +
>> + ns_cnt = offload->ipv6_count;
>> +
>> + len = sizeof(*cmd) +
>> + sizeof(*tlv) +
>> + WMI_MAX_NS_OFFLOADS * sizeof(struct wmi_ns_offload_params) +
>> + sizeof(*tlv) +
>> + WMI_MAX_ARP_OFFLOADS * sizeof(struct wmi_arp_offload_params);
>> +
>> + if (ns_cnt > WMI_MAX_NS_OFFLOADS) {
>> + ns_ext_tuples = ns_cnt - WMI_MAX_NS_OFFLOADS;
>> + len += sizeof(*tlv) +
>> + ns_ext_tuples * sizeof(struct wmi_ns_offload_params);
>> + }
>> +
>> + skb = ath12k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
>> + if (!skb)
>> + return -ENOMEM;
>> +
>> + buf_ptr = skb->data;
>> + cmd = buf_ptr;
>> + cmd->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_SET_ARP_NS_OFFLOAD_CMD,
>> + sizeof(*cmd));
>> + cmd->flags = cpu_to_le32(0);
>> + cmd->vdev_id = cpu_to_le32(arvif->vdev_id);
>> + cmd->num_ns_ext_tuples = cpu_to_le32(ns_ext_tuples);
>> +
>> + buf_ptr += sizeof(*cmd);
>> +
>> + ath12k_wmi_fill_ns_offload(ar, offload, &buf_ptr, enable, 0);
>> + ath12k_wmi_fill_arp_offload(ar, offload, &buf_ptr, enable);
>> +
>> + if (ns_ext_tuples)
>> + ath12k_wmi_fill_ns_offload(ar, offload, &buf_ptr, enable, 1);
>> +
>> + return ath12k_wmi_cmd_send(ar->wmi, skb, WMI_SET_ARP_NS_OFFLOAD_CMDID);
>> +}
>> diff --git a/drivers/net/wireless/ath/ath12k/wmi.h b/drivers/net/wireless/ath/ath12k/wmi.h
>> index 477e2a37eb9c..0542d599d33d 100644
>> --- a/drivers/net/wireless/ath/ath12k/wmi.h
>> +++ b/drivers/net/wireless/ath/ath12k/wmi.h
>> @@ -24,6 +24,7 @@
>>
>> struct ath12k_base;
>> struct ath12k;
>> +struct ath12k_vif;
>>
>> /* There is no signed version of __le32, so for a temporary solution come
>> * up with our own version. The idea is from fs/ntfs/endian.h.
>> @@ -5316,6 +5317,66 @@ struct wmi_hw_data_filter_arg {
>> u32 hw_filter_bitmap;
>> };
>>
>> +#define WMI_IPV6_UC_TYPE 0
>> +#define WMI_IPV6_AC_TYPE 1
>> +
>> +#define WMI_IPV6_MAX_COUNT 16
>> +#define WMI_IPV4_MAX_COUNT 2
>> +
>> +struct wmi_arp_ns_offload_arg {
>> + u8 ipv4_addr[WMI_IPV4_MAX_COUNT][4];
>> + u32 ipv4_count;
>> + u32 ipv6_count;
>> + u8 ipv6_addr[WMI_IPV6_MAX_COUNT][16];
>> + u8 self_ipv6_addr[WMI_IPV6_MAX_COUNT][16];
>> + u8 ipv6_type[WMI_IPV6_MAX_COUNT];
>> + bool ipv6_valid[WMI_IPV6_MAX_COUNT];
>> + u8 mac_addr[ETH_ALEN];
>> +};
>> +
>> +#define WMI_MAX_NS_OFFLOADS 2
>> +#define WMI_MAX_ARP_OFFLOADS 2
>> +
>> +#define WMI_ARPOL_FLAGS_VALID BIT(0)
>> +#define WMI_ARPOL_FLAGS_MAC_VALID BIT(1)
>> +#define WMI_ARPOL_FLAGS_REMOTE_IP_VALID BIT(2)
>> +
>> +struct wmi_arp_offload_params {
>> + __le32 tlv_header;
>> + __le32 flags;
>> + u8 target_ipaddr[4];
>> + u8 remote_ipaddr[4];
>> + struct ath12k_wmi_mac_addr_params target_mac;
>> +} __packed;
>> +
>> +#define WMI_NSOL_FLAGS_VALID BIT(0)
>> +#define WMI_NSOL_FLAGS_MAC_VALID BIT(1)
>> +#define WMI_NSOL_FLAGS_REMOTE_IP_VALID BIT(2)
>> +#define WMI_NSOL_FLAGS_IS_IPV6_ANYCAST BIT(3)
>> +
>> +#define WMI_NSOL_MAX_TARGET_IPS 2
>> +
>> +struct wmi_ns_offload_params {
>> + __le32 tlv_header;
>> + __le32 flags;
>> + u8 target_ipaddr[WMI_NSOL_MAX_TARGET_IPS][16];
>> + u8 solicitation_ipaddr[16];
>> + u8 remote_ipaddr[16];
>> + struct ath12k_wmi_mac_addr_params target_mac;
>> +} __packed;
>> +
>> +struct wmi_set_arp_ns_offload_cmd {
>> + __le32 tlv_header;
>> + __le32 flags;
>> + __le32 vdev_id;
>> + __le32 num_ns_ext_tuples;
>> + /* The TLVs follow:
>> + * wmi_ns_offload_params ns[WMI_MAX_NS_OFFLOADS];
>> + * wmi_arp_offload_params arp[WMI_MAX_ARP_OFFLOADS];
>> + * wmi_ns_offload_params ns_ext[num_ns_ext_tuples];
>> + */
>> +} __packed;
>> +
>> void ath12k_wmi_init_qcn9274(struct ath12k_base *ab,
>> struct ath12k_wmi_resource_config_arg *config);
>> void ath12k_wmi_init_wcn7850(struct ath12k_base *ab,
>> @@ -5481,4 +5542,9 @@ int ath12k_wmi_wow_config_pno(struct ath12k *ar, u32 vdev_id,
>> struct wmi_pno_scan_req_arg *pno_scan);
>> int ath12k_wmi_hw_data_filter_cmd(struct ath12k *ar,
>> struct wmi_hw_data_filter_arg *arg);
>> +int ath12k_wmi_arp_ns_offload(struct ath12k *ar,
>> + struct ath12k_vif *arvif,
>> + struct wmi_arp_ns_offload_arg *offload,
>> + bool enable);
>> +
>> #endif
>> diff --git a/drivers/net/wireless/ath/ath12k/wow.c b/drivers/net/wireless/ath/ath12k/wow.c
>> index 77658a01bb41..92bcafd517e7 100644
>> --- a/drivers/net/wireless/ath/ath12k/wow.c
>> +++ b/drivers/net/wireless/ath/ath12k/wow.c
>> @@ -5,6 +5,9 @@
>> */
>>
>> #include <linux/delay.h>
>> +#include <linux/inetdevice.h>
>> +#include <net/if_inet6.h>
>> +#include <net/ipv6.h>
>>
>> #include "mac.h"
>>
>> @@ -591,6 +594,174 @@ static int ath12k_wow_clear_hw_filter(struct ath12k *ar)
>> return 0;
>> }
>>
>> +static void ath12k_wow_generate_ns_mc_addr(struct ath12k_base *ab,
>> + struct wmi_arp_ns_offload_arg *offload)
>> +{
>> + int i;
>> +
>> + for (i = 0; i < offload->ipv6_count; i++) {
>> + offload->self_ipv6_addr[i][0] = 0xff;
>> + offload->self_ipv6_addr[i][1] = 0x02;
>> + offload->self_ipv6_addr[i][11] = 0x01;
>> + offload->self_ipv6_addr[i][12] = 0xff;
>> + offload->self_ipv6_addr[i][13] =
>> + offload->ipv6_addr[i][13];
>> + offload->self_ipv6_addr[i][14] =
>> + offload->ipv6_addr[i][14];
>> + offload->self_ipv6_addr[i][15] =
>> + offload->ipv6_addr[i][15];
>> + ath12k_dbg(ab, ATH12K_DBG_WOW, "NS solicited addr %pI6\n",
>> + offload->self_ipv6_addr[i]);
>> + }
>> +}
>> +
>> +static void ath12k_wow_prepare_ns_offload(struct ath12k_vif *arvif,
>> + struct wmi_arp_ns_offload_arg *offload)
>> +{
>> + struct inet6_dev *idev = arvif->idev;
>
> as noted above does it make more sense to get the netdev associated with the
> arvif and then use in6_dev_get(net_device) to get the inet6_dev rather than
> caching the pointer from the ipv6_addr_changed() callback?
Ah.. I didn't note that we can get inet6_dev in such a way, just thought the only way is to cache it in ipv6_changed() callback.
will get it using the following in next version:
struct ieee80211_vif *vif = container_of(arvif)
struct ieee80211_sub_if_data *sub_if_data = container_of(vif)
struct net_dev *ndev = sub_if_data->dev
struct inet6_dev *idev = in6_dev_get(ndev)
>
>> + struct ath12k_base *ab = arvif->ar->ab;
>> + struct inet6_ifaddr *ifa6;
>> + struct ifacaddr6 *ifaca6;
>> + u32 count = 0, scope;
>> + struct list_head *p;
>> +
>> + if (!idev)
>> + return;
>> +
>> + ath12k_dbg(ab, ATH12K_DBG_WOW, "wow prepare ns offload\n");
>> +
>> + read_lock_bh(&idev->lock);
>> +
>> + /* get unicast address */
>> + list_for_each(p, &idev->addr_list) {
>> + if (count >= WMI_IPV6_MAX_COUNT)
>> + goto unlock;
>> +
>> + ifa6 = list_entry(p, struct inet6_ifaddr, if_list);
>> + if (ifa6->flags & IFA_F_DADFAILED)
>> + continue;
>> +
>> + scope = ipv6_addr_src_scope(&ifa6->addr);
>> + if (scope != IPV6_ADDR_SCOPE_LINKLOCAL &&
>> + scope != IPV6_ADDR_SCOPE_GLOBAL) {
>> + ath12k_dbg(ab, ATH12K_DBG_WOW,
>> + "Unsupported ipv6 scope: %d\n", scope);
>> + continue;
>> + }
>> +
>> + memcpy(offload->ipv6_addr[count], &ifa6->addr.s6_addr,
>> + sizeof(ifa6->addr.s6_addr));
>> + offload->ipv6_type[count] = WMI_IPV6_UC_TYPE;
>> + ath12k_dbg(ab, ATH12K_DBG_WOW, "mac count %d ipv6 uc %pI6 scope %d\n",
>> + count, offload->ipv6_addr[count],
>> + scope);
>> + count++;
>> + }
>> +
>> + /* get anycast address */
>> + rcu_read_lock();
>> +
>> + for (ifaca6 = rcu_dereference(idev->ac_list); ifaca6;
>> + ifaca6 = rcu_dereference(ifaca6->aca_next)) {
>> + if (count >= WMI_IPV6_MAX_COUNT) {
>> + rcu_read_unlock();
>> + goto unlock;
>> + }
>> +
>> + scope = ipv6_addr_src_scope(&ifaca6->aca_addr);
>> + if (scope != IPV6_ADDR_SCOPE_LINKLOCAL &&
>> + scope != IPV6_ADDR_SCOPE_GLOBAL) {
>> + ath12k_dbg(ab, ATH12K_DBG_WOW,
>> + "Unsupported ipv scope: %d\n", scope);
>> + continue;
>> + }
>> +
>> + memcpy(offload->ipv6_addr[count], &ifaca6->aca_addr,
>> + sizeof(ifaca6->aca_addr));
>> + offload->ipv6_type[count] = WMI_IPV6_AC_TYPE;
>> + ath12k_dbg(ab, ATH12K_DBG_WOW, "mac count %d ipv6 ac %pI6 scope %d\n",
>> + count, offload->ipv6_addr[count],
>> + scope);
>> + count++;
>> + }
>> +
>> + rcu_read_unlock();
>> +
>> +unlock:
>> + read_unlock_bh(&idev->lock);
>> +
>> + offload->ipv6_count = count;
>> + ath12k_wow_generate_ns_mc_addr(ab, offload);
>> +}
>> +
>> +static void ath12k_wow_prepare_arp_offload(struct ath12k_vif *arvif,
>> + struct wmi_arp_ns_offload_arg *offload)
>> +{
>> + struct ieee80211_vif *vif = arvif->vif;
>> + struct ieee80211_vif_cfg vif_cfg = vif->cfg;
>> + struct ath12k_base *ab = arvif->ar->ab;
>> + u32 ipv4_cnt;
>> +
>> + ath12k_dbg(ab, ATH12K_DBG_WOW, "wow prepare arp offload\n");
>> +
>> + ipv4_cnt = min(vif_cfg.arp_addr_cnt, WMI_IPV4_MAX_COUNT);
>> + memcpy(offload->ipv4_addr, vif_cfg.arp_addr_list, ipv4_cnt * sizeof(u32));
>> + offload->ipv4_count = ipv4_cnt;
>> +
>> + ath12k_dbg(ab, ATH12K_DBG_WOW,
>> + "wow arp_addr_cnt %d vif->addr %pM, offload_addr %pI4\n",
>> + vif_cfg.arp_addr_cnt, vif->addr, offload->ipv4_addr);
>> +}
>> +
>> +static int ath12k_wow_arp_ns_offload(struct ath12k *ar, bool enable)
>> +{
>> + struct wmi_arp_ns_offload_arg *offload;
>> + struct ath12k_vif *arvif;
>> + int ret;
>> +
>> + lockdep_assert_held(&ar->conf_mutex);
>> +
>> + offload = kmalloc(sizeof(*offload), GFP_KERNEL);
>> + if (!offload)
>> + return -ENOMEM;
>> +
>> + list_for_each_entry(arvif, &ar->arvifs, list) {
>> + if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
>> + continue;
>> +
>> + memset(offload, 0, sizeof(*offload));
>> +
>> + memcpy(offload->mac_addr, arvif->vif->addr, ETH_ALEN);
>> + ath12k_wow_prepare_ns_offload(arvif, offload);
>> + ath12k_wow_prepare_arp_offload(arvif, offload);
>> +
>> + ret = ath12k_wmi_arp_ns_offload(ar, arvif, offload, enable);
>> + if (ret) {
>> + ath12k_warn(ar->ab, "failed to set arp ns offload vdev %i: enable %d, ret %d\n",
>> + arvif->vdev_id, enable, ret);
>> + return ret;
>> + }
>> + }
>> +
>> + kfree(offload);
>> +
>> + return 0;
>> +}
>> +
>> +static int ath12k_wow_protocol_offload(struct ath12k *ar, bool enable)
>> +{
>> + int ret;
>> +
>> + ret = ath12k_wow_arp_ns_offload(ar, enable);
>> + if (ret) {
>> + ath12k_warn(ar->ab, "failed to offload ARP and NS %d %d\n",
>> + enable, ret);
>> + return ret;
>> + }
>> +
>> + return 0;
>> +}
>> +
>> int ath12k_wow_op_suspend(struct ieee80211_hw *hw,
>> struct cfg80211_wowlan *wowlan)
>> {
>> @@ -614,6 +785,13 @@ int ath12k_wow_op_suspend(struct ieee80211_hw *hw,
>> goto cleanup;
>> }
>>
>> + ret = ath12k_wow_protocol_offload(ar, true);
>> + if (ret) {
>> + ath12k_warn(ar->ab, "failed to set wow protocol offload events: %d\n",
>> + ret);
>> + goto cleanup;
>> + }
>> +
>> ret = ath12k_mac_wait_tx_complete(ar);
>> if (ret) {
>> ath12k_warn(ar->ab, "failed to wait tx complete: %d\n", ret);
>> @@ -700,6 +878,13 @@ int ath12k_wow_op_resume(struct ieee80211_hw *hw)
>> goto exit;
>> }
>>
>> + ret = ath12k_wow_protocol_offload(ar, false);
>> + if (ret) {
>> + ath12k_warn(ar->ab, "failed to clear wow protocol offload events: %d\n",
>> + ret);
>> + goto exit;
>> + }
>> +
>> exit:
>> if (ret) {
>> switch (ah->state) {
>
^ permalink raw reply [flat|nested] 25+ messages in thread* Re: [PATCH v3 6/8] wifi: ath12k: support ARP and NS offload
2024-05-31 3:42 ` Baochen Qiang
@ 2024-05-31 3:49 ` Baochen Qiang
2024-05-31 5:11 ` Baochen Qiang
1 sibling, 0 replies; 25+ messages in thread
From: Baochen Qiang @ 2024-05-31 3:49 UTC (permalink / raw)
To: Jeff Johnson, ath12k; +Cc: linux-wireless
On 5/31/2024 11:42 AM, Baochen Qiang wrote:
>> as noted above does it make more sense to get the netdev associated with the
>> arvif and then use in6_dev_get(net_device) to get the inet6_dev rather than
>> caching the pointer from the ipv6_addr_changed() callback?
> Ah.. I didn't note that we can get inet6_dev in such a way, just thought the only way is to cache it in ipv6_changed() callback.
>
> will get it using the following in next version:
> struct ieee80211_vif *vif = container_of(arvif)
sorry, should be:
struct ieee80211_vif *vif = arvif->vif
> struct ieee80211_sub_if_data *sub_if_data = container_of(vif)
> struct net_dev *ndev = sub_if_data->dev
> struct inet6_dev *idev = in6_dev_get(ndev)
^ permalink raw reply [flat|nested] 25+ messages in thread
* Re: [PATCH v3 6/8] wifi: ath12k: support ARP and NS offload
2024-05-31 3:42 ` Baochen Qiang
2024-05-31 3:49 ` Baochen Qiang
@ 2024-05-31 5:11 ` Baochen Qiang
2024-05-31 17:26 ` Jeff Johnson
2024-06-03 7:36 ` Johannes Berg
1 sibling, 2 replies; 25+ messages in thread
From: Baochen Qiang @ 2024-05-31 5:11 UTC (permalink / raw)
To: Jeff Johnson, ath12k; +Cc: linux-wireless
On 5/31/2024 11:42 AM, Baochen Qiang wrote:
>>> +static void ath12k_wow_prepare_ns_offload(struct ath12k_vif *arvif,
>>> + struct wmi_arp_ns_offload_arg *offload)
>>> +{
>>> + struct inet6_dev *idev = arvif->idev;
>> as noted above does it make more sense to get the netdev associated with the
>> arvif and then use in6_dev_get(net_device) to get the inet6_dev rather than
>> caching the pointer from the ipv6_addr_changed() callback?
> Ah.. I didn't note that we can get inet6_dev in such a way, just thought the only way is to cache it in ipv6_changed() callback.
>
> will get it using the following in next version:
> struct ieee80211_vif *vif = container_of(arvif)
> struct ieee80211_sub_if_data *sub_if_data = container_of(vif)
> struct net_dev *ndev = sub_if_data->dev
> struct inet6_dev *idev = in6_dev_get(ndev)
Just found that ieee80211_sub_if_data is internal to mac80211, so not possible to get netdev in this way.
any other ideas on how to get netdev?
^ permalink raw reply [flat|nested] 25+ messages in thread* Re: [PATCH v3 6/8] wifi: ath12k: support ARP and NS offload
2024-05-31 5:11 ` Baochen Qiang
@ 2024-05-31 17:26 ` Jeff Johnson
2024-06-03 2:47 ` Baochen Qiang
` (2 more replies)
2024-06-03 7:36 ` Johannes Berg
1 sibling, 3 replies; 25+ messages in thread
From: Jeff Johnson @ 2024-05-31 17:26 UTC (permalink / raw)
To: Baochen Qiang, ath12k; +Cc: linux-wireless
On 5/30/2024 10:11 PM, Baochen Qiang wrote:
>
>
> On 5/31/2024 11:42 AM, Baochen Qiang wrote:
>>>> +static void ath12k_wow_prepare_ns_offload(struct ath12k_vif *arvif,
>>>> + struct wmi_arp_ns_offload_arg *offload)
>>>> +{
>>>> + struct inet6_dev *idev = arvif->idev;
>>> as noted above does it make more sense to get the netdev associated with the
>>> arvif and then use in6_dev_get(net_device) to get the inet6_dev rather than
>>> caching the pointer from the ipv6_addr_changed() callback?
>> Ah.. I didn't note that we can get inet6_dev in such a way, just thought the only way is to cache it in ipv6_changed() callback.
>>
>> will get it using the following in next version:
>> struct ieee80211_vif *vif = container_of(arvif)
>> struct ieee80211_sub_if_data *sub_if_data = container_of(vif)
>> struct net_dev *ndev = sub_if_data->dev
>> struct inet6_dev *idev = in6_dev_get(ndev)
> Just found that ieee80211_sub_if_data is internal to mac80211, so not possible to get netdev in this way.
>
> any other ideas on how to get netdev?
Thinking about this some more, it seems like you'd want to send these down to
firmware immediately so that they'd be available for NS offload. Does firmware
support NS offload even when host is awake (I think the downstream Android
driver supports that)?
So perhaps an alternative approach is to collect the information you need from
the notification and then schedule a workqueue to actually send the
information to firmware?
^ permalink raw reply [flat|nested] 25+ messages in thread* Re: [PATCH v3 6/8] wifi: ath12k: support ARP and NS offload
2024-05-31 17:26 ` Jeff Johnson
@ 2024-06-03 2:47 ` Baochen Qiang
2024-06-03 2:48 ` Baochen Qiang
2024-06-03 9:32 ` Baochen Qiang
2 siblings, 0 replies; 25+ messages in thread
From: Baochen Qiang @ 2024-06-03 2:47 UTC (permalink / raw)
To: Jeff Johnson, ath12k; +Cc: linux-wireless
On 6/1/2024 1:26 AM, Jeff Johnson wrote:
> On 5/30/2024 10:11 PM, Baochen Qiang wrote:
>>
>>
>> On 5/31/2024 11:42 AM, Baochen Qiang wrote:
>>>>> +static void ath12k_wow_prepare_ns_offload(struct ath12k_vif *arvif,
>>>>> + struct wmi_arp_ns_offload_arg *offload)
>>>>> +{
>>>>> + struct inet6_dev *idev = arvif->idev;
>>>> as noted above does it make more sense to get the netdev associated with the
>>>> arvif and then use in6_dev_get(net_device) to get the inet6_dev rather than
>>>> caching the pointer from the ipv6_addr_changed() callback?
>>> Ah.. I didn't note that we can get inet6_dev in such a way, just thought the only way is to cache it in ipv6_changed() callback.
>>>
>>> will get it using the following in next version:
>>> struct ieee80211_vif *vif = container_of(arvif)
>>> struct ieee80211_sub_if_data *sub_if_data = container_of(vif)
>>> struct net_dev *ndev = sub_if_data->dev
>>> struct inet6_dev *idev = in6_dev_get(ndev)
>> Just found that ieee80211_sub_if_data is internal to mac80211, so not possible to get netdev in this way.
>>
>> any other ideas on how to get netdev?
>
> Thinking about this some more, it seems like you'd want to send these down to
> firmware immediately so that they'd be available for NS offload. Does firmware
> support NS offload even when host is awake (I think the downstream Android
> driver supports that)?
Checked with firmware team and they confirmed it is supported. But do we really want to do this? Any benefit from offloading when awake?
And won't there be any issues? at least it would make me confused if a arp/NS request/response pair are seen in sniffer but neither of them seen in host ...
> So perhaps an alternative approach is to collect the information you need from
> the notification and then schedule a workqueue to actually send the
> information to firmware?
^ permalink raw reply [flat|nested] 25+ messages in thread* Re: [PATCH v3 6/8] wifi: ath12k: support ARP and NS offload
2024-05-31 17:26 ` Jeff Johnson
2024-06-03 2:47 ` Baochen Qiang
@ 2024-06-03 2:48 ` Baochen Qiang
2024-06-03 14:22 ` Jeff Johnson
2024-06-03 9:32 ` Baochen Qiang
2 siblings, 1 reply; 25+ messages in thread
From: Baochen Qiang @ 2024-06-03 2:48 UTC (permalink / raw)
To: Jeff Johnson, ath12k; +Cc: linux-wireless
On 6/1/2024 1:26 AM, Jeff Johnson wrote:
> On 5/30/2024 10:11 PM, Baochen Qiang wrote:
>>
>>
>> On 5/31/2024 11:42 AM, Baochen Qiang wrote:
>>>>> +static void ath12k_wow_prepare_ns_offload(struct ath12k_vif *arvif,
>>>>> + struct wmi_arp_ns_offload_arg *offload)
>>>>> +{
>>>>> + struct inet6_dev *idev = arvif->idev;
>>>> as noted above does it make more sense to get the netdev associated with the
>>>> arvif and then use in6_dev_get(net_device) to get the inet6_dev rather than
>>>> caching the pointer from the ipv6_addr_changed() callback?
>>> Ah.. I didn't note that we can get inet6_dev in such a way, just thought the only way is to cache it in ipv6_changed() callback.
>>>
>>> will get it using the following in next version:
>>> struct ieee80211_vif *vif = container_of(arvif)
>>> struct ieee80211_sub_if_data *sub_if_data = container_of(vif)
>>> struct net_dev *ndev = sub_if_data->dev
>>> struct inet6_dev *idev = in6_dev_get(ndev)
>> Just found that ieee80211_sub_if_data is internal to mac80211, so not possible to get netdev in this way.
>>
>> any other ideas on how to get netdev?
>
> Thinking about this some more, it seems like you'd want to send these down to
> firmware immediately so that they'd be available for NS offload. Does firmware
> support NS offload even when host is awake (I think the downstream Android
> driver supports that)?
And really curious about the use case in Android scenario.
>
> So perhaps an alternative approach is to collect the information you need from
> the notification and then schedule a workqueue to actually send the
> information to firmware?
^ permalink raw reply [flat|nested] 25+ messages in thread* Re: [PATCH v3 6/8] wifi: ath12k: support ARP and NS offload
2024-06-03 2:48 ` Baochen Qiang
@ 2024-06-03 14:22 ` Jeff Johnson
0 siblings, 0 replies; 25+ messages in thread
From: Jeff Johnson @ 2024-06-03 14:22 UTC (permalink / raw)
To: Baochen Qiang, ath12k; +Cc: linux-wireless
On 6/2/2024 7:48 PM, Baochen Qiang wrote:
>
>
> On 6/1/2024 1:26 AM, Jeff Johnson wrote:
>> On 5/30/2024 10:11 PM, Baochen Qiang wrote:
>>>
>>>
>>> On 5/31/2024 11:42 AM, Baochen Qiang wrote:
>>>>>> +static void ath12k_wow_prepare_ns_offload(struct ath12k_vif *arvif,
>>>>>> + struct wmi_arp_ns_offload_arg *offload)
>>>>>> +{
>>>>>> + struct inet6_dev *idev = arvif->idev;
>>>>> as noted above does it make more sense to get the netdev associated with the
>>>>> arvif and then use in6_dev_get(net_device) to get the inet6_dev rather than
>>>>> caching the pointer from the ipv6_addr_changed() callback?
>>>> Ah.. I didn't note that we can get inet6_dev in such a way, just thought the only way is to cache it in ipv6_changed() callback.
>>>>
>>>> will get it using the following in next version:
>>>> struct ieee80211_vif *vif = container_of(arvif)
>>>> struct ieee80211_sub_if_data *sub_if_data = container_of(vif)
>>>> struct net_dev *ndev = sub_if_data->dev
>>>> struct inet6_dev *idev = in6_dev_get(ndev)
>>> Just found that ieee80211_sub_if_data is internal to mac80211, so not possible to get netdev in this way.
>>>
>>> any other ideas on how to get netdev?
>>
>> Thinking about this some more, it seems like you'd want to send these down to
>> firmware immediately so that they'd be available for NS offload. Does firmware
>> support NS offload even when host is awake (I think the downstream Android
>> driver supports that)?
> And really curious about the use case in Android scenario.
It's all about saving power. The application processor consumes way more power
than the firmware processors, so any work that can be performed by firmware
extends battery life.
A laptop running on battery would presumably benefit from this as well.
But let's get basic functionality in place using ieee80211_vif_to_wdev()
^ permalink raw reply [flat|nested] 25+ messages in thread
* Re: [PATCH v3 6/8] wifi: ath12k: support ARP and NS offload
2024-05-31 17:26 ` Jeff Johnson
2024-06-03 2:47 ` Baochen Qiang
2024-06-03 2:48 ` Baochen Qiang
@ 2024-06-03 9:32 ` Baochen Qiang
2 siblings, 0 replies; 25+ messages in thread
From: Baochen Qiang @ 2024-06-03 9:32 UTC (permalink / raw)
To: Jeff Johnson, ath12k; +Cc: linux-wireless
On 6/1/2024 1:26 AM, Jeff Johnson wrote:
> On 5/30/2024 10:11 PM, Baochen Qiang wrote:
>>
>>
>> On 5/31/2024 11:42 AM, Baochen Qiang wrote:
>>>>> +static void ath12k_wow_prepare_ns_offload(struct ath12k_vif *arvif,
>>>>> + struct wmi_arp_ns_offload_arg *offload)
>>>>> +{
>>>>> + struct inet6_dev *idev = arvif->idev;
>>>> as noted above does it make more sense to get the netdev associated with the
>>>> arvif and then use in6_dev_get(net_device) to get the inet6_dev rather than
>>>> caching the pointer from the ipv6_addr_changed() callback?
>>> Ah.. I didn't note that we can get inet6_dev in such a way, just thought the only way is to cache it in ipv6_changed() callback.
>>>
>>> will get it using the following in next version:
>>> struct ieee80211_vif *vif = container_of(arvif)
>>> struct ieee80211_sub_if_data *sub_if_data = container_of(vif)
>>> struct net_dev *ndev = sub_if_data->dev
>>> struct inet6_dev *idev = in6_dev_get(ndev)
>> Just found that ieee80211_sub_if_data is internal to mac80211, so not possible to get netdev in this way.
>>
>> any other ideas on how to get netdev?
>
> Thinking about this some more, it seems like you'd want to send these down to
> firmware immediately so that they'd be available for NS offload. Does firmware
> support NS offload even when host is awake (I think the downstream Android
> driver supports that)?
>
> So perhaps an alternative approach is to collect the information you need from
> the notification and then schedule a workqueue to actually send the
> information to firmware?
As is pointed out by johannes in another reply, if you are OK with original proposal I can go getting ieee80211_vif_to_wdev(arvif->vif)->netdev in ath12k_wow_prepare_ns_offloa().
^ permalink raw reply [flat|nested] 25+ messages in thread
* Re: [PATCH v3 6/8] wifi: ath12k: support ARP and NS offload
2024-05-31 5:11 ` Baochen Qiang
2024-05-31 17:26 ` Jeff Johnson
@ 2024-06-03 7:36 ` Johannes Berg
2024-06-03 9:15 ` Baochen Qiang
1 sibling, 1 reply; 25+ messages in thread
From: Johannes Berg @ 2024-06-03 7:36 UTC (permalink / raw)
To: Baochen Qiang, Jeff Johnson, ath12k; +Cc: linux-wireless
On Fri, 2024-05-31 at 13:11 +0800, Baochen Qiang wrote:
>
> On 5/31/2024 11:42 AM, Baochen Qiang wrote:
> > > > +static void ath12k_wow_prepare_ns_offload(struct ath12k_vif *arvif,
> > > > + struct wmi_arp_ns_offload_arg *offload)
> > > > +{
> > > > + struct inet6_dev *idev = arvif->idev;
> > > as noted above does it make more sense to get the netdev associated with the
> > > arvif and then use in6_dev_get(net_device) to get the inet6_dev rather than
> > > caching the pointer from the ipv6_addr_changed() callback?
> > Ah.. I didn't note that we can get inet6_dev in such a way, just thought the only way is to cache it in ipv6_changed() callback.
> >
> > will get it using the following in next version:
> > struct ieee80211_vif *vif = container_of(arvif)
> > struct ieee80211_sub_if_data *sub_if_data = container_of(vif)
> > struct net_dev *ndev = sub_if_data->dev
> > struct inet6_dev *idev = in6_dev_get(ndev)
> Just found that ieee80211_sub_if_data is internal to mac80211, so not possible to get netdev in this way.
>
> any other ideas on how to get netdev?
You can go via the wdev.
johannes
^ permalink raw reply [flat|nested] 25+ messages in thread* Re: [PATCH v3 6/8] wifi: ath12k: support ARP and NS offload
2024-06-03 7:36 ` Johannes Berg
@ 2024-06-03 9:15 ` Baochen Qiang
0 siblings, 0 replies; 25+ messages in thread
From: Baochen Qiang @ 2024-06-03 9:15 UTC (permalink / raw)
To: Johannes Berg, Jeff Johnson, ath12k; +Cc: linux-wireless
On 6/3/2024 3:36 PM, Johannes Berg wrote:
> On Fri, 2024-05-31 at 13:11 +0800, Baochen Qiang wrote:
>>
>> On 5/31/2024 11:42 AM, Baochen Qiang wrote:
>>>>> +static void ath12k_wow_prepare_ns_offload(struct ath12k_vif *arvif,
>>>>> + struct wmi_arp_ns_offload_arg *offload)
>>>>> +{
>>>>> + struct inet6_dev *idev = arvif->idev;
>>>> as noted above does it make more sense to get the netdev associated with the
>>>> arvif and then use in6_dev_get(net_device) to get the inet6_dev rather than
>>>> caching the pointer from the ipv6_addr_changed() callback?
>>> Ah.. I didn't note that we can get inet6_dev in such a way, just thought the only way is to cache it in ipv6_changed() callback.
>>>
>>> will get it using the following in next version:
>>> struct ieee80211_vif *vif = container_of(arvif)
>>> struct ieee80211_sub_if_data *sub_if_data = container_of(vif)
>>> struct net_dev *ndev = sub_if_data->dev
>>> struct inet6_dev *idev = in6_dev_get(ndev)
>> Just found that ieee80211_sub_if_data is internal to mac80211, so not possible to get netdev in this way.
>>
>> any other ideas on how to get netdev?
>
> You can go via the wdev.
>
Ah, great! I can get it with ieee80211_vif_to_wdev(arvif->vif)->netdev. Thank you for pointing that.
> johannes
^ permalink raw reply [flat|nested] 25+ messages in thread
* [PATCH v3 7/8] wifi: ath12k: support GTK rekey offload
2024-05-30 7:27 [PATCH v3 0/8] wifi: ath12k: add support for WoW Baochen Qiang
` (5 preceding siblings ...)
2024-05-30 7:27 ` [PATCH v3 6/8] wifi: ath12k: support ARP and NS offload Baochen Qiang
@ 2024-05-30 7:27 ` Baochen Qiang
2024-05-30 7:27 ` [PATCH v3 8/8] wifi: ath12k: handle keepalive during WoWLAN suspend and resume Baochen Qiang
2024-05-30 17:45 ` [PATCH v3 0/8] wifi: ath12k: add support for WoW Jeff Johnson
8 siblings, 0 replies; 25+ messages in thread
From: Baochen Qiang @ 2024-05-30 7:27 UTC (permalink / raw)
To: ath12k; +Cc: linux-wireless, quic_bqiang
Host sets GTK related info to firmware before WoW is enabled, and
gets rekey replay_count and then disables GTK rekey when WoW quits.
Tested-on: WCN7850 hw2.0 PCI WLAN.HMT.1.0-03427-QCAHMTSWPL_V1.0_V2.0_SILICONZ-1.15378.4
Signed-off-by: Baochen Qiang <quic_bqiang@quicinc.com>
---
drivers/net/wireless/ath/ath12k/core.h | 8 ++
drivers/net/wireless/ath/ath12k/mac.c | 38 +++++++++
drivers/net/wireless/ath/ath12k/wmi.c | 112 +++++++++++++++++++++++++
drivers/net/wireless/ath/ath12k/wmi.h | 39 +++++++++
drivers/net/wireless/ath/ath12k/wow.c | 46 +++++++++-
5 files changed, 242 insertions(+), 1 deletion(-)
diff --git a/drivers/net/wireless/ath/ath12k/core.h b/drivers/net/wireless/ath/ath12k/core.h
index f98c3e7c413e..6e7d2dfb1205 100644
--- a/drivers/net/wireless/ath/ath12k/core.h
+++ b/drivers/net/wireless/ath/ath12k/core.h
@@ -229,6 +229,13 @@ struct ath12k_vif_cache {
u32 bss_conf_changed;
};
+struct ath12k_rekey_data {
+ u8 kck[NL80211_KCK_LEN];
+ u8 kek[NL80211_KCK_LEN];
+ u64 replay_ctr;
+ bool enable_offload;
+};
+
struct ath12k_vif {
u32 vdev_id;
enum wmi_vdev_type vdev_type;
@@ -286,6 +293,7 @@ struct ath12k_vif {
bool ps;
struct ath12k_vif_cache *cache;
struct inet6_dev *idev;
+ struct ath12k_rekey_data rekey_data;
};
struct ath12k_vif_iter {
diff --git a/drivers/net/wireless/ath/ath12k/mac.c b/drivers/net/wireless/ath/ath12k/mac.c
index 70311b94fef8..198b8bad0b16 100644
--- a/drivers/net/wireless/ath/ath12k/mac.c
+++ b/drivers/net/wireless/ath/ath12k/mac.c
@@ -2837,6 +2837,7 @@ static void ath12k_bss_assoc(struct ath12k *ar,
}
arvif->is_up = true;
+ arvif->rekey_data.enable_offload = false;
ath12k_dbg(ar->ab, ATH12K_DBG_MAC,
"mac vdev %d up (associated) bssid %pM aid %d\n",
@@ -2884,6 +2885,8 @@ static void ath12k_bss_disassoc(struct ath12k *ar,
arvif->is_up = false;
+ memset(&arvif->rekey_data, 0, sizeof(arvif->rekey_data));
+
cancel_delayed_work(&arvif->connection_loss_work);
}
@@ -8516,6 +8519,40 @@ static __maybe_unused void ath12k_mac_op_ipv6_changed(struct ieee80211_hw *hw,
arvif->idev = idev;
}
+static void ath12k_mac_op_set_rekey_data(struct ieee80211_hw *hw,
+ struct ieee80211_vif *vif,
+ struct cfg80211_gtk_rekey_data *data)
+{
+ struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif);
+ struct ath12k_rekey_data *rekey_data = &arvif->rekey_data;
+ struct ath12k_hw *ah = ath12k_hw_to_ah(hw);
+ struct ath12k *ar = ath12k_ah_to_ar(ah, 0);
+
+ ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac set rekey data vdev %d\n",
+ arvif->vdev_id);
+
+ mutex_lock(&ar->conf_mutex);
+
+ memcpy(rekey_data->kck, data->kck, NL80211_KCK_LEN);
+ memcpy(rekey_data->kek, data->kek, NL80211_KEK_LEN);
+
+ /* The supplicant works on big-endian, the firmware expects it on
+ * little endian.
+ */
+ rekey_data->replay_ctr = get_unaligned_be64(data->replay_ctr);
+
+ arvif->rekey_data.enable_offload = true;
+
+ ath12k_dbg_dump(ar->ab, ATH12K_DBG_MAC, "kck", NULL,
+ rekey_data->kck, NL80211_KCK_LEN);
+ ath12k_dbg_dump(ar->ab, ATH12K_DBG_MAC, "kek", NULL,
+ rekey_data->kck, NL80211_KEK_LEN);
+ ath12k_dbg_dump(ar->ab, ATH12K_DBG_MAC, "replay ctr", NULL,
+ &rekey_data->replay_ctr, sizeof(rekey_data->replay_ctr));
+
+ mutex_unlock(&ar->conf_mutex);
+}
+
static const struct ieee80211_ops ath12k_ops = {
.tx = ath12k_mac_op_tx,
.wake_tx_queue = ieee80211_handle_wake_tx_queue,
@@ -8531,6 +8568,7 @@ static const struct ieee80211_ops ath12k_ops = {
.hw_scan = ath12k_mac_op_hw_scan,
.cancel_hw_scan = ath12k_mac_op_cancel_hw_scan,
.set_key = ath12k_mac_op_set_key,
+ .set_rekey_data = ath12k_mac_op_set_rekey_data,
.sta_state = ath12k_mac_op_sta_state,
.sta_set_txpwr = ath12k_mac_op_sta_set_txpwr,
.sta_rc_update = ath12k_mac_op_sta_rc_update,
diff --git a/drivers/net/wireless/ath/ath12k/wmi.c b/drivers/net/wireless/ath/ath12k/wmi.c
index 8148e518969e..a397c33c7449 100644
--- a/drivers/net/wireless/ath/ath12k/wmi.c
+++ b/drivers/net/wireless/ath/ath12k/wmi.c
@@ -7089,6 +7089,56 @@ static void ath12k_wmi_event_wow_wakeup_host(struct ath12k_base *ab, struct sk_b
complete(&ab->wow.wakeup_completed);
}
+static void ath12k_wmi_gtk_offload_status_event(struct ath12k_base *ab,
+ struct sk_buff *skb)
+{
+ const struct wmi_gtk_offload_status_event *ev;
+ struct ath12k_vif *arvif;
+ __be64 replay_ctr_be;
+ u64 replay_ctr;
+ const void **tb;
+ int ret;
+
+ tb = ath12k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
+ if (IS_ERR(tb)) {
+ ret = PTR_ERR(tb);
+ ath12k_warn(ab, "failed to parse tlv: %d\n", ret);
+ return;
+ }
+
+ ev = tb[WMI_TAG_GTK_OFFLOAD_STATUS_EVENT];
+ if (!ev) {
+ ath12k_warn(ab, "failed to fetch gtk offload status ev");
+ kfree(tb);
+ return;
+ }
+
+ rcu_read_lock();
+ arvif = ath12k_mac_get_arvif_by_vdev_id(ab, le32_to_cpu(ev->vdev_id));
+ if (!arvif) {
+ rcu_read_unlock();
+ ath12k_warn(ab, "failed to get arvif for vdev_id:%d\n",
+ le32_to_cpu(ev->vdev_id));
+ kfree(tb);
+ return;
+ }
+
+ replay_ctr = le64_to_cpu(ev->replay_ctr);
+ arvif->rekey_data.replay_ctr = replay_ctr;
+ ath12k_dbg(ab, ATH12K_DBG_WMI, "wmi gtk offload event refresh_cnt %d replay_ctr %llu\n",
+ le32_to_cpu(ev->refresh_cnt), replay_ctr);
+
+ /* supplicant expects big-endian replay counter */
+ replay_ctr_be = cpu_to_be64(replay_ctr);
+
+ ieee80211_gtk_rekey_notify(arvif->vif, arvif->bssid,
+ (void *)&replay_ctr_be, GFP_ATOMIC);
+
+ rcu_read_unlock();
+
+ kfree(tb);
+}
+
static void ath12k_wmi_op_rx(struct ath12k_base *ab, struct sk_buff *skb)
{
struct wmi_cmd_hdr *cmd_hdr;
@@ -7212,6 +7262,9 @@ static void ath12k_wmi_op_rx(struct ath12k_base *ab, struct sk_buff *skb)
case WMI_WOW_WAKEUP_HOST_EVENTID:
ath12k_wmi_event_wow_wakeup_host(ab, skb);
break;
+ case WMI_GTK_OFFLOAD_STATUS_EVENTID:
+ ath12k_wmi_gtk_offload_status_event(ab, skb);
+ break;
/* TODO: Add remaining events */
default:
ath12k_dbg(ab, ATH12K_DBG_WMI, "Unknown eventid: 0x%x\n", id);
@@ -7928,3 +7981,62 @@ int ath12k_wmi_arp_ns_offload(struct ath12k *ar,
return ath12k_wmi_cmd_send(ar->wmi, skb, WMI_SET_ARP_NS_OFFLOAD_CMDID);
}
+
+int ath12k_wmi_gtk_rekey_offload(struct ath12k *ar,
+ struct ath12k_vif *arvif, bool enable)
+{
+ struct ath12k_rekey_data *rekey_data = &arvif->rekey_data;
+ struct wmi_gtk_rekey_offload_cmd *cmd;
+ struct sk_buff *skb;
+ __le64 replay_ctr;
+ int len;
+
+ len = sizeof(*cmd);
+ skb = ath12k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
+ if (!skb)
+ return -ENOMEM;
+
+ cmd = (struct wmi_gtk_rekey_offload_cmd *)skb->data;
+ cmd->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_GTK_OFFLOAD_CMD, sizeof(*cmd));
+ cmd->vdev_id = cpu_to_le32(arvif->vdev_id);
+
+ if (enable) {
+ cmd->flags = cpu_to_le32(GTK_OFFLOAD_ENABLE_OPCODE);
+
+ /* the length in rekey_data and cmd is equal */
+ memcpy(cmd->kck, rekey_data->kck, sizeof(cmd->kck));
+ memcpy(cmd->kek, rekey_data->kek, sizeof(cmd->kek));
+
+ replay_ctr = cpu_to_le64(rekey_data->replay_ctr);
+ memcpy(cmd->replay_ctr, &replay_ctr,
+ sizeof(replay_ctr));
+ } else {
+ cmd->flags = cpu_to_le32(GTK_OFFLOAD_DISABLE_OPCODE);
+ }
+
+ ath12k_dbg(ar->ab, ATH12K_DBG_WMI, "offload gtk rekey vdev: %d %d\n",
+ arvif->vdev_id, enable);
+ return ath12k_wmi_cmd_send(ar->wmi, skb, WMI_GTK_OFFLOAD_CMDID);
+}
+
+int ath12k_wmi_gtk_rekey_getinfo(struct ath12k *ar,
+ struct ath12k_vif *arvif)
+{
+ struct wmi_gtk_rekey_offload_cmd *cmd;
+ struct sk_buff *skb;
+ int len;
+
+ len = sizeof(*cmd);
+ skb = ath12k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
+ if (!skb)
+ return -ENOMEM;
+
+ cmd = (struct wmi_gtk_rekey_offload_cmd *)skb->data;
+ cmd->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_GTK_OFFLOAD_CMD, sizeof(*cmd));
+ cmd->vdev_id = cpu_to_le32(arvif->vdev_id);
+ cmd->flags = cpu_to_le32(GTK_OFFLOAD_REQUEST_STATUS_OPCODE);
+
+ ath12k_dbg(ar->ab, ATH12K_DBG_WMI, "get gtk rekey vdev_id: %d\n",
+ arvif->vdev_id);
+ return ath12k_wmi_cmd_send(ar->wmi, skb, WMI_GTK_OFFLOAD_CMDID);
+}
diff --git a/drivers/net/wireless/ath/ath12k/wmi.h b/drivers/net/wireless/ath/ath12k/wmi.h
index 0542d599d33d..0188dc78139b 100644
--- a/drivers/net/wireless/ath/ath12k/wmi.h
+++ b/drivers/net/wireless/ath/ath12k/wmi.h
@@ -5377,6 +5377,41 @@ struct wmi_set_arp_ns_offload_cmd {
*/
} __packed;
+#define GTK_OFFLOAD_OPCODE_MASK 0xFF000000
+#define GTK_OFFLOAD_ENABLE_OPCODE 0x01000000
+#define GTK_OFFLOAD_DISABLE_OPCODE 0x02000000
+#define GTK_OFFLOAD_REQUEST_STATUS_OPCODE 0x04000000
+
+#define GTK_OFFLOAD_KEK_BYTES 16
+#define GTK_OFFLOAD_KCK_BYTES 16
+#define GTK_REPLAY_COUNTER_BYTES 8
+#define WMI_MAX_KEY_LEN 32
+#define IGTK_PN_SIZE 6
+
+struct wmi_gtk_offload_status_event {
+ __le32 vdev_id;
+ __le32 flags;
+ __le32 refresh_cnt;
+ __le64 replay_ctr;
+ u8 igtk_key_index;
+ u8 igtk_key_length;
+ u8 igtk_key_rsc[IGTK_PN_SIZE];
+ u8 igtk_key[WMI_MAX_KEY_LEN];
+ u8 gtk_key_index;
+ u8 gtk_key_length;
+ u8 gtk_key_rsc[GTK_REPLAY_COUNTER_BYTES];
+ u8 gtk_key[WMI_MAX_KEY_LEN];
+} __packed;
+
+struct wmi_gtk_rekey_offload_cmd {
+ __le32 tlv_header;
+ __le32 vdev_id;
+ __le32 flags;
+ u8 kek[GTK_OFFLOAD_KEK_BYTES];
+ u8 kck[GTK_OFFLOAD_KCK_BYTES];
+ u8 replay_ctr[GTK_REPLAY_COUNTER_BYTES];
+} __packed;
+
void ath12k_wmi_init_qcn9274(struct ath12k_base *ab,
struct ath12k_wmi_resource_config_arg *config);
void ath12k_wmi_init_wcn7850(struct ath12k_base *ab,
@@ -5546,5 +5581,9 @@ int ath12k_wmi_arp_ns_offload(struct ath12k *ar,
struct ath12k_vif *arvif,
struct wmi_arp_ns_offload_arg *offload,
bool enable);
+int ath12k_wmi_gtk_rekey_offload(struct ath12k *ar,
+ struct ath12k_vif *arvif, bool enable);
+int ath12k_wmi_gtk_rekey_getinfo(struct ath12k *ar,
+ struct ath12k_vif *arvif);
#endif
diff --git a/drivers/net/wireless/ath/ath12k/wow.c b/drivers/net/wireless/ath/ath12k/wow.c
index 92bcafd517e7..755bdae1b9ad 100644
--- a/drivers/net/wireless/ath/ath12k/wow.c
+++ b/drivers/net/wireless/ath/ath12k/wow.c
@@ -20,7 +20,9 @@
static const struct wiphy_wowlan_support ath12k_wowlan_support = {
.flags = WIPHY_WOWLAN_DISCONNECT |
- WIPHY_WOWLAN_MAGIC_PKT,
+ WIPHY_WOWLAN_MAGIC_PKT |
+ WIPHY_WOWLAN_SUPPORTS_GTK_REKEY |
+ WIPHY_WOWLAN_GTK_REKEY_FAILURE,
.pattern_min_len = WOW_MIN_PATTERN_SIZE,
.pattern_max_len = WOW_MAX_PATTERN_SIZE,
.max_pkt_offset = WOW_MAX_PKT_OFFSET,
@@ -748,6 +750,41 @@ static int ath12k_wow_arp_ns_offload(struct ath12k *ar, bool enable)
return 0;
}
+static int ath12k_gtk_rekey_offload(struct ath12k *ar, bool enable)
+{
+ struct ath12k_vif *arvif;
+ int ret;
+
+ lockdep_assert_held(&ar->conf_mutex);
+
+ list_for_each_entry(arvif, &ar->arvifs, list) {
+ if (arvif->vdev_type != WMI_VDEV_TYPE_STA ||
+ !arvif->is_up ||
+ !arvif->rekey_data.enable_offload)
+ continue;
+
+ /* get rekey info before disable rekey offload */
+ if (!enable) {
+ ret = ath12k_wmi_gtk_rekey_getinfo(ar, arvif);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to request rekey info vdev %i, ret %d\n",
+ arvif->vdev_id, ret);
+ return ret;
+ }
+ }
+
+ ret = ath12k_wmi_gtk_rekey_offload(ar, arvif, enable);
+
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to offload gtk reky vdev %i: enable %d, ret %d\n",
+ arvif->vdev_id, enable, ret);
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
static int ath12k_wow_protocol_offload(struct ath12k *ar, bool enable)
{
int ret;
@@ -759,6 +796,13 @@ static int ath12k_wow_protocol_offload(struct ath12k *ar, bool enable)
return ret;
}
+ ret = ath12k_gtk_rekey_offload(ar, enable);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to offload gtk rekey %d %d\n",
+ enable, ret);
+ return ret;
+ }
+
return 0;
}
--
2.25.1
^ permalink raw reply related [flat|nested] 25+ messages in thread* [PATCH v3 8/8] wifi: ath12k: handle keepalive during WoWLAN suspend and resume
2024-05-30 7:27 [PATCH v3 0/8] wifi: ath12k: add support for WoW Baochen Qiang
` (6 preceding siblings ...)
2024-05-30 7:27 ` [PATCH v3 7/8] wifi: ath12k: support GTK rekey offload Baochen Qiang
@ 2024-05-30 7:27 ` Baochen Qiang
2024-05-30 17:45 ` [PATCH v3 0/8] wifi: ath12k: add support for WoW Jeff Johnson
8 siblings, 0 replies; 25+ messages in thread
From: Baochen Qiang @ 2024-05-30 7:27 UTC (permalink / raw)
To: ath12k; +Cc: linux-wireless, quic_bqiang
With WoWLAN enabled and after sleeping for a rather long time,
we are seeing that with some APs, it is not able to wake up
the STA though the correct wake up pattern has been configured.
This is because the host doesn't send keepalive command to
firmware, thus firmware will not send any packet to the AP and
after a specific time the AP kicks out the STA.
So enable keepalive before going to suspend and disable it after
resume back.
Tested-on: WCN7850 hw2.0 PCI WLAN.HMT.1.0-03427-QCAHMTSWPL_V1.0_V2.0_SILICONZ-1.15378.4
Signed-off-by: Baochen Qiang <quic_bqiang@quicinc.com>
Acked-by: Jeff Johnson <quic_jjohnson@quicinc.com>
---
drivers/net/wireless/ath/ath12k/mac.c | 31 ++++++++++++++++++
drivers/net/wireless/ath/ath12k/mac.h | 4 +++
drivers/net/wireless/ath/ath12k/wmi.c | 38 ++++++++++++++++++++++
drivers/net/wireless/ath/ath12k/wmi.h | 46 +++++++++++++++++++++++++++
drivers/net/wireless/ath/ath12k/wow.c | 34 ++++++++++++++++++++
5 files changed, 153 insertions(+)
diff --git a/drivers/net/wireless/ath/ath12k/mac.c b/drivers/net/wireless/ath/ath12k/mac.c
index 198b8bad0b16..b60b6716be3e 100644
--- a/drivers/net/wireless/ath/ath12k/mac.c
+++ b/drivers/net/wireless/ath/ath12k/mac.c
@@ -9386,3 +9386,34 @@ int ath12k_mac_allocate(struct ath12k_base *ab)
return ret;
}
+
+int ath12k_mac_vif_set_keepalive(struct ath12k_vif *arvif,
+ enum wmi_sta_keepalive_method method,
+ u32 interval)
+{
+ struct wmi_sta_keepalive_arg arg = {};
+ struct ath12k *ar = arvif->ar;
+ int ret;
+
+ lockdep_assert_held(&ar->conf_mutex);
+
+ if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
+ return 0;
+
+ if (!test_bit(WMI_TLV_SERVICE_STA_KEEP_ALIVE, ar->ab->wmi_ab.svc_map))
+ return 0;
+
+ arg.vdev_id = arvif->vdev_id;
+ arg.enabled = 1;
+ arg.method = method;
+ arg.interval = interval;
+
+ ret = ath12k_wmi_sta_keepalive(ar, &arg);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to set keepalive on vdev %i: %d\n",
+ arvif->vdev_id, ret);
+ return ret;
+ }
+
+ return 0;
+}
diff --git a/drivers/net/wireless/ath/ath12k/mac.h b/drivers/net/wireless/ath/ath12k/mac.h
index 69fd282b9dd3..2c6cb144827a 100644
--- a/drivers/net/wireless/ath/ath12k/mac.h
+++ b/drivers/net/wireless/ath/ath12k/mac.h
@@ -9,6 +9,7 @@
#include <net/mac80211.h>
#include <net/cfg80211.h>
+#include "wmi.h"
struct ath12k;
struct ath12k_base;
@@ -81,5 +82,8 @@ int ath12k_mac_rfkill_config(struct ath12k *ar);
int ath12k_mac_wait_tx_complete(struct ath12k *ar);
void ath12k_mac_handle_beacon(struct ath12k *ar, struct sk_buff *skb);
void ath12k_mac_handle_beacon_miss(struct ath12k *ar, u32 vdev_id);
+int ath12k_mac_vif_set_keepalive(struct ath12k_vif *arvif,
+ enum wmi_sta_keepalive_method method,
+ u32 interval);
#endif
diff --git a/drivers/net/wireless/ath/ath12k/wmi.c b/drivers/net/wireless/ath/ath12k/wmi.c
index a397c33c7449..01b6f06f9daa 100644
--- a/drivers/net/wireless/ath/ath12k/wmi.c
+++ b/drivers/net/wireless/ath/ath12k/wmi.c
@@ -8040,3 +8040,41 @@ int ath12k_wmi_gtk_rekey_getinfo(struct ath12k *ar,
arvif->vdev_id);
return ath12k_wmi_cmd_send(ar->wmi, skb, WMI_GTK_OFFLOAD_CMDID);
}
+
+int ath12k_wmi_sta_keepalive(struct ath12k *ar,
+ const struct wmi_sta_keepalive_arg *arg)
+{
+ struct wmi_sta_keepalive_arp_resp_params *arp;
+ struct ath12k_wmi_pdev *wmi = ar->wmi;
+ struct wmi_sta_keepalive_cmd *cmd;
+ struct sk_buff *skb;
+ size_t len;
+
+ len = sizeof(*cmd) + sizeof(*arp);
+ skb = ath12k_wmi_alloc_skb(wmi->wmi_ab, len);
+ if (!skb)
+ return -ENOMEM;
+
+ cmd = (struct wmi_sta_keepalive_cmd *)skb->data;
+ cmd->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_STA_KEEPALIVE_CMD, sizeof(*cmd));
+ cmd->vdev_id = cpu_to_le32(arg->vdev_id);
+ cmd->enabled = cpu_to_le32(arg->enabled);
+ cmd->interval = cpu_to_le32(arg->interval);
+ cmd->method = cpu_to_le32(arg->method);
+
+ arp = (struct wmi_sta_keepalive_arp_resp_params *)(cmd + 1);
+ arp->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_STA_KEEPALVE_ARP_RESPONSE,
+ sizeof(*arp));
+ if (arg->method == WMI_STA_KEEPALIVE_METHOD_UNSOLICITED_ARP_RESPONSE ||
+ arg->method == WMI_STA_KEEPALIVE_METHOD_GRATUITOUS_ARP_REQUEST) {
+ arp->src_ip4_addr = cpu_to_le32(arg->src_ip4_addr);
+ arp->dest_ip4_addr = cpu_to_le32(arg->dest_ip4_addr);
+ ether_addr_copy(arp->dest_mac_addr.addr, arg->dest_mac_addr);
+ }
+
+ ath12k_dbg(ar->ab, ATH12K_DBG_WMI,
+ "wmi sta keepalive vdev %d enabled %d method %d interval %d\n",
+ arg->vdev_id, arg->enabled, arg->method, arg->interval);
+
+ return ath12k_wmi_cmd_send(wmi, skb, WMI_STA_KEEPALIVE_CMDID);
+}
diff --git a/drivers/net/wireless/ath/ath12k/wmi.h b/drivers/net/wireless/ath/ath12k/wmi.h
index 0188dc78139b..7d2da9dfdacb 100644
--- a/drivers/net/wireless/ath/ath12k/wmi.h
+++ b/drivers/net/wireless/ath/ath12k/wmi.h
@@ -5412,6 +5412,50 @@ struct wmi_gtk_rekey_offload_cmd {
u8 replay_ctr[GTK_REPLAY_COUNTER_BYTES];
} __packed;
+struct wmi_sta_keepalive_cmd {
+ __le32 tlv_header;
+ __le32 vdev_id;
+ __le32 enabled;
+
+ /* WMI_STA_KEEPALIVE_METHOD_ */
+ __le32 method;
+
+ /* in seconds */
+ __le32 interval;
+
+ /* following this structure is the TLV for struct
+ * wmi_sta_keepalive_arp_resp_params
+ */
+} __packed;
+
+struct wmi_sta_keepalive_arp_resp_params {
+ __le32 tlv_header;
+ __le32 src_ip4_addr;
+ __le32 dest_ip4_addr;
+ struct ath12k_wmi_mac_addr_params dest_mac_addr;
+} __packed;
+
+struct wmi_sta_keepalive_arg {
+ u32 vdev_id;
+ u32 enabled;
+ u32 method;
+ u32 interval;
+ u32 src_ip4_addr;
+ u32 dest_ip4_addr;
+ const u8 dest_mac_addr[ETH_ALEN];
+};
+
+enum wmi_sta_keepalive_method {
+ WMI_STA_KEEPALIVE_METHOD_NULL_FRAME = 1,
+ WMI_STA_KEEPALIVE_METHOD_UNSOLICITED_ARP_RESPONSE = 2,
+ WMI_STA_KEEPALIVE_METHOD_ETHERNET_LOOPBACK = 3,
+ WMI_STA_KEEPALIVE_METHOD_GRATUITOUS_ARP_REQUEST = 4,
+ WMI_STA_KEEPALIVE_METHOD_MGMT_VENDOR_ACTION = 5,
+};
+
+#define WMI_STA_KEEPALIVE_INTERVAL_DEFAULT 30
+#define WMI_STA_KEEPALIVE_INTERVAL_DISABLE 0
+
void ath12k_wmi_init_qcn9274(struct ath12k_base *ab,
struct ath12k_wmi_resource_config_arg *config);
void ath12k_wmi_init_wcn7850(struct ath12k_base *ab,
@@ -5585,5 +5629,7 @@ int ath12k_wmi_gtk_rekey_offload(struct ath12k *ar,
struct ath12k_vif *arvif, bool enable);
int ath12k_wmi_gtk_rekey_getinfo(struct ath12k *ar,
struct ath12k_vif *arvif);
+int ath12k_wmi_sta_keepalive(struct ath12k *ar,
+ const struct wmi_sta_keepalive_arg *arg);
#endif
diff --git a/drivers/net/wireless/ath/ath12k/wow.c b/drivers/net/wireless/ath/ath12k/wow.c
index 755bdae1b9ad..de243fda815e 100644
--- a/drivers/net/wireless/ath/ath12k/wow.c
+++ b/drivers/net/wireless/ath/ath12k/wow.c
@@ -806,6 +806,24 @@ static int ath12k_wow_protocol_offload(struct ath12k *ar, bool enable)
return 0;
}
+static int ath12k_wow_set_keepalive(struct ath12k *ar,
+ enum wmi_sta_keepalive_method method,
+ u32 interval)
+{
+ struct ath12k_vif *arvif;
+ int ret;
+
+ lockdep_assert_held(&ar->conf_mutex);
+
+ list_for_each_entry(arvif, &ar->arvifs, list) {
+ ret = ath12k_mac_vif_set_keepalive(arvif, method, interval);
+ if (ret)
+ return ret;
+ }
+
+ return 0;
+}
+
int ath12k_wow_op_suspend(struct ieee80211_hw *hw,
struct cfg80211_wowlan *wowlan)
{
@@ -849,6 +867,14 @@ int ath12k_wow_op_suspend(struct ieee80211_hw *hw,
goto cleanup;
}
+ ret = ath12k_wow_set_keepalive(ar,
+ WMI_STA_KEEPALIVE_METHOD_NULL_FRAME,
+ WMI_STA_KEEPALIVE_INTERVAL_DEFAULT);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to enable wow keepalive: %d\n", ret);
+ goto cleanup;
+ }
+
ret = ath12k_wow_enable(ar);
if (ret) {
ath12k_warn(ar->ab, "failed to start wow: %d\n", ret);
@@ -929,6 +955,14 @@ int ath12k_wow_op_resume(struct ieee80211_hw *hw)
goto exit;
}
+ ret = ath12k_wow_set_keepalive(ar,
+ WMI_STA_KEEPALIVE_METHOD_NULL_FRAME,
+ WMI_STA_KEEPALIVE_INTERVAL_DISABLE);
+ if (ret) {
+ ath12k_warn(ar->ab, "failed to disable wow keepalive: %d\n", ret);
+ goto exit;
+ }
+
exit:
if (ret) {
switch (ah->state) {
--
2.25.1
^ permalink raw reply related [flat|nested] 25+ messages in thread* Re: [PATCH v3 0/8] wifi: ath12k: add support for WoW
2024-05-30 7:27 [PATCH v3 0/8] wifi: ath12k: add support for WoW Baochen Qiang
` (7 preceding siblings ...)
2024-05-30 7:27 ` [PATCH v3 8/8] wifi: ath12k: handle keepalive during WoWLAN suspend and resume Baochen Qiang
@ 2024-05-30 17:45 ` Jeff Johnson
8 siblings, 0 replies; 25+ messages in thread
From: Jeff Johnson @ 2024-05-30 17:45 UTC (permalink / raw)
To: Baochen Qiang, ath12k; +Cc: linux-wireless
On 5/30/2024 12:27 AM, Baochen Qiang wrote:
> Add support for WoW (Wakeup on Wireless) funtionalities, this including
> magic-pattern, net-detect, disconnect and patterns, HW data filter, ARP
> and NS offload, GTK rekey offload.
>
> Also enable keepalive before suspend to avoid unexpected kick out by AP.
>
> v3:
> - wifi: ath12k: add ATH12K_DBG_WOW log level
> 1. new addition.
> - wifi: ath12k: support ARP and NS offload
> 1. move ipv6 infomation parse to ath12k_wow_arp_ns_offload() to
> avoid memory leak issue.
> 2. move ARP/NS related definition from core.h to wmi.h
> 3. rename ath12k_arp_ns_offlaod to wmi_arp_ns_offload_arg
> 4. rename some macros
> - wifi: ath12k: support GTK rekey offload
> 1. add rcu_read_lock/unlock in ath12k_wmi_gtk_offload_status_event()
>
>
> v2:
> - [2/7] wifi: ath12k: add basic WoW functionalities
> 1. In ath12k_wow_convert_8023_to_80211(), change to use 'size_t'
> instead of 'int' to make GCC happy
> - [5/7] wifi: ath12k: support ARP and NS offload
> 1. In ath12k_mac_arvif_get_arp_ns_offload(), change to use
> GFP_ATOMIC to fix kernel crash due to sleep in invalid context
> - rebased on ToT
>
> Baochen Qiang (8):
> wifi: ath12k: add ATH12K_DBG_WOW log level
> wifi: ath12k: implement WoW enable and wakeup commands
> wifi: ath12k: add basic WoW functionalities
> wifi: ath12k: add WoW net-detect functionality
> wifi: ath12k: implement hardware data filter
> wifi: ath12k: support ARP and NS offload
> wifi: ath12k: support GTK rekey offload
> wifi: ath12k: handle keepalive during WoWLAN suspend and resume
>
> drivers/net/wireless/ath/ath12k/Makefile | 1 +
> drivers/net/wireless/ath/ath12k/core.c | 48 +-
> drivers/net/wireless/ath/ath12k/core.h | 20 +
> drivers/net/wireless/ath/ath12k/debug.h | 1 +
My Qualcomm Innovation Center copyright checker reports:
drivers/net/wireless/ath/ath12k/debug.h copyright missing 2024
> drivers/net/wireless/ath/ath12k/htc.c | 6 +
> drivers/net/wireless/ath/ath12k/mac.c | 110 +++
> drivers/net/wireless/ath/ath12k/mac.h | 4 +
> drivers/net/wireless/ath/ath12k/wmi.c | 720 +++++++++++++++
> drivers/net/wireless/ath/ath12k/wmi.h | 578 ++++++++++++
> drivers/net/wireless/ath/ath12k/wow.c | 1012 ++++++++++++++++++++++
> drivers/net/wireless/ath/ath12k/wow.h | 62 ++
> 11 files changed, 2554 insertions(+), 8 deletions(-)
> create mode 100644 drivers/net/wireless/ath/ath12k/wow.c
> create mode 100644 drivers/net/wireless/ath/ath12k/wow.h
>
>
> base-commit: 2580be9ee6f5d97d6763b5d4ae4f9c0383fdf130
^ permalink raw reply [flat|nested] 25+ messages in thread