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