projects / openwrt / staging / blogic.git / blob
? search:


b88e51928f7abdcc33edcbdf740f467a5498c73d
[openwrt/staging/blogic.git] /
1 From e238e62ba8868a784e485eb94451c87cd1b85cee Mon Sep 17 00:00:00 2001
2 From: Aditya Kumar Singh <quic_adisi@quicinc.com>
3 Date: Wed, 1 Mar 2023 16:20:59 +0200
4 Subject: [PATCH] wifi: ath11k: add debug prints in regulatory WMI event
5 processing
6
7 Add some more debug prints in processing regulatory WMI event in order to
8 increase more debuggability.
9
10 Tested-on: IPQ8074 hw2.0 AHB WLAN.HK.2.7.0.1-01744-QCAHKSWPL_SILICONZ-1
11 Tested-on: QCN9074 hw1.0 PCI WLAN.HK.2.7.0.1-01744-QCAHKSWPL_SILICONZ-1
12 Tested-on: QCN9074 hw1.0 PCI WLAN.HK.2.5.0.1-01100-QCAHKSWPL_SILICONZ-1
13
14 Signed-off-by: Aditya Kumar Singh <quic_adisi@quicinc.com>
15 Signed-off-by: Kalle Valo <quic_kvalo@quicinc.com>
16 Link: https://lore.kernel.org/r/20230110121024.14051-4-quic_adisi@quicinc.com
17 ---
18 drivers/net/wireless/ath/ath11k/reg.c | 2 +-
19 drivers/net/wireless/ath/ath11k/wmi.c | 207 ++++++++++++++++++--------
20 drivers/net/wireless/ath/ath11k/wmi.h | 142 ++++++++++++++++++
21 3 files changed, 291 insertions(+), 60 deletions(-)
22
23 --- a/drivers/net/wireless/ath/ath11k/reg.c
24 +++ b/drivers/net/wireless/ath/ath11k/reg.c
25 @@ -646,7 +646,7 @@ ath11k_reg_build_regd(struct ath11k_base
26 tmp_regd->dfs_region = ath11k_map_fw_dfs_region(reg_info->dfs_region);
27
28 ath11k_dbg(ab, ATH11K_DBG_REG,
29 - "\r\nCountry %s, CFG Regdomain %s FW Regdomain %d, num_reg_rules %d\n",
30 + "Country %s, CFG Regdomain %s FW Regdomain %d, num_reg_rules %d\n",
31 alpha2, ath11k_reg_get_regdom_str(tmp_regd->dfs_region),
32 reg_info->dfs_region, num_rules);
33 /* Update reg_rules[] below. Firmware is expected to
34 --- a/drivers/net/wireless/ath/ath11k/wmi.c
35 +++ b/drivers/net/wireless/ath/ath11k/wmi.c
36 @@ -4925,6 +4925,26 @@ static int ath11k_pull_vdev_start_resp_t
37 return 0;
38 }
39
40 +static void ath11k_print_reg_rule(struct ath11k_base *ab, const char *band,
41 + u32 num_reg_rules,
42 + struct cur_reg_rule *reg_rule_ptr)
43 +{
44 + struct cur_reg_rule *reg_rule = reg_rule_ptr;
45 + u32 count;
46 +
47 + ath11k_dbg(ab, ATH11K_DBG_WMI, "number of reg rules in %s band: %d\n",
48 + band, num_reg_rules);
49 +
50 + for (count = 0; count < num_reg_rules; count++) {
51 + ath11k_dbg(ab, ATH11K_DBG_WMI,
52 + "reg rule %d: (%d - %d @ %d) (%d, %d) (FLAGS %d)\n",
53 + count + 1, reg_rule->start_freq, reg_rule->end_freq,
54 + reg_rule->max_bw, reg_rule->ant_gain,
55 + reg_rule->reg_power, reg_rule->flags);
56 + reg_rule++;
57 + }
58 +}
59 +
60 static struct cur_reg_rule
61 *create_reg_rules_from_wmi(u32 num_reg_rules,
62 struct wmi_regulatory_rule_struct *wmi_reg_rule)
63 @@ -5006,6 +5026,10 @@ static int ath11k_pull_reg_chan_list_upd
64 reg_info->ctry_code = chan_list_event_hdr->country_id;
65 reg_info->reg_dmn_pair = chan_list_event_hdr->domain_code;
66
67 + ath11k_dbg(ab, ATH11K_DBG_WMI,
68 + "status_code %s",
69 + ath11k_cc_status_to_str(reg_info->status_code));
70 +
71 reg_info->status_code =
72 ath11k_wmi_cc_setting_code_to_reg(chan_list_event_hdr->status_code);
73
74 @@ -5020,13 +5044,13 @@ static int ath11k_pull_reg_chan_list_upd
75 num_5ghz_reg_rules = reg_info->num_5ghz_reg_rules;
76
77 ath11k_dbg(ab, ATH11K_DBG_WMI,
78 - "%s:cc %s dsf %d BW: min_2ghz %d max_2ghz %d min_5ghz %d max_5ghz %d",
79 - __func__, reg_info->alpha2, reg_info->dfs_region,
80 + "cc %s dsf %d BW: min_2ghz %d max_2ghz %d min_5ghz %d max_5ghz %d",
81 + reg_info->alpha2, reg_info->dfs_region,
82 reg_info->min_bw_2ghz, reg_info->max_bw_2ghz,
83 reg_info->min_bw_5ghz, reg_info->max_bw_5ghz);
84
85 ath11k_dbg(ab, ATH11K_DBG_WMI,
86 - "%s: num_2ghz_reg_rules %d num_5ghz_reg_rules %d", __func__,
87 + "num_2ghz_reg_rules %d num_5ghz_reg_rules %d",
88 num_2ghz_reg_rules, num_5ghz_reg_rules);
89
90 wmi_reg_rule =
91 @@ -5043,6 +5067,10 @@ static int ath11k_pull_reg_chan_list_upd
92 ath11k_warn(ab, "Unable to Allocate memory for 2 GHz rules\n");
93 return -ENOMEM;
94 }
95 +
96 + ath11k_print_reg_rule(ab, "2 GHz",
97 + num_2ghz_reg_rules,
98 + reg_info->reg_rules_2ghz_ptr);
99 }
100
101 if (num_5ghz_reg_rules) {
102 @@ -5055,6 +5083,10 @@ static int ath11k_pull_reg_chan_list_upd
103 ath11k_warn(ab, "Unable to Allocate memory for 5 GHz rules\n");
104 return -ENOMEM;
105 }
106 +
107 + ath11k_print_reg_rule(ab, "5 GHz",
108 + num_5ghz_reg_rules,
109 + reg_info->reg_rules_5ghz_ptr);
110 }
111
112 ath11k_dbg(ab, ATH11K_DBG_WMI, "processed regulatory channel list\n");
113 @@ -5128,7 +5160,7 @@ static int ath11k_pull_reg_chan_list_ext
114 struct cur_regulatory_info *reg_info)
115 {
116 const void **tb;
117 - const struct wmi_reg_chan_list_cc_ext_event *ext_chan_list_event_hdr;
118 + const struct wmi_reg_chan_list_cc_ext_event *ev;
119 struct wmi_regulatory_ext_rule *ext_wmi_reg_rule;
120 u32 num_2ghz_reg_rules, num_5ghz_reg_rules;
121 u32 num_6ghz_reg_rules_ap[WMI_REG_CURRENT_MAX_AP_TYPE];
122 @@ -5145,31 +5177,29 @@ static int ath11k_pull_reg_chan_list_ext
123 return ret;
124 }
125
126 - ext_chan_list_event_hdr = tb[WMI_TAG_REG_CHAN_LIST_CC_EXT_EVENT];
127 - if (!ext_chan_list_event_hdr) {
128 + ev = tb[WMI_TAG_REG_CHAN_LIST_CC_EXT_EVENT];
129 + if (!ev) {
130 ath11k_warn(ab, "failed to fetch reg chan list ext update ev\n");
131 kfree(tb);
132 return -EPROTO;
133 }
134
135 - reg_info->num_2ghz_reg_rules =
136 - ext_chan_list_event_hdr->num_2ghz_reg_rules;
137 - reg_info->num_5ghz_reg_rules =
138 - ext_chan_list_event_hdr->num_5ghz_reg_rules;
139 + reg_info->num_2ghz_reg_rules = ev->num_2ghz_reg_rules;
140 + reg_info->num_5ghz_reg_rules = ev->num_5ghz_reg_rules;
141 reg_info->num_6ghz_rules_ap[WMI_REG_INDOOR_AP] =
142 - ext_chan_list_event_hdr->num_6ghz_reg_rules_ap_lpi;
143 + ev->num_6ghz_reg_rules_ap_lpi;
144 reg_info->num_6ghz_rules_ap[WMI_REG_STANDARD_POWER_AP] =
145 - ext_chan_list_event_hdr->num_6ghz_reg_rules_ap_sp;
146 + ev->num_6ghz_reg_rules_ap_sp;
147 reg_info->num_6ghz_rules_ap[WMI_REG_VERY_LOW_POWER_AP] =
148 - ext_chan_list_event_hdr->num_6ghz_reg_rules_ap_vlp;
149 + ev->num_6ghz_reg_rules_ap_vlp;
150
151 for (i = 0; i < WMI_REG_MAX_CLIENT_TYPE; i++) {
152 reg_info->num_6ghz_rules_client[WMI_REG_INDOOR_AP][i] =
153 - ext_chan_list_event_hdr->num_6ghz_reg_rules_client_lpi[i];
154 + ev->num_6ghz_reg_rules_client_lpi[i];
155 reg_info->num_6ghz_rules_client[WMI_REG_STANDARD_POWER_AP][i] =
156 - ext_chan_list_event_hdr->num_6ghz_reg_rules_client_sp[i];
157 + ev->num_6ghz_reg_rules_client_sp[i];
158 reg_info->num_6ghz_rules_client[WMI_REG_VERY_LOW_POWER_AP][i] =
159 - ext_chan_list_event_hdr->num_6ghz_reg_rules_client_vlp[i];
160 + ev->num_6ghz_reg_rules_client_vlp[i];
161 }
162
163 num_2ghz_reg_rules = reg_info->num_2ghz_reg_rules;
164 @@ -5231,57 +5261,79 @@ static int ath11k_pull_reg_chan_list_ext
165 return -EINVAL;
166 }
167
168 - memcpy(reg_info->alpha2, &ext_chan_list_event_hdr->alpha2,
169 - REG_ALPHA2_LEN);
170 + memcpy(reg_info->alpha2, &ev->alpha2, REG_ALPHA2_LEN);
171 +
172 + reg_info->dfs_region = ev->dfs_region;
173 + reg_info->phybitmap = ev->phybitmap;
174 + reg_info->num_phy = ev->num_phy;
175 + reg_info->phy_id = ev->phy_id;
176 + reg_info->ctry_code = ev->country_id;
177 + reg_info->reg_dmn_pair = ev->domain_code;
178
179 - reg_info->dfs_region = ext_chan_list_event_hdr->dfs_region;
180 - reg_info->phybitmap = ext_chan_list_event_hdr->phybitmap;
181 - reg_info->num_phy = ext_chan_list_event_hdr->num_phy;
182 - reg_info->phy_id = ext_chan_list_event_hdr->phy_id;
183 - reg_info->ctry_code = ext_chan_list_event_hdr->country_id;
184 - reg_info->reg_dmn_pair = ext_chan_list_event_hdr->domain_code;
185 + ath11k_dbg(ab, ATH11K_DBG_WMI,
186 + "status_code %s",
187 + ath11k_cc_status_to_str(reg_info->status_code));
188
189 reg_info->status_code =
190 - ath11k_wmi_cc_setting_code_to_reg(ext_chan_list_event_hdr->status_code);
191 + ath11k_wmi_cc_setting_code_to_reg(ev->status_code);
192
193 reg_info->is_ext_reg_event = true;
194
195 - reg_info->min_bw_2ghz = ext_chan_list_event_hdr->min_bw_2ghz;
196 - reg_info->max_bw_2ghz = ext_chan_list_event_hdr->max_bw_2ghz;
197 - reg_info->min_bw_5ghz = ext_chan_list_event_hdr->min_bw_5ghz;
198 - reg_info->max_bw_5ghz = ext_chan_list_event_hdr->max_bw_5ghz;
199 + reg_info->min_bw_2ghz = ev->min_bw_2ghz;
200 + reg_info->max_bw_2ghz = ev->max_bw_2ghz;
201 + reg_info->min_bw_5ghz = ev->min_bw_5ghz;
202 + reg_info->max_bw_5ghz = ev->max_bw_5ghz;
203
204 reg_info->min_bw_6ghz_ap[WMI_REG_INDOOR_AP] =
205 - ext_chan_list_event_hdr->min_bw_6ghz_ap_lpi;
206 + ev->min_bw_6ghz_ap_lpi;
207 reg_info->max_bw_6ghz_ap[WMI_REG_INDOOR_AP] =
208 - ext_chan_list_event_hdr->max_bw_6ghz_ap_lpi;
209 + ev->max_bw_6ghz_ap_lpi;
210 reg_info->min_bw_6ghz_ap[WMI_REG_STANDARD_POWER_AP] =
211 - ext_chan_list_event_hdr->min_bw_6ghz_ap_sp;
212 + ev->min_bw_6ghz_ap_sp;
213 reg_info->max_bw_6ghz_ap[WMI_REG_STANDARD_POWER_AP] =
214 - ext_chan_list_event_hdr->max_bw_6ghz_ap_sp;
215 + ev->max_bw_6ghz_ap_sp;
216 reg_info->min_bw_6ghz_ap[WMI_REG_VERY_LOW_POWER_AP] =
217 - ext_chan_list_event_hdr->min_bw_6ghz_ap_vlp;
218 + ev->min_bw_6ghz_ap_vlp;
219 reg_info->max_bw_6ghz_ap[WMI_REG_VERY_LOW_POWER_AP] =
220 - ext_chan_list_event_hdr->max_bw_6ghz_ap_vlp;
221 + ev->max_bw_6ghz_ap_vlp;
222 +
223 + ath11k_dbg(ab, ATH11K_DBG_WMI,
224 + "6 GHz AP BW: LPI (%d - %d), SP (%d - %d), VLP (%d - %d)\n",
225 + reg_info->min_bw_6ghz_ap[WMI_REG_INDOOR_AP],
226 + reg_info->max_bw_6ghz_ap[WMI_REG_INDOOR_AP],
227 + reg_info->min_bw_6ghz_ap[WMI_REG_STANDARD_POWER_AP],
228 + reg_info->max_bw_6ghz_ap[WMI_REG_STANDARD_POWER_AP],
229 + reg_info->min_bw_6ghz_ap[WMI_REG_VERY_LOW_POWER_AP],
230 + reg_info->max_bw_6ghz_ap[WMI_REG_VERY_LOW_POWER_AP]);
231
232 for (i = 0; i < WMI_REG_MAX_CLIENT_TYPE; i++) {
233 reg_info->min_bw_6ghz_client[WMI_REG_INDOOR_AP][i] =
234 - ext_chan_list_event_hdr->min_bw_6ghz_client_lpi[i];
235 + ev->min_bw_6ghz_client_lpi[i];
236 reg_info->max_bw_6ghz_client[WMI_REG_INDOOR_AP][i] =
237 - ext_chan_list_event_hdr->max_bw_6ghz_client_lpi[i];
238 + ev->max_bw_6ghz_client_lpi[i];
239 reg_info->min_bw_6ghz_client[WMI_REG_STANDARD_POWER_AP][i] =
240 - ext_chan_list_event_hdr->min_bw_6ghz_client_sp[i];
241 + ev->min_bw_6ghz_client_sp[i];
242 reg_info->max_bw_6ghz_client[WMI_REG_STANDARD_POWER_AP][i] =
243 - ext_chan_list_event_hdr->max_bw_6ghz_client_sp[i];
244 + ev->max_bw_6ghz_client_sp[i];
245 reg_info->min_bw_6ghz_client[WMI_REG_VERY_LOW_POWER_AP][i] =
246 - ext_chan_list_event_hdr->min_bw_6ghz_client_vlp[i];
247 + ev->min_bw_6ghz_client_vlp[i];
248 reg_info->max_bw_6ghz_client[WMI_REG_VERY_LOW_POWER_AP][i] =
249 - ext_chan_list_event_hdr->max_bw_6ghz_client_vlp[i];
250 + ev->max_bw_6ghz_client_vlp[i];
251 +
252 + ath11k_dbg(ab, ATH11K_DBG_WMI,
253 + "6 GHz %s BW: LPI (%d - %d), SP (%d - %d), VLP (%d - %d)\n",
254 + ath11k_6ghz_client_type_to_str(i),
255 + reg_info->min_bw_6ghz_client[WMI_REG_INDOOR_AP][i],
256 + reg_info->max_bw_6ghz_client[WMI_REG_INDOOR_AP][i],
257 + reg_info->min_bw_6ghz_client[WMI_REG_STANDARD_POWER_AP][i],
258 + reg_info->max_bw_6ghz_client[WMI_REG_STANDARD_POWER_AP][i],
259 + reg_info->min_bw_6ghz_client[WMI_REG_VERY_LOW_POWER_AP][i],
260 + reg_info->max_bw_6ghz_client[WMI_REG_VERY_LOW_POWER_AP][i]);
261 }
262
263 ath11k_dbg(ab, ATH11K_DBG_WMI,
264 - "%s:cc_ext %s dsf %d BW: min_2ghz %d max_2ghz %d min_5ghz %d max_5ghz %d",
265 - __func__, reg_info->alpha2, reg_info->dfs_region,
266 + "cc_ext %s dsf %d BW: min_2ghz %d max_2ghz %d min_5ghz %d max_5ghz %d",
267 + reg_info->alpha2, reg_info->dfs_region,
268 reg_info->min_bw_2ghz, reg_info->max_bw_2ghz,
269 reg_info->min_bw_5ghz, reg_info->max_bw_5ghz);
270
271 @@ -5310,9 +5362,8 @@ static int ath11k_pull_reg_chan_list_ext
272 num_6ghz_client[WMI_REG_VERY_LOW_POWER_AP][j]);
273
274 ext_wmi_reg_rule =
275 - (struct wmi_regulatory_ext_rule *)((u8 *)ext_chan_list_event_hdr
276 - + sizeof(*ext_chan_list_event_hdr)
277 - + sizeof(struct wmi_tlv));
278 + (struct wmi_regulatory_ext_rule *)((u8 *)ev + sizeof(*ev) +
279 + sizeof(struct wmi_tlv));
280 if (num_2ghz_reg_rules) {
281 reg_info->reg_rules_2ghz_ptr =
282 create_ext_reg_rules_from_wmi(num_2ghz_reg_rules,
283 @@ -5323,6 +5374,10 @@ static int ath11k_pull_reg_chan_list_ext
284 ath11k_warn(ab, "Unable to Allocate memory for 2 GHz rules\n");
285 return -ENOMEM;
286 }
287 +
288 + ath11k_print_reg_rule(ab, "2 GHz",
289 + num_2ghz_reg_rules,
290 + reg_info->reg_rules_2ghz_ptr);
291 }
292
293 ext_wmi_reg_rule += num_2ghz_reg_rules;
294 @@ -5358,6 +5413,10 @@ static int ath11k_pull_reg_chan_list_ext
295 ath11k_warn(ab, "Unable to Allocate memory for 5 GHz rules\n");
296 return -ENOMEM;
297 }
298 +
299 + ath11k_print_reg_rule(ab, "5 GHz",
300 + num_5ghz_reg_rules,
301 + reg_info->reg_rules_5ghz_ptr);
302 }
303
304 /* We have adjusted the number of 5 GHz reg rules above. But still those
305 @@ -5378,10 +5437,17 @@ static int ath11k_pull_reg_chan_list_ext
306 return -ENOMEM;
307 }
308
309 + ath11k_print_reg_rule(ab, ath11k_6ghz_ap_type_to_str(i),
310 + num_6ghz_reg_rules_ap[i],
311 + reg_info->reg_rules_6ghz_ap_ptr[i]);
312 +
313 ext_wmi_reg_rule += num_6ghz_reg_rules_ap[i];
314 }
315
316 for (j = 0; j < WMI_REG_CURRENT_MAX_AP_TYPE; j++) {
317 + ath11k_dbg(ab, ATH11K_DBG_WMI,
318 + "6 GHz AP type %s", ath11k_6ghz_ap_type_to_str(j));
319 +
320 for (i = 0; i < WMI_REG_MAX_CLIENT_TYPE; i++) {
321 reg_info->reg_rules_6ghz_client_ptr[j][i] =
322 create_ext_reg_rules_from_wmi(num_6ghz_client[j][i],
323 @@ -5393,35 +5459,58 @@ static int ath11k_pull_reg_chan_list_ext
324 return -ENOMEM;
325 }
326
327 + ath11k_print_reg_rule(ab,
328 + ath11k_6ghz_client_type_to_str(i),
329 + num_6ghz_client[j][i],
330 + reg_info->reg_rules_6ghz_client_ptr[j][i]);
331 +
332 ext_wmi_reg_rule += num_6ghz_client[j][i];
333 }
334 }
335
336 - reg_info->client_type = ext_chan_list_event_hdr->client_type;
337 - reg_info->rnr_tpe_usable = ext_chan_list_event_hdr->rnr_tpe_usable;
338 + reg_info->client_type = ev->client_type;
339 + reg_info->rnr_tpe_usable = ev->rnr_tpe_usable;
340 reg_info->unspecified_ap_usable =
341 - ext_chan_list_event_hdr->unspecified_ap_usable;
342 + ev->unspecified_ap_usable;
343 reg_info->domain_code_6ghz_ap[WMI_REG_INDOOR_AP] =
344 - ext_chan_list_event_hdr->domain_code_6ghz_ap_lpi;
345 + ev->domain_code_6ghz_ap_lpi;
346 reg_info->domain_code_6ghz_ap[WMI_REG_STANDARD_POWER_AP] =
347 - ext_chan_list_event_hdr->domain_code_6ghz_ap_sp;
348 + ev->domain_code_6ghz_ap_sp;
349 reg_info->domain_code_6ghz_ap[WMI_REG_VERY_LOW_POWER_AP] =
350 - ext_chan_list_event_hdr->domain_code_6ghz_ap_vlp;
351 + ev->domain_code_6ghz_ap_vlp;
352 +
353 + ath11k_dbg(ab, ATH11K_DBG_WMI,
354 + "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",
355 + ath11k_6ghz_client_type_to_str(reg_info->client_type),
356 + reg_info->rnr_tpe_usable,
357 + reg_info->unspecified_ap_usable,
358 + ath11k_sub_reg_6ghz_to_str(ev->domain_code_6ghz_ap_lpi),
359 + ath11k_sub_reg_6ghz_to_str(ev->domain_code_6ghz_ap_sp),
360 + ath11k_sub_reg_6ghz_to_str(ev->domain_code_6ghz_ap_vlp));
361
362 for (i = 0; i < WMI_REG_MAX_CLIENT_TYPE; i++) {
363 reg_info->domain_code_6ghz_client[WMI_REG_INDOOR_AP][i] =
364 - ext_chan_list_event_hdr->domain_code_6ghz_client_lpi[i];
365 + ev->domain_code_6ghz_client_lpi[i];
366 reg_info->domain_code_6ghz_client[WMI_REG_STANDARD_POWER_AP][i] =
367 - ext_chan_list_event_hdr->domain_code_6ghz_client_sp[i];
368 + ev->domain_code_6ghz_client_sp[i];
369 reg_info->domain_code_6ghz_client[WMI_REG_VERY_LOW_POWER_AP][i] =
370 - ext_chan_list_event_hdr->domain_code_6ghz_client_vlp[i];
371 + ev->domain_code_6ghz_client_vlp[i];
372 +
373 + ath11k_dbg(ab, ATH11K_DBG_WMI,
374 + "6 GHz client type %s client sub domain: lpi %s, sp %s, vlp %s\n",
375 + ath11k_6ghz_client_type_to_str(i),
376 + ath11k_sub_reg_6ghz_to_str(ev->domain_code_6ghz_client_lpi[i]),
377 + ath11k_sub_reg_6ghz_to_str(ev->domain_code_6ghz_client_sp[i]),
378 + ath11k_sub_reg_6ghz_to_str(ev->domain_code_6ghz_client_vlp[i])
379 + );
380 }
381
382 - reg_info->domain_code_6ghz_super_id =
383 - ext_chan_list_event_hdr->domain_code_6ghz_super_id;
384 + reg_info->domain_code_6ghz_super_id = ev->domain_code_6ghz_super_id;
385
386 - ath11k_dbg(ab, ATH11K_DBG_WMI, "6 GHz client_type: %d domain_code_6ghz_super_id: %d",
387 - reg_info->client_type, reg_info->domain_code_6ghz_super_id);
388 + ath11k_dbg(ab, ATH11K_DBG_WMI,
389 + "6 GHz client_type %s 6 GHz super domain %s",
390 + ath11k_6ghz_client_type_to_str(reg_info->client_type),
391 + ath11k_super_reg_6ghz_to_str(reg_info->domain_code_6ghz_super_id));
392
393 ath11k_dbg(ab, ATH11K_DBG_WMI, "processed regulatory ext channel list\n");
394
395 --- a/drivers/net/wireless/ath/ath11k/wmi.h
396 +++ b/drivers/net/wireless/ath/ath11k/wmi.h
397 @@ -4139,6 +4139,7 @@ enum cc_setting_code {
398
399 /* add new setting code above, update in
400 * @enum wmi_reg_cc_setting_code as well.
401 + * Also handle it in ath11k_cc_status_to_str()
402 */
403 };
404
405 @@ -4163,21 +4164,162 @@ ath11k_wmi_cc_setting_code_to_reg(enum w
406 return REG_SET_CC_STATUS_FAIL;
407 }
408
409 +static inline const char *ath11k_cc_status_to_str(enum cc_setting_code code)
410 +{
411 + switch (code) {
412 + case REG_SET_CC_STATUS_PASS:
413 + return "REG_SET_CC_STATUS_PASS";
414 + case REG_CURRENT_ALPHA2_NOT_FOUND:
415 + return "REG_CURRENT_ALPHA2_NOT_FOUND";
416 + case REG_INIT_ALPHA2_NOT_FOUND:
417 + return "REG_INIT_ALPHA2_NOT_FOUND";
418 + case REG_SET_CC_CHANGE_NOT_ALLOWED:
419 + return "REG_SET_CC_CHANGE_NOT_ALLOWED";
420 + case REG_SET_CC_STATUS_NO_MEMORY:
421 + return "REG_SET_CC_STATUS_NO_MEMORY";
422 + case REG_SET_CC_STATUS_FAIL:
423 + return "REG_SET_CC_STATUS_FAIL";
424 + }
425 +
426 + return "Unknown CC status";
427 +}
428 +
429 enum wmi_reg_6ghz_ap_type {
430 WMI_REG_INDOOR_AP = 0,
431 WMI_REG_STANDARD_POWER_AP = 1,
432 WMI_REG_VERY_LOW_POWER_AP = 2,
433
434 + /* add AP type above, handle in ath11k_6ghz_ap_type_to_str()
435 + */
436 WMI_REG_CURRENT_MAX_AP_TYPE,
437 WMI_REG_MAX_AP_TYPE = 7,
438 };
439
440 +static inline const char *
441 +ath11k_6ghz_ap_type_to_str(enum wmi_reg_6ghz_ap_type type)
442 +{
443 + switch (type) {
444 + case WMI_REG_INDOOR_AP:
445 + return "INDOOR AP";
446 + case WMI_REG_STANDARD_POWER_AP:
447 + return "STANDARD POWER AP";
448 + case WMI_REG_VERY_LOW_POWER_AP:
449 + return "VERY LOW POWER AP";
450 + case WMI_REG_CURRENT_MAX_AP_TYPE:
451 + return "CURRENT_MAX_AP_TYPE";
452 + case WMI_REG_MAX_AP_TYPE:
453 + return "MAX_AP_TYPE";
454 + }
455 +
456 + return "unknown 6 GHz AP type";
457 +}
458 +
459 enum wmi_reg_6ghz_client_type {
460 WMI_REG_DEFAULT_CLIENT = 0,
461 WMI_REG_SUBORDINATE_CLIENT = 1,
462 WMI_REG_MAX_CLIENT_TYPE = 2,
463 +
464 + /* add client type above, handle it in
465 + * ath11k_6ghz_client_type_to_str()
466 + */
467 +};
468 +
469 +static inline const char *
470 +ath11k_6ghz_client_type_to_str(enum wmi_reg_6ghz_client_type type)
471 +{
472 + switch (type) {
473 + case WMI_REG_DEFAULT_CLIENT:
474 + return "DEFAULT CLIENT";
475 + case WMI_REG_SUBORDINATE_CLIENT:
476 + return "SUBORDINATE CLIENT";
477 + case WMI_REG_MAX_CLIENT_TYPE:
478 + return "MAX_CLIENT_TYPE";
479 + }
480 +
481 + return "unknown 6 GHz client type";
482 +}
483 +
484 +enum reg_subdomains_6ghz {
485 + EMPTY_6GHZ = 0x0,
486 + FCC1_CLIENT_LPI_REGULAR_6GHZ = 0x01,
487 + FCC1_CLIENT_SP_6GHZ = 0x02,
488 + FCC1_AP_LPI_6GHZ = 0x03,
489 + FCC1_CLIENT_LPI_SUBORDINATE = FCC1_AP_LPI_6GHZ,
490 + FCC1_AP_SP_6GHZ = 0x04,
491 + ETSI1_LPI_6GHZ = 0x10,
492 + ETSI1_VLP_6GHZ = 0x11,
493 + ETSI2_LPI_6GHZ = 0x12,
494 + ETSI2_VLP_6GHZ = 0x13,
495 + APL1_LPI_6GHZ = 0x20,
496 + APL1_VLP_6GHZ = 0x21,
497 +
498 + /* add sub-domain above, handle it in
499 + * ath11k_sub_reg_6ghz_to_str()
500 + */
501 +};
502 +
503 +static inline const char *
504 +ath11k_sub_reg_6ghz_to_str(enum reg_subdomains_6ghz sub_id)
505 +{
506 + switch (sub_id) {
507 + case EMPTY_6GHZ:
508 + return "N/A";
509 + case FCC1_CLIENT_LPI_REGULAR_6GHZ:
510 + return "FCC1_CLIENT_LPI_REGULAR_6GHZ";
511 + case FCC1_CLIENT_SP_6GHZ:
512 + return "FCC1_CLIENT_SP_6GHZ";
513 + case FCC1_AP_LPI_6GHZ:
514 + return "FCC1_AP_LPI_6GHZ/FCC1_CLIENT_LPI_SUBORDINATE";
515 + case FCC1_AP_SP_6GHZ:
516 + return "FCC1_AP_SP_6GHZ";
517 + case ETSI1_LPI_6GHZ:
518 + return "ETSI1_LPI_6GHZ";
519 + case ETSI1_VLP_6GHZ:
520 + return "ETSI1_VLP_6GHZ";
521 + case ETSI2_LPI_6GHZ:
522 + return "ETSI2_LPI_6GHZ";
523 + case ETSI2_VLP_6GHZ:
524 + return "ETSI2_VLP_6GHZ";
525 + case APL1_LPI_6GHZ:
526 + return "APL1_LPI_6GHZ";
527 + case APL1_VLP_6GHZ:
528 + return "APL1_VLP_6GHZ";
529 + }
530 +
531 + return "unknown sub reg id";
532 +}
533 +
534 +enum reg_super_domain_6ghz {
535 + FCC1_6GHZ = 0x01,
536 + ETSI1_6GHZ = 0x02,
537 + ETSI2_6GHZ = 0x03,
538 + APL1_6GHZ = 0x04,
539 + FCC1_6GHZ_CL = 0x05,
540 +
541 + /* add super domain above, handle it in
542 + * ath11k_super_reg_6ghz_to_str()
543 + */
544 };
545
546 +static inline const char *
547 +ath11k_super_reg_6ghz_to_str(enum reg_super_domain_6ghz domain_id)
548 +{
549 + switch (domain_id) {
550 + case FCC1_6GHZ:
551 + return "FCC1_6GHZ";
552 + case ETSI1_6GHZ:
553 + return "ETSI1_6GHZ";
554 + case ETSI2_6GHZ:
555 + return "ETSI2_6GHZ";
556 + case APL1_6GHZ:
557 + return "APL1_6GHZ";
558 + case FCC1_6GHZ_CL:
559 + return "FCC1_6GHZ_CL";
560 + }
561 +
562 + return "unknown domain id";
563 +}
564 +
565 struct cur_reg_rule {
566 u16 start_freq;
567 u16 end_freq;
John Crispins staging tree