card.c revision ee61fde2074fbcc7575e52206aba67853e0e56cc
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 * vnt_reset_next_tbtt - Set NIC Beacon time 35 * vnt_update_next_tbtt - Sync. NIC Beacon time 36 * vnt_radio_power_off - Turn Off NIC Radio Power 37 * vnt_radio_power_on - 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 vnt_mac_reg_bits_on(priv, MAC_REG_MACCR, MACCR_CLRNAV); 93 94 /* Set Channel[7] = 0 to tell H/W channel is changing now. */ 95 vnt_mac_reg_bits_off(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 vnt_get_phy_field(priv, 14, 304 vnt_get_cck_rate(priv, RATE_1M), PK_TYPE_11B, &phy[0]); 305 306 /*RSPINF_b_2*/ 307 vnt_get_phy_field(priv, 14, 308 vnt_get_cck_rate(priv, RATE_2M), PK_TYPE_11B, &phy[1]); 309 310 /*RSPINF_b_5*/ 311 vnt_get_phy_field(priv, 14, 312 vnt_get_cck_rate(priv, RATE_5M), PK_TYPE_11B, &phy[2]); 313 314 /*RSPINF_b_11*/ 315 vnt_get_phy_field(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 bool ofdm_rate = false; 406 unsigned int ii = 0; 407 408 priv->uSIFS = C_SIFS_BG; 409 410 if (priv->bShortSlotTime) 411 priv->uSlot = C_SLOT_SHORT; 412 else 413 priv->uSlot = C_SLOT_LONG; 414 415 priv->uDIFS = C_SIFS_BG + 2 * priv->uSlot; 416 417 for (ii = RATE_54M; ii >= RATE_6M; ii--) { 418 if (priv->wBasicRate & ((u32)(0x1 << ii))) { 419 ofdm_rate = true; 420 break; 421 } 422 } 423 424 if (ofdm_rate == true) { 425 priv->uCwMin = C_CWMIN_A; 426 max_min = 4; 427 } else { 428 priv->uCwMin = C_CWMIN_B; 429 max_min = 5; 430 } 431 } 432 433 priv->uCwMax = C_CWMAX; 434 priv->uEIFS = C_EIFS; 435 436 data[0] = (u8)priv->uSIFS; 437 data[1] = (u8)priv->uDIFS; 438 data[2] = (u8)priv->uEIFS; 439 data[3] = (u8)priv->uSlot; 440 441 vnt_control_out(priv, MESSAGE_TYPE_WRITE, MAC_REG_SIFS, 442 MESSAGE_REQUEST_MACREG, 4, &data[0]); 443 444 max_min |= 0xa0; 445 446 vnt_control_out(priv, MESSAGE_TYPE_WRITE, MAC_REG_CWMAXMIN0, 447 MESSAGE_REQUEST_MACREG, 1, &max_min); 448} 449 450void vnt_update_top_rates(struct vnt_private *priv) 451{ 452 u8 top_ofdm = RATE_24M, top_cck = RATE_1M; 453 u8 i; 454 455 /*Determines the highest basic rate.*/ 456 for (i = RATE_54M; i >= RATE_6M; i--) { 457 if (priv->wBasicRate & (u16)(1 << i)) { 458 top_ofdm = i; 459 break; 460 } 461 } 462 463 priv->byTopOFDMBasicRate = top_ofdm; 464 465 for (i = RATE_11M;; i--) { 466 if (priv->wBasicRate & (u16)(1 << i)) { 467 top_cck = i; 468 break; 469 } 470 if (i == RATE_1M) 471 break; 472 } 473 474 priv->byTopCCKBasicRate = top_cck; 475 } 476 477/* 478 * Description: Set NIC Tx Basic Rate 479 * 480 * Parameters: 481 * In: 482 * pDevice - The adapter to be set 483 * wBasicRate - Basic Rate to be set 484 * Out: 485 * none 486 * 487 * Return Value: true if succeeded; false if failed. 488 * 489 */ 490void vnt_add_basic_rate(struct vnt_private *priv, u16 rate_idx) 491{ 492 493 priv->wBasicRate |= (1 << rate_idx); 494 495 /*Determines the highest basic rate.*/ 496 vnt_update_top_rates(priv); 497} 498 499int vnt_ofdm_min_rate(struct vnt_private *priv) 500{ 501 int ii; 502 503 for (ii = RATE_54M; ii >= RATE_6M; ii--) { 504 if ((priv->wBasicRate) & ((u16)(1 << ii))) 505 return true; 506 } 507 508 return false; 509} 510 511u8 vnt_get_pkt_type(struct vnt_private *priv) 512{ 513 514 if (priv->byBBType == BB_TYPE_11A || priv->byBBType == BB_TYPE_11B) 515 return (u8)priv->byBBType; 516 else if (vnt_ofdm_min_rate(priv)) 517 return PK_TYPE_11GA; 518 else 519 return PK_TYPE_11GB; 520} 521 522/* 523 * Description: Calculate TSF offset of two TSF input 524 * Get TSF Offset from RxBCN's TSF and local TSF 525 * 526 * Parameters: 527 * In: 528 * rx_rate - rx rate. 529 * tsf1 - Rx BCN's TSF 530 * tsf2 - Local TSF 531 * Out: 532 * none 533 * 534 * Return Value: TSF Offset value 535 * 536 */ 537u64 vnt_get_tsf_offset(u8 rx_rate, u64 tsf1, u64 tsf2) 538{ 539 u64 tsf_offset = 0; 540 u16 rx_bcn_offset = 0; 541 542 rx_bcn_offset = cwRXBCNTSFOff[rx_rate % MAX_RATE]; 543 544 tsf2 += (u64)rx_bcn_offset; 545 546 tsf_offset = tsf1 - tsf2; 547 548 return tsf_offset; 549} 550 551/* 552 * Description: Sync. TSF counter to BSS 553 * Get TSF offset and write to HW 554 * 555 * Parameters: 556 * In: 557 * priv - The adapter to be sync. 558 * time_stamp - Rx BCN's TSF 559 * local_tsf - Local TSF 560 * Out: 561 * none 562 * 563 * Return Value: none 564 * 565 */ 566void vnt_adjust_tsf(struct vnt_private *priv, u8 rx_rate, 567 u64 time_stamp, u64 local_tsf) 568{ 569 u64 tsf_offset = 0; 570 u8 data[8]; 571 572 tsf_offset = vnt_get_tsf_offset(rx_rate, time_stamp, local_tsf); 573 574 data[0] = (u8)tsf_offset; 575 data[1] = (u8)(tsf_offset >> 8); 576 data[2] = (u8)(tsf_offset >> 16); 577 data[3] = (u8)(tsf_offset >> 24); 578 data[4] = (u8)(tsf_offset >> 32); 579 data[5] = (u8)(tsf_offset >> 40); 580 data[6] = (u8)(tsf_offset >> 48); 581 data[7] = (u8)(tsf_offset >> 56); 582 583 vnt_control_out(priv, MESSAGE_TYPE_SET_TSFTBTT, 584 MESSAGE_REQUEST_TSF, 0, 8, data); 585} 586/* 587 * Description: Read NIC TSF counter 588 * Get local TSF counter 589 * 590 * Parameters: 591 * In: 592 * priv - The adapter to be read 593 * Out: 594 * current_tsf - Current TSF counter 595 * 596 * Return Value: true if success; otherwise false 597 * 598 */ 599bool vnt_get_current_tsf(struct vnt_private *priv, u64 *current_tsf) 600{ 601 602 *current_tsf = priv->qwCurrTSF; 603 604 return true; 605} 606 607/* 608 * Description: Clear NIC TSF counter 609 * Clear local TSF counter 610 * 611 * Parameters: 612 * In: 613 * priv - The adapter to be read 614 * 615 * Return Value: true if success; otherwise false 616 * 617 */ 618bool vnt_clear_current_tsf(struct vnt_private *priv) 619{ 620 621 vnt_mac_reg_bits_on(priv, MAC_REG_TFTCTL, TFTCTL_TSFCNTRST); 622 623 priv->qwCurrTSF = 0; 624 625 return true; 626} 627 628/* 629 * Description: Read NIC TSF counter 630 * Get NEXTTBTT from adjusted TSF and Beacon Interval 631 * 632 * Parameters: 633 * In: 634 * tsf - Current TSF counter 635 * beacon_interval - Beacon Interval 636 * Out: 637 * tsf - Current TSF counter 638 * 639 * Return Value: TSF value of next Beacon 640 * 641 */ 642u64 vnt_get_next_tbtt(u64 tsf, u16 beacon_interval) 643{ 644 u32 beacon_int; 645 646 beacon_int = beacon_interval * 1024; 647 648 /* Next TBTT = 649 * ((local_current_TSF / beacon_interval) + 1) * beacon_interval 650 */ 651 if (beacon_int) { 652 do_div(tsf, beacon_int); 653 tsf += 1; 654 tsf *= beacon_int; 655 } 656 657 return tsf; 658} 659 660/* 661 * Description: Set NIC TSF counter for first Beacon time 662 * Get NEXTTBTT from adjusted TSF and Beacon Interval 663 * 664 * Parameters: 665 * In: 666 * dwIoBase - IO Base 667 * beacon_interval - Beacon Interval 668 * Out: 669 * none 670 * 671 * Return Value: none 672 * 673 */ 674void vnt_reset_next_tbtt(struct vnt_private *priv, u16 beacon_interval) 675{ 676 u64 next_tbtt = 0; 677 u8 data[8]; 678 679 vnt_clear_current_tsf(priv); 680 681 next_tbtt = vnt_get_next_tbtt(next_tbtt, beacon_interval); 682 683 data[0] = (u8)next_tbtt; 684 data[1] = (u8)(next_tbtt >> 8); 685 data[2] = (u8)(next_tbtt >> 16); 686 data[3] = (u8)(next_tbtt >> 24); 687 data[4] = (u8)(next_tbtt >> 32); 688 data[5] = (u8)(next_tbtt >> 40); 689 data[6] = (u8)(next_tbtt >> 48); 690 data[7] = (u8)(next_tbtt >> 56); 691 692 vnt_control_out(priv, MESSAGE_TYPE_SET_TSFTBTT, 693 MESSAGE_REQUEST_TBTT, 0, 8, data); 694 695 return; 696} 697 698/* 699 * Description: Sync NIC TSF counter for Beacon time 700 * Get NEXTTBTT and write to HW 701 * 702 * Parameters: 703 * In: 704 * priv - The adapter to be set 705 * tsf - Current TSF counter 706 * beacon_interval - Beacon Interval 707 * Out: 708 * none 709 * 710 * Return Value: none 711 * 712 */ 713void vnt_update_next_tbtt(struct vnt_private *priv, u64 tsf, 714 u16 beacon_interval) 715{ 716 u8 data[8]; 717 718 tsf = vnt_get_next_tbtt(tsf, beacon_interval); 719 720 data[0] = (u8)tsf; 721 data[1] = (u8)(tsf >> 8); 722 data[2] = (u8)(tsf >> 16); 723 data[3] = (u8)(tsf >> 24); 724 data[4] = (u8)(tsf >> 32); 725 data[5] = (u8)(tsf >> 40); 726 data[6] = (u8)(tsf >> 48); 727 data[7] = (u8)(tsf >> 56); 728 729 vnt_control_out(priv, MESSAGE_TYPE_SET_TSFTBTT, 730 MESSAGE_REQUEST_TBTT, 0, 8, data); 731 732 dev_dbg(&priv->usb->dev, "%s TBTT: %8llx\n", __func__, tsf); 733 734 return; 735} 736 737/* 738 * Description: Turn off Radio power 739 * 740 * Parameters: 741 * In: 742 * priv - The adapter to be turned off 743 * Out: 744 * none 745 * 746 * Return Value: true if success; otherwise false 747 * 748 */ 749int vnt_radio_power_off(struct vnt_private *priv) 750{ 751 int ret = true; 752 753 priv->bRadioOff = true; 754 755 switch (priv->byRFType) { 756 case RF_AL2230: 757 case RF_AL2230S: 758 case RF_AIROHA7230: 759 case RF_VT3226: 760 case RF_VT3226D0: 761 case RF_VT3342A0: 762 vnt_mac_reg_bits_off(priv, MAC_REG_SOFTPWRCTL, 763 (SOFTPWRCTL_SWPE2 | SOFTPWRCTL_SWPE3)); 764 break; 765 } 766 767 vnt_mac_reg_bits_off(priv, MAC_REG_HOSTCR, HOSTCR_RXON); 768 769 BBvSetDeepSleep(priv); 770 771 return ret; 772} 773 774/* 775 * Description: Turn on Radio power 776 * 777 * Parameters: 778 * In: 779 * priv - The adapter to be turned on 780 * Out: 781 * none 782 * 783 * Return Value: true if success; otherwise false 784 * 785 */ 786int vnt_radio_power_on(struct vnt_private *priv) 787{ 788 int ret = true; 789 790 if (priv->bHWRadioOff == true || priv->bRadioControlOff == true) 791 return false; 792 793 priv->bRadioOff = false; 794 795 BBvExitDeepSleep(priv); 796 797 vnt_mac_reg_bits_on(priv, MAC_REG_HOSTCR, HOSTCR_RXON); 798 799 switch (priv->byRFType) { 800 case RF_AL2230: 801 case RF_AL2230S: 802 case RF_AIROHA7230: 803 case RF_VT3226: 804 case RF_VT3226D0: 805 case RF_VT3342A0: 806 vnt_mac_reg_bits_on(priv, MAC_REG_SOFTPWRCTL, 807 (SOFTPWRCTL_SWPE2 | SOFTPWRCTL_SWPE3)); 808 break; 809 } 810 811 return ret; 812} 813 814void vnt_set_bss_mode(struct vnt_private *priv) 815{ 816 if (priv->byRFType == RF_AIROHA7230 && priv->byBBType == BB_TYPE_11A) 817 vnt_mac_set_bb_type(priv, BB_TYPE_11G); 818 else 819 vnt_mac_set_bb_type(priv, priv->byBBType); 820 821 priv->byPacketType = vnt_get_pkt_type(priv); 822 823 if (priv->byBBType == BB_TYPE_11A) 824 vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG, 0x88, 0x03); 825 else if (priv->byBBType == BB_TYPE_11B) 826 vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG, 0x88, 0x02); 827 else if (priv->byBBType == BB_TYPE_11G) 828 vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG, 0x88, 0x08); 829 830 vnt_update_ifs(priv); 831 vnt_set_rspinf(priv, (u8)priv->byBBType); 832 833 if (priv->byBBType == BB_TYPE_11A) { 834 if (priv->byRFType == RF_AIROHA7230) { 835 priv->abyBBVGA[0] = 0x20; 836 837 vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG, 838 0xe7, priv->abyBBVGA[0]); 839 } 840 841 priv->abyBBVGA[2] = 0x10; 842 priv->abyBBVGA[3] = 0x10; 843 } else { 844 if (priv->byRFType == RF_AIROHA7230) { 845 priv->abyBBVGA[0] = 0x1c; 846 847 vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG, 848 0xe7, priv->abyBBVGA[0]); 849 } 850 851 priv->abyBBVGA[2] = 0x0; 852 priv->abyBBVGA[3] = 0x0; 853 } 854} 855