[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / rtl8192e / rtl819x_TSProc.c

/******************************************************************************
 * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
 *
 * The full GNU General Public License is included in this distribution in the
 * file called LICENSE.
 *
 * Contact Information:
 * wlanfae <wlanfae@realtek.com>
******************************************************************************/
#include "rtllib.h"
#include <linux/etherdevice.h>
#include "rtl819x_TS.h"

static void TsSetupTimeOut(unsigned long data)
{
}

static void TsInactTimeout(unsigned long data)
{
}

static void RxPktPendingTimeout(unsigned long data)
{
	struct rx_ts_record *pRxTs = (struct rx_ts_record *)data;
	struct rtllib_device *ieee = container_of(pRxTs, struct rtllib_device,
						  RxTsRecord[pRxTs->num]);

	struct rx_reorder_entry *pReorderEntry = NULL;

	unsigned long flags = 0;
	u8 index = 0;
	bool bPktInBuf = false;

	spin_lock_irqsave(&(ieee->reorder_spinlock), flags);
	if (pRxTs->RxTimeoutIndicateSeq != 0xffff) {
		while (!list_empty(&pRxTs->RxPendingPktList)) {
			pReorderEntry = (struct rx_reorder_entry *)
					list_entry(pRxTs->RxPendingPktList.prev,
					struct rx_reorder_entry, List);
			if (index == 0)
				pRxTs->RxIndicateSeq = pReorderEntry->SeqNum;

			if (SN_LESS(pReorderEntry->SeqNum, pRxTs->RxIndicateSeq) ||
				SN_EQUAL(pReorderEntry->SeqNum, pRxTs->RxIndicateSeq)) {
				list_del_init(&pReorderEntry->List);

				if (SN_EQUAL(pReorderEntry->SeqNum,
				    pRxTs->RxIndicateSeq))
					pRxTs->RxIndicateSeq =
					      (pRxTs->RxIndicateSeq + 1) % 4096;

				RTLLIB_DEBUG(RTLLIB_DL_REORDER, "%s(): Indicate"
					     " SeqNum: %d\n", __func__,
					     pReorderEntry->SeqNum);
				ieee->stats_IndicateArray[index] =
							 pReorderEntry->prxb;
				index++;

				list_add_tail(&pReorderEntry->List,
					      &ieee->RxReorder_Unused_List);
			} else {
				bPktInBuf = true;
				break;
			}
		}
	}

	if (index > 0) {
		pRxTs->RxTimeoutIndicateSeq = 0xffff;

		if (index > REORDER_WIN_SIZE) {
			RTLLIB_DEBUG(RTLLIB_DL_ERR, "RxReorderIndicatePacket():"
				     " Rx Reorer struct buffer full!!\n");
			spin_unlock_irqrestore(&(ieee->reorder_spinlock),
					       flags);
			return;
		}
		rtllib_indicate_packets(ieee, ieee->stats_IndicateArray, index);
		bPktInBuf = false;
	}

	if (bPktInBuf && (pRxTs->RxTimeoutIndicateSeq == 0xffff)) {
		pRxTs->RxTimeoutIndicateSeq = pRxTs->RxIndicateSeq;
		mod_timer(&pRxTs->RxPktPendingTimer,  jiffies +
			  MSECS(ieee->pHTInfo->RxReorderPendingTime));
	}
	spin_unlock_irqrestore(&(ieee->reorder_spinlock), flags);
}

static void TsAddBaProcess(unsigned long data)
{
	struct tx_ts_record *pTxTs = (struct tx_ts_record *)data;
	u8 num = pTxTs->num;
	struct rtllib_device *ieee = container_of(pTxTs, struct rtllib_device,
				     TxTsRecord[num]);

	TsInitAddBA(ieee, pTxTs, BA_POLICY_IMMEDIATE, false);
	RTLLIB_DEBUG(RTLLIB_DL_BA, "TsAddBaProcess(): ADDBA Req is "
		     "started!!\n");
}

static void ResetTsCommonInfo(struct ts_common_info *pTsCommonInfo)
{
	memset(pTsCommonInfo->Addr, 0, 6);
	memset(&pTsCommonInfo->TSpec, 0, sizeof(union tspec_body));
	memset(&pTsCommonInfo->TClass, 0, sizeof(union qos_tclas)*TCLAS_NUM);
	pTsCommonInfo->TClasProc = 0;
	pTsCommonInfo->TClasNum = 0;
}

static void ResetTxTsEntry(struct tx_ts_record *pTS)
{
	ResetTsCommonInfo(&pTS->TsCommonInfo);
	pTS->TxCurSeq = 0;
	pTS->bAddBaReqInProgress = false;
	pTS->bAddBaReqDelayed = false;
	pTS->bUsingBa = false;
	pTS->bDisable_AddBa = false;
	ResetBaEntry(&pTS->TxAdmittedBARecord);
	ResetBaEntry(&pTS->TxPendingBARecord);
}

static void ResetRxTsEntry(struct rx_ts_record *pTS)
{
	ResetTsCommonInfo(&pTS->TsCommonInfo);
	pTS->RxIndicateSeq = 0xffff;
	pTS->RxTimeoutIndicateSeq = 0xffff;
	ResetBaEntry(&pTS->RxAdmittedBARecord);
}

void TSInitialize(struct rtllib_device *ieee)
{
	struct tx_ts_record *pTxTS  = ieee->TxTsRecord;
	struct rx_ts_record *pRxTS  = ieee->RxTsRecord;
	struct rx_reorder_entry *pRxReorderEntry = ieee->RxReorderEntry;
	u8				count = 0;
	RTLLIB_DEBUG(RTLLIB_DL_TS, "==========>%s()\n", __func__);
	INIT_LIST_HEAD(&ieee->Tx_TS_Admit_List);
	INIT_LIST_HEAD(&ieee->Tx_TS_Pending_List);
	INIT_LIST_HEAD(&ieee->Tx_TS_Unused_List);

	for (count = 0; count < TOTAL_TS_NUM; count++) {
		pTxTS->num = count;
		_setup_timer(&pTxTS->TsCommonInfo.SetupTimer,
			    TsSetupTimeOut,
			    (unsigned long) pTxTS);

		_setup_timer(&pTxTS->TsCommonInfo.InactTimer,
			    TsInactTimeout,
			    (unsigned long) pTxTS);

		_setup_timer(&pTxTS->TsAddBaTimer,
			    TsAddBaProcess,
			    (unsigned long) pTxTS);

		_setup_timer(&pTxTS->TxPendingBARecord.Timer,
			    BaSetupTimeOut,
			    (unsigned long) pTxTS);
		_setup_timer(&pTxTS->TxAdmittedBARecord.Timer,
			    TxBaInactTimeout,
			    (unsigned long) pTxTS);

		ResetTxTsEntry(pTxTS);
		list_add_tail(&pTxTS->TsCommonInfo.List,
				&ieee->Tx_TS_Unused_List);
		pTxTS++;
	}

	INIT_LIST_HEAD(&ieee->Rx_TS_Admit_List);
	INIT_LIST_HEAD(&ieee->Rx_TS_Pending_List);
	INIT_LIST_HEAD(&ieee->Rx_TS_Unused_List);
	for (count = 0; count < TOTAL_TS_NUM; count++) {
		pRxTS->num = count;
		INIT_LIST_HEAD(&pRxTS->RxPendingPktList);

		_setup_timer(&pRxTS->TsCommonInfo.SetupTimer,
			    TsSetupTimeOut,
			    (unsigned long) pRxTS);

		_setup_timer(&pRxTS->TsCommonInfo.InactTimer,
			    TsInactTimeout,
			    (unsigned long) pRxTS);

		_setup_timer(&pRxTS->RxAdmittedBARecord.Timer,
			    RxBaInactTimeout,
			    (unsigned long) pRxTS);

		_setup_timer(&pRxTS->RxPktPendingTimer,
			    RxPktPendingTimeout,
			    (unsigned long) pRxTS);

		ResetRxTsEntry(pRxTS);
		list_add_tail(&pRxTS->TsCommonInfo.List,
			      &ieee->Rx_TS_Unused_List);
		pRxTS++;
	}
	INIT_LIST_HEAD(&ieee->RxReorder_Unused_List);
	for (count = 0; count < REORDER_ENTRY_NUM; count++) {
		list_add_tail(&pRxReorderEntry->List,
			      &ieee->RxReorder_Unused_List);
		if (count == (REORDER_ENTRY_NUM-1))
			break;
		pRxReorderEntry = &ieee->RxReorderEntry[count+1];
	}

}

static void AdmitTS(struct rtllib_device *ieee,
		    struct ts_common_info *pTsCommonInfo, u32 InactTime)
{
	del_timer_sync(&pTsCommonInfo->SetupTimer);
	del_timer_sync(&pTsCommonInfo->InactTimer);

	if (InactTime != 0)
		mod_timer(&pTsCommonInfo->InactTimer, jiffies +
			  MSECS(InactTime));
}

static struct ts_common_info *SearchAdmitTRStream(struct rtllib_device *ieee,
						  u8 *Addr, u8 TID,
						  enum tr_select TxRxSelect)
{
	u8	dir;
	bool	search_dir[4] = {0};
	struct list_head *psearch_list;
	struct ts_common_info *pRet = NULL;
	if (ieee->iw_mode == IW_MODE_MASTER) {
		if (TxRxSelect == TX_DIR) {
			search_dir[DIR_DOWN] = true;
			search_dir[DIR_BI_DIR] = true;
		} else {
			search_dir[DIR_UP] = true;
			search_dir[DIR_BI_DIR] = true;
		}
	} else if (ieee->iw_mode == IW_MODE_ADHOC) {
		if (TxRxSelect == TX_DIR)
			search_dir[DIR_UP] = true;
		else
			search_dir[DIR_DOWN] = true;
	} else {
		if (TxRxSelect == TX_DIR) {
			search_dir[DIR_UP] = true;
			search_dir[DIR_BI_DIR] = true;
			search_dir[DIR_DIRECT] = true;
		} else {
			search_dir[DIR_DOWN] = true;
			search_dir[DIR_BI_DIR] = true;
			search_dir[DIR_DIRECT] = true;
		}
	}

	if (TxRxSelect == TX_DIR)
		psearch_list = &ieee->Tx_TS_Admit_List;
	else
		psearch_list = &ieee->Rx_TS_Admit_List;

	for (dir = 0; dir <= DIR_BI_DIR; dir++) {
		if (search_dir[dir] == false)
			continue;
		list_for_each_entry(pRet, psearch_list, List) {
			if (memcmp(pRet->Addr, Addr, 6) == 0)
				if (pRet->TSpec.f.TSInfo.field.ucTSID == TID)
					if (pRet->TSpec.f.TSInfo.field.ucDirection == dir)
						break;

		}
		if (&pRet->List  != psearch_list)
			break;
	}

	if (pRet && &pRet->List  != psearch_list)
		return pRet ;
	else
		return NULL;
}

static void MakeTSEntry(struct ts_common_info *pTsCommonInfo, u8 *Addr,
			union tspec_body *pTSPEC, union qos_tclas *pTCLAS,
			u8 TCLAS_Num, u8 TCLAS_Proc)
{
	u8	count;

	if (pTsCommonInfo == NULL)
		return;

	memcpy(pTsCommonInfo->Addr, Addr, 6);

	if (pTSPEC != NULL)
		memcpy((u8 *)(&(pTsCommonInfo->TSpec)), (u8 *)pTSPEC,
			sizeof(union tspec_body));

	for (count = 0; count < TCLAS_Num; count++)
		memcpy((u8 *)(&(pTsCommonInfo->TClass[count])),
		       (u8 *)pTCLAS, sizeof(union qos_tclas));

	pTsCommonInfo->TClasProc = TCLAS_Proc;
	pTsCommonInfo->TClasNum = TCLAS_Num;
}

bool GetTs(struct rtllib_device *ieee, struct ts_common_info **ppTS,
	   u8 *Addr, u8 TID, enum tr_select TxRxSelect, bool bAddNewTs)
{
	u8	UP = 0;
	if (is_multicast_ether_addr(Addr)) {
		RTLLIB_DEBUG(RTLLIB_DL_ERR, "ERR! get TS for Broadcast or "
			     "Multicast\n");
		return false;
	}
	if (ieee->current_network.qos_data.supported == 0) {
		UP = 0;
	} else {
		if (!IsACValid(TID)) {
			RTLLIB_DEBUG(RTLLIB_DL_ERR, "ERR! in %s(), TID(%d) is "
				     "not valid\n", __func__, TID);
			return false;
		}

		switch (TID) {
		case 0:
		case 3:
			UP = 0;
			break;
		case 1:
		case 2:
			UP = 2;
			break;
		case 4:
		case 5:
			UP = 5;
			break;
		case 6:
		case 7:
			UP = 7;
			break;
		}
	}

	*ppTS = SearchAdmitTRStream(ieee, Addr, UP, TxRxSelect);
	if (*ppTS != NULL) {
		return true;
	} else {
		if (bAddNewTs == false) {
			RTLLIB_DEBUG(RTLLIB_DL_TS, "add new TS failed"
				     "(tid:%d)\n", UP);
			return false;
		} else {
			union tspec_body TSpec;
			union qos_tsinfo *pTSInfo = &TSpec.f.TSInfo;
			struct list_head *pUnusedList =
				(TxRxSelect == TX_DIR) ?
				(&ieee->Tx_TS_Unused_List) :
				(&ieee->Rx_TS_Unused_List);

			struct list_head *pAddmitList =
				(TxRxSelect == TX_DIR) ?
				(&ieee->Tx_TS_Admit_List) :
				(&ieee->Rx_TS_Admit_List);

			enum direction_value Dir =
				 (ieee->iw_mode == IW_MODE_MASTER) ?
				 ((TxRxSelect == TX_DIR) ? DIR_DOWN : DIR_UP) :
				 ((TxRxSelect == TX_DIR) ? DIR_UP : DIR_DOWN);
			RTLLIB_DEBUG(RTLLIB_DL_TS, "to add Ts\n");
			if (!list_empty(pUnusedList)) {
				(*ppTS) = list_entry(pUnusedList->next,
					  struct ts_common_info, List);
				list_del_init(&(*ppTS)->List);
				if (TxRxSelect == TX_DIR) {
					struct tx_ts_record *tmp =
						container_of(*ppTS,
						struct tx_ts_record,
						TsCommonInfo);
					ResetTxTsEntry(tmp);
				} else {
					struct rx_ts_record *tmp =
						 container_of(*ppTS,
						 struct rx_ts_record,
						 TsCommonInfo);
					ResetRxTsEntry(tmp);
				}

				RTLLIB_DEBUG(RTLLIB_DL_TS, "to init current TS"
					     ", UP:%d, Dir:%d, addr: %pM"
					     " ppTs=%p\n", UP, Dir,
					      Addr, *ppTS);
				pTSInfo->field.ucTrafficType = 0;
				pTSInfo->field.ucTSID = UP;
				pTSInfo->field.ucDirection = Dir;
				pTSInfo->field.ucAccessPolicy = 1;
				pTSInfo->field.ucAggregation = 0;
				pTSInfo->field.ucPSB = 0;
				pTSInfo->field.ucUP = UP;
				pTSInfo->field.ucTSInfoAckPolicy = 0;
				pTSInfo->field.ucSchedule = 0;

				MakeTSEntry(*ppTS, Addr, &TSpec, NULL, 0, 0);
				AdmitTS(ieee, *ppTS, 0);
				list_add_tail(&((*ppTS)->List), pAddmitList);

				return true;
			} else {
				RTLLIB_DEBUG(RTLLIB_DL_ERR, "ERR!!in function "
					     "%s() There is not enough dir=%d"
					     "(0=up down=1) TS record to be "
					     "used!!", __func__, Dir);
				return false;
			}
		}
	}
}

static void RemoveTsEntry(struct rtllib_device *ieee, struct ts_common_info *pTs,
			  enum tr_select TxRxSelect)
{
	del_timer_sync(&pTs->SetupTimer);
	del_timer_sync(&pTs->InactTimer);
	TsInitDelBA(ieee, pTs, TxRxSelect);

	if (TxRxSelect == RX_DIR) {
		struct rx_reorder_entry *pRxReorderEntry;
		struct rx_ts_record *pRxTS = (struct rx_ts_record *)pTs;

		if (timer_pending(&pRxTS->RxPktPendingTimer))
			del_timer_sync(&pRxTS->RxPktPendingTimer);

		while (!list_empty(&pRxTS->RxPendingPktList)) {
			pRxReorderEntry = (struct rx_reorder_entry *)
					list_entry(pRxTS->RxPendingPktList.prev,
					struct rx_reorder_entry, List);
			RTLLIB_DEBUG(RTLLIB_DL_REORDER, "%s(): Delete SeqNum "
				     "%d!\n", __func__,
				     pRxReorderEntry->SeqNum);
			list_del_init(&pRxReorderEntry->List);
			{
				int i = 0;
				struct rtllib_rxb *prxb = pRxReorderEntry->prxb;
				if (unlikely(!prxb))
					return;
				for (i = 0; i < prxb->nr_subframes; i++)
					dev_kfree_skb(prxb->subframes[i]);
				kfree(prxb);
				prxb = NULL;
			}
			list_add_tail(&pRxReorderEntry->List,
				      &ieee->RxReorder_Unused_List);
		}
	} else {
		struct tx_ts_record *pTxTS = (struct tx_ts_record *)pTs;
		del_timer_sync(&pTxTS->TsAddBaTimer);
	}
}

void RemovePeerTS(struct rtllib_device *ieee, u8 *Addr)
{
	struct ts_common_info *pTS, *pTmpTS;
	printk(KERN_INFO "===========>RemovePeerTS, %pM\n", Addr);

	list_for_each_entry_safe(pTS, pTmpTS, &ieee->Tx_TS_Pending_List, List) {
		if (memcmp(pTS->Addr, Addr, 6) == 0) {
			RemoveTsEntry(ieee, pTS, TX_DIR);
			list_del_init(&pTS->List);
			list_add_tail(&pTS->List, &ieee->Tx_TS_Unused_List);
		}
	}

	list_for_each_entry_safe(pTS, pTmpTS, &ieee->Tx_TS_Admit_List, List) {
		if (memcmp(pTS->Addr, Addr, 6) == 0) {
			printk(KERN_INFO "====>remove Tx_TS_admin_list\n");
			RemoveTsEntry(ieee, pTS, TX_DIR);
			list_del_init(&pTS->List);
			list_add_tail(&pTS->List, &ieee->Tx_TS_Unused_List);
		}
	}

	list_for_each_entry_safe(pTS, pTmpTS, &ieee->Rx_TS_Pending_List, List) {
		if (memcmp(pTS->Addr, Addr, 6) == 0) {
			RemoveTsEntry(ieee, pTS, RX_DIR);
			list_del_init(&pTS->List);
			list_add_tail(&pTS->List, &ieee->Rx_TS_Unused_List);
		}
	}

	list_for_each_entry_safe(pTS, pTmpTS, &ieee->Rx_TS_Admit_List, List) {
		if (memcmp(pTS->Addr, Addr, 6) == 0) {
			RemoveTsEntry(ieee, pTS, RX_DIR);
			list_del_init(&pTS->List);
			list_add_tail(&pTS->List, &ieee->Rx_TS_Unused_List);
		}
	}
}
EXPORT_SYMBOL(RemovePeerTS);

void RemoveAllTS(struct rtllib_device *ieee)
{
	struct ts_common_info *pTS, *pTmpTS;

	list_for_each_entry_safe(pTS, pTmpTS, &ieee->Tx_TS_Pending_List, List) {
		RemoveTsEntry(ieee, pTS, TX_DIR);
		list_del_init(&pTS->List);
		list_add_tail(&pTS->List, &ieee->Tx_TS_Unused_List);
	}

	list_for_each_entry_safe(pTS, pTmpTS, &ieee->Tx_TS_Admit_List, List) {
		RemoveTsEntry(ieee, pTS, TX_DIR);
		list_del_init(&pTS->List);
		list_add_tail(&pTS->List, &ieee->Tx_TS_Unused_List);
	}

	list_for_each_entry_safe(pTS, pTmpTS, &ieee->Rx_TS_Pending_List, List) {
		RemoveTsEntry(ieee, pTS, RX_DIR);
		list_del_init(&pTS->List);
		list_add_tail(&pTS->List, &ieee->Rx_TS_Unused_List);
	}

	list_for_each_entry_safe(pTS, pTmpTS, &ieee->Rx_TS_Admit_List, List) {
		RemoveTsEntry(ieee, pTS, RX_DIR);
		list_del_init(&pTS->List);
		list_add_tail(&pTS->List, &ieee->Rx_TS_Unused_List);
	}
}

void TsStartAddBaProcess(struct rtllib_device *ieee, struct tx_ts_record *pTxTS)
{
	if (pTxTS->bAddBaReqInProgress == false) {
		pTxTS->bAddBaReqInProgress = true;

		if (pTxTS->bAddBaReqDelayed) {
			RTLLIB_DEBUG(RTLLIB_DL_BA, "TsStartAddBaProcess(): "
				     "Delayed Start ADDBA after 60 sec!!\n");
			mod_timer(&pTxTS->TsAddBaTimer, jiffies +
				  MSECS(TS_ADDBA_DELAY));
		} else {
			RTLLIB_DEBUG(RTLLIB_DL_BA, "TsStartAddBaProcess(): "
				     "Immediately Start ADDBA now!!\n");
			mod_timer(&pTxTS->TsAddBaTimer, jiffies+10);
		}
	} else
		RTLLIB_DEBUG(RTLLIB_DL_BA, "%s()==>BA timer is already added\n",
			     __func__);
}
Commit	Line	Data
94a79942 LF	1	/******************************************************************************
	2	* Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
	3	*
	4	* This program is distributed in the hope that it will be useful, but WITHOUT
	5	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	6	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	7	* more details.
	8	*
	9	* You should have received a copy of the GNU General Public License along with
	10	* this program; if not, write to the Free Software Foundation, Inc.,
	11	* 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
	12	*
	13	* The full GNU General Public License is included in this distribution in the
	14	* file called LICENSE.
	15	*
	16	* Contact Information:
	17	* wlanfae <wlanfae@realtek.com>
	18	******************************************************************************/
	19	#include "rtllib.h"
	20	#include <linux/etherdevice.h>
	21	#include "rtl819x_TS.h"
cb762154	22
ec0dc6be	23	static void TsSetupTimeOut(unsigned long data)
94a79942 LF	24	{
	25	}
	26
ec0dc6be	27	static void TsInactTimeout(unsigned long data)
94a79942 LF	28	{
	29	}
	30
ec0dc6be	31	static void RxPktPendingTimeout(unsigned long data)
94a79942	32	{
2c47ae28	33	struct rx_ts_record pRxTs = (struct rx_ts_record )data;
f88ec6cb LF	34	struct rtllib_device *ieee = container_of(pRxTs, struct rtllib_device,
f88ec6cb LF	35	RxTsRecord[pRxTs->num]);
94a79942	36
8cba1432	37	struct rx_reorder_entry *pReorderEntry = NULL;
94a79942 LF	38
94a79942 LF	39	unsigned long flags = 0;
94a79942 LF	40	u8 index = 0;
	41	bool bPktInBuf = false;
	42
	43	spin_lock_irqsave(&(ieee->reorder_spinlock), flags);
f88ec6cb LF	44	if (pRxTs->RxTimeoutIndicateSeq != 0xffff) {
	45	while (!list_empty(&pRxTs->RxPendingPktList)) {
	46	pReorderEntry = (struct rx_reorder_entry *)
	47	list_entry(pRxTs->RxPendingPktList.prev,
	48	struct rx_reorder_entry, List);
94a79942 LF	49	if (index == 0)
	50	pRxTs->RxIndicateSeq = pReorderEntry->SeqNum;
	51
f88ec6cb LF	52	if (SN_LESS(pReorderEntry->SeqNum, pRxTs->RxIndicateSeq) \|\|
f88ec6cb LF	53	SN_EQUAL(pReorderEntry->SeqNum, pRxTs->RxIndicateSeq)) {
94a79942 LF	54	list_del_init(&pReorderEntry->List);
94a79942 LF	55
f88ec6cb LF	56	if (SN_EQUAL(pReorderEntry->SeqNum,
	57	pRxTs->RxIndicateSeq))
	58	pRxTs->RxIndicateSeq =
	59	(pRxTs->RxIndicateSeq + 1) % 4096;
94a79942	60
f88ec6cb LF	61	RTLLIB_DEBUG(RTLLIB_DL_REORDER, "%s(): Indicate"
	62	" SeqNum: %d\n", __func__,
	63	pReorderEntry->SeqNum);
2eed3dee	64	ieee->stats_IndicateArray[index] =
f88ec6cb	65	pReorderEntry->prxb;
94a79942 LF	66	index++;
94a79942 LF	67
f88ec6cb LF	68	list_add_tail(&pReorderEntry->List,
	69	&ieee->RxReorder_Unused_List);
	70	} else {
94a79942 LF	71	bPktInBuf = true;
	72	break;
	73	}
	74	}
	75	}
	76
f88ec6cb	77	if (index > 0) {
94a79942 LF	78	pRxTs->RxTimeoutIndicateSeq = 0xffff;
94a79942 LF	79
f88ec6cb LF	80	if (index > REORDER_WIN_SIZE) {
	81	RTLLIB_DEBUG(RTLLIB_DL_ERR, "RxReorderIndicatePacket():"
	82	" Rx Reorer struct buffer full!!\n");
	83	spin_unlock_irqrestore(&(ieee->reorder_spinlock),
	84	flags);
94a79942 LF	85	return;
94a79942 LF	86	}
2eed3dee	87	rtllib_indicate_packets(ieee, ieee->stats_IndicateArray, index);
94a79942 LF	88	bPktInBuf = false;
	89	}
	90
f88ec6cb	91	if (bPktInBuf && (pRxTs->RxTimeoutIndicateSeq == 0xffff)) {
94a79942	92	pRxTs->RxTimeoutIndicateSeq = pRxTs->RxIndicateSeq;
f88ec6cb LF	93	mod_timer(&pRxTs->RxPktPendingTimer, jiffies +
f88ec6cb LF	94	MSECS(ieee->pHTInfo->RxReorderPendingTime));
94a79942 LF	95	}
	96	spin_unlock_irqrestore(&(ieee->reorder_spinlock), flags);
	97	}
	98
ec0dc6be	99	static void TsAddBaProcess(unsigned long data)
94a79942	100	{
60554f2b	101	struct tx_ts_record pTxTs = (struct tx_ts_record )data;
94a79942	102	u8 num = pTxTs->num;
f88ec6cb LF	103	struct rtllib_device *ieee = container_of(pTxTs, struct rtllib_device,
f88ec6cb LF	104	TxTsRecord[num]);
94a79942 LF	105
94a79942 LF	106	TsInitAddBA(ieee, pTxTs, BA_POLICY_IMMEDIATE, false);
f88ec6cb LF	107	RTLLIB_DEBUG(RTLLIB_DL_BA, "TsAddBaProcess(): ADDBA Req is "
f88ec6cb LF	108	"started!!\n");
94a79942 LF	109	}
94a79942 LF	110
ec0dc6be	111	static void ResetTsCommonInfo(struct ts_common_info *pTsCommonInfo)
94a79942 LF	112	{
94a79942 LF	113	memset(pTsCommonInfo->Addr, 0, 6);
ed306e48	114	memset(&pTsCommonInfo->TSpec, 0, sizeof(union tspec_body));
626f951d	115	memset(&pTsCommonInfo->TClass, 0, sizeof(union qos_tclas)*TCLAS_NUM);
94a79942 LF	116	pTsCommonInfo->TClasProc = 0;
	117	pTsCommonInfo->TClasNum = 0;
	118	}
	119
ec0dc6be	120	static void ResetTxTsEntry(struct tx_ts_record *pTS)
94a79942 LF	121	{
	122	ResetTsCommonInfo(&pTS->TsCommonInfo);
	123	pTS->TxCurSeq = 0;
	124	pTS->bAddBaReqInProgress = false;
	125	pTS->bAddBaReqDelayed = false;
	126	pTS->bUsingBa = false;
	127	pTS->bDisable_AddBa = false;
	128	ResetBaEntry(&pTS->TxAdmittedBARecord);
	129	ResetBaEntry(&pTS->TxPendingBARecord);
	130	}
	131
ec0dc6be	132	static void ResetRxTsEntry(struct rx_ts_record *pTS)
94a79942 LF	133	{
	134	ResetTsCommonInfo(&pTS->TsCommonInfo);
	135	pTS->RxIndicateSeq = 0xffff;
	136	pTS->RxTimeoutIndicateSeq = 0xffff;
	137	ResetBaEntry(&pTS->RxAdmittedBARecord);
	138	}
94a79942 LF	139
	140	void TSInitialize(struct rtllib_device *ieee)
	141	{
60554f2b	142	struct tx_ts_record *pTxTS = ieee->TxTsRecord;
2c47ae28	143	struct rx_ts_record *pRxTS = ieee->RxTsRecord;
8cba1432	144	struct rx_reorder_entry *pRxReorderEntry = ieee->RxReorderEntry;
94a79942 LF	145	u8 count = 0;
	146	RTLLIB_DEBUG(RTLLIB_DL_TS, "==========>%s()\n", __func__);
	147	INIT_LIST_HEAD(&ieee->Tx_TS_Admit_List);
	148	INIT_LIST_HEAD(&ieee->Tx_TS_Pending_List);
	149	INIT_LIST_HEAD(&ieee->Tx_TS_Unused_List);
	150
f88ec6cb	151	for (count = 0; count < TOTAL_TS_NUM; count++) {
94a79942 LF	152	pTxTS->num = count;
	153	_setup_timer(&pTxTS->TsCommonInfo.SetupTimer,
	154	TsSetupTimeOut,
	155	(unsigned long) pTxTS);
	156
	157	_setup_timer(&pTxTS->TsCommonInfo.InactTimer,
	158	TsInactTimeout,
	159	(unsigned long) pTxTS);
	160
	161	_setup_timer(&pTxTS->TsAddBaTimer,
	162	TsAddBaProcess,
	163	(unsigned long) pTxTS);
	164
	165	_setup_timer(&pTxTS->TxPendingBARecord.Timer,
	166	BaSetupTimeOut,
	167	(unsigned long) pTxTS);
	168	_setup_timer(&pTxTS->TxAdmittedBARecord.Timer,
	169	TxBaInactTimeout,
	170	(unsigned long) pTxTS);
	171
	172	ResetTxTsEntry(pTxTS);
	173	list_add_tail(&pTxTS->TsCommonInfo.List,
	174	&ieee->Tx_TS_Unused_List);
	175	pTxTS++;
	176	}
	177
	178	INIT_LIST_HEAD(&ieee->Rx_TS_Admit_List);
	179	INIT_LIST_HEAD(&ieee->Rx_TS_Pending_List);
	180	INIT_LIST_HEAD(&ieee->Rx_TS_Unused_List);
f88ec6cb	181	for (count = 0; count < TOTAL_TS_NUM; count++) {
94a79942 LF	182	pRxTS->num = count;
	183	INIT_LIST_HEAD(&pRxTS->RxPendingPktList);
	184
	185	_setup_timer(&pRxTS->TsCommonInfo.SetupTimer,
	186	TsSetupTimeOut,
	187	(unsigned long) pRxTS);
	188
	189	_setup_timer(&pRxTS->TsCommonInfo.InactTimer,
	190	TsInactTimeout,
	191	(unsigned long) pRxTS);
	192
	193	_setup_timer(&pRxTS->RxAdmittedBARecord.Timer,
	194	RxBaInactTimeout,
	195	(unsigned long) pRxTS);
	196
	197	_setup_timer(&pRxTS->RxPktPendingTimer,
	198	RxPktPendingTimeout,
	199	(unsigned long) pRxTS);
	200
	201	ResetRxTsEntry(pRxTS);
f88ec6cb LF	202	list_add_tail(&pRxTS->TsCommonInfo.List,
f88ec6cb LF	203	&ieee->Rx_TS_Unused_List);
94a79942 LF	204	pRxTS++;
	205	}
	206	INIT_LIST_HEAD(&ieee->RxReorder_Unused_List);
f88ec6cb LF	207	for (count = 0; count < REORDER_ENTRY_NUM; count++) {
	208	list_add_tail(&pRxReorderEntry->List,
	209	&ieee->RxReorder_Unused_List);
94a79942 LF	210	if (count == (REORDER_ENTRY_NUM-1))
	211	break;
	212	pRxReorderEntry = &ieee->RxReorderEntry[count+1];
	213	}
	214
	215	}
	216
ec0dc6be LF	217	static void AdmitTS(struct rtllib_device *ieee,
ec0dc6be LF	218	struct ts_common_info *pTsCommonInfo, u32 InactTime)
94a79942 LF	219	{
	220	del_timer_sync(&pTsCommonInfo->SetupTimer);
	221	del_timer_sync(&pTsCommonInfo->InactTimer);
	222
f88ec6cb LF	223	if (InactTime != 0)
	224	mod_timer(&pTsCommonInfo->InactTimer, jiffies +
	225	MSECS(InactTime));
94a79942 LF	226	}
94a79942 LF	227
ec0dc6be LF	228	static struct ts_common_info SearchAdmitTRStream(struct rtllib_device ieee,
	229	u8 *Addr, u8 TID,
	230	enum tr_select TxRxSelect)
94a79942 LF	231	{
94a79942 LF	232	u8 dir;
ec0dc6be	233	bool search_dir[4] = {0};
f88ec6cb	234	struct list_head *psearch_list;
74724de1	235	struct ts_common_info *pRet = NULL;
f88ec6cb LF	236	if (ieee->iw_mode == IW_MODE_MASTER) {
f88ec6cb LF	237	if (TxRxSelect == TX_DIR) {
94a79942	238	search_dir[DIR_DOWN] = true;
f88ec6cb LF	239	search_dir[DIR_BI_DIR] = true;
	240	} else {
	241	search_dir[DIR_UP] = true;
	242	search_dir[DIR_BI_DIR] = true;
94a79942	243	}
f88ec6cb	244	} else if (ieee->iw_mode == IW_MODE_ADHOC) {
94a79942	245	if (TxRxSelect == TX_DIR)
f88ec6cb	246	search_dir[DIR_UP] = true;
94a79942 LF	247	else
94a79942 LF	248	search_dir[DIR_DOWN] = true;
f88ec6cb LF	249	} else {
	250	if (TxRxSelect == TX_DIR) {
	251	search_dir[DIR_UP] = true;
	252	search_dir[DIR_BI_DIR] = true;
	253	search_dir[DIR_DIRECT] = true;
	254	} else {
94a79942	255	search_dir[DIR_DOWN] = true;
f88ec6cb LF	256	search_dir[DIR_BI_DIR] = true;
f88ec6cb LF	257	search_dir[DIR_DIRECT] = true;
94a79942 LF	258	}
	259	}
	260
	261	if (TxRxSelect == TX_DIR)
	262	psearch_list = &ieee->Tx_TS_Admit_List;
	263	else
	264	psearch_list = &ieee->Rx_TS_Admit_List;
	265
f88ec6cb LF	266	for (dir = 0; dir <= DIR_BI_DIR; dir++) {
f88ec6cb LF	267	if (search_dir[dir] == false)
94a79942	268	continue;
f88ec6cb	269	list_for_each_entry(pRet, psearch_list, List) {
94a79942 LF	270	if (memcmp(pRet->Addr, Addr, 6) == 0)
	271	if (pRet->TSpec.f.TSInfo.field.ucTSID == TID)
	272	if (pRet->TSpec.f.TSInfo.field.ucDirection == dir)
94a79942	273	break;
94a79942 LF	274
	275	}
	276	if (&pRet->List != psearch_list)
	277	break;
	278	}
	279
d7613e53	280	if (pRet && &pRet->List != psearch_list)
94a79942	281	return pRet ;
94a79942 LF	282	else
	283	return NULL;
	284	}
	285
ec0dc6be LF	286	static void MakeTSEntry(struct ts_common_info pTsCommonInfo, u8 Addr,
	287	union tspec_body pTSPEC, union qos_tclas pTCLAS,
	288	u8 TCLAS_Num, u8 TCLAS_Proc)
94a79942 LF	289	{
	290	u8 count;
	291
	292	if (pTsCommonInfo == NULL)
	293	return;
	294
	295	memcpy(pTsCommonInfo->Addr, Addr, 6);
	296
	297	if (pTSPEC != NULL)
f88ec6cb LF	298	memcpy((u8 )(&(pTsCommonInfo->TSpec)), (u8 )pTSPEC,
f88ec6cb LF	299	sizeof(union tspec_body));
94a79942 LF	300
94a79942 LF	301	for (count = 0; count < TCLAS_Num; count++)
f88ec6cb LF	302	memcpy((u8 *)(&(pTsCommonInfo->TClass[count])),
f88ec6cb LF	303	(u8 *)pTCLAS, sizeof(union qos_tclas));
94a79942 LF	304
	305	pTsCommonInfo->TClasProc = TCLAS_Proc;
	306	pTsCommonInfo->TClasNum = TCLAS_Num;
	307	}
	308
f88ec6cb LF	309	bool GetTs(struct rtllib_device ieee, struct ts_common_info *ppTS,
f88ec6cb LF	310	u8 *Addr, u8 TID, enum tr_select TxRxSelect, bool bAddNewTs)
94a79942 LF	311	{
94a79942 LF	312	u8 UP = 0;
14fc4235	313	if (is_multicast_ether_addr(Addr)) {
f88ec6cb LF	314	RTLLIB_DEBUG(RTLLIB_DL_ERR, "ERR! get TS for Broadcast or "
f88ec6cb LF	315	"Multicast\n");
94a79942 LF	316	return false;
	317	}
	318	if (ieee->current_network.qos_data.supported == 0) {
	319	UP = 0;
	320	} else {
	321	if (!IsACValid(TID)) {
f88ec6cb LF	322	RTLLIB_DEBUG(RTLLIB_DL_ERR, "ERR! in %s(), TID(%d) is "
f88ec6cb LF	323	"not valid\n", __func__, TID);
94a79942 LF	324	return false;
	325	}
	326
	327	switch (TID) {
	328	case 0:
	329	case 3:
	330	UP = 0;
	331	break;
	332	case 1:
	333	case 2:
	334	UP = 2;
	335	break;
	336	case 4:
	337	case 5:
	338	UP = 5;
	339	break;
	340	case 6:
	341	case 7:
	342	UP = 7;
	343	break;
	344	}
	345	}
	346
f88ec6cb LF	347	*ppTS = SearchAdmitTRStream(ieee, Addr, UP, TxRxSelect);
f88ec6cb LF	348	if (*ppTS != NULL) {
94a79942	349	return true;
f88ec6cb LF	350	} else {
	351	if (bAddNewTs == false) {
	352	RTLLIB_DEBUG(RTLLIB_DL_TS, "add new TS failed"
	353	"(tid:%d)\n", UP);
94a79942	354	return false;
f88ec6cb	355	} else {
ed306e48	356	union tspec_body TSpec;
42c53e7a	357	union qos_tsinfo *pTSInfo = &TSpec.f.TSInfo;
f88ec6cb LF	358	struct list_head *pUnusedList =
	359	(TxRxSelect == TX_DIR) ?
	360	(&ieee->Tx_TS_Unused_List) :
	361	(&ieee->Rx_TS_Unused_List);
	362
	363	struct list_head *pAddmitList =
	364	(TxRxSelect == TX_DIR) ?
	365	(&ieee->Tx_TS_Admit_List) :
	366	(&ieee->Rx_TS_Admit_List);
	367
	368	enum direction_value Dir =
	369	(ieee->iw_mode == IW_MODE_MASTER) ?
	370	((TxRxSelect == TX_DIR) ? DIR_DOWN : DIR_UP) :
	371	((TxRxSelect == TX_DIR) ? DIR_UP : DIR_DOWN);
94a79942	372	RTLLIB_DEBUG(RTLLIB_DL_TS, "to add Ts\n");
f88ec6cb LF	373	if (!list_empty(pUnusedList)) {
	374	(*ppTS) = list_entry(pUnusedList->next,
	375	struct ts_common_info, List);
94a79942	376	list_del_init(&(*ppTS)->List);
f88ec6cb LF	377	if (TxRxSelect == TX_DIR) {
	378	struct tx_ts_record *tmp =
	379	container_of(*ppTS,
	380	struct tx_ts_record,
	381	TsCommonInfo);
94a79942	382	ResetTxTsEntry(tmp);
f88ec6cb LF	383	} else {
	384	struct rx_ts_record *tmp =
	385	container_of(*ppTS,
	386	struct rx_ts_record,
	387	TsCommonInfo);
94a79942 LF	388	ResetRxTsEntry(tmp);
	389	}
	390
f88ec6cb	391	RTLLIB_DEBUG(RTLLIB_DL_TS, "to init current TS"
ac50ddaa	392	", UP:%d, Dir:%d, addr: %pM"
f88ec6cb	393	" ppTs=%p\n", UP, Dir,
ac50ddaa	394	Addr, *ppTS);
94a79942 LF	395	pTSInfo->field.ucTrafficType = 0;
	396	pTSInfo->field.ucTSID = UP;
	397	pTSInfo->field.ucDirection = Dir;
	398	pTSInfo->field.ucAccessPolicy = 1;
	399	pTSInfo->field.ucAggregation = 0;
	400	pTSInfo->field.ucPSB = 0;
	401	pTSInfo->field.ucUP = UP;
	402	pTSInfo->field.ucTSInfoAckPolicy = 0;
	403	pTSInfo->field.ucSchedule = 0;
	404
	405	MakeTSEntry(*ppTS, Addr, &TSpec, NULL, 0, 0);
	406	AdmitTS(ieee, *ppTS, 0);
	407	list_add_tail(&((*ppTS)->List), pAddmitList);
	408
	409	return true;
f88ec6cb LF	410	} else {
	411	RTLLIB_DEBUG(RTLLIB_DL_ERR, "ERR!!in function "
	412	"%s() There is not enough dir=%d"
	413	"(0=up down=1) TS record to be "
	414	"used!!", __func__, Dir);
94a79942 LF	415	return false;
	416	}
	417	}
	418	}
	419	}
	420
ec0dc6be LF	421	static void RemoveTsEntry(struct rtllib_device ieee, struct ts_common_info pTs,
ec0dc6be LF	422	enum tr_select TxRxSelect)
94a79942 LF	423	{
	424	del_timer_sync(&pTs->SetupTimer);
	425	del_timer_sync(&pTs->InactTimer);
	426	TsInitDelBA(ieee, pTs, TxRxSelect);
	427
f88ec6cb	428	if (TxRxSelect == RX_DIR) {
8cba1432	429	struct rx_reorder_entry *pRxReorderEntry;
2c47ae28	430	struct rx_ts_record pRxTS = (struct rx_ts_record )pTs;
94a79942 LF	431
	432	if (timer_pending(&pRxTS->RxPktPendingTimer))
	433	del_timer_sync(&pRxTS->RxPktPendingTimer);
	434
f88ec6cb LF	435	while (!list_empty(&pRxTS->RxPendingPktList)) {
	436	pRxReorderEntry = (struct rx_reorder_entry *)
	437	list_entry(pRxTS->RxPendingPktList.prev,
	438	struct rx_reorder_entry, List);
	439	RTLLIB_DEBUG(RTLLIB_DL_REORDER, "%s(): Delete SeqNum "
	440	"%d!\n", __func__,
	441	pRxReorderEntry->SeqNum);
94a79942 LF	442	list_del_init(&pRxReorderEntry->List);
	443	{
	444	int i = 0;
f88ec6cb LF	445	struct rtllib_rxb *prxb = pRxReorderEntry->prxb;
f88ec6cb LF	446	if (unlikely(!prxb))
94a79942	447	return;
f88ec6cb	448	for (i = 0; i < prxb->nr_subframes; i++)
94a79942	449	dev_kfree_skb(prxb->subframes[i]);
94a79942 LF	450	kfree(prxb);
	451	prxb = NULL;
	452	}
f88ec6cb LF	453	list_add_tail(&pRxReorderEntry->List,
f88ec6cb LF	454	&ieee->RxReorder_Unused_List);
94a79942	455	}
f88ec6cb	456	} else {
60554f2b	457	struct tx_ts_record pTxTS = (struct tx_ts_record )pTs;
94a79942 LF	458	del_timer_sync(&pTxTS->TsAddBaTimer);
	459	}
	460	}
	461
f88ec6cb	462	void RemovePeerTS(struct rtllib_device ieee, u8 Addr)
94a79942	463	{
74724de1	464	struct ts_common_info pTS, pTmpTS;
ac50ddaa	465	printk(KERN_INFO "===========>RemovePeerTS, %pM\n", Addr);
4f6807e8	466
f88ec6cb LF	467	list_for_each_entry_safe(pTS, pTmpTS, &ieee->Tx_TS_Pending_List, List) {
f88ec6cb LF	468	if (memcmp(pTS->Addr, Addr, 6) == 0) {
94a79942 LF	469	RemoveTsEntry(ieee, pTS, TX_DIR);
	470	list_del_init(&pTS->List);
	471	list_add_tail(&pTS->List, &ieee->Tx_TS_Unused_List);
	472	}
	473	}
	474
f88ec6cb LF	475	list_for_each_entry_safe(pTS, pTmpTS, &ieee->Tx_TS_Admit_List, List) {
	476	if (memcmp(pTS->Addr, Addr, 6) == 0) {
	477	printk(KERN_INFO "====>remove Tx_TS_admin_list\n");
94a79942 LF	478	RemoveTsEntry(ieee, pTS, TX_DIR);
	479	list_del_init(&pTS->List);
	480	list_add_tail(&pTS->List, &ieee->Tx_TS_Unused_List);
	481	}
	482	}
	483
f88ec6cb LF	484	list_for_each_entry_safe(pTS, pTmpTS, &ieee->Rx_TS_Pending_List, List) {
f88ec6cb LF	485	if (memcmp(pTS->Addr, Addr, 6) == 0) {
94a79942 LF	486	RemoveTsEntry(ieee, pTS, RX_DIR);
	487	list_del_init(&pTS->List);
	488	list_add_tail(&pTS->List, &ieee->Rx_TS_Unused_List);
	489	}
	490	}
	491
f88ec6cb LF	492	list_for_each_entry_safe(pTS, pTmpTS, &ieee->Rx_TS_Admit_List, List) {
f88ec6cb LF	493	if (memcmp(pTS->Addr, Addr, 6) == 0) {
94a79942 LF	494	RemoveTsEntry(ieee, pTS, RX_DIR);
	495	list_del_init(&pTS->List);
	496	list_add_tail(&pTS->List, &ieee->Rx_TS_Unused_List);
	497	}
	498	}
94a79942	499	}
3b28499c	500	EXPORT_SYMBOL(RemovePeerTS);
94a79942	501
f88ec6cb	502	void RemoveAllTS(struct rtllib_device *ieee)
94a79942	503	{
74724de1	504	struct ts_common_info pTS, pTmpTS;
4f6807e8	505
f88ec6cb	506	list_for_each_entry_safe(pTS, pTmpTS, &ieee->Tx_TS_Pending_List, List) {
94a79942 LF	507	RemoveTsEntry(ieee, pTS, TX_DIR);
	508	list_del_init(&pTS->List);
	509	list_add_tail(&pTS->List, &ieee->Tx_TS_Unused_List);
	510	}
	511
f88ec6cb	512	list_for_each_entry_safe(pTS, pTmpTS, &ieee->Tx_TS_Admit_List, List) {
94a79942 LF	513	RemoveTsEntry(ieee, pTS, TX_DIR);
	514	list_del_init(&pTS->List);
	515	list_add_tail(&pTS->List, &ieee->Tx_TS_Unused_List);
	516	}
	517
f88ec6cb	518	list_for_each_entry_safe(pTS, pTmpTS, &ieee->Rx_TS_Pending_List, List) {
94a79942 LF	519	RemoveTsEntry(ieee, pTS, RX_DIR);
	520	list_del_init(&pTS->List);
	521	list_add_tail(&pTS->List, &ieee->Rx_TS_Unused_List);
	522	}
	523
f88ec6cb	524	list_for_each_entry_safe(pTS, pTmpTS, &ieee->Rx_TS_Admit_List, List) {
94a79942 LF	525	RemoveTsEntry(ieee, pTS, RX_DIR);
	526	list_del_init(&pTS->List);
	527	list_add_tail(&pTS->List, &ieee->Rx_TS_Unused_List);
	528	}
94a79942 LF	529	}
94a79942 LF	530
f88ec6cb	531	void TsStartAddBaProcess(struct rtllib_device ieee, struct tx_ts_record pTxTS)
94a79942	532	{
f88ec6cb	533	if (pTxTS->bAddBaReqInProgress == false) {
94a79942	534	pTxTS->bAddBaReqInProgress = true;
4f6807e8	535
f88ec6cb LF	536	if (pTxTS->bAddBaReqDelayed) {
	537	RTLLIB_DEBUG(RTLLIB_DL_BA, "TsStartAddBaProcess(): "
	538	"Delayed Start ADDBA after 60 sec!!\n");
	539	mod_timer(&pTxTS->TsAddBaTimer, jiffies +
	540	MSECS(TS_ADDBA_DELAY));
	541	} else {
	542	RTLLIB_DEBUG(RTLLIB_DL_BA, "TsStartAddBaProcess(): "
	543	"Immediately Start ADDBA now!!\n");
94a79942 LF	544	mod_timer(&pTxTS->TsAddBaTimer, jiffies+10);
94a79942 LF	545	}
f88ec6cb LF	546	} else
	547	RTLLIB_DEBUG(RTLLIB_DL_BA, "%s()==>BA timer is already added\n",
	548	__func__);
94a79942	549	}