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