bef0bbd8cef75f17027768416388be2424d93233
[linux-2.6.git] / drivers / staging / rt2860 / common / cmm_data_pci.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 /*
29    All functions in this file must be PCI-depended, or you should out your function
30         in other files.
31
32 */
33 #include        "../rt_config.h"
34
35 u16 RtmpPCI_WriteTxResource(struct rt_rtmp_adapter *pAd,
36                                struct rt_tx_blk *pTxBlk,
37                                IN BOOLEAN bIsLast, u16 * FreeNumber)
38 {
39
40         u8 *pDMAHeaderBufVA;
41         u16 TxIdx, RetTxIdx;
42         struct rt_txd * pTxD;
43         u32 BufBasePaLow;
44         struct rt_rtmp_tx_ring *pTxRing;
45         u16 hwHeaderLen;
46
47         /* */
48         /* get Tx Ring Resource */
49         /* */
50         pTxRing = &pAd->TxRing[pTxBlk->QueIdx];
51         TxIdx = pAd->TxRing[pTxBlk->QueIdx].TxCpuIdx;
52         pDMAHeaderBufVA = (u8 *)pTxRing->Cell[TxIdx].DmaBuf.AllocVa;
53         BufBasePaLow =
54             RTMP_GetPhysicalAddressLow(pTxRing->Cell[TxIdx].DmaBuf.AllocPa);
55
56         /* copy TXINFO + TXWI + WLAN Header + LLC into DMA Header Buffer */
57         if (pTxBlk->TxFrameType == TX_AMSDU_FRAME) {
58                 /*hwHeaderLen = ROUND_UP(pTxBlk->MpduHeaderLen-LENGTH_AMSDU_SUBFRAMEHEAD, 4)+LENGTH_AMSDU_SUBFRAMEHEAD; */
59                 hwHeaderLen =
60                     pTxBlk->MpduHeaderLen - LENGTH_AMSDU_SUBFRAMEHEAD +
61                     pTxBlk->HdrPadLen + LENGTH_AMSDU_SUBFRAMEHEAD;
62         } else {
63                 /*hwHeaderLen = ROUND_UP(pTxBlk->MpduHeaderLen, 4); */
64                 hwHeaderLen = pTxBlk->MpduHeaderLen + pTxBlk->HdrPadLen;
65         }
66         NdisMoveMemory(pDMAHeaderBufVA, pTxBlk->HeaderBuf,
67                        TXINFO_SIZE + TXWI_SIZE + hwHeaderLen);
68
69         pTxRing->Cell[TxIdx].pNdisPacket = pTxBlk->pPacket;
70         pTxRing->Cell[TxIdx].pNextNdisPacket = NULL;
71
72         /* */
73         /* build Tx Descriptor */
74         /* */
75
76         pTxD = (struct rt_txd *) pTxRing->Cell[TxIdx].AllocVa;
77         NdisZeroMemory(pTxD, TXD_SIZE);
78
79         pTxD->SDPtr0 = BufBasePaLow;
80         pTxD->SDLen0 = TXINFO_SIZE + TXWI_SIZE + hwHeaderLen;   /* include padding */
81         pTxD->SDPtr1 = PCI_MAP_SINGLE(pAd, pTxBlk, 0, 1, PCI_DMA_TODEVICE);
82         pTxD->SDLen1 = pTxBlk->SrcBufLen;
83         pTxD->LastSec0 = 0;
84         pTxD->LastSec1 = (bIsLast) ? 1 : 0;
85
86         RTMPWriteTxDescriptor(pAd, pTxD, FALSE, FIFO_EDCA);
87
88         RetTxIdx = TxIdx;
89         /* */
90         /* Update Tx index */
91         /* */
92         INC_RING_INDEX(TxIdx, TX_RING_SIZE);
93         pTxRing->TxCpuIdx = TxIdx;
94
95         *FreeNumber -= 1;
96
97         return RetTxIdx;
98 }
99
100 u16 RtmpPCI_WriteSingleTxResource(struct rt_rtmp_adapter *pAd,
101                                      struct rt_tx_blk *pTxBlk,
102                                      IN BOOLEAN bIsLast,
103                                      u16 * FreeNumber)
104 {
105
106         u8 *pDMAHeaderBufVA;
107         u16 TxIdx, RetTxIdx;
108         struct rt_txd * pTxD;
109         u32 BufBasePaLow;
110         struct rt_rtmp_tx_ring *pTxRing;
111         u16 hwHeaderLen;
112
113         /* */
114         /* get Tx Ring Resource */
115         /* */
116         pTxRing = &pAd->TxRing[pTxBlk->QueIdx];
117         TxIdx = pAd->TxRing[pTxBlk->QueIdx].TxCpuIdx;
118         pDMAHeaderBufVA = (u8 *)pTxRing->Cell[TxIdx].DmaBuf.AllocVa;
119         BufBasePaLow =
120             RTMP_GetPhysicalAddressLow(pTxRing->Cell[TxIdx].DmaBuf.AllocPa);
121
122         /* copy TXINFO + TXWI + WLAN Header + LLC into DMA Header Buffer */
123         /*hwHeaderLen = ROUND_UP(pTxBlk->MpduHeaderLen, 4); */
124         hwHeaderLen = pTxBlk->MpduHeaderLen + pTxBlk->HdrPadLen;
125
126         NdisMoveMemory(pDMAHeaderBufVA, pTxBlk->HeaderBuf,
127                        TXINFO_SIZE + TXWI_SIZE + hwHeaderLen);
128
129         pTxRing->Cell[TxIdx].pNdisPacket = pTxBlk->pPacket;
130         pTxRing->Cell[TxIdx].pNextNdisPacket = NULL;
131
132         /* */
133         /* build Tx Descriptor */
134         /* */
135         pTxD = (struct rt_txd *) pTxRing->Cell[TxIdx].AllocVa;
136         NdisZeroMemory(pTxD, TXD_SIZE);
137
138         pTxD->SDPtr0 = BufBasePaLow;
139         pTxD->SDLen0 = TXINFO_SIZE + TXWI_SIZE + hwHeaderLen;   /* include padding */
140         pTxD->SDPtr1 = PCI_MAP_SINGLE(pAd, pTxBlk, 0, 1, PCI_DMA_TODEVICE);
141         pTxD->SDLen1 = pTxBlk->SrcBufLen;
142         pTxD->LastSec0 = 0;
143         pTxD->LastSec1 = (bIsLast) ? 1 : 0;
144
145         RTMPWriteTxDescriptor(pAd, pTxD, FALSE, FIFO_EDCA);
146
147         RetTxIdx = TxIdx;
148         /* */
149         /* Update Tx index */
150         /* */
151         INC_RING_INDEX(TxIdx, TX_RING_SIZE);
152         pTxRing->TxCpuIdx = TxIdx;
153
154         *FreeNumber -= 1;
155
156         return RetTxIdx;
157 }
158
159 u16 RtmpPCI_WriteMultiTxResource(struct rt_rtmp_adapter *pAd,
160                                     struct rt_tx_blk *pTxBlk,
161                                     u8 frameNum, u16 * FreeNumber)
162 {
163         BOOLEAN bIsLast;
164         u8 *pDMAHeaderBufVA;
165         u16 TxIdx, RetTxIdx;
166         struct rt_txd * pTxD;
167         u32 BufBasePaLow;
168         struct rt_rtmp_tx_ring *pTxRing;
169         u16 hwHdrLen;
170         u32 firstDMALen;
171
172         bIsLast = ((frameNum == (pTxBlk->TotalFrameNum - 1)) ? 1 : 0);
173
174         /* */
175         /* get Tx Ring Resource */
176         /* */
177         pTxRing = &pAd->TxRing[pTxBlk->QueIdx];
178         TxIdx = pAd->TxRing[pTxBlk->QueIdx].TxCpuIdx;
179         pDMAHeaderBufVA = (u8 *)pTxRing->Cell[TxIdx].DmaBuf.AllocVa;
180         BufBasePaLow =
181             RTMP_GetPhysicalAddressLow(pTxRing->Cell[TxIdx].DmaBuf.AllocPa);
182
183         if (frameNum == 0) {
184                 /* copy TXINFO + TXWI + WLAN Header + LLC into DMA Header Buffer */
185                 if (pTxBlk->TxFrameType == TX_AMSDU_FRAME)
186                         /*hwHdrLen = ROUND_UP(pTxBlk->MpduHeaderLen-LENGTH_AMSDU_SUBFRAMEHEAD, 4)+LENGTH_AMSDU_SUBFRAMEHEAD; */
187                         hwHdrLen =
188                             pTxBlk->MpduHeaderLen - LENGTH_AMSDU_SUBFRAMEHEAD +
189                             pTxBlk->HdrPadLen + LENGTH_AMSDU_SUBFRAMEHEAD;
190                 else if (pTxBlk->TxFrameType == TX_RALINK_FRAME)
191                         /*hwHdrLen = ROUND_UP(pTxBlk->MpduHeaderLen-LENGTH_ARALINK_HEADER_FIELD, 4)+LENGTH_ARALINK_HEADER_FIELD; */
192                         hwHdrLen =
193                             pTxBlk->MpduHeaderLen -
194                             LENGTH_ARALINK_HEADER_FIELD + pTxBlk->HdrPadLen +
195                             LENGTH_ARALINK_HEADER_FIELD;
196                 else
197                         /*hwHdrLen = ROUND_UP(pTxBlk->MpduHeaderLen, 4); */
198                         hwHdrLen = pTxBlk->MpduHeaderLen + pTxBlk->HdrPadLen;
199
200                 firstDMALen = TXINFO_SIZE + TXWI_SIZE + hwHdrLen;
201         } else {
202                 firstDMALen = pTxBlk->MpduHeaderLen;
203         }
204
205         NdisMoveMemory(pDMAHeaderBufVA, pTxBlk->HeaderBuf, firstDMALen);
206
207         pTxRing->Cell[TxIdx].pNdisPacket = pTxBlk->pPacket;
208         pTxRing->Cell[TxIdx].pNextNdisPacket = NULL;
209
210         /* */
211         /* build Tx Descriptor */
212         /* */
213         pTxD = (struct rt_txd *) pTxRing->Cell[TxIdx].AllocVa;
214         NdisZeroMemory(pTxD, TXD_SIZE);
215
216         pTxD->SDPtr0 = BufBasePaLow;
217         pTxD->SDLen0 = firstDMALen;     /* include padding */
218         pTxD->SDPtr1 = PCI_MAP_SINGLE(pAd, pTxBlk, 0, 1, PCI_DMA_TODEVICE);
219         pTxD->SDLen1 = pTxBlk->SrcBufLen;
220         pTxD->LastSec0 = 0;
221         pTxD->LastSec1 = (bIsLast) ? 1 : 0;
222
223         RTMPWriteTxDescriptor(pAd, pTxD, FALSE, FIFO_EDCA);
224
225         RetTxIdx = TxIdx;
226         /* */
227         /* Update Tx index */
228         /* */
229         INC_RING_INDEX(TxIdx, TX_RING_SIZE);
230         pTxRing->TxCpuIdx = TxIdx;
231
232         *FreeNumber -= 1;
233
234         return RetTxIdx;
235
236 }
237
238 void RtmpPCI_FinalWriteTxResource(struct rt_rtmp_adapter *pAd,
239                                   struct rt_tx_blk *pTxBlk,
240                                   u16 totalMPDUSize, u16 FirstTxIdx)
241 {
242
243         struct rt_txwi * pTxWI;
244         struct rt_rtmp_tx_ring *pTxRing;
245
246         /* */
247         /* get Tx Ring Resource */
248         /* */
249         pTxRing = &pAd->TxRing[pTxBlk->QueIdx];
250         pTxWI = (struct rt_txwi *) pTxRing->Cell[FirstTxIdx].DmaBuf.AllocVa;
251         pTxWI->MPDUtotalByteCount = totalMPDUSize;
252
253 }
254
255 void RtmpPCIDataLastTxIdx(struct rt_rtmp_adapter *pAd,
256                           u8 QueIdx, u16 LastTxIdx)
257 {
258         struct rt_txd * pTxD;
259         struct rt_rtmp_tx_ring *pTxRing;
260
261         /* */
262         /* get Tx Ring Resource */
263         /* */
264         pTxRing = &pAd->TxRing[QueIdx];
265
266         /* */
267         /* build Tx Descriptor */
268         /* */
269         pTxD = (struct rt_txd *) pTxRing->Cell[LastTxIdx].AllocVa;
270
271         pTxD->LastSec1 = 1;
272
273 }
274
275 u16 RtmpPCI_WriteFragTxResource(struct rt_rtmp_adapter *pAd,
276                                    struct rt_tx_blk *pTxBlk,
277                                    u8 fragNum, u16 * FreeNumber)
278 {
279         u8 *pDMAHeaderBufVA;
280         u16 TxIdx, RetTxIdx;
281         struct rt_txd * pTxD;
282         u32 BufBasePaLow;
283         struct rt_rtmp_tx_ring *pTxRing;
284         u16 hwHeaderLen;
285         u32 firstDMALen;
286
287         /* */
288         /* Get Tx Ring Resource */
289         /* */
290         pTxRing = &pAd->TxRing[pTxBlk->QueIdx];
291         TxIdx = pAd->TxRing[pTxBlk->QueIdx].TxCpuIdx;
292         pDMAHeaderBufVA = (u8 *)pTxRing->Cell[TxIdx].DmaBuf.AllocVa;
293         BufBasePaLow =
294             RTMP_GetPhysicalAddressLow(pTxRing->Cell[TxIdx].DmaBuf.AllocPa);
295
296         /* */
297         /* Copy TXINFO + TXWI + WLAN Header + LLC into DMA Header Buffer */
298         /* */
299         /*hwHeaderLen = ROUND_UP(pTxBlk->MpduHeaderLen, 4); */
300         hwHeaderLen = pTxBlk->MpduHeaderLen + pTxBlk->HdrPadLen;
301
302         firstDMALen = TXINFO_SIZE + TXWI_SIZE + hwHeaderLen;
303         NdisMoveMemory(pDMAHeaderBufVA, pTxBlk->HeaderBuf, firstDMALen);
304
305         /* */
306         /* Build Tx Descriptor */
307         /* */
308         pTxD = (struct rt_txd *) pTxRing->Cell[TxIdx].AllocVa;
309         NdisZeroMemory(pTxD, TXD_SIZE);
310
311         if (fragNum == pTxBlk->TotalFragNum) {
312                 pTxRing->Cell[TxIdx].pNdisPacket = pTxBlk->pPacket;
313                 pTxRing->Cell[TxIdx].pNextNdisPacket = NULL;
314         }
315
316         pTxD->SDPtr0 = BufBasePaLow;
317         pTxD->SDLen0 = firstDMALen;     /* include padding */
318         pTxD->SDPtr1 = PCI_MAP_SINGLE(pAd, pTxBlk, 0, 1, PCI_DMA_TODEVICE);
319         pTxD->SDLen1 = pTxBlk->SrcBufLen;
320         pTxD->LastSec0 = 0;
321         pTxD->LastSec1 = 1;
322
323         RTMPWriteTxDescriptor(pAd, pTxD, FALSE, FIFO_EDCA);
324
325         RetTxIdx = TxIdx;
326         pTxBlk->Priv += pTxBlk->SrcBufLen;
327
328         /* */
329         /* Update Tx index */
330         /* */
331         INC_RING_INDEX(TxIdx, TX_RING_SIZE);
332         pTxRing->TxCpuIdx = TxIdx;
333
334         *FreeNumber -= 1;
335
336         return RetTxIdx;
337
338 }
339
340 /*
341         Must be run in Interrupt context
342         This function handle PCI specific TxDesc and cpu index update and kick the packet out.
343  */
344 int RtmpPCIMgmtKickOut(struct rt_rtmp_adapter *pAd,
345                        u8 QueIdx,
346                        void *pPacket,
347                        u8 *pSrcBufVA, u32 SrcBufLen)
348 {
349         struct rt_txd * pTxD;
350         unsigned long SwIdx = pAd->MgmtRing.TxCpuIdx;
351
352         pTxD = (struct rt_txd *) pAd->MgmtRing.Cell[SwIdx].AllocVa;
353
354         pAd->MgmtRing.Cell[SwIdx].pNdisPacket = pPacket;
355         pAd->MgmtRing.Cell[SwIdx].pNextNdisPacket = NULL;
356
357         RTMPWriteTxDescriptor(pAd, pTxD, TRUE, FIFO_MGMT);
358         pTxD->LastSec0 = 1;
359         pTxD->LastSec1 = 1;
360         pTxD->DMADONE = 0;
361         pTxD->SDLen1 = 0;
362         pTxD->SDPtr0 =
363             PCI_MAP_SINGLE(pAd, pSrcBufVA, SrcBufLen, 0, PCI_DMA_TODEVICE);
364         pTxD->SDLen0 = SrcBufLen;
365
366 /*================================================================== */
367 /*      DBGPRINT_RAW(RT_DEBUG_TRACE, ("MLMEHardTransmit\n"));
368         for (i = 0; i < (TXWI_SIZE+24); i++)
369         {
370
371                 DBGPRINT_RAW(RT_DEBUG_TRACE, ("%x:", *(pSrcBufVA+i)));
372                 if ( i%4 == 3)
373                         DBGPRINT_RAW(RT_DEBUG_TRACE, (" :: "));
374                 if ( i%16 == 15)
375                         DBGPRINT_RAW(RT_DEBUG_TRACE, ("\n      "));
376         }
377         DBGPRINT_RAW(RT_DEBUG_TRACE, ("\n      "));*/
378 /*======================================================================= */
379
380         pAd->RalinkCounters.KickTxCount++;
381         pAd->RalinkCounters.OneSecTxDoneCount++;
382
383         /* Increase TX_CTX_IDX, but write to register later. */
384         INC_RING_INDEX(pAd->MgmtRing.TxCpuIdx, MGMT_RING_SIZE);
385
386         RTMP_IO_WRITE32(pAd, TX_MGMTCTX_IDX, pAd->MgmtRing.TxCpuIdx);
387
388         return 0;
389 }
390
391 /*
392         ========================================================================
393
394         Routine Description:
395                 Check Rx descriptor, return NDIS_STATUS_FAILURE if any error dound
396
397         Arguments:
398                 pRxD            Pointer to the Rx descriptor
399
400         Return Value:
401                 NDIS_STATUS_SUCCESS     No err
402                 NDIS_STATUS_FAILURE     Error
403
404         Note:
405
406         ========================================================================
407 */
408 int RTMPCheckRxError(struct rt_rtmp_adapter *pAd,
409                              struct rt_header_802_11 * pHeader,
410                              struct rt_rxwi * pRxWI, IN PRT28XX_RXD_STRUC pRxD)
411 {
412         struct rt_cipher_key *pWpaKey;
413         int dBm;
414
415         /* Phy errors & CRC errors */
416         if ( /*(pRxD->PhyErr) || */ (pRxD->Crc)) {
417                 /* Check RSSI for Noise Hist statistic collection. */
418                 dBm = (int)(pRxWI->RSSI0) - pAd->BbpRssiToDbmDelta;
419                 if (dBm <= -87)
420                         pAd->StaCfg.RPIDensity[0] += 1;
421                 else if (dBm <= -82)
422                         pAd->StaCfg.RPIDensity[1] += 1;
423                 else if (dBm <= -77)
424                         pAd->StaCfg.RPIDensity[2] += 1;
425                 else if (dBm <= -72)
426                         pAd->StaCfg.RPIDensity[3] += 1;
427                 else if (dBm <= -67)
428                         pAd->StaCfg.RPIDensity[4] += 1;
429                 else if (dBm <= -62)
430                         pAd->StaCfg.RPIDensity[5] += 1;
431                 else if (dBm <= -57)
432                         pAd->StaCfg.RPIDensity[6] += 1;
433                 else if (dBm > -57)
434                         pAd->StaCfg.RPIDensity[7] += 1;
435
436                 return (NDIS_STATUS_FAILURE);
437         }
438         /* Add Rx size to channel load counter, we should ignore error counts */
439         pAd->StaCfg.CLBusyBytes += (pRxD->SDL0 + 14);
440
441         /* Drop ToDs promiscuous frame, it is opened due to CCX 2 channel load statistics */
442         if (pHeader != NULL) {
443                 if (pHeader->FC.ToDs) {
444                         return (NDIS_STATUS_FAILURE);
445                 }
446         }
447         /* Drop not U2M frames, can't's drop here because we will drop beacon in this case */
448         /* I am kind of doubting the U2M bit operation */
449         /* if (pRxD->U2M == 0) */
450         /*      return(NDIS_STATUS_FAILURE); */
451
452         /* drop decyption fail frame */
453         if (pRxD->CipherErr) {
454                 if (pRxD->CipherErr == 2) {
455                         DBGPRINT_RAW(RT_DEBUG_TRACE,
456                                      ("pRxD ERROR: ICV ok but MICErr "));
457                 } else if (pRxD->CipherErr == 1) {
458                         DBGPRINT_RAW(RT_DEBUG_TRACE, ("pRxD ERROR: ICV Err "));
459                 } else if (pRxD->CipherErr == 3)
460                         DBGPRINT_RAW(RT_DEBUG_TRACE,
461                                      ("pRxD ERROR: Key not valid "));
462
463                 if (((pRxD->CipherErr & 1) == 1)
464                     && pAd->CommonCfg.bWirelessEvent && INFRA_ON(pAd))
465                         RTMPSendWirelessEvent(pAd, IW_ICV_ERROR_EVENT_FLAG,
466                                               pAd->MacTab.Content[BSSID_WCID].
467                                               Addr, BSS0, 0);
468
469                 DBGPRINT_RAW(RT_DEBUG_TRACE,
470                              (" %d (len=%d, Mcast=%d, MyBss=%d, Wcid=%d, KeyId=%d)\n",
471                               pRxD->CipherErr, pRxD->SDL0,
472                               pRxD->Mcast | pRxD->Bcast, pRxD->MyBss,
473                               pRxWI->WirelessCliID,
474 /*                      CipherName[pRxD->CipherAlg], */
475                               pRxWI->KeyIndex));
476
477                 /* */
478                 /* MIC Error */
479                 /* */
480                 if (pRxD->CipherErr == 2) {
481                         pWpaKey = &pAd->SharedKey[BSS0][pRxWI->KeyIndex];
482                         if (pAd->StaCfg.WpaSupplicantUP)
483                                 WpaSendMicFailureToWpaSupplicant(pAd,
484                                                                  (pWpaKey->
485                                                                   Type ==
486                                                                   PAIRWISEKEY) ?
487                                                                  TRUE : FALSE);
488                         else
489                                 RTMPReportMicError(pAd, pWpaKey);
490
491                         if (((pRxD->CipherErr & 2) == 2)
492                             && pAd->CommonCfg.bWirelessEvent && INFRA_ON(pAd))
493                                 RTMPSendWirelessEvent(pAd,
494                                                       IW_MIC_ERROR_EVENT_FLAG,
495                                                       pAd->MacTab.
496                                                       Content[BSSID_WCID].Addr,
497                                                       BSS0, 0);
498
499                         DBGPRINT_RAW(RT_DEBUG_ERROR, ("Rx MIC Value error\n"));
500                 }
501
502                 if (pHeader == NULL)
503                         return (NDIS_STATUS_SUCCESS);
504                 /*if ((pRxD->CipherAlg == CIPHER_AES) &&
505                    (pHeader->Sequence == pAd->FragFrame.Sequence))
506                    {
507                    //
508                    // Acceptable since the First FragFrame no CipherErr problem.
509                    //
510                    return(NDIS_STATUS_SUCCESS);
511                    } */
512
513                 return (NDIS_STATUS_FAILURE);
514         }
515
516         return (NDIS_STATUS_SUCCESS);
517 }
518
519 BOOLEAN RTMPFreeTXDUponTxDmaDone(struct rt_rtmp_adapter *pAd, u8 QueIdx)
520 {
521         struct rt_rtmp_tx_ring *pTxRing;
522         struct rt_txd * pTxD;
523         void *pPacket;
524         u8 FREE = 0;
525         struct rt_txd TxD, *pOriTxD;
526         /*unsigned long         IrqFlags; */
527         BOOLEAN bReschedule = FALSE;
528
529         ASSERT(QueIdx < NUM_OF_TX_RING);
530         pTxRing = &pAd->TxRing[QueIdx];
531
532         RTMP_IO_READ32(pAd, TX_DTX_IDX0 + QueIdx * RINGREG_DIFF,
533                        &pTxRing->TxDmaIdx);
534         while (pTxRing->TxSwFreeIdx != pTxRing->TxDmaIdx) {
535 /*              RTMP_IRQ_LOCK(&pAd->irq_lock, IrqFlags); */
536
537                 /* static rate also need NICUpdateFifoStaCounters() function. */
538                 /*if (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_TX_RATE_SWITCH_ENABLED)) */
539                 NICUpdateFifoStaCounters(pAd);
540
541                 /* Note : If (pAd->ate.bQATxStart == TRUE), we will never reach here. */
542                 FREE++;
543                 pTxD =
544                     (struct rt_txd *) (pTxRing->Cell[pTxRing->TxSwFreeIdx].AllocVa);
545                 pOriTxD = pTxD;
546                 NdisMoveMemory(&TxD, pTxD, sizeof(struct rt_txd));
547                 pTxD = &TxD;
548
549                 pTxD->DMADONE = 0;
550
551                 {
552                         pPacket =
553                             pTxRing->Cell[pTxRing->TxSwFreeIdx].pNdisPacket;
554                         if (pPacket) {
555                                 PCI_UNMAP_SINGLE(pAd, pTxD->SDPtr1,
556                                                  pTxD->SDLen1,
557                                                  PCI_DMA_TODEVICE);
558                                 RELEASE_NDIS_PACKET(pAd, pPacket,
559                                                     NDIS_STATUS_SUCCESS);
560                         }
561                         /*Always assign pNdisPacket as NULL after clear */
562                         pTxRing->Cell[pTxRing->TxSwFreeIdx].pNdisPacket = NULL;
563
564                         pPacket =
565                             pTxRing->Cell[pTxRing->TxSwFreeIdx].pNextNdisPacket;
566
567                         ASSERT(pPacket == NULL);
568                         if (pPacket) {
569                                 PCI_UNMAP_SINGLE(pAd, pTxD->SDPtr1,
570                                                  pTxD->SDLen1,
571                                                  PCI_DMA_TODEVICE);
572                                 RELEASE_NDIS_PACKET(pAd, pPacket,
573                                                     NDIS_STATUS_SUCCESS);
574                         }
575                         /*Always assign pNextNdisPacket as NULL after clear */
576                         pTxRing->Cell[pTxRing->TxSwFreeIdx].pNextNdisPacket =
577                             NULL;
578                 }
579
580                 pAd->RalinkCounters.TransmittedByteCount +=
581                     (pTxD->SDLen1 + pTxD->SDLen0);
582                 pAd->RalinkCounters.OneSecDmaDoneCount[QueIdx]++;
583                 INC_RING_INDEX(pTxRing->TxSwFreeIdx, TX_RING_SIZE);
584                 /* get tx_tdx_idx again */
585                 RTMP_IO_READ32(pAd, TX_DTX_IDX0 + QueIdx * RINGREG_DIFF,
586                                &pTxRing->TxDmaIdx);
587                 NdisMoveMemory(pOriTxD, pTxD, sizeof(struct rt_txd));
588
589 /*         RTMP_IRQ_UNLOCK(&pAd->irq_lock, IrqFlags); */
590         }
591
592         return bReschedule;
593
594 }
595
596 /*
597         ========================================================================
598
599         Routine Description:
600                 Process TX Rings DMA Done interrupt, running in DPC level
601
602         Arguments:
603                 Adapter         Pointer to our adapter
604
605         Return Value:
606                 None
607
608         IRQL = DISPATCH_LEVEL
609
610         ========================================================================
611 */
612 BOOLEAN RTMPHandleTxRingDmaDoneInterrupt(struct rt_rtmp_adapter *pAd,
613                                          INT_SOURCE_CSR_STRUC TxRingBitmap)
614 {
615 /*      u8                   Count = 0; */
616         unsigned long IrqFlags;
617         BOOLEAN bReschedule = FALSE;
618
619         /* Make sure Tx ring resource won't be used by other threads */
620         /*NdisAcquireSpinLock(&pAd->TxRingLock); */
621
622         RTMP_IRQ_LOCK(&pAd->irq_lock, IrqFlags);
623
624         if (TxRingBitmap.field.Ac0DmaDone)
625                 bReschedule = RTMPFreeTXDUponTxDmaDone(pAd, QID_AC_BE);
626
627         if (TxRingBitmap.field.Ac3DmaDone)
628                 bReschedule |= RTMPFreeTXDUponTxDmaDone(pAd, QID_AC_VO);
629
630         if (TxRingBitmap.field.Ac2DmaDone)
631                 bReschedule |= RTMPFreeTXDUponTxDmaDone(pAd, QID_AC_VI);
632
633         if (TxRingBitmap.field.Ac1DmaDone)
634                 bReschedule |= RTMPFreeTXDUponTxDmaDone(pAd, QID_AC_BK);
635
636         /* Make sure to release Tx ring resource */
637         /*NdisReleaseSpinLock(&pAd->TxRingLock); */
638         RTMP_IRQ_UNLOCK(&pAd->irq_lock, IrqFlags);
639
640         /* Dequeue outgoing frames from TxSwQueue[] and process it */
641         RTMPDeQueuePacket(pAd, FALSE, NUM_OF_TX_RING, MAX_TX_PROCESS);
642
643         return bReschedule;
644 }
645
646 /*
647         ========================================================================
648
649         Routine Description:
650                 Process MGMT ring DMA done interrupt, running in DPC level
651
652         Arguments:
653                 pAd     Pointer to our adapter
654
655         Return Value:
656                 None
657
658         IRQL = DISPATCH_LEVEL
659
660         Note:
661
662         ========================================================================
663 */
664 void RTMPHandleMgmtRingDmaDoneInterrupt(struct rt_rtmp_adapter *pAd)
665 {
666         struct rt_txd * pTxD;
667         void *pPacket;
668 /*      int              i; */
669         u8 FREE = 0;
670         struct rt_rtmp_mgmt_ring *pMgmtRing = &pAd->MgmtRing;
671
672         NdisAcquireSpinLock(&pAd->MgmtRingLock);
673
674         RTMP_IO_READ32(pAd, TX_MGMTDTX_IDX, &pMgmtRing->TxDmaIdx);
675         while (pMgmtRing->TxSwFreeIdx != pMgmtRing->TxDmaIdx) {
676                 FREE++;
677                 pTxD =
678                     (struct rt_txd *) (pMgmtRing->Cell[pAd->MgmtRing.TxSwFreeIdx].
679                                   AllocVa);
680                 pTxD->DMADONE = 0;
681                 pPacket = pMgmtRing->Cell[pMgmtRing->TxSwFreeIdx].pNdisPacket;
682
683                 if (pPacket) {
684                         PCI_UNMAP_SINGLE(pAd, pTxD->SDPtr0, pTxD->SDLen0,
685                                          PCI_DMA_TODEVICE);
686                         RELEASE_NDIS_PACKET(pAd, pPacket, NDIS_STATUS_SUCCESS);
687                 }
688                 pMgmtRing->Cell[pMgmtRing->TxSwFreeIdx].pNdisPacket = NULL;
689
690                 pPacket =
691                     pMgmtRing->Cell[pMgmtRing->TxSwFreeIdx].pNextNdisPacket;
692                 if (pPacket) {
693                         PCI_UNMAP_SINGLE(pAd, pTxD->SDPtr1, pTxD->SDLen1,
694                                          PCI_DMA_TODEVICE);
695                         RELEASE_NDIS_PACKET(pAd, pPacket, NDIS_STATUS_SUCCESS);
696                 }
697                 pMgmtRing->Cell[pMgmtRing->TxSwFreeIdx].pNextNdisPacket = NULL;
698                 INC_RING_INDEX(pMgmtRing->TxSwFreeIdx, MGMT_RING_SIZE);
699
700         }
701         NdisReleaseSpinLock(&pAd->MgmtRingLock);
702
703 }
704
705 /*
706         ========================================================================
707
708         Routine Description:
709         Arguments:
710                 Adapter         Pointer to our adapter. Dequeue all power safe delayed braodcast frames after beacon.
711
712         IRQL = DISPATCH_LEVEL
713
714         ========================================================================
715 */
716 void RTMPHandleTBTTInterrupt(struct rt_rtmp_adapter *pAd)
717 {
718         {
719                 if (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_DOZE)) {
720                 }
721         }
722 }
723
724 /*
725         ========================================================================
726
727         Routine Description:
728         Arguments:
729                 pAd             Pointer to our adapter. Rewrite beacon content before next send-out.
730
731         IRQL = DISPATCH_LEVEL
732
733         ========================================================================
734 */
735 void RTMPHandlePreTBTTInterrupt(struct rt_rtmp_adapter *pAd)
736 {
737         {
738                 if (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_DOZE)) {
739                         DBGPRINT(RT_DEBUG_TRACE,
740                                  ("RTMPHandlePreTBTTInterrupt...\n"));
741                 }
742         }
743
744 }
745
746 void RTMPHandleRxCoherentInterrupt(struct rt_rtmp_adapter *pAd)
747 {
748         WPDMA_GLO_CFG_STRUC GloCfg;
749
750         if (pAd == NULL) {
751                 DBGPRINT(RT_DEBUG_TRACE, ("====> pAd is NULL, return.\n"));
752                 return;
753         }
754
755         DBGPRINT(RT_DEBUG_TRACE, ("==> RTMPHandleRxCoherentInterrupt \n"));
756
757         RTMP_IO_READ32(pAd, WPDMA_GLO_CFG, &GloCfg.word);
758
759         GloCfg.field.EnTXWriteBackDDONE = 0;
760         GloCfg.field.EnableRxDMA = 0;
761         GloCfg.field.EnableTxDMA = 0;
762         RTMP_IO_WRITE32(pAd, WPDMA_GLO_CFG, GloCfg.word);
763
764         RTMPRingCleanUp(pAd, QID_AC_BE);
765         RTMPRingCleanUp(pAd, QID_AC_BK);
766         RTMPRingCleanUp(pAd, QID_AC_VI);
767         RTMPRingCleanUp(pAd, QID_AC_VO);
768         RTMPRingCleanUp(pAd, QID_MGMT);
769         RTMPRingCleanUp(pAd, QID_RX);
770
771         RTMPEnableRxTx(pAd);
772
773         DBGPRINT(RT_DEBUG_TRACE, ("<== RTMPHandleRxCoherentInterrupt \n"));
774 }
775
776 void *GetPacketFromRxRing(struct rt_rtmp_adapter *pAd,
777                                  OUT PRT28XX_RXD_STRUC pSaveRxD,
778                                  OUT BOOLEAN * pbReschedule,
779                                  IN u32 * pRxPending)
780 {
781         struct rt_rxd * pRxD;
782         void *pRxPacket = NULL;
783         void *pNewPacket;
784         void *AllocVa;
785         dma_addr_t AllocPa;
786         BOOLEAN bReschedule = FALSE;
787         struct rt_rtmp_dmacb *pRxCell;
788
789         RTMP_SEM_LOCK(&pAd->RxRingLock);
790
791         if (*pRxPending == 0) {
792                 /* Get how may packets had been received */
793                 RTMP_IO_READ32(pAd, RX_DRX_IDX, &pAd->RxRing.RxDmaIdx);
794
795                 if (pAd->RxRing.RxSwReadIdx == pAd->RxRing.RxDmaIdx) {
796                         /* no more rx packets */
797                         bReschedule = FALSE;
798                         goto done;
799                 }
800                 /* get rx pending count */
801                 if (pAd->RxRing.RxDmaIdx > pAd->RxRing.RxSwReadIdx)
802                         *pRxPending =
803                             pAd->RxRing.RxDmaIdx - pAd->RxRing.RxSwReadIdx;
804                 else
805                         *pRxPending =
806                             pAd->RxRing.RxDmaIdx + RX_RING_SIZE -
807                             pAd->RxRing.RxSwReadIdx;
808
809         }
810
811         pRxCell = &pAd->RxRing.Cell[pAd->RxRing.RxSwReadIdx];
812
813         /* Point to Rx indexed rx ring descriptor */
814         pRxD = (struct rt_rxd *) pRxCell->AllocVa;
815
816         if (pRxD->DDONE == 0) {
817                 *pRxPending = 0;
818                 /* DMAIndx had done but DDONE bit not ready */
819                 bReschedule = TRUE;
820                 goto done;
821         }
822
823         /* return rx descriptor */
824         NdisMoveMemory(pSaveRxD, pRxD, RXD_SIZE);
825
826         pNewPacket =
827             RTMP_AllocateRxPacketBuffer(pAd, RX_BUFFER_AGGRESIZE, FALSE,
828                                         &AllocVa, &AllocPa);
829
830         if (pNewPacket) {
831                 /* unmap the rx buffer */
832                 PCI_UNMAP_SINGLE(pAd, pRxCell->DmaBuf.AllocPa,
833                                  pRxCell->DmaBuf.AllocSize, PCI_DMA_FROMDEVICE);
834                 pRxPacket = pRxCell->pNdisPacket;
835
836                 pRxCell->DmaBuf.AllocSize = RX_BUFFER_AGGRESIZE;
837                 pRxCell->pNdisPacket = (void *)pNewPacket;
838                 pRxCell->DmaBuf.AllocVa = AllocVa;
839                 pRxCell->DmaBuf.AllocPa = AllocPa;
840                 /* update SDP0 to new buffer of rx packet */
841                 pRxD->SDP0 = AllocPa;
842         } else {
843                 /*DBGPRINT(RT_DEBUG_TRACE,("No Rx Buffer\n")); */
844                 pRxPacket = NULL;
845                 bReschedule = TRUE;
846         }
847
848         pRxD->DDONE = 0;
849
850         /* had handled one rx packet */
851         *pRxPending = *pRxPending - 1;
852
853         /* update rx descriptor and kick rx */
854         INC_RING_INDEX(pAd->RxRing.RxSwReadIdx, RX_RING_SIZE);
855
856         pAd->RxRing.RxCpuIdx =
857             (pAd->RxRing.RxSwReadIdx ==
858              0) ? (RX_RING_SIZE - 1) : (pAd->RxRing.RxSwReadIdx - 1);
859         RTMP_IO_WRITE32(pAd, RX_CRX_IDX, pAd->RxRing.RxCpuIdx);
860
861 done:
862         RTMP_SEM_UNLOCK(&pAd->RxRingLock);
863         *pbReschedule = bReschedule;
864         return pRxPacket;
865 }
866
867 int MlmeHardTransmitTxRing(struct rt_rtmp_adapter *pAd,
868                                    u8 QueIdx, void *pPacket)
869 {
870         struct rt_packet_info PacketInfo;
871         u8 *pSrcBufVA;
872         u32 SrcBufLen;
873         struct rt_txd * pTxD;
874         struct rt_header_802_11 * pHeader_802_11;
875         BOOLEAN bAckRequired, bInsertTimestamp;
876         unsigned long SrcBufPA;
877         /*u8                 TxBufIdx; */
878         u8 MlmeRate;
879         unsigned long SwIdx = pAd->TxRing[QueIdx].TxCpuIdx;
880         struct rt_txwi * pFirstTxWI;
881         /*unsigned long i; */
882         /*HTTRANSMIT_SETTING    MlmeTransmit;   //Rate for this MGMT frame. */
883         unsigned long FreeNum;
884         struct rt_mac_table_entry *pMacEntry = NULL;
885
886         RTMP_QueryPacketInfo(pPacket, &PacketInfo, &pSrcBufVA, &SrcBufLen);
887
888         if (pSrcBufVA == NULL) {
889                 /* The buffer shouldn't be NULL */
890                 return NDIS_STATUS_FAILURE;
891         }
892         /* Make sure MGMT ring resource won't be used by other threads */
893         /*NdisAcquireSpinLock(&pAd->TxRingLock); */
894
895         FreeNum = GET_TXRING_FREENO(pAd, QueIdx);
896
897         if (FreeNum == 0) {
898                 /*NdisReleaseSpinLock(&pAd->TxRingLock); */
899                 return NDIS_STATUS_FAILURE;
900         }
901
902         SwIdx = pAd->TxRing[QueIdx].TxCpuIdx;
903
904         pTxD = (struct rt_txd *) pAd->TxRing[QueIdx].Cell[SwIdx].AllocVa;
905
906         if (pAd->TxRing[QueIdx].Cell[SwIdx].pNdisPacket) {
907                 DBGPRINT(RT_DEBUG_OFF, ("MlmeHardTransmit Error\n"));
908                 /*NdisReleaseSpinLock(&pAd->TxRingLock); */
909                 return NDIS_STATUS_FAILURE;
910         }
911
912         {
913                 /* outgoing frame always wakeup PHY to prevent frame lost */
914                 /* if (pAd->StaCfg.Psm == PWR_SAVE) */
915                 if (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_DOZE))
916                         AsicForceWakeup(pAd, TRUE);
917         }
918         pFirstTxWI = (struct rt_txwi *) pSrcBufVA;
919
920         pHeader_802_11 = (struct rt_header_802_11 *) (pSrcBufVA + TXWI_SIZE);
921         if (pHeader_802_11->Addr1[0] & 0x01) {
922                 MlmeRate = pAd->CommonCfg.BasicMlmeRate;
923         } else {
924                 MlmeRate = pAd->CommonCfg.MlmeRate;
925         }
926
927         if ((pHeader_802_11->FC.Type == BTYPE_DATA) &&
928             (pHeader_802_11->FC.SubType == SUBTYPE_QOS_NULL)) {
929                 pMacEntry = MacTableLookup(pAd, pHeader_802_11->Addr1);
930         }
931         /* Verify Mlme rate for a / g bands. */
932         if ((pAd->LatchRfRegs.Channel > 14) && (MlmeRate < RATE_6))     /* 11A band */
933                 MlmeRate = RATE_6;
934
935         /* */
936         /* Should not be hard code to set PwrMgmt to 0 (PWR_ACTIVE) */
937         /* Snice it's been set to 0 while on MgtMacHeaderInit */
938         /* By the way this will cause frame to be send on PWR_SAVE failed. */
939         /* */
940         /* */
941         /* In WMM-UAPSD, mlme frame should be set psm as power saving but probe request frame */
942         /* Data-Null packets also pass through MMRequest in RT2860, however, we hope control the psm bit to pass APSD */
943         if (pHeader_802_11->FC.Type != BTYPE_DATA) {
944                 if ((pHeader_802_11->FC.SubType == SUBTYPE_PROBE_REQ)
945                     || !(pAd->CommonCfg.bAPSDCapable
946                          && pAd->CommonCfg.APEdcaParm.bAPSDCapable)) {
947                         pHeader_802_11->FC.PwrMgmt = PWR_ACTIVE;
948                 } else {
949                         pHeader_802_11->FC.PwrMgmt =
950                             pAd->CommonCfg.bAPSDForcePowerSave;
951                 }
952         }
953
954         bInsertTimestamp = FALSE;
955         if (pHeader_802_11->FC.Type == BTYPE_CNTL)      /* must be PS-POLL */
956         {
957                 bAckRequired = FALSE;
958         } else                  /* BTYPE_MGMT or BTYPE_DATA(must be NULL frame) */
959         {
960                 if (pHeader_802_11->Addr1[0] & 0x01)    /* MULTICAST, BROADCAST */
961                 {
962                         bAckRequired = FALSE;
963                         pHeader_802_11->Duration = 0;
964                 } else {
965                         bAckRequired = TRUE;
966                         pHeader_802_11->Duration =
967                             RTMPCalcDuration(pAd, MlmeRate, 14);
968                         if (pHeader_802_11->FC.SubType == SUBTYPE_PROBE_RSP) {
969                                 bInsertTimestamp = TRUE;
970                         }
971                 }
972         }
973         pHeader_802_11->Sequence = pAd->Sequence++;
974         if (pAd->Sequence > 0xfff)
975                 pAd->Sequence = 0;
976         /* Before radar detection done, mgmt frame can not be sent but probe req */
977         /* Because we need to use probe req to trigger driver to send probe req in passive scan */
978         if ((pHeader_802_11->FC.SubType != SUBTYPE_PROBE_REQ)
979             && (pAd->CommonCfg.bIEEE80211H == 1)
980             && (pAd->CommonCfg.RadarDetect.RDMode != RD_NORMAL_MODE)) {
981                 DBGPRINT(RT_DEBUG_ERROR,
982                          ("MlmeHardTransmit --> radar detect not in normal mode!\n"));
983                 /*NdisReleaseSpinLock(&pAd->TxRingLock); */
984                 return (NDIS_STATUS_FAILURE);
985         }
986         /* */
987         /* fill scatter-and-gather buffer list into TXD. Internally created NDIS PACKET */
988         /* should always has only one ohysical buffer, and the whole frame size equals */
989         /* to the first scatter buffer size */
990         /* */
991
992         /* Initialize TX Descriptor */
993         /* For inter-frame gap, the number is for this frame and next frame */
994         /* For MLME rate, we will fix as 2Mb to match other vendor's implement */
995 /*      pAd->CommonCfg.MlmeTransmit.field.MODE = 1; */
996
997 /* management frame doesn't need encryption. so use RESERVED_WCID no matter u are sending to specific wcid or not. */
998         /* Only beacon use Nseq=TRUE. So here we use Nseq=FALSE. */
999         if (pMacEntry == NULL) {
1000                 RTMPWriteTxWI(pAd, pFirstTxWI, FALSE, FALSE, bInsertTimestamp,
1001                               FALSE, bAckRequired, FALSE, 0, RESERVED_WCID,
1002                               (SrcBufLen - TXWI_SIZE), PID_MGMT, 0,
1003                               (u8)pAd->CommonCfg.MlmeTransmit.field.MCS,
1004                               IFS_BACKOFF, FALSE, &pAd->CommonCfg.MlmeTransmit);
1005         } else {
1006                 RTMPWriteTxWI(pAd, pFirstTxWI, FALSE, FALSE,
1007                               bInsertTimestamp, FALSE, bAckRequired, FALSE,
1008                               0, pMacEntry->Aid, (SrcBufLen - TXWI_SIZE),
1009                               pMacEntry->MaxHTPhyMode.field.MCS, 0,
1010                               (u8)pMacEntry->MaxHTPhyMode.field.MCS,
1011                               IFS_BACKOFF, FALSE, &pMacEntry->MaxHTPhyMode);
1012         }
1013
1014         pAd->TxRing[QueIdx].Cell[SwIdx].pNdisPacket = pPacket;
1015         pAd->TxRing[QueIdx].Cell[SwIdx].pNextNdisPacket = NULL;
1016 /*      pFirstTxWI->MPDUtotalByteCount = SrcBufLen - TXWI_SIZE; */
1017         SrcBufPA =
1018             PCI_MAP_SINGLE(pAd, pSrcBufVA, SrcBufLen, 0, PCI_DMA_TODEVICE);
1019
1020         RTMPWriteTxDescriptor(pAd, pTxD, TRUE, FIFO_EDCA);
1021         pTxD->LastSec0 = 1;
1022         pTxD->LastSec1 = 1;
1023         pTxD->SDLen0 = SrcBufLen;
1024         pTxD->SDLen1 = 0;
1025         pTxD->SDPtr0 = SrcBufPA;
1026         pTxD->DMADONE = 0;
1027
1028         pAd->RalinkCounters.KickTxCount++;
1029         pAd->RalinkCounters.OneSecTxDoneCount++;
1030
1031         /* Increase TX_CTX_IDX, but write to register later. */
1032         INC_RING_INDEX(pAd->TxRing[QueIdx].TxCpuIdx, TX_RING_SIZE);
1033
1034         RTMP_IO_WRITE32(pAd, TX_CTX_IDX0 + QueIdx * 0x10,
1035                         pAd->TxRing[QueIdx].TxCpuIdx);
1036
1037         /* Make sure to release MGMT ring resource */
1038 /*      NdisReleaseSpinLock(&pAd->TxRingLock); */
1039
1040         return NDIS_STATUS_SUCCESS;
1041 }
1042
1043 int MlmeDataHardTransmit(struct rt_rtmp_adapter *pAd,
1044                                  u8 QueIdx, void *pPacket)
1045 {
1046         if ((pAd->CommonCfg.RadarDetect.RDMode != RD_NORMAL_MODE)
1047             ) {
1048                 return NDIS_STATUS_FAILURE;
1049         }
1050
1051         return MlmeHardTransmitTxRing(pAd, QueIdx, pPacket);
1052 }
1053
1054 /*
1055         ========================================================================
1056
1057         Routine Description:
1058                 Calculates the duration which is required to transmit out frames
1059         with given size and specified rate.
1060
1061         Arguments:
1062                 pTxD            Pointer to transmit descriptor
1063                 Ack             Setting for Ack requirement bit
1064                 Fragment        Setting for Fragment bit
1065                 RetryMode       Setting for retry mode
1066                 Ifs             Setting for IFS gap
1067                 Rate            Setting for transmit rate
1068                 Service         Setting for service
1069                 Length          Frame length
1070                 TxPreamble      Short or Long preamble when using CCK rates
1071                 QueIdx - 0-3, according to 802.11e/d4.4 June/2003
1072
1073         Return Value:
1074                 None
1075
1076         IRQL = PASSIVE_LEVEL
1077         IRQL = DISPATCH_LEVEL
1078
1079         ========================================================================
1080 */
1081 void RTMPWriteTxDescriptor(struct rt_rtmp_adapter *pAd,
1082                            struct rt_txd * pTxD,
1083                            IN BOOLEAN bWIV, u8 QueueSEL)
1084 {
1085         /* */
1086         /* Always use Long preamble before verifiation short preamble functionality works well. */
1087         /* Todo: remove the following line if short preamble functionality works */
1088         /* */
1089         OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_SHORT_PREAMBLE_INUSED);
1090
1091         pTxD->WIV = (bWIV) ? 1 : 0;
1092         pTxD->QSEL = (QueueSEL);
1093         /*RT2860c??  fixed using EDCA queue for test...  We doubt Queue1 has problem.  2006-09-26 Jan */
1094         /*pTxD->QSEL= FIFO_EDCA; */
1095         pTxD->DMADONE = 0;
1096 }