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