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