/******************************************************************************
 *
 * Copyright(c) 2019 Realtek Corporation. All rights reserved.
 *
 * 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.
 *
 ******************************************************************************/

#include "dbcc.h"
#include "mac_priv.h"
#include "cpuio.h"

u32 dbcc_info_init(struct mac_ax_adapter *adapter)
{
	u32 ret = MACSUCCESS;

	adapter->dbcc_info =
		(struct mac_ax_dbcc_info *)PLTFM_MALLOC(DBCC_INFO_SIZE);
	if (!adapter->dbcc_info) {
		PLTFM_MSG_ERR("dbcc info malloc fail\n");
		return MACNPTR;
	}

	adapter->dbcc_info->dbcc_wmm_list = (u8 *)PLTFM_MALLOC(DBCC_WMM_LIST_SIZE);
	if (!adapter->dbcc_info->dbcc_wmm_list) {
		PLTFM_MSG_ERR("dbcc wmm list malloc fail\n");
		return MACNPTR;
	}

	ret = rst_dbcc_info(adapter);

	return ret;
}

u32 dbcc_info_exit(struct mac_ax_adapter *adapter)
{
	PLTFM_FREE(adapter->dbcc_info->dbcc_wmm_list, DBCC_WMM_LIST_SIZE);
	PLTFM_FREE(adapter->dbcc_info, DBCC_INFO_SIZE);

	return MACSUCCESS;
}

u32 rst_dbcc_info(struct mac_ax_adapter *adapter)
{
	struct mac_ax_dbcc_info *dbcc_info = adapter->dbcc_info;
	u32 i;

	if (!dbcc_info) {
		PLTFM_MSG_ERR("no dbcc info when rst dbcc info\n");
		return MACNPTR;
	}

	PLTFM_MEMSET(dbcc_info->dbcc_wmm_list, MAC_AX_DBCC_WMM_INVALID,
		     DBCC_WMM_LIST_SIZE);
	for (i = 0; i < MAC_AX_DBCC_WMM_MAX; i++) {
		dbcc_info->dbcc_role_cnt[i] = 0;
		dbcc_info->dbcc_wmm_type[i] = MAC_AX_NET_TYPE_INVLAID;
		dbcc_info->dbcc_wmm_bp[i] = DBCC_BP_INVALID;
	}

	for (i = MAC_AX_BAND_0; i < MAC_AX_BAND_NUM; i++) {
		dbcc_info->bkp_flag[i] = 0;
		PLTFM_MEMSET(&dbcc_info->ppdu_rpt_bkp, 0,
			     sizeof(struct mac_ax_phy_rpt_cfg));
		PLTFM_MEMSET(&dbcc_info->chinfo_bkp, 0,
			     sizeof(struct mac_ax_phy_rpt_cfg));
	}

	dbcc_info->notify_fw_flag = 0;

	return MACSUCCESS;
}

static u32 get_valid_dbcc_wmm(struct mac_ax_adapter *adapter, u8 *out_dbcc_wmm)
{
	struct mac_ax_dbcc_info *dbcc_info = adapter->dbcc_info;
	u8 wmmidx;

	if (!dbcc_info) {
		PLTFM_MSG_ERR("no dbcc info when get valid dbcc wmm\n");
		*out_dbcc_wmm = MAC_AX_DBCC_WMM_INVALID;
		return MACNPTR;
	}

	for (wmmidx = MAC_AX_DBCC_WMM0; wmmidx < MAC_AX_DBCC_WMM_MAX; wmmidx++) {
		if (!dbcc_info->dbcc_role_cnt[wmmidx])
			break;
	}

	if (wmmidx == MAC_AX_DBCC_WMM_MAX) {
		PLTFM_MSG_ERR("no valid dbcc wmm\n");
		*out_dbcc_wmm = MAC_AX_DBCC_WMM_INVALID;
		return MACNOITEM;
	}

	*out_dbcc_wmm = wmmidx;
	return MACSUCCESS;
}

u32 dbcc_wmm_add_macid(struct mac_ax_adapter *adapter,
		       struct mac_ax_role_info *info)
{
	struct mac_ax_dbcc_info *dbcc_info = adapter->dbcc_info;
	enum mac_ax_ss_wmm_tbl dst_link;
	u8 *cur_dbcc_wmm_type;
	u32 ret;
	u8 chk_emp, tar_dbcc_wmm, wmmidx, curr_bp;

