mwifiex/mxm_wifiex/wlan_src/mlan/mlan_11n.c

/** @file mlan_11n.c
 *
 *  @brief This file contains functions for 11n handling.
 *
 *
 *  Copyright 2008-2021 NXP
 *
 *  This software file (the File) is distributed by NXP
 *  under the terms of the GNU General Public License Version 2, June 1991
 *  (the License).  You may use, redistribute and/or modify the File in
 *  accordance with the terms and conditions of the License, a copy of which
 *  is available by writing to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
 *  worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
 *
 *  THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
 *  ARE EXPRESSLY DISCLAIMED.  The License provides additional details about
 *  this warranty disclaimer.
 *
 */

/********************************************************
Change log:
    11/10/2008: initial version
********************************************************/

#include "mlan.h"
#include "mlan_join.h"
#include "mlan_util.h"
#include "mlan_fw.h"
#include "mlan_main.h"
#include "mlan_wmm.h"
#include "mlan_11n.h"
#include "mlan_11ac.h"

/********************************************************
			Local Variables
********************************************************/

/********************************************************
			Global Variables
********************************************************/

/********************************************************
			Local Functions
********************************************************/

/**
 *
 *  @brief set/get max tx buf size
 *
 *  @param pmadapter	A pointer to mlan_adapter structure
 *  @param pioctl_req	A pointer to ioctl request buffer
 *
 *  @return				MLAN_STATUS_SUCCESS --success, otherwise
 * fail
 */
static mlan_status wlan_11n_ioctl_max_tx_buf_size(pmlan_adapter pmadapter,
						  pmlan_ioctl_req pioctl_req)
{
	mlan_status ret = MLAN_STATUS_SUCCESS;
	mlan_ds_11n_cfg *cfg = MNULL;

	ENTER();
	cfg = (mlan_ds_11n_cfg *)pioctl_req->pbuf;
	cfg->param.tx_buf_size = (t_u32)pmadapter->max_tx_buf_size;
	pioctl_req->data_read_written = sizeof(t_u32) + MLAN_SUB_COMMAND_SIZE;

	LEAVE();
	return ret;
}

/**
 *  @brief Set/get htcapinfo configuration
 *
 *  @param pmadapter	A pointer to mlan_adapter structure
 *  @param pioctl_req	A pointer to ioctl request buffer
 *
 *  @return				MLAN_STATUS_SUCCESS --success, otherwise
 * fail
 */
static mlan_status wlan_11n_ioctl_htusrcfg(pmlan_adapter pmadapter,
					   pmlan_ioctl_req pioctl_req)
{
	mlan_status ret = MLAN_STATUS_SUCCESS;
	mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index];
	mlan_ds_11n_cfg *cfg = MNULL;

	ENTER();

	cfg = (mlan_ds_11n_cfg *)pioctl_req->pbuf;

	if (pioctl_req->action == MLAN_ACT_SET) {
		if (((cfg->param.htcap_cfg.htcap & ~IGN_HW_DEV_CAP) &
		     pmpriv->adapter->hw_dot_11n_dev_cap) !=
		    (cfg->param.htcap_cfg.htcap & ~IGN_HW_DEV_CAP)) {
			pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER;
			ret = MLAN_STATUS_FAILURE;
		} else {
			if (cfg->param.htcap_cfg.misc_cfg == BAND_SELECT_BG) {
				pmpriv->usr_dot_11n_dev_cap_bg =
					cfg->param.htcap_cfg.htcap;
				PRINTM(MINFO,
				       "Set: UsrDot11nCap for 2.4GHz 0x%x\n",
				       pmpriv->usr_dot_11n_dev_cap_bg);
			}
			if (cfg->param.htcap_cfg.misc_cfg == BAND_SELECT_A) {
				pmpriv->usr_dot_11n_dev_cap_a =
					cfg->param.htcap_cfg.htcap;
				PRINTM(MINFO,
				       "Set: UsrDot11nCap for 5GHz 0x%x\n",
				       pmpriv->usr_dot_11n_dev_cap_a);
			}
			if (cfg->param.htcap_cfg.misc_cfg == BAND_SELECT_BOTH) {
				pmpriv->usr_dot_11n_dev_cap_bg =
					cfg->param.htcap_cfg.htcap;
				pmpriv->usr_dot_11n_dev_cap_a =
					cfg->param.htcap_cfg.htcap;
				PRINTM(MINFO,
				       "Set: UsrDot11nCap for 2.4GHz and 5GHz 0x%x\n",
				       cfg->param.htcap_cfg.htcap);
			}
		}
	} else {
		/* Hardware 11N device capability required */
		if (cfg->param.htcap_cfg.hw_cap_req)
			cfg->param.htcap_cfg.htcap =
				pmadapter->hw_dot_11n_dev_cap;
		else {
			if (cfg->param.htcap_cfg.misc_cfg == BAND_SELECT_BG) {
				cfg->param.htcap_cfg.htcap =
					pmpriv->usr_dot_11n_dev_cap_bg;
				PRINTM(MINFO,
				       "Get: UsrDot11nCap for 2.4GHz 0x%x\n",
				       cfg->param.htcap_cfg.htcap);
			}
			if (cfg->param.htcap_cfg.misc_cfg == BAND_SELECT_A) {
				cfg->param.htcap_cfg.htcap =
					pmpriv->usr_dot_11n_dev_cap_a;
				PRINTM(MINFO,
				       "Get: UsrDot11nCap for 5GHz 0x%x\n",
				       cfg->param.htcap_cfg.htcap);
			}
		}
	}

	LEAVE();
	return ret;
}

/**
 *  @brief Enable/Disable AMSDU AGGR CTRL
 *
 *  @param pmadapter	A pointer to mlan_adapter structure
 *  @param pioctl_req	A pointer to ioctl request buffer
 *
 *  @return		MLAN_STATUS_PENDING --success, otherwise fail
 */
static mlan_status wlan_11n_ioctl_amsdu_aggr_ctrl(pmlan_adapter pmadapter,
						  pmlan_ioctl_req pioctl_req)
{
	mlan_status ret = MLAN_STATUS_SUCCESS;
	mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index];
	mlan_ds_11n_cfg *cfg = MNULL;
	t_u16 cmd_action = 0;

	ENTER();

	cfg = (mlan_ds_11n_cfg *)pioctl_req->pbuf;
	if (pioctl_req->action == MLAN_ACT_SET)
		cmd_action = HostCmd_ACT_GEN_SET;
	else
		cmd_action = HostCmd_ACT_GEN_GET;

	/* Send request to firmware */
	ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_AMSDU_AGGR_CTRL, cmd_action,
			       0, (t_void *)pioctl_req,
			       (t_void *)&cfg->param.amsdu_aggr_ctrl);
	if (ret == MLAN_STATUS_SUCCESS)
		ret = MLAN_STATUS_PENDING;

	LEAVE();
	return ret;
}

/**
 *  @brief Set/get 11n configuration
 *
 *  @param pmadapter	A pointer to mlan_adapter structure
 *  @param pioctl_req	A pointer to ioctl request buffer
 *
 *  @return		MLAN_STATUS_PENDING --success, otherwise fail
 */
static mlan_status wlan_11n_ioctl_httxcfg(pmlan_adapter pmadapter,
					  pmlan_ioctl_req pioctl_req)
{
	mlan_status ret = MLAN_STATUS_SUCCESS;
	mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index];
	mlan_ds_11n_cfg *cfg = MNULL;
	t_u16 cmd_action = 0;

	ENTER();

	cfg = (mlan_ds_11n_cfg *)pioctl_req->pbuf;
	if (pioctl_req->action == MLAN_ACT_SET)
		cmd_action = HostCmd_ACT_GEN_SET;
	else
		cmd_action = HostCmd_ACT_GEN_GET;

	/* Send request to firmware */
	ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_11N_CFG, cmd_action, 0,
			       (t_void *)pioctl_req,
			       (t_void *)&cfg->param.tx_cfg);
	if (ret == MLAN_STATUS_SUCCESS)
		ret = MLAN_STATUS_PENDING;

	LEAVE();
	return ret;
}

/**
 *  @brief Set/get TX beamforming capabilities
 *
 *  @param pmadapter    A pointer to mlan_adapter structure
 *  @param pioctl_req   A pointer to ioctl request buffer
 *
 *  @return             MLAN_STATUS_SUCCESS --success
 */
static mlan_status wlan_11n_ioctl_tx_bf_cap(pmlan_adapter pmadapter,
					    pmlan_ioctl_req pioctl_req)
{
	mlan_status ret = MLAN_STATUS_SUCCESS;
	mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index];
	mlan_ds_11n_cfg *cfg = MNULL;

	ENTER();

	cfg = (mlan_ds_11n_cfg *)pioctl_req->pbuf;
	if (pioctl_req->action == MLAN_ACT_SET)
		pmpriv->tx_bf_cap = cfg->param.tx_bf_cap;
	else
		cfg->param.tx_bf_cap = pmpriv->tx_bf_cap;

	LEAVE();
	return ret;
}

/**
 *  @brief Set/get TX beamforming configurations
 *
 *  @param pmadapter    A pointer to mlan_adapter structure
 *  @param pioctl_req   A pointer to ioctl request buffer
 *
 *  @return             MLAN_STATUS_PENDING --success, otherwise fail
 */
static mlan_status wlan_11n_ioctl_tx_bf_cfg(pmlan_adapter pmadapter,
					    pmlan_ioctl_req pioctl_req)
{
	mlan_status ret = MLAN_STATUS_SUCCESS;
	mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index];
	mlan_ds_11n_cfg *cfg = MNULL;
	t_u16 cmd_action = 0;

	ENTER();

	cfg = (mlan_ds_11n_cfg *)pioctl_req->pbuf;
	if (pioctl_req->action == MLAN_ACT_SET)
		cmd_action = HostCmd_ACT_GEN_SET;
	else
		cmd_action = HostCmd_ACT_GEN_GET;

	/* Send request to firmware */
	ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_TX_BF_CFG, cmd_action, 0,
			       (t_void *)pioctl_req,
			       (t_void *)&cfg->param.tx_bf);
	if (ret == MLAN_STATUS_SUCCESS)
		ret = MLAN_STATUS_PENDING;

	LEAVE();
	return ret;
}

/**
 *  @brief Set/get HT stream configurations
 *
 *  @param pmadapter    A pointer to mlan_adapter structure
 *  @param pioctl_req   A pointer to ioctl request buffer
 *
 *  @return             MLAN_STATUS_SUCCESS --success, otherwise fail
 */
static mlan_status wlan_11n_ioctl_stream_cfg(pmlan_adapter pmadapter,
					     pmlan_ioctl_req pioctl_req)
{
	mlan_status ret = MLAN_STATUS_SUCCESS;
	mlan_ds_11n_cfg *cfg = MNULL;
	mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index];

	ENTER();

	cfg = (mlan_ds_11n_cfg *)pioctl_req->pbuf;
	if (pioctl_req->action == MLAN_ACT_GET) {
		cfg->param.stream_cfg = pmpriv->usr_dev_mcs_support;
	} else if (pioctl_req->action == MLAN_ACT_SET) {
		switch (cfg->param.stream_cfg) {
		case HT_STREAM_MODE_2X2:
			if (pmadapter->hw_dev_mcs_support ==
			    HT_STREAM_MODE_1X1) {
				PRINTM(MERROR,
				       "HW does not support this mode\n");
				ret = MLAN_STATUS_FAILURE;
			} else
				pmpriv->usr_dev_mcs_support =
					cfg->param.stream_cfg;
			break;
		case HT_STREAM_MODE_1X1:
			pmpriv->usr_dev_mcs_support = cfg->param.stream_cfg;
			break;
		default:
			PRINTM(MERROR, "Invalid stream mode\n");
			pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER;
			ret = MLAN_STATUS_FAILURE;
			break;
		}
	}

	LEAVE();
	return ret;
}

/**
 *  @brief Set/get control to coex RX window size configuration
 *
 *  @param pmadapter    A pointer to mlan_adapter structure
 *  @param pioctl_req   A pointer to ioctl request buffer
 *
 *  @return             MLAN_STATUS_SUCCESS --success, otherwise fail
 */
static mlan_status wlan_11n_ioctl_coex_rx_winsize(pmlan_adapter pmadapter,
						  pmlan_ioctl_req pioctl_req)
{
	mlan_status ret = MLAN_STATUS_SUCCESS;
	mlan_ds_11n_cfg *cfg = MNULL;

	ENTER();

	cfg = (mlan_ds_11n_cfg *)pioctl_req->pbuf;
	if (pioctl_req->action == MLAN_ACT_GET)
		cfg->param.coex_rx_winsize = pmadapter->coex_rx_winsize;
	else if (pioctl_req->action == MLAN_ACT_SET)
		pmadapter->coex_rx_winsize = (t_u8)cfg->param.coex_rx_winsize;

	LEAVE();
	return ret;
}

/**
 *  @brief This function will send delba request to
 *          the peer in the TxBAStreamTbl
 *
 *  @param priv     A pointer to mlan_private
 *  @param ra       MAC Address to send DELBA
 *
 *  @return         N/A
 */
void wlan_11n_send_delba_to_peer(mlan_private *priv, t_u8 *ra)
{
	TxBAStreamTbl *ptx_tbl;

	ENTER();
	wlan_request_ralist_lock(priv);
	ptx_tbl = (TxBAStreamTbl *)util_peek_list(priv->adapter->pmoal_handle,
						  &priv->tx_ba_stream_tbl_ptr,
						  MNULL, MNULL);
	if (!ptx_tbl) {
		wlan_release_ralist_lock(priv);
		LEAVE();
		return;
	}

	while (ptx_tbl != (TxBAStreamTbl *)&priv->tx_ba_stream_tbl_ptr) {
		if (!memcmp(priv->adapter, ptx_tbl->ra, ra,
			    MLAN_MAC_ADDR_LENGTH)) {
			PRINTM(MIOCTL, "Tx:Send delba to tid=%d, " MACSTR "\n",
			       ptx_tbl->tid, MAC2STR(ptx_tbl->ra));
			wlan_send_delba(priv, MNULL, ptx_tbl->tid, ptx_tbl->ra,
					1);
		}
		ptx_tbl = ptx_tbl->pnext;
	}
	wlan_release_ralist_lock(priv);
	/* Signal MOAL to trigger mlan_main_process */
	wlan_recv_event(priv, MLAN_EVENT_ID_DRV_DEFER_HANDLING, MNULL);
	LEAVE();
	return;
}

/**
 *  @brief Set/Get control to TX AMPDU configuration on infra link
 *
 *  @param pmadapter    A pointer to mlan_adapter structure
 *  @param pioctl_req   A pointer to ioctl request buffer
 *
 *  @return             MLAN_STATUS_SUCCESS --success, otherwise fail
 */
static mlan_status wlan_11n_ioctl_txaggrctrl(pmlan_adapter pmadapter,
					     pmlan_ioctl_req pioctl_req)
{
	mlan_status ret = MLAN_STATUS_SUCCESS;
	mlan_ds_11n_cfg *cfg = MNULL;
	mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index];

	ENTER();

	cfg = (mlan_ds_11n_cfg *)pioctl_req->pbuf;
	if (pioctl_req->action == MLAN_ACT_GET)
		cfg->param.txaggrctrl = pmpriv->txaggrctrl;
	else if (pioctl_req->action == MLAN_ACT_SET)
		pmpriv->txaggrctrl = (t_u8)cfg->param.txaggrctrl;

	if (pmpriv->media_connected == MTRUE) {
		if (pioctl_req->action == MLAN_ACT_SET && !pmpriv->txaggrctrl &&
		    pmpriv->adapter->tdls_status != TDLS_NOT_SETUP)
			wlan_11n_send_delba_to_peer(
				pmpriv, pmpriv->curr_bss_params.bss_descriptor
						.mac_address);
	}
	LEAVE();
	return ret;
}

/**
 *  @brief This function will resend addba request to all
 *          the peer in the TxBAStreamTbl
 *
 *  @param priv     A pointer to mlan_private
 *
 *  @return         N/A
 */
static void wlan_11n_update_addba_request(mlan_private *priv)
{
	TxBAStreamTbl *ptx_tbl;

	ENTER();

	wlan_request_ralist_lock(priv);
	ptx_tbl = (TxBAStreamTbl *)util_peek_list(priv->adapter->pmoal_handle,
						  &priv->tx_ba_stream_tbl_ptr,
						  MNULL, MNULL);
	if (!ptx_tbl) {
		wlan_release_ralist_lock(priv);
		LEAVE();
		return;
	}

	while (ptx_tbl != (TxBAStreamTbl *)&priv->tx_ba_stream_tbl_ptr) {
		wlan_send_addba(priv, ptx_tbl->tid, ptx_tbl->ra);
		ptx_tbl = ptx_tbl->pnext;
	}
	wlan_release_ralist_lock(priv);
	/* Signal MOAL to trigger mlan_main_process */
	wlan_recv_event(priv, MLAN_EVENT_ID_DRV_DEFER_HANDLING, MNULL);
	LEAVE();
	return;
}

