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 timer_delete_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 the_same_macaddr = !memcmp(pnetwork->network.mac_address, cur_network->network.mac_address, ETH_ALEN);
1096
1097 pnetwork->network.length = get_wlan_bssid_ex_sz(&pnetwork->network);
1098 if (pnetwork->network.length > sizeof(struct wlan_bssid_ex))
1099 return;
1100
1101 spin_lock_bh(&pmlmepriv->lock);
1102
1103 pmlmepriv->LinkDetectInfo.TrafficTransitionCount = 0;
1104 pmlmepriv->LinkDetectInfo.LowPowerTransitionCount = 0;
1105
1106 if (pnetwork->join_res > 0) {
1107 spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1108 retry = 0;
1109 if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) {
1110 /* s1. find ptarget_wlan */
1111 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
1112 if (the_same_macaddr) {
1113 ptarget_wlan = rtw_find_network(&pmlmepriv->scanned_queue, cur_network->network.mac_address);
1114 } else {
1115 pcur_wlan = rtw_find_network(&pmlmepriv->scanned_queue, cur_network->network.mac_address);
1116 if (pcur_wlan)
1117 pcur_wlan->fixed = false;
1118
1119 pcur_sta = rtw_get_stainfo(pstapriv, cur_network->network.mac_address);
1120 if (pcur_sta)
1121 rtw_free_stainfo(adapter, pcur_sta);
1122
1123 ptarget_wlan = rtw_find_network(&pmlmepriv->scanned_queue, pnetwork->network.mac_address);
1124 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) {
1125 if (ptarget_wlan)
1126 ptarget_wlan->fixed = true;
1127 }
1128 }
1129
1130 } else {
1131 ptarget_wlan = _rtw_find_same_network(&pmlmepriv->scanned_queue, pnetwork);
1132 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) {
1133 if (ptarget_wlan)
1134 ptarget_wlan->fixed = true;
1135 }
1136 }
1137
1138 /* s2. update cur_network */
1139 if (ptarget_wlan) {
1140 rtw_joinbss_update_network(adapter, ptarget_wlan, pnetwork);
1141 } else {
1142 netdev_dbg(adapter->pnetdev,
1143 "Can't find ptarget_wlan when joinbss_event callback\n");
1144 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1145 goto ignore_joinbss_callback;
1146 }
1147
1148 /* s3. find ptarget_sta & update ptarget_sta after update cur_network only for station mode */
1149 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) {
1150 ptarget_sta = rtw_joinbss_update_stainfo(adapter, pnetwork);
1151 if (!ptarget_sta) {
1152 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1153 goto ignore_joinbss_callback;
1154 }
1155 }
1156
1157 /* s4. indicate connect */
1158 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) {
1159 pmlmepriv->cur_network_scanned = ptarget_wlan;
1160 rtw_indicate_connect(adapter);
1161 }
1162
1163 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1164
1165 spin_unlock_bh(&pmlmepriv->lock);
1166 /* s5. Cancel assoc_timer */
1167 timer_delete_sync(&pmlmepriv->assoc_timer);
1168 spin_lock_bh(&pmlmepriv->lock);
1169 } else {
1170 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1171 }
1172 } else if (pnetwork->join_res == -4) {
1173 rtw_reset_securitypriv(adapter);
1174 _set_timer(&pmlmepriv->assoc_timer, 1);
1175
1176 if ((check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) == true)
1177 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
1178
1179 } else {/* if join_res < 0 (join fails), then try again */
1180
1181 #ifdef REJOIN
1182 res = _FAIL;
1183 if (retry < 2)
1184 res = rtw_select_and_join_from_scanned_queue(pmlmepriv);
1185
1186 if (res == _SUCCESS) {
1187 /* extend time of assoc_timer */
1188 _set_timer(&pmlmepriv->assoc_timer, MAX_JOIN_TIMEOUT);
1189 retry++;
1190 } else if (res == 2) {/* there is no need to wait for join */
1191 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
1192 rtw_indicate_connect(adapter);
1193 } else {
1194 #endif
1195
1196 _set_timer(&pmlmepriv->assoc_timer, 1);
1197 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
1198
1199 #ifdef REJOIN
1200 retry = 0;
1201 }
1202 #endif
1203 }
1204
1205 ignore_joinbss_callback:
1206
1207 spin_unlock_bh(&pmlmepriv->lock);
1208 }
1209
rtw_joinbss_event_callback(struct adapter * adapter,u8 * pbuf)1210 void rtw_joinbss_event_callback(struct adapter *adapter, u8 *pbuf)
1211 {
1212 struct wlan_network *pnetwork = (struct wlan_network *)pbuf;
1213
1214 mlmeext_joinbss_event_callback(adapter, pnetwork->join_res);
1215
1216 rtw_os_xmit_schedule(adapter);
1217 }
1218
1219 /* FOR STA, AP , AD-HOC mode */
rtw_sta_media_status_rpt(struct adapter * adapter,struct sta_info * psta,u32 mstatus)1220 void rtw_sta_media_status_rpt(struct adapter *adapter, struct sta_info *psta, u32 mstatus)
1221 {
1222 u16 media_status_rpt;
1223
1224 if (!psta)
1225 return;
1226
1227 media_status_rpt = (u16)((psta->mac_id<<8)|mstatus); /* MACID|OPMODE:1 connect */
1228 rtw_hal_set_hwreg(adapter, HW_VAR_H2C_MEDIA_STATUS_RPT, (u8 *)&media_status_rpt);
1229 }
1230
rtw_stassoc_event_callback(struct adapter * adapter,u8 * pbuf)1231 void rtw_stassoc_event_callback(struct adapter *adapter, u8 *pbuf)
1232 {
1233 struct sta_info *psta;
1234 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1235 struct stassoc_event *pstassoc = (struct stassoc_event *)pbuf;
1236 struct wlan_network *cur_network = &pmlmepriv->cur_network;
1237 struct wlan_network *ptarget_wlan = NULL;
1238
1239 if (rtw_access_ctrl(adapter, pstassoc->macaddr) == false)
1240 return;
1241
1242 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
1243 psta = rtw_get_stainfo(&adapter->stapriv, pstassoc->macaddr);
1244 if (psta) {
1245 u8 *passoc_req = NULL;
1246 u32 assoc_req_len = 0;
1247
1248 rtw_sta_media_status_rpt(adapter, psta, 1);
1249
1250 ap_sta_info_defer_update(adapter, psta);
1251
1252 /* report to upper layer */
1253 spin_lock_bh(&psta->lock);
1254 if (psta->passoc_req && psta->assoc_req_len > 0) {
1255 passoc_req = rtw_zmalloc(psta->assoc_req_len);
1256 if (passoc_req) {
1257 assoc_req_len = psta->assoc_req_len;
1258 memcpy(passoc_req, psta->passoc_req, assoc_req_len);
1259
1260 kfree(psta->passoc_req);
1261 psta->passoc_req = NULL;
1262 psta->assoc_req_len = 0;
1263 }
1264 }
1265 spin_unlock_bh(&psta->lock);
1266
1267 if (passoc_req && assoc_req_len > 0) {
1268 rtw_cfg80211_indicate_sta_assoc(adapter, passoc_req, assoc_req_len);
1269
1270 kfree(passoc_req);
1271 }
1272 }
1273 return;
1274 }
1275
1276 /* for AD-HOC mode */
1277 psta = rtw_get_stainfo(&adapter->stapriv, pstassoc->macaddr);
1278 if (psta) {
1279 /* the sta have been in sta_info_queue => do nothing */
1280
1281 return; /* between drv has received this event before and fw have not yet to set key to CAM_ENTRY) */
1282 }
1283
1284 psta = rtw_alloc_stainfo(&adapter->stapriv, pstassoc->macaddr);
1285 if (!psta)
1286 return;
1287
1288 /* to do : init sta_info variable */
1289 psta->qos_option = 0;
1290 psta->mac_id = (uint)pstassoc->cam_id;
1291
1292 /* for ad-hoc mode */
1293 rtw_hal_set_odm_var(adapter, HAL_ODM_STA_INFO, psta, true);
1294
1295 rtw_sta_media_status_rpt(adapter, psta, 1);
1296
1297 if (adapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X)
1298 psta->dot118021XPrivacy = adapter->securitypriv.dot11PrivacyAlgrthm;
1299
1300 psta->ieee8021x_blocked = false;
1301
1302 spin_lock_bh(&pmlmepriv->lock);
1303
1304 if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) ||
1305 (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true)) {
1306 if (adapter->stapriv.asoc_sta_count == 2) {
1307 spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1308 ptarget_wlan = rtw_find_network(&pmlmepriv->scanned_queue, cur_network->network.mac_address);
1309 pmlmepriv->cur_network_scanned = ptarget_wlan;
1310 if (ptarget_wlan)
1311 ptarget_wlan->fixed = true;
1312 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1313 /* a sta + bc/mc_stainfo (not Ibss_stainfo) */
1314 rtw_indicate_connect(adapter);
1315 }
1316 }
1317
1318 spin_unlock_bh(&pmlmepriv->lock);
1319
1320 mlmeext_sta_add_event_callback(adapter, psta);
1321 }
1322
rtw_stadel_event_callback(struct adapter * adapter,u8 * pbuf)1323 void rtw_stadel_event_callback(struct adapter *adapter, u8 *pbuf)
1324 {
1325 int mac_id = (-1);
1326 struct sta_info *psta;
1327 struct wlan_network *pwlan = NULL;
1328 struct wlan_bssid_ex *pdev_network = NULL;
1329 u8 *pibss = NULL;
1330 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1331 struct stadel_event *pstadel = (struct stadel_event *)pbuf;
1332 struct wlan_network *tgt_network = &pmlmepriv->cur_network;
1333 struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
1334 struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
1335
1336 psta = rtw_get_stainfo(&adapter->stapriv, pstadel->macaddr);
1337 if (psta)
1338 mac_id = psta->mac_id;
1339 else
1340 mac_id = pstadel->mac_id;
1341
1342 if (mac_id >= 0) {
1343 u16 media_status;
1344
1345 media_status = (mac_id<<8)|0; /* MACID|OPMODE:0 means disconnect */
1346 /* for STA, AP, ADHOC mode, report disconnect stauts to FW */
1347 rtw_hal_set_hwreg(adapter, HW_VAR_H2C_MEDIA_STATUS_RPT, (u8 *)&media_status);
1348 }
1349
1350 /* if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) */
1351 if ((pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE)
1352 return;
1353
1354 mlmeext_sta_del_event_callback(adapter);
1355
1356 spin_lock_bh(&pmlmepriv->lock);
1357
1358 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) {
1359 u16 reason = *((unsigned short *)(pstadel->rsvd));
1360 bool roam = false;
1361 struct wlan_network *roam_target = NULL;
1362
1363 if (adapter->registrypriv.wifi_spec == 1) {
1364 roam = false;
1365 } else if (reason == WLAN_REASON_EXPIRATION_CHK && rtw_chk_roam_flags(adapter, RTW_ROAM_ON_EXPIRED)) {
1366 roam = true;
1367 } else if (reason == WLAN_REASON_ACTIVE_ROAM && rtw_chk_roam_flags(adapter, RTW_ROAM_ACTIVE)) {
1368 roam = true;
1369 roam_target = pmlmepriv->roam_network;
1370 }
1371
1372 if (roam) {
1373 if (rtw_to_roam(adapter) > 0)
1374 rtw_dec_to_roam(adapter); /* this stadel_event is caused by roaming, decrease to_roam */
1375 else if (rtw_to_roam(adapter) == 0)
1376 rtw_set_to_roam(adapter, adapter->registrypriv.max_roaming_times);
1377 } else {
1378 rtw_set_to_roam(adapter, 0);
1379 }
1380
1381 rtw_free_uc_swdec_pending_queue(adapter);
1382
1383 rtw_free_assoc_resources(adapter, 1);
1384 rtw_indicate_disconnect(adapter);
1385
1386 spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1387 /* remove the network entry in scanned_queue */
1388 pwlan = rtw_find_network(&pmlmepriv->scanned_queue, tgt_network->network.mac_address);
1389 if (pwlan) {
1390 pwlan->fixed = false;
1391 rtw_free_network_nolock(adapter, pwlan);
1392 }
1393 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1394
1395 _rtw_roaming(adapter, roam_target);
1396 }
1397
1398 if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) ||
1399 check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) {
1400
1401 rtw_free_stainfo(adapter, psta);
1402
1403 if (adapter->stapriv.asoc_sta_count == 1) {/* a sta + bc/mc_stainfo (not Ibss_stainfo) */
1404 u8 ret = _SUCCESS;
1405 spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1406 /* free old ibss network */
1407 pwlan = rtw_find_network(&pmlmepriv->scanned_queue, tgt_network->network.mac_address);
1408 if (pwlan) {
1409 pwlan->fixed = false;
1410 rtw_free_network_nolock(adapter, pwlan);
1411 }
1412 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1413 /* re-create ibss */
1414 pdev_network = &adapter->registrypriv.dev_network;
1415 pibss = adapter->registrypriv.dev_network.mac_address;
1416
1417 memcpy(pdev_network, &tgt_network->network, get_wlan_bssid_ex_sz(&tgt_network->network));
1418
1419 memcpy(&pdev_network->ssid, &pmlmepriv->assoc_ssid, sizeof(struct ndis_802_11_ssid));
1420
1421 rtw_update_registrypriv_dev_network(adapter);
1422
1423 rtw_generate_random_ibss(pibss);
1424
1425 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) {
1426 set_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE);
1427 _clr_fwstate_(pmlmepriv, WIFI_ADHOC_STATE);
1428 }
1429
1430 ret = rtw_createbss_cmd(adapter);
1431 if (ret != _SUCCESS)
1432 goto unlock;
1433 }
1434
1435 }
1436
1437 unlock:
1438 spin_unlock_bh(&pmlmepriv->lock);
1439 }
1440
rtw_cpwm_event_callback(struct adapter * padapter,u8 * pbuf)1441 void rtw_cpwm_event_callback(struct adapter *padapter, u8 *pbuf)
1442 {
1443 struct reportpwrstate_parm *preportpwrstate;
1444
1445 preportpwrstate = (struct reportpwrstate_parm *)pbuf;
1446 preportpwrstate->state |= (u8)(adapter_to_pwrctl(padapter)->cpwm_tog + 0x80);
1447 cpwm_int_hdl(padapter, preportpwrstate);
1448 }
1449
rtw_wmm_event_callback(struct adapter * padapter,u8 * pbuf)1450 void rtw_wmm_event_callback(struct adapter *padapter, u8 *pbuf)
1451 {
1452 WMMOnAssocRsp(padapter);
1453 }
1454
1455 /*
1456 * _rtw_join_timeout_handler - Timeout/failure handler for CMD JoinBss
1457 * @adapter: pointer to struct adapter structure
1458 */
_rtw_join_timeout_handler(struct timer_list * t)1459 void _rtw_join_timeout_handler(struct timer_list *t)
1460 {
1461 struct adapter *adapter = timer_container_of(adapter, t,
1462 mlmepriv.assoc_timer);
1463 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1464
1465 if (adapter->bDriverStopped || adapter->bSurpriseRemoved)
1466 return;
1467
1468 spin_lock_bh(&pmlmepriv->lock);
1469
1470 if (rtw_to_roam(adapter) > 0) { /* join timeout caused by roaming */
1471 while (1) {
1472 rtw_dec_to_roam(adapter);
1473 if (rtw_to_roam(adapter) != 0) { /* try another */
1474 int do_join_r;
1475
1476 do_join_r = rtw_do_join(adapter);
1477 if (do_join_r != _SUCCESS)
1478 continue;
1479
1480 break;
1481 } else {
1482 rtw_indicate_disconnect(adapter);
1483 break;
1484 }
1485 }
1486
1487 } else {
1488 rtw_indicate_disconnect(adapter);
1489 free_scanqueue(pmlmepriv);/* */
1490
1491 /* indicate disconnect for the case that join_timeout and check_fwstate != FW_LINKED */
1492 rtw_cfg80211_indicate_disconnect(adapter);
1493
1494 }
1495
1496 spin_unlock_bh(&pmlmepriv->lock);
1497 }
1498
1499 /*
1500 * rtw_scan_timeout_handler - Timeout/Failure handler for CMD SiteSurvey
1501 * @adapter: pointer to struct adapter structure
1502 */
rtw_scan_timeout_handler(struct timer_list * t)1503 void rtw_scan_timeout_handler(struct timer_list *t)
1504 {
1505 struct adapter *adapter = timer_container_of(adapter, t,
1506 mlmepriv.scan_to_timer);
1507 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1508
1509 spin_lock_bh(&pmlmepriv->lock);
1510
1511 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY);
1512
1513 spin_unlock_bh(&pmlmepriv->lock);
1514
1515 rtw_indicate_scan_done(adapter, true);
1516 }
1517
rtw_mlme_reset_auto_scan_int(struct adapter * adapter)1518 void rtw_mlme_reset_auto_scan_int(struct adapter *adapter)
1519 {
1520 struct mlme_priv *mlme = &adapter->mlmepriv;
1521 struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
1522 struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
1523
1524 if (pmlmeinfo->VHT_enable) /* disable auto scan when connect to 11AC AP */
1525 mlme->auto_scan_int_ms = 0;
1526 else if (adapter->registrypriv.wifi_spec && is_client_associated_to_ap(adapter) == true)
1527 mlme->auto_scan_int_ms = 60*1000;
1528 else if (rtw_chk_roam_flags(adapter, RTW_ROAM_ACTIVE)) {
1529 if (check_fwstate(mlme, WIFI_STATION_STATE) && check_fwstate(mlme, _FW_LINKED))
1530 mlme->auto_scan_int_ms = mlme->roam_scan_int_ms;
1531 } else
1532 mlme->auto_scan_int_ms = 0; /* disabled */
1533 }
1534
rtw_auto_scan_handler(struct adapter * padapter)1535 static void rtw_auto_scan_handler(struct adapter *padapter)
1536 {
1537 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1538
1539 rtw_mlme_reset_auto_scan_int(padapter);
1540
1541 if (pmlmepriv->auto_scan_int_ms != 0
1542 && jiffies_to_msecs(jiffies - pmlmepriv->scan_start_time) > pmlmepriv->auto_scan_int_ms) {
1543
1544 if (!padapter->registrypriv.wifi_spec) {
1545 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY | _FW_UNDER_LINKING) == true)
1546 goto exit;
1547
1548 if (pmlmepriv->LinkDetectInfo.bBusyTraffic)
1549 goto exit;
1550 }
1551
1552 rtw_set_802_11_bssid_list_scan(padapter, NULL, 0);
1553 }
1554
1555 exit:
1556 return;
1557 }
1558
rtw_dynamic_check_timer_handler(struct adapter * adapter)1559 void rtw_dynamic_check_timer_handler(struct adapter *adapter)
1560 {
1561 if (!adapter)
1562 return;
1563
1564 if (!adapter->hw_init_completed)
1565 return;
1566
1567 if (adapter->bDriverStopped || adapter->bSurpriseRemoved)
1568 return;
1569
1570 if (adapter->net_closed)
1571 return;
1572
1573 if ((adapter_to_pwrctl(adapter)->fw_current_in_ps_mode)
1574 && !(hal_btcoex_IsBtControlLps(adapter))
1575 ) {
1576 u8 bEnterPS;
1577
1578 linked_status_chk(adapter);
1579
1580 bEnterPS = traffic_status_watchdog(adapter, 1);
1581 if (bEnterPS) {
1582 /* rtw_lps_ctrl_wk_cmd(adapter, LPS_CTRL_ENTER, 1); */
1583 rtw_hal_dm_watchdog_in_lps(adapter);
1584 } else {
1585 /* call rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_LEAVE, 1) in traffic_status_watchdog() */
1586 }
1587
1588 } else {
1589 rtw_dynamic_chk_wk_cmd(adapter);
1590 }
1591
1592 /* auto site survey */
1593 rtw_auto_scan_handler(adapter);
1594 }
1595
rtw_is_scan_deny(struct adapter * adapter)1596 inline bool rtw_is_scan_deny(struct adapter *adapter)
1597 {
1598 struct mlme_priv *mlmepriv = &adapter->mlmepriv;
1599
1600 return (atomic_read(&mlmepriv->set_scan_deny) != 0) ? true : false;
1601 }
1602
rtw_clear_scan_deny(struct adapter * adapter)1603 inline void rtw_clear_scan_deny(struct adapter *adapter)
1604 {
1605 struct mlme_priv *mlmepriv = &adapter->mlmepriv;
1606
1607 atomic_set(&mlmepriv->set_scan_deny, 0);
1608 }
1609
rtw_set_scan_deny(struct adapter * adapter,u32 ms)1610 void rtw_set_scan_deny(struct adapter *adapter, u32 ms)
1611 {
1612 struct mlme_priv *mlmepriv = &adapter->mlmepriv;
1613
1614 atomic_set(&mlmepriv->set_scan_deny, 1);
1615 _set_timer(&mlmepriv->set_scan_deny_timer, ms);
1616 }
1617
1618 /*
1619 * Select a new roaming candidate from the original @param candidate and @param competitor
1620 * @return true: candidate is updated
1621 * @return false: candidate is not updated
1622 */
rtw_check_roaming_candidate(struct mlme_priv * mlme,struct wlan_network ** candidate,struct wlan_network * competitor)1623 static int rtw_check_roaming_candidate(struct mlme_priv *mlme
1624 , struct wlan_network **candidate, struct wlan_network *competitor)
1625 {
1626 int updated = false;
1627 struct adapter *adapter = container_of(mlme, struct adapter, mlmepriv);
1628
1629 if (is_same_ess(&competitor->network, &mlme->cur_network.network) == false)
1630 goto exit;
1631
1632 if (rtw_is_desired_network(adapter, competitor) == false)
1633 goto exit;
1634
1635 /* got specific addr to roam */
1636 if (!is_zero_mac_addr(mlme->roam_tgt_addr)) {
1637 if (!memcmp(mlme->roam_tgt_addr, competitor->network.mac_address, ETH_ALEN))
1638 goto update;
1639 else
1640 goto exit;
1641 }
1642 if (jiffies_to_msecs(jiffies - competitor->last_scanned) >= mlme->roam_scanr_exp_ms)
1643 goto exit;
1644
1645 if (competitor->network.rssi - mlme->cur_network_scanned->network.rssi < mlme->roam_rssi_diff_th)
1646 goto exit;
1647
1648 if (*candidate && (*candidate)->network.rssi >= competitor->network.rssi)
1649 goto exit;
1650
1651 update:
1652 *candidate = competitor;
1653 updated = true;
1654
1655 exit:
1656 return updated;
1657 }
1658
rtw_select_roaming_candidate(struct mlme_priv * mlme)1659 int rtw_select_roaming_candidate(struct mlme_priv *mlme)
1660 {
1661 int ret = _FAIL;
1662 struct list_head *phead;
1663 struct __queue *queue = &mlme->scanned_queue;
1664 struct wlan_network *pnetwork = NULL;
1665 struct wlan_network *candidate = NULL;
1666
1667 if (!mlme->cur_network_scanned) {
1668 rtw_warn_on(1);
1669 return ret;
1670 }
1671
1672 spin_lock_bh(&mlme->scanned_queue.lock);
1673 phead = get_list_head(queue);
1674
1675 list_for_each(mlme->pscanned, phead) {
1676
1677 pnetwork = list_entry(mlme->pscanned, struct wlan_network,
1678 list);
1679
1680 rtw_check_roaming_candidate(mlme, &candidate, pnetwork);
1681
1682 }
1683
1684 if (!candidate) {
1685 ret = _FAIL;
1686 goto exit;
1687 } else {
1688 mlme->roam_network = candidate;
1689
1690 if (!memcmp(candidate->network.mac_address, mlme->roam_tgt_addr, ETH_ALEN))
1691 eth_zero_addr(mlme->roam_tgt_addr);
1692 }
1693
1694 ret = _SUCCESS;
1695 exit:
1696 spin_unlock_bh(&mlme->scanned_queue.lock);
1697
1698 return ret;
1699 }
1700
1701 /*
1702 * Select a new join candidate from the original @param candidate and @param competitor
1703 * @return true: candidate is updated
1704 * @return false: candidate is not updated
1705 */
rtw_check_join_candidate(struct mlme_priv * mlme,struct wlan_network ** candidate,struct wlan_network * competitor)1706 static int rtw_check_join_candidate(struct mlme_priv *mlme
1707 , struct wlan_network **candidate, struct wlan_network *competitor)
1708 {
1709 int updated = false;
1710 struct adapter *adapter = container_of(mlme, struct adapter, mlmepriv);
1711
1712 /* check bssid, if needed */
1713 if (mlme->assoc_by_bssid) {
1714 if (memcmp(competitor->network.mac_address, mlme->assoc_bssid, ETH_ALEN))
1715 goto exit;
1716 }
1717
1718 /* check ssid, if needed */
1719 if (mlme->assoc_ssid.ssid[0] && mlme->assoc_ssid.ssid_length) {
1720 if (competitor->network.ssid.ssid_length != mlme->assoc_ssid.ssid_length
1721 || memcmp(competitor->network.ssid.ssid, mlme->assoc_ssid.ssid, mlme->assoc_ssid.ssid_length)
1722 )
1723 goto exit;
1724 }
1725
1726 if (rtw_is_desired_network(adapter, competitor) == false)
1727 goto exit;
1728
1729 if (rtw_to_roam(adapter) > 0) {
1730 if (jiffies_to_msecs(jiffies - competitor->last_scanned) >= mlme->roam_scanr_exp_ms
1731 || is_same_ess(&competitor->network, &mlme->cur_network.network) == false
1732 )
1733 goto exit;
1734 }
1735
1736 if (!*candidate || (*candidate)->network.rssi < competitor->network.rssi) {
1737 *candidate = competitor;
1738 updated = true;
1739 }
1740
1741 exit:
1742 return updated;
1743 }
1744
1745 /*
1746 Calling context:
1747 The caller of the sub-routine will be in critical section...
1748 The caller must hold the following spinlock
1749 pmlmepriv->lock
1750 */
1751
rtw_select_and_join_from_scanned_queue(struct mlme_priv * pmlmepriv)1752 int rtw_select_and_join_from_scanned_queue(struct mlme_priv *pmlmepriv)
1753 {
1754 int ret;
1755 struct list_head *phead;
1756 struct adapter *adapter;
1757 struct __queue *queue = &pmlmepriv->scanned_queue;
1758 struct wlan_network *pnetwork = NULL;
1759 struct wlan_network *candidate = NULL;
1760
1761 adapter = (struct adapter *)pmlmepriv->nic_hdl;
1762
1763 spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1764
1765 if (pmlmepriv->roam_network) {
1766 candidate = pmlmepriv->roam_network;
1767 pmlmepriv->roam_network = NULL;
1768 goto candidate_exist;
1769 }
1770
1771 phead = get_list_head(queue);
1772 list_for_each(pmlmepriv->pscanned, phead) {
1773
1774 pnetwork = list_entry(pmlmepriv->pscanned,
1775 struct wlan_network, list);
1776
1777 rtw_check_join_candidate(pmlmepriv, &candidate, pnetwork);
1778
1779 }
1780
1781 if (!candidate) {
1782 ret = _FAIL;
1783 goto exit;
1784 } else {
1785 goto candidate_exist;
1786 }
1787
1788 candidate_exist:
1789
1790 /* check for situation of _FW_LINKED */
1791 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
1792 rtw_disassoc_cmd(adapter, 0, true);
1793 rtw_indicate_disconnect(adapter);
1794 rtw_free_assoc_resources(adapter, 0);
1795 }
1796
1797 set_fwstate(pmlmepriv, _FW_UNDER_LINKING);
1798 ret = rtw_joinbss_cmd(adapter, candidate);
1799
1800 exit:
1801 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1802 return ret;
1803 }
1804
rtw_set_auth(struct adapter * adapter,struct security_priv * psecuritypriv)1805 signed int rtw_set_auth(struct adapter *adapter, struct security_priv *psecuritypriv)
1806 {
1807 struct cmd_obj *pcmd;
1808 struct setauth_parm *psetauthparm;
1809 struct cmd_priv *pcmdpriv = &adapter->cmdpriv;
1810 signed int res = _SUCCESS;
1811
1812 pcmd = rtw_zmalloc(sizeof(struct cmd_obj));
1813 if (!pcmd) {
1814 res = _FAIL; /* try again */
1815 goto exit;
1816 }
1817
1818 psetauthparm = rtw_zmalloc(sizeof(struct setauth_parm));
1819 if (!psetauthparm) {
1820 kfree(pcmd);
1821 res = _FAIL;
1822 goto exit;
1823 }
1824
1825 psetauthparm->mode = (unsigned char)psecuritypriv->dot11AuthAlgrthm;
1826
1827 pcmd->cmdcode = _SetAuth_CMD_;
1828 pcmd->parmbuf = (unsigned char *)psetauthparm;
1829 pcmd->cmdsz = (sizeof(struct setauth_parm));
1830 pcmd->rsp = NULL;
1831 pcmd->rspsz = 0;
1832
1833 INIT_LIST_HEAD(&pcmd->list);
1834
1835 res = rtw_enqueue_cmd(pcmdpriv, pcmd);
1836
1837 exit:
1838 return res;
1839 }
1840
rtw_set_key(struct adapter * adapter,struct security_priv * psecuritypriv,signed int keyid,u8 set_tx,bool enqueue)1841 signed int rtw_set_key(struct adapter *adapter, struct security_priv *psecuritypriv, signed int keyid, u8 set_tx, bool enqueue)
1842 {
1843 u8 keylen;
1844 struct cmd_obj *pcmd;
1845 struct setkey_parm *psetkeyparm;
1846 struct cmd_priv *pcmdpriv = &adapter->cmdpriv;
1847 signed int res = _SUCCESS;
1848
1849 psetkeyparm = rtw_zmalloc(sizeof(struct setkey_parm));
1850 if (!psetkeyparm) {
1851 res = _FAIL;
1852 goto exit;
1853 }
1854
1855 if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X)
1856 psetkeyparm->algorithm = (unsigned char)psecuritypriv->dot118021XGrpPrivacy;
1857 else
1858 psetkeyparm->algorithm = (u8)psecuritypriv->dot11PrivacyAlgrthm;
1859
1860 psetkeyparm->keyid = (u8)keyid;/* 0~3 */
1861 psetkeyparm->set_tx = set_tx;
1862 if (is_wep_enc(psetkeyparm->algorithm))
1863 adapter->securitypriv.key_mask |= BIT(psetkeyparm->keyid);
1864
1865 switch (psetkeyparm->algorithm) {
1866
1867 case _WEP40_:
1868 keylen = 5;
1869 memcpy(&psetkeyparm->key[0], &psecuritypriv->dot11DefKey[keyid].skey[0], keylen);
1870 break;
1871 case _WEP104_:
1872 keylen = 13;
1873 memcpy(&psetkeyparm->key[0], &psecuritypriv->dot11DefKey[keyid].skey[0], keylen);
1874 break;
1875 case _TKIP_:
1876 keylen = 16;
1877 memcpy(&psetkeyparm->key, &psecuritypriv->dot118021XGrpKey[keyid], keylen);
1878 psetkeyparm->grpkey = 1;
1879 break;
1880 case _AES_:
1881 keylen = 16;
1882 memcpy(&psetkeyparm->key, &psecuritypriv->dot118021XGrpKey[keyid], keylen);
1883 psetkeyparm->grpkey = 1;
1884 break;
1885 default:
1886 res = _FAIL;
1887 kfree(psetkeyparm);
1888 goto exit;
1889 }
1890
1891 if (enqueue) {
1892 pcmd = rtw_zmalloc(sizeof(struct cmd_obj));
1893 if (!pcmd) {
1894 kfree(psetkeyparm);
1895 res = _FAIL; /* try again */
1896 goto exit;
1897 }
1898
1899 pcmd->cmdcode = _SetKey_CMD_;
1900 pcmd->parmbuf = (u8 *)psetkeyparm;
1901 pcmd->cmdsz = (sizeof(struct setkey_parm));
1902 pcmd->rsp = NULL;
1903 pcmd->rspsz = 0;
1904
1905 INIT_LIST_HEAD(&pcmd->list);
1906
1907 res = rtw_enqueue_cmd(pcmdpriv, pcmd);
1908 } else {
1909 setkey_hdl(adapter, (u8 *)psetkeyparm);
1910 kfree(psetkeyparm);
1911 }
1912 exit:
1913 return res;
1914 }
1915
1916 /* 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)1917 int rtw_restruct_wmm_ie(struct adapter *adapter, u8 *in_ie, u8 *out_ie, uint in_len, uint initial_out_len)
1918 {
1919 unsigned int ielength = 0;
1920 unsigned int i, j;
1921
1922 i = 12; /* after the fixed IE */
1923 while (i < in_len) {
1924 ielength = initial_out_len;
1925
1926 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 */
1927 for (j = i; j < i + 9; j++) {
1928 out_ie[ielength] = in_ie[j];
1929 ielength++;
1930 }
1931 out_ie[initial_out_len + 1] = 0x07;
1932 out_ie[initial_out_len + 6] = 0x00;
1933 out_ie[initial_out_len + 8] = 0x00;
1934
1935 break;
1936 }
1937
1938 i += (in_ie[i+1]+2); /* to the next IE element */
1939 }
1940
1941 return ielength;
1942
1943 }
1944
1945 /* */
1946 /* Ported from 8185: IsInPreAuthKeyList(). (Renamed from SecIsInPreAuthKeyList(), 2006-10-13.) */
1947 /* Added by Annie, 2006-05-07. */
1948 /* */
1949 /* Search by BSSID, */
1950 /* Return Value: */
1951 /* -1 :if there is no pre-auth key in the table */
1952 /* >= 0 :if there is pre-auth key, and return the entry id */
1953 /* */
1954 /* */
1955
SecIsInPMKIDList(struct adapter * Adapter,u8 * bssid)1956 static int SecIsInPMKIDList(struct adapter *Adapter, u8 *bssid)
1957 {
1958 struct security_priv *p = &Adapter->securitypriv;
1959 int i;
1960
1961 for (i = 0; i < NUM_PMKID_CACHE; i++)
1962 if ((p->PMKIDList[i].bUsed) &&
1963 (!memcmp(p->PMKIDList[i].Bssid, bssid, ETH_ALEN)))
1964 return i;
1965 return -1;
1966 }
1967
1968 /* */
1969 /* Check the RSN IE length */
1970 /* If the RSN IE length <= 20, the RSN IE didn't include the PMKID information */
1971 /* 0-11th element in the array are the fixed IE */
1972 /* 12th element in the array is the IE */
1973 /* 13th element in the array is the IE length */
1974 /* */
1975
rtw_append_pmkid(struct adapter * Adapter,int iEntry,u8 * ie,uint ie_len)1976 static int rtw_append_pmkid(struct adapter *Adapter, int iEntry, u8 *ie, uint ie_len)
1977 {
1978 struct security_priv *psecuritypriv = &Adapter->securitypriv;
1979
1980 if (ie[13] <= 20) {
1981 /* The RSN IE didn't include the PMK ID, append the PMK information */
1982 ie[ie_len] = 1;
1983 ie_len++;
1984 ie[ie_len] = 0; /* PMKID count = 0x0100 */
1985 ie_len++;
1986 memcpy(&ie[ie_len], &psecuritypriv->PMKIDList[iEntry].PMKID, 16);
1987 ie_len += 16;
1988 ie[13] += 18;/* PMKID length = 2+16 */
1989 }
1990 return ie_len;
1991 }
1992
rtw_restruct_sec_ie(struct adapter * adapter,u8 * in_ie,u8 * out_ie,uint in_len)1993 signed int rtw_restruct_sec_ie(struct adapter *adapter, u8 *in_ie, u8 *out_ie, uint in_len)
1994 {
1995 u8 authmode = 0x0;
1996 uint ielength;
1997 int iEntry;
1998
1999 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
2000 struct security_priv *psecuritypriv = &adapter->securitypriv;
2001 uint ndisauthmode = psecuritypriv->ndisauthtype;
2002
2003 /* copy fixed ie only */
2004 memcpy(out_ie, in_ie, 12);
2005 ielength = 12;
2006 if ((ndisauthmode == Ndis802_11AuthModeWPA) || (ndisauthmode == Ndis802_11AuthModeWPAPSK))
2007 authmode = WLAN_EID_VENDOR_SPECIFIC;
2008 if ((ndisauthmode == Ndis802_11AuthModeWPA2) || (ndisauthmode == Ndis802_11AuthModeWPA2PSK))
2009 authmode = WLAN_EID_RSN;
2010
2011 if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS)) {
2012 memcpy(out_ie+ielength, psecuritypriv->wps_ie, psecuritypriv->wps_ie_len);
2013
2014 ielength += psecuritypriv->wps_ie_len;
2015 } else if ((authmode == WLAN_EID_VENDOR_SPECIFIC) || (authmode == WLAN_EID_RSN)) {
2016 /* copy RSN or SSN */
2017 memcpy(&out_ie[ielength], &psecuritypriv->supplicant_ie[0], psecuritypriv->supplicant_ie[1]+2);
2018 ielength += psecuritypriv->supplicant_ie[1]+2;
2019 rtw_report_sec_ie(adapter, authmode, psecuritypriv->supplicant_ie);
2020 }
2021
2022 iEntry = SecIsInPMKIDList(adapter, pmlmepriv->assoc_bssid);
2023 if (iEntry < 0)
2024 return ielength;
2025
2026 if (authmode == WLAN_EID_RSN)
2027 ielength = rtw_append_pmkid(adapter, iEntry, out_ie, ielength);
2028
2029 return ielength;
2030 }
2031
rtw_init_registrypriv_dev_network(struct adapter * adapter)2032 void rtw_init_registrypriv_dev_network(struct adapter *adapter)
2033 {
2034 struct registry_priv *pregistrypriv = &adapter->registrypriv;
2035 struct eeprom_priv *peepriv = &adapter->eeprompriv;
2036 struct wlan_bssid_ex *pdev_network = &pregistrypriv->dev_network;
2037 u8 *myhwaddr = myid(peepriv);
2038
2039 memcpy(pdev_network->mac_address, myhwaddr, ETH_ALEN);
2040
2041 memcpy(&pdev_network->ssid, &pregistrypriv->ssid, sizeof(struct ndis_802_11_ssid));
2042
2043 pdev_network->configuration.length = sizeof(struct ndis_802_11_conf);
2044 pdev_network->configuration.beacon_period = 100;
2045 }
2046
rtw_update_registrypriv_dev_network(struct adapter * adapter)2047 void rtw_update_registrypriv_dev_network(struct adapter *adapter)
2048 {
2049 int sz = 0;
2050 struct registry_priv *pregistrypriv = &adapter->registrypriv;
2051 struct wlan_bssid_ex *pdev_network = &pregistrypriv->dev_network;
2052 struct security_priv *psecuritypriv = &adapter->securitypriv;
2053 struct wlan_network *cur_network = &adapter->mlmepriv.cur_network;
2054
2055 pdev_network->privacy = (psecuritypriv->dot11PrivacyAlgrthm > 0 ? 1 : 0) ; /* adhoc no 802.1x */
2056
2057 pdev_network->rssi = 0;
2058
2059 switch (pregistrypriv->wireless_mode) {
2060 case WIRELESS_11B:
2061 pdev_network->network_type_in_use = (Ndis802_11DS);
2062 break;
2063 case WIRELESS_11G:
2064 case WIRELESS_11BG:
2065 case WIRELESS_11_24N:
2066 case WIRELESS_11G_24N:
2067 case WIRELESS_11BG_24N:
2068 pdev_network->network_type_in_use = (Ndis802_11OFDM24);
2069 break;
2070 default:
2071 /* TODO */
2072 break;
2073 }
2074
2075 pdev_network->configuration.ds_config = (pregistrypriv->channel);
2076
2077 if (cur_network->network.infrastructure_mode == Ndis802_11IBSS)
2078 pdev_network->configuration.atim_window = (0);
2079
2080 pdev_network->infrastructure_mode = (cur_network->network.infrastructure_mode);
2081
2082 /* 1. Supported rates */
2083 /* 2. IE */
2084
2085 /* rtw_set_supported_rate(pdev_network->supported_rates, pregistrypriv->wireless_mode) ; will be called in rtw_generate_ie */
2086 sz = rtw_generate_ie(pregistrypriv);
2087
2088 pdev_network->ie_length = sz;
2089
2090 pdev_network->length = get_wlan_bssid_ex_sz((struct wlan_bssid_ex *)pdev_network);
2091
2092 /* notes: translate ie_length & length after assign the length to cmdsz in createbss_cmd(); */
2093 /* pdev_network->ie_length = cpu_to_le32(sz); */
2094 }
2095
2096 /* the function is at passive_level */
rtw_joinbss_reset(struct adapter * padapter)2097 void rtw_joinbss_reset(struct adapter *padapter)
2098 {
2099 u8 threshold;
2100 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2101
2102 struct ht_priv *phtpriv = &pmlmepriv->htpriv;
2103
2104 /* todo: if you want to do something io/reg/hw setting before join_bss, please add code here */
2105
2106 pmlmepriv->num_FortyMHzIntolerant = 0;
2107
2108 pmlmepriv->num_sta_no_ht = 0;
2109
2110 phtpriv->ampdu_enable = false;/* reset to disabled */
2111
2112 /* TH = 1 => means that invalidate usb rx aggregation */
2113 /* TH = 0 => means that validate usb rx aggregation, use init value. */
2114 if (phtpriv->ht_option) {
2115 if (padapter->registrypriv.wifi_spec == 1)
2116 threshold = 1;
2117 else
2118 threshold = 0;
2119 rtw_hal_set_hwreg(padapter, HW_VAR_RXDMA_AGG_PG_TH, (u8 *)(&threshold));
2120 } else {
2121 threshold = 1;
2122 rtw_hal_set_hwreg(padapter, HW_VAR_RXDMA_AGG_PG_TH, (u8 *)(&threshold));
2123 }
2124 }
2125
rtw_ht_use_default_setting(struct adapter * padapter)2126 void rtw_ht_use_default_setting(struct adapter *padapter)
2127 {
2128 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2129 struct ht_priv *phtpriv = &pmlmepriv->htpriv;
2130 struct registry_priv *pregistrypriv = &padapter->registrypriv;
2131 bool bHwLDPCSupport = false, bHwSTBCSupport = false;
2132 bool bHwSupportBeamformer = false, bHwSupportBeamformee = false;
2133
2134 if (pregistrypriv->wifi_spec)
2135 phtpriv->bss_coexist = 1;
2136 else
2137 phtpriv->bss_coexist = 0;
2138
2139 phtpriv->sgi_40m = TEST_FLAG(pregistrypriv->short_gi, BIT1) ? true : false;
2140 phtpriv->sgi_20m = TEST_FLAG(pregistrypriv->short_gi, BIT0) ? true : false;
2141
2142 /* LDPC support */
2143 rtw_hal_get_def_var(padapter, HAL_DEF_RX_LDPC, (u8 *)&bHwLDPCSupport);
2144 CLEAR_FLAGS(phtpriv->ldpc_cap);
2145 if (bHwLDPCSupport) {
2146 if (TEST_FLAG(pregistrypriv->ldpc_cap, BIT4))
2147 SET_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_RX);
2148 }
2149 rtw_hal_get_def_var(padapter, HAL_DEF_TX_LDPC, (u8 *)&bHwLDPCSupport);
2150 if (bHwLDPCSupport) {
2151 if (TEST_FLAG(pregistrypriv->ldpc_cap, BIT5))
2152 SET_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_TX);
2153 }
2154
2155 /* STBC */
2156 rtw_hal_get_def_var(padapter, HAL_DEF_TX_STBC, (u8 *)&bHwSTBCSupport);
2157 CLEAR_FLAGS(phtpriv->stbc_cap);
2158 if (bHwSTBCSupport) {
2159 if (TEST_FLAG(pregistrypriv->stbc_cap, BIT5))
2160 SET_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_TX);
2161 }
2162 rtw_hal_get_def_var(padapter, HAL_DEF_RX_STBC, (u8 *)&bHwSTBCSupport);
2163 if (bHwSTBCSupport) {
2164 if (TEST_FLAG(pregistrypriv->stbc_cap, BIT4))
2165 SET_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_RX);
2166 }
2167
2168 /* Beamforming setting */
2169 rtw_hal_get_def_var(padapter, HAL_DEF_EXPLICIT_BEAMFORMER, (u8 *)&bHwSupportBeamformer);
2170 rtw_hal_get_def_var(padapter, HAL_DEF_EXPLICIT_BEAMFORMEE, (u8 *)&bHwSupportBeamformee);
2171 CLEAR_FLAGS(phtpriv->beamform_cap);
2172 if (TEST_FLAG(pregistrypriv->beamform_cap, BIT4) && bHwSupportBeamformer)
2173 SET_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMER_ENABLE);
2174
2175 if (TEST_FLAG(pregistrypriv->beamform_cap, BIT5) && bHwSupportBeamformee)
2176 SET_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMEE_ENABLE);
2177 }
2178
rtw_build_wmm_ie_ht(struct adapter * padapter,u8 * out_ie,uint * pout_len)2179 void rtw_build_wmm_ie_ht(struct adapter *padapter, u8 *out_ie, uint *pout_len)
2180 {
2181 unsigned char WMM_IE[] = {0x00, 0x50, 0xf2, 0x02, 0x00, 0x01, 0x00};
2182 int out_len;
2183
2184 if (padapter->mlmepriv.qospriv.qos_option == 0) {
2185 out_len = *pout_len;
2186 rtw_set_ie(out_ie+out_len, WLAN_EID_VENDOR_SPECIFIC,
2187 _WMM_IE_Length_, WMM_IE, pout_len);
2188
2189 padapter->mlmepriv.qospriv.qos_option = 1;
2190 }
2191 }
2192
2193 /* 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)2194 unsigned int rtw_restructure_ht_ie(struct adapter *padapter, u8 *in_ie, u8 *out_ie, uint in_len, uint *pout_len, u8 channel)
2195 {
2196 u32 ielen, out_len;
2197 enum ieee80211_max_ampdu_length_exp max_rx_ampdu_factor;
2198 unsigned char *p;
2199 struct ieee80211_ht_cap ht_capie;
2200 u8 cbw40_enable = 0, stbc_rx_enable = 0, operation_bw = 0;
2201 struct registry_priv *pregistrypriv = &padapter->registrypriv;
2202 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2203 struct ht_priv *phtpriv = &pmlmepriv->htpriv;
2204 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2205
2206 phtpriv->ht_option = false;
2207
2208 out_len = *pout_len;
2209
2210 memset(&ht_capie, 0, sizeof(struct ieee80211_ht_cap));
2211
2212 ht_capie.cap_info = cpu_to_le16(IEEE80211_HT_CAP_DSSSCCK40);
2213
2214 if (phtpriv->sgi_20m)
2215 ht_capie.cap_info |= cpu_to_le16(IEEE80211_HT_CAP_SGI_20);
2216
2217 /* Get HT BW */
2218 if (!in_ie) {
2219 /* TDLS: TODO 20/40 issue */
2220 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) {
2221 operation_bw = padapter->mlmeextpriv.cur_bwmode;
2222 if (operation_bw > CHANNEL_WIDTH_40)
2223 operation_bw = CHANNEL_WIDTH_40;
2224 } else
2225 /* TDLS: TODO 40? */
2226 operation_bw = CHANNEL_WIDTH_40;
2227 } else {
2228 p = rtw_get_ie(in_ie, WLAN_EID_HT_OPERATION, &ielen, in_len);
2229 if (p && (ielen == sizeof(struct ieee80211_ht_addt_info))) {
2230 struct HT_info_element *pht_info = (struct HT_info_element *)(p+2);
2231
2232 if (pht_info->infos[0] & BIT(2)) {
2233 switch (pht_info->infos[0] & 0x3) {
2234 case 1:
2235 case 3:
2236 operation_bw = CHANNEL_WIDTH_40;
2237 break;
2238 default:
2239 operation_bw = CHANNEL_WIDTH_20;
2240 break;
2241 }
2242 } else {
2243 operation_bw = CHANNEL_WIDTH_20;
2244 }
2245 }
2246 }
2247
2248 /* to disable 40M Hz support while gd_bw_40MHz_en = 0 */
2249 if ((pregistrypriv->bw_mode & 0x0f) > 0)
2250 cbw40_enable = 1;
2251
2252 if ((cbw40_enable == 1) && (operation_bw == CHANNEL_WIDTH_40)) {
2253 ht_capie.cap_info |= cpu_to_le16(IEEE80211_HT_CAP_SUP_WIDTH);
2254 if (phtpriv->sgi_40m)
2255 ht_capie.cap_info |= cpu_to_le16(IEEE80211_HT_CAP_SGI_40);
2256 }
2257
2258 if (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_TX))
2259 ht_capie.cap_info |= cpu_to_le16(IEEE80211_HT_CAP_TX_STBC);
2260
2261 /* todo: disable SM power save mode */
2262 ht_capie.cap_info |= cpu_to_le16(IEEE80211_HT_CAP_SM_PS);
2263
2264 if (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_RX)) {
2265 if ((channel <= 14 && pregistrypriv->rx_stbc == 0x1) || /* enable for 2.4GHz */
2266 (pregistrypriv->wifi_spec == 1))
2267 stbc_rx_enable = 1;
2268 }
2269
2270 /* fill default supported_mcs_set */
2271 memcpy(&ht_capie.mcs, pmlmeext->default_supported_mcs_set, 16);
2272
2273 /* update default supported_mcs_set */
2274 if (stbc_rx_enable)
2275 ht_capie.cap_info |= cpu_to_le16(IEEE80211_HT_CAP_RX_STBC_1R);/* RX STBC One spatial stream */
2276
2277 set_mcs_rate_by_mask(ht_capie.mcs.rx_mask, MCS_RATE_1R);
2278
2279 {
2280 u32 rx_packet_offset, max_recvbuf_sz;
2281
2282 rtw_hal_get_def_var(padapter, HAL_DEF_RX_PACKET_OFFSET, &rx_packet_offset);
2283 rtw_hal_get_def_var(padapter, HAL_DEF_MAX_RECVBUF_SZ, &max_recvbuf_sz);
2284 }
2285
2286 if (padapter->driver_rx_ampdu_factor != 0xFF)
2287 max_rx_ampdu_factor =
2288 (enum ieee80211_max_ampdu_length_exp)padapter->driver_rx_ampdu_factor;
2289 else
2290 rtw_hal_get_def_var(padapter, HW_VAR_MAX_RX_AMPDU_FACTOR,
2291 &max_rx_ampdu_factor);
2292
2293 ht_capie.ampdu_params_info = (max_rx_ampdu_factor&0x03);
2294
2295 if (padapter->securitypriv.dot11PrivacyAlgrthm == _AES_)
2296 ht_capie.ampdu_params_info |= (IEEE80211_HT_CAP_AMPDU_DENSITY&(0x07<<2));
2297 else
2298 ht_capie.ampdu_params_info |= (IEEE80211_HT_CAP_AMPDU_DENSITY&0x00);
2299
2300 rtw_set_ie(out_ie+out_len, WLAN_EID_HT_CAPABILITY,
2301 sizeof(struct ieee80211_ht_cap), (unsigned char *)&ht_capie, pout_len);
2302
2303 phtpriv->ht_option = true;
2304
2305 if (in_ie) {
2306 p = rtw_get_ie(in_ie, WLAN_EID_HT_OPERATION, &ielen, in_len);
2307 if (p && (ielen == sizeof(struct ieee80211_ht_addt_info))) {
2308 out_len = *pout_len;
2309 rtw_set_ie(out_ie+out_len, WLAN_EID_HT_OPERATION, ielen, p+2, pout_len);
2310 }
2311 }
2312
2313 return phtpriv->ht_option;
2314
2315 }
2316
2317 /* the function is > passive_level (in critical_section) */
rtw_update_ht_cap(struct adapter * padapter,u8 * pie,uint ie_len,u8 channel)2318 void rtw_update_ht_cap(struct adapter *padapter, u8 *pie, uint ie_len, u8 channel)
2319 {
2320 u8 *p, max_ampdu_sz;
2321 int len;
2322 struct ieee80211_ht_cap *pht_capie;
2323 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2324 struct ht_priv *phtpriv = &pmlmepriv->htpriv;
2325 struct registry_priv *pregistrypriv = &padapter->registrypriv;
2326 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2327 struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
2328 u8 cbw40_enable = 0;
2329
2330 if (!phtpriv->ht_option)
2331 return;
2332
2333 if ((!pmlmeinfo->HT_info_enable) || (!pmlmeinfo->HT_caps_enable))
2334 return;
2335
2336 /* maybe needs check if ap supports rx ampdu. */
2337 if (!(phtpriv->ampdu_enable) && pregistrypriv->ampdu_enable == 1)
2338 phtpriv->ampdu_enable = true;
2339
2340 /* check Max Rx A-MPDU Size */
2341 len = 0;
2342 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));
2343 if (p && len > 0) {
2344 pht_capie = (struct ieee80211_ht_cap *)(p+2);
2345 max_ampdu_sz = (pht_capie->ampdu_params_info & IEEE80211_HT_CAP_AMPDU_FACTOR);
2346 max_ampdu_sz = 1 << (max_ampdu_sz+3); /* max_ampdu_sz (kbytes); */
2347
2348 phtpriv->rx_ampdu_maxlen = max_ampdu_sz;
2349
2350 }
2351
2352 len = 0;
2353 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));
2354 if (p && len > 0) {
2355 /* todo: */
2356 }
2357
2358 if ((pregistrypriv->bw_mode & 0x0f) > 0)
2359 cbw40_enable = 1;
2360
2361 /* update cur_bwmode & cur_ch_offset */
2362 if ((cbw40_enable) &&
2363 (le16_to_cpu(pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info) &
2364 BIT(1)) && (pmlmeinfo->HT_info.infos[0] & BIT(2))) {
2365 int i;
2366
2367 /* update the MCS set */
2368 for (i = 0; i < 16; i++)
2369 pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate[i] &= pmlmeext->default_supported_mcs_set[i];
2370
2371 /* update the MCS rates */
2372 set_mcs_rate_by_mask(pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate, MCS_RATE_1R);
2373
2374 /* switch to the 40M Hz mode according to the AP */
2375 /* pmlmeext->cur_bwmode = CHANNEL_WIDTH_40; */
2376 switch ((pmlmeinfo->HT_info.infos[0] & 0x3)) {
2377 case EXTCHNL_OFFSET_UPPER:
2378 pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_LOWER;
2379 break;
2380
2381 case EXTCHNL_OFFSET_LOWER:
2382 pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_UPPER;
2383 break;
2384
2385 default:
2386 pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
2387 break;
2388 }
2389 }
2390
2391 /* */
2392 /* Config SM Power Save setting */
2393 /* */
2394 pmlmeinfo->SM_PS =
2395 (le16_to_cpu(pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info) &
2396 0x0C) >> 2;
2397
2398 /* */
2399 /* Config current HT Protection mode. */
2400 /* */
2401 pmlmeinfo->HT_protection = pmlmeinfo->HT_info.infos[1] & 0x3;
2402 }
2403
rtw_issue_addbareq_cmd(struct adapter * padapter,struct xmit_frame * pxmitframe)2404 void rtw_issue_addbareq_cmd(struct adapter *padapter, struct xmit_frame *pxmitframe)
2405 {
2406 u8 issued;
2407 int priority;
2408 struct sta_info *psta;
2409 struct ht_priv *phtpriv;
2410 struct pkt_attrib *pattrib = &pxmitframe->attrib;
2411 s32 bmcst = is_multicast_ether_addr(pattrib->ra);
2412
2413 /* if (bmcst || (padapter->mlmepriv.LinkDetectInfo.bTxBusyTraffic == false)) */
2414 if (bmcst || (padapter->mlmepriv.LinkDetectInfo.NumTxOkInPeriod < 100))
2415 return;
2416
2417 priority = pattrib->priority;
2418
2419 psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
2420 if (pattrib->psta != psta)
2421 return;
2422
2423 if (!psta)
2424 return;
2425
2426 if (!(psta->state & _FW_LINKED))
2427 return;
2428
2429 phtpriv = &psta->htpriv;
2430
2431 if (phtpriv->ht_option && phtpriv->ampdu_enable) {
2432 issued = (phtpriv->agg_enable_bitmap>>priority)&0x1;
2433 issued |= (phtpriv->candidate_tid_bitmap>>priority)&0x1;
2434
2435 if (issued == 0) {
2436 psta->htpriv.candidate_tid_bitmap |= BIT((u8)priority);
2437 rtw_addbareq_cmd(padapter, (u8) priority, pattrib->ra);
2438 }
2439 }
2440
2441 }
2442
rtw_append_exented_cap(struct adapter * padapter,u8 * out_ie,uint * pout_len)2443 void rtw_append_exented_cap(struct adapter *padapter, u8 *out_ie, uint *pout_len)
2444 {
2445 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2446 struct ht_priv *phtpriv = &pmlmepriv->htpriv;
2447 u8 cap_content[8] = {0};
2448
2449 if (phtpriv->bss_coexist)
2450 SET_EXT_CAPABILITY_ELE_BSS_COEXIST(cap_content, 1);
2451
2452 rtw_set_ie(out_ie + *pout_len, WLAN_EID_EXT_CAPABILITY, 8, cap_content, pout_len);
2453 }
2454
rtw_set_to_roam(struct adapter * adapter,u8 to_roam)2455 inline void rtw_set_to_roam(struct adapter *adapter, u8 to_roam)
2456 {
2457 if (to_roam == 0)
2458 adapter->mlmepriv.to_join = false;
2459 adapter->mlmepriv.to_roam = to_roam;
2460 }
2461
rtw_dec_to_roam(struct adapter * adapter)2462 inline u8 rtw_dec_to_roam(struct adapter *adapter)
2463 {
2464 adapter->mlmepriv.to_roam--;
2465 return adapter->mlmepriv.to_roam;
2466 }
2467
rtw_to_roam(struct adapter * adapter)2468 inline u8 rtw_to_roam(struct adapter *adapter)
2469 {
2470 return adapter->mlmepriv.to_roam;
2471 }
2472
rtw_roaming(struct adapter * padapter,struct wlan_network * tgt_network)2473 void rtw_roaming(struct adapter *padapter, struct wlan_network *tgt_network)
2474 {
2475 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2476
2477 spin_lock_bh(&pmlmepriv->lock);
2478 _rtw_roaming(padapter, tgt_network);
2479 spin_unlock_bh(&pmlmepriv->lock);
2480 }
_rtw_roaming(struct adapter * padapter,struct wlan_network * tgt_network)2481 void _rtw_roaming(struct adapter *padapter, struct wlan_network *tgt_network)
2482 {
2483 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2484 struct wlan_network *cur_network = &pmlmepriv->cur_network;
2485
2486 if (rtw_to_roam(padapter) > 0) {
2487 memcpy(&pmlmepriv->assoc_ssid, &cur_network->network.ssid, sizeof(struct ndis_802_11_ssid));
2488
2489 pmlmepriv->assoc_by_bssid = false;
2490
2491 while (rtw_do_join(padapter) != _SUCCESS) {
2492 rtw_dec_to_roam(padapter);
2493 if (rtw_to_roam(padapter) <= 0) {
2494 rtw_indicate_disconnect(padapter);
2495 break;
2496 }
2497 }
2498 }
2499 }
2500
rtw_linked_check(struct adapter * padapter)2501 signed int rtw_linked_check(struct adapter *padapter)
2502 {
2503 if ((check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) == true) ||
2504 (check_fwstate(&padapter->mlmepriv, WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE) == true)) {
2505 if (padapter->stapriv.asoc_sta_count > 2)
2506 return true;
2507 } else { /* Station mode */
2508 if (check_fwstate(&padapter->mlmepriv, _FW_LINKED) == true)
2509 return true;
2510 }
2511 return false;
2512 }
2513