	if (!dbcc_info) {
		PLTFM_MSG_ERR("no dbcc info when add macid\n");
		return MACNPTR;
	}

	curr_bp = (info->port & DBCC_PORT_MASK) |
		  (info->band == MAC_AX_BAND_1 ? DBCC_BAND_BIT : 0);
	tar_dbcc_wmm = MAC_AX_DBCC_WMM_INVALID;

	if (info->net_type == MAC_AX_NET_TYPE_AP) {
		for (wmmidx = MAC_AX_DBCC_WMM0; wmmidx < MAC_AX_DBCC_WMM_MAX; wmmidx++) {
			if (dbcc_info->dbcc_wmm_bp[wmmidx] == curr_bp &&
			    dbcc_info->dbcc_wmm_type[wmmidx] == info->net_type)
				break;
		}

		if (wmmidx < MAC_AX_DBCC_WMM_MAX)
			tar_dbcc_wmm = wmmidx;
	}

	if (tar_dbcc_wmm == MAC_AX_DBCC_WMM_INVALID) {
		ret = get_valid_dbcc_wmm(adapter, &tar_dbcc_wmm);
		if (ret != MACSUCCESS) {
			PLTFM_MSG_ERR("get_valid_dbcc_wmm %d\n", ret);
			return ret;
		}
	}

	cur_dbcc_wmm_type = &dbcc_info->dbcc_wmm_type[tar_dbcc_wmm];
	if ((info->net_type != MAC_AX_NET_TYPE_AP &&
	     *cur_dbcc_wmm_type != MAC_AX_NET_TYPE_INVLAID) ||
	    (info->net_type == MAC_AX_NET_TYPE_AP &&
	     *cur_dbcc_wmm_type != MAC_AX_NET_TYPE_INVLAID &&
	     *cur_dbcc_wmm_type != MAC_AX_NET_TYPE_AP)) {
		PLTFM_MSG_ERR("dbcc wmm%d is occupied by type%d\n",
			      tar_dbcc_wmm, *cur_dbcc_wmm_type);
		return MACPROCERR;
	}

	if (info->macid >= DBCC_WMM_LIST_SIZE) {
		PLTFM_MSG_ERR("macid%d not support in dbcc wmm add macid\n",
			      info->macid);
		return MACFUNCINPUT;
	}

	if (info->band == MAC_AX_BAND_0)
		dst_link = info->wmm ?
			   MAC_AX_SS_WMM_TBL_C0_WMM1 : MAC_AX_SS_WMM_TBL_C0_WMM0;
	else
		dst_link = info->wmm ?
			   MAC_AX_SS_WMM_TBL_C1_WMM1 : MAC_AX_SS_WMM_TBL_C1_WMM0;
	chk_emp = (!dbcc_info->dbcc_role_cnt[tar_dbcc_wmm] ||
		   *cur_dbcc_wmm_type != MAC_AX_NET_TYPE_AP) ? 1 : 0;
	ret = mac_ss_wmm_map_upd(adapter, (enum mac_ax_ss_wmm)tar_dbcc_wmm,
				 dst_link, chk_emp);
	if (ret != MACSUCCESS) {
		PLTFM_MSG_ERR("mac_ss_wmm_map_upd %d/%d/%d/%d\n",
			      tar_dbcc_wmm, dst_link, chk_emp, ret);
		return ret;
	}

	*(dbcc_info->dbcc_wmm_list + info->macid) = tar_dbcc_wmm;
	dbcc_info->dbcc_role_cnt[tar_dbcc_wmm]++;
	*cur_dbcc_wmm_type = info->net_type;
	dbcc_info->dbcc_wmm_bp[tar_dbcc_wmm] = curr_bp;

	return MACSUCCESS;
}

u32 dbcc_wmm_rm_macid(struct mac_ax_adapter *adapter,
		      struct mac_ax_role_info *info)
{
	struct mac_ax_dbcc_info *dbcc_info = adapter->dbcc_info;
	u8 dbcc_wmm;

