1 // SPDX-License-Identifier: GPL-2.0 2 /****************************************************************************** 3 * rtl871x_mlme.c 4 * 5 * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved. 6 * Linux device driver for RTL8192SU 7 * 8 * Modifications for inclusion into the Linux staging tree are 9 * Copyright(c) 2010 Larry Finger. All rights reserved. 10 * 11 * Contact information: 12 * WLAN FAE <wlanfae@realtek.com> 13 * Larry Finger <Larry.Finger@lwfinger.net> 14 * 15 ******************************************************************************/ 16 17 #define _RTL871X_MLME_C_ 18 19 #include <linux/etherdevice.h> 20 21 #include "osdep_service.h" 22 #include "drv_types.h" 23 #include "recv_osdep.h" 24 #include "xmit_osdep.h" 25 #include "mlme_osdep.h" 26 #include "sta_info.h" 27 #include "wifi.h" 28 #include "wlan_bssdef.h" 29 30 static void update_ht_cap(struct _adapter *padapter, u8 *pie, uint ie_len); 31 32 int r8712_init_mlme_priv(struct _adapter *padapter) 33 { 34 sint i; 35 u8 *pbuf; 36 struct wlan_network *pnetwork; 37 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 38 39 memset((u8 *)pmlmepriv, 0, sizeof(struct mlme_priv)); 40 pmlmepriv->nic_hdl = (u8 *)padapter; 41 pmlmepriv->pscanned = NULL; 42 pmlmepriv->fw_state = 0; 43 pmlmepriv->cur_network.network.InfrastructureMode = 44 Ndis802_11AutoUnknown; 45 /* Maybe someday we should rename this variable to "active_mode"(Jeff)*/ 46 pmlmepriv->passive_mode = 1; /* 1: active, 0: passive. */ 47 spin_lock_init(&(pmlmepriv->lock)); 48 spin_lock_init(&(pmlmepriv->lock2)); 49 _init_queue(&(pmlmepriv->free_bss_pool)); 50 _init_queue(&(pmlmepriv->scanned_queue)); 51 set_scanned_network_val(pmlmepriv, 0); 52 memset(&pmlmepriv->assoc_ssid, 0, sizeof(struct ndis_802_11_ssid)); 53 pbuf = kmalloc_array(MAX_BSS_CNT, sizeof(struct wlan_network), 54 GFP_ATOMIC); 55 if (!pbuf) 56 return -ENOMEM; 57 pmlmepriv->free_bss_buf = pbuf; 58 pnetwork = (struct wlan_network *)pbuf; 59 for (i = 0; i < MAX_BSS_CNT; i++) { 60 INIT_LIST_HEAD(&(pnetwork->list)); 61 list_add_tail(&(pnetwork->list), 62 &(pmlmepriv->free_bss_pool.queue)); 63 pnetwork++; 64 } 65 pmlmepriv->sitesurveyctrl.last_rx_pkts = 0; 66 pmlmepriv->sitesurveyctrl.last_tx_pkts = 0; 67 pmlmepriv->sitesurveyctrl.traffic_busy = false; 68 /* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */ 69 r8712_init_mlme_timer(padapter); 70 return 0; 71 } 72 73 struct wlan_network *_r8712_alloc_network(struct mlme_priv *pmlmepriv) 74 { 75 unsigned long irqL; 76 struct wlan_network *pnetwork; 77 struct __queue *free_queue = &pmlmepriv->free_bss_pool; 78 79 spin_lock_irqsave(&free_queue->lock, irqL); 80 pnetwork = list_first_entry_or_null(&free_queue->queue, 81 struct wlan_network, list); 82 if (pnetwork) { 83 list_del_init(&pnetwork->list); 84 pnetwork->last_scanned = jiffies; 85 pmlmepriv->num_of_scanned++; 86 } 87 spin_unlock_irqrestore(&free_queue->lock, irqL); 88 return pnetwork; 89 } 90 91 static void _free_network(struct mlme_priv *pmlmepriv, 92 struct wlan_network *pnetwork) 93 { 94 u32 curr_time, delta_time; 95 unsigned long irqL; 96 struct __queue *free_queue = &(pmlmepriv->free_bss_pool); 97 98 if (!pnetwork) 99 return; 100 if (pnetwork->fixed) 101 return; 102 curr_time = jiffies; 103 delta_time = (curr_time - (u32)pnetwork->last_scanned) / HZ; 104 if (delta_time < SCANQUEUE_LIFETIME) 105 return; 106 spin_lock_irqsave(&free_queue->lock, irqL); 107 list_del_init(&pnetwork->list); 108 list_add_tail(&pnetwork->list, &free_queue->queue); 109 pmlmepriv->num_of_scanned--; 110 spin_unlock_irqrestore(&free_queue->lock, irqL); 111 } 112 113 static void free_network_nolock(struct mlme_priv *pmlmepriv, 114 struct wlan_network *pnetwork) 115 { 116 struct __queue *free_queue = &pmlmepriv->free_bss_pool; 117 118 if (!pnetwork) 119 return; 120 if (pnetwork->fixed) 121 return; 122 list_del_init(&pnetwork->list); 123 list_add_tail(&pnetwork->list, &free_queue->queue); 124 pmlmepriv->num_of_scanned--; 125 } 126 127 /* return the wlan_network with the matching addr 128 * Shall be called under atomic context... 129 * to avoid possible racing condition... 130 */ 131 static struct wlan_network *r8712_find_network(struct __queue *scanned_queue, 132 u8 *addr) 133 { 134 unsigned long irqL; 135 struct list_head *phead, *plist; 136 struct wlan_network *pnetwork = NULL; 137 138 if (is_zero_ether_addr(addr)) 139 return NULL; 140 spin_lock_irqsave(&scanned_queue->lock, irqL); 141 phead = &scanned_queue->queue; 142 list_for_each(plist, phead) { 143 pnetwork = list_entry(plist, struct wlan_network, list); 144 if (!memcmp(addr, pnetwork->network.MacAddress, ETH_ALEN)) 145 break; 146 } 147 if (plist == phead) 148 pnetwork = NULL; 149 spin_unlock_irqrestore(&scanned_queue->lock, irqL); 150 return pnetwork; 151 } 152 153 void r8712_free_network_queue(struct _adapter *padapter) 154 { 155 unsigned long irqL; 156 struct list_head *phead, *plist; 157 struct wlan_network *pnetwork; 158 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 159 struct __queue *scanned_queue = &pmlmepriv->scanned_queue; 160 161 spin_lock_irqsave(&scanned_queue->lock, irqL); 162 phead = &scanned_queue->queue; 163 plist = phead->next; 164 while (!end_of_queue_search(phead, plist)) { 165 pnetwork = container_of(plist, struct wlan_network, list); 166 plist = plist->next; 167 _free_network(pmlmepriv, pnetwork); 168 } 169 spin_unlock_irqrestore(&scanned_queue->lock, irqL); 170 } 171 172 sint r8712_if_up(struct _adapter *padapter) 173 { 174 sint res; 175 176 if (padapter->driver_stopped || padapter->surprise_removed || 177 !check_fwstate(&padapter->mlmepriv, _FW_LINKED)) { 178 res = false; 179 } else { 180 res = true; 181 } 182 return res; 183 } 184 185 void r8712_generate_random_ibss(u8 *pibss) 186 { 187 u32 curtime = jiffies; 188 189 pibss[0] = 0x02; /*in ad-hoc mode bit1 must set to 1 */ 190 pibss[1] = 0x11; 191 pibss[2] = 0x87; 192 pibss[3] = (u8)(curtime & 0xff); 193 pibss[4] = (u8)((curtime >> 8) & 0xff); 194 pibss[5] = (u8)((curtime >> 16) & 0xff); 195 } 196 197 uint r8712_get_wlan_bssid_ex_sz(struct wlan_bssid_ex *bss) 198 { 199 return sizeof(*bss) + bss->IELength - MAX_IE_SZ; 200 } 201 202 u8 *r8712_get_capability_from_ie(u8 *ie) 203 { 204 return ie + 8 + 2; 205 } 206 207 void r8712_free_mlme_priv(struct mlme_priv *pmlmepriv) 208 { 209 kfree(pmlmepriv->free_bss_buf); 210 } 211 212 static struct wlan_network *alloc_network(struct mlme_priv *pmlmepriv) 213 { 214 return _r8712_alloc_network(pmlmepriv); 215 } 216 217 int r8712_is_same_ibss(struct _adapter *adapter, struct wlan_network *pnetwork) 218 { 219 int ret = true; 220 struct security_priv *psecuritypriv = &adapter->securitypriv; 221 222 if ((psecuritypriv->PrivacyAlgrthm != _NO_PRIVACY_) && 223 (pnetwork->network.Privacy == cpu_to_le32(0))) 224 ret = false; 225 else if ((psecuritypriv->PrivacyAlgrthm == _NO_PRIVACY_) && 226 (pnetwork->network.Privacy == cpu_to_le32(1))) 227 ret = false; 228 else 229 ret = true; 230 return ret; 231 232 } 233 234 static int is_same_network(struct wlan_bssid_ex *src, 235 struct wlan_bssid_ex *dst) 236 { 237 u16 s_cap, d_cap; 238 239 memcpy((u8 *)&s_cap, r8712_get_capability_from_ie(src->IEs), 2); 240 memcpy((u8 *)&d_cap, r8712_get_capability_from_ie(dst->IEs), 2); 241 return (src->Ssid.SsidLength == dst->Ssid.SsidLength) && 242 (src->Configuration.DSConfig == 243 dst->Configuration.DSConfig) && 244 ((!memcmp(src->MacAddress, dst->MacAddress, 245 ETH_ALEN))) && 246 ((!memcmp(src->Ssid.Ssid, 247 dst->Ssid.Ssid, 248 src->Ssid.SsidLength))) && 249 ((s_cap & WLAN_CAPABILITY_IBSS) == 250 (d_cap & WLAN_CAPABILITY_IBSS)) && 251 ((s_cap & WLAN_CAPABILITY_ESS) == 252 (d_cap & WLAN_CAPABILITY_ESS)); 253 254 } 255 256 struct wlan_network *r8712_get_oldest_wlan_network( 257 struct __queue *scanned_queue) 258 { 259 struct list_head *plist, *phead; 260 struct wlan_network *pwlan = NULL; 261 struct wlan_network *oldest = NULL; 262 263 phead = &scanned_queue->queue; 264 plist = phead->next; 265 while (1) { 266 if (end_of_queue_search(phead, plist)) 267 break; 268 pwlan = container_of(plist, struct wlan_network, list); 269 if (!pwlan->fixed) { 270 if (!oldest || 271 time_after((unsigned long)oldest->last_scanned, 272 (unsigned long)pwlan->last_scanned)) 273 oldest = pwlan; 274 } 275 plist = plist->next; 276 } 277 return oldest; 278 } 279 280 static void update_network(struct wlan_bssid_ex *dst, 281 struct wlan_bssid_ex *src, 282 struct _adapter *padapter) 283 { 284 u32 last_evm = 0, tmpVal; 285 struct smooth_rssi_data *sqd = &padapter->recvpriv.signal_qual_data; 286 287 if (check_fwstate(&padapter->mlmepriv, _FW_LINKED) && 288 is_same_network(&(padapter->mlmepriv.cur_network.network), src)) { 289 if (padapter->recvpriv.signal_qual_data.total_num++ >= 290 PHY_LINKQUALITY_SLID_WIN_MAX) { 291 padapter->recvpriv.signal_qual_data.total_num = 292 PHY_LINKQUALITY_SLID_WIN_MAX; 293 last_evm = sqd->elements[sqd->index]; 294 padapter->recvpriv.signal_qual_data.total_val -= 295 last_evm; 296 } 297 padapter->recvpriv.signal_qual_data.total_val += src->Rssi; 298 299 sqd->elements[sqd->index++] = src->Rssi; 300 if (padapter->recvpriv.signal_qual_data.index >= 301 PHY_LINKQUALITY_SLID_WIN_MAX) 302 padapter->recvpriv.signal_qual_data.index = 0; 303 /* <1> Showed on UI for user, in percentage. */ 304 tmpVal = padapter->recvpriv.signal_qual_data.total_val / 305 padapter->recvpriv.signal_qual_data.total_num; 306 padapter->recvpriv.signal = (u8)tmpVal; 307 308 src->Rssi = padapter->recvpriv.signal; 309 } else { 310 src->Rssi = (src->Rssi + dst->Rssi) / 2; 311 } 312 memcpy((u8 *)dst, (u8 *)src, r8712_get_wlan_bssid_ex_sz(src)); 313 } 314 315 static void update_current_network(struct _adapter *adapter, 316 struct wlan_bssid_ex *pnetwork) 317 { 318 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 319 320 if (is_same_network(&(pmlmepriv->cur_network.network), pnetwork)) { 321 update_network(&(pmlmepriv->cur_network.network), 322 pnetwork, adapter); 323 r8712_update_protection(adapter, 324 (pmlmepriv->cur_network.network.IEs) + 325 sizeof(struct NDIS_802_11_FIXED_IEs), 326 pmlmepriv->cur_network.network.IELength); 327 } 328 } 329 330 /* Caller must hold pmlmepriv->lock first */ 331 static void update_scanned_network(struct _adapter *adapter, 332 struct wlan_bssid_ex *target) 333 { 334 struct list_head *plist, *phead; 335 336 u32 bssid_ex_sz; 337 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 338 struct __queue *queue = &pmlmepriv->scanned_queue; 339 struct wlan_network *pnetwork = NULL; 340 struct wlan_network *oldest = NULL; 341 342 phead = &queue->queue; 343 plist = phead->next; 344 345 while (1) { 346 if (end_of_queue_search(phead, plist)) 347 break; 348 349 pnetwork = container_of(plist, struct wlan_network, list); 350 if (is_same_network(&pnetwork->network, target)) 351 break; 352 if ((oldest == ((struct wlan_network *)0)) || 353 time_after((unsigned long)oldest->last_scanned, 354 (unsigned long)pnetwork->last_scanned)) 355 oldest = pnetwork; 356 357 plist = plist->next; 358 } 359 360 /* If we didn't find a match, then get a new network slot to initialize 361 * with this beacon's information 362 */ 363 if (end_of_queue_search(phead, plist)) { 364 if (list_empty(&pmlmepriv->free_bss_pool.queue)) { 365 /* If there are no more slots, expire the oldest */ 366 pnetwork = oldest; 367 target->Rssi = (pnetwork->network.Rssi + 368 target->Rssi) / 2; 369 memcpy(&pnetwork->network, target, 370 r8712_get_wlan_bssid_ex_sz(target)); 371 pnetwork->last_scanned = jiffies; 372 } else { 373 /* Otherwise just pull from the free list */ 374 /* update scan_time */ 375 pnetwork = alloc_network(pmlmepriv); 376 if (!pnetwork) 377 return; 378 bssid_ex_sz = r8712_get_wlan_bssid_ex_sz(target); 379 target->Length = bssid_ex_sz; 380 memcpy(&pnetwork->network, target, bssid_ex_sz); 381 list_add_tail(&pnetwork->list, &queue->queue); 382 } 383 } else { 384 /* we have an entry and we are going to update it. But 385 * this entry may be already expired. In this case we 386 * do the same as we found a new net and call the new_net 387 * handler 388 */ 389 update_network(&pnetwork->network, target, adapter); 390 pnetwork->last_scanned = jiffies; 391 } 392 } 393 394 static void rtl8711_add_network(struct _adapter *adapter, 395 struct wlan_bssid_ex *pnetwork) 396 { 397 unsigned long irqL; 398 struct mlme_priv *pmlmepriv = &(((struct _adapter *)adapter)->mlmepriv); 399 struct __queue *queue = &pmlmepriv->scanned_queue; 400 401 spin_lock_irqsave(&queue->lock, irqL); 402 update_current_network(adapter, pnetwork); 403 update_scanned_network(adapter, pnetwork); 404 spin_unlock_irqrestore(&queue->lock, irqL); 405 } 406 407 /*select the desired network based on the capability of the (i)bss. 408 * check items: (1) security 409 * (2) network_type 410 * (3) WMM 411 * (4) HT 412 * (5) others 413 */ 414 static int is_desired_network(struct _adapter *adapter, 415 struct wlan_network *pnetwork) 416 { 417 u8 wps_ie[512]; 418 uint wps_ielen; 419 int bselected = true; 420 struct security_priv *psecuritypriv = &adapter->securitypriv; 421 422 if (psecuritypriv->wps_phase) { 423 if (r8712_get_wps_ie(pnetwork->network.IEs, 424 pnetwork->network.IELength, wps_ie, 425 &wps_ielen)) 426 return true; 427 return false; 428 } 429 if ((psecuritypriv->PrivacyAlgrthm != _NO_PRIVACY_) && 430 (pnetwork->network.Privacy == 0)) 431 bselected = false; 432 if (check_fwstate(&adapter->mlmepriv, WIFI_ADHOC_STATE)) { 433 if (pnetwork->network.InfrastructureMode != 434 adapter->mlmepriv.cur_network.network.InfrastructureMode) 435 bselected = false; 436 } 437 return bselected; 438 } 439 440 /* TODO: Perry : For Power Management */ 441 void r8712_atimdone_event_callback(struct _adapter *adapter, u8 *pbuf) 442 { 443 } 444 445 void r8712_survey_event_callback(struct _adapter *adapter, u8 *pbuf) 446 { 447 unsigned long flags; 448 u32 len; 449 struct wlan_bssid_ex *pnetwork; 450 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 451 452 pnetwork = (struct wlan_bssid_ex *)pbuf; 453 #ifdef __BIG_ENDIAN 454 /* endian_convert */ 455 pnetwork->Length = le32_to_cpu(pnetwork->Length); 456 pnetwork->Ssid.SsidLength = le32_to_cpu(pnetwork->Ssid.SsidLength); 457 pnetwork->Privacy = le32_to_cpu(pnetwork->Privacy); 458 pnetwork->Rssi = le32_to_cpu(pnetwork->Rssi); 459 pnetwork->NetworkTypeInUse = le32_to_cpu(pnetwork->NetworkTypeInUse); 460 pnetwork->Configuration.ATIMWindow = 461 le32_to_cpu(pnetwork->Configuration.ATIMWindow); 462 pnetwork->Configuration.BeaconPeriod = 463 le32_to_cpu(pnetwork->Configuration.BeaconPeriod); 464 pnetwork->Configuration.DSConfig = 465 le32_to_cpu(pnetwork->Configuration.DSConfig); 466 pnetwork->Configuration.FHConfig.DwellTime = 467 le32_to_cpu(pnetwork->Configuration.FHConfig.DwellTime); 468 pnetwork->Configuration.FHConfig.HopPattern = 469 le32_to_cpu(pnetwork->Configuration.FHConfig.HopPattern); 470 pnetwork->Configuration.FHConfig.HopSet = 471 le32_to_cpu(pnetwork->Configuration.FHConfig.HopSet); 472 pnetwork->Configuration.FHConfig.Length = 473 le32_to_cpu(pnetwork->Configuration.FHConfig.Length); 474 pnetwork->Configuration.Length = 475 le32_to_cpu(pnetwork->Configuration.Length); 476 pnetwork->InfrastructureMode = 477 le32_to_cpu(pnetwork->InfrastructureMode); 478 pnetwork->IELength = le32_to_cpu(pnetwork->IELength); 479 #endif 480 len = r8712_get_wlan_bssid_ex_sz(pnetwork); 481 if (len > sizeof(struct wlan_bssid_ex)) 482 return; 483 spin_lock_irqsave(&pmlmepriv->lock2, flags); 484 /* update IBSS_network 's timestamp */ 485 if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) { 486 if (!memcmp(&(pmlmepriv->cur_network.network.MacAddress), 487 pnetwork->MacAddress, ETH_ALEN)) { 488 struct wlan_network *ibss_wlan = NULL; 489 490 memcpy(pmlmepriv->cur_network.network.IEs, 491 pnetwork->IEs, 8); 492 ibss_wlan = r8712_find_network( 493 &pmlmepriv->scanned_queue, 494 pnetwork->MacAddress); 495 if (ibss_wlan) { 496 memcpy(ibss_wlan->network.IEs, 497 pnetwork->IEs, 8); 498 goto exit; 499 } 500 } 501 } 502 /* lock pmlmepriv->lock when you accessing network_q */ 503 if (!check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) { 504 if (pnetwork->Ssid.Ssid[0] != 0) { 505 rtl8711_add_network(adapter, pnetwork); 506 } else { 507 pnetwork->Ssid.SsidLength = 8; 508 memcpy(pnetwork->Ssid.Ssid, "<hidden>", 8); 509 rtl8711_add_network(adapter, pnetwork); 510 } 511 } 512 exit: 513 spin_unlock_irqrestore(&pmlmepriv->lock2, flags); 514 } 515 516 void r8712_surveydone_event_callback(struct _adapter *adapter, u8 *pbuf) 517 { 518 unsigned long irqL; 519 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 520 521 spin_lock_irqsave(&pmlmepriv->lock, irqL); 522 523 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY)) { 524 del_timer(&pmlmepriv->scan_to_timer); 525 526 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY); 527 } 528 529 if (pmlmepriv->to_join) { 530 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) { 531 if (!check_fwstate(pmlmepriv, _FW_LINKED)) { 532 set_fwstate(pmlmepriv, _FW_UNDER_LINKING); 533 534 if (!r8712_select_and_join_from_scan(pmlmepriv)) { 535 mod_timer(&pmlmepriv->assoc_timer, jiffies + 536 msecs_to_jiffies(MAX_JOIN_TIMEOUT)); 537 } else { 538 struct wlan_bssid_ex *pdev_network = 539 &(adapter->registrypriv.dev_network); 540 u8 *pibss = 541 adapter->registrypriv.dev_network.MacAddress; 542 pmlmepriv->fw_state ^= _FW_UNDER_SURVEY; 543 memcpy(&pdev_network->Ssid, 544 &pmlmepriv->assoc_ssid, 545 sizeof(struct 546 ndis_802_11_ssid)); 547 r8712_update_registrypriv_dev_network 548 (adapter); 549 r8712_generate_random_ibss(pibss); 550 pmlmepriv->fw_state = 551 WIFI_ADHOC_MASTER_STATE; 552 pmlmepriv->to_join = false; 553 } 554 } 555 } else { 556 pmlmepriv->to_join = false; 557 set_fwstate(pmlmepriv, _FW_UNDER_LINKING); 558 if (!r8712_select_and_join_from_scan(pmlmepriv)) 559 mod_timer(&pmlmepriv->assoc_timer, jiffies + 560 msecs_to_jiffies(MAX_JOIN_TIMEOUT)); 561 else 562 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING); 563 } 564 } 565 spin_unlock_irqrestore(&pmlmepriv->lock, irqL); 566 } 567 568 /* 569 *r8712_free_assoc_resources: the caller has to lock pmlmepriv->lock 570 */ 571 void r8712_free_assoc_resources(struct _adapter *adapter) 572 { 573 unsigned long irqL; 574 struct wlan_network *pwlan = NULL; 575 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 576 struct sta_priv *pstapriv = &adapter->stapriv; 577 struct wlan_network *tgt_network = &pmlmepriv->cur_network; 578 579 pwlan = r8712_find_network(&pmlmepriv->scanned_queue, 580 tgt_network->network.MacAddress); 581 582 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE | WIFI_AP_STATE)) { 583 struct sta_info *psta; 584 585 psta = r8712_get_stainfo(&adapter->stapriv, 586 tgt_network->network.MacAddress); 587 588 spin_lock_irqsave(&pstapriv->sta_hash_lock, irqL); 589 r8712_free_stainfo(adapter, psta); 590 spin_unlock_irqrestore(&pstapriv->sta_hash_lock, irqL); 591 } 592 593 if (check_fwstate(pmlmepriv, 594 WIFI_ADHOC_STATE | WIFI_ADHOC_MASTER_STATE | WIFI_AP_STATE)) 595 r8712_free_all_stainfo(adapter); 596 if (pwlan) 597 pwlan->fixed = false; 598 599 if (((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) && 600 (adapter->stapriv.asoc_sta_count == 1))) 601 free_network_nolock(pmlmepriv, pwlan); 602 } 603 604 /* 605 * r8712_indicate_connect: the caller has to lock pmlmepriv->lock 606 */ 607 void r8712_indicate_connect(struct _adapter *padapter) 608 { 609 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 610 611 pmlmepriv->to_join = false; 612 set_fwstate(pmlmepriv, _FW_LINKED); 613 padapter->ledpriv.LedControlHandler(padapter, LED_CTL_LINK); 614 r8712_os_indicate_connect(padapter); 615 if (padapter->registrypriv.power_mgnt > PS_MODE_ACTIVE) 616 mod_timer(&pmlmepriv->dhcp_timer, 617 jiffies + msecs_to_jiffies(60000)); 618 } 619 620 /* 621 * r8712_ind_disconnect: the caller has to lock pmlmepriv->lock 622 */ 623 void r8712_ind_disconnect(struct _adapter *padapter) 624 { 625 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 626 627 if (check_fwstate(pmlmepriv, _FW_LINKED)) { 628 _clr_fwstate_(pmlmepriv, _FW_LINKED); 629 padapter->ledpriv.LedControlHandler(padapter, LED_CTL_NO_LINK); 630 r8712_os_indicate_disconnect(padapter); 631 } 632 if (padapter->pwrctrlpriv.pwr_mode != 633 padapter->registrypriv.power_mgnt) { 634 del_timer(&pmlmepriv->dhcp_timer); 635 r8712_set_ps_mode(padapter, padapter->registrypriv.power_mgnt, 636 padapter->registrypriv.smart_ps); 637 } 638 } 639 640 /*Notes: 641 *pnetwork : returns from r8712_joinbss_event_callback 642 *ptarget_wlan: found from scanned_queue 643 *if join_res > 0, for (fw_state==WIFI_STATION_STATE), we check if 644 * "ptarget_sta" & "ptarget_wlan" exist. 645 *if join_res > 0, for (fw_state==WIFI_ADHOC_STATE), we only check 646 * if "ptarget_wlan" exist. 647 *if join_res > 0, update "cur_network->network" from 648 * "pnetwork->network" if (ptarget_wlan !=NULL). 649 */ 650 void r8712_joinbss_event_callback(struct _adapter *adapter, u8 *pbuf) 651 { 652 unsigned long irqL = 0, irqL2; 653 struct sta_info *ptarget_sta = NULL, *pcur_sta = NULL; 654 struct sta_priv *pstapriv = &adapter->stapriv; 655 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 656 struct wlan_network *cur_network = &pmlmepriv->cur_network; 657 struct wlan_network *pcur_wlan = NULL, *ptarget_wlan = NULL; 658 unsigned int the_same_macaddr = false; 659 struct wlan_network *pnetwork; 660 661 if (sizeof(struct list_head) == 4 * sizeof(u32)) { 662 pnetwork = kmalloc(sizeof(struct wlan_network), GFP_ATOMIC); 663 if (!pnetwork) 664 return; 665 memcpy((u8 *)pnetwork + 16, (u8 *)pbuf + 8, 666 sizeof(struct wlan_network) - 16); 667 } else { 668 pnetwork = (struct wlan_network *)pbuf; 669 } 670 671 #ifdef __BIG_ENDIAN 672 /* endian_convert */ 673 pnetwork->join_res = le32_to_cpu(pnetwork->join_res); 674 pnetwork->network_type = le32_to_cpu(pnetwork->network_type); 675 pnetwork->network.Length = le32_to_cpu(pnetwork->network.Length); 676 pnetwork->network.Ssid.SsidLength = 677 le32_to_cpu(pnetwork->network.Ssid.SsidLength); 678 pnetwork->network.Privacy = le32_to_cpu(pnetwork->network.Privacy); 679 pnetwork->network.Rssi = le32_to_cpu(pnetwork->network.Rssi); 680 pnetwork->network.NetworkTypeInUse = 681 le32_to_cpu(pnetwork->network.NetworkTypeInUse); 682 pnetwork->network.Configuration.ATIMWindow = 683 le32_to_cpu(pnetwork->network.Configuration.ATIMWindow); 684 pnetwork->network.Configuration.BeaconPeriod = 685 le32_to_cpu(pnetwork->network.Configuration.BeaconPeriod); 686 pnetwork->network.Configuration.DSConfig = 687 le32_to_cpu(pnetwork->network.Configuration.DSConfig); 688 pnetwork->network.Configuration.FHConfig.DwellTime = 689 le32_to_cpu(pnetwork->network.Configuration.FHConfig.DwellTime); 690 pnetwork->network.Configuration.FHConfig.HopPattern = 691 le32_to_cpu(pnetwork->network.Configuration.FHConfig.HopPattern); 692 pnetwork->network.Configuration.FHConfig.HopSet = 693 le32_to_cpu(pnetwork->network.Configuration.FHConfig.HopSet); 694 pnetwork->network.Configuration.FHConfig.Length = 695 le32_to_cpu(pnetwork->network.Configuration.FHConfig.Length); 696 pnetwork->network.Configuration.Length = 697 le32_to_cpu(pnetwork->network.Configuration.Length); 698 pnetwork->network.InfrastructureMode = 699 le32_to_cpu(pnetwork->network.InfrastructureMode); 700 pnetwork->network.IELength = le32_to_cpu(pnetwork->network.IELength); 701 #endif 702 703 the_same_macaddr = !memcmp(pnetwork->network.MacAddress, 704 cur_network->network.MacAddress, ETH_ALEN); 705 pnetwork->network.Length = 706 r8712_get_wlan_bssid_ex_sz(&pnetwork->network); 707 spin_lock_irqsave(&pmlmepriv->lock, irqL); 708 if (pnetwork->network.Length > sizeof(struct wlan_bssid_ex)) 709 goto ignore_joinbss_callback; 710 if (pnetwork->join_res > 0) { 711 if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) { 712 /*s1. find ptarget_wlan*/ 713 if (check_fwstate(pmlmepriv, _FW_LINKED)) { 714 if (the_same_macaddr) { 715 ptarget_wlan = 716 r8712_find_network(&pmlmepriv->scanned_queue, 717 cur_network->network.MacAddress); 718 } else { 719 pcur_wlan = 720 r8712_find_network(&pmlmepriv->scanned_queue, 721 cur_network->network.MacAddress); 722 if (pcur_wlan) 723 pcur_wlan->fixed = false; 724 725 pcur_sta = r8712_get_stainfo(pstapriv, 726 cur_network->network.MacAddress); 727 spin_lock_irqsave(&pstapriv->sta_hash_lock, irqL2); 728 r8712_free_stainfo(adapter, pcur_sta); 729 spin_unlock_irqrestore(&(pstapriv->sta_hash_lock), irqL2); 730 731 ptarget_wlan = 732 r8712_find_network(&pmlmepriv->scanned_queue, 733 pnetwork->network.MacAddress); 734 if (ptarget_wlan) 735 ptarget_wlan->fixed = true; 736 } 737 } else { 738 ptarget_wlan = r8712_find_network(&pmlmepriv->scanned_queue, 739 pnetwork->network.MacAddress); 740 if (ptarget_wlan) 741 ptarget_wlan->fixed = true; 742 } 743 744 if (!ptarget_wlan) { 745 if (check_fwstate(pmlmepriv, 746 _FW_UNDER_LINKING)) 747 pmlmepriv->fw_state ^= 748 _FW_UNDER_LINKING; 749 goto ignore_joinbss_callback; 750 } 751 752 /*s2. find ptarget_sta & update ptarget_sta*/ 753 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) { 754 if (the_same_macaddr) { 755 ptarget_sta = 756 r8712_get_stainfo(pstapriv, 757 pnetwork->network.MacAddress); 758 if (!ptarget_sta) 759 ptarget_sta = 760 r8712_alloc_stainfo(pstapriv, 761 pnetwork->network.MacAddress); 762 } else { 763 ptarget_sta = 764 r8712_alloc_stainfo(pstapriv, 765 pnetwork->network.MacAddress); 766 } 767 if (ptarget_sta) /*update ptarget_sta*/ { 768 ptarget_sta->aid = pnetwork->join_res; 769 ptarget_sta->qos_option = 1; 770 ptarget_sta->mac_id = 5; 771 if (adapter->securitypriv.AuthAlgrthm == 2) { 772 adapter->securitypriv.binstallGrpkey = false; 773 adapter->securitypriv.busetkipkey = false; 774 adapter->securitypriv.bgrpkey_handshake = false; 775 ptarget_sta->ieee8021x_blocked = true; 776 ptarget_sta->XPrivacy = 777 adapter->securitypriv.PrivacyAlgrthm; 778 memset((u8 *)&ptarget_sta->x_UncstKey, 779 0, 780 sizeof(union Keytype)); 781 memset((u8 *)&ptarget_sta->tkiprxmickey, 782 0, 783 sizeof(union Keytype)); 784 memset((u8 *)&ptarget_sta->tkiptxmickey, 785 0, 786 sizeof(union Keytype)); 787 memset((u8 *)&ptarget_sta->txpn, 788 0, 789 sizeof(union pn48)); 790 memset((u8 *)&ptarget_sta->rxpn, 791 0, 792 sizeof(union pn48)); 793 } 794 } else { 795 if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) 796 pmlmepriv->fw_state ^= 797 _FW_UNDER_LINKING; 798 goto ignore_joinbss_callback; 799 } 800 } 801 802 /*s3. update cur_network & indicate connect*/ 803 memcpy(&cur_network->network, &pnetwork->network, 804 pnetwork->network.Length); 805 cur_network->aid = pnetwork->join_res; 806 /*update fw_state will clr _FW_UNDER_LINKING*/ 807 switch (pnetwork->network.InfrastructureMode) { 808 case Ndis802_11Infrastructure: 809 pmlmepriv->fw_state = WIFI_STATION_STATE; 810 break; 811 case Ndis802_11IBSS: 812 pmlmepriv->fw_state = WIFI_ADHOC_STATE; 813 break; 814 default: 815 pmlmepriv->fw_state = WIFI_NULL_STATE; 816 break; 817 } 818 r8712_update_protection(adapter, 819 (cur_network->network.IEs) + 820 sizeof(struct NDIS_802_11_FIXED_IEs), 821 (cur_network->network.IELength)); 822 /*TODO: update HT_Capability*/ 823 update_ht_cap(adapter, cur_network->network.IEs, 824 cur_network->network.IELength); 825 /*indicate connect*/ 826 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) 827 r8712_indicate_connect(adapter); 828 del_timer(&pmlmepriv->assoc_timer); 829 } else { 830 goto ignore_joinbss_callback; 831 } 832 } else { 833 if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) { 834 mod_timer(&pmlmepriv->assoc_timer, 835 jiffies + msecs_to_jiffies(1)); 836 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING); 837 } 838 } 839 ignore_joinbss_callback: 840 spin_unlock_irqrestore(&pmlmepriv->lock, irqL); 841 if (sizeof(struct list_head) == 4 * sizeof(u32)) 842 kfree(pnetwork); 843 } 844 845 void r8712_stassoc_event_callback(struct _adapter *adapter, u8 *pbuf) 846 { 847 unsigned long irqL; 848 struct sta_info *psta; 849 struct mlme_priv *pmlmepriv = &(adapter->mlmepriv); 850 struct stassoc_event *pstassoc = (struct stassoc_event *)pbuf; 851 852 /* to do: */ 853 if (!r8712_access_ctrl(&adapter->acl_list, pstassoc->macaddr)) 854 return; 855 psta = r8712_get_stainfo(&adapter->stapriv, pstassoc->macaddr); 856 if (psta) { 857 /*the sta have been in sta_info_queue => do nothing 858 *(between drv has received this event before and 859 * fw have not yet to set key to CAM_ENTRY) 860 */ 861 return; 862 } 863 864 psta = r8712_alloc_stainfo(&adapter->stapriv, pstassoc->macaddr); 865 if (!psta) 866 return; 867 /* to do : init sta_info variable */ 868 psta->qos_option = 0; 869 psta->mac_id = le32_to_cpu(pstassoc->cam_id); 870 /* psta->aid = (uint)pstassoc->cam_id; */ 871 872 if (adapter->securitypriv.AuthAlgrthm == 2) 873 psta->XPrivacy = adapter->securitypriv.PrivacyAlgrthm; 874 psta->ieee8021x_blocked = false; 875 spin_lock_irqsave(&pmlmepriv->lock, irqL); 876 if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) || 877 check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) { 878 if (adapter->stapriv.asoc_sta_count == 2) { 879 /* a sta + bc/mc_stainfo (not Ibss_stainfo) */ 880 r8712_indicate_connect(adapter); 881 } 882 } 883 spin_unlock_irqrestore(&pmlmepriv->lock, irqL); 884 } 885 886 void r8712_stadel_event_callback(struct _adapter *adapter, u8 *pbuf) 887 { 888 unsigned long irqL, irqL2; 889 struct sta_info *psta; 890 struct wlan_network *pwlan = NULL; 891 struct wlan_bssid_ex *pdev_network = NULL; 892 u8 *pibss = NULL; 893 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 894 struct stadel_event *pstadel = (struct stadel_event *)pbuf; 895 struct sta_priv *pstapriv = &adapter->stapriv; 896 struct wlan_network *tgt_network = &pmlmepriv->cur_network; 897 898 spin_lock_irqsave(&pmlmepriv->lock, irqL2); 899 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) { 900 r8712_ind_disconnect(adapter); 901 r8712_free_assoc_resources(adapter); 902 } 903 if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE | 904 WIFI_ADHOC_STATE)) { 905 psta = r8712_get_stainfo(&adapter->stapriv, pstadel->macaddr); 906 spin_lock_irqsave(&pstapriv->sta_hash_lock, irqL); 907 r8712_free_stainfo(adapter, psta); 908 spin_unlock_irqrestore(&pstapriv->sta_hash_lock, irqL); 909 if (adapter->stapriv.asoc_sta_count == 1) { 910 /*a sta + bc/mc_stainfo (not Ibss_stainfo) */ 911 pwlan = r8712_find_network(&pmlmepriv->scanned_queue, 912 tgt_network->network.MacAddress); 913 if (pwlan) { 914 pwlan->fixed = false; 915 free_network_nolock(pmlmepriv, pwlan); 916 } 917 /*re-create ibss*/ 918 pdev_network = &(adapter->registrypriv.dev_network); 919 pibss = adapter->registrypriv.dev_network.MacAddress; 920 memcpy(pdev_network, &tgt_network->network, 921 r8712_get_wlan_bssid_ex_sz(&tgt_network->network)); 922 memcpy(&pdev_network->Ssid, 923 &pmlmepriv->assoc_ssid, 924 sizeof(struct ndis_802_11_ssid)); 925 r8712_update_registrypriv_dev_network(adapter); 926 r8712_generate_random_ibss(pibss); 927 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) { 928 _clr_fwstate_(pmlmepriv, WIFI_ADHOC_STATE); 929 set_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE); 930 } 931 } 932 } 933 spin_unlock_irqrestore(&pmlmepriv->lock, irqL2); 934 } 935 936 void r8712_cpwm_event_callback(struct _adapter *adapter, u8 *pbuf) 937 { 938 struct reportpwrstate_parm *preportpwrstate = 939 (struct reportpwrstate_parm *)pbuf; 940 941 preportpwrstate->state |= (u8)(adapter->pwrctrlpriv.cpwm_tog + 0x80); 942 r8712_cpwm_int_hdl(adapter, preportpwrstate); 943 } 944 945 /* When the Netgear 3500 AP is with WPA2PSK-AES mode, it will send 946 * the ADDBA req frame with start seq control = 0 to wifi client after 947 * the WPA handshake and the seqence number of following data packet 948 * will be 0. In this case, the Rx reorder sequence is not longer than 0 949 * and the WiFi client will drop the data with seq number 0. 950 * So, the 8712 firmware has to inform driver with receiving the 951 * ADDBA-Req frame so that the driver can reset the 952 * sequence value of Rx reorder control. 953 */ 954 void r8712_got_addbareq_event_callback(struct _adapter *adapter, u8 *pbuf) 955 { 956 struct ADDBA_Req_Report_parm *pAddbareq_pram = 957 (struct ADDBA_Req_Report_parm *)pbuf; 958 struct sta_info *psta; 959 struct sta_priv *pstapriv = &adapter->stapriv; 960 struct recv_reorder_ctrl *precvreorder_ctrl = NULL; 961 962 psta = r8712_get_stainfo(pstapriv, pAddbareq_pram->MacAddress); 963 if (psta) { 964 precvreorder_ctrl = 965 &psta->recvreorder_ctrl[pAddbareq_pram->tid]; 966 /* set the indicate_seq to 0xffff so that the rx reorder 967 * can store any following data packet. 968 */ 969 precvreorder_ctrl->indicate_seq = 0xffff; 970 } 971 } 972 973 void r8712_wpspbc_event_callback(struct _adapter *adapter, u8 *pbuf) 974 { 975 if (!adapter->securitypriv.wps_hw_pbc_pressed) 976 adapter->securitypriv.wps_hw_pbc_pressed = true; 977 } 978 979 void _r8712_sitesurvey_ctrl_handler(struct _adapter *adapter) 980 { 981 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 982 struct sitesurvey_ctrl *psitesurveyctrl = &pmlmepriv->sitesurveyctrl; 983 struct registry_priv *pregistrypriv = &adapter->registrypriv; 984 u64 current_tx_pkts; 985 uint current_rx_pkts; 986 987 current_tx_pkts = (adapter->xmitpriv.tx_pkts) - 988 (psitesurveyctrl->last_tx_pkts); 989 current_rx_pkts = (adapter->recvpriv.rx_pkts) - 990 (psitesurveyctrl->last_rx_pkts); 991 psitesurveyctrl->last_tx_pkts = adapter->xmitpriv.tx_pkts; 992 psitesurveyctrl->last_rx_pkts = adapter->recvpriv.rx_pkts; 993 if ((current_tx_pkts > pregistrypriv->busy_thresh) || 994 (current_rx_pkts > pregistrypriv->busy_thresh)) 995 psitesurveyctrl->traffic_busy = true; 996 else 997 psitesurveyctrl->traffic_busy = false; 998 } 999 1000 void _r8712_join_timeout_handler(struct _adapter *adapter) 1001 { 1002 unsigned long irqL; 1003 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 1004 1005 if (adapter->driver_stopped || adapter->surprise_removed) 1006 return; 1007 spin_lock_irqsave(&pmlmepriv->lock, irqL); 1008 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING); 1009 pmlmepriv->to_join = false; 1010 if (check_fwstate(pmlmepriv, _FW_LINKED)) { 1011 r8712_os_indicate_disconnect(adapter); 1012 _clr_fwstate_(pmlmepriv, _FW_LINKED); 1013 } 1014 if (adapter->pwrctrlpriv.pwr_mode != adapter->registrypriv.power_mgnt) { 1015 r8712_set_ps_mode(adapter, adapter->registrypriv.power_mgnt, 1016 adapter->registrypriv.smart_ps); 1017 } 1018 spin_unlock_irqrestore(&pmlmepriv->lock, irqL); 1019 } 1020 1021 void r8712_scan_timeout_handler (struct _adapter *adapter) 1022 { 1023 unsigned long irqL; 1024 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 1025 1026 spin_lock_irqsave(&pmlmepriv->lock, irqL); 1027 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY); 1028 pmlmepriv->to_join = false; /* scan fail, so clear to_join flag */ 1029 spin_unlock_irqrestore(&pmlmepriv->lock, irqL); 1030 } 1031 1032 void _r8712_dhcp_timeout_handler (struct _adapter *adapter) 1033 { 1034 if (adapter->driver_stopped || adapter->surprise_removed) 1035 return; 1036 if (adapter->pwrctrlpriv.pwr_mode != adapter->registrypriv.power_mgnt) 1037 r8712_set_ps_mode(adapter, adapter->registrypriv.power_mgnt, 1038 adapter->registrypriv.smart_ps); 1039 } 1040 1041 int r8712_select_and_join_from_scan(struct mlme_priv *pmlmepriv) 1042 { 1043 struct list_head *phead; 1044 unsigned char *dst_ssid, *src_ssid; 1045 struct _adapter *adapter; 1046 struct __queue *queue = NULL; 1047 struct wlan_network *pnetwork = NULL; 1048 struct wlan_network *pnetwork_max_rssi = NULL; 1049 1050 adapter = (struct _adapter *)pmlmepriv->nic_hdl; 1051 queue = &pmlmepriv->scanned_queue; 1052 phead = &queue->queue; 1053 pmlmepriv->pscanned = phead->next; 1054 while (1) { 1055 if (end_of_queue_search(phead, pmlmepriv->pscanned)) { 1056 if (pmlmepriv->assoc_by_rssi && pnetwork_max_rssi) { 1057 pnetwork = pnetwork_max_rssi; 1058 goto ask_for_joinbss; 1059 } 1060 return -EINVAL; 1061 } 1062 pnetwork = container_of(pmlmepriv->pscanned, 1063 struct wlan_network, list); 1064 pmlmepriv->pscanned = pmlmepriv->pscanned->next; 1065 if (pmlmepriv->assoc_by_bssid) { 1066 dst_ssid = pnetwork->network.MacAddress; 1067 src_ssid = pmlmepriv->assoc_bssid; 1068 if (!memcmp(dst_ssid, src_ssid, ETH_ALEN)) { 1069 if (check_fwstate(pmlmepriv, _FW_LINKED)) { 1070 if (is_same_network(&pmlmepriv->cur_network.network, 1071 &pnetwork->network)) { 1072 _clr_fwstate_(pmlmepriv, 1073 _FW_UNDER_LINKING); 1074 /*r8712_indicate_connect again*/ 1075 r8712_indicate_connect(adapter); 1076 return 2; 1077 } 1078 r8712_disassoc_cmd(adapter); 1079 r8712_ind_disconnect(adapter); 1080 r8712_free_assoc_resources(adapter); 1081 } 1082 goto ask_for_joinbss; 1083 } 1084 } else if (pmlmepriv->assoc_ssid.SsidLength == 0) { 1085 goto ask_for_joinbss; 1086 } 1087 dst_ssid = pnetwork->network.Ssid.Ssid; 1088 src_ssid = pmlmepriv->assoc_ssid.Ssid; 1089 if ((pnetwork->network.Ssid.SsidLength == 1090 pmlmepriv->assoc_ssid.SsidLength) && 1091 (!memcmp(dst_ssid, src_ssid, 1092 pmlmepriv->assoc_ssid.SsidLength))) { 1093 if (pmlmepriv->assoc_by_rssi) { 1094 /* if the ssid is the same, select the bss 1095 * which has the max rssi 1096 */ 1097 if (pnetwork_max_rssi) { 1098 if (pnetwork->network.Rssi > 1099 pnetwork_max_rssi->network.Rssi) 1100 pnetwork_max_rssi = pnetwork; 1101 } else { 1102 pnetwork_max_rssi = pnetwork; 1103 } 1104 } else if (is_desired_network(adapter, pnetwork)) { 1105 if (check_fwstate(pmlmepriv, _FW_LINKED)) { 1106 r8712_disassoc_cmd(adapter); 1107 r8712_free_assoc_resources(adapter); 1108 } 1109 goto ask_for_joinbss; 1110 } 1111 } 1112 } 1113 1114 ask_for_joinbss: 1115 return r8712_joinbss_cmd(adapter, pnetwork); 1116 } 1117 1118 int r8712_set_auth(struct _adapter *adapter, 1119 struct security_priv *psecuritypriv) 1120 { 1121 struct cmd_priv *pcmdpriv = &adapter->cmdpriv; 1122 struct cmd_obj *pcmd; 1123 struct setauth_parm *psetauthparm; 1124 1125 pcmd = kmalloc(sizeof(*pcmd), GFP_ATOMIC); 1126 if (!pcmd) 1127 return -ENOMEM; 1128 1129 psetauthparm = kzalloc(sizeof(*psetauthparm), GFP_ATOMIC); 1130 if (!psetauthparm) { 1131 kfree(pcmd); 1132 return -ENOMEM; 1133 } 1134 psetauthparm->mode = (u8)psecuritypriv->AuthAlgrthm; 1135 pcmd->cmdcode = _SetAuth_CMD_; 1136 pcmd->parmbuf = (unsigned char *)psetauthparm; 1137 pcmd->cmdsz = sizeof(struct setauth_parm); 1138 pcmd->rsp = NULL; 1139 pcmd->rspsz = 0; 1140 INIT_LIST_HEAD(&pcmd->list); 1141 r8712_enqueue_cmd(pcmdpriv, pcmd); 1142 return 0; 1143 } 1144 1145 int r8712_set_key(struct _adapter *adapter, 1146 struct security_priv *psecuritypriv, 1147 sint keyid) 1148 { 1149 struct cmd_priv *pcmdpriv = &adapter->cmdpriv; 1150 struct cmd_obj *pcmd; 1151 struct setkey_parm *psetkeyparm; 1152 u8 keylen; 1153 int ret; 1154 1155 pcmd = kmalloc(sizeof(*pcmd), GFP_ATOMIC); 1156 if (!pcmd) 1157 return -ENOMEM; 1158 psetkeyparm = kzalloc(sizeof(*psetkeyparm), GFP_ATOMIC); 1159 if (!psetkeyparm) { 1160 ret = -ENOMEM; 1161 goto err_free_cmd; 1162 } 1163 if (psecuritypriv->AuthAlgrthm == 2) { /* 802.1X */ 1164 psetkeyparm->algorithm = 1165 (u8)psecuritypriv->XGrpPrivacy; 1166 } else { /* WEP */ 1167 psetkeyparm->algorithm = 1168 (u8)psecuritypriv->PrivacyAlgrthm; 1169 } 1170 psetkeyparm->keyid = (u8)keyid; 1171 1172 switch (psetkeyparm->algorithm) { 1173 case _WEP40_: 1174 keylen = 5; 1175 memcpy(psetkeyparm->key, 1176 psecuritypriv->DefKey[keyid].skey, keylen); 1177 break; 1178 case _WEP104_: 1179 keylen = 13; 1180 memcpy(psetkeyparm->key, 1181 psecuritypriv->DefKey[keyid].skey, keylen); 1182 break; 1183 case _TKIP_: 1184 if (keyid < 1 || keyid > 2) { 1185 ret = -EINVAL; 1186 goto err_free_parm; 1187 } 1188 keylen = 16; 1189 memcpy(psetkeyparm->key, 1190 &psecuritypriv->XGrpKey[keyid - 1], keylen); 1191 psetkeyparm->grpkey = 1; 1192 break; 1193 case _AES_: 1194 if (keyid < 1 || keyid > 2) { 1195 ret = -EINVAL; 1196 goto err_free_parm; 1197 } 1198 keylen = 16; 1199 memcpy(psetkeyparm->key, 1200 &psecuritypriv->XGrpKey[keyid - 1], keylen); 1201 psetkeyparm->grpkey = 1; 1202 break; 1203 default: 1204 ret = -EINVAL; 1205 goto err_free_parm; 1206 } 1207 pcmd->cmdcode = _SetKey_CMD_; 1208 pcmd->parmbuf = (u8 *)psetkeyparm; 1209 pcmd->cmdsz = (sizeof(struct setkey_parm)); 1210 pcmd->rsp = NULL; 1211 pcmd->rspsz = 0; 1212 INIT_LIST_HEAD(&pcmd->list); 1213 r8712_enqueue_cmd(pcmdpriv, pcmd); 1214 return 0; 1215 1216 err_free_parm: 1217 kfree(psetkeyparm); 1218 err_free_cmd: 1219 kfree(pcmd); 1220 return ret; 1221 } 1222 1223 /* adjust IEs for r8712_joinbss_cmd in WMM */ 1224 int r8712_restruct_wmm_ie(struct _adapter *adapter, u8 *in_ie, u8 *out_ie, 1225 uint in_len, uint initial_out_len) 1226 { 1227 unsigned int ielength = 0; 1228 unsigned int i, j; 1229 1230 i = 12; /* after the fixed IE */ 1231 while (i < in_len) { 1232 ielength = initial_out_len; 1233 if (in_ie[i] == 0xDD && in_ie[i + 2] == 0x00 && 1234 in_ie[i + 3] == 0x50 && in_ie[i + 4] == 0xF2 && 1235 in_ie[i + 5] == 0x02 && i + 5 < in_len) { 1236 /*WMM element ID and OUI*/ 1237 for (j = i; j < i + 9; j++) { 1238 out_ie[ielength] = in_ie[j]; 1239 ielength++; 1240 } 1241 out_ie[initial_out_len + 1] = 0x07; 1242 out_ie[initial_out_len + 6] = 0x00; 1243 out_ie[initial_out_len + 8] = 0x00; 1244 break; 1245 } 1246 i += (in_ie[i + 1] + 2); /* to the next IE element */ 1247 } 1248 return ielength; 1249 } 1250 1251 /* 1252 * Ported from 8185: IsInPreAuthKeyList(). 1253 * 1254 * Search by BSSID, 1255 * Return Value: 1256 * -1 :if there is no pre-auth key in the table 1257 * >=0 :if there is pre-auth key, and return the entry id 1258 */ 1259 static int SecIsInPMKIDList(struct _adapter *Adapter, u8 *bssid) 1260 { 1261 struct security_priv *p = &Adapter->securitypriv; 1262 int i; 1263 1264 for (i = 0; i < NUM_PMKID_CACHE; i++) 1265 if (p->PMKIDList[i].bUsed && !memcmp(p->PMKIDList[i].Bssid, bssid, ETH_ALEN)) 1266 return i; 1267 return -1; 1268 } 1269 1270 sint r8712_restruct_sec_ie(struct _adapter *adapter, u8 *in_ie, 1271 u8 *out_ie, uint in_len) 1272 { 1273 u8 authmode = 0, match; 1274 u8 sec_ie[IW_CUSTOM_MAX], uncst_oui[4], bkup_ie[255]; 1275 u8 wpa_oui[4] = {0x0, 0x50, 0xf2, 0x01}; 1276 uint ielength, cnt, remove_cnt; 1277 int iEntry; 1278 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 1279 struct security_priv *psecuritypriv = &adapter->securitypriv; 1280 uint ndisauthmode = psecuritypriv->ndisauthtype; 1281 uint ndissecuritytype = psecuritypriv->ndisencryptstatus; 1282 1283 if ((ndisauthmode == Ndis802_11AuthModeWPA) || 1284 (ndisauthmode == Ndis802_11AuthModeWPAPSK)) { 1285 authmode = _WPA_IE_ID_; 1286 uncst_oui[0] = 0x0; 1287 uncst_oui[1] = 0x50; 1288 uncst_oui[2] = 0xf2; 1289 } 1290 if ((ndisauthmode == Ndis802_11AuthModeWPA2) || 1291 (ndisauthmode == Ndis802_11AuthModeWPA2PSK)) { 1292 authmode = _WPA2_IE_ID_; 1293 uncst_oui[0] = 0x0; 1294 uncst_oui[1] = 0x0f; 1295 uncst_oui[2] = 0xac; 1296 } 1297 switch (ndissecuritytype) { 1298 case Ndis802_11Encryption1Enabled: 1299 case Ndis802_11Encryption1KeyAbsent: 1300 uncst_oui[3] = 0x1; 1301 break; 1302 case Ndis802_11Encryption2Enabled: 1303 case Ndis802_11Encryption2KeyAbsent: 1304 uncst_oui[3] = 0x2; 1305 break; 1306 case Ndis802_11Encryption3Enabled: 1307 case Ndis802_11Encryption3KeyAbsent: 1308 uncst_oui[3] = 0x4; 1309 break; 1310 default: 1311 break; 1312 } 1313 /*Search required WPA or WPA2 IE and copy to sec_ie[] */ 1314 cnt = 12; 1315 match = false; 1316 while (cnt < in_len) { 1317 if (in_ie[cnt] == authmode) { 1318 if ((authmode == _WPA_IE_ID_) && 1319 (!memcmp(&in_ie[cnt + 2], &wpa_oui[0], 4))) { 1320 memcpy(&sec_ie[0], &in_ie[cnt], 1321 in_ie[cnt + 1] + 2); 1322 match = true; 1323 break; 1324 } 1325 if (authmode == _WPA2_IE_ID_) { 1326 memcpy(&sec_ie[0], &in_ie[cnt], 1327 in_ie[cnt + 1] + 2); 1328 match = true; 1329 break; 1330 } 1331 if (((authmode == _WPA_IE_ID_) && 1332 (!memcmp(&in_ie[cnt + 2], &wpa_oui[0], 4))) || 1333 (authmode == _WPA2_IE_ID_)) 1334 memcpy(&bkup_ie[0], &in_ie[cnt], 1335 in_ie[cnt + 1] + 2); 1336 } 1337 cnt += in_ie[cnt + 1] + 2; /*get next*/ 1338 } 1339 /*restruct WPA IE or WPA2 IE in sec_ie[] */ 1340 if (match) { 1341 if (sec_ie[0] == _WPA_IE_ID_) { 1342 /* parsing SSN IE to select required encryption 1343 * algorithm, and set the bc/mc encryption algorithm 1344 */ 1345 while (true) { 1346 /*check wpa_oui tag*/ 1347 if (memcmp(&sec_ie[2], &wpa_oui[0], 4)) { 1348 match = false; 1349 break; 1350 } 1351 if ((sec_ie[6] != 0x01) || (sec_ie[7] != 0x0)) { 1352 /*IE Ver error*/ 1353 match = false; 1354 break; 1355 } 1356 if (!memcmp(&sec_ie[8], &wpa_oui[0], 3)) { 1357 /* get bc/mc encryption type (group 1358 * key type) 1359 */ 1360 switch (sec_ie[11]) { 1361 case 0x0: /*none*/ 1362 psecuritypriv->XGrpPrivacy = 1363 _NO_PRIVACY_; 1364 break; 1365 case 0x1: /*WEP_40*/ 1366 psecuritypriv->XGrpPrivacy = 1367 _WEP40_; 1368 break; 1369 case 0x2: /*TKIP*/ 1370 psecuritypriv->XGrpPrivacy = 1371 _TKIP_; 1372 break; 1373 case 0x3: /*AESCCMP*/ 1374 case 0x4: 1375 psecuritypriv->XGrpPrivacy = 1376 _AES_; 1377 break; 1378 case 0x5: /*WEP_104*/ 1379 psecuritypriv->XGrpPrivacy = 1380 _WEP104_; 1381 break; 1382 } 1383 } else { 1384 match = false; 1385 break; 1386 } 1387 if (sec_ie[12] == 0x01) { 1388 /*check the unicast encryption type*/ 1389 if (memcmp(&sec_ie[14], 1390 &uncst_oui[0], 4)) { 1391 match = false; 1392 break; 1393 1394 } /*else the uncst_oui is match*/ 1395 } else { /*mixed mode, unicast_enc_type > 1*/ 1396 /*select the uncst_oui and remove 1397 * the other uncst_oui 1398 */ 1399 cnt = sec_ie[12]; 1400 remove_cnt = (cnt - 1) * 4; 1401 sec_ie[12] = 0x01; 1402 memcpy(&sec_ie[14], &uncst_oui[0], 4); 1403 /*remove the other unicast suit*/ 1404 memcpy(&sec_ie[18], 1405 &sec_ie[18 + remove_cnt], 1406 sec_ie[1] - 18 + 2 - 1407 remove_cnt); 1408 sec_ie[1] = sec_ie[1] - remove_cnt; 1409 } 1410 break; 1411 } 1412 } 1413 if (authmode == _WPA2_IE_ID_) { 1414 /* parsing RSN IE to select required encryption 1415 * algorithm, and set the bc/mc encryption algorithm 1416 */ 1417 while (true) { 1418 if ((sec_ie[2] != 0x01) || (sec_ie[3] != 0x0)) { 1419 /*IE Ver error*/ 1420 match = false; 1421 break; 1422 } 1423 if (!memcmp(&sec_ie[4], &uncst_oui[0], 3)) { 1424 /*get bc/mc encryption type*/ 1425 switch (sec_ie[7]) { 1426 case 0x1: /*WEP_40*/ 1427 psecuritypriv->XGrpPrivacy = 1428 _WEP40_; 1429 break; 1430 case 0x2: /*TKIP*/ 1431 psecuritypriv->XGrpPrivacy = 1432 _TKIP_; 1433 break; 1434 case 0x4: /*AESWRAP*/ 1435 psecuritypriv->XGrpPrivacy = 1436 _AES_; 1437 break; 1438 case 0x5: /*WEP_104*/ 1439 psecuritypriv->XGrpPrivacy = 1440 _WEP104_; 1441 break; 1442 default: /*one*/ 1443 psecuritypriv->XGrpPrivacy = 1444 _NO_PRIVACY_; 1445 break; 1446 } 1447 } else { 1448 match = false; 1449 break; 1450 } 1451 if (sec_ie[8] == 0x01) { 1452 /*check the unicast encryption type*/ 1453 if (memcmp(&sec_ie[10], 1454 &uncst_oui[0], 4)) { 1455 match = false; 1456 break; 1457 } /*else the uncst_oui is match*/ 1458 } else { /*mixed mode, unicast_enc_type > 1*/ 1459 /*select the uncst_oui and remove the 1460 * other uncst_oui 1461 */ 1462 cnt = sec_ie[8]; 1463 remove_cnt = (cnt - 1) * 4; 1464 sec_ie[8] = 0x01; 1465 memcpy(&sec_ie[10], &uncst_oui[0], 4); 1466 /*remove the other unicast suit*/ 1467 memcpy(&sec_ie[14], 1468 &sec_ie[14 + remove_cnt], 1469 (sec_ie[1] - 14 + 2 - 1470 remove_cnt)); 1471 sec_ie[1] = sec_ie[1] - remove_cnt; 1472 } 1473 break; 1474 } 1475 } 1476 } 1477 if ((authmode == _WPA_IE_ID_) || (authmode == _WPA2_IE_ID_)) { 1478 /*copy fixed ie*/ 1479 memcpy(out_ie, in_ie, 12); 1480 ielength = 12; 1481 /*copy RSN or SSN*/ 1482 if (match) { 1483 memcpy(&out_ie[ielength], &sec_ie[0], sec_ie[1] + 2); 1484 ielength += sec_ie[1] + 2; 1485 if (authmode == _WPA2_IE_ID_) { 1486 /*the Pre-Authentication bit should be zero*/ 1487 out_ie[ielength - 1] = 0; 1488 out_ie[ielength - 2] = 0; 1489 } 1490 r8712_report_sec_ie(adapter, authmode, sec_ie); 1491 } 1492 } else { 1493 /*copy fixed ie only*/ 1494 memcpy(out_ie, in_ie, 12); 1495 ielength = 12; 1496 if (psecuritypriv->wps_phase) { 1497 memcpy(out_ie + ielength, psecuritypriv->wps_ie, 1498 psecuritypriv->wps_ie_len); 1499 ielength += psecuritypriv->wps_ie_len; 1500 } 1501 } 1502 iEntry = SecIsInPMKIDList(adapter, pmlmepriv->assoc_bssid); 1503 if (iEntry < 0) 1504 return ielength; 1505 if (authmode == _WPA2_IE_ID_) { 1506 out_ie[ielength] = 1; 1507 ielength++; 1508 out_ie[ielength] = 0; /*PMKID count = 0x0100*/ 1509 ielength++; 1510 memcpy(&out_ie[ielength], 1511 &psecuritypriv->PMKIDList[iEntry].PMKID, 16); 1512 ielength += 16; 1513 out_ie[13] += 18;/*PMKID length = 2+16*/ 1514 } 1515 return ielength; 1516 } 1517 1518 void r8712_init_registrypriv_dev_network(struct _adapter *adapter) 1519 { 1520 struct registry_priv *pregistrypriv = &adapter->registrypriv; 1521 struct eeprom_priv *peepriv = &adapter->eeprompriv; 1522 struct wlan_bssid_ex *pdev_network = &pregistrypriv->dev_network; 1523 u8 *myhwaddr = myid(peepriv); 1524 1525 memcpy(pdev_network->MacAddress, myhwaddr, ETH_ALEN); 1526 memcpy(&pdev_network->Ssid, &pregistrypriv->ssid, 1527 sizeof(struct ndis_802_11_ssid)); 1528 pdev_network->Configuration.Length = 1529 sizeof(struct NDIS_802_11_CONFIGURATION); 1530 pdev_network->Configuration.BeaconPeriod = 100; 1531 pdev_network->Configuration.FHConfig.Length = 0; 1532 pdev_network->Configuration.FHConfig.HopPattern = 0; 1533 pdev_network->Configuration.FHConfig.HopSet = 0; 1534 pdev_network->Configuration.FHConfig.DwellTime = 0; 1535 } 1536 1537 void r8712_update_registrypriv_dev_network(struct _adapter *adapter) 1538 { 1539 int sz = 0; 1540 struct registry_priv *pregistrypriv = &adapter->registrypriv; 1541 struct wlan_bssid_ex *pdev_network = &pregistrypriv->dev_network; 1542 struct security_priv *psecuritypriv = &adapter->securitypriv; 1543 struct wlan_network *cur_network = &adapter->mlmepriv.cur_network; 1544 1545 pdev_network->Privacy = cpu_to_le32(psecuritypriv->PrivacyAlgrthm 1546 > 0 ? 1 : 0); /* adhoc no 802.1x */ 1547 pdev_network->Rssi = 0; 1548 switch (pregistrypriv->wireless_mode) { 1549 case WIRELESS_11B: 1550 pdev_network->NetworkTypeInUse = Ndis802_11DS; 1551 break; 1552 case WIRELESS_11G: 1553 case WIRELESS_11BG: 1554 pdev_network->NetworkTypeInUse = Ndis802_11OFDM24; 1555 break; 1556 case WIRELESS_11A: 1557 pdev_network->NetworkTypeInUse = Ndis802_11OFDM5; 1558 break; 1559 default: 1560 /* TODO */ 1561 break; 1562 } 1563 pdev_network->Configuration.DSConfig = pregistrypriv->channel; 1564 if (cur_network->network.InfrastructureMode == Ndis802_11IBSS) 1565 pdev_network->Configuration.ATIMWindow = 3; 1566 pdev_network->InfrastructureMode = cur_network->network.InfrastructureMode; 1567 /* 1. Supported rates 1568 * 2. IE 1569 */ 1570 sz = r8712_generate_ie(pregistrypriv); 1571 pdev_network->IELength = sz; 1572 pdev_network->Length = r8712_get_wlan_bssid_ex_sz(pdev_network); 1573 } 1574 1575 /*the function is at passive_level*/ 1576 void r8712_joinbss_reset(struct _adapter *padapter) 1577 { 1578 int i; 1579 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1580 struct ht_priv *phtpriv = &pmlmepriv->htpriv; 1581 1582 /* todo: if you want to do something io/reg/hw setting before join_bss, 1583 * please add code here 1584 */ 1585 phtpriv->ampdu_enable = false;/*reset to disabled*/ 1586 for (i = 0; i < 16; i++) 1587 phtpriv->baddbareq_issued[i] = false;/*reset it*/ 1588 if (phtpriv->ht_option) { 1589 /* validate usb rx aggregation */ 1590 r8712_write8(padapter, 0x102500D9, 48);/*TH = 48 pages, 6k*/ 1591 } else { 1592 /* invalidate usb rx aggregation */ 1593 /* TH=1 => means that invalidate usb rx aggregation */ 1594 r8712_write8(padapter, 0x102500D9, 1); 1595 } 1596 } 1597 1598 /*the function is >= passive_level*/ 1599 unsigned int r8712_restructure_ht_ie(struct _adapter *padapter, u8 *in_ie, 1600 u8 *out_ie, uint in_len, uint *pout_len) 1601 { 1602 u32 ielen, out_len; 1603 unsigned char *p; 1604 struct ieee80211_ht_cap ht_capie; 1605 unsigned char WMM_IE[] = {0x00, 0x50, 0xf2, 0x02, 0x00, 0x01, 0x00}; 1606 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1607 struct qos_priv *pqospriv = &pmlmepriv->qospriv; 1608 struct ht_priv *phtpriv = &pmlmepriv->htpriv; 1609 1610 phtpriv->ht_option = 0; 1611 p = r8712_get_ie(in_ie + 12, WLAN_EID_HT_CAPABILITY, &ielen, in_len - 12); 1612 if (p && (ielen > 0)) { 1613 if (pqospriv->qos_option == 0) { 1614 out_len = *pout_len; 1615 r8712_set_ie(out_ie + out_len, WLAN_EID_VENDOR_SPECIFIC, 1616 _WMM_IE_Length_, WMM_IE, pout_len); 1617 pqospriv->qos_option = 1; 1618 } 1619 out_len = *pout_len; 1620 memset(&ht_capie, 0, sizeof(struct ieee80211_ht_cap)); 1621 ht_capie.cap_info = cpu_to_le16(IEEE80211_HT_CAP_SUP_WIDTH_20_40 | 1622 IEEE80211_HT_CAP_SGI_20 | 1623 IEEE80211_HT_CAP_SGI_40 | 1624 IEEE80211_HT_CAP_TX_STBC | 1625 IEEE80211_HT_CAP_MAX_AMSDU | 1626 IEEE80211_HT_CAP_DSSSCCK40); 1627 ht_capie.ampdu_params_info = (IEEE80211_HT_AMPDU_PARM_FACTOR & 1628 0x03) | (IEEE80211_HT_AMPDU_PARM_DENSITY & 0x00); 1629 r8712_set_ie(out_ie + out_len, WLAN_EID_HT_CAPABILITY, 1630 sizeof(struct ieee80211_ht_cap), 1631 (unsigned char *)&ht_capie, pout_len); 1632 phtpriv->ht_option = 1; 1633 } 1634 return phtpriv->ht_option; 1635 } 1636 1637 /* the function is > passive_level (in critical_section) */ 1638 static void update_ht_cap(struct _adapter *padapter, u8 *pie, uint ie_len) 1639 { 1640 u8 *p, max_ampdu_sz; 1641 int i; 1642 uint len; 1643 struct sta_info *bmc_sta, *psta; 1644 struct ieee80211_ht_cap *pht_capie; 1645 struct recv_reorder_ctrl *preorder_ctrl; 1646 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1647 struct ht_priv *phtpriv = &pmlmepriv->htpriv; 1648 struct registry_priv *pregistrypriv = &padapter->registrypriv; 1649 struct wlan_network *pcur_network = &(pmlmepriv->cur_network); 1650 1651 if (!phtpriv->ht_option) 1652 return; 1653 /* maybe needs check if ap supports rx ampdu. */ 1654 if (!phtpriv->ampdu_enable && 1655 (pregistrypriv->ampdu_enable == 1)) 1656 phtpriv->ampdu_enable = true; 1657 /*check Max Rx A-MPDU Size*/ 1658 len = 0; 1659 p = r8712_get_ie(pie + sizeof(struct NDIS_802_11_FIXED_IEs), 1660 WLAN_EID_HT_CAPABILITY, 1661 &len, ie_len - 1662 sizeof(struct NDIS_802_11_FIXED_IEs)); 1663 if (p && len > 0) { 1664 pht_capie = (struct ieee80211_ht_cap *)(p + 2); 1665 max_ampdu_sz = (pht_capie->ampdu_params_info & 1666 IEEE80211_HT_AMPDU_PARM_FACTOR); 1667 /* max_ampdu_sz (kbytes); */ 1668 max_ampdu_sz = 1 << (max_ampdu_sz + 3); 1669 phtpriv->rx_ampdu_maxlen = max_ampdu_sz; 1670 } 1671 /* for A-MPDU Rx reordering buffer control for bmc_sta & sta_info 1672 * if A-MPDU Rx is enabled, resetting rx_ordering_ctrl 1673 * wstart_b(indicate_seq) to default value=0xffff 1674 * todo: check if AP can send A-MPDU packets 1675 */ 1676 bmc_sta = r8712_get_bcmc_stainfo(padapter); 1677 if (bmc_sta) { 1678 for (i = 0; i < 16; i++) { 1679 preorder_ctrl = &bmc_sta->recvreorder_ctrl[i]; 1680 preorder_ctrl->indicate_seq = 0xffff; 1681 preorder_ctrl->wend_b = 0xffff; 1682 } 1683 } 1684 psta = r8712_get_stainfo(&padapter->stapriv, 1685 pcur_network->network.MacAddress); 1686 if (psta) { 1687 for (i = 0; i < 16; i++) { 1688 preorder_ctrl = &psta->recvreorder_ctrl[i]; 1689 preorder_ctrl->indicate_seq = 0xffff; 1690 preorder_ctrl->wend_b = 0xffff; 1691 } 1692 } 1693 len = 0; 1694 p = r8712_get_ie(pie + sizeof(struct NDIS_802_11_FIXED_IEs), 1695 WLAN_EID_HT_OPERATION, &len, 1696 ie_len - sizeof(struct NDIS_802_11_FIXED_IEs)); 1697 } 1698 1699 void r8712_issue_addbareq_cmd(struct _adapter *padapter, int priority) 1700 { 1701 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1702 struct ht_priv *phtpriv = &pmlmepriv->htpriv; 1703 1704 if ((phtpriv->ht_option == 1) && (phtpriv->ampdu_enable)) { 1705 if (!phtpriv->baddbareq_issued[priority]) { 1706 r8712_addbareq_cmd(padapter, (u8)priority); 1707 phtpriv->baddbareq_issued[priority] = true; 1708 } 1709 } 1710 } 1711