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