	if (!dbcc_info) {
		PLTFM_MSG_ERR("no dbcc info when rm macid\n");
		return MACNPTR;
	}

	if (info->macid >= DBCC_WMM_LIST_SIZE) {
		PLTFM_MSG_ERR("macid%d not support in dbcc wmm rm macid\n",
			      info->macid);
		return MACFUNCINPUT;
	}

	dbcc_wmm = *(dbcc_info->dbcc_wmm_list + info->macid);
	if (dbcc_wmm == MAC_AX_DBCC_WMM_INVALID) {
		PLTFM_MSG_ERR("macid%d dbcc wmm invalid in dbcc wmm list\n",
			      info->macid);
		return MACPROCERR;
	}

	if (!dbcc_info->dbcc_role_cnt[dbcc_wmm]) {
		PLTFM_MSG_ERR("dbcc wmm%d rm macid%d underflow\n",
			      dbcc_wmm, info->macid);
		if (dbcc_info->dbcc_wmm_type[dbcc_wmm] !=
		    MAC_AX_NET_TYPE_INVLAID) {
			PLTFM_MSG_ERR("dbcc wmm not invalid when no role\n");
			return MACPROCERR;
		}
		return MACCMP;
	}

	*(dbcc_info->dbcc_wmm_list + info->macid) = MAC_AX_DBCC_WMM_INVALID;
	dbcc_info->dbcc_role_cnt[dbcc_wmm]--;
	if (!dbcc_info->dbcc_role_cnt[dbcc_wmm]) {
		dbcc_info->dbcc_wmm_type[dbcc_wmm] = MAC_AX_NET_TYPE_INVLAID;
		dbcc_info->dbcc_wmm_bp[dbcc_wmm] = DBCC_BP_INVALID;
	}

	return MACSUCCESS;
}

static u32 band1_enable(struct mac_ax_adapter *adapter,
			struct mac_ax_trx_info *info)
{
	struct mac_ax_intf_ops *ops = adapter_to_intf_ops(adapter);
	struct mac_ax_priv_ops *p_ops = adapter_to_priv_ops(adapter);
	u32 ret;

	ret = tx_idle_poll_band(adapter, 0);
	if (ret != MACSUCCESS) {
		PLTFM_MSG_ERR("[ERR]tx idle poll %d\n", ret);
		return ret;
	}

	ret = dle_quota_change(adapter, info->qta_mode);
	if (ret != MACSUCCESS) {
		PLTFM_MSG_ERR("[ERR]DLE quota change %d\n", ret);
		return ret;
	}

	ret = preload_init(adapter, MAC_AX_BAND_1, info->qta_mode);
	if (ret != MACSUCCESS) {
		PLTFM_MSG_ERR("[ERR]preload init B1 %d\n", ret);
		return ret;
	}

	ret = p_ops->cmac_func_en(adapter, MAC_AX_BAND_1, MAC_AX_FUNC_EN);
	if (ret != MACSUCCESS) {
		PLTFM_MSG_ERR("[ERR]CMAC%d func en %d\n", MAC_AX_BAND_1, ret);
		return ret;
	}

	ret = p_ops->cmac_init(adapter, info, MAC_AX_BAND_1);
	if (ret != MACSUCCESS) {
		PLTFM_MSG_ERR("[ERR]CMAC%d init %d\n", MAC_AX_BAND_1, ret);
		return ret;
	}

	MAC_REG_W32(R_AX_SYS_ISO_CTRL_EXTEND,
		    MAC_REG_R32(R_AX_SYS_ISO_CTRL_EXTEND) |
		    B_AX_R_SYM_FEN_WLBBGLB_1 | B_AX_R_SYM_FEN_WLBBFUN_1);

	adapter->sm.bb1_func = MAC_AX_FUNC_ON;

	ret = mac_enable_imr(adapter, MAC_AX_BAND_1, MAC_AX_CMAC_SEL);
	if (ret != MACSUCCESS) {
		PLTFM_MSG_ERR("[ERR] enable CMAC1 IMR %d\n", ret);
		return ret;
	}

	return MACSUCCESS;
}

