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 "usbpipe.h"
  61
  62 //const u16 cwRXBCNTSFOff[MAX_RATE] =
  63 //{17, 34, 96, 192, 34, 23, 17, 11, 8, 5, 4, 3};
  64
  65 static const u16 cwRXBCNTSFOff[MAX_RATE] =
  66 {192, 96, 34, 17, 34, 23, 17, 11, 8, 5, 4, 3};
  67
  68 /*
  69  * Description: Set NIC media channel
  70  *
  71  * Parameters:
  72  *  In:
  73  *      pDevice             - The adapter to be set
  74  *      connection_channel  - Channel to be set
  75  *  Out:
  76  *      none
  77  */
  78 void CARDbSetMediaChannel(struct vnt_private *priv, u32 connection_channel)
  79 {
  80
  81         if (priv->byBBType == BB_TYPE_11A) {
  82                 if ((connection_channel < (CB_MAX_CHANNEL_24G + 1)) ||
  83                                         (connection_channel > CB_MAX_CHANNEL))
  84                         connection_channel = (CB_MAX_CHANNEL_24G + 1);
  85         } else {
  86                 if ((connection_channel > CB_MAX_CHANNEL_24G) ||
  87                                                 (connection_channel == 0))
  88                         connection_channel = 1;
  89         }
  90
  91         /* clear NAV */
  92         MACvRegBitsOn(priv, MAC_REG_MACCR, MACCR_CLRNAV);
  93
  94         /* Set Channel[7] = 0 to tell H/W channel is changing now. */
  95         MACvRegBitsOff(priv, MAC_REG_CHANNEL, 0xb0);
  96
  97         vnt_control_out(priv, MESSAGE_TYPE_SELECT_CHANNLE,
  98                                         connection_channel, 0, 0, NULL);
  99
 100         if (priv->byBBType == BB_TYPE_11A) {
 101                 priv->byCurPwr = 0xff;
 102                 vnt_rf_set_txpower(priv,
 103                         priv->abyOFDMAPwrTbl[connection_channel-15], RATE_54M);
 104         } else if (priv->byBBType == BB_TYPE_11G) {
 105                 priv->byCurPwr = 0xff;
 106                 vnt_rf_set_txpower(priv,
 107                         priv->abyOFDMPwrTbl[connection_channel-1], RATE_54M);
 108         } else {
 109                 priv->byCurPwr = 0xff;
 110                 vnt_rf_set_txpower(priv,
 111                         priv->abyCCKPwrTbl[connection_channel-1], RATE_1M);
 112         }
 113
 114         vnt_control_out_u8(priv, MESSAGE_REQUEST_MACREG, MAC_REG_CHANNEL,
 115                 (u8)(connection_channel|0x80));
 116 }
 117
 118 /*
 119  * Description: Get CCK mode basic rate
 120  *
 121  * Parameters:
 122  *  In:
 123  *      priv            - The adapter to be set
 124  *      rate_idx        - Receiving data rate
 125  *  Out:
 126  *      none
 127  *
 128  * Return Value: response Control frame rate
 129  *
 130  */
 131 static u16 swGetCCKControlRate(struct vnt_private *priv, u16 rate_idx)
 132 {
 133         u16 ui = rate_idx;
 134
 135         while (ui > RATE_1M) {
 136                 if (priv->wBasicRate & (1 << ui))
 137                         return ui;
 138                 ui--;
 139         }
 140
 141         return RATE_1M;
 142 }
 143
 144 /*
 145  * Description: Get OFDM mode basic rate
 146  *
 147  * Parameters:
 148  *  In:
 149  *      priv            - The adapter to be set
 150  *      rate_idx        - Receiving data rate
 151  *  Out:
 152  *      none
 153  *
 154  * Return Value: response Control frame rate
 155  *
 156  */
 157 static u16 swGetOFDMControlRate(struct vnt_private *priv, u16 rate_idx)
 158 {
 159         u16 ui = rate_idx;
 160
 161         dev_dbg(&priv->usb->dev, "%s basic rate: %d\n",
 162                                         __func__,  priv->wBasicRate);
 163
 164         if (!CARDbIsOFDMinBasicRate(priv)) {
 165                 dev_dbg(&priv->usb->dev, "%s (NO OFDM) %d\n",
 166                                                 __func__, rate_idx);
 167                 if (rate_idx > RATE_24M)
 168                         rate_idx = RATE_24M;
 169                 return rate_idx;
 170         }
 171
 172         while (ui > RATE_11M) {
 173                 if (priv->wBasicRate & (1 << ui)) {
 174                         dev_dbg(&priv->usb->dev, "%s rate: %d\n",
 175                                                         __func__, ui);
 176                         return ui;
 177                 }
 178                 ui--;
 179         }
 180
 181         dev_dbg(&priv->usb->dev, "%s basic rate: 24M\n", __func__);
 182
 183         return RATE_24M;
 184 }
 185
 186 /*
 187  * Description: Calculate TxRate and RsvTime fields for RSPINF in OFDM mode.
 188  *
 189  * Parameters:
 190  * In:
 191  *      rate    - Tx Rate
 192  *      bb_type - Tx Packet type
 193  * Out:
 194  *      tx_rate - pointer to RSPINF TxRate field
 195  *      rsv_time- pointer to RSPINF RsvTime field
 196  *
 197  * Return Value: none
 198  *
 199  */
 200 static void CARDvCalculateOFDMRParameter(u16 rate, u8 bb_type,
 201                                         u8 *tx_rate, u8 *rsv_time)
 202 {
 203
 204         switch (rate) {
 205         case RATE_6M:
 206                 if (bb_type == BB_TYPE_11A) {
 207                         *tx_rate = 0x9b;
 208                         *rsv_time = 24;
 209                 } else {
 210                         *tx_rate = 0x8b;
 211                         *rsv_time = 30;
 212                 }
 213                         break;
 214         case RATE_9M:
 215                 if (bb_type == BB_TYPE_11A) {
 216                         *tx_rate = 0x9f;
 217                         *rsv_time = 16;
 218                 } else {
 219                         *tx_rate = 0x8f;
 220                         *rsv_time = 22;
 221                 }
 222                 break;
 223         case RATE_12M:
 224                 if (bb_type == BB_TYPE_11A) {
 225                         *tx_rate = 0x9a;
 226                         *rsv_time = 12;
 227                 } else {
 228                         *tx_rate = 0x8a;
 229                         *rsv_time = 18;
 230                 }
 231                 break;
 232         case RATE_18M:
 233                 if (bb_type == BB_TYPE_11A) {
 234                         *tx_rate = 0x9e;
 235                         *rsv_time = 8;
 236                 } else {
 237                         *tx_rate = 0x8e;
 238                         *rsv_time = 14;
 239                 }
 240                 break;
 241         case RATE_36M:
 242                 if (bb_type == BB_TYPE_11A) {
 243                         *tx_rate = 0x9d;
 244                         *rsv_time = 4;
 245                 } else {
 246                         *tx_rate = 0x8d;
 247                         *rsv_time = 10;
 248                 }
 249                 break;
 250         case RATE_48M:
 251                 if (bb_type == BB_TYPE_11A) {
 252                         *tx_rate = 0x98;
 253                         *rsv_time = 4;
 254                 } else {
 255                         *tx_rate = 0x88;
 256                         *rsv_time = 10;
 257                 }
 258                 break;
 259         case RATE_54M:
 260                 if (bb_type == BB_TYPE_11A) {
 261                         *tx_rate = 0x9c;
 262                         *rsv_time = 4;
 263                 } else {
 264                         *tx_rate = 0x8c;
 265                         *rsv_time = 10;
 266                 }
 267                 break;
 268         case RATE_24M:
 269         default:
 270                 if (bb_type == BB_TYPE_11A) {
 271                         *tx_rate = 0x99;
 272                         *rsv_time = 8;
 273                 } else {
 274                         *tx_rate = 0x89;
 275                         *rsv_time = 14;
 276                 }
 277                 break;
 278         }
 279 }
 280
 281 /*
 282  * Description: Set RSPINF
 283  *
 284  * Parameters:
 285  *  In:
 286  *      pDevice             - The adapter to be set
 287  *  Out:
 288  *      none
 289  *
 290  * Return Value: None.
 291  *
 292  */
 293
 294 void CARDvSetRSPINF(struct vnt_private *priv, u8 bb_type)
 295 {
 296         struct vnt_phy_field phy[4];
 297         u8 tx_rate[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; /* For OFDM */
 298         u8 rsv_time[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
 299         u8 data[34];
 300         int i;
 301
 302         /*RSPINF_b_1*/
 303         BBvCalculateParameter(priv, 14,
 304                 swGetCCKControlRate(priv, RATE_1M), PK_TYPE_11B, &phy[0]);
 305
 306         /*RSPINF_b_2*/
 307         BBvCalculateParameter(priv, 14,
 308                 swGetCCKControlRate(priv, RATE_2M), PK_TYPE_11B, &phy[1]);
 309
 310         /*RSPINF_b_5*/
 311         BBvCalculateParameter(priv, 14,
 312                 swGetCCKControlRate(priv, RATE_5M), PK_TYPE_11B, &phy[2]);
 313
 314         /*RSPINF_b_11*/
 315         BBvCalculateParameter(priv, 14,
 316                 swGetCCKControlRate(priv, RATE_11M), PK_TYPE_11B, &phy[3]);
 317
 318
 319         /*RSPINF_a_6*/
 320         CARDvCalculateOFDMRParameter(RATE_6M, bb_type,
 321                                                 &tx_rate[0], &rsv_time[0]);
 322
 323         /*RSPINF_a_9*/
 324         CARDvCalculateOFDMRParameter(RATE_9M, bb_type,
 325                                                 &tx_rate[1], &rsv_time[1]);
 326
 327         /*RSPINF_a_12*/
 328         CARDvCalculateOFDMRParameter(RATE_12M, bb_type,
 329                                                 &tx_rate[2], &rsv_time[2]);
 330
 331         /*RSPINF_a_18*/
 332         CARDvCalculateOFDMRParameter(RATE_18M, bb_type,
 333                                                 &tx_rate[3], &rsv_time[3]);
 334
 335         /*RSPINF_a_24*/
 336         CARDvCalculateOFDMRParameter(RATE_24M, bb_type,
 337                                                 &tx_rate[4], &rsv_time[4]);
 338
 339         /*RSPINF_a_36*/
 340         CARDvCalculateOFDMRParameter(swGetOFDMControlRate(priv, RATE_36M),
 341                                         bb_type, &tx_rate[5], &rsv_time[5]);
 342
 343         /*RSPINF_a_48*/
 344         CARDvCalculateOFDMRParameter(swGetOFDMControlRate(priv, RATE_48M),
 345                                         bb_type, &tx_rate[6], &rsv_time[6]);
 346
 347         /*RSPINF_a_54*/
 348         CARDvCalculateOFDMRParameter(swGetOFDMControlRate(priv, RATE_54M),
 349                                         bb_type, &tx_rate[7], &rsv_time[7]);
 350
 351         /*RSPINF_a_72*/
 352         CARDvCalculateOFDMRParameter(swGetOFDMControlRate(priv, RATE_54M),
 353                                         bb_type, &tx_rate[8], &rsv_time[8]);
 354
 355         put_unaligned(phy[0].len, (u16 *)&data[0]);
 356         data[2] = phy[0].signal;
 357         data[3] = phy[0].service;
 358
 359         put_unaligned(phy[1].len, (u16 *)&data[4]);
 360         data[6] = phy[1].signal;
 361         data[7] = phy[1].service;
 362
 363         put_unaligned(phy[2].len, (u16 *)&data[8]);
 364         data[10] = phy[2].signal;
 365         data[11] = phy[2].service;
 366
 367         put_unaligned(phy[3].len, (u16 *)&data[12]);
 368         data[14] = phy[3].signal;
 369         data[15] = phy[3].service;
 370
 371         for (i = 0; i < 9; i++) {
 372                 data[16 + i * 2] = tx_rate[i];
 373                 data[16 + i * 2 + 1] = rsv_time[i];
 374         }
 375
 376         vnt_control_out(priv, MESSAGE_TYPE_WRITE,
 377                 MAC_REG_RSPINF_B_1, MESSAGE_REQUEST_MACREG, 34, &data[0]);
 378 }
 379
 380 /*
 381  * Description: Update IFS
 382  *
 383  * Parameters:
 384  *  In:
 385  *      priv - The adapter to be set
 386  * Out:
 387  *      none
 388  *
 389  * Return Value: None.
 390  *
 391  */
 392 void vUpdateIFS(struct vnt_private *priv)
 393 {
 394         u8 max_min = 0;
 395         u8 data[4];
 396
 397         if (priv->byPacketType == PK_TYPE_11A) {
 398                 priv->uSlot = C_SLOT_SHORT;
 399                 priv->uSIFS = C_SIFS_A;
 400                 priv->uDIFS = C_SIFS_A + 2 * C_SLOT_SHORT;
 401                 priv->uCwMin = C_CWMIN_A;
 402                 max_min = 4;
 403         } else if (priv->byPacketType == PK_TYPE_11B) {
 404                 priv->uSlot = C_SLOT_LONG;
 405                 priv->uSIFS = C_SIFS_BG;
 406                 priv->uDIFS = C_SIFS_BG + 2 * C_SLOT_LONG;
 407                 priv->uCwMin = C_CWMIN_B;
 408                 max_min = 5;
 409         } else {/* PK_TYPE_11GA & PK_TYPE_11GB */
 410                 u8 rate = 0;
 411                 bool ofdm_rate = false;
 412                 unsigned int ii = 0;
 413                 PWLAN_IE_SUPP_RATES item_rates = NULL;
 414
 415                 priv->uSIFS = C_SIFS_BG;
 416
 417                 if (priv->bShortSlotTime)
 418                         priv->uSlot = C_SLOT_SHORT;
 419                 else
 420                         priv->uSlot = C_SLOT_LONG;
 421
 422                 priv->uDIFS = C_SIFS_BG + 2 * priv->uSlot;
 423
 424                 item_rates =
 425                         (PWLAN_IE_SUPP_RATES)priv->vnt_mgmt.abyCurrSuppRates;
 426
 427                 for (ii = 0; ii < item_rates->len; ii++) {
 428                         rate = (u8)(item_rates->abyRates[ii] & 0x7f);
 429                         if (RATEwGetRateIdx(rate) > RATE_11M) {
 430                                 ofdm_rate = true;
 431                                 break;
 432                         }
 433                 }
 434
 435                 if (ofdm_rate == false) {
 436                         item_rates = (PWLAN_IE_SUPP_RATES)priv->vnt_mgmt
 437                                 .abyCurrExtSuppRates;
 438                         for (ii = 0; ii < item_rates->len; ii++) {
 439                                 rate = (u8)(item_rates->abyRates[ii] & 0x7f);
 440                                 if (RATEwGetRateIdx(rate) > RATE_11M) {
 441                                         ofdm_rate = true;
 442                                         break;
 443                                 }
 444                         }
 445                 }
 446
 447                 if (ofdm_rate == true) {
 448                         priv->uCwMin = C_CWMIN_A;
 449                         max_min = 4;
 450                 } else {
 451                         priv->uCwMin = C_CWMIN_B;
 452                         max_min = 5;
 453                         }
 454         }
 455
 456         priv->uCwMax = C_CWMAX;
 457         priv->uEIFS = C_EIFS;
 458
 459         data[0] = (u8)priv->uSIFS;
 460         data[1] = (u8)priv->uDIFS;
 461         data[2] = (u8)priv->uEIFS;
 462         data[3] = (u8)priv->uSlot;
 463
 464         vnt_control_out(priv, MESSAGE_TYPE_WRITE, MAC_REG_SIFS,
 465                 MESSAGE_REQUEST_MACREG, 4, &data[0]);
 466
 467         max_min |= 0xa0;
 468
 469         vnt_control_out(priv, MESSAGE_TYPE_WRITE, MAC_REG_CWMAXMIN0,
 470                 MESSAGE_REQUEST_MACREG, 1, &max_min);
 471 }
 472
 473 void CARDvUpdateBasicTopRate(struct vnt_private *priv)
 474 {
 475         u8 top_ofdm = RATE_24M, top_cck = RATE_1M;
 476         u8 i;
 477
 478         /*Determines the highest basic rate.*/
 479         for (i = RATE_54M; i >= RATE_6M; i--) {
 480                 if (priv->wBasicRate & (u16)(1 << i)) {
 481                         top_ofdm = i;
 482                         break;
 483                 }
 484         }
 485
 486         priv->byTopOFDMBasicRate = top_ofdm;
 487
 488         for (i = RATE_11M;; i--) {
 489                 if (priv->wBasicRate & (u16)(1 << i)) {
 490                         top_cck = i;
 491                         break;
 492                 }
 493                 if (i == RATE_1M)
 494                         break;
 495         }
 496
 497         priv->byTopCCKBasicRate = top_cck;
 498  }
 499
 500 /*
 501  * Description: Set NIC Tx Basic Rate
 502  *
 503  * Parameters:
 504  *  In:
 505  *      pDevice         - The adapter to be set
 506  *      wBasicRate      - Basic Rate to be set
 507  *  Out:
 508  *      none
 509  *
 510  * Return Value: true if succeeded; false if failed.
 511  *
 512  */
 513 void CARDbAddBasicRate(struct vnt_private *priv, u16 rate_idx)
 514 {
 515
 516         priv->wBasicRate |= (1 << rate_idx);
 517
 518         /*Determines the highest basic rate.*/
 519         CARDvUpdateBasicTopRate(priv);
 520 }
 521
 522 int CARDbIsOFDMinBasicRate(struct vnt_private *priv)
 523 {
 524         int ii;
 525
 526         for (ii = RATE_54M; ii >= RATE_6M; ii--) {
 527                 if ((priv->wBasicRate) & ((u16)(1 << ii)))
 528                         return true;
 529         }
 530
 531         return false;
 532 }
 533
 534 u8 CARDbyGetPktType(struct vnt_private *priv)
 535 {
 536
 537         if (priv->byBBType == BB_TYPE_11A || priv->byBBType == BB_TYPE_11B)
 538                 return (u8)priv->byBBType;
 539         else if (CARDbIsOFDMinBasicRate(priv))
 540                 return PK_TYPE_11GA;
 541         else
 542                 return PK_TYPE_11GB;
 543 }
 544
 545 /*
 546  * Description: Calculate TSF offset of two TSF input
 547  *              Get TSF Offset from RxBCN's TSF and local TSF
 548  *
 549  * Parameters:
 550  *  In:
 551  *      rx_rate - rx rate.
 552  *      tsf1    - Rx BCN's TSF
 553  *      tsf2    - Local TSF
 554  *  Out:
 555  *      none
 556  *
 557  * Return Value: TSF Offset value
 558  *
 559  */
 560 u64 CARDqGetTSFOffset(u8 rx_rate, u64 tsf1, u64 tsf2)
 561 {
 562         u64 tsf_offset = 0;
 563         u16 rx_bcn_offset = 0;
 564
 565         rx_bcn_offset = cwRXBCNTSFOff[rx_rate % MAX_RATE];
 566
 567         tsf2 += (u64)rx_bcn_offset;
 568
 569         tsf_offset = tsf1 - tsf2;
 570
 571         return tsf_offset;
 572 }
 573
 574 /*
 575  * Description: Sync. TSF counter to BSS
 576  *              Get TSF offset and write to HW
 577  *
 578  * Parameters:
 579  *  In:
 580  *      priv            - The adapter to be sync.
 581  *      time_stamp      - Rx BCN's TSF
 582  *      local_tsf       - Local TSF
 583  *  Out:
 584  *      none
 585  *
 586  * Return Value: none
 587  *
 588  */
 589 void CARDvAdjustTSF(struct vnt_private *priv, u8 rx_rate,
 590                 u64 time_stamp, u64 local_tsf)
 591 {
 592         u64 tsf_offset = 0;
 593         u8 data[8];
 594
 595         tsf_offset = CARDqGetTSFOffset(rx_rate, time_stamp, local_tsf);
 596
 597         data[0] = (u8)tsf_offset;
 598         data[1] = (u8)(tsf_offset >> 8);
 599         data[2] = (u8)(tsf_offset >> 16);
 600         data[3] = (u8)(tsf_offset >> 24);
 601         data[4] = (u8)(tsf_offset >> 32);
 602         data[5] = (u8)(tsf_offset >> 40);
 603         data[6] = (u8)(tsf_offset >> 48);
 604         data[7] = (u8)(tsf_offset >> 56);
 605
 606         vnt_control_out(priv, MESSAGE_TYPE_SET_TSFTBTT,
 607                 MESSAGE_REQUEST_TSF, 0, 8, data);
 608 }
 609 /*
 610  * Description: Read NIC TSF counter
 611  *              Get local TSF counter
 612  *
 613  * Parameters:
 614  *  In:
 615  *      priv            - The adapter to be read
 616  *  Out:
 617  *      current_tsf     - Current TSF counter
 618  *
 619  * Return Value: true if success; otherwise false
 620  *
 621  */
 622 bool CARDbGetCurrentTSF(struct vnt_private *priv, u64 *current_tsf)
 623 {
 624
 625         *current_tsf = priv->qwCurrTSF;
 626
 627         return true;
 628 }
 629
 630 /*
 631  * Description: Clear NIC TSF counter
 632  *              Clear local TSF counter
 633  *
 634  * Parameters:
 635  *  In:
 636  *      priv    - The adapter to be read
 637  *
 638  * Return Value: true if success; otherwise false
 639  *
 640  */
 641 bool CARDbClearCurrentTSF(struct vnt_private *priv)
 642 {
 643
 644         MACvRegBitsOn(priv, MAC_REG_TFTCTL, TFTCTL_TSFCNTRST);
 645
 646         priv->qwCurrTSF = 0;
 647
 648         return true;
 649 }
 650
 651 /*
 652  * Description: Read NIC TSF counter
 653  *              Get NEXTTBTT from adjusted TSF and Beacon Interval
 654  *
 655  * Parameters:
 656  *  In:
 657  *      tsf             - Current TSF counter
 658  *      beacon_interval - Beacon Interval
 659  *  Out:
 660  *      tsf             - Current TSF counter
 661  *
 662  * Return Value: TSF value of next Beacon
 663  *
 664  */
 665 u64 CARDqGetNextTBTT(u64 tsf, u16 beacon_interval)
 666 {
 667         u32 beacon_int;
 668
 669         beacon_int = beacon_interval * 1024;
 670
 671         /* Next TBTT =
 672         *       ((local_current_TSF / beacon_interval) + 1) * beacon_interval
 673         */
 674         if (beacon_int) {
 675                 do_div(tsf, beacon_int);
 676                 tsf += 1;
 677                 tsf *= beacon_int;
 678         }
 679
 680         return tsf;
 681 }
 682
 683 /*
 684  * Description: Set NIC TSF counter for first Beacon time
 685  *              Get NEXTTBTT from adjusted TSF and Beacon Interval
 686  *
 687  * Parameters:
 688  *  In:
 689  *      dwIoBase        - IO Base
 690  *      beacon_interval - Beacon Interval
 691  *  Out:
 692  *      none
 693  *
 694  * Return Value: none
 695  *
 696  */
 697 void CARDvSetFirstNextTBTT(struct vnt_private *priv, u16 beacon_interval)
 698 {
 699         u64 next_tbtt = 0;
 700         u8 data[8];
 701
 702         CARDbClearCurrentTSF(priv);
 703
 704         next_tbtt = CARDqGetNextTBTT(next_tbtt, beacon_interval);
 705
 706         data[0] = (u8)next_tbtt;
 707         data[1] = (u8)(next_tbtt >> 8);
 708         data[2] = (u8)(next_tbtt >> 16);
 709         data[3] = (u8)(next_tbtt >> 24);
 710         data[4] = (u8)(next_tbtt >> 32);
 711         data[5] = (u8)(next_tbtt >> 40);
 712         data[6] = (u8)(next_tbtt >> 48);
 713         data[7] = (u8)(next_tbtt >> 56);
 714
 715         vnt_control_out(priv, MESSAGE_TYPE_SET_TSFTBTT,
 716                 MESSAGE_REQUEST_TBTT, 0, 8, data);
 717
 718         return;
 719 }
 720
 721 /*
 722  * Description: Sync NIC TSF counter for Beacon time
 723  *              Get NEXTTBTT and write to HW
 724  *
 725  * Parameters:
 726  *  In:
 727  *      priv            - The adapter to be set
 728  *      tsf             - Current TSF counter
 729  *      beacon_interval - Beacon Interval
 730  *  Out:
 731  *      none
 732  *
 733  * Return Value: none
 734  *
 735  */
 736 void CARDvUpdateNextTBTT(struct vnt_private *priv, u64 tsf,
 737                         u16 beacon_interval)
 738 {
 739         u8 data[8];
 740
 741         tsf = CARDqGetNextTBTT(tsf, beacon_interval);
 742
 743         data[0] = (u8)tsf;
 744         data[1] = (u8)(tsf >> 8);
 745         data[2] = (u8)(tsf >> 16);
 746         data[3] = (u8)(tsf >> 24);
 747         data[4] = (u8)(tsf >> 32);
 748         data[5] = (u8)(tsf >> 40);
 749         data[6] = (u8)(tsf >> 48);
 750         data[7] = (u8)(tsf >> 56);
 751
 752         vnt_control_out(priv, MESSAGE_TYPE_SET_TSFTBTT,
 753                 MESSAGE_REQUEST_TBTT, 0, 8, data);
 754
 755         dev_dbg(&priv->usb->dev, "%s TBTT: %8llx\n", __func__, tsf);
 756
 757         return;
 758 }
 759
 760 /*
 761  * Description: Turn off Radio power
 762  *
 763  * Parameters:
 764  *  In:
 765  *      priv         - The adapter to be turned off
 766  *  Out:
 767  *      none
 768  *
 769  * Return Value: true if success; otherwise false
 770  *
 771  */
 772 int CARDbRadioPowerOff(struct vnt_private *priv)
 773 {
 774         int ret = true;
 775
 776         priv->bRadioOff = true;
 777
 778         switch (priv->byRFType) {
 779         case RF_AL2230:
 780         case RF_AL2230S:
 781         case RF_AIROHA7230:
 782         case RF_VT3226:
 783         case RF_VT3226D0:
 784         case RF_VT3342A0:
 785                 MACvRegBitsOff(priv, MAC_REG_SOFTPWRCTL,
 786                                 (SOFTPWRCTL_SWPE2 | SOFTPWRCTL_SWPE3));
 787                 break;
 788         }
 789
 790         MACvRegBitsOff(priv, MAC_REG_HOSTCR, HOSTCR_RXON);
 791
 792         BBvSetDeepSleep(priv);
 793
 794         return ret;
 795 }
 796
 797 /*
 798  * Description: Turn on Radio power
 799  *
 800  * Parameters:
 801  *  In:
 802  *      priv         - The adapter to be turned on
 803  *  Out:
 804  *      none
 805  *
 806  * Return Value: true if success; otherwise false
 807  *
 808  */
 809 int CARDbRadioPowerOn(struct vnt_private *priv)
 810 {
 811         int ret = true;
 812
 813         if (priv->bHWRadioOff == true || priv->bRadioControlOff == true)
 814                 return false;
 815
 816         priv->bRadioOff = false;
 817
 818         BBvExitDeepSleep(priv);
 819
 820         MACvRegBitsOn(priv, MAC_REG_HOSTCR, HOSTCR_RXON);
 821
 822         switch (priv->byRFType) {
 823         case RF_AL2230:
 824         case RF_AL2230S:
 825         case RF_AIROHA7230:
 826         case RF_VT3226:
 827         case RF_VT3226D0:
 828         case RF_VT3342A0:
 829                 MACvRegBitsOn(priv, MAC_REG_SOFTPWRCTL,
 830                         (SOFTPWRCTL_SWPE2 | SOFTPWRCTL_SWPE3));
 831                 break;
 832         }
 833
 834         return ret;
 835 }
 836
 837 void CARDvSetBSSMode(struct vnt_private *priv)
 838 {
 839         if (priv->byRFType == RF_AIROHA7230 && priv->byBBType == BB_TYPE_11A)
 840                 MACvSetBBType(priv, BB_TYPE_11G);
 841         else
 842                 MACvSetBBType(priv, priv->byBBType);
 843
 844         priv->byPacketType = CARDbyGetPktType(priv);
 845
 846         if (priv->byBBType == BB_TYPE_11A)
 847                 vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG, 0x88, 0x03);
 848         else if (priv->byBBType == BB_TYPE_11B)
 849                 vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG, 0x88, 0x02);
 850         else if (priv->byBBType == BB_TYPE_11G)
 851                 vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG, 0x88, 0x08);
 852
 853         vUpdateIFS(priv);
 854         CARDvSetRSPINF(priv, (u8)priv->byBBType);
 855
 856         if (priv->byBBType == BB_TYPE_11A) {
 857                 if (priv->byRFType == RF_AIROHA7230) {
 858                         priv->abyBBVGA[0] = 0x20;
 859
 860                         vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG,
 861                                                 0xe7, priv->abyBBVGA[0]);
 862                 }
 863
 864                 priv->abyBBVGA[2] = 0x10;
 865                 priv->abyBBVGA[3] = 0x10;
 866         } else {
 867                 if (priv->byRFType == RF_AIROHA7230) {
 868                         priv->abyBBVGA[0] = 0x1c;
 869
 870                         vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG,
 871                                                 0xe7, priv->abyBBVGA[0]);
 872                 }
 873
 874                 priv->abyBBVGA[2] = 0x0;
 875                 priv->abyBBVGA[3] = 0x0;
 876         }
 877 }