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