static u32 band1_disable(struct mac_ax_adapter *adapter,
			 struct mac_ax_trx_info *info)
{
	u32 ret;
	struct mac_ax_intf_ops *ops = adapter_to_intf_ops(adapter);
	struct mac_ax_priv_ops *p_ops = adapter_to_priv_ops(adapter);

	MAC_REG_W32(R_AX_SYS_ISO_CTRL_EXTEND,
		    MAC_REG_R32(R_AX_SYS_ISO_CTRL_EXTEND) &
		    ~B_AX_R_SYM_FEN_WLBBFUN_1);

	ret = p_ops->cmac_func_en(adapter, MAC_AX_BAND_1, MAC_AX_FUNC_DIS);
	if (ret != MACSUCCESS) {
		PLTFM_MSG_ERR("[ERR]CMAC%d func dis %d\n", MAC_AX_BAND_1, ret);
		return ret;
	}

	ret = dle_quota_change(adapter, info->qta_mode);
	if (ret != MACSUCCESS) {
		PLTFM_MSG_ERR("[ERR]DLE quota change %d\n", ret);
		return ret;
	}

	ret = rst_port_info(adapter, MAC_AX_BAND_1);
	if (ret != MACSUCCESS) {
		PLTFM_MSG_ERR("[ERR]Reset band 1 port info %d\n", ret);
		return ret;
	}

	return 0;
}

static u32 dbcc_chk_notify_done(struct mac_ax_adapter *adapter)
{
	struct mac_ax_dbcc_info *dbcc_info = adapter->dbcc_info;
	u32 cnt = DBCC_CHK_NTFY_CNT;

	while (cnt) {
		if (!dbcc_info->notify_fw_flag)
			break;
		PLTFM_SLEEP_US(DBCC_CHK_NTFY_DLY);
		cnt--;
	}

	if (!cnt)
		return MACPOLLTO;

	PLTFM_MSG_ALWAYS("[TRACE]DBCC check notify cnt %d\n", DBCC_CHK_NTFY_CNT - cnt);
	return MACSUCCESS;
}

u32 dbcc_trx_ctrl_bkp(struct mac_ax_adapter *adapter, enum mac_ax_band band)
{
	struct mac_ax_ops *mops = adapter_to_mac_ops(adapter);
	struct mac_ax_dbcc_info *dbcc_info = adapter->dbcc_info;
	struct mac_ax_phy_rpt_cfg *ppdu_rpt_cfg;
	struct mac_ax_phy_rpt_cfg *chinfo_cfg;
	u32 ret;

	if (!dbcc_info) {
		PLTFM_MSG_ERR("no dbcc info when bkp trx\n");
		return MACNPTR;
	}

	if (dbcc_info->bkp_flag[band]) {
		PLTFM_MSG_ERR("band%d trx ctrl already backup\n", band);
		return MACPROCERR;
	}

	ppdu_rpt_cfg = &dbcc_info->ppdu_rpt_bkp[band];
	ppdu_rpt_cfg->type = MAC_AX_PPDU_STATUS;
	ppdu_rpt_cfg->u.ppdu.band = band;
	ret = mops->get_phy_rpt_cfg(adapter, ppdu_rpt_cfg);
	if (ret != MACSUCCESS) {
		PLTFM_MSG_ERR("get ppdu stus rpt cfg %d\n", ret);
		return ret;
	}

	chinfo_cfg = &dbcc_info->chinfo_bkp[band];
	chinfo_cfg->type = MAC_AX_CH_INFO;
	ret = mops->get_phy_rpt_cfg(adapter, chinfo_cfg);
	if (ret != MACSUCCESS) {
		PLTFM_MSG_ERR("get ch info cfg %d\n", ret);
		return ret;
	}

	dbcc_info->bkp_flag[band] = 1;
	return ret;
}

u32 mac_dbcc_trx_ctrl(struct mac_ax_adapter *adapter,
		      enum mac_ax_band band, u8 pause)
{
	struct mac_ax_intf_ops *ops = adapter_to_intf_ops(adapter);
	struct mac_ax_ops *mops = adapter_to_mac_ops(adapter);
	struct mac_ax_dbcc_info *dbcc_info = adapter->dbcc_info;
	struct mac_ax_sch_tx_en_cfg sch_cfg;
	struct mac_ax_phy_rpt_cfg phyrpt_cfg;
	struct mac_ax_phy_rpt_cfg *ppdu_rpt_bkp;
	struct mac_ax_phy_rpt_cfg *chinfo_cfg_kbp;
	u32 ret, reg;
	u16 val16;

