1 /*
2 * Driver interaction with Linux nl80211/cfg80211 - Capabilities
3 * Copyright (c) 2002-2015, Jouni Malinen <j@w1.fi>
4 * Copyright (c) 2007, Johannes Berg <johannes@sipsolutions.net>
5 * Copyright (c) 2009-2010, Atheros Communications
6 *
7 * This software may be distributed under the terms of the BSD license.
8 * See README for more details.
9 */
10
11 #include "includes.h"
12 #include <netlink/genl/genl.h>
13
14 #include "utils/common.h"
15 #include "common/ieee802_11_common.h"
16 #include "common/wpa_common.h"
17 #include "common/qca-vendor.h"
18 #include "common/qca-vendor-attr.h"
19 #include "common/brcm_vendor.h"
20 #include "driver_nl80211.h"
21
protocol_feature_handler(struct nl_msg * msg,void * arg)22 static int protocol_feature_handler(struct nl_msg *msg, void *arg)
23 {
24 u32 *feat = arg;
25 struct nlattr *tb_msg[NL80211_ATTR_MAX + 1];
26 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
27
28 nla_parse(tb_msg, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
29 genlmsg_attrlen(gnlh, 0), NULL);
30
31 if (tb_msg[NL80211_ATTR_PROTOCOL_FEATURES])
32 *feat = nla_get_u32(tb_msg[NL80211_ATTR_PROTOCOL_FEATURES]);
33
34 return NL_SKIP;
35 }
36
37
get_nl80211_protocol_features(struct wpa_driver_nl80211_data * drv)38 u32 get_nl80211_protocol_features(struct wpa_driver_nl80211_data *drv)
39 {
40 u32 feat = 0;
41 struct nl_msg *msg;
42
43 msg = nlmsg_alloc();
44 if (!msg)
45 return 0;
46
47 if (!nl80211_cmd(drv, msg, 0, NL80211_CMD_GET_PROTOCOL_FEATURES)) {
48 nlmsg_free(msg);
49 return 0;
50 }
51
52 if (send_and_recv_resp(drv, msg, protocol_feature_handler, &feat) == 0)
53 return feat;
54
55 return 0;
56 }
57
58
59 struct wiphy_info_data {
60 struct wpa_driver_nl80211_data *drv;
61 struct wpa_driver_capa *capa;
62
63 unsigned int num_multichan_concurrent;
64
65 unsigned int error:1;
66 unsigned int device_ap_sme:1;
67 unsigned int poll_command_supported:1;
68 unsigned int data_tx_status:1;
69 unsigned int auth_supported:1;
70 unsigned int connect_supported:1;
71 unsigned int p2p_go_supported:1;
72 unsigned int p2p_client_supported:1;
73 unsigned int p2p_go_ctwindow_supported:1;
74 unsigned int p2p_concurrent:1;
75 unsigned int channel_switch_supported:1;
76 unsigned int set_qos_map_supported:1;
77 unsigned int have_low_prio_scan:1;
78 unsigned int wmm_ac_supported:1;
79 unsigned int mac_addr_rand_scan_supported:1;
80 unsigned int mac_addr_rand_sched_scan_supported:1;
81 unsigned int update_ft_ies_supported:1;
82 unsigned int has_key_mgmt:1;
83 unsigned int has_key_mgmt_iftype:1;
84 };
85
86
probe_resp_offload_support(int supp_protocols)87 static unsigned int probe_resp_offload_support(int supp_protocols)
88 {
89 unsigned int prot = 0;
90
91 if (supp_protocols & NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS)
92 prot |= WPA_DRIVER_PROBE_RESP_OFFLOAD_WPS;
93 if (supp_protocols & NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2)
94 prot |= WPA_DRIVER_PROBE_RESP_OFFLOAD_WPS2;
95 if (supp_protocols & NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P)
96 prot |= WPA_DRIVER_PROBE_RESP_OFFLOAD_P2P;
97 if (supp_protocols & NL80211_PROBE_RESP_OFFLOAD_SUPPORT_80211U)
98 prot |= WPA_DRIVER_PROBE_RESP_OFFLOAD_INTERWORKING;
99
100 return prot;
101 }
102
103
wiphy_info_supported_iftypes(struct wiphy_info_data * info,struct nlattr * tb)104 static void wiphy_info_supported_iftypes(struct wiphy_info_data *info,
105 struct nlattr *tb)
106 {
107 struct nlattr *nl_mode;
108 int i;
109
110 if (tb == NULL)
111 return;
112
113 nla_for_each_nested(nl_mode, tb, i) {
114 switch (nla_type(nl_mode)) {
115 case NL80211_IFTYPE_AP:
116 info->capa->flags |= WPA_DRIVER_FLAGS_AP;
117 break;
118 case NL80211_IFTYPE_MESH_POINT:
119 info->capa->flags |= WPA_DRIVER_FLAGS_MESH;
120 break;
121 case NL80211_IFTYPE_ADHOC:
122 info->capa->flags |= WPA_DRIVER_FLAGS_IBSS;
123 break;
124 case NL80211_IFTYPE_P2P_DEVICE:
125 info->capa->flags |=
126 WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE;
127 break;
128 case NL80211_IFTYPE_P2P_GO:
129 info->p2p_go_supported = 1;
130 break;
131 case NL80211_IFTYPE_P2P_CLIENT:
132 info->p2p_client_supported = 1;
133 break;
134 }
135 }
136 }
137
138
wiphy_info_iface_comb_process(struct wiphy_info_data * info,struct nlattr * nl_combi)139 static int wiphy_info_iface_comb_process(struct wiphy_info_data *info,
140 struct nlattr *nl_combi)
141 {
142 struct nlattr *tb_comb[NUM_NL80211_IFACE_COMB];
143 struct nlattr *tb_limit[NUM_NL80211_IFACE_LIMIT];
144 struct nlattr *nl_limit, *nl_mode;
145 int err, rem_limit, rem_mode;
146 int combination_has_p2p = 0, combination_has_mgd = 0;
147 static struct nla_policy
148 iface_combination_policy[NUM_NL80211_IFACE_COMB] = {
149 [NL80211_IFACE_COMB_LIMITS] = { .type = NLA_NESTED },
150 [NL80211_IFACE_COMB_MAXNUM] = { .type = NLA_U32 },
151 [NL80211_IFACE_COMB_STA_AP_BI_MATCH] = { .type = NLA_FLAG },
152 [NL80211_IFACE_COMB_NUM_CHANNELS] = { .type = NLA_U32 },
153 [NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS] = { .type = NLA_U32 },
154 },
155 iface_limit_policy[NUM_NL80211_IFACE_LIMIT] = {
156 [NL80211_IFACE_LIMIT_TYPES] = { .type = NLA_NESTED },
157 [NL80211_IFACE_LIMIT_MAX] = { .type = NLA_U32 },
158 };
159
160 err = nla_parse_nested(tb_comb, MAX_NL80211_IFACE_COMB,
161 nl_combi, iface_combination_policy);
162 if (err || !tb_comb[NL80211_IFACE_COMB_LIMITS] ||
163 !tb_comb[NL80211_IFACE_COMB_MAXNUM] ||
164 !tb_comb[NL80211_IFACE_COMB_NUM_CHANNELS])
165 return 0; /* broken combination */
166
167 if (tb_comb[NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS])
168 info->capa->flags |= WPA_DRIVER_FLAGS_RADAR;
169
170 nla_for_each_nested(nl_limit, tb_comb[NL80211_IFACE_COMB_LIMITS],
171 rem_limit) {
172 err = nla_parse_nested(tb_limit, MAX_NL80211_IFACE_LIMIT,
173 nl_limit, iface_limit_policy);
174 if (err || !tb_limit[NL80211_IFACE_LIMIT_TYPES])
175 return 0; /* broken combination */
176
177 nla_for_each_nested(nl_mode,
178 tb_limit[NL80211_IFACE_LIMIT_TYPES],
179 rem_mode) {
180 int ift = nla_type(nl_mode);
181 if (ift == NL80211_IFTYPE_P2P_GO ||
182 ift == NL80211_IFTYPE_P2P_CLIENT)
183 combination_has_p2p = 1;
184 if (ift == NL80211_IFTYPE_STATION)
185 combination_has_mgd = 1;
186 }
187 if (combination_has_p2p && combination_has_mgd)
188 break;
189 }
190
191 if (combination_has_p2p && combination_has_mgd) {
192 unsigned int num_channels =
193 nla_get_u32(tb_comb[NL80211_IFACE_COMB_NUM_CHANNELS]);
194
195 info->p2p_concurrent = 1;
196 if (info->num_multichan_concurrent < num_channels)
197 info->num_multichan_concurrent = num_channels;
198 }
199
200 return 0;
201 }
202
203
wiphy_info_iface_comb(struct wiphy_info_data * info,struct nlattr * tb)204 static void wiphy_info_iface_comb(struct wiphy_info_data *info,
205 struct nlattr *tb)
206 {
207 struct nlattr *nl_combi;
208 int rem_combi;
209
210 if (tb == NULL)
211 return;
212
213 nla_for_each_nested(nl_combi, tb, rem_combi) {
214 if (wiphy_info_iface_comb_process(info, nl_combi) > 0)
215 break;
216 }
217 }
218
219
wiphy_info_supp_cmds(struct wiphy_info_data * info,struct nlattr * tb)220 static void wiphy_info_supp_cmds(struct wiphy_info_data *info,
221 struct nlattr *tb)
222 {
223 struct nlattr *nl_cmd;
224 int i;
225
226 if (tb == NULL)
227 return;
228
229 nla_for_each_nested(nl_cmd, tb, i) {
230 switch (nla_get_u32(nl_cmd)) {
231 case NL80211_CMD_AUTHENTICATE:
232 info->auth_supported = 1;
233 break;
234 case NL80211_CMD_CONNECT:
235 info->connect_supported = 1;
236 break;
237 case NL80211_CMD_START_SCHED_SCAN:
238 info->capa->sched_scan_supported = 1;
239 break;
240 case NL80211_CMD_PROBE_CLIENT:
241 info->poll_command_supported = 1;
242 break;
243 case NL80211_CMD_CHANNEL_SWITCH:
244 info->channel_switch_supported = 1;
245 break;
246 case NL80211_CMD_SET_QOS_MAP:
247 info->set_qos_map_supported = 1;
248 break;
249 case NL80211_CMD_UPDATE_FT_IES:
250 info->update_ft_ies_supported = 1;
251 break;
252 }
253 }
254 }
255
256
get_akm_suites_info(struct nlattr * tb)257 static unsigned int get_akm_suites_info(struct nlattr *tb)
258 {
259 int i, num;
260 unsigned int key_mgmt = 0;
261 u32 *akms;
262
263 if (!tb)
264 return 0;
265
266 num = nla_len(tb) / sizeof(u32);
267 akms = nla_data(tb);
268 for (i = 0; i < num; i++) {
269 switch (akms[i]) {
270 case RSN_AUTH_KEY_MGMT_UNSPEC_802_1X:
271 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_WPA |
272 WPA_DRIVER_CAPA_KEY_MGMT_WPA2;
273 break;
274 case RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X:
275 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK |
276 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK;
277 break;
278 case RSN_AUTH_KEY_MGMT_FT_802_1X:
279 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_FT;
280 break;
281 case RSN_AUTH_KEY_MGMT_FT_PSK:
282 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_FT_PSK;
283 break;
284 case RSN_AUTH_KEY_MGMT_802_1X_SHA256:
285 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_802_1X_SHA256;
286 break;
287 case RSN_AUTH_KEY_MGMT_PSK_SHA256:
288 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_PSK_SHA256;
289 break;
290 case RSN_AUTH_KEY_MGMT_TPK_HANDSHAKE:
291 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_TPK_HANDSHAKE;
292 break;
293 case RSN_AUTH_KEY_MGMT_FT_SAE:
294 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_FT_SAE;
295 break;
296 case RSN_AUTH_KEY_MGMT_FT_SAE_EXT_KEY:
297 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_FT_SAE_EXT_KEY;
298 break;
299 case RSN_AUTH_KEY_MGMT_FT_802_1X_SHA384:
300 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_FT_802_1X_SHA384;
301 break;
302 case RSN_AUTH_KEY_MGMT_CCKM:
303 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_CCKM;
304 break;
305 case RSN_AUTH_KEY_MGMT_802_1X_SUITE_B:
306 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_SUITE_B;
307 break;
308 case RSN_AUTH_KEY_MGMT_802_1X_SUITE_B_192:
309 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_SUITE_B_192;
310 break;
311 case RSN_AUTH_KEY_MGMT_OWE:
312 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_OWE;
313 break;
314 case RSN_AUTH_KEY_MGMT_DPP:
315 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_DPP;
316 break;
317 case RSN_AUTH_KEY_MGMT_FILS_SHA256:
318 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_FILS_SHA256;
319 break;
320 case RSN_AUTH_KEY_MGMT_FILS_SHA384:
321 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_FILS_SHA384;
322 break;
323 case RSN_AUTH_KEY_MGMT_FT_FILS_SHA256:
324 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_FT_FILS_SHA256;
325 break;
326 case RSN_AUTH_KEY_MGMT_FT_FILS_SHA384:
327 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_FT_FILS_SHA384;
328 break;
329 case RSN_AUTH_KEY_MGMT_SAE:
330 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_SAE;
331 break;
332 case RSN_AUTH_KEY_MGMT_SAE_EXT_KEY:
333 key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_SAE_EXT_KEY;
334 break;
335 }
336 }
337
338 return key_mgmt;
339 }
340
341
get_iface_akm_suites_info(struct wiphy_info_data * info,struct nlattr * nl_akms)342 static void get_iface_akm_suites_info(struct wiphy_info_data *info,
343 struct nlattr *nl_akms)
344 {
345 struct nlattr *tb[NL80211_IFTYPE_AKM_ATTR_MAX + 1];
346 struct nlattr *nl_iftype;
347 unsigned int key_mgmt;
348 int i;
349
350 if (!nl_akms)
351 return;
352
353 nla_parse(tb, NL80211_IFTYPE_AKM_ATTR_MAX,
354 nla_data(nl_akms), nla_len(nl_akms), NULL);
355
356 if (!tb[NL80211_IFTYPE_AKM_ATTR_IFTYPES] ||
357 !tb[NL80211_IFTYPE_AKM_ATTR_SUITES])
358 return;
359
360 info->has_key_mgmt_iftype = 1;
361 key_mgmt = get_akm_suites_info(tb[NL80211_IFTYPE_AKM_ATTR_SUITES]);
362
363 nla_for_each_nested(nl_iftype, tb[NL80211_IFTYPE_AKM_ATTR_IFTYPES], i) {
364 switch (nla_type(nl_iftype)) {
365 case NL80211_IFTYPE_ADHOC:
366 info->drv->capa.key_mgmt_iftype[WPA_IF_IBSS] = key_mgmt;
367 break;
368 case NL80211_IFTYPE_STATION:
369 info->drv->capa.key_mgmt_iftype[WPA_IF_STATION] =
370 key_mgmt;
371 break;
372 case NL80211_IFTYPE_AP:
373 info->drv->capa.key_mgmt_iftype[WPA_IF_AP_BSS] =
374 key_mgmt;
375 break;
376 case NL80211_IFTYPE_AP_VLAN:
377 info->drv->capa.key_mgmt_iftype[WPA_IF_AP_VLAN] =
378 key_mgmt;
379 break;
380 case NL80211_IFTYPE_MESH_POINT:
381 info->drv->capa.key_mgmt_iftype[WPA_IF_MESH] = key_mgmt;
382 break;
383 case NL80211_IFTYPE_P2P_CLIENT:
384 info->drv->capa.key_mgmt_iftype[WPA_IF_P2P_CLIENT] =
385 key_mgmt;
386 break;
387 case NL80211_IFTYPE_P2P_GO:
388 info->drv->capa.key_mgmt_iftype[WPA_IF_P2P_GO] =
389 key_mgmt;
390 break;
391 case NL80211_IFTYPE_P2P_DEVICE:
392 info->drv->capa.key_mgmt_iftype[WPA_IF_P2P_DEVICE] =
393 key_mgmt;
394 break;
395 case NL80211_IFTYPE_NAN:
396 info->drv->capa.key_mgmt_iftype[WPA_IF_NAN] = key_mgmt;
397 break;
398 }
399 wpa_printf(MSG_DEBUG, "nl80211: %s supported key_mgmt 0x%x",
400 nl80211_iftype_str(nla_type(nl_iftype)),
401 key_mgmt);
402 }
403 }
404
405
wiphy_info_iftype_akm_suites(struct wiphy_info_data * info,struct nlattr * tb)406 static void wiphy_info_iftype_akm_suites(struct wiphy_info_data *info,
407 struct nlattr *tb)
408 {
409 struct nlattr *nl_if;
410 int rem_if;
411
412 if (!tb)
413 return;
414
415 nla_for_each_nested(nl_if, tb, rem_if)
416 get_iface_akm_suites_info(info, nl_if);
417 }
418
419
wiphy_info_akm_suites(struct wiphy_info_data * info,struct nlattr * tb)420 static void wiphy_info_akm_suites(struct wiphy_info_data *info,
421 struct nlattr *tb)
422 {
423 if (!tb)
424 return;
425
426 info->has_key_mgmt = 1;
427 info->capa->key_mgmt = get_akm_suites_info(tb);
428 wpa_printf(MSG_DEBUG, "nl80211: wiphy supported key_mgmt 0x%x",
429 info->capa->key_mgmt);
430 }
431
432
wiphy_info_cipher_suites(struct wiphy_info_data * info,struct nlattr * tb)433 static void wiphy_info_cipher_suites(struct wiphy_info_data *info,
434 struct nlattr *tb)
435 {
436 int i, num;
437 u32 *ciphers;
438
439 if (tb == NULL)
440 return;
441
442 num = nla_len(tb) / sizeof(u32);
443 ciphers = nla_data(tb);
444 for (i = 0; i < num; i++) {
445 u32 c = ciphers[i];
446
447 wpa_printf(MSG_DEBUG, "nl80211: Supported cipher %02x-%02x-%02x:%d",
448 c >> 24, (c >> 16) & 0xff,
449 (c >> 8) & 0xff, c & 0xff);
450 switch (c) {
451 case RSN_CIPHER_SUITE_CCMP_256:
452 info->capa->enc |= WPA_DRIVER_CAPA_ENC_CCMP_256;
453 break;
454 case RSN_CIPHER_SUITE_GCMP_256:
455 info->capa->enc |= WPA_DRIVER_CAPA_ENC_GCMP_256;
456 break;
457 case RSN_CIPHER_SUITE_CCMP:
458 info->capa->enc |= WPA_DRIVER_CAPA_ENC_CCMP;
459 break;
460 case RSN_CIPHER_SUITE_GCMP:
461 info->capa->enc |= WPA_DRIVER_CAPA_ENC_GCMP;
462 break;
463 case RSN_CIPHER_SUITE_TKIP:
464 info->capa->enc |= WPA_DRIVER_CAPA_ENC_TKIP;
465 break;
466 case RSN_CIPHER_SUITE_WEP104:
467 info->capa->enc |= WPA_DRIVER_CAPA_ENC_WEP104;
468 break;
469 case RSN_CIPHER_SUITE_WEP40:
470 info->capa->enc |= WPA_DRIVER_CAPA_ENC_WEP40;
471 break;
472 case RSN_CIPHER_SUITE_AES_128_CMAC:
473 info->capa->enc |= WPA_DRIVER_CAPA_ENC_BIP;
474 break;
475 case RSN_CIPHER_SUITE_BIP_GMAC_128:
476 info->capa->enc |= WPA_DRIVER_CAPA_ENC_BIP_GMAC_128;
477 break;
478 case RSN_CIPHER_SUITE_BIP_GMAC_256:
479 info->capa->enc |= WPA_DRIVER_CAPA_ENC_BIP_GMAC_256;
480 break;
481 case RSN_CIPHER_SUITE_BIP_CMAC_256:
482 info->capa->enc |= WPA_DRIVER_CAPA_ENC_BIP_CMAC_256;
483 break;
484 case RSN_CIPHER_SUITE_NO_GROUP_ADDRESSED:
485 info->capa->enc |= WPA_DRIVER_CAPA_ENC_GTK_NOT_USED;
486 break;
487 }
488 }
489 }
490
491
wiphy_info_max_roc(struct wpa_driver_capa * capa,struct nlattr * tb)492 static void wiphy_info_max_roc(struct wpa_driver_capa *capa,
493 struct nlattr *tb)
494 {
495 if (tb)
496 capa->max_remain_on_chan = nla_get_u32(tb);
497 }
498
499
wiphy_info_tdls(struct wpa_driver_capa * capa,struct nlattr * tdls,struct nlattr * ext_setup)500 static void wiphy_info_tdls(struct wpa_driver_capa *capa, struct nlattr *tdls,
501 struct nlattr *ext_setup)
502 {
503 if (tdls == NULL)
504 return;
505
506 wpa_printf(MSG_DEBUG, "nl80211: TDLS supported");
507 capa->flags |= WPA_DRIVER_FLAGS_TDLS_SUPPORT;
508
509 if (ext_setup) {
510 wpa_printf(MSG_DEBUG, "nl80211: TDLS external setup");
511 capa->flags |= WPA_DRIVER_FLAGS_TDLS_EXTERNAL_SETUP;
512 }
513 }
514
515
ext_feature_isset(const u8 * ext_features,int ext_features_len,enum nl80211_ext_feature_index ftidx)516 static int ext_feature_isset(const u8 *ext_features, int ext_features_len,
517 enum nl80211_ext_feature_index ftidx)
518 {
519 u8 ft_byte;
520
521 if ((int) ftidx / 8 >= ext_features_len)
522 return 0;
523
524 ft_byte = ext_features[ftidx / 8];
525 return (ft_byte & BIT(ftidx % 8)) != 0;
526 }
527
528
wiphy_info_ext_feature_flags(struct wiphy_info_data * info,struct nlattr * tb)529 static void wiphy_info_ext_feature_flags(struct wiphy_info_data *info,
530 struct nlattr *tb)
531 {
532 struct wpa_driver_capa *capa = info->capa;
533 u8 *ext_features;
534 int len;
535
536 if (tb == NULL)
537 return;
538
539 ext_features = nla_data(tb);
540 len = nla_len(tb);
541
542 if (ext_feature_isset(ext_features, len, NL80211_EXT_FEATURE_VHT_IBSS))
543 capa->flags |= WPA_DRIVER_FLAGS_VHT_IBSS;
544
545 if (ext_feature_isset(ext_features, len, NL80211_EXT_FEATURE_RRM))
546 capa->rrm_flags |= WPA_DRIVER_FLAGS_SUPPORT_RRM;
547
548 if (ext_feature_isset(ext_features, len, NL80211_EXT_FEATURE_FILS_STA))
549 capa->flags |= WPA_DRIVER_FLAGS_SUPPORT_FILS;
550
551 if (ext_feature_isset(ext_features, len,
552 NL80211_EXT_FEATURE_BEACON_RATE_LEGACY))
553 capa->flags |= WPA_DRIVER_FLAGS_BEACON_RATE_LEGACY;
554
555 if (ext_feature_isset(ext_features, len,
556 NL80211_EXT_FEATURE_BEACON_RATE_HT))
557 capa->flags |= WPA_DRIVER_FLAGS_BEACON_RATE_HT;
558
559 if (ext_feature_isset(ext_features, len,
560 NL80211_EXT_FEATURE_BEACON_RATE_VHT))
561 capa->flags |= WPA_DRIVER_FLAGS_BEACON_RATE_VHT;
562
563 if (ext_feature_isset(ext_features, len,
564 NL80211_EXT_FEATURE_BEACON_RATE_HE))
565 capa->flags2 |= WPA_DRIVER_FLAGS2_BEACON_RATE_HE;
566
567 if (ext_feature_isset(ext_features, len,
568 NL80211_EXT_FEATURE_SET_SCAN_DWELL))
569 capa->rrm_flags |= WPA_DRIVER_FLAGS_SUPPORT_SET_SCAN_DWELL;
570
571 if (ext_feature_isset(ext_features, len,
572 NL80211_EXT_FEATURE_SCAN_START_TIME) &&
573 ext_feature_isset(ext_features, len,
574 NL80211_EXT_FEATURE_BSS_PARENT_TSF) &&
575 ext_feature_isset(ext_features, len,
576 NL80211_EXT_FEATURE_SET_SCAN_DWELL))
577 capa->rrm_flags |= WPA_DRIVER_FLAGS_SUPPORT_BEACON_REPORT;
578 if (ext_feature_isset(ext_features, len,
579 NL80211_EXT_FEATURE_MGMT_TX_RANDOM_TA))
580 capa->flags |= WPA_DRIVER_FLAGS_MGMT_TX_RANDOM_TA;
581 if (ext_feature_isset(ext_features, len,
582 NL80211_EXT_FEATURE_MGMT_TX_RANDOM_TA_CONNECTED))
583 capa->flags |= WPA_DRIVER_FLAGS_MGMT_TX_RANDOM_TA_CONNECTED;
584 if (ext_feature_isset(ext_features, len,
585 NL80211_EXT_FEATURE_SCHED_SCAN_RELATIVE_RSSI))
586 capa->flags |= WPA_DRIVER_FLAGS_SCHED_SCAN_RELATIVE_RSSI;
587 if (ext_feature_isset(ext_features, len,
588 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD))
589 capa->flags |= WPA_DRIVER_FLAGS_FILS_SK_OFFLOAD;
590
591 if (ext_feature_isset(ext_features, len,
592 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_PSK))
593 capa->flags |= WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_PSK;
594 if (ext_feature_isset(ext_features, len,
595 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X))
596 capa->flags |= WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_8021X;
597
598 if (ext_feature_isset(ext_features, len,
599 NL80211_EXT_FEATURE_SAE_OFFLOAD))
600 capa->flags2 |= WPA_DRIVER_FLAGS2_SAE_OFFLOAD_STA;
601
602 if (ext_feature_isset(ext_features, len,
603 NL80211_EXT_FEATURE_MFP_OPTIONAL))
604 capa->flags |= WPA_DRIVER_FLAGS_MFP_OPTIONAL;
605
606 if (ext_feature_isset(ext_features, len,
607 NL80211_EXT_FEATURE_DFS_OFFLOAD))
608 capa->flags |= WPA_DRIVER_FLAGS_DFS_OFFLOAD;
609
610 #ifdef CONFIG_MBO
611 if (ext_feature_isset(ext_features, len,
612 NL80211_EXT_FEATURE_FILS_MAX_CHANNEL_TIME) &&
613 ext_feature_isset(ext_features, len,
614 NL80211_EXT_FEATURE_ACCEPT_BCAST_PROBE_RESP) &&
615 ext_feature_isset(ext_features, len,
616 NL80211_EXT_FEATURE_OCE_PROBE_REQ_HIGH_TX_RATE) &&
617 ext_feature_isset(
618 ext_features, len,
619 NL80211_EXT_FEATURE_OCE_PROBE_REQ_DEFERRAL_SUPPRESSION))
620 capa->flags |= WPA_DRIVER_FLAGS_OCE_STA;
621 #endif /* CONFIG_MBO */
622
623 if (ext_feature_isset(ext_features, len,
624 NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER))
625 capa->flags |= WPA_DRIVER_FLAGS_FTM_RESPONDER;
626
627 if (ext_feature_isset(ext_features, len,
628 NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211))
629 capa->flags |= WPA_DRIVER_FLAGS_CONTROL_PORT;
630 if (ext_feature_isset(ext_features, len,
631 NL80211_EXT_FEATURE_CONTROL_PORT_NO_PREAUTH))
632 capa->flags2 |= WPA_DRIVER_FLAGS2_CONTROL_PORT_RX;
633 if (ext_feature_isset(
634 ext_features, len,
635 NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211_TX_STATUS))
636 capa->flags2 |= WPA_DRIVER_FLAGS2_CONTROL_PORT_TX_STATUS;
637
638 if (ext_feature_isset(ext_features, len,
639 NL80211_EXT_FEATURE_VLAN_OFFLOAD))
640 capa->flags |= WPA_DRIVER_FLAGS_VLAN_OFFLOAD;
641
642 if (ext_feature_isset(ext_features, len,
643 NL80211_EXT_FEATURE_CAN_REPLACE_PTK0))
644 capa->flags |= WPA_DRIVER_FLAGS_SAFE_PTK0_REKEYS;
645
646 if (ext_feature_isset(ext_features, len,
647 NL80211_EXT_FEATURE_BEACON_PROTECTION))
648 capa->flags |= WPA_DRIVER_FLAGS_BEACON_PROTECTION;
649
650 if (ext_feature_isset(ext_features, len,
651 NL80211_EXT_FEATURE_EXT_KEY_ID))
652 capa->flags |= WPA_DRIVER_FLAGS_EXTENDED_KEY_ID;
653
654 if (ext_feature_isset(ext_features, len,
655 NL80211_EXT_FEATURE_MULTICAST_REGISTRATIONS))
656 info->drv->multicast_registrations = 1;
657
658 if (ext_feature_isset(ext_features, len,
659 NL80211_EXT_FEATURE_FILS_DISCOVERY))
660 info->drv->fils_discovery = 1;
661
662 if (ext_feature_isset(ext_features, len,
663 NL80211_EXT_FEATURE_UNSOL_BCAST_PROBE_RESP))
664 info->drv->unsol_bcast_probe_resp = 1;
665
666 if (ext_feature_isset(ext_features, len, NL80211_EXT_FEATURE_PUNCT))
667 info->drv->puncturing = 1;
668
669 if (ext_feature_isset(ext_features, len,
670 NL80211_EXT_FEATURE_BEACON_PROTECTION_CLIENT))
671 capa->flags2 |= WPA_DRIVER_FLAGS2_BEACON_PROTECTION_CLIENT;
672
673 if (ext_feature_isset(ext_features, len,
674 NL80211_EXT_FEATURE_OPERATING_CHANNEL_VALIDATION))
675 capa->flags2 |= WPA_DRIVER_FLAGS2_OCV;
676
677 if (ext_feature_isset(ext_features, len,
678 NL80211_EXT_FEATURE_RADAR_BACKGROUND))
679 capa->flags2 |= WPA_DRIVER_FLAGS2_RADAR_BACKGROUND;
680
681 if (ext_feature_isset(ext_features, len,
682 NL80211_EXT_FEATURE_SECURE_LTF)) {
683 capa->flags2 |= WPA_DRIVER_FLAGS2_SEC_LTF_STA;
684 capa->flags2 |= WPA_DRIVER_FLAGS2_SEC_LTF_AP;
685 }
686
687 if (ext_feature_isset(ext_features, len,
688 NL80211_EXT_FEATURE_SECURE_RTT)) {
689 capa->flags2 |= WPA_DRIVER_FLAGS2_SEC_RTT_STA;
690 capa->flags2 |= WPA_DRIVER_FLAGS2_SEC_RTT_AP;
691 }
692
693 if (ext_feature_isset(
694 ext_features, len,
695 NL80211_EXT_FEATURE_PROT_RANGE_NEGO_AND_MEASURE)) {
696 capa->flags2 |= WPA_DRIVER_FLAGS2_PROT_RANGE_NEG_STA;
697 capa->flags2 |= WPA_DRIVER_FLAGS2_PROT_RANGE_NEG_AP;
698 }
699
700 if (ext_feature_isset(ext_features, len,
701 NL80211_EXT_FEATURE_SCAN_MIN_PREQ_CONTENT))
702 capa->flags2 |= WPA_DRIVER_FLAGS2_SCAN_MIN_PREQ;
703
704 if (ext_feature_isset(ext_features, len,
705 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_AP_PSK))
706 capa->flags2 |= WPA_DRIVER_FLAGS2_4WAY_HANDSHAKE_AP_PSK;
707
708 if (ext_feature_isset(ext_features, len,
709 NL80211_EXT_FEATURE_OWE_OFFLOAD))
710 capa->flags2 |= WPA_DRIVER_FLAGS2_OWE_OFFLOAD_STA;
711
712 if (ext_feature_isset(ext_features, len,
713 NL80211_EXT_FEATURE_OWE_OFFLOAD_AP))
714 capa->flags2 |= WPA_DRIVER_FLAGS2_OWE_OFFLOAD_AP;
715
716 if (ext_feature_isset(ext_features, len,
717 NL80211_EXT_FEATURE_SAE_OFFLOAD_AP))
718 capa->flags2 |= WPA_DRIVER_FLAGS2_SAE_OFFLOAD_AP;
719
720 if (ext_feature_isset(ext_features, len,
721 NL80211_EXT_FEATURE_SPP_AMSDU_SUPPORT))
722 capa->flags2 |= WPA_DRIVER_FLAGS2_SPP_AMSDU;
723 }
724
725
wiphy_info_feature_flags(struct wiphy_info_data * info,struct nlattr * tb)726 static void wiphy_info_feature_flags(struct wiphy_info_data *info,
727 struct nlattr *tb)
728 {
729 u32 flags;
730 struct wpa_driver_capa *capa = info->capa;
731
732 if (tb == NULL)
733 return;
734
735 flags = nla_get_u32(tb);
736
737 if (flags & NL80211_FEATURE_SK_TX_STATUS)
738 info->data_tx_status = 1;
739
740 if (flags & NL80211_FEATURE_INACTIVITY_TIMER)
741 capa->flags |= WPA_DRIVER_FLAGS_INACTIVITY_TIMER;
742
743 if (flags & NL80211_FEATURE_SAE)
744 capa->flags |= WPA_DRIVER_FLAGS_SAE;
745
746 if (flags & NL80211_FEATURE_NEED_OBSS_SCAN)
747 capa->flags |= WPA_DRIVER_FLAGS_OBSS_SCAN;
748
749 if (flags & NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE)
750 capa->flags |= WPA_DRIVER_FLAGS_HT_2040_COEX;
751
752 if (flags & NL80211_FEATURE_TDLS_CHANNEL_SWITCH) {
753 wpa_printf(MSG_DEBUG, "nl80211: TDLS channel switch");
754 capa->flags |= WPA_DRIVER_FLAGS_TDLS_CHANNEL_SWITCH;
755 }
756
757 if (flags & NL80211_FEATURE_P2P_GO_CTWIN)
758 info->p2p_go_ctwindow_supported = 1;
759
760 if (flags & NL80211_FEATURE_LOW_PRIORITY_SCAN)
761 info->have_low_prio_scan = 1;
762
763 if (flags & NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR)
764 info->mac_addr_rand_scan_supported = 1;
765
766 if (flags & NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR)
767 info->mac_addr_rand_sched_scan_supported = 1;
768
769 if (flags & NL80211_FEATURE_SUPPORTS_WMM_ADMISSION)
770 info->wmm_ac_supported = 1;
771
772 if (flags & NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES)
773 capa->rrm_flags |= WPA_DRIVER_FLAGS_DS_PARAM_SET_IE_IN_PROBES;
774
775 if (flags & NL80211_FEATURE_WFA_TPC_IE_IN_PROBES)
776 capa->rrm_flags |= WPA_DRIVER_FLAGS_WFA_TPC_IE_IN_PROBES;
777
778 if (flags & NL80211_FEATURE_QUIET)
779 capa->rrm_flags |= WPA_DRIVER_FLAGS_QUIET;
780
781 if (flags & NL80211_FEATURE_TX_POWER_INSERTION)
782 capa->rrm_flags |= WPA_DRIVER_FLAGS_TX_POWER_INSERTION;
783
784 if (flags & NL80211_FEATURE_HT_IBSS)
785 capa->flags |= WPA_DRIVER_FLAGS_HT_IBSS;
786
787 if (flags & NL80211_FEATURE_FULL_AP_CLIENT_STATE)
788 capa->flags |= WPA_DRIVER_FLAGS_FULL_AP_CLIENT_STATE;
789 }
790
791
wiphy_info_probe_resp_offload(struct wpa_driver_capa * capa,struct nlattr * tb)792 static void wiphy_info_probe_resp_offload(struct wpa_driver_capa *capa,
793 struct nlattr *tb)
794 {
795 u32 protocols;
796
797 if (tb == NULL)
798 return;
799
800 protocols = nla_get_u32(tb);
801 wpa_printf(MSG_DEBUG, "nl80211: Supports Probe Response offload in AP "
802 "mode");
803 capa->flags |= WPA_DRIVER_FLAGS_PROBE_RESP_OFFLOAD;
804 capa->probe_resp_offloads = probe_resp_offload_support(protocols);
805 }
806
807
wiphy_info_wowlan_triggers(struct wpa_driver_capa * capa,struct nlattr * tb)808 static void wiphy_info_wowlan_triggers(struct wpa_driver_capa *capa,
809 struct nlattr *tb)
810 {
811 struct nlattr *triggers[MAX_NL80211_WOWLAN_TRIG + 1];
812
813 if (tb == NULL)
814 return;
815
816 if (nla_parse_nested(triggers, MAX_NL80211_WOWLAN_TRIG,
817 tb, NULL))
818 return;
819
820 if (triggers[NL80211_WOWLAN_TRIG_ANY])
821 capa->wowlan_triggers.any = 1;
822 if (triggers[NL80211_WOWLAN_TRIG_DISCONNECT])
823 capa->wowlan_triggers.disconnect = 1;
824 if (triggers[NL80211_WOWLAN_TRIG_MAGIC_PKT])
825 capa->wowlan_triggers.magic_pkt = 1;
826 if (triggers[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE])
827 capa->wowlan_triggers.gtk_rekey_failure = 1;
828 if (triggers[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST])
829 capa->wowlan_triggers.eap_identity_req = 1;
830 if (triggers[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE])
831 capa->wowlan_triggers.four_way_handshake = 1;
832 if (triggers[NL80211_WOWLAN_TRIG_RFKILL_RELEASE])
833 capa->wowlan_triggers.rfkill_release = 1;
834 }
835
836
wiphy_info_extended_capab(struct wpa_driver_nl80211_data * drv,struct nlattr * tb)837 static void wiphy_info_extended_capab(struct wpa_driver_nl80211_data *drv,
838 struct nlattr *tb)
839 {
840 int rem = 0, i;
841 struct nlattr *tb1[NL80211_ATTR_MAX + 1], *attr;
842
843 if (!tb || drv->num_iface_capa == NL80211_IFTYPE_MAX)
844 return;
845
846 nla_for_each_nested(attr, tb, rem) {
847 unsigned int len;
848 struct drv_nl80211_iface_capa *capa;
849
850 nla_parse(tb1, NL80211_ATTR_MAX, nla_data(attr),
851 nla_len(attr), NULL);
852
853 if (!tb1[NL80211_ATTR_IFTYPE] ||
854 !tb1[NL80211_ATTR_EXT_CAPA] ||
855 !tb1[NL80211_ATTR_EXT_CAPA_MASK])
856 continue;
857
858 capa = &drv->iface_capa[drv->num_iface_capa];
859 capa->iftype = nla_get_u32(tb1[NL80211_ATTR_IFTYPE]);
860 wpa_printf(MSG_DEBUG,
861 "nl80211: Driver-advertised extended capabilities for interface type %s",
862 nl80211_iftype_str(capa->iftype));
863
864 len = nla_len(tb1[NL80211_ATTR_EXT_CAPA]);
865 capa->ext_capa = os_memdup(nla_data(tb1[NL80211_ATTR_EXT_CAPA]),
866 len);
867 if (!capa->ext_capa)
868 goto err;
869
870 capa->ext_capa_len = len;
871 wpa_hexdump(MSG_DEBUG, "nl80211: Extended capabilities",
872 capa->ext_capa, capa->ext_capa_len);
873
874 len = nla_len(tb1[NL80211_ATTR_EXT_CAPA_MASK]);
875 capa->ext_capa_mask =
876 os_memdup(nla_data(tb1[NL80211_ATTR_EXT_CAPA_MASK]),
877 len);
878 if (!capa->ext_capa_mask)
879 goto err;
880
881 wpa_hexdump(MSG_DEBUG, "nl80211: Extended capabilities mask",
882 capa->ext_capa_mask, capa->ext_capa_len);
883
884 if (tb1[NL80211_ATTR_EML_CAPABILITY] &&
885 tb1[NL80211_ATTR_MLD_CAPA_AND_OPS]) {
886 capa->eml_capa =
887 nla_get_u16(tb1[NL80211_ATTR_EML_CAPABILITY]);
888 capa->mld_capa_and_ops =
889 nla_get_u16(tb1[NL80211_ATTR_MLD_CAPA_AND_OPS]);
890 }
891
892 wpa_printf(MSG_DEBUG,
893 "nl80211: EML Capability: 0x%x MLD Capability: 0x%x",
894 capa->eml_capa, capa->mld_capa_and_ops);
895
896 drv->num_iface_capa++;
897 if (drv->num_iface_capa == NL80211_IFTYPE_MAX)
898 break;
899 }
900
901 return;
902
903 err:
904 /* Cleanup allocated memory on error */
905 for (i = 0; i < NL80211_IFTYPE_MAX; i++) {
906 os_free(drv->iface_capa[i].ext_capa);
907 drv->iface_capa[i].ext_capa = NULL;
908 os_free(drv->iface_capa[i].ext_capa_mask);
909 drv->iface_capa[i].ext_capa_mask = NULL;
910 drv->iface_capa[i].ext_capa_len = 0;
911 }
912 drv->num_iface_capa = 0;
913 }
914
915
wiphy_info_mbssid(struct wpa_driver_capa * cap,struct nlattr * attr)916 static void wiphy_info_mbssid(struct wpa_driver_capa *cap, struct nlattr *attr)
917 {
918 struct nlattr *config[NL80211_MBSSID_CONFIG_ATTR_MAX + 1];
919
920 if (nla_parse_nested(config, NL80211_MBSSID_CONFIG_ATTR_MAX, attr,
921 NULL))
922 return;
923
924 if (!config[NL80211_MBSSID_CONFIG_ATTR_MAX_INTERFACES])
925 return;
926
927 cap->mbssid_max_interfaces =
928 nla_get_u8(config[NL80211_MBSSID_CONFIG_ATTR_MAX_INTERFACES]);
929
930 if (config[NL80211_MBSSID_CONFIG_ATTR_MAX_EMA_PROFILE_PERIODICITY])
931 cap->ema_max_periodicity =
932 nla_get_u8(config[NL80211_MBSSID_CONFIG_ATTR_MAX_EMA_PROFILE_PERIODICITY]);
933
934 wpa_printf(MSG_DEBUG,
935 "mbssid: max interfaces %u, max profile periodicity %u",
936 cap->mbssid_max_interfaces, cap->ema_max_periodicity);
937 }
938
939
wiphy_info_handler(struct nl_msg * msg,void * arg)940 static int wiphy_info_handler(struct nl_msg *msg, void *arg)
941 {
942 struct nlattr *tb[NL80211_ATTR_MAX + 1];
943 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
944 struct wiphy_info_data *info = arg;
945 struct wpa_driver_capa *capa = info->capa;
946 struct wpa_driver_nl80211_data *drv = info->drv;
947
948 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
949 genlmsg_attrlen(gnlh, 0), NULL);
950
951 if (tb[NL80211_ATTR_WIPHY])
952 drv->wiphy_idx = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
953
954 if (tb[NL80211_ATTR_WIPHY_NAME])
955 os_strlcpy(drv->phyname,
956 nla_get_string(tb[NL80211_ATTR_WIPHY_NAME]),
957 sizeof(drv->phyname));
958 if (tb[NL80211_ATTR_MAX_NUM_SCAN_SSIDS])
959 capa->max_scan_ssids =
960 nla_get_u8(tb[NL80211_ATTR_MAX_NUM_SCAN_SSIDS]);
961
962 if (tb[NL80211_ATTR_MAX_SCAN_IE_LEN])
963 capa->max_probe_req_ie_len =
964 nla_get_u16(tb[NL80211_ATTR_MAX_SCAN_IE_LEN]);
965
966 if (tb[NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS])
967 capa->max_sched_scan_ssids =
968 nla_get_u8(tb[NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS]);
969
970 if (tb[NL80211_ATTR_MAX_NUM_SCHED_SCAN_PLANS] &&
971 tb[NL80211_ATTR_MAX_SCAN_PLAN_INTERVAL] &&
972 tb[NL80211_ATTR_MAX_SCAN_PLAN_ITERATIONS]) {
973 capa->max_sched_scan_plans =
974 nla_get_u32(tb[NL80211_ATTR_MAX_NUM_SCHED_SCAN_PLANS]);
975
976 capa->max_sched_scan_plan_interval =
977 nla_get_u32(tb[NL80211_ATTR_MAX_SCAN_PLAN_INTERVAL]);
978
979 capa->max_sched_scan_plan_iterations =
980 nla_get_u32(tb[NL80211_ATTR_MAX_SCAN_PLAN_ITERATIONS]);
981 }
982
983 if (tb[NL80211_ATTR_MAX_MATCH_SETS])
984 capa->max_match_sets =
985 nla_get_u8(tb[NL80211_ATTR_MAX_MATCH_SETS]);
986
987 if (tb[NL80211_ATTR_MAC_ACL_MAX])
988 capa->max_acl_mac_addrs =
989 nla_get_u32(tb[NL80211_ATTR_MAC_ACL_MAX]);
990
991 wiphy_info_supported_iftypes(info, tb[NL80211_ATTR_SUPPORTED_IFTYPES]);
992 wiphy_info_iface_comb(info, tb[NL80211_ATTR_INTERFACE_COMBINATIONS]);
993 wiphy_info_supp_cmds(info, tb[NL80211_ATTR_SUPPORTED_COMMANDS]);
994 wiphy_info_cipher_suites(info, tb[NL80211_ATTR_CIPHER_SUITES]);
995 wiphy_info_akm_suites(info, tb[NL80211_ATTR_AKM_SUITES]);
996 wiphy_info_iftype_akm_suites(info, tb[NL80211_ATTR_IFTYPE_AKM_SUITES]);
997
998 if (tb[NL80211_ATTR_OFFCHANNEL_TX_OK]) {
999 wpa_printf(MSG_DEBUG, "nl80211: Using driver-based "
1000 "off-channel TX");
1001 capa->flags |= WPA_DRIVER_FLAGS_OFFCHANNEL_TX;
1002 }
1003
1004 if (tb[NL80211_ATTR_ROAM_SUPPORT]) {
1005 wpa_printf(MSG_DEBUG, "nl80211: Using driver-based roaming");
1006 capa->flags |= WPA_DRIVER_FLAGS_BSS_SELECTION;
1007 }
1008
1009 wiphy_info_max_roc(capa,
1010 tb[NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION]);
1011
1012 if (tb[NL80211_ATTR_SUPPORT_AP_UAPSD])
1013 capa->flags |= WPA_DRIVER_FLAGS_AP_UAPSD;
1014
1015 wiphy_info_tdls(capa, tb[NL80211_ATTR_TDLS_SUPPORT],
1016 tb[NL80211_ATTR_TDLS_EXTERNAL_SETUP]);
1017
1018 if (tb[NL80211_ATTR_DEVICE_AP_SME]) {
1019 u32 ap_sme_features_flags =
1020 nla_get_u32(tb[NL80211_ATTR_DEVICE_AP_SME]);
1021
1022 if (ap_sme_features_flags & NL80211_AP_SME_SA_QUERY_OFFLOAD)
1023 capa->flags2 |= WPA_DRIVER_FLAGS2_SA_QUERY_OFFLOAD_AP;
1024
1025 info->device_ap_sme = 1;
1026 }
1027
1028 wiphy_info_feature_flags(info, tb[NL80211_ATTR_FEATURE_FLAGS]);
1029 wiphy_info_ext_feature_flags(info, tb[NL80211_ATTR_EXT_FEATURES]);
1030 wiphy_info_probe_resp_offload(capa,
1031 tb[NL80211_ATTR_PROBE_RESP_OFFLOAD]);
1032
1033 if (tb[NL80211_ATTR_EXT_CAPA] && tb[NL80211_ATTR_EXT_CAPA_MASK] &&
1034 drv->extended_capa == NULL) {
1035 drv->extended_capa =
1036 os_malloc(nla_len(tb[NL80211_ATTR_EXT_CAPA]));
1037 if (drv->extended_capa) {
1038 os_memcpy(drv->extended_capa,
1039 nla_data(tb[NL80211_ATTR_EXT_CAPA]),
1040 nla_len(tb[NL80211_ATTR_EXT_CAPA]));
1041 drv->extended_capa_len =
1042 nla_len(tb[NL80211_ATTR_EXT_CAPA]);
1043 wpa_hexdump(MSG_DEBUG,
1044 "nl80211: Driver-advertised extended capabilities (default)",
1045 drv->extended_capa, drv->extended_capa_len);
1046 }
1047 drv->extended_capa_mask =
1048 os_malloc(nla_len(tb[NL80211_ATTR_EXT_CAPA_MASK]));
1049 if (drv->extended_capa_mask) {
1050 os_memcpy(drv->extended_capa_mask,
1051 nla_data(tb[NL80211_ATTR_EXT_CAPA_MASK]),
1052 nla_len(tb[NL80211_ATTR_EXT_CAPA_MASK]));
1053 wpa_hexdump(MSG_DEBUG,
1054 "nl80211: Driver-advertised extended capabilities mask (default)",
1055 drv->extended_capa_mask,
1056 drv->extended_capa_len);
1057 } else {
1058 os_free(drv->extended_capa);
1059 drv->extended_capa = NULL;
1060 drv->extended_capa_len = 0;
1061 }
1062 }
1063
1064 wiphy_info_extended_capab(drv, tb[NL80211_ATTR_IFTYPE_EXT_CAPA]);
1065
1066 if (tb[NL80211_ATTR_VENDOR_DATA]) {
1067 struct nlattr *nl;
1068 int rem;
1069
1070 nla_for_each_nested(nl, tb[NL80211_ATTR_VENDOR_DATA], rem) {
1071 struct nl80211_vendor_cmd_info *vinfo;
1072 if (nla_len(nl) != sizeof(*vinfo)) {
1073 wpa_printf(MSG_DEBUG, "nl80211: Unexpected vendor data info");
1074 continue;
1075 }
1076 vinfo = nla_data(nl);
1077 if (vinfo->vendor_id == OUI_QCA) {
1078 switch (vinfo->subcmd) {
1079 case QCA_NL80211_VENDOR_SUBCMD_TEST:
1080 drv->vendor_cmd_test_avail = 1;
1081 break;
1082 #ifdef CONFIG_DRIVER_NL80211_QCA
1083 case QCA_NL80211_VENDOR_SUBCMD_ROAMING:
1084 drv->roaming_vendor_cmd_avail = 1;
1085 break;
1086 case QCA_NL80211_VENDOR_SUBCMD_DFS_CAPABILITY:
1087 drv->dfs_vendor_cmd_avail = 1;
1088 break;
1089 case QCA_NL80211_VENDOR_SUBCMD_GET_FEATURES:
1090 drv->get_features_vendor_cmd_avail = 1;
1091 break;
1092 case QCA_NL80211_VENDOR_SUBCMD_GET_PREFERRED_FREQ_LIST:
1093 drv->get_pref_freq_list = 1;
1094 break;
1095 case QCA_NL80211_VENDOR_SUBCMD_SET_PROBABLE_OPER_CHANNEL:
1096 drv->set_prob_oper_freq = 1;
1097 break;
1098 case QCA_NL80211_VENDOR_SUBCMD_DO_ACS:
1099 drv->capa.flags |=
1100 WPA_DRIVER_FLAGS_ACS_OFFLOAD;
1101 drv->qca_do_acs = 1;
1102 break;
1103 case QCA_NL80211_VENDOR_SUBCMD_SETBAND:
1104 drv->setband_vendor_cmd_avail = 1;
1105 break;
1106 case QCA_NL80211_VENDOR_SUBCMD_TRIGGER_SCAN:
1107 drv->scan_vendor_cmd_avail = 1;
1108 break;
1109 case QCA_NL80211_VENDOR_SUBCMD_SET_WIFI_CONFIGURATION:
1110 drv->set_wifi_conf_vendor_cmd_avail = 1;
1111 break;
1112 case QCA_NL80211_VENDOR_SUBCMD_FETCH_BSS_TRANSITION_STATUS:
1113 drv->fetch_bss_trans_status = 1;
1114 break;
1115 case QCA_NL80211_VENDOR_SUBCMD_ROAM:
1116 drv->roam_vendor_cmd_avail = 1;
1117 break;
1118 case QCA_NL80211_VENDOR_SUBCMD_ADD_STA_NODE:
1119 drv->add_sta_node_vendor_cmd_avail = 1;
1120 break;
1121 case QCA_NL80211_VENDOR_SUBCMD_GET_STA_INFO:
1122 drv->get_sta_info_vendor_cmd_avail = 1;
1123 break;
1124 case QCA_NL80211_VENDOR_SUBCMD_SECURE_RANGING_CONTEXT:
1125 drv->secure_ranging_ctx_vendor_cmd_avail = 1;
1126 break;
1127 case QCA_NL80211_VENDOR_SUBCMD_CONNECT_EXT:
1128 drv->connect_ext_vendor_cmd_avail = 1;
1129 break;
1130 #endif /* CONFIG_DRIVER_NL80211_QCA */
1131 }
1132 #if defined(CONFIG_DRIVER_NL80211_BRCM) || defined(CONFIG_DRIVER_NL80211_SYNA)
1133 } else if (vinfo->vendor_id == OUI_BRCM) {
1134 switch (vinfo->subcmd) {
1135 case BRCM_VENDOR_SCMD_ACS:
1136 drv->capa.flags |=
1137 WPA_DRIVER_FLAGS_ACS_OFFLOAD;
1138 drv->capa.flags |=
1139 WPA_DRIVER_FLAGS_SUPPORT_HW_MODE_ANY;
1140 wpa_printf(MSG_DEBUG,
1141 "Enabled BRCM ACS");
1142 drv->brcm_do_acs = 1;
1143 break;
1144 case BRCM_VENDOR_SCMD_SET_PMK:
1145 drv->vendor_set_pmk = 1;
1146 break;
1147 default:
1148 break;
1149 }
1150 #endif /* CONFIG_DRIVER_NL80211_BRCM || CONFIG_DRIVER_NL80211_SYNA */
1151 }
1152 wpa_printf(MSG_DEBUG, "nl80211: Supported vendor command: vendor_id=0x%x subcmd=%u",
1153 vinfo->vendor_id, vinfo->subcmd);
1154 }
1155 }
1156
1157 if (tb[NL80211_ATTR_VENDOR_EVENTS]) {
1158 struct nlattr *nl;
1159 int rem;
1160
1161 nla_for_each_nested(nl, tb[NL80211_ATTR_VENDOR_EVENTS], rem) {
1162 struct nl80211_vendor_cmd_info *vinfo;
1163 if (nla_len(nl) != sizeof(*vinfo)) {
1164 wpa_printf(MSG_DEBUG, "nl80211: Unexpected vendor data info");
1165 continue;
1166 }
1167 vinfo = nla_data(nl);
1168 wpa_printf(MSG_DEBUG, "nl80211: Supported vendor event: vendor_id=0x%x subcmd=%u",
1169 vinfo->vendor_id, vinfo->subcmd);
1170 }
1171 }
1172
1173 wiphy_info_wowlan_triggers(capa,
1174 tb[NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED]);
1175
1176 if (tb[NL80211_ATTR_MAX_AP_ASSOC_STA])
1177 capa->max_stations =
1178 nla_get_u32(tb[NL80211_ATTR_MAX_AP_ASSOC_STA]);
1179
1180 if (tb[NL80211_ATTR_MAX_CSA_COUNTERS])
1181 capa->max_csa_counters =
1182 nla_get_u8(tb[NL80211_ATTR_MAX_CSA_COUNTERS]);
1183
1184 if (tb[NL80211_ATTR_WIPHY_SELF_MANAGED_REG])
1185 capa->flags |= WPA_DRIVER_FLAGS_SELF_MANAGED_REGULATORY;
1186
1187 if (tb[NL80211_ATTR_MAX_NUM_AKM_SUITES])
1188 capa->max_num_akms =
1189 nla_get_u16(tb[NL80211_ATTR_MAX_NUM_AKM_SUITES]);
1190
1191 if (tb[NL80211_ATTR_MBSSID_CONFIG])
1192 wiphy_info_mbssid(capa, tb[NL80211_ATTR_MBSSID_CONFIG]);
1193
1194 if (tb[NL80211_ATTR_MLO_SUPPORT])
1195 capa->flags2 |= WPA_DRIVER_FLAGS2_MLO;
1196
1197 return NL_SKIP;
1198 }
1199
1200
wpa_driver_nl80211_get_info(struct wpa_driver_nl80211_data * drv,struct wiphy_info_data * info)1201 static int wpa_driver_nl80211_get_info(struct wpa_driver_nl80211_data *drv,
1202 struct wiphy_info_data *info)
1203 {
1204 u32 feat;
1205 struct nl_msg *msg;
1206 int flags = 0;
1207
1208 os_memset(info, 0, sizeof(*info));
1209 info->capa = &drv->capa;
1210 info->drv = drv;
1211
1212 /* Default to large buffer of extra IE(s) to maintain previous behavior
1213 * if the driver does not support reporting an accurate limit. */
1214 info->capa->max_probe_req_ie_len = 1500;
1215
1216 feat = get_nl80211_protocol_features(drv);
1217 if (feat & NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP)
1218 flags = NLM_F_DUMP;
1219 msg = nl80211_cmd_msg(drv->first_bss, flags, NL80211_CMD_GET_WIPHY);
1220 if (!msg || nla_put_flag(msg, NL80211_ATTR_SPLIT_WIPHY_DUMP)) {
1221 nlmsg_free(msg);
1222 return -1;
1223 }
1224
1225 if (send_and_recv_resp(drv, msg, wiphy_info_handler, info))
1226 return -1;
1227
1228 if (info->auth_supported)
1229 drv->capa.flags |= WPA_DRIVER_FLAGS_SME;
1230 else if (!info->connect_supported) {
1231 wpa_printf(MSG_INFO, "nl80211: Driver does not support "
1232 "authentication/association or connect commands");
1233 info->error = 1;
1234 }
1235
1236 if (info->p2p_go_supported && info->p2p_client_supported)
1237 drv->capa.flags |= WPA_DRIVER_FLAGS_P2P_CAPABLE;
1238 if (info->p2p_concurrent) {
1239 wpa_printf(MSG_DEBUG, "nl80211: Use separate P2P group "
1240 "interface (driver advertised support)");
1241 drv->capa.flags |= WPA_DRIVER_FLAGS_P2P_CONCURRENT;
1242 drv->capa.flags |= WPA_DRIVER_FLAGS_P2P_MGMT_AND_NON_P2P;
1243 }
1244 if (info->num_multichan_concurrent > 1) {
1245 wpa_printf(MSG_DEBUG, "nl80211: Enable multi-channel "
1246 "concurrent (driver advertised support)");
1247 drv->capa.num_multichan_concurrent =
1248 info->num_multichan_concurrent;
1249 }
1250 if (drv->capa.flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)
1251 wpa_printf(MSG_DEBUG, "nl80211: use P2P_DEVICE support");
1252
1253 /* default to 5000 since early versions of mac80211 don't set it */
1254 if (!drv->capa.max_remain_on_chan)
1255 drv->capa.max_remain_on_chan = 5000;
1256
1257 drv->capa.wmm_ac_supported = info->wmm_ac_supported;
1258
1259 drv->capa.mac_addr_rand_sched_scan_supported =
1260 info->mac_addr_rand_sched_scan_supported;
1261 drv->capa.mac_addr_rand_scan_supported =
1262 info->mac_addr_rand_scan_supported;
1263
1264 if (info->channel_switch_supported) {
1265 drv->capa.flags |= WPA_DRIVER_FLAGS_AP_CSA;
1266 if (!drv->capa.max_csa_counters)
1267 drv->capa.max_csa_counters = 1;
1268 }
1269
1270 if (!drv->capa.max_sched_scan_plans) {
1271 drv->capa.max_sched_scan_plans = 1;
1272 drv->capa.max_sched_scan_plan_interval = UINT32_MAX;
1273 drv->capa.max_sched_scan_plan_iterations = 0;
1274 }
1275
1276 if (info->update_ft_ies_supported)
1277 drv->capa.flags |= WPA_DRIVER_FLAGS_UPDATE_FT_IES;
1278
1279 if (!drv->capa.max_num_akms)
1280 #if defined(CONFIG_DRIVER_NL80211_BRCM) && !defined(WIFI_BRCM_OPEN_SOURCE_MULTI_AKM)
1281 drv->capa.max_num_akms = 1;
1282 #else
1283 drv->capa.max_num_akms = NL80211_MAX_NR_AKM_SUITES;
1284 #endif /* CONFIG_DRIVER_NL80211_BRCM && !WIFI_BRCM_OPEN_SOURCE_MULTI_AKM */
1285
1286 return 0;
1287 }
1288
1289
1290 #ifdef CONFIG_DRIVER_NL80211_QCA
1291
dfs_info_handler(struct nl_msg * msg,void * arg)1292 static int dfs_info_handler(struct nl_msg *msg, void *arg)
1293 {
1294 struct nlattr *tb[NL80211_ATTR_MAX + 1];
1295 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
1296 int *dfs_capability_ptr = arg;
1297
1298 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
1299 genlmsg_attrlen(gnlh, 0), NULL);
1300
1301 if (tb[NL80211_ATTR_VENDOR_DATA]) {
1302 struct nlattr *nl_vend = tb[NL80211_ATTR_VENDOR_DATA];
1303 struct nlattr *tb_vendor[QCA_WLAN_VENDOR_ATTR_MAX + 1];
1304
1305 nla_parse(tb_vendor, QCA_WLAN_VENDOR_ATTR_MAX,
1306 nla_data(nl_vend), nla_len(nl_vend), NULL);
1307
1308 if (tb_vendor[QCA_WLAN_VENDOR_ATTR_DFS]) {
1309 u32 val;
1310 val = nla_get_u32(tb_vendor[QCA_WLAN_VENDOR_ATTR_DFS]);
1311 wpa_printf(MSG_DEBUG, "nl80211: DFS offload capability: %u",
1312 val);
1313 *dfs_capability_ptr = val;
1314 }
1315 }
1316
1317 return NL_SKIP;
1318 }
1319
1320
qca_nl80211_check_dfs_capa(struct wpa_driver_nl80211_data * drv)1321 static void qca_nl80211_check_dfs_capa(struct wpa_driver_nl80211_data *drv)
1322 {
1323 struct nl_msg *msg;
1324 int dfs_capability = 0;
1325 int ret;
1326
1327 if (!drv->dfs_vendor_cmd_avail)
1328 return;
1329
1330 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
1331 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
1332 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
1333 QCA_NL80211_VENDOR_SUBCMD_DFS_CAPABILITY)) {
1334 nlmsg_free(msg);
1335 return;
1336 }
1337
1338 ret = send_and_recv_resp(drv, msg, dfs_info_handler, &dfs_capability);
1339 if (!ret && dfs_capability)
1340 drv->capa.flags |= WPA_DRIVER_FLAGS_DFS_OFFLOAD;
1341 }
1342
1343
1344 struct features_info {
1345 u8 *flags;
1346 size_t flags_len;
1347 struct wpa_driver_capa *capa;
1348 };
1349
1350
features_info_handler(struct nl_msg * msg,void * arg)1351 static int features_info_handler(struct nl_msg *msg, void *arg)
1352 {
1353 struct nlattr *tb[NL80211_ATTR_MAX + 1];
1354 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
1355 struct features_info *info = arg;
1356 struct nlattr *nl_vend, *attr;
1357
1358 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
1359 genlmsg_attrlen(gnlh, 0), NULL);
1360
1361 nl_vend = tb[NL80211_ATTR_VENDOR_DATA];
1362 if (nl_vend) {
1363 struct nlattr *tb_vendor[QCA_WLAN_VENDOR_ATTR_MAX + 1];
1364
1365 nla_parse(tb_vendor, QCA_WLAN_VENDOR_ATTR_MAX,
1366 nla_data(nl_vend), nla_len(nl_vend), NULL);
1367
1368 attr = tb_vendor[QCA_WLAN_VENDOR_ATTR_FEATURE_FLAGS];
1369 if (attr) {
1370 int len = nla_len(attr);
1371 info->flags = os_malloc(len);
1372 if (info->flags != NULL) {
1373 os_memcpy(info->flags, nla_data(attr), len);
1374 info->flags_len = len;
1375 }
1376 }
1377 attr = tb_vendor[QCA_WLAN_VENDOR_ATTR_CONCURRENCY_CAPA];
1378 if (attr)
1379 info->capa->conc_capab = nla_get_u32(attr);
1380
1381 attr = tb_vendor[
1382 QCA_WLAN_VENDOR_ATTR_MAX_CONCURRENT_CHANNELS_2_4_BAND];
1383 if (attr)
1384 info->capa->max_conc_chan_2_4 = nla_get_u32(attr);
1385
1386 attr = tb_vendor[
1387 QCA_WLAN_VENDOR_ATTR_MAX_CONCURRENT_CHANNELS_5_0_BAND];
1388 if (attr)
1389 info->capa->max_conc_chan_5_0 = nla_get_u32(attr);
1390 }
1391
1392 return NL_SKIP;
1393 }
1394
1395
check_feature(enum qca_wlan_vendor_features feature,struct features_info * info)1396 static int check_feature(enum qca_wlan_vendor_features feature,
1397 struct features_info *info)
1398 {
1399 size_t idx = feature / 8;
1400
1401 return (idx < info->flags_len) &&
1402 (info->flags[idx] & BIT(feature % 8));
1403 }
1404
1405
qca_nl80211_get_features(struct wpa_driver_nl80211_data * drv)1406 static void qca_nl80211_get_features(struct wpa_driver_nl80211_data *drv)
1407 {
1408 struct nl_msg *msg;
1409 struct features_info info;
1410 int ret;
1411
1412 if (!drv->get_features_vendor_cmd_avail)
1413 return;
1414
1415 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
1416 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
1417 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
1418 QCA_NL80211_VENDOR_SUBCMD_GET_FEATURES)) {
1419 nlmsg_free(msg);
1420 return;
1421 }
1422
1423 os_memset(&info, 0, sizeof(info));
1424 info.capa = &drv->capa;
1425 ret = send_and_recv_resp(drv, msg, features_info_handler, &info);
1426 if (ret || !info.flags)
1427 return;
1428
1429 if (check_feature(QCA_WLAN_VENDOR_FEATURE_KEY_MGMT_OFFLOAD, &info))
1430 drv->capa.flags |= WPA_DRIVER_FLAGS_KEY_MGMT_OFFLOAD;
1431
1432 if (check_feature(QCA_WLAN_VENDOR_FEATURE_SUPPORT_HW_MODE_ANY, &info))
1433 drv->capa.flags |= WPA_DRIVER_FLAGS_SUPPORT_HW_MODE_ANY;
1434
1435 if (check_feature(QCA_WLAN_VENDOR_FEATURE_OFFCHANNEL_SIMULTANEOUS,
1436 &info))
1437 drv->capa.flags |= WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS;
1438 if (check_feature(QCA_WLAN_VENDOR_FEATURE_P2P_LISTEN_OFFLOAD, &info))
1439 drv->capa.flags |= WPA_DRIVER_FLAGS_P2P_LISTEN_OFFLOAD;
1440 if (check_feature(QCA_WLAN_VENDOR_FEATURE_OCE_STA, &info))
1441 drv->capa.flags |= WPA_DRIVER_FLAGS_OCE_STA;
1442 if (check_feature(QCA_WLAN_VENDOR_FEATURE_OCE_AP, &info))
1443 drv->capa.flags |= WPA_DRIVER_FLAGS_OCE_AP;
1444 if (check_feature(QCA_WLAN_VENDOR_FEATURE_OCE_STA_CFON, &info))
1445 drv->capa.flags |= WPA_DRIVER_FLAGS_OCE_STA_CFON;
1446 if (check_feature(QCA_WLAN_VENDOR_FEATURE_SECURE_LTF_STA, &info))
1447 drv->capa.flags2 |= WPA_DRIVER_FLAGS2_SEC_LTF_STA;
1448 if (check_feature(QCA_WLAN_VENDOR_FEATURE_SECURE_LTF_AP, &info))
1449 drv->capa.flags2 |= WPA_DRIVER_FLAGS2_SEC_LTF_AP;
1450 if (check_feature(QCA_WLAN_VENDOR_FEATURE_SECURE_RTT_STA, &info))
1451 drv->capa.flags2 |= WPA_DRIVER_FLAGS2_SEC_RTT_STA;
1452 if (check_feature(QCA_WLAN_VENDOR_FEATURE_SECURE_RTT_AP, &info))
1453 drv->capa.flags2 |= WPA_DRIVER_FLAGS2_SEC_RTT_AP;
1454 if (check_feature(
1455 QCA_WLAN_VENDOR_FEATURE_PROT_RANGE_NEGO_AND_MEASURE_STA,
1456 &info))
1457 drv->capa.flags2 |= WPA_DRIVER_FLAGS2_PROT_RANGE_NEG_STA;
1458 if (check_feature(
1459 QCA_WLAN_VENDOR_FEATURE_PROT_RANGE_NEGO_AND_MEASURE_AP,
1460 &info))
1461 drv->capa.flags2 |= WPA_DRIVER_FLAGS2_PROT_RANGE_NEG_AP;
1462 if (check_feature(QCA_WLAN_VENDOR_FEATURE_AP_ALLOWED_FREQ_LIST,
1463 &info))
1464 drv->qca_ap_allowed_freqs = 1;
1465 if (check_feature(QCA_WLAN_VENDOR_FEATURE_HT_VHT_TWT_RESPONDER, &info))
1466 drv->capa.flags2 |= WPA_DRIVER_FLAGS2_HT_VHT_TWT_RESPONDER;
1467 if (check_feature(QCA_WLAN_VENDOR_FEATURE_RSN_OVERRIDE_STA, &info)) {
1468 wpa_printf(MSG_DEBUG,
1469 "The driver supports RSN overriding in STA mode");
1470 drv->capa.flags2 |= WPA_DRIVER_FLAGS2_RSN_OVERRIDE_STA;
1471 }
1472 if (check_feature(QCA_WLAN_VENDOR_FEATURE_NAN_USD_OFFLOAD, &info))
1473 drv->capa.flags2 |= WPA_DRIVER_FLAGS2_NAN_OFFLOAD;
1474
1475 if (!check_feature(QCA_WLAN_VENDOR_FEATURE_P2P_V2, &info))
1476 drv->capa.flags2 &= ~WPA_DRIVER_FLAGS2_P2P_FEATURE_V2;
1477
1478 if (!check_feature(QCA_WLAN_VENDOR_FEATURE_PCC_MODE, &info))
1479 drv->capa.flags2 &= ~WPA_DRIVER_FLAGS2_P2P_FEATURE_PCC_MODE;
1480
1481 os_free(info.flags);
1482 }
1483
1484 #endif /* CONFIG_DRIVER_NL80211_QCA */
1485
1486
wpa_driver_nl80211_capa(struct wpa_driver_nl80211_data * drv)1487 int wpa_driver_nl80211_capa(struct wpa_driver_nl80211_data *drv)
1488 {
1489 struct wiphy_info_data info;
1490 int i;
1491
1492 if (wpa_driver_nl80211_get_info(drv, &info))
1493 return -1;
1494
1495 if (info.error)
1496 return -1;
1497
1498 drv->has_capability = 1;
1499 drv->has_driver_key_mgmt = info.has_key_mgmt | info.has_key_mgmt_iftype;
1500
1501 /* Fallback to hardcoded defaults if the driver does not advertise any
1502 * AKM capabilities. */
1503 if (!drv->has_driver_key_mgmt) {
1504 drv->capa.key_mgmt = WPA_DRIVER_CAPA_KEY_MGMT_WPA |
1505 WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK |
1506 WPA_DRIVER_CAPA_KEY_MGMT_WPA2 |
1507 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK |
1508 WPA_DRIVER_CAPA_KEY_MGMT_PSK_SHA256 |
1509 WPA_DRIVER_CAPA_KEY_MGMT_SUITE_B |
1510 WPA_DRIVER_CAPA_KEY_MGMT_OWE |
1511 WPA_DRIVER_CAPA_KEY_MGMT_DPP;
1512
1513 if (drv->capa.enc & (WPA_DRIVER_CAPA_ENC_CCMP_256 |
1514 WPA_DRIVER_CAPA_ENC_GCMP_256))
1515 drv->capa.key_mgmt |=
1516 WPA_DRIVER_CAPA_KEY_MGMT_SUITE_B_192;
1517
1518 if (drv->capa.flags & WPA_DRIVER_FLAGS_SME)
1519 drv->capa.key_mgmt |=
1520 WPA_DRIVER_CAPA_KEY_MGMT_FILS_SHA256 |
1521 WPA_DRIVER_CAPA_KEY_MGMT_FILS_SHA384 |
1522 WPA_DRIVER_CAPA_KEY_MGMT_FT_FILS_SHA256 |
1523 WPA_DRIVER_CAPA_KEY_MGMT_FT_FILS_SHA384 |
1524 WPA_DRIVER_CAPA_KEY_MGMT_SAE_EXT_KEY |
1525 WPA_DRIVER_CAPA_KEY_MGMT_SAE;
1526 else if (drv->capa.flags & WPA_DRIVER_FLAGS_FILS_SK_OFFLOAD)
1527 drv->capa.key_mgmt |=
1528 WPA_DRIVER_CAPA_KEY_MGMT_FILS_SHA256 |
1529 WPA_DRIVER_CAPA_KEY_MGMT_FILS_SHA384;
1530 }
1531
1532 if (!info.has_key_mgmt_iftype) {
1533 /* If the driver does not advertize per interface AKM
1534 * capabilities, consider all interfaces to support default AKMs
1535 * in key_mgmt. */
1536 for (i = 0; i < WPA_IF_MAX; i++)
1537 drv->capa.key_mgmt_iftype[i] = drv->capa.key_mgmt;
1538 } else if (info.has_key_mgmt_iftype && !info.has_key_mgmt) {
1539 /* If the driver advertizes only per interface supported AKMs
1540 * but does not advertize per wiphy AKM capabilities, consider
1541 * the default key_mgmt as a mask of per interface supported
1542 * AKMs. */
1543 drv->capa.key_mgmt = 0;
1544 for (i = 0; i < WPA_IF_MAX; i++)
1545 drv->capa.key_mgmt |= drv->capa.key_mgmt_iftype[i];
1546 } else if (info.has_key_mgmt_iftype && info.has_key_mgmt) {
1547 /* If the driver advertizes AKM capabilities both per wiphy and
1548 * per interface, consider the interfaces for which per
1549 * interface AKM capabilities were not received to support the
1550 * default key_mgmt capabilities.
1551 */
1552 for (i = 0; i < WPA_IF_MAX; i++)
1553 if (!drv->capa.key_mgmt_iftype[i])
1554 drv->capa.key_mgmt_iftype[i] =
1555 drv->capa.key_mgmt;
1556 }
1557
1558 drv->capa.auth = WPA_DRIVER_AUTH_OPEN |
1559 WPA_DRIVER_AUTH_SHARED |
1560 WPA_DRIVER_AUTH_LEAP;
1561
1562 drv->capa.flags |= WPA_DRIVER_FLAGS_VALID_ERROR_CODES;
1563 drv->capa.flags |= WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC_DONE;
1564 drv->capa.flags |= WPA_DRIVER_FLAGS_EAPOL_TX_STATUS;
1565
1566 /*
1567 * As all cfg80211 drivers must support cases where the AP interface is
1568 * removed without the knowledge of wpa_supplicant/hostapd, e.g., in
1569 * case that the user space daemon has crashed, they must be able to
1570 * cleanup all stations and key entries in the AP tear down flow. Thus,
1571 * this flag can/should always be set for cfg80211 drivers.
1572 */
1573 drv->capa.flags |= WPA_DRIVER_FLAGS_AP_TEARDOWN_SUPPORT;
1574
1575 if (!info.device_ap_sme) {
1576 drv->capa.flags |= WPA_DRIVER_FLAGS_DEAUTH_TX_STATUS;
1577 drv->capa.flags2 |= WPA_DRIVER_FLAGS2_AP_SME;
1578
1579 /*
1580 * No AP SME is currently assumed to also indicate no AP MLME
1581 * in the driver/firmware.
1582 */
1583 drv->capa.flags |= WPA_DRIVER_FLAGS_AP_MLME;
1584 }
1585
1586 drv->device_ap_sme = info.device_ap_sme;
1587 drv->poll_command_supported = info.poll_command_supported;
1588 drv->data_tx_status = info.data_tx_status;
1589 drv->p2p_go_ctwindow_supported = info.p2p_go_ctwindow_supported;
1590 if (info.set_qos_map_supported)
1591 drv->capa.flags |= WPA_DRIVER_FLAGS_QOS_MAPPING;
1592 drv->have_low_prio_scan = info.have_low_prio_scan;
1593
1594 /*
1595 * If the driver doesn't support data TX status, we won't get TX
1596 * status for EAPOL frames.
1597 */
1598 if (!info.data_tx_status)
1599 drv->capa.flags &= ~WPA_DRIVER_FLAGS_EAPOL_TX_STATUS;
1600
1601 /* Enable P2P2 and PCC mode capabilities by default for the drivers
1602 * which can't explicitly indicate whether these capabilities are
1603 * supported. */
1604 drv->capa.flags2 |= WPA_DRIVER_FLAGS2_P2P_FEATURE_V2;
1605 drv->capa.flags2 |= WPA_DRIVER_FLAGS2_P2P_FEATURE_PCC_MODE;
1606
1607 #ifdef CONFIG_DRIVER_NL80211_QCA
1608 if (!(info.capa->flags & WPA_DRIVER_FLAGS_DFS_OFFLOAD))
1609 qca_nl80211_check_dfs_capa(drv);
1610 qca_nl80211_get_features(drv);
1611
1612 /*
1613 * To enable offchannel simultaneous support in wpa_supplicant, the
1614 * underlying driver needs to support the same along with offchannel TX.
1615 * Offchannel TX support is needed since remain_on_channel and
1616 * action_tx use some common data structures and hence cannot be
1617 * scheduled simultaneously.
1618 */
1619 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_OFFCHANNEL_TX))
1620 drv->capa.flags &= ~WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS;
1621 #endif /* CONFIG_DRIVER_NL80211_QCA */
1622
1623 wpa_printf(MSG_DEBUG,
1624 "nl80211: key_mgmt=0x%x enc=0x%x auth=0x%x flags=0x%llx flags2=0x%llx rrm_flags=0x%x probe_resp_offloads=0x%x max_stations=%u max_remain_on_chan=%u max_scan_ssids=%d",
1625 drv->capa.key_mgmt, drv->capa.enc, drv->capa.auth,
1626 (unsigned long long) drv->capa.flags,
1627 (unsigned long long) drv->capa.flags2, drv->capa.rrm_flags,
1628 drv->capa.probe_resp_offloads, drv->capa.max_stations,
1629 drv->capa.max_remain_on_chan, drv->capa.max_scan_ssids);
1630 return 0;
1631 }
1632
1633
1634 struct phy_info_arg {
1635 u16 *num_modes;
1636 struct hostapd_hw_modes *modes;
1637 int last_mode, last_chan_idx;
1638 int failed;
1639 u8 dfs_domain;
1640 };
1641
phy_info_ht_capa(struct hostapd_hw_modes * mode,struct nlattr * capa,struct nlattr * ampdu_factor,struct nlattr * ampdu_density,struct nlattr * mcs_set)1642 static void phy_info_ht_capa(struct hostapd_hw_modes *mode, struct nlattr *capa,
1643 struct nlattr *ampdu_factor,
1644 struct nlattr *ampdu_density,
1645 struct nlattr *mcs_set)
1646 {
1647 if (capa)
1648 mode->ht_capab = nla_get_u16(capa);
1649
1650 if (ampdu_factor)
1651 mode->a_mpdu_params |= nla_get_u8(ampdu_factor) & 0x03;
1652
1653 if (ampdu_density)
1654 mode->a_mpdu_params |= nla_get_u8(ampdu_density) << 2;
1655
1656 if (mcs_set && nla_len(mcs_set) >= 16) {
1657 u8 *mcs;
1658 mcs = nla_data(mcs_set);
1659 os_memcpy(mode->mcs_set, mcs, 16);
1660 }
1661 }
1662
1663
phy_info_vht_capa(struct hostapd_hw_modes * mode,struct nlattr * capa,struct nlattr * mcs_set)1664 static void phy_info_vht_capa(struct hostapd_hw_modes *mode,
1665 struct nlattr *capa,
1666 struct nlattr *mcs_set)
1667 {
1668 if (capa)
1669 mode->vht_capab = nla_get_u32(capa);
1670
1671 if (mcs_set && nla_len(mcs_set) >= 8) {
1672 u8 *mcs;
1673 mcs = nla_data(mcs_set);
1674 os_memcpy(mode->vht_mcs_set, mcs, 8);
1675 }
1676 }
1677
1678
phy_info_edmg_capa(struct hostapd_hw_modes * mode,struct nlattr * bw_config,struct nlattr * channels)1679 static int phy_info_edmg_capa(struct hostapd_hw_modes *mode,
1680 struct nlattr *bw_config,
1681 struct nlattr *channels)
1682 {
1683 if (!bw_config || !channels)
1684 return NL_OK;
1685
1686 mode->edmg.bw_config = nla_get_u8(bw_config);
1687 mode->edmg.channels = nla_get_u8(channels);
1688
1689 if (!mode->edmg.channels || !mode->edmg.bw_config)
1690 return NL_STOP;
1691
1692 return NL_OK;
1693 }
1694
1695
cw2ecw(unsigned int cw)1696 static int cw2ecw(unsigned int cw)
1697 {
1698 int bit;
1699
1700 if (cw == 0)
1701 return 0;
1702
1703 for (bit = 1; cw != 1; bit++)
1704 cw >>= 1;
1705
1706 return bit;
1707 }
1708
1709
phy_info_freq(struct hostapd_hw_modes * mode,struct hostapd_channel_data * chan,struct nlattr * tb_freq[])1710 static void phy_info_freq(struct hostapd_hw_modes *mode,
1711 struct hostapd_channel_data *chan,
1712 struct nlattr *tb_freq[])
1713 {
1714 u8 channel;
1715
1716 os_memset(chan, 0, sizeof(*chan));
1717 chan->freq = nla_get_u32(tb_freq[NL80211_FREQUENCY_ATTR_FREQ]);
1718 chan->flag = 0;
1719 chan->allowed_bw = ~0;
1720 chan->dfs_cac_ms = 0;
1721 if (ieee80211_freq_to_chan(chan->freq, &channel) != NUM_HOSTAPD_MODES)
1722 chan->chan = channel;
1723 else
1724 wpa_printf(MSG_DEBUG,
1725 "nl80211: No channel number found for frequency %u MHz",
1726 chan->freq);
1727
1728 if (tb_freq[NL80211_FREQUENCY_ATTR_DISABLED])
1729 chan->flag |= HOSTAPD_CHAN_DISABLED;
1730 if (tb_freq[NL80211_FREQUENCY_ATTR_NO_IR])
1731 chan->flag |= HOSTAPD_CHAN_NO_IR;
1732 if (tb_freq[NL80211_FREQUENCY_ATTR_RADAR])
1733 chan->flag |= HOSTAPD_CHAN_RADAR;
1734 if (tb_freq[NL80211_FREQUENCY_ATTR_INDOOR_ONLY])
1735 chan->flag |= HOSTAPD_CHAN_INDOOR_ONLY;
1736 if (tb_freq[NL80211_FREQUENCY_ATTR_GO_CONCURRENT])
1737 chan->flag |= HOSTAPD_CHAN_GO_CONCURRENT;
1738
1739 if (tb_freq[NL80211_FREQUENCY_ATTR_NO_10MHZ])
1740 chan->allowed_bw &= ~HOSTAPD_CHAN_WIDTH_10;
1741 if (tb_freq[NL80211_FREQUENCY_ATTR_NO_20MHZ])
1742 chan->allowed_bw &= ~HOSTAPD_CHAN_WIDTH_20;
1743 if (tb_freq[NL80211_FREQUENCY_ATTR_NO_HT40_PLUS])
1744 chan->allowed_bw &= ~HOSTAPD_CHAN_WIDTH_40P;
1745 if (tb_freq[NL80211_FREQUENCY_ATTR_NO_HT40_MINUS])
1746 chan->allowed_bw &= ~HOSTAPD_CHAN_WIDTH_40M;
1747 if (tb_freq[NL80211_FREQUENCY_ATTR_NO_80MHZ])
1748 chan->allowed_bw &= ~HOSTAPD_CHAN_WIDTH_80;
1749 if (tb_freq[NL80211_FREQUENCY_ATTR_NO_160MHZ])
1750 chan->allowed_bw &= ~HOSTAPD_CHAN_WIDTH_160;
1751 if (tb_freq[NL80211_FREQUENCY_ATTR_NO_320MHZ])
1752 chan->allowed_bw &= ~HOSTAPD_CHAN_WIDTH_320;
1753
1754 if (tb_freq[NL80211_FREQUENCY_ATTR_DFS_STATE]) {
1755 enum nl80211_dfs_state state =
1756 nla_get_u32(tb_freq[NL80211_FREQUENCY_ATTR_DFS_STATE]);
1757
1758 switch (state) {
1759 case NL80211_DFS_USABLE:
1760 chan->flag |= HOSTAPD_CHAN_DFS_USABLE;
1761 break;
1762 case NL80211_DFS_AVAILABLE:
1763 chan->flag |= HOSTAPD_CHAN_DFS_AVAILABLE;
1764 break;
1765 case NL80211_DFS_UNAVAILABLE:
1766 chan->flag |= HOSTAPD_CHAN_DFS_UNAVAILABLE;
1767 break;
1768 }
1769 }
1770
1771 if (tb_freq[NL80211_FREQUENCY_ATTR_DFS_CAC_TIME]) {
1772 chan->dfs_cac_ms = nla_get_u32(
1773 tb_freq[NL80211_FREQUENCY_ATTR_DFS_CAC_TIME]);
1774 }
1775
1776 chan->wmm_rules_valid = 0;
1777 if (tb_freq[NL80211_FREQUENCY_ATTR_WMM]) {
1778 static struct nla_policy wmm_policy[NL80211_WMMR_MAX + 1] = {
1779 [NL80211_WMMR_CW_MIN] = { .type = NLA_U16 },
1780 [NL80211_WMMR_CW_MAX] = { .type = NLA_U16 },
1781 [NL80211_WMMR_AIFSN] = { .type = NLA_U8 },
1782 [NL80211_WMMR_TXOP] = { .type = NLA_U16 },
1783 };
1784 static const u8 wmm_map[4] = {
1785 [NL80211_AC_BE] = WMM_AC_BE,
1786 [NL80211_AC_BK] = WMM_AC_BK,
1787 [NL80211_AC_VI] = WMM_AC_VI,
1788 [NL80211_AC_VO] = WMM_AC_VO,
1789 };
1790 struct nlattr *nl_wmm;
1791 struct nlattr *tb_wmm[NL80211_WMMR_MAX + 1];
1792 int rem_wmm, ac, count = 0;
1793
1794 nla_for_each_nested(nl_wmm, tb_freq[NL80211_FREQUENCY_ATTR_WMM],
1795 rem_wmm) {
1796 if (nla_parse_nested(tb_wmm, NL80211_WMMR_MAX, nl_wmm,
1797 wmm_policy)) {
1798 wpa_printf(MSG_DEBUG,
1799 "nl80211: Failed to parse WMM rules attribute");
1800 return;
1801 }
1802 if (!tb_wmm[NL80211_WMMR_CW_MIN] ||
1803 !tb_wmm[NL80211_WMMR_CW_MAX] ||
1804 !tb_wmm[NL80211_WMMR_AIFSN] ||
1805 !tb_wmm[NL80211_WMMR_TXOP]) {
1806 wpa_printf(MSG_DEBUG,
1807 "nl80211: Channel is missing WMM rule attribute");
1808 return;
1809 }
1810 ac = nl_wmm->nla_type;
1811 if ((unsigned int) ac >= ARRAY_SIZE(wmm_map)) {
1812 wpa_printf(MSG_DEBUG,
1813 "nl80211: Invalid AC value %d", ac);
1814 return;
1815 }
1816
1817 ac = wmm_map[ac];
1818 chan->wmm_rules[ac].min_cwmin =
1819 cw2ecw(nla_get_u16(
1820 tb_wmm[NL80211_WMMR_CW_MIN]));
1821 chan->wmm_rules[ac].min_cwmax =
1822 cw2ecw(nla_get_u16(
1823 tb_wmm[NL80211_WMMR_CW_MAX]));
1824 chan->wmm_rules[ac].min_aifs =
1825 nla_get_u8(tb_wmm[NL80211_WMMR_AIFSN]);
1826 chan->wmm_rules[ac].max_txop =
1827 nla_get_u16(tb_wmm[NL80211_WMMR_TXOP]) / 32;
1828 count++;
1829 }
1830
1831 /* Set valid flag if all the AC rules are present */
1832 if (count == WMM_AC_NUM)
1833 chan->wmm_rules_valid = 1;
1834 }
1835 }
1836
1837
phy_info_freqs(struct phy_info_arg * phy_info,struct hostapd_hw_modes * mode,struct nlattr * tb)1838 static int phy_info_freqs(struct phy_info_arg *phy_info,
1839 struct hostapd_hw_modes *mode, struct nlattr *tb)
1840 {
1841 static struct nla_policy freq_policy[NL80211_FREQUENCY_ATTR_MAX + 1] = {
1842 [NL80211_FREQUENCY_ATTR_FREQ] = { .type = NLA_U32 },
1843 [NL80211_FREQUENCY_ATTR_DISABLED] = { .type = NLA_FLAG },
1844 [NL80211_FREQUENCY_ATTR_NO_IR] = { .type = NLA_FLAG },
1845 [NL80211_FREQUENCY_ATTR_RADAR] = { .type = NLA_FLAG },
1846 [NL80211_FREQUENCY_ATTR_MAX_TX_POWER] = { .type = NLA_U32 },
1847 [NL80211_FREQUENCY_ATTR_DFS_STATE] = { .type = NLA_U32 },
1848 [NL80211_FREQUENCY_ATTR_NO_10MHZ] = { .type = NLA_FLAG },
1849 [NL80211_FREQUENCY_ATTR_NO_20MHZ] = { .type = NLA_FLAG },
1850 [NL80211_FREQUENCY_ATTR_NO_HT40_PLUS] = { .type = NLA_FLAG },
1851 [NL80211_FREQUENCY_ATTR_NO_HT40_MINUS] = { .type = NLA_FLAG },
1852 [NL80211_FREQUENCY_ATTR_NO_80MHZ] = { .type = NLA_FLAG },
1853 [NL80211_FREQUENCY_ATTR_NO_160MHZ] = { .type = NLA_FLAG },
1854 [NL80211_FREQUENCY_ATTR_NO_320MHZ] = { .type = NLA_FLAG },
1855
1856 };
1857 int new_channels = 0;
1858 struct hostapd_channel_data *channel;
1859 struct nlattr *tb_freq[NL80211_FREQUENCY_ATTR_MAX + 1];
1860 struct nlattr *nl_freq;
1861 int rem_freq, idx;
1862
1863 if (tb == NULL)
1864 return NL_OK;
1865
1866 nla_for_each_nested(nl_freq, tb, rem_freq) {
1867 nla_parse(tb_freq, NL80211_FREQUENCY_ATTR_MAX,
1868 nla_data(nl_freq), nla_len(nl_freq), freq_policy);
1869 if (!tb_freq[NL80211_FREQUENCY_ATTR_FREQ])
1870 continue;
1871 new_channels++;
1872 }
1873
1874 channel = os_realloc_array(mode->channels,
1875 mode->num_channels + new_channels,
1876 sizeof(struct hostapd_channel_data));
1877 if (!channel)
1878 return NL_STOP;
1879
1880 mode->channels = channel;
1881 mode->num_channels += new_channels;
1882
1883 idx = phy_info->last_chan_idx;
1884
1885 nla_for_each_nested(nl_freq, tb, rem_freq) {
1886 nla_parse(tb_freq, NL80211_FREQUENCY_ATTR_MAX,
1887 nla_data(nl_freq), nla_len(nl_freq), freq_policy);
1888 if (!tb_freq[NL80211_FREQUENCY_ATTR_FREQ])
1889 continue;
1890 phy_info_freq(mode, &mode->channels[idx], tb_freq);
1891 idx++;
1892 }
1893 phy_info->last_chan_idx = idx;
1894
1895 return NL_OK;
1896 }
1897
1898
phy_info_rates(struct hostapd_hw_modes * mode,struct nlattr * tb)1899 static int phy_info_rates(struct hostapd_hw_modes *mode, struct nlattr *tb)
1900 {
1901 static struct nla_policy rate_policy[NL80211_BITRATE_ATTR_MAX + 1] = {
1902 [NL80211_BITRATE_ATTR_RATE] = { .type = NLA_U32 },
1903 [NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE] =
1904 { .type = NLA_FLAG },
1905 };
1906 struct nlattr *tb_rate[NL80211_BITRATE_ATTR_MAX + 1];
1907 struct nlattr *nl_rate;
1908 int rem_rate, idx;
1909
1910 if (tb == NULL)
1911 return NL_OK;
1912
1913 nla_for_each_nested(nl_rate, tb, rem_rate) {
1914 nla_parse(tb_rate, NL80211_BITRATE_ATTR_MAX,
1915 nla_data(nl_rate), nla_len(nl_rate),
1916 rate_policy);
1917 if (!tb_rate[NL80211_BITRATE_ATTR_RATE])
1918 continue;
1919 mode->num_rates++;
1920 }
1921
1922 mode->rates = os_calloc(mode->num_rates, sizeof(int));
1923 if (!mode->rates)
1924 return NL_STOP;
1925
1926 idx = 0;
1927
1928 nla_for_each_nested(nl_rate, tb, rem_rate) {
1929 nla_parse(tb_rate, NL80211_BITRATE_ATTR_MAX,
1930 nla_data(nl_rate), nla_len(nl_rate),
1931 rate_policy);
1932 if (!tb_rate[NL80211_BITRATE_ATTR_RATE])
1933 continue;
1934 mode->rates[idx] = nla_get_u32(
1935 tb_rate[NL80211_BITRATE_ATTR_RATE]);
1936 idx++;
1937 }
1938
1939 return NL_OK;
1940 }
1941
1942
phy_info_iftype_copy(struct hostapd_hw_modes * mode,enum ieee80211_op_mode opmode,struct nlattr ** tb,struct nlattr ** tb_flags)1943 static void phy_info_iftype_copy(struct hostapd_hw_modes *mode,
1944 enum ieee80211_op_mode opmode,
1945 struct nlattr **tb, struct nlattr **tb_flags)
1946 {
1947 enum nl80211_iftype iftype;
1948 size_t len;
1949 struct he_capabilities *he_capab = &mode->he_capab[opmode];
1950 struct eht_capabilities *eht_capab = &mode->eht_capab[opmode];
1951
1952 switch (opmode) {
1953 case IEEE80211_MODE_INFRA:
1954 iftype = NL80211_IFTYPE_STATION;
1955 break;
1956 case IEEE80211_MODE_IBSS:
1957 iftype = NL80211_IFTYPE_ADHOC;
1958 break;
1959 case IEEE80211_MODE_AP:
1960 iftype = NL80211_IFTYPE_AP;
1961 break;
1962 case IEEE80211_MODE_MESH:
1963 iftype = NL80211_IFTYPE_MESH_POINT;
1964 break;
1965 default:
1966 return;
1967 }
1968
1969 if (!nla_get_flag(tb_flags[iftype]))
1970 return;
1971
1972 he_capab->he_supported = 1;
1973
1974 if (tb[NL80211_BAND_IFTYPE_ATTR_HE_CAP_PHY]) {
1975 len = nla_len(tb[NL80211_BAND_IFTYPE_ATTR_HE_CAP_PHY]);
1976
1977 if (len > sizeof(he_capab->phy_cap))
1978 len = sizeof(he_capab->phy_cap);
1979 os_memcpy(he_capab->phy_cap,
1980 nla_data(tb[NL80211_BAND_IFTYPE_ATTR_HE_CAP_PHY]),
1981 len);
1982 }
1983
1984 if (tb[NL80211_BAND_IFTYPE_ATTR_HE_CAP_MAC]) {
1985 len = nla_len(tb[NL80211_BAND_IFTYPE_ATTR_HE_CAP_MAC]);
1986
1987 if (len > sizeof(he_capab->mac_cap))
1988 len = sizeof(he_capab->mac_cap);
1989 os_memcpy(he_capab->mac_cap,
1990 nla_data(tb[NL80211_BAND_IFTYPE_ATTR_HE_CAP_MAC]),
1991 len);
1992 }
1993
1994 if (tb[NL80211_BAND_IFTYPE_ATTR_HE_CAP_MCS_SET]) {
1995 len = nla_len(tb[NL80211_BAND_IFTYPE_ATTR_HE_CAP_MCS_SET]);
1996
1997 if (len > sizeof(he_capab->mcs))
1998 len = sizeof(he_capab->mcs);
1999 os_memcpy(he_capab->mcs,
2000 nla_data(tb[NL80211_BAND_IFTYPE_ATTR_HE_CAP_MCS_SET]),
2001 len);
2002 }
2003
2004 if (tb[NL80211_BAND_IFTYPE_ATTR_HE_CAP_PPE]) {
2005 len = nla_len(tb[NL80211_BAND_IFTYPE_ATTR_HE_CAP_PPE]);
2006
2007 if (len > sizeof(he_capab->ppet))
2008 len = sizeof(he_capab->ppet);
2009 os_memcpy(&he_capab->ppet,
2010 nla_data(tb[NL80211_BAND_IFTYPE_ATTR_HE_CAP_PPE]),
2011 len);
2012 }
2013
2014 if (tb[NL80211_BAND_IFTYPE_ATTR_HE_6GHZ_CAPA])
2015 he_capab->he_6ghz_capa =
2016 nla_get_u16(tb[NL80211_BAND_IFTYPE_ATTR_HE_6GHZ_CAPA]);
2017
2018 if (!tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_MAC] ||
2019 !tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_PHY])
2020 return;
2021
2022 eht_capab->eht_supported = true;
2023
2024 if (tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_MAC] &&
2025 nla_len(tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_MAC]) >= 2) {
2026 const u8 *pos;
2027
2028 pos = nla_data(tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_MAC]);
2029 eht_capab->mac_cap = WPA_GET_LE16(pos);
2030 }
2031
2032 if (tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_PHY]) {
2033 len = nla_len(tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_PHY]);
2034 if (len > sizeof(eht_capab->phy_cap))
2035 len = sizeof(eht_capab->phy_cap);
2036 os_memcpy(eht_capab->phy_cap,
2037 nla_data(tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_PHY]),
2038 len);
2039 }
2040
2041 if (tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_MCS_SET]) {
2042 len = nla_len(tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_MCS_SET]);
2043 if (len > sizeof(eht_capab->mcs))
2044 len = sizeof(eht_capab->mcs);
2045 os_memcpy(eht_capab->mcs,
2046 nla_data(tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_MCS_SET]),
2047 len);
2048 }
2049
2050 if (tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_PPE]) {
2051 len = nla_len(tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_PPE]);
2052 if (len > sizeof(eht_capab->ppet))
2053 len = sizeof(eht_capab->ppet);
2054 os_memcpy(&eht_capab->ppet,
2055 nla_data(tb[NL80211_BAND_IFTYPE_ATTR_EHT_CAP_PPE]),
2056 len);
2057 }
2058 }
2059
2060
phy_info_iftype(struct hostapd_hw_modes * mode,struct nlattr * nl_iftype)2061 static int phy_info_iftype(struct hostapd_hw_modes *mode,
2062 struct nlattr *nl_iftype)
2063 {
2064 struct nlattr *tb[NL80211_BAND_IFTYPE_ATTR_MAX + 1];
2065 struct nlattr *tb_flags[NL80211_IFTYPE_MAX + 1];
2066 unsigned int i;
2067
2068 nla_parse(tb, NL80211_BAND_IFTYPE_ATTR_MAX,
2069 nla_data(nl_iftype), nla_len(nl_iftype), NULL);
2070
2071 if (!tb[NL80211_BAND_IFTYPE_ATTR_IFTYPES])
2072 return NL_STOP;
2073
2074 if (nla_parse_nested(tb_flags, NL80211_IFTYPE_MAX,
2075 tb[NL80211_BAND_IFTYPE_ATTR_IFTYPES], NULL))
2076 return NL_STOP;
2077
2078 for (i = 0; i < IEEE80211_MODE_NUM; i++)
2079 phy_info_iftype_copy(mode, i, tb, tb_flags);
2080
2081 return NL_OK;
2082 }
2083
2084
phy_info_band(struct phy_info_arg * phy_info,struct nlattr * nl_band)2085 static int phy_info_band(struct phy_info_arg *phy_info, struct nlattr *nl_band)
2086 {
2087 struct nlattr *tb_band[NL80211_BAND_ATTR_MAX + 1];
2088 struct hostapd_hw_modes *mode;
2089 int ret;
2090
2091 if (phy_info->last_mode != nl_band->nla_type) {
2092 mode = os_realloc_array(phy_info->modes,
2093 *phy_info->num_modes + 1,
2094 sizeof(*mode));
2095 if (!mode) {
2096 phy_info->failed = 1;
2097 return NL_STOP;
2098 }
2099 phy_info->modes = mode;
2100
2101 mode = &phy_info->modes[*(phy_info->num_modes)];
2102 os_memset(mode, 0, sizeof(*mode));
2103 mode->mode = NUM_HOSTAPD_MODES;
2104 mode->flags = HOSTAPD_MODE_FLAG_HT_INFO_KNOWN |
2105 HOSTAPD_MODE_FLAG_VHT_INFO_KNOWN |
2106 HOSTAPD_MODE_FLAG_HE_INFO_KNOWN;
2107
2108 /*
2109 * Unsupported VHT MCS stream is defined as value 3, so the VHT
2110 * MCS RX/TX map must be initialized with 0xffff to mark all 8
2111 * possible streams as unsupported. This will be overridden if
2112 * driver advertises VHT support.
2113 */
2114 mode->vht_mcs_set[0] = 0xff;
2115 mode->vht_mcs_set[1] = 0xff;
2116 mode->vht_mcs_set[4] = 0xff;
2117 mode->vht_mcs_set[5] = 0xff;
2118
2119 *(phy_info->num_modes) += 1;
2120 phy_info->last_mode = nl_band->nla_type;
2121 phy_info->last_chan_idx = 0;
2122 } else
2123 mode = &phy_info->modes[*(phy_info->num_modes) - 1];
2124
2125 nla_parse(tb_band, NL80211_BAND_ATTR_MAX, nla_data(nl_band),
2126 nla_len(nl_band), NULL);
2127
2128 phy_info_ht_capa(mode, tb_band[NL80211_BAND_ATTR_HT_CAPA],
2129 tb_band[NL80211_BAND_ATTR_HT_AMPDU_FACTOR],
2130 tb_band[NL80211_BAND_ATTR_HT_AMPDU_DENSITY],
2131 tb_band[NL80211_BAND_ATTR_HT_MCS_SET]);
2132 phy_info_vht_capa(mode, tb_band[NL80211_BAND_ATTR_VHT_CAPA],
2133 tb_band[NL80211_BAND_ATTR_VHT_MCS_SET]);
2134 ret = phy_info_edmg_capa(mode,
2135 tb_band[NL80211_BAND_ATTR_EDMG_BW_CONFIG],
2136 tb_band[NL80211_BAND_ATTR_EDMG_CHANNELS]);
2137 if (ret == NL_OK)
2138 ret = phy_info_freqs(phy_info, mode,
2139 tb_band[NL80211_BAND_ATTR_FREQS]);
2140 if (ret == NL_OK)
2141 ret = phy_info_rates(mode, tb_band[NL80211_BAND_ATTR_RATES]);
2142 if (ret != NL_OK) {
2143 phy_info->failed = 1;
2144 return ret;
2145 }
2146
2147 if (tb_band[NL80211_BAND_ATTR_IFTYPE_DATA]) {
2148 struct nlattr *nl_iftype;
2149 int rem_band;
2150
2151 nla_for_each_nested(nl_iftype,
2152 tb_band[NL80211_BAND_ATTR_IFTYPE_DATA],
2153 rem_band) {
2154 ret = phy_info_iftype(mode, nl_iftype);
2155 if (ret != NL_OK)
2156 return ret;
2157 }
2158 }
2159
2160 return NL_OK;
2161 }
2162
2163
phy_info_handler(struct nl_msg * msg,void * arg)2164 static int phy_info_handler(struct nl_msg *msg, void *arg)
2165 {
2166 struct nlattr *tb_msg[NL80211_ATTR_MAX + 1];
2167 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
2168 struct phy_info_arg *phy_info = arg;
2169 struct nlattr *nl_band;
2170 int rem_band;
2171
2172 nla_parse(tb_msg, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
2173 genlmsg_attrlen(gnlh, 0), NULL);
2174
2175 if (!tb_msg[NL80211_ATTR_WIPHY_BANDS])
2176 return NL_SKIP;
2177
2178 nla_for_each_nested(nl_band, tb_msg[NL80211_ATTR_WIPHY_BANDS], rem_band)
2179 {
2180 int res = phy_info_band(phy_info, nl_band);
2181 if (res != NL_OK)
2182 return res;
2183 }
2184
2185 return NL_SKIP;
2186 }
2187
2188
2189 static struct hostapd_hw_modes *
wpa_driver_nl80211_postprocess_modes(struct hostapd_hw_modes * modes,u16 * num_modes)2190 wpa_driver_nl80211_postprocess_modes(struct hostapd_hw_modes *modes,
2191 u16 *num_modes)
2192 {
2193 u16 m;
2194 struct hostapd_hw_modes *mode11g = NULL, *nmodes, *mode;
2195 int i, mode11g_idx = -1;
2196
2197 /* heuristic to set up modes */
2198 for (m = 0; m < *num_modes; m++) {
2199 if (!modes[m].num_channels)
2200 continue;
2201
2202 modes[m].is_6ghz = false;
2203
2204 if (modes[m].channels[0].freq < 2000) {
2205 modes[m].num_channels = 0;
2206 continue;
2207 } else if (modes[m].channels[0].freq < 4000) {
2208 modes[m].mode = HOSTAPD_MODE_IEEE80211B;
2209 for (i = 0; i < modes[m].num_rates; i++) {
2210 if (modes[m].rates[i] > 200) {
2211 modes[m].mode = HOSTAPD_MODE_IEEE80211G;
2212 break;
2213 }
2214 }
2215 } else if (modes[m].channels[0].freq > 50000) {
2216 modes[m].mode = HOSTAPD_MODE_IEEE80211AD;
2217 } else if (is_6ghz_freq(modes[m].channels[0].freq)) {
2218 modes[m].mode = HOSTAPD_MODE_IEEE80211A;
2219 modes[m].is_6ghz = true;
2220 } else {
2221 modes[m].mode = HOSTAPD_MODE_IEEE80211A;
2222 }
2223 }
2224
2225 /* Remove unsupported bands */
2226 m = 0;
2227 while (m < *num_modes) {
2228 if (modes[m].mode == NUM_HOSTAPD_MODES) {
2229 wpa_printf(MSG_DEBUG,
2230 "nl80211: Remove unsupported mode");
2231 os_free(modes[m].channels);
2232 os_free(modes[m].rates);
2233 if (m + 1 < *num_modes)
2234 os_memmove(&modes[m], &modes[m + 1],
2235 sizeof(struct hostapd_hw_modes) *
2236 (*num_modes - (m + 1)));
2237 (*num_modes)--;
2238 continue;
2239 }
2240 m++;
2241 }
2242
2243 /* If only 802.11g mode is included, use it to construct matching
2244 * 802.11b mode data. */
2245
2246 for (m = 0; m < *num_modes; m++) {
2247 if (modes[m].mode == HOSTAPD_MODE_IEEE80211B)
2248 return modes; /* 802.11b already included */
2249 if (modes[m].mode == HOSTAPD_MODE_IEEE80211G)
2250 mode11g_idx = m;
2251 }
2252
2253 if (mode11g_idx < 0)
2254 return modes; /* 2.4 GHz band not supported at all */
2255
2256 nmodes = os_realloc_array(modes, *num_modes + 1, sizeof(*nmodes));
2257 if (nmodes == NULL)
2258 return modes; /* Could not add 802.11b mode */
2259
2260 mode = &nmodes[*num_modes];
2261 os_memset(mode, 0, sizeof(*mode));
2262 (*num_modes)++;
2263 modes = nmodes;
2264
2265 mode->mode = HOSTAPD_MODE_IEEE80211B;
2266
2267 mode11g = &modes[mode11g_idx];
2268 mode->num_channels = mode11g->num_channels;
2269 mode->channels = os_memdup(mode11g->channels,
2270 mode11g->num_channels *
2271 sizeof(struct hostapd_channel_data));
2272 if (mode->channels == NULL) {
2273 (*num_modes)--;
2274 return modes; /* Could not add 802.11b mode */
2275 }
2276
2277 mode->num_rates = 0;
2278 mode->rates = os_malloc(4 * sizeof(int));
2279 if (mode->rates == NULL) {
2280 os_free(mode->channels);
2281 (*num_modes)--;
2282 return modes; /* Could not add 802.11b mode */
2283 }
2284
2285 for (i = 0; i < mode11g->num_rates; i++) {
2286 if (mode11g->rates[i] != 10 && mode11g->rates[i] != 20 &&
2287 mode11g->rates[i] != 55 && mode11g->rates[i] != 110)
2288 continue;
2289 mode->rates[mode->num_rates] = mode11g->rates[i];
2290 mode->num_rates++;
2291 if (mode->num_rates == 4)
2292 break;
2293 }
2294
2295 if (mode->num_rates == 0) {
2296 os_free(mode->channels);
2297 os_free(mode->rates);
2298 (*num_modes)--;
2299 return modes; /* No 802.11b rates */
2300 }
2301
2302 wpa_printf(MSG_DEBUG, "nl80211: Added 802.11b mode based on 802.11g "
2303 "information");
2304
2305 return modes;
2306 }
2307
2308
nl80211_set_ht40_mode(struct hostapd_hw_modes * mode,int start,int end)2309 static void nl80211_set_ht40_mode(struct hostapd_hw_modes *mode, int start,
2310 int end)
2311 {
2312 int c;
2313
2314 for (c = 0; c < mode->num_channels; c++) {
2315 struct hostapd_channel_data *chan = &mode->channels[c];
2316 if (chan->freq - 10 >= start && chan->freq + 10 <= end)
2317 chan->flag |= HOSTAPD_CHAN_HT40;
2318 }
2319 }
2320
2321
nl80211_set_ht40_mode_sec(struct hostapd_hw_modes * mode,int start,int end)2322 static void nl80211_set_ht40_mode_sec(struct hostapd_hw_modes *mode, int start,
2323 int end)
2324 {
2325 int c;
2326
2327 for (c = 0; c < mode->num_channels; c++) {
2328 struct hostapd_channel_data *chan = &mode->channels[c];
2329 if (!(chan->flag & HOSTAPD_CHAN_HT40))
2330 continue;
2331 if (chan->freq - 30 >= start && chan->freq - 10 <= end)
2332 chan->flag |= HOSTAPD_CHAN_HT40MINUS;
2333 if (chan->freq + 10 >= start && chan->freq + 30 <= end)
2334 chan->flag |= HOSTAPD_CHAN_HT40PLUS;
2335 }
2336 }
2337
2338
nl80211_reg_rule_max_eirp(u32 start,u32 end,u32 max_eirp,struct phy_info_arg * results)2339 static void nl80211_reg_rule_max_eirp(u32 start, u32 end, u32 max_eirp,
2340 struct phy_info_arg *results)
2341 {
2342 u16 m;
2343
2344 for (m = 0; m < *results->num_modes; m++) {
2345 int c;
2346 struct hostapd_hw_modes *mode = &results->modes[m];
2347
2348 for (c = 0; c < mode->num_channels; c++) {
2349 struct hostapd_channel_data *chan = &mode->channels[c];
2350 if ((u32) chan->freq - 10 >= start &&
2351 (u32) chan->freq + 10 <= end)
2352 chan->max_tx_power = max_eirp;
2353 }
2354 }
2355 }
2356
2357
nl80211_reg_rule_ht40(u32 start,u32 end,struct phy_info_arg * results)2358 static void nl80211_reg_rule_ht40(u32 start, u32 end,
2359 struct phy_info_arg *results)
2360 {
2361 u16 m;
2362
2363 for (m = 0; m < *results->num_modes; m++) {
2364 if (!(results->modes[m].ht_capab &
2365 HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET))
2366 continue;
2367 nl80211_set_ht40_mode(&results->modes[m], start, end);
2368 }
2369 }
2370
2371
nl80211_reg_rule_sec(struct nlattr * tb[],struct phy_info_arg * results)2372 static void nl80211_reg_rule_sec(struct nlattr *tb[],
2373 struct phy_info_arg *results)
2374 {
2375 u32 start, end, max_bw;
2376 u16 m;
2377
2378 if (tb[NL80211_ATTR_FREQ_RANGE_START] == NULL ||
2379 tb[NL80211_ATTR_FREQ_RANGE_END] == NULL ||
2380 tb[NL80211_ATTR_FREQ_RANGE_MAX_BW] == NULL)
2381 return;
2382
2383 start = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]) / 1000;
2384 end = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]) / 1000;
2385 max_bw = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]) / 1000;
2386
2387 if (max_bw < 20)
2388 return;
2389
2390 for (m = 0; m < *results->num_modes; m++) {
2391 if (!(results->modes[m].ht_capab &
2392 HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET))
2393 continue;
2394 nl80211_set_ht40_mode_sec(&results->modes[m], start, end);
2395 }
2396 }
2397
2398
nl80211_set_vht_mode(struct hostapd_hw_modes * mode,int start,int end,int max_bw)2399 static void nl80211_set_vht_mode(struct hostapd_hw_modes *mode, int start,
2400 int end, int max_bw)
2401 {
2402 int c;
2403
2404 for (c = 0; c < mode->num_channels; c++) {
2405 struct hostapd_channel_data *chan = &mode->channels[c];
2406
2407 if (chan->freq - 10 < start || chan->freq + 10 > end)
2408 continue;
2409
2410 if (max_bw >= 80)
2411 chan->flag |= HOSTAPD_CHAN_VHT_80MHZ_SUBCHANNEL;
2412
2413 if (max_bw >= 160)
2414 chan->flag |= HOSTAPD_CHAN_VHT_160MHZ_SUBCHANNEL;
2415 }
2416 }
2417
2418
nl80211_reg_rule_vht(struct nlattr * tb[],struct phy_info_arg * results)2419 static void nl80211_reg_rule_vht(struct nlattr *tb[],
2420 struct phy_info_arg *results)
2421 {
2422 u32 start, end, max_bw;
2423 u16 m;
2424
2425 if (tb[NL80211_ATTR_FREQ_RANGE_START] == NULL ||
2426 tb[NL80211_ATTR_FREQ_RANGE_END] == NULL ||
2427 tb[NL80211_ATTR_FREQ_RANGE_MAX_BW] == NULL)
2428 return;
2429
2430 start = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]) / 1000;
2431 end = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]) / 1000;
2432 max_bw = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]) / 1000;
2433
2434 if (max_bw < 80)
2435 return;
2436
2437 for (m = 0; m < *results->num_modes; m++) {
2438 if (!(results->modes[m].ht_capab &
2439 HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET))
2440 continue;
2441 /* TODO: use a real VHT support indication */
2442 if (!results->modes[m].vht_capab)
2443 continue;
2444
2445 nl80211_set_vht_mode(&results->modes[m], start, end, max_bw);
2446 }
2447 }
2448
2449
nl80211_set_6ghz_mode(struct hostapd_hw_modes * mode,int start,int end,int max_bw)2450 static void nl80211_set_6ghz_mode(struct hostapd_hw_modes *mode, int start,
2451 int end, int max_bw)
2452 {
2453 int c;
2454
2455 for (c = 0; c < mode->num_channels; c++) {
2456 struct hostapd_channel_data *chan = &mode->channels[c];
2457
2458 if (chan->freq - 10 < start || chan->freq + 10 > end)
2459 continue;
2460
2461 if (max_bw >= 80)
2462 chan->flag |= HOSTAPD_CHAN_VHT_80MHZ_SUBCHANNEL;
2463
2464 if (max_bw >= 160)
2465 chan->flag |= HOSTAPD_CHAN_VHT_160MHZ_SUBCHANNEL;
2466
2467 if (max_bw >= 320)
2468 chan->flag |= HOSTAPD_CHAN_EHT_320MHZ_SUBCHANNEL;
2469 }
2470 }
2471
2472
nl80211_reg_rule_6ghz(struct nlattr * tb[],struct phy_info_arg * results)2473 static void nl80211_reg_rule_6ghz(struct nlattr *tb[],
2474 struct phy_info_arg *results)
2475 {
2476 u32 start, end, max_bw;
2477 u16 m;
2478
2479 if (!tb[NL80211_ATTR_FREQ_RANGE_START] ||
2480 !tb[NL80211_ATTR_FREQ_RANGE_END] ||
2481 !tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
2482 return;
2483
2484 start = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]) / 1000;
2485 end = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]) / 1000;
2486 max_bw = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]) / 1000;
2487
2488 if (max_bw < 80)
2489 return;
2490
2491 for (m = 0; m < *results->num_modes; m++) {
2492 if (results->modes[m].num_channels == 0 ||
2493 !is_6ghz_freq(results->modes[m].channels[0].freq))
2494 continue;
2495
2496 nl80211_set_6ghz_mode(&results->modes[m], start, end, max_bw);
2497 }
2498 }
2499
2500
nl80211_set_dfs_domain(enum nl80211_dfs_regions region,u8 * dfs_domain)2501 static void nl80211_set_dfs_domain(enum nl80211_dfs_regions region,
2502 u8 *dfs_domain)
2503 {
2504 if (region == NL80211_DFS_FCC)
2505 *dfs_domain = HOSTAPD_DFS_REGION_FCC;
2506 else if (region == NL80211_DFS_ETSI)
2507 *dfs_domain = HOSTAPD_DFS_REGION_ETSI;
2508 else if (region == NL80211_DFS_JP)
2509 *dfs_domain = HOSTAPD_DFS_REGION_JP;
2510 else
2511 *dfs_domain = 0;
2512 }
2513
2514
dfs_domain_name(enum nl80211_dfs_regions region)2515 static const char * dfs_domain_name(enum nl80211_dfs_regions region)
2516 {
2517 switch (region) {
2518 case NL80211_DFS_UNSET:
2519 return "DFS-UNSET";
2520 case NL80211_DFS_FCC:
2521 return "DFS-FCC";
2522 case NL80211_DFS_ETSI:
2523 return "DFS-ETSI";
2524 case NL80211_DFS_JP:
2525 return "DFS-JP";
2526 default:
2527 return "DFS-invalid";
2528 }
2529 }
2530
2531
nl80211_get_reg(struct nl_msg * msg,void * arg)2532 static int nl80211_get_reg(struct nl_msg *msg, void *arg)
2533 {
2534 struct phy_info_arg *results = arg;
2535 struct nlattr *tb_msg[NL80211_ATTR_MAX + 1];
2536 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
2537 struct nlattr *nl_rule;
2538 struct nlattr *tb_rule[NL80211_FREQUENCY_ATTR_MAX + 1];
2539 int rem_rule;
2540 static struct nla_policy reg_policy[NL80211_FREQUENCY_ATTR_MAX + 1] = {
2541 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 },
2542 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 },
2543 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 },
2544 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 },
2545 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 },
2546 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 },
2547 };
2548
2549 nla_parse(tb_msg, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
2550 genlmsg_attrlen(gnlh, 0), NULL);
2551 if (!tb_msg[NL80211_ATTR_REG_ALPHA2] ||
2552 !tb_msg[NL80211_ATTR_REG_RULES]) {
2553 wpa_printf(MSG_DEBUG, "nl80211: No regulatory information "
2554 "available");
2555 return NL_SKIP;
2556 }
2557
2558 if (tb_msg[NL80211_ATTR_DFS_REGION]) {
2559 enum nl80211_dfs_regions dfs_domain;
2560 dfs_domain = nla_get_u8(tb_msg[NL80211_ATTR_DFS_REGION]);
2561 nl80211_set_dfs_domain(dfs_domain, &results->dfs_domain);
2562 wpa_printf(MSG_DEBUG, "nl80211: Regulatory information - country=%s (%s)",
2563 (char *) nla_data(tb_msg[NL80211_ATTR_REG_ALPHA2]),
2564 dfs_domain_name(dfs_domain));
2565 } else {
2566 wpa_printf(MSG_DEBUG, "nl80211: Regulatory information - country=%s",
2567 (char *) nla_data(tb_msg[NL80211_ATTR_REG_ALPHA2]));
2568 }
2569
2570 nla_for_each_nested(nl_rule, tb_msg[NL80211_ATTR_REG_RULES], rem_rule)
2571 {
2572 u32 start, end, max_eirp = 0, max_bw = 0, flags = 0;
2573 nla_parse(tb_rule, NL80211_FREQUENCY_ATTR_MAX,
2574 nla_data(nl_rule), nla_len(nl_rule), reg_policy);
2575 if (tb_rule[NL80211_ATTR_FREQ_RANGE_START] == NULL ||
2576 tb_rule[NL80211_ATTR_FREQ_RANGE_END] == NULL)
2577 continue;
2578 start = nla_get_u32(tb_rule[NL80211_ATTR_FREQ_RANGE_START]) / 1000;
2579 end = nla_get_u32(tb_rule[NL80211_ATTR_FREQ_RANGE_END]) / 1000;
2580 if (tb_rule[NL80211_ATTR_POWER_RULE_MAX_EIRP])
2581 max_eirp = nla_get_u32(tb_rule[NL80211_ATTR_POWER_RULE_MAX_EIRP]) / 100;
2582 if (tb_rule[NL80211_ATTR_FREQ_RANGE_MAX_BW])
2583 max_bw = nla_get_u32(tb_rule[NL80211_ATTR_FREQ_RANGE_MAX_BW]) / 1000;
2584 if (tb_rule[NL80211_ATTR_REG_RULE_FLAGS])
2585 flags = nla_get_u32(tb_rule[NL80211_ATTR_REG_RULE_FLAGS]);
2586
2587 wpa_printf(MSG_DEBUG, "nl80211: %u-%u @ %u MHz %u mBm%s%s%s%s%s%s%s%s",
2588 start, end, max_bw, max_eirp,
2589 flags & NL80211_RRF_NO_OFDM ? " (no OFDM)" : "",
2590 flags & NL80211_RRF_NO_CCK ? " (no CCK)" : "",
2591 flags & NL80211_RRF_NO_INDOOR ? " (no indoor)" : "",
2592 flags & NL80211_RRF_NO_OUTDOOR ? " (no outdoor)" :
2593 "",
2594 flags & NL80211_RRF_DFS ? " (DFS)" : "",
2595 flags & NL80211_RRF_PTP_ONLY ? " (PTP only)" : "",
2596 flags & NL80211_RRF_PTMP_ONLY ? " (PTMP only)" : "",
2597 flags & NL80211_RRF_NO_IR ? " (no IR)" : "");
2598 if (max_bw >= 40)
2599 nl80211_reg_rule_ht40(start, end, results);
2600 if (tb_rule[NL80211_ATTR_POWER_RULE_MAX_EIRP])
2601 nl80211_reg_rule_max_eirp(start, end, max_eirp,
2602 results);
2603 }
2604
2605 nla_for_each_nested(nl_rule, tb_msg[NL80211_ATTR_REG_RULES], rem_rule)
2606 {
2607 nla_parse(tb_rule, NL80211_FREQUENCY_ATTR_MAX,
2608 nla_data(nl_rule), nla_len(nl_rule), reg_policy);
2609 nl80211_reg_rule_sec(tb_rule, results);
2610 }
2611
2612 nla_for_each_nested(nl_rule, tb_msg[NL80211_ATTR_REG_RULES], rem_rule)
2613 {
2614 nla_parse(tb_rule, NL80211_FREQUENCY_ATTR_MAX,
2615 nla_data(nl_rule), nla_len(nl_rule), reg_policy);
2616 nl80211_reg_rule_vht(tb_rule, results);
2617 }
2618
2619 nla_for_each_nested(nl_rule, tb_msg[NL80211_ATTR_REG_RULES], rem_rule)
2620 {
2621 nla_parse(tb_rule, NL80211_FREQUENCY_ATTR_MAX,
2622 nla_data(nl_rule), nla_len(nl_rule), reg_policy);
2623 nl80211_reg_rule_6ghz(tb_rule, results);
2624 }
2625
2626 return NL_SKIP;
2627 }
2628
2629
nl80211_set_regulatory_flags(struct wpa_driver_nl80211_data * drv,struct phy_info_arg * results)2630 static int nl80211_set_regulatory_flags(struct wpa_driver_nl80211_data *drv,
2631 struct phy_info_arg *results)
2632 {
2633 struct nl_msg *msg;
2634
2635 msg = nlmsg_alloc();
2636 if (!msg)
2637 return -ENOMEM;
2638
2639 nl80211_cmd(drv, msg, 0, NL80211_CMD_GET_REG);
2640 if (drv->capa.flags & WPA_DRIVER_FLAGS_SELF_MANAGED_REGULATORY) {
2641 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, drv->wiphy_idx)) {
2642 nlmsg_free(msg);
2643 return -1;
2644 }
2645 }
2646
2647 return send_and_recv_resp(drv, msg, nl80211_get_reg, results);
2648 }
2649
2650
modestr(enum hostapd_hw_mode mode)2651 static const char * modestr(enum hostapd_hw_mode mode)
2652 {
2653 switch (mode) {
2654 case HOSTAPD_MODE_IEEE80211B:
2655 return "802.11b";
2656 case HOSTAPD_MODE_IEEE80211G:
2657 return "802.11g";
2658 case HOSTAPD_MODE_IEEE80211A:
2659 return "802.11a";
2660 case HOSTAPD_MODE_IEEE80211AD:
2661 return "802.11ad";
2662 default:
2663 return "?";
2664 }
2665 }
2666
2667
nl80211_dump_chan_list(struct wpa_driver_nl80211_data * drv,struct hostapd_hw_modes * modes,u16 num_modes)2668 static void nl80211_dump_chan_list(struct wpa_driver_nl80211_data *drv,
2669 struct hostapd_hw_modes *modes,
2670 u16 num_modes)
2671 {
2672 int i;
2673
2674 if (!modes)
2675 return;
2676
2677 for (i = 0; i < num_modes; i++) {
2678 struct hostapd_hw_modes *mode = &modes[i];
2679 char str[1000];
2680 char *pos = str;
2681 char *end = pos + sizeof(str);
2682 int j, res;
2683
2684 for (j = 0; j < mode->num_channels; j++) {
2685 struct hostapd_channel_data *chan = &mode->channels[j];
2686
2687 if (is_6ghz_freq(chan->freq))
2688 drv->uses_6ghz = true;
2689 if (chan->freq >= 900 && chan->freq < 1000)
2690 drv->uses_s1g = true;
2691 res = os_snprintf(pos, end - pos, " %d%s%s%s",
2692 chan->freq,
2693 (chan->flag & HOSTAPD_CHAN_DISABLED) ?
2694 "[DISABLED]" : "",
2695 (chan->flag & HOSTAPD_CHAN_NO_IR) ?
2696 "[NO_IR]" : "",
2697 (chan->flag & HOSTAPD_CHAN_RADAR) ?
2698 "[RADAR]" : "");
2699 if (os_snprintf_error(end - pos, res))
2700 break;
2701 pos += res;
2702 }
2703
2704 *pos = '\0';
2705 wpa_printf(MSG_DEBUG, "nl80211: Mode IEEE %s:%s",
2706 modestr(mode->mode), str);
2707 }
2708 }
2709
2710
2711 struct hostapd_hw_modes *
nl80211_get_hw_feature_data(void * priv,u16 * num_modes,u16 * flags,u8 * dfs_domain)2712 nl80211_get_hw_feature_data(void *priv, u16 *num_modes, u16 *flags,
2713 u8 *dfs_domain)
2714 {
2715 u32 feat;
2716 struct i802_bss *bss = priv;
2717 struct wpa_driver_nl80211_data *drv = bss->drv;
2718 int nl_flags = 0;
2719 struct nl_msg *msg;
2720 struct phy_info_arg result = {
2721 .num_modes = num_modes,
2722 .modes = NULL,
2723 .last_mode = -1,
2724 .failed = 0,
2725 .dfs_domain = 0,
2726 };
2727
2728 *num_modes = 0;
2729 *flags = 0;
2730 *dfs_domain = 0;
2731
2732 feat = get_nl80211_protocol_features(drv);
2733 if (feat & NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP)
2734 nl_flags = NLM_F_DUMP;
2735 if (!(msg = nl80211_cmd_msg(bss, nl_flags, NL80211_CMD_GET_WIPHY)) ||
2736 nla_put_flag(msg, NL80211_ATTR_SPLIT_WIPHY_DUMP)) {
2737 nlmsg_free(msg);
2738 return NULL;
2739 }
2740
2741 if (send_and_recv_resp(drv, msg, phy_info_handler, &result) == 0) {
2742 struct hostapd_hw_modes *modes;
2743
2744 nl80211_set_regulatory_flags(drv, &result);
2745 if (result.failed) {
2746 int i;
2747
2748 for (i = 0; result.modes && i < *num_modes; i++) {
2749 os_free(result.modes[i].channels);
2750 os_free(result.modes[i].rates);
2751 }
2752 os_free(result.modes);
2753 *num_modes = 0;
2754 return NULL;
2755 }
2756
2757 *dfs_domain = result.dfs_domain;
2758
2759 modes = wpa_driver_nl80211_postprocess_modes(result.modes,
2760 num_modes);
2761 nl80211_dump_chan_list(drv, modes, *num_modes);
2762 return modes;
2763 }
2764
2765 return NULL;
2766 }
2767
2768
phy_multi_hw_info_parse(struct hostapd_multi_hw_info * hw_info,struct nlattr * radio_attr)2769 static int phy_multi_hw_info_parse(struct hostapd_multi_hw_info *hw_info,
2770 struct nlattr *radio_attr)
2771 {
2772 struct nlattr *tb_freq[NL80211_WIPHY_RADIO_FREQ_ATTR_MAX + 1];
2773 int start_freq, end_freq;
2774
2775 switch (nla_type(radio_attr)) {
2776 case NL80211_WIPHY_RADIO_ATTR_INDEX:
2777 hw_info->hw_idx = nla_get_u32(radio_attr);
2778 return NL_OK;
2779 case NL80211_WIPHY_RADIO_ATTR_FREQ_RANGE:
2780 if (nla_parse_nested(tb_freq, NL80211_WIPHY_RADIO_FREQ_ATTR_MAX,
2781 radio_attr, NULL) ||
2782 !tb_freq[NL80211_WIPHY_RADIO_FREQ_ATTR_START] ||
2783 !tb_freq[NL80211_WIPHY_RADIO_FREQ_ATTR_END])
2784 return NL_STOP;
2785
2786 start_freq = nla_get_u32(
2787 tb_freq[NL80211_WIPHY_RADIO_FREQ_ATTR_START]);
2788 end_freq = nla_get_u32(
2789 tb_freq[NL80211_WIPHY_RADIO_FREQ_ATTR_END]);
2790
2791 /* Convert to MHz and store */
2792 hw_info->start_freq = start_freq / 1000;
2793 hw_info->end_freq = end_freq / 1000;
2794 return NL_OK;
2795 default:
2796 return NL_OK;
2797 }
2798 }
2799
2800
2801 struct phy_multi_hw_info_arg {
2802 bool failed;
2803 unsigned int *num_multi_hws;
2804 struct hostapd_multi_hw_info *multi_hws;
2805 };
2806
2807
phy_multi_hw_info_handler(struct nl_msg * msg,void * arg)2808 static int phy_multi_hw_info_handler(struct nl_msg *msg, void *arg)
2809 {
2810 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
2811 struct phy_multi_hw_info_arg *multi_hw_info = arg;
2812 struct hostapd_multi_hw_info *multi_hws, hw_info;
2813 struct nlattr *tb_msg[NL80211_ATTR_MAX + 1];
2814 struct nlattr *nl_hw, *radio_attr;
2815 int rem_hw, rem_radio_prop, res;
2816
2817 nla_parse(tb_msg, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
2818 genlmsg_attrlen(gnlh, 0), NULL);
2819
2820 if (!tb_msg[NL80211_ATTR_WIPHY_RADIOS])
2821 return NL_SKIP;
2822
2823 *multi_hw_info->num_multi_hws = 0;
2824
2825 nla_for_each_nested(nl_hw, tb_msg[NL80211_ATTR_WIPHY_RADIOS], rem_hw) {
2826 os_memset(&hw_info, 0, sizeof(hw_info));
2827
2828 nla_for_each_nested(radio_attr, nl_hw, rem_radio_prop) {
2829 res = phy_multi_hw_info_parse(&hw_info, radio_attr);
2830 if (res != NL_OK)
2831 goto out;
2832 }
2833
2834 if (hw_info.start_freq == 0 || hw_info.end_freq == 0)
2835 goto out;
2836
2837 multi_hws = os_realloc_array(multi_hw_info->multi_hws,
2838 *multi_hw_info->num_multi_hws + 1,
2839 sizeof(*multi_hws));
2840 if (!multi_hws)
2841 goto out;
2842
2843 multi_hw_info->multi_hws = multi_hws;
2844 os_memcpy(&multi_hws[*(multi_hw_info->num_multi_hws)],
2845 &hw_info, sizeof(struct hostapd_multi_hw_info));
2846 *(multi_hw_info->num_multi_hws) += 1;
2847 }
2848
2849 return NL_OK;
2850 out:
2851 multi_hw_info->failed = true;
2852 return NL_STOP;
2853 }
2854
2855
2856 struct hostapd_multi_hw_info *
nl80211_get_multi_hw_info(struct i802_bss * bss,unsigned int * num_multi_hws)2857 nl80211_get_multi_hw_info(struct i802_bss *bss, unsigned int *num_multi_hws)
2858 {
2859 u32 feat;
2860 struct wpa_driver_nl80211_data *drv = bss->drv;
2861 int nl_flags = 0;
2862 struct nl_msg *msg;
2863 struct phy_multi_hw_info_arg result = {
2864 .failed = false,
2865 .num_multi_hws = num_multi_hws,
2866 .multi_hws = NULL,
2867 };
2868
2869 *num_multi_hws = 0;
2870
2871 if (!drv->has_capability || !(drv->capa.flags2 & WPA_DRIVER_FLAGS2_MLO))
2872 return NULL;
2873
2874 feat = get_nl80211_protocol_features(drv);
2875 if (feat & NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP)
2876 nl_flags = NLM_F_DUMP;
2877 if (!(msg = nl80211_cmd_msg(bss, nl_flags, NL80211_CMD_GET_WIPHY)) ||
2878 nla_put_flag(msg, NL80211_ATTR_SPLIT_WIPHY_DUMP)) {
2879 nlmsg_free(msg);
2880 return NULL;
2881 }
2882
2883 if (send_and_recv_resp(drv, msg, phy_multi_hw_info_handler,
2884 &result) == 0) {
2885 if (result.failed) {
2886 os_free(result.multi_hws);
2887 *num_multi_hws = 0;
2888 return NULL;
2889 }
2890
2891 return result.multi_hws;
2892 }
2893
2894 return NULL;
2895 }
2896