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