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