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