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
 674         /* Set to Page1 */
 675         MACvSelectPage1(pDevice->PortOffset);
 676
 677         /* RSPINF_b_1 */
 678         vnt_get_phy_field(pDevice, 14,
 679                           CARDwGetCCKControlRate(pDevice, RATE_1M),
 680                           PK_TYPE_11B, &phy.field_read);
 681
 682          /* swap over to get correct write order */
 683         swap(phy.swap[0], phy.swap[1]);
 684
 685         VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_1, phy.field_write);
 686
 687         /* RSPINF_b_2 */
 688         vnt_get_phy_field(pDevice, 14,
 689                           CARDwGetCCKControlRate(pDevice, RATE_2M),
 690                           PK_TYPE_11B, &phy.field_read);
 691
 692         swap(phy.swap[0], phy.swap[1]);
 693
 694         VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_2, phy.field_write);
 695
 696         /* RSPINF_b_5 */
 697         vnt_get_phy_field(pDevice, 14,
 698                           CARDwGetCCKControlRate(pDevice, RATE_5M),
 699                           PK_TYPE_11B, &phy.field_read);
 700
 701         swap(phy.swap[0], phy.swap[1]);
 702
 703         VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_5, phy.field_write);
 704
 705         /* RSPINF_b_11 */
 706         vnt_get_phy_field(pDevice, 14,
 707                           CARDwGetCCKControlRate(pDevice, RATE_11M),
 708                           PK_TYPE_11B, &phy.field_read);
 709
 710         swap(phy.swap[0], phy.swap[1]);
 711
 712         VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_11, phy.field_write);
 713
 714         /* RSPINF_a_6 */
 715         s_vCalculateOFDMRParameter(RATE_6M,
 716                                    bb_type,
 717                                    &byTxRate,
 718                                    &byRsvTime);
 719         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_6, MAKEWORD(byTxRate, byRsvTime));
 720         /* RSPINF_a_9 */
 721         s_vCalculateOFDMRParameter(RATE_9M,
 722                                    bb_type,
 723                                    &byTxRate,
 724                                    &byRsvTime);
 725         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_9, MAKEWORD(byTxRate, byRsvTime));
 726         /* RSPINF_a_12 */
 727         s_vCalculateOFDMRParameter(RATE_12M,
 728                                    bb_type,
 729                                    &byTxRate,
 730                                    &byRsvTime);
 731         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_12, MAKEWORD(byTxRate, byRsvTime));
 732         /* RSPINF_a_18 */
 733         s_vCalculateOFDMRParameter(RATE_18M,
 734                                    bb_type,
 735                                    &byTxRate,
 736                                    &byRsvTime);
 737         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_18, MAKEWORD(byTxRate, byRsvTime));
 738         /* RSPINF_a_24 */
 739         s_vCalculateOFDMRParameter(RATE_24M,
 740                                    bb_type,
 741                                    &byTxRate,
 742                                    &byRsvTime);
 743         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_24, MAKEWORD(byTxRate, byRsvTime));
 744         /* RSPINF_a_36 */
 745         s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate((void *)pDevice, RATE_36M),
 746                                    bb_type,
 747                                    &byTxRate,
 748                                    &byRsvTime);
 749         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_36, MAKEWORD(byTxRate, byRsvTime));
 750         /* RSPINF_a_48 */
 751         s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate((void *)pDevice, RATE_48M),
 752                                    bb_type,
 753                                    &byTxRate,
 754                                    &byRsvTime);
 755         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_48, MAKEWORD(byTxRate, byRsvTime));
 756         /* RSPINF_a_54 */
 757         s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate((void *)pDevice, RATE_54M),
 758                                    bb_type,
 759                                    &byTxRate,
 760                                    &byRsvTime);
 761         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_54, MAKEWORD(byTxRate, byRsvTime));
 762         /* RSPINF_a_72 */
 763         s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate((void *)pDevice, RATE_54M),
 764                                    bb_type,
 765                                    &byTxRate,
 766                                    &byRsvTime);
 767         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_72, MAKEWORD(byTxRate, byRsvTime));
 768         /* Set to Page0 */
 769         MACvSelectPage0(pDevice->PortOffset);
 770 }
 771
 772 void CARDvUpdateBasicTopRate(struct vnt_private *pDevice)
 773 {
 774         unsigned char byTopOFDM = RATE_24M, byTopCCK = RATE_1M;
 775         unsigned char ii;
 776
 777         /* Determines the highest basic rate. */
 778         for (ii = RATE_54M; ii >= RATE_6M; ii--) {
 779                 if ((pDevice->basic_rates) & ((u32)(1 << ii))) {
 780                         byTopOFDM = ii;
 781                         break;
 782                 }
 783         }
 784         pDevice->byTopOFDMBasicRate = byTopOFDM;
 785
 786         for (ii = RATE_11M;; ii--) {
 787                 if ((pDevice->basic_rates) & ((u32)(1 << ii))) {
 788                         byTopCCK = ii;
 789                         break;
 790                 }
 791                 if (ii == RATE_1M)
 792                         break;
 793         }
 794         pDevice->byTopCCKBasicRate = byTopCCK;
 795 }
 796
 797 bool CARDbIsOFDMinBasicRate(struct vnt_private *pDevice)
 798 {
 799         int ii;
 800
 801         for (ii = RATE_54M; ii >= RATE_6M; ii--) {
 802                 if ((pDevice->basic_rates) & ((u32)(1 << ii)))
 803                         return true;
 804         }
 805         return false;
 806 }
 807
 808 unsigned char CARDbyGetPktType(struct vnt_private *pDevice)
 809 {
 810
 811         if (pDevice->byBBType == BB_TYPE_11A || pDevice->byBBType == BB_TYPE_11B)
 812                 return (unsigned char)pDevice->byBBType;
 813         else if (CARDbIsOFDMinBasicRate((void *)pDevice))
 814                 return PK_TYPE_11GA;
 815         else
 816                 return PK_TYPE_11GB;
 817 }
 818
 819 /*
 820  * Description: Set NIC Loopback mode
 821  *
 822  * Parameters:
 823  *  In:
 824  *      pDevice         - The adapter to be set
 825  *      wLoopbackMode   - Loopback mode to be set
 826  *  Out:
 827  *      none
 828  *
 829  * Return Value: none
 830  */
 831 void CARDvSetLoopbackMode(struct vnt_private *priv, unsigned short wLoopbackMode)
 832 {
 833         void __iomem *dwIoBase = priv->PortOffset;
 834
 835         switch (wLoopbackMode) {
 836         case CARD_LB_NONE:
 837         case CARD_LB_MAC:
 838         case CARD_LB_PHY:
 839                 break;
 840         default:
 841                 ASSERT(false);
 842                 break;
 843         }
 844         /* set MAC loopback */
 845         MACvSetLoopbackMode(dwIoBase, LOBYTE(wLoopbackMode));
 846         /* set Baseband loopback */
 847 }
 848
 849 /*
 850  * Description: Software Reset NIC
 851  *
 852  * Parameters:
 853  *  In:
 854  *      pDevice         - The adapter to be reset
 855  *  Out:
 856  *      none
 857  *
 858  * Return Value: none
 859  */
 860 bool CARDbSoftwareReset(struct vnt_private *pDevice)
 861 {
 862
 863         /* reset MAC */
 864         if (!MACbSafeSoftwareReset(pDevice->PortOffset))
 865                 return false;
 866
 867         return true;
 868 }
 869
 870 /*
 871  * Description: Calculate TSF offset of two TSF input
 872  *              Get TSF Offset from RxBCN's TSF and local TSF
 873  *
 874  * Parameters:
 875  *  In:
 876  *      pDevice         - The adapter to be sync.
 877  *      qwTSF1          - Rx BCN's TSF
 878  *      qwTSF2          - Local TSF
 879  *  Out:
 880  *      none
 881  *
 882  * Return Value: TSF Offset value
 883  */
 884 u64 CARDqGetTSFOffset(unsigned char byRxRate, u64 qwTSF1, u64 qwTSF2)
 885 {
 886         u64 qwTSFOffset = 0;
 887         unsigned short wRxBcnTSFOffst = 0;
 888
 889         wRxBcnTSFOffst = cwRXBCNTSFOff[byRxRate%MAX_RATE];
 890
 891         qwTSF2 += (u64)wRxBcnTSFOffst;
 892
 893         qwTSFOffset = qwTSF1 - qwTSF2;
 894
 895         return qwTSFOffset;
 896 }
 897
 898 /*
 899  * Description: Read NIC TSF counter
 900  *              Get local TSF counter
 901  *
 902  * Parameters:
 903  *  In:
 904  *      pDevice         - The adapter to be read
 905  *  Out:
 906  *      qwCurrTSF       - Current TSF counter
 907  *
 908  * Return Value: true if success; otherwise false
 909  */
 910 bool CARDbGetCurrentTSF(struct vnt_private *priv, u64 *pqwCurrTSF)
 911 {
 912         void __iomem *dwIoBase = priv->PortOffset;
 913         unsigned short ww;
 914         unsigned char byData;
 915
 916         MACvRegBitsOn(dwIoBase, MAC_REG_TFTCTL, TFTCTL_TSFCNTRRD);
 917         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
 918                 VNSvInPortB(dwIoBase + MAC_REG_TFTCTL, &byData);
 919                 if (!(byData & TFTCTL_TSFCNTRRD))
 920                         break;
 921         }
 922         if (ww == W_MAX_TIMEOUT)
 923                 return false;
 924         VNSvInPortD(dwIoBase + MAC_REG_TSFCNTR, (u32 *)pqwCurrTSF);
 925         VNSvInPortD(dwIoBase + MAC_REG_TSFCNTR + 4, (u32 *)pqwCurrTSF + 1);
 926
 927         return true;
 928 }
 929
 930 /*
 931  * Description: Read NIC TSF counter
 932  *              Get NEXTTBTT from adjusted TSF and Beacon Interval
 933  *
 934  * Parameters:
 935  *  In:
 936  *      qwTSF           - Current TSF counter
 937  *      wbeaconInterval - Beacon Interval
 938  *  Out:
 939  *      qwCurrTSF       - Current TSF counter
 940  *
 941  * Return Value: TSF value of next Beacon
 942  */
 943 u64 CARDqGetNextTBTT(u64 qwTSF, unsigned short wBeaconInterval)
 944 {
 945         u32 beacon_int;
 946
 947         beacon_int = wBeaconInterval * 1024;
 948         if (beacon_int) {
 949                 do_div(qwTSF, beacon_int);
 950                 qwTSF += 1;
 951                 qwTSF *= beacon_int;
 952         }
 953
 954         return qwTSF;
 955 }
 956
 957 /*
 958  * Description: Set NIC TSF counter for first Beacon time
 959  *              Get NEXTTBTT from adjusted TSF and Beacon Interval
 960  *
 961  * Parameters:
 962  *  In:
 963  *      dwIoBase        - IO Base
 964  *      wBeaconInterval - Beacon Interval
 965  *  Out:
 966  *      none
 967  *
 968  * Return Value: none
 969  */
 970 void CARDvSetFirstNextTBTT(struct vnt_private *priv, unsigned short wBeaconInterval)
 971 {
 972         void __iomem *dwIoBase = priv->PortOffset;
 973         u64 qwNextTBTT = 0;
 974
 975         CARDbGetCurrentTSF(priv, &qwNextTBTT); /* Get Local TSF counter */
 976
 977         qwNextTBTT = CARDqGetNextTBTT(qwNextTBTT, wBeaconInterval);
 978         /* Set NextTBTT */
 979         VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT, (u32)qwNextTBTT);
 980         VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT + 4, (u32)(qwNextTBTT >> 32));
 981         MACvRegBitsOn(dwIoBase, MAC_REG_TFTCTL, TFTCTL_TBTTSYNCEN);
 982 }
 983
 984 /*
 985  * Description: Sync NIC TSF counter for Beacon time
 986  *              Get NEXTTBTT and write to HW
 987  *
 988  * Parameters:
 989  *  In:
 990  *      pDevice         - The adapter to be set
 991  *      qwTSF           - Current TSF counter
 992  *      wBeaconInterval - Beacon Interval
 993  *  Out:
 994  *      none
 995  *
 996  * Return Value: none
 997  */
 998 void CARDvUpdateNextTBTT(struct vnt_private *priv, u64 qwTSF, unsigned short wBeaconInterval)
 999 {
1000         void __iomem *dwIoBase = priv->PortOffset;
1001
1002         qwTSF = CARDqGetNextTBTT(qwTSF, wBeaconInterval);
1003         /* Set NextTBTT */
1004         VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT, (u32)qwTSF);
1005         VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT + 4, (u32)(qwTSF >> 32));
1006         MACvRegBitsOn(dwIoBase, MAC_REG_TFTCTL, TFTCTL_TBTTSYNCEN);
1007         pr_debug("Card:Update Next TBTT[%8llx]\n", qwTSF);
1008 }