mirror of
git://nv-tegra.nvidia.com/linux-nv-oot.git
synced 2025-12-23 17:55:05 +03:00
04fa635c7d
1. Update makefiles to add Nvidia source path 2. Change file permissions to 0644 3. Delete files with .orig extensions 4. Fix compilation issue due to enum-int mismatch Bug 4667769 Bug 4667981 Change-Id: I0df6f3073780daf6879c4165cd97fd62fd0a4b65 Reviewed-on: https://git-master.nvidia.com/r/c/linux-nv-oot/+/3195602 GVS: buildbot_gerritrpt <buildbot_gerritrpt@nvidia.com> Reviewed-by: Revanth Kumar Uppala <ruppala@nvidia.com> Reviewed-by: Ashutosh Jha <ajha@nvidia.com> Tested-by: Shobek Attupurath <sattupurath@nvidia.com>
2241 lines
66 KiB
C
2241 lines
66 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 _PHL_CHAN_C_
|
|
#include "phl_headers.h"
|
|
|
|
const char *const _band_str[] = {
|
|
"BAND_ON_24G",
|
|
"BAND_ON_5G",
|
|
"BAND_ON_6G",
|
|
"BAND_UNKNOWN"
|
|
};
|
|
#define _get_band_str(band) (((band) >= BAND_MAX) ? _band_str[BAND_MAX] : _band_str[(band)])
|
|
|
|
const char *const _bw_str[] = {
|
|
"BW_20M",
|
|
"BW_40M",
|
|
"BW_80M",
|
|
"BW_160M",
|
|
"BW_80_80M",
|
|
"BW_5M",
|
|
"BW_10M",
|
|
"BW_UNKNOWN"
|
|
};
|
|
#define _get_bw_str(bw) (((bw) >= CHANNEL_WIDTH_MAX) ? _bw_str[CHANNEL_WIDTH_MAX] : _bw_str[((bw))])
|
|
|
|
#ifdef DBG_PHL_CHAN
|
|
void phl_chan_dump_chandef(const char *caller, const int line, bool show_caller,
|
|
struct rtw_chan_def *chandef)
|
|
{
|
|
if (show_caller)
|
|
PHL_INFO("###### FUN - %s LINE - %d #######\n", caller, line);
|
|
|
|
PHL_INFO("\t[CH] band:%s\n", _get_band_str(chandef->band));
|
|
PHL_INFO("\t[CH] chan:%d\n", chandef->chan);
|
|
PHL_INFO("\t[CH] center_ch:%d\n", chandef->center_ch);
|
|
PHL_INFO("\t[CH] bw:%s\n", _get_bw_str(chandef->bw));
|
|
PHL_INFO("\t[CH] offset:%d\n", chandef->offset);
|
|
|
|
PHL_INFO("\t[CH] center_freq1:%d\n", chandef->center_freq1);
|
|
PHL_INFO("\t[CH] center_freq2:%d\n", chandef->center_freq2);
|
|
PHL_INFO("\t[CH] hw_value:%d\n", chandef->hw_value);
|
|
|
|
if (show_caller)
|
|
PHL_INFO("#################################\n");
|
|
}
|
|
#endif
|
|
|
|
enum rtw_phl_status
|
|
phl_set_ch_bw(struct phl_info_t *phl_info, u8 band_idx,
|
|
struct rtw_chan_def *chdef, enum rfk_tri_type rt_type)
|
|
{
|
|
enum rtw_hal_status hstatus = RTW_HAL_STATUS_FAILURE;
|
|
bool rd_enabled = false;
|
|
|
|
#ifdef CONFIG_PHL_DFS
|
|
struct dfs_rd_ch_switch_ctx dfs_rd_cs_ctx;
|
|
|
|
phl_dfs_rd_setting_before_ch_switch(phl_info, band_idx
|
|
, chdef->band, chdef->chan, chdef->bw, chdef->offset
|
|
, &dfs_rd_cs_ctx);
|
|
rd_enabled = dfs_rd_cs_ctx.rd_enabled;
|
|
#endif
|
|
|
|
hstatus = rtw_hal_set_ch_bw(phl_info->hal, band_idx,
|
|
chdef, rt_type, rd_enabled, false);
|
|
if (RTW_HAL_STATUS_SUCCESS != hstatus)
|
|
PHL_ERR("%s rtw_hal_set_ch_bw: statuts = %u\n", __func__, hstatus);
|
|
|
|
#ifdef CONFIG_PHL_DFS
|
|
phl_dfs_rd_setting_after_ch_switch(phl_info, band_idx
|
|
, chdef->band, chdef->chan, chdef->bw, chdef->offset
|
|
, &dfs_rd_cs_ctx);
|
|
#endif
|
|
|
|
return RTW_PHL_STATUS_SUCCESS;
|
|
}
|
|
|
|
#ifdef CONFIG_CMD_DISP
|
|
|
|
static void
|
|
_phl_chg_op_chdef_done(void *drv_priv, u8 *cmd, u32 cmd_len,
|
|
enum rtw_phl_status status)
|
|
{
|
|
if (cmd) {
|
|
struct chg_opch_param *param = (struct chg_opch_param *)cmd;
|
|
|
|
if (param->chg_opch_done) {
|
|
enum rtw_phl_status psts = RTW_PHL_STATUS_FAILURE;
|
|
|
|
if (RTW_PHL_STATUS_CMD_SUCCESS == status &&
|
|
RTW_PHL_STATUS_CMD_SUCCESS == param->cmd_start_sts)
|
|
psts = RTW_PHL_STATUS_SUCCESS;
|
|
param->chg_opch_done(drv_priv,
|
|
param->wrole->id,
|
|
param->rlink,
|
|
psts);
|
|
}
|
|
_os_spinlock_free(drv_priv, ¶m->lock);
|
|
_os_kmem_free(drv_priv, cmd, cmd_len);
|
|
cmd = NULL;
|
|
PHL_INFO("%s.....\n", __func__);
|
|
}
|
|
}
|
|
|
|
static void _phl_chg_op_chdef_start_done(void *drv_priv, u8 *cmd, u32 cmd_len, enum rtw_phl_status status)
|
|
{
|
|
struct chg_opch_param *param = NULL;
|
|
|
|
if (!cmd)
|
|
return;
|
|
param = (struct chg_opch_param *)cmd;
|
|
|
|
_os_spinlock(drv_priv, ¶m->lock, _bh, NULL);
|
|
if (param->send_end_msg_fail) {
|
|
_os_spinunlock(drv_priv, ¶m->lock, _bh, NULL);
|
|
_os_spinlock_free(drv_priv, ¶m->lock);
|
|
_os_kmem_free(drv_priv, cmd, cmd_len);
|
|
cmd = NULL;
|
|
PHL_ERR("%s: Send MSG_EVT_CHG_OP_CH_DEF_END fail, Free para!!, Something went wrong!!\n",
|
|
__func__);
|
|
goto _exit;
|
|
}
|
|
param->cmd_start_sts = status;
|
|
param->start_msg_done = true;
|
|
_os_spinunlock(drv_priv, ¶m->lock, _bh, NULL);
|
|
_exit:
|
|
PHL_INFO("%s.....\n", __func__);
|
|
}
|
|
|
|
enum rtw_phl_status
|
|
phl_cmd_chg_op_chdef_start_hdl(struct phl_info_t *phl, u8 *param)
|
|
{
|
|
enum rtw_phl_status pstatus = RTW_PHL_STATUS_FAILURE;
|
|
struct chg_opch_param *ch_param = (struct chg_opch_param *)param;
|
|
void *drv = phl_to_drvpriv(phl);
|
|
enum phl_upd_mode mode = PHL_UPD_STA_INFO_CHANGE;
|
|
struct phl_queue *sta_queue = NULL;
|
|
struct rtw_phl_stainfo_t *sta = NULL;
|
|
struct rtw_chan_def chctx_result = {0};
|
|
|
|
sta = rtw_phl_get_stainfo_self(phl, ch_param->rlink);
|
|
if (NULL == sta) {
|
|
PHL_TRACE(COMP_PHL_DBG, _PHL_ERR_, "%s: cannot get stainfo_self\n",
|
|
__FUNCTION__);
|
|
goto exit;
|
|
}
|
|
|
|
/* Update MR chctx */
|
|
if (RTW_PHL_STATUS_SUCCESS != phl_mr_chandef_chg(phl,
|
|
ch_param->wrole,
|
|
ch_param->rlink,
|
|
&ch_param->new_chdef,
|
|
&chctx_result)) {
|
|
PHL_TRACE(COMP_PHL_DBG, _PHL_ERR_, "%s: MR chang chdef failed!\n",
|
|
__FUNCTION__);
|
|
goto exit;
|
|
}
|
|
|
|
/* Update role link chdef */
|
|
_os_mem_cpy(drv,
|
|
&ch_param->rlink->chandef,
|
|
&ch_param->new_chdef,
|
|
sizeof(struct rtw_chan_def));
|
|
|
|
/* Update self Sta chdef */
|
|
_os_mem_cpy(drv, &sta->chandef, &ch_param->new_chdef,
|
|
sizeof(struct rtw_chan_def));
|
|
/* Notify rf for the suspended channel */
|
|
rtw_hal_disconnect_notify(phl->hal, &ch_param->ori_chdef);
|
|
/* Switch channel */
|
|
if (RTW_PHL_STATUS_SUCCESS != phl_set_ch_bw(phl,
|
|
ch_param->rlink->hw_band,
|
|
&chctx_result,
|
|
RFK_TYPE_CHG_OP)) {
|
|
PHL_TRACE(COMP_PHL_DBG, _PHL_ERR_, "%s: Switch ch failed!\n",
|
|
__FUNCTION__);
|
|
goto exit;
|
|
}
|
|
|
|
if (ch_param->rlink->mstate == MLME_LINKED) {
|
|
/*Up STA setting(RA....) */
|
|
sta_queue = &ch_param->rlink->assoc_sta_queue;
|
|
_os_spinlock(drv, &sta_queue->lock, _bh, NULL);
|
|
phl_list_for_loop(sta, struct rtw_phl_stainfo_t,
|
|
&sta_queue->queue, list) {
|
|
if (sta)
|
|
phl_change_stainfo(phl, sta, mode);
|
|
}
|
|
_os_spinunlock(drv, &sta_queue->lock, _bh, NULL);
|
|
}
|
|
pstatus = RTW_PHL_STATUS_SUCCESS;
|
|
exit:
|
|
PHL_TRACE(COMP_PHL_DBG, _PHL_INFO_, "%s: pstatus(%d)\n",
|
|
__FUNCTION__, pstatus);
|
|
return pstatus;
|
|
}
|
|
|
|
enum rtw_phl_status
|
|
rtw_phl_cmd_chg_op_chdef(struct rtw_wifi_role_t *wrole,
|
|
struct rtw_wifi_role_link_t *rlink,
|
|
struct rtw_chan_def *new_chdef,
|
|
bool cmd_wait,
|
|
u32 cmd_timeout,
|
|
void (*chg_opch_done)(void *priv,
|
|
u8 ridx,
|
|
struct rtw_wifi_role_link_t *rlink,
|
|
enum rtw_phl_status status)
|
|
)
|
|
{
|
|
enum rtw_phl_status psts = RTW_PHL_STATUS_FAILURE;
|
|
struct phl_info_t *phl = wrole->phl_com->phl_priv;
|
|
void *drv = phl_to_drvpriv(phl);
|
|
u32 param_len = sizeof(struct chg_opch_param);
|
|
struct chg_opch_param *param = _os_kmem_alloc(drv, param_len);
|
|
|
|
if (param == NULL) {
|
|
PHL_ERR("%s: alloc param failed!\n", __func__);
|
|
goto _exit;
|
|
}
|
|
_os_spinlock_init(drv, ¶m->lock);
|
|
param->wrole = wrole;
|
|
param->rlink = rlink;
|
|
_os_mem_cpy(drv, ¶m->new_chdef, new_chdef,
|
|
sizeof(struct rtw_chan_def));
|
|
|
|
_os_mem_cpy(drv, ¶m->ori_chdef, &rlink->chandef,
|
|
sizeof(struct rtw_chan_def));
|
|
|
|
param->chg_opch_done = chg_opch_done;
|
|
psts = phl_cmd_enqueue(phl,
|
|
rlink->hw_band,
|
|
MSG_EVT_CHG_OP_CH_DEF_START,
|
|
(u8 *)param,
|
|
param_len,
|
|
_phl_chg_op_chdef_start_done,
|
|
PHL_CMD_NO_WAIT,
|
|
0);
|
|
if (psts != RTW_PHL_STATUS_SUCCESS) {
|
|
PHL_INFO("%s: Fail to issue change op chdef start!!\n",
|
|
__func__);
|
|
if (!is_cmd_failure(psts)) {
|
|
/* Send cmd fail */
|
|
_os_spinlock_free(drv, ¶m->lock);
|
|
_os_kmem_free(drv, param, param_len);
|
|
psts = RTW_PHL_STATUS_FAILURE;
|
|
}
|
|
goto _exit;
|
|
}
|
|
psts = phl_cmd_enqueue(phl,
|
|
rlink->hw_band,
|
|
MSG_EVT_CHG_OP_CH_DEF_END,
|
|
(u8 *)param,
|
|
param_len,
|
|
_phl_chg_op_chdef_done,
|
|
cmd_wait ? PHL_CMD_WAIT : PHL_CMD_NO_WAIT,
|
|
cmd_timeout);
|
|
if (psts != RTW_PHL_STATUS_SUCCESS) {
|
|
PHL_INFO("%s: Fail to issue change op chdef end!!\n",
|
|
__func__);
|
|
if (!is_cmd_failure(psts)) {
|
|
/* Send cmd fail */
|
|
_os_spinlock(drv, ¶m->lock, _bh, NULL);
|
|
if (param->start_msg_done) {
|
|
_os_spinunlock(drv, ¶m->lock, _bh, NULL);
|
|
_os_spinlock_free(drv, ¶m->lock);
|
|
_os_kmem_free(drv, param, param_len);
|
|
psts = RTW_PHL_STATUS_FAILURE;
|
|
goto _exit;
|
|
} else {
|
|
param->send_end_msg_fail = true;
|
|
}
|
|
_os_spinunlock(drv, ¶m->lock, _bh, NULL);
|
|
psts = RTW_PHL_STATUS_FAILURE;
|
|
}
|
|
goto _exit;
|
|
}
|
|
_exit:
|
|
PHL_INFO("%s: Issue cmd, status(%d)\n", __func__, psts);
|
|
return psts;
|
|
}
|
|
|
|
enum rtw_phl_status
|
|
phl_cmd_set_ch_bw_hdl(struct phl_info_t *phl_info, u8 *param)
|
|
{
|
|
struct setch_param *ch_param = (struct setch_param *)param;
|
|
|
|
return phl_set_ch_bw(phl_info,
|
|
ch_param->rlink->hw_band,
|
|
&(ch_param->chdef),
|
|
ch_param->rt_type);
|
|
}
|
|
|
|
static void _phl_set_ch_bw_done(void *drv_priv, u8 *cmd, u32 cmd_len, enum rtw_phl_status status)
|
|
{
|
|
if (cmd) {
|
|
_os_kmem_free(drv_priv, cmd, cmd_len);
|
|
cmd = NULL;
|
|
PHL_INFO("%s.....\n", __func__);
|
|
}
|
|
}
|
|
|
|
enum rtw_phl_status
|
|
rtw_phl_cmd_set_ch_bw(struct rtw_wifi_role_t *wifi_role,
|
|
struct rtw_wifi_role_link_t *rlink,
|
|
struct rtw_chan_def *chdef,
|
|
enum rfk_tri_type rt_type,
|
|
enum phl_cmd_type cmd_type,
|
|
u32 cmd_timeout)
|
|
{
|
|
struct phl_info_t *phl_info = wifi_role->phl_com->phl_priv;
|
|
void *drv = wifi_role->phl_com->drv_priv;
|
|
enum rtw_phl_status psts = RTW_PHL_STATUS_FAILURE;
|
|
struct setch_param *param = NULL;
|
|
u32 param_len;
|
|
|
|
if (cmd_type == PHL_CMD_DIRECTLY) {
|
|
psts = phl_set_ch_bw(phl_info, rlink->hw_band, chdef, rt_type);
|
|
goto _exit;
|
|
}
|
|
|
|
param_len = sizeof(struct setch_param);
|
|
param = _os_kmem_alloc(drv, param_len);
|
|
if (param == NULL) {
|
|
PHL_ERR("%s: alloc param failed!\n", __func__);
|
|
goto _exit;
|
|
}
|
|
param->wrole = wifi_role;
|
|
param->rlink = rlink;
|
|
_os_mem_cpy(drv, ¶m->chdef, chdef, sizeof(struct rtw_chan_def));
|
|
param->rt_type = rt_type;
|
|
|
|
psts = phl_cmd_enqueue(phl_info,
|
|
rlink->hw_band,
|
|
MSG_EVT_SWCH_START,
|
|
(u8 *)param,
|
|
param_len,
|
|
_phl_set_ch_bw_done,
|
|
cmd_type,
|
|
cmd_timeout);
|
|
|
|
if (is_cmd_failure(psts)) {
|
|
/* Send cmd success, but wait cmd fail*/
|
|
psts = RTW_PHL_STATUS_FAILURE;
|
|
} else if (psts != RTW_PHL_STATUS_SUCCESS) {
|
|
/* Send cmd fail */
|
|
_os_kmem_free(drv, param, param_len);
|
|
psts = RTW_PHL_STATUS_FAILURE;
|
|
}
|
|
_exit:
|
|
return psts;
|
|
}
|
|
#endif /*CONFIG_CMD_DISP*/
|
|
|
|
u8 rtw_phl_get_cur_ch(struct rtw_wifi_role_t *wifi_role,
|
|
struct rtw_wifi_role_link_t *rlink)
|
|
{
|
|
struct phl_info_t *phl_info = wifi_role->phl_com->phl_priv;
|
|
|
|
return rtw_hal_get_cur_ch(phl_info->hal, rlink->hw_band);
|
|
}
|
|
|
|
enum rtw_phl_status
|
|
rtw_phl_get_cur_hal_chdef(struct rtw_wifi_role_t *wifi_role,
|
|
struct rtw_wifi_role_link_t *rlink,
|
|
struct rtw_chan_def *cur_chandef)
|
|
{
|
|
struct phl_info_t *phl_info = wifi_role->phl_com->phl_priv;
|
|
|
|
rtw_hal_get_cur_chdef(phl_info->hal, rlink->hw_band, cur_chandef);
|
|
return RTW_PHL_STATUS_SUCCESS;
|
|
}
|
|
|
|
enum rtw_phl_status
|
|
rtw_phl_get_cur_hal_chdef_by_hwband(void *phl_info,
|
|
enum phl_band_idx band_idx,
|
|
struct rtw_chan_def *cur_chandef)
|
|
{
|
|
if (band_idx >= HW_BAND_MAX)
|
|
return RTW_PHL_STATUS_FAILURE;
|
|
|
|
rtw_hal_get_cur_chdef(((struct phl_info_t *)phl_info)->hal, band_idx, cur_chandef);
|
|
return RTW_PHL_STATUS_SUCCESS;
|
|
}
|
|
|
|
static enum rtw_phl_status
|
|
_dfs_hw_tx_pause(struct phl_info_t *phl_info,
|
|
enum phl_band_idx hw_band,
|
|
bool tx_pause,
|
|
u8 reason)
|
|
{
|
|
|
|
enum rtw_hal_status hstatus = RTW_HAL_STATUS_FAILURE;
|
|
|
|
hstatus = rtw_hal_dfs_pause_tx(phl_info->hal, hw_band, tx_pause, reason);
|
|
|
|
if (RTW_HAL_STATUS_SUCCESS == hstatus) {
|
|
return RTW_PHL_STATUS_SUCCESS;
|
|
} else {
|
|
PHL_ERR("%s Failure :%u\n", __func__, hstatus);
|
|
return RTW_PHL_STATUS_FAILURE;
|
|
}
|
|
}
|
|
|
|
#ifdef CONFIG_CMD_DISP
|
|
struct dfs_txpause_param {
|
|
enum phl_band_idx hw_band;
|
|
bool pause;
|
|
u8 pause_reason;
|
|
};
|
|
|
|
enum rtw_phl_status
|
|
phl_cmd_dfs_tx_pause_hdl(struct phl_info_t *phl_info, u8 *param)
|
|
{
|
|
struct dfs_txpause_param *dfs = (struct dfs_txpause_param *)param;
|
|
|
|
PHL_INFO("%s(), dfs param, hw_band = %u, pause = %d pause_reason = %d\n",
|
|
__func__, dfs->hw_band, dfs->pause, dfs->pause_reason);
|
|
|
|
return _dfs_hw_tx_pause(phl_info, dfs->hw_band, dfs->pause, dfs->pause_reason);
|
|
}
|
|
|
|
static void _phl_dfs_tx_pause_done(void *drv_priv, u8 *cmd, u32 cmd_len, enum rtw_phl_status status)
|
|
{
|
|
if (cmd) {
|
|
_os_kmem_free(drv_priv, cmd, cmd_len);
|
|
cmd = NULL;
|
|
PHL_INFO("%s.....\n", __func__);
|
|
}
|
|
}
|
|
#endif /*CONFIG_CMD_DISP*/
|
|
|
|
static enum rtw_phl_status
|
|
_rtw_phl_cmd_dfs_tx_pause(struct phl_info_t *phl_info,
|
|
enum phl_band_idx hw_band,
|
|
bool pause,
|
|
enum tx_pause_rson reason,
|
|
enum phl_cmd_type cmd_type,
|
|
u32 cmd_timeout)
|
|
{
|
|
#ifdef CONFIG_CMD_DISP
|
|
void *drv = phl_info->phl_com->drv_priv;
|
|
enum rtw_phl_status psts = RTW_PHL_STATUS_FAILURE;
|
|
struct dfs_txpause_param *param = NULL;
|
|
u32 param_len;
|
|
|
|
param_len = sizeof(struct dfs_txpause_param);
|
|
param = _os_kmem_alloc(drv, param_len);
|
|
if (param == NULL) {
|
|
PHL_ERR("%s: alloc param failed!\n", __func__);
|
|
goto _exit;
|
|
}
|
|
param->hw_band = hw_band;
|
|
param->pause = pause;
|
|
param->pause_reason = reason;
|
|
|
|
if (cmd_type == PHL_CMD_DIRECTLY) {
|
|
psts = phl_cmd_dfs_tx_pause_hdl(phl_info, (u8 *)param);
|
|
_phl_dfs_tx_pause_done(drv, (u8 *)param, param_len, psts);
|
|
goto _exit;
|
|
}
|
|
|
|
psts = phl_cmd_enqueue(phl_info,
|
|
hw_band,
|
|
MSG_EVT_DFS_PAUSE_TX,
|
|
(u8 *)param,
|
|
param_len,
|
|
_phl_dfs_tx_pause_done,
|
|
cmd_type,
|
|
cmd_timeout);
|
|
|
|
if (is_cmd_failure(psts)) {
|
|
/* Send cmd success, but wait cmd fail*/
|
|
psts = RTW_PHL_STATUS_FAILURE;
|
|
} else if (psts != RTW_PHL_STATUS_SUCCESS) {
|
|
/* Send cmd fail */
|
|
_os_kmem_free(drv, param, param_len);
|
|
psts = RTW_PHL_STATUS_FAILURE;
|
|
}
|
|
|
|
_exit:
|
|
return psts;
|
|
#else
|
|
PHL_ERR("%s(), CONFIG_CMD_DISP need to be enabled for MSG_EVT_DFS_PAUSE_TX \n",__func__);
|
|
|
|
return RTW_PHL_STATUS_FAILURE;
|
|
#endif
|
|
}
|
|
|
|
enum rtw_phl_status
|
|
rtw_phl_cmd_dfs_csa_tx_pause(void *phl_info,
|
|
enum phl_band_idx hw_band,
|
|
bool pause,
|
|
bool csa,
|
|
enum phl_cmd_type cmd_type,
|
|
u32 cmd_timeout)
|
|
{
|
|
return _rtw_phl_cmd_dfs_tx_pause(phl_info, hw_band, pause
|
|
, PAUSE_RSON_DFS_CSA
|
|
, cmd_type, cmd_timeout);
|
|
}
|
|
|
|
enum rtw_phl_status
|
|
rtw_phl_cmd_dfs_csa_mg_tx_pause(void *phl_info,
|
|
enum phl_band_idx hw_band,
|
|
bool pause,
|
|
enum phl_cmd_type cmd_type,
|
|
u32 cmd_timeout)
|
|
{
|
|
return _rtw_phl_cmd_dfs_tx_pause(phl_info, hw_band, pause
|
|
, PAUSE_RSON_DFS_CSA_MG
|
|
, cmd_type, cmd_timeout);
|
|
}
|
|
|
|
#define MAX_CHANCTX_QUEUE_NUM 2
|
|
|
|
static enum rtw_phl_status
|
|
_phl_cc_band_map_set(struct phl_info_t *phl_info,
|
|
struct hw_band_ctl_t *band_ctrl, struct rtw_chan_ctx *chanctx)
|
|
{
|
|
struct rtw_chan_def *chan_def = &chanctx->chan_def;
|
|
static enum rtw_phl_status psts = RTW_PHL_STATUS_SUCCESS;
|
|
|
|
if (BAND_2GHZ(chan_def->band)) {
|
|
_os_atomic_inc(phl_to_drvpriv(phl_info), &band_ctrl->ccb_24g_rc);
|
|
band_ctrl->chctx_band_map |= BIT(CC_BAND_24G);
|
|
|
|
} else if (BAND_5GHZ(chan_def->band)) {
|
|
if (CH_5GHZ_BAND1(chan_def->chan)) {
|
|
_os_atomic_inc(phl_to_drvpriv(phl_info), &band_ctrl->ccb_5gb1_rc);
|
|
band_ctrl->chctx_band_map |= BIT(CC_BAND_5G_B1);
|
|
} else if (CH_5GHZ_BAND2(chan_def->chan)) {
|
|
_os_atomic_inc(phl_to_drvpriv(phl_info), &band_ctrl->ccb_5gb2_rc);
|
|
band_ctrl->chctx_band_map |= BIT(CC_BAND_5G_B2);
|
|
} else if (CH_5GHZ_BAND3(chan_def->chan)) {
|
|
_os_atomic_inc(phl_to_drvpriv(phl_info), &band_ctrl->ccb_5gb3_rc);
|
|
band_ctrl->chctx_band_map |= BIT(CC_BAND_5G_B3);
|
|
} else if (CH_5GHZ_BAND4(chan_def->chan)) {
|
|
_os_atomic_inc(phl_to_drvpriv(phl_info), &band_ctrl->ccb_5gb4_rc);
|
|
band_ctrl->chctx_band_map |= BIT(CC_BAND_5G_B4);
|
|
} else {
|
|
PHL_ERR("%s chctx 5G band unknow\n", __func__);
|
|
_os_warn_on(1);
|
|
psts = RTW_PHL_STATUS_FAILURE;
|
|
}
|
|
} else if (BAND_6GHZ(chan_def->band)) {
|
|
if (CH_6GHZ_UNII5(chan_def->chan)) {
|
|
_os_atomic_inc(phl_to_drvpriv(phl_info), &band_ctrl->ccb_6gu5_rc);
|
|
band_ctrl->chctx_band_map |= BIT(CC_BAND_6G_U5);
|
|
} else if (CH_6GHZ_UNII6(chan_def->chan)) {
|
|
_os_atomic_inc(phl_to_drvpriv(phl_info), &band_ctrl->ccb_6gu6_rc);
|
|
band_ctrl->chctx_band_map |= BIT(CC_BAND_6G_U6);
|
|
} else if (CH_6GHZ_UNII7(chan_def->chan)) {
|
|
_os_atomic_inc(phl_to_drvpriv(phl_info), &band_ctrl->ccb_6gu7_rc);
|
|
band_ctrl->chctx_band_map |= BIT(CC_BAND_6G_U7);
|
|
} else if (CH_6GHZ_UNII8(chan_def->chan)) {
|
|
_os_atomic_inc(phl_to_drvpriv(phl_info), &band_ctrl->ccb_6gu8_rc);
|
|
band_ctrl->chctx_band_map |= BIT(CC_BAND_6G_U8);
|
|
} else {
|
|
PHL_ERR("%s chctx 6G band unknow\n", __func__);
|
|
_os_warn_on(1);
|
|
psts = RTW_PHL_STATUS_FAILURE;
|
|
}
|
|
}
|
|
|
|
return psts;
|
|
}
|
|
|
|
static enum rtw_phl_status
|
|
_phl_cc_band_map_clr(struct phl_info_t *phl_info,
|
|
struct hw_band_ctl_t *band_ctrl, struct rtw_chan_ctx *chanctx)
|
|
{
|
|
struct rtw_chan_def *chan_def = &chanctx->chan_def;
|
|
static enum rtw_phl_status psts = RTW_PHL_STATUS_SUCCESS;
|
|
|
|
if (BAND_2GHZ(chan_def->band)) {
|
|
_os_atomic_dec(phl_to_drvpriv(phl_info), &band_ctrl->ccb_24g_rc);
|
|
if (_os_atomic_read(phl_to_drvpriv(phl_info), &band_ctrl->ccb_24g_rc) == 0)
|
|
band_ctrl->chctx_band_map &= ~BIT(CC_BAND_24G);
|
|
}
|
|
else if (BAND_5GHZ(chan_def->band)) {
|
|
if (CH_5GHZ_BAND1(chan_def->chan)) {
|
|
_os_atomic_dec(phl_to_drvpriv(phl_info), &band_ctrl->ccb_5gb1_rc);
|
|
if (_os_atomic_read(phl_to_drvpriv(phl_info), &band_ctrl->ccb_5gb1_rc) == 0)
|
|
band_ctrl->chctx_band_map &= ~BIT(CC_BAND_5G_B1);
|
|
} else if (CH_5GHZ_BAND2(chan_def->chan)) {
|
|
_os_atomic_dec(phl_to_drvpriv(phl_info), &band_ctrl->ccb_5gb2_rc);
|
|
if (_os_atomic_read(phl_to_drvpriv(phl_info), &band_ctrl->ccb_5gb2_rc) == 0)
|
|
band_ctrl->chctx_band_map &= ~BIT(CC_BAND_5G_B2);
|
|
} else if (CH_5GHZ_BAND3(chan_def->chan)) {
|
|
_os_atomic_dec(phl_to_drvpriv(phl_info), &band_ctrl->ccb_5gb3_rc);
|
|
if (_os_atomic_read(phl_to_drvpriv(phl_info), &band_ctrl->ccb_5gb3_rc) == 0)
|
|
band_ctrl->chctx_band_map &= ~BIT(CC_BAND_5G_B3);
|
|
} else if (CH_5GHZ_BAND4(chan_def->chan)) {
|
|
_os_atomic_dec(phl_to_drvpriv(phl_info), &band_ctrl->ccb_5gb4_rc);
|
|
if (_os_atomic_read(phl_to_drvpriv(phl_info), &band_ctrl->ccb_5gb4_rc) == 0)
|
|
band_ctrl->chctx_band_map &= ~BIT(CC_BAND_5G_B4);
|
|
} else {
|
|
PHL_ERR("%s chctx 5G band unknow\n", __func__);
|
|
_os_warn_on(1);
|
|
psts = RTW_PHL_STATUS_FAILURE;
|
|
}
|
|
}
|
|
else if (BAND_6GHZ(chan_def->band)) {
|
|
if (CH_6GHZ_UNII5(chan_def->chan)) {
|
|
_os_atomic_dec(phl_to_drvpriv(phl_info), &band_ctrl->ccb_6gu5_rc);
|
|
if (_os_atomic_read(phl_to_drvpriv(phl_info), &band_ctrl->ccb_6gu5_rc) == 0)
|
|
band_ctrl->chctx_band_map &= ~BIT(CC_BAND_6G_U5);
|
|
} else if (CH_6GHZ_UNII6(chan_def->chan)) {
|
|
_os_atomic_dec(phl_to_drvpriv(phl_info), &band_ctrl->ccb_6gu6_rc);
|
|
if (_os_atomic_read(phl_to_drvpriv(phl_info), &band_ctrl->ccb_6gu6_rc) == 0)
|
|
band_ctrl->chctx_band_map &= ~BIT(CC_BAND_6G_U6);
|
|
} else if (CH_6GHZ_UNII7(chan_def->chan)) {
|
|
_os_atomic_dec(phl_to_drvpriv(phl_info), &band_ctrl->ccb_6gu7_rc);
|
|
if (_os_atomic_read(phl_to_drvpriv(phl_info), &band_ctrl->ccb_6gu7_rc) == 0)
|
|
band_ctrl->chctx_band_map &= ~BIT(CC_BAND_6G_U7);
|
|
} else if (CH_6GHZ_UNII8(chan_def->chan)) {
|
|
_os_atomic_dec(phl_to_drvpriv(phl_info), &band_ctrl->ccb_6gu8_rc);
|
|
if (_os_atomic_read(phl_to_drvpriv(phl_info), &band_ctrl->ccb_6gu8_rc) == 0)
|
|
band_ctrl->chctx_band_map &= ~BIT(CC_BAND_6G_U8);
|
|
} else {
|
|
PHL_ERR("%s chctx 6G band unknow\n", __func__);
|
|
_os_warn_on(1);
|
|
psts = RTW_PHL_STATUS_FAILURE;
|
|
}
|
|
}
|
|
return psts;
|
|
}
|
|
|
|
static enum rtw_phl_status
|
|
_phl_chanctx_add(struct phl_info_t *phl_info,
|
|
struct hw_band_ctl_t *band_ctrl,
|
|
struct rtw_chan_ctx *chanctx)
|
|
{
|
|
struct phl_queue *chan_ctx_queue;
|
|
enum rtw_phl_status psts = RTW_PHL_STATUS_FAILURE;
|
|
|
|
if (!chanctx)
|
|
return psts;
|
|
|
|
chan_ctx_queue = &band_ctrl->chan_ctx_queue;
|
|
|
|
list_add_tail(&chanctx->list, &chan_ctx_queue->queue);
|
|
chan_ctx_queue->cnt++;
|
|
if (chan_ctx_queue->cnt > MAX_CHANCTX_QUEUE_NUM) {
|
|
PHL_ERR("%s chan_ctx_queue cnt(%d) > 2\n", __func__, chan_ctx_queue->cnt);
|
|
_os_warn_on(1);
|
|
goto _exit;
|
|
}
|
|
psts = _phl_cc_band_map_set(phl_info, band_ctrl, chanctx);
|
|
|
|
_exit:
|
|
return psts;
|
|
}
|
|
|
|
static enum rtw_phl_status
|
|
_phl_chanctx_add_with_lock(struct phl_info_t *phl_info,
|
|
struct hw_band_ctl_t *band_ctrl,
|
|
struct rtw_chan_ctx *chanctx)
|
|
{
|
|
void *drv = phl_to_drvpriv(phl_info);
|
|
enum rtw_phl_status psts = RTW_PHL_STATUS_FAILURE;
|
|
|
|
if (!chanctx)
|
|
return psts;
|
|
|
|
_os_spinlock(drv, &band_ctrl->chan_ctx_queue.lock, _bh, NULL);
|
|
psts = _phl_chanctx_add(phl_info, band_ctrl, chanctx);
|
|
_os_spinunlock(drv, &band_ctrl->chan_ctx_queue.lock, _bh, NULL);
|
|
return psts;
|
|
}
|
|
|
|
static enum rtw_phl_status
|
|
_phl_chanctx_del(struct phl_info_t *phl_info,
|
|
struct hw_band_ctl_t *band_ctrl,
|
|
struct rtw_chan_ctx *chanctx)
|
|
{
|
|
struct phl_queue *chan_ctx_queue;
|
|
enum rtw_phl_status psts = RTW_PHL_STATUS_FAILURE;
|
|
|
|
if (!chanctx)
|
|
return psts;
|
|
|
|
psts = _phl_cc_band_map_clr(phl_info,band_ctrl, chanctx);
|
|
if (psts == RTW_PHL_STATUS_FAILURE) {
|
|
PHL_ERR("%s _phl_cc_band_map_clr failed\n", __func__);
|
|
_os_warn_on(1);
|
|
}
|
|
chan_ctx_queue = &band_ctrl->chan_ctx_queue;
|
|
/*if (!list_empty(&chan_ctx_queue->queue)) {*/
|
|
if (chan_ctx_queue->cnt) {
|
|
list_del(&chanctx->list);
|
|
chan_ctx_queue->cnt--;
|
|
if (chan_ctx_queue->cnt < 0) {
|
|
PHL_ERR("%s chan_ctx_queue cnt(%d) < 0\n", __func__, chan_ctx_queue->cnt);
|
|
_os_warn_on(1);
|
|
goto _exit;
|
|
}
|
|
}
|
|
psts = RTW_PHL_STATUS_SUCCESS;
|
|
_exit:
|
|
return psts;
|
|
}
|
|
|
|
static enum rtw_phl_status
|
|
_phl_chanctx_del_with_lock(struct phl_info_t *phl_info,
|
|
struct hw_band_ctl_t *band_ctrl,
|
|
struct rtw_chan_ctx *chanctx)
|
|
{
|
|
void *drv = phl_to_drvpriv(phl_info);
|
|
enum rtw_phl_status psts = RTW_PHL_STATUS_FAILURE;
|
|
|
|
if (!chanctx)
|
|
return psts;
|
|
|
|
_os_spinlock(drv, &band_ctrl->chan_ctx_queue.lock, _bh, NULL);
|
|
psts = _phl_chanctx_del(phl_info, band_ctrl, chanctx);
|
|
_os_spinunlock(drv, &band_ctrl->chan_ctx_queue.lock, _bh, NULL);
|
|
return psts;
|
|
}
|
|
|
|
static inline enum rtw_phl_status
|
|
_phl_chanctx_rmap_set(struct phl_info_t *phl_info,
|
|
struct rtw_wifi_role_t *wifi_role,
|
|
struct rtw_wifi_role_link_t *rlink,
|
|
struct phl_queue *chan_ctx_queue,
|
|
struct rtw_chan_ctx *chanctx)
|
|
{
|
|
u8 ridx = wifi_role->id;
|
|
|
|
if (!chanctx)
|
|
return RTW_PHL_STATUS_FAILURE;
|
|
|
|
if (chanctx->role_map & BIT(ridx)) {
|
|
PHL_ERR("wifi_role idx(%d) has in chanctx->role_map(0x%02x)\n",
|
|
ridx, chanctx->role_map);
|
|
_os_warn_on(1);
|
|
return RTW_PHL_STATUS_FAILURE;
|
|
}
|
|
|
|
chanctx->role_map |= BIT(ridx);
|
|
rlink->chanctx = chanctx;
|
|
return RTW_PHL_STATUS_SUCCESS;
|
|
}
|
|
|
|
static enum rtw_phl_status
|
|
_phl_chanctx_rmap_set_with_lock(struct phl_info_t *phl_info,
|
|
struct rtw_wifi_role_t *wifi_role,
|
|
struct rtw_wifi_role_link_t *rlink,
|
|
struct phl_queue *chan_ctx_queue,
|
|
struct rtw_chan_ctx *chanctx)
|
|
{
|
|
void *drv = phl_to_drvpriv(phl_info);
|
|
|
|
if (!chanctx)
|
|
return RTW_PHL_STATUS_FAILURE;
|
|
|
|
_os_spinlock(drv, &chan_ctx_queue->lock, _bh, NULL);
|
|
_phl_chanctx_rmap_set(phl_info, wifi_role, rlink, chan_ctx_queue, chanctx);
|
|
_os_spinunlock(drv, &chan_ctx_queue->lock, _bh, NULL);
|
|
return RTW_PHL_STATUS_SUCCESS;
|
|
}
|
|
|
|
static inline enum rtw_phl_status
|
|
_phl_chanctx_rmap_clr(struct phl_info_t *phl_info,
|
|
struct rtw_wifi_role_t *wifi_role,
|
|
struct rtw_wifi_role_link_t *rlink,
|
|
struct phl_queue *chan_ctx_queue,
|
|
struct rtw_chan_ctx *chanctx)
|
|
{
|
|
u8 ridx = wifi_role->id;
|
|
|
|
if (!chanctx)
|
|
return RTW_PHL_STATUS_FAILURE;
|
|
|
|
#ifdef DBG_CHCTX_RMAP
|
|
if (!(chanctx->role_map & BIT(ridx)))
|
|
PHL_ERR("ridx(%d) hasn't in chanctx->role_map(0x%02x)\n", ridx, chanctx->role_map);
|
|
#endif
|
|
rlink->chanctx = NULL;
|
|
chanctx->role_map &= ~BIT(ridx);
|
|
|
|
return RTW_PHL_STATUS_SUCCESS;
|
|
}
|
|
|
|
static enum rtw_phl_status
|
|
_phl_chanctx_rmap_clr_with_lock(struct phl_info_t *phl_info,
|
|
struct rtw_wifi_role_t *wifi_role,
|
|
struct rtw_wifi_role_link_t *rlink,
|
|
struct phl_queue *chan_ctx_queue,
|
|
struct rtw_chan_ctx *chanctx)
|
|
{
|
|
void *drv = phl_to_drvpriv(phl_info);
|
|
|
|
if (!chanctx)
|
|
return RTW_PHL_STATUS_FAILURE;
|
|
|
|
_os_spinlock(drv, &chan_ctx_queue->lock, _bh, NULL);
|
|
_phl_chanctx_rmap_clr(phl_info, wifi_role, rlink, chan_ctx_queue, chanctx);
|
|
_os_spinunlock(drv, &chan_ctx_queue->lock, _bh, NULL);
|
|
return RTW_PHL_STATUS_SUCCESS;
|
|
}
|
|
|
|
u8 phl_chanctx_get_rnum(struct phl_info_t *phl_info,
|
|
struct phl_queue *chan_ctx_queue,
|
|
struct rtw_chan_ctx *chanctx)
|
|
{
|
|
u8 i;
|
|
u8 role_num = 0;
|
|
|
|
for (i = 0; i < MAX_WIFI_ROLE_NUMBER; i++)
|
|
if (chanctx->role_map & BIT(i))
|
|
role_num++;
|
|
return role_num;
|
|
}
|
|
|
|
u8 phl_chanctx_get_rnum_with_lock(struct phl_info_t *phl_info,
|
|
struct phl_queue *chan_ctx_queue,
|
|
struct rtw_chan_ctx *chanctx)
|
|
{
|
|
void *drv = phl_to_drvpriv(phl_info);
|
|
u8 role_num = 0;
|
|
|
|
if (!chanctx)
|
|
return role_num;
|
|
|
|
_os_spinlock(drv, &chan_ctx_queue->lock, _bh, NULL);
|
|
role_num = phl_chanctx_get_rnum(phl_info, chan_ctx_queue, chanctx);
|
|
_os_spinunlock(drv, &chan_ctx_queue->lock, _bh, NULL);
|
|
return role_num;
|
|
}
|
|
|
|
/**
|
|
* _phl_is_chbw_grouped - test if the two ch settings can be grouped together
|
|
* @chandef_a : chandef of set a
|
|
* @chandef_b : chandef of set b
|
|
*/
|
|
static bool _phl_is_chbw_grouped(struct rtw_chan_def *chandef_a,
|
|
struct rtw_chan_def *chandef_b)
|
|
{
|
|
bool is_grouped = false;
|
|
|
|
if (chandef_a->band != chandef_b->band)
|
|
goto exit;
|
|
|
|
if (chandef_a->chan != chandef_b->chan) {
|
|
/* ch is different */
|
|
goto exit;
|
|
} else if ((chandef_a->bw == CHANNEL_WIDTH_40 || chandef_a->bw == CHANNEL_WIDTH_80 ||
|
|
chandef_a->bw == CHANNEL_WIDTH_160)
|
|
&& (chandef_b->bw == CHANNEL_WIDTH_40 || chandef_b->bw == CHANNEL_WIDTH_80 ||
|
|
chandef_b->bw == CHANNEL_WIDTH_160)
|
|
) {
|
|
if (chandef_a->offset != chandef_b->offset)
|
|
goto exit;
|
|
}
|
|
|
|
is_grouped = true;
|
|
|
|
exit:
|
|
return is_grouped;
|
|
}
|
|
|
|
|
|
static inline bool
|
|
_phl_feature_check(struct rtw_phl_com_t *phl_com, u8 flg)
|
|
{
|
|
return (phl_com->dev_cap.hw_sup_flags & flg) ? true : false;
|
|
}
|
|
|
|
static void _phl_upt_offset_by_chbw_24g(struct rtw_chan_def *n_chdef)
|
|
{
|
|
u8 valid = 1;
|
|
enum chan_offset offset = CHAN_OFFSET_NO_EXT;
|
|
|
|
if (n_chdef->bw >= CHANNEL_WIDTH_80
|
|
|| n_chdef->chan < 1 || n_chdef->chan > 14
|
|
) {
|
|
PHL_ERR("%s bw:%d, ch:%d - check failed\n", __func__, n_chdef->bw, n_chdef->chan);
|
|
valid = 0;
|
|
goto exit;
|
|
}
|
|
|
|
if (n_chdef->bw == CHANNEL_WIDTH_20)
|
|
goto exit;
|
|
|
|
if (n_chdef->chan >= 1 && n_chdef->chan <= 4) {
|
|
offset = CHAN_OFFSET_UPPER;
|
|
}
|
|
else if (n_chdef->chan >= 5 && n_chdef->chan <= 9) {
|
|
if (n_chdef->offset == CHAN_OFFSET_UPPER || n_chdef->offset == CHAN_OFFSET_LOWER)
|
|
offset = n_chdef->offset; /* both lower and upper is valid, obey input value */
|
|
else
|
|
offset = CHAN_OFFSET_LOWER; /* default use primary upper */
|
|
} else if (n_chdef->chan >= 10 && n_chdef->chan <= 13) {
|
|
offset = CHAN_OFFSET_LOWER;
|
|
}
|
|
else {
|
|
valid = 0; /* ch14 doesn't support 40MHz bandwidth */
|
|
goto exit;
|
|
}
|
|
|
|
exit:
|
|
if (valid)
|
|
n_chdef->offset = offset;
|
|
|
|
}
|
|
static void _phl_upt_offset_by_chbw_5g(struct rtw_chan_def *n_chdef)
|
|
{
|
|
u8 valid = 1;
|
|
enum chan_offset offset = CHAN_OFFSET_NO_EXT;
|
|
|
|
if (n_chdef->chan < 36 || n_chdef->chan > 177) {
|
|
valid = 0;
|
|
goto exit;
|
|
}
|
|
|
|
switch (n_chdef->chan) {
|
|
case 36:
|
|
case 44:
|
|
case 52:
|
|
case 60:
|
|
case 100:
|
|
case 108:
|
|
case 116:
|
|
case 124:
|
|
case 132:
|
|
case 140:
|
|
case 149:
|
|
case 157:
|
|
case 165:
|
|
case 173:
|
|
if (n_chdef->bw >= CHANNEL_WIDTH_40 && n_chdef->bw <= CHANNEL_WIDTH_160)
|
|
offset = CHAN_OFFSET_UPPER;
|
|
break;
|
|
case 40:
|
|
case 48:
|
|
case 56:
|
|
case 64:
|
|
case 104:
|
|
case 112:
|
|
case 120:
|
|
case 128:
|
|
case 136:
|
|
case 144:
|
|
case 153:
|
|
case 161:
|
|
case 169:
|
|
case 177:
|
|
if (n_chdef->bw >= CHANNEL_WIDTH_40 && n_chdef->bw <= CHANNEL_WIDTH_160)
|
|
offset = CHAN_OFFSET_LOWER;
|
|
break;
|
|
default:
|
|
valid = 0;
|
|
break;
|
|
}
|
|
|
|
exit:
|
|
if (valid)
|
|
n_chdef->offset = offset;
|
|
}
|
|
static void _phl_upt_offset_by_chbw_6g(struct rtw_chan_def *n_chdef)
|
|
{
|
|
if (n_chdef->chan >= 1 && n_chdef->chan <= 253) {
|
|
u8 mod8 = n_chdef->chan % 8;
|
|
|
|
if (mod8 == 1) {
|
|
if (n_chdef->bw == CHANNEL_WIDTH_20)
|
|
n_chdef->offset = CHAN_OFFSET_NO_EXT;
|
|
else
|
|
n_chdef->offset = CHAN_OFFSET_UPPER;
|
|
}
|
|
if (mod8 == 5) {
|
|
if (n_chdef->bw == CHANNEL_WIDTH_20)
|
|
n_chdef->offset = CHAN_OFFSET_NO_EXT;
|
|
else
|
|
n_chdef->offset = CHAN_OFFSET_LOWER;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void _phl_upt_offset_by_chbw(struct rtw_chan_def *n_chdef)
|
|
{
|
|
if (n_chdef->band == BAND_ON_24G)
|
|
_phl_upt_offset_by_chbw_24g(n_chdef);
|
|
else if (n_chdef->band == BAND_ON_5G)
|
|
_phl_upt_offset_by_chbw_5g(n_chdef);
|
|
else if (n_chdef->band == BAND_ON_6G)
|
|
_phl_upt_offset_by_chbw_6g(n_chdef);
|
|
}
|
|
|
|
static void
|
|
_phl_adjust_chandef(struct rtw_chan_def *n_chdef,
|
|
struct rtw_chan_def *g_chdef,
|
|
bool g_chdef_upt)
|
|
{
|
|
|
|
n_chdef->band = g_chdef->band;
|
|
n_chdef->chan = g_chdef->chan;
|
|
|
|
if ((g_chdef->band == BAND_ON_24G) &&
|
|
(n_chdef->bw == CHANNEL_WIDTH_80 || n_chdef->bw == CHANNEL_WIDTH_160)) {
|
|
/*2.4G ch, downgrade to 40Mhz */
|
|
n_chdef->bw = CHANNEL_WIDTH_40;
|
|
}
|
|
|
|
switch (n_chdef->bw) {
|
|
case CHANNEL_WIDTH_160:
|
|
case CHANNEL_WIDTH_80:
|
|
case CHANNEL_WIDTH_40:
|
|
if (g_chdef->bw == CHANNEL_WIDTH_40 || g_chdef->bw == CHANNEL_WIDTH_80 ||
|
|
g_chdef->bw == CHANNEL_WIDTH_160)
|
|
n_chdef->offset = g_chdef->offset;
|
|
else if (g_chdef->bw == CHANNEL_WIDTH_20)
|
|
_phl_upt_offset_by_chbw(n_chdef);
|
|
|
|
if (n_chdef->offset == CHAN_OFFSET_NO_EXT) {
|
|
if (n_chdef->bw == CHANNEL_WIDTH_160)
|
|
PHL_ERR("%s req 160MHz BW without offset, down to 20MHz\n", __func__);
|
|
else if (n_chdef->bw == CHANNEL_WIDTH_80)
|
|
PHL_ERR("%s req 80MHz BW without offset, down to 20MHz\n", __func__);
|
|
else if (n_chdef->bw == CHANNEL_WIDTH_40)
|
|
PHL_ERR("%s req 40MHz BW without offset, down to 20MHz\n", __func__);
|
|
_os_warn_on(1);
|
|
n_chdef->bw = CHANNEL_WIDTH_20;
|
|
}
|
|
break;
|
|
case CHANNEL_WIDTH_20:
|
|
n_chdef->offset = CHAN_OFFSET_NO_EXT;
|
|
break;
|
|
default:
|
|
PHL_ERR("%s req unsupported BW:%u\n", __func__, n_chdef->bw);
|
|
_os_warn_on(1);
|
|
break;
|
|
}
|
|
|
|
if (!g_chdef_upt)
|
|
return;
|
|
|
|
if (n_chdef->bw > g_chdef->bw) {
|
|
g_chdef->bw = n_chdef->bw;
|
|
g_chdef->offset = n_chdef->offset;
|
|
}
|
|
}
|
|
|
|
static enum rtw_phl_status
|
|
_phl_chanctx_create(struct phl_info_t *phl_info,
|
|
struct rtw_wifi_role_t *wifi_role,
|
|
struct rtw_wifi_role_link_t *rlink,
|
|
struct rtw_chan_def *new_chdef)
|
|
{
|
|
enum rtw_phl_status phl_sts = RTW_PHL_STATUS_FAILURE;
|
|
void *drv = phl_to_drvpriv(phl_info);
|
|
struct rtw_chan_ctx *chanctx = NULL;
|
|
struct mr_ctl_t *mr_ctl = phlcom_to_mr_ctrl(phl_info->phl_com);
|
|
struct hw_band_ctl_t *band_ctrl = &(mr_ctl->band_ctrl[rlink->hw_band]);
|
|
chanctx = _os_kmem_alloc(drv, sizeof(struct rtw_chan_ctx));
|
|
if (chanctx == NULL) {
|
|
PHL_ERR("alloc chanctx failed\n");
|
|
goto _exit;
|
|
}
|
|
|
|
_os_mem_cpy(drv, &chanctx->chan_def, new_chdef, sizeof(struct rtw_chan_def));
|
|
phl_sts = _phl_chanctx_add_with_lock(phl_info, band_ctrl, chanctx);
|
|
|
|
if (phl_sts == RTW_PHL_STATUS_SUCCESS)
|
|
_phl_chanctx_rmap_set_with_lock(phl_info,
|
|
wifi_role,
|
|
rlink,
|
|
&band_ctrl->chan_ctx_queue,
|
|
chanctx);
|
|
_exit:
|
|
return phl_sts;
|
|
}
|
|
|
|
enum rtw_phl_status
|
|
phl_chanctx_free(struct phl_info_t *phl_info, struct hw_band_ctl_t *band_ctl)
|
|
{
|
|
int chanctx_num = 0;
|
|
struct rtw_chan_ctx *chanctx = NULL;
|
|
struct phl_queue *chan_ctx_queue = &band_ctl->chan_ctx_queue;
|
|
void *drv = phl_to_drvpriv(phl_info);
|
|
|
|
chanctx_num = phl_mr_get_chanctx_num(phl_info, band_ctl);
|
|
if (chanctx_num == 0)
|
|
return RTW_PHL_STATUS_SUCCESS;
|
|
|
|
PHL_INFO("%s band_idx:%d chctx_num:%d\n", __func__, band_ctl->id, chanctx_num);
|
|
do {
|
|
_os_spinlock(drv, &band_ctl->chan_ctx_queue.lock, _bh, NULL);
|
|
if (list_empty(&chan_ctx_queue->queue)) {
|
|
chanctx = NULL;
|
|
} else {
|
|
chanctx = list_first_entry(&chan_ctx_queue->queue,
|
|
struct rtw_chan_ctx, list);
|
|
list_del(&chanctx->list);
|
|
chan_ctx_queue->cnt--;
|
|
}
|
|
_os_spinunlock(drv, &band_ctl->chan_ctx_queue.lock, _bh, NULL);
|
|
|
|
if (chanctx) {
|
|
_os_kmem_free(drv, chanctx, sizeof(struct rtw_chan_ctx));
|
|
}
|
|
} while (chanctx != NULL);
|
|
return RTW_PHL_STATUS_SUCCESS;
|
|
}
|
|
|
|
/* used for get all role under band_idx */
|
|
u8 phl_get_chanctx_rolemap(struct phl_info_t *phl_info, u8 band_idx)
|
|
{
|
|
void *drv = phl_to_drvpriv(phl_info);
|
|
struct hw_band_ctl_t *band_ctrl = get_band_ctrl(phl_info, band_idx);
|
|
_os_list *chan_ctx_list = &band_ctrl->chan_ctx_queue.queue;
|
|
struct rtw_chan_ctx *chanctx = NULL;
|
|
u8 role_map =0;
|
|
|
|
_os_spinlock(drv, &band_ctrl->chan_ctx_queue.lock, _bh, NULL);
|
|
phl_list_for_loop(chanctx, struct rtw_chan_ctx, chan_ctx_list, list) {
|
|
role_map |= chanctx->role_map;
|
|
}
|
|
_os_spinunlock(drv, &band_ctrl->chan_ctx_queue.lock, _bh, NULL);
|
|
|
|
return role_map;
|
|
}
|
|
static bool
|
|
is_ch_in_same_band(struct rtw_chan_def *chdef_a, struct rtw_chan_def *chdef_b)
|
|
{
|
|
bool ch_in_same_band = false;
|
|
|
|
if (chdef_a->band == chdef_b->band) {
|
|
if (BAND_2GHZ(chdef_a->band)) {
|
|
PHL_INFO("%s - case MC-SB : 2G(%d)+2G(%d)\n",
|
|
__func__, chdef_a->chan, chdef_b->chan);
|
|
ch_in_same_band = true;
|
|
} else if (BAND_5GHZ(chdef_b->band)) {
|
|
if (CH_IN_SAME_5G_BAND(chdef_a->chan, chdef_b->chan)) {
|
|
PHL_INFO("%s - case MC-SB : 5G(%d)+5G(%d)\n",
|
|
__func__, chdef_a->chan, chdef_b->chan);
|
|
ch_in_same_band = true;
|
|
}
|
|
} else if (BAND_6GHZ(chdef_b->band)) {
|
|
if (CH_IN_SAME_6G_BAND(chdef_a->chan, chdef_b->chan)) {
|
|
PHL_INFO("%s - case MC-SB : 6G(%d)+6G(%d)\n",
|
|
__func__, chdef_a->chan, chdef_b->chan);
|
|
ch_in_same_band = true;
|
|
}
|
|
}
|
|
}
|
|
return ch_in_same_band;
|
|
}
|
|
|
|
static bool
|
|
is_ch_in_interference_band(struct rtw_chan_def *chdef_a, struct rtw_chan_def *chdef_b)
|
|
{
|
|
bool ch_in_same_band = false;
|
|
|
|
if (BAND_5GHZ(chdef_a->band) && BAND_5GHZ(chdef_b->band)) {
|
|
PHL_INFO("%s - case MC-MB : 5G(%d)+5G(%d)\n",
|
|
__func__, chdef_a->chan, chdef_b->chan);
|
|
ch_in_same_band = true;
|
|
} else if (BAND_6GHZ(chdef_a->band) && BAND_6GHZ(chdef_b->band)) {
|
|
PHL_INFO("%s - case MC-MB : 6G(%d)+6G(%d)\n",
|
|
__func__, chdef_a->chan, chdef_b->chan);
|
|
ch_in_same_band = true;
|
|
} else if (BAND_5GHZ(chdef_a->band) && BAND_6GHZ(chdef_b->band)) {
|
|
PHL_INFO("%s - case MC-MB : 5G(%d)+6G(%d)\n",
|
|
__func__, chdef_a->chan, chdef_b->chan);
|
|
ch_in_same_band = true;
|
|
} else if (BAND_6GHZ(chdef_a->band) && BAND_5GHZ(chdef_b->band)) {
|
|
PHL_INFO("%s - case MC-MB : 6G(%d)+5G(%d)\n",
|
|
__func__, chdef_a->chan, chdef_b->chan);
|
|
ch_in_same_band = true;
|
|
}
|
|
return ch_in_same_band;
|
|
}
|
|
|
|
static void _phl_dump_mr_cc_info(struct phl_info_t *phl_info,
|
|
struct rtw_mr_chctx_info *mr_cc_info)
|
|
{
|
|
PHL_INFO("[CC-INFO] is dual band:%s\n", (mr_cc_info->is_db) ? "Y" : "N");
|
|
PHL_INFO("[CC-INFO] cur_band_idx:%d\n", mr_cc_info->cur_band_idx);
|
|
PHL_INFO("[CC-INFO] role_num:%d\n", mr_cc_info->role_num);
|
|
PHL_INFO("[CC-INFO] chctx_num:%d\n", mr_cc_info->chctx_num);
|
|
|
|
PHL_INFO("[CC-INFO] chctx_band_map:0x%04x\n", mr_cc_info->chctx_band_map);
|
|
phl_dump_cc_band_map(phl_info, mr_cc_info->chctx_band_map);
|
|
|
|
if (mr_cc_info->sugg_opmode == MR_OP_SWR)
|
|
PHL_INFO("[CC-INFO] suggest opmode:%s\n", "SINGLE ROLE");
|
|
else if (mr_cc_info->sugg_opmode == MR_OP_SCC)
|
|
PHL_INFO("[CC-INFO] suggest opmode:%s\n", "SCC");
|
|
else if (mr_cc_info->sugg_opmode == MR_OP_MCC)
|
|
PHL_INFO("[CC-INFO] suggest opmode:%s\n", "MCC");
|
|
else if (mr_cc_info->sugg_opmode == MR_OP_DBCC)
|
|
PHL_INFO("[CC-INFO] suggest opmode:%s\n", "DBCC");
|
|
else
|
|
PHL_INFO("[CC-INFO] suggest opmode:%s\n", "NON");
|
|
}
|
|
|
|
bool rtw_phl_chanctx_chk_by_band(void *phl,
|
|
u8 band_idx,
|
|
struct rtw_chan_def *new_chdef,
|
|
struct rtw_mr_chctx_info *mr_cc_info)
|
|
{
|
|
struct phl_info_t *phl_info = (struct phl_info_t *)phl;
|
|
struct rtw_phl_com_t *phl_com = phl_info->phl_com;
|
|
void *drv = phl_to_drvpriv(phl_info);
|
|
struct mr_ctl_t *mr_ctl = phlcom_to_mr_ctrl(phl_com);
|
|
bool is_ch_group = false;
|
|
struct hw_band_ctl_t *band_ctrl = &(mr_ctl->band_ctrl[band_idx]);
|
|
int chanctx_num = 0;
|
|
struct rtw_chan_ctx *chanctx = NULL;
|
|
struct rtw_chan_def *chandef = NULL;
|
|
enum mr_op_mode sop_mode = MR_OP_NONE;
|
|
u8 band_role_num = 0;
|
|
|
|
if (new_chdef && new_chdef->chan == 0) {
|
|
PHL_ERR("%s req chan = 0 \n", __func__);
|
|
_os_warn_on(1);
|
|
goto _exit;
|
|
}
|
|
|
|
#if 0 /*status check for debug*/
|
|
if (mr_ctl->is_db == true) { /*in DBCC*/
|
|
struct hw_band_ctl_t *tmp_band_ctrl = NULL;
|
|
u8 band_idx;
|
|
|
|
for (band_idx = 0; band_idx < HW_BAND_MAX; band_idx++) {
|
|
tmp_band_ctrl = &mr_ctl->band_ctrl[band_idx];
|
|
band_role_num = phl_mr_get_role_num(phl_info, tmp_band_ctrl);
|
|
chanctx_num = phl_mr_get_chanctx_num(phl_info, tmp_band_ctrl);
|
|
PHL_INFO("BAND_%d : role num:%d, chctx num:%d\n",
|
|
band_idx, band_role_num, chanctx_num);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
band_role_num = phl_mr_get_role_num(phl_info, band_ctrl);
|
|
|
|
chanctx_num = phl_mr_get_chanctx_num(phl_info, band_ctrl);
|
|
|
|
if (new_chdef) {
|
|
if (chanctx_num == 0) {
|
|
is_ch_group = true;
|
|
sop_mode = MR_OP_SWR;
|
|
goto _exit;
|
|
}
|
|
|
|
_os_spinlock(drv, &band_ctrl->chan_ctx_queue.lock, _bh, NULL);
|
|
phl_list_for_loop(chanctx, struct rtw_chan_ctx, &band_ctrl->chan_ctx_queue.queue, list) {
|
|
chandef = &chanctx->chan_def;
|
|
is_ch_group = _phl_is_chbw_grouped(chandef, new_chdef);
|
|
if (is_ch_group)
|
|
break;
|
|
}
|
|
_os_spinunlock(drv, &band_ctrl->chan_ctx_queue.lock, _bh, NULL);
|
|
|
|
if (is_ch_group == true) {/* SCC or MCC */
|
|
/*current chanctx_num*/
|
|
if (chanctx_num == 1) {
|
|
sop_mode = MR_OP_SCC;
|
|
}
|
|
else if (chanctx_num == 2) {
|
|
#ifdef CONFIG_MCC_SUPPORT
|
|
if (phl_com->dev_cap.mcc_sup == true) {
|
|
sop_mode = MR_OP_MCC;
|
|
} else
|
|
#endif
|
|
{
|
|
PHL_ERR("Don't support MCC, but cur chanctx num = 2 ??\n");
|
|
_os_warn_on(1);
|
|
}
|
|
}
|
|
else {
|
|
PHL_ERR("%s Unknow state - chan can grouped, ch-ctx num:%d\n",
|
|
__func__, chanctx_num);
|
|
_os_warn_on(1);
|
|
}
|
|
goto _exit;
|
|
}
|
|
|
|
if (chanctx_num >= 2) {
|
|
PHL_ERR("current chan_ctx num(%d) >= 2, not support over 3xchan-set on one band\n",
|
|
chanctx_num);
|
|
#ifdef CONFIG_DBCC_SUPPORT
|
|
/*TODO : Consider scenario - [MCC] 2G-CH6+5G-CH149, New ch is 2G-CH11*/
|
|
if (phl_com->dev_cap.mcmb_skip_dbcc == false && phl_com->dev_cap.dbcc_sup == true)
|
|
sop_mode = MR_OP_DBCC;
|
|
#endif
|
|
goto _exit;
|
|
}
|
|
|
|
/* MCC,condition- chanctx_num == 1 */
|
|
/* MC-SB */
|
|
if (is_ch_in_same_band(new_chdef, chandef))
|
|
goto _mcc_hdl;
|
|
|
|
/* MC-MB - MCC */
|
|
#ifdef CONFIG_DBCC_SUPPORT
|
|
if (phl_com->dev_cap.mcmb_itf_ctrl == false &&
|
|
is_ch_in_interference_band(new_chdef, chandef))
|
|
goto _mcc_hdl;
|
|
|
|
/* MC-MB - DBCC */
|
|
if (phl_com->dev_cap.mcmb_skip_dbcc == false && phl_com->dev_cap.dbcc_sup == true) {
|
|
PHL_INFO("%s support DBCC\n", __func__);
|
|
/* suggest DBCC */
|
|
sop_mode = MR_OP_DBCC;
|
|
goto _exit;
|
|
}
|
|
#endif
|
|
|
|
_mcc_hdl:
|
|
/* MCC */
|
|
#ifdef CONFIG_MCC_SUPPORT
|
|
if (phl_com->dev_cap.mcc_sup == true) {
|
|
PHL_INFO("%s support MCC\n", __func__);
|
|
is_ch_group = true;
|
|
sop_mode = MR_OP_MCC;
|
|
} else
|
|
#endif
|
|
{
|
|
PHL_ERR("%s don't support MCC\n", __func__);
|
|
}
|
|
} else {
|
|
if (mr_ctl->is_db == false) { /*stay in single band*/
|
|
sop_mode = band_ctrl->op_mode;
|
|
} else {/*stay in dual band*/
|
|
#ifdef CONFIG_DBCC_SUPPORT
|
|
if (band_ctrl->op_mode == MR_OP_NONE)
|
|
sop_mode = MR_OP_DBCC;
|
|
#endif
|
|
}
|
|
}
|
|
_exit:
|
|
if (mr_cc_info) {
|
|
mr_cc_info->is_db = mr_ctl->is_db;
|
|
mr_cc_info->cur_band_idx = band_idx;
|
|
mr_cc_info->role_num = band_role_num;
|
|
mr_cc_info->chctx_num = (u8)chanctx_num;
|
|
mr_cc_info->chctx_band_map = band_ctrl->chctx_band_map;
|
|
mr_cc_info->sugg_opmode = sop_mode;
|
|
_phl_dump_mr_cc_info(phl_info, mr_cc_info);
|
|
}
|
|
|
|
PHL_DUMP_MR_EX(phl_info);
|
|
return is_ch_group;
|
|
}
|
|
bool rtw_phl_chanctx_chk(void *phl,
|
|
struct rtw_wifi_role_t *wifi_role,
|
|
struct rtw_wifi_role_link_t *rlink,
|
|
struct rtw_chan_def *new_chdef,
|
|
struct rtw_mr_chctx_info *mr_cc_info)
|
|
{
|
|
return rtw_phl_chanctx_chk_by_band(phl, rlink->hw_band, new_chdef, mr_cc_info);
|
|
}
|
|
|
|
bool rtw_phl_adjust_chandef(void *phl,
|
|
struct rtw_wifi_role_link_t *rlink,
|
|
struct rtw_chan_def *new_chdef)
|
|
{
|
|
bool is_ch_grouped = false;
|
|
struct phl_info_t *phl_info = (struct phl_info_t *)phl;
|
|
void *drv = phl_to_drvpriv(phl_info);
|
|
u8 band_idx = rlink->hw_band;
|
|
struct hw_band_ctl_t *band_ctrl = get_band_ctrl(phl, band_idx);
|
|
_os_list *chan_ctx_list = &band_ctrl->chan_ctx_queue.queue;
|
|
struct rtw_chan_ctx *chanctx = NULL;
|
|
struct rtw_chan_def *chandef = NULL;
|
|
|
|
_os_spinlock(drv, &band_ctrl->chan_ctx_queue.lock, _bh, NULL);
|
|
phl_list_for_loop(chanctx, struct rtw_chan_ctx, chan_ctx_list, list) {
|
|
chandef = &chanctx->chan_def;
|
|
is_ch_grouped = _phl_is_chbw_grouped(chandef, new_chdef);
|
|
if (is_ch_grouped) {
|
|
_phl_adjust_chandef(new_chdef, chandef, false);
|
|
break;
|
|
}
|
|
}
|
|
_os_spinunlock(drv, &band_ctrl->chan_ctx_queue.lock, _bh, NULL);
|
|
|
|
return is_ch_grouped;
|
|
}
|
|
|
|
static bool phl_chanctx_add(struct phl_info_t *phl_info,
|
|
struct rtw_wifi_role_t *wifi_role,
|
|
struct rtw_wifi_role_link_t *rlink,
|
|
struct rtw_chan_def *new_chdef,
|
|
struct rtw_mr_chctx_info *mr_cc_info)
|
|
{
|
|
enum rtw_phl_status phl_sts = RTW_PHL_STATUS_FAILURE;
|
|
struct rtw_phl_com_t *phl_com = phl_info->phl_com;
|
|
void *drv = phl_to_drvpriv(phl_info);
|
|
struct mr_ctl_t *mr_ctl = phlcom_to_mr_ctrl(phl_com);
|
|
u8 band_idx = rlink->hw_band;
|
|
struct hw_band_ctl_t *band_ctrl = &(mr_ctl->band_ctrl[band_idx]);
|
|
struct rtw_chan_ctx *chanctx = NULL;
|
|
struct rtw_chan_def *chandef = NULL;
|
|
_os_list *chan_ctx_list = &band_ctrl->chan_ctx_queue.queue;
|
|
bool is_ch_grouped = false;
|
|
bool rmap_chk_fail = false;
|
|
enum mr_op_mode sop_mode = MR_OP_NONE;
|
|
u8 band_role_num = 0;
|
|
int chanctx_num = 0;
|
|
|
|
if (wifi_role == NULL) {
|
|
PHL_ERR("%s wrole == NULL\n", __func__);
|
|
goto _exit;
|
|
}
|
|
|
|
PHL_INFO("%s new chan_def - hw_band_idx:%d, band:%u, chan:%d, bw:%d, offset:%d\n",
|
|
__func__, rlink->hw_band, new_chdef->band,
|
|
new_chdef->chan, new_chdef->bw, new_chdef->offset);
|
|
|
|
band_ctrl->op_mode = sop_mode;
|
|
band_role_num = phl_mr_get_role_num(phl_info, band_ctrl);
|
|
|
|
chanctx_num = phl_mr_get_chanctx_num(phl_info, band_ctrl);
|
|
if (chanctx_num == 0) {
|
|
phl_sts = _phl_chanctx_create(phl_info, wifi_role, rlink, new_chdef);
|
|
if (phl_sts == RTW_PHL_STATUS_SUCCESS) {
|
|
is_ch_grouped = true;
|
|
sop_mode = MR_OP_SWR;
|
|
band_ctrl->op_mode = sop_mode;
|
|
}
|
|
else {
|
|
PHL_ERR("%s %d create chanctx failed\n", __FUNCTION__, __LINE__);
|
|
_os_warn_on(1);
|
|
}
|
|
goto _exit;
|
|
}
|
|
|
|
_os_spinlock(drv, &band_ctrl->chan_ctx_queue.lock, _bh, NULL);
|
|
phl_list_for_loop(chanctx, struct rtw_chan_ctx, chan_ctx_list, list) {
|
|
chandef = &chanctx->chan_def;
|
|
is_ch_grouped = _phl_is_chbw_grouped(chandef, new_chdef);
|
|
if (is_ch_grouped) {
|
|
_phl_adjust_chandef(new_chdef, chandef, true);
|
|
_os_mem_cpy(drv, new_chdef, chandef, sizeof(struct rtw_chan_def));
|
|
phl_sts = _phl_chanctx_rmap_set(phl_info, wifi_role, rlink,
|
|
&band_ctrl->chan_ctx_queue, chanctx);
|
|
if (phl_sts != RTW_PHL_STATUS_SUCCESS) {
|
|
rmap_chk_fail = true;
|
|
is_ch_grouped = false;
|
|
sop_mode = MR_OP_MAX;
|
|
/*band_ctrl->op_mode = sop_mode;*/
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
_os_spinunlock(drv, &band_ctrl->chan_ctx_queue.lock, _bh, NULL);
|
|
|
|
if (rmap_chk_fail == true)
|
|
goto _exit;
|
|
|
|
if (is_ch_grouped == true) {/****** SCC or MCC ******/
|
|
PHL_INFO("%s grouped chan_def - hw_band_idx:%d band:%d chan:%d, bw:%d, offset:%d\n",
|
|
__func__, rlink->hw_band, new_chdef->band, new_chdef->chan, new_chdef->bw, new_chdef->offset);
|
|
|
|
/*current chanctx_num*/
|
|
if (chanctx_num == 1) {
|
|
sop_mode = MR_OP_SCC;
|
|
band_ctrl->op_mode = sop_mode;
|
|
}
|
|
else if (chanctx_num == 2) {
|
|
#ifdef CONFIG_MCC_SUPPORT
|
|
if (phl_com->dev_cap.mcc_sup == true) {
|
|
sop_mode = MR_OP_MCC;
|
|
band_ctrl->op_mode = sop_mode;
|
|
} else
|
|
#endif
|
|
{
|
|
PHL_ERR("Don't support MCC, but cur chanctx num = 2 ??\n");
|
|
_os_warn_on(1);
|
|
}
|
|
}
|
|
else {
|
|
PHL_ERR("%s Unknow state - chan can grouped, ch-ctx num:%d\n",
|
|
__func__, chanctx_num);
|
|
_os_warn_on(1);
|
|
}
|
|
goto _exit;
|
|
}
|
|
|
|
if (chanctx_num >= 2) {
|
|
PHL_ERR("current chan_ctx num(%d) >= 2, not support over 3xchan-set on one band\n",
|
|
chanctx_num);
|
|
#ifdef CONFIG_DBCC_SUPPORT
|
|
/*TODO : Consider scenario - [MCC] 2G-CH6+5G-CH149, New ch is 2G-CH11*/
|
|
if (phl_com->dev_cap.mcmb_skip_dbcc == false && phl_com->dev_cap.dbcc_sup == true)
|
|
sop_mode = MR_OP_DBCC;
|
|
#endif
|
|
goto _exit;
|
|
}
|
|
|
|
/* MCC - chanctx_num == 1 */
|
|
/* MC-SB */
|
|
if (is_ch_in_same_band(new_chdef, chandef))
|
|
goto _mcc_hdl;
|
|
|
|
/* MC-MB - MCC */
|
|
#ifdef CONFIG_DBCC_SUPPORT
|
|
if (phl_com->dev_cap.mcmb_itf_ctrl == false &&
|
|
is_ch_in_interference_band(new_chdef, chandef))
|
|
goto _mcc_hdl;
|
|
|
|
/* MC-MB - DBCC */
|
|
if (phl_com->dev_cap.mcmb_skip_dbcc == false && phl_com->dev_cap.dbcc_sup == true) {
|
|
PHL_INFO("%s support DBCC\n", __func__);
|
|
sop_mode = MR_OP_DBCC;
|
|
goto _exit;
|
|
}
|
|
#endif
|
|
|
|
_mcc_hdl:
|
|
/* MCC */
|
|
#ifdef CONFIG_MCC_SUPPORT
|
|
if (phl_com->dev_cap.mcc_sup == true) {
|
|
phl_sts = _phl_chanctx_create(phl_info,
|
|
wifi_role,
|
|
rlink,
|
|
new_chdef);
|
|
if (phl_sts == RTW_PHL_STATUS_SUCCESS) {
|
|
is_ch_grouped = true;
|
|
PHL_INFO("%s chan:%d, bw:%d, offset:%d could be created - MCC\n",
|
|
__func__, new_chdef->chan, new_chdef->bw, new_chdef->offset);
|
|
sop_mode = MR_OP_MCC;
|
|
band_ctrl->op_mode = sop_mode;
|
|
} else {
|
|
PHL_ERR("%s %d create chanctx failed\n", __FUNCTION__, __LINE__);
|
|
_os_warn_on(1);
|
|
}
|
|
}
|
|
#endif/*CONFIG_MCC_SUPPORT*/
|
|
{
|
|
PHL_ERR("%s don't support MCC\n", __func__);
|
|
}
|
|
|
|
_exit:
|
|
if (mr_cc_info) {
|
|
mr_cc_info->is_db = mr_ctl->is_db;
|
|
mr_cc_info->cur_band_idx = band_idx;
|
|
mr_cc_info->role_num = band_role_num;
|
|
mr_cc_info->chctx_num = (u8)chanctx_num;
|
|
mr_cc_info->chctx_band_map = band_ctrl->chctx_band_map;
|
|
mr_cc_info->sugg_opmode = sop_mode;
|
|
_phl_dump_mr_cc_info(phl_info, mr_cc_info);
|
|
}
|
|
PHL_DUMP_MR_EX(phl_info);
|
|
|
|
return is_ch_grouped;
|
|
}
|
|
|
|
|
|
/*
|
|
* Add new operating chdef to MR.
|
|
* @new_chan: Input: new chdef; Output: the final operating ch ctx.
|
|
* ex: In the scc case, it will be the group chdef.
|
|
*/
|
|
bool rtw_phl_chanctx_add(void *phl,
|
|
struct rtw_wifi_role_t *wifi_role,
|
|
struct rtw_wifi_role_link_t *rlink,
|
|
struct rtw_chan_def *new_chdef,
|
|
struct rtw_mr_chctx_info *mr_cc_info)
|
|
{
|
|
struct phl_info_t *phl_info = (struct phl_info_t *)phl;
|
|
struct rtw_phl_com_t *phl_com = phl_info->phl_com;
|
|
struct mr_ctl_t *mr_ctl = phlcom_to_mr_ctrl(phl_com);
|
|
u8 band_idx = rlink->hw_band;
|
|
bool is_ch_grouped = false;
|
|
|
|
if(new_chdef == NULL)
|
|
goto _exit;
|
|
|
|
if (new_chdef->chan == 0) {
|
|
PHL_ERR("%s req chan = 0 \n", __func__);
|
|
goto _exit;
|
|
}
|
|
|
|
/*status check*/
|
|
if (mr_ctl->is_db == false) {
|
|
if (band_idx == 1) {
|
|
PHL_ERR("wrole:%d in band_idx:%d\n", wifi_role->id, band_idx);
|
|
goto _exit;
|
|
}
|
|
}
|
|
|
|
is_ch_grouped = phl_chanctx_add(phl_info, wifi_role, rlink, new_chdef, mr_cc_info);
|
|
|
|
_exit:
|
|
PHL_DUMP_MR_EX(phl_info);
|
|
return is_ch_grouped;
|
|
}
|
|
|
|
enum rtw_phl_status
|
|
rtw_phl_chanctx_del_no_self(void *phl,
|
|
struct rtw_wifi_role_t *wifi_role,
|
|
struct rtw_wifi_role_link_t *rlink)
|
|
{
|
|
enum rtw_phl_status phl_sts = RTW_PHL_STATUS_FAILURE;
|
|
struct phl_info_t *phl_info = (struct phl_info_t *)phl;
|
|
struct rtw_phl_com_t *phl_com = phl_info->phl_com;
|
|
void *drv = phl_to_drvpriv(phl_info);
|
|
struct mr_ctl_t *mr_ctl = phlcom_to_mr_ctrl(phl_com);
|
|
struct hw_band_ctl_t *band_ctrl = &(mr_ctl->band_ctrl[rlink->hw_band]);
|
|
struct rtw_chan_ctx *chanctx = NULL;
|
|
int chctx_num = 0;
|
|
|
|
chctx_num = phl_mr_get_chanctx_num(phl_info, band_ctrl);
|
|
if (chctx_num > 2) {
|
|
PHL_ERR("%s ERR - chanctx_num(%d) > 2\n", __func__, chctx_num);
|
|
_os_warn_on(1);
|
|
goto _exit;
|
|
}
|
|
|
|
if (chctx_num == 0) {
|
|
phl_sts = RTW_PHL_STATUS_SUCCESS;
|
|
PHL_INFO("%s - chctx_num = 0\n", __func__);
|
|
goto _exit;
|
|
}
|
|
else if (chctx_num == 1) { /*SCC*/
|
|
_os_spinlock(drv, &band_ctrl->chan_ctx_queue.lock, _bh, NULL);
|
|
if (!list_empty(&band_ctrl->chan_ctx_queue.queue)) {
|
|
chanctx = list_first_entry(&band_ctrl->chan_ctx_queue.queue,
|
|
struct rtw_chan_ctx, list);
|
|
phl_sts = _phl_chanctx_del(phl_info, band_ctrl, chanctx);
|
|
if (phl_sts != RTW_PHL_STATUS_SUCCESS) {
|
|
PHL_ERR("%s _phl_chanctx_del failed\n", __func__);
|
|
_os_warn_on(1);
|
|
}
|
|
}
|
|
_os_spinunlock(drv, &band_ctrl->chan_ctx_queue.lock, _bh, NULL);
|
|
_os_kmem_free(drv, chanctx, sizeof(struct rtw_chan_ctx));
|
|
}
|
|
else if (chctx_num == 2) { /*MCC*/
|
|
}
|
|
|
|
_exit:
|
|
PHL_DUMP_MR_EX(phl_info);
|
|
return phl_sts;
|
|
}
|
|
|
|
int rtw_phl_chanctx_del(void *phl,
|
|
struct rtw_wifi_role_t *wifi_role,
|
|
struct rtw_wifi_role_link_t *rlink,
|
|
struct rtw_chan_def *chan_def)
|
|
{
|
|
enum rtw_phl_status phl_sts = RTW_PHL_STATUS_FAILURE;
|
|
struct phl_info_t *phl_info = (struct phl_info_t *)phl;
|
|
struct rtw_phl_com_t *phl_com = phl_info->phl_com;
|
|
void *drv = phl_to_drvpriv(phl_info);
|
|
struct mr_ctl_t *mr_ctl = phlcom_to_mr_ctrl(phl_com);
|
|
u8 band_idx = 0;
|
|
struct hw_band_ctl_t *band_ctrl = NULL;
|
|
struct phl_queue *chan_ctx_queue = NULL;
|
|
struct rtw_chan_ctx *target_chanctx = NULL;
|
|
struct rtw_chan_ctx *chanctx = NULL;
|
|
int chctx_num = 0;
|
|
u8 chctx_role_num = 0;
|
|
u8 band_role_num = 0;
|
|
|
|
if (wifi_role == NULL) {
|
|
PHL_ERR("%s wifi_role == NULL!!\n", __func__);
|
|
/*_os_warn_on(1);*/
|
|
goto _exit;
|
|
}
|
|
|
|
if (rlink == NULL) {
|
|
PHL_ERR("%s role link == NULL!!\n", __func__);
|
|
/*_os_warn_on(1);*/
|
|
goto _exit;
|
|
}
|
|
|
|
band_idx = rlink->hw_band;
|
|
band_ctrl = &(mr_ctl->band_ctrl[band_idx]);
|
|
chan_ctx_queue = &band_ctrl->chan_ctx_queue;
|
|
target_chanctx = rlink->chanctx;
|
|
if (target_chanctx == NULL) {
|
|
PHL_ERR("%s target chanctx == NULL\n", __func__);
|
|
/*_os_warn_on(1);*/
|
|
goto _exit;
|
|
}
|
|
|
|
/*init chan_def*/
|
|
if (chan_def)
|
|
chan_def->chan = 0;
|
|
|
|
chctx_num = phl_mr_get_chanctx_num(phl_info, band_ctrl);
|
|
band_role_num = phl_mr_get_role_num(phl_info, band_ctrl);
|
|
|
|
chctx_role_num = phl_chanctx_get_rnum_with_lock(phl_info, chan_ctx_queue, target_chanctx);
|
|
|
|
if (chctx_num == 0 || chctx_role_num == 0) {
|
|
PHL_ERR("%s ERR - chanctx_num(%d), role_num(%d)\n", __func__, chctx_num, chctx_role_num);
|
|
_os_warn_on(1);
|
|
goto _exit;
|
|
}
|
|
if (chctx_num > 2) {
|
|
PHL_ERR("%s ERR - chanctx_num(%d) > 2\n", __func__, chctx_num);
|
|
_os_warn_on(1);
|
|
goto _exit;
|
|
}
|
|
|
|
if (chctx_role_num == 1) { /*single role on this chctx*/
|
|
_os_spinlock(drv, &chan_ctx_queue->lock, _bh, NULL);
|
|
phl_sts = _phl_chanctx_rmap_clr(phl_info, wifi_role, rlink,
|
|
chan_ctx_queue, target_chanctx);
|
|
if (phl_sts != RTW_PHL_STATUS_SUCCESS)
|
|
PHL_ERR("_phl_chanctx_rmap_clr failed\n");
|
|
|
|
phl_sts = _phl_chanctx_del(phl_info, band_ctrl, target_chanctx);
|
|
if (phl_sts != RTW_PHL_STATUS_SUCCESS)
|
|
PHL_ERR("_phl_chanctx_del failed\n");
|
|
_os_spinunlock(drv, &chan_ctx_queue->lock, _bh, NULL);
|
|
|
|
_os_kmem_free(drv, target_chanctx, sizeof(struct rtw_chan_ctx));
|
|
target_chanctx = NULL;
|
|
|
|
} else { /*multi roles on this chctx*/
|
|
phl_sts = _phl_chanctx_rmap_clr_with_lock(phl_info,
|
|
wifi_role,
|
|
rlink,
|
|
chan_ctx_queue,
|
|
target_chanctx);
|
|
if (phl_sts != RTW_PHL_STATUS_SUCCESS)
|
|
PHL_ERR("_phl_chanctx_rmap_clr_with_lock failed\n");
|
|
|
|
phl_sts = phl_mr_chandef_upt(phl_info, band_ctrl, target_chanctx);
|
|
if (phl_sts != RTW_PHL_STATUS_SUCCESS) {
|
|
PHL_ERR("phl_mr_chandef_upt failed\n");
|
|
_os_warn_on(1);
|
|
goto _exit;
|
|
}
|
|
}
|
|
|
|
chctx_num = phl_mr_get_chanctx_num(phl_info, band_ctrl);
|
|
if (chctx_num == 0) {
|
|
band_ctrl->op_mode = MR_OP_NONE;
|
|
}
|
|
else if (chctx_num == 1) {
|
|
_os_spinlock(drv, &chan_ctx_queue->lock, _bh, NULL);
|
|
chanctx = list_first_entry(&chan_ctx_queue->queue,
|
|
struct rtw_chan_ctx, list);
|
|
chctx_role_num = phl_chanctx_get_rnum(phl_info, chan_ctx_queue, chanctx);
|
|
if (chan_def)
|
|
_os_mem_cpy(drv, chan_def, &chanctx->chan_def, sizeof(struct rtw_chan_def));
|
|
_os_spinunlock(drv, &chan_ctx_queue->lock, _bh, NULL);
|
|
|
|
#ifdef DBG_PHL_MR
|
|
if (chctx_role_num == 0) {
|
|
PHL_ERR("chctx_num=1, chctx_role_num=0\n");
|
|
_os_warn_on(1);
|
|
}
|
|
#endif
|
|
band_ctrl->op_mode = (chctx_role_num == 1) ? MR_OP_SWR : MR_OP_SCC;
|
|
} else if (chctx_num == 2) {
|
|
if (chan_def && target_chanctx)
|
|
_os_mem_cpy(drv, chan_def, &target_chanctx->chan_def, sizeof(struct rtw_chan_def));
|
|
band_ctrl->op_mode = MR_OP_MCC;
|
|
}
|
|
|
|
phl_sts = RTW_PHL_STATUS_SUCCESS;
|
|
PHL_INFO("%s - Bidx(%d) - Total role_num:%d, chctx_num:%d, target-chctx rnum:%d, op_mode:%d\n",
|
|
__func__, band_ctrl->id, band_role_num, chctx_num, chctx_role_num, band_ctrl->op_mode);
|
|
|
|
_exit:
|
|
PHL_DUMP_MR_EX(phl_info);
|
|
return chctx_num;
|
|
}
|
|
|
|
#ifdef CONFIG_DBCC_SUPPORT
|
|
enum rtw_phl_status
|
|
phl_chanctx_switch(struct phl_info_t *phl_info,
|
|
struct hw_band_ctl_t *dest, struct hw_band_ctl_t *src)
|
|
{
|
|
struct rtw_chan_ctx *chanctx = NULL;
|
|
struct phl_queue *chan_ctx_queue;
|
|
enum rtw_phl_status psts = RTW_PHL_STATUS_FAILURE;
|
|
void *drv = phl_to_drvpriv(phl_info);
|
|
|
|
PHL_INFO("%s src band_idx:%d chctx_num:%d - desc band_idx:%d chctx_num:%d\n",
|
|
__func__,
|
|
src->id, phl_mr_get_chanctx_num(phl_info, src),
|
|
dest->id, phl_mr_get_chanctx_num(phl_info, dest));
|
|
|
|
chan_ctx_queue = &src->chan_ctx_queue;
|
|
|
|
do {
|
|
_os_spinlock(drv, &src->chan_ctx_queue.lock, _bh, NULL);
|
|
if (list_empty(&chan_ctx_queue->queue)) {
|
|
chanctx = NULL;
|
|
} else {
|
|
chanctx = list_first_entry(&chan_ctx_queue->queue,
|
|
struct rtw_chan_ctx, list);
|
|
list_del(&chanctx->list);
|
|
chan_ctx_queue->cnt--;
|
|
psts = _phl_chanctx_add_with_lock(phl_info, dest, chanctx);
|
|
if (psts != RTW_PHL_STATUS_SUCCESS) {
|
|
PHL_ERR("%s chanctx add failed\n", __func__);
|
|
_os_warn_on(1);
|
|
}
|
|
}
|
|
_os_spinunlock(drv, &src->chan_ctx_queue.lock, _bh, NULL);
|
|
} while (chanctx != NULL);
|
|
return RTW_PHL_STATUS_SUCCESS;
|
|
}
|
|
#endif
|
|
|
|
#ifdef PHL_MR_PROC_CMD
|
|
#ifdef CONFIG_DBCC_SUPPORT
|
|
bool phl_chanctx_switch_test(void *phl, u8 test_mode)
|
|
{
|
|
struct phl_info_t *phl_info = (struct phl_info_t *)phl;
|
|
struct rtw_phl_com_t *phl_com = phl_info->phl_com;
|
|
struct mr_ctl_t *mr_ctl = phlcom_to_mr_ctrl(phl_com);
|
|
struct hw_band_ctl_t *band0_ctrl = &(mr_ctl->band_ctrl[HW_BAND_0]);
|
|
struct hw_band_ctl_t *band1_ctrl = &(mr_ctl->band_ctrl[HW_BAND_1]);
|
|
int b0_chctx_num = 0;
|
|
int b1_chctx_num = 0;
|
|
bool rst = true;
|
|
|
|
b0_chctx_num = phl_mr_get_chanctx_num(phl_info, band0_ctrl);
|
|
b1_chctx_num = phl_mr_get_chanctx_num(phl_info, band1_ctrl);
|
|
PHL_INFO("%s Band_0 has chctx_num(%d)\n", __func__, b0_chctx_num);
|
|
PHL_INFO("%s Band_1 has chctx_num(%d)\n", __func__, b1_chctx_num);
|
|
if (test_mode == 3)
|
|
phl_chanctx_switch(phl_info, band0_ctrl, band1_ctrl);
|
|
else if (test_mode == 4)
|
|
phl_chanctx_switch(phl_info, band1_ctrl, band0_ctrl);
|
|
|
|
PHL_DUMP_MR_EX(phl_info);
|
|
return rst;
|
|
}
|
|
#endif /* CONFIG_DBCC_SUPPORT */
|
|
bool rtw_phl_chanctx_test(void *phl,
|
|
struct rtw_wifi_role_t *wifi_role,
|
|
struct rtw_wifi_role_link_t *rlink,
|
|
u8 test_mode,/*0-chk, 1-add, 2-del*/
|
|
struct rtw_chan_def *new_chdef,
|
|
struct rtw_mr_chctx_info *mr_cc_info)
|
|
{
|
|
bool rst = true;
|
|
int chanctx_num = 0;
|
|
struct rtw_chan_def chan_def = {0};
|
|
|
|
if (test_mode == 0){
|
|
rst = rtw_phl_chanctx_chk(phl, wifi_role, rlink, new_chdef, mr_cc_info);
|
|
}
|
|
else if (test_mode == 1) {
|
|
rst = rtw_phl_chanctx_add(phl, wifi_role, rlink, new_chdef, mr_cc_info);
|
|
}
|
|
else if (test_mode == 2){
|
|
chanctx_num = rtw_phl_chanctx_del(phl, wifi_role, rlink, &chan_def);
|
|
PHL_ERR("%s chctx_num = %d\n", __func__, chanctx_num);
|
|
PHL_DUMP_CHAN_DEF(&chan_def);
|
|
}
|
|
|
|
#ifdef CONFIG_DBCC_SUPPORT
|
|
else if (test_mode == 3 || test_mode == 4) {
|
|
rst = phl_chanctx_switch_test(phl, test_mode);
|
|
}
|
|
#endif
|
|
return rst;
|
|
}
|
|
#endif
|
|
|
|
u8 rtw_phl_get_center_ch(struct rtw_chan_def *chan_def)
|
|
{
|
|
u8 ch = chan_def->chan;
|
|
u8 i, start, end, cent_ch;
|
|
|
|
if (chan_def->bw == CHANNEL_WIDTH_160) {
|
|
if (chan_def->band == BAND_ON_6G) {
|
|
start = 1;
|
|
end = 29;
|
|
cent_ch = 15;
|
|
|
|
for (i = 0; i < 8; i++){
|
|
if (ch >= (start + (i * 32))
|
|
&& ch <= (end + (i * 32))) {
|
|
ch = (cent_ch + (i * 32));
|
|
}
|
|
}
|
|
} else {
|
|
if (ch % 4 == 0) {
|
|
if (ch >= 36 && ch <= 64)
|
|
ch = 50;
|
|
else if (ch >= 100 && ch <= 128)
|
|
ch = 114;
|
|
} else if (ch % 4 == 1) {
|
|
if (ch >= 149 && ch <= 177)
|
|
ch = 163;
|
|
}
|
|
}
|
|
} else if (chan_def->bw == CHANNEL_WIDTH_80) {
|
|
if (chan_def->band == BAND_ON_6G) {
|
|
start = 1;
|
|
end = 13;
|
|
cent_ch = 7;
|
|
|
|
for (i = 0; i < 16; i++){
|
|
if (ch >= (start + (i * 16))
|
|
&& ch <= (end + (i * 16))) {
|
|
ch = (cent_ch + (i * 16));
|
|
}
|
|
}
|
|
} else {
|
|
if (ch <= 14)
|
|
ch = 7; /* special case for 2.4G */
|
|
else if (ch % 4 == 0) {
|
|
if (ch >= 36 && ch <= 48)
|
|
ch = 42;
|
|
else if (ch >= 52 && ch <= 64)
|
|
ch = 58;
|
|
else if (ch >= 100 && ch <= 112)
|
|
ch = 106;
|
|
else if (ch >= 116 && ch <= 128)
|
|
ch = 122;
|
|
else if (ch >= 132 && ch <= 144)
|
|
ch = 138;
|
|
} else if (ch % 4 == 1) {
|
|
if (ch >= 149 && ch <= 161)
|
|
ch = 155;
|
|
else if (ch >= 165 && ch <= 177)
|
|
ch = 171;
|
|
}
|
|
}
|
|
} else if (chan_def->bw == CHANNEL_WIDTH_40) {
|
|
if (chan_def->offset == CHAN_OFFSET_UPPER)
|
|
ch += 2;
|
|
else if (chan_def->offset == CHAN_OFFSET_LOWER)
|
|
ch -= 2;
|
|
|
|
} else if (chan_def->bw == CHANNEL_WIDTH_20
|
|
|| chan_def->bw == CHANNEL_WIDTH_10
|
|
|| chan_def->bw == CHANNEL_WIDTH_5) {
|
|
; /* the same as ch */
|
|
}
|
|
else {
|
|
PHL_ERR("%s failed\n", __func__);
|
|
}
|
|
return ch;
|
|
}
|
|
|
|
int rtw_phl_bch2freq(enum band_type band, int ch)
|
|
{
|
|
if (band == BAND_ON_6G) {
|
|
if (ch >= 1 && ch <= 253)
|
|
return 5950 + ch * 5;
|
|
} else if (band == BAND_ON_24G || band == BAND_ON_5G) {
|
|
if (ch >= 1 && ch <= 14) {
|
|
if (ch == 14)
|
|
return 2484;
|
|
else if (ch < 14)
|
|
return 2407 + ch * 5;
|
|
} else if (ch >= 36 && ch <= 177)
|
|
return 5000 + ch * 5;
|
|
}
|
|
|
|
return 0; /* not supported */
|
|
}
|
|
|
|
bool rtw_phl_bchbw_to_freq_range(enum band_type band, u8 ch
|
|
, enum channel_width bw, enum chan_offset offset, u32 *hi, u32 *lo)
|
|
{
|
|
struct rtw_chan_def chan_def;
|
|
u8 c_ch;
|
|
u32 freq;
|
|
u32 hi_ret = 0, lo_ret = 0;
|
|
bool valid = false;
|
|
|
|
if (hi)
|
|
*hi = 0;
|
|
if (lo)
|
|
*lo = 0;
|
|
|
|
chan_def.band = band;
|
|
chan_def.chan = ch;
|
|
chan_def.bw = bw;
|
|
chan_def.offset = offset;
|
|
c_ch = rtw_phl_get_center_ch(&chan_def);
|
|
freq = rtw_phl_bch2freq(band, c_ch);
|
|
|
|
if (!freq) {
|
|
_os_warn_on(1);
|
|
goto exit;
|
|
}
|
|
|
|
if (bw == CHANNEL_WIDTH_160) {
|
|
hi_ret = freq + 80;
|
|
lo_ret = freq - 80;
|
|
} else if (bw == CHANNEL_WIDTH_80) {
|
|
hi_ret = freq + 40;
|
|
lo_ret = freq - 40;
|
|
} else if (bw == CHANNEL_WIDTH_40) {
|
|
hi_ret = freq + 20;
|
|
lo_ret = freq - 20;
|
|
} else if (bw == CHANNEL_WIDTH_20) {
|
|
hi_ret = freq + 10;
|
|
lo_ret = freq - 10;
|
|
} else
|
|
_os_warn_on(1);
|
|
|
|
if (hi)
|
|
*hi = hi_ret;
|
|
if (lo)
|
|
*lo = lo_ret;
|
|
|
|
valid = true;
|
|
|
|
exit:
|
|
return valid;
|
|
}
|
|
|
|
/*
|
|
* Refer to 80211 spec Annex E Table E-4 Global operating classes
|
|
* Handle 2.4G/5G/6G Bandwidth 20/40/80/160
|
|
* 80+ not support.
|
|
*/
|
|
u8
|
|
rtw_phl_get_operating_class(
|
|
struct rtw_chan_def chan_def
|
|
)
|
|
{
|
|
u8 operating_class = 0;
|
|
|
|
if(chan_def.bw == CHANNEL_WIDTH_20){
|
|
if(chan_def.band == BAND_ON_6G)
|
|
operating_class = 131;
|
|
else if(chan_def.chan <= 13)
|
|
operating_class = 81;
|
|
else if(chan_def.chan ==14)
|
|
operating_class = 82;
|
|
else if(chan_def.chan >= 36 && chan_def.chan <= 48)
|
|
operating_class = 115;
|
|
else if(chan_def.chan >= 52 && chan_def.chan <= 64)
|
|
operating_class = 118;
|
|
else if(chan_def.chan >= 100 && chan_def.chan <= 144)
|
|
operating_class = 121;
|
|
else if(chan_def.chan >= 149 && chan_def.chan <= 177)
|
|
operating_class = 125;
|
|
else
|
|
PHL_WARN("%s: Undefined channel (%d)\n", __FUNCTION__, chan_def.chan);
|
|
} else if(chan_def.bw == CHANNEL_WIDTH_40) {
|
|
if(chan_def.band == BAND_ON_6G)
|
|
operating_class = 132;
|
|
else if(chan_def.offset == CHAN_OFFSET_UPPER) {
|
|
if(chan_def.chan >= 1 && chan_def.chan <= 9)
|
|
operating_class = 83;
|
|
else if(chan_def.chan == 36 || chan_def.chan == 44)
|
|
operating_class = 116;
|
|
else if(chan_def.chan == 52 || chan_def.chan == 60)
|
|
operating_class = 119;
|
|
else if(chan_def.chan == 100 || chan_def.chan == 108 ||
|
|
chan_def.chan == 116 || chan_def.chan == 124 ||
|
|
chan_def.chan == 132 || chan_def.chan == 140)
|
|
operating_class = 122;
|
|
else if(chan_def.chan == 149 || chan_def.chan == 157 ||
|
|
chan_def.chan == 165 || chan_def.chan == 173)
|
|
operating_class = 126;
|
|
else
|
|
PHL_WARN("%s: Undefined channel (%d)\n", __FUNCTION__, chan_def.chan);
|
|
} else if(chan_def.offset == CHAN_OFFSET_LOWER) {
|
|
if(chan_def.chan >= 5 && chan_def.chan <= 13)
|
|
operating_class = 84;
|
|
else if(chan_def.chan == 40 || chan_def.chan == 48)
|
|
operating_class = 117;
|
|
else if(chan_def.chan == 56 || chan_def.chan == 64)
|
|
operating_class = 120;
|
|
else if(chan_def.chan == 104 || chan_def.chan == 112 ||
|
|
chan_def.chan == 120 || chan_def.chan == 128 ||
|
|
chan_def.chan == 136 || chan_def.chan == 144)
|
|
operating_class = 123;
|
|
else if(chan_def.chan == 153 || chan_def.chan == 161 ||
|
|
chan_def.chan == 169 || chan_def.chan == 177)
|
|
operating_class = 127;
|
|
else
|
|
PHL_WARN("%s: Undefined channel (%d)\n", __FUNCTION__, chan_def.chan);
|
|
} else {
|
|
PHL_WARN("%s: Invalid offset(%d)\n",
|
|
__FUNCTION__, chan_def.offset);
|
|
}
|
|
} else if(chan_def.bw == CHANNEL_WIDTH_80) {
|
|
if(chan_def.band == BAND_ON_5G)
|
|
operating_class = 128;
|
|
else if(chan_def.band == BAND_ON_6G)
|
|
operating_class = 133;
|
|
else
|
|
PHL_WARN("%s: Undefined channel (%d)\n", __FUNCTION__, chan_def.center_ch);
|
|
} else if(chan_def.bw == CHANNEL_WIDTH_160) {
|
|
if(chan_def.band == BAND_ON_5G)
|
|
operating_class = 129;
|
|
else if(chan_def.band == BAND_ON_6G)
|
|
operating_class = 134;
|
|
else
|
|
PHL_WARN("%s: Undefined channel (%d)\n", __FUNCTION__, chan_def.center_ch);
|
|
} else {
|
|
PHL_WARN("%s: Not handle bandwidth (%d)\n", __FUNCTION__, chan_def.bw);
|
|
}
|
|
|
|
return operating_class;
|
|
}
|
|
|
|
bool
|
|
rtw_phl_get_chandef_from_operating_class(
|
|
u8 channel,
|
|
u8 operating_class,
|
|
struct rtw_chan_def *chan_def
|
|
)
|
|
{
|
|
bool ret = true;
|
|
|
|
if(operating_class == 81 || operating_class == 82) {
|
|
/* 2.4G 20MHz */
|
|
chan_def->chan = channel;
|
|
chan_def->bw = CHANNEL_WIDTH_20;
|
|
chan_def->offset = CHAN_OFFSET_NO_EXT;
|
|
chan_def->band = BAND_ON_24G;
|
|
chan_def->center_ch = rtw_phl_get_center_ch(chan_def);
|
|
} else if(operating_class == 115 || operating_class == 118 ||
|
|
operating_class == 121 || operating_class == 124 ||
|
|
operating_class == 125) {
|
|
/* 5G 20MHz */
|
|
chan_def->chan = channel;
|
|
chan_def->bw = CHANNEL_WIDTH_20;
|
|
chan_def->offset = CHAN_OFFSET_NO_EXT;
|
|
chan_def->band = BAND_ON_5G;
|
|
chan_def->center_ch = rtw_phl_get_center_ch(chan_def);
|
|
} else if(operating_class == 83) {
|
|
/* 2.4G 40MHz Upper */
|
|
chan_def->chan = channel;
|
|
chan_def->bw = CHANNEL_WIDTH_40;
|
|
chan_def->offset = CHAN_OFFSET_UPPER;
|
|
chan_def->band = BAND_ON_24G;
|
|
chan_def->center_ch = rtw_phl_get_center_ch(chan_def);
|
|
} else if(operating_class == 116 || operating_class == 119 ||
|
|
operating_class == 122 || operating_class == 126) {
|
|
/* 5G 40MHz Upper */
|
|
chan_def->chan = channel;
|
|
chan_def->bw = CHANNEL_WIDTH_40;
|
|
chan_def->offset = CHAN_OFFSET_UPPER;
|
|
chan_def->band = BAND_ON_5G;
|
|
chan_def->center_ch = rtw_phl_get_center_ch(chan_def);
|
|
} else if(operating_class == 84) {
|
|
/* 2.4G 40MHz Lower */
|
|
chan_def->chan = channel;
|
|
chan_def->bw = CHANNEL_WIDTH_40;
|
|
chan_def->offset = CHAN_OFFSET_LOWER;
|
|
chan_def->band = BAND_ON_24G;
|
|
chan_def->center_ch = rtw_phl_get_center_ch(chan_def);
|
|
} else if(operating_class == 117 || operating_class == 120 ||
|
|
operating_class == 123 || operating_class == 127) {
|
|
/* 5G 40MHz Lower */
|
|
chan_def->chan = channel;
|
|
chan_def->bw = CHANNEL_WIDTH_40;
|
|
chan_def->offset = CHAN_OFFSET_LOWER;
|
|
chan_def->band = BAND_ON_5G;
|
|
chan_def->center_ch = rtw_phl_get_center_ch(chan_def);
|
|
} else if(operating_class == 128){
|
|
/* 5G 80MHz */
|
|
chan_def->chan = channel;
|
|
chan_def->bw = CHANNEL_WIDTH_80;
|
|
chan_def->offset = CHAN_OFFSET_NO_DEF;
|
|
chan_def->band = BAND_ON_5G;
|
|
chan_def->center_ch = rtw_phl_get_center_ch(chan_def);
|
|
} else if(operating_class == 129){
|
|
/* 5G 160MHz */
|
|
chan_def->chan = channel;
|
|
chan_def->bw = CHANNEL_WIDTH_160;
|
|
chan_def->offset = CHAN_OFFSET_NO_DEF;
|
|
chan_def->band = BAND_ON_5G;
|
|
chan_def->center_ch = rtw_phl_get_center_ch(chan_def);
|
|
} else if(operating_class == 131) {
|
|
/* 6G 20MHz */
|
|
chan_def->chan = channel;
|
|
chan_def->bw = CHANNEL_WIDTH_20;
|
|
chan_def->offset = CHAN_OFFSET_NO_DEF;
|
|
chan_def->center_ch = channel;
|
|
chan_def->band = BAND_ON_6G;
|
|
} else if(operating_class == 132) {
|
|
/* 6G 40MHz */
|
|
chan_def->chan = channel;
|
|
chan_def->bw = CHANNEL_WIDTH_40;
|
|
chan_def->offset = CHAN_OFFSET_NO_DEF;
|
|
chan_def->center_ch = channel;
|
|
chan_def->band = BAND_ON_6G;
|
|
} else if(operating_class == 133 || operating_class == 135) {
|
|
/* 6G 80MHz */
|
|
chan_def->chan = channel;
|
|
chan_def->bw = CHANNEL_WIDTH_80;
|
|
chan_def->offset = CHAN_OFFSET_NO_DEF;
|
|
chan_def->center_ch = channel;
|
|
chan_def->band = BAND_ON_6G;
|
|
} else if(operating_class == 134) {
|
|
/* 6G 160MHz */
|
|
chan_def->chan = channel;
|
|
chan_def->bw = CHANNEL_WIDTH_160;
|
|
chan_def->offset = CHAN_OFFSET_NO_DEF;
|
|
chan_def->center_ch = channel;
|
|
chan_def->band = BAND_ON_6G;
|
|
} else {
|
|
PHL_ERR("%s: Unknown operating class (%d)\n", __FUNCTION__, operating_class);
|
|
ret = false;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
#ifdef CONFIG_PHL_CHSWOFLD
|
|
void rtw_phl_set_chsw_ofld_info(struct rtw_phl_com_t *phl_com,
|
|
bool chsw_ofld_en, bool rf_reload, bool skip_normal_watchdog)
|
|
{
|
|
struct chsw_ofld_info_t *chsw_ofld_info = &phl_com->chsw_ofld_info;
|
|
|
|
if (chsw_ofld_en) {
|
|
if (phl_com->dev_cap.chsw_ofld) {
|
|
chsw_ofld_info->chsw_ofld_en = true;
|
|
chsw_ofld_info->rf_reload = rf_reload;
|
|
chsw_ofld_info->skip_normal_watchdog = skip_normal_watchdog;
|
|
return;
|
|
} else {
|
|
PHL_WARN("%s: channel switch offload is not supported.\n", __FUNCTION__);
|
|
}
|
|
}
|
|
chsw_ofld_info->chsw_ofld_en = false;
|
|
chsw_ofld_info->rf_reload = false;
|
|
chsw_ofld_info->skip_normal_watchdog = false;
|
|
}
|
|
#endif
|