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