drivers/staging/vt6656/card.c

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