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
 466     CONTROLnsRequestOut(pDevice,
 467                         MESSAGE_TYPE_WRITE,
 468                         MAC_REG_RSPINF_B_1,
 469                         MESSAGE_REQUEST_MACREG,
 470                         34,
 471                         &abyData[0]);
 472
 473 }
 474
 475 /*
 476  * Description: Update IFS
 477  *
 478  * Parameters:
 479  *  In:
 480  *      pDevice             - The adapter to be set
 481  *  Out:
 482  *      none
 483  *
 484  * Return Value: None.
 485  *
 486  */
 487 void vUpdateIFS(void *pDeviceHandler)
 488 {
 489     PSDevice    pDevice = (PSDevice) pDeviceHandler;
 490     //Set SIFS, DIFS, EIFS, SlotTime, CwMin
 491     BYTE byMaxMin = 0;
 492     BYTE byData[4];
 493
 494     if (pDevice->byPacketType==PK_TYPE_11A) {//0000 0000 0000 0000,11a
 495         pDevice->uSlot = C_SLOT_SHORT;
 496         pDevice->uSIFS = C_SIFS_A;
 497         pDevice->uDIFS = C_SIFS_A + 2*C_SLOT_SHORT;
 498         pDevice->uCwMin = C_CWMIN_A;
 499         byMaxMin = 4;
 500     }
 501     else if (pDevice->byPacketType==PK_TYPE_11B) {//0000 0001 0000 0000,11b
 502         pDevice->uSlot = C_SLOT_LONG;
 503         pDevice->uSIFS = C_SIFS_BG;
 504         pDevice->uDIFS = C_SIFS_BG + 2*C_SLOT_LONG;
 505           pDevice->uCwMin = C_CWMIN_B;
 506         byMaxMin = 5;
 507     }
 508     else {// PK_TYPE_11GA & PK_TYPE_11GB
 509         BYTE byRate = 0;
 510         BOOL bOFDMRate = FALSE;
 511         unsigned int ii = 0;
 512         PWLAN_IE_SUPP_RATES pItemRates = NULL;
 513
 514         pDevice->uSIFS = C_SIFS_BG;
 515         if (pDevice->bShortSlotTime) {
 516             pDevice->uSlot = C_SLOT_SHORT;
 517         } else {
 518             pDevice->uSlot = C_SLOT_LONG;
 519         }
 520         pDevice->uDIFS = C_SIFS_BG + 2*pDevice->uSlot;
 521
 522         pItemRates = (PWLAN_IE_SUPP_RATES)pDevice->sMgmtObj.abyCurrSuppRates;
 523         for (ii = 0; ii < pItemRates->len; ii++) {
 524             byRate = (BYTE)(pItemRates->abyRates[ii]&0x7F);
 525             if (RATEwGetRateIdx(byRate) > RATE_11M) {
 526                 bOFDMRate = TRUE;
 527                 break;
 528             }
 529         }
 530         if (bOFDMRate == FALSE) {
 531             pItemRates = (PWLAN_IE_SUPP_RATES)pDevice->sMgmtObj.abyCurrExtSuppRates;
 532             for (ii = 0; ii < pItemRates->len; ii++) {
 533                 byRate = (BYTE)(pItemRates->abyRates[ii]&0x7F);
 534                 if (RATEwGetRateIdx(byRate) > RATE_11M) {
 535                     bOFDMRate = TRUE;
 536                     break;
 537                 }
 538             }
 539         }
 540         if (bOFDMRate == TRUE) {
 541             pDevice->uCwMin = C_CWMIN_A;
 542             byMaxMin = 4;
 543         } else {
 544             pDevice->uCwMin = C_CWMIN_B;
 545             byMaxMin = 5;
 546         }
 547     }
 548
 549     pDevice->uCwMax = C_CWMAX;
 550     pDevice->uEIFS = C_EIFS;
 551
 552     byData[0] = (BYTE)pDevice->uSIFS;
 553     byData[1] = (BYTE)pDevice->uDIFS;
 554     byData[2] = (BYTE)pDevice->uEIFS;
 555     byData[3] = (BYTE)pDevice->uSlot;
 556     CONTROLnsRequestOut(pDevice,
 557                         MESSAGE_TYPE_WRITE,
 558                         MAC_REG_SIFS,
 559                         MESSAGE_REQUEST_MACREG,
 560                         4,
 561                         &byData[0]);
 562
 563     byMaxMin |= 0xA0;//1010 1111,C_CWMAX = 1023
 564     CONTROLnsRequestOut(pDevice,
 565                         MESSAGE_TYPE_WRITE,
 566                         MAC_REG_CWMAXMIN0,
 567                         MESSAGE_REQUEST_MACREG,
 568                         1,
 569                         &byMaxMin);
 570 }
 571
 572 void CARDvUpdateBasicTopRate(void *pDeviceHandler)
 573 {
 574 PSDevice    pDevice = (PSDevice) pDeviceHandler;
 575 BYTE byTopOFDM = RATE_24M, byTopCCK = RATE_1M;
 576 BYTE ii;
 577
 578      //Determines the highest basic rate.
 579      for (ii = RATE_54M; ii >= RATE_6M; ii --) {
 580          if ( (pDevice->wBasicRate) & ((WORD)(1<<ii)) ) {
 581              byTopOFDM = ii;
 582              break;
 583          }
 584      }
 585      pDevice->byTopOFDMBasicRate = byTopOFDM;
 586
 587      for (ii = RATE_11M;; ii --) {
 588          if ( (pDevice->wBasicRate) & ((WORD)(1<<ii)) ) {
 589              byTopCCK = ii;
 590              break;
 591          }
 592          if (ii == RATE_1M)
 593             break;
 594      }
 595      pDevice->byTopCCKBasicRate = byTopCCK;
 596  }
 597
 598 /*
 599  * Description: Set NIC Tx Basic Rate
 600  *
 601  * Parameters:
 602  *  In:
 603  *      pDevice         - The adapter to be set
 604  *      wBasicRate      - Basic Rate to be set
 605  *  Out:
 606  *      none
 607  *
 608  * Return Value: TRUE if succeeded; FALSE if failed.
 609  *
 610  */
 611 BOOL CARDbAddBasicRate(void *pDeviceHandler, WORD wRateIdx)
 612 {
 613 PSDevice    pDevice = (PSDevice) pDeviceHandler;
 614 WORD wRate = (WORD)(1<<wRateIdx);
 615
 616     pDevice->wBasicRate |= wRate;
 617
 618     //Determines the highest basic rate.
 619     CARDvUpdateBasicTopRate(pDevice);
 620
 621     return(TRUE);
 622 }
 623
 624 BOOL CARDbIsOFDMinBasicRate(void *pDeviceHandler)
 625 {
 626 PSDevice    pDevice = (PSDevice) pDeviceHandler;
 627 int ii;
 628
 629     for (ii = RATE_54M; ii >= RATE_6M; ii --) {
 630         if ((pDevice->wBasicRate) & ((WORD)(1<<ii)))
 631             return TRUE;
 632     }
 633     return FALSE;
 634 }
 635
 636 BYTE CARDbyGetPktType(void *pDeviceHandler)
 637 {
 638     PSDevice    pDevice = (PSDevice) pDeviceHandler;
 639
 640     if (pDevice->byBBType == BB_TYPE_11A || pDevice->byBBType == BB_TYPE_11B) {
 641         return (BYTE)pDevice->byBBType;
 642     }
 643     else if (CARDbIsOFDMinBasicRate(pDevice)) {
 644         return PK_TYPE_11GA;
 645     }
 646     else {
 647         return PK_TYPE_11GB;
 648     }
 649 }
 650
 651
 652 /*
 653  * Description: Caculate TSF offset of two TSF input
 654  *              Get TSF Offset from RxBCN's TSF and local TSF
 655  *
 656  * Parameters:
 657  *  In:
 658  *      pDevice         - The adapter to be sync.
 659  *      qwTSF1          - Rx BCN's TSF
 660  *      qwTSF2          - Local TSF
 661  *  Out:
 662  *      none
 663  *
 664  * Return Value: TSF Offset value
 665  *
 666  */
 667 QWORD CARDqGetTSFOffset (BYTE byRxRate, QWORD qwTSF1, QWORD qwTSF2)
 668 {
 669     QWORD   qwTSFOffset;
 670     WORD    wRxBcnTSFOffst = 0;
 671
 672     HIDWORD(qwTSFOffset) = 0;
 673     LODWORD(qwTSFOffset) = 0;
 674
 675     wRxBcnTSFOffst = cwRXBCNTSFOff[byRxRate%MAX_RATE];
 676     (qwTSF2).u.dwLowDword += (DWORD)(wRxBcnTSFOffst);
 677     if ((qwTSF2).u.dwLowDword < (DWORD)(wRxBcnTSFOffst)) {
 678         (qwTSF2).u.dwHighDword++;
 679     }
 680     LODWORD(qwTSFOffset) = LODWORD(qwTSF1) - LODWORD(qwTSF2);
 681     if (LODWORD(qwTSF1) < LODWORD(qwTSF2)) {
 682         // if borrow needed
 683         HIDWORD(qwTSFOffset) = HIDWORD(qwTSF1) - HIDWORD(qwTSF2) - 1 ;
 684     }
 685     else {
 686         HIDWORD(qwTSFOffset) = HIDWORD(qwTSF1) - HIDWORD(qwTSF2);
 687     };
 688     return (qwTSFOffset);
 689 }
 690
 691
 692
 693 /*
 694  * Description: Sync. TSF counter to BSS
 695  *              Get TSF offset and write to HW
 696  *
 697  * Parameters:
 698  *  In:
 699  *      pDevice         - The adapter to be sync.
 700  *      qwBSSTimestamp  - Rx BCN's TSF
 701  *      qwLocalTSF      - Local TSF
 702  *  Out:
 703  *      none
 704  *
 705  * Return Value: none
 706  *
 707  */
 708 void CARDvAdjustTSF(void *pDeviceHandler, BYTE byRxRate,
 709                     QWORD qwBSSTimestamp, QWORD qwLocalTSF)
 710 {
 711
 712     PSDevice        pDevice = (PSDevice) pDeviceHandler;
 713     QWORD           qwTSFOffset;
 714     DWORD           dwTSFOffset1,dwTSFOffset2;
 715     BYTE            pbyData[8];
 716
 717     HIDWORD(qwTSFOffset) = 0;
 718     LODWORD(qwTSFOffset) = 0;
 719
 720     qwTSFOffset = CARDqGetTSFOffset(byRxRate, qwBSSTimestamp, qwLocalTSF);
 721     // adjust TSF
 722     // HW's TSF add TSF Offset reg
 723     dwTSFOffset1 = LODWORD(qwTSFOffset);
 724     dwTSFOffset2 = HIDWORD(qwTSFOffset);
 725
 726
 727     pbyData[0] = (BYTE)dwTSFOffset1;
 728     pbyData[1] = (BYTE)(dwTSFOffset1>>8);
 729     pbyData[2] = (BYTE)(dwTSFOffset1>>16);
 730     pbyData[3] = (BYTE)(dwTSFOffset1>>24);
 731     pbyData[4] = (BYTE)dwTSFOffset2;
 732     pbyData[5] = (BYTE)(dwTSFOffset2>>8);
 733     pbyData[6] = (BYTE)(dwTSFOffset2>>16);
 734     pbyData[7] = (BYTE)(dwTSFOffset2>>24);
 735
 736     CONTROLnsRequestOut(pDevice,
 737                         MESSAGE_TYPE_SET_TSFTBTT,
 738                         MESSAGE_REQUEST_TSF,
 739                         0,
 740                         8,
 741                         pbyData
 742                         );
 743
 744 }
 745 /*
 746  * Description: Read NIC TSF counter
 747  *              Get local TSF counter
 748  *
 749  * Parameters:
 750  *  In:
 751  *      pDevice         - The adapter to be read
 752  *  Out:
 753  *      qwCurrTSF       - Current TSF counter
 754  *
 755  * Return Value: TRUE if success; otherwise FALSE
 756  *
 757  */
 758 BOOL CARDbGetCurrentTSF(void *pDeviceHandler, PQWORD pqwCurrTSF)
 759 {
 760     PSDevice    pDevice = (PSDevice) pDeviceHandler;
 761
 762     LODWORD(*pqwCurrTSF) = LODWORD(pDevice->qwCurrTSF);
 763     HIDWORD(*pqwCurrTSF) = HIDWORD(pDevice->qwCurrTSF);
 764
 765     return(TRUE);
 766 }
 767
 768
 769 /*
 770  * Description: Clear NIC TSF counter
 771  *              Clear local TSF counter
 772  *
 773  * Parameters:
 774  *  In:
 775  *      pDevice         - The adapter to be read
 776  *
 777  * Return Value: TRUE if success; otherwise FALSE
 778  *
 779  */
 780 BOOL CARDbClearCurrentTSF(void *pDeviceHandler)
 781 {
 782     PSDevice    pDevice = (PSDevice) pDeviceHandler;
 783
 784     MACvRegBitsOn(pDevice,MAC_REG_TFTCTL,TFTCTL_TSFCNTRST);
 785
 786     LODWORD(pDevice->qwCurrTSF) = 0;
 787     HIDWORD(pDevice->qwCurrTSF) = 0;
 788
 789     return(TRUE);
 790 }
 791
 792 /*
 793  * Description: Read NIC TSF counter
 794  *              Get NEXTTBTT from adjusted TSF and Beacon Interval
 795  *
 796  * Parameters:
 797  *  In:
 798  *      qwTSF           - Current TSF counter
 799  *      wbeaconInterval - Beacon Interval
 800  *  Out:
 801  *      qwCurrTSF       - Current TSF counter
 802  *
 803  * Return Value: TSF value of next Beacon
 804  *
 805  */
 806 QWORD CARDqGetNextTBTT (QWORD qwTSF, WORD wBeaconInterval)
 807 {
 808
 809     unsigned int    uLowNextTBTT;
 810     unsigned int    uHighRemain, uLowRemain;
 811     unsigned int    uBeaconInterval;
 812
 813     uBeaconInterval = wBeaconInterval * 1024;
 814     // Next TBTT = ((local_current_TSF / beacon_interval) + 1 ) * beacon_interval
 815     uLowNextTBTT = (LODWORD(qwTSF) >> 10) << 10;
 816     uLowRemain = (uLowNextTBTT) % uBeaconInterval;
 817     uHighRemain = ((0x80000000 % uBeaconInterval)* 2 * HIDWORD(qwTSF))
 818                   % uBeaconInterval;
 819     uLowRemain = (uHighRemain + uLowRemain) % uBeaconInterval;
 820     uLowRemain = uBeaconInterval - uLowRemain;
 821
 822     // check if carry when add one beacon interval
 823     if ((~uLowNextTBTT) < uLowRemain)
 824         HIDWORD(qwTSF) ++ ;
 825
 826     LODWORD(qwTSF) = uLowNextTBTT + uLowRemain;
 827
 828     return (qwTSF);
 829 }
 830
 831
 832 /*
 833  * Description: Set NIC TSF counter for first Beacon time
 834  *              Get NEXTTBTT from adjusted TSF and Beacon Interval
 835  *
 836  * Parameters:
 837  *  In:
 838  *      dwIoBase        - IO Base
 839  *      wBeaconInterval - Beacon Interval
 840  *  Out:
 841  *      none
 842  *
 843  * Return Value: none
 844  *
 845  */
 846 void CARDvSetFirstNextTBTT(void *pDeviceHandler, WORD wBeaconInterval)
 847 {
 848
 849     PSDevice        pDevice = (PSDevice) pDeviceHandler;
 850     QWORD           qwNextTBTT;
 851     DWORD           dwLoTBTT,dwHiTBTT;
 852     BYTE            pbyData[8];
 853
 854     HIDWORD(qwNextTBTT) = 0;
 855     LODWORD(qwNextTBTT) = 0;
 856     CARDbClearCurrentTSF(pDevice);
 857     //CARDbGetCurrentTSF(pDevice, &qwNextTBTT); //Get Local TSF counter
 858     qwNextTBTT = CARDqGetNextTBTT(qwNextTBTT, wBeaconInterval);
 859     // Set NextTBTT
 860
 861     dwLoTBTT = LODWORD(qwNextTBTT);
 862     dwHiTBTT = HIDWORD(qwNextTBTT);
 863
 864     pbyData[0] = (BYTE)dwLoTBTT;
 865     pbyData[1] = (BYTE)(dwLoTBTT>>8);
 866     pbyData[2] = (BYTE)(dwLoTBTT>>16);
 867     pbyData[3] = (BYTE)(dwLoTBTT>>24);
 868     pbyData[4] = (BYTE)dwHiTBTT;
 869     pbyData[5] = (BYTE)(dwHiTBTT>>8);
 870     pbyData[6] = (BYTE)(dwHiTBTT>>16);
 871     pbyData[7] = (BYTE)(dwHiTBTT>>24);
 872
 873     CONTROLnsRequestOut(pDevice,
 874                         MESSAGE_TYPE_SET_TSFTBTT,
 875                         MESSAGE_REQUEST_TBTT,
 876                         0,
 877                         8,
 878                         pbyData
 879                         );
 880
 881     return;
 882 }
 883
 884
 885 /*
 886  * Description: Sync NIC TSF counter for Beacon time
 887  *              Get NEXTTBTT and write to HW
 888  *
 889  * Parameters:
 890  *  In:
 891  *      pDevice         - The adapter to be set
 892  *      qwTSF           - Current TSF counter
 893  *      wBeaconInterval - Beacon Interval
 894  *  Out:
 895  *      none
 896  *
 897  * Return Value: none
 898  *
 899  */
 900 void CARDvUpdateNextTBTT(void *pDeviceHandler, QWORD qwTSF,
 901                          WORD wBeaconInterval)
 902 {
 903     PSDevice        pDevice = (PSDevice) pDeviceHandler;
 904     DWORD           dwLoTBTT,dwHiTBTT;
 905     BYTE            pbyData[8];
 906
 907     qwTSF = CARDqGetNextTBTT(qwTSF, wBeaconInterval);
 908
 909     // Set NextTBTT
 910     dwLoTBTT = LODWORD(qwTSF);
 911     dwHiTBTT = HIDWORD(qwTSF);
 912
 913     pbyData[0] = (BYTE)dwLoTBTT;
 914     pbyData[1] = (BYTE)(dwLoTBTT>>8);
 915     pbyData[2] = (BYTE)(dwLoTBTT>>16);
 916     pbyData[3] = (BYTE)(dwLoTBTT>>24);
 917     pbyData[4] = (BYTE)dwHiTBTT;
 918     pbyData[5] = (BYTE)(dwHiTBTT>>8);
 919     pbyData[6] = (BYTE)(dwHiTBTT>>16);
 920     pbyData[7] = (BYTE)(dwHiTBTT>>24);
 921
 922     CONTROLnsRequestOut(pDevice,
 923                         MESSAGE_TYPE_SET_TSFTBTT,
 924                         MESSAGE_REQUEST_TBTT,
 925                         0,
 926                         8,
 927                         pbyData
 928                         );
 929
 930
 931     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Card:Update Next TBTT[%8xh:%8xh] \n",(int)HIDWORD(qwTSF), (int)LODWORD(qwTSF));
 932
 933     return;
 934 }
 935
 936 /*
 937  * Description: Turn off Radio power
 938  *
 939  * Parameters:
 940  *  In:
 941  *      pDevice         - The adapter to be turned off
 942  *  Out:
 943  *      none
 944  *
 945  * Return Value: TRUE if success; otherwise FALSE
 946  *
 947  */
 948 BOOL CARDbRadioPowerOff(void *pDeviceHandler)
 949 {
 950 PSDevice    pDevice = (PSDevice) pDeviceHandler;
 951 BOOL bResult = TRUE;
 952
 953     //if (pDevice->bRadioOff == TRUE)
 954     //    return TRUE;
 955
 956     pDevice->bRadioOff = TRUE;
 957
 958     switch (pDevice->byRFType) {
 959         case RF_AL2230:
 960         case RF_AL2230S:
 961         case RF_AIROHA7230:
 962         case RF_VT3226:     //RobertYu:20051111
 963         case RF_VT3226D0:
 964         case RF_VT3342A0:   //RobertYu:20060609
 965             MACvRegBitsOff(pDevice, MAC_REG_SOFTPWRCTL, (SOFTPWRCTL_SWPE2 | SOFTPWRCTL_SWPE3));
 966             break;
 967     }
 968
 969     MACvRegBitsOff(pDevice, MAC_REG_HOSTCR, HOSTCR_RXON);
 970
 971     BBvSetDeepSleep(pDevice);
 972
 973     return bResult;
 974 }
 975
 976
 977 /*
 978  * Description: Turn on Radio power
 979  *
 980  * Parameters:
 981  *  In:
 982  *      pDevice         - The adapter to be turned on
 983  *  Out:
 984  *      none
 985  *
 986  * Return Value: TRUE if success; otherwise FALSE
 987  *
 988  */
 989 BOOL CARDbRadioPowerOn(void *pDeviceHandler)
 990 {
 991 PSDevice    pDevice = (PSDevice) pDeviceHandler;
 992 BOOL bResult = TRUE;
 993
 994
 995     if ((pDevice->bHWRadioOff == TRUE) || (pDevice->bRadioControlOff == TRUE)) {
 996         return FALSE;
 997     }
 998
 999     //if (pDevice->bRadioOff == FALSE)
1000     //    return TRUE;
1001
1002     pDevice->bRadioOff = FALSE;
1003
1004     BBvExitDeepSleep(pDevice);
1005
1006     MACvRegBitsOn(pDevice, MAC_REG_HOSTCR, HOSTCR_RXON);
1007
1008     switch (pDevice->byRFType) {
1009         case RF_AL2230:
1010         case RF_AL2230S:
1011         case RF_AIROHA7230:
1012         case RF_VT3226:     //RobertYu:20051111
1013         case RF_VT3226D0:
1014         case RF_VT3342A0:   //RobertYu:20060609
1015             MACvRegBitsOn(pDevice, MAC_REG_SOFTPWRCTL, (SOFTPWRCTL_SWPE2 | SOFTPWRCTL_SWPE3));
1016             break;
1017     }
1018
1019     return bResult;
1020 }
1021
1022 void CARDvSetBSSMode(void *pDeviceHandler)
1023 {
1024     PSDevice    pDevice = (PSDevice) pDeviceHandler;
1025     // Set BB and packet type at the same time.//{{RobertYu:20050222, AL7230 have two TX PA output, only connet to b/g now
1026     // so in 11a mode need to set the MAC Reg0x4C to 11b/g mode to turn on PA
1027     if( (pDevice->byRFType == RF_AIROHA7230 ) && (pDevice->byBBType == BB_TYPE_11A) )
1028     {
1029         MACvSetBBType(pDevice, BB_TYPE_11G);
1030     }
1031     else
1032     {
1033         MACvSetBBType(pDevice, pDevice->byBBType);
1034     }
1035     pDevice->byPacketType = CARDbyGetPktType(pDevice);
1036
1037     if (pDevice->byBBType == BB_TYPE_11A) {
1038         ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0x88, 0x03);
1039     } else if (pDevice->byBBType == BB_TYPE_11B) {
1040         ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0x88, 0x02);
1041     } else if (pDevice->byBBType == BB_TYPE_11G) {
1042         ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0x88, 0x08);
1043     }
1044
1045     vUpdateIFS(pDevice);
1046     CARDvSetRSPINF(pDevice, (BYTE)pDevice->byBBType);
1047
1048     if ( pDevice->byBBType == BB_TYPE_11A ) {
1049         //request by Jack 2005-04-26
1050         if (pDevice->byRFType == RF_AIROHA7230) {
1051             pDevice->abyBBVGA[0] = 0x20;
1052             ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xE7, pDevice->abyBBVGA[0]);
1053         }
1054         pDevice->abyBBVGA[2] = 0x10;
1055         pDevice->abyBBVGA[3] = 0x10;
1056     } else {
1057         //request by Jack 2005-04-26
1058         if (pDevice->byRFType == RF_AIROHA7230) {
1059             pDevice->abyBBVGA[0] = 0x1C;
1060             ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xE7, pDevice->abyBBVGA[0]);
1061         }
1062         pDevice->abyBBVGA[2] = 0x0;
1063         pDevice->abyBBVGA[3] = 0x0;
1064     }
1065 }
1066
1067 /*
1068  *
1069  * Description:
1070  *    Do Channel Switch defined in 802.11h
1071  *
1072  * Parameters:
1073  *  In:
1074  *      hDeviceContext - device structure point
1075  *  Out:
1076  *      none
1077  *
1078  * Return Value: none.
1079  *
1080 -*/
1081 BOOL
1082 CARDbChannelSwitch (
1083      void *pDeviceHandler,
1084      BYTE             byMode,
1085      BYTE             byNewChannel,
1086      BYTE             byCount
1087     )
1088 {
1089     PSDevice    pDevice = (PSDevice) pDeviceHandler;
1090     BOOL        bResult = TRUE;
1091
1092     if (byCount == 0) {
1093         pDevice->sMgmtObj.uCurrChannel = byNewChannel;
1094         bResult = CARDbSetMediaChannel(pDevice, byNewChannel);
1095
1096         return(bResult);
1097     }
1098     pDevice->byChannelSwitchCount = byCount;
1099     pDevice->byNewChannel = byNewChannel;
1100     pDevice->bChannelSwitch = TRUE;
1101
1102     if (byMode == 1) {
1103         //bResult=CARDbStopTxPacket(pDevice, PKT_TYPE_802_11_ALL);
1104         pDevice->bStopDataPkt = TRUE;
1105     }
1106     return (bResult);
1107 }
1108
1109
1110
1111
1112
1113