1 /******************************************************************************
4 * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved.
5 * Linux device driver for RTL8192SU
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of version 2 of the GNU General Public License as
9 * published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 * You should have received a copy of the GNU General Public License along with
17 * this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
20 * Modifications for inclusion into the Linux staging tree are
21 * Copyright(c) 2010 Larry Finger. All rights reserved.
23 * Contact information:
24 * WLAN FAE <wlanfae@realtek.com>
25 * Larry Finger <Larry.Finger@lwfinger.net>
27 ******************************************************************************/
29 #define _RTL871X_MLME_C_
31 #include <linux/etherdevice.h>
33 #include "osdep_service.h"
34 #include "drv_types.h"
35 #include "recv_osdep.h"
36 #include "xmit_osdep.h"
37 #include "mlme_osdep.h"
40 #include "wlan_bssdef.h"
42 static void update_ht_cap(struct _adapter *padapter, u8 *pie, uint ie_len);
44 static sint _init_mlme_priv(struct _adapter *padapter)
48 struct wlan_network *pnetwork;
49 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
51 memset((u8 *)pmlmepriv, 0, sizeof(struct mlme_priv));
52 pmlmepriv->nic_hdl = (u8 *)padapter;
53 pmlmepriv->pscanned = NULL;
54 pmlmepriv->fw_state = 0;
55 pmlmepriv->cur_network.network.InfrastructureMode =
56 Ndis802_11AutoUnknown;
57 /* Maybe someday we should rename this variable to "active_mode"(Jeff)*/
58 pmlmepriv->passive_mode = 1; /* 1: active, 0: passive. */
59 spin_lock_init(&(pmlmepriv->lock));
60 spin_lock_init(&(pmlmepriv->lock2));
61 _init_queue(&(pmlmepriv->free_bss_pool));
62 _init_queue(&(pmlmepriv->scanned_queue));
63 set_scanned_network_val(pmlmepriv, 0);
64 memset(&pmlmepriv->assoc_ssid, 0, sizeof(struct ndis_802_11_ssid));
65 pbuf = kmalloc(MAX_BSS_CNT * (sizeof(struct wlan_network)),
69 pmlmepriv->free_bss_buf = pbuf;
70 pnetwork = (struct wlan_network *)pbuf;
71 for (i = 0; i < MAX_BSS_CNT; i++) {
72 INIT_LIST_HEAD(&(pnetwork->list));
73 list_add_tail(&(pnetwork->list),
74 &(pmlmepriv->free_bss_pool.queue));
77 pmlmepriv->sitesurveyctrl.last_rx_pkts = 0;
78 pmlmepriv->sitesurveyctrl.last_tx_pkts = 0;
79 pmlmepriv->sitesurveyctrl.traffic_busy = false;
80 /* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */
81 r8712_init_mlme_timer(padapter);
85 struct wlan_network *_r8712_alloc_network(struct mlme_priv *pmlmepriv)
88 struct wlan_network *pnetwork;
89 struct __queue *free_queue = &pmlmepriv->free_bss_pool;
90 struct list_head *plist = NULL;
92 if (list_empty(&free_queue->queue))
94 spin_lock_irqsave(&free_queue->lock, irqL);
95 plist = free_queue->queue.next;
96 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
97 list_del_init(&pnetwork->list);
98 pnetwork->last_scanned = jiffies;
99 pmlmepriv->num_of_scanned++;
100 spin_unlock_irqrestore(&free_queue->lock, irqL);
104 static void _free_network(struct mlme_priv *pmlmepriv,
105 struct wlan_network *pnetwork)
107 u32 curr_time, delta_time;
109 struct __queue *free_queue = &(pmlmepriv->free_bss_pool);
111 if (pnetwork == NULL)
113 if (pnetwork->fixed == true)
116 delta_time = (curr_time - (u32)pnetwork->last_scanned) / HZ;
117 if (delta_time < SCANQUEUE_LIFETIME)
119 spin_lock_irqsave(&free_queue->lock, irqL);
120 list_del_init(&pnetwork->list);
121 list_add_tail(&pnetwork->list, &free_queue->queue);
122 pmlmepriv->num_of_scanned--;
123 spin_unlock_irqrestore(&free_queue->lock, irqL);
126 static void _free_network_nolock(struct mlme_priv *pmlmepriv,
127 struct wlan_network *pnetwork)
129 struct __queue *free_queue = &pmlmepriv->free_bss_pool;
131 if (pnetwork == NULL)
133 if (pnetwork->fixed == true)
135 list_del_init(&pnetwork->list);
136 list_add_tail(&pnetwork->list, &free_queue->queue);
137 pmlmepriv->num_of_scanned--;
142 return the wlan_network with the matching addr
143 Shall be called under atomic context...
144 to avoid possible racing condition...
146 static struct wlan_network *_r8712_find_network(struct __queue *scanned_queue,
150 struct list_head *phead, *plist;
151 struct wlan_network *pnetwork = NULL;
153 if (is_zero_ether_addr(addr))
155 spin_lock_irqsave(&scanned_queue->lock, irqL);
156 phead = &scanned_queue->queue;
158 while (plist != phead) {
159 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
161 if (!memcmp(addr, pnetwork->network.MacAddress, ETH_ALEN))
164 spin_unlock_irqrestore(&scanned_queue->lock, irqL);
168 static void _free_network_queue(struct _adapter *padapter)
171 struct list_head *phead, *plist;
172 struct wlan_network *pnetwork;
173 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
174 struct __queue *scanned_queue = &pmlmepriv->scanned_queue;
176 spin_lock_irqsave(&scanned_queue->lock, irqL);
177 phead = &scanned_queue->queue;
179 while (end_of_queue_search(phead, plist) == false) {
180 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
182 _free_network(pmlmepriv, pnetwork);
184 spin_unlock_irqrestore(&scanned_queue->lock, irqL);
187 sint r8712_if_up(struct _adapter *padapter)
191 if (padapter->bDriverStopped || padapter->bSurpriseRemoved ||
192 (check_fwstate(&padapter->mlmepriv, _FW_LINKED) == false)) {
199 void r8712_generate_random_ibss(u8 *pibss)
201 u32 curtime = jiffies;
203 pibss[0] = 0x02; /*in ad-hoc mode bit1 must set to 1 */
206 pibss[3] = (u8)(curtime & 0xff);
207 pibss[4] = (u8)((curtime>>8) & 0xff);
208 pibss[5] = (u8)((curtime>>16) & 0xff);
211 uint r8712_get_ndis_wlan_bssid_ex_sz(struct ndis_wlan_bssid_ex *bss)
215 t_len = sizeof(u32) + 6 * sizeof(unsigned long) + 2 +
216 sizeof(struct ndis_802_11_ssid) + sizeof(u32) +
218 sizeof(enum NDIS_802_11_NETWORK_TYPE) +
219 sizeof(struct NDIS_802_11_CONFIGURATION) +
220 sizeof(enum NDIS_802_11_NETWORK_INFRASTRUCTURE) +
221 sizeof(NDIS_802_11_RATES_EX) +
222 sizeof(u32) + bss->IELength;
226 u8 *r8712_get_capability_from_ie(u8 *ie)
231 int r8712_init_mlme_priv(struct _adapter *padapter)
233 return _init_mlme_priv(padapter);
236 void r8712_free_mlme_priv(struct mlme_priv *pmlmepriv)
238 kfree(pmlmepriv->free_bss_buf);
241 static struct wlan_network *alloc_network(struct mlme_priv *pmlmepriv)
243 return _r8712_alloc_network(pmlmepriv);
246 static void free_network_nolock(struct mlme_priv *pmlmepriv,
247 struct wlan_network *pnetwork)
249 _free_network_nolock(pmlmepriv, pnetwork);
252 void r8712_free_network_queue(struct _adapter *dev)
254 _free_network_queue(dev);
258 return the wlan_network with the matching addr
260 Shall be called under atomic context...
261 to avoid possible racing condition...
263 static struct wlan_network *r8712_find_network(struct __queue *scanned_queue,
266 struct wlan_network *pnetwork = _r8712_find_network(scanned_queue,
272 int r8712_is_same_ibss(struct _adapter *adapter, struct wlan_network *pnetwork)
275 struct security_priv *psecuritypriv = &adapter->securitypriv;
277 if ((psecuritypriv->PrivacyAlgrthm != _NO_PRIVACY_) &&
278 (pnetwork->network.Privacy == 0))
280 else if ((psecuritypriv->PrivacyAlgrthm == _NO_PRIVACY_) &&
281 (pnetwork->network.Privacy == 1))
289 static int is_same_network(struct ndis_wlan_bssid_ex *src,
290 struct ndis_wlan_bssid_ex *dst)
294 memcpy((u8 *)&s_cap, r8712_get_capability_from_ie(src->IEs), 2);
295 memcpy((u8 *)&d_cap, r8712_get_capability_from_ie(dst->IEs), 2);
296 return (src->Ssid.SsidLength == dst->Ssid.SsidLength) &&
297 (src->Configuration.DSConfig ==
298 dst->Configuration.DSConfig) &&
299 ((!memcmp(src->MacAddress, dst->MacAddress,
301 ((!memcmp(src->Ssid.Ssid,
303 src->Ssid.SsidLength))) &&
304 ((s_cap & WLAN_CAPABILITY_IBSS) ==
305 (d_cap & WLAN_CAPABILITY_IBSS)) &&
306 ((s_cap & WLAN_CAPABILITY_BSS) ==
307 (d_cap & WLAN_CAPABILITY_BSS));
311 struct wlan_network *r8712_get_oldest_wlan_network(
312 struct __queue *scanned_queue)
314 struct list_head *plist, *phead;
315 struct wlan_network *pwlan = NULL;
316 struct wlan_network *oldest = NULL;
318 phead = &scanned_queue->queue;
321 if (end_of_queue_search(phead, plist) == true)
323 pwlan = LIST_CONTAINOR(plist, struct wlan_network, list);
324 if (pwlan->fixed != true) {
325 if (oldest == NULL ||
326 time_after((unsigned long)oldest->last_scanned,
327 (unsigned long)pwlan->last_scanned))
335 static void update_network(struct ndis_wlan_bssid_ex *dst,
336 struct ndis_wlan_bssid_ex *src,
337 struct _adapter *padapter)
339 u32 last_evm = 0, tmpVal;
341 if (check_fwstate(&padapter->mlmepriv, _FW_LINKED) &&
342 is_same_network(&(padapter->mlmepriv.cur_network.network), src)) {
343 if (padapter->recvpriv.signal_qual_data.total_num++ >=
344 PHY_LINKQUALITY_SLID_WIN_MAX) {
345 padapter->recvpriv.signal_qual_data.total_num =
346 PHY_LINKQUALITY_SLID_WIN_MAX;
347 last_evm = padapter->recvpriv.signal_qual_data.
348 elements[padapter->recvpriv.
349 signal_qual_data.index];
350 padapter->recvpriv.signal_qual_data.total_val -=
353 padapter->recvpriv.signal_qual_data.total_val += src->Rssi;
355 padapter->recvpriv.signal_qual_data.
356 elements[padapter->recvpriv.signal_qual_data.
357 index++] = src->Rssi;
358 if (padapter->recvpriv.signal_qual_data.index >=
359 PHY_LINKQUALITY_SLID_WIN_MAX)
360 padapter->recvpriv.signal_qual_data.index = 0;
361 /* <1> Showed on UI for user, in percentage. */
362 tmpVal = padapter->recvpriv.signal_qual_data.total_val /
363 padapter->recvpriv.signal_qual_data.total_num;
364 padapter->recvpriv.signal = (u8)tmpVal;
366 src->Rssi = padapter->recvpriv.signal;
368 src->Rssi = (src->Rssi + dst->Rssi) / 2;
369 memcpy((u8 *)dst, (u8 *)src, r8712_get_ndis_wlan_bssid_ex_sz(src));
372 static void update_current_network(struct _adapter *adapter,
373 struct ndis_wlan_bssid_ex *pnetwork)
375 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
377 if (is_same_network(&(pmlmepriv->cur_network.network), pnetwork)) {
378 update_network(&(pmlmepriv->cur_network.network),
380 r8712_update_protection(adapter,
381 (pmlmepriv->cur_network.network.IEs) +
382 sizeof(struct NDIS_802_11_FIXED_IEs),
383 pmlmepriv->cur_network.network.IELength);
388 Caller must hold pmlmepriv->lock first.
390 static void update_scanned_network(struct _adapter *adapter,
391 struct ndis_wlan_bssid_ex *target)
393 struct list_head *plist, *phead;
396 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
397 struct __queue *queue = &pmlmepriv->scanned_queue;
398 struct wlan_network *pnetwork = NULL;
399 struct wlan_network *oldest = NULL;
401 phead = &queue->queue;
405 if (end_of_queue_search(phead, plist) == true)
408 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
409 if (is_same_network(&pnetwork->network, target))
411 if ((oldest == ((struct wlan_network *)0)) ||
412 time_after((unsigned long)oldest->last_scanned,
413 (unsigned long)pnetwork->last_scanned))
420 /* If we didn't find a match, then get a new network slot to initialize
421 * with this beacon's information */
422 if (end_of_queue_search(phead, plist) == true) {
423 if (list_empty(&pmlmepriv->free_bss_pool.queue)) {
424 /* If there are no more slots, expire the oldest */
426 target->Rssi = (pnetwork->network.Rssi +
428 memcpy(&pnetwork->network, target,
429 r8712_get_ndis_wlan_bssid_ex_sz(target));
430 pnetwork->last_scanned = jiffies;
432 /* Otherwise just pull from the free list */
433 /* update scan_time */
434 pnetwork = alloc_network(pmlmepriv);
435 if (pnetwork == NULL)
437 bssid_ex_sz = r8712_get_ndis_wlan_bssid_ex_sz(target);
438 target->Length = bssid_ex_sz;
439 memcpy(&pnetwork->network, target, bssid_ex_sz);
440 list_add_tail(&pnetwork->list, &queue->queue);
443 /* we have an entry and we are going to update it. But
444 * this entry may be already expired. In this case we
445 * do the same as we found a new net and call the new_net
448 update_network(&pnetwork->network, target, adapter);
449 pnetwork->last_scanned = jiffies;
453 static void rtl8711_add_network(struct _adapter *adapter,
454 struct ndis_wlan_bssid_ex *pnetwork)
457 struct mlme_priv *pmlmepriv = &(((struct _adapter *)adapter)->mlmepriv);
458 struct __queue *queue = &pmlmepriv->scanned_queue;
460 spin_lock_irqsave(&queue->lock, irqL);
461 update_current_network(adapter, pnetwork);
462 update_scanned_network(adapter, pnetwork);
463 spin_unlock_irqrestore(&queue->lock, irqL);
466 /*select the desired network based on the capability of the (i)bss.
467 * check items: (1) security
473 static int is_desired_network(struct _adapter *adapter,
474 struct wlan_network *pnetwork)
478 int bselected = true;
479 struct security_priv *psecuritypriv = &adapter->securitypriv;
481 if (psecuritypriv->wps_phase == true) {
482 if (r8712_get_wps_ie(pnetwork->network.IEs,
483 pnetwork->network.IELength, wps_ie,
489 if ((psecuritypriv->PrivacyAlgrthm != _NO_PRIVACY_) &&
490 (pnetwork->network.Privacy == 0))
492 if (check_fwstate(&adapter->mlmepriv, WIFI_ADHOC_STATE) == true) {
493 if (pnetwork->network.InfrastructureMode !=
494 adapter->mlmepriv.cur_network.network.
501 /* TODO: Perry : For Power Management */
502 void r8712_atimdone_event_callback(struct _adapter *adapter, u8 *pbuf)
506 void r8712_survey_event_callback(struct _adapter *adapter, u8 *pbuf)
510 struct ndis_wlan_bssid_ex *pnetwork;
511 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
513 pnetwork = (struct ndis_wlan_bssid_ex *)pbuf;
516 pnetwork->Length = le32_to_cpu(pnetwork->Length);
517 pnetwork->Ssid.SsidLength = le32_to_cpu(pnetwork->Ssid.SsidLength);
518 pnetwork->Privacy = le32_to_cpu(pnetwork->Privacy);
519 pnetwork->Rssi = le32_to_cpu(pnetwork->Rssi);
520 pnetwork->NetworkTypeInUse = le32_to_cpu(pnetwork->NetworkTypeInUse);
521 pnetwork->Configuration.ATIMWindow =
522 le32_to_cpu(pnetwork->Configuration.ATIMWindow);
523 pnetwork->Configuration.BeaconPeriod =
524 le32_to_cpu(pnetwork->Configuration.BeaconPeriod);
525 pnetwork->Configuration.DSConfig =
526 le32_to_cpu(pnetwork->Configuration.DSConfig);
527 pnetwork->Configuration.FHConfig.DwellTime =
528 le32_to_cpu(pnetwork->Configuration.FHConfig.DwellTime);
529 pnetwork->Configuration.FHConfig.HopPattern =
530 le32_to_cpu(pnetwork->Configuration.FHConfig.HopPattern);
531 pnetwork->Configuration.FHConfig.HopSet =
532 le32_to_cpu(pnetwork->Configuration.FHConfig.HopSet);
533 pnetwork->Configuration.FHConfig.Length =
534 le32_to_cpu(pnetwork->Configuration.FHConfig.Length);
535 pnetwork->Configuration.Length =
536 le32_to_cpu(pnetwork->Configuration.Length);
537 pnetwork->InfrastructureMode =
538 le32_to_cpu(pnetwork->InfrastructureMode);
539 pnetwork->IELength = le32_to_cpu(pnetwork->IELength);
541 len = r8712_get_ndis_wlan_bssid_ex_sz(pnetwork);
542 if (len > sizeof(struct wlan_bssid_ex))
544 spin_lock_irqsave(&pmlmepriv->lock2, flags);
545 /* update IBSS_network 's timestamp */
546 if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) {
547 if (!memcmp(&(pmlmepriv->cur_network.network.MacAddress),
548 pnetwork->MacAddress, ETH_ALEN)) {
549 struct wlan_network *ibss_wlan = NULL;
551 memcpy(pmlmepriv->cur_network.network.IEs,
553 ibss_wlan = r8712_find_network(
554 &pmlmepriv->scanned_queue,
555 pnetwork->MacAddress);
557 memcpy(ibss_wlan->network.IEs,
563 /* lock pmlmepriv->lock when you accessing network_q */
564 if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == false) {
565 if (pnetwork->Ssid.Ssid[0] != 0)
566 rtl8711_add_network(adapter, pnetwork);
568 pnetwork->Ssid.SsidLength = 8;
569 memcpy(pnetwork->Ssid.Ssid, "<hidden>", 8);
570 rtl8711_add_network(adapter, pnetwork);
574 spin_unlock_irqrestore(&pmlmepriv->lock2, flags);
577 void r8712_surveydone_event_callback(struct _adapter *adapter, u8 *pbuf)
580 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
582 spin_lock_irqsave(&pmlmepriv->lock, irqL);
584 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == true) {
587 _cancel_timer(&pmlmepriv->scan_to_timer, &timer_cancelled);
589 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY);
592 if (pmlmepriv->to_join == true) {
593 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true) {
594 if (check_fwstate(pmlmepriv, _FW_LINKED) == false) {
595 set_fwstate(pmlmepriv, _FW_UNDER_LINKING);
597 if (r8712_select_and_join_from_scan(pmlmepriv)
599 mod_timer(&pmlmepriv->assoc_timer, jiffies +
600 msecs_to_jiffies(MAX_JOIN_TIMEOUT));
602 struct wlan_bssid_ex *pdev_network =
603 &(adapter->registrypriv.dev_network);
605 adapter->registrypriv.
606 dev_network.MacAddress;
607 pmlmepriv->fw_state ^= _FW_UNDER_SURVEY;
608 memcpy(&pdev_network->Ssid,
609 &pmlmepriv->assoc_ssid,
612 r8712_update_registrypriv_dev_network
614 r8712_generate_random_ibss(pibss);
615 pmlmepriv->fw_state =
616 WIFI_ADHOC_MASTER_STATE;
617 pmlmepriv->to_join = false;
621 pmlmepriv->to_join = false;
622 set_fwstate(pmlmepriv, _FW_UNDER_LINKING);
623 if (r8712_select_and_join_from_scan(pmlmepriv) ==
625 mod_timer(&pmlmepriv->assoc_timer, jiffies +
626 msecs_to_jiffies(MAX_JOIN_TIMEOUT));
628 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
631 spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
635 *r8712_free_assoc_resources: the caller has to lock pmlmepriv->lock
637 void r8712_free_assoc_resources(struct _adapter *adapter)
640 struct wlan_network *pwlan = NULL;
641 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
642 struct sta_priv *pstapriv = &adapter->stapriv;
643 struct wlan_network *tgt_network = &pmlmepriv->cur_network;
645 pwlan = r8712_find_network(&pmlmepriv->scanned_queue,
646 tgt_network->network.MacAddress);
648 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE|WIFI_AP_STATE)) {
649 struct sta_info *psta;
651 psta = r8712_get_stainfo(&adapter->stapriv,
652 tgt_network->network.MacAddress);
654 spin_lock_irqsave(&pstapriv->sta_hash_lock, irqL);
655 r8712_free_stainfo(adapter, psta);
656 spin_unlock_irqrestore(&pstapriv->sta_hash_lock, irqL);
659 if (check_fwstate(pmlmepriv,
660 WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE|WIFI_AP_STATE))
661 r8712_free_all_stainfo(adapter);
663 pwlan->fixed = false;
665 if (((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) &&
666 (adapter->stapriv.asoc_sta_count == 1)))
667 free_network_nolock(pmlmepriv, pwlan);
671 *r8712_indicate_connect: the caller has to lock pmlmepriv->lock
673 void r8712_indicate_connect(struct _adapter *padapter)
675 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
677 pmlmepriv->to_join = false;
678 set_fwstate(pmlmepriv, _FW_LINKED);
679 padapter->ledpriv.LedControlHandler(padapter, LED_CTL_LINK);
680 r8712_os_indicate_connect(padapter);
681 if (padapter->registrypriv.power_mgnt > PS_MODE_ACTIVE)
682 mod_timer(&pmlmepriv->dhcp_timer,
683 jiffies + msecs_to_jiffies(60000));
688 *r8712_ind_disconnect: the caller has to lock pmlmepriv->lock
690 void r8712_ind_disconnect(struct _adapter *padapter)
692 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
694 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
695 _clr_fwstate_(pmlmepriv, _FW_LINKED);
696 padapter->ledpriv.LedControlHandler(padapter, LED_CTL_NO_LINK);
697 r8712_os_indicate_disconnect(padapter);
699 if (padapter->pwrctrlpriv.pwr_mode !=
700 padapter->registrypriv.power_mgnt) {
701 _cancel_timer_ex(&pmlmepriv->dhcp_timer);
702 r8712_set_ps_mode(padapter, padapter->registrypriv.power_mgnt,
703 padapter->registrypriv.smart_ps);
708 *pnetwork : returns from r8712_joinbss_event_callback
709 *ptarget_wlan: found from scanned_queue
710 *if join_res > 0, for (fw_state==WIFI_STATION_STATE), we check if
711 * "ptarget_sta" & "ptarget_wlan" exist.
712 *if join_res > 0, for (fw_state==WIFI_ADHOC_STATE), we only check
713 * if "ptarget_wlan" exist.
714 *if join_res > 0, update "cur_network->network" from
715 * "pnetwork->network" if (ptarget_wlan !=NULL).
717 void r8712_joinbss_event_callback(struct _adapter *adapter, u8 *pbuf)
719 unsigned long irqL = 0, irqL2;
721 struct sta_info *ptarget_sta = NULL, *pcur_sta = NULL;
722 struct sta_priv *pstapriv = &adapter->stapriv;
723 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
724 struct wlan_network *cur_network = &pmlmepriv->cur_network;
725 struct wlan_network *pcur_wlan = NULL, *ptarget_wlan = NULL;
726 unsigned int the_same_macaddr = false;
727 struct wlan_network *pnetwork;
729 if (sizeof(struct list_head) == 4 * sizeof(u32)) {
730 pnetwork = kmalloc(sizeof(struct wlan_network), GFP_ATOMIC);
731 memcpy((u8 *)pnetwork+16, (u8 *)pbuf + 8,
732 sizeof(struct wlan_network) - 16);
734 pnetwork = (struct wlan_network *)pbuf;
738 pnetwork->join_res = le32_to_cpu(pnetwork->join_res);
739 pnetwork->network_type = le32_to_cpu(pnetwork->network_type);
740 pnetwork->network.Length = le32_to_cpu(pnetwork->network.Length);
741 pnetwork->network.Ssid.SsidLength =
742 le32_to_cpu(pnetwork->network.Ssid.SsidLength);
743 pnetwork->network.Privacy = le32_to_cpu(pnetwork->network.Privacy);
744 pnetwork->network.Rssi = le32_to_cpu(pnetwork->network.Rssi);
745 pnetwork->network.NetworkTypeInUse =
746 le32_to_cpu(pnetwork->network.NetworkTypeInUse);
747 pnetwork->network.Configuration.ATIMWindow =
748 le32_to_cpu(pnetwork->network.Configuration.ATIMWindow);
749 pnetwork->network.Configuration.BeaconPeriod =
750 le32_to_cpu(pnetwork->network.Configuration.BeaconPeriod);
751 pnetwork->network.Configuration.DSConfig =
752 le32_to_cpu(pnetwork->network.Configuration.DSConfig);
753 pnetwork->network.Configuration.FHConfig.DwellTime =
754 le32_to_cpu(pnetwork->network.Configuration.FHConfig.
756 pnetwork->network.Configuration.FHConfig.HopPattern =
757 le32_to_cpu(pnetwork->network.Configuration.
758 FHConfig.HopPattern);
759 pnetwork->network.Configuration.FHConfig.HopSet =
760 le32_to_cpu(pnetwork->network.Configuration.FHConfig.HopSet);
761 pnetwork->network.Configuration.FHConfig.Length =
762 le32_to_cpu(pnetwork->network.Configuration.FHConfig.Length);
763 pnetwork->network.Configuration.Length =
764 le32_to_cpu(pnetwork->network.Configuration.Length);
765 pnetwork->network.InfrastructureMode =
766 le32_to_cpu(pnetwork->network.InfrastructureMode);
767 pnetwork->network.IELength = le32_to_cpu(pnetwork->network.IELength);
770 the_same_macaddr = !memcmp(pnetwork->network.MacAddress,
771 cur_network->network.MacAddress, ETH_ALEN);
772 pnetwork->network.Length =
773 r8712_get_ndis_wlan_bssid_ex_sz(&pnetwork->network);
774 spin_lock_irqsave(&pmlmepriv->lock, irqL);
775 if (pnetwork->network.Length > sizeof(struct wlan_bssid_ex))
776 goto ignore_joinbss_callback;
777 if (pnetwork->join_res > 0) {
778 if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == true) {
779 /*s1. find ptarget_wlan*/
780 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
781 if (the_same_macaddr == true)
783 r8712_find_network(&pmlmepriv->
785 cur_network->network.MacAddress);
788 r8712_find_network(&pmlmepriv->
790 cur_network->network.MacAddress);
791 pcur_wlan->fixed = false;
793 pcur_sta = r8712_get_stainfo(pstapriv,
794 cur_network->network.MacAddress);
795 spin_lock_irqsave(&pstapriv->
796 sta_hash_lock, irqL2);
797 r8712_free_stainfo(adapter, pcur_sta);
798 spin_unlock_irqrestore(&(pstapriv->
799 sta_hash_lock), irqL2);
802 r8712_find_network(&pmlmepriv->
807 ptarget_wlan->fixed = true;
810 ptarget_wlan = r8712_find_network(&pmlmepriv->
812 pnetwork->network.MacAddress);
814 ptarget_wlan->fixed = true;
817 if (ptarget_wlan == NULL) {
818 if (check_fwstate(pmlmepriv,
820 pmlmepriv->fw_state ^=
822 goto ignore_joinbss_callback;
825 /*s2. find ptarget_sta & update ptarget_sta*/
826 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) {
827 if (the_same_macaddr == true) {
829 r8712_get_stainfo(pstapriv,
830 pnetwork->network.MacAddress);
831 if (ptarget_sta == NULL)
833 r8712_alloc_stainfo(pstapriv,
834 pnetwork->network.MacAddress);
837 r8712_alloc_stainfo(pstapriv,
838 pnetwork->network.MacAddress);
839 if (ptarget_sta) /*update ptarget_sta*/ {
840 ptarget_sta->aid = pnetwork->join_res;
841 ptarget_sta->qos_option = 1;
842 ptarget_sta->mac_id = 5;
843 if (adapter->securitypriv.
845 adapter->securitypriv.
848 adapter->securitypriv.
851 adapter->securitypriv.
854 ptarget_sta->ieee8021x_blocked
856 ptarget_sta->XPrivacy =
857 adapter->securitypriv.
859 memset((u8 *)&ptarget_sta->
862 sizeof(union Keytype));
863 memset((u8 *)&ptarget_sta->
866 sizeof(union Keytype));
867 memset((u8 *)&ptarget_sta->
870 sizeof(union Keytype));
871 memset((u8 *)&ptarget_sta->
874 memset((u8 *)&ptarget_sta->
879 if (check_fwstate(pmlmepriv,
881 pmlmepriv->fw_state ^=
883 goto ignore_joinbss_callback;
887 /*s3. update cur_network & indicate connect*/
888 memcpy(&cur_network->network, &pnetwork->network,
889 pnetwork->network.Length);
890 cur_network->aid = pnetwork->join_res;
891 /*update fw_state will clr _FW_UNDER_LINKING*/
892 switch (pnetwork->network.InfrastructureMode) {
893 case Ndis802_11Infrastructure:
894 pmlmepriv->fw_state = WIFI_STATION_STATE;
897 pmlmepriv->fw_state = WIFI_ADHOC_STATE;
900 pmlmepriv->fw_state = WIFI_NULL_STATE;
903 r8712_update_protection(adapter,
904 (cur_network->network.IEs) +
905 sizeof(struct NDIS_802_11_FIXED_IEs),
906 (cur_network->network.IELength));
907 /*TODO: update HT_Capability*/
908 update_ht_cap(adapter, cur_network->network.IEs,
909 cur_network->network.IELength);
911 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)
913 r8712_indicate_connect(adapter);
914 _cancel_timer(&pmlmepriv->assoc_timer,
917 goto ignore_joinbss_callback;
919 if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == true) {
920 mod_timer(&pmlmepriv->assoc_timer,
921 jiffies + msecs_to_jiffies(1));
922 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
925 ignore_joinbss_callback:
926 spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
927 if (sizeof(struct list_head) == 4 * sizeof(u32))
931 void r8712_stassoc_event_callback(struct _adapter *adapter, u8 *pbuf)
934 struct sta_info *psta;
935 struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
936 struct stassoc_event *pstassoc = (struct stassoc_event *)pbuf;
939 if (r8712_access_ctrl(&adapter->acl_list, pstassoc->macaddr) == false)
941 psta = r8712_get_stainfo(&adapter->stapriv, pstassoc->macaddr);
943 /*the sta have been in sta_info_queue => do nothing
944 *(between drv has received this event before and
945 * fw have not yet to set key to CAM_ENTRY) */
949 psta = r8712_alloc_stainfo(&adapter->stapriv, pstassoc->macaddr);
952 /* to do : init sta_info variable */
953 psta->qos_option = 0;
954 psta->mac_id = le32_to_cpu((uint)pstassoc->cam_id);
955 /* psta->aid = (uint)pstassoc->cam_id; */
957 if (adapter->securitypriv.AuthAlgrthm == 2)
958 psta->XPrivacy = adapter->securitypriv.PrivacyAlgrthm;
959 psta->ieee8021x_blocked = false;
960 spin_lock_irqsave(&pmlmepriv->lock, irqL);
961 if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) ||
962 (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true)) {
963 if (adapter->stapriv.asoc_sta_count == 2) {
964 /* a sta + bc/mc_stainfo (not Ibss_stainfo) */
965 r8712_indicate_connect(adapter);
968 spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
971 void r8712_stadel_event_callback(struct _adapter *adapter, u8 *pbuf)
973 unsigned long irqL, irqL2;
974 struct sta_info *psta;
975 struct wlan_network *pwlan = NULL;
976 struct wlan_bssid_ex *pdev_network = NULL;
978 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
979 struct stadel_event *pstadel = (struct stadel_event *)pbuf;
980 struct sta_priv *pstapriv = &adapter->stapriv;
981 struct wlan_network *tgt_network = &pmlmepriv->cur_network;
983 spin_lock_irqsave(&pmlmepriv->lock, irqL2);
984 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) {
985 r8712_ind_disconnect(adapter);
986 r8712_free_assoc_resources(adapter);
988 if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE |
990 psta = r8712_get_stainfo(&adapter->stapriv, pstadel->macaddr);
991 spin_lock_irqsave(&pstapriv->sta_hash_lock, irqL);
992 r8712_free_stainfo(adapter, psta);
993 spin_unlock_irqrestore(&pstapriv->sta_hash_lock, irqL);
994 if (adapter->stapriv.asoc_sta_count == 1) {
995 /*a sta + bc/mc_stainfo (not Ibss_stainfo) */
996 pwlan = r8712_find_network(&pmlmepriv->scanned_queue,
997 tgt_network->network.MacAddress);
999 pwlan->fixed = false;
1000 free_network_nolock(pmlmepriv, pwlan);
1003 pdev_network = &(adapter->registrypriv.dev_network);
1004 pibss = adapter->registrypriv.dev_network.MacAddress;
1005 memcpy(pdev_network, &tgt_network->network,
1006 r8712_get_ndis_wlan_bssid_ex_sz(&tgt_network->
1008 memcpy(&pdev_network->Ssid,
1009 &pmlmepriv->assoc_ssid,
1010 sizeof(struct ndis_802_11_ssid));
1011 r8712_update_registrypriv_dev_network(adapter);
1012 r8712_generate_random_ibss(pibss);
1013 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) {
1014 _clr_fwstate_(pmlmepriv, WIFI_ADHOC_STATE);
1015 set_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE);
1019 spin_unlock_irqrestore(&pmlmepriv->lock, irqL2);
1022 void r8712_cpwm_event_callback(struct _adapter *adapter, u8 *pbuf)
1024 struct reportpwrstate_parm *preportpwrstate =
1025 (struct reportpwrstate_parm *)pbuf;
1027 preportpwrstate->state |= (u8)(adapter->pwrctrlpriv.cpwm_tog + 0x80);
1028 r8712_cpwm_int_hdl(adapter, preportpwrstate);
1031 /* When the Netgear 3500 AP is with WPA2PSK-AES mode, it will send
1032 * the ADDBA req frame with start seq control = 0 to wifi client after
1033 * the WPA handshake and the seqence number of following data packet
1034 * will be 0. In this case, the Rx reorder sequence is not longer than 0
1035 * and the WiFi client will drop the data with seq number 0.
1036 * So, the 8712 firmware has to inform driver with receiving the
1037 * ADDBA-Req frame so that the driver can reset the
1038 * sequence value of Rx reorder control.
1040 void r8712_got_addbareq_event_callback(struct _adapter *adapter, u8 *pbuf)
1042 struct ADDBA_Req_Report_parm *pAddbareq_pram =
1043 (struct ADDBA_Req_Report_parm *)pbuf;
1044 struct sta_info *psta;
1045 struct sta_priv *pstapriv = &adapter->stapriv;
1046 struct recv_reorder_ctrl *precvreorder_ctrl = NULL;
1048 psta = r8712_get_stainfo(pstapriv, pAddbareq_pram->MacAddress);
1051 &psta->recvreorder_ctrl[pAddbareq_pram->tid];
1052 /* set the indicate_seq to 0xffff so that the rx reorder
1053 * can store any following data packet.
1055 precvreorder_ctrl->indicate_seq = 0xffff;
1059 void r8712_wpspbc_event_callback(struct _adapter *adapter, u8 *pbuf)
1061 if (adapter->securitypriv.wps_hw_pbc_pressed == false)
1062 adapter->securitypriv.wps_hw_pbc_pressed = true;
1065 void _r8712_sitesurvey_ctrl_handler(struct _adapter *adapter)
1067 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1068 struct sitesurvey_ctrl *psitesurveyctrl = &pmlmepriv->sitesurveyctrl;
1069 struct registry_priv *pregistrypriv = &adapter->registrypriv;
1070 u64 current_tx_pkts;
1071 uint current_rx_pkts;
1073 current_tx_pkts = (adapter->xmitpriv.tx_pkts) -
1074 (psitesurveyctrl->last_tx_pkts);
1075 current_rx_pkts = (adapter->recvpriv.rx_pkts) -
1076 (psitesurveyctrl->last_rx_pkts);
1077 psitesurveyctrl->last_tx_pkts = adapter->xmitpriv.tx_pkts;
1078 psitesurveyctrl->last_rx_pkts = adapter->recvpriv.rx_pkts;
1079 if ((current_tx_pkts > pregistrypriv->busy_thresh) ||
1080 (current_rx_pkts > pregistrypriv->busy_thresh))
1081 psitesurveyctrl->traffic_busy = true;
1083 psitesurveyctrl->traffic_busy = false;
1086 void _r8712_join_timeout_handler(struct _adapter *adapter)
1089 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1091 if (adapter->bDriverStopped || adapter->bSurpriseRemoved)
1093 spin_lock_irqsave(&pmlmepriv->lock, irqL);
1094 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
1095 pmlmepriv->to_join = false;
1096 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
1097 r8712_os_indicate_disconnect(adapter);
1098 _clr_fwstate_(pmlmepriv, _FW_LINKED);
1100 if (adapter->pwrctrlpriv.pwr_mode != adapter->registrypriv.power_mgnt) {
1101 r8712_set_ps_mode(adapter, adapter->registrypriv.power_mgnt,
1102 adapter->registrypriv.smart_ps);
1104 spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
1107 void r8712_scan_timeout_handler (struct _adapter *adapter)
1110 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1112 spin_lock_irqsave(&pmlmepriv->lock, irqL);
1113 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY);
1114 pmlmepriv->to_join = false; /* scan fail, so clear to_join flag */
1115 spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
1118 void _r8712_dhcp_timeout_handler (struct _adapter *adapter)
1120 if (adapter->bDriverStopped || adapter->bSurpriseRemoved)
1122 if (adapter->pwrctrlpriv.pwr_mode != adapter->registrypriv.power_mgnt)
1123 r8712_set_ps_mode(adapter, adapter->registrypriv.power_mgnt,
1124 adapter->registrypriv.smart_ps);
1127 void _r8712_wdg_timeout_handler(struct _adapter *adapter)
1129 r8712_wdg_wk_cmd(adapter);
1132 int r8712_select_and_join_from_scan(struct mlme_priv *pmlmepriv)
1134 struct list_head *phead;
1135 unsigned char *dst_ssid, *src_ssid;
1136 struct _adapter *adapter;
1137 struct __queue *queue = NULL;
1138 struct wlan_network *pnetwork = NULL;
1139 struct wlan_network *pnetwork_max_rssi = NULL;
1141 adapter = (struct _adapter *)pmlmepriv->nic_hdl;
1142 queue = &pmlmepriv->scanned_queue;
1143 phead = &queue->queue;
1144 pmlmepriv->pscanned = phead->next;
1146 if (end_of_queue_search(phead, pmlmepriv->pscanned) == true) {
1147 if ((pmlmepriv->assoc_by_rssi == true) &&
1148 (pnetwork_max_rssi != NULL)) {
1149 pnetwork = pnetwork_max_rssi;
1150 goto ask_for_joinbss;
1154 pnetwork = LIST_CONTAINOR(pmlmepriv->pscanned,
1155 struct wlan_network, list);
1156 if (pnetwork == NULL)
1158 pmlmepriv->pscanned = pmlmepriv->pscanned->next;
1159 if (pmlmepriv->assoc_by_bssid == true) {
1160 dst_ssid = pnetwork->network.MacAddress;
1161 src_ssid = pmlmepriv->assoc_bssid;
1162 if (!memcmp(dst_ssid, src_ssid, ETH_ALEN)) {
1163 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
1164 if (is_same_network(&pmlmepriv->
1165 cur_network.network,
1166 &pnetwork->network)) {
1167 _clr_fwstate_(pmlmepriv,
1169 /*r8712_indicate_connect again*/
1170 r8712_indicate_connect(adapter);
1173 r8712_disassoc_cmd(adapter);
1174 r8712_ind_disconnect(adapter);
1175 r8712_free_assoc_resources(adapter);
1177 goto ask_for_joinbss;
1179 } else if (pmlmepriv->assoc_ssid.SsidLength == 0)
1180 goto ask_for_joinbss;
1181 dst_ssid = pnetwork->network.Ssid.Ssid;
1182 src_ssid = pmlmepriv->assoc_ssid.Ssid;
1183 if ((pnetwork->network.Ssid.SsidLength ==
1184 pmlmepriv->assoc_ssid.SsidLength) &&
1185 (!memcmp(dst_ssid, src_ssid,
1186 pmlmepriv->assoc_ssid.SsidLength))) {
1187 if (pmlmepriv->assoc_by_rssi == true) {
1188 /* if the ssid is the same, select the bss
1189 * which has the max rssi*/
1190 if (pnetwork_max_rssi) {
1191 if (pnetwork->network.Rssi >
1192 pnetwork_max_rssi->network.Rssi)
1193 pnetwork_max_rssi = pnetwork;
1195 pnetwork_max_rssi = pnetwork;
1196 } else if (is_desired_network(adapter, pnetwork)) {
1197 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
1198 r8712_disassoc_cmd(adapter);
1199 r8712_free_assoc_resources(adapter);
1201 goto ask_for_joinbss;
1207 return r8712_joinbss_cmd(adapter, pnetwork);
1210 sint r8712_set_auth(struct _adapter *adapter,
1211 struct security_priv *psecuritypriv)
1213 struct cmd_priv *pcmdpriv = &adapter->cmdpriv;
1214 struct cmd_obj *pcmd;
1215 struct setauth_parm *psetauthparm;
1217 pcmd = kmalloc(sizeof(*pcmd), GFP_ATOMIC);
1221 psetauthparm = kzalloc(sizeof(*psetauthparm), GFP_ATOMIC);
1222 if (psetauthparm == NULL) {
1226 psetauthparm->mode = (u8)psecuritypriv->AuthAlgrthm;
1227 pcmd->cmdcode = _SetAuth_CMD_;
1228 pcmd->parmbuf = (unsigned char *)psetauthparm;
1229 pcmd->cmdsz = sizeof(struct setauth_parm);
1232 INIT_LIST_HEAD(&pcmd->list);
1233 r8712_enqueue_cmd(pcmdpriv, pcmd);
1237 sint r8712_set_key(struct _adapter *adapter,
1238 struct security_priv *psecuritypriv,
1241 struct cmd_priv *pcmdpriv = &adapter->cmdpriv;
1242 struct cmd_obj *pcmd;
1243 struct setkey_parm *psetkeyparm;
1245 sint ret = _SUCCESS;
1247 pcmd = kmalloc(sizeof(*pcmd), GFP_ATOMIC);
1250 psetkeyparm = kzalloc(sizeof(*psetkeyparm), GFP_ATOMIC);
1251 if (psetkeyparm == NULL) {
1255 if (psecuritypriv->AuthAlgrthm == 2) { /* 802.1X */
1256 psetkeyparm->algorithm =
1257 (u8)psecuritypriv->XGrpPrivacy;
1259 psetkeyparm->algorithm =
1260 (u8)psecuritypriv->PrivacyAlgrthm;
1262 psetkeyparm->keyid = (u8)keyid;
1264 switch (psetkeyparm->algorithm) {
1267 memcpy(psetkeyparm->key,
1268 psecuritypriv->DefKey[keyid].skey, keylen);
1272 memcpy(psetkeyparm->key,
1273 psecuritypriv->DefKey[keyid].skey, keylen);
1276 if (keyid < 1 || keyid > 2) {
1281 memcpy(psetkeyparm->key,
1282 &psecuritypriv->XGrpKey[keyid - 1], keylen);
1283 psetkeyparm->grpkey = 1;
1286 if (keyid < 1 || keyid > 2) {
1291 memcpy(psetkeyparm->key,
1292 &psecuritypriv->XGrpKey[keyid - 1], keylen);
1293 psetkeyparm->grpkey = 1;
1299 pcmd->cmdcode = _SetKey_CMD_;
1300 pcmd->parmbuf = (u8 *)psetkeyparm;
1301 pcmd->cmdsz = (sizeof(struct setkey_parm));
1304 INIT_LIST_HEAD(&pcmd->list);
1305 r8712_enqueue_cmd(pcmdpriv, pcmd);
1315 /* adjust IEs for r8712_joinbss_cmd in WMM */
1316 int r8712_restruct_wmm_ie(struct _adapter *adapter, u8 *in_ie, u8 *out_ie,
1317 uint in_len, uint initial_out_len)
1319 unsigned int ielength = 0;
1322 i = 12; /* after the fixed IE */
1323 while (i < in_len) {
1324 ielength = initial_out_len;
1325 if (in_ie[i] == 0xDD && in_ie[i + 2] == 0x00 &&
1326 in_ie[i + 3] == 0x50 && in_ie[i + 4] == 0xF2 &&
1327 in_ie[i + 5] == 0x02 && i + 5 < in_len) {
1328 /*WMM element ID and OUI*/
1329 for (j = i; j < i + 9; j++) {
1330 out_ie[ielength] = in_ie[j];
1333 out_ie[initial_out_len + 1] = 0x07;
1334 out_ie[initial_out_len + 6] = 0x00;
1335 out_ie[initial_out_len + 8] = 0x00;
1338 i += (in_ie[i + 1] + 2); /* to the next IE element */
1344 * Ported from 8185: IsInPreAuthKeyList().
1348 * -1 :if there is no pre-auth key in the table
1349 * >=0 :if there is pre-auth key, and return the entry id
1351 static int SecIsInPMKIDList(struct _adapter *Adapter, u8 *bssid)
1353 struct security_priv *psecuritypriv = &Adapter->securitypriv;
1357 if (psecuritypriv->PMKIDList[i].bUsed &&
1358 (!memcmp(psecuritypriv->PMKIDList[i].Bssid,
1363 } while (i < NUM_PMKID_CACHE);
1365 if (i == NUM_PMKID_CACHE) {
1366 i = -1; /* Could not find. */
1368 ; /* There is one Pre-Authentication Key for the
1369 * specific BSSID. */
1374 sint r8712_restruct_sec_ie(struct _adapter *adapter, u8 *in_ie,
1375 u8 *out_ie, uint in_len)
1377 u8 authmode = 0, match;
1378 u8 sec_ie[255], uncst_oui[4], bkup_ie[255];
1379 u8 wpa_oui[4] = {0x0, 0x50, 0xf2, 0x01};
1380 uint ielength, cnt, remove_cnt;
1382 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1383 struct security_priv *psecuritypriv = &adapter->securitypriv;
1384 uint ndisauthmode = psecuritypriv->ndisauthtype;
1385 uint ndissecuritytype = psecuritypriv->ndisencryptstatus;
1387 if ((ndisauthmode == Ndis802_11AuthModeWPA) ||
1388 (ndisauthmode == Ndis802_11AuthModeWPAPSK)) {
1389 authmode = _WPA_IE_ID_;
1391 uncst_oui[1] = 0x50;
1392 uncst_oui[2] = 0xf2;
1394 if ((ndisauthmode == Ndis802_11AuthModeWPA2) ||
1395 (ndisauthmode == Ndis802_11AuthModeWPA2PSK)) {
1396 authmode = _WPA2_IE_ID_;
1398 uncst_oui[1] = 0x0f;
1399 uncst_oui[2] = 0xac;
1401 switch (ndissecuritytype) {
1402 case Ndis802_11Encryption1Enabled:
1403 case Ndis802_11Encryption1KeyAbsent:
1406 case Ndis802_11Encryption2Enabled:
1407 case Ndis802_11Encryption2KeyAbsent:
1410 case Ndis802_11Encryption3Enabled:
1411 case Ndis802_11Encryption3KeyAbsent:
1417 /*Search required WPA or WPA2 IE and copy to sec_ie[] */
1420 while (cnt < in_len) {
1421 if (in_ie[cnt] == authmode) {
1422 if ((authmode == _WPA_IE_ID_) &&
1423 (!memcmp(&in_ie[cnt+2], &wpa_oui[0], 4))) {
1424 memcpy(&sec_ie[0], &in_ie[cnt],
1425 in_ie[cnt + 1] + 2);
1429 if (authmode == _WPA2_IE_ID_) {
1430 memcpy(&sec_ie[0], &in_ie[cnt],
1431 in_ie[cnt + 1] + 2);
1435 if (((authmode == _WPA_IE_ID_) &&
1436 (!memcmp(&in_ie[cnt + 2], &wpa_oui[0], 4))) ||
1437 (authmode == _WPA2_IE_ID_))
1438 memcpy(&bkup_ie[0], &in_ie[cnt],
1439 in_ie[cnt + 1] + 2);
1441 cnt += in_ie[cnt+1] + 2; /*get next*/
1443 /*restruct WPA IE or WPA2 IE in sec_ie[] */
1444 if (match == true) {
1445 if (sec_ie[0] == _WPA_IE_ID_) {
1446 /* parsing SSN IE to select required encryption
1447 * algorithm, and set the bc/mc encryption algorithm */
1449 /*check wpa_oui tag*/
1450 if (memcmp(&sec_ie[2], &wpa_oui[0], 4)) {
1454 if ((sec_ie[6] != 0x01) || (sec_ie[7] != 0x0)) {
1459 if (!memcmp(&sec_ie[8], &wpa_oui[0], 3)) {
1460 /* get bc/mc encryption type (group
1462 switch (sec_ie[11]) {
1464 psecuritypriv->XGrpPrivacy =
1467 case 0x1: /*WEP_40*/
1468 psecuritypriv->XGrpPrivacy =
1472 psecuritypriv->XGrpPrivacy =
1475 case 0x3: /*AESCCMP*/
1477 psecuritypriv->XGrpPrivacy =
1480 case 0x5: /*WEP_104*/
1481 psecuritypriv->XGrpPrivacy =
1489 if (sec_ie[12] == 0x01) {
1490 /*check the unicast encryption type*/
1491 if (memcmp(&sec_ie[14],
1492 &uncst_oui[0], 4)) {
1496 } /*else the uncst_oui is match*/
1497 } else { /*mixed mode, unicast_enc_type > 1*/
1498 /*select the uncst_oui and remove
1499 * the other uncst_oui*/
1501 remove_cnt = (cnt-1) * 4;
1503 memcpy(&sec_ie[14], &uncst_oui[0], 4);
1504 /*remove the other unicast suit*/
1506 &sec_ie[18 + remove_cnt],
1507 sec_ie[1] - 18 + 2 -
1509 sec_ie[1] = sec_ie[1] - remove_cnt;
1514 if (authmode == _WPA2_IE_ID_) {
1515 /* parsing RSN IE to select required encryption
1516 * algorithm, and set the bc/mc encryption algorithm */
1518 if ((sec_ie[2] != 0x01) || (sec_ie[3] != 0x0)) {
1523 if (!memcmp(&sec_ie[4], &uncst_oui[0], 3)) {
1524 /*get bc/mc encryption type*/
1525 switch (sec_ie[7]) {
1526 case 0x1: /*WEP_40*/
1527 psecuritypriv->XGrpPrivacy =
1531 psecuritypriv->XGrpPrivacy =
1534 case 0x4: /*AESWRAP*/
1535 psecuritypriv->XGrpPrivacy =
1538 case 0x5: /*WEP_104*/
1539 psecuritypriv->XGrpPrivacy =
1543 psecuritypriv->XGrpPrivacy =
1551 if (sec_ie[8] == 0x01) {
1552 /*check the unicast encryption type*/
1553 if (memcmp(&sec_ie[10],
1554 &uncst_oui[0], 4)) {
1557 } /*else the uncst_oui is match*/
1558 } else { /*mixed mode, unicast_enc_type > 1*/
1559 /*select the uncst_oui and remove the
1562 remove_cnt = (cnt-1)*4;
1564 memcpy(&sec_ie[10], &uncst_oui[0], 4);
1565 /*remove the other unicast suit*/
1567 &sec_ie[14 + remove_cnt],
1568 (sec_ie[1] - 14 + 2 -
1570 sec_ie[1] = sec_ie[1]-remove_cnt;
1576 if ((authmode == _WPA_IE_ID_) || (authmode == _WPA2_IE_ID_)) {
1578 memcpy(out_ie, in_ie, 12);
1581 if (match == true) {
1582 memcpy(&out_ie[ielength], &sec_ie[0], sec_ie[1]+2);
1583 ielength += sec_ie[1] + 2;
1584 if (authmode == _WPA2_IE_ID_) {
1585 /*the Pre-Authentication bit should be zero*/
1586 out_ie[ielength - 1] = 0;
1587 out_ie[ielength - 2] = 0;
1589 r8712_report_sec_ie(adapter, authmode, sec_ie);
1592 /*copy fixed ie only*/
1593 memcpy(out_ie, in_ie, 12);
1595 if (psecuritypriv->wps_phase == true) {
1596 memcpy(out_ie+ielength, psecuritypriv->wps_ie,
1597 psecuritypriv->wps_ie_len);
1598 ielength += psecuritypriv->wps_ie_len;
1601 iEntry = SecIsInPMKIDList(adapter, pmlmepriv->assoc_bssid);
1605 if (authmode == _WPA2_IE_ID_) {
1606 out_ie[ielength] = 1;
1608 out_ie[ielength] = 0; /*PMKID count = 0x0100*/
1610 memcpy(&out_ie[ielength],
1611 &psecuritypriv->PMKIDList[iEntry].PMKID, 16);
1613 out_ie[13] += 18;/*PMKID length = 2+16*/
1619 void r8712_init_registrypriv_dev_network(struct _adapter *adapter)
1621 struct registry_priv *pregistrypriv = &adapter->registrypriv;
1622 struct eeprom_priv *peepriv = &adapter->eeprompriv;
1623 struct wlan_bssid_ex *pdev_network = &pregistrypriv->dev_network;
1624 u8 *myhwaddr = myid(peepriv);
1626 memcpy(pdev_network->MacAddress, myhwaddr, ETH_ALEN);
1627 memcpy(&pdev_network->Ssid, &pregistrypriv->ssid,
1628 sizeof(struct ndis_802_11_ssid));
1629 pdev_network->Configuration.Length =
1630 sizeof(struct NDIS_802_11_CONFIGURATION);
1631 pdev_network->Configuration.BeaconPeriod = 100;
1632 pdev_network->Configuration.FHConfig.Length = 0;
1633 pdev_network->Configuration.FHConfig.HopPattern = 0;
1634 pdev_network->Configuration.FHConfig.HopSet = 0;
1635 pdev_network->Configuration.FHConfig.DwellTime = 0;
1638 void r8712_update_registrypriv_dev_network(struct _adapter *adapter)
1641 struct registry_priv *pregistrypriv = &adapter->registrypriv;
1642 struct wlan_bssid_ex *pdev_network = &pregistrypriv->dev_network;
1643 struct security_priv *psecuritypriv = &adapter->securitypriv;
1644 struct wlan_network *cur_network = &adapter->mlmepriv.cur_network;
1646 pdev_network->Privacy = cpu_to_le32(psecuritypriv->PrivacyAlgrthm
1647 > 0 ? 1 : 0); /* adhoc no 802.1x */
1648 pdev_network->Rssi = 0;
1649 switch (pregistrypriv->wireless_mode) {
1651 pdev_network->NetworkTypeInUse = cpu_to_le32(Ndis802_11DS);
1655 pdev_network->NetworkTypeInUse = cpu_to_le32(Ndis802_11OFDM24);
1658 pdev_network->NetworkTypeInUse = cpu_to_le32(Ndis802_11OFDM5);
1664 pdev_network->Configuration.DSConfig = cpu_to_le32(
1665 pregistrypriv->channel);
1666 if (cur_network->network.InfrastructureMode == Ndis802_11IBSS)
1667 pdev_network->Configuration.ATIMWindow = cpu_to_le32(3);
1668 pdev_network->InfrastructureMode = cpu_to_le32(
1669 cur_network->network.InfrastructureMode);
1670 /* 1. Supported rates
1673 sz = r8712_generate_ie(pregistrypriv);
1674 pdev_network->IELength = sz;
1675 pdev_network->Length = r8712_get_ndis_wlan_bssid_ex_sz(
1676 (struct ndis_wlan_bssid_ex *)pdev_network);
1679 /*the function is at passive_level*/
1680 void r8712_joinbss_reset(struct _adapter *padapter)
1683 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1684 struct ht_priv *phtpriv = &pmlmepriv->htpriv;
1686 /* todo: if you want to do something io/reg/hw setting before join_bss,
1687 * please add code here */
1688 phtpriv->ampdu_enable = false;/*reset to disabled*/
1689 for (i = 0; i < 16; i++)
1690 phtpriv->baddbareq_issued[i] = false;/*reset it*/
1691 if (phtpriv->ht_option) {
1692 /* validate usb rx aggregation */
1693 r8712_write8(padapter, 0x102500D9, 48);/*TH = 48 pages, 6k*/
1695 /* invalidate usb rx aggregation */
1696 /* TH=1 => means that invalidate usb rx aggregation */
1697 r8712_write8(padapter, 0x102500D9, 1);
1701 /*the function is >= passive_level*/
1702 unsigned int r8712_restructure_ht_ie(struct _adapter *padapter, u8 *in_ie,
1703 u8 *out_ie, uint in_len, uint *pout_len)
1707 struct ieee80211_ht_cap ht_capie;
1708 unsigned char WMM_IE[] = {0x00, 0x50, 0xf2, 0x02, 0x00, 0x01, 0x00};
1709 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1710 struct qos_priv *pqospriv = &pmlmepriv->qospriv;
1711 struct ht_priv *phtpriv = &pmlmepriv->htpriv;
1713 phtpriv->ht_option = 0;
1714 p = r8712_get_ie(in_ie+12, _HT_CAPABILITY_IE_, &ielen, in_len-12);
1715 if (p && (ielen > 0)) {
1716 if (pqospriv->qos_option == 0) {
1717 out_len = *pout_len;
1718 r8712_set_ie(out_ie+out_len, _VENDOR_SPECIFIC_IE_,
1719 _WMM_IE_Length_, WMM_IE, pout_len);
1720 pqospriv->qos_option = 1;
1722 out_len = *pout_len;
1723 memset(&ht_capie, 0, sizeof(struct ieee80211_ht_cap));
1724 ht_capie.cap_info = IEEE80211_HT_CAP_SUP_WIDTH |
1725 IEEE80211_HT_CAP_SGI_20 |
1726 IEEE80211_HT_CAP_SGI_40 |
1727 IEEE80211_HT_CAP_TX_STBC |
1728 IEEE80211_HT_CAP_MAX_AMSDU |
1729 IEEE80211_HT_CAP_DSSSCCK40;
1730 ht_capie.ampdu_params_info = (IEEE80211_HT_CAP_AMPDU_FACTOR &
1731 0x03) | (IEEE80211_HT_CAP_AMPDU_DENSITY & 0x00);
1732 r8712_set_ie(out_ie+out_len, _HT_CAPABILITY_IE_,
1733 sizeof(struct ieee80211_ht_cap),
1734 (unsigned char *)&ht_capie, pout_len);
1735 phtpriv->ht_option = 1;
1737 return phtpriv->ht_option;
1740 /* the function is > passive_level (in critical_section) */
1741 static void update_ht_cap(struct _adapter *padapter, u8 *pie, uint ie_len)
1743 u8 *p, max_ampdu_sz;
1745 struct sta_info *bmc_sta, *psta;
1746 struct ieee80211_ht_cap *pht_capie;
1747 struct recv_reorder_ctrl *preorder_ctrl;
1748 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1749 struct ht_priv *phtpriv = &pmlmepriv->htpriv;
1750 struct registry_priv *pregistrypriv = &padapter->registrypriv;
1751 struct wlan_network *pcur_network = &(pmlmepriv->cur_network);
1753 if (!phtpriv->ht_option)
1755 /* maybe needs check if ap supports rx ampdu. */
1756 if ((phtpriv->ampdu_enable == false) &&
1757 (pregistrypriv->ampdu_enable == 1))
1758 phtpriv->ampdu_enable = true;
1759 /*check Max Rx A-MPDU Size*/
1761 p = r8712_get_ie(pie + sizeof(struct NDIS_802_11_FIXED_IEs),
1764 sizeof(struct NDIS_802_11_FIXED_IEs));
1766 pht_capie = (struct ieee80211_ht_cap *)(p+2);
1767 max_ampdu_sz = (pht_capie->ampdu_params_info &
1768 IEEE80211_HT_CAP_AMPDU_FACTOR);
1769 /* max_ampdu_sz (kbytes); */
1770 max_ampdu_sz = 1 << (max_ampdu_sz+3);
1771 phtpriv->rx_ampdu_maxlen = max_ampdu_sz;
1773 /* for A-MPDU Rx reordering buffer control for bmc_sta & sta_info
1774 * if A-MPDU Rx is enabled, resetting rx_ordering_ctrl
1775 * wstart_b(indicate_seq) to default value=0xffff
1776 * todo: check if AP can send A-MPDU packets
1778 bmc_sta = r8712_get_bcmc_stainfo(padapter);
1780 for (i = 0; i < 16; i++) {
1781 preorder_ctrl = &bmc_sta->recvreorder_ctrl[i];
1782 preorder_ctrl->indicate_seq = 0xffff;
1783 preorder_ctrl->wend_b = 0xffff;
1786 psta = r8712_get_stainfo(&padapter->stapriv,
1787 pcur_network->network.MacAddress);
1789 for (i = 0; i < 16; i++) {
1790 preorder_ctrl = &psta->recvreorder_ctrl[i];
1791 preorder_ctrl->indicate_seq = 0xffff;
1792 preorder_ctrl->wend_b = 0xffff;
1796 p = r8712_get_ie(pie + sizeof(struct NDIS_802_11_FIXED_IEs),
1797 _HT_ADD_INFO_IE_, &len,
1798 ie_len-sizeof(struct NDIS_802_11_FIXED_IEs));
1801 void r8712_issue_addbareq_cmd(struct _adapter *padapter, int priority)
1803 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1804 struct ht_priv *phtpriv = &pmlmepriv->htpriv;
1806 if ((phtpriv->ht_option == 1) && (phtpriv->ampdu_enable == true)) {
1807 if (phtpriv->baddbareq_issued[priority] == false) {
1808 r8712_addbareq_cmd(padapter, (u8)priority);
1809 phtpriv->baddbareq_issued[priority] = true;