/**
 *  @brief Set/get addba parameter
 *
 *  @param pmadapter	A pointer to mlan_adapter structure
 *  @param pioctl_req	A pointer to ioctl request buffer
 *
 *  @return				MLAN_STATUS_SUCCESS --success
 */
static mlan_status wlan_11n_ioctl_addba_param(pmlan_adapter pmadapter,
					      pmlan_ioctl_req pioctl_req)
{
	mlan_status ret = MLAN_STATUS_SUCCESS;
	mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index];
	mlan_ds_11n_cfg *cfg = MNULL;
	t_u32 timeout;

	ENTER();

	cfg = (mlan_ds_11n_cfg *)pioctl_req->pbuf;
	if (pioctl_req->action == MLAN_ACT_GET) {
		cfg->param.addba_param.timeout = pmpriv->add_ba_param.timeout;
		cfg->param.addba_param.txwinsize =
			pmpriv->add_ba_param.tx_win_size;
		cfg->param.addba_param.rxwinsize =
			pmpriv->add_ba_param.rx_win_size;
		cfg->param.addba_param.txamsdu = pmpriv->add_ba_param.tx_amsdu;
		cfg->param.addba_param.rxamsdu = pmpriv->add_ba_param.rx_amsdu;
	} else {
		timeout = pmpriv->add_ba_param.timeout;
		pmpriv->add_ba_param.timeout = cfg->param.addba_param.timeout;
		pmpriv->add_ba_param.tx_win_size =
			cfg->param.addba_param.txwinsize;

		pmpriv->add_ba_param.rx_win_size =
			cfg->param.addba_param.rxwinsize;
		pmpriv->user_rxwinsize = pmpriv->add_ba_param.rx_win_size;
		pmpriv->add_ba_param.tx_amsdu = cfg->param.addba_param.txamsdu;
		pmpriv->add_ba_param.rx_amsdu = cfg->param.addba_param.rxamsdu;
		if (timeout != pmpriv->add_ba_param.timeout)
			wlan_11n_update_addba_request(pmpriv);
	}

	LEAVE();
	return ret;
}

/**
 *  @brief This function send delba to specific tid
 *
 *  @param priv         A pointer to mlan_priv
 *  @param tid          tid
 *  @return             N/A
 */
void wlan_11n_delba(mlan_private *priv, int tid)
{
	RxReorderTbl *rx_reor_tbl_ptr;

	ENTER();

	rx_reor_tbl_ptr = (RxReorderTbl *)util_peek_list(
		priv->adapter->pmoal_handle, &priv->rx_reorder_tbl_ptr,
		priv->adapter->callbacks.moal_spin_lock,
		priv->adapter->callbacks.moal_spin_unlock);
	if (!rx_reor_tbl_ptr) {
		LEAVE();
		return;
	}

	while (rx_reor_tbl_ptr != (RxReorderTbl *)&priv->rx_reorder_tbl_ptr) {
		if (rx_reor_tbl_ptr->tid == tid) {
			PRINTM(MIOCTL, "Send delba to tid=%d, " MACSTR "\n",
			       tid, MAC2STR(rx_reor_tbl_ptr->ta));
			wlan_send_delba(priv, MNULL, tid, rx_reor_tbl_ptr->ta,
					0);
			LEAVE();
			return;
		}
		rx_reor_tbl_ptr = rx_reor_tbl_ptr->pnext;
	}

	LEAVE();
	return;
}

/**
 *  @brief Set/get addba reject set
 *
 *  @param pmadapter	A pointer to mlan_adapter structure
 *  @param pioctl_req	A pointer to ioctl request buffer
 *
 *  @return		MLAN_STATUS_SUCCESS --success, otherwise fail
 */
static mlan_status wlan_11n_ioctl_addba_reject(pmlan_adapter pmadapter,
					       pmlan_ioctl_req pioctl_req)
{
	int i = 0;
	mlan_status ret = MLAN_STATUS_SUCCESS;
	mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index];
	mlan_ds_11n_cfg *cfg = MNULL;

	ENTER();

	cfg = (mlan_ds_11n_cfg *)pioctl_req->pbuf;

	if (pioctl_req->action == MLAN_ACT_GET) {
		PRINTM(MINFO, "Get Addba reject\n");
		memcpy_ext(pmadapter, cfg->param.addba_reject,
			   pmpriv->addba_reject, MAX_NUM_TID, MAX_NUM_TID);
	} else {
		for (i = 0; i < MAX_NUM_TID; i++) {
			/* For AMPDU */
			if (cfg->param.addba_reject[i] >
			    ADDBA_RSP_STATUS_REJECT) {
				pioctl_req->status_code =
					MLAN_ERROR_INVALID_PARAMETER;
				ret = MLAN_STATUS_FAILURE;
				break;
			}

			pmpriv->addba_reject[i] = cfg->param.addba_reject[i];
		}
		if (pmpriv->media_connected == MTRUE) {
			for (i = 0; i < MAX_NUM_TID; i++) {
				if (cfg->param.addba_reject[i] ==
				    ADDBA_RSP_STATUS_REJECT) {
					PRINTM(MIOCTL,
					       "Receive addba reject: tid=%d\n",
					       i);
					wlan_11n_delba(pmpriv, i);
				}
			}
			wlan_recv_event(pmpriv,
					MLAN_EVENT_ID_DRV_DEFER_HANDLING,
					MNULL);
		}
	}

	LEAVE();
	return ret;
}

/**
 *  @brief Set/get ibss ampdu param
 *
 *  @param pmadapter	A pointer to mlan_adapter structure
 *  @param pioctl_req	A pointer to ioctl request buffer
 *
 *  @return		MLAN_STATUS_SUCCESS --success, otherwise fail
 */
static mlan_status wlan_11n_ioctl_ibss_ampdu_param(pmlan_adapter pmadapter,
						   pmlan_ioctl_req pioctl_req)
{
	int i = 0;
	mlan_status ret = MLAN_STATUS_SUCCESS;
	mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index];
	mlan_ds_11n_cfg *cfg = MNULL;

	ENTER();

	cfg = (mlan_ds_11n_cfg *)pioctl_req->pbuf;

	if (pioctl_req->action == MLAN_ACT_GET) {
		PRINTM(MINFO, "Get IBSS AMPDU param\n");
		for (i = 0; i < MAX_NUM_TID; i++) {
			cfg->param.ibss_ampdu.ampdu[i] = pmpriv->ibss_ampdu[i];
			cfg->param.ibss_ampdu.addba_reject[i] =
				pmpriv->ibss_addba_reject[i];
		}
	} else {
		for (i = 0; i < MAX_NUM_TID; i++) {
			/* For AMPDU  RX*/
			if (cfg->param.ibss_ampdu.addba_reject[i] >
			    ADDBA_RSP_STATUS_REJECT) {
				pioctl_req->status_code =
					MLAN_ERROR_INVALID_PARAMETER;
				ret = MLAN_STATUS_FAILURE;
				break;
			}
			pmpriv->ibss_addba_reject[i] =
				cfg->param.ibss_ampdu.addba_reject[i];
			/* For AMPDU TX*/
			if ((cfg->param.ibss_ampdu.ampdu[i] > HIGH_PRIO_TID) &&
			    (cfg->param.ibss_ampdu.ampdu[i] !=
			     BA_STREAM_NOT_ALLOWED)) {
				pioctl_req->status_code =
					MLAN_ERROR_INVALID_PARAMETER;
				ret = MLAN_STATUS_FAILURE;
				break;
			}
			pmpriv->ibss_ampdu[i] = cfg->param.ibss_ampdu.ampdu[i];
		}
		PRINTM(MMSG, "IBSS addba reject: %d %d %d %d %d %d %d %d\n",
		       pmpriv->ibss_addba_reject[0],
		       pmpriv->ibss_addba_reject[1],
		       pmpriv->ibss_addba_reject[2],
		       pmpriv->ibss_addba_reject[3],
		       pmpriv->ibss_addba_reject[4],
		       pmpriv->ibss_addba_reject[5],
		       pmpriv->ibss_addba_reject[6],
		       pmpriv->ibss_addba_reject[7]);
		PRINTM(MMSG, "IBSS ampdu %d %d %d %d %d %d %d %d\n",
		       pmpriv->ibss_ampdu[0], pmpriv->ibss_ampdu[1],
		       pmpriv->ibss_ampdu[2], pmpriv->ibss_ampdu[3],
		       pmpriv->ibss_ampdu[4], pmpriv->ibss_ampdu[5],
		       pmpriv->ibss_ampdu[6], pmpriv->ibss_ampdu[7]);
	}
	LEAVE();
	return ret;
}

/**
 *  @brief Set/Get Minimum BA Threshold
 *
 *  @param pmadapter   A pointer to mlan_adapter structure
 *  @param pioctl_req A pointer to ioctl request buffer
 *
 *  @return     MLAN_STATUS_SUCCESS --success
 */
static mlan_status
wlan_11n_ioctl_min_ba_threshold_cfg(pmlan_adapter pmadapter,
				    pmlan_ioctl_req pioctl_req)
{
	mlan_status ret = MLAN_STATUS_SUCCESS;
	mlan_ds_11n_cfg *cfg = MNULL;
	ENTER();
	cfg = (mlan_ds_11n_cfg *)pioctl_req->pbuf;
	if (pioctl_req->action == MLAN_ACT_GET)
		cfg->param.min_ba_threshold = pmadapter->min_ba_threshold;
	else
		pmadapter->min_ba_threshold = cfg->param.min_ba_threshold;
	pioctl_req->data_read_written = sizeof(t_u8) + MLAN_SUB_COMMAND_SIZE;
	LEAVE();
	return ret;
}

/**
 *  @brief This function will send DELBA to entries in the priv's
 *          Tx BA stream table
 *
 *  @param priv                 A pointer to mlan_private
 *  @param pioctl_req	        A pointer to ioctl request buffer
 *  @param tid                  TID
 *  @param peer_address         A pointer to peer address
 *  @param last_tx_ba_to_delete A pointer to the last entry in TxBAStreamTbl
 *
 *  @return		MLAN_STATUS_SUCCESS or MLAN_STATUS_PENDING
 */
static mlan_status wlan_send_delba_to_entry_in_txbastream_tbl(
	pmlan_private priv, pmlan_ioctl_req pioctl_req, t_u8 tid,
	t_u8 *peer_address, TxBAStreamTbl *last_tx_ba_to_delete)
{
	pmlan_adapter pmadapter = priv->adapter;
	TxBAStreamTbl *tx_ba_stream_tbl_ptr;
	t_u8 zero_mac[MLAN_MAC_ADDR_LENGTH] = {0};
	mlan_status ret = MLAN_STATUS_SUCCESS;

	ENTER();

	wlan_request_ralist_lock(priv);
	tx_ba_stream_tbl_ptr =
		(TxBAStreamTbl *)util_peek_list(pmadapter->pmoal_handle,
						&priv->tx_ba_stream_tbl_ptr,
						MNULL, MNULL);
	if (!tx_ba_stream_tbl_ptr) {
		wlan_release_ralist_lock(priv);
		LEAVE();
		return ret;
	}

	while (tx_ba_stream_tbl_ptr !=
	       (TxBAStreamTbl *)&priv->tx_ba_stream_tbl_ptr) {
		if (tx_ba_stream_tbl_ptr->ba_status ==
		    BA_STREAM_SETUP_COMPLETE) {
			if (((tid == DELBA_ALL_TIDS) ||
			     (tid == tx_ba_stream_tbl_ptr->tid)) &&
			    (!memcmp(pmadapter, peer_address, zero_mac,
				     MLAN_MAC_ADDR_LENGTH) ||
			     !memcmp(pmadapter, peer_address,
				     tx_ba_stream_tbl_ptr->ra,
				     MLAN_MAC_ADDR_LENGTH))) {
				if (last_tx_ba_to_delete &&
				    (tx_ba_stream_tbl_ptr ==
				     last_tx_ba_to_delete))
					ret = wlan_send_delba(
						priv, pioctl_req,
						tx_ba_stream_tbl_ptr->tid,
						tx_ba_stream_tbl_ptr->ra, 1);
				else
					ret = wlan_send_delba(
						priv, MNULL,
						tx_ba_stream_tbl_ptr->tid,
						tx_ba_stream_tbl_ptr->ra, 1);
			}
		}
		tx_ba_stream_tbl_ptr = tx_ba_stream_tbl_ptr->pnext;
	}
	wlan_release_ralist_lock(priv);

	LEAVE();
	return ret;
}

/**
 *  @brief This function will send DELBA to entries in the priv's
 *          rx reordering table
 *
 *  @param priv                 A pointer to mlan_private
 *  @param pioctl_req	        A pointer to ioctl request buffer
 *  @param tid                  TID
 *  @param peer_address         A pointer to peer address
 *  @param last_rx_ba_to_delete A pointer to the last entry in RxReorderTbl
 *
 *  @return		MLAN_STATUS_SUCCESS or MLAN_STATUS_PENDING
 */
static mlan_status wlan_send_delba_to_entry_in_reorder_tbl(
	pmlan_private priv, pmlan_ioctl_req pioctl_req, t_u8 tid,
	t_u8 *peer_address, RxReorderTbl *last_rx_ba_to_delete)
{
	pmlan_adapter pmadapter = priv->adapter;
	RxReorderTbl *rx_reor_tbl_ptr;
	t_u8 zero_mac[MLAN_MAC_ADDR_LENGTH] = {0};
	mlan_status ret = MLAN_STATUS_SUCCESS;

	ENTER();

	rx_reor_tbl_ptr = (RxReorderTbl *)util_peek_list(
		pmadapter->pmoal_handle, &priv->rx_reorder_tbl_ptr,
		pmadapter->callbacks.moal_spin_lock,
		pmadapter->callbacks.moal_spin_unlock);
	if (!rx_reor_tbl_ptr) {
		LEAVE();
		return ret;
	}

	while (rx_reor_tbl_ptr != (RxReorderTbl *)&priv->rx_reorder_tbl_ptr) {
		if (rx_reor_tbl_ptr->ba_status == BA_STREAM_SETUP_COMPLETE) {
			if (((tid == DELBA_ALL_TIDS) ||
			     (tid == rx_reor_tbl_ptr->tid)) &&
			    (!memcmp(pmadapter, peer_address, zero_mac,
				     MLAN_MAC_ADDR_LENGTH) ||
			     !memcmp(pmadapter, peer_address,
				     rx_reor_tbl_ptr->ta,
				     MLAN_MAC_ADDR_LENGTH))) {
				if (last_rx_ba_to_delete &&
				    (rx_reor_tbl_ptr == last_rx_ba_to_delete))
					ret = wlan_send_delba(
						priv, pioctl_req,
						rx_reor_tbl_ptr->tid,
						rx_reor_tbl_ptr->ta, 0);
				else
					ret = wlan_send_delba(
						priv, MNULL,
						rx_reor_tbl_ptr->tid,
						rx_reor_tbl_ptr->ta, 0);
			}
		}
		rx_reor_tbl_ptr = rx_reor_tbl_ptr->pnext;
	}

	LEAVE();
	return ret;
}

/**
 *  @brief IOCTL to delete BA
 *
 *  @param pmadapter	A pointer to mlan_adapter structure
 *  @param pioctl_req	A pointer to ioctl request buffer
 *
 *  @return		MLAN_STATUS_SUCCESS --success, otherwise fail
 */
