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