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