static mlan_status wlan_11n_ioctl_delba(pmlan_adapter pmadapter,
					pmlan_ioctl_req pioctl_req)
{
	mlan_status ret = MLAN_STATUS_SUCCESS;
	mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index];
	mlan_ds_11n_cfg *cfg = MNULL;
	TxBAStreamTbl *tx_ba_stream_tbl_ptr, *last_tx_ba_to_delete = MNULL;
	RxReorderTbl *rx_reor_tbl_ptr, *last_rx_ba_to_delete = MNULL;
	t_u8 zero_mac[MLAN_MAC_ADDR_LENGTH] = {0};
	t_u8 tid, *peer_address;

	ENTER();

	cfg = (mlan_ds_11n_cfg *)pioctl_req->pbuf;
	tid = cfg->param.del_ba.tid;
	peer_address = cfg->param.del_ba.peer_mac_addr;

	PRINTM(MINFO, "DelBA: direction %d, TID %d, peer address " MACSTR "\n",
	       cfg->param.del_ba.direction, tid, MAC2STR(peer_address));

	if (cfg->param.del_ba.direction & DELBA_RX) {
		rx_reor_tbl_ptr = (RxReorderTbl *)util_peek_list(
			pmadapter->pmoal_handle, &pmpriv->rx_reorder_tbl_ptr,
			pmadapter->callbacks.moal_spin_lock,
			pmadapter->callbacks.moal_spin_unlock);

		if (rx_reor_tbl_ptr) {
			while (rx_reor_tbl_ptr !=
			       (RxReorderTbl *)&pmpriv->rx_reorder_tbl_ptr) {
				if (rx_reor_tbl_ptr->ba_status ==
				    BA_STREAM_SETUP_COMPLETE) {
					if (((tid == DELBA_ALL_TIDS) ||
					     (tid == rx_reor_tbl_ptr->tid)) &&
					    (!memcmp(pmadapter, peer_address,
						     zero_mac,
						     MLAN_MAC_ADDR_LENGTH) ||
					     !memcmp(pmadapter, peer_address,
						     rx_reor_tbl_ptr->ta,
						     MLAN_MAC_ADDR_LENGTH))) {
						/* Found RX BA to delete */
						last_rx_ba_to_delete =
							rx_reor_tbl_ptr;
					}
				}
				rx_reor_tbl_ptr = rx_reor_tbl_ptr->pnext;
			}
		}
	}

	if ((last_rx_ba_to_delete == MNULL) &&
	    (cfg->param.del_ba.direction & DELBA_TX)) {
		wlan_request_ralist_lock(pmpriv);
		tx_ba_stream_tbl_ptr = (TxBAStreamTbl *)util_peek_list(
			pmadapter->pmoal_handle, &pmpriv->tx_ba_stream_tbl_ptr,
			MNULL, MNULL);

		if (tx_ba_stream_tbl_ptr) {
			while (tx_ba_stream_tbl_ptr !=
			       (TxBAStreamTbl *)&pmpriv->tx_ba_stream_tbl_ptr) {
				if (tx_ba_stream_tbl_ptr->ba_status ==
				    BA_STREAM_SETUP_COMPLETE) {
					if (((tid == DELBA_ALL_TIDS) ||
					     (tid ==
					      tx_ba_stream_tbl_ptr->tid)) &&
					    (!memcmp(pmadapter, peer_address,
						     zero_mac,
						     MLAN_MAC_ADDR_LENGTH) ||
					     !memcmp(pmadapter, peer_address,
						     tx_ba_stream_tbl_ptr->ra,
						     MLAN_MAC_ADDR_LENGTH))) {
						/* Found TX BA to delete */
						last_tx_ba_to_delete =
							tx_ba_stream_tbl_ptr;
					}
				}
				tx_ba_stream_tbl_ptr =
					tx_ba_stream_tbl_ptr->pnext;
			}
		}
		wlan_release_ralist_lock(pmpriv);
	}

	if (cfg->param.del_ba.direction & DELBA_TX) {
		if (last_rx_ba_to_delete)
			ret = wlan_send_delba_to_entry_in_txbastream_tbl(
				pmpriv, MNULL, tid, peer_address, MNULL);
		else
			ret = wlan_send_delba_to_entry_in_txbastream_tbl(
				pmpriv, pioctl_req, tid, peer_address,
				last_tx_ba_to_delete);
	}
	if (last_rx_ba_to_delete) {
		ret = wlan_send_delba_to_entry_in_reorder_tbl(
			pmpriv, pioctl_req, tid, peer_address,
			last_rx_ba_to_delete);
	}

	LEAVE();
	return ret;
}

/**
 *  @brief IOCTL to reject addba req
 *
 *  @param pmadapter	A pointer to mlan_adapter structure
 *  @param pioctl_req	A pointer to ioctl request buffer
 *
 *  @return		MLAN_STATUS_SUCCESS --success, otherwise fail
 */
static mlan_status wlan_11n_ioctl_rejectaddbareq(pmlan_adapter pmadapter,
						 pmlan_ioctl_req pioctl_req)
{
	mlan_status ret = MLAN_STATUS_SUCCESS;
	mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index];
	mlan_ds_11n_cfg *cfg = MNULL;
	t_u16 cmd_action = 0;

	ENTER();

	cfg = (mlan_ds_11n_cfg *)pioctl_req->pbuf;
	if (pioctl_req->action == MLAN_ACT_SET)
		cmd_action = HostCmd_ACT_GEN_SET;
	else
		cmd_action = HostCmd_ACT_GEN_GET;

	/* Send command to firmware */
	ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_REJECT_ADDBA_REQ, cmd_action,
			       0, (t_void *)pioctl_req,
			       &cfg->param.reject_addba_req);

	if (ret == MLAN_STATUS_SUCCESS)
		ret = MLAN_STATUS_PENDING;

	LEAVE();
	return ret;
}

/**
 *  @brief This function will send DELBA to entries in the priv's
 *          Tx BA stream table
 *
 *  @param priv                 A pointer to mlan_private
 *  @param tid                  TID
 *
 *  @return		 N/A
 */
static void wlan_send_delba_txbastream_tbl(pmlan_private priv, t_u8 tid)
{
	pmlan_adapter pmadapter = priv->adapter;
	TxBAStreamTbl *tx_ba_stream_tbl_ptr;

	ENTER();

	wlan_request_ralist_lock(priv);
	tx_ba_stream_tbl_ptr =
		(TxBAStreamTbl *)util_peek_list(pmadapter->pmoal_handle,
						&priv->tx_ba_stream_tbl_ptr,
						MNULL, MNULL);
	if (!tx_ba_stream_tbl_ptr) {
		wlan_release_ralist_lock(priv);
		LEAVE();
		return;
	}

	while (tx_ba_stream_tbl_ptr !=
	       (TxBAStreamTbl *)&priv->tx_ba_stream_tbl_ptr) {
		if (tx_ba_stream_tbl_ptr->ba_status ==
		    BA_STREAM_SETUP_COMPLETE) {
			if (tid == tx_ba_stream_tbl_ptr->tid) {
				PRINTM(MIOCTL,
				       "Tx:Send delba to tid=%d, " MACSTR "\n",
				       tid, MAC2STR(tx_ba_stream_tbl_ptr->ra));
				wlan_release_ralist_lock(priv);
				wlan_send_delba(priv, MNULL,
						tx_ba_stream_tbl_ptr->tid,
						tx_ba_stream_tbl_ptr->ra, 1);
				LEAVE();
				return;
			}
		}
		tx_ba_stream_tbl_ptr = tx_ba_stream_tbl_ptr->pnext;
	}
	wlan_release_ralist_lock(priv);

	LEAVE();
	return;
}

/**
 *  @brief update station list for the new aggr_prio_tbl setting
 *
 *  @param priv 	A pointer to mlan_private structure
 *
 *
 *  @return		N/A
 */
static void wlan_update_all_stations_ampdu(mlan_private *priv)
{
	sta_node *sta_ptr;
	mlan_adapter *pmadapter = priv->adapter;
	int i = 0;

	ENTER();
	pmadapter->callbacks.moal_spin_lock(pmadapter->pmoal_handle,
					    priv->wmm.ra_list_spinlock);
	sta_ptr = (sta_node *)util_peek_list(pmadapter->pmoal_handle,
					     &priv->sta_list, MNULL, MNULL);
	if (!sta_ptr) {
		pmadapter->callbacks.moal_spin_unlock(
			pmadapter->pmoal_handle, priv->wmm.ra_list_spinlock);
		LEAVE();
		return;
	}
	while (sta_ptr != (sta_node *)&priv->sta_list) {
		for (i = 0; i < MAX_NUM_TID; i++) {
			if (sta_ptr->is_11n_enabled || sta_ptr->is_11ax_enabled)
				sta_ptr->ampdu_sta[i] =
					priv->aggr_prio_tbl[i].ampdu_user;
		}
		sta_ptr = sta_ptr->pnext;
	}
	pmadapter->callbacks.moal_spin_unlock(pmadapter->pmoal_handle,
					      priv->wmm.ra_list_spinlock);
	LEAVE();
	return;
}

/**
 *  @brief Set/get aggr_prio_tbl
 *
 *  @param pmadapter	A pointer to mlan_adapter structure
 *  @param pioctl_req	A pointer to ioctl request buffer
 *
 *  @return		MLAN_STATUS_SUCCESS --success, otherwise fail
 */
static mlan_status wlan_11n_ioctl_aggr_prio_tbl(pmlan_adapter pmadapter,
						pmlan_ioctl_req pioctl_req)
{
	int i = 0;
	mlan_status ret = MLAN_STATUS_SUCCESS;
	mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index];
	mlan_ds_11n_cfg *cfg = MNULL;

	ENTER();

	cfg = (mlan_ds_11n_cfg *)pioctl_req->pbuf;

	if (pioctl_req->action == MLAN_ACT_GET) {
		for (i = 0; i < MAX_NUM_TID; i++) {
			cfg->param.aggr_prio_tbl.ampdu[i] =
				pmpriv->aggr_prio_tbl[i].ampdu_user;
			cfg->param.aggr_prio_tbl.amsdu[i] =
				pmpriv->aggr_prio_tbl[i].amsdu;
		}
	} else {
		for (i = 0; i < MAX_NUM_TID; i++) {
			/* For AMPDU */
			if ((cfg->param.aggr_prio_tbl.ampdu[i] >
			     HIGH_PRIO_TID) &&
			    (cfg->param.aggr_prio_tbl.ampdu[i] !=
			     BA_STREAM_NOT_ALLOWED)) {
				pioctl_req->status_code =
					MLAN_ERROR_INVALID_PARAMETER;
				ret = MLAN_STATUS_FAILURE;
				break;
			}

			pmpriv->aggr_prio_tbl[i].ampdu_ap =
				pmpriv->aggr_prio_tbl[i].ampdu_user =
					cfg->param.aggr_prio_tbl.ampdu[i];

			/* For AMSDU */
			if ((cfg->param.aggr_prio_tbl.amsdu[i] >
				     HIGH_PRIO_TID &&
			     cfg->param.aggr_prio_tbl.amsdu[i] !=
				     BA_STREAM_NOT_ALLOWED)) {
				pioctl_req->status_code =
					MLAN_ERROR_INVALID_PARAMETER;
				ret = MLAN_STATUS_FAILURE;
				break;
			} else {
				pmpriv->aggr_prio_tbl[i].amsdu =
					cfg->param.aggr_prio_tbl.amsdu[i];
			}
		}
		if (pmpriv->media_connected == MTRUE) {
			for (i = 0; i < MAX_NUM_TID; i++) {
				if (cfg->param.aggr_prio_tbl.ampdu[i] ==
				    BA_STREAM_NOT_ALLOWED) {
					PRINTM(MIOCTL,
					       "Receive aggrpriotbl: BA not allowed tid=%d\n",
					       i);
					wlan_send_delba_txbastream_tbl(pmpriv,
								       i);
				}
			}
			wlan_update_all_stations_ampdu(pmpriv);
			wlan_recv_event(pmpriv,
					MLAN_EVENT_ID_DRV_DEFER_HANDLING,
					MNULL);
		}
	}

	LEAVE();
	return ret;
}

/**
 *  @brief This function update all the tx_win_size
 *
 *  @param pmadapter    A pointer to mlan_adapter
 *
 *
 *  @return             N/A
 */
void wlan_update_ampdu_txwinsize(pmlan_adapter pmadapter)
{
	t_u8 i;
	t_u32 tx_win_size = 0;
	pmlan_private priv = MNULL;

	ENTER();

	for (i = 0; i < pmadapter->priv_num; i++) {
		if (pmadapter->priv[i]) {
			priv = pmadapter->priv[i];
			tx_win_size = priv->add_ba_param.tx_win_size;
#ifdef STA_SUPPORT
			if (priv->bss_type == MLAN_BSS_TYPE_STA)
				priv->add_ba_param.tx_win_size =
					MLAN_STA_AMPDU_DEF_TXWINSIZE;
#endif
#ifdef WIFI_DIRECT_SUPPORT
			if (priv->bss_type == MLAN_BSS_TYPE_WIFIDIRECT)
				priv->add_ba_param.tx_win_size =
					MLAN_WFD_AMPDU_DEF_TXRXWINSIZE;
#endif
#ifdef UAP_SUPPORT
			if (priv->bss_type == MLAN_BSS_TYPE_UAP)
				priv->add_ba_param.tx_win_size =
					MLAN_UAP_AMPDU_DEF_TXWINSIZE;
#endif
			if (pmadapter->coex_win_size &&
			    pmadapter->coex_tx_win_size)
				priv->add_ba_param.tx_win_size =
					pmadapter->coex_tx_win_size;

			if (tx_win_size != priv->add_ba_param.tx_win_size) {
				if (priv->media_connected == MTRUE) {
					for (i = 0; i < MAX_NUM_TID; i++)
						wlan_send_delba_txbastream_tbl(
							priv, i);
					wlan_recv_event(
						priv,
						MLAN_EVENT_ID_DRV_DEFER_HANDLING,
						MNULL);
				}
			}
		}
	}
	LEAVE();
	return;
}

/**
 *  @brief Get supported MCS set
 *
 *  @param pmadapter	A pointer to mlan_adapter structure
 *  @param pioctl_req	A pointer to ioctl request buffer
 *
 *  @return		MLAN_STATUS_SUCCESS --success, otherwise fail
 */
static mlan_status wlan_11n_ioctl_supported_mcs_set(pmlan_adapter pmadapter,
						    pmlan_ioctl_req pioctl_req)
{
	mlan_ds_11n_cfg *cfg = MNULL;
	int rx_mcs_supp;
	t_u8 mcs_set[NUM_MCS_FIELD];
	mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index];

	ENTER();

	if (pioctl_req->action == MLAN_ACT_SET) {
		PRINTM(MERROR, "Set operation is not supported\n");
		pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID;
		LEAVE();
		return MLAN_STATUS_FAILURE;
	}
	rx_mcs_supp = GET_RXMCSSUPP(pmpriv->usr_dev_mcs_support);
	/* Set MCS for 1x1/2x2*/
	memset(pmadapter, (t_u8 *)mcs_set, 0xff, rx_mcs_supp);
	/* Clear all the other values */
	memset(pmadapter, (t_u8 *)&mcs_set[rx_mcs_supp], 0,
	       NUM_MCS_FIELD - rx_mcs_supp);
	/* Set MCS32 with 40MHz support */
	if ((ISSUPP_CHANWIDTH40(pmpriv->usr_dot_11n_dev_cap_bg) ||
	     ISSUPP_CHANWIDTH40(pmpriv->usr_dot_11n_dev_cap_a)) &&
	    !(pmpriv->curr_chan_flags & CHAN_FLAGS_NO_HT40PLUS &&
	      pmpriv->curr_chan_flags & CHAN_FLAGS_NO_HT40MINUS) &&
	    pmadapter->init_para.mcs32 == 1)
		SETHT_MCS32(mcs_set);

	cfg = (mlan_ds_11n_cfg *)pioctl_req->pbuf;
	memcpy_ext(pmadapter, cfg->param.supported_mcs_set, mcs_set,
		   NUM_MCS_FIELD, NUM_MCS_FIELD);

	LEAVE();
	return MLAN_STATUS_SUCCESS;
}

/**
 *  @brief This function checks if the given pointer is valid entry of
 *         Tx BA Stream table
 *
 *  @param priv         Pointer to mlan_private
 *  @param ptxtblptr    Pointer to tx ba stream entry
 *
 *  @return             MTRUE or MFALSE
 */
static int wlan_is_txbastreamptr_valid(mlan_private *priv,
				       TxBAStreamTbl *ptxtblptr)
{
	TxBAStreamTbl *ptx_tbl;

	ENTER();

	ptx_tbl = (TxBAStreamTbl *)util_peek_list(priv->adapter->pmoal_handle,
						  &priv->tx_ba_stream_tbl_ptr,
						  MNULL, MNULL);
	if (!ptx_tbl) {
		LEAVE();
		return MFALSE;
	}

	while (ptx_tbl != (TxBAStreamTbl *)&priv->tx_ba_stream_tbl_ptr) {
		if (ptx_tbl == ptxtblptr) {
			LEAVE();
			return MTRUE;
		}
		ptx_tbl = ptx_tbl->pnext;
	}
	LEAVE();
	return MFALSE;
}

/**
 *  @brief This function will return the pointer to a entry in BA Stream
 *          table which matches the ba_status requested
 *
 *  @param priv         A pointer to mlan_private
 *  @param ba_status    Current status of the BA stream
 *
 *  @return             A pointer to first entry matching status in BA stream
 *                      NULL if not found
 */