	if (!dbcc_info) {
		PLTFM_MSG_ERR("no dbcc info when trx ctrl\n");
		return MACNPTR;
	}

	if (pause) {
		ret = dbcc_trx_ctrl_bkp(adapter, band);
		if (ret != MACSUCCESS) {
			PLTFM_MSG_ERR("B%d dbcc trx bkp %d\n", band, ret);
			return ret;
		}
	} else if (!dbcc_info->bkp_flag[band]) {
		PLTFM_MSG_ERR("B%d dbcc trx is not backup\n", band);
		return MACPROCERR;
	}

	if (!pause && band == MAC_AX_BAND_1 &&
	    check_mac_en(adapter, MAC_AX_BAND_1, MAC_AX_CMAC_SEL) != MACSUCCESS) {
		dbcc_info->bkp_flag[band] = 0;
		return MACSUCCESS;
	}

	ppdu_rpt_bkp = &dbcc_info->ppdu_rpt_bkp[band];
	chinfo_cfg_kbp = &dbcc_info->chinfo_bkp[band];

	sch_cfg.band = (u8)band;
	if (pause)
		PLTFM_MEMSET(&sch_cfg.tx_en, 0, SCH_TX_EN_SIZE);
	else
		PLTFM_MEMSET(&sch_cfg.tx_en, 0xFF, SCH_TX_EN_SIZE);
	PLTFM_MEMSET(&sch_cfg.tx_en_mask, 0xFF, SCH_TX_EN_SIZE);
	ret = mops->set_hw_value(adapter, MAC_AX_HW_SET_SCH_TXEN_CFG,
				 (void *)&sch_cfg);
	if (ret != MACSUCCESS) {
		PLTFM_MSG_ERR("B%d pause%d sch txen cfg %d\n", band, pause, ret);
		return ret;
	}

	reg = band == MAC_AX_BAND_0 ? R_AX_RCR : R_AX_RCR_C1;
	val16 = MAC_REG_R16(reg);
	if (pause)
		MAC_REG_W16(reg, val16 | B_AX_STOP_RX_IN);
	else
		MAC_REG_W16(reg, val16 & ~B_AX_STOP_RX_IN);

	phyrpt_cfg.type = MAC_AX_PPDU_STATUS;
	phyrpt_cfg.en = pause ? 0 : ppdu_rpt_bkp->en;
	phyrpt_cfg.dest = ppdu_rpt_bkp->dest;
	phyrpt_cfg.u.ppdu = ppdu_rpt_bkp->u.ppdu;
	ret = mops->cfg_phy_rpt(adapter, &phyrpt_cfg);
	if (ret != MACSUCCESS) {
		PLTFM_MSG_ERR("B%d pause%d ppdu status cfg %d\n", band, pause, ret);
		return ret;
	}

	phyrpt_cfg.type = MAC_AX_CH_INFO;
	phyrpt_cfg.en = pause ? 0 : chinfo_cfg_kbp->en;
	phyrpt_cfg.dest = chinfo_cfg_kbp->dest;
	phyrpt_cfg.u.chif = chinfo_cfg_kbp->u.chif;
	ret = mops->cfg_phy_rpt(adapter, &phyrpt_cfg);
	if (ret != MACSUCCESS) {
		PLTFM_MSG_ERR("B%d pause%d ch info cfg %d\n", band, pause, ret);
		return ret;
	}

	if (!pause)
		dbcc_info->bkp_flag[band] = 0;

	return ret;
}

