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 - uPadding;
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         /* Set TSR1 & ReqCount in TxDescHead */
1212         ptdCurr->m_td1TD1.byTCR |= (TCR_STP | TCR_EDP | EDMSDU);
1213         ptdCurr->m_td1TD1.wReqCount = cpu_to_le16((unsigned short)(cbReqCount));
1214
1215         return cbHeaderLength;
1216 }
1217
1218 static void vnt_fill_txkey(struct ieee80211_hdr *hdr, u8 *key_buffer,
1219                            struct ieee80211_key_conf *tx_key,
1220                            struct sk_buff *skb, u16 payload_len,
1221                            struct vnt_mic_hdr *mic_hdr)
1222 {
1223         struct ieee80211_key_seq seq;
1224         u8 *iv = ((u8 *)hdr + ieee80211_get_hdrlen_from_skb(skb));
1225
1226         /* strip header and icv len from payload */
1227         payload_len -= ieee80211_get_hdrlen_from_skb(skb);
1228         payload_len -= tx_key->icv_len;
1229
1230         switch (tx_key->cipher) {
1231         case WLAN_CIPHER_SUITE_WEP40:
1232         case WLAN_CIPHER_SUITE_WEP104:
1233                 memcpy(key_buffer, iv, 3);
1234                 memcpy(key_buffer + 3, tx_key->key, tx_key->keylen);
1235
1236                 if (tx_key->keylen == WLAN_KEY_LEN_WEP40) {
1237                         memcpy(key_buffer + 8, iv, 3);
1238                         memcpy(key_buffer + 11,
1239                                tx_key->key, WLAN_KEY_LEN_WEP40);
1240                 }
1241
1242                 break;
1243         case WLAN_CIPHER_SUITE_TKIP:
1244                 ieee80211_get_tkip_p2k(tx_key, skb, key_buffer);
1245
1246                 break;
1247         case WLAN_CIPHER_SUITE_CCMP:
1248
1249                 if (!mic_hdr)
1250                         return;
1251
1252                 mic_hdr->id = 0x59;
1253                 mic_hdr->payload_len = cpu_to_be16(payload_len);
1254                 ether_addr_copy(mic_hdr->mic_addr2, hdr->addr2);
1255
1256                 ieee80211_get_key_tx_seq(tx_key, &seq);
1257
1258                 memcpy(mic_hdr->ccmp_pn, seq.ccmp.pn, IEEE80211_CCMP_PN_LEN);
1259
1260                 if (ieee80211_has_a4(hdr->frame_control))
1261                         mic_hdr->hlen = cpu_to_be16(28);
1262                 else
1263                         mic_hdr->hlen = cpu_to_be16(22);
1264
1265                 ether_addr_copy(mic_hdr->addr1, hdr->addr1);
1266                 ether_addr_copy(mic_hdr->addr2, hdr->addr2);
1267                 ether_addr_copy(mic_hdr->addr3, hdr->addr3);
1268
1269                 mic_hdr->frame_control = cpu_to_le16(
1270                         le16_to_cpu(hdr->frame_control) & 0xc78f);
1271                 mic_hdr->seq_ctrl = cpu_to_le16(
1272                                 le16_to_cpu(hdr->seq_ctrl) & 0xf);
1273
1274                 if (ieee80211_has_a4(hdr->frame_control))
1275                         ether_addr_copy(mic_hdr->addr4, hdr->addr4);
1276
1277                 memcpy(key_buffer, tx_key->key, WLAN_KEY_LEN_CCMP);
1278
1279                 break;
1280         default:
1281                 break;
1282         }
1283 }
1284
1285 int vnt_generate_fifo_header(struct vnt_private *priv, u32 dma_idx,
1286                              PSTxDesc head_td, struct sk_buff *skb)
1287 {
1288         PDEVICE_TD_INFO td_info = head_td->pTDInfo;
1289         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1290         struct ieee80211_tx_rate *tx_rate = &info->control.rates[0];
1291         struct ieee80211_rate *rate;
1292         struct ieee80211_key_conf *tx_key;
1293         struct ieee80211_hdr *hdr;
1294         struct vnt_tx_fifo_head *tx_buffer_head =
1295                         (struct vnt_tx_fifo_head *)td_info->buf;
1296         u16 tx_body_size = skb->len, current_rate;
1297         u8 pkt_type;
1298         bool is_pspoll = false;
1299
1300         memset(tx_buffer_head, 0, sizeof(*tx_buffer_head));
1301
1302         hdr = (struct ieee80211_hdr *)(skb->data);
1303
1304         rate = ieee80211_get_tx_rate(priv->hw, info);
1305
1306         current_rate = rate->hw_value;
1307         if (priv->wCurrentRate != current_rate &&
1308                         !(priv->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL)) {
1309                 priv->wCurrentRate = current_rate;
1310
1311                 RFbSetPower(priv, priv->wCurrentRate,
1312                             priv->hw->conf.chandef.chan->hw_value);
1313         }
1314
1315         if (current_rate > RATE_11M)
1316                 pkt_type = (u8)priv->byPacketType;
1317         else
1318                 pkt_type = PK_TYPE_11B;
1319
1320         /*Set fifo controls */
1321         if (pkt_type == PK_TYPE_11A)
1322                 tx_buffer_head->fifo_ctl = 0;
1323         else if (pkt_type == PK_TYPE_11B)
1324                 tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11B);
1325         else if (pkt_type == PK_TYPE_11GB)
1326                 tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11GB);
1327         else if (pkt_type == PK_TYPE_11GA)
1328                 tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11GA);
1329
1330         /* generate interrupt */
1331         tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_GENINT);
1332
1333         if (!ieee80211_is_data(hdr->frame_control)) {
1334                 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_TMOEN);
1335                 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_ISDMA0);
1336                 tx_buffer_head->time_stamp =
1337                         cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us);
1338         } else {
1339                 tx_buffer_head->time_stamp =
1340                         cpu_to_le16(DEFAULT_MSDU_LIFETIME_RES_64us);
1341         }
1342
1343         if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
1344                 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_NEEDACK);
1345
1346         if (ieee80211_has_retry(hdr->frame_control))
1347                 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_LRETRY);
1348
1349         if (tx_rate->flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
1350                 priv->byPreambleType = PREAMBLE_SHORT;
1351         else
1352                 priv->byPreambleType = PREAMBLE_LONG;
1353
1354         if (tx_rate->flags & IEEE80211_TX_RC_USE_RTS_CTS)
1355                 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_RTS);
1356
1357         if (ieee80211_has_a4(hdr->frame_control)) {
1358                 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_LHEAD);
1359                 priv->bLongHeader = true;
1360         }
1361
1362         if (info->flags & IEEE80211_TX_CTL_NO_PS_BUFFER)
1363                 is_pspoll = true;
1364
1365         tx_buffer_head->frag_ctl =
1366                         cpu_to_le16(ieee80211_get_hdrlen_from_skb(skb) << 10);
1367
1368         if (info->control.hw_key) {
1369                 tx_key = info->control.hw_key;
1370
1371                 switch (info->control.hw_key->cipher) {
1372                 case WLAN_CIPHER_SUITE_WEP40:
1373                 case WLAN_CIPHER_SUITE_WEP104:
1374                         tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_LEGACY);
1375                         break;
1376                 case WLAN_CIPHER_SUITE_TKIP:
1377                         tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_TKIP);
1378                         break;
1379                 case WLAN_CIPHER_SUITE_CCMP:
1380                         tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_AES);
1381                 default:
1382                         break;
1383                 }
1384         }
1385
1386         tx_buffer_head->current_rate = cpu_to_le16(current_rate);
1387
1388         /* legacy rates TODO use ieee80211_tx_rate */
1389         if (current_rate >= RATE_18M && ieee80211_is_data(hdr->frame_control)) {
1390                 if (priv->byAutoFBCtrl == AUTO_FB_0)
1391                         tx_buffer_head->fifo_ctl |=
1392                                                 cpu_to_le16(FIFOCTL_AUTO_FB_0);
1393                 else if (priv->byAutoFBCtrl == AUTO_FB_1)
1394                         tx_buffer_head->fifo_ctl |=
1395                                                 cpu_to_le16(FIFOCTL_AUTO_FB_1);
1396
1397         }
1398
1399         tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_NONFRAG);
1400
1401         s_cbFillTxBufHead(priv, pkt_type, (u8 *)tx_buffer_head,
1402                           dma_idx, head_td, is_pspoll);
1403
1404         if (info->control.hw_key) {
1405                 tx_key = info->control.hw_key;
1406                 if (tx_key->keylen > 0)
1407                         vnt_fill_txkey(hdr, tx_buffer_head->tx_key,
1408                                 tx_key, skb, tx_body_size, td_info->mic_hdr);
1409         }
1410
1411         return 0;
1412 }
1413
1414 static int vnt_beacon_xmit(struct vnt_private *priv,
1415                            struct sk_buff *skb)
1416 {
1417         struct vnt_tx_short_buf_head *short_head =
1418                 (struct vnt_tx_short_buf_head *)priv->tx_beacon_bufs;
1419         struct ieee80211_mgmt *mgmt_hdr = (struct ieee80211_mgmt *)
1420                                 (priv->tx_beacon_bufs + sizeof(*short_head));
1421         struct ieee80211_tx_info *info;
1422         u32 frame_size = skb->len + 4;
1423         u16 current_rate;
1424
1425         memset(priv->tx_beacon_bufs, 0, sizeof(*short_head));
1426
1427         if (priv->byBBType == BB_TYPE_11A) {
1428                 current_rate = RATE_6M;
1429
1430                 /* Get SignalField,ServiceField,Length */
1431                 vnt_get_phy_field(priv, frame_size, current_rate,
1432                                   PK_TYPE_11A, &short_head->ab);
1433
1434                 /* Get Duration and TimeStampOff */
1435                 short_head->duration =
1436                         cpu_to_le16((u16)s_uGetDataDuration(priv, DATADUR_B,
1437                                     frame_size, PK_TYPE_11A, current_rate,
1438                                     false, 0, 0, 1, AUTO_FB_NONE));
1439
1440                 short_head->time_stamp_off =
1441                                 vnt_time_stamp_off(priv, current_rate);
1442         } else {
1443                 current_rate = RATE_1M;
1444                 short_head->fifo_ctl |= cpu_to_le16(FIFOCTL_11B);
1445
1446                 /* Get SignalField,ServiceField,Length */
1447                 vnt_get_phy_field(priv, frame_size, current_rate,
1448                                   PK_TYPE_11B, &short_head->ab);
1449
1450                 /* Get Duration and TimeStampOff */
1451                 short_head->duration =
1452                         cpu_to_le16((u16)s_uGetDataDuration(priv, DATADUR_B,
1453                                     frame_size, PK_TYPE_11B, current_rate,
1454                                     false, 0, 0, 1, AUTO_FB_NONE));
1455
1456                 short_head->time_stamp_off =
1457                         vnt_time_stamp_off(priv, current_rate);
1458         }
1459
1460         short_head->fifo_ctl |= cpu_to_le16(FIFOCTL_GENINT);
1461
1462         /* Copy Beacon */
1463         memcpy(mgmt_hdr, skb->data, skb->len);
1464
1465         /* time stamp always 0 */
1466         mgmt_hdr->u.beacon.timestamp = 0;
1467
1468         info = IEEE80211_SKB_CB(skb);
1469         if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
1470                 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)mgmt_hdr;
1471
1472                 hdr->duration_id = 0;
1473                 hdr->seq_ctrl = cpu_to_le16(priv->wSeqCounter << 4);
1474         }
1475
1476         priv->wSeqCounter++;
1477         if (priv->wSeqCounter > 0x0fff)
1478                 priv->wSeqCounter = 0;
1479
1480         priv->wBCNBufLen = sizeof(*short_head) + skb->len;
1481
1482         MACvSetCurrBCNTxDescAddr(priv->PortOffset, priv->tx_beacon_dma);
1483
1484         MACvSetCurrBCNLength(priv->PortOffset, priv->wBCNBufLen);
1485         /* Set auto Transmit on */
1486         MACvRegBitsOn(priv->PortOffset, MAC_REG_TCR, TCR_AUTOBCNTX);
1487         /* Poll Transmit the adapter */
1488         MACvTransmitBCN(priv->PortOffset);
1489
1490         return 0;
1491 }
1492
1493 int vnt_beacon_make(struct vnt_private *priv, struct ieee80211_vif *vif)
1494 {
1495         struct sk_buff *beacon;
1496
1497         beacon = ieee80211_beacon_get(priv->hw, vif);
1498         if (!beacon)
1499                 return -ENOMEM;
1500
1501         if (vnt_beacon_xmit(priv, beacon)) {
1502                 ieee80211_free_txskb(priv->hw, beacon);
1503                 return -ENODEV;
1504         }
1505
1506         return 0;
1507 }
1508
1509 int vnt_beacon_enable(struct vnt_private *priv, struct ieee80211_vif *vif,
1510                       struct ieee80211_bss_conf *conf)
1511 {
1512         int ret;
1513
1514         VNSvOutPortB(priv->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTRST);
1515
1516         VNSvOutPortB(priv->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTREN);
1517
1518         CARDvSetFirstNextTBTT(priv, conf->beacon_int);
1519
1520         CARDbSetBeaconPeriod(priv, conf->beacon_int);
1521
1522         ret = vnt_beacon_make(priv, vif);
1523
1524         return ret;
1525 }