1 /* 2 * Copyright (c) 2017-2021 The Linux Foundation. All rights reserved. 3 * Copyright (c) 2021-2024 Qualcomm Innovation Center, Inc. All rights reserved. 4 * 5 * Permission to use, copy, modify, and/or distribute this software for 6 * any purpose with or without fee is hereby granted, provided that the 7 * above copyright notice and this permission notice appear in all 8 * copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 11 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 12 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 13 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 14 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 15 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 16 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 17 * PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20 /* 21 * DOC: contains scan public utility functions 22 */ 23 24 #ifndef _WLAN_SCAN_UTILS_H_ 25 #define _WLAN_SCAN_UTILS_H_ 26 27 #include <wlan_objmgr_cmn.h> 28 #include <qdf_mc_timer.h> 29 #include <wlan_objmgr_psoc_obj.h> 30 #include <wlan_objmgr_pdev_obj.h> 31 #include <wlan_objmgr_vdev_obj.h> 32 #include <wlan_scan_public_structs.h> 33 #include<wlan_mgmt_txrx_utils_api.h> 34 #include <wlan_reg_services_api.h> 35 #ifdef WLAN_FEATURE_11BE_MLO 36 #include "wlan_mlo_mgr_public_structs.h" 37 #endif 38 39 #define ASCII_SPACE_CHARACTER 32 40 41 /** 42 * util_is_scan_entry_match() - func to check if both scan entry 43 * are from same AP 44 * @entry1: scan entry 1 45 * @entry2: scan entry 2 46 * 47 * match the two scan entries 48 * 49 * Return: true if entry match else false. 50 */ 51 bool util_is_scan_entry_match( 52 struct scan_cache_entry *entry1, 53 struct scan_cache_entry *entry2); 54 55 /** 56 * util_scan_unpack_beacon_frame() - func to unpack beacon frame to scan entry 57 * @pdev: pdev pointer 58 * @frame: beacon/probe frame 59 * @frame_len: beacon frame len 60 * @frm_subtype: beacon or probe 61 * @rx_param: rx meta data 62 * 63 * get the defaults scan params 64 * 65 * Return: unpacked list of scan entries. 66 */ 67 qdf_list_t *util_scan_unpack_beacon_frame( 68 struct wlan_objmgr_pdev *pdev, 69 uint8_t *frame, qdf_size_t frame_len, uint32_t frm_subtype, 70 struct mgmt_rx_event_params *rx_param); 71 72 /** 73 * util_scan_add_hidden_ssid() - func to add hidden ssid 74 * @pdev: pdev pointer 75 * @bcnbuf: beacon buf 76 * 77 * Return: QDF_STATUS_SUCCESS on success, otherwise a QDF_STATUS error 78 */ 79 #ifdef WLAN_DFS_CHAN_HIDDEN_SSID 80 QDF_STATUS 81 util_scan_add_hidden_ssid(struct wlan_objmgr_pdev *pdev, qdf_nbuf_t bcnbuf); 82 #else 83 static inline QDF_STATUS 84 util_scan_add_hidden_ssid(struct wlan_objmgr_pdev *pdev, qdf_nbuf_t bcnbuf) 85 { 86 return QDF_STATUS_SUCCESS; 87 } 88 #endif /* WLAN_DFS_CHAN_HIDDEN_SSID */ 89 90 /** 91 * util_scan_get_ev_type_name() - converts enum event to printable string 92 * @event: event of type scan_event_type 93 * 94 * API, converts enum event to printable character string 95 * 96 * Return: pointer to printable string 97 */ 98 const char *util_scan_get_ev_type_name(enum scan_event_type event); 99 100 /** 101 * util_scan_get_ev_reason_name() - converts enum reason to printable string 102 * @reason: enum of scan completion reason 103 * 104 * API, converts enum event to printable character string 105 * 106 * Return: pointer to printable string 107 */ 108 const char *util_scan_get_ev_reason_name(enum scan_completion_reason reason); 109 110 /** 111 * util_scan_entry_macaddr() - function to read transmitter address 112 * @scan_entry: scan entry 113 * 114 * API, function to read transmitter address of scan entry 115 * 116 * Return: pointer to mac address 117 */ 118 static inline uint8_t* 119 util_scan_entry_macaddr(struct scan_cache_entry *scan_entry) 120 { 121 return &(scan_entry->mac_addr.bytes[0]); 122 } 123 124 #ifdef WLAN_FEATURE_11BE_MLO 125 /** 126 * util_scan_entry_mldaddr() - Function to get MLD address 127 * @scan_entry: Scan entry 128 * 129 * API will return the MLD address of the scan entry. 130 * 131 * Return: Pointer to MLD address. 132 */ 133 134 static inline struct qdf_mac_addr * 135 util_scan_entry_mldaddr(struct scan_cache_entry *scan_entry) 136 { 137 struct qdf_mac_addr *mld_addr = &scan_entry->ml_info.mld_mac_addr; 138 139 if (qdf_is_macaddr_zero(mld_addr)) 140 return NULL; 141 142 return mld_addr; 143 } 144 #else 145 static inline struct qdf_mac_addr * 146 util_scan_entry_mldaddr(struct scan_cache_entry *scan_entry) 147 { 148 return NULL; 149 } 150 #endif 151 152 /** 153 * util_scan_entry_bssid() - function to read bssid 154 * @scan_entry: scan entry 155 * 156 * API, function to read bssid of scan entry 157 * 158 * Return: pointer to mac address 159 */ 160 static inline uint8_t* 161 util_scan_entry_bssid(struct scan_cache_entry *scan_entry) 162 { 163 return &(scan_entry->bssid.bytes[0]); 164 } 165 166 /** 167 * util_scan_entry_capinfo() - function to read capibility info 168 * @scan_entry: scan entry 169 * 170 * API, function to read capibility info of scan entry 171 * 172 * Return: capability info 173 */ 174 static inline union wlan_capability 175 util_scan_entry_capinfo(struct scan_cache_entry *scan_entry) 176 { 177 return scan_entry->cap_info; 178 } 179 180 /** 181 * util_scan_entry_beacon_interval() - function to read beacon interval 182 * @scan_entry: scan entry 183 * 184 * API, function to read beacon interval of scan entry 185 * 186 * Return: beacon interval 187 */ 188 static inline uint16_t 189 util_scan_entry_beacon_interval(struct scan_cache_entry *scan_entry) 190 { 191 return scan_entry->bcn_int; 192 } 193 194 /** 195 * util_scan_entry_sequence_number() - function to read sequence number 196 * @scan_entry: scan entry 197 * 198 * API, function to read sequence number of scan entry 199 * 200 * Return: sequence number 201 */ 202 static inline uint16_t 203 util_scan_entry_sequence_number(struct scan_cache_entry *scan_entry) 204 { 205 return scan_entry->seq_num; 206 } 207 208 /** 209 * util_scan_entry_tsf() - function to read tsf 210 * @scan_entry: scan entry 211 * 212 * API, function to read tsf of scan entry 213 * 214 * Return: tsf 215 */ 216 static inline uint8_t* 217 util_scan_entry_tsf(struct scan_cache_entry *scan_entry) 218 { 219 return scan_entry->tsf_info.data; 220 } 221 222 /** 223 * util_scan_entry_reset_timestamp() - function to reset bcn receive timestamp 224 * @scan_entry: scan entry 225 * 226 * API, function to reset bcn receive timestamp of scan entry 227 * 228 * Return: void 229 */ 230 static inline void 231 util_scan_entry_reset_timestamp(struct scan_cache_entry *scan_entry) 232 { 233 scan_entry->scan_entry_time = 0; 234 } 235 236 /* 237 * Macros used for RSSI calculation. 238 */ 239 #define WLAN_RSSI_AVERAGING_TIME (5 * 1000) /* 5 seconds */ 240 241 #define WLAN_RSSI_EP_MULTIPLIER (1<<7) /* pow2 to optimize out * and / */ 242 243 #define WLAN_RSSI_LPF_LEN 0 244 #define WLAN_RSSI_DUMMY_MARKER 0x127 245 246 #define WLAN_EP_MUL(x, mul) ((x) * (mul)) 247 248 #define WLAN_EP_RND(x, mul) ((((x)%(mul)) >= ((mul)/2)) ?\ 249 ((x) + ((mul) - 1)) / (mul) : (x)/(mul)) 250 251 #define WLAN_RSSI_GET(x) WLAN_EP_RND(x, WLAN_RSSI_EP_MULTIPLIER) 252 253 #define RSSI_LPF_THRESHOLD -20 254 255 256 #define WLAN_RSSI_OUT(x) (((x) != WLAN_RSSI_DUMMY_MARKER) ? \ 257 (WLAN_EP_RND((x), WLAN_RSSI_EP_MULTIPLIER)) : WLAN_RSSI_DUMMY_MARKER) 258 259 260 #define WLAN_RSSI_IN(x) (WLAN_EP_MUL((x), WLAN_RSSI_EP_MULTIPLIER)) 261 262 #define WLAN_LPF_RSSI(x, y, len) \ 263 ((x != WLAN_RSSI_DUMMY_MARKER) ? ((((x) << 3) + (y) - (x)) >> 3) : (y)) 264 265 #define WLAN_RSSI_LPF(x, y) do { \ 266 if ((y) < RSSI_LPF_THRESHOLD) \ 267 x = WLAN_LPF_RSSI((x), WLAN_RSSI_IN((y)), WLAN_RSSI_LPF_LEN); \ 268 } while (0) 269 270 #define WLAN_ABS_RSSI_LPF(x, y) do { \ 271 if ((y) >= (RSSI_LPF_THRESHOLD + WLAN_DEFAULT_NOISE_FLOOR)) \ 272 x = WLAN_LPF_RSSI((x), WLAN_RSSI_IN((y)), WLAN_RSSI_LPF_LEN); \ 273 } while (0) 274 275 #define WLAN_SNR_EP_MULTIPLIER BIT(7) /* pow2 to optimize out * and / */ 276 #define WLAN_SNR_DUMMY_MARKER 127 277 #define SNR_LPF_THRESHOLD 0 278 #define WLAN_SNR_LPF_LEN 10 279 280 #define WLAN_SNR_OUT(x) (((x) != WLAN_SNR_DUMMY_MARKER) ? \ 281 (WLAN_EP_RND((x), WLAN_SNR_EP_MULTIPLIER)) : WLAN_SNR_DUMMY_MARKER) 282 283 #define WLAN_SNR_IN(x) (WLAN_EP_MUL((x), WLAN_SNR_EP_MULTIPLIER)) 284 285 #define WLAN_LPF_SNR(x, y, len) \ 286 ((x != WLAN_SNR_DUMMY_MARKER) ? ((((x) << 3) + (y) - (x)) >> 3) : (y)) 287 288 #define WLAN_SNR_LPF(x, y) do { \ 289 if ((y) > SNR_LPF_THRESHOLD) \ 290 x = WLAN_LPF_SNR((x), WLAN_SNR_IN((y)), WLAN_SNR_LPF_LEN); \ 291 } while (0) 292 293 /** 294 * util_scan_entry_rssi() - function to read rssi of scan entry 295 * @scan_entry: scan entry 296 * 297 * API, function to read rssi value of scan entry 298 * 299 * Return: rssi 300 */ 301 static inline int32_t 302 util_scan_entry_rssi(struct scan_cache_entry *scan_entry) 303 { 304 return WLAN_RSSI_OUT(scan_entry->avg_rssi); 305 } 306 307 /** 308 * util_scan_entry_snr() - function to read snr of scan entry 309 * @scan_entry: scan entry 310 * 311 * API, function to read snr value of scan entry 312 * 313 * Return: snr 314 */ 315 static inline uint8_t 316 util_scan_entry_snr(struct scan_cache_entry *scan_entry) 317 { 318 uint32_t snr = WLAN_SNR_OUT(scan_entry->avg_snr); 319 /* 320 * An entry is in the BSS list means we've received at least one beacon 321 * from the corresponding AP, so the snr must be initialized. 322 * 323 * If the SNR is not initialized, return 0 (i.e. SNR == Noise Floor). 324 * Once se_avgsnr field has been initialized, ATH_SNR_OUT always 325 * returns values that fit in an 8-bit variable. 326 */ 327 return (snr >= WLAN_SNR_DUMMY_MARKER) ? 0 : (uint8_t)snr; 328 } 329 330 /** 331 * util_scan_entry_phymode() - function to read phymode of scan entry 332 * @scan_entry: scan entry 333 * 334 * API, function to read phymode of scan entry 335 * 336 * Return: phymode 337 */ 338 static inline enum wlan_phymode 339 util_scan_entry_phymode(struct scan_cache_entry *scan_entry) 340 { 341 return scan_entry->phy_mode; 342 } 343 344 /** 345 * util_scan_entry_nss() - function to read nss of scan entry 346 * @scan_entry: scan entry 347 * 348 * API, function to read nss of scan entry 349 * 350 * Return: nss 351 */ 352 static inline u_int8_t 353 util_scan_entry_nss(struct scan_cache_entry *scan_entry) 354 { 355 return scan_entry->nss; 356 } 357 358 /** 359 * util_is_ssid_match() - to check if ssid match 360 * @ssid1: ssid 1 361 * @ssid2: ssid 2 362 * 363 * Return: true if ssid match 364 */ 365 static inline bool 366 util_is_ssid_match(struct wlan_ssid *ssid1, 367 struct wlan_ssid *ssid2) 368 { 369 if (ssid1->length != ssid2->length) 370 return false; 371 372 if (!qdf_mem_cmp(ssid1->ssid, 373 ssid2->ssid, ssid1->length)) 374 return true; 375 376 return false; 377 } 378 379 /** 380 * util_is_bssid_match() - to check if bssid match 381 * @bssid1: bssid 1 382 * @bssid2: bssid 2 383 * 384 * Return: true if bssid match 385 */ 386 static inline bool util_is_bssid_match(struct qdf_mac_addr *bssid1, 387 struct qdf_mac_addr *bssid2) 388 { 389 390 if (qdf_is_macaddr_zero(bssid1) || 391 qdf_is_macaddr_broadcast(bssid1)) 392 return true; 393 394 if (qdf_is_macaddr_equal(bssid1, bssid2)) 395 return true; 396 397 return false; 398 } 399 400 /** 401 * util_is_bss_type_match() - to check if bss type 402 * @bss_type: bss type 403 * @cap: capability 404 * 405 * Return: true if bss type match 406 */ 407 static inline bool util_is_bss_type_match(enum wlan_bss_type bss_type, 408 union wlan_capability cap) 409 { 410 bool match = true; 411 412 switch (bss_type) { 413 case WLAN_TYPE_ANY: 414 break; 415 case WLAN_TYPE_IBSS: 416 if (!cap.wlan_caps.ibss) 417 match = false; 418 break; 419 case WLAN_TYPE_BSS: 420 if (!cap.wlan_caps.ess) 421 match = false; 422 break; 423 default: 424 match = false; 425 } 426 427 return match; 428 } 429 430 /** 431 * util_country_code_match() - to check if country match 432 * @country: country code pointer 433 * @cc: country IE in beacon 434 * 435 * Return: true if country match 436 */ 437 static inline bool util_country_code_match(uint8_t *country, 438 struct wlan_country_ie *cc) 439 { 440 if (!country || !country[0]) 441 return true; 442 443 if (!cc) 444 return false; 445 446 if (cc->cc[0] == country[0] && 447 cc->cc[1] == country[1]) 448 return true; 449 450 return false; 451 } 452 453 /** 454 * util_mdie_match() - to check if mdie match 455 * @mobility_domain: mobility domain 456 * @mdie: mobility domain ie 457 * 458 * Return: true if country match 459 */ 460 static inline bool util_mdie_match(uint16_t mobility_domain, 461 struct rsn_mdie *mdie) 462 { 463 uint16_t md; 464 465 if (!mobility_domain) 466 return true; 467 468 if (!mdie) 469 return false; 470 471 md = 472 (mdie->mobility_domain[1] << 8) | 473 mdie->mobility_domain[0]; 474 475 if (md == mobility_domain) 476 return true; 477 478 return false; 479 } 480 481 /** 482 * util_scan_entry_ssid() - function to read ssid of scan entry 483 * @scan_entry: scan entry 484 * 485 * API, function to read ssid of scan entry 486 * 487 * Return: ssid 488 */ 489 static inline struct wlan_ssid* 490 util_scan_entry_ssid(struct scan_cache_entry *scan_entry) 491 { 492 return &(scan_entry->ssid); 493 } 494 495 /** 496 * util_scan_entry_dtimperiod() - function to read dtim period of scan entry 497 * @scan_entry: scan entry 498 * 499 * API, function to read dtim period of scan entry 500 * 501 * Return: dtim period 502 */ 503 static inline uint8_t 504 util_scan_entry_dtimperiod(struct scan_cache_entry *scan_entry) 505 { 506 return scan_entry->dtim_period; 507 } 508 509 /** 510 * util_scan_entry_tim() - function to read tim ie of scan entry 511 * @scan_entry: scan entry 512 * 513 * API, function to read tim ie of scan entry 514 * 515 * Return: timie or NULL if ie is not present 516 */ 517 static inline uint8_t* 518 util_scan_entry_tim(struct scan_cache_entry *scan_entry) 519 { 520 return scan_entry->ie_list.tim; 521 } 522 523 /** 524 * util_scan_entry_beacon_frame() - function to read full beacon or 525 * probe resp frame 526 * @scan_entry: scan entry 527 * 528 * API, function to read full beacon or probe resp frame including frame header 529 * 530 * Return: beacon/probe resp frame 531 */ 532 static inline struct element_info 533 util_scan_entry_beacon_frame(struct scan_cache_entry *scan_entry) 534 { 535 /* util_scan_entry_beacon_data */ 536 return scan_entry->raw_frame; 537 } 538 539 /** 540 * util_scan_entry_ie_data() - function to read tagged IEs 541 * @scan_entry: scan entry 542 * 543 * API, function to read beacon/probe response frames starting from tagged IEs 544 * (excluding frame header and fixed parameters) 545 * 546 * Return: tagged IES of beacon/probe resp frame 547 */ 548 static inline uint8_t* 549 util_scan_entry_ie_data(struct scan_cache_entry *scan_entry) 550 { 551 struct element_info bcn_frm; 552 uint8_t *ie_data = NULL; 553 554 bcn_frm = util_scan_entry_beacon_frame(scan_entry); 555 ie_data = (uint8_t *) (bcn_frm.ptr + 556 sizeof(struct wlan_frame_hdr) + 557 offsetof(struct wlan_bcn_frame, ie)); 558 return ie_data; 559 } 560 561 /** 562 * util_scan_entry_ie_len() - function to read length of all tagged IEs 563 * @scan_entry: scan entry 564 * 565 * API, function to read length of all tagged IEs 566 * 567 * Return: length of all tagged IEs 568 */ 569 static inline uint16_t 570 util_scan_entry_ie_len(struct scan_cache_entry *scan_entry) 571 { 572 struct element_info bcn_frm; 573 uint16_t ie_len = 0; 574 575 bcn_frm = util_scan_entry_beacon_frame(scan_entry); 576 ie_len = (uint16_t) (bcn_frm.len - 577 sizeof(struct wlan_frame_hdr) - 578 offsetof(struct wlan_bcn_frame, ie)); 579 return ie_len; 580 } 581 582 /** 583 * util_scan_entry_frame_len() - function to frame length 584 * @scan_entry: scan entry 585 * 586 * API, function to read frame length 587 * 588 * Return: frame length 589 */ 590 static inline uint32_t 591 util_scan_entry_frame_len(struct scan_cache_entry *scan_entry) 592 { 593 return scan_entry->raw_frame.len; 594 } 595 596 /** 597 * util_scan_entry_frame_ptr() - function to get frame ptr 598 * @scan_entry: scan entry 599 * 600 * API, function to read frame ptr 601 * 602 * Return: frame ptr 603 */ 604 static inline uint8_t* 605 util_scan_entry_frame_ptr(struct scan_cache_entry *scan_entry) 606 { 607 return scan_entry->raw_frame.ptr; 608 } 609 610 /** 611 * util_scan_entry_copy_ie_data() - function to get a copy of all tagged IEs 612 * @scan_entry: scan entry 613 * @iebuf: destination IE buffer. May be NULL if only the 614 * @ie_len: pointer to the ie buffer length. On input must hold the size of 615 * @iebuf. On output it will be filled with the length of the IEs. 616 * 617 * API, function to get a copy of all tagged IEs in passed memory 618 * 619 * Return: QDF_STATUS_SUCCESS if tagged IEs copied successfully 620 * QDF_STATUS_E_NOMEM if passed memory/length can't hold all tagged IEs 621 */ 622 static inline QDF_STATUS 623 util_scan_entry_copy_ie_data(struct scan_cache_entry *scan_entry, 624 uint8_t *iebuf, uint16_t *ie_len) 625 { 626 u_int8_t *buff; 627 u_int16_t buff_len; 628 629 /* iebuf can be NULL, ie_len must be a valid pointer. */ 630 QDF_ASSERT(ie_len); 631 if (!ie_len) 632 return QDF_STATUS_E_NULL_VALUE; 633 634 buff = util_scan_entry_ie_data(scan_entry); 635 buff_len = util_scan_entry_ie_len(scan_entry); 636 /* 637 * If caller passed a buffer, check the length to make sure 638 * it's large enough. 639 * If no buffer is passed, just return the length of the IE blob. 640 */ 641 if (iebuf) { 642 if (*ie_len >= buff_len) { 643 qdf_mem_copy(iebuf, buff, buff_len); 644 *ie_len = buff_len; 645 return QDF_STATUS_SUCCESS; 646 } 647 } 648 649 *ie_len = buff_len; 650 return QDF_STATUS_E_NOMEM; 651 } 652 653 /** 654 * util_scan_free_cache_entry() - function to free scan 655 * cache entry 656 * @scan_entry: scan entry 657 * 658 * API, function to free scan cache entry 659 * 660 * Return: void 661 */ 662 static inline void 663 util_scan_free_cache_entry(struct scan_cache_entry *scan_entry) 664 { 665 if (!scan_entry) 666 return; 667 if (scan_entry->alt_wcn_ie.ptr) 668 qdf_mem_free(scan_entry->alt_wcn_ie.ptr); 669 if (scan_entry->raw_frame.ptr) 670 qdf_mem_free(scan_entry->raw_frame.ptr); 671 672 qdf_mem_free(scan_entry); 673 } 674 675 #define conv_ptr(_address, _base1, _base2) \ 676 ((_address) ? (((u_int8_t *) (_address) - \ 677 (u_int8_t *) (_base1)) + (u_int8_t *) (_base2)) : NULL) 678 679 /** 680 * util_scan_copy_beacon_data() - copy beacon and update ie ptrs 681 * cache entry 682 * @new_entry: new scan entry 683 * @scan_entry: entry from where data is copied 684 * 685 * API, function to copy beacon and update ie ptrs 686 * 687 * Return: QDF_STATUS 688 */ 689 static inline QDF_STATUS 690 util_scan_copy_beacon_data(struct scan_cache_entry *new_entry, 691 struct scan_cache_entry *scan_entry) 692 { 693 u_int8_t *new_ptr, *old_ptr; 694 struct ie_list *ie_lst; 695 uint8_t i; 696 697 new_entry->raw_frame.ptr = 698 qdf_mem_malloc_atomic(scan_entry->raw_frame.len); 699 if (!new_entry->raw_frame.ptr) 700 return QDF_STATUS_E_NOMEM; 701 702 qdf_mem_copy(new_entry->raw_frame.ptr, 703 scan_entry->raw_frame.ptr, 704 scan_entry->raw_frame.len); 705 new_entry->raw_frame.len = scan_entry->raw_frame.len; 706 new_ptr = new_entry->raw_frame.ptr; 707 old_ptr = scan_entry->raw_frame.ptr; 708 709 new_entry->ie_list = scan_entry->ie_list; 710 711 ie_lst = &new_entry->ie_list; 712 713 /* New info_element needs also be added in ieee80211_parse_beacon */ 714 ie_lst->tim = conv_ptr(ie_lst->tim, old_ptr, new_ptr); 715 ie_lst->country = conv_ptr(ie_lst->country, old_ptr, new_ptr); 716 ie_lst->ssid = conv_ptr(ie_lst->ssid, old_ptr, new_ptr); 717 ie_lst->rates = conv_ptr(ie_lst->rates, old_ptr, new_ptr); 718 ie_lst->xrates = conv_ptr(ie_lst->xrates, old_ptr, new_ptr); 719 ie_lst->ds_param = conv_ptr(ie_lst->ds_param, old_ptr, new_ptr); 720 ie_lst->csa = conv_ptr(ie_lst->csa, old_ptr, new_ptr); 721 ie_lst->xcsa = conv_ptr(ie_lst->xcsa, old_ptr, new_ptr); 722 ie_lst->mcst = conv_ptr(ie_lst->mcst, old_ptr, new_ptr); 723 ie_lst->secchanoff = conv_ptr(ie_lst->secchanoff, old_ptr, new_ptr); 724 ie_lst->wpa = conv_ptr(ie_lst->wpa, old_ptr, new_ptr); 725 ie_lst->wcn = conv_ptr(ie_lst->wcn, old_ptr, new_ptr); 726 ie_lst->rsn = conv_ptr(ie_lst->rsn, old_ptr, new_ptr); 727 ie_lst->wps = conv_ptr(ie_lst->wps, old_ptr, new_ptr); 728 ie_lst->wmeinfo = conv_ptr(ie_lst->wmeinfo, old_ptr, new_ptr); 729 ie_lst->wmeparam = conv_ptr(ie_lst->wmeparam, old_ptr, new_ptr); 730 ie_lst->quiet = conv_ptr(ie_lst->quiet, old_ptr, new_ptr); 731 ie_lst->htcap = conv_ptr(ie_lst->htcap, old_ptr, new_ptr); 732 ie_lst->htinfo = conv_ptr(ie_lst->htinfo, old_ptr, new_ptr); 733 ie_lst->athcaps = conv_ptr(ie_lst->athcaps, old_ptr, new_ptr); 734 ie_lst->athextcaps = conv_ptr(ie_lst->athextcaps, old_ptr, new_ptr); 735 ie_lst->sfa = conv_ptr(ie_lst->sfa, old_ptr, new_ptr); 736 ie_lst->vendor = conv_ptr(ie_lst->vendor, old_ptr, new_ptr); 737 ie_lst->qbssload = conv_ptr(ie_lst->qbssload, old_ptr, new_ptr); 738 ie_lst->wapi = conv_ptr(ie_lst->wapi, old_ptr, new_ptr); 739 ie_lst->p2p = conv_ptr(ie_lst->p2p, old_ptr, new_ptr); 740 ie_lst->alt_wcn = conv_ptr(ie_lst->alt_wcn, old_ptr, new_ptr); 741 ie_lst->extcaps = conv_ptr(ie_lst->extcaps, old_ptr, new_ptr); 742 ie_lst->ibssdfs = conv_ptr(ie_lst->ibssdfs, old_ptr, new_ptr); 743 ie_lst->sonadv = conv_ptr(ie_lst->sonadv, old_ptr, new_ptr); 744 ie_lst->vhtcap = conv_ptr(ie_lst->vhtcap, old_ptr, new_ptr); 745 ie_lst->vhtop = conv_ptr(ie_lst->vhtop, old_ptr, new_ptr); 746 ie_lst->opmode = conv_ptr(ie_lst->opmode, old_ptr, new_ptr); 747 ie_lst->cswrp = conv_ptr(ie_lst->cswrp, old_ptr, new_ptr); 748 for (i = 0; i < WLAN_MAX_NUM_TPE_IE; i++) 749 ie_lst->tpe[i] = conv_ptr(ie_lst->tpe[i], old_ptr, new_ptr); 750 ie_lst->widebw = conv_ptr(ie_lst->widebw, old_ptr, new_ptr); 751 ie_lst->txpwrenvlp = conv_ptr(ie_lst->txpwrenvlp, old_ptr, new_ptr); 752 ie_lst->bwnss_map = conv_ptr(ie_lst->bwnss_map, old_ptr, new_ptr); 753 ie_lst->mdie = conv_ptr(ie_lst->mdie, old_ptr, new_ptr); 754 ie_lst->hecap = conv_ptr(ie_lst->hecap, old_ptr, new_ptr); 755 ie_lst->hecap_6g = conv_ptr(ie_lst->hecap_6g, old_ptr, new_ptr); 756 ie_lst->heop = conv_ptr(ie_lst->heop, old_ptr, new_ptr); 757 ie_lst->srp = conv_ptr(ie_lst->srp, old_ptr, new_ptr); 758 ie_lst->fils_indication = conv_ptr(ie_lst->fils_indication, 759 old_ptr, new_ptr); 760 ie_lst->esp = conv_ptr(ie_lst->esp, old_ptr, new_ptr); 761 ie_lst->mbo_oce = conv_ptr(ie_lst->mbo_oce, old_ptr, new_ptr); 762 ie_lst->muedca = conv_ptr(ie_lst->muedca, old_ptr, new_ptr); 763 ie_lst->rnrie = conv_ptr(ie_lst->rnrie, old_ptr, new_ptr); 764 ie_lst->extender = conv_ptr(ie_lst->extender, old_ptr, new_ptr); 765 ie_lst->adaptive_11r = conv_ptr(ie_lst->adaptive_11r, old_ptr, new_ptr); 766 ie_lst->single_pmk = conv_ptr(ie_lst->single_pmk, old_ptr, new_ptr); 767 ie_lst->rsnxe = conv_ptr(ie_lst->rsnxe, old_ptr, new_ptr); 768 #ifdef WLAN_FEATURE_11BE 769 /* This macro will be removed once 11be is enabled */ 770 ie_lst->ehtcap = conv_ptr(ie_lst->ehtcap, old_ptr, new_ptr); 771 ie_lst->ehtop = conv_ptr(ie_lst->ehtop, old_ptr, new_ptr); 772 ie_lst->bw_ind = 773 conv_ptr(ie_lst->bw_ind, old_ptr, new_ptr); 774 #endif 775 #ifdef WLAN_FEATURE_11BE_MLO 776 ie_lst->multi_link_bv = 777 conv_ptr(ie_lst->multi_link_bv, old_ptr, new_ptr); 778 ie_lst->multi_link_rv = 779 conv_ptr(ie_lst->multi_link_rv, old_ptr, new_ptr); 780 for (i = 0; i < WLAN_MAX_T2LM_IE; i++) 781 ie_lst->t2lm[i] = conv_ptr(ie_lst->t2lm[i], old_ptr, new_ptr); 782 #endif 783 ie_lst->qcn = conv_ptr(ie_lst->qcn, old_ptr, new_ptr); 784 785 return QDF_STATUS_SUCCESS; 786 } 787 788 #ifdef WLAN_FEATURE_11BE_MLO 789 /** 790 * util_scan_get_ml_partner_info() - Get partner links info of an ML connection 791 * @scan_entry: scan entry 792 * @partner_info: partner link info 793 * 794 * API, function to get partner link information from an ML scan cache entry 795 * 796 * Return: QDF_STATUS 797 */ 798 static inline QDF_STATUS 799 util_scan_get_ml_partner_info(struct scan_cache_entry *scan_entry, 800 struct mlo_partner_info *partner_info) 801 { 802 uint8_t i; 803 804 if (!scan_entry->ml_info.num_links) 805 return QDF_STATUS_E_FAILURE; 806 807 partner_info->num_partner_links = 808 scan_entry->ml_info.num_links; 809 /* TODO: Make sure that scan_entry->ml_info->link_info is a sorted 810 * list */ 811 for (i = 0; i < partner_info->num_partner_links; i++) { 812 partner_info->partner_link_info[i].link_addr = 813 scan_entry->ml_info.link_info[i].link_addr; 814 partner_info->partner_link_info[i].link_id = 815 scan_entry->ml_info.link_info[i].link_id; 816 } 817 818 return QDF_STATUS_SUCCESS; 819 } 820 #endif 821 822 /** 823 * util_scan_copy_cache_entry() - function to create a copy 824 * of scan cache entry 825 * @scan_entry: scan entry 826 * 827 * API, function to create a copy of scan cache entry 828 * 829 * Return: copy of scan_entry 830 */ 831 static inline struct scan_cache_entry * 832 util_scan_copy_cache_entry(struct scan_cache_entry *scan_entry) 833 { 834 struct scan_cache_entry *new_entry; 835 QDF_STATUS status; 836 837 if (!scan_entry) 838 return NULL; 839 840 new_entry = 841 qdf_mem_malloc_atomic(sizeof(*scan_entry)); 842 if (!new_entry) 843 return NULL; 844 845 qdf_mem_copy(new_entry, 846 scan_entry, sizeof(*scan_entry)); 847 848 if (scan_entry->alt_wcn_ie.ptr) { 849 new_entry->alt_wcn_ie.ptr = 850 qdf_mem_malloc_atomic(scan_entry->alt_wcn_ie.len); 851 if (!new_entry->alt_wcn_ie.ptr) { 852 qdf_mem_free(new_entry); 853 return NULL; 854 } 855 qdf_mem_copy(new_entry->alt_wcn_ie.ptr, 856 scan_entry->alt_wcn_ie.ptr, 857 scan_entry->alt_wcn_ie.len); 858 new_entry->alt_wcn_ie.len = 859 scan_entry->alt_wcn_ie.len; 860 } 861 862 status = util_scan_copy_beacon_data(new_entry, scan_entry); 863 if (QDF_IS_STATUS_ERROR(status)) { 864 util_scan_free_cache_entry(new_entry); 865 return NULL; 866 } 867 868 return new_entry; 869 } 870 871 /** 872 * util_scan_entry_channel() - function to read channel info 873 * @scan_entry: scan entry 874 * 875 * API, function to read channel info 876 * 877 * Return: channel info 878 */ 879 static inline struct channel_info* 880 util_scan_entry_channel(struct scan_cache_entry *scan_entry) 881 { 882 return &(scan_entry->channel); 883 } 884 885 /** 886 * util_scan_entry_channel_frequency() - function to read channel number 887 * @scan_entry: scan entry 888 * 889 * API, function to read channel number 890 * 891 * Return: channel number 892 */ 893 static inline uint32_t 894 util_scan_entry_channel_frequency(struct scan_cache_entry *scan_entry) 895 { 896 return scan_entry->channel.chan_freq; 897 } 898 899 /** 900 * util_scan_entry_erpinfo() - function to read erp info 901 * @scan_entry: scan entry 902 * 903 * API, function to read erp info 904 * 905 * Return: erp info 906 */ 907 static inline uint8_t 908 util_scan_entry_erpinfo(struct scan_cache_entry *scan_entry) 909 { 910 return scan_entry->erp; 911 } 912 913 /** 914 * util_scan_entry_rates() - function to read supported rates IE 915 * @scan_entry: scan entry 916 * 917 * API, function to read supported rates IE 918 * 919 * Return: basic ratesie or NULL if ie is not present 920 */ 921 static inline uint8_t* 922 util_scan_entry_rates(struct scan_cache_entry *scan_entry) 923 { 924 return scan_entry->ie_list.rates; 925 } 926 927 /** 928 * util_scan_entry_xrates()- function to read extended supported rates IE 929 * @scan_entry: scan entry 930 * 931 * API, function to read extended supported rates IE 932 * 933 * Return: extended supported ratesie or NULL if ie is not present 934 */ 935 static inline uint8_t* 936 util_scan_entry_xrates(struct scan_cache_entry *scan_entry) 937 { 938 return scan_entry->ie_list.xrates; 939 } 940 941 /** 942 * util_scan_entry_rsn()- function to read rsn IE 943 * @scan_entry: scan entry 944 * 945 * API, function to read rsn IE 946 * 947 * Return: rsnie or NULL if ie is not present 948 */ 949 static inline uint8_t* 950 util_scan_entry_rsn(struct scan_cache_entry *scan_entry) 951 { 952 return scan_entry->ie_list.rsn; 953 } 954 955 /** 956 * util_scan_entry_adaptive_11r()- function to read adaptive 11r Vendor IE 957 * @scan_entry: scan entry 958 * 959 * API, function to read adaptive 11r IE 960 * 961 * Return: apaptive 11r ie or NULL if ie is not present 962 */ 963 static inline uint8_t* 964 util_scan_entry_adaptive_11r(struct scan_cache_entry *scan_entry) 965 { 966 return scan_entry->ie_list.adaptive_11r; 967 } 968 969 #if defined(WLAN_SAE_SINGLE_PMK) && defined(WLAN_FEATURE_ROAM_OFFLOAD) 970 /** 971 * util_scan_entry_single_pmk()- function to read single pmk Vendor IE 972 * @psoc: Pointer to global psoc object 973 * @scan_entry: scan entry 974 * 975 * API, function to read sae single pmk IE 976 * 977 * Return: true if single_pmk ie is present or false if ie is not present 978 */ 979 bool 980 util_scan_entry_single_pmk(struct wlan_objmgr_psoc *psoc, 981 struct scan_cache_entry *scan_entry); 982 #else 983 static inline bool 984 util_scan_entry_single_pmk(struct wlan_objmgr_psoc *psoc, 985 struct scan_cache_entry *scan_entry) 986 { 987 return false; 988 } 989 #endif 990 991 /** 992 * util_scan_get_rsn_len()- function to read rsn IE length if present 993 * @scan_entry: scan entry 994 * 995 * API, function to read rsn length if present 996 * 997 * Return: rsnie length 998 */ 999 static inline uint8_t 1000 util_scan_get_rsn_len(struct scan_cache_entry *scan_entry) 1001 { 1002 if (scan_entry && scan_entry->ie_list.rsn) 1003 return scan_entry->ie_list.rsn[1] + 2; 1004 else 1005 return 0; 1006 } 1007 1008 1009 /** 1010 * util_scan_entry_wpa() - function to read wpa IE 1011 * @scan_entry: scan entry 1012 * 1013 * API, function to read wpa IE 1014 * 1015 * Return: wpaie or NULL if ie is not present 1016 */ 1017 static inline uint8_t* 1018 util_scan_entry_wpa(struct scan_cache_entry *scan_entry) 1019 { 1020 return scan_entry->ie_list.wpa; 1021 } 1022 1023 /** 1024 * util_scan_get_wpa_len()- function to read wpa IE length if present 1025 * @scan_entry: scan entry 1026 * 1027 * API, function to read wpa ie length if present 1028 * 1029 * Return: wpa ie length 1030 */ 1031 static inline uint8_t 1032 util_scan_get_wpa_len(struct scan_cache_entry *scan_entry) 1033 { 1034 if (scan_entry && scan_entry->ie_list.wpa) 1035 return scan_entry->ie_list.wpa[1] + 2; 1036 else 1037 return 0; 1038 } 1039 1040 1041 /** 1042 * util_scan_entry_wapi() - function to read wapi IE 1043 * @scan_entry: scan entry 1044 * 1045 * API, function to read wapi IE 1046 * 1047 * Return: wapiie or NULL if ie is not present 1048 */ 1049 static inline uint8_t* 1050 util_scan_entry_wapi(struct scan_cache_entry *scan_entry) 1051 { 1052 return scan_entry->ie_list.wapi; 1053 } 1054 1055 /** 1056 * util_scan_entry_wps() - function to read wps IE 1057 * @scan_entry: scan entry 1058 * 1059 * API, function to read wps IE 1060 * 1061 * Return: wpsie or NULL if ie is not present 1062 */ 1063 static inline uint8_t* 1064 util_scan_entry_wps(struct scan_cache_entry *scan_entry) 1065 { 1066 return scan_entry->ie_list.wps; 1067 } 1068 1069 /** 1070 * util_scan_entry_sfa() - function to read sfa IE 1071 * @scan_entry: scan entry 1072 * 1073 * API, function to read sfa IE 1074 * 1075 * Return: sfaie or NULL if ie is not present 1076 */ 1077 static inline uint8_t* 1078 util_scan_entry_sfa(struct scan_cache_entry *scan_entry) 1079 { 1080 return scan_entry->ie_list.sfa; 1081 } 1082 1083 /** 1084 * util_scan_entry_ds_param() - function to read ds params 1085 * @scan_entry: scan entry 1086 * 1087 * API, function to read ds params 1088 * 1089 * Return: ds params or NULL if ie is not present 1090 */ 1091 static inline uint8_t* 1092 util_scan_entry_ds_param(struct scan_cache_entry *scan_entry) 1093 { 1094 if (scan_entry) 1095 return scan_entry->ie_list.ds_param; 1096 else 1097 return NULL; 1098 } 1099 1100 /** 1101 * util_scan_entry_csa() - function to read csa IE 1102 * @scan_entry: scan entry 1103 * 1104 * API, function to read csa IE 1105 * 1106 * Return: csaie or NULL if ie is not present 1107 */ 1108 static inline uint8_t* 1109 util_scan_entry_csa(struct scan_cache_entry *scan_entry) 1110 { 1111 return scan_entry->ie_list.csa; 1112 } 1113 1114 /** 1115 * util_scan_entry_xcsa() - function to read extended csa IE 1116 * @scan_entry: scan entry 1117 * 1118 * API, function to read extended csa IE 1119 * 1120 * Return: extended csaie or NULL if ie is not present 1121 */ 1122 static inline uint8_t* 1123 util_scan_entry_xcsa(struct scan_cache_entry *scan_entry) 1124 { 1125 return scan_entry->ie_list.xcsa; 1126 } 1127 1128 /** 1129 * util_scan_entry_htinfo() - function to read htinfo IE 1130 * @scan_entry: scan entry 1131 * 1132 * API, function to read htinfo IE 1133 * 1134 * Return: htinfoie or NULL if ie is not present 1135 */ 1136 static inline uint8_t* 1137 util_scan_entry_htinfo(struct scan_cache_entry *scan_entry) 1138 { 1139 return scan_entry->ie_list.htinfo; 1140 } 1141 1142 1143 /** 1144 * util_scan_entry_htcap() - function to read htcap IE 1145 * @scan_entry: scan entry 1146 * 1147 * API, function to read htcap IE 1148 * 1149 * Return: htcapie or NULL if ie is not present 1150 */ 1151 static inline uint8_t* 1152 util_scan_entry_htcap(struct scan_cache_entry *scan_entry) 1153 { 1154 return scan_entry->ie_list.htcap; 1155 } 1156 1157 /** 1158 * util_scan_entry_vhtcap() - function to read vhtcap IE 1159 * @scan_entry: scan entry 1160 * 1161 * API, function to read vhtcap IE 1162 * 1163 * Return: vhtcapie or NULL if ie is not present 1164 */ 1165 static inline uint8_t* 1166 util_scan_entry_vhtcap(struct scan_cache_entry *scan_entry) 1167 { 1168 return scan_entry->ie_list.vhtcap; 1169 } 1170 1171 /** 1172 * util_scan_entry_vhtop() - function to read vhtop IE 1173 * @scan_entry: scan entry 1174 * 1175 * API, function to read vhtop IE 1176 * 1177 * Return: vhtopie or NULL if ie is not present 1178 */ 1179 static inline uint8_t* 1180 util_scan_entry_vhtop(struct scan_cache_entry *scan_entry) 1181 { 1182 return scan_entry->ie_list.vhtop; 1183 } 1184 1185 /** 1186 * util_scan_entry_quiet() - function to read quiet IE 1187 * @scan_entry: scan entry 1188 * 1189 * API, function to read quiet IE 1190 * 1191 * Return: quietie or NULL if ie is not present 1192 */ 1193 static inline uint8_t* 1194 util_scan_entry_quiet(struct scan_cache_entry *scan_entry) 1195 { 1196 return scan_entry->ie_list.quiet; 1197 } 1198 1199 /** 1200 * util_scan_entry_qbssload() - function to read qbss load IE 1201 * @scan_entry: scan entry 1202 * 1203 * API, function to read qbss load IE 1204 * 1205 * Return: qbss loadie or NULL if ie is not present 1206 */ 1207 static inline uint8_t* 1208 util_scan_entry_qbssload(struct scan_cache_entry *scan_entry) 1209 { 1210 return scan_entry->ie_list.qbssload; 1211 } 1212 1213 /** 1214 * util_scan_entry_vendor() - function to read vendor IE 1215 * @scan_entry: scan entry 1216 * 1217 * API, function to read vendor IE 1218 * 1219 * Return: vendorie or NULL if ie is not present 1220 */ 1221 static inline uint8_t* 1222 util_scan_entry_vendor(struct scan_cache_entry *scan_entry) 1223 { 1224 return scan_entry->ie_list.vendor; 1225 } 1226 1227 /** 1228 * util_scan_entry_country() - function to read country IE 1229 * @scan_entry: scan entry 1230 * 1231 * API, function to read country IE 1232 * 1233 * Return: countryie or NULL if ie is not present 1234 */ 1235 static inline struct wlan_country_ie* 1236 util_scan_entry_country(struct scan_cache_entry *scan_entry) 1237 { 1238 return (struct wlan_country_ie *)scan_entry->ie_list.country; 1239 } 1240 1241 /** 1242 * util_scan_entry_copy_country() - function to copy country name 1243 * @scan_entry: scan entry 1244 * @cntry: out buffer 1245 * 1246 * API, function to copy country name code string in given memory @centry 1247 * 1248 * Return: QDF_STATUS_SUCCESS if successfully copied country name 1249 * QDF_STATUS_E_INVAL if passed buffer is null 1250 * QDF_STATUS_E_NOMEM if scan entry dont have country IE 1251 */ 1252 static inline QDF_STATUS 1253 util_scan_entry_copy_country(struct scan_cache_entry *scan_entry, 1254 uint8_t *cntry) 1255 { 1256 struct wlan_country_ie *country_ie; 1257 1258 if (!cntry) 1259 return QDF_STATUS_E_INVAL; 1260 1261 country_ie = util_scan_entry_country(scan_entry); 1262 1263 if (!country_ie) 1264 return QDF_STATUS_E_NOMEM; 1265 1266 qdf_mem_copy(cntry, country_ie->cc, 3); 1267 1268 return QDF_STATUS_SUCCESS; 1269 } 1270 1271 /** 1272 * util_scan_entry_wmeinfo() - function to read wme info ie 1273 * @scan_entry: scan entry 1274 * 1275 * API, function to read wme info ie 1276 * 1277 * Return: wme infoie or NULL if ie is not present 1278 */ 1279 static inline uint8_t* 1280 util_scan_entry_wmeinfo(struct scan_cache_entry *scan_entry) 1281 { 1282 return scan_entry->ie_list.wmeinfo; 1283 } 1284 1285 /** 1286 * util_scan_entry_wmeparam() - function to read wme param ie 1287 * @scan_entry: scan entry 1288 * 1289 * API, function to read wme param ie 1290 * 1291 * Return: wme paramie or NULL if ie is not present 1292 */ 1293 static inline uint8_t* 1294 util_scan_entry_wmeparam(struct scan_cache_entry *scan_entry) 1295 { 1296 return scan_entry->ie_list.wmeparam; 1297 } 1298 1299 /** 1300 * util_scan_entry_age() - function to read age of scan entry 1301 * @scan_entry: scan entry 1302 * 1303 * API, function to read age of scan entry 1304 * 1305 * Return: age in ms 1306 */ 1307 static inline qdf_time_t 1308 util_scan_entry_age(struct scan_cache_entry *scan_entry) 1309 { 1310 qdf_time_t ts = scan_entry->scan_entry_time; 1311 1312 return qdf_mc_timer_get_system_time() - ts; 1313 } 1314 1315 /** 1316 * util_scan_mlme_info() - function to read mlme info struct 1317 * @scan_entry: scan entry 1318 * 1319 * API, function to read mlme info struct 1320 * 1321 * Return: mlme info 1322 */ 1323 static inline struct mlme_info* 1324 util_scan_mlme_info(struct scan_cache_entry *scan_entry) 1325 { 1326 return &scan_entry->mlme_info; 1327 } 1328 1329 /** 1330 * util_scan_entry_bss_type() - function to read bss type 1331 * @scan_entry: scan entry 1332 * 1333 * API, function to read bss type 1334 * 1335 * Return: bss type 1336 */ 1337 static inline enum wlan_bss_type 1338 util_scan_entry_bss_type(struct scan_cache_entry *scan_entry) 1339 { 1340 if (scan_entry->cap_info.value & WLAN_CAPINFO_ESS) 1341 return WLAN_TYPE_BSS; 1342 else if (scan_entry->cap_info.value & WLAN_CAPINFO_IBSS) 1343 return WLAN_TYPE_IBSS; 1344 else 1345 return WLAN_TYPE_ANY; 1346 } 1347 1348 /** 1349 * util_scan_entry_privacy() - function to check if privacy is enebled 1350 * @scan_entry: scan entry 1351 * 1352 * API, function to check if privacy is enebled 1353 * 1354 * Return: true if privacy is enabled, false other wise 1355 */ 1356 static inline bool 1357 util_scan_entry_privacy(struct scan_cache_entry *scan_entry) 1358 { 1359 return (scan_entry->cap_info.value & 1360 WLAN_CAPINFO_PRIVACY) ? true : false; 1361 } 1362 1363 /** 1364 * util_scan_entry_athcaps() - function to read ath caps vendor ie 1365 * @scan_entry: scan entry 1366 * 1367 * API, function to read ath caps vendor ie 1368 * 1369 * Return: ath caps vendorie or NULL if ie is not present 1370 */ 1371 static inline uint8_t* 1372 util_scan_entry_athcaps(struct scan_cache_entry *scan_entry) 1373 { 1374 return scan_entry->ie_list.athcaps; 1375 } 1376 1377 /** 1378 * util_scan_entry_athextcaps() - function to read ath extcaps vendor ie 1379 * @scan_entry: scan entry 1380 * 1381 * API, function to read ath extcaps vendor ie 1382 * 1383 * Return: ath extcaps vendorie or NULL if ie is not present 1384 */ 1385 static inline uint8_t* 1386 util_scan_entry_athextcaps(struct scan_cache_entry *scan_entry) 1387 { 1388 return scan_entry->ie_list.athextcaps; 1389 } 1390 1391 /** 1392 * util_scan_entry_bwnss_map() - function to read bwnss_map ie 1393 * @scan_entry: scan entry 1394 * 1395 * API, function to read bwnss_map ie 1396 * 1397 * Return: bwnss_map ie or NULL if ie is not present 1398 */ 1399 static inline uint8_t* 1400 util_scan_entry_bwnss_map(struct scan_cache_entry *scan_entry) 1401 { 1402 return scan_entry->ie_list.bwnss_map; 1403 } 1404 1405 /** 1406 * util_scan_entry_sonie() - function to read son ie 1407 * @scan_entry: scan entry 1408 * 1409 * API, function to read son ie 1410 * 1411 * Return: son ie or NULL if ie is not present 1412 */ 1413 static inline uint8_t* 1414 util_scan_entry_sonie(struct scan_cache_entry *scan_entry) 1415 { 1416 return scan_entry->ie_list.sonadv; 1417 } 1418 1419 /** 1420 * util_scan_entry_widebw() - function to read wide band chan switch sub elem ie 1421 * @scan_entry: scan entry 1422 * 1423 * API, function to read wide band chan switch sub elem ie 1424 * 1425 * Return: wide band chan switch sub elem or NULL if ie is not present 1426 */ 1427 static inline uint8_t* 1428 util_scan_entry_widebw(struct scan_cache_entry *scan_entry) 1429 { 1430 return scan_entry->ie_list.widebw; 1431 } 1432 1433 /** 1434 * util_scan_entry_secchanoff() - function to read secondary channel offset ie 1435 * @scan_entry: scan entry 1436 * 1437 * API, function to read secondary channel offset ie 1438 * 1439 * Return: secondary channel offset element or NULL if ie is not present 1440 */ 1441 static inline uint8_t* 1442 util_scan_entry_secchanoff(struct scan_cache_entry *scan_entry) 1443 { 1444 return scan_entry->ie_list.secchanoff; 1445 } 1446 1447 /** 1448 * util_scan_entry_cswrp() - function to read channel switch wrapper ie 1449 * @scan_entry: scan entry 1450 * 1451 * API, function to read channel switch wrapper ie 1452 * 1453 * Return: channel switch wrapper element or NULL if ie is not present 1454 */ 1455 static inline uint8_t* 1456 util_scan_entry_cswrp(struct scan_cache_entry *scan_entry) 1457 { 1458 return scan_entry->ie_list.cswrp; 1459 } 1460 1461 /** 1462 * util_scan_entry_omn() - function to read operating mode notification ie 1463 * @scan_entry: scan entry 1464 * 1465 * API, function to read operating mode notification 1466 * 1467 * Return: operating mode notification element or NULL if ie is not present 1468 */ 1469 static inline uint8_t* 1470 util_scan_entry_omn(struct scan_cache_entry *scan_entry) 1471 { 1472 return scan_entry->ie_list.opmode; 1473 } 1474 1475 /** 1476 * util_scan_entry_extcaps() - function to read extcap ie 1477 * @scan_entry: scan entry 1478 * 1479 * API, function to read extcap ie 1480 * 1481 * Return: extcap element or NULL if ie is not present 1482 */ 1483 static inline uint8_t* 1484 util_scan_entry_extcaps(struct scan_cache_entry *scan_entry) 1485 { 1486 return scan_entry->ie_list.extcaps; 1487 } 1488 1489 /** 1490 * util_scan_entry_get_extcap() - function to read extended capability field ie 1491 * @scan_entry: scan entry 1492 * @extcap_bit_field: extended capability bit field 1493 * @extcap_value: pointer to fill extended capability field value 1494 * 1495 * API, function to read extended capability field 1496 * 1497 * Return: QDF_STATUS_SUCCESS if extended capability field is found 1498 * QDF_STATUS_E_NOMEM if extended capability field is not found 1499 */ 1500 static inline QDF_STATUS 1501 util_scan_entry_get_extcap(struct scan_cache_entry *scan_entry, 1502 enum ext_cap_bit_field extcap_bit_field, 1503 uint8_t *extcap_value) 1504 { 1505 struct wlan_ext_cap_ie *ext_cap = 1506 (struct wlan_ext_cap_ie *)util_scan_entry_extcaps(scan_entry); 1507 1508 uint8_t ext_caps_byte = (extcap_bit_field >> 3); 1509 uint8_t ext_caps_bit_pos = extcap_bit_field & 0x7; 1510 1511 *extcap_value = 0; 1512 1513 if (!ext_cap) 1514 return QDF_STATUS_E_NULL_VALUE; 1515 1516 if (ext_cap->ext_cap_len <= ext_caps_byte) 1517 return QDF_STATUS_E_NULL_VALUE; 1518 1519 *extcap_value = 1520 ((ext_cap->ext_caps[ext_caps_byte] >> ext_caps_bit_pos) & 0x1); 1521 1522 return QDF_STATUS_SUCCESS; 1523 } 1524 1525 /** 1526 * util_scan_entry_mlme_info() - function to read MLME info 1527 * @scan_entry: scan entry 1528 * 1529 * API, function to read MLME info 1530 * 1531 * Return: MLME info or NULL if it is not present 1532 */ 1533 static inline struct mlme_info* 1534 util_scan_entry_mlme_info(struct scan_cache_entry *scan_entry) 1535 { 1536 return &(scan_entry->mlme_info); 1537 } 1538 1539 /** 1540 * util_scan_entry_mcst() - function to read mcst IE 1541 * @scan_entry:scan entry 1542 * 1543 * API, function to read mcst IE 1544 * 1545 * Return: mcst or NULL if ie is not present 1546 */ 1547 static inline uint8_t* 1548 util_scan_entry_mcst(struct scan_cache_entry *scan_entry) 1549 { 1550 return scan_entry->ie_list.mcst; 1551 } 1552 1553 /** 1554 * util_scan_entry_hecap() - function to read he caps vendor ie 1555 * @scan_entry: scan entry 1556 * 1557 * API, function to read he caps vendor ie 1558 * 1559 * Return: he caps vendorie or NULL if ie is not present 1560 */ 1561 static inline uint8_t* 1562 util_scan_entry_hecap(struct scan_cache_entry *scan_entry) 1563 { 1564 return scan_entry->ie_list.hecap; 1565 } 1566 1567 /** 1568 * util_scan_entry_he_6g_cap() - function to read he 6GHz caps vendor ie 1569 * @scan_entry: scan entry 1570 * 1571 * API, function to read he 6GHz caps vendor ie 1572 * 1573 * Return: he caps vendorie or NULL if ie is not present 1574 */ 1575 static inline uint8_t* 1576 util_scan_entry_he_6g_cap(struct scan_cache_entry *scan_entry) 1577 { 1578 return scan_entry->ie_list.hecap_6g; 1579 } 1580 1581 /** 1582 * util_scan_entry_heop() - function to read heop vendor ie 1583 * @scan_entry: scan entry 1584 * 1585 * API, function to read heop vendor ie 1586 * 1587 * Return, heop vendorie or NULL if ie is not present 1588 */ 1589 static inline uint8_t* 1590 util_scan_entry_heop(struct scan_cache_entry *scan_entry) 1591 { 1592 return scan_entry->ie_list.heop; 1593 } 1594 1595 #ifdef WLAN_FEATURE_11BE 1596 /** 1597 * util_scan_entry_ehtcap() - function to read eht caps vendor ie 1598 * @scan_entry: scan entry 1599 * 1600 * API, function to read eht caps vendor ie 1601 * 1602 * Return: eht caps vendorie or NULL if ie is not present 1603 */ 1604 static inline uint8_t* 1605 util_scan_entry_ehtcap(struct scan_cache_entry *scan_entry) 1606 { 1607 return scan_entry->ie_list.ehtcap; 1608 } 1609 1610 /** 1611 * util_scan_entry_ehtop() - function to read ehtop vendor ie 1612 * @scan_entry: scan entry 1613 * 1614 * API, function to read ehtop vendor ie 1615 * 1616 * Return, ehtop vendorie or NULL if ie is not present 1617 */ 1618 static inline uint8_t* 1619 util_scan_entry_ehtop(struct scan_cache_entry *scan_entry) 1620 { 1621 return scan_entry->ie_list.ehtop; 1622 } 1623 1624 static inline uint8_t* 1625 util_scan_entry_bw_ind(struct scan_cache_entry *scan_entry) 1626 { 1627 return scan_entry->ie_list.bw_ind; 1628 } 1629 #else 1630 1631 static inline uint8_t* 1632 util_scan_entry_ehtcap(struct scan_cache_entry *scan_entry) 1633 { 1634 return NULL; 1635 } 1636 1637 static inline uint8_t* 1638 util_scan_entry_bw_ind(struct scan_cache_entry *scan_entry) 1639 { 1640 return NULL; 1641 } 1642 #endif 1643 1644 #ifdef WLAN_FEATURE_11BE_MLO 1645 static inline uint8_t* 1646 util_scan_entry_t2lm(struct scan_cache_entry *scan_entry) 1647 { 1648 return scan_entry->ie_list.t2lm[0]; 1649 } 1650 1651 /** 1652 * util_scan_entry_t2lm_len() - API to get t2lm IE length 1653 * @scan_entry: scan entry 1654 * 1655 * Return, Length or 0 if ie is not present 1656 */ 1657 uint32_t util_scan_entry_t2lm_len(struct scan_cache_entry *scan_entry); 1658 #else 1659 static inline uint8_t* 1660 util_scan_entry_t2lm(struct scan_cache_entry *scan_entry) 1661 { 1662 return NULL; 1663 } 1664 1665 static inline uint32_t 1666 util_scan_entry_t2lm_len(struct scan_cache_entry *scan_entry) 1667 { 1668 return 0; 1669 } 1670 #endif 1671 1672 /** 1673 * util_scan_entry_tpe() - function to read tpe ie 1674 * @scan_entry: scan entry 1675 * 1676 * API, function to read tpe ie 1677 * 1678 * Return, tpe ie or NULL if ie is not present 1679 */ 1680 static inline uint8_t** 1681 util_scan_entry_tpe(struct scan_cache_entry *scan_entry) 1682 { 1683 return scan_entry->ie_list.tpe; 1684 } 1685 1686 /** 1687 * util_scan_entry_muedca() - function to read MU-EDCA IE 1688 * @scan_entry: scan entry 1689 * 1690 * API, function to read MU-EDCA IE 1691 * 1692 * Return, MUEDCA IE or NULL if IE is not present 1693 */ 1694 static inline uint8_t* 1695 util_scan_entry_muedca(struct scan_cache_entry *scan_entry) 1696 { 1697 return scan_entry->ie_list.muedca; 1698 } 1699 1700 /** 1701 * util_scan_entry_spatial_reuse_parameter() - function to read spatial reuse 1702 * parameter ie 1703 * @scan_entry: scan entry 1704 * 1705 * API, function to read scan_entry reuse parameter ie 1706 * 1707 * Return, spatial reuse parameter ie or NULL if ie is not present 1708 */ 1709 static inline uint8_t* 1710 util_scan_entry_spatial_reuse_parameter(struct scan_cache_entry *scan_entry) 1711 { 1712 return scan_entry->ie_list.srp; 1713 } 1714 1715 /** 1716 * util_scan_entry_fils_indication() - function to read FILS indication ie 1717 * @scan_entry: scan entry 1718 * 1719 * API, function to read FILS indication ie 1720 * 1721 * Return, FILS indication ie or NULL if ie is not present 1722 */ 1723 static inline uint8_t* 1724 util_scan_entry_fils_indication(struct scan_cache_entry *scan_entry) 1725 { 1726 return scan_entry->ie_list.fils_indication; 1727 } 1728 1729 /** 1730 * util_get_last_scan_time() - function to get last scan time on this pdev 1731 * @vdev: vdev object 1732 * 1733 * API, function to read last scan time on this pdev 1734 * 1735 * Return: qdf_time_t 1736 */ 1737 qdf_time_t 1738 util_get_last_scan_time(struct wlan_objmgr_vdev *vdev); 1739 1740 /** 1741 * util_scan_entry_update_mlme_info() - function to update mlme info 1742 * @pdev: pdev object 1743 * @scan_entry: scan entry object 1744 * 1745 * API, function to update mlme info in scan DB 1746 * 1747 * Return: QDF_STATUS 1748 */ 1749 QDF_STATUS 1750 util_scan_entry_update_mlme_info(struct wlan_objmgr_pdev *pdev, 1751 struct scan_cache_entry *scan_entry); 1752 1753 /** 1754 * util_scan_is_hidden_ssid() - function to check if ssid is hidden 1755 * @ssid: struct ie_ssid object 1756 * 1757 * API, function to check if ssid is hidden 1758 * 1759 * Return: true if ap is hidden, false otherwise 1760 */ 1761 bool 1762 util_scan_is_hidden_ssid(struct ie_ssid *ssid); 1763 1764 /** 1765 * util_scan_entry_is_hidden_ap() - function to check if ap is hidden 1766 * @scan_entry: scan entry 1767 * 1768 * API, function to check if ap is hidden 1769 * 1770 * Return: true if ap is hidden, false otherwise 1771 */ 1772 static inline bool 1773 util_scan_entry_is_hidden_ap(struct scan_cache_entry *scan_entry) 1774 { 1775 return util_scan_is_hidden_ssid( 1776 (struct ie_ssid *)scan_entry->ie_list.ssid); 1777 } 1778 1779 /** 1780 * util_scan_entry_esp_info() - function to read ESP info 1781 * @scan_entry: scan entry 1782 * 1783 * API, function to read ESP info 1784 * 1785 * Return: erp info 1786 */ 1787 static inline uint8_t * 1788 util_scan_entry_esp_info(struct scan_cache_entry *scan_entry) 1789 { 1790 return scan_entry->ie_list.esp; 1791 } 1792 1793 /** 1794 * util_scan_entry_mbo_oce() - function to read MBO/OCE ie 1795 * @scan_entry: scan entry 1796 * 1797 * API, function to read MBO/OCE ie 1798 * 1799 * Return: MBO/OCE ie 1800 */ 1801 static inline uint8_t * 1802 util_scan_entry_mbo_oce(struct scan_cache_entry *scan_entry) 1803 { 1804 return scan_entry->ie_list.mbo_oce; 1805 } 1806 1807 /** 1808 * util_scan_entry_rsnxe() - function to read RSNXE ie 1809 * @scan_entry: scan entry 1810 * 1811 * API, function to read RSNXE ie 1812 * 1813 * Return: RSNXE ie 1814 */ 1815 static inline uint8_t * 1816 util_scan_entry_rsnxe(struct scan_cache_entry *scan_entry) 1817 { 1818 return scan_entry->ie_list.rsnxe; 1819 } 1820 1821 /** 1822 * util_is_rsnxe_h2e_capable() - API to check whether the RSNXE has 1823 * H2E capable or not. 1824 * @rsnxe: Pointer to RSNXE IE. 1825 * 1826 * Returns true if RSNXE caps has H2E capable bit set or else false. 1827 * 1828 * Return: bool 1829 */ 1830 bool util_is_rsnxe_h2e_capable(const uint8_t *rsnxe); 1831 1832 /** 1833 * util_scan_entry_sae_h2e_capable() - API to check whether the 1834 * current scan entry is SAE-H2E capable 1835 * @scan_entry: Scan cache entry 1836 * 1837 * Returns true if the current scan entry has RSNXE IE with H2E bit 1838 * set. 1839 * 1840 * Return: bool 1841 */ 1842 bool util_scan_entry_sae_h2e_capable(struct scan_cache_entry *scan_entry); 1843 1844 /** 1845 * util_scan_scm_freq_to_band() - API to get band from frequency 1846 * @freq: Channel frequency 1847 * 1848 * Return: Band information as per frequency 1849 */ 1850 enum wlan_band util_scan_scm_freq_to_band(uint16_t freq); 1851 1852 /** 1853 * util_is_scan_completed() - function to get scan complete status 1854 * @event: scan event 1855 * @success: true if scan complete success, false otherwise 1856 * 1857 * API, function to get the scan result 1858 * 1859 * Return: true if scan complete, false otherwise 1860 */ 1861 bool util_is_scan_completed(struct scan_event *event, bool *success); 1862 1863 /** 1864 * util_scan_entry_extenderie() - function to read extender IE 1865 * @scan_entry: scan entry 1866 * 1867 * API, function to read extender IE 1868 * 1869 * Return: extenderie or NULL if ie is not present 1870 */ 1871 static inline uint8_t* 1872 util_scan_entry_extenderie(struct scan_cache_entry *scan_entry) 1873 { 1874 return scan_entry->ie_list.extender; 1875 } 1876 1877 /** 1878 * util_scan_entry_mdie() - function to read Mobility Domain IE 1879 * @scan_entry: scan entry 1880 * 1881 * API, function to read Mobility Domain IE 1882 * 1883 * Return: MDIE or NULL if IE is not present 1884 */ 1885 static inline uint8_t* 1886 util_scan_entry_mdie(struct scan_cache_entry *scan_entry) 1887 { 1888 return scan_entry->ie_list.mdie; 1889 } 1890 1891 /** 1892 * util_scan_is_null_ssid() - to check for NULL ssid 1893 * @ssid: ssid 1894 * 1895 * Return: true if NULL ssid else false 1896 */ 1897 static inline bool util_scan_is_null_ssid(struct wlan_ssid *ssid) 1898 { 1899 uint32_t ssid_length; 1900 uint8_t *ssid_str; 1901 1902 if (ssid->length == 0) 1903 return true; 1904 1905 /* Consider 0 or space for hidden SSID */ 1906 if (0 == ssid->ssid[0]) 1907 return true; 1908 1909 ssid_length = ssid->length; 1910 ssid_str = ssid->ssid; 1911 1912 while (ssid_length) { 1913 if (*ssid_str != ASCII_SPACE_CHARACTER && 1914 *ssid_str) 1915 break; 1916 ssid_str++; 1917 ssid_length--; 1918 } 1919 1920 if (ssid_length == 0) 1921 return true; 1922 1923 return false; 1924 } 1925 1926 /** 1927 * util_scan_get_6g_oper_channel() - function to get primary channel 1928 * from he op IE 1929 * @he_op_ie : ie pointer 1930 * 1931 * Return: primary channel or 0 if 6g params is not present. 1932 */ 1933 #ifdef CONFIG_BAND_6GHZ 1934 uint8_t util_scan_get_6g_oper_channel(uint8_t *he_op_ie); 1935 #else 1936 static inline uint8_t 1937 util_scan_get_6g_oper_channel(uint8_t *he_op_ie) 1938 { 1939 return 0; 1940 } 1941 #endif 1942 /* 1943 * util_is_bssid_non_tx() - Is the given BSSID a non-tx neighbor 1944 * entry in the RNR db 1945 * @psoc: psoc 1946 * @bssid: bssid 1947 * @freq: frequency corresponding to the bssid 1948 * 1949 * Return: Is bssid non tx 1950 */ 1951 bool util_is_bssid_non_tx(struct wlan_objmgr_psoc *psoc, 1952 struct qdf_mac_addr *bssid, qdf_freq_t freq); 1953 #endif 1954