]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/staging/rtl8723au/core/rtw_mlme.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
staging: rtl8723au: Improve some bad switch() formatting
[mirror_ubuntu-artful-kernel.git] / drivers / staging / rtl8723au / core / rtw_mlme.c
CommitLineData
5e93f352
LF		 1/******************************************************************************
2 *
3 * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 ******************************************************************************/
15#define _RTW_MLME_C_
16
17#include <osdep_service.h>
18#include <drv_types.h>
19#include <recv_osdep.h>
20#include <xmit_osdep.h>
21#include <hal_intf.h>
22#include <mlme_osdep.h>
23#include <sta_info.h>
24#include <linux/ieee80211.h>
25#include <wifi.h>
26#include <wlan_bssdef.h>
27#include <rtw_ioctl_set.h>
28
29extern u8 rtw_do_join23a(struct rtw_adapter * padapter);
30
31static void rtw_init_mlme_timer(struct rtw_adapter *padapter)
32{
33 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
34
35 setup_timer(&pmlmepriv->assoc_timer, rtw23a_join_to_handler,
36 (unsigned long)padapter);
37
38 setup_timer(&pmlmepriv->scan_to_timer, rtw_scan_timeout_handler23a,
39 (unsigned long)padapter);
40
41 setup_timer(&pmlmepriv->dynamic_chk_timer,
42 rtw_dynamic_check_timer_handler, (unsigned long)padapter);
43
44 setup_timer(&pmlmepriv->set_scan_deny_timer,
45 rtw_set_scan_deny_timer_hdl, (unsigned long)padapter);
46}
47
48int _rtw_init_mlme_priv23a(struct rtw_adapter *padapter)
49{
50 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
51 int res = _SUCCESS;
52
53 pmlmepriv->nic_hdl = padapter;
54
55 pmlmepriv->fw_state = 0;
56 pmlmepriv->cur_network.network.InfrastructureMode = Ndis802_11AutoUnknown;
57 pmlmepriv->scan_mode=SCAN_ACTIVE;/* 1: active, 0: pasive. Maybe someday we should rename this varable to "active_mode" (Jeff) */
58
59 spin_lock_init(&pmlmepriv->lock);
60 _rtw_init_queue23a(&pmlmepriv->scanned_queue);
61
62 memset(&pmlmepriv->assoc_ssid, 0, sizeof(struct cfg80211_ssid));
63
64 /* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */
65
66 rtw_clear_scan_deny(padapter);
67
68 rtw_init_mlme_timer(padapter);
69 return res;
70}
71
c17416ef 72#ifdef CONFIG_8723AU_AP_MODE
5e93f352
LF		 73static void rtw_free_mlme_ie_data(u8 **ppie, u32 *plen)
74{
75 if(*ppie)
76 {
77 kfree(*ppie);
78 *plen = 0;
79 *ppie=NULL;
80 }
81}
c17416ef 82#endif
5e93f352
LF		 83
84void rtw23a_free_mlme_priv_ie_data(struct mlme_priv *pmlmepriv)
85{
86#ifdef CONFIG_8723AU_AP_MODE
87 kfree(pmlmepriv->assoc_req);
88 kfree(pmlmepriv->assoc_rsp);
89 rtw_free_mlme_ie_data(&pmlmepriv->wps_beacon_ie, &pmlmepriv->wps_beacon_ie_len);
90 rtw_free_mlme_ie_data(&pmlmepriv->wps_probe_req_ie, &pmlmepriv->wps_probe_req_ie_len);
91 rtw_free_mlme_ie_data(&pmlmepriv->wps_probe_resp_ie, &pmlmepriv->wps_probe_resp_ie_len);
92 rtw_free_mlme_ie_data(&pmlmepriv->wps_assoc_resp_ie, &pmlmepriv->wps_assoc_resp_ie_len);
93
94 rtw_free_mlme_ie_data(&pmlmepriv->p2p_beacon_ie, &pmlmepriv->p2p_beacon_ie_len);
95 rtw_free_mlme_ie_data(&pmlmepriv->p2p_probe_req_ie, &pmlmepriv->p2p_probe_req_ie_len);
96 rtw_free_mlme_ie_data(&pmlmepriv->p2p_probe_resp_ie, &pmlmepriv->p2p_probe_resp_ie_len);
97 rtw_free_mlme_ie_data(&pmlmepriv->p2p_go_probe_resp_ie, &pmlmepriv->p2p_go_probe_resp_ie_len);
98 rtw_free_mlme_ie_data(&pmlmepriv->p2p_assoc_req_ie, &pmlmepriv->p2p_assoc_req_ie_len);
5e93f352 99
5e93f352
LF		 100 rtw_free_mlme_ie_data(&pmlmepriv->wfd_beacon_ie, &pmlmepriv->wfd_beacon_ie_len);
101 rtw_free_mlme_ie_data(&pmlmepriv->wfd_probe_req_ie, &pmlmepriv->wfd_probe_req_ie_len);
102 rtw_free_mlme_ie_data(&pmlmepriv->wfd_probe_resp_ie, &pmlmepriv->wfd_probe_resp_ie_len);
103 rtw_free_mlme_ie_data(&pmlmepriv->wfd_go_probe_resp_ie, &pmlmepriv->wfd_go_probe_resp_ie_len);
104 rtw_free_mlme_ie_data(&pmlmepriv->wfd_assoc_req_ie, &pmlmepriv->wfd_assoc_req_ie_len);
105#endif
106}
107
108void _rtw_free_mlme_priv23a(struct mlme_priv *pmlmepriv)
109{
110
111 rtw23a_free_mlme_priv_ie_data(pmlmepriv);
112
113}
114
115struct wlan_network *rtw_alloc_network(struct mlme_priv *pmlmepriv)
116{
117 struct wlan_network *pnetwork;
118
119 pnetwork = kzalloc(sizeof(struct wlan_network), GFP_ATOMIC);
120 if (pnetwork) {
121 INIT_LIST_HEAD(&pnetwork->list);
122 pnetwork->network_type = 0;
123 pnetwork->fixed = false;
124 pnetwork->last_scanned = jiffies;
125 pnetwork->aid = 0;
126 pnetwork->join_res = 0;
127 }
128
129 return pnetwork;
130}
131
132void _rtw_free_network23a(struct mlme_priv *pmlmepriv,
133 struct wlan_network *pnetwork, u8 isfreeall)
134{
135 u32 lifetime = SCANQUEUE_LIFETIME;
136
137 if (!pnetwork)
138 return;
139
140 if (pnetwork->fixed == true)
141 return;
142
143 if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) ||
144 (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true))
145 lifetime = 1;
146
147 list_del_init(&pnetwork->list);
148
149 kfree(pnetwork);
150}
151
152void _rtw_free_network23a_nolock23a(struct mlme_priv *pmlmepriv,
153 struct wlan_network *pnetwork)
154{
155
156 if (pnetwork == NULL)
157 return;
158
159 if (pnetwork->fixed == true)
160 return;
161
162 list_del_init(&pnetwork->list);
163
164 kfree(pnetwork);
165}
166
167/*
168 return the wlan_network with the matching addr
169
170 Shall be calle under atomic context... to avoid possible racing condition...
171*/
172struct wlan_network *
173_rtw_find_network23a(struct rtw_queue *scanned_queue, u8 *addr)
174{
175 struct list_head *phead, *plist;
176 struct wlan_network *pnetwork = NULL;
177
178 if (is_zero_ether_addr(addr)) {
179 pnetwork = NULL;
180 goto exit;
181 }
182
183 /* spin_lock_bh(&scanned_queue->lock); */
184
185 phead = get_list_head(scanned_queue);
186 plist = phead->next;
187
188 while (plist != phead) {
189 pnetwork = container_of(plist, struct wlan_network, list);
190
191 if (ether_addr_equal(addr, pnetwork->network.MacAddress))
192 break;
193
194 plist = plist->next;
195 }
196
197 if(plist == phead)
198 pnetwork = NULL;
199
200 /* spin_unlock_bh(&scanned_queue->lock); */
201
202exit:
203
204 return pnetwork;
205}
206
207void _rtw_free_network23a_queue23a(struct rtw_adapter *padapter, u8 isfreeall)
208{
209 struct list_head *phead, *plist, *ptmp;
210 struct wlan_network *pnetwork;
211 struct mlme_priv* pmlmepriv = &padapter->mlmepriv;
212 struct rtw_queue *scanned_queue = &pmlmepriv->scanned_queue;
213
214 spin_lock_bh(&scanned_queue->lock);
215
216 phead = get_list_head(scanned_queue);
217
218 list_for_each_safe(plist, ptmp, phead) {
219 pnetwork = container_of(plist, struct wlan_network, list);
220
221 _rtw_free_network23a(pmlmepriv,pnetwork, isfreeall);
222 }
223
224 spin_unlock_bh(&scanned_queue->lock);
225
226}
227
228int rtw_if_up23a(struct rtw_adapter *padapter) {
229
230 int res;
231
232 if(padapter->bDriverStopped || padapter->bSurpriseRemoved ||
233 (check_fwstate(&padapter->mlmepriv, _FW_LINKED)== false)) {
234 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_if_up23a:bDriverStopped(%d) OR bSurpriseRemoved(%d)", padapter->bDriverStopped, padapter->bSurpriseRemoved));
235 res=false;
236 }
237 else
238 res= true;
239
240 return res;
241}
242
243void rtw_generate_random_ibss23a(u8* pibss)
244{
245 unsigned long curtime = jiffies;
246
247 pibss[0] = 0x02; /* in ad-hoc mode bit1 must set to 1 */
248 pibss[1] = 0x11;
249 pibss[2] = 0x87;
250 pibss[3] = (u8)(curtime & 0xff) ;/* p[0]; */
251 pibss[4] = (u8)((curtime>>8) & 0xff) ;/* p[1]; */
252 pibss[5] = (u8)((curtime>>16) & 0xff) ;/* p[2]; */
253
254 return;
255}
256
257u8 *rtw_get_capability23a_from_ie(u8 *ie)
258{
259 return ie + 8 + 2;
260}
261
262u16 rtw_get_capability23a(struct wlan_bssid_ex *bss)
263{
264 u16 val;
265
266 memcpy((u8 *)&val, rtw_get_capability23a_from_ie(bss->IEs), 2);
267
268 return le16_to_cpu(val);
269}
270
271u8 *rtw_get_timestampe_from_ie23a(u8 *ie)
272{
273 return ie + 0;
274}
275
276u8 *rtw_get_beacon_interval23a_from_ie(u8 *ie)
277{
278 return ie + 8;
279}
280
281int rtw_init_mlme_priv23a (struct rtw_adapter *padapter)/* struct mlme_priv *pmlmepriv) */
282{
283 int res;
284
285 res = _rtw_init_mlme_priv23a(padapter);/* (pmlmepriv); */
286
287 return res;
288}
289
290void rtw_free_mlme_priv23a (struct mlme_priv *pmlmepriv)
291{
292
293 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_, ("rtw_free_mlme_priv23a\n"));
294 _rtw_free_mlme_priv23a(pmlmepriv);
295
296}
297
298void rtw_free_network(struct mlme_priv *pmlmepriv, struct wlan_network *pnetwork, u8 is_freeall);
299void rtw_free_network(struct mlme_priv *pmlmepriv, struct wlan_network *pnetwork, u8 is_freeall)/* struct wlan_network *pnetwork, _queue *free_queue) */
300{
301
302 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
303 ("rtw_free_network ==> ssid = %s\n\n" ,
304 pnetwork->network.Ssid.ssid));
305 _rtw_free_network23a(pmlmepriv, pnetwork, is_freeall);
306
307}
308
309void rtw_free_network_nolock(struct mlme_priv *pmlmepriv, struct wlan_network *pnetwork);
310void rtw_free_network_nolock(struct mlme_priv *pmlmepriv, struct wlan_network *pnetwork)
311{
312
313 /* RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_, ("rtw_free_network ==> ssid = %s\n\n" , pnetwork->network.Ssid.ssid)); */
314 _rtw_free_network23a_nolock23a(pmlmepriv, pnetwork);
315
316}
317
318void rtw_free_network_queue23a(struct rtw_adapter* dev, u8 isfreeall)
319{
320
321 _rtw_free_network23a_queue23a(dev, isfreeall);
322
323}
324
325/*
326 return the wlan_network with the matching addr
327
328 Shall be calle under atomic context... to avoid possible racing condition...
329*/
330struct wlan_network *
331rtw_find_network23a(struct rtw_queue *scanned_queue, u8 *addr)
332{
333 struct wlan_network *pnetwork;
334
335 pnetwork = _rtw_find_network23a(scanned_queue, addr);
336
337 return pnetwork;
338}
339
340int rtw_is_same_ibss23a(struct rtw_adapter *adapter, struct wlan_network *pnetwork)
341{
342 int ret = true;
343 struct security_priv *psecuritypriv = &adapter->securitypriv;
344
345 if ((psecuritypriv->dot11PrivacyAlgrthm != _NO_PRIVACY_) &&
346 (pnetwork->network.Privacy == 0))
347 {
348 ret = false;
349 }
350 else if ((psecuritypriv->dot11PrivacyAlgrthm == _NO_PRIVACY_) &&
351 (pnetwork->network.Privacy == 1))
352 {
353 ret = false;
354 }
355 else
356 {
357 ret = true;
358 }
359
360 return ret;
361}
362
363inline int is_same_ess(struct wlan_bssid_ex *a, struct wlan_bssid_ex *b);
364inline int is_same_ess(struct wlan_bssid_ex *a, struct wlan_bssid_ex *b)
365{
366 /* RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_, ("(%s,%d)(%s,%d)\n", */
367 /* a->Ssid.Ssid, a->Ssid.SsidLength, b->Ssid.Ssid, b->Ssid.SsidLength)); */
368 return (a->Ssid.ssid_len == b->Ssid.ssid_len) &&
369 !memcmp(a->Ssid.ssid, b->Ssid.ssid, a->Ssid.ssid_len);
370}
371
372int is_same_network23a(struct wlan_bssid_ex *src, struct wlan_bssid_ex *dst)
373{
374 u16 s_cap, d_cap;
375
376 memcpy((u8 *)&s_cap, rtw_get_capability23a_from_ie(src->IEs), 2);
377 memcpy((u8 *)&d_cap, rtw_get_capability23a_from_ie(dst->IEs), 2);
378
379 s_cap = le16_to_cpu(s_cap);
380 d_cap = le16_to_cpu(d_cap);
381
382 return ((src->Ssid.ssid_len == dst->Ssid.ssid_len) &&
383 /* (src->Configuration.DSConfig == dst->Configuration.DSConfig) && */
384 ether_addr_equal(src->MacAddress, dst->MacAddress) &&
385 ((!memcmp(src->Ssid.ssid, dst->Ssid.ssid, src->Ssid.ssid_len))) &&
386 ((s_cap & WLAN_CAPABILITY_IBSS) ==
387 (d_cap & WLAN_CAPABILITY_IBSS)) &&
388 ((s_cap & WLAN_CAPABILITY_ESS) ==
389 (d_cap & WLAN_CAPABILITY_ESS)));
390}
391
392struct wlan_network *rtw_get_oldest_wlan_network23a(struct rtw_queue *scanned_queue)
393{
394 struct list_head *plist, *phead;
395
396 struct wlan_network *pwlan;
397 struct wlan_network *oldest = NULL;
398
399 phead = get_list_head(scanned_queue);
400
401 list_for_each(plist, phead) {
402 pwlan = container_of(plist, struct wlan_network, list);
403
404 if (pwlan->fixed != true) {
405 if (!oldest || time_after(oldest->last_scanned,
406 pwlan->last_scanned))
407 oldest = pwlan;
408 }
409 }
410
411 return oldest;
412}
413
414void update_network23a(struct wlan_bssid_ex *dst, struct wlan_bssid_ex *src,
415 struct rtw_adapter * padapter, bool update_ie)
416{
417 u8 ss_ori = dst->PhyInfo.SignalStrength;
418 u8 sq_ori = dst->PhyInfo.SignalQuality;
419 long rssi_ori = dst->Rssi;
420
421 u8 ss_smp = src->PhyInfo.SignalStrength;
422 u8 sq_smp = src->PhyInfo.SignalQuality;
423 long rssi_smp = src->Rssi;
424
425 u8 ss_final;
426 u8 sq_final;
427 long rssi_final;
428
429 DBG_8723A("%s %s(%pM, ch%u) ss_ori:%3u, sq_ori:%3u, rssi_ori:%3ld, ss_smp:%3u, sq_smp:%3u, rssi_smp:%3ld\n",
430 __func__, src->Ssid.ssid, src->MacAddress,
431 src->Configuration.DSConfig, ss_ori, sq_ori, rssi_ori,
432 ss_smp, sq_smp, rssi_smp
433 );
434
435 /* The rule below is 1/5 for sample value, 4/5 for history value */
436 if (check_fwstate(&padapter->mlmepriv, _FW_LINKED) && is_same_network23a(&padapter->mlmepriv.cur_network.network, src)) {
437 /* Take the recvpriv's value for the connected AP*/
438 ss_final = padapter->recvpriv.signal_strength;
439 sq_final = padapter->recvpriv.signal_qual;
440 /* the rssi value here is undecorated, and will be used for antenna diversity */
441 if (sq_smp != 101) /* from the right channel */
442 rssi_final = (src->Rssi+dst->Rssi*4)/5;
443 else
444 rssi_final = rssi_ori;
445 }
446 else {
447 if (sq_smp != 101) { /* from the right channel */
448 ss_final = ((u32)(src->PhyInfo.SignalStrength)+(u32)(dst->PhyInfo.SignalStrength)*4)/5;
449 sq_final = ((u32)(src->PhyInfo.SignalQuality)+(u32)(dst->PhyInfo.SignalQuality)*4)/5;
450 rssi_final = (src->Rssi+dst->Rssi*4)/5;
451 } else {
452 /* bss info not receving from the right channel, use the original RX signal infos */
453 ss_final = dst->PhyInfo.SignalStrength;
454 sq_final = dst->PhyInfo.SignalQuality;
455 rssi_final = dst->Rssi;
456 }
457
458 }
459
460 if (update_ie)
461 memcpy((u8 *)dst, (u8 *)src, get_wlan_bssid_ex_sz(src));
462
463 dst->PhyInfo.SignalStrength = ss_final;
464 dst->PhyInfo.SignalQuality = sq_final;
465 dst->Rssi = rssi_final;
466
467 DBG_8723A("%s %s(%pM), SignalStrength:%u, SignalQuality:%u, RawRSSI:%ld\n",
468 __func__, dst->Ssid.ssid, dst->MacAddress,
469 dst->PhyInfo.SignalStrength,
470 dst->PhyInfo.SignalQuality, dst->Rssi);
471
472}
473
474static void update_current_network(struct rtw_adapter *adapter, struct wlan_bssid_ex *pnetwork)
475{
476 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
477
478 if ((check_fwstate(pmlmepriv, _FW_LINKED)== true) && (is_same_network23a(&pmlmepriv->cur_network.network, pnetwork)))
479 {
480 /* RT_TRACE(_module_rtl871x_mlme_c_,_drv_err_,"Same Network\n"); */
481
482 /* if(pmlmepriv->cur_network.network.IELength<= pnetwork->IELength) */
483 {
484 update_network23a(&pmlmepriv->cur_network.network, pnetwork,adapter, true);
485 rtw_update_protection23a(adapter, (pmlmepriv->cur_network.network.IEs) + sizeof (struct ndis_802_11_fixed_ies),
486 pmlmepriv->cur_network.network.IELength);
487 }
488 }
489
490}
491
492/*
493
494Caller must hold pmlmepriv->lock first.
495
496*/
497void rtw_update_scanned_network23a(struct rtw_adapter *adapter, struct wlan_bssid_ex *target)
498{
499 struct list_head *plist, *phead;
500 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
501 struct wlan_network *pnetwork = NULL;
502 struct wlan_network *oldest = NULL;
503 struct rtw_queue *queue = &pmlmepriv->scanned_queue;
504 u32 bssid_ex_sz;
505 int found = 0;
506
507 spin_lock_bh(&queue->lock);
508 phead = get_list_head(queue);
509
510 list_for_each(plist, phead) {
511 pnetwork = container_of(plist, struct wlan_network, list);
512
513 if (is_same_network23a(&pnetwork->network, target)) {
514 found = 1;
515 break;
516 }
517 if (!oldest || time_after(oldest->last_scanned,
518 pnetwork->last_scanned))
519 oldest = pnetwork;
520 }
521
522 /* If we didn't find a match, then get a new network slot to initialize
523 * with this beacon's information */
524 if (!found) {
525 pnetwork = rtw_alloc_network(pmlmepriv);
526 if (!pnetwork) {
527 if (!oldest) {
528 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
529 ("\n\n\nsomething wrong here\n\n\n"));
530 goto exit;
531 }
532 pnetwork = oldest;
533 } else
534 list_add_tail(&pnetwork->list, &queue->queue);
535
536 bssid_ex_sz = get_wlan_bssid_ex_sz(target);
537 target->Length = bssid_ex_sz;
538 memcpy(&pnetwork->network, target, bssid_ex_sz);
539
540 /* variable initialize */
541 pnetwork->fixed = false;
542 pnetwork->last_scanned = jiffies;
543
544 pnetwork->network_type = 0;
545 pnetwork->aid = 0;
546 pnetwork->join_res = 0;
547
548 /* bss info not receving from the right channel */
549 if (pnetwork->network.PhyInfo.SignalQuality == 101)
550 pnetwork->network.PhyInfo.SignalQuality = 0;
551 } else {
552 /*
553 * we have an entry and we are going to update it. But
554 * this entry may be already expired. In this case we
555 * do the same as we found a new net and call the
556 * new_net handler
557 */
558 bool update_ie = true;
559
560 pnetwork->last_scanned = jiffies;
561
562 /* target.reserved == 1, means that scanned network is
563 * a bcn frame. */
564 if ((pnetwork->network.IELength>target->IELength) &&
565 (target->reserved == 1))
566 update_ie = false;
567
568 update_network23a(&pnetwork->network, target,adapter, update_ie);
569 }
570
571exit:
572 spin_unlock_bh(&queue->lock);
573
574}
575
576void rtw_add_network(struct rtw_adapter *adapter, struct wlan_bssid_ex *pnetwork)
577{
578 update_current_network(adapter, pnetwork);
579 rtw_update_scanned_network23a(adapter, pnetwork);
580}
581
582/* select the desired network based on the capability of the (i)bss. */
583/* check items: (1) security */
584/* (2) network_type */
585/* (3) WMM */
586/* (4) HT */
587/* (5) others */
588int rtw_is_desired_network(struct rtw_adapter *adapter, struct wlan_network *pnetwork)
589{
590 struct security_priv *psecuritypriv = &adapter->securitypriv;
591 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
592 u32 desired_encmode;
593 u32 privacy;
594
595 /* u8 wps_ie[512]; */
596 uint wps_ielen;
597
598 int bselected = true;
599
600 desired_encmode = psecuritypriv->ndisencryptstatus;
601 privacy = pnetwork->network.Privacy;
602
603 if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS))
604 {
605 if (rtw_get_wps_ie23a(pnetwork->network.IEs+_FIXED_IE_LENGTH_, pnetwork->network.IELength-_FIXED_IE_LENGTH_, NULL, &wps_ielen)!= NULL)
606 {
607 return true;
608 }
609 else
610 {
611 return false;
612 }
613 }
614 if (adapter->registrypriv.wifi_spec == 1) /* for correct flow of 8021X to do.... */
615 {
616 if ((desired_encmode == Ndis802_11EncryptionDisabled) && (privacy != 0))
617 bselected = false;
618 }
619
620 if ((desired_encmode != Ndis802_11EncryptionDisabled) && (privacy == 0)) {
621 DBG_8723A("desired_encmode: %d, privacy: %d\n", desired_encmode, privacy);
622 bselected = false;
623 }
624
625 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true)
626 {
627 if (pnetwork->network.InfrastructureMode != pmlmepriv->cur_network.network.InfrastructureMode)
628 bselected = false;
629 }
630
631 return bselected;
632}
633
634/* TODO: Perry : For Power Management */
635void rtw_atimdone_event_callback23a(struct rtw_adapter *adapter , u8 *pbuf)
636{
637
638 RT_TRACE(_module_rtl871x_mlme_c_,_drv_err_,("receive atimdone_evet\n"));
639
640 return;
641}
642
643void rtw_survey_event_cb23a(struct rtw_adapter *adapter, u8 *pbuf)
644{
645 u32 len;
646 struct wlan_bssid_ex *pnetwork;
647 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
648
649 pnetwork = (struct wlan_bssid_ex *)pbuf;
650
651 RT_TRACE(_module_rtl871x_mlme_c_,_drv_info_,("rtw_survey_event_cb23a, ssid=%s\n", pnetwork->Ssid.ssid));
652
653 len = get_wlan_bssid_ex_sz(pnetwork);
654 if(len > (sizeof(struct wlan_bssid_ex)))
655 {
656 RT_TRACE(_module_rtl871x_mlme_c_,_drv_err_,("\n ****rtw_survey_event_cb23a: return a wrong bss ***\n"));
657 return;
658 }
659
660 spin_lock_bh(&pmlmepriv->lock);
661
662 /* update IBSS_network 's timestamp */
663 if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) == true)
664 {
665 /* RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,"rtw_survey_event_cb23a : WIFI_ADHOC_MASTER_STATE\n\n"); */
666 if (ether_addr_equal(pmlmepriv->cur_network.network.MacAddress,
667 pnetwork->MacAddress)) {
668 struct wlan_network* ibss_wlan = NULL;
669
670 memcpy(pmlmepriv->cur_network.network.IEs, pnetwork->IEs, 8);
671 spin_lock_bh(&pmlmepriv->scanned_queue.lock);
672 ibss_wlan = rtw_find_network23a(&pmlmepriv->scanned_queue, pnetwork->MacAddress);
673 if (ibss_wlan)
674 {
675 memcpy(ibss_wlan->network.IEs , pnetwork->IEs, 8);
676 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
677 goto exit;
678 }
679 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
680 }
681 }
682
683 /* lock pmlmepriv->lock when you accessing network_q */
684 if ((check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) == false)
685 {
686 if (pnetwork->Ssid.ssid[0] == 0)
687 pnetwork->Ssid.ssid_len = 0;
688
689 rtw_add_network(adapter, pnetwork);
690 }
691
692exit:
693
694 spin_unlock_bh(&pmlmepriv->lock);
695
696 return;
697}
698
699void rtw_surveydone_event_callback23a(struct rtw_adapter *adapter, u8 *pbuf)
700{
701 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
702 struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
703
704 spin_lock_bh(&pmlmepriv->lock);
705
706 if (pmlmepriv->wps_probe_req_ie) {
707 pmlmepriv->wps_probe_req_ie_len = 0;
708 kfree(pmlmepriv->wps_probe_req_ie);
709 pmlmepriv->wps_probe_req_ie = NULL;
710 }
711
712 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_surveydone_event_callback23a: fw_state:%x\n\n", get_fwstate(pmlmepriv)));
713
714 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY)) {
715 del_timer_sync(&pmlmepriv->scan_to_timer);
716
717 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY);
718 } else {
719
720 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_, ("nic status =%x, survey done event comes too late!\n", get_fwstate(pmlmepriv)));
721 }
722
723 rtw_set_signal_stat_timer(&adapter->recvpriv);
724
725 if (pmlmepriv->to_join == true) {
726 if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true)) {
727 if (check_fwstate(pmlmepriv, _FW_LINKED) == false) {
728 set_fwstate(pmlmepriv, _FW_UNDER_LINKING);
729
730 if (rtw_select_and_join_from_scanned_queue23a(pmlmepriv) == _SUCCESS) {
731 mod_timer(&pmlmepriv->assoc_timer,
732 jiffies + msecs_to_jiffies(MAX_JOIN_TIMEOUT));
733 } else {
734 struct wlan_bssid_ex *pdev_network = &adapter->registrypriv.dev_network;
735 u8 *pibss = adapter->registrypriv.dev_network.MacAddress;
736
737 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY);
738
739 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_, ("switching to adhoc master\n"));
740
741 memset(&pdev_network->Ssid, 0, sizeof(struct cfg80211_ssid));
742 memcpy(&pdev_network->Ssid, &pmlmepriv->assoc_ssid, sizeof(struct cfg80211_ssid));
743
744 rtw_update_registrypriv_dev_network23a(adapter);
745 rtw_generate_random_ibss23a(pibss);
746
747 pmlmepriv->fw_state = WIFI_ADHOC_MASTER_STATE;
748
749 if (rtw_createbss_cmd23a(adapter)!= _SUCCESS)
750 {
751 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_, ("Error =>rtw_createbss_cmd23a status FAIL\n"));
752 }
753
754 pmlmepriv->to_join = false;
755 }
756 }
757 } else {
758 int ret;
759 set_fwstate(pmlmepriv, _FW_UNDER_LINKING);
760 pmlmepriv->to_join = false;
761 ret = rtw_select_and_join_from_scanned_queue23a(pmlmepriv);
762 if (ret == _SUCCESS) {
763 unsigned long e;
764 e = msecs_to_jiffies(MAX_JOIN_TIMEOUT);
765 mod_timer(&pmlmepriv->assoc_timer, jiffies + e);
766 } else if (ret == 2)/* there is no need to wait for join */
767 {
768 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
769 rtw_indicate_connect23a(adapter);
770 } else {
771 DBG_8723A("try_to_join, but select scanning queue fail, to_roaming:%d\n", rtw_to_roaming(adapter));
772 if (rtw_to_roaming(adapter) != 0) {
773 if (--pmlmepriv->to_roaming == 0
774 || _SUCCESS != rtw_sitesurvey_cmd23a(adapter, &pmlmepriv->assoc_ssid, 1, NULL, 0)
775 ) {
776 rtw_set_roaming(adapter, 0);
777 rtw_free_assoc_resources23a(adapter, 1);
778 rtw_indicate_disconnect23a(adapter);
779 } else {
780 pmlmepriv->to_join = true;
781 }
782 }
783 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
784 }
785 }
786 }
787
788 spin_unlock_bh(&pmlmepriv->lock);
789
790#ifdef CONFIG_8723AU_P2P
791 if (check_fwstate(pmlmepriv, _FW_LINKED) == true)
792 p2p_ps_wk_cmd23a(adapter, P2P_PS_SCAN_DONE, 0);
793#endif /* CONFIG_8723AU_P2P */
794
795 rtw_os_xmit_schedule23a(adapter);
796
797 if(pmlmeext->sitesurvey_res.bss_cnt == 0)
798 rtw_hal_sreset_reset23a(adapter);
799
800 rtw_cfg80211_surveydone_event_callback(adapter);
801
802}
803
804void rtw_dummy_event_callback23a(struct rtw_adapter *adapter , u8 *pbuf)
805{
806}
807
808void rtw23a_fwdbg_event_callback(struct rtw_adapter *adapter , u8 *pbuf)
809{
810}
811
812static void free_scanqueue(struct mlme_priv *pmlmepriv)
813{
814 struct wlan_network *pnetwork;
815 struct rtw_queue *scan_queue = &pmlmepriv->scanned_queue;
816 struct list_head *plist, *phead, *ptemp;
817
818 RT_TRACE(_module_rtl871x_mlme_c_, _drv_notice_, ("+free_scanqueue\n"));
819 spin_lock_bh(&scan_queue->lock);
820
821 phead = get_list_head(scan_queue);
822
823 list_for_each_safe(plist, ptemp, phead) {
824 list_del_init(plist);
825 pnetwork = container_of(plist, struct wlan_network, list);
826 kfree(pnetwork);
827 }
828
829 spin_unlock_bh(&scan_queue->lock);
830
831}
832
833/*
834*rtw_free_assoc_resources23a: the caller has to lock pmlmepriv->lock
835*/
836void rtw_free_assoc_resources23a(struct rtw_adapter *adapter, int lock_scanned_queue)
837{
838 struct wlan_network* pwlan = NULL;
839 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
840 struct sta_priv *pstapriv = &adapter->stapriv;
841 struct wlan_network *tgt_network = &pmlmepriv->cur_network;
842
843 RT_TRACE(_module_rtl871x_mlme_c_, _drv_notice_, ("+rtw_free_assoc_resources23a\n"));
844 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("tgt_network->network.MacAddress="MAC_FMT" ssid=%s\n",
845 MAC_ARG(tgt_network->network.MacAddress), tgt_network->network.Ssid.ssid));
846
847 if(check_fwstate(pmlmepriv, WIFI_STATION_STATE|WIFI_AP_STATE))
848 {
849 struct sta_info* psta;
850
851 psta = rtw_get_stainfo23a(&adapter->stapriv, tgt_network->network.MacAddress);
852
853 {
854 spin_lock_bh(&pstapriv->sta_hash_lock);
855 rtw_free_stainfo23a(adapter, psta);
856 }
857
858 spin_unlock_bh(&pstapriv->sta_hash_lock);
859
860 }
861
862 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE|WIFI_AP_STATE))
863 {
864 struct sta_info* psta;
865
866 rtw_free_all_stainfo23a(adapter);
867
868 psta = rtw_get_bcmc_stainfo23a(adapter);
869 spin_lock_bh(&pstapriv->sta_hash_lock);
870 rtw_free_stainfo23a(adapter, psta);
871 spin_unlock_bh(&pstapriv->sta_hash_lock);
872
873 rtw_init_bcmc_stainfo23a(adapter);
874 }
875
876 if(lock_scanned_queue)
877 spin_lock_bh(&pmlmepriv->scanned_queue.lock);
878
879 pwlan = rtw_find_network23a(&pmlmepriv->scanned_queue, tgt_network->network.MacAddress);
880 if(pwlan)
881 pwlan->fixed = false;
882 else
883 RT_TRACE(_module_rtl871x_mlme_c_,_drv_err_,("rtw_free_assoc_resources23a : pwlan== NULL\n\n"));
884
885 if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) && (adapter->stapriv.asoc_sta_count == 1))
886 rtw_free_network_nolock(pmlmepriv, pwlan);
887
888 if(lock_scanned_queue)
889 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
890
891 pmlmepriv->key_mask = 0;
892
893}
894
895/*
896*rtw_indicate_connect23a: the caller has to lock pmlmepriv->lock
897*/
898void rtw_indicate_connect23a(struct rtw_adapter *padapter)
899{
900 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
901
902 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_, ("+rtw_indicate_connect23a\n"));
903
904 pmlmepriv->to_join = false;
905
906 if(!check_fwstate(&padapter->mlmepriv, _FW_LINKED)) {
907 set_fwstate(pmlmepriv, _FW_LINKED);
908
909 rtw_led_control(padapter, LED_CTL_LINK);
910
911 rtw_os_indicate_connect23a(padapter);
912 }
913
914 rtw_set_roaming(padapter, 0);
915
916 rtw_set_scan_deny(padapter, 3000);
917
918 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_, ("-rtw_indicate_connect23a: fw_state=0x%08x\n", get_fwstate(pmlmepriv)));
919
920}
921
922/*
923*rtw_indicate_disconnect23a: the caller has to lock pmlmepriv->lock
924*/
925void rtw_indicate_disconnect23a(struct rtw_adapter *padapter)
926{
927 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
928
929 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_, ("+rtw_indicate_disconnect23a\n"));
930
931 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING|WIFI_UNDER_WPS);
932
933 /* DBG_8723A("clear wps when %s\n", __func__); */
934
935 if (rtw_to_roaming(padapter) > 0)
936 _clr_fwstate_(pmlmepriv, _FW_LINKED);
937
938 if (check_fwstate(&padapter->mlmepriv, _FW_LINKED) ||
939 (rtw_to_roaming(padapter) <= 0)) {
940 rtw_os_indicate_disconnect23a(padapter);
941
942 /* set ips_deny_time to avoid enter IPS before LPS leave */
943 padapter->pwrctrlpriv.ips_deny_time =
c17416ef 944 jiffies + msecs_to_jiffies(3000);
5e93f352
LF		 945
946 _clr_fwstate_(pmlmepriv, _FW_LINKED);
947
948 rtw_led_control(padapter, LED_CTL_NO_LINK);
949
950 rtw_clear_scan_deny(padapter);
951
952 }
953
954#ifdef CONFIG_8723AU_P2P
955 p2p_ps_wk_cmd23a(padapter, P2P_PS_DISABLE, 1);
956#endif /* CONFIG_8723AU_P2P */
957
958 rtw_lps_ctrl_wk_cmd23a(padapter, LPS_CTRL_DISCONNECT, 1);
959
960}
961
962inline void rtw_indicate_scan_done23a(struct rtw_adapter *padapter, bool aborted)
963{
964 rtw_os_indicate_scan_done23a(padapter, aborted);
965}
966
967void rtw_scan_abort23a(struct rtw_adapter *adapter)
968{
969 unsigned long start;
970 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
971 struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
972
973 start = jiffies;
974 pmlmeext->scan_abort = true;
975 while (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) &&
976 jiffies_to_msecs(jiffies - start) <= 200) {
977
978 if (adapter->bDriverStopped || adapter->bSurpriseRemoved)
979 break;
980
981 DBG_8723A(FUNC_NDEV_FMT"fw_state = _FW_UNDER_SURVEY!\n", FUNC_NDEV_ARG(adapter->pnetdev));
982 msleep(20);
983 }
984
985 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY)) {
986 if (!adapter->bDriverStopped && !adapter->bSurpriseRemoved)
987 DBG_8723A(FUNC_NDEV_FMT"waiting for scan_abort time out!\n", FUNC_NDEV_ARG(adapter->pnetdev));
988 rtw_indicate_scan_done23a(adapter, true);
989 }
990 pmlmeext->scan_abort = false;
991}
992
993static struct sta_info *rtw_joinbss_update_stainfo(struct rtw_adapter *padapter, struct wlan_network *pnetwork)
994{
995 int i;
996 struct sta_info *bmc_sta, *psta = NULL;
997 struct recv_reorder_ctrl *preorder_ctrl;
998 struct sta_priv *pstapriv = &padapter->stapriv;
999
1000 psta = rtw_get_stainfo23a(pstapriv, pnetwork->network.MacAddress);
1001 if (psta == NULL) {
1002 psta = rtw_alloc_stainfo23a(pstapriv, pnetwork->network.MacAddress);
1003 }
1004
1005 if (psta) /* update ptarget_sta */
1006 {
1007 DBG_8723A("%s\n", __func__);
1008
1009 psta->aid = pnetwork->join_res;
1010 psta->mac_id = 0;
1011
1012 /* sta mode */
1013 rtw_hal_set_odm_var23a(padapter, HAL_ODM_STA_INFO, psta, true);
1014
1015 /* security related */
1016 if (padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X)
1017 {
1018 padapter->securitypriv.binstallGrpkey = false;
1019 padapter->securitypriv.busetkipkey = false;
1020 padapter->securitypriv.bgrpkey_handshake = false;
1021
1022 psta->ieee8021x_blocked = true;
1023 psta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm;
1024
1025 memset((u8 *)&psta->dot118021x_UncstKey, 0, sizeof (union Keytype));
1026
1027 memset((u8 *)&psta->dot11tkiprxmickey, 0, sizeof (union Keytype));
1028 memset((u8 *)&psta->dot11tkiptxmickey, 0, sizeof (union Keytype));
1029
1030 memset((u8 *)&psta->dot11txpn, 0, sizeof (union pn48));
1031 memset((u8 *)&psta->dot11rxpn, 0, sizeof (union pn48));
1032 }
1033
1034 /* Commented by Albert 2012/07/21 */
1035 /* When doing the WPS, the wps_ie_len won't equal to 0 */
1036 /* And the Wi-Fi driver shouldn't allow the data packet to be tramsmitted. */
1037 if (padapter->securitypriv.wps_ie_len != 0)
1038 {
1039 psta->ieee8021x_blocked = true;
1040 padapter->securitypriv.wps_ie_len = 0;
1041 }
1042
1043 /* for A-MPDU Rx reordering buffer control for bmc_sta & sta_info */
1044 /* if A-MPDU Rx is enabled, reseting rx_ordering_ctrl wstart_b(indicate_seq) to default value = 0xffff */
1045 /* todo: check if AP can send A-MPDU packets */
1046 for (i = 0; i < 16 ; i++)
1047 {
1048 /* preorder_ctrl = &precvpriv->recvreorder_ctrl[i]; */
1049 preorder_ctrl = &psta->recvreorder_ctrl[i];
1050 preorder_ctrl->enable = false;
1051 preorder_ctrl->indicate_seq = 0xffff;
1052 preorder_ctrl->wend_b = 0xffff;
1053 preorder_ctrl->wsize_b = 64;/* max_ampdu_sz; ex. 32(kbytes) -> wsize_b = 32 */
1054 }
1055
1056 bmc_sta = rtw_get_bcmc_stainfo23a(padapter);
1057 if (bmc_sta)
1058 {
1059 for (i = 0; i < 16 ; i++)
1060 {
1061 /* preorder_ctrl = &precvpriv->recvreorder_ctrl[i]; */
1062 preorder_ctrl = &bmc_sta->recvreorder_ctrl[i];
1063 preorder_ctrl->enable = false;
1064 preorder_ctrl->indicate_seq = 0xffff;
1065 preorder_ctrl->wend_b = 0xffff;
1066 preorder_ctrl->wsize_b = 64;/* max_ampdu_sz; ex. 32(kbytes) -> wsize_b = 32 */
1067 }
1068 }
1069
1070 /* misc. */
1071 update_sta_info23a(padapter, psta);
1072
1073 }
1074
1075 return psta;
1076}
1077
1078/* pnetwork : returns from rtw23a_joinbss_event_cb */
1079/* ptarget_wlan: found from scanned_queue */
1080static void rtw_joinbss_update_network23a(struct rtw_adapter *padapter, struct wlan_network *ptarget_wlan, struct wlan_network *pnetwork)
1081{
1082 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1083 struct wlan_network *cur_network = &pmlmepriv->cur_network;
1084
1085 DBG_8723A("%s\n", __func__);
1086
1087 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("\nfw_state:%x, BSSID:"MAC_FMT"\n"
1088 , get_fwstate(pmlmepriv), MAC_ARG(pnetwork->network.MacAddress)));
1089
1090 /* why not use ptarget_wlan?? */
1091 memcpy(&cur_network->network, &pnetwork->network, pnetwork->network.Length);
1092 /* some IEs in pnetwork is wrong, so we should use ptarget_wlan IEs */
1093 cur_network->network.IELength = ptarget_wlan->network.IELength;
1094 memcpy(&cur_network->network.IEs[0], &ptarget_wlan->network.IEs[0], MAX_IE_SZ);
1095
1096 cur_network->aid = pnetwork->join_res;
1097
1098 rtw_set_signal_stat_timer(&padapter->recvpriv);
1099 padapter->recvpriv.signal_strength = ptarget_wlan->network.PhyInfo.SignalStrength;
1100 padapter->recvpriv.signal_qual = ptarget_wlan->network.PhyInfo.SignalQuality;
1101 /* the ptarget_wlan->network.Rssi is raw data, we use ptarget_wlan->network.PhyInfo.SignalStrength instead (has scaled) */
1102 padapter->recvpriv.rssi = translate_percentage_to_dbm(ptarget_wlan->network.PhyInfo.SignalStrength);
1103 DBG_8723A("%s signal_strength:%3u, rssi:%3d, signal_qual:%3u\n",
1104 __func__, padapter->recvpriv.signal_strength,
1105 padapter->recvpriv.rssi, padapter->recvpriv.signal_qual);
1106 rtw_set_signal_stat_timer(&padapter->recvpriv);
1107
1108 /* update fw_state will clr _FW_UNDER_LINKING here indirectly */
1109 switch (pnetwork->network.InfrastructureMode) {
1110 case Ndis802_11Infrastructure:
1111 if (pmlmepriv->fw_state&WIFI_UNDER_WPS)
1112 pmlmepriv->fw_state = WIFI_STATION_STATE|WIFI_UNDER_WPS;
1113 else
1114 pmlmepriv->fw_state = WIFI_STATION_STATE;
1115 break;
1116 case Ndis802_11IBSS:
1117 pmlmepriv->fw_state = WIFI_ADHOC_STATE;
1118 break;
1119 default:
1120 pmlmepriv->fw_state = WIFI_NULL_STATE;
1121 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_, ("Invalid network_mode\n"));
1122 break;
1123 }
1124
1125 rtw_update_protection23a(padapter, (cur_network->network.IEs) + sizeof (struct ndis_802_11_fixed_ies),
1126 (cur_network->network.IELength));
1127
1128 rtw_update_ht_cap23a(padapter, cur_network->network.IEs, cur_network->network.IELength);
1129}
1130
1131/* Notes: the fucntion could be > passive_level (the same context as Rx tasklet) */
1132/* pnetwork : returns from rtw23a_joinbss_event_cb */
1133/* ptarget_wlan: found from scanned_queue */
1134/* if join_res > 0, for (fw_state==WIFI_STATION_STATE), we check if "ptarget_sta" & "ptarget_wlan" exist. */
1135/* if join_res > 0, for (fw_state==WIFI_ADHOC_STATE), we only check if "ptarget_wlan" exist. */
1136/* if join_res > 0, update "cur_network->network" from "pnetwork->network" if (ptarget_wlan !=NULL). */
1137
1138void rtw_joinbss_event_prehandle23a(struct rtw_adapter *adapter, u8 *pbuf)
1139{
1140 static u8 retry=0;
1141 struct sta_info *ptarget_sta= NULL, *pcur_sta = NULL;
1142 struct sta_priv *pstapriv = &adapter->stapriv;
1143 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1144 struct wlan_network *pnetwork = (struct wlan_network *)pbuf;
1145 struct wlan_network *cur_network = &pmlmepriv->cur_network;
1146 struct wlan_network *pcur_wlan = NULL, *ptarget_wlan = NULL;
1147 unsigned int the_same_macaddr = false;
1148
1149 RT_TRACE(_module_rtl871x_mlme_c_,_drv_info_,("joinbss event call back received with res=%d\n", pnetwork->join_res));
1150
1151 rtw_get_encrypt_decrypt_from_registrypriv23a(adapter);
1152
1153 if (pmlmepriv->assoc_ssid.ssid_len == 0) {
1154 RT_TRACE(_module_rtl871x_mlme_c_,_drv_err_,("@@@@@ joinbss event call back for Any SSid\n"));
1155 } else {
1156 RT_TRACE(_module_rtl871x_mlme_c_,_drv_err_,
1157 ("@@@@@ rtw23a_joinbss_event_cb for SSid:%s\n",
1158 pmlmepriv->assoc_ssid.ssid));
1159 }
1160
1161 if (ether_addr_equal(pnetwork->network.MacAddress,
1162 cur_network->network.MacAddress))
1163 the_same_macaddr = true;
1164 else
1165 the_same_macaddr = false;
1166
1167 pnetwork->network.Length = get_wlan_bssid_ex_sz(&pnetwork->network);
1168 if(pnetwork->network.Length > sizeof(struct wlan_bssid_ex))
1169 {
1170 RT_TRACE(_module_rtl871x_mlme_c_,_drv_err_,("\n\n ***joinbss_evt_callback return a wrong bss ***\n\n"));
1171 return;
1172 }
1173
1174 spin_lock_bh(&pmlmepriv->lock);
1175
1176 RT_TRACE(_module_rtl871x_mlme_c_,_drv_info_,("\n rtw23a_joinbss_event_cb !! _enter_critical\n"));
1177
1178 if(pnetwork->join_res > 0)
1179 {
1180 spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1181 retry = 0;
1182 if (check_fwstate(pmlmepriv,_FW_UNDER_LINKING))
1183 {
1184 /* s1. find ptarget_wlan */
1185 if(check_fwstate(pmlmepriv, _FW_LINKED))
1186 {
1187 if(the_same_macaddr == true)
1188 {
1189 ptarget_wlan = rtw_find_network23a(&pmlmepriv->scanned_queue, cur_network->network.MacAddress);
1190 }
1191 else
1192 {
1193 pcur_wlan = rtw_find_network23a(&pmlmepriv->scanned_queue, cur_network->network.MacAddress);
1194 if(pcur_wlan) pcur_wlan->fixed = false;
1195
1196 pcur_sta = rtw_get_stainfo23a(pstapriv, cur_network->network.MacAddress);
1197 if(pcur_sta) {
1198 spin_lock_bh(&pstapriv->sta_hash_lock);
1199 rtw_free_stainfo23a(adapter, pcur_sta);
1200 spin_unlock_bh(&pstapriv->sta_hash_lock);
1201 }
1202
1203 ptarget_wlan = rtw_find_network23a(&pmlmepriv->scanned_queue, pnetwork->network.MacAddress);
1204 if(check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) {
1205 if(ptarget_wlan) ptarget_wlan->fixed = true;
1206 }
1207 }
1208
1209 }
1210 else
1211 {
1212 ptarget_wlan = rtw_find_network23a(&pmlmepriv->scanned_queue, pnetwork->network.MacAddress);
1213 if(check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) {
1214 if(ptarget_wlan) ptarget_wlan->fixed = true;
1215 }
1216 }
1217
1218 /* s2. update cur_network */
1219 if(ptarget_wlan)
1220 {
1221 rtw_joinbss_update_network23a(adapter, ptarget_wlan, pnetwork);
1222 }
1223 else
1224 {
1225 RT_TRACE(_module_rtl871x_mlme_c_,_drv_err_,("Can't find ptarget_wlan when joinbss_event callback\n"));
1226 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1227 goto ignore_joinbss_callback;
1228 }
1229
1230 /* s3. find ptarget_sta & update ptarget_sta after update cur_network only for station mode */
1231 if(check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true)
1232 {
1233 ptarget_sta = rtw_joinbss_update_stainfo(adapter, pnetwork);
1234 if(ptarget_sta==NULL)
1235 {
1236 RT_TRACE(_module_rtl871x_mlme_c_,_drv_err_,("Can't update stainfo when joinbss_event callback\n"));
1237 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1238 goto ignore_joinbss_callback;
1239 }
1240 }
1241
1242 /* s4. indicate connect */
1243 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true)
1244 {
1245 rtw_indicate_connect23a(adapter);
1246 } else {
1247 /* adhoc mode will rtw_indicate_connect23a when rtw_stassoc_event_callback23a */
1248 RT_TRACE(_module_rtl871x_mlme_c_,_drv_info_,("adhoc mode, fw_state:%x", get_fwstate(pmlmepriv)));
1249 }
1250
1251 /* s5. Cancle assoc_timer */
1252 del_timer_sync(&pmlmepriv->assoc_timer);
1253
1254 RT_TRACE(_module_rtl871x_mlme_c_,_drv_info_,("Cancle assoc_timer\n"));
1255 } else {
1256 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1257 ("rtw23a_joinbss_event_cb err: fw_state:%x",
1258 get_fwstate(pmlmepriv)));
1259 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1260 goto ignore_joinbss_callback;
1261 }
1262 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1263 } else if(pnetwork->join_res == -4) {
1264 rtw_reset_securitypriv23a(adapter);
1265 mod_timer(&pmlmepriv->assoc_timer,
1266 jiffies + msecs_to_jiffies(1));
1267
1268 /* rtw_free_assoc_resources23a(adapter, 1); */
1269
1270 if((check_fwstate(pmlmepriv, _FW_UNDER_LINKING))) {
1271 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1272 ("fail! clear _FW_UNDER_LINKING ^^^fw_state=%x\n",
1273 get_fwstate(pmlmepriv)));
1274 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
1275 }
1276
1277 } else {
1278 /* if join_res < 0 (join fails), then try again */
1279 mod_timer(&pmlmepriv->assoc_timer,
1280 jiffies + msecs_to_jiffies(1));
1281 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
1282 }
1283
1284ignore_joinbss_callback:
1285
1286 spin_unlock_bh(&pmlmepriv->lock);
1287}
1288
1289void rtw23a_joinbss_event_cb(struct rtw_adapter *adapter, u8 *pbuf)
1290{
1291 struct wlan_network *pnetwork = (struct wlan_network *)pbuf;
1292
1293 mlmeext_joinbss_event_callback23a(adapter, pnetwork->join_res);
1294
1295 rtw_os_xmit_schedule23a(adapter);
1296
1297}
1298
5e93f352
LF		 1299void rtw_stassoc_event_callback23a(struct rtw_adapter *adapter, u8 *pbuf)
1300{
1301 struct sta_info *psta;
1302 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1303 struct stassoc_event *pstassoc = (struct stassoc_event*)pbuf;
1304 struct wlan_network *cur_network = &pmlmepriv->cur_network;
1305 struct wlan_network *ptarget_wlan = NULL;
1306
1307 if(rtw_access_ctrl23a(adapter, pstassoc->macaddr) == false)
1308 return;
1309
1310#ifdef CONFIG_8723AU_AP_MODE
1311 if(check_fwstate(pmlmepriv, WIFI_AP_STATE))
1312 {
1313 psta = rtw_get_stainfo23a(&adapter->stapriv, pstassoc->macaddr);
1314 if (psta) {
1315 /* bss_cap_update_on_sta_join23a(adapter, psta); */
1316 /* sta_info_update23a(adapter, psta); */
1317 ap_sta_info_defer_update23a(adapter, psta);
5e93f352
LF		 1318 }
1319 return;
1320 }
1321#endif
1322 /* for AD-HOC mode */
1323 psta = rtw_get_stainfo23a(&adapter->stapriv, pstassoc->macaddr);
1324 if (psta != NULL) {
1325 /* the sta have been in sta_info_queue => do nothing */
1326 RT_TRACE(_module_rtl871x_mlme_c_,_drv_err_,("Error: rtw_stassoc_event_callback23a: sta has been in sta_hash_queue\n"));
1327 return; /* between drv has received this event before and fw have not yet to set key to CAM_ENTRY) */
1328 }
1329
1330 psta = rtw_alloc_stainfo23a(&adapter->stapriv, pstassoc->macaddr);
1331 if (psta == NULL) {
1332 RT_TRACE(_module_rtl871x_mlme_c_,_drv_err_,("Can't alloc sta_info when rtw_stassoc_event_callback23a\n"));
1333 return;
1334 }
1335
1336 /* to do : init sta_info variable */
1337 psta->qos_option = 0;
1338 psta->mac_id = (uint)pstassoc->cam_id;
1339 /* psta->aid = (uint)pstassoc->cam_id; */
1340 DBG_8723A("%s\n",__func__);
1341 /* for ad-hoc mode */
1342 rtw_hal_set_odm_var23a(adapter,HAL_ODM_STA_INFO,psta,true);
1343
5e93f352
LF		 1344 if(adapter->securitypriv.dot11AuthAlgrthm==dot11AuthAlgrthm_8021X)
1345 psta->dot118021XPrivacy = adapter->securitypriv.dot11PrivacyAlgrthm;
1346
1347 psta->ieee8021x_blocked = false;
1348
1349 spin_lock_bh(&pmlmepriv->lock);
1350
1351 if ( (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)==true ) ||
1352 (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)==true ) )
1353 {
1354 if(adapter->stapriv.asoc_sta_count== 2)
1355 {
1356 spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1357 ptarget_wlan = rtw_find_network23a(&pmlmepriv->scanned_queue, cur_network->network.MacAddress);
1358 if(ptarget_wlan) ptarget_wlan->fixed = true;
1359 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1360 /* a sta + bc/mc_stainfo (not Ibss_stainfo) */
1361 rtw_indicate_connect23a(adapter);
1362 }
1363 }
1364
1365 spin_unlock_bh(&pmlmepriv->lock);
1366
1367 mlmeext_sta_add_event_callback23a(adapter, psta);
1368}
1369
1370void rtw_stadel_event_callback23a(struct rtw_adapter *adapter, u8 *pbuf)
1371{
1372 int mac_id=-1;
1373 struct sta_info *psta;
1374 struct wlan_network* pwlan = NULL;
1375 struct wlan_bssid_ex *pdev_network=NULL;
1376 u8* pibss = NULL;
1377 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1378 struct stadel_event *pstadel = (struct stadel_event*)pbuf;
1379 struct sta_priv *pstapriv = &adapter->stapriv;
1380 struct wlan_network *tgt_network = &pmlmepriv->cur_network;
1381
1382 psta = rtw_get_stainfo23a(&adapter->stapriv, pstadel->macaddr);
1383 if(psta)
1384 mac_id = psta->mac_id;
1385 else
1386 mac_id = pstadel->mac_id;
1387
1388 DBG_8723A("%s(mac_id=%d)=" MAC_FMT "\n", __func__, mac_id, MAC_ARG(pstadel->macaddr));
1389
5e93f352
LF		 1390 if (check_fwstate(pmlmepriv, WIFI_AP_STATE))
1391 {
1392 return;
1393 }
1394
1395 mlmeext_sta_del_event_callback23a(adapter);
1396
1397 spin_lock_bh(&pmlmepriv->lock);
1398
1399 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE))
1400 {
1401 if (rtw_to_roaming(adapter) > 0)
1402 pmlmepriv->to_roaming--; /* this stadel_event is caused by roaming, decrease to_roaming */
1403 else if (rtw_to_roaming(adapter) == 0)
1404 rtw_set_roaming(adapter, adapter->registrypriv.max_roaming_times);
1405 if (*((unsigned short *)(pstadel->rsvd)) != WLAN_REASON_EXPIRATION_CHK)
1406 rtw_set_roaming(adapter, 0); /* don't roam */
1407
1408 rtw_free_uc_swdec_pending_queue23a(adapter);
1409
1410 rtw_free_assoc_resources23a(adapter, 1);
1411 rtw_indicate_disconnect23a(adapter);
1412 spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1413 /* remove the network entry in scanned_queue */
1414 pwlan = rtw_find_network23a(&pmlmepriv->scanned_queue, tgt_network->network.MacAddress);
1415 if (pwlan) {
1416 pwlan->fixed = false;
1417 rtw_free_network_nolock(pmlmepriv, pwlan);
1418 }
1419 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1420
1421 _rtw23a_roaming(adapter, tgt_network);
1422 }
1423
1424 if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) ||
1425 check_fwstate(pmlmepriv, WIFI_ADHOC_STATE))
1426 {
1427
1428 spin_lock_bh(&pstapriv->sta_hash_lock);
1429 rtw_free_stainfo23a(adapter, psta);
1430 spin_unlock_bh(&pstapriv->sta_hash_lock);
1431
1432 if (adapter->stapriv.asoc_sta_count == 1) /* a sta + bc/mc_stainfo (not Ibss_stainfo) */
1433 {
1434 spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1435 /* free old ibss network */
1436 /* pwlan = rtw_find_network23a(&pmlmepriv->scanned_queue, pstadel->macaddr); */
1437 pwlan = rtw_find_network23a(&pmlmepriv->scanned_queue, tgt_network->network.MacAddress);
1438 if (pwlan)
1439 {
1440 pwlan->fixed = false;
1441 rtw_free_network_nolock(pmlmepriv, pwlan);
1442 }
1443 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1444 /* re-create ibss */
1445 pdev_network = &adapter->registrypriv.dev_network;
1446 pibss = adapter->registrypriv.dev_network.MacAddress;
1447
1448 memcpy(pdev_network, &tgt_network->network, get_wlan_bssid_ex_sz(&tgt_network->network));
1449
1450 memset(&pdev_network->Ssid, 0,
1451 sizeof(struct cfg80211_ssid));
1452 memcpy(&pdev_network->Ssid, &pmlmepriv->assoc_ssid,
1453 sizeof(struct cfg80211_ssid));
1454
1455 rtw_update_registrypriv_dev_network23a(adapter);
1456
1457 rtw_generate_random_ibss23a(pibss);
1458
1459 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE))
1460 {
1461 set_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE);
1462 _clr_fwstate_(pmlmepriv, WIFI_ADHOC_STATE);
1463 }
1464
1465 if (rtw_createbss_cmd23a(adapter)!= _SUCCESS)
1466 {
1467
1468 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("***Error =>stadel_event_callback: rtw_createbss_cmd23a status FAIL***\n "));
1469
1470 }
1471
1472 }
1473
1474 }
1475
1476 spin_unlock_bh(&pmlmepriv->lock);
1477
1478}
1479
1480void rtw_cpwm_event_callback23a(struct rtw_adapter *padapter, u8 *pbuf)
1481{
1482
1483 RT_TRACE(_module_rtl871x_mlme_c_,_drv_err_,("+rtw_cpwm_event_callback23a !!!\n"));
1484
1485}
1486
1487/*
1488* rtw23a_join_to_handler - Timeout/faliure handler for CMD JoinBss
1489* @adapter: pointer to _adapter structure
1490*/
1491void rtw23a_join_to_handler (unsigned long data)
1492{
1493 struct rtw_adapter *adapter = (struct rtw_adapter *)data;
1494 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1495 int do_join_r;
1496
1497 DBG_8723A("%s, fw_state=%x\n", __func__, get_fwstate(pmlmepriv));
1498
1499 if(adapter->bDriverStopped ||adapter->bSurpriseRemoved)
1500 return;
1501
1502 spin_lock_bh(&pmlmepriv->lock);
1503
1504 if (rtw_to_roaming(adapter) > 0) { /* join timeout caused by roaming */
1505 while(1) {
1506 pmlmepriv->to_roaming--;
1507 if (rtw_to_roaming(adapter) != 0) { /* try another */
1508 DBG_8723A("%s try another roaming\n", __func__);
1509 if (_SUCCESS!= (do_join_r = rtw_do_join23a(adapter))) {
1510 DBG_8723A("%s roaming do_join return %d\n", __func__ , do_join_r);
1511 continue;
1512 }
1513 break;
1514 } else {
1515 DBG_8723A("%s We've try roaming but fail\n", __func__);
1516 rtw_indicate_disconnect23a(adapter);
1517 break;
1518 }
1519 }
1520 } else {
1521 rtw_indicate_disconnect23a(adapter);
1522 free_scanqueue(pmlmepriv);/* */
1523
1524 /* indicate disconnect for the case that join_timeout and check_fwstate != FW_LINKED */
1525 rtw_cfg80211_indicate_disconnect(adapter);
1526 }
1527
1528 spin_unlock_bh(&pmlmepriv->lock);
1529
1530}
1531
1532/*
1533* rtw_scan_timeout_handler23a - Timeout/Faliure handler for CMD SiteSurvey
1534* @data: pointer to _adapter structure
1535*/
1536void rtw_scan_timeout_handler23a(unsigned long data)
1537{
1538 struct rtw_adapter *adapter = (struct rtw_adapter *)data;
1539 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1540
1541 DBG_8723A(FUNC_ADPT_FMT" fw_state =%x\n", FUNC_ADPT_ARG(adapter), get_fwstate(pmlmepriv));
1542
1543 spin_lock_bh(&pmlmepriv->lock);
1544
1545 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY);
1546
1547 spin_unlock_bh(&pmlmepriv->lock);
1548
1549 rtw_indicate_scan_done23a(adapter, true);
1550}
1551
1552static void rtw_auto_scan_handler(struct rtw_adapter *padapter)
1553{
1554 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1555
1556 /* auto site survey per 60sec */
1557 if (pmlmepriv->scan_interval > 0) {
1558 pmlmepriv->scan_interval--;
1559 if (pmlmepriv->scan_interval == 0) {
1560 DBG_8723A("%s\n", __func__);
1561 rtw_set_802_11_bssid23a_list_scan(padapter, NULL, 0);
1562 pmlmepriv->scan_interval = SCAN_INTERVAL;/* 30*2 sec = 60sec */
1563 }
1564 }
1565}
1566
1567void rtw_dynamic_check_timer_handler(unsigned long data)
1568{
1569 struct rtw_adapter *adapter = (struct rtw_adapter *)data;
1570 struct registry_priv *pregistrypriv = &adapter->registrypriv;
1571
1572 if (adapter->hw_init_completed == false)
1573 goto out;
1574
1575 if ((adapter->bDriverStopped == true)||(adapter->bSurpriseRemoved == true))
1576 goto out;
1577
1578 if (adapter->net_closed == true)
1579 goto out;
1580
1581 rtw_dynamic_chk_wk_cmd23a(adapter);
1582
1583 if (pregistrypriv->wifi_spec == 1)
1584 {
1585#ifdef CONFIG_8723AU_P2P
1586 struct wifidirect_info *pwdinfo = &adapter->wdinfo;
1587 if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
1588#endif
1589 {
1590 /* auto site survey */
1591 rtw_auto_scan_handler(adapter);
1592 }
1593 }
1594out:
1595 mod_timer(&adapter->mlmepriv.dynamic_chk_timer,
1596 jiffies + msecs_to_jiffies(2000));
1597}
1598
1599inline bool rtw_is_scan_deny(struct rtw_adapter *adapter)
1600{
1601 struct mlme_priv *mlmepriv = &adapter->mlmepriv;
1602 return (atomic_read(&mlmepriv->set_scan_deny) != 0) ? true : false;
1603}
1604
1605void rtw_clear_scan_deny(struct rtw_adapter *adapter)
1606{
1607 struct mlme_priv *mlmepriv = &adapter->mlmepriv;
1608 atomic_set(&mlmepriv->set_scan_deny, 0);
1609 if (0)
1610 DBG_8723A(FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(adapter));
1611}
1612
1613void rtw_set_scan_deny_timer_hdl(unsigned long data)
1614{
1615 struct rtw_adapter *adapter = (struct rtw_adapter *)data;
1616 rtw_clear_scan_deny(adapter);
1617}
1618
1619void rtw_set_scan_deny(struct rtw_adapter *adapter, u32 ms)
1620{
1621 struct mlme_priv *mlmepriv = &adapter->mlmepriv;
1622
1623 if (0)
1624 DBG_8723A(FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(adapter));
1625 atomic_set(&mlmepriv->set_scan_deny, 1);
1626 mod_timer(&mlmepriv->set_scan_deny_timer,
1627 jiffies + msecs_to_jiffies(ms));
1628
1629}
1630
1631#if defined(IEEE80211_SCAN_RESULT_EXPIRE)
1632#define RTW_SCAN_RESULT_EXPIRE IEEE80211_SCAN_RESULT_EXPIRE/HZ*1000 -1000 /* 3000 -1000 */
1633#else
1634#define RTW_SCAN_RESULT_EXPIRE 2000
1635#endif
1636
1637/*
1638* Select a new join candidate from the original @param candidate and @param competitor
1639* @return true: candidate is updated
1640* @return false: candidate is not updated
1641*/
1642static int rtw_check_join_candidate(struct mlme_priv *pmlmepriv
1643 , struct wlan_network **candidate, struct wlan_network *competitor)
1644{
1645 int updated = false;
1646 struct rtw_adapter *adapter = container_of(pmlmepriv, struct rtw_adapter, mlmepriv);
1647
1648 /* check bssid, if needed */
1649 if (pmlmepriv->assoc_by_bssid == true) {
1650 if (!ether_addr_equal(competitor->network.MacAddress,
1651 pmlmepriv->assoc_bssid))
1652 goto exit;
1653 }
1654
1655 /* check ssid, if needed */
c17416ef 1656 if (pmlmepriv->assoc_ssid.ssid_len) {
5e93f352
LF		 1657 if (competitor->network.Ssid.ssid_len !=
1658 pmlmepriv->assoc_ssid.ssid_len ||
1659 memcmp(competitor->network.Ssid.ssid,
1660 pmlmepriv->assoc_ssid.ssid,
1661 pmlmepriv->assoc_ssid.ssid_len))
1662 goto exit;
1663 }
1664
1665 if (rtw_is_desired_network(adapter, competitor) == false)
1666 goto exit;
1667
1668 if (rtw_to_roaming(adapter) > 0) {
1669 unsigned int passed;
1670
1671 passed = jiffies_to_msecs(jiffies - competitor->last_scanned);
1672 if (passed >= RTW_SCAN_RESULT_EXPIRE ||
1673 is_same_ess(&competitor->network,
1674 &pmlmepriv->cur_network.network) == false)
1675 goto exit;
1676 }
1677
1678 if (*candidate == NULL ||(*candidate)->network.Rssi<competitor->network.Rssi) {
1679 *candidate = competitor;
1680 updated = true;
1681 }
1682
1683 if (updated) {
1684 DBG_8723A("[by_bssid:%u][assoc_ssid:%s][to_roaming:%u] new candidate: %s("MAC_FMT") rssi:%d\n",
1685 pmlmepriv->assoc_by_bssid,
1686 pmlmepriv->assoc_ssid.ssid,
1687 rtw_to_roaming(adapter),
1688 (*candidate)->network.Ssid.ssid,
1689 MAC_ARG((*candidate)->network.MacAddress),
1690 (int)(*candidate)->network.Rssi);
1691 }
1692
1693exit:
1694 return updated;
1695}
1696
1697/*
1698Calling context:
1699The caller of the sub-routine will be in critical section...
1700
1701The caller must hold the following spinlock
1702
1703pmlmepriv->lock
1704
1705*/
1706
1707int rtw_select_and_join_from_scanned_queue23a(struct mlme_priv *pmlmepriv)
1708{
1709 int ret;
1710 struct list_head *phead, *plist, *ptmp;
1711 struct rtw_adapter *adapter;
1712 struct rtw_queue *queue = &pmlmepriv->scanned_queue;
1713 struct wlan_network *pnetwork = NULL;
1714 struct wlan_network *candidate = NULL;
1715
1716 spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1717 phead = get_list_head(queue);
1718 adapter = pmlmepriv->nic_hdl;
1719
1720 list_for_each_safe(plist, ptmp, phead) {
1721 pnetwork = container_of(plist, struct wlan_network, list);
1722 if (!pnetwork) {
1723 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1724 ("%s return _FAIL:(pnetwork == NULL)\n",
1725 __func__));
1726 ret = _FAIL;
1727 goto exit;
1728 }
1729
1730 rtw_check_join_candidate(pmlmepriv, &candidate, pnetwork);
1731 }
1732
1733 if (!candidate) {
1734 DBG_8723A("%s: return _FAIL(candidate == NULL)\n", __func__);
1735 ret = _FAIL;
1736 goto exit;
1737 } else {
1738 DBG_8723A("%s: candidate: %s("MAC_FMT", ch:%u)\n", __func__,
1739 candidate->network.Ssid.ssid,
1740 MAC_ARG(candidate->network.MacAddress),
1741 candidate->network.Configuration.DSConfig);
1742 }
1743
1744 /* check for situation of _FW_LINKED */
1745 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
1746 DBG_8723A("%s: _FW_LINKED while ask_for_joinbss!!!\n",
1747 __func__);
1748
1749 rtw_disassoc_cmd23a(adapter, 0, true);
1750 rtw_indicate_disconnect23a(adapter);
1751 rtw_free_assoc_resources23a(adapter, 0);
1752 }
1753 set_fwstate(pmlmepriv, _FW_UNDER_LINKING);
1754 ret = rtw_joinbss_cmd23a(adapter, candidate);
1755
1756exit:
1757 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1758
1759 return ret;
1760}
1761
1762int rtw_set_auth23a(struct rtw_adapter * adapter,
1763 struct security_priv *psecuritypriv)
1764{
1765 struct cmd_obj* pcmd;
1766 struct setauth_parm *psetauthparm;
1767 struct cmd_priv *pcmdpriv = &adapter->cmdpriv;
1768 int res = _SUCCESS;
1769
1770 pcmd = (struct cmd_obj *)kzalloc(sizeof(struct cmd_obj), GFP_KERNEL);
1771 if (!pcmd) {
1772 res = _FAIL; /* try again */
1773 goto exit;
1774 }
1775
1776 psetauthparm = (struct setauth_parm*)
1777 kzalloc(sizeof(struct setauth_parm), GFP_KERNEL);
1778 if (!psetauthparm) {
1779 kfree(pcmd);
1780 res = _FAIL;
1781 goto exit;
1782 }
1783
1784 psetauthparm->mode = (unsigned char)psecuritypriv->dot11AuthAlgrthm;
1785
1786 pcmd->cmdcode = _SetAuth_CMD_;
1787 pcmd->parmbuf = (unsigned char *)psetauthparm;
1788 pcmd->cmdsz = (sizeof(struct setauth_parm));
1789 pcmd->rsp = NULL;
1790 pcmd->rspsz = 0;
1791
1792 INIT_LIST_HEAD(&pcmd->list);
1793
1794 RT_TRACE(_module_rtl871x_mlme_c_,_drv_err_,
1795 ("after enqueue set_auth_cmd, auth_mode=%x\n",
1796 psecuritypriv->dot11AuthAlgrthm));
1797
1798 res = rtw_enqueue_cmd23a(pcmdpriv, pcmd);
1799
1800exit:
1801
1802 return res;
1803}
1804
1805int rtw_set_key23a(struct rtw_adapter *adapter,
1806 struct security_priv *psecuritypriv, int keyid, u8 set_tx)
1807{
1808 u8 keylen;
1809 struct cmd_obj *pcmd;
1810 struct setkey_parm *psetkeyparm;
1811 struct cmd_priv *pcmdpriv = &adapter->cmdpriv;
1812 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1813 int res = _SUCCESS;
1814
1815 pcmd = (struct cmd_obj *)kzalloc(sizeof(struct cmd_obj), GFP_KERNEL);
1816 if (!pcmd) {
1817 res = _FAIL; /* try again */
1818 goto exit;
1819 }
c17416ef 1820 psetkeyparm = kzalloc(sizeof(struct setkey_parm), GFP_KERNEL);
5e93f352
LF		 1821 if (!psetkeyparm) {
1822 kfree(pcmd);
1823 res = _FAIL;
1824 goto exit;
1825 }
1826
1827 if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) {
1828 psetkeyparm->algorithm = (unsigned char)
1829 psecuritypriv->dot118021XGrpPrivacy;
1830 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1831 ("\n rtw_set_key23a: psetkeyparm->algorithm = (unsigned "
1832 "char)psecuritypriv->dot118021XGrpPrivacy =%d\n",
1833 psetkeyparm->algorithm));
1834 } else {
1835 psetkeyparm->algorithm = (u8)psecuritypriv->dot11PrivacyAlgrthm;
1836 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1837 ("\n rtw_set_key23a: psetkeyparm->algorithm = (u8)"
1838 "psecuritypriv->dot11PrivacyAlgrthm =%d\n",
1839 psetkeyparm->algorithm));
1840 }
1841 psetkeyparm->keyid = (u8)keyid;/* 0~3 */
1842 psetkeyparm->set_tx = set_tx;
1843 if (is_wep_enc(psetkeyparm->algorithm))
1844 pmlmepriv->key_mask |= CHKBIT(psetkeyparm->keyid);
1845
1846 DBG_8723A("==> rtw_set_key23a algorithm(%x), keyid(%x), key_mask(%x)\n",
1847 psetkeyparm->algorithm, psetkeyparm->keyid,
1848 pmlmepriv->key_mask);
1849 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1850 ("\n rtw_set_key23a: psetkeyparm->algorithm =%d psetkeyparm->"
1851 "keyid = (u8)keyid =%d\n", psetkeyparm->algorithm, keyid));
1852
1853 switch (psetkeyparm->algorithm) {
1854 case _WEP40_:
1855 keylen = 5;
1856 memcpy(&psetkeyparm->key[0],
1857 &psecuritypriv->dot11DefKey[keyid].skey[0], keylen);
1858 break;
1859 case _WEP104_:
1860 keylen = 13;
1861 memcpy(&psetkeyparm->key[0],
1862 &psecuritypriv->dot11DefKey[keyid].skey[0], keylen);
1863 break;
1864 case _TKIP_:
1865 keylen = 16;
1866 memcpy(&psetkeyparm->key,
1867 &psecuritypriv->dot118021XGrpKey[keyid], keylen);
1868 psetkeyparm->grpkey = 1;
1869 break;
1870 case _AES_:
1871 keylen = 16;
1872 memcpy(&psetkeyparm->key,
1873 &psecuritypriv->dot118021XGrpKey[keyid], keylen);
1874 psetkeyparm->grpkey = 1;
1875 break;
1876 default:
1877 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1878 ("\n rtw_set_key23a:psecuritypriv->dot11PrivacyAlgrthm = "
1879 "%x (must be 1 or 2 or 4 or 5)\n",
1880 psecuritypriv->dot11PrivacyAlgrthm));
1881 res = _FAIL;
c17416ef
LF		 1882 kfree(pcmd);
1883 kfree(psetkeyparm);
5e93f352
LF		 1884 goto exit;
1885 }
1886
1887 pcmd->cmdcode = _SetKey_CMD_;
1888 pcmd->parmbuf = (u8 *)psetkeyparm;
1889 pcmd->cmdsz = (sizeof(struct setkey_parm));
1890 pcmd->rsp = NULL;
1891 pcmd->rspsz = 0;
1892
1893 INIT_LIST_HEAD(&pcmd->list);
1894
1895 /* sema_init(&pcmd->cmd_sem, 0); */
1896
1897 res = rtw_enqueue_cmd23a(pcmdpriv, pcmd);
1898
1899exit:
1900
1901 return res;
1902}
1903
1904/* adjust IEs for rtw_joinbss_cmd23a in WMM */
1905int rtw_restruct_wmm_ie23a(struct rtw_adapter *adapter, u8 *in_ie,
1906 u8 *out_ie, uint in_len, uint initial_out_len)
1907{
1908 unsigned int ielength = 0;
1909 unsigned int i, j;
1910
1911 i = 12; /* after the fixed IE */
1912 while(i < in_len) {
1913 ielength = initial_out_len;
1914
1915 /* WMM element ID and OUI */
1916 if (in_ie[i] == 0xDD && in_ie[i + 2] == 0x00 &&
1917 in_ie[i + 3] == 0x50 && in_ie[i + 4] == 0xF2 &&
1918 in_ie[i + 5] == 0x02 && i+5 < in_len) {
1919
1920 /* Append WMM IE to the last index of out_ie */
1921 for (j = i; j < i + 9; j++) {
1922 out_ie[ielength] = in_ie[j];
1923 ielength++;
1924 }
1925 out_ie[initial_out_len + 1] = 0x07;
1926 out_ie[initial_out_len + 6] = 0x00;
1927 out_ie[initial_out_len + 8] = 0x00;
1928
1929 break;
1930 }
1931
1932 i += (in_ie[i + 1] + 2); /* to the next IE element */
1933 }
1934
1935 return ielength;
1936}
1937
1938/* */
1939/* Ported from 8185: IsInPreAuthKeyList().
1940 (Renamed from SecIsInPreAuthKeyList(), 2006-10-13.) */
1941/* Added by Annie, 2006-05-07. */
1942/* */
1943/* Search by BSSID, */
1944/* Return Value: */
1945/* -1 :if there is no pre-auth key in the table */
1946/* >= 0 :if there is pre-auth key, and return the entry id */
1947/* */
1948/* */
1949
1950static int SecIsInPMKIDList(struct rtw_adapter *Adapter, u8 *bssid)
1951{
1952 struct security_priv *psecuritypriv = &Adapter->securitypriv;
1953 int i = 0;
1954
1955 do {
1956 if (psecuritypriv->PMKIDList[i].bUsed &&
1957 ether_addr_equal(psecuritypriv->PMKIDList[i].Bssid, bssid)) {
1958 break;
1959 } else {
1960 i++;
1961 /* continue; */
1962 }
1963 } while(i < NUM_PMKID_CACHE);
1964
1965 if (i == NUM_PMKID_CACHE) {
1966 i = -1;/* Could not find. */
1967 } else {
1968 /* There is one Pre-Authentication Key for
1969 the specific BSSID. */
1970 }
1971
1972 return i;
1973}
1974
1975/* */
1976/* Check the RSN IE length */
1977/* If the RSN IE length <= 20, the RSN IE didn't include
1978 the PMKID information */
1979/* 0-11th element in the array are the fixed IE */
1980/* 12th element in the array is the IE */
1981/* 13th element in the array is the IE length */
1982/* */
1983
1984static int rtw_append_pmkid(struct rtw_adapter *Adapter, int iEntry,
1985 u8 *ie, uint ie_len)
1986{
1987 struct security_priv *psecuritypriv = &Adapter->securitypriv;
1988
1989 if (ie[13] <= 20) {
1990 /* The RSN IE didn't include the PMK ID,
1991 append the PMK information */
1992 ie[ie_len] = 1;
1993 ie_len++;
1994 ie[ie_len] = 0; /* PMKID count = 0x0100 */
1995 ie_len++;
1996 memcpy(&ie[ie_len],
1997 &psecuritypriv->PMKIDList[iEntry].PMKID, 16);
1998
1999 ie_len += 16;
2000 ie[13] += 18;/* PMKID length = 2+16 */
2001 }
2002 return ie_len;
2003}
2004int rtw_restruct_sec_ie23a(struct rtw_adapter *adapter, u8 *in_ie, u8 *out_ie,
2005 uint in_len)
2006{
2007 u8 authmode;
2008 uint ielength;
2009 int iEntry;
2010 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
2011 struct security_priv *psecuritypriv = &adapter->securitypriv;
2012 uint ndisauthmode = psecuritypriv->ndisauthtype;
2013 uint ndissecuritytype = psecuritypriv->ndisencryptstatus;
2014
2015 RT_TRACE(_module_rtl871x_mlme_c_, _drv_notice_,
2016 ("+rtw_restruct_sec_ie23a: ndisauthmode=%d ndissecuritytype=%d\n",
2017 ndisauthmode, ndissecuritytype));
2018
2019 /* copy fixed ie only */
2020 memcpy(out_ie, in_ie, 12);
2021 ielength = 12;
2022 if ((ndisauthmode==Ndis802_11AuthModeWPA) ||
2023 (ndisauthmode==Ndis802_11AuthModeWPAPSK))
2024 authmode=_WPA_IE_ID_;
2025 if ((ndisauthmode==Ndis802_11AuthModeWPA2) ||
2026 (ndisauthmode==Ndis802_11AuthModeWPA2PSK))
2027 authmode=_WPA2_IE_ID_;
2028
2029 if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS)) {
2030 memcpy(out_ie + ielength, psecuritypriv->wps_ie,
2031 psecuritypriv->wps_ie_len);
2032
2033 ielength += psecuritypriv->wps_ie_len;
2034 } else if ((authmode==_WPA_IE_ID_) || (authmode==_WPA2_IE_ID_)) {
2035 /* copy RSN or SSN */
2036 memcpy(&out_ie[ielength], &psecuritypriv->supplicant_ie[0],
2037 psecuritypriv->supplicant_ie[1] + 2);
2038 ielength += psecuritypriv->supplicant_ie[1] + 2;
2039 rtw_report_sec_ie23a(adapter, authmode,
2040 psecuritypriv->supplicant_ie);
2041 }
2042
2043 iEntry = SecIsInPMKIDList(adapter, pmlmepriv->assoc_bssid);
2044 if (iEntry < 0) {
2045 return ielength;
2046 } else {
2047 if (authmode == _WPA2_IE_ID_) {
2048 ielength=rtw_append_pmkid(adapter, iEntry,
2049 out_ie, ielength);
2050 }
2051 }
2052
2053 return ielength;
2054}
2055
2056void rtw_init_registrypriv_dev_network23a(struct rtw_adapter* adapter)
2057{
2058 struct registry_priv* pregistrypriv = &adapter->registrypriv;
2059 struct eeprom_priv* peepriv = &adapter->eeprompriv;
2060 struct wlan_bssid_ex *pdev_network = &pregistrypriv->dev_network;
2061 u8 *myhwaddr = myid(peepriv);
2062
2063 ether_addr_copy(pdev_network->MacAddress, myhwaddr);
2064
2065 memcpy(&pdev_network->Ssid, &pregistrypriv->ssid,
2066 sizeof(struct cfg80211_ssid));
2067
2068 pdev_network->Configuration.Length=sizeof(struct ndis_802_11_config);
2069 pdev_network->Configuration.BeaconPeriod = 100;
2070 pdev_network->Configuration.FHConfig.Length = 0;
2071 pdev_network->Configuration.FHConfig.HopPattern = 0;
2072 pdev_network->Configuration.FHConfig.HopSet = 0;
2073 pdev_network->Configuration.FHConfig.DwellTime = 0;
2074
2075}
2076
2077void rtw_update_registrypriv_dev_network23a(struct rtw_adapter* adapter)
2078{
2079 int sz = 0;
2080 struct registry_priv* pregistrypriv = &adapter->registrypriv;
2081 struct wlan_bssid_ex *pdev_network = &pregistrypriv->dev_network;
2082 struct security_priv *psecuritypriv = &adapter->securitypriv;
2083 struct wlan_network *cur_network = &adapter->mlmepriv.cur_network;
2084 /* struct xmit_priv *pxmitpriv = &adapter->xmitpriv; */
2085
2086 pdev_network->Privacy =
2087 (psecuritypriv->dot11PrivacyAlgrthm > 0 ? 1 : 0);
2088
2089 pdev_network->Rssi = 0;
2090
2091 switch (pregistrypriv->wireless_mode)
2092 {
2093 case WIRELESS_11B:
2094 pdev_network->NetworkTypeInUse = Ndis802_11DS;
2095 break;
2096 case WIRELESS_11G:
2097 case WIRELESS_11BG:
2098 case WIRELESS_11_24N:
2099 case WIRELESS_11G_24N:
2100 case WIRELESS_11BG_24N:
2101 pdev_network->NetworkTypeInUse = Ndis802_11OFDM24;
2102 break;
2103 case WIRELESS_11A:
2104 case WIRELESS_11A_5N:
2105 pdev_network->NetworkTypeInUse = Ndis802_11OFDM5;
2106 break;
2107 case WIRELESS_11ABGN:
2108 if (pregistrypriv->channel > 14)
2109 pdev_network->NetworkTypeInUse = Ndis802_11OFDM5;
2110 else
2111 pdev_network->NetworkTypeInUse = Ndis802_11OFDM24;
2112 break;
2113 default :
2114 /* TODO */
2115 break;
2116 }
2117
2118 pdev_network->Configuration.DSConfig = pregistrypriv->channel;
2119 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_,
2120 ("pregistrypriv->channel =%d, pdev_network->Configuration."
2121 "DSConfig = 0x%x\n", pregistrypriv->channel,
2122 pdev_network->Configuration.DSConfig));
2123
2124 if (cur_network->network.InfrastructureMode == Ndis802_11IBSS)
2125 pdev_network->Configuration.ATIMWindow = 0;
2126
2127 pdev_network->InfrastructureMode =
2128 cur_network->network.InfrastructureMode;
2129
2130 /* 1. Supported rates */
2131 /* 2. IE */
2132
2133 sz = rtw_generate_ie23a(pregistrypriv);
2134
2135 pdev_network->IELength = sz;
2136
2137 pdev_network->Length =
2138 get_wlan_bssid_ex_sz((struct wlan_bssid_ex *)pdev_network);
2139
2140 /* notes: translate IELength & Length after assign the
2141 Length to cmdsz in createbss_cmd(); */
2142 /* pdev_network->IELength = cpu_to_le32(sz); */
2143
2144}
2145
2146void rtw_get_encrypt_decrypt_from_registrypriv23a(struct rtw_adapter* adapter)
2147{
2148
2149}
2150
2151/* the fucntion is at passive_level */
2152void rtw_joinbss_reset23a(struct rtw_adapter *padapter)
2153{
2154 u8 threshold;
2155 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2156 struct ht_priv *phtpriv = &pmlmepriv->htpriv;
2157
2158 /* todo: if you want to do something io/reg/hw setting
2159 before join_bss, please add code here */
2160
2161 pmlmepriv->num_FortyMHzIntolerant = 0;
2162
2163 pmlmepriv->num_sta_no_ht = 0;
2164
2165 phtpriv->ampdu_enable = false;/* reset to disabled */
2166
2167 /* TH = 1 => means that invalidate usb rx aggregation */
2168 /* TH = 0 => means that validate usb rx aggregation, use init value. */
2169 if (phtpriv->ht_option) {
2170 if (padapter->registrypriv.wifi_spec == 1)
2171 threshold = 1;
2172 else
2173 threshold = 0;
1e7b6ebe 2174 } else
5e93f352 2175 threshold = 1;
1e7b6ebe
JS		 2176
2177 rtl8723a_set_rxdma_agg_pg_th(padapter, threshold);
5e93f352
LF		 2178}
2179
2180/* the fucntion is >= passive_level */
2181unsigned int rtw_restructure_ht_ie23a(struct rtw_adapter *padapter, u8 *in_ie,
2182 u8 *out_ie, uint in_len, uint *pout_len)
2183{
2184 u32 ielen, out_len;
2185 int max_rx_ampdu_factor;
2186 unsigned char *p, *pframe;
2187 struct ieee80211_ht_cap ht_capie;
2188 unsigned char WMM_IE[] = {0x00, 0x50, 0xf2, 0x02, 0x00, 0x01, 0x00};
2189 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2190 struct qos_priv *pqospriv = &pmlmepriv->qospriv;
2191 struct ht_priv *phtpriv = &pmlmepriv->htpriv;
2192
2193 phtpriv->ht_option = false;
2194
2195 p = rtw_get_ie23a(in_ie + 12, _HT_CAPABILITY_IE_, &ielen, in_len - 12);
2196
2197 if (p && ielen > 0) {
2198 u32 rx_packet_offset, max_recvbuf_sz;
2199 if (pqospriv->qos_option == 0) {
2200 out_len = *pout_len;
2201 pframe = rtw_set_ie23a(out_ie + out_len,
2202 _VENDOR_SPECIFIC_IE_,
2203 _WMM_IE_Length_, WMM_IE, pout_len);
2204
2205 pqospriv->qos_option = 1;
2206 }
2207
2208 out_len = *pout_len;
2209
2210 memset(&ht_capie, 0, sizeof(struct ieee80211_ht_cap));
2211
2212 ht_capie.cap_info = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
2213 IEEE80211_HT_CAP_SGI_20 | IEEE80211_HT_CAP_SGI_40 |
2214 IEEE80211_HT_CAP_TX_STBC | IEEE80211_HT_CAP_DSSSCCK40;
2215
2216 rtw_hal_get_def_var23a(padapter, HAL_DEF_RX_PACKET_OFFSET,
2217 &rx_packet_offset);
2218 rtw_hal_get_def_var23a(padapter, HAL_DEF_MAX_RECVBUF_SZ,
2219 &max_recvbuf_sz);
2220
2221 rtw_hal_get_def_var23a(padapter, HW_VAR_MAX_RX_AMPDU_FACTOR,
2222 &max_rx_ampdu_factor);
2223 ht_capie.ampdu_params_info = max_rx_ampdu_factor & 0x03;
2224
2225 if (padapter->securitypriv.dot11PrivacyAlgrthm == _AES_)
2226 ht_capie.ampdu_params_info |=
2227 (IEEE80211_HT_AMPDU_PARM_DENSITY& (0x07 << 2));
2228 else
2229 ht_capie.ampdu_params_info |=
2230 (IEEE80211_HT_AMPDU_PARM_DENSITY & 0x00);
2231
2232 pframe = rtw_set_ie23a(out_ie + out_len, _HT_CAPABILITY_IE_,
2233 sizeof(struct ieee80211_ht_cap),
2234 (unsigned char*)&ht_capie, pout_len);
2235
2236 phtpriv->ht_option = true;
2237
2238 p = rtw_get_ie23a(in_ie + 12, _HT_ADD_INFO_IE_, &ielen, in_len-12);
2239 if (p && (ielen == sizeof(struct ieee80211_ht_addt_info))) {
2240 out_len = *pout_len;
2241 pframe = rtw_set_ie23a(out_ie + out_len, _HT_ADD_INFO_IE_,
2242 ielen, p + 2 , pout_len);
2243 }
2244 }
2245
2246 return phtpriv->ht_option;
2247}
2248
2249/* the fucntion is > passive_level (in critical_section) */
2250void rtw_update_ht_cap23a(struct rtw_adapter *padapter, u8 *pie, uint ie_len)
2251{
2252 u8 *p, max_ampdu_sz;
2253 int len;
2254 /* struct sta_info *bmc_sta, *psta; */
2255 struct ieee80211_ht_cap *pht_capie;
2256 struct ieee80211_ht_addt_info *pht_addtinfo;
2257 /* struct recv_reorder_ctrl *preorder_ctrl; */
2258 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2259 struct ht_priv *phtpriv = &pmlmepriv->htpriv;
2260 /* struct recv_priv *precvpriv = &padapter->recvpriv; */
2261 struct registry_priv *pregistrypriv = &padapter->registrypriv;
2262 /* struct wlan_network *pcur_network = &pmlmepriv->cur_network;; */
2263 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2264 struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
2265
2266 if (!phtpriv->ht_option)
2267 return;
2268
2269 if ((!pmlmeinfo->HT_info_enable) || (!pmlmeinfo->HT_caps_enable))
2270 return;
2271
2272 DBG_8723A("+rtw_update_ht_cap23a()\n");
2273
2274 /* maybe needs check if ap supports rx ampdu. */
2275 if ((phtpriv->ampdu_enable == false) && (pregistrypriv->ampdu_enable == 1)) {
2276 if (pregistrypriv->wifi_spec == 1)
2277 phtpriv->ampdu_enable = false;
2278 else
2279 phtpriv->ampdu_enable = true;
2280 } else if (pregistrypriv->ampdu_enable == 2) {
2281 phtpriv->ampdu_enable = true;
2282 }
2283
2284 /* check Max Rx A-MPDU Size */
2285 len = 0;
2286 p = rtw_get_ie23a(pie+sizeof (struct ndis_802_11_fixed_ies), _HT_CAPABILITY_IE_, &len, ie_len-sizeof (struct ndis_802_11_fixed_ies));
2287 if (p && len > 0) {
2288 pht_capie = (struct ieee80211_ht_cap *)(p+2);
2289 max_ampdu_sz = (pht_capie->ampdu_params_info & IEEE80211_HT_AMPDU_PARM_FACTOR);
2290 max_ampdu_sz = 1 << (max_ampdu_sz+3); /* max_ampdu_sz (kbytes); */
2291
2292 /* DBG_8723A("rtw_update_ht_cap23a(): max_ampdu_sz =%d\n", max_ampdu_sz); */
2293 phtpriv->rx_ampdu_maxlen = max_ampdu_sz;
2294
2295 }
2296
2297 len = 0;
2298 p = rtw_get_ie23a(pie+sizeof (struct ndis_802_11_fixed_ies), _HT_ADD_INFO_IE_, &len, ie_len-sizeof (struct ndis_802_11_fixed_ies));
2299 if (p && len>0)
2300 {
2301 pht_addtinfo = (struct ieee80211_ht_addt_info *)(p+2);
2302 /* todo: */
2303 }
2304
2305 /* update cur_bwmode & cur_ch_offset */
2306 if ((pregistrypriv->cbw40_enable) &&
2307 (pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info & BIT(1)) &&
2308 (pmlmeinfo->HT_info.infos[0] & BIT(2)))
2309 {
2310 int i;
2311 u8 rf_type;
2312
2313 padapter->HalFunc.GetHwRegHandler(padapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type));
2314
2315 /* update the MCS rates */
2316 for (i = 0; i < 16; i++)
2317 {
2318 if ((rf_type == RF_1T1R) || (rf_type == RF_1T2R))
2319 pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate[i] &= MCS_rate_1R23A[i];
2320 else
2321 pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate[i] &= MCS_rate_2R23A[i];
2322 }
2323 /* switch to the 40M Hz mode accoring to the AP */
2324 pmlmeext->cur_bwmode = HT_CHANNEL_WIDTH_40;
2325 switch ((pmlmeinfo->HT_info.infos[0] & 0x3))
2326 {
b54e8804
JS		 2327 case HT_EXTCHNL_OFFSET_UPPER:
2328 pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_LOWER;
2329 break;
5e93f352 2330
b54e8804
JS		 2331 case HT_EXTCHNL_OFFSET_LOWER:
2332 pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_UPPER;
2333 break;
5e93f352 2334
b54e8804
JS		 2335 default:
2336 pmlmeext->cur_ch_offset =
2337 HAL_PRIME_CHNL_OFFSET_DONT_CARE;
2338 break;
5e93f352
LF		 2339 }
2340 }
2341
2342 /* */
2343 /* Config SM Power Save setting */
2344 /* */
2345 pmlmeinfo->SM_PS = (pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info & 0x0C) >> 2;
2346 if (pmlmeinfo->SM_PS == WLAN_HT_CAP_SM_PS_STATIC)
2347 DBG_8723A("%s(): WLAN_HT_CAP_SM_PS_STATIC\n", __func__);
2348
2349 /* */
2350 /* Config current HT Protection mode. */
2351 /* */
2352 pmlmeinfo->HT_protection = pmlmeinfo->HT_info.infos[1] & 0x3;
2353}
2354
2355void rtw_issue_addbareq_cmd23a(struct rtw_adapter *padapter, struct xmit_frame *pxmitframe)
2356{
2357 u8 issued;
2358 int priority;
2359 struct sta_info *psta = NULL;
2360 struct ht_priv *phtpriv;
2361 struct pkt_attrib *pattrib = &pxmitframe->attrib;
2362 s32 bmcst = is_multicast_ether_addr(pattrib->ra);
2363
2364 if (bmcst || (padapter->mlmepriv.LinkDetectInfo.NumTxOkInPeriod<100))
2365 return;
2366
2367 priority = pattrib->priority;
2368
2369 if (pattrib->psta)
2370 psta = pattrib->psta;
2371 else
2372 {
2373 DBG_8723A("%s, call rtw_get_stainfo23a()\n", __func__);
2374 psta = rtw_get_stainfo23a(&padapter->stapriv, pattrib->ra);
2375 }
2376
2377 if (psta == NULL)
2378 {
2379 DBG_8723A("%s, psta == NUL\n", __func__);
2380 return;
2381 }
2382
2383 if (!(psta->state &_FW_LINKED))
2384 {
2385 DBG_8723A("%s, psta->state(0x%x) != _FW_LINKED\n", __func__, psta->state);
2386 return;
2387 }
2388
2389 phtpriv = &psta->htpriv;
2390
2391 if ((phtpriv->ht_option == true) && (phtpriv->ampdu_enable == true))
2392 {
2393 issued = (phtpriv->agg_enable_bitmap>>priority)&0x1;
2394 issued |= (phtpriv->candidate_tid_bitmap>>priority)&0x1;
2395
2396 if (0 == issued)
2397 {
2398 DBG_8723A("rtw_issue_addbareq_cmd23a, p =%d\n", priority);
2399 psta->htpriv.candidate_tid_bitmap |= CHKBIT((u8)priority);
2400 rtw_addbareq_cmd23a(padapter, (u8) priority, pattrib->ra);
2401 }
2402 }
2403}
2404
2405inline void rtw_set_roaming(struct rtw_adapter *adapter, u8 to_roaming)
2406{
2407 if (to_roaming == 0)
2408 adapter->mlmepriv.to_join = false;
2409 adapter->mlmepriv.to_roaming = to_roaming;
2410}
2411
2412inline u8 rtw_to_roaming(struct rtw_adapter *adapter)
2413{
2414 return adapter->mlmepriv.to_roaming;
2415}
2416
2417void rtw23a_roaming(struct rtw_adapter *padapter, struct wlan_network *tgt_network)
2418{
2419 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2420
2421 spin_lock_bh(&pmlmepriv->lock);
2422 _rtw23a_roaming(padapter, tgt_network);
2423 spin_unlock_bh(&pmlmepriv->lock);
2424}
2425void _rtw23a_roaming(struct rtw_adapter *padapter, struct wlan_network *tgt_network)
2426{
2427 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2428 struct wlan_network *pnetwork;
2429 int do_join_r;
2430
2431 if (tgt_network != NULL)
2432 pnetwork = tgt_network;
2433 else
2434 pnetwork = &pmlmepriv->cur_network;
2435
2436 if (0 < rtw_to_roaming(padapter)) {
2437 DBG_8723A("roaming from %s("MAC_FMT"), length:%d\n",
2438 pnetwork->network.Ssid.ssid,
2439 MAC_ARG(pnetwork->network.MacAddress),
2440 pnetwork->network.Ssid.ssid_len);
2441 memcpy(&pmlmepriv->assoc_ssid, &pnetwork->network.Ssid,
2442 sizeof(struct cfg80211_ssid));
2443
2444 pmlmepriv->assoc_by_bssid = false;
2445
2446 while(1) {
2447 if (_SUCCESS == (do_join_r = rtw_do_join23a(padapter))) {
2448 break;
2449 } else {
2450 DBG_8723A("roaming do_join return %d\n", do_join_r);
2451 pmlmepriv->to_roaming--;
2452
2453 if (0 < rtw_to_roaming(padapter)) {
2454 continue;
2455 } else {
2456 DBG_8723A("%s(%d) -to roaming fail, indicate_disconnect\n", __func__, __LINE__);
2457 rtw_indicate_disconnect23a(padapter);
2458 break;
2459 }
2460 }
2461 }
2462 }
2463}
2464
2465int rtw_linked_check(struct rtw_adapter *padapter)
2466{
2467 if ((check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE)) ||
2468 (check_fwstate(&padapter->mlmepriv, WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE))) {
2469 if (padapter->stapriv.asoc_sta_count > 2)
2470 return true;
2471 } else { /* Station mode */
2472 if (check_fwstate(&padapter->mlmepriv, _FW_LINKED) == true)
2473 return true;
2474 }
2475 return false;
2476}
Ubuntu Artful kernel mirror