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