static TxBAStreamTbl *wlan_11n_get_txbastream_status(mlan_private *priv,
						     baStatus_e ba_status)
{
	TxBAStreamTbl *ptx_tbl;

	ENTER();

	ptx_tbl = (TxBAStreamTbl *)util_peek_list(priv->adapter->pmoal_handle,
						  &priv->tx_ba_stream_tbl_ptr,
						  MNULL, MNULL);
	if (!ptx_tbl) {
		LEAVE();
		return MNULL;
	}

	while (ptx_tbl != (TxBAStreamTbl *)&priv->tx_ba_stream_tbl_ptr) {
		if (ptx_tbl->ba_status == ba_status) {
			LEAVE();
			return ptx_tbl;
		}
		ptx_tbl = ptx_tbl->pnext;
	}

	LEAVE();
	return MNULL;
}

/********************************************************
			Global Functions
********************************************************/

#ifdef STA_SUPPORT
/**
 *  @brief This function fills the cap info
 *
 *  @param priv         A pointer to mlan_private structure
 *  @param pht_cap      A pointer to MrvlIETypes_HTCap_t structure
 *  @param bands        Band configuration
 *
 *  @return             N/A
 */
static void wlan_fill_cap_info(mlan_private *priv, HTCap_t *ht_cap, t_u16 bands)
{
	t_u32 usr_dot_11n_dev_cap;

	ENTER();

	if (bands & BAND_A)
		usr_dot_11n_dev_cap = priv->usr_dot_11n_dev_cap_a;
	else
		usr_dot_11n_dev_cap = priv->usr_dot_11n_dev_cap_bg;

	if (ISSUPP_CHANWIDTH40(usr_dot_11n_dev_cap))
		SETHT_SUPPCHANWIDTH(ht_cap->ht_cap_info);
	else
		RESETHT_SUPPCHANWIDTH(ht_cap->ht_cap_info);

	if (ISSUPP_GREENFIELD(usr_dot_11n_dev_cap))
		SETHT_GREENFIELD(ht_cap->ht_cap_info);
	else
		RESETHT_GREENFIELD(ht_cap->ht_cap_info);

	if (ISSUPP_SHORTGI20(usr_dot_11n_dev_cap))
		SETHT_SHORTGI20(ht_cap->ht_cap_info);
	else
		RESETHT_SHORTGI20(ht_cap->ht_cap_info);

	if (ISSUPP_SHORTGI40(usr_dot_11n_dev_cap))
		SETHT_SHORTGI40(ht_cap->ht_cap_info);
	else
		RESETHT_SHORTGI40(ht_cap->ht_cap_info);
	if (ISSUPP_RXSTBC(usr_dot_11n_dev_cap))
		SETHT_RXSTBC(ht_cap->ht_cap_info, 1);
	else
		RESETHT_RXSTBC(ht_cap->ht_cap_info);

	if (ISENABLED_40MHZ_INTOLARENT(usr_dot_11n_dev_cap))
		SETHT_40MHZ_INTOLARANT(ht_cap->ht_cap_info);
	else
		RESETHT_40MHZ_INTOLARANT(ht_cap->ht_cap_info);

	/** if current channel only allow 20Mhz, we should cler 40Mhz support */
	if (priv->curr_chan_flags & CHAN_FLAGS_NO_HT40PLUS &&
	    priv->curr_chan_flags & CHAN_FLAGS_NO_HT40MINUS) {
		RESETHT_SUPPCHANWIDTH(ht_cap->ht_cap_info);
		RESETHT_SHORTGI40(ht_cap->ht_cap_info);
		RESETHT_40MHZ_INTOLARANT(ht_cap->ht_cap_info);
	}
	/* No user config for LDPC coding capability yet */
	if (ISSUPP_RXLDPC(usr_dot_11n_dev_cap))
		SETHT_LDPCCODINGCAP(ht_cap->ht_cap_info);
	else
		RESETHT_LDPCCODINGCAP(ht_cap->ht_cap_info);

	/* No user config for TX STBC yet */
	if (ISSUPP_TXSTBC(usr_dot_11n_dev_cap))
		SETHT_TXSTBC(ht_cap->ht_cap_info);
	else
		RESETHT_TXSTBC(ht_cap->ht_cap_info);

	/* No user config for Delayed BACK yet */
	RESETHT_DELAYEDBACK(ht_cap->ht_cap_info);

	/* Need change to support 8k AMSDU receive */
	RESETHT_MAXAMSDU(ht_cap->ht_cap_info);

	/* SM power save */
	RESETHT_SM_POWERSAVE(ht_cap->ht_cap_info); /* Clear to HT SMPS static
						      mode*/
	if (ISSUPP_MIMOPS(usr_dot_11n_dev_cap)) {
		if (ISSUPP_SMPS_DYNAMIC_MODE(usr_dot_11n_dev_cap))
			SETHT_SMPS_DYNAMIC(ht_cap->ht_cap_info); /* Set to HT
								    SMPS dynamic
								    mode */
	} else {
		SETHT_SMPS_DISABLE(ht_cap->ht_cap_info); /* Disable HT SMPS */
	}

	LEAVE();
}

/**
 *  @brief This function clear the bit in cap info which we don't support
 *
 *  @param priv         A pointer to mlan_private structure
 *  @param pht_cap      A pointer to MrvlIETypes_HTCap_t structure
 *  @param bands        Band configuration
 *
 *  @return             N/A
 */
static void wlan_reset_cap_info(mlan_private *priv, HTCap_t *ht_cap,
				t_u16 bands)
{
	t_u32 usr_dot_11n_dev_cap;

	ENTER();

	if (bands & BAND_A)
		usr_dot_11n_dev_cap = priv->usr_dot_11n_dev_cap_a;
	else
		usr_dot_11n_dev_cap = priv->usr_dot_11n_dev_cap_bg;

	if (!ISSUPP_CHANWIDTH40(usr_dot_11n_dev_cap))
		RESETHT_SUPPCHANWIDTH(ht_cap->ht_cap_info);

	if (!ISSUPP_GREENFIELD(usr_dot_11n_dev_cap))
		RESETHT_GREENFIELD(ht_cap->ht_cap_info);

	if (!ISSUPP_SHORTGI20(usr_dot_11n_dev_cap))
		RESETHT_SHORTGI20(ht_cap->ht_cap_info);

	if (!ISSUPP_SHORTGI40(usr_dot_11n_dev_cap))
		RESETHT_SHORTGI40(ht_cap->ht_cap_info);
	if (!ISSUPP_RXSTBC(usr_dot_11n_dev_cap))
		RESETHT_RXSTBC(ht_cap->ht_cap_info);

	if (!ISENABLED_40MHZ_INTOLARENT(usr_dot_11n_dev_cap))
		RESETHT_40MHZ_INTOLARANT(ht_cap->ht_cap_info);

	/** if current channel only allow 20Mhz, we should cler 40Mhz support */
	if (priv->curr_chan_flags & CHAN_FLAGS_NO_HT40PLUS &&
	    priv->curr_chan_flags & CHAN_FLAGS_NO_HT40MINUS) {
		RESETHT_SUPPCHANWIDTH(ht_cap->ht_cap_info);
		RESETHT_SHORTGI40(ht_cap->ht_cap_info);
		RESETHT_40MHZ_INTOLARANT(ht_cap->ht_cap_info);
	}
	/* No user config for LDPC coding capability yet */
	if (!ISSUPP_RXLDPC(usr_dot_11n_dev_cap))
		RESETHT_LDPCCODINGCAP(ht_cap->ht_cap_info);

	/* No user config for TX STBC yet */
	if (!ISSUPP_TXSTBC(usr_dot_11n_dev_cap))
		RESETHT_TXSTBC(ht_cap->ht_cap_info);

	/* No user config for Delayed BACK yet */
	RESETHT_DELAYEDBACK(ht_cap->ht_cap_info);

	/* Need change to support 8k AMSDU receive */
	RESETHT_MAXAMSDU(ht_cap->ht_cap_info);
	/* SM power save */
	if (!ISSUPP_MIMOPS(usr_dot_11n_dev_cap))
		SETHT_SMPS_DISABLE(ht_cap->ht_cap_info); /* Disable HT SMPS */

	LEAVE();
}

/**
 *  @brief This function fills the HT cap tlv
 *
 *  @param priv         A pointer to mlan_private structure
 *  @param pht_cap      A pointer to MrvlIETypes_HTCap_t structure
 *  @param bands        Band configuration
 *  @param fill         A flag for fill the htcap info
 *
 *  @return             N/A
 */
void wlan_fill_ht_cap_tlv(mlan_private *priv, MrvlIETypes_HTCap_t *pht_cap,
			  t_u16 bands, t_u8 fill)
{
	mlan_adapter *pmadapter = priv->adapter;
	int rx_mcs_supp;
	t_u32 usr_dot_11n_dev_cap;

	ENTER();

	if (bands & BAND_A)
		usr_dot_11n_dev_cap = priv->usr_dot_11n_dev_cap_a;
	else
		usr_dot_11n_dev_cap = priv->usr_dot_11n_dev_cap_bg;

	/* Fill HT cap info */
	if (fill)
		wlan_fill_cap_info(priv, &pht_cap->ht_cap, bands);
	else
		wlan_reset_cap_info(priv, &pht_cap->ht_cap, bands);

	pht_cap->ht_cap.ht_cap_info =
		wlan_cpu_to_le16(pht_cap->ht_cap.ht_cap_info);

	/* Set ampdu param */
	SETAMPDU_SIZE(pht_cap->ht_cap.ampdu_param, AMPDU_FACTOR_64K);
	SETAMPDU_SPACING(pht_cap->ht_cap.ampdu_param, 0);

	rx_mcs_supp = GET_RXMCSSUPP(priv->usr_dev_mcs_support);
#if defined(PCIE9098) || defined(SD9098) || defined(USB9098) ||                \
	defined(PCIE9097) || defined(SD9097) || defined(USB9097) ||            \
	defined(SDNW62X) || defined(PCIENW62X) || defined(USBNW62X)
	if (IS_CARD9098(pmadapter->card_type) ||
	    IS_CARDNW62X(pmadapter->card_type) ||
	    IS_CARD9097(pmadapter->card_type)) {
		if (bands & BAND_A)
			rx_mcs_supp = MIN(
				rx_mcs_supp,
				GET_RXMCSSUPP(pmadapter->user_htstream >> 8));
		else
			rx_mcs_supp =
				MIN(rx_mcs_supp,
				    GET_RXMCSSUPP(pmadapter->user_htstream));
	}
#endif
	memset(pmadapter, (t_u8 *)pht_cap->ht_cap.supported_mcs_set, 0xff,
	       rx_mcs_supp);
	/* Clear all the other values to get the minimum mcs set btw STA and AP
	 */
	memset(pmadapter,
	       (t_u8 *)&pht_cap->ht_cap.supported_mcs_set[rx_mcs_supp], 0,
	       NUM_MCS_FIELD - rx_mcs_supp);
	/* Set MCS32 with 40MHz support */
	/* if current channel only support 20MHz, we should not set 40Mz
	 * supprot*/
	if (ISSUPP_CHANWIDTH40(usr_dot_11n_dev_cap) &&
	    !(priv->curr_chan_flags & CHAN_FLAGS_NO_HT40PLUS &&
	      priv->curr_chan_flags & CHAN_FLAGS_NO_HT40MINUS) &&
	    pmadapter->init_para.mcs32 == 1)
		SETHT_MCS32(pht_cap->ht_cap.supported_mcs_set);

	/* Clear RD responder bit */
	RESETHT_EXTCAP_RDG(pht_cap->ht_cap.ht_ext_cap);
	pht_cap->ht_cap.ht_ext_cap =
		wlan_cpu_to_le16(pht_cap->ht_cap.ht_ext_cap);

	/* Set Tx BF cap */
	pht_cap->ht_cap.tx_bf_cap = wlan_cpu_to_le32(priv->tx_bf_cap);

	LEAVE();
	return;
}

/**
 *  @brief This function fills the HT cap ie
 *
 *  @param priv         A pointer to mlan_private structure
 *  @param pht_cap      A pointer to IEEEtypes_HTCap_t structure
 *  @param bands        Band configuration
 *
 *  @return             N/A
 */
void wlan_fill_ht_cap_ie(mlan_private *priv, IEEEtypes_HTCap_t *pht_cap,
			 t_u16 bands)
{
	mlan_adapter *pmadapter = priv->adapter;
	int rx_mcs_supp;
	t_u32 usr_dot_11n_dev_cap;

	ENTER();

	pht_cap->ieee_hdr.element_id = HT_CAPABILITY;
	pht_cap->ieee_hdr.len = sizeof(HTCap_t);
	if (bands & BAND_A)
		usr_dot_11n_dev_cap = priv->usr_dot_11n_dev_cap_a;
	else
		usr_dot_11n_dev_cap = priv->usr_dot_11n_dev_cap_bg;

	/* Fill HT cap info */
	wlan_fill_cap_info(priv, &pht_cap->ht_cap, bands);

	/* Set ampdu param */
	SETAMPDU_SIZE(pht_cap->ht_cap.ampdu_param, AMPDU_FACTOR_64K);
	SETAMPDU_SPACING(pht_cap->ht_cap.ampdu_param, 0);

	rx_mcs_supp = GET_RXMCSSUPP(priv->usr_dev_mcs_support);
#if defined(PCIE9098) || defined(SD9098) || defined(USB9098) ||                \
	defined(PCIE9097) || defined(SD9097) || defined(USB9097) ||            \
	defined(SDNW62X) || defined(PCIENW62X) || defined(USBNW62X)
	if (IS_CARD9098(pmadapter->card_type) ||
	    IS_CARDNW62X(pmadapter->card_type) ||
	    IS_CARD9097(pmadapter->card_type)) {
		if (bands & BAND_A)
			rx_mcs_supp = MIN(
				rx_mcs_supp,
				GET_RXMCSSUPP(pmadapter->user_htstream >> 8));
		else
			rx_mcs_supp =
				MIN(rx_mcs_supp,
				    GET_RXMCSSUPP(pmadapter->user_htstream));
	}
#endif
	memset(pmadapter, (t_u8 *)pht_cap->ht_cap.supported_mcs_set, 0xff,
	       rx_mcs_supp);
	/* Clear all the other values to get the minimum mcs set btw STA and AP
	 */
	memset(pmadapter,
	       (t_u8 *)&pht_cap->ht_cap.supported_mcs_set[rx_mcs_supp], 0,
	       NUM_MCS_FIELD - rx_mcs_supp);
	/* Set MCS32 with 40MHz support */
	/* if current channel only support 20MHz, we should not set 40Mz
	 * supprot*/
	if (ISSUPP_CHANWIDTH40(usr_dot_11n_dev_cap) &&
	    !(priv->curr_chan_flags & CHAN_FLAGS_NO_HT40PLUS &&
	      priv->curr_chan_flags & CHAN_FLAGS_NO_HT40MINUS) &&
	    pmadapter->init_para.mcs32 == 1)
		SETHT_MCS32(pht_cap->ht_cap.supported_mcs_set);

	/* Clear RD responder bit */
	RESETHT_EXTCAP_RDG(pht_cap->ht_cap.ht_ext_cap);

	/* Set Tx BF cap */
	pht_cap->ht_cap.tx_bf_cap = priv->tx_bf_cap;

	LEAVE();
	return;
}
#endif /* STA_SUPPORT */

/**
 *  @brief This function prints the 802.11n device capability
 *
 *  @param pmadapter     A pointer to mlan_adapter structure
 *  @param cap           Capability value
 *
 *  @return        N/A
 */
