projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix common misspellings
[deliverable/linux.git] / drivers / staging / rt2860 / common / ba_action.c
1 /*
2 *************************************************************************
3 * Ralink Tech Inc.
4 * 5F., No.36, Taiyuan St., Jhubei City,
5 * Hsinchu County 302,
6 * Taiwan, R.O.C.
7 *
8 * (c) Copyright 2002-2007, Ralink Technology, Inc.
9 *
10 * This program is free software; you can redistribute it and/or modify *
11 * it under the terms of the GNU General Public License as published by *
12 * the Free Software Foundation; either version 2 of the License, or *
13 * (at your option) any later version. *
14 * *
15 * This program is distributed in the hope that it will be useful, *
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
18 * GNU General Public License for more details. *
19 * *
20 * You should have received a copy of the GNU General Public License *
21 * along with this program; if not, write to the *
22 * Free Software Foundation, Inc., *
23 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
24 * *
25 *************************************************************************
26 */
27
28 #include "../rt_config.h"
29 #include <linux/kernel.h>
30
31 #define BA_ORI_INIT_SEQ (pEntry->TxSeq[TID]) /*1 // initial sequence number of BA session */
32
33 #define ORI_SESSION_MAX_RETRY 8
34 #define ORI_BA_SESSION_TIMEOUT (2000) /* ms */
35 #define REC_BA_SESSION_IDLE_TIMEOUT (1000) /* ms */
36
37 #define REORDERING_PACKET_TIMEOUT ((100 * OS_HZ)/1000) /* system ticks -- 100 ms */
38 #define MAX_REORDERING_PACKET_TIMEOUT ((3000 * OS_HZ)/1000) /* system ticks -- 100 ms */
39
40 #define RESET_RCV_SEQ (0xFFFF)
41
42 static void ba_mpdu_blk_free(struct rt_rtmp_adapter *pAd,
43 struct reordering_mpdu *mpdu_blk);
44
45 struct rt_ba_ori_entry *BATableAllocOriEntry(struct rt_rtmp_adapter *pAd, u16 * Idx);
46
47 struct rt_ba_rec_entry *BATableAllocRecEntry(struct rt_rtmp_adapter *pAd, u16 * Idx);
48
49 void BAOriSessionSetupTimeout(void *SystemSpecific1,
50 void *FunctionContext,
51 void *SystemSpecific2,
52 void *SystemSpecific3);
53
54 void BARecSessionIdleTimeout(void *SystemSpecific1,
55 void *FunctionContext,
56 void *SystemSpecific2,
57 void *SystemSpecific3);
58
59 BUILD_TIMER_FUNCTION(BAOriSessionSetupTimeout);
60 BUILD_TIMER_FUNCTION(BARecSessionIdleTimeout);
61
62 #define ANNOUNCE_REORDERING_PACKET(_pAd, _mpdu_blk) \
63 Announce_Reordering_Packet(_pAd, _mpdu_blk);
64
65 void BA_MaxWinSizeReasign(struct rt_rtmp_adapter *pAd,
66 struct rt_mac_table_entry *pEntryPeer, u8 * pWinSize)
67 {
68 u8 MaxSize;
69
70 if (pAd->MACVersion >= RALINK_2883_VERSION) /* 3*3 */
71 {
72 if (pAd->MACVersion >= RALINK_3070_VERSION) {
73 if (pEntryPeer->WepStatus !=
74 Ndis802_11EncryptionDisabled)
75 MaxSize = 7; /* for non-open mode */
76 else
77 MaxSize = 13;
78 } else
79 MaxSize = 31;
80 } else if (pAd->MACVersion >= RALINK_2880E_VERSION) /* 2880 e */
81 {
82 if (pEntryPeer->WepStatus != Ndis802_11EncryptionDisabled)
83 MaxSize = 7; /* for non-open mode */
84 else
85 MaxSize = 13;
86 } else
87 MaxSize = 7;
88
89 DBGPRINT(RT_DEBUG_TRACE, ("ba> Win Size = %d, Max Size = %d\n",
90 *pWinSize, MaxSize));
91
92 if ((*pWinSize) > MaxSize) {
93 DBGPRINT(RT_DEBUG_TRACE,
94 ("ba> reassign max win size from %d to %d\n",
95 *pWinSize, MaxSize));
96
97 *pWinSize = MaxSize;
98 }
99 }
100
101 void Announce_Reordering_Packet(struct rt_rtmp_adapter *pAd,
102 IN struct reordering_mpdu *mpdu)
103 {
104 void *pPacket;
105
106 pPacket = mpdu->pPacket;
107
108 if (mpdu->bAMSDU) {
109 ASSERT(0);
110 BA_Reorder_AMSDU_Announce(pAd, pPacket);
111 } else {
112 /* */
113 /* pass this 802.3 packet to upper layer or forward this packet to WM directly */
114 /* */
115
116 ANNOUNCE_OR_FORWARD_802_3_PACKET(pAd, pPacket,
117 RTMP_GET_PACKET_IF(pPacket));
118 }
119 }
120
121 /*
122 * Insert a reordering mpdu into sorted linked list by sequence no.
123 */
124 BOOLEAN ba_reordering_mpdu_insertsorted(struct reordering_list *list,
125 struct reordering_mpdu *mpdu)
126 {
127
128 struct reordering_mpdu **ppScan = &list->next;
129
130 while (*ppScan != NULL) {
131 if (SEQ_SMALLER((*ppScan)->Sequence, mpdu->Sequence, MAXSEQ)) {
132 ppScan = &(*ppScan)->next;
133 } else if ((*ppScan)->Sequence == mpdu->Sequence) {
134 /* give up this duplicated frame */
135 return (FALSE);
136 } else {
137 /* find position */
138 break;
139 }
140 }
141
142 mpdu->next = *ppScan;
143 *ppScan = mpdu;
144 list->qlen++;
145 return TRUE;
146 }
147
148 /*
149 * caller lock critical section if necessary
150 */
151 static inline void ba_enqueue(struct reordering_list *list,
152 struct reordering_mpdu *mpdu_blk)
153 {
154 list->qlen++;
155 mpdu_blk->next = list->next;
156 list->next = mpdu_blk;
157 }
158
159 /*
160 * caller lock critical section if necessary
161 */
162 static inline struct reordering_mpdu *ba_dequeue(struct reordering_list *list)
163 {
164 struct reordering_mpdu *mpdu_blk = NULL;
165
166 ASSERT(list);
167
168 if (list->qlen) {
169 list->qlen--;
170 mpdu_blk = list->next;
171 if (mpdu_blk) {
172 list->next = mpdu_blk->next;
173 mpdu_blk->next = NULL;
174 }
175 }
176 return mpdu_blk;
177 }
178
179 static inline struct reordering_mpdu *ba_reordering_mpdu_dequeue(struct
180 reordering_list
181 *list)
182 {
183 return (ba_dequeue(list));
184 }
185
186 static inline struct reordering_mpdu *ba_reordering_mpdu_probe(struct
187 reordering_list
188 *list)
189 {
190 ASSERT(list);
191
192 return (list->next);
193 }
194
195 /*
196 * free all resource for reordering mechanism
197 */
198 void ba_reordering_resource_release(struct rt_rtmp_adapter *pAd)
199 {
200 struct rt_ba_table *Tab;
201 struct rt_ba_rec_entry *pBAEntry;
202 struct reordering_mpdu *mpdu_blk;
203 int i;
204
205 Tab = &pAd->BATable;
206
207 /* I. release all pending reordering packet */
208 NdisAcquireSpinLock(&pAd->BATabLock);
209 for (i = 0; i < MAX_LEN_OF_BA_REC_TABLE; i++) {
210 pBAEntry = &Tab->BARecEntry[i];
211 if (pBAEntry->REC_BA_Status != Recipient_NONE) {
212 while ((mpdu_blk =
213 ba_reordering_mpdu_dequeue(&pBAEntry->list))) {
214 ASSERT(mpdu_blk->pPacket);
215 RELEASE_NDIS_PACKET(pAd, mpdu_blk->pPacket,
216 NDIS_STATUS_FAILURE);
217 ba_mpdu_blk_free(pAd, mpdu_blk);
218 }
219 }
220 }
221 NdisReleaseSpinLock(&pAd->BATabLock);
222
223 ASSERT(pBAEntry->list.qlen == 0);
224 /* II. free memory of reordering mpdu table */
225 NdisAcquireSpinLock(&pAd->mpdu_blk_pool.lock);
226 os_free_mem(pAd, pAd->mpdu_blk_pool.mem);
227 NdisReleaseSpinLock(&pAd->mpdu_blk_pool.lock);
228 }
229
230 /*
231 * Allocate all resource for reordering mechanism
232 */
233 BOOLEAN ba_reordering_resource_init(struct rt_rtmp_adapter *pAd, int num)
234 {
235 int i;
236 u8 *mem;
237 struct reordering_mpdu *mpdu_blk;
238 struct reordering_list *freelist;
239
240 /* allocate spinlock */
241 NdisAllocateSpinLock(&pAd->mpdu_blk_pool.lock);
242
243 /* initialize freelist */
244 freelist = &pAd->mpdu_blk_pool.freelist;
245 freelist->next = NULL;
246 freelist->qlen = 0;
247
248 DBGPRINT(RT_DEBUG_TRACE,
249 ("Allocate %d memory for BA reordering\n",
250 (u32)(num * sizeof(struct reordering_mpdu))));
251
252 /* allocate number of mpdu_blk memory */
253 os_alloc_mem(pAd, (u8 **) & mem,
254 (num * sizeof(struct reordering_mpdu)));
255
256 pAd->mpdu_blk_pool.mem = mem;
257
258 if (mem == NULL) {
259 DBGPRINT(RT_DEBUG_ERROR,
260 ("Can't Allocate Memory for BA Reordering\n"));
261 return (FALSE);
262 }
263
264 /* build mpdu_blk free list */
265 for (i = 0; i < num; i++) {
266 /* get mpdu_blk */
267 mpdu_blk = (struct reordering_mpdu *)mem;
268 /* initial mpdu_blk */
269 NdisZeroMemory(mpdu_blk, sizeof(struct reordering_mpdu));
270 /* next mpdu_blk */
271 mem += sizeof(struct reordering_mpdu);
272 /* insert mpdu_blk into freelist */
273 ba_enqueue(freelist, mpdu_blk);
274 }
275
276 return (TRUE);
277 }
278
279 /*static int blk_count=0; // sample take off, no use */
280
281 static struct reordering_mpdu *ba_mpdu_blk_alloc(struct rt_rtmp_adapter *pAd)
282 {
283 struct reordering_mpdu *mpdu_blk;
284
285 NdisAcquireSpinLock(&pAd->mpdu_blk_pool.lock);
286 mpdu_blk = ba_dequeue(&pAd->mpdu_blk_pool.freelist);
287 if (mpdu_blk) {
288 /* blk_count++; */
289 /* reset mpdu_blk */
290 NdisZeroMemory(mpdu_blk, sizeof(struct reordering_mpdu));
291 }
292 NdisReleaseSpinLock(&pAd->mpdu_blk_pool.lock);
293 return mpdu_blk;
294 }
295
296 static void ba_mpdu_blk_free(struct rt_rtmp_adapter *pAd,
297 struct reordering_mpdu *mpdu_blk)
298 {
299 ASSERT(mpdu_blk);
300
301 NdisAcquireSpinLock(&pAd->mpdu_blk_pool.lock);
302 /* blk_count--; */
303 ba_enqueue(&pAd->mpdu_blk_pool.freelist, mpdu_blk);
304 NdisReleaseSpinLock(&pAd->mpdu_blk_pool.lock);
305 }
306
307 static u16 ba_indicate_reordering_mpdus_in_order(struct rt_rtmp_adapter *pAd,
308 struct rt_ba_rec_entry *pBAEntry,
309 u16 StartSeq)
310 {
311 struct reordering_mpdu *mpdu_blk;
312 u16 LastIndSeq = RESET_RCV_SEQ;
313
314 NdisAcquireSpinLock(&pBAEntry->RxReRingLock);
315
316 while ((mpdu_blk = ba_reordering_mpdu_probe(&pBAEntry->list))) {
317 /* find in-order frame */
318 if (!SEQ_STEPONE(mpdu_blk->Sequence, StartSeq, MAXSEQ)) {
319 break;
320 }
321 /* dequeue in-order frame from reodering list */
322 mpdu_blk = ba_reordering_mpdu_dequeue(&pBAEntry->list);
323 /* pass this frame up */
324 ANNOUNCE_REORDERING_PACKET(pAd, mpdu_blk);
325 /* move to next sequence */
326 StartSeq = mpdu_blk->Sequence;
327 LastIndSeq = StartSeq;
328 /* free mpdu_blk */
329 ba_mpdu_blk_free(pAd, mpdu_blk);
330 }
331
332 NdisReleaseSpinLock(&pBAEntry->RxReRingLock);
333
334 /* update last indicated sequence */
335 return LastIndSeq;
336 }
337
338 static void ba_indicate_reordering_mpdus_le_seq(struct rt_rtmp_adapter *pAd,
339 struct rt_ba_rec_entry *pBAEntry,
340 u16 Sequence)
341 {
342 struct reordering_mpdu *mpdu_blk;
343
344 NdisAcquireSpinLock(&pBAEntry->RxReRingLock);
345 while ((mpdu_blk = ba_reordering_mpdu_probe(&pBAEntry->list))) {
346 /* find in-order frame */
347 if ((mpdu_blk->Sequence == Sequence)
348 || SEQ_SMALLER(mpdu_blk->Sequence, Sequence, MAXSEQ)) {
349 /* dequeue in-order frame from reodering list */
350 mpdu_blk = ba_reordering_mpdu_dequeue(&pBAEntry->list);
351 /* pass this frame up */
352 ANNOUNCE_REORDERING_PACKET(pAd, mpdu_blk);
353 /* free mpdu_blk */
354 ba_mpdu_blk_free(pAd, mpdu_blk);
355 } else {
356 break;
357 }
358 }
359 NdisReleaseSpinLock(&pBAEntry->RxReRingLock);
360 }
361
362 static void ba_refresh_reordering_mpdus(struct rt_rtmp_adapter *pAd,
363 struct rt_ba_rec_entry *pBAEntry)
364 {
365 struct reordering_mpdu *mpdu_blk;
366
367 NdisAcquireSpinLock(&pBAEntry->RxReRingLock);
368
369 /* dequeue in-order frame from reodering list */
370 while ((mpdu_blk = ba_reordering_mpdu_dequeue(&pBAEntry->list))) {
371 /* pass this frame up */
372 ANNOUNCE_REORDERING_PACKET(pAd, mpdu_blk);
373
374 pBAEntry->LastIndSeq = mpdu_blk->Sequence;
375 ba_mpdu_blk_free(pAd, mpdu_blk);
376
377 /* update last indicated sequence */
378 }
379 ASSERT(pBAEntry->list.qlen == 0);
380 pBAEntry->LastIndSeq = RESET_RCV_SEQ;
381 NdisReleaseSpinLock(&pBAEntry->RxReRingLock);
382 }
383
384 /*static */
385 void ba_flush_reordering_timeout_mpdus(struct rt_rtmp_adapter *pAd,
386 struct rt_ba_rec_entry *pBAEntry,
387 unsigned long Now32)
388 {
389 u16 Sequence;
390
391 /* if ((RTMP_TIME_AFTER((unsigned long)Now32, (unsigned long)(pBAEntry->LastIndSeqAtTimer+REORDERING_PACKET_TIMEOUT)) && */
392 /* (pBAEntry->list.qlen > ((pBAEntry->BAWinSize*7)/8))) //|| */
393 /* (RTMP_TIME_AFTER((unsigned long)Now32, (unsigned long)(pBAEntry->LastIndSeqAtTimer+(10*REORDERING_PACKET_TIMEOUT))) && */
394 /* (pBAEntry->list.qlen > (pBAEntry->BAWinSize/8))) */
395 if (RTMP_TIME_AFTER
396 ((unsigned long)Now32,
397 (unsigned long)(pBAEntry->LastIndSeqAtTimer +
398 (MAX_REORDERING_PACKET_TIMEOUT / 6)))
399 && (pBAEntry->list.qlen > 1)
400 ) {
401 DBGPRINT(RT_DEBUG_TRACE,
402 ("timeout[%d] (%08lx-%08lx = %d > %d): %x, flush all!\n ",
403 pBAEntry->list.qlen, Now32,
404 (pBAEntry->LastIndSeqAtTimer),
405 (int)((long)Now32 -
406 (long)(pBAEntry->LastIndSeqAtTimer)),
407 MAX_REORDERING_PACKET_TIMEOUT, pBAEntry->LastIndSeq));
408 ba_refresh_reordering_mpdus(pAd, pBAEntry);
409 pBAEntry->LastIndSeqAtTimer = Now32;
410 } else
411 if (RTMP_TIME_AFTER
412 ((unsigned long)Now32,
413 (unsigned long)(pBAEntry->LastIndSeqAtTimer +
414 (REORDERING_PACKET_TIMEOUT)))
415 && (pBAEntry->list.qlen > 0)
416 ) {
417 /* */
418 /* force LastIndSeq to shift to LastIndSeq+1 */
419 /* */
420 Sequence = (pBAEntry->LastIndSeq + 1) & MAXSEQ;
421 ba_indicate_reordering_mpdus_le_seq(pAd, pBAEntry, Sequence);
422 pBAEntry->LastIndSeqAtTimer = Now32;
423 pBAEntry->LastIndSeq = Sequence;
424 /* */
425 /* indicate in-order mpdus */
426 /* */
427 Sequence =
428 ba_indicate_reordering_mpdus_in_order(pAd, pBAEntry,
429 Sequence);
430 if (Sequence != RESET_RCV_SEQ) {
431 pBAEntry->LastIndSeq = Sequence;
432 }
433
434 DBGPRINT(RT_DEBUG_OFF,
435 ("%x, flush one!\n", pBAEntry->LastIndSeq));
436
437 }
438 }
439
440 /*
441 * generate ADDBA request to
442 * set up BA agreement
443 */
444 void BAOriSessionSetUp(struct rt_rtmp_adapter *pAd,
445 struct rt_mac_table_entry *pEntry,
446 u8 TID,
447 u16 TimeOut,
448 unsigned long DelayTime, IN BOOLEAN isForced)
449 {
450 /*struct rt_mlme_addba_req AddbaReq; */
451 struct rt_ba_ori_entry *pBAEntry = NULL;
452 u16 Idx;
453 BOOLEAN Cancelled;
454
455 if ((pAd->CommonCfg.BACapability.field.AutoBA != TRUE)
456 && (isForced == FALSE))
457 return;
458
459 /* if this entry is limited to use legacy tx mode, it doesn't generate BA. */
460 if (RTMPStaFixedTxMode(pAd, pEntry) != FIXED_TXMODE_HT)
461 return;
462
463 if ((pEntry->BADeclineBitmap & (1 << TID)) && (isForced == FALSE)) {
464 /* try again after 3 secs */
465 DelayTime = 3000;
466 /* DBGPRINT(RT_DEBUG_TRACE, ("DeCline BA from Peer\n")); */
467 /* return; */
468 }
469
470 Idx = pEntry->BAOriWcidArray[TID];
471 if (Idx == 0) {
472 /* allocate a BA session */
473 pBAEntry = BATableAllocOriEntry(pAd, &Idx);
474 if (pBAEntry == NULL) {
475 DBGPRINT(RT_DEBUG_TRACE,
476 ("ADDBA - MlmeADDBAAction() allocate BA session failed \n"));
477 return;
478 }
479 } else {
480 pBAEntry = &pAd->BATable.BAOriEntry[Idx];
481 }
482
483 if (pBAEntry->ORI_BA_Status >= Originator_WaitRes) {
484 return;
485 }
486
487 pEntry->BAOriWcidArray[TID] = Idx;
488
489 /* Initialize BA session */
490 pBAEntry->ORI_BA_Status = Originator_WaitRes;
491 pBAEntry->Wcid = pEntry->Aid;
492 pBAEntry->BAWinSize = pAd->CommonCfg.BACapability.field.RxBAWinLimit;
493 pBAEntry->Sequence = BA_ORI_INIT_SEQ;
494 pBAEntry->Token = 1; /* (2008-01-21) Jan Lee recommends it - this token can't be 0 */
495 pBAEntry->TID = TID;
496 pBAEntry->TimeOutValue = TimeOut;
497 pBAEntry->pAdapter = pAd;
498
499 if (!(pEntry->TXBAbitmap & (1 << TID))) {
500 RTMPInitTimer(pAd, &pBAEntry->ORIBATimer,
501 GET_TIMER_FUNCTION(BAOriSessionSetupTimeout),
502 pBAEntry, FALSE);
503 } else
504 RTMPCancelTimer(&pBAEntry->ORIBATimer, &Cancelled);
505
506 /* set timer to send ADDBA request */
507 RTMPSetTimer(&pBAEntry->ORIBATimer, DelayTime);
508 }
509
510 void BAOriSessionAdd(struct rt_rtmp_adapter *pAd,
511 struct rt_mac_table_entry *pEntry, struct rt_frame_addba_rsp * pFrame)
512 {
513 struct rt_ba_ori_entry *pBAEntry = NULL;
514 BOOLEAN Cancelled;
515 u8 TID;
516 u16 Idx;
517 u8 *pOutBuffer2 = NULL;
518 int NStatus;
519 unsigned long FrameLen;
520 struct rt_frame_bar FrameBar;
521
522 TID = pFrame->BaParm.TID;
523 Idx = pEntry->BAOriWcidArray[TID];
524 pBAEntry = &pAd->BATable.BAOriEntry[Idx];
525
526 /* Start fill in parameters. */
527 if ((Idx != 0) && (pBAEntry->TID == TID)
528 && (pBAEntry->ORI_BA_Status == Originator_WaitRes)) {
529 pBAEntry->BAWinSize =
530 min(pBAEntry->BAWinSize, ((u8)pFrame->BaParm.BufSize));
531 BA_MaxWinSizeReasign(pAd, pEntry, &pBAEntry->BAWinSize);
532
533 pBAEntry->TimeOutValue = pFrame->TimeOutValue;
534 pBAEntry->ORI_BA_Status = Originator_Done;
535 pAd->BATable.numDoneOriginator++;
536
537 /* reset sequence number */
538 pBAEntry->Sequence = BA_ORI_INIT_SEQ;
539 /* Set Bitmap flag. */
540 pEntry->TXBAbitmap |= (1 << TID);
541 RTMPCancelTimer(&pBAEntry->ORIBATimer, &Cancelled);
542
543 pBAEntry->ORIBATimer.TimerValue = 0; /*pFrame->TimeOutValue; */
544
545 DBGPRINT(RT_DEBUG_TRACE,
546 ("%s : TXBAbitmap = %x, BAWinSize = %d, TimeOut = %ld\n",
547 __func__, pEntry->TXBAbitmap, pBAEntry->BAWinSize,
548 pBAEntry->ORIBATimer.TimerValue));
549
550 /* SEND BAR ; */
551 NStatus = MlmeAllocateMemory(pAd, &pOutBuffer2); /*Get an unused nonpaged memory */
552 if (NStatus != NDIS_STATUS_SUCCESS) {
553 DBGPRINT(RT_DEBUG_TRACE,
554 ("BA - BAOriSessionAdd() allocate memory failed \n"));
555 return;
556 }
557
558 BarHeaderInit(pAd, &FrameBar,
559 pAd->MacTab.Content[pBAEntry->Wcid].Addr,
560 pAd->CurrentAddress);
561
562 FrameBar.StartingSeq.field.FragNum = 0; /* make sure sequence not clear in DEL function. */
563 FrameBar.StartingSeq.field.StartSeq = pBAEntry->Sequence; /* make sure sequence not clear in DEL funciton. */
564 FrameBar.BarControl.TID = pBAEntry->TID; /* make sure sequence not clear in DEL funciton. */
565 MakeOutgoingFrame(pOutBuffer2, &FrameLen,
566 sizeof(struct rt_frame_bar), &FrameBar, END_OF_ARGS);
567 MiniportMMRequest(pAd, QID_AC_BE, pOutBuffer2, FrameLen);
568 MlmeFreeMemory(pAd, pOutBuffer2);
569
570 if (pBAEntry->ORIBATimer.TimerValue)
571 RTMPSetTimer(&pBAEntry->ORIBATimer, pBAEntry->ORIBATimer.TimerValue); /* in mSec */
572 }
573 }
574
575 BOOLEAN BARecSessionAdd(struct rt_rtmp_adapter *pAd,
576 struct rt_mac_table_entry *pEntry, struct rt_frame_addba_req * pFrame)
577 {
578 struct rt_ba_rec_entry *pBAEntry = NULL;
579 BOOLEAN Status = TRUE;
580 BOOLEAN Cancelled;
581 u16 Idx;
582 u8 TID;
583 u8 BAWinSize;
584 /*u32 Value; */
585 /*u32 offset; */
586
587 ASSERT(pEntry);
588
589 /* find TID */
590 TID = pFrame->BaParm.TID;
591
592 BAWinSize =
593 min(((u8)pFrame->BaParm.BufSize),
594 (u8)pAd->CommonCfg.BACapability.field.RxBAWinLimit);
595
596 /* Intel patch */
597 if (BAWinSize == 0) {
598 BAWinSize = 64;
599 }
600
601 Idx = pEntry->BARecWcidArray[TID];
602
603 if (Idx == 0) {
604 pBAEntry = BATableAllocRecEntry(pAd, &Idx);
605 } else {
606 pBAEntry = &pAd->BATable.BARecEntry[Idx];
607 /* flush all pending reordering mpdus */
608 ba_refresh_reordering_mpdus(pAd, pBAEntry);
609 }
610
611 DBGPRINT(RT_DEBUG_TRACE,
612 ("%s(%ld): Idx = %d, BAWinSize(req %d) = %d\n", __func__,
613 pAd->BATable.numAsRecipient, Idx, pFrame->BaParm.BufSize,
614 BAWinSize));
615
616 /* Start fill in parameters. */
617 if (pBAEntry != NULL) {
618 ASSERT(pBAEntry->list.qlen == 0);
619
620 pBAEntry->REC_BA_Status = Recipient_HandleRes;
621 pBAEntry->BAWinSize = BAWinSize;
622 pBAEntry->Wcid = pEntry->Aid;
623 pBAEntry->TID = TID;
624 pBAEntry->TimeOutValue = pFrame->TimeOutValue;
625 pBAEntry->REC_BA_Status = Recipient_Accept;
626 /* initial sequence number */
627 pBAEntry->LastIndSeq = RESET_RCV_SEQ; /*pFrame->BaStartSeq.field.StartSeq; */
628
629 DBGPRINT(RT_DEBUG_OFF,
630 ("Start Seq = %08x\n",
631 pFrame->BaStartSeq.field.StartSeq));
632
633 if (pEntry->RXBAbitmap & (1 << TID)) {
634 RTMPCancelTimer(&pBAEntry->RECBATimer, &Cancelled);
635 } else {
636 RTMPInitTimer(pAd, &pBAEntry->RECBATimer,
637 GET_TIMER_FUNCTION
638 (BARecSessionIdleTimeout), pBAEntry,
639 TRUE);
640 }
641
642 /* Set Bitmap flag. */
643 pEntry->RXBAbitmap |= (1 << TID);
644 pEntry->BARecWcidArray[TID] = Idx;
645
646 pEntry->BADeclineBitmap &= ~(1 << TID);
647
648 /* Set BA session mask in WCID table. */
649 RTMP_ADD_BA_SESSION_TO_ASIC(pAd, pEntry->Aid, TID);
650
651 DBGPRINT(RT_DEBUG_TRACE,
652 ("MACEntry[%d]RXBAbitmap = 0x%x. BARecWcidArray=%d\n",
653 pEntry->Aid, pEntry->RXBAbitmap,
654 pEntry->BARecWcidArray[TID]));
655 } else {
656 Status = FALSE;
657 DBGPRINT(RT_DEBUG_TRACE,
658 ("Can't Accept ADDBA for %pM TID = %d\n",
659 pEntry->Addr, TID));
660 }
661 return (Status);
662 }
663
664 struct rt_ba_rec_entry *BATableAllocRecEntry(struct rt_rtmp_adapter *pAd, u16 * Idx)
665 {
666 int i;
667 struct rt_ba_rec_entry *pBAEntry = NULL;
668
669 NdisAcquireSpinLock(&pAd->BATabLock);
670
671 if (pAd->BATable.numAsRecipient >= MAX_BARECI_SESSION) {
672 DBGPRINT(RT_DEBUG_OFF, ("BA Recipeint Session (%ld) > %d\n",
673 pAd->BATable.numAsRecipient,
674 MAX_BARECI_SESSION));
675 goto done;
676 }
677 /* reserve idx 0 to identify BAWcidArray[TID] as empty */
678 for (i = 1; i < MAX_LEN_OF_BA_REC_TABLE; i++) {
679 pBAEntry = &pAd->BATable.BARecEntry[i];
680 if ((pBAEntry->REC_BA_Status == Recipient_NONE)) {
681 /* get one */
682 pAd->BATable.numAsRecipient++;
683 pBAEntry->REC_BA_Status = Recipient_USED;
684 *Idx = i;
685 break;
686 }
687 }
688
689 done:
690 NdisReleaseSpinLock(&pAd->BATabLock);
691 return pBAEntry;
692 }
693
694 struct rt_ba_ori_entry *BATableAllocOriEntry(struct rt_rtmp_adapter *pAd, u16 * Idx)
695 {
696 int i;
697 struct rt_ba_ori_entry *pBAEntry = NULL;
698
699 NdisAcquireSpinLock(&pAd->BATabLock);
700
701 if (pAd->BATable.numAsOriginator >= (MAX_LEN_OF_BA_ORI_TABLE)) {
702 goto done;
703 }
704 /* reserve idx 0 to identify BAWcidArray[TID] as empty */
705 for (i = 1; i < MAX_LEN_OF_BA_ORI_TABLE; i++) {
706 pBAEntry = &pAd->BATable.BAOriEntry[i];
707 if ((pBAEntry->ORI_BA_Status == Originator_NONE)) {
708 /* get one */
709 pAd->BATable.numAsOriginator++;
710 pBAEntry->ORI_BA_Status = Originator_USED;
711 pBAEntry->pAdapter = pAd;
712 *Idx = i;
713 break;
714 }
715 }
716
717 done:
718 NdisReleaseSpinLock(&pAd->BATabLock);
719 return pBAEntry;
720 }
721
722 void BATableFreeOriEntry(struct rt_rtmp_adapter *pAd, unsigned long Idx)
723 {
724 struct rt_ba_ori_entry *pBAEntry = NULL;
725 struct rt_mac_table_entry *pEntry;
726
727 if ((Idx == 0) || (Idx >= MAX_LEN_OF_BA_ORI_TABLE))
728 return;
729
730 pBAEntry = &pAd->BATable.BAOriEntry[Idx];
731
732 if (pBAEntry->ORI_BA_Status != Originator_NONE) {
733 pEntry = &pAd->MacTab.Content[pBAEntry->Wcid];
734 pEntry->BAOriWcidArray[pBAEntry->TID] = 0;
735
736 NdisAcquireSpinLock(&pAd->BATabLock);
737 if (pBAEntry->ORI_BA_Status == Originator_Done) {
738 pAd->BATable.numDoneOriginator -= 1;
739 pEntry->TXBAbitmap &= (~(1 << (pBAEntry->TID)));
740 DBGPRINT(RT_DEBUG_TRACE,
741 ("BATableFreeOriEntry numAsOriginator= %ld\n",
742 pAd->BATable.numAsRecipient));
743 /* Erase Bitmap flag. */
744 }
745
746 ASSERT(pAd->BATable.numAsOriginator != 0);
747
748 pAd->BATable.numAsOriginator -= 1;
749
750 pBAEntry->ORI_BA_Status = Originator_NONE;
751 pBAEntry->Token = 0;
752 NdisReleaseSpinLock(&pAd->BATabLock);
753 }
754 }
755
756 void BATableFreeRecEntry(struct rt_rtmp_adapter *pAd, unsigned long Idx)
757 {
758 struct rt_ba_rec_entry *pBAEntry = NULL;
759 struct rt_mac_table_entry *pEntry;
760
761 if ((Idx == 0) || (Idx >= MAX_LEN_OF_BA_REC_TABLE))
762 return;
763
764 pBAEntry = &pAd->BATable.BARecEntry[Idx];
765
766 if (pBAEntry->REC_BA_Status != Recipient_NONE) {
767 pEntry = &pAd->MacTab.Content[pBAEntry->Wcid];
768 pEntry->BARecWcidArray[pBAEntry->TID] = 0;
769
770 NdisAcquireSpinLock(&pAd->BATabLock);
771
772 ASSERT(pAd->BATable.numAsRecipient != 0);
773
774 pAd->BATable.numAsRecipient -= 1;
775
776 pBAEntry->REC_BA_Status = Recipient_NONE;
777 NdisReleaseSpinLock(&pAd->BATabLock);
778 }
779 }
780
781 void BAOriSessionTearDown(struct rt_rtmp_adapter *pAd,
782 u8 Wcid,
783 u8 TID,
784 IN BOOLEAN bPassive, IN BOOLEAN bForceSend)
785 {
786 unsigned long Idx = 0;
787 struct rt_ba_ori_entry *pBAEntry;
788 BOOLEAN Cancelled;
789
790 if (Wcid >= MAX_LEN_OF_MAC_TABLE) {
791 return;
792 }
793 /* */
794 /* Locate corresponding BA Originator Entry in BA Table with the (pAddr,TID). */
795 /* */
796 Idx = pAd->MacTab.Content[Wcid].BAOriWcidArray[TID];
797 if ((Idx == 0) || (Idx >= MAX_LEN_OF_BA_ORI_TABLE)) {
798 if (bForceSend == TRUE) {
799 /* force send specified TID DelBA */
800 struct rt_mlme_delba_req DelbaReq;
801 struct rt_mlme_queue_elem *Elem =
802 kmalloc(sizeof(struct rt_mlme_queue_elem),
803 MEM_ALLOC_FLAG);
804 if (Elem != NULL) {
805 NdisZeroMemory(&DelbaReq, sizeof(DelbaReq));
806 NdisZeroMemory(Elem, sizeof(struct rt_mlme_queue_elem));
807
808 COPY_MAC_ADDR(DelbaReq.Addr,
809 pAd->MacTab.Content[Wcid].Addr);
810 DelbaReq.Wcid = Wcid;
811 DelbaReq.TID = TID;
812 DelbaReq.Initiator = ORIGINATOR;
813 Elem->MsgLen = sizeof(DelbaReq);
814 NdisMoveMemory(Elem->Msg, &DelbaReq,
815 sizeof(DelbaReq));
816 MlmeDELBAAction(pAd, Elem);
817 kfree(Elem);
818 } else {
819 DBGPRINT(RT_DEBUG_ERROR,
820 ("%s(bForceSend):alloc memory failed!\n",
821 __func__));
822 }
823 }
824
825 return;
826 }
827
828 DBGPRINT(RT_DEBUG_TRACE,
829 ("%s===>Wcid=%d.TID=%d \n", __func__, Wcid, TID));
830
831 pBAEntry = &pAd->BATable.BAOriEntry[Idx];
832 DBGPRINT(RT_DEBUG_TRACE,
833 ("\t===>Idx = %ld, Wcid=%d.TID=%d, ORI_BA_Status = %d \n", Idx,
834 Wcid, TID, pBAEntry->ORI_BA_Status));
835 /* */
836 /* Prepare DelBA action frame and send to the peer. */
837 /* */
838 if ((bPassive == FALSE) && (TID == pBAEntry->TID)
839 && (pBAEntry->ORI_BA_Status == Originator_Done)) {
840 struct rt_mlme_delba_req DelbaReq;
841 struct rt_mlme_queue_elem *Elem =
842 kmalloc(sizeof(struct rt_mlme_queue_elem),
843 MEM_ALLOC_FLAG);
844 if (Elem != NULL) {
845 NdisZeroMemory(&DelbaReq, sizeof(DelbaReq));
846 NdisZeroMemory(Elem, sizeof(struct rt_mlme_queue_elem));
847
848 COPY_MAC_ADDR(DelbaReq.Addr,
849 pAd->MacTab.Content[Wcid].Addr);
850 DelbaReq.Wcid = Wcid;
851 DelbaReq.TID = pBAEntry->TID;
852 DelbaReq.Initiator = ORIGINATOR;
853 Elem->MsgLen = sizeof(DelbaReq);
854 NdisMoveMemory(Elem->Msg, &DelbaReq, sizeof(DelbaReq));
855 MlmeDELBAAction(pAd, Elem);
856 kfree(Elem);
857 } else {
858 DBGPRINT(RT_DEBUG_ERROR,
859 ("%s():alloc memory failed!\n", __func__));
860 return;
861 }
862 }
863 RTMPCancelTimer(&pBAEntry->ORIBATimer, &Cancelled);
864 BATableFreeOriEntry(pAd, Idx);
865
866 if (bPassive) {
867 /*BAOriSessionSetUp(pAd, &pAd->MacTab.Content[Wcid], TID, 0, 10000, TRUE); */
868 }
869 }
870
871 void BARecSessionTearDown(struct rt_rtmp_adapter *pAd,
872 u8 Wcid, u8 TID, IN BOOLEAN bPassive)
873 {
874 unsigned long Idx = 0;
875 struct rt_ba_rec_entry *pBAEntry;
876
877 if (Wcid >= MAX_LEN_OF_MAC_TABLE) {
878 return;
879 }
880 /* */
881 /* Locate corresponding BA Originator Entry in BA Table with the (pAddr,TID). */
882 /* */
883 Idx = pAd->MacTab.Content[Wcid].BARecWcidArray[TID];
884 if (Idx == 0)
885 return;
886
887 DBGPRINT(RT_DEBUG_TRACE,
888 ("%s===>Wcid=%d.TID=%d \n", __func__, Wcid, TID));
889
890 pBAEntry = &pAd->BATable.BARecEntry[Idx];
891 DBGPRINT(RT_DEBUG_TRACE,
892 ("\t===>Idx = %ld, Wcid=%d.TID=%d, REC_BA_Status = %d \n", Idx,
893 Wcid, TID, pBAEntry->REC_BA_Status));
894 /* */
895 /* Prepare DelBA action frame and send to the peer. */
896 /* */
897 if ((TID == pBAEntry->TID)
898 && (pBAEntry->REC_BA_Status == Recipient_Accept)) {
899 struct rt_mlme_delba_req DelbaReq;
900 BOOLEAN Cancelled;
901 /*unsigned long offset; */
902 /*u32 VALUE; */
903
904 RTMPCancelTimer(&pBAEntry->RECBATimer, &Cancelled);
905
906 /* */
907 /* 1. Send DELBA Action Frame */
908 /* */
909 if (bPassive == FALSE) {
910 struct rt_mlme_queue_elem *Elem =
911 kmalloc(sizeof(struct rt_mlme_queue_elem),
912 MEM_ALLOC_FLAG);
913 if (Elem != NULL) {
914 NdisZeroMemory(&DelbaReq, sizeof(DelbaReq));
915 NdisZeroMemory(Elem, sizeof(struct rt_mlme_queue_elem));
916
917 COPY_MAC_ADDR(DelbaReq.Addr,
918 pAd->MacTab.Content[Wcid].Addr);
919 DelbaReq.Wcid = Wcid;
920 DelbaReq.TID = TID;
921 DelbaReq.Initiator = RECIPIENT;
922 Elem->MsgLen = sizeof(DelbaReq);
923 NdisMoveMemory(Elem->Msg, &DelbaReq,
924 sizeof(DelbaReq));
925 MlmeDELBAAction(pAd, Elem);
926 kfree(Elem);
927 } else {
928 DBGPRINT(RT_DEBUG_ERROR,
929 ("%s():alloc memory failed!\n",
930 __func__));
931 return;
932 }
933 }
934
935 /* */
936 /* 2. Free resource of BA session */
937 /* */
938 /* flush all pending reordering mpdus */
939 ba_refresh_reordering_mpdus(pAd, pBAEntry);
940
941 NdisAcquireSpinLock(&pAd->BATabLock);
942
943 /* Erase Bitmap flag. */
944 pBAEntry->LastIndSeq = RESET_RCV_SEQ;
945 pBAEntry->BAWinSize = 0;
946 /* Erase Bitmap flag at software mactable */
947 pAd->MacTab.Content[Wcid].RXBAbitmap &=
948 (~(1 << (pBAEntry->TID)));
949 pAd->MacTab.Content[Wcid].BARecWcidArray[TID] = 0;
950
951 RTMP_DEL_BA_SESSION_FROM_ASIC(pAd, Wcid, TID);
952
953 NdisReleaseSpinLock(&pAd->BATabLock);
954
955 }
956
957 BATableFreeRecEntry(pAd, Idx);
958 }
959
960 void BASessionTearDownALL(struct rt_rtmp_adapter *pAd, u8 Wcid)
961 {
962 int i;
963
964 for (i = 0; i < NUM_OF_TID; i++) {
965 BAOriSessionTearDown(pAd, Wcid, i, FALSE, FALSE);
966 BARecSessionTearDown(pAd, Wcid, i, FALSE);
967 }
968 }
969
970 /*
971 ==========================================================================
972 Description:
973 Retry sending ADDBA Reqest.
974
975 IRQL = DISPATCH_LEVEL
976
977 Parametrs:
978 p8023Header: if this is already 802.3 format, p8023Header is NULL
979
980 Return : TRUE if put into rx reordering buffer, shouldn't indicaterxhere.
981 FALSE , then continue indicaterx at this moment.
982 ==========================================================================
983 */
984 void BAOriSessionSetupTimeout(void *SystemSpecific1,
985 void *FunctionContext,
986 void *SystemSpecific2,
987 void *SystemSpecific3)
988 {
989 struct rt_ba_ori_entry *pBAEntry = (struct rt_ba_ori_entry *)FunctionContext;
990 struct rt_mac_table_entry *pEntry;
991 struct rt_rtmp_adapter *pAd;
992
993 if (pBAEntry == NULL)
994 return;
995
996 pAd = pBAEntry->pAdapter;
997
998 {
999 /* Do nothing if monitor mode is on */
1000 if (MONITOR_ON(pAd))
1001 return;
1002 }
1003
1004 pEntry = &pAd->MacTab.Content[pBAEntry->Wcid];
1005
1006 if ((pBAEntry->ORI_BA_Status == Originator_WaitRes)
1007 && (pBAEntry->Token < ORI_SESSION_MAX_RETRY)) {
1008 struct rt_mlme_addba_req AddbaReq;
1009
1010 NdisZeroMemory(&AddbaReq, sizeof(AddbaReq));
1011 COPY_MAC_ADDR(AddbaReq.pAddr, pEntry->Addr);
1012 AddbaReq.Wcid = (u8)(pEntry->Aid);
1013 AddbaReq.TID = pBAEntry->TID;
1014 AddbaReq.BaBufSize =
1015 pAd->CommonCfg.BACapability.field.RxBAWinLimit;
1016 AddbaReq.TimeOutValue = 0;
1017 AddbaReq.Token = pBAEntry->Token;
1018 MlmeEnqueue(pAd, ACTION_STATE_MACHINE, MT2_MLME_ADD_BA_CATE,
1019 sizeof(struct rt_mlme_addba_req), (void *)& AddbaReq);
1020 RTMP_MLME_HANDLER(pAd);
1021 DBGPRINT(RT_DEBUG_TRACE,
1022 ("BA Ori Session Timeout(%d) : Send ADD BA again\n",
1023 pBAEntry->Token));
1024
1025 pBAEntry->Token++;
1026 RTMPSetTimer(&pBAEntry->ORIBATimer, ORI_BA_SESSION_TIMEOUT);
1027 } else {
1028 BATableFreeOriEntry(pAd, pEntry->BAOriWcidArray[pBAEntry->TID]);
1029 }
1030 }
1031
1032 /*
1033 ==========================================================================
1034 Description:
1035 Retry sending ADDBA Reqest.
1036
1037 IRQL = DISPATCH_LEVEL
1038
1039 Parametrs:
1040 p8023Header: if this is already 802.3 format, p8023Header is NULL
1041
1042 Return : TRUE if put into rx reordering buffer, shouldn't indicaterxhere.
1043 FALSE , then continue indicaterx at this moment.
1044 ==========================================================================
1045 */
1046 void BARecSessionIdleTimeout(void *SystemSpecific1,
1047 void *FunctionContext,
1048 void *SystemSpecific2, void *SystemSpecific3)
1049 {
1050
1051 struct rt_ba_rec_entry *pBAEntry = (struct rt_ba_rec_entry *)FunctionContext;
1052 struct rt_rtmp_adapter *pAd;
1053 unsigned long Now32;
1054
1055 if (pBAEntry == NULL)
1056 return;
1057
1058 if ((pBAEntry->REC_BA_Status == Recipient_Accept)) {
1059 NdisGetSystemUpTime(&Now32);
1060
1061 if (RTMP_TIME_AFTER
1062 ((unsigned long)Now32,
1063 (unsigned long)(pBAEntry->LastIndSeqAtTimer +
1064 REC_BA_SESSION_IDLE_TIMEOUT))) {
1065 pAd = pBAEntry->pAdapter;
1066 /* flush all pending reordering mpdus */
1067 ba_refresh_reordering_mpdus(pAd, pBAEntry);
1068 DBGPRINT(RT_DEBUG_OFF,
1069 ("%ld: REC BA session Timeout\n", Now32));
1070 }
1071 }
1072 }
1073
1074 void PeerAddBAReqAction(struct rt_rtmp_adapter *pAd, struct rt_mlme_queue_elem *Elem)
1075 {
1076 /* 7.4.4.1 */
1077 /*unsigned long Idx; */
1078 u8 Status = 1;
1079 u8 pAddr[6];
1080 struct rt_frame_addba_rsp ADDframe;
1081 u8 *pOutBuffer = NULL;
1082 int NStatus;
1083 struct rt_frame_addba_req * pAddreqFrame = NULL;
1084 /*u8 BufSize; */
1085 unsigned long FrameLen;
1086 unsigned long *ptemp;
1087 struct rt_mac_table_entry *pMacEntry;
1088
1089 DBGPRINT(RT_DEBUG_TRACE,
1090 ("%s ==> (Wcid = %d)\n", __func__, Elem->Wcid));
1091
1092 /*hex_dump("AddBAReq", Elem->Msg, Elem->MsgLen); */
1093
1094 /*ADDBA Request from unknown peer, ignore this. */
1095 if (Elem->Wcid >= MAX_LEN_OF_MAC_TABLE)
1096 return;
1097
1098 pMacEntry = &pAd->MacTab.Content[Elem->Wcid];
1099 DBGPRINT(RT_DEBUG_TRACE, ("BA - PeerAddBAReqAction----> \n"));
1100 ptemp = (unsigned long *)Elem->Msg;
1101 /*DBGPRINT_RAW(RT_DEBUG_EMU, ("%08x:: %08x:: %08x:: %08x:: %08x:: %08x:: %08x:: %08x:: %08x\n", *(ptemp), *(ptemp+1), *(ptemp+2), *(ptemp+3), *(ptemp+4), *(ptemp+5), *(ptemp+6), *(ptemp+7), *(ptemp+8))); */
1102
1103 if (PeerAddBAReqActionSanity(pAd, Elem->Msg, Elem->MsgLen, pAddr)) {
1104
1105 if ((pAd->CommonCfg.bBADecline == FALSE)
1106 && IS_HT_STA(pMacEntry)) {
1107 pAddreqFrame = (struct rt_frame_addba_req *) (&Elem->Msg[0]);
1108 DBGPRINT(RT_DEBUG_OFF,
1109 ("Rcv Wcid(%d) AddBAReq\n", Elem->Wcid));
1110 if (BARecSessionAdd
1111 (pAd, &pAd->MacTab.Content[Elem->Wcid],
1112 pAddreqFrame))
1113 Status = 0;
1114 else
1115 Status = 38; /* more parameters have invalid values */
1116 } else {
1117 Status = 37; /* the request has been declined. */
1118 }
1119 }
1120
1121 if (pAd->MacTab.Content[Elem->Wcid].ValidAsCLI)
1122 ASSERT(pAd->MacTab.Content[Elem->Wcid].Sst == SST_ASSOC);
1123
1124 pAddreqFrame = (struct rt_frame_addba_req *) (&Elem->Msg[0]);
1125 /* 2. Always send back ADDBA Response */
1126 NStatus = MlmeAllocateMemory(pAd, &pOutBuffer); /*Get an unused nonpaged memory */
1127 if (NStatus != NDIS_STATUS_SUCCESS) {
1128 DBGPRINT(RT_DEBUG_TRACE,
1129 ("ACTION - PeerBAAction() allocate memory failed \n"));
1130 return;
1131 }
1132
1133 NdisZeroMemory(&ADDframe, sizeof(struct rt_frame_addba_rsp));
1134
1135 /* 2-1. Prepare ADDBA Response frame. */
1136 {
1137 if (ADHOC_ON(pAd))
1138 ActHeaderInit(pAd, &ADDframe.Hdr, pAddr,
1139 pAd->CurrentAddress,
1140 pAd->CommonCfg.Bssid);
1141 else
1142 ActHeaderInit(pAd, &ADDframe.Hdr, pAd->CommonCfg.Bssid,
1143 pAd->CurrentAddress, pAddr);
1144 }
1145
1146 ADDframe.Category = CATEGORY_BA;
1147 ADDframe.Action = ADDBA_RESP;
1148 ADDframe.Token = pAddreqFrame->Token;
1149 /* What is the Status code?? need to check. */
1150 ADDframe.StatusCode = Status;
1151 ADDframe.BaParm.BAPolicy = IMMED_BA;
1152 ADDframe.BaParm.AMSDUSupported = 0;
1153 ADDframe.BaParm.TID = pAddreqFrame->BaParm.TID;
1154 ADDframe.BaParm.BufSize =
1155 min(((u8)pAddreqFrame->BaParm.BufSize),
1156 (u8)pAd->CommonCfg.BACapability.field.RxBAWinLimit);
1157 if (ADDframe.BaParm.BufSize == 0) {
1158 ADDframe.BaParm.BufSize = 64;
1159 }
1160 ADDframe.TimeOutValue = 0; /*pAddreqFrame->TimeOutValue; */
1161
1162 *(u16 *) (&ADDframe.BaParm) =
1163 cpu2le16(*(u16 *) (&ADDframe.BaParm));
1164 ADDframe.StatusCode = cpu2le16(ADDframe.StatusCode);
1165 ADDframe.TimeOutValue = cpu2le16(ADDframe.TimeOutValue);
1166
1167 MakeOutgoingFrame(pOutBuffer, &FrameLen,
1168 sizeof(struct rt_frame_addba_rsp), &ADDframe, END_OF_ARGS);
1169 MiniportMMRequest(pAd, QID_AC_BE, pOutBuffer, FrameLen);
1170 MlmeFreeMemory(pAd, pOutBuffer);
1171
1172 DBGPRINT(RT_DEBUG_TRACE,
1173 ("%s(%d): TID(%d), BufSize(%d) <== \n", __func__, Elem->Wcid,
1174 ADDframe.BaParm.TID, ADDframe.BaParm.BufSize));
1175 }
1176
1177 void PeerAddBARspAction(struct rt_rtmp_adapter *pAd, struct rt_mlme_queue_elem *Elem)
1178 {
1179 /*u8 Idx, i; */
1180 /*u8 * pOutBuffer = NULL; */
1181 struct rt_frame_addba_rsp * pFrame = NULL;
1182 /*struct rt_ba_ori_entry *pBAEntry; */
1183
1184 /*ADDBA Response from unknown peer, ignore this. */
1185 if (Elem->Wcid >= MAX_LEN_OF_MAC_TABLE)
1186 return;
1187
1188 DBGPRINT(RT_DEBUG_TRACE, ("%s ==> Wcid(%d)\n", __func__, Elem->Wcid));
1189
1190 /*hex_dump("PeerAddBARspAction()", Elem->Msg, Elem->MsgLen); */
1191
1192 if (PeerAddBARspActionSanity(pAd, Elem->Msg, Elem->MsgLen)) {
1193 pFrame = (struct rt_frame_addba_rsp *) (&Elem->Msg[0]);
1194
1195 DBGPRINT(RT_DEBUG_TRACE,
1196 ("\t\t StatusCode = %d\n", pFrame->StatusCode));
1197 switch (pFrame->StatusCode) {
1198 case 0:
1199 /* I want a BAsession with this peer as an originator. */
1200 BAOriSessionAdd(pAd, &pAd->MacTab.Content[Elem->Wcid],
1201 pFrame);
1202 break;
1203 default:
1204 /* check status == USED ??? */
1205 BAOriSessionTearDown(pAd, Elem->Wcid,
1206 pFrame->BaParm.TID, TRUE, FALSE);
1207 break;
1208 }
1209 /* Rcv Decline StatusCode */
1210 if ((pFrame->StatusCode == 37)
1211 || ((pAd->OpMode == OPMODE_STA) && STA_TGN_WIFI_ON(pAd)
1212 && (pFrame->StatusCode != 0))
1213 ) {
1214 pAd->MacTab.Content[Elem->Wcid].BADeclineBitmap |=
1215 1 << pFrame->BaParm.TID;
1216 }
1217 }
1218 }
1219
1220 void PeerDelBAAction(struct rt_rtmp_adapter *pAd, struct rt_mlme_queue_elem *Elem)
1221 {
1222 /*u8 Idx; */
1223 /*u8 * pOutBuffer = NULL; */
1224 struct rt_frame_delba_req * pDelFrame = NULL;
1225
1226 DBGPRINT(RT_DEBUG_TRACE, ("%s ==>\n", __func__));
1227 /*DELBA Request from unknown peer, ignore this. */
1228 if (PeerDelBAActionSanity(pAd, Elem->Wcid, Elem->Msg, Elem->MsgLen)) {
1229 pDelFrame = (struct rt_frame_delba_req *) (&Elem->Msg[0]);
1230 if (pDelFrame->DelbaParm.Initiator == ORIGINATOR) {
1231 DBGPRINT(RT_DEBUG_TRACE,
1232 ("BA - PeerDelBAAction----> ORIGINATOR\n"));
1233 BARecSessionTearDown(pAd, Elem->Wcid,
1234 pDelFrame->DelbaParm.TID, TRUE);
1235 } else {
1236 DBGPRINT(RT_DEBUG_TRACE,
1237 ("BA - PeerDelBAAction----> RECIPIENT, Reason = %d\n",
1238 pDelFrame->ReasonCode));
1239 /*hex_dump("DelBA Frame", pDelFrame, Elem->MsgLen); */
1240 BAOriSessionTearDown(pAd, Elem->Wcid,
1241 pDelFrame->DelbaParm.TID, TRUE,
1242 FALSE);
1243 }
1244 }
1245 }
1246
1247 BOOLEAN CntlEnqueueForRecv(struct rt_rtmp_adapter *pAd,
1248 unsigned long Wcid,
1249 unsigned long MsgLen, struct rt_frame_ba_req * pMsg)
1250 {
1251 struct rt_frame_ba_req * pFrame = pMsg;
1252 /*PRTMP_REORDERBUF pBuffer; */
1253 /*PRTMP_REORDERBUF pDmaBuf; */
1254 struct rt_ba_rec_entry *pBAEntry;
1255 /*BOOLEAN Result; */
1256 unsigned long Idx;
1257 /*u8 NumRxPkt; */
1258 u8 TID; /*, i; */
1259
1260 TID = (u8)pFrame->BARControl.TID;
1261
1262 DBGPRINT(RT_DEBUG_TRACE,
1263 ("%s(): BAR-Wcid(%ld), Tid (%d)\n", __func__, Wcid, TID));
1264 /*hex_dump("BAR", (char *)pFrame, MsgLen); */
1265 /* Do nothing if the driver is starting halt state. */
1266 /* This might happen when timer already been fired before cancel timer with mlmehalt */
1267 if (RTMP_TEST_FLAG
1268 (pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS | fRTMP_ADAPTER_NIC_NOT_EXIST))
1269 return FALSE;
1270
1271 /* First check the size, it MUST not exceed the mlme queue size */
1272 if (MsgLen > MGMT_DMA_BUFFER_SIZE) {
1273 DBGPRINT_ERR("CntlEnqueueForRecv: frame too large, size = %ld \n", MsgLen);
1274 return FALSE;
1275 } else if (MsgLen != sizeof(struct rt_frame_ba_req)) {
1276 DBGPRINT_ERR("CntlEnqueueForRecv: BlockAck Request frame length size = %ld incorrect\n", MsgLen);
1277 return FALSE;
1278 } else if (MsgLen != sizeof(struct rt_frame_ba_req)) {
1279 DBGPRINT_ERR("CntlEnqueueForRecv: BlockAck Request frame length size = %ld incorrect\n", MsgLen);
1280 return FALSE;
1281 }
1282
1283 if ((Wcid < MAX_LEN_OF_MAC_TABLE) && (TID < 8)) {
1284 /* if this receiving packet is from SA that is in our OriEntry. Since WCID <9 has direct mapping. no need search. */
1285 Idx = pAd->MacTab.Content[Wcid].BARecWcidArray[TID];
1286 pBAEntry = &pAd->BATable.BARecEntry[Idx];
1287 } else {
1288 return FALSE;
1289 }
1290
1291 DBGPRINT(RT_DEBUG_TRACE,
1292 ("BAR(%ld) : Tid (%d) - %04x:%04x\n", Wcid, TID,
1293 pFrame->BAStartingSeq.field.StartSeq, pBAEntry->LastIndSeq));
1294
1295 if (SEQ_SMALLER
1296 (pBAEntry->LastIndSeq, pFrame->BAStartingSeq.field.StartSeq,
1297 MAXSEQ)) {
1298 /*DBGPRINT(RT_DEBUG_TRACE, ("BAR Seq = %x, LastIndSeq = %x\n", pFrame->BAStartingSeq.field.StartSeq, pBAEntry->LastIndSeq)); */
1299 ba_indicate_reordering_mpdus_le_seq(pAd, pBAEntry,
1300 pFrame->BAStartingSeq.field.
1301 StartSeq);
1302 pBAEntry->LastIndSeq =
1303 (pFrame->BAStartingSeq.field.StartSeq ==
1304 0) ? MAXSEQ : (pFrame->BAStartingSeq.field.StartSeq - 1);
1305 }
1306 /*ba_refresh_reordering_mpdus(pAd, pBAEntry); */
1307 return TRUE;
1308 }
1309
1310 /*
1311 Description : Send PSMP Action frame If PSMP mode switches.
1312 */
1313 void SendPSMPAction(struct rt_rtmp_adapter *pAd, u8 Wcid, u8 Psmp)
1314 {
1315 u8 *pOutBuffer = NULL;
1316 int NStatus;
1317 /*unsigned long Idx; */
1318 struct rt_frame_psmp_action Frame;
1319 unsigned long FrameLen;
1320
1321 NStatus = MlmeAllocateMemory(pAd, &pOutBuffer); /*Get an unused nonpaged memory */
1322 if (NStatus != NDIS_STATUS_SUCCESS) {
1323 DBGPRINT(RT_DEBUG_ERROR,
1324 ("BA - MlmeADDBAAction() allocate memory failed \n"));
1325 return;
1326 }
1327
1328 ActHeaderInit(pAd, &Frame.Hdr, pAd->CommonCfg.Bssid,
1329 pAd->CurrentAddress, pAd->MacTab.Content[Wcid].Addr);
1330
1331 Frame.Category = CATEGORY_HT;
1332 Frame.Action = SMPS_ACTION;
1333 switch (Psmp) {
1334 case MMPS_ENABLE:
1335 #ifdef RT30xx
1336 if (IS_RT30xx(pAd)
1337 && (pAd->Antenna.field.RxPath > 1
1338 || pAd->Antenna.field.TxPath > 1)) {
1339 RTMP_ASIC_MMPS_DISABLE(pAd);
1340 }
1341 #endif /* RT30xx // */
1342 Frame.Psmp = 0;
1343 break;
1344 case MMPS_DYNAMIC:
1345 Frame.Psmp = 3;
1346 break;
1347 case MMPS_STATIC:
1348 #ifdef RT30xx
1349 if (IS_RT30xx(pAd)
1350 && (pAd->Antenna.field.RxPath > 1
1351 || pAd->Antenna.field.TxPath > 1)) {
1352 RTMP_ASIC_MMPS_ENABLE(pAd);
1353 }
1354 #endif /* RT30xx // */
1355 Frame.Psmp = 1;
1356 break;
1357 }
1358 MakeOutgoingFrame(pOutBuffer, &FrameLen,
1359 sizeof(struct rt_frame_psmp_action), &Frame, END_OF_ARGS);
1360 MiniportMMRequest(pAd, QID_AC_BE, pOutBuffer, FrameLen);
1361 MlmeFreeMemory(pAd, pOutBuffer);
1362 DBGPRINT(RT_DEBUG_ERROR, ("HT - SendPSMPAction( %d ) \n", Frame.Psmp));
1363 }
1364
1365 #define RADIO_MEASUREMENT_REQUEST_ACTION 0
1366
1367 struct PACKED rt_beacon_request {
1368 u8 RegulatoryClass;
1369 u8 ChannelNumber;
1370 u16 RandomInterval;
1371 u16 MeasurementDuration;
1372 u8 MeasurementMode;
1373 u8 BSSID[MAC_ADDR_LEN];
1374 u8 ReportingCondition;
1375 u8 Threshold;
1376 u8 SSIDIE[2]; /* 2 byte */
1377 };
1378
1379 struct PACKED rt_measurement_req {
1380 u8 ID;
1381 u8 Length;
1382 u8 Token;
1383 u8 RequestMode;
1384 u8 Type;
1385 };
1386
1387 void convert_reordering_packet_to_preAMSDU_or_802_3_packet(struct rt_rtmp_adapter *pAd,
1388 struct rt_rx_blk *pRxBlk,
1389 u8
1390 FromWhichBSSID)
1391 {
1392 void *pRxPkt;
1393 u8 Header802_3[LENGTH_802_3];
1394
1395 /* 1. get 802.3 Header */
1396 /* 2. remove LLC */
1397 /* a. pointer pRxBlk->pData to payload */
1398 /* b. modify pRxBlk->DataSize */
1399
1400 RTMP_802_11_REMOVE_LLC_AND_CONVERT_TO_802_3(pRxBlk, Header802_3);
1401
1402 ASSERT(pRxBlk->pRxPacket);
1403 pRxPkt = RTPKT_TO_OSPKT(pRxBlk->pRxPacket);
1404
1405 SET_OS_PKT_NETDEV(pRxPkt, get_netdev_from_bssid(pAd, FromWhichBSSID));
1406 SET_OS_PKT_DATAPTR(pRxPkt, pRxBlk->pData);
1407 SET_OS_PKT_LEN(pRxPkt, pRxBlk->DataSize);
1408 SET_OS_PKT_DATATAIL(pRxPkt, pRxBlk->pData, pRxBlk->DataSize);
1409
1410 /* */
1411 /* copy 802.3 header, if necessary */
1412 /* */
1413 if (!RX_BLK_TEST_FLAG(pRxBlk, fRX_AMSDU)) {
1414 {
1415 #ifdef LINUX
1416 NdisMoveMemory(skb_push(pRxPkt, LENGTH_802_3),
1417 Header802_3, LENGTH_802_3);
1418 #endif
1419 }
1420 }
1421 }
1422
1423 #define INDICATE_LEGACY_OR_AMSDU(_pAd, _pRxBlk, _fromWhichBSSID) \
1424 do \
1425 { \
1426 if (RX_BLK_TEST_FLAG(_pRxBlk, fRX_AMSDU)) \
1427 { \
1428 Indicate_AMSDU_Packet(_pAd, _pRxBlk, _fromWhichBSSID); \
1429 } \
1430 else if (RX_BLK_TEST_FLAG(_pRxBlk, fRX_EAP)) \
1431 { \
1432 Indicate_EAPOL_Packet(_pAd, _pRxBlk, _fromWhichBSSID); \
1433 } \
1434 else \
1435 { \
1436 Indicate_Legacy_Packet(_pAd, _pRxBlk, _fromWhichBSSID); \
1437 } \
1438 } while (0);
1439
1440 static void ba_enqueue_reordering_packet(struct rt_rtmp_adapter *pAd,
1441 struct rt_ba_rec_entry *pBAEntry,
1442 struct rt_rx_blk *pRxBlk,
1443 u8 FromWhichBSSID)
1444 {
1445 struct reordering_mpdu *mpdu_blk;
1446 u16 Sequence = (u16)pRxBlk->pHeader->Sequence;
1447
1448 mpdu_blk = ba_mpdu_blk_alloc(pAd);
1449 if ((mpdu_blk != NULL) && (!RX_BLK_TEST_FLAG(pRxBlk, fRX_EAP))) {
1450 /* Write RxD buffer address & allocated buffer length */
1451 NdisAcquireSpinLock(&pBAEntry->RxReRingLock);
1452
1453 mpdu_blk->Sequence = Sequence;
1454
1455 mpdu_blk->bAMSDU = RX_BLK_TEST_FLAG(pRxBlk, fRX_AMSDU);
1456
1457 convert_reordering_packet_to_preAMSDU_or_802_3_packet(pAd,
1458 pRxBlk,
1459 FromWhichBSSID);
1460
1461 STATS_INC_RX_PACKETS(pAd, FromWhichBSSID);
1462
1463 /* */
1464 /* it is necessary for reordering packet to record */
1465 /* which BSS it come from */
1466 /* */
1467 RTMP_SET_PACKET_IF(pRxBlk->pRxPacket, FromWhichBSSID);
1468
1469 mpdu_blk->pPacket = pRxBlk->pRxPacket;
1470
1471 if (ba_reordering_mpdu_insertsorted(&pBAEntry->list, mpdu_blk)
1472 == FALSE) {
1473 /* had been already within reordering list */
1474 /* don't indicate */
1475 RELEASE_NDIS_PACKET(pAd, pRxBlk->pRxPacket,
1476 NDIS_STATUS_SUCCESS);
1477 ba_mpdu_blk_free(pAd, mpdu_blk);
1478 }
1479
1480 ASSERT((0 <= pBAEntry->list.qlen)
1481 && (pBAEntry->list.qlen <= pBAEntry->BAWinSize));
1482 NdisReleaseSpinLock(&pBAEntry->RxReRingLock);
1483 } else {
1484 DBGPRINT(RT_DEBUG_ERROR,
1485 (" (%d) Can't allocate reordering mpdu blk\n",
1486 pBAEntry->list.qlen));
1487
1488 /*
1489 * flush all pending reordering mpdus
1490 * and receiving mpdu to upper layer
1491 * make tcp/ip to take care reordering mechanism
1492 */
1493 /*ba_refresh_reordering_mpdus(pAd, pBAEntry); */
1494 ba_indicate_reordering_mpdus_le_seq(pAd, pBAEntry, Sequence);
1495
1496 pBAEntry->LastIndSeq = Sequence;
1497 INDICATE_LEGACY_OR_AMSDU(pAd, pRxBlk, FromWhichBSSID);
1498 }
1499 }
1500
1501 /*
1502 ==========================================================================
1503 Description:
1504 Indicate this packet to upper layer or put it into reordering buffer
1505
1506 Parametrs:
1507 pRxBlk : carry necessary packet info 802.11 format
1508 FromWhichBSSID : the packet received from which BSS
1509
1510 Return :
1511 none
1512
1513 Note :
1514 the packet queued into reordering buffer need to cover to 802.3 format
1515 or pre_AMSDU format
1516 ==========================================================================
1517 */
1518
1519 void Indicate_AMPDU_Packet(struct rt_rtmp_adapter *pAd,
1520 struct rt_rx_blk *pRxBlk, u8 FromWhichBSSID)
1521 {
1522 u16 Idx;
1523 struct rt_ba_rec_entry *pBAEntry = NULL;
1524 u16 Sequence = pRxBlk->pHeader->Sequence;
1525 unsigned long Now32;
1526 u8 Wcid = pRxBlk->pRxWI->WirelessCliID;
1527 u8 TID = pRxBlk->pRxWI->TID;
1528
1529 if (!RX_BLK_TEST_FLAG(pRxBlk, fRX_AMSDU)
1530 && (pRxBlk->DataSize > MAX_RX_PKT_LEN)) {
1531 /* release packet */
1532 RELEASE_NDIS_PACKET(pAd, pRxBlk->pRxPacket,
1533 NDIS_STATUS_FAILURE);
1534 return;
1535 }
1536
1537 if (Wcid < MAX_LEN_OF_MAC_TABLE) {
1538 Idx = pAd->MacTab.Content[Wcid].BARecWcidArray[TID];
1539 if (Idx == 0) {
1540 /* Rec BA Session had been torn down */
1541 INDICATE_LEGACY_OR_AMSDU(pAd, pRxBlk, FromWhichBSSID);
1542 return;
1543 }
1544 pBAEntry = &pAd->BATable.BARecEntry[Idx];
1545 } else {
1546 /* impossible ! */
1547 ASSERT(0);
1548 /* release packet */
1549 RELEASE_NDIS_PACKET(pAd, pRxBlk->pRxPacket,
1550 NDIS_STATUS_FAILURE);
1551 return;
1552 }
1553
1554 ASSERT(pBAEntry);
1555
1556 /* update last rx time */
1557 NdisGetSystemUpTime(&Now32);
1558
1559 pBAEntry->rcvSeq = Sequence;
1560
1561 ba_flush_reordering_timeout_mpdus(pAd, pBAEntry, Now32);
1562 pBAEntry->LastIndSeqAtTimer = Now32;
1563
1564 /* */
1565 /* Reset Last Indicate Sequence */
1566 /* */
1567 if (pBAEntry->LastIndSeq == RESET_RCV_SEQ) {
1568 ASSERT((pBAEntry->list.qlen == 0)
1569 && (pBAEntry->list.next == NULL));
1570
1571 /* reset rcv sequence of BA session */
1572 pBAEntry->LastIndSeq = Sequence;
1573 pBAEntry->LastIndSeqAtTimer = Now32;
1574 INDICATE_LEGACY_OR_AMSDU(pAd, pRxBlk, FromWhichBSSID);
1575 return;
1576 }
1577
1578 /* */
1579 /* I. Check if in order. */
1580 /* */
1581 if (SEQ_STEPONE(Sequence, pBAEntry->LastIndSeq, MAXSEQ)) {
1582 u16 LastIndSeq;
1583
1584 pBAEntry->LastIndSeq = Sequence;
1585 INDICATE_LEGACY_OR_AMSDU(pAd, pRxBlk, FromWhichBSSID);
1586 LastIndSeq =
1587 ba_indicate_reordering_mpdus_in_order(pAd, pBAEntry,
1588 pBAEntry->LastIndSeq);
1589 if (LastIndSeq != RESET_RCV_SEQ) {
1590 pBAEntry->LastIndSeq = LastIndSeq;
1591 }
1592 pBAEntry->LastIndSeqAtTimer = Now32;
1593 }
1594 /* */
1595 /* II. Drop Duplicated Packet */
1596 /* */
1597 else if (Sequence == pBAEntry->LastIndSeq) {
1598
1599 /* drop and release packet */
1600 pBAEntry->nDropPacket++;
1601 RELEASE_NDIS_PACKET(pAd, pRxBlk->pRxPacket,
1602 NDIS_STATUS_FAILURE);
1603 }
1604 /* */
1605 /* III. Drop Old Received Packet */
1606 /* */
1607 else if (SEQ_SMALLER(Sequence, pBAEntry->LastIndSeq, MAXSEQ)) {
1608
1609 /* drop and release packet */
1610 pBAEntry->nDropPacket++;
1611 RELEASE_NDIS_PACKET(pAd, pRxBlk->pRxPacket,
1612 NDIS_STATUS_FAILURE);
1613 }
1614 /* */
1615 /* IV. Receive Sequence within Window Size */
1616 /* */
1617 else if (SEQ_SMALLER
1618 (Sequence,
1619 (((pBAEntry->LastIndSeq + pBAEntry->BAWinSize + 1)) & MAXSEQ),
1620 MAXSEQ)) {
1621 ba_enqueue_reordering_packet(pAd, pBAEntry, pRxBlk,
1622 FromWhichBSSID);
1623 }
1624 /* */
1625 /* V. Receive seq surpasses Win(lastseq + nMSDU). So refresh all reorder buffer */
1626 /* */
1627 else {
1628 long WinStartSeq, TmpSeq;
1629
1630 TmpSeq = Sequence - (pBAEntry->BAWinSize) - 1;
1631 if (TmpSeq < 0) {
1632 TmpSeq = (MAXSEQ + 1) + TmpSeq;
1633 }
1634 WinStartSeq = (TmpSeq + 1) & MAXSEQ;
1635 ba_indicate_reordering_mpdus_le_seq(pAd, pBAEntry, WinStartSeq);
1636 pBAEntry->LastIndSeq = WinStartSeq; /*TmpSeq; */
1637
1638 pBAEntry->LastIndSeqAtTimer = Now32;
1639
1640 ba_enqueue_reordering_packet(pAd, pBAEntry, pRxBlk,
1641 FromWhichBSSID);
1642
1643 TmpSeq =
1644 ba_indicate_reordering_mpdus_in_order(pAd, pBAEntry,
1645 pBAEntry->LastIndSeq);
1646 if (TmpSeq != RESET_RCV_SEQ) {
1647 pBAEntry->LastIndSeq = TmpSeq;
1648 }
1649 }
1650 }
Linux kernel - Deliverables
This page took 0.064521 seconds and 5 git commands to generate.