drivers/staging/vt6655/rxtx.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
   4  * All rights reserved.
   5  *
   6  * File: rxtx.c
   7  *
   8  * Purpose: handle WMAC/802.3/802.11 rx & tx functions
   9  *
  10  * Author: Lyndon Chen
  11  *
  12  * Date: May 20, 2003
  13  *
  14  * Functions:
  15  *      s_vGenerateTxParameter - Generate tx dma required parameter.
  16  *      vGenerateMACHeader - Translate 802.3 to 802.11 header
  17  *      cbGetFragCount - Calculate fragment number count
  18  *      csBeacon_xmit - beacon tx function
  19  *      csMgmt_xmit - management tx function
  20  *      s_cbFillTxBufHead - fulfill tx dma buffer header
  21  *      s_uGetDataDuration - get tx data required duration
  22  *      s_uFillDataHead- fulfill tx data duration header
  23  *      s_uGetRTSCTSDuration- get rtx/cts required duration
  24  *      s_uGetRTSCTSRsvTime- get rts/cts reserved time
  25  *      s_uGetTxRsvTime- get frame reserved time
  26  *      s_vFillCTSHead- fulfill CTS ctl header
  27  *      s_vFillFragParameter- Set fragment ctl parameter.
  28  *      s_vFillRTSHead- fulfill RTS ctl header
  29  *      s_vFillTxKey- fulfill tx encrypt key
  30  *      s_vSWencryption- Software encrypt header
  31  *      vDMA0_tx_80211- tx 802.11 frame via dma0
  32  *      vGenerateFIFOHeader- Generate tx FIFO ctl header
  33  *
  34  * Revision History:
  35  *
  36  */
  37
  38 #include "device.h"
  39 #include "rxtx.h"
  40 #include "card.h"
  41 #include "mac.h"
  42 #include "baseband.h"
  43 #include "rf.h"
  44
  45 /*---------------------  Static Definitions -------------------------*/
  46
  47 /*---------------------  Static Classes  ----------------------------*/
  48
  49 /*---------------------  Static Variables  --------------------------*/
  50
  51 /*---------------------  Static Functions  --------------------------*/
  52
  53 /*---------------------  Static Definitions -------------------------*/
  54 /* if packet size < 256 -> in-direct send
  55  * vpacket size >= 256 -> direct send
  56  */
  57 #define CRITICAL_PACKET_LEN      256
  58
  59 static const unsigned short wTimeStampOff[2][MAX_RATE] = {
  60         {384, 288, 226, 209, 54, 43, 37, 31, 28, 25, 24, 23}, /* Long Preamble */
  61         {384, 192, 130, 113, 54, 43, 37, 31, 28, 25, 24, 23}, /* Short Preamble */
  62 };
  63
  64 static const unsigned short wFB_Opt0[2][5] = {
  65         {RATE_12M, RATE_18M, RATE_24M, RATE_36M, RATE_48M}, /* fallback_rate0 */
  66         {RATE_12M, RATE_12M, RATE_18M, RATE_24M, RATE_36M}, /* fallback_rate1 */
  67 };
  68 static const unsigned short wFB_Opt1[2][5] = {
  69         {RATE_12M, RATE_18M, RATE_24M, RATE_24M, RATE_36M}, /* fallback_rate0 */
  70         {RATE_6M,  RATE_6M,  RATE_12M, RATE_12M, RATE_18M}, /* fallback_rate1 */
  71 };
  72
  73 #define RTSDUR_BB       0
  74 #define RTSDUR_BA       1
  75 #define RTSDUR_AA       2
  76 #define CTSDUR_BA       3
  77 #define RTSDUR_BA_F0    4
  78 #define RTSDUR_AA_F0    5
  79 #define RTSDUR_BA_F1    6
  80 #define RTSDUR_AA_F1    7
  81 #define CTSDUR_BA_F0    8
  82 #define CTSDUR_BA_F1    9
  83 #define DATADUR_B       10
  84 #define DATADUR_A       11
  85 #define DATADUR_A_F0    12
  86 #define DATADUR_A_F1    13
  87
  88 /*---------------------  Static Functions  --------------------------*/
  89 static
  90 void
  91 s_vFillRTSHead(
  92         struct vnt_private *pDevice,
  93         unsigned char byPktType,
  94         void *pvRTS,
  95         unsigned int    cbFrameLength,
  96         bool bNeedAck,
  97         bool bDisCRC,
  98         struct ieee80211_hdr *hdr,
  99         unsigned short wCurrentRate,
 100         unsigned char byFBOption
 101 );
 102
 103 static
 104 void
 105 s_vGenerateTxParameter(
 106         struct vnt_private *pDevice,
 107         unsigned char byPktType,
 108         struct vnt_tx_fifo_head *,
 109         void *pvRrvTime,
 110         void *pvRTS,
 111         void *pvCTS,
 112         unsigned int    cbFrameSize,
 113         bool bNeedACK,
 114         unsigned int    uDMAIdx,
 115         void *psEthHeader,
 116         unsigned short wCurrentRate
 117 );
 118
 119 static unsigned int
 120 s_cbFillTxBufHead(struct vnt_private *pDevice, unsigned char byPktType,
 121                   unsigned char *pbyTxBufferAddr,
 122                   unsigned int uDMAIdx, struct vnt_tx_desc *pHeadTD,
 123                   unsigned int uNodeIndex);
 124
 125 static
 126 __le16
 127 s_uFillDataHead(
 128         struct vnt_private *pDevice,
 129         unsigned char byPktType,
 130         void *pTxDataHead,
 131         unsigned int cbFrameLength,
 132         unsigned int uDMAIdx,
 133         bool bNeedAck,
 134         unsigned int uFragIdx,
 135         unsigned int cbLastFragmentSize,
 136         unsigned int uMACfragNum,
 137         unsigned char byFBOption,
 138         unsigned short wCurrentRate,
 139         bool is_pspoll
 140 );
 141
 142 /*---------------------  Export Variables  --------------------------*/
 143
 144 static __le16 vnt_time_stamp_off(struct vnt_private *priv, u16 rate)
 145 {
 146         return cpu_to_le16(wTimeStampOff[priv->byPreambleType % 2]
 147                                                         [rate % MAX_RATE]);
 148 }
 149
 150 /* byPktType : PK_TYPE_11A     0
 151  * PK_TYPE_11B     1
 152  * PK_TYPE_11GB    2
 153  * PK_TYPE_11GA    3
 154  */
 155 static
 156 unsigned int
 157 s_uGetTxRsvTime(
 158         struct vnt_private *pDevice,
 159         unsigned char byPktType,
 160         unsigned int cbFrameLength,
 161         unsigned short wRate,
 162         bool bNeedAck
 163 )
 164 {
 165         unsigned int uDataTime, uAckTime;
 166
 167         uDataTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, cbFrameLength, wRate);
 168         if (byPktType == PK_TYPE_11B) /* llb,CCK mode */
 169                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, (unsigned short)pDevice->byTopCCKBasicRate);
 170         else /* 11g 2.4G OFDM mode & 11a 5G OFDM mode */
 171                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, (unsigned short)pDevice->byTopOFDMBasicRate);
 172
 173         if (bNeedAck)
 174                 return uDataTime + pDevice->uSIFS + uAckTime;
 175         else
 176                 return uDataTime;
 177 }
 178
 179 static __le16 vnt_rxtx_rsvtime_le16(struct vnt_private *priv, u8 pkt_type,
 180                                     u32 frame_length, u16 rate, bool need_ack)
 181 {
 182         return cpu_to_le16((u16)s_uGetTxRsvTime(priv, pkt_type,
 183                                                 frame_length, rate, need_ack));
 184 }
 185
 186 /* byFreqType: 0=>5GHZ 1=>2.4GHZ */
 187 static
 188 __le16
 189 s_uGetRTSCTSRsvTime(
 190         struct vnt_private *pDevice,
 191         unsigned char byRTSRsvType,
 192         unsigned char byPktType,
 193         unsigned int cbFrameLength,
 194         unsigned short wCurrentRate
 195 )
 196 {
 197         unsigned int uRrvTime, uRTSTime, uCTSTime, uAckTime, uDataTime;
 198
 199         uRrvTime = uRTSTime = uCTSTime = uAckTime = uDataTime = 0;
 200
 201         uDataTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, cbFrameLength, wCurrentRate);
 202         if (byRTSRsvType == 0) { /* RTSTxRrvTime_bb */
 203                 uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopCCKBasicRate);
 204                 uCTSTime = uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 205         } else if (byRTSRsvType == 1) { /* RTSTxRrvTime_ba, only in 2.4GHZ */
 206                 uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopCCKBasicRate);
 207                 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 208                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 209         } else if (byRTSRsvType == 2) { /* RTSTxRrvTime_aa */
 210                 uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopOFDMBasicRate);
 211                 uCTSTime = uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 212         } else if (byRTSRsvType == 3) { /* CTSTxRrvTime_ba, only in 2.4GHZ */
 213                 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 214                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 215                 uRrvTime = uCTSTime + uAckTime + uDataTime + 2*pDevice->uSIFS;
 216                 return cpu_to_le16((u16)uRrvTime);
 217         }
 218
 219         /* RTSRrvTime */
 220         uRrvTime = uRTSTime + uCTSTime + uAckTime + uDataTime + 3*pDevice->uSIFS;
 221         return cpu_to_le16((u16)uRrvTime);
 222 }
 223
 224 /* byFreqType 0: 5GHz, 1:2.4Ghz */
 225 static
 226 unsigned int
 227 s_uGetDataDuration(
 228         struct vnt_private *pDevice,
 229         unsigned char byDurType,
 230         unsigned int cbFrameLength,
 231         unsigned char byPktType,
 232         unsigned short wRate,
 233         bool bNeedAck,
 234         unsigned int uFragIdx,
 235         unsigned int cbLastFragmentSize,
 236         unsigned int uMACfragNum,
 237         unsigned char byFBOption
 238 )
 239 {
 240         bool bLastFrag = false;
 241         unsigned int uAckTime = 0, uNextPktTime = 0;
 242
 243         if (uFragIdx == (uMACfragNum-1))
 244                 bLastFrag = true;
 245
 246         switch (byDurType) {
 247         case DATADUR_B:    /* DATADUR_B */
 248                 if (((uMACfragNum == 1)) || bLastFrag) {/* Non Frag or Last Frag */
 249                         if (bNeedAck) {
 250                                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 251                                 return pDevice->uSIFS + uAckTime;
 252                         } else {
 253                                 return 0;
 254                         }
 255                 } else {/* First Frag or Mid Frag */
 256                         if (uFragIdx == (uMACfragNum-2))
 257                                 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wRate, bNeedAck);
 258                         else
 259                                 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
 260
 261                         if (bNeedAck) {
 262                                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 263                                 return pDevice->uSIFS + uAckTime + uNextPktTime;
 264                         } else {
 265                                 return pDevice->uSIFS + uNextPktTime;
 266                         }
 267                 }
 268                 break;
 269
 270         case DATADUR_A:    /* DATADUR_A */
 271                 if (((uMACfragNum == 1)) || bLastFrag) {/* Non Frag or Last Frag */
 272                         if (bNeedAck) {
 273                                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 274                                 return pDevice->uSIFS + uAckTime;
 275                         } else {
 276                                 return 0;
 277                         }
 278                 } else {/* First Frag or Mid Frag */
 279                         if (uFragIdx == (uMACfragNum-2))
 280                                 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wRate, bNeedAck);
 281                         else
 282                                 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
 283
 284                         if (bNeedAck) {
 285                                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 286                                 return pDevice->uSIFS + uAckTime + uNextPktTime;
 287                         } else {
 288                                 return pDevice->uSIFS + uNextPktTime;
 289                         }
 290                 }
 291                 break;
 292
 293         case DATADUR_A_F0:    /* DATADUR_A_F0 */
 294                 if (((uMACfragNum == 1)) || bLastFrag) {/* Non Frag or Last Frag */
 295                         if (bNeedAck) {
 296                                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 297                                 return pDevice->uSIFS + uAckTime;
 298                         } else {
 299                                 return 0;
 300                         }
 301                 } else { /* First Frag or Mid Frag */
 302                         if (byFBOption == AUTO_FB_0) {
 303                                 if (wRate < RATE_18M)
 304                                         wRate = RATE_18M;
 305                                 else if (wRate > RATE_54M)
 306                                         wRate = RATE_54M;
 307
 308                                 if (uFragIdx == (uMACfragNum-2))
 309                                         uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
 310                                 else
 311                                         uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
 312
 313                         } else { /* (byFBOption == AUTO_FB_1) */
 314                                 if (wRate < RATE_18M)
 315                                         wRate = RATE_18M;
 316                                 else if (wRate > RATE_54M)
 317                                         wRate = RATE_54M;
 318
 319                                 if (uFragIdx == (uMACfragNum-2))
 320                                         uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
 321                                 else
 322                                         uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
 323                         }
 324
 325                         if (bNeedAck) {
 326                                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 327                                 return pDevice->uSIFS + uAckTime + uNextPktTime;
 328                         } else {
 329                                 return pDevice->uSIFS + uNextPktTime;
 330                         }
 331                 }
 332                 break;
 333
 334         case DATADUR_A_F1:    /* DATADUR_A_F1 */
 335                 if (((uMACfragNum == 1)) || bLastFrag) { /* Non Frag or Last Frag */
 336                         if (bNeedAck) {
 337                                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 338                                 return pDevice->uSIFS + uAckTime;
 339                         } else {
 340                                 return 0;
 341                         }
 342                 } else { /* First Frag or Mid Frag */
 343                         if (byFBOption == AUTO_FB_0) {
 344                                 if (wRate < RATE_18M)
 345                                         wRate = RATE_18M;
 346                                 else if (wRate > RATE_54M)
 347                                         wRate = RATE_54M;
 348
 349                                 if (uFragIdx == (uMACfragNum-2))
 350                                         uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
 351                                 else
 352                                         uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
 353
 354                         } else { /* (byFBOption == AUTO_FB_1) */
 355                                 if (wRate < RATE_18M)
 356                                         wRate = RATE_18M;
 357                                 else if (wRate > RATE_54M)
 358                                         wRate = RATE_54M;
 359
 360                                 if (uFragIdx == (uMACfragNum-2))
 361                                         uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
 362                                 else
 363                                         uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
 364                         }
 365                         if (bNeedAck) {
 366                                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 367                                 return pDevice->uSIFS + uAckTime + uNextPktTime;
 368                         } else {
 369                                 return pDevice->uSIFS + uNextPktTime;
 370                         }
 371                 }
 372                 break;
 373
 374         default:
 375                 break;
 376         }
 377
 378         return 0;
 379 }
 380
 381 /* byFreqType: 0=>5GHZ 1=>2.4GHZ */
 382 static
 383 __le16
 384 s_uGetRTSCTSDuration(
 385         struct vnt_private *pDevice,
 386         unsigned char byDurType,
 387         unsigned int cbFrameLength,
 388         unsigned char byPktType,
 389         unsigned short wRate,
 390         bool bNeedAck,
 391         unsigned char byFBOption
 392 )
 393 {
 394         unsigned int uCTSTime = 0, uDurTime = 0;
 395
 396         switch (byDurType) {
 397         case RTSDUR_BB:    /* RTSDuration_bb */
 398                 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 399                 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
 400                 break;
 401
 402         case RTSDUR_BA:    /* RTSDuration_ba */
 403                 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 404                 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
 405                 break;
 406
 407         case RTSDUR_AA:    /* RTSDuration_aa */
 408                 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 409                 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
 410                 break;
 411
 412         case CTSDUR_BA:    /* CTSDuration_ba */
 413                 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
 414                 break;
 415
 416         case RTSDUR_BA_F0: /* RTSDuration_ba_f0 */
 417                 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 418                 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
 419                         uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
 420                 else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
 421                         uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
 422
 423                 break;
 424
 425         case RTSDUR_AA_F0: /* RTSDuration_aa_f0 */
 426                 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 427                 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
 428                         uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
 429                 else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
 430                         uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
 431
 432                 break;
 433
 434         case RTSDUR_BA_F1: /* RTSDuration_ba_f1 */
 435                 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 436                 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
 437                         uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
 438                 else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
 439                         uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
 440
 441                 break;
 442
 443         case RTSDUR_AA_F1: /* RTSDuration_aa_f1 */
 444                 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 445                 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
 446                         uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
 447                 else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
 448                         uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
 449
 450                 break;
 451
 452         case CTSDUR_BA_F0: /* CTSDuration_ba_f0 */
 453                 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
 454                         uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
 455                 else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
 456                         uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
 457
 458                 break;
 459
 460         case CTSDUR_BA_F1: /* CTSDuration_ba_f1 */
 461                 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
 462                         uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
 463                 else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
 464                         uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
 465
 466                 break;
 467
 468         default:
 469                 break;
 470         }
 471
 472         return cpu_to_le16((u16)uDurTime);
 473 }
 474
 475 static
 476 __le16
 477 s_uFillDataHead(
 478         struct vnt_private *pDevice,
 479         unsigned char byPktType,
 480         void *pTxDataHead,
 481         unsigned int cbFrameLength,
 482         unsigned int uDMAIdx,
 483         bool bNeedAck,
 484         unsigned int uFragIdx,
 485         unsigned int cbLastFragmentSize,
 486         unsigned int uMACfragNum,
 487         unsigned char byFBOption,
 488         unsigned short wCurrentRate,
 489         bool is_pspoll
 490 )
 491 {
 492         if (!pTxDataHead)
 493                 return 0;
 494
 495         if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
 496                 if (byFBOption == AUTO_FB_NONE) {
 497                         struct vnt_tx_datahead_g *buf = pTxDataHead;
 498                         /* Get SignalField, ServiceField & Length */
 499                         vnt_get_phy_field(pDevice, cbFrameLength, wCurrentRate,
 500                                           byPktType, &buf->a);
 501
 502                         vnt_get_phy_field(pDevice, cbFrameLength,
 503                                           pDevice->byTopCCKBasicRate,
 504                                           PK_TYPE_11B, &buf->b);
 505
 506                         if (is_pspoll) {
 507                                 __le16 dur = cpu_to_le16(pDevice->current_aid | BIT(14) | BIT(15));
 508
 509                                 buf->duration_a = dur;
 510                                 buf->duration_b = dur;
 511                         } else {
 512                                 /* Get Duration and TimeStamp */
 513                                 buf->duration_a =
 514                                         cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength,
 515                                                                             byPktType, wCurrentRate, bNeedAck, uFragIdx,
 516                                                                             cbLastFragmentSize, uMACfragNum,
 517                                                                             byFBOption));
 518                                 buf->duration_b =
 519                                         cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength,
 520                                                                             PK_TYPE_11B, pDevice->byTopCCKBasicRate,
 521                                                                             bNeedAck, uFragIdx, cbLastFragmentSize,
 522                                                                             uMACfragNum, byFBOption));
 523                         }
 524
 525                         buf->time_stamp_off_a = vnt_time_stamp_off(pDevice, wCurrentRate);
 526                         buf->time_stamp_off_b = vnt_time_stamp_off(pDevice, pDevice->byTopCCKBasicRate);
 527
 528                         return buf->duration_a;
 529                 } else {
 530                         /* Auto Fallback */
 531                         struct vnt_tx_datahead_g_fb *buf = pTxDataHead;
 532                         /* Get SignalField, ServiceField & Length */
 533                         vnt_get_phy_field(pDevice, cbFrameLength, wCurrentRate,
 534                                           byPktType, &buf->a);
 535
 536                         vnt_get_phy_field(pDevice, cbFrameLength,
 537                                           pDevice->byTopCCKBasicRate,
 538                                           PK_TYPE_11B, &buf->b);
 539                         /* Get Duration and TimeStamp */
 540                         buf->duration_a = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
 541                                                                               wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption));
 542                         buf->duration_b = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength, PK_TYPE_11B,
 543                                                                                pDevice->byTopCCKBasicRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption));
 544                         buf->duration_a_f0 = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A_F0, cbFrameLength, byPktType,
 545                                                                                   wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption));
 546                         buf->duration_a_f1 = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A_F1, cbFrameLength, byPktType,
 547                                                                                  wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption));
 548
 549                         buf->time_stamp_off_a = vnt_time_stamp_off(pDevice, wCurrentRate);
 550                         buf->time_stamp_off_b = vnt_time_stamp_off(pDevice, pDevice->byTopCCKBasicRate);
 551
 552                         return buf->duration_a;
 553                 } /* if (byFBOption == AUTO_FB_NONE) */
 554         } else if (byPktType == PK_TYPE_11A) {
 555                 if (byFBOption != AUTO_FB_NONE) {
 556                         /* Auto Fallback */
 557                         struct vnt_tx_datahead_a_fb *buf = pTxDataHead;
 558                         /* Get SignalField, ServiceField & Length */
 559                         vnt_get_phy_field(pDevice, cbFrameLength, wCurrentRate,
 560                                           byPktType, &buf->a);
 561
 562                         /* Get Duration and TimeStampOff */
 563                         buf->duration = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
 564                                                                             wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption));
 565                         buf->duration_f0 = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A_F0, cbFrameLength, byPktType,
 566                                                                                wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption));
 567                         buf->duration_f1 = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A_F1, cbFrameLength, byPktType,
 568                                                                                 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption));
 569                         buf->time_stamp_off = vnt_time_stamp_off(pDevice, wCurrentRate);
 570                         return buf->duration;
 571                 } else {
 572                         struct vnt_tx_datahead_ab *buf = pTxDataHead;
 573                         /* Get SignalField, ServiceField & Length */
 574                         vnt_get_phy_field(pDevice, cbFrameLength, wCurrentRate,
 575                                           byPktType, &buf->ab);
 576
 577                         if (is_pspoll) {
 578                                 __le16 dur = cpu_to_le16(pDevice->current_aid | BIT(14) | BIT(15));
 579
 580                                 buf->duration = dur;
 581                         } else {
 582                                 /* Get Duration and TimeStampOff */
 583                                 buf->duration =
 584                                         cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
 585                                                                             wCurrentRate, bNeedAck, uFragIdx,
 586                                                                             cbLastFragmentSize, uMACfragNum,
 587                                                                             byFBOption));
 588                         }
 589
 590                         buf->time_stamp_off = vnt_time_stamp_off(pDevice, wCurrentRate);
 591                         return buf->duration;
 592                 }
 593         } else {
 594                 struct vnt_tx_datahead_ab *buf = pTxDataHead;
 595                 /* Get SignalField, ServiceField & Length */
 596                 vnt_get_phy_field(pDevice, cbFrameLength, wCurrentRate,
 597                                   byPktType, &buf->ab);
 598
 599                 if (is_pspoll) {
 600                         __le16 dur = cpu_to_le16(pDevice->current_aid | BIT(14) | BIT(15));
 601
 602                         buf->duration = dur;
 603                 } else {
 604                         /* Get Duration and TimeStampOff */
 605                         buf->duration =
 606                                 cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength, byPktType,
 607                                                                     wCurrentRate, bNeedAck, uFragIdx,
 608                                                                     cbLastFragmentSize, uMACfragNum,
 609                                                                     byFBOption));
 610                 }
 611
 612                 buf->time_stamp_off = vnt_time_stamp_off(pDevice, wCurrentRate);
 613                 return buf->duration;
 614         }
 615         return 0;
 616 }
 617
 618 static
 619 void
 620 s_vFillRTSHead(
 621         struct vnt_private *pDevice,
 622         unsigned char byPktType,
 623         void *pvRTS,
 624         unsigned int cbFrameLength,
 625         bool bNeedAck,
 626         bool bDisCRC,
 627         struct ieee80211_hdr *hdr,
 628         unsigned short wCurrentRate,
 629         unsigned char byFBOption
 630 )
 631 {
 632         unsigned int uRTSFrameLen = 20;
 633
 634         if (!pvRTS)
 635                 return;
 636
 637         if (bDisCRC) {
 638                 /* When CRCDIS bit is on, H/W forgot to generate FCS for
 639                  * RTS frame, in this case we need to decrease its length by 4.
 640                  */
 641                 uRTSFrameLen -= 4;
 642         }
 643
 644         /* Note: So far RTSHead doesn't appear in ATIM & Beacom DMA,
 645          * so we don't need to take them into account.
 646          * Otherwise, we need to modify codes for them.
 647          */
 648         if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
 649                 if (byFBOption == AUTO_FB_NONE) {
 650                         struct vnt_rts_g *buf = pvRTS;
 651                         /* Get SignalField, ServiceField & Length */
 652                         vnt_get_phy_field(pDevice, uRTSFrameLen,
 653                                           pDevice->byTopCCKBasicRate,
 654                                           PK_TYPE_11B, &buf->b);
 655
 656                         vnt_get_phy_field(pDevice, uRTSFrameLen,
 657                                           pDevice->byTopOFDMBasicRate,
 658                                           byPktType, &buf->a);
 659                         /* Get Duration */
 660                         buf->duration_bb =
 661                                 s_uGetRTSCTSDuration(pDevice, RTSDUR_BB,
 662                                                      cbFrameLength, PK_TYPE_11B,
 663                                                      pDevice->byTopCCKBasicRate,
 664                                                      bNeedAck, byFBOption);
 665                         buf->duration_aa =
 666                                 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA,
 667                                                      cbFrameLength, byPktType,
 668                                                      wCurrentRate, bNeedAck,
 669                                                      byFBOption);
 670                         buf->duration_ba =
 671                                 s_uGetRTSCTSDuration(pDevice, RTSDUR_BA,
 672                                                      cbFrameLength, byPktType,
 673                                                      wCurrentRate, bNeedAck,
 674                                                      byFBOption);
 675
 676                         buf->data.duration = buf->duration_aa;
 677                         /* Get RTS Frame body */
 678                         buf->data.frame_control =
 679                                         cpu_to_le16(IEEE80211_FTYPE_CTL |
 680                                                     IEEE80211_STYPE_RTS);
 681
 682                         ether_addr_copy(buf->data.ra, hdr->addr1);
 683                         ether_addr_copy(buf->data.ta, hdr->addr2);
 684                 } else {
 685                         struct vnt_rts_g_fb *buf = pvRTS;
 686                         /* Get SignalField, ServiceField & Length */
 687                         vnt_get_phy_field(pDevice, uRTSFrameLen,
 688                                           pDevice->byTopCCKBasicRate,
 689                                           PK_TYPE_11B, &buf->b);
 690
 691                         vnt_get_phy_field(pDevice, uRTSFrameLen,
 692                                           pDevice->byTopOFDMBasicRate,
 693                                           byPktType, &buf->a);
 694                         /* Get Duration */
 695                         buf->duration_bb =
 696                                 s_uGetRTSCTSDuration(pDevice, RTSDUR_BB,
 697                                                      cbFrameLength, PK_TYPE_11B,
 698                                                      pDevice->byTopCCKBasicRate,
 699                                                      bNeedAck, byFBOption);
 700                         buf->duration_aa =
 701                                 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA,
 702                                                      cbFrameLength, byPktType,
 703                                                      wCurrentRate, bNeedAck,
 704                                                      byFBOption);
 705                         buf->duration_ba =
 706                                 s_uGetRTSCTSDuration(pDevice, RTSDUR_BA,
 707                                                      cbFrameLength, byPktType,
 708                                                      wCurrentRate, bNeedAck,
 709                                                      byFBOption);
 710                         buf->rts_duration_ba_f0 =
 711                                 s_uGetRTSCTSDuration(pDevice, RTSDUR_BA_F0,
 712                                                      cbFrameLength, byPktType,
 713                                                      wCurrentRate, bNeedAck,
 714                                                      byFBOption);
 715                         buf->rts_duration_aa_f0 =
 716                                 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F0,
 717                                                      cbFrameLength, byPktType,
 718                                                      wCurrentRate, bNeedAck,
 719                                                      byFBOption);
 720                         buf->rts_duration_ba_f1 =
 721                                 s_uGetRTSCTSDuration(pDevice, RTSDUR_BA_F1,
 722                                                      cbFrameLength, byPktType,
 723                                                      wCurrentRate, bNeedAck,
 724                                                      byFBOption);
 725                         buf->rts_duration_aa_f1 =
 726                                 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F1,
 727                                                      cbFrameLength, byPktType,
 728                                                      wCurrentRate, bNeedAck,
 729                                                      byFBOption);
 730                         buf->data.duration = buf->duration_aa;
 731                         /* Get RTS Frame body */
 732                         buf->data.frame_control =
 733                                         cpu_to_le16(IEEE80211_FTYPE_CTL |
 734                                                     IEEE80211_STYPE_RTS);
 735
 736                         ether_addr_copy(buf->data.ra, hdr->addr1);
 737                         ether_addr_copy(buf->data.ta, hdr->addr2);
 738                 } /* if (byFBOption == AUTO_FB_NONE) */
 739         } else if (byPktType == PK_TYPE_11A) {
 740                 if (byFBOption == AUTO_FB_NONE) {
 741                         struct vnt_rts_ab *buf = pvRTS;
 742                         /* Get SignalField, ServiceField & Length */
 743                         vnt_get_phy_field(pDevice, uRTSFrameLen,
 744                                           pDevice->byTopOFDMBasicRate,
 745                                           byPktType, &buf->ab);
 746                         /* Get Duration */
 747                         buf->duration =
 748                                 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA,
 749                                                      cbFrameLength, byPktType,
 750                                                      wCurrentRate, bNeedAck,
 751                                                      byFBOption);
 752                         buf->data.duration = buf->duration;
 753                         /* Get RTS Frame body */
 754                         buf->data.frame_control =
 755                                         cpu_to_le16(IEEE80211_FTYPE_CTL |
 756                                                     IEEE80211_STYPE_RTS);
 757
 758                         ether_addr_copy(buf->data.ra, hdr->addr1);
 759                         ether_addr_copy(buf->data.ta, hdr->addr2);
 760                 } else {
 761                         struct vnt_rts_a_fb *buf = pvRTS;
 762                         /* Get SignalField, ServiceField & Length */
 763                         vnt_get_phy_field(pDevice, uRTSFrameLen,
 764                                           pDevice->byTopOFDMBasicRate,
 765                                           byPktType, &buf->a);
 766                         /* Get Duration */
 767                         buf->duration =
 768                                 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA,
 769                                                      cbFrameLength, byPktType,
 770                                                      wCurrentRate, bNeedAck,
 771                                                      byFBOption);
 772                         buf->rts_duration_f0 =
 773                                 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F0,
 774                                                      cbFrameLength, byPktType,
 775                                                      wCurrentRate, bNeedAck,
 776                                                      byFBOption);
 777                         buf->rts_duration_f1 =
 778                                 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F1,
 779                                                      cbFrameLength, byPktType,
 780                                                      wCurrentRate, bNeedAck,
 781                                                      byFBOption);
 782                         buf->data.duration = buf->duration;
 783                         /* Get RTS Frame body */
 784                         buf->data.frame_control =
 785                                         cpu_to_le16(IEEE80211_FTYPE_CTL |
 786                                                     IEEE80211_STYPE_RTS);
 787
 788                         ether_addr_copy(buf->data.ra, hdr->addr1);
 789                         ether_addr_copy(buf->data.ta, hdr->addr2);
 790                 }
 791         } else if (byPktType == PK_TYPE_11B) {
 792                 struct vnt_rts_ab *buf = pvRTS;
 793                 /* Get SignalField, ServiceField & Length */
 794                 vnt_get_phy_field(pDevice, uRTSFrameLen,
 795                                   pDevice->byTopCCKBasicRate,
 796                                   PK_TYPE_11B, &buf->ab);
 797                 /* Get Duration */
 798                 buf->duration =
 799                         s_uGetRTSCTSDuration(pDevice, RTSDUR_BB, cbFrameLength,
 800                                              byPktType, wCurrentRate, bNeedAck,
 801                                              byFBOption);
 802
 803                 buf->data.duration = buf->duration;
 804                 /* Get RTS Frame body */
 805                 buf->data.frame_control =
 806                         cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_RTS);
 807
 808                 ether_addr_copy(buf->data.ra, hdr->addr1);
 809                 ether_addr_copy(buf->data.ta, hdr->addr2);
 810         }
 811 }
 812
 813 static
 814 void
 815 s_vFillCTSHead(
 816         struct vnt_private *pDevice,
 817         unsigned int uDMAIdx,
 818         unsigned char byPktType,
 819         void *pvCTS,
 820         unsigned int cbFrameLength,
 821         bool bNeedAck,
 822         bool bDisCRC,
 823         unsigned short wCurrentRate,
 824         unsigned char byFBOption
 825 )
 826 {
 827         unsigned int uCTSFrameLen = 14;
 828
 829         if (!pvCTS)
 830                 return;
 831
 832         if (bDisCRC) {
 833                 /* When CRCDIS bit is on, H/W forgot to generate FCS for
 834                  * CTS frame, in this case we need to decrease its length by 4.
 835                  */
 836                 uCTSFrameLen -= 4;
 837         }
 838
 839         if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
 840                 if (byFBOption != AUTO_FB_NONE && uDMAIdx != TYPE_ATIMDMA && uDMAIdx != TYPE_BEACONDMA) {
 841                         /* Auto Fall back */
 842                         struct vnt_cts_fb *buf = pvCTS;
 843                         /* Get SignalField, ServiceField & Length */
 844                         vnt_get_phy_field(pDevice, uCTSFrameLen,
 845                                           pDevice->byTopCCKBasicRate,
 846                                           PK_TYPE_11B, &buf->b);
 847
 848                         buf->duration_ba =
 849                                 s_uGetRTSCTSDuration(pDevice, CTSDUR_BA,
 850                                                      cbFrameLength, byPktType,
 851                                                      wCurrentRate, bNeedAck,
 852                                                      byFBOption);
 853
 854                         /* Get CTSDuration_ba_f0 */
 855                         buf->cts_duration_ba_f0 =
 856                                 s_uGetRTSCTSDuration(pDevice, CTSDUR_BA_F0,
 857                                                      cbFrameLength, byPktType,
 858                                                      wCurrentRate, bNeedAck,
 859                                                      byFBOption);
 860
 861                         /* Get CTSDuration_ba_f1 */
 862                         buf->cts_duration_ba_f1 =
 863                                 s_uGetRTSCTSDuration(pDevice, CTSDUR_BA_F1,
 864                                                      cbFrameLength, byPktType,
 865                                                      wCurrentRate, bNeedAck,
 866                                                      byFBOption);
 867
 868                         /* Get CTS Frame body */
 869                         buf->data.duration = buf->duration_ba;
 870
 871                         buf->data.frame_control =
 872                                 cpu_to_le16(IEEE80211_FTYPE_CTL |
 873                                             IEEE80211_STYPE_CTS);
 874
 875                         buf->reserved2 = 0x0;
 876
 877                         ether_addr_copy(buf->data.ra,
 878                                         pDevice->abyCurrentNetAddr);
 879                 } else { /* if (byFBOption != AUTO_FB_NONE && uDMAIdx != TYPE_ATIMDMA && uDMAIdx != TYPE_BEACONDMA) */
 880                         struct vnt_cts *buf = pvCTS;
 881                         /* Get SignalField, ServiceField & Length */
 882                         vnt_get_phy_field(pDevice, uCTSFrameLen,
 883                                           pDevice->byTopCCKBasicRate,
 884                                           PK_TYPE_11B, &buf->b);
 885
 886                         /* Get CTSDuration_ba */
 887                         buf->duration_ba =
 888                                 s_uGetRTSCTSDuration(pDevice, CTSDUR_BA,
 889                                                      cbFrameLength, byPktType,
 890                                                      wCurrentRate, bNeedAck,
 891                                                      byFBOption);
 892
 893                         /* Get CTS Frame body */
 894                         buf->data.duration = buf->duration_ba;
 895
 896                         buf->data.frame_control =
 897                                 cpu_to_le16(IEEE80211_FTYPE_CTL |
 898                                             IEEE80211_STYPE_CTS);
 899
 900                         buf->reserved2 = 0x0;
 901                         ether_addr_copy(buf->data.ra,
 902                                         pDevice->abyCurrentNetAddr);
 903                 }
 904         }
 905 }
 906
 907 /*
 908  *
 909  * Description:
 910  *      Generate FIFO control for MAC & Baseband controller
 911  *
 912  * Parameters:
 913  *  In:
 914  *      pDevice         - Pointer to adapter
 915  *      pTxDataHead     - Transmit Data Buffer
 916  *      pTxBufHead      - pTxBufHead
 917  *      pvRrvTime        - pvRrvTime
 918  *      pvRTS            - RTS Buffer
 919  *      pCTS            - CTS Buffer
 920  *      cbFrameSize     - Transmit Data Length (Hdr+Payload+FCS)
 921  *      bNeedACK        - If need ACK
 922  *      uDescIdx        - Desc Index
 923  *  Out:
 924  *      none
 925  *
 926  * Return Value: none
 927  *
 928  -
 929  * unsigned int cbFrameSize, Hdr+Payload+FCS
 930  */
 931 static
 932 void
 933 s_vGenerateTxParameter(
 934         struct vnt_private *pDevice,
 935         unsigned char byPktType,
 936         struct vnt_tx_fifo_head *tx_buffer_head,
 937         void *pvRrvTime,
 938         void *pvRTS,
 939         void *pvCTS,
 940         unsigned int cbFrameSize,
 941         bool bNeedACK,
 942         unsigned int uDMAIdx,
 943         void *psEthHeader,
 944         unsigned short wCurrentRate
 945 )
 946 {
 947         u16 fifo_ctl = le16_to_cpu(tx_buffer_head->fifo_ctl);
 948         bool bDisCRC = false;
 949         unsigned char byFBOption = AUTO_FB_NONE;
 950
 951         tx_buffer_head->current_rate = cpu_to_le16(wCurrentRate);
 952
 953         if (fifo_ctl & FIFOCTL_CRCDIS)
 954                 bDisCRC = true;
 955
 956         if (fifo_ctl & FIFOCTL_AUTO_FB_0)
 957                 byFBOption = AUTO_FB_0;
 958         else if (fifo_ctl & FIFOCTL_AUTO_FB_1)
 959                 byFBOption = AUTO_FB_1;
 960
 961         if (!pvRrvTime)
 962                 return;
 963
 964         if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
 965                 if (pvRTS) { /* RTS_need */
 966                         /* Fill RsvTime */
 967                         struct vnt_rrv_time_rts *buf = pvRrvTime;
 968
 969                         buf->rts_rrv_time_aa = s_uGetRTSCTSRsvTime(pDevice, 2, byPktType, cbFrameSize, wCurrentRate);
 970                         buf->rts_rrv_time_ba = s_uGetRTSCTSRsvTime(pDevice, 1, byPktType, cbFrameSize, wCurrentRate);
 971                         buf->rts_rrv_time_bb = s_uGetRTSCTSRsvTime(pDevice, 0, byPktType, cbFrameSize, wCurrentRate);
 972                         buf->rrv_time_a = vnt_rxtx_rsvtime_le16(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK);
 973                         buf->rrv_time_b = vnt_rxtx_rsvtime_le16(pDevice, PK_TYPE_11B, cbFrameSize, pDevice->byTopCCKBasicRate, bNeedACK);
 974
 975                         s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);
 976                 } else {/* RTS_needless, PCF mode */
 977                         struct vnt_rrv_time_cts *buf = pvRrvTime;
 978
 979                         buf->rrv_time_a = vnt_rxtx_rsvtime_le16(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK);
 980                         buf->rrv_time_b = vnt_rxtx_rsvtime_le16(pDevice, PK_TYPE_11B, cbFrameSize, pDevice->byTopCCKBasicRate, bNeedACK);
 981                         buf->cts_rrv_time_ba = s_uGetRTSCTSRsvTime(pDevice, 3, byPktType, cbFrameSize, wCurrentRate);
 982
 983                         /* Fill CTS */
 984                         s_vFillCTSHead(pDevice, uDMAIdx, byPktType, pvCTS, cbFrameSize, bNeedACK, bDisCRC, wCurrentRate, byFBOption);
 985                 }
 986         } else if (byPktType == PK_TYPE_11A) {
 987                 if (pvRTS) {/* RTS_need, non PCF mode */
 988                         struct vnt_rrv_time_ab *buf = pvRrvTime;
 989
 990                         buf->rts_rrv_time = s_uGetRTSCTSRsvTime(pDevice, 2, byPktType, cbFrameSize, wCurrentRate);
 991                         buf->rrv_time = vnt_rxtx_rsvtime_le16(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK);
 992
 993                         /* Fill RTS */
 994                         s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);
 995                 } else if (!pvRTS) {/* RTS_needless, non PCF mode */
 996                         struct vnt_rrv_time_ab *buf = pvRrvTime;
 997
 998                         buf->rrv_time = vnt_rxtx_rsvtime_le16(pDevice, PK_TYPE_11A, cbFrameSize, wCurrentRate, bNeedACK);
 999                 }
