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