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