1000         } else if (byPktType == PK_TYPE_11B) {
1001                 if (pvRTS) {/* RTS_need, non PCF mode */
1002                         struct vnt_rrv_time_ab *buf = pvRrvTime;
1003
1004                         buf->rts_rrv_time = s_uGetRTSCTSRsvTime(pDevice, 0, byPktType, cbFrameSize, wCurrentRate);
1005                         buf->rrv_time = vnt_rxtx_rsvtime_le16(pDevice, PK_TYPE_11B, cbFrameSize, wCurrentRate, bNeedACK);
1006
1007                         /* Fill RTS */
1008                         s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);
1009                 } else { /* RTS_needless, non PCF mode */
1010                         struct vnt_rrv_time_ab *buf = pvRrvTime;
1011
1012                         buf->rrv_time = vnt_rxtx_rsvtime_le16(pDevice, PK_TYPE_11B, cbFrameSize, wCurrentRate, bNeedACK);
1013                 }
1014         }
1015 }
1016
1017 static unsigned int
1018 s_cbFillTxBufHead(struct vnt_private *pDevice, unsigned char byPktType,
1019                   unsigned char *pbyTxBufferAddr,
1020                   unsigned int uDMAIdx, struct vnt_tx_desc *pHeadTD,
1021                   unsigned int is_pspoll)
1022 {
1023         struct vnt_td_info *td_info = pHeadTD->td_info;
1024         struct sk_buff *skb = td_info->skb;
1025         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1026         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1027         struct vnt_tx_fifo_head *tx_buffer_head =
1028                         (struct vnt_tx_fifo_head *)td_info->buf;
1029         u16 fifo_ctl = le16_to_cpu(tx_buffer_head->fifo_ctl);
1030         unsigned int cbFrameSize;
1031         __le16 uDuration;
1032         unsigned char *pbyBuffer;
1033         unsigned int uLength = 0;
1034         unsigned int cbMICHDR = 0;
1035         unsigned int uMACfragNum = 1;
1036         unsigned int uPadding = 0;
1037         unsigned int cbReqCount = 0;
1038         bool bNeedACK = (bool)(fifo_ctl & FIFOCTL_NEEDACK);
1039         bool bRTS = (bool)(fifo_ctl & FIFOCTL_RTS);
1040         struct vnt_tx_desc *ptdCurr;
1041         unsigned int cbHeaderLength = 0;
1042         void *pvRrvTime;
1043         struct vnt_mic_hdr *pMICHDR;
1044         void *pvRTS;
1045         void *pvCTS;
1046         void *pvTxDataHd;
1047         unsigned short wTxBufSize;   /* FFinfo size */
1048         unsigned char byFBOption = AUTO_FB_NONE;
1049
1050         pvRrvTime = pMICHDR = pvRTS = pvCTS = pvTxDataHd = NULL;
1051
1052         cbFrameSize = skb->len + 4;
1053
1054         if (info->control.hw_key) {
1055                 switch (info->control.hw_key->cipher) {
1056                 case WLAN_CIPHER_SUITE_CCMP:
1057                         cbMICHDR = sizeof(struct vnt_mic_hdr);
1058                 default:
1059                         break;
1060                 }
1061
1062                 cbFrameSize += info->control.hw_key->icv_len;
1063
1064                 if (pDevice->byLocalID > REV_ID_VT3253_A1) {
1065                         /* MAC Header should be padding 0 to DW alignment. */
1066                         uPadding = 4 - (ieee80211_get_hdrlen_from_skb(skb) % 4);
1067                         uPadding %= 4;
1068                 }
1069         }
1070
1071         /*
1072          * Use for AUTO FALL BACK
1073          */
1074         if (fifo_ctl & FIFOCTL_AUTO_FB_0)
1075                 byFBOption = AUTO_FB_0;
1076         else if (fifo_ctl & FIFOCTL_AUTO_FB_1)
1077                 byFBOption = AUTO_FB_1;
1078
1079         /* Set RrvTime/RTS/CTS Buffer */
1080         wTxBufSize = sizeof(struct vnt_tx_fifo_head);
1081         if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {/* 802.11g packet */
1082
1083                 if (byFBOption == AUTO_FB_NONE) {
1084                         if (bRTS) {/* RTS_need */
1085                                 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize);
1086                                 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_rts));
1087                                 pvRTS = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_rts) + cbMICHDR);
1088                                 pvCTS = NULL;
1089                                 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_rts) +
1090                                                         cbMICHDR + sizeof(struct vnt_rts_g));
1091                                 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_rts) +
1092                                                         cbMICHDR + sizeof(struct vnt_rts_g) +
1093                                                         sizeof(struct vnt_tx_datahead_g);
1094                         } else { /* RTS_needless */
1095                                 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize);
1096                                 pMICHDR = (struct vnt_mic_hdr *) (pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_cts));
1097                                 pvRTS = NULL;
1098                                 pvCTS = (void *) (pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_cts) + cbMICHDR);
1099                                 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize +
1100                                                 sizeof(struct vnt_rrv_time_cts) + cbMICHDR + sizeof(struct vnt_cts));
1101                                 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_cts) +
1102                                                         cbMICHDR + sizeof(struct vnt_cts) + sizeof(struct vnt_tx_datahead_g);
1103                         }
1104                 } else {
1105                         /* Auto Fall Back */
1106                         if (bRTS) {/* RTS_need */
1107                                 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize);
1108                                 pMICHDR = (struct vnt_mic_hdr *) (pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_rts));
1109                                 pvRTS = (void *) (pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_rts) + cbMICHDR);
1110                                 pvCTS = NULL;
1111                                 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_rts) +
1112                                         cbMICHDR + sizeof(struct vnt_rts_g_fb));
1113                                 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_rts) +
1114                                         cbMICHDR + sizeof(struct vnt_rts_g_fb) + sizeof(struct vnt_tx_datahead_g_fb);
1115                         } else { /* RTS_needless */
1116                                 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize);
1117                                 pMICHDR = (struct vnt_mic_hdr *) (pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_cts));
1118                                 pvRTS = NULL;
1119                                 pvCTS = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_cts) + cbMICHDR);
1120                                 pvTxDataHd = (void  *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_cts) +
1121                                         cbMICHDR + sizeof(struct vnt_cts_fb));
1122                                 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_cts) +
1123                                         cbMICHDR + sizeof(struct vnt_cts_fb) + sizeof(struct vnt_tx_datahead_g_fb);
1124                         }
1125                 } /* Auto Fall Back */
1126         } else {/* 802.11a/b packet */
1127
1128                 if (byFBOption == AUTO_FB_NONE) {
1129                         if (bRTS) {
1130                                 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize);
1131                                 pMICHDR = (struct vnt_mic_hdr *) (pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab));
1132                                 pvRTS = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab) + cbMICHDR);
1133                                 pvCTS = NULL;
1134                                 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize +
1135                                         sizeof(struct vnt_rrv_time_ab) + cbMICHDR + sizeof(struct vnt_rts_ab));
1136                                 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_ab) +
1137                                         cbMICHDR + sizeof(struct vnt_rts_ab) + sizeof(struct vnt_tx_datahead_ab);
1138                         } else { /* RTS_needless, need MICHDR */
1139                                 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize);
1140                                 pMICHDR = (struct vnt_mic_hdr *) (pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab));
1141                                 pvRTS = NULL;
1142                                 pvCTS = NULL;
1143                                 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab) + cbMICHDR);
1144                                 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_ab) +
1145                                         cbMICHDR + sizeof(struct vnt_tx_datahead_ab);
1146                         }
1147                 } else {
1148                         /* Auto Fall Back */
1149                         if (bRTS) { /* RTS_need */
1150                                 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize);
1151                                 pMICHDR = (struct vnt_mic_hdr *) (pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab));
1152                                 pvRTS = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab) + cbMICHDR);
1153                                 pvCTS = NULL;
1154                                 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize +
1155                                         sizeof(struct vnt_rrv_time_ab) + cbMICHDR + sizeof(struct vnt_rts_a_fb));
1156                                 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_ab) +
1157                                         cbMICHDR + sizeof(struct vnt_rts_a_fb) + sizeof(struct vnt_tx_datahead_a_fb);
1158                         } else { /* RTS_needless */
1159                                 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize);
1160                                 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab));
1161                                 pvRTS = NULL;
1162                                 pvCTS = NULL;
1163                                 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab) + cbMICHDR);
1164                                 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_ab) +
1165                                         cbMICHDR + sizeof(struct vnt_tx_datahead_a_fb);
1166                         }
1167                 } /* Auto Fall Back */
1168         }
1169
1170         td_info->mic_hdr = pMICHDR;
1171
1172         memset((void *)(pbyTxBufferAddr + wTxBufSize), 0, (cbHeaderLength - wTxBufSize));
1173
1174         /* Fill FIFO,RrvTime,RTS,and CTS */
1175         s_vGenerateTxParameter(pDevice, byPktType, tx_buffer_head, pvRrvTime, pvRTS, pvCTS,
1176                                cbFrameSize, bNeedACK, uDMAIdx, hdr, pDevice->wCurrentRate);
1177         /* Fill DataHead */
1178         uDuration = s_uFillDataHead(pDevice, byPktType, pvTxDataHd, cbFrameSize, uDMAIdx, bNeedACK,
1179                                     0, 0, uMACfragNum, byFBOption, pDevice->wCurrentRate, is_pspoll);
1180
1181         hdr->duration_id = uDuration;
1182
1183         cbReqCount = cbHeaderLength + uPadding + skb->len;
1184         pbyBuffer = (unsigned char *)pHeadTD->td_info->buf;
1185         uLength = cbHeaderLength + uPadding;
1186
1187         /* Copy the Packet into a tx Buffer */
1188         memcpy((pbyBuffer + uLength), skb->data, skb->len);
1189
1190         ptdCurr = pHeadTD;
1191
1192         ptdCurr->td_info->req_count = (u16)cbReqCount;
1193
1194         return cbHeaderLength;
1195 }
1196
1197 static void vnt_fill_txkey(struct ieee80211_hdr *hdr, u8 *key_buffer,
1198                            struct ieee80211_key_conf *tx_key,
1199                            struct sk_buff *skb, u16 payload_len,
1200                            struct vnt_mic_hdr *mic_hdr)
1201 {
1202         u64 pn64;
1203         u8 *iv = ((u8 *)hdr + ieee80211_get_hdrlen_from_skb(skb));
1204
1205         /* strip header and icv len from payload */
1206         payload_len -= ieee80211_get_hdrlen_from_skb(skb);
1207         payload_len -= tx_key->icv_len;
1208
1209         switch (tx_key->cipher) {
1210         case WLAN_CIPHER_SUITE_WEP40:
1211         case WLAN_CIPHER_SUITE_WEP104:
1212                 memcpy(key_buffer, iv, 3);
1213                 memcpy(key_buffer + 3, tx_key->key, tx_key->keylen);
1214
1215                 if (tx_key->keylen == WLAN_KEY_LEN_WEP40) {
1216                         memcpy(key_buffer + 8, iv, 3);
1217                         memcpy(key_buffer + 11,
1218                                tx_key->key, WLAN_KEY_LEN_WEP40);
1219                 }
1220
1221                 break;
1222         case WLAN_CIPHER_SUITE_TKIP:
1223                 ieee80211_get_tkip_p2k(tx_key, skb, key_buffer);
1224
1225                 break;
1226         case WLAN_CIPHER_SUITE_CCMP:
1227
1228                 if (!mic_hdr)
1229                         return;
1230
1231                 mic_hdr->id = 0x59;
1232                 mic_hdr->payload_len = cpu_to_be16(payload_len);
1233                 ether_addr_copy(mic_hdr->mic_addr2, hdr->addr2);
1234
1235                 pn64 = atomic64_read(&tx_key->tx_pn);
1236                 mic_hdr->ccmp_pn[5] = pn64;
1237                 mic_hdr->ccmp_pn[4] = pn64 >> 8;
1238                 mic_hdr->ccmp_pn[3] = pn64 >> 16;
1239                 mic_hdr->ccmp_pn[2] = pn64 >> 24;
1240                 mic_hdr->ccmp_pn[1] = pn64 >> 32;
1241                 mic_hdr->ccmp_pn[0] = pn64 >> 40;
1242
1243                 if (ieee80211_has_a4(hdr->frame_control))
1244                         mic_hdr->hlen = cpu_to_be16(28);
1245                 else
1246                         mic_hdr->hlen = cpu_to_be16(22);
1247
1248                 ether_addr_copy(mic_hdr->addr1, hdr->addr1);
1249                 ether_addr_copy(mic_hdr->addr2, hdr->addr2);
1250                 ether_addr_copy(mic_hdr->addr3, hdr->addr3);
1251
1252                 mic_hdr->frame_control = cpu_to_le16(
1253                         le16_to_cpu(hdr->frame_control) & 0xc78f);
1254                 mic_hdr->seq_ctrl = cpu_to_le16(
1255                                 le16_to_cpu(hdr->seq_ctrl) & 0xf);
1256
1257                 if (ieee80211_has_a4(hdr->frame_control))
1258                         ether_addr_copy(mic_hdr->addr4, hdr->addr4);
1259
1260                 memcpy(key_buffer, tx_key->key, WLAN_KEY_LEN_CCMP);
1261
1262                 break;
1263         default:
1264                 break;
1265         }
1266 }
1267
1268 int vnt_generate_fifo_header(struct vnt_private *priv, u32 dma_idx,
1269                              struct vnt_tx_desc *head_td, struct sk_buff *skb)
1270 {
1271         struct vnt_td_info *td_info = head_td->td_info;
1272         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1273         struct ieee80211_tx_rate *tx_rate = &info->control.rates[0];
1274         struct ieee80211_rate *rate;
1275         struct ieee80211_key_conf *tx_key;
1276         struct ieee80211_hdr *hdr;
1277         struct vnt_tx_fifo_head *tx_buffer_head =
1278                         (struct vnt_tx_fifo_head *)td_info->buf;
1279         u16 tx_body_size = skb->len, current_rate;
1280         u8 pkt_type;
1281         bool is_pspoll = false;
1282
1283         memset(tx_buffer_head, 0, sizeof(*tx_buffer_head));
1284
1285         hdr = (struct ieee80211_hdr *)(skb->data);
1286
1287         rate = ieee80211_get_tx_rate(priv->hw, info);
1288
1289         current_rate = rate->hw_value;
1290         if (priv->wCurrentRate != current_rate &&
1291                         !(priv->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL)) {
1292                 priv->wCurrentRate = current_rate;
1293
1294                 RFbSetPower(priv, priv->wCurrentRate,
1295                             priv->hw->conf.chandef.chan->hw_value);
1296         }
1297
1298         if (current_rate > RATE_11M) {
1299                 if (info->band == NL80211_BAND_5GHZ) {
1300                         pkt_type = PK_TYPE_11A;
1301                 } else {
1302                         if (tx_rate->flags & IEEE80211_TX_RC_USE_CTS_PROTECT)
1303                                 pkt_type = PK_TYPE_11GB;
1304                         else
1305                                 pkt_type = PK_TYPE_11GA;
1306                 }
1307         } else {
1308                 pkt_type = PK_TYPE_11B;
1309         }
1310
1311         /*Set fifo controls */
1312         if (pkt_type == PK_TYPE_11A)
1313                 tx_buffer_head->fifo_ctl = 0;
1314         else if (pkt_type == PK_TYPE_11B)
1315                 tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11B);
1316         else if (pkt_type == PK_TYPE_11GB)
1317                 tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11GB);
1318         else if (pkt_type == PK_TYPE_11GA)
1319                 tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11GA);
1320
1321         /* generate interrupt */
1322         tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_GENINT);
1323
1324         if (!ieee80211_is_data(hdr->frame_control)) {
1325                 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_TMOEN);
1326                 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_ISDMA0);
1327                 tx_buffer_head->time_stamp =
1328                         cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us);
1329         } else {
1330                 tx_buffer_head->time_stamp =
1331                         cpu_to_le16(DEFAULT_MSDU_LIFETIME_RES_64us);
1332         }
1333
1334         if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
1335                 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_NEEDACK);
1336
1337         if (ieee80211_has_retry(hdr->frame_control))
1338                 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_LRETRY);
1339
1340         if (tx_rate->flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
1341                 priv->byPreambleType = PREAMBLE_SHORT;
1342         else
1343                 priv->byPreambleType = PREAMBLE_LONG;
1344
1345         if (tx_rate->flags & IEEE80211_TX_RC_USE_RTS_CTS)
1346                 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_RTS);
1347
1348         if (ieee80211_has_a4(hdr->frame_control)) {
1349                 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_LHEAD);
1350                 priv->bLongHeader = true;
1351         }
1352
1353         if (info->flags & IEEE80211_TX_CTL_NO_PS_BUFFER)
1354                 is_pspoll = true;
1355
1356         tx_buffer_head->frag_ctl =
1357                         cpu_to_le16(ieee80211_get_hdrlen_from_skb(skb) << 10);
1358
1359         if (info->control.hw_key) {
1360                 tx_key = info->control.hw_key;
1361
1362                 switch (info->control.hw_key->cipher) {
1363                 case WLAN_CIPHER_SUITE_WEP40:
1364                 case WLAN_CIPHER_SUITE_WEP104:
1365                         tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_LEGACY);
1366                         break;
1367                 case WLAN_CIPHER_SUITE_TKIP:
1368                         tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_TKIP);
1369                         break;
1370                 case WLAN_CIPHER_SUITE_CCMP:
1371                         tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_AES);
1372                 default:
1373                         break;
1374                 }
1375         }
1376
1377         tx_buffer_head->current_rate = cpu_to_le16(current_rate);
1378
1379         /* legacy rates TODO use ieee80211_tx_rate */
1380         if (current_rate >= RATE_18M && ieee80211_is_data(hdr->frame_control)) {
1381                 if (priv->byAutoFBCtrl == AUTO_FB_0)
1382                         tx_buffer_head->fifo_ctl |=
1383                                                 cpu_to_le16(FIFOCTL_AUTO_FB_0);
1384                 else if (priv->byAutoFBCtrl == AUTO_FB_1)
1385                         tx_buffer_head->fifo_ctl |=
1386                                                 cpu_to_le16(FIFOCTL_AUTO_FB_1);
1387         }
1388
1389         tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_NONFRAG);
1390
1391         s_cbFillTxBufHead(priv, pkt_type, (u8 *)tx_buffer_head,
1392                           dma_idx, head_td, is_pspoll);
1393
1394         if (info->control.hw_key) {
1395                 tx_key = info->control.hw_key;
1396                 if (tx_key->keylen > 0)
1397                         vnt_fill_txkey(hdr, tx_buffer_head->tx_key,
1398                                 tx_key, skb, tx_body_size, td_info->mic_hdr);
1399         }
1400
1401         return 0;
1402 }
1403
1404 static int vnt_beacon_xmit(struct vnt_private *priv,
1405                            struct sk_buff *skb)
1406 {
1407         struct vnt_tx_short_buf_head *short_head =
1408                 (struct vnt_tx_short_buf_head *)priv->tx_beacon_bufs;
1409         struct ieee80211_mgmt *mgmt_hdr = (struct ieee80211_mgmt *)
1410                                 (priv->tx_beacon_bufs + sizeof(*short_head));
1411         struct ieee80211_tx_info *info;
1412         u32 frame_size = skb->len + 4;
1413         u16 current_rate;
1414
1415         memset(priv->tx_beacon_bufs, 0, sizeof(*short_head));
1416
1417         if (priv->byBBType == BB_TYPE_11A) {
1418                 current_rate = RATE_6M;
1419
1420                 /* Get SignalField,ServiceField,Length */
1421                 vnt_get_phy_field(priv, frame_size, current_rate,
1422                                   PK_TYPE_11A, &short_head->ab);
1423
1424                 /* Get Duration and TimeStampOff */
1425                 short_head->duration =
1426                         cpu_to_le16((u16)s_uGetDataDuration(priv, DATADUR_B,
1427                                     frame_size, PK_TYPE_11A, current_rate,
1428                                     false, 0, 0, 1, AUTO_FB_NONE));
1429
1430                 short_head->time_stamp_off =
1431                                 vnt_time_stamp_off(priv, current_rate);
1432         } else {
1433                 current_rate = RATE_1M;
1434                 short_head->fifo_ctl |= cpu_to_le16(FIFOCTL_11B);
1435
1436                 /* Get SignalField,ServiceField,Length */
1437                 vnt_get_phy_field(priv, frame_size, current_rate,
1438                                   PK_TYPE_11B, &short_head->ab);
1439
1440                 /* Get Duration and TimeStampOff */
1441                 short_head->duration =
1442                         cpu_to_le16((u16)s_uGetDataDuration(priv, DATADUR_B,
1443                                     frame_size, PK_TYPE_11B, current_rate,
1444                                     false, 0, 0, 1, AUTO_FB_NONE));
1445
1446                 short_head->time_stamp_off =
1447                         vnt_time_stamp_off(priv, current_rate);
1448         }
1449
1450         short_head->fifo_ctl |= cpu_to_le16(FIFOCTL_GENINT);
1451
1452         /* Copy Beacon */
1453         memcpy(mgmt_hdr, skb->data, skb->len);
1454
1455         /* time stamp always 0 */
1456         mgmt_hdr->u.beacon.timestamp = 0;
1457
1458         info = IEEE80211_SKB_CB(skb);
1459         if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
1460                 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)mgmt_hdr;
1461
1462                 hdr->duration_id = 0;
1463                 hdr->seq_ctrl = cpu_to_le16(priv->wSeqCounter << 4);
1464         }
1465
1466         priv->wSeqCounter++;
1467         if (priv->wSeqCounter > 0x0fff)
1468                 priv->wSeqCounter = 0;
1469
1470         priv->wBCNBufLen = sizeof(*short_head) + skb->len;
1471
1472         MACvSetCurrBCNTxDescAddr(priv->PortOffset, priv->tx_beacon_dma);
1473
1474         MACvSetCurrBCNLength(priv->PortOffset, priv->wBCNBufLen);
1475         /* Set auto Transmit on */
1476         MACvRegBitsOn(priv->PortOffset, MAC_REG_TCR, TCR_AUTOBCNTX);
1477         /* Poll Transmit the adapter */
1478         MACvTransmitBCN(priv->PortOffset);
1479
1480         return 0;
1481 }
1482
1483 int vnt_beacon_make(struct vnt_private *priv, struct ieee80211_vif *vif)
1484 {
1485         struct sk_buff *beacon;
1486
1487         beacon = ieee80211_beacon_get(priv->hw, vif);
1488         if (!beacon)
1489                 return -ENOMEM;
1490
1491         if (vnt_beacon_xmit(priv, beacon)) {
1492                 ieee80211_free_txskb(priv->hw, beacon);
1493                 return -ENODEV;
1494         }
1495
1496         return 0;
1497 }
1498
1499 int vnt_beacon_enable(struct vnt_private *priv, struct ieee80211_vif *vif,
1500                       struct ieee80211_bss_conf *conf)
1501 {
1502         VNSvOutPortB(priv->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTRST);
1503
1504         VNSvOutPortB(priv->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTREN);
1505
1506         CARDvSetFirstNextTBTT(priv, conf->beacon_int);
1507
1508         CARDbSetBeaconPeriod(priv, conf->beacon_int);
1509
1510         return vnt_beacon_make(priv, vif);
1511 }