/*
   * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
   * All rights reserved.
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU General Public License as published by
   * the Free Software Foundation; either version 2 of the License, or
   * (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License along
   * with this program; if not, write to the Free Software Foundation, Inc.,
   * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * File: rxtx.c
   *
   * Purpose: handle WMAC/802.3/802.11 rx & tx functions
   *
   * Author: Lyndon Chen
   *
   * Date: May 20, 2003
   *
   * Functions:

   *      s_vGenerateTxParameter - Generate tx dma required parameter.

   *      vGenerateMACHeader - Translate 802.3 to 802.11 header

   *      cbGetFragCount - Caculate fragment number count

   *      csBeacon_xmit - beacon tx function
   *      csMgmt_xmit - management tx function
   *      s_cbFillTxBufHead - fulfill tx dma buffer header
   *      s_uGetDataDuration - get tx data required duration
   *      s_uFillDataHead- fulfill tx data duration header

   *      s_uGetRTSCTSDuration- get rtx/cts required duration

   *      s_uGetRTSCTSRsvTime- get rts/cts reserved time
   *      s_uGetTxRsvTime- get frame reserved time
   *      s_vFillCTSHead- fulfill CTS ctl header

   *      s_vFillFragParameter- Set fragment ctl parameter.

   *      s_vFillRTSHead- fulfill RTS ctl header
   *      s_vFillTxKey- fulfill tx encrypt key
   *      s_vSWencryption- Software encrypt header
   *      vDMA0_tx_80211- tx 802.11 frame via dma0
   *      vGenerateFIFOHeader- Generate tx FIFO ctl header
   *
   * Revision History:
   *
   */

  #include "device.h"

  #include "rxtx.h"

  #include "tether.h"

  #include "card.h"

  #include "bssdb.h"

  #include "mac.h"

  #include "baseband.h"

  #include "michael.h"

  #include "tkip.h"

  #include "tcrc.h"

  #include "wctl.h"

  #include "wroute.h"

  #include "hostap.h"

  #include "rf.h"

  
  /*---------------------  Static Definitions -------------------------*/
  
  /*---------------------  Static Classes  ----------------------------*/
  
  /*---------------------  Static Variables  --------------------------*/
  //static int          msglevel                =MSG_LEVEL_DEBUG;
  static int          msglevel                =MSG_LEVEL_INFO;
  
  #define	PLICE_DEBUG
  
  
  /*---------------------  Static Functions  --------------------------*/
  
  /*---------------------  Static Definitions -------------------------*/
  #define CRITICAL_PACKET_LEN      256    // if packet size < 256 -> in-direct send
                                          //    packet size >= 256 -> direct send

  const unsigned short wTimeStampOff[2][MAX_RATE] = {

          {384, 288, 226, 209, 54, 43, 37, 31, 28, 25, 24, 23}, // Long Preamble
          {384, 192, 130, 113, 54, 43, 37, 31, 28, 25, 24, 23}, // Short Preamble
      };

  const unsigned short wFB_Opt0[2][5] = {

          {RATE_12M, RATE_18M, RATE_24M, RATE_36M, RATE_48M}, // fallback_rate0
          {RATE_12M, RATE_12M, RATE_18M, RATE_24M, RATE_36M}, // fallback_rate1
      };

  const unsigned short wFB_Opt1[2][5] = {

          {RATE_12M, RATE_18M, RATE_24M, RATE_24M, RATE_36M}, // fallback_rate0
          {RATE_6M , RATE_6M,  RATE_12M, RATE_12M, RATE_18M}, // fallback_rate1
      };
  
  
  #define RTSDUR_BB       0
  #define RTSDUR_BA       1
  #define RTSDUR_AA       2
  #define CTSDUR_BA       3
  #define RTSDUR_BA_F0    4
  #define RTSDUR_AA_F0    5
  #define RTSDUR_BA_F1    6
  #define RTSDUR_AA_F1    7
  #define CTSDUR_BA_F0    8
  #define CTSDUR_BA_F1    9
  #define DATADUR_B       10
  #define DATADUR_A       11
  #define DATADUR_A_F0    12
  #define DATADUR_A_F1    13
  
  /*---------------------  Static Functions  --------------------------*/
  
  
  
  static

  void

  s_vFillTxKey(

      PSDevice   pDevice,

      unsigned char *pbyBuf,
      unsigned char *pbyIVHead,

      PSKeyItem  pTransmitKey,

      unsigned char *pbyHdrBuf,

      unsigned short wPayloadLen,

      unsigned char *pMICHDR

      );
  
  
  
  static

  void

  s_vFillRTSHead(

      PSDevice         pDevice,

      unsigned char byPktType,

      void *           pvRTS,

      unsigned int	cbFrameLength,

      bool bNeedAck,
      bool bDisCRC,

      PSEthernetHeader psEthHeader,

      unsigned short wCurrentRate,

      unsigned char byFBOption

      );
  
  static

  void

  s_vGenerateTxParameter(

      PSDevice         pDevice,

      unsigned char byPktType,

      void *           pTxBufHead,
      void *           pvRrvTime,
      void *           pvRTS,
      void *           pvCTS,

      unsigned int	cbFrameSize,

      bool bNeedACK,

      unsigned int	uDMAIdx,

      PSEthernetHeader psEthHeader,

      unsigned short wCurrentRate

      );
  
  
  
  static void s_vFillFragParameter(

      PSDevice pDevice,

      unsigned char *pbyBuffer,

      unsigned int	uTxType,

      void *   pvtdCurr,

      unsigned short wFragType,

      unsigned int	cbReqCount

      );

  static unsigned int
  s_cbFillTxBufHead(PSDevice pDevice, unsigned char byPktType, unsigned char *pbyTxBufferAddr,
  	unsigned int cbFrameBodySize, unsigned int uDMAIdx, PSTxDesc pHeadTD,

  	PSEthernetHeader psEthHeader, unsigned char *pPacket, bool bNeedEncrypt,

  	PSKeyItem pTransmitKey, unsigned int uNodeIndex, unsigned int *puMACfragNum);

  
  
  static

  unsigned int

  s_uFillDataHead (

      PSDevice pDevice,

      unsigned char byPktType,

      void *   pTxDataHead,

      unsigned int cbFrameLength,
      unsigned int uDMAIdx,

      bool bNeedAck,

      unsigned int uFragIdx,
      unsigned int cbLastFragmentSize,
      unsigned int uMACfragNum,

      unsigned char byFBOption,

      unsigned short wCurrentRate

      );
  
  
  /*---------------------  Export Variables  --------------------------*/
  
  
  
  static

  void

  s_vFillTxKey (

      PSDevice   pDevice,

      unsigned char *pbyBuf,
      unsigned char *pbyIVHead,

      PSKeyItem  pTransmitKey,

      unsigned char *pbyHdrBuf,

      unsigned short wPayloadLen,

      unsigned char *pMICHDR

      )
  {

      unsigned long *pdwIV = (unsigned long *) pbyIVHead;
      unsigned long *pdwExtIV = (unsigned long *) ((unsigned char *)pbyIVHead+4);

      unsigned short wValue;

      PS802_11Header  pMACHeader = (PS802_11Header)pbyHdrBuf;

      unsigned long dwRevIVCounter;

      unsigned char byKeyIndex = 0;

  
  
  
      //Fill TXKEY
      if (pTransmitKey == NULL)
          return;
  
      dwRevIVCounter = cpu_to_le32(pDevice->dwIVCounter);
      *pdwIV = pDevice->dwIVCounter;
      byKeyIndex = pTransmitKey->dwKeyIndex & 0xf;
  
      if (pTransmitKey->byCipherSuite == KEY_CTL_WEP) {
          if (pTransmitKey->uKeyLength == WLAN_WEP232_KEYLEN ){

              memcpy(pDevice->abyPRNG, (unsigned char *)&(dwRevIVCounter), 3);

              memcpy(pDevice->abyPRNG+3, pTransmitKey->abyKey, pTransmitKey->uKeyLength);

          } else {

              memcpy(pbyBuf, (unsigned char *)&(dwRevIVCounter), 3);

              memcpy(pbyBuf+3, pTransmitKey->abyKey, pTransmitKey->uKeyLength);

              if(pTransmitKey->uKeyLength == WLAN_WEP40_KEYLEN) {

                  memcpy(pbyBuf+8, (unsigned char *)&(dwRevIVCounter), 3);

                  memcpy(pbyBuf+11, pTransmitKey->abyKey, pTransmitKey->uKeyLength);

              }

              memcpy(pDevice->abyPRNG, pbyBuf, 16);

          }
          // Append IV after Mac Header
          *pdwIV &= WEP_IV_MASK;//00000000 11111111 11111111 11111111
          *pdwIV |= (byKeyIndex << 30);
          *pdwIV = cpu_to_le32(*pdwIV);
          pDevice->dwIVCounter++;
          if (pDevice->dwIVCounter > WEP_IV_MASK) {
              pDevice->dwIVCounter = 0;
          }
      } else if (pTransmitKey->byCipherSuite == KEY_CTL_TKIP) {
          pTransmitKey->wTSC15_0++;
          if (pTransmitKey->wTSC15_0 == 0) {
              pTransmitKey->dwTSC47_16++;
          }
          TKIPvMixKey(pTransmitKey->abyKey, pDevice->abyCurrentNetAddr,
                      pTransmitKey->wTSC15_0, pTransmitKey->dwTSC47_16, pDevice->abyPRNG);

          memcpy(pbyBuf, pDevice->abyPRNG, 16);

          // Make IV

          memcpy(pdwIV, pDevice->abyPRNG, 3);

          *(pbyIVHead+3) = (unsigned char)(((byKeyIndex << 6) & 0xc0) | 0x20); // 0x20 is ExtIV

          // Append IV&ExtIV after Mac Header
          *pdwExtIV = cpu_to_le32(pTransmitKey->dwTSC47_16);

          DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"vFillTxKey()---- pdwExtIV: %lx
  ", *pdwExtIV);

  
      } else if (pTransmitKey->byCipherSuite == KEY_CTL_CCMP) {
          pTransmitKey->wTSC15_0++;
          if (pTransmitKey->wTSC15_0 == 0) {
              pTransmitKey->dwTSC47_16++;
          }

          memcpy(pbyBuf, pTransmitKey->abyKey, 16);

  
          // Make IV
          *pdwIV = 0;

          *(pbyIVHead+3) = (unsigned char)(((byKeyIndex << 6) & 0xc0) | 0x20); // 0x20 is ExtIV

          *pdwIV |= cpu_to_le16((unsigned short)(pTransmitKey->wTSC15_0));

          //Append IV&ExtIV after Mac Header
          *pdwExtIV = cpu_to_le32(pTransmitKey->dwTSC47_16);
  
          //Fill MICHDR0
          *pMICHDR = 0x59;

          *((unsigned char *)(pMICHDR+1)) = 0; // TxPriority

          memcpy(pMICHDR+2, &(pMACHeader->abyAddr2[0]), 6);

          *((unsigned char *)(pMICHDR+8)) = HIBYTE(HIWORD(pTransmitKey->dwTSC47_16));
          *((unsigned char *)(pMICHDR+9)) = LOBYTE(HIWORD(pTransmitKey->dwTSC47_16));
          *((unsigned char *)(pMICHDR+10)) = HIBYTE(LOWORD(pTransmitKey->dwTSC47_16));
          *((unsigned char *)(pMICHDR+11)) = LOBYTE(LOWORD(pTransmitKey->dwTSC47_16));
          *((unsigned char *)(pMICHDR+12)) = HIBYTE(pTransmitKey->wTSC15_0);
          *((unsigned char *)(pMICHDR+13)) = LOBYTE(pTransmitKey->wTSC15_0);
          *((unsigned char *)(pMICHDR+14)) = HIBYTE(wPayloadLen);
          *((unsigned char *)(pMICHDR+15)) = LOBYTE(wPayloadLen);

  
          //Fill MICHDR1

          *((unsigned char *)(pMICHDR+16)) = 0; // HLEN[15:8]

          if (pDevice->bLongHeader) {

              *((unsigned char *)(pMICHDR+17)) = 28; // HLEN[7:0]

          } else {

              *((unsigned char *)(pMICHDR+17)) = 22; // HLEN[7:0]

          }
          wValue = cpu_to_le16(pMACHeader->wFrameCtl & 0xC78F);

          memcpy(pMICHDR+18, (unsigned char *)&wValue, 2); // MSKFRACTL

          memcpy(pMICHDR+20, &(pMACHeader->abyAddr1[0]), 6);
          memcpy(pMICHDR+26, &(pMACHeader->abyAddr2[0]), 6);

  
          //Fill MICHDR2

          memcpy(pMICHDR+32, &(pMACHeader->abyAddr3[0]), 6);

          wValue = pMACHeader->wSeqCtl;
          wValue &= 0x000F;
          wValue = cpu_to_le16(wValue);

          memcpy(pMICHDR+38, (unsigned char *)&wValue, 2); // MSKSEQCTL

          if (pDevice->bLongHeader) {

              memcpy(pMICHDR+40, &(pMACHeader->abyAddr4[0]), 6);

          }
      }
  }
  
  
  static

  void

  s_vSWencryption (

      PSDevice            pDevice,
      PSKeyItem           pTransmitKey,

      unsigned char *pbyPayloadHead,

      unsigned short wPayloadSize

      )
  {

      unsigned int cbICVlen = 4;

      unsigned long dwICV = 0xFFFFFFFFL;

      unsigned long *pdwICV;

  
      if (pTransmitKey == NULL)
          return;
  
      if (pTransmitKey->byCipherSuite == KEY_CTL_WEP) {
          //=======================================================================
          // Append ICV after payload
          dwICV = CRCdwGetCrc32Ex(pbyPayloadHead, wPayloadSize, dwICV);//ICV(Payload)

          pdwICV = (unsigned long *)(pbyPayloadHead + wPayloadSize);

          // finally, we must invert dwCRC to get the correct answer
          *pdwICV = cpu_to_le32(~dwICV);
          // RC4 encryption
          rc4_init(&pDevice->SBox, pDevice->abyPRNG, pTransmitKey->uKeyLength + 3);
          rc4_encrypt(&pDevice->SBox, pbyPayloadHead, pbyPayloadHead, wPayloadSize+cbICVlen);
          //=======================================================================
      } else if (pTransmitKey->byCipherSuite == KEY_CTL_TKIP) {
          //=======================================================================
          //Append ICV after payload
          dwICV = CRCdwGetCrc32Ex(pbyPayloadHead, wPayloadSize, dwICV);//ICV(Payload)

          pdwICV = (unsigned long *)(pbyPayloadHead + wPayloadSize);

          // finally, we must invert dwCRC to get the correct answer
          *pdwICV = cpu_to_le32(~dwICV);
          // RC4 encryption
          rc4_init(&pDevice->SBox, pDevice->abyPRNG, TKIP_KEY_LEN);
          rc4_encrypt(&pDevice->SBox, pbyPayloadHead, pbyPayloadHead, wPayloadSize+cbICVlen);
          //=======================================================================
      }
  }

  /*byPktType : PK_TYPE_11A     0

               PK_TYPE_11B     1
               PK_TYPE_11GB    2
               PK_TYPE_11GA    3
  */
  static

  unsigned int

  s_uGetTxRsvTime (

      PSDevice pDevice,

      unsigned char byPktType,

      unsigned int cbFrameLength,

      unsigned short wRate,

      bool bNeedAck

      )
  {

      unsigned int uDataTime, uAckTime;

      uDataTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, cbFrameLength, wRate);

  #ifdef	PLICE_DEBUG
  	//printk("s_uGetTxRsvTime is %d
  ",uDataTime);
  #endif

      if (byPktType == PK_TYPE_11B) {//llb,CCK mode

          uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, (unsigned short)pDevice->byTopCCKBasicRate);

      } else {//11g 2.4G OFDM mode & 11a 5G OFDM mode

          uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, (unsigned short)pDevice->byTopOFDMBasicRate);

      }
  
      if (bNeedAck) {
          return (uDataTime + pDevice->uSIFS + uAckTime);
      }
      else {
          return uDataTime;
      }
  }
  
  //byFreqType: 0=>5GHZ 1=>2.4GHZ
  static

  unsigned int

  s_uGetRTSCTSRsvTime (

      PSDevice pDevice,

      unsigned char byRTSRsvType,
      unsigned char byPktType,

      unsigned int cbFrameLength,

      unsigned short wCurrentRate

      )
  {

      unsigned int uRrvTime  , uRTSTime, uCTSTime, uAckTime, uDataTime;

  
      uRrvTime = uRTSTime = uCTSTime = uAckTime = uDataTime = 0;

      uDataTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, cbFrameLength, wCurrentRate);

      if (byRTSRsvType == 0) { //RTSTxRrvTime_bb

          uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopCCKBasicRate);
          uCTSTime = uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);

      }
      else if (byRTSRsvType == 1){ //RTSTxRrvTime_ba, only in 2.4GHZ

          uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopCCKBasicRate);
          uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
          uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);

      }
      else if (byRTSRsvType == 2) { //RTSTxRrvTime_aa

          uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopOFDMBasicRate);
          uCTSTime = uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);

      }
      else if (byRTSRsvType == 3) { //CTSTxRrvTime_ba, only in 2.4GHZ

          uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
          uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);

          uRrvTime = uCTSTime + uAckTime + uDataTime + 2*pDevice->uSIFS;
          return uRrvTime;
      }
  
      //RTSRrvTime
      uRrvTime = uRTSTime + uCTSTime + uAckTime + uDataTime + 3*pDevice->uSIFS;
      return uRrvTime;
  }
  
  //byFreqType 0: 5GHz, 1:2.4Ghz
  static

  unsigned int

  s_uGetDataDuration (

      PSDevice pDevice,

      unsigned char byDurType,

      unsigned int cbFrameLength,

      unsigned char byPktType,

      unsigned short wRate,

      bool bNeedAck,

      unsigned int uFragIdx,
      unsigned int cbLastFragmentSize,
      unsigned int uMACfragNum,

      unsigned char byFBOption

      )
  {

      bool bLastFrag = 0;

      unsigned int uAckTime =0, uNextPktTime = 0;

  
  
  
      if (uFragIdx == (uMACfragNum-1)) {
          bLastFrag = 1;
      }
  
  
      switch (byDurType) {
  
      case DATADUR_B:    //DATADUR_B
          if (((uMACfragNum == 1)) || (bLastFrag == 1)) {//Non Frag or Last Frag
              if (bNeedAck) {
              	uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
                  return (pDevice->uSIFS + uAckTime);
              } else {
                  return 0;
              }
          }
          else {//First Frag or Mid Frag
              if (uFragIdx == (uMACfragNum-2)) {
              	uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wRate, bNeedAck);
              } else {
                  uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
              }
              if (bNeedAck) {
              	uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
                  return (pDevice->uSIFS + uAckTime + uNextPktTime);
              } else {
                  return (pDevice->uSIFS + uNextPktTime);
              }
          }
          break;
  
      case DATADUR_A:    //DATADUR_A
          if (((uMACfragNum==1)) || (bLastFrag==1)) {//Non Frag or Last Frag
              if(bNeedAck){
              	uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
                  return (pDevice->uSIFS + uAckTime);
              } else {
                  return 0;
              }
          }
          else {//First Frag or Mid Frag
              if(uFragIdx == (uMACfragNum-2)){
              	uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wRate, bNeedAck);
              } else {
                  uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
              }
              if(bNeedAck){
              	uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
                  return (pDevice->uSIFS + uAckTime + uNextPktTime);
              } else {
                  return (pDevice->uSIFS + uNextPktTime);
              }
          }
          break;
  
      case DATADUR_A_F0:    //DATADUR_A_F0
  	    if (((uMACfragNum==1)) || (bLastFrag==1)) {//Non Frag or Last Frag
              if(bNeedAck){
              	uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
                  return (pDevice->uSIFS + uAckTime);
              } else {
                  return 0;
              }
          }
  	    else { //First Frag or Mid Frag
  	        if (byFBOption == AUTO_FB_0) {
                  if (wRate < RATE_18M)
                      wRate = RATE_18M;
                  else if (wRate > RATE_54M)
                      wRate = RATE_54M;
  
  	            if(uFragIdx == (uMACfragNum-2)){
              	    uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
                  } else {
                      uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
                  }
  	        } else { // (byFBOption == AUTO_FB_1)
                  if (wRate < RATE_18M)
                      wRate = RATE_18M;
                  else if (wRate > RATE_54M)
                      wRate = RATE_54M;
  
  	            if(uFragIdx == (uMACfragNum-2)){
              	    uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
                  } else {
                      uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
                  }
  	        }
  
  	        if(bNeedAck){
              	uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
                  return (pDevice->uSIFS + uAckTime + uNextPktTime);
              } else {
                  return (pDevice->uSIFS + uNextPktTime);
              }
  	    }
          break;
  
      case DATADUR_A_F1:    //DATADUR_A_F1
          if (((uMACfragNum==1)) || (bLastFrag==1)) {//Non Frag or Last Frag
              if(bNeedAck){
              	uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
                  return (pDevice->uSIFS + uAckTime);
              } else {
                  return 0;
              }
          }
  	    else { //First Frag or Mid Frag
  	        if (byFBOption == AUTO_FB_0) {
                  if (wRate < RATE_18M)
                      wRate = RATE_18M;
                  else if (wRate > RATE_54M)
                      wRate = RATE_54M;
  
  	            if(uFragIdx == (uMACfragNum-2)){
              	    uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
                  } else {
                      uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
                  }
  
  	        } else { // (byFBOption == AUTO_FB_1)
                  if (wRate < RATE_18M)
                      wRate = RATE_18M;
                  else if (wRate > RATE_54M)
                      wRate = RATE_54M;
  
  	            if(uFragIdx == (uMACfragNum-2)){
              	    uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
                  } else {
                      uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
                  }
  	        }
  	        if(bNeedAck){
              	uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
                  return (pDevice->uSIFS + uAckTime + uNextPktTime);
              } else {
                  return (pDevice->uSIFS + uNextPktTime);
              }
  	    }
          break;
  
      default:
          break;
      }

  	ASSERT(false);

  	return 0;
  }
  
  
  //byFreqType: 0=>5GHZ 1=>2.4GHZ
  static

  unsigned int

  s_uGetRTSCTSDuration (

      PSDevice pDevice,

      unsigned char byDurType,

      unsigned int cbFrameLength,

      unsigned char byPktType,

      unsigned short wRate,

      bool bNeedAck,

      unsigned char byFBOption

      )
  {

      unsigned int uCTSTime = 0, uDurTime = 0;

  
  
      switch (byDurType) {
  
      case RTSDUR_BB:    //RTSDuration_bb
          uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
          uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
          break;
  
      case RTSDUR_BA:    //RTSDuration_ba
          uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
          uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
          break;
  
      case RTSDUR_AA:    //RTSDuration_aa
          uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
          uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
          break;
  
      case CTSDUR_BA:    //CTSDuration_ba
          uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
          break;
  
      case RTSDUR_BA_F0: //RTSDuration_ba_f0
          uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
          if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
              uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
          } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
              uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
          }
          break;
  
      case RTSDUR_AA_F0: //RTSDuration_aa_f0
          uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
          if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
              uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
          } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
              uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
          }
          break;
  
      case RTSDUR_BA_F1: //RTSDuration_ba_f1
          uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
          if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
              uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
          } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
              uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
          }
          break;
  
      case RTSDUR_AA_F1: //RTSDuration_aa_f1
          uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
          if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
              uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
          } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
              uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
          }
          break;
  
      case CTSDUR_BA_F0: //CTSDuration_ba_f0
          if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
              uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
          } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
              uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
          }
          break;
  
      case CTSDUR_BA_F1: //CTSDuration_ba_f1
          if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
              uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
          } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
              uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
          }
          break;
  
      default:
          break;
      }
  
      return uDurTime;
  
  }
  
  
  
  static

  unsigned int

  s_uFillDataHead (

      PSDevice pDevice,

      unsigned char byPktType,

      void *   pTxDataHead,

      unsigned int cbFrameLength,
      unsigned int uDMAIdx,

      bool bNeedAck,

      unsigned int uFragIdx,
      unsigned int cbLastFragmentSize,
      unsigned int uMACfragNum,

      unsigned char byFBOption,

      unsigned short wCurrentRate

      )
  {

      unsigned short wLen = 0x0000;

  
      if (pTxDataHead == NULL) {
          return 0;
      }

      if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {

          if (byFBOption == AUTO_FB_NONE) {
              PSTxDataHead_g pBuf = (PSTxDataHead_g)pTxDataHead;
              //Get SignalField,ServiceField,Length

              BBvCaculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,

                  (unsigned short *)&(wLen), (unsigned char *)&(pBuf->byServiceField_a), (unsigned char *)&(pBuf->bySignalField_a)

              );
              pBuf->wTransmitLength_a = cpu_to_le16(wLen);
              BBvCaculateParameter(pDevice, cbFrameLength, pDevice->byTopCCKBasicRate, PK_TYPE_11B,

                  (unsigned short *)&(wLen), (unsigned char *)&(pBuf->byServiceField_b), (unsigned char *)&(pBuf->bySignalField_b)

              );
              pBuf->wTransmitLength_b = cpu_to_le16(wLen);
              //Get Duration and TimeStamp

              pBuf->wDuration_a = cpu_to_le16((unsigned short)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength,

                                                           byPktType, wCurrentRate, bNeedAck, uFragIdx,

                                                           cbLastFragmentSize, uMACfragNum,
                                                           byFBOption)); //1: 2.4GHz

              pBuf->wDuration_b = cpu_to_le16((unsigned short)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength,

                                                           PK_TYPE_11B, pDevice->byTopCCKBasicRate,
                                                           bNeedAck, uFragIdx, cbLastFragmentSize,
                                                           uMACfragNum, byFBOption)); //1: 2.4
  
              pBuf->wTimeStampOff_a = cpu_to_le16(wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE]);
              pBuf->wTimeStampOff_b = cpu_to_le16(wTimeStampOff[pDevice->byPreambleType%2][pDevice->byTopCCKBasicRate%MAX_RATE]);
  
              return (pBuf->wDuration_a);
           } else {
              // Auto Fallback
              PSTxDataHead_g_FB pBuf = (PSTxDataHead_g_FB)pTxDataHead;
              //Get SignalField,ServiceField,Length

              BBvCaculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,

                  (unsigned short *)&(wLen), (unsigned char *)&(pBuf->byServiceField_a), (unsigned char *)&(pBuf->bySignalField_a)

              );
              pBuf->wTransmitLength_a = cpu_to_le16(wLen);
              BBvCaculateParameter(pDevice, cbFrameLength, pDevice->byTopCCKBasicRate, PK_TYPE_11B,

                  (unsigned short *)&(wLen), (unsigned char *)&(pBuf->byServiceField_b), (unsigned char *)&(pBuf->bySignalField_b)

              );
              pBuf->wTransmitLength_b = cpu_to_le16(wLen);
              //Get Duration and TimeStamp

              pBuf->wDuration_a = cpu_to_le16((unsigned short)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,

                                           wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption)); //1: 2.4GHz

              pBuf->wDuration_b = cpu_to_le16((unsigned short)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength, PK_TYPE_11B,

                                           pDevice->byTopCCKBasicRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption)); //1: 2.4GHz

              pBuf->wDuration_a_f0 = cpu_to_le16((unsigned short)s_uGetDataDuration(pDevice, DATADUR_A_F0, cbFrameLength, byPktType,

                                           wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption)); //1: 2.4GHz

              pBuf->wDuration_a_f1 = cpu_to_le16((unsigned short)s_uGetDataDuration(pDevice, DATADUR_A_F1, cbFrameLength, byPktType,

                                           wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption)); //1: 2.4GHz
  
              pBuf->wTimeStampOff_a = cpu_to_le16(wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE]);
              pBuf->wTimeStampOff_b = cpu_to_le16(wTimeStampOff[pDevice->byPreambleType%2][pDevice->byTopCCKBasicRate%MAX_RATE]);
  
              return (pBuf->wDuration_a);
          } //if (byFBOption == AUTO_FB_NONE)
      }

      else if (byPktType == PK_TYPE_11A) {

          if ((byFBOption != AUTO_FB_NONE)) {
              // Auto Fallback
              PSTxDataHead_a_FB pBuf = (PSTxDataHead_a_FB)pTxDataHead;
              //Get SignalField,ServiceField,Length

              BBvCaculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,

                  (unsigned short *)&(wLen), (unsigned char *)&(pBuf->byServiceField), (unsigned char *)&(pBuf->bySignalField)

              );
              pBuf->wTransmitLength = cpu_to_le16(wLen);
              //Get Duration and TimeStampOff

              pBuf->wDuration = cpu_to_le16((unsigned short)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,

                                          wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption)); //0: 5GHz

              pBuf->wDuration_f0 = cpu_to_le16((unsigned short)s_uGetDataDuration(pDevice, DATADUR_A_F0, cbFrameLength, byPktType,

                                          wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption)); //0: 5GHz

              pBuf->wDuration_f1 = cpu_to_le16((unsigned short)s_uGetDataDuration(pDevice, DATADUR_A_F1, cbFrameLength, byPktType,

                                          wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption)); //0: 5GHz
              pBuf->wTimeStampOff = cpu_to_le16(wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE]);
              return (pBuf->wDuration);
          } else {
              PSTxDataHead_ab pBuf = (PSTxDataHead_ab)pTxDataHead;
              //Get SignalField,ServiceField,Length

              BBvCaculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,

                  (unsigned short *)&(wLen), (unsigned char *)&(pBuf->byServiceField), (unsigned char *)&(pBuf->bySignalField)

              );
              pBuf->wTransmitLength = cpu_to_le16(wLen);
              //Get Duration and TimeStampOff

              pBuf->wDuration = cpu_to_le16((unsigned short)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,

                                                         wCurrentRate, bNeedAck, uFragIdx,
                                                         cbLastFragmentSize, uMACfragNum,
                                                         byFBOption));
  
              pBuf->wTimeStampOff = cpu_to_le16(wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE]);
              return (pBuf->wDuration);
          }
      }
      else {
              PSTxDataHead_ab pBuf = (PSTxDataHead_ab)pTxDataHead;
              //Get SignalField,ServiceField,Length

              BBvCaculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,

                  (unsigned short *)&(wLen), (unsigned char *)&(pBuf->byServiceField), (unsigned char *)&(pBuf->bySignalField)

              );
              pBuf->wTransmitLength = cpu_to_le16(wLen);
              //Get Duration and TimeStampOff

              pBuf->wDuration = cpu_to_le16((unsigned short)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength, byPktType,

                                                         wCurrentRate, bNeedAck, uFragIdx,
                                                         cbLastFragmentSize, uMACfragNum,
                                                         byFBOption));
              pBuf->wTimeStampOff = cpu_to_le16(wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE]);
              return (pBuf->wDuration);
      }
      return 0;
  }
  
  
  static

  void

  s_vFillRTSHead (

      PSDevice         pDevice,

      unsigned char byPktType,

      void *           pvRTS,

      unsigned int cbFrameLength,

      bool bNeedAck,
      bool bDisCRC,

      PSEthernetHeader psEthHeader,

      unsigned short wCurrentRate,

      unsigned char byFBOption

      )
  {

      unsigned int uRTSFrameLen = 20;

      unsigned short wLen = 0x0000;

      if (pvRTS == NULL)
      	return;
  
      if (bDisCRC) {
          // When CRCDIS bit is on, H/W forgot to generate FCS for RTS frame,
          // in this case we need to decrease its length by 4.
          uRTSFrameLen -= 4;
      }
  
      // Note: So far RTSHead dosen't appear in ATIM & Beacom DMA, so we don't need to take them into account.

      //       Otherwise, we need to modify codes for them.

      if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {

          if (byFBOption == AUTO_FB_NONE) {
              PSRTS_g pBuf = (PSRTS_g)pvRTS;
              //Get SignalField,ServiceField,Length
              BBvCaculateParameter(pDevice, uRTSFrameLen, pDevice->byTopCCKBasicRate, PK_TYPE_11B,

                  (unsigned short *)&(wLen), (unsigned char *)&(pBuf->byServiceField_b), (unsigned char *)&(pBuf->bySignalField_b)

              );
              pBuf->wTransmitLength_b = cpu_to_le16(wLen);

              BBvCaculateParameter(pDevice, uRTSFrameLen, pDevice->byTopOFDMBasicRate, byPktType,

                  (unsigned short *)&(wLen), (unsigned char *)&(pBuf->byServiceField_a), (unsigned char *)&(pBuf->bySignalField_a)

              );
              pBuf->wTransmitLength_a = cpu_to_le16(wLen);
              //Get Duration

              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
              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
              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

  
              pBuf->Data.wDurationID = pBuf->wDuration_aa;
              //Get RTS Frame body
              pBuf->Data.wFrameControl = TYPE_CTL_RTS;//0x00B4
              if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
                  (pDevice->eOPMode == OP_MODE_AP)) {

                  memcpy(&(pBuf->Data.abyRA[0]), &(psEthHeader->abyDstAddr[0]), ETH_ALEN);

              }
              else {

                  memcpy(&(pBuf->Data.abyRA[0]), &(pDevice->abyBSSID[0]), ETH_ALEN);

              }
              if (pDevice->eOPMode == OP_MODE_AP) {

                  memcpy(&(pBuf->Data.abyTA[0]), &(pDevice->abyBSSID[0]), ETH_ALEN);

              }
              else {

                  memcpy(&(pBuf->Data.abyTA[0]), &(psEthHeader->abySrcAddr[0]), ETH_ALEN);

              }
          }
          else {
             PSRTS_g_FB pBuf = (PSRTS_g_FB)pvRTS;
              //Get SignalField,ServiceField,Length
              BBvCaculateParameter(pDevice, uRTSFrameLen, pDevice->byTopCCKBasicRate, PK_TYPE_11B,

                  (unsigned short *)&(wLen), (unsigned char *)&(pBuf->byServiceField_b), (unsigned char *)&(pBuf->bySignalField_b)

              );
              pBuf->wTransmitLength_b = cpu_to_le16(wLen);

              BBvCaculateParameter(pDevice, uRTSFrameLen, pDevice->byTopOFDMBasicRate, byPktType,

                  (unsigned short *)&(wLen), (unsigned char *)&(pBuf->byServiceField_a), (unsigned char *)&(pBuf->bySignalField_a)

              );
              pBuf->wTransmitLength_a = cpu_to_le16(wLen);
  
              //Get Duration

              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
              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
              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
              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
              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
              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
              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

              pBuf->Data.wDurationID = pBuf->wDuration_aa;
              //Get RTS Frame body
              pBuf->Data.wFrameControl = TYPE_CTL_RTS;//0x00B4
  
              if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
                  (pDevice->eOPMode == OP_MODE_AP)) {

                  memcpy(&(pBuf->Data.abyRA[0]), &(psEthHeader->abyDstAddr[0]), ETH_ALEN);

              }
              else {

                  memcpy(&(pBuf->Data.abyRA[0]), &(pDevice->abyBSSID[0]), ETH_ALEN);

              }
  
              if (pDevice->eOPMode == OP_MODE_AP) {

                  memcpy(&(pBuf->Data.abyTA[0]), &(pDevice->abyBSSID[0]), ETH_ALEN);

              }
              else {

                  memcpy(&(pBuf->Data.abyTA[0]), &(psEthHeader->abySrcAddr[0]), ETH_ALEN);

              }
  
          } // if (byFBOption == AUTO_FB_NONE)
      }

      else if (byPktType == PK_TYPE_11A) {

          if (byFBOption == AUTO_FB_NONE) {
              PSRTS_ab pBuf = (PSRTS_ab)pvRTS;
              //Get SignalField,ServiceField,Length

              BBvCaculateParameter(pDevice, uRTSFrameLen, pDevice->byTopOFDMBasicRate, byPktType,

                  (unsigned short *)&(wLen), (unsigned char *)&(pBuf->byServiceField), (unsigned char *)&(pBuf->bySignalField)

              );
              pBuf->wTransmitLength = cpu_to_le16(wLen);
              //Get Duration

              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

      	    pBuf->Data.wDurationID = pBuf->wDuration;
              //Get RTS Frame body
              pBuf->Data.wFrameControl = TYPE_CTL_RTS;//0x00B4
  
              if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
                  (pDevice->eOPMode == OP_MODE_AP)) {

                  memcpy(&(pBuf->Data.abyRA[0]), &(psEthHeader->abyDstAddr[0]), ETH_ALEN);

              }
              else {

                  memcpy(&(pBuf->Data.abyRA[0]), &(pDevice->abyBSSID[0]), ETH_ALEN);

              }
  
              if (pDevice->eOPMode == OP_MODE_AP) {

                  memcpy(&(pBuf->Data.abyTA[0]), &(pDevice->abyBSSID[0]), ETH_ALEN);

              }
              else {

                  memcpy(&(pBuf->Data.abyTA[0]), &(psEthHeader->abySrcAddr[0]), ETH_ALEN);

              }
  
          }
          else {
              PSRTS_a_FB pBuf = (PSRTS_a_FB)pvRTS;
              //Get SignalField,ServiceField,Length

              BBvCaculateParameter(pDevice, uRTSFrameLen, pDevice->byTopOFDMBasicRate, byPktType,

                  (unsigned short *)&(wLen), (unsigned char *)&(pBuf->byServiceField), (unsigned char *)&(pBuf->bySignalField)

              );
              pBuf->wTransmitLength = cpu_to_le16(wLen);
              //Get Duration

              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
      	    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
      	    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:

      	    pBuf->Data.wDurationID = pBuf->wDuration;
      	    //Get RTS Frame body
              pBuf->Data.wFrameControl = TYPE_CTL_RTS;//0x00B4
  
              if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
                  (pDevice->eOPMode == OP_MODE_AP)) {

                  memcpy(&(pBuf->Data.abyRA[0]), &(psEthHeader->abyDstAddr[0]), ETH_ALEN);

              }
              else {

                  memcpy(&(pBuf->Data.abyRA[0]), &(pDevice->abyBSSID[0]), ETH_ALEN);

              }
              if (pDevice->eOPMode == OP_MODE_AP) {

                  memcpy(&(pBuf->Data.abyTA[0]), &(pDevice->abyBSSID[0]), ETH_ALEN);

              }
              else {

                  memcpy(&(pBuf->Data.abyTA[0]), &(psEthHeader->abySrcAddr[0]), ETH_ALEN);

              }
          }
      }

      else if (byPktType == PK_TYPE_11B) {

          PSRTS_ab pBuf = (PSRTS_ab)pvRTS;
          //Get SignalField,ServiceField,Length
          BBvCaculateParameter(pDevice, uRTSFrameLen, pDevice->byTopCCKBasicRate, PK_TYPE_11B,

              (unsigned short *)&(wLen), (unsigned char *)&(pBuf->byServiceField), (unsigned char *)&(pBuf->bySignalField)

          );
          pBuf->wTransmitLength = cpu_to_le16(wLen);
          //Get Duration

          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

          pBuf->Data.wDurationID = pBuf->wDuration;
          //Get RTS Frame body
          pBuf->Data.wFrameControl = TYPE_CTL_RTS;//0x00B4
  
  
          if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
              (pDevice->eOPMode == OP_MODE_AP)) {

              memcpy(&(pBuf->Data.abyRA[0]), &(psEthHeader->abyDstAddr[0]), ETH_ALEN);

          }
          else {

              memcpy(&(pBuf->Data.abyRA[0]), &(pDevice->abyBSSID[0]), ETH_ALEN);

          }
  
          if (pDevice->eOPMode == OP_MODE_AP) {

              memcpy(&(pBuf->Data.abyTA[0]), &(pDevice->abyBSSID[0]), ETH_ALEN);

          }
          else {

              memcpy(&(pBuf->Data.abyTA[0]), &(psEthHeader->abySrcAddr[0]), ETH_ALEN);

          }
      }
  }
  
  static

  void

  s_vFillCTSHead (

      PSDevice pDevice,

      unsigned int uDMAIdx,

      unsigned char byPktType,

      void *   pvCTS,

      unsigned int cbFrameLength,

      bool bNeedAck,
      bool bDisCRC,

      unsigned short wCurrentRate,

      unsigned char byFBOption

      )
  {

      unsigned int uCTSFrameLen = 14;

      unsigned short wLen = 0x0000;

  
      if (pvCTS == NULL) {
          return;
      }
  
      if (bDisCRC) {
          // When CRCDIS bit is on, H/W forgot to generate FCS for CTS frame,
          // in this case we need to decrease its length by 4.
          uCTSFrameLen -= 4;
      }

      if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {

          if (byFBOption != AUTO_FB_NONE && uDMAIdx != TYPE_ATIMDMA && uDMAIdx != TYPE_BEACONDMA) {
              // Auto Fall back
              PSCTS_FB pBuf = (PSCTS_FB)pvCTS;
              //Get SignalField,ServiceField,Length
              BBvCaculateParameter(pDevice, uCTSFrameLen, pDevice->byTopCCKBasicRate, PK_TYPE_11B,

                  (unsigned short *)&(wLen), (unsigned char *)&(pBuf->byServiceField_b), (unsigned char *)&(pBuf->bySignalField_b)

              );
  
  
              pBuf->wTransmitLength_b = cpu_to_le16(wLen);

              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

              pBuf->wDuration_ba += pDevice->wCTSDuration;
              pBuf->wDuration_ba = cpu_to_le16(pBuf->wDuration_ba);
              //Get CTSDuration_ba_f0

              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

              pBuf->wCTSDuration_ba_f0 += pDevice->wCTSDuration;
              pBuf->wCTSDuration_ba_f0 = cpu_to_le16(pBuf->wCTSDuration_ba_f0);
              //Get CTSDuration_ba_f1

              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

              pBuf->wCTSDuration_ba_f1 += pDevice->wCTSDuration;
              pBuf->wCTSDuration_ba_f1 = cpu_to_le16(pBuf->wCTSDuration_ba_f1);
              //Get CTS Frame body
              pBuf->Data.wDurationID = pBuf->wDuration_ba;
              pBuf->Data.wFrameControl = TYPE_CTL_CTS;//0x00C4
              pBuf->Data.wReserved = 0x0000;

              memcpy(&(pBuf->Data.abyRA[0]), &(pDevice->abyCurrentNetAddr[0]), ETH_ALEN);

  
          } else { //if (byFBOption != AUTO_FB_NONE && uDMAIdx != TYPE_ATIMDMA && uDMAIdx != TYPE_BEACONDMA)
              PSCTS pBuf = (PSCTS)pvCTS;
              //Get SignalField,ServiceField,Length
              BBvCaculateParameter(pDevice, uCTSFrameLen, pDevice->byTopCCKBasicRate, PK_TYPE_11B,

                  (unsigned short *)&(wLen), (unsigned char *)&(pBuf->byServiceField_b), (unsigned char *)&(pBuf->bySignalField_b)

              );
              pBuf->wTransmitLength_b = cpu_to_le16(wLen);
              //Get CTSDuration_ba

              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

              pBuf->wDuration_ba += pDevice->wCTSDuration;
              pBuf->wDuration_ba = cpu_to_le16(pBuf->wDuration_ba);
  
              //Get CTS Frame body
              pBuf->Data.wDurationID = pBuf->wDuration_ba;
              pBuf->Data.wFrameControl = TYPE_CTL_CTS;//0x00C4
              pBuf->Data.wReserved = 0x0000;

              memcpy(&(pBuf->Data.abyRA[0]), &(pDevice->abyCurrentNetAddr[0]), ETH_ALEN);

          }
      }
  }
  
  
  
  
  
  
  /*+
   *
   * Description:
   *      Generate FIFO control for MAC & Baseband controller
   *
   * Parameters:
   *  In:

   *      pDevice         - Pointer to adapter

   *      pTxDataHead     - Transmit Data Buffer
   *      pTxBufHead      - pTxBufHead
   *      pvRrvTime        - pvRrvTime
   *      pvRTS            - RTS Buffer
   *      pCTS            - CTS Buffer
   *      cbFrameSize     - Transmit Data Length (Hdr+Payload+FCS)
   *      bNeedACK        - If need ACK
   *      uDescIdx        - Desc Index
   *  Out:
   *      none
   *
   * Return Value: none
   *
  -*/

  // unsigned int cbFrameSize,//Hdr+Payload+FCS

  static

  void

  s_vGenerateTxParameter (

      PSDevice         pDevice,

      unsigned char byPktType,

      void *           pTxBufHead,
      void *           pvRrvTime,
      void *           pvRTS,
      void *           pvCTS,

      unsigned int cbFrameSize,

      bool bNeedACK,

      unsigned int uDMAIdx,

      PSEthernetHeader psEthHeader,

      unsigned short wCurrentRate

      )
  {

      unsigned int cbMACHdLen = WLAN_HDR_ADDR3_LEN; //24

      unsigned short wFifoCtl;

      bool bDisCRC = false;

      unsigned char byFBOption = AUTO_FB_NONE;

  //    unsigned short wCurrentRate = pDevice->wCurrentRate;

      //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_vGenerateTxParameter...
  ");

      PSTxBufHead pFifoHead = (PSTxBufHead)pTxBufHead;
      pFifoHead->wReserved = wCurrentRate;
      wFifoCtl = pFifoHead->wFIFOCtl;
  
      if (wFifoCtl & FIFOCTL_CRCDIS) {

          bDisCRC = true;

      }
  
      if (wFifoCtl & FIFOCTL_AUTO_FB_0) {
          byFBOption = AUTO_FB_0;
      }
      else if (wFifoCtl & FIFOCTL_AUTO_FB_1) {
          byFBOption = AUTO_FB_1;
      }
  
      if (pDevice->bLongHeader)
          cbMACHdLen = WLAN_HDR_ADDR3_LEN + 6;

      if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {

  
          if (pvRTS != NULL) { //RTS_need
              //Fill RsvTime
              if (pvRrvTime) {
                  PSRrvTime_gRTS pBuf = (PSRrvTime_gRTS)pvRrvTime;

                  pBuf->wRTSTxRrvTime_aa = cpu_to_le16((unsigned short)s_uGetRTSCTSRsvTime(pDevice, 2, byPktType, cbFrameSize, wCurrentRate));//2:RTSTxRrvTime_aa, 1:2.4GHz
                  pBuf->wRTSTxRrvTime_ba = cpu_to_le16((unsigned short)s_uGetRTSCTSRsvTime(pDevice, 1, byPktType, cbFrameSize, wCurrentRate));//1:RTSTxRrvTime_ba, 1:2.4GHz
                  pBuf->wRTSTxRrvTime_bb = cpu_to_le16((unsigned short)s_uGetRTSCTSRsvTime(pDevice, 0, byPktType, cbFrameSize, wCurrentRate));//0:RTSTxRrvTime_bb, 1:2.4GHz
                  pBuf->wTxRrvTime_a = cpu_to_le16((unsigned short) s_uGetTxRsvTime(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK));//2.4G OFDM
                  pBuf->wTxRrvTime_b = cpu_to_le16((unsigned short) s_uGetTxRsvTime(pDevice, PK_TYPE_11B, cbFrameSize, pDevice->byTopCCKBasicRate, bNeedACK));//1:CCK

              }
              //Fill RTS

              s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);

          }
          else {//RTS_needless, PCF mode
  
              //Fill RsvTime
              if (pvRrvTime) {
                  PSRrvTime_gCTS pBuf = (PSRrvTime_gCTS)pvRrvTime;

                  pBuf->wTxRrvTime_a = cpu_to_le16((unsigned short)s_uGetTxRsvTime(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK));//2.4G OFDM
                  pBuf->wTxRrvTime_b = cpu_to_le16((unsigned short)s_uGetTxRsvTime(pDevice, PK_TYPE_11B, cbFrameSize, pDevice->byTopCCKBasicRate, bNeedACK));//1:CCK
                  pBuf->wCTSTxRrvTime_ba = cpu_to_le16((unsigned short)s_uGetRTSCTSRsvTime(pDevice, 3, byPktType, cbFrameSize, wCurrentRate));//3:CTSTxRrvTime_Ba, 1:2.4GHz

              }
  
  
              //Fill CTS

              s_vFillCTSHead(pDevice, uDMAIdx, byPktType, pvCTS, cbFrameSize, bNeedACK, bDisCRC, wCurrentRate, byFBOption);

          }
      }

      else if (byPktType == PK_TYPE_11A) {

  
          if (pvRTS != NULL) {//RTS_need, non PCF mode
              //Fill RsvTime
              if (pvRrvTime) {
                  PSRrvTime_ab pBuf = (PSRrvTime_ab)pvRrvTime;

                  pBuf->wRTSTxRrvTime = cpu_to_le16((unsigned short)s_uGetRTSCTSRsvTime(pDevice, 2, byPktType, cbFrameSize, wCurrentRate));//2:RTSTxRrvTime_aa, 0:5GHz
                  pBuf->wTxRrvTime = cpu_to_le16((unsigned short)s_uGetTxRsvTime(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK));//0:OFDM

              }
              //Fill RTS

              s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);

          }
          else if (pvRTS == NULL) {//RTS_needless, non PCF mode
              //Fill RsvTime
              if (pvRrvTime) {
                  PSRrvTime_ab pBuf = (PSRrvTime_ab)pvRrvTime;

                  pBuf->wTxRrvTime = cpu_to_le16((unsigned short)s_uGetTxRsvTime(pDevice, PK_TYPE_11A, cbFrameSize, wCurrentRate, bNeedACK)); //0:OFDM

              }
          }
      }

      else if (byPktType == PK_TYPE_11B) {

  
          if ((pvRTS != NULL)) {//RTS_need, non PCF mode
              //Fill RsvTime
              if (pvRrvTime) {
                  PSRrvTime_ab pBuf = (PSRrvTime_ab)pvRrvTime;

                  pBuf->wRTSTxRrvTime = cpu_to_le16((unsigned short)s_uGetRTSCTSRsvTime(pDevice, 0, byPktType, cbFrameSize, wCurrentRate));//0:RTSTxRrvTime_bb, 1:2.4GHz
                  pBuf->wTxRrvTime = cpu_to_le16((unsigned short)s_uGetTxRsvTime(pDevice, PK_TYPE_11B, cbFrameSize, wCurrentRate, bNeedACK));//1:CCK

              }
              //Fill RTS

              s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);

          }
          else { //RTS_needless, non PCF mode
              //Fill RsvTime
              if (pvRrvTime) {
                  PSRrvTime_ab pBuf = (PSRrvTime_ab)pvRrvTime;

                  pBuf->wTxRrvTime = cpu_to_le16((unsigned short)s_uGetTxRsvTime(pDevice, PK_TYPE_11B, cbFrameSize, wCurrentRate, bNeedACK)); //1:CCK

              }
          }
      }

      //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_vGenerateTxParameter END.
  ");

  }
  /*

      unsigned char *pbyBuffer,//point to pTxBufHead

      unsigned short wFragType,//00:Non-Frag, 01:Start, 02:Mid, 03:Last

      unsigned int cbFragmentSize,//Hdr+payoad+FCS

  */
  static

  void

  s_vFillFragParameter(

      PSDevice pDevice,

      unsigned char *pbyBuffer,

      unsigned int uTxType,

      void *   pvtdCurr,

      unsigned short wFragType,

      unsigned int cbReqCount

      )
  {
      PSTxBufHead pTxBufHead = (PSTxBufHead) pbyBuffer;

      //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_vFillFragParameter...
  ");

  
      if (uTxType == TYPE_SYNCDMA) {
          //PSTxSyncDesc ptdCurr = (PSTxSyncDesc)s_pvGetTxDescHead(pDevice, uTxType, uCurIdx);
          PSTxSyncDesc ptdCurr = (PSTxSyncDesc)pvtdCurr;
  
           //Set FIFOCtl & TimeStamp in TxSyncDesc
          ptdCurr->m_wFIFOCtl = pTxBufHead->wFIFOCtl;
          ptdCurr->m_wTimeStamp = pTxBufHead->wTimeStamp;
          //Set TSR1 & ReqCount in TxDescHead

          ptdCurr->m_td1TD1.wReqCount = cpu_to_le16((unsigned short)(cbReqCount));

          if (wFragType == FRAGCTL_ENDFRAG) { //Last Fragmentation
              ptdCurr->m_td1TD1.byTCR |= (TCR_STP | TCR_EDP | EDMSDU);
          }
          else {
              ptdCurr->m_td1TD1.byTCR |= (TCR_STP | TCR_EDP);
          }
      }
      else {
          //PSTxDesc ptdCurr = (PSTxDesc)s_pvGetTxDescHead(pDevice, uTxType, uCurIdx);
          PSTxDesc ptdCurr = (PSTxDesc)pvtdCurr;
          //Set TSR1 & ReqCount in TxDescHead

          ptdCurr->m_td1TD1.wReqCount = cpu_to_le16((unsigned short)(cbReqCount));

          if (wFragType == FRAGCTL_ENDFRAG) { //Last Fragmentation
              ptdCurr->m_td1TD1.byTCR |= (TCR_STP | TCR_EDP | EDMSDU);
          }
          else {
              ptdCurr->m_td1TD1.byTCR |= (TCR_STP | TCR_EDP);
          }
      }

      pTxBufHead->wFragCtl |= (unsigned short)wFragType;//0x0001; //0000 0000 0000 0001

      //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_vFillFragParameter END
  ");

  }

  static unsigned int
  s_cbFillTxBufHead(PSDevice pDevice, unsigned char byPktType, unsigned char *pbyTxBufferAddr,
  	unsigned int cbFrameBodySize, unsigned int uDMAIdx, PSTxDesc pHeadTD,

  	PSEthernetHeader psEthHeader, unsigned char *pPacket, bool bNeedEncrypt,

  	PSKeyItem pTransmitKey, unsigned int uNodeIndex, unsigned int *puMACfragNum)

  {

      unsigned int cbMACHdLen;
      unsigned int cbFrameSize;
      unsigned int cbFragmentSize; //Hdr+(IV)+payoad+(MIC)+(ICV)+FCS
      unsigned int cbFragPayloadSize;
      unsigned int cbLastFragmentSize; //Hdr+(IV)+payoad+(MIC)+(ICV)+FCS
      unsigned int cbLastFragPayloadSize;
      unsigned int uFragIdx;

      unsigned char *pbyPayloadHead;
      unsigned char *pbyIVHead;
      unsigned char *pbyMacHdr;

      unsigned short wFragType; //00:Non-Frag, 01:Start, 10:Mid, 11:Last

      unsigned int uDuration;

      unsigned char *pbyBuffer;

  //    unsigned int uKeyEntryIdx = NUM_KEY_ENTRY+1;

  //    unsigned char byKeySel = 0xFF;

      unsigned int cbIVlen = 0;
      unsigned int cbICVlen = 0;
      unsigned int cbMIClen = 0;
      unsigned int cbFCSlen = 4;
      unsigned int cb802_1_H_len = 0;
      unsigned int uLength = 0;
      unsigned int uTmpLen = 0;

  //    unsigned char abyTmp[8];

  //    unsigned long dwCRC;

      unsigned int cbMICHDR = 0;

      unsigned long dwMICKey0, dwMICKey1;
      unsigned long dwMIC_Priority;

      unsigned long *pdwMIC_L;
      unsigned long *pdwMIC_R;

      unsigned long dwSafeMIC_L, dwSafeMIC_R; //Fix "Last Frag Size" < "MIC length".

      bool bMIC2Frag = false;

      unsigned int uMICFragLen = 0;
      unsigned int uMACfragNum = 1;
      unsigned int uPadding = 0;
      unsigned int cbReqCount = 0;

      bool bNeedACK;
      bool bRTS;
      bool bIsAdhoc;

      unsigned char *pbyType;

      PSTxDesc       ptdCurr;
      PSTxBufHead    psTxBufHd = (PSTxBufHead) pbyTxBufferAddr;

  //    unsigned int tmpDescIdx;
      unsigned int cbHeaderLength = 0;

      void *         pvRrvTime;

      PSMICHDRHead   pMICHDR;

      void *         pvRTS;
      void *         pvCTS;
      void *         pvTxDataHd;

      unsigned short wTxBufSize;   // FFinfo size

      unsigned int uTotalCopyLength = 0;

      unsigned char byFBOption = AUTO_FB_NONE;

      bool bIsWEP256 = false;

      PSMgmtObject    pMgmt = pDevice->pMgmt;
  
  
      pvRrvTime = pMICHDR = pvRTS = pvCTS = pvTxDataHd = NULL;

      //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_cbFillTxBufHead...
  ");

      if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
          (pDevice->eOPMode == OP_MODE_AP)) {

  	if (is_multicast_ether_addr(&(psEthHeader->abyDstAddr[0])))

  		bNeedACK = false;

          else

              bNeedACK = true;
          bIsAdhoc = true;

      }
      else {
          // MSDUs in Infra mode always need ACK

          bNeedACK = true;

          bIsAdhoc = false;

      }
  
      if (pDevice->bLongHeader)
          cbMACHdLen = WLAN_HDR_ADDR3_LEN + 6;
      else
          cbMACHdLen = WLAN_HDR_ADDR3_LEN;

      if ((bNeedEncrypt == true) && (pTransmitKey != NULL)) {

          if (pTransmitKey->byCipherSuite == KEY_CTL_WEP) {
              cbIVlen = 4;
              cbICVlen = 4;
              if (pTransmitKey->uKeyLength == WLAN_WEP232_KEYLEN) {

                  bIsWEP256 = true;

              }
          }
          if (pTransmitKey->byCipherSuite == KEY_CTL_TKIP) {
              cbIVlen = 8;//IV+ExtIV
              cbMIClen = 8;
              cbICVlen = 4;
          }
          if (pTransmitKey->byCipherSuite == KEY_CTL_CCMP) {
              cbIVlen = 8;//RSN Header
              cbICVlen = 8;//MIC
              cbMICHDR = sizeof(SMICHDRHead);
          }
          if (pDevice->byLocalID > REV_ID_VT3253_A1) {
              //MAC Header should be padding 0 to DW alignment.
              uPadding = 4 - (cbMACHdLen%4);
              uPadding %= 4;
          }
      }
  
  
      cbFrameSize = cbMACHdLen + cbIVlen + (cbFrameBodySize + cbMIClen) + cbICVlen + cbFCSlen;

      if ((bNeedACK == false) ||

          (cbFrameSize < pDevice->wRTSThreshold) ||
          ((cbFrameSize >= pDevice->wFragmentationThreshold) && (pDevice->wFragmentationThreshold <= pDevice->wRTSThreshold))
          ) {

          bRTS = false;

      }
      else {

          bRTS = true;

          psTxBufHd->wFIFOCtl |= (FIFOCTL_RTS | FIFOCTL_LRETRY);
      }
      //
      // Use for AUTO FALL BACK
      //
      if (psTxBufHd->wFIFOCtl & FIFOCTL_AUTO_FB_0) {
          byFBOption = AUTO_FB_0;
      }
      else if (psTxBufHd->wFIFOCtl & FIFOCTL_AUTO_FB_1) {
          byFBOption = AUTO_FB_1;
      }
  
      //////////////////////////////////////////////////////
      //Set RrvTime/RTS/CTS Buffer
      wTxBufSize = sizeof(STxBufHead);

      if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {//802.11g packet

  
          if (byFBOption == AUTO_FB_NONE) {

              if (bRTS == true) {//RTS_need

                  pvRrvTime = (PSRrvTime_gRTS) (pbyTxBufferAddr + wTxBufSize);
                  pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS));
                  pvRTS = (PSRTS_g) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR);
                  pvCTS = NULL;
                  pvTxDataHd = (PSTxDataHead_g) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR + sizeof(SRTS_g));
                  cbHeaderLength = wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR + sizeof(SRTS_g) + sizeof(STxDataHead_g);
              }
              else { //RTS_needless
                  pvRrvTime = (PSRrvTime_gCTS) (pbyTxBufferAddr + wTxBufSize);
                  pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS));
                  pvRTS = NULL;
                  pvCTS = (PSCTS) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR);
                  pvTxDataHd = (PSTxDataHead_g) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS));
                  cbHeaderLength = wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS) + sizeof(STxDataHead_g);
              }
          } else {
              // Auto Fall Back

              if (bRTS == true) {//RTS_need

                  pvRrvTime = (PSRrvTime_gRTS) (pbyTxBufferAddr + wTxBufSize);
                  pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS));
                  pvRTS = (PSRTS_g_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR);
                  pvCTS = NULL;
                  pvTxDataHd = (PSTxDataHead_g_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR + sizeof(SRTS_g_FB));
                  cbHeaderLength = wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR + sizeof(SRTS_g_FB) + sizeof(STxDataHead_g_FB);
              }
              else { //RTS_needless
                  pvRrvTime = (PSRrvTime_gCTS) (pbyTxBufferAddr + wTxBufSize);
                  pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS));
                  pvRTS = NULL;
                  pvCTS = (PSCTS_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR);
                  pvTxDataHd = (PSTxDataHead_g_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS_FB));
                  cbHeaderLength = wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS_FB) + sizeof(STxDataHead_g_FB);
              }
          } // Auto Fall Back
      }
      else {//802.11a/b packet
  
          if (byFBOption == AUTO_FB_NONE) {

              if (bRTS == true) {

                  pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
                  pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
                  pvRTS = (PSRTS_ab) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR);
                  pvCTS = NULL;
                  pvTxDataHd = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize + sizeof(PSRrvTime_ab) + cbMICHDR + sizeof(SRTS_ab));
                  cbHeaderLength = wTxBufSize + sizeof(PSRrvTime_ab) + cbMICHDR + sizeof(SRTS_ab) + sizeof(STxDataHead_ab);
              }
              else { //RTS_needless, need MICHDR
                  pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
                  pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
                  pvRTS = NULL;
                  pvCTS = NULL;
                  pvTxDataHd = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR);
                  cbHeaderLength = wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR + sizeof(STxDataHead_ab);
              }
          } else {
              // Auto Fall Back

              if (bRTS == true) {//RTS_need

                  pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
                  pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
                  pvRTS = (PSRTS_a_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR);
                  pvCTS = NULL;
                  pvTxDataHd = (PSTxDataHead_a_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(PSRrvTime_ab) + cbMICHDR + sizeof(SRTS_a_FB));
                  cbHeaderLength = wTxBufSize + sizeof(PSRrvTime_ab) + cbMICHDR + sizeof(SRTS_a_FB) + sizeof(STxDataHead_a_FB);
              }
              else { //RTS_needless
                  pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
                  pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
                  pvRTS = NULL;
                  pvCTS = NULL;
                  pvTxDataHd = (PSTxDataHead_a_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR);
                  cbHeaderLength = wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR + sizeof(STxDataHead_a_FB);
              }
          } // Auto Fall Back
      }

      memset((void *)(pbyTxBufferAddr + wTxBufSize), 0, (cbHeaderLength - wTxBufSize));

  
  //////////////////////////////////////////////////////////////////

      if ((bNeedEncrypt == true) && (pTransmitKey != NULL) && (pTransmitKey->byCipherSuite == KEY_CTL_TKIP)) {

          if (pDevice->pMgmt->eAuthenMode == WMAC_AUTH_WPANONE) {

              dwMICKey0 = *(unsigned long *)(&pTransmitKey->abyKey[16]);
              dwMICKey1 = *(unsigned long *)(&pTransmitKey->abyKey[20]);

          }
          else if ((pTransmitKey->dwKeyIndex & AUTHENTICATOR_KEY) != 0) {

              dwMICKey0 = *(unsigned long *)(&pTransmitKey->abyKey[16]);
              dwMICKey1 = *(unsigned long *)(&pTransmitKey->abyKey[20]);

          }
          else {

              dwMICKey0 = *(unsigned long *)(&pTransmitKey->abyKey[24]);
              dwMICKey1 = *(unsigned long *)(&pTransmitKey->abyKey[28]);

          }
          // DO Software Michael
          MIC_vInit(dwMICKey0, dwMICKey1);

          MIC_vAppend((unsigned char *)&(psEthHeader->abyDstAddr[0]), 12);

          dwMIC_Priority = 0;

          MIC_vAppend((unsigned char *)&dwMIC_Priority, 4);

          DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MIC KEY: %lX, %lX
  ", dwMICKey0, dwMICKey1);

      }
  
  ///////////////////////////////////////////////////////////////////

      pbyMacHdr = (unsigned char *)(pbyTxBufferAddr + cbHeaderLength);
      pbyPayloadHead = (unsigned char *)(pbyMacHdr + cbMACHdLen + uPadding + cbIVlen);
      pbyIVHead = (unsigned char *)(pbyMacHdr + cbMACHdLen + uPadding);

      if ((cbFrameSize > pDevice->wFragmentationThreshold) && (bNeedACK == true) && (bIsWEP256 == false)) {

          // Fragmentation
          // FragThreshold = Fragment size(Hdr+(IV)+fragment payload+(MIC)+(ICV)+FCS)
          cbFragmentSize = pDevice->wFragmentationThreshold;
          cbFragPayloadSize = cbFragmentSize - cbMACHdLen - cbIVlen - cbICVlen - cbFCSlen;
          //FragNum = (FrameSize-(Hdr+FCS))/(Fragment Size -(Hrd+FCS)))

          uMACfragNum = (unsigned short) ((cbFrameBodySize + cbMIClen) / cbFragPayloadSize);

          cbLastFragPayloadSize = (cbFrameBodySize + cbMIClen) % cbFragPayloadSize;
          if (cbLastFragPayloadSize == 0) {
              cbLastFragPayloadSize = cbFragPayloadSize;
          } else {
              uMACfragNum++;
          }
          //[Hdr+(IV)+last fragment payload+(MIC)+(ICV)+FCS]
          cbLastFragmentSize = cbMACHdLen + cbLastFragPayloadSize + cbIVlen + cbICVlen + cbFCSlen;
  
          for (uFragIdx = 0; uFragIdx < uMACfragNum; uFragIdx ++) {
              if (uFragIdx == 0) {
                  //=========================
                  //    Start Fragmentation
                  //=========================

                  DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Start Fragmentation...
  ");

                  wFragType = FRAGCTL_STAFRAG;
  
  
                  //Fill FIFO,RrvTime,RTS,and CTS

                  s_vGenerateTxParameter(pDevice, byPktType, (void *)psTxBufHd, pvRrvTime, pvRTS, pvCTS,

                                         cbFragmentSize, bNeedACK, uDMAIdx, psEthHeader, pDevice->wCurrentRate);
                  //Fill DataHead

                  uDuration = s_uFillDataHead(pDevice, byPktType, pvTxDataHd, cbFragmentSize, uDMAIdx, bNeedACK,

                                              uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption, pDevice->wCurrentRate);
                  // Generate TX MAC Header

                  vGenerateMACHeader(pDevice, pbyMacHdr, (unsigned short)uDuration, psEthHeader, bNeedEncrypt,

                                     wFragType, uDMAIdx, uFragIdx);

                  if (bNeedEncrypt == true) {

                      //Fill TXKEY

                      s_vFillTxKey(pDevice, (unsigned char *)(psTxBufHd->adwTxKey), pbyIVHead, pTransmitKey,

                                   pbyMacHdr, (unsigned short)cbFragPayloadSize, (unsigned char *)pMICHDR);

                      //Fill IV(ExtIV,RSNHDR)
                      if (pDevice->bEnableHostWEP) {
                          pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16 = pTransmitKey->dwTSC47_16;
                          pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0 = pTransmitKey->wTSC15_0;
                      }
                  }
  
  
                  // 802.1H

                  if (ntohs(psEthHeader->wType) > ETH_DATA_LEN) {

                      if ((psEthHeader->wType == TYPE_PKT_IPX) ||
                          (psEthHeader->wType == cpu_to_le16(0xF380))) {

                          memcpy((unsigned char *) (pbyPayloadHead), &pDevice->abySNAP_Bridgetunnel[0], 6);

                      }
                      else {

                          memcpy((unsigned char *) (pbyPayloadHead), &pDevice->abySNAP_RFC1042[0], 6);

                      }

                      pbyType = (unsigned char *) (pbyPayloadHead + 6);

                      memcpy(pbyType, &(psEthHeader->wType), sizeof(unsigned short));

                      cb802_1_H_len = 8;
                  }
  
                  cbReqCount = cbHeaderLength + cbMACHdLen + uPadding + cbIVlen + cbFragPayloadSize;
                  //---------------------------
                  // S/W or H/W Encryption
                  //---------------------------
                  //Fill MICHDR
                  //if (pDevice->bAES) {

                  //    s_vFillMICHDR(pDevice, (unsigned char *)pMICHDR, pbyMacHdr, (unsigned short)cbFragPayloadSize);

                  //}

                  //cbReqCount += s_uDoEncryption(pDevice, psEthHeader, (void *)psTxBufHd, byKeySel,

                  //                                pbyPayloadHead, (unsigned short)cbFragPayloadSize, uDMAIdx);

                  //pbyBuffer = (unsigned char *)pDevice->aamTxBuf[uDMAIdx][uDescIdx].pbyVAddr;
                  pbyBuffer = (unsigned char *)pHeadTD->pTDInfo->buf;

  
                  uLength = cbHeaderLength + cbMACHdLen + uPadding + cbIVlen + cb802_1_H_len;
                  //copy TxBufferHeader + MacHeader to desc

                  memcpy(pbyBuffer, (void *)psTxBufHd, uLength);

  
                  // Copy the Packet into a tx Buffer

                  memcpy((pbyBuffer + uLength), (pPacket + 14), (cbFragPayloadSize - cb802_1_H_len));

  
  
                  uTotalCopyLength += cbFragPayloadSize - cb802_1_H_len;

                  if ((bNeedEncrypt == true) && (pTransmitKey != NULL) && (pTransmitKey->byCipherSuite == KEY_CTL_TKIP)) {

                      DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Start MIC: %d
  ", cbFragPayloadSize);

                      MIC_vAppend((pbyBuffer + uLength - cb802_1_H_len), cbFragPayloadSize);
  
                  }
  
                  //---------------------------
                  // S/W Encryption
                  //---------------------------
                  if ((pDevice->byLocalID <= REV_ID_VT3253_A1)) {
                      if (bNeedEncrypt) {

                          s_vSWencryption(pDevice, pTransmitKey, (pbyBuffer + uLength - cb802_1_H_len), (unsigned short)cbFragPayloadSize);

                          cbReqCount += cbICVlen;
                      }
                  }
  
                  ptdCurr = (PSTxDesc)pHeadTD;
                  //--------------------
                  //1.Set TSR1 & ReqCount in TxDescHead
                  //2.Set FragCtl in TxBufferHead
                  //3.Set Frame Control
                  //4.Set Sequence Control
                  //5.Get S/W generate FCS
                  //--------------------

                  s_vFillFragParameter(pDevice, pbyBuffer, uDMAIdx, (void *)ptdCurr, wFragType, cbReqCount);

  
                  ptdCurr->pTDInfo->dwReqCount = cbReqCount - uPadding;
                  ptdCurr->pTDInfo->dwHeaderLength = cbHeaderLength;
                  ptdCurr->pTDInfo->skb_dma = ptdCurr->pTDInfo->buf_dma;
                  ptdCurr->buff_addr = cpu_to_le32(ptdCurr->pTDInfo->skb_dma);
                  pDevice->iTDUsed[uDMAIdx]++;
                  pHeadTD = ptdCurr->next;
              }
              else if (uFragIdx == (uMACfragNum-1)) {
                  //=========================
                  //    Last Fragmentation
                  //=========================

                  DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Last Fragmentation...
  ");

                  //tmpDescIdx = (uDescIdx + uFragIdx) % pDevice->cbTD[uDMAIdx];
  
                  wFragType = FRAGCTL_ENDFRAG;
  
                  //Fill FIFO,RrvTime,RTS,and CTS

                  s_vGenerateTxParameter(pDevice, byPktType, (void *)psTxBufHd, pvRrvTime, pvRTS, pvCTS,

                                         cbLastFragmentSize, bNeedACK, uDMAIdx, psEthHeader, pDevice->wCurrentRate);
                  //Fill DataHead

                  uDuration = s_uFillDataHead(pDevice, byPktType, pvTxDataHd, cbLastFragmentSize, uDMAIdx, bNeedACK,

                                              uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption, pDevice->wCurrentRate);
  
                  // Generate TX MAC Header

                  vGenerateMACHeader(pDevice, pbyMacHdr, (unsigned short)uDuration, psEthHeader, bNeedEncrypt,

                                     wFragType, uDMAIdx, uFragIdx);

                  if (bNeedEncrypt == true) {

                      //Fill TXKEY

                      s_vFillTxKey(pDevice, (unsigned char *)(psTxBufHd->adwTxKey), pbyIVHead, pTransmitKey,

                                   pbyMacHdr, (unsigned short)cbLastFragPayloadSize, (unsigned char *)pMICHDR);

  
                      if (pDevice->bEnableHostWEP) {
                          pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16 = pTransmitKey->dwTSC47_16;
                          pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0 = pTransmitKey->wTSC15_0;
                      }
  
                  }
  
  
                  cbReqCount = cbHeaderLength + cbMACHdLen + uPadding + cbIVlen + cbLastFragPayloadSize;
                  //---------------------------
                  // S/W or H/W Encryption
                  //---------------------------

                  pbyBuffer = (unsigned char *)pHeadTD->pTDInfo->buf;
                  //pbyBuffer = (unsigned char *)pDevice->aamTxBuf[uDMAIdx][tmpDescIdx].pbyVAddr;

  
                  uLength = cbHeaderLength + cbMACHdLen + uPadding + cbIVlen;
  
                  //copy TxBufferHeader + MacHeader to desc

                  memcpy(pbyBuffer, (void *)psTxBufHd, uLength);

  
                  // Copy the Packet into a tx Buffer

                  if (bMIC2Frag == false) {

                      memcpy((pbyBuffer + uLength),

                               (pPacket + 14 + uTotalCopyLength),
                               (cbLastFragPayloadSize - cbMIClen)
                               );
                      //TODO check uTmpLen !
                      uTmpLen = cbLastFragPayloadSize - cbMIClen;
  
                  }

                  if ((bNeedEncrypt == true) && (pTransmitKey != NULL) && (pTransmitKey->byCipherSuite == KEY_CTL_TKIP)) {

                      DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"LAST: uMICFragLen:%d, cbLastFragPayloadSize:%d, uTmpLen:%d
  ",

                                     uMICFragLen, cbLastFragPayloadSize, uTmpLen);

                      if (bMIC2Frag == false) {

                          if (uTmpLen != 0)
                              MIC_vAppend((pbyBuffer + uLength), uTmpLen);

                          pdwMIC_L = (unsigned long *)(pbyBuffer + uLength + uTmpLen);
                          pdwMIC_R = (unsigned long *)(pbyBuffer + uLength + uTmpLen + 4);

                          MIC_vGetMIC(pdwMIC_L, pdwMIC_R);

                          DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Last MIC:%lX, %lX
  ", *pdwMIC_L, *pdwMIC_R);

                      } else {
                          if (uMICFragLen >= 4) {

                              memcpy((pbyBuffer + uLength), ((unsigned char *)&dwSafeMIC_R + (uMICFragLen - 4)),

                                       (cbMIClen - uMICFragLen));

                              DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"LAST: uMICFragLen >= 4: %X, %d
  ",

                                             *(unsigned char *)((unsigned char *)&dwSafeMIC_R + (uMICFragLen - 4)),

                                             (cbMIClen - uMICFragLen));
  
                          } else {

                              memcpy((pbyBuffer + uLength), ((unsigned char *)&dwSafeMIC_L + uMICFragLen),

                                       (4 - uMICFragLen));

                              memcpy((pbyBuffer + uLength + (4 - uMICFragLen)), &dwSafeMIC_R, 4);

                              DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"LAST: uMICFragLen < 4: %X, %d
  ",

                                             *(unsigned char *)((unsigned char *)&dwSafeMIC_R + uMICFragLen - 4),

                                             (cbMIClen - uMICFragLen));
                          }
                          /*
                          for (ii = 0; ii < cbLastFragPayloadSize + 8 + 24; ii++) {

                              DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"%02x ", *((unsigned char *)((pbyBuffer + uLength) + ii - 8 - 24)));

                          }

                          DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"
  
  ");

                          */
                      }
                      MIC_vUnInit();
                  } else {
                      ASSERT(uTmpLen == (cbLastFragPayloadSize - cbMIClen));
                  }
  
  
                  //---------------------------
                  // S/W Encryption
                  //---------------------------
                  if ((pDevice->byLocalID <= REV_ID_VT3253_A1)) {
                      if (bNeedEncrypt) {

                          s_vSWencryption(pDevice, pTransmitKey, (pbyBuffer + uLength), (unsigned short)cbLastFragPayloadSize);

                          cbReqCount += cbICVlen;
                      }
                  }
  
                  ptdCurr = (PSTxDesc)pHeadTD;
  
                  //--------------------
                  //1.Set TSR1 & ReqCount in TxDescHead
                  //2.Set FragCtl in TxBufferHead
                  //3.Set Frame Control
                  //4.Set Sequence Control
                  //5.Get S/W generate FCS
                  //--------------------

                  s_vFillFragParameter(pDevice, pbyBuffer, uDMAIdx, (void *)ptdCurr, wFragType, cbReqCount);

  
                  ptdCurr->pTDInfo->dwReqCount = cbReqCount - uPadding;
                  ptdCurr->pTDInfo->dwHeaderLength = cbHeaderLength;
                  ptdCurr->pTDInfo->skb_dma = ptdCurr->pTDInfo->buf_dma;
                  ptdCurr->buff_addr = cpu_to_le32(ptdCurr->pTDInfo->skb_dma);
                  pDevice->iTDUsed[uDMAIdx]++;
                  pHeadTD = ptdCurr->next;
  
              }
              else {
                  //=========================
                  //    Middle Fragmentation
                  //=========================

                  DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Middle Fragmentation...
  ");

                  //tmpDescIdx = (uDescIdx + uFragIdx) % pDevice->cbTD[uDMAIdx];
  
                  wFragType = FRAGCTL_MIDFRAG;
  
                  //Fill FIFO,RrvTime,RTS,and CTS

                  s_vGenerateTxParameter(pDevice, byPktType, (void *)psTxBufHd, pvRrvTime, pvRTS, pvCTS,

                                         cbFragmentSize, bNeedACK, uDMAIdx, psEthHeader, pDevice->wCurrentRate);
                  //Fill DataHead

                  uDuration = s_uFillDataHead(pDevice, byPktType, pvTxDataHd, cbFragmentSize, uDMAIdx, bNeedACK,

                                              uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption, pDevice->wCurrentRate);
  
                  // Generate TX MAC Header

                  vGenerateMACHeader(pDevice, pbyMacHdr, (unsigned short)uDuration, psEthHeader, bNeedEncrypt,

                                     wFragType, uDMAIdx, uFragIdx);

                  if (bNeedEncrypt == true) {

                      //Fill TXKEY

                      s_vFillTxKey(pDevice, (unsigned char *)(psTxBufHd->adwTxKey), pbyIVHead, pTransmitKey,

                                   pbyMacHdr, (unsigned short)cbFragPayloadSize, (unsigned char *)pMICHDR);