?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix Tomato RAF theme for all builds. Compilation typo.
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / drivers / staging / vt6655 / wcmd.c
blob6b3372faa405240f51d005fd70089f387d156ec7
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
60
61
62 /*--------------------- Static Classes ----------------------------*/
63
64 /*--------------------- Static Variables --------------------------*/
65 static int msglevel =MSG_LEVEL_INFO;
66 //static int msglevel =MSG_LEVEL_DEBUG;
67 /*--------------------- Static Functions --------------------------*/
68
69 static
70 void
71 s_vProbeChannel(
72 PSDevice pDevice
73 );
74
75
76 static
77 PSTxMgmtPacket
78 s_MgrMakeProbeRequest(
79 PSDevice pDevice,
80 PSMgmtObject pMgmt,
81 unsigned char *pScanBSSID,
82 PWLAN_IE_SSID pSSID,
83 PWLAN_IE_SUPP_RATES pCurrRates,
84 PWLAN_IE_SUPP_RATES pCurrExtSuppRates
85 );
86
87
88 static
89 bool
90 s_bCommandComplete (
91 PSDevice pDevice
92 );
93
94 /*--------------------- Export Variables --------------------------*/
95
96
97 /*--------------------- Export Functions --------------------------*/
98
99
100
101 /*
102 * Description:
103 * Stop AdHoc beacon during scan process
104 *
105 * Parameters:
106 * In:
107 * pDevice - Pointer to the adapter
108 * Out:
109 * none
110 *
111 * Return Value: none
112 *
113 */
114 static
115 void
116 vAdHocBeaconStop(PSDevice pDevice)
117 {
118
119 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
120 bool bStop;
121
122 /*
123 * temporarily stop Beacon packet for AdHoc Server
124 * if all of the following coditions are met:
125 * (1) STA is in AdHoc mode
126 * (2) VT3253 is programmed as automatic Beacon Transmitting
127 * (3) One of the following conditions is met
128 * (3.1) AdHoc channel is in B/G band and the
129 * current scan channel is in A band
130 * or
131 * (3.2) AdHoc channel is in A mode
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 } /* vAdHocBeaconStop */
154
155
156 /*
157 * Description:
158 * Restart AdHoc beacon after scan process complete
159 *
160 * Parameters:
161 * In:
162 * pDevice - Pointer to the adapter
163 * Out:
164 * none
165 *
166 * Return Value: none
167 *
168 */
169 static
170 void
171 vAdHocBeaconRestart(PSDevice pDevice)
172 {
173 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
174
175 /*
176 * Restart Beacon packet for AdHoc Server
177 * if all of the following coditions are met:
178 * (1) STA is in AdHoc mode
179 * (2) VT3253 is programmed as automatic Beacon Transmitting
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 * Routine Description:
197 * Prepare and send probe request management frames.
198 *
199 *
200 * Return Value:
201 * none.
202 *
203 -*/
204
205 static
206 void
207 s_vProbeChannel(
208 PSDevice pDevice
209 )
210 {
211 //1M, 2M, 5M, 11M, 18M, 24M, 36M, 54M
212 unsigned char abyCurrSuppRatesG[] = {WLAN_EID_SUPP_RATES, 8, 0x02, 0x04, 0x0B, 0x16, 0x24, 0x30, 0x48, 0x6C};
213 unsigned char abyCurrExtSuppRatesG[] = {WLAN_EID_EXTSUPP_RATES, 4, 0x0C, 0x12, 0x18, 0x60};
214 //6M, 9M, 12M, 48M
215 unsigned char abyCurrSuppRatesA[] = {WLAN_EID_SUPP_RATES, 8, 0x0C, 0x12, 0x18, 0x24, 0x30, 0x48, 0x60, 0x6C};
216 unsigned char abyCurrSuppRatesB[] = {WLAN_EID_SUPP_RATES, 4, 0x02, 0x04, 0x0B, 0x16};
217 unsigned char *pbyRate;
218 PSTxMgmtPacket pTxPacket;
219 PSMgmtObject pMgmt = pDevice->pMgmt;
220 unsigned int 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 // build an assocreq frame and send it
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 * Routine Description:
260 * Constructs an probe request frame
261 *
262 *
263 * Return Value:
264 * A ptr to Tx frame or NULL on allocation failue
265 *
266 -*/
267
268
269 PSTxMgmtPacket
270 s_MgrMakeProbeRequest(
271 PSDevice pDevice,
272 PSMgmtObject pMgmt,
273 unsigned char *pScanBSSID,
274 PWLAN_IE_SSID pSSID,
275 PWLAN_IE_SUPP_RATES pCurrRates,
276 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)((unsigned char *)pTxPacket + sizeof(STxMgmtPacket));
287 sFrame.pBuf = (unsigned char *)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 // Copy the SSID, pSSID->len=0 indicate broadcast SSID
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 // Copy the extension rate set
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
321 void
322 vCommandTimerWait(
323 void *hDeviceContext,
324 unsigned int MSecond
325 )
326 {
327 PSDevice pDevice = (PSDevice)hDeviceContext;
328
329 init_timer(&pDevice->sTimerCommand);
330 pDevice->sTimerCommand.data = (unsigned long) pDevice;
331 pDevice->sTimerCommand.function = (TimerFunction)vCommandTimer;
332 // RUN_AT :1 msec ~= (HZ/1024)
333 pDevice->sTimerCommand.expires = (unsigned int)RUN_AT((MSecond * HZ) >> 10);
334 add_timer(&pDevice->sTimerCommand);
335 return;
336 }
337
338
339
340
341 void
342 vCommandTimer (
343 void *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 unsigned int ii;
352 unsigned char 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 // wait all Data TD complete
384 if (pDevice->iTDUsed[TYPE_AC0DMA] != 0){
385 spin_unlock_irq(&pDevice->lock);
386 vCommandTimerWait((void *)pDevice, 10);
387 return;
388 };
389
390 if (pMgmt->uScanChannel == 0 ) {
391 pMgmt->uScanChannel = pDevice->byMinChannel;
392 // Set Baseband to be more sensitive.
393
394 }
395 if (pMgmt->uScanChannel > pDevice->byMaxChannel) {
396 pMgmt->eScanState = WMAC_NO_SCANNING;
397
398 // Set Baseband's sensitivity back.
399 // Set channel back
400 set_channel(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 //2008-8-4 <add> by chester
412 if (!is_channel_valid(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 //printk("chester-pMgmt->uScanChannel=%d,pDevice->byMaxChannel=%d\n",pMgmt->uScanChannel,pDevice->byMaxChannel);
418 if (pMgmt->uScanChannel == pDevice->byMinChannel) {
419 //pMgmt->eScanType = WMAC_SCAN_ACTIVE;
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 // clear bssid list
428 // BSSvClearBSSList((void *)pDevice, pDevice->bLinkPass);
429 pMgmt->eScanState = WMAC_IS_SCANNING;
430
431 }
432
433 vAdHocBeaconStop(pDevice);
434
435 if (set_channel(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 // printk("chester-mxch=%d\n",pDevice->byMaxChannel);
442 // printk("chester-ch=%d\n",pMgmt->uScanChannel);
443 pMgmt->uScanChannel++;
444 //2008-8-4 <modify> by chester
445 if (!is_channel_valid(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((void *)pDevice, WCMD_ACTIVE_SCAN_TIME);
458 return;
459 } else {
460 spin_unlock_irq(&pDevice->lock);
461 vCommandTimerWait((void *)pDevice, WCMD_PASSIVE_SCAN_TIME);
462 return;
463 }
464
465 }
466
467 break;
468
469 case WLAN_CMD_SCAN_END:
470
471 // Set Baseband's sensitivity back.
472 // Set channel back
473 set_channel(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 //2008-0409-07, <Add> by Einsn Liu
484 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
485 if(pMgmt->eScanType == WMAC_SCAN_PASSIVE)
486 {//send scan event to wpa_Supplicant
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 // reason = 8 : disassoc because sta has left
505 vMgrDisassocBeginSta((void *)pDevice, pMgmt, pMgmt->abyCurrBSSID, (8), &Status);
506 pDevice->bLinkPass = false;
507 // unlock command busy
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 // pDevice->bBeaconBufReady = false;
514 }
515 netif_stop_queue(pDevice->dev);
516 pDevice->eCommandState = WLAN_DISASSOCIATE_WAIT;
517 // wait all Control TD complete
518 if (pDevice->iTDUsed[TYPE_TXDMA0] != 0){
519 vCommandTimerWait((void *)pDevice, 10);
520 spin_unlock_irq(&pDevice->lock);
521 return;
522 };
523 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" CARDbRadioPowerOff\n");
524 //2008-09-02 <mark> by chester
525 // CARDbRadioPowerOff(pDevice);
526 s_bCommandComplete(pDevice);
527 break;
528
529 case WLAN_DISASSOCIATE_WAIT :
530 // wait all Control TD complete
531 if (pDevice->iTDUsed[TYPE_TXDMA0] != 0){
532 vCommandTimerWait((void *)pDevice, 10);
533 spin_unlock_irq(&pDevice->lock);
534 return;
535 };
536 //2008-09-02 <mark> by chester
537 // CARDbRadioPowerOff(pDevice);
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 //printk("chester-currmode=%d\n",pMgmt->eCurrMode);
549 printk("chester-abyDesireSSID=%s\n",((PWLAN_IE_SSID)pMgmt->abyDesireSSID)->abySSID);
550 //memcpy(pMgmt->abyAdHocSSID,pMgmt->abyDesireSSID,
551 //((PWLAN_IE_SSID)pMgmt->abyDesireSSID)->len + WLAN_IEHDR_LEN);
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 // set initial state
580 pMgmt->eCurrState = WMAC_STATE_IDLE;
581 pMgmt->eCurrMode = WMAC_MODE_STANDBY;
582 PSvDisablePowerSaving((void *)pDevice);
583 BSSvClearNodeDBTable(pDevice, 0);
584
585 vMgrJoinBSSBegin((void *)pDevice, &Status);
586 // if Infra mode
587 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_STA) && (pMgmt->eCurrState == WMAC_STATE_JOINTED)) {
588
589 // Call mgr to begin the deauthentication
590 // reason = (3) beacuse sta has left ESS
591 if (pMgmt->eCurrState>= WMAC_STATE_AUTH) {
592 vMgrDeAuthenBeginSta((void *)pDevice, pMgmt, pMgmt->abyCurrBSSID, (3), &Status);
593 }
594 // Call mgr to begin the authentication
595 vMgrAuthenBeginSta((void *)pDevice, pMgmt, &Status);
596 if (Status == CMD_STATUS_SUCCESS) {
597 pDevice->byLinkWaitCount = 0;
598 pDevice->eCommandState = WLAN_AUTHENTICATE_WAIT;
599 vCommandTimerWait((void *)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 // if Adhoc mode
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 // start own IBSS
619 vMgrCreateOwnIBSS((void *)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 // if SSID not found
627 else if (pMgmt->eCurrMode == WMAC_MODE_STANDBY) {
628 if (pMgmt->eConfigMode == WMAC_CONFIG_IBSS_STA ||
629 pMgmt->eConfigMode == WMAC_CONFIG_AUTO) {
630 // start own IBSS
631 vMgrCreateOwnIBSS((void *)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 // if(pDevice->bWPASuppWextEnabled == true)
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 // Call mgr to begin the association
663 pDevice->byLinkWaitCount = 0;
664 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCurrState == WMAC_STATE_AUTH\n");
665 vMgrAssocBeginSta((void *)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((void *)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){ //mike add:wait another 2 sec if authenticated_frame delay!
680 pDevice->byLinkWaitCount ++;
681 printk("WLAN_AUTHENTICATE_WAIT:wait %d times!!\n",pDevice->byLinkWaitCount);
682 spin_unlock_irq(&pDevice->lock);
683 vCommandTimerWait((void *)pDevice, AUTHENTICATE_TIMEOUT/2);
684 return;
685 }
686 pDevice->byLinkWaitCount = 0;
687 s_bCommandComplete(pDevice);
688 break;
689
690 case WLAN_ASSOCIATE_WAIT :
691 if (pMgmt->eCurrState == WMAC_STATE_ASSOC) {
692 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCurrState == WMAC_STATE_ASSOC\n");
693 if (pDevice->ePSMode != WMAC_POWER_CAM) {
694 PSvEnablePowerSaving((void *)pDevice, pMgmt->wListenInterval);
695 }
696 if (pMgmt->eAuthenMode >= WMAC_AUTH_WPA) {
697 KeybRemoveAllKey(&(pDevice->sKey), pDevice->abyBSSID, pDevice->PortOffset);
698 }
699 pDevice->bLinkPass = true;
700 pDevice->byLinkWaitCount = 0;
701 pDevice->byReAssocCount = 0;
702 bClearBSSID_SCAN(pDevice);
703 if (pDevice->byFOETuning) {
704 BBvSetFOE(pDevice->PortOffset);
705 PSbSendNullPacket(pDevice);
706 }
707 if (netif_queue_stopped(pDevice->dev)){
708 netif_wake_queue(pDevice->dev);
709 }
710 #ifdef TxInSleep
711 if(pDevice->IsTxDataTrigger != false) { //TxDataTimer is not triggered at the first time
712 // printk("Re-initial TxDataTimer****\n");
713 del_timer(&pDevice->sTimerTxData);
714 init_timer(&pDevice->sTimerTxData);
715 pDevice->sTimerTxData.data = (unsigned long) pDevice;
716 pDevice->sTimerTxData.function = (TimerFunction)BSSvSecondTxData;
717 pDevice->sTimerTxData.expires = RUN_AT(10*HZ); //10s callback
718 pDevice->fTxDataInSleep = false;
719 pDevice->nTxDataTimeCout = 0;
720 }
721 else {
722 // printk("mike:-->First time triger TimerTxData InSleep\n");
723 }
724 pDevice->IsTxDataTrigger = true;
725 add_timer(&pDevice->sTimerTxData);
726 #endif
727 }
728 else if(pMgmt->eCurrState < WMAC_STATE_ASSOCPENDING) {
729 printk("WLAN_ASSOCIATE_WAIT:Association Fail???\n");
730 }
731 else if(pDevice->byLinkWaitCount <= 4){ //mike add:wait another 2 sec if associated_frame delay!
732 pDevice->byLinkWaitCount ++;
733 printk("WLAN_ASSOCIATE_WAIT:wait %d times!!\n",pDevice->byLinkWaitCount);
734 spin_unlock_irq(&pDevice->lock);
735 vCommandTimerWait((void *)pDevice, ASSOCIATE_TIMEOUT/2);
736 return;
737 }
738 pDevice->byLinkWaitCount = 0;
739
740 s_bCommandComplete(pDevice);
741 break;
742
743 case WLAN_CMD_AP_MODE_START :
744 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCommandState == WLAN_CMD_AP_MODE_START\n");
745
746 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
747 del_timer(&pMgmt->sTimerSecondCallback);
748 pMgmt->eCurrState = WMAC_STATE_IDLE;
749 pMgmt->eCurrMode = WMAC_MODE_STANDBY;
750 pDevice->bLinkPass = false;
751 if (pDevice->bEnableHostWEP == true)
752 BSSvClearNodeDBTable(pDevice, 1);
753 else
754 BSSvClearNodeDBTable(pDevice, 0);
755 pDevice->uAssocCount = 0;
756 pMgmt->eCurrState = WMAC_STATE_IDLE;
757 pDevice->bFixRate = false;
758
759 vMgrCreateOwnIBSS((void *)pDevice, &Status);
760 if (Status != CMD_STATUS_SUCCESS){
761 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " vMgrCreateOwnIBSS fail ! \n");
762 };
763 // alway turn off unicast bit
764 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_RCR, RCR_UNICAST);
765 pDevice->byRxMode &= ~RCR_UNICAST;
766 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "wcmd: rx_mode = %x\n", pDevice->byRxMode );
767 BSSvAddMulticastNode(pDevice);
768 if (netif_queue_stopped(pDevice->dev)){
769 netif_wake_queue(pDevice->dev);
770 }
771 pDevice->bLinkPass = true;
772 add_timer(&pMgmt->sTimerSecondCallback);
773 }
774 s_bCommandComplete(pDevice);
775 break;
776
777 case WLAN_CMD_TX_PSPACKET_START :
778 // DTIM Multicast tx
779 if (pMgmt->sNodeDBTable[0].bRxPSPoll) {
780 while ((skb = skb_dequeue(&pMgmt->sNodeDBTable[0].sTxPSQueue)) != NULL) {
781 if (skb_queue_empty(&pMgmt->sNodeDBTable[0].sTxPSQueue)) {
782 pMgmt->abyPSTxMap[0] &= ~byMask[0];
783 pDevice->bMoreData = false;
784 }
785 else {
786 pDevice->bMoreData = true;
787 }
788 if (!device_dma0_xmit(pDevice, skb, 0)) {
789 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Multicast ps tx fail \n");
790 }
791 pMgmt->sNodeDBTable[0].wEnQueueCnt--;
792 }
793 };
794
795 // PS nodes tx
796 for (ii = 1; ii < (MAX_NODE_NUM + 1); ii++) {
797 if (pMgmt->sNodeDBTable[ii].bActive &&
798 pMgmt->sNodeDBTable[ii].bRxPSPoll) {
799 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Index=%d Enqueu Cnt= %d\n",
800 ii, pMgmt->sNodeDBTable[ii].wEnQueueCnt);
801 while ((skb = skb_dequeue(&pMgmt->sNodeDBTable[ii].sTxPSQueue)) != NULL) {
802 if (skb_queue_empty(&pMgmt->sNodeDBTable[ii].sTxPSQueue)) {
803 // clear tx map
804 pMgmt->abyPSTxMap[pMgmt->sNodeDBTable[ii].wAID >> 3] &=
805 ~byMask[pMgmt->sNodeDBTable[ii].wAID & 7];
806 pDevice->bMoreData = false;
807 }
808 else {
809 pDevice->bMoreData = true;
810 }
811 if (!device_dma0_xmit(pDevice, skb, ii)) {
812 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "sta ps tx fail \n");
813 }
814 pMgmt->sNodeDBTable[ii].wEnQueueCnt--;
815 // check if sta ps enable, wait next pspoll
816 // if sta ps disable, send all pending buffers.
817 if (pMgmt->sNodeDBTable[ii].bPSEnable)
818 break;
819 }
820 if (skb_queue_empty(&pMgmt->sNodeDBTable[ii].sTxPSQueue)) {
821 // clear tx map
822 pMgmt->abyPSTxMap[pMgmt->sNodeDBTable[ii].wAID >> 3] &=
823 ~byMask[pMgmt->sNodeDBTable[ii].wAID & 7];
824 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Index=%d PS queue clear \n", ii);
825 }
826 pMgmt->sNodeDBTable[ii].bRxPSPoll = false;
827 }
828 }
829
830 s_bCommandComplete(pDevice);
831 break;
832
833
834 case WLAN_CMD_RADIO_START :
835 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCommandState == WLAN_CMD_RADIO_START\n");
836 if (pDevice->bRadioCmd == true)
837 CARDbRadioPowerOn(pDevice);
838 else
839 CARDbRadioPowerOff(pDevice);
840
841 s_bCommandComplete(pDevice);
842 break;
843
844
845 case WLAN_CMD_CHECK_BBSENSITIVITY_CHANGE :
846 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCommandState == WLAN_CMD_CHECK_BBSENSITIVITY_START\n");
847 // wait all TD complete
848 if (pDevice->iTDUsed[TYPE_AC0DMA] != 0){
849 vCommandTimerWait((void *)pDevice, 10);
850 spin_unlock_irq(&pDevice->lock);
851 return;
852 }
853 if (pDevice->iTDUsed[TYPE_TXDMA0] != 0){
854 vCommandTimerWait((void *)pDevice, 10);
855 spin_unlock_irq(&pDevice->lock);
856 return;
857 }
858 pDevice->byBBVGACurrent = pDevice->byBBVGANew;
859 BBvSetVGAGainOffset(pDevice, pDevice->byBBVGACurrent);
860 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"SetVGAGainOffset %02X\n", pDevice->byBBVGACurrent);
861 s_bCommandComplete(pDevice);
862 break;
863
864 default :
865 s_bCommandComplete(pDevice);
866 break;
867
868 } //switch
869 spin_unlock_irq(&pDevice->lock);
870 return;
871
872 }
873
874
875 static
876 bool
877 s_bCommandComplete (
878 PSDevice pDevice
879 )
880 {
881 PWLAN_IE_SSID pSSID;
882 bool bRadioCmd = false;
883 //unsigned short wDeAuthenReason = 0;
884 bool bForceSCAN = true;
885 PSMgmtObject pMgmt = pDevice->pMgmt;
886
887
888 pDevice->eCommandState = WLAN_CMD_IDLE;
889 if (pDevice->cbFreeCmdQueue == CMD_Q_SIZE) {
890 //Command Queue Empty
891 pDevice->bCmdRunning = false;
892 return true;
893 }
894 else {
895 pDevice->eCommand = pDevice->eCmdQueue[pDevice->uCmdDequeueIdx].eCmd;
896 pSSID = (PWLAN_IE_SSID)pDevice->eCmdQueue[pDevice->uCmdDequeueIdx].abyCmdDesireSSID;
897 bRadioCmd = pDevice->eCmdQueue[pDevice->uCmdDequeueIdx].bRadioCmd;
898 bForceSCAN = pDevice->eCmdQueue[pDevice->uCmdDequeueIdx].bForceSCAN;
899 ADD_ONE_WITH_WRAP_AROUND(pDevice->uCmdDequeueIdx, CMD_Q_SIZE);
900 pDevice->cbFreeCmdQueue++;
901 pDevice->bCmdRunning = true;
902 switch ( pDevice->eCommand ) {
903 case WLAN_CMD_BSSID_SCAN:
904 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCommandState= WLAN_CMD_BSSID_SCAN\n");
905 pDevice->eCommandState = WLAN_CMD_SCAN_START;
906 pMgmt->uScanChannel = 0;
907 if (pSSID->len != 0) {
908 memcpy(pMgmt->abyScanSSID, pSSID, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
909 } else {
910 memset(pMgmt->abyScanSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
911 }
912 /*
913 if ((bForceSCAN == false) && (pDevice->bLinkPass == true)) {
914 if ((pSSID->len == ((PWLAN_IE_SSID)pMgmt->abyCurrSSID)->len) &&
915 ( !memcmp(pSSID->abySSID, ((PWLAN_IE_SSID)pMgmt->abyCurrSSID)->abySSID, pSSID->len))) {
916 pDevice->eCommandState = WLAN_CMD_IDLE;
917 }
918 }
919 */
920 break;
921 case WLAN_CMD_SSID:
922 pDevice->eCommandState = WLAN_CMD_SSID_START;
923 if (pSSID->len > WLAN_SSID_MAXLEN)
924 pSSID->len = WLAN_SSID_MAXLEN;
925 if (pSSID->len != 0)
926 memcpy(pDevice->pMgmt->abyDesireSSID, pSSID, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
927 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"eCommandState= WLAN_CMD_SSID_START\n");
928 break;
929 case WLAN_CMD_DISASSOCIATE:
930 pDevice->eCommandState = WLAN_CMD_DISASSOCIATE_START;
931 break;
932 case WLAN_CMD_RX_PSPOLL:
933 pDevice->eCommandState = WLAN_CMD_TX_PSPACKET_START;
934 break;
935 case WLAN_CMD_RUN_AP:
936 pDevice->eCommandState = WLAN_CMD_AP_MODE_START;
937 break;
938 case WLAN_CMD_RADIO:
939 pDevice->eCommandState = WLAN_CMD_RADIO_START;
940 pDevice->bRadioCmd = bRadioCmd;
941 break;
942 case WLAN_CMD_CHANGE_BBSENSITIVITY:
943 pDevice->eCommandState = WLAN_CMD_CHECK_BBSENSITIVITY_CHANGE;
944 break;
945
946 default:
947 break;
948
949 }
950
951 vCommandTimerWait((void *)pDevice, 0);
952 }
953
954 return true;
955 }
956
957
958
959 bool bScheduleCommand (
960 void *hDeviceContext,
961 CMD_CODE eCommand,
962 unsigned char *pbyItem0
963 )
964 {
965 PSDevice pDevice = (PSDevice)hDeviceContext;
966
967
968 if (pDevice->cbFreeCmdQueue == 0) {
969 return (false);
970 }
971 pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].eCmd = eCommand;
972 pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].bForceSCAN = true;
973 memset(pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].abyCmdDesireSSID, 0 , WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
974
975 if (pbyItem0 != NULL) {
976 switch (eCommand) {
977
978 case WLAN_CMD_BSSID_SCAN:
979 memcpy(pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].abyCmdDesireSSID,
980 pbyItem0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
981 pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].bForceSCAN = false;
982 break;
983
984 case WLAN_CMD_SSID:
985 memcpy(pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].abyCmdDesireSSID,
986 pbyItem0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
987 break;
988
989 case WLAN_CMD_DISASSOCIATE:
990 pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].bNeedRadioOFF = *((int *)pbyItem0);
991 break;
992 /*
993 case WLAN_CMD_DEAUTH:
994 pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].wDeAuthenReason = *((unsigned short *)pbyItem0);
995 break;
996 */
997
998 case WLAN_CMD_RX_PSPOLL:
999 break;
1000
1001 case WLAN_CMD_RADIO:
1002 pDevice->eCmdQueue[pDevice->uCmdEnqueueIdx].bRadioCmd = *((int *)pbyItem0);
1003 break;
1004
1005 case WLAN_CMD_CHANGE_BBSENSITIVITY:
1006 pDevice->eCommandState = WLAN_CMD_CHECK_BBSENSITIVITY_CHANGE;
1007 break;
1008
1009 default:
1010 break;
1011 }
1012 }
1013
1014 ADD_ONE_WITH_WRAP_AROUND(pDevice->uCmdEnqueueIdx, CMD_Q_SIZE);
1015 pDevice->cbFreeCmdQueue--;
1016
1017 if (pDevice->bCmdRunning == false) {
1018 s_bCommandComplete(pDevice);
1019 }
1020 else {
1021 }
1022 return (true);
1023
1024 }
1025
1026 /*
1027 * Description:
1028 * Clear BSSID_SCAN cmd in CMD Queue
1029 *
1030 * Parameters:
1031 * In:
1032 * hDeviceContext - Pointer to the adapter
1033 * eCommand - Command
1034 * Out:
1035 * none
1036 *
1037 * Return Value: true if success; otherwise false
1038 *
1039 */
1040 bool bClearBSSID_SCAN (
1041 void *hDeviceContext
1042 )
1043 {
1044 PSDevice pDevice = (PSDevice)hDeviceContext;
1045 unsigned int uCmdDequeueIdx = pDevice->uCmdDequeueIdx;
1046 unsigned int ii;
1047
1048 if ((pDevice->cbFreeCmdQueue < CMD_Q_SIZE) && (uCmdDequeueIdx != pDevice->uCmdEnqueueIdx)) {
1049 for (ii = 0; ii < (CMD_Q_SIZE - pDevice->cbFreeCmdQueue); ii ++) {
1050 if (pDevice->eCmdQueue[uCmdDequeueIdx].eCmd == WLAN_CMD_BSSID_SCAN)
1051 pDevice->eCmdQueue[uCmdDequeueIdx].eCmd = WLAN_CMD_IDLE;
1052 ADD_ONE_WITH_WRAP_AROUND(uCmdDequeueIdx, CMD_Q_SIZE);
1053 if (uCmdDequeueIdx == pDevice->uCmdEnqueueIdx)
1054 break;
1055 }
1056 }
1057 return true;
1058 }
1059
1060 //mike add:reset command timer
1061 void
1062 vResetCommandTimer(
1063 void *hDeviceContext
1064 )
1065 {
1066 PSDevice pDevice = (PSDevice)hDeviceContext;
1067
1068 //delete timer
1069 del_timer(&pDevice->sTimerCommand);
1070 //init timer
1071 init_timer(&pDevice->sTimerCommand);
1072 pDevice->sTimerCommand.data = (unsigned long) pDevice;
1073 pDevice->sTimerCommand.function = (TimerFunction)vCommandTimer;
1074 pDevice->sTimerCommand.expires = RUN_AT(HZ);
1075 pDevice->cbFreeCmdQueue = CMD_Q_SIZE;
1076 pDevice->uCmdDequeueIdx = 0;
1077 pDevice->uCmdEnqueueIdx = 0;
1078 pDevice->eCommandState = WLAN_CMD_IDLE;
1079 pDevice->bCmdRunning = false;
1080 pDevice->bCmdClear = false;
1081 }
1082
1083
1084 #ifdef TxInSleep
1085 void
1086 BSSvSecondTxData(
1087 void *hDeviceContext
1088 )
1089 {
1090 PSDevice pDevice = (PSDevice)hDeviceContext;
1091 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1092 pDevice->nTxDataTimeCout++;
1093
1094 if(pDevice->nTxDataTimeCout<4) //don't tx data if timer less than 40s
1095 {
1096 // printk("mike:%s-->no data Tx not exceed the desired Time as %d\n",__FUNCTION__,
1097 // (int)pDevice->nTxDataTimeCout);
1098 pDevice->sTimerTxData.expires = RUN_AT(10*HZ); //10s callback
1099 add_timer(&pDevice->sTimerTxData);
1100 return;
1101 }
1102
1103 spin_lock_irq(&pDevice->lock);
1104 if(((pDevice->bLinkPass ==true)&&(pMgmt->eAuthenMode < WMAC_AUTH_WPA)) || //open && sharekey linking
1105 (pDevice->fWPA_Authened == true)) { //wpa linking
1106
1107 // printk("mike:%s-->InSleep Tx Data Procedure\n",__FUNCTION__);
1108 pDevice->fTxDataInSleep = true;
1109 PSbSendNullPacket(pDevice); //send null packet
1110 pDevice->fTxDataInSleep = false;
1111 }
1112 spin_unlock_irq(&pDevice->lock);
1113
1114 pDevice->sTimerTxData.expires = RUN_AT(10*HZ); //10s callback
1115 add_timer(&pDevice->sTimerTxData);
1116 return;
1117 }
1118 #endif
Tomato firmware and modifications.