[openwrt/openwrt] mac80211: ath12k: allow country set for WCN7850

LEDE Commits lede-commits at lists.infradead.org
Mon Oct 7 03:48:01 PDT 2024


robimarko pushed a commit to openwrt/openwrt.git, branch main:
https://git.openwrt.org/73d3789e6792e685aeed039178d263510330f198

commit 73d3789e6792e685aeed039178d263510330f198
Author: Janusz Dziedzic <janusz.dziedzic at gmail.com>
AuthorDate: Fri Oct 4 15:24:14 2024 +0200

    mac80211: ath12k: allow country set for WCN7850
    
    Update channels when country set.
    
    Signed-off-by: Janusz Dziedzic <janusz.dziedzic at gmail.com>
    Link: https://github.com/openwrt/openwrt/pull/16613
    Signed-off-by: Robert Marko <robimarko at gmail.com>
---
 ...pport-and-handle-country-code-for-WCN7850.patch | 924 +++++++++++++++++++++
 1 file changed, 924 insertions(+)

diff --git a/package/kernel/mac80211/patches/ath12k/001-wifi-ath12k-add-11d-scan-offload-support-and-handle-country-code-for-WCN7850.patch b/package/kernel/mac80211/patches/ath12k/001-wifi-ath12k-add-11d-scan-offload-support-and-handle-country-code-for-WCN7850.patch
new file mode 100644
index 0000000000..d370db1047
--- /dev/null
+++ b/package/kernel/mac80211/patches/ath12k/001-wifi-ath12k-add-11d-scan-offload-support-and-handle-country-code-for-WCN7850.patch
@@ -0,0 +1,924 @@
+From patchwork Thu Sep  5 02:35:08 2024
+Content-Type: text/plain; charset="utf-8"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+X-Patchwork-Submitter: Kang Yang <quic_kangyang at quicinc.com>
+X-Patchwork-Id: 13791624
+X-Patchwork-Delegate: kvalo at adurom.com
+Received: from mx0b-0031df01.pphosted.com (mx0b-0031df01.pphosted.com
+ [205.220.180.131])
+	(using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits))
+	(No client certificate requested)
+	by smtp.subspace.kernel.org (Postfix) with ESMTPS id D313D33CFC
+	for <linux-wireless at vger.kernel.org>; Thu,  5 Sep 2024 02:36:17 +0000 (UTC)
+Authentication-Results: smtp.subspace.kernel.org;
+ arc=none smtp.client-ip=205.220.180.131
+ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116;
+	t=1725503779; cv=none;
+ b=blv4mH95IN2AR7Rt90gw/V7DnZRtr3upgAP50X6ew3jh0CusPG6/OTO9CSJVthJnqHU3Y3GT88jaeMzb9+f2xzqgl7+E35TmwN3uf6dFmbp7CD8LL0W6xu76ZZgFGxzRspv9YoVy/fydZY6I4JRc2faWqI540+n9bHEXdSJTZMM=
+ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org;
+	s=arc-20240116; t=1725503779; c=relaxed/simple;
+	bh=vjzfDc6UXtw2Li6Q3bAgcW0K1rcTpi3dAxkQgbT5ogI=;
+	h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References:
+	 MIME-Version:Content-Type;
+ b=VMgF0PfIOoXmfB6EARb/O+dooXutjAm/cnemJ0RC7uc8TSIAusH1ffc6jF1XndEp+nPTWnuMQ5/d1cE/bPeIvSTxrtWaUepnKNjQDrNKm4NrqmjR446CT9t0VHG16RZ1cmCmU74qXnfgus4XfTqD093lc1N5Q/YRh/kwmcCzxhY=
+ARC-Authentication-Results: i=1; smtp.subspace.kernel.org;
+ dmarc=pass (p=none dis=none) header.from=quicinc.com;
+ spf=pass smtp.mailfrom=quicinc.com;
+ dkim=pass (2048-bit key) header.d=quicinc.com header.i=@quicinc.com
+ header.b=E5hktrdm; arc=none smtp.client-ip=205.220.180.131
+Authentication-Results: smtp.subspace.kernel.org;
+ dmarc=pass (p=none dis=none) header.from=quicinc.com
+Authentication-Results: smtp.subspace.kernel.org;
+ spf=pass smtp.mailfrom=quicinc.com
+Authentication-Results: smtp.subspace.kernel.org;
+	dkim=pass (2048-bit key) header.d=quicinc.com header.i=@quicinc.com
+ header.b="E5hktrdm"
+Received: from pps.filterd (m0279869.ppops.net [127.0.0.1])
+	by mx0a-0031df01.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id
+ 484MRZwS008193;
+	Thu, 5 Sep 2024 02:36:12 GMT
+DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=quicinc.com; h=
+	cc:content-transfer-encoding:content-type:date:from:in-reply-to
+	:message-id:mime-version:references:subject:to; s=qcppdkim1; bh=
+	No6X3gHpioHamjfMDccV8LJEZBGk/uDqbZ/fuGUTvJM=; b=E5hktrdmmOb3KcP6
+	Qi3M5Y06Yd8RxNJTps8WMEoXZ7xzROVuhmRmlG/mw21NjBMTTMgtjcaen/n8Anj3
+	Ash1VFK6s7PrLcwoUT/uui6hzleGE+X9Wh8DJXYnZKKWmeQ+8E0yEzNR0kt9FG0n
+	S+asFc8VYEJHid6QDNAfM9e4JqJgU3NGXYJBTBM2lpdbqeWU7LEYnVTGCqvOPaH2
+	K+QDwvNiNeXlqbaxnqCYimUrSDnTbSUoiVxSpTe9/muWWAB+6YuUbXRfTceqgcd1
+	xFIOE1KrtAowMOk5mO3tn6Tjl7nJzewVUm9hncBRfynP8k2jt1xosMezL42dmb56
+	a9VWLQ==
+Received: from nalasppmta03.qualcomm.com (Global_NAT1.qualcomm.com
+ [129.46.96.20])
+	by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 41bt674mq1-1
+	(version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT);
+	Thu, 05 Sep 2024 02:36:11 +0000 (GMT)
+Received: from nalasex01b.na.qualcomm.com (nalasex01b.na.qualcomm.com
+ [10.47.209.197])
+	by NALASPPMTA03.qualcomm.com (8.18.1.2/8.18.1.2) with ESMTPS id
+ 4852aAdV010181
+	(version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT);
+	Thu, 5 Sep 2024 02:36:10 GMT
+Received: from kangyang.ap.qualcomm.com (10.80.80.8) by
+ nalasex01b.na.qualcomm.com (10.47.209.197) with Microsoft SMTP Server
+ (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id
+ 15.2.1544.9; Wed, 4 Sep 2024 19:36:09 -0700
+From: Kang Yang <quic_kangyang at quicinc.com>
+To: <ath12k at lists.infradead.org>
+CC: <linux-wireless at vger.kernel.org>, <quic_kangyang at quicinc.com>
+Subject: [PATCH v3 1/4] wifi: ath12k: add configure country code for WCN7850
+Date: Thu, 5 Sep 2024 10:35:08 +0800
+Message-ID: <20240905023511.362-2-quic_kangyang at quicinc.com>
+X-Mailer: git-send-email 2.34.1.windows.1
+In-Reply-To: <20240905023511.362-1-quic_kangyang at quicinc.com>
+References: <20240905023511.362-1-quic_kangyang at quicinc.com>
+Precedence: bulk
+X-Mailing-List: linux-wireless at vger.kernel.org
+List-Id: <linux-wireless.vger.kernel.org>
+List-Subscribe: <mailto:linux-wireless+subscribe at vger.kernel.org>
+List-Unsubscribe: <mailto:linux-wireless+unsubscribe at vger.kernel.org>
+MIME-Version: 1.0
+X-ClientProxiedBy: nasanex01b.na.qualcomm.com (10.46.141.250) To
+ nalasex01b.na.qualcomm.com (10.47.209.197)
+X-QCInternal: smtphost
+X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800
+ signatures=585085
+X-Proofpoint-ORIG-GUID: FzfHe7cZy6IUVu8IKORVKLxkYG9f8WUl
+X-Proofpoint-GUID: FzfHe7cZy6IUVu8IKORVKLxkYG9f8WUl
+X-Proofpoint-Virus-Version: vendor=baseguard
+ engine=ICAP:2.0.293,Aquarius:18.0.1039,Hydra:6.0.680,FMLib:17.12.60.29
+ definitions=2024-09-05_01,2024-09-04_01,2024-09-02_01
+X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0
+ malwarescore=0 adultscore=0
+ bulkscore=0 mlxscore=0 impostorscore=0 suspectscore=0 phishscore=0
+ mlxlogscore=999 lowpriorityscore=0 spamscore=0 clxscore=1015
+ priorityscore=1501 classifier=spam adjust=0 reason=mlx scancount=1
+ engine=8.19.0-2407110000 definitions=main-2409050018
+
+From: Wen Gong <quic_wgong at quicinc.com>
+
+Add handler to send WMI_SET_CURRENT_COUNTRY_CMDID to firmware, which
+is used for WCN7850 to update country code.
+
+Tested-on: WCN7850 hw2.0 PCI WLAN.HMT.1.0.c5-00481-QCAHMTSWPL_V1.0_V2.0_SILICONZ-3
+
+Signed-off-by: Wen Gong <quic_wgong at quicinc.com>
+Signed-off-by: Kang Yang <quic_kangyang at quicinc.com>
+Acked-by: Jeff Johnson <quic_jjohnson at quicinc.com>
+---
+ drivers/net/wireless/ath/ath12k/wmi.c | 36 +++++++++++++++++++++++++++
+ drivers/net/wireless/ath/ath12k/wmi.h | 13 ++++++++++
+ 2 files changed, 49 insertions(+)
+
+--- a/drivers/net/wireless/ath/ath12k/wmi.c
++++ b/drivers/net/wireless/ath/ath12k/wmi.c
+@@ -171,6 +171,8 @@ static const struct ath12k_wmi_tlv_polic
+ 		.min_len = sizeof(struct ath12k_wmi_p2p_noa_info) },
+ 	[WMI_TAG_P2P_NOA_EVENT] = {
+ 		.min_len = sizeof(struct wmi_p2p_noa_event) },
++	[WMI_TAG_11D_NEW_COUNTRY_EVENT] = {
++		.min_len = sizeof(struct wmi_11d_new_cc_event) },
+ };
+ 
+ static __le32 ath12k_wmi_tlv_hdr(u32 cmd, u32 len)
+@@ -2363,7 +2365,10 @@ int ath12k_wmi_send_scan_start_cmd(struc
+ 	cmd->scan_id = cpu_to_le32(arg->scan_id);
+ 	cmd->scan_req_id = cpu_to_le32(arg->scan_req_id);
+ 	cmd->vdev_id = cpu_to_le32(arg->vdev_id);
+-	cmd->scan_priority = cpu_to_le32(arg->scan_priority);
++	if (ar->state_11d == ATH12K_11D_PREPARING)
++		arg->scan_priority = WMI_SCAN_PRIORITY_MEDIUM;
++	else
++		arg->scan_priority = WMI_SCAN_PRIORITY_LOW;
+ 	cmd->notify_scan_events = cpu_to_le32(arg->notify_scan_events);
+ 
+ 	ath12k_wmi_copy_scan_event_cntrl_flags(cmd, arg);
+@@ -3083,6 +3088,110 @@ out:
+ 	return ret;
+ }
+ 
++int ath12k_wmi_send_set_current_country_cmd(struct ath12k *ar,
++					    struct wmi_set_current_country_arg *arg)
++{
++	struct ath12k_wmi_pdev *wmi = ar->wmi;
++	struct wmi_set_current_country_cmd *cmd;
++	struct sk_buff *skb;
++	int ret;
++
++	skb = ath12k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
++	if (!skb)
++		return -ENOMEM;
++
++	cmd = (struct wmi_set_current_country_cmd *)skb->data;
++	cmd->tlv_header =
++		ath12k_wmi_tlv_cmd_hdr(WMI_TAG_SET_CURRENT_COUNTRY_CMD,
++				       sizeof(*cmd));
++
++	cmd->pdev_id = cpu_to_le32(ar->pdev->pdev_id);
++	memcpy(&cmd->new_alpha2, &arg->alpha2, sizeof(arg->alpha2));
++	ret = ath12k_wmi_cmd_send(wmi, skb, WMI_SET_CURRENT_COUNTRY_CMDID);
++
++	ath12k_dbg(ar->ab, ATH12K_DBG_WMI,
++		   "set current country pdev id %d alpha2 %c%c\n",
++		   ar->pdev->pdev_id,
++		   arg->alpha2[0],
++		   arg->alpha2[1]);
++
++	if (ret) {
++		ath12k_warn(ar->ab,
++			    "failed to send WMI_SET_CURRENT_COUNTRY_CMDID: %d\n", ret);
++		dev_kfree_skb(skb);
++	}
++
++	return ret;
++}
++
++int ath12k_wmi_send_11d_scan_start_cmd(struct ath12k *ar,
++				       struct wmi_11d_scan_start_arg *arg)
++{
++	struct ath12k_wmi_pdev *wmi = ar->wmi;
++	struct wmi_11d_scan_start_cmd *cmd;
++	struct sk_buff *skb;
++	int ret;
++
++	skb = ath12k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
++	if (!skb)
++		return -ENOMEM;
++
++	cmd = (struct wmi_11d_scan_start_cmd *)skb->data;
++	cmd->tlv_header =
++		ath12k_wmi_tlv_cmd_hdr(WMI_TAG_11D_SCAN_START_CMD,
++				       sizeof(*cmd));
++
++	cmd->vdev_id = cpu_to_le32(arg->vdev_id);
++	cmd->scan_period_msec = cpu_to_le32(arg->scan_period_msec);
++	cmd->start_interval_msec = cpu_to_le32(arg->start_interval_msec);
++	ret = ath12k_wmi_cmd_send(wmi, skb, WMI_11D_SCAN_START_CMDID);
++
++	ath12k_dbg(ar->ab, ATH12K_DBG_WMI,
++		   "send 11d scan start vdev id %d period %d ms internal %d ms\n",
++		   arg->vdev_id, arg->scan_period_msec,
++		   arg->start_interval_msec);
++
++	if (ret) {
++		ath12k_warn(ar->ab,
++			    "failed to send WMI_11D_SCAN_START_CMDID: %d\n", ret);
++		dev_kfree_skb(skb);
++	}
++
++	return ret;
++}
++
++int ath12k_wmi_send_11d_scan_stop_cmd(struct ath12k *ar, u32 vdev_id)
++{
++	struct ath12k_wmi_pdev *wmi = ar->wmi;
++	struct wmi_11d_scan_stop_cmd *cmd;
++	struct sk_buff *skb;
++	int ret;
++
++	skb = ath12k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
++	if (!skb)
++		return -ENOMEM;
++
++	cmd = (struct wmi_11d_scan_stop_cmd *)skb->data;
++	cmd->tlv_header =
++		ath12k_wmi_tlv_cmd_hdr(WMI_TAG_11D_SCAN_STOP_CMD,
++				       sizeof(*cmd));
++
++	cmd->vdev_id = cpu_to_le32(vdev_id);
++	ret = ath12k_wmi_cmd_send(wmi, skb, WMI_11D_SCAN_STOP_CMDID);
++
++	ath12k_dbg(ar->ab, ATH12K_DBG_WMI,
++		   "send 11d scan stop vdev id %d\n",
++		   cmd->vdev_id);
++
++	if (ret) {
++		ath12k_warn(ar->ab,
++			    "failed to send WMI_11D_SCAN_STOP_CMDID: %d\n", ret);
++		dev_kfree_skb(skb);
++	}
++
++	return ret;
++}
++
+ int
+ ath12k_wmi_send_twt_enable_cmd(struct ath12k *ar, u32 pdev_id)
+ {
+@@ -5668,6 +5777,50 @@ static void ath12k_wmi_op_ep_tx_credits(
+ 	wake_up(&ab->wmi_ab.tx_credits_wq);
+ }
+ 
++static int ath12k_reg_11d_new_cc_event(struct ath12k_base *ab, struct sk_buff *skb)
++{
++	const struct wmi_11d_new_cc_event *ev;
++	struct ath12k *ar;
++	struct ath12k_pdev *pdev;
++	const void **tb;
++	int ret, i;
++
++	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 ret;
++	}
++
++	ev = tb[WMI_TAG_11D_NEW_COUNTRY_EVENT];
++	if (!ev) {
++		kfree(tb);
++		ath12k_warn(ab, "failed to fetch 11d new cc ev");
++		return -EPROTO;
++	}
++
++	spin_lock_bh(&ab->base_lock);
++	memcpy(&ab->new_alpha2, &ev->new_alpha2, REG_ALPHA2_LEN);
++	spin_unlock_bh(&ab->base_lock);
++
++	ath12k_dbg(ab, ATH12K_DBG_WMI, "wmi 11d new cc %c%c\n",
++		   ab->new_alpha2[0],
++		   ab->new_alpha2[1]);
++
++	kfree(tb);
++
++	for (i = 0; i < ab->num_radios; i++) {
++		pdev = &ab->pdevs[i];
++		ar = pdev->ar;
++		ar->state_11d = ATH12K_11D_IDLE;
++		complete(&ar->completed_11d_scan);
++	}
++
++	queue_work(ab->workqueue, &ab->update_11d_work);
++
++	return 0;
++}
++
+ static void ath12k_wmi_htc_tx_complete(struct ath12k_base *ab,
+ 				       struct sk_buff *skb)
+ {
+@@ -7269,6 +7422,9 @@ static void ath12k_wmi_op_rx(struct ath1
+ 	case WMI_GTK_OFFLOAD_STATUS_EVENTID:
+ 		ath12k_wmi_gtk_offload_status_event(ab, skb);
+ 		break;
++	case WMI_11D_NEW_COUNTRY_EVENTID:
++		ath12k_reg_11d_new_cc_event(ab, skb);
++		break;
+ 	/* TODO: Add remaining events */
+ 	default:
+ 		ath12k_dbg(ab, ATH12K_DBG_WMI, "Unknown eventid: 0x%x\n", id);
+--- a/drivers/net/wireless/ath/ath12k/wmi.h
++++ b/drivers/net/wireless/ath/ath12k/wmi.h
+@@ -3859,6 +3859,28 @@ struct wmi_init_country_cmd {
+ 	} cc_info;
+ } __packed;
+ 
++struct wmi_11d_scan_start_arg {
++	u32 vdev_id;
++	u32 scan_period_msec;
++	u32 start_interval_msec;
++};
++
++struct wmi_11d_scan_start_cmd {
++	__le32 tlv_header;
++	__le32 vdev_id;
++	__le32 scan_period_msec;
++	__le32 start_interval_msec;
++} __packed;
++
++struct wmi_11d_scan_stop_cmd {
++	__le32 tlv_header;
++	__le32 vdev_id;
++} __packed;
++
++struct wmi_11d_new_cc_event {
++	__le32 new_alpha2;
++} __packed;
++
+ struct wmi_delba_send_cmd {
+ 	__le32 tlv_header;
+ 	__le32 vdev_id;
+@@ -3944,6 +3966,16 @@ struct ath12k_wmi_eht_rate_set_params {
+ #define MAX_6G_REG_RULES 5
+ #define REG_US_5G_NUM_REG_RULES 4
+ 
++struct wmi_set_current_country_arg {
++	u8 alpha2[REG_ALPHA2_LEN];
++};
++
++struct wmi_set_current_country_cmd {
++	__le32 tlv_header;
++	__le32 pdev_id;
++	__le32 new_alpha2;
++} __packed;
++
+ enum wmi_start_event_param {
+ 	WMI_VDEV_START_RESP_EVENT = 0,
+ 	WMI_VDEV_RESTART_RESP_EVENT,
+@@ -5546,11 +5578,17 @@ int ath12k_wmi_send_bcn_offload_control_
+ 					    u32 vdev_id, u32 bcn_ctrl_op);
+ int ath12k_wmi_send_init_country_cmd(struct ath12k *ar,
+ 				     struct ath12k_wmi_init_country_arg *arg);
++int
++ath12k_wmi_send_set_current_country_cmd(struct ath12k *ar,
++					struct wmi_set_current_country_arg *arg);
+ int ath12k_wmi_peer_rx_reorder_queue_setup(struct ath12k *ar,
+ 					   int vdev_id, const u8 *addr,
+ 					   dma_addr_t paddr, u8 tid,
+ 					   u8 ba_window_size_valid,
+ 					   u32 ba_window_size);
++int ath12k_wmi_send_11d_scan_start_cmd(struct ath12k *ar,
++				       struct wmi_11d_scan_start_arg *arg);
++int ath12k_wmi_send_11d_scan_stop_cmd(struct ath12k *ar, u32 vdev_id);
+ int
+ ath12k_wmi_rx_reord_queue_remove(struct ath12k *ar,
+ 				 struct ath12k_wmi_rx_reorder_queue_remove_arg *arg);
+--- a/drivers/net/wireless/ath/ath12k/core.c
++++ b/drivers/net/wireless/ath/ath12k/core.c
+@@ -1014,6 +1014,7 @@ void ath12k_core_halt(struct ath12k *ar)
+ 	cancel_delayed_work_sync(&ar->scan.timeout);
+ 	cancel_work_sync(&ar->regd_update_work);
+ 	cancel_work_sync(&ab->rfkill_work);
++	cancel_work_sync(&ab->update_11d_work);
+ 
+ 	rcu_assign_pointer(ab->pdevs_active[ar->pdev_idx], NULL);
+ 	synchronize_rcu();
+@@ -1021,6 +1022,34 @@ void ath12k_core_halt(struct ath12k *ar)
+ 	idr_init(&ar->txmgmt_idr);
+ }
+ 
++static void ath12k_update_11d(struct work_struct *work)
++{
++	struct ath12k_base *ab = container_of(work, struct ath12k_base, update_11d_work);
++	struct ath12k *ar;
++	struct ath12k_pdev *pdev;
++	struct wmi_set_current_country_arg arg = {};
++	int ret, i;
++
++	spin_lock_bh(&ab->base_lock);
++	memcpy(&arg.alpha2, &ab->new_alpha2, 2);
++	spin_unlock_bh(&ab->base_lock);
++
++	ath12k_dbg(ab, ATH12K_DBG_WMI, "update 11d new cc %c%c\n",
++		   arg.alpha2[0], arg.alpha2[1]);
++
++	for (i = 0; i < ab->num_radios; i++) {
++		pdev = &ab->pdevs[i];
++		ar = pdev->ar;
++
++		memcpy(&ar->alpha2, &arg.alpha2, 2);
++		ret = ath12k_wmi_send_set_current_country_cmd(ar, &arg);
++		if (ret)
++			ath12k_warn(ar->ab,
++				    "pdev id %d failed set current country code: %d\n",
++				    i, ret);
++	}
++}
++
+ static void ath12k_core_pre_reconfigure_recovery(struct ath12k_base *ab)
+ {
+ 	struct ath12k *ar;
+@@ -1045,8 +1074,10 @@ static void ath12k_core_pre_reconfigure_
+ 			ar = &ah->radio[j];
+ 
+ 			ath12k_mac_drain_tx(ar);
++			ar->state_11d = ATH12K_11D_IDLE;
++			complete(&ar->completed_11d_scan);
+ 			complete(&ar->scan.started);
+-			complete(&ar->scan.completed);
++			complete_all(&ar->scan.completed);
+ 			complete(&ar->scan.on_channel);
+ 			complete(&ar->peer_assoc_done);
+ 			complete(&ar->peer_delete_done);
+@@ -1312,6 +1343,7 @@ struct ath12k_base *ath12k_core_alloc(st
+ 	INIT_WORK(&ab->restart_work, ath12k_core_restart);
+ 	INIT_WORK(&ab->reset_work, ath12k_core_reset);
+ 	INIT_WORK(&ab->rfkill_work, ath12k_rfkill_work);
++	INIT_WORK(&ab->update_11d_work, ath12k_update_11d);
+ 
+ 	timer_setup(&ab->rx_replenish_retry, ath12k_ce_rx_replenish_retry, 0);
+ 	init_completion(&ab->htc_suspend);
+--- a/drivers/net/wireless/ath/ath12k/core.h
++++ b/drivers/net/wireless/ath/ath12k/core.h
+@@ -199,6 +199,12 @@ enum ath12k_scan_state {
+ 	ATH12K_SCAN_ABORTING,
+ };
+ 
++enum ath12k_11d_state {
++	ATH12K_11D_IDLE,
++	ATH12K_11D_PREPARING,
++	ATH12K_11D_RUNNING,
++};
++
+ enum ath12k_dev_flags {
+ 	ATH12K_CAC_RUNNING,
+ 	ATH12K_FLAG_CRASH_FLUSH,
+@@ -313,6 +319,8 @@ struct ath12k_vif_iter {
+ #define ATH12K_RX_RATE_TABLE_11AX_NUM	576
+ #define ATH12K_RX_RATE_TABLE_NUM 320
+ 
++#define ATH12K_SCAN_TIMEOUT_HZ (20 * HZ)
++
+ struct ath12k_rx_peer_rate_stats {
+ 	u64 ht_mcs_count[HAL_RX_MAX_MCS_HT + 1];
+ 	u64 vht_mcs_count[HAL_RX_MAX_MCS_VHT + 1];
+@@ -648,6 +656,13 @@ struct ath12k {
+ 	u32 freq_low;
+ 	u32 freq_high;
+ 
++	/* Protected by wiphy::mtx lock. */
++	u32 vdev_id_11d_scan;
++	struct completion completed_11d_scan;
++	enum ath12k_11d_state state_11d;
++	u8 alpha2[REG_ALPHA2_LEN];
++	bool regdom_set_by_user;
++
+ 	bool nlo_enabled;
+ };
+ 
+@@ -880,6 +895,8 @@ struct ath12k_base {
+ 	/* continuous recovery fail count */
+ 	atomic_t fail_cont_count;
+ 	unsigned long reset_fail_timeout;
++	struct work_struct update_11d_work;
++	u8 new_alpha2[2];
+ 	struct {
+ 		/* protected by data_lock */
+ 		u32 fw_crash_counter;
+--- a/drivers/net/wireless/ath/ath12k/mac.c
++++ b/drivers/net/wireless/ath/ath12k/mac.c
+@@ -2947,6 +2947,11 @@ static void ath12k_bss_assoc(struct ath1
+ 	if (ret)
+ 		ath12k_warn(ar->ab, "failed to set vdev %i OBSS PD parameters: %d\n",
+ 			    arvif->vdev_id, ret);
++
++	if (test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map) &&
++	    arvif->vdev_type == WMI_VDEV_TYPE_STA &&
++	    arvif->vdev_subtype == WMI_VDEV_SUBTYPE_NONE)
++		ath12k_mac_11d_scan_stop_all(ar->ab);
+ }
+ 
+ static void ath12k_bss_disassoc(struct ath12k *ar,
+@@ -3522,7 +3527,7 @@ void __ath12k_mac_scan_finish(struct ath
+ 		ar->scan_channel = NULL;
+ 		ar->scan.roc_freq = 0;
+ 		cancel_delayed_work(&ar->scan.timeout);
+-		complete(&ar->scan.completed);
++		complete_all(&ar->scan.completed);
+ 		break;
+ 	}
+ }
+@@ -3783,7 +3788,12 @@ scan:
+ 
+ 	ret = ath12k_start_scan(ar, &arg);
+ 	if (ret) {
+-		ath12k_warn(ar->ab, "failed to start hw scan: %d\n", ret);
++		if (ret == -EBUSY)
++			ath12k_dbg(ar->ab, ATH12K_DBG_MAC,
++				   "scan engine is busy 11d state %d\n", ar->state_11d);
++		else
++			ath12k_warn(ar->ab, "failed to start hw scan: %d\n", ret);
++
+ 		spin_lock_bh(&ar->data_lock);
+ 		ar->scan.state = ATH12K_SCAN_IDLE;
+ 		spin_unlock_bh(&ar->data_lock);
+@@ -3802,6 +3812,11 @@ exit:
+ 
+ 	mutex_unlock(&ar->conf_mutex);
+ 
++	if (ar->state_11d == ATH12K_11D_PREPARING &&
++	    arvif->vdev_type == WMI_VDEV_TYPE_STA &&
++	    arvif->vdev_subtype == WMI_VDEV_SUBTYPE_NONE)
++		ath12k_mac_11d_scan_start(ar, arvif->vdev_id);
++
+ 	return ret;
+ }
+ 
+@@ -5986,7 +6001,7 @@ static int ath12k_mac_start(struct ath12
+ 
+ 	/* TODO: Do we need to enable ANI? */
+ 
+-	ath12k_reg_update_chan_list(ar);
++	ath12k_reg_update_chan_list(ar, false);
+ 
+ 	ar->num_started_vdevs = 0;
+ 	ar->num_created_vdevs = 0;
+@@ -6166,6 +6181,9 @@ static void ath12k_mac_stop(struct ath12
+ 	cancel_delayed_work_sync(&ar->scan.timeout);
+ 	cancel_work_sync(&ar->regd_update_work);
+ 	cancel_work_sync(&ar->ab->rfkill_work);
++	cancel_work_sync(&ar->ab->update_11d_work);
++	ar->state_11d = ATH12K_11D_IDLE;
++	complete(&ar->completed_11d_scan);
+ 
+ 	spin_lock_bh(&ar->data_lock);
+ 	list_for_each_entry_safe(ppdu_stats, tmp, &ar->ppdu_stats_info, list) {
+@@ -6412,6 +6430,117 @@ static void ath12k_mac_op_update_vif_off
+ 	ath12k_mac_update_vif_offload(arvif);
+ }
+ 
++static bool ath12k_mac_vif_ap_active_any(struct ath12k_base *ab)
++{
++	struct ath12k *ar;
++	struct ath12k_pdev *pdev;
++	struct ath12k_vif *arvif;
++	int i;
++
++	for (i = 0; i < ab->num_radios; i++) {
++		pdev = &ab->pdevs[i];
++		ar = pdev->ar;
++		list_for_each_entry(arvif, &ar->arvifs, list) {
++			if (arvif->is_up && arvif->vdev_type == WMI_VDEV_TYPE_AP)
++				return true;
++		}
++	}
++	return false;
++}
++
++void ath12k_mac_11d_scan_start(struct ath12k *ar, u32 vdev_id)
++{
++	struct wmi_11d_scan_start_arg arg;
++	int ret;
++
++	lockdep_assert_wiphy(ath12k_ar_to_hw(ar)->wiphy);
++
++	if (ar->regdom_set_by_user)
++		goto fin;
++
++	if (ar->vdev_id_11d_scan != ATH12K_11D_INVALID_VDEV_ID)
++		goto fin;
++
++	if (!test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map))
++		goto fin;
++
++	if (ath12k_mac_vif_ap_active_any(ar->ab))
++		goto fin;
++
++	arg.vdev_id = vdev_id;
++	arg.start_interval_msec = 0;
++	arg.scan_period_msec = ATH12K_SCAN_11D_INTERVAL;
++
++	ath12k_dbg(ar->ab, ATH12K_DBG_MAC,
++		   "mac start 11d scan for vdev %d\n", vdev_id);
++
++	ret = ath12k_wmi_send_11d_scan_start_cmd(ar, &arg);
++	if (ret) {
++		ath12k_warn(ar->ab, "failed to start 11d scan vdev %d ret: %d\n",
++			    vdev_id, ret);
++	} else {
++		ar->vdev_id_11d_scan = vdev_id;
++		if (ar->state_11d == ATH12K_11D_PREPARING)
++			ar->state_11d = ATH12K_11D_RUNNING;
++	}
++
++fin:
++	if (ar->state_11d == ATH12K_11D_PREPARING) {
++		ar->state_11d = ATH12K_11D_IDLE;
++		complete(&ar->completed_11d_scan);
++	}
++}
++
++void ath12k_mac_11d_scan_stop(struct ath12k *ar)
++{
++	int ret;
++	u32 vdev_id;
++
++	lockdep_assert_wiphy(ath12k_ar_to_hw(ar)->wiphy);
++
++	if (!test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map))
++		return;
++
++	ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac stop 11d for vdev %d\n",
++		   ar->vdev_id_11d_scan);
++
++	if (ar->state_11d == ATH12K_11D_PREPARING) {
++		ar->state_11d = ATH12K_11D_IDLE;
++		complete(&ar->completed_11d_scan);
++	}
++
++	if (ar->vdev_id_11d_scan != ATH12K_11D_INVALID_VDEV_ID) {
++		vdev_id = ar->vdev_id_11d_scan;
++
++		ret = ath12k_wmi_send_11d_scan_stop_cmd(ar, vdev_id);
++		if (ret) {
++			ath12k_warn(ar->ab,
++				    "failed to stopt 11d scan vdev %d ret: %d\n",
++				    vdev_id, ret);
++		} else {
++			ar->vdev_id_11d_scan = ATH12K_11D_INVALID_VDEV_ID;
++			ar->state_11d = ATH12K_11D_IDLE;
++			complete(&ar->completed_11d_scan);
++		}
++	}
++}
++
++void ath12k_mac_11d_scan_stop_all(struct ath12k_base *ab)
++{
++	struct ath12k *ar;
++	struct ath12k_pdev *pdev;
++	int i;
++
++	ath12k_dbg(ab, ATH12K_DBG_MAC, "mac stop soc 11d scan\n");
++
++	for (i = 0; i < ab->num_radios; i++) {
++		pdev = &ab->pdevs[i];
++		ar = pdev->ar;
++
++		ath12k_mac_11d_scan_stop(ar);
++	}
++}
++
+ static int ath12k_mac_vdev_create(struct ath12k *ar, struct ieee80211_vif *vif)
+ {
+ 	struct ath12k_hw *ah = ar->ah;
+@@ -6526,6 +6655,7 @@ static int ath12k_mac_vdev_create(struct
+ 				    arvif->vdev_id, ret);
+ 			goto err_peer_del;
+ 		}
++		ath12k_mac_11d_scan_stop_all(ar->ab);
+ 		break;
+ 	case WMI_VDEV_TYPE_STA:
+ 		param_id = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
+@@ -6564,6 +6694,13 @@ static int ath12k_mac_vdev_create(struct
+ 				    arvif->vdev_id, ret);
+ 			goto err_peer_del;
+ 		}
++
++		if (test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ab->wmi_ab.svc_map) &&
++		    arvif->vdev_type == WMI_VDEV_TYPE_STA &&
++		    arvif->vdev_subtype == WMI_VDEV_SUBTYPE_NONE) {
++			reinit_completion(&ar->completed_11d_scan);
++			ar->state_11d = ATH12K_11D_PREPARING;
++		}
+ 		break;
+ 	default:
+ 		break;
+@@ -6904,6 +7041,11 @@ static void ath12k_mac_op_remove_interfa
+ 	ath12k_dbg(ab, ATH12K_DBG_MAC, "mac remove interface (vdev %d)\n",
+ 		   arvif->vdev_id);
+ 
++	if (test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ab->wmi_ab.svc_map) &&
++	    arvif->vdev_type == WMI_VDEV_TYPE_STA &&
++	    arvif->vdev_subtype == WMI_VDEV_SUBTYPE_NONE)
++		ath12k_mac_11d_scan_stop(ar);
++
+ 	if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
+ 		ret = ath12k_peer_delete(ar, arvif->vdev_id, vif->addr);
+ 		if (ret)
+@@ -7744,6 +7886,14 @@ ath12k_mac_op_unassign_vif_chanctx(struc
+ 	    ar->num_started_vdevs == 1 && ar->monitor_vdev_created)
+ 		ath12k_mac_monitor_stop(ar);
+ 
++	if (test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ab->wmi_ab.svc_map) &&
++	    arvif->vdev_type == WMI_VDEV_TYPE_STA &&
++	    arvif->vdev_subtype == WMI_VDEV_SUBTYPE_NONE &&
++	    ar->state_11d != ATH12K_11D_PREPARING) {
++		reinit_completion(&ar->completed_11d_scan);
++		ar->state_11d = ATH12K_11D_PREPARING;
++	}
++
+ 	mutex_unlock(&ar->conf_mutex);
+ }
+ 
+@@ -8282,6 +8432,14 @@ ath12k_mac_op_reconfig_complete(struct i
+ 		ath12k_warn(ar->ab, "pdev %d successfully recovered\n",
+ 			    ar->pdev->pdev_id);
+ 
++		if (ar->ab->hw_params->current_cc_support &&
++		    ar->alpha2[0] != 0 && ar->alpha2[1] != 0) {
++			struct wmi_set_current_country_arg arg = {};
++
++			memcpy(&arg.alpha2, ar->alpha2, 2);
++			ath12k_wmi_send_set_current_country_cmd(ar, &arg);
++		}
++
+ 		if (ab->is_reset) {
+ 			recovery_count = atomic_inc_return(&ab->recovery_count);
+ 
+@@ -9331,6 +9489,9 @@ static void ath12k_mac_setup(struct ath1
+ 
+ 	INIT_WORK(&ar->wmi_mgmt_tx_work, ath12k_mgmt_over_wmi_tx_work);
+ 	skb_queue_head_init(&ar->wmi_mgmt_tx_queue);
++
++	ar->vdev_id_11d_scan = ATH12K_11D_INVALID_VDEV_ID;
++	init_completion(&ar->completed_11d_scan);
+ }
+ 
+ int ath12k_mac_register(struct ath12k_base *ab)
+--- a/drivers/net/wireless/ath/ath12k/mac.h
++++ b/drivers/net/wireless/ath/ath12k/mac.h
+@@ -51,6 +51,13 @@ enum ath12k_supported_bw {
+ 
+ extern const struct htt_rx_ring_tlv_filter ath12k_mac_mon_status_filter_default;
+ 
++#define ATH12K_SCAN_11D_INTERVAL		600000
++#define ATH12K_11D_INVALID_VDEV_ID		0xFFFF
++
++void ath12k_mac_11d_scan_start(struct ath12k *ar, u32 vdev_id);
++void ath12k_mac_11d_scan_stop(struct ath12k *ar);
++void ath12k_mac_11d_scan_stop_all(struct ath12k_base *ab);
++
+ void ath12k_mac_destroy(struct ath12k_base *ab);
+ void ath12k_mac_unregister(struct ath12k_base *ab);
+ int ath12k_mac_register(struct ath12k_base *ab);
+--- a/drivers/net/wireless/ath/ath12k/reg.c
++++ b/drivers/net/wireless/ath/ath12k/reg.c
+@@ -48,6 +48,7 @@ ath12k_reg_notifier(struct wiphy *wiphy,
+ {
+ 	struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
+ 	struct ath12k_wmi_init_country_arg arg;
++	struct wmi_set_current_country_arg current_arg = {};
+ 	struct ath12k_hw *ah = ath12k_hw_to_ah(hw);
+ 	struct ath12k *ar = ath12k_ah_to_ar(ah, 0);
+ 	int ret, i;
+@@ -77,27 +78,38 @@ ath12k_reg_notifier(struct wiphy *wiphy,
+ 		return;
+ 	}
+ 
+-	/* Set the country code to the firmware and wait for
+-	 * the WMI_REG_CHAN_LIST_CC EVENT for updating the
+-	 * reg info
+-	 */
+-	arg.flags = ALPHA_IS_SET;
+-	memcpy(&arg.cc_info.alpha2, request->alpha2, 2);
+-	arg.cc_info.alpha2[2] = 0;
+-
+ 	/* Allow fresh updates to wiphy regd */
+ 	ah->regd_updated = false;
+ 
+ 	/* Send the reg change request to all the radios */
+ 	for_each_ar(ah, ar, i) {
+-		ret = ath12k_wmi_send_init_country_cmd(ar, &arg);
+-		if (ret)
+-			ath12k_warn(ar->ab,
+-				    "INIT Country code set to fw failed : %d\n", ret);
++		if (ar->ab->hw_params->current_cc_support) {
++			memcpy(&current_arg.alpha2, request->alpha2, 2);
++			memcpy(&ar->alpha2, &current_arg.alpha2, 2);
++			ret = ath12k_wmi_send_set_current_country_cmd(ar, &current_arg);
++			if (ret)
++				ath12k_warn(ar->ab,
++					    "failed set current country code: %d\n", ret);
++		} else {
++			arg.flags = ALPHA_IS_SET;
++			memcpy(&arg.cc_info.alpha2, request->alpha2, 2);
++			arg.cc_info.alpha2[2] = 0;
++
++			ret = ath12k_wmi_send_init_country_cmd(ar, &arg);
++			if (ret)
++				ath12k_warn(ar->ab,
++					    "failed set INIT Country code: %d\n", ret);
++		}
++
++		wiphy_lock(wiphy);
++		ath12k_mac_11d_scan_stop(ar);
++		wiphy_unlock(wiphy);
++
++		ar->regdom_set_by_user = true;
+ 	}
+ }
+ 
+-int ath12k_reg_update_chan_list(struct ath12k *ar)
++int ath12k_reg_update_chan_list(struct ath12k *ar, bool wait)
+ {
+ 	struct ieee80211_supported_band **bands;
+ 	struct ath12k_wmi_scan_chan_list_arg *arg;
+@@ -106,7 +118,35 @@ int ath12k_reg_update_chan_list(struct a
+ 	struct ath12k_wmi_channel_arg *ch;
+ 	enum nl80211_band band;
+ 	int num_channels = 0;
+-	int i, ret;
++	int i, ret, left;
++
++	if (wait && ar->state_11d != ATH12K_11D_IDLE) {
++		left = wait_for_completion_timeout(&ar->completed_11d_scan,
++						   ATH12K_SCAN_TIMEOUT_HZ);
++		if (!left) {
++			ath12k_dbg(ar->ab, ATH12K_DBG_REG,
++				   "failed to receive 11d scan complete: timed out\n");
++			ar->state_11d = ATH12K_11D_IDLE;
++		}
++		ath12k_dbg(ar->ab, ATH12K_DBG_REG,
++			   "reg 11d scan wait left time %d\n", left);
++	}
++
++	if (wait &&
++	    (ar->scan.state == ATH12K_SCAN_STARTING ||
++	    ar->scan.state == ATH12K_SCAN_RUNNING)) {
++		left = wait_for_completion_timeout(&ar->scan.completed,
++						   ATH12K_SCAN_TIMEOUT_HZ);
++		if (!left)
++			ath12k_dbg(ar->ab, ATH12K_DBG_REG,
++				   "failed to receive hw scan complete: timed out\n");
++
++		ath12k_dbg(ar->ab, ATH12K_DBG_REG,
++			   "reg hw scan wait left time %d\n", left);
++	}
++
++	if (ar->ah->state == ATH12K_HW_STATE_RESTARTING)
++		return 0;
+ 
+ 	bands = hw->wiphy->bands;
+ 	for (band = 0; band < NUM_NL80211_BANDS; band++) {
+@@ -295,7 +335,7 @@ int ath12k_regd_update(struct ath12k *ar
+ 	 */
+ 	for_each_ar(ah, ar, i) {
+ 		ab = ar->ab;
+-		ret = ath12k_reg_update_chan_list(ar);
++		ret = ath12k_reg_update_chan_list(ar, true);
+ 		if (ret)
+ 			goto err;
+ 	}
+--- a/drivers/net/wireless/ath/ath12k/reg.h
++++ b/drivers/net/wireless/ath/ath12k/reg.h
+@@ -1,7 +1,7 @@
+ /* SPDX-License-Identifier: BSD-3-Clause-Clear */
+ /*
+  * Copyright (c) 2019-2021 The Linux Foundation. All rights reserved.
+- * Copyright (c) 2021-2023 Qualcomm Innovation Center, Inc. All rights reserved.
++ * Copyright (c) 2021-2024 Qualcomm Innovation Center, Inc. All rights reserved.
+  */
+ 
+ #ifndef ATH12K_REG_H
+@@ -96,6 +96,6 @@ struct ieee80211_regdomain *ath12k_reg_b
+ 						  struct ath12k_reg_info *reg_info,
+ 						  bool intersect);
+ int ath12k_regd_update(struct ath12k *ar, bool init);
+-int ath12k_reg_update_chan_list(struct ath12k *ar);
++int ath12k_reg_update_chan_list(struct ath12k *ar, bool wait);
+ 
+ #endif
+--- a/drivers/net/wireless/ath/ath12k/hw.c
++++ b/drivers/net/wireless/ath/ath12k/hw.c
+@@ -926,6 +926,7 @@ static const struct ath12k_hw_params ath
+ 		.supports_dynamic_smps_6ghz = true,
+ 
+ 		.iova_mask = 0,
++		.current_cc_support = false,
+ 	},
+ 	{
+ 		.name = "wcn7850 hw2.0",
+@@ -1004,6 +1005,7 @@ static const struct ath12k_hw_params ath
+ 		.supports_dynamic_smps_6ghz = false,
+ 
+ 		.iova_mask = ATH12K_PCIE_MAX_PAYLOAD_SIZE - 1,
++		.current_cc_support = true,
+ 	},
+ 	{
+ 		.name = "qcn9274 hw2.0",
+@@ -1078,6 +1080,7 @@ static const struct ath12k_hw_params ath
+ 		.supports_dynamic_smps_6ghz = true,
+ 
+ 		.iova_mask = 0,
++		.current_cc_support = false,
+ 	},
+ };
+ 
+--- a/drivers/net/wireless/ath/ath12k/hw.h
++++ b/drivers/net/wireless/ath/ath12k/hw.h
+@@ -189,6 +189,7 @@ struct ath12k_hw_params {
+ 	bool tcl_ring_retry:1;
+ 	bool reoq_lut_support:1;
+ 	bool supports_shadow_regs:1;
++	bool current_cc_support:1;
+ 
+ 	u32 num_tcl_banks;
+ 	u32 max_tx_ring;




More information about the lede-commits mailing list