drivers/staging/vt6655/rxtx.c

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