void wlan_show_dot11ndevcap(pmlan_adapter pmadapter, t_u32 cap)
{
	ENTER();

	PRINTM(MINFO, "GET_HW_SPEC: Maximum MSDU length = %s octets\n",
	       (ISSUPP_MAXAMSDU(cap) ? "7935" : "3839"));
	PRINTM(MINFO, "GET_HW_SPEC: Beam forming %s\n",
	       (ISSUPP_BEAMFORMING(cap) ? "supported" : "not supported"));
	PRINTM(MINFO, "GET_HW_SPEC: Greenfield preamble %s\n",
	       (ISSUPP_GREENFIELD(cap) ? "supported" : "not supported"));
	PRINTM(MINFO, "GET_HW_SPEC: AMPDU %s\n",
	       (ISSUPP_AMPDU(cap) ? "supported" : "not supported"));
	PRINTM(MINFO, "GET_HW_SPEC: MIMO Power Save %s\n",
	       (ISSUPP_MIMOPS(cap) ? "supported" : "not supported"));
	PRINTM(MINFO, "GET_HW_SPEC: Rx STBC %s\n",
	       (ISSUPP_RXSTBC(cap) ? "supported" : "not supported"));
	PRINTM(MINFO, "GET_HW_SPEC: Tx STBC %s\n",
	       (ISSUPP_TXSTBC(cap) ? "supported" : "not supported"));
	PRINTM(MINFO, "GET_HW_SPEC: Short GI for 40 Mhz %s\n",
	       (ISSUPP_SHORTGI40(cap) ? "supported" : "not supported"));
	PRINTM(MINFO, "GET_HW_SPEC: Short GI for 20 Mhz %s\n",
	       (ISSUPP_SHORTGI20(cap) ? "supported" : "not supported"));
	PRINTM(MINFO, "GET_HW_SPEC: LDPC coded packet receive %s\n",
	       (ISSUPP_RXLDPC(cap) ? "supported" : "not supported"));

	PRINTM(MINFO, "GET_HW_SPEC: Number of Tx BA streams supported = %d\n",
	       ISSUPP_GETTXBASTREAM(cap));
	PRINTM(MINFO, "GET_HW_SPEC: 40 Mhz channel width %s\n",
	       (ISSUPP_CHANWIDTH40(cap) ? "supported" : "not supported"));
	PRINTM(MINFO, "GET_HW_SPEC: 20 Mhz channel width %s\n",
	       (ISSUPP_CHANWIDTH20(cap) ? "supported" : "not supported"));
	PRINTM(MINFO, "GET_HW_SPEC: 10 Mhz channel width %s\n",
	       (ISSUPP_CHANWIDTH10(cap) ? "supported" : "not supported"));

	if (ISSUPP_RXANTENNAA(cap))
		PRINTM(MINFO, "GET_HW_SPEC: Presence of Rx antenna A\n");
	if (ISSUPP_RXANTENNAB(cap))
		PRINTM(MINFO, "GET_HW_SPEC: Presence of Rx antenna B\n");
	if (ISSUPP_RXANTENNAC(cap))
		PRINTM(MINFO, "GET_HW_SPEC: Presence of Rx antenna C\n");
	if (ISSUPP_RXANTENNAD(cap))
		PRINTM(MINFO, "GET_HW_SPEC: Presence of Rx antenna D\n");
	if (ISSUPP_TXANTENNAA(cap))
		PRINTM(MINFO, "GET_HW_SPEC: Presence of Tx antenna A\n");
	if (ISSUPP_TXANTENNAB(cap))
		PRINTM(MINFO, "GET_HW_SPEC: Presence of Tx antenna B\n");
	if (ISSUPP_TXANTENNAC(cap))
		PRINTM(MINFO, "GET_HW_SPEC: Presence of Tx antenna C\n");
	if (ISSUPP_TXANTENNAD(cap))
		PRINTM(MINFO, "GET_HW_SPEC: Presence of Tx antenna D\n");

	LEAVE();
	return;
}

/**
 *  @brief This function prints the 802.11n device MCS
 *
 *  @param pmadapter A pointer to mlan_adapter structure
 *  @param support   Support value
 *
 *  @return        N/A
 */
void wlan_show_devmcssupport(pmlan_adapter pmadapter, t_u8 support)
{
	ENTER();

	PRINTM(MINFO, "GET_HW_SPEC: MCSs for %dx%d MIMO\n",
	       GET_RXMCSSUPP(support), GET_TXMCSSUPP(support));

	LEAVE();
	return;
}

/**
 *  @brief This function handles the command response of
 *              delete a block ack request
 *
 *  @param priv    A pointer to mlan_private structure
 *  @param resp    A pointer to HostCmd_DS_COMMAND
 *
 *  @return        MLAN_STATUS_SUCCESS
 */
mlan_status wlan_ret_11n_delba(mlan_private *priv, HostCmd_DS_COMMAND *resp)
{
	int tid;
	TxBAStreamTbl *ptx_ba_tbl;
	HostCmd_DS_11N_DELBA *pdel_ba =
		(HostCmd_DS_11N_DELBA *)&resp->params.del_ba;

	ENTER();

	pdel_ba->del_ba_param_set = wlan_le16_to_cpu(pdel_ba->del_ba_param_set);
	pdel_ba->reason_code = wlan_le16_to_cpu(pdel_ba->reason_code);

	tid = pdel_ba->del_ba_param_set >> DELBA_TID_POS;
	if (pdel_ba->del_result == BA_RESULT_SUCCESS) {
		mlan_11n_delete_bastream_tbl(
			priv, tid, pdel_ba->peer_mac_addr, TYPE_DELBA_SENT,
			INITIATOR_BIT(pdel_ba->del_ba_param_set), 0);
		wlan_request_ralist_lock(priv);
		ptx_ba_tbl = wlan_11n_get_txbastream_status(
			priv, BA_STREAM_SETUP_INPROGRESS);
		wlan_release_ralist_lock(priv);
		if (ptx_ba_tbl)
			wlan_send_addba(priv, ptx_ba_tbl->tid, ptx_ba_tbl->ra);
	} else { /*
		  * In case of failure, recreate
		  * the deleted stream in case
		  * we initiated the ADDBA
		  */
		if (INITIATOR_BIT(pdel_ba->del_ba_param_set)) {
			wlan_request_ralist_lock(priv);
			if (!wlan_11n_get_txbastream_tbl(
				    priv, tid, pdel_ba->peer_mac_addr, MFALSE))
				wlan_11n_create_txbastream_tbl(
					priv, pdel_ba->peer_mac_addr, tid,
					BA_STREAM_SETUP_INPROGRESS);
			ptx_ba_tbl = wlan_11n_get_txbastream_status(
				priv, BA_STREAM_SETUP_INPROGRESS);
			wlan_release_ralist_lock(priv);
			if (ptx_ba_tbl) {
				mlan_11n_delete_bastream_tbl(
					priv, ptx_ba_tbl->tid, ptx_ba_tbl->ra,
					TYPE_DELBA_SENT, MTRUE, 0);
			}
		}
	}

	LEAVE();
	return MLAN_STATUS_SUCCESS;
}

/**
 *  @brief This function handles the command response of
 *              add a block ack request
 *
 *  @param priv    A pointer to mlan_private structure
 *  @param resp    A pointer to HostCmd_DS_COMMAND
 *
 *  @return        MLAN_STATUS_SUCCESS
 */
mlan_status wlan_ret_11n_addba_req(mlan_private *priv, HostCmd_DS_COMMAND *resp)
{
	t_u8 tid;
	HostCmd_DS_11N_ADDBA_RSP *padd_ba_rsp =
		(HostCmd_DS_11N_ADDBA_RSP *)&resp->params.add_ba_rsp;
	TxBAStreamTbl *ptx_ba_tbl;
	raListTbl *ra_list = MNULL;
	int tid_down;

	ENTER();

	padd_ba_rsp->block_ack_param_set =
		wlan_le16_to_cpu(padd_ba_rsp->block_ack_param_set);
	padd_ba_rsp->block_ack_tmo =
		wlan_le16_to_cpu(padd_ba_rsp->block_ack_tmo);
	padd_ba_rsp->ssn = (wlan_le16_to_cpu(padd_ba_rsp->ssn)) & SSN_MASK;
	padd_ba_rsp->status_code = wlan_le16_to_cpu(padd_ba_rsp->status_code);

	tid = (padd_ba_rsp->block_ack_param_set & BLOCKACKPARAM_TID_MASK) >>
	      BLOCKACKPARAM_TID_POS;
	tid_down = wlan_get_wmm_tid_down(priv, tid);
	ra_list = wlan_wmm_get_ralist_node(priv, tid_down,
					   padd_ba_rsp->peer_mac_addr);
	if (padd_ba_rsp->status_code == BA_RESULT_SUCCESS) {
		ptx_ba_tbl = wlan_11n_get_txbastream_tbl(
			priv, tid, padd_ba_rsp->peer_mac_addr, MTRUE);
		if (ptx_ba_tbl) {
			PRINTM(MCMND,
			       "ADDBA REQ: " MACSTR
			       " tid=%d ssn=%d win_size=%d,amsdu=%d\n",
			       MAC2STR(padd_ba_rsp->peer_mac_addr), tid,
			       padd_ba_rsp->ssn,
			       ((padd_ba_rsp->block_ack_param_set &
				 BLOCKACKPARAM_WINSIZE_MASK) >>
				BLOCKACKPARAM_WINSIZE_POS),
			       padd_ba_rsp->block_ack_param_set &
				       BLOCKACKPARAM_AMSDU_SUPP_MASK);
			ptx_ba_tbl->ba_status = BA_STREAM_SETUP_COMPLETE;
			if ((padd_ba_rsp->block_ack_param_set &
			     BLOCKACKPARAM_AMSDU_SUPP_MASK) &&
			    priv->add_ba_param.tx_amsdu &&
			    (priv->aggr_prio_tbl[tid].amsdu !=
			     BA_STREAM_NOT_ALLOWED))
				ptx_ba_tbl->amsdu = MTRUE;
			else
				ptx_ba_tbl->amsdu = MFALSE;
			if (ra_list) {
				ra_list->amsdu_in_ampdu = ptx_ba_tbl->amsdu;
				ra_list->ba_status = BA_STREAM_SETUP_COMPLETE;
			}
		} else {
			PRINTM(MERROR, "BA stream not created\n");
		}
	} else {
		if (ra_list) {
			ra_list->amsdu_in_ampdu = MFALSE;
			ra_list->ba_status = BA_STREAM_NOT_SETUP;
		}
		mlan_11n_delete_bastream_tbl(priv, tid,
					     padd_ba_rsp->peer_mac_addr,
					     TYPE_DELBA_SENT, MTRUE, 0);
		if (padd_ba_rsp->add_rsp_result != BA_RESULT_TIMEOUT) {
#ifdef UAP_SUPPORT
			if (GET_BSS_ROLE(priv) == MLAN_BSS_ROLE_UAP)
				disable_station_ampdu(
					priv, tid, padd_ba_rsp->peer_mac_addr);
#endif /* UAP_SUPPORT */
			if (ra_list && ra_list->is_tdls_link)
				disable_station_ampdu(
					priv, tid, padd_ba_rsp->peer_mac_addr);
			priv->aggr_prio_tbl[tid].ampdu_ap =
				BA_STREAM_NOT_ALLOWED;

		} else {
			if (ra_list) {
				ra_list->packet_count = 0;
				ra_list->ba_packet_threshold =
					wlan_get_random_ba_threshold(
						priv->adapter);
			}
		}
	}

	LEAVE();
	return MLAN_STATUS_SUCCESS;
}

/**
 *  @brief This function restore tx_pause flag
 *
 *  @param priv         A pointer to mlan_private structure
 *  @param flag         MTRUE/MFALSE;
 *
 *  @return             N/A
 */
void wlan_set_tx_pause_flag(mlan_private *priv, t_u8 flag)
{
	mlan_private *pmpriv = MNULL;
	t_u8 i;
	for (i = 0; i < priv->adapter->priv_num; i++) {
		pmpriv = priv->adapter->priv[i];
		if (pmpriv)
			pmpriv->tx_pause = flag;
	}
}

/**
 *  @brief This function prepares command of reconfigure tx buf
 *
 *  @param priv         A pointer to mlan_private structure
 *  @param cmd          A pointer to HostCmd_DS_COMMAND structure
 *  @param cmd_action   The action: GET or SET
 *  @param pdata_buf    A pointer to data buffer
 *
 *  @return             MLAN_STATUS_SUCCESS
 */
mlan_status wlan_cmd_recfg_tx_buf(mlan_private *priv, HostCmd_DS_COMMAND *cmd,
				  int cmd_action, void *pdata_buf)
{
	HostCmd_DS_TXBUF_CFG *ptx_buf = &cmd->params.tx_buf;
	t_u16 action = (t_u16)cmd_action;
	t_u16 buf_size = *((t_u16 *)pdata_buf);

	ENTER();
	cmd->command = wlan_cpu_to_le16(HostCmd_CMD_RECONFIGURE_TX_BUFF);
	cmd->size = wlan_cpu_to_le16(sizeof(HostCmd_DS_TXBUF_CFG) + S_DS_GEN);
	ptx_buf->action = wlan_cpu_to_le16(action);
	switch (action) {
	case HostCmd_ACT_GEN_SET:
		PRINTM(MCMND, "set tx_buf = %d\n", buf_size);
		ptx_buf->buff_size = wlan_cpu_to_le16(buf_size);
		/** stop tx traffic */
		wlan_set_tx_pause_flag(priv, MTRUE);
		break;
	case HostCmd_ACT_GEN_GET:
	default:
		ptx_buf->buff_size = 0;
		break;
	}
	LEAVE();
	return MLAN_STATUS_SUCCESS;
}

/**
 *  @brief This function prepares command of amsdu aggr control
 *
 *  @param priv         A pointer to mlan_private structure
 *  @param cmd          A pointer to HostCmd_DS_COMMAND structure
 *  @param cmd_action   The action: GET or SET
 *  @param pdata_buf    A pointer to data buffer
 *
 *  @return             MLAN_STATUS_SUCCESS
 */
mlan_status wlan_cmd_amsdu_aggr_ctrl(mlan_private *priv,
				     HostCmd_DS_COMMAND *cmd, int cmd_action,
				     void *pdata_buf)
{
	HostCmd_DS_AMSDU_AGGR_CTRL *pamsdu_ctrl = &cmd->params.amsdu_aggr_ctrl;
	t_u16 action = (t_u16)cmd_action;
	mlan_ds_11n_amsdu_aggr_ctrl *aa_ctrl =
		(mlan_ds_11n_amsdu_aggr_ctrl *)pdata_buf;

	ENTER();

	cmd->command = wlan_cpu_to_le16(HostCmd_CMD_AMSDU_AGGR_CTRL);
	cmd->size =
		wlan_cpu_to_le16(sizeof(HostCmd_DS_AMSDU_AGGR_CTRL) + S_DS_GEN);
	pamsdu_ctrl->action = wlan_cpu_to_le16(action);
	switch (action) {
	case HostCmd_ACT_GEN_SET:
		pamsdu_ctrl->enable = wlan_cpu_to_le16(aa_ctrl->enable);
		pamsdu_ctrl->curr_buf_size = 0;
		break;
	case HostCmd_ACT_GEN_GET:
	default:
		pamsdu_ctrl->curr_buf_size = 0;
		break;
	}
	LEAVE();
	return MLAN_STATUS_SUCCESS;
}

/**
 *  @brief This function handles the command response of amsdu aggr ctrl
 *
 *  @param pmpriv       A pointer to mlan_private structure
 *  @param resp         A pointer to HostCmd_DS_COMMAND
 *  @param pioctl_buf   A pointer to mlan_ioctl_req structure
 *
 *  @return        MLAN_STATUS_SUCCESS
 */
mlan_status wlan_ret_amsdu_aggr_ctrl(pmlan_private pmpriv,
				     HostCmd_DS_COMMAND *resp,
				     mlan_ioctl_req *pioctl_buf)
{
	mlan_ds_11n_cfg *cfg = MNULL;
	HostCmd_DS_AMSDU_AGGR_CTRL *amsdu_ctrl = &resp->params.amsdu_aggr_ctrl;

	ENTER();

	if (pioctl_buf) {
		cfg = (mlan_ds_11n_cfg *)pioctl_buf->pbuf;
		cfg->param.amsdu_aggr_ctrl.enable =
			wlan_le16_to_cpu(amsdu_ctrl->enable);
		cfg->param.amsdu_aggr_ctrl.curr_buf_size =
			wlan_le16_to_cpu(amsdu_ctrl->curr_buf_size);
	}
	LEAVE();
	return MLAN_STATUS_SUCCESS;
}

/**
 *  @brief This function prepares 11n cfg command
 *
 *  @param pmpriv       A pointer to mlan_private structure
 *  @param cmd          A pointer to HostCmd_DS_COMMAND structure
 *  @param cmd_action   the action: GET or SET
 *  @param pdata_buf    A pointer to data buffer
 *  @return             MLAN_STATUS_SUCCESS
 */
mlan_status wlan_cmd_11n_cfg(pmlan_private pmpriv, HostCmd_DS_COMMAND *cmd,
			     t_u16 cmd_action, t_void *pdata_buf)
{
	HostCmd_DS_11N_CFG *htcfg = &cmd->params.htcfg;
	mlan_ds_11n_tx_cfg *txcfg = (mlan_ds_11n_tx_cfg *)pdata_buf;

	ENTER();
	cmd->command = wlan_cpu_to_le16(HostCmd_CMD_11N_CFG);
	cmd->size = wlan_cpu_to_le16(sizeof(HostCmd_DS_11N_CFG) + S_DS_GEN);
	htcfg->action = wlan_cpu_to_le16(cmd_action);
	htcfg->ht_tx_cap = wlan_cpu_to_le16(txcfg->httxcap);
	htcfg->ht_tx_info = wlan_cpu_to_le16(txcfg->httxinfo);
	htcfg->misc_config = wlan_cpu_to_le16(txcfg->misc_cfg);
	LEAVE();
	return MLAN_STATUS_SUCCESS;
}

/**
 *  @brief This function handles the command response of 11ncfg
 *
 *  @param pmpriv       A pointer to mlan_private structure
 *  @param resp         A pointer to HostCmd_DS_COMMAND
 *  @param pioctl_buf   A pointer to mlan_ioctl_req structure
 *
 *  @return        MLAN_STATUS_SUCCESS
 */
