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