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