drivers/staging/vt6656/card.c

   1 /*
   2  * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
   3  * All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * File: card.c
  20  * Purpose: Provide functions to setup NIC operation mode
  21  * Functions:
  22  *      s_vSafeResetTx - Rest Tx
  23  *      CARDvSetRSPINF - Set RSPINF
  24  *      vUpdateIFS - Update slotTime,SIFS,DIFS, and EIFS
  25  *      CARDvUpdateBasicTopRate - Update BasicTopRate
  26  *      CARDbAddBasicRate - Add to BasicRateSet
  27  *      CARDbSetBasicRate - Set Basic Tx Rate
  28  *      CARDbIsOFDMinBasicRate - Check if any OFDM rate is in BasicRateSet
  29  *      CARDvSetLoopbackMode - Set Loopback mode
  30  *      CARDbSoftwareReset - Sortware reset NIC
  31  *      CARDqGetTSFOffset - Calculate TSFOffset
  32  *      CARDbGetCurrentTSF - Read Current NIC TSF counter
  33  *      CARDqGetNextTBTT - Calculate Next Beacon TSF counter
  34  *      CARDvSetFirstNextTBTT - Set NIC Beacon time
  35  *      CARDvUpdateNextTBTT - Sync. NIC Beacon time
  36  *      CARDbRadioPowerOff - Turn Off NIC Radio Power
  37  *      CARDbRadioPowerOn - Turn On NIC Radio Power
  38  *      CARDbSetWEPMode - Set NIC Wep mode
  39  *      CARDbSetTxPower - Set NIC tx power
  40  *
  41  * Revision History:
  42  *      06-10-2003 Bryan YC Fan:  Re-write codes to support VT3253 spec.
  43  *      08-26-2003 Kyle Hsu:      Modify the definition 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 "power.h"
  55 #include "key.h"
  56 #include "rc4.h"
  57 #include "country.h"
  58 #include "datarate.h"
  59 #include "rndis.h"
  60 #include "control.h"
  61
  62 /*---------------------  Static Definitions -------------------------*/
  63
  64 //static int          msglevel                =MSG_LEVEL_DEBUG;
  65 static int          msglevel                =MSG_LEVEL_INFO;
  66
  67
  68 /*---------------------  Static Definitions -------------------------*/
  69
  70 /*---------------------  Static Classes  ----------------------------*/
  71
  72 /*---------------------  Static Variables  --------------------------*/
  73 //const WORD cwRXBCNTSFOff[MAX_RATE] =
  74 //{17, 34, 96, 192, 34, 23, 17, 11, 8, 5, 4, 3};
  75
  76 const WORD cwRXBCNTSFOff[MAX_RATE] =
  77 {192, 96, 34, 17, 34, 23, 17, 11, 8, 5, 4, 3};
  78
  79 /*---------------------  Static Functions  --------------------------*/
  80
  81 /*---------------------  Export Variables  --------------------------*/
  82
  83 /*---------------------  Export Functions  --------------------------*/
  84 /*
  85  * Description: Set NIC media channel
  86  *
  87  * Parameters:
  88  *  In:
  89  *      pDevice             - The adapter to be set
  90  *      uConnectionChannel  - Channel to be set
  91  *  Out:
  92  *      none
  93  */
  94 void CARDbSetMediaChannel(void *pDeviceHandler, unsigned int uConnectionChannel)
  95 {
  96 PSDevice            pDevice = (PSDevice) pDeviceHandler;
  97
  98     if (pDevice->byBBType == BB_TYPE_11A) { // 15 ~ 38
  99         if ((uConnectionChannel < (CB_MAX_CHANNEL_24G+1)) || (uConnectionChannel > CB_MAX_CHANNEL))
 100             uConnectionChannel = (CB_MAX_CHANNEL_24G+1);
 101     } else {
 102         if ((uConnectionChannel > CB_MAX_CHANNEL_24G) || (uConnectionChannel == 0)) // 1 ~ 14
 103             uConnectionChannel = 1;
 104     }
 105
 106     // clear NAV
 107     MACvRegBitsOn(pDevice, MAC_REG_MACCR, MACCR_CLRNAV);
 108
 109     // Set Channel[7] = 0 to tell H/W channel is changing now.
 110     MACvRegBitsOff(pDevice, MAC_REG_CHANNEL, 0x80);
 111
 112     //if (pMgmt->uCurrChannel == uConnectionChannel)
 113     //    return bResult;
 114
 115     CONTROLnsRequestOut(pDevice,
 116                         MESSAGE_TYPE_SELECT_CHANNLE,
 117                         (WORD) uConnectionChannel,
 118                         0,
 119                         0,
 120                         NULL
 121                         );
 122
 123     //{{ RobertYu: 20041202
 124     //// TX_PE will reserve 3 us for MAX2829 A mode only, it is for better TX throughput
 125
 126     if (pDevice->byBBType == BB_TYPE_11A) {
 127         pDevice->byCurPwr = 0xFF;
 128         RFbRawSetPower(pDevice, pDevice->abyOFDMAPwrTbl[uConnectionChannel-15], RATE_54M);
 129     } else if (pDevice->byBBType == BB_TYPE_11G) {
 130         pDevice->byCurPwr = 0xFF;
 131         RFbRawSetPower(pDevice, pDevice->abyOFDMPwrTbl[uConnectionChannel-1], RATE_54M);
 132     } else {
 133         pDevice->byCurPwr = 0xFF;
 134         RFbRawSetPower(pDevice, pDevice->abyCCKPwrTbl[uConnectionChannel-1], RATE_1M);
 135     }
 136     ControlvWriteByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_CHANNEL,(BYTE)(uConnectionChannel|0x80));
 137 }
 138
 139 /*
 140  * Description: Get CCK mode basic rate
 141  *
 142  * Parameters:
 143  *  In:
 144  *      pDevice             - The adapter to be set
 145  *      wRateIdx            - Receiving data rate
 146  *  Out:
 147  *      none
 148  *
 149  * Return Value: response Control frame rate
 150  *
 151  */
 152 static WORD swGetCCKControlRate(void *pDeviceHandler, WORD wRateIdx)
 153 {
 154     PSDevice    pDevice = (PSDevice) pDeviceHandler;
 155     unsigned int ui = (unsigned int)wRateIdx;
 156     while (ui > RATE_1M) {
 157         if (pDevice->wBasicRate & ((WORD)1 << ui)) {
 158             return (WORD)ui;
 159         }
 160         ui --;
 161     }
 162     return (WORD)RATE_1M;
 163 }
 164
 165 /*
 166  * Description: Get OFDM mode basic rate
 167  *
 168  * Parameters:
 169  *  In:
 170  *      pDevice             - The adapter to be set
 171  *      wRateIdx            - Receiving data rate
 172  *  Out:
 173  *      none
 174  *
 175  * Return Value: response Control frame rate
 176  *
 177  */
 178 static WORD swGetOFDMControlRate(void *pDeviceHandler, WORD wRateIdx)
 179 {
 180     PSDevice    pDevice = (PSDevice) pDeviceHandler;
 181     unsigned int ui = (unsigned int)wRateIdx;
 182
 183     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"BASIC RATE: %X\n", pDevice->wBasicRate);
 184
 185     if (!CARDbIsOFDMinBasicRate(pDevice)) {
 186         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"swGetOFDMControlRate:(NO OFDM) %d\n", wRateIdx);
 187         if (wRateIdx > RATE_24M)
 188             wRateIdx = RATE_24M;
 189         return wRateIdx;
 190     }
 191     while (ui > RATE_11M) {
 192         if (pDevice->wBasicRate & ((WORD)1 << ui)) {
 193             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"swGetOFDMControlRate : %d\n", ui);
 194             return (WORD)ui;
 195         }
 196         ui --;
 197     }
 198     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"swGetOFDMControlRate: 6M\n");
 199     return (WORD)RATE_24M;
 200 }
 201
 202 /*
 203  * Description: Calculate TxRate and RsvTime fields for RSPINF in OFDM mode.
 204  *
 205  * Parameters:
 206  *  In:
 207  *      wRate           - Tx Rate
 208  *      byPktType       - Tx Packet type
 209  *  Out:
 210  *      pbyTxRate       - pointer to RSPINF TxRate field
 211  *      pbyRsvTime      - pointer to RSPINF RsvTime field
 212  *
 213  * Return Value: none
 214  *
 215  */
 216 void
 217 CARDvCalculateOFDMRParameter (
 218       WORD wRate,
 219       BYTE byBBType,
 220      PBYTE pbyTxRate,
 221      PBYTE pbyRsvTime
 222     )
 223 {
 224     switch (wRate) {
 225     case RATE_6M :
 226         if (byBBType == BB_TYPE_11A) {//5GHZ
 227             *pbyTxRate = 0x9B;
 228             *pbyRsvTime = 24;
 229         }
 230         else {
 231             *pbyTxRate = 0x8B;
 232             *pbyRsvTime = 30;
 233         }
 234         break;
 235
 236     case RATE_9M :
 237         if (byBBType == BB_TYPE_11A) {//5GHZ
 238             *pbyTxRate = 0x9F;
 239             *pbyRsvTime = 16;
 240         }
 241         else {
 242             *pbyTxRate = 0x8F;
 243             *pbyRsvTime = 22;
 244         }
 245         break;
 246
 247    case RATE_12M :
 248         if (byBBType == BB_TYPE_11A) {//5GHZ
 249             *pbyTxRate = 0x9A;
 250             *pbyRsvTime = 12;
 251         }
 252         else {
 253             *pbyTxRate = 0x8A;
 254             *pbyRsvTime = 18;
 255         }
 256         break;
 257
 258    case RATE_18M :
 259         if (byBBType == BB_TYPE_11A) {//5GHZ
 260             *pbyTxRate = 0x9E;
 261             *pbyRsvTime = 8;
 262         }
 263         else {
 264             *pbyTxRate = 0x8E;
 265             *pbyRsvTime = 14;
 266         }
 267         break;
 268
 269     case RATE_36M :
 270         if (byBBType == BB_TYPE_11A) {//5GHZ
 271             *pbyTxRate = 0x9D;
 272             *pbyRsvTime = 4;
 273         }
 274         else {
 275             *pbyTxRate = 0x8D;
 276             *pbyRsvTime = 10;
 277         }
 278         break;
 279
 280     case RATE_48M :
 281         if (byBBType == BB_TYPE_11A) {//5GHZ
 282             *pbyTxRate = 0x98;
 283             *pbyRsvTime = 4;
 284         }
 285         else {
 286             *pbyTxRate = 0x88;
 287             *pbyRsvTime = 10;
 288         }
 289         break;
 290
 291     case RATE_54M :
 292         if (byBBType == BB_TYPE_11A) {//5GHZ
 293             *pbyTxRate = 0x9C;
 294             *pbyRsvTime = 4;
 295         }
 296         else {
 297             *pbyTxRate = 0x8C;
 298             *pbyRsvTime = 10;
 299         }
 300         break;
 301
 302     case RATE_24M :
 303     default :
 304         if (byBBType == BB_TYPE_11A) {//5GHZ
 305             *pbyTxRate = 0x99;
 306             *pbyRsvTime = 8;
 307         }
 308         else {
 309             *pbyTxRate = 0x89;
 310             *pbyRsvTime = 14;
 311         }
 312         break;
 313     }
 314 }
 315
 316 /*
 317  * Description: Set RSPINF
 318  *
 319  * Parameters:
 320  *  In:
 321  *      pDevice             - The adapter to be set
 322  *  Out:
 323  *      none
 324  *
 325  * Return Value: None.
 326  *
 327  */
 328 void CARDvSetRSPINF(void *pDeviceHandler, BYTE byBBType)
 329 {
 330     PSDevice    pDevice = (PSDevice) pDeviceHandler;
 331     BYTE    abyServ[4] = {0,0,0,0};             // For CCK
 332     BYTE    abySignal[4] = {0,0,0,0};
 333     WORD    awLen[4] = {0,0,0,0};
 334     BYTE    abyTxRate[9] = {0,0,0,0,0,0,0,0,0}; // For OFDM
 335     BYTE    abyRsvTime[9] = {0,0,0,0,0,0,0,0,0};
 336     BYTE    abyData[34];
 337     int     i;
 338
 339     //RSPINF_b_1
 340     BBvCalculateParameter(pDevice,
 341                          14,
 342                          swGetCCKControlRate(pDevice, RATE_1M),
 343                          PK_TYPE_11B,
 344                          &awLen[0],
 345                          &abyServ[0],
 346                          &abySignal[0]
 347     );
 348
 349     ///RSPINF_b_2
 350     BBvCalculateParameter(pDevice,
 351                          14,
 352                          swGetCCKControlRate(pDevice, RATE_2M),
 353                          PK_TYPE_11B,
 354                          &awLen[1],
 355                          &abyServ[1],
 356                          &abySignal[1]
 357     );
 358
 359     //RSPINF_b_5
 360     BBvCalculateParameter(pDevice,
 361                          14,
 362                          swGetCCKControlRate(pDevice, RATE_5M),
 363                          PK_TYPE_11B,
 364                          &awLen[2],
 365                          &abyServ[2],
 366                          &abySignal[2]
 367     );
 368
 369     //RSPINF_b_11
 370     BBvCalculateParameter(pDevice,
 371                          14,
 372                          swGetCCKControlRate(pDevice, RATE_11M),
 373                          PK_TYPE_11B,
 374                          &awLen[3],
 375                          &abyServ[3],
 376                          &abySignal[3]
 377     );
 378
 379     //RSPINF_a_6
 380     CARDvCalculateOFDMRParameter (RATE_6M,
 381                                  byBBType,
 382                                  &abyTxRate[0],
 383                                  &abyRsvTime[0]);
 384
 385     //RSPINF_a_9
 386     CARDvCalculateOFDMRParameter (RATE_9M,
 387                                  byBBType,
 388                                  &abyTxRate[1],
 389                                  &abyRsvTime[1]);
 390
 391     //RSPINF_a_12
 392     CARDvCalculateOFDMRParameter (RATE_12M,
 393                                  byBBType,
 394                                  &abyTxRate[2],
 395                                  &abyRsvTime[2]);
 396
 397     //RSPINF_a_18
 398     CARDvCalculateOFDMRParameter (RATE_18M,
 399                                  byBBType,
 400                                  &abyTxRate[3],
 401                                  &abyRsvTime[3]);
 402
 403     //RSPINF_a_24
 404     CARDvCalculateOFDMRParameter (RATE_24M,
 405                                  byBBType,
 406                                  &abyTxRate[4],
 407                                  &abyRsvTime[4]);
 408
 409     //RSPINF_a_36
 410     CARDvCalculateOFDMRParameter (swGetOFDMControlRate(pDevice, RATE_36M),
 411                                  byBBType,
 412                                  &abyTxRate[5],
 413                                  &abyRsvTime[5]);
 414
 415     //RSPINF_a_48
 416     CARDvCalculateOFDMRParameter (swGetOFDMControlRate(pDevice, RATE_48M),
 417                                  byBBType,
 418                                  &abyTxRate[6],
 419                                  &abyRsvTime[6]);
 420
 421     //RSPINF_a_54
 422     CARDvCalculateOFDMRParameter (swGetOFDMControlRate(pDevice, RATE_54M),
 423                                  byBBType,
 424                                  &abyTxRate[7],
 425                                  &abyRsvTime[7]);
 426
 427     //RSPINF_a_72
 428     CARDvCalculateOFDMRParameter (swGetOFDMControlRate(pDevice, RATE_54M),
 429                                  byBBType,
 430                                  &abyTxRate[8],
 431                                  &abyRsvTime[8]);
 432
 433     abyData[0] = (BYTE)(awLen[0]&0xFF);
 434     abyData[1] = (BYTE)(awLen[0]>>8);
 435     abyData[2] = abySignal[0];
 436     abyData[3] = abyServ[0];
 437
 438     abyData[4] = (BYTE)(awLen[1]&0xFF);
 439     abyData[5] = (BYTE)(awLen[1]>>8);
 440     abyData[6] = abySignal[1];
 441     abyData[7] = abyServ[1];
 442
 443     abyData[8] = (BYTE)(awLen[2]&0xFF);
 444     abyData[9] = (BYTE)(awLen[2]>>8);
 445     abyData[10] = abySignal[2];
 446     abyData[11] = abyServ[2];
 447
 448     abyData[12] = (BYTE)(awLen[3]&0xFF);
 449     abyData[13] = (BYTE)(awLen[3]>>8);
 450     abyData[14] = abySignal[3];
 451     abyData[15] = abyServ[3];
 452
 453     for (i = 0; i < 9; i++) {
 454         abyData[16+i*2] = abyTxRate[i];
 455         abyData[16+i*2+1] = abyRsvTime[i];
 456     }
 457
 458     CONTROLnsRequestOut(pDevice,
 459                         MESSAGE_TYPE_WRITE,
 460                         MAC_REG_RSPINF_B_1,
 461                         MESSAGE_REQUEST_MACREG,
 462                         34,
 463                         &abyData[0]);
 464
 465 }
 466
 467 /*
 468  * Description: Update IFS
 469  *
 470  * Parameters:
 471  *  In:
 472  *      pDevice             - The adapter to be set
 473  *  Out:
 474  *      none
 475  *
 476  * Return Value: None.
 477  *
 478  */
 479 void vUpdateIFS(void *pDeviceHandler)
 480 {
 481     PSDevice    pDevice = (PSDevice) pDeviceHandler;
 482     //Set SIFS, DIFS, EIFS, SlotTime, CwMin
 483     BYTE byMaxMin = 0;
 484     BYTE byData[4];
 485
 486     if (pDevice->byPacketType==PK_TYPE_11A) {//0000 0000 0000 0000,11a
 487         pDevice->uSlot = C_SLOT_SHORT;
 488         pDevice->uSIFS = C_SIFS_A;
 489         pDevice->uDIFS = C_SIFS_A + 2*C_SLOT_SHORT;
 490         pDevice->uCwMin = C_CWMIN_A;
 491         byMaxMin = 4;
 492     }
 493     else if (pDevice->byPacketType==PK_TYPE_11B) {//0000 0001 0000 0000,11b
 494         pDevice->uSlot = C_SLOT_LONG;
 495         pDevice->uSIFS = C_SIFS_BG;
 496         pDevice->uDIFS = C_SIFS_BG + 2*C_SLOT_LONG;
 497           pDevice->uCwMin = C_CWMIN_B;
 498         byMaxMin = 5;
 499     }
 500     else {// PK_TYPE_11GA & PK_TYPE_11GB
 501         BYTE byRate = 0;
 502         BOOL bOFDMRate = FALSE;
 503         unsigned int ii = 0;
 504         PWLAN_IE_SUPP_RATES pItemRates = NULL;
 505
 506         pDevice->uSIFS = C_SIFS_BG;
 507         if (pDevice->bShortSlotTime) {
 508             pDevice->uSlot = C_SLOT_SHORT;
 509         } else {
 510             pDevice->uSlot = C_SLOT_LONG;
 511         }
 512         pDevice->uDIFS = C_SIFS_BG + 2*pDevice->uSlot;
 513
 514         pItemRates = (PWLAN_IE_SUPP_RATES)pDevice->sMgmtObj.abyCurrSuppRates;
 515         for (ii = 0; ii < pItemRates->len; ii++) {
 516             byRate = (BYTE)(pItemRates->abyRates[ii]&0x7F);
 517             if (RATEwGetRateIdx(byRate) > RATE_11M) {
 518                 bOFDMRate = TRUE;
 519                 break;
 520             }
 521         }
 522         if (bOFDMRate == FALSE) {
 523             pItemRates = (PWLAN_IE_SUPP_RATES)pDevice->sMgmtObj.abyCurrExtSuppRates;
 524             for (ii = 0; ii < pItemRates->len; ii++) {
 525                 byRate = (BYTE)(pItemRates->abyRates[ii]&0x7F);
 526                 if (RATEwGetRateIdx(byRate) > RATE_11M) {
 527                     bOFDMRate = TRUE;
 528                     break;
 529                 }
 530             }
 531         }
 532         if (bOFDMRate == TRUE) {
 533             pDevice->uCwMin = C_CWMIN_A;
 534             byMaxMin = 4;
 535         } else {
 536             pDevice->uCwMin = C_CWMIN_B;
 537             byMaxMin = 5;
 538         }
 539     }
 540
 541     pDevice->uCwMax = C_CWMAX;
 542     pDevice->uEIFS = C_EIFS;
 543
 544     byData[0] = (BYTE)pDevice->uSIFS;
 545     byData[1] = (BYTE)pDevice->uDIFS;
 546     byData[2] = (BYTE)pDevice->uEIFS;
 547     byData[3] = (BYTE)pDevice->uSlot;
 548     CONTROLnsRequestOut(pDevice,
 549                         MESSAGE_TYPE_WRITE,
 550                         MAC_REG_SIFS,
 551                         MESSAGE_REQUEST_MACREG,
 552                         4,
 553                         &byData[0]);
 554
 555     byMaxMin |= 0xA0;//1010 1111,C_CWMAX = 1023
 556     CONTROLnsRequestOut(pDevice,
 557                         MESSAGE_TYPE_WRITE,
 558                         MAC_REG_CWMAXMIN0,
 559                         MESSAGE_REQUEST_MACREG,
 560                         1,
 561                         &byMaxMin);
 562 }
 563
 564 void CARDvUpdateBasicTopRate(void *pDeviceHandler)
 565 {
 566 PSDevice    pDevice = (PSDevice) pDeviceHandler;
 567 BYTE byTopOFDM = RATE_24M, byTopCCK = RATE_1M;
 568 BYTE ii;
 569
 570      //Determines the highest basic rate.
 571      for (ii = RATE_54M; ii >= RATE_6M; ii --) {
 572          if ( (pDevice->wBasicRate) & ((WORD)(1<<ii)) ) {
 573              byTopOFDM = ii;
 574              break;
 575          }
 576      }
 577      pDevice->byTopOFDMBasicRate = byTopOFDM;
 578
 579      for (ii = RATE_11M;; ii --) {
 580          if ( (pDevice->wBasicRate) & ((WORD)(1<<ii)) ) {
 581              byTopCCK = ii;
 582              break;
 583          }
 584          if (ii == RATE_1M)
 585             break;
 586      }
 587      pDevice->byTopCCKBasicRate = byTopCCK;
 588  }
 589
 590 /*
 591  * Description: Set NIC Tx Basic Rate
 592  *
 593  * Parameters:
 594  *  In:
 595  *      pDevice         - The adapter to be set
 596  *      wBasicRate      - Basic Rate to be set
 597  *  Out:
 598  *      none
 599  *
 600  * Return Value: TRUE if succeeded; FALSE if failed.
 601  *
 602  */
 603 void CARDbAddBasicRate(void *pDeviceHandler, WORD wRateIdx)
 604 {
 605 PSDevice    pDevice = (PSDevice) pDeviceHandler;
 606 WORD wRate = (WORD)(1<<wRateIdx);
 607
 608     pDevice->wBasicRate |= wRate;
 609
 610     //Determines the highest basic rate.
 611     CARDvUpdateBasicTopRate(pDevice);
 612 }
 613
 614 BOOL CARDbIsOFDMinBasicRate(void *pDeviceHandler)
 615 {
 616 PSDevice    pDevice = (PSDevice) pDeviceHandler;
 617 int ii;
 618
 619     for (ii = RATE_54M; ii >= RATE_6M; ii --) {
 620         if ((pDevice->wBasicRate) & ((WORD)(1<<ii)))
 621             return TRUE;
 622     }
 623     return FALSE;
 624 }
 625
 626 BYTE CARDbyGetPktType(void *pDeviceHandler)
 627 {
 628     PSDevice    pDevice = (PSDevice) pDeviceHandler;
 629
 630     if (pDevice->byBBType == BB_TYPE_11A || pDevice->byBBType == BB_TYPE_11B) {
 631         return (BYTE)pDevice->byBBType;
 632     }
 633     else if (CARDbIsOFDMinBasicRate(pDevice)) {
 634         return PK_TYPE_11GA;
 635     }
 636     else {
 637         return PK_TYPE_11GB;
 638     }
 639 }
 640
 641
 642 /*
 643  * Description: Calculate TSF offset of two TSF input
 644  *              Get TSF Offset from RxBCN's TSF and local TSF
 645  *
 646  * Parameters:
 647  *  In:
 648  *      pDevice         - The adapter to be sync.
 649  *      qwTSF1          - Rx BCN's TSF
 650  *      qwTSF2          - Local TSF
 651  *  Out:
 652  *      none
 653  *
 654  * Return Value: TSF Offset value
 655  *
 656  */
 657 QWORD CARDqGetTSFOffset (BYTE byRxRate, QWORD qwTSF1, QWORD qwTSF2)
 658 {
 659     QWORD   qwTSFOffset;
 660     WORD    wRxBcnTSFOffst = 0;
 661
 662     HIDWORD(qwTSFOffset) = 0;
 663     LODWORD(qwTSFOffset) = 0;
 664
 665     wRxBcnTSFOffst = cwRXBCNTSFOff[byRxRate%MAX_RATE];
 666     (qwTSF2).u.dwLowDword += (DWORD)(wRxBcnTSFOffst);
 667     if ((qwTSF2).u.dwLowDword < (DWORD)(wRxBcnTSFOffst)) {
 668         (qwTSF2).u.dwHighDword++;
 669     }
 670     LODWORD(qwTSFOffset) = LODWORD(qwTSF1) - LODWORD(qwTSF2);
 671     if (LODWORD(qwTSF1) < LODWORD(qwTSF2)) {
 672         // if borrow needed
 673         HIDWORD(qwTSFOffset) = HIDWORD(qwTSF1) - HIDWORD(qwTSF2) - 1 ;
 674     }
 675     else {
 676         HIDWORD(qwTSFOffset) = HIDWORD(qwTSF1) - HIDWORD(qwTSF2);
 677     };
 678     return (qwTSFOffset);
 679 }
 680
 681
 682
 683 /*
 684  * Description: Sync. TSF counter to BSS
 685  *              Get TSF offset and write to HW
 686  *
 687  * Parameters:
 688  *  In:
 689  *      pDevice         - The adapter to be sync.
 690  *      qwBSSTimestamp  - Rx BCN's TSF
 691  *      qwLocalTSF      - Local TSF
 692  *  Out:
 693  *      none
 694  *
 695  * Return Value: none
 696  *
 697  */
 698 void CARDvAdjustTSF(void *pDeviceHandler, BYTE byRxRate,
 699                     QWORD qwBSSTimestamp, QWORD qwLocalTSF)
 700 {
 701
 702     PSDevice        pDevice = (PSDevice) pDeviceHandler;
 703     QWORD           qwTSFOffset;
 704     DWORD           dwTSFOffset1,dwTSFOffset2;
 705     BYTE            pbyData[8];
 706
 707     HIDWORD(qwTSFOffset) = 0;
 708     LODWORD(qwTSFOffset) = 0;
 709
 710     qwTSFOffset = CARDqGetTSFOffset(byRxRate, qwBSSTimestamp, qwLocalTSF);
 711     // adjust TSF
 712     // HW's TSF add TSF Offset reg
 713     dwTSFOffset1 = LODWORD(qwTSFOffset);
 714     dwTSFOffset2 = HIDWORD(qwTSFOffset);
 715
 716
 717     pbyData[0] = (BYTE)dwTSFOffset1;
 718     pbyData[1] = (BYTE)(dwTSFOffset1>>8);
 719     pbyData[2] = (BYTE)(dwTSFOffset1>>16);
 720     pbyData[3] = (BYTE)(dwTSFOffset1>>24);
 721     pbyData[4] = (BYTE)dwTSFOffset2;
 722     pbyData[5] = (BYTE)(dwTSFOffset2>>8);
 723     pbyData[6] = (BYTE)(dwTSFOffset2>>16);
 724     pbyData[7] = (BYTE)(dwTSFOffset2>>24);
 725
 726     CONTROLnsRequestOut(pDevice,
 727                         MESSAGE_TYPE_SET_TSFTBTT,
 728                         MESSAGE_REQUEST_TSF,
 729                         0,
 730                         8,
 731                         pbyData
 732                         );
 733
 734 }
 735 /*
 736  * Description: Read NIC TSF counter
 737  *              Get local TSF counter
 738  *
 739  * Parameters:
 740  *  In:
 741  *      pDevice         - The adapter to be read
 742  *  Out:
 743  *      qwCurrTSF       - Current TSF counter
 744  *
 745  * Return Value: TRUE if success; otherwise FALSE
 746  *
 747  */
 748 BOOL CARDbGetCurrentTSF(void *pDeviceHandler, PQWORD pqwCurrTSF)
 749 {
 750     PSDevice    pDevice = (PSDevice) pDeviceHandler;
 751
 752     LODWORD(*pqwCurrTSF) = LODWORD(pDevice->qwCurrTSF);
 753     HIDWORD(*pqwCurrTSF) = HIDWORD(pDevice->qwCurrTSF);
 754
 755     return(TRUE);
 756 }
 757
 758
 759 /*
 760  * Description: Clear NIC TSF counter
 761  *              Clear local TSF counter
 762  *
 763  * Parameters:
 764  *  In:
 765  *      pDevice         - The adapter to be read
 766  *
 767  * Return Value: TRUE if success; otherwise FALSE
 768  *
 769  */
 770 BOOL CARDbClearCurrentTSF(void *pDeviceHandler)
 771 {
 772     PSDevice    pDevice = (PSDevice) pDeviceHandler;
 773
 774     MACvRegBitsOn(pDevice,MAC_REG_TFTCTL,TFTCTL_TSFCNTRST);
 775
 776     LODWORD(pDevice->qwCurrTSF) = 0;
 777     HIDWORD(pDevice->qwCurrTSF) = 0;
 778
 779     return(TRUE);
 780 }
 781
 782 /*
 783  * Description: Read NIC TSF counter
 784  *              Get NEXTTBTT from adjusted TSF and Beacon Interval
 785  *
 786  * Parameters:
 787  *  In:
 788  *      qwTSF           - Current TSF counter
 789  *      wbeaconInterval - Beacon Interval
 790  *  Out:
 791  *      qwCurrTSF       - Current TSF counter
 792  *
 793  * Return Value: TSF value of next Beacon
 794  *
 795  */
 796 QWORD CARDqGetNextTBTT (QWORD qwTSF, WORD wBeaconInterval)
 797 {
 798
 799     unsigned int    uLowNextTBTT;
 800     unsigned int    uHighRemain, uLowRemain;
 801     unsigned int    uBeaconInterval;
 802
 803     uBeaconInterval = wBeaconInterval * 1024;
 804     // Next TBTT = ((local_current_TSF / beacon_interval) + 1 ) * beacon_interval
 805     uLowNextTBTT = (LODWORD(qwTSF) >> 10) << 10;
 806     uLowRemain = (uLowNextTBTT) % uBeaconInterval;
 807     uHighRemain = ((0x80000000 % uBeaconInterval)* 2 * HIDWORD(qwTSF))
 808                   % uBeaconInterval;
 809     uLowRemain = (uHighRemain + uLowRemain) % uBeaconInterval;
 810     uLowRemain = uBeaconInterval - uLowRemain;
 811
 812     // check if carry when add one beacon interval
 813     if ((~uLowNextTBTT) < uLowRemain)
 814         HIDWORD(qwTSF) ++ ;
 815
 816     LODWORD(qwTSF) = uLowNextTBTT + uLowRemain;
 817
 818     return (qwTSF);
 819 }
 820
 821
 822 /*
 823  * Description: Set NIC TSF counter for first Beacon time
 824  *              Get NEXTTBTT from adjusted TSF and Beacon Interval
 825  *
 826  * Parameters:
 827  *  In:
 828  *      dwIoBase        - IO Base
 829  *      wBeaconInterval - Beacon Interval
 830  *  Out:
 831  *      none
 832  *
 833  * Return Value: none
 834  *
 835  */
 836 void CARDvSetFirstNextTBTT(void *pDeviceHandler, WORD wBeaconInterval)
 837 {
 838
 839     PSDevice        pDevice = (PSDevice) pDeviceHandler;
 840     QWORD           qwNextTBTT;
 841     DWORD           dwLoTBTT,dwHiTBTT;
 842     BYTE            pbyData[8];
 843
 844     HIDWORD(qwNextTBTT) = 0;
 845     LODWORD(qwNextTBTT) = 0;
 846     CARDbClearCurrentTSF(pDevice);
 847     //CARDbGetCurrentTSF(pDevice, &qwNextTBTT); //Get Local TSF counter
 848     qwNextTBTT = CARDqGetNextTBTT(qwNextTBTT, wBeaconInterval);
 849     // Set NextTBTT
 850
 851     dwLoTBTT = LODWORD(qwNextTBTT);
 852     dwHiTBTT = HIDWORD(qwNextTBTT);
 853
 854     pbyData[0] = (BYTE)dwLoTBTT;
 855     pbyData[1] = (BYTE)(dwLoTBTT>>8);
 856     pbyData[2] = (BYTE)(dwLoTBTT>>16);
 857     pbyData[3] = (BYTE)(dwLoTBTT>>24);
 858     pbyData[4] = (BYTE)dwHiTBTT;
 859     pbyData[5] = (BYTE)(dwHiTBTT>>8);
 860     pbyData[6] = (BYTE)(dwHiTBTT>>16);
 861     pbyData[7] = (BYTE)(dwHiTBTT>>24);
 862
 863     CONTROLnsRequestOut(pDevice,
 864                         MESSAGE_TYPE_SET_TSFTBTT,
 865                         MESSAGE_REQUEST_TBTT,
 866                         0,
 867                         8,
 868                         pbyData
 869                         );
 870
 871     return;
 872 }
 873
 874
 875 /*
 876  * Description: Sync NIC TSF counter for Beacon time
 877  *              Get NEXTTBTT and write to HW
 878  *
 879  * Parameters:
 880  *  In:
 881  *      pDevice         - The adapter to be set
 882  *      qwTSF           - Current TSF counter
 883  *      wBeaconInterval - Beacon Interval
 884  *  Out:
 885  *      none
 886  *
 887  * Return Value: none
 888  *
 889  */
 890 void CARDvUpdateNextTBTT(void *pDeviceHandler, QWORD qwTSF,
 891                          WORD wBeaconInterval)
 892 {
 893     PSDevice        pDevice = (PSDevice) pDeviceHandler;
 894     DWORD           dwLoTBTT,dwHiTBTT;
 895     BYTE            pbyData[8];
 896
 897     qwTSF = CARDqGetNextTBTT(qwTSF, wBeaconInterval);
 898
 899     // Set NextTBTT
 900     dwLoTBTT = LODWORD(qwTSF);
 901     dwHiTBTT = HIDWORD(qwTSF);
 902
 903     pbyData[0] = (BYTE)dwLoTBTT;
 904     pbyData[1] = (BYTE)(dwLoTBTT>>8);
 905     pbyData[2] = (BYTE)(dwLoTBTT>>16);
 906     pbyData[3] = (BYTE)(dwLoTBTT>>24);
 907     pbyData[4] = (BYTE)dwHiTBTT;
 908     pbyData[5] = (BYTE)(dwHiTBTT>>8);
 909     pbyData[6] = (BYTE)(dwHiTBTT>>16);
 910     pbyData[7] = (BYTE)(dwHiTBTT>>24);
 911
 912     CONTROLnsRequestOut(pDevice,
 913                         MESSAGE_TYPE_SET_TSFTBTT,
 914                         MESSAGE_REQUEST_TBTT,
 915                         0,
 916                         8,
 917                         pbyData
 918                         );
 919
 920
 921     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Card:Update Next TBTT[%8xh:%8xh] \n",(int)HIDWORD(qwTSF), (int)LODWORD(qwTSF));
 922
 923     return;
 924 }
 925
 926 /*
 927  * Description: Turn off Radio power
 928  *
 929  * Parameters:
 930  *  In:
 931  *      pDevice         - The adapter to be turned off
 932  *  Out:
 933  *      none
 934  *
 935  * Return Value: TRUE if success; otherwise FALSE
 936  *
 937  */
 938 BOOL CARDbRadioPowerOff(void *pDeviceHandler)
 939 {
 940 PSDevice    pDevice = (PSDevice) pDeviceHandler;
 941 BOOL bResult = TRUE;
 942
 943     //if (pDevice->bRadioOff == TRUE)
 944     //    return TRUE;
 945
 946     pDevice->bRadioOff = TRUE;
 947
 948     switch (pDevice->byRFType) {
 949         case RF_AL2230:
 950         case RF_AL2230S:
 951         case RF_AIROHA7230:
 952         case RF_VT3226:     //RobertYu:20051111
 953         case RF_VT3226D0:
 954         case RF_VT3342A0:   //RobertYu:20060609
 955             MACvRegBitsOff(pDevice, MAC_REG_SOFTPWRCTL, (SOFTPWRCTL_SWPE2 | SOFTPWRCTL_SWPE3));
 956             break;
 957     }
 958
 959     MACvRegBitsOff(pDevice, MAC_REG_HOSTCR, HOSTCR_RXON);
 960
 961     BBvSetDeepSleep(pDevice);
 962
 963     return bResult;
 964 }
 965
 966
 967 /*
 968  * Description: Turn on Radio power
 969  *
 970  * Parameters:
 971  *  In:
 972  *      pDevice         - The adapter to be turned on
 973  *  Out:
 974  *      none
 975  *
 976  * Return Value: TRUE if success; otherwise FALSE
 977  *
 978  */
 979 BOOL CARDbRadioPowerOn(void *pDeviceHandler)
 980 {
 981 PSDevice    pDevice = (PSDevice) pDeviceHandler;
 982 BOOL bResult = TRUE;
 983
 984
 985     if ((pDevice->bHWRadioOff == TRUE) || (pDevice->bRadioControlOff == TRUE)) {
 986         return FALSE;
 987     }
 988
 989     //if (pDevice->bRadioOff == FALSE)
 990     //    return TRUE;
 991
 992     pDevice->bRadioOff = FALSE;
 993
 994     BBvExitDeepSleep(pDevice);
 995
 996     MACvRegBitsOn(pDevice, MAC_REG_HOSTCR, HOSTCR_RXON);
 997
 998     switch (pDevice->byRFType) {
 999         case RF_AL2230:
1000         case RF_AL2230S:
1001         case RF_AIROHA7230:
1002         case RF_VT3226:     //RobertYu:20051111
1003         case RF_VT3226D0:
1004         case RF_VT3342A0:   //RobertYu:20060609
1005             MACvRegBitsOn(pDevice, MAC_REG_SOFTPWRCTL, (SOFTPWRCTL_SWPE2 | SOFTPWRCTL_SWPE3));
1006             break;
1007     }
1008
1009     return bResult;
1010 }
1011
1012 void CARDvSetBSSMode(void *pDeviceHandler)
1013 {
1014     PSDevice    pDevice = (PSDevice) pDeviceHandler;
1015     // Set BB and packet type at the same time.//{{RobertYu:20050222, AL7230 have two TX PA output, only connet to b/g now
1016     // so in 11a mode need to set the MAC Reg0x4C to 11b/g mode to turn on PA
1017     if( (pDevice->byRFType == RF_AIROHA7230 ) && (pDevice->byBBType == BB_TYPE_11A) )
1018     {
1019         MACvSetBBType(pDevice, BB_TYPE_11G);
1020     }
1021     else
1022     {
1023         MACvSetBBType(pDevice, pDevice->byBBType);
1024     }
1025     pDevice->byPacketType = CARDbyGetPktType(pDevice);
1026
1027     if (pDevice->byBBType == BB_TYPE_11A) {
1028         ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0x88, 0x03);
1029     } else if (pDevice->byBBType == BB_TYPE_11B) {
1030         ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0x88, 0x02);
1031     } else if (pDevice->byBBType == BB_TYPE_11G) {
1032         ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0x88, 0x08);
1033     }
1034
1035     vUpdateIFS(pDevice);
1036     CARDvSetRSPINF(pDevice, (BYTE)pDevice->byBBType);
1037
1038     if ( pDevice->byBBType == BB_TYPE_11A ) {
1039         //request by Jack 2005-04-26
1040         if (pDevice->byRFType == RF_AIROHA7230) {
1041             pDevice->abyBBVGA[0] = 0x20;
1042             ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xE7, pDevice->abyBBVGA[0]);
1043         }
1044         pDevice->abyBBVGA[2] = 0x10;
1045         pDevice->abyBBVGA[3] = 0x10;
1046     } else {
1047         //request by Jack 2005-04-26
1048         if (pDevice->byRFType == RF_AIROHA7230) {
1049             pDevice->abyBBVGA[0] = 0x1C;
1050             ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xE7, pDevice->abyBBVGA[0]);
1051         }
1052         pDevice->abyBBVGA[2] = 0x0;
1053         pDevice->abyBBVGA[3] = 0x0;
1054     }
1055 }
1056
1057 /*
1058  *
1059  * Description:
1060  *    Do Channel Switch defined in 802.11h
1061  *
1062  * Parameters:
1063  *  In:
1064  *      hDeviceContext - device structure point
1065  *  Out:
1066  *      none
1067  *
1068  * Return Value: none.
1069  *
1070 -*/
1071 BOOL
1072 CARDbChannelSwitch (
1073      void *pDeviceHandler,
1074      BYTE             byMode,
1075      BYTE             byNewChannel,
1076      BYTE             byCount
1077     )
1078 {
1079     PSDevice    pDevice = (PSDevice) pDeviceHandler;
1080     BOOL        bResult = TRUE;
1081
1082     if (byCount == 0) {
1083         pDevice->sMgmtObj.uCurrChannel = byNewChannel;
1084         CARDbSetMediaChannel(pDevice, byNewChannel);
1085
1086         return bResult;
1087     }
1088     pDevice->byChannelSwitchCount = byCount;
1089     pDevice->byNewChannel = byNewChannel;
1090     pDevice->bChannelSwitch = TRUE;
1091
1092     if (byMode == 1) {
1093         //bResult=CARDbStopTxPacket(pDevice, PKT_TYPE_802_11_ALL);
1094         pDevice->bStopDataPkt = TRUE;
1095     }
1096         return bResult;
1097 }
1098
1099
1100
1101
1102
1103