Pileus Git - ~andy/linux/blob - 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         struct vnt_phy_field phy[4];
 323         u8 abyTxRate[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; /* For OFDM */
 324         u8 abyRsvTime[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
 325         u8 abyData[34];
 326         int i;
 327
 328     //RSPINF_b_1
 329         BBvCalculateParameter(pDevice, 14,
 330                 swGetCCKControlRate(pDevice, RATE_1M), PK_TYPE_11B, &phy[0]);
 331
 332     ///RSPINF_b_2
 333         BBvCalculateParameter(pDevice, 14,
 334                 swGetCCKControlRate(pDevice, RATE_2M), PK_TYPE_11B, &phy[1]);
 335
 336     //RSPINF_b_5
 337         BBvCalculateParameter(pDevice, 14,
 338                 swGetCCKControlRate(pDevice, RATE_5M), PK_TYPE_11B, &phy[2]);
 339
 340     //RSPINF_b_11
 341         BBvCalculateParameter(pDevice, 14,
 342                 swGetCCKControlRate(pDevice, RATE_11M), PK_TYPE_11B, &phy[3]);
 343
 344     //RSPINF_a_6
 345     CARDvCalculateOFDMRParameter (RATE_6M,
 346                                  byBBType,
 347                                  &abyTxRate[0],
 348                                  &abyRsvTime[0]);
 349
 350     //RSPINF_a_9
 351     CARDvCalculateOFDMRParameter (RATE_9M,
 352                                  byBBType,
 353                                  &abyTxRate[1],
 354                                  &abyRsvTime[1]);
 355
 356     //RSPINF_a_12
 357     CARDvCalculateOFDMRParameter (RATE_12M,
 358                                  byBBType,
 359                                  &abyTxRate[2],
 360                                  &abyRsvTime[2]);
 361
 362     //RSPINF_a_18
 363     CARDvCalculateOFDMRParameter (RATE_18M,
 364                                  byBBType,
 365                                  &abyTxRate[3],
 366                                  &abyRsvTime[3]);
 367
 368     //RSPINF_a_24
 369     CARDvCalculateOFDMRParameter (RATE_24M,
 370                                  byBBType,
 371                                  &abyTxRate[4],
 372                                  &abyRsvTime[4]);
 373
 374     //RSPINF_a_36
 375     CARDvCalculateOFDMRParameter (swGetOFDMControlRate(pDevice, RATE_36M),
 376                                  byBBType,
 377                                  &abyTxRate[5],
 378                                  &abyRsvTime[5]);
 379
 380     //RSPINF_a_48
 381     CARDvCalculateOFDMRParameter (swGetOFDMControlRate(pDevice, RATE_48M),
 382                                  byBBType,
 383                                  &abyTxRate[6],
 384                                  &abyRsvTime[6]);
 385
 386     //RSPINF_a_54
 387     CARDvCalculateOFDMRParameter (swGetOFDMControlRate(pDevice, RATE_54M),
 388                                  byBBType,
 389                                  &abyTxRate[7],
 390                                  &abyRsvTime[7]);
 391
 392     //RSPINF_a_72
 393     CARDvCalculateOFDMRParameter (swGetOFDMControlRate(pDevice, RATE_54M),
 394                                  byBBType,
 395                                  &abyTxRate[8],
 396                                  &abyRsvTime[8]);
 397
 398         put_unaligned(phy[0].len, (u16 *)&abyData[0]);
 399         abyData[2] = phy[0].signal;
 400         abyData[3] = phy[0].service;
 401
 402         put_unaligned(phy[1].len, (u16 *)&abyData[4]);
 403         abyData[6] = phy[1].signal;
 404         abyData[7] = phy[1].service;
 405
 406         put_unaligned(phy[2].len, (u16 *)&abyData[8]);
 407         abyData[10] = phy[2].signal;
 408         abyData[11] = phy[2].service;
 409
 410         put_unaligned(phy[3].len, (u16 *)&abyData[12]);
 411         abyData[14] = phy[3].signal;
 412         abyData[15] = phy[3].service;
 413
 414     for (i = 0; i < 9; i++) {
 415         abyData[16+i*2] = abyTxRate[i];
 416         abyData[16+i*2+1] = abyRsvTime[i];
 417     }
 418
 419     CONTROLnsRequestOut(pDevice,
 420                         MESSAGE_TYPE_WRITE,
 421                         MAC_REG_RSPINF_B_1,
 422                         MESSAGE_REQUEST_MACREG,
 423                         34,
 424                         &abyData[0]);
 425
 426 }
 427
 428 /*
 429  * Description: Update IFS
 430  *
 431  * Parameters:
 432  *  In:
 433  *      pDevice             - The adapter to be set
 434  *  Out:
 435  *      none
 436  *
 437  * Return Value: None.
 438  *
 439  */
 440 void vUpdateIFS(struct vnt_private *pDevice)
 441 {
 442         u8 byMaxMin = 0;
 443         u8 byData[4];
 444
 445     if (pDevice->byPacketType==PK_TYPE_11A) {//0000 0000 0000 0000,11a
 446         pDevice->uSlot = C_SLOT_SHORT;
 447         pDevice->uSIFS = C_SIFS_A;
 448         pDevice->uDIFS = C_SIFS_A + 2*C_SLOT_SHORT;
 449         pDevice->uCwMin = C_CWMIN_A;
 450         byMaxMin = 4;
 451     }
 452     else if (pDevice->byPacketType==PK_TYPE_11B) {//0000 0001 0000 0000,11b
 453         pDevice->uSlot = C_SLOT_LONG;
 454         pDevice->uSIFS = C_SIFS_BG;
 455         pDevice->uDIFS = C_SIFS_BG + 2*C_SLOT_LONG;
 456           pDevice->uCwMin = C_CWMIN_B;
 457         byMaxMin = 5;
 458     }
 459     else {// PK_TYPE_11GA & PK_TYPE_11GB
 460         u8 byRate = 0;
 461         bool bOFDMRate = false;
 462         unsigned int ii = 0;
 463         PWLAN_IE_SUPP_RATES pItemRates = NULL;
 464
 465         pDevice->uSIFS = C_SIFS_BG;
 466         if (pDevice->bShortSlotTime) {
 467             pDevice->uSlot = C_SLOT_SHORT;
 468         } else {
 469             pDevice->uSlot = C_SLOT_LONG;
 470         }
 471         pDevice->uDIFS = C_SIFS_BG + 2*pDevice->uSlot;
 472
 473         pItemRates = (PWLAN_IE_SUPP_RATES)pDevice->vnt_mgmt.abyCurrSuppRates;
 474         for (ii = 0; ii < pItemRates->len; ii++) {
 475             byRate = (u8)(pItemRates->abyRates[ii]&0x7F);
 476             if (RATEwGetRateIdx(byRate) > RATE_11M) {
 477                 bOFDMRate = true;
 478                 break;
 479             }
 480         }
 481         if (bOFDMRate == false) {
 482                 pItemRates = (PWLAN_IE_SUPP_RATES)pDevice->vnt_mgmt
 483                         .abyCurrExtSuppRates;
 484             for (ii = 0; ii < pItemRates->len; ii++) {
 485                 byRate = (u8)(pItemRates->abyRates[ii]&0x7F);
 486                 if (RATEwGetRateIdx(byRate) > RATE_11M) {
 487                     bOFDMRate = true;
 488                     break;
 489                 }
 490             }
 491         }
 492         if (bOFDMRate == true) {
 493             pDevice->uCwMin = C_CWMIN_A;
 494             byMaxMin = 4;
 495         } else {
 496             pDevice->uCwMin = C_CWMIN_B;
 497             byMaxMin = 5;
 498         }
 499     }
 500
 501     pDevice->uCwMax = C_CWMAX;
 502     pDevice->uEIFS = C_EIFS;
 503
 504     byData[0] = (u8)pDevice->uSIFS;
 505     byData[1] = (u8)pDevice->uDIFS;
 506     byData[2] = (u8)pDevice->uEIFS;
 507     byData[3] = (u8)pDevice->uSlot;
 508     CONTROLnsRequestOut(pDevice,
 509                         MESSAGE_TYPE_WRITE,
 510                         MAC_REG_SIFS,
 511                         MESSAGE_REQUEST_MACREG,
 512                         4,
 513                         &byData[0]);
 514
 515     byMaxMin |= 0xA0;//1010 1111,C_CWMAX = 1023
 516     CONTROLnsRequestOut(pDevice,
 517                         MESSAGE_TYPE_WRITE,
 518                         MAC_REG_CWMAXMIN0,
 519                         MESSAGE_REQUEST_MACREG,
 520                         1,
 521                         &byMaxMin);
 522 }
 523
 524 void CARDvUpdateBasicTopRate(struct vnt_private *pDevice)
 525 {
 526         u8 byTopOFDM = RATE_24M, byTopCCK = RATE_1M;
 527         u8 ii;
 528
 529      //Determines the highest basic rate.
 530      for (ii = RATE_54M; ii >= RATE_6M; ii --) {
 531          if ( (pDevice->wBasicRate) & ((u16)(1<<ii)) ) {
 532              byTopOFDM = ii;
 533              break;
 534          }
 535      }
 536      pDevice->byTopOFDMBasicRate = byTopOFDM;
 537
 538      for (ii = RATE_11M;; ii --) {
 539          if ( (pDevice->wBasicRate) & ((u16)(1<<ii)) ) {
 540              byTopCCK = ii;
 541              break;
 542          }
 543          if (ii == RATE_1M)
 544             break;
 545      }
 546      pDevice->byTopCCKBasicRate = byTopCCK;
 547  }
 548
 549 /*
 550  * Description: Set NIC Tx Basic Rate
 551  *
 552  * Parameters:
 553  *  In:
 554  *      pDevice         - The adapter to be set
 555  *      wBasicRate      - Basic Rate to be set
 556  *  Out:
 557  *      none
 558  *
 559  * Return Value: true if succeeded; false if failed.
 560  *
 561  */
 562 void CARDbAddBasicRate(struct vnt_private *pDevice, u16 wRateIdx)
 563 {
 564         u16 wRate = (1 << wRateIdx);
 565
 566     pDevice->wBasicRate |= wRate;
 567
 568     //Determines the highest basic rate.
 569     CARDvUpdateBasicTopRate(pDevice);
 570 }
 571
 572 int CARDbIsOFDMinBasicRate(struct vnt_private *pDevice)
 573 {
 574         int ii;
 575
 576     for (ii = RATE_54M; ii >= RATE_6M; ii --) {
 577         if ((pDevice->wBasicRate) & ((u16)(1<<ii)))
 578             return true;
 579     }
 580     return false;
 581 }
 582
 583 u8 CARDbyGetPktType(struct vnt_private *pDevice)
 584 {
 585
 586     if (pDevice->byBBType == BB_TYPE_11A || pDevice->byBBType == BB_TYPE_11B) {
 587         return (u8)pDevice->byBBType;
 588     }
 589     else if (CARDbIsOFDMinBasicRate(pDevice)) {
 590         return PK_TYPE_11GA;
 591     }
 592     else {
 593         return PK_TYPE_11GB;
 594     }
 595 }
 596
 597 /*
 598  * Description: Calculate TSF offset of two TSF input
 599  *              Get TSF Offset from RxBCN's TSF and local TSF
 600  *
 601  * Parameters:
 602  *  In:
 603  *      pDevice         - The adapter to be sync.
 604  *      qwTSF1          - Rx BCN's TSF
 605  *      qwTSF2          - Local TSF
 606  *  Out:
 607  *      none
 608  *
 609  * Return Value: TSF Offset value
 610  *
 611  */
 612 u64 CARDqGetTSFOffset(u8 byRxRate, u64 qwTSF1, u64 qwTSF2)
 613 {
 614         u64 qwTSFOffset = 0;
 615         u16 wRxBcnTSFOffst = 0;
 616
 617         wRxBcnTSFOffst = cwRXBCNTSFOff[byRxRate % MAX_RATE];
 618
 619         qwTSF2 += (u64)wRxBcnTSFOffst;
 620
 621         qwTSFOffset = qwTSF1 - qwTSF2;
 622
 623         return qwTSFOffset;
 624 }
 625
 626 /*
 627  * Description: Sync. TSF counter to BSS
 628  *              Get TSF offset and write to HW
 629  *
 630  * Parameters:
 631  *  In:
 632  *      pDevice         - The adapter to be sync.
 633  *      qwBSSTimestamp  - Rx BCN's TSF
 634  *      qwLocalTSF      - Local TSF
 635  *  Out:
 636  *      none
 637  *
 638  * Return Value: none
 639  *
 640  */
 641 void CARDvAdjustTSF(struct vnt_private *pDevice, u8 byRxRate,
 642                 u64 qwBSSTimestamp, u64 qwLocalTSF)
 643 {
 644         u64 qwTSFOffset = 0;
 645         u8 pbyData[8];
 646
 647     qwTSFOffset = CARDqGetTSFOffset(byRxRate, qwBSSTimestamp, qwLocalTSF);
 648     // adjust TSF
 649     // HW's TSF add TSF Offset reg
 650
 651         pbyData[0] = (u8)qwTSFOffset;
 652         pbyData[1] = (u8)(qwTSFOffset >> 8);
 653         pbyData[2] = (u8)(qwTSFOffset >> 16);
 654         pbyData[3] = (u8)(qwTSFOffset >> 24);
 655         pbyData[4] = (u8)(qwTSFOffset >> 32);
 656         pbyData[5] = (u8)(qwTSFOffset >> 40);
 657         pbyData[6] = (u8)(qwTSFOffset >> 48);
 658         pbyData[7] = (u8)(qwTSFOffset >> 56);
 659
 660     CONTROLnsRequestOut(pDevice,
 661                         MESSAGE_TYPE_SET_TSFTBTT,
 662                         MESSAGE_REQUEST_TSF,
 663                         0,
 664                         8,
 665                         pbyData
 666                         );
 667
 668 }
 669 /*
 670  * Description: Read NIC TSF counter
 671  *              Get local TSF counter
 672  *
 673  * Parameters:
 674  *  In:
 675  *      pDevice         - The adapter to be read
 676  *  Out:
 677  *      qwCurrTSF       - Current TSF counter
 678  *
 679  * Return Value: true if success; otherwise false
 680  *
 681  */
 682 bool CARDbGetCurrentTSF(struct vnt_private *pDevice, u64 *pqwCurrTSF)
 683 {
 684
 685         *pqwCurrTSF = pDevice->qwCurrTSF;
 686
 687         return true;
 688 }
 689
 690 /*
 691  * Description: Clear NIC TSF counter
 692  *              Clear local TSF counter
 693  *
 694  * Parameters:
 695  *  In:
 696  *      pDevice         - The adapter to be read
 697  *
 698  * Return Value: true if success; otherwise false
 699  *
 700  */
 701 bool CARDbClearCurrentTSF(struct vnt_private *pDevice)
 702 {
 703
 704         MACvRegBitsOn(pDevice, MAC_REG_TFTCTL, TFTCTL_TSFCNTRST);
 705
 706         pDevice->qwCurrTSF = 0;
 707
 708         return true;
 709 }
 710
 711 /*
 712  * Description: Read NIC TSF counter
 713  *              Get NEXTTBTT from adjusted TSF and Beacon Interval
 714  *
 715  * Parameters:
 716  *  In:
 717  *      qwTSF           - Current TSF counter
 718  *      wbeaconInterval - Beacon Interval
 719  *  Out:
 720  *      qwCurrTSF       - Current TSF counter
 721  *
 722  * Return Value: TSF value of next Beacon
 723  *
 724  */
 725 u64 CARDqGetNextTBTT(u64 qwTSF, u16 wBeaconInterval)
 726 {
 727
 728     unsigned int    uLowNextTBTT;
 729     unsigned int    uHighRemain, uLowRemain;
 730     unsigned int    uBeaconInterval;
 731
 732     uBeaconInterval = wBeaconInterval * 1024;
 733     // Next TBTT = ((local_current_TSF / beacon_interval) + 1 ) * beacon_interval
 734         uLowNextTBTT = ((qwTSF & 0xffffffffU) >> 10) << 10;
 735         uLowRemain = (uLowNextTBTT) % uBeaconInterval;
 736         uHighRemain = ((0x80000000 % uBeaconInterval) * 2 * (u32)(qwTSF >> 32))
 737                 % uBeaconInterval;
 738         uLowRemain = (uHighRemain + uLowRemain) % uBeaconInterval;
 739         uLowRemain = uBeaconInterval - uLowRemain;
 740
 741     // check if carry when add one beacon interval
 742         if ((~uLowNextTBTT) < uLowRemain)
 743                 qwTSF = ((qwTSF >> 32) + 1) << 32;
 744
 745         qwTSF = (qwTSF & 0xffffffff00000000ULL) |
 746                 (u64)(uLowNextTBTT + uLowRemain);
 747
 748     return (qwTSF);
 749 }
 750
 751 /*
 752  * Description: Set NIC TSF counter for first Beacon time
 753  *              Get NEXTTBTT from adjusted TSF and Beacon Interval
 754  *
 755  * Parameters:
 756  *  In:
 757  *      dwIoBase        - IO Base
 758  *      wBeaconInterval - Beacon Interval
 759  *  Out:
 760  *      none
 761  *
 762  * Return Value: none
 763  *
 764  */
 765 void CARDvSetFirstNextTBTT(struct vnt_private *pDevice, u16 wBeaconInterval)
 766 {
 767         u64 qwNextTBTT = 0;
 768         u8 pbyData[8];
 769
 770         CARDbClearCurrentTSF(pDevice);
 771     //CARDbGetCurrentTSF(pDevice, &qwNextTBTT); //Get Local TSF counter
 772         qwNextTBTT = CARDqGetNextTBTT(qwNextTBTT, wBeaconInterval);
 773     // Set NextTBTT
 774
 775         pbyData[0] = (u8)qwNextTBTT;
 776         pbyData[1] = (u8)(qwNextTBTT >> 8);
 777         pbyData[2] = (u8)(qwNextTBTT >> 16);
 778         pbyData[3] = (u8)(qwNextTBTT >> 24);
 779         pbyData[4] = (u8)(qwNextTBTT >> 32);
 780         pbyData[5] = (u8)(qwNextTBTT >> 40);
 781         pbyData[6] = (u8)(qwNextTBTT >> 48);
 782         pbyData[7] = (u8)(qwNextTBTT >> 56);
 783
 784     CONTROLnsRequestOut(pDevice,
 785                         MESSAGE_TYPE_SET_TSFTBTT,
 786                         MESSAGE_REQUEST_TBTT,
 787                         0,
 788                         8,
 789                         pbyData
 790                         );
 791
 792     return;
 793 }
 794
 795 /*
 796  * Description: Sync NIC TSF counter for Beacon time
 797  *              Get NEXTTBTT and write to HW
 798  *
 799  * Parameters:
 800  *  In:
 801  *      pDevice         - The adapter to be set
 802  *      qwTSF           - Current TSF counter
 803  *      wBeaconInterval - Beacon Interval
 804  *  Out:
 805  *      none
 806  *
 807  * Return Value: none
 808  *
 809  */
 810 void CARDvUpdateNextTBTT(struct vnt_private *pDevice, u64 qwTSF,
 811                         u16 wBeaconInterval)
 812 {
 813         u8 pbyData[8];
 814
 815     qwTSF = CARDqGetNextTBTT(qwTSF, wBeaconInterval);
 816
 817     // Set NextTBTT
 818
 819         pbyData[0] = (u8)qwTSF;
 820         pbyData[1] = (u8)(qwTSF >> 8);
 821         pbyData[2] = (u8)(qwTSF >> 16);
 822         pbyData[3] = (u8)(qwTSF >> 24);
 823         pbyData[4] = (u8)(qwTSF >> 32);
 824         pbyData[5] = (u8)(qwTSF >> 40);
 825         pbyData[6] = (u8)(qwTSF >> 48);
 826         pbyData[7] = (u8)(qwTSF >> 56);
 827
 828     CONTROLnsRequestOut(pDevice,
 829                         MESSAGE_TYPE_SET_TSFTBTT,
 830                         MESSAGE_REQUEST_TBTT,
 831                         0,
 832                         8,
 833                         pbyData
 834                         );
 835
 836         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO
 837                 "Card:Update Next TBTT[%8lx]\n", (unsigned long)qwTSF);
 838
 839     return;
 840 }
 841
 842 /*
 843  * Description: Turn off Radio power
 844  *
 845  * Parameters:
 846  *  In:
 847  *      pDevice         - The adapter to be turned off
 848  *  Out:
 849  *      none
 850  *
 851  * Return Value: true if success; otherwise false
 852  *
 853  */
 854 int CARDbRadioPowerOff(struct vnt_private *pDevice)
 855 {
 856         int bResult = true;
 857
 858     //if (pDevice->bRadioOff == true)
 859     //    return true;
 860
 861     pDevice->bRadioOff = true;
 862
 863     switch (pDevice->byRFType) {
 864         case RF_AL2230:
 865         case RF_AL2230S:
 866         case RF_AIROHA7230:
 867         case RF_VT3226:     //RobertYu:20051111
 868         case RF_VT3226D0:
 869         case RF_VT3342A0:   //RobertYu:20060609
 870             MACvRegBitsOff(pDevice, MAC_REG_SOFTPWRCTL, (SOFTPWRCTL_SWPE2 | SOFTPWRCTL_SWPE3));
 871             break;
 872     }
 873
 874     MACvRegBitsOff(pDevice, MAC_REG_HOSTCR, HOSTCR_RXON);
 875
 876     BBvSetDeepSleep(pDevice);
 877
 878     return bResult;
 879 }
 880
 881 /*
 882  * Description: Turn on Radio power
 883  *
 884  * Parameters:
 885  *  In:
 886  *      pDevice         - The adapter to be turned on
 887  *  Out:
 888  *      none
 889  *
 890  * Return Value: true if success; otherwise false
 891  *
 892  */
 893 int CARDbRadioPowerOn(struct vnt_private *pDevice)
 894 {
 895         int bResult = true;
 896
 897     if ((pDevice->bHWRadioOff == true) || (pDevice->bRadioControlOff == true)) {
 898         return false;
 899     }
 900
 901     //if (pDevice->bRadioOff == false)
 902     //    return true;
 903
 904     pDevice->bRadioOff = false;
 905
 906     BBvExitDeepSleep(pDevice);
 907
 908     MACvRegBitsOn(pDevice, MAC_REG_HOSTCR, HOSTCR_RXON);
 909
 910     switch (pDevice->byRFType) {
 911         case RF_AL2230:
 912         case RF_AL2230S:
 913         case RF_AIROHA7230:
 914         case RF_VT3226:     //RobertYu:20051111
 915         case RF_VT3226D0:
 916         case RF_VT3342A0:   //RobertYu:20060609
 917             MACvRegBitsOn(pDevice, MAC_REG_SOFTPWRCTL, (SOFTPWRCTL_SWPE2 | SOFTPWRCTL_SWPE3));
 918             break;
 919     }
 920
 921     return bResult;
 922 }
 923
 924 void CARDvSetBSSMode(struct vnt_private *pDevice)
 925 {
 926     // Set BB and packet type at the same time.//{{RobertYu:20050222, AL7230 have two TX PA output, only connet to b/g now
 927     // so in 11a mode need to set the MAC Reg0x4C to 11b/g mode to turn on PA
 928     if( (pDevice->byRFType == RF_AIROHA7230 ) && (pDevice->byBBType == BB_TYPE_11A) )
 929     {
 930         MACvSetBBType(pDevice, BB_TYPE_11G);
 931     }
 932     else
 933     {
 934         MACvSetBBType(pDevice, pDevice->byBBType);
 935     }
 936     pDevice->byPacketType = CARDbyGetPktType(pDevice);
 937
 938     if (pDevice->byBBType == BB_TYPE_11A) {
 939         ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0x88, 0x03);
 940     } else if (pDevice->byBBType == BB_TYPE_11B) {
 941         ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0x88, 0x02);
 942     } else if (pDevice->byBBType == BB_TYPE_11G) {
 943         ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0x88, 0x08);
 944     }
 945
 946     vUpdateIFS(pDevice);
 947     CARDvSetRSPINF(pDevice, (u8)pDevice->byBBType);
 948
 949     if ( pDevice->byBBType == BB_TYPE_11A ) {
 950         //request by Jack 2005-04-26
 951         if (pDevice->byRFType == RF_AIROHA7230) {
 952             pDevice->abyBBVGA[0] = 0x20;
 953             ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xE7, pDevice->abyBBVGA[0]);
 954         }
 955         pDevice->abyBBVGA[2] = 0x10;
 956         pDevice->abyBBVGA[3] = 0x10;
 957     } else {
 958         //request by Jack 2005-04-26
 959         if (pDevice->byRFType == RF_AIROHA7230) {
 960             pDevice->abyBBVGA[0] = 0x1C;
 961             ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xE7, pDevice->abyBBVGA[0]);
 962         }
 963         pDevice->abyBBVGA[2] = 0x0;
 964         pDevice->abyBBVGA[3] = 0x0;
 965     }
 966 }