card.c revision 75ef1b5195311993d148ca98e061f08f9f573d6d
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 * vnt_set_rspinf - Set RSPINF 24 * vnt_update_ifs - Update slotTime,SIFS,DIFS, and EIFS 25 * vnt_update_top_rates - Update BasicTopRate 26 * vnt_add_basic_rate - Add to BasicRateSet 27 * CARDbSetBasicRate - Set Basic Tx Rate 28 * vnt_ofdm_min_rate - Check if any OFDM rate is in BasicRateSet 29 * CARDvSetLoopbackMode - Set Loopback mode 30 * CARDbSoftwareReset - Sortware reset NIC 31 * vnt_get_tsf_offset - Calculate TSFOffset 32 * vnt_get_current_tsf - Read Current NIC TSF counter 33 * vnt_get_next_tbtt - 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 vnt_update_ifs(). 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 65static 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 */ 78void vnt_set_channel(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 */ 131static u16 vnt_get_cck_rate(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 */ 157static u16 vnt_get_ofdm_rate(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 (!vnt_ofdm_min_rate(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 */ 200static void vnt_calculate_ofdm_rate(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 294void vnt_set_rspinf(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 vnt_get_cck_rate(priv, RATE_1M), PK_TYPE_11B, &phy[0]); 305 306 /*RSPINF_b_2*/ 307 BBvCalculateParameter(priv, 14, 308 vnt_get_cck_rate(priv, RATE_2M), PK_TYPE_11B, &phy[1]); 309 310 /*RSPINF_b_5*/ 311 BBvCalculateParameter(priv, 14, 312 vnt_get_cck_rate(priv, RATE_5M), PK_TYPE_11B, &phy[2]); 313 314 /*RSPINF_b_11*/ 315 BBvCalculateParameter(priv, 14, 316 vnt_get_cck_rate(priv, RATE_11M), PK_TYPE_11B, &phy[3]); 317 318 319 /*RSPINF_a_6*/ 320 vnt_calculate_ofdm_rate(RATE_6M, bb_type, &tx_rate[0], &rsv_time[0]); 321 322 /*RSPINF_a_9*/ 323 vnt_calculate_ofdm_rate(RATE_9M, bb_type, &tx_rate[1], &rsv_time[1]); 324 325 /*RSPINF_a_12*/ 326 vnt_calculate_ofdm_rate(RATE_12M, bb_type, &tx_rate[2], &rsv_time[2]); 327 328 /*RSPINF_a_18*/ 329 vnt_calculate_ofdm_rate(RATE_18M, bb_type, &tx_rate[3], &rsv_time[3]); 330 331 /*RSPINF_a_24*/ 332 vnt_calculate_ofdm_rate(RATE_24M, bb_type, &tx_rate[4], &rsv_time[4]); 333 334 /*RSPINF_a_36*/ 335 vnt_calculate_ofdm_rate(vnt_get_ofdm_rate(priv, RATE_36M), 336 bb_type, &tx_rate[5], &rsv_time[5]); 337 338 /*RSPINF_a_48*/ 339 vnt_calculate_ofdm_rate(vnt_get_ofdm_rate(priv, RATE_48M), 340 bb_type, &tx_rate[6], &rsv_time[6]); 341 342 /*RSPINF_a_54*/ 343 vnt_calculate_ofdm_rate(vnt_get_ofdm_rate(priv, RATE_54M), 344 bb_type, &tx_rate[7], &rsv_time[7]); 345 346 /*RSPINF_a_72*/ 347 vnt_calculate_ofdm_rate(vnt_get_ofdm_rate(priv, RATE_54M), 348 bb_type, &tx_rate[8], &rsv_time[8]); 349 350 put_unaligned(phy[0].len, (u16 *)&data[0]); 351 data[2] = phy[0].signal; 352 data[3] = phy[0].service; 353 354 put_unaligned(phy[1].len, (u16 *)&data[4]); 355 data[6] = phy[1].signal; 356 data[7] = phy[1].service; 357 358 put_unaligned(phy[2].len, (u16 *)&data[8]); 359 data[10] = phy[2].signal; 360 data[11] = phy[2].service; 361 362 put_unaligned(phy[3].len, (u16 *)&data[12]); 363 data[14] = phy[3].signal; 364 data[15] = phy[3].service; 365 366 for (i = 0; i < 9; i++) { 367 data[16 + i * 2] = tx_rate[i]; 368 data[16 + i * 2 + 1] = rsv_time[i]; 369 } 370 371 vnt_control_out(priv, MESSAGE_TYPE_WRITE, 372 MAC_REG_RSPINF_B_1, MESSAGE_REQUEST_MACREG, 34, &data[0]); 373} 374 375/* 376 * Description: Update IFS 377 * 378 * Parameters: 379 * In: 380 * priv - The adapter to be set 381 * Out: 382 * none 383 * 384 * Return Value: None. 385 * 386 */ 387void vnt_update_ifs(struct vnt_private *priv) 388{ 389 u8 max_min = 0; 390 u8 data[4]; 391 392 if (priv->byPacketType == PK_TYPE_11A) { 393 priv->uSlot = C_SLOT_SHORT; 394 priv->uSIFS = C_SIFS_A; 395 priv->uDIFS = C_SIFS_A + 2 * C_SLOT_SHORT; 396 priv->uCwMin = C_CWMIN_A; 397 max_min = 4; 398 } else if (priv->byPacketType == PK_TYPE_11B) { 399 priv->uSlot = C_SLOT_LONG; 400 priv->uSIFS = C_SIFS_BG; 401 priv->uDIFS = C_SIFS_BG + 2 * C_SLOT_LONG; 402 priv->uCwMin = C_CWMIN_B; 403 max_min = 5; 404 } else {/* PK_TYPE_11GA & PK_TYPE_11GB */ 405 u8 rate = 0; 406 bool ofdm_rate = false; 407 unsigned int ii = 0; 408 PWLAN_IE_SUPP_RATES item_rates = NULL; 409 410 priv->uSIFS = C_SIFS_BG; 411 412 if (priv->bShortSlotTime) 413 priv->uSlot = C_SLOT_SHORT; 414 else 415 priv->uSlot = C_SLOT_LONG; 416 417 priv->uDIFS = C_SIFS_BG + 2 * priv->uSlot; 418 419 item_rates = 420 (PWLAN_IE_SUPP_RATES)priv->vnt_mgmt.abyCurrSuppRates; 421 422 for (ii = 0; ii < item_rates->len; ii++) { 423 rate = (u8)(item_rates->abyRates[ii] & 0x7f); 424 if (RATEwGetRateIdx(rate) > RATE_11M) { 425 ofdm_rate = true; 426 break; 427 } 428 } 429 430 if (ofdm_rate == false) { 431 item_rates = (PWLAN_IE_SUPP_RATES)priv->vnt_mgmt 432 .abyCurrExtSuppRates; 433 for (ii = 0; ii < item_rates->len; ii++) { 434 rate = (u8)(item_rates->abyRates[ii] & 0x7f); 435 if (RATEwGetRateIdx(rate) > RATE_11M) { 436 ofdm_rate = true; 437 break; 438 } 439 } 440 } 441 442 if (ofdm_rate == true) { 443 priv->uCwMin = C_CWMIN_A; 444 max_min = 4; 445 } else { 446 priv->uCwMin = C_CWMIN_B; 447 max_min = 5; 448 } 449 } 450 451 priv->uCwMax = C_CWMAX; 452 priv->uEIFS = C_EIFS; 453 454 data[0] = (u8)priv->uSIFS; 455 data[1] = (u8)priv->uDIFS; 456 data[2] = (u8)priv->uEIFS; 457 data[3] = (u8)priv->uSlot; 458 459 vnt_control_out(priv, MESSAGE_TYPE_WRITE, MAC_REG_SIFS, 460 MESSAGE_REQUEST_MACREG, 4, &data[0]); 461 462 max_min |= 0xa0; 463 464 vnt_control_out(priv, MESSAGE_TYPE_WRITE, MAC_REG_CWMAXMIN0, 465 MESSAGE_REQUEST_MACREG, 1, &max_min); 466} 467 468void vnt_update_top_rates(struct vnt_private *priv) 469{ 470 u8 top_ofdm = RATE_24M, top_cck = RATE_1M; 471 u8 i; 472 473 /*Determines the highest basic rate.*/ 474 for (i = RATE_54M; i >= RATE_6M; i--) { 475 if (priv->wBasicRate & (u16)(1 << i)) { 476 top_ofdm = i; 477 break; 478 } 479 } 480 481 priv->byTopOFDMBasicRate = top_ofdm; 482 483 for (i = RATE_11M;; i--) { 484 if (priv->wBasicRate & (u16)(1 << i)) { 485 top_cck = i; 486 break; 487 } 488 if (i == RATE_1M) 489 break; 490 } 491 492 priv->byTopCCKBasicRate = top_cck; 493 } 494 495/* 496 * Description: Set NIC Tx Basic Rate 497 * 498 * Parameters: 499 * In: 500 * pDevice - The adapter to be set 501 * wBasicRate - Basic Rate to be set 502 * Out: 503 * none 504 * 505 * Return Value: true if succeeded; false if failed. 506 * 507 */ 508void vnt_add_basic_rate(struct vnt_private *priv, u16 rate_idx) 509{ 510 511 priv->wBasicRate |= (1 << rate_idx); 512 513 /*Determines the highest basic rate.*/ 514 vnt_update_top_rates(priv); 515} 516 517int vnt_ofdm_min_rate(struct vnt_private *priv) 518{ 519 int ii; 520 521 for (ii = RATE_54M; ii >= RATE_6M; ii--) { 522 if ((priv->wBasicRate) & ((u16)(1 << ii))) 523 return true; 524 } 525 526 return false; 527} 528 529u8 vnt_get_pkt_type(struct vnt_private *priv) 530{ 531 532 if (priv->byBBType == BB_TYPE_11A || priv->byBBType == BB_TYPE_11B) 533 return (u8)priv->byBBType; 534 else if (vnt_ofdm_min_rate(priv)) 535 return PK_TYPE_11GA; 536 else 537 return PK_TYPE_11GB; 538} 539 540/* 541 * Description: Calculate TSF offset of two TSF input 542 * Get TSF Offset from RxBCN's TSF and local TSF 543 * 544 * Parameters: 545 * In: 546 * rx_rate - rx rate. 547 * tsf1 - Rx BCN's TSF 548 * tsf2 - Local TSF 549 * Out: 550 * none 551 * 552 * Return Value: TSF Offset value 553 * 554 */ 555u64 vnt_get_tsf_offset(u8 rx_rate, u64 tsf1, u64 tsf2) 556{ 557 u64 tsf_offset = 0; 558 u16 rx_bcn_offset = 0; 559 560 rx_bcn_offset = cwRXBCNTSFOff[rx_rate % MAX_RATE]; 561 562 tsf2 += (u64)rx_bcn_offset; 563 564 tsf_offset = tsf1 - tsf2; 565 566 return tsf_offset; 567} 568 569/* 570 * Description: Sync. TSF counter to BSS 571 * Get TSF offset and write to HW 572 * 573 * Parameters: 574 * In: 575 * priv - The adapter to be sync. 576 * time_stamp - Rx BCN's TSF 577 * local_tsf - Local TSF 578 * Out: 579 * none 580 * 581 * Return Value: none 582 * 583 */ 584void vnt_adjust_tsf(struct vnt_private *priv, u8 rx_rate, 585 u64 time_stamp, u64 local_tsf) 586{ 587 u64 tsf_offset = 0; 588 u8 data[8]; 589 590 tsf_offset = vnt_get_tsf_offset(rx_rate, time_stamp, local_tsf); 591 592 data[0] = (u8)tsf_offset; 593 data[1] = (u8)(tsf_offset >> 8); 594 data[2] = (u8)(tsf_offset >> 16); 595 data[3] = (u8)(tsf_offset >> 24); 596 data[4] = (u8)(tsf_offset >> 32); 597 data[5] = (u8)(tsf_offset >> 40); 598 data[6] = (u8)(tsf_offset >> 48); 599 data[7] = (u8)(tsf_offset >> 56); 600 601 vnt_control_out(priv, MESSAGE_TYPE_SET_TSFTBTT, 602 MESSAGE_REQUEST_TSF, 0, 8, data); 603} 604/* 605 * Description: Read NIC TSF counter 606 * Get local TSF counter 607 * 608 * Parameters: 609 * In: 610 * priv - The adapter to be read 611 * Out: 612 * current_tsf - Current TSF counter 613 * 614 * Return Value: true if success; otherwise false 615 * 616 */ 617bool vnt_get_current_tsf(struct vnt_private *priv, u64 *current_tsf) 618{ 619 620 *current_tsf = priv->qwCurrTSF; 621 622 return true; 623} 624 625/* 626 * Description: Clear NIC TSF counter 627 * Clear local TSF counter 628 * 629 * Parameters: 630 * In: 631 * priv - The adapter to be read 632 * 633 * Return Value: true if success; otherwise false 634 * 635 */ 636bool vnt_clear_current_tsf(struct vnt_private *priv) 637{ 638 639 MACvRegBitsOn(priv, MAC_REG_TFTCTL, TFTCTL_TSFCNTRST); 640 641 priv->qwCurrTSF = 0; 642 643 return true; 644} 645 646/* 647 * Description: Read NIC TSF counter 648 * Get NEXTTBTT from adjusted TSF and Beacon Interval 649 * 650 * Parameters: 651 * In: 652 * tsf - Current TSF counter 653 * beacon_interval - Beacon Interval 654 * Out: 655 * tsf - Current TSF counter 656 * 657 * Return Value: TSF value of next Beacon 658 * 659 */ 660u64 vnt_get_next_tbtt(u64 tsf, u16 beacon_interval) 661{ 662 u32 beacon_int; 663 664 beacon_int = beacon_interval * 1024; 665 666 /* Next TBTT = 667 * ((local_current_TSF / beacon_interval) + 1) * beacon_interval 668 */ 669 if (beacon_int) { 670 do_div(tsf, beacon_int); 671 tsf += 1; 672 tsf *= beacon_int; 673 } 674 675 return tsf; 676} 677 678/* 679 * Description: Set NIC TSF counter for first Beacon time 680 * Get NEXTTBTT from adjusted TSF and Beacon Interval 681 * 682 * Parameters: 683 * In: 684 * dwIoBase - IO Base 685 * beacon_interval - Beacon Interval 686 * Out: 687 * none 688 * 689 * Return Value: none 690 * 691 */ 692void CARDvSetFirstNextTBTT(struct vnt_private *priv, u16 beacon_interval) 693{ 694 u64 next_tbtt = 0; 695 u8 data[8]; 696 697 vnt_clear_current_tsf(priv); 698 699 next_tbtt = vnt_get_next_tbtt(next_tbtt, beacon_interval); 700 701 data[0] = (u8)next_tbtt; 702 data[1] = (u8)(next_tbtt >> 8); 703 data[2] = (u8)(next_tbtt >> 16); 704 data[3] = (u8)(next_tbtt >> 24); 705 data[4] = (u8)(next_tbtt >> 32); 706 data[5] = (u8)(next_tbtt >> 40); 707 data[6] = (u8)(next_tbtt >> 48); 708 data[7] = (u8)(next_tbtt >> 56); 709 710 vnt_control_out(priv, MESSAGE_TYPE_SET_TSFTBTT, 711 MESSAGE_REQUEST_TBTT, 0, 8, data); 712 713 return; 714} 715 716/* 717 * Description: Sync NIC TSF counter for Beacon time 718 * Get NEXTTBTT and write to HW 719 * 720 * Parameters: 721 * In: 722 * priv - The adapter to be set 723 * tsf - Current TSF counter 724 * beacon_interval - Beacon Interval 725 * Out: 726 * none 727 * 728 * Return Value: none 729 * 730 */ 731void CARDvUpdateNextTBTT(struct vnt_private *priv, u64 tsf, 732 u16 beacon_interval) 733{ 734 u8 data[8]; 735 736 tsf = vnt_get_next_tbtt(tsf, beacon_interval); 737 738 data[0] = (u8)tsf; 739 data[1] = (u8)(tsf >> 8); 740 data[2] = (u8)(tsf >> 16); 741 data[3] = (u8)(tsf >> 24); 742 data[4] = (u8)(tsf >> 32); 743 data[5] = (u8)(tsf >> 40); 744 data[6] = (u8)(tsf >> 48); 745 data[7] = (u8)(tsf >> 56); 746 747 vnt_control_out(priv, MESSAGE_TYPE_SET_TSFTBTT, 748 MESSAGE_REQUEST_TBTT, 0, 8, data); 749 750 dev_dbg(&priv->usb->dev, "%s TBTT: %8llx\n", __func__, tsf); 751 752 return; 753} 754 755/* 756 * Description: Turn off Radio power 757 * 758 * Parameters: 759 * In: 760 * priv - The adapter to be turned off 761 * Out: 762 * none 763 * 764 * Return Value: true if success; otherwise false 765 * 766 */ 767int CARDbRadioPowerOff(struct vnt_private *priv) 768{ 769 int ret = true; 770 771 priv->bRadioOff = true; 772 773 switch (priv->byRFType) { 774 case RF_AL2230: 775 case RF_AL2230S: 776 case RF_AIROHA7230: 777 case RF_VT3226: 778 case RF_VT3226D0: 779 case RF_VT3342A0: 780 MACvRegBitsOff(priv, MAC_REG_SOFTPWRCTL, 781 (SOFTPWRCTL_SWPE2 | SOFTPWRCTL_SWPE3)); 782 break; 783 } 784 785 MACvRegBitsOff(priv, MAC_REG_HOSTCR, HOSTCR_RXON); 786 787 BBvSetDeepSleep(priv); 788 789 return ret; 790} 791 792/* 793 * Description: Turn on Radio power 794 * 795 * Parameters: 796 * In: 797 * priv - The adapter to be turned on 798 * Out: 799 * none 800 * 801 * Return Value: true if success; otherwise false 802 * 803 */ 804int CARDbRadioPowerOn(struct vnt_private *priv) 805{ 806 int ret = true; 807 808 if (priv->bHWRadioOff == true || priv->bRadioControlOff == true) 809 return false; 810 811 priv->bRadioOff = false; 812 813 BBvExitDeepSleep(priv); 814 815 MACvRegBitsOn(priv, MAC_REG_HOSTCR, HOSTCR_RXON); 816 817 switch (priv->byRFType) { 818 case RF_AL2230: 819 case RF_AL2230S: 820 case RF_AIROHA7230: 821 case RF_VT3226: 822 case RF_VT3226D0: 823 case RF_VT3342A0: 824 MACvRegBitsOn(priv, MAC_REG_SOFTPWRCTL, 825 (SOFTPWRCTL_SWPE2 | SOFTPWRCTL_SWPE3)); 826 break; 827 } 828 829 return ret; 830} 831 832void CARDvSetBSSMode(struct vnt_private *priv) 833{ 834 if (priv->byRFType == RF_AIROHA7230 && priv->byBBType == BB_TYPE_11A) 835 MACvSetBBType(priv, BB_TYPE_11G); 836 else 837 MACvSetBBType(priv, priv->byBBType); 838 839 priv->byPacketType = vnt_get_pkt_type(priv); 840 841 if (priv->byBBType == BB_TYPE_11A) 842 vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG, 0x88, 0x03); 843 else if (priv->byBBType == BB_TYPE_11B) 844 vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG, 0x88, 0x02); 845 else if (priv->byBBType == BB_TYPE_11G) 846 vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG, 0x88, 0x08); 847 848 vnt_update_ifs(priv); 849 vnt_set_rspinf(priv, (u8)priv->byBBType); 850 851 if (priv->byBBType == BB_TYPE_11A) { 852 if (priv->byRFType == RF_AIROHA7230) { 853 priv->abyBBVGA[0] = 0x20; 854 855 vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG, 856 0xe7, priv->abyBBVGA[0]); 857 } 858 859 priv->abyBBVGA[2] = 0x10; 860 priv->abyBBVGA[3] = 0x10; 861 } else { 862 if (priv->byRFType == RF_AIROHA7230) { 863 priv->abyBBVGA[0] = 0x1c; 864 865 vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG, 866 0xe7, priv->abyBBVGA[0]); 867 } 868 869 priv->abyBBVGA[2] = 0x0; 870 priv->abyBBVGA[3] = 0x0; 871 } 872} 873