--- /dev/null
+From e238e62ba8868a784e485eb94451c87cd1b85cee Mon Sep 17 00:00:00 2001
+From: Aditya Kumar Singh <quic_adisi@quicinc.com>
+Date: Wed, 1 Mar 2023 16:20:59 +0200
+Subject: [PATCH] wifi: ath11k: add debug prints in regulatory WMI event
+ processing
+
+Add some more debug prints in processing regulatory WMI event in order to
+increase more debuggability.
+
+Tested-on: IPQ8074 hw2.0 AHB WLAN.HK.2.7.0.1-01744-QCAHKSWPL_SILICONZ-1
+Tested-on: QCN9074 hw1.0 PCI WLAN.HK.2.7.0.1-01744-QCAHKSWPL_SILICONZ-1
+Tested-on: QCN9074 hw1.0 PCI WLAN.HK.2.5.0.1-01100-QCAHKSWPL_SILICONZ-1
+
+Signed-off-by: Aditya Kumar Singh <quic_adisi@quicinc.com>
+Signed-off-by: Kalle Valo <quic_kvalo@quicinc.com>
+Link: https://lore.kernel.org/r/20230110121024.14051-4-quic_adisi@quicinc.com
+---
+ drivers/net/wireless/ath/ath11k/reg.c | 2 +-
+ drivers/net/wireless/ath/ath11k/wmi.c | 207 ++++++++++++++++++--------
+ drivers/net/wireless/ath/ath11k/wmi.h | 142 ++++++++++++++++++
+ 3 files changed, 291 insertions(+), 60 deletions(-)
+
+--- a/drivers/net/wireless/ath/ath11k/reg.c
++++ b/drivers/net/wireless/ath/ath11k/reg.c
+@@ -646,7 +646,7 @@ ath11k_reg_build_regd(struct ath11k_base
+ tmp_regd->dfs_region = ath11k_map_fw_dfs_region(reg_info->dfs_region);
+
+ ath11k_dbg(ab, ATH11K_DBG_REG,
+- "\r\nCountry %s, CFG Regdomain %s FW Regdomain %d, num_reg_rules %d\n",
++ "Country %s, CFG Regdomain %s FW Regdomain %d, num_reg_rules %d\n",
+ alpha2, ath11k_reg_get_regdom_str(tmp_regd->dfs_region),
+ reg_info->dfs_region, num_rules);
+ /* Update reg_rules[] below. Firmware is expected to
+--- a/drivers/net/wireless/ath/ath11k/wmi.c
++++ b/drivers/net/wireless/ath/ath11k/wmi.c
+@@ -4925,6 +4925,26 @@ static int ath11k_pull_vdev_start_resp_t
+ return 0;
+ }
+
++static void ath11k_print_reg_rule(struct ath11k_base *ab, const char *band,
++ u32 num_reg_rules,
++ struct cur_reg_rule *reg_rule_ptr)
++{
++ struct cur_reg_rule *reg_rule = reg_rule_ptr;
++ u32 count;
++
++ ath11k_dbg(ab, ATH11K_DBG_WMI, "number of reg rules in %s band: %d\n",
++ band, num_reg_rules);
++
++ for (count = 0; count < num_reg_rules; count++) {
++ ath11k_dbg(ab, ATH11K_DBG_WMI,
++ "reg rule %d: (%d - %d @ %d) (%d, %d) (FLAGS %d)\n",
++ count + 1, reg_rule->start_freq, reg_rule->end_freq,
++ reg_rule->max_bw, reg_rule->ant_gain,
++ reg_rule->reg_power, reg_rule->flags);
++ reg_rule++;
++ }
++}
++
+ static struct cur_reg_rule
+ *create_reg_rules_from_wmi(u32 num_reg_rules,
+ struct wmi_regulatory_rule_struct *wmi_reg_rule)
+@@ -5006,6 +5026,10 @@ static int ath11k_pull_reg_chan_list_upd
+ reg_info->ctry_code = chan_list_event_hdr->country_id;
+ reg_info->reg_dmn_pair = chan_list_event_hdr->domain_code;
+
++ ath11k_dbg(ab, ATH11K_DBG_WMI,
++ "status_code %s",
++ ath11k_cc_status_to_str(reg_info->status_code));
++
+ reg_info->status_code =
+ ath11k_wmi_cc_setting_code_to_reg(chan_list_event_hdr->status_code);
+
+@@ -5020,13 +5044,13 @@ static int ath11k_pull_reg_chan_list_upd
+ num_5ghz_reg_rules = reg_info->num_5ghz_reg_rules;
+
+ ath11k_dbg(ab, ATH11K_DBG_WMI,
+- "%s:cc %s dsf %d BW: min_2ghz %d max_2ghz %d min_5ghz %d max_5ghz %d",
+- __func__, reg_info->alpha2, reg_info->dfs_region,
++ "cc %s dsf %d BW: min_2ghz %d max_2ghz %d min_5ghz %d max_5ghz %d",
++ reg_info->alpha2, reg_info->dfs_region,
+ reg_info->min_bw_2ghz, reg_info->max_bw_2ghz,
+ reg_info->min_bw_5ghz, reg_info->max_bw_5ghz);
+
+ ath11k_dbg(ab, ATH11K_DBG_WMI,
+- "%s: num_2ghz_reg_rules %d num_5ghz_reg_rules %d", __func__,
++ "num_2ghz_reg_rules %d num_5ghz_reg_rules %d",
+ num_2ghz_reg_rules, num_5ghz_reg_rules);
+
+ wmi_reg_rule =
+@@ -5043,6 +5067,10 @@ static int ath11k_pull_reg_chan_list_upd
+ ath11k_warn(ab, "Unable to Allocate memory for 2 GHz rules\n");
+ return -ENOMEM;
+ }
++
++ ath11k_print_reg_rule(ab, "2 GHz",
++ num_2ghz_reg_rules,
++ reg_info->reg_rules_2ghz_ptr);
+ }
+
+ if (num_5ghz_reg_rules) {
+@@ -5055,6 +5083,10 @@ static int ath11k_pull_reg_chan_list_upd
+ ath11k_warn(ab, "Unable to Allocate memory for 5 GHz rules\n");
+ return -ENOMEM;
+ }
++
++ ath11k_print_reg_rule(ab, "5 GHz",
++ num_5ghz_reg_rules,
++ reg_info->reg_rules_5ghz_ptr);
+ }
+
+ ath11k_dbg(ab, ATH11K_DBG_WMI, "processed regulatory channel list\n");
+@@ -5128,7 +5160,7 @@ static int ath11k_pull_reg_chan_list_ext
+ struct cur_regulatory_info *reg_info)
+ {
+ const void **tb;
+- const struct wmi_reg_chan_list_cc_ext_event *ext_chan_list_event_hdr;
++ const struct wmi_reg_chan_list_cc_ext_event *ev;
+ struct wmi_regulatory_ext_rule *ext_wmi_reg_rule;
+ u32 num_2ghz_reg_rules, num_5ghz_reg_rules;
+ u32 num_6ghz_reg_rules_ap[WMI_REG_CURRENT_MAX_AP_TYPE];
+@@ -5145,31 +5177,29 @@ static int ath11k_pull_reg_chan_list_ext
+ return ret;
+ }
+
+- ext_chan_list_event_hdr = tb[WMI_TAG_REG_CHAN_LIST_CC_EXT_EVENT];
+- if (!ext_chan_list_event_hdr) {
++ ev = tb[WMI_TAG_REG_CHAN_LIST_CC_EXT_EVENT];
++ if (!ev) {
+ ath11k_warn(ab, "failed to fetch reg chan list ext update ev\n");
+ kfree(tb);
+ return -EPROTO;
+ }
+
+- reg_info->num_2ghz_reg_rules =
+- ext_chan_list_event_hdr->num_2ghz_reg_rules;
+- reg_info->num_5ghz_reg_rules =
+- ext_chan_list_event_hdr->num_5ghz_reg_rules;
++ reg_info->num_2ghz_reg_rules = ev->num_2ghz_reg_rules;
++ reg_info->num_5ghz_reg_rules = ev->num_5ghz_reg_rules;
+ reg_info->num_6ghz_rules_ap[WMI_REG_INDOOR_AP] =
+- ext_chan_list_event_hdr->num_6ghz_reg_rules_ap_lpi;
++ ev->num_6ghz_reg_rules_ap_lpi;
+ reg_info->num_6ghz_rules_ap[WMI_REG_STANDARD_POWER_AP] =
+- ext_chan_list_event_hdr->num_6ghz_reg_rules_ap_sp;
++ ev->num_6ghz_reg_rules_ap_sp;
+ reg_info->num_6ghz_rules_ap[WMI_REG_VERY_LOW_POWER_AP] =
+- ext_chan_list_event_hdr->num_6ghz_reg_rules_ap_vlp;
++ ev->num_6ghz_reg_rules_ap_vlp;
+
+ for (i = 0; i < WMI_REG_MAX_CLIENT_TYPE; i++) {
+ reg_info->num_6ghz_rules_client[WMI_REG_INDOOR_AP][i] =
+- ext_chan_list_event_hdr->num_6ghz_reg_rules_client_lpi[i];
++ ev->num_6ghz_reg_rules_client_lpi[i];
+ reg_info->num_6ghz_rules_client[WMI_REG_STANDARD_POWER_AP][i] =
+- ext_chan_list_event_hdr->num_6ghz_reg_rules_client_sp[i];
++ ev->num_6ghz_reg_rules_client_sp[i];
+ reg_info->num_6ghz_rules_client[WMI_REG_VERY_LOW_POWER_AP][i] =
+- ext_chan_list_event_hdr->num_6ghz_reg_rules_client_vlp[i];
++ ev->num_6ghz_reg_rules_client_vlp[i];
+ }
+
+ num_2ghz_reg_rules = reg_info->num_2ghz_reg_rules;
+@@ -5231,57 +5261,79 @@ static int ath11k_pull_reg_chan_list_ext
+ return -EINVAL;
+ }
+
+- memcpy(reg_info->alpha2, &ext_chan_list_event_hdr->alpha2,
+- REG_ALPHA2_LEN);
++ memcpy(reg_info->alpha2, &ev->alpha2, REG_ALPHA2_LEN);
++
++ reg_info->dfs_region = ev->dfs_region;
++ reg_info->phybitmap = ev->phybitmap;
++ reg_info->num_phy = ev->num_phy;
++ reg_info->phy_id = ev->phy_id;
++ reg_info->ctry_code = ev->country_id;
++ reg_info->reg_dmn_pair = ev->domain_code;
+
+- reg_info->dfs_region = ext_chan_list_event_hdr->dfs_region;
+- reg_info->phybitmap = ext_chan_list_event_hdr->phybitmap;
+- reg_info->num_phy = ext_chan_list_event_hdr->num_phy;
+- reg_info->phy_id = ext_chan_list_event_hdr->phy_id;
+- reg_info->ctry_code = ext_chan_list_event_hdr->country_id;
+- reg_info->reg_dmn_pair = ext_chan_list_event_hdr->domain_code;
++ ath11k_dbg(ab, ATH11K_DBG_WMI,
++ "status_code %s",
++ ath11k_cc_status_to_str(reg_info->status_code));
+
+ reg_info->status_code =
+- ath11k_wmi_cc_setting_code_to_reg(ext_chan_list_event_hdr->status_code);
++ ath11k_wmi_cc_setting_code_to_reg(ev->status_code);
+
+ reg_info->is_ext_reg_event = true;
+
+- reg_info->min_bw_2ghz = ext_chan_list_event_hdr->min_bw_2ghz;
+- reg_info->max_bw_2ghz = ext_chan_list_event_hdr->max_bw_2ghz;
+- reg_info->min_bw_5ghz = ext_chan_list_event_hdr->min_bw_5ghz;
+- reg_info->max_bw_5ghz = ext_chan_list_event_hdr->max_bw_5ghz;
++ reg_info->min_bw_2ghz = ev->min_bw_2ghz;
++ reg_info->max_bw_2ghz = ev->max_bw_2ghz;
++ reg_info->min_bw_5ghz = ev->min_bw_5ghz;
++ reg_info->max_bw_5ghz = ev->max_bw_5ghz;
+
+ reg_info->min_bw_6ghz_ap[WMI_REG_INDOOR_AP] =
+- ext_chan_list_event_hdr->min_bw_6ghz_ap_lpi;
++ ev->min_bw_6ghz_ap_lpi;
+ reg_info->max_bw_6ghz_ap[WMI_REG_INDOOR_AP] =
+- ext_chan_list_event_hdr->max_bw_6ghz_ap_lpi;
++ ev->max_bw_6ghz_ap_lpi;
+ reg_info->min_bw_6ghz_ap[WMI_REG_STANDARD_POWER_AP] =
+- ext_chan_list_event_hdr->min_bw_6ghz_ap_sp;
++ ev->min_bw_6ghz_ap_sp;
+ reg_info->max_bw_6ghz_ap[WMI_REG_STANDARD_POWER_AP] =
+- ext_chan_list_event_hdr->max_bw_6ghz_ap_sp;
++ ev->max_bw_6ghz_ap_sp;
+ reg_info->min_bw_6ghz_ap[WMI_REG_VERY_LOW_POWER_AP] =
+- ext_chan_list_event_hdr->min_bw_6ghz_ap_vlp;
++ ev->min_bw_6ghz_ap_vlp;
+ reg_info->max_bw_6ghz_ap[WMI_REG_VERY_LOW_POWER_AP] =
+- ext_chan_list_event_hdr->max_bw_6ghz_ap_vlp;
++ ev->max_bw_6ghz_ap_vlp;
++
++ ath11k_dbg(ab, ATH11K_DBG_WMI,
++ "6 GHz AP BW: LPI (%d - %d), SP (%d - %d), VLP (%d - %d)\n",
++ reg_info->min_bw_6ghz_ap[WMI_REG_INDOOR_AP],
++ reg_info->max_bw_6ghz_ap[WMI_REG_INDOOR_AP],
++ reg_info->min_bw_6ghz_ap[WMI_REG_STANDARD_POWER_AP],
++ reg_info->max_bw_6ghz_ap[WMI_REG_STANDARD_POWER_AP],
++ reg_info->min_bw_6ghz_ap[WMI_REG_VERY_LOW_POWER_AP],
++ reg_info->max_bw_6ghz_ap[WMI_REG_VERY_LOW_POWER_AP]);
+
+ for (i = 0; i < WMI_REG_MAX_CLIENT_TYPE; i++) {
+ reg_info->min_bw_6ghz_client[WMI_REG_INDOOR_AP][i] =
+- ext_chan_list_event_hdr->min_bw_6ghz_client_lpi[i];
++ ev->min_bw_6ghz_client_lpi[i];
+ reg_info->max_bw_6ghz_client[WMI_REG_INDOOR_AP][i] =
+- ext_chan_list_event_hdr->max_bw_6ghz_client_lpi[i];
++ ev->max_bw_6ghz_client_lpi[i];
+ reg_info->min_bw_6ghz_client[WMI_REG_STANDARD_POWER_AP][i] =
+- ext_chan_list_event_hdr->min_bw_6ghz_client_sp[i];
++ ev->min_bw_6ghz_client_sp[i];
+ reg_info->max_bw_6ghz_client[WMI_REG_STANDARD_POWER_AP][i] =
+- ext_chan_list_event_hdr->max_bw_6ghz_client_sp[i];
++ ev->max_bw_6ghz_client_sp[i];
+ reg_info->min_bw_6ghz_client[WMI_REG_VERY_LOW_POWER_AP][i] =
+- ext_chan_list_event_hdr->min_bw_6ghz_client_vlp[i];
++ ev->min_bw_6ghz_client_vlp[i];
+ reg_info->max_bw_6ghz_client[WMI_REG_VERY_LOW_POWER_AP][i] =
+- ext_chan_list_event_hdr->max_bw_6ghz_client_vlp[i];
++ ev->max_bw_6ghz_client_vlp[i];
++
++ ath11k_dbg(ab, ATH11K_DBG_WMI,
++ "6 GHz %s BW: LPI (%d - %d), SP (%d - %d), VLP (%d - %d)\n",
++ ath11k_6ghz_client_type_to_str(i),
++ reg_info->min_bw_6ghz_client[WMI_REG_INDOOR_AP][i],
++ reg_info->max_bw_6ghz_client[WMI_REG_INDOOR_AP][i],
++ reg_info->min_bw_6ghz_client[WMI_REG_STANDARD_POWER_AP][i],
++ reg_info->max_bw_6ghz_client[WMI_REG_STANDARD_POWER_AP][i],
++ reg_info->min_bw_6ghz_client[WMI_REG_VERY_LOW_POWER_AP][i],
++ reg_info->max_bw_6ghz_client[WMI_REG_VERY_LOW_POWER_AP][i]);
+ }
+
+ ath11k_dbg(ab, ATH11K_DBG_WMI,
+- "%s:cc_ext %s dsf %d BW: min_2ghz %d max_2ghz %d min_5ghz %d max_5ghz %d",
+- __func__, reg_info->alpha2, reg_info->dfs_region,
++ "cc_ext %s dsf %d BW: min_2ghz %d max_2ghz %d min_5ghz %d max_5ghz %d",
++ reg_info->alpha2, reg_info->dfs_region,
+ reg_info->min_bw_2ghz, reg_info->max_bw_2ghz,
+ reg_info->min_bw_5ghz, reg_info->max_bw_5ghz);
+
+@@ -5310,9 +5362,8 @@ static int ath11k_pull_reg_chan_list_ext
+ num_6ghz_client[WMI_REG_VERY_LOW_POWER_AP][j]);
+
+ ext_wmi_reg_rule =
+- (struct wmi_regulatory_ext_rule *)((u8 *)ext_chan_list_event_hdr
+- + sizeof(*ext_chan_list_event_hdr)
+- + sizeof(struct wmi_tlv));
++ (struct wmi_regulatory_ext_rule *)((u8 *)ev + sizeof(*ev) +
++ sizeof(struct wmi_tlv));
+ if (num_2ghz_reg_rules) {
+ reg_info->reg_rules_2ghz_ptr =
+ create_ext_reg_rules_from_wmi(num_2ghz_reg_rules,
+@@ -5323,6 +5374,10 @@ static int ath11k_pull_reg_chan_list_ext
+ ath11k_warn(ab, "Unable to Allocate memory for 2 GHz rules\n");
+ return -ENOMEM;
+ }
++
++ ath11k_print_reg_rule(ab, "2 GHz",
++ num_2ghz_reg_rules,
++ reg_info->reg_rules_2ghz_ptr);
+ }
+
+ ext_wmi_reg_rule += num_2ghz_reg_rules;
+@@ -5358,6 +5413,10 @@ static int ath11k_pull_reg_chan_list_ext
+ ath11k_warn(ab, "Unable to Allocate memory for 5 GHz rules\n");
+ return -ENOMEM;
+ }
++
++ ath11k_print_reg_rule(ab, "5 GHz",
++ num_5ghz_reg_rules,
++ reg_info->reg_rules_5ghz_ptr);
+ }
+
+ /* We have adjusted the number of 5 GHz reg rules above. But still those
+@@ -5378,10 +5437,17 @@ static int ath11k_pull_reg_chan_list_ext
+ return -ENOMEM;
+ }
+
++ ath11k_print_reg_rule(ab, ath11k_6ghz_ap_type_to_str(i),
++ num_6ghz_reg_rules_ap[i],
++ reg_info->reg_rules_6ghz_ap_ptr[i]);
++
+ ext_wmi_reg_rule += num_6ghz_reg_rules_ap[i];
+ }
+
+ for (j = 0; j < WMI_REG_CURRENT_MAX_AP_TYPE; j++) {
++ ath11k_dbg(ab, ATH11K_DBG_WMI,
++ "6 GHz AP type %s", ath11k_6ghz_ap_type_to_str(j));
++
+ for (i = 0; i < WMI_REG_MAX_CLIENT_TYPE; i++) {
+ reg_info->reg_rules_6ghz_client_ptr[j][i] =
+ create_ext_reg_rules_from_wmi(num_6ghz_client[j][i],
+@@ -5393,35 +5459,58 @@ static int ath11k_pull_reg_chan_list_ext
+ return -ENOMEM;
+ }
+
++ ath11k_print_reg_rule(ab,
++ ath11k_6ghz_client_type_to_str(i),
++ num_6ghz_client[j][i],
++ reg_info->reg_rules_6ghz_client_ptr[j][i]);
++
+ ext_wmi_reg_rule += num_6ghz_client[j][i];
+ }
+ }
+
+- reg_info->client_type = ext_chan_list_event_hdr->client_type;
+- reg_info->rnr_tpe_usable = ext_chan_list_event_hdr->rnr_tpe_usable;
++ reg_info->client_type = ev->client_type;
++ reg_info->rnr_tpe_usable = ev->rnr_tpe_usable;
+ reg_info->unspecified_ap_usable =
+- ext_chan_list_event_hdr->unspecified_ap_usable;
++ ev->unspecified_ap_usable;
+ reg_info->domain_code_6ghz_ap[WMI_REG_INDOOR_AP] =
+- ext_chan_list_event_hdr->domain_code_6ghz_ap_lpi;
++ ev->domain_code_6ghz_ap_lpi;
+ reg_info->domain_code_6ghz_ap[WMI_REG_STANDARD_POWER_AP] =
+- ext_chan_list_event_hdr->domain_code_6ghz_ap_sp;
++ ev->domain_code_6ghz_ap_sp;
+ reg_info->domain_code_6ghz_ap[WMI_REG_VERY_LOW_POWER_AP] =
+- ext_chan_list_event_hdr->domain_code_6ghz_ap_vlp;
++ ev->domain_code_6ghz_ap_vlp;
++
++ ath11k_dbg(ab, ATH11K_DBG_WMI,
++ "6 GHz reg info client type %s rnr_tpe_usable %d unspecified_ap_usable %d AP sub domain: lpi %s, sp %s, vlp %s\n",
++ ath11k_6ghz_client_type_to_str(reg_info->client_type),
++ reg_info->rnr_tpe_usable,
++ reg_info->unspecified_ap_usable,
++ ath11k_sub_reg_6ghz_to_str(ev->domain_code_6ghz_ap_lpi),
++ ath11k_sub_reg_6ghz_to_str(ev->domain_code_6ghz_ap_sp),
++ ath11k_sub_reg_6ghz_to_str(ev->domain_code_6ghz_ap_vlp));
+
+ for (i = 0; i < WMI_REG_MAX_CLIENT_TYPE; i++) {
+ reg_info->domain_code_6ghz_client[WMI_REG_INDOOR_AP][i] =
+- ext_chan_list_event_hdr->domain_code_6ghz_client_lpi[i];
++ ev->domain_code_6ghz_client_lpi[i];
+ reg_info->domain_code_6ghz_client[WMI_REG_STANDARD_POWER_AP][i] =
+- ext_chan_list_event_hdr->domain_code_6ghz_client_sp[i];
++ ev->domain_code_6ghz_client_sp[i];
+ reg_info->domain_code_6ghz_client[WMI_REG_VERY_LOW_POWER_AP][i] =
+- ext_chan_list_event_hdr->domain_code_6ghz_client_vlp[i];
++ ev->domain_code_6ghz_client_vlp[i];
++
++ ath11k_dbg(ab, ATH11K_DBG_WMI,
++ "6 GHz client type %s client sub domain: lpi %s, sp %s, vlp %s\n",
++ ath11k_6ghz_client_type_to_str(i),
++ ath11k_sub_reg_6ghz_to_str(ev->domain_code_6ghz_client_lpi[i]),
++ ath11k_sub_reg_6ghz_to_str(ev->domain_code_6ghz_client_sp[i]),
++ ath11k_sub_reg_6ghz_to_str(ev->domain_code_6ghz_client_vlp[i])
++ );
+ }
+
+- reg_info->domain_code_6ghz_super_id =
+- ext_chan_list_event_hdr->domain_code_6ghz_super_id;
++ reg_info->domain_code_6ghz_super_id = ev->domain_code_6ghz_super_id;
+
+- ath11k_dbg(ab, ATH11K_DBG_WMI, "6 GHz client_type: %d domain_code_6ghz_super_id: %d",
+- reg_info->client_type, reg_info->domain_code_6ghz_super_id);
++ ath11k_dbg(ab, ATH11K_DBG_WMI,
++ "6 GHz client_type %s 6 GHz super domain %s",
++ ath11k_6ghz_client_type_to_str(reg_info->client_type),
++ ath11k_super_reg_6ghz_to_str(reg_info->domain_code_6ghz_super_id));
+
+ ath11k_dbg(ab, ATH11K_DBG_WMI, "processed regulatory ext channel list\n");
+
+--- a/drivers/net/wireless/ath/ath11k/wmi.h
++++ b/drivers/net/wireless/ath/ath11k/wmi.h
+@@ -4139,6 +4139,7 @@ enum cc_setting_code {
+
+ /* add new setting code above, update in
+ * @enum wmi_reg_cc_setting_code as well.
++ * Also handle it in ath11k_cc_status_to_str()
+ */
+ };
+
+@@ -4163,21 +4164,162 @@ ath11k_wmi_cc_setting_code_to_reg(enum w
+ return REG_SET_CC_STATUS_FAIL;
+ }
+
++static inline const char *ath11k_cc_status_to_str(enum cc_setting_code code)
++{
++ switch (code) {
++ case REG_SET_CC_STATUS_PASS:
++ return "REG_SET_CC_STATUS_PASS";
++ case REG_CURRENT_ALPHA2_NOT_FOUND:
++ return "REG_CURRENT_ALPHA2_NOT_FOUND";
++ case REG_INIT_ALPHA2_NOT_FOUND:
++ return "REG_INIT_ALPHA2_NOT_FOUND";
++ case REG_SET_CC_CHANGE_NOT_ALLOWED:
++ return "REG_SET_CC_CHANGE_NOT_ALLOWED";
++ case REG_SET_CC_STATUS_NO_MEMORY:
++ return "REG_SET_CC_STATUS_NO_MEMORY";
++ case REG_SET_CC_STATUS_FAIL:
++ return "REG_SET_CC_STATUS_FAIL";
++ }
++
++ return "Unknown CC status";
++}
++
+ enum wmi_reg_6ghz_ap_type {
+ WMI_REG_INDOOR_AP = 0,
+ WMI_REG_STANDARD_POWER_AP = 1,
+ WMI_REG_VERY_LOW_POWER_AP = 2,
+
++ /* add AP type above, handle in ath11k_6ghz_ap_type_to_str()
++ */
+ WMI_REG_CURRENT_MAX_AP_TYPE,
+ WMI_REG_MAX_AP_TYPE = 7,
+ };
+
++static inline const char *
++ath11k_6ghz_ap_type_to_str(enum wmi_reg_6ghz_ap_type type)
++{
++ switch (type) {
++ case WMI_REG_INDOOR_AP:
++ return "INDOOR AP";
++ case WMI_REG_STANDARD_POWER_AP:
++ return "STANDARD POWER AP";
++ case WMI_REG_VERY_LOW_POWER_AP:
++ return "VERY LOW POWER AP";
++ case WMI_REG_CURRENT_MAX_AP_TYPE:
++ return "CURRENT_MAX_AP_TYPE";
++ case WMI_REG_MAX_AP_TYPE:
++ return "MAX_AP_TYPE";
++ }
++
++ return "unknown 6 GHz AP type";
++}
++
+ enum wmi_reg_6ghz_client_type {
+ WMI_REG_DEFAULT_CLIENT = 0,
+ WMI_REG_SUBORDINATE_CLIENT = 1,
+ WMI_REG_MAX_CLIENT_TYPE = 2,
++
++ /* add client type above, handle it in
++ * ath11k_6ghz_client_type_to_str()
++ */
++};
++
++static inline const char *
++ath11k_6ghz_client_type_to_str(enum wmi_reg_6ghz_client_type type)
++{
++ switch (type) {
++ case WMI_REG_DEFAULT_CLIENT:
++ return "DEFAULT CLIENT";
++ case WMI_REG_SUBORDINATE_CLIENT:
++ return "SUBORDINATE CLIENT";
++ case WMI_REG_MAX_CLIENT_TYPE:
++ return "MAX_CLIENT_TYPE";
++ }
++
++ return "unknown 6 GHz client type";
++}
++
++enum reg_subdomains_6ghz {
++ EMPTY_6GHZ = 0x0,
++ FCC1_CLIENT_LPI_REGULAR_6GHZ = 0x01,
++ FCC1_CLIENT_SP_6GHZ = 0x02,
++ FCC1_AP_LPI_6GHZ = 0x03,
++ FCC1_CLIENT_LPI_SUBORDINATE = FCC1_AP_LPI_6GHZ,
++ FCC1_AP_SP_6GHZ = 0x04,
++ ETSI1_LPI_6GHZ = 0x10,
++ ETSI1_VLP_6GHZ = 0x11,
++ ETSI2_LPI_6GHZ = 0x12,
++ ETSI2_VLP_6GHZ = 0x13,
++ APL1_LPI_6GHZ = 0x20,
++ APL1_VLP_6GHZ = 0x21,
++
++ /* add sub-domain above, handle it in
++ * ath11k_sub_reg_6ghz_to_str()
++ */
++};
++
++static inline const char *
++ath11k_sub_reg_6ghz_to_str(enum reg_subdomains_6ghz sub_id)
++{
++ switch (sub_id) {
++ case EMPTY_6GHZ:
++ return "N/A";
++ case FCC1_CLIENT_LPI_REGULAR_6GHZ:
++ return "FCC1_CLIENT_LPI_REGULAR_6GHZ";
++ case FCC1_CLIENT_SP_6GHZ:
++ return "FCC1_CLIENT_SP_6GHZ";
++ case FCC1_AP_LPI_6GHZ:
++ return "FCC1_AP_LPI_6GHZ/FCC1_CLIENT_LPI_SUBORDINATE";
++ case FCC1_AP_SP_6GHZ:
++ return "FCC1_AP_SP_6GHZ";
++ case ETSI1_LPI_6GHZ:
++ return "ETSI1_LPI_6GHZ";
++ case ETSI1_VLP_6GHZ:
++ return "ETSI1_VLP_6GHZ";
++ case ETSI2_LPI_6GHZ:
++ return "ETSI2_LPI_6GHZ";
++ case ETSI2_VLP_6GHZ:
++ return "ETSI2_VLP_6GHZ";
++ case APL1_LPI_6GHZ:
++ return "APL1_LPI_6GHZ";
++ case APL1_VLP_6GHZ:
++ return "APL1_VLP_6GHZ";
++ }
++
++ return "unknown sub reg id";
++}
++
++enum reg_super_domain_6ghz {
++ FCC1_6GHZ = 0x01,
++ ETSI1_6GHZ = 0x02,
++ ETSI2_6GHZ = 0x03,
++ APL1_6GHZ = 0x04,
++ FCC1_6GHZ_CL = 0x05,
++
++ /* add super domain above, handle it in
++ * ath11k_super_reg_6ghz_to_str()
++ */
+ };
+
++static inline const char *
++ath11k_super_reg_6ghz_to_str(enum reg_super_domain_6ghz domain_id)
++{
++ switch (domain_id) {
++ case FCC1_6GHZ:
++ return "FCC1_6GHZ";
++ case ETSI1_6GHZ:
++ return "ETSI1_6GHZ";
++ case ETSI2_6GHZ:
++ return "ETSI2_6GHZ";
++ case APL1_6GHZ:
++ return "APL1_6GHZ";
++ case FCC1_6GHZ_CL:
++ return "FCC1_6GHZ_CL";
++ }
++
++ return "unknown domain id";
++}
++
+ struct cur_reg_rule {
+ u16 start_freq;
+ u16 end_freq;
projects / openwrt / staging / dedeckeh.git / blobdiff