Gitiles
Code Review Sign In
gerrit-public.fairphone.software / kernel / msm-4.9 / 0f5e44ca6e777660af6b0eb44d4787563932eda8 / . / drivers / staging / vt6656 / wcmd.c
blob: 80d7ca73bcd949a7f2a003fccce90a0db76e48e6 [file] [log] [blame]
Forest Bond92b96792009-06-13 07:38:31 -0400[diff] [blame]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 * s_bClearBSSID_SCAN- Clear BSSID_SCAN cmd in CMD Queue
36 *
37 * Revision History:
38 *
39 */
40
41
42
43
44#if !defined(__TTYPE_H__)
45#include "ttype.h"
46#endif
47#if !defined(__TMACRO_H__)
48#include "tmacro.h"
49#endif
50#if !defined(__DEVICE_H__)
51#include "device.h"
52#endif
53#if !defined(__MAC_H__)
54#include "mac.h"
55#endif
56#if !defined(__CARD_H__)
57#include "card.h"
58#endif
59#if !defined(__80211HDR_H__)
60#include "80211hdr.h"
61#endif
62#if !defined(__WCMD_H__)
63#include "wcmd.h"
64#endif
65#if !defined(__WMGR_H__)
66#include "wmgr.h"
67#endif
68#if !defined(__POWER_H__)
69#include "power.h"
70#endif
71#if !defined(__WCTL_H__)
72#include "wctl.h"
73#endif
74#if !defined(__CARD_H__)
75#include "card.h"
76#endif
77#if !defined(__BASEBAND_H__)
78#include "baseband.h"
79#endif
80#if !defined(__CONTROL_H__)
81#include "control.h"
82#endif
83#if !defined(__UMEM_H__)
84#include "umem.h"
85#endif
86#if !defined(__RXTX_H__)
87#include "rxtx.h"
88#endif
89#if !defined(__RF_H__)
90#include "rf.h"
91#endif
92#if !defined(__RNDIS_H__)
93#include "rndis.h"
94#endif
95#if !defined (_CHANNEL_H_)
96#include "channel.h"
97#endif
98//DavidWang
99#if !defined(__IOWPA_H__)
100#include "iowpa.h"
101#endif
102
103/*--------------------- Static Definitions -------------------------*/
104
105
106
107
108/*--------------------- Static Classes ----------------------------*/
109
110/*--------------------- Static Variables --------------------------*/
111static int msglevel =MSG_LEVEL_INFO;
112//static int msglevel =MSG_LEVEL_DEBUG;
113/*--------------------- Static Functions --------------------------*/
114
115static
116VOID
117s_vProbeChannel(
118 IN PSDevice pDevice
119 );
120
121
122static
123PSTxMgmtPacket
124s_MgrMakeProbeRequest(
125 IN PSDevice pDevice,
126 IN PSMgmtObject pMgmt,
127 IN PBYTE pScanBSSID,
128 IN PWLAN_IE_SSID pSSID,
129 IN PWLAN_IE_SUPP_RATES pCurrRates,
130 IN PWLAN_IE_SUPP_RATES pCurrExtSuppRates
131 );
132
133
134static
135BOOL
136s_bCommandComplete (
137 PSDevice pDevice
138 );
139
140
141static
142BOOL s_bClearBSSID_SCAN (
143 IN HANDLE hDeviceContext
144 );
145
146/*--------------------- Export Variables --------------------------*/
147
148
149/*--------------------- Export Functions --------------------------*/
150
151
152
153/*
154 * Description:
155 * Stop AdHoc beacon during scan process
156 *
157 * Parameters:
158 * In:
159 * pDevice - Pointer to the adapter
160 * Out:
161 * none
162 *
163 * Return Value: none
164 *
165 */
166static
167void
168vAdHocBeaconStop(PSDevice pDevice)
169{
170
171 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
172 BOOL bStop;
173
174 /*
175 * temporarily stop Beacon packet for AdHoc Server
176 * if all of the following coditions are met:
177 * (1) STA is in AdHoc mode
178 * (2) VT3253 is programmed as automatic Beacon Transmitting
179 * (3) One of the following conditions is met
180 * (3.1) AdHoc channel is in B/G band and the
181 * current scan channel is in A band
182 * or
183 * (3.2) AdHoc channel is in A mode
184 */
185 bStop = FALSE;
186 if ((pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) &&
187 (pMgmt->eCurrState >= WMAC_STATE_STARTED))
188 {
189 if ((pMgmt->uIBSSChannel <= CB_MAX_CHANNEL_24G) &&
190 (pMgmt->uScanChannel > CB_MAX_CHANNEL_24G))
191 {
192 bStop = TRUE;
193 }
194 if (pMgmt->uIBSSChannel > CB_MAX_CHANNEL_24G)
195 {
196 bStop = TRUE;
197 }
198 }
199
200 if (bStop)
201 {
202 //PMESG(("STOP_BEACON: IBSSChannel = %u, ScanChannel = %u\n",
203 // pMgmt->uIBSSChannel, pMgmt->uScanChannel));
204 MACvRegBitsOff(pDevice, MAC_REG_TCR, TCR_AUTOBCNTX);
205 }
206
207} /* vAdHocBeaconStop */
208
209
210/*
211 * Description:
212 * Restart AdHoc beacon after scan process complete
213 *
214 * Parameters:
215 * In:
216 * pDevice - Pointer to the adapter
217 * Out:
218 * none
219 *
220 * Return Value: none
221 *
222 */
223static
224void
225vAdHocBeaconRestart(PSDevice pDevice)
226{
227 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
228
229 /*
230 * Restart Beacon packet for AdHoc Server
231 * if all of the following coditions are met:
232 * (1) STA is in AdHoc mode
233 * (2) VT3253 is programmed as automatic Beacon Transmitting
234 */
235 if ((pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) &&
236 (pMgmt->eCurrState >= WMAC_STATE_STARTED))
237 {
238 //PMESG(("RESTART_BEACON\n"));
239 MACvRegBitsOn(pDevice, MAC_REG_TCR, TCR_AUTOBCNTX);
240 }
241
242}
243
244
245/*+
246 *
247 * Routine Description:
248 * Prepare and send probe request management frames.
249 *
250 *
251 * Return Value:
252 * none.
253 *
254-*/
255
256static
257VOID
258s_vProbeChannel(
259 IN PSDevice pDevice
260 )
261{
262 //1M, 2M, 5M, 11M, 18M, 24M, 36M, 54M
263 BYTE abyCurrSuppRatesG[] = {WLAN_EID_SUPP_RATES, 8, 0x02, 0x04, 0x0B, 0x16, 0x24, 0x30, 0x48, 0x6C};
264 BYTE abyCurrExtSuppRatesG[] = {WLAN_EID_EXTSUPP_RATES, 4, 0x0C, 0x12, 0x18, 0x60};
265 //6M, 9M, 12M, 48M
266 BYTE abyCurrSuppRatesA[] = {WLAN_EID_SUPP_RATES, 8, 0x0C, 0x12, 0x18, 0x24, 0x30, 0x48, 0x60, 0x6C};
267 BYTE abyCurrSuppRatesB[] = {WLAN_EID_SUPP_RATES, 4, 0x02, 0x04, 0x0B, 0x16};
268 PBYTE pbyRate;
269 PSTxMgmtPacket pTxPacket;
270 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
271 UINT ii;
272
273
274 if (pDevice->byBBType == BB_TYPE_11A) {
275 pbyRate = &abyCurrSuppRatesA[0];
276 } else if (pDevice->byBBType == BB_TYPE_11B) {
277 pbyRate = &abyCurrSuppRatesB[0];
278 } else {
279 pbyRate = &abyCurrSuppRatesG[0];
280 }
281 // build an assocreq frame and send it
282 pTxPacket = s_MgrMakeProbeRequest
283 (
284 pDevice,
285 pMgmt,
286 pMgmt->abyScanBSSID,
287 (PWLAN_IE_SSID)pMgmt->abyScanSSID,
288 (PWLAN_IE_SUPP_RATES)pbyRate,
289 (PWLAN_IE_SUPP_RATES)abyCurrExtSuppRatesG
290 );
291
292 if (pTxPacket != NULL ){
293 for (ii = 0; ii < 1 ; ii++) {
294 if (csMgmt_xmit(pDevice, pTxPacket) != CMD_STATUS_PENDING) {
295 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Probe request sending fail.. \n");
296 }
297 else {
298 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Probe request is sending.. \n");
299 }
300 }
301 }
302
303}
304
305
306
307
308/*+
309 *
310 * Routine Description:
311 * Constructs an probe request frame
312 *
313 *
314 * Return Value:
315 * A ptr to Tx frame or NULL on allocation failue
316 *
317-*/
318
319
320PSTxMgmtPacket
321s_MgrMakeProbeRequest(
322 IN PSDevice pDevice,
323 IN PSMgmtObject pMgmt,
324 IN PBYTE pScanBSSID,
325 IN PWLAN_IE_SSID pSSID,
326 IN PWLAN_IE_SUPP_RATES pCurrRates,
327 IN PWLAN_IE_SUPP_RATES pCurrExtSuppRates
328
329 )
330{
331 PSTxMgmtPacket pTxPacket = NULL;
332 WLAN_FR_PROBEREQ sFrame;
333
334
335 pTxPacket = (PSTxMgmtPacket)pMgmt->pbyMgmtPacketPool;
336 memset(pTxPacket, 0, sizeof(STxMgmtPacket) + WLAN_PROBEREQ_FR_MAXLEN);
337 pTxPacket->p80211Header = (PUWLAN_80211HDR)((PBYTE)pTxPacket + sizeof(STxMgmtPacket));
338 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
339 sFrame.len = WLAN_PROBEREQ_FR_MAXLEN;
340 vMgrEncodeProbeRequest(&sFrame);
341 sFrame.pHdr->sA3.wFrameCtl = cpu_to_le16(
342 (
343 WLAN_SET_FC_FTYPE(WLAN_TYPE_MGR) |
344 WLAN_SET_FC_FSTYPE(WLAN_FSTYPE_PROBEREQ)
345 ));
346 memcpy( sFrame.pHdr->sA3.abyAddr1, pScanBSSID, WLAN_ADDR_LEN);
347 memcpy( sFrame.pHdr->sA3.abyAddr2, pMgmt->abyMACAddr, WLAN_ADDR_LEN);
348 memcpy( sFrame.pHdr->sA3.abyAddr3, pScanBSSID, WLAN_BSSID_LEN);
349 // Copy the SSID, pSSID->len=0 indicate broadcast SSID
350 sFrame.pSSID = (PWLAN_IE_SSID)(sFrame.pBuf + sFrame.len);
351 sFrame.len += pSSID->len + WLAN_IEHDR_LEN;
352 memcpy(sFrame.pSSID, pSSID, pSSID->len + WLAN_IEHDR_LEN);
353 sFrame.pSuppRates = (PWLAN_IE_SUPP_RATES)(sFrame.pBuf + sFrame.len);
354 sFrame.len += pCurrRates->len + WLAN_IEHDR_LEN;
355 memcpy(sFrame.pSuppRates, pCurrRates, pCurrRates->len + WLAN_IEHDR_LEN);
356 // Copy the extension rate set
357 if (pDevice->byBBType == BB_TYPE_11G) {
358 sFrame.pExtSuppRates = (PWLAN_IE_SUPP_RATES)(sFrame.pBuf + sFrame.len);
359 sFrame.len += pCurrExtSuppRates->len + WLAN_IEHDR_LEN;
360 memcpy(sFrame.pExtSuppRates, pCurrExtSuppRates, pCurrExtSuppRates->len + WLAN_IEHDR_LEN);
361 }
362 pTxPacket->cbMPDULen = sFrame.len;
363 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN;
364
365 return pTxPacket;
366}
367
368
369
370
371
372VOID
373vCommandTimerWait(
374 IN HANDLE hDeviceContext,
375 IN UINT MSecond
376 )
377{
378 PSDevice pDevice = (PSDevice)hDeviceContext;
379
380 init_timer(&pDevice->sTimerCommand);
381 pDevice->sTimerCommand.data = (ULONG)pDevice;
382 pDevice->sTimerCommand.function = (TimerFunction)vRunCommand;
383 // RUN_AT :1 msec ~= (HZ/1024)
384 pDevice->sTimerCommand.expires = (UINT)RUN_AT((MSecond * HZ) >> 10);
385 add_timer(&pDevice->sTimerCommand);
386 return;
387}
388
389
390
391
392VOID
393vRunCommand(
394 IN HANDLE hDeviceContext
395 )
396{
397 PSDevice pDevice = (PSDevice)hDeviceContext;
398 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
399 PWLAN_IE_SSID pItemSSID;
400 PWLAN_IE_SSID pItemSSIDCurr;
401 CMD_STATUS Status;
402 UINT ii;
403 BYTE byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
404 struct sk_buff *skb;
405 BYTE byData;
406
407
408 if (pDevice->dwDiagRefCount != 0)
409 return;
410 if (pDevice->bCmdRunning != TRUE)
411 return;
412
413 spin_lock_irq(&pDevice->lock);
414
415 switch ( pDevice->eCommandState ) {
416
417 case WLAN_CMD_SCAN_START:
418
419 pDevice->byReAssocCount = 0;
420 if (pDevice->bRadioOff == TRUE) {
421 s_bCommandComplete(pDevice);
422 spin_unlock_irq(&pDevice->lock);
423 return;
424 }
425
426 if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
427 s_bCommandComplete(pDevice);
428 spin_unlock_irq(&pDevice->lock);
429 return;
430 }
431
432 pItemSSID = (PWLAN_IE_SSID)pMgmt->abyScanSSID;
433
434 if (pMgmt->uScanChannel == 0 ) {
435 pMgmt->uScanChannel = pDevice->byMinChannel;
436 }
437 if (pMgmt->uScanChannel > pDevice->byMaxChannel) {
438 pMgmt->eScanState = WMAC_NO_SCANNING;
439
440 if (pDevice->byBBType != pDevice->byScanBBType) {
441 pDevice->byBBType = pDevice->byScanBBType;
442 CARDvSetBSSMode(pDevice);
443 }
444
445 if (pDevice->bUpdateBBVGA) {
446 BBvSetShortSlotTime(pDevice);
447 BBvSetVGAGainOffset(pDevice, pDevice->byBBVGACurrent);
448 BBvUpdatePreEDThreshold(pDevice, FALSE);
449 }
450 // Set channel back
451 vAdHocBeaconRestart(pDevice);
452 // Set channel back
453 CARDbSetMediaChannel(pDevice, pMgmt->uCurrChannel);
454 // Set Filter
455 if (pMgmt->bCurrBSSIDFilterOn) {
456 MACvRegBitsOn(pDevice, MAC_REG_RCR, RCR_BSSID);
457 pDevice->byRxMode |= RCR_BSSID;
458 }
459 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Scanning, set back to channel: [%d]\n", pMgmt->uCurrChannel);
460 pDevice->bStopDataPkt = FALSE;
461 s_bCommandComplete(pDevice);
462 spin_unlock_irq(&pDevice->lock);
463 return;
464
465 } else {
466 if (!ChannelValid(pDevice->byZoneType, pMgmt->uScanChannel)) {
467 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Invalid channel pMgmt->uScanChannel = %d \n",pMgmt->uScanChannel);
468 s_bCommandComplete(pDevice);
469 spin_unlock_irq(&pDevice->lock);
470 return;
471 }
472 if (pMgmt->uScanChannel == pDevice->byMinChannel) {
473 // pMgmt->eScanType = WMAC_SCAN_ACTIVE; //mike mark
474 pMgmt->abyScanBSSID[0] = 0xFF;
475 pMgmt->abyScanBSSID[1] = 0xFF;
476 pMgmt->abyScanBSSID[2] = 0xFF;
477 pMgmt->abyScanBSSID[3] = 0xFF;
478 pMgmt->abyScanBSSID[4] = 0xFF;
479 pMgmt->abyScanBSSID[5] = 0xFF;
480 pItemSSID->byElementID = WLAN_EID_SSID;
481 // clear bssid list
482 // BSSvClearBSSList((HANDLE)pDevice, pDevice->bLinkPass);
483 pMgmt->eScanState = WMAC_IS_SCANNING;
484 pDevice->byScanBBType = pDevice->byBBType; //lucas
485 pDevice->bStopDataPkt = TRUE;
486 // Turn off RCR_BSSID filter everytime
487 MACvRegBitsOff(pDevice, MAC_REG_RCR, RCR_BSSID);
488 pDevice->byRxMode &= ~RCR_BSSID;
489
490 }
491 //lucas
492 vAdHocBeaconStop(pDevice);
493 if ((pDevice->byBBType != BB_TYPE_11A) && (pMgmt->uScanChannel > CB_MAX_CHANNEL_24G)) {
494 pDevice->byBBType = BB_TYPE_11A;
495 CARDvSetBSSMode(pDevice);
496 }
497 else if ((pDevice->byBBType == BB_TYPE_11A) && (pMgmt->uScanChannel <= CB_MAX_CHANNEL_24G)) {
498 pDevice->byBBType = BB_TYPE_11G;
499 CARDvSetBSSMode(pDevice);
500 }
501 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Scanning.... channel: [%d]\n", pMgmt->uScanChannel);
502 // Set channel
503 CARDbSetMediaChannel(pDevice, pMgmt->uScanChannel);
504 // Set Baseband to be more sensitive.
505
506 if (pDevice->bUpdateBBVGA) {
507 BBvSetShortSlotTime(pDevice);
508 BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]);
509 BBvUpdatePreEDThreshold(pDevice, TRUE);
510 }
511 pMgmt->uScanChannel++;
512
513 while (!ChannelValid(pDevice->byZoneType, pMgmt->uScanChannel) &&
514 pMgmt->uScanChannel <= pDevice->byMaxChannel ){
515 pMgmt->uScanChannel++;
516 }
517
518 if (pMgmt->uScanChannel > pDevice->byMaxChannel) {
519 // Set Baseband to be not sensitive and rescan
520 pDevice->eCommandState = WLAN_CMD_SCAN_END;
521
522 }
523 if ((pMgmt->b11hEnable == FALSE) ||
524 (pMgmt->uScanChannel < CB_MAX_CHANNEL_24G)) {
525 s_vProbeChannel(pDevice);
526 spin_unlock_irq(&pDevice->lock);
Forest Bond92b96792009-06-13 07:38:31 -0400[diff] [blame]527 vCommandTimerWait((HANDLE)pDevice, 100);
Forest Bond92b96792009-06-13 07:38:31 -0400[diff] [blame]528 return;
529 } else {
530 spin_unlock_irq(&pDevice->lock);
531 vCommandTimerWait((HANDLE)pDevice, WCMD_PASSIVE_SCAN_TIME);
532 return;
533 }
534
535 }
536
537 break;
538
539 case WLAN_CMD_SCAN_END:
540
541 // Set Baseband's sensitivity back.
542 if (pDevice->byBBType != pDevice->byScanBBType) {
543 pDevice->byBBType = pDevice->byScanBBType;
544 CARDvSetBSSMode(pDevice);
545 }
546
547 if (pDevice->bUpdateBBVGA) {
548 BBvSetShortSlotTime(pDevice);
549 BBvSetVGAGainOffset(pDevice, pDevice->byBBVGACurrent);
550 BBvUpdatePreEDThreshold(pDevice, FALSE);
551 }
552
553 // Set channel back
554 vAdHocBeaconRestart(pDevice);
555 // Set channel back
556 CARDbSetMediaChannel(pDevice, pMgmt->uCurrChannel);
557 // Set Filter
558 if (pMgmt->bCurrBSSIDFilterOn) {
559 MACvRegBitsOn(pDevice, MAC_REG_RCR, RCR_BSSID);
560 pDevice->byRxMode |= RCR_BSSID;
561 }
562 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Scanning, set back to channel: [%d]\n", pMgmt->uCurrChannel);
563 pMgmt->eScanState = WMAC_NO_SCANNING;
564 pDevice->bStopDataPkt = FALSE;
565//2008-0409-07, <Add> by Einsn Liu
566#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
567 if(pMgmt->eScanType == WMAC_SCAN_PASSIVE)
568 {
569 //send scan event to wpa_Supplicant
570 union iwreq_data wrqu;
571 PRINT_K("wireless_send_event--->SIOCGIWSCAN(scan done)\n");
572 memset(&wrqu, 0, sizeof(wrqu));
573 wireless_send_event(pDevice->dev, SIOCGIWSCAN, &wrqu, NULL);
574 }
575#endif
576 s_bCommandComplete(pDevice);
577 break;
578
579 case WLAN_CMD_DISASSOCIATE_START :
580 pDevice->byReAssocCount = 0;
581 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_STA) &&
582 (pMgmt->eCurrState != WMAC_STATE_ASSOC)) {
583 s_bCommandComplete(pDevice);
584 spin_unlock_irq(&pDevice->lock);
585 return;
586 } else {
587
588 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
589 pDevice->bwextstep0 = FALSE;
590 pDevice->bwextstep1 = FALSE;
591 pDevice->bwextstep2 = FALSE;
592 pDevice->bwextstep3 = FALSE;
593 pDevice->bWPASuppWextEnabled = FALSE;
594 #endif
595 pDevice->fWPA_Authened = FALSE;
596
597 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Send Disassociation Packet..\n");
598 // reason = 8 : disassoc because sta has left
599 vMgrDisassocBeginSta((HANDLE)pDevice, pMgmt, pMgmt->abyCurrBSSID, (8), &Status);
600 pDevice->bLinkPass = FALSE;
601 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
602 // unlock command busy
603 pItemSSID = (PWLAN_IE_SSID)pMgmt->abyCurrSSID;
604 pItemSSID->len = 0;
605 memset(pItemSSID->abySSID, 0, WLAN_SSID_MAXLEN);
606 pMgmt->eCurrState = WMAC_STATE_IDLE;
607 pMgmt->sNodeDBTable[0].bActive = FALSE;
608// pDevice->bBeaconBufReady = FALSE;
609 }
610 netif_stop_queue(pDevice->dev);
611 if (pDevice->bNeedRadioOFF == TRUE)
612 CARDbRadioPowerOff(pDevice);
613 s_bCommandComplete(pDevice);
614 break;
615
616
617 case WLAN_CMD_SSID_START:
618
619 pDevice->byReAssocCount = 0;
620 if (pDevice->bRadioOff == TRUE) {
621 s_bCommandComplete(pDevice);
622 spin_unlock_irq(&pDevice->lock);
623 return;
624 }
625
626//20080131-03,<Add> by Mike Liu
627 #ifdef Adhoc_STA
628 memcpy(pMgmt->abyAdHocSSID,pMgmt->abyDesireSSID,
629 ((PWLAN_IE_SSID)pMgmt->abyDesireSSID)->len + WLAN_IEHDR_LEN);
630 #endif
631 pItemSSID = (PWLAN_IE_SSID)pMgmt->abyDesireSSID;
632 pItemSSIDCurr = (PWLAN_IE_SSID)pMgmt->abyCurrSSID;
633 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" cmd: desire ssid = %s\n", pItemSSID->abySSID);
634 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" cmd: curr ssid = %s\n", pItemSSIDCurr->abySSID);
635
636 if (pMgmt->eCurrState == WMAC_STATE_ASSOC) {
637 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Cmd pMgmt->eCurrState == WMAC_STATE_ASSOC\n");
638 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" pItemSSID->len =%d\n",pItemSSID->len);
639 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" pItemSSIDCurr->len = %d\n",pItemSSIDCurr->len);
640 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" desire ssid = %s\n", pItemSSID->abySSID);
641 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" curr ssid = %s\n", pItemSSIDCurr->abySSID);
642 }
643
644 if ((pMgmt->eCurrState == WMAC_STATE_ASSOC) ||
645 ((pMgmt->eCurrMode == WMAC_MODE_IBSS_STA)&& (pMgmt->eCurrState == WMAC_STATE_JOINTED))) {
646
647 if (pItemSSID->len == pItemSSIDCurr->len) {
648 if (memcmp(pItemSSID->abySSID, pItemSSIDCurr->abySSID, pItemSSID->len) == 0) {
649 s_bCommandComplete(pDevice);
650 spin_unlock_irq(&pDevice->lock);
651 return;
652 }
653 }
654 netif_stop_queue(pDevice->dev);
655 pDevice->bLinkPass = FALSE;
656 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
657 }
658 // set initial state
659 pMgmt->eCurrState = WMAC_STATE_IDLE;
660 pMgmt->eCurrMode = WMAC_MODE_STANDBY;
661 PSvDisablePowerSaving((HANDLE)pDevice);
662 BSSvClearNodeDBTable(pDevice, 0);
663 vMgrJoinBSSBegin((HANDLE)pDevice, &Status);
664 // if Infra mode
665 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_STA) && (pMgmt->eCurrState == WMAC_STATE_JOINTED)) {
666 // Call mgr to begin the deauthentication
667 // reason = (3) beacuse sta has left ESS
668 if (pMgmt->eCurrState>= WMAC_STATE_AUTH) {
669 vMgrDeAuthenBeginSta((HANDLE)pDevice, pMgmt, pMgmt->abyCurrBSSID, (3), &Status);
670 }
671 // Call mgr to begin the authentication
672 vMgrAuthenBeginSta((HANDLE)pDevice, pMgmt, &Status);
673 if (Status == CMD_STATUS_SUCCESS) {
674 pDevice->byLinkWaitCount = 0;
675 pDevice->eCommandState = WLAN_AUTHENTICATE_WAIT;
676 vCommandTimerWait((HANDLE)pDevice, AUTHENTICATE_TIMEOUT);
677 spin_unlock_irq(&pDevice->lock);
678 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Set eCommandState = WLAN_AUTHENTICATE_WAIT\n");
679 return;
680 }
681 }
682 // if Adhoc mode
683 else if (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
684 if (pMgmt->eCurrState == WMAC_STATE_JOINTED) {
685 if (netif_queue_stopped(pDevice->dev)){
686 netif_wake_queue(pDevice->dev);
687 }
688 pDevice->bLinkPass = TRUE;
689 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_INTER);
690 pMgmt->sNodeDBTable[0].bActive = TRUE;
691 pMgmt->sNodeDBTable[0].uInActiveCount = 0;
692 }
693 else {
694 // start own IBSS
695 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "CreateOwn IBSS by CurrMode = IBSS_STA \n");
696 vMgrCreateOwnIBSS((HANDLE)pDevice, &Status);
697 if (Status != CMD_STATUS_SUCCESS){
698 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " WLAN_CMD_IBSS_CREATE fail ! \n");
699 };
700 BSSvAddMulticastNode(pDevice);
701 }
702 s_bClearBSSID_SCAN(pDevice);
703 }
704 // if SSID not found
705 else if (pMgmt->eCurrMode == WMAC_MODE_STANDBY) {
706 if (pMgmt->eConfigMode == WMAC_CONFIG_IBSS_STA ||
707 pMgmt->eConfigMode == WMAC_CONFIG_AUTO) {
708 // start own IBSS
709 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "CreateOwn IBSS by CurrMode = STANDBY \n");
710 vMgrCreateOwnIBSS((HANDLE)pDevice, &Status);
711 if (Status != CMD_STATUS_SUCCESS){
712 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" WLAN_CMD_IBSS_CREATE fail ! \n");
713 };
714 BSSvAddMulticastNode(pDevice);
715 s_bClearBSSID_SCAN(pDevice);
716/*
717 pDevice->bLinkPass = TRUE;
718 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_INTER);
719 if (netif_queue_stopped(pDevice->dev)){
720 netif_wake_queue(pDevice->dev);
721 }
722 s_bClearBSSID_SCAN(pDevice);
723*/
724 }
725 else {
726 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Disconnect SSID none\n");
727 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
728 // if(pDevice->bWPASuppWextEnabled == TRUE)
729 {
730 union iwreq_data wrqu;
731 memset(&wrqu, 0, sizeof (wrqu));
732 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
733 PRINT_K("wireless_send_event--->SIOCGIWAP(disassociated:vMgrJoinBSSBegin Fail !!)\n");
734 wireless_send_event(pDevice->dev, SIOCGIWAP, &wrqu, NULL);
735 }
736 #endif
737 }
738 }
739 s_bCommandComplete(pDevice);
740 break;
741
742 case WLAN_AUTHENTICATE_WAIT :
743 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCommandState == WLAN_AUTHENTICATE_WAIT\n");
744 if (pMgmt->eCurrState == WMAC_STATE_AUTH) {
745 pDevice->byLinkWaitCount = 0;
746 // Call mgr to begin the association
747 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCurrState == WMAC_STATE_AUTH\n");
748 vMgrAssocBeginSta((HANDLE)pDevice, pMgmt, &Status);
749 if (Status == CMD_STATUS_SUCCESS) {
750 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCommandState = WLAN_ASSOCIATE_WAIT\n");
751 pDevice->byLinkWaitCount = 0;
752 pDevice->eCommandState = WLAN_ASSOCIATE_WAIT;
753 vCommandTimerWait((HANDLE)pDevice, ASSOCIATE_TIMEOUT);
754 spin_unlock_irq(&pDevice->lock);
755 return;
756 }
757 }
758 else if(pMgmt->eCurrState < WMAC_STATE_AUTHPENDING) {
759 printk("WLAN_AUTHENTICATE_WAIT:Authen Fail???\n");
760 }
761 else if(pDevice->byLinkWaitCount <= 4){ //mike add:wait another 2 sec if authenticated_frame delay!
762 pDevice->byLinkWaitCount ++;
763 printk("WLAN_AUTHENTICATE_WAIT:wait %d times!!\n",pDevice->byLinkWaitCount);
764 spin_unlock_irq(&pDevice->lock);
765 vCommandTimerWait((HANDLE)pDevice, AUTHENTICATE_TIMEOUT/2);
766 return;
767 }
768 pDevice->byLinkWaitCount = 0;
769 #if 0
770 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
771 // if(pDevice->bWPASuppWextEnabled == TRUE)
772 {
773 union iwreq_data wrqu;
774 memset(&wrqu, 0, sizeof (wrqu));
775 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
776 printk("wireless_send_event--->SIOCGIWAP(disassociated:AUTHENTICATE_WAIT_timeout)\n");
777 wireless_send_event(pDevice->dev, SIOCGIWAP, &wrqu, NULL);
778 }
779 #endif
780 #endif
781
782 s_bCommandComplete(pDevice);
783 break;
784
785 case WLAN_ASSOCIATE_WAIT :
786 if (pMgmt->eCurrState == WMAC_STATE_ASSOC) {
787 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCurrState == WMAC_STATE_ASSOC\n");
788 if (pDevice->ePSMode != WMAC_POWER_CAM) {
789 PSvEnablePowerSaving((HANDLE)pDevice, pMgmt->wListenInterval);
790 }
791/*
792 if (pMgmt->eAuthenMode >= WMAC_AUTH_WPA) {
793 KeybRemoveAllKey(pDevice, &(pDevice->sKey), pDevice->abyBSSID);
794 }
795*/
796 pDevice->byLinkWaitCount = 0;
797 pDevice->byReAssocCount = 0;
798 pDevice->bLinkPass = TRUE;
799 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_INTER);
800 s_bClearBSSID_SCAN(pDevice);
801
802 if (netif_queue_stopped(pDevice->dev)){
803 netif_wake_queue(pDevice->dev);
804 }
805
806 //2007-0115-07<Add>by MikeLiu
807 #ifdef TxInSleep
808 if(pDevice->IsTxDataTrigger != FALSE) { //TxDataTimer is not triggered at the first time
809 // printk("Re-initial TxDataTimer****\n");
810 del_timer(&pDevice->sTimerTxData);
811 init_timer(&pDevice->sTimerTxData);
812 pDevice->sTimerTxData.data = (ULONG)pDevice;
813 pDevice->sTimerTxData.function = (TimerFunction)BSSvSecondTxData;
814 pDevice->sTimerTxData.expires = RUN_AT(10*HZ); //10s callback
815 pDevice->fTxDataInSleep = FALSE;
816 pDevice->nTxDataTimeCout = 0;
817 }
818 else {
819 // printk("mike:-->First time triger TimerTxData InSleep\n");
820 }
821 pDevice->IsTxDataTrigger = TRUE;
822 add_timer(&pDevice->sTimerTxData);
823 #endif
824
825 }
826 else if(pMgmt->eCurrState < WMAC_STATE_ASSOCPENDING) {
827 printk("WLAN_ASSOCIATE_WAIT:Association Fail???\n");
828 }
829 else if(pDevice->byLinkWaitCount <= 4){ //mike add:wait another 2 sec if associated_frame delay!
830 pDevice->byLinkWaitCount ++;
831 printk("WLAN_ASSOCIATE_WAIT:wait %d times!!\n",pDevice->byLinkWaitCount);
832 spin_unlock_irq(&pDevice->lock);
833 vCommandTimerWait((HANDLE)pDevice, ASSOCIATE_TIMEOUT/2);
834 return;
835 }
836 pDevice->byLinkWaitCount = 0;
837 #if 0
838 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
839 // if(pDevice->bWPASuppWextEnabled == TRUE)
840 {
841 union iwreq_data wrqu;
842 memset(&wrqu, 0, sizeof (wrqu));
843 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
844 printk("wireless_send_event--->SIOCGIWAP(disassociated:ASSOCIATE_WAIT_timeout)\n");
845 wireless_send_event(pDevice->dev, SIOCGIWAP, &wrqu, NULL);
846 }
847 #endif
848 #endif
849
850 s_bCommandComplete(pDevice);
851 break;
852
853 case WLAN_CMD_AP_MODE_START :
854 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCommandState == WLAN_CMD_AP_MODE_START\n");
855
856 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
857 del_timer(&pMgmt->sTimerSecondCallback);
858 pMgmt->eCurrState = WMAC_STATE_IDLE;
859 pMgmt->eCurrMode = WMAC_MODE_STANDBY;
860 pDevice->bLinkPass = FALSE;
861 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
862 if (pDevice->bEnableHostWEP == TRUE)
863 BSSvClearNodeDBTable(pDevice, 1);
864 else
865 BSSvClearNodeDBTable(pDevice, 0);
866 pDevice->uAssocCount = 0;
867 pMgmt->eCurrState = WMAC_STATE_IDLE;
868 pDevice->bFixRate = FALSE;
869
870 vMgrCreateOwnIBSS((HANDLE)pDevice, &Status);
871 if (Status != CMD_STATUS_SUCCESS){
872 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " vMgrCreateOwnIBSS fail ! \n");
873 };
874 // alway turn off unicast bit
875 MACvRegBitsOff(pDevice, MAC_REG_RCR, RCR_UNICAST);
876 pDevice->byRxMode &= ~RCR_UNICAST;
877 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "wcmd: rx_mode = %x\n", pDevice->byRxMode );
878 BSSvAddMulticastNode(pDevice);
879 if (netif_queue_stopped(pDevice->dev)){
880 netif_wake_queue(pDevice->dev);
881 }
882 pDevice->bLinkPass = TRUE;
883 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_INTER);
884 add_timer(&pMgmt->sTimerSecondCallback);
885 }
886 s_bCommandComplete(pDevice);
887 break;
888
889 case WLAN_CMD_TX_PSPACKET_START :
890 // DTIM Multicast tx
891 if (pMgmt->sNodeDBTable[0].bRxPSPoll) {
892 while ((skb = skb_dequeue(&pMgmt->sNodeDBTable[0].sTxPSQueue)) != NULL) {
893 if (skb_queue_empty(&pMgmt->sNodeDBTable[0].sTxPSQueue)) {
894 pMgmt->abyPSTxMap[0] &= ~byMask[0];
895 pDevice->bMoreData = FALSE;
896 }
897 else {
898 pDevice->bMoreData = TRUE;
899 }
900
901 if (nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb) != 0) {
902 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Multicast ps tx fail \n");
903 }
904
905 pMgmt->sNodeDBTable[0].wEnQueueCnt--;
906 }
907 };
908
909 // PS nodes tx
910 for (ii = 1; ii < (MAX_NODE_NUM + 1); ii++) {
911 if (pMgmt->sNodeDBTable[ii].bActive &&
912 pMgmt->sNodeDBTable[ii].bRxPSPoll) {
913 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Index=%d Enqueu Cnt= %d\n",
914 ii, pMgmt->sNodeDBTable[ii].wEnQueueCnt);
915 while ((skb = skb_dequeue(&pMgmt->sNodeDBTable[ii].sTxPSQueue)) != NULL) {
916 if (skb_queue_empty(&pMgmt->sNodeDBTable[ii].sTxPSQueue)) {
917 // clear tx map
918 pMgmt->abyPSTxMap[pMgmt->sNodeDBTable[ii].wAID >> 3] &=
919 ~byMask[pMgmt->sNodeDBTable[ii].wAID & 7];
920 pDevice->bMoreData = FALSE;
921 }
922 else {
923 pDevice->bMoreData = TRUE;
924 }
925
926 if (nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb) != 0) {
927 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "sta ps tx fail \n");
928 }
929
930 pMgmt->sNodeDBTable[ii].wEnQueueCnt--;
931 // check if sta ps enable, wait next pspoll
932 // if sta ps disable, send all pending buffers.
933 if (pMgmt->sNodeDBTable[ii].bPSEnable)
934 break;
935 }
936 if (skb_queue_empty(&pMgmt->sNodeDBTable[ii].sTxPSQueue)) {
937 // clear tx map
938 pMgmt->abyPSTxMap[pMgmt->sNodeDBTable[ii].wAID >> 3] &=
939 ~byMask[pMgmt->sNodeDBTable[ii].wAID & 7];
940 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Index=%d PS queue clear \n", ii);
941 }
942 pMgmt->sNodeDBTable[ii].bRxPSPoll = FALSE;
943 }
944 }
945
946 s_bCommandComplete(pDevice);
947 break;
948
949 case WLAN_CMD_RADIO_START:
950
951 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCommandState == WLAN_CMD_RADIO_START\n");
952 // if (pDevice->bRadioCmd == TRUE)
953 // CARDbRadioPowerOn(pDevice);
954 // else
955 // CARDbRadioPowerOff(pDevice);
956 //2008-09-09<Add> BY Mike:Hot Key for Radio On/Off
957 {
958 NTSTATUS ntStatus = STATUS_SUCCESS;
959 BYTE byTmp;
960
961 ntStatus = CONTROLnsRequestIn(pDevice,
962 MESSAGE_TYPE_READ,
963 MAC_REG_GPIOCTL1,
964 MESSAGE_REQUEST_MACREG,
965 1,
966 &byTmp);
967
968 if ( ntStatus != STATUS_SUCCESS ) {
969 s_bCommandComplete(pDevice);
970 spin_unlock_irq(&pDevice->lock);
971 return;
972 }
973 if ( (byTmp & GPIO3_DATA) == 0 ) {
974 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" WLAN_CMD_RADIO_START_OFF........................\n");
975 // Old commands are useless.
976 // empty command Q
977 pDevice->cbFreeCmdQueue = CMD_Q_SIZE;
978 pDevice->uCmdDequeueIdx = 0;
979 pDevice->uCmdEnqueueIdx = 0;
980 //0415pDevice->bCmdRunning = FALSE;
981 pDevice->bCmdClear = TRUE;
982 pDevice->bStopTx0Pkt = FALSE;
983 pDevice->bStopDataPkt = TRUE;
984
985 pDevice->byKeyIndex = 0;
986 pDevice->bTransmitKey = FALSE;
987 spin_unlock_irq(&pDevice->lock);
988 KeyvInitTable(pDevice,&pDevice->sKey);
989 spin_lock_irq(&pDevice->lock);
990 pMgmt->byCSSPK = KEY_CTL_NONE;
991 pMgmt->byCSSGK = KEY_CTL_NONE;
992
993 if (pDevice->bLinkPass == TRUE) {
994 // reason = 8 : disassoc because sta has left
995 vMgrDisassocBeginSta((HANDLE)pDevice, pMgmt, pMgmt->abyCurrBSSID, (8), &Status);
996 pDevice->bLinkPass = FALSE;
997 // unlock command busy
998 pMgmt->eCurrState = WMAC_STATE_IDLE;
999 pMgmt->sNodeDBTable[0].bActive = FALSE;
1000 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1001 // if(pDevice->bWPASuppWextEnabled == TRUE)
1002 {
1003 union iwreq_data wrqu;
1004 memset(&wrqu, 0, sizeof (wrqu));
1005 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1006 PRINT_K("wireless_send_event--->SIOCGIWAP(disassociated)\n");
1007 wireless_send_event(pDevice->dev, SIOCGIWAP, &wrqu, NULL);
1008 }
1009 #endif
1010 }
1011 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1012 pDevice->bwextstep0 = FALSE;
1013 pDevice->bwextstep1 = FALSE;
1014 pDevice->bwextstep2 = FALSE;
1015 pDevice->bwextstep3 = FALSE;
1016 pDevice->bWPASuppWextEnabled = FALSE;
1017 #endif
1018 //clear current SSID
1019 pItemSSID = (PWLAN_IE_SSID)pMgmt->abyCurrSSID;
1020 pItemSSID->len = 0;
1021 memset(pItemSSID->abySSID, 0, WLAN_SSID_MAXLEN);
1022 //clear dessire SSID
1023 pItemSSID = (PWLAN_IE_SSID)pMgmt->abyDesireSSID;
1024 pItemSSID->len = 0;
1025 memset(pItemSSID->abySSID, 0, WLAN_SSID_MAXLEN);
1026
1027 netif_stop_queue(pDevice->dev);
1028 CARDbRadioPowerOff(pDevice);
1029 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
1030 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_OFF);
1031 pDevice->bHWRadioOff = TRUE;
1032 } else {
1033 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" WLAN_CMD_RADIO_START_ON........................\n");
1034 pDevice->bHWRadioOff = FALSE;
1035 CARDbRadioPowerOn(pDevice);
1036 MACvRegBitsOff(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
1037 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_ON);
1038 }
1039 }
1040
1041 s_bCommandComplete(pDevice);
1042 break;
1043
1044
1045 case WLAN_CMD_CHANGE_BBSENSITIVITY_START:
1046
1047 pDevice->bStopDataPkt = TRUE;
1048 pDevice->byBBVGACurrent = pDevice->byBBVGANew;
1049 BBvSetVGAGainOffset(pDevice, pDevice->byBBVGACurrent);
1050 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Change sensitivity pDevice->byBBVGACurrent = %x\n", pDevice->byBBVGACurrent);
1051 pDevice->bStopDataPkt = FALSE;
1052 s_bCommandComplete(pDevice);
1053 break;
1054
1055 case WLAN_CMD_TBTT_WAKEUP_START:
1056 PSbIsNextTBTTWakeUp(pDevice);
1057 s_bCommandComplete(pDevice);
1058 break;
1059
1060 case WLAN_CMD_BECON_SEND_START:
1061 bMgrPrepareBeaconToSend(pDevice, pMgmt);
1062 s_bCommandComplete(pDevice);
1063 break;
1064
1065 case WLAN_CMD_SETPOWER_START:
1066
1067 RFbSetPower(pDevice, pDevice->wCurrentRate, pMgmt->uCurrChannel);
1068
1069 s_bCommandComplete(pDevice);
1070 break;
1071
1072 case WLAN_CMD_CHANGE_ANTENNA_START:
1073 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Change from Antenna%d to", (int)pDevice->dwRxAntennaSel);
1074 if ( pDevice->dwRxAntennaSel == 0) {
1075 pDevice->dwRxAntennaSel=1;
1076 if (pDevice->bTxRxAntInv == TRUE)
1077 BBvSetAntennaMode(pDevice, ANT_RXA);
1078 else
1079 BBvSetAntennaMode(pDevice, ANT_RXB);
1080 } else {
1081 pDevice->dwRxAntennaSel=0;
1082 if (pDevice->bTxRxAntInv == TRUE)
1083 BBvSetAntennaMode(pDevice, ANT_RXB);
1084 else
1085 BBvSetAntennaMode(pDevice, ANT_RXA);
1086 }
1087 s_bCommandComplete(pDevice);
1088 break;
1089
1090 case WLAN_CMD_REMOVE_ALLKEY_START:
1091 KeybRemoveAllKey(pDevice, &(pDevice->sKey), pDevice->abyBSSID);
1092 s_bCommandComplete(pDevice);
1093 break;
1094
1095
1096 case WLAN_CMD_MAC_DISPOWERSAVING_START:
1097 ControlvReadByte (pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_PSCTL, &byData);
1098 if ( (byData & PSCTL_PS) != 0 ) {
1099 // disable power saving hw function
1100 CONTROLnsRequestOut(pDevice,
1101 MESSAGE_TYPE_DISABLE_PS,
1102 0,
1103 0,
1104 0,
1105 NULL
1106 );
1107 }
1108 s_bCommandComplete(pDevice);
1109 break;
1110
1111 case WLAN_CMD_11H_CHSW_START:
1112 CARDbSetMediaChannel(pDevice, pDevice->byNewChannel);
1113 pDevice->bChannelSwitch = FALSE;
1114 pMgmt->uCurrChannel = pDevice->byNewChannel;
1115 pDevice->bStopDataPkt = FALSE;
1116 s_bCommandComplete(pDevice);
1117 break;
1118
1119 default:
1120 s_bCommandComplete(pDevice);
1121 break;
1122 } //switch
1123
1124 spin_unlock_irq(&pDevice->lock);
1125 return;
1126}
1127
1128
1129static
1130BOOL
1131s_bCommandComplete (
1132 PSDevice pDevice
1133 )
1134{
1135 PWLAN_IE_SSID pSSID;
1136 BOOL bRadioCmd = FALSE;
1137 //WORD wDeAuthenReason = 0;
1138 BOOL bForceSCAN = TRUE;
1139 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1140
1141
1142 pDevice->eCommandState = WLAN_CMD_IDLE;
1143 if (pDevice->cbFreeCmdQueue == CMD_Q_SIZE) {
1144 //Command Queue Empty
1145 pDevice->bCmdRunning = FALSE;
1146 return TRUE;
1147 }
1148 else {
1149 pDevice->eCommand = pDevice->eCmdQueue[pDevice->uCmdDequeueIdx].eCmd;
1150 pSSID = (PWLAN_IE_SSID)pDevice->eCmdQueue[pDevice->uCmdDequeueIdx].abyCmdDesireSSID;
1151 bRadioCmd = pDevice->eCmdQueue[pDevice->uCmdDequeueIdx].bRadioCmd;
1152 bForceSCAN = pDevice->eCmdQueue[pDevice->uCmdDequeueIdx].bForceSCAN;
1153 ADD_ONE_WITH_WRAP_AROUND(pDevice->uCmdDequeueIdx, CMD_Q_SIZE);
1154 pDevice->cbFreeCmdQueue++;
1155 pDevice->bCmdRunning = TRUE;
1156 switch ( pDevice->eCommand ) {
1157 case WLAN_CMD_BSSID_SCAN:
1158 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCommandState= WLAN_CMD_BSSID_SCAN\n");
1159 pDevice->eCommandState = WLAN_CMD_SCAN_START;
1160 pMgmt->uScanChannel = 0;
1161 if (pSSID->len != 0) {
1162 MEMvCopy(pMgmt->abyScanSSID, pSSID, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1163 } else {
1164 memset(pMgmt->abyScanSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1165 }
1166/*
1167 if ((bForceSCAN == FALSE) && (pDevice->bLinkPass == TRUE)) {
1168 if ((pSSID->len == ((PWLAN_IE_SSID)pMgmt->abyCurrSSID)->len) &&
1169 (MEMEqualMemory(pSSID->abySSID, ((PWLAN_IE_SSID)pMgmt->abyCurrSSID)->abySSID, pSSID->len))) {
1170 pDevice->eCommandState = WLAN_CMD_IDLE;
1171 }
1172 }
1173*/
1174 break;
1175 case WLAN_CMD_SSID:
1176 pDevice->eCommandState = WLAN_CMD_SSID_START;
1177 if (pSSID->len > WLAN_SSID_MAXLEN)
1178 pSSID->len = WLAN_SSID_MAXLEN;
1179 if (pSSID->len != 0)
1180 MEMvCopy(pMgmt->abyDesireSSID, pSSID, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1181 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCommandState= WLAN_CMD_SSID_START\n");
1182 break;
1183 case WLAN_CMD_DISASSOCIATE:
1184 pDevice->eCommandState = WLAN_CMD_DISASSOCIATE_START;
1185 break;
1186 case WLAN_CMD_RX_PSPOLL:
1187 pDevice->eCommandState = WLAN_CMD_TX_PSPACKET_START;
1188 break;
1189 case WLAN_CMD_RUN_AP:
1190 pDevice->eCommandState = WLAN_CMD_AP_MODE_START;
1191 break;
1192 case WLAN_CMD_RADIO:
1193 pDevice->eCommandState = WLAN_CMD_RADIO_START;
1194 pDevice->bRadioCmd = bRadioCmd;
1195 break;
1196 case WLAN_CMD_CHANGE_BBSENSITIVITY:
1197 pDevice->eCommandState = WLAN_CMD_CHANGE_BBSENSITIVITY_START;
1198 break;
1199
1200 case WLAN_CMD_TBTT_WAKEUP:
1201 pDevice->eCommandState = WLAN_CMD_TBTT_WAKEUP_START;
1202 break;
1203
1204 case WLAN_CMD_BECON_SEND:
1205 pDevice->eCommandState = WLAN_CMD_BECON_SEND_START;
1206 break;
1207
1208 case WLAN_CMD_SETPOWER:
1209 pDevice->eCommandState = WLAN_CMD_SETPOWER_START;
1210 break;
1211
1212 case WLAN_CMD_CHANGE_ANTENNA:
1213 pDevice->eCommandState = WLAN_CMD_CHANGE_ANTENNA_START;
1214 break;
1215
1216 case WLAN_CMD_REMOVE_ALLKEY:
1217 pDevice->eCommandState = WLAN_CMD_REMOVE_ALLKEY_START;
1218 break;
1219
1220 case WLAN_CMD_MAC_DISPOWERSAVING:
1221 pDevice->eCommandState = WLAN_CMD_MAC_DISPOWERSAVING_START;
1222 break;
1223
1224 case WLAN_CMD_11H_CHSW:
1225 pDevice->eCommandState = WLAN_CMD_11H_CHSW_START;
1226 break;
1227
1228 default:
1229 break;
1230
1231 }
1232
1233 vCommandTimerWait((HANDLE)pDevice, 0);
1234 }
1235
1236 return TRUE;
1237}
1238
1239BOOL bScheduleCommand (
1240 IN HANDLE hDeviceContext,
1241 IN CMD_CODE eCommand,
1242 IN PBYTE pbyItem0
1243 )
1244{
1245 PSDevice pDevice = (PSDevice)hDeviceContext;
1246
1247
1248 if (pDevice->cbFreeCmdQueue == 0) {
1249 return (FALSE);
1250 }
1251 pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].eCmd = eCommand;
1252 pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].bForceSCAN = TRUE;
1253 memset(pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].abyCmdDesireSSID, 0 , WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1254 if (pbyItem0 != NULL) {
1255 switch (eCommand) {
1256 case WLAN_CMD_BSSID_SCAN:
1257 pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].bForceSCAN = FALSE;
1258 MEMvCopy(pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].abyCmdDesireSSID,
1259 pbyItem0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1260 break;
1261
1262 case WLAN_CMD_SSID:
1263 MEMvCopy(pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].abyCmdDesireSSID,
1264 pbyItem0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1265 break;
1266
1267 case WLAN_CMD_DISASSOCIATE:
1268 pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].bNeedRadioOFF = *((PBOOL)pbyItem0);
1269 break;
1270/*
1271 case WLAN_CMD_DEAUTH:
1272 pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].wDeAuthenReason = *((PWORD)pbyItem0);
1273 break;
1274*/
1275
1276 case WLAN_CMD_RADIO:
1277 pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].bRadioCmd = *((PBOOL)pbyItem0);
1278 break;
1279
1280 default:
1281 break;
1282 }
1283 }
1284
1285 ADD_ONE_WITH_WRAP_AROUND(pDevice->uCmdEnqueueIdx, CMD_Q_SIZE);
1286 pDevice->cbFreeCmdQueue--;
1287
1288 if (pDevice->bCmdRunning == FALSE) {
1289 s_bCommandComplete(pDevice);
1290 }
1291 else {
1292 }
1293 return (TRUE);
1294
1295}
1296
1297/*
1298 * Description:
1299 * Clear BSSID_SCAN cmd in CMD Queue
1300 *
1301 * Parameters:
1302 * In:
1303 * hDeviceContext - Pointer to the adapter
1304 * eCommand - Command
1305 * Out:
1306 * none
1307 *
1308 * Return Value: TRUE if success; otherwise FALSE
1309 *
1310 */
1311static
1312BOOL s_bClearBSSID_SCAN (
1313 IN HANDLE hDeviceContext
1314 )
1315{
1316 PSDevice pDevice = (PSDevice)hDeviceContext;
1317 UINT uCmdDequeueIdx = pDevice->uCmdDequeueIdx;
1318 UINT ii;
1319
1320 if ((pDevice->cbFreeCmdQueue < CMD_Q_SIZE) && (uCmdDequeueIdx != pDevice->uCmdEnqueueIdx)) {
1321 for (ii = 0; ii < (CMD_Q_SIZE - pDevice->cbFreeCmdQueue); ii ++) {
1322 if (pDevice->eCmdQueue[uCmdDequeueIdx].eCmd == WLAN_CMD_BSSID_SCAN)
1323 pDevice->eCmdQueue[uCmdDequeueIdx].eCmd = WLAN_CMD_IDLE;
1324 ADD_ONE_WITH_WRAP_AROUND(uCmdDequeueIdx, CMD_Q_SIZE);
1325 if (uCmdDequeueIdx == pDevice->uCmdEnqueueIdx)
1326 break;
1327 }
1328 }
1329 return TRUE;
1330}
1331
1332
1333//mike add:reset command timer
1334VOID
1335vResetCommandTimer(
1336 IN HANDLE hDeviceContext
1337 )
1338{
1339 PSDevice pDevice = (PSDevice)hDeviceContext;
1340
1341 //delete timer
1342 del_timer(&pDevice->sTimerCommand);
1343 //init timer
1344 init_timer(&pDevice->sTimerCommand);
1345 pDevice->sTimerCommand.data = (ULONG)pDevice;
1346 pDevice->sTimerCommand.function = (TimerFunction)vRunCommand;
1347 pDevice->sTimerCommand.expires = RUN_AT(HZ);
1348 pDevice->cbFreeCmdQueue = CMD_Q_SIZE;
1349 pDevice->uCmdDequeueIdx = 0;
1350 pDevice->uCmdEnqueueIdx = 0;
1351 pDevice->eCommandState = WLAN_CMD_IDLE;
1352 pDevice->bCmdRunning = FALSE;
1353 pDevice->bCmdClear = FALSE;
1354}
1355
1356//2007-0115-08<Add>by MikeLiu
1357#ifdef TxInSleep
1358VOID
1359BSSvSecondTxData(
1360 IN HANDLE hDeviceContext
1361 )
1362{
1363 PSDevice pDevice = (PSDevice)hDeviceContext;
1364 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1365
1366 pDevice->nTxDataTimeCout++;
1367
1368 if(pDevice->nTxDataTimeCout<4) //don't tx data if timer less than 40s
1369 {
1370 // printk("mike:%s-->no data Tx not exceed the desired Time as %d\n",__FUNCTION__,
1371 // (int)pDevice->nTxDataTimeCout);
1372 pDevice->sTimerTxData.expires = RUN_AT(10*HZ); //10s callback
1373 add_timer(&pDevice->sTimerTxData);
1374 return;
1375 }
1376
1377 spin_lock_irq(&pDevice->lock);
1378 //is wap_supplicant running sucessful OR only open && sharekey mode!
1379 #if 1
1380 if(((pDevice->bLinkPass ==TRUE)&&(pMgmt->eAuthenMode < WMAC_AUTH_WPA)) || //open && sharekey linking
1381 (pDevice->fWPA_Authened == TRUE)) { //wpa linking
1382 #else
1383 if(pDevice->bLinkPass ==TRUE) {
1384 #endif
1385 // printk("mike:%s-->InSleep Tx Data Procedure\n",__FUNCTION__);
1386 pDevice->fTxDataInSleep = TRUE;
1387 PSbSendNullPacket(pDevice); //send null packet
1388 pDevice->fTxDataInSleep = FALSE;
1389 }
1390 spin_unlock_irq(&pDevice->lock);
1391
1392 pDevice->sTimerTxData.expires = RUN_AT(10*HZ); //10s callback
1393 add_timer(&pDevice->sTimerTxData);
1394 return;
1395}
1396#endif
1397