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