Pileus Git - ~andy/linux/blob - drivers/staging/vt6656/rxtx.c

   1 /*
   2  * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
   3  * All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * File: rxtx.c
  20  *
  21  * Purpose: handle WMAC/802.3/802.11 rx & tx functions
  22  *
  23  * Author: Lyndon Chen
  24  *
  25  * Date: May 20, 2003
  26  *
  27  * Functions:
  28  *      s_vGenerateTxParameter - Generate tx dma required parameter.
  29  *      s_vGenerateMACHeader - Translate 802.3 to 802.11 header
  30  *      csBeacon_xmit - beacon tx function
  31  *      csMgmt_xmit - management tx function
  32  *      s_uGetDataDuration - get tx data required duration
  33  *      s_uFillDataHead- fulfill tx data duration header
  34  *      s_uGetRTSCTSDuration- get rtx/cts required duration
  35  *      s_uGetRTSCTSRsvTime- get rts/cts reserved time
  36  *      s_uGetTxRsvTime- get frame reserved time
  37  *      s_vFillCTSHead- fulfill CTS ctl header
  38  *      s_vFillFragParameter- Set fragment ctl parameter.
  39  *      s_vFillRTSHead- fulfill RTS ctl header
  40  *      s_vFillTxKey- fulfill tx encrypt key
  41  *      s_vSWencryption- Software encrypt header
  42  *      vDMA0_tx_80211- tx 802.11 frame via dma0
  43  *      vGenerateFIFOHeader- Generate tx FIFO ctl header
  44  *
  45  * Revision History:
  46  *
  47  */
  48
  49 #include "device.h"
  50 #include "rxtx.h"
  51 #include "tether.h"
  52 #include "card.h"
  53 #include "bssdb.h"
  54 #include "mac.h"
  55 #include "baseband.h"
  56 #include "michael.h"
  57 #include "tkip.h"
  58 #include "tcrc.h"
  59 #include "wctl.h"
  60 #include "hostap.h"
  61 #include "rf.h"
  62 #include "datarate.h"
  63 #include "usbpipe.h"
  64 #include "iocmd.h"
  65
  66 static int          msglevel                = MSG_LEVEL_INFO;
  67
  68 const u16 wTimeStampOff[2][MAX_RATE] = {
  69         {384, 288, 226, 209, 54, 43, 37, 31, 28, 25, 24, 23}, // Long Preamble
  70         {384, 192, 130, 113, 54, 43, 37, 31, 28, 25, 24, 23}, // Short Preamble
  71     };
  72
  73 const u16 wFB_Opt0[2][5] = {
  74         {RATE_12M, RATE_18M, RATE_24M, RATE_36M, RATE_48M}, // fallback_rate0
  75         {RATE_12M, RATE_12M, RATE_18M, RATE_24M, RATE_36M}, // fallback_rate1
  76     };
  77 const u16 wFB_Opt1[2][5] = {
  78         {RATE_12M, RATE_18M, RATE_24M, RATE_24M, RATE_36M}, // fallback_rate0
  79         {RATE_6M , RATE_6M,  RATE_12M, RATE_12M, RATE_18M}, // fallback_rate1
  80     };
  81
  82 #define RTSDUR_BB       0
  83 #define RTSDUR_BA       1
  84 #define RTSDUR_AA       2
  85 #define CTSDUR_BA       3
  86 #define RTSDUR_BA_F0    4
  87 #define RTSDUR_AA_F0    5
  88 #define RTSDUR_BA_F1    6
  89 #define RTSDUR_AA_F1    7
  90 #define CTSDUR_BA_F0    8
  91 #define CTSDUR_BA_F1    9
  92 #define DATADUR_B       10
  93 #define DATADUR_A       11
  94 #define DATADUR_A_F0    12
  95 #define DATADUR_A_F1    13
  96
  97 static void s_vSaveTxPktInfo(struct vnt_private *pDevice, u8 byPktNum,
  98         u8 *pbyDestAddr, u16 wPktLength, u16 wFIFOCtl);
  99
 100 static void *s_vGetFreeContext(struct vnt_private *pDevice);
 101
 102 static void s_vGenerateTxParameter(struct vnt_private *pDevice,
 103         u8 byPktType, u16 wCurrentRate, void *pTxBufHead, void *pvRrvTime,
 104         void *pvRTS, void *pvCTS, u32 cbFrameSize, int bNeedACK, u32 uDMAIdx,
 105         struct ethhdr *psEthHeader);
 106
 107 static u32 s_uFillDataHead(struct vnt_private *pDevice,
 108         u8 byPktType, u16 wCurrentRate, void *pTxDataHead, u32 cbFrameLength,
 109         u32 uDMAIdx, int bNeedAck, u32 uFragIdx, u32 cbLastFragmentSize,
 110         u32 uMACfragNum, u8 byFBOption);
 111
 112 static void s_vGenerateMACHeader(struct vnt_private *pDevice,
 113         u8 *pbyBufferAddr, u16 wDuration, struct ethhdr *psEthHeader,
 114         int bNeedEncrypt, u16 wFragType, u32 uDMAIdx, u32 uFragIdx);
 115
 116 static void s_vFillTxKey(struct vnt_private *pDevice, u8 *pbyBuf,
 117         u8 *pbyIVHead, PSKeyItem pTransmitKey, u8 *pbyHdrBuf, u16 wPayloadLen,
 118         u8 *pMICHDR);
 119
 120 static void s_vSWencryption(struct vnt_private *pDevice,
 121         PSKeyItem pTransmitKey, u8 *pbyPayloadHead, u16 wPayloadSize);
 122
 123 static unsigned int s_uGetTxRsvTime(struct vnt_private *pDevice, u8 byPktType,
 124         u32 cbFrameLength, u16 wRate, int bNeedAck);
 125
 126 static u32 s_uGetRTSCTSRsvTime(struct vnt_private *pDevice, u8 byRTSRsvType,
 127         u8 byPktType, u32 cbFrameLength, u16 wCurrentRate);
 128
 129 static void s_vFillCTSHead(struct vnt_private *pDevice, u32 uDMAIdx,
 130         u8 byPktType, void *pvCTS, u32 cbFrameLength, int bNeedAck,
 131         int bDisCRC, u16 wCurrentRate, u8 byFBOption);
 132
 133 static void s_vFillRTSHead(struct vnt_private *pDevice, u8 byPktType,
 134         void *pvRTS, u32 cbFrameLength, int bNeedAck, int bDisCRC,
 135         struct ethhdr *psEthHeader, u16 wCurrentRate, u8 byFBOption);
 136
 137 static u32 s_uGetDataDuration(struct vnt_private *pDevice, u8 byDurType,
 138         u32 cbFrameLength, u8 byPktType, u16 wRate, int bNeedAck,
 139         u32 uFragIdx, u32 cbLastFragmentSize, u32 uMACfragNum,
 140         u8 byFBOption);
 141
 142 static unsigned int s_uGetRTSCTSDuration(struct vnt_private *pDevice,
 143         u8 byDurType, u32 cbFrameLength, u8 byPktType, u16 wRate,
 144         int bNeedAck, u8 byFBOption);
 145
 146 static void *s_vGetFreeContext(struct vnt_private *pDevice)
 147 {
 148         PUSB_SEND_CONTEXT pContext = NULL;
 149         PUSB_SEND_CONTEXT pReturnContext = NULL;
 150         int ii;
 151
 152     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"GetFreeContext()\n");
 153
 154     for (ii = 0; ii < pDevice->cbTD; ii++) {
 155         pContext = pDevice->apTD[ii];
 156         if (pContext->bBoolInUse == false) {
 157             pContext->bBoolInUse = true;
 158             pReturnContext = pContext;
 159             break;
 160         }
 161     }
 162     if ( ii == pDevice->cbTD ) {
 163         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"No Free Tx Context\n");
 164     }
 165     return (void *) pReturnContext;
 166 }
 167
 168 static void s_vSaveTxPktInfo(struct vnt_private *pDevice, u8 byPktNum,
 169         u8 *pbyDestAddr, u16 wPktLength, u16 wFIFOCtl)
 170 {
 171         PSStatCounter pStatistic = &pDevice->scStatistic;
 172
 173     if (is_broadcast_ether_addr(pbyDestAddr))
 174         pStatistic->abyTxPktInfo[byPktNum].byBroadMultiUni = TX_PKT_BROAD;
 175     else if (is_multicast_ether_addr(pbyDestAddr))
 176         pStatistic->abyTxPktInfo[byPktNum].byBroadMultiUni = TX_PKT_MULTI;
 177     else
 178         pStatistic->abyTxPktInfo[byPktNum].byBroadMultiUni = TX_PKT_UNI;
 179
 180     pStatistic->abyTxPktInfo[byPktNum].wLength = wPktLength;
 181     pStatistic->abyTxPktInfo[byPktNum].wFIFOCtl = wFIFOCtl;
 182     memcpy(pStatistic->abyTxPktInfo[byPktNum].abyDestAddr,
 183            pbyDestAddr,
 184            ETH_ALEN);
 185 }
 186
 187 static void s_vFillTxKey(struct vnt_private *pDevice, u8 *pbyBuf,
 188         u8 *pbyIVHead, PSKeyItem pTransmitKey, u8 *pbyHdrBuf,
 189         u16 wPayloadLen, u8 *pMICHDR)
 190 {
 191         u32 *pdwIV = (u32 *)pbyIVHead;
 192         u32 *pdwExtIV = (u32 *)((u8 *)pbyIVHead + 4);
 193         u16 wValue;
 194         struct ieee80211_hdr *pMACHeader = (struct ieee80211_hdr *)pbyHdrBuf;
 195         u32 dwRevIVCounter;
 196
 197     //Fill TXKEY
 198     if (pTransmitKey == NULL)
 199         return;
 200
 201     dwRevIVCounter = cpu_to_le32(pDevice->dwIVCounter);
 202     *pdwIV = pDevice->dwIVCounter;
 203     pDevice->byKeyIndex = pTransmitKey->dwKeyIndex & 0xf;
 204
 205     if (pTransmitKey->byCipherSuite == KEY_CTL_WEP) {
 206         if (pTransmitKey->uKeyLength == WLAN_WEP232_KEYLEN ){
 207             memcpy(pDevice->abyPRNG, (u8 *)&(dwRevIVCounter), 3);
 208             memcpy(pDevice->abyPRNG+3, pTransmitKey->abyKey, pTransmitKey->uKeyLength);
 209         } else {
 210             memcpy(pbyBuf, (u8 *)&(dwRevIVCounter), 3);
 211             memcpy(pbyBuf+3, pTransmitKey->abyKey, pTransmitKey->uKeyLength);
 212             if(pTransmitKey->uKeyLength == WLAN_WEP40_KEYLEN) {
 213                 memcpy(pbyBuf+8, (u8 *)&(dwRevIVCounter), 3);
 214                 memcpy(pbyBuf+11, pTransmitKey->abyKey, pTransmitKey->uKeyLength);
 215             }
 216             memcpy(pDevice->abyPRNG, pbyBuf, 16);
 217         }
 218         // Append IV after Mac Header
 219         *pdwIV &= WEP_IV_MASK;//00000000 11111111 11111111 11111111
 220         *pdwIV |= (u32)pDevice->byKeyIndex << 30;
 221         *pdwIV = cpu_to_le32(*pdwIV);
 222         pDevice->dwIVCounter++;
 223         if (pDevice->dwIVCounter > WEP_IV_MASK) {
 224             pDevice->dwIVCounter = 0;
 225         }
 226     } else if (pTransmitKey->byCipherSuite == KEY_CTL_TKIP) {
 227         pTransmitKey->wTSC15_0++;
 228         if (pTransmitKey->wTSC15_0 == 0) {
 229             pTransmitKey->dwTSC47_16++;
 230         }
 231         TKIPvMixKey(pTransmitKey->abyKey, pDevice->abyCurrentNetAddr,
 232                     pTransmitKey->wTSC15_0, pTransmitKey->dwTSC47_16, pDevice->abyPRNG);
 233         memcpy(pbyBuf, pDevice->abyPRNG, 16);
 234         // Make IV
 235         memcpy(pdwIV, pDevice->abyPRNG, 3);
 236
 237         *(pbyIVHead+3) = (u8)(((pDevice->byKeyIndex << 6) & 0xc0) | 0x20); // 0x20 is ExtIV
 238         // Append IV&ExtIV after Mac Header
 239         *pdwExtIV = cpu_to_le32(pTransmitKey->dwTSC47_16);
 240         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"vFillTxKey()---- pdwExtIV: %x\n",
 241                 *pdwExtIV);
 242
 243     } else if (pTransmitKey->byCipherSuite == KEY_CTL_CCMP) {
 244         pTransmitKey->wTSC15_0++;
 245         if (pTransmitKey->wTSC15_0 == 0) {
 246             pTransmitKey->dwTSC47_16++;
 247         }
 248         memcpy(pbyBuf, pTransmitKey->abyKey, 16);
 249
 250         // Make IV
 251         *pdwIV = 0;
 252         *(pbyIVHead+3) = (u8)(((pDevice->byKeyIndex << 6) & 0xc0) | 0x20); // 0x20 is ExtIV
 253         *pdwIV |= cpu_to_le16((u16)(pTransmitKey->wTSC15_0));
 254         //Append IV&ExtIV after Mac Header
 255         *pdwExtIV = cpu_to_le32(pTransmitKey->dwTSC47_16);
 256
 257         //Fill MICHDR0
 258         *pMICHDR = 0x59;
 259         *((u8 *)(pMICHDR+1)) = 0; // TxPriority
 260         memcpy(pMICHDR+2, &(pMACHeader->addr2[0]), 6);
 261         *((u8 *)(pMICHDR+8)) = HIBYTE(HIWORD(pTransmitKey->dwTSC47_16));
 262         *((u8 *)(pMICHDR+9)) = LOBYTE(HIWORD(pTransmitKey->dwTSC47_16));
 263         *((u8 *)(pMICHDR+10)) = HIBYTE(LOWORD(pTransmitKey->dwTSC47_16));
 264         *((u8 *)(pMICHDR+11)) = LOBYTE(LOWORD(pTransmitKey->dwTSC47_16));
 265         *((u8 *)(pMICHDR+12)) = HIBYTE(pTransmitKey->wTSC15_0);
 266         *((u8 *)(pMICHDR+13)) = LOBYTE(pTransmitKey->wTSC15_0);
 267         *((u8 *)(pMICHDR+14)) = HIBYTE(wPayloadLen);
 268         *((u8 *)(pMICHDR+15)) = LOBYTE(wPayloadLen);
 269
 270         //Fill MICHDR1
 271         *((u8 *)(pMICHDR+16)) = 0; // HLEN[15:8]
 272         if (pDevice->bLongHeader) {
 273             *((u8 *)(pMICHDR+17)) = 28; // HLEN[7:0]
 274         } else {
 275             *((u8 *)(pMICHDR+17)) = 22; // HLEN[7:0]
 276         }
 277         wValue = cpu_to_le16(pMACHeader->frame_control & 0xC78F);
 278         memcpy(pMICHDR+18, (u8 *)&wValue, 2); // MSKFRACTL
 279         memcpy(pMICHDR+20, &(pMACHeader->addr1[0]), 6);
 280         memcpy(pMICHDR+26, &(pMACHeader->addr2[0]), 6);
 281
 282         //Fill MICHDR2
 283         memcpy(pMICHDR+32, &(pMACHeader->addr3[0]), 6);
 284         wValue = pMACHeader->seq_ctrl;
 285         wValue &= 0x000F;
 286         wValue = cpu_to_le16(wValue);
 287         memcpy(pMICHDR+38, (u8 *)&wValue, 2); // MSKSEQCTL
 288         if (pDevice->bLongHeader) {
 289             memcpy(pMICHDR+40, &(pMACHeader->addr4[0]), 6);
 290         }
 291     }
 292 }
 293
 294 static void s_vSWencryption(struct vnt_private *pDevice,
 295         PSKeyItem pTransmitKey, u8 *pbyPayloadHead, u16 wPayloadSize)
 296 {
 297         u32 cbICVlen = 4;
 298         u32 dwICV = 0xffffffff;
 299         u32 *pdwICV;
 300
 301     if (pTransmitKey == NULL)
 302         return;
 303
 304     if (pTransmitKey->byCipherSuite == KEY_CTL_WEP) {
 305         //=======================================================================
 306         // Append ICV after payload
 307         dwICV = CRCdwGetCrc32Ex(pbyPayloadHead, wPayloadSize, dwICV);//ICV(Payload)
 308         pdwICV = (u32 *)(pbyPayloadHead + wPayloadSize);
 309         // finally, we must invert dwCRC to get the correct answer
 310         *pdwICV = cpu_to_le32(~dwICV);
 311         // RC4 encryption
 312         rc4_init(&pDevice->SBox, pDevice->abyPRNG, pTransmitKey->uKeyLength + 3);
 313         rc4_encrypt(&pDevice->SBox, pbyPayloadHead, pbyPayloadHead, wPayloadSize+cbICVlen);
 314         //=======================================================================
 315     } else if (pTransmitKey->byCipherSuite == KEY_CTL_TKIP) {
 316         //=======================================================================
 317         //Append ICV after payload
 318         dwICV = CRCdwGetCrc32Ex(pbyPayloadHead, wPayloadSize, dwICV);//ICV(Payload)
 319         pdwICV = (u32 *)(pbyPayloadHead + wPayloadSize);
 320         // finally, we must invert dwCRC to get the correct answer
 321         *pdwICV = cpu_to_le32(~dwICV);
 322         // RC4 encryption
 323         rc4_init(&pDevice->SBox, pDevice->abyPRNG, TKIP_KEY_LEN);
 324         rc4_encrypt(&pDevice->SBox, pbyPayloadHead, pbyPayloadHead, wPayloadSize+cbICVlen);
 325         //=======================================================================
 326     }
 327 }
 328
 329 /*byPktType : PK_TYPE_11A     0
 330              PK_TYPE_11B     1
 331              PK_TYPE_11GB    2
 332              PK_TYPE_11GA    3
 333 */
 334 static u32 s_uGetTxRsvTime(struct vnt_private *pDevice, u8 byPktType,
 335         u32 cbFrameLength, u16 wRate, int bNeedAck)
 336 {
 337         u32 uDataTime, uAckTime;
 338
 339     uDataTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, cbFrameLength, wRate);
 340     if (byPktType == PK_TYPE_11B) {//llb,CCK mode
 341         uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, (u16)pDevice->byTopCCKBasicRate);
 342     } else {//11g 2.4G OFDM mode & 11a 5G OFDM mode
 343         uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, (u16)pDevice->byTopOFDMBasicRate);
 344     }
 345
 346     if (bNeedAck) {
 347         return (uDataTime + pDevice->uSIFS + uAckTime);
 348     }
 349     else {
 350         return uDataTime;
 351     }
 352 }
 353
 354 //byFreqType: 0=>5GHZ 1=>2.4GHZ
 355 static u32 s_uGetRTSCTSRsvTime(struct vnt_private *pDevice,
 356         u8 byRTSRsvType, u8 byPktType, u32 cbFrameLength, u16 wCurrentRate)
 357 {
 358         u32 uRrvTime, uRTSTime, uCTSTime, uAckTime, uDataTime;
 359
 360     uRrvTime = uRTSTime = uCTSTime = uAckTime = uDataTime = 0;
 361
 362     uDataTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, cbFrameLength, wCurrentRate);
 363     if (byRTSRsvType == 0) { //RTSTxRrvTime_bb
 364         uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopCCKBasicRate);
 365         uCTSTime = uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 366     }
 367     else if (byRTSRsvType == 1){ //RTSTxRrvTime_ba, only in 2.4GHZ
 368         uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopCCKBasicRate);
 369         uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 370         uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 371     }
 372     else if (byRTSRsvType == 2) { //RTSTxRrvTime_aa
 373         uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopOFDMBasicRate);
 374         uCTSTime = uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 375     }
 376     else if (byRTSRsvType == 3) { //CTSTxRrvTime_ba, only in 2.4GHZ
 377         uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 378         uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 379         uRrvTime = uCTSTime + uAckTime + uDataTime + 2*pDevice->uSIFS;
 380         return uRrvTime;
 381     }
 382
 383     //RTSRrvTime
 384     uRrvTime = uRTSTime + uCTSTime + uAckTime + uDataTime + 3*pDevice->uSIFS;
 385     return uRrvTime;
 386 }
 387
 388 //byFreqType 0: 5GHz, 1:2.4Ghz
 389 static u32 s_uGetDataDuration(struct vnt_private *pDevice, u8 byDurType,
 390         u32 cbFrameLength, u8 byPktType, u16 wRate, int bNeedAck,
 391         u32 uFragIdx, u32 cbLastFragmentSize, u32 uMACfragNum,
 392         u8 byFBOption)
 393 {
 394         int bLastFrag = 0;
 395         u32 uAckTime = 0, uNextPktTime = 0;
 396
 397     if (uFragIdx == (uMACfragNum-1)) {
 398         bLastFrag = 1;
 399     }
 400
 401     switch (byDurType) {
 402
 403     case DATADUR_B:    //DATADUR_B
 404         if (((uMACfragNum == 1)) || (bLastFrag == 1)) {//Non Frag or Last Frag
 405             if (bNeedAck) {
 406                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 407                 return (pDevice->uSIFS + uAckTime);
 408             } else {
 409                 return 0;
 410             }
 411         }
 412         else {//First Frag or Mid Frag
 413             if (uFragIdx == (uMACfragNum-2)) {
 414                 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wRate, bNeedAck);
 415             } else {
 416                 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
 417             }
 418             if (bNeedAck) {
 419                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 420                 return (pDevice->uSIFS + uAckTime + uNextPktTime);
 421             } else {
 422                 return (pDevice->uSIFS + uNextPktTime);
 423             }
 424         }
 425         break;
 426
 427     case DATADUR_A:    //DATADUR_A
 428         if (((uMACfragNum==1)) || (bLastFrag==1)) {//Non Frag or Last Frag
 429             if(bNeedAck){
 430                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 431                 return (pDevice->uSIFS + uAckTime);
 432             } else {
 433                 return 0;
 434             }
 435         }
 436         else {//First Frag or Mid Frag
 437             if(uFragIdx == (uMACfragNum-2)){
 438                 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wRate, bNeedAck);
 439             } else {
 440                 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
 441             }
 442             if(bNeedAck){
 443                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 444                 return (pDevice->uSIFS + uAckTime + uNextPktTime);
 445             } else {
 446                 return (pDevice->uSIFS + uNextPktTime);
 447             }
 448         }
 449         break;
 450
 451     case DATADUR_A_F0:    //DATADUR_A_F0
 452             if (((uMACfragNum==1)) || (bLastFrag==1)) {//Non Frag or Last Frag
 453             if(bNeedAck){
 454                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 455                 return (pDevice->uSIFS + uAckTime);
 456             } else {
 457                 return 0;
 458             }
 459         }
 460             else { //First Frag or Mid Frag
 461                 if (byFBOption == AUTO_FB_0) {
 462                 if (wRate < RATE_18M)
 463                     wRate = RATE_18M;
 464                 else if (wRate > RATE_54M)
 465                     wRate = RATE_54M;
 466
 467                     if(uFragIdx == (uMACfragNum-2)){
 468                     uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
 469                 } else {
 470                     uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
 471                 }
 472                 } else { // (byFBOption == AUTO_FB_1)
 473                 if (wRate < RATE_18M)
 474                     wRate = RATE_18M;
 475                 else if (wRate > RATE_54M)
 476                     wRate = RATE_54M;
 477
 478                     if(uFragIdx == (uMACfragNum-2)){
 479                     uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
 480                 } else {
 481                     uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
 482                 }
 483                 }
 484
 485                 if(bNeedAck){
 486                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 487                 return (pDevice->uSIFS + uAckTime + uNextPktTime);
 488             } else {
 489                 return (pDevice->uSIFS + uNextPktTime);
 490             }
 491             }
 492         break;
 493
 494     case DATADUR_A_F1:    //DATADUR_A_F1
 495         if (((uMACfragNum==1)) || (bLastFrag==1)) {//Non Frag or Last Frag
 496             if(bNeedAck){
 497                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 498                 return (pDevice->uSIFS + uAckTime);
 499             } else {
 500                 return 0;
 501             }
 502         }
 503             else { //First Frag or Mid Frag
 504                 if (byFBOption == AUTO_FB_0) {
 505                 if (wRate < RATE_18M)
 506                     wRate = RATE_18M;
 507                 else if (wRate > RATE_54M)
 508                     wRate = RATE_54M;
 509
 510                     if(uFragIdx == (uMACfragNum-2)){
 511                     uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
 512                 } else {
 513                     uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
 514                 }
 515
 516                 } else { // (byFBOption == AUTO_FB_1)
 517                 if (wRate < RATE_18M)
 518                     wRate = RATE_18M;
 519                 else if (wRate > RATE_54M)
 520                     wRate = RATE_54M;
 521
 522                     if(uFragIdx == (uMACfragNum-2)){
 523                     uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
 524                 } else {
 525                     uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
 526                 }
 527                 }
 528                 if(bNeedAck){
 529                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 530                 return (pDevice->uSIFS + uAckTime + uNextPktTime);
 531             } else {
 532                 return (pDevice->uSIFS + uNextPktTime);
 533             }
 534             }
 535         break;
 536
 537     default:
 538         break;
 539     }
 540
 541         ASSERT(false);
 542         return 0;
 543 }
 544
 545 //byFreqType: 0=>5GHZ 1=>2.4GHZ
 546 static u32 s_uGetRTSCTSDuration(struct vnt_private *pDevice, u8 byDurType,
 547         u32 cbFrameLength, u8 byPktType, u16 wRate, int bNeedAck,
 548         u8 byFBOption)
 549 {
 550         u32 uCTSTime = 0, uDurTime = 0;
 551
 552     switch (byDurType) {
 553
 554     case RTSDUR_BB:    //RTSDuration_bb
 555         uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 556         uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
 557         break;
 558
 559     case RTSDUR_BA:    //RTSDuration_ba
 560         uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 561         uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
 562         break;
 563
 564     case RTSDUR_AA:    //RTSDuration_aa
 565         uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 566         uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
 567         break;
 568
 569     case CTSDUR_BA:    //CTSDuration_ba
 570         uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
 571         break;
 572
 573     case RTSDUR_BA_F0: //RTSDuration_ba_f0
 574         uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 575         if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
 576             uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
 577         } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
 578             uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
 579         }
 580         break;
 581
 582     case RTSDUR_AA_F0: //RTSDuration_aa_f0
 583         uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 584         if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
 585             uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
 586         } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
 587             uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
 588         }
 589         break;
 590
 591     case RTSDUR_BA_F1: //RTSDuration_ba_f1
 592         uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 593         if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
 594             uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
 595         } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
 596             uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
 597         }
 598         break;
 599
 600     case RTSDUR_AA_F1: //RTSDuration_aa_f1
 601         uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 602         if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
 603             uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
 604         } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
 605             uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
 606         }
 607         break;
 608
 609     case CTSDUR_BA_F0: //CTSDuration_ba_f0
 610         if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
 611             uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
 612         } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
 613             uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
 614         }
 615         break;
 616
 617     case CTSDUR_BA_F1: //CTSDuration_ba_f1
 618         if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
 619             uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
 620         } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
 621             uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
 622         }
 623         break;
 624
 625     default:
 626         break;
 627     }
 628
 629     return uDurTime;
 630
 631 }
 632
 633 static u32 s_uFillDataHead(struct vnt_private *pDevice,
 634         u8 byPktType, u16 wCurrentRate, void *pTxDataHead, u32 cbFrameLength,
 635         u32 uDMAIdx, int bNeedAck, u32 uFragIdx, u32 cbLastFragmentSize,
 636         u32 uMACfragNum, u8 byFBOption)
 637 {
 638
 639     if (pTxDataHead == NULL) {
 640         return 0;
 641     }
 642
 643     if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
 644         if ((uDMAIdx == TYPE_ATIMDMA) || (uDMAIdx == TYPE_BEACONDMA)) {
 645                 PSTxDataHead_ab pBuf = (PSTxDataHead_ab) pTxDataHead;
 646             //Get SignalField,ServiceField,Length
 647             BBvCalculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
 648                 (u16 *)&(pBuf->wTransmitLength), (u8 *)&(pBuf->byServiceField), (u8 *)&(pBuf->bySignalField)
 649             );
 650             //Get Duration and TimeStampOff
 651             pBuf->wDuration = (u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
 652                                                        wCurrentRate, bNeedAck, uFragIdx,
 653                                                        cbLastFragmentSize, uMACfragNum,
 654                                                        byFBOption); //1: 2.4GHz
 655             if(uDMAIdx!=TYPE_ATIMDMA) {
 656                 pBuf->wTimeStampOff = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
 657             }
 658             return (pBuf->wDuration);
 659         }
 660         else { // DATA & MANAGE Frame
 661             if (byFBOption == AUTO_FB_NONE) {
 662                 PSTxDataHead_g pBuf = (PSTxDataHead_g)pTxDataHead;
 663                 //Get SignalField,ServiceField,Length
 664                 BBvCalculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
 665                     (u16 *)&(pBuf->wTransmitLength_a), (u8 *)&(pBuf->byServiceField_a), (u8 *)&(pBuf->bySignalField_a)
 666                 );
 667                 BBvCalculateParameter(pDevice, cbFrameLength, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
 668                     (u16 *)&(pBuf->wTransmitLength_b), (u8 *)&(pBuf->byServiceField_b), (u8 *)&(pBuf->bySignalField_b)
 669                 );
 670                 //Get Duration and TimeStamp
 671                 pBuf->wDuration_a = (u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength,
 672                                                              byPktType, wCurrentRate, bNeedAck, uFragIdx,
 673                                                              cbLastFragmentSize, uMACfragNum,
 674                                                              byFBOption); //1: 2.4GHz
 675                 pBuf->wDuration_b = (u16)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength,
 676                                                              PK_TYPE_11B, pDevice->byTopCCKBasicRate,
 677                                                              bNeedAck, uFragIdx, cbLastFragmentSize,
 678                                                              uMACfragNum, byFBOption); //1: 2.4GHz
 679
 680                 pBuf->wTimeStampOff_a = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
 681                 pBuf->wTimeStampOff_b = wTimeStampOff[pDevice->byPreambleType%2][pDevice->byTopCCKBasicRate%MAX_RATE];
 682                 return (pBuf->wDuration_a);
 683              } else {
 684                 // Auto Fallback
 685                 PSTxDataHead_g_FB pBuf = (PSTxDataHead_g_FB)pTxDataHead;
 686                 //Get SignalField,ServiceField,Length
 687                 BBvCalculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
 688                     (u16 *)&(pBuf->wTransmitLength_a), (u8 *)&(pBuf->byServiceField_a), (u8 *)&(pBuf->bySignalField_a)
 689                 );
 690                 BBvCalculateParameter(pDevice, cbFrameLength, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
 691                     (u16 *)&(pBuf->wTransmitLength_b), (u8 *)&(pBuf->byServiceField_b), (u8 *)&(pBuf->bySignalField_b)
 692                 );
 693                 //Get Duration and TimeStamp
 694                 pBuf->wDuration_a = (u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
 695                                              wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //1: 2.4GHz
 696                 pBuf->wDuration_b = (u16)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength, PK_TYPE_11B,
 697                                              pDevice->byTopCCKBasicRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //1: 2.4GHz
 698                 pBuf->wDuration_a_f0 = (u16)s_uGetDataDuration(pDevice, DATADUR_A_F0, cbFrameLength, byPktType,
 699                                              wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //1: 2.4GHz
 700                 pBuf->wDuration_a_f1 = (u16)s_uGetDataDuration(pDevice, DATADUR_A_F1, cbFrameLength, byPktType,
 701                                              wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //1: 2.4GHz
 702                 pBuf->wTimeStampOff_a = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
 703                 pBuf->wTimeStampOff_b = wTimeStampOff[pDevice->byPreambleType%2][pDevice->byTopCCKBasicRate%MAX_RATE];
 704                 return (pBuf->wDuration_a);
 705             } //if (byFBOption == AUTO_FB_NONE)
 706         }
 707     }
 708     else if (byPktType == PK_TYPE_11A) {
 709         if ((byFBOption != AUTO_FB_NONE) && (uDMAIdx != TYPE_ATIMDMA) && (uDMAIdx != TYPE_BEACONDMA)) {
 710             // Auto Fallback
 711             PSTxDataHead_a_FB pBuf = (PSTxDataHead_a_FB)pTxDataHead;
 712             //Get SignalField,ServiceField,Length
 713             BBvCalculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
 714                 (u16 *)&(pBuf->wTransmitLength), (u8 *)&(pBuf->byServiceField), (u8 *)&(pBuf->bySignalField)
 715             );
 716             //Get Duration and TimeStampOff
 717             pBuf->wDuration = (u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
 718                                         wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //0: 5GHz
 719             pBuf->wDuration_f0 = (u16)s_uGetDataDuration(pDevice, DATADUR_A_F0, cbFrameLength, byPktType,
 720                                         wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //0: 5GHz
 721             pBuf->wDuration_f1 = (u16)s_uGetDataDuration(pDevice, DATADUR_A_F1, cbFrameLength, byPktType,
 722                                         wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //0: 5GHz
 723             if(uDMAIdx!=TYPE_ATIMDMA) {
 724                 pBuf->wTimeStampOff = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
 725             }
 726             return (pBuf->wDuration);
 727         } else {
 728             PSTxDataHead_ab pBuf = (PSTxDataHead_ab)pTxDataHead;
 729             //Get SignalField,ServiceField,Length
 730             BBvCalculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
 731                 (u16 *)&(pBuf->wTransmitLength), (u8 *)&(pBuf->byServiceField), (u8 *)&(pBuf->bySignalField)
 732             );
 733             //Get Duration and TimeStampOff
 734             pBuf->wDuration = (u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
 735                                                        wCurrentRate, bNeedAck, uFragIdx,
 736                                                        cbLastFragmentSize, uMACfragNum,
 737                                                        byFBOption);
 738
 739             if(uDMAIdx!=TYPE_ATIMDMA) {
 740                 pBuf->wTimeStampOff = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
 741             }
 742             return (pBuf->wDuration);
 743         }
 744     }
 745     else if (byPktType == PK_TYPE_11B) {
 746             PSTxDataHead_ab pBuf = (PSTxDataHead_ab)pTxDataHead;
 747             //Get SignalField,ServiceField,Length
 748             BBvCalculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
 749                 (u16 *)&(pBuf->wTransmitLength), (u8 *)&(pBuf->byServiceField), (u8 *)&(pBuf->bySignalField)
 750             );
 751             //Get Duration and TimeStampOff
 752             pBuf->wDuration = (u16)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength, byPktType,
 753                                                        wCurrentRate, bNeedAck, uFragIdx,
 754                                                        cbLastFragmentSize, uMACfragNum,
 755                                                        byFBOption);
 756             if (uDMAIdx != TYPE_ATIMDMA) {
 757                 pBuf->wTimeStampOff = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
 758             }
 759             return (pBuf->wDuration);
 760     }
 761     return 0;
 762 }
 763
 764 static void s_vFillRTSHead(struct vnt_private *pDevice, u8 byPktType,
 765         void *pvRTS, u32 cbFrameLength, int bNeedAck, int bDisCRC,
 766         struct ethhdr *psEthHeader, u16 wCurrentRate, u8 byFBOption)
 767 {
 768         u32 uRTSFrameLen = 20;
 769         u16 wLen = 0;
 770
 771     if (pvRTS == NULL)
 772         return;
 773
 774     if (bDisCRC) {
 775         // When CRCDIS bit is on, H/W forgot to generate FCS for RTS frame,
 776         // in this case we need to decrease its length by 4.
 777         uRTSFrameLen -= 4;
 778     }
 779
 780     // Note: So far RTSHead doesn't appear in ATIM & Beacom DMA, so we don't need to take them into account.
 781     //       Otherwise, we need to modified codes for them.
 782     if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
 783         if (byFBOption == AUTO_FB_NONE) {
 784             PSRTS_g pBuf = (PSRTS_g)pvRTS;
 785             //Get SignalField,ServiceField,Length
 786             BBvCalculateParameter(pDevice, uRTSFrameLen, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
 787                 (u16 *)&(wLen), (u8 *)&(pBuf->byServiceField_b), (u8 *)&(pBuf->bySignalField_b)
 788             );
 789             pBuf->wTransmitLength_b = cpu_to_le16(wLen);
 790             BBvCalculateParameter(pDevice, uRTSFrameLen, pDevice->byTopOFDMBasicRate, byPktType,
 791                 (u16 *)&(wLen), (u8 *)&(pBuf->byServiceField_a), (u8 *)&(pBuf->bySignalField_a)
 792             );
 793             pBuf->wTransmitLength_a = cpu_to_le16(wLen);
 794             //Get Duration
 795             pBuf->wDuration_bb = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_BB, cbFrameLength, PK_TYPE_11B, pDevice->byTopCCKBasicRate, bNeedAck, byFBOption));    //0:RTSDuration_bb, 1:2.4G, 1:CCKData
 796             pBuf->wDuration_aa = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //2:RTSDuration_aa, 1:2.4G, 2,3: 2.4G OFDMData
 797             pBuf->wDuration_ba = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_BA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //1:RTSDuration_ba, 1:2.4G, 2,3:2.4G OFDM Data
 798
 799             pBuf->Data.wDurationID = pBuf->wDuration_aa;
 800             //Get RTS Frame body
 801             pBuf->Data.wFrameControl = TYPE_CTL_RTS;//0x00B4
 802
 803         if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
 804             (pDevice->eOPMode == OP_MODE_AP)) {
 805                 memcpy(&(pBuf->Data.abyRA[0]),
 806                        &(psEthHeader->h_dest[0]),
 807                        ETH_ALEN);
 808         }
 809             else {
 810                     memcpy(&(pBuf->Data.abyRA[0]),
 811                            &(pDevice->abyBSSID[0]),
 812                            ETH_ALEN);
 813             }
 814         if (pDevice->eOPMode == OP_MODE_AP) {
 815                 memcpy(&(pBuf->Data.abyTA[0]),
 816                        &(pDevice->abyBSSID[0]),
 817                        ETH_ALEN);
 818         }
 819             else {
 820                     memcpy(&(pBuf->Data.abyTA[0]),
 821                            &(psEthHeader->h_source[0]),
 822                            ETH_ALEN);
 823             }
 824         }
 825         else {
 826            PSRTS_g_FB pBuf = (PSRTS_g_FB)pvRTS;
 827             //Get SignalField,ServiceField,Length
 828             BBvCalculateParameter(pDevice, uRTSFrameLen, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
 829                 (u16 *)&(wLen), (u8 *)&(pBuf->byServiceField_b), (u8 *)&(pBuf->bySignalField_b)
 830             );
 831             pBuf->wTransmitLength_b = cpu_to_le16(wLen);
 832             BBvCalculateParameter(pDevice, uRTSFrameLen, pDevice->byTopOFDMBasicRate, byPktType,
 833                 (u16 *)&(wLen), (u8 *)&(pBuf->byServiceField_a), (u8 *)&(pBuf->bySignalField_a)
 834             );
 835             pBuf->wTransmitLength_a = cpu_to_le16(wLen);
 836             //Get Duration
 837             pBuf->wDuration_bb = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_BB, cbFrameLength, PK_TYPE_11B, pDevice->byTopCCKBasicRate, bNeedAck, byFBOption));    //0:RTSDuration_bb, 1:2.4G, 1:CCKData
 838             pBuf->wDuration_aa = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //2:RTSDuration_aa, 1:2.4G, 2,3:2.4G OFDMData
 839             pBuf->wDuration_ba = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_BA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //1:RTSDuration_ba, 1:2.4G, 2,3:2.4G OFDMData
 840             pBuf->wRTSDuration_ba_f0 = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_BA_F0, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption));    //4:wRTSDuration_ba_f0, 1:2.4G, 1:CCKData
 841             pBuf->wRTSDuration_aa_f0 = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F0, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption));    //5:wRTSDuration_aa_f0, 1:2.4G, 1:CCKData
 842             pBuf->wRTSDuration_ba_f1 = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_BA_F1, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption));    //6:wRTSDuration_ba_f1, 1:2.4G, 1:CCKData
 843             pBuf->wRTSDuration_aa_f1 = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F1, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption));    //7:wRTSDuration_aa_f1, 1:2.4G, 1:CCKData
 844             pBuf->Data.wDurationID = pBuf->wDuration_aa;
 845             //Get RTS Frame body
 846             pBuf->Data.wFrameControl = TYPE_CTL_RTS;//0x00B4
 847
 848         if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
 849             (pDevice->eOPMode == OP_MODE_AP)) {
 850                 memcpy(&(pBuf->Data.abyRA[0]),
 851                        &(psEthHeader->h_dest[0]),
 852                        ETH_ALEN);
 853         }
 854             else {
 855                 memcpy(&(pBuf->Data.abyRA[0]),
 856                        &(pDevice->abyBSSID[0]),
 857                        ETH_ALEN);
 858             }
 859
 860         if (pDevice->eOPMode == OP_MODE_AP) {
 861                 memcpy(&(pBuf->Data.abyTA[0]),
 862                        &(pDevice->abyBSSID[0]),
 863                        ETH_ALEN);
 864         }
 865             else {
 866                     memcpy(&(pBuf->Data.abyTA[0]),
 867                            &(psEthHeader->h_source[0]),
 868                            ETH_ALEN);
 869             }
 870
 871         } // if (byFBOption == AUTO_FB_NONE)
 872     }
 873     else if (byPktType == PK_TYPE_11A) {
 874         if (byFBOption == AUTO_FB_NONE) {
 875             PSRTS_ab pBuf = (PSRTS_ab)pvRTS;
 876             //Get SignalField,ServiceField,Length
 877             BBvCalculateParameter(pDevice, uRTSFrameLen, pDevice->byTopOFDMBasicRate, byPktType,
 878                 (u16 *)&(wLen), (u8 *)&(pBuf->byServiceField), (u8 *)&(pBuf->bySignalField)
 879             );
 880             pBuf->wTransmitLength = cpu_to_le16(wLen);
 881             //Get Duration
 882             pBuf->wDuration = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //0:RTSDuration_aa, 0:5G, 0: 5G OFDMData
 883             pBuf->Data.wDurationID = pBuf->wDuration;
 884             //Get RTS Frame body
 885             pBuf->Data.wFrameControl = TYPE_CTL_RTS;//0x00B4
 886
 887         if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
 888             (pDevice->eOPMode == OP_MODE_AP)) {
 889                 memcpy(&(pBuf->Data.abyRA[0]),
 890                        &(psEthHeader->h_dest[0]),
 891                        ETH_ALEN);
 892         } else {
 893                 memcpy(&(pBuf->Data.abyRA[0]),
 894                        &(pDevice->abyBSSID[0]),
 895                        ETH_ALEN);
 896         }
 897
 898         if (pDevice->eOPMode == OP_MODE_AP) {
 899                 memcpy(&(pBuf->Data.abyTA[0]),
 900                        &(pDevice->abyBSSID[0]),
 901                        ETH_ALEN);
 902         } else {
 903                 memcpy(&(pBuf->Data.abyTA[0]),
 904                        &(psEthHeader->h_source[0]),
 905                        ETH_ALEN);
 906         }
 907
 908         }
 909         else {
 910             PSRTS_a_FB pBuf = (PSRTS_a_FB)pvRTS;
 911             //Get SignalField,ServiceField,Length
 912             BBvCalculateParameter(pDevice, uRTSFrameLen, pDevice->byTopOFDMBasicRate, byPktType,
 913                 (u16 *)&(wLen), (u8 *)&(pBuf->byServiceField), (u8 *)&(pBuf->bySignalField)
 914             );
 915             pBuf->wTransmitLength = cpu_to_le16(wLen);
 916             //Get Duration
 917             pBuf->wDuration = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //0:RTSDuration_aa, 0:5G, 0: 5G OFDMData
 918             pBuf->wRTSDuration_f0 = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F0, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //5:RTSDuration_aa_f0, 0:5G, 0: 5G OFDMData
 919             pBuf->wRTSDuration_f1 = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F1, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //7:RTSDuration_aa_f1, 0:5G, 0:
 920             pBuf->Data.wDurationID = pBuf->wDuration;
 921             //Get RTS Frame body
 922             pBuf->Data.wFrameControl = TYPE_CTL_RTS;//0x00B4
 923
 924         if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
 925             (pDevice->eOPMode == OP_MODE_AP)) {
 926                 memcpy(&(pBuf->Data.abyRA[0]),
 927                        &(psEthHeader->h_dest[0]),
 928                        ETH_ALEN);
 929         } else {
 930                 memcpy(&(pBuf->Data.abyRA[0]),
 931                        &(pDevice->abyBSSID[0]),
 932                        ETH_ALEN);
 933         }
 934         if (pDevice->eOPMode == OP_MODE_AP) {
 935                 memcpy(&(pBuf->Data.abyTA[0]),
 936                        &(pDevice->abyBSSID[0]),
 937                        ETH_ALEN);
 938         } else {
 939                 memcpy(&(pBuf->Data.abyTA[0]),
 940                        &(psEthHeader->h_source[0]),
 941                        ETH_ALEN);
 942         }
 943         }
 944     }
 945     else if (byPktType == PK_TYPE_11B) {
 946         PSRTS_ab pBuf = (PSRTS_ab)pvRTS;
 947         //Get SignalField,ServiceField,Length
 948         BBvCalculateParameter(pDevice, uRTSFrameLen, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
 949             (u16 *)&(wLen), (u8 *)&(pBuf->byServiceField), (u8 *)&(pBuf->bySignalField)
 950         );
 951         pBuf->wTransmitLength = cpu_to_le16(wLen);
 952         //Get Duration
 953         pBuf->wDuration = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_BB, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //0:RTSDuration_bb, 1:2.4G, 1:CCKData
 954         pBuf->Data.wDurationID = pBuf->wDuration;
 955         //Get RTS Frame body
 956         pBuf->Data.wFrameControl = TYPE_CTL_RTS;//0x00B4
 957
 958         if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
 959             (pDevice->eOPMode == OP_MODE_AP)) {
 960                 memcpy(&(pBuf->Data.abyRA[0]),
 961                        &(psEthHeader->h_dest[0]),
 962                        ETH_ALEN);
 963         }
 964         else {
 965                 memcpy(&(pBuf->Data.abyRA[0]),
 966                        &(pDevice->abyBSSID[0]),
 967                        ETH_ALEN);
 968         }
 969
 970         if (pDevice->eOPMode == OP_MODE_AP) {
 971                 memcpy(&(pBuf->Data.abyTA[0]),
 972                        &(pDevice->abyBSSID[0]),
 973                        ETH_ALEN);
 974         } else {
 975                 memcpy(&(pBuf->Data.abyTA[0]),
 976                        &(psEthHeader->h_source[0]),
 977                        ETH_ALEN);
 978         }
 979     }
 980 }
 981
 982 static void s_vFillCTSHead(struct vnt_private *pDevice, u32 uDMAIdx,
 983         u8 byPktType, void *pvCTS, u32 cbFrameLength, int bNeedAck,
 984         int bDisCRC, u16 wCurrentRate, u8 byFBOption)
 985 {
 986         u32 uCTSFrameLen = 14;
 987         u16 wLen = 0;
 988
 989     if (pvCTS == NULL) {
 990         return;
 991     }
 992
 993     if (bDisCRC) {
 994         // When CRCDIS bit is on, H/W forgot to generate FCS for CTS frame,
 995         // in this case we need to decrease its length by 4.
 996         uCTSFrameLen -= 4;
 997     }
 998
 999     if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
1000         if (byFBOption != AUTO_FB_NONE && uDMAIdx != TYPE_ATIMDMA && uDMAIdx != TYPE_BEACONDMA) {
1001             // Auto Fall back
1002             PSCTS_FB pBuf = (PSCTS_FB)pvCTS;
1003             //Get SignalField,ServiceField,Length
1004             BBvCalculateParameter(pDevice, uCTSFrameLen, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
1005                 (u16 *)&(wLen), (u8 *)&(pBuf->byServiceField_b), (u8 *)&(pBuf->bySignalField_b)
1006             );
1007             pBuf->wTransmitLength_b = cpu_to_le16(wLen);
1008             pBuf->wDuration_ba = (u16)s_uGetRTSCTSDuration(pDevice, CTSDUR_BA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption); //3:CTSDuration_ba, 1:2.4G, 2,3:2.4G OFDM Data
1009             pBuf->wDuration_ba += pDevice->wCTSDuration;
1010             pBuf->wDuration_ba = cpu_to_le16(pBuf->wDuration_ba);
1011             //Get CTSDuration_ba_f0
1012             pBuf->wCTSDuration_ba_f0 = (u16)s_uGetRTSCTSDuration(pDevice, CTSDUR_BA_F0, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption); //8:CTSDuration_ba_f0, 1:2.4G, 2,3:2.4G OFDM Data
1013             pBuf->wCTSDuration_ba_f0 += pDevice->wCTSDuration;
1014             pBuf->wCTSDuration_ba_f0 = cpu_to_le16(pBuf->wCTSDuration_ba_f0);
1015             //Get CTSDuration_ba_f1
1016             pBuf->wCTSDuration_ba_f1 = (u16)s_uGetRTSCTSDuration(pDevice, CTSDUR_BA_F1, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption); //9:CTSDuration_ba_f1, 1:2.4G, 2,3:2.4G OFDM Data
1017             pBuf->wCTSDuration_ba_f1 += pDevice->wCTSDuration;
1018             pBuf->wCTSDuration_ba_f1 = cpu_to_le16(pBuf->wCTSDuration_ba_f1);
1019             //Get CTS Frame body
1020             pBuf->Data.wDurationID = pBuf->wDuration_ba;
1021             pBuf->Data.wFrameControl = TYPE_CTL_CTS;//0x00C4
1022             pBuf->Data.wReserved = 0x0000;
1023         memcpy(&(pBuf->Data.abyRA[0]),
1024                &(pDevice->abyCurrentNetAddr[0]),
1025                ETH_ALEN);
1026         } else { //if (byFBOption != AUTO_FB_NONE && uDMAIdx != TYPE_ATIMDMA && uDMAIdx != TYPE_BEACONDMA)
1027             PSCTS pBuf = (PSCTS)pvCTS;
1028             //Get SignalField,ServiceField,Length
1029             BBvCalculateParameter(pDevice, uCTSFrameLen, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
1030                 (u16 *)&(wLen), (u8 *)&(pBuf->byServiceField_b), (u8 *)&(pBuf->bySignalField_b)
1031             );
1032             pBuf->wTransmitLength_b = cpu_to_le16(wLen);
1033             //Get CTSDuration_ba
1034             pBuf->wDuration_ba = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, CTSDUR_BA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //3:CTSDuration_ba, 1:2.4G, 2,3:2.4G OFDM Data
1035             pBuf->wDuration_ba += pDevice->wCTSDuration;
1036             pBuf->wDuration_ba = cpu_to_le16(pBuf->wDuration_ba);
1037
1038             //Get CTS Frame body
1039             pBuf->Data.wDurationID = pBuf->wDuration_ba;
1040             pBuf->Data.wFrameControl = TYPE_CTL_CTS;//0x00C4
1041             pBuf->Data.wReserved = 0x0000;
1042         memcpy(&(pBuf->Data.abyRA[0]),
1043                &(pDevice->abyCurrentNetAddr[0]),
1044                ETH_ALEN);
1045         }
1046     }
1047 }
1048
1049 /*+
1050  *
1051  * Description:
1052  *      Generate FIFO control for MAC & Baseband controller
1053  *
1054  * Parameters:
1055  *  In:
1056  *      pDevice         - Pointer to adpater
1057  *      pTxDataHead     - Transmit Data Buffer
1058  *      pTxBufHead      - pTxBufHead
1059  *      pvRrvTime        - pvRrvTime
1060  *      pvRTS            - RTS Buffer
1061  *      pCTS            - CTS Buffer
1062  *      cbFrameSize     - Transmit Data Length (Hdr+Payload+FCS)
1063  *      bNeedACK        - If need ACK
1064  *      uDMAIdx         - DMA Index
1065  *  Out:
1066  *      none
1067  *
1068  * Return Value: none
1069  *
1070 -*/
1071
1072 static void s_vGenerateTxParameter(struct vnt_private *pDevice,
1073         u8 byPktType, u16 wCurrentRate, void *pTxBufHead, void *pvRrvTime,
1074         void *pvRTS, void *pvCTS, u32 cbFrameSize, int bNeedACK, u32 uDMAIdx,
1075         struct ethhdr *psEthHeader)
1076 {
1077         u32 cbMACHdLen = WLAN_HDR_ADDR3_LEN; /* 24 */
1078         u16 wFifoCtl;
1079         int bDisCRC = false;
1080         u8 byFBOption = AUTO_FB_NONE;
1081
1082     //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_vGenerateTxParameter...\n");
1083     PSTxBufHead pFifoHead = (PSTxBufHead)pTxBufHead;
1084     pFifoHead->wReserved = wCurrentRate;
1085     wFifoCtl = pFifoHead->wFIFOCtl;
1086
1087     if (wFifoCtl & FIFOCTL_CRCDIS) {
1088         bDisCRC = true;
1089     }
1090
1091     if (wFifoCtl & FIFOCTL_AUTO_FB_0) {
1092         byFBOption = AUTO_FB_0;
1093     }
1094     else if (wFifoCtl & FIFOCTL_AUTO_FB_1) {
1095         byFBOption = AUTO_FB_1;
1096     }
1097
1098     if (pDevice->bLongHeader)
1099         cbMACHdLen = WLAN_HDR_ADDR3_LEN + 6;
1100
1101     if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
1102
1103         if (pvRTS != NULL) { //RTS_need
1104             //Fill RsvTime
1105             if (pvRrvTime) {
1106                 PSRrvTime_gRTS pBuf = (PSRrvTime_gRTS)pvRrvTime;
1107                 pBuf->wRTSTxRrvTime_aa = cpu_to_le16((u16)s_uGetRTSCTSRsvTime(pDevice, 2, byPktType, cbFrameSize, wCurrentRate));//2:RTSTxRrvTime_aa, 1:2.4GHz
1108                 pBuf->wRTSTxRrvTime_ba = cpu_to_le16((u16)s_uGetRTSCTSRsvTime(pDevice, 1, byPktType, cbFrameSize, wCurrentRate));//1:RTSTxRrvTime_ba, 1:2.4GHz
1109                 pBuf->wRTSTxRrvTime_bb = cpu_to_le16((u16)s_uGetRTSCTSRsvTime(pDevice, 0, byPktType, cbFrameSize, wCurrentRate));//0:RTSTxRrvTime_bb, 1:2.4GHz
1110                 pBuf->wTxRrvTime_a = cpu_to_le16((u16) s_uGetTxRsvTime(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK));//2.4G OFDM
1111                 pBuf->wTxRrvTime_b = cpu_to_le16((u16) s_uGetTxRsvTime(pDevice, PK_TYPE_11B, cbFrameSize, pDevice->byTopCCKBasicRate, bNeedACK));//1:CCK
1112             }
1113             //Fill RTS
1114             s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);
1115         }
1116         else {//RTS_needless, PCF mode
1117
1118             //Fill RsvTime
1119             if (pvRrvTime) {
1120                 PSRrvTime_gCTS pBuf = (PSRrvTime_gCTS)pvRrvTime;
1121                 pBuf->wTxRrvTime_a = cpu_to_le16((u16)s_uGetTxRsvTime(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK));//2.4G OFDM
1122                 pBuf->wTxRrvTime_b = cpu_to_le16((u16)s_uGetTxRsvTime(pDevice, PK_TYPE_11B, cbFrameSize, pDevice->byTopCCKBasicRate, bNeedACK));//1:CCK
1123                 pBuf->wCTSTxRrvTime_ba = cpu_to_le16((u16)s_uGetRTSCTSRsvTime(pDevice, 3, byPktType, cbFrameSize, wCurrentRate));//3:CTSTxRrvTime_Ba, 1:2.4GHz
1124             }
1125             //Fill CTS
1126             s_vFillCTSHead(pDevice, uDMAIdx, byPktType, pvCTS, cbFrameSize, bNeedACK, bDisCRC, wCurrentRate, byFBOption);
1127         }
1128     }
1129     else if (byPktType == PK_TYPE_11A) {
1130
1131         if (pvRTS != NULL) {//RTS_need, non PCF mode
1132             //Fill RsvTime
1133             if (pvRrvTime) {
1134                 PSRrvTime_ab pBuf = (PSRrvTime_ab)pvRrvTime;
1135                 pBuf->wRTSTxRrvTime = cpu_to_le16((u16)s_uGetRTSCTSRsvTime(pDevice, 2, byPktType, cbFrameSize, wCurrentRate));//2:RTSTxRrvTime_aa, 0:5GHz
1136                 pBuf->wTxRrvTime = cpu_to_le16((u16)s_uGetTxRsvTime(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK));//0:OFDM
1137             }
1138             //Fill RTS
1139             s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);
1140         }
1141         else if (pvRTS == NULL) {//RTS_needless, non PCF mode
1142             //Fill RsvTime
1143             if (pvRrvTime) {
1144                 PSRrvTime_ab pBuf = (PSRrvTime_ab)pvRrvTime;
1145                 pBuf->wTxRrvTime = cpu_to_le16((u16)s_uGetTxRsvTime(pDevice, PK_TYPE_11A, cbFrameSize, wCurrentRate, bNeedACK)); //0:OFDM
1146             }
1147         }
1148     }
1149     else if (byPktType == PK_TYPE_11B) {
1150
1151         if ((pvRTS != NULL)) {//RTS_need, non PCF mode
1152             //Fill RsvTime
1153             if (pvRrvTime) {
1154                 PSRrvTime_ab pBuf = (PSRrvTime_ab)pvRrvTime;
1155                 pBuf->wRTSTxRrvTime = cpu_to_le16((u16)s_uGetRTSCTSRsvTime(pDevice, 0, byPktType, cbFrameSize, wCurrentRate));//0:RTSTxRrvTime_bb, 1:2.4GHz
1156                 pBuf->wTxRrvTime = cpu_to_le16((u16)s_uGetTxRsvTime(pDevice, PK_TYPE_11B, cbFrameSize, wCurrentRate, bNeedACK));//1:CCK
1157             }
1158             //Fill RTS
1159             s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);
1160         }
1161         else { //RTS_needless, non PCF mode
1162             //Fill RsvTime
1163             if (pvRrvTime) {
1164                 PSRrvTime_ab pBuf = (PSRrvTime_ab)pvRrvTime;
1165                 pBuf->wTxRrvTime = cpu_to_le16((u16)s_uGetTxRsvTime(pDevice, PK_TYPE_11B, cbFrameSize, wCurrentRate, bNeedACK)); //1:CCK
1166             }
1167         }
1168     }
1169     //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_vGenerateTxParameter END.\n");
1170 }
1171 /*
1172     u8 * pbyBuffer,//point to pTxBufHead
1173     u16  wFragType,//00:Non-Frag, 01:Start, 02:Mid, 03:Last
1174     unsigned int  cbFragmentSize,//Hdr+payoad+FCS
1175 */
1176
1177 static int s_bPacketToWirelessUsb(struct vnt_private *pDevice, u8 byPktType,
1178         u8 *usbPacketBuf, int bNeedEncryption, u32 uSkbPacketLen, u32 uDMAIdx,
1179         struct ethhdr *psEthHeader, u8 *pPacket, PSKeyItem pTransmitKey,
1180         u32 uNodeIndex, u16 wCurrentRate, u32 *pcbHeaderLen, u32 *pcbTotalLen)
1181 {
1182         struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
1183         u32 cbFrameSize, cbFrameBodySize;
1184         PTX_BUFFER pTxBufHead;
1185         u32 cb802_1_H_len;
1186         u32 cbIVlen = 0, cbICVlen = 0, cbMIClen = 0, cbMACHdLen = 0;
1187         u32 cbFCSlen = 4, cbMICHDR = 0;
1188         int bNeedACK, bRTS;
1189         u8 *pbyType, *pbyMacHdr, *pbyIVHead, *pbyPayloadHead, *pbyTxBufferAddr;
1190         u8 abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
1191         u8 abySNAP_Bridgetunnel[ETH_ALEN]
1192                 = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
1193         u32 uDuration;
1194         u32 cbHeaderLength = 0, uPadding = 0;
1195         void *pvRrvTime;
1196         PSMICHDRHead pMICHDR;
1197         void *pvRTS;
1198         void *pvCTS;
1199         void *pvTxDataHd;
1200         u8 byFBOption = AUTO_FB_NONE, byFragType;
1201         u16 wTxBufSize;
1202         u32 dwMICKey0, dwMICKey1, dwMIC_Priority, dwCRC;
1203         u32 *pdwMIC_L, *pdwMIC_R;
1204         int bSoftWEP = false;
1205
1206         pvRrvTime = pMICHDR = pvRTS = pvCTS = pvTxDataHd = NULL;
1207
1208         if (bNeedEncryption && pTransmitKey->pvKeyTable) {
1209                 if (((PSKeyTable)pTransmitKey->pvKeyTable)->bSoftWEP == true)
1210                         bSoftWEP = true; /* WEP 256 */
1211         }
1212
1213     pTxBufHead = (PTX_BUFFER) usbPacketBuf;
1214     memset(pTxBufHead, 0, sizeof(TX_BUFFER));
1215
1216     // Get pkt type
1217     if (ntohs(psEthHeader->h_proto) > ETH_DATA_LEN) {
1218         if (pDevice->dwDiagRefCount == 0) {
1219             cb802_1_H_len = 8;
1220         } else {
1221             cb802_1_H_len = 2;
1222         }
1223     } else {
1224         cb802_1_H_len = 0;
1225     }
1226
1227     cbFrameBodySize = uSkbPacketLen - ETH_HLEN + cb802_1_H_len;
1228
1229     //Set packet type
1230     pTxBufHead->wFIFOCtl |= (u16)(byPktType<<8);
1231
1232     if (pDevice->dwDiagRefCount != 0) {
1233         bNeedACK = false;
1234         pTxBufHead->wFIFOCtl = pTxBufHead->wFIFOCtl & (~FIFOCTL_NEEDACK);
1235     } else { //if (pDevice->dwDiagRefCount != 0) {
1236         if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
1237             (pDevice->eOPMode == OP_MODE_AP)) {
1238                 if (is_multicast_ether_addr(psEthHeader->h_dest)) {
1239                         bNeedACK = false;
1240                         pTxBufHead->wFIFOCtl =
1241                                 pTxBufHead->wFIFOCtl & (~FIFOCTL_NEEDACK);
1242                 } else {
1243                         bNeedACK = true;
1244                         pTxBufHead->wFIFOCtl |= FIFOCTL_NEEDACK;
1245                 }
1246         }
1247         else {
1248             // MSDUs in Infra mode always need ACK
1249             bNeedACK = true;
1250             pTxBufHead->wFIFOCtl |= FIFOCTL_NEEDACK;
1251         }
1252     } //if (pDevice->dwDiagRefCount != 0) {
1253
1254     pTxBufHead->wTimeStamp = DEFAULT_MSDU_LIFETIME_RES_64us;
1255
1256     //Set FIFOCTL_LHEAD
1257     if (pDevice->bLongHeader)
1258         pTxBufHead->wFIFOCtl |= FIFOCTL_LHEAD;
1259
1260     if (pDevice->bSoftwareGenCrcErr) {
1261         pTxBufHead->wFIFOCtl |= FIFOCTL_CRCDIS; // set tx descriptors to NO hardware CRC
1262     }
1263
1264     //Set FRAGCTL_MACHDCNT
1265     if (pDevice->bLongHeader) {
1266         cbMACHdLen = WLAN_HDR_ADDR3_LEN + 6;
1267     } else {
1268         cbMACHdLen = WLAN_HDR_ADDR3_LEN;
1269     }
1270     pTxBufHead->wFragCtl |= (u16)(cbMACHdLen << 10);
1271
1272     //Set FIFOCTL_GrpAckPolicy
1273     if (pDevice->bGrpAckPolicy == true) {//0000 0100 0000 0000
1274         pTxBufHead->wFIFOCtl |= FIFOCTL_GRPACK;
1275     }
1276
1277     //Set Auto Fallback Ctl
1278     if (wCurrentRate >= RATE_18M) {
1279         if (pDevice->byAutoFBCtrl == AUTO_FB_0) {
1280             pTxBufHead->wFIFOCtl |= FIFOCTL_AUTO_FB_0;
1281             byFBOption = AUTO_FB_0;
1282         } else if (pDevice->byAutoFBCtrl == AUTO_FB_1) {
1283             pTxBufHead->wFIFOCtl |= FIFOCTL_AUTO_FB_1;
1284             byFBOption = AUTO_FB_1;
1285         }
1286     }
1287
1288     if (bSoftWEP != true) {
1289         if ((bNeedEncryption) && (pTransmitKey != NULL))  { //WEP enabled
1290             if (pTransmitKey->byCipherSuite == KEY_CTL_WEP) { //WEP40 or WEP104
1291                 pTxBufHead->wFragCtl |= FRAGCTL_LEGACY;
1292             }
1293             if (pTransmitKey->byCipherSuite == KEY_CTL_TKIP) {
1294                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Tx Set wFragCtl == FRAGCTL_TKIP\n");
1295                 pTxBufHead->wFragCtl |= FRAGCTL_TKIP;
1296             }
1297             else if (pTransmitKey->byCipherSuite == KEY_CTL_CCMP) { //CCMP
1298                 pTxBufHead->wFragCtl |= FRAGCTL_AES;
1299             }
1300         }
1301     }
1302
1303     if ((bNeedEncryption) && (pTransmitKey != NULL))  {
1304         if (pTransmitKey->byCipherSuite == KEY_CTL_WEP) {
1305             cbIVlen = 4;
1306             cbICVlen = 4;
1307         }
1308         else if (pTransmitKey->byCipherSuite == KEY_CTL_TKIP) {
1309             cbIVlen = 8;//IV+ExtIV
1310             cbMIClen = 8;
1311             cbICVlen = 4;
1312         }
1313         if (pTransmitKey->byCipherSuite == KEY_CTL_CCMP) {
1314             cbIVlen = 8;//RSN Header
1315             cbICVlen = 8;//MIC
1316             cbMICHDR = sizeof(SMICHDRHead);
1317         }
1318         if (bSoftWEP == false) {
1319             //MAC Header should be padding 0 to DW alignment.
1320             uPadding = 4 - (cbMACHdLen%4);
1321             uPadding %= 4;
1322         }
1323     }
1324
1325     cbFrameSize = cbMACHdLen + cbIVlen + (cbFrameBodySize + cbMIClen) + cbICVlen + cbFCSlen;
1326
1327     if ( (bNeedACK == false) ||(cbFrameSize < pDevice->wRTSThreshold) ) {
1328         bRTS = false;
1329     } else {
1330         bRTS = true;
1331         pTxBufHead->wFIFOCtl |= (FIFOCTL_RTS | FIFOCTL_LRETRY);
1332     }
1333
1334     pbyTxBufferAddr = (u8 *) &(pTxBufHead->adwTxKey[0]);
1335     wTxBufSize = sizeof(STxBufHead);
1336     if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {//802.11g packet
1337         if (byFBOption == AUTO_FB_NONE) {
1338             if (bRTS == true) {//RTS_need
1339                 pvRrvTime = (PSRrvTime_gRTS) (pbyTxBufferAddr + wTxBufSize);
1340                 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS));
1341                 pvRTS = (PSRTS_g) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR);
1342                 pvCTS = NULL;
1343                 pvTxDataHd = (PSTxDataHead_g) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR + sizeof(SRTS_g));
1344                 cbHeaderLength = wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR + sizeof(SRTS_g) + sizeof(STxDataHead_g);
1345             }
1346             else { //RTS_needless
1347                 pvRrvTime = (PSRrvTime_gCTS) (pbyTxBufferAddr + wTxBufSize);
1348                 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS));
1349                 pvRTS = NULL;
1350                 pvCTS = (PSCTS) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR);
1351                 pvTxDataHd = (PSTxDataHead_g) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS));
1352                 cbHeaderLength = wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS) + sizeof(STxDataHead_g);
1353             }
1354         } else {
1355             // Auto Fall Back
1356             if (bRTS == true) {//RTS_need
1357                 pvRrvTime = (PSRrvTime_gRTS) (pbyTxBufferAddr + wTxBufSize);
1358                 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS));
1359                 pvRTS = (PSRTS_g_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR);
1360                 pvCTS = NULL;
1361                 pvTxDataHd = (PSTxDataHead_g_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR + sizeof(SRTS_g_FB));
1362                 cbHeaderLength = wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR + sizeof(SRTS_g_FB) + sizeof(STxDataHead_g_FB);
1363             }
1364             else if (bRTS == false) { //RTS_needless
1365                 pvRrvTime = (PSRrvTime_gCTS) (pbyTxBufferAddr + wTxBufSize);
1366                 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS));
1367                 pvRTS = NULL;
1368                 pvCTS = (PSCTS_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR);
1369                 pvTxDataHd = (PSTxDataHead_g_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS_FB));
1370                 cbHeaderLength = wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS_FB) + sizeof(STxDataHead_g_FB);
1371             }
1372         } // Auto Fall Back
1373     }
1374     else {//802.11a/b packet
1375         if (byFBOption == AUTO_FB_NONE) {
1376             if (bRTS == true) {//RTS_need
1377                 pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
1378                 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
1379                 pvRTS = (PSRTS_ab) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR);
1380                 pvCTS = NULL;
1381                 pvTxDataHd = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR + sizeof(SRTS_ab));
1382                 cbHeaderLength = wTxBufSize + sizeof(PSRrvTime_ab) + cbMICHDR + sizeof(SRTS_ab) + sizeof(STxDataHead_ab);
1383             }
1384             else if (bRTS == false) { //RTS_needless, no MICHDR
1385                 pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
1386                 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
1387                 pvRTS = NULL;
1388                 pvCTS = NULL;
1389                 pvTxDataHd = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR);
1390                 cbHeaderLength = wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR + sizeof(STxDataHead_ab);
1391             }
1392         } else {
1393             // Auto Fall Back
1394             if (bRTS == true) {//RTS_need
1395                 pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
1396                 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
1397                 pvRTS = (PSRTS_a_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR);
1398                 pvCTS = NULL;
1399                 pvTxDataHd = (PSTxDataHead_a_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR + sizeof(SRTS_a_FB));
1400                 cbHeaderLength = wTxBufSize + sizeof(PSRrvTime_ab) + cbMICHDR + sizeof(SRTS_a_FB) + sizeof(STxDataHead_a_FB);
1401             }
1402             else if (bRTS == false) { //RTS_needless
1403                 pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
1404                 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
1405                 pvRTS = NULL;
1406                 pvCTS = NULL;
1407                 pvTxDataHd = (PSTxDataHead_a_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR);
1408                 cbHeaderLength = wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR + sizeof(STxDataHead_a_FB);
1409             }
1410         } // Auto Fall Back
1411     }
1412
1413     pbyMacHdr = (u8 *)(pbyTxBufferAddr + cbHeaderLength);
1414     pbyIVHead = (u8 *)(pbyMacHdr + cbMACHdLen + uPadding);
1415     pbyPayloadHead = (u8 *)(pbyMacHdr + cbMACHdLen + uPadding + cbIVlen);
1416
1417     //=========================
1418     //    No Fragmentation
1419     //=========================
1420     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"No Fragmentation...\n");
1421     byFragType = FRAGCTL_NONFRAG;
1422     //uDMAIdx = TYPE_AC0DMA;
1423     //pTxBufHead = (PSTxBufHead) &(pTxBufHead->adwTxKey[0]);
1424
1425     //Fill FIFO,RrvTime,RTS,and CTS
1426     s_vGenerateTxParameter(pDevice, byPktType, wCurrentRate,
1427                            (void *)pbyTxBufferAddr, pvRrvTime, pvRTS, pvCTS,
1428                                cbFrameSize, bNeedACK, uDMAIdx, psEthHeader);
1429     //Fill DataHead
1430     uDuration = s_uFillDataHead(pDevice, byPktType, wCurrentRate, pvTxDataHd, cbFrameSize, uDMAIdx, bNeedACK,
1431                                     0, 0, 1/*uMACfragNum*/, byFBOption);
1432     // Generate TX MAC Header
1433     s_vGenerateMACHeader(pDevice, pbyMacHdr, (u16)uDuration, psEthHeader, bNeedEncryption,
1434                            byFragType, uDMAIdx, 0);
1435
1436     if (bNeedEncryption == true) {
1437         //Fill TXKEY
1438         s_vFillTxKey(pDevice, (u8 *)(pTxBufHead->adwTxKey), pbyIVHead, pTransmitKey,
1439                          pbyMacHdr, (u16)cbFrameBodySize, (u8 *)pMICHDR);
1440
1441         if (pDevice->bEnableHostWEP) {
1442             pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16 = pTransmitKey->dwTSC47_16;
1443             pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0 = pTransmitKey->wTSC15_0;
1444         }
1445     }
1446
1447     // 802.1H
1448     if (ntohs(psEthHeader->h_proto) > ETH_DATA_LEN) {
1449         if (pDevice->dwDiagRefCount == 0) {
1450                 if ((psEthHeader->h_proto == cpu_to_be16(ETH_P_IPX)) ||
1451                     (psEthHeader->h_proto == cpu_to_le16(0xF380))) {
1452                         memcpy((u8 *) (pbyPayloadHead),
1453                                abySNAP_Bridgetunnel, 6);
1454             } else {
1455                 memcpy((u8 *) (pbyPayloadHead), &abySNAP_RFC1042[0], 6);
1456             }
1457             pbyType = (u8 *) (pbyPayloadHead + 6);
1458             memcpy(pbyType, &(psEthHeader->h_proto), sizeof(u16));
1459         } else {
1460             memcpy((u8 *) (pbyPayloadHead), &(psEthHeader->h_proto), sizeof(u16));
1461
1462         }
1463
1464     }
1465
1466     if (pPacket != NULL) {
1467         // Copy the Packet into a tx Buffer
1468         memcpy((pbyPayloadHead + cb802_1_H_len),
1469                  (pPacket + ETH_HLEN),
1470                  uSkbPacketLen - ETH_HLEN
1471                  );
1472
1473     } else {
1474         // while bRelayPacketSend psEthHeader is point to header+payload
1475         memcpy((pbyPayloadHead + cb802_1_H_len), ((u8 *)psEthHeader) + ETH_HLEN, uSkbPacketLen - ETH_HLEN);
1476     }
1477
1478     ASSERT(uLength == cbNdisBodySize);
1479
1480     if ((bNeedEncryption == true) && (pTransmitKey != NULL) && (pTransmitKey->byCipherSuite == KEY_CTL_TKIP)) {
1481
1482         ///////////////////////////////////////////////////////////////////
1483
1484         if (pDevice->vnt_mgmt.eAuthenMode == WMAC_AUTH_WPANONE) {
1485                 dwMICKey0 = *(u32 *)(&pTransmitKey->abyKey[16]);
1486                 dwMICKey1 = *(u32 *)(&pTransmitKey->abyKey[20]);
1487         }
1488         else if ((pTransmitKey->dwKeyIndex & AUTHENTICATOR_KEY) != 0) {
1489             dwMICKey0 = *(u32 *)(&pTransmitKey->abyKey[16]);
1490             dwMICKey1 = *(u32 *)(&pTransmitKey->abyKey[20]);
1491         }
1492         else {
1493             dwMICKey0 = *(u32 *)(&pTransmitKey->abyKey[24]);
1494             dwMICKey1 = *(u32 *)(&pTransmitKey->abyKey[28]);
1495         }
1496         // DO Software Michael
1497         MIC_vInit(dwMICKey0, dwMICKey1);
1498         MIC_vAppend((u8 *)&(psEthHeader->h_dest[0]), 12);
1499         dwMIC_Priority = 0;
1500         MIC_vAppend((u8 *)&dwMIC_Priority, 4);
1501         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MIC KEY: %X, %X\n",
1502                 dwMICKey0, dwMICKey1);
1503
1504         ///////////////////////////////////////////////////////////////////
1505
1506         //DBG_PRN_GRP12(("Length:%d, %d\n", cbFrameBodySize, uFromHDtoPLDLength));
1507         //for (ii = 0; ii < cbFrameBodySize; ii++) {
1508         //    DBG_PRN_GRP12(("%02x ", *((u8 *)((pbyPayloadHead + cb802_1_H_len) + ii))));
1509         //}
1510         //DBG_PRN_GRP12(("\n\n\n"));
1511
1512         MIC_vAppend(pbyPayloadHead, cbFrameBodySize);
1513
1514         pdwMIC_L = (u32 *)(pbyPayloadHead + cbFrameBodySize);
1515         pdwMIC_R = (u32 *)(pbyPayloadHead + cbFrameBodySize + 4);
1516
1517         MIC_vGetMIC(pdwMIC_L, pdwMIC_R);
1518         MIC_vUnInit();
1519
1520         if (pDevice->bTxMICFail == true) {
1521             *pdwMIC_L = 0;
1522             *pdwMIC_R = 0;
1523             pDevice->bTxMICFail = false;
1524         }
1525         //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"uLength: %d, %d\n", uLength, cbFrameBodySize);
1526         //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"cbReqCount:%d, %d, %d, %d\n", cbReqCount, cbHeaderLength, uPadding, cbIVlen);
1527         //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MIC:%lX, %lX\n", *pdwMIC_L, *pdwMIC_R);
1528     }
1529
1530     if (bSoftWEP == true) {
1531
1532         s_vSWencryption(pDevice, pTransmitKey, (pbyPayloadHead), (u16)(cbFrameBodySize + cbMIClen));
1533
1534     } else if (  ((pDevice->eEncryptionStatus == Ndis802_11Encryption1Enabled) && (bNeedEncryption == true))  ||
1535           ((pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled) && (bNeedEncryption == true))   ||
1536           ((pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled) && (bNeedEncryption == true))      ) {
1537         cbFrameSize -= cbICVlen;
1538     }
1539
1540     if (pDevice->bSoftwareGenCrcErr == true) {
1541         unsigned int cbLen;
1542         u32 * pdwCRC;
1543
1544         dwCRC = 0xFFFFFFFFL;
1545         cbLen = cbFrameSize - cbFCSlen;
1546         // calculate CRC, and wrtie CRC value to end of TD
1547         dwCRC = CRCdwGetCrc32Ex(pbyMacHdr, cbLen, dwCRC);
1548         pdwCRC = (u32 *)(pbyMacHdr + cbLen);
1549         // finally, we must invert dwCRC to get the correct answer
1550         *pdwCRC = ~dwCRC;
1551         // Force Error
1552         *pdwCRC -= 1;
1553     } else {
1554         cbFrameSize -= cbFCSlen;
1555     }
1556
1557     *pcbHeaderLen = cbHeaderLength;
1558     *pcbTotalLen = cbHeaderLength + cbFrameSize ;
1559
1560     //Set FragCtl in TxBufferHead
1561     pTxBufHead->wFragCtl |= (u16)byFragType;
1562
1563     return true;
1564
1565 }
1566
1567 /*+
1568  *
1569  * Description:
1570  *      Translate 802.3 to 802.11 header
1571  *
1572  * Parameters:
1573  *  In:
1574  *      pDevice         - Pointer to adapter
1575  *      dwTxBufferAddr  - Transmit Buffer
1576  *      pPacket         - Packet from upper layer
1577  *      cbPacketSize    - Transmit Data Length
1578  *  Out:
1579  *      pcbHeadSize         - Header size of MAC&Baseband control and 802.11 Header
1580  *      pcbAppendPayload    - size of append payload for 802.1H translation
1581  *
1582  * Return Value: none
1583  *
1584 -*/
1585
1586 static void s_vGenerateMACHeader(struct vnt_private *pDevice,
1587         u8 *pbyBufferAddr, u16 wDuration, struct ethhdr *psEthHeader,
1588         int bNeedEncrypt, u16 wFragType, u32 uDMAIdx, u32 uFragIdx)
1589 {
1590         struct ieee80211_hdr *pMACHeader = (struct ieee80211_hdr *)pbyBufferAddr;
1591
1592     memset(pMACHeader, 0, (sizeof(struct ieee80211_hdr)));
1593
1594     if (uDMAIdx == TYPE_ATIMDMA) {
1595         pMACHeader->frame_control = TYPE_802_11_ATIM;
1596     } else {
1597         pMACHeader->frame_control = TYPE_802_11_DATA;
1598     }
1599
1600     if (pDevice->eOPMode == OP_MODE_AP) {
1601         memcpy(&(pMACHeader->addr1[0]),
1602                &(psEthHeader->h_dest[0]),
1603                ETH_ALEN);
1604         memcpy(&(pMACHeader->addr2[0]), &(pDevice->abyBSSID[0]), ETH_ALEN);
1605         memcpy(&(pMACHeader->addr3[0]),
1606                &(psEthHeader->h_source[0]),
1607                ETH_ALEN);
1608         pMACHeader->frame_control |= FC_FROMDS;
1609     } else {
1610         if (pDevice->eOPMode == OP_MODE_ADHOC) {
1611                 memcpy(&(pMACHeader->addr1[0]),
1612                        &(psEthHeader->h_dest[0]),
1613                        ETH_ALEN);
1614                 memcpy(&(pMACHeader->addr2[0]),
1615                        &(psEthHeader->h_source[0]),
1616                        ETH_ALEN);
1617                 memcpy(&(pMACHeader->addr3[0]),
1618                        &(pDevice->abyBSSID[0]),
1619                        ETH_ALEN);
1620         } else {
1621                 memcpy(&(pMACHeader->addr3[0]),
1622                        &(psEthHeader->h_dest[0]),
1623                        ETH_ALEN);
1624                 memcpy(&(pMACHeader->addr2[0]),
1625                        &(psEthHeader->h_source[0]),
1626                        ETH_ALEN);
1627                 memcpy(&(pMACHeader->addr1[0]),
1628                        &(pDevice->abyBSSID[0]),
1629                        ETH_ALEN);
1630             pMACHeader->frame_control |= FC_TODS;
1631         }
1632     }
1633
1634     if (bNeedEncrypt)
1635         pMACHeader->frame_control |= cpu_to_le16((u16)WLAN_SET_FC_ISWEP(1));
1636
1637     pMACHeader->duration_id = cpu_to_le16(wDuration);
1638
1639     if (pDevice->bLongHeader) {
1640         PWLAN_80211HDR_A4 pMACA4Header  = (PWLAN_80211HDR_A4) pbyBufferAddr;
1641         pMACHeader->frame_control |= (FC_TODS | FC_FROMDS);
1642         memcpy(pMACA4Header->abyAddr4, pDevice->abyBSSID, WLAN_ADDR_LEN);
1643     }
1644     pMACHeader->seq_ctrl = cpu_to_le16(pDevice->wSeqCounter << 4);
1645
1646     //Set FragNumber in Sequence Control
1647     pMACHeader->seq_ctrl |= cpu_to_le16((u16)uFragIdx);
1648
1649     if ((wFragType == FRAGCTL_ENDFRAG) || (wFragType == FRAGCTL_NONFRAG)) {
1650         pDevice->wSeqCounter++;
1651         if (pDevice->wSeqCounter > 0x0fff)
1652             pDevice->wSeqCounter = 0;
1653     }
1654
1655     if ((wFragType == FRAGCTL_STAFRAG) || (wFragType == FRAGCTL_MIDFRAG)) { //StartFrag or MidFrag
1656         pMACHeader->frame_control |= FC_MOREFRAG;
1657     }
1658 }
1659
1660 /*+
1661  *
1662  * Description:
1663  *      Request instructs a MAC to transmit a 802.11 management packet through
1664  *      the adapter onto the medium.
1665  *
1666  * Parameters:
1667  *  In:
1668  *      hDeviceContext  - Pointer to the adapter
1669  *      pPacket         - A pointer to a descriptor for the packet to transmit
1670  *  Out:
1671  *      none
1672  *
1673  * Return Value: CMD_STATUS_PENDING if MAC Tx resource available; otherwise false
1674  *
1675 -*/
1676
1677 CMD_STATUS csMgmt_xmit(struct vnt_private *pDevice,
1678         struct vnt_tx_mgmt *pPacket)
1679 {
1680         struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
1681         PTX_BUFFER pTX_Buffer;
1682         PSTxBufHead pTxBufHead;
1683         PUSB_SEND_CONTEXT pContext;
1684         struct ieee80211_hdr *pMACHeader;
1685         PSCTS pCTS;
1686         struct ethhdr sEthHeader;
1687         u8 byPktType, *pbyTxBufferAddr;
1688         void *pvRTS, *pvTxDataHd, *pvRrvTime, *pMICHDR;
1689         u32 uDuration, cbReqCount, cbHeaderSize, cbFrameBodySize, cbFrameSize;
1690         int bNeedACK, bIsPSPOLL = false;
1691         u32 cbIVlen = 0, cbICVlen = 0, cbMIClen = 0, cbFCSlen = 4;
1692         u32 uPadding = 0;
1693         u16 wTxBufSize;
1694         u32 cbMacHdLen;
1695         u16 wCurrentRate = RATE_1M;
1696
1697     pContext = (PUSB_SEND_CONTEXT)s_vGetFreeContext(pDevice);
1698
1699     if (NULL == pContext) {
1700         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ManagementSend TX...NO CONTEXT!\n");
1701         return CMD_STATUS_RESOURCES;
1702     }
1703
1704     pTX_Buffer = (PTX_BUFFER) (&pContext->Data[0]);
1705     pbyTxBufferAddr = (u8 *)&(pTX_Buffer->adwTxKey[0]);
1706     cbFrameBodySize = pPacket->cbPayloadLen;
1707     pTxBufHead = (PSTxBufHead) pbyTxBufferAddr;
1708     wTxBufSize = sizeof(STxBufHead);
1709     memset(pTxBufHead, 0, wTxBufSize);
1710
1711     if (pDevice->byBBType == BB_TYPE_11A) {
1712         wCurrentRate = RATE_6M;
1713         byPktType = PK_TYPE_11A;
1714     } else {
1715         wCurrentRate = RATE_1M;
1716         byPktType = PK_TYPE_11B;
1717     }
1718
1719     // SetPower will cause error power TX state for OFDM Date packet in TX buffer.
1720     // 2004.11.11 Kyle -- Using OFDM power to tx MngPkt will decrease the connection capability.
1721     //                    And cmd timer will wait data pkt TX finish before scanning so it's OK
1722     //                    to set power here.
1723     if (pMgmt->eScanState != WMAC_NO_SCANNING) {
1724         RFbSetPower(pDevice, wCurrentRate, pDevice->byCurrentCh);
1725     } else {
1726         RFbSetPower(pDevice, wCurrentRate, pMgmt->uCurrChannel);
1727     }
1728     pDevice->wCurrentRate = wCurrentRate;
1729
1730     //Set packet type
1731     if (byPktType == PK_TYPE_11A) {//0000 0000 0000 0000
1732         pTxBufHead->wFIFOCtl = 0;
1733     }
1734     else if (byPktType == PK_TYPE_11B) {//0000 0001 0000 0000
1735         pTxBufHead->wFIFOCtl |= FIFOCTL_11B;
1736     }
1737     else if (byPktType == PK_TYPE_11GB) {//0000 0010 0000 0000
1738         pTxBufHead->wFIFOCtl |= FIFOCTL_11GB;
1739     }
1740     else if (byPktType == PK_TYPE_11GA) {//0000 0011 0000 0000
1741         pTxBufHead->wFIFOCtl |= FIFOCTL_11GA;
1742     }
1743
1744     pTxBufHead->wFIFOCtl |= FIFOCTL_TMOEN;
1745     pTxBufHead->wTimeStamp = cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us);
1746
1747     if (is_multicast_ether_addr(pPacket->p80211Header->sA3.abyAddr1)) {
1748         bNeedACK = false;
1749     }
1750     else {
1751         bNeedACK = true;
1752         pTxBufHead->wFIFOCtl |= FIFOCTL_NEEDACK;
1753     };
1754
1755     if ((pMgmt->eCurrMode == WMAC_MODE_ESS_AP) ||
1756         (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) ) {
1757
1758         pTxBufHead->wFIFOCtl |= FIFOCTL_LRETRY;
1759         //Set Preamble type always long
1760         //pDevice->byPreambleType = PREAMBLE_LONG;
1761         // probe-response don't retry
1762         //if ((pPacket->p80211Header->sA4.wFrameCtl & TYPE_SUBTYPE_MASK) == TYPE_MGMT_PROBE_RSP) {
1763         //     bNeedACK = false;
1764         //     pTxBufHead->wFIFOCtl  &= (~FIFOCTL_NEEDACK);
1765         //}
1766     }
1767
1768     pTxBufHead->wFIFOCtl |= (FIFOCTL_GENINT | FIFOCTL_ISDMA0);
1769
1770     if ((pPacket->p80211Header->sA4.wFrameCtl & TYPE_SUBTYPE_MASK) == TYPE_CTL_PSPOLL) {
1771         bIsPSPOLL = true;
1772         cbMacHdLen = WLAN_HDR_ADDR2_LEN;
1773     } else {
1774         cbMacHdLen = WLAN_HDR_ADDR3_LEN;
1775     }
1776
1777     //Set FRAGCTL_MACHDCNT
1778     pTxBufHead->wFragCtl |= cpu_to_le16((u16)(cbMacHdLen << 10));
1779
1780     // Notes:
1781     // Although spec says MMPDU can be fragmented; In most case,
1782     // no one will send a MMPDU under fragmentation. With RTS may occur.
1783     pDevice->bAES = false;  //Set FRAGCTL_WEPTYP
1784
1785     if (WLAN_GET_FC_ISWEP(pPacket->p80211Header->sA4.wFrameCtl) != 0) {
1786         if (pDevice->eEncryptionStatus == Ndis802_11Encryption1Enabled) {
1787             cbIVlen = 4;
1788             cbICVlen = 4;
1789             pTxBufHead->wFragCtl |= FRAGCTL_LEGACY;
1790         }
1791         else if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled) {
1792             cbIVlen = 8;//IV+ExtIV
1793             cbMIClen = 8;
1794             cbICVlen = 4;
1795             pTxBufHead->wFragCtl |= FRAGCTL_TKIP;
1796             //We need to get seed here for filling TxKey entry.
1797             //TKIPvMixKey(pTransmitKey->abyKey, pDevice->abyCurrentNetAddr,
1798             //            pTransmitKey->wTSC15_0, pTransmitKey->dwTSC47_16, pDevice->abyPRNG);
1799         }
1800         else if (pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled) {
1801             cbIVlen = 8;//RSN Header
1802             cbICVlen = 8;//MIC
1803             pTxBufHead->wFragCtl |= FRAGCTL_AES;
1804             pDevice->bAES = true;
1805         }
1806         //MAC Header should be padding 0 to DW alignment.
1807         uPadding = 4 - (cbMacHdLen%4);
1808         uPadding %= 4;
1809     }
1810
1811     cbFrameSize = cbMacHdLen + cbFrameBodySize + cbIVlen + cbMIClen + cbICVlen + cbFCSlen;
1812
1813     //Set FIFOCTL_GrpAckPolicy
1814     if (pDevice->bGrpAckPolicy == true) {//0000 0100 0000 0000
1815         pTxBufHead->wFIFOCtl |= FIFOCTL_GRPACK;
1816     }
1817     //the rest of pTxBufHead->wFragCtl:FragTyp will be set later in s_vFillFragParameter()
1818
1819     //Set RrvTime/RTS/CTS Buffer
1820     if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {//802.11g packet
1821
1822         pvRrvTime = (PSRrvTime_gCTS) (pbyTxBufferAddr + wTxBufSize);
1823         pMICHDR = NULL;
1824         pvRTS = NULL;
1825         pCTS = (PSCTS) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS));
1826         pvTxDataHd = (PSTxDataHead_g) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + sizeof(SCTS));
1827         cbHeaderSize = wTxBufSize + sizeof(SRrvTime_gCTS) + sizeof(SCTS) + sizeof(STxDataHead_g);
1828     }
1829     else { // 802.11a/b packet
1830         pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
1831         pMICHDR = NULL;
1832         pvRTS = NULL;
1833         pCTS = NULL;
1834         pvTxDataHd = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
1835         cbHeaderSize = wTxBufSize + sizeof(SRrvTime_ab) + sizeof(STxDataHead_ab);
1836     }
1837
1838     memset((void *)(pbyTxBufferAddr + wTxBufSize), 0,
1839            (cbHeaderSize - wTxBufSize));
1840
1841     memcpy(&(sEthHeader.h_dest[0]),
1842            &(pPacket->p80211Header->sA3.abyAddr1[0]),
1843            ETH_ALEN);
1844     memcpy(&(sEthHeader.h_source[0]),
1845            &(pPacket->p80211Header->sA3.abyAddr2[0]),
1846            ETH_ALEN);
1847     //=========================
1848     //    No Fragmentation
1849     //=========================
1850     pTxBufHead->wFragCtl |= (u16)FRAGCTL_NONFRAG;
1851
1852     //Fill FIFO,RrvTime,RTS,and CTS
1853     s_vGenerateTxParameter(pDevice, byPktType, wCurrentRate,  pbyTxBufferAddr, pvRrvTime, pvRTS, pCTS,
1854                            cbFrameSize, bNeedACK, TYPE_TXDMA0, &sEthHeader);
1855
1856     //Fill DataHead
1857     uDuration = s_uFillDataHead(pDevice, byPktType, wCurrentRate, pvTxDataHd, cbFrameSize, TYPE_TXDMA0, bNeedACK,
1858                                 0, 0, 1, AUTO_FB_NONE);
1859
1860     pMACHeader = (struct ieee80211_hdr *) (pbyTxBufferAddr + cbHeaderSize);
1861
1862     cbReqCount = cbHeaderSize + cbMacHdLen + uPadding + cbIVlen + cbFrameBodySize;
1863
1864     if (WLAN_GET_FC_ISWEP(pPacket->p80211Header->sA4.wFrameCtl) != 0) {
1865         u8 *           pbyIVHead;
1866         u8 *           pbyPayloadHead;
1867         u8 *           pbyBSSID;
1868         PSKeyItem       pTransmitKey = NULL;
1869
1870         pbyIVHead = (u8 *)(pbyTxBufferAddr + cbHeaderSize + cbMacHdLen + uPadding);
1871         pbyPayloadHead = (u8 *)(pbyTxBufferAddr + cbHeaderSize + cbMacHdLen + uPadding + cbIVlen);
1872         do {
1873             if ((pDevice->eOPMode == OP_MODE_INFRASTRUCTURE) &&
1874                 (pDevice->bLinkPass == true)) {
1875                 pbyBSSID = pDevice->abyBSSID;
1876                 // get pairwise key
1877                 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == false) {
1878                     // get group key
1879                     if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == true) {
1880                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Get GTK.\n");
1881                         break;
1882                     }
1883                 } else {
1884                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Get PTK.\n");
1885                     break;
1886                 }
1887             }
1888             // get group key
1889             pbyBSSID = pDevice->abyBroadcastAddr;
1890             if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == false) {
1891                 pTransmitKey = NULL;
1892                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"KEY is NULL. OP Mode[%d]\n", pDevice->eOPMode);
1893             } else {
1894                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Get GTK.\n");
1895             }
1896         } while(false);
1897         //Fill TXKEY
1898         s_vFillTxKey(pDevice, (u8 *)(pTxBufHead->adwTxKey), pbyIVHead, pTransmitKey,
1899                      (u8 *)pMACHeader, (u16)cbFrameBodySize, NULL);
1900
1901         memcpy(pMACHeader, pPacket->p80211Header, cbMacHdLen);
1902         memcpy(pbyPayloadHead, ((u8 *)(pPacket->p80211Header) + cbMacHdLen),
1903                  cbFrameBodySize);
1904     }
1905     else {
1906         // Copy the Packet into a tx Buffer
1907         memcpy(pMACHeader, pPacket->p80211Header, pPacket->cbMPDULen);
1908     }
1909
1910     pMACHeader->seq_ctrl = cpu_to_le16(pDevice->wSeqCounter << 4);
1911     pDevice->wSeqCounter++ ;
1912     if (pDevice->wSeqCounter > 0x0fff)
1913         pDevice->wSeqCounter = 0;
1914
1915     if (bIsPSPOLL) {
1916         // The MAC will automatically replace the Duration-field of MAC header by Duration-field
1917         // of FIFO control header.
1918         // This will cause AID-field of PS-POLL packet be incorrect (Because PS-POLL's AID field is
1919         // in the same place of other packet's Duration-field).
1920         // And it will cause Cisco-AP to issue Disassociation-packet
1921         if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
1922             ((PSTxDataHead_g)pvTxDataHd)->wDuration_a = cpu_to_le16(pPacket->p80211Header->sA2.wDurationID);
1923             ((PSTxDataHead_g)pvTxDataHd)->wDuration_b = cpu_to_le16(pPacket->p80211Header->sA2.wDurationID);
1924         } else {
1925             ((PSTxDataHead_ab)pvTxDataHd)->wDuration = cpu_to_le16(pPacket->p80211Header->sA2.wDurationID);
1926         }
1927     }
1928
1929     pTX_Buffer->wTxByteCount = cpu_to_le16((u16)(cbReqCount));
1930     pTX_Buffer->byPKTNO = (u8) (((wCurrentRate<<4) &0x00F0) | ((pDevice->wSeqCounter - 1) & 0x000F));
1931     pTX_Buffer->byType = 0x00;
1932
1933     pContext->pPacket = NULL;
1934     pContext->Type = CONTEXT_MGMT_PACKET;
1935     pContext->uBufLen = (u16)cbReqCount + 4;  //USB header
1936
1937     if (WLAN_GET_FC_TODS(pMACHeader->frame_control) == 0) {
1938         s_vSaveTxPktInfo(pDevice, (u8) (pTX_Buffer->byPKTNO & 0x0F), &(pMACHeader->addr1[0]), (u16)cbFrameSize, pTX_Buffer->wFIFOCtl);
1939     }
1940     else {
1941         s_vSaveTxPktInfo(pDevice, (u8) (pTX_Buffer->byPKTNO & 0x0F), &(pMACHeader->addr3[0]), (u16)cbFrameSize, pTX_Buffer->wFIFOCtl);
1942     }
1943
1944     PIPEnsSendBulkOut(pDevice,pContext);
1945     return CMD_STATUS_PENDING;
1946 }
1947
1948 CMD_STATUS csBeacon_xmit(struct vnt_private *pDevice,
1949         struct vnt_tx_mgmt *pPacket)
1950 {
1951         u32 cbFrameSize = pPacket->cbMPDULen + WLAN_FCS_LEN;
1952         u32 cbHeaderSize = 0;
1953         u16 wTxBufSize = sizeof(STxShortBufHead);
1954         PSTxShortBufHead pTxBufHead;
1955         struct ieee80211_hdr *pMACHeader;
1956         PSTxDataHead_ab pTxDataHead;
1957         u16 wCurrentRate;
1958         u32 cbFrameBodySize;
1959         u32 cbReqCount;
1960         PBEACON_BUFFER pTX_Buffer;
1961         u8 *pbyTxBufferAddr;
1962         PUSB_SEND_CONTEXT pContext;
1963         CMD_STATUS status;
1964
1965     pContext = (PUSB_SEND_CONTEXT)s_vGetFreeContext(pDevice);
1966     if (NULL == pContext) {
1967         status = CMD_STATUS_RESOURCES;
1968         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ManagementSend TX...NO CONTEXT!\n");
1969         return status ;
1970     }
1971     pTX_Buffer = (PBEACON_BUFFER) (&pContext->Data[0]);
1972     pbyTxBufferAddr = (u8 *)&(pTX_Buffer->wFIFOCtl);
1973
1974     cbFrameBodySize = pPacket->cbPayloadLen;
1975
1976     pTxBufHead = (PSTxShortBufHead) pbyTxBufferAddr;
1977     wTxBufSize = sizeof(STxShortBufHead);
1978     memset(pTxBufHead, 0, wTxBufSize);
1979
1980     if (pDevice->byBBType == BB_TYPE_11A) {
1981         wCurrentRate = RATE_6M;
1982         pTxDataHead = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize);
1983         //Get SignalField,ServiceField,Length
1984         BBvCalculateParameter(pDevice, cbFrameSize, wCurrentRate, PK_TYPE_11A,
1985             (u16 *)&(pTxDataHead->wTransmitLength), (u8 *)&(pTxDataHead->byServiceField), (u8 *)&(pTxDataHead->bySignalField)
1986         );
1987         //Get Duration and TimeStampOff
1988         pTxDataHead->wDuration = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameSize, PK_TYPE_11A,
1989                                                           wCurrentRate, false, 0, 0, 1, AUTO_FB_NONE));
1990         pTxDataHead->wTimeStampOff = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
1991         cbHeaderSize = wTxBufSize + sizeof(STxDataHead_ab);
1992     } else {
1993         wCurrentRate = RATE_1M;
1994         pTxBufHead->wFIFOCtl |= FIFOCTL_11B;
1995         pTxDataHead = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize);
1996         //Get SignalField,ServiceField,Length
1997         BBvCalculateParameter(pDevice, cbFrameSize, wCurrentRate, PK_TYPE_11B,
1998             (u16 *)&(pTxDataHead->wTransmitLength), (u8 *)&(pTxDataHead->byServiceField), (u8 *)&(pTxDataHead->bySignalField)
1999         );
2000         //Get Duration and TimeStampOff
2001         pTxDataHead->wDuration = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameSize, PK_TYPE_11B,
2002                                                           wCurrentRate, false, 0, 0, 1, AUTO_FB_NONE));
2003         pTxDataHead->wTimeStampOff = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
2004         cbHeaderSize = wTxBufSize + sizeof(STxDataHead_ab);
2005     }
2006
2007     //Generate Beacon Header
2008     pMACHeader = (struct ieee80211_hdr *)(pbyTxBufferAddr + cbHeaderSize);
2009     memcpy(pMACHeader, pPacket->p80211Header, pPacket->cbMPDULen);
2010
2011     pMACHeader->duration_id = 0;
2012     pMACHeader->seq_ctrl = cpu_to_le16(pDevice->wSeqCounter << 4);
2013     pDevice->wSeqCounter++ ;
2014     if (pDevice->wSeqCounter > 0x0fff)
2015         pDevice->wSeqCounter = 0;
2016
2017     cbReqCount = cbHeaderSize + WLAN_HDR_ADDR3_LEN + cbFrameBodySize;
2018
2019     pTX_Buffer->wTxByteCount = (u16)cbReqCount;
2020     pTX_Buffer->byPKTNO = (u8) (((wCurrentRate<<4) &0x00F0) | ((pDevice->wSeqCounter - 1) & 0x000F));
2021     pTX_Buffer->byType = 0x01;
2022
2023     pContext->pPacket = NULL;
2024     pContext->Type = CONTEXT_MGMT_PACKET;
2025     pContext->uBufLen = (u16)cbReqCount + 4;  //USB header
2026
2027     PIPEnsSendBulkOut(pDevice,pContext);
2028     return CMD_STATUS_PENDING;
2029
2030 }
2031
2032 void vDMA0_tx_80211(struct vnt_private *pDevice, struct sk_buff *skb)
2033 {
2034         struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
2035         u8 byPktType;
2036         u8 *pbyTxBufferAddr;
2037         void *pvRTS, *pvCTS, *pvTxDataHd;
2038         u32 uDuration, cbReqCount;
2039         struct ieee80211_hdr *pMACHeader;
2040         u32 cbHeaderSize, cbFrameBodySize;
2041         int bNeedACK, bIsPSPOLL = false;
2042         PSTxBufHead pTxBufHead;
2043         u32 cbFrameSize;
2044         u32 cbIVlen = 0, cbICVlen = 0, cbMIClen = 0, cbFCSlen = 4;
2045         u32 uPadding = 0;
2046         u32 cbMICHDR = 0, uLength = 0;
2047         u32 dwMICKey0, dwMICKey1;
2048         u32 dwMIC_Priority;
2049         u32 *pdwMIC_L, *pdwMIC_R;
2050         u16 wTxBufSize;
2051         u32 cbMacHdLen;
2052         struct ethhdr sEthHeader;
2053         void *pvRrvTime, *pMICHDR;
2054         u32 wCurrentRate = RATE_1M;
2055         PUWLAN_80211HDR  p80211Header;
2056         u32 uNodeIndex = 0;
2057         int bNodeExist = false;
2058         SKeyItem STempKey;
2059         PSKeyItem pTransmitKey = NULL;
2060         u8 *pbyIVHead, *pbyPayloadHead, *pbyMacHdr;
2061         u32 cbExtSuppRate = 0;
2062         PTX_BUFFER pTX_Buffer;
2063         PUSB_SEND_CONTEXT pContext;
2064
2065     pvRrvTime = pMICHDR = pvRTS = pvCTS = pvTxDataHd = NULL;
2066
2067     if(skb->len <= WLAN_HDR_ADDR3_LEN) {
2068        cbFrameBodySize = 0;
2069     }
2070     else {
2071        cbFrameBodySize = skb->len - WLAN_HDR_ADDR3_LEN;
2072     }
2073     p80211Header = (PUWLAN_80211HDR)skb->data;
2074
2075     pContext = (PUSB_SEND_CONTEXT)s_vGetFreeContext(pDevice);
2076
2077     if (NULL == pContext) {
2078         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"DMA0 TX...NO CONTEXT!\n");
2079         dev_kfree_skb_irq(skb);
2080         return ;
2081     }
2082
2083     pTX_Buffer = (PTX_BUFFER)(&pContext->Data[0]);
2084     pbyTxBufferAddr = (u8 *)(&pTX_Buffer->adwTxKey[0]);
2085     pTxBufHead = (PSTxBufHead) pbyTxBufferAddr;
2086     wTxBufSize = sizeof(STxBufHead);
2087     memset(pTxBufHead, 0, wTxBufSize);
2088
2089     if (pDevice->byBBType == BB_TYPE_11A) {
2090         wCurrentRate = RATE_6M;
2091         byPktType = PK_TYPE_11A;
2092     } else {
2093         wCurrentRate = RATE_1M;
2094         byPktType = PK_TYPE_11B;
2095     }
2096
2097     // SetPower will cause error power TX state for OFDM Date packet in TX buffer.
2098     // 2004.11.11 Kyle -- Using OFDM power to tx MngPkt will decrease the connection capability.
2099     //                    And cmd timer will wait data pkt TX finish before scanning so it's OK
2100     //                    to set power here.
2101     if (pMgmt->eScanState != WMAC_NO_SCANNING) {
2102         RFbSetPower(pDevice, wCurrentRate, pDevice->byCurrentCh);
2103     } else {
2104         RFbSetPower(pDevice, wCurrentRate, pMgmt->uCurrChannel);
2105     }
2106
2107     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"vDMA0_tx_80211: p80211Header->sA3.wFrameCtl = %x \n", p80211Header->sA3.wFrameCtl);
2108
2109     //Set packet type
2110     if (byPktType == PK_TYPE_11A) {//0000 0000 0000 0000
2111         pTxBufHead->wFIFOCtl = 0;
2112     }
2113     else if (byPktType == PK_TYPE_11B) {//0000 0001 0000 0000
2114         pTxBufHead->wFIFOCtl |= FIFOCTL_11B;
2115     }
2116     else if (byPktType == PK_TYPE_11GB) {//0000 0010 0000 0000
2117         pTxBufHead->wFIFOCtl |= FIFOCTL_11GB;
2118     }
2119     else if (byPktType == PK_TYPE_11GA) {//0000 0011 0000 0000
2120         pTxBufHead->wFIFOCtl |= FIFOCTL_11GA;
2121     }
2122
2123     pTxBufHead->wFIFOCtl |= FIFOCTL_TMOEN;
2124     pTxBufHead->wTimeStamp = cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us);
2125
2126     if (is_multicast_ether_addr(p80211Header->sA3.abyAddr1)) {
2127         bNeedACK = false;
2128         if (pDevice->bEnableHostWEP) {
2129             uNodeIndex = 0;
2130             bNodeExist = true;
2131         }
2132     }
2133     else {
2134         if (pDevice->bEnableHostWEP) {
2135             if (BSSbIsSTAInNodeDB(pDevice, (u8 *)(p80211Header->sA3.abyAddr1), &uNodeIndex))
2136                 bNodeExist = true;
2137         }
2138         bNeedACK = true;
2139         pTxBufHead->wFIFOCtl |= FIFOCTL_NEEDACK;
2140     };
2141
2142     if ((pMgmt->eCurrMode == WMAC_MODE_ESS_AP) ||
2143         (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) ) {
2144
2145         pTxBufHead->wFIFOCtl |= FIFOCTL_LRETRY;
2146         //Set Preamble type always long
2147         //pDevice->byPreambleType = PREAMBLE_LONG;
2148
2149         // probe-response don't retry
2150         //if ((p80211Header->sA4.wFrameCtl & TYPE_SUBTYPE_MASK) == TYPE_MGMT_PROBE_RSP) {
2151         //     bNeedACK = false;
2152         //     pTxBufHead->wFIFOCtl  &= (~FIFOCTL_NEEDACK);
2153         //}
2154     }
2155
2156     pTxBufHead->wFIFOCtl |= (FIFOCTL_GENINT | FIFOCTL_ISDMA0);
2157
2158     if ((p80211Header->sA4.wFrameCtl & TYPE_SUBTYPE_MASK) == TYPE_CTL_PSPOLL) {
2159         bIsPSPOLL = true;
2160         cbMacHdLen = WLAN_HDR_ADDR2_LEN;
2161     } else {
2162         cbMacHdLen = WLAN_HDR_ADDR3_LEN;
2163     }
2164
2165     // hostapd daemon ext support rate patch
2166     if (WLAN_GET_FC_FSTYPE(p80211Header->sA4.wFrameCtl) == WLAN_FSTYPE_ASSOCRESP) {
2167
2168         if (((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates)->len != 0) {
2169             cbExtSuppRate += ((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates)->len + WLAN_IEHDR_LEN;
2170          }
2171
2172         if (((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates)->len != 0) {
2173             cbExtSuppRate += ((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates)->len + WLAN_IEHDR_LEN;
2174          }
2175
2176          if (cbExtSuppRate >0) {
2177             cbFrameBodySize = WLAN_ASSOCRESP_OFF_SUPP_RATES;
2178          }
2179     }
2180
2181     //Set FRAGCTL_MACHDCNT
2182     pTxBufHead->wFragCtl |= cpu_to_le16((u16)cbMacHdLen << 10);
2183
2184     // Notes:
2185     // Although spec says MMPDU can be fragmented; In most case,
2186     // no one will send a MMPDU under fragmentation. With RTS may occur.
2187     pDevice->bAES = false;  //Set FRAGCTL_WEPTYP
2188
2189     if (WLAN_GET_FC_ISWEP(p80211Header->sA4.wFrameCtl) != 0) {
2190         if (pDevice->eEncryptionStatus == Ndis802_11Encryption1Enabled) {
2191             cbIVlen = 4;
2192             cbICVlen = 4;
2193             pTxBufHead->wFragCtl |= FRAGCTL_LEGACY;
2194         }
2195         else if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled) {
2196             cbIVlen = 8;//IV+ExtIV
2197             cbMIClen = 8;
2198             cbICVlen = 4;
2199             pTxBufHead->wFragCtl |= FRAGCTL_TKIP;
2200             //We need to get seed here for filling TxKey entry.
2201             //TKIPvMixKey(pTransmitKey->abyKey, pDevice->abyCurrentNetAddr,
2202             //            pTransmitKey->wTSC15_0, pTransmitKey->dwTSC47_16, pDevice->abyPRNG);
2203         }
2204         else if (pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled) {
2205             cbIVlen = 8;//RSN Header
2206             cbICVlen = 8;//MIC
2207             cbMICHDR = sizeof(SMICHDRHead);
2208             pTxBufHead->wFragCtl |= FRAGCTL_AES;
2209             pDevice->bAES = true;
2210         }
2211         //MAC Header should be padding 0 to DW alignment.
2212         uPadding = 4 - (cbMacHdLen%4);
2213         uPadding %= 4;
2214     }
2215
2216     cbFrameSize = cbMacHdLen + cbFrameBodySize + cbIVlen + cbMIClen + cbICVlen + cbFCSlen + cbExtSuppRate;
2217
2218     //Set FIFOCTL_GrpAckPolicy
2219     if (pDevice->bGrpAckPolicy == true) {//0000 0100 0000 0000
2220         pTxBufHead->wFIFOCtl |= FIFOCTL_GRPACK;
2221     }
2222     //the rest of pTxBufHead->wFragCtl:FragTyp will be set later in s_vFillFragParameter()
2223
2224     if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {//802.11g packet
2225
2226         pvRrvTime = (PSRrvTime_gCTS) (pbyTxBufferAddr + wTxBufSize);
2227         pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS));
2228         pvRTS = NULL;
2229         pvCTS = (PSCTS) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR);
2230         pvTxDataHd = (PSTxDataHead_g) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS));
2231         cbHeaderSize = wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS) + sizeof(STxDataHead_g);
2232
2233     }
2234     else {//802.11a/b packet
2235
2236         pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
2237         pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
2238         pvRTS = NULL;
2239         pvCTS = NULL;
2240         pvTxDataHd = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR);
2241         cbHeaderSize = wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR + sizeof(STxDataHead_ab);
2242     }
2243     memset((void *)(pbyTxBufferAddr + wTxBufSize), 0,
2244            (cbHeaderSize - wTxBufSize));
2245     memcpy(&(sEthHeader.h_dest[0]),
2246            &(p80211Header->sA3.abyAddr1[0]),
2247            ETH_ALEN);
2248     memcpy(&(sEthHeader.h_source[0]),
2249            &(p80211Header->sA3.abyAddr2[0]),
2250            ETH_ALEN);
2251     //=========================
2252     //    No Fragmentation
2253     //=========================
2254     pTxBufHead->wFragCtl |= (u16)FRAGCTL_NONFRAG;
2255
2256     //Fill FIFO,RrvTime,RTS,and CTS
2257     s_vGenerateTxParameter(pDevice, byPktType, wCurrentRate, pbyTxBufferAddr, pvRrvTime, pvRTS, pvCTS,
2258                            cbFrameSize, bNeedACK, TYPE_TXDMA0, &sEthHeader);
2259
2260     //Fill DataHead
2261     uDuration = s_uFillDataHead(pDevice, byPktType, wCurrentRate, pvTxDataHd, cbFrameSize, TYPE_TXDMA0, bNeedACK,
2262                                 0, 0, 1, AUTO_FB_NONE);
2263
2264     pMACHeader = (struct ieee80211_hdr *) (pbyTxBufferAddr + cbHeaderSize);
2265
2266     cbReqCount = cbHeaderSize + cbMacHdLen + uPadding + cbIVlen + (cbFrameBodySize + cbMIClen) + cbExtSuppRate;
2267
2268     pbyMacHdr = (u8 *)(pbyTxBufferAddr + cbHeaderSize);
2269     pbyPayloadHead = (u8 *)(pbyMacHdr + cbMacHdLen + uPadding + cbIVlen);
2270     pbyIVHead = (u8 *)(pbyMacHdr + cbMacHdLen + uPadding);
2271
2272     // Copy the Packet into a tx Buffer
2273     memcpy(pbyMacHdr, skb->data, cbMacHdLen);
2274
2275     // version set to 0, patch for hostapd deamon
2276     pMACHeader->frame_control &= cpu_to_le16(0xfffc);
2277     memcpy(pbyPayloadHead, (skb->data + cbMacHdLen), cbFrameBodySize);
2278
2279     // replace support rate, patch for hostapd daemon( only support 11M)
2280     if (WLAN_GET_FC_FSTYPE(p80211Header->sA4.wFrameCtl) == WLAN_FSTYPE_ASSOCRESP) {
2281         if (cbExtSuppRate != 0) {
2282             if (((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates)->len != 0)
2283                 memcpy((pbyPayloadHead + cbFrameBodySize),
2284                         pMgmt->abyCurrSuppRates,
2285                         ((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates)->len + WLAN_IEHDR_LEN
2286                        );
2287              if (((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates)->len != 0)
2288                 memcpy((pbyPayloadHead + cbFrameBodySize) + ((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates)->len + WLAN_IEHDR_LEN,
2289                         pMgmt->abyCurrExtSuppRates,
2290                         ((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates)->len + WLAN_IEHDR_LEN
2291                        );
2292          }
2293     }
2294
2295     // Set wep
2296     if (WLAN_GET_FC_ISWEP(p80211Header->sA4.wFrameCtl) != 0) {
2297
2298         if (pDevice->bEnableHostWEP) {
2299             pTransmitKey = &STempKey;
2300             pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
2301             pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
2302             pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
2303             pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
2304             pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
2305             memcpy(pTransmitKey->abyKey,
2306                 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
2307                 pTransmitKey->uKeyLength
2308                 );
2309         }
2310
2311         if ((pTransmitKey != NULL) && (pTransmitKey->byCipherSuite == KEY_CTL_TKIP)) {
2312
2313             dwMICKey0 = *(u32 *)(&pTransmitKey->abyKey[16]);
2314             dwMICKey1 = *(u32 *)(&pTransmitKey->abyKey[20]);
2315
2316             // DO Software Michael
2317             MIC_vInit(dwMICKey0, dwMICKey1);
2318             MIC_vAppend((u8 *)&(sEthHeader.h_dest[0]), 12);
2319             dwMIC_Priority = 0;
2320             MIC_vAppend((u8 *)&dwMIC_Priority, 4);
2321                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"DMA0_tx_8021:MIC KEY:"\
2322                         " %X, %X\n", dwMICKey0, dwMICKey1);
2323
2324             uLength = cbHeaderSize + cbMacHdLen + uPadding + cbIVlen;
2325
2326             MIC_vAppend((pbyTxBufferAddr + uLength), cbFrameBodySize);
2327
2328             pdwMIC_L = (u32 *)(pbyTxBufferAddr + uLength + cbFrameBodySize);
2329             pdwMIC_R = (u32 *)(pbyTxBufferAddr + uLength + cbFrameBodySize + 4);
2330
2331             MIC_vGetMIC(pdwMIC_L, pdwMIC_R);
2332             MIC_vUnInit();
2333
2334             if (pDevice->bTxMICFail == true) {
2335                 *pdwMIC_L = 0;
2336                 *pdwMIC_R = 0;
2337                 pDevice->bTxMICFail = false;
2338             }
2339
2340             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"uLength: %d, %d\n", uLength, cbFrameBodySize);
2341             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"cbReqCount:%d, %d, %d, %d\n", cbReqCount, cbHeaderSize, uPadding, cbIVlen);
2342                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MIC:%x, %x\n",
2343                         *pdwMIC_L, *pdwMIC_R);
2344
2345         }
2346
2347         s_vFillTxKey(pDevice, (u8 *)(pTxBufHead->adwTxKey), pbyIVHead, pTransmitKey,
2348                      pbyMacHdr, (u16)cbFrameBodySize, (u8 *)pMICHDR);
2349
2350         if (pDevice->bEnableHostWEP) {
2351             pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16 = pTransmitKey->dwTSC47_16;
2352             pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0 = pTransmitKey->wTSC15_0;
2353         }
2354
2355         if ((pDevice->byLocalID <= REV_ID_VT3253_A1)) {
2356             s_vSWencryption(pDevice, pTransmitKey, pbyPayloadHead, (u16)(cbFrameBodySize + cbMIClen));
2357         }
2358     }
2359
2360     pMACHeader->seq_ctrl = cpu_to_le16(pDevice->wSeqCounter << 4);
2361     pDevice->wSeqCounter++ ;
2362     if (pDevice->wSeqCounter > 0x0fff)
2363         pDevice->wSeqCounter = 0;
2364
2365     if (bIsPSPOLL) {
2366         // The MAC will automatically replace the Duration-field of MAC header by Duration-field
2367         // of  FIFO control header.
2368         // This will cause AID-field of PS-POLL packet be incorrect (Because PS-POLL's AID field is
2369         // in the same place of other packet's Duration-field).
2370         // And it will cause Cisco-AP to issue Disassociation-packet
2371         if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
2372             ((PSTxDataHead_g)pvTxDataHd)->wDuration_a = cpu_to_le16(p80211Header->sA2.wDurationID);
2373             ((PSTxDataHead_g)pvTxDataHd)->wDuration_b = cpu_to_le16(p80211Header->sA2.wDurationID);
2374         } else {
2375             ((PSTxDataHead_ab)pvTxDataHd)->wDuration = cpu_to_le16(p80211Header->sA2.wDurationID);
2376         }
2377     }
2378
2379     pTX_Buffer->wTxByteCount = cpu_to_le16((u16)(cbReqCount));
2380     pTX_Buffer->byPKTNO = (u8) (((wCurrentRate<<4) &0x00F0) | ((pDevice->wSeqCounter - 1) & 0x000F));
2381     pTX_Buffer->byType = 0x00;
2382
2383     pContext->pPacket = skb;
2384     pContext->Type = CONTEXT_MGMT_PACKET;
2385     pContext->uBufLen = (u16)cbReqCount + 4;  //USB header
2386
2387     if (WLAN_GET_FC_TODS(pMACHeader->frame_control) == 0) {
2388         s_vSaveTxPktInfo(pDevice, (u8) (pTX_Buffer->byPKTNO & 0x0F), &(pMACHeader->addr1[0]), (u16)cbFrameSize, pTX_Buffer->wFIFOCtl);
2389     }
2390     else {
2391         s_vSaveTxPktInfo(pDevice, (u8) (pTX_Buffer->byPKTNO & 0x0F), &(pMACHeader->addr3[0]), (u16)cbFrameSize, pTX_Buffer->wFIFOCtl);
2392     }
2393     PIPEnsSendBulkOut(pDevice,pContext);
2394     return ;
2395
2396 }
2397
2398 //TYPE_AC0DMA data tx
2399 /*
2400  * Description:
2401  *      Tx packet via AC0DMA(DMA1)
2402  *
2403  * Parameters:
2404  *  In:
2405  *      pDevice         - Pointer to the adapter
2406  *      skb             - Pointer to tx skb packet
2407  *  Out:
2408  *      void
2409  *
2410  * Return Value: NULL
2411  */
2412
2413 int nsDMA_tx_packet(struct vnt_private *pDevice,
2414         u32 uDMAIdx, struct sk_buff *skb)
2415 {
2416         struct net_device_stats *pStats = &pDevice->stats;
2417         struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
2418         u32 BytesToWrite = 0, uHeaderLen = 0;
2419         u32 uNodeIndex = 0;
2420         u8 byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
2421         u16 wAID;
2422         u8 byPktType;
2423         int bNeedEncryption = false;
2424         PSKeyItem pTransmitKey = NULL;
2425         SKeyItem STempKey;
2426         int ii;
2427         int bTKIP_UseGTK = false;
2428         int bNeedDeAuth = false;
2429         u8 *pbyBSSID;
2430         int bNodeExist = false;
2431         PUSB_SEND_CONTEXT pContext;
2432         bool fConvertedPacket;
2433         PTX_BUFFER pTX_Buffer;
2434         u32 status;
2435         u16 wKeepRate = pDevice->wCurrentRate;
2436         int bTxeapol_key = false;
2437
2438     if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
2439
2440         if (pDevice->uAssocCount == 0) {
2441             dev_kfree_skb_irq(skb);
2442             return 0;
2443         }
2444
2445         if (is_multicast_ether_addr((u8 *)(skb->data))) {
2446             uNodeIndex = 0;
2447             bNodeExist = true;
2448             if (pMgmt->sNodeDBTable[0].bPSEnable) {
2449
2450                 skb_queue_tail(&(pMgmt->sNodeDBTable[0].sTxPSQueue), skb);
2451                 pMgmt->sNodeDBTable[0].wEnQueueCnt++;
2452                 // set tx map
2453                 pMgmt->abyPSTxMap[0] |= byMask[0];
2454                 return 0;
2455             }
2456             // multicast/broadcast data rate
2457
2458             if (pDevice->byBBType != BB_TYPE_11A)
2459                 pDevice->wCurrentRate = RATE_2M;
2460             else
2461                 pDevice->wCurrentRate = RATE_24M;
2462             // long preamble type
2463             pDevice->byPreambleType = PREAMBLE_SHORT;
2464
2465         }else {
2466
2467             if (BSSbIsSTAInNodeDB(pDevice, (u8 *)(skb->data), &uNodeIndex)) {
2468
2469                 if (pMgmt->sNodeDBTable[uNodeIndex].bPSEnable) {
2470
2471                     skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, skb);
2472
2473                     pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt++;
2474                     // set tx map
2475                     wAID = pMgmt->sNodeDBTable[uNodeIndex].wAID;
2476                     pMgmt->abyPSTxMap[wAID >> 3] |=  byMask[wAID & 7];
2477                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Set:pMgmt->abyPSTxMap[%d]= %d\n",
2478                              (wAID >> 3), pMgmt->abyPSTxMap[wAID >> 3]);
2479
2480                     return 0;
2481                 }
2482                 // AP rate decided from node
2483                 pDevice->wCurrentRate = pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate;
2484                 // tx preamble decided from node
2485
2486                 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) {
2487                     pDevice->byPreambleType = pDevice->byShortPreamble;
2488
2489                 }else {
2490                     pDevice->byPreambleType = PREAMBLE_LONG;
2491                 }
2492                 bNodeExist = true;
2493             }
2494         }
2495
2496         if (bNodeExist == false) {
2497             DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Unknown STA not found in node DB \n");
2498             dev_kfree_skb_irq(skb);
2499             return 0;
2500         }
2501     }
2502
2503     pContext = (PUSB_SEND_CONTEXT)s_vGetFreeContext(pDevice);
2504
2505     if (pContext == NULL) {
2506         DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG" pContext == NULL\n");
2507         dev_kfree_skb_irq(skb);
2508         return STATUS_RESOURCES;
2509     }
2510
2511     memcpy(pDevice->sTxEthHeader.h_dest, (u8 *)(skb->data), ETH_HLEN);
2512
2513 //mike add:station mode check eapol-key challenge--->
2514 {
2515     u8  Protocol_Version;    //802.1x Authentication
2516     u8  Packet_Type;           //802.1x Authentication
2517     u8  Descriptor_type;
2518     u16 Key_info;
2519
2520     Protocol_Version = skb->data[ETH_HLEN];
2521     Packet_Type = skb->data[ETH_HLEN+1];
2522     Descriptor_type = skb->data[ETH_HLEN+1+1+2];
2523     Key_info = (skb->data[ETH_HLEN+1+1+2+1] << 8)|(skb->data[ETH_HLEN+1+1+2+2]);
2524         if (pDevice->sTxEthHeader.h_proto == cpu_to_be16(ETH_P_PAE)) {
2525                 /* 802.1x OR eapol-key challenge frame transfer */
2526                 if (((Protocol_Version == 1) || (Protocol_Version == 2)) &&
2527                         (Packet_Type == 3)) {
2528                         bTxeapol_key = true;
2529                        if(!(Key_info & BIT3) &&  //WPA or RSN group-key challenge
2530                            (Key_info & BIT8) && (Key_info & BIT9)) {    //send 2/2 key
2531                           if(Descriptor_type==254) {
2532                                pDevice->fWPA_Authened = true;
2533                              PRINT_K("WPA ");
2534                           }
2535                           else {
2536                                pDevice->fWPA_Authened = true;
2537                              PRINT_K("WPA2(re-keying) ");
2538                           }
2539                           PRINT_K("Authentication completed!!\n");
2540                         }
2541                     else if((Key_info & BIT3) && (Descriptor_type==2) &&  //RSN pairwise-key challenge
2542                                (Key_info & BIT8) && (Key_info & BIT9)) {
2543                           pDevice->fWPA_Authened = true;
2544                             PRINT_K("WPA2 Authentication completed!!\n");
2545                      }
2546              }
2547    }
2548 }
2549 //mike add:station mode check eapol-key challenge<---
2550
2551     if (pDevice->bEncryptionEnable == true) {
2552         bNeedEncryption = true;
2553         // get Transmit key
2554         do {
2555             if ((pMgmt->eCurrMode == WMAC_MODE_ESS_STA) &&
2556                 (pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
2557                 pbyBSSID = pDevice->abyBSSID;
2558                 // get pairwise key
2559                 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == false) {
2560                     // get group key
2561                     if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == true) {
2562                         bTKIP_UseGTK = true;
2563                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n");
2564                         break;
2565                     }
2566                 } else {
2567                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get PTK.\n");
2568                     break;
2569                 }
2570             }else if (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2571               /* TO_DS = 0 and FROM_DS = 0 --> 802.11 MAC Address1 */
2572                 pbyBSSID = pDevice->sTxEthHeader.h_dest;
2573                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"IBSS Serach Key: \n");
2574                 for (ii = 0; ii< 6; ii++)
2575                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"%x \n", *(pbyBSSID+ii));
2576                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"\n");
2577
2578                 // get pairwise key
2579                 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == true)
2580                     break;
2581             }
2582             // get group key
2583             pbyBSSID = pDevice->abyBroadcastAddr;
2584             if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == false) {
2585                 pTransmitKey = NULL;
2586                 if (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2587                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"IBSS and KEY is NULL. [%d]\n", pMgmt->eCurrMode);
2588                 }
2589                 else
2590                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"NOT IBSS and KEY is NULL. [%d]\n", pMgmt->eCurrMode);
2591             } else {
2592                 bTKIP_UseGTK = true;
2593                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n");
2594             }
2595         } while(false);
2596     }
2597
2598     if (pDevice->bEnableHostWEP) {
2599         DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"acdma0: STA index %d\n", uNodeIndex);
2600         if (pDevice->bEncryptionEnable == true) {
2601             pTransmitKey = &STempKey;
2602             pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
2603             pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
2604             pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
2605             pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
2606             pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
2607             memcpy(pTransmitKey->abyKey,
2608                 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
2609                 pTransmitKey->uKeyLength
2610                 );
2611          }
2612     }
2613
2614     byPktType = (u8)pDevice->byPacketType;
2615
2616     if (pDevice->bFixRate) {
2617         if (pDevice->byBBType == BB_TYPE_11B) {
2618             if (pDevice->uConnectionRate >= RATE_11M) {
2619                 pDevice->wCurrentRate = RATE_11M;
2620             } else {
2621                 pDevice->wCurrentRate = (u16)pDevice->uConnectionRate;
2622             }
2623         } else {
2624             if ((pDevice->byBBType == BB_TYPE_11A) &&
2625                 (pDevice->uConnectionRate <= RATE_6M)) {
2626                 pDevice->wCurrentRate = RATE_6M;
2627             } else {
2628                 if (pDevice->uConnectionRate >= RATE_54M)
2629                     pDevice->wCurrentRate = RATE_54M;
2630                 else
2631                     pDevice->wCurrentRate = (u16)pDevice->uConnectionRate;
2632             }
2633         }
2634     }
2635     else {
2636         if (pDevice->eOPMode == OP_MODE_ADHOC) {
2637             // Adhoc Tx rate decided from node DB
2638             if (is_multicast_ether_addr(pDevice->sTxEthHeader.h_dest)) {
2639                 // Multicast use highest data rate
2640                 pDevice->wCurrentRate = pMgmt->sNodeDBTable[0].wTxDataRate;
2641                 // preamble type
2642                 pDevice->byPreambleType = pDevice->byShortPreamble;
2643             }
2644             else {
2645                 if (BSSbIsSTAInNodeDB(pDevice, &(pDevice->sTxEthHeader.h_dest[0]), &uNodeIndex)) {
2646                     pDevice->wCurrentRate = pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate;
2647                     if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) {
2648                         pDevice->byPreambleType = pDevice->byShortPreamble;
2649
2650                     }
2651                     else {
2652                         pDevice->byPreambleType = PREAMBLE_LONG;
2653                     }
2654                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Found Node Index is [%d]  Tx Data Rate:[%d]\n",uNodeIndex, pDevice->wCurrentRate);
2655                 }
2656                 else {
2657                     if (pDevice->byBBType != BB_TYPE_11A)
2658                        pDevice->wCurrentRate = RATE_2M;
2659                     else
2660                        pDevice->wCurrentRate = RATE_24M; // refer to vMgrCreateOwnIBSS()'s
2661                                                          // abyCurrExtSuppRates[]
2662                     pDevice->byPreambleType = PREAMBLE_SHORT;
2663                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Not Found Node use highest basic Rate.....\n");
2664                 }
2665             }
2666         }
2667         if (pDevice->eOPMode == OP_MODE_INFRASTRUCTURE) {
2668             // Infra STA rate decided from AP Node, index = 0
2669             pDevice->wCurrentRate = pMgmt->sNodeDBTable[0].wTxDataRate;
2670         }
2671     }
2672
2673         if (pDevice->sTxEthHeader.h_proto == cpu_to_be16(ETH_P_PAE)) {
2674                 if (pDevice->byBBType != BB_TYPE_11A) {
2675                         pDevice->wCurrentRate = RATE_1M;
2676                         pDevice->byACKRate = RATE_1M;
2677                         pDevice->byTopCCKBasicRate = RATE_1M;
2678                         pDevice->byTopOFDMBasicRate = RATE_6M;
2679                 } else {
2680                         pDevice->wCurrentRate = RATE_6M;
2681                         pDevice->byACKRate = RATE_6M;
2682                         pDevice->byTopCCKBasicRate = RATE_1M;
2683                         pDevice->byTopOFDMBasicRate = RATE_6M;
2684                 }
2685         }
2686
2687     DBG_PRT(MSG_LEVEL_DEBUG,
2688             KERN_INFO "dma_tx: pDevice->wCurrentRate = %d\n",
2689             pDevice->wCurrentRate);
2690
2691     if (wKeepRate != pDevice->wCurrentRate) {
2692         bScheduleCommand((void *) pDevice, WLAN_CMD_SETPOWER, NULL);
2693     }
2694
2695     if (pDevice->wCurrentRate <= RATE_11M) {
2696         byPktType = PK_TYPE_11B;
2697     }
2698
2699     if (bNeedEncryption == true) {
2700         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ntohs Pkt Type=%04x\n", ntohs(pDevice->sTxEthHeader.h_proto));
2701         if ((pDevice->sTxEthHeader.h_proto) == cpu_to_be16(ETH_P_PAE)) {
2702                 bNeedEncryption = false;
2703             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Pkt Type=%04x\n", (pDevice->sTxEthHeader.h_proto));
2704             if ((pMgmt->eCurrMode == WMAC_MODE_ESS_STA) && (pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
2705                 if (pTransmitKey == NULL) {
2706                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Don't Find TX KEY\n");
2707                 }
2708                 else {
2709                     if (bTKIP_UseGTK == true) {
2710                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"error: KEY is GTK!!~~\n");
2711                     }
2712                     else {
2713                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Find PTK [%X]\n",
2714                                 pTransmitKey->dwKeyIndex);
2715                         bNeedEncryption = true;
2716                     }
2717                 }
2718             }
2719
2720             if (pDevice->bEnableHostWEP) {
2721                 if ((uNodeIndex != 0) &&
2722                     (pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex & PAIRWISE_KEY)) {
2723                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Find PTK [%X]\n",
2724                                 pTransmitKey->dwKeyIndex);
2725                     bNeedEncryption = true;
2726                  }
2727              }
2728         }
2729         else {
2730
2731             if (pTransmitKey == NULL) {
2732                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"return no tx key\n");
2733                 pContext->bBoolInUse = false;
2734                 dev_kfree_skb_irq(skb);
2735                 pStats->tx_dropped++;
2736                 return STATUS_FAILURE;
2737             }
2738         }
2739     }
2740
2741     fConvertedPacket = s_bPacketToWirelessUsb(pDevice, byPktType,
2742                         (u8 *)(&pContext->Data[0]), bNeedEncryption,
2743                         skb->len, uDMAIdx, &pDevice->sTxEthHeader,
2744                         (u8 *)skb->data, pTransmitKey, uNodeIndex,
2745                         pDevice->wCurrentRate,
2746                         &uHeaderLen, &BytesToWrite
2747                        );
2748
2749     if (fConvertedPacket == false) {
2750         pContext->bBoolInUse = false;
2751         dev_kfree_skb_irq(skb);
2752         return STATUS_FAILURE;
2753     }
2754
2755     if ( pDevice->bEnablePSMode == true ) {
2756         if ( !pDevice->bPSModeTxBurst ) {
2757                 bScheduleCommand((void *) pDevice,
2758                                  WLAN_CMD_MAC_DISPOWERSAVING,
2759                                  NULL);
2760             pDevice->bPSModeTxBurst = true;
2761         }
2762     }
2763
2764     pTX_Buffer = (PTX_BUFFER)&(pContext->Data[0]);
2765     pTX_Buffer->byPKTNO = (u8) (((pDevice->wCurrentRate<<4) &0x00F0) | ((pDevice->wSeqCounter - 1) & 0x000F));
2766     pTX_Buffer->wTxByteCount = (u16)BytesToWrite;
2767
2768     pContext->pPacket = skb;
2769     pContext->Type = CONTEXT_DATA_PACKET;
2770     pContext->uBufLen = (u16)BytesToWrite + 4 ; //USB header
2771
2772     s_vSaveTxPktInfo(pDevice, (u8) (pTX_Buffer->byPKTNO & 0x0F), &(pContext->sEthHeader.h_dest[0]), (u16) (BytesToWrite-uHeaderLen), pTX_Buffer->wFIFOCtl);
2773
2774     status = PIPEnsSendBulkOut(pDevice,pContext);
2775
2776     if (bNeedDeAuth == true) {
2777         u16 wReason = WLAN_MGMT_REASON_MIC_FAILURE;
2778
2779         bScheduleCommand((void *) pDevice, WLAN_CMD_DEAUTH, (u8 *) &wReason);
2780     }
2781
2782   if(status!=STATUS_PENDING) {
2783      pContext->bBoolInUse = false;
2784     dev_kfree_skb_irq(skb);
2785     return STATUS_FAILURE;
2786   }
2787   else
2788     return 0;
2789
2790 }
2791
2792 /*
2793  * Description:
2794  *      Relay packet send (AC1DMA) from rx dpc.
2795  *
2796  * Parameters:
2797  *  In:
2798  *      pDevice         - Pointer to the adapter
2799  *      pPacket         - Pointer to rx packet
2800  *      cbPacketSize    - rx ethernet frame size
2801  *  Out:
2802  *      TURE, false
2803  *
2804  * Return Value: Return true if packet is copy to dma1; otherwise false
2805  */
2806
2807 int bRelayPacketSend(struct vnt_private *pDevice, u8 *pbySkbData, u32 uDataLen,
2808         u32 uNodeIndex)
2809 {
2810         struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
2811         u32 BytesToWrite = 0, uHeaderLen = 0;
2812         u8 byPktType = PK_TYPE_11B;
2813         int bNeedEncryption = false;
2814         SKeyItem STempKey;
2815         PSKeyItem pTransmitKey = NULL;
2816         u8 *pbyBSSID;
2817         PUSB_SEND_CONTEXT pContext;
2818         u8 byPktTyp;
2819         int fConvertedPacket;
2820         PTX_BUFFER pTX_Buffer;
2821         u32 status;
2822         u16 wKeepRate = pDevice->wCurrentRate;
2823
2824     pContext = (PUSB_SEND_CONTEXT)s_vGetFreeContext(pDevice);
2825
2826     if (NULL == pContext) {
2827         return false;
2828     }
2829
2830     memcpy(pDevice->sTxEthHeader.h_dest, (u8 *)pbySkbData, ETH_HLEN);
2831
2832     if (pDevice->bEncryptionEnable == true) {
2833         bNeedEncryption = true;
2834         // get group key
2835         pbyBSSID = pDevice->abyBroadcastAddr;
2836         if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == false) {
2837             pTransmitKey = NULL;
2838             DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"KEY is NULL. [%d]\n", pMgmt->eCurrMode);
2839         } else {
2840             DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n");
2841         }
2842     }
2843
2844     if (pDevice->bEnableHostWEP) {
2845         if (uNodeIndex < MAX_NODE_NUM + 1) {
2846             pTransmitKey = &STempKey;
2847             pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
2848             pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
2849             pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
2850             pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
2851             pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
2852             memcpy(pTransmitKey->abyKey,
2853                     &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
2854                     pTransmitKey->uKeyLength
2855                   );
2856         }
2857     }
2858
2859     if ( bNeedEncryption && (pTransmitKey == NULL) ) {
2860         pContext->bBoolInUse = false;
2861         return false;
2862     }
2863
2864     byPktTyp = (u8)pDevice->byPacketType;
2865
2866     if (pDevice->bFixRate) {
2867         if (pDevice->byBBType == BB_TYPE_11B) {
2868             if (pDevice->uConnectionRate >= RATE_11M) {
2869                 pDevice->wCurrentRate = RATE_11M;
2870             } else {
2871                 pDevice->wCurrentRate = (u16)pDevice->uConnectionRate;
2872             }
2873         } else {
2874             if ((pDevice->byBBType == BB_TYPE_11A) &&
2875                 (pDevice->uConnectionRate <= RATE_6M)) {
2876                 pDevice->wCurrentRate = RATE_6M;
2877             } else {
2878                 if (pDevice->uConnectionRate >= RATE_54M)
2879                     pDevice->wCurrentRate = RATE_54M;
2880                 else
2881                     pDevice->wCurrentRate = (u16)pDevice->uConnectionRate;
2882             }
2883         }
2884     }
2885     else {
2886         pDevice->wCurrentRate = pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate;
2887     }
2888
2889     if (wKeepRate != pDevice->wCurrentRate) {
2890         bScheduleCommand((void *) pDevice, WLAN_CMD_SETPOWER, NULL);
2891     }
2892
2893     if (pDevice->wCurrentRate <= RATE_11M)
2894         byPktType = PK_TYPE_11B;
2895
2896     BytesToWrite = uDataLen + ETH_FCS_LEN;
2897
2898     // Convert the packet to an usb frame and copy into our buffer
2899     // and send the irp.
2900
2901     fConvertedPacket = s_bPacketToWirelessUsb(pDevice, byPktType,
2902                          (u8 *)(&pContext->Data[0]), bNeedEncryption,
2903                          uDataLen, TYPE_AC0DMA, &pDevice->sTxEthHeader,
2904                          pbySkbData, pTransmitKey, uNodeIndex,
2905                          pDevice->wCurrentRate,
2906                          &uHeaderLen, &BytesToWrite
2907                         );
2908
2909     if (fConvertedPacket == false) {
2910         pContext->bBoolInUse = false;
2911         return false;
2912     }
2913
2914     pTX_Buffer = (PTX_BUFFER)&(pContext->Data[0]);
2915     pTX_Buffer->byPKTNO = (u8) (((pDevice->wCurrentRate<<4) &0x00F0) | ((pDevice->wSeqCounter - 1) & 0x000F));
2916     pTX_Buffer->wTxByteCount = (u16)BytesToWrite;
2917
2918     pContext->pPacket = NULL;
2919     pContext->Type = CONTEXT_DATA_PACKET;
2920     pContext->uBufLen = (u16)BytesToWrite + 4 ; //USB header
2921
2922     s_vSaveTxPktInfo(pDevice, (u8) (pTX_Buffer->byPKTNO & 0x0F), &(pContext->sEthHeader.h_dest[0]), (u16) (BytesToWrite-uHeaderLen), pTX_Buffer->wFIFOCtl);
2923
2924     status = PIPEnsSendBulkOut(pDevice,pContext);
2925
2926     return true;
2927 }
2928