1 /******************************************************************************
2 *
3 * Copyright(c) 2007 - 2019 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_MI_C_
16
17 #include <drv_types.h>
18 #include <hal_data.h>
19
rtw_mi_update_union_chan_inf(_adapter * adapter,u8 ch,u8 offset,u8 bw)20 void rtw_mi_update_union_chan_inf(_adapter *adapter, u8 ch, u8 offset , u8 bw)
21 {
22 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
23 struct mi_state *iface_state = &dvobj->iface_state;
24
25 iface_state->union_ch = ch;
26 iface_state->union_bw = bw;
27 iface_state->union_offset = offset;
28 }
29
30 #ifdef DBG_IFACE_STATUS
31 #ifdef CONFIG_P2P
_rtw_mi_p2p_listen_scan_chk(_adapter * adapter)32 static u8 _rtw_mi_p2p_listen_scan_chk(_adapter *adapter)
33 {
34 int i;
35 _adapter *iface;
36 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
37 u8 p2p_listen_scan_state = _FALSE;
38
39 for (i = 0; i < dvobj->iface_nums; i++) {
40 iface = dvobj->padapters[i];
41 if (rtw_p2p_chk_state(&iface->wdinfo, P2P_STATE_LISTEN) ||
42 rtw_p2p_chk_state(&iface->wdinfo, P2P_STATE_SCAN)) {
43 p2p_listen_scan_state = _TRUE;
44 break;
45 }
46 }
47 return p2p_listen_scan_state;
48 }
49 #endif
50 #endif
51
rtw_mi_stayin_union_ch_chk(_adapter * adapter)52 u8 rtw_mi_stayin_union_ch_chk(_adapter *adapter)
53 {
54 u8 rst = _TRUE;
55 u8 u_ch, u_bw, u_offset;
56 u8 o_ch, o_bw, o_offset;
57
58 u_ch = rtw_mi_get_union_chan(adapter);
59 u_bw = rtw_mi_get_union_bw(adapter);
60 u_offset = rtw_mi_get_union_offset(adapter);
61
62 o_ch = rtw_get_oper_ch(adapter);
63 o_bw = rtw_get_oper_bw(adapter);
64 o_offset = rtw_get_oper_choffset(adapter);
65
66 if ((u_ch != o_ch) || (u_bw != o_bw) || (u_offset != o_offset))
67 rst = _FALSE;
68
69 #ifdef DBG_IFACE_STATUS
70 if (rst == _FALSE) {
71 RTW_ERR("%s Not stay in union channel\n", __func__);
72 if (GET_HAL_DATA(adapter)->bScanInProcess == _TRUE)
73 RTW_ERR("ScanInProcess\n");
74 #ifdef CONFIG_P2P
75 if (_rtw_mi_p2p_listen_scan_chk(adapter))
76 RTW_ERR("P2P in listen or scan state\n");
77 #endif
78 RTW_ERR("union ch, bw, offset: %u,%u,%u\n", u_ch, u_bw, u_offset);
79 RTW_ERR("oper ch, bw, offset: %u,%u,%u\n", o_ch, o_bw, o_offset);
80 RTW_ERR("=========================\n");
81 }
82 #endif
83 return rst;
84 }
85
rtw_mi_stayin_union_band_chk(_adapter * adapter)86 u8 rtw_mi_stayin_union_band_chk(_adapter *adapter)
87 {
88 u8 rst = _TRUE;
89 u8 u_ch, o_ch;
90 u8 u_band, o_band;
91
92 u_ch = rtw_mi_get_union_chan(adapter);
93 o_ch = rtw_get_oper_ch(adapter);
94 u_band = (u_ch > 14) ? BAND_ON_5G : BAND_ON_2_4G;
95 o_band = (o_ch > 14) ? BAND_ON_5G : BAND_ON_2_4G;
96
97 if (u_ch != o_ch)
98 if(u_band != o_band)
99 rst = _FALSE;
100
101 #ifdef DBG_IFACE_STATUS
102 if (rst == _FALSE)
103 RTW_ERR("%s Not stay in union band\n", __func__);
104 #endif
105
106 return rst;
107 }
108
109 /* Find union about ch, bw, ch_offset of all linked/linking interfaces */
rtw_mi_get_ch_setting_union_by_ifbmp(struct dvobj_priv * dvobj,u8 ifbmp,u8 * ch,u8 * bw,u8 * offset)110 int rtw_mi_get_ch_setting_union_by_ifbmp(struct dvobj_priv *dvobj, u8 ifbmp, u8 *ch, u8 *bw, u8 *offset)
111 {
112 _adapter *iface;
113 struct mlme_ext_priv *mlmeext;
114 int i;
115 u8 ch_ret = 0;
116 u8 bw_ret = CHANNEL_WIDTH_20;
117 u8 offset_ret = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
118 int num = 0;
119
120 if (ch)
121 *ch = 0;
122 if (bw)
123 *bw = CHANNEL_WIDTH_20;
124 if (offset)
125 *offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
126
127 for (i = 0; i < dvobj->iface_nums; i++) {
128 iface = dvobj->padapters[i];
129 if (!iface || !(ifbmp & BIT(iface->iface_id)))
130 continue;
131
132 mlmeext = &iface->mlmeextpriv;
133
134 if (!check_fwstate(&iface->mlmepriv, WIFI_ASOC_STATE | WIFI_UNDER_LINKING))
135 continue;
136
137 if (check_fwstate(&iface->mlmepriv, WIFI_OP_CH_SWITCHING))
138 continue;
139
140 if (num == 0) {
141 ch_ret = mlmeext->cur_channel;
142 bw_ret = mlmeext->cur_bwmode;
143 offset_ret = mlmeext->cur_ch_offset;
144 num++;
145 continue;
146 }
147
148 if (ch_ret != mlmeext->cur_channel) {
149 num = 0;
150 break;
151 }
152
153 if (bw_ret < mlmeext->cur_bwmode) {
154 bw_ret = mlmeext->cur_bwmode;
155 offset_ret = mlmeext->cur_ch_offset;
156 } else if (bw_ret == mlmeext->cur_bwmode && offset_ret != mlmeext->cur_ch_offset) {
157 num = 0;
158 break;
159 }
160
161 num++;
162 }
163
164 if (num) {
165 if (ch)
166 *ch = ch_ret;
167 if (bw)
168 *bw = bw_ret;
169 if (offset)
170 *offset = offset_ret;
171 }
172
173 return num;
174 }
175
rtw_mi_get_ch_setting_union(_adapter * adapter,u8 * ch,u8 * bw,u8 * offset)176 inline int rtw_mi_get_ch_setting_union(_adapter *adapter, u8 *ch, u8 *bw, u8 *offset)
177 {
178 return rtw_mi_get_ch_setting_union_by_ifbmp(adapter_to_dvobj(adapter), 0xFF, ch, bw, offset);
179 }
180
rtw_mi_get_ch_setting_union_no_self(_adapter * adapter,u8 * ch,u8 * bw,u8 * offset)181 inline int rtw_mi_get_ch_setting_union_no_self(_adapter *adapter, u8 *ch, u8 *bw, u8 *offset)
182 {
183 return rtw_mi_get_ch_setting_union_by_ifbmp(adapter_to_dvobj(adapter), 0xFF & ~BIT(adapter->iface_id), ch, bw, offset);
184 }
185
186 /* For now, not return union_ch/bw/offset */
rtw_mi_status_by_ifbmp(struct dvobj_priv * dvobj,u8 ifbmp,struct mi_state * mstate)187 void rtw_mi_status_by_ifbmp(struct dvobj_priv *dvobj, u8 ifbmp, struct mi_state *mstate)
188 {
189 _adapter *iface;
190 int i;
191
192 _rtw_memset(mstate, 0, sizeof(struct mi_state));
193
194 for (i = 0; i < dvobj->iface_nums; i++) {
195 iface = dvobj->padapters[i];
196 if (!iface || !(ifbmp & BIT(iface->iface_id)))
197 continue;
198
199 if (check_fwstate(&iface->mlmepriv, WIFI_STATION_STATE) == _TRUE) {
200 MSTATE_STA_NUM(mstate)++;
201 if (check_fwstate(&iface->mlmepriv, WIFI_ASOC_STATE) == _TRUE) {
202 MSTATE_STA_LD_NUM(mstate)++;
203
204 #ifdef CONFIG_TDLS
205 if (iface->tdlsinfo.link_established == _TRUE)
206 MSTATE_TDLS_LD_NUM(mstate)++;
207 #endif
208 #ifdef CONFIG_P2P
209 if (MLME_IS_GC(iface))
210 MSTATE_P2P_GC_NUM(mstate)++;
211 #endif
212 }
213 if (check_fwstate(&iface->mlmepriv, WIFI_UNDER_LINKING) == _TRUE)
214 MSTATE_STA_LG_NUM(mstate)++;
215
216 #ifdef CONFIG_AP_MODE
217 } else if (check_fwstate(&iface->mlmepriv, WIFI_AP_STATE) == _TRUE ) {
218 if (check_fwstate(&iface->mlmepriv, WIFI_ASOC_STATE) == _TRUE) {
219 MSTATE_AP_NUM(mstate)++;
220 if (iface->stapriv.asoc_sta_count > 2)
221 MSTATE_AP_LD_NUM(mstate)++;
222 #ifdef CONFIG_P2P
223 if (MLME_IS_GO(iface))
224 MSTATE_P2P_GO_NUM(mstate)++;
225 #endif
226 } else
227 MSTATE_AP_STARTING_NUM(mstate)++;
228 #endif
229
230 } else if (check_fwstate(&iface->mlmepriv, WIFI_ADHOC_STATE | WIFI_ADHOC_MASTER_STATE) == _TRUE
231 && check_fwstate(&iface->mlmepriv, WIFI_ASOC_STATE) == _TRUE
232 ) {
233 MSTATE_ADHOC_NUM(mstate)++;
234 if (iface->stapriv.asoc_sta_count > 2)
235 MSTATE_ADHOC_LD_NUM(mstate)++;
236
237 #ifdef CONFIG_RTW_MESH
238 } else if (check_fwstate(&iface->mlmepriv, WIFI_MESH_STATE) == _TRUE
239 && check_fwstate(&iface->mlmepriv, WIFI_ASOC_STATE) == _TRUE
240 ) {
241 MSTATE_MESH_NUM(mstate)++;
242 if (iface->stapriv.asoc_sta_count > 2)
243 MSTATE_MESH_LD_NUM(mstate)++;
244 #endif
245
246 }
247
248 if (check_fwstate(&iface->mlmepriv, WIFI_UNDER_WPS) == _TRUE)
249 MSTATE_WPS_NUM(mstate)++;
250
251 if (check_fwstate(&iface->mlmepriv, WIFI_UNDER_SURVEY) == _TRUE) {
252 MSTATE_SCAN_NUM(mstate)++;
253
254 if (mlmeext_scan_state(&iface->mlmeextpriv) != SCAN_DISABLE
255 && mlmeext_scan_state(&iface->mlmeextpriv) != SCAN_BACK_OP)
256 MSTATE_SCAN_ENTER_NUM(mstate)++;
257 }
258
259 #ifdef CONFIG_IOCTL_CFG80211
260 if (rtw_cfg80211_get_is_mgmt_tx(iface))
261 MSTATE_MGMT_TX_NUM(mstate)++;
262
263 if (rtw_cfg80211_get_is_roch(iface) == _TRUE)
264 MSTATE_ROCH_NUM(mstate)++;
265
266 #endif /* CONFIG_IOCTL_CFG80211 */
267 #ifdef CONFIG_P2P
268 if (MLME_IS_PD(iface))
269 MSTATE_P2P_DV_NUM(mstate)++;
270 #endif
271 }
272 }
273
rtw_mi_status(_adapter * adapter,struct mi_state * mstate)274 inline void rtw_mi_status(_adapter *adapter, struct mi_state *mstate)
275 {
276 return rtw_mi_status_by_ifbmp(adapter_to_dvobj(adapter), 0xFF, mstate);
277 }
278
rtw_mi_status_no_self(_adapter * adapter,struct mi_state * mstate)279 inline void rtw_mi_status_no_self(_adapter *adapter, struct mi_state *mstate)
280 {
281 return rtw_mi_status_by_ifbmp(adapter_to_dvobj(adapter), 0xFF & ~BIT(adapter->iface_id), mstate);
282 }
283
rtw_mi_status_no_others(_adapter * adapter,struct mi_state * mstate)284 inline void rtw_mi_status_no_others(_adapter *adapter, struct mi_state *mstate)
285 {
286 return rtw_mi_status_by_ifbmp(adapter_to_dvobj(adapter), BIT(adapter->iface_id), mstate);
287 }
288
289 /* For now, not handle union_ch/bw/offset */
rtw_mi_status_merge(struct mi_state * d,struct mi_state * a)290 inline void rtw_mi_status_merge(struct mi_state *d, struct mi_state *a)
291 {
292 d->sta_num += a->sta_num;
293 d->ld_sta_num += a->ld_sta_num;
294 d->lg_sta_num += a->lg_sta_num;
295 #ifdef CONFIG_TDLS
296 d->ld_tdls_num += a->ld_tdls_num;
297 #endif
298 #ifdef CONFIG_AP_MODE
299 d->ap_num += a->ap_num;
300 d->ld_ap_num += a->ld_ap_num;
301 #endif
302 d->adhoc_num += a->adhoc_num;
303 d->ld_adhoc_num += a->ld_adhoc_num;
304 #ifdef CONFIG_RTW_MESH
305 d->mesh_num += a->mesh_num;
306 d->ld_mesh_num += a->ld_mesh_num;
307 #endif
308 d->scan_num += a->scan_num;
309 d->scan_enter_num += a->scan_enter_num;
310 d->uwps_num += a->uwps_num;
311 #ifdef CONFIG_IOCTL_CFG80211
312 #ifdef CONFIG_P2P
313 d->roch_num += a->roch_num;
314 #endif
315 d->mgmt_tx_num += a->mgmt_tx_num;
316 #endif
317 }
318
dump_mi_status(void * sel,struct dvobj_priv * dvobj)319 void dump_mi_status(void *sel, struct dvobj_priv *dvobj)
320 {
321 RTW_PRINT_SEL(sel, "== dvobj-iface_state ==\n");
322 RTW_PRINT_SEL(sel, "sta_num:%d\n", DEV_STA_NUM(dvobj));
323 RTW_PRINT_SEL(sel, "linking_sta_num:%d\n", DEV_STA_LG_NUM(dvobj));
324 RTW_PRINT_SEL(sel, "linked_sta_num:%d\n", DEV_STA_LD_NUM(dvobj));
325 #ifdef CONFIG_TDLS
326 RTW_PRINT_SEL(sel, "linked_tdls_num:%d\n", DEV_TDLS_LD_NUM(dvobj));
327 #endif
328 #ifdef CONFIG_AP_MODE
329 RTW_PRINT_SEL(sel, "ap_num:%d\n", DEV_AP_NUM(dvobj));
330 RTW_PRINT_SEL(sel, "starting_ap_num:%d\n", DEV_AP_STARTING_NUM(dvobj));
331 RTW_PRINT_SEL(sel, "linked_ap_num:%d\n", DEV_AP_LD_NUM(dvobj));
332 #endif
333 RTW_PRINT_SEL(sel, "adhoc_num:%d\n", DEV_ADHOC_NUM(dvobj));
334 RTW_PRINT_SEL(sel, "linked_adhoc_num:%d\n", DEV_ADHOC_LD_NUM(dvobj));
335 #ifdef CONFIG_RTW_MESH
336 RTW_PRINT_SEL(sel, "mesh_num:%d\n", DEV_MESH_NUM(dvobj));
337 RTW_PRINT_SEL(sel, "linked_mesh_num:%d\n", DEV_MESH_LD_NUM(dvobj));
338 #endif
339 #ifdef CONFIG_P2P
340 RTW_PRINT_SEL(sel, "p2p_device_num:%d\n", DEV_P2P_DV_NUM(dvobj));
341 RTW_PRINT_SEL(sel, "p2p_gc_num:%d\n", DEV_P2P_GC_NUM(dvobj));
342 RTW_PRINT_SEL(sel, "p2p_go_num:%d\n", DEV_P2P_GO_NUM(dvobj));
343 #endif
344 RTW_PRINT_SEL(sel, "scan_num:%d\n", DEV_SCAN_NUM(dvobj));
345 RTW_PRINT_SEL(sel, "under_wps_num:%d\n", DEV_WPS_NUM(dvobj));
346 #if defined(CONFIG_IOCTL_CFG80211)
347 #if defined(CONFIG_P2P)
348 RTW_PRINT_SEL(sel, "roch_num:%d\n", DEV_ROCH_NUM(dvobj));
349 #endif
350 RTW_PRINT_SEL(sel, "mgmt_tx_num:%d\n", DEV_MGMT_TX_NUM(dvobj));
351 #endif
352 RTW_PRINT_SEL(sel, "union_ch:%d\n", DEV_U_CH(dvobj));
353 RTW_PRINT_SEL(sel, "union_bw:%d\n", DEV_U_BW(dvobj));
354 RTW_PRINT_SEL(sel, "union_offset:%d\n", DEV_U_OFFSET(dvobj));
355 RTW_PRINT_SEL(sel, "================\n\n");
356 }
357
dump_dvobj_mi_status(void * sel,const char * fun_name,_adapter * adapter)358 void dump_dvobj_mi_status(void *sel, const char *fun_name, _adapter *adapter)
359 {
360 RTW_INFO("\n[ %s ] call %s\n", fun_name, __func__);
361 dump_mi_status(sel, adapter_to_dvobj(adapter));
362 }
363
rtw_mi_update_iface_status(struct mlme_priv * pmlmepriv,sint state)364 inline void rtw_mi_update_iface_status(struct mlme_priv *pmlmepriv, sint state)
365 {
366 _adapter *adapter = container_of(pmlmepriv, _adapter, mlmepriv);
367 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
368 struct mi_state *iface_state = &dvobj->iface_state;
369 struct mi_state tmp_mstate;
370 u8 u_ch, u_offset, u_bw;
371
372 if (state == WIFI_MONITOR_STATE
373 || state == 0xFFFFFFFF
374 )
375 return;
376
377 if (0)
378 RTW_INFO("%s => will change or clean state to 0x%08x\n", __func__, state);
379
380 rtw_mi_status(adapter, &tmp_mstate);
381 _rtw_memcpy(iface_state, &tmp_mstate, sizeof(struct mi_state));
382
383 if (rtw_mi_get_ch_setting_union(adapter, &u_ch, &u_bw, &u_offset))
384 rtw_mi_update_union_chan_inf(adapter , u_ch, u_offset , u_bw);
385 else {
386 if (0) {
387 dump_adapters_status(RTW_DBGDUMP , dvobj);
388 RTW_INFO("%s-[ERROR] cannot get union channel\n", __func__);
389 rtw_warn_on(1);
390 }
391 }
392
393 #ifdef DBG_IFACE_STATUS
394 DBG_IFACE_STATUS_DUMP(adapter);
395 #endif
396 }
rtw_mi_check_status(_adapter * adapter,u8 type)397 u8 rtw_mi_check_status(_adapter *adapter, u8 type)
398 {
399 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
400 struct mi_state *iface_state = &dvobj->iface_state;
401 u8 ret = _FALSE;
402
403 #ifdef DBG_IFACE_STATUS
404 DBG_IFACE_STATUS_DUMP(adapter);
405 RTW_INFO("%s-"ADPT_FMT" check type:%d\n", __func__, ADPT_ARG(adapter), type);
406 #endif
407
408 switch (type) {
409 case MI_LINKED:
410 if (MSTATE_STA_LD_NUM(iface_state) || MSTATE_AP_NUM(iface_state) || MSTATE_ADHOC_NUM(iface_state) || MSTATE_MESH_NUM(iface_state)) /*check_fwstate(&iface->mlmepriv, WIFI_ASOC_STATE)*/
411 ret = _TRUE;
412 break;
413 case MI_ASSOC:
414 if (MSTATE_STA_LD_NUM(iface_state) || MSTATE_AP_LD_NUM(iface_state) || MSTATE_ADHOC_LD_NUM(iface_state) || MSTATE_MESH_LD_NUM(iface_state))
415 ret = _TRUE;
416 break;
417 case MI_UNDER_WPS:
418 if (MSTATE_WPS_NUM(iface_state))
419 ret = _TRUE;
420 break;
421
422 case MI_AP_MODE:
423 if (MSTATE_AP_NUM(iface_state))
424 ret = _TRUE;
425 break;
426 case MI_AP_ASSOC:
427 if (MSTATE_AP_LD_NUM(iface_state))
428 ret = _TRUE;
429 break;
430
431 case MI_ADHOC:
432 if (MSTATE_ADHOC_NUM(iface_state))
433 ret = _TRUE;
434 break;
435 case MI_ADHOC_ASSOC:
436 if (MSTATE_ADHOC_LD_NUM(iface_state))
437 ret = _TRUE;
438 break;
439
440 #ifdef CONFIG_RTW_MESH
441 case MI_MESH:
442 if (MSTATE_MESH_NUM(iface_state))
443 ret = _TRUE;
444 break;
445 case MI_MESH_ASSOC:
446 if (MSTATE_MESH_LD_NUM(iface_state))
447 ret = _TRUE;
448 break;
449 #endif
450
451 case MI_STA_NOLINK: /* this is misleading, but not used now */
452 if (MSTATE_STA_NUM(iface_state) && (!(MSTATE_STA_LD_NUM(iface_state) || MSTATE_STA_LG_NUM(iface_state))))
453 ret = _TRUE;
454 break;
455 case MI_STA_LINKED:
456 if (MSTATE_STA_LD_NUM(iface_state))
457 ret = _TRUE;
458 break;
459 case MI_STA_LINKING:
460 if (MSTATE_STA_LG_NUM(iface_state))
461 ret = _TRUE;
462 break;
463
464 default:
465 break;
466 }
467 return ret;
468 }
469
470 /*
471 * return value : 0 is failed or have not interface meet condition
472 * return value : !0 is success or interface numbers which meet condition
473 * return value of ops_func must be _TRUE or _FALSE
474 */
_rtw_mi_process(_adapter * padapter,bool exclude_self,void * data,u8 (* ops_func)(_adapter * padapter,void * data))475 static u8 _rtw_mi_process(_adapter *padapter, bool exclude_self,
476 void *data, u8(*ops_func)(_adapter *padapter, void *data))
477 {
478 int i;
479 _adapter *iface;
480 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
481
482 u8 ret = 0;
483
484 for (i = 0; i < dvobj->iface_nums; i++) {
485 iface = dvobj->padapters[i];
486 if ((iface) && rtw_is_adapter_up(iface)) {
487
488 if ((exclude_self) && (iface == padapter))
489 continue;
490
491 if (ops_func)
492 if (_TRUE == ops_func(iface, data))
493 ret++;
494 }
495 }
496 return ret;
497 }
_rtw_mi_process_without_schk(_adapter * padapter,bool exclude_self,void * data,u8 (* ops_func)(_adapter * padapter,void * data))498 static u8 _rtw_mi_process_without_schk(_adapter *padapter, bool exclude_self,
499 void *data, u8(*ops_func)(_adapter *padapter, void *data))
500 {
501 int i;
502 _adapter *iface;
503 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
504
505 u8 ret = 0;
506
507 for (i = 0; i < dvobj->iface_nums; i++) {
508 iface = dvobj->padapters[i];
509 if (iface) {
510 if ((exclude_self) && (iface == padapter))
511 continue;
512
513 if (ops_func)
514 if (ops_func(iface, data) == _TRUE)
515 ret++;
516 }
517 }
518 return ret;
519 }
520
_rtw_mi_netif_caroff_qstop(_adapter * padapter,void * data)521 static u8 _rtw_mi_netif_caroff_qstop(_adapter *padapter, void *data)
522 {
523 struct net_device *pnetdev = padapter->pnetdev;
524
525 rtw_netif_carrier_off(pnetdev);
526 rtw_netif_stop_queue(pnetdev);
527 return _TRUE;
528 }
rtw_mi_netif_caroff_qstop(_adapter * padapter)529 u8 rtw_mi_netif_caroff_qstop(_adapter *padapter)
530 {
531 return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_netif_caroff_qstop);
532 }
rtw_mi_buddy_netif_caroff_qstop(_adapter * padapter)533 u8 rtw_mi_buddy_netif_caroff_qstop(_adapter *padapter)
534 {
535 return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_netif_caroff_qstop);
536 }
537
_rtw_mi_netif_caron_qstart(_adapter * padapter,void * data)538 static u8 _rtw_mi_netif_caron_qstart(_adapter *padapter, void *data)
539 {
540 struct net_device *pnetdev = padapter->pnetdev;
541
542 rtw_netif_carrier_on(pnetdev);
543 rtw_netif_start_queue(pnetdev);
544 return _TRUE;
545 }
rtw_mi_netif_caron_qstart(_adapter * padapter)546 u8 rtw_mi_netif_caron_qstart(_adapter *padapter)
547 {
548 return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_netif_caron_qstart);
549 }
rtw_mi_buddy_netif_caron_qstart(_adapter * padapter)550 u8 rtw_mi_buddy_netif_caron_qstart(_adapter *padapter)
551 {
552 return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_netif_caron_qstart);
553 }
554
_rtw_mi_netif_stop_queue(_adapter * padapter,void * data)555 static u8 _rtw_mi_netif_stop_queue(_adapter *padapter, void *data)
556 {
557 struct net_device *pnetdev = padapter->pnetdev;
558
559 rtw_netif_stop_queue(pnetdev);
560 return _TRUE;
561 }
rtw_mi_netif_stop_queue(_adapter * padapter)562 u8 rtw_mi_netif_stop_queue(_adapter *padapter)
563 {
564 return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_netif_stop_queue);
565 }
rtw_mi_buddy_netif_stop_queue(_adapter * padapter)566 u8 rtw_mi_buddy_netif_stop_queue(_adapter *padapter)
567 {
568 return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_netif_stop_queue);
569 }
570
_rtw_mi_netif_wake_queue(_adapter * padapter,void * data)571 static u8 _rtw_mi_netif_wake_queue(_adapter *padapter, void *data)
572 {
573 struct net_device *pnetdev = padapter->pnetdev;
574
575 if (pnetdev)
576 rtw_netif_wake_queue(pnetdev);
577 return _TRUE;
578 }
rtw_mi_netif_wake_queue(_adapter * padapter)579 u8 rtw_mi_netif_wake_queue(_adapter *padapter)
580 {
581 return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_netif_wake_queue);
582 }
rtw_mi_buddy_netif_wake_queue(_adapter * padapter)583 u8 rtw_mi_buddy_netif_wake_queue(_adapter *padapter)
584 {
585 return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_netif_wake_queue);
586 }
587
_rtw_mi_netif_carrier_on(_adapter * padapter,void * data)588 static u8 _rtw_mi_netif_carrier_on(_adapter *padapter, void *data)
589 {
590 struct net_device *pnetdev = padapter->pnetdev;
591
592 if (pnetdev)
593 rtw_netif_carrier_on(pnetdev);
594 return _TRUE;
595 }
rtw_mi_netif_carrier_on(_adapter * padapter)596 u8 rtw_mi_netif_carrier_on(_adapter *padapter)
597 {
598 return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_netif_carrier_on);
599 }
rtw_mi_buddy_netif_carrier_on(_adapter * padapter)600 u8 rtw_mi_buddy_netif_carrier_on(_adapter *padapter)
601 {
602 return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_netif_carrier_on);
603 }
604
_rtw_mi_netif_carrier_off(_adapter * padapter,void * data)605 static u8 _rtw_mi_netif_carrier_off(_adapter *padapter, void *data)
606 {
607 struct net_device *pnetdev = padapter->pnetdev;
608
609 if (pnetdev)
610 rtw_netif_carrier_off(pnetdev);
611 return _TRUE;
612 }
rtw_mi_netif_carrier_off(_adapter * padapter)613 u8 rtw_mi_netif_carrier_off(_adapter *padapter)
614 {
615 return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_netif_carrier_off);
616 }
rtw_mi_buddy_netif_carrier_off(_adapter * padapter)617 u8 rtw_mi_buddy_netif_carrier_off(_adapter *padapter)
618 {
619 return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_netif_carrier_off);
620 }
621
_rtw_mi_scan_abort(_adapter * adapter,void * data)622 static u8 _rtw_mi_scan_abort(_adapter *adapter, void *data)
623 {
624 bool bwait = *(bool *)data;
625
626 if (bwait)
627 rtw_scan_abort(adapter);
628 else
629 rtw_scan_abort_no_wait(adapter);
630
631 return _TRUE;
632 }
rtw_mi_scan_abort(_adapter * adapter,bool bwait)633 void rtw_mi_scan_abort(_adapter *adapter, bool bwait)
634 {
635 bool in_data = bwait;
636
637 _rtw_mi_process(adapter, _FALSE, &in_data, _rtw_mi_scan_abort);
638
639 }
rtw_mi_buddy_scan_abort(_adapter * adapter,bool bwait)640 void rtw_mi_buddy_scan_abort(_adapter *adapter, bool bwait)
641 {
642 bool in_data = bwait;
643
644 _rtw_mi_process(adapter, _TRUE, &in_data, _rtw_mi_scan_abort);
645 }
646
_rtw_mi_start_drv_threads(_adapter * adapter,bool exclude_self)647 static u32 _rtw_mi_start_drv_threads(_adapter *adapter, bool exclude_self)
648 {
649 int i;
650 _adapter *iface = NULL;
651 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
652 u32 _status = _SUCCESS;
653
654 for (i = 0; i < dvobj->iface_nums; i++) {
655 iface = dvobj->padapters[i];
656 if (iface) {
657 if ((exclude_self) && (iface == adapter))
658 continue;
659 if (rtw_start_drv_threads(iface) == _FAIL) {
660 _status = _FAIL;
661 break;
662 }
663 }
664 }
665 return _status;
666 }
rtw_mi_start_drv_threads(_adapter * adapter)667 u32 rtw_mi_start_drv_threads(_adapter *adapter)
668 {
669 return _rtw_mi_start_drv_threads(adapter, _FALSE);
670 }
rtw_mi_buddy_start_drv_threads(_adapter * adapter)671 u32 rtw_mi_buddy_start_drv_threads(_adapter *adapter)
672 {
673 return _rtw_mi_start_drv_threads(adapter, _TRUE);
674 }
675
_rtw_mi_stop_drv_threads(_adapter * adapter,bool exclude_self)676 static void _rtw_mi_stop_drv_threads(_adapter *adapter, bool exclude_self)
677 {
678 int i;
679 _adapter *iface = NULL;
680 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
681
682 for (i = 0; i < dvobj->iface_nums; i++) {
683 iface = dvobj->padapters[i];
684 if (iface) {
685 if ((exclude_self) && (iface == adapter))
686 continue;
687 rtw_stop_drv_threads(iface);
688 }
689 }
690 }
rtw_mi_stop_drv_threads(_adapter * adapter)691 void rtw_mi_stop_drv_threads(_adapter *adapter)
692 {
693 _rtw_mi_stop_drv_threads(adapter, _FALSE);
694 }
rtw_mi_buddy_stop_drv_threads(_adapter * adapter)695 void rtw_mi_buddy_stop_drv_threads(_adapter *adapter)
696 {
697 _rtw_mi_stop_drv_threads(adapter, _TRUE);
698 }
699
_rtw_mi_cancel_all_timer(_adapter * adapter,void * data)700 static u8 _rtw_mi_cancel_all_timer(_adapter *adapter, void *data)
701 {
702 rtw_cancel_all_timer(adapter);
703 return _TRUE;
704 }
rtw_mi_cancel_all_timer(_adapter * adapter)705 void rtw_mi_cancel_all_timer(_adapter *adapter)
706 {
707 _rtw_mi_process(adapter, _FALSE, NULL, _rtw_mi_cancel_all_timer);
708 }
rtw_mi_buddy_cancel_all_timer(_adapter * adapter)709 void rtw_mi_buddy_cancel_all_timer(_adapter *adapter)
710 {
711 _rtw_mi_process(adapter, _TRUE, NULL, _rtw_mi_cancel_all_timer);
712 }
713
_rtw_mi_reset_drv_sw(_adapter * adapter,void * data)714 static u8 _rtw_mi_reset_drv_sw(_adapter *adapter, void *data)
715 {
716 rtw_reset_drv_sw(adapter);
717 return _TRUE;
718 }
rtw_mi_reset_drv_sw(_adapter * adapter)719 void rtw_mi_reset_drv_sw(_adapter *adapter)
720 {
721 _rtw_mi_process_without_schk(adapter, _FALSE, NULL, _rtw_mi_reset_drv_sw);
722 }
rtw_mi_buddy_reset_drv_sw(_adapter * adapter)723 void rtw_mi_buddy_reset_drv_sw(_adapter *adapter)
724 {
725 _rtw_mi_process_without_schk(adapter, _TRUE, NULL, _rtw_mi_reset_drv_sw);
726 }
727
_rtw_mi_intf_start(_adapter * adapter,void * data)728 static u8 _rtw_mi_intf_start(_adapter *adapter, void *data)
729 {
730 rtw_intf_start(adapter);
731 return _TRUE;
732 }
rtw_mi_intf_start(_adapter * adapter)733 void rtw_mi_intf_start(_adapter *adapter)
734 {
735 _rtw_mi_process(adapter, _FALSE, NULL, _rtw_mi_intf_start);
736 }
rtw_mi_buddy_intf_start(_adapter * adapter)737 void rtw_mi_buddy_intf_start(_adapter *adapter)
738 {
739 _rtw_mi_process(adapter, _TRUE, NULL, _rtw_mi_intf_start);
740 }
741
_rtw_mi_intf_stop(_adapter * adapter,void * data)742 static u8 _rtw_mi_intf_stop(_adapter *adapter, void *data)
743 {
744 rtw_intf_stop(adapter);
745 return _TRUE;
746 }
rtw_mi_intf_stop(_adapter * adapter)747 void rtw_mi_intf_stop(_adapter *adapter)
748 {
749 _rtw_mi_process(adapter, _FALSE, NULL, _rtw_mi_intf_stop);
750 }
rtw_mi_buddy_intf_stop(_adapter * adapter)751 void rtw_mi_buddy_intf_stop(_adapter *adapter)
752 {
753 _rtw_mi_process(adapter, _TRUE, NULL, _rtw_mi_intf_stop);
754 }
755
756 #ifdef CONFIG_NEW_NETDEV_HDL
rtw_mi_hal_iface_init(_adapter * padapter)757 u8 rtw_mi_hal_iface_init(_adapter *padapter)
758 {
759 int i;
760 _adapter *iface;
761 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
762
763 u8 ret = _TRUE;
764
765 for (i = 0; i < dvobj->iface_nums; i++) {
766 iface = dvobj->padapters[i];
767 if (iface && iface->netif_up)
768 rtw_hal_iface_init(padapter);
769 }
770 return ret;
771 }
772 #endif
773
_rtw_mi_suspend_free_assoc_resource(_adapter * padapter,void * data)774 static u8 _rtw_mi_suspend_free_assoc_resource(_adapter *padapter, void *data)
775 {
776 return rtw_suspend_free_assoc_resource(padapter);
777 }
rtw_mi_suspend_free_assoc_resource(_adapter * adapter)778 void rtw_mi_suspend_free_assoc_resource(_adapter *adapter)
779 {
780 _rtw_mi_process(adapter, _FALSE, NULL, _rtw_mi_suspend_free_assoc_resource);
781 }
rtw_mi_buddy_suspend_free_assoc_resource(_adapter * adapter)782 void rtw_mi_buddy_suspend_free_assoc_resource(_adapter *adapter)
783 {
784 _rtw_mi_process(adapter, _TRUE, NULL, _rtw_mi_suspend_free_assoc_resource);
785 }
786
_rtw_mi_is_scan_deny(_adapter * adapter,void * data)787 static u8 _rtw_mi_is_scan_deny(_adapter *adapter, void *data)
788 {
789 return rtw_is_scan_deny(adapter);
790 }
791
rtw_mi_is_scan_deny(_adapter * adapter)792 u8 rtw_mi_is_scan_deny(_adapter *adapter)
793 {
794 return _rtw_mi_process(adapter, _FALSE, NULL, _rtw_mi_is_scan_deny);
795
796 }
rtw_mi_buddy_is_scan_deny(_adapter * adapter)797 u8 rtw_mi_buddy_is_scan_deny(_adapter *adapter)
798 {
799 return _rtw_mi_process(adapter, _TRUE, NULL, _rtw_mi_is_scan_deny);
800 }
801
802 #ifdef CONFIG_SET_SCAN_DENY_TIMER
_rtw_mi_set_scan_deny(_adapter * adapter,void * data)803 static u8 _rtw_mi_set_scan_deny(_adapter *adapter, void *data)
804 {
805 u32 ms = *(u32 *)data;
806
807 rtw_set_scan_deny(adapter, ms);
808 return _TRUE;
809 }
rtw_mi_set_scan_deny(_adapter * adapter,u32 ms)810 void rtw_mi_set_scan_deny(_adapter *adapter, u32 ms)
811 {
812 u32 in_data = ms;
813
814 _rtw_mi_process(adapter, _FALSE, &in_data, _rtw_mi_set_scan_deny);
815 }
rtw_mi_buddy_set_scan_deny(_adapter * adapter,u32 ms)816 void rtw_mi_buddy_set_scan_deny(_adapter *adapter, u32 ms)
817 {
818 u32 in_data = ms;
819
820 _rtw_mi_process(adapter, _TRUE, &in_data, _rtw_mi_set_scan_deny);
821 }
822 #endif /*CONFIG_SET_SCAN_DENY_TIMER*/
823
824 #ifdef CONFIG_AP_MODE
_rtw_mi_beacon_update(_adapter * padapter,void * data)825 static u8 _rtw_mi_beacon_update(_adapter *padapter, void *data)
826 {
827 if (!MLME_IS_STA(padapter)
828 && check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE) == _TRUE) {
829 RTW_INFO(ADPT_FMT" - update_beacon\n", ADPT_ARG(padapter));
830 update_beacon(padapter, 0xFF, NULL, _TRUE, 0);
831 }
832 return _TRUE;
833 }
834
rtw_mi_beacon_update(_adapter * padapter)835 void rtw_mi_beacon_update(_adapter *padapter)
836 {
837 _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_beacon_update);
838 }
839
rtw_mi_buddy_beacon_update(_adapter * padapter)840 void rtw_mi_buddy_beacon_update(_adapter *padapter)
841 {
842 _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_beacon_update);
843 }
844 #endif /* CONFIG_AP_MODE */
845
846 #ifndef CONFIG_MI_WITH_MBSSID_CAM
_rtw_mi_hal_dump_macaddr(_adapter * padapter,void * sel)847 static u8 _rtw_mi_hal_dump_macaddr(_adapter *padapter, void *sel)
848 {
849 u8 mac_addr[ETH_ALEN] = {0};
850
851 rtw_hal_get_hwreg(padapter, HW_VAR_MAC_ADDR, mac_addr);
852 RTW_PRINT_SEL(sel, ADPT_FMT"- hw port(%d) mac_addr ="MAC_FMT"\n",
853 ADPT_ARG(padapter), padapter->hw_port, MAC_ARG(mac_addr));
854
855 return _TRUE;
856 }
rtw_mi_hal_dump_macaddr(void * sel,_adapter * padapter)857 void rtw_mi_hal_dump_macaddr(void *sel, _adapter *padapter)
858 {
859 _rtw_mi_process(padapter, _FALSE, sel, _rtw_mi_hal_dump_macaddr);
860 }
rtw_mi_buddy_hal_dump_macaddr(void * sel,_adapter * padapter)861 void rtw_mi_buddy_hal_dump_macaddr(void *sel, _adapter *padapter)
862 {
863 _rtw_mi_process(padapter, _TRUE, sel, _rtw_mi_hal_dump_macaddr);
864 }
865 #endif
866
867 #ifdef CONFIG_PCI_HCI
_rtw_mi_xmit_tasklet_schedule(_adapter * padapter,void * data)868 static u8 _rtw_mi_xmit_tasklet_schedule(_adapter *padapter, void *data)
869 {
870 if (rtw_txframes_pending(padapter)) {
871 /* try to deal with the pending packets */
872 tasklet_hi_schedule(&(padapter->xmitpriv.xmit_tasklet));
873 }
874 return _TRUE;
875 }
rtw_mi_xmit_tasklet_schedule(_adapter * padapter)876 void rtw_mi_xmit_tasklet_schedule(_adapter *padapter)
877 {
878 _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_xmit_tasklet_schedule);
879 }
rtw_mi_buddy_xmit_tasklet_schedule(_adapter * padapter)880 void rtw_mi_buddy_xmit_tasklet_schedule(_adapter *padapter)
881 {
882 _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_xmit_tasklet_schedule);
883 }
884 #endif
885
_rtw_mi_busy_traffic_check(_adapter * padapter,void * data)886 u8 _rtw_mi_busy_traffic_check(_adapter *padapter, void *data)
887 {
888 return padapter->mlmepriv.LinkDetectInfo.bBusyTraffic;
889 }
890
rtw_mi_busy_traffic_check(_adapter * padapter)891 u8 rtw_mi_busy_traffic_check(_adapter *padapter)
892 {
893 return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_busy_traffic_check);
894 }
rtw_mi_buddy_busy_traffic_check(_adapter * padapter)895 u8 rtw_mi_buddy_busy_traffic_check(_adapter *padapter)
896 {
897 return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_busy_traffic_check);
898 }
_rtw_mi_check_mlmeinfo_state(_adapter * padapter,void * data)899 static u8 _rtw_mi_check_mlmeinfo_state(_adapter *padapter, void *data)
900 {
901 u32 state = *(u32 *)data;
902 struct mlme_ext_priv *mlmeext = &padapter->mlmeextpriv;
903
904 /*if (mlmeext_msr(mlmeext) == state)*/
905 if (check_mlmeinfo_state(mlmeext, state))
906 return _TRUE;
907 else
908 return _FALSE;
909 }
910
rtw_mi_check_mlmeinfo_state(_adapter * padapter,u32 state)911 u8 rtw_mi_check_mlmeinfo_state(_adapter *padapter, u32 state)
912 {
913 u32 in_data = state;
914
915 return _rtw_mi_process(padapter, _FALSE, &in_data, _rtw_mi_check_mlmeinfo_state);
916 }
917
rtw_mi_buddy_check_mlmeinfo_state(_adapter * padapter,u32 state)918 u8 rtw_mi_buddy_check_mlmeinfo_state(_adapter *padapter, u32 state)
919 {
920 u32 in_data = state;
921
922 return _rtw_mi_process(padapter, _TRUE, &in_data, _rtw_mi_check_mlmeinfo_state);
923 }
924
925 /*#define DBG_DUMP_FW_STATE*/
926 #ifdef DBG_DUMP_FW_STATE
rtw_dbg_dump_fwstate(_adapter * padapter,sint state)927 static void rtw_dbg_dump_fwstate(_adapter *padapter, sint state)
928 {
929 u8 buf[32] = {0};
930
931 if (state & WIFI_FW_NULL_STATE) {
932 _rtw_memset(buf, 0, 32);
933 sprintf(buf, "WIFI_FW_NULL_STATE");
934 RTW_INFO(FUNC_ADPT_FMT"fwstate-%s\n", FUNC_ADPT_ARG(padapter), buf);
935 }
936
937 if (state & WIFI_ASOC_STATE) {
938 _rtw_memset(buf, 0, 32);
939 sprintf(buf, "WIFI_ASOC_STATE");
940 RTW_INFO(FUNC_ADPT_FMT"fwstate-%s\n", FUNC_ADPT_ARG(padapter), buf);
941 }
942
943 if (state & WIFI_UNDER_LINKING) {
944 _rtw_memset(buf, 0, 32);
945 sprintf(buf, "WIFI_UNDER_LINKING");
946 RTW_INFO(FUNC_ADPT_FMT"fwstate-%s\n", FUNC_ADPT_ARG(padapter), buf);
947 }
948
949 if (state & WIFI_UNDER_SURVEY) {
950 _rtw_memset(buf, 0, 32);
951 sprintf(buf, "WIFI_UNDER_SURVEY");
952 RTW_INFO(FUNC_ADPT_FMT"fwstate-%s\n", FUNC_ADPT_ARG(padapter), buf);
953 }
954 }
955 #endif
956
_rtw_mi_check_fwstate(_adapter * padapter,void * data)957 static u8 _rtw_mi_check_fwstate(_adapter *padapter, void *data)
958 {
959 u8 ret = _FALSE;
960
961 sint state = *(sint *)data;
962
963 if ((state == WIFI_FW_NULL_STATE) &&
964 (padapter->mlmepriv.fw_state == WIFI_FW_NULL_STATE))
965 ret = _TRUE;
966 else if (_TRUE == check_fwstate(&padapter->mlmepriv, state))
967 ret = _TRUE;
968 #ifdef DBG_DUMP_FW_STATE
969 if (ret)
970 rtw_dbg_dump_fwstate(padapter, state);
971 #endif
972 return ret;
973 }
rtw_mi_check_fwstate(_adapter * padapter,sint state)974 u8 rtw_mi_check_fwstate(_adapter *padapter, sint state)
975 {
976 sint in_data = state;
977
978 return _rtw_mi_process(padapter, _FALSE, &in_data, _rtw_mi_check_fwstate);
979 }
rtw_mi_buddy_check_fwstate(_adapter * padapter,sint state)980 u8 rtw_mi_buddy_check_fwstate(_adapter *padapter, sint state)
981 {
982 sint in_data = state;
983
984 return _rtw_mi_process(padapter, _TRUE, &in_data, _rtw_mi_check_fwstate);
985 }
986
_rtw_mi_traffic_statistics(_adapter * padapter,void * data)987 static u8 _rtw_mi_traffic_statistics(_adapter *padapter , void *data)
988 {
989 struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
990
991 /* Tx */
992 pdvobjpriv->traffic_stat.tx_bytes += padapter->xmitpriv.tx_bytes;
993 pdvobjpriv->traffic_stat.tx_pkts += padapter->xmitpriv.tx_pkts;
994 pdvobjpriv->traffic_stat.tx_drop += padapter->xmitpriv.tx_drop;
995
996 /* Rx */
997 pdvobjpriv->traffic_stat.rx_bytes += padapter->recvpriv.rx_bytes;
998 pdvobjpriv->traffic_stat.rx_pkts += padapter->recvpriv.rx_pkts;
999 pdvobjpriv->traffic_stat.rx_drop += padapter->recvpriv.rx_drop;
1000 return _TRUE;
1001 }
rtw_mi_traffic_statistics(_adapter * padapter)1002 u8 rtw_mi_traffic_statistics(_adapter *padapter)
1003 {
1004 return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_traffic_statistics);
1005 }
1006
_rtw_mi_check_miracast_enabled(_adapter * padapter,void * data)1007 static u8 _rtw_mi_check_miracast_enabled(_adapter *padapter , void *data)
1008 {
1009 return is_miracast_enabled(padapter);
1010 }
rtw_mi_check_miracast_enabled(_adapter * padapter)1011 u8 rtw_mi_check_miracast_enabled(_adapter *padapter)
1012 {
1013 return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_check_miracast_enabled);
1014 }
1015
1016 #ifdef CONFIG_XMIT_THREAD_MODE
_rtw_mi_check_pending_xmitbuf(_adapter * padapter,void * data)1017 static u8 _rtw_mi_check_pending_xmitbuf(_adapter *padapter , void *data)
1018 {
1019 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
1020
1021 return check_pending_xmitbuf(pxmitpriv);
1022 }
rtw_mi_check_pending_xmitbuf(_adapter * padapter)1023 u8 rtw_mi_check_pending_xmitbuf(_adapter *padapter)
1024 {
1025 return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_check_pending_xmitbuf);
1026 }
rtw_mi_buddy_check_pending_xmitbuf(_adapter * padapter)1027 u8 rtw_mi_buddy_check_pending_xmitbuf(_adapter *padapter)
1028 {
1029 return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_check_pending_xmitbuf);
1030 }
1031 #endif
1032
1033 #if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
_rtw_mi_dequeue_writeport(_adapter * padapter,bool exclude_self)1034 static u8 _rtw_mi_dequeue_writeport(_adapter *padapter , bool exclude_self)
1035 {
1036 int i;
1037 u8 queue_empty = _TRUE;
1038 _adapter *iface;
1039 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
1040
1041 for (i = 0; i < dvobj->iface_nums; i++) {
1042 iface = dvobj->padapters[i];
1043 if ((iface) && rtw_is_adapter_up(iface)) {
1044
1045 if ((exclude_self) && (iface == padapter))
1046 continue;
1047
1048 queue_empty &= _dequeue_writeport(iface);
1049 }
1050 }
1051 return queue_empty;
1052 }
rtw_mi_dequeue_writeport(_adapter * padapter)1053 u8 rtw_mi_dequeue_writeport(_adapter *padapter)
1054 {
1055 return _rtw_mi_dequeue_writeport(padapter, _FALSE);
1056 }
rtw_mi_buddy_dequeue_writeport(_adapter * padapter)1057 u8 rtw_mi_buddy_dequeue_writeport(_adapter *padapter)
1058 {
1059 return _rtw_mi_dequeue_writeport(padapter, _TRUE);
1060 }
1061 #endif
_rtw_mi_adapter_reset(_adapter * padapter,u8 exclude_self)1062 static void _rtw_mi_adapter_reset(_adapter *padapter , u8 exclude_self)
1063 {
1064 int i;
1065 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
1066
1067 for (i = 0; i < dvobj->iface_nums; i++) {
1068 if (dvobj->padapters[i]) {
1069 if ((exclude_self) && (dvobj->padapters[i] == padapter))
1070 continue;
1071 dvobj->padapters[i] = NULL;
1072 }
1073 }
1074 }
1075
rtw_mi_adapter_reset(_adapter * padapter)1076 void rtw_mi_adapter_reset(_adapter *padapter)
1077 {
1078 _rtw_mi_adapter_reset(padapter, _FALSE);
1079 }
1080
rtw_mi_buddy_adapter_reset(_adapter * padapter)1081 void rtw_mi_buddy_adapter_reset(_adapter *padapter)
1082 {
1083 _rtw_mi_adapter_reset(padapter, _TRUE);
1084 }
1085
_rtw_mi_dynamic_check_timer_handlder(_adapter * adapter,void * data)1086 static u8 _rtw_mi_dynamic_check_timer_handlder(_adapter *adapter, void *data)
1087 {
1088 rtw_iface_dynamic_check_timer_handlder(adapter);
1089 return _TRUE;
1090 }
rtw_mi_dynamic_check_timer_handlder(_adapter * padapter)1091 u8 rtw_mi_dynamic_check_timer_handlder(_adapter *padapter)
1092 {
1093 return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_dynamic_check_timer_handlder);
1094 }
rtw_mi_buddy_dynamic_check_timer_handlder(_adapter * padapter)1095 u8 rtw_mi_buddy_dynamic_check_timer_handlder(_adapter *padapter)
1096 {
1097 return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_dynamic_check_timer_handlder);
1098 }
1099
_rtw_mi_dynamic_chk_wk_hdl(_adapter * adapter,void * data)1100 static u8 _rtw_mi_dynamic_chk_wk_hdl(_adapter *adapter, void *data)
1101 {
1102 rtw_iface_dynamic_chk_wk_hdl(adapter);
1103 return _TRUE;
1104 }
rtw_mi_dynamic_chk_wk_hdl(_adapter * padapter)1105 u8 rtw_mi_dynamic_chk_wk_hdl(_adapter *padapter)
1106 {
1107 return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_dynamic_chk_wk_hdl);
1108 }
rtw_mi_buddy_dynamic_chk_wk_hdl(_adapter * padapter)1109 u8 rtw_mi_buddy_dynamic_chk_wk_hdl(_adapter *padapter)
1110 {
1111 return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_dynamic_chk_wk_hdl);
1112 }
1113
_rtw_mi_os_xmit_schedule(_adapter * adapter,void * data)1114 static u8 _rtw_mi_os_xmit_schedule(_adapter *adapter, void *data)
1115 {
1116 rtw_os_xmit_schedule(adapter);
1117 return _TRUE;
1118 }
rtw_mi_os_xmit_schedule(_adapter * padapter)1119 u8 rtw_mi_os_xmit_schedule(_adapter *padapter)
1120 {
1121 return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_os_xmit_schedule);
1122 }
rtw_mi_buddy_os_xmit_schedule(_adapter * padapter)1123 u8 rtw_mi_buddy_os_xmit_schedule(_adapter *padapter)
1124 {
1125 return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_os_xmit_schedule);
1126 }
1127
_rtw_mi_report_survey_event(_adapter * adapter,void * data)1128 static u8 _rtw_mi_report_survey_event(_adapter *adapter, void *data)
1129 {
1130 union recv_frame *precv_frame = (union recv_frame *)data;
1131
1132 report_survey_event(adapter, precv_frame);
1133 return _TRUE;
1134 }
rtw_mi_report_survey_event(_adapter * padapter,union recv_frame * precv_frame)1135 u8 rtw_mi_report_survey_event(_adapter *padapter, union recv_frame *precv_frame)
1136 {
1137 return _rtw_mi_process(padapter, _FALSE, precv_frame, _rtw_mi_report_survey_event);
1138 }
rtw_mi_buddy_report_survey_event(_adapter * padapter,union recv_frame * precv_frame)1139 u8 rtw_mi_buddy_report_survey_event(_adapter *padapter, union recv_frame *precv_frame)
1140 {
1141 return _rtw_mi_process(padapter, _TRUE, precv_frame, _rtw_mi_report_survey_event);
1142 }
1143
_rtw_mi_sreset_adapter_hdl(_adapter * adapter,void * data)1144 static u8 _rtw_mi_sreset_adapter_hdl(_adapter *adapter, void *data)
1145 {
1146 u8 bstart = *(u8 *)data;
1147
1148 if (bstart)
1149 sreset_start_adapter(adapter);
1150 else
1151 sreset_stop_adapter(adapter);
1152 return _TRUE;
1153 }
rtw_mi_sreset_adapter_hdl(_adapter * padapter,u8 bstart)1154 u8 rtw_mi_sreset_adapter_hdl(_adapter *padapter, u8 bstart)
1155 {
1156 u8 in_data = bstart;
1157
1158 return _rtw_mi_process(padapter, _FALSE, &in_data, _rtw_mi_sreset_adapter_hdl);
1159 }
1160
1161 #if defined(CONFIG_AP_MODE) && defined(DBG_CONFIG_ERROR_RESET) && defined(CONFIG_CONCURRENT_MODE)
rtw_mi_ap_info_restore(_adapter * adapter)1162 void rtw_mi_ap_info_restore(_adapter *adapter)
1163 {
1164 int i;
1165 _adapter *iface;
1166 struct mlme_priv *pmlmepriv;
1167 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
1168
1169 for (i = 0; i < dvobj->iface_nums; i++) {
1170 iface = dvobj->padapters[i];
1171 if (iface) {
1172 pmlmepriv = &iface->mlmepriv;
1173
1174 if (MLME_IS_AP(iface) || MLME_IS_MESH(iface)) {
1175 RTW_INFO(FUNC_ADPT_FMT" %s\n", FUNC_ADPT_ARG(iface), MLME_IS_AP(iface) ? "AP" : "MESH");
1176 rtw_iface_bcmc_sec_cam_map_restore(iface);
1177 }
1178 }
1179 }
1180 }
1181 #endif /*#if defined(DBG_CONFIG_ERROR_RESET) && defined(CONFIG_CONCURRENT_MODE)*/
1182
rtw_mi_buddy_sreset_adapter_hdl(_adapter * padapter,u8 bstart)1183 u8 rtw_mi_buddy_sreset_adapter_hdl(_adapter *padapter, u8 bstart)
1184 {
1185 u8 in_data = bstart;
1186
1187 return _rtw_mi_process(padapter, _TRUE, &in_data, _rtw_mi_sreset_adapter_hdl);
1188 }
1189
1190 #ifdef CONFIG_AP_MODE
_rtw_mi_tx_beacon_hdl(_adapter * adapter,void * data)1191 static u8 _rtw_mi_tx_beacon_hdl(_adapter *adapter, void *data)
1192 {
1193 if ((MLME_IS_AP(adapter) || MLME_IS_MESH(adapter))
1194 && check_fwstate(&adapter->mlmepriv, WIFI_ASOC_STATE) == _TRUE
1195 ) {
1196 adapter->mlmepriv.update_bcn = _TRUE;
1197 #ifndef CONFIG_INTERRUPT_BASED_TXBCN
1198 #if defined(CONFIG_USB_HCI) || defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI) || defined(CONFIG_PCI_BCN_POLLING)
1199 tx_beacon_hdl(adapter, NULL);
1200 #endif
1201 #endif
1202 }
1203 return _TRUE;
1204 }
rtw_mi_tx_beacon_hdl(_adapter * padapter)1205 u8 rtw_mi_tx_beacon_hdl(_adapter *padapter)
1206 {
1207 return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_tx_beacon_hdl);
1208 }
rtw_mi_buddy_tx_beacon_hdl(_adapter * padapter)1209 u8 rtw_mi_buddy_tx_beacon_hdl(_adapter *padapter)
1210 {
1211 return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_sreset_adapter_hdl);
1212 }
1213
_rtw_mi_set_tx_beacon_cmd(_adapter * adapter,void * data)1214 static u8 _rtw_mi_set_tx_beacon_cmd(_adapter *adapter, void *data)
1215 {
1216 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1217
1218 if (MLME_IS_AP(adapter) || MLME_IS_MESH(adapter)) {
1219 if (pmlmepriv->update_bcn == _TRUE)
1220 set_tx_beacon_cmd(adapter, 0);
1221 }
1222 return _TRUE;
1223 }
rtw_mi_set_tx_beacon_cmd(_adapter * padapter)1224 u8 rtw_mi_set_tx_beacon_cmd(_adapter *padapter)
1225 {
1226 return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_set_tx_beacon_cmd);
1227 }
rtw_mi_buddy_set_tx_beacon_cmd(_adapter * padapter)1228 u8 rtw_mi_buddy_set_tx_beacon_cmd(_adapter *padapter)
1229 {
1230 return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_set_tx_beacon_cmd);
1231 }
1232 #endif /* CONFIG_AP_MODE */
1233
1234 #ifdef CONFIG_P2P
_rtw_mi_p2p_chk_state(_adapter * adapter,void * data)1235 static u8 _rtw_mi_p2p_chk_state(_adapter *adapter, void *data)
1236 {
1237 struct wifidirect_info *pwdinfo = &(adapter->wdinfo);
1238 enum P2P_STATE state = *(enum P2P_STATE *)data;
1239
1240 return rtw_p2p_chk_state(pwdinfo, state);
1241 }
rtw_mi_p2p_chk_state(_adapter * padapter,enum P2P_STATE p2p_state)1242 u8 rtw_mi_p2p_chk_state(_adapter *padapter, enum P2P_STATE p2p_state)
1243 {
1244 u8 in_data = p2p_state;
1245
1246 return _rtw_mi_process(padapter, _FALSE, &in_data, _rtw_mi_p2p_chk_state);
1247 }
rtw_mi_buddy_p2p_chk_state(_adapter * padapter,enum P2P_STATE p2p_state)1248 u8 rtw_mi_buddy_p2p_chk_state(_adapter *padapter, enum P2P_STATE p2p_state)
1249 {
1250 u8 in_data = p2p_state;
1251
1252 return _rtw_mi_process(padapter, _TRUE, &in_data, _rtw_mi_p2p_chk_state);
1253 }
_rtw_mi_stay_in_p2p_mode(_adapter * adapter,void * data)1254 static u8 _rtw_mi_stay_in_p2p_mode(_adapter *adapter, void *data)
1255 {
1256 struct wifidirect_info *pwdinfo = &(adapter->wdinfo);
1257
1258 if (rtw_p2p_role(pwdinfo) != P2P_ROLE_DISABLE)
1259 return _TRUE;
1260 return _FALSE;
1261 }
rtw_mi_stay_in_p2p_mode(_adapter * padapter)1262 u8 rtw_mi_stay_in_p2p_mode(_adapter *padapter)
1263 {
1264 return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_stay_in_p2p_mode);
1265 }
rtw_mi_buddy_stay_in_p2p_mode(_adapter * padapter)1266 u8 rtw_mi_buddy_stay_in_p2p_mode(_adapter *padapter)
1267 {
1268 return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_stay_in_p2p_mode);
1269 }
1270 #endif /*CONFIG_P2P*/
1271
rtw_get_iface_by_id(_adapter * padapter,u8 iface_id)1272 _adapter *rtw_get_iface_by_id(_adapter *padapter, u8 iface_id)
1273 {
1274 _adapter *iface = NULL;
1275 struct dvobj_priv *dvobj;
1276
1277 if ((padapter == NULL) || (iface_id >= CONFIG_IFACE_NUMBER)) {
1278 rtw_warn_on(1);
1279 return iface;
1280 }
1281
1282 dvobj = adapter_to_dvobj(padapter);
1283 return dvobj->padapters[iface_id];
1284 }
1285
rtw_get_iface_by_macddr(_adapter * padapter,const u8 * mac_addr)1286 _adapter *rtw_get_iface_by_macddr(_adapter *padapter, const u8 *mac_addr)
1287 {
1288 int i;
1289 _adapter *iface = NULL;
1290 u8 bmatch = _FALSE;
1291 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
1292
1293 for (i = 0; i < dvobj->iface_nums; i++) {
1294 iface = dvobj->padapters[i];
1295 if ((iface) && (_rtw_memcmp(mac_addr, adapter_mac_addr(iface), ETH_ALEN))) {
1296 bmatch = _TRUE;
1297 break;
1298 }
1299 }
1300 if (bmatch)
1301 return iface;
1302 else
1303 return NULL;
1304 }
1305
rtw_get_iface_by_hwport(_adapter * padapter,u8 hw_port)1306 _adapter *rtw_get_iface_by_hwport(_adapter *padapter, u8 hw_port)
1307 {
1308 int i;
1309 _adapter *iface = NULL;
1310 u8 bmatch = _FALSE;
1311 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
1312
1313 for (i = 0; i < dvobj->iface_nums; i++) {
1314 iface = dvobj->padapters[i];
1315 if ((iface) && (hw_port == iface->hw_port)) {
1316 bmatch = _TRUE;
1317 break;
1318 }
1319 }
1320 if (bmatch)
1321 return iface;
1322 else
1323 return NULL;
1324 }
1325
1326 /*#define CONFIG_SKB_ALLOCATED*/
1327 #define DBG_SKB_PROCESS
1328 #ifdef DBG_SKB_PROCESS
rtw_dbg_skb_process(_adapter * padapter,union recv_frame * precvframe,union recv_frame * pcloneframe)1329 void rtw_dbg_skb_process(_adapter *padapter, union recv_frame *precvframe, union recv_frame *pcloneframe)
1330 {
1331 _pkt *pkt_copy, *pkt_org;
1332
1333 pkt_org = precvframe->u.hdr.pkt;
1334 pkt_copy = pcloneframe->u.hdr.pkt;
1335 /*
1336 RTW_INFO("%s ===== ORG SKB =====\n", __func__);
1337 RTW_INFO(" SKB head(%p)\n", pkt_org->head);
1338 RTW_INFO(" SKB data(%p)\n", pkt_org->data);
1339 RTW_INFO(" SKB tail(%p)\n", pkt_org->tail);
1340 RTW_INFO(" SKB end(%p)\n", pkt_org->end);
1341
1342 RTW_INFO(" recv frame head(%p)\n", precvframe->u.hdr.rx_head);
1343 RTW_INFO(" recv frame data(%p)\n", precvframe->u.hdr.rx_data);
1344 RTW_INFO(" recv frame tail(%p)\n", precvframe->u.hdr.rx_tail);
1345 RTW_INFO(" recv frame end(%p)\n", precvframe->u.hdr.rx_end);
1346
1347 RTW_INFO("%s ===== COPY SKB =====\n", __func__);
1348 RTW_INFO(" SKB head(%p)\n", pkt_copy->head);
1349 RTW_INFO(" SKB data(%p)\n", pkt_copy->data);
1350 RTW_INFO(" SKB tail(%p)\n", pkt_copy->tail);
1351 RTW_INFO(" SKB end(%p)\n", pkt_copy->end);
1352
1353 RTW_INFO(" recv frame head(%p)\n", pcloneframe->u.hdr.rx_head);
1354 RTW_INFO(" recv frame data(%p)\n", pcloneframe->u.hdr.rx_data);
1355 RTW_INFO(" recv frame tail(%p)\n", pcloneframe->u.hdr.rx_tail);
1356 RTW_INFO(" recv frame end(%p)\n", pcloneframe->u.hdr.rx_end);
1357 */
1358 /*
1359 RTW_INFO("%s => recv_frame adapter(%p,%p)\n", __func__, precvframe->u.hdr.adapter, pcloneframe->u.hdr.adapter);
1360 RTW_INFO("%s => recv_frame dev(%p,%p)\n", __func__, pkt_org->dev , pkt_copy->dev);
1361 RTW_INFO("%s => recv_frame len(%d,%d)\n", __func__, precvframe->u.hdr.len, pcloneframe->u.hdr.len);
1362 */
1363 if (precvframe->u.hdr.len != pcloneframe->u.hdr.len)
1364 RTW_INFO("%s [WARN] recv_frame length(%d:%d) compare failed\n", __func__, precvframe->u.hdr.len, pcloneframe->u.hdr.len);
1365
1366 if (_rtw_memcmp(&precvframe->u.hdr.attrib, &pcloneframe->u.hdr.attrib, sizeof(struct rx_pkt_attrib)) == _FALSE)
1367 RTW_INFO("%s [WARN] recv_frame attrib compare failed\n", __func__);
1368
1369 if (_rtw_memcmp(precvframe->u.hdr.rx_data, pcloneframe->u.hdr.rx_data, precvframe->u.hdr.len) == _FALSE)
1370 RTW_INFO("%s [WARN] recv_frame rx_data compare failed\n", __func__);
1371
1372 }
1373 #endif
1374
_rtw_mi_buddy_clone_bcmc_packet(_adapter * adapter,union recv_frame * precvframe,u8 * pphy_status,union recv_frame * pcloneframe)1375 static s32 _rtw_mi_buddy_clone_bcmc_packet(_adapter *adapter, union recv_frame *precvframe, u8 *pphy_status, union recv_frame *pcloneframe)
1376 {
1377 s32 ret = _SUCCESS;
1378 #ifdef CONFIG_SKB_ALLOCATED
1379 u8 *pbuf = precvframe->u.hdr.rx_data;
1380 #endif
1381 struct rx_pkt_attrib *pattrib = NULL;
1382
1383 if (pcloneframe) {
1384 pcloneframe->u.hdr.adapter = adapter;
1385
1386 _rtw_init_listhead(&pcloneframe->u.hdr.list);
1387 pcloneframe->u.hdr.precvbuf = NULL; /*can't access the precvbuf for new arch.*/
1388 pcloneframe->u.hdr.len = 0;
1389
1390 _rtw_memcpy(&pcloneframe->u.hdr.attrib, &precvframe->u.hdr.attrib, sizeof(struct rx_pkt_attrib));
1391
1392 pattrib = &pcloneframe->u.hdr.attrib;
1393 #ifdef CONFIG_SKB_ALLOCATED
1394 if (rtw_os_alloc_recvframe(adapter, pcloneframe, pbuf, NULL) == _SUCCESS)
1395 #else
1396 if (rtw_os_recvframe_duplicate_skb(adapter, pcloneframe, precvframe->u.hdr.pkt) == _SUCCESS)
1397 #endif
1398 {
1399 #ifdef CONFIG_SKB_ALLOCATED
1400 recvframe_put(pcloneframe, pattrib->pkt_len);
1401 #endif
1402
1403 #ifdef DBG_SKB_PROCESS
1404 rtw_dbg_skb_process(adapter, precvframe, pcloneframe);
1405 #endif
1406
1407 if (pphy_status)
1408 rx_query_phy_status(pcloneframe, pphy_status);
1409
1410 ret = rtw_recv_entry(pcloneframe);
1411 } else {
1412 ret = -1;
1413 RTW_INFO("%s()-%d: rtw_os_alloc_recvframe() failed!\n", __func__, __LINE__);
1414 }
1415
1416 }
1417 return ret;
1418 }
1419
rtw_mi_buddy_clone_bcmc_packet(_adapter * padapter,union recv_frame * precvframe,u8 * pphy_status)1420 void rtw_mi_buddy_clone_bcmc_packet(_adapter *padapter, union recv_frame *precvframe, u8 *pphy_status)
1421 {
1422 int i;
1423 s32 ret = _SUCCESS;
1424 _adapter *iface = NULL;
1425 union recv_frame *pcloneframe = NULL;
1426 struct recv_priv *precvpriv = &padapter->recvpriv;/*primary_padapter*/
1427 _queue *pfree_recv_queue = &precvpriv->free_recv_queue;
1428 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
1429 u8 *fhead = get_recvframe_data(precvframe);
1430 u8 type = GetFrameType(fhead);
1431
1432 for (i = 0; i < dvobj->iface_nums; i++) {
1433 iface = dvobj->padapters[i];
1434 if (!iface || iface == padapter)
1435 continue;
1436 if (rtw_is_adapter_up(iface) == _FALSE || iface->registered == 0)
1437 continue;
1438 if (type == WIFI_DATA_TYPE && !adapter_allow_bmc_data_rx(iface))
1439 continue;
1440
1441 pcloneframe = rtw_alloc_recvframe(pfree_recv_queue);
1442 if (pcloneframe) {
1443 ret = _rtw_mi_buddy_clone_bcmc_packet(iface, precvframe, pphy_status, pcloneframe);
1444 if (_SUCCESS != ret) {
1445 if (ret == -1)
1446 rtw_free_recvframe(pcloneframe, pfree_recv_queue);
1447 /*RTW_INFO(ADPT_FMT"-clone BC/MC frame failed\n", ADPT_ARG(iface));*/
1448 }
1449 }
1450 }
1451
1452 }
1453
1454 #ifdef CONFIG_PCI_HCI
1455 /*API be created temporary for MI, caller is interrupt-handler, PCIE's interrupt handler cannot apply to multi-AP*/
rtw_mi_get_ap_adapter(_adapter * padapter)1456 _adapter *rtw_mi_get_ap_adapter(_adapter *padapter)
1457 {
1458 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
1459 int i;
1460 _adapter *iface = NULL;
1461
1462 for (i = 0; i < dvobj->iface_nums; i++) {
1463 iface = dvobj->padapters[i];
1464 if (!iface)
1465 continue;
1466
1467 if (check_fwstate(&iface->mlmepriv, WIFI_AP_STATE) == _TRUE
1468 && check_fwstate(&iface->mlmepriv, WIFI_ASOC_STATE) == _TRUE)
1469 break;
1470
1471 }
1472 return iface;
1473 }
1474 #endif
1475
rtw_mi_get_ld_sta_ifbmp(_adapter * adapter)1476 u8 rtw_mi_get_ld_sta_ifbmp(_adapter *adapter)
1477 {
1478 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
1479 int i;
1480 _adapter *iface = NULL;
1481 u8 ifbmp = 0;
1482
1483 for (i = 0; i < dvobj->iface_nums; i++) {
1484 iface = dvobj->padapters[i];
1485 if (!iface)
1486 continue;
1487
1488 if (MLME_IS_STA(iface) && MLME_IS_ASOC(iface))
1489 ifbmp |= BIT(i);
1490 }
1491
1492 return ifbmp;
1493 }
1494
rtw_mi_get_ap_mesh_ifbmp(_adapter * adapter)1495 u8 rtw_mi_get_ap_mesh_ifbmp(_adapter *adapter)
1496 {
1497 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
1498 int i;
1499 _adapter *iface = NULL;
1500 u8 ifbmp = 0;
1501
1502 for (i = 0; i < dvobj->iface_nums; i++) {
1503 iface = dvobj->padapters[i];
1504 if (!iface)
1505 continue;
1506
1507 if (CHK_MLME_STATE(iface, WIFI_AP_STATE | WIFI_MESH_STATE)
1508 && MLME_IS_ASOC(iface))
1509 ifbmp |= BIT(i);
1510 }
1511
1512 return ifbmp;
1513 }
1514
rtw_mi_update_ap_bmc_camid(_adapter * padapter,u8 camid_a,u8 camid_b)1515 void rtw_mi_update_ap_bmc_camid(_adapter *padapter, u8 camid_a, u8 camid_b)
1516 {
1517 #ifdef CONFIG_CONCURRENT_MODE
1518 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
1519 struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj);
1520
1521 int i;
1522 _adapter *iface = NULL;
1523
1524 for (i = 0; i < dvobj->iface_nums; i++) {
1525 iface = dvobj->padapters[i];
1526 if (!iface)
1527 continue;
1528
1529 if (macid_ctl->iface_bmc[iface->iface_id] != INVALID_SEC_MAC_CAM_ID) {
1530 if (macid_ctl->iface_bmc[iface->iface_id] == camid_a)
1531 macid_ctl->iface_bmc[iface->iface_id] = camid_b;
1532 else if (macid_ctl->iface_bmc[iface->iface_id] == camid_b)
1533 macid_ctl->iface_bmc[iface->iface_id] = camid_a;
1534 iface->securitypriv.dot118021x_bmc_cam_id = macid_ctl->iface_bmc[iface->iface_id];
1535 }
1536 }
1537 #endif
1538 }
1539
rtw_mi_get_assoc_if_num(_adapter * adapter)1540 u8 rtw_mi_get_assoc_if_num(_adapter *adapter)
1541 {
1542 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
1543 u8 n_assoc_iface = 0;
1544 #if 1
1545 u8 i;
1546
1547 for (i = 0; i < dvobj->iface_nums; i++) {
1548 if (check_fwstate(&(dvobj->padapters[i]->mlmepriv), WIFI_ASOC_STATE))
1549 n_assoc_iface++;
1550 }
1551 #else
1552 n_assoc_iface = DEV_STA_LD_NUM(dvobj) + DEV_AP_NUM(dvobj) + DEV_ADHOC_NUM(dvobj) + DEV_MESH_NUM(dvobj);
1553 #endif
1554 return n_assoc_iface;
1555 }
1556