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 <rtw_debug.h> 10 #include <asm/unaligned.h> 11 12 void init_mlme_ap_info(struct adapter *padapter) 13 { 14 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 15 struct sta_priv *pstapriv = &padapter->stapriv; 16 struct wlan_acl_pool *pacl_list = &pstapriv->acl_list; 17 18 spin_lock_init(&pmlmepriv->bcn_update_lock); 19 20 /* for ACL */ 21 INIT_LIST_HEAD(&pacl_list->acl_node_q.queue); 22 spin_lock_init(&pacl_list->acl_node_q.lock); 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->ie_length - _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->ie_length - 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->ie_length - _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->ie_length - _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->ie_length - 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->ie_length = 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.ds_config > 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->supported_rates); 401 network_type = rtw_check_network_type((u8 *)&pcur_network->supported_rates, 402 supportRateNum, 403 pcur_network->configuration.ds_config 404 ); 405 if (is_supported_tx_cck(network_type)) { 406 network_type = WIRELESS_11B; 407 } else if (network_type == WIRELESS_INVALID) { /* error handling */ 408 409 if (pcur_network->configuration.ds_config > 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->supported_rates); 576 memcpy(psta->bssrateset, pnetwork->supported_rates, 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.beacon_period; 660 cur_channel = pnetwork->configuration.ds_config; 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->ie_length - _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->mac_address); 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->ie_length - 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->supported_rates); 790 rtw_hal_set_hwreg(padapter, HW_VAR_BASIC_RATE, pnetwork->supported_rates); 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->ie_length = len; 839 840 memset(ie, 0, MAX_IE_SZ); 841 842 memcpy(ie, pbuf, pbss_network->ie_length); 843 844 if (pbss_network->infrastructure_mode != Ndis802_11APMode) 845 return _FAIL; 846 847 pbss_network->rssi = 0; 848 849 memcpy(pbss_network->mac_address, 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.beacon_period = le16_to_cpu(*(unsigned short*)p); */ 854 pbss_network->configuration.beacon_period = 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->ie_length - _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.ssid_length = 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->ie_length - _BEACON_IE_OFFSET_) 881 ); 882 if (p && ie_len > 0) 883 channel = *(p + 2); 884 885 pbss_network->configuration.ds_config = 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->ie_length - _BEACON_IE_OFFSET_) 894 ); 895 if (p) { 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->ie_length - _BEACON_IE_OFFSET_ 906 ); 907 if (p) { 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->supported_rates, 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->ie_length - _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->ie_length - _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->ie_length - _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 || 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->ie_length - _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 || 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->ie_length - _BEACON_IE_OFFSET_) 1036 ); 1037 if (p && ie_len > 0) { 1038 u8 max_rx_ampdu_factor = 0; 1039 struct ieee80211_ht_cap *pht_cap = (struct ieee80211_ht_cap *)(p + 2); 1040 1041 pHT_caps_ie = p; 1042 1043 ht_cap = true; 1044 network_type |= WIRELESS_11_24N; 1045 1046 rtw_ht_use_default_setting(padapter); 1047 1048 if (pmlmepriv->htpriv.sgi_20m == false) 1049 pht_cap->cap_info &= cpu_to_le16(~(IEEE80211_HT_CAP_SGI_20)); 1050 1051 if (pmlmepriv->htpriv.sgi_40m == false) 1052 pht_cap->cap_info &= cpu_to_le16(~(IEEE80211_HT_CAP_SGI_40)); 1053 1054 if (!TEST_FLAG(pmlmepriv->htpriv.ldpc_cap, LDPC_HT_ENABLE_RX)) 1055 pht_cap->cap_info &= cpu_to_le16(~(IEEE80211_HT_CAP_LDPC_CODING)); 1056 1057 if (!TEST_FLAG(pmlmepriv->htpriv.stbc_cap, STBC_HT_ENABLE_TX)) 1058 pht_cap->cap_info &= cpu_to_le16(~(IEEE80211_HT_CAP_TX_STBC)); 1059 1060 if (!TEST_FLAG(pmlmepriv->htpriv.stbc_cap, STBC_HT_ENABLE_RX)) 1061 pht_cap->cap_info &= cpu_to_le16(~(IEEE80211_HT_CAP_RX_STBC_3R)); 1062 1063 pht_cap->ampdu_params_info &= ~( 1064 IEEE80211_HT_CAP_AMPDU_FACTOR | IEEE80211_HT_CAP_AMPDU_DENSITY 1065 ); 1066 1067 if ((psecuritypriv->wpa_pairwise_cipher & WPA_CIPHER_CCMP) || 1068 (psecuritypriv->wpa2_pairwise_cipher & WPA_CIPHER_CCMP)) { 1069 pht_cap->ampdu_params_info |= (IEEE80211_HT_CAP_AMPDU_DENSITY & (0x07 << 2)); 1070 } else { 1071 pht_cap->ampdu_params_info |= (IEEE80211_HT_CAP_AMPDU_DENSITY & 0x00); 1072 } 1073 1074 rtw_hal_get_def_var( 1075 padapter, 1076 HW_VAR_MAX_RX_AMPDU_FACTOR, 1077 &max_rx_ampdu_factor 1078 ); 1079 pht_cap->ampdu_params_info |= ( 1080 IEEE80211_HT_CAP_AMPDU_FACTOR & max_rx_ampdu_factor 1081 ); /* set Max Rx AMPDU size to 64K */ 1082 1083 pht_cap->mcs.rx_mask[0] = 0xff; 1084 pht_cap->mcs.rx_mask[1] = 0x0; 1085 1086 memcpy(&pmlmepriv->htpriv.ht_cap, p + 2, ie_len); 1087 } 1088 1089 /* parsing HT_INFO_IE */ 1090 p = rtw_get_ie( 1091 ie + _BEACON_IE_OFFSET_, 1092 WLAN_EID_HT_OPERATION, 1093 &ie_len, 1094 (pbss_network->ie_length - _BEACON_IE_OFFSET_) 1095 ); 1096 if (p && ie_len > 0) 1097 pHT_info_ie = p; 1098 1099 switch (network_type) { 1100 case WIRELESS_11B: 1101 pbss_network->network_type_in_use = Ndis802_11DS; 1102 break; 1103 case WIRELESS_11G: 1104 case WIRELESS_11BG: 1105 case WIRELESS_11G_24N: 1106 case WIRELESS_11BG_24N: 1107 pbss_network->network_type_in_use = Ndis802_11OFDM24; 1108 break; 1109 default: 1110 pbss_network->network_type_in_use = Ndis802_11OFDM24; 1111 break; 1112 } 1113 1114 pmlmepriv->cur_network.network_type = network_type; 1115 1116 pmlmepriv->htpriv.ht_option = false; 1117 1118 if ((psecuritypriv->wpa2_pairwise_cipher & WPA_CIPHER_TKIP) || 1119 (psecuritypriv->wpa_pairwise_cipher & WPA_CIPHER_TKIP)) { 1120 /* todo: */ 1121 /* ht_cap = false; */ 1122 } 1123 1124 /* ht_cap */ 1125 if (pregistrypriv->ht_enable && ht_cap) { 1126 pmlmepriv->htpriv.ht_option = true; 1127 pmlmepriv->qospriv.qos_option = 1; 1128 1129 if (pregistrypriv->ampdu_enable == 1) 1130 pmlmepriv->htpriv.ampdu_enable = true; 1131 1132 HT_caps_handler(padapter, (struct ndis_80211_var_ie *)pHT_caps_ie); 1133 1134 HT_info_handler(padapter, (struct ndis_80211_var_ie *)pHT_info_ie); 1135 } 1136 1137 pbss_network->length = get_wlan_bssid_ex_sz( 1138 (struct wlan_bssid_ex *)pbss_network 1139 ); 1140 1141 /* issue beacon to start bss network */ 1142 /* start_bss_network(padapter, (u8 *)pbss_network); */ 1143 rtw_startbss_cmd(padapter, RTW_CMDF_WAIT_ACK); 1144 1145 /* alloc sta_info for ap itself */ 1146 psta = rtw_get_stainfo(&padapter->stapriv, pbss_network->mac_address); 1147 if (!psta) { 1148 psta = rtw_alloc_stainfo(&padapter->stapriv, pbss_network->mac_address); 1149 if (!psta) 1150 return _FAIL; 1151 } 1152 1153 /* update AP's sta info */ 1154 update_ap_info(padapter, psta); 1155 1156 psta->state |= WIFI_AP_STATE; /* Aries, add, fix bug of flush_cam_entry at STOP AP mode , 0724 */ 1157 rtw_indicate_connect(padapter); 1158 1159 pmlmepriv->cur_network.join_res = true;/* for check if already set beacon */ 1160 1161 /* update bc/mc sta_info */ 1162 /* update_bmc_sta(padapter); */ 1163 1164 return ret; 1165 } 1166 1167 void rtw_set_macaddr_acl(struct adapter *padapter, int mode) 1168 { 1169 struct sta_priv *pstapriv = &padapter->stapriv; 1170 struct wlan_acl_pool *pacl_list = &pstapriv->acl_list; 1171 1172 pacl_list->mode = mode; 1173 } 1174 1175 int rtw_acl_add_sta(struct adapter *padapter, u8 *addr) 1176 { 1177 struct list_head *plist, *phead; 1178 u8 added = false; 1179 int i, ret = 0; 1180 struct rtw_wlan_acl_node *paclnode; 1181 struct sta_priv *pstapriv = &padapter->stapriv; 1182 struct wlan_acl_pool *pacl_list = &pstapriv->acl_list; 1183 struct __queue *pacl_node_q = &pacl_list->acl_node_q; 1184 1185 if ((NUM_ACL - 1) < pacl_list->num) 1186 return (-1); 1187 1188 spin_lock_bh(&(pacl_node_q->lock)); 1189 1190 phead = get_list_head(pacl_node_q); 1191 list_for_each(plist, phead) { 1192 paclnode = list_entry(plist, struct rtw_wlan_acl_node, list); 1193 1194 if (!memcmp(paclnode->addr, addr, ETH_ALEN)) { 1195 if (paclnode->valid == true) { 1196 added = true; 1197 break; 1198 } 1199 } 1200 } 1201 1202 spin_unlock_bh(&(pacl_node_q->lock)); 1203 1204 if (added) 1205 return ret; 1206 1207 spin_lock_bh(&(pacl_node_q->lock)); 1208 1209 for (i = 0; i < NUM_ACL; i++) { 1210 paclnode = &pacl_list->aclnode[i]; 1211 1212 if (!paclnode->valid) { 1213 INIT_LIST_HEAD(&paclnode->list); 1214 1215 memcpy(paclnode->addr, addr, ETH_ALEN); 1216 1217 paclnode->valid = true; 1218 1219 list_add_tail(&paclnode->list, get_list_head(pacl_node_q)); 1220 1221 pacl_list->num++; 1222 1223 break; 1224 } 1225 } 1226 1227 spin_unlock_bh(&(pacl_node_q->lock)); 1228 1229 return ret; 1230 } 1231 1232 void rtw_acl_remove_sta(struct adapter *padapter, u8 *addr) 1233 { 1234 struct list_head *plist, *phead, *tmp; 1235 struct rtw_wlan_acl_node *paclnode; 1236 struct sta_priv *pstapriv = &padapter->stapriv; 1237 struct wlan_acl_pool *pacl_list = &pstapriv->acl_list; 1238 struct __queue *pacl_node_q = &pacl_list->acl_node_q; 1239 u8 baddr[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; /* Baddr is used for clearing acl_list */ 1240 1241 spin_lock_bh(&(pacl_node_q->lock)); 1242 1243 phead = get_list_head(pacl_node_q); 1244 list_for_each_safe(plist, tmp, phead) { 1245 paclnode = list_entry(plist, struct rtw_wlan_acl_node, list); 1246 1247 if ( 1248 !memcmp(paclnode->addr, addr, ETH_ALEN) || 1249 !memcmp(baddr, addr, ETH_ALEN) 1250 ) { 1251 if (paclnode->valid) { 1252 paclnode->valid = false; 1253 1254 list_del_init(&paclnode->list); 1255 1256 pacl_list->num--; 1257 } 1258 } 1259 } 1260 1261 spin_unlock_bh(&(pacl_node_q->lock)); 1262 1263 } 1264 1265 u8 rtw_ap_set_pairwise_key(struct adapter *padapter, struct sta_info *psta) 1266 { 1267 struct cmd_obj *ph2c; 1268 struct set_stakey_parm *psetstakey_para; 1269 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1270 u8 res = _SUCCESS; 1271 1272 ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 1273 if (!ph2c) { 1274 res = _FAIL; 1275 goto exit; 1276 } 1277 1278 psetstakey_para = rtw_zmalloc(sizeof(struct set_stakey_parm)); 1279 if (!psetstakey_para) { 1280 kfree(ph2c); 1281 res = _FAIL; 1282 goto exit; 1283 } 1284 1285 init_h2fwcmd_w_parm_no_rsp(ph2c, psetstakey_para, _SetStaKey_CMD_); 1286 1287 psetstakey_para->algorithm = (u8)psta->dot118021XPrivacy; 1288 1289 memcpy(psetstakey_para->addr, psta->hwaddr, ETH_ALEN); 1290 1291 memcpy(psetstakey_para->key, &psta->dot118021x_UncstKey, 16); 1292 1293 res = rtw_enqueue_cmd(pcmdpriv, ph2c); 1294 1295 exit: 1296 1297 return res; 1298 } 1299 1300 static int rtw_ap_set_key( 1301 struct adapter *padapter, 1302 u8 *key, 1303 u8 alg, 1304 int keyid, 1305 u8 set_tx 1306 ) 1307 { 1308 u8 keylen; 1309 struct cmd_obj *pcmd; 1310 struct setkey_parm *psetkeyparm; 1311 struct cmd_priv *pcmdpriv = &(padapter->cmdpriv); 1312 int res = _SUCCESS; 1313 1314 pcmd = rtw_zmalloc(sizeof(struct cmd_obj)); 1315 if (!pcmd) { 1316 res = _FAIL; 1317 goto exit; 1318 } 1319 psetkeyparm = rtw_zmalloc(sizeof(struct setkey_parm)); 1320 if (!psetkeyparm) { 1321 kfree(pcmd); 1322 res = _FAIL; 1323 goto exit; 1324 } 1325 1326 psetkeyparm->keyid = (u8)keyid; 1327 if (is_wep_enc(alg)) 1328 padapter->securitypriv.key_mask |= BIT(psetkeyparm->keyid); 1329 1330 psetkeyparm->algorithm = alg; 1331 1332 psetkeyparm->set_tx = set_tx; 1333 1334 switch (alg) { 1335 case _WEP40_: 1336 keylen = 5; 1337 break; 1338 case _WEP104_: 1339 keylen = 13; 1340 break; 1341 case _TKIP_: 1342 case _TKIP_WTMIC_: 1343 case _AES_: 1344 default: 1345 keylen = 16; 1346 } 1347 1348 memcpy(&(psetkeyparm->key[0]), key, keylen); 1349 1350 pcmd->cmdcode = _SetKey_CMD_; 1351 pcmd->parmbuf = (u8 *)psetkeyparm; 1352 pcmd->cmdsz = (sizeof(struct setkey_parm)); 1353 pcmd->rsp = NULL; 1354 pcmd->rspsz = 0; 1355 1356 INIT_LIST_HEAD(&pcmd->list); 1357 1358 res = rtw_enqueue_cmd(pcmdpriv, pcmd); 1359 1360 exit: 1361 1362 return res; 1363 } 1364 1365 int rtw_ap_set_group_key(struct adapter *padapter, u8 *key, u8 alg, int keyid) 1366 { 1367 return rtw_ap_set_key(padapter, key, alg, keyid, 1); 1368 } 1369 1370 int rtw_ap_set_wep_key( 1371 struct adapter *padapter, 1372 u8 *key, 1373 u8 keylen, 1374 int keyid, 1375 u8 set_tx 1376 ) 1377 { 1378 u8 alg; 1379 1380 switch (keylen) { 1381 case 5: 1382 alg = _WEP40_; 1383 break; 1384 case 13: 1385 alg = _WEP104_; 1386 break; 1387 default: 1388 alg = _NO_PRIVACY_; 1389 } 1390 1391 return rtw_ap_set_key(padapter, key, alg, keyid, set_tx); 1392 } 1393 1394 static void update_bcn_fixed_ie(struct adapter *padapter) 1395 { 1396 } 1397 1398 static void update_bcn_erpinfo_ie(struct adapter *padapter) 1399 { 1400 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1401 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv); 1402 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 1403 struct wlan_bssid_ex *pnetwork = &(pmlmeinfo->network); 1404 unsigned char *p, *ie = pnetwork->ies; 1405 u32 len = 0; 1406 1407 if (!pmlmeinfo->ERP_enable) 1408 return; 1409 1410 /* parsing ERP_IE */ 1411 p = rtw_get_ie( 1412 ie + _BEACON_IE_OFFSET_, 1413 WLAN_EID_ERP_INFO, 1414 &len, 1415 (pnetwork->ie_length - _BEACON_IE_OFFSET_) 1416 ); 1417 if (p && len > 0) { 1418 struct ndis_80211_var_ie *pIE = (struct ndis_80211_var_ie *)p; 1419 1420 if (pmlmepriv->num_sta_non_erp == 1) 1421 pIE->data[0] |= RTW_ERP_INFO_NON_ERP_PRESENT | RTW_ERP_INFO_USE_PROTECTION; 1422 else 1423 pIE->data[0] &= ~( 1424 RTW_ERP_INFO_NON_ERP_PRESENT | RTW_ERP_INFO_USE_PROTECTION 1425 ); 1426 1427 if (pmlmepriv->num_sta_no_short_preamble > 0) 1428 pIE->data[0] |= RTW_ERP_INFO_BARKER_PREAMBLE_MODE; 1429 else 1430 pIE->data[0] &= ~(RTW_ERP_INFO_BARKER_PREAMBLE_MODE); 1431 1432 ERP_IE_handler(padapter, pIE); 1433 } 1434 } 1435 1436 static void update_bcn_htcap_ie(struct adapter *padapter) 1437 { 1438 } 1439 1440 static void update_bcn_htinfo_ie(struct adapter *padapter) 1441 { 1442 } 1443 1444 static void update_bcn_rsn_ie(struct adapter *padapter) 1445 { 1446 } 1447 1448 static void update_bcn_wpa_ie(struct adapter *padapter) 1449 { 1450 } 1451 1452 static void update_bcn_wmm_ie(struct adapter *padapter) 1453 { 1454 } 1455 1456 static void update_bcn_wps_ie(struct adapter *padapter) 1457 { 1458 u8 *pwps_ie = NULL; 1459 u8 *pwps_ie_src; 1460 u8 *premainder_ie; 1461 u8 *pbackup_remainder_ie = NULL; 1462 1463 uint wps_ielen = 0, wps_offset, remainder_ielen; 1464 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1465 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv); 1466 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 1467 struct wlan_bssid_ex *pnetwork = &(pmlmeinfo->network); 1468 unsigned char *ie = pnetwork->ies; 1469 u32 ielen = pnetwork->ie_length; 1470 1471 pwps_ie = rtw_get_wps_ie( 1472 ie + _FIXED_IE_LENGTH_, 1473 ielen - _FIXED_IE_LENGTH_, 1474 NULL, 1475 &wps_ielen 1476 ); 1477 1478 if (!pwps_ie || wps_ielen == 0) 1479 return; 1480 1481 pwps_ie_src = pmlmepriv->wps_beacon_ie; 1482 if (!pwps_ie_src) 1483 return; 1484 1485 wps_offset = (uint)(pwps_ie - ie); 1486 1487 premainder_ie = pwps_ie + wps_ielen; 1488 1489 remainder_ielen = ielen - wps_offset - wps_ielen; 1490 1491 if (remainder_ielen > 0) { 1492 pbackup_remainder_ie = rtw_malloc(remainder_ielen); 1493 if (pbackup_remainder_ie) 1494 memcpy(pbackup_remainder_ie, premainder_ie, remainder_ielen); 1495 } 1496 1497 wps_ielen = (uint)pwps_ie_src[1];/* to get ie data len */ 1498 if ((wps_offset + wps_ielen + 2 + remainder_ielen) <= MAX_IE_SZ) { 1499 memcpy(pwps_ie, pwps_ie_src, wps_ielen + 2); 1500 pwps_ie += (wps_ielen+2); 1501 1502 if (pbackup_remainder_ie) 1503 memcpy(pwps_ie, pbackup_remainder_ie, remainder_ielen); 1504 1505 /* update ie_length */ 1506 pnetwork->ie_length = wps_offset + (wps_ielen + 2) + remainder_ielen; 1507 } 1508 1509 kfree(pbackup_remainder_ie); 1510 } 1511 1512 static void update_bcn_p2p_ie(struct adapter *padapter) 1513 { 1514 } 1515 1516 static void update_bcn_vendor_spec_ie(struct adapter *padapter, u8 *oui) 1517 { 1518 if (!memcmp(RTW_WPA_OUI, oui, 4)) 1519 update_bcn_wpa_ie(padapter); 1520 1521 else if (!memcmp(WMM_OUI, oui, 4)) 1522 update_bcn_wmm_ie(padapter); 1523 1524 else if (!memcmp(WPS_OUI, oui, 4)) 1525 update_bcn_wps_ie(padapter); 1526 1527 else if (!memcmp(P2P_OUI, oui, 4)) 1528 update_bcn_p2p_ie(padapter); 1529 } 1530 1531 void update_beacon(struct adapter *padapter, u8 ie_id, u8 *oui, u8 tx) 1532 { 1533 struct mlme_priv *pmlmepriv; 1534 struct mlme_ext_priv *pmlmeext; 1535 /* struct mlme_ext_info *pmlmeinfo; */ 1536 1537 if (!padapter) 1538 return; 1539 1540 pmlmepriv = &(padapter->mlmepriv); 1541 pmlmeext = &(padapter->mlmeextpriv); 1542 /* pmlmeinfo = &(pmlmeext->mlmext_info); */ 1543 1544 if (!pmlmeext->bstart_bss) 1545 return; 1546 1547 spin_lock_bh(&pmlmepriv->bcn_update_lock); 1548 1549 switch (ie_id) { 1550 case 0xFF: 1551 1552 update_bcn_fixed_ie(padapter);/* 8: TimeStamp, 2: Beacon Interval 2:Capability */ 1553 1554 break; 1555 1556 case WLAN_EID_TIM: 1557 1558 update_BCNTIM(padapter); 1559 1560 break; 1561 1562 case WLAN_EID_ERP_INFO: 1563 1564 update_bcn_erpinfo_ie(padapter); 1565 1566 break; 1567 1568 case WLAN_EID_HT_CAPABILITY: 1569 1570 update_bcn_htcap_ie(padapter); 1571 1572 break; 1573 1574 case WLAN_EID_RSN: 1575 1576 update_bcn_rsn_ie(padapter); 1577 1578 break; 1579 1580 case WLAN_EID_HT_OPERATION: 1581 1582 update_bcn_htinfo_ie(padapter); 1583 1584 break; 1585 1586 case WLAN_EID_VENDOR_SPECIFIC: 1587 1588 update_bcn_vendor_spec_ie(padapter, oui); 1589 1590 break; 1591 1592 default: 1593 break; 1594 } 1595 1596 pmlmepriv->update_bcn = true; 1597 1598 spin_unlock_bh(&pmlmepriv->bcn_update_lock); 1599 1600 if (tx) { 1601 /* send_beacon(padapter);//send_beacon must execute on TSR level */ 1602 set_tx_beacon_cmd(padapter); 1603 } 1604 } 1605 1606 /* 1607 * op_mode 1608 * Set to 0 (HT pure) under the following conditions 1609 * - all STAs in the BSS are 20/40 MHz HT in 20/40 MHz BSS or 1610 * - all STAs in the BSS are 20 MHz HT in 20 MHz BSS 1611 * Set to 1 (HT non-member protection) if there may be non-HT STAs 1612 * in both the primary and the secondary channel 1613 * Set to 2 if only HT STAs are associated in BSS, 1614 * however and at least one 20 MHz HT STA is associated 1615 * Set to 3 (HT mixed mode) when one or more non-HT STAs are associated 1616 * (currently non-GF HT station is considered as non-HT STA also) 1617 */ 1618 static int rtw_ht_operation_update(struct adapter *padapter) 1619 { 1620 u16 cur_op_mode, new_op_mode; 1621 int op_mode_changes = 0; 1622 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1623 struct ht_priv *phtpriv_ap = &pmlmepriv->htpriv; 1624 1625 if (pmlmepriv->htpriv.ht_option) 1626 return 0; 1627 1628 if (!(pmlmepriv->ht_op_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT) 1629 && pmlmepriv->num_sta_ht_no_gf) { 1630 pmlmepriv->ht_op_mode |= 1631 IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT; 1632 op_mode_changes++; 1633 } else if ((pmlmepriv->ht_op_mode & 1634 IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT) && 1635 pmlmepriv->num_sta_ht_no_gf == 0) { 1636 pmlmepriv->ht_op_mode &= 1637 ~IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT; 1638 op_mode_changes++; 1639 } 1640 1641 if (!(pmlmepriv->ht_op_mode & IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT) && 1642 (pmlmepriv->num_sta_no_ht || pmlmepriv->olbc_ht)) { 1643 pmlmepriv->ht_op_mode |= IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT; 1644 op_mode_changes++; 1645 } else if ((pmlmepriv->ht_op_mode & 1646 IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT) && 1647 (pmlmepriv->num_sta_no_ht == 0 && !pmlmepriv->olbc_ht)) { 1648 pmlmepriv->ht_op_mode &= 1649 ~IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT; 1650 op_mode_changes++; 1651 } 1652 1653 /* Note: currently we switch to the MIXED op mode if HT non-greenfield 1654 * station is associated. Probably it's a theoretical case, since 1655 * it looks like all known HT STAs support greenfield. 1656 */ 1657 new_op_mode = 0; 1658 if (pmlmepriv->num_sta_no_ht || 1659 (pmlmepriv->ht_op_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT)) 1660 new_op_mode = IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED; 1661 else if ( 1662 (le16_to_cpu(phtpriv_ap->ht_cap.cap_info) & IEEE80211_HT_CAP_SUP_WIDTH) 1663 && pmlmepriv->num_sta_ht_20mhz) 1664 new_op_mode = IEEE80211_HT_OP_MODE_PROTECTION_20MHZ; 1665 else if (pmlmepriv->olbc_ht) 1666 new_op_mode = IEEE80211_HT_OP_MODE_PROTECTION_NONMEMBER; 1667 else 1668 new_op_mode = IEEE80211_HT_OP_MODE_PROTECTION_NONE; 1669 1670 cur_op_mode = pmlmepriv->ht_op_mode & IEEE80211_HT_OP_MODE_PROTECTION; 1671 if (cur_op_mode != new_op_mode) { 1672 pmlmepriv->ht_op_mode &= ~IEEE80211_HT_OP_MODE_PROTECTION; 1673 pmlmepriv->ht_op_mode |= new_op_mode; 1674 op_mode_changes++; 1675 } 1676 1677 return op_mode_changes; 1678 } 1679 1680 void associated_clients_update(struct adapter *padapter, u8 updated) 1681 { 1682 /* update associated stations cap. */ 1683 if (updated) { 1684 struct list_head *phead, *plist; 1685 struct sta_info *psta = NULL; 1686 struct sta_priv *pstapriv = &padapter->stapriv; 1687 1688 spin_lock_bh(&pstapriv->asoc_list_lock); 1689 1690 phead = &pstapriv->asoc_list; 1691 /* check asoc_queue */ 1692 list_for_each(plist, phead) { 1693 psta = list_entry(plist, struct sta_info, asoc_list); 1694 1695 VCS_update(padapter, psta); 1696 } 1697 1698 spin_unlock_bh(&pstapriv->asoc_list_lock); 1699 } 1700 } 1701 1702 /* called > TSR LEVEL for USB or SDIO Interface*/ 1703 void bss_cap_update_on_sta_join(struct adapter *padapter, struct sta_info *psta) 1704 { 1705 u8 beacon_updated = false; 1706 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1707 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv); 1708 1709 if (!(psta->flags & WLAN_STA_SHORT_PREAMBLE)) { 1710 if (!psta->no_short_preamble_set) { 1711 psta->no_short_preamble_set = 1; 1712 1713 pmlmepriv->num_sta_no_short_preamble++; 1714 1715 if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) && 1716 (pmlmepriv->num_sta_no_short_preamble == 1)) { 1717 beacon_updated = true; 1718 update_beacon(padapter, 0xFF, NULL, true); 1719 } 1720 } 1721 } else { 1722 if (psta->no_short_preamble_set) { 1723 psta->no_short_preamble_set = 0; 1724 1725 pmlmepriv->num_sta_no_short_preamble--; 1726 1727 if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) && 1728 (pmlmepriv->num_sta_no_short_preamble == 0)) { 1729 beacon_updated = true; 1730 update_beacon(padapter, 0xFF, NULL, true); 1731 } 1732 } 1733 } 1734 1735 if (psta->flags & WLAN_STA_NONERP) { 1736 if (!psta->nonerp_set) { 1737 psta->nonerp_set = 1; 1738 1739 pmlmepriv->num_sta_non_erp++; 1740 1741 if (pmlmepriv->num_sta_non_erp == 1) { 1742 beacon_updated = true; 1743 update_beacon(padapter, WLAN_EID_ERP_INFO, NULL, true); 1744 } 1745 } 1746 } else { 1747 if (psta->nonerp_set) { 1748 psta->nonerp_set = 0; 1749 1750 pmlmepriv->num_sta_non_erp--; 1751 1752 if (pmlmepriv->num_sta_non_erp == 0) { 1753 beacon_updated = true; 1754 update_beacon(padapter, WLAN_EID_ERP_INFO, NULL, true); 1755 } 1756 } 1757 } 1758 1759 if (!(psta->capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)) { 1760 if (!psta->no_short_slot_time_set) { 1761 psta->no_short_slot_time_set = 1; 1762 1763 pmlmepriv->num_sta_no_short_slot_time++; 1764 1765 if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) && 1766 (pmlmepriv->num_sta_no_short_slot_time == 1)) { 1767 beacon_updated = true; 1768 update_beacon(padapter, 0xFF, NULL, true); 1769 } 1770 } 1771 } else { 1772 if (psta->no_short_slot_time_set) { 1773 psta->no_short_slot_time_set = 0; 1774 1775 pmlmepriv->num_sta_no_short_slot_time--; 1776 1777 if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) && 1778 (pmlmepriv->num_sta_no_short_slot_time == 0)) { 1779 beacon_updated = true; 1780 update_beacon(padapter, 0xFF, NULL, true); 1781 } 1782 } 1783 } 1784 1785 if (psta->flags & WLAN_STA_HT) { 1786 u16 ht_capab = le16_to_cpu(psta->htpriv.ht_cap.cap_info); 1787 1788 if (psta->no_ht_set) { 1789 psta->no_ht_set = 0; 1790 pmlmepriv->num_sta_no_ht--; 1791 } 1792 1793 if ((ht_capab & IEEE80211_HT_CAP_GRN_FLD) == 0) { 1794 if (!psta->no_ht_gf_set) { 1795 psta->no_ht_gf_set = 1; 1796 pmlmepriv->num_sta_ht_no_gf++; 1797 } 1798 } 1799 1800 if ((ht_capab & IEEE80211_HT_CAP_SUP_WIDTH) == 0) { 1801 if (!psta->ht_20mhz_set) { 1802 psta->ht_20mhz_set = 1; 1803 pmlmepriv->num_sta_ht_20mhz++; 1804 } 1805 } 1806 1807 } else { 1808 if (!psta->no_ht_set) { 1809 psta->no_ht_set = 1; 1810 pmlmepriv->num_sta_no_ht++; 1811 } 1812 } 1813 1814 if (rtw_ht_operation_update(padapter) > 0) { 1815 update_beacon(padapter, WLAN_EID_HT_CAPABILITY, NULL, false); 1816 update_beacon(padapter, WLAN_EID_HT_OPERATION, NULL, true); 1817 } 1818 1819 /* update associated stations cap. */ 1820 associated_clients_update(padapter, beacon_updated); 1821 } 1822 1823 u8 bss_cap_update_on_sta_leave(struct adapter *padapter, struct sta_info *psta) 1824 { 1825 u8 beacon_updated = false; 1826 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1827 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv); 1828 1829 if (!psta) 1830 return beacon_updated; 1831 1832 if (psta->no_short_preamble_set) { 1833 psta->no_short_preamble_set = 0; 1834 pmlmepriv->num_sta_no_short_preamble--; 1835 if (pmlmeext->cur_wireless_mode > WIRELESS_11B 1836 && pmlmepriv->num_sta_no_short_preamble == 0){ 1837 beacon_updated = true; 1838 update_beacon(padapter, 0xFF, NULL, true); 1839 } 1840 } 1841 1842 if (psta->nonerp_set) { 1843 psta->nonerp_set = 0; 1844 pmlmepriv->num_sta_non_erp--; 1845 if (pmlmepriv->num_sta_non_erp == 0) { 1846 beacon_updated = true; 1847 update_beacon(padapter, WLAN_EID_ERP_INFO, NULL, true); 1848 } 1849 } 1850 1851 if (psta->no_short_slot_time_set) { 1852 psta->no_short_slot_time_set = 0; 1853 pmlmepriv->num_sta_no_short_slot_time--; 1854 if (pmlmeext->cur_wireless_mode > WIRELESS_11B 1855 && pmlmepriv->num_sta_no_short_slot_time == 0){ 1856 beacon_updated = true; 1857 update_beacon(padapter, 0xFF, NULL, true); 1858 } 1859 } 1860 1861 if (psta->no_ht_gf_set) { 1862 psta->no_ht_gf_set = 0; 1863 pmlmepriv->num_sta_ht_no_gf--; 1864 } 1865 1866 if (psta->no_ht_set) { 1867 psta->no_ht_set = 0; 1868 pmlmepriv->num_sta_no_ht--; 1869 } 1870 1871 if (psta->ht_20mhz_set) { 1872 psta->ht_20mhz_set = 0; 1873 pmlmepriv->num_sta_ht_20mhz--; 1874 } 1875 1876 if (rtw_ht_operation_update(padapter) > 0) { 1877 update_beacon(padapter, WLAN_EID_HT_CAPABILITY, NULL, false); 1878 update_beacon(padapter, WLAN_EID_HT_OPERATION, NULL, true); 1879 } 1880 1881 return beacon_updated; 1882 } 1883 1884 u8 ap_free_sta( 1885 struct adapter *padapter, 1886 struct sta_info *psta, 1887 bool active, 1888 u16 reason 1889 ) 1890 { 1891 u8 beacon_updated = false; 1892 1893 if (!psta) 1894 return beacon_updated; 1895 1896 if (active) { 1897 /* tear down Rx AMPDU */ 1898 send_delba(padapter, 0, psta->hwaddr);/* recipient */ 1899 1900 /* tear down TX AMPDU */ 1901 send_delba(padapter, 1, psta->hwaddr);/* // originator */ 1902 1903 issue_deauth(padapter, psta->hwaddr, reason); 1904 } 1905 1906 psta->htpriv.agg_enable_bitmap = 0x0;/* reset */ 1907 psta->htpriv.candidate_tid_bitmap = 0x0;/* reset */ 1908 1909 /* report_del_sta_event(padapter, psta->hwaddr, reason); */ 1910 1911 /* clear cam entry / key */ 1912 rtw_clearstakey_cmd(padapter, psta, true); 1913 1914 spin_lock_bh(&psta->lock); 1915 psta->state &= ~_FW_LINKED; 1916 spin_unlock_bh(&psta->lock); 1917 1918 rtw_cfg80211_indicate_sta_disassoc(padapter, psta->hwaddr, reason); 1919 1920 report_del_sta_event(padapter, psta->hwaddr, reason); 1921 1922 beacon_updated = bss_cap_update_on_sta_leave(padapter, psta); 1923 1924 rtw_free_stainfo(padapter, psta); 1925 1926 return beacon_updated; 1927 } 1928 1929 void rtw_sta_flush(struct adapter *padapter) 1930 { 1931 struct list_head *phead, *plist, *tmp; 1932 struct sta_info *psta = NULL; 1933 struct sta_priv *pstapriv = &padapter->stapriv; 1934 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 1935 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 1936 u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; 1937 1938 if ((pmlmeinfo->state & 0x03) != WIFI_FW_AP_STATE) 1939 return; 1940 1941 spin_lock_bh(&pstapriv->asoc_list_lock); 1942 phead = &pstapriv->asoc_list; 1943 /* free sta asoc_queue */ 1944 list_for_each_safe(plist, tmp, phead) { 1945 psta = list_entry(plist, struct sta_info, asoc_list); 1946 1947 list_del_init(&psta->asoc_list); 1948 pstapriv->asoc_list_cnt--; 1949 1950 /* spin_unlock_bh(&pstapriv->asoc_list_lock); */ 1951 ap_free_sta(padapter, psta, true, WLAN_REASON_DEAUTH_LEAVING); 1952 /* spin_lock_bh(&pstapriv->asoc_list_lock); */ 1953 } 1954 spin_unlock_bh(&pstapriv->asoc_list_lock); 1955 1956 issue_deauth(padapter, bc_addr, WLAN_REASON_DEAUTH_LEAVING); 1957 1958 associated_clients_update(padapter, true); 1959 } 1960 1961 /* called > TSR LEVEL for USB or SDIO Interface*/ 1962 void sta_info_update(struct adapter *padapter, struct sta_info *psta) 1963 { 1964 int flags = psta->flags; 1965 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1966 1967 /* update wmm cap. */ 1968 if (WLAN_STA_WME & flags) 1969 psta->qos_option = 1; 1970 else 1971 psta->qos_option = 0; 1972 1973 if (pmlmepriv->qospriv.qos_option == 0) 1974 psta->qos_option = 0; 1975 1976 /* update 802.11n ht cap. */ 1977 if (WLAN_STA_HT & flags) { 1978 psta->htpriv.ht_option = true; 1979 psta->qos_option = 1; 1980 } else { 1981 psta->htpriv.ht_option = false; 1982 } 1983 1984 if (!pmlmepriv->htpriv.ht_option) 1985 psta->htpriv.ht_option = false; 1986 1987 update_sta_info_apmode(padapter, psta); 1988 } 1989 1990 /* called >= TSR LEVEL for USB or SDIO Interface*/ 1991 void ap_sta_info_defer_update(struct adapter *padapter, struct sta_info *psta) 1992 { 1993 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 1994 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 1995 1996 if (psta->state & _FW_LINKED) { 1997 pmlmeinfo->FW_sta_info[psta->mac_id].psta = psta; 1998 1999 /* add ratid */ 2000 add_RATid(padapter, psta, 0);/* DM_RATR_STA_INIT */ 2001 } 2002 } 2003 /* restore hw setting from sw data structures */ 2004 void rtw_ap_restore_network(struct adapter *padapter) 2005 { 2006 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 2007 struct sta_priv *pstapriv = &padapter->stapriv; 2008 struct sta_info *psta; 2009 struct security_priv *psecuritypriv = &(padapter->securitypriv); 2010 struct list_head *phead, *plist; 2011 u8 chk_alive_num = 0; 2012 char chk_alive_list[NUM_STA]; 2013 int i; 2014 2015 rtw_setopmode_cmd(padapter, Ndis802_11APMode, false); 2016 2017 set_channel_bwmode( 2018 padapter, 2019 pmlmeext->cur_channel, 2020 pmlmeext->cur_ch_offset, 2021 pmlmeext->cur_bwmode 2022 ); 2023 2024 start_bss_network(padapter); 2025 2026 if ((padapter->securitypriv.dot11PrivacyAlgrthm == _TKIP_) || 2027 (padapter->securitypriv.dot11PrivacyAlgrthm == _AES_)) { 2028 /* restore group key, WEP keys is restored in ips_leave() */ 2029 rtw_set_key( 2030 padapter, 2031 psecuritypriv, 2032 psecuritypriv->dot118021XGrpKeyid, 2033 0, 2034 false 2035 ); 2036 } 2037 2038 spin_lock_bh(&pstapriv->asoc_list_lock); 2039 2040 phead = &pstapriv->asoc_list; 2041 list_for_each(plist, phead) { 2042 int stainfo_offset; 2043 2044 psta = list_entry(plist, struct sta_info, asoc_list); 2045 2046 stainfo_offset = rtw_stainfo_offset(pstapriv, psta); 2047 if (stainfo_offset_valid(stainfo_offset)) 2048 chk_alive_list[chk_alive_num++] = stainfo_offset; 2049 } 2050 2051 spin_unlock_bh(&pstapriv->asoc_list_lock); 2052 2053 for (i = 0; i < chk_alive_num; i++) { 2054 psta = rtw_get_stainfo_by_offset(pstapriv, chk_alive_list[i]); 2055 2056 if (!psta) 2057 continue; 2058 2059 if (psta->state & _FW_LINKED) { 2060 rtw_sta_media_status_rpt(padapter, psta, 1); 2061 Update_RA_Entry(padapter, psta); 2062 /* pairwise key */ 2063 /* per sta pairwise key and settings */ 2064 if ((psecuritypriv->dot11PrivacyAlgrthm == _TKIP_) || 2065 (psecuritypriv->dot11PrivacyAlgrthm == _AES_)) { 2066 rtw_setstakey_cmd(padapter, psta, true, false); 2067 } 2068 } 2069 } 2070 } 2071 2072 void start_ap_mode(struct adapter *padapter) 2073 { 2074 int i; 2075 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 2076 struct sta_priv *pstapriv = &padapter->stapriv; 2077 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 2078 struct wlan_acl_pool *pacl_list = &pstapriv->acl_list; 2079 2080 pmlmepriv->update_bcn = false; 2081 2082 /* init_mlme_ap_info(padapter); */ 2083 pmlmeext->bstart_bss = false; 2084 2085 pmlmepriv->num_sta_non_erp = 0; 2086 2087 pmlmepriv->num_sta_no_short_slot_time = 0; 2088 2089 pmlmepriv->num_sta_no_short_preamble = 0; 2090 2091 pmlmepriv->num_sta_ht_no_gf = 0; 2092 pmlmepriv->num_sta_no_ht = 0; 2093 pmlmepriv->num_sta_ht_20mhz = 0; 2094 2095 pmlmepriv->olbc = false; 2096 2097 pmlmepriv->olbc_ht = false; 2098 2099 pmlmepriv->ht_op_mode = 0; 2100 2101 for (i = 0; i < NUM_STA; i++) 2102 pstapriv->sta_aid[i] = NULL; 2103 2104 pmlmepriv->wps_beacon_ie = NULL; 2105 pmlmepriv->wps_probe_resp_ie = NULL; 2106 pmlmepriv->wps_assoc_resp_ie = NULL; 2107 2108 pmlmepriv->p2p_beacon_ie = NULL; 2109 pmlmepriv->p2p_probe_resp_ie = NULL; 2110 2111 /* for ACL */ 2112 INIT_LIST_HEAD(&(pacl_list->acl_node_q.queue)); 2113 pacl_list->num = 0; 2114 pacl_list->mode = 0; 2115 for (i = 0; i < NUM_ACL; i++) { 2116 INIT_LIST_HEAD(&pacl_list->aclnode[i].list); 2117 pacl_list->aclnode[i].valid = false; 2118 } 2119 } 2120 2121 void stop_ap_mode(struct adapter *padapter) 2122 { 2123 struct list_head *phead, *plist, *tmp; 2124 struct rtw_wlan_acl_node *paclnode; 2125 struct sta_info *psta = NULL; 2126 struct sta_priv *pstapriv = &padapter->stapriv; 2127 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 2128 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 2129 struct wlan_acl_pool *pacl_list = &pstapriv->acl_list; 2130 struct __queue *pacl_node_q = &pacl_list->acl_node_q; 2131 2132 pmlmepriv->update_bcn = false; 2133 pmlmeext->bstart_bss = false; 2134 2135 /* reset and init security priv , this can refine with rtw_reset_securitypriv */ 2136 memset( 2137 (unsigned char *)&padapter->securitypriv, 2138 0, 2139 sizeof(struct security_priv) 2140 ); 2141 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeOpen; 2142 padapter->securitypriv.ndisencryptstatus = Ndis802_11WEPDisabled; 2143 2144 /* for ACL */ 2145 spin_lock_bh(&(pacl_node_q->lock)); 2146 phead = get_list_head(pacl_node_q); 2147 list_for_each_safe(plist, tmp, phead) { 2148 paclnode = list_entry(plist, struct rtw_wlan_acl_node, list); 2149 2150 if (paclnode->valid) { 2151 paclnode->valid = false; 2152 2153 list_del_init(&paclnode->list); 2154 2155 pacl_list->num--; 2156 } 2157 } 2158 spin_unlock_bh(&(pacl_node_q->lock)); 2159 2160 rtw_sta_flush(padapter); 2161 2162 /* free_assoc_sta_resources */ 2163 rtw_free_all_stainfo(padapter); 2164 2165 psta = rtw_get_bcmc_stainfo(padapter); 2166 rtw_free_stainfo(padapter, psta); 2167 2168 rtw_init_bcmc_stainfo(padapter); 2169 2170 rtw_free_mlme_priv_ie_data(pmlmepriv); 2171 2172 rtw_btcoex_MediaStatusNotify(padapter, 0); /* disconnect */ 2173 } 2174