drivers/staging/rtl8192e/ieee80211/rtl819x_TSProc.c

   1 #include "ieee80211.h"
   2 #include <linux/etherdevice.h>
   3 #include <linux/slab.h>
   4 #include "rtl819x_TS.h"
   5
   6 void TsSetupTimeOut(unsigned long data)
   7 {
   8         // Not implement yet
   9         // This is used for WMMSA and ACM , that would send ADDTSReq frame.
  10 }
  11
  12 void TsInactTimeout(unsigned long data)
  13 {
  14         // Not implement yet
  15         // This is used for WMMSA and ACM.
  16         // This function would be call when TS is no Tx/Rx for some period of time.
  17 }
  18
  19 /********************************************************************************************************************
  20  *function:  I still not understand this function, so wait for further implementation
  21  *   input:  unsigned long       data           //acturally we send TX_TS_RECORD or RX_TS_RECORD to these timer
  22  *  return:  NULL
  23  *  notice:
  24 ********************************************************************************************************************/
  25 void RxPktPendingTimeout(unsigned long data)
  26 {
  27         PRX_TS_RECORD   pRxTs = (PRX_TS_RECORD)data;
  28         struct ieee80211_device *ieee = container_of(pRxTs, struct ieee80211_device, RxTsRecord[pRxTs->num]);
  29
  30         PRX_REORDER_ENTRY       pReorderEntry = NULL;
  31
  32         //u32 flags = 0;
  33         unsigned long flags = 0;
  34         struct ieee80211_rxb *stats_IndicateArray[REORDER_WIN_SIZE];
  35         u8 index = 0;
  36         bool bPktInBuf = false;
  37
  38
  39         spin_lock_irqsave(&(ieee->reorder_spinlock), flags);
  40         //PlatformAcquireSpinLock(Adapter, RT_RX_SPINLOCK);
  41         IEEE80211_DEBUG(IEEE80211_DL_REORDER,"==================>%s()\n",__FUNCTION__);
  42         if(pRxTs->RxTimeoutIndicateSeq != 0xffff)
  43         {
  44                 // Indicate the pending packets sequentially according to SeqNum until meet the gap.
  45                 while(!list_empty(&pRxTs->RxPendingPktList))
  46                 {
  47                         pReorderEntry = (PRX_REORDER_ENTRY)list_entry(pRxTs->RxPendingPktList.prev,RX_REORDER_ENTRY,List);
  48                         if(index == 0)
  49                                 pRxTs->RxIndicateSeq = pReorderEntry->SeqNum;
  50
  51                         if( SN_LESS(pReorderEntry->SeqNum, pRxTs->RxIndicateSeq) ||
  52                                 SN_EQUAL(pReorderEntry->SeqNum, pRxTs->RxIndicateSeq)   )
  53                         {
  54                                 list_del_init(&pReorderEntry->List);
  55
  56                                 if(SN_EQUAL(pReorderEntry->SeqNum, pRxTs->RxIndicateSeq))
  57                                         pRxTs->RxIndicateSeq = (pRxTs->RxIndicateSeq + 1) % 4096;
  58
  59                                 IEEE80211_DEBUG(IEEE80211_DL_REORDER,"RxPktPendingTimeout(): IndicateSeq: %d\n", pReorderEntry->SeqNum);
  60                                 stats_IndicateArray[index] = pReorderEntry->prxb;
  61                                 index++;
  62
  63                                 list_add_tail(&pReorderEntry->List, &ieee->RxReorder_Unused_List);
  64                         }
  65                         else
  66                         {
  67                                 bPktInBuf = true;
  68                                 break;
  69                         }
  70                 }
  71         }
  72
  73         if(index>0)
  74         {
  75                 // Set RxTimeoutIndicateSeq to 0xffff to indicate no pending packets in buffer now.
  76                 pRxTs->RxTimeoutIndicateSeq = 0xffff;
  77
  78                 // Indicate packets
  79                 if(index > REORDER_WIN_SIZE){
  80                         IEEE80211_DEBUG(IEEE80211_DL_ERR, "RxReorderIndicatePacket(): Rx Reorer buffer full!! \n");
  81                         spin_unlock_irqrestore(&(ieee->reorder_spinlock), flags);
  82                         return;
  83                 }
  84                 ieee80211_indicate_packets(ieee, stats_IndicateArray, index);
  85         }
  86
  87         if(bPktInBuf && (pRxTs->RxTimeoutIndicateSeq==0xffff))
  88         {
  89                 pRxTs->RxTimeoutIndicateSeq = pRxTs->RxIndicateSeq;
  90                 mod_timer(&pRxTs->RxPktPendingTimer, jiffies + MSECS(ieee->pHTInfo->RxReorderPendingTime));
  91         }
  92         spin_unlock_irqrestore(&(ieee->reorder_spinlock), flags);
  93         //PlatformReleaseSpinLock(Adapter, RT_RX_SPINLOCK);
  94 }
  95
  96 /********************************************************************************************************************
  97  *function:  Add BA timer function
  98  *   input:  unsigned long       data           //acturally we send TX_TS_RECORD or RX_TS_RECORD to these timer
  99  *  return:  NULL
 100  *  notice:
 101 ********************************************************************************************************************/
 102 void TsAddBaProcess(unsigned long data)
 103 {
 104         PTX_TS_RECORD   pTxTs = (PTX_TS_RECORD)data;
 105         u8 num = pTxTs->num;
 106         struct ieee80211_device *ieee = container_of(pTxTs, struct ieee80211_device, TxTsRecord[num]);
 107
 108         TsInitAddBA(ieee, pTxTs, BA_POLICY_IMMEDIATE, false);
 109         IEEE80211_DEBUG(IEEE80211_DL_BA, "TsAddBaProcess(): ADDBA Req is started!! \n");
 110 }
 111
 112
 113 void ResetTsCommonInfo(PTS_COMMON_INFO  pTsCommonInfo)
 114 {
 115         memset(pTsCommonInfo->Addr, 0, 6);
 116         memset(&pTsCommonInfo->TSpec, 0, sizeof(TSPEC_BODY));
 117         memset(&pTsCommonInfo->TClass, 0, sizeof(QOS_TCLAS)*TCLAS_NUM);
 118         pTsCommonInfo->TClasProc = 0;
 119         pTsCommonInfo->TClasNum = 0;
 120 }
 121
 122 void ResetTxTsEntry(PTX_TS_RECORD pTS)
 123 {
 124         ResetTsCommonInfo(&pTS->TsCommonInfo);
 125         pTS->TxCurSeq = 0;
 126         pTS->bAddBaReqInProgress = false;
 127         pTS->bAddBaReqDelayed = false;
 128         pTS->bUsingBa = false;
 129         ResetBaEntry(&pTS->TxAdmittedBARecord); //For BA Originator
 130         ResetBaEntry(&pTS->TxPendingBARecord);
 131 }
 132
 133 void ResetRxTsEntry(PRX_TS_RECORD pTS)
 134 {
 135         ResetTsCommonInfo(&pTS->TsCommonInfo);
 136         pTS->RxIndicateSeq = 0xffff; // This indicate the RxIndicateSeq is not used now!!
 137         pTS->RxTimeoutIndicateSeq = 0xffff; // This indicate the RxTimeoutIndicateSeq is not used now!!
 138         ResetBaEntry(&pTS->RxAdmittedBARecord);   // For BA Recepient
 139 }
 140
 141 void TSInitialize(struct ieee80211_device *ieee)
 142 {
 143         PTX_TS_RECORD           pTxTS  = ieee->TxTsRecord;
 144         PRX_TS_RECORD           pRxTS  = ieee->RxTsRecord;
 145         PRX_REORDER_ENTRY       pRxReorderEntry = ieee->RxReorderEntry;
 146         u8                              count = 0;
 147         IEEE80211_DEBUG(IEEE80211_DL_TS, "==========>%s()\n", __FUNCTION__);
 148         // Initialize Tx TS related info.
 149         INIT_LIST_HEAD(&ieee->Tx_TS_Admit_List);
 150         INIT_LIST_HEAD(&ieee->Tx_TS_Pending_List);
 151         INIT_LIST_HEAD(&ieee->Tx_TS_Unused_List);
 152
 153         for(count = 0; count < TOTAL_TS_NUM; count++)
 154         {
 155                 //
 156                 pTxTS->num = count;
 157                 // The timers for the operation of Traffic Stream and Block Ack.
 158                 // DLS related timer will be add here in the future!!
 159                 init_timer(&pTxTS->TsCommonInfo.SetupTimer);
 160                 pTxTS->TsCommonInfo.SetupTimer.data = (unsigned long)pTxTS;
 161                 pTxTS->TsCommonInfo.SetupTimer.function = TsSetupTimeOut;
 162
 163                 init_timer(&pTxTS->TsCommonInfo.InactTimer);
 164                 pTxTS->TsCommonInfo.InactTimer.data = (unsigned long)pTxTS;
 165                 pTxTS->TsCommonInfo.InactTimer.function = TsInactTimeout;
 166
 167                 init_timer(&pTxTS->TsAddBaTimer);
 168                 pTxTS->TsAddBaTimer.data = (unsigned long)pTxTS;
 169                 pTxTS->TsAddBaTimer.function = TsAddBaProcess;
 170
 171                 init_timer(&pTxTS->TxPendingBARecord.Timer);
 172                 pTxTS->TxPendingBARecord.Timer.data = (unsigned long)pTxTS;
 173                 pTxTS->TxPendingBARecord.Timer.function = BaSetupTimeOut;
 174
 175                 init_timer(&pTxTS->TxAdmittedBARecord.Timer);
 176                 pTxTS->TxAdmittedBARecord.Timer.data = (unsigned long)pTxTS;
 177                 pTxTS->TxAdmittedBARecord.Timer.function = TxBaInactTimeout;
 178
 179                 ResetTxTsEntry(pTxTS);
 180                 list_add_tail(&pTxTS->TsCommonInfo.List, &ieee->Tx_TS_Unused_List);
 181                 pTxTS++;
 182         }
 183
 184         // Initialize Rx TS related info.
 185         INIT_LIST_HEAD(&ieee->Rx_TS_Admit_List);
 186         INIT_LIST_HEAD(&ieee->Rx_TS_Pending_List);
 187         INIT_LIST_HEAD(&ieee->Rx_TS_Unused_List);
 188         for(count = 0; count < TOTAL_TS_NUM; count++)
 189         {
 190                 pRxTS->num = count;
 191                 INIT_LIST_HEAD(&pRxTS->RxPendingPktList);
 192
 193                 init_timer(&pRxTS->TsCommonInfo.SetupTimer);
 194                 pRxTS->TsCommonInfo.SetupTimer.data = (unsigned long)pRxTS;
 195                 pRxTS->TsCommonInfo.SetupTimer.function = TsSetupTimeOut;
 196
 197                 init_timer(&pRxTS->TsCommonInfo.InactTimer);
 198                 pRxTS->TsCommonInfo.InactTimer.data = (unsigned long)pRxTS;
 199                 pRxTS->TsCommonInfo.InactTimer.function = TsInactTimeout;
 200
 201                 init_timer(&pRxTS->RxAdmittedBARecord.Timer);
 202                 pRxTS->RxAdmittedBARecord.Timer.data = (unsigned long)pRxTS;
 203                 pRxTS->RxAdmittedBARecord.Timer.function = RxBaInactTimeout;
 204
 205                 init_timer(&pRxTS->RxPktPendingTimer);
 206                 pRxTS->RxPktPendingTimer.data = (unsigned long)pRxTS;
 207                 pRxTS->RxPktPendingTimer.function = RxPktPendingTimeout;
 208
 209                 ResetRxTsEntry(pRxTS);
 210                 list_add_tail(&pRxTS->TsCommonInfo.List, &ieee->Rx_TS_Unused_List);
 211                 pRxTS++;
 212         }
 213         // Initialize unused Rx Reorder List.
 214         INIT_LIST_HEAD(&ieee->RxReorder_Unused_List);
 215 //#ifdef TO_DO_LIST
 216         for(count = 0; count < REORDER_ENTRY_NUM; count++)
 217         {
 218                 list_add_tail( &pRxReorderEntry->List,&ieee->RxReorder_Unused_List);
 219                 if(count == (REORDER_ENTRY_NUM-1))
 220                         break;
 221                 pRxReorderEntry = &ieee->RxReorderEntry[count+1];
 222         }
 223 //#endif
 224
 225 }
 226
 227 void AdmitTS(struct ieee80211_device *ieee, PTS_COMMON_INFO pTsCommonInfo, u32 InactTime)
 228 {
 229         del_timer_sync(&pTsCommonInfo->SetupTimer);
 230         del_timer_sync(&pTsCommonInfo->InactTimer);
 231
 232         if(InactTime!=0)
 233                 mod_timer(&pTsCommonInfo->InactTimer, jiffies + MSECS(InactTime));
 234 }
 235
 236
 237 PTS_COMMON_INFO SearchAdmitTRStream(struct ieee80211_device *ieee, u8*  Addr, u8 TID, TR_SELECT TxRxSelect)
 238 {
 239         //DIRECTION_VALUE       dir;
 240         u8      dir;
 241         bool                            search_dir[4] = {0, 0, 0, 0};
 242         struct list_head*               psearch_list; //FIXME
 243         PTS_COMMON_INFO pRet = NULL;
 244         if(ieee->iw_mode == IW_MODE_MASTER) //ap mode
 245         {
 246                 if(TxRxSelect == TX_DIR)
 247                 {
 248                         search_dir[DIR_DOWN] = true;
 249                         search_dir[DIR_BI_DIR]= true;
 250                 }
 251                 else
 252                 {
 253                         search_dir[DIR_UP]      = true;
 254                         search_dir[DIR_BI_DIR]= true;
 255                 }
 256         }
 257         else if(ieee->iw_mode == IW_MODE_ADHOC)
 258         {
 259                 if(TxRxSelect == TX_DIR)
 260                         search_dir[DIR_UP]      = true;
 261                 else
 262                         search_dir[DIR_DOWN] = true;
 263         }
 264         else
 265         {
 266                 if(TxRxSelect == TX_DIR)
 267                 {
 268                         search_dir[DIR_UP]      = true;
 269                         search_dir[DIR_BI_DIR]= true;
 270                         search_dir[DIR_DIRECT]= true;
 271                 }
 272                 else
 273                 {
 274                         search_dir[DIR_DOWN] = true;
 275                         search_dir[DIR_BI_DIR]= true;
 276                         search_dir[DIR_DIRECT]= true;
 277                 }
 278         }
 279
 280         if(TxRxSelect == TX_DIR)
 281                 psearch_list = &ieee->Tx_TS_Admit_List;
 282         else
 283                 psearch_list = &ieee->Rx_TS_Admit_List;
 284
 285         //for(dir = DIR_UP; dir <= DIR_BI_DIR; dir++)
 286         for(dir = 0; dir <= DIR_BI_DIR; dir++)
 287         {
 288                 if(search_dir[dir] ==false )
 289                         continue;
 290                 list_for_each_entry(pRet, psearch_list, List){
 291         //              IEEE80211_DEBUG(IEEE80211_DL_TS, "ADD:%pM, TID:%d, dir:%d\n", pRet->Addr, pRet->TSpec.f.TSInfo.field.ucTSID, pRet->TSpec.f.TSInfo.field.ucDirection);
 292                         if (memcmp(pRet->Addr, Addr, 6) == 0)
 293                                 if (pRet->TSpec.f.TSInfo.field.ucTSID == TID)
 294                                         if(pRet->TSpec.f.TSInfo.field.ucDirection == dir)
 295                                         {
 296                                                 break;
 297                                         }
 298
 299                 }
 300                 if(&pRet->List  != psearch_list)
 301                         break;
 302         }
 303
 304         if(&pRet->List  != psearch_list){
 305                 return pRet ;
 306         }
 307         else
 308                 return NULL;
 309 }
 310
 311 void MakeTSEntry(
 312                 PTS_COMMON_INFO pTsCommonInfo,
 313                 u8*             Addr,
 314                 PTSPEC_BODY     pTSPEC,
 315                 PQOS_TCLAS      pTCLAS,
 316                 u8              TCLAS_Num,
 317                 u8              TCLAS_Proc
 318         )
 319 {
 320         u8      count;
 321
 322         if(pTsCommonInfo == NULL)
 323                 return;
 324
 325         memcpy(pTsCommonInfo->Addr, Addr, 6);
 326
 327         if(pTSPEC != NULL)
 328                 memcpy((u8*)(&(pTsCommonInfo->TSpec)), (u8*)pTSPEC, sizeof(TSPEC_BODY));
 329
 330         for(count = 0; count < TCLAS_Num; count++)
 331                 memcpy((u8*)(&(pTsCommonInfo->TClass[count])), (u8*)pTCLAS, sizeof(QOS_TCLAS));
 332
 333         pTsCommonInfo->TClasProc = TCLAS_Proc;
 334         pTsCommonInfo->TClasNum = TCLAS_Num;
 335 }
 336
 337
 338 bool GetTs(
 339         struct ieee80211_device*        ieee,
 340         PTS_COMMON_INFO                 *ppTS,
 341         u8*                             Addr,
 342         u8                              TID,
 343         TR_SELECT                       TxRxSelect,  //Rx:1, Tx:0
 344         bool                            bAddNewTs
 345         )
 346 {
 347         u8      UP = 0;
 348         //
 349         // We do not build any TS for Broadcast or Multicast stream.
 350         // So reject these kinds of search here.
 351         //
 352         if(is_broadcast_ether_addr(Addr) || is_multicast_ether_addr(Addr))
 353         {
 354                 IEEE80211_DEBUG(IEEE80211_DL_ERR, "get TS for Broadcast or Multicast\n");
 355                 return false;
 356         }
 357
 358         if (ieee->current_network.qos_data.supported == 0)
 359                 UP = 0;
 360         else
 361         {
 362                 // In WMM case: we use 4 TID only
 363                 if (!IsACValid(TID))
 364                 {
 365                         IEEE80211_DEBUG(IEEE80211_DL_ERR, " in %s(), TID(%d) is not valid\n", __FUNCTION__, TID);
 366                         return false;
 367                 }
 368
 369                 switch(TID)
 370                 {
 371                 case 0:
 372                 case 3:
 373                         UP = 0;
 374                         break;
 375
 376                 case 1:
 377                 case 2:
 378                         UP = 2;
 379                         break;
 380
 381                 case 4:
 382                 case 5:
 383                         UP = 5;
 384                         break;
 385
 386                 case 6:
 387                 case 7:
 388                         UP = 7;
 389                         break;
 390                 }
 391         }
 392
 393         *ppTS = SearchAdmitTRStream(
 394                         ieee,
 395                         Addr,
 396                         UP,
 397                         TxRxSelect);
 398         if(*ppTS != NULL)
 399         {
 400                 return true;
 401         }
 402         else
 403         {
 404                 if(bAddNewTs == false)
 405                 {
 406                         IEEE80211_DEBUG(IEEE80211_DL_TS, "add new TS failed(tid:%d)\n", UP);
 407                         return false;
 408                 }
 409                 else
 410                 {
 411                         //
 412                         // Create a new Traffic stream for current Tx/Rx
 413                         // This is for EDCA and WMM to add a new TS.
 414                         // For HCCA or WMMSA, TS cannot be addmit without negotiation.
 415                         //
 416                         TSPEC_BODY      TSpec;
 417                         PQOS_TSINFO             pTSInfo = &TSpec.f.TSInfo;
 418                         struct list_head*       pUnusedList =
 419                                                                 (TxRxSelect == TX_DIR)?
 420                                                                 (&ieee->Tx_TS_Unused_List):
 421                                                                 (&ieee->Rx_TS_Unused_List);
 422
 423                         struct list_head*       pAddmitList =
 424                                                                 (TxRxSelect == TX_DIR)?
 425                                                                 (&ieee->Tx_TS_Admit_List):
 426                                                                 (&ieee->Rx_TS_Admit_List);
 427
 428                         DIRECTION_VALUE         Dir =           (ieee->iw_mode == IW_MODE_MASTER)?
 429                                                                 ((TxRxSelect==TX_DIR)?DIR_DOWN:DIR_UP):
 430                                                                 ((TxRxSelect==TX_DIR)?DIR_UP:DIR_DOWN);
 431                         IEEE80211_DEBUG(IEEE80211_DL_TS, "to add Ts\n");
 432                         if(!list_empty(pUnusedList))
 433                         {
 434                                 (*ppTS) = list_entry(pUnusedList->next, TS_COMMON_INFO, List);
 435                                 list_del_init(&(*ppTS)->List);
 436                                 if(TxRxSelect==TX_DIR)
 437                                 {
 438                                         PTX_TS_RECORD tmp = container_of(*ppTS, TX_TS_RECORD, TsCommonInfo);
 439                                         ResetTxTsEntry(tmp);
 440                                 }
 441                                 else{
 442                                         PRX_TS_RECORD tmp = container_of(*ppTS, RX_TS_RECORD, TsCommonInfo);
 443                                         ResetRxTsEntry(tmp);
 444                                 }
 445
 446                                 IEEE80211_DEBUG(IEEE80211_DL_TS, "to init current TS, UP:%d, Dir:%d, addr:%pM\n", UP, Dir, Addr);
 447                                 // Prepare TS Info releated field
 448                                 pTSInfo->field.ucTrafficType = 0;                       // Traffic type: WMM is reserved in this field
 449                                 pTSInfo->field.ucTSID = UP;                     // TSID
 450                                 pTSInfo->field.ucDirection = Dir;                       // Direction: if there is DirectLink, this need additional consideration.
 451                                 pTSInfo->field.ucAccessPolicy = 1;              // Access policy
 452                                 pTSInfo->field.ucAggregation = 0;               // Aggregation
 453                                 pTSInfo->field.ucPSB = 0;                               // Aggregation
 454                                 pTSInfo->field.ucUP = UP;                               // User priority
 455                                 pTSInfo->field.ucTSInfoAckPolicy = 0;           // Ack policy
 456                                 pTSInfo->field.ucSchedule = 0;                  // Schedule
 457
 458                                 MakeTSEntry(*ppTS, Addr, &TSpec, NULL, 0, 0);
 459                                 AdmitTS(ieee, *ppTS, 0);
 460                                 list_add_tail(&((*ppTS)->List), pAddmitList);
 461                                 // if there is DirectLink, we need to do additional operation here!!
 462
 463                                 return true;
 464                         }
 465                         else
 466                         {
 467                                 IEEE80211_DEBUG(IEEE80211_DL_ERR, "in function %s() There is not enough TS record to be used!!", __FUNCTION__);
 468                                 return false;
 469                         }
 470                 }
 471         }
 472 }
 473
 474 void RemoveTsEntry(
 475         struct ieee80211_device*        ieee,
 476         PTS_COMMON_INFO                 pTs,
 477         TR_SELECT                       TxRxSelect
 478         )
 479 {
 480         //u32 flags = 0;
 481         unsigned long flags = 0;
 482         del_timer_sync(&pTs->SetupTimer);
 483         del_timer_sync(&pTs->InactTimer);
 484         TsInitDelBA(ieee, pTs, TxRxSelect);
 485
 486         if(TxRxSelect == RX_DIR)
 487         {
 488 //#ifdef TO_DO_LIST
 489                 PRX_REORDER_ENTRY       pRxReorderEntry;
 490                 PRX_TS_RECORD           pRxTS = (PRX_TS_RECORD)pTs;
 491                 if(timer_pending(&pRxTS->RxPktPendingTimer))
 492                         del_timer_sync(&pRxTS->RxPktPendingTimer);
 493
 494                 while(!list_empty(&pRxTS->RxPendingPktList))
 495                 {
 496                 //      PlatformAcquireSpinLock(Adapter, RT_RX_SPINLOCK);
 497                         spin_lock_irqsave(&(ieee->reorder_spinlock), flags);
 498                         //pRxReorderEntry = list_entry(&pRxTS->RxPendingPktList.prev,RX_REORDER_ENTRY,List);
 499                         pRxReorderEntry = (PRX_REORDER_ENTRY)list_entry(pRxTS->RxPendingPktList.prev,RX_REORDER_ENTRY,List);
 500                         list_del_init(&pRxReorderEntry->List);
 501                         {
 502                                 int i = 0;
 503                                 struct ieee80211_rxb * prxb = pRxReorderEntry->prxb;
 504                                 if (unlikely(!prxb))
 505                                 {
 506                                         spin_unlock_irqrestore(&(ieee->reorder_spinlock), flags);
 507                                         return;
 508                                 }
 509                                 for(i =0; i < prxb->nr_subframes; i++) {
 510                                         dev_kfree_skb(prxb->subframes[i]);
 511                                 }
 512                                 kfree(prxb);
 513                                 prxb = NULL;
 514                         }
 515                         list_add_tail(&pRxReorderEntry->List,&ieee->RxReorder_Unused_List);
 516                         //PlatformReleaseSpinLock(Adapter, RT_RX_SPINLOCK);
 517                         spin_unlock_irqrestore(&(ieee->reorder_spinlock), flags);
 518                 }
 519
 520 //#endif
 521         }
 522         else
 523         {
 524                 PTX_TS_RECORD pTxTS = (PTX_TS_RECORD)pTs;
 525                 del_timer_sync(&pTxTS->TsAddBaTimer);
 526         }
 527 }
 528
 529 void RemovePeerTS(struct ieee80211_device* ieee, u8* Addr)
 530 {
 531         PTS_COMMON_INFO pTS, pTmpTS;
 532
 533         printk("===========>RemovePeerTS,%pM\n", Addr);
 534         list_for_each_entry_safe(pTS, pTmpTS, &ieee->Tx_TS_Pending_List, List)
 535         {
 536                 if (memcmp(pTS->Addr, Addr, 6) == 0)
 537                 {
 538                         RemoveTsEntry(ieee, pTS, TX_DIR);
 539                         list_del_init(&pTS->List);
 540                         list_add_tail(&pTS->List, &ieee->Tx_TS_Unused_List);
 541                 }
 542         }
 543
 544         list_for_each_entry_safe(pTS, pTmpTS, &ieee->Tx_TS_Admit_List, List)
 545         {
 546                 if (memcmp(pTS->Addr, Addr, 6) == 0)
 547                 {
 548                         printk("====>remove Tx_TS_admin_list\n");
 549                         RemoveTsEntry(ieee, pTS, TX_DIR);
 550                         list_del_init(&pTS->List);
 551                         list_add_tail(&pTS->List, &ieee->Tx_TS_Unused_List);
 552                 }
 553         }
 554
 555         list_for_each_entry_safe(pTS, pTmpTS, &ieee->Rx_TS_Pending_List, List)
 556         {
 557                 if (memcmp(pTS->Addr, Addr, 6) == 0)
 558                 {
 559                         RemoveTsEntry(ieee, pTS, RX_DIR);
 560                         list_del_init(&pTS->List);
 561                         list_add_tail(&pTS->List, &ieee->Rx_TS_Unused_List);
 562                 }
 563         }
 564
 565         list_for_each_entry_safe(pTS, pTmpTS, &ieee->Rx_TS_Admit_List, List)
 566         {
 567                 if (memcmp(pTS->Addr, Addr, 6) == 0)
 568                 {
 569                         RemoveTsEntry(ieee, pTS, RX_DIR);
 570                         list_del_init(&pTS->List);
 571                         list_add_tail(&pTS->List, &ieee->Rx_TS_Unused_List);
 572                 }
 573         }
 574 }
 575
 576 void RemoveAllTS(struct ieee80211_device* ieee)
 577 {
 578         PTS_COMMON_INFO pTS, pTmpTS;
 579
 580         list_for_each_entry_safe(pTS, pTmpTS, &ieee->Tx_TS_Pending_List, List)
 581         {
 582                 RemoveTsEntry(ieee, pTS, TX_DIR);
 583                 list_del_init(&pTS->List);
 584                 list_add_tail(&pTS->List, &ieee->Tx_TS_Unused_List);
 585         }
 586
 587         list_for_each_entry_safe(pTS, pTmpTS, &ieee->Tx_TS_Admit_List, List)
 588         {
 589                 RemoveTsEntry(ieee, pTS, TX_DIR);
 590                 list_del_init(&pTS->List);
 591                 list_add_tail(&pTS->List, &ieee->Tx_TS_Unused_List);
 592         }
 593
 594         list_for_each_entry_safe(pTS, pTmpTS, &ieee->Rx_TS_Pending_List, List)
 595         {
 596                 RemoveTsEntry(ieee, pTS, RX_DIR);
 597                 list_del_init(&pTS->List);
 598                 list_add_tail(&pTS->List, &ieee->Rx_TS_Unused_List);
 599         }
 600
 601         list_for_each_entry_safe(pTS, pTmpTS, &ieee->Rx_TS_Admit_List, List)
 602         {
 603                 RemoveTsEntry(ieee, pTS, RX_DIR);
 604                 list_del_init(&pTS->List);
 605                 list_add_tail(&pTS->List, &ieee->Rx_TS_Unused_List);
 606         }
 607 }
 608
 609 void TsStartAddBaProcess(struct ieee80211_device* ieee, PTX_TS_RECORD   pTxTS)
 610 {
 611         if(pTxTS->bAddBaReqInProgress == false)
 612         {
 613                 pTxTS->bAddBaReqInProgress = true;
 614                 if(pTxTS->bAddBaReqDelayed)
 615                 {
 616                         IEEE80211_DEBUG(IEEE80211_DL_BA, "TsStartAddBaProcess(): Delayed Start ADDBA after 60 sec!!\n");
 617                         mod_timer(&pTxTS->TsAddBaTimer, jiffies + MSECS(TS_ADDBA_DELAY));
 618                 }
 619                 else
 620                 {
 621                         IEEE80211_DEBUG(IEEE80211_DL_BA,"TsStartAddBaProcess(): Immediately Start ADDBA now!!\n");
 622                         mod_timer(&pTxTS->TsAddBaTimer, jiffies+10); //set 10 ticks
 623                 }
 624         }
 625         else
 626                 IEEE80211_DEBUG(IEEE80211_DL_ERR, "%s()==>BA timer is already added\n", __FUNCTION__);
 627 }