1 /******************************************************************************
2 *
3 * Copyright(c) 2015 - 2016 Realtek Corporation. All rights reserved.
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 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
17 *
18 *
19 ******************************************************************************/
20 #define _RTL8822B_CMD_C_
21
22 #include <hal_data.h> /* HAL_DATA_TYPE */
23 #include "../hal_halmac.h" /* HRTW_HALMAC_H2C_MAX_SIZE, CMD_ID_RSVD_PAGE and etc. */
24 #include "rtl8822b.h"
25
26 /*
27 * Below functions are for C2H
28 */
29 /*****************************************
30 * H2C Msg format :
31 *| 31 - 8 |7-5 | 4 - 0 |
32 *| h2c_msg |Class |CMD_ID |
33 *| 31-0 |
34 *| Ext msg |
35 *
36 ******************************************/
rtl8822b_fillh2ccmd(PADAPTER adapter,u8 id,u32 buf_len,u8 * pbuf)37 s32 rtl8822b_fillh2ccmd(PADAPTER adapter, u8 id, u32 buf_len, u8 *pbuf)
38 {
39 u8 h2c[RTW_HALMAC_H2C_MAX_SIZE] = {0};
40 #ifdef CONFIG_RTW_DEBUG
41 u8 msg[(RTW_HALMAC_H2C_MAX_SIZE - 1) * 5 + 1] = {0};
42 u8 *msg_p;
43 u32 msg_size, i, n;
44 #endif /* CONFIG_RTW_DEBUG */
45 s32 ret = _FAIL;
46
47
48 if (!pbuf)
49 goto exit;
50
51 if (buf_len > (RTW_HALMAC_H2C_MAX_SIZE - 1))
52 goto exit;
53
54 if (rtw_is_surprise_removed(adapter))
55 goto exit;
56
57 #ifdef CONFIG_RTW_DEBUG
58 msg_p = msg;
59 msg_size = (RTW_HALMAC_H2C_MAX_SIZE - 1) * 5 + 1;
60 for (i = 0; i < buf_len; i++) {
61 n = rtw_sprintf(msg_p, msg_size, " 0x%02x", pbuf[i]);
62 msg_p += n;
63 msg_size -= n;
64 if (msg_size == 0)
65 break;
66 }
67 RTW_DBG(FUNC_ADPT_FMT ": id=0x%02x buf=%s\n",
68 FUNC_ADPT_ARG(adapter), id, msg);
69 #endif /* CONFIG_RTW_DEBUG */
70
71 h2c[0] = id;
72 _rtw_memcpy(h2c + 1, pbuf, buf_len);
73
74 ret = (s32)rtw_halmac_send_h2c(adapter_to_dvobj(adapter), h2c);
75
76 exit:
77
78 return ret;
79 }
80
rtl8822b_set_FwRsvdPage_cmd(PADAPTER adapter,PRSVDPAGE_LOC rsvdpageloc)81 static void rtl8822b_set_FwRsvdPage_cmd(PADAPTER adapter, PRSVDPAGE_LOC rsvdpageloc)
82 {
83 u8 h2c[RTW_HALMAC_H2C_MAX_SIZE] = {0};
84
85
86 RTW_INFO(FUNC_ADPT_FMT ": ProbeRsp=%d PsPoll=%d Null=%d QoSNull=%d BTNull=%d\n",
87 FUNC_ADPT_ARG(adapter),
88 rsvdpageloc->LocProbeRsp, rsvdpageloc->LocPsPoll,
89 rsvdpageloc->LocNullData, rsvdpageloc->LocQosNull,
90 rsvdpageloc->LocBTQosNull);
91
92 RSVD_PAGE_SET_CMD_ID(h2c, CMD_ID_RSVD_PAGE);
93 RSVD_PAGE_SET_CLASS(h2c, CLASS_RSVD_PAGE);
94 RSVD_PAGE_SET_LOC_PROBE_RSP(h2c, rsvdpageloc->LocProbeRsp);
95 RSVD_PAGE_SET_LOC_PS_POLL(h2c, rsvdpageloc->LocPsPoll);
96 RSVD_PAGE_SET_LOC_NULL_DATA(h2c, rsvdpageloc->LocNullData);
97 RSVD_PAGE_SET_LOC_QOS_NULL(h2c, rsvdpageloc->LocQosNull);
98 RSVD_PAGE_SET_LOC_BT_QOS_NULL(h2c, rsvdpageloc->LocBTQosNull);
99
100 RTW_DBG_DUMP("H2C-RsvdPage Parm:", h2c, RTW_HALMAC_H2C_MAX_SIZE);
101 rtw_halmac_send_h2c(adapter_to_dvobj(adapter), h2c);
102 }
103
rtl8822b_set_FwAoacRsvdPage_cmd(PADAPTER adapter,PRSVDPAGE_LOC rsvdpageloc)104 static void rtl8822b_set_FwAoacRsvdPage_cmd(PADAPTER adapter, PRSVDPAGE_LOC rsvdpageloc)
105 {
106 #ifdef CONFIG_WOWLAN
107 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(adapter);
108 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
109 u8 res = 0, count = 0;
110 u8 h2c[RTW_HALMAC_H2C_MAX_SIZE] = {0};
111
112
113 RTW_INFO(FUNC_ADPT_FMT ": RWC=%d ArpRsp=%d NbrAdv=%d GtkRsp=%d GtkInfo=%d ProbeReq=%d NetworkList=%d\n",
114 FUNC_ADPT_ARG(adapter),
115 rsvdpageloc->LocRemoteCtrlInfo, rsvdpageloc->LocArpRsp,
116 rsvdpageloc->LocNbrAdv, rsvdpageloc->LocGTKRsp,
117 rsvdpageloc->LocGTKInfo, rsvdpageloc->LocProbeReq,
118 rsvdpageloc->LocNetList);
119
120 if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) {
121 AOAC_RSVD_PAGE_SET_CMD_ID(h2c, CMD_ID_AOAC_RSVD_PAGE);
122 AOAC_RSVD_PAGE_SET_CLASS(h2c, CLASS_AOAC_RSVD_PAGE);
123 AOAC_RSVD_PAGE_SET_LOC_REMOTE_CTRL_INFO(h2c, rsvdpageloc->LocRemoteCtrlInfo);
124 AOAC_RSVD_PAGE_SET_LOC_ARP_RESPONSE(h2c, rsvdpageloc->LocArpRsp);
125 AOAC_RSVD_PAGE_SET_LOC_GTK_RSP(h2c, rsvdpageloc->LocGTKRsp);
126 AOAC_RSVD_PAGE_SET_LOC_GTK_INFO(h2c, rsvdpageloc->LocGTKInfo);
127 #ifdef CONFIG_GTK_OL
128 AOAC_RSVD_PAGE_SET_LOC_GTK_EXT_MEM(h2c, rsvdpageloc->LocGTKEXTMEM);
129 #endif /* CONFIG_GTK_OL */
130 RTW_DBG_DUMP("H2C-AoacRsvdPage Parm:", h2c, RTW_HALMAC_H2C_MAX_SIZE);
131 rtw_halmac_send_h2c(adapter_to_dvobj(adapter), h2c);
132 } else {
133 #ifdef CONFIG_PNO_SUPPORT
134 if (!pwrpriv->pno_in_resume) {
135 RTW_INFO("%s: NLO_INFO=%d\n", __FUNCTION__, rsvdpageloc->LocPNOInfo);
136 AOAC_RSVD_PAGE3_SET_CMD_ID(h2c, CMD_ID_AOAC_RSVD_PAGE3);
137 AOAC_RSVD_PAGE3_SET_CLASS(h2c, CLASS_AOAC_RSVD_PAGE3);
138 AOAC_RSVD_PAGE3_SET_LOC_NLO_INFO(h2c, rsvdpageloc->LocPNOInfo);
139 RTW_DBG_DUMP("H2C-AoacRsvdPage3 Parm:", h2c, RTW_HALMAC_H2C_MAX_SIZE);
140 rtw_halmac_send_h2c(adapter_to_dvobj(adapter), h2c);
141 rtw_msleep_os(10);
142 }
143 #endif /* CONFIG_PNO_SUPPORT */
144 }
145 #endif /* CONFIG_WOWLAN */
146 }
147
rtl8822b_set_FwMediaStatusRpt_cmd(PADAPTER adapter,u8 mstatus,u8 macid)148 void rtl8822b_set_FwMediaStatusRpt_cmd(PADAPTER adapter, u8 mstatus, u8 macid)
149 {
150 u8 h2c[RTW_HALMAC_H2C_MAX_SIZE] = {0};
151 u8 macid_end = 0;
152
153 RTW_INFO(FUNC_ADPT_FMT ": mstatus=%d macid=%d\n",
154 FUNC_ADPT_ARG(adapter), mstatus, macid);
155
156 MEDIA_STATUS_RPT_SET_CMD_ID(h2c, CMD_ID_MEDIA_STATUS_RPT);
157 MEDIA_STATUS_RPT_SET_CLASS(h2c, CLASS_MEDIA_STATUS_RPT);
158 MEDIA_STATUS_RPT_SET_OP_MODE(h2c, mstatus);
159 MEDIA_STATUS_RPT_SET_MACID_IN(h2c, 0);
160 MEDIA_STATUS_RPT_SET_MACID(h2c, macid);
161 MEDIA_STATUS_RPT_SET_MACID_END(h2c, macid_end);
162
163 RTW_DBG_DUMP("H2C-MediaStatusRpt Parm:", h2c, RTW_HALMAC_H2C_MAX_SIZE);
164 rtw_halmac_send_h2c(adapter_to_dvobj(adapter), h2c);
165 }
166
rtl8822b_set_FwKeepAlive_cmd(PADAPTER adapter,u8 benable,u8 pkt_type)167 static void rtl8822b_set_FwKeepAlive_cmd(PADAPTER adapter, u8 benable, u8 pkt_type)
168 {
169 u8 h2c[RTW_HALMAC_H2C_MAX_SIZE] = {0};
170 u8 adopt = 1;
171 #ifdef CONFIG_PLATFORM_INTEL_BYT
172 u8 check_period = 10;
173 #else
174 u8 check_period = 5;
175 #endif
176
177
178 RTW_INFO(FUNC_ADPT_FMT ": benable=%d\n", FUNC_ADPT_ARG(adapter), benable);
179
180 KEEP_ALIVE_SET_CMD_ID(h2c, CMD_ID_KEEP_ALIVE);
181 KEEP_ALIVE_SET_CLASS(h2c, CLASS_KEEP_ALIVE);
182 KEEP_ALIVE_SET_ENABLE(h2c, benable);
183 KEEP_ALIVE_SET_ADOPT_USER_SETTING(h2c, adopt);
184 KEEP_ALIVE_SET_PKT_TYPE(h2c, pkt_type);
185 KEEP_ALIVE_SET_KEEP_ALIVE_CHECK_PERIOD(h2c, check_period);
186
187 RTW_DBG_DUMP("H2C-KeepAlive Parm:", h2c, RTW_HALMAC_H2C_MAX_SIZE);
188 rtw_halmac_send_h2c(adapter_to_dvobj(adapter), h2c);
189 }
190
rtl8822b_set_FwDisconDecision_cmd(PADAPTER adapter,u8 benable)191 static void rtl8822b_set_FwDisconDecision_cmd(PADAPTER adapter, u8 benable)
192 {
193 u8 h2c[RTW_HALMAC_H2C_MAX_SIZE] = {0};
194 u8 adopt = 1, check_period = 10, trypkt_num = 0;
195
196
197 RTW_INFO(FUNC_ADPT_FMT ": benable=%d\n",
198 FUNC_ADPT_ARG(adapter), benable);
199
200 DISCONNECT_DECISION_SET_CMD_ID(h2c, CMD_ID_DISCONNECT_DECISION);
201 DISCONNECT_DECISION_SET_CLASS(h2c, CLASS_DISCONNECT_DECISION);
202 DISCONNECT_DECISION_SET_ENABLE(h2c, benable);
203 DISCONNECT_DECISION_SET_ADOPT_USER_SETTING(h2c, adopt);
204 DISCONNECT_DECISION_SET_DISCON_DECISION_CHECK_PERIOD(h2c, check_period);
205 DISCONNECT_DECISION_SET_TRY_PKT_NUM(h2c, trypkt_num);
206
207 RTW_DBG_DUMP("H2C-DisconDecision Parm:", h2c, RTW_HALMAC_H2C_MAX_SIZE);
208 rtw_halmac_send_h2c(adapter_to_dvobj(adapter), h2c);
209 }
210
get_ra_vht_en(u32 wirelessMode,u32 bitmap)211 static u8 get_ra_vht_en(u32 wirelessMode, u32 bitmap)
212 {
213 u8 ret = 0;
214
215 if (wirelessMode == WIRELESS_11_24AC) {
216 if (bitmap & 0xfff00000) /* 2SS */
217 ret = 3;
218 else /* 1SS */
219 ret = 2;
220 } else if (wirelessMode == WIRELESS_11_5AC)
221 ret = 1;
222
223 return ret;
224 }
225
get_ra_ldpc(struct sta_info * psta)226 static u8 get_ra_ldpc(struct sta_info *psta)
227 {
228 u8 en_ldpc = 0;
229
230 if (psta != NULL) {
231 if (psta->mac_id == 1)
232 en_ldpc = 0;
233 else {
234 #ifdef CONFIG_80211AC_VHT
235 if (IsSupportedVHT(psta->wireless_mode)) {
236 if (TEST_FLAG(psta->vhtpriv.ldpc_cap, LDPC_VHT_CAP_TX))
237 en_ldpc = 1;
238 else
239 en_ldpc = 0;
240 } else if (IsSupportedHT(psta->wireless_mode)) {
241 if (TEST_FLAG(psta->htpriv.ldpc_cap, LDPC_HT_CAP_TX))
242 en_ldpc = 1;
243 else
244 en_ldpc = 0;
245 } else
246 #endif
247 en_ldpc = 0;
248 }
249 }
250
251 return en_ldpc;
252 }
253
254
255 /*
256 * arg[0] = macid
257 * arg[1] = raid
258 * arg[2] = shortGIrate
259 * arg[3] = init_rate
260 */
rtl8822b_set_FwMacIdConfig_cmd(PADAPTER adapter,u64 mask,u8 * arg)261 void rtl8822b_set_FwMacIdConfig_cmd(PADAPTER adapter, u64 mask, u8 *arg)
262 {
263 HAL_DATA_TYPE *hal = GET_HAL_DATA(adapter);
264 struct macid_ctl_t *macid_ctl = &adapter->dvobj->macid_ctl;
265 struct sta_info *psta = NULL;
266 u8 mac_id, init_rate, raid, bw, sgi = _FALSE;
267 u8 h2c[RTW_HALMAC_H2C_MAX_SIZE] = {0};
268
269
270 if (hal->fw_ractrl == _FALSE) {
271 RTW_INFO(FUNC_ADPT_FMT" fw ractrl = _FALSE\n",
272 FUNC_ADPT_ARG(adapter));
273 return;
274 }
275
276 mac_id = arg[0];
277 raid = arg[1];
278 sgi = arg[2];
279 init_rate = arg[3];
280
281 if (mac_id < macid_ctl->num)
282 psta = macid_ctl->sta[mac_id];
283
284 if (!psta) {
285 RTW_INFO(FUNC_ADPT_FMT" macid:%u, sta is NULL\n",
286 FUNC_ADPT_ARG(adapter), mac_id);
287 return;
288 }
289
290 bw = psta->bw_mode;
291
292 RTW_INFO(FUNC_ADPT_FMT ": mac_id=%d raid=0x%x bw=%d mask=0x%016llx\n",
293 FUNC_ADPT_ARG(adapter), mac_id, raid, bw, mask);
294
295
296 MACID_CFG_SET_CMD_ID(h2c, CMD_ID_MACID_CFG);
297 MACID_CFG_SET_CLASS(h2c, CLASS_MACID_CFG);
298
299 /* common for h2c cmd 0x40 & 0x46 */
300 MACID_CFG_SET_MAC_ID(h2c, mac_id);
301 MACID_CFG_SET_RATE_ID(h2c, raid);
302 MACID_CFG_SET_SGI(h2c, (sgi) ? 1 : 0);
303 MACID_CFG_SET_BW(h2c, bw);
304 MACID_CFG_SET_LDPC_CAP(h2c, get_ra_ldpc(psta));
305 MACID_CFG_SET_WHT_EN(h2c, get_ra_vht_en(psta->wireless_mode, mask));
306
307
308 /* DisableTXPowerTraining */
309 if (hal->bDisableTXPowerTraining) {
310 MACID_CFG_SET_DISPT(h2c, 1);
311 RTW_INFO("%s: Disable PWT by driver\n", __FUNCTION__);
312 } else {
313 PDM_ODM_T pDM_OutSrc = &hal->odmpriv;
314
315 if (pDM_OutSrc->bDisablePowerTraining) {
316 MACID_CFG_SET_DISPT(h2c, 1);
317 RTW_INFO("%s: Disable PWT by DM\n", __FUNCTION__);
318 }
319 }
320
321 MACID_CFG_SET_RATE_MASK7_0(h2c, (u8)(mask & 0x000000ff));
322 MACID_CFG_SET_RATE_MASK15_8(h2c, (u8)((mask & 0x0000ff00) >> 8));
323 MACID_CFG_SET_RATE_MASK23_16(h2c, (u8)((mask & 0x00ff0000) >> 16));
324 MACID_CFG_SET_RATE_MASK31_24(h2c, (u8)((mask & 0xff000000) >> 24));
325
326 RTW_INFO("%s, mask=0x%016llx, mac_id=0x%x, raid=0x%x, shortGIrate=%x, power training=%02x\n"
327 , __FUNCTION__, mask, mac_id, raid, sgi, h2c[2] & BIT(6));
328
329 RTW_DBG_DUMP("H2C-MACIDConfig Parm:", h2c, RTW_HALMAC_H2C_MAX_SIZE);
330 rtw_halmac_send_h2c(adapter_to_dvobj(adapter), h2c);
331
332 /* update initial rate */
333 if (sgi)
334 init_rate |= BIT(7);
335
336 hal->INIDATA_RATE[mac_id] = init_rate;
337 }
338
rtl8822b_set_FwRssiSetting_cmd(PADAPTER adapter,u8 * param)339 void rtl8822b_set_FwRssiSetting_cmd(PADAPTER adapter, u8 *param)
340 {
341 u8 h2c[RTW_HALMAC_H2C_MAX_SIZE] = {0};
342 u8 mac_id = *param;
343 u8 rssi = *(param + 2);
344 u8 ra_info = 0;
345
346
347 RTW_INFO(FUNC_ADPT_FMT ": mac_id=%d rssi=%d param=%.2x-%.2x-%.2x\n",
348 FUNC_ADPT_ARG(adapter),
349 mac_id, rssi, *param, *(param + 1), *(param + 2));
350
351 RSSI_SETTING_SET_CMD_ID(h2c, CMD_ID_RSSI_SETTING);
352 RSSI_SETTING_SET_CLASS(h2c, CLASS_RSSI_SETTING);
353 RSSI_SETTING_SET_MAC_ID(h2c, mac_id);
354 RSSI_SETTING_SET_RSSI(h2c, rssi);
355 RSSI_SETTING_SET_RA_INFO(h2c, ra_info);
356
357 RTW_DBG_DUMP("H2C-RssiSetting Parm:", h2c, RTW_HALMAC_H2C_MAX_SIZE);
358 rtw_halmac_send_h2c(adapter_to_dvobj(adapter), h2c);
359 }
360
rtl8822b_set_FwAPReqRPT_cmd(PADAPTER adapter,u32 need_ack)361 void rtl8822b_set_FwAPReqRPT_cmd(PADAPTER adapter, u32 need_ack)
362 {
363 u8 h2c[RTW_HALMAC_H2C_MAX_SIZE] = {0};
364 u8 macid1 = 1, macid2 = 0;
365
366
367 RTW_INFO(FUNC_ADPT_FMT ": need_ack = %d\n",
368 FUNC_ADPT_ARG(adapter), need_ack);
369
370 AP_REQ_TXRPT_SET_CMD_ID(h2c, CMD_ID_AP_REQ_TXRPT);
371 AP_REQ_TXRPT_SET_CLASS(h2c, CLASS_AP_REQ_TXRPT);
372 AP_REQ_TXRPT_SET_STA1_MACID(h2c, macid1);
373 AP_REQ_TXRPT_SET_STA2_MACID(h2c, macid2);
374
375 RTW_DBG_DUMP("H2C-ApReqRpt Parm:", h2c, RTW_HALMAC_H2C_MAX_SIZE);
376 rtw_halmac_send_h2c(adapter_to_dvobj(adapter), h2c);
377 }
378
rtl8822b_req_txrpt_cmd(PADAPTER adapter,u8 macid)379 void rtl8822b_req_txrpt_cmd(PADAPTER adapter, u8 macid)
380 {
381 u8 h2c[RTW_HALMAC_H2C_MAX_SIZE] = {0};
382
383 AP_REQ_TXRPT_SET_CMD_ID(h2c, CMD_ID_AP_REQ_TXRPT);
384 AP_REQ_TXRPT_SET_CLASS(h2c, CLASS_AP_REQ_TXRPT);
385
386 AP_REQ_TXRPT_SET_STA1_MACID(h2c, macid);
387 AP_REQ_TXRPT_SET_STA2_MACID(h2c, 0xff);
388 AP_REQ_TXRPT_SET_RTY_OK_TOTAL(h2c, 0x00);
389 AP_REQ_TXRPT_SET_RTY_CNT_MACID(h2c, 0x00);
390 rtw_halmac_send_h2c(adapter_to_dvobj(adapter), h2c);
391
392 AP_REQ_TXRPT_SET_RTY_CNT_MACID(h2c, 0x01);
393 rtw_halmac_send_h2c(adapter_to_dvobj(adapter), h2c);
394 }
395
rtl8822b_set_FwPwrMode_cmd(PADAPTER adapter,u8 psmode)396 void rtl8822b_set_FwPwrMode_cmd(PADAPTER adapter, u8 psmode)
397 {
398 int i;
399 u8 smart_ps = 0;
400 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(adapter);
401 struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
402 u8 h2c[RTW_HALMAC_H2C_MAX_SIZE] = {0};
403 u8 PowerState = 0, awake_intvl = 1, byte5 = 0, rlbm = 0;
404 #ifdef CONFIG_P2P
405 struct wifidirect_info *wdinfo = &adapter->wdinfo;
406 #endif /* CONFIG_P2P */
407
408
409 if (pwrpriv->dtim > 0)
410 RTW_INFO(FUNC_ADPT_FMT ": FW LPS mode = %d, SmartPS=%d, dtim=%d, HW port id=%d\n",
411 FUNC_ADPT_ARG(adapter), psmode, pwrpriv->smart_ps, pwrpriv->dtim,
412 psmode == PS_MODE_ACTIVE ? pwrpriv->current_lps_hw_port_id:get_hw_port(adapter));
413 else
414 RTW_INFO(FUNC_ADPT_FMT ": FW LPS mode = %d, SmartPS=%d, HW port id=%d\n",
415 FUNC_ADPT_ARG(adapter), psmode, pwrpriv->smart_ps,
416 psmode == PS_MODE_ACTIVE ? pwrpriv->current_lps_hw_port_id:get_hw_port(adapter));
417
418 if (psmode == PS_MODE_MIN) {
419 rlbm = 0;
420 awake_intvl = 2;
421 smart_ps = pwrpriv->smart_ps;
422 } else if (psmode == PS_MODE_MAX) {
423 rlbm = 1;
424 awake_intvl = 2;
425 smart_ps = pwrpriv->smart_ps;
426 } else if (psmode == PS_MODE_DTIM) {
427 /* For WOWLAN LPS, DTIM = (awake_intvl - 1) */
428 if (pwrpriv->dtim > 0 && pwrpriv->dtim < 16)
429 /* DTIM = (awake_intvl - 1) */
430 awake_intvl = pwrpriv->dtim + 1;
431 else
432 /* DTIM = 3 */
433 awake_intvl = 4;
434
435 rlbm = 2;
436 smart_ps = pwrpriv->smart_ps;
437 } else {
438 rlbm = 2;
439 awake_intvl = 4;
440 smart_ps = pwrpriv->smart_ps;
441 }
442
443 #ifdef CONFIG_P2P
444 if (!rtw_p2p_chk_state(wdinfo, P2P_STATE_NONE)) {
445 awake_intvl = 2;
446 rlbm = 1;
447 }
448 #endif /* CONFIG_P2P */
449
450 if (adapter->registrypriv.wifi_spec == 1) {
451 awake_intvl = 2;
452 rlbm = 1;
453 }
454
455 if (psmode > 0) {
456 #ifdef CONFIG_BT_COEXIST
457 if (rtw_btcoex_IsBtControlLps(adapter) == _TRUE) {
458 PowerState = rtw_btcoex_RpwmVal(adapter);
459 byte5 = rtw_btcoex_LpsVal(adapter);
460
461 if ((rlbm == 2) && (byte5 & BIT(4))) {
462 /*
463 * Keep awake interval to 1 to prevent from
464 * decreasing coex performance
465 */
466 awake_intvl = 2;
467 rlbm = 2;
468 }
469 } else
470 #endif /* CONFIG_BT_COEXIST */
471 {
472 PowerState = 0x00; /* AllON(0x0C), RFON(0x04), RFOFF(0x00) */
473 byte5 = 0x40;
474 }
475 } else {
476 PowerState = 0x0C; /* AllON(0x0C), RFON(0x04), RFOFF(0x00) */
477 byte5 = 0x40;
478 }
479
480 SET_PWR_MODE_SET_CMD_ID(h2c, CMD_ID_SET_PWR_MODE);
481 SET_PWR_MODE_SET_CLASS(h2c, CLASS_SET_PWR_MODE);
482 SET_PWR_MODE_SET_MODE(h2c, (psmode > 0) ? 1 : 0);
483 SET_PWR_MODE_SET_SMART_PS(h2c, smart_ps);
484 SET_PWR_MODE_SET_RLBM(h2c, rlbm);
485 SET_PWR_MODE_SET_AWAKE_INTERVAL(h2c, awake_intvl);
486 SET_PWR_MODE_SET_B_ALL_QUEUE_UAPSD(h2c, adapter->registrypriv.uapsd_enable);
487 SET_PWR_MODE_SET_PWR_STATE(h2c, PowerState);
488 if (psmode == PS_MODE_ACTIVE) {
489 /* Leave LPS, set the same HW port ID */
490 SET_PWR_MODE_SET_PORT_ID(h2c, pwrpriv->current_lps_hw_port_id);
491 } else {
492 /* Enter LPS, record HW port ID */
493 SET_PWR_MODE_SET_PORT_ID(h2c, get_hw_port(adapter));
494 pwrpriv->current_lps_hw_port_id = get_hw_port(adapter);
495 }
496
497 if (byte5 & BIT(0))
498 SET_PWR_MODE_SET_LOW_POWER_RX_BCN(h2c, 1);
499 if (byte5 & BIT(1))
500 SET_PWR_MODE_SET_ANT_AUTO_SWITCH(h2c, 1);
501 if (byte5 & BIT(2))
502 SET_PWR_MODE_SET_PS_ALLOW_BT_HIGH_PRIORITY(h2c, 1);
503 if (byte5 & BIT(3))
504 SET_PWR_MODE_SET_PROTECT_BCN(h2c, 1);
505 if (byte5 & BIT(4))
506 SET_PWR_MODE_SET_SILENCE_PERIOD(h2c, 1);
507 if (byte5 & BIT(5))
508 SET_PWR_MODE_SET_FAST_BT_CONNECT(h2c, 1);
509 if (byte5 & BIT(6))
510 SET_PWR_MODE_SET_TWO_ANTENNA_EN(h2c, 1);
511
512 #ifdef CONFIG_LPS_LCLK
513 if (psmode != PS_MODE_ACTIVE) {
514 if ((pmlmeext->adaptive_tsf_done == _FALSE)
515 && (pmlmeext->bcn_cnt > 0)) {
516 u8 ratio_20_delay, ratio_80_delay;
517
518 /*
519 * byte 6 for adaptive_early_32k
520 * [0:3] = DrvBcnEarly (ms), [4:7] = DrvBcnTimeOut (ms)
521 * 20% for DrvBcnEarly, 80% for DrvBcnTimeOut
522 */
523 ratio_20_delay = 0;
524 ratio_80_delay = 0;
525 pmlmeext->DrvBcnEarly = 0xff;
526 pmlmeext->DrvBcnTimeOut = 0xff;
527
528 for (i = 0; i < 9; i++) {
529 pmlmeext->bcn_delay_ratio[i] = (pmlmeext->bcn_delay_cnt[i] * 100) / pmlmeext->bcn_cnt;
530
531 ratio_20_delay += pmlmeext->bcn_delay_ratio[i];
532 ratio_80_delay += pmlmeext->bcn_delay_ratio[i];
533
534 if (ratio_20_delay > 20 && pmlmeext->DrvBcnEarly == 0xff)
535 pmlmeext->DrvBcnEarly = i;
536
537 if (ratio_80_delay > 80 && pmlmeext->DrvBcnTimeOut == 0xff)
538 pmlmeext->DrvBcnTimeOut = i;
539
540 /* reset adaptive_early_32k cnt */
541 pmlmeext->bcn_delay_cnt[i] = 0;
542 pmlmeext->bcn_delay_ratio[i] = 0;
543 }
544
545 pmlmeext->bcn_cnt = 0;
546 pmlmeext->adaptive_tsf_done = _TRUE;
547 }
548 }
549 #endif /* CONFIG_LPS_LCLK */
550
551 #ifdef CONFIG_BT_COEXIST
552 rtw_btcoex_RecordPwrMode(adapter, h2c + 1, RTW_HALMAC_H2C_MAX_SIZE - 1);
553 #endif /* CONFIG_BT_COEXIST */
554
555 RTW_DBG_DUMP("H2C-PwrMode Parm:", h2c, RTW_HALMAC_H2C_MAX_SIZE);
556 rtw_halmac_send_h2c(adapter_to_dvobj(adapter), h2c);
557 }
558
rtl8822b_set_FwPwrModeInIPS_cmd(PADAPTER adapter,u8 cmd_param)559 void rtl8822b_set_FwPwrModeInIPS_cmd(PADAPTER adapter, u8 cmd_param)
560 {
561 }
562
rtl8822b_set_FwLowPwrLps_cmd(PADAPTER adapter,u8 enable)563 static s32 rtl8822b_set_FwLowPwrLps_cmd(PADAPTER adapter, u8 enable)
564 {
565 return _FALSE;
566 }
567
568 #ifdef CONFIG_BT_COEXIST
ConstructBeacon(PADAPTER adapter,u8 * pframe,u32 * pLength)569 static void ConstructBeacon(PADAPTER adapter, u8 *pframe, u32 *pLength)
570 {
571 struct rtw_ieee80211_hdr *pwlanhdr;
572 u16 *fctrl;
573 u32 rate_len, pktlen;
574 struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
575 struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
576 WLAN_BSSID_EX *cur_network = &pmlmeinfo->network;
577 u8 bc_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
578
579
580 pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
581
582 fctrl = &(pwlanhdr->frame_ctl);
583 *(fctrl) = 0;
584
585 _rtw_memcpy(pwlanhdr->addr1, bc_addr, ETH_ALEN);
586 _rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(adapter), ETH_ALEN);
587 _rtw_memcpy(pwlanhdr->addr3, get_my_bssid(cur_network), ETH_ALEN);
588
589 SetSeqNum(pwlanhdr, 0);
590 SetFrameSubType(pframe, WIFI_BEACON);
591
592 pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
593 pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
594
595 /* timestamp will be inserted by hardware */
596 pframe += 8;
597 pktlen += 8;
598
599 /* beacon interval: 2 bytes */
600 _rtw_memcpy(pframe, (u8 *)rtw_get_beacon_interval_from_ie(cur_network->IEs), 2);
601
602 pframe += 2;
603 pktlen += 2;
604
605 /* capability info: 2 bytes */
606 _rtw_memcpy(pframe, (u8 *)rtw_get_capability_from_ie(cur_network->IEs), 2);
607
608 pframe += 2;
609 pktlen += 2;
610
611 if ((pmlmeinfo->state & 0x03) == WIFI_FW_AP_STATE) {
612 pktlen += cur_network->IELength - sizeof(NDIS_802_11_FIXED_IEs);
613 _rtw_memcpy(pframe, cur_network->IEs + sizeof(NDIS_802_11_FIXED_IEs), pktlen);
614
615 goto _ConstructBeacon;
616 }
617
618 /* below for ad-hoc mode */
619
620 /* SSID */
621 pframe = rtw_set_ie(pframe, _SSID_IE_, cur_network->Ssid.SsidLength, cur_network->Ssid.Ssid, &pktlen);
622
623 /* supported rates... */
624 rate_len = rtw_get_rateset_len(cur_network->SupportedRates);
625 pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_, ((rate_len > 8) ? 8 : rate_len), cur_network->SupportedRates, &pktlen);
626
627 /* DS parameter set */
628 pframe = rtw_set_ie(pframe, _DSSET_IE_, 1, (unsigned char *)&(cur_network->Configuration.DSConfig), &pktlen);
629
630 if ((pmlmeinfo->state & 0x03) == WIFI_FW_ADHOC_STATE) {
631 u32 ATIMWindow;
632 /* IBSS Parameter Set... */
633 ATIMWindow = 0;
634 pframe = rtw_set_ie(pframe, _IBSS_PARA_IE_, 2, (unsigned char *)(&ATIMWindow), &pktlen);
635 }
636
637 /* todo: ERP IE */
638
639 /* EXTERNDED SUPPORTED RATE */
640 if (rate_len > 8)
641 pframe = rtw_set_ie(pframe, _EXT_SUPPORTEDRATES_IE_, (rate_len - 8), (cur_network->SupportedRates + 8), &pktlen);
642
643
644 /* todo:HT for adhoc */
645
646 _ConstructBeacon:
647
648 if ((pktlen + TXDESC_SIZE) > 512) {
649 RTW_INFO("beacon frame too large\n");
650 return;
651 }
652
653 *pLength = pktlen;
654 }
655
ConstructPSPoll(PADAPTER adapter,u8 * pframe,u32 * pLength)656 static void ConstructPSPoll(PADAPTER adapter, u8 *pframe, u32 *pLength)
657 {
658 struct rtw_ieee80211_hdr *pwlanhdr;
659 u16 *fctrl;
660 u32 pktlen;
661 struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
662 struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
663
664
665 pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
666
667 /* Frame control. */
668 fctrl = &(pwlanhdr->frame_ctl);
669 *(fctrl) = 0;
670 SetPwrMgt(fctrl);
671 SetFrameSubType(pframe, WIFI_PSPOLL);
672
673 /* AID. */
674 SetDuration(pframe, (pmlmeinfo->aid | 0xc000));
675
676 /* BSSID. */
677 _rtw_memcpy(pwlanhdr->addr1, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
678
679 /* TA. */
680 _rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(adapter), ETH_ALEN);
681
682 *pLength = 16;
683 }
684
ConstructNullFunctionData(PADAPTER adapter,u8 * pframe,u32 * pLength,u8 * StaAddr,u8 bQoS,u8 AC,u8 bEosp,u8 bForcePowerSave)685 static void ConstructNullFunctionData(
686 PADAPTER adapter,
687 u8 *pframe,
688 u32 *pLength,
689 u8 *StaAddr,
690 u8 bQoS,
691 u8 AC,
692 u8 bEosp,
693 u8 bForcePowerSave)
694 {
695 struct rtw_ieee80211_hdr *pwlanhdr;
696 u16 *fctrl;
697 u32 pktlen;
698 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
699 struct wlan_network *cur_network = &pmlmepriv->cur_network;
700 struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
701 struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
702
703
704 pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
705
706 fctrl = &pwlanhdr->frame_ctl;
707 *(fctrl) = 0;
708 if (bForcePowerSave)
709 SetPwrMgt(fctrl);
710
711 switch (cur_network->network.InfrastructureMode) {
712 case Ndis802_11Infrastructure:
713 SetToDs(fctrl);
714 _rtw_memcpy(pwlanhdr->addr1, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
715 _rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(adapter), ETH_ALEN);
716 _rtw_memcpy(pwlanhdr->addr3, StaAddr, ETH_ALEN);
717 break;
718 case Ndis802_11APMode:
719 SetFrDs(fctrl);
720 _rtw_memcpy(pwlanhdr->addr1, StaAddr, ETH_ALEN);
721 _rtw_memcpy(pwlanhdr->addr2, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
722 _rtw_memcpy(pwlanhdr->addr3, adapter_mac_addr(adapter), ETH_ALEN);
723 break;
724 case Ndis802_11IBSS:
725 default:
726 _rtw_memcpy(pwlanhdr->addr1, StaAddr, ETH_ALEN);
727 _rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(adapter), ETH_ALEN);
728 _rtw_memcpy(pwlanhdr->addr3, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
729 break;
730 }
731
732 SetSeqNum(pwlanhdr, 0);
733
734 if (bQoS == _TRUE) {
735 struct rtw_ieee80211_hdr_3addr_qos *pwlanqoshdr;
736
737 SetFrameSubType(pframe, WIFI_QOS_DATA_NULL);
738
739 pwlanqoshdr = (struct rtw_ieee80211_hdr_3addr_qos *)pframe;
740 SetPriority(&pwlanqoshdr->qc, AC);
741 SetEOSP(&pwlanqoshdr->qc, bEosp);
742
743 pktlen = sizeof(struct rtw_ieee80211_hdr_3addr_qos);
744 } else {
745 SetFrameSubType(pframe, WIFI_DATA_NULL);
746
747 pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
748 }
749
750 *pLength = pktlen;
751 }
752
ConstructProbeRsp(PADAPTER adapter,u8 * pframe,u32 * pLength,u8 * StaAddr,BOOLEAN bHideSSID)753 static void ConstructProbeRsp(PADAPTER adapter, u8 *pframe, u32 *pLength, u8 *StaAddr, BOOLEAN bHideSSID)
754 {
755 struct rtw_ieee80211_hdr *pwlanhdr;
756 u16 *fctrl;
757 u8 *mac, *bssid;
758 u32 pktlen;
759 struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
760 struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
761 WLAN_BSSID_EX *cur_network = &pmlmeinfo->network;
762 #if defined(CONFIG_AP_MODE) && defined(CONFIG_NATIVEAP_MLME)
763 u8 *pwps_ie;
764 uint wps_ielen;
765 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
766 #endif /* CONFIG_AP_MODE && CONFIG_NATIVEAP_MLME */
767 #ifdef CONFIG_P2P
768 struct wifidirect_info *pwdinfo = &adapter->wdinfo;
769 #ifdef CONFIG_WFD
770 u32 wfdielen = 0;
771 #endif /* CONFIG_WFD */
772 #endif /* CONFIG_P2P */
773
774 pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
775
776 mac = adapter_mac_addr(adapter);
777 bssid = cur_network->MacAddress;
778
779 fctrl = &(pwlanhdr->frame_ctl);
780 *(fctrl) = 0;
781 _rtw_memcpy(pwlanhdr->addr1, StaAddr, ETH_ALEN);
782 _rtw_memcpy(pwlanhdr->addr2, mac, ETH_ALEN);
783 _rtw_memcpy(pwlanhdr->addr3, bssid, ETH_ALEN);
784
785 RTW_INFO("%s FW Mac Addr:" MAC_FMT "\n", __FUNCTION__, MAC_ARG(mac));
786 RTW_INFO("%s FW IP Addr" IP_FMT "\n", __FUNCTION__, IP_ARG(StaAddr));
787
788 SetSeqNum(pwlanhdr, 0);
789 SetFrameSubType(fctrl, WIFI_PROBERSP);
790
791 pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
792 pframe += pktlen;
793
794 if (cur_network->IELength > MAX_IE_SZ)
795 return;
796
797 pwps_ie = rtw_get_wps_ie(cur_network->IEs + _FIXED_IE_LENGTH_,
798 cur_network->IELength - _FIXED_IE_LENGTH_, NULL, &wps_ielen);
799
800 /* inerset & update wps_probe_resp_ie */
801 if ((pmlmepriv->wps_probe_resp_ie != NULL) && pwps_ie && (wps_ielen > 0)) {
802 uint wps_offset, remainder_ielen;
803 u8 *premainder_ie;
804
805 wps_offset = (uint)(pwps_ie - cur_network->IEs);
806
807 premainder_ie = pwps_ie + wps_ielen;
808
809 remainder_ielen = cur_network->IELength - wps_offset - wps_ielen;
810
811 _rtw_memcpy(pframe, cur_network->IEs, wps_offset);
812 pframe += wps_offset;
813 pktlen += wps_offset;
814
815 wps_ielen = (uint)pmlmepriv->wps_probe_resp_ie[1];/* to get ie data len */
816 if ((wps_offset + wps_ielen + 2) <= MAX_IE_SZ) {
817 _rtw_memcpy(pframe, pmlmepriv->wps_probe_resp_ie, wps_ielen + 2);
818 pframe += wps_ielen + 2;
819 pktlen += wps_ielen + 2;
820 }
821
822 if ((wps_offset + wps_ielen + 2 + remainder_ielen) <= MAX_IE_SZ) {
823 _rtw_memcpy(pframe, premainder_ie, remainder_ielen);
824 pframe += remainder_ielen;
825 pktlen += remainder_ielen;
826 }
827 } else {
828 _rtw_memcpy(pframe, cur_network->IEs, cur_network->IELength);
829 pframe += cur_network->IELength;
830 pktlen += cur_network->IELength;
831 }
832
833 /* retrieve SSID IE from cur_network->Ssid */
834 {
835 u8 *ssid_ie;
836 sint ssid_ielen = 0;
837 sint ssid_ielen_diff;
838 u8 buf[MAX_IE_SZ];
839 u8 *ies = pframe + sizeof(struct rtw_ieee80211_hdr_3addr);
840
841 ssid_ie = rtw_get_ie(ies + _FIXED_IE_LENGTH_, _SSID_IE_, &ssid_ielen,
842 (pframe - ies) - _FIXED_IE_LENGTH_);
843
844 ssid_ielen_diff = cur_network->Ssid.SsidLength - ssid_ielen;
845
846 if (ssid_ie && cur_network->Ssid.SsidLength) {
847 uint remainder_ielen;
848 u8 *remainder_ie;
849
850 remainder_ie = ssid_ie + 2;
851 remainder_ielen = pframe - remainder_ie;
852
853 if (remainder_ielen > MAX_IE_SZ) {
854 RTW_WARN(FUNC_ADPT_FMT" remainder_ielen > MAX_IE_SZ\n", FUNC_ADPT_ARG(adapter));
855 remainder_ielen = MAX_IE_SZ;
856 }
857
858 _rtw_memcpy(buf, remainder_ie, remainder_ielen);
859 _rtw_memcpy(remainder_ie + ssid_ielen_diff, buf, remainder_ielen);
860 *(ssid_ie + 1) = cur_network->Ssid.SsidLength;
861 _rtw_memcpy(ssid_ie + 2, cur_network->Ssid.Ssid, cur_network->Ssid.SsidLength);
862 pframe += ssid_ielen_diff;
863 pktlen += ssid_ielen_diff;
864 }
865 }
866
867 #ifdef CONFIG_P2P
868 if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO)) {
869 u32 len;
870 #ifdef CONFIG_IOCTL_CFG80211
871 if (adapter_wdev_data(adapter)->p2p_enabled && (pwdinfo->driver_interface == DRIVER_CFG80211)) {
872 /* if pwdinfo->role == P2P_ROLE_DEVICE will call issue_probersp_p2p() */
873 len = pmlmepriv->p2p_go_probe_resp_ie_len;
874 if (pmlmepriv->p2p_go_probe_resp_ie && (len > 0))
875 _rtw_memcpy(pframe, pmlmepriv->p2p_go_probe_resp_ie, len);
876 } else
877 #endif /* CONFIG_IOCTL_CFG80211 */
878 {
879 len = build_probe_resp_p2p_ie(pwdinfo, pframe);
880 }
881
882 pframe += len;
883 pktlen += len;
884
885 #ifdef CONFIG_WFD
886 #ifdef CONFIG_IOCTL_CFG80211
887 if (_FALSE == pwdinfo->wfd_info->wfd_enable) {
888 len = 0;
889 if (pmlmepriv->wfd_probe_resp_ie && (pmlmepriv->wfd_probe_resp_ie_len > 0)) {
890 len = pmlmepriv->wfd_probe_resp_ie_len;
891 _rtw_memcpy(pframe, pmlmepriv->wfd_probe_resp_ie, len);
892 }
893 } else
894 #endif /* CONFIG_IOCTL_CFG80211 */
895 {
896 len = build_probe_resp_wfd_ie(pwdinfo, pframe, 0);
897 }
898
899 pframe += len;
900 pktlen += len;
901 #endif /* CONFIG_WFD */
902 }
903 #endif /* CONFIG_P2P */
904
905 *pLength = pktlen;
906 }
907
ConstructBtNullFunctionData(PADAPTER adapter,u8 * pframe,u32 * pLength,u8 * StaAddr,u8 bQoS,u8 AC,u8 bEosp,u8 bForcePowerSave)908 static void ConstructBtNullFunctionData(
909 PADAPTER adapter,
910 u8 *pframe,
911 u32 *pLength,
912 u8 *StaAddr,
913 u8 bQoS,
914 u8 AC,
915 u8 bEosp,
916 u8 bForcePowerSave)
917 {
918 struct rtw_ieee80211_hdr *pwlanhdr;
919 u16 *fctrl;
920 u32 pktlen;
921 struct mlme_ext_priv *pmlmeext;
922 struct mlme_ext_info *pmlmeinfo;
923 u8 bssid[ETH_ALEN];
924
925
926 RTW_INFO("+" FUNC_ADPT_FMT ": qos=%d eosp=%d ps=%d\n",
927 FUNC_ADPT_ARG(adapter), bQoS, bEosp, bForcePowerSave);
928
929 pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
930 pmlmeext = &adapter->mlmeextpriv;
931 pmlmeinfo = &pmlmeext->mlmext_info;
932
933 if (NULL == StaAddr) {
934 _rtw_memcpy(bssid, adapter_mac_addr(adapter), ETH_ALEN);
935 StaAddr = bssid;
936 }
937
938 fctrl = &pwlanhdr->frame_ctl;
939 *fctrl = 0;
940 if (bForcePowerSave)
941 SetPwrMgt(fctrl);
942
943 SetFrDs(fctrl);
944 _rtw_memcpy(pwlanhdr->addr1, StaAddr, ETH_ALEN);
945 _rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(adapter), ETH_ALEN);
946 _rtw_memcpy(pwlanhdr->addr3, adapter_mac_addr(adapter), ETH_ALEN);
947
948 SetDuration(pwlanhdr, 0);
949 SetSeqNum(pwlanhdr, 0);
950
951 if (bQoS == _TRUE) {
952 struct rtw_ieee80211_hdr_3addr_qos *pwlanqoshdr;
953
954 SetFrameSubType(pframe, WIFI_QOS_DATA_NULL);
955
956 pwlanqoshdr = (struct rtw_ieee80211_hdr_3addr_qos *)pframe;
957 SetPriority(&pwlanqoshdr->qc, AC);
958 SetEOSP(&pwlanqoshdr->qc, bEosp);
959
960 pktlen = sizeof(struct rtw_ieee80211_hdr_3addr_qos);
961 } else {
962 SetFrameSubType(pframe, WIFI_DATA_NULL);
963
964 pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
965 }
966
967 *pLength = pktlen;
968 }
969
SetFwRsvdPagePkt_BTCoex(PADAPTER adapter)970 static void SetFwRsvdPagePkt_BTCoex(PADAPTER adapter)
971 {
972 PHAL_DATA_TYPE hal;
973 struct xmit_frame *pcmdframe;
974 struct pkt_attrib *pattrib;
975 struct xmit_priv *pxmitpriv;
976 struct mlme_ext_priv *pmlmeext;
977 struct mlme_ext_info *pmlmeinfo;
978 u32 BeaconLength = 0;
979 u32 BTQosNullLength = 0;
980 u8 *ReservedPagePacket;
981 u8 TxDescLen, TxDescOffset;
982 u8 TotalPageNum = 0, CurtPktPageNum = 0, RsvdPageNum = 0;
983 u16 BufIndex, PageSize;
984 u32 TotalPacketLen, MaxRsvdPageBufSize = 0;
985 RSVDPAGE_LOC RsvdPageLoc;
986
987
988 hal = GET_HAL_DATA(adapter);
989 pxmitpriv = &adapter->xmitpriv;
990 pmlmeext = &adapter->mlmeextpriv;
991 pmlmeinfo = &pmlmeext->mlmext_info;
992 TxDescLen = TXDESC_SIZE;
993 TxDescOffset = TXDESC_OFFSET;
994
995 rtw_hal_get_def_var(adapter, HAL_DEF_TX_PAGE_SIZE, (u8 *)&PageSize);
996 RsvdPageNum = rtw_hal_get_txbuff_rsvd_page_num(adapter, _FALSE);
997 MaxRsvdPageBufSize = RsvdPageNum * PageSize;
998
999 pcmdframe = rtw_alloc_cmdxmitframe(pxmitpriv);
1000 if (pcmdframe == NULL) {
1001 RTW_INFO("%s: alloc ReservedPagePacket fail!\n", __FUNCTION__);
1002 return;
1003 }
1004
1005 ReservedPagePacket = pcmdframe->buf_addr;
1006 _rtw_memset(&RsvdPageLoc, 0, sizeof(RSVDPAGE_LOC));
1007
1008 /* (1) beacon */
1009 BufIndex = TxDescOffset;
1010 ConstructBeacon(adapter, &ReservedPagePacket[BufIndex], &BeaconLength);
1011
1012 /*
1013 * When we count the first page size, we need to reserve description size for the RSVD
1014 * packet, it will be filled in front of the packet in TXPKTBUF.
1015 */
1016 CurtPktPageNum = (u8)PageNum(TxDescLen + BeaconLength, PageSize);
1017 /*
1018 * If we don't add 1 more page, the WOWLAN function has a problem.
1019 * Maybe it's a bug of firmware?
1020 */
1021 if (CurtPktPageNum == 1)
1022 CurtPktPageNum += 1;
1023 TotalPageNum += CurtPktPageNum;
1024
1025 BufIndex += (CurtPktPageNum * PageSize);
1026
1027 /* Jump to lastest page */
1028 if (BufIndex < (MaxRsvdPageBufSize - PageSize)) {
1029 BufIndex = TxDescOffset + (MaxRsvdPageBufSize - PageSize);
1030 TotalPageNum = RsvdPageNum - 1;
1031 }
1032
1033 /* (6) BT Qos null data */
1034 RsvdPageLoc.LocBTQosNull = TotalPageNum;
1035 ConstructBtNullFunctionData(
1036 adapter,
1037 &ReservedPagePacket[BufIndex],
1038 &BTQosNullLength,
1039 NULL,
1040 _TRUE, 0, 0, _FALSE);
1041 rtw_hal_fill_fake_txdesc(adapter, &ReservedPagePacket[BufIndex - TxDescLen], BTQosNullLength, _FALSE, _TRUE, _FALSE);
1042
1043 CurtPktPageNum = (u8)PageNum(TxDescLen + BTQosNullLength, PageSize);
1044
1045 TotalPageNum += CurtPktPageNum;
1046
1047 TotalPacketLen = BufIndex + BTQosNullLength;
1048 if (TotalPacketLen > MaxRsvdPageBufSize) {
1049 RTW_INFO(FUNC_ADPT_FMT ": ERROR: The rsvd page size is not enough!!TotalPacketLen %d, MaxRsvdPageBufSize %d\n",
1050 FUNC_ADPT_ARG(adapter), TotalPacketLen, MaxRsvdPageBufSize);
1051 goto error;
1052 }
1053
1054 /* update attribute */
1055 pattrib = &pcmdframe->attrib;
1056 update_mgntframe_attrib(adapter, pattrib);
1057 pattrib->qsel = QSLT_BEACON;
1058 pattrib->pktlen = pattrib->last_txcmdsz = TotalPacketLen - TxDescOffset;
1059 #ifdef CONFIG_PCI_HCI
1060 dump_mgntframe(adapter, pcmdframe);
1061 #else /* !CONFIG_PCI_HCI */
1062 dump_mgntframe_and_wait(adapter, pcmdframe, 100);
1063 #endif /* !CONFIG_PCI_HCI */
1064
1065 rtl8822b_set_FwRsvdPage_cmd(adapter, &RsvdPageLoc);
1066 rtl8822b_set_FwAoacRsvdPage_cmd(adapter, &RsvdPageLoc);
1067
1068 return;
1069
1070 error:
1071 rtw_free_xmitframe(pxmitpriv, pcmdframe);
1072 }
1073
rtl8822b_download_BTCoex_AP_mode_rsvd_page(PADAPTER adapter)1074 void rtl8822b_download_BTCoex_AP_mode_rsvd_page(PADAPTER adapter)
1075 {
1076 PHAL_DATA_TYPE hal;
1077 struct mlme_ext_priv *pmlmeext;
1078 struct mlme_ext_info *pmlmeinfo;
1079 u8 bRecover = _FALSE;
1080 u8 bcn_valid = _FALSE;
1081 u8 DLBcnCount = 0;
1082 u32 poll = 0;
1083 u8 val8;
1084
1085
1086 RTW_INFO("+" FUNC_ADPT_FMT ": hw_port=%d fw_state=0x%08X\n",
1087 FUNC_ADPT_ARG(adapter), get_hw_port(adapter), get_fwstate(&adapter->mlmepriv));
1088
1089 #ifdef CONFIG_RTW_DEBUG
1090 if (check_fwstate(&adapter->mlmepriv, WIFI_AP_STATE) == _FALSE) {
1091 RTW_INFO(FUNC_ADPT_FMT ": [WARNING] not in AP mode!!\n",
1092 FUNC_ADPT_ARG(adapter));
1093 }
1094 #endif /* CONFIG_RTW_DEBUG */
1095
1096 hal = GET_HAL_DATA(adapter);
1097 pmlmeext = &adapter->mlmeextpriv;
1098 pmlmeinfo = &pmlmeext->mlmext_info;
1099
1100 /* We should set AID, correct TSF, HW seq enable before set JoinBssReport to Fw in 88/92C. */
1101 rtw_write16(adapter, REG_BCN_PSR_RPT, (0xC000 | pmlmeinfo->aid));
1102
1103 /* set REG_CR bit 8 */
1104 val8 = rtw_read8(adapter, REG_CR + 1);
1105 val8 |= BIT(0); /* ENSWBCN */
1106 rtw_write8(adapter, REG_CR + 1, val8);
1107
1108 /*
1109 * Disable Hw protection for a time which revserd for Hw sending beacon.
1110 * Fix download reserved page packet fail that access collision with the protection time.
1111 */
1112 val8 = rtw_read8(adapter, REG_BCN_CTRL);
1113 val8 &= ~EN_BCN_FUNCTION;
1114 val8 |= DIS_TSF_UDT;
1115 rtw_write8(adapter, REG_BCN_CTRL, val8);
1116
1117 /* Set FWHW_TXQ_CTRL 0x422[6]=0 to tell Hw the packet is not a real beacon frame. */
1118 if (hal->RegFwHwTxQCtrl & BIT(6))
1119 bRecover = _TRUE;
1120
1121 /* To tell Hw the packet is not a real beacon frame. */
1122 hal->RegFwHwTxQCtrl &= ~BIT(6);
1123 rtw_write8(adapter, REG_FWHW_TXQ_CTRL + 2, hal->RegFwHwTxQCtrl);
1124
1125 /* Clear beacon valid check bit. */
1126 rtw_hal_set_hwreg(adapter, HW_VAR_BCN_VALID, NULL);
1127 rtw_hal_set_hwreg(adapter, HW_VAR_DL_BCN_SEL, NULL);
1128
1129 DLBcnCount = 0;
1130 poll = 0;
1131 do {
1132 SetFwRsvdPagePkt_BTCoex(adapter);
1133 DLBcnCount++;
1134 do {
1135 rtw_yield_os();
1136
1137 /* check rsvd page download OK. */
1138 rtw_hal_get_hwreg(adapter, HW_VAR_BCN_VALID, &bcn_valid);
1139 poll++;
1140 } while (!bcn_valid && (poll % 10) != 0 && !RTW_CANNOT_RUN(adapter));
1141 } while (!bcn_valid && (DLBcnCount <= 100) && !RTW_CANNOT_RUN(adapter));
1142
1143 if (_TRUE == bcn_valid) {
1144 struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(adapter);
1145
1146 pwrctl->fw_psmode_iface_id = adapter->iface_id;
1147 RTW_INFO(ADPT_FMT": DL RSVD page success! DLBcnCount:%d, poll:%d\n",
1148 ADPT_ARG(adapter), DLBcnCount, poll);
1149 } else {
1150 RTW_INFO(ADPT_FMT": DL RSVD page fail! DLBcnCount:%d, poll:%d\n",
1151 ADPT_ARG(adapter), DLBcnCount, poll);
1152 RTW_INFO(ADPT_FMT": DL RSVD page fail! bSurpriseRemoved=%s\n",
1153 ADPT_ARG(adapter), rtw_is_surprise_removed(adapter) ? "True" : "False");
1154 RTW_INFO(ADPT_FMT": DL RSVD page fail! bDriverStopped=%s\n",
1155 ADPT_ARG(adapter), rtw_is_drv_stopped(adapter) ? "True" : "False");
1156 }
1157
1158 val8 = rtw_read8(adapter, REG_BCN_CTRL);
1159 val8 |= EN_BCN_FUNCTION;
1160 val8 &= ~DIS_TSF_UDT;
1161 rtw_write8(adapter, REG_BCN_CTRL, val8);
1162
1163 /*
1164 * To make sure that if there exists an adapter which would like to send beacon.
1165 * If exists, the origianl value of 0x422[6] will be 1, we should check this to
1166 * prevent from setting 0x422[6] to 0 after download reserved page, or it will cause
1167 * the beacon cannot be sent by HW.
1168 */
1169 if (bRecover) {
1170 hal->RegFwHwTxQCtrl |= BIT(6);
1171 rtw_write8(adapter, REG_FWHW_TXQ_CTRL + 2, hal->RegFwHwTxQCtrl);
1172 }
1173
1174 /* Clear CR[8] or beacon packet will not be send to TxBuf anymore. */
1175 #ifndef CONFIG_PCI_HCI
1176 val8 = rtw_read8(adapter, REG_CR + 1);
1177 val8 &= ~BIT(0); /* ~ENSWBCN */
1178 rtw_write8(adapter, REG_CR + 1, val8);
1179 #endif /* !CONFIG_PCI_HCI */
1180 }
1181 #endif /* CONFIG_BT_COEXIST */
1182
1183 #ifdef CONFIG_P2P_PS
rtl8822b_set_p2p_ps_offload_cmd(PADAPTER adapter,u8 p2p_ps_state)1184 void rtl8822b_set_p2p_ps_offload_cmd(PADAPTER adapter, u8 p2p_ps_state)
1185 {
1186 PHAL_DATA_TYPE hal = GET_HAL_DATA(adapter);
1187 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(adapter);
1188 struct wifidirect_info *pwdinfo = &adapter->wdinfo;
1189 u8 i;
1190 u8 h2c[RTW_HALMAC_H2C_MAX_SIZE] = {0};
1191
1192
1193 _rtw_memcpy(&h2c[1], &hal->p2p_ps_offload, sizeof(hal->p2p_ps_offload));
1194
1195 P2P_PS_OFFLOAD_SET_CMD_ID(h2c, CMD_ID_P2P_PS_OFFLOAD);
1196 P2P_PS_OFFLOAD_SET_CLASS(h2c, CLASS_P2P_PS_OFFLOAD);
1197
1198 switch (p2p_ps_state) {
1199 case P2P_PS_DISABLE:
1200 RTW_INFO("P2P_PS_DISABLE\n");
1201 _rtw_memset(&h2c[1], 0, sizeof(hal->p2p_ps_offload));
1202 break;
1203
1204 case P2P_PS_ENABLE:
1205 RTW_INFO("P2P_PS_ENABLE\n");
1206 /* update CTWindow value. */
1207 if (pwdinfo->ctwindow > 0) {
1208 P2P_PS_OFFLOAD_SET_CTWINDOW_EN(h2c, 1);
1209 rtw_write8(adapter, REG_CTWND_8822B, pwdinfo->ctwindow);
1210 }
1211
1212 /* hw only support 2 set of NoA */
1213 for (i = 0; i < pwdinfo->noa_num; i++) {
1214 /* To control the register setting for which NOA */
1215 rtw_write8(adapter, REG_TXCMD_NOA_SEL_8822B, (i << 4));
1216 if (i == 0)
1217 P2P_PS_OFFLOAD_SET_NOA0_EN(h2c, 1);
1218 else
1219 P2P_PS_OFFLOAD_SET_NOA1_EN(h2c, 1);
1220
1221 /* config P2P NoA Descriptor Register */
1222 /* config NOA duration */
1223 rtw_write32(adapter, REG_NOA_PARAM_8822B, pwdinfo->noa_duration[i]);
1224 /* config NOA interval */
1225 rtw_write32(adapter, (REG_NOA_PARAM_8822B + 4), pwdinfo->noa_interval[i]);
1226 /* config NOA start time */
1227 rtw_write32(adapter, (REG_NOA_PARAM_8822B + 8), pwdinfo->noa_start_time[i]);
1228 /* config NOA count */
1229 rtw_write8(adapter, (REG_NOA_PARAM_8822B + 12), pwdinfo->noa_count[i]);
1230 }
1231
1232 if ((pwdinfo->opp_ps == 1) || (pwdinfo->noa_num > 0)) {
1233 /* rst p2p circuit */
1234 rtw_write8(adapter, REG_P2P_RST_8822B, BIT(0));
1235
1236 P2P_PS_OFFLOAD_SET_OFFLOAD_EN(h2c, 1);
1237
1238 if (pwdinfo->role == P2P_ROLE_GO) {
1239 P2P_PS_OFFLOAD_SET_ROLE(h2c, 1);
1240 P2P_PS_OFFLOAD_SET_ALL_STA_SLEEP(h2c, 0);
1241 } else
1242 P2P_PS_OFFLOAD_SET_ROLE(h2c, 0);
1243
1244 ((struct P2P_PS_Offload_t *)&h2c[1])->discovery = 0;
1245 }
1246 break;
1247
1248 case P2P_PS_SCAN:
1249 RTW_INFO("P2P_PS_SCAN\n");
1250 ((struct P2P_PS_Offload_t *)&h2c[1])->discovery = 1;
1251 break;
1252
1253 case P2P_PS_SCAN_DONE:
1254 RTW_INFO("P2P_PS_SCAN_DONE\n");
1255 ((struct P2P_PS_Offload_t *)&h2c[1])->discovery = 0;
1256 pwdinfo->p2p_ps_state = P2P_PS_ENABLE;
1257 break;
1258
1259 default:
1260 break;
1261 }
1262
1263 RTW_DBG_DUMP("H2C-P2PPSOffload Parm:", h2c, RTW_HALMAC_H2C_MAX_SIZE);
1264 rtw_halmac_send_h2c(adapter_to_dvobj(adapter), h2c);
1265
1266 _rtw_memcpy(&hal->p2p_ps_offload, &h2c[1], sizeof(hal->p2p_ps_offload));
1267 }
1268 #endif /* CONFIG_P2P */
1269
1270 #ifdef CONFIG_TSF_RESET_OFFLOAD
1271 /*
1272 * ask FW to Reset sync register at Beacon early interrupt
1273 */
rtl8822b_reset_tsf(PADAPTER adapter,u8 reset_port)1274 u8 rtl8822b_reset_tsf(PADAPTER adapter, u8 reset_port)
1275 {
1276 u8 buf[2];
1277 u8 res = _SUCCESS;
1278
1279
1280 if (HW_PORT0 == reset_port) {
1281 buf[0] = 0x1;
1282 buf[1] = 0;
1283 } else {
1284 buf[0] = 0x0;
1285 buf[1] = 0x1;
1286 }
1287
1288 rtl8822b_fillh2ccmd(adapter, H2C_RESET_TSF, 2, buf);
1289
1290 return res;
1291 }
1292 #endif /* CONFIG_TSF_RESET_OFFLOAD */
1293
1294
rtl8822b_fw_update_beacon_cmd(PADAPTER adapter)1295 void rtl8822b_fw_update_beacon_cmd(PADAPTER adapter)
1296 {
1297 }
1298
1299 /*
1300 * Below functions are for C2H
1301 */
c2h_ccx_rpt(PADAPTER adapter,u8 * pdata)1302 static void c2h_ccx_rpt(PADAPTER adapter, u8 *pdata)
1303 {
1304 #ifdef CONFIG_XMIT_ACK
1305 u8 seq_no, retry_over, life_time_over;
1306
1307
1308 seq_no = C2H_CCX_RPT_GET_SEQ(pdata);
1309 retry_over = C2H_CCX_RPT_GET_RETRY_OVER(pdata);
1310 life_time_over = C2H_CCX_RPT_GET_LIFE_TIME_OVER(pdata);
1311
1312 if (retry_over || life_time_over)
1313 rtw_ack_tx_done(&adapter->xmitpriv, RTW_SCTX_DONE_CCX_PKT_FAIL);
1314 else
1315 rtw_ack_tx_done(&adapter->xmitpriv, RTW_SCTX_DONE_SUCCESS);
1316 #endif /* CONFIG_XMIT_ACK */
1317 }
1318
1319 static VOID
C2HTxRPTHandler_8822b(IN PADAPTER Adapter,IN u8 * CmdBuf,IN u8 CmdLen)1320 C2HTxRPTHandler_8822b(
1321 IN PADAPTER Adapter,
1322 IN u8 *CmdBuf,
1323 IN u8 CmdLen
1324 )
1325 {
1326 _irqL irqL;
1327 u8 macid = 0, IniRate = 0;
1328 u16 TxOK = 0, TxFail = 0;
1329 u8 TxOK0 = 0, TxOK1 = 0;
1330 u8 TxFail0 = 0, TxFail1 = 0;
1331 struct sta_priv *pstapriv = &(Adapter->stapriv);
1332 struct sta_info *psta=NULL;
1333 struct sta_info *pbcmc_stainfo = rtw_get_bcmc_stainfo(Adapter);
1334 //_list *plist, *phead;
1335
1336 if (!pstapriv->c2h_sta) {
1337 RTW_WARN("%s: No corresponding sta_info!\n", __FUNCTION__);
1338 return;
1339 }
1340 psta = pstapriv->c2h_sta;
1341 macid = C2H_AP_REQ_TXRPT_GET_STA1_MACID(CmdBuf);
1342 TxOK0 = C2H_AP_REQ_TXRPT_GET_TX_OK1_0(CmdBuf);
1343 TxOK1 = C2H_AP_REQ_TXRPT_GET_TX_OK1_1(CmdBuf);
1344 TxOK = (TxOK1 << 8) | TxOK0;
1345 TxFail0 = C2H_AP_REQ_TXRPT_GET_TX_FAIL1_0(CmdBuf);
1346 TxFail1 = C2H_AP_REQ_TXRPT_GET_TX_FAIL1_1(CmdBuf);
1347 TxFail = (TxFail1 << 8) | TxFail0;
1348 IniRate = C2H_AP_REQ_TXRPT_GET_INITIAL_RATE1(CmdBuf);
1349
1350 psta->sta_stats.tx_ok_cnt = TxOK;
1351 psta->sta_stats.tx_fail_cnt = TxFail;
1352
1353 }
1354
1355 static VOID
C2HSPC_STAT_8822b(IN PADAPTER Adapter,IN u8 * CmdBuf,IN u8 CmdLen)1356 C2HSPC_STAT_8822b(
1357 IN PADAPTER Adapter,
1358 IN u8 *CmdBuf,
1359 IN u8 CmdLen
1360 )
1361 {
1362 _irqL irqL;
1363 struct sta_priv *pstapriv = &(Adapter->stapriv);
1364 struct sta_info *psta=NULL;
1365 struct sta_info *pbcmc_stainfo = rtw_get_bcmc_stainfo(Adapter);
1366 _list *plist, *phead;
1367 u8 idx = C2H_SPECIAL_STATISTICS_GET_STATISTICS_IDX(CmdBuf);
1368
1369 if (!pstapriv->c2h_sta) {
1370 RTW_WARN("%s: No corresponding sta_info!\n", __FUNCTION__);
1371 return;
1372 }
1373 psta = pstapriv->c2h_sta;
1374 psta->sta_stats.tx_retry_cnt = ( C2H_SPECIAL_STATISTICS_GET_DATA3(CmdBuf) << 8 )| C2H_SPECIAL_STATISTICS_GET_DATA2(CmdBuf);
1375 pstapriv->c2h_sta = NULL;
1376 rtw_sctx_done(&pstapriv->gotc2h);
1377 }
1378
1379 /**
1380 * c2h = RXDESC + c2h packet
1381 * size = RXDESC_SIZE + c2h packet size
1382 * c2h payload = c2h packet revmoe id & seq
1383 */
process_c2h_event(PADAPTER adapter,u8 * c2h,u32 size)1384 static void process_c2h_event(PADAPTER adapter, u8 *c2h, u32 size)
1385 {
1386 PHAL_DATA_TYPE hal;
1387 struct mlme_ext_priv *pmlmeext;
1388 struct mlme_ext_info *pmlmeinfo;
1389 PDM_ODM_T pDM_Odm;
1390 u8 id, seq;
1391 u8 c2h_len, c2h_payload_len;
1392 u8 *pc2h_data, *pc2h_payload;
1393
1394
1395 if (!c2h) {
1396 RTW_INFO("%s: c2h buffer is NULL!!\n", __FUNCTION__);
1397 return;
1398 }
1399
1400 if (size < HALMAC_RX_DESC_SIZE_8822B) {
1401 RTW_INFO("%s: c2h length(%d) is smaller than RXDESC_SIZE(%d)!!\n",
1402 __FUNCTION__, size, HALMAC_RX_DESC_SIZE_8822B);
1403 return;
1404 }
1405
1406 hal = GET_HAL_DATA(adapter);
1407 pDM_Odm = &hal->odmpriv;
1408 pmlmeext = &adapter->mlmeextpriv;
1409 pmlmeinfo = &pmlmeext->mlmext_info;
1410
1411 /* shift rx desc len */
1412 pc2h_data = c2h + HALMAC_RX_DESC_SIZE_8822B;
1413 c2h_len = size - HALMAC_RX_DESC_SIZE_8822B;
1414
1415 id = C2H_GET_CMD_ID(pc2h_data);
1416 seq = C2H_GET_SEQ(pc2h_data);
1417
1418 /* shift 2 byte to remove cmd id & seq */
1419 pc2h_payload = pc2h_data + 2;
1420 c2h_payload_len = c2h_len - 2;
1421
1422 switch (id) {
1423 case CMD_ID_C2H_CCX_RPT:
1424 c2h_ccx_rpt(adapter, pc2h_data);
1425 break;
1426 #ifdef CONFIG_BT_COEXIST
1427 case C2H_BT_INFO:
1428 rtw_btcoex_BtInfoNotify(adapter, c2h_payload_len, pc2h_payload);
1429 break;
1430 case C2H_BT_MP_INFO:
1431 rtw_btcoex_BtMpRptNotify(adapter, c2h_payload_len, pc2h_payload);
1432 break;
1433 case C2H_BT_SCOREBOARD_STATUS:
1434 rtw_btcoex_ScoreBoardStatusNotify(adapter, c2h_payload_len, pc2h_payload);
1435 break;
1436 #endif
1437 case CMD_ID_C2H_AP_REQ_TXRPT:
1438 /*RTW_INFO("[C2H], C2H_AP_REQ_TXRPT!!\n");*/
1439 C2HTxRPTHandler_8822b(adapter, pc2h_data, c2h_len);
1440 break;
1441 case CMD_ID_C2H_SPECIAL_STATISTICS:
1442 /*RTW_INFO("[C2H], C2H_SPC_STAT!!\n");*/
1443 C2HSPC_STAT_8822b(adapter, pc2h_data, c2h_len);
1444 break;
1445 /* FW offload C2H is 0xFF cmd according to halmac function -
1446 * halmac_parse_c2h_packet
1447 */
1448
1449 case 0x15: /* mailbox status */
1450 break;
1451
1452 case 0xFF:
1453 /* indicate c2h pkt + rx desc to halmac */
1454 rtw_halmac_c2h_handle(adapter_to_dvobj(adapter), c2h, size);
1455 break;
1456 /* others for phydm */
1457 default:
1458 if (!(phydm_c2H_content_parsing(pDM_Odm, id, c2h_payload_len, pc2h_payload)))
1459 RTW_INFO("%s: [WARNING] unknown C2H(0x%02x)\n", __FUNCTION__, id);
1460 break;
1461 }
1462 }
1463
rtl8822b_c2h_handler(PADAPTER adapter,u8 * pbuf,u16 length)1464 void rtl8822b_c2h_handler(PADAPTER adapter, u8 *pbuf, u16 length)
1465 {
1466 #ifdef CONFIG_WOWLAN
1467 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(adapter);
1468
1469 if (pwrpriv->wowlan_mode == _TRUE) {
1470 RTW_INFO("%s: return because wowolan_mode==TRUE! CMDID=%d\n",
1471 __FUNCTION__, C2H_GET_CMD_ID(pbuf + RXDESC_SIZE));
1472 return;
1473 }
1474 #endif /* CONFIG_WOWLAN*/
1475
1476 process_c2h_event(adapter, pbuf, length);
1477 }
1478
1479 /**
1480 * pbuf = RXDESC + c2h packet
1481 * length = RXDESC_SIZE + c2h packet size
1482 */
rtl8822b_c2h_handler_no_io(PADAPTER adapter,u8 * pbuf,u16 length)1483 void rtl8822b_c2h_handler_no_io(PADAPTER adapter, u8 *pbuf, u16 length)
1484 {
1485 u8 id, seq, c2h_size;
1486 u8 *pc2h_content;
1487
1488
1489 if ((length == 0) || (!pbuf))
1490 return;
1491
1492 /* shift rx desc len to get c2h packet content */
1493 pc2h_content = pbuf + HALMAC_RX_DESC_SIZE_8822B;
1494 id = C2H_GET_CMD_ID(pc2h_content);
1495 seq = C2H_GET_SEQ(pc2h_content);
1496
1497 RTW_DBG("%s: C2H, ID=%d seq=%d len=%d\n",
1498 __FUNCTION__, id, seq, length);
1499
1500 switch (id) {
1501 /* no I/O, process directly */
1502 case CMD_ID_C2H_SND_TXBF:
1503 case CMD_ID_C2H_CCX_RPT:
1504 case C2H_BT_MP_INFO:
1505 case C2H_FW_CHNL_SWITCH_COMPLETE:
1506 case C2H_IQK_FINISH:
1507 case C2H_BCN_EARLY_RPT:
1508 process_c2h_event(adapter, pbuf, length);
1509 break;
1510
1511 /* need I/O, run in command thread */
1512 default:
1513 if (rtw_c2h_packet_wk_cmd(adapter, pbuf, length) == _FAIL)
1514 RTW_ERR("%s: C2H(%d) enqueue FAIL!\n", __FUNCTION__, id);
1515 break;
1516 }
1517 }
1518
c2h_id_filter_ccx_8822b(u8 * buf)1519 s32 c2h_id_filter_ccx_8822b(u8 *buf)
1520 {
1521 struct c2h_evt_hdr_88xx *c2h_evt = (struct c2h_evt_hdr_88xx *)buf;
1522 s32 ret = _FALSE;
1523 if (c2h_evt->id == C2H_AP_REQ_TXRPT)
1524 ret = _TRUE;
1525 else if (c2h_evt->id == C2H_SPC_STAT)
1526 ret = _TRUE;
1527
1528 return ret;
1529 }
1530