drivers/staging/vt6655/vntwifi.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  *
  20  * File: vntwifi.c
  21  *
  22  * Purpose: export functions for vntwifi lib
  23  *
  24  * Functions:
  25  *
  26  * Revision History:
  27  *
  28  * Author: Yiching Chen
  29  *
  30  * Date: feb. 2, 2005
  31  *
  32  */
  33
  34 #include "vntwifi.h"
  35 #include "umem.h"
  36 #include "tbit.h"
  37 #include "IEEE11h.h"
  38 #include "country.h"
  39 #include "device.h"
  40 #include "wmgr.h"
  41 #include "datarate.h"
  42
  43 //#define       PLICE_DEBUG
  44
  45 /*---------------------  Static Definitions -------------------------*/
  46 //static int          msglevel                =MSG_LEVEL_DEBUG;
  47 //static int          msglevel                =MSG_LEVEL_INFO;
  48
  49 /*---------------------  Static Classes  ----------------------------*/
  50
  51 /*---------------------  Static Variables  --------------------------*/
  52
  53 /*---------------------  Static Functions  --------------------------*/
  54
  55 /*---------------------  Export Variables  --------------------------*/
  56
  57 /*---------------------  Export Functions  --------------------------*/
  58
  59 /*+
  60  *
  61  * Description:
  62  *    Set Operation Mode
  63  *
  64  * Parameters:
  65  *  In:
  66  *      pMgmtHandle - pointer to management object
  67  *      eOPMode     - Opreation Mode
  68  *  Out:
  69  *      none
  70  *
  71  * Return Value: none
  72  *
  73 -*/
  74 VOID
  75 VNTWIFIvSetOPMode (
  76     IN PVOID pMgmtHandle,
  77     IN WMAC_CONFIG_MODE eOPMode
  78     )
  79 {
  80     PSMgmtObject        pMgmt = (PSMgmtObject)pMgmtHandle;
  81
  82     pMgmt->eConfigMode = eOPMode;
  83 }
  84
  85
  86 /*+
  87  *
  88  * Description:
  89  *    Set Operation Mode
  90  *
  91  * Parameters:
  92  *  In:
  93  *      pMgmtHandle - pointer to management object
  94  *      wBeaconPeriod - Beacon Period
  95  *      wATIMWindow - ATIM window
  96  *      uChannel - channel number
  97  *  Out:
  98  *      none
  99  *
 100  * Return Value: none
 101  *
 102 -*/
 103 VOID
 104 VNTWIFIvSetIBSSParameter (
 105     IN PVOID pMgmtHandle,
 106     IN WORD  wBeaconPeriod,
 107     IN WORD  wATIMWindow,
 108     IN UINT  uChannel
 109     )
 110 {
 111     PSMgmtObject        pMgmt = (PSMgmtObject)pMgmtHandle;
 112
 113     pMgmt->wIBSSBeaconPeriod = wBeaconPeriod;
 114     pMgmt->wIBSSATIMWindow = wATIMWindow;
 115     pMgmt->uIBSSChannel = uChannel;
 116 }
 117
 118 /*+
 119  *
 120  * Description:
 121  *    Get current SSID
 122  *
 123  * Parameters:
 124  *  In:
 125  *      pMgmtHandle - pointer to management object
 126  *  Out:
 127  *      none
 128  *
 129  * Return Value: current SSID pointer.
 130  *
 131 -*/
 132 PWLAN_IE_SSID
 133 VNTWIFIpGetCurrentSSID (
 134     IN PVOID pMgmtHandle
 135     )
 136 {
 137     PSMgmtObject        pMgmt = (PSMgmtObject)pMgmtHandle;
 138     return((PWLAN_IE_SSID) pMgmt->abyCurrSSID);
 139 }
 140
 141 /*+
 142  *
 143  * Description:
 144  *    Get current link channel
 145  *
 146  * Parameters:
 147  *  In:
 148  *      pMgmtHandle - pointer to management object
 149  *  Out:
 150  *      none
 151  *
 152  * Return Value: current Channel.
 153  *
 154 -*/
 155 UINT
 156 VNTWIFIpGetCurrentChannel (
 157     IN PVOID pMgmtHandle
 158     )
 159 {
 160     PSMgmtObject        pMgmt = (PSMgmtObject)pMgmtHandle;
 161     if (pMgmtHandle != NULL) {
 162         return (pMgmt->uCurrChannel);
 163     }
 164     return 0;
 165 }
 166
 167 /*+
 168  *
 169  * Description:
 170  *    Get current Assoc ID
 171  *
 172  * Parameters:
 173  *  In:
 174  *      pMgmtHandle - pointer to management object
 175  *  Out:
 176  *      none
 177  *
 178  * Return Value: current Assoc ID
 179  *
 180 -*/
 181 WORD
 182 VNTWIFIwGetAssocID (
 183     IN PVOID pMgmtHandle
 184     )
 185 {
 186     PSMgmtObject        pMgmt = (PSMgmtObject)pMgmtHandle;
 187     return(pMgmt->wCurrAID);
 188 }
 189
 190
 191
 192 /*+
 193  *
 194  * Description:
 195  *    This routine return max support rate of IES
 196  *
 197  * Parameters:
 198  *  In:
 199  *      pSupportRateIEs
 200  *      pExtSupportRateIEs
 201  *
 202  *  Out:
 203  *
 204  * Return Value: max support rate
 205  *
 206 -*/
 207 BYTE
 208 VNTWIFIbyGetMaxSupportRate (
 209     IN PWLAN_IE_SUPP_RATES pSupportRateIEs,
 210     IN PWLAN_IE_SUPP_RATES pExtSupportRateIEs
 211     )
 212 {
 213     BYTE    byMaxSupportRate = RATE_1M;
 214     BYTE    bySupportRate = RATE_1M;
 215     UINT    ii = 0;
 216
 217     if (pSupportRateIEs) {
 218         for (ii = 0; ii < pSupportRateIEs->len; ii++) {
 219             bySupportRate = DATARATEbyGetRateIdx(pSupportRateIEs->abyRates[ii]);
 220             if (bySupportRate > byMaxSupportRate) {
 221                 byMaxSupportRate = bySupportRate;
 222             }
 223         }
 224     }
 225     if (pExtSupportRateIEs) {
 226         for (ii = 0; ii < pExtSupportRateIEs->len; ii++) {
 227             bySupportRate = DATARATEbyGetRateIdx(pExtSupportRateIEs->abyRates[ii]);
 228             if (bySupportRate > byMaxSupportRate) {
 229                 byMaxSupportRate = bySupportRate;
 230             }
 231         }
 232     }
 233
 234     return byMaxSupportRate;
 235 }
 236
 237 /*+
 238  *
 239  * Description:
 240  *    This routine return data rate of ACK packtet
 241  *
 242  * Parameters:
 243  *  In:
 244  *      byRxDataRate
 245  *      pSupportRateIEs
 246  *      pExtSupportRateIEs
 247  *
 248  *  Out:
 249  *
 250  * Return Value: max support rate
 251  *
 252 -*/
 253 BYTE
 254 VNTWIFIbyGetACKTxRate (
 255     IN BYTE byRxDataRate,
 256     IN PWLAN_IE_SUPP_RATES pSupportRateIEs,
 257     IN PWLAN_IE_SUPP_RATES pExtSupportRateIEs
 258     )
 259 {
 260     BYTE    byMaxAckRate;
 261     BYTE    byBasicRate;
 262     UINT    ii;
 263
 264     if (byRxDataRate <= RATE_11M) {
 265         byMaxAckRate = RATE_1M;
 266     } else  {
 267         // 24M is mandatory for 802.11a and 802.11g
 268         byMaxAckRate = RATE_24M;
 269     }
 270     if (pSupportRateIEs) {
 271         for (ii = 0; ii < pSupportRateIEs->len; ii++) {
 272             if (pSupportRateIEs->abyRates[ii] & 0x80) {
 273                 byBasicRate = DATARATEbyGetRateIdx(pSupportRateIEs->abyRates[ii]);
 274                 if ((byBasicRate <= byRxDataRate) &&
 275                     (byBasicRate > byMaxAckRate))  {
 276                     byMaxAckRate = byBasicRate;
 277                 }
 278             }
 279         }
 280     }
 281     if (pExtSupportRateIEs) {
 282         for (ii = 0; ii < pExtSupportRateIEs->len; ii++) {
 283             if (pExtSupportRateIEs->abyRates[ii] & 0x80) {
 284                 byBasicRate = DATARATEbyGetRateIdx(pExtSupportRateIEs->abyRates[ii]);
 285                 if ((byBasicRate <= byRxDataRate) &&
 286                     (byBasicRate > byMaxAckRate))  {
 287                     byMaxAckRate = byBasicRate;
 288                 }
 289             }
 290         }
 291     }
 292
 293     return byMaxAckRate;
 294 }
 295
 296 /*+
 297  *
 298  * Description:
 299  *    Set Authentication Mode
 300  *
 301  * Parameters:
 302  *  In:
 303  *      pMgmtHandle - pointer to management object
 304  *      eAuthMode   - Authentication mode
 305  *  Out:
 306  *      none
 307  *
 308  * Return Value: none
 309  *
 310 -*/
 311 VOID
 312 VNTWIFIvSetAuthenticationMode (
 313     IN PVOID pMgmtHandle,
 314     IN WMAC_AUTHENTICATION_MODE eAuthMode
 315     )
 316 {
 317     PSMgmtObject        pMgmt = (PSMgmtObject)pMgmtHandle;
 318
 319     pMgmt->eAuthenMode = eAuthMode;
 320     if ((eAuthMode == WMAC_AUTH_SHAREKEY) ||
 321         (eAuthMode == WMAC_AUTH_AUTO)) {
 322         pMgmt->bShareKeyAlgorithm = TRUE;
 323     } else {
 324         pMgmt->bShareKeyAlgorithm = FALSE;
 325     }
 326 }
 327
 328 /*+
 329  *
 330  * Description:
 331  *    Set Encryption Mode
 332  *
 333  * Parameters:
 334  *  In:
 335  *      pMgmtHandle - pointer to management object
 336  *      eAuthMode   - Authentication mode
 337  *  Out:
 338  *      none
 339  *
 340  * Return Value: none
 341  *
 342 -*/
 343 VOID
 344 VNTWIFIvSetEncryptionMode (
 345     IN PVOID pMgmtHandle,
 346     IN WMAC_ENCRYPTION_MODE eEncryptionMode
 347     )
 348 {
 349     PSMgmtObject        pMgmt = (PSMgmtObject)pMgmtHandle;
 350
 351     pMgmt->eEncryptionMode = eEncryptionMode;
 352     if ((eEncryptionMode == WMAC_ENCRYPTION_WEPEnabled) ||
 353         (eEncryptionMode == WMAC_ENCRYPTION_TKIPEnabled) ||
 354         (eEncryptionMode == WMAC_ENCRYPTION_AESEnabled) ) {
 355         pMgmt->bPrivacyInvoked = TRUE;
 356     } else {
 357         pMgmt->bPrivacyInvoked = FALSE;
 358     }
 359 }
 360
 361
 362
 363 BOOL
 364 VNTWIFIbConfigPhyMode (
 365     IN PVOID pMgmtHandle,
 366     IN CARD_PHY_TYPE ePhyType
 367     )
 368 {
 369     PSMgmtObject        pMgmt = (PSMgmtObject)pMgmtHandle;
 370
 371     if ((ePhyType != PHY_TYPE_AUTO) &&
 372         (ePhyType != pMgmt->eCurrentPHYMode)) {
 373         if (CARDbSetPhyParameter(pMgmt->pAdapter, ePhyType, 0, 0, NULL, NULL)==TRUE) {
 374             pMgmt->eCurrentPHYMode = ePhyType;
 375         } else {
 376             return(FALSE);
 377         }
 378     }
 379     pMgmt->eConfigPHYMode = ePhyType;
 380     return(TRUE);
 381 }
 382
 383
 384 VOID
 385 VNTWIFIbGetConfigPhyMode (
 386     IN  PVOID pMgmtHandle,
 387     OUT PVOID pePhyType
 388     )
 389 {
 390     PSMgmtObject        pMgmt = (PSMgmtObject)pMgmtHandle;
 391
 392     if ((pMgmt != NULL) && (pePhyType != NULL)) {
 393         *(PCARD_PHY_TYPE)pePhyType = pMgmt->eConfigPHYMode;
 394     }
 395 }
 396
 397 /*+
 398  *
 399  * Description:
 400  *      Clear BSS List Database except current assoc BSS
 401  *
 402  * Parameters:
 403  *  In:
 404  *      pMgmtHandle     - Management Object structure
 405  *      bLinkPass       - Current Link status
 406  *  Out:
 407  *
 408  * Return Value: None.
 409  *
 410 -*/
 411
 412
 413 /*+
 414  *
 415  * Description:
 416  *      Query BSS List in management database
 417  *
 418  * Parameters:
 419  *  In:
 420  *      pMgmtHandle     - Management Object structure
 421  *  Out:
 422  *      puBSSCount      - BSS count
 423  *      pvFirstBSS      - pointer to first BSS
 424  *
 425  * Return Value: None.
 426  *
 427 -*/
 428
 429 VOID
 430 VNTWIFIvQueryBSSList (
 431     IN PVOID    pMgmtHandle,
 432     OUT PUINT   puBSSCount,
 433     OUT PVOID   *pvFirstBSS
 434     )
 435 {
 436     UINT            ii = 0;
 437     PSMgmtObject    pMgmt = (PSMgmtObject)pMgmtHandle;
 438     PKnownBSS       pBSS = NULL;
 439     UINT            uCount = 0;
 440
 441     *pvFirstBSS = NULL;
 442
 443     for (ii = 0; ii < MAX_BSS_NUM; ii++) {
 444         pBSS = &(pMgmt->sBSSList[ii]);
 445         if (!pBSS->bActive) {
 446             continue;
 447         }
 448         if (*pvFirstBSS == NULL) {
 449             *pvFirstBSS = &(pMgmt->sBSSList[ii]);
 450         }
 451         uCount++;
 452     }
 453     *puBSSCount = uCount;
 454 }
 455
 456
 457
 458
 459 VOID
 460 VNTWIFIvGetNextBSS (
 461     IN PVOID            pMgmtHandle,
 462     IN PVOID            pvCurrentBSS,
 463     OUT PVOID           *pvNextBSS
 464     )
 465 {
 466     PKnownBSS       pBSS = (PKnownBSS) pvCurrentBSS;
 467     PSMgmtObject    pMgmt = (PSMgmtObject)pMgmtHandle;
 468
 469     *pvNextBSS = NULL;
 470
 471     while (*pvNextBSS == NULL) {
 472         pBSS++;
 473         if (pBSS > &(pMgmt->sBSSList[MAX_BSS_NUM])) {
 474             return;
 475         }
 476         if (pBSS->bActive == TRUE) {
 477             *pvNextBSS = pBSS;
 478             return;
 479         }
 480     }
 481 }
 482
 483
 484
 485
 486
 487 /*+
 488  *
 489  * Description:
 490  *      Update Tx attemps, Tx failure counter in Node DB
 491  *
 492  *  In:
 493  *  Out:
 494  *      none
 495  *
 496  * Return Value: none
 497  *
 498 -*/
 499 VOID
 500 VNTWIFIvUpdateNodeTxCounter(
 501     IN PVOID    pMgmtHandle,
 502     IN PBYTE    pbyDestAddress,
 503     IN BOOL     bTxOk,
 504     IN WORD     wRate,
 505     IN PBYTE    pbyTxFailCount
 506     )
 507 {
 508     PSMgmtObject    pMgmt = (PSMgmtObject)pMgmtHandle;
 509     UINT            uNodeIndex = 0;
 510     UINT            ii;
 511
 512     if ((pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) ||
 513         (pMgmt->eCurrMode == WMAC_MODE_ESS_AP)) {
 514         if (BSSDBbIsSTAInNodeDB(pMgmt, pbyDestAddress, &uNodeIndex) == FALSE) {
 515             return;
 516         }
 517     }
 518     pMgmt->sNodeDBTable[uNodeIndex].uTxAttempts++;
 519     if (bTxOk == TRUE) {
 520         // transmit success, TxAttempts at least plus one
 521         pMgmt->sNodeDBTable[uNodeIndex].uTxOk[MAX_RATE]++;
 522         pMgmt->sNodeDBTable[uNodeIndex].uTxOk[wRate]++;
 523     } else {
 524         pMgmt->sNodeDBTable[uNodeIndex].uTxFailures++;
 525     }
 526     pMgmt->sNodeDBTable[uNodeIndex].uTxRetry += pbyTxFailCount[MAX_RATE];
 527     for(ii=0;ii<MAX_RATE;ii++) {
 528         pMgmt->sNodeDBTable[uNodeIndex].uTxFail[ii] += pbyTxFailCount[ii];
 529     }
 530     return;
 531 }
 532
 533
 534 VOID
 535 VNTWIFIvGetTxRate(
 536     IN PVOID    pMgmtHandle,
 537     IN PBYTE    pbyDestAddress,
 538     OUT PWORD   pwTxDataRate,
 539     OUT PBYTE   pbyACKRate,
 540     OUT PBYTE   pbyCCKBasicRate,
 541     OUT PBYTE   pbyOFDMBasicRate
 542     )
 543 {
 544     PSMgmtObject        pMgmt = (PSMgmtObject)pMgmtHandle;
 545     UINT                uNodeIndex = 0;
 546     WORD                wTxDataRate = RATE_1M;
 547     BYTE                byACKRate = RATE_1M;
 548     BYTE                byCCKBasicRate = RATE_1M;
 549     BYTE                byOFDMBasicRate = RATE_24M;
 550     PWLAN_IE_SUPP_RATES pSupportRateIEs = NULL;
 551     PWLAN_IE_SUPP_RATES pExtSupportRateIEs = NULL;
 552
 553
 554     if ((pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) ||
 555         (pMgmt->eCurrMode == WMAC_MODE_ESS_AP)) {
 556         // Adhoc Tx rate decided from node DB
 557         if(BSSDBbIsSTAInNodeDB(pMgmt, pbyDestAddress, &uNodeIndex)) {
 558             wTxDataRate = (pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate);
 559             pSupportRateIEs = (PWLAN_IE_SUPP_RATES) (pMgmt->sNodeDBTable[uNodeIndex].abyCurrSuppRates);
 560             pExtSupportRateIEs = (PWLAN_IE_SUPP_RATES) (pMgmt->sNodeDBTable[uNodeIndex].abyCurrExtSuppRates);
 561         } else {
 562             if (pMgmt->eCurrentPHYMode != PHY_TYPE_11A) {
 563                 wTxDataRate = RATE_2M;
 564             } else {
 565                 wTxDataRate = RATE_24M;
 566             }
 567             pSupportRateIEs = (PWLAN_IE_SUPP_RATES) pMgmt->abyCurrSuppRates;
 568             pExtSupportRateIEs = (PWLAN_IE_SUPP_RATES) pMgmt->abyCurrExtSuppRates;
 569         }
 570     } else { // Infrastructure: rate decided from AP Node, index = 0
 571
 572                 wTxDataRate = (pMgmt->sNodeDBTable[0].wTxDataRate);
 573 #ifdef  PLICE_DEBUG
 574                 printk("GetTxRate:AP MAC is %02x:%02x:%02x:%02x:%02x:%02x,TxRate is %d\n",
 575                                 pMgmt->sNodeDBTable[0].abyMACAddr[0],pMgmt->sNodeDBTable[0].abyMACAddr[1],
 576                                 pMgmt->sNodeDBTable[0].abyMACAddr[2],pMgmt->sNodeDBTable[0].abyMACAddr[3],
 577                                 pMgmt->sNodeDBTable[0].abyMACAddr[4],pMgmt->sNodeDBTable[0].abyMACAddr[5],wTxDataRate);
 578 #endif
 579
 580
 581         pSupportRateIEs = (PWLAN_IE_SUPP_RATES) pMgmt->abyCurrSuppRates;
 582         pExtSupportRateIEs = (PWLAN_IE_SUPP_RATES) pMgmt->abyCurrExtSuppRates;
 583     }
 584     byACKRate = VNTWIFIbyGetACKTxRate(  (BYTE) wTxDataRate,
 585                                         pSupportRateIEs,
 586                                         pExtSupportRateIEs
 587                                         );
 588     if (byACKRate > (BYTE) wTxDataRate) {
 589         byACKRate = (BYTE) wTxDataRate;
 590     }
 591     byCCKBasicRate = VNTWIFIbyGetACKTxRate( RATE_11M,
 592                                             pSupportRateIEs,
 593                                             pExtSupportRateIEs
 594                                             );
 595     byOFDMBasicRate = VNTWIFIbyGetACKTxRate(RATE_54M,
 596                                             pSupportRateIEs,
 597                                             pExtSupportRateIEs
 598                                             );
 599     *pwTxDataRate = wTxDataRate;
 600     *pbyACKRate = byACKRate;
 601     *pbyCCKBasicRate = byCCKBasicRate;
 602     *pbyOFDMBasicRate = byOFDMBasicRate;
 603     return;
 604 }
 605
 606 BYTE
 607 VNTWIFIbyGetKeyCypher(
 608     IN PVOID    pMgmtHandle,
 609     IN BOOL     bGroupKey
 610     )
 611 {
 612     PSMgmtObject    pMgmt = (PSMgmtObject)pMgmtHandle;
 613
 614     if (bGroupKey == TRUE) {
 615         return (pMgmt->byCSSGK);
 616     } else {
 617         return (pMgmt->byCSSPK);
 618     }
 619 }
 620
 621
 622 /*
 623 BOOL
 624 VNTWIFIbInit(
 625     IN PVOID    pAdapterHandler,
 626     OUT PVOID   *pMgmtHandler
 627     )
 628 {
 629
 630     PSMgmtObject        pMgmt = NULL;
 631     UINT                ii;
 632
 633
 634     pMgmt = (PSMgmtObject)kmalloc(sizeof(SMgmtObject), (int)GFP_ATOMIC);
 635     if (pMgmt == NULL) {
 636         *pMgmtHandler = NULL;
 637         return FALSE;
 638     }
 639
 640     memset(pMgmt, 0, sizeof(SMgmtObject));
 641     pMgmt->pAdapter = (PVOID) pAdapterHandler;
 642
 643     // should initial MAC address abyMACAddr
 644     for(ii=0;ii<WLAN_BSSID_LEN;ii++) {
 645         pMgmt->abyDesireBSSID[ii] = 0xFF;
 646     }
 647     pMgmt->pbyPSPacketPool = &pMgmt->byPSPacketPool[0];
 648     pMgmt->pbyMgmtPacketPool = &pMgmt->byMgmtPacketPool[0];
 649     pMgmt->byCSSPK = KEY_CTL_NONE;
 650     pMgmt->byCSSGK = KEY_CTL_NONE;
 651     pMgmt->wIBSSBeaconPeriod = DEFAULT_IBSS_BI;
 652
 653     pMgmt->cbFreeCmdQueue = CMD_Q_SIZE;
 654     pMgmt->uCmdDequeueIdx = 0;
 655     pMgmt->uCmdEnqueueIdx = 0;
 656     pMgmt->eCommandState = WLAN_CMD_STATE_IDLE;
 657     pMgmt->bCmdStop = FALSE;
 658     pMgmt->bCmdRunning = FALSE;
 659
 660     *pMgmtHandler = pMgmt;
 661     return TRUE;
 662 }
 663 */
 664
 665
 666
 667 BOOL
 668 VNTWIFIbSetPMKIDCache (
 669     IN PVOID pMgmtObject,
 670     IN ULONG ulCount,
 671     IN PVOID pPMKIDInfo
 672     )
 673 {
 674     PSMgmtObject    pMgmt = (PSMgmtObject) pMgmtObject;
 675
 676     if (ulCount > MAX_PMKID_CACHE) {
 677         return (FALSE);
 678     }
 679     pMgmt->gsPMKIDCache.BSSIDInfoCount = ulCount;
 680     MEMvCopy(pMgmt->gsPMKIDCache.BSSIDInfo, pPMKIDInfo, (ulCount*sizeof(PMKIDInfo)));
 681     return (TRUE);
 682 }
 683
 684
 685
 686 WORD
 687 VNTWIFIwGetMaxSupportRate(
 688     IN PVOID pMgmtObject
 689     )
 690 {
 691     WORD wRate = RATE_54M;
 692     PSMgmtObject    pMgmt = (PSMgmtObject) pMgmtObject;
 693
 694     for(wRate = RATE_54M; wRate > RATE_1M; wRate--) {
 695         if (BITbIsBitOn(pMgmt->sNodeDBTable[0].wSuppRate, (1<<wRate))) {
 696             return (wRate);
 697         }
 698     }
 699     if (pMgmt->eCurrentPHYMode == PHY_TYPE_11A) {
 700         return (RATE_6M);
 701     } else {
 702         return (RATE_1M);
 703     }
 704 }
 705
 706
 707 VOID
 708 VNTWIFIvSet11h (
 709     IN PVOID pMgmtObject,
 710     IN BOOL  b11hEnable
 711     )
 712 {
 713     PSMgmtObject    pMgmt = (PSMgmtObject) pMgmtObject;
 714
 715     pMgmt->b11hEnable = b11hEnable;
 716 }
 717
 718 BOOL
 719 VNTWIFIbMeasureReport(
 720     IN PVOID pMgmtObject,
 721     IN BOOL  bEndOfReport,
 722     IN PVOID pvMeasureEID,
 723     IN BYTE  byReportMode,
 724     IN BYTE  byBasicMap,
 725     IN BYTE  byCCAFraction,
 726     IN PBYTE pbyRPIs
 727     )
 728 {
 729     PSMgmtObject    pMgmt = (PSMgmtObject) pMgmtObject;
 730     PBYTE           pbyCurrentEID = (PBYTE) (pMgmt->pCurrMeasureEIDRep);
 731
 732     //spin_lock_irq(&pDevice->lock);
 733     if ((pvMeasureEID != NULL) &&
 734         (pMgmt->uLengthOfRepEIDs < (WLAN_A3FR_MAXLEN - sizeof(MEASEURE_REP) - sizeof(WLAN_80211HDR_A3) - 3))
 735         ) {
 736         pMgmt->pCurrMeasureEIDRep->byElementID = WLAN_EID_MEASURE_REP;
 737         pMgmt->pCurrMeasureEIDRep->len = 3;
 738         pMgmt->pCurrMeasureEIDRep->byToken = ((PWLAN_IE_MEASURE_REQ) pvMeasureEID)->byToken;
 739         pMgmt->pCurrMeasureEIDRep->byMode = byReportMode;
 740         pMgmt->pCurrMeasureEIDRep->byType = ((PWLAN_IE_MEASURE_REQ) pvMeasureEID)->byType;
 741         switch (pMgmt->pCurrMeasureEIDRep->byType) {
 742             case MEASURE_TYPE_BASIC :
 743                 pMgmt->pCurrMeasureEIDRep->len += sizeof(MEASEURE_REP_BASIC);
 744                 MEMvCopy(   &(pMgmt->pCurrMeasureEIDRep->sRep.sBasic),
 745                             &(((PWLAN_IE_MEASURE_REQ) pvMeasureEID)->sReq),
 746                             sizeof(MEASEURE_REQ));
 747                 pMgmt->pCurrMeasureEIDRep->sRep.sBasic.byMap = byBasicMap;
 748                 break;
 749             case MEASURE_TYPE_CCA :
 750                 pMgmt->pCurrMeasureEIDRep->len += sizeof(MEASEURE_REP_CCA);
 751                 MEMvCopy(   &(pMgmt->pCurrMeasureEIDRep->sRep.sCCA),
 752                             &(((PWLAN_IE_MEASURE_REQ) pvMeasureEID)->sReq),
 753                             sizeof(MEASEURE_REQ));
 754                 pMgmt->pCurrMeasureEIDRep->sRep.sCCA.byCCABusyFraction = byCCAFraction;
 755                 break;
 756             case MEASURE_TYPE_RPI :
 757                 pMgmt->pCurrMeasureEIDRep->len += sizeof(MEASEURE_REP_RPI);
 758                 MEMvCopy(   &(pMgmt->pCurrMeasureEIDRep->sRep.sRPI),
 759                             &(((PWLAN_IE_MEASURE_REQ) pvMeasureEID)->sReq),
 760                             sizeof(MEASEURE_REQ));
 761                 MEMvCopy(pMgmt->pCurrMeasureEIDRep->sRep.sRPI.abyRPIdensity, pbyRPIs, 8);
 762                 break;
 763             default :
 764                 break;
 765         }
 766         pbyCurrentEID += (2 + pMgmt->pCurrMeasureEIDRep->len);
 767         pMgmt->uLengthOfRepEIDs += (2 + pMgmt->pCurrMeasureEIDRep->len);
 768         pMgmt->pCurrMeasureEIDRep = (PWLAN_IE_MEASURE_REP) pbyCurrentEID;
 769     }
 770     if (bEndOfReport == TRUE) {
 771         IEEE11hbMSRRepTx(pMgmt);
 772     }
 773     //spin_unlock_irq(&pDevice->lock);
 774     return (TRUE);
 775 }
 776
 777
 778 BOOL
 779 VNTWIFIbChannelSwitch(
 780     IN PVOID pMgmtObject,
 781     IN BYTE  byNewChannel
 782     )
 783 {
 784     PSMgmtObject    pMgmt = (PSMgmtObject) pMgmtObject;
 785
 786     //spin_lock_irq(&pDevice->lock);
 787     pMgmt->uCurrChannel = byNewChannel;
 788     pMgmt->bSwitchChannel = FALSE;
 789     //spin_unlock_irq(&pDevice->lock);
 790     return TRUE;
 791 }
 792
 793 /*
 794 BOOL
 795 VNTWIFIbRadarPresent(
 796     IN PVOID pMgmtObject,
 797     IN BYTE  byChannel
 798     )
 799 {
 800     PSMgmtObject    pMgmt = (PSMgmtObject) pMgmtObject;
 801     if ((pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) &&
 802         (byChannel == (BYTE) pMgmt->uCurrChannel) &&
 803         (pMgmt->bSwitchChannel != TRUE) &&
 804         (pMgmt->b11hEnable == TRUE)) {
 805         if (IS_ETH_ADDRESS_EQUAL(pMgmt->abyIBSSDFSOwner, CARDpGetCurrentAddress(pMgmt->pAdapter))) {
 806             pMgmt->byNewChannel = CARDbyAutoChannelSelect(pMgmt->pAdapter,(BYTE) pMgmt->uCurrChannel);
 807             pMgmt->bSwitchChannel = TRUE;
 808         }
 809         BEACONbSendBeacon(pMgmt);
 810         CARDbChannelSwitch(pMgmt->pAdapter, 0, pMgmt->byNewChannel, 10);
 811     }
 812     return TRUE;
 813 }
 814 */
 815