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