u32 mac_notify_fw_dbcc(struct mac_ax_adapter *adapter, u8 en)
{
	u32 ret;
	struct fwcmd_notify_dbcc *dbcc;
	struct h2c_info h2c_info = {0};

	if (adapter->sm.fwdl != MAC_AX_FWDL_INIT_RDY) {
		PLTFM_MSG_WARN("%s fw not ready\n", __func__);
		return MACFWNONRDY;
	}

	h2c_info.agg_en = 0;
	h2c_info.content_len = sizeof(struct fwcmd_notify_dbcc);
	h2c_info.h2c_cat = FWCMD_H2C_CAT_MAC;
	h2c_info.h2c_class = FWCMD_H2C_CL_MEDIA_RPT;
	h2c_info.h2c_func = FWCMD_H2C_FUNC_NOTIFY_DBCC;
	h2c_info.rec_ack = 0;
	h2c_info.done_ack = 1;

	dbcc = (struct fwcmd_notify_dbcc *)PLTFM_MALLOC(h2c_info.content_len);
	if (!dbcc) {
		PLTFM_MSG_ERR("%s: h2c MALLOC fail\n", __func__);
		return MACNPTR;
	}

	dbcc->dword0 = en ? FWCMD_H2C_NOTIFY_DBCC_EN : 0;

	ret = mac_h2c_common(adapter, &h2c_info, (u32 *)dbcc);

	PLTFM_FREE(dbcc, h2c_info.content_len);

	return ret;
}

u32 mac_dbcc_enable(struct mac_ax_adapter *adapter,
		    struct mac_ax_trx_info *info, u8 dbcc_en)
{
	u32 ret;

	if (dbcc_en) {
		ret = band1_enable(adapter, info);
		if (ret != MACSUCCESS) {
			PLTFM_MSG_ERR("[ERR] band1_enable %d\n", ret);
			return ret;
		}
		if (adapter->sm.fwdl == MAC_AX_FWDL_INIT_RDY) {
			ret = mac_notify_fw_dbcc(adapter, 1);
			if (ret != MACSUCCESS) {
				PLTFM_MSG_ERR("%s:[ERR]notfify dbcc1 fail %d\n",
					      __func__, ret);
				return ret;
			}
		} else {
			PLTFM_MSG_WARN("%s fw not ready\n", __func__);
		}
	} else {
		if (adapter->sm.fwdl == MAC_AX_FWDL_INIT_RDY) {
			ret = mac_notify_fw_dbcc(adapter, 0);
			if (ret != MACSUCCESS) {
				PLTFM_MSG_ERR("%s:[ERR]notfify dbcc0 fail %d\n",
					      __func__, ret);
				return ret;
			}
		} else {
			PLTFM_MSG_WARN("%s fw not ready\n", __func__);
		}
		ret = band1_disable(adapter, info);
		if (ret != MACSUCCESS) {
			PLTFM_MSG_ERR("[ERR] band1_disable %d\n", ret);
			return ret;
		}
	}

	return MACSUCCESS;
}

u32 mac_dbcc_pre_cfg(struct mac_ax_adapter *adapter, struct mac_dbcc_cfg_info *info)
{
	struct mac_ax_dbcc_info *dbcc_info = adapter->dbcc_info;
	struct mac_ax_trx_info trx_info;
	u32 ret = MACSUCCESS;
	u8 notify_en;

	trx_info.trx_mode = info->trx_mode;
	trx_info.qta_mode = info->qta_mode;
	trx_info.rpr_cfg = NULL;

	if (info->dbcc_en) {
		notify_en = 1;
		ret = band1_enable(adapter, &trx_info);
		if (ret != MACSUCCESS) {
			PLTFM_MSG_ERR("[ERR] band1_enable %d\n", ret);
			return ret;
		}
		if (adapter->sm.fwdl == MAC_AX_FWDL_INIT_RDY) {
			if (dbcc_info->notify_fw_flag) {
				PLTFM_MSG_WARN("[WARN]Notify FW dbcc %d flag already set\n",
					       notify_en);
			}
			dbcc_info->notify_fw_flag = 1;
			ret = mac_notify_fw_dbcc(adapter, notify_en);
			if (ret != MACSUCCESS) {
				PLTFM_MSG_ERR("%s:[ERR]Notify dbcc %d fail %d\n",
					      __func__, notify_en, ret);
				return ret;
			}
		} else {
			PLTFM_MSG_WARN("%s en %d fw not ready\n", __func__, info->dbcc_en);
		}
	} else {
		notify_en = 0;
		if (adapter->sm.fwdl == MAC_AX_FWDL_INIT_RDY) {
			if (dbcc_info->notify_fw_flag) {
				PLTFM_MSG_WARN("[WARN]Notify FW dbcc %d flag already set\n",
					       notify_en);
			}
			dbcc_info->notify_fw_flag = 1;
			ret = mac_notify_fw_dbcc(adapter, notify_en);
			if (ret != MACSUCCESS) {
				PLTFM_MSG_ERR("%s:[ERR]Notify dbcc %d fail %d\n",
					      __func__, notify_en, ret);
				return ret;
			}
		} else {
			PLTFM_MSG_WARN("%s en %d fw not ready\n", __func__, info->dbcc_en);
		}
	}

	return ret;
}

