drivers/staging/vt6655/wcmd.c

   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  --------------------------*/
  65 static int          msglevel                =MSG_LEVEL_INFO;
  66 //static int          msglevel                =MSG_LEVEL_DEBUG;
  67 /*---------------------  Static Functions  --------------------------*/
  68
  69 static
  70 void
  71 s_vProbeChannel(
  72     PSDevice pDevice
  73     );
  74
  75
  76 static
  77 PSTxMgmtPacket
  78 s_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
  88 static
  89 bool
  90 s_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  */
 114 static
 115 void
 116 vAdHocBeaconStop(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  */
 169 static
 170 void
 171 vAdHocBeaconRestart(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
 205 static
 206 void
 207 s_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
 269 PSTxMgmtPacket
 270 s_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
 321 void
 322 vCommandTimerWait(
 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
 341 void
 342 vCommandTimer (
 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);
 549 printk("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
 899 static
 900 bool
 901 s_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
 983 bool 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  */
1064 bool 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
1085 void
1086 vResetCommandTimer(
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
1109 void
1110 BSSvSecondTxData(
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