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