570 lines
16 KiB
C
570 lines
16 KiB
C
/******************************************************************************
|
|
*
|
|
* Copyright(c) 2019 Realtek Corporation.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of version 2 of the GNU General Public License as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
* more details.
|
|
*
|
|
*****************************************************************************/
|
|
#define _HAL_WOW_C_
|
|
#include "hal_headers.h"
|
|
|
|
#ifdef CONFIG_WOWLAN
|
|
|
|
#define case_rsn(rsn) \
|
|
case MAC_AX_WOW_##rsn: return RTW_WOW_RSN_##rsn
|
|
|
|
u8 _trans_wake_rsn(u8 mac_rsn)
|
|
{
|
|
switch (mac_rsn) {
|
|
case_rsn(RX_PAIRWISEKEY);
|
|
case_rsn(RX_GTK);
|
|
case_rsn(RX_FOURWAY_HANDSHAKE);
|
|
case_rsn(RX_DISASSOC);
|
|
case_rsn(RX_DEAUTH);
|
|
case_rsn(RX_ARP_REQUEST);
|
|
case_rsn(RX_NS);
|
|
case_rsn(RX_EAPREQ_IDENTIFY);
|
|
case_rsn(FW_DECISION_DISCONNECT);
|
|
case_rsn(RX_MAGIC_PKT);
|
|
case_rsn(RX_UNICAST_PKT);
|
|
case_rsn(RX_PATTERN_PKT);
|
|
case_rsn(RTD3_SSID_MATCH);
|
|
case_rsn(RX_DATA_PKT);
|
|
case_rsn(RX_SSDP_MATCH);
|
|
case_rsn(RX_WSD_MATCH);
|
|
case_rsn(RX_SLP_MATCH);
|
|
case_rsn(RX_LLTD_MATCH);
|
|
case_rsn(RX_MDNS_MATCH);
|
|
case_rsn(RX_REALWOW_V2_WAKEUP_PKT);
|
|
case_rsn(RX_REALWOW_V2_ACK_LOST);
|
|
case_rsn(RX_REALWOW_V2_TX_KAPKT);
|
|
case_rsn(ENABLE_FAIL_DMA_IDLE);
|
|
case_rsn(ENABLE_FAIL_DMA_PAUSE);
|
|
case_rsn(RTIME_FAIL_DMA_IDLE);
|
|
case_rsn(RTIME_FAIL_DMA_PAUSE);
|
|
case_rsn(RX_SNMP_MISMATCHED_PKT);
|
|
case_rsn(RX_DESIGNATED_MAC_PKT);
|
|
case_rsn(NLO_SSID_MACH);
|
|
case_rsn(AP_OFFLOAD_WAKEUP);
|
|
case_rsn(DMAC_ERROR_OCCURRED);
|
|
case_rsn(EXCEPTION_OCCURRED);
|
|
case_rsn(L0_TO_L1_ERROR_OCCURRED);
|
|
case_rsn(ASSERT_OCCURRED);
|
|
case_rsn(L2_ERROR_OCCURRED);
|
|
case_rsn(WDT_TIMEOUT_WAKE);
|
|
case_rsn(RX_ACTION);
|
|
case_rsn(CLK_32K_UNLOCK);
|
|
case_rsn(CLK_32K_LOCK);
|
|
default:
|
|
return RTW_WOW_RSN_MAX;
|
|
}
|
|
}
|
|
|
|
#define MAX_POLLING_WOW_FW_STS_CNT 1000 /* 50ms */
|
|
|
|
static enum rtw_hal_status _hal_check_wow_fw_ready(void *hal, u8 func_en)
|
|
{
|
|
struct hal_info_t *hal_info = (struct hal_info_t *)hal;
|
|
enum rtw_hal_status hstats = RTW_HAL_STATUS_FAILURE;
|
|
void* drv_priv = hal_to_drvpriv(hal_info);
|
|
u8 fw_status = 0;
|
|
u32 poll_cnt = 0;
|
|
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "[wow] %s : start polling... (func_en %d)\n", __func__, func_en);
|
|
|
|
/* polling fw status */
|
|
while (1) {
|
|
|
|
if (poll_cnt >= MAX_POLLING_WOW_FW_STS_CNT) {
|
|
PHL_ERR("%s polling fw status timeout !!!\n", __func__);
|
|
hstats = RTW_HAL_STATUS_FAILURE;
|
|
break;
|
|
}
|
|
|
|
hstats = rtw_hal_mac_get_wow_fw_status(hal_info, &fw_status,
|
|
func_en);
|
|
|
|
if (RTW_HAL_STATUS_SUCCESS != hstats) {
|
|
|
|
PHL_ERR("%s : status %u\n", __func__, fw_status);
|
|
break;
|
|
}
|
|
|
|
if (fw_status) {
|
|
hstats = RTW_HAL_STATUS_SUCCESS;
|
|
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_,
|
|
"%s : polling count %u\n", __func__, poll_cnt);
|
|
break;
|
|
} else {
|
|
|
|
_os_delay_us(drv_priv, 50);
|
|
|
|
}
|
|
poll_cnt++;
|
|
|
|
}
|
|
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "[wow] %s : finish polling... (func_en %d)\n", __func__, func_en);
|
|
|
|
return hstats;
|
|
}
|
|
|
|
enum rtw_hal_status rtw_hal_get_wake_rsn(void *hal, enum rtw_wow_wake_reason *wake_rsn, u8 *reset)
|
|
{
|
|
struct hal_info_t *hal_info = (struct hal_info_t *)hal;
|
|
enum rtw_hal_status hstats = RTW_HAL_STATUS_FAILURE;
|
|
u8 mac_rsn = 0;
|
|
|
|
hstats = rtw_hal_mac_get_wake_rsn(hal_info, &mac_rsn, reset);
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "%s : wake rsn from mac in hex 0x%x (reset %d).\n",
|
|
__func__, mac_rsn, *reset);
|
|
|
|
if (RTW_HAL_STATUS_SUCCESS != hstats) {
|
|
PHL_ERR("%s : rtw_hal_mac_get_wake_rsn failed.\n", __func__);
|
|
} else {
|
|
*wake_rsn = (mac_rsn == 0) ? RTW_WOW_RSN_UNKNOWN : _trans_wake_rsn(mac_rsn) ;
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "%s : wake reason %u.\n", __func__, *wake_rsn);
|
|
}
|
|
|
|
return hstats;
|
|
}
|
|
|
|
enum rtw_hal_status rtw_hal_cfg_wow_sleep(void *hal, u8 sleep)
|
|
{
|
|
struct hal_info_t *hal_info = (struct hal_info_t *)hal;
|
|
enum rtw_hal_status hstats = RTW_HAL_STATUS_FAILURE;
|
|
|
|
hstats = rtw_hal_mac_cfg_wow_sleep(hal_info, sleep);
|
|
|
|
if (RTW_HAL_STATUS_SUCCESS != hstats)
|
|
PHL_ERR("%s : sleep %u\n", __func__, sleep);
|
|
|
|
return hstats;
|
|
}
|
|
|
|
enum rtw_hal_status rtw_hal_get_wow_aoac_rpt(void *hal, struct rtw_aoac_report *aoac_info, u8 rx_ready)
|
|
{
|
|
struct hal_info_t *hal_info = (struct hal_info_t *)hal;
|
|
enum rtw_hal_status hstatus = RTW_HAL_STATUS_FAILURE;
|
|
|
|
FUNCIN();
|
|
|
|
/* get aoac report */
|
|
hstatus = rtw_hal_mac_get_aoac_rpt(hal_info, aoac_info, rx_ready);
|
|
|
|
if (RTW_HAL_STATUS_SUCCESS != hstatus)
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "[wow] %s(): failed with status(%u)\n", __func__, hstatus);
|
|
|
|
FUNCOUT();
|
|
|
|
return hstatus;
|
|
}
|
|
|
|
|
|
enum rtw_hal_status rtw_hal_reset_pkt_ofld_state(void *hal)
|
|
{
|
|
|
|
struct hal_info_t *hal_info = (struct hal_info_t *)hal;
|
|
enum rtw_hal_status hstats = RTW_HAL_STATUS_FAILURE;
|
|
|
|
hstats = rtw_hal_mac_reset_pkt_ofld_state(hal_info);
|
|
|
|
if (RTW_HAL_STATUS_SUCCESS != hstats)
|
|
PHL_ERR("%s : failed \n", __func__);
|
|
|
|
return hstats;
|
|
}
|
|
|
|
#ifdef CONFIG_PCI_HCI
|
|
enum rtw_hal_status rtw_hal_wow_cfg_txdma(void *hal, u8 en)
|
|
{
|
|
struct hal_info_t *hal_info = (struct hal_info_t *)hal;
|
|
struct hal_trx_ops *trx_ops = hal_info->trx_ops;
|
|
|
|
PHL_TRACE(COMP_PHL_DBG, _PHL_DEBUG_, "%s : enable %d.\n", __func__, en);
|
|
|
|
trx_ops->cfg_wow_txdma(hal_info, en);
|
|
|
|
return RTW_HAL_STATUS_SUCCESS;
|
|
}
|
|
#endif
|
|
|
|
enum rtw_hal_status
|
|
rtw_hal_wow_cfg_nlo(void *hal, enum SCAN_OFLD_OP op, u16 mac_id,
|
|
u8 hw_band, u8 hw_port, struct rtw_nlo_info *cfg)
|
|
{
|
|
struct hal_info_t *hal_info = (struct hal_info_t *)hal;
|
|
enum rtw_hal_status hstatus = RTW_HAL_STATUS_FAILURE;
|
|
struct scan_ofld_info info = {0};
|
|
u64 tsf;
|
|
u32 tsf_h = 0, tsf_l = 0;
|
|
|
|
if (cfg->delay != 0) {
|
|
hstatus = rtw_hal_mac_get_tsf(hal, &hw_port, &tsf_h, &tsf_l);
|
|
if (hstatus == RTW_HAL_STATUS_SUCCESS) {
|
|
tsf = ((u64)tsf_h << 32) | tsf_l;
|
|
tsf += cfg->delay * 1000;
|
|
tsf_h = tsf >> 32;
|
|
tsf_l = (u32)tsf;
|
|
info.tsf_high = tsf_h;
|
|
info.tsf_low = tsf_l;
|
|
} else {
|
|
PHL_WARN("%s Getting TSF failed \n", __func__);
|
|
}
|
|
|
|
}
|
|
/* configure scan offload */
|
|
info.operation = op;
|
|
info.probe_req_pkt_id = cfg->probe_req_id;
|
|
info.period = cfg->period;
|
|
info.slow_period = cfg->slow_period;
|
|
info.cycle = cfg->cycle;
|
|
|
|
if (info.period == 0 && info.slow_period == 0) {
|
|
info.mode = SCAN_OFLD_MD_ONCE;
|
|
} else if (info.period == 0) {
|
|
info.mode = SCAN_OFLD_MD_SEEMLESS;
|
|
} else if (info.slow_period == 0) {
|
|
info.mode = SCAN_OFLD_MD_PD;
|
|
} else {
|
|
info.mode = SCAN_OFLD_MD_PD_SLOW;
|
|
}
|
|
|
|
hstatus = rtw_hal_mac_scan_ofld(hal_info, (u8)mac_id,
|
|
hw_band, hw_port, &info);
|
|
|
|
if (hstatus != RTW_HAL_STATUS_SUCCESS)
|
|
return hstatus;
|
|
|
|
return hstatus;
|
|
}
|
|
|
|
enum rtw_hal_status
|
|
rtw_hal_wow_cfg_nlo_chnl_list(void *hal, struct rtw_nlo_info *cfg)
|
|
{
|
|
struct hal_info_t *hal_info = (struct hal_info_t *)hal;
|
|
enum rtw_hal_status hstatus = RTW_HAL_STATUS_FAILURE;
|
|
u8 i = 0;
|
|
|
|
if (cfg->channel_num == 0)
|
|
return RTW_HAL_STATUS_FAILURE;
|
|
|
|
for (i = 0; i < cfg->channel_num; i++) {
|
|
/* set channel to mac */
|
|
hstatus = rtw_hal_mac_scan_ofld_add_ch(hal_info,
|
|
&cfg->channel_list[i],
|
|
i == (cfg->channel_num-1) ? true : false);
|
|
if (hstatus != RTW_HAL_STATUS_SUCCESS)
|
|
return hstatus;
|
|
}
|
|
|
|
return hstatus;
|
|
}
|
|
|
|
enum rtw_hal_status rtw_hal_wow_init(struct rtw_phl_com_t *phl_com, void *hal,
|
|
struct rtw_phl_stainfo_t *sta)
|
|
{
|
|
struct hal_info_t *hal_info = (struct hal_info_t *)hal;
|
|
enum rtw_hal_status hal_status = RTW_HAL_STATUS_FAILURE;
|
|
struct hal_ops_t *hal_ops = hal_get_ops(hal_info);
|
|
|
|
FUNCIN_WSTS(hal_status);
|
|
|
|
/* download wowlan fw and do related tasks needed after redownload fw */
|
|
hal_status = hal_ops->hal_wow_init(phl_com, hal_info, sta);
|
|
if (hal_status != RTW_HAL_STATUS_SUCCESS)
|
|
return hal_status;
|
|
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "%s successfully done.\n", __func__);
|
|
|
|
FUNCOUT_WSTS(hal_status);
|
|
|
|
return hal_status;
|
|
}
|
|
|
|
enum rtw_hal_status rtw_hal_wow_deinit(struct rtw_phl_com_t *phl_com, void *hal,
|
|
struct rtw_phl_stainfo_t *sta)
|
|
{
|
|
struct hal_info_t *hal_info = (struct hal_info_t *)hal;
|
|
enum rtw_hal_status hal_status = RTW_HAL_STATUS_FAILURE;
|
|
struct hal_ops_t *hal_ops = hal_get_ops(hal_info);
|
|
|
|
FUNCIN_WSTS(hal_status);
|
|
|
|
/* download wowlan fw and do related tasks needed after redownload fw */
|
|
hal_status = hal_ops->hal_wow_deinit(phl_com, hal_info, sta);
|
|
if (hal_status != RTW_HAL_STATUS_SUCCESS)
|
|
return hal_status;
|
|
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "%s successfully done.\n", __func__);
|
|
|
|
FUNCOUT_WSTS(hal_status);
|
|
|
|
return hal_status;
|
|
}
|
|
|
|
enum rtw_hal_status
|
|
rtw_hal_wow_func_en(struct rtw_phl_com_t *phl_com, void *hal, u16 macid,
|
|
struct rtw_hal_wow_cfg *cfg)
|
|
{
|
|
|
|
struct hal_info_t *hal_info = (struct hal_info_t *)hal;
|
|
enum rtw_hal_status hstatus = RTW_HAL_STATUS_FAILURE;
|
|
|
|
FUNCIN();
|
|
|
|
do {
|
|
/* config wow cam : pattern match */
|
|
#ifndef RTW_WKARD_WOW_SKIP_WOW_CAM_CONFIG
|
|
hstatus = rtw_hal_mac_cfg_wow_cam(hal_info, macid, true, cfg->pattern_match_info);
|
|
if (RTW_HAL_STATUS_SUCCESS != hstatus)
|
|
break;
|
|
#endif
|
|
/* gtk offload */
|
|
if (cfg->gtk_ofld_cfg->gtk_en) {
|
|
hstatus = rtw_hal_mac_cfg_gtk_ofld(hal_info, macid, true,
|
|
cfg->gtk_ofld_cfg);
|
|
if (RTW_HAL_STATUS_SUCCESS != hstatus)
|
|
break;
|
|
}
|
|
/* arp offload */
|
|
if (cfg->arp_ofld_cfg->arp_en) {
|
|
hstatus = rtw_hal_mac_cfg_arp_ofld(hal_info, macid, true,
|
|
cfg->arp_ofld_cfg);
|
|
if (RTW_HAL_STATUS_SUCCESS != hstatus)
|
|
break;
|
|
}
|
|
/* ndp offload */
|
|
if (cfg->ndp_ofld_cfg->ndp_en) {
|
|
hstatus = rtw_hal_mac_cfg_ndp_ofld(hal_info, macid, true,
|
|
cfg->ndp_ofld_cfg);
|
|
if (RTW_HAL_STATUS_SUCCESS != hstatus)
|
|
break;
|
|
}
|
|
/* config keep alive */
|
|
if (cfg->keep_alive_cfg->keep_alive_en) {
|
|
hstatus = rtw_hal_mac_cfg_keep_alive(hal_info, macid, true,
|
|
cfg->keep_alive_cfg);
|
|
if (RTW_HAL_STATUS_SUCCESS != hstatus)
|
|
break;
|
|
}
|
|
/* config disconnect detection */
|
|
if (cfg->disc_det_cfg->disc_det_en) {
|
|
hstatus = rtw_hal_mac_cfg_disc_dec(hal_info, macid, true,
|
|
cfg->disc_det_cfg);
|
|
if (RTW_HAL_STATUS_SUCCESS != hstatus)
|
|
break;
|
|
}
|
|
/* realwow offload */
|
|
if (cfg->realwow_cfg->realwow_en) {
|
|
hstatus = rtw_hal_mac_cfg_realwow(hal_info, macid, true,
|
|
cfg->realwow_cfg);
|
|
if (RTW_HAL_STATUS_SUCCESS != hstatus)
|
|
break;
|
|
}
|
|
/* config gpio */
|
|
if (cfg->wow_gpio->d2h_gpio_info.dev2hst_gpio_en) {
|
|
hstatus = rtw_hal_mac_cfg_dev2hst_gpio(hal_info, true, cfg->wow_gpio);
|
|
if (RTW_HAL_STATUS_SUCCESS != hstatus)
|
|
break;
|
|
}
|
|
/* network list offload */
|
|
if (cfg->nlo_cfg->nlo_en) {
|
|
hstatus = rtw_hal_mac_cfg_nlo(hal_info, macid, true, cfg->nlo_cfg);
|
|
if (RTW_HAL_STATUS_SUCCESS != hstatus)
|
|
break;
|
|
}
|
|
} while(0);
|
|
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "[wow] %s status(%u).\n", __func__, hstatus);
|
|
|
|
FUNCOUT();
|
|
|
|
return hstatus;
|
|
}
|
|
|
|
enum rtw_hal_status
|
|
rtw_hal_wow_func_dis(struct rtw_phl_com_t *phl_com, void *hal, u16 macid,
|
|
struct rtw_hal_wow_cfg *cfg)
|
|
{
|
|
|
|
struct hal_info_t *hal_info = (struct hal_info_t *)hal;
|
|
enum rtw_hal_status hstatus = RTW_HAL_STATUS_FAILURE;
|
|
|
|
FUNCIN();
|
|
|
|
/* cancel pattern match */
|
|
#ifndef RTW_WKARD_WOW_SKIP_WOW_CAM_CONFIG
|
|
hstatus = rtw_hal_mac_cfg_wow_cam(hal_info, macid, false, NULL);
|
|
if (RTW_HAL_STATUS_SUCCESS != hstatus)
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "[wow] rtw_hal_mac_cfg_wow_cam failed \n");
|
|
#endif
|
|
/* cancel gtk offload */
|
|
if (cfg->gtk_ofld_cfg->gtk_en) {
|
|
hstatus = rtw_hal_mac_cfg_gtk_ofld(hal_info, macid, false, NULL);
|
|
if (RTW_HAL_STATUS_SUCCESS != hstatus)
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "[wow] rtw_hal_mac_cfg_gtk_ofld failed \n");
|
|
}
|
|
/* cancel arp offload */
|
|
if (cfg->arp_ofld_cfg->arp_en) {
|
|
hstatus = rtw_hal_mac_cfg_arp_ofld(hal_info, macid, false, NULL);
|
|
if (RTW_HAL_STATUS_SUCCESS != hstatus)
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "[wow] rtw_hal_mac_cfg_arp_ofld failed \n");
|
|
}
|
|
/* cancel ndp offload */
|
|
if (cfg->ndp_ofld_cfg->ndp_en) {
|
|
hstatus = rtw_hal_mac_cfg_ndp_ofld(hal_info, macid, false, NULL);
|
|
if (RTW_HAL_STATUS_SUCCESS != hstatus)
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "[wow] rtw_hal_mac_cfg_ndp_ofld failed \n");
|
|
}
|
|
/* disable keep alive */
|
|
if (cfg->keep_alive_cfg->keep_alive_en) {
|
|
hstatus = rtw_hal_mac_cfg_keep_alive(hal_info, macid, false, NULL);
|
|
if (RTW_HAL_STATUS_SUCCESS != hstatus)
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "[wow] rtw_hal_mac_cfg_keep_alive failed \n");
|
|
}
|
|
/* disable disconect detection */
|
|
if (cfg->disc_det_cfg->disc_det_en) {
|
|
hstatus = rtw_hal_mac_cfg_disc_dec(hal_info, macid, false, NULL);
|
|
if (RTW_HAL_STATUS_SUCCESS != hstatus)
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "[wow] rtw_hal_mac_cfg_disc_dec failed \n");
|
|
}
|
|
/* realwow offload */
|
|
if (cfg->realwow_cfg->realwow_en) {
|
|
hstatus = rtw_hal_mac_cfg_realwow(hal_info, macid, false, NULL);
|
|
if (RTW_HAL_STATUS_SUCCESS != hstatus)
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "[wow] rtw_hal_mac_cfg_realwow_ofld failed \n");
|
|
}
|
|
/* config gpio */
|
|
if (cfg->wow_gpio->d2h_gpio_info.dev2hst_gpio_en) {
|
|
hstatus = rtw_hal_mac_cfg_dev2hst_gpio(hal_info, false, NULL);
|
|
if (RTW_HAL_STATUS_SUCCESS != hstatus)
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "[wow] rtw_hal_mac_cfg_dev2hst_gpio failed \n");
|
|
}
|
|
/* nlo */
|
|
if (cfg->nlo_cfg->nlo_en) {
|
|
hstatus = rtw_hal_mac_cfg_nlo(hal_info, macid, false, NULL);
|
|
if (RTW_HAL_STATUS_SUCCESS != hstatus)
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "[wow] rtw_hal_mac_cfg_nlo failed \n");
|
|
}
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "[wow] %s status(%u).\n", __func__, hstatus);
|
|
|
|
FUNCOUT();
|
|
|
|
return RTW_HAL_STATUS_SUCCESS;
|
|
}
|
|
|
|
enum rtw_hal_status rtw_hal_wow_func_start(struct rtw_phl_com_t *phl_com, void *hal, u16 macid, struct rtw_hal_wow_cfg *cfg)
|
|
{
|
|
struct hal_info_t *hal_info = (struct hal_info_t *)hal;
|
|
enum rtw_hal_status hstatus = RTW_HAL_STATUS_FAILURE;
|
|
|
|
do {
|
|
hstatus = rtw_hal_mac_cfg_wow_wake(hal_info, macid, true, cfg->wow_wake_cfg);
|
|
if (RTW_HAL_STATUS_SUCCESS != hstatus)
|
|
break;
|
|
/* poll fw status */
|
|
hstatus = _hal_check_wow_fw_ready(hal_info, 1);
|
|
if (RTW_HAL_STATUS_SUCCESS != hstatus)
|
|
break;
|
|
} while(0);
|
|
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "[wow] %s status(%u).\n", __func__, hstatus);
|
|
|
|
return hstatus;
|
|
}
|
|
|
|
enum rtw_hal_status rtw_hal_wow_func_stop(struct rtw_phl_com_t *phl_com, void *hal, u16 macid)
|
|
{
|
|
struct hal_info_t *hal_info = (struct hal_info_t *)hal;
|
|
enum rtw_hal_status hstatus = RTW_HAL_STATUS_FAILURE;
|
|
|
|
/* config wow ctrl */
|
|
hstatus = rtw_hal_mac_cfg_wow_wake(hal_info, macid, false, NULL);
|
|
if (RTW_HAL_STATUS_SUCCESS != hstatus)
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "[wow] rtw_hal_mac_cfg_wow_wake failed \n");
|
|
|
|
hstatus = _hal_check_wow_fw_ready(hal_info, 0);
|
|
if (RTW_HAL_STATUS_SUCCESS != hstatus)
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "[wow] _hal_poll_wow_fw_status failed \n");
|
|
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "[wow] %s status(%u).\n", __func__, hstatus);
|
|
|
|
return hstatus;
|
|
}
|
|
|
|
enum rtw_hal_status rtw_hal_set_wowlan(struct rtw_phl_com_t *phl_com, void *hal, u8 enter)
|
|
{
|
|
struct hal_info_t *hal_info = (struct hal_info_t *)hal;
|
|
enum rtw_hal_status hal_status = RTW_HAL_STATUS_FAILURE;
|
|
hal_status = rtw_hal_mac_set_wowlan(hal_info, enter);
|
|
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "%s : status(%u).\n", __func__, hal_status);
|
|
|
|
return hal_status;
|
|
}
|
|
|
|
static enum rtw_hal_status _wow_chk_txq_empty(struct hal_info_t *hal_info, u8 *empty)
|
|
{
|
|
enum rtw_hal_status hal_status = RTW_HAL_STATUS_FAILURE;
|
|
|
|
hal_status = rtw_hal_mac_wow_chk_txq_empty(hal_info, empty);
|
|
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "%s : status(%u).\n", __func__, hal_status);
|
|
|
|
return hal_status;
|
|
}
|
|
|
|
static enum rtw_hal_status _wow_wde_drop(struct hal_info_t *hal_info, u8 band)
|
|
{
|
|
enum rtw_hal_status hal_status = RTW_HAL_STATUS_FAILURE;
|
|
|
|
hal_status = rtw_hal_mac_wow_wde_drop(hal_info, band);
|
|
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "%s : status(%u).\n", __func__, hal_status);
|
|
|
|
return hal_status;
|
|
}
|
|
|
|
#define MAX_WOW_DROP_HWTX_TRYCNT 3
|
|
enum rtw_hal_status rtw_hal_wow_drop_tx(void *hal, u8 band)
|
|
{
|
|
enum rtw_hal_status hal_status = RTW_HAL_STATUS_FAILURE;
|
|
struct hal_info_t *hal_info = (struct hal_info_t *)hal;
|
|
u8 empty = 0;
|
|
u8 i = 0;
|
|
|
|
for (i = 0; i < MAX_WOW_DROP_HWTX_TRYCNT; i++) {
|
|
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "[wow] %s : chk/drop for the %d time\n", __func__, i + 1);
|
|
|
|
if (RTW_HAL_STATUS_SUCCESS != _wow_chk_txq_empty(hal_info, &empty))
|
|
PHL_WARN("[wow] _wow_chk_txq_empty failed.\n");
|
|
|
|
/* force drop wde if txq is not empty */
|
|
if (!empty)
|
|
_wow_wde_drop(hal_info, band);
|
|
else
|
|
break;
|
|
}
|
|
|
|
if (!empty) {
|
|
PHL_WARN("[wow] %s : chk/drop fail!\n", __func__);
|
|
} else {
|
|
PHL_TRACE(COMP_PHL_WOW, _PHL_INFO_, "[wow] %s : chk/drop ok.\n", __func__);
|
|
hal_status = RTW_HAL_STATUS_SUCCESS;
|
|
}
|
|
|
|
return hal_status;
|
|
}
|
|
|
|
#endif /* CONFIG_WOWLAN */
|