1 // SPDX-License-Identifier: GPL-2.0 2 /****************************************************************************** 3 * 4 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved. 5 * 6 ******************************************************************************/ 7 #define _RTW_AP_C_ 8 9 #include <drv_types.h> 10 #include <rtw_debug.h> 11 #include <asm/unaligned.h> 12 13 void init_mlme_ap_info(struct adapter *padapter) 14 { 15 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 16 struct sta_priv *pstapriv = &padapter->stapriv; 17 struct wlan_acl_pool *pacl_list = &pstapriv->acl_list; 18 19 spin_lock_init(&pmlmepriv->bcn_update_lock); 20 21 /* for ACL */ 22 _rtw_init_queue(&pacl_list->acl_node_q); 23 24 /* pmlmeext->bstart_bss = false; */ 25 26 start_ap_mode(padapter); 27 } 28 29 void free_mlme_ap_info(struct adapter *padapter) 30 { 31 struct sta_info *psta = NULL; 32 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 33 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 34 struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info; 35 36 /* stop_ap_mode(padapter); */ 37 38 pmlmepriv->update_bcn = false; 39 pmlmeext->bstart_bss = false; 40 41 rtw_sta_flush(padapter); 42 43 pmlmeinfo->state = _HW_STATE_NOLINK_; 44 45 /* free_assoc_sta_resources */ 46 rtw_free_all_stainfo(padapter); 47 48 /* free bc/mc sta_info */ 49 psta = rtw_get_bcmc_stainfo(padapter); 50 rtw_free_stainfo(padapter, psta); 51 } 52 53 static void update_BCNTIM(struct adapter *padapter) 54 { 55 struct sta_priv *pstapriv = &padapter->stapriv; 56 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 57 struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info; 58 struct wlan_bssid_ex *pnetwork_mlmeext = &pmlmeinfo->network; 59 unsigned char *pie = pnetwork_mlmeext->IEs; 60 61 /* update TIM IE */ 62 u8 *p, *dst_ie, *premainder_ie = NULL, *pbackup_remainder_ie = NULL; 63 __le16 tim_bitmap_le; 64 uint offset, tmp_len, tim_ielen, tim_ie_offset, remainder_ielen; 65 66 tim_bitmap_le = cpu_to_le16(pstapriv->tim_bitmap); 67 68 p = rtw_get_ie(pie + _FIXED_IE_LENGTH_, 69 WLAN_EID_TIM, 70 &tim_ielen, 71 pnetwork_mlmeext->IELength - _FIXED_IE_LENGTH_ 72 ); 73 if (p && tim_ielen > 0) { 74 tim_ielen += 2; 75 76 premainder_ie = p + tim_ielen; 77 78 tim_ie_offset = (signed int)(p - pie); 79 80 remainder_ielen = pnetwork_mlmeext->IELength - tim_ie_offset - tim_ielen; 81 82 /* append TIM IE from dst_ie offset */ 83 dst_ie = p; 84 } else { 85 tim_ielen = 0; 86 87 /* calculate head_len */ 88 offset = _FIXED_IE_LENGTH_; 89 90 /* get ssid_ie len */ 91 p = rtw_get_ie(pie + _BEACON_IE_OFFSET_, 92 WLAN_EID_SSID, 93 &tmp_len, 94 (pnetwork_mlmeext->IELength - _BEACON_IE_OFFSET_) 95 ); 96 if (p) 97 offset += tmp_len + 2; 98 99 /* get supported rates len */ 100 p = rtw_get_ie(pie + _BEACON_IE_OFFSET_, 101 WLAN_EID_SUPP_RATES, &tmp_len, 102 (pnetwork_mlmeext->IELength - _BEACON_IE_OFFSET_) 103 ); 104 if (p) 105 offset += tmp_len + 2; 106 107 /* DS Parameter Set IE, len =3 */ 108 offset += 3; 109 110 premainder_ie = pie + offset; 111 112 remainder_ielen = pnetwork_mlmeext->IELength - offset - tim_ielen; 113 114 /* append TIM IE from offset */ 115 dst_ie = pie + offset; 116 } 117 118 if (remainder_ielen > 0) { 119 pbackup_remainder_ie = rtw_malloc(remainder_ielen); 120 if (pbackup_remainder_ie && premainder_ie) 121 memcpy(pbackup_remainder_ie, premainder_ie, remainder_ielen); 122 } 123 124 *dst_ie++ = WLAN_EID_TIM; 125 126 if ((pstapriv->tim_bitmap & 0xff00) && (pstapriv->tim_bitmap & 0x00fe)) 127 tim_ielen = 5; 128 else 129 tim_ielen = 4; 130 131 *dst_ie++ = tim_ielen; 132 133 *dst_ie++ = 0;/* DTIM count */ 134 *dst_ie++ = 1;/* DTIM period */ 135 136 if (pstapriv->tim_bitmap & BIT(0))/* for bc/mc frames */ 137 *dst_ie++ = BIT(0);/* bitmap ctrl */ 138 else 139 *dst_ie++ = 0; 140 141 if (tim_ielen == 4) { 142 __le16 pvb; 143 144 if (pstapriv->tim_bitmap & 0xff00) 145 pvb = cpu_to_le16(pstapriv->tim_bitmap >> 8); 146 else 147 pvb = tim_bitmap_le; 148 149 *dst_ie++ = le16_to_cpu(pvb); 150 151 } else if (tim_ielen == 5) { 152 memcpy(dst_ie, &tim_bitmap_le, 2); 153 dst_ie += 2; 154 } 155 156 /* copy remainder IE */ 157 if (pbackup_remainder_ie) { 158 memcpy(dst_ie, pbackup_remainder_ie, remainder_ielen); 159 160 kfree(pbackup_remainder_ie); 161 } 162 163 offset = (uint)(dst_ie - pie); 164 pnetwork_mlmeext->IELength = offset + remainder_ielen; 165 } 166 167 static u8 chk_sta_is_alive(struct sta_info *psta) 168 { 169 sta_update_last_rx_pkts(psta); 170 171 return true; 172 } 173 174 void expire_timeout_chk(struct adapter *padapter) 175 { 176 struct list_head *phead, *plist, *tmp; 177 u8 updated = false; 178 struct sta_info *psta = NULL; 179 struct sta_priv *pstapriv = &padapter->stapriv; 180 u8 chk_alive_num = 0; 181 char chk_alive_list[NUM_STA]; 182 int i; 183 184 spin_lock_bh(&pstapriv->auth_list_lock); 185 186 phead = &pstapriv->auth_list; 187 /* check auth_queue */ 188 list_for_each_safe(plist, tmp, phead) { 189 psta = list_entry(plist, struct sta_info, auth_list); 190 191 if (psta->expire_to > 0) { 192 psta->expire_to--; 193 if (psta->expire_to == 0) { 194 list_del_init(&psta->auth_list); 195 pstapriv->auth_list_cnt--; 196 197 spin_unlock_bh(&pstapriv->auth_list_lock); 198 199 rtw_free_stainfo(padapter, psta); 200 201 spin_lock_bh(&pstapriv->auth_list_lock); 202 } 203 } 204 } 205 206 spin_unlock_bh(&pstapriv->auth_list_lock); 207 psta = NULL; 208 209 spin_lock_bh(&pstapriv->asoc_list_lock); 210 211 phead = &pstapriv->asoc_list; 212 /* check asoc_queue */ 213 list_for_each_safe(plist, tmp, phead) { 214 psta = list_entry(plist, struct sta_info, asoc_list); 215 if (chk_sta_is_alive(psta) || !psta->expire_to) { 216 psta->expire_to = pstapriv->expire_to; 217 psta->keep_alive_trycnt = 0; 218 psta->under_exist_checking = 0; 219 } else { 220 if (psta->expire_to > 0) 221 psta->expire_to--; 222 } 223 224 if (psta->expire_to == 0) { 225 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 226 227 if (padapter->registrypriv.wifi_spec == 1) { 228 psta->expire_to = pstapriv->expire_to; 229 continue; 230 } 231 232 if (psta->state & WIFI_SLEEP_STATE) { 233 if (!(psta->state & WIFI_STA_ALIVE_CHK_STATE)) { 234 /* to check if alive by another methods */ 235 /* if station is at ps mode. */ 236 psta->expire_to = pstapriv->expire_to; 237 psta->state |= WIFI_STA_ALIVE_CHK_STATE; 238 239 /* to update bcn with tim_bitmap for this station */ 240 pstapriv->tim_bitmap |= BIT(psta->aid); 241 update_beacon(padapter, WLAN_EID_TIM, NULL, true); 242 243 if (!pmlmeext->active_keep_alive_check) 244 continue; 245 } 246 } 247 if (pmlmeext->active_keep_alive_check) { 248 int stainfo_offset; 249 250 stainfo_offset = rtw_stainfo_offset(pstapriv, psta); 251 if (stainfo_offset_valid(stainfo_offset)) 252 chk_alive_list[chk_alive_num++] = stainfo_offset; 253 254 continue; 255 } 256 list_del_init(&psta->asoc_list); 257 pstapriv->asoc_list_cnt--; 258 updated = ap_free_sta(padapter, psta, false, WLAN_REASON_DEAUTH_LEAVING); 259 } else { 260 /* TODO: Aging mechanism to digest frames in sleep_q to */ 261 /* avoid running out of xmitframe */ 262 if (psta->sleepq_len > (NR_XMITFRAME / pstapriv->asoc_list_cnt) 263 && padapter->xmitpriv.free_xmitframe_cnt < (( 264 NR_XMITFRAME / pstapriv->asoc_list_cnt 265 ) / 2) 266 ) 267 wakeup_sta_to_xmit(padapter, psta); 268 } 269 } 270 271 spin_unlock_bh(&pstapriv->asoc_list_lock); 272 273 if (chk_alive_num) { 274 u8 backup_oper_channel = 0; 275 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 276 277 /* switch to correct channel of current network before issue keep-alive frames */ 278 if (rtw_get_oper_ch(padapter) != pmlmeext->cur_channel) { 279 backup_oper_channel = rtw_get_oper_ch(padapter); 280 SelectChannel(padapter, pmlmeext->cur_channel); 281 } 282 283 /* issue null data to check sta alive*/ 284 for (i = 0; i < chk_alive_num; i++) { 285 int ret = _FAIL; 286 287 psta = rtw_get_stainfo_by_offset(pstapriv, chk_alive_list[i]); 288 if (!(psta->state & _FW_LINKED)) 289 continue; 290 291 if (psta->state & WIFI_SLEEP_STATE) 292 ret = issue_nulldata(padapter, psta->hwaddr, 0, 1, 50); 293 else 294 ret = issue_nulldata(padapter, psta->hwaddr, 0, 3, 50); 295 296 psta->keep_alive_trycnt++; 297 if (ret == _SUCCESS) { 298 psta->expire_to = pstapriv->expire_to; 299 psta->keep_alive_trycnt = 0; 300 continue; 301 } else if (psta->keep_alive_trycnt <= 3) { 302 psta->expire_to = 1; 303 continue; 304 } 305 306 psta->keep_alive_trycnt = 0; 307 spin_lock_bh(&pstapriv->asoc_list_lock); 308 if (list_empty(&psta->asoc_list) == false) { 309 list_del_init(&psta->asoc_list); 310 pstapriv->asoc_list_cnt--; 311 updated = ap_free_sta(padapter, psta, false, 312 WLAN_REASON_DEAUTH_LEAVING); 313 } 314 spin_unlock_bh(&pstapriv->asoc_list_lock); 315 } 316 317 if (backup_oper_channel > 0) /* back to the original operation channel */ 318 SelectChannel(padapter, backup_oper_channel); 319 } 320 321 associated_clients_update(padapter, updated); 322 } 323 324 void add_RATid(struct adapter *padapter, struct sta_info *psta, u8 rssi_level) 325 { 326 unsigned char sta_band = 0, shortGIrate = false; 327 unsigned int tx_ra_bitmap = 0; 328 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 329 struct wlan_bssid_ex 330 *pcur_network = (struct wlan_bssid_ex *)&pmlmepriv->cur_network.network; 331 332 if (!psta) 333 return; 334 335 if (!(psta->state & _FW_LINKED)) 336 return; 337 338 rtw_hal_update_sta_rate_mask(padapter, psta); 339 tx_ra_bitmap = psta->ra_mask; 340 341 shortGIrate = query_ra_short_GI(psta); 342 343 if (pcur_network->Configuration.DSConfig > 14) { 344 sta_band |= WIRELESS_INVALID; 345 } else { 346 if (tx_ra_bitmap & 0xffff000) 347 sta_band |= WIRELESS_11_24N; 348 349 if (tx_ra_bitmap & 0xff0) 350 sta_band |= WIRELESS_11G; 351 352 if (tx_ra_bitmap & 0x0f) 353 sta_band |= WIRELESS_11B; 354 } 355 356 psta->wireless_mode = sta_band; 357 psta->raid = networktype_to_raid_ex(padapter, psta); 358 359 if (psta->aid < NUM_STA) { 360 u8 arg[4] = {0}; 361 362 arg[0] = psta->mac_id; 363 arg[1] = psta->raid; 364 arg[2] = shortGIrate; 365 arg[3] = psta->init_rate; 366 367 rtw_hal_add_ra_tid(padapter, tx_ra_bitmap, arg, rssi_level); 368 } 369 } 370 371 void update_bmc_sta(struct adapter *padapter) 372 { 373 unsigned char network_type; 374 int supportRateNum = 0; 375 unsigned int tx_ra_bitmap = 0; 376 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 377 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv); 378 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 379 struct wlan_bssid_ex 380 *pcur_network = (struct wlan_bssid_ex *)&pmlmepriv->cur_network.network; 381 struct sta_info *psta = rtw_get_bcmc_stainfo(padapter); 382 383 if (psta) { 384 psta->aid = 0;/* default set to 0 */ 385 /* psta->mac_id = psta->aid+4; */ 386 psta->mac_id = psta->aid + 1;/* mac_id = 1 for bc/mc stainfo */ 387 388 pmlmeinfo->FW_sta_info[psta->mac_id].psta = psta; 389 390 psta->qos_option = 0; 391 psta->htpriv.ht_option = false; 392 393 psta->ieee8021x_blocked = 0; 394 395 memset((void *)&psta->sta_stats, 0, sizeof(struct stainfo_stats)); 396 397 /* psta->dot118021XPrivacy = _NO_PRIVACY_;//!!! remove it, because it has been set before this. */ 398 399 /* prepare for add_RATid */ 400 supportRateNum = rtw_get_rateset_len((u8 *)&pcur_network->SupportedRates); 401 network_type = rtw_check_network_type((u8 *)&pcur_network->SupportedRates, 402 supportRateNum, 403 pcur_network->Configuration.DSConfig 404 ); 405 if (IsSupportedTxCCK(network_type)) { 406 network_type = WIRELESS_11B; 407 } else if (network_type == WIRELESS_INVALID) { /* error handling */ 408 409 if (pcur_network->Configuration.DSConfig > 14) 410 network_type = WIRELESS_INVALID; 411 else 412 network_type = WIRELESS_11B; 413 } 414 update_sta_basic_rate(psta, network_type); 415 psta->wireless_mode = network_type; 416 417 rtw_hal_update_sta_rate_mask(padapter, psta); 418 tx_ra_bitmap = psta->ra_mask; 419 420 psta->raid = networktype_to_raid_ex(padapter, psta); 421 422 /* ap mode */ 423 rtw_hal_set_odm_var(padapter, HAL_ODM_STA_INFO, psta, true); 424 425 /* if (pHalData->fw_ractrl == true) */ 426 { 427 u8 arg[4] = {0}; 428 429 arg[0] = psta->mac_id; 430 arg[1] = psta->raid; 431 arg[2] = 0; 432 arg[3] = psta->init_rate; 433 434 rtw_hal_add_ra_tid(padapter, tx_ra_bitmap, arg, 0); 435 } 436 437 rtw_sta_media_status_rpt(padapter, psta, 1); 438 439 spin_lock_bh(&psta->lock); 440 psta->state = _FW_LINKED; 441 spin_unlock_bh(&psta->lock); 442 443 } 444 } 445 446 /* notes: */ 447 /* AID: 1~MAX for sta and 0 for bc/mc in ap/adhoc mode */ 448 /* MAC_ID = AID+1 for sta in ap/adhoc mode */ 449 /* MAC_ID = 1 for bc/mc for sta/ap/adhoc */ 450 /* MAC_ID = 0 for bssid for sta/ap/adhoc */ 451 /* CAM_ID = 0~3 for default key, cmd_id =macid + 3, macid =aid+1; */ 452 453 void update_sta_info_apmode(struct adapter *padapter, struct sta_info *psta) 454 { 455 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 456 struct security_priv *psecuritypriv = &padapter->securitypriv; 457 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv); 458 struct ht_priv *phtpriv_ap = &pmlmepriv->htpriv; 459 struct ht_priv *phtpriv_sta = &psta->htpriv; 460 u8 cur_ldpc_cap = 0, cur_stbc_cap = 0, cur_beamform_cap = 0; 461 /* set intf_tag to if1 */ 462 /* psta->intf_tag = 0; */ 463 464 /* psta->mac_id = psta->aid+4; */ 465 /* psta->mac_id = psta->aid+1;//alloc macid when call rtw_alloc_stainfo(), */ 466 /* release macid when call rtw_free_stainfo() */ 467 468 /* ap mode */ 469 rtw_hal_set_odm_var(padapter, HAL_ODM_STA_INFO, psta, true); 470 471 if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) 472 psta->ieee8021x_blocked = true; 473 else 474 psta->ieee8021x_blocked = false; 475 476 /* update sta's cap */ 477 478 /* ERP */ 479 VCS_update(padapter, psta); 480 481 /* HT related cap */ 482 if (phtpriv_sta->ht_option) { 483 /* check if sta supports rx ampdu */ 484 phtpriv_sta->ampdu_enable = phtpriv_ap->ampdu_enable; 485 486 phtpriv_sta->rx_ampdu_min_spacing = ( 487 phtpriv_sta->ht_cap.ampdu_params_info & IEEE80211_HT_CAP_AMPDU_DENSITY 488 ) >> 2; 489 490 /* bwmode */ 491 if (( 492 phtpriv_sta->ht_cap.cap_info & phtpriv_ap->ht_cap.cap_info 493 ) & cpu_to_le16(IEEE80211_HT_CAP_SUP_WIDTH)) 494 psta->bw_mode = CHANNEL_WIDTH_40; 495 else 496 psta->bw_mode = CHANNEL_WIDTH_20; 497 498 if (pmlmeext->cur_bwmode < psta->bw_mode) 499 psta->bw_mode = pmlmeext->cur_bwmode; 500 501 phtpriv_sta->ch_offset = pmlmeext->cur_ch_offset; 502 503 /* check if sta support s Short GI 20M */ 504 if (( 505 phtpriv_sta->ht_cap.cap_info & phtpriv_ap->ht_cap.cap_info 506 ) & cpu_to_le16(IEEE80211_HT_CAP_SGI_20)) 507 phtpriv_sta->sgi_20m = true; 508 509 /* check if sta support s Short GI 40M */ 510 if (( 511 phtpriv_sta->ht_cap.cap_info & phtpriv_ap->ht_cap.cap_info 512 ) & cpu_to_le16(IEEE80211_HT_CAP_SGI_40)) { 513 if (psta->bw_mode == CHANNEL_WIDTH_40) /* according to psta->bw_mode */ 514 phtpriv_sta->sgi_40m = true; 515 else 516 phtpriv_sta->sgi_40m = false; 517 } 518 519 psta->qos_option = true; 520 521 /* B0 Config LDPC Coding Capability */ 522 if (TEST_FLAG(phtpriv_ap->ldpc_cap, LDPC_HT_ENABLE_TX) && 523 GET_HT_CAPABILITY_ELE_LDPC_CAP((u8 *)(&phtpriv_sta->ht_cap))) 524 SET_FLAG(cur_ldpc_cap, (LDPC_HT_ENABLE_TX | LDPC_HT_CAP_TX)); 525 526 /* B7 B8 B9 Config STBC setting */ 527 if (TEST_FLAG(phtpriv_ap->stbc_cap, STBC_HT_ENABLE_TX) && 528 GET_HT_CAPABILITY_ELE_RX_STBC((u8 *)(&phtpriv_sta->ht_cap))) 529 SET_FLAG(cur_stbc_cap, (STBC_HT_ENABLE_TX | STBC_HT_CAP_TX)); 530 } else { 531 phtpriv_sta->ampdu_enable = false; 532 533 phtpriv_sta->sgi_20m = false; 534 phtpriv_sta->sgi_40m = false; 535 psta->bw_mode = CHANNEL_WIDTH_20; 536 phtpriv_sta->ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE; 537 } 538 539 phtpriv_sta->ldpc_cap = cur_ldpc_cap; 540 phtpriv_sta->stbc_cap = cur_stbc_cap; 541 phtpriv_sta->beamform_cap = cur_beamform_cap; 542 543 /* Rx AMPDU */ 544 send_delba(padapter, 0, psta->hwaddr);/* recipient */ 545 546 /* TX AMPDU */ 547 send_delba(padapter, 1, psta->hwaddr);/* originator */ 548 phtpriv_sta->agg_enable_bitmap = 0x0;/* reset */ 549 phtpriv_sta->candidate_tid_bitmap = 0x0;/* reset */ 550 551 update_ldpc_stbc_cap(psta); 552 553 /* todo: init other variables */ 554 555 memset((void *)&psta->sta_stats, 0, sizeof(struct stainfo_stats)); 556 557 /* add ratid */ 558 /* add_RATid(padapter, psta);//move to ap_sta_info_defer_update() */ 559 560 spin_lock_bh(&psta->lock); 561 psta->state |= _FW_LINKED; 562 spin_unlock_bh(&psta->lock); 563 } 564 565 static void update_ap_info(struct adapter *padapter, struct sta_info *psta) 566 { 567 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 568 struct wlan_bssid_ex 569 *pnetwork = (struct wlan_bssid_ex *)&pmlmepriv->cur_network.network; 570 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv); 571 struct ht_priv *phtpriv_ap = &pmlmepriv->htpriv; 572 573 psta->wireless_mode = pmlmeext->cur_wireless_mode; 574 575 psta->bssratelen = rtw_get_rateset_len(pnetwork->SupportedRates); 576 memcpy(psta->bssrateset, pnetwork->SupportedRates, psta->bssratelen); 577 578 /* HT related cap */ 579 if (phtpriv_ap->ht_option) { 580 /* check if sta supports rx ampdu */ 581 /* phtpriv_ap->ampdu_enable = phtpriv_ap->ampdu_enable; */ 582 583 /* check if sta support s Short GI 20M */ 584 if ((phtpriv_ap->ht_cap.cap_info) & cpu_to_le16(IEEE80211_HT_CAP_SGI_20)) 585 phtpriv_ap->sgi_20m = true; 586 587 /* check if sta support s Short GI 40M */ 588 if ((phtpriv_ap->ht_cap.cap_info) & cpu_to_le16(IEEE80211_HT_CAP_SGI_40)) 589 phtpriv_ap->sgi_40m = true; 590 591 psta->qos_option = true; 592 } else { 593 phtpriv_ap->ampdu_enable = false; 594 595 phtpriv_ap->sgi_20m = false; 596 phtpriv_ap->sgi_40m = false; 597 } 598 599 psta->bw_mode = pmlmeext->cur_bwmode; 600 phtpriv_ap->ch_offset = pmlmeext->cur_ch_offset; 601 602 phtpriv_ap->agg_enable_bitmap = 0x0;/* reset */ 603 phtpriv_ap->candidate_tid_bitmap = 0x0;/* reset */ 604 605 memcpy(&psta->htpriv, &pmlmepriv->htpriv, sizeof(struct ht_priv)); 606 } 607 608 static void update_hw_ht_param(struct adapter *padapter) 609 { 610 unsigned char max_AMPDU_len; 611 unsigned char min_MPDU_spacing; 612 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 613 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 614 615 /* handle A-MPDU parameter field 616 * 617 * AMPDU_para [1:0]:Max AMPDU Len => 0:8k , 1:16k, 2:32k, 3:64k 618 * AMPDU_para [4:2]:Min MPDU Start Spacing 619 */ 620 max_AMPDU_len = pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x03; 621 622 min_MPDU_spacing = (pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x1c) >> 2; 623 624 rtw_hal_set_hwreg(padapter, HW_VAR_AMPDU_MIN_SPACE, (u8 *)(&min_MPDU_spacing)); 625 626 rtw_hal_set_hwreg(padapter, HW_VAR_AMPDU_FACTOR, (u8 *)(&max_AMPDU_len)); 627 628 /* */ 629 /* Config SM Power Save setting */ 630 /* */ 631 pmlmeinfo->SM_PS = (le16_to_cpu( 632 pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info 633 ) & 0x0C) >> 2; 634 635 /* */ 636 /* Config current HT Protection mode. */ 637 /* */ 638 /* pmlmeinfo->HT_protection = pmlmeinfo->HT_info.infos[1] & 0x3; */ 639 } 640 641 void start_bss_network(struct adapter *padapter) 642 { 643 u8 *p; 644 u8 val8, cur_channel, cur_bwmode, cur_ch_offset; 645 u16 bcn_interval; 646 u32 acparm; 647 int ie_len; 648 struct registry_priv *pregpriv = &padapter->registrypriv; 649 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 650 struct security_priv *psecuritypriv = &(padapter->securitypriv); 651 struct wlan_bssid_ex 652 *pnetwork = (struct wlan_bssid_ex *)&pmlmepriv->cur_network.network; 653 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv); 654 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 655 struct wlan_bssid_ex *pnetwork_mlmeext = &(pmlmeinfo->network); 656 struct HT_info_element *pht_info = NULL; 657 u8 cbw40_enable = 0; 658 659 bcn_interval = (u16)pnetwork->Configuration.BeaconPeriod; 660 cur_channel = pnetwork->Configuration.DSConfig; 661 cur_bwmode = CHANNEL_WIDTH_20; 662 cur_ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE; 663 664 /* check if there is wps ie, */ 665 /* if there is wpsie in beacon, the hostapd will update beacon twice when stating hostapd, */ 666 /* and at first time the security ie (RSN/WPA IE) will not include in beacon. */ 667 if (!rtw_get_wps_ie(pnetwork->IEs + _FIXED_IE_LENGTH_, 668 pnetwork->IELength - _FIXED_IE_LENGTH_, NULL, NULL)) 669 pmlmeext->bstart_bss = true; 670 671 /* todo: update wmm, ht cap */ 672 /* pmlmeinfo->WMM_enable; */ 673 /* pmlmeinfo->HT_enable; */ 674 if (pmlmepriv->qospriv.qos_option) 675 pmlmeinfo->WMM_enable = true; 676 if (pmlmepriv->htpriv.ht_option) { 677 pmlmeinfo->WMM_enable = true; 678 pmlmeinfo->HT_enable = true; 679 /* pmlmeinfo->HT_info_enable = true; */ 680 /* pmlmeinfo->HT_caps_enable = true; */ 681 682 update_hw_ht_param(padapter); 683 } 684 685 if (!pmlmepriv->cur_network.join_res) { /* setting only at first time */ 686 687 /* WEP Key will be set before this function, do not clear CAM. */ 688 if ((psecuritypriv->dot11PrivacyAlgrthm != _WEP40_) && 689 (psecuritypriv->dot11PrivacyAlgrthm != _WEP104_)) 690 flush_all_cam_entry(padapter); /* clear CAM */ 691 } 692 693 /* set MSR to AP_Mode */ 694 Set_MSR(padapter, _HW_STATE_AP_); 695 696 /* Set BSSID REG */ 697 rtw_hal_set_hwreg(padapter, HW_VAR_BSSID, pnetwork->MacAddress); 698 699 /* Set EDCA param reg */ 700 acparm = 0x002F3217; /* VO */ 701 rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_VO, (u8 *)(&acparm)); 702 acparm = 0x005E4317; /* VI */ 703 rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_VI, (u8 *)(&acparm)); 704 /* acparm = 0x00105320; // BE */ 705 acparm = 0x005ea42b; 706 rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_BE, (u8 *)(&acparm)); 707 acparm = 0x0000A444; /* BK */ 708 rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_BK, (u8 *)(&acparm)); 709 710 /* Set Security */ 711 val8 = ( 712 psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X 713 ) ? 0xcc : 0xcf; 714 rtw_hal_set_hwreg(padapter, HW_VAR_SEC_CFG, (u8 *)(&val8)); 715 716 /* Beacon Control related register */ 717 rtw_hal_set_hwreg(padapter, HW_VAR_BEACON_INTERVAL, (u8 *)(&bcn_interval)); 718 719 rtw_hal_set_hwreg(padapter, HW_VAR_DO_IQK, NULL); 720 721 if (!pmlmepriv->cur_network.join_res) { /* setting only at first time */ 722 /* u32 initialgain; */ 723 724 /* initialgain = 0x1e; */ 725 726 /* disable dynamic functions, such as high power, DIG */ 727 /* Save_DM_Func_Flag(padapter); */ 728 /* Switch_DM_Func(padapter, DYNAMIC_FUNC_DISABLE, false); */ 729 730 /* turn on all dynamic functions */ 731 Switch_DM_Func(padapter, DYNAMIC_ALL_FUNC_ENABLE, true); 732 733 /* rtw_hal_set_hwreg(padapter, HW_VAR_INITIAL_GAIN, (u8 *)(&initialgain)); */ 734 } 735 736 /* set channel, bwmode */ 737 p = rtw_get_ie((pnetwork->IEs + sizeof(struct ndis_802_11_fix_ie)), 738 WLAN_EID_HT_OPERATION, 739 &ie_len, 740 (pnetwork->IELength - sizeof(struct ndis_802_11_fix_ie)) 741 ); 742 if (p && ie_len) { 743 pht_info = (struct HT_info_element *)(p + 2); 744 745 if (cur_channel > 14) { 746 if ((pregpriv->bw_mode & 0xf0) > 0) 747 cbw40_enable = 1; 748 } else { 749 if ((pregpriv->bw_mode & 0x0f) > 0) 750 cbw40_enable = 1; 751 } 752 753 if ((cbw40_enable) && (pht_info->infos[0] & BIT(2))) { 754 /* switch to the 40M Hz mode */ 755 /* pmlmeext->cur_bwmode = CHANNEL_WIDTH_40; */ 756 cur_bwmode = CHANNEL_WIDTH_40; 757 switch (pht_info->infos[0] & 0x3) { 758 case 1: 759 /* pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_LOWER; */ 760 cur_ch_offset = HAL_PRIME_CHNL_OFFSET_LOWER; 761 break; 762 763 case 3: 764 /* pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_UPPER; */ 765 cur_ch_offset = HAL_PRIME_CHNL_OFFSET_UPPER; 766 break; 767 768 default: 769 /* pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE; */ 770 cur_ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE; 771 break; 772 } 773 } 774 } 775 776 set_channel_bwmode(padapter, cur_channel, cur_ch_offset, cur_bwmode); 777 pmlmeext->cur_channel = cur_channel; 778 pmlmeext->cur_bwmode = cur_bwmode; 779 pmlmeext->cur_ch_offset = cur_ch_offset; 780 pmlmeext->cur_wireless_mode = pmlmepriv->cur_network.network_type; 781 782 /* let pnetwork_mlmeext == pnetwork_mlme. */ 783 memcpy(pnetwork_mlmeext, pnetwork, pnetwork->Length); 784 785 /* update cur_wireless_mode */ 786 update_wireless_mode(padapter); 787 788 /* update RRSR after set channel and bandwidth */ 789 UpdateBrateTbl(padapter, pnetwork->SupportedRates); 790 rtw_hal_set_hwreg(padapter, HW_VAR_BASIC_RATE, pnetwork->SupportedRates); 791 792 /* update capability after cur_wireless_mode updated */ 793 update_capinfo( 794 padapter, 795 rtw_get_capability((struct wlan_bssid_ex *)pnetwork) 796 ); 797 798 if (pmlmeext->bstart_bss) { 799 update_beacon(padapter, WLAN_EID_TIM, NULL, true); 800 801 /* issue beacon frame */ 802 send_beacon(padapter); 803 } 804 805 /* update bc/mc sta_info */ 806 update_bmc_sta(padapter); 807 808 /* pmlmeext->bstart_bss = true; */ 809 } 810 811 int rtw_check_beacon_data(struct adapter *padapter, u8 *pbuf, int len) 812 { 813 int ret = _SUCCESS; 814 u8 *p; 815 u8 *pHT_caps_ie = NULL; 816 u8 *pHT_info_ie = NULL; 817 struct sta_info *psta = NULL; 818 u16 cap, ht_cap = false; 819 uint ie_len = 0; 820 int group_cipher, pairwise_cipher; 821 u8 channel, network_type, supportRate[NDIS_802_11_LENGTH_RATES_EX]; 822 int supportRateNum = 0; 823 u8 OUI1[] = {0x00, 0x50, 0xf2, 0x01}; 824 u8 WMM_PARA_IE[] = {0x00, 0x50, 0xf2, 0x02, 0x01, 0x01}; 825 struct registry_priv *pregistrypriv = &padapter->registrypriv; 826 struct security_priv *psecuritypriv = &padapter->securitypriv; 827 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 828 struct wlan_bssid_ex 829 *pbss_network = (struct wlan_bssid_ex *)&pmlmepriv->cur_network.network; 830 u8 *ie = pbss_network->IEs; 831 832 if (!check_fwstate(pmlmepriv, WIFI_AP_STATE)) 833 return _FAIL; 834 835 if (len < 0 || len > MAX_IE_SZ) 836 return _FAIL; 837 838 pbss_network->IELength = len; 839 840 memset(ie, 0, MAX_IE_SZ); 841 842 memcpy(ie, pbuf, pbss_network->IELength); 843 844 if (pbss_network->InfrastructureMode != Ndis802_11APMode) 845 return _FAIL; 846 847 pbss_network->Rssi = 0; 848 849 memcpy(pbss_network->MacAddress, myid(&(padapter->eeprompriv)), ETH_ALEN); 850 851 /* beacon interval */ 852 p = rtw_get_beacon_interval_from_ie(ie);/* ie + 8; 8: TimeStamp, 2: Beacon Interval 2:Capability */ 853 /* pbss_network->Configuration.BeaconPeriod = le16_to_cpu(*(unsigned short*)p); */ 854 pbss_network->Configuration.BeaconPeriod = get_unaligned_le16(p); 855 856 /* capability */ 857 /* cap = *(unsigned short *)rtw_get_capability_from_ie(ie); */ 858 /* cap = le16_to_cpu(cap); */ 859 cap = get_unaligned_le16(ie); 860 861 /* SSID */ 862 p = rtw_get_ie( 863 ie + _BEACON_IE_OFFSET_, 864 WLAN_EID_SSID, 865 &ie_len, 866 (pbss_network->IELength - _BEACON_IE_OFFSET_) 867 ); 868 if (p && ie_len > 0) { 869 memset(&pbss_network->Ssid, 0, sizeof(struct ndis_802_11_ssid)); 870 memcpy(pbss_network->Ssid.Ssid, (p + 2), ie_len); 871 pbss_network->Ssid.SsidLength = ie_len; 872 } 873 874 /* channel */ 875 channel = 0; 876 pbss_network->Configuration.Length = 0; 877 p = rtw_get_ie( 878 ie + _BEACON_IE_OFFSET_, 879 WLAN_EID_DS_PARAMS, &ie_len, 880 (pbss_network->IELength - _BEACON_IE_OFFSET_) 881 ); 882 if (p && ie_len > 0) 883 channel = *(p + 2); 884 885 pbss_network->Configuration.DSConfig = channel; 886 887 memset(supportRate, 0, NDIS_802_11_LENGTH_RATES_EX); 888 /* get supported rates */ 889 p = rtw_get_ie( 890 ie + _BEACON_IE_OFFSET_, 891 WLAN_EID_SUPP_RATES, 892 &ie_len, 893 (pbss_network->IELength - _BEACON_IE_OFFSET_) 894 ); 895 if (p != NULL) { 896 memcpy(supportRate, p + 2, ie_len); 897 supportRateNum = ie_len; 898 } 899 900 /* get ext_supported rates */ 901 p = rtw_get_ie( 902 ie + _BEACON_IE_OFFSET_, 903 WLAN_EID_EXT_SUPP_RATES, 904 &ie_len, 905 pbss_network->IELength - _BEACON_IE_OFFSET_ 906 ); 907 if (p != NULL) { 908 memcpy(supportRate + supportRateNum, p + 2, ie_len); 909 supportRateNum += ie_len; 910 } 911 912 network_type = rtw_check_network_type(supportRate, supportRateNum, channel); 913 914 rtw_set_supported_rate(pbss_network->SupportedRates, network_type); 915 916 /* parsing ERP_IE */ 917 p = rtw_get_ie( 918 ie + _BEACON_IE_OFFSET_, 919 WLAN_EID_ERP_INFO, 920 &ie_len, 921 (pbss_network->IELength - _BEACON_IE_OFFSET_) 922 ); 923 if (p && ie_len > 0) 924 ERP_IE_handler(padapter, (struct ndis_80211_var_ie *)p); 925 926 /* update privacy/security */ 927 if (cap & BIT(4)) 928 pbss_network->Privacy = 1; 929 else 930 pbss_network->Privacy = 0; 931 932 psecuritypriv->wpa_psk = 0; 933 934 /* wpa2 */ 935 group_cipher = 0; pairwise_cipher = 0; 936 psecuritypriv->wpa2_group_cipher = _NO_PRIVACY_; 937 psecuritypriv->wpa2_pairwise_cipher = _NO_PRIVACY_; 938 p = rtw_get_ie( 939 ie + _BEACON_IE_OFFSET_, 940 WLAN_EID_RSN, 941 &ie_len, 942 (pbss_network->IELength - _BEACON_IE_OFFSET_) 943 ); 944 if (p && ie_len > 0) { 945 if (rtw_parse_wpa2_ie( 946 p, 947 ie_len + 2, 948 &group_cipher, 949 &pairwise_cipher, 950 NULL 951 ) == _SUCCESS) { 952 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_8021X; 953 954 psecuritypriv->dot8021xalg = 1;/* psk, todo:802.1x */ 955 psecuritypriv->wpa_psk |= BIT(1); 956 957 psecuritypriv->wpa2_group_cipher = group_cipher; 958 psecuritypriv->wpa2_pairwise_cipher = pairwise_cipher; 959 } 960 } 961 962 /* wpa */ 963 ie_len = 0; 964 group_cipher = 0; pairwise_cipher = 0; 965 psecuritypriv->wpa_group_cipher = _NO_PRIVACY_; 966 psecuritypriv->wpa_pairwise_cipher = _NO_PRIVACY_; 967 for (p = ie + _BEACON_IE_OFFSET_; ; p += (ie_len + 2)) { 968 p = rtw_get_ie( 969 p, 970 WLAN_EID_VENDOR_SPECIFIC, 971 &ie_len, 972 (pbss_network->IELength - _BEACON_IE_OFFSET_ - (ie_len + 2)) 973 ); 974 if ((p) && (!memcmp(p + 2, OUI1, 4))) { 975 if (rtw_parse_wpa_ie( 976 p, 977 ie_len + 2, 978 &group_cipher, 979 &pairwise_cipher, 980 NULL 981 ) == _SUCCESS) { 982 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_8021X; 983 984 psecuritypriv->dot8021xalg = 1;/* psk, todo:802.1x */ 985 986 psecuritypriv->wpa_psk |= BIT(0); 987 988 psecuritypriv->wpa_group_cipher = group_cipher; 989 psecuritypriv->wpa_pairwise_cipher = pairwise_cipher; 990 } 991 992 break; 993 } 994 995 if ((p == NULL) || (ie_len == 0)) 996 break; 997 } 998 999 /* wmm */ 1000 ie_len = 0; 1001 pmlmepriv->qospriv.qos_option = 0; 1002 if (pregistrypriv->wmm_enable) { 1003 for (p = ie + _BEACON_IE_OFFSET_; ; p += (ie_len + 2)) { 1004 p = rtw_get_ie( 1005 p, 1006 WLAN_EID_VENDOR_SPECIFIC, 1007 &ie_len, 1008 (pbss_network->IELength - _BEACON_IE_OFFSET_ - (ie_len + 2)) 1009 ); 1010 if ((p) && !memcmp(p + 2, WMM_PARA_IE, 6)) { 1011 pmlmepriv->qospriv.qos_option = 1; 1012 1013 *(p + 8) |= BIT(7);/* QoS Info, support U-APSD */ 1014 1015 /* disable all ACM bits since the WMM admission */ 1016 /* control is not supported */ 1017 *(p + 10) &= ~BIT(4); /* BE */ 1018 *(p + 14) &= ~BIT(4); /* BK */ 1019 *(p + 18) &= ~BIT(4); /* VI */ 1020 *(p + 22) &= ~BIT(4); /* VO */ 1021 1022 break; 1023 } 1024 1025 if ((p == NULL) || (ie_len == 0)) 1026 break; 1027 } 1028 } 1029 1030 /* parsing HT_CAP_IE */ 1031 p = rtw_get_ie( 1032 ie + _BEACON_IE_OFFSET_, 1033 WLAN_EID_HT_CAPABILITY, 1034 &ie_len, 1035 (pbss_network->IELength - _BEACON_IE_OFFSET_) 1036 ); 1037 if (p && ie_len > 0) { 1038 u8 rf_type = 0; 1039 u8 max_rx_ampdu_factor = 0; 1040 struct ieee80211_ht_cap *pht_cap = (struct ieee80211_ht_cap *)(p + 2); 1041 1042 pHT_caps_ie = p; 1043 1044 ht_cap = true; 1045 network_type |= WIRELESS_11_24N; 1046 1047 rtw_ht_use_default_setting(padapter); 1048 1049 if (pmlmepriv->htpriv.sgi_20m == false) 1050 pht_cap->cap_info &= cpu_to_le16(~(IEEE80211_HT_CAP_SGI_20)); 1051 1052 if (pmlmepriv->htpriv.sgi_40m == false) 1053 pht_cap->cap_info &= cpu_to_le16(~(IEEE80211_HT_CAP_SGI_40)); 1054 1055 if (!TEST_FLAG(pmlmepriv->htpriv.ldpc_cap, LDPC_HT_ENABLE_RX)) 1056 pht_cap->cap_info &= cpu_to_le16(~(IEEE80211_HT_CAP_LDPC_CODING)); 1057 1058 if (!TEST_FLAG(pmlmepriv->htpriv.stbc_cap, STBC_HT_ENABLE_TX)) 1059 pht_cap->cap_info &= cpu_to_le16(~(IEEE80211_HT_CAP_TX_STBC)); 1060 1061 if (!TEST_FLAG(pmlmepriv->htpriv.stbc_cap, STBC_HT_ENABLE_RX)) 1062 pht_cap->cap_info &= cpu_to_le16(~(IEEE80211_HT_CAP_RX_STBC_3R)); 1063 1064 pht_cap->ampdu_params_info &= ~( 1065 IEEE80211_HT_CAP_AMPDU_FACTOR | IEEE80211_HT_CAP_AMPDU_DENSITY 1066 ); 1067 1068 if ((psecuritypriv->wpa_pairwise_cipher & WPA_CIPHER_CCMP) || 1069 (psecuritypriv->wpa2_pairwise_cipher & WPA_CIPHER_CCMP)) { 1070 pht_cap->ampdu_params_info |= (IEEE80211_HT_CAP_AMPDU_DENSITY & (0x07 << 2)); 1071 } else { 1072 pht_cap->ampdu_params_info |= (IEEE80211_HT_CAP_AMPDU_DENSITY & 0x00); 1073 } 1074 1075 rtw_hal_get_def_var( 1076 padapter, 1077 HW_VAR_MAX_RX_AMPDU_FACTOR, 1078 &max_rx_ampdu_factor 1079 ); 1080 pht_cap->ampdu_params_info |= ( 1081 IEEE80211_HT_CAP_AMPDU_FACTOR & max_rx_ampdu_factor 1082 ); /* set Max Rx AMPDU size to 64K */ 1083 1084 rtw_hal_get_hwreg(padapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type)); 1085 if (rf_type == RF_1T1R) { 1086 pht_cap->mcs.rx_mask[0] = 0xff; 1087 pht_cap->mcs.rx_mask[1] = 0x0; 1088 } 1089 1090 memcpy(&pmlmepriv->htpriv.ht_cap, p + 2, ie_len); 1091 } 1092 1093 /* parsing HT_INFO_IE */ 1094 p = rtw_get_ie( 1095 ie + _BEACON_IE_OFFSET_, 1096 WLAN_EID_HT_OPERATION, 1097 &ie_len, 1098 (pbss_network->IELength - _BEACON_IE_OFFSET_) 1099 ); 1100 if (p && ie_len > 0) 1101 pHT_info_ie = p; 1102 1103 switch (network_type) { 1104 case WIRELESS_11B: 1105 pbss_network->NetworkTypeInUse = Ndis802_11DS; 1106 break; 1107 case WIRELESS_11G: 1108 case WIRELESS_11BG: 1109 case WIRELESS_11G_24N: 1110 case WIRELESS_11BG_24N: 1111 pbss_network->NetworkTypeInUse = Ndis802_11OFDM24; 1112 break; 1113 default: 1114 pbss_network->NetworkTypeInUse = Ndis802_11OFDM24; 1115 break; 1116 } 1117 1118 pmlmepriv->cur_network.network_type = network_type; 1119 1120 pmlmepriv->htpriv.ht_option = false; 1121 1122 if ((psecuritypriv->wpa2_pairwise_cipher & WPA_CIPHER_TKIP) || 1123 (psecuritypriv->wpa_pairwise_cipher & WPA_CIPHER_TKIP)) { 1124 /* todo: */ 1125 /* ht_cap = false; */ 1126 } 1127 1128 /* ht_cap */ 1129 if (pregistrypriv->ht_enable && ht_cap) { 1130 pmlmepriv->htpriv.ht_option = true; 1131 pmlmepriv->qospriv.qos_option = 1; 1132 1133 if (pregistrypriv->ampdu_enable == 1) 1134 pmlmepriv->htpriv.ampdu_enable = true; 1135 1136 HT_caps_handler(padapter, (struct ndis_80211_var_ie *)pHT_caps_ie); 1137 1138 HT_info_handler(padapter, (struct ndis_80211_var_ie *)pHT_info_ie); 1139 } 1140 1141 pbss_network->Length = get_wlan_bssid_ex_sz( 1142 (struct wlan_bssid_ex *)pbss_network 1143 ); 1144 1145 /* issue beacon to start bss network */ 1146 /* start_bss_network(padapter, (u8 *)pbss_network); */ 1147 rtw_startbss_cmd(padapter, RTW_CMDF_WAIT_ACK); 1148 1149 /* alloc sta_info for ap itself */ 1150 psta = rtw_get_stainfo(&padapter->stapriv, pbss_network->MacAddress); 1151 if (!psta) { 1152 psta = rtw_alloc_stainfo(&padapter->stapriv, pbss_network->MacAddress); 1153 if (psta == NULL) 1154 return _FAIL; 1155 } 1156 1157 /* update AP's sta info */ 1158 update_ap_info(padapter, psta); 1159 1160 psta->state |= WIFI_AP_STATE; /* Aries, add, fix bug of flush_cam_entry at STOP AP mode , 0724 */ 1161 rtw_indicate_connect(padapter); 1162 1163 pmlmepriv->cur_network.join_res = true;/* for check if already set beacon */ 1164 1165 /* update bc/mc sta_info */ 1166 /* update_bmc_sta(padapter); */ 1167 1168 return ret; 1169 } 1170 1171 void rtw_set_macaddr_acl(struct adapter *padapter, int mode) 1172 { 1173 struct sta_priv *pstapriv = &padapter->stapriv; 1174 struct wlan_acl_pool *pacl_list = &pstapriv->acl_list; 1175 1176 pacl_list->mode = mode; 1177 } 1178 1179 int rtw_acl_add_sta(struct adapter *padapter, u8 *addr) 1180 { 1181 struct list_head *plist, *phead; 1182 u8 added = false; 1183 int i, ret = 0; 1184 struct rtw_wlan_acl_node *paclnode; 1185 struct sta_priv *pstapriv = &padapter->stapriv; 1186 struct wlan_acl_pool *pacl_list = &pstapriv->acl_list; 1187 struct __queue *pacl_node_q = &pacl_list->acl_node_q; 1188 1189 if ((NUM_ACL - 1) < pacl_list->num) 1190 return (-1); 1191 1192 spin_lock_bh(&(pacl_node_q->lock)); 1193 1194 phead = get_list_head(pacl_node_q); 1195 list_for_each(plist, phead) { 1196 paclnode = list_entry(plist, struct rtw_wlan_acl_node, list); 1197 1198 if (!memcmp(paclnode->addr, addr, ETH_ALEN)) { 1199 if (paclnode->valid == true) { 1200 added = true; 1201 break; 1202 } 1203 } 1204 } 1205 1206 spin_unlock_bh(&(pacl_node_q->lock)); 1207 1208 if (added) 1209 return ret; 1210 1211 spin_lock_bh(&(pacl_node_q->lock)); 1212 1213 for (i = 0; i < NUM_ACL; i++) { 1214 paclnode = &pacl_list->aclnode[i]; 1215 1216 if (!paclnode->valid) { 1217 INIT_LIST_HEAD(&paclnode->list); 1218 1219 memcpy(paclnode->addr, addr, ETH_ALEN); 1220 1221 paclnode->valid = true; 1222 1223 list_add_tail(&paclnode->list, get_list_head(pacl_node_q)); 1224 1225 pacl_list->num++; 1226 1227 break; 1228 } 1229 } 1230 1231 spin_unlock_bh(&(pacl_node_q->lock)); 1232 1233 return ret; 1234 } 1235 1236 void rtw_acl_remove_sta(struct adapter *padapter, u8 *addr) 1237 { 1238 struct list_head *plist, *phead, *tmp; 1239 struct rtw_wlan_acl_node *paclnode; 1240 struct sta_priv *pstapriv = &padapter->stapriv; 1241 struct wlan_acl_pool *pacl_list = &pstapriv->acl_list; 1242 struct __queue *pacl_node_q = &pacl_list->acl_node_q; 1243 u8 baddr[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; /* Baddr is used for clearing acl_list */ 1244 1245 spin_lock_bh(&(pacl_node_q->lock)); 1246 1247 phead = get_list_head(pacl_node_q); 1248 list_for_each_safe(plist, tmp, phead) { 1249 paclnode = list_entry(plist, struct rtw_wlan_acl_node, list); 1250 1251 if ( 1252 !memcmp(paclnode->addr, addr, ETH_ALEN) || 1253 !memcmp(baddr, addr, ETH_ALEN) 1254 ) { 1255 if (paclnode->valid) { 1256 paclnode->valid = false; 1257 1258 list_del_init(&paclnode->list); 1259 1260 pacl_list->num--; 1261 } 1262 } 1263 } 1264 1265 spin_unlock_bh(&(pacl_node_q->lock)); 1266 1267 } 1268 1269 u8 rtw_ap_set_pairwise_key(struct adapter *padapter, struct sta_info *psta) 1270 { 1271 struct cmd_obj *ph2c; 1272 struct set_stakey_parm *psetstakey_para; 1273 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1274 u8 res = _SUCCESS; 1275 1276 ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 1277 if (!ph2c) { 1278 res = _FAIL; 1279 goto exit; 1280 } 1281 1282 psetstakey_para = rtw_zmalloc(sizeof(struct set_stakey_parm)); 1283 if (psetstakey_para == NULL) { 1284 kfree(ph2c); 1285 res = _FAIL; 1286 goto exit; 1287 } 1288 1289 init_h2fwcmd_w_parm_no_rsp(ph2c, psetstakey_para, _SetStaKey_CMD_); 1290 1291 psetstakey_para->algorithm = (u8)psta->dot118021XPrivacy; 1292 1293 memcpy(psetstakey_para->addr, psta->hwaddr, ETH_ALEN); 1294 1295 memcpy(psetstakey_para->key, &psta->dot118021x_UncstKey, 16); 1296 1297 res = rtw_enqueue_cmd(pcmdpriv, ph2c); 1298 1299 exit: 1300 1301 return res; 1302 } 1303 1304 static int rtw_ap_set_key( 1305 struct adapter *padapter, 1306 u8 *key, 1307 u8 alg, 1308 int keyid, 1309 u8 set_tx 1310 ) 1311 { 1312 u8 keylen; 1313 struct cmd_obj *pcmd; 1314 struct setkey_parm *psetkeyparm; 1315 struct cmd_priv *pcmdpriv = &(padapter->cmdpriv); 1316 int res = _SUCCESS; 1317 1318 pcmd = rtw_zmalloc(sizeof(struct cmd_obj)); 1319 if (pcmd == NULL) { 1320 res = _FAIL; 1321 goto exit; 1322 } 1323 psetkeyparm = rtw_zmalloc(sizeof(struct setkey_parm)); 1324 if (psetkeyparm == NULL) { 1325 kfree(pcmd); 1326 res = _FAIL; 1327 goto exit; 1328 } 1329 1330 psetkeyparm->keyid = (u8)keyid; 1331 if (is_wep_enc(alg)) 1332 padapter->securitypriv.key_mask |= BIT(psetkeyparm->keyid); 1333 1334 psetkeyparm->algorithm = alg; 1335 1336 psetkeyparm->set_tx = set_tx; 1337 1338 switch (alg) { 1339 case _WEP40_: 1340 keylen = 5; 1341 break; 1342 case _WEP104_: 1343 keylen = 13; 1344 break; 1345 case _TKIP_: 1346 case _TKIP_WTMIC_: 1347 case _AES_: 1348 default: 1349 keylen = 16; 1350 } 1351 1352 memcpy(&(psetkeyparm->key[0]), key, keylen); 1353 1354 pcmd->cmdcode = _SetKey_CMD_; 1355 pcmd->parmbuf = (u8 *)psetkeyparm; 1356 pcmd->cmdsz = (sizeof(struct setkey_parm)); 1357 pcmd->rsp = NULL; 1358 pcmd->rspsz = 0; 1359 1360 INIT_LIST_HEAD(&pcmd->list); 1361 1362 res = rtw_enqueue_cmd(pcmdpriv, pcmd); 1363 1364 exit: 1365 1366 return res; 1367 } 1368 1369 int rtw_ap_set_group_key(struct adapter *padapter, u8 *key, u8 alg, int keyid) 1370 { 1371 return rtw_ap_set_key(padapter, key, alg, keyid, 1); 1372 } 1373 1374 int rtw_ap_set_wep_key( 1375 struct adapter *padapter, 1376 u8 *key, 1377 u8 keylen, 1378 int keyid, 1379 u8 set_tx 1380 ) 1381 { 1382 u8 alg; 1383 1384 switch (keylen) { 1385 case 5: 1386 alg = _WEP40_; 1387 break; 1388 case 13: 1389 alg = _WEP104_; 1390 break; 1391 default: 1392 alg = _NO_PRIVACY_; 1393 } 1394 1395 return rtw_ap_set_key(padapter, key, alg, keyid, set_tx); 1396 } 1397 1398 static void update_bcn_fixed_ie(struct adapter *padapter) 1399 { 1400 } 1401 1402 static void update_bcn_erpinfo_ie(struct adapter *padapter) 1403 { 1404 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1405 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv); 1406 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 1407 struct wlan_bssid_ex *pnetwork = &(pmlmeinfo->network); 1408 unsigned char *p, *ie = pnetwork->IEs; 1409 u32 len = 0; 1410 1411 if (!pmlmeinfo->ERP_enable) 1412 return; 1413 1414 /* parsing ERP_IE */ 1415 p = rtw_get_ie( 1416 ie + _BEACON_IE_OFFSET_, 1417 WLAN_EID_ERP_INFO, 1418 &len, 1419 (pnetwork->IELength - _BEACON_IE_OFFSET_) 1420 ); 1421 if (p && len > 0) { 1422 struct ndis_80211_var_ie *pIE = (struct ndis_80211_var_ie *)p; 1423 1424 if (pmlmepriv->num_sta_non_erp == 1) 1425 pIE->data[0] |= RTW_ERP_INFO_NON_ERP_PRESENT | RTW_ERP_INFO_USE_PROTECTION; 1426 else 1427 pIE->data[0] &= ~( 1428 RTW_ERP_INFO_NON_ERP_PRESENT | RTW_ERP_INFO_USE_PROTECTION 1429 ); 1430 1431 if (pmlmepriv->num_sta_no_short_preamble > 0) 1432 pIE->data[0] |= RTW_ERP_INFO_BARKER_PREAMBLE_MODE; 1433 else 1434 pIE->data[0] &= ~(RTW_ERP_INFO_BARKER_PREAMBLE_MODE); 1435 1436 ERP_IE_handler(padapter, pIE); 1437 } 1438 } 1439 1440 static void update_bcn_htcap_ie(struct adapter *padapter) 1441 { 1442 } 1443 1444 static void update_bcn_htinfo_ie(struct adapter *padapter) 1445 { 1446 } 1447 1448 static void update_bcn_rsn_ie(struct adapter *padapter) 1449 { 1450 } 1451 1452 static void update_bcn_wpa_ie(struct adapter *padapter) 1453 { 1454 } 1455 1456 static void update_bcn_wmm_ie(struct adapter *padapter) 1457 { 1458 } 1459 1460 static void update_bcn_wps_ie(struct adapter *padapter) 1461 { 1462 u8 *pwps_ie = NULL; 1463 u8 *pwps_ie_src; 1464 u8 *premainder_ie; 1465 u8 *pbackup_remainder_ie = NULL; 1466 1467 uint wps_ielen = 0, wps_offset, remainder_ielen; 1468 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1469 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv); 1470 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 1471 struct wlan_bssid_ex *pnetwork = &(pmlmeinfo->network); 1472 unsigned char *ie = pnetwork->IEs; 1473 u32 ielen = pnetwork->IELength; 1474 1475 pwps_ie = rtw_get_wps_ie( 1476 ie + _FIXED_IE_LENGTH_, 1477 ielen - _FIXED_IE_LENGTH_, 1478 NULL, 1479 &wps_ielen 1480 ); 1481 1482 if (pwps_ie == NULL || wps_ielen == 0) 1483 return; 1484 1485 pwps_ie_src = pmlmepriv->wps_beacon_ie; 1486 if (pwps_ie_src == NULL) 1487 return; 1488 1489 wps_offset = (uint)(pwps_ie - ie); 1490 1491 premainder_ie = pwps_ie + wps_ielen; 1492 1493 remainder_ielen = ielen - wps_offset - wps_ielen; 1494 1495 if (remainder_ielen > 0) { 1496 pbackup_remainder_ie = rtw_malloc(remainder_ielen); 1497 if (pbackup_remainder_ie) 1498 memcpy(pbackup_remainder_ie, premainder_ie, remainder_ielen); 1499 } 1500 1501 wps_ielen = (uint)pwps_ie_src[1];/* to get ie data len */ 1502 if ((wps_offset + wps_ielen + 2 + remainder_ielen) <= MAX_IE_SZ) { 1503 memcpy(pwps_ie, pwps_ie_src, wps_ielen + 2); 1504 pwps_ie += (wps_ielen+2); 1505 1506 if (pbackup_remainder_ie) 1507 memcpy(pwps_ie, pbackup_remainder_ie, remainder_ielen); 1508 1509 /* update IELength */ 1510 pnetwork->IELength = wps_offset + (wps_ielen + 2) + remainder_ielen; 1511 } 1512 1513 kfree(pbackup_remainder_ie); 1514 } 1515 1516 static void update_bcn_p2p_ie(struct adapter *padapter) 1517 { 1518 } 1519 1520 static void update_bcn_vendor_spec_ie(struct adapter *padapter, u8 *oui) 1521 { 1522 if (!memcmp(RTW_WPA_OUI, oui, 4)) 1523 update_bcn_wpa_ie(padapter); 1524 1525 else if (!memcmp(WMM_OUI, oui, 4)) 1526 update_bcn_wmm_ie(padapter); 1527 1528 else if (!memcmp(WPS_OUI, oui, 4)) 1529 update_bcn_wps_ie(padapter); 1530 1531 else if (!memcmp(P2P_OUI, oui, 4)) 1532 update_bcn_p2p_ie(padapter); 1533 } 1534 1535 void update_beacon(struct adapter *padapter, u8 ie_id, u8 *oui, u8 tx) 1536 { 1537 struct mlme_priv *pmlmepriv; 1538 struct mlme_ext_priv *pmlmeext; 1539 /* struct mlme_ext_info *pmlmeinfo; */ 1540 1541 if (!padapter) 1542 return; 1543 1544 pmlmepriv = &(padapter->mlmepriv); 1545 pmlmeext = &(padapter->mlmeextpriv); 1546 /* pmlmeinfo = &(pmlmeext->mlmext_info); */ 1547 1548 if (!pmlmeext->bstart_bss) 1549 return; 1550 1551 spin_lock_bh(&pmlmepriv->bcn_update_lock); 1552 1553 switch (ie_id) { 1554 case 0xFF: 1555 1556 update_bcn_fixed_ie(padapter);/* 8: TimeStamp, 2: Beacon Interval 2:Capability */ 1557 1558 break; 1559 1560 case WLAN_EID_TIM: 1561 1562 update_BCNTIM(padapter); 1563 1564 break; 1565 1566 case WLAN_EID_ERP_INFO: 1567 1568 update_bcn_erpinfo_ie(padapter); 1569 1570 break; 1571 1572 case WLAN_EID_HT_CAPABILITY: 1573 1574 update_bcn_htcap_ie(padapter); 1575 1576 break; 1577 1578 case WLAN_EID_RSN: 1579 1580 update_bcn_rsn_ie(padapter); 1581 1582 break; 1583 1584 case WLAN_EID_HT_OPERATION: 1585 1586 update_bcn_htinfo_ie(padapter); 1587 1588 break; 1589 1590 case WLAN_EID_VENDOR_SPECIFIC: 1591 1592 update_bcn_vendor_spec_ie(padapter, oui); 1593 1594 break; 1595 1596 default: 1597 break; 1598 } 1599 1600 pmlmepriv->update_bcn = true; 1601 1602 spin_unlock_bh(&pmlmepriv->bcn_update_lock); 1603 1604 if (tx) { 1605 /* send_beacon(padapter);//send_beacon must execute on TSR level */ 1606 set_tx_beacon_cmd(padapter); 1607 } 1608 } 1609 1610 /* 1611 * op_mode 1612 * Set to 0 (HT pure) under the following conditions 1613 * - all STAs in the BSS are 20/40 MHz HT in 20/40 MHz BSS or 1614 * - all STAs in the BSS are 20 MHz HT in 20 MHz BSS 1615 * Set to 1 (HT non-member protection) if there may be non-HT STAs 1616 * in both the primary and the secondary channel 1617 * Set to 2 if only HT STAs are associated in BSS, 1618 * however and at least one 20 MHz HT STA is associated 1619 * Set to 3 (HT mixed mode) when one or more non-HT STAs are associated 1620 * (currently non-GF HT station is considered as non-HT STA also) 1621 */ 1622 static int rtw_ht_operation_update(struct adapter *padapter) 1623 { 1624 u16 cur_op_mode, new_op_mode; 1625 int op_mode_changes = 0; 1626 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1627 struct ht_priv *phtpriv_ap = &pmlmepriv->htpriv; 1628 1629 if (pmlmepriv->htpriv.ht_option) 1630 return 0; 1631 1632 if (!(pmlmepriv->ht_op_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT) 1633 && pmlmepriv->num_sta_ht_no_gf) { 1634 pmlmepriv->ht_op_mode |= 1635 IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT; 1636 op_mode_changes++; 1637 } else if ((pmlmepriv->ht_op_mode & 1638 IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT) && 1639 pmlmepriv->num_sta_ht_no_gf == 0) { 1640 pmlmepriv->ht_op_mode &= 1641 ~IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT; 1642 op_mode_changes++; 1643 } 1644 1645 if (!(pmlmepriv->ht_op_mode & IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT) && 1646 (pmlmepriv->num_sta_no_ht || pmlmepriv->olbc_ht)) { 1647 pmlmepriv->ht_op_mode |= IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT; 1648 op_mode_changes++; 1649 } else if ((pmlmepriv->ht_op_mode & 1650 IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT) && 1651 (pmlmepriv->num_sta_no_ht == 0 && !pmlmepriv->olbc_ht)) { 1652 pmlmepriv->ht_op_mode &= 1653 ~IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT; 1654 op_mode_changes++; 1655 } 1656 1657 /* Note: currently we switch to the MIXED op mode if HT non-greenfield 1658 * station is associated. Probably it's a theoretical case, since 1659 * it looks like all known HT STAs support greenfield. 1660 */ 1661 new_op_mode = 0; 1662 if (pmlmepriv->num_sta_no_ht || 1663 (pmlmepriv->ht_op_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT)) 1664 new_op_mode = IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED; 1665 else if ( 1666 (le16_to_cpu(phtpriv_ap->ht_cap.cap_info) & IEEE80211_HT_CAP_SUP_WIDTH) 1667 && pmlmepriv->num_sta_ht_20mhz) 1668 new_op_mode = IEEE80211_HT_OP_MODE_PROTECTION_20MHZ; 1669 else if (pmlmepriv->olbc_ht) 1670 new_op_mode = IEEE80211_HT_OP_MODE_PROTECTION_NONMEMBER; 1671 else 1672 new_op_mode = IEEE80211_HT_OP_MODE_PROTECTION_NONE; 1673 1674 cur_op_mode = pmlmepriv->ht_op_mode & IEEE80211_HT_OP_MODE_PROTECTION; 1675 if (cur_op_mode != new_op_mode) { 1676 pmlmepriv->ht_op_mode &= ~IEEE80211_HT_OP_MODE_PROTECTION; 1677 pmlmepriv->ht_op_mode |= new_op_mode; 1678 op_mode_changes++; 1679 } 1680 1681 return op_mode_changes; 1682 } 1683 1684 void associated_clients_update(struct adapter *padapter, u8 updated) 1685 { 1686 /* update associated stations cap. */ 1687 if (updated) { 1688 struct list_head *phead, *plist; 1689 struct sta_info *psta = NULL; 1690 struct sta_priv *pstapriv = &padapter->stapriv; 1691 1692 spin_lock_bh(&pstapriv->asoc_list_lock); 1693 1694 phead = &pstapriv->asoc_list; 1695 /* check asoc_queue */ 1696 list_for_each(plist, phead) { 1697 psta = list_entry(plist, struct sta_info, asoc_list); 1698 1699 VCS_update(padapter, psta); 1700 } 1701 1702 spin_unlock_bh(&pstapriv->asoc_list_lock); 1703 } 1704 } 1705 1706 /* called > TSR LEVEL for USB or SDIO Interface*/ 1707 void bss_cap_update_on_sta_join(struct adapter *padapter, struct sta_info *psta) 1708 { 1709 u8 beacon_updated = false; 1710 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1711 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv); 1712 1713 if (!(psta->flags & WLAN_STA_SHORT_PREAMBLE)) { 1714 if (!psta->no_short_preamble_set) { 1715 psta->no_short_preamble_set = 1; 1716 1717 pmlmepriv->num_sta_no_short_preamble++; 1718 1719 if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) && 1720 (pmlmepriv->num_sta_no_short_preamble == 1)) { 1721 beacon_updated = true; 1722 update_beacon(padapter, 0xFF, NULL, true); 1723 } 1724 } 1725 } else { 1726 if (psta->no_short_preamble_set) { 1727 psta->no_short_preamble_set = 0; 1728 1729 pmlmepriv->num_sta_no_short_preamble--; 1730 1731 if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) && 1732 (pmlmepriv->num_sta_no_short_preamble == 0)) { 1733 beacon_updated = true; 1734 update_beacon(padapter, 0xFF, NULL, true); 1735 } 1736 } 1737 } 1738 1739 if (psta->flags & WLAN_STA_NONERP) { 1740 if (!psta->nonerp_set) { 1741 psta->nonerp_set = 1; 1742 1743 pmlmepriv->num_sta_non_erp++; 1744 1745 if (pmlmepriv->num_sta_non_erp == 1) { 1746 beacon_updated = true; 1747 update_beacon(padapter, WLAN_EID_ERP_INFO, NULL, true); 1748 } 1749 } 1750 } else { 1751 if (psta->nonerp_set) { 1752 psta->nonerp_set = 0; 1753 1754 pmlmepriv->num_sta_non_erp--; 1755 1756 if (pmlmepriv->num_sta_non_erp == 0) { 1757 beacon_updated = true; 1758 update_beacon(padapter, WLAN_EID_ERP_INFO, NULL, true); 1759 } 1760 } 1761 } 1762 1763 if (!(psta->capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)) { 1764 if (!psta->no_short_slot_time_set) { 1765 psta->no_short_slot_time_set = 1; 1766 1767 pmlmepriv->num_sta_no_short_slot_time++; 1768 1769 if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) && 1770 (pmlmepriv->num_sta_no_short_slot_time == 1)) { 1771 beacon_updated = true; 1772 update_beacon(padapter, 0xFF, NULL, true); 1773 } 1774 } 1775 } else { 1776 if (psta->no_short_slot_time_set) { 1777 psta->no_short_slot_time_set = 0; 1778 1779 pmlmepriv->num_sta_no_short_slot_time--; 1780 1781 if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) && 1782 (pmlmepriv->num_sta_no_short_slot_time == 0)) { 1783 beacon_updated = true; 1784 update_beacon(padapter, 0xFF, NULL, true); 1785 } 1786 } 1787 } 1788 1789 if (psta->flags & WLAN_STA_HT) { 1790 u16 ht_capab = le16_to_cpu(psta->htpriv.ht_cap.cap_info); 1791 1792 if (psta->no_ht_set) { 1793 psta->no_ht_set = 0; 1794 pmlmepriv->num_sta_no_ht--; 1795 } 1796 1797 if ((ht_capab & IEEE80211_HT_CAP_GRN_FLD) == 0) { 1798 if (!psta->no_ht_gf_set) { 1799 psta->no_ht_gf_set = 1; 1800 pmlmepriv->num_sta_ht_no_gf++; 1801 } 1802 } 1803 1804 if ((ht_capab & IEEE80211_HT_CAP_SUP_WIDTH) == 0) { 1805 if (!psta->ht_20mhz_set) { 1806 psta->ht_20mhz_set = 1; 1807 pmlmepriv->num_sta_ht_20mhz++; 1808 } 1809 } 1810 1811 } else { 1812 if (!psta->no_ht_set) { 1813 psta->no_ht_set = 1; 1814 pmlmepriv->num_sta_no_ht++; 1815 } 1816 } 1817 1818 if (rtw_ht_operation_update(padapter) > 0) { 1819 update_beacon(padapter, WLAN_EID_HT_CAPABILITY, NULL, false); 1820 update_beacon(padapter, WLAN_EID_HT_OPERATION, NULL, true); 1821 } 1822 1823 /* update associated stations cap. */ 1824 associated_clients_update(padapter, beacon_updated); 1825 } 1826 1827 u8 bss_cap_update_on_sta_leave(struct adapter *padapter, struct sta_info *psta) 1828 { 1829 u8 beacon_updated = false; 1830 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1831 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv); 1832 1833 if (!psta) 1834 return beacon_updated; 1835 1836 if (psta->no_short_preamble_set) { 1837 psta->no_short_preamble_set = 0; 1838 pmlmepriv->num_sta_no_short_preamble--; 1839 if (pmlmeext->cur_wireless_mode > WIRELESS_11B 1840 && pmlmepriv->num_sta_no_short_preamble == 0){ 1841 beacon_updated = true; 1842 update_beacon(padapter, 0xFF, NULL, true); 1843 } 1844 } 1845 1846 if (psta->nonerp_set) { 1847 psta->nonerp_set = 0; 1848 pmlmepriv->num_sta_non_erp--; 1849 if (pmlmepriv->num_sta_non_erp == 0) { 1850 beacon_updated = true; 1851 update_beacon(padapter, WLAN_EID_ERP_INFO, NULL, true); 1852 } 1853 } 1854 1855 if (psta->no_short_slot_time_set) { 1856 psta->no_short_slot_time_set = 0; 1857 pmlmepriv->num_sta_no_short_slot_time--; 1858 if (pmlmeext->cur_wireless_mode > WIRELESS_11B 1859 && pmlmepriv->num_sta_no_short_slot_time == 0){ 1860 beacon_updated = true; 1861 update_beacon(padapter, 0xFF, NULL, true); 1862 } 1863 } 1864 1865 if (psta->no_ht_gf_set) { 1866 psta->no_ht_gf_set = 0; 1867 pmlmepriv->num_sta_ht_no_gf--; 1868 } 1869 1870 if (psta->no_ht_set) { 1871 psta->no_ht_set = 0; 1872 pmlmepriv->num_sta_no_ht--; 1873 } 1874 1875 if (psta->ht_20mhz_set) { 1876 psta->ht_20mhz_set = 0; 1877 pmlmepriv->num_sta_ht_20mhz--; 1878 } 1879 1880 if (rtw_ht_operation_update(padapter) > 0) { 1881 update_beacon(padapter, WLAN_EID_HT_CAPABILITY, NULL, false); 1882 update_beacon(padapter, WLAN_EID_HT_OPERATION, NULL, true); 1883 } 1884 1885 return beacon_updated; 1886 } 1887 1888 u8 ap_free_sta( 1889 struct adapter *padapter, 1890 struct sta_info *psta, 1891 bool active, 1892 u16 reason 1893 ) 1894 { 1895 u8 beacon_updated = false; 1896 1897 if (!psta) 1898 return beacon_updated; 1899 1900 if (active) { 1901 /* tear down Rx AMPDU */ 1902 send_delba(padapter, 0, psta->hwaddr);/* recipient */ 1903 1904 /* tear down TX AMPDU */ 1905 send_delba(padapter, 1, psta->hwaddr);/* // originator */ 1906 1907 issue_deauth(padapter, psta->hwaddr, reason); 1908 } 1909 1910 psta->htpriv.agg_enable_bitmap = 0x0;/* reset */ 1911 psta->htpriv.candidate_tid_bitmap = 0x0;/* reset */ 1912 1913 /* report_del_sta_event(padapter, psta->hwaddr, reason); */ 1914 1915 /* clear cam entry / key */ 1916 rtw_clearstakey_cmd(padapter, psta, true); 1917 1918 spin_lock_bh(&psta->lock); 1919 psta->state &= ~_FW_LINKED; 1920 spin_unlock_bh(&psta->lock); 1921 1922 rtw_cfg80211_indicate_sta_disassoc(padapter, psta->hwaddr, reason); 1923 1924 report_del_sta_event(padapter, psta->hwaddr, reason); 1925 1926 beacon_updated = bss_cap_update_on_sta_leave(padapter, psta); 1927 1928 rtw_free_stainfo(padapter, psta); 1929 1930 return beacon_updated; 1931 } 1932 1933 void rtw_sta_flush(struct adapter *padapter) 1934 { 1935 struct list_head *phead, *plist, *tmp; 1936 struct sta_info *psta = NULL; 1937 struct sta_priv *pstapriv = &padapter->stapriv; 1938 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 1939 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 1940 u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; 1941 1942 if ((pmlmeinfo->state & 0x03) != WIFI_FW_AP_STATE) 1943 return; 1944 1945 spin_lock_bh(&pstapriv->asoc_list_lock); 1946 phead = &pstapriv->asoc_list; 1947 /* free sta asoc_queue */ 1948 list_for_each_safe(plist, tmp, phead) { 1949 psta = list_entry(plist, struct sta_info, asoc_list); 1950 1951 list_del_init(&psta->asoc_list); 1952 pstapriv->asoc_list_cnt--; 1953 1954 /* spin_unlock_bh(&pstapriv->asoc_list_lock); */ 1955 ap_free_sta(padapter, psta, true, WLAN_REASON_DEAUTH_LEAVING); 1956 /* spin_lock_bh(&pstapriv->asoc_list_lock); */ 1957 } 1958 spin_unlock_bh(&pstapriv->asoc_list_lock); 1959 1960 issue_deauth(padapter, bc_addr, WLAN_REASON_DEAUTH_LEAVING); 1961 1962 associated_clients_update(padapter, true); 1963 } 1964 1965 /* called > TSR LEVEL for USB or SDIO Interface*/ 1966 void sta_info_update(struct adapter *padapter, struct sta_info *psta) 1967 { 1968 int flags = psta->flags; 1969 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1970 1971 /* update wmm cap. */ 1972 if (WLAN_STA_WME & flags) 1973 psta->qos_option = 1; 1974 else 1975 psta->qos_option = 0; 1976 1977 if (pmlmepriv->qospriv.qos_option == 0) 1978 psta->qos_option = 0; 1979 1980 /* update 802.11n ht cap. */ 1981 if (WLAN_STA_HT & flags) { 1982 psta->htpriv.ht_option = true; 1983 psta->qos_option = 1; 1984 } else { 1985 psta->htpriv.ht_option = false; 1986 } 1987 1988 if (!pmlmepriv->htpriv.ht_option) 1989 psta->htpriv.ht_option = false; 1990 1991 update_sta_info_apmode(padapter, psta); 1992 } 1993 1994 /* called >= TSR LEVEL for USB or SDIO Interface*/ 1995 void ap_sta_info_defer_update(struct adapter *padapter, struct sta_info *psta) 1996 { 1997 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 1998 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 1999 2000 if (psta->state & _FW_LINKED) { 2001 pmlmeinfo->FW_sta_info[psta->mac_id].psta = psta; 2002 2003 /* add ratid */ 2004 add_RATid(padapter, psta, 0);/* DM_RATR_STA_INIT */ 2005 } 2006 } 2007 /* restore hw setting from sw data structures */ 2008 void rtw_ap_restore_network(struct adapter *padapter) 2009 { 2010 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 2011 struct sta_priv *pstapriv = &padapter->stapriv; 2012 struct sta_info *psta; 2013 struct security_priv *psecuritypriv = &(padapter->securitypriv); 2014 struct list_head *phead, *plist; 2015 u8 chk_alive_num = 0; 2016 char chk_alive_list[NUM_STA]; 2017 int i; 2018 2019 rtw_setopmode_cmd(padapter, Ndis802_11APMode, false); 2020 2021 set_channel_bwmode( 2022 padapter, 2023 pmlmeext->cur_channel, 2024 pmlmeext->cur_ch_offset, 2025 pmlmeext->cur_bwmode 2026 ); 2027 2028 start_bss_network(padapter); 2029 2030 if ((padapter->securitypriv.dot11PrivacyAlgrthm == _TKIP_) || 2031 (padapter->securitypriv.dot11PrivacyAlgrthm == _AES_)) { 2032 /* restore group key, WEP keys is restored in ips_leave() */ 2033 rtw_set_key( 2034 padapter, 2035 psecuritypriv, 2036 psecuritypriv->dot118021XGrpKeyid, 2037 0, 2038 false 2039 ); 2040 } 2041 2042 spin_lock_bh(&pstapriv->asoc_list_lock); 2043 2044 phead = &pstapriv->asoc_list; 2045 list_for_each(plist, phead) { 2046 int stainfo_offset; 2047 2048 psta = list_entry(plist, struct sta_info, asoc_list); 2049 2050 stainfo_offset = rtw_stainfo_offset(pstapriv, psta); 2051 if (stainfo_offset_valid(stainfo_offset)) 2052 chk_alive_list[chk_alive_num++] = stainfo_offset; 2053 } 2054 2055 spin_unlock_bh(&pstapriv->asoc_list_lock); 2056 2057 for (i = 0; i < chk_alive_num; i++) { 2058 psta = rtw_get_stainfo_by_offset(pstapriv, chk_alive_list[i]); 2059 2060 if (!psta) 2061 continue; 2062 2063 if (psta->state & _FW_LINKED) { 2064 rtw_sta_media_status_rpt(padapter, psta, 1); 2065 Update_RA_Entry(padapter, psta); 2066 /* pairwise key */ 2067 /* per sta pairwise key and settings */ 2068 if ((psecuritypriv->dot11PrivacyAlgrthm == _TKIP_) || 2069 (psecuritypriv->dot11PrivacyAlgrthm == _AES_)) { 2070 rtw_setstakey_cmd(padapter, psta, true, false); 2071 } 2072 } 2073 } 2074 } 2075 2076 void start_ap_mode(struct adapter *padapter) 2077 { 2078 int i; 2079 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 2080 struct sta_priv *pstapriv = &padapter->stapriv; 2081 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 2082 struct wlan_acl_pool *pacl_list = &pstapriv->acl_list; 2083 2084 pmlmepriv->update_bcn = false; 2085 2086 /* init_mlme_ap_info(padapter); */ 2087 pmlmeext->bstart_bss = false; 2088 2089 pmlmepriv->num_sta_non_erp = 0; 2090 2091 pmlmepriv->num_sta_no_short_slot_time = 0; 2092 2093 pmlmepriv->num_sta_no_short_preamble = 0; 2094 2095 pmlmepriv->num_sta_ht_no_gf = 0; 2096 pmlmepriv->num_sta_no_ht = 0; 2097 pmlmepriv->num_sta_ht_20mhz = 0; 2098 2099 pmlmepriv->olbc = false; 2100 2101 pmlmepriv->olbc_ht = false; 2102 2103 pmlmepriv->ht_op_mode = 0; 2104 2105 for (i = 0; i < NUM_STA; i++) 2106 pstapriv->sta_aid[i] = NULL; 2107 2108 pmlmepriv->wps_beacon_ie = NULL; 2109 pmlmepriv->wps_probe_resp_ie = NULL; 2110 pmlmepriv->wps_assoc_resp_ie = NULL; 2111 2112 pmlmepriv->p2p_beacon_ie = NULL; 2113 pmlmepriv->p2p_probe_resp_ie = NULL; 2114 2115 /* for ACL */ 2116 INIT_LIST_HEAD(&(pacl_list->acl_node_q.queue)); 2117 pacl_list->num = 0; 2118 pacl_list->mode = 0; 2119 for (i = 0; i < NUM_ACL; i++) { 2120 INIT_LIST_HEAD(&pacl_list->aclnode[i].list); 2121 pacl_list->aclnode[i].valid = false; 2122 } 2123 } 2124 2125 void stop_ap_mode(struct adapter *padapter) 2126 { 2127 struct list_head *phead, *plist, *tmp; 2128 struct rtw_wlan_acl_node *paclnode; 2129 struct sta_info *psta = NULL; 2130 struct sta_priv *pstapriv = &padapter->stapriv; 2131 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 2132 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 2133 struct wlan_acl_pool *pacl_list = &pstapriv->acl_list; 2134 struct __queue *pacl_node_q = &pacl_list->acl_node_q; 2135 2136 pmlmepriv->update_bcn = false; 2137 pmlmeext->bstart_bss = false; 2138 2139 /* reset and init security priv , this can refine with rtw_reset_securitypriv */ 2140 memset( 2141 (unsigned char *)&padapter->securitypriv, 2142 0, 2143 sizeof(struct security_priv) 2144 ); 2145 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeOpen; 2146 padapter->securitypriv.ndisencryptstatus = Ndis802_11WEPDisabled; 2147 2148 /* for ACL */ 2149 spin_lock_bh(&(pacl_node_q->lock)); 2150 phead = get_list_head(pacl_node_q); 2151 list_for_each_safe(plist, tmp, phead) { 2152 paclnode = list_entry(plist, struct rtw_wlan_acl_node, list); 2153 2154 if (paclnode->valid) { 2155 paclnode->valid = false; 2156 2157 list_del_init(&paclnode->list); 2158 2159 pacl_list->num--; 2160 } 2161 } 2162 spin_unlock_bh(&(pacl_node_q->lock)); 2163 2164 rtw_sta_flush(padapter); 2165 2166 /* free_assoc_sta_resources */ 2167 rtw_free_all_stainfo(padapter); 2168 2169 psta = rtw_get_bcmc_stainfo(padapter); 2170 rtw_free_stainfo(padapter, psta); 2171 2172 rtw_init_bcmc_stainfo(padapter); 2173 2174 rtw_free_mlme_priv_ie_data(pmlmepriv); 2175 2176 rtw_btcoex_MediaStatusNotify(padapter, 0); /* disconnect */ 2177 } 2178