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