Gitiles
Code Review Sign In
gerrit-public.fairphone.software / kernel / msm-4.9 / 92b96797118e5836294a6d42a5a8e10b86f50e3f / . / drivers / staging / vt6656 / wcmd.c
blob: 7c0829ee0ac01ac80af3160a5e3480969c3dbc9e [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);
527 //2008-0526-02<Add>by MikeLiu
528 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)
529 vCommandTimerWait((HANDLE)pDevice, 100);
530 #else
531 vCommandTimerWait((HANDLE)pDevice, WCMD_ACTIVE_SCAN_TIME);
532 #endif
533 return;
534 } else {
535 spin_unlock_irq(&pDevice->lock);
536 vCommandTimerWait((HANDLE)pDevice, WCMD_PASSIVE_SCAN_TIME);
537 return;
538 }
539
540 }
541
542 break;
543
544 case WLAN_CMD_SCAN_END:
545
546 // Set Baseband's sensitivity back.
547 if (pDevice->byBBType != pDevice->byScanBBType) {
548 pDevice->byBBType = pDevice->byScanBBType;
549 CARDvSetBSSMode(pDevice);
550 }
551
552 if (pDevice->bUpdateBBVGA) {
553 BBvSetShortSlotTime(pDevice);
554 BBvSetVGAGainOffset(pDevice, pDevice->byBBVGACurrent);
555 BBvUpdatePreEDThreshold(pDevice, FALSE);
556 }
557
558 // Set channel back
559 vAdHocBeaconRestart(pDevice);
560 // Set channel back
561 CARDbSetMediaChannel(pDevice, pMgmt->uCurrChannel);
562 // Set Filter
563 if (pMgmt->bCurrBSSIDFilterOn) {
564 MACvRegBitsOn(pDevice, MAC_REG_RCR, RCR_BSSID);
565 pDevice->byRxMode |= RCR_BSSID;
566 }
567 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Scanning, set back to channel: [%d]\n", pMgmt->uCurrChannel);
568 pMgmt->eScanState = WMAC_NO_SCANNING;
569 pDevice->bStopDataPkt = FALSE;
570//2008-0409-07, <Add> by Einsn Liu
571#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
572 if(pMgmt->eScanType == WMAC_SCAN_PASSIVE)
573 {
574 //send scan event to wpa_Supplicant
575 union iwreq_data wrqu;
576 PRINT_K("wireless_send_event--->SIOCGIWSCAN(scan done)\n");
577 memset(&wrqu, 0, sizeof(wrqu));
578 wireless_send_event(pDevice->dev, SIOCGIWSCAN, &wrqu, NULL);
579 }
580#endif
581 s_bCommandComplete(pDevice);
582 break;
583
584 case WLAN_CMD_DISASSOCIATE_START :
585 pDevice->byReAssocCount = 0;
586 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_STA) &&
587 (pMgmt->eCurrState != WMAC_STATE_ASSOC)) {
588 s_bCommandComplete(pDevice);
589 spin_unlock_irq(&pDevice->lock);
590 return;
591 } else {
592
593 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
594 pDevice->bwextstep0 = FALSE;
595 pDevice->bwextstep1 = FALSE;
596 pDevice->bwextstep2 = FALSE;
597 pDevice->bwextstep3 = FALSE;
598 pDevice->bWPASuppWextEnabled = FALSE;
599 #endif
600 pDevice->fWPA_Authened = FALSE;
601
602 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Send Disassociation Packet..\n");
603 // reason = 8 : disassoc because sta has left
604 vMgrDisassocBeginSta((HANDLE)pDevice, pMgmt, pMgmt->abyCurrBSSID, (8), &Status);
605 pDevice->bLinkPass = FALSE;
606 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
607 // unlock command busy
608 pItemSSID = (PWLAN_IE_SSID)pMgmt->abyCurrSSID;
609 pItemSSID->len = 0;
610 memset(pItemSSID->abySSID, 0, WLAN_SSID_MAXLEN);
611 pMgmt->eCurrState = WMAC_STATE_IDLE;
612 pMgmt->sNodeDBTable[0].bActive = FALSE;
613// pDevice->bBeaconBufReady = FALSE;
614 }
615 netif_stop_queue(pDevice->dev);
616 if (pDevice->bNeedRadioOFF == TRUE)
617 CARDbRadioPowerOff(pDevice);
618 s_bCommandComplete(pDevice);
619 break;
620
621
622 case WLAN_CMD_SSID_START:
623
624 pDevice->byReAssocCount = 0;
625 if (pDevice->bRadioOff == TRUE) {
626 s_bCommandComplete(pDevice);
627 spin_unlock_irq(&pDevice->lock);
628 return;
629 }
630
631//20080131-03,<Add> by Mike Liu
632 #ifdef Adhoc_STA
633 memcpy(pMgmt->abyAdHocSSID,pMgmt->abyDesireSSID,
634 ((PWLAN_IE_SSID)pMgmt->abyDesireSSID)->len + WLAN_IEHDR_LEN);
635 #endif
636 pItemSSID = (PWLAN_IE_SSID)pMgmt->abyDesireSSID;
637 pItemSSIDCurr = (PWLAN_IE_SSID)pMgmt->abyCurrSSID;
638 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" cmd: desire ssid = %s\n", pItemSSID->abySSID);
639 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" cmd: curr ssid = %s\n", pItemSSIDCurr->abySSID);
640
641 if (pMgmt->eCurrState == WMAC_STATE_ASSOC) {
642 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Cmd pMgmt->eCurrState == WMAC_STATE_ASSOC\n");
643 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" pItemSSID->len =%d\n",pItemSSID->len);
644 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" pItemSSIDCurr->len = %d\n",pItemSSIDCurr->len);
645 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" desire ssid = %s\n", pItemSSID->abySSID);
646 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" curr ssid = %s\n", pItemSSIDCurr->abySSID);
647 }
648
649 if ((pMgmt->eCurrState == WMAC_STATE_ASSOC) ||
650 ((pMgmt->eCurrMode == WMAC_MODE_IBSS_STA)&& (pMgmt->eCurrState == WMAC_STATE_JOINTED))) {
651
652 if (pItemSSID->len == pItemSSIDCurr->len) {
653 if (memcmp(pItemSSID->abySSID, pItemSSIDCurr->abySSID, pItemSSID->len) == 0) {
654 s_bCommandComplete(pDevice);
655 spin_unlock_irq(&pDevice->lock);
656 return;
657 }
658 }
659 netif_stop_queue(pDevice->dev);
660 pDevice->bLinkPass = FALSE;
661 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
662 }
663 // set initial state
664 pMgmt->eCurrState = WMAC_STATE_IDLE;
665 pMgmt->eCurrMode = WMAC_MODE_STANDBY;
666 PSvDisablePowerSaving((HANDLE)pDevice);
667 BSSvClearNodeDBTable(pDevice, 0);
668 vMgrJoinBSSBegin((HANDLE)pDevice, &Status);
669 // if Infra mode
670 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_STA) && (pMgmt->eCurrState == WMAC_STATE_JOINTED)) {
671 // Call mgr to begin the deauthentication
672 // reason = (3) beacuse sta has left ESS
673 if (pMgmt->eCurrState>= WMAC_STATE_AUTH) {
674 vMgrDeAuthenBeginSta((HANDLE)pDevice, pMgmt, pMgmt->abyCurrBSSID, (3), &Status);
675 }
676 // Call mgr to begin the authentication
677 vMgrAuthenBeginSta((HANDLE)pDevice, pMgmt, &Status);
678 if (Status == CMD_STATUS_SUCCESS) {
679 pDevice->byLinkWaitCount = 0;
680 pDevice->eCommandState = WLAN_AUTHENTICATE_WAIT;
681 vCommandTimerWait((HANDLE)pDevice, AUTHENTICATE_TIMEOUT);
682 spin_unlock_irq(&pDevice->lock);
683 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Set eCommandState = WLAN_AUTHENTICATE_WAIT\n");
684 return;
685 }
686 }
687 // if Adhoc mode
688 else if (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
689 if (pMgmt->eCurrState == WMAC_STATE_JOINTED) {
690 if (netif_queue_stopped(pDevice->dev)){
691 netif_wake_queue(pDevice->dev);
692 }
693 pDevice->bLinkPass = TRUE;
694 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_INTER);
695 pMgmt->sNodeDBTable[0].bActive = TRUE;
696 pMgmt->sNodeDBTable[0].uInActiveCount = 0;
697 }
698 else {
699 // start own IBSS
700 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "CreateOwn IBSS by CurrMode = IBSS_STA \n");
701 vMgrCreateOwnIBSS((HANDLE)pDevice, &Status);
702 if (Status != CMD_STATUS_SUCCESS){
703 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " WLAN_CMD_IBSS_CREATE fail ! \n");
704 };
705 BSSvAddMulticastNode(pDevice);
706 }
707 s_bClearBSSID_SCAN(pDevice);
708 }
709 // if SSID not found
710 else if (pMgmt->eCurrMode == WMAC_MODE_STANDBY) {
711 if (pMgmt->eConfigMode == WMAC_CONFIG_IBSS_STA ||
712 pMgmt->eConfigMode == WMAC_CONFIG_AUTO) {
713 // start own IBSS
714 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "CreateOwn IBSS by CurrMode = STANDBY \n");
715 vMgrCreateOwnIBSS((HANDLE)pDevice, &Status);
716 if (Status != CMD_STATUS_SUCCESS){
717 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" WLAN_CMD_IBSS_CREATE fail ! \n");
718 };
719 BSSvAddMulticastNode(pDevice);
720 s_bClearBSSID_SCAN(pDevice);
721/*
722 pDevice->bLinkPass = TRUE;
723 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_INTER);
724 if (netif_queue_stopped(pDevice->dev)){
725 netif_wake_queue(pDevice->dev);
726 }
727 s_bClearBSSID_SCAN(pDevice);
728*/
729 }
730 else {
731 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Disconnect SSID none\n");
732 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
733 // if(pDevice->bWPASuppWextEnabled == TRUE)
734 {
735 union iwreq_data wrqu;
736 memset(&wrqu, 0, sizeof (wrqu));
737 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
738 PRINT_K("wireless_send_event--->SIOCGIWAP(disassociated:vMgrJoinBSSBegin Fail !!)\n");
739 wireless_send_event(pDevice->dev, SIOCGIWAP, &wrqu, NULL);
740 }
741 #endif
742 }
743 }
744 s_bCommandComplete(pDevice);
745 break;
746
747 case WLAN_AUTHENTICATE_WAIT :
748 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCommandState == WLAN_AUTHENTICATE_WAIT\n");
749 if (pMgmt->eCurrState == WMAC_STATE_AUTH) {
750 pDevice->byLinkWaitCount = 0;
751 // Call mgr to begin the association
752 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCurrState == WMAC_STATE_AUTH\n");
753 vMgrAssocBeginSta((HANDLE)pDevice, pMgmt, &Status);
754 if (Status == CMD_STATUS_SUCCESS) {
755 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCommandState = WLAN_ASSOCIATE_WAIT\n");
756 pDevice->byLinkWaitCount = 0;
757 pDevice->eCommandState = WLAN_ASSOCIATE_WAIT;
758 vCommandTimerWait((HANDLE)pDevice, ASSOCIATE_TIMEOUT);
759 spin_unlock_irq(&pDevice->lock);
760 return;
761 }
762 }
763 else if(pMgmt->eCurrState < WMAC_STATE_AUTHPENDING) {
764 printk("WLAN_AUTHENTICATE_WAIT:Authen Fail???\n");
765 }
766 else if(pDevice->byLinkWaitCount <= 4){ //mike add:wait another 2 sec if authenticated_frame delay!
767 pDevice->byLinkWaitCount ++;
768 printk("WLAN_AUTHENTICATE_WAIT:wait %d times!!\n",pDevice->byLinkWaitCount);
769 spin_unlock_irq(&pDevice->lock);
770 vCommandTimerWait((HANDLE)pDevice, AUTHENTICATE_TIMEOUT/2);
771 return;
772 }
773 pDevice->byLinkWaitCount = 0;
774 #if 0
775 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
776 // if(pDevice->bWPASuppWextEnabled == TRUE)
777 {
778 union iwreq_data wrqu;
779 memset(&wrqu, 0, sizeof (wrqu));
780 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
781 printk("wireless_send_event--->SIOCGIWAP(disassociated:AUTHENTICATE_WAIT_timeout)\n");
782 wireless_send_event(pDevice->dev, SIOCGIWAP, &wrqu, NULL);
783 }
784 #endif
785 #endif
786
787 s_bCommandComplete(pDevice);
788 break;
789
790 case WLAN_ASSOCIATE_WAIT :
791 if (pMgmt->eCurrState == WMAC_STATE_ASSOC) {
792 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCurrState == WMAC_STATE_ASSOC\n");
793 if (pDevice->ePSMode != WMAC_POWER_CAM) {
794 PSvEnablePowerSaving((HANDLE)pDevice, pMgmt->wListenInterval);
795 }
796/*
797 if (pMgmt->eAuthenMode >= WMAC_AUTH_WPA) {
798 KeybRemoveAllKey(pDevice, &(pDevice->sKey), pDevice->abyBSSID);
799 }
800*/
801 pDevice->byLinkWaitCount = 0;
802 pDevice->byReAssocCount = 0;
803 pDevice->bLinkPass = TRUE;
804 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_INTER);
805 s_bClearBSSID_SCAN(pDevice);
806
807 if (netif_queue_stopped(pDevice->dev)){
808 netif_wake_queue(pDevice->dev);
809 }
810
811 //2007-0115-07<Add>by MikeLiu
812 #ifdef TxInSleep
813 if(pDevice->IsTxDataTrigger != FALSE) { //TxDataTimer is not triggered at the first time
814 // printk("Re-initial TxDataTimer****\n");
815 del_timer(&pDevice->sTimerTxData);
816 init_timer(&pDevice->sTimerTxData);
817 pDevice->sTimerTxData.data = (ULONG)pDevice;
818 pDevice->sTimerTxData.function = (TimerFunction)BSSvSecondTxData;
819 pDevice->sTimerTxData.expires = RUN_AT(10*HZ); //10s callback
820 pDevice->fTxDataInSleep = FALSE;
821 pDevice->nTxDataTimeCout = 0;
822 }
823 else {
824 // printk("mike:-->First time triger TimerTxData InSleep\n");
825 }
826 pDevice->IsTxDataTrigger = TRUE;
827 add_timer(&pDevice->sTimerTxData);
828 #endif
829
830 }
831 else if(pMgmt->eCurrState < WMAC_STATE_ASSOCPENDING) {
832 printk("WLAN_ASSOCIATE_WAIT:Association Fail???\n");
833 }
834 else if(pDevice->byLinkWaitCount <= 4){ //mike add:wait another 2 sec if associated_frame delay!
835 pDevice->byLinkWaitCount ++;
836 printk("WLAN_ASSOCIATE_WAIT:wait %d times!!\n",pDevice->byLinkWaitCount);
837 spin_unlock_irq(&pDevice->lock);
838 vCommandTimerWait((HANDLE)pDevice, ASSOCIATE_TIMEOUT/2);
839 return;
840 }
841 pDevice->byLinkWaitCount = 0;
842 #if 0
843 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
844 // if(pDevice->bWPASuppWextEnabled == TRUE)
845 {
846 union iwreq_data wrqu;
847 memset(&wrqu, 0, sizeof (wrqu));
848 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
849 printk("wireless_send_event--->SIOCGIWAP(disassociated:ASSOCIATE_WAIT_timeout)\n");
850 wireless_send_event(pDevice->dev, SIOCGIWAP, &wrqu, NULL);
851 }
852 #endif
853 #endif
854
855 s_bCommandComplete(pDevice);
856 break;
857
858 case WLAN_CMD_AP_MODE_START :
859 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCommandState == WLAN_CMD_AP_MODE_START\n");
860
861 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
862 del_timer(&pMgmt->sTimerSecondCallback);
863 pMgmt->eCurrState = WMAC_STATE_IDLE;
864 pMgmt->eCurrMode = WMAC_MODE_STANDBY;
865 pDevice->bLinkPass = FALSE;
866 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
867 if (pDevice->bEnableHostWEP == TRUE)
868 BSSvClearNodeDBTable(pDevice, 1);
869 else
870 BSSvClearNodeDBTable(pDevice, 0);
871 pDevice->uAssocCount = 0;
872 pMgmt->eCurrState = WMAC_STATE_IDLE;
873 pDevice->bFixRate = FALSE;
874
875 vMgrCreateOwnIBSS((HANDLE)pDevice, &Status);
876 if (Status != CMD_STATUS_SUCCESS){
877 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " vMgrCreateOwnIBSS fail ! \n");
878 };
879 // alway turn off unicast bit
880 MACvRegBitsOff(pDevice, MAC_REG_RCR, RCR_UNICAST);
881 pDevice->byRxMode &= ~RCR_UNICAST;
882 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "wcmd: rx_mode = %x\n", pDevice->byRxMode );
883 BSSvAddMulticastNode(pDevice);
884 if (netif_queue_stopped(pDevice->dev)){
885 netif_wake_queue(pDevice->dev);
886 }
887 pDevice->bLinkPass = TRUE;
888 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_INTER);
889 add_timer(&pMgmt->sTimerSecondCallback);
890 }
891 s_bCommandComplete(pDevice);
892 break;
893
894 case WLAN_CMD_TX_PSPACKET_START :
895 // DTIM Multicast tx
896 if (pMgmt->sNodeDBTable[0].bRxPSPoll) {
897 while ((skb = skb_dequeue(&pMgmt->sNodeDBTable[0].sTxPSQueue)) != NULL) {
898 if (skb_queue_empty(&pMgmt->sNodeDBTable[0].sTxPSQueue)) {
899 pMgmt->abyPSTxMap[0] &= ~byMask[0];
900 pDevice->bMoreData = FALSE;
901 }
902 else {
903 pDevice->bMoreData = TRUE;
904 }
905
906 if (nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb) != 0) {
907 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Multicast ps tx fail \n");
908 }
909
910 pMgmt->sNodeDBTable[0].wEnQueueCnt--;
911 }
912 };
913
914 // PS nodes tx
915 for (ii = 1; ii < (MAX_NODE_NUM + 1); ii++) {
916 if (pMgmt->sNodeDBTable[ii].bActive &&
917 pMgmt->sNodeDBTable[ii].bRxPSPoll) {
918 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Index=%d Enqueu Cnt= %d\n",
919 ii, pMgmt->sNodeDBTable[ii].wEnQueueCnt);
920 while ((skb = skb_dequeue(&pMgmt->sNodeDBTable[ii].sTxPSQueue)) != NULL) {
921 if (skb_queue_empty(&pMgmt->sNodeDBTable[ii].sTxPSQueue)) {
922 // clear tx map
923 pMgmt->abyPSTxMap[pMgmt->sNodeDBTable[ii].wAID >> 3] &=
924 ~byMask[pMgmt->sNodeDBTable[ii].wAID & 7];
925 pDevice->bMoreData = FALSE;
926 }
927 else {
928 pDevice->bMoreData = TRUE;
929 }
930
931 if (nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb) != 0) {
932 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "sta ps tx fail \n");
933 }
934
935 pMgmt->sNodeDBTable[ii].wEnQueueCnt--;
936 // check if sta ps enable, wait next pspoll
937 // if sta ps disable, send all pending buffers.
938 if (pMgmt->sNodeDBTable[ii].bPSEnable)
939 break;
940 }
941 if (skb_queue_empty(&pMgmt->sNodeDBTable[ii].sTxPSQueue)) {
942 // clear tx map
943 pMgmt->abyPSTxMap[pMgmt->sNodeDBTable[ii].wAID >> 3] &=
944 ~byMask[pMgmt->sNodeDBTable[ii].wAID & 7];
945 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Index=%d PS queue clear \n", ii);
946 }
947 pMgmt->sNodeDBTable[ii].bRxPSPoll = FALSE;
948 }
949 }
950
951 s_bCommandComplete(pDevice);
952 break;
953
954 case WLAN_CMD_RADIO_START:
955
956 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCommandState == WLAN_CMD_RADIO_START\n");
957 // if (pDevice->bRadioCmd == TRUE)
958 // CARDbRadioPowerOn(pDevice);
959 // else
960 // CARDbRadioPowerOff(pDevice);
961 //2008-09-09<Add> BY Mike:Hot Key for Radio On/Off
962 {
963 NTSTATUS ntStatus = STATUS_SUCCESS;
964 BYTE byTmp;
965
966 ntStatus = CONTROLnsRequestIn(pDevice,
967 MESSAGE_TYPE_READ,
968 MAC_REG_GPIOCTL1,
969 MESSAGE_REQUEST_MACREG,
970 1,
971 &byTmp);
972
973 if ( ntStatus != STATUS_SUCCESS ) {
974 s_bCommandComplete(pDevice);
975 spin_unlock_irq(&pDevice->lock);
976 return;
977 }
978 if ( (byTmp & GPIO3_DATA) == 0 ) {
979 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" WLAN_CMD_RADIO_START_OFF........................\n");
980 // Old commands are useless.
981 // empty command Q
982 pDevice->cbFreeCmdQueue = CMD_Q_SIZE;
983 pDevice->uCmdDequeueIdx = 0;
984 pDevice->uCmdEnqueueIdx = 0;
985 //0415pDevice->bCmdRunning = FALSE;
986 pDevice->bCmdClear = TRUE;
987 pDevice->bStopTx0Pkt = FALSE;
988 pDevice->bStopDataPkt = TRUE;
989
990 pDevice->byKeyIndex = 0;
991 pDevice->bTransmitKey = FALSE;
992 spin_unlock_irq(&pDevice->lock);
993 KeyvInitTable(pDevice,&pDevice->sKey);
994 spin_lock_irq(&pDevice->lock);
995 pMgmt->byCSSPK = KEY_CTL_NONE;
996 pMgmt->byCSSGK = KEY_CTL_NONE;
997
998 if (pDevice->bLinkPass == TRUE) {
999 // reason = 8 : disassoc because sta has left
1000 vMgrDisassocBeginSta((HANDLE)pDevice, pMgmt, pMgmt->abyCurrBSSID, (8), &Status);
1001 pDevice->bLinkPass = FALSE;
1002 // unlock command busy
1003 pMgmt->eCurrState = WMAC_STATE_IDLE;
1004 pMgmt->sNodeDBTable[0].bActive = FALSE;
1005 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1006 // if(pDevice->bWPASuppWextEnabled == TRUE)
1007 {
1008 union iwreq_data wrqu;
1009 memset(&wrqu, 0, sizeof (wrqu));
1010 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1011 PRINT_K("wireless_send_event--->SIOCGIWAP(disassociated)\n");
1012 wireless_send_event(pDevice->dev, SIOCGIWAP, &wrqu, NULL);
1013 }
1014 #endif
1015 }
1016 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1017 pDevice->bwextstep0 = FALSE;
1018 pDevice->bwextstep1 = FALSE;
1019 pDevice->bwextstep2 = FALSE;
1020 pDevice->bwextstep3 = FALSE;
1021 pDevice->bWPASuppWextEnabled = FALSE;
1022 #endif
1023 //clear current SSID
1024 pItemSSID = (PWLAN_IE_SSID)pMgmt->abyCurrSSID;
1025 pItemSSID->len = 0;
1026 memset(pItemSSID->abySSID, 0, WLAN_SSID_MAXLEN);
1027 //clear dessire SSID
1028 pItemSSID = (PWLAN_IE_SSID)pMgmt->abyDesireSSID;
1029 pItemSSID->len = 0;
1030 memset(pItemSSID->abySSID, 0, WLAN_SSID_MAXLEN);
1031
1032 netif_stop_queue(pDevice->dev);
1033 CARDbRadioPowerOff(pDevice);
1034 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
1035 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_OFF);
1036 pDevice->bHWRadioOff = TRUE;
1037 } else {
1038 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" WLAN_CMD_RADIO_START_ON........................\n");
1039 pDevice->bHWRadioOff = FALSE;
1040 CARDbRadioPowerOn(pDevice);
1041 MACvRegBitsOff(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
1042 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_ON);
1043 }
1044 }
1045
1046 s_bCommandComplete(pDevice);
1047 break;
1048
1049
1050 case WLAN_CMD_CHANGE_BBSENSITIVITY_START:
1051
1052 pDevice->bStopDataPkt = TRUE;
1053 pDevice->byBBVGACurrent = pDevice->byBBVGANew;
1054 BBvSetVGAGainOffset(pDevice, pDevice->byBBVGACurrent);
1055 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Change sensitivity pDevice->byBBVGACurrent = %x\n", pDevice->byBBVGACurrent);
1056 pDevice->bStopDataPkt = FALSE;
1057 s_bCommandComplete(pDevice);
1058 break;
1059
1060 case WLAN_CMD_TBTT_WAKEUP_START:
1061 PSbIsNextTBTTWakeUp(pDevice);
1062 s_bCommandComplete(pDevice);
1063 break;
1064
1065 case WLAN_CMD_BECON_SEND_START:
1066 bMgrPrepareBeaconToSend(pDevice, pMgmt);
1067 s_bCommandComplete(pDevice);
1068 break;
1069
1070 case WLAN_CMD_SETPOWER_START:
1071
1072 RFbSetPower(pDevice, pDevice->wCurrentRate, pMgmt->uCurrChannel);
1073
1074 s_bCommandComplete(pDevice);
1075 break;
1076
1077 case WLAN_CMD_CHANGE_ANTENNA_START:
1078 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Change from Antenna%d to", (int)pDevice->dwRxAntennaSel);
1079 if ( pDevice->dwRxAntennaSel == 0) {
1080 pDevice->dwRxAntennaSel=1;
1081 if (pDevice->bTxRxAntInv == TRUE)
1082 BBvSetAntennaMode(pDevice, ANT_RXA);
1083 else
1084 BBvSetAntennaMode(pDevice, ANT_RXB);
1085 } else {
1086 pDevice->dwRxAntennaSel=0;
1087 if (pDevice->bTxRxAntInv == TRUE)
1088 BBvSetAntennaMode(pDevice, ANT_RXB);
1089 else
1090 BBvSetAntennaMode(pDevice, ANT_RXA);
1091 }
1092 s_bCommandComplete(pDevice);
1093 break;
1094
1095 case WLAN_CMD_REMOVE_ALLKEY_START:
1096 KeybRemoveAllKey(pDevice, &(pDevice->sKey), pDevice->abyBSSID);
1097 s_bCommandComplete(pDevice);
1098 break;
1099
1100
1101 case WLAN_CMD_MAC_DISPOWERSAVING_START:
1102 ControlvReadByte (pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_PSCTL, &byData);
1103 if ( (byData & PSCTL_PS) != 0 ) {
1104 // disable power saving hw function
1105 CONTROLnsRequestOut(pDevice,
1106 MESSAGE_TYPE_DISABLE_PS,
1107 0,
1108 0,
1109 0,
1110 NULL
1111 );
1112 }
1113 s_bCommandComplete(pDevice);
1114 break;
1115
1116 case WLAN_CMD_11H_CHSW_START:
1117 CARDbSetMediaChannel(pDevice, pDevice->byNewChannel);
1118 pDevice->bChannelSwitch = FALSE;
1119 pMgmt->uCurrChannel = pDevice->byNewChannel;
1120 pDevice->bStopDataPkt = FALSE;
1121 s_bCommandComplete(pDevice);
1122 break;
1123
1124 default:
1125 s_bCommandComplete(pDevice);
1126 break;
1127 } //switch
1128
1129 spin_unlock_irq(&pDevice->lock);
1130 return;
1131}
1132
1133
1134static
1135BOOL
1136s_bCommandComplete (
1137 PSDevice pDevice
1138 )
1139{
1140 PWLAN_IE_SSID pSSID;
1141 BOOL bRadioCmd = FALSE;
1142 //WORD wDeAuthenReason = 0;
1143 BOOL bForceSCAN = TRUE;
1144 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1145
1146
1147 pDevice->eCommandState = WLAN_CMD_IDLE;
1148 if (pDevice->cbFreeCmdQueue == CMD_Q_SIZE) {
1149 //Command Queue Empty
1150 pDevice->bCmdRunning = FALSE;
1151 return TRUE;
1152 }
1153 else {
1154 pDevice->eCommand = pDevice->eCmdQueue[pDevice->uCmdDequeueIdx].eCmd;
1155 pSSID = (PWLAN_IE_SSID)pDevice->eCmdQueue[pDevice->uCmdDequeueIdx].abyCmdDesireSSID;
1156 bRadioCmd = pDevice->eCmdQueue[pDevice->uCmdDequeueIdx].bRadioCmd;
1157 bForceSCAN = pDevice->eCmdQueue[pDevice->uCmdDequeueIdx].bForceSCAN;
1158 ADD_ONE_WITH_WRAP_AROUND(pDevice->uCmdDequeueIdx, CMD_Q_SIZE);
1159 pDevice->cbFreeCmdQueue++;
1160 pDevice->bCmdRunning = TRUE;
1161 switch ( pDevice->eCommand ) {
1162 case WLAN_CMD_BSSID_SCAN:
1163 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCommandState= WLAN_CMD_BSSID_SCAN\n");
1164 pDevice->eCommandState = WLAN_CMD_SCAN_START;
1165 pMgmt->uScanChannel = 0;
1166 if (pSSID->len != 0) {
1167 MEMvCopy(pMgmt->abyScanSSID, pSSID, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1168 } else {
1169 memset(pMgmt->abyScanSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1170 }
1171/*
1172 if ((bForceSCAN == FALSE) && (pDevice->bLinkPass == TRUE)) {
1173 if ((pSSID->len == ((PWLAN_IE_SSID)pMgmt->abyCurrSSID)->len) &&
1174 (MEMEqualMemory(pSSID->abySSID, ((PWLAN_IE_SSID)pMgmt->abyCurrSSID)->abySSID, pSSID->len))) {
1175 pDevice->eCommandState = WLAN_CMD_IDLE;
1176 }
1177 }
1178*/
1179 break;
1180 case WLAN_CMD_SSID:
1181 pDevice->eCommandState = WLAN_CMD_SSID_START;
1182 if (pSSID->len > WLAN_SSID_MAXLEN)
1183 pSSID->len = WLAN_SSID_MAXLEN;
1184 if (pSSID->len != 0)
1185 MEMvCopy(pMgmt->abyDesireSSID, pSSID, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1186 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCommandState= WLAN_CMD_SSID_START\n");
1187 break;
1188 case WLAN_CMD_DISASSOCIATE:
1189 pDevice->eCommandState = WLAN_CMD_DISASSOCIATE_START;
1190 break;
1191 case WLAN_CMD_RX_PSPOLL:
1192 pDevice->eCommandState = WLAN_CMD_TX_PSPACKET_START;
1193 break;
1194 case WLAN_CMD_RUN_AP:
1195 pDevice->eCommandState = WLAN_CMD_AP_MODE_START;
1196 break;
1197 case WLAN_CMD_RADIO:
1198 pDevice->eCommandState = WLAN_CMD_RADIO_START;
1199 pDevice->bRadioCmd = bRadioCmd;
1200 break;
1201 case WLAN_CMD_CHANGE_BBSENSITIVITY:
1202 pDevice->eCommandState = WLAN_CMD_CHANGE_BBSENSITIVITY_START;
1203 break;
1204
1205 case WLAN_CMD_TBTT_WAKEUP:
1206 pDevice->eCommandState = WLAN_CMD_TBTT_WAKEUP_START;
1207 break;
1208
1209 case WLAN_CMD_BECON_SEND:
1210 pDevice->eCommandState = WLAN_CMD_BECON_SEND_START;
1211 break;
1212
1213 case WLAN_CMD_SETPOWER:
1214 pDevice->eCommandState = WLAN_CMD_SETPOWER_START;
1215 break;
1216
1217 case WLAN_CMD_CHANGE_ANTENNA:
1218 pDevice->eCommandState = WLAN_CMD_CHANGE_ANTENNA_START;
1219 break;
1220
1221 case WLAN_CMD_REMOVE_ALLKEY:
1222 pDevice->eCommandState = WLAN_CMD_REMOVE_ALLKEY_START;
1223 break;
1224
1225 case WLAN_CMD_MAC_DISPOWERSAVING:
1226 pDevice->eCommandState = WLAN_CMD_MAC_DISPOWERSAVING_START;
1227 break;
1228
1229 case WLAN_CMD_11H_CHSW:
1230 pDevice->eCommandState = WLAN_CMD_11H_CHSW_START;
1231 break;
1232
1233 default:
1234 break;
1235
1236 }
1237
1238 vCommandTimerWait((HANDLE)pDevice, 0);
1239 }
1240
1241 return TRUE;
1242}
1243
1244BOOL bScheduleCommand (
1245 IN HANDLE hDeviceContext,
1246 IN CMD_CODE eCommand,
1247 IN PBYTE pbyItem0
1248 )
1249{
1250 PSDevice pDevice = (PSDevice)hDeviceContext;
1251
1252
1253 if (pDevice->cbFreeCmdQueue == 0) {
1254 return (FALSE);
1255 }
1256 pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].eCmd = eCommand;
1257 pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].bForceSCAN = TRUE;
1258 memset(pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].abyCmdDesireSSID, 0 , WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1259 if (pbyItem0 != NULL) {
1260 switch (eCommand) {
1261 case WLAN_CMD_BSSID_SCAN:
1262 pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].bForceSCAN = FALSE;
1263 MEMvCopy(pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].abyCmdDesireSSID,
1264 pbyItem0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1265 break;
1266
1267 case WLAN_CMD_SSID:
1268 MEMvCopy(pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].abyCmdDesireSSID,
1269 pbyItem0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1270 break;
1271
1272 case WLAN_CMD_DISASSOCIATE:
1273 pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].bNeedRadioOFF = *((PBOOL)pbyItem0);
1274 break;
1275/*
1276 case WLAN_CMD_DEAUTH:
1277 pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].wDeAuthenReason = *((PWORD)pbyItem0);
1278 break;
1279*/
1280
1281 case WLAN_CMD_RADIO:
1282 pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].bRadioCmd = *((PBOOL)pbyItem0);
1283 break;
1284
1285 default:
1286 break;
1287 }
1288 }
1289
1290 ADD_ONE_WITH_WRAP_AROUND(pDevice->uCmdEnqueueIdx, CMD_Q_SIZE);
1291 pDevice->cbFreeCmdQueue--;
1292
1293 if (pDevice->bCmdRunning == FALSE) {
1294 s_bCommandComplete(pDevice);
1295 }
1296 else {
1297 }
1298 return (TRUE);
1299
1300}
1301
1302/*
1303 * Description:
1304 * Clear BSSID_SCAN cmd in CMD Queue
1305 *
1306 * Parameters:
1307 * In:
1308 * hDeviceContext - Pointer to the adapter
1309 * eCommand - Command
1310 * Out:
1311 * none
1312 *
1313 * Return Value: TRUE if success; otherwise FALSE
1314 *
1315 */
1316static
1317BOOL s_bClearBSSID_SCAN (
1318 IN HANDLE hDeviceContext
1319 )
1320{
1321 PSDevice pDevice = (PSDevice)hDeviceContext;
1322 UINT uCmdDequeueIdx = pDevice->uCmdDequeueIdx;
1323 UINT ii;
1324
1325 if ((pDevice->cbFreeCmdQueue < CMD_Q_SIZE) && (uCmdDequeueIdx != pDevice->uCmdEnqueueIdx)) {
1326 for (ii = 0; ii < (CMD_Q_SIZE - pDevice->cbFreeCmdQueue); ii ++) {
1327 if (pDevice->eCmdQueue[uCmdDequeueIdx].eCmd == WLAN_CMD_BSSID_SCAN)
1328 pDevice->eCmdQueue[uCmdDequeueIdx].eCmd = WLAN_CMD_IDLE;
1329 ADD_ONE_WITH_WRAP_AROUND(uCmdDequeueIdx, CMD_Q_SIZE);
1330 if (uCmdDequeueIdx == pDevice->uCmdEnqueueIdx)
1331 break;
1332 }
1333 }
1334 return TRUE;
1335}
1336
1337
1338//mike add:reset command timer
1339VOID
1340vResetCommandTimer(
1341 IN HANDLE hDeviceContext
1342 )
1343{
1344 PSDevice pDevice = (PSDevice)hDeviceContext;
1345
1346 //delete timer
1347 del_timer(&pDevice->sTimerCommand);
1348 //init timer
1349 init_timer(&pDevice->sTimerCommand);
1350 pDevice->sTimerCommand.data = (ULONG)pDevice;
1351 pDevice->sTimerCommand.function = (TimerFunction)vRunCommand;
1352 pDevice->sTimerCommand.expires = RUN_AT(HZ);
1353 pDevice->cbFreeCmdQueue = CMD_Q_SIZE;
1354 pDevice->uCmdDequeueIdx = 0;
1355 pDevice->uCmdEnqueueIdx = 0;
1356 pDevice->eCommandState = WLAN_CMD_IDLE;
1357 pDevice->bCmdRunning = FALSE;
1358 pDevice->bCmdClear = FALSE;
1359}
1360
1361//2007-0115-08<Add>by MikeLiu
1362#ifdef TxInSleep
1363VOID
1364BSSvSecondTxData(
1365 IN HANDLE hDeviceContext
1366 )
1367{
1368 PSDevice pDevice = (PSDevice)hDeviceContext;
1369 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1370
1371 pDevice->nTxDataTimeCout++;
1372
1373 if(pDevice->nTxDataTimeCout<4) //don't tx data if timer less than 40s
1374 {
1375 // printk("mike:%s-->no data Tx not exceed the desired Time as %d\n",__FUNCTION__,
1376 // (int)pDevice->nTxDataTimeCout);
1377 pDevice->sTimerTxData.expires = RUN_AT(10*HZ); //10s callback
1378 add_timer(&pDevice->sTimerTxData);
1379 return;
1380 }
1381
1382 spin_lock_irq(&pDevice->lock);
1383 //is wap_supplicant running sucessful OR only open && sharekey mode!
1384 #if 1
1385 if(((pDevice->bLinkPass ==TRUE)&&(pMgmt->eAuthenMode < WMAC_AUTH_WPA)) || //open && sharekey linking
1386 (pDevice->fWPA_Authened == TRUE)) { //wpa linking
1387 #else
1388 if(pDevice->bLinkPass ==TRUE) {
1389 #endif
1390 // printk("mike:%s-->InSleep Tx Data Procedure\n",__FUNCTION__);
1391 pDevice->fTxDataInSleep = TRUE;
1392 PSbSendNullPacket(pDevice); //send null packet
1393 pDevice->fTxDataInSleep = FALSE;
1394 }
1395 spin_unlock_irq(&pDevice->lock);
1396
1397 pDevice->sTimerTxData.expires = RUN_AT(10*HZ); //10s callback
1398 add_timer(&pDevice->sTimerTxData);
1399 return;
1400}
1401#endif
1402