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