drivers/staging/vt6655/rxtx.c

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