mlan_status wlan_ret_11n_cfg(pmlan_private pmpriv, HostCmd_DS_COMMAND *resp,
			     mlan_ioctl_req *pioctl_buf)
{
	mlan_ds_11n_cfg *cfg = MNULL;
	HostCmd_DS_11N_CFG *htcfg = &resp->params.htcfg;

	ENTER();
	if (pioctl_buf &&
	    (wlan_le16_to_cpu(htcfg->action) == HostCmd_ACT_GEN_GET)) {
		cfg = (mlan_ds_11n_cfg *)pioctl_buf->pbuf;
		cfg->param.tx_cfg.httxcap = wlan_le16_to_cpu(htcfg->ht_tx_cap);
		cfg->param.tx_cfg.httxinfo =
			wlan_le16_to_cpu(htcfg->ht_tx_info);
		cfg->param.tx_cfg.misc_cfg =
			wlan_le16_to_cpu(htcfg->misc_config);
	}
	LEAVE();
	return MLAN_STATUS_SUCCESS;
}

/**
 *  @brief This function prepares reject addba req command
 *
 *  @param pmpriv       A pointer to mlan_private structure
 *  @param cmd          A pointer to HostCmd_DS_COMMAND structure
 *  @param cmd_action   the action: GET or SET
 *  @param pdata_buf    A pointer to data buffer
 *  @return             MLAN_STATUS_SUCCESS
 */
mlan_status wlan_cmd_reject_addba_req(pmlan_private pmpriv,
				      HostCmd_DS_COMMAND *cmd, t_u16 cmd_action,
				      t_void *pdata_buf)
{
	HostCmd_DS_REJECT_ADDBA_REQ *preject_addba_req =
		&cmd->params.rejectaddbareq;
	mlan_ds_reject_addba_req *prejaddbareq =
		(mlan_ds_reject_addba_req *)pdata_buf;

	ENTER();
	cmd->command = wlan_cpu_to_le16(HostCmd_CMD_REJECT_ADDBA_REQ);
	cmd->size = wlan_cpu_to_le16(sizeof(HostCmd_DS_REJECT_ADDBA_REQ) +
				     S_DS_GEN);
	preject_addba_req->action = wlan_cpu_to_le16(cmd_action);
	preject_addba_req->conditions =
		wlan_cpu_to_le32(prejaddbareq->conditions);
	LEAVE();
	return MLAN_STATUS_SUCCESS;
}

/**
 *  @brief This function handles the command response of reject addba req
 *
 *  @param pmpriv       A pointer to mlan_private structure
 *  @param resp         A pointer to HostCmd_DS_COMMAND
 *  @param pioctl_buf   A pointer to mlan_ioctl_req structure
 *
 *  @return        MLAN_STATUS_SUCCESS
 */
mlan_status wlan_ret_reject_addba_req(pmlan_private pmpriv,
				      HostCmd_DS_COMMAND *resp,
				      mlan_ioctl_req *pioctl_buf)
{
	mlan_ds_11n_cfg *cfg = MNULL;
	HostCmd_DS_REJECT_ADDBA_REQ *preject_addba_req =
		&resp->params.rejectaddbareq;

	ENTER();
	if (pioctl_buf && (wlan_le16_to_cpu(preject_addba_req->action) ==
			   HostCmd_ACT_GEN_GET)) {
		cfg = (mlan_ds_11n_cfg *)pioctl_buf->pbuf;
		cfg->param.reject_addba_req.conditions =
			wlan_le32_to_cpu(preject_addba_req->conditions);
	}
	LEAVE();
	return MLAN_STATUS_SUCCESS;
}

/**
 *  @brief This function prepares TX BF configuration command
 *
 *  @param pmpriv       A pointer to mlan_private structure
 *  @param cmd          A pointer to HostCmd_DS_COMMAND structure
 *  @param cmd_action   The action: GET or SET
 *  @param pdata_buf    A pointer to data buffer
 *  @return             MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
 */
mlan_status wlan_cmd_tx_bf_cfg(pmlan_private pmpriv, HostCmd_DS_COMMAND *cmd,
			       t_u16 cmd_action, t_void *pdata_buf)
{
	pmlan_adapter pmadapter = pmpriv->adapter;
	HostCmd_DS_TX_BF_CFG *txbfcfg = &cmd->params.tx_bf_cfg;
	mlan_ds_11n_tx_bf_cfg *txbf = (mlan_ds_11n_tx_bf_cfg *)pdata_buf;

	ENTER();

	cmd->command = wlan_cpu_to_le16(HostCmd_CMD_TX_BF_CFG);
	cmd->size = wlan_cpu_to_le16(sizeof(HostCmd_DS_TX_BF_CFG) + S_DS_GEN);

	if (txbf->bf_action == SET_GET_BF_PERIODICITY) {
		memcpy_ext(pmadapter, txbfcfg->body.bf_periodicity.peer_mac,
			   txbf->body.bf_periodicity[0].peer_mac,
			   MLAN_MAC_ADDR_LENGTH, MLAN_MAC_ADDR_LENGTH);
	}
	txbfcfg->action = wlan_cpu_to_le16(txbf->action);
	txbfcfg->bf_action = wlan_cpu_to_le16(txbf->bf_action);
	if (cmd_action == HostCmd_ACT_GEN_SET) {
		switch (txbf->bf_action) {
		case BF_GLOBAL_CONFIGURATION:
			txbfcfg->body.bf_global_cfg.bf_enbl =
				txbf->body.bf_global_cfg.bf_enbl;
			txbfcfg->body.bf_global_cfg.sounding_enbl =
				txbf->body.bf_global_cfg.sounding_enbl;
			txbfcfg->body.bf_global_cfg.fb_type =
				txbf->body.bf_global_cfg.fb_type;
			txbfcfg->body.bf_global_cfg.snr_threshold =
				txbf->body.bf_global_cfg.snr_threshold;
			txbfcfg->body.bf_global_cfg.sounding_interval =
				wlan_cpu_to_le16(txbf->body.bf_global_cfg
							 .sounding_interval);
			txbfcfg->body.bf_global_cfg.bf_mode =
				txbf->body.bf_global_cfg.bf_mode;
			break;
		case TRIGGER_SOUNDING_FOR_PEER:
			memcpy_ext(pmadapter,
				   txbfcfg->body.bf_sound_args.peer_mac,
				   txbf->body.bf_sound[0].peer_mac,
				   MLAN_MAC_ADDR_LENGTH, MLAN_MAC_ADDR_LENGTH);
			break;
		case SET_GET_BF_PERIODICITY:
			txbfcfg->body.bf_periodicity.interval =
				wlan_cpu_to_le16(
					txbf->body.bf_periodicity->interval);
			break;
		case TX_BF_FOR_PEER_ENBL:
			memcpy_ext(pmadapter, txbfcfg->body.tx_bf_peer.peer_mac,
				   txbf->body.tx_bf_peer[0].peer_mac,
				   MLAN_MAC_ADDR_LENGTH, MLAN_MAC_ADDR_LENGTH);
			txbfcfg->body.tx_bf_peer.bf_enbl =
				txbf->body.tx_bf_peer[0].bf_enbl;
			txbfcfg->body.tx_bf_peer.sounding_enbl =
				txbf->body.tx_bf_peer[0].sounding_enbl;
			txbfcfg->body.tx_bf_peer.fb_type =
				txbf->body.tx_bf_peer[0].fb_type;
			break;
		case SET_SNR_THR_PEER:
			memcpy_ext(pmadapter, txbfcfg->body.bf_snr.peer_mac,
				   txbf->body.bf_snr[0].peer_mac,
				   MLAN_MAC_ADDR_LENGTH, MLAN_MAC_ADDR_LENGTH);
			txbfcfg->body.bf_snr.snr = txbf->body.bf_snr[0].snr;
			break;
		default:
			LEAVE();
			return MLAN_STATUS_FAILURE;
		}
	}

	LEAVE();
	return MLAN_STATUS_SUCCESS;
}

/**
 *  @brief This function handles the command response
 *  of TX BF configuration
 *
 *  @param pmpriv       A pointer to mlan_private structure
 *  @param resp         A pointer to HostCmd_DS_COMMAND
 *  @param pioctl_buf   A pointer to mlan_ioctl_req structure
 *
 *  @return        MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
 */
mlan_status wlan_ret_tx_bf_cfg(pmlan_private pmpriv, HostCmd_DS_COMMAND *resp,
			       mlan_ioctl_req *pioctl_buf)
{
	pmlan_adapter pmadapter = pmpriv->adapter;
	HostCmd_DS_TX_BF_CFG *txbfcfg = &resp->params.tx_bf_cfg;
	mlan_ds_11n_cfg *cfg_11n = MNULL;
	mlan_ds_11n_tx_bf_cfg *txbf = MNULL;
	bf_peer_args *tx_bf_peer;
	bf_snr_thr_t *bf_snr;
	int i;

	ENTER();

	if (pioctl_buf) {
		cfg_11n = (mlan_ds_11n_cfg *)pioctl_buf->pbuf;
		txbf = (mlan_ds_11n_tx_bf_cfg *)&cfg_11n->param.tx_bf;
		txbf->bf_action = wlan_le16_to_cpu(txbfcfg->bf_action);
		switch (txbf->bf_action) {
		case BF_GLOBAL_CONFIGURATION:
			txbf->body.bf_global_cfg.bf_enbl =
				txbfcfg->body.bf_global_cfg.bf_enbl;
			txbf->body.bf_global_cfg.sounding_enbl =
				txbfcfg->body.bf_global_cfg.sounding_enbl;
			txbf->body.bf_global_cfg.fb_type =
				txbfcfg->body.bf_global_cfg.fb_type;
			txbf->body.bf_global_cfg.snr_threshold =
				txbfcfg->body.bf_global_cfg.snr_threshold;
			txbf->body.bf_global_cfg.sounding_interval =
				wlan_le16_to_cpu(txbfcfg->body.bf_global_cfg
							 .sounding_interval);
			txbf->body.bf_global_cfg.bf_mode =
				txbfcfg->body.bf_global_cfg.bf_mode;
			break;
		case TRIGGER_SOUNDING_FOR_PEER:
			memcpy_ext(pmadapter, txbf->body.bf_sound[0].peer_mac,
				   txbfcfg->body.bf_sound_args.peer_mac,
				   MLAN_MAC_ADDR_LENGTH, MLAN_MAC_ADDR_LENGTH);
			txbf->body.bf_sound[0].status =
				txbfcfg->body.bf_sound_args.status;
			break;
		case SET_GET_BF_PERIODICITY:
			memcpy_ext(pmadapter,
				   txbf->body.bf_periodicity->peer_mac,
				   txbfcfg->body.bf_periodicity.peer_mac,
				   MLAN_MAC_ADDR_LENGTH, MLAN_MAC_ADDR_LENGTH);
			txbf->body.bf_periodicity->interval = wlan_le16_to_cpu(
				txbfcfg->body.bf_periodicity.interval);
			break;
		case TX_BF_FOR_PEER_ENBL:
			txbf->no_of_peers = *(t_u8 *)&txbfcfg->body;
			tx_bf_peer = (bf_peer_args *)((t_u8 *)&txbfcfg->body +
						      sizeof(t_u8));
			for (i = 0; i < (int)txbf->no_of_peers; i++) {
				memcpy_ext(pmadapter,
					   txbf->body.tx_bf_peer[i].peer_mac,
					   (t_u8 *)tx_bf_peer->peer_mac,
					   MLAN_MAC_ADDR_LENGTH,
					   MLAN_MAC_ADDR_LENGTH);
				txbf->body.tx_bf_peer[i].bf_enbl =
					tx_bf_peer->bf_enbl;
				txbf->body.tx_bf_peer[i].sounding_enbl =
					tx_bf_peer->sounding_enbl;
				txbf->body.tx_bf_peer[i].fb_type =
					tx_bf_peer->fb_type;
				tx_bf_peer++;
			}
			break;
		case SET_SNR_THR_PEER:
			txbf->no_of_peers = *(t_u8 *)&txbfcfg->body;
			bf_snr = (bf_snr_thr_t *)((t_u8 *)&txbfcfg->body +
						  sizeof(t_u8));
			for (i = 0; i < (int)txbf->no_of_peers; i++) {
				memcpy_ext(pmadapter,
					   txbf->body.bf_snr[i].peer_mac,
					   (t_u8 *)bf_snr->peer_mac,
					   MLAN_MAC_ADDR_LENGTH,
					   MLAN_MAC_ADDR_LENGTH);
				txbf->body.bf_snr[i].snr = bf_snr->snr;
				bf_snr++;
			}
			break;
		default:
			LEAVE();
			return MLAN_STATUS_FAILURE;
		}
	}

	LEAVE();
	return MLAN_STATUS_SUCCESS;
}

/**
 * @brief Get second channel offset
 *
 * @param chan            channel num
 * @return                second channel offset
 */
t_u8 wlan_get_second_channel_offset(mlan_private *priv, int chan)
{
	t_u8 chan2Offset = SEC_CHAN_NONE;

	/* Special Case: 20Mhz-only Channel */
	if (priv->adapter->region_code != COUNTRY_CODE_US && chan == 165)
		return chan2Offset;

	switch (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:
		chan2Offset = SEC_CHAN_ABOVE;
		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:
		chan2Offset = SEC_CHAN_BELOW;
		break;
	}
	return chan2Offset;
}

#ifdef STA_SUPPORT
/**
 *  @brief validate the channel offset for Infra/Ad-hoc band configuration
 *
 *  @param pmpriv       A pointer to mlan_private structure
 *  @param band         band
 *  @param chan         primary channel
 *  @param chan_bw      channel bandwidth
 *
 *  @return             channel offset (NO_SEC_CHANNEL, SEC_CHANNEL_ABOVE,
 *                                      SEC_CHANNEL_BELOW)
 */
t_u8 wlan_validate_chan_offset(mlan_private *pmpriv, t_u16 band, t_u32 chan,
			       t_u8 chan_bw)
{
	t_u8 chan_offset;
	pmlan_adapter pmadapter = pmpriv->adapter;

	if (chan_bw == CHANNEL_BW_40MHZ_ABOVE)
		chan_offset = SEC_CHAN_ABOVE;
	else if (chan_bw == CHANNEL_BW_40MHZ_BELOW)
		chan_offset = SEC_CHAN_BELOW;
	else
		chan_offset = SEC_CHAN_NONE;

	/* validation */
	if (chan_offset != SEC_CHAN_NONE) {
		if (band & BAND_GN) {
			if ((chan == 1) || (chan == 2) || (chan == 3) ||
			    (chan == 4))
				chan_offset = SEC_CHAN_ABOVE;
			else if ((chan == 10) || (chan == 11) || (chan == 12) ||
				 (chan == 13))
				chan_offset = SEC_CHAN_BELOW;

			/* check if channel 12 is supported in the region */
			if (!wlan_find_cfp_by_band_and_channel(pmadapter, band,
							       12))
				if ((chan == 8) || (chan == 9))
					chan_offset = SEC_CHAN_BELOW;
		} else if (band & BAND_AN)
			chan_offset =
				wlan_get_second_channel_offset(pmpriv, chan);
	}
	return chan_offset;
}

/**
 *  @brief This function check if ht40 is allowed in current region
 *
 *  @param pmpriv       A pointer to mlan_private structure
 *  @param pbss_desc    A pointer to BSSDescriptor_t structure
 *
 *  @return MTRUE/MFALSE
 */