u32 mac_dbcc_cfg(struct mac_ax_adapter *adapter, struct mac_dbcc_cfg_info *info)
{
	struct mac_ax_trx_info trx_info;
	u32 ret = MACSUCCESS;

	trx_info.trx_mode = info->trx_mode;
	trx_info.qta_mode = info->qta_mode;
	trx_info.rpr_cfg = NULL;

	if (info->dbcc_en) {
		ret = dbcc_chk_notify_done(adapter);
		if (ret != MACSUCCESS) {
			PLTFM_MSG_ERR("[ERR]Check dbcc notify %d fail %d\n",
				      info->dbcc_en, ret);
			return ret;
		}
	} else {
		ret = dbcc_chk_notify_done(adapter);
		if (ret != MACSUCCESS) {
			PLTFM_MSG_ERR("[ERR]Check dbcc notify %d fail %d\n",
				      info->dbcc_en, ret);
			return ret;
		}

		ret = band1_disable(adapter, &trx_info);
		if (ret != MACSUCCESS) {
			PLTFM_MSG_ERR("[ERR] band1_disable %d\n", ret);
			return ret;
		}
	}

	return ret;
}

u32 mac_dbcc_move_wmm(struct mac_ax_adapter *adapter,
		      struct mac_ax_role_info *info)
{
	struct mac_ax_dbcc_info *dbcc_info = adapter->dbcc_info;
	enum mac_ax_ss_wmm_tbl dst_link;
	u8 dbcc_wmm;
	u8 role_cnt;
	u8 wmm_type;
	u8 dbcc_en = info->band;
	u32 ret;

	if (!dbcc_info) {
		PLTFM_MSG_ERR("no dbcc info when move wmm\n");
		return MACNPTR;
	}

	dbcc_wmm = *(dbcc_info->dbcc_wmm_list + info->macid);
	role_cnt = dbcc_info->dbcc_role_cnt[dbcc_wmm];
	wmm_type = dbcc_info->dbcc_wmm_type[dbcc_wmm];

	if (!role_cnt) {
		PLTFM_MSG_ERR("dbcc en%d move wmm%d role cnt 0\n",
			      dbcc_en, dbcc_wmm);
		return MACCMP;
	}

	dst_link = dbcc_en ?
		   MAC_AX_SS_WMM_TBL_C1_WMM0 : MAC_AX_SS_WMM_TBL_C0_WMM0;
	if (dbcc_en == MAC_AX_BAND_0)
		dst_link = info->wmm ?
			   MAC_AX_SS_WMM_TBL_C0_WMM1 : MAC_AX_SS_WMM_TBL_C0_WMM0;
	else
		dst_link = info->wmm ?
			   MAC_AX_SS_WMM_TBL_C1_WMM1 : MAC_AX_SS_WMM_TBL_C1_WMM0;
	ret = mac_ss_wmm_sta_move(adapter,
				  (enum mac_ax_ss_wmm)dbcc_wmm,
				  dst_link);
	if (ret == MACARDYDONE) {
		if (wmm_type != MAC_AX_NET_TYPE_AP)
			PLTFM_MSG_WARN("dbcc en%d move wmm%d is already mapped\n",
				       dbcc_en, dbcc_wmm);
		return MACSUCCESS;
	} else if (ret != MACSUCCESS) {
		PLTFM_MSG_ERR("dbcc en%d move wmm%d sta %d\n",
			      dbcc_en, dbcc_wmm, ret);
		return ret;
	}

	return MACSUCCESS;
}

