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