drivers/staging/vt6655/card.c

   1 /*
   2  * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
   3  * All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * File: card.c
  20  * Purpose: Provide functions to setup NIC operation mode
  21  * Functions:
  22  *      s_vSafeResetTx - Rest Tx
  23  *      CARDvSetRSPINF - Set RSPINF
  24  *      vUpdateIFS - Update slotTime,SIFS,DIFS, and EIFS
  25  *      CARDvUpdateBasicTopRate - Update BasicTopRate
  26  *      CARDbAddBasicRate - Add to BasicRateSet
  27  *      CARDbIsOFDMinBasicRate - Check if any OFDM rate is in BasicRateSet
  28  *      CARDvSetLoopbackMode - Set Loopback mode
  29  *      CARDbSoftwareReset - Sortware reset NIC
  30  *      CARDqGetTSFOffset - Calculate TSFOffset
  31  *      CARDbGetCurrentTSF - Read Current NIC TSF counter
  32  *      CARDqGetNextTBTT - Calculate Next Beacon TSF counter
  33  *      CARDvSetFirstNextTBTT - Set NIC Beacon time
  34  *      CARDvUpdateNextTBTT - Sync. NIC Beacon time
  35  *      CARDbRadioPowerOff - Turn Off NIC Radio Power
  36  *      CARDbRadioPowerOn - Turn On NIC Radio Power
  37  *      CARDbSetWEPMode - Set NIC Wep mode
  38  *      CARDbSetTxPower - Set NIC tx power
  39  *
  40  * Revision History:
  41  *      06-10-2003 Bryan YC Fan:  Re-write codes to support VT3253 spec.
  42  *      08-26-2003 Kyle Hsu:      Modify the defination type of dwIoBase.
  43  *      09-01-2003 Bryan YC Fan:  Add vUpdateIFS().
  44  *
  45  */
  46
  47 #include "tmacro.h"
  48 #include "card.h"
  49 #include "baseband.h"
  50 #include "mac.h"
  51 #include "desc.h"
  52 #include "rf.h"
  53 #include "vntwifi.h"
  54 #include "power.h"
  55 #include "key.h"
  56 #include "rc4.h"
  57 #include "country.h"
  58 #include "channel.h"
  59
  60 /*---------------------  Static Definitions -------------------------*/
  61
  62 static int msglevel = MSG_LEVEL_INFO;
  63
  64 #define C_SIFS_A        16      // micro sec.
  65 #define C_SIFS_BG       10
  66
  67 #define C_EIFS          80      // micro sec.
  68
  69 #define C_SLOT_SHORT    9       // micro sec.
  70 #define C_SLOT_LONG     20
  71
  72 #define C_CWMIN_A       15      // slot time
  73 #define C_CWMIN_B       31
  74
  75 #define C_CWMAX         1023    // slot time
  76
  77 #define WAIT_BEACON_TX_DOWN_TMO         3    // Times
  78
  79 //1M,   2M,   5M,  11M,  18M,  24M,  36M,  54M
  80 static unsigned char abyDefaultSuppRatesG[] = {WLAN_EID_SUPP_RATES, 8, 0x02, 0x04, 0x0B, 0x16, 0x24, 0x30, 0x48, 0x6C};
  81 //6M,   9M,  12M,  48M
  82 static unsigned char abyDefaultExtSuppRatesG[] = {WLAN_EID_EXTSUPP_RATES, 4, 0x0C, 0x12, 0x18, 0x60};
  83 //6M,   9M,  12M,  18M,  24M,  36M,  48M,  54M
  84 static unsigned char abyDefaultSuppRatesA[] = {WLAN_EID_SUPP_RATES, 8, 0x0C, 0x12, 0x18, 0x24, 0x30, 0x48, 0x60, 0x6C};
  85 //1M,   2M,   5M,  11M,
  86 static unsigned char abyDefaultSuppRatesB[] = {WLAN_EID_SUPP_RATES, 4, 0x02, 0x04, 0x0B, 0x16};
  87
  88 /*---------------------  Static Variables  --------------------------*/
  89
  90 const unsigned short cwRXBCNTSFOff[MAX_RATE] =
  91 {17, 17, 17, 17, 34, 23, 17, 11, 8, 5, 4, 3};
  92
  93 /*---------------------  Static Functions  --------------------------*/
  94
  95 static
  96 void
  97 s_vCalculateOFDMRParameter(
  98         unsigned char byRate,
  99         CARD_PHY_TYPE ePHYType,
 100         unsigned char *pbyTxRate,
 101         unsigned char *pbyRsvTime
 102 );
 103
 104 /*---------------------  Export Functions  --------------------------*/
 105
 106 /*
 107  * Description: Calculate TxRate and RsvTime fields for RSPINF in OFDM mode.
 108  *
 109  * Parameters:
 110  *  In:
 111  *      wRate           - Tx Rate
 112  *      byPktType       - Tx Packet type
 113  *  Out:
 114  *      pbyTxRate       - pointer to RSPINF TxRate field
 115  *      pbyRsvTime      - pointer to RSPINF RsvTime field
 116  *
 117  * Return Value: none
 118  *
 119  */
 120 static
 121 void
 122 s_vCalculateOFDMRParameter(
 123         unsigned char byRate,
 124         CARD_PHY_TYPE ePHYType,
 125         unsigned char *pbyTxRate,
 126         unsigned char *pbyRsvTime
 127 )
 128 {
 129         switch (byRate) {
 130         case RATE_6M:
 131                 if (ePHYType == PHY_TYPE_11A) {//5GHZ
 132                         *pbyTxRate = 0x9B;
 133                         *pbyRsvTime = 44;
 134                 } else {
 135                         *pbyTxRate = 0x8B;
 136                         *pbyRsvTime = 50;
 137                 }
 138                 break;
 139
 140         case RATE_9M:
 141                 if (ePHYType == PHY_TYPE_11A) {//5GHZ
 142                         *pbyTxRate = 0x9F;
 143                         *pbyRsvTime = 36;
 144                 } else {
 145                         *pbyTxRate = 0x8F;
 146                         *pbyRsvTime = 42;
 147                 }
 148                 break;
 149
 150         case RATE_12M:
 151                 if (ePHYType == PHY_TYPE_11A) {//5GHZ
 152                         *pbyTxRate = 0x9A;
 153                         *pbyRsvTime = 32;
 154                 } else {
 155                         *pbyTxRate = 0x8A;
 156                         *pbyRsvTime = 38;
 157                 }
 158                 break;
 159
 160         case RATE_18M:
 161                 if (ePHYType == PHY_TYPE_11A) {//5GHZ
 162                         *pbyTxRate = 0x9E;
 163                         *pbyRsvTime = 28;
 164                 } else {
 165                         *pbyTxRate = 0x8E;
 166                         *pbyRsvTime = 34;
 167                 }
 168                 break;
 169
 170         case RATE_36M:
 171                 if (ePHYType == PHY_TYPE_11A) {//5GHZ
 172                         *pbyTxRate = 0x9D;
 173                         *pbyRsvTime = 24;
 174                 } else {
 175                         *pbyTxRate = 0x8D;
 176                         *pbyRsvTime = 30;
 177                 }
 178                 break;
 179
 180         case RATE_48M:
 181                 if (ePHYType == PHY_TYPE_11A) {//5GHZ
 182                         *pbyTxRate = 0x98;
 183                         *pbyRsvTime = 24;
 184                 } else {
 185                         *pbyTxRate = 0x88;
 186                         *pbyRsvTime = 30;
 187                 }
 188                 break;
 189
 190         case RATE_54M:
 191                 if (ePHYType == PHY_TYPE_11A) {//5GHZ
 192                         *pbyTxRate = 0x9C;
 193                         *pbyRsvTime = 24;
 194                 } else {
 195                         *pbyTxRate = 0x8C;
 196                         *pbyRsvTime = 30;
 197                 }
 198                 break;
 199
 200         case RATE_24M:
 201         default:
 202                 if (ePHYType == PHY_TYPE_11A) {//5GHZ
 203                         *pbyTxRate = 0x99;
 204                         *pbyRsvTime = 28;
 205                 } else {
 206                         *pbyTxRate = 0x89;
 207                         *pbyRsvTime = 34;
 208                 }
 209                 break;
 210         }
 211 }
 212
 213 /*
 214  * Description: Set RSPINF
 215  *
 216  * Parameters:
 217  *  In:
 218  *      pDevice             - The adapter to be set
 219  *  Out:
 220  *      none
 221  *
 222  * Return Value: None.
 223  *
 224  */
 225 static
 226 void
 227 s_vSetRSPINF(PSDevice pDevice, CARD_PHY_TYPE ePHYType, void *pvSupportRateIEs, void *pvExtSupportRateIEs)
 228 {
 229         unsigned char byServ = 0, bySignal = 0; // For CCK
 230         unsigned short wLen = 0;
 231         unsigned char byTxRate = 0, byRsvTime = 0;    // For OFDM
 232
 233         //Set to Page1
 234         MACvSelectPage1(pDevice->PortOffset);
 235
 236         //RSPINF_b_1
 237         BBvCalculateParameter(pDevice,
 238                               14,
 239                               VNTWIFIbyGetACKTxRate(RATE_1M, pvSupportRateIEs, pvExtSupportRateIEs),
 240                               PK_TYPE_11B,
 241                               &wLen,
 242                               &byServ,
 243                               &bySignal
 244 );
 245
 246         VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_1, MAKEDWORD(wLen, MAKEWORD(bySignal, byServ)));
 247         ///RSPINF_b_2
 248         BBvCalculateParameter(pDevice,
 249                               14,
 250                               VNTWIFIbyGetACKTxRate(RATE_2M, pvSupportRateIEs, pvExtSupportRateIEs),
 251                               PK_TYPE_11B,
 252                               &wLen,
 253                               &byServ,
 254                               &bySignal
 255 );
 256
 257         VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_2, MAKEDWORD(wLen, MAKEWORD(bySignal, byServ)));
 258         //RSPINF_b_5
 259         BBvCalculateParameter(pDevice,
 260                               14,
 261                               VNTWIFIbyGetACKTxRate(RATE_5M, pvSupportRateIEs, pvExtSupportRateIEs),
 262                               PK_TYPE_11B,
 263                               &wLen,
 264                               &byServ,
 265                               &bySignal
 266 );
 267
 268         VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_5, MAKEDWORD(wLen, MAKEWORD(bySignal, byServ)));
 269         //RSPINF_b_11
 270         BBvCalculateParameter(pDevice,
 271                               14,
 272                               VNTWIFIbyGetACKTxRate(RATE_11M, pvSupportRateIEs, pvExtSupportRateIEs),
 273                               PK_TYPE_11B,
 274                               &wLen,
 275                               &byServ,
 276                               &bySignal
 277 );
 278
 279         VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_11, MAKEDWORD(wLen, MAKEWORD(bySignal, byServ)));
 280         //RSPINF_a_6
 281         s_vCalculateOFDMRParameter(RATE_6M,
 282                                    ePHYType,
 283                                    &byTxRate,
 284                                    &byRsvTime);
 285         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_6, MAKEWORD(byTxRate, byRsvTime));
 286         //RSPINF_a_9
 287         s_vCalculateOFDMRParameter(RATE_9M,
 288                                    ePHYType,
 289                                    &byTxRate,
 290                                    &byRsvTime);
 291         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_9, MAKEWORD(byTxRate, byRsvTime));
 292         //RSPINF_a_12
 293         s_vCalculateOFDMRParameter(RATE_12M,
 294                                    ePHYType,
 295                                    &byTxRate,
 296                                    &byRsvTime);
 297         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_12, MAKEWORD(byTxRate, byRsvTime));
 298         //RSPINF_a_18
 299         s_vCalculateOFDMRParameter(RATE_18M,
 300                                    ePHYType,
 301                                    &byTxRate,
 302                                    &byRsvTime);
 303         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_18, MAKEWORD(byTxRate, byRsvTime));
 304         //RSPINF_a_24
 305         s_vCalculateOFDMRParameter(RATE_24M,
 306                                    ePHYType,
 307                                    &byTxRate,
 308                                    &byRsvTime);
 309         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_24, MAKEWORD(byTxRate, byRsvTime));
 310         //RSPINF_a_36
 311         s_vCalculateOFDMRParameter(
 312                 VNTWIFIbyGetACKTxRate(RATE_36M, pvSupportRateIEs, pvExtSupportRateIEs),
 313                 ePHYType,
 314                 &byTxRate,
 315                 &byRsvTime);
 316         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_36, MAKEWORD(byTxRate, byRsvTime));
 317         //RSPINF_a_48
 318         s_vCalculateOFDMRParameter(
 319                 VNTWIFIbyGetACKTxRate(RATE_48M, pvSupportRateIEs, pvExtSupportRateIEs),
 320                 ePHYType,
 321                 &byTxRate,
 322                 &byRsvTime);
 323         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_48, MAKEWORD(byTxRate, byRsvTime));
 324         //RSPINF_a_54
 325         s_vCalculateOFDMRParameter(
 326                 VNTWIFIbyGetACKTxRate(RATE_54M, pvSupportRateIEs, pvExtSupportRateIEs),
 327                 ePHYType,
 328                 &byTxRate,
 329                 &byRsvTime);
 330         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_54, MAKEWORD(byTxRate, byRsvTime));
 331         //RSPINF_a_72
 332         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_72, MAKEWORD(byTxRate, byRsvTime));
 333         //Set to Page0
 334         MACvSelectPage0(pDevice->PortOffset);
 335 }
 336
 337 /*---------------------  Export Functions  --------------------------*/
 338
 339 /*
 340  * Description: Get Card short preamble option value
 341  *
 342  * Parameters:
 343  *  In:
 344  *      pDevice             - The adapter to be set
 345  *  Out:
 346  *      none
 347  *
 348  * Return Value: true if short preamble; otherwise false
 349  *
 350  */
 351 bool CARDbIsShortPreamble(void *pDeviceHandler)
 352 {
 353         PSDevice    pDevice = (PSDevice) pDeviceHandler;
 354         if (pDevice->byPreambleType == 0) {
 355                 return false;
 356         }
 357         return true;
 358 }
 359
 360 /*
 361  * Description: Get Card short slot time option value
 362  *
 363  * Parameters:
 364  *  In:
 365  *      pDevice             - The adapter to be set
 366  *  Out:
 367  *      none
 368  *
 369  * Return Value: true if short slot time; otherwise false
 370  *
 371  */
 372 bool CARDbIsShorSlotTime(void *pDeviceHandler)
 373 {
 374         PSDevice    pDevice = (PSDevice) pDeviceHandler;
 375         return pDevice->bShortSlotTime;
 376 }
 377
 378 /*
 379  * Description: Update IFS
 380  *
 381  * Parameters:
 382  *  In:
 383  *      pDevice             - The adapter to be set
 384  *  Out:
 385  *      none
 386  *
 387  * Return Value: None.
 388  *
 389  */
 390 bool CARDbSetPhyParameter(void *pDeviceHandler, CARD_PHY_TYPE ePHYType, unsigned short wCapInfo, unsigned char byERPField, void *pvSupportRateIEs, void *pvExtSupportRateIEs)
 391 {
 392         PSDevice    pDevice = (PSDevice) pDeviceHandler;
 393         unsigned char byCWMaxMin = 0;
 394         unsigned char bySlot = 0;
 395         unsigned char bySIFS = 0;
 396         unsigned char byDIFS = 0;
 397         unsigned char byData;
 398         PWLAN_IE_SUPP_RATES pSupportRates = (PWLAN_IE_SUPP_RATES) pvSupportRateIEs;
 399         PWLAN_IE_SUPP_RATES pExtSupportRates = (PWLAN_IE_SUPP_RATES) pvExtSupportRateIEs;
 400
 401         //Set SIFS, DIFS, EIFS, SlotTime, CwMin
 402         if (ePHYType == PHY_TYPE_11A) {
 403                 if (pSupportRates == NULL) {
 404                         pSupportRates = (PWLAN_IE_SUPP_RATES) abyDefaultSuppRatesA;
 405                 }
 406                 if (pDevice->byRFType == RF_AIROHA7230) {
 407                         // AL7230 use single PAPE and connect to PAPE_2.4G
 408                         MACvSetBBType(pDevice->PortOffset, BB_TYPE_11G);
 409                         pDevice->abyBBVGA[0] = 0x20;
 410                         pDevice->abyBBVGA[2] = 0x10;
 411                         pDevice->abyBBVGA[3] = 0x10;
 412                         BBbReadEmbedded(pDevice->PortOffset, 0xE7, &byData);
 413                         if (byData == 0x1C) {
 414                                 BBbWriteEmbedded(pDevice->PortOffset, 0xE7, pDevice->abyBBVGA[0]);
 415                         }
 416                 } else if (pDevice->byRFType == RF_UW2452) {
 417                         MACvSetBBType(pDevice->PortOffset, BB_TYPE_11A);
 418                         pDevice->abyBBVGA[0] = 0x18;
 419                         BBbReadEmbedded(pDevice->PortOffset, 0xE7, &byData);
 420                         if (byData == 0x14) {
 421                                 BBbWriteEmbedded(pDevice->PortOffset, 0xE7, pDevice->abyBBVGA[0]);
 422                                 BBbWriteEmbedded(pDevice->PortOffset, 0xE1, 0x57);
 423                         }
 424                 } else {
 425                         MACvSetBBType(pDevice->PortOffset, BB_TYPE_11A);
 426                 }
 427                 BBbWriteEmbedded(pDevice->PortOffset, 0x88, 0x03);
 428                 bySlot = C_SLOT_SHORT;
 429                 bySIFS = C_SIFS_A;
 430                 byDIFS = C_SIFS_A + 2*C_SLOT_SHORT;
 431                 byCWMaxMin = 0xA4;
 432         } else if (ePHYType == PHY_TYPE_11B) {
 433                 if (pSupportRates == NULL) {
 434                         pSupportRates = (PWLAN_IE_SUPP_RATES) abyDefaultSuppRatesB;
 435                 }
 436                 MACvSetBBType(pDevice->PortOffset, BB_TYPE_11B);
 437                 if (pDevice->byRFType == RF_AIROHA7230) {
 438                         pDevice->abyBBVGA[0] = 0x1C;
 439                         pDevice->abyBBVGA[2] = 0x00;
 440                         pDevice->abyBBVGA[3] = 0x00;
 441                         BBbReadEmbedded(pDevice->PortOffset, 0xE7, &byData);
 442                         if (byData == 0x20) {
 443                                 BBbWriteEmbedded(pDevice->PortOffset, 0xE7, pDevice->abyBBVGA[0]);
 444                         }
 445                 } else if (pDevice->byRFType == RF_UW2452) {
 446                         pDevice->abyBBVGA[0] = 0x14;
 447                         BBbReadEmbedded(pDevice->PortOffset, 0xE7, &byData);
 448                         if (byData == 0x18) {
 449                                 BBbWriteEmbedded(pDevice->PortOffset, 0xE7, pDevice->abyBBVGA[0]);
 450                                 BBbWriteEmbedded(pDevice->PortOffset, 0xE1, 0xD3);
 451                         }
 452                 }
 453                 BBbWriteEmbedded(pDevice->PortOffset, 0x88, 0x02);
 454                 bySlot = C_SLOT_LONG;
 455                 bySIFS = C_SIFS_BG;
 456                 byDIFS = C_SIFS_BG + 2*C_SLOT_LONG;
 457                 byCWMaxMin = 0xA5;
 458         } else {// PK_TYPE_11GA & PK_TYPE_11GB
 459                 if (pSupportRates == NULL) {
 460                         pSupportRates = (PWLAN_IE_SUPP_RATES) abyDefaultSuppRatesG;
 461                         pExtSupportRates = (PWLAN_IE_SUPP_RATES) abyDefaultExtSuppRatesG;
 462                 }
 463                 MACvSetBBType(pDevice->PortOffset, BB_TYPE_11G);
 464                 if (pDevice->byRFType == RF_AIROHA7230) {
 465                         pDevice->abyBBVGA[0] = 0x1C;
 466                         pDevice->abyBBVGA[2] = 0x00;
 467                         pDevice->abyBBVGA[3] = 0x00;
 468                         BBbReadEmbedded(pDevice->PortOffset, 0xE7, &byData);
 469                         if (byData == 0x20) {
 470                                 BBbWriteEmbedded(pDevice->PortOffset, 0xE7, pDevice->abyBBVGA[0]);
 471                         }
 472                 } else if (pDevice->byRFType == RF_UW2452) {
 473                         pDevice->abyBBVGA[0] = 0x14;
 474                         BBbReadEmbedded(pDevice->PortOffset, 0xE7, &byData);
 475                         if (byData == 0x18) {
 476                                 BBbWriteEmbedded(pDevice->PortOffset, 0xE7, pDevice->abyBBVGA[0]);
 477                                 BBbWriteEmbedded(pDevice->PortOffset, 0xE1, 0xD3);
 478                         }
 479                 }
 480                 BBbWriteEmbedded(pDevice->PortOffset, 0x88, 0x08);
 481                 bySIFS = C_SIFS_BG;
 482                 if (VNTWIFIbIsShortSlotTime(wCapInfo)) {
 483                         bySlot = C_SLOT_SHORT;
 484                         byDIFS = C_SIFS_BG + 2*C_SLOT_SHORT;
 485                 } else {
 486                         bySlot = C_SLOT_LONG;
 487                         byDIFS = C_SIFS_BG + 2*C_SLOT_LONG;
 488                 }
 489                 if (VNTWIFIbyGetMaxSupportRate(pSupportRates, pExtSupportRates) > RATE_11M) {
 490                         byCWMaxMin = 0xA4;
 491                 } else {
 492                         byCWMaxMin = 0xA5;
 493                 }
 494                 if (pDevice->bProtectMode != VNTWIFIbIsProtectMode(byERPField)) {
 495                         pDevice->bProtectMode = VNTWIFIbIsProtectMode(byERPField);
 496                         if (pDevice->bProtectMode) {
 497                                 MACvEnableProtectMD(pDevice->PortOffset);
 498                         } else {
 499                                 MACvDisableProtectMD(pDevice->PortOffset);
 500                         }
 501                 }
 502                 if (pDevice->bBarkerPreambleMd != VNTWIFIbIsBarkerMode(byERPField)) {
 503                         pDevice->bBarkerPreambleMd = VNTWIFIbIsBarkerMode(byERPField);
 504                         if (pDevice->bBarkerPreambleMd) {
 505                                 MACvEnableBarkerPreambleMd(pDevice->PortOffset);
 506                         } else {
 507                                 MACvDisableBarkerPreambleMd(pDevice->PortOffset);
 508                         }
 509                 }
 510         }
 511
 512         if (pDevice->byRFType == RF_RFMD2959) {
 513                 // bcs TX_PE will reserve 3 us
 514                 // hardware's processing time here is 2 us.
 515                 bySIFS -= 3;
 516                 byDIFS -= 3;
 517                 //{{ RobertYu: 20041202
 518                 //// TX_PE will reserve 3 us for MAX2829 A mode only, it is for better TX throughput
 519                 //// MAC will need 2 us to process, so the SIFS, DIFS can be shorter by 2 us.
 520         }
 521
 522         if (pDevice->bySIFS != bySIFS) {
 523                 pDevice->bySIFS = bySIFS;
 524                 VNSvOutPortB(pDevice->PortOffset + MAC_REG_SIFS, pDevice->bySIFS);
 525         }
 526         if (pDevice->byDIFS != byDIFS) {
 527                 pDevice->byDIFS = byDIFS;
 528                 VNSvOutPortB(pDevice->PortOffset + MAC_REG_DIFS, pDevice->byDIFS);
 529         }
 530         if (pDevice->byEIFS != C_EIFS) {
 531                 pDevice->byEIFS = C_EIFS;
 532                 VNSvOutPortB(pDevice->PortOffset + MAC_REG_EIFS, pDevice->byEIFS);
 533         }
 534         if (pDevice->bySlot != bySlot) {
 535                 pDevice->bySlot = bySlot;
 536                 VNSvOutPortB(pDevice->PortOffset + MAC_REG_SLOT, pDevice->bySlot);
 537                 if (pDevice->bySlot == C_SLOT_SHORT) {
 538                         pDevice->bShortSlotTime = true;
 539                 } else {
 540                         pDevice->bShortSlotTime = false;
 541                 }
 542                 BBvSetShortSlotTime(pDevice);
 543         }
 544         if (pDevice->byCWMaxMin != byCWMaxMin) {
 545                 pDevice->byCWMaxMin = byCWMaxMin;
 546                 VNSvOutPortB(pDevice->PortOffset + MAC_REG_CWMAXMIN0, pDevice->byCWMaxMin);
 547         }
 548         if (VNTWIFIbIsShortPreamble(wCapInfo)) {
 549                 pDevice->byPreambleType = pDevice->byShortPreamble;
 550         } else {
 551                 pDevice->byPreambleType = 0;
 552         }
 553         s_vSetRSPINF(pDevice, ePHYType, pSupportRates, pExtSupportRates);
 554         pDevice->eCurrentPHYType = ePHYType;
 555         // set for NDIS OID_802_11SUPPORTED_RATES
 556         return true;
 557 }
 558
 559 /*
 560  * Description: Sync. TSF counter to BSS
 561  *              Get TSF offset and write to HW
 562  *
 563  * Parameters:
 564  *  In:
 565  *      pDevice         - The adapter to be sync.
 566  *      byRxRate        - data rate of receive beacon
 567  *      qwBSSTimestamp  - Rx BCN's TSF
 568  *      qwLocalTSF      - Local TSF
 569  *  Out:
 570  *      none
 571  *
 572  * Return Value: none
 573  *
 574  */
 575 bool CARDbUpdateTSF(void *pDeviceHandler, unsigned char byRxRate, QWORD qwBSSTimestamp, QWORD qwLocalTSF)
 576 {
 577         PSDevice    pDevice = (PSDevice) pDeviceHandler;
 578         QWORD       qwTSFOffset;
 579
 580         HIDWORD(qwTSFOffset) = 0;
 581         LODWORD(qwTSFOffset) = 0;
 582
 583         if ((HIDWORD(qwBSSTimestamp) != HIDWORD(qwLocalTSF)) ||
 584             (LODWORD(qwBSSTimestamp) != LODWORD(qwLocalTSF))) {
 585                 qwTSFOffset = CARDqGetTSFOffset(byRxRate, qwBSSTimestamp, qwLocalTSF);
 586                 // adjust TSF
 587                 // HW's TSF add TSF Offset reg
 588                 VNSvOutPortD(pDevice->PortOffset + MAC_REG_TSFOFST, LODWORD(qwTSFOffset));
 589                 VNSvOutPortD(pDevice->PortOffset + MAC_REG_TSFOFST + 4, HIDWORD(qwTSFOffset));
 590                 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_TFTCTL, TFTCTL_TSFSYNCEN);
 591         }
 592         return true;
 593 }
 594
 595 /*
 596  * Description: Set NIC TSF counter for first Beacon time
 597  *              Get NEXTTBTT from adjusted TSF and Beacon Interval
 598  *
 599  * Parameters:
 600  *  In:
 601  *      pDevice         - The adapter to be set.
 602  *      wBeaconInterval - Beacon Interval
 603  *  Out:
 604  *      none
 605  *
 606  * Return Value: true if succeed; otherwise false
 607  *
 608  */
 609 bool CARDbSetBeaconPeriod(void *pDeviceHandler, unsigned short wBeaconInterval)
 610 {
 611         PSDevice    pDevice = (PSDevice) pDeviceHandler;
 612         unsigned int uBeaconInterval = 0;
 613         unsigned int uLowNextTBTT = 0;
 614         unsigned int uHighRemain = 0;
 615         unsigned int uLowRemain = 0;
 616         QWORD       qwNextTBTT;
 617
 618         HIDWORD(qwNextTBTT) = 0;
 619         LODWORD(qwNextTBTT) = 0;
 620         CARDbGetCurrentTSF(pDevice->PortOffset, &qwNextTBTT); //Get Local TSF counter
 621         uBeaconInterval = wBeaconInterval * 1024;
 622         // Next TBTT = ((local_current_TSF / beacon_interval) + 1) * beacon_interval
 623         uLowNextTBTT = (LODWORD(qwNextTBTT) >> 10) << 10;
 624         uLowRemain = (uLowNextTBTT) % uBeaconInterval;
 625         // high dword (mod) bcn
 626         uHighRemain = (((0xffffffff % uBeaconInterval) + 1) * HIDWORD(qwNextTBTT))
 627                 % uBeaconInterval;
 628         uLowRemain = (uHighRemain + uLowRemain) % uBeaconInterval;
 629         uLowRemain = uBeaconInterval - uLowRemain;
 630
 631         // check if carry when add one beacon interval
 632         if ((~uLowNextTBTT) < uLowRemain) {
 633                 HIDWORD(qwNextTBTT)++;
 634         }
 635         LODWORD(qwNextTBTT) = uLowNextTBTT + uLowRemain;
 636
 637         // set HW beacon interval
 638         VNSvOutPortW(pDevice->PortOffset + MAC_REG_BI, wBeaconInterval);
 639         pDevice->wBeaconInterval = wBeaconInterval;
 640         // Set NextTBTT
 641         VNSvOutPortD(pDevice->PortOffset + MAC_REG_NEXTTBTT, LODWORD(qwNextTBTT));
 642         VNSvOutPortD(pDevice->PortOffset + MAC_REG_NEXTTBTT + 4, HIDWORD(qwNextTBTT));
 643         MACvRegBitsOn(pDevice->PortOffset, MAC_REG_TFTCTL, TFTCTL_TBTTSYNCEN);
 644
 645         return true;
 646 }
 647
 648 /*
 649  * Description: Card Stop Hardware Tx
 650  *
 651  * Parameters:
 652  *  In:
 653  *      pDeviceHandler      - The adapter to be set
 654  *      ePktType            - Packet type to stop
 655  *  Out:
 656  *      none
 657  *
 658  * Return Value: true if all data packet complete; otherwise false.
 659  *
 660  */
 661 bool CARDbStopTxPacket(void *pDeviceHandler, CARD_PKT_TYPE ePktType)
 662 {
 663         PSDevice    pDevice = (PSDevice) pDeviceHandler;
 664
 665         if (ePktType == PKT_TYPE_802_11_ALL) {
 666                 pDevice->bStopBeacon = true;
 667                 pDevice->bStopTx0Pkt = true;
 668                 pDevice->bStopDataPkt = true;
 669         } else if (ePktType == PKT_TYPE_802_11_BCN) {
 670                 pDevice->bStopBeacon = true;
 671         } else if (ePktType == PKT_TYPE_802_11_MNG) {
 672                 pDevice->bStopTx0Pkt = true;
 673         } else if (ePktType == PKT_TYPE_802_11_DATA) {
 674                 pDevice->bStopDataPkt = true;
 675         }
 676
 677         if (pDevice->bStopBeacon == true) {
 678                 if (pDevice->bIsBeaconBufReadySet == true) {
 679                         if (pDevice->cbBeaconBufReadySetCnt < WAIT_BEACON_TX_DOWN_TMO) {
 680                                 pDevice->cbBeaconBufReadySetCnt++;
 681                                 return false;
 682                         }
 683                 }
 684                 pDevice->bIsBeaconBufReadySet = false;
 685                 pDevice->cbBeaconBufReadySetCnt = 0;
 686                 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_TCR, TCR_AUTOBCNTX);
 687         }
 688         // wait all TD0 complete
 689         if (pDevice->bStopTx0Pkt == true) {
 690                 if (pDevice->iTDUsed[TYPE_TXDMA0] != 0) {
 691                         return false;
 692                 }
 693         }
 694         // wait all Data TD complete
 695         if (pDevice->bStopDataPkt == true) {
 696                 if (pDevice->iTDUsed[TYPE_AC0DMA] != 0) {
 697                         return false;
 698                 }
 699         }
 700
 701         return true;
 702 }
 703
 704 /*
 705  * Description: Card Start Hardware Tx
 706  *
 707  * Parameters:
 708  *  In:
 709  *      pDeviceHandler      - The adapter to be set
 710  *      ePktType            - Packet type to start
 711  *  Out:
 712  *      none
 713  *
 714  * Return Value: true if success; false if failed.
 715  *
 716  */
 717 bool CARDbStartTxPacket(void *pDeviceHandler, CARD_PKT_TYPE ePktType)
 718 {
 719         PSDevice    pDevice = (PSDevice) pDeviceHandler;
 720
 721         if (ePktType == PKT_TYPE_802_11_ALL) {
 722                 pDevice->bStopBeacon = false;
 723                 pDevice->bStopTx0Pkt = false;
 724                 pDevice->bStopDataPkt = false;
 725         } else if (ePktType == PKT_TYPE_802_11_BCN) {
 726                 pDevice->bStopBeacon = false;
 727         } else if (ePktType == PKT_TYPE_802_11_MNG) {
 728                 pDevice->bStopTx0Pkt = false;
 729         } else if (ePktType == PKT_TYPE_802_11_DATA) {
 730                 pDevice->bStopDataPkt = false;
 731         }
 732
 733         if ((pDevice->bStopBeacon == false) &&
 734             (pDevice->bBeaconBufReady == true) &&
 735             (pDevice->eOPMode == OP_MODE_ADHOC)) {
 736                 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_TCR, TCR_AUTOBCNTX);
 737         }
 738
 739         return true;
 740 }
 741
 742 /*
 743  * Description: Card Set BSSID value
 744  *
 745  * Parameters:
 746  *  In:
 747  *      pDeviceHandler      - The adapter to be set
 748  *      pbyBSSID            - pointer to BSSID field
 749  *      bAdhoc              - flag to indicate IBSS
 750  *  Out:
 751  *      none
 752  *
 753  * Return Value: true if success; false if failed.
 754  *
 755  */
 756 bool CARDbSetBSSID(void *pDeviceHandler, unsigned char *pbyBSSID, CARD_OP_MODE eOPMode)
 757 {
 758         PSDevice    pDevice = (PSDevice) pDeviceHandler;
 759
 760         MACvWriteBSSIDAddress(pDevice->PortOffset, pbyBSSID);
 761         memcpy(pDevice->abyBSSID, pbyBSSID, WLAN_BSSID_LEN);
 762         if (eOPMode == OP_MODE_ADHOC) {
 763                 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_HOSTCR, HOSTCR_ADHOC);
 764         } else {
 765                 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_HOSTCR, HOSTCR_ADHOC);
 766         }
 767         if (eOPMode == OP_MODE_AP) {
 768                 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_HOSTCR, HOSTCR_AP);
 769         } else {
 770                 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_HOSTCR, HOSTCR_AP);
 771         }
 772         if (eOPMode == OP_MODE_UNKNOWN) {
 773                 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_RCR, RCR_BSSID);
 774                 pDevice->bBSSIDFilter = false;
 775                 pDevice->byRxMode &= ~RCR_BSSID;
 776                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "wcmd: rx_mode = %x\n", pDevice->byRxMode);
 777         } else {
 778                 if (is_zero_ether_addr(pDevice->abyBSSID) == false) {
 779                         MACvRegBitsOn(pDevice->PortOffset, MAC_REG_RCR, RCR_BSSID);
 780                         pDevice->bBSSIDFilter = true;
 781                         pDevice->byRxMode |= RCR_BSSID;
 782                 }
 783                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "wmgr: rx_mode = %x\n", pDevice->byRxMode);
 784         }
 785         // Adopt BSS state in Adapter Device Object
 786         pDevice->eOPMode = eOPMode;
 787         return true;
 788 }
 789
 790 /*
 791  * Description: Card indicate status
 792  *
 793  * Parameters:
 794  *  In:
 795  *      pDeviceHandler      - The adapter to be set
 796  *      eStatus             - Status
 797  *  Out:
 798  *      none
 799  *
 800  * Return Value: true if success; false if failed.
 801  *
 802  */
 803
 804 /*
 805  * Description: Save Assoc info. contain in assoc. response frame
 806  *
 807  * Parameters:
 808  *  In:
 809  *      pDevice             - The adapter to be set
 810  *      wCapabilityInfo     - Capability information
 811  *      wStatus             - Status code
 812  *      wAID                - Assoc. ID
 813  *      uLen                - Length of IEs
 814  *      pbyIEs              - pointer to IEs
 815  *  Out:
 816  *      none
 817  *
 818  * Return Value: true if succeed; otherwise false
 819  *
 820  */
 821 bool CARDbSetTxDataRate(
 822         void *pDeviceHandler,
 823         unsigned short wDataRate
 824 )
 825 {
 826         PSDevice    pDevice = (PSDevice) pDeviceHandler;
 827
 828         pDevice->wCurrentRate = wDataRate;
 829         return true;
 830 }
 831
 832 /*+
 833  *
 834  * Routine Description:
 835  *      Consider to power down when no more packets to tx or rx.
 836  *
 837  * Parameters:
 838  *  In:
 839  *      pDevice             - The adapter to be set
 840  *  Out:
 841  *      none
 842  *
 843  * Return Value: true if power down success; otherwise false
 844  *
 845  -*/
 846 bool
 847 CARDbPowerDown(
 848         void *pDeviceHandler
 849 )
 850 {
 851         PSDevice        pDevice = (PSDevice)pDeviceHandler;
 852         unsigned int uIdx;
 853
 854         // check if already in Doze mode
 855         if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS))
 856                 return true;
 857
 858         // Froce PSEN on
 859         MACvRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PSEN);
 860
 861         // check if all TD are empty,
 862
 863         for (uIdx = 0; uIdx < TYPE_MAXTD; uIdx++) {
 864                 if (pDevice->iTDUsed[uIdx] != 0)
 865                         return false;
 866         }
 867
 868         MACvRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_GO2DOZE);
 869         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Go to Doze ZZZZZZZZZZZZZZZ\n");
 870         return true;
 871 }
 872
 873 /*
 874  * Description: Turn off Radio power
 875  *
 876  * Parameters:
 877  *  In:
 878  *      pDevice         - The adapter to be turned off
 879  *  Out:
 880  *      none
 881  *
 882  * Return Value: true if success; otherwise false
 883  *
 884  */
 885 bool CARDbRadioPowerOff(void *pDeviceHandler)
 886 {
 887         PSDevice    pDevice = (PSDevice)pDeviceHandler;
 888         bool bResult = true;
 889
 890         if (pDevice->bRadioOff == true)
 891                 return true;
 892
 893         switch (pDevice->byRFType) {
 894         case RF_RFMD2959:
 895                 MACvWordRegBitsOff(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_TXPEINV);
 896                 MACvWordRegBitsOn(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPE1);
 897                 break;
 898
 899         case RF_AIROHA:
 900         case RF_AL2230S:
 901         case RF_AIROHA7230: //RobertYu:20050104
 902                 MACvWordRegBitsOff(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPE2);
 903                 MACvWordRegBitsOff(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPE3);
 904                 break;
 905
 906         }
 907
 908         MACvRegBitsOff(pDevice->PortOffset, MAC_REG_HOSTCR, HOSTCR_RXON);
 909
 910         BBvSetDeepSleep(pDevice->PortOffset, pDevice->byLocalID);
 911
 912         pDevice->bRadioOff = true;
 913         //2007-0409-03,<Add> by chester
 914         printk("chester power off\n");
 915         MACvRegBitsOn(pDevice->PortOffset, MAC_REG_GPIOCTL0, LED_ACTSET);  //LED issue
 916         return bResult;
 917 }
 918
 919 /*
 920  * Description: Turn on Radio power
 921  *
 922  * Parameters:
 923  *  In:
 924  *      pDevice         - The adapter to be turned on
 925  *  Out:
 926  *      none
 927  *
 928  * Return Value: true if success; otherwise false
 929  *
 930  */
 931 bool CARDbRadioPowerOn(void *pDeviceHandler)
 932 {
 933         PSDevice    pDevice = (PSDevice) pDeviceHandler;
 934         bool bResult = true;
 935         printk("chester power on\n");
 936         if (pDevice->bRadioControlOff == true) {
 937                 if (pDevice->bHWRadioOff == true) printk("chester bHWRadioOff\n");
 938                 if (pDevice->bRadioControlOff == true) printk("chester bRadioControlOff\n");
 939                 return false; }
 940
 941         if (pDevice->bRadioOff == false) {
 942                 printk("chester pbRadioOff\n");
 943                 return true; }
 944
 945         BBvExitDeepSleep(pDevice->PortOffset, pDevice->byLocalID);
 946
 947         MACvRegBitsOn(pDevice->PortOffset, MAC_REG_HOSTCR, HOSTCR_RXON);
 948
 949         switch (pDevice->byRFType) {
 950         case RF_RFMD2959:
 951                 MACvWordRegBitsOn(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_TXPEINV);
 952                 MACvWordRegBitsOff(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPE1);
 953                 break;
 954
 955         case RF_AIROHA:
 956         case RF_AL2230S:
 957         case RF_AIROHA7230: //RobertYu:20050104
 958                 MACvWordRegBitsOn(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, (SOFTPWRCTL_SWPE2 |
 959                                                                             SOFTPWRCTL_SWPE3));
 960                 break;
 961
 962         }
 963
 964         pDevice->bRadioOff = false;
 965 //  2007-0409-03,<Add> by chester
 966         printk("chester power on\n");
 967         MACvRegBitsOff(pDevice->PortOffset, MAC_REG_GPIOCTL0, LED_ACTSET); //LED issue
 968         return bResult;
 969 }
 970
 971 bool CARDbRemoveKey(void *pDeviceHandler, unsigned char *pbyBSSID)
 972 {
 973         PSDevice    pDevice = (PSDevice) pDeviceHandler;
 974
 975         KeybRemoveAllKey(&(pDevice->sKey), pbyBSSID, pDevice->PortOffset);
 976         return true;
 977 }
 978
 979 /*
 980  *
 981  * Description:
 982  *    Add BSSID in PMKID Candidate list.
 983  *
 984  * Parameters:
 985  *  In:
 986  *      hDeviceContext - device structure point
 987  *      pbyBSSID - BSSID address for adding
 988  *      wRSNCap - BSS's RSN capability
 989  *  Out:
 990  *      none
 991  *
 992  * Return Value: none.
 993  *
 994  -*/
 995 bool
 996 CARDbAdd_PMKID_Candidate(
 997         void *pDeviceHandler,
 998         unsigned char *pbyBSSID,
 999         bool bRSNCapExist,
1000         unsigned short wRSNCap
1001 )
1002 {
1003         PSDevice            pDevice = (PSDevice) pDeviceHandler;
1004         PPMKID_CANDIDATE    pCandidateList;
1005         unsigned int ii = 0;
1006
1007         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "bAdd_PMKID_Candidate START: (%d)\n", (int)pDevice->gsPMKIDCandidate.NumCandidates);
1008
1009         if (pDevice->gsPMKIDCandidate.NumCandidates >= MAX_PMKIDLIST) {
1010                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "vFlush_PMKID_Candidate: 3\n");
1011                 memset(&pDevice->gsPMKIDCandidate, 0, sizeof(SPMKIDCandidateEvent));
1012         }
1013
1014         for (ii = 0; ii < 6; ii++) {
1015                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%02X ", *(pbyBSSID + ii));
1016         }
1017         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "\n");
1018
1019         // Update Old Candidate
1020         for (ii = 0; ii < pDevice->gsPMKIDCandidate.NumCandidates; ii++) {
1021                 pCandidateList = &pDevice->gsPMKIDCandidate.CandidateList[ii];
1022                 if (!memcmp(pCandidateList->BSSID, pbyBSSID, ETH_ALEN)) {
1023                         if (bRSNCapExist && (wRSNCap & BIT0)) {
1024                                 pCandidateList->Flags |= NDIS_802_11_PMKID_CANDIDATE_PREAUTH_ENABLED;
1025                         } else {
1026                                 pCandidateList->Flags &= ~(NDIS_802_11_PMKID_CANDIDATE_PREAUTH_ENABLED);
1027                         }
1028                         return true;
1029                 }
1030         }
1031
1032         // New Candidate
1033         pCandidateList = &pDevice->gsPMKIDCandidate.CandidateList[pDevice->gsPMKIDCandidate.NumCandidates];
1034         if (bRSNCapExist && (wRSNCap & BIT0)) {
1035                 pCandidateList->Flags |= NDIS_802_11_PMKID_CANDIDATE_PREAUTH_ENABLED;
1036         } else {
1037                 pCandidateList->Flags &= ~(NDIS_802_11_PMKID_CANDIDATE_PREAUTH_ENABLED);
1038         }
1039         memcpy(pCandidateList->BSSID, pbyBSSID, ETH_ALEN);
1040         pDevice->gsPMKIDCandidate.NumCandidates++;
1041         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "NumCandidates:%d\n", (int)pDevice->gsPMKIDCandidate.NumCandidates);
1042         return true;
1043 }
1044
1045 void *
1046 CARDpGetCurrentAddress(
1047         void *pDeviceHandler
1048 )
1049 {
1050         PSDevice            pDevice = (PSDevice) pDeviceHandler;
1051
1052         return pDevice->abyCurrentNetAddr;
1053 }
1054
1055 /*
1056  *
1057  * Description:
1058  *    Start Spectrum Measure defined in 802.11h
1059  *
1060  * Parameters:
1061  *  In:
1062  *      hDeviceContext - device structure point
1063  *  Out:
1064  *      none
1065  *
1066  * Return Value: none.
1067  *
1068  -*/
1069 bool
1070 CARDbStartMeasure(
1071         void *pDeviceHandler,
1072         void *pvMeasureEIDs,
1073         unsigned int uNumOfMeasureEIDs
1074 )
1075 {
1076         PSDevice                pDevice = (PSDevice) pDeviceHandler;
1077         PWLAN_IE_MEASURE_REQ    pEID = (PWLAN_IE_MEASURE_REQ) pvMeasureEIDs;
1078         QWORD                   qwCurrTSF;
1079         QWORD                   qwStartTSF;
1080         bool bExpired = true;
1081         unsigned short wDuration = 0;
1082
1083         if ((pEID == NULL) ||
1084             (uNumOfMeasureEIDs == 0)) {
1085                 return true;
1086         }
1087         CARDbGetCurrentTSF(pDevice->PortOffset, &qwCurrTSF);
1088         if (pDevice->bMeasureInProgress == true) {
1089                 pDevice->bMeasureInProgress = false;
1090                 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, pDevice->byOrgRCR);
1091                 MACvSelectPage1(pDevice->PortOffset);
1092                 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, pDevice->dwOrgMAR0);
1093                 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR4, pDevice->dwOrgMAR4);
1094                 // clear measure control
1095                 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_EN);
1096                 MACvSelectPage0(pDevice->PortOffset);
1097                 set_channel(pDevice, pDevice->byOrgChannel);
1098                 MACvSelectPage1(pDevice->PortOffset);
1099                 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
1100                 MACvSelectPage0(pDevice->PortOffset);
1101         }
1102         pDevice->uNumOfMeasureEIDs = uNumOfMeasureEIDs;
1103
1104         do {
1105                 pDevice->pCurrMeasureEID = pEID;
1106                 pEID++;
1107                 pDevice->uNumOfMeasureEIDs--;
1108
1109                 if (pDevice->byLocalID > REV_ID_VT3253_B1) {
1110                         HIDWORD(qwStartTSF) = HIDWORD(*((PQWORD)(pDevice->pCurrMeasureEID->sReq.abyStartTime)));
1111                         LODWORD(qwStartTSF) = LODWORD(*((PQWORD)(pDevice->pCurrMeasureEID->sReq.abyStartTime)));
1112                         wDuration = *((unsigned short *)(pDevice->pCurrMeasureEID->sReq.abyDuration));
1113                         wDuration += 1; // 1 TU for channel switching
1114
1115                         if ((LODWORD(qwStartTSF) == 0) && (HIDWORD(qwStartTSF) == 0)) {
1116                                 // start immediately by setting start TSF == current TSF + 2 TU
1117                                 LODWORD(qwStartTSF) = LODWORD(qwCurrTSF) + 2048;
1118                                 HIDWORD(qwStartTSF) = HIDWORD(qwCurrTSF);
1119                                 if (LODWORD(qwCurrTSF) > LODWORD(qwStartTSF)) {
1120                                         HIDWORD(qwStartTSF)++;
1121                                 }
1122                                 bExpired = false;
1123                                 break;
1124                         } else {
1125                                 // start at setting start TSF - 1TU(for channel switching)
1126                                 if (LODWORD(qwStartTSF) < 1024) {
1127                                         HIDWORD(qwStartTSF)--;
1128                                 }
1129                                 LODWORD(qwStartTSF) -= 1024;
1130                         }
1131
1132                         if ((HIDWORD(qwCurrTSF) < HIDWORD(qwStartTSF)) ||
1133                             ((HIDWORD(qwCurrTSF) == HIDWORD(qwStartTSF)) &&
1134                              (LODWORD(qwCurrTSF) < LODWORD(qwStartTSF)))
1135 ) {
1136                                 bExpired = false;
1137                                 break;
1138                         }
1139                         VNTWIFIbMeasureReport(pDevice->pMgmt,
1140                                               false,
1141                                               pDevice->pCurrMeasureEID,
1142                                               MEASURE_MODE_LATE,
1143                                               pDevice->byBasicMap,
1144                                               pDevice->byCCAFraction,
1145                                               pDevice->abyRPIs
1146                                 );
1147                 } else {
1148                         // hardware do not support measure
1149                         VNTWIFIbMeasureReport(pDevice->pMgmt,
1150                                               false,
1151                                               pDevice->pCurrMeasureEID,
1152                                               MEASURE_MODE_INCAPABLE,
1153                                               pDevice->byBasicMap,
1154                                               pDevice->byCCAFraction,
1155                                               pDevice->abyRPIs
1156                                 );
1157                 }
1158         } while (pDevice->uNumOfMeasureEIDs != 0);
1159
1160         if (!bExpired) {
1161                 MACvSelectPage1(pDevice->PortOffset);
1162                 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MSRSTART, LODWORD(qwStartTSF));
1163                 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MSRSTART + 4, HIDWORD(qwStartTSF));
1164                 VNSvOutPortW(pDevice->PortOffset + MAC_REG_MSRDURATION, wDuration);
1165                 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_EN);
1166                 MACvSelectPage0(pDevice->PortOffset);
1167         } else {
1168                 // all measure start time expired we should complete action
1169                 VNTWIFIbMeasureReport(pDevice->pMgmt,
1170                                       true,
1171                                       NULL,
1172                                       0,
1173                                       pDevice->byBasicMap,
1174                                       pDevice->byCCAFraction,
1175                                       pDevice->abyRPIs
1176                         );
1177         }
1178         return true;
1179 }
1180
1181 /*
1182  *
1183  * Description:
1184  *    Do Channel Switch defined in 802.11h
1185  *
1186  * Parameters:
1187  *  In:
1188  *      hDeviceContext - device structure point
1189  *  Out:
1190  *      none
1191  *
1192  * Return Value: none.
1193  *
1194  -*/
1195 bool
1196 CARDbChannelSwitch(
1197         void *pDeviceHandler,
1198         unsigned char byMode,
1199         unsigned char byNewChannel,
1200         unsigned char byCount
1201 )
1202 {
1203         PSDevice    pDevice = (PSDevice) pDeviceHandler;
1204         bool bResult = true;
1205
1206         if (byCount == 0) {
1207                 bResult = set_channel(pDevice, byNewChannel);
1208                 VNTWIFIbChannelSwitch(pDevice->pMgmt, byNewChannel);
1209                 MACvSelectPage1(pDevice->PortOffset);
1210                 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
1211                 MACvSelectPage0(pDevice->PortOffset);
1212                 return bResult;
1213         }
1214         pDevice->byChannelSwitchCount = byCount;
1215         pDevice->byNewChannel = byNewChannel;
1216         pDevice->bChannelSwitch = true;
1217         if (byMode == 1) {
1218                 bResult = CARDbStopTxPacket(pDevice, PKT_TYPE_802_11_ALL);
1219         }
1220         return bResult;
1221 }
1222
1223 /*
1224  *
1225  * Description:
1226  *    Handle Quiet EID defined in 802.11h
1227  *
1228  * Parameters:
1229  *  In:
1230  *      hDeviceContext - device structure point
1231  *  Out:
1232  *      none
1233  *
1234  * Return Value: none.
1235  *
1236  -*/
1237 bool
1238 CARDbSetQuiet(
1239         void *pDeviceHandler,
1240         bool bResetQuiet,
1241         unsigned char byQuietCount,
1242         unsigned char byQuietPeriod,
1243         unsigned short wQuietDuration,
1244         unsigned short wQuietOffset
1245 )
1246 {
1247         PSDevice    pDevice = (PSDevice) pDeviceHandler;
1248         unsigned int ii = 0;
1249
1250         if (bResetQuiet) {
1251                 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, (MSRCTL_QUIETTXCHK | MSRCTL_QUIETEN));
1252                 for (ii = 0; ii < MAX_QUIET_COUNT; ii++) {
1253                         pDevice->sQuiet[ii].bEnable = false;
1254                 }
1255                 pDevice->uQuietEnqueue = 0;
1256                 pDevice->bEnableFirstQuiet = false;
1257                 pDevice->bQuietEnable = false;
1258                 pDevice->byQuietStartCount = byQuietCount;
1259         }
1260         if (pDevice->sQuiet[pDevice->uQuietEnqueue].bEnable == false) {
1261                 pDevice->sQuiet[pDevice->uQuietEnqueue].bEnable = true;
1262                 pDevice->sQuiet[pDevice->uQuietEnqueue].byPeriod = byQuietPeriod;
1263                 pDevice->sQuiet[pDevice->uQuietEnqueue].wDuration = wQuietDuration;
1264                 pDevice->sQuiet[pDevice->uQuietEnqueue].dwStartTime = (unsigned long) byQuietCount;
1265                 pDevice->sQuiet[pDevice->uQuietEnqueue].dwStartTime *= pDevice->wBeaconInterval;
1266                 pDevice->sQuiet[pDevice->uQuietEnqueue].dwStartTime += wQuietOffset;
1267                 pDevice->uQuietEnqueue++;
1268                 pDevice->uQuietEnqueue %= MAX_QUIET_COUNT;
1269                 if (pDevice->byQuietStartCount < byQuietCount) {
1270                         pDevice->byQuietStartCount = byQuietCount;
1271                 }
1272         }
1273         return true;
1274 }
1275
1276 /*
1277  *
1278  * Description:
1279  *    Do Quiet, It will be called by either ISR(after start)
1280  *    or VNTWIFI(before start) so we do not need a SPINLOCK
1281  *
1282  * Parameters:
1283  *  In:
1284  *      hDeviceContext - device structure point
1285  *  Out:
1286  *      none
1287  *
1288  * Return Value: none.
1289  *
1290  -*/
1291 bool
1292 CARDbStartQuiet(
1293         void *pDeviceHandler
1294 )
1295 {
1296         PSDevice    pDevice = (PSDevice) pDeviceHandler;
1297         unsigned int ii = 0;
1298         unsigned long dwStartTime = 0xFFFFFFFF;
1299         unsigned int uCurrentQuietIndex = 0;
1300         unsigned long dwNextTime = 0;
1301         unsigned long dwGap = 0;
1302         unsigned long dwDuration = 0;
1303
1304         for (ii = 0; ii < MAX_QUIET_COUNT; ii++) {
1305                 if ((pDevice->sQuiet[ii].bEnable == true) &&
1306                     (dwStartTime > pDevice->sQuiet[ii].dwStartTime)) {
1307                         dwStartTime = pDevice->sQuiet[ii].dwStartTime;
1308                         uCurrentQuietIndex = ii;
1309                 }
1310         }
1311         if (dwStartTime == 0xFFFFFFFF) {
1312                 // no more quiet
1313                 pDevice->bQuietEnable = false;
1314                 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, (MSRCTL_QUIETTXCHK | MSRCTL_QUIETEN));
1315         } else {
1316                 if (pDevice->bQuietEnable == false) {
1317                         // first quiet
1318                         pDevice->byQuietStartCount--;
1319                         dwNextTime = pDevice->sQuiet[uCurrentQuietIndex].dwStartTime;
1320                         dwNextTime %= pDevice->wBeaconInterval;
1321                         MACvSelectPage1(pDevice->PortOffset);
1322                         VNSvOutPortW(pDevice->PortOffset + MAC_REG_QUIETINIT, (unsigned short) dwNextTime);
1323                         VNSvOutPortW(pDevice->PortOffset + MAC_REG_QUIETDUR, (unsigned short) pDevice->sQuiet[uCurrentQuietIndex].wDuration);
1324                         if (pDevice->byQuietStartCount == 0) {
1325                                 pDevice->bEnableFirstQuiet = false;
1326                                 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, (MSRCTL_QUIETTXCHK | MSRCTL_QUIETEN));
1327                         } else {
1328                                 pDevice->bEnableFirstQuiet = true;
1329                         }
1330                         MACvSelectPage0(pDevice->PortOffset);
1331                 } else {
1332                         if (pDevice->dwCurrentQuietEndTime > pDevice->sQuiet[uCurrentQuietIndex].dwStartTime) {
1333                                 // overlap with previous Quiet
1334                                 dwGap =  pDevice->dwCurrentQuietEndTime - pDevice->sQuiet[uCurrentQuietIndex].dwStartTime;
1335                                 if (dwGap >= pDevice->sQuiet[uCurrentQuietIndex].wDuration) {
1336                                         // return false to indicate next quiet expired, should call this function again
1337                                         return false;
1338                                 }
1339                                 dwDuration = pDevice->sQuiet[uCurrentQuietIndex].wDuration - dwGap;
1340                                 dwGap = 0;
1341                         } else {
1342                                 dwGap = pDevice->sQuiet[uCurrentQuietIndex].dwStartTime - pDevice->dwCurrentQuietEndTime;
1343                                 dwDuration = pDevice->sQuiet[uCurrentQuietIndex].wDuration;
1344                         }
1345                         // set GAP and Next duration
1346                         MACvSelectPage1(pDevice->PortOffset);
1347                         VNSvOutPortW(pDevice->PortOffset + MAC_REG_QUIETGAP, (unsigned short) dwGap);
1348                         VNSvOutPortW(pDevice->PortOffset + MAC_REG_QUIETDUR, (unsigned short) dwDuration);
1349                         MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_QUIETRPT);
1350                         MACvSelectPage0(pDevice->PortOffset);
1351                 }
1352                 pDevice->bQuietEnable = true;
1353                 pDevice->dwCurrentQuietEndTime = pDevice->sQuiet[uCurrentQuietIndex].dwStartTime;
1354                 pDevice->dwCurrentQuietEndTime += pDevice->sQuiet[uCurrentQuietIndex].wDuration;
1355                 if (pDevice->sQuiet[uCurrentQuietIndex].byPeriod == 0) {
1356                         // not period disable current quiet element
1357                         pDevice->sQuiet[uCurrentQuietIndex].bEnable = false;
1358                 } else {
1359                         // set next period start time
1360                         dwNextTime = (unsigned long) pDevice->sQuiet[uCurrentQuietIndex].byPeriod;
1361                         dwNextTime *= pDevice->wBeaconInterval;
1362                         pDevice->sQuiet[uCurrentQuietIndex].dwStartTime = dwNextTime;
1363                 }
1364                 if (pDevice->dwCurrentQuietEndTime > 0x80010000) {
1365                         // decreament all time to avoid wrap around
1366                         for (ii = 0; ii < MAX_QUIET_COUNT; ii++) {
1367                                 if (pDevice->sQuiet[ii].bEnable == true) {
1368                                         pDevice->sQuiet[ii].dwStartTime -= 0x80000000;
1369                                 }
1370                         }
1371                         pDevice->dwCurrentQuietEndTime -= 0x80000000;
1372                 }
1373         }
1374         return true;
1375 }
1376
1377 /*
1378  *
1379  * Description:
1380  *    Set Local Power Constraint
1381  *
1382  * Parameters:
1383  *  In:
1384  *      hDeviceContext - device structure point
1385  *  Out:
1386  *      none
1387  *
1388  * Return Value: none.
1389  *
1390  -*/
1391 void
1392 CARDvSetPowerConstraint(
1393         void *pDeviceHandler,
1394         unsigned char byChannel,
1395         char byPower
1396 )
1397 {
1398         PSDevice    pDevice = (PSDevice) pDeviceHandler;
1399
1400         if (byChannel > CB_MAX_CHANNEL_24G) {
1401                 if (pDevice->bCountryInfo5G == true) {
1402                         pDevice->abyLocalPwr[byChannel] = pDevice->abyRegPwr[byChannel] - byPower;
1403                 }
1404         } else {
1405                 if (pDevice->bCountryInfo24G == true) {
1406                         pDevice->abyLocalPwr[byChannel] = pDevice->abyRegPwr[byChannel] - byPower;
1407                 }
1408         }
1409 }
1410
1411 /*
1412  *
1413  * Description:
1414  *    Set Local Power Constraint
1415  *
1416  * Parameters:
1417  *  In:
1418  *      hDeviceContext - device structure point
1419  *  Out:
1420  *      none
1421  *
1422  * Return Value: none.
1423  *
1424  -*/
1425 void
1426 CARDvGetPowerCapability(
1427         void *pDeviceHandler,
1428         unsigned char *pbyMinPower,
1429         unsigned char *pbyMaxPower
1430 )
1431 {
1432         PSDevice    pDevice = (PSDevice) pDeviceHandler;
1433         unsigned char byDec = 0;
1434
1435         *pbyMaxPower = pDevice->abyOFDMDefaultPwr[pDevice->byCurrentCh];
1436         byDec = pDevice->abyOFDMPwrTbl[pDevice->byCurrentCh];
1437         if (pDevice->byRFType == RF_UW2452) {
1438                 byDec *= 3;
1439                 byDec >>= 1;
1440         } else {
1441                 byDec <<= 1;
1442         }
1443         *pbyMinPower = pDevice->abyOFDMDefaultPwr[pDevice->byCurrentCh] - byDec;
1444 }
1445
1446 /*
1447  *
1448  * Description:
1449  *    Get Current Tx Power
1450  *
1451  * Parameters:
1452  *  In:
1453  *      hDeviceContext - device structure point
1454  *  Out:
1455  *      none
1456  *
1457  * Return Value: none.
1458  *
1459  */
1460 char
1461 CARDbyGetTransmitPower(
1462         void *pDeviceHandler
1463 )
1464 {
1465         PSDevice    pDevice = (PSDevice) pDeviceHandler;
1466
1467         return pDevice->byCurPwrdBm;
1468 }
1469
1470 //xxx
1471 void
1472 CARDvSafeResetTx(
1473         void *pDeviceHandler
1474 )
1475 {
1476         PSDevice    pDevice = (PSDevice) pDeviceHandler;
1477         unsigned int uu;
1478         PSTxDesc    pCurrTD;
1479
1480         // initialize TD index
1481         pDevice->apTailTD[0] = pDevice->apCurrTD[0] = &(pDevice->apTD0Rings[0]);
1482         pDevice->apTailTD[1] = pDevice->apCurrTD[1] = &(pDevice->apTD1Rings[0]);
1483
1484         for (uu = 0; uu < TYPE_MAXTD; uu++)
1485                 pDevice->iTDUsed[uu] = 0;
1486
1487         for (uu = 0; uu < pDevice->sOpts.nTxDescs[0]; uu++) {
1488                 pCurrTD = &(pDevice->apTD0Rings[uu]);
1489                 pCurrTD->m_td0TD0.f1Owner = OWNED_BY_HOST;
1490                 // init all Tx Packet pointer to NULL
1491         }
1492         for (uu = 0; uu < pDevice->sOpts.nTxDescs[1]; uu++) {
1493                 pCurrTD = &(pDevice->apTD1Rings[uu]);
1494                 pCurrTD->m_td0TD0.f1Owner = OWNED_BY_HOST;
1495                 // init all Tx Packet pointer to NULL
1496         }
1497
1498         // set MAC TD pointer
1499         MACvSetCurrTXDescAddr(TYPE_TXDMA0, pDevice->PortOffset,
1500                               (pDevice->td0_pool_dma));
1501
1502         MACvSetCurrTXDescAddr(TYPE_AC0DMA, pDevice->PortOffset,
1503                               (pDevice->td1_pool_dma));
1504
1505         // set MAC Beacon TX pointer
1506         MACvSetCurrBCNTxDescAddr(pDevice->PortOffset,
1507                                  (pDevice->tx_beacon_dma));
1508 }
1509
1510 /*+
1511  *
1512  * Description:
1513  *      Reset Rx
1514  *
1515  * Parameters:
1516  *  In:
1517  *      pDevice     - Pointer to the adapter
1518  *  Out:
1519  *      none
1520  *
1521  * Return Value: none
1522  *
1523  -*/
1524 void
1525 CARDvSafeResetRx(
1526         void *pDeviceHandler
1527 )
1528 {
1529         PSDevice    pDevice = (PSDevice) pDeviceHandler;
1530         unsigned int uu;
1531         PSRxDesc    pDesc;
1532
1533         // initialize RD index
1534         pDevice->pCurrRD[0] = &(pDevice->aRD0Ring[0]);
1535         pDevice->pCurrRD[1] = &(pDevice->aRD1Ring[0]);
1536
1537         // init state, all RD is chip's
1538         for (uu = 0; uu < pDevice->sOpts.nRxDescs0; uu++) {
1539                 pDesc = &(pDevice->aRD0Ring[uu]);
1540                 pDesc->m_rd0RD0.wResCount = (unsigned short)(pDevice->rx_buf_sz);
1541                 pDesc->m_rd0RD0.f1Owner = OWNED_BY_NIC;
1542                 pDesc->m_rd1RD1.wReqCount = (unsigned short)(pDevice->rx_buf_sz);
1543         }
1544
1545         // init state, all RD is chip's
1546         for (uu = 0; uu < pDevice->sOpts.nRxDescs1; uu++) {
1547                 pDesc = &(pDevice->aRD1Ring[uu]);
1548                 pDesc->m_rd0RD0.wResCount = (unsigned short)(pDevice->rx_buf_sz);
1549                 pDesc->m_rd0RD0.f1Owner = OWNED_BY_NIC;
1550                 pDesc->m_rd1RD1.wReqCount = (unsigned short)(pDevice->rx_buf_sz);
1551         }
1552
1553         pDevice->cbDFCB = CB_MAX_RX_FRAG;
1554         pDevice->cbFreeDFCB = pDevice->cbDFCB;
1555
1556         // set perPkt mode
1557         MACvRx0PerPktMode(pDevice->PortOffset);
1558         MACvRx1PerPktMode(pDevice->PortOffset);
1559         // set MAC RD pointer
1560         MACvSetCurrRx0DescAddr(pDevice->PortOffset,
1561                                pDevice->rd0_pool_dma);
1562
1563         MACvSetCurrRx1DescAddr(pDevice->PortOffset,
1564                                pDevice->rd1_pool_dma);
1565 }
1566
1567 /*
1568  * Description: Get response Control frame rate in CCK mode
1569  *
1570  * Parameters:
1571  *  In:
1572  *      pDevice             - The adapter to be set
1573  *      wRateIdx            - Receiving data rate
1574  *  Out:
1575  *      none
1576  *
1577  * Return Value: response Control frame rate
1578  *
1579  */
1580 unsigned short CARDwGetCCKControlRate(void *pDeviceHandler, unsigned short wRateIdx)
1581 {
1582         PSDevice    pDevice = (PSDevice) pDeviceHandler;
1583         unsigned int ui = (unsigned int) wRateIdx;
1584
1585         while (ui > RATE_1M) {
1586                 if (pDevice->wBasicRate & ((unsigned short)1 << ui)) {
1587                         return (unsigned short)ui;
1588                 }
1589                 ui--;
1590         }
1591         return (unsigned short)RATE_1M;
1592 }
1593
1594 /*
1595  * Description: Get response Control frame rate in OFDM mode
1596  *
1597  * Parameters:
1598  *  In:
1599  *      pDevice             - The adapter to be set
1600  *      wRateIdx            - Receiving data rate
1601  *  Out:
1602  *      none
1603  *
1604  * Return Value: response Control frame rate
1605  *
1606  */
1607 unsigned short CARDwGetOFDMControlRate(void *pDeviceHandler, unsigned short wRateIdx)
1608 {
1609         PSDevice pDevice = (PSDevice) pDeviceHandler;
1610         unsigned int ui = (unsigned int) wRateIdx;
1611
1612         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "BASIC RATE: %X\n", pDevice->wBasicRate);
1613
1614         if (!CARDbIsOFDMinBasicRate((void *)pDevice)) {
1615                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "CARDwGetOFDMControlRate:(NO OFDM) %d\n", wRateIdx);
1616                 if (wRateIdx > RATE_24M)
1617                         wRateIdx = RATE_24M;
1618                 return wRateIdx;
1619         }
1620         while (ui > RATE_11M) {
1621                 if (pDevice->wBasicRate & ((unsigned short)1 << ui)) {
1622                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "CARDwGetOFDMControlRate : %d\n", ui);
1623                         return (unsigned short)ui;
1624                 }
1625                 ui--;
1626         }
1627         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "CARDwGetOFDMControlRate: 6M\n");
1628         return (unsigned short)RATE_24M;
1629 }
1630
1631 /*
1632  * Description: Set RSPINF
1633  *
1634  * Parameters:
1635  *  In:
1636  *      pDevice             - The adapter to be set
1637  *  Out:
1638  *      none
1639  *
1640  * Return Value: None.
1641  *
1642  */
1643 void CARDvSetRSPINF(void *pDeviceHandler, CARD_PHY_TYPE ePHYType)
1644 {
1645         PSDevice pDevice = (PSDevice) pDeviceHandler;
1646         unsigned char byServ = 0x00, bySignal = 0x00; //For CCK
1647         unsigned short wLen = 0x0000;
1648         unsigned char byTxRate, byRsvTime;             //For OFDM
1649
1650         //Set to Page1
1651         MACvSelectPage1(pDevice->PortOffset);
1652
1653         //RSPINF_b_1
1654         BBvCalculateParameter(pDevice,
1655                               14,
1656                               CARDwGetCCKControlRate((void *)pDevice, RATE_1M),
1657                               PK_TYPE_11B,
1658                               &wLen,
1659                               &byServ,
1660                               &bySignal
1661 );
1662
1663         VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_1, MAKEDWORD(wLen, MAKEWORD(bySignal, byServ)));
1664         ///RSPINF_b_2
1665         BBvCalculateParameter(pDevice,
1666                               14,
1667                               CARDwGetCCKControlRate((void *)pDevice, RATE_2M),
1668                               PK_TYPE_11B,
1669                               &wLen,
1670                               &byServ,
1671                               &bySignal
1672 );
1673
1674         VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_2, MAKEDWORD(wLen, MAKEWORD(bySignal, byServ)));
1675         //RSPINF_b_5
1676         BBvCalculateParameter(pDevice,
1677                               14,
1678                               CARDwGetCCKControlRate((void *)pDevice, RATE_5M),
1679                               PK_TYPE_11B,
1680                               &wLen,
1681                               &byServ,
1682                               &bySignal
1683 );
1684
1685         VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_5, MAKEDWORD(wLen, MAKEWORD(bySignal, byServ)));
1686         //RSPINF_b_11
1687         BBvCalculateParameter(pDevice,
1688                               14,
1689                               CARDwGetCCKControlRate((void *)pDevice, RATE_11M),
1690                               PK_TYPE_11B,
1691                               &wLen,
1692                               &byServ,
1693                               &bySignal
1694 );
1695
1696         VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_11, MAKEDWORD(wLen, MAKEWORD(bySignal, byServ)));
1697         //RSPINF_a_6
1698         s_vCalculateOFDMRParameter(RATE_6M,
1699                                    ePHYType,
1700                                    &byTxRate,
1701                                    &byRsvTime);
1702         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_6, MAKEWORD(byTxRate, byRsvTime));
1703         //RSPINF_a_9
1704         s_vCalculateOFDMRParameter(RATE_9M,
1705                                    ePHYType,
1706                                    &byTxRate,
1707                                    &byRsvTime);
1708         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_9, MAKEWORD(byTxRate, byRsvTime));
1709         //RSPINF_a_12
1710         s_vCalculateOFDMRParameter(RATE_12M,
1711                                    ePHYType,
1712                                    &byTxRate,
1713                                    &byRsvTime);
1714         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_12, MAKEWORD(byTxRate, byRsvTime));
1715         //RSPINF_a_18
1716         s_vCalculateOFDMRParameter(RATE_18M,
1717                                    ePHYType,
1718                                    &byTxRate,
1719                                    &byRsvTime);
1720         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_18, MAKEWORD(byTxRate, byRsvTime));
1721         //RSPINF_a_24
1722         s_vCalculateOFDMRParameter(RATE_24M,
1723                                    ePHYType,
1724                                    &byTxRate,
1725                                    &byRsvTime);
1726         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_24, MAKEWORD(byTxRate, byRsvTime));
1727         //RSPINF_a_36
1728         s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate((void *)pDevice, RATE_36M),
1729                                    ePHYType,
1730                                    &byTxRate,
1731                                    &byRsvTime);
1732         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_36, MAKEWORD(byTxRate, byRsvTime));
1733         //RSPINF_a_48
1734         s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate((void *)pDevice, RATE_48M),
1735                                    ePHYType,
1736                                    &byTxRate,
1737                                    &byRsvTime);
1738         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_48, MAKEWORD(byTxRate, byRsvTime));
1739         //RSPINF_a_54
1740         s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate((void *)pDevice, RATE_54M),
1741                                    ePHYType,
1742                                    &byTxRate,
1743                                    &byRsvTime);
1744         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_54, MAKEWORD(byTxRate, byRsvTime));
1745
1746         //RSPINF_a_72
1747         s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate((void *)pDevice, RATE_54M),
1748                                    ePHYType,
1749                                    &byTxRate,
1750                                    &byRsvTime);
1751         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_72, MAKEWORD(byTxRate, byRsvTime));
1752         //Set to Page0
1753         MACvSelectPage0(pDevice->PortOffset);
1754 }
1755
1756 /*
1757  * Description: Update IFS
1758  *
1759  * Parameters:
1760  *  In:
1761  *      pDevice             - The adapter to be set
1762  *  Out:
1763  *      none
1764  *
1765  * Return Value: None.
1766  *
1767  */
1768 void vUpdateIFS(void *pDeviceHandler)
1769 {
1770         //Set SIFS, DIFS, EIFS, SlotTime, CwMin
1771         PSDevice pDevice = (PSDevice) pDeviceHandler;
1772
1773         unsigned char byMaxMin = 0;
1774         if (pDevice->byPacketType == PK_TYPE_11A) {//0000 0000 0000 0000,11a
1775                 pDevice->uSlot = C_SLOT_SHORT;
1776                 pDevice->uSIFS = C_SIFS_A;
1777                 pDevice->uDIFS = C_SIFS_A + 2*C_SLOT_SHORT;
1778                 pDevice->uCwMin = C_CWMIN_A;
1779                 byMaxMin = 4;
1780         } else if (pDevice->byPacketType == PK_TYPE_11B) {//0000 0001 0000 0000,11b
1781                 pDevice->uSlot = C_SLOT_LONG;
1782                 pDevice->uSIFS = C_SIFS_BG;
1783                 pDevice->uDIFS = C_SIFS_BG + 2*C_SLOT_LONG;
1784                 pDevice->uCwMin = C_CWMIN_B;
1785                 byMaxMin = 5;
1786         } else { // PK_TYPE_11GA & PK_TYPE_11GB
1787                 pDevice->uSIFS = C_SIFS_BG;
1788                 if (pDevice->bShortSlotTime) {
1789                         pDevice->uSlot = C_SLOT_SHORT;
1790                 } else {
1791                         pDevice->uSlot = C_SLOT_LONG;
1792                 }
1793                 pDevice->uDIFS = C_SIFS_BG + 2*pDevice->uSlot;
1794                 if (pDevice->wBasicRate & 0x0150) { //0000 0001 0101 0000,24M,12M,6M
1795                         pDevice->uCwMin = C_CWMIN_A;
1796                         byMaxMin = 4;
1797                 } else {
1798                         pDevice->uCwMin = C_CWMIN_B;
1799                         byMaxMin = 5;
1800                 }
1801         }
1802
1803         pDevice->uCwMax = C_CWMAX;
1804         pDevice->uEIFS = C_EIFS;
1805         if (pDevice->byRFType == RF_RFMD2959) {
1806                 // bcs TX_PE will reserve 3 us
1807                 VNSvOutPortB(pDevice->PortOffset + MAC_REG_SIFS, (unsigned char)(pDevice->uSIFS - 3));
1808                 VNSvOutPortB(pDevice->PortOffset + MAC_REG_DIFS, (unsigned char)(pDevice->uDIFS - 3));
1809         } else {
1810                 VNSvOutPortB(pDevice->PortOffset + MAC_REG_SIFS, (unsigned char)pDevice->uSIFS);
1811                 VNSvOutPortB(pDevice->PortOffset + MAC_REG_DIFS, (unsigned char)pDevice->uDIFS);
1812         }
1813         VNSvOutPortB(pDevice->PortOffset + MAC_REG_EIFS, (unsigned char)pDevice->uEIFS);
1814         VNSvOutPortB(pDevice->PortOffset + MAC_REG_SLOT, (unsigned char)pDevice->uSlot);
1815         byMaxMin |= 0xA0;//1010 1111,C_CWMAX = 1023
1816         VNSvOutPortB(pDevice->PortOffset + MAC_REG_CWMAXMIN0, (unsigned char)byMaxMin);
1817 }
1818
1819 void CARDvUpdateBasicTopRate(void *pDeviceHandler)
1820 {
1821         PSDevice pDevice = (PSDevice) pDeviceHandler;
1822         unsigned char byTopOFDM = RATE_24M, byTopCCK = RATE_1M;
1823         unsigned char ii;
1824
1825         //Determines the highest basic rate.
1826         for (ii = RATE_54M; ii >= RATE_6M; ii--) {
1827                 if ((pDevice->wBasicRate) & ((unsigned short)(1<<ii))) {
1828                         byTopOFDM = ii;
1829                         break;
1830                 }
1831         }
1832         pDevice->byTopOFDMBasicRate = byTopOFDM;
1833
1834         for (ii = RATE_11M;; ii--) {
1835                 if ((pDevice->wBasicRate) & ((unsigned short)(1<<ii))) {
1836                         byTopCCK = ii;
1837                         break;
1838                 }
1839                 if (ii == RATE_1M)
1840                         break;
1841         }
1842         pDevice->byTopCCKBasicRate = byTopCCK;
1843 }
1844
1845 bool CARDbAddBasicRate(void *pDeviceHandler, unsigned short wRateIdx)
1846 {
1847         PSDevice pDevice = (PSDevice) pDeviceHandler;
1848         unsigned short wRate = (unsigned short)(1<<wRateIdx);
1849
1850         pDevice->wBasicRate |= wRate;
1851
1852         //Determines the highest basic rate.
1853         CARDvUpdateBasicTopRate((void *)pDevice);
1854
1855         return true;
1856 }
1857
1858 bool CARDbIsOFDMinBasicRate(void *pDeviceHandler)
1859 {
1860         PSDevice pDevice = (PSDevice)pDeviceHandler;
1861         int ii;
1862
1863         for (ii = RATE_54M; ii >= RATE_6M; ii--) {
1864                 if ((pDevice->wBasicRate) & ((unsigned short)(1 << ii)))
1865                         return true;
1866         }
1867         return false;
1868 }
1869
1870 unsigned char CARDbyGetPktType(void *pDeviceHandler)
1871 {
1872         PSDevice pDevice = (PSDevice) pDeviceHandler;
1873
1874         if (pDevice->byBBType == BB_TYPE_11A || pDevice->byBBType == BB_TYPE_11B) {
1875                 return (unsigned char)pDevice->byBBType;
1876         } else if (CARDbIsOFDMinBasicRate((void *)pDevice)) {
1877                 return PK_TYPE_11GA;
1878         } else {
1879                 return PK_TYPE_11GB;
1880         }
1881 }
1882
1883 /*
1884  * Description: Set NIC Loopback mode
1885  *
1886  * Parameters:
1887  *  In:
1888  *      pDevice         - The adapter to be set
1889  *      wLoopbackMode   - Loopback mode to be set
1890  *  Out:
1891  *      none
1892  *
1893  * Return Value: none
1894  *
1895  */
1896 void CARDvSetLoopbackMode(unsigned long dwIoBase, unsigned short wLoopbackMode)
1897 {
1898         switch (wLoopbackMode) {
1899         case CARD_LB_NONE:
1900         case CARD_LB_MAC:
1901         case CARD_LB_PHY:
1902                 break;
1903         default:
1904                 ASSERT(false);
1905                 break;
1906         }
1907         // set MAC loopback
1908         MACvSetLoopbackMode(dwIoBase, LOBYTE(wLoopbackMode));
1909         // set Baseband loopback
1910 }
1911
1912 /*
1913  * Description: Software Reset NIC
1914  *
1915  * Parameters:
1916  *  In:
1917  *      pDevice         - The adapter to be reset
1918  *  Out:
1919  *      none
1920  *
1921  * Return Value: none
1922  *
1923  */
1924 bool CARDbSoftwareReset(void *pDeviceHandler)
1925 {
1926         PSDevice pDevice = (PSDevice) pDeviceHandler;
1927
1928         // reset MAC
1929         if (!MACbSafeSoftwareReset(pDevice->PortOffset))
1930                 return false;
1931
1932         return true;
1933 }
1934
1935 /*
1936  * Description: Calculate TSF offset of two TSF input
1937  *              Get TSF Offset from RxBCN's TSF and local TSF
1938  *
1939  * Parameters:
1940  *  In:
1941  *      pDevice         - The adapter to be sync.
1942  *      qwTSF1          - Rx BCN's TSF
1943  *      qwTSF2          - Local TSF
1944  *  Out:
1945  *      none
1946  *
1947  * Return Value: TSF Offset value
1948  *
1949  */
1950 QWORD CARDqGetTSFOffset(unsigned char byRxRate, QWORD qwTSF1, QWORD qwTSF2)
1951 {
1952         QWORD   qwTSFOffset;
1953         unsigned short wRxBcnTSFOffst = 0;
1954
1955         HIDWORD(qwTSFOffset) = 0;
1956         LODWORD(qwTSFOffset) = 0;
1957         wRxBcnTSFOffst = cwRXBCNTSFOff[byRxRate%MAX_RATE];
1958         (qwTSF2).u.dwLowDword += (unsigned long)(wRxBcnTSFOffst);
1959         if ((qwTSF2).u.dwLowDword < (unsigned long)(wRxBcnTSFOffst)) {
1960                 (qwTSF2).u.dwHighDword++;
1961         }
1962         LODWORD(qwTSFOffset) = LODWORD(qwTSF1) - LODWORD(qwTSF2);
1963         if (LODWORD(qwTSF1) < LODWORD(qwTSF2)) {
1964                 // if borrow needed
1965                 HIDWORD(qwTSFOffset) = HIDWORD(qwTSF1) - HIDWORD(qwTSF2) - 1;
1966         } else {
1967                 HIDWORD(qwTSFOffset) = HIDWORD(qwTSF1) - HIDWORD(qwTSF2);
1968         }
1969         return qwTSFOffset;
1970 }
1971
1972 /*
1973  * Description: Read NIC TSF counter
1974  *              Get local TSF counter
1975  *
1976  * Parameters:
1977  *  In:
1978  *      pDevice         - The adapter to be read
1979  *  Out:
1980  *      qwCurrTSF       - Current TSF counter
1981  *
1982  * Return Value: true if success; otherwise false
1983  *
1984  */
1985 bool CARDbGetCurrentTSF(unsigned long dwIoBase, PQWORD pqwCurrTSF)
1986 {
1987         unsigned short ww;
1988         unsigned char byData;
1989
1990         MACvRegBitsOn(dwIoBase, MAC_REG_TFTCTL, TFTCTL_TSFCNTRRD);
1991         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
1992                 VNSvInPortB(dwIoBase + MAC_REG_TFTCTL, &byData);
1993                 if (!(byData & TFTCTL_TSFCNTRRD))
1994                         break;
1995         }
1996         if (ww == W_MAX_TIMEOUT)
1997                 return false;
1998         VNSvInPortD(dwIoBase + MAC_REG_TSFCNTR, &LODWORD(*pqwCurrTSF));
1999         VNSvInPortD(dwIoBase + MAC_REG_TSFCNTR + 4, &HIDWORD(*pqwCurrTSF));
2000
2001         return true;
2002 }
2003
2004 /*
2005  * Description: Read NIC TSF counter
2006  *              Get NEXTTBTT from adjusted TSF and Beacon Interval
2007  *
2008  * Parameters:
2009  *  In:
2010  *      qwTSF           - Current TSF counter
2011  *      wbeaconInterval - Beacon Interval
2012  *  Out:
2013  *      qwCurrTSF       - Current TSF counter
2014  *
2015  * Return Value: TSF value of next Beacon
2016  *
2017  */
2018 QWORD CARDqGetNextTBTT(QWORD qwTSF, unsigned short wBeaconInterval)
2019 {
2020         unsigned int uLowNextTBTT;
2021         unsigned int uHighRemain, uLowRemain;
2022         unsigned int uBeaconInterval;
2023
2024         uBeaconInterval = wBeaconInterval * 1024;
2025         // Next TBTT = ((local_current_TSF / beacon_interval) + 1) * beacon_interval
2026         uLowNextTBTT = (LODWORD(qwTSF) >> 10) << 10;
2027         // low dword (mod) bcn
2028         uLowRemain = (uLowNextTBTT) % uBeaconInterval;
2029         // high dword (mod) bcn
2030         uHighRemain = (((0xffffffff % uBeaconInterval) + 1) * HIDWORD(qwTSF))
2031                 % uBeaconInterval;
2032         uLowRemain = (uHighRemain + uLowRemain) % uBeaconInterval;
2033         uLowRemain = uBeaconInterval - uLowRemain;
2034
2035         // check if carry when add one beacon interval
2036         if ((~uLowNextTBTT) < uLowRemain)
2037                 HIDWORD(qwTSF)++;
2038
2039         LODWORD(qwTSF) = uLowNextTBTT + uLowRemain;
2040
2041         return qwTSF;
2042 }
2043
2044 /*
2045  * Description: Set NIC TSF counter for first Beacon time
2046  *              Get NEXTTBTT from adjusted TSF and Beacon Interval
2047  *
2048  * Parameters:
2049  *  In:
2050  *      dwIoBase        - IO Base
2051  *      wBeaconInterval - Beacon Interval
2052  *  Out:
2053  *      none
2054  *
2055  * Return Value: none
2056  *
2057  */
2058 void CARDvSetFirstNextTBTT(unsigned long dwIoBase, unsigned short wBeaconInterval)
2059 {
2060         QWORD   qwNextTBTT;
2061
2062         HIDWORD(qwNextTBTT) = 0;
2063         LODWORD(qwNextTBTT) = 0;
2064         CARDbGetCurrentTSF(dwIoBase, &qwNextTBTT); //Get Local TSF counter
2065         qwNextTBTT = CARDqGetNextTBTT(qwNextTBTT, wBeaconInterval);
2066         // Set NextTBTT
2067         VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT, LODWORD(qwNextTBTT));
2068         VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT + 4, HIDWORD(qwNextTBTT));
2069         MACvRegBitsOn(dwIoBase, MAC_REG_TFTCTL, TFTCTL_TBTTSYNCEN);
2070
2071         return;
2072 }
2073
2074 /*
2075  * Description: Sync NIC TSF counter for Beacon time
2076  *              Get NEXTTBTT and write to HW
2077  *
2078  * Parameters:
2079  *  In:
2080  *      pDevice         - The adapter to be set
2081  *      qwTSF           - Current TSF counter
2082  *      wBeaconInterval - Beacon Interval
2083  *  Out:
2084  *      none
2085  *
2086  * Return Value: none
2087  *
2088  */
2089 void CARDvUpdateNextTBTT(unsigned long dwIoBase, QWORD qwTSF, unsigned short wBeaconInterval)
2090 {
2091         qwTSF = CARDqGetNextTBTT(qwTSF, wBeaconInterval);
2092         // Set NextTBTT
2093         VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT, LODWORD(qwTSF));
2094         VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT + 4, HIDWORD(qwTSF));
2095         MACvRegBitsOn(dwIoBase, MAC_REG_TFTCTL, TFTCTL_TBTTSYNCEN);
2096         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Card:Update Next TBTT[%8xh:%8xh] \n",
2097                 (unsigned int) HIDWORD(qwTSF), (unsigned int) LODWORD(qwTSF));
2098
2099         return;
2100 }