/******************************************************************************
|
*
|
* 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.
|
*
|
*****************************************************************************/
|
#ifndef _HAL_COM_I_C_
|
#define _HAL_COM_I_C_
|
#include "hal_headers.h"
|
|
void
|
rtw_hal_com_scan_set_tx_lifetime(void *hal, u8 band)
|
{
|
struct hal_info_t *hal_info = (struct hal_info_t *)hal;
|
|
/* set mgnt queue pkt lifetime */
|
#define HAL_COM_MGQ_TX_LIFETIME_MS 19
|
rtw_hal_mac_set_tx_lifetime(hal_info, band, false, true, 0,
|
(HAL_COM_MGQ_TX_LIFETIME_MS * 1000));
|
}
|
|
void rtw_hal_com_scan_restore_tx_lifetime(void *hal, u8 band)
|
{
|
struct hal_info_t *hal_info = (struct hal_info_t *)hal;
|
|
/* reset data/mgnt queue pkt lifetime to 0 */
|
rtw_hal_mac_set_tx_lifetime(hal_info, band, false, false, 0, 0);
|
|
}
|
|
enum rtw_hal_status rtw_hal_scan_pause_tx_fifo(void *hinfo,
|
u8 band_idx, bool off_ch)
|
{
|
enum rtw_hal_status hal_status = RTW_HAL_STATUS_SUCCESS;
|
struct hal_info_t *hal_info = (struct hal_info_t *)hinfo;
|
|
|
hal_status = rtw_hal_tx_pause(hal_info->hal_com, band_idx,
|
off_ch, PAUSE_RSON_NOR_SCAN);
|
|
return hal_status;
|
}
|
|
enum rtw_hal_status rtw_hal_dfs_pause_tx(void *hinfo,
|
u8 band_idx, bool off_ch)
|
{
|
enum rtw_hal_status hal_status = RTW_HAL_STATUS_SUCCESS;
|
struct hal_info_t *hal_info = (struct hal_info_t *)hinfo;
|
|
hal_status = rtw_hal_tx_pause(hal_info->hal_com, band_idx,
|
off_ch, PAUSE_RSON_DFS);
|
|
return hal_status;
|
}
|
|
#ifdef CONFIG_FSM
|
enum rtw_hal_status rtw_hal_scan_flush_queue(void *hinfo,
|
struct rtw_wifi_role_t *wrole)
|
{
|
struct hal_info_t *hal_info = (struct hal_info_t *)hinfo;
|
int wait = 5/* 10ms */, hal_status;
|
u8 val8;
|
#if 0
|
struct phl_queue *sta_queue;
|
struct rtw_phl_stainfo_t *sta;
|
void *drv = hal_to_drvpriv(hal_info);
|
_os_list *sta_list;
|
u8 rts_txcnt_lmt_sel = 1;
|
u8 rts_txcnt_lmt = 1;
|
u8 data_txcnt_lmt_sel = 1;
|
u8 data_tx_cnt_lmt = 1;
|
#endif
|
hal_status = rtw_hal_mac_is_tx_mgnt_empty(hal_info, wrole->hw_band, &val8);
|
|
if (val8)
|
return RTW_HAL_STATUS_SUCCESS;
|
|
#if 0
|
sta_queue = &wrole->assoc_sta_queue;
|
sta_list = &sta_queue->queue;
|
|
/* TODO wait halmac api */
|
/* shorten retry limit */
|
_os_spinlock(drv, &sta_queue->lock, _bh, NULL);
|
phl_list_for_loop(sta, struct rtw_phl_stainfo_t, sta_list, list) {
|
rtw_hal_mac_set_rty_lmt(hal_info->hal_com, sta->macid,
|
rts_txcnt_lmt_sel, rts_txcnt_lmt,
|
data_txcnt_lmt_sel, data_tx_cnt_lmt);
|
}
|
_os_spinunlock(drv, &sta_queue->lock, _bh, NULL);
|
#endif
|
while (wait-- && (!val8)) {
|
_os_delay_ms(hal_info->hal_com->drv_priv, 2);
|
rtw_hal_mac_is_tx_mgnt_empty(hal_info, wrole->hw_band, &val8);
|
}
|
#if 0
|
/* restore retry limit */
|
if (wrole->cap.rty_lmt_rts == 0xFF)
|
rts_txcnt_lmt_sel = 0;
|
else
|
rts_txcnt_lmt = wrole->cap.rty_lmt_rts & 0xF;
|
|
if (wrole->cap.rty_lmt == 0xFF)
|
data_txcnt_lmt_sel = 0;
|
else
|
data_tx_cnt_lmt = wrole->cap.rty_lmt & 0x3F;
|
|
rtw_hal_mac_set_rty_lmt(hal_info->hal_com, sta->macid,
|
rts_txcnt_lmt_sel, rts_txcnt_lmt,
|
data_txcnt_lmt_sel, data_tx_cnt_lmt);
|
#endif
|
if (val8 == DLE_QUEUE_EMPTY)
|
return RTW_HAL_STATUS_SUCCESS;
|
|
return RTW_HAL_STATUS_FAILURE;
|
}
|
#endif
|
|
enum rtw_hal_status rtw_hal_notify_switch_band(void *hinfo,
|
enum band_type band, enum phl_phy_idx phy_idx)
|
{
|
enum rtw_hal_status hal_status = RTW_HAL_STATUS_SUCCESS;
|
struct hal_info_t *hal_info = (struct hal_info_t *)hinfo;
|
|
#ifdef CONFIG_BTCOEX
|
rtw_hal_btc_switch_band_ntfy(hal_info, phy_idx, band);
|
#endif
|
|
rtw_hal_bb_fw_edcca(hal_info);
|
|
rtw_hal_rf_set_power(hal_info, phy_idx, PWR_BY_RATE);
|
|
rtw_hal_rf_do_tssi_scan(hal_info, phy_idx);
|
|
return hal_status;
|
}
|
|
enum rtw_hal_status
|
rtw_hal_proc_cmd(void *hal, char proc_cmd, struct rtw_proc_cmd *incmd,
|
char *output, u32 out_len)
|
{
|
struct hal_info_t *hal_info = (struct hal_info_t *)hal;
|
enum rtw_hal_status hal_status = RTW_HAL_STATUS_FAILURE;
|
|
if(proc_cmd == RTW_PROC_CMD_BB){
|
if(rtw_hal_bb_proc_cmd(hal_info, incmd, output, out_len))
|
hal_status = RTW_HAL_STATUS_SUCCESS;
|
}
|
if(proc_cmd == RTW_PROC_CMD_RF){
|
if(rtw_hal_rf_proc_cmd(hal_info, incmd, output, out_len))
|
hal_status = RTW_HAL_STATUS_SUCCESS;
|
}
|
if(proc_cmd == RTW_PROC_CMD_MAC){
|
if(rtw_hal_mac_proc_cmd(hal_info, incmd, output, out_len))
|
hal_status = RTW_HAL_STATUS_SUCCESS;
|
}
|
#ifdef CONFIG_BTCOEX
|
if(proc_cmd == RTW_PROC_CMD_BTC){
|
if(rtw_hal_btc_proc_cmd(hal_info, incmd, output, out_len))
|
hal_status = RTW_HAL_STATUS_SUCCESS;
|
}
|
#endif
|
if(proc_cmd == RTW_PROC_CMD_EFUSE){
|
if(rtw_hal_efuse_proc_cmd(hal_info, incmd, output, out_len))
|
hal_status = RTW_HAL_STATUS_SUCCESS;
|
}
|
return hal_status;
|
}
|
|
void rtw_hal_get_fw_ver(void *hal, char *ver_str, u16 len)
|
{
|
rtw_hal_mac_get_fw_ver((struct hal_info_t *)hal, ver_str, len);
|
}
|
|
enum rtw_hal_status
|
rtw_hal_set_mu_edca(void *hal, u8 band, u8 ac,
|
u16 timer, u8 cw_min, u8 cw_max, u8 aifsn)
|
{
|
struct hal_info_t *hal_info = (struct hal_info_t *)hal;
|
enum rtw_hal_status hal_status = RTW_HAL_STATUS_FAILURE;
|
u16 timer_32us;
|
u8 aifs_us;
|
u8 slot_time, sifs;
|
|
/* TODO: Get aSlotTime and aSIFS according to current PHY */
|
slot_time = 9;
|
sifs = 16;
|
timer_32us = (timer<<8);
|
aifs_us = (aifsn == 0)?0:(aifsn*slot_time + sifs);
|
hal_status = rtw_hal_mac_set_mu_edca(hal_info->hal_com,
|
band, ac, timer_32us, cw_min, cw_max, aifs_us);
|
return hal_status;
|
}
|
|
enum rtw_hal_status
|
rtw_hal_set_mu_edca_ctrl(void *hal, u8 band, u8 wmm, u8 set)
|
{
|
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_mu_edca_ctrl(hal_info->hal_com,
|
band, wmm, set);
|
return hal_status;
|
}
|
enum rtw_hal_status
|
rtw_hal_reset(struct rtw_hal_com_t *hal_com, enum phl_phy_idx phy_idx, u8 band_idx, bool reset)
|
{
|
struct hal_info_t *hal_info = hal_com->hal_priv;
|
enum rtw_hal_status status = RTW_HAL_STATUS_SUCCESS;
|
|
if (reset){
|
/* disable contention */
|
status = rtw_hal_tx_pause(hal_com, band_idx, true, PAUSE_RSON_RESET);
|
if(status != RTW_HAL_STATUS_SUCCESS){
|
PHL_ERR("%s rtw_hal_tx_pause - failed\n", __func__);
|
return status;
|
}
|
|
/* disable ppdu_sts */
|
status = rtw_hal_mac_ppdu_stat_cfg(hal_info, band_idx, false, 0, 0);
|
if(status != RTW_HAL_STATUS_SUCCESS){
|
PHL_ERR("%s rtw_hal_mac_ppdu_stat_cfg - failed\n", __func__);
|
return status;
|
}
|
|
/*disable DFS/TSSI*/
|
rtw_hal_bb_dfs_en(hal_info, false);
|
if (!hal_com->dbcc_en) {
|
rtw_hal_bb_tssi_cont_en(hal_info, false, RF_PATH_A);
|
rtw_hal_bb_tssi_cont_en(hal_info, false, RF_PATH_B);
|
}else{
|
if(phy_idx == HW_PHY_0)
|
rtw_hal_bb_tssi_cont_en(hal_info, false, RF_PATH_A);
|
else
|
rtw_hal_bb_tssi_cont_en(hal_info, false, RF_PATH_B);
|
}
|
/*disable ADC*/
|
rtw_hal_bb_adc_en(hal_info, false);
|
/* wait 40us*/
|
_os_delay_us(hal_com->drv_priv, 40);
|
/* reset BB*/
|
rtw_hal_bb_reset_en(hal_info, false, phy_idx);
|
}else{
|
/*enable ppdu_sts*/
|
status = rtw_hal_mac_ppdu_stat_cfg(
|
hal_info, band_idx, true,
|
hal_com->band[band_idx].ppdu_sts_appen_info,
|
hal_com->band[band_idx].ppdu_sts_filter);
|
|
if(status != RTW_HAL_STATUS_SUCCESS){
|
PHL_ERR("%s rtw_hal_mac_ppdu_stat_cfg - failed\n", __func__);
|
return status;
|
}
|
/*enable ADC*/
|
rtw_hal_bb_adc_en(hal_info, true);
|
/*enable DFS/TSSI*/
|
rtw_hal_bb_dfs_en(hal_info, true);
|
if (!hal_com->dbcc_en) {
|
rtw_hal_bb_tssi_cont_en(hal_info, true, RF_PATH_A);
|
rtw_hal_bb_tssi_cont_en(hal_info, true, RF_PATH_B);
|
}else{
|
if(phy_idx == HW_PHY_0)
|
rtw_hal_bb_tssi_cont_en(hal_info, true, RF_PATH_A);
|
else
|
rtw_hal_bb_tssi_cont_en(hal_info, true, RF_PATH_B);
|
}
|
/*BB reset set to 1*/
|
rtw_hal_bb_reset_en(hal_info, true, phy_idx);
|
|
status = rtw_hal_tx_pause(hal_com, band_idx, false, PAUSE_RSON_RESET);
|
if(status != RTW_HAL_STATUS_SUCCESS){
|
PHL_ERR("%s rtw_hal_tx_pause - failed\n", __func__);
|
return status;
|
}
|
}
|
return status;
|
}
|
|
enum rtw_hal_status rtw_hal_ppdu_sts_cfg(void *hal, u8 band_idx, bool en)
|
{
|
struct hal_info_t *hal_info = (struct hal_info_t *)hal;
|
struct rtw_hal_com_t *hal_com = hal_info->hal_com;
|
enum rtw_hal_status hal_status = RTW_HAL_STATUS_SUCCESS;
|
|
if (en) {
|
hal_status = rtw_hal_mac_ppdu_stat_cfg(
|
hal_info, band_idx, true,
|
hal_com->band[band_idx].ppdu_sts_appen_info,
|
hal_com->band[band_idx].ppdu_sts_filter);
|
} else {
|
hal_status = rtw_hal_mac_ppdu_stat_cfg(hal_info, band_idx, false, 0, 0);
|
}
|
|
if (hal_status != RTW_HAL_STATUS_SUCCESS)
|
PHL_ERR("%s (en %d) - failed\n", __func__, en);
|
|
return hal_status;
|
}
|
|
void
|
rtw_hal_disconnect_notify(void *hal, struct rtw_chan_def *chandef)
|
{
|
rtw_hal_rf_disconnect_notify(hal, chandef);
|
PHL_TRACE(COMP_PHL_MCC, _PHL_INFO_, "rtw_hal_disconnect_notify(): chandef band(%d), chan(%d), bw(%d), offset(%d)\n",
|
chandef->band, chandef->chan, chandef->bw, chandef->offset);
|
}
|
|
bool rtw_hal_check_ch_rfk(void *hal, struct rtw_chan_def *chandef)
|
{
|
bool check = false;
|
check = rtw_hal_rf_check_mcc_ch(hal, chandef);
|
PHL_TRACE(COMP_PHL_MCC, _PHL_INFO_, "rtw_hal_check_ch_rfk(): check ok(%d), band(%d), chan(%d), bw(%d), offset(%d)\n",
|
check, chandef->band, chandef->chan, chandef->bw, chandef->offset);
|
return check;
|
}
|
|
void rtw_hal_env_rpt(struct rtw_hal_com_t *hal_com, struct rtw_env_report *env_rpt,
|
struct rtw_wifi_role_t *wrole)
|
{
|
enum phl_phy_idx p_idx = HW_PHY_0;
|
|
p_idx = rtw_hal_bb_band_to_phy_idx(hal_com, wrole->hw_band);
|
rtw_hal_bb_env_rpt(hal_com, env_rpt, p_idx);
|
}
|
|
#endif /* _HAL_COM_I_C_ */
|
