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