1 /* 2 * Copyright (c) 2017-2018 The Linux Foundation. All rights reserved. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for 5 * any purpose with or without fee is hereby granted, provided that the 6 * above copyright notice and this permission notice appear in all 7 * copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 10 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 11 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 12 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 13 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 14 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 15 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 16 * PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 /* 20 * DOC: Defines scan utility functions 21 */ 22 23 #include <wlan_cmn.h> 24 #include <wlan_scan_ucfg_api.h> 25 #include <wlan_scan_utils_api.h> 26 #include <../../core/src/wlan_scan_cache_db.h> 27 #include <../../core/src/wlan_scan_main.h> 28 #include <wlan_reg_services_api.h> 29 30 const char* 31 util_scan_get_ev_type_name(enum scan_event_type type) 32 { 33 static const char * const event_name[] = { 34 [SCAN_EVENT_TYPE_STARTED] = "STARTED", 35 [SCAN_EVENT_TYPE_COMPLETED] = "COMPLETED", 36 [SCAN_EVENT_TYPE_BSS_CHANNEL] = "HOME_CHANNEL", 37 [SCAN_EVENT_TYPE_FOREIGN_CHANNEL] = "FOREIGN_CHANNEL", 38 [SCAN_EVENT_TYPE_DEQUEUED] = "DEQUEUED", 39 [SCAN_EVENT_TYPE_PREEMPTED] = "PREEMPTED", 40 [SCAN_EVENT_TYPE_START_FAILED] = "START_FAILED", 41 [SCAN_EVENT_TYPE_RESTARTED] = "RESTARTED", 42 [SCAN_EVENT_TYPE_FOREIGN_CHANNEL_EXIT] = "FOREIGN_CHANNEL_EXIT", 43 [SCAN_EVENT_TYPE_SUSPENDED] = "SUSPENDED", 44 [SCAN_EVENT_TYPE_RESUMED] = "RESUMED", 45 [SCAN_EVENT_TYPE_NLO_COMPLETE] = "NLO_COMPLETE", 46 [SCAN_EVENT_TYPE_NLO_MATCH] = "NLO_MATCH", 47 [SCAN_EVENT_TYPE_INVALID] = "INVALID", 48 [SCAN_EVENT_TYPE_GPIO_TIMEOUT] = "GPIO_TIMEOUT", 49 [SCAN_EVENT_TYPE_RADIO_MEASUREMENT_START] = 50 "RADIO_MEASUREMENT_START", 51 [SCAN_EVENT_TYPE_RADIO_MEASUREMENT_END] = 52 "RADIO_MEASUREMENT_END", 53 [SCAN_EVENT_TYPE_BSSID_MATCH] = "BSSID_MATCH", 54 [SCAN_EVENT_TYPE_FOREIGN_CHANNEL_GET_NF] = 55 "FOREIGN_CHANNEL_GET_NF", 56 }; 57 58 if (type >= SCAN_EVENT_TYPE_MAX) 59 return "UNKNOWN"; 60 61 return event_name[type]; 62 } 63 64 65 const char* 66 util_scan_get_ev_reason_name(enum scan_completion_reason reason) 67 { 68 static const char * const reason_name[] = { 69 [SCAN_REASON_NONE] = "NONE", 70 [SCAN_REASON_COMPLETED] = "COMPLETED", 71 [SCAN_REASON_CANCELLED] = "CANCELLED", 72 [SCAN_REASON_PREEMPTED] = "PREEMPTED", 73 [SCAN_REASON_TIMEDOUT] = "TIMEDOUT", 74 [SCAN_REASON_INTERNAL_FAILURE] = "INTERNAL_FAILURE", 75 [SCAN_REASON_SUSPENDED] = "SUSPENDED", 76 [SCAN_REASON_RUN_FAILED] = "RUN_FAILED", 77 [SCAN_REASON_TERMINATION_FUNCTION] = "TERMINATION_FUNCTION", 78 [SCAN_REASON_MAX_OFFCHAN_RETRIES] = "MAX_OFFCHAN_RETRIES", 79 }; 80 81 if (reason >= SCAN_REASON_MAX) 82 return "UNKNOWN"; 83 84 return reason_name[reason]; 85 } 86 87 qdf_time_t 88 util_get_last_scan_time(struct wlan_objmgr_vdev *vdev) 89 { 90 uint8_t pdev_id; 91 struct wlan_scan_obj *scan_obj; 92 93 if (!vdev) { 94 scm_warn("null vdev"); 95 QDF_ASSERT(0); 96 return 0; 97 } 98 pdev_id = wlan_scan_vdev_get_pdev_id(vdev); 99 scan_obj = wlan_vdev_get_scan_obj(vdev); 100 101 return scan_obj->pdev_info[pdev_id].last_scan_time; 102 } 103 104 enum wlan_band util_scan_scm_chan_to_band(uint32_t chan) 105 { 106 if (WLAN_CHAN_IS_2GHZ(chan)) 107 return WLAN_BAND_2_4_GHZ; 108 109 return WLAN_BAND_5_GHZ; 110 } 111 112 enum wlan_band util_scan_scm_freq_to_band(uint16_t freq) 113 { 114 if (WLAN_REG_IS_24GHZ_CH_FREQ(freq)) 115 return WLAN_BAND_2_4_GHZ; 116 117 return WLAN_BAND_5_GHZ; 118 } 119 120 bool util_is_scan_entry_match( 121 struct scan_cache_entry *entry1, 122 struct scan_cache_entry *entry2) 123 { 124 125 if (entry1->cap_info.wlan_caps.ess != 126 entry2->cap_info.wlan_caps.ess) 127 return false; 128 129 if (entry1->cap_info.wlan_caps.ess && 130 !qdf_mem_cmp(entry1->bssid.bytes, 131 entry2->bssid.bytes, QDF_MAC_ADDR_SIZE) && 132 util_scan_scm_chan_to_band( 133 entry1->channel.chan_idx) == 134 util_scan_scm_chan_to_band(entry2->channel.chan_idx)) { 135 /* Check for BSS */ 136 if (util_is_ssid_match( 137 &entry1->ssid, &entry2->ssid)) 138 return true; 139 } else if (entry1->cap_info.wlan_caps.ibss && 140 (entry1->channel.chan_idx == 141 entry2->channel.chan_idx)) { 142 /* 143 * Same channel cannot have same SSID for 144 * different IBSS, so no need to check BSSID 145 */ 146 if (util_is_ssid_match( 147 &entry1->ssid, &entry2->ssid)) 148 return true; 149 } else if (!entry1->cap_info.wlan_caps.ibss && 150 !entry1->cap_info.wlan_caps.ess && 151 !qdf_mem_cmp(entry1->bssid.bytes, 152 entry2->bssid.bytes, QDF_MAC_ADDR_SIZE)) { 153 /* In case of P2P devices, ess and ibss will be set to zero */ 154 return true; 155 } 156 157 return false; 158 } 159 160 static bool util_is_pureg_rate(uint8_t *rates, uint8_t nrates) 161 { 162 static const uint8_t g_rates[] = {12, 18, 24, 36, 48, 72, 96, 108}; 163 bool pureg = false; 164 uint8_t i, j; 165 166 for (i = 0; i < nrates; i++) { 167 for (j = 0; j < QDF_ARRAY_SIZE(g_rates); j++) { 168 if (WLAN_RV(rates[i]) == g_rates[j]) { 169 pureg = true; 170 break; 171 } 172 } 173 if (pureg) 174 break; 175 } 176 177 return pureg; 178 } 179 static enum wlan_phymode 180 util_scan_get_phymode_5g(struct scan_cache_entry *scan_params) 181 { 182 enum wlan_phymode phymode = WLAN_PHYMODE_AUTO; 183 uint16_t ht_cap = 0; 184 struct htcap_cmn_ie *htcap; 185 struct wlan_ie_htinfo_cmn *htinfo; 186 struct wlan_ie_vhtop *vhtop; 187 188 htcap = (struct htcap_cmn_ie *) 189 util_scan_entry_htcap(scan_params); 190 htinfo = (struct wlan_ie_htinfo_cmn *) 191 util_scan_entry_htinfo(scan_params); 192 vhtop = (struct wlan_ie_vhtop *) 193 util_scan_entry_vhtop(scan_params); 194 195 if (!(htcap && htinfo)) 196 return WLAN_PHYMODE_11A; 197 198 if (htcap) 199 ht_cap = le16toh(htcap->hc_cap); 200 201 if (util_scan_entry_vhtcap(scan_params) && vhtop) { 202 switch (vhtop->vht_op_chwidth) { 203 case WLAN_VHTOP_CHWIDTH_2040: 204 if ((ht_cap & WLAN_HTCAP_C_CHWIDTH40) && 205 (htinfo->hi_extchoff == 206 WLAN_HTINFO_EXTOFFSET_ABOVE)) 207 phymode = WLAN_PHYMODE_11AC_VHT40PLUS; 208 else if ((ht_cap & WLAN_HTCAP_C_CHWIDTH40) && 209 (htinfo->hi_extchoff == 210 WLAN_HTINFO_EXTOFFSET_BELOW)) 211 phymode = WLAN_PHYMODE_11AC_VHT40MINUS; 212 else 213 phymode = WLAN_PHYMODE_11AC_VHT20; 214 break; 215 case WLAN_VHTOP_CHWIDTH_80: 216 if (WLAN_IS_REVSIG_VHT80_80(vhtop)) 217 phymode = WLAN_PHYMODE_11AC_VHT80_80; 218 else if (WLAN_IS_REVSIG_VHT160(vhtop)) 219 phymode = WLAN_PHYMODE_11AC_VHT160; 220 else 221 phymode = WLAN_PHYMODE_11AC_VHT80; 222 break; 223 case WLAN_VHTOP_CHWIDTH_160: 224 phymode = WLAN_PHYMODE_11AC_VHT160; 225 break; 226 case WLAN_VHTOP_CHWIDTH_80_80: 227 phymode = WLAN_PHYMODE_11AC_VHT80_80; 228 break; 229 default: 230 scm_err("bad channel: %d", 231 vhtop->vht_op_chwidth); 232 break; 233 } 234 } else if ((ht_cap & WLAN_HTCAP_C_CHWIDTH40) && 235 (htinfo->hi_extchoff == WLAN_HTINFO_EXTOFFSET_ABOVE)) 236 phymode = WLAN_PHYMODE_11NA_HT40PLUS; 237 else if ((ht_cap & WLAN_HTCAP_C_CHWIDTH40) && 238 (htinfo->hi_extchoff == WLAN_HTINFO_EXTOFFSET_BELOW)) 239 phymode = WLAN_PHYMODE_11NA_HT40MINUS; 240 else 241 phymode = WLAN_PHYMODE_11NA_HT20; 242 243 return phymode; 244 } 245 246 static enum wlan_phymode 247 util_scan_get_phymode_2g(struct scan_cache_entry *scan_params) 248 { 249 enum wlan_phymode phymode = WLAN_PHYMODE_AUTO; 250 uint16_t ht_cap = 0; 251 struct htcap_cmn_ie *htcap; 252 struct wlan_ie_htinfo_cmn *htinfo; 253 struct wlan_ie_vhtop *vhtop; 254 255 htcap = (struct htcap_cmn_ie *) 256 util_scan_entry_htcap(scan_params); 257 htinfo = (struct wlan_ie_htinfo_cmn *) 258 util_scan_entry_htinfo(scan_params); 259 vhtop = (struct wlan_ie_vhtop *) 260 util_scan_entry_vhtop(scan_params); 261 262 if (htcap) 263 ht_cap = le16toh(htcap->hc_cap); 264 265 if (htcap && htinfo) { 266 if ((ht_cap & WLAN_HTCAP_C_CHWIDTH40) && 267 (htinfo->hi_extchoff == WLAN_HTINFO_EXTOFFSET_ABOVE)) 268 phymode = WLAN_PHYMODE_11NG_HT40PLUS; 269 else if ((ht_cap & WLAN_HTCAP_C_CHWIDTH40) && 270 (htinfo->hi_extchoff == WLAN_HTINFO_EXTOFFSET_BELOW)) 271 phymode = WLAN_PHYMODE_11NG_HT40MINUS; 272 else 273 phymode = WLAN_PHYMODE_11NG_HT20; 274 } else if (util_scan_entry_xrates(scan_params)) { 275 /* only 11G stations will have more than 8 rates */ 276 phymode = WLAN_PHYMODE_11G; 277 } else { 278 /* Some mischievous g-only APs do not set extended rates */ 279 if (util_scan_entry_rates(scan_params)) { 280 if (util_is_pureg_rate(&scan_params->ie_list.rates[2], 281 scan_params->ie_list.rates[1])) 282 phymode = WLAN_PHYMODE_11G; 283 else 284 phymode = WLAN_PHYMODE_11B; 285 } else { 286 phymode = WLAN_PHYMODE_11B; 287 } 288 } 289 290 return phymode; 291 } 292 293 static QDF_STATUS 294 util_scan_parse_chan_switch_wrapper_ie(struct scan_cache_entry *scan_params, 295 struct ie_header *sub_ie, qdf_size_t sub_ie_len) 296 { 297 /* Walk through to check nothing is malformed */ 298 while (sub_ie_len >= sizeof(struct ie_header)) { 299 /* At least one more header is present */ 300 sub_ie_len -= sizeof(struct ie_header); 301 302 if (sub_ie->ie_len == 0) { 303 sub_ie += 1; 304 continue; 305 } 306 if (sub_ie_len < sub_ie->ie_len) { 307 scm_err("Incomplete corrupted IE:%x", 308 WLAN_ELEMID_CHAN_SWITCH_WRAP); 309 return QDF_STATUS_E_INVAL; 310 } 311 switch (sub_ie->ie_id) { 312 case WLAN_ELEMID_COUNTRY: 313 scan_params->ie_list.country = (uint8_t *)sub_ie; 314 break; 315 case WLAN_ELEMID_WIDE_BAND_CHAN_SWITCH: 316 scan_params->ie_list.widebw = (uint8_t *)sub_ie; 317 break; 318 case WLAN_ELEMID_VHT_TX_PWR_ENVLP: 319 scan_params->ie_list.txpwrenvlp = (uint8_t *)sub_ie; 320 break; 321 } 322 /* Consume sub info element */ 323 sub_ie_len -= sub_ie->ie_len; 324 /* go to next Sub IE */ 325 sub_ie = (struct ie_header *) 326 (((uint8_t *) sub_ie) + 327 sizeof(struct ie_header) + sub_ie->ie_len); 328 } 329 330 return QDF_STATUS_SUCCESS; 331 } 332 333 bool 334 util_scan_is_hidden_ssid(struct ie_ssid *ssid) 335 { 336 uint8_t i; 337 338 /* 339 * We flag this as Hidden SSID if the Length is 0 340 * of the SSID only contains 0's 341 */ 342 if (!ssid || !ssid->ssid_len) 343 return true; 344 345 for (i = 0; i < ssid->ssid_len; i++) 346 if (ssid->ssid[i] != 0) 347 return false; 348 349 /* All 0's */ 350 return true; 351 } 352 353 static QDF_STATUS 354 util_scan_parse_extn_ie(struct scan_cache_entry *scan_params, 355 struct ie_header *ie) 356 { 357 struct extn_ie_header *extn_ie = (struct extn_ie_header *) ie; 358 359 switch (extn_ie->ie_extn_id) { 360 case WLAN_EXTN_ELEMID_SRP: 361 scan_params->ie_list.srp = (uint8_t *)ie; 362 break; 363 case WLAN_EXTN_ELEMID_HECAP: 364 scan_params->ie_list.hecap = (uint8_t *)ie; 365 break; 366 case WLAN_EXTN_ELEMID_HEOP: 367 scan_params->ie_list.heop = (uint8_t *)ie; 368 break; 369 case WLAN_EXTN_ELEMID_ESP: 370 scan_params->ie_list.esp = (uint8_t *)ie; 371 break; 372 case WLAN_EXTN_ELEMID_MUEDCA: 373 scan_params->ie_list.muedca = (uint8_t *)ie; 374 break; 375 default: 376 break; 377 } 378 return QDF_STATUS_SUCCESS; 379 } 380 381 static QDF_STATUS 382 util_scan_parse_vendor_ie(struct scan_cache_entry *scan_params, 383 struct ie_header *ie) 384 { 385 if (scan_params->ie_list.vendor == NULL) 386 scan_params->ie_list.vendor = (uint8_t *)ie; 387 388 if (is_wpa_oui((uint8_t *)ie)) { 389 scan_params->ie_list.wpa = (uint8_t *)ie; 390 } else if (is_wps_oui((uint8_t *)ie)) { 391 scan_params->ie_list.wps = (uint8_t *)ie; 392 /* WCN IE should be a subset of WPS IE */ 393 if (is_wcn_oui((uint8_t *)ie)) 394 scan_params->ie_list.wcn = (uint8_t *)ie; 395 } else if (is_wme_param((uint8_t *)ie)) { 396 scan_params->ie_list.wmeparam = (uint8_t *)ie; 397 } else if (is_wme_info((uint8_t *)ie)) { 398 scan_params->ie_list.wmeinfo = (uint8_t *)ie; 399 } else if (is_atheros_oui((uint8_t *)ie)) { 400 scan_params->ie_list.athcaps = (uint8_t *)ie; 401 } else if (is_atheros_extcap_oui((uint8_t *)ie)) { 402 scan_params->ie_list.athextcaps = (uint8_t *)ie; 403 } else if (is_sfa_oui((uint8_t *)ie)) { 404 scan_params->ie_list.sfa = (uint8_t *)ie; 405 } else if (is_p2p_oui((uint8_t *)ie)) { 406 scan_params->ie_list.p2p = (uint8_t *)ie; 407 } else if (is_qca_son_oui((uint8_t *)ie, 408 QCA_OUI_WHC_AP_INFO_SUBTYPE)) { 409 scan_params->ie_list.sonadv = (uint8_t *)ie; 410 } else if (is_ht_cap((uint8_t *)ie)) { 411 /* we only care if there isn't already an HT IE (ANA) */ 412 if (scan_params->ie_list.htcap == NULL) { 413 if (ie->ie_len != (WLAN_VENDOR_HT_IE_OFFSET_LEN + 414 sizeof(struct htcap_cmn_ie))) 415 return QDF_STATUS_E_INVAL; 416 scan_params->ie_list.htcap = 417 (uint8_t *)&(((struct wlan_vendor_ie_htcap *)ie)->ie); 418 } 419 } else if (is_ht_info((uint8_t *)ie)) { 420 /* we only care if there isn't already an HT IE (ANA) */ 421 if (scan_params->ie_list.htinfo == NULL) { 422 if (ie->ie_len != WLAN_VENDOR_HT_IE_OFFSET_LEN + 423 sizeof(struct wlan_ie_htinfo_cmn)) 424 return QDF_STATUS_E_INVAL; 425 scan_params->ie_list.htinfo = 426 (uint8_t *)&(((struct wlan_vendor_ie_htinfo *) 427 ie)->hi_ie); 428 } 429 } else if (is_interop_vht((uint8_t *)ie) && 430 !(scan_params->ie_list.vhtop)) { 431 uint8_t *vendor_ie = (uint8_t *)(ie); 432 433 if (ie->ie_len < ((WLAN_VENDOR_VHTCAP_IE_OFFSET + 434 sizeof(struct wlan_ie_vhtcaps)) - 435 sizeof(struct ie_header))) 436 return QDF_STATUS_E_INVAL; 437 vendor_ie = ((uint8_t *)(ie)) + WLAN_VENDOR_VHTCAP_IE_OFFSET; 438 if (vendor_ie[1] != (sizeof(struct wlan_ie_vhtcaps)) - 439 sizeof(struct ie_header)) 440 return QDF_STATUS_E_INVAL; 441 /* location where Interop Vht Cap IE and VHT OP IE Present */ 442 scan_params->ie_list.vhtcap = (((uint8_t *)(ie)) + 443 WLAN_VENDOR_VHTCAP_IE_OFFSET); 444 if (ie->ie_len > ((WLAN_VENDOR_VHTCAP_IE_OFFSET + 445 sizeof(struct wlan_ie_vhtcaps)) - 446 sizeof(struct ie_header)) && 447 ie->ie_len < ((WLAN_VENDOR_VHTOP_IE_OFFSET + 448 sizeof(struct wlan_ie_vhtop)) - 449 sizeof(struct ie_header))) 450 return QDF_STATUS_E_INVAL; 451 vendor_ie = ((uint8_t *)(ie)) + WLAN_VENDOR_VHTOP_IE_OFFSET; 452 if (vendor_ie[1] != (sizeof(struct wlan_ie_vhtop) - 453 sizeof(struct ie_header))) 454 return QDF_STATUS_E_INVAL; 455 scan_params->ie_list.vhtop = (((uint8_t *)(ie)) + 456 WLAN_VENDOR_VHTOP_IE_OFFSET); 457 } else if (is_bwnss_oui((uint8_t *)ie)) { 458 /* 459 * Bandwidth-NSS map has sub-type & version. 460 * hence copy data just after version byte 461 */ 462 scan_params->ie_list.bwnss_map = (((uint8_t *)ie) + 8); 463 } else if (is_mbo_oce_oui((uint8_t *)ie)) { 464 scan_params->ie_list.mbo_oce = (uint8_t *)ie; 465 } else if (is_extender_oui((uint8_t *)ie)) { 466 scan_params->ie_list.extender = (uint8_t *)ie; 467 } 468 return QDF_STATUS_SUCCESS; 469 } 470 471 static QDF_STATUS 472 util_scan_populate_bcn_ie_list(struct scan_cache_entry *scan_params) 473 { 474 struct ie_header *ie, *sub_ie; 475 uint32_t ie_len, sub_ie_len; 476 QDF_STATUS status; 477 478 ie_len = util_scan_entry_ie_len(scan_params); 479 ie = (struct ie_header *) 480 util_scan_entry_ie_data(scan_params); 481 482 while (ie_len >= sizeof(struct ie_header)) { 483 ie_len -= sizeof(struct ie_header); 484 485 if (!ie->ie_len) { 486 ie += 1; 487 continue; 488 } 489 490 if (ie_len < ie->ie_len) { 491 scm_debug("Incomplete corrupted IE:%x", 492 ie->ie_id); 493 return QDF_STATUS_E_INVAL; 494 } 495 496 switch (ie->ie_id) { 497 case WLAN_ELEMID_SSID: 498 if (ie->ie_len > (sizeof(struct ie_ssid) - 499 sizeof(struct ie_header))) 500 return QDF_STATUS_E_INVAL; 501 scan_params->ie_list.ssid = (uint8_t *)ie; 502 break; 503 case WLAN_ELEMID_RATES: 504 if (ie->ie_len > WLAN_SUPPORTED_RATES_IE_MAX_LEN) 505 return QDF_STATUS_E_INVAL; 506 scan_params->ie_list.rates = (uint8_t *)ie; 507 break; 508 case WLAN_ELEMID_DSPARMS: 509 if (ie->ie_len != WLAN_DS_PARAM_IE_MAX_LEN) 510 return QDF_STATUS_E_INVAL; 511 scan_params->ie_list.ds_param = (uint8_t *)ie; 512 scan_params->channel.chan_idx = 513 ((struct ds_ie *)ie)->cur_chan; 514 break; 515 case WLAN_ELEMID_TIM: 516 if (ie->ie_len < WLAN_TIM_IE_MIN_LENGTH) 517 return QDF_STATUS_E_INVAL; 518 scan_params->ie_list.tim = (uint8_t *)ie; 519 scan_params->dtim_period = 520 ((struct wlan_tim_ie *)ie)->tim_period; 521 break; 522 case WLAN_ELEMID_COUNTRY: 523 if (ie->ie_len < WLAN_COUNTRY_IE_MIN_LEN) 524 return QDF_STATUS_E_INVAL; 525 scan_params->ie_list.country = (uint8_t *)ie; 526 break; 527 case WLAN_ELEMID_QBSS_LOAD: 528 if (ie->ie_len != sizeof(struct qbss_load_ie) - 529 sizeof(struct ie_header)) { 530 /* 531 * Expected QBSS IE length is 5Bytes; For some 532 * old cisco AP, QBSS IE length is 4Bytes, which 533 * doesn't match with latest spec, So ignore 534 * QBSS IE in such case. 535 */ 536 break; 537 } 538 scan_params->ie_list.qbssload = (uint8_t *)ie; 539 break; 540 case WLAN_ELEMID_CHANSWITCHANN: 541 if (ie->ie_len != WLAN_CSA_IE_MAX_LEN) 542 return QDF_STATUS_E_INVAL; 543 scan_params->ie_list.csa = (uint8_t *)ie; 544 break; 545 case WLAN_ELEMID_IBSSDFS: 546 if (ie->ie_len < WLAN_IBSSDFS_IE_MIN_LEN) 547 return QDF_STATUS_E_INVAL; 548 scan_params->ie_list.ibssdfs = (uint8_t *)ie; 549 break; 550 case WLAN_ELEMID_QUIET: 551 if (ie->ie_len != WLAN_QUIET_IE_MAX_LEN) 552 return QDF_STATUS_E_INVAL; 553 scan_params->ie_list.quiet = (uint8_t *)ie; 554 break; 555 case WLAN_ELEMID_ERP: 556 if (ie->ie_len != (sizeof(struct erp_ie) - 557 sizeof(struct ie_header))) 558 return QDF_STATUS_E_INVAL; 559 scan_params->erp = ((struct erp_ie *)ie)->value; 560 break; 561 case WLAN_ELEMID_HTCAP_ANA: 562 if (ie->ie_len != sizeof(struct htcap_cmn_ie)) 563 return QDF_STATUS_E_INVAL; 564 scan_params->ie_list.htcap = 565 (uint8_t *)&(((struct htcap_ie *)ie)->ie); 566 break; 567 case WLAN_ELEMID_RSN: 568 if (ie->ie_len < WLAN_RSN_IE_MIN_LEN) 569 return QDF_STATUS_E_INVAL; 570 scan_params->ie_list.rsn = (uint8_t *)ie; 571 break; 572 case WLAN_ELEMID_XRATES: 573 scan_params->ie_list.xrates = (uint8_t *)ie; 574 break; 575 case WLAN_ELEMID_EXTCHANSWITCHANN: 576 if (ie->ie_len != WLAN_XCSA_IE_MAX_LEN) 577 return QDF_STATUS_E_INVAL; 578 scan_params->ie_list.xcsa = (uint8_t *)ie; 579 break; 580 case WLAN_ELEMID_SECCHANOFFSET: 581 if (ie->ie_len != WLAN_SECCHANOFF_IE_MAX_LEN) 582 return QDF_STATUS_E_INVAL; 583 scan_params->ie_list.secchanoff = (uint8_t *)ie; 584 break; 585 case WLAN_ELEMID_HTINFO_ANA: 586 if (ie->ie_len != sizeof(struct wlan_ie_htinfo_cmn)) 587 return QDF_STATUS_E_INVAL; 588 scan_params->ie_list.htinfo = 589 (uint8_t *)&(((struct wlan_ie_htinfo *) ie)->hi_ie); 590 scan_params->channel.chan_idx = 591 ((struct wlan_ie_htinfo_cmn *) 592 (scan_params->ie_list.htinfo))->hi_ctrlchannel; 593 break; 594 case WLAN_ELEMID_WAPI: 595 if (ie->ie_len < WLAN_WAPI_IE_MIN_LEN) 596 return QDF_STATUS_E_INVAL; 597 scan_params->ie_list.wapi = (uint8_t *)ie; 598 break; 599 case WLAN_ELEMID_XCAPS: 600 if (ie->ie_len > WLAN_EXTCAP_IE_MAX_LEN) 601 return QDF_STATUS_E_INVAL; 602 scan_params->ie_list.extcaps = (uint8_t *)ie; 603 break; 604 case WLAN_ELEMID_VHTCAP: 605 if (ie->ie_len != (sizeof(struct wlan_ie_vhtcaps) - 606 sizeof(struct ie_header))) 607 return QDF_STATUS_E_INVAL; 608 scan_params->ie_list.vhtcap = (uint8_t *)ie; 609 break; 610 case WLAN_ELEMID_VHTOP: 611 if (ie->ie_len != (sizeof(struct wlan_ie_vhtop) - 612 sizeof(struct ie_header))) 613 return QDF_STATUS_E_INVAL; 614 scan_params->ie_list.vhtop = (uint8_t *)ie; 615 break; 616 case WLAN_ELEMID_OP_MODE_NOTIFY: 617 if (ie->ie_len != WLAN_OPMODE_IE_MAX_LEN) 618 return QDF_STATUS_E_INVAL; 619 scan_params->ie_list.opmode = (uint8_t *)ie; 620 break; 621 case WLAN_ELEMID_MOBILITY_DOMAIN: 622 if (ie->ie_len != WLAN_MOBILITY_DOMAIN_IE_MAX_LEN) 623 return QDF_STATUS_E_INVAL; 624 scan_params->ie_list.mdie = (uint8_t *)ie; 625 break; 626 case WLAN_ELEMID_VENDOR: 627 status = util_scan_parse_vendor_ie(scan_params, 628 ie); 629 if (QDF_IS_STATUS_ERROR(status)) 630 return status; 631 break; 632 case WLAN_ELEMID_CHAN_SWITCH_WRAP: 633 scan_params->ie_list.cswrp = (uint8_t *)ie; 634 /* Go to next sub IE */ 635 sub_ie = (struct ie_header *) 636 (((uint8_t *)ie) + sizeof(struct ie_header)); 637 sub_ie_len = ie->ie_len; 638 status = 639 util_scan_parse_chan_switch_wrapper_ie( 640 scan_params, sub_ie, sub_ie_len); 641 if (QDF_IS_STATUS_ERROR(status)) { 642 scm_err("failed to parse chan_switch_wrapper_ie"); 643 return status; 644 } 645 break; 646 case WLAN_ELEMID_FILS_INDICATION: 647 if (ie->ie_len < WLAN_FILS_INDICATION_IE_MIN_LEN) 648 return QDF_STATUS_E_INVAL; 649 scan_params->ie_list.fils_indication = (uint8_t *)ie; 650 break; 651 case WLAN_ELEMID_EXTN_ELEM: 652 status = util_scan_parse_extn_ie(scan_params, ie); 653 if (QDF_IS_STATUS_ERROR(status)) 654 return status; 655 break; 656 default: 657 break; 658 } 659 660 /* Consume info element */ 661 ie_len -= ie->ie_len; 662 /* Go to next IE */ 663 ie = (struct ie_header *) 664 (((uint8_t *) ie) + 665 sizeof(struct ie_header) + 666 ie->ie_len); 667 } 668 669 return QDF_STATUS_SUCCESS; 670 } 671 672 /** 673 * util_scan_update_esp_data: update ESP params from beacon/probe response 674 * @esp_information: pointer to wlan_esp_information 675 * @scan_entry: new received entry 676 * 677 * The Estimated Service Parameters element is 678 * used by a AP to provide information to another STA which 679 * can then use the information as input to an algorithm to 680 * generate an estimate of throughput between the two STAs. 681 * The ESP Information List field contains from 1 to 4 ESP 682 * Information fields(each field 24 bits), each corresponding 683 * to an access category for which estimated service parameters 684 * information is provided. 685 * 686 * Return: None 687 */ 688 static void util_scan_update_esp_data(struct wlan_esp_ie *esp_information, 689 struct scan_cache_entry *scan_entry) 690 { 691 692 uint8_t *data; 693 int i = 0; 694 uint64_t total_elements; 695 struct wlan_esp_info *esp_info; 696 struct wlan_esp_ie *esp_ie; 697 698 esp_ie = (struct wlan_esp_ie *) 699 util_scan_entry_esp_info(scan_entry); 700 701 total_elements = esp_ie->esp_len; 702 data = (uint8_t *)esp_ie + 3; 703 do_div(total_elements, ESP_INFORMATION_LIST_LENGTH); 704 705 if (total_elements > MAX_ESP_INFORMATION_FIELD) { 706 scm_err("No of Air time fractions are greater than supported"); 707 return; 708 } 709 710 for (i = 0; i < total_elements; i++) { 711 esp_info = (struct wlan_esp_info *)data; 712 if (esp_info->access_category == ESP_AC_BK) { 713 qdf_mem_copy(&esp_information->esp_info_AC_BK, 714 data, 3); 715 data = data + ESP_INFORMATION_LIST_LENGTH; 716 continue; 717 } 718 if (esp_info->access_category == ESP_AC_BE) { 719 qdf_mem_copy(&esp_information->esp_info_AC_BE, 720 data, 3); 721 data = data + ESP_INFORMATION_LIST_LENGTH; 722 continue; 723 } 724 if (esp_info->access_category == ESP_AC_VI) { 725 qdf_mem_copy(&esp_information->esp_info_AC_VI, 726 data, 3); 727 data = data + ESP_INFORMATION_LIST_LENGTH; 728 continue; 729 } 730 if (esp_info->access_category == ESP_AC_VO) { 731 qdf_mem_copy(&esp_information->esp_info_AC_VO, 732 data, 3); 733 data = data + ESP_INFORMATION_LIST_LENGTH; 734 break; 735 } 736 } 737 } 738 739 /** 740 * util_scan_scm_update_bss_with_esp_dataa: calculate estimated air time 741 * fraction 742 * @scan_entry: new received entry 743 * 744 * This function process all Access category ESP params and provide 745 * best effort air time fraction. 746 * If best effort is not available, it will choose VI, VO and BK in sequence 747 * 748 */ 749 static void util_scan_scm_update_bss_with_esp_data( 750 struct scan_cache_entry *scan_entry) 751 { 752 uint8_t air_time_fraction = 0; 753 struct wlan_esp_ie esp_information; 754 755 if (!scan_entry->ie_list.esp) 756 return; 757 758 util_scan_update_esp_data(&esp_information, scan_entry); 759 760 /* 761 * If the ESP metric is transmitting multiple airtime fractions, then 762 * follow the sequence AC_BE, AC_VI, AC_VO, AC_BK and pick whichever is 763 * the first one available 764 */ 765 if (esp_information.esp_info_AC_BE.access_category 766 == ESP_AC_BE) 767 air_time_fraction = 768 esp_information.esp_info_AC_BE. 769 estimated_air_fraction; 770 else if (esp_information.esp_info_AC_VI.access_category 771 == ESP_AC_VI) 772 air_time_fraction = 773 esp_information.esp_info_AC_VI. 774 estimated_air_fraction; 775 else if (esp_information.esp_info_AC_VO.access_category 776 == ESP_AC_VO) 777 air_time_fraction = 778 esp_information.esp_info_AC_VO. 779 estimated_air_fraction; 780 else if (esp_information.esp_info_AC_BK.access_category 781 == ESP_AC_BK) 782 air_time_fraction = 783 esp_information.esp_info_AC_BK. 784 estimated_air_fraction; 785 scan_entry->air_time_fraction = air_time_fraction; 786 } 787 788 /** 789 * util_scan_scm_calc_nss_supported_by_ap() - finds out nss from AP 790 * @scan_entry: new received entry 791 * 792 * Return: number of nss advertised by AP 793 */ 794 static int util_scan_scm_calc_nss_supported_by_ap( 795 struct scan_cache_entry *scan_params) 796 { 797 struct htcap_cmn_ie *htcap; 798 struct wlan_ie_vhtcaps *vhtcaps; 799 uint8_t rx_mcs_map; 800 801 htcap = (struct htcap_cmn_ie *) 802 util_scan_entry_htcap(scan_params); 803 vhtcaps = (struct wlan_ie_vhtcaps *) 804 util_scan_entry_vhtcap(scan_params); 805 if (vhtcaps) { 806 rx_mcs_map = vhtcaps->rx_mcs_map; 807 if ((rx_mcs_map & 0xC0) != 0xC0) 808 return 4; 809 810 if ((rx_mcs_map & 0x30) != 0x30) 811 return 3; 812 813 if ((rx_mcs_map & 0x0C) != 0x0C) 814 return 2; 815 } else if (htcap) { 816 if (htcap->mcsset[3]) 817 return 4; 818 819 if (htcap->mcsset[2]) 820 return 3; 821 822 if (htcap->mcsset[1]) 823 return 2; 824 825 } 826 return 1; 827 } 828 829 qdf_list_t * 830 util_scan_unpack_beacon_frame(struct wlan_objmgr_pdev *pdev, uint8_t *frame, 831 qdf_size_t frame_len, uint32_t frm_subtype, 832 struct mgmt_rx_event_params *rx_param) 833 { 834 struct wlan_frame_hdr *hdr; 835 struct wlan_bcn_frame *bcn; 836 QDF_STATUS status; 837 struct ie_ssid *ssid; 838 struct scan_cache_entry *scan_entry; 839 struct qbss_load_ie *qbss_load; 840 qdf_list_t *scan_list; 841 struct scan_cache_node *scan_node; 842 843 scan_list = qdf_mem_malloc_atomic(sizeof(*scan_list)); 844 if (!scan_list) { 845 scm_err("failed to allocate scan_list"); 846 return NULL; 847 } 848 qdf_list_create(scan_list, MAX_SCAN_CACHE_SIZE); 849 850 scan_entry = qdf_mem_malloc_atomic(sizeof(*scan_entry)); 851 if (!scan_entry) { 852 scm_err("failed to allocate memory for scan_entry"); 853 qdf_mem_free(scan_list); 854 return NULL; 855 } 856 scan_entry->raw_frame.ptr = 857 qdf_mem_malloc_atomic(frame_len); 858 if (!scan_entry->raw_frame.ptr) { 859 scm_err("failed to allocate memory for frame"); 860 qdf_mem_free(scan_entry); 861 qdf_mem_free(scan_list); 862 return NULL; 863 } 864 865 bcn = (struct wlan_bcn_frame *) 866 (frame + sizeof(*hdr)); 867 hdr = (struct wlan_frame_hdr *)frame; 868 869 /* update timestamp in nanoseconds needed by kernel layers */ 870 scan_entry->boottime_ns = qdf_get_bootbased_boottime_ns(); 871 872 scan_entry->frm_subtype = frm_subtype; 873 qdf_mem_copy(scan_entry->bssid.bytes, 874 hdr->i_addr3, QDF_MAC_ADDR_SIZE); 875 /* Scr addr */ 876 qdf_mem_copy(scan_entry->mac_addr.bytes, 877 hdr->i_addr2, QDF_MAC_ADDR_SIZE); 878 scan_entry->seq_num = 879 (le16toh(*(uint16_t *)hdr->i_seq) >> WLAN_SEQ_SEQ_SHIFT); 880 881 scan_entry->rssi_raw = rx_param->rssi; 882 scan_entry->avg_rssi = WLAN_RSSI_IN(scan_entry->rssi_raw); 883 scan_entry->tsf_delta = rx_param->tsf_delta; 884 885 /* Copy per chain rssi to scan entry */ 886 qdf_mem_copy(scan_entry->per_chain_snr, rx_param->rssi_ctl, 887 WLAN_MGMT_TXRX_HOST_MAX_ANTENNA); 888 889 /* store jiffies */ 890 scan_entry->rrm_parent_tsf = (u_int32_t) qdf_system_ticks(); 891 892 scan_entry->bcn_int = le16toh(bcn->beacon_interval); 893 894 /* 895 * In case if the beacon dosnt have 896 * valid beacon interval falback to def 897 */ 898 if (!scan_entry->bcn_int) 899 scan_entry->bcn_int = 100; 900 scan_entry->cap_info.value = le16toh(bcn->capability.value); 901 qdf_mem_copy(scan_entry->tsf_info.data, 902 bcn->timestamp, 8); 903 scan_entry->erp = ERP_NON_ERP_PRESENT; 904 905 scan_entry->scan_entry_time = 906 qdf_mc_timer_get_system_time(); 907 908 scan_entry->raw_frame.len = frame_len; 909 qdf_mem_copy(scan_entry->raw_frame.ptr, 910 frame, frame_len); 911 status = util_scan_populate_bcn_ie_list(scan_entry); 912 if (QDF_IS_STATUS_ERROR(status)) { 913 scm_debug("failed to parse beacon IE"); 914 qdf_mem_free(scan_entry->raw_frame.ptr); 915 qdf_mem_free(scan_entry); 916 qdf_mem_free(scan_list); 917 return NULL; 918 } 919 920 if (!scan_entry->ie_list.rates) { 921 qdf_mem_free(scan_entry->raw_frame.ptr); 922 qdf_mem_free(scan_entry); 923 qdf_mem_free(scan_list); 924 return NULL; 925 } 926 927 ssid = (struct ie_ssid *) 928 scan_entry->ie_list.ssid; 929 930 if (ssid && (ssid->ssid_len > WLAN_SSID_MAX_LEN)) { 931 qdf_mem_free(scan_entry->raw_frame.ptr); 932 qdf_mem_free(scan_entry); 933 qdf_mem_free(scan_list); 934 return NULL; 935 } 936 937 if (scan_entry->ie_list.p2p) 938 scan_entry->is_p2p = true; 939 940 /* If no channel info is present in beacon use meta channel */ 941 if (!scan_entry->channel.chan_idx) { 942 scan_entry->channel.chan_idx = 943 rx_param->channel; 944 } else if (rx_param->channel != 945 scan_entry->channel.chan_idx) { 946 if (!wlan_reg_chan_is_49ghz(pdev, scan_entry->channel.chan_idx)) 947 scan_entry->channel_mismatch = true; 948 } 949 950 if (util_scan_is_hidden_ssid(ssid)) { 951 scan_entry->ie_list.ssid = NULL; 952 } else { 953 qdf_mem_copy(scan_entry->ssid.ssid, 954 ssid->ssid, WLAN_SSID_MAX_LEN); 955 scan_entry->ssid.length = ssid->ssid_len; 956 scan_entry->hidden_ssid_timestamp = 957 scan_entry->scan_entry_time; 958 } 959 960 if (WLAN_CHAN_IS_5GHZ(scan_entry->channel.chan_idx)) 961 scan_entry->phy_mode = util_scan_get_phymode_5g(scan_entry); 962 else 963 scan_entry->phy_mode = util_scan_get_phymode_2g(scan_entry); 964 965 scan_entry->nss = util_scan_scm_calc_nss_supported_by_ap(scan_entry); 966 util_scan_scm_update_bss_with_esp_data(scan_entry); 967 qbss_load = (struct qbss_load_ie *) 968 util_scan_entry_qbssload(scan_entry); 969 if (qbss_load) 970 scan_entry->qbss_chan_load = qbss_load->qbss_chan_load; 971 972 scan_node = qdf_mem_malloc_atomic(sizeof(*scan_node)); 973 if (!scan_node) { 974 qdf_mem_free(scan_entry->raw_frame.ptr); 975 qdf_mem_free(scan_entry); 976 qdf_mem_free(scan_list); 977 return NULL; 978 } 979 980 scan_node->entry = scan_entry; 981 qdf_list_insert_front(scan_list, &scan_node->node); 982 983 /* TODO calculate channel struct */ 984 return scan_list; 985 } 986 987 QDF_STATUS 988 util_scan_entry_update_mlme_info(struct wlan_objmgr_pdev *pdev, 989 struct scan_cache_entry *scan_entry) 990 { 991 992 if (!pdev || !scan_entry) { 993 scm_err("pdev 0x%pK, scan_entry: 0x%pK", pdev, scan_entry); 994 return QDF_STATUS_E_INVAL; 995 } 996 997 return scm_update_scan_mlme_info(pdev, scan_entry); 998 } 999 1000 bool util_is_scan_completed(struct scan_event *event, bool *success) 1001 { 1002 if ((event->type == SCAN_EVENT_TYPE_COMPLETED) || 1003 (event->type == SCAN_EVENT_TYPE_DEQUEUED) || 1004 (event->type == SCAN_EVENT_TYPE_START_FAILED)) { 1005 if ((event->type == SCAN_EVENT_TYPE_COMPLETED) && 1006 (event->reason == SCAN_REASON_COMPLETED)) 1007 *success = true; 1008 else 1009 *success = false; 1010 1011 return true; 1012 } 1013 1014 *success = false; 1015 return false; 1016 } 1017 1018