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