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 BOOL 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     return(TRUE);
 621 }
 622
 623 BOOL CARDbIsOFDMinBasicRate(void *pDeviceHandler)
 624 {
 625 PSDevice    pDevice = (PSDevice) pDeviceHandler;
 626 int ii;
 627
 628     for (ii = RATE_54M; ii >= RATE_6M; ii --) {
 629         if ((pDevice->wBasicRate) & ((WORD)(1<<ii)))
 630             return TRUE;
 631     }
 632     return FALSE;
 633 }
 634
 635 BYTE CARDbyGetPktType(void *pDeviceHandler)
 636 {
 637     PSDevice    pDevice = (PSDevice) pDeviceHandler;
 638
 639     if (pDevice->byBBType == BB_TYPE_11A || pDevice->byBBType == BB_TYPE_11B) {
 640         return (BYTE)pDevice->byBBType;
 641     }
 642     else if (CARDbIsOFDMinBasicRate(pDevice)) {
 643         return PK_TYPE_11GA;
 644     }
 645     else {
 646         return PK_TYPE_11GB;
 647     }
 648 }
 649
 650
 651 /*
 652  * Description: Caculate TSF offset of two TSF input
 653  *              Get TSF Offset from RxBCN's TSF and local TSF
 654  *
 655  * Parameters:
 656  *  In:
 657  *      pDevice         - The adapter to be sync.
 658  *      qwTSF1          - Rx BCN's TSF
 659  *      qwTSF2          - Local TSF
 660  *  Out:
 661  *      none
 662  *
 663  * Return Value: TSF Offset value
 664  *
 665  */
 666 QWORD CARDqGetTSFOffset (BYTE byRxRate, QWORD qwTSF1, QWORD qwTSF2)
 667 {
 668     QWORD   qwTSFOffset;
 669     WORD    wRxBcnTSFOffst = 0;
 670
 671     HIDWORD(qwTSFOffset) = 0;
 672     LODWORD(qwTSFOffset) = 0;
 673
 674     wRxBcnTSFOffst = cwRXBCNTSFOff[byRxRate%MAX_RATE];
 675     (qwTSF2).u.dwLowDword += (DWORD)(wRxBcnTSFOffst);
 676     if ((qwTSF2).u.dwLowDword < (DWORD)(wRxBcnTSFOffst)) {
 677         (qwTSF2).u.dwHighDword++;
 678     }
 679     LODWORD(qwTSFOffset) = LODWORD(qwTSF1) - LODWORD(qwTSF2);
 680     if (LODWORD(qwTSF1) < LODWORD(qwTSF2)) {
 681         // if borrow needed
 682         HIDWORD(qwTSFOffset) = HIDWORD(qwTSF1) - HIDWORD(qwTSF2) - 1 ;
 683     }
 684     else {
 685         HIDWORD(qwTSFOffset) = HIDWORD(qwTSF1) - HIDWORD(qwTSF2);
 686     };
 687     return (qwTSFOffset);
 688 }
 689
 690
 691
 692 /*
 693  * Description: Sync. TSF counter to BSS
 694  *              Get TSF offset and write to HW
 695  *
 696  * Parameters:
 697  *  In:
 698  *      pDevice         - The adapter to be sync.
 699  *      qwBSSTimestamp  - Rx BCN's TSF
 700  *      qwLocalTSF      - Local TSF
 701  *  Out:
 702  *      none
 703  *
 704  * Return Value: none
 705  *
 706  */
 707 void CARDvAdjustTSF(void *pDeviceHandler, BYTE byRxRate,
 708                     QWORD qwBSSTimestamp, QWORD qwLocalTSF)
 709 {
 710
 711     PSDevice        pDevice = (PSDevice) pDeviceHandler;
 712     QWORD           qwTSFOffset;
 713     DWORD           dwTSFOffset1,dwTSFOffset2;
 714     BYTE            pbyData[8];
 715
 716     HIDWORD(qwTSFOffset) = 0;
 717     LODWORD(qwTSFOffset) = 0;
 718
 719     qwTSFOffset = CARDqGetTSFOffset(byRxRate, qwBSSTimestamp, qwLocalTSF);
 720     // adjust TSF
 721     // HW's TSF add TSF Offset reg
 722     dwTSFOffset1 = LODWORD(qwTSFOffset);
 723     dwTSFOffset2 = HIDWORD(qwTSFOffset);
 724
 725
 726     pbyData[0] = (BYTE)dwTSFOffset1;
 727     pbyData[1] = (BYTE)(dwTSFOffset1>>8);
 728     pbyData[2] = (BYTE)(dwTSFOffset1>>16);
 729     pbyData[3] = (BYTE)(dwTSFOffset1>>24);
 730     pbyData[4] = (BYTE)dwTSFOffset2;
 731     pbyData[5] = (BYTE)(dwTSFOffset2>>8);
 732     pbyData[6] = (BYTE)(dwTSFOffset2>>16);
 733     pbyData[7] = (BYTE)(dwTSFOffset2>>24);
 734
 735     CONTROLnsRequestOut(pDevice,
 736                         MESSAGE_TYPE_SET_TSFTBTT,
 737                         MESSAGE_REQUEST_TSF,
 738                         0,
 739                         8,
 740                         pbyData
 741                         );
 742
 743 }
 744 /*
 745  * Description: Read NIC TSF counter
 746  *              Get local TSF counter
 747  *
 748  * Parameters:
 749  *  In:
 750  *      pDevice         - The adapter to be read
 751  *  Out:
 752  *      qwCurrTSF       - Current TSF counter
 753  *
 754  * Return Value: TRUE if success; otherwise FALSE
 755  *
 756  */
 757 BOOL CARDbGetCurrentTSF(void *pDeviceHandler, PQWORD pqwCurrTSF)
 758 {
 759     PSDevice    pDevice = (PSDevice) pDeviceHandler;
 760
 761     LODWORD(*pqwCurrTSF) = LODWORD(pDevice->qwCurrTSF);
 762     HIDWORD(*pqwCurrTSF) = HIDWORD(pDevice->qwCurrTSF);
 763
 764     return(TRUE);
 765 }
 766
 767
 768 /*
 769  * Description: Clear NIC TSF counter
 770  *              Clear local TSF counter
 771  *
 772  * Parameters:
 773  *  In:
 774  *      pDevice         - The adapter to be read
 775  *
 776  * Return Value: TRUE if success; otherwise FALSE
 777  *
 778  */
 779 BOOL CARDbClearCurrentTSF(void *pDeviceHandler)
 780 {
 781     PSDevice    pDevice = (PSDevice) pDeviceHandler;
 782
 783     MACvRegBitsOn(pDevice,MAC_REG_TFTCTL,TFTCTL_TSFCNTRST);
 784
 785     LODWORD(pDevice->qwCurrTSF) = 0;
 786     HIDWORD(pDevice->qwCurrTSF) = 0;
 787
 788     return(TRUE);
 789 }
 790
 791 /*
 792  * Description: Read NIC TSF counter
 793  *              Get NEXTTBTT from adjusted TSF and Beacon Interval
 794  *
 795  * Parameters:
 796  *  In:
 797  *      qwTSF           - Current TSF counter
 798  *      wbeaconInterval - Beacon Interval
 799  *  Out:
 800  *      qwCurrTSF       - Current TSF counter
 801  *
 802  * Return Value: TSF value of next Beacon
 803  *
 804  */
 805 QWORD CARDqGetNextTBTT (QWORD qwTSF, WORD wBeaconInterval)
 806 {
 807
 808     unsigned int    uLowNextTBTT;
 809     unsigned int    uHighRemain, uLowRemain;
 810     unsigned int    uBeaconInterval;
 811
 812     uBeaconInterval = wBeaconInterval * 1024;
 813     // Next TBTT = ((local_current_TSF / beacon_interval) + 1 ) * beacon_interval
 814     uLowNextTBTT = (LODWORD(qwTSF) >> 10) << 10;
 815     uLowRemain = (uLowNextTBTT) % uBeaconInterval;
 816     uHighRemain = ((0x80000000 % uBeaconInterval)* 2 * HIDWORD(qwTSF))
 817                   % uBeaconInterval;
 818     uLowRemain = (uHighRemain + uLowRemain) % uBeaconInterval;
 819     uLowRemain = uBeaconInterval - uLowRemain;
 820
 821     // check if carry when add one beacon interval
 822     if ((~uLowNextTBTT) < uLowRemain)
 823         HIDWORD(qwTSF) ++ ;
 824
 825     LODWORD(qwTSF) = uLowNextTBTT + uLowRemain;
 826
 827     return (qwTSF);
 828 }
 829
 830
 831 /*
 832  * Description: Set NIC TSF counter for first Beacon time
 833  *              Get NEXTTBTT from adjusted TSF and Beacon Interval
 834  *
 835  * Parameters:
 836  *  In:
 837  *      dwIoBase        - IO Base
 838  *      wBeaconInterval - Beacon Interval
 839  *  Out:
 840  *      none
 841  *
 842  * Return Value: none
 843  *
 844  */
 845 void CARDvSetFirstNextTBTT(void *pDeviceHandler, WORD wBeaconInterval)
 846 {
 847
 848     PSDevice        pDevice = (PSDevice) pDeviceHandler;
 849     QWORD           qwNextTBTT;
 850     DWORD           dwLoTBTT,dwHiTBTT;
 851     BYTE            pbyData[8];
 852
 853     HIDWORD(qwNextTBTT) = 0;
 854     LODWORD(qwNextTBTT) = 0;
 855     CARDbClearCurrentTSF(pDevice);
 856     //CARDbGetCurrentTSF(pDevice, &qwNextTBTT); //Get Local TSF counter
 857     qwNextTBTT = CARDqGetNextTBTT(qwNextTBTT, wBeaconInterval);
 858     // Set NextTBTT
 859
 860     dwLoTBTT = LODWORD(qwNextTBTT);
 861     dwHiTBTT = HIDWORD(qwNextTBTT);
 862
 863     pbyData[0] = (BYTE)dwLoTBTT;
 864     pbyData[1] = (BYTE)(dwLoTBTT>>8);
 865     pbyData[2] = (BYTE)(dwLoTBTT>>16);
 866     pbyData[3] = (BYTE)(dwLoTBTT>>24);
 867     pbyData[4] = (BYTE)dwHiTBTT;
 868     pbyData[5] = (BYTE)(dwHiTBTT>>8);
 869     pbyData[6] = (BYTE)(dwHiTBTT>>16);
 870     pbyData[7] = (BYTE)(dwHiTBTT>>24);
 871
 872     CONTROLnsRequestOut(pDevice,
 873                         MESSAGE_TYPE_SET_TSFTBTT,
 874                         MESSAGE_REQUEST_TBTT,
 875                         0,
 876                         8,
 877                         pbyData
 878                         );
 879
 880     return;
 881 }
 882
 883
 884 /*
 885  * Description: Sync NIC TSF counter for Beacon time
 886  *              Get NEXTTBTT and write to HW
 887  *
 888  * Parameters:
 889  *  In:
 890  *      pDevice         - The adapter to be set
 891  *      qwTSF           - Current TSF counter
 892  *      wBeaconInterval - Beacon Interval
 893  *  Out:
 894  *      none
 895  *
 896  * Return Value: none
 897  *
 898  */
 899 void CARDvUpdateNextTBTT(void *pDeviceHandler, QWORD qwTSF,
 900                          WORD wBeaconInterval)
 901 {
 902     PSDevice        pDevice = (PSDevice) pDeviceHandler;
 903     DWORD           dwLoTBTT,dwHiTBTT;
 904     BYTE            pbyData[8];
 905
 906     qwTSF = CARDqGetNextTBTT(qwTSF, wBeaconInterval);
 907
 908     // Set NextTBTT
 909     dwLoTBTT = LODWORD(qwTSF);
 910     dwHiTBTT = HIDWORD(qwTSF);
 911
 912     pbyData[0] = (BYTE)dwLoTBTT;
 913     pbyData[1] = (BYTE)(dwLoTBTT>>8);
 914     pbyData[2] = (BYTE)(dwLoTBTT>>16);
 915     pbyData[3] = (BYTE)(dwLoTBTT>>24);
 916     pbyData[4] = (BYTE)dwHiTBTT;
 917     pbyData[5] = (BYTE)(dwHiTBTT>>8);
 918     pbyData[6] = (BYTE)(dwHiTBTT>>16);
 919     pbyData[7] = (BYTE)(dwHiTBTT>>24);
 920
 921     CONTROLnsRequestOut(pDevice,
 922                         MESSAGE_TYPE_SET_TSFTBTT,
 923                         MESSAGE_REQUEST_TBTT,
 924                         0,
 925                         8,
 926                         pbyData
 927                         );
 928
 929
 930     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Card:Update Next TBTT[%8xh:%8xh] \n",(int)HIDWORD(qwTSF), (int)LODWORD(qwTSF));
 931
 932     return;
 933 }
 934
 935 /*
 936  * Description: Turn off Radio power
 937  *
 938  * Parameters:
 939  *  In:
 940  *      pDevice         - The adapter to be turned off
 941  *  Out:
 942  *      none
 943  *
 944  * Return Value: TRUE if success; otherwise FALSE
 945  *
 946  */
 947 BOOL CARDbRadioPowerOff(void *pDeviceHandler)
 948 {
 949 PSDevice    pDevice = (PSDevice) pDeviceHandler;
 950 BOOL bResult = TRUE;
 951
 952     //if (pDevice->bRadioOff == TRUE)
 953     //    return TRUE;
 954
 955     pDevice->bRadioOff = TRUE;
 956
 957     switch (pDevice->byRFType) {
 958         case RF_AL2230:
 959         case RF_AL2230S:
 960         case RF_AIROHA7230:
 961         case RF_VT3226:     //RobertYu:20051111
 962         case RF_VT3226D0:
 963         case RF_VT3342A0:   //RobertYu:20060609
 964             MACvRegBitsOff(pDevice, MAC_REG_SOFTPWRCTL, (SOFTPWRCTL_SWPE2 | SOFTPWRCTL_SWPE3));
 965             break;
 966     }
 967
 968     MACvRegBitsOff(pDevice, MAC_REG_HOSTCR, HOSTCR_RXON);
 969
 970     BBvSetDeepSleep(pDevice);
 971
 972     return bResult;
 973 }
 974
 975
 976 /*
 977  * Description: Turn on Radio power
 978  *
 979  * Parameters:
 980  *  In:
 981  *      pDevice         - The adapter to be turned on
 982  *  Out:
 983  *      none
 984  *
 985  * Return Value: TRUE if success; otherwise FALSE
 986  *
 987  */
 988 BOOL CARDbRadioPowerOn(void *pDeviceHandler)
 989 {
 990 PSDevice    pDevice = (PSDevice) pDeviceHandler;
 991 BOOL bResult = TRUE;
 992
 993
 994     if ((pDevice->bHWRadioOff == TRUE) || (pDevice->bRadioControlOff == TRUE)) {
 995         return FALSE;
 996     }
 997
 998     //if (pDevice->bRadioOff == FALSE)
 999     //    return TRUE;
1000
1001     pDevice->bRadioOff = FALSE;
1002
1003     BBvExitDeepSleep(pDevice);
1004
1005     MACvRegBitsOn(pDevice, MAC_REG_HOSTCR, HOSTCR_RXON);
1006
1007     switch (pDevice->byRFType) {
1008         case RF_AL2230:
1009         case RF_AL2230S:
1010         case RF_AIROHA7230:
1011         case RF_VT3226:     //RobertYu:20051111
1012         case RF_VT3226D0:
1013         case RF_VT3342A0:   //RobertYu:20060609
1014             MACvRegBitsOn(pDevice, MAC_REG_SOFTPWRCTL, (SOFTPWRCTL_SWPE2 | SOFTPWRCTL_SWPE3));
1015             break;
1016     }
1017
1018     return bResult;
1019 }
1020
1021 void CARDvSetBSSMode(void *pDeviceHandler)
1022 {
1023     PSDevice    pDevice = (PSDevice) pDeviceHandler;
1024     // Set BB and packet type at the same time.//{{RobertYu:20050222, AL7230 have two TX PA output, only connet to b/g now
1025     // so in 11a mode need to set the MAC Reg0x4C to 11b/g mode to turn on PA
1026     if( (pDevice->byRFType == RF_AIROHA7230 ) && (pDevice->byBBType == BB_TYPE_11A) )
1027     {
1028         MACvSetBBType(pDevice, BB_TYPE_11G);
1029     }
1030     else
1031     {
1032         MACvSetBBType(pDevice, pDevice->byBBType);
1033     }
1034     pDevice->byPacketType = CARDbyGetPktType(pDevice);
1035
1036     if (pDevice->byBBType == BB_TYPE_11A) {
1037         ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0x88, 0x03);
1038     } else if (pDevice->byBBType == BB_TYPE_11B) {
1039         ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0x88, 0x02);
1040     } else if (pDevice->byBBType == BB_TYPE_11G) {
1041         ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0x88, 0x08);
1042     }
1043
1044     vUpdateIFS(pDevice);
1045     CARDvSetRSPINF(pDevice, (BYTE)pDevice->byBBType);
1046
1047     if ( pDevice->byBBType == BB_TYPE_11A ) {
1048         //request by Jack 2005-04-26
1049         if (pDevice->byRFType == RF_AIROHA7230) {
1050             pDevice->abyBBVGA[0] = 0x20;
1051             ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xE7, pDevice->abyBBVGA[0]);
1052         }
1053         pDevice->abyBBVGA[2] = 0x10;
1054         pDevice->abyBBVGA[3] = 0x10;
1055     } else {
1056         //request by Jack 2005-04-26
1057         if (pDevice->byRFType == RF_AIROHA7230) {
1058             pDevice->abyBBVGA[0] = 0x1C;
1059             ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xE7, pDevice->abyBBVGA[0]);
1060         }
1061         pDevice->abyBBVGA[2] = 0x0;
1062         pDevice->abyBBVGA[3] = 0x0;
1063     }
1064 }
1065
1066 /*
1067  *
1068  * Description:
1069  *    Do Channel Switch defined in 802.11h
1070  *
1071  * Parameters:
1072  *  In:
1073  *      hDeviceContext - device structure point
1074  *  Out:
1075  *      none
1076  *
1077  * Return Value: none.
1078  *
1079 -*/
1080 BOOL
1081 CARDbChannelSwitch (
1082      void *pDeviceHandler,
1083      BYTE             byMode,
1084      BYTE             byNewChannel,
1085      BYTE             byCount
1086     )
1087 {
1088     PSDevice    pDevice = (PSDevice) pDeviceHandler;
1089     BOOL        bResult = TRUE;
1090
1091     if (byCount == 0) {
1092         pDevice->sMgmtObj.uCurrChannel = byNewChannel;
1093         bResult = CARDbSetMediaChannel(pDevice, byNewChannel);
1094
1095         return bResult;
1096     }
1097     pDevice->byChannelSwitchCount = byCount;
1098     pDevice->byNewChannel = byNewChannel;
1099     pDevice->bChannelSwitch = TRUE;
1100
1101     if (byMode == 1) {
1102         //bResult=CARDbStopTxPacket(pDevice, PKT_TYPE_802_11_ALL);
1103         pDevice->bStopDataPkt = TRUE;
1104     }
1105         return bResult;
1106 }
1107
1108
1109
1110
1111
1112