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 = adapter-> 777 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, 0, 788 sizeof(union pn48)); 789 memset((u8 *)&ptarget_sta->rxpn, 0, 790 sizeof(union pn48)); 791 } 792 } else { 793 if (check_fwstate(pmlmepriv, 794 _FW_UNDER_LINKING)) 795 pmlmepriv->fw_state ^= 796 _FW_UNDER_LINKING; 797 goto ignore_joinbss_callback; 798 } 799 } 800 801 /*s3. update cur_network & indicate connect*/ 802 memcpy(&cur_network->network, &pnetwork->network, 803 pnetwork->network.Length); 804 cur_network->aid = pnetwork->join_res; 805 /*update fw_state will clr _FW_UNDER_LINKING*/ 806 switch (pnetwork->network.InfrastructureMode) { 807 case Ndis802_11Infrastructure: 808 pmlmepriv->fw_state = WIFI_STATION_STATE; 809 break; 810 case Ndis802_11IBSS: 811 pmlmepriv->fw_state = WIFI_ADHOC_STATE; 812 break; 813 default: 814 pmlmepriv->fw_state = WIFI_NULL_STATE; 815 break; 816 } 817 r8712_update_protection(adapter, 818 (cur_network->network.IEs) + 819 sizeof(struct NDIS_802_11_FIXED_IEs), 820 (cur_network->network.IELength)); 821 /*TODO: update HT_Capability*/ 822 update_ht_cap(adapter, cur_network->network.IEs, 823 cur_network->network.IELength); 824 /*indicate connect*/ 825 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) 826 r8712_indicate_connect(adapter); 827 del_timer(&pmlmepriv->assoc_timer); 828 } else { 829 goto ignore_joinbss_callback; 830 } 831 } else { 832 if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) { 833 mod_timer(&pmlmepriv->assoc_timer, 834 jiffies + msecs_to_jiffies(1)); 835 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING); 836 } 837 } 838 ignore_joinbss_callback: 839 spin_unlock_irqrestore(&pmlmepriv->lock, irqL); 840 if (sizeof(struct list_head) == 4 * sizeof(u32)) 841 kfree(pnetwork); 842 } 843 844 void r8712_stassoc_event_callback(struct _adapter *adapter, u8 *pbuf) 845 { 846 unsigned long irqL; 847 struct sta_info *psta; 848 struct mlme_priv *pmlmepriv = &(adapter->mlmepriv); 849 struct stassoc_event *pstassoc = (struct stassoc_event *)pbuf; 850 851 /* to do: */ 852 if (!r8712_access_ctrl(&adapter->acl_list, pstassoc->macaddr)) 853 return; 854 psta = r8712_get_stainfo(&adapter->stapriv, pstassoc->macaddr); 855 if (psta) { 856 /*the sta have been in sta_info_queue => do nothing 857 *(between drv has received this event before and 858 * fw have not yet to set key to CAM_ENTRY) 859 */ 860 return; 861 } 862 863 psta = r8712_alloc_stainfo(&adapter->stapriv, pstassoc->macaddr); 864 if (!psta) 865 return; 866 /* to do : init sta_info variable */ 867 psta->qos_option = 0; 868 psta->mac_id = le32_to_cpu(pstassoc->cam_id); 869 /* psta->aid = (uint)pstassoc->cam_id; */ 870 871 if (adapter->securitypriv.AuthAlgrthm == 2) 872 psta->XPrivacy = adapter->securitypriv.PrivacyAlgrthm; 873 psta->ieee8021x_blocked = false; 874 spin_lock_irqsave(&pmlmepriv->lock, irqL); 875 if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) || 876 check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) { 877 if (adapter->stapriv.asoc_sta_count == 2) { 878 /* a sta + bc/mc_stainfo (not Ibss_stainfo) */ 879 r8712_indicate_connect(adapter); 880 } 881 } 882 spin_unlock_irqrestore(&pmlmepriv->lock, irqL); 883 } 884 885 void r8712_stadel_event_callback(struct _adapter *adapter, u8 *pbuf) 886 { 887 unsigned long irqL, irqL2; 888 struct sta_info *psta; 889 struct wlan_network *pwlan = NULL; 890 struct wlan_bssid_ex *pdev_network = NULL; 891 u8 *pibss = NULL; 892 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 893 struct stadel_event *pstadel = (struct stadel_event *)pbuf; 894 struct sta_priv *pstapriv = &adapter->stapriv; 895 struct wlan_network *tgt_network = &pmlmepriv->cur_network; 896 897 spin_lock_irqsave(&pmlmepriv->lock, irqL2); 898 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) { 899 r8712_ind_disconnect(adapter); 900 r8712_free_assoc_resources(adapter); 901 } 902 if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE | 903 WIFI_ADHOC_STATE)) { 904 psta = r8712_get_stainfo(&adapter->stapriv, pstadel->macaddr); 905 spin_lock_irqsave(&pstapriv->sta_hash_lock, irqL); 906 r8712_free_stainfo(adapter, psta); 907 spin_unlock_irqrestore(&pstapriv->sta_hash_lock, irqL); 908 if (adapter->stapriv.asoc_sta_count == 1) { 909 /*a sta + bc/mc_stainfo (not Ibss_stainfo) */ 910 pwlan = r8712_find_network(&pmlmepriv->scanned_queue, 911 tgt_network->network.MacAddress); 912 if (pwlan) { 913 pwlan->fixed = false; 914 free_network_nolock(pmlmepriv, pwlan); 915 } 916 /*re-create ibss*/ 917 pdev_network = &(adapter->registrypriv.dev_network); 918 pibss = adapter->registrypriv.dev_network.MacAddress; 919 memcpy(pdev_network, &tgt_network->network, 920 r8712_get_wlan_bssid_ex_sz(&tgt_network->network)); 921 memcpy(&pdev_network->Ssid, 922 &pmlmepriv->assoc_ssid, 923 sizeof(struct ndis_802_11_ssid)); 924 r8712_update_registrypriv_dev_network(adapter); 925 r8712_generate_random_ibss(pibss); 926 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) { 927 _clr_fwstate_(pmlmepriv, WIFI_ADHOC_STATE); 928 set_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE); 929 } 930 } 931 } 932 spin_unlock_irqrestore(&pmlmepriv->lock, irqL2); 933 } 934 935 void r8712_cpwm_event_callback(struct _adapter *adapter, u8 *pbuf) 936 { 937 struct reportpwrstate_parm *preportpwrstate = 938 (struct reportpwrstate_parm *)pbuf; 939 940 preportpwrstate->state |= (u8)(adapter->pwrctrlpriv.cpwm_tog + 0x80); 941 r8712_cpwm_int_hdl(adapter, preportpwrstate); 942 } 943 944 /* When the Netgear 3500 AP is with WPA2PSK-AES mode, it will send 945 * the ADDBA req frame with start seq control = 0 to wifi client after 946 * the WPA handshake and the seqence number of following data packet 947 * will be 0. In this case, the Rx reorder sequence is not longer than 0 948 * and the WiFi client will drop the data with seq number 0. 949 * So, the 8712 firmware has to inform driver with receiving the 950 * ADDBA-Req frame so that the driver can reset the 951 * sequence value of Rx reorder control. 952 */ 953 void r8712_got_addbareq_event_callback(struct _adapter *adapter, u8 *pbuf) 954 { 955 struct ADDBA_Req_Report_parm *pAddbareq_pram = 956 (struct ADDBA_Req_Report_parm *)pbuf; 957 struct sta_info *psta; 958 struct sta_priv *pstapriv = &adapter->stapriv; 959 struct recv_reorder_ctrl *precvreorder_ctrl = NULL; 960 961 psta = r8712_get_stainfo(pstapriv, pAddbareq_pram->MacAddress); 962 if (psta) { 963 precvreorder_ctrl = 964 &psta->recvreorder_ctrl[pAddbareq_pram->tid]; 965 /* set the indicate_seq to 0xffff so that the rx reorder 966 * can store any following data packet. 967 */ 968 precvreorder_ctrl->indicate_seq = 0xffff; 969 } 970 } 971 972 void r8712_wpspbc_event_callback(struct _adapter *adapter, u8 *pbuf) 973 { 974 if (!adapter->securitypriv.wps_hw_pbc_pressed) 975 adapter->securitypriv.wps_hw_pbc_pressed = true; 976 } 977 978 void _r8712_sitesurvey_ctrl_handler(struct _adapter *adapter) 979 { 980 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 981 struct sitesurvey_ctrl *psitesurveyctrl = &pmlmepriv->sitesurveyctrl; 982 struct registry_priv *pregistrypriv = &adapter->registrypriv; 983 u64 current_tx_pkts; 984 uint current_rx_pkts; 985 986 current_tx_pkts = (adapter->xmitpriv.tx_pkts) - 987 (psitesurveyctrl->last_tx_pkts); 988 current_rx_pkts = (adapter->recvpriv.rx_pkts) - 989 (psitesurveyctrl->last_rx_pkts); 990 psitesurveyctrl->last_tx_pkts = adapter->xmitpriv.tx_pkts; 991 psitesurveyctrl->last_rx_pkts = adapter->recvpriv.rx_pkts; 992 if ((current_tx_pkts > pregistrypriv->busy_thresh) || 993 (current_rx_pkts > pregistrypriv->busy_thresh)) 994 psitesurveyctrl->traffic_busy = true; 995 else 996 psitesurveyctrl->traffic_busy = false; 997 } 998 999 void _r8712_join_timeout_handler(struct _adapter *adapter) 1000 { 1001 unsigned long irqL; 1002 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 1003 1004 if (adapter->driver_stopped || adapter->surprise_removed) 1005 return; 1006 spin_lock_irqsave(&pmlmepriv->lock, irqL); 1007 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING); 1008 pmlmepriv->to_join = false; 1009 if (check_fwstate(pmlmepriv, _FW_LINKED)) { 1010 r8712_os_indicate_disconnect(adapter); 1011 _clr_fwstate_(pmlmepriv, _FW_LINKED); 1012 } 1013 if (adapter->pwrctrlpriv.pwr_mode != adapter->registrypriv.power_mgnt) { 1014 r8712_set_ps_mode(adapter, adapter->registrypriv.power_mgnt, 1015 adapter->registrypriv.smart_ps); 1016 } 1017 spin_unlock_irqrestore(&pmlmepriv->lock, irqL); 1018 } 1019 1020 void r8712_scan_timeout_handler (struct _adapter *adapter) 1021 { 1022 unsigned long irqL; 1023 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 1024 1025 spin_lock_irqsave(&pmlmepriv->lock, irqL); 1026 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY); 1027 pmlmepriv->to_join = false; /* scan fail, so clear to_join flag */ 1028 spin_unlock_irqrestore(&pmlmepriv->lock, irqL); 1029 } 1030 1031 void _r8712_dhcp_timeout_handler (struct _adapter *adapter) 1032 { 1033 if (adapter->driver_stopped || adapter->surprise_removed) 1034 return; 1035 if (adapter->pwrctrlpriv.pwr_mode != adapter->registrypriv.power_mgnt) 1036 r8712_set_ps_mode(adapter, adapter->registrypriv.power_mgnt, 1037 adapter->registrypriv.smart_ps); 1038 } 1039 1040 int r8712_select_and_join_from_scan(struct mlme_priv *pmlmepriv) 1041 { 1042 struct list_head *phead; 1043 unsigned char *dst_ssid, *src_ssid; 1044 struct _adapter *adapter; 1045 struct __queue *queue = NULL; 1046 struct wlan_network *pnetwork = NULL; 1047 struct wlan_network *pnetwork_max_rssi = NULL; 1048 1049 adapter = (struct _adapter *)pmlmepriv->nic_hdl; 1050 queue = &pmlmepriv->scanned_queue; 1051 phead = &queue->queue; 1052 pmlmepriv->pscanned = phead->next; 1053 while (1) { 1054 if (end_of_queue_search(phead, pmlmepriv->pscanned)) { 1055 if (pmlmepriv->assoc_by_rssi && pnetwork_max_rssi) { 1056 pnetwork = pnetwork_max_rssi; 1057 goto ask_for_joinbss; 1058 } 1059 return -EINVAL; 1060 } 1061 pnetwork = container_of(pmlmepriv->pscanned, 1062 struct wlan_network, list); 1063 pmlmepriv->pscanned = pmlmepriv->pscanned->next; 1064 if (pmlmepriv->assoc_by_bssid) { 1065 dst_ssid = pnetwork->network.MacAddress; 1066 src_ssid = pmlmepriv->assoc_bssid; 1067 if (!memcmp(dst_ssid, src_ssid, ETH_ALEN)) { 1068 if (check_fwstate(pmlmepriv, _FW_LINKED)) { 1069 if (is_same_network(&pmlmepriv->cur_network.network, 1070 &pnetwork->network)) { 1071 _clr_fwstate_(pmlmepriv, 1072 _FW_UNDER_LINKING); 1073 /*r8712_indicate_connect again*/ 1074 r8712_indicate_connect(adapter); 1075 return 2; 1076 } 1077 r8712_disassoc_cmd(adapter); 1078 r8712_ind_disconnect(adapter); 1079 r8712_free_assoc_resources(adapter); 1080 } 1081 goto ask_for_joinbss; 1082 } 1083 } else if (pmlmepriv->assoc_ssid.SsidLength == 0) { 1084 goto ask_for_joinbss; 1085 } 1086 dst_ssid = pnetwork->network.Ssid.Ssid; 1087 src_ssid = pmlmepriv->assoc_ssid.Ssid; 1088 if ((pnetwork->network.Ssid.SsidLength == 1089 pmlmepriv->assoc_ssid.SsidLength) && 1090 (!memcmp(dst_ssid, src_ssid, 1091 pmlmepriv->assoc_ssid.SsidLength))) { 1092 if (pmlmepriv->assoc_by_rssi) { 1093 /* if the ssid is the same, select the bss 1094 * which has the max rssi 1095 */ 1096 if (pnetwork_max_rssi) { 1097 if (pnetwork->network.Rssi > 1098 pnetwork_max_rssi->network.Rssi) 1099 pnetwork_max_rssi = pnetwork; 1100 } else { 1101 pnetwork_max_rssi = pnetwork; 1102 } 1103 } else if (is_desired_network(adapter, pnetwork)) { 1104 if (check_fwstate(pmlmepriv, _FW_LINKED)) { 1105 r8712_disassoc_cmd(adapter); 1106 r8712_free_assoc_resources(adapter); 1107 } 1108 goto ask_for_joinbss; 1109 } 1110 } 1111 } 1112 1113 ask_for_joinbss: 1114 return r8712_joinbss_cmd(adapter, pnetwork); 1115 } 1116 1117 int r8712_set_auth(struct _adapter *adapter, 1118 struct security_priv *psecuritypriv) 1119 { 1120 struct cmd_priv *pcmdpriv = &adapter->cmdpriv; 1121 struct cmd_obj *pcmd; 1122 struct setauth_parm *psetauthparm; 1123 1124 pcmd = kmalloc(sizeof(*pcmd), GFP_ATOMIC); 1125 if (!pcmd) 1126 return -ENOMEM; 1127 1128 psetauthparm = kzalloc(sizeof(*psetauthparm), GFP_ATOMIC); 1129 if (!psetauthparm) { 1130 kfree(pcmd); 1131 return -ENOMEM; 1132 } 1133 psetauthparm->mode = (u8)psecuritypriv->AuthAlgrthm; 1134 pcmd->cmdcode = _SetAuth_CMD_; 1135 pcmd->parmbuf = (unsigned char *)psetauthparm; 1136 pcmd->cmdsz = sizeof(struct setauth_parm); 1137 pcmd->rsp = NULL; 1138 pcmd->rspsz = 0; 1139 INIT_LIST_HEAD(&pcmd->list); 1140 r8712_enqueue_cmd(pcmdpriv, pcmd); 1141 return 0; 1142 } 1143 1144 int r8712_set_key(struct _adapter *adapter, 1145 struct security_priv *psecuritypriv, 1146 sint keyid) 1147 { 1148 struct cmd_priv *pcmdpriv = &adapter->cmdpriv; 1149 struct cmd_obj *pcmd; 1150 struct setkey_parm *psetkeyparm; 1151 u8 keylen; 1152 int ret; 1153 1154 pcmd = kmalloc(sizeof(*pcmd), GFP_ATOMIC); 1155 if (!pcmd) 1156 return -ENOMEM; 1157 psetkeyparm = kzalloc(sizeof(*psetkeyparm), GFP_ATOMIC); 1158 if (!psetkeyparm) { 1159 ret = -ENOMEM; 1160 goto err_free_cmd; 1161 } 1162 if (psecuritypriv->AuthAlgrthm == 2) { /* 802.1X */ 1163 psetkeyparm->algorithm = 1164 (u8)psecuritypriv->XGrpPrivacy; 1165 } else { /* WEP */ 1166 psetkeyparm->algorithm = 1167 (u8)psecuritypriv->PrivacyAlgrthm; 1168 } 1169 psetkeyparm->keyid = (u8)keyid; 1170 1171 switch (psetkeyparm->algorithm) { 1172 case _WEP40_: 1173 keylen = 5; 1174 memcpy(psetkeyparm->key, 1175 psecuritypriv->DefKey[keyid].skey, keylen); 1176 break; 1177 case _WEP104_: 1178 keylen = 13; 1179 memcpy(psetkeyparm->key, 1180 psecuritypriv->DefKey[keyid].skey, keylen); 1181 break; 1182 case _TKIP_: 1183 if (keyid < 1 || keyid > 2) { 1184 ret = -EINVAL; 1185 goto err_free_parm; 1186 } 1187 keylen = 16; 1188 memcpy(psetkeyparm->key, 1189 &psecuritypriv->XGrpKey[keyid - 1], keylen); 1190 psetkeyparm->grpkey = 1; 1191 break; 1192 case _AES_: 1193 if (keyid < 1 || keyid > 2) { 1194 ret = -EINVAL; 1195 goto err_free_parm; 1196 } 1197 keylen = 16; 1198 memcpy(psetkeyparm->key, 1199 &psecuritypriv->XGrpKey[keyid - 1], keylen); 1200 psetkeyparm->grpkey = 1; 1201 break; 1202 default: 1203 ret = -EINVAL; 1204 goto err_free_parm; 1205 } 1206 pcmd->cmdcode = _SetKey_CMD_; 1207 pcmd->parmbuf = (u8 *)psetkeyparm; 1208 pcmd->cmdsz = (sizeof(struct setkey_parm)); 1209 pcmd->rsp = NULL; 1210 pcmd->rspsz = 0; 1211 INIT_LIST_HEAD(&pcmd->list); 1212 r8712_enqueue_cmd(pcmdpriv, pcmd); 1213 return 0; 1214 1215 err_free_parm: 1216 kfree(psetkeyparm); 1217 err_free_cmd: 1218 kfree(pcmd); 1219 return ret; 1220 } 1221 1222 /* adjust IEs for r8712_joinbss_cmd in WMM */ 1223 int r8712_restruct_wmm_ie(struct _adapter *adapter, u8 *in_ie, u8 *out_ie, 1224 uint in_len, uint initial_out_len) 1225 { 1226 unsigned int ielength = 0; 1227 unsigned int i, j; 1228 1229 i = 12; /* after the fixed IE */ 1230 while (i < in_len) { 1231 ielength = initial_out_len; 1232 if (in_ie[i] == 0xDD && in_ie[i + 2] == 0x00 && 1233 in_ie[i + 3] == 0x50 && in_ie[i + 4] == 0xF2 && 1234 in_ie[i + 5] == 0x02 && i + 5 < in_len) { 1235 /*WMM element ID and OUI*/ 1236 for (j = i; j < i + 9; j++) { 1237 out_ie[ielength] = in_ie[j]; 1238 ielength++; 1239 } 1240 out_ie[initial_out_len + 1] = 0x07; 1241 out_ie[initial_out_len + 6] = 0x00; 1242 out_ie[initial_out_len + 8] = 0x00; 1243 break; 1244 } 1245 i += (in_ie[i + 1] + 2); /* to the next IE element */ 1246 } 1247 return ielength; 1248 } 1249 1250 /* 1251 * Ported from 8185: IsInPreAuthKeyList(). 1252 * 1253 * Search by BSSID, 1254 * Return Value: 1255 * -1 :if there is no pre-auth key in the table 1256 * >=0 :if there is pre-auth key, and return the entry id 1257 */ 1258 static int SecIsInPMKIDList(struct _adapter *Adapter, u8 *bssid) 1259 { 1260 struct security_priv *p = &Adapter->securitypriv; 1261 int i; 1262 1263 for (i = 0; i < NUM_PMKID_CACHE; i++) 1264 if (p->PMKIDList[i].bUsed && !memcmp(p->PMKIDList[i].Bssid, bssid, ETH_ALEN)) 1265 return i; 1266 return -1; 1267 } 1268 1269 sint r8712_restruct_sec_ie(struct _adapter *adapter, u8 *in_ie, 1270 u8 *out_ie, uint in_len) 1271 { 1272 u8 authmode = 0, match; 1273 u8 sec_ie[IW_CUSTOM_MAX], uncst_oui[4], bkup_ie[255]; 1274 u8 wpa_oui[4] = {0x0, 0x50, 0xf2, 0x01}; 1275 uint ielength, cnt, remove_cnt; 1276 int iEntry; 1277 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 1278 struct security_priv *psecuritypriv = &adapter->securitypriv; 1279 uint ndisauthmode = psecuritypriv->ndisauthtype; 1280 uint ndissecuritytype = psecuritypriv->ndisencryptstatus; 1281 1282 if ((ndisauthmode == Ndis802_11AuthModeWPA) || 1283 (ndisauthmode == Ndis802_11AuthModeWPAPSK)) { 1284 authmode = _WPA_IE_ID_; 1285 uncst_oui[0] = 0x0; 1286 uncst_oui[1] = 0x50; 1287 uncst_oui[2] = 0xf2; 1288 } 1289 if ((ndisauthmode == Ndis802_11AuthModeWPA2) || 1290 (ndisauthmode == Ndis802_11AuthModeWPA2PSK)) { 1291 authmode = _WPA2_IE_ID_; 1292 uncst_oui[0] = 0x0; 1293 uncst_oui[1] = 0x0f; 1294 uncst_oui[2] = 0xac; 1295 } 1296 switch (ndissecuritytype) { 1297 case Ndis802_11Encryption1Enabled: 1298 case Ndis802_11Encryption1KeyAbsent: 1299 uncst_oui[3] = 0x1; 1300 break; 1301 case Ndis802_11Encryption2Enabled: 1302 case Ndis802_11Encryption2KeyAbsent: 1303 uncst_oui[3] = 0x2; 1304 break; 1305 case Ndis802_11Encryption3Enabled: 1306 case Ndis802_11Encryption3KeyAbsent: 1307 uncst_oui[3] = 0x4; 1308 break; 1309 default: 1310 break; 1311 } 1312 /*Search required WPA or WPA2 IE and copy to sec_ie[] */ 1313 cnt = 12; 1314 match = false; 1315 while (cnt < in_len) { 1316 if (in_ie[cnt] == authmode) { 1317 if ((authmode == _WPA_IE_ID_) && 1318 (!memcmp(&in_ie[cnt + 2], &wpa_oui[0], 4))) { 1319 memcpy(&sec_ie[0], &in_ie[cnt], 1320 in_ie[cnt + 1] + 2); 1321 match = true; 1322 break; 1323 } 1324 if (authmode == _WPA2_IE_ID_) { 1325 memcpy(&sec_ie[0], &in_ie[cnt], 1326 in_ie[cnt + 1] + 2); 1327 match = true; 1328 break; 1329 } 1330 if (((authmode == _WPA_IE_ID_) && 1331 (!memcmp(&in_ie[cnt + 2], &wpa_oui[0], 4))) || 1332 (authmode == _WPA2_IE_ID_)) 1333 memcpy(&bkup_ie[0], &in_ie[cnt], 1334 in_ie[cnt + 1] + 2); 1335 } 1336 cnt += in_ie[cnt + 1] + 2; /*get next*/ 1337 } 1338 /*restruct WPA IE or WPA2 IE in sec_ie[] */ 1339 if (match) { 1340 if (sec_ie[0] == _WPA_IE_ID_) { 1341 /* parsing SSN IE to select required encryption 1342 * algorithm, and set the bc/mc encryption algorithm 1343 */ 1344 while (true) { 1345 /*check wpa_oui tag*/ 1346 if (memcmp(&sec_ie[2], &wpa_oui[0], 4)) { 1347 match = false; 1348 break; 1349 } 1350 if ((sec_ie[6] != 0x01) || (sec_ie[7] != 0x0)) { 1351 /*IE Ver error*/ 1352 match = false; 1353 break; 1354 } 1355 if (!memcmp(&sec_ie[8], &wpa_oui[0], 3)) { 1356 /* get bc/mc encryption type (group 1357 * key type) 1358 */ 1359 switch (sec_ie[11]) { 1360 case 0x0: /*none*/ 1361 psecuritypriv->XGrpPrivacy = 1362 _NO_PRIVACY_; 1363 break; 1364 case 0x1: /*WEP_40*/ 1365 psecuritypriv->XGrpPrivacy = 1366 _WEP40_; 1367 break; 1368 case 0x2: /*TKIP*/ 1369 psecuritypriv->XGrpPrivacy = 1370 _TKIP_; 1371 break; 1372 case 0x3: /*AESCCMP*/ 1373 case 0x4: 1374 psecuritypriv->XGrpPrivacy = 1375 _AES_; 1376 break; 1377 case 0x5: /*WEP_104*/ 1378 psecuritypriv->XGrpPrivacy = 1379 _WEP104_; 1380 break; 1381 } 1382 } else { 1383 match = false; 1384 break; 1385 } 1386 if (sec_ie[12] == 0x01) { 1387 /*check the unicast encryption type*/ 1388 if (memcmp(&sec_ie[14], 1389 &uncst_oui[0], 4)) { 1390 match = false; 1391 break; 1392 1393 } /*else the uncst_oui is match*/ 1394 } else { /*mixed mode, unicast_enc_type > 1*/ 1395 /*select the uncst_oui and remove 1396 * the other uncst_oui 1397 */ 1398 cnt = sec_ie[12]; 1399 remove_cnt = (cnt - 1) * 4; 1400 sec_ie[12] = 0x01; 1401 memcpy(&sec_ie[14], &uncst_oui[0], 4); 1402 /*remove the other unicast suit*/ 1403 memcpy(&sec_ie[18], 1404 &sec_ie[18 + remove_cnt], 1405 sec_ie[1] - 18 + 2 - 1406 remove_cnt); 1407 sec_ie[1] = sec_ie[1] - remove_cnt; 1408 } 1409 break; 1410 } 1411 } 1412 if (authmode == _WPA2_IE_ID_) { 1413 /* parsing RSN IE to select required encryption 1414 * algorithm, and set the bc/mc encryption algorithm 1415 */ 1416 while (true) { 1417 if ((sec_ie[2] != 0x01) || (sec_ie[3] != 0x0)) { 1418 /*IE Ver error*/ 1419 match = false; 1420 break; 1421 } 1422 if (!memcmp(&sec_ie[4], &uncst_oui[0], 3)) { 1423 /*get bc/mc encryption type*/ 1424 switch (sec_ie[7]) { 1425 case 0x1: /*WEP_40*/ 1426 psecuritypriv->XGrpPrivacy = 1427 _WEP40_; 1428 break; 1429 case 0x2: /*TKIP*/ 1430 psecuritypriv->XGrpPrivacy = 1431 _TKIP_; 1432 break; 1433 case 0x4: /*AESWRAP*/ 1434 psecuritypriv->XGrpPrivacy = 1435 _AES_; 1436 break; 1437 case 0x5: /*WEP_104*/ 1438 psecuritypriv->XGrpPrivacy = 1439 _WEP104_; 1440 break; 1441 default: /*one*/ 1442 psecuritypriv->XGrpPrivacy = 1443 _NO_PRIVACY_; 1444 break; 1445 } 1446 } else { 1447 match = false; 1448 break; 1449 } 1450 if (sec_ie[8] == 0x01) { 1451 /*check the unicast encryption type*/ 1452 if (memcmp(&sec_ie[10], 1453 &uncst_oui[0], 4)) { 1454 match = false; 1455 break; 1456 } /*else the uncst_oui is match*/ 1457 } else { /*mixed mode, unicast_enc_type > 1*/ 1458 /*select the uncst_oui and remove the 1459 * other uncst_oui 1460 */ 1461 cnt = sec_ie[8]; 1462 remove_cnt = (cnt - 1) * 4; 1463 sec_ie[8] = 0x01; 1464 memcpy(&sec_ie[10], &uncst_oui[0], 4); 1465 /*remove the other unicast suit*/ 1466 memcpy(&sec_ie[14], 1467 &sec_ie[14 + remove_cnt], 1468 (sec_ie[1] - 14 + 2 - 1469 remove_cnt)); 1470 sec_ie[1] = sec_ie[1] - remove_cnt; 1471 } 1472 break; 1473 } 1474 } 1475 } 1476 if ((authmode == _WPA_IE_ID_) || (authmode == _WPA2_IE_ID_)) { 1477 /*copy fixed ie*/ 1478 memcpy(out_ie, in_ie, 12); 1479 ielength = 12; 1480 /*copy RSN or SSN*/ 1481 if (match) { 1482 memcpy(&out_ie[ielength], &sec_ie[0], sec_ie[1] + 2); 1483 ielength += sec_ie[1] + 2; 1484 if (authmode == _WPA2_IE_ID_) { 1485 /*the Pre-Authentication bit should be zero*/ 1486 out_ie[ielength - 1] = 0; 1487 out_ie[ielength - 2] = 0; 1488 } 1489 r8712_report_sec_ie(adapter, authmode, sec_ie); 1490 } 1491 } else { 1492 /*copy fixed ie only*/ 1493 memcpy(out_ie, in_ie, 12); 1494 ielength = 12; 1495 if (psecuritypriv->wps_phase) { 1496 memcpy(out_ie + ielength, psecuritypriv->wps_ie, 1497 psecuritypriv->wps_ie_len); 1498 ielength += psecuritypriv->wps_ie_len; 1499 } 1500 } 1501 iEntry = SecIsInPMKIDList(adapter, pmlmepriv->assoc_bssid); 1502 if (iEntry < 0) 1503 return ielength; 1504 if (authmode == _WPA2_IE_ID_) { 1505 out_ie[ielength] = 1; 1506 ielength++; 1507 out_ie[ielength] = 0; /*PMKID count = 0x0100*/ 1508 ielength++; 1509 memcpy(&out_ie[ielength], 1510 &psecuritypriv->PMKIDList[iEntry].PMKID, 16); 1511 ielength += 16; 1512 out_ie[13] += 18;/*PMKID length = 2+16*/ 1513 } 1514 return ielength; 1515 } 1516 1517 void r8712_init_registrypriv_dev_network(struct _adapter *adapter) 1518 { 1519 struct registry_priv *pregistrypriv = &adapter->registrypriv; 1520 struct eeprom_priv *peepriv = &adapter->eeprompriv; 1521 struct wlan_bssid_ex *pdev_network = &pregistrypriv->dev_network; 1522 u8 *myhwaddr = myid(peepriv); 1523 1524 memcpy(pdev_network->MacAddress, myhwaddr, ETH_ALEN); 1525 memcpy(&pdev_network->Ssid, &pregistrypriv->ssid, 1526 sizeof(struct ndis_802_11_ssid)); 1527 pdev_network->Configuration.Length = 1528 sizeof(struct NDIS_802_11_CONFIGURATION); 1529 pdev_network->Configuration.BeaconPeriod = 100; 1530 pdev_network->Configuration.FHConfig.Length = 0; 1531 pdev_network->Configuration.FHConfig.HopPattern = 0; 1532 pdev_network->Configuration.FHConfig.HopSet = 0; 1533 pdev_network->Configuration.FHConfig.DwellTime = 0; 1534 } 1535 1536 void r8712_update_registrypriv_dev_network(struct _adapter *adapter) 1537 { 1538 int sz = 0; 1539 struct registry_priv *pregistrypriv = &adapter->registrypriv; 1540 struct wlan_bssid_ex *pdev_network = &pregistrypriv->dev_network; 1541 struct security_priv *psecuritypriv = &adapter->securitypriv; 1542 struct wlan_network *cur_network = &adapter->mlmepriv.cur_network; 1543 1544 pdev_network->Privacy = cpu_to_le32(psecuritypriv->PrivacyAlgrthm 1545 > 0 ? 1 : 0); /* adhoc no 802.1x */ 1546 pdev_network->Rssi = 0; 1547 switch (pregistrypriv->wireless_mode) { 1548 case WIRELESS_11B: 1549 pdev_network->NetworkTypeInUse = Ndis802_11DS; 1550 break; 1551 case WIRELESS_11G: 1552 case WIRELESS_11BG: 1553 pdev_network->NetworkTypeInUse = Ndis802_11OFDM24; 1554 break; 1555 case WIRELESS_11A: 1556 pdev_network->NetworkTypeInUse = Ndis802_11OFDM5; 1557 break; 1558 default: 1559 /* TODO */ 1560 break; 1561 } 1562 pdev_network->Configuration.DSConfig = pregistrypriv->channel; 1563 if (cur_network->network.InfrastructureMode == Ndis802_11IBSS) 1564 pdev_network->Configuration.ATIMWindow = 3; 1565 pdev_network->InfrastructureMode = cur_network->network.InfrastructureMode; 1566 /* 1. Supported rates 1567 * 2. IE 1568 */ 1569 sz = r8712_generate_ie(pregistrypriv); 1570 pdev_network->IELength = sz; 1571 pdev_network->Length = r8712_get_wlan_bssid_ex_sz(pdev_network); 1572 } 1573 1574 /*the function is at passive_level*/ 1575 void r8712_joinbss_reset(struct _adapter *padapter) 1576 { 1577 int i; 1578 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1579 struct ht_priv *phtpriv = &pmlmepriv->htpriv; 1580 1581 /* todo: if you want to do something io/reg/hw setting before join_bss, 1582 * please add code here 1583 */ 1584 phtpriv->ampdu_enable = false;/*reset to disabled*/ 1585 for (i = 0; i < 16; i++) 1586 phtpriv->baddbareq_issued[i] = false;/*reset it*/ 1587 if (phtpriv->ht_option) { 1588 /* validate usb rx aggregation */ 1589 r8712_write8(padapter, 0x102500D9, 48);/*TH = 48 pages, 6k*/ 1590 } else { 1591 /* invalidate usb rx aggregation */ 1592 /* TH=1 => means that invalidate usb rx aggregation */ 1593 r8712_write8(padapter, 0x102500D9, 1); 1594 } 1595 } 1596 1597 /*the function is >= passive_level*/ 1598 unsigned int r8712_restructure_ht_ie(struct _adapter *padapter, u8 *in_ie, 1599 u8 *out_ie, uint in_len, uint *pout_len) 1600 { 1601 u32 ielen, out_len; 1602 unsigned char *p; 1603 struct ieee80211_ht_cap ht_capie; 1604 unsigned char WMM_IE[] = {0x00, 0x50, 0xf2, 0x02, 0x00, 0x01, 0x00}; 1605 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1606 struct qos_priv *pqospriv = &pmlmepriv->qospriv; 1607 struct ht_priv *phtpriv = &pmlmepriv->htpriv; 1608 1609 phtpriv->ht_option = 0; 1610 p = r8712_get_ie(in_ie + 12, WLAN_EID_HT_CAPABILITY, &ielen, in_len - 12); 1611 if (p && (ielen > 0)) { 1612 if (pqospriv->qos_option == 0) { 1613 out_len = *pout_len; 1614 r8712_set_ie(out_ie + out_len, WLAN_EID_VENDOR_SPECIFIC, 1615 _WMM_IE_Length_, WMM_IE, pout_len); 1616 pqospriv->qos_option = 1; 1617 } 1618 out_len = *pout_len; 1619 memset(&ht_capie, 0, sizeof(struct ieee80211_ht_cap)); 1620 ht_capie.cap_info = cpu_to_le16(IEEE80211_HT_CAP_SUP_WIDTH_20_40 | 1621 IEEE80211_HT_CAP_SGI_20 | 1622 IEEE80211_HT_CAP_SGI_40 | 1623 IEEE80211_HT_CAP_TX_STBC | 1624 IEEE80211_HT_CAP_MAX_AMSDU | 1625 IEEE80211_HT_CAP_DSSSCCK40); 1626 ht_capie.ampdu_params_info = (IEEE80211_HT_AMPDU_PARM_FACTOR & 1627 0x03) | (IEEE80211_HT_AMPDU_PARM_DENSITY & 0x00); 1628 r8712_set_ie(out_ie + out_len, WLAN_EID_HT_CAPABILITY, 1629 sizeof(struct ieee80211_ht_cap), 1630 (unsigned char *)&ht_capie, pout_len); 1631 phtpriv->ht_option = 1; 1632 } 1633 return phtpriv->ht_option; 1634 } 1635 1636 /* the function is > passive_level (in critical_section) */ 1637 static void update_ht_cap(struct _adapter *padapter, u8 *pie, uint ie_len) 1638 { 1639 u8 *p, max_ampdu_sz; 1640 int i; 1641 uint len; 1642 struct sta_info *bmc_sta, *psta; 1643 struct ieee80211_ht_cap *pht_capie; 1644 struct recv_reorder_ctrl *preorder_ctrl; 1645 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1646 struct ht_priv *phtpriv = &pmlmepriv->htpriv; 1647 struct registry_priv *pregistrypriv = &padapter->registrypriv; 1648 struct wlan_network *pcur_network = &(pmlmepriv->cur_network); 1649 1650 if (!phtpriv->ht_option) 1651 return; 1652 /* maybe needs check if ap supports rx ampdu. */ 1653 if (!phtpriv->ampdu_enable && 1654 (pregistrypriv->ampdu_enable == 1)) 1655 phtpriv->ampdu_enable = true; 1656 /*check Max Rx A-MPDU Size*/ 1657 len = 0; 1658 p = r8712_get_ie(pie + sizeof(struct NDIS_802_11_FIXED_IEs), 1659 WLAN_EID_HT_CAPABILITY, 1660 &len, ie_len - 1661 sizeof(struct NDIS_802_11_FIXED_IEs)); 1662 if (p && len > 0) { 1663 pht_capie = (struct ieee80211_ht_cap *)(p + 2); 1664 max_ampdu_sz = (pht_capie->ampdu_params_info & 1665 IEEE80211_HT_AMPDU_PARM_FACTOR); 1666 /* max_ampdu_sz (kbytes); */ 1667 max_ampdu_sz = 1 << (max_ampdu_sz + 3); 1668 phtpriv->rx_ampdu_maxlen = max_ampdu_sz; 1669 } 1670 /* for A-MPDU Rx reordering buffer control for bmc_sta & sta_info 1671 * if A-MPDU Rx is enabled, resetting rx_ordering_ctrl 1672 * wstart_b(indicate_seq) to default value=0xffff 1673 * todo: check if AP can send A-MPDU packets 1674 */ 1675 bmc_sta = r8712_get_bcmc_stainfo(padapter); 1676 if (bmc_sta) { 1677 for (i = 0; i < 16; i++) { 1678 preorder_ctrl = &bmc_sta->recvreorder_ctrl[i]; 1679 preorder_ctrl->indicate_seq = 0xffff; 1680 preorder_ctrl->wend_b = 0xffff; 1681 } 1682 } 1683 psta = r8712_get_stainfo(&padapter->stapriv, 1684 pcur_network->network.MacAddress); 1685 if (psta) { 1686 for (i = 0; i < 16; i++) { 1687 preorder_ctrl = &psta->recvreorder_ctrl[i]; 1688 preorder_ctrl->indicate_seq = 0xffff; 1689 preorder_ctrl->wend_b = 0xffff; 1690 } 1691 } 1692 len = 0; 1693 p = r8712_get_ie(pie + sizeof(struct NDIS_802_11_FIXED_IEs), 1694 WLAN_EID_HT_OPERATION, &len, 1695 ie_len - sizeof(struct NDIS_802_11_FIXED_IEs)); 1696 } 1697 1698 void r8712_issue_addbareq_cmd(struct _adapter *padapter, int priority) 1699 { 1700 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1701 struct ht_priv *phtpriv = &pmlmepriv->htpriv; 1702 1703 if ((phtpriv->ht_option == 1) && (phtpriv->ampdu_enable)) { 1704 if (!phtpriv->baddbareq_issued[priority]) { 1705 r8712_addbareq_cmd(padapter, (u8)priority); 1706 phtpriv->baddbareq_issued[priority] = true; 1707 } 1708 } 1709 } 1710