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