wcmd.c revision 3a215e0ff4184314f7f1a099354a272ddedff289
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: wcmd.c 20 * 21 * Purpose: Handles the management command interface functions 22 * 23 * Author: Lyndon Chen 24 * 25 * Date: May 8, 2003 26 * 27 * Functions: 28 * s_vProbeChannel - Active scan channel 29 * s_MgrMakeProbeRequest - Make ProbeRequest packet 30 * CommandTimer - Timer function to handle command 31 * s_bCommandComplete - Command Complete function 32 * bScheduleCommand - Push Command and wait Command Scheduler to do 33 * vCommandTimer- Command call back functions 34 * vCommandTimerWait- Call back timer 35 * bClearBSSID_SCAN- Clear BSSID_SCAN cmd in CMD Queue 36 * 37 * Revision History: 38 * 39 */ 40 41#include "ttype.h" 42#include "tmacro.h" 43#include "device.h" 44#include "mac.h" 45#include "card.h" 46#include "80211hdr.h" 47#include "wcmd.h" 48#include "wmgr.h" 49#include "power.h" 50#include "wctl.h" 51#include "baseband.h" 52#include "rxtx.h" 53#include "rf.h" 54#include "iowpa.h" 55 56/*--------------------- Static Definitions -------------------------*/ 57 58 59 60 61/*--------------------- Static Classes ----------------------------*/ 62 63/*--------------------- Static Variables --------------------------*/ 64static int msglevel =MSG_LEVEL_INFO; 65//static int msglevel =MSG_LEVEL_DEBUG; 66/*--------------------- Static Functions --------------------------*/ 67 68static 69void 70s_vProbeChannel( 71 PSDevice pDevice 72 ); 73 74 75static 76PSTxMgmtPacket 77s_MgrMakeProbeRequest( 78 PSDevice pDevice, 79 PSMgmtObject pMgmt, 80 PBYTE pScanBSSID, 81 PWLAN_IE_SSID pSSID, 82 PWLAN_IE_SUPP_RATES pCurrRates, 83 PWLAN_IE_SUPP_RATES pCurrExtSuppRates 84 ); 85 86 87static 88BOOL 89s_bCommandComplete ( 90 PSDevice pDevice 91 ); 92 93/*--------------------- Export Variables --------------------------*/ 94 95 96/*--------------------- Export Functions --------------------------*/ 97 98 99 100/* 101 * Description: 102 * Stop AdHoc beacon during scan process 103 * 104 * Parameters: 105 * In: 106 * pDevice - Pointer to the adapter 107 * Out: 108 * none 109 * 110 * Return Value: none 111 * 112 */ 113static 114void 115vAdHocBeaconStop(PSDevice pDevice) 116{ 117 118 PSMgmtObject pMgmt = &(pDevice->sMgmtObj); 119 BOOL bStop; 120 121 /* 122 * temporarily stop Beacon packet for AdHoc Server 123 * if all of the following coditions are met: 124 * (1) STA is in AdHoc mode 125 * (2) VT3253 is programmed as automatic Beacon Transmitting 126 * (3) One of the following conditions is met 127 * (3.1) AdHoc channel is in B/G band and the 128 * current scan channel is in A band 129 * or 130 * (3.2) AdHoc channel is in A mode 131 */ 132 bStop = FALSE; 133 if ((pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) && 134 (pMgmt->eCurrState >= WMAC_STATE_STARTED)) 135 { 136 if ((pMgmt->uIBSSChannel <= CB_MAX_CHANNEL_24G) && 137 (pMgmt->uScanChannel > CB_MAX_CHANNEL_24G)) 138 { 139 bStop = TRUE; 140 } 141 if (pMgmt->uIBSSChannel > CB_MAX_CHANNEL_24G) 142 { 143 bStop = TRUE; 144 } 145 } 146 147 if (bStop) 148 { 149 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_TCR, TCR_AUTOBCNTX); 150 } 151 152} /* vAdHocBeaconStop */ 153 154 155/* 156 * Description: 157 * Restart AdHoc beacon after scan process complete 158 * 159 * Parameters: 160 * In: 161 * pDevice - Pointer to the adapter 162 * Out: 163 * none 164 * 165 * Return Value: none 166 * 167 */ 168static 169void 170vAdHocBeaconRestart(PSDevice pDevice) 171{ 172 PSMgmtObject pMgmt = &(pDevice->sMgmtObj); 173 174 /* 175 * Restart Beacon packet for AdHoc Server 176 * if all of the following coditions are met: 177 * (1) STA is in AdHoc mode 178 * (2) VT3253 is programmed as automatic Beacon Transmitting 179 */ 180 if ((pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) && 181 (pMgmt->eCurrState >= WMAC_STATE_STARTED)) 182 { 183 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_TCR, TCR_AUTOBCNTX); 184 } 185 186} 187 188 189 190 191 192 193/*+ 194 * 195 * Routine Description: 196 * Prepare and send probe request management frames. 197 * 198 * 199 * Return Value: 200 * none. 201 * 202-*/ 203 204static 205void 206s_vProbeChannel( 207 PSDevice pDevice 208 ) 209{ 210 //1M, 2M, 5M, 11M, 18M, 24M, 36M, 54M 211 BYTE abyCurrSuppRatesG[] = {WLAN_EID_SUPP_RATES, 8, 0x02, 0x04, 0x0B, 0x16, 0x24, 0x30, 0x48, 0x6C}; 212 BYTE abyCurrExtSuppRatesG[] = {WLAN_EID_EXTSUPP_RATES, 4, 0x0C, 0x12, 0x18, 0x60}; 213 //6M, 9M, 12M, 48M 214 BYTE abyCurrSuppRatesA[] = {WLAN_EID_SUPP_RATES, 8, 0x0C, 0x12, 0x18, 0x24, 0x30, 0x48, 0x60, 0x6C}; 215 BYTE abyCurrSuppRatesB[] = {WLAN_EID_SUPP_RATES, 4, 0x02, 0x04, 0x0B, 0x16}; 216 PBYTE pbyRate; 217 PSTxMgmtPacket pTxPacket; 218 PSMgmtObject pMgmt = pDevice->pMgmt; 219 UINT ii; 220 221 222 if (pDevice->eCurrentPHYType == PHY_TYPE_11A) { 223 pbyRate = &abyCurrSuppRatesA[0]; 224 } else if (pDevice->eCurrentPHYType == PHY_TYPE_11B) { 225 pbyRate = &abyCurrSuppRatesB[0]; 226 } else { 227 pbyRate = &abyCurrSuppRatesG[0]; 228 } 229 // build an assocreq frame and send it 230 pTxPacket = s_MgrMakeProbeRequest 231 ( 232 pDevice, 233 pMgmt, 234 pMgmt->abyScanBSSID, 235 (PWLAN_IE_SSID)pMgmt->abyScanSSID, 236 (PWLAN_IE_SUPP_RATES)pbyRate, 237 (PWLAN_IE_SUPP_RATES)abyCurrExtSuppRatesG 238 ); 239 240 if (pTxPacket != NULL ){ 241 for (ii = 0; ii < 2 ; ii++) { 242 if (csMgmt_xmit(pDevice, pTxPacket) != CMD_STATUS_PENDING) { 243 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Probe request sending fail.. \n"); 244 } 245 else { 246 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Probe request is sending.. \n"); 247 } 248 } 249 } 250 251} 252 253 254 255 256/*+ 257 * 258 * Routine Description: 259 * Constructs an probe request frame 260 * 261 * 262 * Return Value: 263 * A ptr to Tx frame or NULL on allocation failue 264 * 265-*/ 266 267 268PSTxMgmtPacket 269s_MgrMakeProbeRequest( 270 PSDevice pDevice, 271 PSMgmtObject pMgmt, 272 PBYTE pScanBSSID, 273 PWLAN_IE_SSID pSSID, 274 PWLAN_IE_SUPP_RATES pCurrRates, 275 PWLAN_IE_SUPP_RATES pCurrExtSuppRates 276 277 ) 278{ 279 PSTxMgmtPacket pTxPacket = NULL; 280 WLAN_FR_PROBEREQ sFrame; 281 282 283 pTxPacket = (PSTxMgmtPacket)pMgmt->pbyMgmtPacketPool; 284 memset(pTxPacket, 0, sizeof(STxMgmtPacket) + WLAN_PROBEREQ_FR_MAXLEN); 285 pTxPacket->p80211Header = (PUWLAN_80211HDR)((PBYTE)pTxPacket + sizeof(STxMgmtPacket)); 286 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header; 287 sFrame.len = WLAN_PROBEREQ_FR_MAXLEN; 288 vMgrEncodeProbeRequest(&sFrame); 289 sFrame.pHdr->sA3.wFrameCtl = cpu_to_le16( 290 ( 291 WLAN_SET_FC_FTYPE(WLAN_TYPE_MGR) | 292 WLAN_SET_FC_FSTYPE(WLAN_FSTYPE_PROBEREQ) 293 )); 294 memcpy( sFrame.pHdr->sA3.abyAddr1, pScanBSSID, WLAN_ADDR_LEN); 295 memcpy( sFrame.pHdr->sA3.abyAddr2, pMgmt->abyMACAddr, WLAN_ADDR_LEN); 296 memcpy( sFrame.pHdr->sA3.abyAddr3, pScanBSSID, WLAN_BSSID_LEN); 297 // Copy the SSID, pSSID->len=0 indicate broadcast SSID 298 sFrame.pSSID = (PWLAN_IE_SSID)(sFrame.pBuf + sFrame.len); 299 sFrame.len += pSSID->len + WLAN_IEHDR_LEN; 300 memcpy(sFrame.pSSID, pSSID, pSSID->len + WLAN_IEHDR_LEN); 301 sFrame.pSuppRates = (PWLAN_IE_SUPP_RATES)(sFrame.pBuf + sFrame.len); 302 sFrame.len += pCurrRates->len + WLAN_IEHDR_LEN; 303 memcpy(sFrame.pSuppRates, pCurrRates, pCurrRates->len + WLAN_IEHDR_LEN); 304 // Copy the extension rate set 305 if (pDevice->eCurrentPHYType == PHY_TYPE_11G) { 306 sFrame.pExtSuppRates = (PWLAN_IE_SUPP_RATES)(sFrame.pBuf + sFrame.len); 307 sFrame.len += pCurrExtSuppRates->len + WLAN_IEHDR_LEN; 308 memcpy(sFrame.pExtSuppRates, pCurrExtSuppRates, pCurrExtSuppRates->len + WLAN_IEHDR_LEN); 309 } 310 pTxPacket->cbMPDULen = sFrame.len; 311 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN; 312 313 return pTxPacket; 314} 315 316 317 318 319 320void 321vCommandTimerWait( 322 void *hDeviceContext, 323 UINT MSecond 324 ) 325{ 326 PSDevice pDevice = (PSDevice)hDeviceContext; 327 328 init_timer(&pDevice->sTimerCommand); 329 pDevice->sTimerCommand.data = (ULONG)pDevice; 330 pDevice->sTimerCommand.function = (TimerFunction)vCommandTimer; 331 // RUN_AT :1 msec ~= (HZ/1024) 332 pDevice->sTimerCommand.expires = (UINT)RUN_AT((MSecond * HZ) >> 10); 333 add_timer(&pDevice->sTimerCommand); 334 return; 335} 336 337 338 339 340void 341vCommandTimer ( 342 void *hDeviceContext 343 ) 344{ 345 PSDevice pDevice = (PSDevice)hDeviceContext; 346 PSMgmtObject pMgmt = pDevice->pMgmt; 347 PWLAN_IE_SSID pItemSSID; 348 PWLAN_IE_SSID pItemSSIDCurr; 349 CMD_STATUS Status; 350 UINT ii; 351 BYTE byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80}; 352 struct sk_buff *skb; 353 354 355 if (pDevice->dwDiagRefCount != 0) 356 return; 357 if (pDevice->bCmdRunning != TRUE) 358 return; 359 360 spin_lock_irq(&pDevice->lock); 361 362 switch ( pDevice->eCommandState ) { 363 364 case WLAN_CMD_SCAN_START: 365 366 pDevice->byReAssocCount = 0; 367 if (pDevice->bRadioOff == TRUE) { 368 s_bCommandComplete(pDevice); 369 spin_unlock_irq(&pDevice->lock); 370 return; 371 } 372 373 if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) { 374 s_bCommandComplete(pDevice); 375 CARDbSetBSSID(pMgmt->pAdapter, pMgmt->abyCurrBSSID, OP_MODE_AP); 376 spin_unlock_irq(&pDevice->lock); 377 return; 378 } 379 380 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCommandState= WLAN_CMD_SCAN_START\n"); 381 pItemSSID = (PWLAN_IE_SSID)pMgmt->abyScanSSID; 382 // wait all Data TD complete 383 if (pDevice->iTDUsed[TYPE_AC0DMA] != 0){ 384 spin_unlock_irq(&pDevice->lock); 385 vCommandTimerWait((void *)pDevice, 10); 386 return; 387 }; 388 389 if (pMgmt->uScanChannel == 0 ) { 390 pMgmt->uScanChannel = pDevice->byMinChannel; 391 // Set Baseband to be more sensitive. 392 393 } 394 if (pMgmt->uScanChannel > pDevice->byMaxChannel) { 395 pMgmt->eScanState = WMAC_NO_SCANNING; 396 397 // Set Baseband's sensitivity back. 398 // Set channel back 399 CARDbSetChannel(pMgmt->pAdapter, pMgmt->uCurrChannel); 400 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Scanning, set back to channel: [%d]\n", pMgmt->uCurrChannel); 401 if (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) { 402 CARDbSetBSSID(pMgmt->pAdapter, pMgmt->abyCurrBSSID, OP_MODE_ADHOC); 403 } else { 404 CARDbSetBSSID(pMgmt->pAdapter, pMgmt->abyCurrBSSID, OP_MODE_INFRASTRUCTURE); 405 } 406 vAdHocBeaconRestart(pDevice); 407 s_bCommandComplete(pDevice); 408 409 } else { 410//2008-8-4 <add> by chester 411 if (!ChannelValid(pDevice->byZoneType, pMgmt->uScanChannel)) { 412 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Invalid channel pMgmt->uScanChannel = %d \n",pMgmt->uScanChannel); 413 s_bCommandComplete(pDevice); 414 return; 415 } 416//printk("chester-pMgmt->uScanChannel=%d,pDevice->byMaxChannel=%d\n",pMgmt->uScanChannel,pDevice->byMaxChannel); 417 if (pMgmt->uScanChannel == pDevice->byMinChannel) { 418 //pMgmt->eScanType = WMAC_SCAN_ACTIVE; 419 pMgmt->abyScanBSSID[0] = 0xFF; 420 pMgmt->abyScanBSSID[1] = 0xFF; 421 pMgmt->abyScanBSSID[2] = 0xFF; 422 pMgmt->abyScanBSSID[3] = 0xFF; 423 pMgmt->abyScanBSSID[4] = 0xFF; 424 pMgmt->abyScanBSSID[5] = 0xFF; 425 pItemSSID->byElementID = WLAN_EID_SSID; 426 // clear bssid list 427 // BSSvClearBSSList((void *)pDevice, pDevice->bLinkPass); 428 pMgmt->eScanState = WMAC_IS_SCANNING; 429 430 } 431 432 vAdHocBeaconStop(pDevice); 433 434 if (CARDbSetChannel(pMgmt->pAdapter, pMgmt->uScanChannel) == TRUE) { 435 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"SCAN Channel: %d\n", pMgmt->uScanChannel); 436 } else { 437 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"SET SCAN Channel Fail: %d\n", pMgmt->uScanChannel); 438 } 439 CARDbSetBSSID(pMgmt->pAdapter, pMgmt->abyCurrBSSID, OP_MODE_UNKNOWN); 440// printk("chester-mxch=%d\n",pDevice->byMaxChannel); 441 // printk("chester-ch=%d\n",pMgmt->uScanChannel); 442 pMgmt->uScanChannel++; 443//2008-8-4 <modify> by chester 444 if (!ChannelValid(pDevice->byZoneType, pMgmt->uScanChannel) && 445 pMgmt->uScanChannel <= pDevice->byMaxChannel ){ 446 pMgmt->uScanChannel=pDevice->byMaxChannel+1; 447 pMgmt->eCommandState = WLAN_CMD_SCAN_END; 448 449 } 450 451 452 if ((pMgmt->b11hEnable == FALSE) || 453 (pMgmt->uScanChannel < CB_MAX_CHANNEL_24G)) { 454 s_vProbeChannel(pDevice); 455 spin_unlock_irq(&pDevice->lock); 456 vCommandTimerWait((void *)pDevice, WCMD_ACTIVE_SCAN_TIME); 457 return; 458 } else { 459 spin_unlock_irq(&pDevice->lock); 460 vCommandTimerWait((void *)pDevice, WCMD_PASSIVE_SCAN_TIME); 461 return; 462 } 463 464 } 465 466 break; 467 468 case WLAN_CMD_SCAN_END: 469 470 // Set Baseband's sensitivity back. 471 // Set channel back 472 CARDbSetChannel(pMgmt->pAdapter, pMgmt->uCurrChannel); 473 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Scanning, set back to channel: [%d]\n", pMgmt->uCurrChannel); 474 if (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) { 475 CARDbSetBSSID(pMgmt->pAdapter, pMgmt->abyCurrBSSID, OP_MODE_ADHOC); 476 } else { 477 CARDbSetBSSID(pMgmt->pAdapter, pMgmt->abyCurrBSSID, OP_MODE_INFRASTRUCTURE); 478 } 479 480 pMgmt->eScanState = WMAC_NO_SCANNING; 481 vAdHocBeaconRestart(pDevice); 482//2008-0409-07, <Add> by Einsn Liu 483#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT 484 if(pMgmt->eScanType == WMAC_SCAN_PASSIVE) 485 {//send scan event to wpa_Supplicant 486 union iwreq_data wrqu; 487 memset(&wrqu, 0, sizeof(wrqu)); 488 wireless_send_event(pDevice->dev, SIOCGIWSCAN, &wrqu, NULL); 489 } 490#endif 491 s_bCommandComplete(pDevice); 492 break; 493 494 case WLAN_CMD_DISASSOCIATE_START : 495 pDevice->byReAssocCount = 0; 496 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_STA) && 497 (pMgmt->eCurrState != WMAC_STATE_ASSOC)) { 498 s_bCommandComplete(pDevice); 499 spin_unlock_irq(&pDevice->lock); 500 return; 501 } else { 502 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Send Disassociation Packet..\n"); 503 // reason = 8 : disassoc because sta has left 504 vMgrDisassocBeginSta((void *)pDevice, pMgmt, pMgmt->abyCurrBSSID, (8), &Status); 505 pDevice->bLinkPass = FALSE; 506 // unlock command busy 507 pItemSSID = (PWLAN_IE_SSID)pMgmt->abyCurrSSID; 508 pItemSSID->len = 0; 509 memset(pItemSSID->abySSID, 0, WLAN_SSID_MAXLEN); 510 pMgmt->eCurrState = WMAC_STATE_IDLE; 511 pMgmt->sNodeDBTable[0].bActive = FALSE; 512// pDevice->bBeaconBufReady = FALSE; 513 } 514 netif_stop_queue(pDevice->dev); 515 pDevice->eCommandState = WLAN_DISASSOCIATE_WAIT; 516 // wait all Control TD complete 517 if (pDevice->iTDUsed[TYPE_TXDMA0] != 0){ 518 vCommandTimerWait((void *)pDevice, 10); 519 spin_unlock_irq(&pDevice->lock); 520 return; 521 }; 522 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" CARDbRadioPowerOff\n"); 523 //2008-09-02 <mark> by chester 524 // CARDbRadioPowerOff(pDevice); 525 s_bCommandComplete(pDevice); 526 break; 527 528 case WLAN_DISASSOCIATE_WAIT : 529 // wait all Control TD complete 530 if (pDevice->iTDUsed[TYPE_TXDMA0] != 0){ 531 vCommandTimerWait((void *)pDevice, 10); 532 spin_unlock_irq(&pDevice->lock); 533 return; 534 }; 535//2008-09-02 <mark> by chester 536 // CARDbRadioPowerOff(pDevice); 537 s_bCommandComplete(pDevice); 538 break; 539 540 case WLAN_CMD_SSID_START: 541 pDevice->byReAssocCount = 0; 542 if (pDevice->bRadioOff == TRUE) { 543 s_bCommandComplete(pDevice); 544 spin_unlock_irq(&pDevice->lock); 545 return; 546 } 547//printk("chester-currmode=%d\n",pMgmt->eCurrMode); 548printk("chester-abyDesireSSID=%s\n",((PWLAN_IE_SSID)pMgmt->abyDesireSSID)->abySSID); 549 //memcpy(pMgmt->abyAdHocSSID,pMgmt->abyDesireSSID, 550 //((PWLAN_IE_SSID)pMgmt->abyDesireSSID)->len + WLAN_IEHDR_LEN); 551 pItemSSID = (PWLAN_IE_SSID)pMgmt->abyDesireSSID; 552 pItemSSIDCurr = (PWLAN_IE_SSID)pMgmt->abyCurrSSID; 553 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" cmd: desire ssid = %s\n", pItemSSID->abySSID); 554 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" cmd: curr ssid = %s\n", pItemSSIDCurr->abySSID); 555 556 if (pMgmt->eCurrState == WMAC_STATE_ASSOC) { 557 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Cmd pMgmt->eCurrState == WMAC_STATE_ASSOC\n"); 558 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" pItemSSID->len =%d\n",pItemSSID->len); 559 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" pItemSSIDCurr->len = %d\n",pItemSSIDCurr->len); 560 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" desire ssid = %s\n", pItemSSID->abySSID); 561 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" curr ssid = %s\n", pItemSSIDCurr->abySSID); 562 } 563 564 if ((pMgmt->eCurrState == WMAC_STATE_ASSOC) || 565 ((pMgmt->eCurrMode == WMAC_MODE_IBSS_STA)&& (pMgmt->eCurrState == WMAC_STATE_JOINTED))) { 566 567 if (pItemSSID->len == pItemSSIDCurr->len) { 568 if (memcmp(pItemSSID->abySSID, pItemSSIDCurr->abySSID, pItemSSID->len) == 0) { 569 s_bCommandComplete(pDevice); 570 spin_unlock_irq(&pDevice->lock); 571 return; 572 } 573 } 574 575 netif_stop_queue(pDevice->dev); 576 pDevice->bLinkPass = FALSE; 577 } 578 // set initial state 579 pMgmt->eCurrState = WMAC_STATE_IDLE; 580 pMgmt->eCurrMode = WMAC_MODE_STANDBY; 581 PSvDisablePowerSaving((void *)pDevice); 582 BSSvClearNodeDBTable(pDevice, 0); 583 584 vMgrJoinBSSBegin((void *)pDevice, &Status); 585 // if Infra mode 586 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_STA) && (pMgmt->eCurrState == WMAC_STATE_JOINTED)) { 587 588 // Call mgr to begin the deauthentication 589 // reason = (3) beacuse sta has left ESS 590 if (pMgmt->eCurrState>= WMAC_STATE_AUTH) { 591 vMgrDeAuthenBeginSta((void *)pDevice, pMgmt, pMgmt->abyCurrBSSID, (3), &Status); 592 } 593 // Call mgr to begin the authentication 594 vMgrAuthenBeginSta((void *)pDevice, pMgmt, &Status); 595 if (Status == CMD_STATUS_SUCCESS) { 596 pDevice->byLinkWaitCount = 0; 597 pDevice->eCommandState = WLAN_AUTHENTICATE_WAIT; 598 vCommandTimerWait((void *)pDevice, AUTHENTICATE_TIMEOUT); 599 spin_unlock_irq(&pDevice->lock); 600 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Set eCommandState = WLAN_AUTHENTICATE_WAIT\n"); 601 return; 602 } 603 } 604 // if Adhoc mode 605 else if (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) { 606 if (pMgmt->eCurrState == WMAC_STATE_JOINTED) { 607 if (netif_queue_stopped(pDevice->dev)){ 608 netif_wake_queue(pDevice->dev); 609 } 610 pDevice->bLinkPass = TRUE; 611 612 pMgmt->sNodeDBTable[0].bActive = TRUE; 613 pMgmt->sNodeDBTable[0].uInActiveCount = 0; 614 bClearBSSID_SCAN(pDevice); 615 } 616 else { 617 // start own IBSS 618 vMgrCreateOwnIBSS((void *)pDevice, &Status); 619 if (Status != CMD_STATUS_SUCCESS){ 620 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " WLAN_CMD_IBSS_CREATE fail ! \n"); 621 }; 622 BSSvAddMulticastNode(pDevice); 623 } 624 } 625 // if SSID not found 626 else if (pMgmt->eCurrMode == WMAC_MODE_STANDBY) { 627 if (pMgmt->eConfigMode == WMAC_CONFIG_IBSS_STA || 628 pMgmt->eConfigMode == WMAC_CONFIG_AUTO) { 629 // start own IBSS 630 vMgrCreateOwnIBSS((void *)pDevice, &Status); 631 if (Status != CMD_STATUS_SUCCESS){ 632 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" WLAN_CMD_IBSS_CREATE fail ! \n"); 633 }; 634 BSSvAddMulticastNode(pDevice); 635 if (netif_queue_stopped(pDevice->dev)){ 636 netif_wake_queue(pDevice->dev); 637 } 638 pDevice->bLinkPass = TRUE; 639 } 640 else { 641 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Disconnect SSID none\n"); 642 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT 643 // if(pDevice->bWPASuppWextEnabled == TRUE) 644 { 645 union iwreq_data wrqu; 646 memset(&wrqu, 0, sizeof (wrqu)); 647 wrqu.ap_addr.sa_family = ARPHRD_ETHER; 648 printk("wireless_send_event--->SIOCGIWAP(disassociated:vMgrJoinBSSBegin Fail !!)\n"); 649 wireless_send_event(pDevice->dev, SIOCGIWAP, &wrqu, NULL); 650 } 651 #endif 652 653 } 654 } 655 s_bCommandComplete(pDevice); 656 break; 657 658 case WLAN_AUTHENTICATE_WAIT : 659 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCommandState == WLAN_AUTHENTICATE_WAIT\n"); 660 if (pMgmt->eCurrState == WMAC_STATE_AUTH) { 661 // Call mgr to begin the association 662 pDevice->byLinkWaitCount = 0; 663 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCurrState == WMAC_STATE_AUTH\n"); 664 vMgrAssocBeginSta((void *)pDevice, pMgmt, &Status); 665 if (Status == CMD_STATUS_SUCCESS) { 666 pDevice->byLinkWaitCount = 0; 667 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCommandState = WLAN_ASSOCIATE_WAIT\n"); 668 pDevice->eCommandState = WLAN_ASSOCIATE_WAIT; 669 vCommandTimerWait((void *)pDevice, ASSOCIATE_TIMEOUT); 670 spin_unlock_irq(&pDevice->lock); 671 return; 672 } 673 } 674 675 else if(pMgmt->eCurrState < WMAC_STATE_AUTHPENDING) { 676 printk("WLAN_AUTHENTICATE_WAIT:Authen Fail???\n"); 677 } 678 else if(pDevice->byLinkWaitCount <= 4){ //mike add:wait another 2 sec if authenticated_frame delay! 679 pDevice->byLinkWaitCount ++; 680 printk("WLAN_AUTHENTICATE_WAIT:wait %d times!!\n",pDevice->byLinkWaitCount); 681 spin_unlock_irq(&pDevice->lock); 682 vCommandTimerWait((void *)pDevice, AUTHENTICATE_TIMEOUT/2); 683 return; 684 } 685 pDevice->byLinkWaitCount = 0; 686 #if 0 687 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT 688 // if(pDevice->bWPASuppWextEnabled == TRUE) 689 { 690 union iwreq_data wrqu; 691 memset(&wrqu, 0, sizeof (wrqu)); 692 wrqu.ap_addr.sa_family = ARPHRD_ETHER; 693 printk("wireless_send_event--->SIOCGIWAP(disassociated:AUTHENTICATE_WAIT_timeout)\n"); 694 wireless_send_event(pDevice->dev, SIOCGIWAP, &wrqu, NULL); 695 } 696 #endif 697 #endif 698 s_bCommandComplete(pDevice); 699 break; 700 701 case WLAN_ASSOCIATE_WAIT : 702 if (pMgmt->eCurrState == WMAC_STATE_ASSOC) { 703 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCurrState == WMAC_STATE_ASSOC\n"); 704 if (pDevice->ePSMode != WMAC_POWER_CAM) { 705 PSvEnablePowerSaving((void *)pDevice, pMgmt->wListenInterval); 706 } 707 if (pMgmt->eAuthenMode >= WMAC_AUTH_WPA) { 708 KeybRemoveAllKey(&(pDevice->sKey), pDevice->abyBSSID, pDevice->PortOffset); 709 } 710 pDevice->bLinkPass = TRUE; 711 pDevice->byLinkWaitCount = 0; 712 pDevice->byReAssocCount = 0; 713 bClearBSSID_SCAN(pDevice); 714 if (pDevice->byFOETuning) { 715 BBvSetFOE(pDevice->PortOffset); 716 PSbSendNullPacket(pDevice); 717 } 718 if (netif_queue_stopped(pDevice->dev)){ 719 netif_wake_queue(pDevice->dev); 720 } 721 #ifdef TxInSleep 722 if(pDevice->IsTxDataTrigger != FALSE) { //TxDataTimer is not triggered at the first time 723 // printk("Re-initial TxDataTimer****\n"); 724 del_timer(&pDevice->sTimerTxData); 725 init_timer(&pDevice->sTimerTxData); 726 pDevice->sTimerTxData.data = (ULONG)pDevice; 727 pDevice->sTimerTxData.function = (TimerFunction)BSSvSecondTxData; 728 pDevice->sTimerTxData.expires = RUN_AT(10*HZ); //10s callback 729 pDevice->fTxDataInSleep = FALSE; 730 pDevice->nTxDataTimeCout = 0; 731 } 732 else { 733 // printk("mike:-->First time triger TimerTxData InSleep\n"); 734 } 735 pDevice->IsTxDataTrigger = TRUE; 736 add_timer(&pDevice->sTimerTxData); 737 #endif 738 } 739 else if(pMgmt->eCurrState < WMAC_STATE_ASSOCPENDING) { 740 printk("WLAN_ASSOCIATE_WAIT:Association Fail???\n"); 741 } 742 else if(pDevice->byLinkWaitCount <= 4){ //mike add:wait another 2 sec if associated_frame delay! 743 pDevice->byLinkWaitCount ++; 744 printk("WLAN_ASSOCIATE_WAIT:wait %d times!!\n",pDevice->byLinkWaitCount); 745 spin_unlock_irq(&pDevice->lock); 746 vCommandTimerWait((void *)pDevice, ASSOCIATE_TIMEOUT/2); 747 return; 748 } 749 pDevice->byLinkWaitCount = 0; 750 #if 0 751 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT 752 // if(pDevice->bWPASuppWextEnabled == TRUE) 753 { 754 union iwreq_data wrqu; 755 memset(&wrqu, 0, sizeof (wrqu)); 756 wrqu.ap_addr.sa_family = ARPHRD_ETHER; 757 printk("wireless_send_event--->SIOCGIWAP(disassociated:ASSOCIATE_WAIT_timeout)\n"); 758 wireless_send_event(pDevice->dev, SIOCGIWAP, &wrqu, NULL); 759 } 760 #endif 761 #endif 762 763 s_bCommandComplete(pDevice); 764 break; 765 766 case WLAN_CMD_AP_MODE_START : 767 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCommandState == WLAN_CMD_AP_MODE_START\n"); 768 769 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) { 770 del_timer(&pMgmt->sTimerSecondCallback); 771 pMgmt->eCurrState = WMAC_STATE_IDLE; 772 pMgmt->eCurrMode = WMAC_MODE_STANDBY; 773 pDevice->bLinkPass = FALSE; 774 if (pDevice->bEnableHostWEP == TRUE) 775 BSSvClearNodeDBTable(pDevice, 1); 776 else 777 BSSvClearNodeDBTable(pDevice, 0); 778 pDevice->uAssocCount = 0; 779 pMgmt->eCurrState = WMAC_STATE_IDLE; 780 pDevice->bFixRate = FALSE; 781 782 vMgrCreateOwnIBSS((void *)pDevice, &Status); 783 if (Status != CMD_STATUS_SUCCESS){ 784 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " vMgrCreateOwnIBSS fail ! \n"); 785 }; 786 // alway turn off unicast bit 787 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_RCR, RCR_UNICAST); 788 pDevice->byRxMode &= ~RCR_UNICAST; 789 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "wcmd: rx_mode = %x\n", pDevice->byRxMode ); 790 BSSvAddMulticastNode(pDevice); 791 if (netif_queue_stopped(pDevice->dev)){ 792 netif_wake_queue(pDevice->dev); 793 } 794 pDevice->bLinkPass = TRUE; 795 add_timer(&pMgmt->sTimerSecondCallback); 796 } 797 s_bCommandComplete(pDevice); 798 break; 799 800 case WLAN_CMD_TX_PSPACKET_START : 801 // DTIM Multicast tx 802 if (pMgmt->sNodeDBTable[0].bRxPSPoll) { 803 while ((skb = skb_dequeue(&pMgmt->sNodeDBTable[0].sTxPSQueue)) != NULL) { 804 if (skb_queue_empty(&pMgmt->sNodeDBTable[0].sTxPSQueue)) { 805 pMgmt->abyPSTxMap[0] &= ~byMask[0]; 806 pDevice->bMoreData = FALSE; 807 } 808 else { 809 pDevice->bMoreData = TRUE; 810 } 811 if (!device_dma0_xmit(pDevice, skb, 0)) { 812 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Multicast ps tx fail \n"); 813 } 814 pMgmt->sNodeDBTable[0].wEnQueueCnt--; 815 } 816 }; 817 818 // PS nodes tx 819 for (ii = 1; ii < (MAX_NODE_NUM + 1); ii++) { 820 if (pMgmt->sNodeDBTable[ii].bActive && 821 pMgmt->sNodeDBTable[ii].bRxPSPoll) { 822 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Index=%d Enqueu Cnt= %d\n", 823 ii, pMgmt->sNodeDBTable[ii].wEnQueueCnt); 824 while ((skb = skb_dequeue(&pMgmt->sNodeDBTable[ii].sTxPSQueue)) != NULL) { 825 if (skb_queue_empty(&pMgmt->sNodeDBTable[ii].sTxPSQueue)) { 826 // clear tx map 827 pMgmt->abyPSTxMap[pMgmt->sNodeDBTable[ii].wAID >> 3] &= 828 ~byMask[pMgmt->sNodeDBTable[ii].wAID & 7]; 829 pDevice->bMoreData = FALSE; 830 } 831 else { 832 pDevice->bMoreData = TRUE; 833 } 834 if (!device_dma0_xmit(pDevice, skb, ii)) { 835 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "sta ps tx fail \n"); 836 } 837 pMgmt->sNodeDBTable[ii].wEnQueueCnt--; 838 // check if sta ps enable, wait next pspoll 839 // if sta ps disable, send all pending buffers. 840 if (pMgmt->sNodeDBTable[ii].bPSEnable) 841 break; 842 } 843 if (skb_queue_empty(&pMgmt->sNodeDBTable[ii].sTxPSQueue)) { 844 // clear tx map 845 pMgmt->abyPSTxMap[pMgmt->sNodeDBTable[ii].wAID >> 3] &= 846 ~byMask[pMgmt->sNodeDBTable[ii].wAID & 7]; 847 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Index=%d PS queue clear \n", ii); 848 } 849 pMgmt->sNodeDBTable[ii].bRxPSPoll = FALSE; 850 } 851 } 852 853 s_bCommandComplete(pDevice); 854 break; 855 856 857 case WLAN_CMD_RADIO_START : 858 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCommandState == WLAN_CMD_RADIO_START\n"); 859 if (pDevice->bRadioCmd == TRUE) 860 CARDbRadioPowerOn(pDevice); 861 else 862 CARDbRadioPowerOff(pDevice); 863 864 s_bCommandComplete(pDevice); 865 break; 866 867 868 case WLAN_CMD_CHECK_BBSENSITIVITY_CHANGE : 869 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCommandState == WLAN_CMD_CHECK_BBSENSITIVITY_START\n"); 870 // wait all TD complete 871 if (pDevice->iTDUsed[TYPE_AC0DMA] != 0){ 872 vCommandTimerWait((void *)pDevice, 10); 873 spin_unlock_irq(&pDevice->lock); 874 return; 875 } 876 if (pDevice->iTDUsed[TYPE_TXDMA0] != 0){ 877 vCommandTimerWait((void *)pDevice, 10); 878 spin_unlock_irq(&pDevice->lock); 879 return; 880 } 881 pDevice->byBBVGACurrent = pDevice->byBBVGANew; 882 BBvSetVGAGainOffset(pDevice, pDevice->byBBVGACurrent); 883 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"SetVGAGainOffset %02X\n", pDevice->byBBVGACurrent); 884 s_bCommandComplete(pDevice); 885 break; 886 887 default : 888 s_bCommandComplete(pDevice); 889 break; 890 891 } //switch 892 spin_unlock_irq(&pDevice->lock); 893 return; 894 895} 896 897 898static 899BOOL 900s_bCommandComplete ( 901 PSDevice pDevice 902 ) 903{ 904 PWLAN_IE_SSID pSSID; 905 BOOL bRadioCmd = FALSE; 906 //WORD wDeAuthenReason = 0; 907 BOOL bForceSCAN = TRUE; 908 PSMgmtObject pMgmt = pDevice->pMgmt; 909 910 911 pDevice->eCommandState = WLAN_CMD_IDLE; 912 if (pDevice->cbFreeCmdQueue == CMD_Q_SIZE) { 913 //Command Queue Empty 914 pDevice->bCmdRunning = FALSE; 915 return TRUE; 916 } 917 else { 918 pDevice->eCommand = pDevice->eCmdQueue[pDevice->uCmdDequeueIdx].eCmd; 919 pSSID = (PWLAN_IE_SSID)pDevice->eCmdQueue[pDevice->uCmdDequeueIdx].abyCmdDesireSSID; 920 bRadioCmd = pDevice->eCmdQueue[pDevice->uCmdDequeueIdx].bRadioCmd; 921 bForceSCAN = pDevice->eCmdQueue[pDevice->uCmdDequeueIdx].bForceSCAN; 922 ADD_ONE_WITH_WRAP_AROUND(pDevice->uCmdDequeueIdx, CMD_Q_SIZE); 923 pDevice->cbFreeCmdQueue++; 924 pDevice->bCmdRunning = TRUE; 925 switch ( pDevice->eCommand ) { 926 case WLAN_CMD_BSSID_SCAN: 927 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCommandState= WLAN_CMD_BSSID_SCAN\n"); 928 pDevice->eCommandState = WLAN_CMD_SCAN_START; 929 pMgmt->uScanChannel = 0; 930 if (pSSID->len != 0) { 931 memcpy(pMgmt->abyScanSSID, pSSID, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1); 932 } else { 933 memset(pMgmt->abyScanSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1); 934 } 935/* 936 if ((bForceSCAN == FALSE) && (pDevice->bLinkPass == TRUE)) { 937 if ((pSSID->len == ((PWLAN_IE_SSID)pMgmt->abyCurrSSID)->len) && 938 ( !memcmp(pSSID->abySSID, ((PWLAN_IE_SSID)pMgmt->abyCurrSSID)->abySSID, pSSID->len))) { 939 pDevice->eCommandState = WLAN_CMD_IDLE; 940 } 941 } 942*/ 943 break; 944 case WLAN_CMD_SSID: 945 pDevice->eCommandState = WLAN_CMD_SSID_START; 946 if (pSSID->len > WLAN_SSID_MAXLEN) 947 pSSID->len = WLAN_SSID_MAXLEN; 948 if (pSSID->len != 0) 949 memcpy(pDevice->pMgmt->abyDesireSSID, pSSID, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1); 950 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCommandState= WLAN_CMD_SSID_START\n"); 951 break; 952 case WLAN_CMD_DISASSOCIATE: 953 pDevice->eCommandState = WLAN_CMD_DISASSOCIATE_START; 954 break; 955 case WLAN_CMD_RX_PSPOLL: 956 pDevice->eCommandState = WLAN_CMD_TX_PSPACKET_START; 957 break; 958 case WLAN_CMD_RUN_AP: 959 pDevice->eCommandState = WLAN_CMD_AP_MODE_START; 960 break; 961 case WLAN_CMD_RADIO: 962 pDevice->eCommandState = WLAN_CMD_RADIO_START; 963 pDevice->bRadioCmd = bRadioCmd; 964 break; 965 case WLAN_CMD_CHANGE_BBSENSITIVITY: 966 pDevice->eCommandState = WLAN_CMD_CHECK_BBSENSITIVITY_CHANGE; 967 break; 968 969 default: 970 break; 971 972 } 973 974 vCommandTimerWait((void *)pDevice, 0); 975 } 976 977 return TRUE; 978} 979 980 981 982BOOL bScheduleCommand ( 983 void *hDeviceContext, 984 CMD_CODE eCommand, 985 PBYTE pbyItem0 986 ) 987{ 988 PSDevice pDevice = (PSDevice)hDeviceContext; 989 990 991 if (pDevice->cbFreeCmdQueue == 0) { 992 return (FALSE); 993 } 994 pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].eCmd = eCommand; 995 pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].bForceSCAN = TRUE; 996 memset(pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].abyCmdDesireSSID, 0 , WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1); 997 998 if (pbyItem0 != NULL) { 999 switch (eCommand) { 1000 1001 case WLAN_CMD_BSSID_SCAN: 1002 memcpy(pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].abyCmdDesireSSID, 1003 pbyItem0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1); 1004 pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].bForceSCAN = FALSE; 1005 break; 1006 1007 case WLAN_CMD_SSID: 1008 memcpy(pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].abyCmdDesireSSID, 1009 pbyItem0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1); 1010 break; 1011 1012 case WLAN_CMD_DISASSOCIATE: 1013 pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].bNeedRadioOFF = *((int *)pbyItem0); 1014 break; 1015/* 1016 case WLAN_CMD_DEAUTH: 1017 pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].wDeAuthenReason = *((PWORD)pbyItem0); 1018 break; 1019*/ 1020 1021 case WLAN_CMD_RX_PSPOLL: 1022 break; 1023 1024 case WLAN_CMD_RADIO: 1025 pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].bRadioCmd = *((int *)pbyItem0); 1026 break; 1027 1028 case WLAN_CMD_CHANGE_BBSENSITIVITY: 1029 pDevice->eCommandState = WLAN_CMD_CHECK_BBSENSITIVITY_CHANGE; 1030 break; 1031 1032 default: 1033 break; 1034 } 1035 } 1036 1037 ADD_ONE_WITH_WRAP_AROUND(pDevice->uCmdEnqueueIdx, CMD_Q_SIZE); 1038 pDevice->cbFreeCmdQueue--; 1039 1040 if (pDevice->bCmdRunning == FALSE) { 1041 s_bCommandComplete(pDevice); 1042 } 1043 else { 1044 } 1045 return (TRUE); 1046 1047} 1048 1049/* 1050 * Description: 1051 * Clear BSSID_SCAN cmd in CMD Queue 1052 * 1053 * Parameters: 1054 * In: 1055 * hDeviceContext - Pointer to the adapter 1056 * eCommand - Command 1057 * Out: 1058 * none 1059 * 1060 * Return Value: TRUE if success; otherwise FALSE 1061 * 1062 */ 1063BOOL bClearBSSID_SCAN ( 1064 void *hDeviceContext 1065 ) 1066{ 1067 PSDevice pDevice = (PSDevice)hDeviceContext; 1068 UINT uCmdDequeueIdx = pDevice->uCmdDequeueIdx; 1069 UINT ii; 1070 1071 if ((pDevice->cbFreeCmdQueue < CMD_Q_SIZE) && (uCmdDequeueIdx != pDevice->uCmdEnqueueIdx)) { 1072 for (ii = 0; ii < (CMD_Q_SIZE - pDevice->cbFreeCmdQueue); ii ++) { 1073 if (pDevice->eCmdQueue[uCmdDequeueIdx].eCmd == WLAN_CMD_BSSID_SCAN) 1074 pDevice->eCmdQueue[uCmdDequeueIdx].eCmd = WLAN_CMD_IDLE; 1075 ADD_ONE_WITH_WRAP_AROUND(uCmdDequeueIdx, CMD_Q_SIZE); 1076 if (uCmdDequeueIdx == pDevice->uCmdEnqueueIdx) 1077 break; 1078 } 1079 } 1080 return TRUE; 1081} 1082 1083//mike add:reset command timer 1084void 1085vResetCommandTimer( 1086 void *hDeviceContext 1087 ) 1088{ 1089 PSDevice pDevice = (PSDevice)hDeviceContext; 1090 1091 //delete timer 1092 del_timer(&pDevice->sTimerCommand); 1093 //init timer 1094 init_timer(&pDevice->sTimerCommand); 1095 pDevice->sTimerCommand.data = (ULONG)pDevice; 1096 pDevice->sTimerCommand.function = (TimerFunction)vCommandTimer; 1097 pDevice->sTimerCommand.expires = RUN_AT(HZ); 1098 pDevice->cbFreeCmdQueue = CMD_Q_SIZE; 1099 pDevice->uCmdDequeueIdx = 0; 1100 pDevice->uCmdEnqueueIdx = 0; 1101 pDevice->eCommandState = WLAN_CMD_IDLE; 1102 pDevice->bCmdRunning = FALSE; 1103 pDevice->bCmdClear = FALSE; 1104} 1105 1106 1107#ifdef TxInSleep 1108void 1109BSSvSecondTxData( 1110 void *hDeviceContext 1111 ) 1112{ 1113 PSDevice pDevice = (PSDevice)hDeviceContext; 1114 PSMgmtObject pMgmt = &(pDevice->sMgmtObj); 1115 pDevice->nTxDataTimeCout++; 1116 1117 if(pDevice->nTxDataTimeCout<4) //don't tx data if timer less than 40s 1118 { 1119 // printk("mike:%s-->no data Tx not exceed the desired Time as %d\n",__FUNCTION__, 1120 // (int)pDevice->nTxDataTimeCout); 1121 pDevice->sTimerTxData.expires = RUN_AT(10*HZ); //10s callback 1122 add_timer(&pDevice->sTimerTxData); 1123 return; 1124 } 1125 1126 spin_lock_irq(&pDevice->lock); 1127 #if 1 1128 if(((pDevice->bLinkPass ==TRUE)&&(pMgmt->eAuthenMode < WMAC_AUTH_WPA)) || //open && sharekey linking 1129 (pDevice->fWPA_Authened == TRUE)) { //wpa linking 1130 #else 1131 if(pDevice->bLinkPass ==TRUE) { 1132 #endif 1133 1134 // printk("mike:%s-->InSleep Tx Data Procedure\n",__FUNCTION__); 1135 pDevice->fTxDataInSleep = TRUE; 1136 PSbSendNullPacket(pDevice); //send null packet 1137 pDevice->fTxDataInSleep = FALSE; 1138 } 1139 spin_unlock_irq(&pDevice->lock); 1140 1141 pDevice->sTimerTxData.expires = RUN_AT(10*HZ); //10s callback 1142 add_timer(&pDevice->sTimerTxData); 1143 return; 1144} 1145#endif 1146 1147