static int wlan_check_chan_width_ht40_by_region(mlan_private *pmpriv,
						BSSDescriptor_t *pbss_desc)
{
	pmlan_adapter pmadapter = pmpriv->adapter;
	int i = 0;
	int cover_pri_chan = MFALSE;
	t_u8 pri_chan;
	t_u8 chan_offset;
	t_u8 num_cfp;

	ENTER();

	if (pbss_desc->pht_info == MNULL) {
		PRINTM(MERROR, "ht_info pointer NULL, force use HT20\n");
		LEAVE();
		return MFALSE;
	}
	if (pmpriv->curr_chan_flags & CHAN_FLAGS_NO_HT40PLUS &&
	    pmpriv->curr_chan_flags & CHAN_FLAGS_NO_HT40MINUS) {
		LEAVE();
		return MFALSE;
	}

	pri_chan = pbss_desc->pht_info->ht_info.pri_chan;
	chan_offset = GET_SECONDARYCHAN(pbss_desc->pht_info->ht_info.field2);
	if ((chan_offset == SEC_CHAN_ABOVE) &&
	    (pmpriv->curr_chan_flags & CHAN_FLAGS_NO_HT40PLUS)) {
		pmpriv->curr_chan_flags |=
			CHAN_FLAGS_NO_HT40MINUS | CHAN_FLAGS_NO_80MHZ;
		return MFALSE;
	}
	if ((chan_offset == SEC_CHAN_BELOW) &&
	    (pmpriv->curr_chan_flags & CHAN_FLAGS_NO_HT40MINUS)) {
		pmpriv->curr_chan_flags |=
			CHAN_FLAGS_NO_HT40PLUS | CHAN_FLAGS_NO_80MHZ;
		return MFALSE;
	}
	if (pmpriv->curr_chan_flags & CHAN_FLAGS_MAX)
		return MTRUE;

	num_cfp = pmadapter->region_channel[0].num_cfp;

	if ((pbss_desc->bss_band & (BAND_B | BAND_G)) &&
	    pmadapter->region_channel[0].valid) {
		for (i = 0; i < num_cfp; i++) {
			if (pri_chan ==
			    pmadapter->region_channel[0].pcfp[i].channel) {
				cover_pri_chan = MTRUE;
				break;
			}
		}
		if (!cover_pri_chan) {
			PRINTM(MERROR, "Invalid channel, force use HT20\n");
			LEAVE();
			return MFALSE;
		}

		if (chan_offset == SEC_CHAN_ABOVE) {
			if (pri_chan > num_cfp - 4) {
				PRINTM(MERROR,
				       "Invalid second channel offset, force use HT20\n");
				LEAVE();
				return MFALSE;
			}
		}
	}
	LEAVE();
	return MTRUE;
}

/**
 *  @brief This function append the 802_11N tlv
 *
 *  @param pmpriv       A pointer to mlan_private structure
 *  @param pbss_desc    A pointer to BSSDescriptor_t structure
 *  @param ppbuffer     A Pointer to command buffer pointer
 *
 *  @return bytes added to the buffer
 */
int wlan_cmd_append_11n_tlv(mlan_private *pmpriv, BSSDescriptor_t *pbss_desc,
			    t_u8 **ppbuffer)
{
	pmlan_adapter pmadapter = pmpriv->adapter;
	MrvlIETypes_HTCap_t *pht_cap;
	MrvlIEtypes_ChanListParamSet_t *pchan_list;
	MrvlIETypes_2040BSSCo_t *p2040_bss_co;
	MrvlIETypes_ExtCap_t *pext_cap;
	t_u32 usr_dot_11n_dev_cap, orig_usr_dot_11n_dev_cap = 0;
	t_u8 usr_dot_11ac_bw;
	int ret_len = 0;

	ENTER();

	/* Null Checks */
	if (ppbuffer == MNULL) {
		LEAVE();
		return 0;
	}
	if (*ppbuffer == MNULL) {
		LEAVE();
		return 0;
	}
	if (pbss_desc == MNULL) {
		LEAVE();
		return 0;
	}

	if (pbss_desc->bss_band & BAND_A)
		usr_dot_11n_dev_cap = pmpriv->usr_dot_11n_dev_cap_a;
	else
		usr_dot_11n_dev_cap = pmpriv->usr_dot_11n_dev_cap_bg;

	if (pmpriv->bss_mode == MLAN_BSS_MODE_IBSS)
		usr_dot_11ac_bw = BW_FOLLOW_VHTCAP;
	else
		usr_dot_11ac_bw = pmpriv->usr_dot_11ac_bw;
	if ((pbss_desc->bss_band & (BAND_B | BAND_G | BAND_A)) &&
	    ISSUPP_CHANWIDTH40(usr_dot_11n_dev_cap) &&
	    !wlan_check_chan_width_ht40_by_region(pmpriv, pbss_desc)) {
		orig_usr_dot_11n_dev_cap = usr_dot_11n_dev_cap;
		RESETSUPP_CHANWIDTH40(usr_dot_11n_dev_cap);
		RESET_40MHZ_INTOLARENT(usr_dot_11n_dev_cap);
		RESETSUPP_SHORTGI40(usr_dot_11n_dev_cap);
		pmpriv->usr_dot_11n_dev_cap_bg = usr_dot_11n_dev_cap;
		pbss_desc->curr_bandwidth = BW_20MHZ;
	}
	if (pbss_desc->pht_cap) {
		pht_cap = (MrvlIETypes_HTCap_t *)*ppbuffer;
		memset(pmadapter, pht_cap, 0, sizeof(MrvlIETypes_HTCap_t));
		pht_cap->header.type = wlan_cpu_to_le16(HT_CAPABILITY);
		pht_cap->header.len = sizeof(HTCap_t);
		memcpy_ext(pmadapter,
			   (t_u8 *)pht_cap + sizeof(MrvlIEtypesHeader_t),
			   (t_u8 *)pbss_desc->pht_cap +
				   sizeof(IEEEtypes_Header_t),
			   pht_cap->header.len, pht_cap->header.len);

		pht_cap->ht_cap.ht_cap_info =
			wlan_le16_to_cpu(pht_cap->ht_cap.ht_cap_info);
		pht_cap->ht_cap.ht_ext_cap =
			wlan_le16_to_cpu(pht_cap->ht_cap.ht_ext_cap);
		wlan_fill_ht_cap_tlv(pmpriv, pht_cap, pbss_desc->bss_band,
				     MTRUE);

		/** check if need support 80+80MHZ */
		/** reset the 2 spatial stream rate for 80 + 80 Mhz */
		if (wlan_is_80_80_support(pmpriv, pbss_desc))
			pht_cap->ht_cap.supported_mcs_set[1] = 0;
		HEXDUMP("HT_CAPABILITIES IE", (t_u8 *)pht_cap,
			sizeof(MrvlIETypes_HTCap_t));
		*ppbuffer += sizeof(MrvlIETypes_HTCap_t);
		ret_len += sizeof(MrvlIETypes_HTCap_t);
		pht_cap->header.len = wlan_cpu_to_le16(pht_cap->header.len);
	} else {
		// AP don't support 11N
		LEAVE();
		return 0;
	}

	if (pbss_desc->pht_info) {
		pchan_list = (MrvlIEtypes_ChanListParamSet_t *)*ppbuffer;
		memset(pmadapter, pchan_list, 0,
		       sizeof(MrvlIEtypes_ChanListParamSet_t));
		pchan_list->header.type = wlan_cpu_to_le16(TLV_TYPE_CHANLIST);
		pchan_list->header.len =
			sizeof(MrvlIEtypes_ChanListParamSet_t) -
			sizeof(MrvlIEtypesHeader_t);
		pchan_list->chan_scan_param[0].chan_number =
			pbss_desc->pht_info->ht_info.pri_chan;
		pchan_list->chan_scan_param[0].bandcfg.chanBand =
			wlan_band_to_radio_type(pbss_desc->bss_band);
		/* support the VHT if the network to be join has the VHT
		 * operation */
		if (ISSUPP_11ACENABLED(pmadapter->fw_cap_info) &&
		    (usr_dot_11ac_bw == BW_FOLLOW_VHTCAP) &&
		    (!(pmpriv->curr_chan_flags & CHAN_FLAGS_NO_80MHZ)) &&
		    wlan_11ac_bandconfig_allowed(pmpriv, pbss_desc->bss_band) &&
		    pbss_desc->pvht_oprat &&
		    pbss_desc->pvht_oprat->chan_width == VHT_OPER_CHWD_80MHZ) {
			pchan_list->chan_scan_param[0].bandcfg.chanWidth =
				CHAN_BW_80MHZ;
			pchan_list->chan_scan_param[0].bandcfg.chan2Offset =
				GET_SECONDARYCHAN(
					pbss_desc->pht_info->ht_info.field2);
			pbss_desc->curr_bandwidth = BW_80MHZ;
		} else if (ISSUPP_CHANWIDTH40(usr_dot_11n_dev_cap) &&
			   ISALLOWED_CHANWIDTH40(
				   pbss_desc->pht_info->ht_info.field2) &&
			   wlan_check_chan_width_ht40_by_region(pmpriv,
								pbss_desc)) {
			pchan_list->chan_scan_param[0].bandcfg.chan2Offset =
				GET_SECONDARYCHAN(
					pbss_desc->pht_info->ht_info.field2);
			pbss_desc->curr_bandwidth = BW_40MHZ;
			pchan_list->chan_scan_param[0].bandcfg.chanWidth =
				CHAN_BW_40MHZ;
		}
		pchan_list->chan_scan_param[0].bandcfg.scanMode =
			SCAN_MODE_USER;
		HEXDUMP("ChanList", (t_u8 *)pchan_list,
			sizeof(MrvlIEtypes_ChanListParamSet_t));
		HEXDUMP("pht_info", (t_u8 *)pbss_desc->pht_info,
			sizeof(MrvlIETypes_HTInfo_t) - 2);
		*ppbuffer += sizeof(MrvlIEtypes_ChanListParamSet_t);
		ret_len += sizeof(MrvlIEtypes_ChanListParamSet_t);
		pchan_list->header.len =
			wlan_cpu_to_le16(pchan_list->header.len);
	}

	if (pbss_desc->pbss_co_2040) {
		p2040_bss_co = (MrvlIETypes_2040BSSCo_t *)*ppbuffer;
		memset(pmadapter, p2040_bss_co, 0,
		       sizeof(MrvlIETypes_2040BSSCo_t));
		p2040_bss_co->header.type = wlan_cpu_to_le16(BSSCO_2040);
		p2040_bss_co->header.len = sizeof(BSSCo2040_t);

		memcpy_ext(pmadapter,
			   (t_u8 *)p2040_bss_co + sizeof(MrvlIEtypesHeader_t),
			   (t_u8 *)pbss_desc->pbss_co_2040 +
				   sizeof(IEEEtypes_Header_t),
			   p2040_bss_co->header.len, p2040_bss_co->header.len);

		HEXDUMP("20/40 BSS Coexistence IE", (t_u8 *)p2040_bss_co,
			sizeof(MrvlIETypes_2040BSSCo_t));
		*ppbuffer += sizeof(MrvlIETypes_2040BSSCo_t);
		ret_len += sizeof(MrvlIETypes_2040BSSCo_t);
		p2040_bss_co->header.len =
			wlan_cpu_to_le16(p2040_bss_co->header.len);
	}

	if (pbss_desc->pext_cap) {
		pext_cap = (MrvlIETypes_ExtCap_t *)*ppbuffer;
		memset(pmadapter, pext_cap, 0, sizeof(MrvlIETypes_ExtCap_t));
		pext_cap->header.type = wlan_cpu_to_le16(EXT_CAPABILITY);
		pext_cap->header.len = sizeof(ExtCap_t);

		memcpy_ext(pmadapter,
			   (t_u8 *)pext_cap + sizeof(MrvlIEtypesHeader_t),
			   (t_u8 *)&pmpriv->ext_cap, sizeof(ExtCap_t),
			   pext_cap->header.len);
		if (pbss_desc && pbss_desc->multi_bssid_ap)
			SET_EXTCAP_MULTI_BSSID(pext_cap->ext_cap);
		if (!pmadapter->ecsa_enable)
			RESET_EXTCAP_EXT_CHANNEL_SWITCH(pext_cap->ext_cap);
		else
			SET_EXTCAP_EXT_CHANNEL_SWITCH(pext_cap->ext_cap);

		HEXDUMP("Extended Capabilities IE", (t_u8 *)pext_cap,
			sizeof(MrvlIETypes_ExtCap_t));
		*ppbuffer += sizeof(MrvlIETypes_ExtCap_t);
		ret_len += sizeof(MrvlIETypes_ExtCap_t);
		pext_cap->header.len = wlan_cpu_to_le16(pext_cap->header.len);
	} else if (wlan_is_ext_capa_support(pmpriv) ||
		   (pmpriv->config_bands & BAND_AAC)) {
		wlan_add_ext_capa_info_ie(pmpriv, pbss_desc, ppbuffer);
		ret_len += sizeof(MrvlIETypes_ExtCap_t);
	}
	PRINTM(MCMND, "curr_bandwidth=%d\n", pbss_desc->curr_bandwidth);
	if (orig_usr_dot_11n_dev_cap)
		pmpriv->usr_dot_11n_dev_cap_bg = orig_usr_dot_11n_dev_cap;

	LEAVE();
	return ret_len;
}

#endif /* STA_SUPPORT */

/**
 *  @brief 11n configuration handler
 *
 *  @param pmadapter	A pointer to mlan_adapter structure
 *  @param pioctl_req	A pointer to ioctl request buffer
 *
 *  @return		MLAN_STATUS_SUCCESS --success, otherwise fail
 */
mlan_status wlan_11n_cfg_ioctl(pmlan_adapter pmadapter,
			       pmlan_ioctl_req pioctl_req)
{
	mlan_status status = MLAN_STATUS_SUCCESS;
	mlan_ds_11n_cfg *cfg = MNULL;

	ENTER();

	if (pioctl_req->buf_len < sizeof(mlan_ds_11n_cfg)) {
		PRINTM(MINFO, "MLAN bss IOCTL length is too short.\n");
		pioctl_req->data_read_written = 0;
		pioctl_req->buf_len_needed = sizeof(mlan_ds_11n_cfg);
		pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER;
		LEAVE();
		return MLAN_STATUS_RESOURCE;
	}
	cfg = (mlan_ds_11n_cfg *)pioctl_req->pbuf;
	switch (cfg->sub_command) {
	case MLAN_OID_11N_CFG_TX:
		status = wlan_11n_ioctl_httxcfg(pmadapter, pioctl_req);
		break;
	case MLAN_OID_11N_HTCAP_CFG:
		status = wlan_11n_ioctl_htusrcfg(pmadapter, pioctl_req);
		break;
	case MLAN_OID_11N_CFG_AGGR_PRIO_TBL:
		status = wlan_11n_ioctl_aggr_prio_tbl(pmadapter, pioctl_req);
		break;
	case MLAN_OID_11N_CFG_ADDBA_REJECT:
		status = wlan_11n_ioctl_addba_reject(pmadapter, pioctl_req);
		break;
	case MLAN_OID_11N_CFG_ADDBA_PARAM:
		status = wlan_11n_ioctl_addba_param(pmadapter, pioctl_req);
		break;
	case MLAN_OID_11N_CFG_DELBA:
		status = wlan_11n_ioctl_delba(pmadapter, pioctl_req);
		break;
	case MLAN_OID_11N_CFG_REJECT_ADDBA_REQ:
		status = wlan_11n_ioctl_rejectaddbareq(pmadapter, pioctl_req);
		break;
	case MLAN_OID_11N_CFG_MAX_TX_BUF_SIZE:
		status = wlan_11n_ioctl_max_tx_buf_size(pmadapter, pioctl_req);
		break;
	case MLAN_OID_11N_CFG_AMSDU_AGGR_CTRL:
		status = wlan_11n_ioctl_amsdu_aggr_ctrl(pmadapter, pioctl_req);
		break;
	case MLAN_OID_11N_CFG_SUPPORTED_MCS_SET:
		status =
			wlan_11n_ioctl_supported_mcs_set(pmadapter, pioctl_req);
		break;
	case MLAN_OID_11N_CFG_TX_BF_CAP:
		status = wlan_11n_ioctl_tx_bf_cap(pmadapter, pioctl_req);
		break;
	case MLAN_OID_11N_CFG_TX_BF_CFG:
		status = wlan_11n_ioctl_tx_bf_cfg(pmadapter, pioctl_req);
		break;
	case MLAN_OID_11N_CFG_STREAM_CFG:
		status = wlan_11n_ioctl_stream_cfg(pmadapter, pioctl_req);
		break;
	case MLAN_OID_11N_CFG_COEX_RX_WINSIZE:
		status = wlan_11n_ioctl_coex_rx_winsize(pmadapter, pioctl_req);
		break;
	case MLAN_OID_11N_CFG_TX_AGGR_CTRL:
		status = wlan_11n_ioctl_txaggrctrl(pmadapter, pioctl_req);
		break;
	case MLAN_OID_11N_CFG_IBSS_AMPDU_PARAM:
		status = wlan_11n_ioctl_ibss_ampdu_param(pmadapter, pioctl_req);
		break;
	case MLAN_OID_11N_CFG_MIN_BA_THRESHOLD:
		status = wlan_11n_ioctl_min_ba_threshold_cfg(pmadapter,
							     pioctl_req);
		break;
	default:
		pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID;
		status = MLAN_STATUS_FAILURE;
		break;
	}
	LEAVE();
	return status;
}

/**
 *  @brief This function will delete the given entry in Tx BA Stream table
 *
 *  @param priv     Pointer to mlan_private
 *  @param ptx_tbl  Pointer to tx ba stream entry to delete
 *
 *  @return         N/A
 */
