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