drivers/staging/vt6655/card.c

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