drivers/staging/vt6655/card.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: Provide functions to setup NIC operation mode
   7  * Functions:
   8  *      s_vSafeResetTx - Rest Tx
   9  *      CARDvSetRSPINF - Set RSPINF
  10  *      CARDvUpdateBasicTopRate - Update BasicTopRate
  11  *      CARDbAddBasicRate - Add to BasicRateSet
  12  *      CARDbIsOFDMinBasicRate - Check if any OFDM rate is in BasicRateSet
  13  *      CARDqGetTSFOffset - Calculate TSFOffset
  14  *      vt6655_get_current_tsf - Read Current NIC TSF counter
  15  *      CARDqGetNextTBTT - Calculate Next Beacon TSF counter
  16  *      CARDvSetFirstNextTBTT - Set NIC Beacon time
  17  *      CARDvUpdateNextTBTT - Sync. NIC Beacon time
  18  *      CARDbRadioPowerOff - Turn Off NIC Radio Power
  19  *
  20  * Revision History:
  21  *      06-10-2003 Bryan YC Fan:  Re-write codes to support VT3253 spec.
  22  *      08-26-2003 Kyle Hsu:      Modify the definition type of iobase.
  23  *      09-01-2003 Bryan YC Fan:  Add vUpdateIFS().
  24  *
  25  */
  26
  27 #include "card.h"
  28 #include "baseband.h"
  29 #include "mac.h"
  30 #include "desc.h"
  31 #include "rf.h"
  32 #include "power.h"
  33
  34 /*---------------------  Static Definitions -------------------------*/
  35
  36 #define C_SIFS_A        16      /* micro sec. */
  37 #define C_SIFS_BG       10
  38
  39 #define C_EIFS          80      /* micro sec. */
  40
  41 #define C_SLOT_SHORT    9       /* micro sec. */
  42 #define C_SLOT_LONG     20
  43
  44 #define C_CWMIN_A       15      /* slot time */
  45 #define C_CWMIN_B       31
  46
  47 #define C_CWMAX         1023    /* slot time */
  48
  49 #define WAIT_BEACON_TX_DOWN_TMO         3    /* Times */
  50
  51 /*---------------------  Static Variables  --------------------------*/
  52
  53 static const unsigned short cwRXBCNTSFOff[MAX_RATE] = {
  54         17, 17, 17, 17, 34, 23, 17, 11, 8, 5, 4, 3};
  55
  56 /*---------------------  Static Functions  --------------------------*/
  57
  58 static void s_vCalculateOFDMRParameter(unsigned char rate, u8 bb_type,
  59                                        unsigned char *pbyTxRate,
  60                                        unsigned char *pbyRsvTime);
  61
  62 /*---------------------  Export Functions  --------------------------*/
  63
  64 /*
  65  * Description: Calculate TxRate and RsvTime fields for RSPINF in OFDM mode.
  66  *
  67  * Parameters:
  68  *  In:
  69  *      wRate           - Tx Rate
  70  *      byPktType       - Tx Packet type
  71  *  Out:
  72  *      pbyTxRate       - pointer to RSPINF TxRate field
  73  *      pbyRsvTime      - pointer to RSPINF RsvTime field
  74  *
  75  * Return Value: none
  76  */
  77 static void s_vCalculateOFDMRParameter(unsigned char rate,
  78                                        u8 bb_type,
  79                                        unsigned char *pbyTxRate,
  80                                        unsigned char *pbyRsvTime)
  81 {
  82         switch (rate) {
  83         case RATE_6M:
  84                 if (bb_type == BB_TYPE_11A) { /* 5GHZ */
  85                         *pbyTxRate = 0x9B;
  86                         *pbyRsvTime = 44;
  87                 } else {
  88                         *pbyTxRate = 0x8B;
  89                         *pbyRsvTime = 50;
  90                 }
  91                 break;
  92
  93         case RATE_9M:
  94                 if (bb_type == BB_TYPE_11A) { /* 5GHZ */
  95                         *pbyTxRate = 0x9F;
  96                         *pbyRsvTime = 36;
  97                 } else {
  98                         *pbyTxRate = 0x8F;
  99                         *pbyRsvTime = 42;
 100                 }
 101                 break;
 102
 103         case RATE_12M:
 104                 if (bb_type == BB_TYPE_11A) { /* 5GHZ */
 105                         *pbyTxRate = 0x9A;
 106                         *pbyRsvTime = 32;
 107                 } else {
 108                         *pbyTxRate = 0x8A;
 109                         *pbyRsvTime = 38;
 110                 }
 111                 break;
 112
 113         case RATE_18M:
 114                 if (bb_type == BB_TYPE_11A) { /* 5GHZ */
 115                         *pbyTxRate = 0x9E;
 116                         *pbyRsvTime = 28;
 117                 } else {
 118                         *pbyTxRate = 0x8E;
 119                         *pbyRsvTime = 34;
 120                 }
 121                 break;
 122
 123         case RATE_36M:
 124                 if (bb_type == BB_TYPE_11A) { /* 5GHZ */
 125                         *pbyTxRate = 0x9D;
 126                         *pbyRsvTime = 24;
 127                 } else {
 128                         *pbyTxRate = 0x8D;
 129                         *pbyRsvTime = 30;
 130                 }
 131                 break;
 132
 133         case RATE_48M:
 134                 if (bb_type == BB_TYPE_11A) { /* 5GHZ */
 135                         *pbyTxRate = 0x98;
 136                         *pbyRsvTime = 24;
 137                 } else {
 138                         *pbyTxRate = 0x88;
 139                         *pbyRsvTime = 30;
 140                 }
 141                 break;
 142
 143         case RATE_54M:
 144                 if (bb_type == BB_TYPE_11A) { /* 5GHZ */
 145                         *pbyTxRate = 0x9C;
 146                         *pbyRsvTime = 24;
 147                 } else {
 148                         *pbyTxRate = 0x8C;
 149                         *pbyRsvTime = 30;
 150                 }
 151                 break;
 152
 153         case RATE_24M:
 154         default:
 155                 if (bb_type == BB_TYPE_11A) { /* 5GHZ */
 156                         *pbyTxRate = 0x99;
 157                         *pbyRsvTime = 28;
 158                 } else {
 159                         *pbyTxRate = 0x89;
 160                         *pbyRsvTime = 34;
 161                 }
 162                 break;
 163         }
 164 }
 165
 166 /*---------------------  Export Functions  --------------------------*/
 167
 168 /*
 169  * Description: Update IFS
 170  *
 171  * Parameters:
 172  *  In:
 173  *      priv             - The adapter to be set
 174  *  Out:
 175  *      none
 176  *
 177  * Return Value: None.
 178  */
 179 bool CARDbSetPhyParameter(struct vnt_private *priv, u8 bb_type)
 180 {
 181         unsigned char byCWMaxMin = 0;
 182         unsigned char bySlot = 0;
 183         unsigned char bySIFS = 0;
 184         unsigned char byDIFS = 0;
 185         int i;
 186
 187         /* Set SIFS, DIFS, EIFS, SlotTime, CwMin */
 188         if (bb_type == BB_TYPE_11A) {
 189                 MACvSetBBType(priv->port_offset, BB_TYPE_11A);
 190                 bb_write_embedded(priv, 0x88, 0x03);
 191                 bySlot = C_SLOT_SHORT;
 192                 bySIFS = C_SIFS_A;
 193                 byDIFS = C_SIFS_A + 2 * C_SLOT_SHORT;
 194                 byCWMaxMin = 0xA4;
 195         } else if (bb_type == BB_TYPE_11B) {
 196                 MACvSetBBType(priv->port_offset, BB_TYPE_11B);
 197                 bb_write_embedded(priv, 0x88, 0x02);
 198                 bySlot = C_SLOT_LONG;
 199                 bySIFS = C_SIFS_BG;
 200                 byDIFS = C_SIFS_BG + 2 * C_SLOT_LONG;
 201                 byCWMaxMin = 0xA5;
 202         } else { /* PK_TYPE_11GA & PK_TYPE_11GB */
 203                 MACvSetBBType(priv->port_offset, BB_TYPE_11G);
 204                 bb_write_embedded(priv, 0x88, 0x08);
 205                 bySIFS = C_SIFS_BG;
 206
 207                 if (priv->short_slot_time) {
 208                         bySlot = C_SLOT_SHORT;
 209                         byDIFS = C_SIFS_BG + 2 * C_SLOT_SHORT;
 210                 } else {
 211                         bySlot = C_SLOT_LONG;
 212                         byDIFS = C_SIFS_BG + 2 * C_SLOT_LONG;
 213                 }
 214
 215                 byCWMaxMin = 0xa4;
 216
 217                 for (i = RATE_54M; i >= RATE_6M; i--) {
 218                         if (priv->basic_rates & ((u32)(0x1 << i))) {
 219                                 byCWMaxMin |= 0x1;
 220                                 break;
 221                         }
 222                 }
 223         }
 224
 225         if (priv->byRFType == RF_RFMD2959) {
 226                 /*
 227                  * bcs TX_PE will reserve 3 us hardware's processing
 228                  * time here is 2 us.
 229                  */
 230                 bySIFS -= 3;
 231                 byDIFS -= 3;
 232                 /*
 233                  * TX_PE will reserve 3 us for MAX2829 A mode only, it is for
 234                  * better TX throughput; MAC will need 2 us to process, so the
 235                  * SIFS, DIFS can be shorter by 2 us.
 236                  */
 237         }
 238
 239         if (priv->bySIFS != bySIFS) {
 240                 priv->bySIFS = bySIFS;
 241                 iowrite8(priv->bySIFS, priv->port_offset + MAC_REG_SIFS);
 242         }
 243         if (priv->byDIFS != byDIFS) {
 244                 priv->byDIFS = byDIFS;
 245                 iowrite8(priv->byDIFS, priv->port_offset + MAC_REG_DIFS);
 246         }
 247         if (priv->byEIFS != C_EIFS) {
 248                 priv->byEIFS = C_EIFS;
 249                 iowrite8(priv->byEIFS, priv->port_offset + MAC_REG_EIFS);
 250         }
 251         if (priv->bySlot != bySlot) {
 252                 priv->bySlot = bySlot;
 253                 iowrite8(priv->bySlot, priv->port_offset + MAC_REG_SLOT);
 254
 255                 bb_set_short_slot_time(priv);
 256         }
 257         if (priv->byCWMaxMin != byCWMaxMin) {
 258                 priv->byCWMaxMin = byCWMaxMin;
 259                 iowrite8(priv->byCWMaxMin, priv->port_offset + MAC_REG_CWMAXMIN0);
 260         }
 261
 262         priv->byPacketType = CARDbyGetPktType(priv);
 263
 264         CARDvSetRSPINF(priv, bb_type);
 265
 266         return true;
 267 }
 268
 269 /*
 270  * Description: Sync. TSF counter to BSS
 271  *              Get TSF offset and write to HW
 272  *
 273  * Parameters:
 274  *  In:
 275  *      priv         - The adapter to be sync.
 276  *      byRxRate        - data rate of receive beacon
 277  *      qwBSSTimestamp  - Rx BCN's TSF
 278  *      qwLocalTSF      - Local TSF
 279  *  Out:
 280  *      none
 281  *
 282  * Return Value: none
 283  */
 284 bool CARDbUpdateTSF(struct vnt_private *priv, unsigned char byRxRate,
 285                     u64 qwBSSTimestamp)
 286 {
 287         u64 local_tsf;
 288         u64 qwTSFOffset = 0;
 289
 290         local_tsf = vt6655_get_current_tsf(priv);
 291
 292         if (qwBSSTimestamp != local_tsf) {
 293                 qwTSFOffset = CARDqGetTSFOffset(byRxRate, qwBSSTimestamp,
 294                                                 local_tsf);
 295                 /* adjust TSF, HW's TSF add TSF Offset reg */
 296                 VNSvOutPortD(priv->port_offset + MAC_REG_TSFOFST,
 297                              (u32)qwTSFOffset);
 298                 VNSvOutPortD(priv->port_offset + MAC_REG_TSFOFST + 4,
 299                              (u32)(qwTSFOffset >> 32));
 300                 MACvRegBitsOn(priv->port_offset, MAC_REG_TFTCTL,
 301                               TFTCTL_TSFSYNCEN);
 302         }
 303         return true;
 304 }
 305
 306 /*
 307  * Description: Set NIC TSF counter for first Beacon time
 308  *              Get NEXTTBTT from adjusted TSF and Beacon Interval
 309  *
 310  * Parameters:
 311  *  In:
 312  *      priv         - The adapter to be set.
 313  *      wBeaconInterval - Beacon Interval
 314  *  Out:
 315  *      none
 316  *
 317  * Return Value: true if succeed; otherwise false
 318  */
 319 bool CARDbSetBeaconPeriod(struct vnt_private *priv,
 320                           unsigned short wBeaconInterval)
 321 {
 322         u64 qwNextTBTT;
 323
 324         qwNextTBTT = vt6655_get_current_tsf(priv); /* Get Local TSF counter */
 325
 326         qwNextTBTT = CARDqGetNextTBTT(qwNextTBTT, wBeaconInterval);
 327
 328         /* set HW beacon interval */
 329         VNSvOutPortW(priv->port_offset + MAC_REG_BI, wBeaconInterval);
 330         priv->wBeaconInterval = wBeaconInterval;
 331         /* Set NextTBTT */
 332         VNSvOutPortD(priv->port_offset + MAC_REG_NEXTTBTT, (u32)qwNextTBTT);
 333         VNSvOutPortD(priv->port_offset + MAC_REG_NEXTTBTT + 4,
 334                      (u32)(qwNextTBTT >> 32));
 335         MACvRegBitsOn(priv->port_offset, MAC_REG_TFTCTL, TFTCTL_TBTTSYNCEN);
 336
 337         return true;
 338 }
 339
 340 /*
 341  * Description: Turn off Radio power
 342  *
 343  * Parameters:
 344  *  In:
 345  *      priv         - The adapter to be turned off
 346  *  Out:
 347  *      none
 348  *
 349  */
 350 void CARDbRadioPowerOff(struct vnt_private *priv)
 351 {
 352         if (priv->radio_off)
 353                 return;
 354
 355         switch (priv->byRFType) {
 356         case RF_RFMD2959:
 357                 MACvWordRegBitsOff(priv->port_offset, MAC_REG_SOFTPWRCTL,
 358                                    SOFTPWRCTL_TXPEINV);
 359                 MACvWordRegBitsOn(priv->port_offset, MAC_REG_SOFTPWRCTL,
 360                                   SOFTPWRCTL_SWPE1);
 361                 break;
 362
 363         case RF_AIROHA:
 364         case RF_AL2230S:
 365                 MACvWordRegBitsOff(priv->port_offset, MAC_REG_SOFTPWRCTL,
 366                                    SOFTPWRCTL_SWPE2);
 367                 MACvWordRegBitsOff(priv->port_offset, MAC_REG_SOFTPWRCTL,
 368                                    SOFTPWRCTL_SWPE3);
 369                 break;
 370         }
 371
 372         MACvRegBitsOff(priv->port_offset, MAC_REG_HOSTCR, HOSTCR_RXON);
 373
 374         bb_set_deep_sleep(priv, priv->local_id);
 375
 376         priv->radio_off = true;
 377         pr_debug("chester power off\n");
 378         MACvRegBitsOn(priv->port_offset, MAC_REG_GPIOCTL0,
 379                       LED_ACTSET);  /* LED issue */
 380 }
 381
 382 void CARDvSafeResetTx(struct vnt_private *priv)
 383 {
 384         unsigned int uu;
 385         struct vnt_tx_desc *pCurrTD;
 386
 387         /* initialize TD index */
 388         priv->apTailTD[0] = &priv->apTD0Rings[0];
 389         priv->apCurrTD[0] = &priv->apTD0Rings[0];
 390
 391         priv->apTailTD[1] = &priv->apTD1Rings[0];
 392         priv->apCurrTD[1] = &priv->apTD1Rings[0];
 393
 394         for (uu = 0; uu < TYPE_MAXTD; uu++)
 395                 priv->iTDUsed[uu] = 0;
 396
 397         for (uu = 0; uu < priv->opts.tx_descs[0]; uu++) {
 398                 pCurrTD = &priv->apTD0Rings[uu];
 399                 pCurrTD->td0.owner = OWNED_BY_HOST;
 400                 /* init all Tx Packet pointer to NULL */
 401         }
 402         for (uu = 0; uu < priv->opts.tx_descs[1]; uu++) {
 403                 pCurrTD = &priv->apTD1Rings[uu];
 404                 pCurrTD->td0.owner = OWNED_BY_HOST;
 405                 /* init all Tx Packet pointer to NULL */
 406         }
 407
 408         /* set MAC TD pointer */
 409         MACvSetCurrTXDescAddr(TYPE_TXDMA0, priv, priv->td0_pool_dma);
 410
 411         MACvSetCurrTXDescAddr(TYPE_AC0DMA, priv, priv->td1_pool_dma);
 412
 413         /* set MAC Beacon TX pointer */
 414         MACvSetCurrBCNTxDescAddr(priv->port_offset,
 415                                  (priv->tx_beacon_dma));
 416 }
 417
 418 /*
 419  * Description:
 420  *      Reset Rx
 421  *
 422  * Parameters:
 423  *  In:
 424  *      priv     - Pointer to the adapter
 425  *  Out:
 426  *      none
 427  *
 428  * Return Value: none
 429  */
 430 void CARDvSafeResetRx(struct vnt_private *priv)
 431 {
 432         unsigned int uu;
 433         struct vnt_rx_desc *pDesc;
 434
 435         /* initialize RD index */
 436         priv->pCurrRD[0] = &priv->aRD0Ring[0];
 437         priv->pCurrRD[1] = &priv->aRD1Ring[0];
 438
 439         /* init state, all RD is chip's */
 440         for (uu = 0; uu < priv->opts.rx_descs0; uu++) {
 441                 pDesc = &priv->aRD0Ring[uu];
 442                 pDesc->rd0.res_count = cpu_to_le16(priv->rx_buf_sz);
 443                 pDesc->rd0.owner = OWNED_BY_NIC;
 444                 pDesc->rd1.req_count = cpu_to_le16(priv->rx_buf_sz);
 445         }
 446
 447         /* init state, all RD is chip's */
 448         for (uu = 0; uu < priv->opts.rx_descs1; uu++) {
 449                 pDesc = &priv->aRD1Ring[uu];
 450                 pDesc->rd0.res_count = cpu_to_le16(priv->rx_buf_sz);
 451                 pDesc->rd0.owner = OWNED_BY_NIC;
 452                 pDesc->rd1.req_count = cpu_to_le16(priv->rx_buf_sz);
 453         }
 454
 455         /* set perPkt mode */
 456         MACvRx0PerPktMode(priv->port_offset);
 457         MACvRx1PerPktMode(priv->port_offset);
 458         /* set MAC RD pointer */
 459         MACvSetCurrRx0DescAddr(priv, priv->rd0_pool_dma);
 460
 461         MACvSetCurrRx1DescAddr(priv, priv->rd1_pool_dma);
 462 }
 463
 464 /*
 465  * Description: Get response Control frame rate in CCK mode
 466  *
 467  * Parameters:
 468  *  In:
 469  *      priv             - The adapter to be set
 470  *      wRateIdx            - Receiving data rate
 471  *  Out:
 472  *      none
 473  *
 474  * Return Value: response Control frame rate
 475  */
 476 static unsigned short CARDwGetCCKControlRate(struct vnt_private *priv,
 477                                              unsigned short wRateIdx)
 478 {
 479         unsigned int ui = (unsigned int)wRateIdx;
 480
 481         while (ui > RATE_1M) {
 482                 if (priv->basic_rates & ((u32)0x1 << ui))
 483                         return (unsigned short)ui;
 484
 485                 ui--;
 486         }
 487         return (unsigned short)RATE_1M;
 488 }
 489
 490 /*
 491  * Description: Get response Control frame rate in OFDM mode
 492  *
 493  * Parameters:
 494  *  In:
 495  *      priv             - The adapter to be set
 496  *      wRateIdx            - Receiving data rate
 497  *  Out:
 498  *      none
 499  *
 500  * Return Value: response Control frame rate
 501  */
 502 static unsigned short CARDwGetOFDMControlRate(struct vnt_private *priv,
 503                                               unsigned short wRateIdx)
 504 {
 505         unsigned int ui = (unsigned int)wRateIdx;
 506
 507         pr_debug("BASIC RATE: %X\n", priv->basic_rates);
 508
 509         if (!CARDbIsOFDMinBasicRate((void *)priv)) {
 510                 pr_debug("%s:(NO OFDM) %d\n", __func__, wRateIdx);
 511                 if (wRateIdx > RATE_24M)
 512                         wRateIdx = RATE_24M;
 513                 return wRateIdx;
 514         }
 515         while (ui > RATE_11M) {
 516                 if (priv->basic_rates & ((u32)0x1 << ui)) {
 517                         pr_debug("%s : %d\n", __func__, ui);
 518                         return (unsigned short)ui;
 519                 }
 520                 ui--;
 521         }
 522         pr_debug("%s: 6M\n", __func__);
 523         return (unsigned short)RATE_24M;
 524 }
 525
 526 /*
 527  * Description: Set RSPINF
 528  *
 529  * Parameters:
 530  *  In:
 531  *      priv             - The adapter to be set
 532  *  Out:
 533  *      none
 534  *
 535  * Return Value: None.
 536  */
 537 void CARDvSetRSPINF(struct vnt_private *priv, u8 bb_type)
 538 {
 539         union vnt_phy_field_swap phy;
 540         unsigned char byTxRate, byRsvTime;      /* For OFDM */
 541         unsigned long flags;
 542
 543         spin_lock_irqsave(&priv->lock, flags);
 544
 545         /* Set to Page1 */
 546         MACvSelectPage1(priv->port_offset);
 547
 548         /* RSPINF_b_1 */
 549         vnt_get_phy_field(priv, 14,
 550                           CARDwGetCCKControlRate(priv, RATE_1M),
 551                           PK_TYPE_11B, &phy.field_read);
 552
 553          /* swap over to get correct write order */
 554         swap(phy.swap[0], phy.swap[1]);
 555
 556         VNSvOutPortD(priv->port_offset + MAC_REG_RSPINF_B_1, phy.field_write);
 557
 558         /* RSPINF_b_2 */
 559         vnt_get_phy_field(priv, 14,
 560                           CARDwGetCCKControlRate(priv, RATE_2M),
 561                           PK_TYPE_11B, &phy.field_read);
 562
 563         swap(phy.swap[0], phy.swap[1]);
 564
 565         VNSvOutPortD(priv->port_offset + MAC_REG_RSPINF_B_2, phy.field_write);
 566
 567         /* RSPINF_b_5 */
 568         vnt_get_phy_field(priv, 14,
 569                           CARDwGetCCKControlRate(priv, RATE_5M),
 570                           PK_TYPE_11B, &phy.field_read);
 571
 572         swap(phy.swap[0], phy.swap[1]);
 573
 574         VNSvOutPortD(priv->port_offset + MAC_REG_RSPINF_B_5, phy.field_write);
 575
 576         /* RSPINF_b_11 */
 577         vnt_get_phy_field(priv, 14,
 578                           CARDwGetCCKControlRate(priv, RATE_11M),
 579                           PK_TYPE_11B, &phy.field_read);
 580
 581         swap(phy.swap[0], phy.swap[1]);
 582
 583         VNSvOutPortD(priv->port_offset + MAC_REG_RSPINF_B_11, phy.field_write);
 584
 585         /* RSPINF_a_6 */
 586         s_vCalculateOFDMRParameter(RATE_6M,
 587                                    bb_type,
 588                                    &byTxRate,
 589                                    &byRsvTime);
 590         VNSvOutPortW(priv->port_offset + MAC_REG_RSPINF_A_6,
 591                      MAKEWORD(byTxRate, byRsvTime));
 592         /* RSPINF_a_9 */
 593         s_vCalculateOFDMRParameter(RATE_9M,
 594                                    bb_type,
 595                                    &byTxRate,
 596                                    &byRsvTime);
 597         VNSvOutPortW(priv->port_offset + MAC_REG_RSPINF_A_9,
 598                      MAKEWORD(byTxRate, byRsvTime));
 599         /* RSPINF_a_12 */
 600         s_vCalculateOFDMRParameter(RATE_12M,
 601                                    bb_type,
 602                                    &byTxRate,
 603                                    &byRsvTime);
 604         VNSvOutPortW(priv->port_offset + MAC_REG_RSPINF_A_12,
 605                      MAKEWORD(byTxRate, byRsvTime));
 606         /* RSPINF_a_18 */
 607         s_vCalculateOFDMRParameter(RATE_18M,
 608                                    bb_type,
 609                                    &byTxRate,
 610                                    &byRsvTime);
 611         VNSvOutPortW(priv->port_offset + MAC_REG_RSPINF_A_18,
 612                      MAKEWORD(byTxRate, byRsvTime));
 613         /* RSPINF_a_24 */
 614         s_vCalculateOFDMRParameter(RATE_24M,
 615                                    bb_type,
 616                                    &byTxRate,
 617                                    &byRsvTime);
 618         VNSvOutPortW(priv->port_offset + MAC_REG_RSPINF_A_24,
 619                      MAKEWORD(byTxRate, byRsvTime));
 620         /* RSPINF_a_36 */
 621         s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate((void *)priv,
 622                                                            RATE_36M),
 623                                    bb_type,
 624                                    &byTxRate,
 625                                    &byRsvTime);
 626         VNSvOutPortW(priv->port_offset + MAC_REG_RSPINF_A_36,
 627                      MAKEWORD(byTxRate, byRsvTime));
 628         /* RSPINF_a_48 */
 629         s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate((void *)priv,
 630                                                            RATE_48M),
 631                                    bb_type,
 632                                    &byTxRate,
 633                                    &byRsvTime);
 634         VNSvOutPortW(priv->port_offset + MAC_REG_RSPINF_A_48,
 635                      MAKEWORD(byTxRate, byRsvTime));
 636         /* RSPINF_a_54 */
 637         s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate((void *)priv,
 638                                                            RATE_54M),
 639                                    bb_type,
 640                                    &byTxRate,
 641                                    &byRsvTime);
 642         VNSvOutPortW(priv->port_offset + MAC_REG_RSPINF_A_54,
 643                      MAKEWORD(byTxRate, byRsvTime));
 644         /* RSPINF_a_72 */
 645         s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate((void *)priv,
 646                                                            RATE_54M),
 647                                    bb_type,
 648                                    &byTxRate,
 649                                    &byRsvTime);
 650         VNSvOutPortW(priv->port_offset + MAC_REG_RSPINF_A_72,
 651                      MAKEWORD(byTxRate, byRsvTime));
 652         /* Set to Page0 */
 653         MACvSelectPage0(priv->port_offset);
 654
 655         spin_unlock_irqrestore(&priv->lock, flags);
 656 }
 657
 658 void CARDvUpdateBasicTopRate(struct vnt_private *priv)
 659 {
 660         unsigned char byTopOFDM = RATE_24M, byTopCCK = RATE_1M;
 661         unsigned char ii;
 662
 663         /* Determines the highest basic rate. */
 664         for (ii = RATE_54M; ii >= RATE_6M; ii--) {
 665                 if ((priv->basic_rates) & ((u32)(1 << ii))) {
 666                         byTopOFDM = ii;
 667                         break;
 668                 }
 669         }
 670         priv->byTopOFDMBasicRate = byTopOFDM;
 671
 672         for (ii = RATE_11M;; ii--) {
 673                 if ((priv->basic_rates) & ((u32)(1 << ii))) {
 674                         byTopCCK = ii;
 675                         break;
 676                 }
 677                 if (ii == RATE_1M)
 678                         break;
 679         }
 680         priv->byTopCCKBasicRate = byTopCCK;
 681 }
 682
 683 bool CARDbIsOFDMinBasicRate(struct vnt_private *priv)
 684 {
 685         int ii;
 686
 687         for (ii = RATE_54M; ii >= RATE_6M; ii--) {
 688                 if ((priv->basic_rates) & ((u32)BIT(ii)))
 689                         return true;
 690         }
 691         return false;
 692 }
 693
 694 unsigned char CARDbyGetPktType(struct vnt_private *priv)
 695 {
 696         if (priv->byBBType == BB_TYPE_11A || priv->byBBType == BB_TYPE_11B)
 697                 return (unsigned char)priv->byBBType;
 698         else if (CARDbIsOFDMinBasicRate((void *)priv))
 699                 return PK_TYPE_11GA;
 700         else
 701                 return PK_TYPE_11GB;
 702 }
 703
 704 /*
 705  * Description: Calculate TSF offset of two TSF input
 706  *              Get TSF Offset from RxBCN's TSF and local TSF
 707  *
 708  * Parameters:
 709  *  In:
 710  *      priv         - The adapter to be sync.
 711  *      qwTSF1          - Rx BCN's TSF
 712  *      qwTSF2          - Local TSF
 713  *  Out:
 714  *      none
 715  *
 716  * Return Value: TSF Offset value
 717  */
 718 u64 CARDqGetTSFOffset(unsigned char byRxRate, u64 qwTSF1, u64 qwTSF2)
 719 {
 720         unsigned short wRxBcnTSFOffst;
 721
 722         wRxBcnTSFOffst = cwRXBCNTSFOff[byRxRate % MAX_RATE];
 723
 724         qwTSF2 += (u64)wRxBcnTSFOffst;
 725
 726         return qwTSF1 - qwTSF2;
 727 }
 728
 729 /*
 730  * Description: Read NIC TSF counter
 731  *              Get local TSF counter
 732  *
 733  * Parameters:
 734  *  In:
 735  *      priv         - The adapter to be read
 736  *  Out:
 737  *      qwCurrTSF       - Current TSF counter
 738  *
 739  * Return Value: true if success; otherwise false
 740  */
 741 u64 vt6655_get_current_tsf(struct vnt_private *priv)
 742 {
 743         void __iomem *iobase = priv->port_offset;
 744         unsigned short ww;
 745         unsigned char data;
 746         u32 low, high;
 747
 748         MACvRegBitsOn(iobase, MAC_REG_TFTCTL, TFTCTL_TSFCNTRRD);
 749         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
 750                 data = ioread8(iobase + MAC_REG_TFTCTL);
 751                 if (!(data & TFTCTL_TSFCNTRRD))
 752                         break;
 753         }
 754         if (ww == W_MAX_TIMEOUT)
 755                 return 0;
 756         low = ioread32(iobase + MAC_REG_TSFCNTR);
 757         high = ioread32(iobase + MAC_REG_TSFCNTR + 4);
 758         return le64_to_cpu(low + ((u64)high << 32));
 759 }
 760
 761 /*
 762  * Description: Read NIC TSF counter
 763  *              Get NEXTTBTT from adjusted TSF and Beacon Interval
 764  *
 765  * Parameters:
 766  *  In:
 767  *      qwTSF           - Current TSF counter
 768  *      wbeaconInterval - Beacon Interval
 769  *  Out:
 770  *      qwCurrTSF       - Current TSF counter
 771  *
 772  * Return Value: TSF value of next Beacon
 773  */
 774 u64 CARDqGetNextTBTT(u64 qwTSF, unsigned short wBeaconInterval)
 775 {
 776         u32 beacon_int;
 777
 778         beacon_int = wBeaconInterval * 1024;
 779         if (beacon_int) {
 780                 do_div(qwTSF, beacon_int);
 781                 qwTSF += 1;
 782                 qwTSF *= beacon_int;
 783         }
 784
 785         return qwTSF;
 786 }
 787
 788 /*
 789  * Description: Set NIC TSF counter for first Beacon time
 790  *              Get NEXTTBTT from adjusted TSF and Beacon Interval
 791  *
 792  * Parameters:
 793  *  In:
 794  *      iobase          - IO Base
 795  *      wBeaconInterval - Beacon Interval
 796  *  Out:
 797  *      none
 798  *
 799  * Return Value: none
 800  */
 801 void CARDvSetFirstNextTBTT(struct vnt_private *priv,
 802                            unsigned short wBeaconInterval)
 803 {
 804         void __iomem *iobase = priv->port_offset;
 805         u64 qwNextTBTT;
 806
 807         qwNextTBTT = vt6655_get_current_tsf(priv); /* Get Local TSF counter */
 808
 809         qwNextTBTT = CARDqGetNextTBTT(qwNextTBTT, wBeaconInterval);
 810         /* Set NextTBTT */
 811         VNSvOutPortD(iobase + MAC_REG_NEXTTBTT, (u32)qwNextTBTT);
 812         VNSvOutPortD(iobase + MAC_REG_NEXTTBTT + 4, (u32)(qwNextTBTT >> 32));
 813         MACvRegBitsOn(iobase, MAC_REG_TFTCTL, TFTCTL_TBTTSYNCEN);
 814 }
 815
 816 /*
 817  * Description: Sync NIC TSF counter for Beacon time
 818  *              Get NEXTTBTT and write to HW
 819  *
 820  * Parameters:
 821  *  In:
 822  *      priv         - The adapter to be set
 823  *      qwTSF           - Current TSF counter
 824  *      wBeaconInterval - Beacon Interval
 825  *  Out:
 826  *      none
 827  *
 828  * Return Value: none
 829  */
 830 void CARDvUpdateNextTBTT(struct vnt_private *priv, u64 qwTSF,
 831                          unsigned short wBeaconInterval)
 832 {
 833         void __iomem *iobase = priv->port_offset;
 834
 835         qwTSF = CARDqGetNextTBTT(qwTSF, wBeaconInterval);
 836         /* Set NextTBTT */
 837         VNSvOutPortD(iobase + MAC_REG_NEXTTBTT, (u32)qwTSF);
 838         VNSvOutPortD(iobase + MAC_REG_NEXTTBTT + 4, (u32)(qwTSF >> 32));
 839         MACvRegBitsOn(iobase, MAC_REG_TFTCTL, TFTCTL_TBTTSYNCEN);
 840         pr_debug("Card:Update Next TBTT[%8llx]\n", qwTSF);
 841 }