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