1 /******************************************************************************
2 *
3 * Copyright(c) 2007 - 2021 Realtek Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 *****************************************************************************/
15 #define _RTW_MLME_C_
16 #include <drv_types.h>
17
18
19 extern u8 rtw_do_join(_adapter *padapter);
20
21
rtw_init_mlme_timer(_adapter * padapter)22 void rtw_init_mlme_timer(_adapter *padapter)
23 {
24 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
25
26 rtw_init_timer(&(pmlmepriv->assoc_timer), rtw_join_timeout_handler, padapter);
27 rtw_init_timer(&(pmlmepriv->scan_to_timer), rtw_scan_timeout_handler, padapter);
28
29 #ifdef CONFIG_SET_SCAN_DENY_TIMER
30 rtw_init_timer(&(pmlmepriv->set_scan_deny_timer), rtw_set_scan_deny_timer_hdl, padapter);
31 #endif
32
33 #ifdef RTK_DMP_PLATFORM
34 _init_workitem(&(pmlmepriv->Linkup_workitem), Linkup_workitem_callback, padapter);
35 _init_workitem(&(pmlmepriv->Linkdown_workitem), Linkdown_workitem_callback, padapter);
36 #endif
37 }
38
_rtw_init_mlme_priv(_adapter * padapter)39 sint _rtw_init_mlme_priv(_adapter *padapter)
40 {
41 sint i;
42 u8 *pbuf;
43 struct wlan_network *pnetwork;
44 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
45 struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
46 sint res = _SUCCESS;
47 #ifdef CONFIG_RTW_MULTI_AP
48 struct unassoc_sta_info *unassoc_sta;
49 #endif
50
51
52 /* We don't need to memset padapter->XXX to zero, because adapter is allocated by rtw_zvmalloc(). */
53 /* _rtw_memset((u8 *)pmlmepriv, 0, sizeof(struct mlme_priv)); */
54
55
56 /*qos_priv*/
57 /*pmlmepriv->qospriv.qos_option = pregistrypriv->wmm_enable;*/
58
59 /*ht_priv*/
60 #ifdef CONFIG_80211N_HT
61 pmlmepriv->htpriv.ampdu_enable = _FALSE;/*set to disabled*/
62 #endif
63
64 pmlmepriv->nic_hdl = (u8 *)padapter;
65
66 pmlmepriv->pscanned = NULL;
67 init_fwstate(pmlmepriv, WIFI_STATION_STATE);
68 pmlmepriv->cur_network.network.InfrastructureMode = Ndis802_11AutoUnknown;
69 pmlmepriv->scan_mode = RTW_PHL_SCAN_ACTIVE; /* 1: active, 0: pasive. Maybe someday we should rename this varable to "active_mode" (Jeff) */
70
71 _rtw_spinlock_init(&(pmlmepriv->lock));
72 _rtw_init_queue(&(pmlmepriv->free_bss_pool));
73 _rtw_init_queue(&(pmlmepriv->scanned_queue));
74
75 set_scanned_network_val(pmlmepriv, 0);
76
77 _rtw_memset(&pmlmepriv->assoc_ssid, 0, sizeof(NDIS_802_11_SSID));
78
79 if (padapter->registrypriv.max_bss_cnt != 0)
80 pmlmepriv->max_bss_cnt = padapter->registrypriv.max_bss_cnt;
81 else if (rfctl->max_chan_nums <= MAX_CHANNEL_NUM_2G)
82 pmlmepriv->max_bss_cnt = MAX_BSS_CNT;
83 else
84 pmlmepriv->max_bss_cnt = MAX_BSS_CNT + MAX_BSS_CNT;
85
86
87 pbuf = rtw_zvmalloc(pmlmepriv->max_bss_cnt * (sizeof(struct wlan_network)));
88
89 if (pbuf == NULL) {
90 res = _FAIL;
91 goto exit;
92 }
93 pmlmepriv->free_bss_buf = pbuf;
94
95 pnetwork = (struct wlan_network *)pbuf;
96
97 for (i = 0; i < pmlmepriv->max_bss_cnt; i++) {
98 _rtw_init_listhead(&(pnetwork->list));
99
100 rtw_list_insert_tail(&(pnetwork->list), &(pmlmepriv->free_bss_pool.queue));
101
102 pnetwork++;
103 }
104
105 #ifdef CONFIG_RTW_MULTI_AP
106 if (is_primary_adapter(padapter)) {
107 _rtw_init_queue(&(pmlmepriv->free_unassoc_sta_queue));
108 _rtw_init_queue(&(pmlmepriv->unassoc_sta_queue));
109 for (i = 0; i < UNASOC_STA_SRC_NUM; i++)
110 pmlmepriv->unassoc_sta_mode_of_stype[i] = padapter->registrypriv.unassoc_sta_mode_of_stype[i];
111
112 if (padapter->registrypriv.max_unassoc_sta_cnt != 0)
113 pmlmepriv->max_unassoc_sta_cnt = padapter->registrypriv.max_unassoc_sta_cnt;
114 else if (rfctl->max_chan_nums <= MAX_CHANNEL_NUM_2G)
115 pmlmepriv->max_unassoc_sta_cnt = MAX_UNASSOC_STA_CNT;
116 else
117 pmlmepriv->max_unassoc_sta_cnt = MAX_UNASSOC_STA_CNT * 2;
118
119 pbuf = rtw_zvmalloc(pmlmepriv->max_unassoc_sta_cnt * (sizeof(struct unassoc_sta_info)));
120 if (pbuf == NULL) {
121 res = _FAIL;
122 goto exit;
123 }
124
125 pmlmepriv->free_unassoc_sta_buf = pbuf;
126 unassoc_sta = (struct unassoc_sta_info *) pbuf;
127 for (i = 0; i < pmlmepriv->max_unassoc_sta_cnt; i++) {
128 _rtw_init_listhead(&(unassoc_sta->list));
129 rtw_list_insert_tail(&(unassoc_sta->list), &(pmlmepriv->free_unassoc_sta_queue.queue));
130 unassoc_sta++;
131 }
132 }
133 #endif
134 /* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */
135
136 rtw_clear_scan_deny(padapter);
137 #ifdef CONFIG_ARP_KEEP_ALIVE
138 pmlmepriv->bGetGateway = 0;
139 pmlmepriv->GetGatewayTryCnt = 0;
140 #endif
141
142 #ifdef CONFIG_LAYER2_ROAMING
143 #define RTW_ROAM_SCAN_RESULT_EXP_MS (5*1000)
144 #define RTW_ROAM_RSSI_DIFF_TH 10
145 #define RTW_ROAM_SCAN_INTERVAL (5) /* 5*(2 second)*/
146 #define RTW_ROAM_RSSI_THRESHOLD 70
147
148 pmlmepriv->roam_flags = CONFIG_ROAMING_FLAG;
149
150 pmlmepriv->roam_scanr_exp_ms = RTW_ROAM_SCAN_RESULT_EXP_MS;
151 pmlmepriv->roam_rssi_diff_th = RTW_ROAM_RSSI_DIFF_TH;
152 pmlmepriv->roam_scan_int = RTW_ROAM_SCAN_INTERVAL;
153 pmlmepriv->roam_rssi_threshold = RTW_ROAM_RSSI_THRESHOLD;
154 pmlmepriv->need_to_roam = _FALSE;
155 pmlmepriv->last_roaming = rtw_get_current_time();
156 #endif /* CONFIG_LAYER2_ROAMING */
157
158 #ifdef CONFIG_RTW_80211R
159 rtw_ft_info_init(&pmlmepriv->ft_roam);
160 #endif
161
162 #ifdef CONFIG_RTW_MBO
163 #ifdef CONFIG_LAYER2_ROAMING
164 #if defined(CONFIG_RTW_WNM) || defined(CONFIG_RTW_80211K)
165 rtw_roam_nb_info_init(padapter);
166 pmlmepriv->ch_cnt = 0;
167 #endif
168 #endif
169 #endif
170
171 #ifdef CONFIG_RTW_MBO
172 rtw_mbo_attr_info_init(padapter);
173 #endif
174
175 pmlmepriv->defs_lmt_sta = 2;
176 pmlmepriv->defs_lmt_time = 5;
177
178 rtw_init_mlme_timer(padapter);
179
180 exit:
181
182
183 return res;
184 }
185
rtw_mfree_mlme_priv_lock(struct mlme_priv * pmlmepriv)186 void rtw_mfree_mlme_priv_lock(struct mlme_priv *pmlmepriv)
187 {
188 _rtw_spinlock_free(&pmlmepriv->lock);
189 _rtw_spinlock_free(&(pmlmepriv->free_bss_pool.lock));
190 _rtw_spinlock_free(&(pmlmepriv->scanned_queue.lock));
191 #ifdef CONFIG_RTW_MULTI_AP
192 if (is_primary_adapter(mlme_to_adapter(pmlmepriv))) {
193 _rtw_spinlock_free(&(pmlmepriv->unassoc_sta_queue.lock));
194 _rtw_spinlock_free(&(pmlmepriv->free_unassoc_sta_queue.lock));
195 }
196 #endif
197 }
198
rtw_free_mlme_ie_data(u8 ** ppie,u32 * plen)199 static void rtw_free_mlme_ie_data(u8 **ppie, u32 *plen)
200 {
201 if (*ppie) {
202 rtw_mfree(*ppie, *plen);
203 *plen = 0;
204 *ppie = NULL;
205 }
206 }
207
rtw_free_mlme_priv_ie_data(struct mlme_priv * pmlmepriv)208 void rtw_free_mlme_priv_ie_data(struct mlme_priv *pmlmepriv)
209 {
210 #ifdef CONFIG_80211D
211 rtw_buf_free(&pmlmepriv->recv_country_ie, &pmlmepriv->recv_country_ie_len);
212 #endif
213 #if defined(CONFIG_AP_MODE) && defined (CONFIG_NATIVEAP_MLME)
214 rtw_buf_free(&pmlmepriv->assoc_req, &pmlmepriv->assoc_req_len);
215 rtw_buf_free(&pmlmepriv->assoc_rsp, &pmlmepriv->assoc_rsp_len);
216 rtw_free_mlme_ie_data(&pmlmepriv->wps_beacon_ie, &pmlmepriv->wps_beacon_ie_len);
217 rtw_free_mlme_ie_data(&pmlmepriv->wps_probe_req_ie, &pmlmepriv->wps_probe_req_ie_len);
218 rtw_free_mlme_ie_data(&pmlmepriv->wps_probe_resp_ie, &pmlmepriv->wps_probe_resp_ie_len);
219 rtw_free_mlme_ie_data(&pmlmepriv->wps_assoc_resp_ie, &pmlmepriv->wps_assoc_resp_ie_len);
220
221 rtw_free_mlme_ie_data(&pmlmepriv->p2p_beacon_ie, &pmlmepriv->p2p_beacon_ie_len);
222 rtw_free_mlme_ie_data(&pmlmepriv->p2p_probe_req_ie, &pmlmepriv->p2p_probe_req_ie_len);
223 rtw_free_mlme_ie_data(&pmlmepriv->p2p_probe_resp_ie, &pmlmepriv->p2p_probe_resp_ie_len);
224 rtw_free_mlme_ie_data(&pmlmepriv->p2p_go_probe_resp_ie, &pmlmepriv->p2p_go_probe_resp_ie_len);
225 rtw_free_mlme_ie_data(&pmlmepriv->p2p_assoc_req_ie, &pmlmepriv->p2p_assoc_req_ie_len);
226 rtw_free_mlme_ie_data(&pmlmepriv->p2p_assoc_resp_ie, &pmlmepriv->p2p_assoc_resp_ie_len);
227 #endif
228
229 #if defined(CONFIG_WFD) && defined(CONFIG_IOCTL_CFG80211)
230 rtw_free_mlme_ie_data(&pmlmepriv->wfd_beacon_ie, &pmlmepriv->wfd_beacon_ie_len);
231 rtw_free_mlme_ie_data(&pmlmepriv->wfd_probe_req_ie, &pmlmepriv->wfd_probe_req_ie_len);
232 rtw_free_mlme_ie_data(&pmlmepriv->wfd_probe_resp_ie, &pmlmepriv->wfd_probe_resp_ie_len);
233 rtw_free_mlme_ie_data(&pmlmepriv->wfd_go_probe_resp_ie, &pmlmepriv->wfd_go_probe_resp_ie_len);
234 rtw_free_mlme_ie_data(&pmlmepriv->wfd_assoc_req_ie, &pmlmepriv->wfd_assoc_req_ie_len);
235 rtw_free_mlme_ie_data(&pmlmepriv->wfd_assoc_resp_ie, &pmlmepriv->wfd_assoc_resp_ie_len);
236 #endif
237
238 #ifdef CONFIG_RTW_80211R
239 rtw_free_mlme_ie_data(&pmlmepriv->auth_rsp, &pmlmepriv->auth_rsp_len);
240 #endif
241 #ifdef CONFIG_RTW_MBO
242 rtw_buf_free(&pmlmepriv->pcell_data_cap_ie, &pmlmepriv->cell_data_cap_len);
243 #endif
244 }
245
246 #if defined(CONFIG_WFD) && defined(CONFIG_IOCTL_CFG80211)
rtw_mlme_update_wfd_ie_data(struct mlme_priv * mlme,u8 type,u8 * ie,u32 ie_len)247 int rtw_mlme_update_wfd_ie_data(struct mlme_priv *mlme, u8 type, u8 *ie, u32 ie_len)
248 {
249 _adapter *adapter = mlme_to_adapter(mlme);
250 struct wifi_display_info *wfd_info = &adapter->wfd_info;
251 u8 clear = 0;
252 u8 **t_ie = NULL;
253 u32 *t_ie_len = NULL;
254 int ret = _FAIL;
255
256 if (!rtw_hw_chk_wl_func(adapter_to_dvobj(adapter), WL_FUNC_MIRACAST))
257 goto success;
258
259 if (wfd_info->wfd_enable == _TRUE)
260 goto success; /* WFD IE is build by self */
261
262 if (!ie && !ie_len)
263 clear = 1;
264 else if (!ie || !ie_len) {
265 RTW_PRINT(FUNC_ADPT_FMT" type:%u, ie:%p, ie_len:%u"
266 , FUNC_ADPT_ARG(adapter), type, ie, ie_len);
267 rtw_warn_on(1);
268 goto exit;
269 }
270
271 switch (type) {
272 case MLME_BEACON_IE:
273 t_ie = &mlme->wfd_beacon_ie;
274 t_ie_len = &mlme->wfd_beacon_ie_len;
275 break;
276 case MLME_PROBE_REQ_IE:
277 t_ie = &mlme->wfd_probe_req_ie;
278 t_ie_len = &mlme->wfd_probe_req_ie_len;
279 break;
280 case MLME_PROBE_RESP_IE:
281 t_ie = &mlme->wfd_probe_resp_ie;
282 t_ie_len = &mlme->wfd_probe_resp_ie_len;
283 break;
284 case MLME_GO_PROBE_RESP_IE:
285 t_ie = &mlme->wfd_go_probe_resp_ie;
286 t_ie_len = &mlme->wfd_go_probe_resp_ie_len;
287 break;
288 case MLME_ASSOC_REQ_IE:
289 t_ie = &mlme->wfd_assoc_req_ie;
290 t_ie_len = &mlme->wfd_assoc_req_ie_len;
291 break;
292 case MLME_ASSOC_RESP_IE:
293 t_ie = &mlme->wfd_assoc_resp_ie;
294 t_ie_len = &mlme->wfd_assoc_resp_ie_len;
295 break;
296 default:
297 RTW_PRINT(FUNC_ADPT_FMT" unsupported type:%u"
298 , FUNC_ADPT_ARG(adapter), type);
299 rtw_warn_on(1);
300 goto exit;
301 }
302
303 if (*t_ie) {
304 u32 free_len = *t_ie_len;
305 *t_ie_len = 0;
306 rtw_mfree(*t_ie, free_len);
307 *t_ie = NULL;
308 }
309
310 if (!clear) {
311 *t_ie = rtw_malloc(ie_len);
312 if (*t_ie == NULL) {
313 RTW_ERR(FUNC_ADPT_FMT" type:%u, rtw_malloc() fail\n"
314 , FUNC_ADPT_ARG(adapter), type);
315 goto exit;
316 }
317 _rtw_memcpy(*t_ie, ie, ie_len);
318 *t_ie_len = ie_len;
319 }
320
321 if (*t_ie && *t_ie_len) {
322 u8 *attr_content;
323 u32 attr_contentlen = 0;
324
325 attr_content = rtw_get_wfd_attr_content(*t_ie, *t_ie_len, WFD_ATTR_DEVICE_INFO, NULL, &attr_contentlen);
326 if (attr_content && attr_contentlen) {
327 if (RTW_GET_BE16(attr_content + 2) != wfd_info->rtsp_ctrlport) {
328 wfd_info->rtsp_ctrlport = RTW_GET_BE16(attr_content + 2);
329 RTW_INFO(FUNC_ADPT_FMT" type:%u, RTSP CTRL port = %u\n"
330 , FUNC_ADPT_ARG(adapter), type, wfd_info->rtsp_ctrlport);
331 }
332 }
333 }
334
335 success:
336 ret = _SUCCESS;
337
338 exit:
339 return ret;
340 }
341 #endif /* defined(CONFIG_WFD) && defined(CONFIG_IOCTL_CFG80211) */
342
_rtw_free_mlme_priv(struct mlme_priv * pmlmepriv)343 void _rtw_free_mlme_priv(struct mlme_priv *pmlmepriv)
344 {
345 _adapter *adapter = mlme_to_adapter(pmlmepriv);
346 if (NULL == pmlmepriv) {
347 rtw_warn_on(1);
348 goto exit;
349 }
350 rtw_free_mlme_priv_ie_data(pmlmepriv);
351
352 if (pmlmepriv) {
353 rtw_mfree_mlme_priv_lock(pmlmepriv);
354
355 if (pmlmepriv->free_bss_buf)
356 rtw_vmfree(pmlmepriv->free_bss_buf, pmlmepriv->max_bss_cnt * sizeof(struct wlan_network));
357
358 #ifdef CONFIG_RTW_MULTI_AP
359 if (is_primary_adapter(adapter)) {
360 if (pmlmepriv->free_unassoc_sta_buf)
361 rtw_vmfree(pmlmepriv->free_unassoc_sta_buf, pmlmepriv->max_unassoc_sta_cnt * sizeof(struct unassoc_sta_info));
362 }
363 #endif
364 }
365 exit:
366 return;
367 }
368
_rtw_enqueue_network(_queue * queue,struct wlan_network * pnetwork)369 sint _rtw_enqueue_network(_queue *queue, struct wlan_network *pnetwork)
370 {
371
372 if (pnetwork == NULL)
373 goto exit;
374
375 _rtw_spinlock_bh(&queue->lock);
376
377 rtw_list_insert_tail(&pnetwork->list, &queue->queue);
378
379 _rtw_spinunlock_bh(&queue->lock);
380
381 exit:
382
383
384 return _SUCCESS;
385 }
386
387 /*
388 struct wlan_network *_rtw_dequeue_network(_queue *queue)
389 {
390
391 struct wlan_network *pnetwork;
392
393
394 _rtw_spinlock_bh(&queue->lock);
395
396 if (_rtw_queue_empty(queue) == _TRUE)
397
398 pnetwork = NULL;
399
400 else
401 {
402 pnetwork = LIST_CONTAINOR(get_next(&queue->queue), struct wlan_network, list);
403
404 rtw_list_delete(&(pnetwork->list));
405 }
406
407 _rtw_spinunlock_bh(&queue->lock);
408
409
410 return pnetwork;
411 }
412 */
413
_rtw_alloc_network(struct mlme_priv * pmlmepriv)414 struct wlan_network *_rtw_alloc_network(struct mlme_priv *pmlmepriv) /* (_queue *free_queue) */
415 {
416 struct wlan_network *pnetwork;
417 _queue *free_queue = &pmlmepriv->free_bss_pool;
418 _list *plist = NULL;
419
420
421 _rtw_spinlock_bh(&free_queue->lock);
422
423 if (_rtw_queue_empty(free_queue) == _TRUE) {
424 pnetwork = NULL;
425 goto exit;
426 }
427 plist = get_next(&(free_queue->queue));
428
429 pnetwork = LIST_CONTAINOR(plist , struct wlan_network, list);
430
431 rtw_list_delete(&pnetwork->list);
432
433 pnetwork->network_type = 0;
434 pnetwork->fixed = _FALSE;
435 pnetwork->last_scanned = rtw_get_current_time();
436 pnetwork->last_non_hidden_ssid_ap = pnetwork->last_scanned;
437 #if defined(CONFIG_RTW_MESH) && CONFIG_RTW_MESH_ACNODE_PREVENT
438 pnetwork->acnode_stime = 0;
439 pnetwork->acnode_notify_etime = 0;
440 #endif
441
442 pnetwork->aid = 0;
443 pnetwork->join_res = 0;
444
445 pmlmepriv->num_of_scanned++;
446
447 exit:
448 _rtw_spinunlock_bh(&free_queue->lock);
449
450
451 return pnetwork;
452 }
453
_rtw_free_network(struct mlme_priv * pmlmepriv,struct wlan_network * pnetwork,u8 isfreeall)454 void _rtw_free_network(struct mlme_priv *pmlmepriv , struct wlan_network *pnetwork, u8 isfreeall)
455 {
456 u32 delta_time;
457 u32 lifetime = SCANQUEUE_LIFETIME;
458 _queue *free_queue = &(pmlmepriv->free_bss_pool);
459
460
461 if (pnetwork == NULL)
462 goto exit;
463
464 if (pnetwork->fixed == _TRUE)
465 goto exit;
466
467 if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == _TRUE) ||
468 (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == _TRUE))
469 lifetime = 1;
470
471 if (!isfreeall) {
472 delta_time = (u32) rtw_get_passing_time_ms(pnetwork->last_scanned);
473 if (delta_time < lifetime) /* unit:msec */
474 goto exit;
475 }
476
477 _rtw_spinlock_bh(&free_queue->lock);
478
479 rtw_list_delete(&(pnetwork->list));
480
481 rtw_list_insert_tail(&(pnetwork->list), &(free_queue->queue));
482
483 pmlmepriv->num_of_scanned--;
484
485
486 /* RTW_INFO("_rtw_free_network:SSID=%s\n", pnetwork->network.Ssid.Ssid); */
487
488 _rtw_spinunlock_bh(&free_queue->lock);
489
490 exit:
491 return;
492 }
493
_rtw_free_network_nolock(struct mlme_priv * pmlmepriv,struct wlan_network * pnetwork)494 void _rtw_free_network_nolock(struct mlme_priv *pmlmepriv, struct wlan_network *pnetwork)
495 {
496
497 _queue *free_queue = &(pmlmepriv->free_bss_pool);
498
499
500 if (pnetwork == NULL)
501 goto exit;
502
503 if (pnetwork->fixed == _TRUE)
504 goto exit;
505
506 /* _rtw_spinlock_irq(&free_queue->lock, &sp_flags); */
507
508 rtw_list_delete(&(pnetwork->list));
509
510 rtw_list_insert_tail(&(pnetwork->list), get_list_head(free_queue));
511
512 pmlmepriv->num_of_scanned--;
513
514 /* _rtw_spinunlock_irq(&free_queue->lock, &sp_flags); */
515
516 exit:
517 return;
518 }
519
_rtw_free_network_queue(_adapter * padapter,u8 isfreeall)520 void _rtw_free_network_queue(_adapter *padapter, u8 isfreeall)
521 {
522
523 _list *phead, *plist;
524 struct wlan_network *pnetwork;
525 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
526 _queue *scanned_queue = &pmlmepriv->scanned_queue;
527
528
529
530 _rtw_spinlock_bh(&scanned_queue->lock);
531
532 phead = get_list_head(scanned_queue);
533 plist = get_next(phead);
534
535 while (rtw_end_of_queue_search(phead, plist) == _FALSE) {
536
537 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
538
539 plist = get_next(plist);
540
541 _rtw_free_network(pmlmepriv, pnetwork, isfreeall);
542
543 }
544
545 _rtw_spinunlock_bh(&scanned_queue->lock);
546
547
548 }
549
550
551
552
rtw_if_up(_adapter * padapter)553 sint rtw_if_up(_adapter *padapter)
554 {
555
556 sint res;
557
558 if (RTW_CANNOT_RUN(adapter_to_dvobj(padapter)) ||
559 (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE) == _FALSE)) {
560 res = _FALSE;
561 } else
562 res = _TRUE;
563
564 return res;
565 }
566
567
rtw_generate_random_ibss(u8 * pibss)568 void rtw_generate_random_ibss(u8 *pibss)
569 {
570 *((u32 *)(&pibss[2])) = rtw_random32();
571 pibss[0] = 0x02; /* in ad-hoc mode local bit must set to 1 */
572 pibss[1] = 0x11;
573 pibss[2] = 0x87;
574 }
575
rtw_get_capability_from_ie(u8 * ie)576 u8 *rtw_get_capability_from_ie(u8 *ie)
577 {
578 return ie + 8 + 2;
579 }
580
581
rtw_get_capability(WLAN_BSSID_EX * bss)582 u16 rtw_get_capability(WLAN_BSSID_EX *bss)
583 {
584 u16 val;
585
586 _rtw_memcpy((u8 *)&val, rtw_get_capability_from_ie(bss->IEs), 2);
587
588 return le16_to_cpu(val);
589 }
590
rtw_get_timestampe_from_ie(u8 * ie)591 u8 *rtw_get_timestampe_from_ie(u8 *ie)
592 {
593 return ie + 0;
594 }
595
rtw_get_beacon_interval_from_ie(u8 * ie)596 u8 *rtw_get_beacon_interval_from_ie(u8 *ie)
597 {
598 return ie + 8;
599 }
600
601
rtw_init_mlme_priv(_adapter * padapter)602 int rtw_init_mlme_priv(_adapter *padapter) /* (struct mlme_priv *pmlmepriv) */
603 {
604 int res;
605 res = _rtw_init_mlme_priv(padapter);/* (pmlmepriv); */
606 return res;
607 }
608
rtw_free_mlme_priv(struct mlme_priv * pmlmepriv)609 void rtw_free_mlme_priv(struct mlme_priv *pmlmepriv)
610 {
611 _rtw_free_mlme_priv(pmlmepriv);
612 }
613
rtw_enqueue_network(_queue * queue,struct wlan_network * pnetwork)614 int rtw_enqueue_network(_queue *queue, struct wlan_network *pnetwork)
615 {
616 int res;
617 res = _rtw_enqueue_network(queue, pnetwork);
618 return res;
619 }
620
rtw_free_network(struct mlme_priv * pmlmepriv,struct wlan_network * pnetwork,u8 is_freeall)621 void rtw_free_network(struct mlme_priv *pmlmepriv, struct wlan_network *pnetwork, u8 is_freeall)/* (struct wlan_network *pnetwork, _queue *free_queue) */
622 {
623 _rtw_free_network(pmlmepriv, pnetwork, is_freeall);
624 }
625
rtw_free_network_nolock(_adapter * padapter,struct wlan_network * pnetwork)626 void rtw_free_network_nolock(_adapter *padapter, struct wlan_network *pnetwork)
627 {
628 _rtw_free_network_nolock(&(padapter->mlmepriv), pnetwork);
629 #ifdef CONFIG_IOCTL_CFG80211
630 rtw_cfg80211_unlink_bss(padapter, pnetwork);
631 #endif /* CONFIG_IOCTL_CFG80211 */
632 }
633
634
rtw_free_network_queue(_adapter * dev,u8 isfreeall)635 void rtw_free_network_queue(_adapter *dev, u8 isfreeall)
636 {
637 _rtw_free_network_queue(dev, isfreeall);
638 }
639
_rtw_find_network(_queue * scanned_queue,const u8 * addr)640 struct wlan_network *_rtw_find_network(_queue *scanned_queue, const u8 *addr)
641 {
642 _list *phead, *plist;
643 struct wlan_network *pnetwork = NULL;
644 u8 zero_addr[ETH_ALEN] = {0, 0, 0, 0, 0, 0};
645
646 if (_rtw_memcmp(zero_addr, addr, ETH_ALEN)) {
647 pnetwork = NULL;
648 goto exit;
649 }
650
651 phead = get_list_head(scanned_queue);
652 plist = get_next(phead);
653
654 while (plist != phead) {
655 pnetwork = LIST_CONTAINOR(plist, struct wlan_network , list);
656
657 if (_rtw_memcmp(addr, pnetwork->network.MacAddress, ETH_ALEN) == _TRUE)
658 break;
659
660 plist = get_next(plist);
661 }
662
663 if (plist == phead)
664 pnetwork = NULL;
665
666 exit:
667 return pnetwork;
668 }
669
rtw_find_network(_queue * scanned_queue,const u8 * addr)670 struct wlan_network *rtw_find_network(_queue *scanned_queue, const u8 *addr)
671 {
672 struct wlan_network *pnetwork;
673
674 _rtw_spinlock_bh(&scanned_queue->lock);
675 pnetwork = _rtw_find_network(scanned_queue, addr);
676 _rtw_spinunlock_bh(&scanned_queue->lock);
677
678 return pnetwork;
679 }
680
rtw_is_same_ibss(_adapter * adapter,struct wlan_network * pnetwork)681 int rtw_is_same_ibss(_adapter *adapter, struct wlan_network *pnetwork)
682 {
683 int ret = _TRUE;
684 struct security_priv *psecuritypriv = &adapter->securitypriv;
685
686 if ((psecuritypriv->dot11PrivacyAlgrthm != _NO_PRIVACY_) &&
687 (pnetwork->network.Privacy == 0))
688 ret = _FALSE;
689 else if ((psecuritypriv->dot11PrivacyAlgrthm == _NO_PRIVACY_) &&
690 (pnetwork->network.Privacy == 1))
691 ret = _FALSE;
692 else
693 ret = _TRUE;
694
695 return ret;
696
697 }
698
is_same_ess(WLAN_BSSID_EX * a,WLAN_BSSID_EX * b)699 inline int is_same_ess(WLAN_BSSID_EX *a, WLAN_BSSID_EX *b)
700 {
701 return (a->Ssid.SsidLength == b->Ssid.SsidLength)
702 && _rtw_memcmp(a->Ssid.Ssid, b->Ssid.Ssid, a->Ssid.SsidLength) == _TRUE;
703 }
704
is_same_network(WLAN_BSSID_EX * src,WLAN_BSSID_EX * dst)705 int is_same_network(WLAN_BSSID_EX *src, WLAN_BSSID_EX *dst)
706 {
707 u16 s_cap, d_cap;
708
709
710 _rtw_memcpy((u8 *)&s_cap, rtw_get_capability_from_ie(src->IEs), 2);
711 _rtw_memcpy((u8 *)&d_cap, rtw_get_capability_from_ie(dst->IEs), 2);
712
713
714 s_cap = le16_to_cpu(s_cap);
715 d_cap = le16_to_cpu(d_cap);
716
717 /* Wi-Fi driver doesn't consider the situation of BCN and ProbRsp sent from the same hidden AP,
718 * it considers these two packets are sent from different AP.
719 * Therefore, the scan queue may store two scan results of the same hidden AP, likes below.
720 *
721 * index bssid ch RSSI SdBm Noise age flag ssid
722 * 1 00:e0:4c:55:50:01 153 -73 -73 0 7044 [WPS][ESS] RTK5G
723 * 3 00:e0:4c:55:50:01 153 -73 -73 0 7044 [WPS][ESS]
724 *
725 * Original rules will compare Ssid, SsidLength, MacAddress, s_cap, d_cap at the same time.
726 * Wi-Fi driver will assume that the BCN and ProbRsp sent from the same hidden AP are the same network
727 * after we add an additional rule to compare SsidLength and Ssid.
728 * It means the scan queue will not store two scan results of the same hidden AP, it only store ProbRsp.
729 * For customer request.
730 */
731
732 if (((_rtw_memcmp(src->MacAddress, dst->MacAddress, ETH_ALEN)) == _TRUE) &&
733 ((s_cap & WLAN_CAPABILITY_IBSS) == (d_cap & WLAN_CAPABILITY_IBSS)) &&
734 ((s_cap & WLAN_CAPABILITY_BSS) == (d_cap & WLAN_CAPABILITY_BSS))) {
735 if ((src->Ssid.SsidLength == dst->Ssid.SsidLength) &&
736 (((_rtw_memcmp(src->Ssid.Ssid, dst->Ssid.Ssid, src->Ssid.SsidLength)) == _TRUE) || //Case of normal AP
737 (is_all_null(src->Ssid.Ssid, src->Ssid.SsidLength) == _TRUE || is_all_null(dst->Ssid.Ssid, dst->Ssid.SsidLength) == _TRUE))) //Case of hidden AP
738 return _TRUE;
739 else if ((src->Ssid.SsidLength == 0 || dst->Ssid.SsidLength == 0)) //Case of hidden AP
740 return _TRUE;
741 else
742 return _FALSE;
743 } else {
744 return _FALSE;
745 }
746 }
747
_rtw_find_same_network(_queue * scanned_queue,struct wlan_network * network)748 struct wlan_network *_rtw_find_same_network(_queue *scanned_queue, struct wlan_network *network)
749 {
750 _list *phead, *plist;
751 struct wlan_network *found = NULL;
752
753 phead = get_list_head(scanned_queue);
754 plist = get_next(phead);
755
756 while (plist != phead) {
757 found = LIST_CONTAINOR(plist, struct wlan_network , list);
758
759 if (is_same_network(&network->network, &found->network))
760 break;
761
762 plist = get_next(plist);
763 }
764
765 if (plist == phead)
766 found = NULL;
767
768 return found;
769 }
770
rtw_find_same_network(_queue * scanned_queue,struct wlan_network * network)771 struct wlan_network *rtw_find_same_network(_queue *scanned_queue, struct wlan_network *network)
772 {
773 struct wlan_network *found = NULL;
774
775 if (scanned_queue == NULL || network == NULL)
776 goto exit;
777
778 _rtw_spinlock_bh(&scanned_queue->lock);
779 found = _rtw_find_same_network(scanned_queue, network);
780 _rtw_spinunlock_bh(&scanned_queue->lock);
781
782 exit:
783 return found;
784 }
785
rtw_get_oldest_wlan_network(_queue * scanned_queue)786 struct wlan_network *rtw_get_oldest_wlan_network(_queue *scanned_queue)
787 {
788 _list *plist, *phead;
789
790
791 struct wlan_network *pwlan = NULL;
792 struct wlan_network *oldest = NULL;
793 phead = get_list_head(scanned_queue);
794
795 plist = get_next(phead);
796
797 while (1) {
798
799 if (rtw_end_of_queue_search(phead, plist) == _TRUE)
800 break;
801
802 pwlan = LIST_CONTAINOR(plist, struct wlan_network, list);
803
804 if (pwlan->fixed != _TRUE) {
805 if (oldest == NULL || rtw_time_after(oldest->last_scanned, pwlan->last_scanned))
806 oldest = pwlan;
807 }
808
809 plist = get_next(plist);
810 }
811 return oldest;
812
813 }
814
rtw_update_network(WLAN_BSSID_EX * dst,WLAN_BSSID_EX * src,_adapter * padapter,bool update_ie)815 void rtw_update_network(WLAN_BSSID_EX *dst, WLAN_BSSID_EX *src,
816 _adapter *padapter, bool update_ie)
817 {
818 #if defined(DBG_RX_SIGNAL_DISPLAY_SSID_MONITORED) && 1
819 u8 ss_ori = dst->PhyInfo.SignalStrength;
820 u8 sq_ori = dst->PhyInfo.SignalQuality;
821 u8 ss_smp = src->PhyInfo.SignalStrength;
822 s8 rssi_smp = src->PhyInfo.rssi;
823 #endif
824 s8 rssi_ori = dst->PhyInfo.rssi;
825
826 u8 sq_smp = src->PhyInfo.SignalQuality;
827 u8 ss_final;
828 u8 sq_final;
829 s8 rssi_final;
830
831
832 #ifdef CONFIG_ANTENNA_DIVERSITY
833 rtw_hal_antdiv_rssi_compared(padapter, dst, src); /* this will update src->PhyInfo.rssi, need consider again */
834 #endif
835
836 #if defined(DBG_RX_SIGNAL_DISPLAY_SSID_MONITORED) && 1
837 if (strcmp(dst->Ssid.Ssid, DBG_RX_SIGNAL_DISPLAY_SSID_MONITORED) == 0) {
838 RTW_INFO(FUNC_ADPT_FMT" %s("MAC_FMT", ch%u) ss_ori:%3u, sq_ori:%3u, rssi_ori:%d, ss_smp:%3u, sq_smp:%3u, rssi_smp:%d\n"
839 , FUNC_ADPT_ARG(padapter)
840 , src->Ssid.Ssid, MAC_ARG(src->MacAddress), src->Configuration.DSConfig
841 , ss_ori, sq_ori, rssi_ori
842 , ss_smp, sq_smp, rssi_smp
843 );
844 }
845 #endif
846
847 /* The rule below is 1/5 for sample value, 4/5 for history value */
848 if (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE) && is_same_network(&(padapter->mlmepriv.cur_network.network), src)) {
849 /* Take the recvpriv's value for the connected AP*/
850 ss_final = padapter->recvinfo.signal_strength;
851 sq_final = padapter->recvinfo.signal_qual;
852 /* the rssi value here is undecorated, and will be used for antenna diversity */
853 if (sq_smp != 101) /* from the right channel */
854 rssi_final = (src->PhyInfo.rssi + dst->PhyInfo.rssi * 4) / 5;
855 else
856 rssi_final = rssi_ori;
857 } else {
858 if (sq_smp != 101) { /* from the right channel */
859 ss_final = ((u32)(src->PhyInfo.SignalStrength) + (u32)(dst->PhyInfo.SignalStrength) * 4) / 5;
860 sq_final = ((u32)(src->PhyInfo.SignalQuality) + (u32)(dst->PhyInfo.SignalQuality) * 4) / 5;
861 rssi_final = (src->PhyInfo.rssi + dst->PhyInfo.rssi * 4) / 5;
862 } else {
863 /* bss info not receving from the right channel, use the original RX signal infos */
864 ss_final = dst->PhyInfo.SignalStrength;
865 sq_final = dst->PhyInfo.SignalQuality;
866 rssi_final = dst->PhyInfo.rssi;
867 }
868
869 }
870
871 if (update_ie) {
872 dst->Reserved[0] = src->Reserved[0];
873 dst->Reserved[1] = src->Reserved[1];
874 _rtw_memcpy((u8 *)dst, (u8 *)src, get_WLAN_BSSID_EX_sz(src));
875 }
876
877 dst->PhyInfo.SignalStrength = ss_final;
878 dst->PhyInfo.SignalQuality = sq_final;
879 dst->PhyInfo.rssi = rssi_final;
880
881 #if defined(DBG_RX_SIGNAL_DISPLAY_SSID_MONITORED) && 1
882 if (strcmp(dst->Ssid.Ssid, DBG_RX_SIGNAL_DISPLAY_SSID_MONITORED) == 0) {
883 RTW_INFO(FUNC_ADPT_FMT" %s("MAC_FMT"), SignalStrength:%u, SignalQuality:%u, RawRSSI:%d\n"
884 , FUNC_ADPT_ARG(padapter)
885 , dst->Ssid.Ssid, MAC_ARG(dst->MacAddress),
886 dst->PhyInfo.SignalStrength, dst->PhyInfo.SignalQuality, dst->PhyInfo.rssi);
887 }
888 #endif
889 }
890
891 #ifdef CONFIG_RTW_MULTI_AP
rtw_map_config_monitor_act_non(_adapter * adapter)892 void rtw_map_config_monitor_act_non(_adapter *adapter)
893 {
894 rtw_map_config_monitor(adapter, MLME_ACTION_NONE);
895 }
896
rtw_map_config_monitor(_adapter * adapter,u8 self_act)897 void rtw_map_config_monitor(_adapter *adapter, u8 self_act)
898 {
899 struct mi_state mstate, mstate_s;
900 void *phl = GET_PHL_INFO(adapter_to_dvobj(adapter));
901
902 rtw_mi_status_no_self(adapter, &mstate);
903 rtw_mi_status_no_others(adapter, &mstate_s);
904
905 switch (self_act) {
906 case MLME_AP_STARTED:
907 mstate_s.ap_num = 1;
908 break;
909 case MLME_AP_STOPPED:
910 mstate_s.ap_num = 0;
911 break;
912 case MLME_ACTION_NONE:
913 break;
914 default:
915 break;
916 }
917
918 rtw_mi_status_merge(&mstate, &mstate_s);
919 if (MSTATE_AP_NUM(&mstate) &&
920 rtw_unassoc_sta_src_chk(adapter, UNASOC_STA_SRC_RX_NMY_UC))
921 rtw_phl_enter_mon_mode(phl, adapter->phl_role);
922 else
923 rtw_phl_leave_mon_mode(phl, adapter->phl_role);
924 }
925
rtw_unassoc_sta_set_mode(_adapter * adapter,u8 stype,u8 mode)926 void rtw_unassoc_sta_set_mode(_adapter *adapter, u8 stype, u8 mode)
927 {
928 if (stype >= UNASOC_STA_SRC_NUM || mode >= UNASOC_STA_MODE_NUM)
929 return;
930
931 adapter = GET_PRIMARY_ADAPTER(adapter);
932 if (adapter->mlmepriv.unassoc_sta_mode_of_stype[stype] == mode)
933 return;
934
935 adapter->mlmepriv.unassoc_sta_mode_of_stype[stype] = mode;
936 rtw_run_in_thread_cmd_wait(adapter, ((void *)(rtw_map_config_monitor_act_non)), adapter, 2000);
937 }
938
rtw_unassoc_sta_src_chk(_adapter * adapter,u8 stype)939 bool rtw_unassoc_sta_src_chk(_adapter *adapter, u8 stype)
940 {
941 if (stype >= UNASOC_STA_SRC_NUM)
942 return 0;
943
944 adapter = GET_PRIMARY_ADAPTER(adapter);
945 return adapter->mlmepriv.unassoc_sta_mode_of_stype[stype] == UNASOC_STA_MODE_ALL
946 || (adapter->mlmepriv.unassoc_sta_mode_of_stype[stype] == UNASOC_STA_MODE_INTERESTED
947 && adapter->mlmepriv.interested_unassoc_sta_cnt);
948 }
949
950 const char *unasoc_sta_src_str[] = {
951 "BMC",
952 "NMY_UC",
953 };
954
955 const char *unasoc_sta_mode_str[] = {
956 "DISABLED",
957 "INTERESTED",
958 "ALL",
959 };
960
dump_unassoc_sta(void * sel,_adapter * adapter)961 void dump_unassoc_sta(void *sel, _adapter *adapter)
962 {
963 struct mlme_priv *mlmepriv;
964 _queue *queue;
965 _list *list, *head;
966 struct unassoc_sta_info **unassoc_sta_arr;
967 struct unassoc_sta_info *unassoc_sta;
968 u16 i, unassoc_sta_cnt = 0;
969
970 adapter = GET_PRIMARY_ADAPTER(adapter);
971 mlmepriv = &(adapter->mlmepriv);
972 queue = &(mlmepriv->unassoc_sta_queue);
973 for (i = 0; i < UNASOC_STA_SRC_NUM; i++) {
974 RTW_PRINT_SEL(sel, "[%u]%-6s:%u(%s)\n", i, unasoc_sta_src_str[i],
975 mlmepriv->unassoc_sta_mode_of_stype[i],
976 unasoc_sta_mode_str[mlmepriv->unassoc_sta_mode_of_stype[i]]);
977 }
978
979 RTW_PRINT_SEL(sel, "interested_unassoc_sta_cnt:%u\n",
980 mlmepriv->interested_unassoc_sta_cnt);
981
982 unassoc_sta_arr = rtw_zvmalloc(mlmepriv->max_unassoc_sta_cnt * sizeof(struct unassoc_sta_info *));
983 if (!unassoc_sta_arr)
984 return;
985
986 _rtw_spinlock_bh(&queue->lock);
987 head = get_list_head(queue);
988 list = get_next(head);
989 while (rtw_end_of_queue_search(head, list) == _FALSE) {
990 unassoc_sta = LIST_CONTAINOR(list, struct unassoc_sta_info, list);
991 list = get_next(list);
992 unassoc_sta_arr[unassoc_sta_cnt++] = unassoc_sta;
993 }
994
995 _rtw_spinunlock_bh(&queue->lock);
996 RTW_PRINT_SEL(sel, " %17s %18s %6s\n", "mac_addr", "measure_delta_time", "rssi");
997
998 for (i = 0; i < unassoc_sta_cnt; i++) {
999 u8 rcpi;
1000 s8 rx_power;
1001 u32 measure_delta_time;
1002
1003 unassoc_sta = unassoc_sta_arr[i];
1004 measure_delta_time = rtw_systime_to_ms(rtw_get_current_time() - unassoc_sta->time);
1005 RTW_PRINT_SEL(sel, "%c "MAC_FMT" %18u %6d\n"
1006 , unassoc_sta->interested ? '*' : ' '
1007 , MAC_ARG(unassoc_sta->addr), measure_delta_time,
1008 unassoc_sta->recv_signal_power);
1009 }
1010
1011 rtw_vmfree(unassoc_sta_arr, mlmepriv->max_unassoc_sta_cnt * sizeof(struct unassoc_sta_info *));
1012 }
1013
del_unassoc_sta(struct mlme_priv * mlmepriv,struct unassoc_sta_info * unassoc_sta)1014 static void del_unassoc_sta(struct mlme_priv *mlmepriv, struct unassoc_sta_info *unassoc_sta)
1015 {
1016 _queue *free_queue = &(mlmepriv->free_unassoc_sta_queue);
1017
1018 if (unassoc_sta->interested)
1019 mlmepriv->interested_unassoc_sta_cnt--;
1020
1021 if (mlmepriv->interested_unassoc_sta_cnt == 0) {
1022 rtw_run_in_thread_cmd(mlme_to_adapter(mlmepriv)
1023 , ((void *)(rtw_map_config_monitor_act_non)), mlme_to_adapter(mlmepriv));
1024 }
1025
1026 _rtw_spinlock_bh(&free_queue->lock);
1027 rtw_list_delete(&(unassoc_sta->list));
1028 rtw_list_insert_tail(&(unassoc_sta->list), &(free_queue->queue));
1029 _rtw_spinunlock_bh(&free_queue->lock);
1030 }
1031
del_unassoc_sta_chk(struct mlme_priv * mlmepriv,struct unassoc_sta_info * unassoc_sta)1032 static u8 del_unassoc_sta_chk(struct mlme_priv *mlmepriv, struct unassoc_sta_info *unassoc_sta)
1033 {
1034 systime cur, lifetime;
1035
1036 if (unassoc_sta == NULL)
1037 return UNASOC_STA_DEL_CHK_SKIP;
1038
1039 if (unassoc_sta->interested)
1040 return UNASOC_STA_DEL_CHK_SKIP;
1041
1042 cur = rtw_get_current_time();
1043 lifetime = unassoc_sta->time + rtw_ms_to_systime(UNASSOC_STA_LIFETIME_MS);
1044 if (rtw_time_before(cur, lifetime))
1045 return UNASOC_STA_DEL_CHK_ALIVE;
1046
1047 del_unassoc_sta(mlmepriv, unassoc_sta);
1048 return UNASOC_STA_DEL_CHK_DELETED;
1049 }
1050
alloc_unassoc_sta(struct mlme_priv * mlmepriv)1051 static struct unassoc_sta_info *alloc_unassoc_sta(struct mlme_priv *mlmepriv)
1052 {
1053 struct unassoc_sta_info *unassoc_sta;
1054 _queue *free_queue = &mlmepriv->free_unassoc_sta_queue;
1055 _list *list = NULL;
1056
1057 _rtw_spinlock_bh(&free_queue->lock);
1058 if (_rtw_queue_empty(free_queue) == _TRUE) {
1059 unassoc_sta = NULL;
1060 goto exit;
1061 }
1062
1063 list = get_next(&(free_queue->queue));
1064 unassoc_sta = LIST_CONTAINOR(list, struct unassoc_sta_info, list);
1065 rtw_list_delete(&unassoc_sta->list);
1066 _rtw_memset(unassoc_sta->addr, 0, ETH_ALEN);
1067 unassoc_sta->recv_signal_power = 0;
1068 unassoc_sta->time = 0;
1069 unassoc_sta->interested = 0;
1070 exit:
1071 _rtw_spinunlock_bh(&free_queue->lock);
1072 return unassoc_sta;
1073 }
1074
rtw_del_unassoc_sta_queue(_adapter * adapter)1075 void rtw_del_unassoc_sta_queue(_adapter *adapter)
1076 {
1077 struct unassoc_sta_info *unassoc_sta;
1078 struct mlme_priv *mlmepriv;
1079 _queue *queue;
1080 _list *head, *list;
1081
1082 adapter = GET_PRIMARY_ADAPTER(adapter);
1083 mlmepriv = &(adapter->mlmepriv);
1084 queue = &(mlmepriv->unassoc_sta_queue);
1085
1086 _rtw_spinlock_bh(&queue->lock);
1087 head = get_list_head(queue);
1088 list = get_next(head);
1089 while ((rtw_end_of_queue_search(head, list)) == _FALSE) {
1090 unassoc_sta = LIST_CONTAINOR(list , struct unassoc_sta_info, list);
1091 list = get_next(list);
1092 del_unassoc_sta(mlmepriv, unassoc_sta);
1093 }
1094
1095 _rtw_spinunlock_bh(&queue->lock);
1096 }
1097
rtw_del_unassoc_sta(_adapter * adapter,u8 * addr)1098 void rtw_del_unassoc_sta(_adapter *adapter, u8 *addr)
1099 {
1100 struct unassoc_sta_info *unassoc_sta;
1101 struct mlme_priv *mlmepriv;
1102 _queue *queue;
1103 _list *head, *list;
1104
1105 adapter = GET_PRIMARY_ADAPTER(adapter);
1106 mlmepriv = &(adapter->mlmepriv);
1107 queue = &(mlmepriv->unassoc_sta_queue);
1108
1109 _rtw_spinlock_bh(&queue->lock);
1110
1111 head = get_list_head(queue);
1112 list = get_next(head);
1113
1114 while ((rtw_end_of_queue_search(head, list)) == _FALSE) {
1115 unassoc_sta = LIST_CONTAINOR(list , struct unassoc_sta_info, list);
1116 list = get_next(list);
1117
1118 if (_rtw_memcmp(addr, unassoc_sta->addr, ETH_ALEN) == _TRUE) {
1119 del_unassoc_sta(mlmepriv, unassoc_sta);
1120 goto unlock_unassoc_sta_queue;
1121 }
1122 }
1123
1124 unlock_unassoc_sta_queue:
1125 _rtw_spinunlock_bh(&queue->lock);
1126 }
1127
rtw_rx_add_unassoc_sta(_adapter * adapter,u8 stype,u8 * addr,s8 recv_signal_power)1128 void rtw_rx_add_unassoc_sta(_adapter *adapter, u8 stype, u8 *addr, s8 recv_signal_power)
1129 {
1130 struct unassoc_sta_info *unassoc_sta;
1131 struct unassoc_sta_info *oldest_unassoc_sta = NULL;
1132 struct mlme_priv *mlmepriv;
1133 _queue *queue;
1134 _list *head, *list;
1135
1136 adapter = GET_PRIMARY_ADAPTER(adapter);
1137 mlmepriv = &(adapter->mlmepriv);
1138 queue = &(mlmepriv->unassoc_sta_queue);
1139
1140 _rtw_spinlock_bh(&queue->lock);
1141 head = get_list_head(queue);
1142 list = get_next(head);
1143 while ((rtw_end_of_queue_search(head, list)) == _FALSE) {
1144 unassoc_sta = LIST_CONTAINOR(list , struct unassoc_sta_info, list);
1145 list = get_next(list);
1146 if (_rtw_memcmp(addr, unassoc_sta->addr, ETH_ALEN) == _TRUE) {
1147 if (unassoc_sta->interested ||
1148 mlmepriv->unassoc_sta_mode_of_stype[stype] >=
1149 UNASOC_STA_MODE_ALL) {
1150 unassoc_sta->recv_signal_power = recv_signal_power;
1151 unassoc_sta->time = rtw_get_current_time();
1152 goto unlock_unassoc_sta_queue;
1153 }
1154 }
1155
1156 if (del_unassoc_sta_chk(mlmepriv, unassoc_sta) == UNASOC_STA_DEL_CHK_ALIVE) {
1157 if (oldest_unassoc_sta == NULL)
1158 oldest_unassoc_sta = unassoc_sta;
1159 else if (rtw_time_before(unassoc_sta->time, oldest_unassoc_sta->time))
1160 oldest_unassoc_sta = unassoc_sta;
1161 }
1162 }
1163
1164 if (mlmepriv->unassoc_sta_mode_of_stype[stype] <= UNASOC_STA_MODE_INTERESTED)
1165 goto unlock_unassoc_sta_queue;
1166
1167 unassoc_sta = alloc_unassoc_sta(mlmepriv);
1168 if (unassoc_sta == NULL) {
1169 if (oldest_unassoc_sta) {
1170 del_unassoc_sta(mlmepriv, oldest_unassoc_sta);
1171 unassoc_sta = alloc_unassoc_sta(mlmepriv);
1172 } else
1173 goto unlock_unassoc_sta_queue;
1174 }
1175
1176 _rtw_memcpy(unassoc_sta->addr, addr, ETH_ALEN);
1177 unassoc_sta->recv_signal_power = recv_signal_power;
1178 unassoc_sta->time = rtw_get_current_time();
1179 rtw_list_insert_tail(&(unassoc_sta->list), &(queue->queue));
1180
1181 unlock_unassoc_sta_queue:
1182 _rtw_spinunlock_bh(&queue->lock);
1183 }
1184
rtw_add_interested_unassoc_sta(_adapter * adapter,u8 * addr)1185 void rtw_add_interested_unassoc_sta(_adapter *adapter, u8 *addr)
1186 {
1187 struct unassoc_sta_info *unassoc_sta;
1188 struct unassoc_sta_info *oldest_unassoc_sta = NULL;
1189 struct mlme_priv *mlmepriv;
1190 _queue *queue;
1191 _list *head, *list;
1192
1193 adapter = GET_PRIMARY_ADAPTER(adapter);
1194 mlmepriv = &(adapter->mlmepriv);
1195 queue = &(mlmepriv->unassoc_sta_queue);
1196
1197 _rtw_spinlock_bh(&queue->lock);
1198
1199 head = get_list_head(queue);
1200 list = get_next(head);
1201
1202 while ((rtw_end_of_queue_search(head, list)) == _FALSE) {
1203 unassoc_sta = LIST_CONTAINOR(list , struct unassoc_sta_info, list);
1204 list = get_next(list);
1205
1206 if (_rtw_memcmp(addr, unassoc_sta->addr, ETH_ALEN) == _TRUE) {
1207 if (!unassoc_sta->interested) {
1208 unassoc_sta->interested = 1;
1209 mlmepriv->interested_unassoc_sta_cnt++;
1210 if (mlmepriv->interested_unassoc_sta_cnt == 1) {
1211 rtw_run_in_thread_cmd(mlme_to_adapter(mlmepriv)
1212 , ((void *)(rtw_map_config_monitor_act_non)), mlme_to_adapter(mlmepriv));
1213 }
1214 }
1215 goto unlock_unassoc_sta_queue;
1216 }
1217
1218 if (del_unassoc_sta_chk(mlmepriv, unassoc_sta) == UNASOC_STA_DEL_CHK_ALIVE) {
1219 if (oldest_unassoc_sta == NULL)
1220 oldest_unassoc_sta = unassoc_sta;
1221 else if (rtw_time_after(unassoc_sta->time, oldest_unassoc_sta->time))
1222 oldest_unassoc_sta = unassoc_sta;
1223 }
1224 }
1225 unassoc_sta = alloc_unassoc_sta(mlmepriv);
1226 if (unassoc_sta == NULL) {
1227 RTW_INFO(FUNC_ADPT_FMT": Allocate fail\n", FUNC_ADPT_ARG(adapter));
1228 if (oldest_unassoc_sta) {
1229 RTW_INFO(FUNC_ADPT_FMT": Delete oldest entry and try again.\n", FUNC_ADPT_ARG(adapter));
1230 del_unassoc_sta(mlmepriv, oldest_unassoc_sta);
1231 unassoc_sta = alloc_unassoc_sta(mlmepriv);
1232 } else
1233 goto unlock_unassoc_sta_queue;
1234 }
1235
1236 _rtw_memcpy(unassoc_sta->addr, addr, ETH_ALEN);
1237 unassoc_sta->interested = 1;
1238 unassoc_sta->recv_signal_power = 0;
1239 unassoc_sta->time = rtw_get_current_time() - rtw_ms_to_systime(UNASSOC_STA_LIFETIME_MS);
1240 rtw_list_insert_tail(&(unassoc_sta->list), &(queue->queue));
1241 mlmepriv->interested_unassoc_sta_cnt++;
1242 if (mlmepriv->interested_unassoc_sta_cnt == 1) {
1243 rtw_run_in_thread_cmd(mlme_to_adapter(mlmepriv)
1244 , ((void *)(rtw_map_config_monitor_act_non)), mlme_to_adapter(mlmepriv));
1245 }
1246
1247 unlock_unassoc_sta_queue:
1248 _rtw_spinunlock_bh(&queue->lock);
1249 }
1250
rtw_undo_interested_unassoc_sta(_adapter * adapter,u8 * addr)1251 void rtw_undo_interested_unassoc_sta(_adapter *adapter, u8 *addr)
1252 {
1253 struct unassoc_sta_info *unassoc_sta;
1254 struct mlme_priv *mlmepriv;
1255 _queue *queue;
1256 _list *head, *list;
1257
1258 adapter = GET_PRIMARY_ADAPTER(adapter);
1259 mlmepriv = &(adapter->mlmepriv);
1260 queue = &(mlmepriv->unassoc_sta_queue);
1261
1262 _rtw_spinlock_bh(&queue->lock);
1263 head = get_list_head(queue);
1264 list = get_next(head);
1265
1266 while ((rtw_end_of_queue_search(head, list)) == _FALSE) {
1267 unassoc_sta = LIST_CONTAINOR(list , struct unassoc_sta_info, list);
1268 list = get_next(list);
1269
1270 if (_rtw_memcmp(addr, unassoc_sta->addr, ETH_ALEN) == _TRUE) {
1271 if (unassoc_sta->interested) {
1272 unassoc_sta->interested = 0;
1273 mlmepriv->interested_unassoc_sta_cnt--;
1274 if (mlmepriv->interested_unassoc_sta_cnt == 0) {
1275 rtw_run_in_thread_cmd(mlme_to_adapter(mlmepriv)
1276 , ((void *)(rtw_map_config_monitor_act_non)), mlme_to_adapter(mlmepriv));
1277 }
1278 }
1279
1280 goto unlock_unassoc_sta_queue;
1281 }
1282 }
1283 unlock_unassoc_sta_queue:
1284 _rtw_spinunlock_bh(&queue->lock);
1285 }
1286
rtw_undo_all_interested_unassoc_sta(_adapter * adapter)1287 void rtw_undo_all_interested_unassoc_sta(_adapter *adapter)
1288 {
1289 struct unassoc_sta_info *unassoc_sta;
1290 struct mlme_priv *mlmepriv;
1291 _queue *queue;
1292 _list *head, *list;
1293
1294 adapter = GET_PRIMARY_ADAPTER(adapter);
1295 mlmepriv = &(adapter->mlmepriv);
1296 queue = &(mlmepriv->unassoc_sta_queue);
1297
1298 _rtw_spinlock_bh(&queue->lock);
1299 head = get_list_head(queue);
1300 list = get_next(head);
1301
1302 while ((rtw_end_of_queue_search(head, list)) == _FALSE) {
1303 unassoc_sta = LIST_CONTAINOR(list , struct unassoc_sta_info, list);
1304 list = get_next(list);
1305
1306 if (unassoc_sta->interested) {
1307 unassoc_sta->interested = 0;
1308 mlmepriv->interested_unassoc_sta_cnt--;
1309 if (mlmepriv->interested_unassoc_sta_cnt == 0) {
1310 rtw_run_in_thread_cmd(mlme_to_adapter(mlmepriv)
1311 , ((void *)(rtw_map_config_monitor_act_non)), mlme_to_adapter(mlmepriv));
1312 goto unlock_unassoc_sta_queue;
1313 }
1314 }
1315 }
1316 unlock_unassoc_sta_queue:
1317 _rtw_spinunlock_bh(&queue->lock);
1318 }
1319
1320 #endif /* CONFIG_RTW_MULTI_AP */
1321
1322 /* select the desired network based on the capability of the (i)bss.
1323 * check items: (1) security
1324 * (2) network_type
1325 * (3) WMM
1326 * (4) HT
1327 * (5) others */
rtw_is_desired_network(_adapter * adapter,struct wlan_network * pnetwork)1328 int rtw_is_desired_network(_adapter *adapter, struct wlan_network *pnetwork)
1329 {
1330 struct security_priv *psecuritypriv = &adapter->securitypriv;
1331 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1332 u32 desired_encmode;
1333 u32 privacy;
1334
1335 /* u8 wps_ie[512]; */
1336 uint wps_ielen;
1337
1338 int bselected = _TRUE;
1339
1340 desired_encmode = psecuritypriv->ndisencryptstatus;
1341 privacy = pnetwork->network.Privacy;
1342
1343 if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS)) {
1344 if (rtw_get_wps_ie(pnetwork->network.IEs + _FIXED_IE_LENGTH_, pnetwork->network.IELength - _FIXED_IE_LENGTH_, NULL, &wps_ielen) != NULL)
1345 return _TRUE;
1346 else
1347 return _FALSE;
1348 }
1349 if (adapter->registrypriv.wifi_spec == 1) { /* for correct flow of 8021X to do.... */
1350 u8 *p = NULL;
1351 uint ie_len = 0;
1352
1353 if ((desired_encmode == Ndis802_11EncryptionDisabled) && (privacy != 0))
1354 bselected = _FALSE;
1355
1356 if (psecuritypriv->ndisauthtype == Ndis802_11AuthModeWPA2PSK) {
1357 p = rtw_get_ie(pnetwork->network.IEs + _BEACON_IE_OFFSET_, _RSN_IE_2_, &ie_len, (pnetwork->network.IELength - _BEACON_IE_OFFSET_));
1358 if (p && ie_len > 0)
1359 bselected = _TRUE;
1360 else
1361 bselected = _FALSE;
1362 }
1363 }
1364
1365
1366 if ((desired_encmode != Ndis802_11EncryptionDisabled) && (privacy == 0)) {
1367 RTW_INFO("desired_encmode: %d, privacy: %d\n", desired_encmode, privacy);
1368 bselected = _FALSE;
1369 }
1370
1371 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == _TRUE) {
1372 if (pnetwork->network.InfrastructureMode != pmlmepriv->cur_network.network.InfrastructureMode)
1373 bselected = _FALSE;
1374 }
1375
1376 #ifdef CONFIG_RTW_MBO
1377 if (rtw_mbo_disallowed_network(pnetwork) == _TRUE)
1378 bselected = _FALSE;
1379 #endif
1380
1381 return bselected;
1382 }
1383
free_scanqueue(struct mlme_priv * pmlmepriv)1384 static void free_scanqueue(struct mlme_priv *pmlmepriv)
1385 {
1386 _queue *free_queue = &pmlmepriv->free_bss_pool;
1387 _queue *scan_queue = &pmlmepriv->scanned_queue;
1388 _list *plist, *phead, *ptemp;
1389
1390
1391 _rtw_spinlock_bh(&scan_queue->lock);
1392 _rtw_spinlock_bh(&free_queue->lock);
1393
1394 phead = get_list_head(scan_queue);
1395 plist = get_next(phead);
1396
1397 while (plist != phead) {
1398 ptemp = get_next(plist);
1399 rtw_list_delete(plist);
1400 rtw_list_insert_tail(plist, &free_queue->queue);
1401 plist = ptemp;
1402 pmlmepriv->num_of_scanned--;
1403 }
1404
1405 _rtw_spinunlock_bh(&free_queue->lock);
1406 _rtw_spinunlock_bh(&scan_queue->lock);
1407
1408 }
1409
rtw_reset_rx_info(_adapter * adapter)1410 void rtw_reset_rx_info(_adapter *adapter)
1411 {
1412 struct recv_info *precvinfo = &adapter->recvinfo;
1413
1414 precvinfo->dbg_rx_ampdu_drop_count = 0;
1415 precvinfo->dbg_rx_ampdu_forced_indicate_count = 0;
1416 precvinfo->dbg_rx_ampdu_loss_count = 0;
1417 precvinfo->dbg_rx_dup_mgt_frame_drop_count = 0;
1418 precvinfo->dbg_rx_ampdu_window_shift_cnt = 0;
1419 precvinfo->dbg_rx_drop_count = 0;
1420 precvinfo->dbg_rx_conflic_mac_addr_cnt = 0;
1421 }
1422
1423 /*
1424 * Note: There may be I/O in following functions:
1425 * rtw_free_stainfo()
1426 * rtw_init_self_stainfo()
1427 */
rtw_free_assoc_resources(_adapter * adapter,u8 lock_scanned_queue)1428 void rtw_free_assoc_resources(_adapter *adapter, u8 lock_scanned_queue)
1429 {
1430 struct wlan_network *pwlan = NULL;
1431 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1432 struct wlan_network *tgt_network = &pmlmepriv->cur_network;
1433
1434
1435 #ifdef CONFIG_TDLS
1436 struct tdls_info *ptdlsinfo = &adapter->tdlsinfo;
1437 #endif /* CONFIG_TDLS */
1438
1439
1440 RTW_INFO("%s-"ADPT_FMT" tgt_network MacAddress=" MAC_FMT" ssid=%s\n",
1441 __func__, ADPT_ARG(adapter), MAC_ARG(tgt_network->network.MacAddress), tgt_network->network.Ssid.Ssid);
1442
1443 if (MLME_IS_STA(adapter)) {
1444 struct sta_info *psta;
1445
1446 psta = rtw_get_stainfo(&adapter->stapriv, tgt_network->network.MacAddress);
1447 if (!psta) {
1448 RTW_WARN("[TODO]" FUNC_ADPT_FMT ": fail to find stainfo"
1449 "(" MAC_FMT ")\n",
1450 FUNC_ADPT_ARG(adapter),
1451 MAC_ARG(tgt_network->network.MacAddress));
1452 }
1453
1454 #ifdef CONFIG_TDLS
1455 rtw_free_all_tdls_sta(adapter, _TRUE);
1456 rtw_reset_tdls_info(adapter);
1457
1458 if (ptdlsinfo->link_established == _TRUE)
1459 rtw_tdls_cmd(adapter, NULL, TDLS_RS_RCR);
1460 #endif /* CONFIG_TDLS */
1461
1462 /* _rtw_spinlock_bh(&(pstapriv->sta_hash_lock)); */
1463 rtw_free_stainfo(adapter, psta);
1464 rtw_init_self_stainfo(adapter);
1465 /* _rtw_spinunlock_bh(&(pstapriv->sta_hash_lock)); */
1466
1467 }
1468
1469 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE | WIFI_ADHOC_MASTER_STATE)) {
1470 struct sta_info *psta;
1471
1472 rtw_free_all_stainfo(adapter);
1473 }
1474
1475 if (lock_scanned_queue)
1476 _rtw_spinlock_bh(&(pmlmepriv->scanned_queue.lock));
1477
1478 if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS) || (pmlmepriv->wpa_phase == _TRUE)){
1479 RTW_INFO("Dont free disconnecting network of scanned_queue due to uner %s %s phase\n\n",
1480 check_fwstate(pmlmepriv, WIFI_UNDER_WPS) ? "WPS" : "",
1481 (pmlmepriv->wpa_phase == _TRUE) ? "WPA" : "");
1482 } else {
1483 pwlan = _rtw_find_same_network(&pmlmepriv->scanned_queue, tgt_network);
1484 if (pwlan) {
1485 pwlan->fixed = _FALSE;
1486
1487 RTW_INFO("Free disconnecting network of scanned_queue\n");
1488 rtw_free_network_nolock(adapter, pwlan);
1489 #ifdef CONFIG_P2P
1490 if (rtw_p2p_chk_role(&adapter->wdinfo, P2P_ROLE_CLIENT) ||
1491 rtw_p2p_chk_role(&adapter->wdinfo, P2P_ROLE_GO)) {
1492 rtw_set_scan_deny(adapter, 2000);
1493 /* rtw_clear_scan_deny(adapter); */
1494 }
1495 #endif /* CONFIG_P2P */
1496 } else
1497 RTW_ERR("Free disconnecting network of scanned_queue failed due to pwlan == NULL\n\n");
1498 }
1499
1500 if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) && (adapter->stapriv.asoc_sta_count == 1))
1501 /*||MLME_IS_STA(adapter)*/) {
1502 if (pwlan)
1503 rtw_free_network_nolock(adapter, pwlan);
1504 }
1505
1506 if (lock_scanned_queue)
1507 _rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
1508
1509 adapter->securitypriv.key_mask = 0;
1510
1511 rtw_reset_rx_info(adapter);
1512
1513
1514 }
1515
1516 /*
1517 *rtw_indicate_connect: the caller has to lock pmlmepriv->lock
1518 */
rtw_indicate_connect(_adapter * padapter)1519 void rtw_indicate_connect(_adapter *padapter)
1520 {
1521 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1522
1523 pmlmepriv->to_join = _FALSE;
1524
1525 if (!check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE)) {
1526
1527 set_fwstate(pmlmepriv, WIFI_ASOC_STATE);
1528
1529 rtw_led_control(padapter, LED_CTL_LINK);
1530
1531 rtw_os_indicate_connect(padapter);
1532
1533 #ifdef CONFIG_RTW_WDS
1534 if (MLME_IS_STA(padapter))
1535 rtw_wds_gptr_tbl_init(padapter);
1536 #endif
1537 }
1538
1539 rtw_set_to_roam(padapter, 0);
1540 if (!MLME_IS_AP(padapter) && !MLME_IS_MESH(padapter))
1541 rtw_mi_set_scan_deny(padapter, 3000);
1542
1543
1544 }
1545
1546
1547 /*
1548 *rtw_indicate_disconnect: the caller has to lock pmlmepriv->lock
1549 */
rtw_indicate_disconnect(_adapter * padapter,u16 reason,u8 locally_generated)1550 void rtw_indicate_disconnect(_adapter *padapter, u16 reason, u8 locally_generated)
1551 {
1552 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1553 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
1554 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1555 WLAN_BSSID_EX *cur_network = &(pmlmeinfo->network);
1556 u8 *wps_ie = NULL;
1557 uint wpsie_len = 0;
1558
1559 if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS))
1560 pmlmepriv->wpa_phase = _TRUE;
1561
1562 _clr_fwstate_(pmlmepriv, WIFI_UNDER_LINKING | WIFI_UNDER_WPS | WIFI_OP_CH_SWITCHING | WIFI_UNDER_KEY_HANDSHAKE);
1563
1564 /* force to clear cur_network_scanned's SELECTED REGISTRAR */
1565 if (pmlmepriv->cur_network_scanned) {
1566 WLAN_BSSID_EX *current_joined_bss = &(pmlmepriv->cur_network_scanned->network);
1567
1568 if (current_joined_bss) {
1569 wps_ie = rtw_get_wps_ie(current_joined_bss->IEs + _FIXED_IE_LENGTH_,
1570 current_joined_bss->IELength - _FIXED_IE_LENGTH_, NULL, &wpsie_len);
1571 if (wps_ie && wpsie_len > 0) {
1572 u8 *attr = NULL;
1573 u32 attr_len;
1574 attr = rtw_get_wps_attr(wps_ie, wpsie_len, WPS_ATTR_SELECTED_REGISTRAR,
1575 NULL, &attr_len);
1576 if (attr)
1577 *(attr + 4) = 0;
1578 }
1579 }
1580 }
1581 /* RTW_INFO("clear wps when %s\n", __func__); */
1582
1583 if (rtw_to_roam(padapter) > 0)
1584 _clr_fwstate_(pmlmepriv, WIFI_ASOC_STATE);
1585
1586 #ifdef CONFIG_WAPI_SUPPORT
1587 if (MLME_IS_STA(padapter))
1588 rtw_wapi_return_one_sta_info(padapter, NULL);
1589 else if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) ||
1590 check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE))
1591 rtw_wapi_return_all_sta_info(padapter);
1592 #endif
1593
1594 if (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE)
1595 || (rtw_to_roam(padapter) <= 0)
1596 ) {
1597 #ifdef CONFIG_RTW_WDS
1598 adapter_set_use_wds(padapter, 0);
1599 rtw_wds_gptr_tbl_unregister(padapter);
1600 #endif
1601 #ifdef CONFIG_RTW_MULTI_AP
1602 padapter->multi_ap = 0;
1603 #endif
1604
1605 #ifdef CONFIG_RTW_TOKEN_BASED_XMIT
1606 if (ATOMIC_READ(&padapter->tbtx_tx_pause) == _TRUE) {
1607 ATOMIC_SET(&padapter->tbtx_tx_pause, _FALSE);
1608 rtw_tx_control_cmd(padapter);
1609 }
1610 #endif
1611 /* rtw_phl_chanctx_del(adapter_to_dvobj(padapter)->phl, padapter->phl_role, NULL); */
1612
1613 rtw_os_indicate_disconnect(padapter, reason, locally_generated);
1614
1615 /* set ips_deny_time to avoid enter IPS before LPS leave */
1616 rtw_set_ips_deny(padapter, 3000);
1617
1618 _clr_fwstate_(pmlmepriv, WIFI_ASOC_STATE);
1619
1620 rtw_led_control(padapter, LED_CTL_NO_LINK);
1621
1622 rtw_clear_scan_deny(padapter);
1623 }
1624
1625 #ifdef CONFIG_P2P_PS
1626 p2p_ps_wk_cmd(padapter, P2P_PS_DISABLE, 1);
1627 #endif /* CONFIG_P2P_PS */
1628
1629 #ifdef CONFIG_LPS
1630 rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_DISCONNECT, 0);
1631 #endif
1632 }
1633
rtw_indicate_scan_done(_adapter * padapter,bool aborted)1634 inline void rtw_indicate_scan_done(_adapter *padapter, bool aborted)
1635 {
1636 RTW_INFO(FUNC_ADPT_FMT" aborted=%d\n", FUNC_ADPT_ARG(padapter), aborted);
1637
1638 rtw_os_indicate_scan_done(padapter, aborted);
1639
1640 #ifdef CONFIG_IPS
1641 if (is_primary_adapter(padapter)
1642 && (_FALSE == adapter_to_pwrctl(padapter)->bInSuspend)
1643 && (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE | WIFI_UNDER_LINKING) == _FALSE)) {
1644 struct pwrctrl_priv *pwrpriv;
1645
1646 pwrpriv = adapter_to_pwrctl(padapter);
1647 rtw_set_ips_deny(padapter, 0);
1648 #ifdef CONFIG_IPS_CHECK_IN_WD
1649 #if 0 /*#ifdef CONFIG_CORE_DM_CHK_TIMER*/
1650 _set_timer(&adapter_to_dvobj(padapter)->dynamic_chk_timer, 1);
1651 #endif
1652 #else /* !CONFIG_IPS_CHECK_IN_WD */
1653 _rtw_set_pwr_state_check_timer(pwrpriv, 1);
1654 #endif /* !CONFIG_IPS_CHECK_IN_WD */
1655 }
1656 #endif /* CONFIG_IPS */
1657 }
1658
_rtw_wait_join_done(_adapter * adapter,u8 abort,u32 timeout_ms)1659 static u32 _rtw_wait_join_done(_adapter *adapter, u8 abort, u32 timeout_ms)
1660 {
1661 systime start;
1662 u32 pass_ms;
1663 struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
1664 struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
1665
1666 start = rtw_get_current_time();
1667
1668 pmlmeext->join_abort = abort;
1669 if (abort)
1670 set_link_timer(pmlmeext, 1);
1671
1672 while (rtw_get_passing_time_ms(start) <= timeout_ms
1673 && (check_fwstate(pmlmepriv, WIFI_UNDER_LINKING)
1674 #ifdef CONFIG_IOCTL_CFG80211
1675 || rtw_cfg80211_is_connect_requested(adapter)
1676 #endif
1677 )
1678 ) {
1679 if (RTW_CANNOT_RUN(adapter_to_dvobj(adapter)))
1680 break;
1681
1682 RTW_INFO(FUNC_ADPT_FMT" linking...\n", FUNC_ADPT_ARG(adapter));
1683 rtw_msleep_os(20);
1684 }
1685
1686 if (abort) {
1687 if (check_fwstate(pmlmepriv, WIFI_UNDER_LINKING)
1688 #ifdef CONFIG_IOCTL_CFG80211
1689 || rtw_cfg80211_is_connect_requested(adapter)
1690 #endif
1691 ) {
1692 if (!RTW_CANNOT_RUN(adapter_to_dvobj(adapter)))
1693 RTW_INFO(FUNC_ADPT_FMT" waiting for join_abort time out!\n", FUNC_ADPT_ARG(adapter));
1694 }
1695 }
1696
1697 pmlmeext->join_abort = 0;
1698 pass_ms = rtw_get_passing_time_ms(start);
1699
1700 return pass_ms;
1701 }
1702
rtw_join_abort_timeout(_adapter * adapter,u32 timeout_ms)1703 u32 rtw_join_abort_timeout(_adapter *adapter, u32 timeout_ms)
1704 {
1705 return _rtw_wait_join_done(adapter, _TRUE, timeout_ms);
1706 }
1707
rtw_joinbss_update_stainfo(_adapter * padapter,struct wlan_network * pnetwork)1708 static struct sta_info *rtw_joinbss_update_stainfo(_adapter *padapter, struct wlan_network *pnetwork)
1709 {
1710 int i;
1711 struct sta_info *psta = NULL;
1712 struct recv_reorder_ctrl *preorder_ctrl;
1713 struct sta_priv *pstapriv = &padapter->stapriv;
1714 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1715 #if defined(CONFIG_RTW_MULTI_AP) || defined(CONFIG_RTS_FULL_BW)
1716 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1717 #endif
1718 #ifdef CONFIG_RTS_FULL_BW
1719 struct wlan_network *cur_network = &(pmlmepriv->cur_network);
1720 #endif/*CONFIG_RTS_FULL_BW*/
1721
1722 psta = rtw_get_stainfo(pstapriv, pnetwork->network.MacAddress);
1723 if (psta == NULL) {
1724 RTW_ERR("%s: can not find "MAC_FMT"\n", __func__, MAC_ARG(pnetwork->network.MacAddress));
1725 psta = rtw_alloc_stainfo(pstapriv, pnetwork->network.MacAddress);
1726 }
1727
1728 if (psta) { /* update ptarget_sta */
1729 RTW_INFO("%s\n", __FUNCTION__);
1730
1731 /* assign aid */
1732 psta->phl_sta->aid = pnetwork->join_res;
1733
1734 update_sta_info(padapter, psta);
1735
1736 /* update station supportRate */
1737 psta->bssratelen = rtw_get_rateset_len(pnetwork->network.SupportedRates);
1738 _rtw_memcpy(psta->bssrateset, pnetwork->network.SupportedRates, psta->bssratelen);
1739 update_sta_ra_info(padapter, psta);
1740
1741 psta->phl_sta->wmode = pmlmeext->cur_wireless_mode;
1742
1743
1744 /* security related */
1745 #ifdef CONFIG_RTW_80211R
1746 if ((padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X)
1747 && (psta->ft_pairwise_key_installed == _FALSE))
1748 #else
1749 if (padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X)
1750 #endif
1751 {
1752 u8 *ie;
1753 sint ie_len;
1754 u8 mfp_opt = MFP_NO;
1755 u8 spp_opt = 0;
1756
1757 padapter->securitypriv.binstallGrpkey = _FALSE;
1758 padapter->securitypriv.busetkipkey = _FALSE;
1759 padapter->securitypriv.bgrpkey_handshake = _FALSE;
1760
1761 ie = rtw_get_ie(pnetwork->network.IEs + _BEACON_IE_OFFSET_, WLAN_EID_RSN
1762 , &ie_len, (pnetwork->network.IELength - _BEACON_IE_OFFSET_));
1763 if (ie && ie_len > 0
1764 && rtw_parse_wpa2_ie(ie, ie_len + 2, NULL, NULL, NULL, NULL, &mfp_opt, &spp_opt) == _SUCCESS
1765 ) {
1766 if (padapter->securitypriv.mfp_opt >= MFP_OPTIONAL && mfp_opt >= MFP_OPTIONAL)
1767 psta->flags |= WLAN_STA_MFP;
1768 }
1769 if (padapter->securitypriv.dot11PrivacyAlgrthm != _NO_PRIVACY_ ) {
1770 /*check if amsdu is allowed */
1771 if (rtw_check_amsdu_disable(padapter->registrypriv.amsdu_mode, spp_opt) == _TRUE)
1772 psta->flags |= WLAN_STA_AMSDU_DISABLE;
1773 }
1774 psta->ieee8021x_blocked = _TRUE;
1775 psta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm;
1776
1777 _rtw_memset((u8 *)&psta->dot118021x_UncstKey, 0, sizeof(union Keytype));
1778 _rtw_memset((u8 *)&psta->dot11tkiprxmickey, 0, sizeof(union Keytype));
1779 _rtw_memset((u8 *)&psta->dot11tkiptxmickey, 0, sizeof(union Keytype));
1780 }
1781
1782 /* Commented by Albert 2012/07/21 */
1783 /* When doing the WPS, the wps_ie_len won't equal to 0 */
1784 /* And the Wi-Fi driver shouldn't allow the data packet to be tramsmitted. */
1785 if (padapter->securitypriv.wps_ie_len != 0) {
1786 psta->ieee8021x_blocked = _TRUE;
1787 padapter->securitypriv.wps_ie_len = 0;
1788 }
1789
1790
1791 /* for A-MPDU Rx reordering buffer control for sta_info */
1792 /* if A-MPDU Rx is enabled, reseting rx_ordering_ctrl wstart_b(indicate_seq) to default value=0xffff */
1793 /* todo: check if AP can send A-MPDU packets */
1794 for (i = 0; i < 16 ; i++) {
1795 preorder_ctrl = &psta->recvreorder_ctrl[i];
1796 preorder_ctrl->enable = _FALSE;
1797 preorder_ctrl->indicate_seq = 0xffff;
1798 rtw_clear_bit(RTW_RECV_ACK_OR_TIMEOUT, &preorder_ctrl->rec_abba_rsp_ack);
1799 #ifdef DBG_RX_SEQ
1800 RTW_INFO("DBG_RX_SEQ "FUNC_ADPT_FMT" tid:%u SN_CLEAR indicate_seq:%u preorder_ctrl->rec_abba_rsp_ack:%lu\n"
1801 , FUNC_ADPT_ARG(padapter)
1802 , i
1803 , preorder_ctrl->indicate_seq
1804 ,preorder_ctrl->rec_abba_rsp_ack
1805 );
1806 #endif
1807 #ifdef CONFIG_RECV_REORDERING_CTRL
1808 preorder_ctrl->wsize_b = 64;/* max_ampdu_sz; */ /* ex. 32(kbytes) -> wsize_b=32 */
1809 #endif
1810 preorder_ctrl->ampdu_size = RX_AMPDU_SIZE_INVALID;
1811 }
1812
1813 #ifdef CONFIG_RTW_80211K
1814 _rtw_memcpy(&psta->rm_en_cap, pnetwork->network.PhyInfo.rm_en_cap, 5);
1815 #endif
1816 #ifdef CONFIG_RTW_MULTI_AP
1817 if (padapter->multi_ap & MULTI_AP_BACKHAUL_STA) {
1818 u8 multi_ap = rtw_get_multi_ap_ie_ext(pmlmepriv->assoc_rsp + sizeof(struct rtw_ieee80211_hdr_3addr) + 6
1819 , pmlmepriv->assoc_rsp_len - sizeof(struct rtw_ieee80211_hdr_3addr) - 6);
1820
1821 if (multi_ap & MULTI_AP_BACKHAUL_BSS) /* backhaul bss, enable WDS */
1822 psta->flags |= WLAN_STA_MULTI_AP | WLAN_STA_WDS;
1823 else if (multi_ap & MULTI_AP_FRONTHAUL_BSS) /* fronthaul bss only */
1824 psta->flags |= WLAN_STA_MULTI_AP;
1825 }
1826 #endif
1827 #ifdef CONFIG_RTS_FULL_BW
1828 rtw_parse_sta_vendor_ie_8812(padapter, psta, BSS_EX_TLV_IES(&cur_network->network), BSS_EX_TLV_IES_LEN(&cur_network->network));
1829 #endif
1830 }
1831 return psta;
1832
1833 }
1834
1835 /* pnetwork : returns from rtw_joinbss_event_callback
1836 * ptarget_wlan: found from scanned_queue */
rtw_joinbss_update_network(_adapter * padapter,struct wlan_network * ptarget_wlan,struct wlan_network * pnetwork)1837 static void rtw_joinbss_update_network(_adapter *padapter, struct wlan_network *ptarget_wlan, struct wlan_network *pnetwork)
1838 {
1839 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1840 struct security_priv *psecuritypriv = &padapter->securitypriv;
1841 struct wlan_network *cur_network = &(pmlmepriv->cur_network);
1842 sint tmp_fw_state = 0x0;
1843
1844 RTW_INFO("%s\n", __FUNCTION__);
1845
1846 /* why not use ptarget_wlan?? */
1847 _rtw_memcpy(&cur_network->network, &pnetwork->network, pnetwork->network.Length);
1848 /* some IEs in pnetwork is wrong, so we should use ptarget_wlan IEs */
1849 cur_network->network.IELength = ptarget_wlan->network.IELength;
1850 _rtw_memcpy(&cur_network->network.IEs[0], &ptarget_wlan->network.IEs[0], MAX_IE_SZ);
1851
1852 cur_network->aid = pnetwork->join_res;
1853 #ifdef CONFIG_SIGNAL_STAT_PROCESS
1854 rtw_set_signal_stat_timer(&padapter->recvinfo);
1855 #endif
1856
1857 /*RTW_WKARD_CORE_RSSI_V1 - GEORGIA MUST REFINE*/
1858 padapter->recvinfo.signal_strength = ptarget_wlan->network.PhyInfo.SignalStrength;
1859 padapter->recvinfo.signal_qual = ptarget_wlan->network.PhyInfo.SignalQuality;
1860 /* the ptarget_wlan->network.PhyInfo.rssi is raw data, we use ptarget_wlan->network.PhyInfo.SignalStrength instead (has scaled) */
1861 padapter->recvinfo.rssi = ptarget_wlan->network.PhyInfo.rssi;
1862 #if defined(DBG_RX_SIGNAL_DISPLAY_PROCESSING) && 1
1863 RTW_INFO(FUNC_ADPT_FMT" signal_strength:%3u, rssi:%3d, signal_qual:%3u"
1864 "\n"
1865 , FUNC_ADPT_ARG(padapter)
1866 , padapter->recvinfo.signal_strength
1867 , padapter->recvinfo.rssi
1868 , padapter->recvinfo.signal_qual
1869 );
1870 #endif
1871 #ifdef CONFIG_SIGNAL_STAT_PROCESS
1872 rtw_set_signal_stat_timer(&padapter->recvinfo);
1873 #endif
1874 /* update fw_state */ /* will clr WIFI_UNDER_LINKING here indirectly */
1875
1876 switch (pnetwork->network.InfrastructureMode) {
1877 case Ndis802_11Infrastructure:
1878 /* Check encryption */
1879 if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X)
1880 tmp_fw_state = tmp_fw_state | WIFI_UNDER_KEY_HANDSHAKE;
1881
1882 if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS))
1883 tmp_fw_state = tmp_fw_state | WIFI_UNDER_WPS;
1884
1885 init_fwstate(pmlmepriv, WIFI_STATION_STATE | tmp_fw_state);
1886
1887 break;
1888 case Ndis802_11IBSS:
1889 /*pmlmepriv->fw_state = WIFI_ADHOC_STATE;*/
1890 init_fwstate(pmlmepriv, WIFI_ADHOC_STATE);
1891 break;
1892 default:
1893 /*pmlmepriv->fw_state = WIFI_NULL_STATE;*/
1894 init_fwstate(pmlmepriv, WIFI_NULL_STATE);
1895 break;
1896 }
1897
1898 rtw_update_protection(padapter, (cur_network->network.IEs) + sizeof(NDIS_802_11_FIXED_IEs),
1899 (cur_network->network.IELength));
1900
1901 #ifdef CONFIG_80211N_HT
1902 rtw_update_ht_cap(padapter, cur_network->network.IEs, cur_network->network.IELength, (u8) cur_network->network.Configuration.DSConfig);
1903 #endif
1904 }
1905
1906 /* Notes: the fucntion could be > passive_level (the same context as Rx tasklet)
1907 * pnetwork : returns from rtw_joinbss_event_callback
1908 * ptarget_wlan: found from scanned_queue
1909 * if join_res > 0, for (fw_state==WIFI_STATION_STATE), we check if "ptarget_sta" & "ptarget_wlan" exist.
1910 * if join_res > 0, for (fw_state==WIFI_ADHOC_STATE), we only check if "ptarget_wlan" exist.
1911 * if join_res > 0, update "cur_network->network" from "pnetwork->network" if (ptarget_wlan !=NULL).
1912 */
1913 /* #define REJOIN */
rtw_joinbss_event_prehandle(_adapter * adapter,u8 * pbuf,u16 status)1914 void rtw_joinbss_event_prehandle(_adapter *adapter, u8 *pbuf, u16 status)
1915 {
1916 static u8 retry = 0;
1917 struct sta_info *ptarget_sta = NULL, *pcur_sta = NULL;
1918 struct sta_priv *pstapriv = &adapter->stapriv;
1919 struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
1920 struct wlan_network *pnetwork = (struct wlan_network *)pbuf;
1921 struct wlan_network *cur_network = &(pmlmepriv->cur_network);
1922 struct wlan_network *pcur_wlan = NULL, *ptarget_wlan = NULL;
1923 unsigned int the_same_macaddr = _FALSE;
1924
1925 rtw_get_encrypt_decrypt_from_registrypriv(adapter);
1926
1927 the_same_macaddr = _rtw_memcmp(pnetwork->network.MacAddress, cur_network->network.MacAddress, ETH_ALEN);
1928
1929 pnetwork->network.Length = get_WLAN_BSSID_EX_sz(&pnetwork->network);
1930 if (pnetwork->network.Length > sizeof(WLAN_BSSID_EX))
1931 goto exit;
1932
1933 _rtw_spinlock_bh(&pmlmepriv->lock);
1934
1935 pmlmepriv->LinkDetectInfo.TrafficTransitionCount = 0;
1936 pmlmepriv->LinkDetectInfo.LowPowerTransitionCount = 0;
1937
1938
1939 if (pnetwork->join_res > 0) {
1940 _rtw_spinlock_bh(&(pmlmepriv->scanned_queue.lock));
1941 retry = 0;
1942 if (check_fwstate(pmlmepriv, WIFI_UNDER_LINKING)) {
1943 /* s1. find ptarget_wlan */
1944 if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE)) {
1945 if (the_same_macaddr == _TRUE)
1946 ptarget_wlan = _rtw_find_network(&pmlmepriv->scanned_queue, cur_network->network.MacAddress);
1947 else {
1948 pcur_wlan = _rtw_find_network(&pmlmepriv->scanned_queue, cur_network->network.MacAddress);
1949 if (pcur_wlan)
1950 pcur_wlan->fixed = _FALSE;
1951
1952 pcur_sta = rtw_get_stainfo(pstapriv, cur_network->network.MacAddress);
1953 if (pcur_sta) {
1954 /* _rtw_spinlock_bh(&(pstapriv->sta_hash_lock)); */
1955 rtw_free_stainfo(adapter, pcur_sta);
1956 /* _rtw_spinunlock_bh(&(pstapriv->sta_hash_lock)); */
1957 }
1958
1959 ptarget_wlan = _rtw_find_network(&pmlmepriv->scanned_queue, pnetwork->network.MacAddress);
1960 if (MLME_IS_STA(adapter)) {
1961 if (ptarget_wlan)
1962 ptarget_wlan->fixed = _TRUE;
1963 }
1964 }
1965
1966 } else {
1967 ptarget_wlan = _rtw_find_same_network(&pmlmepriv->scanned_queue, pnetwork);
1968 if (MLME_IS_STA(adapter)) {
1969 if (ptarget_wlan)
1970 ptarget_wlan->fixed = _TRUE;
1971 }
1972 }
1973
1974 /* s2. update cur_network */
1975 if (ptarget_wlan)
1976 rtw_joinbss_update_network(adapter, ptarget_wlan, pnetwork);
1977 else {
1978 RTW_PRINT("Can't find ptarget_wlan when joinbss_event callback\n");
1979 _rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
1980 goto ignore_joinbss_callback;
1981 }
1982
1983
1984 /* s3. find ptarget_sta & update ptarget_sta after update cur_network only for station mode */
1985 if (MLME_IS_STA(adapter)) {
1986 ptarget_sta = rtw_joinbss_update_stainfo(adapter, pnetwork);
1987 if (ptarget_sta == NULL) {
1988 RTW_ERR("Can't update stainfo when joinbss_event callback\n");
1989 _rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
1990 goto ignore_joinbss_callback;
1991 }
1992
1993 /* Queue TX packets before FW/HW ready */
1994 /* clear in mlmeext_joinbss_event_callback() */
1995 rtw_xmit_queue_set(ptarget_sta);
1996 }
1997
1998 /* s4. indicate connect */
1999 if (MLME_IS_STA(adapter) || MLME_IS_ADHOC(adapter)) {
2000 pmlmepriv->cur_network_scanned = ptarget_wlan;
2001 rtw_indicate_connect(adapter);
2002 }
2003
2004 /* s5. Cancle assoc_timer */
2005 /*_cancel_timer_ex(&pmlmepriv->assoc_timer);*/
2006 cancel_assoc_timer(pmlmepriv);
2007
2008
2009 } else {
2010 _rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
2011 goto ignore_joinbss_callback;
2012 }
2013
2014 _rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
2015
2016 } else if (pnetwork->join_res == -4) {
2017 rtw_reset_securitypriv(adapter);
2018 pmlmepriv->join_status = status;
2019 /*_set_timer(&pmlmepriv->assoc_timer, 1);*/
2020 set_assoc_timer(pmlmepriv, 1);
2021
2022 /* rtw_free_assoc_resources(adapter, _TRUE); */
2023
2024 if ((check_fwstate(pmlmepriv, WIFI_UNDER_LINKING)) == _TRUE) {
2025 _clr_fwstate_(pmlmepriv, WIFI_UNDER_LINKING);
2026 }
2027
2028 } else { /* if join_res < 0 (join fails), then try again */
2029
2030 #ifdef REJOIN
2031 res = _FAIL;
2032 if (retry < 2) {
2033 res = rtw_select_and_join_from_scanned_queue(pmlmepriv);
2034 }
2035
2036 if (res == _SUCCESS) {
2037 /* extend time of assoc_timer */
2038 /*_set_timer(&pmlmepriv->assoc_timer, MAX_JOIN_TIMEOUT);*/
2039 set_assoc_timer(pmlmepriv, MAX_JOIN_TIMEOUT);
2040 retry++;
2041 } else if (res == 2) { /* there is no need to wait for join */
2042 _clr_fwstate_(pmlmepriv, WIFI_UNDER_LINKING);
2043 rtw_indicate_connect(adapter);
2044 } else {
2045 #endif
2046 pmlmepriv->join_status = status;
2047 /*_set_timer(&pmlmepriv->assoc_timer, 1);*/
2048 set_assoc_timer(pmlmepriv, 1);
2049 /* rtw_free_assoc_resources(adapter, _TRUE); */
2050 _clr_fwstate_(pmlmepriv, WIFI_UNDER_LINKING);
2051
2052 #ifdef REJOIN
2053 retry = 0;
2054 }
2055 #endif
2056 }
2057
2058 ignore_joinbss_callback:
2059 _rtw_spinunlock_bh(&pmlmepriv->lock);
2060
2061 exit:
2062 return;
2063 }
2064
rtw_joinbss_event_callback(_adapter * adapter,u8 * pbuf)2065 void rtw_joinbss_event_callback(_adapter *adapter, u8 *pbuf)
2066 {
2067 struct wlan_network *pnetwork = (struct wlan_network *)pbuf;
2068
2069
2070 rtw_set_hw_after_join(adapter, pnetwork->join_res);
2071 rtw_mi_os_xmit_schedule(adapter);
2072 }
2073
rtw_sta_media_status_rpt(_adapter * adapter,struct sta_info * sta,bool connected)2074 void rtw_sta_media_status_rpt(_adapter *adapter, struct sta_info *sta, bool connected)
2075 {
2076 /* ToDo H2C */
2077 #if 0
2078 struct macid_ctl_t *macid_ctl = &adapter->dvobj->macid_ctl;
2079 bool miracast_enabled = 0;
2080 bool miracast_sink = 0;
2081 u8 role = H2C_MSR_ROLE_RSVD;
2082
2083 if (sta == NULL) {
2084 RTW_PRINT(FUNC_ADPT_FMT" sta is NULL\n"
2085 , FUNC_ADPT_ARG(adapter));
2086 rtw_warn_on(1);
2087 return;
2088 }
2089
2090 if (sta->phl_sta->macid >= macid_ctl->num) {
2091 RTW_PRINT(FUNC_ADPT_FMT" invalid macid:%u\n"
2092 , FUNC_ADPT_ARG(adapter), sta->phl_sta->macid);
2093 rtw_warn_on(1);
2094 return;
2095 }
2096
2097 if (!rtw_macid_is_used(macid_ctl, sta->phl_sta->macid)) {
2098 RTW_PRINT(FUNC_ADPT_FMT" macid:%u not is used, set connected to 0\n"
2099 , FUNC_ADPT_ARG(adapter), sta->phl_sta->macid);
2100 connected = 0;
2101 rtw_warn_on(1);
2102 }
2103
2104 if (connected && !rtw_macid_is_bmc(macid_ctl, sta->phl_sta->macid)) {
2105 miracast_enabled = STA_OP_WFD_MODE(sta) != 0 && is_miracast_enabled(adapter);
2106 miracast_sink = miracast_enabled && (STA_OP_WFD_MODE(sta) & MIRACAST_SINK);
2107
2108 #ifdef CONFIG_TDLS
2109 if (sta->tdls_sta_state & TDLS_LINKED_STATE)
2110 role = H2C_MSR_ROLE_TDLS;
2111 else
2112 #endif
2113 if (MLME_IS_STA(adapter)) {
2114 if (MLME_IS_GC(adapter))
2115 role = H2C_MSR_ROLE_GO;
2116 else
2117 role = H2C_MSR_ROLE_AP;
2118 } else if (MLME_IS_AP(adapter)) {
2119 if (MLME_IS_GO(adapter))
2120 role = H2C_MSR_ROLE_GC;
2121 else
2122 role = H2C_MSR_ROLE_STA;
2123 } else if (MLME_IS_ADHOC(adapter) || MLME_IS_ADHOC_MASTER(adapter))
2124 role = H2C_MSR_ROLE_ADHOC;
2125 else if (MLME_IS_MESH(adapter))
2126 role = H2C_MSR_ROLE_MESH;
2127
2128 #ifdef CONFIG_WFD
2129 if (role == H2C_MSR_ROLE_GC
2130 || role == H2C_MSR_ROLE_GO
2131 || role == H2C_MSR_ROLE_TDLS
2132 ) {
2133 if (adapter->wfd_info.rtsp_ctrlport
2134 || adapter->wfd_info.tdls_rtsp_ctrlport
2135 || adapter->wfd_info.peer_rtsp_ctrlport)
2136 rtw_wfd_st_switch(sta, 1);
2137 }
2138 #endif
2139 }
2140
2141 rtw_hal_set_FwMediaStatusRpt_single_cmd(adapter
2142 , connected
2143 , miracast_enabled
2144 , miracast_sink
2145 , role
2146 , sta->phl_sta->macid
2147 );
2148 #endif
2149 }
2150
rtw_sta_media_status_rpt_cmd(_adapter * adapter,struct sta_info * sta,bool connected)2151 u8 rtw_sta_media_status_rpt_cmd(_adapter *adapter, struct sta_info *sta, bool connected)
2152 {
2153 struct cmd_priv *cmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
2154 struct cmd_obj *cmdobj;
2155 struct drvextra_cmd_parm *cmd_parm;
2156 struct sta_media_status_rpt_cmd_parm *rpt_parm;
2157 u8 res = _SUCCESS;
2158
2159 cmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
2160 if (cmdobj == NULL) {
2161 res = _FAIL;
2162 goto exit;
2163 }
2164 cmdobj->padapter = adapter;
2165
2166 cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
2167 if (cmd_parm == NULL) {
2168 rtw_mfree((u8 *)cmdobj, sizeof(struct cmd_obj));
2169 res = _FAIL;
2170 goto exit;
2171 }
2172
2173 rpt_parm = (struct sta_media_status_rpt_cmd_parm *)rtw_zmalloc(sizeof(struct sta_media_status_rpt_cmd_parm));
2174 if (rpt_parm == NULL) {
2175 rtw_mfree((u8 *)cmdobj, sizeof(struct cmd_obj));
2176 rtw_mfree((u8 *)cmd_parm, sizeof(struct drvextra_cmd_parm));
2177 res = _FAIL;
2178 goto exit;
2179 }
2180
2181 rpt_parm->sta = sta;
2182 rpt_parm->connected = connected;
2183
2184 cmd_parm->ec_id = STA_MSTATUS_RPT_WK_CID;
2185 cmd_parm->type = 0;
2186 cmd_parm->size = sizeof(struct sta_media_status_rpt_cmd_parm);
2187 cmd_parm->pbuf = (u8 *)rpt_parm;
2188 init_h2fwcmd_w_parm_no_rsp(cmdobj, cmd_parm, CMD_SET_DRV_EXTRA);
2189
2190 res = rtw_enqueue_cmd(cmdpriv, cmdobj);
2191
2192 exit:
2193 return res;
2194 }
2195
rtw_sta_media_status_rpt_cmd_hdl(_adapter * adapter,struct sta_media_status_rpt_cmd_parm * parm)2196 inline void rtw_sta_media_status_rpt_cmd_hdl(_adapter *adapter, struct sta_media_status_rpt_cmd_parm *parm)
2197 {
2198 rtw_sta_media_status_rpt(adapter, parm->sta, parm->connected);
2199 }
2200
rtw_stassoc_event_callback(_adapter * adapter,u8 * pbuf)2201 void rtw_stassoc_event_callback(_adapter *adapter, u8 *pbuf)
2202 {
2203 struct sta_info *psta;
2204 struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
2205 struct stassoc_event *pstassoc = (struct stassoc_event *)pbuf;
2206 struct wlan_network *cur_network = &(pmlmepriv->cur_network);
2207 struct wlan_network *ptarget_wlan = NULL;
2208
2209
2210 #if CONFIG_RTW_MACADDR_ACL
2211 if (rtw_access_ctrl(adapter, pstassoc->macaddr) == _FALSE)
2212 return;
2213 #endif
2214
2215 #if defined(CONFIG_AP_MODE) && defined (CONFIG_NATIVEAP_MLME)
2216 if (MLME_IS_AP(adapter) || MLME_IS_MESH(adapter)) {
2217 psta = rtw_get_stainfo(&adapter->stapriv, pstassoc->macaddr);
2218 if (psta) {
2219 u8 *passoc_req = NULL;
2220 u32 assoc_req_len = 0;
2221
2222 rtw_alloc_stainfo_hw(&adapter->stapriv, psta);
2223
2224 #if 0
2225 rtw_sta_media_status_rpt(adapter, psta, 1);
2226 #else
2227 rtw_hw_connected_apmode(adapter, psta);
2228 #endif
2229
2230 #ifndef CONFIG_AUTO_AP_MODE
2231 if (!MLME_IS_MESH(adapter)) {
2232 /* report to upper layer */
2233 RTW_INFO("indicate_sta_assoc_event to upper layer - hostapd\n");
2234 #ifdef CONFIG_IOCTL_CFG80211
2235 _rtw_spinlock_bh(&psta->lock);
2236 if (psta->passoc_req && psta->assoc_req_len > 0) {
2237 passoc_req = rtw_zmalloc(psta->assoc_req_len);
2238 if (passoc_req) {
2239 assoc_req_len = psta->assoc_req_len;
2240 _rtw_memcpy(passoc_req, psta->passoc_req, assoc_req_len);
2241 }
2242 }
2243 _rtw_spinunlock_bh(&psta->lock);
2244
2245 if (passoc_req && assoc_req_len > 0) {
2246 rtw_cfg80211_indicate_sta_assoc(adapter, passoc_req, assoc_req_len);
2247 rtw_mfree(passoc_req, assoc_req_len);
2248 }
2249 #else /* !CONFIG_IOCTL_CFG80211 */
2250 rtw_indicate_sta_assoc_event(adapter, psta);
2251 #endif /* !CONFIG_IOCTL_CFG80211 */
2252 }
2253 #endif /* !CONFIG_AUTO_AP_MODE */
2254
2255 if (is_wep_enc(adapter->securitypriv.dot11PrivacyAlgrthm))
2256 rtw_ap_wep_pk_setting(adapter, psta);
2257 }
2258 goto exit;
2259 }
2260 #endif /* defined (CONFIG_AP_MODE) && defined (CONFIG_NATIVEAP_MLME) */
2261
2262 /* for AD-HOC mode */
2263 psta = rtw_get_stainfo(&adapter->stapriv, pstassoc->macaddr);
2264 if (psta == NULL) {
2265 RTW_ERR(FUNC_ADPT_FMT" get no sta_info with "MAC_FMT"\n"
2266 , FUNC_ADPT_ARG(adapter), MAC_ARG(pstassoc->macaddr));
2267 rtw_warn_on(1);
2268 goto exit;
2269 }
2270
2271 rtw_sta_media_status_rpt(adapter, psta, 1);
2272
2273 if (adapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X)
2274 psta->dot118021XPrivacy = adapter->securitypriv.dot11PrivacyAlgrthm;
2275
2276
2277 psta->ieee8021x_blocked = _FALSE;
2278
2279 _rtw_spinlock_bh(&pmlmepriv->lock);
2280
2281 if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == _TRUE) ||
2282 (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == _TRUE)) {
2283 if (adapter->stapriv.asoc_sta_count == 2) {
2284 _rtw_spinlock_bh(&(pmlmepriv->scanned_queue.lock));
2285 ptarget_wlan = _rtw_find_network(&pmlmepriv->scanned_queue, cur_network->network.MacAddress);
2286 pmlmepriv->cur_network_scanned = ptarget_wlan;
2287 if (ptarget_wlan)
2288 ptarget_wlan->fixed = _TRUE;
2289 _rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
2290 /* a sta + bc/mc_stainfo (not Ibss_stainfo) */
2291 rtw_indicate_connect(adapter);
2292 }
2293 }
2294
2295 _rtw_spinunlock_bh(&pmlmepriv->lock);
2296
2297
2298 mlmeext_sta_add_event_callback(adapter, psta);
2299
2300 #ifdef CONFIG_RTL8711
2301 /* submit SetStaKey_cmd to tell fw, fw will allocate an CAM entry for this sta */
2302 rtw_setstakey_cmd(adapter, psta, GROUP_KEY, _TRUE);
2303 #endif
2304
2305 exit:
2306 #ifdef CONFIG_RTS_FULL_BW
2307 rtw_set_rts_bw(adapter);
2308 #endif/*CONFIG_RTS_FULL_BW*/
2309 return;
2310 }
2311
2312 #ifdef CONFIG_IEEE80211W
rtw_sta_timeout_event_callback(_adapter * adapter,u8 * pbuf)2313 void rtw_sta_timeout_event_callback(_adapter *adapter, u8 *pbuf)
2314 {
2315 struct sta_info *psta;
2316 struct stadel_event *pstadel = (struct stadel_event *)pbuf;
2317 struct sta_priv *pstapriv = &adapter->stapriv;
2318
2319
2320 psta = rtw_get_stainfo(&adapter->stapriv, pstadel->macaddr);
2321
2322 if (psta) {
2323 u8 updated = _FALSE;
2324
2325 _rtw_spinlock_bh(&pstapriv->asoc_list_lock);
2326 if (rtw_is_list_empty(&psta->asoc_list) == _FALSE) {
2327 rtw_list_delete(&psta->asoc_list);
2328 pstapriv->asoc_list_cnt--;
2329 #ifdef CONFIG_RTW_TOKEN_BASED_XMIT
2330 if (psta->tbtx_enable)
2331 pstapriv->tbtx_asoc_list_cnt--;
2332 #endif
2333 updated = ap_free_sta(adapter, psta, _TRUE, WLAN_REASON_PREV_AUTH_NOT_VALID, _TRUE, _FALSE);
2334 }
2335 _rtw_spinunlock_bh(&pstapriv->asoc_list_lock);
2336
2337 associated_clients_update(adapter, updated, STA_INFO_UPDATE_ALL);
2338 }
2339
2340
2341
2342 }
2343 #endif /* CONFIG_IEEE80211W */
2344
2345
2346 /* Note: the caller should already have lock of a->mlmepriv.lock */
2347 /* Note2: There may be I/O in rtw_free_assoc_resources() */
_stadel_posthandle_sta(struct _ADAPTER * a,struct stadel_event * stadel)2348 static void _stadel_posthandle_sta(struct _ADAPTER *a,
2349 struct stadel_event *stadel)
2350 {
2351 struct mlme_priv *mlme = &a->mlmepriv;
2352 u16 reason = *((unsigned short *)stadel->rsvd);
2353 bool roam = _FALSE;
2354 struct wlan_network *roam_target = NULL;
2355
2356
2357 #ifdef CONFIG_LAYER2_ROAMING
2358 #ifdef CONFIG_RTW_80211R
2359 if (rtw_ft_roam_expired(a, reason))
2360 mlme->ft_roam.ft_roam_on_expired = _TRUE;
2361 else
2362 mlme->ft_roam.ft_roam_on_expired = _FALSE;
2363 #endif
2364 if (a->registrypriv.wifi_spec == 1) {
2365 roam = _FALSE;
2366 } else if ((reason == WLAN_REASON_EXPIRATION_CHK)
2367 && rtw_chk_roam_flags(a, RTW_ROAM_ON_EXPIRED)) {
2368 roam = _TRUE;
2369 } else if ((reason == WLAN_REASON_ACTIVE_ROAM)
2370 && rtw_chk_roam_flags(a, RTW_ROAM_ACTIVE)) {
2371 roam = _TRUE;
2372 roam_target = mlme->roam_network;
2373 }
2374 #ifdef CONFIG_RTW_80211R
2375 if ((reason == WLAN_REASON_ACTIVE_ROAM)
2376 && rtw_ft_chk_flags(a, RTW_FT_BTM_ROAM)) {
2377 roam = _TRUE;
2378 roam_target = mlme->roam_network;
2379 }
2380 #endif
2381
2382 if (roam == _TRUE) {
2383 if (rtw_to_roam(a) > 0)
2384 rtw_dec_to_roam(a); /* this stadel_event is caused by roaming, decrease to_roam */
2385 else if (rtw_to_roam(a) == 0)
2386 rtw_set_to_roam(a, a->registrypriv.max_roaming_times);
2387 } else {
2388 rtw_set_to_roam(a, 0);
2389 }
2390 #endif /* CONFIG_LAYER2_ROAMING */
2391
2392 #if 0
2393 rtw_free_uc_swdec_pending_queue(adapter_to_dvobj(a));
2394 #endif
2395 if (MLME_IS_ASOC(a))
2396 rtw_free_assoc_resources(a, _TRUE);
2397 rtw_free_mlme_priv_ie_data(mlme);
2398
2399 rtw_indicate_disconnect(a, *(u16 *)stadel->rsvd, stadel->locally_generated);
2400
2401 _rtw_roaming(a, roam_target);
2402 }
2403
rtw_stadel_event_callback(_adapter * adapter,u8 * pbuf)2404 void rtw_stadel_event_callback(_adapter *adapter, u8 *pbuf)
2405 {
2406 struct sta_info *psta;
2407 struct wlan_network *pwlan = NULL;
2408 WLAN_BSSID_EX *pdev_network = NULL;
2409 u8 *pibss = NULL;
2410 struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
2411 struct stadel_event *pstadel = (struct stadel_event *)pbuf;
2412 struct wlan_network *tgt_network = &(pmlmepriv->cur_network);
2413
2414 RTW_INFO("%s(mac_id=%d)=" MAC_FMT "\n", __func__, pstadel->mac_id, MAC_ARG(pstadel->macaddr));
2415
2416 psta = rtw_get_stainfo(&adapter->stapriv, pstadel->macaddr);
2417
2418 if (psta == NULL) {
2419 RTW_INFO("%s(mac_id=%d)=" MAC_FMT " psta == NULL\n", __func__, pstadel->mac_id, MAC_ARG(pstadel->macaddr));
2420 /*rtw_warn_on(1);*/
2421 }
2422
2423 if (psta) {
2424 rtw_wfd_st_switch(psta, 0);
2425 psta->hw_decrypted = _FALSE;
2426 }
2427
2428 if (MLME_IS_MESH(adapter)) {
2429 rtw_free_stainfo(adapter, psta);
2430 goto exit;
2431 }
2432
2433 if (MLME_IS_AP(adapter)) {
2434 #ifdef CONFIG_IOCTL_CFG80211
2435 #ifdef COMPAT_KERNEL_RELEASE
2436
2437 #elif (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 37)) || defined(CONFIG_CFG80211_FORCE_COMPATIBLE_2_6_37_UNDER)
2438 rtw_cfg80211_indicate_sta_disassoc(adapter, pstadel->macaddr, *(u16 *)pstadel->rsvd);
2439 #endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 37)) || defined(CONFIG_CFG80211_FORCE_COMPATIBLE_2_6_37_UNDER) */
2440 #endif /* CONFIG_IOCTL_CFG80211 */
2441
2442 rtw_hw_disconnect(adapter, psta);
2443
2444 rtw_free_stainfo(adapter, psta);
2445
2446 goto exit;
2447 }
2448
2449 mlmeext_sta_del_event_callback(adapter);
2450
2451 _rtw_spinlock_bh(&pmlmepriv->lock);
2452
2453 if (MLME_IS_STA(adapter))
2454 _stadel_posthandle_sta(adapter, pstadel);
2455
2456 if (MLME_IS_ADHOC_MASTER(adapter) ||
2457 MLME_IS_ADHOC(adapter)) {
2458
2459 /* _rtw_spinlock_bh(&(pstapriv->sta_hash_lock)); */
2460 rtw_free_stainfo(adapter, psta);
2461 /* _rtw_spinunlock_bh(&(pstapriv->sta_hash_lock)); */
2462
2463 if (adapter->stapriv.asoc_sta_count == 1) { /* a sta + bc/mc_stainfo (not Ibss_stainfo) */
2464 /* rtw_indicate_disconnect(adapter); */ /* removed@20091105 */
2465 _rtw_spinlock_bh(&(pmlmepriv->scanned_queue.lock));
2466 /* free old ibss network */
2467 /* pwlan = _rtw_find_network(&pmlmepriv->scanned_queue, pstadel->macaddr); */
2468 pwlan = _rtw_find_network(&pmlmepriv->scanned_queue, tgt_network->network.MacAddress);
2469 if (pwlan) {
2470 pwlan->fixed = _FALSE;
2471 rtw_free_network_nolock(adapter, pwlan);
2472 }
2473 _rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
2474 /* re-create ibss */
2475 pdev_network = &(adapter->registrypriv.dev_network);
2476 pibss = adapter->registrypriv.dev_network.MacAddress;
2477
2478 _rtw_memcpy(pdev_network, &tgt_network->network, get_WLAN_BSSID_EX_sz(&tgt_network->network));
2479
2480 _rtw_memset(&pdev_network->Ssid, 0, sizeof(NDIS_802_11_SSID));
2481 _rtw_memcpy(&pdev_network->Ssid, &pmlmepriv->assoc_ssid, sizeof(NDIS_802_11_SSID));
2482
2483 rtw_update_registrypriv_dev_network(adapter);
2484
2485 rtw_generate_random_ibss(pibss);
2486
2487 if (MLME_IS_ADHOC(adapter)) {
2488 set_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE);
2489 _clr_fwstate_(pmlmepriv, WIFI_ADHOC_STATE);
2490 }
2491
2492 if (rtw_create_ibss_cmd(adapter, 0) != _SUCCESS)
2493 RTW_ERR("rtw_create_ibss_cmd FAIL\n");
2494
2495 }
2496
2497 }
2498
2499 _rtw_spinunlock_bh(&pmlmepriv->lock);
2500 exit:
2501 #ifdef CONFIG_RTS_FULL_BW
2502 rtw_set_rts_bw(adapter);
2503 #endif/*CONFIG_RTS_FULL_BW*/
2504 return;
2505 }
2506
rtw_wmm_event_callback(_adapter * padapter,u8 * pbuf)2507 void rtw_wmm_event_callback(_adapter *padapter, u8 *pbuf)
2508 {
2509
2510 WMMOnAssocRsp(padapter);
2511
2512
2513 }
2514
2515 /*
2516 * rtw_join_timeout_handler - Timeout/failure handler for CMD JoinBss
2517 */
rtw_join_timeout_handler(void * ctx)2518 void rtw_join_timeout_handler(void *ctx)
2519 {
2520 _adapter *adapter = (_adapter *)ctx;
2521 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
2522 struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
2523 struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
2524
2525 #if 0
2526 if (dev_is_drv_stopped(adapter_to_dvobj(adapter))) {
2527 _rtw_up_sema(&pmlmepriv->assoc_terminate);
2528 return;
2529 }
2530 #endif
2531
2532
2533
2534 RTW_INFO("%s, fw_state=%x\n", __FUNCTION__, get_fwstate(pmlmepriv));
2535
2536 if (RTW_CANNOT_RUN(adapter_to_dvobj(adapter)))
2537 return;
2538
2539
2540 _rtw_spinlock_bh(&pmlmepriv->lock);
2541
2542 #ifdef CONFIG_LAYER2_ROAMING
2543 if (rtw_to_roam(adapter) > 0) { /* join timeout caused by roaming */
2544 while (1) {
2545 rtw_dec_to_roam(adapter);
2546 if (rtw_to_roam(adapter) != 0) { /* try another */
2547 int do_join_r;
2548 RTW_INFO("%s try another roaming\n", __FUNCTION__);
2549 do_join_r = rtw_do_join(adapter);
2550 if (_SUCCESS != do_join_r) {
2551 RTW_INFO("%s roaming do_join return %d\n", __FUNCTION__ , do_join_r);
2552 continue;
2553 }
2554 break;
2555 } else {
2556 RTW_INFO("%s We've try roaming but fail\n", __FUNCTION__);
2557 #ifdef CONFIG_RTW_80211R
2558 /* rtw_ft_clr_flags(adapter, RTW_FT_PEER_EN|RTW_FT_PEER_OTD_EN); */
2559 rtw_ft_reset_status(adapter);
2560 #endif
2561 rtw_indicate_disconnect(adapter, pmlmepriv->join_status, _FALSE);
2562 pmlmeinfo->disconnect_occurred_time = rtw_systime_to_ms(rtw_get_current_time());
2563 pmlmeinfo->disconnect_code = DISCONNECTION_BY_DRIVER_DUE_TO_JOINBSS_TIMEOUT;
2564 pmlmeinfo->wifi_reason_code = WLAN_REASON_UNSPECIFIED;
2565 #ifdef CONFIG_STA_CMD_DISPR
2566 rtw_connect_abort(adapter);
2567 #endif
2568 break;
2569 }
2570 }
2571
2572 } else
2573 #endif
2574 {
2575 #ifdef CONFIG_STA_CMD_DISPR
2576 if (check_fwstate(pmlmepriv, WIFI_UNDER_LINKING) == _TRUE)
2577 rtw_connect_abort(adapter);
2578 #endif /* CONFIG_STA_CMD_DISPR */
2579
2580 rtw_indicate_disconnect(adapter, pmlmepriv->join_status, _FALSE);
2581 pmlmeinfo->disconnect_occurred_time = rtw_systime_to_ms(rtw_get_current_time());
2582 pmlmeinfo->disconnect_code = DISCONNECTION_BY_DRIVER_DUE_TO_JOINBSS_TIMEOUT;
2583 pmlmeinfo->wifi_reason_code = WLAN_REASON_UNSPECIFIED;
2584 free_scanqueue(pmlmepriv);/* ??? */
2585
2586 #ifdef CONFIG_IOCTL_CFG80211
2587 /* indicate disconnect for the case that join_timeout and check_fwstate != FW_LINKED */
2588 rtw_cfg80211_indicate_disconnect(adapter, pmlmepriv->join_status, _FALSE);
2589 #endif /* CONFIG_IOCTL_CFG80211 */
2590 }
2591
2592 pmlmepriv->join_status = 0; /* reset */
2593
2594 _rtw_spinunlock_bh(&pmlmepriv->lock);
2595
2596
2597 #ifdef CONFIG_DRVEXT_MODULE_WSC
2598 drvext_assoc_fail_indicate(&adapter->drvextpriv);
2599 #endif
2600
2601
2602
2603 }
2604
rtw_mlme_reset_auto_scan_int(_adapter * adapter,u8 * reason)2605 void rtw_mlme_reset_auto_scan_int(_adapter *adapter, u8 *reason)
2606 {
2607 #if defined(CONFIG_RTW_MESH) && defined(CONFIG_DFS_MASTER)
2608 #if CONFIG_RTW_MESH_OFFCH_CAND
2609 struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
2610 #endif
2611 #endif
2612 u8 u_ch;
2613 u32 interval_ms = 0xffffffff; /* 0xffffffff: special value to make min() works well, also means no auto scan */
2614
2615 *reason = RTW_AUTO_SCAN_REASON_UNSPECIFIED;
2616 rtw_mi_get_ch_setting_union(adapter, &u_ch, NULL, NULL);
2617
2618 if (rtw_hw_chk_bw_cap(adapter_to_dvobj(adapter), BW_CAP_40M)
2619 && is_client_associated_to_ap(adapter) == _TRUE
2620 && u_ch >= 1 && u_ch <= 14
2621 && adapter->registrypriv.wifi_spec
2622 /* TODO: AP Connected is 40MHz capability? */
2623 ) {
2624 interval_ms = rtw_min(interval_ms, 60 * 1000);
2625 *reason |= RTW_AUTO_SCAN_REASON_2040_BSS;
2626 }
2627
2628 #ifdef CONFIG_RTW_MESH
2629 #if CONFIG_RTW_MESH_OFFCH_CAND
2630 if (adapter->mesh_cfg.peer_sel_policy.offch_find_int_ms
2631 && rtw_mesh_offch_candidate_accepted(adapter)
2632 #ifdef CONFIG_DFS_MASTER
2633 && (!rfctl->radar_detect_ch || (IS_CH_WAITING(rfctl) && !IS_UNDER_CAC(rfctl)))
2634 #endif
2635 ) {
2636 interval_ms = rtw_min(interval_ms, adapter->mesh_cfg.peer_sel_policy.offch_find_int_ms);
2637 *reason |= RTW_AUTO_SCAN_REASON_MESH_OFFCH_CAND;
2638 }
2639 #endif
2640 #endif /* CONFIG_RTW_MESH */
2641
2642 if (interval_ms == 0xffffffff)
2643 interval_ms = 0;
2644
2645 rtw_mlme_set_auto_scan_int(adapter, interval_ms);
2646 return;
2647 }
2648
2649
rtw_auto_scan_handler(_adapter * padapter)2650 static void rtw_auto_scan_handler(_adapter *padapter)
2651 {
2652 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2653 u8 reason = RTW_AUTO_SCAN_REASON_UNSPECIFIED;
2654 #ifdef CONFIG_LAYER2_ROAMING
2655 struct recv_info *precvinfo = &padapter->recvinfo;
2656 #endif
2657
2658 rtw_mlme_reset_auto_scan_int(padapter, &reason);
2659
2660 #ifdef CONFIG_P2P
2661 if (rtw_p2p_chk_role(&padapter->wdinfo, P2P_ROLE_CLIENT) ||
2662 rtw_p2p_chk_role(&padapter->wdinfo, P2P_ROLE_GO))
2663 goto exit;
2664 #endif
2665
2666 #ifdef CONFIG_TDLS
2667 if (padapter->tdlsinfo.link_established == _TRUE)
2668 goto exit;
2669 #endif
2670
2671 #ifdef CONFIG_LAYER2_ROAMING
2672 if (is_client_associated_to_ap(padapter) &&
2673 rtw_chk_roam_flags(padapter, RTW_ROAM_ACTIVE)) {
2674 RTW_INFO("avg_val = %d, need_to_roam=%d\n", precvinfo->signal_strength_data.avg_val, pmlmepriv->need_to_roam);
2675 if (precvinfo->signal_strength_data.avg_val < pmlmepriv->roam_rssi_threshold) {
2676 pmlmepriv->need_to_roam = _TRUE;
2677 if (rtw_get_passing_time_ms(pmlmepriv->last_roaming) >= pmlmepriv->roam_scan_int*2000) {
2678 #ifdef CONFIG_RTW_80211K
2679 rtw_roam_nb_discover(padapter, _FALSE);
2680 #endif
2681 reason = RTW_AUTO_SCAN_REASON_ROAM_ACTIVE;
2682 pmlmepriv->last_roaming = rtw_get_current_time();
2683 goto do_scan;
2684 }
2685 } else
2686 pmlmepriv->need_to_roam = _FALSE;
2687 }
2688 #endif
2689
2690 if (pmlmepriv->auto_scan_int_ms == 0
2691 || rtw_get_passing_time_ms(pmlmepriv->scan_start_time) < pmlmepriv->auto_scan_int_ms)
2692 goto exit;
2693 do_scan:
2694 rtw_drv_scan_by_self(padapter, reason);
2695
2696 exit:
2697 return;
2698 }
is_drv_in_lps(_adapter * adapter)2699 static u8 is_drv_in_lps(_adapter *adapter)
2700 {
2701 u8 is_in_lps = _FALSE;
2702
2703 #ifdef CONFIG_LPS_LCLK_WD_TIMER /* to avoid leaving lps 32k frequently*/
2704 if ((adapter_to_pwrctl(adapter)->bFwCurrentInPSMode == _TRUE)
2705 )
2706 is_in_lps = _TRUE;
2707 #endif /* CONFIG_LPS_LCLK_WD_TIMER*/
2708 return is_in_lps;
2709 }
2710
rtw_iface_dynamic_check_handlder(struct _ADAPTER * a)2711 void rtw_iface_dynamic_check_handlder(struct _ADAPTER *a)
2712 {
2713 if (!a->netif_up)
2714 return;
2715
2716 #ifdef CONFIG_ACTIVE_KEEP_ALIVE_CHECK
2717 #ifdef CONFIG_AP_MODE
2718 if (MLME_IS_AP(a) || MLME_IS_MESH(a)) {
2719 expire_timeout_chk(a);
2720 #ifdef CONFIG_RTW_MESH
2721 if (MLME_IS_MESH(a) && MLME_IS_ASOC(a))
2722 rtw_mesh_peer_status_chk(a);
2723 #endif
2724 }
2725 #endif
2726 #endif /* CONFIG_ACTIVE_KEEP_ALIVE_CHECK */
2727
2728 /* auto site survey */
2729 rtw_auto_scan_handler(a);
2730 dynamic_update_bcn_check(a);
2731 linked_status_chk(a, 0);
2732 traffic_status_watchdog(a, 0);
2733
2734 #ifdef CONFIG_BR_EXT
2735 if (!adapter_use_wds(a)) {
2736 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35))
2737 rcu_read_lock();
2738 #endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35)) */
2739
2740 #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35))
2741 if (a->pnetdev->br_port
2742 #else /* (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35)) */
2743 if (rcu_dereference(a->pnetdev->rx_handler_data)
2744 #endif /* (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35)) */
2745 && (MLME_IS_STA(a) || MLME_IS_ADHOC(a))) {
2746 /* expire NAT2.5 entry */
2747 void nat25_db_expire(_adapter *priv);
2748 nat25_db_expire(a);
2749
2750 if (a->pppoe_connection_in_progress > 0)
2751 a->pppoe_connection_in_progress--;
2752 if (a->pppoe_connection_in_progress > 0)
2753 a->pppoe_connection_in_progress--;
2754 }
2755
2756 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35))
2757 rcu_read_unlock();
2758 #endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35)) */
2759 }
2760 #endif /* CONFIG_BR_EXT */
2761 #ifdef CONFIG_RTW_CFGVENDOR_RSSIMONITOR
2762 rtw_cfgvendor_rssi_monitor_evt(a);
2763 #endif
2764 }
2765
rtw_iface_dynamic_check_timer_handlder(_adapter * adapter)2766 void rtw_iface_dynamic_check_timer_handlder(_adapter *adapter)
2767 {
2768 #ifdef CONFIG_AP_MODE
2769 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
2770 #endif /* CONFIG_AP_MODE */
2771
2772 if (!adapter->netif_up)
2773 return;
2774 #ifdef CONFIG_LPS_LCLK_WD_TIMER /* to avoid leaving lps 32k frequently*/
2775 if (is_drv_in_lps(adapter)) {
2776 u8 bEnterPS;
2777
2778 linked_status_chk(adapter, 1);
2779
2780 bEnterPS = traffic_status_watchdog(adapter, 1);
2781 #if 0 /*PS TODO ...*/
2782 if (bEnterPS) {
2783 /* rtw_lps_ctrl_wk_cmd(adapter, LPS_CTRL_ENTER, 0); */
2784 rtw_hal_dm_watchdog_in_lps(adapter);
2785 } else {
2786 /* call rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_LEAVE, 0) in traffic_status_watchdog() */
2787 }
2788 #endif
2789 }
2790 #endif /* CONFIG_LPS_LCLK_WD_TIMER */
2791
2792 #ifdef CONFIG_AP_MODE
2793 if (MLME_IS_AP(adapter)|| MLME_IS_MESH(adapter)) {
2794 #ifndef CONFIG_ACTIVE_KEEP_ALIVE_CHECK
2795 expire_timeout_chk(adapter);
2796 #endif /* !CONFIG_ACTIVE_KEEP_ALIVE_CHECK */
2797
2798 #ifdef CONFIG_BMC_TX_RATE_SELECT
2799 rtw_update_bmc_sta_tx_rate(adapter);
2800 #endif /*CONFIG_BMC_TX_RATE_SELECT*/
2801 }
2802 #endif /*CONFIG_AP_MODE*/
2803
2804 rtw_iface_dynamic_check_handlder(adapter);
2805 }
2806
2807 /*TP_avg(t) = (1/10) * TP_avg(t-1) + (9/10) * TP(t) MBps*/
collect_sta_traffic_statistics(_adapter * adapter)2808 static void collect_sta_traffic_statistics(_adapter *adapter)
2809 {
2810 /* ToDo */
2811 #if 0
2812 struct macid_ctl_t *macid_ctl = &adapter->dvobj->macid_ctl;
2813 struct sta_info *sta;
2814 u64 curr_tx_bytes = 0, curr_rx_bytes = 0;
2815 u32 curr_tx_mbytes = 0, curr_rx_mbytes = 0;
2816 int i;
2817
2818 for (i = 0; i < MACID_NUM_SW_LIMIT; i++) {
2819 sta = macid_ctl->sta[i];
2820 if (sta && !is_broadcast_mac_addr(sta->phl_sta->mac_addr)) {
2821 if (sta->sta_stats.last_tx_bytes > sta->sta_stats.tx_bytes)
2822 sta->sta_stats.last_tx_bytes = sta->sta_stats.tx_bytes;
2823 if (sta->sta_stats.last_rx_bytes > sta->sta_stats.rx_bytes)
2824 sta->sta_stats.last_rx_bytes = sta->sta_stats.rx_bytes;
2825 if (sta->sta_stats.last_rx_bc_bytes > sta->sta_stats.rx_bc_bytes)
2826 sta->sta_stats.last_rx_bc_bytes = sta->sta_stats.rx_bc_bytes;
2827 if (sta->sta_stats.last_rx_mc_bytes > sta->sta_stats.rx_mc_bytes)
2828 sta->sta_stats.last_rx_mc_bytes = sta->sta_stats.rx_mc_bytes;
2829
2830 curr_tx_bytes = sta->sta_stats.tx_bytes - sta->sta_stats.last_tx_bytes;
2831 curr_rx_bytes = sta->sta_stats.rx_bytes - sta->sta_stats.last_rx_bytes;
2832 sta->sta_stats.tx_tp_kbits = (curr_tx_bytes * 8 / 2) >> 10;/*Kbps*/
2833 sta->sta_stats.rx_tp_kbits = (curr_rx_bytes * 8 / 2) >> 10;/*Kbps*/
2834
2835 sta->sta_stats.smooth_tx_tp_kbits = (sta->sta_stats.smooth_tx_tp_kbits * 6 / 10) + (sta->sta_stats.tx_tp_kbits * 4 / 10);/*Kbps*/
2836 sta->sta_stats.smooth_rx_tp_kbits = (sta->sta_stats.smooth_rx_tp_kbits * 6 / 10) + (sta->sta_stats.rx_tp_kbits * 4 / 10);/*Kbps*/
2837
2838 curr_tx_mbytes = (curr_tx_bytes / 2) >> 20;/*MBps*/
2839 curr_rx_mbytes = (curr_rx_bytes / 2) >> 20;/*MBps*/
2840
2841 sta->phl_sta->tx_moving_average_tp =
2842 (sta->phl_sta->tx_moving_average_tp / 10) + (curr_tx_mbytes * 9 / 10); /*MBps*/
2843
2844 sta->phl_sta->rx_moving_average_tp =
2845 (sta->phl_sta->rx_moving_average_tp / 10) + (curr_rx_mbytes * 9 /10); /*MBps*/
2846
2847 rtw_collect_bcn_info(sta->padapter);
2848
2849 if (adapter->bsta_tp_dump)
2850 rtw_hal_dump_sta_traffic(RTW_DBGDUMP, adapter, sta);
2851
2852 sta->sta_stats.last_tx_bytes = sta->sta_stats.tx_bytes;
2853 sta->sta_stats.last_rx_bytes = sta->sta_stats.rx_bytes;
2854 sta->sta_stats.last_rx_bc_bytes = sta->sta_stats.rx_bc_bytes;
2855 sta->sta_stats.last_rx_mc_bytes = sta->sta_stats.rx_mc_bytes;
2856 }
2857 }
2858 #endif
2859 }
2860
rtw_sta_traffic_info(void * sel,_adapter * adapter)2861 void rtw_sta_traffic_info(void *sel, _adapter *adapter)
2862 {
2863 /* ToDo */
2864 #if 0
2865 struct macid_ctl_t *macid_ctl = &adapter->dvobj->macid_ctl;
2866 struct sta_info *sta;
2867 int i;
2868
2869 for (i = 0; i < MACID_NUM_SW_LIMIT; i++) {
2870 sta = macid_ctl->sta[i];
2871 if (sta && !is_broadcast_mac_addr(sta->phl_sta->mac_addr))
2872 rtw_hal_dump_sta_traffic(sel, adapter, sta);
2873 }
2874 #endif
2875 }
2876
2877 /*#define DBG_TRAFFIC_STATISTIC*/
collect_traffic_statistics(_adapter * padapter)2878 static void collect_traffic_statistics(_adapter *padapter)
2879 {
2880 struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
2881
2882 /*_rtw_memset(&pdvobjpriv->traffic_stat, 0, sizeof(struct rtw_traffic_statistics));*/
2883
2884 /* Tx bytes reset*/
2885 pdvobjpriv->traffic_stat.tx_bytes = 0;
2886 pdvobjpriv->traffic_stat.tx_pkts = 0;
2887 pdvobjpriv->traffic_stat.tx_drop = 0;
2888
2889 /* Rx bytes reset*/
2890 pdvobjpriv->traffic_stat.rx_bytes = 0;
2891 pdvobjpriv->traffic_stat.rx_pkts = 0;
2892 pdvobjpriv->traffic_stat.rx_drop = 0;
2893
2894 rtw_mi_traffic_statistics(padapter);
2895
2896 /* Calculate throughput in last interval */
2897 pdvobjpriv->traffic_stat.cur_tx_bytes = pdvobjpriv->traffic_stat.tx_bytes - pdvobjpriv->traffic_stat.last_tx_bytes;
2898 pdvobjpriv->traffic_stat.cur_rx_bytes = pdvobjpriv->traffic_stat.rx_bytes - pdvobjpriv->traffic_stat.last_rx_bytes;
2899 pdvobjpriv->traffic_stat.last_tx_bytes = pdvobjpriv->traffic_stat.tx_bytes;
2900 pdvobjpriv->traffic_stat.last_rx_bytes = pdvobjpriv->traffic_stat.rx_bytes;
2901
2902 pdvobjpriv->traffic_stat.cur_tx_tp = (u32)(pdvobjpriv->traffic_stat.cur_tx_bytes * 8 / 2 / 1024 / 1024);/*Mbps*/
2903 pdvobjpriv->traffic_stat.cur_rx_tp = (u32)(pdvobjpriv->traffic_stat.cur_rx_bytes * 8 / 2 / 1024 / 1024);/*Mbps*/
2904
2905 #ifdef DBG_TRAFFIC_STATISTIC
2906 RTW_INFO("\n========================\n");
2907 RTW_INFO("cur_tx_bytes:%lld\n", pdvobjpriv->traffic_stat.cur_tx_bytes);
2908 RTW_INFO("cur_rx_bytes:%lld\n", pdvobjpriv->traffic_stat.cur_rx_bytes);
2909
2910 RTW_INFO("last_tx_bytes:%lld\n", pdvobjpriv->traffic_stat.last_tx_bytes);
2911 RTW_INFO("last_rx_bytes:%lld\n", pdvobjpriv->traffic_stat.last_rx_bytes);
2912
2913 RTW_INFO("cur_tx_tp:%d (Mbps)\n", pdvobjpriv->traffic_stat.cur_tx_tp);
2914 RTW_INFO("cur_rx_tp:%d (Mbps)\n", pdvobjpriv->traffic_stat.cur_rx_tp);
2915 #endif
2916
2917 #ifdef CONFIG_RTW_NAPI
2918 #ifdef CONFIG_RTW_NAPI_DYNAMIC
2919 dynamic_napi_th_chk (padapter);
2920 #endif /* CONFIG_RTW_NAPI_DYNAMIC */
2921 #endif
2922
2923 }
2924
rtw_accumulate_fa_count(struct dvobj_priv * dvobj)2925 static void rtw_accumulate_fa_count(struct dvobj_priv *dvobj)
2926 {
2927 u32 fa_count;
2928 enum phl_band_idx band_idx;
2929
2930 for (band_idx = HW_BAND_0; band_idx < HW_BAND_MAX; band_idx++) {
2931 fa_count = rtw_phl_get_phy_stat_info(GET_PHL_INFO(dvobj),
2932 band_idx,
2933 STAT_INFO_FA_ALL);
2934 ATOMIC_ADD((ATOMIC_T *)&dvobj->fa_cnt_acc[band_idx],
2935 (int)fa_count);
2936 }
2937 }
2938
2939 #if 0 /*#ifdef CONFIG_CORE_DM_CHK_TIMER*/
2940 void rtw_dynamic_check_timer_handlder(void *ctx)
2941 {
2942 struct dvobj_priv *pdvobj = (struct dvobj_priv *)ctx;
2943 _adapter *adapter = dvobj_get_primary_adapter(pdvobj);
2944
2945 if (!adapter)
2946 goto exit;
2947
2948 #if (MP_DRIVER == 1)
2949 if (adapter->registrypriv.mp_mode == 1 && adapter->mppriv.mp_dm == 0) { /* for MP ODM dynamic Tx power tracking */
2950 /* RTW_INFO("%s mp_dm =0 return\n", __func__); */
2951 goto exit;
2952 }
2953 #endif
2954
2955 if (!rtw_hw_is_init_completed(pdvobj))
2956 goto exit;
2957
2958 if (RTW_CANNOT_RUN(pdvobj))
2959 goto exit;
2960
2961 collect_traffic_statistics(adapter);
2962 collect_sta_traffic_statistics(adapter);
2963 rtw_mi_dynamic_check_timer_handlder(adapter);
2964
2965 if (!is_drv_in_lps(adapter))
2966 rtw_dynamic_chk_wk_cmd(adapter);
2967
2968 exit:
2969 _set_timer(&pdvobj->dynamic_chk_timer, 2000);
2970 }
2971 #endif
2972 #ifdef CONFIG_CMD_GENERAL
rtw_core_watchdog_sw_hdlr(void * drv_priv)2973 void rtw_core_watchdog_sw_hdlr(void *drv_priv)
2974 {
2975 struct dvobj_priv *pdvobj = (struct dvobj_priv *)drv_priv;
2976 struct _ADAPTER *adapter = dvobj_get_primary_adapter(pdvobj);
2977
2978 if (!adapter)
2979 goto exit;
2980 #if (MP_DRIVER == 1)
2981 /* for MP ODM dynamic Tx power tracking */
2982 if (adapter->registrypriv.mp_mode == 1 && adapter->mppriv.mp_dm == 0) {
2983 /* RTW_INFO("%s mp_dm =0 return\n", __func__); */
2984 goto exit;
2985 }
2986 #endif
2987 if (!rtw_hw_is_init_completed(pdvobj))
2988 goto exit;
2989
2990 collect_traffic_statistics(adapter);
2991 collect_sta_traffic_statistics(adapter);
2992 rtw_mi_dynamic_check_handlder(adapter);
2993 rtw_dynamic_chk_wk_sw_hdl(adapter);
2994 rtw_accumulate_fa_count(pdvobj);
2995
2996 exit:
2997 return;
2998 }
2999
rtw_core_watchdog_hw_hdlr(void * drv_priv)3000 void rtw_core_watchdog_hw_hdlr(void *drv_priv)
3001 {
3002 struct dvobj_priv *pdvobj = (struct dvobj_priv *)drv_priv;
3003 struct _ADAPTER *adapter = dvobj_get_primary_adapter(pdvobj);
3004
3005 if (!adapter)
3006 goto exit;
3007 #if (MP_DRIVER == 1)
3008 /* for MP ODM dynamic Tx power tracking */
3009 if (adapter->registrypriv.mp_mode == 1 && adapter->mppriv.mp_dm == 0) {
3010 /* RTW_INFO("%s mp_dm =0 return\n", __func__); */
3011 goto exit;
3012 }
3013 #endif
3014 if (!rtw_hw_is_init_completed(pdvobj))
3015 goto exit;
3016
3017 if (RTW_CANNOT_RUN(pdvobj))
3018 goto exit;
3019
3020 rtw_dynamic_chk_wk_hw_hdl(adapter);
3021
3022 exit:
3023 return;
3024 }
3025 #else
rtw_dynamic_check_handlder(void * ctx,void * parm,bool discard)3026 int rtw_dynamic_check_handlder(void *ctx, void *parm, bool discard)
3027 {
3028 struct dvobj_priv *pdvobj = (struct dvobj_priv *)ctx;
3029 struct _ADAPTER *adapter = dvobj_get_primary_adapter(pdvobj);
3030
3031 if (!adapter)
3032 goto exit;
3033
3034 #if (MP_DRIVER == 1)
3035 /* for MP ODM dynamic Tx power tracking */
3036 if (adapter->registrypriv.mp_mode == 1 && adapter->mppriv.mp_dm == 0) {
3037 /* RTW_INFO("%s mp_dm =0 return\n", __func__); */
3038 goto exit;
3039 }
3040 #endif
3041
3042 if (!rtw_hw_is_init_completed(pdvobj))
3043 goto exit;
3044
3045 if (RTW_CANNOT_RUN(pdvobj))
3046 goto exit;
3047
3048 collect_traffic_statistics(adapter);
3049 collect_sta_traffic_statistics(adapter);
3050 rtw_mi_dynamic_check_handlder(adapter);
3051 rtw_dynamic_chk_wk_hdl(adapter);
3052
3053 exit:
3054
3055 return 0;
3056 }
3057 #endif
3058
3059 #ifdef CONFIG_LAYER2_ROAMING
3060 /*
3061 * Select a new roaming candidate from the original @param candidate and @param competitor
3062 * @return _TRUE: candidate is updated
3063 * @return _FALSE: candidate is not updated
3064 */
rtw_check_roaming_candidate(struct mlme_priv * mlme,struct wlan_network ** candidate,struct wlan_network * competitor)3065 static int rtw_check_roaming_candidate(struct mlme_priv *mlme
3066 , struct wlan_network **candidate, struct wlan_network *competitor)
3067 {
3068 int updated = _FALSE;
3069 _adapter *adapter = container_of(mlme, _adapter, mlmepriv);
3070 struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
3071 RT_CHANNEL_INFO *chset = rfctl->channel_set;
3072 u8 ch = competitor->network.Configuration.DSConfig;
3073
3074 if (rtw_chset_search_ch(chset, ch) < 0)
3075 goto exit;
3076 if (IS_DFS_SLAVE_WITH_RD(rfctl)
3077 && !rtw_rfctl_dfs_domain_unknown(rfctl)
3078 && rtw_chset_is_ch_non_ocp(chset, ch))
3079 goto exit;
3080
3081 if (is_same_ess(&competitor->network, &mlme->cur_network.network) == _FALSE)
3082 goto exit;
3083
3084 if (rtw_is_desired_network(adapter, competitor) == _FALSE)
3085 goto exit;
3086
3087 #ifdef CONFIG_LAYER2_ROAMING
3088 if (mlme->need_to_roam == _FALSE)
3089 goto exit;
3090 #endif
3091
3092 RTW_INFO("roam candidate:%s %s("MAC_FMT", ch%3u) rssi:%d, age:%5d\n",
3093 (competitor == mlme->cur_network_scanned) ? "*" : " " ,
3094 competitor->network.Ssid.Ssid,
3095 MAC_ARG(competitor->network.MacAddress),
3096 competitor->network.Configuration.DSConfig,
3097 (int)competitor->network.PhyInfo.rssi,
3098 rtw_get_passing_time_ms(competitor->last_scanned)
3099 );
3100
3101 /* got specific addr to roam */
3102 if (!is_zero_mac_addr(mlme->roam_tgt_addr)) {
3103 if (_rtw_memcmp(mlme->roam_tgt_addr, competitor->network.MacAddress, ETH_ALEN) == _TRUE)
3104 goto update;
3105 else
3106 goto exit;
3107 }
3108
3109 #ifdef CONFIG_RTW_80211R
3110 if (rtw_ft_chk_flags(adapter, RTW_FT_PEER_EN)) {
3111 if (rtw_ft_chk_roaming_candidate(adapter, competitor) == _FALSE)
3112 goto exit;
3113 }
3114
3115 #ifdef CONFIG_RTW_WNM
3116 if (rtw_wnm_btm_diff_bss(adapter) &&
3117 rtw_wnm_btm_roam_candidate(adapter, competitor)) {
3118 goto update;
3119 }
3120 #endif
3121 #endif
3122
3123 #if 1
3124 if (rtw_get_passing_time_ms(competitor->last_scanned) >= mlme->roam_scanr_exp_ms)
3125 goto exit;
3126
3127 if (competitor->network.PhyInfo.rssi - mlme->cur_network_scanned->network.PhyInfo.rssi < mlme->roam_rssi_diff_th)
3128 goto exit;
3129
3130 if (*candidate != NULL && (*candidate)->network.PhyInfo.rssi >= competitor->network.PhyInfo.rssi)
3131 goto exit;
3132 #else
3133 goto exit;
3134 #endif
3135
3136 update:
3137 *candidate = competitor;
3138 updated = _TRUE;
3139
3140 exit:
3141 return updated;
3142 }
3143
rtw_select_roaming_candidate(struct mlme_priv * mlme)3144 int rtw_select_roaming_candidate(struct mlme_priv *mlme)
3145 {
3146 int ret = _FAIL;
3147 _list *phead;
3148 _adapter *adapter;
3149 _queue *queue = &(mlme->scanned_queue);
3150 struct wlan_network *pnetwork = NULL;
3151 struct wlan_network *candidate = NULL;
3152
3153 if (mlme->cur_network_scanned == NULL) {
3154 rtw_warn_on(1);
3155 goto exit;
3156 }
3157
3158 _rtw_spinlock_bh(&(mlme->scanned_queue.lock));
3159 phead = get_list_head(queue);
3160 adapter = (_adapter *)mlme->nic_hdl;
3161
3162 mlme->pscanned = get_next(phead);
3163
3164 while (!rtw_end_of_queue_search(phead, mlme->pscanned)) {
3165
3166 pnetwork = LIST_CONTAINOR(mlme->pscanned, struct wlan_network, list);
3167 if (pnetwork == NULL) {
3168 ret = _FAIL;
3169 goto exit;
3170 }
3171
3172 mlme->pscanned = get_next(mlme->pscanned);
3173
3174 if (0)
3175 RTW_INFO("%s("MAC_FMT", ch%u) rssi:%d\n"
3176 , pnetwork->network.Ssid.Ssid
3177 , MAC_ARG(pnetwork->network.MacAddress)
3178 , pnetwork->network.Configuration.DSConfig
3179 , (int)pnetwork->network.PhyInfo.rssi);
3180
3181 rtw_check_roaming_candidate(mlme, &candidate, pnetwork);
3182
3183 }
3184
3185 if (candidate == NULL) {
3186 /* if parent note lost the path to root and there is no other cadidate, report disconnection */
3187 RTW_INFO("%s: return _FAIL(candidate == NULL)\n", __FUNCTION__);
3188 ret = _FAIL;
3189 goto exit;
3190 } else {
3191 RTW_INFO("%s: candidate: %s("MAC_FMT", ch:%u)\n", __FUNCTION__,
3192 candidate->network.Ssid.Ssid, MAC_ARG(candidate->network.MacAddress),
3193 candidate->network.Configuration.DSConfig);
3194 mlme->roam_network = candidate;
3195
3196 if (_rtw_memcmp(candidate->network.MacAddress, mlme->roam_tgt_addr, ETH_ALEN) == _TRUE)
3197 _rtw_memset(mlme->roam_tgt_addr, 0, ETH_ALEN);
3198 }
3199
3200 ret = _SUCCESS;
3201 exit:
3202 _rtw_spinunlock_bh(&(mlme->scanned_queue.lock));
3203
3204 return ret;
3205 }
3206 #endif /* CONFIG_LAYER2_ROAMING */
3207
3208 /*
3209 * Select a new join candidate from the original @param candidate and @param competitor
3210 * @return _TRUE: candidate is updated
3211 * @return _FALSE: candidate is not updated
3212 */
rtw_check_join_candidate(struct mlme_priv * mlme,struct wlan_network ** candidate,struct wlan_network * competitor)3213 static int rtw_check_join_candidate(struct mlme_priv *mlme
3214 , struct wlan_network **candidate, struct wlan_network *competitor)
3215 {
3216 int updated = _FALSE;
3217 _adapter *adapter = container_of(mlme, _adapter, mlmepriv);
3218 struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
3219 RT_CHANNEL_INFO *chset = rfctl->channel_set;
3220 u8 ch = competitor->network.Configuration.DSConfig;
3221
3222 if (rtw_chset_search_ch(chset, ch) < 0)
3223 goto exit;
3224 if (IS_DFS_SLAVE_WITH_RD(rfctl)
3225 && !rtw_rfctl_dfs_domain_unknown(rfctl)
3226 && rtw_chset_is_ch_non_ocp(chset, ch))
3227 goto exit;
3228
3229 /* check bssid, if needed */
3230 if (mlme->assoc_by_bssid == _TRUE) {
3231 if (_rtw_memcmp(competitor->network.MacAddress, mlme->assoc_bssid, ETH_ALEN) == _FALSE)
3232 goto exit;
3233 }
3234
3235 /* check ssid, if needed */
3236 if (mlme->assoc_ssid.Ssid[0] && mlme->assoc_ssid.SsidLength) {
3237 if (competitor->network.Ssid.SsidLength != mlme->assoc_ssid.SsidLength
3238 || _rtw_memcmp(competitor->network.Ssid.Ssid, mlme->assoc_ssid.Ssid, mlme->assoc_ssid.SsidLength) == _FALSE
3239 )
3240 goto exit;
3241 }
3242
3243 if (rtw_is_desired_network(adapter, competitor) == _FALSE)
3244 goto exit;
3245
3246 #ifdef CONFIG_LAYER2_ROAMING
3247 if (rtw_to_roam(adapter) > 0) {
3248 if (rtw_get_passing_time_ms(competitor->last_scanned) >= mlme->roam_scanr_exp_ms
3249 || is_same_ess(&competitor->network, &mlme->cur_network.network) == _FALSE
3250 )
3251 goto exit;
3252 }
3253 #endif
3254
3255 if (*candidate == NULL || (*candidate)->network.PhyInfo.rssi < competitor->network.PhyInfo.rssi) {
3256 *candidate = competitor;
3257 updated = _TRUE;
3258 }
3259
3260 if (updated) {
3261 RTW_INFO("[by_bssid:%u][assoc_ssid:%s][to_roam:%u] "
3262 "new candidate: %s("MAC_FMT", ch%u) rssi:%d\n",
3263 mlme->assoc_by_bssid,
3264 mlme->assoc_ssid.Ssid,
3265 rtw_to_roam(adapter),
3266 (*candidate)->network.Ssid.Ssid,
3267 MAC_ARG((*candidate)->network.MacAddress),
3268 (*candidate)->network.Configuration.DSConfig,
3269 (int)(*candidate)->network.PhyInfo.rssi
3270 );
3271 }
3272
3273 exit:
3274 return updated;
3275 }
3276
3277 /*
3278 Calling context:
3279 The caller of the sub-routine will be in critical section...
3280
3281 The caller must hold the following spinlock
3282
3283 pmlmepriv->lock
3284
3285
3286 */
3287
rtw_select_and_join_from_scanned_queue(struct mlme_priv * pmlmepriv)3288 int rtw_select_and_join_from_scanned_queue(struct mlme_priv *pmlmepriv)
3289 {
3290 int ret;
3291 _list *phead;
3292 _adapter *adapter;
3293 _queue *queue = &(pmlmepriv->scanned_queue);
3294 struct wlan_network *pnetwork = NULL;
3295 struct wlan_network *candidate = NULL;
3296 #ifdef CONFIG_ANTENNA_DIVERSITY
3297 u8 bSupportAntDiv = _FALSE;
3298 #endif
3299 struct mlme_ext_priv *pmlmeext;
3300 struct mlme_ext_info *pmlmeinfo;
3301
3302 adapter = (_adapter *)pmlmepriv->nic_hdl;
3303 pmlmeext = &adapter->mlmeextpriv;
3304 pmlmeinfo = &pmlmeext->mlmext_info;
3305
3306 _rtw_spinlock_bh(&(pmlmepriv->scanned_queue.lock));
3307
3308 #ifdef CONFIG_LAYER2_ROAMING
3309 if (pmlmepriv->roam_network) {
3310 candidate = pmlmepriv->roam_network;
3311 goto candidate_exist;
3312 }
3313 #endif
3314
3315 phead = get_list_head(queue);
3316 pmlmepriv->pscanned = get_next(phead);
3317
3318 while (!rtw_end_of_queue_search(phead, pmlmepriv->pscanned)) {
3319
3320 pnetwork = LIST_CONTAINOR(pmlmepriv->pscanned, struct wlan_network, list);
3321 if (pnetwork == NULL) {
3322 ret = _FAIL;
3323 goto exit;
3324 }
3325
3326 pmlmepriv->pscanned = get_next(pmlmepriv->pscanned);
3327
3328 if (0)
3329 RTW_INFO("%s("MAC_FMT", ch%u) rssi:%d\n"
3330 , pnetwork->network.Ssid.Ssid
3331 , MAC_ARG(pnetwork->network.MacAddress)
3332 , pnetwork->network.Configuration.DSConfig
3333 , (int)pnetwork->network.PhyInfo.rssi);
3334
3335 rtw_check_join_candidate(pmlmepriv, &candidate, pnetwork);
3336
3337 }
3338
3339 if (candidate == NULL) {
3340 RTW_INFO("%s: return _FAIL(candidate == NULL)\n", __FUNCTION__);
3341 #ifdef CONFIG_WOWLAN
3342 _clr_fwstate_(pmlmepriv, WIFI_ASOC_STATE | WIFI_UNDER_LINKING);
3343 #endif
3344 ret = _FAIL;
3345 goto exit;
3346 } else {
3347 RTW_INFO("%s: candidate: %s("MAC_FMT", ch:%u)\n", __FUNCTION__,
3348 candidate->network.Ssid.Ssid, MAC_ARG(candidate->network.MacAddress),
3349 candidate->network.Configuration.DSConfig);
3350 goto candidate_exist;
3351 }
3352
3353 candidate_exist:
3354
3355 /* check for situation of WIFI_ASOC_STATE */
3356 if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
3357 RTW_INFO("%s: WIFI_ASOC_STATE while ask_for_joinbss!!!\n", __FUNCTION__);
3358
3359 #if 0 /* for WPA/WPA2 authentication, wpa_supplicant will expect authentication from AP, it is needed to reconnect AP... */
3360 if (is_same_network(&pmlmepriv->cur_network.network, &candidate->network)) {
3361 RTW_INFO("%s: WIFI_ASOC_STATE and is same network, it needn't join again\n", __FUNCTION__);
3362
3363 rtw_indicate_connect(adapter);/* rtw_indicate_connect again */
3364
3365 ret = 2;
3366 goto exit;
3367 } else
3368 #endif
3369 {
3370 rtw_disassoc_cmd(adapter, 0, 0);
3371 if (1
3372 #ifdef CONFIG_STA_CMD_DISPR
3373 && (MLME_IS_STA(adapter) == _FALSE)
3374 #endif /* CONFIG_STA_CMD_DISPR */
3375 )
3376 rtw_free_assoc_resources_cmd(adapter, _TRUE, 0);
3377 rtw_indicate_disconnect(adapter, 0, _FALSE);
3378
3379 pmlmeinfo->disconnect_occurred_time = rtw_systime_to_ms(rtw_get_current_time());
3380 pmlmeinfo->disconnect_code = DISCONNECTION_BY_DRIVER_DUE_TO_CONNECTION_EXIST;
3381 pmlmeinfo->wifi_reason_code = WLAN_REASON_DEAUTH_LEAVING;
3382 }
3383 }
3384
3385 set_fwstate(pmlmepriv, WIFI_UNDER_LINKING);
3386 ret = rtw_joinbss_cmd(adapter, candidate);
3387
3388 exit:
3389 _rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
3390
3391
3392 return ret;
3393 }
3394
rtw_set_auth(_adapter * adapter,struct security_priv * psecuritypriv)3395 sint rtw_set_auth(_adapter *adapter, struct security_priv *psecuritypriv)
3396 {
3397 struct cmd_obj *pcmd;
3398 struct setauth_parm *psetauthparm;
3399 struct cmd_priv *pcmdpriv = &(adapter_to_dvobj(adapter)->cmdpriv);
3400 sint res = _SUCCESS;
3401
3402
3403 pcmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
3404 if (pcmd == NULL) {
3405 res = _FAIL; /* try again */
3406 goto exit;
3407 }
3408 pcmd->padapter = adapter;
3409
3410 psetauthparm = (struct setauth_parm *)rtw_zmalloc(sizeof(struct setauth_parm));
3411 if (psetauthparm == NULL) {
3412 rtw_mfree((unsigned char *)pcmd, sizeof(struct cmd_obj));
3413 res = _FAIL;
3414 goto exit;
3415 }
3416
3417 _rtw_memset(psetauthparm, 0, sizeof(struct setauth_parm));
3418 psetauthparm->mode = (unsigned char)psecuritypriv->dot11AuthAlgrthm;
3419
3420 pcmd->cmdcode = CMD_SET_AUTH; /* _SetAuth_CMD_;*/
3421 pcmd->parmbuf = (unsigned char *)psetauthparm;
3422 pcmd->cmdsz = (sizeof(struct setauth_parm));
3423 pcmd->rsp = NULL;
3424 pcmd->rspsz = 0;
3425
3426 _rtw_init_listhead(&pcmd->list);
3427
3428 res = rtw_enqueue_cmd(pcmdpriv, pcmd);
3429 exit:
3430 return res;
3431 }
3432
3433 #ifdef CONFIG_CMD_DISP
rtw_set_key(_adapter * adapter,struct security_priv * psecuritypriv,sint keyid,u8 set_tx,bool enqueue)3434 sint rtw_set_key(_adapter *adapter, struct security_priv *psecuritypriv, sint keyid, u8 set_tx, bool enqueue)
3435 {
3436 u8 keylen;
3437 struct setkey_parm setkeyparm;
3438 sint res = _SUCCESS;
3439
3440 _rtw_memset(&setkeyparm, 0, sizeof(struct setkey_parm));
3441
3442 if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) {
3443 /* BIP use keyid 4 or 5 */
3444 if (keyid >= 4)
3445 setkeyparm.algorithm = (unsigned char)psecuritypriv->dot11wCipher;
3446 else
3447 setkeyparm.algorithm = (unsigned char)psecuritypriv->dot118021XGrpPrivacy;
3448 } else {
3449 setkeyparm.algorithm = (u8)psecuritypriv->dot11PrivacyAlgrthm;
3450
3451 }
3452 setkeyparm.keyid = (u8)keyid;/* 0~3 */
3453 setkeyparm.set_tx = set_tx;
3454 if (is_wep_enc(setkeyparm.algorithm))
3455 adapter->securitypriv.key_mask |= BIT(setkeyparm.keyid);
3456
3457 RTW_INFO("==> rtw_set_key algorithm(%x),keyid(%x),key_mask(%x)\n", setkeyparm.algorithm, setkeyparm.keyid, adapter->securitypriv.key_mask);
3458
3459 switch (setkeyparm.algorithm) {
3460
3461 case _WEP40_:
3462 keylen = 5;
3463 _rtw_memcpy(&(setkeyparm.key[0]), &(psecuritypriv->dot11DefKey[keyid].skey[0]), keylen);
3464 break;
3465 case _WEP104_:
3466 keylen = 13;
3467 _rtw_memcpy(&(setkeyparm.key[0]), &(psecuritypriv->dot11DefKey[keyid].skey[0]), keylen);
3468 break;
3469 case _TKIP_:
3470 keylen = 16;
3471 _rtw_memcpy(&setkeyparm.key, &psecuritypriv->dot118021XGrpKey[keyid], keylen);
3472 break;
3473 case _AES_:
3474 case _GCMP_:
3475 keylen = 16;
3476 _rtw_memcpy(&setkeyparm.key, &psecuritypriv->dot118021XGrpKey[keyid], keylen);
3477 break;
3478 case _GCMP_256_:
3479 case _CCMP_256_:
3480 keylen = 32;
3481 _rtw_memcpy(&setkeyparm.key, &psecuritypriv->dot118021XGrpKey[keyid], keylen);
3482 break;
3483 #ifdef CONFIG_IEEE80211W
3484 case _BIP_CMAC_128_:
3485 keylen = 16;
3486 _rtw_memcpy(&setkeyparm.key, &psecuritypriv->dot11wBIPKey[keyid], keylen);
3487 break;
3488 #endif /* CONFIG_IEEE80211W */
3489 default:
3490 res = _FAIL;
3491 goto exit;
3492 }
3493
3494
3495 if (enqueue)
3496 setkey_hdl(adapter, &setkeyparm, PHL_CMD_NO_WAIT, 0);
3497 else
3498 setkey_hdl(adapter, &setkeyparm, PHL_CMD_DIRECTLY, 0);
3499 exit:
3500 return res;
3501
3502 }
3503 #else /* CONFIG_FSM */
rtw_set_key(_adapter * adapter,struct security_priv * psecuritypriv,sint keyid,u8 set_tx,bool enqueue)3504 sint rtw_set_key(_adapter *adapter, struct security_priv *psecuritypriv, sint keyid, u8 set_tx, bool enqueue)
3505 {
3506 u8 keylen;
3507 struct cmd_obj *pcmd;
3508 struct setkey_parm *psetkeyparm;
3509 struct cmd_priv *pcmdpriv = &(adapter_to_dvobj(adapter)->cmdpriv);
3510 sint res = _SUCCESS;
3511
3512
3513 psetkeyparm = (struct setkey_parm *)rtw_zmalloc(sizeof(struct setkey_parm));
3514 if (psetkeyparm == NULL) {
3515 res = _FAIL;
3516 goto exit;
3517 }
3518 _rtw_memset(psetkeyparm, 0, sizeof(struct setkey_parm));
3519
3520 if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) {
3521 /* BIP use keyid 4 or 5 */
3522 if (keyid >= 4)
3523 psetkeyparm->algorithm = (unsigned char)psecuritypriv->dot11wCipher;
3524 else
3525 psetkeyparm->algorithm = (unsigned char)psecuritypriv->dot118021XGrpPrivacy;
3526 } else {
3527 psetkeyparm->algorithm = (u8)psecuritypriv->dot11PrivacyAlgrthm;
3528
3529 }
3530 psetkeyparm->keyid = (u8)keyid;/* 0~3 */
3531 psetkeyparm->set_tx = set_tx;
3532 if (is_wep_enc(psetkeyparm->algorithm))
3533 adapter->securitypriv.key_mask |= BIT(psetkeyparm->keyid);
3534
3535 RTW_INFO("==> rtw_set_key algorithm(%x),keyid(%x),key_mask(%x)\n", psetkeyparm->algorithm, psetkeyparm->keyid, adapter->securitypriv.key_mask);
3536
3537 switch (psetkeyparm->algorithm) {
3538
3539 case _WEP40_:
3540 keylen = 5;
3541 _rtw_memcpy(&(psetkeyparm->key[0]), &(psecuritypriv->dot11DefKey[keyid].skey[0]), keylen);
3542 break;
3543 case _WEP104_:
3544 keylen = 13;
3545 _rtw_memcpy(&(psetkeyparm->key[0]), &(psecuritypriv->dot11DefKey[keyid].skey[0]), keylen);
3546 break;
3547 case _TKIP_:
3548 keylen = 16;
3549 _rtw_memcpy(&psetkeyparm->key, &psecuritypriv->dot118021XGrpKey[keyid], keylen);
3550 break;
3551 case _AES_:
3552 case _GCMP_:
3553 keylen = 16;
3554 _rtw_memcpy(&psetkeyparm->key, &psecuritypriv->dot118021XGrpKey[keyid], keylen);
3555 break;
3556 case _GCMP_256_:
3557 case _CCMP_256_:
3558 keylen = 32;
3559 _rtw_memcpy(&psetkeyparm->key, &psecuritypriv->dot118021XGrpKey[keyid], keylen);
3560 break;
3561 #ifdef CONFIG_IEEE80211W
3562 case _BIP_CMAC_128_:
3563 keylen = 16;
3564 _rtw_memcpy(&psetkeyparm->key, &psecuritypriv->dot11wBIPKey[keyid], keylen);
3565 break;
3566 #endif /* CONFIG_IEEE80211W */
3567 default:
3568 res = _FAIL;
3569 rtw_mfree((unsigned char *)psetkeyparm, sizeof(struct setkey_parm));
3570 goto exit;
3571 }
3572
3573
3574 if (enqueue) {
3575 pcmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
3576 if (pcmd == NULL) {
3577 rtw_mfree((unsigned char *)psetkeyparm, sizeof(struct setkey_parm));
3578 res = _FAIL; /* try again */
3579 goto exit;
3580 }
3581 pcmd->padapter = adapter;
3582
3583 pcmd->cmdcode = CMD_SET_KEY; /*_SetKey_CMD_*/
3584 pcmd->parmbuf = (u8 *)psetkeyparm;
3585 pcmd->cmdsz = (sizeof(struct setkey_parm));
3586 pcmd->rsp = NULL;
3587 pcmd->rspsz = 0;
3588
3589 _rtw_init_listhead(&pcmd->list);
3590
3591 /* _rtw_init_sema(&(pcmd->cmd_sem), 0); */
3592
3593 res = rtw_enqueue_cmd(pcmdpriv, pcmd);
3594 } else {
3595 setkey_hdl(adapter, (u8 *)psetkeyparm);
3596 rtw_mfree((u8 *) psetkeyparm, sizeof(struct setkey_parm));
3597 }
3598 exit:
3599 return res;
3600
3601 }
3602 #endif
3603 #ifdef CONFIG_WMMPS_STA
3604 /*
3605 * rtw_uapsd_use_default_setting
3606 * This function is used for setting default uapsd max sp length to uapsd_max_sp_len
3607 * in qos_priv data structure from registry. In additional, it will also map default uapsd
3608 * ac to each uapsd TID, delivery-enabled and trigger-enabled of corresponding TID.
3609 *
3610 * Arguments:
3611 * @padapter: _adapter pointer.
3612 *
3613 * Auther: Arvin Liu
3614 * Date: 2017/05/03
3615 */
rtw_uapsd_use_default_setting(_adapter * padapter)3616 void rtw_uapsd_use_default_setting(_adapter *padapter)
3617 {
3618 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
3619 struct qos_priv *pqospriv = &pmlmepriv->qospriv;
3620 struct registry_priv *pregistrypriv = &padapter->registrypriv;
3621
3622 if (pregistrypriv->uapsd_ac_enable != 0) {
3623 pqospriv->uapsd_max_sp_len = pregistrypriv->uapsd_max_sp_len;
3624
3625 CLEAR_FLAGS(pqospriv->uapsd_tid);
3626 CLEAR_FLAGS(pqospriv->uapsd_tid_delivery_enabled);
3627 CLEAR_FLAGS(pqospriv->uapsd_tid_trigger_enabled);
3628
3629 /* check the uapsd setting of AC_VO from registry then map these setting to each TID if necessary */
3630 if(TEST_FLAG(pregistrypriv->uapsd_ac_enable, DRV_CFG_UAPSD_VO)) {
3631 SET_FLAG(pqospriv->uapsd_tid, WMM_TID7);
3632 SET_FLAG(pqospriv->uapsd_tid_delivery_enabled, WMM_TID7);
3633 SET_FLAG(pqospriv->uapsd_tid_trigger_enabled, WMM_TID7);
3634 SET_FLAG(pqospriv->uapsd_tid, WMM_TID6);
3635 SET_FLAG(pqospriv->uapsd_tid_delivery_enabled, WMM_TID6);
3636 SET_FLAG(pqospriv->uapsd_tid_trigger_enabled, WMM_TID6);
3637 }
3638
3639 /* check the uapsd setting of AC_VI from registry then map these setting to each TID if necessary */
3640 if(TEST_FLAG(pregistrypriv->uapsd_ac_enable, DRV_CFG_UAPSD_VI)) {
3641 SET_FLAG(pqospriv->uapsd_tid, WMM_TID5);
3642 SET_FLAG(pqospriv->uapsd_tid_delivery_enabled, WMM_TID5);
3643 SET_FLAG(pqospriv->uapsd_tid_trigger_enabled, WMM_TID5);
3644 SET_FLAG(pqospriv->uapsd_tid, WMM_TID4);
3645 SET_FLAG(pqospriv->uapsd_tid_delivery_enabled, WMM_TID4);
3646 SET_FLAG(pqospriv->uapsd_tid_trigger_enabled, WMM_TID4);
3647 }
3648
3649 /* check the uapsd setting of AC_BK from registry then map these setting to each TID if necessary */
3650 if(TEST_FLAG(pregistrypriv->uapsd_ac_enable, DRV_CFG_UAPSD_BK)) {
3651 SET_FLAG(pqospriv->uapsd_tid, WMM_TID2);
3652 SET_FLAG(pqospriv->uapsd_tid_delivery_enabled, WMM_TID2);
3653 SET_FLAG(pqospriv->uapsd_tid_trigger_enabled, WMM_TID2);
3654 SET_FLAG(pqospriv->uapsd_tid, WMM_TID1);
3655 SET_FLAG(pqospriv->uapsd_tid_delivery_enabled, WMM_TID1);
3656 SET_FLAG(pqospriv->uapsd_tid_trigger_enabled, WMM_TID1);
3657 }
3658
3659 /* check the uapsd setting of AC_BE from registry then map these setting to each TID if necessary */
3660 if(TEST_FLAG(pregistrypriv->uapsd_ac_enable, DRV_CFG_UAPSD_BE)) {
3661 SET_FLAG(pqospriv->uapsd_tid, WMM_TID3);
3662 SET_FLAG(pqospriv->uapsd_tid_delivery_enabled, WMM_TID3);
3663 SET_FLAG(pqospriv->uapsd_tid_trigger_enabled, WMM_TID3);
3664 SET_FLAG(pqospriv->uapsd_tid, WMM_TID0);
3665 SET_FLAG(pqospriv->uapsd_tid_delivery_enabled, WMM_TID0);
3666 SET_FLAG(pqospriv->uapsd_tid_trigger_enabled, WMM_TID0);
3667 }
3668
3669 RTW_INFO("[WMMPS] UAPSD MAX SP Len = 0x%02x, UAPSD TID enabled = 0x%02x\n",
3670 pqospriv->uapsd_max_sp_len, (u8)pqospriv->uapsd_tid);
3671 }
3672
3673 }
3674
3675 /*
3676 * rtw_is_wmmps_mode
3677 * This function is used for checking whether Driver and an AP support uapsd function or not.
3678 * If both of them support uapsd function, it will return true. Otherwise returns false.
3679 *
3680 * Arguments:
3681 * @padapter: _adapter pointer.
3682 *
3683 * Auther: Arvin Liu
3684 * Date: 2017/06/12
3685 */
rtw_is_wmmps_mode(_adapter * padapter)3686 bool rtw_is_wmmps_mode(_adapter *padapter)
3687 {
3688 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
3689 struct qos_priv *pqospriv = &pmlmepriv->qospriv;
3690
3691 if ((pqospriv->uapsd_ap_supported) && ((pqospriv->uapsd_tid & BIT_MASK_TID_TC) != 0))
3692 return _TRUE;
3693
3694 return _FALSE;
3695 }
3696 #endif /* CONFIG_WMMPS_STA */
3697
3698 /* adjust IEs for rtw_joinbss_cmd in WMM */
rtw_restruct_wmm_ie(_adapter * adapter,u8 * in_ie,u8 * out_ie,uint in_len,uint initial_out_len)3699 int rtw_restruct_wmm_ie(_adapter *adapter, u8 *in_ie, u8 *out_ie, uint in_len, uint initial_out_len)
3700 {
3701 #ifdef CONFIG_WMMPS_STA
3702 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
3703 struct qos_priv *pqospriv = &pmlmepriv->qospriv;
3704 #endif /* CONFIG_WMMPS_STA */
3705 unsigned int ielength = 0;
3706 unsigned int i, j;
3707 u8 qos_info = 0;
3708
3709 i = 12; /* after the fixed IE */
3710 while (i < in_len) {
3711 ielength = initial_out_len;
3712
3713 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 */
3714
3715 /* Append WMM IE to the last index of out_ie */
3716 #if 0
3717 for (j = i; j < i + (in_ie[i + 1] + 2); j++) {
3718 out_ie[ielength] = in_ie[j];
3719 ielength++;
3720 }
3721 out_ie[initial_out_len + 8] = 0x00; /* force the QoS Info Field to be zero */
3722 #endif
3723
3724 for (j = i; j < i + 9; j++) {
3725 out_ie[ielength] = in_ie[j];
3726 ielength++;
3727 }
3728 out_ie[initial_out_len + 1] = 0x07;
3729 out_ie[initial_out_len + 6] = 0x00;
3730
3731 #ifdef CONFIG_WMMPS_STA
3732 switch(pqospriv->uapsd_max_sp_len) {
3733 case NO_LIMIT:
3734 /* do nothing */
3735 break;
3736 case TWO_MSDU:
3737 SET_FLAG(qos_info, BIT5);
3738 break;
3739 case FOUR_MSDU:
3740 SET_FLAG(qos_info, BIT6);
3741 break;
3742 case SIX_MSDU:
3743 SET_FLAG(qos_info, BIT5);
3744 SET_FLAG(qos_info, BIT6);
3745 break;
3746 default:
3747 /* do nothing */
3748 break;
3749 };
3750
3751 /* check TID7 and TID6 for AC_VO to set corresponding Qos_info bit in WMM IE */
3752 if((TEST_FLAG(pqospriv->uapsd_tid, WMM_TID7)) && (TEST_FLAG(pqospriv->uapsd_tid, WMM_TID6)))
3753 SET_FLAG(qos_info, WMM_IE_UAPSD_VO);
3754 /* check TID5 and TID4 for AC_VI to set corresponding Qos_info bit in WMM IE */
3755 if((TEST_FLAG(pqospriv->uapsd_tid, WMM_TID5)) && (TEST_FLAG(pqospriv->uapsd_tid, WMM_TID4)))
3756 SET_FLAG(qos_info, WMM_IE_UAPSD_VI);
3757 /* check TID2 and TID1 for AC_BK to set corresponding Qos_info bit in WMM IE */
3758 if((TEST_FLAG(pqospriv->uapsd_tid, WMM_TID2)) && (TEST_FLAG(pqospriv->uapsd_tid, WMM_TID1)))
3759 SET_FLAG(qos_info, WMM_IE_UAPSD_BK);
3760 /* check TID3 and TID0 for AC_BE to set corresponding Qos_info bit in WMM IE */
3761 if((TEST_FLAG(pqospriv->uapsd_tid, WMM_TID3)) && (TEST_FLAG(pqospriv->uapsd_tid, WMM_TID0)))
3762 SET_FLAG(qos_info, WMM_IE_UAPSD_BE);
3763 #endif /* CONFIG_WMMPS_STA */
3764
3765 out_ie[initial_out_len + 8] = qos_info;
3766
3767 break;
3768 }
3769
3770 i += (in_ie[i + 1] + 2); /* to the next IE element */
3771 }
3772
3773 return ielength;
3774
3775 }
3776
3777
3778 /*
3779 * Ported from 8185: IsInPreAuthKeyList(). (Renamed from SecIsInPreAuthKeyList(), 2006-10-13.)
3780 * Added by Annie, 2006-05-07.
3781 *
3782 * Search by BSSID,
3783 * Return Value:
3784 * -1 :if there is no pre-auth key in the table
3785 * >=0 :if there is pre-auth key, and return the entry id
3786 *
3787 * */
3788
SecIsInPMKIDList(_adapter * adapter,u8 * bssid)3789 static int SecIsInPMKIDList(_adapter *adapter, u8 *bssid)
3790 {
3791 struct security_priv *psecuritypriv = &adapter->securitypriv;
3792 int i = 0;
3793
3794 do {
3795 if ((psecuritypriv->PMKIDList[i].bUsed) &&
3796 (_rtw_memcmp(psecuritypriv->PMKIDList[i].Bssid, bssid, ETH_ALEN) == _TRUE))
3797 break;
3798 else {
3799 i++;
3800 /* continue; */
3801 }
3802
3803 } while (i < NUM_PMKID_CACHE);
3804
3805 if (i == NUM_PMKID_CACHE) {
3806 i = -1;/* Could not find. */
3807 } else {
3808 /* There is one Pre-Authentication Key for the specific BSSID. */
3809 }
3810
3811 return i;
3812
3813 }
3814
rtw_cached_pmkid(_adapter * adapter,u8 * bssid)3815 int rtw_cached_pmkid(_adapter *adapter, u8 *bssid)
3816 {
3817 return SecIsInPMKIDList(adapter, bssid);
3818 }
3819
rtw_rsn_sync_pmkid(_adapter * adapter,u8 * ie,uint ie_len,int i_ent)3820 int rtw_rsn_sync_pmkid(_adapter *adapter, u8 *ie, uint ie_len, int i_ent)
3821 {
3822 struct security_priv *sec = &adapter->securitypriv;
3823 struct rsne_info info;
3824 u8 gm_cs[4];
3825 int i;
3826
3827 rtw_rsne_info_parse(ie, ie_len, &info);
3828
3829 if (info.err) {
3830 RTW_WARN(FUNC_ADPT_FMT" rtw_rsne_info_parse error\n"
3831 , FUNC_ADPT_ARG(adapter));
3832 return 0;
3833 }
3834
3835 if (i_ent < 0 && info.pmkid_cnt == 0)
3836 goto exit;
3837
3838 if (i_ent >= 0 && info.pmkid_cnt == 1 && _rtw_memcmp(info.pmkid_list, sec->PMKIDList[i_ent].PMKID, 16)) {
3839 RTW_INFO(FUNC_ADPT_FMT" has carried the same PMKID:"KEY_FMT"\n"
3840 , FUNC_ADPT_ARG(adapter), KEY_ARG(&sec->PMKIDList[i_ent].PMKID));
3841 goto exit;
3842 }
3843
3844 /* bakcup group mgmt cs */
3845 if (info.gmcs)
3846 _rtw_memcpy(gm_cs, info.gmcs, 4);
3847
3848 if (info.pmkid_cnt) {
3849 RTW_INFO(FUNC_ADPT_FMT" remove original PMKID, count:%u\n"
3850 , FUNC_ADPT_ARG(adapter), info.pmkid_cnt);
3851 for (i = 0; i < info.pmkid_cnt; i++)
3852 RTW_INFO(" "KEY_FMT"\n", KEY_ARG(info.pmkid_list + i * 16));
3853 }
3854
3855 if (i_ent >= 0) {
3856 RTW_INFO(FUNC_ADPT_FMT" append PMKID:"KEY_FMT"\n"
3857 , FUNC_ADPT_ARG(adapter), KEY_ARG(sec->PMKIDList[i_ent].PMKID));
3858
3859 info.pmkid_cnt = 1; /* update new pmkid_cnt */
3860 _rtw_memcpy(info.pmkid_list, sec->PMKIDList[i_ent].PMKID, 16);
3861 } else
3862 info.pmkid_cnt = 0; /* update new pmkid_cnt */
3863
3864 RTW_PUT_LE16(info.pmkid_list - 2, info.pmkid_cnt);
3865 if (info.gmcs)
3866 _rtw_memcpy(info.pmkid_list + 16 * info.pmkid_cnt, gm_cs, 4);
3867
3868 ie_len = 1 + 1 + 2 + 4
3869 + 2 + 4 * info.pcs_cnt
3870 + 2 + 4 * info.akm_cnt
3871 + 2
3872 + 2 + 16 * info.pmkid_cnt
3873 + (info.gmcs ? 4 : 0)
3874 ;
3875
3876 ie[1] = (u8)(ie_len - 2);
3877
3878 exit:
3879 return ie_len;
3880 }
3881
rtw_restruct_sec_ie(_adapter * adapter,u8 * out_ie)3882 sint rtw_restruct_sec_ie(_adapter *adapter, u8 *out_ie)
3883 {
3884 u8 authmode = 0x0;
3885 uint ielength = 0;
3886 int iEntry;
3887
3888 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
3889 struct security_priv *psecuritypriv = &adapter->securitypriv;
3890 uint ndisauthmode = psecuritypriv->ndisauthtype;
3891
3892 if ((ndisauthmode == Ndis802_11AuthModeWPA) || (ndisauthmode == Ndis802_11AuthModeWPAPSK))
3893 authmode = _WPA_IE_ID_;
3894 if ((ndisauthmode == Ndis802_11AuthModeWPA2) || (ndisauthmode == Ndis802_11AuthModeWPA2PSK))
3895 authmode = _WPA2_IE_ID_;
3896
3897 if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS)) {
3898 _rtw_memcpy(out_ie, psecuritypriv->wps_ie, psecuritypriv->wps_ie_len);
3899 ielength = psecuritypriv->wps_ie_len;
3900
3901 } else if ((authmode == _WPA_IE_ID_) || (authmode == _WPA2_IE_ID_)) {
3902 /* copy RSN or SSN */
3903 _rtw_memcpy(out_ie, psecuritypriv->supplicant_ie, psecuritypriv->supplicant_ie[1] + 2);
3904 /* debug for CONFIG_IEEE80211W
3905 {
3906 int jj;
3907 printk("supplicant_ie_length=%d &&&&&&&&&&&&&&&&&&&\n", psecuritypriv->supplicant_ie[1]+2);
3908 for(jj=0; jj < psecuritypriv->supplicant_ie[1]+2; jj++)
3909 printk(" %02x ", psecuritypriv->supplicant_ie[jj]);
3910 printk("\n");
3911 }*/
3912 ielength = psecuritypriv->supplicant_ie[1] + 2;
3913 rtw_report_sec_ie(adapter, authmode, psecuritypriv->supplicant_ie);
3914 }
3915
3916 if (authmode == WLAN_EID_RSN) {
3917 iEntry = SecIsInPMKIDList(adapter, pmlmepriv->assoc_bssid);
3918 ielength = rtw_rsn_sync_pmkid(adapter, out_ie, ielength, iEntry);
3919 }
3920
3921 if ((psecuritypriv->auth_type == MLME_AUTHTYPE_SAE) &&
3922 (psecuritypriv->rsnx_ie_len >= 3)) {
3923 u8 *_pos = out_ie + \
3924 (psecuritypriv->supplicant_ie[1] + 2);
3925 _rtw_memcpy(_pos, psecuritypriv->rsnx_ie,
3926 psecuritypriv->rsnx_ie_len);
3927 ielength += psecuritypriv->rsnx_ie_len;
3928 RTW_INFO_DUMP("update IE for RSNX :",
3929 out_ie, ielength);
3930 }
3931
3932
3933 return ielength;
3934 }
3935
rtw_init_registrypriv_dev_network(_adapter * adapter)3936 void rtw_init_registrypriv_dev_network(_adapter *adapter)
3937 {
3938 struct registry_priv *pregistrypriv = &adapter->registrypriv;
3939 WLAN_BSSID_EX *pdev_network = &pregistrypriv->dev_network;
3940 u8 *myhwaddr = adapter_mac_addr(adapter);
3941
3942
3943 _rtw_memcpy(pdev_network->MacAddress, myhwaddr, ETH_ALEN);
3944
3945 _rtw_memcpy(&pdev_network->Ssid, &pregistrypriv->ssid, sizeof(NDIS_802_11_SSID));
3946
3947 pdev_network->Configuration.Length = sizeof(NDIS_802_11_CONFIGURATION);
3948 pdev_network->Configuration.BeaconPeriod = 100;
3949 }
3950
rtw_update_registrypriv_dev_network(_adapter * adapter)3951 void rtw_update_registrypriv_dev_network(_adapter *adapter)
3952 {
3953 int sz = 0;
3954 struct registry_priv *pregistrypriv = &adapter->registrypriv;
3955 WLAN_BSSID_EX *pdev_network = &pregistrypriv->dev_network;
3956 struct security_priv *psecuritypriv = &adapter->securitypriv;
3957 struct wlan_network *cur_network = &adapter->mlmepriv.cur_network;
3958 /* struct xmit_priv *pxmitpriv = &adapter->xmitpriv; */
3959 struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
3960
3961
3962 #if 0
3963 pxmitpriv->vcs_setting = pregistrypriv->vrtl_carrier_sense;
3964 pxmitpriv->vcs = pregistrypriv->vcs_type;
3965 pxmitpriv->vcs_type = pregistrypriv->vcs_type;
3966 /* pxmitpriv->rts_thresh = pregistrypriv->rts_thresh; */
3967 pxmitpriv->frag_len = pregistrypriv->frag_thresh;
3968
3969 adapter->qospriv.qos_option = pregistrypriv->wmm_enable;
3970 #endif
3971
3972 pdev_network->Privacy = (psecuritypriv->dot11PrivacyAlgrthm > 0 ? 1 : 0) ; /* adhoc no 802.1x */
3973
3974 pdev_network->PhyInfo.rssi = 0;
3975
3976 pdev_network->Configuration.DSConfig = (pregistrypriv->channel);
3977
3978 if (cur_network->network.InfrastructureMode == Ndis802_11IBSS) {
3979 pdev_network->Configuration.ATIMWindow = (0);
3980
3981 if (pmlmeext->chandef.chan != 0)
3982 pdev_network->Configuration.DSConfig = pmlmeext->chandef.chan;
3983 else
3984 pdev_network->Configuration.DSConfig = 1;
3985 }
3986
3987 pdev_network->InfrastructureMode = (cur_network->network.InfrastructureMode);
3988
3989 /* 1. Supported rates */
3990 /* 2. IE */
3991
3992 /* rtw_set_supported_rate(pdev_network->SupportedRates, pregistrypriv->wireless_mode) ; */ /* will be called in rtw_generate_ie */
3993 sz = rtw_generate_ie(pregistrypriv);
3994
3995 pdev_network->IELength = sz;
3996
3997 pdev_network->Length = get_WLAN_BSSID_EX_sz((WLAN_BSSID_EX *)pdev_network);
3998
3999 /* notes: translate IELength & Length after assign the Length to cmdsz in createbss_cmd(); */
4000 /* pdev_network->IELength = cpu_to_le32(sz); */
4001
4002
4003 }
4004
rtw_get_encrypt_decrypt_from_registrypriv(_adapter * adapter)4005 void rtw_get_encrypt_decrypt_from_registrypriv(_adapter *adapter)
4006 {
4007
4008
4009
4010 }
4011
4012 /* the fucntion is at passive_level */
rtw_joinbss_reset(_adapter * padapter)4013 void rtw_joinbss_reset(_adapter *padapter)
4014 {
4015 u8 threshold;
4016 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
4017 /* todo: if you want to do something io/reg/hw setting before join_bss, please add code here */
4018
4019 #ifdef CONFIG_80211N_HT
4020 struct ht_priv *phtpriv = &pmlmepriv->htpriv;
4021
4022 pmlmepriv->num_FortyMHzIntolerant = 0;
4023
4024 pmlmepriv->num_sta_no_ht = 0;
4025
4026 phtpriv->ampdu_enable = _FALSE;/* reset to disabled */
4027
4028 #if defined(CONFIG_USB_HCI) || defined(CONFIG_SDIO_HCI)
4029 /* TH=1 => means that invalidate usb rx aggregation */
4030 /* TH=0 => means that validate usb rx aggregation, use init value. */
4031 if (phtpriv->ht_option) {
4032 if (padapter->registrypriv.wifi_spec == 1)
4033 threshold = 1;
4034 else
4035 threshold = 0;
4036 rtw_hal_set_hwreg(padapter, HW_VAR_RXDMA_AGG_PG_TH, (u8 *)(&threshold));
4037 } else {
4038 threshold = 1;
4039 rtw_hal_set_hwreg(padapter, HW_VAR_RXDMA_AGG_PG_TH, (u8 *)(&threshold));
4040 }
4041 #endif/* #if defined( CONFIG_USB_HCI) || defined (CONFIG_SDIO_HCI) */
4042
4043 #endif/* #ifdef CONFIG_80211N_HT */
4044
4045 }
4046
4047
4048 #ifdef CONFIG_80211N_HT
rtw_ht_get_dft_setting(_adapter * padapter,struct protocol_cap_t * dft_proto_cap,struct role_cap_t * dft_cap)4049 void rtw_ht_get_dft_setting(_adapter *padapter,
4050 struct protocol_cap_t *dft_proto_cap,
4051 struct role_cap_t *dft_cap)
4052 {
4053 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
4054 struct ht_priv *phtpriv = &pmlmepriv->htpriv;
4055 struct registry_priv *pregistrypriv = &padapter->registrypriv;
4056 BOOLEAN bHwLDPCSupport = _FALSE, bHwSTBCSupport = _FALSE;
4057 u8 stbc_rx = 0;
4058 #ifdef CONFIG_BEAMFORMING
4059 BOOLEAN bHwSupportBeamformer = _FALSE, bHwSupportBeamformee = _FALSE;
4060 #endif /* CONFIG_BEAMFORMING */
4061
4062 if (pregistrypriv->wifi_spec)
4063 phtpriv->bss_coexist = 1;
4064 else
4065 phtpriv->bss_coexist = 0;
4066
4067 /*dft_proto_cap->sgi_40;*/
4068 phtpriv->sgi_40m = TEST_FLAG(pregistrypriv->short_gi, BIT1) ? _TRUE : _FALSE;
4069 /*dft_proto_cap->sgi_20;*/
4070 phtpriv->sgi_20m = TEST_FLAG(pregistrypriv->short_gi, BIT0) ? _TRUE : _FALSE;
4071
4072 /* LDPC support */
4073 CLEAR_FLAGS(phtpriv->ldpc_cap);
4074 bHwLDPCSupport = (dft_proto_cap->ht_ldpc) ? _TRUE : _FALSE;
4075 if (bHwLDPCSupport) {
4076 if (TEST_FLAG(pregistrypriv->ldpc_cap, BIT4))
4077 SET_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_RX);
4078 }
4079
4080 bHwLDPCSupport = (dft_cap->tx_ht_ldpc) ? _TRUE : _FALSE;
4081 if (bHwLDPCSupport) {
4082 if (TEST_FLAG(pregistrypriv->ldpc_cap, BIT5))
4083 SET_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_TX);
4084 }
4085 if (phtpriv->ldpc_cap)
4086 RTW_INFO("[HT] HAL Support LDPC = 0x%02X\n", phtpriv->ldpc_cap);
4087
4088 /* STBC */
4089 CLEAR_FLAGS(phtpriv->stbc_cap);
4090 if (dft_proto_cap->stbc_ht_tx)
4091 SET_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_TX);
4092
4093 if (dft_proto_cap->stbc_ht_rx)
4094 SET_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_RX);
4095
4096 if (phtpriv->stbc_cap)
4097 RTW_INFO("[HT] HAL Support STBC = 0x%02X\n", phtpriv->stbc_cap);
4098
4099 /* Beamforming setting */
4100 CLEAR_FLAGS(phtpriv->beamform_cap);
4101 #ifdef CONFIG_BEAMFORMING
4102 /* only enable beamforming in STA client mode */
4103 if (MLME_IS_STA(padapter) && !MLME_IS_GC(padapter)
4104 && !MLME_IS_ADHOC(padapter)
4105 && !MLME_IS_MESH(padapter))
4106 {
4107 bHwSupportBeamformer = (dft_proto_cap->ht_su_bfmr) ? _TRUE : _FALSE;
4108 bHwSupportBeamformee = (dft_proto_cap->ht_su_bfme) ? _TRUE : _FALSE;
4109
4110 if (TEST_FLAG(pregistrypriv->beamform_cap, BIT4) && bHwSupportBeamformer) {
4111 SET_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMER_ENABLE);
4112 RTW_INFO("[HT] HAL Support Beamformer\n");
4113 }
4114 if (TEST_FLAG(pregistrypriv->beamform_cap, BIT5) && bHwSupportBeamformee) {
4115 SET_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMEE_ENABLE);
4116 RTW_INFO("[HT] HAL Support Beamformee\n");
4117 }
4118 }
4119 #endif /* CONFIG_BEAMFORMING */
4120 }
4121
rtw_ht_use_default_setting(_adapter * padapter)4122 void rtw_ht_use_default_setting(_adapter *padapter)
4123 {
4124 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
4125 struct ht_priv *phtpriv = &pmlmepriv->htpriv;
4126 struct registry_priv *pregistrypriv = &padapter->registrypriv;
4127 BOOLEAN bHwLDPCSupport = _FALSE, bHwSTBCSupport = _FALSE;
4128 u8 stbc_rx = 0;
4129 #ifdef CONFIG_BEAMFORMING
4130 BOOLEAN bHwSupportBeamformer = _FALSE, bHwSupportBeamformee = _FALSE;
4131 #endif /* CONFIG_BEAMFORMING */
4132
4133 if (pregistrypriv->wifi_spec)
4134 phtpriv->bss_coexist = 1;
4135 else
4136 phtpriv->bss_coexist = 0;
4137
4138 phtpriv->sgi_40m = TEST_FLAG(pregistrypriv->short_gi, BIT1) ? _TRUE : _FALSE;
4139 phtpriv->sgi_20m = TEST_FLAG(pregistrypriv->short_gi, BIT0) ? _TRUE : _FALSE;
4140
4141 /* LDPC support */
4142 if (padapter->phl_role->proto_role_cap.ht_ldpc)
4143 SET_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_RX);
4144
4145 if (padapter->phl_role->cap.tx_ht_ldpc)
4146 SET_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_TX);
4147
4148 if (phtpriv->ldpc_cap)
4149 RTW_INFO("[HT] HAL Support LDPC = 0x%02X\n", phtpriv->ldpc_cap);
4150
4151 /* STBC */
4152 if (padapter->phl_role->proto_role_cap.stbc_ht_tx)
4153 SET_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_TX);
4154
4155 if (padapter->phl_role->proto_role_cap.stbc_ht_rx)
4156 SET_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_RX);
4157
4158 if (phtpriv->stbc_cap)
4159 RTW_INFO("[HT] HAL Support STBC = 0x%02X\n", phtpriv->stbc_cap);
4160
4161 /* Beamforming setting */
4162 CLEAR_FLAGS(phtpriv->beamform_cap);
4163 #ifdef CONFIG_BEAMFORMING
4164 /* only enable beamforming in STA client mode */
4165 if (MLME_IS_STA(padapter) && !MLME_IS_GC(padapter)
4166 && !MLME_IS_ADHOC(padapter)
4167 && !MLME_IS_MESH(padapter))
4168 {
4169 if (padapter->phl_role->proto_role_cap.ht_su_bfmr) {
4170 SET_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMER_ENABLE);
4171 RTW_INFO("[HT] HAL Support Beamformer\n");
4172 }
4173
4174 if (padapter->phl_role->proto_role_cap.ht_su_bfme) {
4175 SET_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMEE_ENABLE);
4176 RTW_INFO("[HT] HAL Support Beamformee\n");
4177 }
4178 }
4179 #endif /* CONFIG_BEAMFORMING */
4180 }
rtw_build_wmm_ie_ht(_adapter * padapter,u8 * out_ie,uint * pout_len)4181 void rtw_build_wmm_ie_ht(_adapter *padapter, u8 *out_ie, uint *pout_len)
4182 {
4183 unsigned char WMM_IE[] = {0x00, 0x50, 0xf2, 0x02, 0x00, 0x01, 0x00};
4184 int out_len;
4185 u8 *pframe;
4186
4187 if (padapter->mlmepriv.qospriv.qos_option == 0) {
4188 out_len = *pout_len;
4189 pframe = rtw_set_ie(out_ie + out_len, _VENDOR_SPECIFIC_IE_,
4190 _WMM_IE_Length_, WMM_IE, pout_len);
4191
4192 padapter->mlmepriv.qospriv.qos_option = 1;
4193 }
4194 }
4195 #if defined(CONFIG_80211N_HT)
4196 /* the fucntion is >= passive_level */
rtw_restructure_ht_ie(_adapter * padapter,u8 * in_ie,u8 * out_ie,uint in_len,uint * pout_len,u8 channel,struct country_chplan * req_chplan)4197 unsigned int rtw_restructure_ht_ie(_adapter *padapter, u8 *in_ie, u8 *out_ie, uint in_len, uint *pout_len, u8 channel, struct country_chplan *req_chplan)
4198 {
4199 u32 ielen, out_len;
4200 HT_CAP_AMPDU_FACTOR max_rx_ampdu_factor = 0;
4201 HT_CAP_AMPDU_DENSITY best_ampdu_density = 0;
4202 unsigned char *p, *pframe;
4203 enum band_type band = channel > 14 ? BAND_ON_5G : BAND_ON_24G;
4204 struct rtw_ieee80211_ht_cap ht_capie;
4205 u8 cbw40_enable = 0, rf_num = 0, rx_stbc_nss = 0, rx_nss = 0;
4206 struct registry_priv *pregistrypriv = &padapter->registrypriv;
4207 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
4208 struct ht_priv *phtpriv = &pmlmepriv->htpriv;
4209 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
4210 #ifdef CONFIG_80211AC_VHT
4211 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
4212 struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
4213 #endif /* CONFIG_80211AC_VHT */
4214
4215 phtpriv->ht_option = _FALSE;
4216
4217 out_len = *pout_len;
4218
4219 _rtw_memset(&ht_capie, 0, sizeof(struct rtw_ieee80211_ht_cap));
4220
4221 ht_capie.cap_info = IEEE80211_HT_CAP_DSSSCCK40;
4222
4223 if (phtpriv->sgi_20m)
4224 ht_capie.cap_info |= IEEE80211_HT_CAP_SGI_20;
4225
4226 /* check if 40MHz is allowed according to hal cap and registry */
4227 if (rtw_hw_chk_bw_cap(adapter_to_dvobj(padapter), BW_CAP_40M)) {
4228 if (band == BAND_ON_5G) {
4229 if (REGSTY_IS_BW_5G_SUPPORT(pregistrypriv, CHANNEL_WIDTH_40))
4230 cbw40_enable = 1;
4231 } else if (band == BAND_ON_24G) {
4232 if (REGSTY_IS_BW_2G_SUPPORT(pregistrypriv, CHANNEL_WIDTH_40))
4233 cbw40_enable = 1;
4234 }
4235 }
4236
4237 if (cbw40_enable) {
4238 struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
4239 RT_CHANNEL_INFO *chset = rfctl->channel_set;
4240 u8 oper_bw = CHANNEL_WIDTH_20, oper_offset = CHAN_OFFSET_NO_EXT;
4241
4242 if (in_ie == NULL) {
4243 /* TDLS: TODO 20/40 issue */
4244 if (MLME_IS_STA(padapter)) {
4245 oper_bw = padapter->mlmeextpriv.chandef.bw;
4246 if (oper_bw > CHANNEL_WIDTH_40)
4247 oper_bw = CHANNEL_WIDTH_40;
4248 } else
4249 /* TDLS: TODO 40? */
4250 oper_bw = CHANNEL_WIDTH_40;
4251 } else {
4252 p = rtw_get_ie(in_ie, WLAN_EID_HT_OPERATION, &ielen, in_len);
4253 if (p && ielen == HT_OP_IE_LEN) {
4254 if (GET_HT_OP_ELE_STA_CHL_WIDTH(p + 2)) {
4255 switch (GET_HT_OP_ELE_2ND_CHL_OFFSET(p + 2)) {
4256 case IEEE80211_SCA:
4257 oper_bw = CHANNEL_WIDTH_40;
4258 oper_offset = CHAN_OFFSET_UPPER;
4259 break;
4260 case IEEE80211_SCB:
4261 oper_bw = CHANNEL_WIDTH_40;
4262 oper_offset = CHAN_OFFSET_LOWER;
4263 break;
4264 }
4265 }
4266 }
4267 /* IOT issue : AP TP-Link WDR6500 */
4268 if(oper_bw == CHANNEL_WIDTH_40){
4269 p = rtw_get_ie(in_ie, WLAN_EID_HT_CAP, &ielen, in_len);
4270 if (p && ielen == HT_CAP_IE_LEN) {
4271 oper_bw = GET_HT_CAP_ELE_CHL_WIDTH(p + 2) ? CHANNEL_WIDTH_40 : CHANNEL_WIDTH_20;
4272 if(oper_bw == CHANNEL_WIDTH_20)
4273 oper_offset = CHAN_OFFSET_NO_EXT;
4274 }
4275 }
4276 }
4277
4278 /* adjust bw to fit in channel plan setting */
4279 if (oper_bw == CHANNEL_WIDTH_40
4280 && oper_offset != CHAN_OFFSET_NO_EXT /* check this because TDLS has no info to set offset */
4281 ) {
4282 if ((req_chplan && !rtw_country_chplan_is_chbw_valid(req_chplan, band, channel, oper_bw, oper_offset, 1, 1, pregistrypriv))
4283 || (!req_chplan && !rtw_chset_is_chbw_valid(chset, channel, oper_bw, oper_offset, 1, 1))
4284 || (IS_DFS_SLAVE_WITH_RD(rfctl)
4285 && !rtw_rfctl_dfs_domain_unknown(rfctl)
4286 && rtw_chset_is_chbw_non_ocp(chset, channel, oper_bw, oper_offset))
4287 ) {
4288 oper_bw = CHANNEL_WIDTH_20;
4289 oper_offset = CHAN_OFFSET_NO_EXT;
4290 rtw_warn_on(req_chplan && !rtw_country_chplan_is_chbw_valid(req_chplan, band, channel, oper_bw, oper_offset, 1, 1, pregistrypriv));
4291 rtw_warn_on(!req_chplan && !rtw_chset_is_chbw_valid(chset, channel, oper_bw, oper_offset, 1, 1));
4292 if (IS_DFS_SLAVE_WITH_RD(rfctl) && !rtw_rfctl_dfs_domain_unknown(rfctl))
4293 rtw_warn_on(rtw_chset_is_chbw_non_ocp(chset, channel, oper_bw, oper_offset));
4294 }
4295 }
4296
4297 if (oper_bw == CHANNEL_WIDTH_40) {
4298 ht_capie.cap_info |= IEEE80211_HT_CAP_SUP_WIDTH;
4299 if (phtpriv->sgi_40m)
4300 ht_capie.cap_info |= IEEE80211_HT_CAP_SGI_40;
4301 }
4302
4303 cbw40_enable = oper_bw == CHANNEL_WIDTH_40 ? 1 : 0;
4304 }
4305
4306 /* todo: disable SM power save mode */
4307 ht_capie.cap_info |= IEEE80211_HT_CAP_SM_PS;
4308
4309 /* RX LDPC */
4310 if (TEST_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_RX)) {
4311 ht_capie.cap_info |= IEEE80211_HT_CAP_LDPC_CODING;
4312 RTW_INFO("[HT] Declare supporting RX LDPC\n");
4313 }
4314
4315 /* TX STBC */
4316 if (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_TX)) {
4317 ht_capie.cap_info |= IEEE80211_HT_CAP_TX_STBC;
4318 RTW_INFO("[HT] Declare supporting TX STBC\n");
4319 }
4320
4321 /* RX STBC */
4322 if (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_RX) ||
4323 (pregistrypriv->wifi_spec == 1)) {
4324 rx_stbc_nss = padapter->phl_role->proto_role_cap.stbc_ht_rx;
4325 if (rx_stbc_nss > 3)
4326 rx_stbc_nss = 3;
4327 SET_HT_CAP_ELE_RX_STBC(&ht_capie, rx_stbc_nss);
4328 RTW_INFO("[HT] Declare supporting RX STBC = %d\n", rx_stbc_nss);
4329 }
4330
4331 /* fill default supported_mcs_set */
4332 _rtw_memcpy(ht_capie.supp_mcs_set, pmlmeext->default_supported_mcs_set, 16);
4333
4334 /* update default supported_mcs_set */
4335 rx_nss = get_phy_rx_nss(padapter);
4336
4337 switch (rx_nss) {
4338 case 1:
4339 set_mcs_rate_by_mask(ht_capie.supp_mcs_set, MCS_RATE_1R);
4340 break;
4341 case 2:
4342 #ifdef CONFIG_DISABLE_MCS13TO15
4343 if (cbw40_enable && pregistrypriv->wifi_spec != 1)
4344 set_mcs_rate_by_mask(ht_capie.supp_mcs_set, MCS_RATE_2R_13TO15_OFF);
4345 else
4346 #endif
4347 set_mcs_rate_by_mask(ht_capie.supp_mcs_set, MCS_RATE_2R);
4348 break;
4349 case 3:
4350 set_mcs_rate_by_mask(ht_capie.supp_mcs_set, MCS_RATE_3R);
4351 break;
4352 case 4:
4353 set_mcs_rate_by_mask(ht_capie.supp_mcs_set, MCS_RATE_4R);
4354 break;
4355 default:
4356 RTW_WARN("rf_type:%d or rx_nss:%u is not expected\n",
4357 GET_HAL_RFPATH(adapter_to_dvobj(padapter)), rx_nss);
4358 }
4359
4360 if (padapter->phl_role->proto_role_cap.max_amsdu_len > 0) {
4361 /*SET_HT_CAP_ELE_MAX_AMSDU_LENGTH(&ht_capie, 1);*/
4362 RTW_INFO("%s IEEE80211_HT_CAP_MAX_AMSDU is set\n", __func__);
4363 ht_capie.cap_info = ht_capie.cap_info | IEEE80211_HT_CAP_MAX_AMSDU;
4364 }
4365
4366 if (padapter->driver_rx_ampdu_factor != 0xFF)
4367 max_rx_ampdu_factor = (HT_CAP_AMPDU_FACTOR)padapter->driver_rx_ampdu_factor;
4368 else
4369 rtw_hal_get_def_var(padapter, HW_VAR_MAX_RX_AMPDU_FACTOR, &max_rx_ampdu_factor);
4370
4371 /* rtw_hal_get_def_var(padapter, HW_VAR_MAX_RX_AMPDU_FACTOR, &max_rx_ampdu_factor); */
4372 ht_capie.ampdu_params_info = (max_rx_ampdu_factor & 0x03);
4373
4374 if (padapter->driver_rx_ampdu_spacing != 0xFF)
4375 ht_capie.ampdu_params_info |= ((padapter->driver_rx_ampdu_spacing & 0x07) << 2);
4376 else {
4377 if (padapter->securitypriv.dot11PrivacyAlgrthm == _AES_) {
4378 /*
4379 * Todo : Each chip must to ask DD , this chip best ampdu_density setting
4380 * By yiwei.sun
4381 */
4382 rtw_hal_get_def_var(padapter, HW_VAR_BEST_AMPDU_DENSITY, &best_ampdu_density);
4383
4384 ht_capie.ampdu_params_info |= (IEEE80211_HT_CAP_AMPDU_DENSITY & (best_ampdu_density << 2));
4385
4386 } else
4387 ht_capie.ampdu_params_info |= (IEEE80211_HT_CAP_AMPDU_DENSITY & 0x00);
4388 }
4389 #ifdef CONFIG_BEAMFORMING
4390 ht_capie.tx_BF_cap_info = 0;
4391
4392 /* HT Beamformer*/
4393 if (TEST_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMER_ENABLE)) {
4394 /* Transmit NDP Capable */
4395 SET_HT_CAP_TXBF_TRANSMIT_NDP_CAP(&ht_capie, 1);
4396 /* Explicit Compressed Steering Capable */
4397 SET_HT_CAP_TXBF_EXPLICIT_COMP_STEERING_CAP(&ht_capie, 1);
4398 /* Compressed Steering Number Antennas */
4399 SET_HT_CAP_TXBF_COMP_STEERING_NUM_ANTENNAS(&ht_capie, 1);
4400 rtw_hal_get_def_var(padapter, HAL_DEF_BEAMFORMER_CAP, (u8 *)&rf_num);
4401 if (rf_num > 3)
4402 rf_num = 3;
4403 SET_HT_CAP_TXBF_CHNL_ESTIMATION_NUM_ANTENNAS(&ht_capie, rf_num);
4404 }
4405
4406 /* HT Beamformee */
4407 if (TEST_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMEE_ENABLE)) {
4408 /* Receive NDP Capable */
4409 SET_HT_CAP_TXBF_RECEIVE_NDP_CAP(&ht_capie, 1);
4410 /* Explicit Compressed Beamforming Feedback Capable */
4411 SET_HT_CAP_TXBF_EXPLICIT_COMP_FEEDBACK_CAP(&ht_capie, 2);
4412
4413 rtw_hal_get_def_var(padapter, HAL_DEF_BEAMFORMEE_CAP, (u8 *)&rf_num);
4414 if (rf_num > 3)
4415 rf_num = 3;
4416 #ifdef CONFIG_80211AC_VHT
4417 /* IOT action suggested by Yu Chen 2017/3/3 */
4418 if ((pmlmeinfo->assoc_AP_vendor == HT_IOT_PEER_BROADCOM) &&
4419 !pvhtpriv->ap_bf_cap.is_mu_bfer &&
4420 pvhtpriv->ap_bf_cap.su_sound_dim == 2)
4421 rf_num = (rf_num >= 2 ? 2 : rf_num);
4422 #endif
4423 SET_HT_CAP_TXBF_COMP_STEERING_NUM_ANTENNAS(&ht_capie, rf_num);
4424 }
4425 #endif/*CONFIG_BEAMFORMING*/
4426
4427 pframe = rtw_set_ie(out_ie + out_len, _HT_CAPABILITY_IE_,
4428 sizeof(struct rtw_ieee80211_ht_cap), (unsigned char *)&ht_capie, pout_len);
4429
4430 phtpriv->ht_option = _TRUE;
4431
4432 if (in_ie != NULL) {
4433 p = rtw_get_ie(in_ie, _HT_ADD_INFO_IE_, &ielen, in_len);
4434 if (p && (ielen == sizeof(struct ieee80211_ht_addt_info))) {
4435 out_len = *pout_len;
4436 pframe = rtw_set_ie(out_ie + out_len, _HT_ADD_INFO_IE_, ielen, p + 2 , pout_len);
4437 }
4438 }
4439
4440 return phtpriv->ht_option;
4441
4442 }
4443
4444 /* the fucntion is > passive_level (in critical_section) */
rtw_update_ht_cap(_adapter * padapter,u8 * pie,uint ie_len,u8 channel)4445 void rtw_update_ht_cap(_adapter *padapter, u8 *pie, uint ie_len, u8 channel)
4446 {
4447 u8 *p, max_ampdu_sz;
4448 int len;
4449 /* struct sta_info *bmc_sta, *psta; */
4450 struct rtw_ieee80211_ht_cap *pht_capie;
4451 struct ieee80211_ht_addt_info *pht_addtinfo;
4452 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
4453 struct ht_priv *phtpriv = &pmlmepriv->htpriv;
4454 struct registry_priv *pregistrypriv = &padapter->registrypriv;
4455 /* struct wlan_network *pcur_network = &(pmlmepriv->cur_network);; */
4456 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
4457 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
4458 u8 cbw40_enable = 0;
4459
4460
4461 if (!phtpriv->ht_option)
4462 return;
4463
4464 if ((!pmlmeinfo->HT_info_enable) || (!pmlmeinfo->HT_caps_enable))
4465 return;
4466
4467 RTW_INFO("+rtw_update_ht_cap()\n");
4468
4469 /* maybe needs check if ap supports rx ampdu. */
4470 if ((phtpriv->ampdu_enable == _FALSE) && (pregistrypriv->ampdu_enable == 1)) {
4471 if (pregistrypriv->wifi_spec == 1) {
4472 /* remove this part because testbed AP should disable RX AMPDU */
4473 /* phtpriv->ampdu_enable = _FALSE; */
4474 phtpriv->ampdu_enable = _TRUE;
4475 } else
4476 phtpriv->ampdu_enable = _TRUE;
4477 }
4478
4479
4480 /* check Max Rx A-MPDU Size */
4481 len = 0;
4482 p = rtw_get_ie(pie + sizeof(NDIS_802_11_FIXED_IEs), _HT_CAPABILITY_IE_, &len, ie_len - sizeof(NDIS_802_11_FIXED_IEs));
4483 if (p && len > 0) {
4484 pht_capie = (struct rtw_ieee80211_ht_cap *)(p + 2);
4485 max_ampdu_sz = (pht_capie->ampdu_params_info & IEEE80211_HT_CAP_AMPDU_FACTOR);
4486 max_ampdu_sz = 1 << (max_ampdu_sz + 3); /* max_ampdu_sz (kbytes); */
4487
4488 /* RTW_INFO("rtw_update_ht_cap(): max_ampdu_sz=%d\n", max_ampdu_sz); */
4489 phtpriv->rx_ampdu_maxlen = max_ampdu_sz;
4490
4491 }
4492
4493
4494 len = 0;
4495 p = rtw_get_ie(pie + sizeof(NDIS_802_11_FIXED_IEs), _HT_ADD_INFO_IE_, &len, ie_len - sizeof(NDIS_802_11_FIXED_IEs));
4496 if (p && len > 0) {
4497 pht_addtinfo = (struct ieee80211_ht_addt_info *)(p + 2);
4498 /* todo: */
4499 }
4500
4501 if (rtw_hw_chk_bw_cap(adapter_to_dvobj(padapter), BW_CAP_40M)) {
4502 if (channel > 14) {
4503 if (REGSTY_IS_BW_5G_SUPPORT(pregistrypriv, CHANNEL_WIDTH_40))
4504 cbw40_enable = 1;
4505 } else {
4506 if (REGSTY_IS_BW_2G_SUPPORT(pregistrypriv, CHANNEL_WIDTH_40))
4507 cbw40_enable = 1;
4508 }
4509 }
4510
4511 /* update cur_bwmode & cur_ch_offset */
4512 if ((cbw40_enable) &&
4513 (pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info & BIT(1)) &&
4514 (pmlmeinfo->HT_info.infos[0] & BIT(2))) {
4515 int i;
4516 u8 rx_nss = 0;
4517
4518 rx_nss = get_phy_rx_nss(padapter);
4519
4520
4521 /* update the MCS set */
4522 for (i = 0; i < 16; i++)
4523 pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate[i] &= pmlmeext->default_supported_mcs_set[i];
4524
4525 /* update the MCS rates */
4526 switch (rx_nss) {
4527 case 1:
4528 set_mcs_rate_by_mask(pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate, MCS_RATE_1R);
4529 break;
4530 case 2:
4531 #ifdef CONFIG_DISABLE_MCS13TO15
4532 if (pmlmeext->chandef.bw == CHANNEL_WIDTH_40 && pregistrypriv->wifi_spec != 1)
4533 set_mcs_rate_by_mask(pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate, MCS_RATE_2R_13TO15_OFF);
4534 else
4535 #endif
4536 set_mcs_rate_by_mask(pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate, MCS_RATE_2R);
4537 break;
4538 case 3:
4539 set_mcs_rate_by_mask(pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate, MCS_RATE_3R);
4540 break;
4541 case 4:
4542 set_mcs_rate_by_mask(pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate, MCS_RATE_4R);
4543 break;
4544 default:
4545 RTW_WARN("rx_nss:%u is not expected\n", rx_nss);
4546 }
4547
4548 /* switch to the 40M Hz mode accoring to the AP */
4549 /* pmlmeext->cur_bwmode = CHANNEL_WIDTH_40; */
4550 /* Secondary Channel Offset */
4551 switch ((pmlmeinfo->HT_info.infos[0] & 0x3)) {
4552 case IEEE80211_SCA:
4553 pmlmeext->chandef.offset = CHAN_OFFSET_UPPER;
4554 break;
4555
4556 case IEEE80211_SCB:
4557 pmlmeext->chandef.offset = CHAN_OFFSET_LOWER;
4558 break;
4559
4560 default:
4561 pmlmeext->chandef.bw = CHANNEL_WIDTH_20;
4562 pmlmeext->chandef.offset = CHAN_OFFSET_NO_EXT;
4563 RTW_INFO("%s : ch offset is not assigned for HT40 mod , update cur_bwmode=%u, cur_ch_offset=%u\n",
4564 __func__, pmlmeext->chandef.bw, pmlmeext->chandef.offset);
4565 break;
4566 }
4567 }
4568
4569 /* */
4570 /* Config SM Power Save setting */
4571 /* */
4572 pmlmeinfo->SM_PS = (pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info & 0x0C) >> 2;
4573 if (pmlmeinfo->SM_PS == WLAN_HT_CAP_SM_PS_STATIC) {
4574 #if 0
4575 u8 i;
4576 /* update the MCS rates */
4577 for (i = 0; i < 16; i++)
4578 pmlmeinfo->HT_caps.HT_cap_element.MCS_rate[i] &= MCS_rate_1R[i];
4579 #endif
4580 RTW_INFO("%s(): WLAN_HT_CAP_SM_PS_STATIC\n", __FUNCTION__);
4581 }
4582
4583 /* */
4584 /* Config current HT Protection mode. */
4585 /* */
4586 pmlmeinfo->HT_protection = pmlmeinfo->HT_info.infos[1] & 0x3;
4587 }
4588 #endif
4589
4590 #ifdef CONFIG_TDLS
rtw_issue_addbareq_cmd_tdls(_adapter * padapter,struct xmit_frame * pxmitframe)4591 void rtw_issue_addbareq_cmd_tdls(_adapter *padapter, struct xmit_frame *pxmitframe)
4592 {
4593 struct pkt_attrib *pattrib = &pxmitframe->attrib;
4594 struct sta_info *ptdls_sta = NULL;
4595 u8 issued;
4596 int priority;
4597 struct ht_priv *phtpriv;
4598
4599 priority = pattrib->priority;
4600
4601 if (pattrib->direct_link == _TRUE) {
4602 ptdls_sta = rtw_get_stainfo(&padapter->stapriv, pattrib->dst);
4603 if ((ptdls_sta != NULL) && (ptdls_sta->tdls_sta_state & TDLS_LINKED_STATE)) {
4604 phtpriv = &ptdls_sta->htpriv;
4605
4606 if ((phtpriv->ht_option == _TRUE) && (phtpriv->ampdu_enable == _TRUE)) {
4607 issued = (phtpriv->agg_enable_bitmap >> priority) & 0x1;
4608 issued |= (phtpriv->candidate_tid_bitmap >> priority) & 0x1;
4609
4610 if (0 == issued) {
4611 RTW_INFO("[%s], p=%d\n", __FUNCTION__, priority);
4612 ptdls_sta->htpriv.candidate_tid_bitmap |= BIT((u8)priority);
4613 rtw_addbareq_cmd(padapter, (u8)priority, pattrib->dst);
4614 }
4615 }
4616 }
4617 }
4618 }
4619 #endif /* CONFIG_TDLS */
4620
4621 #ifdef CONFIG_80211N_HT
rtw_issue_addbareq_check(_adapter * padapter,struct xmit_frame * pxmitframe,u8 issue_when_busy)4622 static u8 rtw_issue_addbareq_check(_adapter *padapter, struct xmit_frame *pxmitframe, u8 issue_when_busy)
4623 {
4624 struct registry_priv *pregpriv = &padapter->registrypriv;
4625 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
4626 struct registry_priv *pregistry = &padapter->registrypriv;
4627 struct pkt_attrib *pattrib = &pxmitframe->attrib;
4628 s32 bmcst = IS_MCAST(pattrib->ra);
4629
4630 if (bmcst)
4631 return _FALSE;
4632
4633 if (pregpriv->wifi_spec == 1)
4634 return _TRUE;
4635
4636 if (pregistry->tx_quick_addba_req == 0) {
4637 if ((issue_when_busy == _TRUE) && (pmlmepriv->LinkDetectInfo.bBusyTraffic == _FALSE))
4638 return _FALSE;
4639
4640 if (pmlmepriv->LinkDetectInfo.NumTxOkInPeriod < 100)
4641 return _FALSE;
4642 }
4643
4644 return _TRUE;
4645 }
4646
rtw_issue_addbareq_cmd(_adapter * padapter,struct xmit_frame * pxmitframe,u8 issue_when_busy)4647 void rtw_issue_addbareq_cmd(_adapter *padapter, struct xmit_frame *pxmitframe, u8 issue_when_busy)
4648 {
4649 u8 issued;
4650 int priority;
4651 struct sta_info *psta = NULL;
4652 struct ht_priv *phtpriv;
4653 struct pkt_attrib *pattrib = &pxmitframe->attrib;
4654
4655 if (rtw_issue_addbareq_check(padapter,pxmitframe, issue_when_busy) == _FALSE)
4656 return;
4657
4658 priority = pattrib->priority;
4659
4660 #ifdef CONFIG_TDLS
4661 rtw_issue_addbareq_cmd_tdls(padapter, pxmitframe);
4662 #endif /* CONFIG_TDLS */
4663
4664 psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
4665 if (pattrib->psta != psta) {
4666 RTW_INFO("%s, pattrib->psta(%p) != psta(%p)\n", __func__, pattrib->psta, psta);
4667 return;
4668 }
4669
4670 if (psta == NULL) {
4671 RTW_INFO("%s, psta==NUL\n", __func__);
4672 return;
4673 }
4674
4675 if (!(psta->state & WIFI_ASOC_STATE)) {
4676 RTW_INFO("%s, psta->state(0x%x) != WIFI_ASOC_STATE\n", __func__, psta->state);
4677 return;
4678 }
4679
4680
4681 phtpriv = &psta->htpriv;
4682
4683 if ((phtpriv->ht_option == _TRUE) && (phtpriv->ampdu_enable == _TRUE)) {
4684 issued = (phtpriv->agg_enable_bitmap >> priority) & 0x1;
4685 issued |= (phtpriv->candidate_tid_bitmap >> priority) & 0x1;
4686
4687 if (0 == issued) {
4688 RTW_INFO("rtw_issue_addbareq_cmd, p=%d\n", priority);
4689 psta->htpriv.candidate_tid_bitmap |= BIT((u8)priority);
4690 rtw_addbareq_cmd(padapter, (u8) priority, pattrib->ra);
4691 }
4692 }
4693
4694 }
4695 #endif /* CONFIG_80211N_HT */
rtw_append_extended_cap(_adapter * padapter,u8 * out_ie,uint * pout_len)4696 void rtw_append_extended_cap(_adapter *padapter, u8 *out_ie, uint *pout_len)
4697 {
4698 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
4699 struct ht_priv *phtpriv = &pmlmepriv->htpriv;
4700 #ifdef CONFIG_80211AC_VHT
4701 struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
4702 #endif /* CONFIG_80211AC_VHT */
4703 u8 *ext_cap_data = pmlmepriv->ext_capab_ie_data;
4704 u8 *ext_cap_data_len = &(pmlmepriv->ext_capab_ie_len);
4705
4706 if (phtpriv->bss_coexist)
4707 rtw_add_ext_cap_info(ext_cap_data, ext_cap_data_len, BSS_COEXT);
4708
4709 #ifdef CONFIG_80211AC_VHT
4710 if (pvhtpriv->vht_option)
4711 rtw_add_ext_cap_info(ext_cap_data, ext_cap_data_len, OP_MODE_NOTIFICATION);
4712 #endif /* CONFIG_80211AC_VHT */
4713 #ifdef CONFIG_RTW_WNM
4714 rtw_add_ext_cap_info(ext_cap_data, ext_cap_data_len, BSS_TRANSITION);
4715 #endif
4716
4717 #ifdef CONFIG_RTW_MBO
4718 rtw_add_ext_cap_info(ext_cap_data, ext_cap_data_len, INTERWORKING);
4719 #endif
4720
4721 #ifdef CONFIG_80211AX_HE
4722 /* CONFIG_80211AX_HE_TODO */
4723 #endif /* CONFIG_80211AX_HE */
4724
4725 #ifdef CONFIG_STA_MULTIPLE_BSSID
4726 rtw_add_ext_cap_info(ext_cap_data, ext_cap_data_len, MULTI_BSSID);
4727 #endif
4728
4729 /*
4730 From 802.11 specification,if a STA does not support any of capabilities defined
4731 in the Extended Capabilities element, then the STA is not required to
4732 transmit the Extended Capabilities element.
4733 */
4734 rtw_update_ext_cap_ie(ext_cap_data, *ext_cap_data_len, out_ie, pout_len, _BEACON_IE_OFFSET_);
4735 }
4736 #endif
4737
4738 #ifdef CONFIG_LAYER2_ROAMING
rtw_set_to_roam(_adapter * adapter,u8 to_roam)4739 inline void rtw_set_to_roam(_adapter *adapter, u8 to_roam)
4740 {
4741 if (to_roam == 0)
4742 adapter->mlmepriv.to_join = _FALSE;
4743 adapter->mlmepriv.to_roam = to_roam;
4744 }
4745
rtw_dec_to_roam(_adapter * adapter)4746 inline u8 rtw_dec_to_roam(_adapter *adapter)
4747 {
4748 adapter->mlmepriv.to_roam--;
4749 return adapter->mlmepriv.to_roam;
4750 }
4751
rtw_to_roam(_adapter * adapter)4752 inline u8 rtw_to_roam(_adapter *adapter)
4753 {
4754 return adapter->mlmepriv.to_roam;
4755 }
4756
rtw_roaming(_adapter * padapter,struct wlan_network * tgt_network)4757 void rtw_roaming(_adapter *padapter, struct wlan_network *tgt_network)
4758 {
4759 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
4760
4761 _rtw_spinlock_bh(&pmlmepriv->lock);
4762 _rtw_roaming(padapter, tgt_network);
4763 _rtw_spinunlock_bh(&pmlmepriv->lock);
4764 }
_rtw_roaming(_adapter * padapter,struct wlan_network * tgt_network)4765 void _rtw_roaming(_adapter *padapter, struct wlan_network *tgt_network)
4766 {
4767 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
4768 struct wlan_network *cur_network = &pmlmepriv->cur_network;
4769 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
4770 struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
4771 int do_join_r;
4772
4773 if (0 < rtw_to_roam(padapter)) {
4774 RTW_INFO("roaming from %s("MAC_FMT"), length:%d\n",
4775 cur_network->network.Ssid.Ssid, MAC_ARG(cur_network->network.MacAddress),
4776 cur_network->network.Ssid.SsidLength);
4777 _rtw_memcpy(&pmlmepriv->assoc_ssid, &cur_network->network.Ssid, sizeof(NDIS_802_11_SSID));
4778 pmlmepriv->assoc_ch = 0;
4779 pmlmepriv->assoc_by_bssid = _FALSE;
4780
4781 #ifdef CONFIG_WAPI_SUPPORT
4782 rtw_wapi_return_all_sta_info(padapter);
4783 #endif
4784
4785 while (1) {
4786 do_join_r = rtw_do_join(padapter);
4787 if (_SUCCESS == do_join_r)
4788 break;
4789 else {
4790 RTW_INFO("roaming do_join return %d\n", do_join_r);
4791 rtw_dec_to_roam(padapter);
4792
4793 if (rtw_to_roam(padapter) > 0)
4794 continue;
4795 else {
4796 RTW_INFO("%s(%d) -to roaming fail, indicate_disconnect\n", __FUNCTION__, __LINE__);
4797 #ifdef CONFIG_RTW_80211R
4798 /* rtw_ft_clr_flags(padapter, RTW_FT_PEER_EN|RTW_FT_PEER_OTD_EN); */
4799 rtw_ft_reset_status(padapter);
4800 #endif
4801 rtw_indicate_disconnect(padapter, 0, _FALSE);
4802 pmlmeinfo->disconnect_occurred_time = rtw_systime_to_ms(rtw_get_current_time());
4803 pmlmeinfo->disconnect_code = DISCONNECTION_BY_DRIVER_DUE_TO_LAYER2_ROAMING_TERMINATE;
4804 pmlmeinfo->wifi_reason_code = WLAN_REASON_UNSPECIFIED;
4805 break;
4806 }
4807 }
4808 }
4809 }
4810
4811 }
4812 #endif /* CONFIG_LAYER2_ROAMING */
4813
rtw_adjust_chbw(_adapter * adapter,u8 req_ch,u8 * req_bw,u8 * req_offset)4814 bool rtw_adjust_chbw(_adapter *adapter, u8 req_ch, u8 *req_bw, u8 *req_offset)
4815 {
4816 struct registry_priv *regsty = adapter_to_regsty(adapter);
4817 u8 allowed_bw;
4818
4819 if (req_ch < 14)
4820 allowed_bw = REGSTY_BW_2G(regsty);
4821 else if (req_ch == 14)
4822 allowed_bw = CHANNEL_WIDTH_20;
4823 else
4824 allowed_bw = REGSTY_BW_5G(regsty);
4825
4826 allowed_bw = rtw_hw_largest_bw(adapter_to_dvobj(adapter), allowed_bw);
4827
4828 if (allowed_bw == CHANNEL_WIDTH_80 && *req_bw > CHANNEL_WIDTH_80)
4829 *req_bw = CHANNEL_WIDTH_80;
4830 else if (allowed_bw == CHANNEL_WIDTH_40 && *req_bw > CHANNEL_WIDTH_40)
4831 *req_bw = CHANNEL_WIDTH_40;
4832 else if (allowed_bw == CHANNEL_WIDTH_20 && *req_bw > CHANNEL_WIDTH_20) {
4833 *req_bw = CHANNEL_WIDTH_20;
4834 *req_offset = CHAN_OFFSET_NO_EXT;
4835 } else
4836 return _FALSE;
4837
4838 return _TRUE;
4839 }
4840
rtw_linked_check(_adapter * padapter)4841 sint rtw_linked_check(_adapter *padapter)
4842 {
4843 if (MLME_IS_AP(padapter) || MLME_IS_MESH(padapter)
4844 || MLME_IS_ADHOC(padapter) || MLME_IS_ADHOC_MASTER(padapter)
4845 ) {
4846 if (padapter->stapriv.asoc_sta_count > 1)
4847 return _TRUE;
4848 } else {
4849 /* Station mode */
4850 if (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE) == _TRUE)
4851 return _TRUE;
4852 }
4853 return _FALSE;
4854 }
4855 /*#define DBG_ADAPTER_STATE_CHK*/
rtw_is_adapter_up(_adapter * padapter)4856 u8 rtw_is_adapter_up(_adapter *padapter)
4857 {
4858 struct dvobj_priv *dvobj;
4859
4860 if (padapter == NULL)
4861 return _FALSE;
4862
4863 dvobj = adapter_to_dvobj(padapter);
4864
4865 if (RTW_CANNOT_RUN(dvobj)) {
4866 #ifdef DBG_ADAPTER_STATE_CHK
4867 RTW_INFO(FUNC_ADPT_FMT " FALSE -bDriverStopped(%s) bSurpriseRemoved(%s)\n"
4868 , FUNC_ADPT_ARG(padapter)
4869 , dev_is_drv_stopped(dvobj) ? "True" : "False"
4870 , dev_is_surprise_removed(dvobj) ? "True" : "False");
4871 #endif
4872 return _FALSE;
4873 }
4874
4875 if (padapter->netif_up == _FALSE) {
4876 #ifdef DBG_ADAPTER_STATE_CHK
4877 RTW_INFO(FUNC_ADPT_FMT " FALSE -(netif_up == _FALSE)\n", FUNC_ADPT_ARG(padapter));
4878 #endif
4879 return _FALSE;
4880 }
4881
4882 if (padapter->phl_role == NULL) {
4883 #ifdef DBG_ADAPTER_STATE_CHK
4884 RTW_INFO(FUNC_ADPT_FMT " FALSE -(phl_role == NULL)\n", FUNC_ADPT_ARG(padapter));
4885 #endif
4886 return _FALSE;
4887 }
4888
4889 return _TRUE;
4890 }
4891
is_miracast_enabled(_adapter * adapter)4892 bool is_miracast_enabled(_adapter *adapter)
4893 {
4894 bool enabled = 0;
4895 #ifdef CONFIG_WFD
4896 struct wifi_display_info *wfdinfo = &adapter->wfd_info;
4897
4898 enabled = (wfdinfo->stack_wfd_mode & (MIRACAST_SOURCE | MIRACAST_SINK))
4899 || (wfdinfo->op_wfd_mode & (MIRACAST_SOURCE | MIRACAST_SINK));
4900 #endif
4901
4902 return enabled;
4903 }
4904
rtw_chk_miracast_mode(_adapter * adapter,u8 mode)4905 bool rtw_chk_miracast_mode(_adapter *adapter, u8 mode)
4906 {
4907 bool ret = 0;
4908 #ifdef CONFIG_WFD
4909 struct wifi_display_info *wfdinfo = &adapter->wfd_info;
4910
4911 ret = (wfdinfo->stack_wfd_mode & mode) || (wfdinfo->op_wfd_mode & mode);
4912 #endif
4913
4914 return ret;
4915 }
4916
get_miracast_mode_str(int mode)4917 const char *get_miracast_mode_str(int mode)
4918 {
4919 if (mode == MIRACAST_SOURCE)
4920 return "SOURCE";
4921 else if (mode == MIRACAST_SINK)
4922 return "SINK";
4923 else if (mode == (MIRACAST_SOURCE | MIRACAST_SINK))
4924 return "SOURCE&SINK";
4925 else if (mode == MIRACAST_DISABLED)
4926 return "DISABLED";
4927 else
4928 return "INVALID";
4929 }
4930
4931 #ifdef CONFIG_WFD
wfd_st_match_rule(_adapter * adapter,u8 * local_naddr,u8 * local_port,u8 * remote_naddr,u8 * remote_port)4932 static bool wfd_st_match_rule(_adapter *adapter, u8 *local_naddr, u8 *local_port, u8 *remote_naddr, u8 *remote_port)
4933 {
4934 struct wifi_display_info *wfdinfo = &adapter->wfd_info;
4935
4936 if (ntohs(*((u16 *)local_port)) == wfdinfo->rtsp_ctrlport
4937 || ntohs(*((u16 *)local_port)) == wfdinfo->tdls_rtsp_ctrlport
4938 || ntohs(*((u16 *)remote_port)) == wfdinfo->peer_rtsp_ctrlport)
4939 return _TRUE;
4940 return _FALSE;
4941 }
4942
4943 static struct st_register wfd_st_reg = {
4944 .s_proto = 0x06,
4945 .rule = wfd_st_match_rule,
4946 };
4947 #endif /* CONFIG_WFD */
4948
rtw_wfd_st_switch(struct sta_info * sta,bool on)4949 inline void rtw_wfd_st_switch(struct sta_info *sta, bool on)
4950 {
4951 #ifdef CONFIG_WFD
4952 if (on)
4953 rtw_st_ctl_register(&sta->st_ctl, SESSION_TRACKER_REG_ID_WFD, &wfd_st_reg);
4954 else
4955 rtw_st_ctl_unregister(&sta->st_ctl, SESSION_TRACKER_REG_ID_WFD);
4956 #endif
4957 }
4958
dump_arp_pkt(void * sel,u8 * da,u8 * sa,u8 * arp,bool tx)4959 void dump_arp_pkt(void *sel, u8 *da, u8 *sa, u8 *arp, bool tx)
4960 {
4961 RTW_PRINT_SEL(sel, "%s ARP da="MAC_FMT", sa="MAC_FMT"\n"
4962 , tx ? "send" : "recv", MAC_ARG(da), MAC_ARG(sa));
4963 RTW_PRINT_SEL(sel, "htype=%u, ptype=0x%04x, hlen=%u, plen=%u, oper=%u\n"
4964 , GET_ARP_HTYPE(arp), GET_ARP_PTYPE(arp), GET_ARP_HLEN(arp)
4965 , GET_ARP_PLEN(arp), GET_ARP_OPER(arp));
4966 RTW_PRINT_SEL(sel, "sha="MAC_FMT", spa="IP_FMT"\n"
4967 , MAC_ARG(ARP_SENDER_MAC_ADDR(arp)), IP_ARG(ARP_SENDER_IP_ADDR(arp)));
4968 RTW_PRINT_SEL(sel, "tha="MAC_FMT", tpa="IP_FMT"\n"
4969 , MAC_ARG(ARP_TARGET_MAC_ADDR(arp)), IP_ARG(ARP_TARGET_IP_ADDR(arp)));
4970 }
4971
4972 #ifdef CONFIG_STA_CMD_DISPR
4973 /* software setting top half for connect abort */
_connect_abort_sw_top_half(struct _ADAPTER * a)4974 static void _connect_abort_sw_top_half(struct _ADAPTER *a)
4975 {
4976 cancel_link_timer(&a->mlmeextpriv);
4977 cancel_assoc_timer(&a->mlmepriv);
4978 a->mlmeextpriv.join_abort = 1;
4979 }
4980
4981 /* software setting bottom half for connect abort */
_connect_abort_sw_bottom_half(struct _ADAPTER * a)4982 static void _connect_abort_sw_bottom_half(struct _ADAPTER *a)
4983 {
4984 /* ref: rtw_joinbss_event_prehandle(), join_res == -4 */
4985 _clr_fwstate_(&a->mlmepriv, WIFI_UNDER_LINKING);
4986 rtw_reset_securitypriv(a);
4987 a->mlmeextpriv.join_abort = 0;
4988 }
4989
4990 /*
4991 * _connect_disconncet_hw - Handle hardware part of connect abort and fail
4992 * @a: struct _ADAPTER *
4993 *
4994 * Handle hardware part of connect fail.
4995 * Most implement is reference from bottom half of rtw_joinbss_event_callback()
4996 * with join_res < 0.
4997 *
4998 * Reference functions:
4999 * 1. rtw_joinbss_event_callback()
5000 * 2. rtw_set_hw_after_join(a, -1)
5001 * 3. rtw_hw_connect_abort()
5002 */
_connect_disconnect_hw(struct _ADAPTER * a)5003 static void _connect_disconnect_hw(struct _ADAPTER *a)
5004 {
5005 struct dvobj_priv *d;
5006 void *phl;
5007 u8 *mac;
5008 struct sta_info *sta;
5009
5010
5011 d = adapter_to_dvobj(a);
5012 phl = GET_PHL_INFO(d);
5013 /* ref: rtw_set_hw_after_join(a, -1) */
5014 mac = (u8*)a->mlmeextpriv.mlmext_info.network.MacAddress;
5015 sta = rtw_get_stainfo(&a->stapriv, mac);
5016 if (!sta) {
5017 RTW_ERR(FUNC_ADPT_FMT ": stainfo(" MAC_FMT ") not exist!\n",
5018 FUNC_ADPT_ARG(a), MAC_ARG(mac));
5019 return;
5020 }
5021
5022 /* bottom half of rtw_hw_connect_abort() - start */
5023 rtw_phl_chanctx_del(phl, a->phl_role, NULL);
5024 /* restore original union ch */
5025 rtw_join_done_chk_ch(a, -1);
5026 /* free connecting AP sta info */
5027 rtw_free_stainfo(a, sta);
5028 rtw_init_self_stainfo(a);
5029 /* bottom half of rtw_hw_connect_abort() - end */
5030
5031 /* bottom half of rtw_joinbss_event_callback() */
5032 rtw_mi_os_xmit_schedule(a);
5033 }
5034
_connect_abort_notify_cb(void * priv,struct phl_msg * msg)5035 static void _connect_abort_notify_cb(void *priv, struct phl_msg *msg)
5036 {
5037 struct _ADAPTER *a = (struct _ADAPTER *)priv;
5038
5039
5040 RTW_DBG(FUNC_ADPT_FMT ": connect_st=%u\n",
5041 FUNC_ADPT_ARG(a), a->connect_state);
5042
5043 _connect_disconnect_hw(a);
5044 _connect_abort_sw_bottom_half(a);
5045
5046 _rtw_spinlock(&a->connect_st_lock);
5047 if ((a->connect_state != CONNECT_ST_ACQUIRED) || !a->connect_abort) {
5048 RTW_ERR(FUNC_ADPT_FMT ": connect_st=%u, abort is %s !\n",
5049 FUNC_ADPT_ARG(a), a->connect_state,
5050 a->connect_abort?"true":"false");
5051 } else {
5052 a->connect_state = CONNECT_ST_IDLE;
5053 a->connect_abort = false;
5054 }
5055 _rtw_spinunlock(&a->connect_st_lock);
5056 }
5057
_connect_abort_notify(struct _ADAPTER * a)5058 static enum rtw_phl_status _connect_abort_notify(struct _ADAPTER *a)
5059 {
5060 struct dvobj_priv *d = adapter_to_dvobj(a);
5061 struct phl_msg msg = {0};
5062 struct phl_msg_attribute attr = {0};
5063 enum rtw_phl_status status;
5064
5065
5066 SET_MSG_MDL_ID_FIELD(msg.msg_id, PHL_FG_MDL_CONNECT);
5067 SET_MSG_EVT_ID_FIELD(msg.msg_id, MSG_EVT_DISCONNECT);
5068 msg.band_idx = a->phl_role->hw_band;
5069 msg.rsvd[0] = (u8*)a->phl_role;
5070
5071 attr.opt = MSG_OPT_SEND_IN_ABORT;
5072 attr.completion.completion = _connect_abort_notify_cb;
5073 attr.completion.priv = a;
5074
5075 status = rtw_phl_send_msg_to_dispr(GET_PHL_INFO(d), &msg, &attr, NULL);
5076 if (status != RTW_PHL_STATUS_SUCCESS)
5077 RTW_ERR(FUNC_ADPT_FMT ": send_msg_to_dispr fail(0x%x)!\n",
5078 FUNC_ADPT_ARG(a), status);
5079
5080 return status;
5081 }
5082
_connect_swch_done_notify_cb(void * priv,struct phl_msg * msg)5083 static void _connect_swch_done_notify_cb(void *priv, struct phl_msg *msg)
5084 {
5085 struct _ADAPTER *a = (struct _ADAPTER *)priv;
5086
5087
5088 RTW_DBG(FUNC_ADPT_FMT ": connect_st=%u\n",
5089 FUNC_ADPT_ARG(a), a->connect_state);
5090
5091 if (msg->inbuf) {
5092 rtw_vmfree(msg->inbuf, msg->inlen);
5093 msg->inbuf = NULL;
5094 }
5095 }
5096
_connect_swch_done_notify(struct _ADAPTER * a,struct rtw_chan_def * chandef)5097 static enum rtw_phl_status _connect_swch_done_notify(struct _ADAPTER *a,
5098 struct rtw_chan_def *chandef)
5099 {
5100 struct dvobj_priv *d = adapter_to_dvobj(a);
5101 struct phl_msg msg = {0};
5102 struct phl_msg_attribute attr = {0};
5103 u8 *info = NULL;
5104 enum rtw_phl_status status;
5105
5106
5107 info = rtw_vmalloc(sizeof(struct rtw_chan_def));
5108 if (!info) {
5109 RTW_ERR(FUNC_ADPT_FMT ": Allocate msg hub buffer fail!\n",
5110 FUNC_ADPT_ARG(a));
5111 return RTW_PHL_STATUS_RESOURCE;
5112 }
5113 _rtw_memcpy(info, chandef, sizeof(struct rtw_chan_def));
5114
5115 SET_MSG_MDL_ID_FIELD(msg.msg_id, PHL_FG_MDL_CONNECT);
5116 SET_MSG_EVT_ID_FIELD(msg.msg_id, MSG_EVT_SWCH_DONE);
5117 msg.band_idx = a->phl_role->hw_band;
5118 msg.inbuf = info;
5119 msg.inlen = sizeof(struct rtw_chan_def);
5120
5121 attr.completion.completion = _connect_swch_done_notify_cb;
5122 attr.completion.priv = a;
5123
5124 status = rtw_phl_send_msg_to_dispr(GET_PHL_INFO(d),
5125 &msg, &attr, NULL);
5126 if (status != RTW_PHL_STATUS_SUCCESS) {
5127 rtw_vmfree(info, sizeof(struct rtw_chan_def));
5128 RTW_ERR(FUNC_ADPT_FMT ": send_msg_to_dispr fail(0x%x)!\n",
5129 FUNC_ADPT_ARG(a), status);
5130 }
5131
5132 return status;
5133 }
5134
_connect_cmd_done(struct _ADAPTER * a)5135 static void _connect_cmd_done(struct _ADAPTER *a)
5136 {
5137 struct dvobj_priv *d = adapter_to_dvobj(a);
5138 struct rtw_wifi_role_t *role = a->phl_role;
5139 enum rtw_phl_status status;
5140
5141
5142 RTW_DBG(FUNC_ADPT_FMT ": +\n", FUNC_ADPT_ARG(a));
5143
5144 if (!a->connect_token){
5145 RTW_ERR(FUNC_ADPT_FMT ": token is NULL!\n", FUNC_ADPT_ARG(a));
5146 return;
5147 }
5148
5149 _rtw_spinlock(&a->connect_st_lock);
5150 status = rtw_phl_free_cmd_token(GET_PHL_INFO(d),
5151 role->hw_band, &a->connect_token);
5152 a->connect_token = 0;
5153 if (status != RTW_PHL_STATUS_SUCCESS)
5154 RTW_ERR(FUNC_ADPT_FMT ": free_cmd_token fail(0x%x)!\n",
5155 FUNC_ADPT_ARG(a), status);
5156 a->connect_state = CONNECT_ST_IDLE;
5157 a->connect_abort = false;
5158 _rtw_spinunlock(&a->connect_st_lock);
5159
5160 RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
5161 }
5162
_connect_acquired(void * dispr,void * priv)5163 static enum phl_mdl_ret_code _connect_acquired(void* dispr, void *priv)
5164 {
5165 struct _ADAPTER *a = (struct _ADAPTER *)priv;
5166 struct dvobj_priv *d = adapter_to_dvobj(a);
5167 struct _WLAN_BSSID_EX *network = &a->mlmeextpriv.mlmext_info.network;
5168
5169
5170 RTW_DBG(FUNC_ADPT_FMT ": +\n", FUNC_ADPT_ARG(a));
5171
5172 _rtw_spinlock(&a->connect_st_lock);
5173 if (a->connect_state != CONNECT_ST_REQUESTING)
5174 RTW_ERR(FUNC_ADPT_FMT ": connect_st=%u, not requesting?!\n",
5175 FUNC_ADPT_ARG(a), a->connect_state);
5176 a->connect_state = CONNECT_ST_ACQUIRED;
5177 _rtw_spinunlock(&a->connect_st_lock);
5178
5179 /*rtw_hw_prepare_connect(a, NULL, network->MacAddress);*/
5180 rtw_phl_connect_prepare(GET_PHL_INFO(d), a->phl_role,
5181 network->MacAddress);
5182
5183 RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
5184
5185 return MDL_RET_SUCCESS;
5186 }
5187
_connect_abort(void * dispr,void * priv)5188 static enum phl_mdl_ret_code _connect_abort(void* dispr, void *priv)
5189 {
5190 struct _ADAPTER *a = (struct _ADAPTER *)priv;
5191 bool inner_abort = false;
5192 enum rtw_phl_status phl_status = RTW_PHL_STATUS_FAILURE;
5193
5194
5195 RTW_DBG(FUNC_ADPT_FMT ": +\n", FUNC_ADPT_ARG(a));
5196
5197 _rtw_spinlock(&a->connect_st_lock);
5198 RTW_INFO(FUNC_ADPT_FMT ": connect_st=%u, abort is %s\n",
5199 FUNC_ADPT_ARG(a), a->connect_state,
5200 a->connect_abort?"true":"false");
5201 if (a->connect_state == CONNECT_ST_IDLE) {
5202 _rtw_spinunlock(&a->connect_st_lock);
5203 return MDL_RET_SUCCESS;
5204 }
5205 if (!a->connect_abort) {
5206 RTW_INFO(FUNC_ADPT_FMT ": framework asking abort!\n",
5207 FUNC_ADPT_ARG(a));
5208 a->connect_abort = true;
5209 inner_abort = true;
5210 }
5211 _rtw_spinunlock(&a->connect_st_lock);
5212
5213 _connect_abort_sw_top_half(a);
5214 if (inner_abort) {
5215 /* ref: rtw_join_timeout_handler() */
5216 _rtw_spinlock_bh(&a->mlmepriv.lock);
5217 a->mlmepriv.join_status = WLAN_STATUS_UNSPECIFIED_FAILURE;
5218 rtw_indicate_disconnect(a, a->mlmepriv.join_status, _FALSE);
5219 #ifdef CONFIG_IOCTL_CFG80211
5220 rtw_cfg80211_indicate_disconnect(a, a->mlmepriv.join_status, _FALSE);
5221 #endif /* CONFIG_IOCTL_CFG80211 */
5222 a->mlmepriv.join_status = 0;
5223 _rtw_spinunlock_bh(&a->mlmepriv.lock);
5224 }
5225
5226 if (a->connect_state == CONNECT_ST_ACQUIRED)
5227 phl_status = _connect_abort_notify(a);
5228 a->connect_token = 0; /* framework will free this token later */
5229 if (phl_status != RTW_PHL_STATUS_SUCCESS) {
5230 /* No callback function, everything should be done here */
5231 _connect_abort_sw_bottom_half(a);
5232 _rtw_spinlock(&a->connect_st_lock);
5233 a->connect_state = CONNECT_ST_IDLE;
5234 a->connect_abort = false;
5235 _rtw_spinunlock(&a->connect_st_lock);
5236 }
5237
5238 RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
5239
5240 return MDL_RET_SUCCESS;
5241 }
5242
_connect_msg_hdlr(void * dispr,void * priv,struct phl_msg * msg)5243 static enum phl_mdl_ret_code _connect_msg_hdlr(void* dispr, void* priv,
5244 struct phl_msg* msg)
5245 {
5246 struct _ADAPTER *a = (struct _ADAPTER *)priv;
5247 struct dvobj_priv *d = adapter_to_dvobj(a);
5248 struct rtw_wifi_role_t *role = NULL;
5249 struct _WLAN_BSSID_EX *network = &a->mlmeextpriv.mlmext_info.network;
5250 struct sta_info *sta = NULL;
5251 u8 u_ch;
5252 enum channel_width u_bw;
5253 enum chan_offset u_offset;
5254 struct phl_msg nextmsg = {0};
5255 struct phl_msg_attribute attr = {0};
5256 enum rtw_phl_status status;
5257 enum phl_mdl_ret_code mdl_err;
5258 int err;
5259 u32 res;
5260
5261
5262 RTW_INFO(FUNC_ADPT_FMT ": + msg_id=0x%08x\n",
5263 FUNC_ADPT_ARG(a), msg->msg_id);
5264
5265 if (MSG_MDL_ID_FIELD(msg->msg_id) != PHL_FG_MDL_CONNECT) {
5266 RTW_INFO(FUNC_ADPT_FMT ": Message is not from connect module, "
5267 "skip msg_id=0x%08x\n", FUNC_ADPT_ARG(a), msg->msg_id);
5268 RTW_INFO(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
5269 return MDL_RET_IGNORE;
5270 }
5271
5272 if (IS_MSG_FAIL(msg->msg_id)) {
5273 RTW_WARN(FUNC_ADPT_FMT ": cmd dispatcher notify cmd failure on "
5274 "msg_id=0x%08x\n", FUNC_ADPT_ARG(a), msg->msg_id);
5275 if (MSG_EVT_ID_FIELD(msg->msg_id) != MSG_EVT_DISCONNECT)
5276 goto send_disconnect;
5277 }
5278
5279 role = a->phl_role;
5280 SET_MSG_MDL_ID_FIELD(nextmsg.msg_id, PHL_FG_MDL_CONNECT);
5281 nextmsg.band_idx = role->hw_band;
5282
5283 switch (MSG_EVT_ID_FIELD(msg->msg_id)) {
5284 case MSG_EVT_CONNECT_START:
5285 RTW_INFO(FUNC_ADPT_FMT ": MSG_EVT_CONNECT_START\n",
5286 FUNC_ADPT_ARG(a));
5287
5288 /* ref: top half of rtw_join_cmd_hdl() */
5289
5290 sta = rtw_get_stainfo(&a->stapriv, a->phl_role->mac_addr);
5291 rtw_free_stainfo(a, sta);
5292 sta = rtw_alloc_stainfo(&a->stapriv, network->MacAddress);
5293 if (sta == NULL) {
5294 RTW_ERR(FUNC_ADPT_FMT ": alloc sta " MAC_FMT " fail!\n",
5295 FUNC_ADPT_ARG(a), MAC_ARG(network->MacAddress));
5296 rtw_init_self_stainfo(a);
5297 goto send_disconnect;
5298 }
5299
5300 /* check channel, bandwidth, offset and switch */
5301 u_ch = a->mlmeextpriv.chandef.chan;
5302 u_bw = a->mlmeextpriv.chandef.bw;
5303 u_offset = a->mlmeextpriv.chandef.offset;
5304 if (!rtw_phl_chanctx_add(GET_PHL_INFO(d), role,
5305 &u_ch, &u_bw, &u_offset))
5306 goto send_disconnect;
5307
5308 rtw_hw_update_chan_def(a);
5309 rtw_mi_update_union_chan_inf(a, u_ch, (u8)u_offset, (u8)u_bw);
5310
5311 #ifdef CONFIG_ANTENNA_DIVERSITY
5312 rtw_antenna_select_cmd(a, network->PhyInfo.Optimum_antenna, _FALSE);
5313 #endif
5314
5315 #ifdef CONFIG_80211D
5316 rtw_joinbss_update_regulatory(a, network);
5317 #endif
5318
5319 SET_MSG_EVT_ID_FIELD(nextmsg.msg_id, MSG_EVT_SWCH_START);
5320 status = rtw_phl_send_msg_to_dispr(GET_PHL_INFO(d),
5321 &nextmsg, &attr, NULL);
5322 break;
5323
5324 case MSG_EVT_SWCH_START:
5325 RTW_INFO(FUNC_ADPT_FMT ": MSG_EVT_SWCH_START\n",
5326 FUNC_ADPT_ARG(a));
5327 if (!role) {
5328 RTW_ERR(FUNC_ADPT_FMT ": role == NULL\n",
5329 FUNC_ADPT_ARG(a));
5330 break;
5331 }
5332
5333 /* ref: bottom half of rtw_join_cmd_hdl() */
5334 RTW_INFO(FUNC_ADPT_FMT ": Switch to channel before link: "
5335 "chan(%d), bw(%d), offset(%d)\n",
5336 FUNC_ADPT_ARG(a),
5337 d->iface_state.union_ch, d->iface_state.union_bw,
5338 d->iface_state.union_offset);
5339 set_channel_bwmode(a, d->iface_state.union_ch,
5340 d->iface_state.union_offset,
5341 d->iface_state.union_bw, _TRUE);
5342
5343 status = _connect_swch_done_notify(a, &role->chandef);
5344 break;
5345
5346 case MSG_EVT_SWCH_DONE:
5347 RTW_INFO(FUNC_ADPT_FMT ": MSG_EVT_SWCH_DONE\n",
5348 FUNC_ADPT_ARG(a));
5349
5350 /* ref: last part of rtw_join_cmd_hdl() */
5351 cancel_link_timer(&a->mlmeextpriv);
5352 start_clnt_join(a);
5353
5354 break;
5355
5356 case MSG_EVT_CONNECT_LINKED:
5357 RTW_INFO(FUNC_ADPT_FMT ": MSG_EVT_CONNECT_LINKED\n",
5358 FUNC_ADPT_ARG(a));
5359
5360 /* ref: top half of rtw_joinbss_event_callback() */
5361 err = rtw_set_hw_after_join(a, 0);
5362 if (err) {
5363 RTW_ERR(FUNC_ADPT_FMT ": set hardware fail(%d) during "
5364 "connecting!\n",
5365 FUNC_ADPT_ARG(a), err);
5366 goto send_disconnect;
5367 }
5368
5369 break;
5370
5371 case MSG_EVT_CONNECT_END:
5372 RTW_INFO(FUNC_ADPT_FMT ": MSG_EVT_CONNECT_END\n",
5373 FUNC_ADPT_ARG(a));
5374
5375 /* ref: bottom half of rtw_set_hw_after_join() */
5376 sta = rtw_get_stainfo(&a->stapriv, network->MacAddress);
5377 if (sta)
5378 rtw_xmit_queue_clear(sta);
5379 else
5380 RTW_ERR(FUNC_ADPT_FMT ": stainfo(" MAC_FMT ") not exist!\n",
5381 FUNC_ADPT_ARG(a), MAC_ARG(network->MacAddress));
5382
5383 /* ref: bottom half of rtw_joinbss_event_callback() */
5384 rtw_mi_os_xmit_schedule(a);
5385
5386 _connect_cmd_done(a);
5387 #ifdef CONFIG_LAYER2_ROAMING
5388 if (a->securitypriv.dot11PrivacyAlgrthm == _NO_PRIVACY_)
5389 dequeuq_roam_pkt(a);
5390 #endif
5391 break;
5392
5393 case MSG_EVT_DISCONNECT_PREPARE:
5394 RTW_WARN(FUNC_ADPT_FMT ": MSG_EVT_DISCONNECT_PREPARE\n",
5395 FUNC_ADPT_ARG(a));
5396
5397 /* STA connect fail case, top half */
5398
5399 /* top half of rtw_joinbss_event_callback() */
5400 err = rtw_set_hw_after_join(a, -1);
5401 if (err) {
5402 RTW_ERR(FUNC_ADPT_FMT ": set hardware fail(%d) during "
5403 "connect abort!\n",
5404 FUNC_ADPT_ARG(a), err);
5405 }
5406
5407 rtw_phl_disconnect(GET_PHL_INFO(d), a->phl_role, false);
5408
5409 break;
5410
5411 case MSG_EVT_DISCONNECT:
5412 RTW_WARN(FUNC_ADPT_FMT ": MSG_EVT_DISCONNECT\n",
5413 FUNC_ADPT_ARG(a));
5414
5415 /* STA connect fail case, bottom half */
5416 _connect_disconnect_hw(a);
5417
5418 _connect_cmd_done(a);
5419 break;
5420
5421 default:
5422 break;
5423 }
5424
5425 goto exit;
5426
5427 send_disconnect:
5428 /*
5429 * Trigger software handle and notify OS by rtw_joinbss_event_prehandle()
5430 * Trigger hardware handle by sending MSG_EVT_DISCONNECT
5431 */
5432 res = report_join_res(a, -4, WLAN_STATUS_UNSPECIFIED_FAILURE);
5433 if (res != _SUCCESS) {
5434 /*
5435 * Fail to send MSG_EVT_DISCONNECT_PREPARE, do jobs in
5436 * MSG_EVT_DISCONNECT_PREPARE and MSG_EVT_DISCONNECT directly
5437 * here.
5438 */
5439
5440 /* ref: rtw_set_hw_after_join(a, -1) */
5441 a->mlmepriv.wpa_phase = _FALSE;
5442 sta = rtw_get_stainfo(&a->stapriv, network->MacAddress);
5443 if (sta) {
5444 /* rtw_hw_connect_abort(a, sta) */
5445 rtw_hw_del_all_key(a, sta, PHL_CMD_DIRECTLY, 0);
5446 status = rtw_phl_cmd_update_media_status(
5447 GET_PHL_INFO(d),
5448 sta->phl_sta, NULL, false,
5449 PHL_CMD_DIRECTLY, 0);
5450 if (status != RTW_PHL_STATUS_SUCCESS) {
5451 RTW_ERR(FUNC_ADPT_FMT ": update media status "
5452 "fail(0x%x)!\n",
5453 FUNC_ADPT_ARG(a), status);
5454 }
5455 _connect_disconnect_hw(a);
5456 } else {
5457 RTW_ERR(FUNC_ADPT_FMT ": stainfo(" MAC_FMT ") not exist!\n",
5458 FUNC_ADPT_ARG(a), MAC_ARG(network->MacAddress));
5459 }
5460
5461 _connect_cmd_done(a);
5462 }
5463
5464 exit:
5465 RTW_INFO(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
5466 return MDL_RET_SUCCESS;
5467 }
5468
_connect_set_info(void * dispr,void * priv,struct phl_module_op_info * info)5469 static enum phl_mdl_ret_code _connect_set_info(void* dispr, void* priv,
5470 struct phl_module_op_info* info)
5471 {
5472 struct _ADAPTER *a = (struct _ADAPTER *)priv;
5473
5474
5475 RTW_DBG(FUNC_ADPT_FMT ": +\n", FUNC_ADPT_ARG(a));
5476 RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
5477
5478 return MDL_RET_IGNORE;
5479 }
5480
_connect_query_info(void * dispr,void * priv,struct phl_module_op_info * info)5481 static enum phl_mdl_ret_code _connect_query_info(void* dispr, void* priv,
5482 struct phl_module_op_info* info)
5483 {
5484 struct _ADAPTER *a = (struct _ADAPTER *)priv;
5485 enum phl_mdl_ret_code ret = MDL_RET_IGNORE;
5486
5487
5488 RTW_DBG(FUNC_ADPT_FMT ": +\n", FUNC_ADPT_ARG(a));
5489
5490 switch (info->op_code) {
5491 case FG_REQ_OP_GET_ROLE:
5492 info->outbuf = (u8*)a->phl_role;
5493 ret = MDL_RET_SUCCESS;
5494 break;
5495
5496 #ifdef RTW_WKARD_MRC_ISSUE_NULL_WITH_SCAN_OPS
5497 case FG_REQ_OP_GET_ISSUE_NULL_OPS:
5498 {
5499 u8 (*issue_null)(void *, u8, bool) = scan_issu_null_data_cb;
5500 info->outbuf = (u8 *)issue_null;
5501 info->outlen = 0;
5502 ret = MDL_RET_SUCCESS;
5503 }
5504 break;
5505 #endif
5506
5507 default:
5508 break;
5509 }
5510
5511 RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
5512 return ret;
5513 }
5514
rtw_connect_cmd(struct _ADAPTER * a,struct _WLAN_BSSID_EX * network)5515 enum rtw_phl_status rtw_connect_cmd(struct _ADAPTER *a,
5516 struct _WLAN_BSSID_EX *network)
5517 {
5518 struct dvobj_priv *d = adapter_to_dvobj(a);
5519 struct rtw_wifi_role_t *role = a->phl_role;
5520 struct rtw_chan_def *chdef;
5521 struct mi_state mstate = {0};
5522 struct phl_cmd_token_req *cmd_req;
5523 enum rtw_phl_status status = RTW_PHL_STATUS_FAILURE;
5524
5525
5526 RTW_DBG(FUNC_ADPT_FMT ": st=%u\n",
5527 FUNC_ADPT_ARG(a), a->connect_state);
5528
5529 _rtw_spinlock(&a->connect_st_lock);
5530
5531 if (a->connect_state != CONNECT_ST_IDLE) {
5532 status = RTW_PHL_STATUS_SUCCESS;
5533 RTW_WARN(FUNC_ADPT_FMT ": connect is on going...\n",
5534 FUNC_ADPT_ARG(a));
5535 goto exit;
5536 }
5537
5538 if ((network->IELength > MAX_IE_SZ) || (network->IELength < 2)) {
5539 status = RTW_PHL_STATUS_INVALID_PARAM;
5540 RTW_ERR(FUNC_ADPT_FMT ": invalid IE length(%u)\n",
5541 FUNC_ADPT_ARG(a), network->IELength);
5542 goto exit;
5543 }
5544
5545 /* ref: top half of rtw_join_cmd_hdl(), software only */
5546 /* Todo: disconnect before connecting */
5547 /*set_hw_before_join(a);*/
5548
5549 /* Update HT/VHT/HE CAP and chan/bw/offset to a->mlmeextpriv.mlmext_info.network */
5550 update_join_info(a, network);
5551
5552 /* check channel, bandwidth, offset and switch */
5553 chdef = &a->mlmeextpriv.chandef;
5554 if (!rtw_phl_chanctx_chk(GET_PHL_INFO(d), role,
5555 chdef->chan, chdef->bw, chdef->offset)) {
5556 /* ref: not group case in rtw_chk_start_clnt_join() */
5557 rtw_mi_status_no_self(a, &mstate);
5558 RTW_WARN(FUNC_ADPT_FMT ": channel group fail! ld_sta_num:%u, "
5559 "ap_num:%u, mesh_num:%u\n",
5560 FUNC_ADPT_ARG(a), MSTATE_STA_LD_NUM(&mstate),
5561 MSTATE_AP_NUM(&mstate), MSTATE_MESH_NUM(&mstate));
5562 if ((MSTATE_STA_LD_NUM(&mstate) + MSTATE_AP_LD_NUM(&mstate)
5563 + MSTATE_MESH_LD_NUM(&mstate)) >= 4) {
5564 status = RTW_PHL_STATUS_RESOURCE;
5565 goto exit;
5566 }
5567 rtw_mi_buddy_disconnect(a, DISCONNECTION_BY_DRIVER_DUE_TO_EACH_IFACE_CHBW_NOT_SYNC);
5568 }
5569
5570 cmd_req = &a->connect_req;
5571 cmd_req->role = role;
5572 status = rtw_phl_add_cmd_token_req(GET_PHL_INFO(d),
5573 role->hw_band,
5574 cmd_req, &a->connect_token);
5575 if ((status != RTW_PHL_STATUS_SUCCESS)
5576 && (status != RTW_PHL_STATUS_PENDING)) {
5577 RTW_ERR(FUNC_ADPT_FMT ": add_cmd_token_req fail(0x%x)!\n",
5578 FUNC_ADPT_ARG(a), status);
5579 goto exit;
5580 }
5581
5582 a->connect_state = CONNECT_ST_REQUESTING;
5583 status = RTW_PHL_STATUS_SUCCESS;
5584
5585 exit:
5586 _rtw_spinunlock(&a->connect_st_lock);
5587
5588 RTW_DBG(FUNC_ADPT_FMT ": - st=%u ret=%u\n",
5589 FUNC_ADPT_ARG(a), a->connect_state, status);
5590 return status;
5591 }
5592
rtw_connect_abort(struct _ADAPTER * a)5593 void rtw_connect_abort(struct _ADAPTER *a)
5594 {
5595 struct dvobj_priv *d = adapter_to_dvobj(a);
5596 struct rtw_wifi_role_t *role = a->phl_role;
5597 enum rtw_phl_status status;
5598
5599
5600 RTW_WARN(FUNC_ADPT_FMT ": connect_st=%u, abort=%u\n",
5601 FUNC_ADPT_ARG(a), a->connect_state, a->connect_abort);
5602 if (a->connect_state == CONNECT_ST_NOT_READY)
5603 return;
5604
5605 _rtw_spinlock(&a->connect_st_lock);
5606 if ((a->connect_state == CONNECT_ST_IDLE) || a->connect_abort) {
5607 _rtw_spinunlock(&a->connect_st_lock);
5608 return;
5609 }
5610 a->mlmepriv.wpa_phase = _FALSE;
5611 a->connect_abort = true;
5612 _rtw_spinunlock(&a->connect_st_lock);
5613
5614 status = rtw_phl_cancel_cmd_token(GET_PHL_INFO(d),
5615 role->hw_band,
5616 &a->connect_token);
5617 a->connect_token = 0;
5618 if (status != RTW_PHL_STATUS_SUCCESS) {
5619 RTW_ERR(FUNC_ADPT_FMT ": cancel_cmd_token fail(0x%x)!\n",
5620 FUNC_ADPT_ARG(a), status);
5621 /* Cancel fail, and something needed to be handled by self */
5622 /* Release connect resource (software) */
5623 _connect_abort_sw_top_half(a);
5624 _connect_abort_sw_bottom_half(a);
5625
5626 _rtw_spinlock(&a->connect_st_lock);
5627 a->connect_state = CONNECT_ST_IDLE;
5628 a->connect_abort = false;
5629 _rtw_spinunlock(&a->connect_st_lock);
5630 }
5631 }
5632
5633 #define _CONNECT_ABORT_TO_ 5000 /* unit: ms */
5634 /**
5635 * rtw_connect_abort_wait() - Abort connect FG and wait to finish
5636 * @a pointer of struct _ADAPTER
5637 *
5638 * Send cancel cmd to framework and wait connect FG to stop.
5639 *
5640 * Return 0 for connect FG already stopped, -1 for sending cancel command
5641 * fail, or -2 for waiting connect FG stop timeout.
5642 */
rtw_connect_abort_wait(struct _ADAPTER * a)5643 int rtw_connect_abort_wait(struct _ADAPTER *a)
5644 {
5645 u32 timeout = _CONNECT_ABORT_TO_;
5646 systime start_t;
5647 u32 pass_t = 0;
5648 u32 msg_i; /* message interval */
5649 u32 msg_t = 0; /* next time point to print message */
5650 int err = 0;
5651
5652
5653 if (a->connect_state == CONNECT_ST_NOT_READY)
5654 return err;
5655
5656 msg_i = timeout / 10; /* at most print 10 msg in whole waiting time */
5657 if (!msg_i)
5658 msg_i = 1;
5659
5660 _rtw_spinlock(&a->connect_st_lock);
5661 start_t = rtw_get_current_time();
5662 while (a->connect_state != CONNECT_ST_IDLE) {
5663 if (pass_t >= msg_t) {
5664 RTW_INFO(FUNC_ADPT_FMT ": connect st=%u, %u ms/%u pass...\n",
5665 FUNC_ADPT_ARG(a), a->connect_state, pass_t, timeout);
5666 msg_t += msg_i;
5667 }
5668 _rtw_spinunlock(&a->connect_st_lock);
5669
5670 pass_t = rtw_get_passing_time_ms(start_t);
5671 if (pass_t > timeout) {
5672 RTW_ERR(FUNC_ADPT_FMT ": Timeout, fail to abort connect!"
5673 " used:%u > max:%u ms\n",
5674 FUNC_ADPT_ARG(a), pass_t, timeout);
5675 err = -2; /* Timeout */
5676 _rtw_spinlock(&a->connect_st_lock);
5677 break;
5678 }
5679 rtw_connect_abort(a);
5680 rtw_msleep_os(1);
5681
5682 _rtw_spinlock(&a->connect_st_lock);
5683 }
5684 _rtw_spinunlock(&a->connect_st_lock);
5685
5686 return err;
5687 }
5688
rtw_connect_req_free(struct _ADAPTER * a)5689 void rtw_connect_req_free(struct _ADAPTER *a)
5690 {
5691 if (a->connect_state == CONNECT_ST_NOT_READY)
5692 return;
5693
5694 rtw_connect_abort_wait(a);
5695
5696 _rtw_spinlock_free(&a->connect_st_lock);
5697 /* Terminate state, lock protection is not necessary */
5698 a->connect_state = CONNECT_ST_NOT_READY;
5699 }
5700
rtw_connect_req_init(struct _ADAPTER * a)5701 void rtw_connect_req_init(struct _ADAPTER *a)
5702 {
5703 struct phl_cmd_token_req *req;
5704
5705
5706 if (a->connect_state != CONNECT_ST_NOT_READY) {
5707 RTW_WARN(FUNC_ADPT_FMT ": connect_st=%u, not NOT_READY?!\n",
5708 FUNC_ADPT_ARG(a), a->connect_state);
5709 return;
5710 }
5711
5712 _rtw_spinlock_init(&a->connect_st_lock);
5713
5714 req = &a->connect_req;
5715 req->module_id = PHL_FG_MDL_CONNECT;
5716 req->priv = a;
5717 req->role = NULL; /* a->phl_role, but role will change by time */
5718 req->acquired = _connect_acquired;
5719 req->abort = _connect_abort;
5720 req->msg_hdlr = _connect_msg_hdlr;
5721 req->set_info = _connect_set_info;
5722 req->query_info = _connect_query_info;
5723
5724 /* initialize state, lock protection is not necessary */
5725 a->connect_state = CONNECT_ST_IDLE;
5726 a->connect_abort = false;
5727 }
5728
rtw_connect_disconnect_prepare(struct _ADAPTER * a)5729 enum rtw_phl_status rtw_connect_disconnect_prepare(struct _ADAPTER *a)
5730 {
5731 struct dvobj_priv *d = adapter_to_dvobj(a);
5732 struct phl_msg msg = {0};
5733 struct phl_msg_attribute attr = {0};
5734 enum rtw_phl_status status;
5735
5736
5737 SET_MSG_MDL_ID_FIELD(msg.msg_id, PHL_FG_MDL_CONNECT);
5738 SET_MSG_EVT_ID_FIELD(msg.msg_id, MSG_EVT_DISCONNECT_PREPARE);
5739 msg.band_idx = a->phl_role->hw_band;
5740 msg.rsvd[0] = (u8*)a->phl_role;
5741
5742 status = rtw_phl_send_msg_to_dispr(GET_PHL_INFO(d), &msg, &attr, NULL);
5743 if (status != RTW_PHL_STATUS_SUCCESS)
5744 RTW_ERR(FUNC_ADPT_FMT ": send_msg_to_dispr fail(0x%x)!\n",
5745 FUNC_ADPT_ARG(a), status);
5746
5747 return status;
5748 }
5749
_disconnect_done_notify(struct _ADAPTER * a)5750 static enum rtw_phl_status _disconnect_done_notify(struct _ADAPTER *a)
5751 {
5752 struct dvobj_priv *d = adapter_to_dvobj(a);
5753 struct phl_msg msg = {0};
5754 struct phl_msg_attribute attr = {0};
5755 struct rtw_wifi_role_t *wrole = a->phl_role;
5756 enum rtw_phl_status status;
5757
5758
5759 SET_MSG_MDL_ID_FIELD(msg.msg_id, PHL_FG_MDL_DISCONNECT);
5760 SET_MSG_EVT_ID_FIELD(msg.msg_id, MSG_EVT_DISCONNECT);
5761 msg.band_idx = wrole->hw_band;
5762 msg.rsvd[0] = (u8*)wrole;
5763
5764 status = rtw_phl_send_msg_to_dispr(GET_PHL_INFO(d), &msg, &attr, NULL);
5765 if (status != RTW_PHL_STATUS_SUCCESS)
5766 RTW_ERR(FUNC_ADPT_FMT ": send_msg_to_dispr fail(0x%x)!\n",
5767 FUNC_ADPT_ARG(a), status);
5768
5769 return status;
5770 }
5771
_disconnect_free_cmdobj(struct _ADAPTER * a)5772 static void _disconnect_free_cmdobj(struct _ADAPTER *a)
5773 {
5774 struct cmd_obj *cmd;
5775
5776
5777 cmd = a->discon_cmd;
5778 if (!cmd)
5779 return;
5780
5781 _rtw_spinlock(&a->disconnect_lock);
5782
5783 a->discon_cmd = NULL;
5784
5785 if (cmd->sctx) {
5786 if (cmd->res == H2C_SUCCESS)
5787 rtw_sctx_done(&cmd->sctx);
5788 else
5789 rtw_sctx_done_err(&cmd->sctx, RTW_SCTX_DONE_CMD_ERROR);
5790 }
5791
5792 _rtw_spinunlock(&a->disconnect_lock);
5793
5794 rtw_free_cmd_obj(cmd);
5795 }
5796
_disconnect_cmd_done(struct _ADAPTER * a)5797 static void _disconnect_cmd_done(struct _ADAPTER *a)
5798 {
5799 struct dvobj_priv *d = adapter_to_dvobj(a);
5800 struct rtw_wifi_role_t *role = a->phl_role;
5801 enum rtw_phl_status status;
5802
5803
5804 RTW_DBG(FUNC_ADPT_FMT ": + token=0x%08x\n",
5805 FUNC_ADPT_ARG(a), a->disconnect_token);
5806
5807 _rtw_spinlock(&a->disconnect_lock);
5808 /* avoid to race with rtw_disconnect_abort() */
5809
5810 if (!a->disconnect_token) {
5811 RTW_WARN(FUNC_ADPT_FMT ": Others try to stop disconnect!\n",
5812 FUNC_ADPT_ARG(a));
5813 _rtw_spinunlock(&a->disconnect_lock);
5814 return;
5815 }
5816
5817 status = rtw_phl_free_cmd_token(GET_PHL_INFO(d),
5818 role->hw_band, &a->disconnect_token);
5819 if (status != RTW_PHL_STATUS_SUCCESS)
5820 RTW_ERR(FUNC_ADPT_FMT ": free_cmd_token fail(0x%x)!\n",
5821 FUNC_ADPT_ARG(a), status);
5822 a->disconnect_token = 0;
5823
5824 _rtw_spinunlock(&a->disconnect_lock);
5825
5826 _disconnect_free_cmdobj(a);
5827 }
5828
_disconnect_acquired(void * dispr,void * priv)5829 static enum phl_mdl_ret_code _disconnect_acquired(void* dispr, void *priv)
5830 {
5831 struct _ADAPTER *a = (struct _ADAPTER *)priv;
5832 struct dvobj_priv *d = adapter_to_dvobj(a);
5833
5834
5835 RTW_DBG(FUNC_ADPT_FMT ": +\n", FUNC_ADPT_ARG(a));
5836
5837 rtw_phl_disconnect(GET_PHL_INFO(d), a->phl_role, true);
5838
5839 RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
5840
5841 return MDL_RET_SUCCESS;
5842 }
5843
_disconnect_abort(void * dispr,void * priv)5844 static enum phl_mdl_ret_code _disconnect_abort(void* dispr, void *priv)
5845 {
5846 struct _ADAPTER *a = (struct _ADAPTER *)priv;
5847
5848
5849 RTW_DBG(FUNC_ADPT_FMT ": + token=0x%08x\n",
5850 FUNC_ADPT_ARG(a), a->disconnect_token);
5851
5852 /*
5853 * Framework will free disconnect token automatically after abort,
5854 * so do all in _disconnect_cmd_done() besides rtw_phl_free_cmd_token().
5855 * ref: _disconnect_cmd_done()
5856 */
5857 if (a->disconnect_token) {
5858 RTW_WARN(FUNC_ADPT_FMT ": framework asking abort!\n",
5859 FUNC_ADPT_ARG(a));
5860 a->disconnect_token = 0;
5861 }
5862
5863 _disconnect_free_cmdobj(a);
5864
5865 RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
5866
5867 return MDL_RET_SUCCESS;
5868 }
5869
_disconnect_msg_hdlr(void * dispr,void * priv,struct phl_msg * msg)5870 static enum phl_mdl_ret_code _disconnect_msg_hdlr(void* dispr, void* priv,
5871 struct phl_msg* msg)
5872 {
5873 struct _ADAPTER *a = (struct _ADAPTER *)priv;
5874 struct disconnect_parm *discon;
5875 struct stadel_event *stadel;
5876 struct _WLAN_BSSID_EX *network;
5877 u8 is_issue_deauth;
5878 u32 retry = 0;
5879 enum rtw_phl_status status = RTW_PHL_STATUS_SUCCESS;
5880
5881
5882 RTW_DBG(FUNC_ADPT_FMT ": + msg_id=0x%08x\n",
5883 FUNC_ADPT_ARG(a), msg->msg_id);
5884
5885 if (MSG_MDL_ID_FIELD(msg->msg_id) != PHL_FG_MDL_DISCONNECT) {
5886 RTW_INFO(FUNC_ADPT_FMT ": Message is not from disconnect module, "
5887 "skip msg_id=0x%08x\n", FUNC_ADPT_ARG(a), msg->msg_id);
5888 RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
5889 return MDL_RET_IGNORE;
5890 }
5891
5892 /* Whether msg fail or not */
5893 switch (MSG_EVT_ID_FIELD(msg->msg_id)) {
5894 case MSG_EVT_DISCONNECT_PREPARE:
5895 RTW_DBG(FUNC_ADPT_FMT ": MSG_EVT_DISCONNECT_PREPARE\n",
5896 FUNC_ADPT_ARG(a));
5897
5898 /*
5899 * ref: Top half of disconnect_hdl(), before and including
5900 * rtw_mlmeext_disconnect().
5901 * Note: The bottom half, after rtw_mlmeext_disconnect(),
5902 * would be put to case MSG_EVT_DISCONNECT.
5903 */
5904
5905 if ((a->discon_cmd->cmdcode == CMD_SET_MLME_EVT)
5906 #if CONFIG_DFS
5907 || IS_RADAR_DETECTED(adapter_to_rfctl(a))
5908 || adapter_to_rfctl(a)->csa_chandef.chan
5909 #endif
5910 )
5911 is_issue_deauth = 0;
5912 else
5913 is_issue_deauth = 1;
5914
5915 if (is_issue_deauth) {
5916 #ifdef CONFIG_PLATFORM_ROCKCHIPS
5917 /*
5918 * To avoid connecting to AP fail during resume process,
5919 * change retry count from 5 to 1
5920 */
5921 retry = 1;
5922 #else /* !CONFIG_PLATFORM_ROCKCHIPS */
5923 discon = (struct disconnect_parm*)a->discon_cmd->parmbuf;
5924 retry = discon->deauth_timeout_ms / 100;
5925 #endif /* !CONFIG_PLATFORM_ROCKCHIPS */
5926
5927 network = &a->mlmeextpriv.mlmext_info.network;
5928 issue_deauth_ex(a, network->MacAddress,
5929 WLAN_REASON_DEAUTH_LEAVING,
5930 retry, 100);
5931 }
5932
5933 rtw_mlmeext_disconnect(a);
5934
5935 status = _disconnect_done_notify(a);
5936 if (status == RTW_PHL_STATUS_SUCCESS)
5937 break;
5938 fallthrough;
5939 case MSG_EVT_DISCONNECT:
5940 RTW_DBG(FUNC_ADPT_FMT ": MSG_EVT_DISCONNECT\n",
5941 FUNC_ADPT_ARG(a));
5942
5943
5944 if (a->discon_cmd->cmdcode == CMD_SET_MLME_EVT) {
5945 /* EVT_DEL_STA case */
5946 /* ref: bottom half of rtw_stadel_event_callback() */
5947 stadel = (struct stadel_event*)(a->discon_cmd->parmbuf
5948 + sizeof(struct rtw_evt_header));
5949 _stadel_posthandle_sta(a, stadel);
5950 } else {
5951 rtw_free_assoc_resources(a, _TRUE);
5952 }
5953
5954 rtw_phl_disconnected_resume_hdlr(GET_PHL_INFO(adapter_to_dvobj(a)),
5955 a->phl_role);
5956 _disconnect_cmd_done(a);
5957 break;
5958
5959 default:
5960 break;
5961 }
5962
5963 RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
5964 return MDL_RET_SUCCESS;
5965 }
5966
_disconnect_set_info(void * dispr,void * priv,struct phl_module_op_info * info)5967 static enum phl_mdl_ret_code _disconnect_set_info(void* dispr, void* priv,
5968 struct phl_module_op_info* info)
5969 {
5970 struct _ADAPTER *a = (struct _ADAPTER *)priv;
5971
5972
5973 RTW_DBG(FUNC_ADPT_FMT ": +\n", FUNC_ADPT_ARG(a));
5974 RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
5975 return MDL_RET_IGNORE;
5976 }
5977
_disconnect_query_info(void * dispr,void * priv,struct phl_module_op_info * info)5978 static enum phl_mdl_ret_code _disconnect_query_info(void* dispr, void* priv,
5979 struct phl_module_op_info* info)
5980 {
5981 struct _ADAPTER *a = (struct _ADAPTER *)priv;
5982 enum phl_mdl_ret_code ret = MDL_RET_IGNORE;
5983
5984
5985 RTW_DBG(FUNC_ADPT_FMT ": +\n", FUNC_ADPT_ARG(a));
5986
5987 switch (info->op_code) {
5988 case FG_REQ_OP_GET_ROLE:
5989 info->outbuf = (u8 *)a->phl_role;
5990 ret = MDL_RET_SUCCESS;
5991 break;
5992 default:
5993 break;
5994 }
5995
5996 RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
5997 return ret;
5998 }
5999
rtw_disconnect_cmd(struct _ADAPTER * a,struct cmd_obj * pcmd)6000 enum rtw_phl_status rtw_disconnect_cmd(struct _ADAPTER *a, struct cmd_obj *pcmd)
6001 {
6002 struct dvobj_priv *d = adapter_to_dvobj(a);
6003 struct rtw_wifi_role_t *role = a->phl_role;
6004 struct rtw_evt_header *hdr;
6005 struct stadel_event *stadel;
6006 struct sta_info *sta;
6007 struct phl_cmd_token_req *cmd_req;
6008 enum rtw_phl_status phl_status = RTW_PHL_STATUS_FAILURE;
6009
6010
6011 RTW_DBG(FUNC_ADPT_FMT ": + token=0x%08x\n",
6012 FUNC_ADPT_ARG(a), a->disconnect_token);
6013
6014 if (a->disconnect_token) {
6015 RTW_WARN(FUNC_ADPT_FMT ": disconnect is on going...\n",
6016 FUNC_ADPT_ARG(a));
6017 return RTW_PHL_STATUS_FAILURE;
6018 }
6019
6020 if (pcmd->cmdcode == CMD_SET_MLME_EVT) {
6021 /* EVT_DEL_STA case */
6022 /* ref: top half of rtw_stadel_event_callback() */
6023 hdr = (struct rtw_evt_header*)pcmd->parmbuf;
6024 stadel = (struct stadel_event *)(pcmd->parmbuf + sizeof(*hdr));
6025 sta = rtw_get_stainfo(&a->stapriv, stadel->macaddr);
6026 if (!sta) {
6027 RTW_ERR(FUNC_ADPT_FMT ": stainfo(" MAC_FMT ") not exist!\n",
6028 FUNC_ADPT_ARG(a), MAC_ARG(stadel->macaddr));
6029 return RTW_PHL_STATUS_FAILURE;
6030 }
6031 rtw_wfd_st_switch(sta, 0);
6032 sta->hw_decrypted = _FALSE;
6033 }
6034
6035 a->discon_cmd = pcmd;
6036 cmd_req = &a->disconnect_req;
6037 cmd_req->role = role;
6038
6039 phl_status = rtw_phl_add_cmd_token_req(GET_PHL_INFO(d),
6040 role->hw_band,
6041 cmd_req, &a->disconnect_token);
6042 if ((phl_status != RTW_PHL_STATUS_SUCCESS)
6043 && (phl_status != RTW_PHL_STATUS_PENDING)) {
6044 RTW_WARN(FUNC_ADPT_FMT ": add_cmd_token_req fail(0x%x)!\n",
6045 FUNC_ADPT_ARG(a), phl_status);
6046 return RTW_PHL_STATUS_FAILURE;
6047 }
6048
6049 RTW_DBG(FUNC_ADPT_FMT ": - token=0x%08x\n",
6050 FUNC_ADPT_ARG(a), a->disconnect_token);
6051 return RTW_PHL_STATUS_SUCCESS;
6052 }
6053
6054 /* Wait disconnect FG to finish */
_disconnect_wait(struct _ADAPTER * a,u32 timeout)6055 static bool _disconnect_wait(struct _ADAPTER *a, u32 timeout)
6056 {
6057 struct dvobj_priv *d = adapter_to_dvobj(a);
6058 struct rtw_wifi_role_t *role = a->phl_role;
6059 systime start;
6060 u32 pass_t;
6061 u32 msg_i; /* message interval */
6062 u32 msg_t = 0; /* next time point to print message */
6063 enum rtw_phl_status status;
6064 bool terminated = false;
6065
6066
6067 RTW_DBG(FUNC_ADPT_FMT ": + token=0x%08x\n",
6068 FUNC_ADPT_ARG(a), a->disconnect_token);
6069
6070 msg_i = timeout / 10; /* at most print 10 msg in whole waiting time */
6071 if (!msg_i)
6072 msg_i = 1;
6073 start = rtw_get_current_time();
6074 do {
6075 _rtw_spinlock(&a->disconnect_lock);
6076 pass_t = rtw_get_passing_time_ms(start);
6077 if (!a->discon_cmd) {
6078 _rtw_spinunlock(&a->disconnect_lock);
6079 terminated = true;
6080 break;
6081 }
6082 _rtw_spinunlock(&a->disconnect_lock);
6083
6084 if (pass_t >= msg_t) {
6085 RTW_DBG(FUNC_ADPT_FMT ": Waiting disconnect FG, %u ms/%u pass...\n",
6086 FUNC_ADPT_ARG(a), pass_t, timeout);
6087 msg_t += msg_i;
6088 }
6089 if (pass_t > timeout) {
6090 RTW_ERR(FUNC_ADPT_FMT ": Timeout! used:%u > max:%u ms\n",
6091 FUNC_ADPT_ARG(a), pass_t, timeout);
6092 break;
6093 }
6094
6095 rtw_usleep_os(_rtw_systime_to_us(1)); /* sleep 1/HZ sec */
6096 } while (1);
6097 RTW_DBG(FUNC_ADPT_FMT ": Stop waiting disconnect FG, cost %u ms\n",
6098 FUNC_ADPT_ARG(a), pass_t);
6099
6100 exit:
6101 RTW_DBG(FUNC_ADPT_FMT ": - %s\n", FUNC_ADPT_ARG(a), terminated?"OK":"Fail!");
6102 return terminated;
6103 }
6104
6105 /**
6106 * rtw_disconnect_abort() - Send cmd to abort disconnect FG
6107 * @a pointer of struct _ADAPTER
6108 *
6109 * Send cancel cmd to framework to stop disconnect FG.
6110 *
6111 * Return 0 for sending command ok, 1 for not necessary to send command because
6112 * no disconnect FG exist, or negative status code returned from function
6113 * rtw_phl_cancel_cmd_token().
6114 */
rtw_disconnect_abort(struct _ADAPTER * a)6115 static int rtw_disconnect_abort(struct _ADAPTER *a)
6116 {
6117 struct dvobj_priv *d = adapter_to_dvobj(a);
6118 struct rtw_wifi_role_t *role = a->phl_role;
6119 u32 token;
6120 enum rtw_phl_status status;
6121 int err = 0;
6122
6123
6124 RTW_DBG(FUNC_ADPT_FMT ": + token=0x%08x\n",
6125 FUNC_ADPT_ARG(a), a->disconnect_token);
6126
6127 _rtw_spinlock(&a->disconnect_lock);
6128 /* avoid to race with _disconnect_cmd_done() */
6129
6130 if (!a->disconnect_token) {
6131 _rtw_spinunlock(&a->disconnect_lock);
6132 err = 1;
6133 goto exit;
6134 }
6135
6136 token = a->disconnect_token;
6137 status = rtw_phl_cancel_cmd_token(GET_PHL_INFO(d),
6138 role->hw_band, &token);
6139 if (status == RTW_PHL_STATUS_SUCCESS) {
6140 a->disconnect_token = 0;
6141 } else {
6142 err = -status;
6143 RTW_ERR(FUNC_ADPT_FMT ": cancel_cmd_token fail(0x%x)!\n",
6144 FUNC_ADPT_ARG(a), status);
6145 }
6146
6147 _rtw_spinunlock(&a->disconnect_lock);
6148
6149 exit:
6150 RTW_DBG(FUNC_ADPT_FMT ": - err=%d\n", FUNC_ADPT_ARG(a), err);
6151 return err;
6152 }
6153
6154 #define _DISCONNECT_ABORT_TO_ 3000 /* unit: ms */
6155 /**
6156 * rtw_disconnect_abort_wait() - Abort disconnect FG and wait to finish
6157 * @a pointer of struct _ADAPTER
6158 *
6159 * Send cancel cmd to framework and wait disconnect FG to stop.
6160 *
6161 * Return 0 for disconnect FG already stopped, -1 for sending cancel command
6162 * fail, or -2 for waiting disconnect FG stop timeout.
6163 */
rtw_disconnect_abort_wait(struct _ADAPTER * a)6164 int rtw_disconnect_abort_wait(struct _ADAPTER *a)
6165 {
6166 struct dvobj_priv *d = adapter_to_dvobj(a);
6167 struct rtw_wifi_role_t *role = a->phl_role;
6168 u32 token;
6169 enum rtw_phl_status status;
6170 int ret, err = 0;
6171
6172
6173 RTW_DBG(FUNC_ADPT_FMT ": + token=0x%08x\n",
6174 FUNC_ADPT_ARG(a), a->disconnect_token);
6175
6176 if (!a->disconnect_token)
6177 goto exit;
6178
6179 ret = rtw_disconnect_abort(a);
6180 if (ret) {
6181 if (ret < 0)
6182 err = -1; /* Fail to send cancel cmd */
6183 goto exit;
6184 }
6185
6186 if (!_disconnect_wait(a, _DISCONNECT_ABORT_TO_))
6187 err = -2; /* Timeout */
6188
6189 exit:
6190 RTW_DBG(FUNC_ADPT_FMT ": - err=%d\n", FUNC_ADPT_ARG(a), err);
6191 return err;
6192 }
6193
rtw_disconnect_req_free(struct _ADAPTER * a)6194 void rtw_disconnect_req_free(struct _ADAPTER *a)
6195 {
6196 rtw_disconnect_abort_wait(a);
6197
6198 _rtw_spinlock_free(&a->disconnect_lock);
6199 }
6200
rtw_disconnect_req_init(struct _ADAPTER * a)6201 void rtw_disconnect_req_init(struct _ADAPTER *a)
6202 {
6203 struct phl_cmd_token_req *req;
6204
6205
6206 _rtw_spinlock_init(&a->disconnect_lock);
6207
6208 req = &a->disconnect_req;
6209 req->module_id = PHL_FG_MDL_DISCONNECT;
6210 req->priv = a;
6211 req->role = NULL; /* a->phl_role, but role will change by time */
6212 req->acquired = _disconnect_acquired;
6213 req->abort = _disconnect_abort;
6214 req->msg_hdlr = _disconnect_msg_hdlr;
6215 req->set_info = _disconnect_set_info;
6216 req->query_info = _disconnect_query_info;
6217 }
6218 #endif /* CONFIG_STA_CMD_DISPR */
6219