1 // SPDX-License-Identifier: GPL-2.0 2 /****************************************************************************** 3 * 4 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved. 5 * 6 ******************************************************************************/ 7 8 #include <drv_types.h> 9 #include <hal_com_h2c.h> 10 11 static unsigned char ARTHEROS_OUI1[] = {0x00, 0x03, 0x7f}; 12 static unsigned char ARTHEROS_OUI2[] = {0x00, 0x13, 0x74}; 13 14 static unsigned char BROADCOM_OUI1[] = {0x00, 0x10, 0x18}; 15 static unsigned char BROADCOM_OUI2[] = {0x00, 0x0a, 0xf7}; 16 static unsigned char BROADCOM_OUI3[] = {0x00, 0x05, 0xb5}; 17 18 static unsigned char CISCO_OUI[] = {0x00, 0x40, 0x96}; 19 static unsigned char MARVELL_OUI[] = {0x00, 0x50, 0x43}; 20 static unsigned char RALINK_OUI[] = {0x00, 0x0c, 0x43}; 21 static unsigned char REALTEK_OUI[] = {0x00, 0xe0, 0x4c}; 22 static unsigned char AIRGOCAP_OUI[] = {0x00, 0x0a, 0xf5}; 23 static unsigned char RSN_TKIP_CIPHER[4] = {0x00, 0x0f, 0xac, 0x02}; 24 static unsigned char WPA_TKIP_CIPHER[4] = {0x00, 0x50, 0xf2, 0x02}; 25 26 /* define WAIT_FOR_BCN_TO_MIN (3000) */ 27 #define WAIT_FOR_BCN_TO_MIN (6000) 28 #define WAIT_FOR_BCN_TO_MAX (20000) 29 30 #define DISCONNECT_BY_CHK_BCN_FAIL_OBSERV_PERIOD_IN_MS 1000 31 #define DISCONNECT_BY_CHK_BCN_FAIL_THRESHOLD 3 32 33 static u8 rtw_basic_rate_cck[4] = { 34 IEEE80211_CCK_RATE_1MB | IEEE80211_BASIC_RATE_MASK, 35 IEEE80211_CCK_RATE_2MB | IEEE80211_BASIC_RATE_MASK, 36 IEEE80211_CCK_RATE_5MB | IEEE80211_BASIC_RATE_MASK, 37 IEEE80211_CCK_RATE_11MB | IEEE80211_BASIC_RATE_MASK 38 }; 39 40 static u8 rtw_basic_rate_ofdm[3] = { 41 IEEE80211_OFDM_RATE_6MB | IEEE80211_BASIC_RATE_MASK, 42 IEEE80211_OFDM_RATE_12MB | IEEE80211_BASIC_RATE_MASK, 43 IEEE80211_OFDM_RATE_24MB | IEEE80211_BASIC_RATE_MASK 44 }; 45 46 u8 networktype_to_raid_ex(struct adapter *adapter, struct sta_info *psta) 47 { 48 u8 raid; 49 50 switch (psta->wireless_mode) { 51 case WIRELESS_11B: 52 raid = RATEID_IDX_B; 53 break; 54 case WIRELESS_11G: 55 raid = RATEID_IDX_G; 56 break; 57 case WIRELESS_11BG: 58 raid = RATEID_IDX_BG; 59 break; 60 case WIRELESS_11_24N: 61 case WIRELESS_11G_24N: 62 raid = RATEID_IDX_GN_N1SS; 63 break; 64 case WIRELESS_11B_24N: 65 case WIRELESS_11BG_24N: 66 if (psta->bw_mode == CHANNEL_WIDTH_20) 67 raid = RATEID_IDX_BGN_20M_1SS_BN; 68 else 69 raid = RATEID_IDX_BGN_40M_1SS; 70 break; 71 default: 72 raid = RATEID_IDX_BGN_40M_2SS; 73 break; 74 } 75 return raid; 76 } 77 78 unsigned char ratetbl_val_2wifirate(unsigned char rate); 79 unsigned char ratetbl_val_2wifirate(unsigned char rate) 80 { 81 switch (rate & 0x7f) { 82 case 0: 83 return IEEE80211_CCK_RATE_1MB; 84 case 1: 85 return IEEE80211_CCK_RATE_2MB; 86 case 2: 87 return IEEE80211_CCK_RATE_5MB; 88 case 3: 89 return IEEE80211_CCK_RATE_11MB; 90 case 4: 91 return IEEE80211_OFDM_RATE_6MB; 92 case 5: 93 return IEEE80211_OFDM_RATE_9MB; 94 case 6: 95 return IEEE80211_OFDM_RATE_12MB; 96 case 7: 97 return IEEE80211_OFDM_RATE_18MB; 98 case 8: 99 return IEEE80211_OFDM_RATE_24MB; 100 case 9: 101 return IEEE80211_OFDM_RATE_36MB; 102 case 10: 103 return IEEE80211_OFDM_RATE_48MB; 104 case 11: 105 return IEEE80211_OFDM_RATE_54MB; 106 default: 107 return 0; 108 } 109 } 110 111 int is_basicrate(struct adapter *padapter, unsigned char rate); 112 int is_basicrate(struct adapter *padapter, unsigned char rate) 113 { 114 int i; 115 unsigned char val; 116 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 117 118 for (i = 0; i < NumRates; i++) { 119 val = pmlmeext->basicrate[i]; 120 121 if ((val != 0xff) && (val != 0xfe)) 122 if (rate == ratetbl_val_2wifirate(val)) 123 return true; 124 } 125 126 return false; 127 } 128 129 unsigned int ratetbl2rateset(struct adapter *padapter, unsigned char *rateset); 130 unsigned int ratetbl2rateset(struct adapter *padapter, unsigned char *rateset) 131 { 132 int i; 133 unsigned char rate; 134 unsigned int len = 0; 135 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 136 137 for (i = 0; i < NumRates; i++) { 138 rate = pmlmeext->datarate[i]; 139 140 switch (rate) { 141 case 0xff: 142 return len; 143 144 case 0xfe: 145 continue; 146 147 default: 148 rate = ratetbl_val_2wifirate(rate); 149 150 if (is_basicrate(padapter, rate) == true) 151 rate |= IEEE80211_BASIC_RATE_MASK; 152 153 rateset[len] = rate; 154 len++; 155 break; 156 } 157 } 158 return len; 159 } 160 161 void get_rate_set(struct adapter *padapter, unsigned char *pbssrate, int *bssrate_len) 162 { 163 unsigned char supportedrates[NumRates]; 164 165 memset(supportedrates, 0, NumRates); 166 *bssrate_len = ratetbl2rateset(padapter, supportedrates); 167 memcpy(pbssrate, supportedrates, *bssrate_len); 168 } 169 170 void set_mcs_rate_by_mask(u8 *mcs_set, u32 mask) 171 { 172 u8 mcs_rate_1r = (u8)(mask & 0xff); 173 u8 mcs_rate_2r = (u8)((mask >> 8) & 0xff); 174 u8 mcs_rate_3r = (u8)((mask >> 16) & 0xff); 175 u8 mcs_rate_4r = (u8)((mask >> 24) & 0xff); 176 177 mcs_set[0] &= mcs_rate_1r; 178 mcs_set[1] &= mcs_rate_2r; 179 mcs_set[2] &= mcs_rate_3r; 180 mcs_set[3] &= mcs_rate_4r; 181 } 182 183 void update_basic_rate_table(struct adapter *Adapter, u8 *mBratesOS) 184 { 185 u8 i; 186 u8 rate; 187 188 /* 1M, 2M, 5.5M, 11M, 6M, 12M, 24M are mandatory. */ 189 for (i = 0; i < NDIS_802_11_LENGTH_RATES_EX; i++) { 190 rate = mBratesOS[i] & 0x7f; 191 switch (rate) { 192 case IEEE80211_CCK_RATE_1MB: 193 case IEEE80211_CCK_RATE_2MB: 194 case IEEE80211_CCK_RATE_5MB: 195 case IEEE80211_CCK_RATE_11MB: 196 case IEEE80211_OFDM_RATE_6MB: 197 case IEEE80211_OFDM_RATE_12MB: 198 case IEEE80211_OFDM_RATE_24MB: 199 mBratesOS[i] |= IEEE80211_BASIC_RATE_MASK; 200 break; 201 } 202 } 203 } 204 205 void update_basic_rate_table_soft_ap(u8 *bssrateset, u32 bssratelen) 206 { 207 u8 i; 208 u8 rate; 209 210 for (i = 0; i < bssratelen; i++) { 211 rate = bssrateset[i] & 0x7f; 212 switch (rate) { 213 case IEEE80211_CCK_RATE_1MB: 214 case IEEE80211_CCK_RATE_2MB: 215 case IEEE80211_CCK_RATE_5MB: 216 case IEEE80211_CCK_RATE_11MB: 217 bssrateset[i] |= IEEE80211_BASIC_RATE_MASK; 218 break; 219 } 220 } 221 } 222 223 void Save_DM_Func_Flag(struct adapter *padapter) 224 { 225 u8 bSaveFlag = true; 226 227 rtw_hal_set_hwreg(padapter, HW_VAR_DM_FUNC_OP, (u8 *)(&bSaveFlag)); 228 } 229 230 void Restore_DM_Func_Flag(struct adapter *padapter) 231 { 232 u8 bSaveFlag = false; 233 234 rtw_hal_set_hwreg(padapter, HW_VAR_DM_FUNC_OP, (u8 *)(&bSaveFlag)); 235 } 236 237 void Switch_DM_Func(struct adapter *padapter, u32 mode, u8 enable) 238 { 239 if (enable == true) 240 rtw_hal_set_hwreg(padapter, HW_VAR_DM_FUNC_SET, (u8 *)(&mode)); 241 else 242 rtw_hal_set_hwreg(padapter, HW_VAR_DM_FUNC_CLR, (u8 *)(&mode)); 243 } 244 245 void set_msr(struct adapter *padapter, u8 type) 246 { 247 rtw_hal_set_hwreg(padapter, HW_VAR_MEDIA_STATUS, (u8 *)(&type)); 248 } 249 250 inline u8 rtw_get_oper_ch(struct adapter *adapter) 251 { 252 return adapter_to_dvobj(adapter)->oper_channel; 253 } 254 255 inline void rtw_set_oper_ch(struct adapter *adapter, u8 ch) 256 { 257 #ifdef DBG_CH_SWITCH 258 const int len = 128; 259 char msg[128] = {0}; 260 int cnt = 0; 261 int i = 0; 262 #endif /* DBG_CH_SWITCH */ 263 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter); 264 265 if (dvobj->oper_channel != ch) { 266 dvobj->on_oper_ch_time = jiffies; 267 268 #ifdef DBG_CH_SWITCH 269 cnt += scnprintf(msg + cnt, len - cnt, "switch to ch %3u", ch); 270 271 for (i = 0; i < dvobj->iface_nums; i++) { 272 struct adapter *iface = dvobj->padapters[i]; 273 274 cnt += scnprintf(msg + cnt, len - cnt, " [%s:", ADPT_ARG(iface)); 275 if (iface->mlmeextpriv.cur_channel == ch) 276 cnt += scnprintf(msg + cnt, len - cnt, "C"); 277 else 278 cnt += scnprintf(msg + cnt, len - cnt, "_"); 279 if (iface->wdinfo.listen_channel == ch && !rtw_p2p_chk_state(&iface->wdinfo, P2P_STATE_NONE)) 280 cnt += scnprintf(msg + cnt, len - cnt, "L"); 281 else 282 cnt += scnprintf(msg + cnt, len - cnt, "_"); 283 cnt += scnprintf(msg + cnt, len - cnt, "]"); 284 } 285 286 #endif /* DBG_CH_SWITCH */ 287 } 288 289 dvobj->oper_channel = ch; 290 } 291 292 inline void rtw_set_oper_bw(struct adapter *adapter, u8 bw) 293 { 294 adapter_to_dvobj(adapter)->oper_bwmode = bw; 295 } 296 297 inline void rtw_set_oper_choffset(struct adapter *adapter, u8 offset) 298 { 299 adapter_to_dvobj(adapter)->oper_ch_offset = offset; 300 } 301 302 u8 rtw_get_center_ch(u8 channel, u8 chnl_bw, u8 chnl_offset) 303 { 304 u8 center_ch = channel; 305 306 if (chnl_bw == CHANNEL_WIDTH_40) { 307 if (chnl_offset == HAL_PRIME_CHNL_OFFSET_LOWER) 308 center_ch = channel + 2; 309 else 310 center_ch = channel - 2; 311 } 312 313 return center_ch; 314 } 315 316 inline unsigned long rtw_get_on_cur_ch_time(struct adapter *adapter) 317 { 318 if (adapter->mlmeextpriv.cur_channel == adapter_to_dvobj(adapter)->oper_channel) 319 return adapter_to_dvobj(adapter)->on_oper_ch_time; 320 else 321 return 0; 322 } 323 324 void r8723bs_select_channel(struct adapter *padapter, unsigned char channel) 325 { 326 if (mutex_lock_interruptible(&(adapter_to_dvobj(padapter)->setch_mutex))) 327 return; 328 329 /* saved channel info */ 330 rtw_set_oper_ch(padapter, channel); 331 332 rtw_hal_set_chan(padapter, channel); 333 334 mutex_unlock(&(adapter_to_dvobj(padapter)->setch_mutex)); 335 } 336 337 void set_channel_bwmode(struct adapter *padapter, unsigned char channel, unsigned char channel_offset, unsigned short bwmode) 338 { 339 u8 center_ch, chnl_offset80 = HAL_PRIME_CHNL_OFFSET_DONT_CARE; 340 341 center_ch = rtw_get_center_ch(channel, bwmode, channel_offset); 342 343 344 /* set Channel */ 345 if (mutex_lock_interruptible(&(adapter_to_dvobj(padapter)->setch_mutex))) 346 return; 347 348 /* saved channel/bw info */ 349 rtw_set_oper_ch(padapter, channel); 350 rtw_set_oper_bw(padapter, bwmode); 351 rtw_set_oper_choffset(padapter, channel_offset); 352 353 rtw_hal_set_chnl_bw(padapter, center_ch, bwmode, channel_offset, chnl_offset80); /* set center channel */ 354 355 mutex_unlock(&(adapter_to_dvobj(padapter)->setch_mutex)); 356 } 357 358 inline u8 *get_my_bssid(struct wlan_bssid_ex *pnetwork) 359 { 360 return pnetwork->mac_address; 361 } 362 363 u16 get_beacon_interval(struct wlan_bssid_ex *bss) 364 { 365 __le16 val; 366 367 memcpy((unsigned char *)&val, rtw_get_beacon_interval_from_ie(bss->ies), 2); 368 369 return le16_to_cpu(val); 370 } 371 372 int is_client_associated_to_ap(struct adapter *padapter) 373 { 374 struct mlme_ext_priv *pmlmeext; 375 struct mlme_ext_info *pmlmeinfo; 376 377 if (!padapter) 378 return _FAIL; 379 380 pmlmeext = &padapter->mlmeextpriv; 381 pmlmeinfo = &(pmlmeext->mlmext_info); 382 383 if ((pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS) && ((pmlmeinfo->state & 0x03) == WIFI_FW_STATION_STATE)) 384 return true; 385 else 386 return _FAIL; 387 } 388 389 int is_client_associated_to_ibss(struct adapter *padapter) 390 { 391 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 392 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 393 394 if ((pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS) && ((pmlmeinfo->state & 0x03) == WIFI_FW_ADHOC_STATE)) 395 return true; 396 else 397 return _FAIL; 398 } 399 400 int is_IBSS_empty(struct adapter *padapter) 401 { 402 unsigned int i; 403 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 404 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 405 406 for (i = IBSS_START_MAC_ID; i < NUM_STA; i++) { 407 if (pmlmeinfo->FW_sta_info[i].status == 1) 408 return _FAIL; 409 } 410 411 return true; 412 } 413 414 unsigned int decide_wait_for_beacon_timeout(unsigned int bcn_interval) 415 { 416 if ((bcn_interval << 2) < WAIT_FOR_BCN_TO_MIN) 417 return WAIT_FOR_BCN_TO_MIN; 418 else if ((bcn_interval << 2) > WAIT_FOR_BCN_TO_MAX) 419 return WAIT_FOR_BCN_TO_MAX; 420 else 421 return bcn_interval << 2; 422 } 423 424 void invalidate_cam_all(struct adapter *padapter) 425 { 426 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter); 427 struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl; 428 429 rtw_hal_set_hwreg(padapter, HW_VAR_CAM_INVALID_ALL, NULL); 430 431 spin_lock_bh(&cam_ctl->lock); 432 cam_ctl->bitmap = 0; 433 memset(dvobj->cam_cache, 0, sizeof(struct cam_entry_cache) * TOTAL_CAM_ENTRY); 434 spin_unlock_bh(&cam_ctl->lock); 435 } 436 437 void _write_cam(struct adapter *padapter, u8 entry, u16 ctrl, u8 *mac, u8 *key) 438 { 439 unsigned int i, val, addr; 440 int j; 441 u32 cam_val[2]; 442 443 addr = entry << 3; 444 445 for (j = 5; j >= 0; j--) { 446 switch (j) { 447 case 0: 448 val = (ctrl | (mac[0] << 16) | (mac[1] << 24)); 449 break; 450 case 1: 451 val = (mac[2] | (mac[3] << 8) | (mac[4] << 16) | (mac[5] << 24)); 452 break; 453 default: 454 i = (j - 2) << 2; 455 val = (key[i] | (key[i + 1] << 8) | (key[i + 2] << 16) | (key[i + 3] << 24)); 456 break; 457 } 458 459 cam_val[0] = val; 460 cam_val[1] = addr + (unsigned int)j; 461 462 rtw_hal_set_hwreg(padapter, HW_VAR_CAM_WRITE, (u8 *)cam_val); 463 } 464 } 465 466 void _clear_cam_entry(struct adapter *padapter, u8 entry) 467 { 468 unsigned char null_sta[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 469 unsigned char null_key[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 470 471 _write_cam(padapter, entry, 0, null_sta, null_key); 472 } 473 474 inline void write_cam(struct adapter *adapter, u8 id, u16 ctrl, u8 *mac, u8 *key) 475 { 476 _write_cam(adapter, id, ctrl, mac, key); 477 write_cam_cache(adapter, id, ctrl, mac, key); 478 } 479 480 inline void clear_cam_entry(struct adapter *adapter, u8 id) 481 { 482 _clear_cam_entry(adapter, id); 483 clear_cam_cache(adapter, id); 484 } 485 486 void write_cam_cache(struct adapter *adapter, u8 id, u16 ctrl, u8 *mac, u8 *key) 487 { 488 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter); 489 struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl; 490 491 spin_lock_bh(&cam_ctl->lock); 492 493 dvobj->cam_cache[id].ctrl = ctrl; 494 memcpy(dvobj->cam_cache[id].mac, mac, ETH_ALEN); 495 memcpy(dvobj->cam_cache[id].key, key, 16); 496 497 spin_unlock_bh(&cam_ctl->lock); 498 } 499 500 void clear_cam_cache(struct adapter *adapter, u8 id) 501 { 502 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter); 503 struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl; 504 505 spin_lock_bh(&cam_ctl->lock); 506 507 memset(&(dvobj->cam_cache[id]), 0, sizeof(struct cam_entry_cache)); 508 509 spin_unlock_bh(&cam_ctl->lock); 510 } 511 512 static bool _rtw_camid_is_gk(struct adapter *adapter, u8 cam_id) 513 { 514 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter); 515 struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl; 516 bool ret = false; 517 518 if (cam_id >= TOTAL_CAM_ENTRY) 519 goto exit; 520 521 if (!(cam_ctl->bitmap & BIT(cam_id))) 522 goto exit; 523 524 ret = (dvobj->cam_cache[cam_id].ctrl & BIT6) ? true : false; 525 526 exit: 527 return ret; 528 } 529 530 static s16 _rtw_camid_search(struct adapter *adapter, u8 *addr, s16 kid) 531 { 532 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter); 533 int i; 534 s16 cam_id = -1; 535 536 for (i = 0; i < TOTAL_CAM_ENTRY; i++) { 537 if (addr && memcmp(dvobj->cam_cache[i].mac, addr, ETH_ALEN)) 538 continue; 539 if (kid >= 0 && kid != (dvobj->cam_cache[i].ctrl & 0x03)) 540 continue; 541 542 cam_id = i; 543 break; 544 } 545 546 return cam_id; 547 } 548 549 s16 rtw_camid_search(struct adapter *adapter, u8 *addr, s16 kid) 550 { 551 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter); 552 struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl; 553 s16 cam_id = -1; 554 555 spin_lock_bh(&cam_ctl->lock); 556 cam_id = _rtw_camid_search(adapter, addr, kid); 557 spin_unlock_bh(&cam_ctl->lock); 558 559 return cam_id; 560 } 561 562 s16 rtw_camid_alloc(struct adapter *adapter, struct sta_info *sta, u8 kid) 563 { 564 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter); 565 struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl; 566 s16 cam_id = -1; 567 struct mlme_ext_info *mlmeinfo; 568 569 spin_lock_bh(&cam_ctl->lock); 570 571 mlmeinfo = &adapter->mlmeextpriv.mlmext_info; 572 573 if ((((mlmeinfo->state & 0x03) == WIFI_FW_AP_STATE) || ((mlmeinfo->state & 0x03) == WIFI_FW_ADHOC_STATE)) 574 && !sta) { 575 /* AP/Ad-hoc mode group key: static allocation to default key by key ID */ 576 if (kid > 3) { 577 netdev_dbg(adapter->pnetdev, 578 FUNC_ADPT_FMT " group key with invalid key id:%u\n", 579 FUNC_ADPT_ARG(adapter), kid); 580 rtw_warn_on(1); 581 goto bitmap_handle; 582 } 583 584 cam_id = kid; 585 } else { 586 int i; 587 u8 *addr = sta ? sta->hwaddr : NULL; 588 589 if (!sta) { 590 if (!(mlmeinfo->state & WIFI_FW_ASSOC_SUCCESS)) { 591 /* bypass STA mode group key setting before connected(ex:WEP) because bssid is not ready */ 592 goto bitmap_handle; 593 } 594 595 addr = get_bssid(&adapter->mlmepriv); 596 } 597 598 i = _rtw_camid_search(adapter, addr, kid); 599 if (i >= 0) { 600 /* Fix issue that pairwise and group key have same key id. 601 * Pairwise key first, group key can overwrite group only(ex: rekey) 602 */ 603 if (sta || _rtw_camid_is_gk(adapter, i)) 604 cam_id = i; 605 else 606 netdev_dbg(adapter->pnetdev, 607 FUNC_ADPT_FMT " group key id:%u the same key id as pairwise key\n", 608 FUNC_ADPT_ARG(adapter), kid); 609 goto bitmap_handle; 610 } 611 612 for (i = 4; i < TOTAL_CAM_ENTRY; i++) 613 if (!(cam_ctl->bitmap & BIT(i))) 614 break; 615 616 if (i == TOTAL_CAM_ENTRY) { 617 if (sta) 618 netdev_dbg(adapter->pnetdev, 619 FUNC_ADPT_FMT " pairwise key with %pM id:%u no room\n", 620 FUNC_ADPT_ARG(adapter), 621 sta->hwaddr, kid); 622 else 623 netdev_dbg(adapter->pnetdev, 624 FUNC_ADPT_FMT " group key id:%u no room\n", 625 FUNC_ADPT_ARG(adapter), kid); 626 rtw_warn_on(1); 627 goto bitmap_handle; 628 } 629 630 cam_id = i; 631 } 632 633 bitmap_handle: 634 if (cam_id >= 0 && cam_id < 32) 635 cam_ctl->bitmap |= BIT(cam_id); 636 637 spin_unlock_bh(&cam_ctl->lock); 638 639 return cam_id; 640 } 641 642 void rtw_camid_free(struct adapter *adapter, u8 cam_id) 643 { 644 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter); 645 struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl; 646 647 spin_lock_bh(&cam_ctl->lock); 648 649 if (cam_id < TOTAL_CAM_ENTRY) 650 cam_ctl->bitmap &= ~(BIT(cam_id)); 651 652 spin_unlock_bh(&cam_ctl->lock); 653 } 654 655 int allocate_fw_sta_entry(struct adapter *padapter) 656 { 657 unsigned int mac_id; 658 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 659 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 660 661 for (mac_id = IBSS_START_MAC_ID; mac_id < NUM_STA; mac_id++) { 662 if (pmlmeinfo->FW_sta_info[mac_id].status == 0) { 663 pmlmeinfo->FW_sta_info[mac_id].status = 1; 664 pmlmeinfo->FW_sta_info[mac_id].retry = 0; 665 break; 666 } 667 } 668 669 return mac_id; 670 } 671 672 void flush_all_cam_entry(struct adapter *padapter) 673 { 674 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 675 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 676 677 invalidate_cam_all(padapter); 678 /* clear default key related key search setting */ 679 rtw_hal_set_hwreg(padapter, HW_VAR_SEC_DK_CFG, (u8 *)false); 680 681 memset((u8 *)(pmlmeinfo->FW_sta_info), 0, sizeof(pmlmeinfo->FW_sta_info)); 682 } 683 684 int WMM_param_handler(struct adapter *padapter, struct ndis_80211_var_ie *pIE) 685 { 686 /* struct registry_priv *pregpriv = &padapter->registrypriv; */ 687 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 688 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 689 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 690 691 if (pmlmepriv->qospriv.qos_option == 0) { 692 pmlmeinfo->WMM_enable = 0; 693 return false; 694 } 695 696 if (!memcmp(&(pmlmeinfo->WMM_param), (pIE->data + 6), sizeof(struct WMM_para_element))) 697 return false; 698 699 memcpy(&(pmlmeinfo->WMM_param), (pIE->data + 6), sizeof(struct WMM_para_element)); 700 701 pmlmeinfo->WMM_enable = 1; 702 return true; 703 } 704 705 static void sort_wmm_ac_params(u32 *inx, u32 *edca) 706 { 707 u32 i, j, change_inx = false; 708 709 /* entry index: 0->vo, 1->vi, 2->be, 3->bk. */ 710 for (i = 0; i < 4; i++) { 711 for (j = i + 1; j < 4; j++) { 712 /* compare CW and AIFS */ 713 if ((edca[j] & 0xFFFF) < (edca[i] & 0xFFFF)) { 714 change_inx = true; 715 } else if ((edca[j] & 0xFFFF) == (edca[i] & 0xFFFF)) { 716 /* compare TXOP */ 717 if ((edca[j] >> 16) > (edca[i] >> 16)) 718 change_inx = true; 719 } 720 721 if (change_inx) { 722 swap(edca[i], edca[j]); 723 swap(inx[i], inx[j]); 724 725 change_inx = false; 726 } 727 } 728 } 729 } 730 731 void WMMOnAssocRsp(struct adapter *padapter) 732 { 733 u8 ACI, ACM, AIFS, ECWMin, ECWMax, aSifsTime; 734 u8 acm_mask; 735 u16 TXOP; 736 u32 acParm, i; 737 u32 edca[4], inx[4]; 738 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 739 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 740 struct xmit_priv *pxmitpriv = &padapter->xmitpriv; 741 struct registry_priv *pregpriv = &padapter->registrypriv; 742 743 acm_mask = 0; 744 745 if (pmlmeext->cur_wireless_mode & WIRELESS_11_24N) 746 aSifsTime = 16; 747 else 748 aSifsTime = 10; 749 750 if (pmlmeinfo->WMM_enable == 0) { 751 padapter->mlmepriv.acm_mask = 0; 752 753 AIFS = aSifsTime + (2 * pmlmeinfo->slotTime); 754 755 if (pmlmeext->cur_wireless_mode & WIRELESS_11G) { 756 ECWMin = 4; 757 ECWMax = 10; 758 } else if (pmlmeext->cur_wireless_mode & WIRELESS_11B) { 759 ECWMin = 5; 760 ECWMax = 10; 761 } else { 762 ECWMin = 4; 763 ECWMax = 10; 764 } 765 766 TXOP = 0; 767 acParm = AIFS | (ECWMin << 8) | (ECWMax << 12) | (TXOP << 16); 768 rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_BE, (u8 *)(&acParm)); 769 rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_BK, (u8 *)(&acParm)); 770 rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_VI, (u8 *)(&acParm)); 771 772 ECWMin = 2; 773 ECWMax = 3; 774 TXOP = 0x2f; 775 acParm = AIFS | (ECWMin << 8) | (ECWMax << 12) | (TXOP << 16); 776 rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_VO, (u8 *)(&acParm)); 777 } else { 778 edca[0] = edca[1] = edca[2] = edca[3] = 0; 779 780 for (i = 0; i < 4; i++) { 781 ACI = (pmlmeinfo->WMM_param.ac_param[i].ACI_AIFSN >> 5) & 0x03; 782 ACM = (pmlmeinfo->WMM_param.ac_param[i].ACI_AIFSN >> 4) & 0x01; 783 784 /* AIFS = AIFSN * slot time + SIFS - r2t phy delay */ 785 AIFS = (pmlmeinfo->WMM_param.ac_param[i].ACI_AIFSN & 0x0f) * pmlmeinfo->slotTime + aSifsTime; 786 787 ECWMin = (pmlmeinfo->WMM_param.ac_param[i].CW & 0x0f); 788 ECWMax = (pmlmeinfo->WMM_param.ac_param[i].CW & 0xf0) >> 4; 789 TXOP = le16_to_cpu(pmlmeinfo->WMM_param.ac_param[i].TXOP_limit); 790 791 acParm = AIFS | (ECWMin << 8) | (ECWMax << 12) | (TXOP << 16); 792 793 switch (ACI) { 794 case 0x0: 795 rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_BE, (u8 *)(&acParm)); 796 acm_mask |= (ACM ? BIT(1) : 0); 797 edca[XMIT_BE_QUEUE] = acParm; 798 break; 799 800 case 0x1: 801 rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_BK, (u8 *)(&acParm)); 802 /* acm_mask |= (ACM? BIT(0):0); */ 803 edca[XMIT_BK_QUEUE] = acParm; 804 break; 805 806 case 0x2: 807 rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_VI, (u8 *)(&acParm)); 808 acm_mask |= (ACM ? BIT(2) : 0); 809 edca[XMIT_VI_QUEUE] = acParm; 810 break; 811 812 case 0x3: 813 rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_VO, (u8 *)(&acParm)); 814 acm_mask |= (ACM ? BIT(3) : 0); 815 edca[XMIT_VO_QUEUE] = acParm; 816 break; 817 } 818 } 819 820 if (padapter->registrypriv.acm_method == 1) 821 rtw_hal_set_hwreg(padapter, HW_VAR_ACM_CTRL, (u8 *)(&acm_mask)); 822 else 823 padapter->mlmepriv.acm_mask = acm_mask; 824 825 inx[0] = 0; inx[1] = 1; inx[2] = 2; inx[3] = 3; 826 827 if (pregpriv->wifi_spec == 1) 828 sort_wmm_ac_params(inx, edca); 829 830 for (i = 0; i < 4; i++) 831 pxmitpriv->wmm_para_seq[i] = inx[i]; 832 } 833 } 834 835 static void bwmode_update_check(struct adapter *padapter, struct ndis_80211_var_ie *pIE) 836 { 837 unsigned char new_bwmode; 838 unsigned char new_ch_offset; 839 struct HT_info_element *pHT_info; 840 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 841 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 842 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 843 struct registry_priv *pregistrypriv = &padapter->registrypriv; 844 struct ht_priv *phtpriv = &pmlmepriv->htpriv; 845 u8 cbw40_enable = 0; 846 847 if (!pIE) 848 return; 849 850 if (phtpriv->ht_option == false) 851 return; 852 853 if (pIE->length > sizeof(struct HT_info_element)) 854 return; 855 856 pHT_info = (struct HT_info_element *)pIE->data; 857 858 if ((pregistrypriv->bw_mode & 0x0f) > 0) 859 cbw40_enable = 1; 860 861 if ((pHT_info->infos[0] & BIT(2)) && cbw40_enable) { 862 new_bwmode = CHANNEL_WIDTH_40; 863 864 switch (pHT_info->infos[0] & 0x3) { 865 case 1: 866 new_ch_offset = HAL_PRIME_CHNL_OFFSET_LOWER; 867 break; 868 869 case 3: 870 new_ch_offset = HAL_PRIME_CHNL_OFFSET_UPPER; 871 break; 872 873 default: 874 new_bwmode = CHANNEL_WIDTH_20; 875 new_ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE; 876 break; 877 } 878 } else { 879 new_bwmode = CHANNEL_WIDTH_20; 880 new_ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE; 881 } 882 883 if ((new_bwmode != pmlmeext->cur_bwmode) || (new_ch_offset != pmlmeext->cur_ch_offset)) { 884 pmlmeinfo->bwmode_updated = true; 885 886 pmlmeext->cur_bwmode = new_bwmode; 887 pmlmeext->cur_ch_offset = new_ch_offset; 888 889 /* update HT info also */ 890 HT_info_handler(padapter, pIE); 891 } else { 892 pmlmeinfo->bwmode_updated = false; 893 } 894 895 if (true == pmlmeinfo->bwmode_updated) { 896 struct sta_info *psta; 897 struct wlan_bssid_ex *cur_network = &(pmlmeinfo->network); 898 struct sta_priv *pstapriv = &padapter->stapriv; 899 900 /* set_channel_bwmode(padapter, pmlmeext->cur_channel, pmlmeext->cur_ch_offset, pmlmeext->cur_bwmode); */ 901 902 /* update ap's stainfo */ 903 psta = rtw_get_stainfo(pstapriv, cur_network->mac_address); 904 if (psta) { 905 struct ht_priv *phtpriv_sta = &psta->htpriv; 906 907 if (phtpriv_sta->ht_option) { 908 /* bwmode */ 909 psta->bw_mode = pmlmeext->cur_bwmode; 910 phtpriv_sta->ch_offset = pmlmeext->cur_ch_offset; 911 } else { 912 psta->bw_mode = CHANNEL_WIDTH_20; 913 phtpriv_sta->ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE; 914 } 915 916 rtw_dm_ra_mask_wk_cmd(padapter, (u8 *)psta); 917 } 918 } 919 } 920 921 void HT_caps_handler(struct adapter *padapter, struct ndis_80211_var_ie *pIE) 922 { 923 unsigned int i; 924 u8 max_AMPDU_len, min_MPDU_spacing; 925 u8 cur_ldpc_cap = 0, cur_stbc_cap = 0; 926 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 927 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 928 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 929 struct ht_priv *phtpriv = &pmlmepriv->htpriv; 930 931 if (!pIE) 932 return; 933 934 if (phtpriv->ht_option == false) 935 return; 936 937 pmlmeinfo->HT_caps_enable = 1; 938 939 for (i = 0; i < (pIE->length); i++) { 940 if (i != 2) { 941 /* Commented by Albert 2010/07/12 */ 942 /* Got the endian issue here. */ 943 pmlmeinfo->HT_caps.u.HT_cap[i] &= (pIE->data[i]); 944 } else { 945 /* modify from fw by Thomas 2010/11/17 */ 946 max_AMPDU_len = min(pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x3, 947 pIE->data[i] & 0x3); 948 949 min_MPDU_spacing = max(pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x1c, 950 pIE->data[i] & 0x1c); 951 952 pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para = max_AMPDU_len | min_MPDU_spacing; 953 } 954 } 955 956 /* update the MCS set */ 957 for (i = 0; i < 16; i++) 958 pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate[i] &= pmlmeext->default_supported_mcs_set[i]; 959 960 /* update the MCS rates */ 961 set_mcs_rate_by_mask(pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate, MCS_RATE_1R); 962 963 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) { 964 /* Config STBC setting */ 965 if (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_TX) && 966 GET_HT_CAPABILITY_ELE_TX_STBC(pIE->data)) 967 SET_FLAG(cur_stbc_cap, STBC_HT_ENABLE_TX); 968 969 phtpriv->stbc_cap = cur_stbc_cap; 970 } else { 971 /* Config LDPC Coding Capability */ 972 if (TEST_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_TX) && 973 GET_HT_CAPABILITY_ELE_LDPC_CAP(pIE->data)) 974 SET_FLAG(cur_ldpc_cap, (LDPC_HT_ENABLE_TX | LDPC_HT_CAP_TX)); 975 976 phtpriv->ldpc_cap = cur_ldpc_cap; 977 978 /* Config STBC setting */ 979 if (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_TX) && 980 GET_HT_CAPABILITY_ELE_RX_STBC(pIE->data)) 981 SET_FLAG(cur_stbc_cap, (STBC_HT_ENABLE_TX | STBC_HT_CAP_TX)); 982 983 phtpriv->stbc_cap = cur_stbc_cap; 984 } 985 } 986 987 void HT_info_handler(struct adapter *padapter, struct ndis_80211_var_ie *pIE) 988 { 989 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 990 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 991 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 992 struct ht_priv *phtpriv = &pmlmepriv->htpriv; 993 994 if (!pIE) 995 return; 996 997 if (phtpriv->ht_option == false) 998 return; 999 1000 if (pIE->length > sizeof(struct HT_info_element)) 1001 return; 1002 1003 pmlmeinfo->HT_info_enable = 1; 1004 memcpy(&(pmlmeinfo->HT_info), pIE->data, pIE->length); 1005 } 1006 1007 void HTOnAssocRsp(struct adapter *padapter) 1008 { 1009 unsigned char max_AMPDU_len; 1010 unsigned char min_MPDU_spacing; 1011 /* struct registry_priv *pregpriv = &padapter->registrypriv; */ 1012 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 1013 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 1014 1015 if ((pmlmeinfo->HT_info_enable) && (pmlmeinfo->HT_caps_enable)) { 1016 pmlmeinfo->HT_enable = 1; 1017 } else { 1018 pmlmeinfo->HT_enable = 0; 1019 /* set_channel_bwmode(padapter, pmlmeext->cur_channel, pmlmeext->cur_ch_offset, pmlmeext->cur_bwmode); */ 1020 return; 1021 } 1022 1023 /* handle A-MPDU parameter field */ 1024 /* 1025 * AMPDU_para [1:0]:Max AMPDU Len => 0:8k , 1:16k, 2:32k, 3:64k 1026 * AMPDU_para [4:2]:Min MPDU Start Spacing 1027 */ 1028 max_AMPDU_len = pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x03; 1029 1030 min_MPDU_spacing = (pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x1c) >> 2; 1031 1032 rtw_hal_set_hwreg(padapter, HW_VAR_AMPDU_MIN_SPACE, (u8 *)(&min_MPDU_spacing)); 1033 1034 rtw_hal_set_hwreg(padapter, HW_VAR_AMPDU_FACTOR, (u8 *)(&max_AMPDU_len)); 1035 } 1036 1037 void ERP_IE_handler(struct adapter *padapter, struct ndis_80211_var_ie *pIE) 1038 { 1039 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 1040 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 1041 1042 if (pIE->length > 1) 1043 return; 1044 1045 pmlmeinfo->ERP_enable = 1; 1046 memcpy(&(pmlmeinfo->ERP_IE), pIE->data, pIE->length); 1047 } 1048 1049 void VCS_update(struct adapter *padapter, struct sta_info *psta) 1050 { 1051 struct registry_priv *pregpriv = &padapter->registrypriv; 1052 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 1053 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 1054 1055 switch (pregpriv->vrtl_carrier_sense) {/* 0:off 1:on 2:auto */ 1056 case 0: /* off */ 1057 psta->rtsen = 0; 1058 psta->cts2self = 0; 1059 break; 1060 1061 case 1: /* on */ 1062 if (pregpriv->vcs_type == 1) { /* 1:RTS/CTS 2:CTS to self */ 1063 psta->rtsen = 1; 1064 psta->cts2self = 0; 1065 } else { 1066 psta->rtsen = 0; 1067 psta->cts2self = 1; 1068 } 1069 break; 1070 1071 case 2: /* auto */ 1072 default: 1073 if ((pmlmeinfo->ERP_enable) && (pmlmeinfo->ERP_IE & BIT(1))) { 1074 if (pregpriv->vcs_type == 1) { 1075 psta->rtsen = 1; 1076 psta->cts2self = 0; 1077 } else { 1078 psta->rtsen = 0; 1079 psta->cts2self = 1; 1080 } 1081 } else { 1082 psta->rtsen = 0; 1083 psta->cts2self = 0; 1084 } 1085 break; 1086 } 1087 } 1088 1089 void update_ldpc_stbc_cap(struct sta_info *psta) 1090 { 1091 if (psta->htpriv.ht_option) { 1092 if (TEST_FLAG(psta->htpriv.ldpc_cap, LDPC_HT_ENABLE_TX)) 1093 psta->ldpc = 1; 1094 1095 if (TEST_FLAG(psta->htpriv.stbc_cap, STBC_HT_ENABLE_TX)) 1096 psta->stbc = 1; 1097 } else { 1098 psta->ldpc = 0; 1099 psta->stbc = 0; 1100 } 1101 } 1102 1103 int rtw_check_bcn_info(struct adapter *Adapter, u8 *pframe, u32 packet_len) 1104 { 1105 unsigned int len; 1106 unsigned char *p; 1107 unsigned short val16, subtype; 1108 struct wlan_network *cur_network = &(Adapter->mlmepriv.cur_network); 1109 /* u8 wpa_ie[255], rsn_ie[255]; */ 1110 u16 wpa_len = 0, rsn_len = 0; 1111 u8 encryp_protocol = 0; 1112 struct wlan_bssid_ex *bssid; 1113 int group_cipher = 0, pairwise_cipher = 0, is_8021x = 0; 1114 unsigned char *pbuf; 1115 u32 wpa_ielen = 0; 1116 u8 *pbssid = GetAddr3Ptr(pframe); 1117 struct HT_info_element *pht_info = NULL; 1118 struct ieee80211_ht_cap *pht_cap = NULL; 1119 u32 bcn_channel; 1120 unsigned short ht_cap_info; 1121 unsigned char ht_info_infos_0; 1122 struct mlme_priv *pmlmepriv = &Adapter->mlmepriv; 1123 int ssid_len; 1124 1125 if (is_client_associated_to_ap(Adapter) == false) 1126 return true; 1127 1128 len = packet_len - sizeof(struct ieee80211_hdr_3addr); 1129 1130 if (len > MAX_IE_SZ) 1131 return _FAIL; 1132 1133 if (memcmp(cur_network->network.mac_address, pbssid, 6)) 1134 return true; 1135 1136 bssid = kzalloc_obj(*bssid); 1137 if (!bssid) 1138 return true; 1139 1140 if ((pmlmepriv->timeBcnInfoChkStart != 0) && (jiffies_to_msecs(jiffies - pmlmepriv->timeBcnInfoChkStart) > DISCONNECT_BY_CHK_BCN_FAIL_OBSERV_PERIOD_IN_MS)) { 1141 pmlmepriv->timeBcnInfoChkStart = 0; 1142 pmlmepriv->NumOfBcnInfoChkFail = 0; 1143 } 1144 1145 subtype = GetFrameSubType(pframe) >> 4; 1146 1147 if (subtype == WIFI_BEACON) 1148 bssid->reserved[0] = 1; 1149 1150 bssid->length = sizeof(struct wlan_bssid_ex) - MAX_IE_SZ + len; 1151 1152 /* below is to copy the information element */ 1153 bssid->ie_length = len; 1154 memcpy(bssid->ies, (pframe + sizeof(struct ieee80211_hdr_3addr)), bssid->ie_length); 1155 1156 /* check bw and channel offset */ 1157 /* parsing HT_CAP_IE */ 1158 p = rtw_get_ie(bssid->ies + _FIXED_IE_LENGTH_, WLAN_EID_HT_CAPABILITY, &len, bssid->ie_length - _FIXED_IE_LENGTH_); 1159 if (p && len > 0) { 1160 pht_cap = (struct ieee80211_ht_cap *)(p + 2); 1161 ht_cap_info = le16_to_cpu(pht_cap->cap_info); 1162 } else { 1163 ht_cap_info = 0; 1164 } 1165 /* parsing HT_INFO_IE */ 1166 p = rtw_get_ie(bssid->ies + _FIXED_IE_LENGTH_, WLAN_EID_HT_OPERATION, &len, bssid->ie_length - _FIXED_IE_LENGTH_); 1167 if (p && len > 0) { 1168 pht_info = (struct HT_info_element *)(p + 2); 1169 ht_info_infos_0 = pht_info->infos[0]; 1170 } else { 1171 ht_info_infos_0 = 0; 1172 } 1173 if (ht_cap_info != cur_network->bcn_info.ht_cap_info || 1174 ((ht_info_infos_0 & 0x03) != (cur_network->bcn_info.ht_info_infos_0 & 0x03))) { 1175 { 1176 /* bcn_info_update */ 1177 cur_network->bcn_info.ht_cap_info = ht_cap_info; 1178 cur_network->bcn_info.ht_info_infos_0 = ht_info_infos_0; 1179 /* to do : need to check that whether modify related register of BB or not */ 1180 } 1181 /* goto _mismatch; */ 1182 } 1183 1184 /* Checking for channel */ 1185 p = rtw_get_ie(bssid->ies + _FIXED_IE_LENGTH_, WLAN_EID_DS_PARAMS, &len, bssid->ie_length - _FIXED_IE_LENGTH_); 1186 if (p) { 1187 bcn_channel = *(p + 2); 1188 } else {/* In 5G, some ap do not have DSSET IE checking HT info for channel */ 1189 rtw_get_ie(bssid->ies + _FIXED_IE_LENGTH_, WLAN_EID_HT_OPERATION, 1190 &len, bssid->ie_length - _FIXED_IE_LENGTH_); 1191 if (pht_info) 1192 bcn_channel = pht_info->primary_channel; 1193 else /* we don't find channel IE, so don't check it */ 1194 bcn_channel = Adapter->mlmeextpriv.cur_channel; 1195 } 1196 1197 if (bcn_channel != Adapter->mlmeextpriv.cur_channel) 1198 goto _mismatch; 1199 1200 /* checking SSID */ 1201 ssid_len = 0; 1202 p = rtw_get_ie(bssid->ies + _FIXED_IE_LENGTH_, WLAN_EID_SSID, &len, bssid->ie_length - _FIXED_IE_LENGTH_); 1203 if (p) { 1204 ssid_len = *(p + 1); 1205 if (ssid_len > NDIS_802_11_LENGTH_SSID) 1206 ssid_len = 0; 1207 } 1208 memcpy(bssid->ssid.ssid, (p + 2), ssid_len); 1209 bssid->ssid.ssid_length = ssid_len; 1210 1211 if (memcmp(bssid->ssid.ssid, cur_network->network.ssid.ssid, 32) || 1212 bssid->ssid.ssid_length != cur_network->network.ssid.ssid_length) 1213 if (bssid->ssid.ssid[0] != '\0' && 1214 bssid->ssid.ssid_length != 0) /* not hidden ssid */ 1215 goto _mismatch; 1216 1217 /* check encryption info */ 1218 val16 = rtw_get_capability((struct wlan_bssid_ex *)bssid); 1219 1220 if (val16 & BIT(4)) 1221 bssid->privacy = 1; 1222 else 1223 bssid->privacy = 0; 1224 1225 if (cur_network->network.privacy != bssid->privacy) 1226 goto _mismatch; 1227 1228 rtw_get_sec_ie(bssid->ies, bssid->ie_length, NULL, &rsn_len, NULL, &wpa_len); 1229 1230 if (rsn_len > 0) 1231 encryp_protocol = ENCRYP_PROTOCOL_WPA2; 1232 else if (wpa_len > 0) 1233 encryp_protocol = ENCRYP_PROTOCOL_WPA; 1234 else 1235 if (bssid->privacy) 1236 encryp_protocol = ENCRYP_PROTOCOL_WEP; 1237 1238 if (cur_network->bcn_info.encryp_protocol != encryp_protocol) 1239 goto _mismatch; 1240 1241 if (encryp_protocol == ENCRYP_PROTOCOL_WPA || encryp_protocol == ENCRYP_PROTOCOL_WPA2) { 1242 pbuf = rtw_get_wpa_ie(&bssid->ies[12], &wpa_ielen, bssid->ie_length - 12); 1243 if (pbuf && (wpa_ielen > 0)) { 1244 rtw_parse_wpa_ie(pbuf, wpa_ielen + 2, &group_cipher, 1245 &pairwise_cipher, &is_8021x); 1246 } else { 1247 pbuf = rtw_get_wpa2_ie(&bssid->ies[12], &wpa_ielen, bssid->ie_length - 12); 1248 1249 if (pbuf && (wpa_ielen > 0)) 1250 rtw_parse_wpa2_ie(pbuf, wpa_ielen + 2, &group_cipher, 1251 &pairwise_cipher, &is_8021x); 1252 } 1253 1254 if (pairwise_cipher != cur_network->bcn_info.pairwise_cipher || 1255 group_cipher != cur_network->bcn_info.group_cipher) 1256 goto _mismatch; 1257 1258 if (is_8021x != cur_network->bcn_info.is_8021x) 1259 goto _mismatch; 1260 } 1261 1262 kfree(bssid); 1263 return _SUCCESS; 1264 1265 _mismatch: 1266 kfree(bssid); 1267 1268 if (pmlmepriv->NumOfBcnInfoChkFail == 0) 1269 pmlmepriv->timeBcnInfoChkStart = jiffies; 1270 1271 pmlmepriv->NumOfBcnInfoChkFail++; 1272 1273 if ((pmlmepriv->timeBcnInfoChkStart != 0) && (jiffies_to_msecs(jiffies - pmlmepriv->timeBcnInfoChkStart) <= DISCONNECT_BY_CHK_BCN_FAIL_OBSERV_PERIOD_IN_MS) 1274 && (pmlmepriv->NumOfBcnInfoChkFail >= DISCONNECT_BY_CHK_BCN_FAIL_THRESHOLD)) { 1275 pmlmepriv->timeBcnInfoChkStart = 0; 1276 pmlmepriv->NumOfBcnInfoChkFail = 0; 1277 return _FAIL; 1278 } 1279 1280 return _SUCCESS; 1281 } 1282 1283 void update_beacon_info(struct adapter *padapter, u8 *pframe, uint pkt_len, struct sta_info *psta) 1284 { 1285 unsigned int i; 1286 unsigned int len; 1287 struct ndis_80211_var_ie *pIE; 1288 1289 len = pkt_len - (_BEACON_IE_OFFSET_ + WLAN_HDR_A3_LEN); 1290 1291 for (i = 0; i < len;) { 1292 pIE = (struct ndis_80211_var_ie *)(pframe + (_BEACON_IE_OFFSET_ + WLAN_HDR_A3_LEN) + i); 1293 1294 switch (pIE->element_id) { 1295 case WLAN_EID_VENDOR_SPECIFIC: 1296 /* to update WMM parameter set while receiving beacon */ 1297 if (!memcmp(pIE->data, WMM_PARA_OUI, 6) && pIE->length == WLAN_WMM_LEN) /* WMM */ 1298 if (WMM_param_handler(padapter, pIE)) 1299 report_wmm_edca_update(padapter); 1300 1301 break; 1302 1303 case WLAN_EID_HT_OPERATION: /* HT info */ 1304 /* HT_info_handler(padapter, pIE); */ 1305 bwmode_update_check(padapter, pIE); 1306 break; 1307 1308 case WLAN_EID_ERP_INFO: 1309 ERP_IE_handler(padapter, pIE); 1310 VCS_update(padapter, psta); 1311 break; 1312 1313 default: 1314 break; 1315 } 1316 1317 i += (pIE->length + 2); 1318 } 1319 } 1320 1321 unsigned int is_ap_in_tkip(struct adapter *padapter) 1322 { 1323 u32 i; 1324 struct ndis_80211_var_ie *pIE; 1325 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 1326 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 1327 struct wlan_bssid_ex *cur_network = &(pmlmeinfo->network); 1328 1329 if (rtw_get_capability((struct wlan_bssid_ex *)cur_network) & WLAN_CAPABILITY_PRIVACY) { 1330 for (i = sizeof(struct ndis_802_11_fix_ie); i < pmlmeinfo->network.ie_length;) { 1331 pIE = (struct ndis_80211_var_ie *)(pmlmeinfo->network.ies + i); 1332 1333 switch (pIE->element_id) { 1334 case WLAN_EID_VENDOR_SPECIFIC: 1335 if ((!memcmp(pIE->data, RTW_WPA_OUI, 4)) && (!memcmp((pIE->data + 12), WPA_TKIP_CIPHER, 4))) 1336 return true; 1337 1338 break; 1339 1340 case WLAN_EID_RSN: 1341 if (!memcmp((pIE->data + 8), RSN_TKIP_CIPHER, 4)) 1342 return true; 1343 break; 1344 1345 default: 1346 break; 1347 } 1348 1349 i += (pIE->length + 2); 1350 } 1351 1352 return false; 1353 } else { 1354 return false; 1355 } 1356 } 1357 1358 int support_short_GI(struct adapter *padapter, struct HT_caps_element *pHT_caps, u8 bwmode) 1359 { 1360 unsigned char bit_offset; 1361 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 1362 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 1363 1364 if (!(pmlmeinfo->HT_enable)) 1365 return _FAIL; 1366 1367 bit_offset = (bwmode & CHANNEL_WIDTH_40) ? 6 : 5; 1368 1369 if (le16_to_cpu(pHT_caps->u.HT_cap_element.HT_caps_info) & (0x1 << bit_offset)) 1370 return _SUCCESS; 1371 else 1372 return _FAIL; 1373 } 1374 1375 unsigned char get_highest_rate_idx(u32 mask) 1376 { 1377 int i; 1378 unsigned char rate_idx = 0; 1379 1380 for (i = 31; i >= 0; i--) { 1381 if (mask & BIT(i)) { 1382 rate_idx = i; 1383 break; 1384 } 1385 } 1386 1387 return rate_idx; 1388 } 1389 1390 void Update_RA_Entry(struct adapter *padapter, struct sta_info *psta) 1391 { 1392 rtw_hal_update_ra_mask(psta, 0); 1393 } 1394 1395 void set_sta_rate(struct adapter *padapter, struct sta_info *psta) 1396 { 1397 /* rate adaptive */ 1398 Update_RA_Entry(padapter, psta); 1399 } 1400 1401 static u32 get_realtek_assoc_AP_vender(struct ndis_80211_var_ie *pIE) 1402 { 1403 u32 Vender = HT_IOT_PEER_REALTEK; 1404 1405 if (pIE->length >= 5) { 1406 if (pIE->data[4] == 1) 1407 /* if (pIE->data[5] & RT_HT_CAP_USE_LONG_PREAMBLE) */ 1408 /* bssDesc->BssHT.RT2RT_HT_Mode |= RT_HT_CAP_USE_LONG_PREAMBLE; */ 1409 if (pIE->data[5] & RT_HT_CAP_USE_92SE) 1410 /* bssDesc->BssHT.RT2RT_HT_Mode |= RT_HT_CAP_USE_92SE; */ 1411 Vender = HT_IOT_PEER_REALTEK_92SE; 1412 1413 if (pIE->data[5] & RT_HT_CAP_USE_SOFTAP) 1414 Vender = HT_IOT_PEER_REALTEK_SOFTAP; 1415 1416 if (pIE->data[4] == 2) { 1417 if (pIE->data[6] & RT_HT_CAP_USE_JAGUAR_BCUT) 1418 Vender = HT_IOT_PEER_REALTEK_JAGUAR_BCUTAP; 1419 1420 if (pIE->data[6] & RT_HT_CAP_USE_JAGUAR_CCUT) 1421 Vender = HT_IOT_PEER_REALTEK_JAGUAR_CCUTAP; 1422 } 1423 } 1424 1425 return Vender; 1426 } 1427 1428 unsigned char check_assoc_AP(u8 *pframe, uint len) 1429 { 1430 unsigned int i; 1431 struct ndis_80211_var_ie *pIE; 1432 1433 for (i = sizeof(struct ndis_802_11_fix_ie); i < len;) { 1434 pIE = (struct ndis_80211_var_ie *)(pframe + i); 1435 1436 switch (pIE->element_id) { 1437 case WLAN_EID_VENDOR_SPECIFIC: 1438 if ((!memcmp(pIE->data, ARTHEROS_OUI1, 3)) || (!memcmp(pIE->data, ARTHEROS_OUI2, 3))) 1439 return HT_IOT_PEER_ATHEROS; 1440 else if ((!memcmp(pIE->data, BROADCOM_OUI1, 3)) || 1441 (!memcmp(pIE->data, BROADCOM_OUI2, 3)) || 1442 (!memcmp(pIE->data, BROADCOM_OUI3, 3))) 1443 return HT_IOT_PEER_BROADCOM; 1444 else if (!memcmp(pIE->data, MARVELL_OUI, 3)) 1445 return HT_IOT_PEER_MARVELL; 1446 else if (!memcmp(pIE->data, RALINK_OUI, 3)) 1447 return HT_IOT_PEER_RALINK; 1448 else if (!memcmp(pIE->data, CISCO_OUI, 3)) 1449 return HT_IOT_PEER_CISCO; 1450 else if (!memcmp(pIE->data, REALTEK_OUI, 3)) 1451 return get_realtek_assoc_AP_vender(pIE); 1452 else if (!memcmp(pIE->data, AIRGOCAP_OUI, 3)) 1453 return HT_IOT_PEER_AIRGO; 1454 break; 1455 default: 1456 break; 1457 } 1458 1459 i += (pIE->length + 2); 1460 } 1461 1462 return HT_IOT_PEER_UNKNOWN; 1463 } 1464 1465 void update_IOT_info(struct adapter *padapter) 1466 { 1467 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 1468 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 1469 1470 switch (pmlmeinfo->assoc_AP_vendor) { 1471 case HT_IOT_PEER_MARVELL: 1472 pmlmeinfo->turboMode_cts2self = 1; 1473 pmlmeinfo->turboMode_rtsen = 0; 1474 break; 1475 1476 case HT_IOT_PEER_RALINK: 1477 pmlmeinfo->turboMode_cts2self = 0; 1478 pmlmeinfo->turboMode_rtsen = 1; 1479 /* disable high power */ 1480 Switch_DM_Func(padapter, (~DYNAMIC_BB_DYNAMIC_TXPWR), false); 1481 break; 1482 case HT_IOT_PEER_REALTEK: 1483 /* rtw_write16(padapter, 0x4cc, 0xffff); */ 1484 /* rtw_write16(padapter, 0x546, 0x01c0); */ 1485 /* disable high power */ 1486 Switch_DM_Func(padapter, (~DYNAMIC_BB_DYNAMIC_TXPWR), false); 1487 break; 1488 default: 1489 pmlmeinfo->turboMode_cts2self = 0; 1490 pmlmeinfo->turboMode_rtsen = 1; 1491 break; 1492 } 1493 } 1494 1495 void update_capinfo(struct adapter *Adapter, u16 updateCap) 1496 { 1497 struct mlme_ext_priv *pmlmeext = &Adapter->mlmeextpriv; 1498 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 1499 bool ShortPreamble; 1500 1501 /* Check preamble mode, 2005.01.06, by rcnjko. */ 1502 /* Mark to update preamble value forever, 2008.03.18 by lanhsin */ 1503 /* if (pMgntInfo->RegPreambleMode == PREAMBLE_AUTO) */ 1504 { 1505 if (updateCap & cShortPreamble) { 1506 /* Short Preamble */ 1507 if (pmlmeinfo->preamble_mode != PREAMBLE_SHORT) { /* PREAMBLE_LONG or PREAMBLE_AUTO */ 1508 ShortPreamble = true; 1509 pmlmeinfo->preamble_mode = PREAMBLE_SHORT; 1510 rtw_hal_set_hwreg(Adapter, HW_VAR_ACK_PREAMBLE, (u8 *)&ShortPreamble); 1511 } 1512 } else { 1513 /* Long Preamble */ 1514 if (pmlmeinfo->preamble_mode != PREAMBLE_LONG) { /* PREAMBLE_SHORT or PREAMBLE_AUTO */ 1515 ShortPreamble = false; 1516 pmlmeinfo->preamble_mode = PREAMBLE_LONG; 1517 rtw_hal_set_hwreg(Adapter, HW_VAR_ACK_PREAMBLE, (u8 *)&ShortPreamble); 1518 } 1519 } 1520 } 1521 1522 if (updateCap & cIBSS) { 1523 /* Filen: See 802.11-2007 p.91 */ 1524 pmlmeinfo->slotTime = NON_SHORT_SLOT_TIME; 1525 } else { 1526 /* Filen: See 802.11-2007 p.90 */ 1527 if (pmlmeext->cur_wireless_mode & (WIRELESS_11_24N)) { 1528 pmlmeinfo->slotTime = SHORT_SLOT_TIME; 1529 } else if (pmlmeext->cur_wireless_mode & (WIRELESS_11G)) { 1530 if ((updateCap & cShortSlotTime) /* && (!(pMgntInfo->pHTInfo->RT2RT_HT_Mode & RT_HT_CAP_USE_LONG_PREAMBLE)) */) 1531 /* Short Slot Time */ 1532 pmlmeinfo->slotTime = SHORT_SLOT_TIME; 1533 else 1534 /* Long Slot Time */ 1535 pmlmeinfo->slotTime = NON_SHORT_SLOT_TIME; 1536 } else { 1537 /* B Mode */ 1538 pmlmeinfo->slotTime = NON_SHORT_SLOT_TIME; 1539 } 1540 } 1541 1542 rtw_hal_set_hwreg(Adapter, HW_VAR_SLOT_TIME, &pmlmeinfo->slotTime); 1543 } 1544 1545 void update_wireless_mode(struct adapter *padapter) 1546 { 1547 int network_type = 0; 1548 u32 SIFS_Timer; 1549 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 1550 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 1551 struct wlan_bssid_ex *cur_network = &(pmlmeinfo->network); 1552 unsigned char *rate = cur_network->supported_rates; 1553 1554 if ((pmlmeinfo->HT_info_enable) && (pmlmeinfo->HT_caps_enable)) 1555 pmlmeinfo->HT_enable = 1; 1556 1557 if (pmlmeinfo->HT_enable) 1558 network_type = WIRELESS_11_24N; 1559 1560 if (rtw_is_cckratesonly_included(rate)) 1561 network_type |= WIRELESS_11B; 1562 else if (rtw_is_cckrates_included(rate)) 1563 network_type |= WIRELESS_11BG; 1564 else 1565 network_type |= WIRELESS_11G; 1566 1567 pmlmeext->cur_wireless_mode = network_type & padapter->registrypriv.wireless_mode; 1568 1569 SIFS_Timer = 0x0a0a0808; /* 0x0808 -> for CCK, 0x0a0a -> for OFDM */ 1570 /* change this value if having IOT issues. */ 1571 1572 SetHwReg8723BS(padapter, HW_VAR_RESP_SIFS, (u8 *)&SIFS_Timer); 1573 1574 SetHwReg8723BS(padapter, HW_VAR_WIRELESS_MODE, (u8 *)&(pmlmeext->cur_wireless_mode)); 1575 1576 if (pmlmeext->cur_wireless_mode & WIRELESS_11B) 1577 update_mgnt_tx_rate(padapter, IEEE80211_CCK_RATE_1MB); 1578 else 1579 update_mgnt_tx_rate(padapter, IEEE80211_OFDM_RATE_6MB); 1580 } 1581 1582 void update_sta_basic_rate(struct sta_info *psta, u8 wireless_mode) 1583 { 1584 if (is_supported_tx_cck(wireless_mode)) { 1585 /* Only B, B/G, and B/G/N AP could use CCK rate */ 1586 memcpy(psta->bssrateset, rtw_basic_rate_cck, 4); 1587 psta->bssratelen = 4; 1588 } else { 1589 memcpy(psta->bssrateset, rtw_basic_rate_ofdm, 3); 1590 psta->bssratelen = 3; 1591 } 1592 } 1593 1594 int update_sta_support_rate(struct adapter *padapter, u8 *pvar_ie, uint var_ie_len, int cam_idx) 1595 { 1596 unsigned int ie_len; 1597 struct ndis_80211_var_ie *pIE; 1598 int support_rate_num = 0; 1599 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv); 1600 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 1601 1602 pIE = (struct ndis_80211_var_ie *)rtw_get_ie(pvar_ie, WLAN_EID_SUPP_RATES, &ie_len, var_ie_len); 1603 if (!pIE) 1604 return _FAIL; 1605 if (ie_len > sizeof(pmlmeinfo->FW_sta_info[cam_idx].SupportedRates)) 1606 return _FAIL; 1607 1608 memcpy(pmlmeinfo->FW_sta_info[cam_idx].SupportedRates, pIE->data, ie_len); 1609 support_rate_num = ie_len; 1610 1611 pIE = (struct ndis_80211_var_ie *)rtw_get_ie(pvar_ie, WLAN_EID_EXT_SUPP_RATES, &ie_len, var_ie_len); 1612 if (pIE && (ie_len <= sizeof(pmlmeinfo->FW_sta_info[cam_idx].SupportedRates) - support_rate_num)) 1613 memcpy((pmlmeinfo->FW_sta_info[cam_idx].SupportedRates + support_rate_num), pIE->data, ie_len); 1614 1615 return _SUCCESS; 1616 } 1617 1618 void process_addba_req(struct adapter *padapter, u8 *paddba_req, u8 *addr) 1619 { 1620 struct sta_info *psta; 1621 u16 tid, param; 1622 struct recv_reorder_ctrl *preorder_ctrl; 1623 struct sta_priv *pstapriv = &padapter->stapriv; 1624 struct ADDBA_request *preq = (struct ADDBA_request *)paddba_req; 1625 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 1626 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 1627 1628 psta = rtw_get_stainfo(pstapriv, addr); 1629 1630 if (psta) { 1631 param = le16_to_cpu(preq->BA_para_set); 1632 tid = (param >> 2) & 0x0f; 1633 1634 preorder_ctrl = &psta->recvreorder_ctrl[tid]; 1635 1636 preorder_ctrl->indicate_seq = 0xffff; 1637 1638 preorder_ctrl->enable = pmlmeinfo->accept_addba_req; 1639 } 1640 } 1641 1642 void update_TSF(struct mlme_ext_priv *pmlmeext, u8 *pframe, uint len) 1643 { 1644 u8 *pIE; 1645 __le32 *pbuf; 1646 1647 pIE = pframe + sizeof(struct ieee80211_hdr_3addr); 1648 pbuf = (__le32 *)pIE; 1649 1650 pmlmeext->TSFValue = le32_to_cpu(*(pbuf + 1)); 1651 1652 pmlmeext->TSFValue = pmlmeext->TSFValue << 32; 1653 1654 pmlmeext->TSFValue |= le32_to_cpu(*pbuf); 1655 } 1656 1657 void correct_TSF(struct adapter *padapter, struct mlme_ext_priv *pmlmeext) 1658 { 1659 rtw_hal_set_hwreg(padapter, HW_VAR_CORRECT_TSF, NULL); 1660 } 1661 1662 void adaptive_early_32k(struct mlme_ext_priv *pmlmeext, u8 *pframe, uint len) 1663 { 1664 int i; 1665 u8 *pIE; 1666 __le32 *pbuf; 1667 u64 tsf = 0; 1668 u32 delay_ms; 1669 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 1670 1671 pmlmeext->bcn_cnt++; 1672 1673 pIE = pframe + sizeof(struct ieee80211_hdr_3addr); 1674 pbuf = (__le32 *)pIE; 1675 1676 tsf = le32_to_cpu(*(pbuf + 1)); 1677 tsf = tsf << 32; 1678 tsf |= le32_to_cpu(*pbuf); 1679 1680 /* delay = (timestamp mod 1024*100)/1000 (unit: ms) */ 1681 /* delay_ms = do_div(tsf, (pmlmeinfo->bcn_interval*1024))/1000; */ 1682 delay_ms = do_div(tsf, (pmlmeinfo->bcn_interval * 1024)); 1683 delay_ms = delay_ms / 1000; 1684 1685 if (delay_ms >= 8) 1686 pmlmeext->bcn_delay_cnt[8]++; 1687 /* pmlmeext->bcn_delay_ratio[8] = (pmlmeext->bcn_delay_cnt[8] * 100) /pmlmeext->bcn_cnt; */ 1688 else 1689 pmlmeext->bcn_delay_cnt[delay_ms]++; 1690 /* pmlmeext->bcn_delay_ratio[delay_ms] = (pmlmeext->bcn_delay_cnt[delay_ms] * 100) /pmlmeext->bcn_cnt; */ 1691 /* dump for adaptive_early_32k */ 1692 if (pmlmeext->bcn_cnt > 100 && (pmlmeext->adaptive_tsf_done == true)) { 1693 u8 ratio_20_delay, ratio_80_delay; 1694 u8 DrvBcnEarly, DrvBcnTimeOut; 1695 1696 ratio_20_delay = 0; 1697 ratio_80_delay = 0; 1698 DrvBcnEarly = 0xff; 1699 DrvBcnTimeOut = 0xff; 1700 1701 for (i = 0; i < 9; i++) { 1702 pmlmeext->bcn_delay_ratio[i] = (pmlmeext->bcn_delay_cnt[i] * 100) / pmlmeext->bcn_cnt; 1703 1704 ratio_20_delay += pmlmeext->bcn_delay_ratio[i]; 1705 ratio_80_delay += pmlmeext->bcn_delay_ratio[i]; 1706 1707 if (ratio_20_delay > 20 && DrvBcnEarly == 0xff) 1708 DrvBcnEarly = i; 1709 1710 if (ratio_80_delay > 80 && DrvBcnTimeOut == 0xff) 1711 DrvBcnTimeOut = i; 1712 1713 /* reset adaptive_early_32k cnt */ 1714 pmlmeext->bcn_delay_cnt[i] = 0; 1715 pmlmeext->bcn_delay_ratio[i] = 0; 1716 } 1717 1718 pmlmeext->DrvBcnEarly = DrvBcnEarly; 1719 pmlmeext->DrvBcnTimeOut = DrvBcnTimeOut; 1720 1721 pmlmeext->bcn_cnt = 0; 1722 } 1723 } 1724 1725 void rtw_alloc_macid(struct adapter *padapter, struct sta_info *psta) 1726 { 1727 int i; 1728 struct dvobj_priv *pdvobj = adapter_to_dvobj(padapter); 1729 1730 if (is_broadcast_ether_addr(psta->hwaddr)) 1731 return; 1732 1733 if (!memcmp(psta->hwaddr, myid(&padapter->eeprompriv), ETH_ALEN)) { 1734 psta->mac_id = NUM_STA; 1735 return; 1736 } 1737 1738 spin_lock_bh(&pdvobj->lock); 1739 for (i = 0; i < NUM_STA; i++) { 1740 if (pdvobj->macid[i] == false) { 1741 pdvobj->macid[i] = true; 1742 break; 1743 } 1744 } 1745 spin_unlock_bh(&pdvobj->lock); 1746 1747 if (i > (NUM_STA - 1)) 1748 psta->mac_id = NUM_STA; 1749 else 1750 psta->mac_id = i; 1751 } 1752 1753 void rtw_release_macid(struct adapter *padapter, struct sta_info *psta) 1754 { 1755 struct dvobj_priv *pdvobj = adapter_to_dvobj(padapter); 1756 1757 if (is_broadcast_ether_addr(psta->hwaddr)) 1758 return; 1759 1760 if (!memcmp(psta->hwaddr, myid(&padapter->eeprompriv), ETH_ALEN)) 1761 return; 1762 1763 spin_lock_bh(&pdvobj->lock); 1764 if (psta->mac_id < NUM_STA && psta->mac_id != 1) { 1765 if (pdvobj->macid[psta->mac_id] == true) { 1766 pdvobj->macid[psta->mac_id] = false; 1767 psta->mac_id = NUM_STA; 1768 } 1769 } 1770 spin_unlock_bh(&pdvobj->lock); 1771 } 1772