drivers/staging/vt6656/card.c

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