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