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  *      priv             - The adapter to be set
 201  *  Out:
 202  *      none
 203  *
 204  * Return Value: None.
 205  */
 206 bool CARDbSetPhyParameter(struct vnt_private *priv, 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 (priv->byRFType == RF_AIROHA7230) {
 218                         /* AL7230 use single PAPE and connect to PAPE_2.4G */
 219                         MACvSetBBType(priv->PortOffset, BB_TYPE_11G);
 220                         priv->abyBBVGA[0] = 0x20;
 221                         priv->abyBBVGA[2] = 0x10;
 222                         priv->abyBBVGA[3] = 0x10;
 223                         BBbReadEmbedded(priv, 0xE7, &byData);
 224                         if (byData == 0x1C)
 225                                 BBbWriteEmbedded(priv, 0xE7, priv->abyBBVGA[0]);
 226
 227                 } else if (priv->byRFType == RF_UW2452) {
 228                         MACvSetBBType(priv->PortOffset, BB_TYPE_11A);
 229                         priv->abyBBVGA[0] = 0x18;
 230                         BBbReadEmbedded(priv, 0xE7, &byData);
 231                         if (byData == 0x14) {
 232                                 BBbWriteEmbedded(priv, 0xE7, priv->abyBBVGA[0]);
 233                                 BBbWriteEmbedded(priv, 0xE1, 0x57);
 234                         }
 235                 } else {
 236                         MACvSetBBType(priv->PortOffset, BB_TYPE_11A);
 237                 }
 238                 BBbWriteEmbedded(priv, 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(priv->PortOffset, BB_TYPE_11B);
 245                 if (priv->byRFType == RF_AIROHA7230) {
 246                         priv->abyBBVGA[0] = 0x1C;
 247                         priv->abyBBVGA[2] = 0x00;
 248                         priv->abyBBVGA[3] = 0x00;
 249                         BBbReadEmbedded(priv, 0xE7, &byData);
 250                         if (byData == 0x20)
 251                                 BBbWriteEmbedded(priv, 0xE7, priv->abyBBVGA[0]);
 252
 253                 } else if (priv->byRFType == RF_UW2452) {
 254                         priv->abyBBVGA[0] = 0x14;
 255                         BBbReadEmbedded(priv, 0xE7, &byData);
 256                         if (byData == 0x18) {
 257                                 BBbWriteEmbedded(priv, 0xE7, priv->abyBBVGA[0]);
 258                                 BBbWriteEmbedded(priv, 0xE1, 0xD3);
 259                         }
 260                 }
 261                 BBbWriteEmbedded(priv, 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(priv->PortOffset, BB_TYPE_11G);
 268                 if (priv->byRFType == RF_AIROHA7230) {
 269                         priv->abyBBVGA[0] = 0x1C;
 270                         priv->abyBBVGA[2] = 0x00;
 271                         priv->abyBBVGA[3] = 0x00;
 272                         BBbReadEmbedded(priv, 0xE7, &byData);
 273                         if (byData == 0x20)
 274                                 BBbWriteEmbedded(priv, 0xE7, priv->abyBBVGA[0]);
 275
 276                 } else if (priv->byRFType == RF_UW2452) {
 277                         priv->abyBBVGA[0] = 0x14;
 278                         BBbReadEmbedded(priv, 0xE7, &byData);
 279                         if (byData == 0x18) {
 280                                 BBbWriteEmbedded(priv, 0xE7, priv->abyBBVGA[0]);
 281                                 BBbWriteEmbedded(priv, 0xE1, 0xD3);
 282                         }
 283                 }
 284                 BBbWriteEmbedded(priv, 0x88, 0x08);
 285                 bySIFS = C_SIFS_BG;
 286
 287                 if (priv->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 (priv->basic_rates & ((u32)(0x1 << i))) {
 299                                 byCWMaxMin |= 0x1;
 300                                 break;
 301                         }
 302                 }
 303         }
 304
 305         if (priv->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 (priv->bySIFS != bySIFS) {
 320                 priv->bySIFS = bySIFS;
 321                 VNSvOutPortB(priv->PortOffset + MAC_REG_SIFS, priv->bySIFS);
 322         }
 323         if (priv->byDIFS != byDIFS) {
 324                 priv->byDIFS = byDIFS;
 325                 VNSvOutPortB(priv->PortOffset + MAC_REG_DIFS, priv->byDIFS);
 326         }
 327         if (priv->byEIFS != C_EIFS) {
 328                 priv->byEIFS = C_EIFS;
 329                 VNSvOutPortB(priv->PortOffset + MAC_REG_EIFS, priv->byEIFS);
 330         }
 331         if (priv->bySlot != bySlot) {
 332                 priv->bySlot = bySlot;
 333                 VNSvOutPortB(priv->PortOffset + MAC_REG_SLOT, priv->bySlot);
 334
 335                 BBvSetShortSlotTime(priv);
 336         }
 337         if (priv->byCWMaxMin != byCWMaxMin) {
 338                 priv->byCWMaxMin = byCWMaxMin;
 339                 VNSvOutPortB(priv->PortOffset + MAC_REG_CWMAXMIN0, priv->byCWMaxMin);
 340         }
 341
 342         priv->byPacketType = CARDbyGetPktType(priv);
 343
 344         CARDvSetRSPINF(priv, 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  *      priv         - 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 *priv, unsigned char byRxRate,
 365                     u64 qwBSSTimestamp)
 366 {
 367         u64 local_tsf;
 368         u64 qwTSFOffset = 0;
 369
 370         CARDbGetCurrentTSF(priv, &local_tsf);
 371
 372         if (qwBSSTimestamp != local_tsf) {
 373                 qwTSFOffset = CARDqGetTSFOffset(byRxRate, qwBSSTimestamp,
 374                                                 local_tsf);
 375                 /* adjust TSF, HW's TSF add TSF Offset reg */
 376                 VNSvOutPortD(priv->PortOffset + MAC_REG_TSFOFST, (u32)qwTSFOffset);
 377                 VNSvOutPortD(priv->PortOffset + MAC_REG_TSFOFST + 4, (u32)(qwTSFOffset >> 32));
 378                 MACvRegBitsOn(priv->PortOffset, MAC_REG_TFTCTL, TFTCTL_TSFSYNCEN);
 379         }
 380         return true;
 381 }
 382
 383 /*
 384  * Description: Set NIC TSF counter for first Beacon time
 385  *              Get NEXTTBTT from adjusted TSF and Beacon Interval
 386  *
 387  * Parameters:
 388  *  In:
 389  *      priv         - The adapter to be set.
 390  *      wBeaconInterval - Beacon Interval
 391  *  Out:
 392  *      none
 393  *
 394  * Return Value: true if succeed; otherwise false
 395  */
 396 bool CARDbSetBeaconPeriod(struct vnt_private *priv,
 397                           unsigned short wBeaconInterval)
 398 {
 399         u64 qwNextTBTT = 0;
 400
 401         CARDbGetCurrentTSF(priv, &qwNextTBTT); /* Get Local TSF counter */
 402
 403         qwNextTBTT = CARDqGetNextTBTT(qwNextTBTT, wBeaconInterval);
 404
 405         /* set HW beacon interval */
 406         VNSvOutPortW(priv->PortOffset + MAC_REG_BI, wBeaconInterval);
 407         priv->wBeaconInterval = wBeaconInterval;
 408         /* Set NextTBTT */
 409         VNSvOutPortD(priv->PortOffset + MAC_REG_NEXTTBTT, (u32)qwNextTBTT);
 410         VNSvOutPortD(priv->PortOffset + MAC_REG_NEXTTBTT + 4, (u32)(qwNextTBTT >> 32));
 411         MACvRegBitsOn(priv->PortOffset, MAC_REG_TFTCTL, TFTCTL_TBTTSYNCEN);
 412
 413         return true;
 414 }
 415
 416 /*
 417  * Description: Turn off Radio power
 418  *
 419  * Parameters:
 420  *  In:
 421  *      priv         - The adapter to be turned off
 422  *  Out:
 423  *      none
 424  *
 425  * Return Value: true if success; otherwise false
 426  */
 427 bool CARDbRadioPowerOff(struct vnt_private *priv)
 428 {
 429         bool bResult = true;
 430
 431         if (priv->bRadioOff)
 432                 return true;
 433
 434         switch (priv->byRFType) {
 435         case RF_RFMD2959:
 436                 MACvWordRegBitsOff(priv->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_TXPEINV);
 437                 MACvWordRegBitsOn(priv->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPE1);
 438                 break;
 439
 440         case RF_AIROHA:
 441         case RF_AL2230S:
 442         case RF_AIROHA7230:
 443                 MACvWordRegBitsOff(priv->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPE2);
 444                 MACvWordRegBitsOff(priv->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPE3);
 445                 break;
 446         }
 447
 448         MACvRegBitsOff(priv->PortOffset, MAC_REG_HOSTCR, HOSTCR_RXON);
 449
 450         BBvSetDeepSleep(priv, priv->byLocalID);
 451
 452         priv->bRadioOff = true;
 453         pr_debug("chester power off\n");
 454         MACvRegBitsOn(priv->PortOffset, MAC_REG_GPIOCTL0, LED_ACTSET);  /* LED issue */
 455         return bResult;
 456 }
 457
 458 /*
 459  * Description: Turn on Radio power
 460  *
 461  * Parameters:
 462  *  In:
 463  *      priv         - The adapter to be turned on
 464  *  Out:
 465  *      none
 466  *
 467  * Return Value: true if success; otherwise false
 468  */
 469 bool CARDbRadioPowerOn(struct vnt_private *priv)
 470 {
 471         bool bResult = true;
 472
 473         pr_debug("chester power on\n");
 474         if (priv->bRadioControlOff) {
 475                 if (priv->bHWRadioOff)
 476                         pr_debug("chester bHWRadioOff\n");
 477                 if (priv->bRadioControlOff)
 478                         pr_debug("chester bRadioControlOff\n");
 479                 return false; }
 480
 481         if (!priv->bRadioOff) {
 482                 pr_debug("chester pbRadioOff\n");
 483                 return true; }
 484
 485         BBvExitDeepSleep(priv, priv->byLocalID);
 486
 487         MACvRegBitsOn(priv->PortOffset, MAC_REG_HOSTCR, HOSTCR_RXON);
 488
 489         switch (priv->byRFType) {
 490         case RF_RFMD2959:
 491                 MACvWordRegBitsOn(priv->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_TXPEINV);
 492                 MACvWordRegBitsOff(priv->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPE1);
 493                 break;
 494
 495         case RF_AIROHA:
 496         case RF_AL2230S:
 497         case RF_AIROHA7230:
 498                 MACvWordRegBitsOn(priv->PortOffset, MAC_REG_SOFTPWRCTL, (SOFTPWRCTL_SWPE2 |
 499                                                                             SOFTPWRCTL_SWPE3));
 500                 break;
 501         }
 502
 503         priv->bRadioOff = false;
 504         pr_debug("chester power on\n");
 505         MACvRegBitsOff(priv->PortOffset, MAC_REG_GPIOCTL0, LED_ACTSET); /* LED issue */
 506         return bResult;
 507 }
 508
 509 void
 510 CARDvSafeResetTx(
 511         struct vnt_private *priv
 512 )
 513 {
 514         unsigned int uu;
 515         struct vnt_tx_desc *pCurrTD;
 516
 517         /* initialize TD index */
 518         priv->apTailTD[0] = priv->apCurrTD[0] = &(priv->apTD0Rings[0]);
 519         priv->apTailTD[1] = priv->apCurrTD[1] = &(priv->apTD1Rings[0]);
 520
 521         for (uu = 0; uu < TYPE_MAXTD; uu++)
 522                 priv->iTDUsed[uu] = 0;
 523
 524         for (uu = 0; uu < priv->opts.tx_descs[0]; uu++) {
 525                 pCurrTD = &(priv->apTD0Rings[uu]);
 526                 pCurrTD->td0.owner = OWNED_BY_HOST;
 527                 /* init all Tx Packet pointer to NULL */
 528         }
 529         for (uu = 0; uu < priv->opts.tx_descs[1]; uu++) {
 530                 pCurrTD = &(priv->apTD1Rings[uu]);
 531                 pCurrTD->td0.owner = OWNED_BY_HOST;
 532                 /* init all Tx Packet pointer to NULL */
 533         }
 534
 535         /* set MAC TD pointer */
 536         MACvSetCurrTXDescAddr(TYPE_TXDMA0, priv, priv->td0_pool_dma);
 537
 538         MACvSetCurrTXDescAddr(TYPE_AC0DMA, priv, priv->td1_pool_dma);
 539
 540         /* set MAC Beacon TX pointer */
 541         MACvSetCurrBCNTxDescAddr(priv->PortOffset,
 542                                  (priv->tx_beacon_dma));
 543 }
 544
 545 /*
 546  * Description:
 547  *      Reset Rx
 548  *
 549  * Parameters:
 550  *  In:
 551  *      priv     - Pointer to the adapter
 552  *  Out:
 553  *      none
 554  *
 555  * Return Value: none
 556  */
 557 void
 558 CARDvSafeResetRx(
 559         struct vnt_private *priv
 560 )
 561 {
 562         unsigned int uu;
 563         struct vnt_rx_desc *pDesc;
 564
 565         /* initialize RD index */
 566         priv->pCurrRD[0] = &(priv->aRD0Ring[0]);
 567         priv->pCurrRD[1] = &(priv->aRD1Ring[0]);
 568
 569         /* init state, all RD is chip's */
 570         for (uu = 0; uu < priv->opts.rx_descs0; uu++) {
 571                 pDesc = &(priv->aRD0Ring[uu]);
 572                 pDesc->rd0.res_count = cpu_to_le16(priv->rx_buf_sz);
 573                 pDesc->rd0.owner = OWNED_BY_NIC;
 574                 pDesc->rd1.req_count = cpu_to_le16(priv->rx_buf_sz);
 575         }
 576
 577         /* init state, all RD is chip's */
 578         for (uu = 0; uu < priv->opts.rx_descs1; uu++) {
 579                 pDesc = &(priv->aRD1Ring[uu]);
 580                 pDesc->rd0.res_count = cpu_to_le16(priv->rx_buf_sz);
 581                 pDesc->rd0.owner = OWNED_BY_NIC;
 582                 pDesc->rd1.req_count = cpu_to_le16(priv->rx_buf_sz);
 583         }
 584
 585         /* set perPkt mode */
 586         MACvRx0PerPktMode(priv->PortOffset);
 587         MACvRx1PerPktMode(priv->PortOffset);
 588         /* set MAC RD pointer */
 589         MACvSetCurrRx0DescAddr(priv, priv->rd0_pool_dma);
 590
 591         MACvSetCurrRx1DescAddr(priv, priv->rd1_pool_dma);
 592 }
 593
 594 /*
 595  * Description: Get response Control frame rate in CCK mode
 596  *
 597  * Parameters:
 598  *  In:
 599  *      priv             - The adapter to be set
 600  *      wRateIdx            - Receiving data rate
 601  *  Out:
 602  *      none
 603  *
 604  * Return Value: response Control frame rate
 605  */
 606 static unsigned short CARDwGetCCKControlRate(struct vnt_private *priv,
 607                                              unsigned short wRateIdx)
 608 {
 609         unsigned int ui = (unsigned int) wRateIdx;
 610
 611         while (ui > RATE_1M) {
 612                 if (priv->basic_rates & ((u32)0x1 << ui))
 613                         return (unsigned short)ui;
 614
 615                 ui--;
 616         }
 617         return (unsigned short)RATE_1M;
 618 }
 619
 620 /*
 621  * Description: Get response Control frame rate in OFDM mode
 622  *
 623  * Parameters:
 624  *  In:
 625  *      priv             - The adapter to be set
 626  *      wRateIdx            - Receiving data rate
 627  *  Out:
 628  *      none
 629  *
 630  * Return Value: response Control frame rate
 631  */
 632 static unsigned short CARDwGetOFDMControlRate(struct vnt_private *priv,
 633                                               unsigned short wRateIdx)
 634 {
 635         unsigned int ui = (unsigned int) wRateIdx;
 636
 637         pr_debug("BASIC RATE: %X\n", priv->basic_rates);
 638
 639         if (!CARDbIsOFDMinBasicRate((void *)priv)) {
 640                 pr_debug("CARDwGetOFDMControlRate:(NO OFDM) %d\n", wRateIdx);
 641                 if (wRateIdx > RATE_24M)
 642                         wRateIdx = RATE_24M;
 643                 return wRateIdx;
 644         }
 645         while (ui > RATE_11M) {
 646                 if (priv->basic_rates & ((u32)0x1 << ui)) {
 647                         pr_debug("CARDwGetOFDMControlRate : %d\n", ui);
 648                         return (unsigned short)ui;
 649                 }
 650                 ui--;
 651         }
 652         pr_debug("CARDwGetOFDMControlRate: 6M\n");
 653         return (unsigned short)RATE_24M;
 654 }
 655
 656 /*
 657  * Description: Set RSPINF
 658  *
 659  * Parameters:
 660  *  In:
 661  *      priv             - The adapter to be set
 662  *  Out:
 663  *      none
 664  *
 665  * Return Value: None.
 666  */
 667 void CARDvSetRSPINF(struct vnt_private *priv, u8 bb_type)
 668 {
 669         union vnt_phy_field_swap phy;
 670         unsigned char byTxRate, byRsvTime;      /* For OFDM */
 671         unsigned long flags;
 672
 673         spin_lock_irqsave(&priv->lock, flags);
 674
 675         /* Set to Page1 */
 676         MACvSelectPage1(priv->PortOffset);
 677
 678         /* RSPINF_b_1 */
 679         vnt_get_phy_field(priv, 14,
 680                           CARDwGetCCKControlRate(priv, 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(priv->PortOffset + MAC_REG_RSPINF_B_1, phy.field_write);
 687
 688         /* RSPINF_b_2 */
 689         vnt_get_phy_field(priv, 14,
 690                           CARDwGetCCKControlRate(priv, RATE_2M),
 691                           PK_TYPE_11B, &phy.field_read);
 692
 693         swap(phy.swap[0], phy.swap[1]);
 694
 695         VNSvOutPortD(priv->PortOffset + MAC_REG_RSPINF_B_2, phy.field_write);
 696
 697         /* RSPINF_b_5 */
 698         vnt_get_phy_field(priv, 14,
 699                           CARDwGetCCKControlRate(priv, RATE_5M),
 700                           PK_TYPE_11B, &phy.field_read);
 701
 702         swap(phy.swap[0], phy.swap[1]);
 703
 704         VNSvOutPortD(priv->PortOffset + MAC_REG_RSPINF_B_5, phy.field_write);
 705
 706         /* RSPINF_b_11 */
 707         vnt_get_phy_field(priv, 14,
 708                           CARDwGetCCKControlRate(priv, RATE_11M),
 709                           PK_TYPE_11B, &phy.field_read);
 710
 711         swap(phy.swap[0], phy.swap[1]);
 712
 713         VNSvOutPortD(priv->PortOffset + MAC_REG_RSPINF_B_11, phy.field_write);
 714
 715         /* RSPINF_a_6 */
 716         s_vCalculateOFDMRParameter(RATE_6M,
 717                                    bb_type,
 718                                    &byTxRate,
 719                                    &byRsvTime);
 720         VNSvOutPortW(priv->PortOffset + MAC_REG_RSPINF_A_6, MAKEWORD(byTxRate, byRsvTime));
 721         /* RSPINF_a_9 */
 722         s_vCalculateOFDMRParameter(RATE_9M,
 723                                    bb_type,
 724                                    &byTxRate,
 725                                    &byRsvTime);
 726         VNSvOutPortW(priv->PortOffset + MAC_REG_RSPINF_A_9, MAKEWORD(byTxRate, byRsvTime));
 727         /* RSPINF_a_12 */
 728         s_vCalculateOFDMRParameter(RATE_12M,
 729                                    bb_type,
 730                                    &byTxRate,
 731                                    &byRsvTime);
 732         VNSvOutPortW(priv->PortOffset + MAC_REG_RSPINF_A_12, MAKEWORD(byTxRate, byRsvTime));
 733         /* RSPINF_a_18 */
 734         s_vCalculateOFDMRParameter(RATE_18M,
 735                                    bb_type,
 736                                    &byTxRate,
 737                                    &byRsvTime);
 738         VNSvOutPortW(priv->PortOffset + MAC_REG_RSPINF_A_18, MAKEWORD(byTxRate, byRsvTime));
 739         /* RSPINF_a_24 */
 740         s_vCalculateOFDMRParameter(RATE_24M,
 741                                    bb_type,
 742                                    &byTxRate,
 743                                    &byRsvTime);
 744         VNSvOutPortW(priv->PortOffset + MAC_REG_RSPINF_A_24, MAKEWORD(byTxRate, byRsvTime));
 745         /* RSPINF_a_36 */
 746         s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate((void *)priv, RATE_36M),
 747                                    bb_type,
 748                                    &byTxRate,
 749                                    &byRsvTime);
 750         VNSvOutPortW(priv->PortOffset + MAC_REG_RSPINF_A_36, MAKEWORD(byTxRate, byRsvTime));
 751         /* RSPINF_a_48 */
 752         s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate((void *)priv, RATE_48M),
 753                                    bb_type,
 754                                    &byTxRate,
 755                                    &byRsvTime);
 756         VNSvOutPortW(priv->PortOffset + MAC_REG_RSPINF_A_48, MAKEWORD(byTxRate, byRsvTime));
 757         /* RSPINF_a_54 */
 758         s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate((void *)priv, RATE_54M),
 759                                    bb_type,
 760                                    &byTxRate,
 761                                    &byRsvTime);
 762         VNSvOutPortW(priv->PortOffset + MAC_REG_RSPINF_A_54, MAKEWORD(byTxRate, byRsvTime));
 763         /* RSPINF_a_72 */
 764         s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate((void *)priv, RATE_54M),
 765                                    bb_type,
 766                                    &byTxRate,
 767                                    &byRsvTime);
 768         VNSvOutPortW(priv->PortOffset + MAC_REG_RSPINF_A_72, MAKEWORD(byTxRate, byRsvTime));
 769         /* Set to Page0 */
 770         MACvSelectPage0(priv->PortOffset);
 771
 772         spin_unlock_irqrestore(&priv->lock, flags);
 773 }
 774
 775 void CARDvUpdateBasicTopRate(struct vnt_private *priv)
 776 {
 777         unsigned char byTopOFDM = RATE_24M, byTopCCK = RATE_1M;
 778         unsigned char ii;
 779
 780         /* Determines the highest basic rate. */
 781         for (ii = RATE_54M; ii >= RATE_6M; ii--) {
 782                 if ((priv->basic_rates) & ((u32)(1 << ii))) {
 783                         byTopOFDM = ii;
 784                         break;
 785                 }
 786         }
 787         priv->byTopOFDMBasicRate = byTopOFDM;
 788
 789         for (ii = RATE_11M;; ii--) {
 790                 if ((priv->basic_rates) & ((u32)(1 << ii))) {
 791                         byTopCCK = ii;
 792                         break;
 793                 }
 794                 if (ii == RATE_1M)
 795                         break;
 796         }
 797         priv->byTopCCKBasicRate = byTopCCK;
 798 }
 799
 800 bool CARDbIsOFDMinBasicRate(struct vnt_private *priv)
 801 {
 802         int ii;
 803
 804         for (ii = RATE_54M; ii >= RATE_6M; ii--) {
 805                 if ((priv->basic_rates) & ((u32)BIT(ii)))
 806                         return true;
 807         }
 808         return false;
 809 }
 810
 811 unsigned char CARDbyGetPktType(struct vnt_private *priv)
 812 {
 813         if (priv->byBBType == BB_TYPE_11A || priv->byBBType == BB_TYPE_11B)
 814                 return (unsigned char)priv->byBBType;
 815         else if (CARDbIsOFDMinBasicRate((void *)priv))
 816                 return PK_TYPE_11GA;
 817         else
 818                 return PK_TYPE_11GB;
 819 }
 820
 821 /*
 822  * Description: Set NIC Loopback mode
 823  *
 824  * Parameters:
 825  *  In:
 826  *      priv         - The adapter to be set
 827  *      wLoopbackMode   - Loopback mode to be set
 828  *  Out:
 829  *      none
 830  *
 831  * Return Value: none
 832  */
 833 void CARDvSetLoopbackMode(struct vnt_private *priv, unsigned short wLoopbackMode)
 834 {
 835         switch (wLoopbackMode) {
 836         case CARD_LB_NONE:
 837         case CARD_LB_MAC:
 838         case CARD_LB_PHY:
 839                 break;
 840         default:
 841                 break;
 842         }
 843         /* set MAC loopback */
 844         MACvSetLoopbackMode(priv, LOBYTE(wLoopbackMode));
 845         /* set Baseband loopback */
 846 }
 847
 848 /*
 849  * Description: Software Reset NIC
 850  *
 851  * Parameters:
 852  *  In:
 853  *      priv         - The adapter to be reset
 854  *  Out:
 855  *      none
 856  *
 857  * Return Value: none
 858  */
 859 bool CARDbSoftwareReset(struct vnt_private *priv)
 860 {
 861         /* reset MAC */
 862         if (!MACbSafeSoftwareReset(priv))
 863                 return false;
 864
 865         return true;
 866 }
 867
 868 /*
 869  * Description: Calculate TSF offset of two TSF input
 870  *              Get TSF Offset from RxBCN's TSF and local TSF
 871  *
 872  * Parameters:
 873  *  In:
 874  *      priv         - The adapter to be sync.
 875  *      qwTSF1          - Rx BCN's TSF
 876  *      qwTSF2          - Local TSF
 877  *  Out:
 878  *      none
 879  *
 880  * Return Value: TSF Offset value
 881  */
 882 u64 CARDqGetTSFOffset(unsigned char byRxRate, u64 qwTSF1, u64 qwTSF2)
 883 {
 884         u64 qwTSFOffset = 0;
 885         unsigned short wRxBcnTSFOffst;
 886
 887         wRxBcnTSFOffst = cwRXBCNTSFOff[byRxRate%MAX_RATE];
 888
 889         qwTSF2 += (u64)wRxBcnTSFOffst;
 890
 891         qwTSFOffset = qwTSF1 - qwTSF2;
 892
 893         return qwTSFOffset;
 894 }
 895
 896 /*
 897  * Description: Read NIC TSF counter
 898  *              Get local TSF counter
 899  *
 900  * Parameters:
 901  *  In:
 902  *      priv         - The adapter to be read
 903  *  Out:
 904  *      qwCurrTSF       - Current TSF counter
 905  *
 906  * Return Value: true if success; otherwise false
 907  */
 908 bool CARDbGetCurrentTSF(struct vnt_private *priv, u64 *pqwCurrTSF)
 909 {
 910         void __iomem *dwIoBase = priv->PortOffset;
 911         unsigned short ww;
 912         unsigned char byData;
 913
 914         MACvRegBitsOn(dwIoBase, MAC_REG_TFTCTL, TFTCTL_TSFCNTRRD);
 915         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
 916                 VNSvInPortB(dwIoBase + MAC_REG_TFTCTL, &byData);
 917                 if (!(byData & TFTCTL_TSFCNTRRD))
 918                         break;
 919         }
 920         if (ww == W_MAX_TIMEOUT)
 921                 return false;
 922         VNSvInPortD(dwIoBase + MAC_REG_TSFCNTR, (u32 *)pqwCurrTSF);
 923         VNSvInPortD(dwIoBase + MAC_REG_TSFCNTR + 4, (u32 *)pqwCurrTSF + 1);
 924
 925         return true;
 926 }
 927
 928 /*
 929  * Description: Read NIC TSF counter
 930  *              Get NEXTTBTT from adjusted TSF and Beacon Interval
 931  *
 932  * Parameters:
 933  *  In:
 934  *      qwTSF           - Current TSF counter
 935  *      wbeaconInterval - Beacon Interval
 936  *  Out:
 937  *      qwCurrTSF       - Current TSF counter
 938  *
 939  * Return Value: TSF value of next Beacon
 940  */
 941 u64 CARDqGetNextTBTT(u64 qwTSF, unsigned short wBeaconInterval)
 942 {
 943         u32 beacon_int;
 944
 945         beacon_int = wBeaconInterval * 1024;
 946         if (beacon_int) {
 947                 do_div(qwTSF, beacon_int);
 948                 qwTSF += 1;
 949                 qwTSF *= beacon_int;
 950         }
 951
 952         return qwTSF;
 953 }
 954
 955 /*
 956  * Description: Set NIC TSF counter for first Beacon time
 957  *              Get NEXTTBTT from adjusted TSF and Beacon Interval
 958  *
 959  * Parameters:
 960  *  In:
 961  *      dwIoBase        - IO Base
 962  *      wBeaconInterval - Beacon Interval
 963  *  Out:
 964  *      none
 965  *
 966  * Return Value: none
 967  */
 968 void CARDvSetFirstNextTBTT(struct vnt_private *priv, unsigned short wBeaconInterval)
 969 {
 970         void __iomem *dwIoBase = priv->PortOffset;
 971         u64 qwNextTBTT = 0;
 972
 973         CARDbGetCurrentTSF(priv, &qwNextTBTT); /* Get Local TSF counter */
 974
 975         qwNextTBTT = CARDqGetNextTBTT(qwNextTBTT, wBeaconInterval);
 976         /* Set NextTBTT */
 977         VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT, (u32)qwNextTBTT);
 978         VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT + 4, (u32)(qwNextTBTT >> 32));
 979         MACvRegBitsOn(dwIoBase, MAC_REG_TFTCTL, TFTCTL_TBTTSYNCEN);
 980 }
 981
 982 /*
 983  * Description: Sync NIC TSF counter for Beacon time
 984  *              Get NEXTTBTT and write to HW
 985  *
 986  * Parameters:
 987  *  In:
 988  *      priv         - The adapter to be set
 989  *      qwTSF           - Current TSF counter
 990  *      wBeaconInterval - Beacon Interval
 991  *  Out:
 992  *      none
 993  *
 994  * Return Value: none
 995  */
 996 void CARDvUpdateNextTBTT(struct vnt_private *priv, u64 qwTSF, unsigned short wBeaconInterval)
 997 {
 998         void __iomem *dwIoBase = priv->PortOffset;
 999
1000         qwTSF = CARDqGetNextTBTT(qwTSF, wBeaconInterval);
1001         /* Set NextTBTT */
1002         VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT, (u32)qwTSF);
1003         VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT + 4, (u32)(qwTSF >> 32));
1004         MACvRegBitsOn(dwIoBase, MAC_REG_TFTCTL, TFTCTL_TBTTSYNCEN);
1005         pr_debug("Card:Update Next TBTT[%8llx]\n", qwTSF);
1006 }