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