void wlan_11n_delete_txbastream_tbl_entry(mlan_private *priv,
					  TxBAStreamTbl *ptx_tbl)
{
	pmlan_adapter pmadapter = priv->adapter;

	ENTER();

	if (!ptx_tbl || !wlan_is_txbastreamptr_valid(priv, ptx_tbl))
		goto exit;
	PRINTM(MINFO, "Delete BA stream table entry: %p\n", ptx_tbl);
	util_unlink_list(pmadapter->pmoal_handle, &priv->tx_ba_stream_tbl_ptr,
			 (pmlan_linked_list)ptx_tbl, MNULL, MNULL);
	pmadapter->callbacks.moal_mfree(pmadapter->pmoal_handle,
					(t_u8 *)ptx_tbl);
exit:
	LEAVE();
}

/**
 *  @brief This function will delete all the entries in Tx BA Stream table
 *
 *  @param priv         A pointer to mlan_private
 *
 *  @return             N/A
 */
void wlan_11n_deleteall_txbastream_tbl(mlan_private *priv)
{
	int i;
	TxBAStreamTbl *del_tbl_ptr = MNULL;

	ENTER();

	wlan_request_ralist_lock(priv);
	while ((del_tbl_ptr = (TxBAStreamTbl *)util_peek_list(
			priv->adapter->pmoal_handle,
			&priv->tx_ba_stream_tbl_ptr, MNULL, MNULL))) {
		wlan_11n_delete_txbastream_tbl_entry(priv, del_tbl_ptr);
	}

	util_init_list((pmlan_linked_list)&priv->tx_ba_stream_tbl_ptr);
	wlan_release_ralist_lock(priv);
	for (i = 0; i < MAX_NUM_TID; ++i) {
		priv->aggr_prio_tbl[i].ampdu_ap =
			priv->aggr_prio_tbl[i].ampdu_user;
	}

	LEAVE();
}

/**
 *  @brief This function will return the pointer to an entry in BA Stream
 *          table which matches the give RA/TID pair
 *
 *  @param priv    A pointer to mlan_private
 *  @param tid     TID to find in reordering table
 *  @param ra      RA to find in reordering table
 *  @param lock    flag for request the spin_lock
 *
 *  @return        A pointer to first entry matching RA/TID in BA stream
 *                 NULL if not found
 */
TxBAStreamTbl *wlan_11n_get_txbastream_tbl(mlan_private *priv, int tid,
					   t_u8 *ra, int lock)
{
	TxBAStreamTbl *ptx_tbl;
	pmlan_adapter pmadapter = priv->adapter;

	ENTER();

	if (lock)
		wlan_request_ralist_lock(priv);
	ptx_tbl = (TxBAStreamTbl *)util_peek_list(pmadapter->pmoal_handle,
						  &priv->tx_ba_stream_tbl_ptr,
						  MNULL, MNULL);
	if (!ptx_tbl) {
		if (lock)
			wlan_release_ralist_lock(priv);
		LEAVE();
		return MNULL;
	}

	while (ptx_tbl != (TxBAStreamTbl *)&priv->tx_ba_stream_tbl_ptr) {
		PRINTM(MDAT_D, "get_txbastream_tbl TID %d\n", ptx_tbl->tid);
		DBG_HEXDUMP(MDAT_D, "RA", ptx_tbl->ra, MLAN_MAC_ADDR_LENGTH);

		if ((!memcmp(pmadapter, ptx_tbl->ra, ra,
			     MLAN_MAC_ADDR_LENGTH)) &&
		    (ptx_tbl->tid == tid)) {
			if (lock)
				wlan_release_ralist_lock(priv);
			LEAVE();
			return ptx_tbl;
		}

		ptx_tbl = ptx_tbl->pnext;
	}
	if (lock)
		wlan_release_ralist_lock(priv);
	LEAVE();
	return MNULL;
}

/**
 *  @brief This function will create a entry in tx ba stream table for the
 *          given RA/TID.
 *
 *  @param priv      A pointer to mlan_private
 *  @param ra        RA to find in reordering table
 *  @param tid       TID to find in reordering table
 *  @param ba_status BA stream status to create the stream with
 *
 *  @return          N/A
 */
void wlan_11n_create_txbastream_tbl(mlan_private *priv, t_u8 *ra, int tid,
				    baStatus_e ba_status)
{
	TxBAStreamTbl *new_node = MNULL;
	pmlan_adapter pmadapter = priv->adapter;
	raListTbl *ra_list = MNULL;
	int tid_down;

	ENTER();

	PRINTM(MDAT_D, "create_txbastream_tbl TID %d\n", tid);
	DBG_HEXDUMP(MDAT_D, "RA", ra, MLAN_MAC_ADDR_LENGTH);

	if (pmadapter->callbacks.moal_malloc(
		    pmadapter->pmoal_handle, sizeof(TxBAStreamTbl),
		    MLAN_MEM_DEF, (t_u8 **)&new_node)) {
		PRINTM(MERROR,
		       "wlan_11n_create_txbastream_tbl Failed to allocate new_node\n");
		LEAVE();
		return;
	}
	tid_down = wlan_get_wmm_tid_down(priv, tid);
	ra_list = wlan_wmm_get_ralist_node(priv, tid_down, ra);
	if (ra_list) {
		ra_list->amsdu_in_ampdu = MFALSE;
		ra_list->ba_status = ba_status;
	}
	util_init_list((pmlan_linked_list)new_node);

	new_node->tid = tid;
	new_node->ba_status = ba_status;
	memcpy_ext(pmadapter, new_node->ra, ra, MLAN_MAC_ADDR_LENGTH,
		   MLAN_MAC_ADDR_LENGTH);

	util_enqueue_list_tail(pmadapter->pmoal_handle,
			       &priv->tx_ba_stream_tbl_ptr,
			       (pmlan_linked_list)new_node, MNULL, MNULL);

	LEAVE();
}

/**
 *  @brief This function will send a block ack to given tid/ra
 *
 *  @param priv     A pointer to mlan_private
 *  @param tid      TID to send the ADDBA
 *  @param peer_mac MAC address to send the ADDBA
 *
 *  @return         MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
 */
int wlan_send_addba(mlan_private *priv, int tid, t_u8 *peer_mac)
{
	HostCmd_DS_11N_ADDBA_REQ add_ba_req;
	static t_u8 dialog_tok;
	mlan_status ret;

	ENTER();

	PRINTM(MCMND, "Send addba: TID %d\n", tid);
	DBG_HEXDUMP(MCMD_D, "Send addba RA", peer_mac, MLAN_MAC_ADDR_LENGTH);

	add_ba_req.block_ack_param_set = (t_u16)(
		(tid << BLOCKACKPARAM_TID_POS) |
		(priv->add_ba_param.tx_win_size << BLOCKACKPARAM_WINSIZE_POS) |
		IMMEDIATE_BLOCK_ACK);
	/** enable AMSDU inside AMPDU */
	if (priv->add_ba_param.tx_amsdu &&
	    (priv->aggr_prio_tbl[tid].amsdu != BA_STREAM_NOT_ALLOWED))
		add_ba_req.block_ack_param_set |= BLOCKACKPARAM_AMSDU_SUPP_MASK;
	add_ba_req.block_ack_tmo = (t_u16)priv->add_ba_param.timeout;

	++dialog_tok;

	if (dialog_tok == 0)
		dialog_tok = 1;

	add_ba_req.dialog_token = dialog_tok;
	memcpy_ext(priv->adapter, &add_ba_req.peer_mac_addr, peer_mac,
		   MLAN_MAC_ADDR_LENGTH, MLAN_MAC_ADDR_LENGTH);

	/* We don't wait for the response of this command */
	ret = wlan_prepare_cmd(priv, HostCmd_CMD_11N_ADDBA_REQ, 0, 0, MNULL,
			       &add_ba_req);

	LEAVE();
	return ret;
}

/**
 *  @brief This function will delete a block ack to given tid/ra
 *
 *  @param priv         A pointer to mlan_private
 *  @param pioctl_req   A pointer to ioctl request buffer
 *  @param tid          TID to send the ADDBA
 *  @param peer_mac     MAC address to send the ADDBA
 *  @param initiator    MTRUE if we have initiated ADDBA, MFALSE otherwise
 *
 *  @return             MLAN_STATUS_PENDING --success, otherwise fail
 */
int wlan_send_delba(mlan_private *priv, pmlan_ioctl_req pioctl_req, int tid,
		    t_u8 *peer_mac, int initiator)
{
	HostCmd_DS_11N_DELBA delba;
	mlan_status ret;

	ENTER();

	memset(priv->adapter, &delba, 0, sizeof(delba));
	delba.del_ba_param_set = (tid << DELBA_TID_POS);

	if (initiator)
		DELBA_INITIATOR(delba.del_ba_param_set);
	else
		DELBA_RECIPIENT(delba.del_ba_param_set);

	memcpy_ext(priv->adapter, &delba.peer_mac_addr, peer_mac,
		   MLAN_MAC_ADDR_LENGTH, MLAN_MAC_ADDR_LENGTH);

	ret = wlan_prepare_cmd(priv, HostCmd_CMD_11N_DELBA, HostCmd_ACT_GEN_SET,
			       0, (t_void *)pioctl_req, (t_void *)&delba);

	if (ret == MLAN_STATUS_SUCCESS)
		ret = MLAN_STATUS_PENDING;

	LEAVE();
	return ret;
}

/**
 *  @brief This function handles the command response of
 *          delete a block ack request
 *
 *  @param priv		A pointer to mlan_private structure
 *  @param del_ba	A pointer to command response buffer
 *
 *  @return        N/A
 */
void wlan_11n_delete_bastream(mlan_private *priv, t_u8 *del_ba)
{
	HostCmd_DS_11N_DELBA *pdel_ba = (HostCmd_DS_11N_DELBA *)del_ba;
	int tid;

	ENTER();

	DBG_HEXDUMP(MCMD_D, "Delba:", (t_u8 *)pdel_ba, 20);
	pdel_ba->del_ba_param_set = wlan_le16_to_cpu(pdel_ba->del_ba_param_set);
	pdel_ba->reason_code = wlan_le16_to_cpu(pdel_ba->reason_code);

	tid = pdel_ba->del_ba_param_set >> DELBA_TID_POS;

	mlan_11n_delete_bastream_tbl(priv, tid, pdel_ba->peer_mac_addr,
				     TYPE_DELBA_RECEIVE,
				     INITIATOR_BIT(pdel_ba->del_ba_param_set),
				     pdel_ba->reason_code);

	LEAVE();
}

/**
 *  @brief Get Rx reordering table
 *
 *  @param priv         A pointer to mlan_private structure
 *  @param buf          A pointer to rx_reorder_tbl structure
 *  @return             number of rx reorder table entry
 */
int wlan_get_rxreorder_tbl(mlan_private *priv, rx_reorder_tbl *buf)
{
	int i;
	rx_reorder_tbl *ptbl = buf;
	RxReorderTbl *rx_reorder_tbl_ptr;
	int count = 0;
	ENTER();
	priv->adapter->callbacks.moal_spin_lock(priv->adapter->pmoal_handle,
						priv->rx_reorder_tbl_ptr.plock);
	rx_reorder_tbl_ptr =
		(RxReorderTbl *)util_peek_list(priv->adapter->pmoal_handle,
					       &priv->rx_reorder_tbl_ptr, MNULL,
					       MNULL);
	if (!rx_reorder_tbl_ptr) {
		priv->adapter->callbacks.moal_spin_unlock(
			priv->adapter->pmoal_handle,
			priv->rx_reorder_tbl_ptr.plock);
		LEAVE();
		return count;
	}
	while (rx_reorder_tbl_ptr !=
	       (RxReorderTbl *)&priv->rx_reorder_tbl_ptr) {
		ptbl->tid = (t_u16)rx_reorder_tbl_ptr->tid;
		memcpy_ext(priv->adapter, ptbl->ta, rx_reorder_tbl_ptr->ta,
			   MLAN_MAC_ADDR_LENGTH, MLAN_MAC_ADDR_LENGTH);
		ptbl->start_win = rx_reorder_tbl_ptr->start_win;
		ptbl->win_size = rx_reorder_tbl_ptr->win_size;

		ptbl->amsdu = rx_reorder_tbl_ptr->amsdu;
		for (i = 0; i < rx_reorder_tbl_ptr->win_size; ++i) {
			if (rx_reorder_tbl_ptr->rx_reorder_ptr[i])
				ptbl->buffer[i] = MTRUE;
			else
				ptbl->buffer[i] = MFALSE;
		}
		rx_reorder_tbl_ptr = rx_reorder_tbl_ptr->pnext;
		ptbl++;
		count++;
		if (count >= MLAN_MAX_RX_BASTREAM_SUPPORTED)
			break;
	}
	priv->adapter->callbacks.moal_spin_unlock(
		priv->adapter->pmoal_handle, priv->rx_reorder_tbl_ptr.plock);
	LEAVE();
	return count;
}

/**
 *  @brief Get transmit BA stream table
 *
 *  @param priv         A pointer to mlan_private structure
 *  @param buf          A pointer to tx_ba_stream_tbl structure
 *  @return             number of ba stream table entry
 */
int wlan_get_txbastream_tbl(mlan_private *priv, tx_ba_stream_tbl *buf)
{
	TxBAStreamTbl *ptxtbl;
	tx_ba_stream_tbl *ptbl = buf;
	int count = 0;
	t_u32 bastream_max = 0;

	ENTER();

	wlan_request_ralist_lock(priv);
	ptxtbl = (TxBAStreamTbl *)util_peek_list(priv->adapter->pmoal_handle,
						 &priv->tx_ba_stream_tbl_ptr,
						 MNULL, MNULL);
	if (!ptxtbl) {
		wlan_release_ralist_lock(priv);
		LEAVE();
		return count;
	}
	bastream_max = ISSUPP_GETTXBASTREAM(priv->adapter->hw_dot_11n_dev_cap);
	if (bastream_max == 0)
		bastream_max = MLAN_MAX_TX_BASTREAM_DEFAULT;

	while (ptxtbl != (TxBAStreamTbl *)&priv->tx_ba_stream_tbl_ptr) {
		ptbl->tid = (t_u16)ptxtbl->tid;
		PRINTM(MINFO, "tid=%d\n", ptbl->tid);
		memcpy_ext(priv->adapter, ptbl->ra, ptxtbl->ra,
			   MLAN_MAC_ADDR_LENGTH, MLAN_MAC_ADDR_LENGTH);
		ptbl->amsdu = ptxtbl->amsdu;
		ptxtbl = ptxtbl->pnext;
		ptbl++;
		count++;
		if (count >= (int)bastream_max)
			break;
	}
	wlan_release_ralist_lock(priv);
	LEAVE();
	return count;
}

/**
 *  @brief This function check if 11AC is allowed in bandcfg
 *
 *  @param pmpriv       A pointer to mlan_private structure
 *  @param bss_band     bss band
 *
 *  @return 0--not allowed, other value allowed
 */
t_u8 wlan_11n_bandconfig_allowed(mlan_private *pmpriv, t_u16 bss_band)
{
	if (pmpriv->bss_mode == MLAN_BSS_MODE_IBSS) {
		if (bss_band & BAND_G)
			return (pmpriv->adapter->adhoc_start_band & BAND_GN);
		else if (bss_band & BAND_A)
			return (pmpriv->adapter->adhoc_start_band & BAND_AN);
	} else {
		if (bss_band & BAND_G)
			return (pmpriv->config_bands & BAND_GN);
		else if (bss_band & BAND_A)
			return (pmpriv->config_bands & BAND_AN);
	}
	return 0;
}

/**
 *  @brief This function cleans up txbastream_tbl for specific station
 *
 *  @param priv     A pointer to mlan_private
 *  @param ra       RA to find in txbastream_tbl
 *  @return         N/A
 */
void wlan_11n_cleanup_txbastream_tbl(mlan_private *priv, t_u8 *ra)
{
	TxBAStreamTbl *ptx_tbl = MNULL;
	t_u8 i;
	ENTER();

	wlan_request_ralist_lock(priv);
	for (i = 0; i < MAX_NUM_TID; ++i) {
		ptx_tbl = wlan_11n_get_txbastream_tbl(priv, i, ra, MFALSE);
		if (ptx_tbl)
			wlan_11n_delete_txbastream_tbl_entry(priv, ptx_tbl);
	}
	wlan_release_ralist_lock(priv);
	LEAVE();
	return;
}

void wlan_update_11n_cap(mlan_private *pmpriv)
{
	mlan_adapter *pmadapter = pmpriv->adapter;

	pmpriv->usr_dev_mcs_support = pmadapter->hw_dev_mcs_support;
	pmpriv->usr_dot_11n_dev_cap_bg =
		pmadapter->hw_dot_11n_dev_cap & DEFAULT_11N_CAP_MASK_BG;
	pmpriv->usr_dot_11n_dev_cap_a =
		pmadapter->hw_dot_11n_dev_cap & DEFAULT_11N_CAP_MASK_A;
}