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 - Caculate TSFOffset 32 * CARDbGetCurrentTSF - Read Current NIC TSF counter 33 * CARDqGetNextTBTT - Caculate 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 defination type of dwIoBase. 44 * 09-01-2003 Bryan YC Fan: Add vUpdateIFS(). 45 * 46 */ 47 48 #include "tmacro.h" 49 #include "card.h" 50 #include "baseband.h" 51 #include "mac.h" 52 #include "desc.h" 53 #include "rf.h" 54 #include "vntwifi.h" 55 #include "power.h" 56 #include "key.h" 57 #include "rc4.h" 58 #include "country.h" 59 #include "channel.h" 60 61 /*--------------------- Static Definitions -------------------------*/ 62 63 //static int msglevel =MSG_LEVEL_DEBUG; 64 static int msglevel =MSG_LEVEL_INFO; 65 66 #define C_SIFS_A 16 // micro sec. 67 #define C_SIFS_BG 10 68 69 #define C_EIFS 80 // micro sec. 70 71 72 #define C_SLOT_SHORT 9 // micro sec. 73 #define C_SLOT_LONG 20 74 75 #define C_CWMIN_A 15 // slot time 76 #define C_CWMIN_B 31 77 78 #define C_CWMAX 1023 // slot time 79 80 #define WAIT_BEACON_TX_DOWN_TMO 3 // Times 81 82 //1M, 2M, 5M, 11M, 18M, 24M, 36M, 54M 83 static unsigned char abyDefaultSuppRatesG[] = {WLAN_EID_SUPP_RATES, 8, 0x02, 0x04, 0x0B, 0x16, 0x24, 0x30, 0x48, 0x6C}; 84 //6M, 9M, 12M, 48M 85 static unsigned char abyDefaultExtSuppRatesG[] = {WLAN_EID_EXTSUPP_RATES, 4, 0x0C, 0x12, 0x18, 0x60}; 86 //6M, 9M, 12M, 18M, 24M, 36M, 48M, 54M 87 static unsigned char abyDefaultSuppRatesA[] = {WLAN_EID_SUPP_RATES, 8, 0x0C, 0x12, 0x18, 0x24, 0x30, 0x48, 0x60, 0x6C}; 88 //1M, 2M, 5M, 11M, 89 static unsigned char abyDefaultSuppRatesB[] = {WLAN_EID_SUPP_RATES, 4, 0x02, 0x04, 0x0B, 0x16}; 90 91 92 /*--------------------- Static Variables --------------------------*/ 93 94 95 const unsigned short cwRXBCNTSFOff[MAX_RATE] = 96 {17, 17, 17, 17, 34, 23, 17, 11, 8, 5, 4, 3}; 97 98 99 /*--------------------- Static Functions --------------------------*/ 100 101 static 102 void 103 s_vCaculateOFDMRParameter( 104 unsigned char byRate, 105 CARD_PHY_TYPE ePHYType, 106 unsigned char *pbyTxRate, 107 unsigned char *pbyRsvTime 108 ); 109 110 111 /*--------------------- Export Functions --------------------------*/ 112 113 /* 114 * Description: Caculate TxRate and RsvTime fields for RSPINF in OFDM mode. 115 * 116 * Parameters: 117 * In: 118 * wRate - Tx Rate 119 * byPktType - Tx Packet type 120 * Out: 121 * pbyTxRate - pointer to RSPINF TxRate field 122 * pbyRsvTime - pointer to RSPINF RsvTime field 123 * 124 * Return Value: none 125 * 126 */ 127 static 128 void 129 s_vCaculateOFDMRParameter ( 130 unsigned char byRate, 131 CARD_PHY_TYPE ePHYType, 132 unsigned char *pbyTxRate, 133 unsigned char *pbyRsvTime 134 ) 135 { 136 switch (byRate) { 137 case RATE_6M : 138 if (ePHYType == PHY_TYPE_11A) {//5GHZ 139 *pbyTxRate = 0x9B; 140 *pbyRsvTime = 44; 141 } 142 else { 143 *pbyTxRate = 0x8B; 144 *pbyRsvTime = 50; 145 } 146 break; 147 148 case RATE_9M : 149 if (ePHYType == PHY_TYPE_11A) {//5GHZ 150 *pbyTxRate = 0x9F; 151 *pbyRsvTime = 36; 152 } 153 else { 154 *pbyTxRate = 0x8F; 155 *pbyRsvTime = 42; 156 } 157 break; 158 159 case RATE_12M : 160 if (ePHYType == PHY_TYPE_11A) {//5GHZ 161 *pbyTxRate = 0x9A; 162 *pbyRsvTime = 32; 163 } 164 else { 165 *pbyTxRate = 0x8A; 166 *pbyRsvTime = 38; 167 } 168 break; 169 170 case RATE_18M : 171 if (ePHYType == PHY_TYPE_11A) {//5GHZ 172 *pbyTxRate = 0x9E; 173 *pbyRsvTime = 28; 174 } 175 else { 176 *pbyTxRate = 0x8E; 177 *pbyRsvTime = 34; 178 } 179 break; 180 181 case RATE_36M : 182 if (ePHYType == PHY_TYPE_11A) {//5GHZ 183 *pbyTxRate = 0x9D; 184 *pbyRsvTime = 24; 185 } 186 else { 187 *pbyTxRate = 0x8D; 188 *pbyRsvTime = 30; 189 } 190 break; 191 192 case RATE_48M : 193 if (ePHYType == PHY_TYPE_11A) {//5GHZ 194 *pbyTxRate = 0x98; 195 *pbyRsvTime = 24; 196 } 197 else { 198 *pbyTxRate = 0x88; 199 *pbyRsvTime = 30; 200 } 201 break; 202 203 case RATE_54M : 204 if (ePHYType == PHY_TYPE_11A) {//5GHZ 205 *pbyTxRate = 0x9C; 206 *pbyRsvTime = 24; 207 } 208 else { 209 *pbyTxRate = 0x8C; 210 *pbyRsvTime = 30; 211 } 212 break; 213 214 case RATE_24M : 215 default : 216 if (ePHYType == PHY_TYPE_11A) {//5GHZ 217 *pbyTxRate = 0x99; 218 *pbyRsvTime = 28; 219 } 220 else { 221 *pbyTxRate = 0x89; 222 *pbyRsvTime = 34; 223 } 224 break; 225 } 226 } 227 228 229 230 /* 231 * Description: Set RSPINF 232 * 233 * Parameters: 234 * In: 235 * pDevice - The adapter to be set 236 * Out: 237 * none 238 * 239 * Return Value: None. 240 * 241 */ 242 static 243 void 244 s_vSetRSPINF (PSDevice pDevice, CARD_PHY_TYPE ePHYType, void *pvSupportRateIEs, void *pvExtSupportRateIEs) 245 { 246 unsigned char byServ = 0, bySignal = 0; // For CCK 247 unsigned short wLen = 0; 248 unsigned char byTxRate = 0, byRsvTime = 0; // For OFDM 249 250 //Set to Page1 251 MACvSelectPage1(pDevice->PortOffset); 252 253 //RSPINF_b_1 254 BBvCaculateParameter(pDevice, 255 14, 256 VNTWIFIbyGetACKTxRate(RATE_1M, pvSupportRateIEs, pvExtSupportRateIEs), 257 PK_TYPE_11B, 258 &wLen, 259 &byServ, 260 &bySignal 261 ); 262 263 VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_1, MAKEDWORD(wLen,MAKEWORD(bySignal,byServ))); 264 ///RSPINF_b_2 265 BBvCaculateParameter(pDevice, 266 14, 267 VNTWIFIbyGetACKTxRate(RATE_2M, pvSupportRateIEs, pvExtSupportRateIEs), 268 PK_TYPE_11B, 269 &wLen, 270 &byServ, 271 &bySignal 272 ); 273 274 VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_2, MAKEDWORD(wLen,MAKEWORD(bySignal,byServ))); 275 //RSPINF_b_5 276 BBvCaculateParameter(pDevice, 277 14, 278 VNTWIFIbyGetACKTxRate(RATE_5M, pvSupportRateIEs, pvExtSupportRateIEs), 279 PK_TYPE_11B, 280 &wLen, 281 &byServ, 282 &bySignal 283 ); 284 285 VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_5, MAKEDWORD(wLen,MAKEWORD(bySignal,byServ))); 286 //RSPINF_b_11 287 BBvCaculateParameter(pDevice, 288 14, 289 VNTWIFIbyGetACKTxRate(RATE_11M, pvSupportRateIEs, pvExtSupportRateIEs), 290 PK_TYPE_11B, 291 &wLen, 292 &byServ, 293 &bySignal 294 ); 295 296 VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_11, MAKEDWORD(wLen,MAKEWORD(bySignal,byServ))); 297 //RSPINF_a_6 298 s_vCaculateOFDMRParameter(RATE_6M, 299 ePHYType, 300 &byTxRate, 301 &byRsvTime); 302 VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_6, MAKEWORD(byTxRate,byRsvTime)); 303 //RSPINF_a_9 304 s_vCaculateOFDMRParameter(RATE_9M, 305 ePHYType, 306 &byTxRate, 307 &byRsvTime); 308 VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_9, MAKEWORD(byTxRate,byRsvTime)); 309 //RSPINF_a_12 310 s_vCaculateOFDMRParameter(RATE_12M, 311 ePHYType, 312 &byTxRate, 313 &byRsvTime); 314 VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_12, MAKEWORD(byTxRate,byRsvTime)); 315 //RSPINF_a_18 316 s_vCaculateOFDMRParameter(RATE_18M, 317 ePHYType, 318 &byTxRate, 319 &byRsvTime); 320 VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_18, MAKEWORD(byTxRate,byRsvTime)); 321 //RSPINF_a_24 322 s_vCaculateOFDMRParameter(RATE_24M, 323 ePHYType, 324 &byTxRate, 325 &byRsvTime); 326 VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_24, MAKEWORD(byTxRate,byRsvTime)); 327 //RSPINF_a_36 328 s_vCaculateOFDMRParameter( 329 VNTWIFIbyGetACKTxRate(RATE_36M, pvSupportRateIEs, pvExtSupportRateIEs), 330 ePHYType, 331 &byTxRate, 332 &byRsvTime); 333 VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_36, MAKEWORD(byTxRate,byRsvTime)); 334 //RSPINF_a_48 335 s_vCaculateOFDMRParameter( 336 VNTWIFIbyGetACKTxRate(RATE_48M, pvSupportRateIEs, pvExtSupportRateIEs), 337 ePHYType, 338 &byTxRate, 339 &byRsvTime); 340 VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_48, MAKEWORD(byTxRate,byRsvTime)); 341 //RSPINF_a_54 342 s_vCaculateOFDMRParameter( 343 VNTWIFIbyGetACKTxRate(RATE_54M, pvSupportRateIEs, pvExtSupportRateIEs), 344 ePHYType, 345 &byTxRate, 346 &byRsvTime); 347 VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_54, MAKEWORD(byTxRate,byRsvTime)); 348 //RSPINF_a_72 349 VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_72, MAKEWORD(byTxRate,byRsvTime)); 350 //Set to Page0 351 MACvSelectPage0(pDevice->PortOffset); 352 } 353 354 /*--------------------- Export Functions --------------------------*/ 355 356 /* 357 * Description: Card Send packet function 358 * 359 * Parameters: 360 * In: 361 * pDeviceHandler - The adapter to be set 362 * pPacket - Packet buffer pointer 363 * ePktType - Packet type 364 * uLength - Packet length 365 * Out: 366 * none 367 * 368 * Return Value: true if succeeded; false if failed. 369 * 370 */ 371 /* 372 bool CARDbSendPacket (void *pDeviceHandler, void *pPacket, CARD_PKT_TYPE ePktType, unsigned int uLength) 373 { 374 PSDevice pDevice = (PSDevice) pDeviceHandler; 375 if (ePktType == PKT_TYPE_802_11_MNG) { 376 return TXbTD0Send(pDevice, pPacket, uLength); 377 } else if (ePktType == PKT_TYPE_802_11_BCN) { 378 return TXbBeaconSend(pDevice, pPacket, uLength); 379 } if (ePktType == PKT_TYPE_802_11_DATA) { 380 return TXbTD1Send(pDevice, pPacket, uLength); 381 } 382 383 return (true); 384 } 385 */ 386 387 388 /* 389 * Description: Get Card short preamble option value 390 * 391 * Parameters: 392 * In: 393 * pDevice - The adapter to be set 394 * Out: 395 * none 396 * 397 * Return Value: true if short preamble; otherwise false 398 * 399 */ 400 bool CARDbIsShortPreamble (void *pDeviceHandler) 401 { 402 PSDevice pDevice = (PSDevice) pDeviceHandler; 403 if (pDevice->byPreambleType == 0) { 404 return(false); 405 } 406 return(true); 407 } 408 409 /* 410 * Description: Get Card short slot time option value 411 * 412 * Parameters: 413 * In: 414 * pDevice - The adapter to be set 415 * Out: 416 * none 417 * 418 * Return Value: true if short slot time; otherwise false 419 * 420 */ 421 bool CARDbIsShorSlotTime (void *pDeviceHandler) 422 { 423 PSDevice pDevice = (PSDevice) pDeviceHandler; 424 return(pDevice->bShortSlotTime); 425 } 426 427 428 /* 429 * Description: Update IFS 430 * 431 * Parameters: 432 * In: 433 * pDevice - The adapter to be set 434 * Out: 435 * none 436 * 437 * Return Value: None. 438 * 439 */ 440 bool CARDbSetPhyParameter (void *pDeviceHandler, CARD_PHY_TYPE ePHYType, unsigned short wCapInfo, unsigned char byERPField, void *pvSupportRateIEs, void *pvExtSupportRateIEs) 441 { 442 PSDevice pDevice = (PSDevice) pDeviceHandler; 443 unsigned char byCWMaxMin = 0; 444 unsigned char bySlot = 0; 445 unsigned char bySIFS = 0; 446 unsigned char byDIFS = 0; 447 unsigned char byData; 448 // PWLAN_IE_SUPP_RATES pRates = NULL; 449 PWLAN_IE_SUPP_RATES pSupportRates = (PWLAN_IE_SUPP_RATES) pvSupportRateIEs; 450 PWLAN_IE_SUPP_RATES pExtSupportRates = (PWLAN_IE_SUPP_RATES) pvExtSupportRateIEs; 451 452 453 //Set SIFS, DIFS, EIFS, SlotTime, CwMin 454 if (ePHYType == PHY_TYPE_11A) { 455 if (pSupportRates == NULL) { 456 pSupportRates = (PWLAN_IE_SUPP_RATES) abyDefaultSuppRatesA; 457 } 458 if (pDevice->byRFType == RF_AIROHA7230) { 459 // AL7230 use single PAPE and connect to PAPE_2.4G 460 MACvSetBBType(pDevice->PortOffset, BB_TYPE_11G); 461 pDevice->abyBBVGA[0] = 0x20; 462 pDevice->abyBBVGA[2] = 0x10; 463 pDevice->abyBBVGA[3] = 0x10; 464 BBbReadEmbeded(pDevice->PortOffset, 0xE7, &byData); 465 if (byData == 0x1C) { 466 BBbWriteEmbeded(pDevice->PortOffset, 0xE7, pDevice->abyBBVGA[0]); 467 } 468 } else if (pDevice->byRFType == RF_UW2452) { 469 MACvSetBBType(pDevice->PortOffset, BB_TYPE_11A); 470 pDevice->abyBBVGA[0] = 0x18; 471 BBbReadEmbeded(pDevice->PortOffset, 0xE7, &byData); 472 if (byData == 0x14) { 473 BBbWriteEmbeded(pDevice->PortOffset, 0xE7, pDevice->abyBBVGA[0]); 474 BBbWriteEmbeded(pDevice->PortOffset, 0xE1, 0x57); 475 } 476 } else { 477 MACvSetBBType(pDevice->PortOffset, BB_TYPE_11A); 478 } 479 BBbWriteEmbeded(pDevice->PortOffset, 0x88, 0x03); 480 bySlot = C_SLOT_SHORT; 481 bySIFS = C_SIFS_A; 482 byDIFS = C_SIFS_A + 2*C_SLOT_SHORT; 483 byCWMaxMin = 0xA4; 484 } else if (ePHYType == PHY_TYPE_11B) { 485 if (pSupportRates == NULL) { 486 pSupportRates = (PWLAN_IE_SUPP_RATES) abyDefaultSuppRatesB; 487 } 488 MACvSetBBType(pDevice->PortOffset, BB_TYPE_11B); 489 if (pDevice->byRFType == RF_AIROHA7230) { 490 pDevice->abyBBVGA[0] = 0x1C; 491 pDevice->abyBBVGA[2] = 0x00; 492 pDevice->abyBBVGA[3] = 0x00; 493 BBbReadEmbeded(pDevice->PortOffset, 0xE7, &byData); 494 if (byData == 0x20) { 495 BBbWriteEmbeded(pDevice->PortOffset, 0xE7, pDevice->abyBBVGA[0]); 496 } 497 } else if (pDevice->byRFType == RF_UW2452) { 498 pDevice->abyBBVGA[0] = 0x14; 499 BBbReadEmbeded(pDevice->PortOffset, 0xE7, &byData); 500 if (byData == 0x18) { 501 BBbWriteEmbeded(pDevice->PortOffset, 0xE7, pDevice->abyBBVGA[0]); 502 BBbWriteEmbeded(pDevice->PortOffset, 0xE1, 0xD3); 503 } 504 } 505 BBbWriteEmbeded(pDevice->PortOffset, 0x88, 0x02); 506 bySlot = C_SLOT_LONG; 507 bySIFS = C_SIFS_BG; 508 byDIFS = C_SIFS_BG + 2*C_SLOT_LONG; 509 byCWMaxMin = 0xA5; 510 } else {// PK_TYPE_11GA & PK_TYPE_11GB 511 if (pSupportRates == NULL) { 512 pSupportRates = (PWLAN_IE_SUPP_RATES) abyDefaultSuppRatesG; 513 pExtSupportRates = (PWLAN_IE_SUPP_RATES) abyDefaultExtSuppRatesG; 514 } 515 MACvSetBBType(pDevice->PortOffset, BB_TYPE_11G); 516 if (pDevice->byRFType == RF_AIROHA7230) { 517 pDevice->abyBBVGA[0] = 0x1C; 518 pDevice->abyBBVGA[2] = 0x00; 519 pDevice->abyBBVGA[3] = 0x00; 520 BBbReadEmbeded(pDevice->PortOffset, 0xE7, &byData); 521 if (byData == 0x20) { 522 BBbWriteEmbeded(pDevice->PortOffset, 0xE7, pDevice->abyBBVGA[0]); 523 } 524 } else if (pDevice->byRFType == RF_UW2452) { 525 pDevice->abyBBVGA[0] = 0x14; 526 BBbReadEmbeded(pDevice->PortOffset, 0xE7, &byData); 527 if (byData == 0x18) { 528 BBbWriteEmbeded(pDevice->PortOffset, 0xE7, pDevice->abyBBVGA[0]); 529 BBbWriteEmbeded(pDevice->PortOffset, 0xE1, 0xD3); 530 } 531 } 532 BBbWriteEmbeded(pDevice->PortOffset, 0x88, 0x08); 533 bySIFS = C_SIFS_BG; 534 if(VNTWIFIbIsShortSlotTime(wCapInfo)) { 535 bySlot = C_SLOT_SHORT; 536 byDIFS = C_SIFS_BG + 2*C_SLOT_SHORT; 537 } else { 538 bySlot = C_SLOT_LONG; 539 byDIFS = C_SIFS_BG + 2*C_SLOT_LONG; 540 } 541 if (VNTWIFIbyGetMaxSupportRate(pSupportRates, pExtSupportRates) > RATE_11M) { 542 byCWMaxMin = 0xA4; 543 } else { 544 byCWMaxMin = 0xA5; 545 } 546 if (pDevice->bProtectMode != VNTWIFIbIsProtectMode(byERPField)) { 547 pDevice->bProtectMode = VNTWIFIbIsProtectMode(byERPField); 548 if (pDevice->bProtectMode) { 549 MACvEnableProtectMD(pDevice->PortOffset); 550 } else { 551 MACvDisableProtectMD(pDevice->PortOffset); 552 } 553 } 554 if (pDevice->bBarkerPreambleMd != VNTWIFIbIsBarkerMode(byERPField)) { 555 pDevice->bBarkerPreambleMd = VNTWIFIbIsBarkerMode(byERPField); 556 if (pDevice->bBarkerPreambleMd) { 557 MACvEnableBarkerPreambleMd(pDevice->PortOffset); 558 } else { 559 MACvDisableBarkerPreambleMd(pDevice->PortOffset); 560 } 561 } 562 } 563 564 if (pDevice->byRFType == RF_RFMD2959) { 565 // bcs TX_PE will reserve 3 us 566 // hardware's processing time here is 2 us. 567 bySIFS -= 3; 568 byDIFS -= 3; 569 //{{ RobertYu: 20041202 570 //// TX_PE will reserve 3 us for MAX2829 A mode only, it is for better TX throughput 571 //// MAC will need 2 us to process, so the SIFS, DIFS can be shorter by 2 us. 572 } 573 574 if (pDevice->bySIFS != bySIFS) { 575 pDevice->bySIFS = bySIFS; 576 VNSvOutPortB(pDevice->PortOffset + MAC_REG_SIFS, pDevice->bySIFS); 577 } 578 if (pDevice->byDIFS != byDIFS) { 579 pDevice->byDIFS = byDIFS; 580 VNSvOutPortB(pDevice->PortOffset + MAC_REG_DIFS, pDevice->byDIFS); 581 } 582 if (pDevice->byEIFS != C_EIFS) { 583 pDevice->byEIFS = C_EIFS; 584 VNSvOutPortB(pDevice->PortOffset + MAC_REG_EIFS, pDevice->byEIFS); 585 } 586 if (pDevice->bySlot != bySlot) { 587 pDevice->bySlot = bySlot; 588 VNSvOutPortB(pDevice->PortOffset + MAC_REG_SLOT, pDevice->bySlot); 589 if (pDevice->bySlot == C_SLOT_SHORT) { 590 pDevice->bShortSlotTime = true; 591 } else { 592 pDevice->bShortSlotTime = false; 593 } 594 BBvSetShortSlotTime(pDevice); 595 } 596 if (pDevice->byCWMaxMin != byCWMaxMin) { 597 pDevice->byCWMaxMin = byCWMaxMin; 598 VNSvOutPortB(pDevice->PortOffset + MAC_REG_CWMAXMIN0, pDevice->byCWMaxMin); 599 } 600 if (VNTWIFIbIsShortPreamble(wCapInfo)) { 601 pDevice->byPreambleType = pDevice->byShortPreamble; 602 } else { 603 pDevice->byPreambleType = 0; 604 } 605 s_vSetRSPINF(pDevice, ePHYType, pSupportRates, pExtSupportRates); 606 pDevice->eCurrentPHYType = ePHYType; 607 // set for NDIS OID_802_11SUPPORTED_RATES 608 return (true); 609 } 610 611 /* 612 * Description: Sync. TSF counter to BSS 613 * Get TSF offset and write to HW 614 * 615 * Parameters: 616 * In: 617 * pDevice - The adapter to be sync. 618 * byRxRate - data rate of receive beacon 619 * qwBSSTimestamp - Rx BCN's TSF 620 * qwLocalTSF - Local TSF 621 * Out: 622 * none 623 * 624 * Return Value: none 625 * 626 */ 627 bool CARDbUpdateTSF (void *pDeviceHandler, unsigned char byRxRate, QWORD qwBSSTimestamp, QWORD qwLocalTSF) 628 { 629 PSDevice pDevice = (PSDevice) pDeviceHandler; 630 QWORD qwTSFOffset; 631 632 HIDWORD(qwTSFOffset) = 0; 633 LODWORD(qwTSFOffset) = 0; 634 635 if ((HIDWORD(qwBSSTimestamp) != HIDWORD(qwLocalTSF)) || 636 (LODWORD(qwBSSTimestamp) != LODWORD(qwLocalTSF))) { 637 qwTSFOffset = CARDqGetTSFOffset(byRxRate, qwBSSTimestamp, qwLocalTSF); 638 // adjust TSF 639 // HW's TSF add TSF Offset reg 640 VNSvOutPortD(pDevice->PortOffset + MAC_REG_TSFOFST, LODWORD(qwTSFOffset)); 641 VNSvOutPortD(pDevice->PortOffset + MAC_REG_TSFOFST + 4, HIDWORD(qwTSFOffset)); 642 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_TFTCTL, TFTCTL_TSFSYNCEN); 643 } 644 return(true); 645 } 646 647 648 /* 649 * Description: Set NIC TSF counter for first Beacon time 650 * Get NEXTTBTT from adjusted TSF and Beacon Interval 651 * 652 * Parameters: 653 * In: 654 * pDevice - The adapter to be set. 655 * wBeaconInterval - Beacon Interval 656 * Out: 657 * none 658 * 659 * Return Value: true if succeed; otherwise false 660 * 661 */ 662 bool CARDbSetBeaconPeriod (void *pDeviceHandler, unsigned short wBeaconInterval) 663 { 664 PSDevice pDevice = (PSDevice) pDeviceHandler; 665 unsigned int uBeaconInterval = 0; 666 unsigned int uLowNextTBTT = 0; 667 unsigned int uHighRemain = 0; 668 unsigned int uLowRemain = 0; 669 QWORD qwNextTBTT; 670 671 HIDWORD(qwNextTBTT) = 0; 672 LODWORD(qwNextTBTT) = 0; 673 CARDbGetCurrentTSF(pDevice->PortOffset, &qwNextTBTT); //Get Local TSF counter 674 uBeaconInterval = wBeaconInterval * 1024; 675 // Next TBTT = ((local_current_TSF / beacon_interval) + 1 ) * beacon_interval 676 uLowNextTBTT = (LODWORD(qwNextTBTT) >> 10) << 10; 677 uLowRemain = (uLowNextTBTT) % uBeaconInterval; 678 // high dword (mod) bcn 679 uHighRemain = (((0xffffffff % uBeaconInterval) + 1) * HIDWORD(qwNextTBTT)) 680 % uBeaconInterval; 681 uLowRemain = (uHighRemain + uLowRemain) % uBeaconInterval; 682 uLowRemain = uBeaconInterval - uLowRemain; 683 684 // check if carry when add one beacon interval 685 if ((~uLowNextTBTT) < uLowRemain) { 686 HIDWORD(qwNextTBTT) ++ ; 687 } 688 LODWORD(qwNextTBTT) = uLowNextTBTT + uLowRemain; 689 690 // set HW beacon interval 691 VNSvOutPortW(pDevice->PortOffset + MAC_REG_BI, wBeaconInterval); 692 pDevice->wBeaconInterval = wBeaconInterval; 693 // Set NextTBTT 694 VNSvOutPortD(pDevice->PortOffset + MAC_REG_NEXTTBTT, LODWORD(qwNextTBTT)); 695 VNSvOutPortD(pDevice->PortOffset + MAC_REG_NEXTTBTT + 4, HIDWORD(qwNextTBTT)); 696 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_TFTCTL, TFTCTL_TBTTSYNCEN); 697 698 return(true); 699 } 700 701 702 703 /* 704 * Description: Card Stop Hardware Tx 705 * 706 * Parameters: 707 * In: 708 * pDeviceHandler - The adapter to be set 709 * ePktType - Packet type to stop 710 * Out: 711 * none 712 * 713 * Return Value: true if all data packet complete; otherwise false. 714 * 715 */ 716 bool CARDbStopTxPacket (void *pDeviceHandler, CARD_PKT_TYPE ePktType) 717 { 718 PSDevice pDevice = (PSDevice) pDeviceHandler; 719 720 721 if (ePktType == PKT_TYPE_802_11_ALL) { 722 pDevice->bStopBeacon = true; 723 pDevice->bStopTx0Pkt = true; 724 pDevice->bStopDataPkt = true; 725 } else if (ePktType == PKT_TYPE_802_11_BCN) { 726 pDevice->bStopBeacon = true; 727 } else if (ePktType == PKT_TYPE_802_11_MNG) { 728 pDevice->bStopTx0Pkt = true; 729 } else if (ePktType == PKT_TYPE_802_11_DATA) { 730 pDevice->bStopDataPkt = true; 731 } 732 733 if (pDevice->bStopBeacon == true) { 734 if (pDevice->bIsBeaconBufReadySet == true) { 735 if (pDevice->cbBeaconBufReadySetCnt < WAIT_BEACON_TX_DOWN_TMO) { 736 pDevice->cbBeaconBufReadySetCnt ++; 737 return(false); 738 } 739 } 740 pDevice->bIsBeaconBufReadySet = false; 741 pDevice->cbBeaconBufReadySetCnt = 0; 742 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_TCR, TCR_AUTOBCNTX); 743 } 744 // wait all TD0 complete 745 if (pDevice->bStopTx0Pkt == true) { 746 if (pDevice->iTDUsed[TYPE_TXDMA0] != 0){ 747 return(false); 748 } 749 } 750 // wait all Data TD complete 751 if (pDevice->bStopDataPkt == true) { 752 if (pDevice->iTDUsed[TYPE_AC0DMA] != 0){ 753 return(false); 754 } 755 } 756 757 return(true); 758 } 759 760 761 /* 762 * Description: Card Start Hardware Tx 763 * 764 * Parameters: 765 * In: 766 * pDeviceHandler - The adapter to be set 767 * ePktType - Packet type to start 768 * Out: 769 * none 770 * 771 * Return Value: true if success; false if failed. 772 * 773 */ 774 bool CARDbStartTxPacket (void *pDeviceHandler, CARD_PKT_TYPE ePktType) 775 { 776 PSDevice pDevice = (PSDevice) pDeviceHandler; 777 778 779 if (ePktType == PKT_TYPE_802_11_ALL) { 780 pDevice->bStopBeacon = false; 781 pDevice->bStopTx0Pkt = false; 782 pDevice->bStopDataPkt = false; 783 } else if (ePktType == PKT_TYPE_802_11_BCN) { 784 pDevice->bStopBeacon = false; 785 } else if (ePktType == PKT_TYPE_802_11_MNG) { 786 pDevice->bStopTx0Pkt = false; 787 } else if (ePktType == PKT_TYPE_802_11_DATA) { 788 pDevice->bStopDataPkt = false; 789 } 790 791 if ((pDevice->bStopBeacon == false) && 792 (pDevice->bBeaconBufReady == true) && 793 (pDevice->eOPMode == OP_MODE_ADHOC)) { 794 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_TCR, TCR_AUTOBCNTX); 795 } 796 797 return(true); 798 } 799 800 801 802 /* 803 * Description: Card Set BSSID value 804 * 805 * Parameters: 806 * In: 807 * pDeviceHandler - The adapter to be set 808 * pbyBSSID - pointer to BSSID field 809 * bAdhoc - flag to indicate IBSS 810 * Out: 811 * none 812 * 813 * Return Value: true if success; false if failed. 814 * 815 */ 816 bool CARDbSetBSSID(void *pDeviceHandler, unsigned char *pbyBSSID, CARD_OP_MODE eOPMode) 817 { 818 PSDevice pDevice = (PSDevice) pDeviceHandler; 819 820 MACvWriteBSSIDAddress(pDevice->PortOffset, pbyBSSID); 821 memcpy(pDevice->abyBSSID, pbyBSSID, WLAN_BSSID_LEN); 822 if (eOPMode == OP_MODE_ADHOC) { 823 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_HOSTCR, HOSTCR_ADHOC); 824 } else { 825 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_HOSTCR, HOSTCR_ADHOC); 826 } 827 if (eOPMode == OP_MODE_AP) { 828 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_HOSTCR, HOSTCR_AP); 829 } else { 830 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_HOSTCR, HOSTCR_AP); 831 } 832 if (eOPMode == OP_MODE_UNKNOWN) { 833 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_RCR, RCR_BSSID); 834 pDevice->bBSSIDFilter = false; 835 pDevice->byRxMode &= ~RCR_BSSID; 836 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "wcmd: rx_mode = %x\n", pDevice->byRxMode ); 837 } else { 838 if (is_zero_ether_addr(pDevice->abyBSSID) == false) { 839 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_RCR, RCR_BSSID); 840 pDevice->bBSSIDFilter = true; 841 pDevice->byRxMode |= RCR_BSSID; 842 } 843 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "wmgr: rx_mode = %x\n", pDevice->byRxMode ); 844 } 845 // Adopt BSS state in Adapter Device Object 846 pDevice->eOPMode = eOPMode; 847 return(true); 848 } 849 850 851 /* 852 * Description: Card indicate status 853 * 854 * Parameters: 855 * In: 856 * pDeviceHandler - The adapter to be set 857 * eStatus - Status 858 * Out: 859 * none 860 * 861 * Return Value: true if success; false if failed. 862 * 863 */ 864 865 866 867 868 /* 869 * Description: Save Assoc info. contain in assoc. response frame 870 * 871 * Parameters: 872 * In: 873 * pDevice - The adapter to be set 874 * wCapabilityInfo - Capability information 875 * wStatus - Status code 876 * wAID - Assoc. ID 877 * uLen - Length of IEs 878 * pbyIEs - pointer to IEs 879 * Out: 880 * none 881 * 882 * Return Value: true if succeed; otherwise false 883 * 884 */ 885 bool CARDbSetTxDataRate( 886 void *pDeviceHandler, 887 unsigned short wDataRate 888 ) 889 { 890 PSDevice pDevice = (PSDevice) pDeviceHandler; 891 892 pDevice->wCurrentRate = wDataRate; 893 return(true); 894 } 895 896 /*+ 897 * 898 * Routine Description: 899 * Consider to power down when no more packets to tx or rx. 900 * 901 * Parameters: 902 * In: 903 * pDevice - The adapter to be set 904 * Out: 905 * none 906 * 907 * Return Value: true if power down success; otherwise false 908 * 909 -*/ 910 bool 911 CARDbPowerDown( 912 void *pDeviceHandler 913 ) 914 { 915 PSDevice pDevice = (PSDevice)pDeviceHandler; 916 unsigned int uIdx; 917 918 // check if already in Doze mode 919 if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) 920 return true; 921 922 // Froce PSEN on 923 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PSEN); 924 925 // check if all TD are empty, 926 927 for (uIdx = 0; uIdx < TYPE_MAXTD; uIdx ++) { 928 if (pDevice->iTDUsed[uIdx] != 0) 929 return false; 930 } 931 932 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_GO2DOZE); 933 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Go to Doze ZZZZZZZZZZZZZZZ\n"); 934 return true; 935 } 936 937 /* 938 * Description: Turn off Radio power 939 * 940 * Parameters: 941 * In: 942 * pDevice - The adapter to be turned off 943 * Out: 944 * none 945 * 946 * Return Value: true if success; otherwise false 947 * 948 */ 949 bool CARDbRadioPowerOff (void *pDeviceHandler) 950 { 951 PSDevice pDevice = (PSDevice) pDeviceHandler; 952 bool bResult = true; 953 954 if (pDevice->bRadioOff == true) 955 return true; 956 957 958 switch (pDevice->byRFType) { 959 960 case RF_RFMD2959: 961 MACvWordRegBitsOff(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_TXPEINV); 962 MACvWordRegBitsOn(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPE1); 963 break; 964 965 case RF_AIROHA: 966 case RF_AL2230S: 967 case RF_AIROHA7230: //RobertYu:20050104 968 MACvWordRegBitsOff(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPE2); 969 MACvWordRegBitsOff(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPE3); 970 break; 971 972 } 973 974 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_HOSTCR, HOSTCR_RXON); 975 976 BBvSetDeepSleep(pDevice->PortOffset, pDevice->byLocalID); 977 978 pDevice->bRadioOff = true; 979 //2007-0409-03,<Add> by chester 980 printk("chester power off\n"); 981 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_GPIOCTL0, LED_ACTSET); //LED issue 982 return bResult; 983 } 984 985 986 /* 987 * Description: Turn on Radio power 988 * 989 * Parameters: 990 * In: 991 * pDevice - The adapter to be turned on 992 * Out: 993 * none 994 * 995 * Return Value: true if success; otherwise false 996 * 997 */ 998 bool CARDbRadioPowerOn (void *pDeviceHandler) 999 { 1000 PSDevice pDevice = (PSDevice) pDeviceHandler; 1001 bool bResult = true; 1002 printk("chester power on\n"); 1003 if (pDevice->bRadioControlOff == true){ 1004 if (pDevice->bHWRadioOff == true) printk("chester bHWRadioOff\n"); 1005 if (pDevice->bRadioControlOff == true) printk("chester bRadioControlOff\n"); 1006 return false;} 1007 1008 if (pDevice->bRadioOff == false) 1009 { 1010 printk("chester pbRadioOff\n"); 1011 return true;} 1012 1013 BBvExitDeepSleep(pDevice->PortOffset, pDevice->byLocalID); 1014 1015 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_HOSTCR, HOSTCR_RXON); 1016 1017 switch (pDevice->byRFType) { 1018 1019 case RF_RFMD2959: 1020 MACvWordRegBitsOn(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_TXPEINV); 1021 MACvWordRegBitsOff(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPE1); 1022 break; 1023 1024 case RF_AIROHA: 1025 case RF_AL2230S: 1026 case RF_AIROHA7230: //RobertYu:20050104 1027 MACvWordRegBitsOn(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, (SOFTPWRCTL_SWPE2 | 1028 SOFTPWRCTL_SWPE3)); 1029 break; 1030 1031 } 1032 1033 pDevice->bRadioOff = false; 1034 // 2007-0409-03,<Add> by chester 1035 printk("chester power on\n"); 1036 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_GPIOCTL0, LED_ACTSET); //LED issue 1037 return bResult; 1038 } 1039 1040 1041 1042 bool CARDbRemoveKey (void *pDeviceHandler, unsigned char *pbyBSSID) 1043 { 1044 PSDevice pDevice = (PSDevice) pDeviceHandler; 1045 1046 KeybRemoveAllKey(&(pDevice->sKey), pbyBSSID, pDevice->PortOffset); 1047 return (true); 1048 } 1049 1050 1051 /* 1052 * 1053 * Description: 1054 * Add BSSID in PMKID Candidate list. 1055 * 1056 * Parameters: 1057 * In: 1058 * hDeviceContext - device structure point 1059 * pbyBSSID - BSSID address for adding 1060 * wRSNCap - BSS's RSN capability 1061 * Out: 1062 * none 1063 * 1064 * Return Value: none. 1065 * 1066 -*/ 1067 bool 1068 CARDbAdd_PMKID_Candidate ( 1069 void *pDeviceHandler, 1070 unsigned char *pbyBSSID, 1071 bool bRSNCapExist, 1072 unsigned short wRSNCap 1073 ) 1074 { 1075 PSDevice pDevice = (PSDevice) pDeviceHandler; 1076 PPMKID_CANDIDATE pCandidateList; 1077 unsigned int ii = 0; 1078 1079 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"bAdd_PMKID_Candidate START: (%d)\n", (int)pDevice->gsPMKIDCandidate.NumCandidates); 1080 1081 if (pDevice->gsPMKIDCandidate.NumCandidates >= MAX_PMKIDLIST) { 1082 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"vFlush_PMKID_Candidate: 3\n"); 1083 memset(&pDevice->gsPMKIDCandidate, 0, sizeof(SPMKIDCandidateEvent)); 1084 } 1085 1086 for (ii = 0; ii < 6; ii++) { 1087 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"%02X ", *(pbyBSSID + ii)); 1088 } 1089 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"\n"); 1090 1091 1092 // Update Old Candidate 1093 for (ii = 0; ii < pDevice->gsPMKIDCandidate.NumCandidates; ii++) { 1094 pCandidateList = &pDevice->gsPMKIDCandidate.CandidateList[ii]; 1095 if ( !memcmp(pCandidateList->BSSID, pbyBSSID, ETH_ALEN)) { 1096 if ((bRSNCapExist == true) && (wRSNCap & BIT0)) { 1097 pCandidateList->Flags |= NDIS_802_11_PMKID_CANDIDATE_PREAUTH_ENABLED; 1098 } else { 1099 pCandidateList->Flags &= ~(NDIS_802_11_PMKID_CANDIDATE_PREAUTH_ENABLED); 1100 } 1101 return true; 1102 } 1103 } 1104 1105 // New Candidate 1106 pCandidateList = &pDevice->gsPMKIDCandidate.CandidateList[pDevice->gsPMKIDCandidate.NumCandidates]; 1107 if ((bRSNCapExist == true) && (wRSNCap & BIT0)) { 1108 pCandidateList->Flags |= NDIS_802_11_PMKID_CANDIDATE_PREAUTH_ENABLED; 1109 } else { 1110 pCandidateList->Flags &= ~(NDIS_802_11_PMKID_CANDIDATE_PREAUTH_ENABLED); 1111 } 1112 memcpy(pCandidateList->BSSID, pbyBSSID, ETH_ALEN); 1113 pDevice->gsPMKIDCandidate.NumCandidates++; 1114 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"NumCandidates:%d\n", (int)pDevice->gsPMKIDCandidate.NumCandidates); 1115 return true; 1116 } 1117 1118 void * 1119 CARDpGetCurrentAddress ( 1120 void *pDeviceHandler 1121 ) 1122 { 1123 PSDevice pDevice = (PSDevice) pDeviceHandler; 1124 1125 return (pDevice->abyCurrentNetAddr); 1126 } 1127 1128 /* 1129 * 1130 * Description: 1131 * Start Spectrum Measure defined in 802.11h 1132 * 1133 * Parameters: 1134 * In: 1135 * hDeviceContext - device structure point 1136 * Out: 1137 * none 1138 * 1139 * Return Value: none. 1140 * 1141 -*/ 1142 bool 1143 CARDbStartMeasure ( 1144 void *pDeviceHandler, 1145 void *pvMeasureEIDs, 1146 unsigned int uNumOfMeasureEIDs 1147 ) 1148 { 1149 PSDevice pDevice = (PSDevice) pDeviceHandler; 1150 PWLAN_IE_MEASURE_REQ pEID = (PWLAN_IE_MEASURE_REQ) pvMeasureEIDs; 1151 QWORD qwCurrTSF; 1152 QWORD qwStartTSF; 1153 bool bExpired = true; 1154 unsigned short wDuration = 0; 1155 1156 if ((pEID == NULL) || 1157 (uNumOfMeasureEIDs == 0)) { 1158 return (true); 1159 } 1160 CARDbGetCurrentTSF(pDevice->PortOffset, &qwCurrTSF); 1161 if (pDevice->bMeasureInProgress == true) { 1162 pDevice->bMeasureInProgress = false; 1163 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, pDevice->byOrgRCR); 1164 MACvSelectPage1(pDevice->PortOffset); 1165 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, pDevice->dwOrgMAR0); 1166 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR4, pDevice->dwOrgMAR4); 1167 // clear measure control 1168 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_EN); 1169 MACvSelectPage0(pDevice->PortOffset); 1170 set_channel(pDevice, pDevice->byOrgChannel); 1171 MACvSelectPage1(pDevice->PortOffset); 1172 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE); 1173 MACvSelectPage0(pDevice->PortOffset); 1174 } 1175 pDevice->uNumOfMeasureEIDs = uNumOfMeasureEIDs; 1176 1177 do { 1178 pDevice->pCurrMeasureEID = pEID; 1179 pEID++; 1180 pDevice->uNumOfMeasureEIDs--; 1181 1182 if (pDevice->byLocalID > REV_ID_VT3253_B1) { 1183 HIDWORD(qwStartTSF) = HIDWORD(*((PQWORD) (pDevice->pCurrMeasureEID->sReq.abyStartTime))); 1184 LODWORD(qwStartTSF) = LODWORD(*((PQWORD) (pDevice->pCurrMeasureEID->sReq.abyStartTime))); 1185 wDuration = *((unsigned short *) (pDevice->pCurrMeasureEID->sReq.abyDuration)); 1186 wDuration += 1; // 1 TU for channel switching 1187 1188 if ((LODWORD(qwStartTSF) == 0) && (HIDWORD(qwStartTSF) == 0)) { 1189 // start immediately by setting start TSF == current TSF + 2 TU 1190 LODWORD(qwStartTSF) = LODWORD(qwCurrTSF) + 2048; 1191 HIDWORD(qwStartTSF) = HIDWORD(qwCurrTSF); 1192 if (LODWORD(qwCurrTSF) > LODWORD(qwStartTSF)) { 1193 HIDWORD(qwStartTSF)++; 1194 } 1195 bExpired = false; 1196 break; 1197 } else { 1198 // start at setting start TSF - 1TU(for channel switching) 1199 if (LODWORD(qwStartTSF) < 1024) { 1200 HIDWORD(qwStartTSF)--; 1201 } 1202 LODWORD(qwStartTSF) -= 1024; 1203 } 1204 1205 if ((HIDWORD(qwCurrTSF) < HIDWORD(qwStartTSF)) || 1206 ((HIDWORD(qwCurrTSF) == HIDWORD(qwStartTSF)) && 1207 (LODWORD(qwCurrTSF) < LODWORD(qwStartTSF))) 1208 ) { 1209 bExpired = false; 1210 break; 1211 } 1212 VNTWIFIbMeasureReport( pDevice->pMgmt, 1213 false, 1214 pDevice->pCurrMeasureEID, 1215 MEASURE_MODE_LATE, 1216 pDevice->byBasicMap, 1217 pDevice->byCCAFraction, 1218 pDevice->abyRPIs 1219 ); 1220 } else { 1221 // hardware do not support measure 1222 VNTWIFIbMeasureReport( pDevice->pMgmt, 1223 false, 1224 pDevice->pCurrMeasureEID, 1225 MEASURE_MODE_INCAPABLE, 1226 pDevice->byBasicMap, 1227 pDevice->byCCAFraction, 1228 pDevice->abyRPIs 1229 ); 1230 } 1231 } while (pDevice->uNumOfMeasureEIDs != 0); 1232 1233 if (bExpired == false) { 1234 MACvSelectPage1(pDevice->PortOffset); 1235 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MSRSTART, LODWORD(qwStartTSF)); 1236 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MSRSTART + 4, HIDWORD(qwStartTSF)); 1237 VNSvOutPortW(pDevice->PortOffset + MAC_REG_MSRDURATION, wDuration); 1238 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_EN); 1239 MACvSelectPage0(pDevice->PortOffset); 1240 } else { 1241 // all measure start time expired we should complete action 1242 VNTWIFIbMeasureReport( pDevice->pMgmt, 1243 true, 1244 NULL, 1245 0, 1246 pDevice->byBasicMap, 1247 pDevice->byCCAFraction, 1248 pDevice->abyRPIs 1249 ); 1250 } 1251 return (true); 1252 } 1253 1254 1255 /* 1256 * 1257 * Description: 1258 * Do Channel Switch defined in 802.11h 1259 * 1260 * Parameters: 1261 * In: 1262 * hDeviceContext - device structure point 1263 * Out: 1264 * none 1265 * 1266 * Return Value: none. 1267 * 1268 -*/ 1269 bool 1270 CARDbChannelSwitch ( 1271 void *pDeviceHandler, 1272 unsigned char byMode, 1273 unsigned char byNewChannel, 1274 unsigned char byCount 1275 ) 1276 { 1277 PSDevice pDevice = (PSDevice) pDeviceHandler; 1278 bool bResult = true; 1279 1280 if (byCount == 0) { 1281 bResult = set_channel(pDevice, byNewChannel); 1282 VNTWIFIbChannelSwitch(pDevice->pMgmt, byNewChannel); 1283 MACvSelectPage1(pDevice->PortOffset); 1284 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE); 1285 MACvSelectPage0(pDevice->PortOffset); 1286 return(bResult); 1287 } 1288 pDevice->byChannelSwitchCount = byCount; 1289 pDevice->byNewChannel = byNewChannel; 1290 pDevice->bChannelSwitch = true; 1291 if (byMode == 1) { 1292 bResult=CARDbStopTxPacket(pDevice, PKT_TYPE_802_11_ALL); 1293 } 1294 return (bResult); 1295 } 1296 1297 1298 /* 1299 * 1300 * Description: 1301 * Handle Quiet EID defined in 802.11h 1302 * 1303 * Parameters: 1304 * In: 1305 * hDeviceContext - device structure point 1306 * Out: 1307 * none 1308 * 1309 * Return Value: none. 1310 * 1311 -*/ 1312 bool 1313 CARDbSetQuiet ( 1314 void *pDeviceHandler, 1315 bool bResetQuiet, 1316 unsigned char byQuietCount, 1317 unsigned char byQuietPeriod, 1318 unsigned short wQuietDuration, 1319 unsigned short wQuietOffset 1320 ) 1321 { 1322 PSDevice pDevice = (PSDevice) pDeviceHandler; 1323 unsigned int ii = 0; 1324 1325 if (bResetQuiet == true) { 1326 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, (MSRCTL_QUIETTXCHK | MSRCTL_QUIETEN)); 1327 for(ii=0;ii<MAX_QUIET_COUNT;ii++) { 1328 pDevice->sQuiet[ii].bEnable = false; 1329 } 1330 pDevice->uQuietEnqueue = 0; 1331 pDevice->bEnableFirstQuiet = false; 1332 pDevice->bQuietEnable = false; 1333 pDevice->byQuietStartCount = byQuietCount; 1334 } 1335 if (pDevice->sQuiet[pDevice->uQuietEnqueue].bEnable == false) { 1336 pDevice->sQuiet[pDevice->uQuietEnqueue].bEnable = true; 1337 pDevice->sQuiet[pDevice->uQuietEnqueue].byPeriod = byQuietPeriod; 1338 pDevice->sQuiet[pDevice->uQuietEnqueue].wDuration = wQuietDuration; 1339 pDevice->sQuiet[pDevice->uQuietEnqueue].dwStartTime = (unsigned long) byQuietCount; 1340 pDevice->sQuiet[pDevice->uQuietEnqueue].dwStartTime *= pDevice->wBeaconInterval; 1341 pDevice->sQuiet[pDevice->uQuietEnqueue].dwStartTime += wQuietOffset; 1342 pDevice->uQuietEnqueue++; 1343 pDevice->uQuietEnqueue %= MAX_QUIET_COUNT; 1344 if (pDevice->byQuietStartCount < byQuietCount) { 1345 pDevice->byQuietStartCount = byQuietCount; 1346 } 1347 } else { 1348 // we can not handle Quiet EID more 1349 } 1350 return (true); 1351 } 1352 1353 1354 /* 1355 * 1356 * Description: 1357 * Do Quiet, It will called by either ISR (after start) or VNTWIFI (before start) so do not need SPINLOCK 1358 * 1359 * Parameters: 1360 * In: 1361 * hDeviceContext - device structure point 1362 * Out: 1363 * none 1364 * 1365 * Return Value: none. 1366 * 1367 -*/ 1368 bool 1369 CARDbStartQuiet ( 1370 void *pDeviceHandler 1371 ) 1372 { 1373 PSDevice pDevice = (PSDevice) pDeviceHandler; 1374 unsigned int ii = 0; 1375 unsigned long dwStartTime = 0xFFFFFFFF; 1376 unsigned int uCurrentQuietIndex = 0; 1377 unsigned long dwNextTime = 0; 1378 unsigned long dwGap = 0; 1379 unsigned long dwDuration = 0; 1380 1381 for(ii=0;ii<MAX_QUIET_COUNT;ii++) { 1382 if ((pDevice->sQuiet[ii].bEnable == true) && 1383 (dwStartTime > pDevice->sQuiet[ii].dwStartTime)) { 1384 dwStartTime = pDevice->sQuiet[ii].dwStartTime; 1385 uCurrentQuietIndex = ii; 1386 } 1387 } 1388 if (dwStartTime == 0xFFFFFFFF) { 1389 // no more quiet 1390 pDevice->bQuietEnable = false; 1391 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, (MSRCTL_QUIETTXCHK | MSRCTL_QUIETEN)); 1392 } else { 1393 if (pDevice->bQuietEnable == false) { 1394 // first quiet 1395 pDevice->byQuietStartCount--; 1396 dwNextTime = pDevice->sQuiet[uCurrentQuietIndex].dwStartTime; 1397 dwNextTime %= pDevice->wBeaconInterval; 1398 MACvSelectPage1(pDevice->PortOffset); 1399 VNSvOutPortW(pDevice->PortOffset + MAC_REG_QUIETINIT, (unsigned short) dwNextTime); 1400 VNSvOutPortW(pDevice->PortOffset + MAC_REG_QUIETDUR, (unsigned short) pDevice->sQuiet[uCurrentQuietIndex].wDuration); 1401 if (pDevice->byQuietStartCount == 0) { 1402 pDevice->bEnableFirstQuiet = false; 1403 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, (MSRCTL_QUIETTXCHK | MSRCTL_QUIETEN)); 1404 } else { 1405 pDevice->bEnableFirstQuiet = true; 1406 } 1407 MACvSelectPage0(pDevice->PortOffset); 1408 } else { 1409 if (pDevice->dwCurrentQuietEndTime > pDevice->sQuiet[uCurrentQuietIndex].dwStartTime) { 1410 // overlap with previous Quiet 1411 dwGap = pDevice->dwCurrentQuietEndTime - pDevice->sQuiet[uCurrentQuietIndex].dwStartTime; 1412 if (dwGap >= pDevice->sQuiet[uCurrentQuietIndex].wDuration) { 1413 // return false to indicate next quiet expired, should call this function again 1414 return (false); 1415 } 1416 dwDuration = pDevice->sQuiet[uCurrentQuietIndex].wDuration - dwGap; 1417 dwGap = 0; 1418 } else { 1419 dwGap = pDevice->sQuiet[uCurrentQuietIndex].dwStartTime - pDevice->dwCurrentQuietEndTime; 1420 dwDuration = pDevice->sQuiet[uCurrentQuietIndex].wDuration; 1421 } 1422 // set GAP and Next duration 1423 MACvSelectPage1(pDevice->PortOffset); 1424 VNSvOutPortW(pDevice->PortOffset + MAC_REG_QUIETGAP, (unsigned short) dwGap); 1425 VNSvOutPortW(pDevice->PortOffset + MAC_REG_QUIETDUR, (unsigned short) dwDuration); 1426 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_QUIETRPT); 1427 MACvSelectPage0(pDevice->PortOffset); 1428 } 1429 pDevice->bQuietEnable = true; 1430 pDevice->dwCurrentQuietEndTime = pDevice->sQuiet[uCurrentQuietIndex].dwStartTime; 1431 pDevice->dwCurrentQuietEndTime += pDevice->sQuiet[uCurrentQuietIndex].wDuration; 1432 if (pDevice->sQuiet[uCurrentQuietIndex].byPeriod == 0) { 1433 // not period disable current quiet element 1434 pDevice->sQuiet[uCurrentQuietIndex].bEnable = false; 1435 } else { 1436 // set next period start time 1437 dwNextTime = (unsigned long) pDevice->sQuiet[uCurrentQuietIndex].byPeriod; 1438 dwNextTime *= pDevice->wBeaconInterval; 1439 pDevice->sQuiet[uCurrentQuietIndex].dwStartTime = dwNextTime; 1440 } 1441 if (pDevice->dwCurrentQuietEndTime > 0x80010000) { 1442 // decreament all time to avoid wrap around 1443 for(ii=0;ii<MAX_QUIET_COUNT;ii++) { 1444 if (pDevice->sQuiet[ii].bEnable == true) { 1445 pDevice->sQuiet[ii].dwStartTime -= 0x80000000; 1446 } 1447 } 1448 pDevice->dwCurrentQuietEndTime -= 0x80000000; 1449 } 1450 } 1451 return (true); 1452 } 1453 1454 /* 1455 * 1456 * Description: 1457 * Set Local Power Constraint 1458 * 1459 * Parameters: 1460 * In: 1461 * hDeviceContext - device structure point 1462 * Out: 1463 * none 1464 * 1465 * Return Value: none. 1466 * 1467 -*/ 1468 void 1469 CARDvSetPowerConstraint ( 1470 void *pDeviceHandler, 1471 unsigned char byChannel, 1472 char byPower 1473 ) 1474 { 1475 PSDevice pDevice = (PSDevice) pDeviceHandler; 1476 1477 if (byChannel > CB_MAX_CHANNEL_24G) { 1478 if (pDevice->bCountryInfo5G == true) { 1479 pDevice->abyLocalPwr[byChannel] = pDevice->abyRegPwr[byChannel] - byPower; 1480 } 1481 } else { 1482 if (pDevice->bCountryInfo24G == true) { 1483 pDevice->abyLocalPwr[byChannel] = pDevice->abyRegPwr[byChannel] - byPower; 1484 } 1485 } 1486 } 1487 1488 1489 /* 1490 * 1491 * Description: 1492 * Set Local Power Constraint 1493 * 1494 * Parameters: 1495 * In: 1496 * hDeviceContext - device structure point 1497 * Out: 1498 * none 1499 * 1500 * Return Value: none. 1501 * 1502 -*/ 1503 void 1504 CARDvGetPowerCapability ( 1505 void *pDeviceHandler, 1506 unsigned char *pbyMinPower, 1507 unsigned char *pbyMaxPower 1508 ) 1509 { 1510 PSDevice pDevice = (PSDevice) pDeviceHandler; 1511 unsigned char byDec = 0; 1512 1513 *pbyMaxPower = pDevice->abyOFDMDefaultPwr[pDevice->byCurrentCh]; 1514 byDec = pDevice->abyOFDMPwrTbl[pDevice->byCurrentCh]; 1515 if (pDevice->byRFType == RF_UW2452) { 1516 byDec *= 3; 1517 byDec >>= 1; 1518 } else { 1519 byDec <<= 1; 1520 } 1521 *pbyMinPower = pDevice->abyOFDMDefaultPwr[pDevice->byCurrentCh] - byDec; 1522 } 1523 1524 /* 1525 * 1526 * Description: 1527 * Get Current Tx Power 1528 * 1529 * Parameters: 1530 * In: 1531 * hDeviceContext - device structure point 1532 * Out: 1533 * none 1534 * 1535 * Return Value: none. 1536 * 1537 */ 1538 char 1539 CARDbyGetTransmitPower ( 1540 void *pDeviceHandler 1541 ) 1542 { 1543 PSDevice pDevice = (PSDevice) pDeviceHandler; 1544 1545 return (pDevice->byCurPwrdBm); 1546 } 1547 1548 //xxx 1549 void 1550 CARDvSafeResetTx ( 1551 void *pDeviceHandler 1552 ) 1553 { 1554 PSDevice pDevice = (PSDevice) pDeviceHandler; 1555 unsigned int uu; 1556 PSTxDesc pCurrTD; 1557 1558 // initialize TD index 1559 pDevice->apTailTD[0] = pDevice->apCurrTD[0] = &(pDevice->apTD0Rings[0]); 1560 pDevice->apTailTD[1] = pDevice->apCurrTD[1] = &(pDevice->apTD1Rings[0]); 1561 1562 for (uu = 0; uu < TYPE_MAXTD; uu ++) 1563 pDevice->iTDUsed[uu] = 0; 1564 1565 for (uu = 0; uu < pDevice->sOpts.nTxDescs[0]; uu++) { 1566 pCurrTD = &(pDevice->apTD0Rings[uu]); 1567 pCurrTD->m_td0TD0.f1Owner = OWNED_BY_HOST; 1568 // init all Tx Packet pointer to NULL 1569 } 1570 for (uu = 0; uu < pDevice->sOpts.nTxDescs[1]; uu++) { 1571 pCurrTD = &(pDevice->apTD1Rings[uu]); 1572 pCurrTD->m_td0TD0.f1Owner = OWNED_BY_HOST; 1573 // init all Tx Packet pointer to NULL 1574 } 1575 1576 // set MAC TD pointer 1577 MACvSetCurrTXDescAddr(TYPE_TXDMA0, pDevice->PortOffset, 1578 (pDevice->td0_pool_dma)); 1579 1580 MACvSetCurrTXDescAddr(TYPE_AC0DMA, pDevice->PortOffset, 1581 (pDevice->td1_pool_dma)); 1582 1583 // set MAC Beacon TX pointer 1584 MACvSetCurrBCNTxDescAddr(pDevice->PortOffset, 1585 (pDevice->tx_beacon_dma)); 1586 1587 } 1588 1589 1590 1591 /*+ 1592 * 1593 * Description: 1594 * Reset Rx 1595 * 1596 * Parameters: 1597 * In: 1598 * pDevice - Pointer to the adapter 1599 * Out: 1600 * none 1601 * 1602 * Return Value: none 1603 * 1604 -*/ 1605 void 1606 CARDvSafeResetRx ( 1607 void *pDeviceHandler 1608 ) 1609 { 1610 PSDevice pDevice = (PSDevice) pDeviceHandler; 1611 unsigned int uu; 1612 PSRxDesc pDesc; 1613 1614 1615 1616 // initialize RD index 1617 pDevice->pCurrRD[0]=&(pDevice->aRD0Ring[0]); 1618 pDevice->pCurrRD[1]=&(pDevice->aRD1Ring[0]); 1619 1620 // init state, all RD is chip's 1621 for (uu = 0; uu < pDevice->sOpts.nRxDescs0; uu++) { 1622 pDesc =&(pDevice->aRD0Ring[uu]); 1623 pDesc->m_rd0RD0.wResCount = (unsigned short)(pDevice->rx_buf_sz); 1624 pDesc->m_rd0RD0.f1Owner=OWNED_BY_NIC; 1625 pDesc->m_rd1RD1.wReqCount = (unsigned short)(pDevice->rx_buf_sz); 1626 } 1627 1628 // init state, all RD is chip's 1629 for (uu = 0; uu < pDevice->sOpts.nRxDescs1; uu++) { 1630 pDesc =&(pDevice->aRD1Ring[uu]); 1631 pDesc->m_rd0RD0.wResCount = (unsigned short)(pDevice->rx_buf_sz); 1632 pDesc->m_rd0RD0.f1Owner=OWNED_BY_NIC; 1633 pDesc->m_rd1RD1.wReqCount = (unsigned short)(pDevice->rx_buf_sz); 1634 } 1635 1636 pDevice->cbDFCB = CB_MAX_RX_FRAG; 1637 pDevice->cbFreeDFCB = pDevice->cbDFCB; 1638 1639 // set perPkt mode 1640 MACvRx0PerPktMode(pDevice->PortOffset); 1641 MACvRx1PerPktMode(pDevice->PortOffset); 1642 // set MAC RD pointer 1643 MACvSetCurrRx0DescAddr(pDevice->PortOffset, 1644 pDevice->rd0_pool_dma); 1645 1646 MACvSetCurrRx1DescAddr(pDevice->PortOffset, 1647 pDevice->rd1_pool_dma); 1648 } 1649 1650 1651 1652 1653 /* 1654 * Description: Get response Control frame rate in CCK mode 1655 * 1656 * Parameters: 1657 * In: 1658 * pDevice - The adapter to be set 1659 * wRateIdx - Receiving data rate 1660 * Out: 1661 * none 1662 * 1663 * Return Value: response Control frame rate 1664 * 1665 */ 1666 unsigned short CARDwGetCCKControlRate(void *pDeviceHandler, unsigned short wRateIdx) 1667 { 1668 PSDevice pDevice = (PSDevice) pDeviceHandler; 1669 unsigned int ui = (unsigned int) wRateIdx; 1670 1671 while (ui > RATE_1M) { 1672 if (pDevice->wBasicRate & ((unsigned short)1 << ui)) { 1673 return (unsigned short)ui; 1674 } 1675 ui --; 1676 } 1677 return (unsigned short)RATE_1M; 1678 } 1679 1680 /* 1681 * Description: Get response Control frame rate in OFDM mode 1682 * 1683 * Parameters: 1684 * In: 1685 * pDevice - The adapter to be set 1686 * wRateIdx - Receiving data rate 1687 * Out: 1688 * none 1689 * 1690 * Return Value: response Control frame rate 1691 * 1692 */ 1693 unsigned short CARDwGetOFDMControlRate (void *pDeviceHandler, unsigned short wRateIdx) 1694 { 1695 PSDevice pDevice = (PSDevice) pDeviceHandler; 1696 unsigned int ui = (unsigned int) wRateIdx; 1697 1698 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"BASIC RATE: %X\n", pDevice->wBasicRate); 1699 1700 if (!CARDbIsOFDMinBasicRate((void *)pDevice)) { 1701 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"CARDwGetOFDMControlRate:(NO OFDM) %d\n", wRateIdx); 1702 if (wRateIdx > RATE_24M) 1703 wRateIdx = RATE_24M; 1704 return wRateIdx; 1705 } 1706 while (ui > RATE_11M) { 1707 if (pDevice->wBasicRate & ((unsigned short)1 << ui)) { 1708 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"CARDwGetOFDMControlRate : %d\n", ui); 1709 return (unsigned short)ui; 1710 } 1711 ui --; 1712 } 1713 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"CARDwGetOFDMControlRate: 6M\n"); 1714 return (unsigned short)RATE_24M; 1715 } 1716 1717 1718 /* 1719 * Description: Set RSPINF 1720 * 1721 * Parameters: 1722 * In: 1723 * pDevice - The adapter to be set 1724 * Out: 1725 * none 1726 * 1727 * Return Value: None. 1728 * 1729 */ 1730 void CARDvSetRSPINF (void *pDeviceHandler, CARD_PHY_TYPE ePHYType) 1731 { 1732 PSDevice pDevice = (PSDevice) pDeviceHandler; 1733 unsigned char byServ = 0x00, bySignal = 0x00; //For CCK 1734 unsigned short wLen = 0x0000; 1735 unsigned char byTxRate, byRsvTime; //For OFDM 1736 1737 //Set to Page1 1738 MACvSelectPage1(pDevice->PortOffset); 1739 1740 //RSPINF_b_1 1741 BBvCaculateParameter(pDevice, 1742 14, 1743 CARDwGetCCKControlRate((void *)pDevice, RATE_1M), 1744 PK_TYPE_11B, 1745 &wLen, 1746 &byServ, 1747 &bySignal 1748 ); 1749 1750 VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_1, MAKEDWORD(wLen,MAKEWORD(bySignal,byServ))); 1751 ///RSPINF_b_2 1752 BBvCaculateParameter(pDevice, 1753 14, 1754 CARDwGetCCKControlRate((void *)pDevice, RATE_2M), 1755 PK_TYPE_11B, 1756 &wLen, 1757 &byServ, 1758 &bySignal 1759 ); 1760 1761 VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_2, MAKEDWORD(wLen,MAKEWORD(bySignal,byServ))); 1762 //RSPINF_b_5 1763 BBvCaculateParameter(pDevice, 1764 14, 1765 CARDwGetCCKControlRate((void *)pDevice, RATE_5M), 1766 PK_TYPE_11B, 1767 &wLen, 1768 &byServ, 1769 &bySignal 1770 ); 1771 1772 VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_5, MAKEDWORD(wLen,MAKEWORD(bySignal,byServ))); 1773 //RSPINF_b_11 1774 BBvCaculateParameter(pDevice, 1775 14, 1776 CARDwGetCCKControlRate((void *)pDevice, RATE_11M), 1777 PK_TYPE_11B, 1778 &wLen, 1779 &byServ, 1780 &bySignal 1781 ); 1782 1783 VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_11, MAKEDWORD(wLen,MAKEWORD(bySignal,byServ))); 1784 //RSPINF_a_6 1785 s_vCaculateOFDMRParameter(RATE_6M, 1786 ePHYType, 1787 &byTxRate, 1788 &byRsvTime); 1789 VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_6, MAKEWORD(byTxRate,byRsvTime)); 1790 //RSPINF_a_9 1791 s_vCaculateOFDMRParameter(RATE_9M, 1792 ePHYType, 1793 &byTxRate, 1794 &byRsvTime); 1795 VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_9, MAKEWORD(byTxRate,byRsvTime)); 1796 //RSPINF_a_12 1797 s_vCaculateOFDMRParameter(RATE_12M, 1798 ePHYType, 1799 &byTxRate, 1800 &byRsvTime); 1801 VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_12, MAKEWORD(byTxRate,byRsvTime)); 1802 //RSPINF_a_18 1803 s_vCaculateOFDMRParameter(RATE_18M, 1804 ePHYType, 1805 &byTxRate, 1806 &byRsvTime); 1807 VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_18, MAKEWORD(byTxRate,byRsvTime)); 1808 //RSPINF_a_24 1809 s_vCaculateOFDMRParameter(RATE_24M, 1810 ePHYType, 1811 &byTxRate, 1812 &byRsvTime); 1813 VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_24, MAKEWORD(byTxRate,byRsvTime)); 1814 //RSPINF_a_36 1815 s_vCaculateOFDMRParameter(CARDwGetOFDMControlRate((void *)pDevice, RATE_36M), 1816 ePHYType, 1817 &byTxRate, 1818 &byRsvTime); 1819 VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_36, MAKEWORD(byTxRate,byRsvTime)); 1820 //RSPINF_a_48 1821 s_vCaculateOFDMRParameter(CARDwGetOFDMControlRate((void *)pDevice, RATE_48M), 1822 ePHYType, 1823 &byTxRate, 1824 &byRsvTime); 1825 VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_48, MAKEWORD(byTxRate,byRsvTime)); 1826 //RSPINF_a_54 1827 s_vCaculateOFDMRParameter(CARDwGetOFDMControlRate((void *)pDevice, RATE_54M), 1828 ePHYType, 1829 &byTxRate, 1830 &byRsvTime); 1831 VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_54, MAKEWORD(byTxRate,byRsvTime)); 1832 1833 //RSPINF_a_72 1834 s_vCaculateOFDMRParameter(CARDwGetOFDMControlRate((void *)pDevice, RATE_54M), 1835 ePHYType, 1836 &byTxRate, 1837 &byRsvTime); 1838 VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_72, MAKEWORD(byTxRate,byRsvTime)); 1839 //Set to Page0 1840 MACvSelectPage0(pDevice->PortOffset); 1841 } 1842 1843 /* 1844 * Description: Update IFS 1845 * 1846 * Parameters: 1847 * In: 1848 * pDevice - The adapter to be set 1849 * Out: 1850 * none 1851 * 1852 * Return Value: None. 1853 * 1854 */ 1855 void vUpdateIFS (void *pDeviceHandler) 1856 { 1857 //Set SIFS, DIFS, EIFS, SlotTime, CwMin 1858 PSDevice pDevice = (PSDevice) pDeviceHandler; 1859 1860 unsigned char byMaxMin = 0; 1861 if (pDevice->byPacketType==PK_TYPE_11A) {//0000 0000 0000 0000,11a 1862 pDevice->uSlot = C_SLOT_SHORT; 1863 pDevice->uSIFS = C_SIFS_A; 1864 pDevice->uDIFS = C_SIFS_A + 2*C_SLOT_SHORT; 1865 pDevice->uCwMin = C_CWMIN_A; 1866 byMaxMin = 4; 1867 } 1868 else if (pDevice->byPacketType==PK_TYPE_11B) {//0000 0001 0000 0000,11b 1869 pDevice->uSlot = C_SLOT_LONG; 1870 pDevice->uSIFS = C_SIFS_BG; 1871 pDevice->uDIFS = C_SIFS_BG + 2*C_SLOT_LONG; 1872 pDevice->uCwMin = C_CWMIN_B; 1873 byMaxMin = 5; 1874 } 1875 else { // PK_TYPE_11GA & PK_TYPE_11GB 1876 pDevice->uSIFS = C_SIFS_BG; 1877 if (pDevice->bShortSlotTime) { 1878 pDevice->uSlot = C_SLOT_SHORT; 1879 } else { 1880 pDevice->uSlot = C_SLOT_LONG; 1881 } 1882 pDevice->uDIFS = C_SIFS_BG + 2*pDevice->uSlot; 1883 if (pDevice->wBasicRate & 0x0150) { //0000 0001 0101 0000,24M,12M,6M 1884 pDevice->uCwMin = C_CWMIN_A; 1885 byMaxMin = 4; 1886 } 1887 else { 1888 pDevice->uCwMin = C_CWMIN_B; 1889 byMaxMin = 5; 1890 } 1891 } 1892 1893 pDevice->uCwMax = C_CWMAX; 1894 pDevice->uEIFS = C_EIFS; 1895 if (pDevice->byRFType == RF_RFMD2959) { 1896 // bcs TX_PE will reserve 3 us 1897 VNSvOutPortB(pDevice->PortOffset + MAC_REG_SIFS, (unsigned char)(pDevice->uSIFS - 3)); 1898 VNSvOutPortB(pDevice->PortOffset + MAC_REG_DIFS, (unsigned char)(pDevice->uDIFS - 3)); 1899 } else { 1900 VNSvOutPortB(pDevice->PortOffset + MAC_REG_SIFS, (unsigned char)pDevice->uSIFS); 1901 VNSvOutPortB(pDevice->PortOffset + MAC_REG_DIFS, (unsigned char)pDevice->uDIFS); 1902 } 1903 VNSvOutPortB(pDevice->PortOffset + MAC_REG_EIFS, (unsigned char)pDevice->uEIFS); 1904 VNSvOutPortB(pDevice->PortOffset + MAC_REG_SLOT, (unsigned char)pDevice->uSlot); 1905 byMaxMin |= 0xA0;//1010 1111,C_CWMAX = 1023 1906 VNSvOutPortB(pDevice->PortOffset + MAC_REG_CWMAXMIN0, (unsigned char)byMaxMin); 1907 } 1908 1909 void CARDvUpdateBasicTopRate (void *pDeviceHandler) 1910 { 1911 PSDevice pDevice = (PSDevice) pDeviceHandler; 1912 unsigned char byTopOFDM = RATE_24M, byTopCCK = RATE_1M; 1913 unsigned char ii; 1914 1915 //Determines the highest basic rate. 1916 for (ii = RATE_54M; ii >= RATE_6M; ii --) { 1917 if ( (pDevice->wBasicRate) & ((unsigned short)(1<<ii)) ) { 1918 byTopOFDM = ii; 1919 break; 1920 } 1921 } 1922 pDevice->byTopOFDMBasicRate = byTopOFDM; 1923 1924 for (ii = RATE_11M;; ii --) { 1925 if ( (pDevice->wBasicRate) & ((unsigned short)(1<<ii)) ) { 1926 byTopCCK = ii; 1927 break; 1928 } 1929 if (ii == RATE_1M) 1930 break; 1931 } 1932 pDevice->byTopCCKBasicRate = byTopCCK; 1933 } 1934 1935 1936 /* 1937 * Description: Set NIC Tx Basic Rate 1938 * 1939 * Parameters: 1940 * In: 1941 * pDevice - The adapter to be set 1942 * wBasicRate - Basic Rate to be set 1943 * Out: 1944 * none 1945 * 1946 * Return Value: true if succeeded; false if failed. 1947 * 1948 */ 1949 bool CARDbAddBasicRate (void *pDeviceHandler, unsigned short wRateIdx) 1950 { 1951 PSDevice pDevice = (PSDevice) pDeviceHandler; 1952 unsigned short wRate = (unsigned short)(1<<wRateIdx); 1953 1954 pDevice->wBasicRate |= wRate; 1955 1956 //Determines the highest basic rate. 1957 CARDvUpdateBasicTopRate((void *)pDevice); 1958 1959 return(true); 1960 } 1961 1962 bool CARDbIsOFDMinBasicRate (void *pDeviceHandler) 1963 { 1964 PSDevice pDevice = (PSDevice) pDeviceHandler; 1965 int ii; 1966 1967 for (ii = RATE_54M; ii >= RATE_6M; ii --) { 1968 if ((pDevice->wBasicRate) & ((unsigned short)(1<<ii))) 1969 return true; 1970 } 1971 return false; 1972 } 1973 1974 unsigned char CARDbyGetPktType (void *pDeviceHandler) 1975 { 1976 PSDevice pDevice = (PSDevice) pDeviceHandler; 1977 1978 if (pDevice->byBBType == BB_TYPE_11A || pDevice->byBBType == BB_TYPE_11B) { 1979 return (unsigned char)pDevice->byBBType; 1980 } 1981 else if (CARDbIsOFDMinBasicRate((void *)pDevice)) { 1982 return PK_TYPE_11GA; 1983 } 1984 else { 1985 return PK_TYPE_11GB; 1986 } 1987 } 1988 1989 /* 1990 * Description: Set NIC Loopback mode 1991 * 1992 * Parameters: 1993 * In: 1994 * pDevice - The adapter to be set 1995 * wLoopbackMode - Loopback mode to be set 1996 * Out: 1997 * none 1998 * 1999 * Return Value: none 2000 * 2001 */ 2002 void CARDvSetLoopbackMode (unsigned long dwIoBase, unsigned short wLoopbackMode) 2003 { 2004 switch(wLoopbackMode) { 2005 case CARD_LB_NONE: 2006 case CARD_LB_MAC: 2007 case CARD_LB_PHY: 2008 break; 2009 default: 2010 ASSERT(false); 2011 break; 2012 } 2013 // set MAC loopback 2014 MACvSetLoopbackMode(dwIoBase, LOBYTE(wLoopbackMode)); 2015 // set Baseband loopback 2016 } 2017 2018 2019 /* 2020 * Description: Software Reset NIC 2021 * 2022 * Parameters: 2023 * In: 2024 * pDevice - The adapter to be reset 2025 * Out: 2026 * none 2027 * 2028 * Return Value: none 2029 * 2030 */ 2031 bool CARDbSoftwareReset (void *pDeviceHandler) 2032 { 2033 PSDevice pDevice = (PSDevice) pDeviceHandler; 2034 2035 // reset MAC 2036 if (!MACbSafeSoftwareReset(pDevice->PortOffset)) 2037 return false; 2038 2039 return true; 2040 } 2041 2042 2043 /* 2044 * Description: Caculate TSF offset of two TSF input 2045 * Get TSF Offset from RxBCN's TSF and local TSF 2046 * 2047 * Parameters: 2048 * In: 2049 * pDevice - The adapter to be sync. 2050 * qwTSF1 - Rx BCN's TSF 2051 * qwTSF2 - Local TSF 2052 * Out: 2053 * none 2054 * 2055 * Return Value: TSF Offset value 2056 * 2057 */ 2058 QWORD CARDqGetTSFOffset (unsigned char byRxRate, QWORD qwTSF1, QWORD qwTSF2) 2059 { 2060 QWORD qwTSFOffset; 2061 unsigned short wRxBcnTSFOffst= 0; 2062 2063 HIDWORD(qwTSFOffset) = 0; 2064 LODWORD(qwTSFOffset) = 0; 2065 wRxBcnTSFOffst = cwRXBCNTSFOff[byRxRate%MAX_RATE]; 2066 (qwTSF2).u.dwLowDword += (unsigned long)(wRxBcnTSFOffst); 2067 if ((qwTSF2).u.dwLowDword < (unsigned long)(wRxBcnTSFOffst)) { 2068 (qwTSF2).u.dwHighDword++; 2069 } 2070 LODWORD(qwTSFOffset) = LODWORD(qwTSF1) - LODWORD(qwTSF2); 2071 if (LODWORD(qwTSF1) < LODWORD(qwTSF2)) { 2072 // if borrow needed 2073 HIDWORD(qwTSFOffset) = HIDWORD(qwTSF1) - HIDWORD(qwTSF2) - 1 ; 2074 } 2075 else { 2076 HIDWORD(qwTSFOffset) = HIDWORD(qwTSF1) - HIDWORD(qwTSF2); 2077 }; 2078 return (qwTSFOffset); 2079 } 2080 2081 2082 /* 2083 * Description: Read NIC TSF counter 2084 * Get local TSF counter 2085 * 2086 * Parameters: 2087 * In: 2088 * pDevice - The adapter to be read 2089 * Out: 2090 * qwCurrTSF - Current TSF counter 2091 * 2092 * Return Value: true if success; otherwise false 2093 * 2094 */ 2095 bool CARDbGetCurrentTSF (unsigned long dwIoBase, PQWORD pqwCurrTSF) 2096 { 2097 unsigned short ww; 2098 unsigned char byData; 2099 2100 MACvRegBitsOn(dwIoBase, MAC_REG_TFTCTL, TFTCTL_TSFCNTRRD); 2101 for (ww = 0; ww < W_MAX_TIMEOUT; ww++) { 2102 VNSvInPortB(dwIoBase + MAC_REG_TFTCTL, &byData); 2103 if ( !(byData & TFTCTL_TSFCNTRRD)) 2104 break; 2105 } 2106 if (ww == W_MAX_TIMEOUT) 2107 return(false); 2108 VNSvInPortD(dwIoBase + MAC_REG_TSFCNTR, &LODWORD(*pqwCurrTSF)); 2109 VNSvInPortD(dwIoBase + MAC_REG_TSFCNTR + 4, &HIDWORD(*pqwCurrTSF)); 2110 2111 return(true); 2112 } 2113 2114 2115 /* 2116 * Description: Read NIC TSF counter 2117 * Get NEXTTBTT from adjusted TSF and Beacon Interval 2118 * 2119 * Parameters: 2120 * In: 2121 * qwTSF - Current TSF counter 2122 * wbeaconInterval - Beacon Interval 2123 * Out: 2124 * qwCurrTSF - Current TSF counter 2125 * 2126 * Return Value: TSF value of next Beacon 2127 * 2128 */ 2129 QWORD CARDqGetNextTBTT (QWORD qwTSF, unsigned short wBeaconInterval) 2130 { 2131 2132 unsigned int uLowNextTBTT; 2133 unsigned int uHighRemain, uLowRemain; 2134 unsigned int uBeaconInterval; 2135 2136 uBeaconInterval = wBeaconInterval * 1024; 2137 // Next TBTT = ((local_current_TSF / beacon_interval) + 1 ) * beacon_interval 2138 uLowNextTBTT = (LODWORD(qwTSF) >> 10) << 10; 2139 // low dword (mod) bcn 2140 uLowRemain = (uLowNextTBTT) % uBeaconInterval; 2141 // uHighRemain = ((0x80000000 % uBeaconInterval)* 2 * HIDWORD(qwTSF)) 2142 // % uBeaconInterval; 2143 // high dword (mod) bcn 2144 uHighRemain = (((0xffffffff % uBeaconInterval) + 1) * HIDWORD(qwTSF)) 2145 % uBeaconInterval; 2146 uLowRemain = (uHighRemain + uLowRemain) % uBeaconInterval; 2147 uLowRemain = uBeaconInterval - uLowRemain; 2148 2149 // check if carry when add one beacon interval 2150 if ((~uLowNextTBTT) < uLowRemain) 2151 HIDWORD(qwTSF) ++ ; 2152 2153 LODWORD(qwTSF) = uLowNextTBTT + uLowRemain; 2154 2155 return (qwTSF); 2156 } 2157 2158 2159 /* 2160 * Description: Set NIC TSF counter for first Beacon time 2161 * Get NEXTTBTT from adjusted TSF and Beacon Interval 2162 * 2163 * Parameters: 2164 * In: 2165 * dwIoBase - IO Base 2166 * wBeaconInterval - Beacon Interval 2167 * Out: 2168 * none 2169 * 2170 * Return Value: none 2171 * 2172 */ 2173 void CARDvSetFirstNextTBTT (unsigned long dwIoBase, unsigned short wBeaconInterval) 2174 { 2175 2176 QWORD qwNextTBTT; 2177 2178 HIDWORD(qwNextTBTT) = 0; 2179 LODWORD(qwNextTBTT) = 0; 2180 CARDbGetCurrentTSF(dwIoBase, &qwNextTBTT); //Get Local TSF counter 2181 qwNextTBTT = CARDqGetNextTBTT(qwNextTBTT, wBeaconInterval); 2182 // Set NextTBTT 2183 VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT, LODWORD(qwNextTBTT)); 2184 VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT + 4, HIDWORD(qwNextTBTT)); 2185 MACvRegBitsOn(dwIoBase, MAC_REG_TFTCTL, TFTCTL_TBTTSYNCEN); 2186 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Card:First Next TBTT[%8xh:%8xh] \n", HIDWORD(qwNextTBTT), LODWORD(qwNextTBTT)); 2187 return; 2188 } 2189 2190 2191 /* 2192 * Description: Sync NIC TSF counter for Beacon time 2193 * Get NEXTTBTT and write to HW 2194 * 2195 * Parameters: 2196 * In: 2197 * pDevice - The adapter to be set 2198 * qwTSF - Current TSF counter 2199 * wBeaconInterval - Beacon Interval 2200 * Out: 2201 * none 2202 * 2203 * Return Value: none 2204 * 2205 */ 2206 void CARDvUpdateNextTBTT (unsigned long dwIoBase, QWORD qwTSF, unsigned short wBeaconInterval) 2207 { 2208 2209 qwTSF = CARDqGetNextTBTT(qwTSF, wBeaconInterval); 2210 // Set NextTBTT 2211 VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT, LODWORD(qwTSF)); 2212 VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT + 4, HIDWORD(qwTSF)); 2213 MACvRegBitsOn(dwIoBase, MAC_REG_TFTCTL, TFTCTL_TBTTSYNCEN); 2214 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Card:Update Next TBTT[%8xh:%8xh] \n", 2215 (unsigned int) HIDWORD(qwTSF), (unsigned int) LODWORD(qwTSF)); 2216 2217 return; 2218 } 2219 2220 2221 2222 2223 2224 2225 2226