projects / deliverable / linux.git / blob
? search:


a8e53d94df4a3fd6929be7fbbffda1ccdcf4ec63
[deliverable/linux.git] / drivers / staging / vt6656 / bssdb.c
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: bssdb.c
20 *
21 * Purpose: Handles the Basic Service Set & Node Database functions
22 *
23 * Functions:
24 * BSSpSearchBSSList - Search known BSS list for Desire SSID or BSSID
25 * BSSvClearBSSList - Clear BSS List
26 * BSSbInsertToBSSList - Insert a BSS set into known BSS list
27 * BSSbUpdateToBSSList - Update BSS set in known BSS list
28 * BSSbIsSTAInNodeDB - Search Node DB table to find the index of matched DstAddr
29 * BSSvCreateOneNode - Allocate an Node for Node DB
30 * BSSvUpdateAPNode - Update AP Node content in Index 0 of KnownNodeDB
31 * BSSvSecondCallBack - One second timer callback function to update Node DB info & AP link status
32 * BSSvUpdateNodeTxCounter - Update Tx attemps, Tx failure counter in Node DB for auto-fall back rate control
33 *
34 * Revision History:
35 *
36 * Author: Lyndon Chen
37 *
38 * Date: July 17, 2002
39 *
40 */
41
42 #include "ttype.h"
43 #include "tmacro.h"
44 #include "tether.h"
45 #include "device.h"
46 #include "80211hdr.h"
47 #include "bssdb.h"
48 #include "wmgr.h"
49 #include "datarate.h"
50 #include "desc.h"
51 #include "wcmd.h"
52 #include "wpa.h"
53 #include "baseband.h"
54 #include "rf.h"
55 #include "card.h"
56 #include "mac.h"
57 #include "wpa2.h"
58 #include "tbit.h"
59 #include "control.h"
60 #include "rndis.h"
61 #include "iowpa.h"
62
63 /*--------------------- Static Definitions -------------------------*/
64
65
66
67
68 /*--------------------- Static Classes ----------------------------*/
69
70 /*--------------------- Static Variables --------------------------*/
71 static int msglevel =MSG_LEVEL_INFO;
72 //static int msglevel =MSG_LEVEL_DEBUG;
73
74
75
76 const WORD awHWRetry0[5][5] = {
77 {RATE_18M, RATE_18M, RATE_12M, RATE_12M, RATE_12M},
78 {RATE_24M, RATE_24M, RATE_18M, RATE_12M, RATE_12M},
79 {RATE_36M, RATE_36M, RATE_24M, RATE_18M, RATE_18M},
80 {RATE_48M, RATE_48M, RATE_36M, RATE_24M, RATE_24M},
81 {RATE_54M, RATE_54M, RATE_48M, RATE_36M, RATE_36M}
82 };
83 const WORD awHWRetry1[5][5] = {
84 {RATE_18M, RATE_18M, RATE_12M, RATE_6M, RATE_6M},
85 {RATE_24M, RATE_24M, RATE_18M, RATE_6M, RATE_6M},
86 {RATE_36M, RATE_36M, RATE_24M, RATE_12M, RATE_12M},
87 {RATE_48M, RATE_48M, RATE_24M, RATE_12M, RATE_12M},
88 {RATE_54M, RATE_54M, RATE_36M, RATE_18M, RATE_18M}
89 };
90
91
92
93 /*--------------------- Static Functions --------------------------*/
94
95 VOID s_vCheckSensitivity(
96 IN HANDLE hDeviceContext
97 );
98
99 VOID s_vCheckPreEDThreshold(
100 IN HANDLE hDeviceContext
101 );
102
103 #ifdef Calcu_LinkQual
104 VOID s_uCalculateLinkQual(
105 IN HANDLE hDeviceContext
106 );
107 #endif
108 /*--------------------- Export Variables --------------------------*/
109
110
111 /*--------------------- Export Functions --------------------------*/
112
113
114
115
116
117 /*+
118 *
119 * Routine Description:
120 * Search known BSS list for Desire SSID or BSSID.
121 *
122 * Return Value:
123 * PTR to KnownBSS or NULL
124 *
125 -*/
126
127 PKnownBSS
128 BSSpSearchBSSList(
129 IN HANDLE hDeviceContext,
130 IN PBYTE pbyDesireBSSID,
131 IN PBYTE pbyDesireSSID,
132 IN CARD_PHY_TYPE ePhyType
133 )
134 {
135 PSDevice pDevice = (PSDevice)hDeviceContext;
136 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
137 PBYTE pbyBSSID = NULL;
138 PWLAN_IE_SSID pSSID = NULL;
139 PKnownBSS pCurrBSS = NULL;
140 PKnownBSS pSelect = NULL;
141 BYTE ZeroBSSID[WLAN_BSSID_LEN]={0x00,0x00,0x00,0x00,0x00,0x00};
142 UINT ii = 0;
143 UINT jj = 0; //DavidWang
144 if (pbyDesireBSSID != NULL) {
145 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"BSSpSearchBSSList BSSID[%02X %02X %02X-%02X %02X %02X]\n",
146 *pbyDesireBSSID,*(pbyDesireBSSID+1),*(pbyDesireBSSID+2),
147 *(pbyDesireBSSID+3),*(pbyDesireBSSID+4),*(pbyDesireBSSID+5));
148 if ((!IS_BROADCAST_ADDRESS(pbyDesireBSSID)) &&
149 (memcmp(pbyDesireBSSID, ZeroBSSID, 6)!= 0)){
150 pbyBSSID = pbyDesireBSSID;
151 }
152 }
153 if (pbyDesireSSID != NULL) {
154 if (((PWLAN_IE_SSID)pbyDesireSSID)->len != 0) {
155 pSSID = (PWLAN_IE_SSID) pbyDesireSSID;
156 }
157 }
158
159 if ((pbyBSSID != NULL)&&(pDevice->bRoaming == FALSE)) {
160 // match BSSID first
161 for (ii = 0; ii <MAX_BSS_NUM; ii++) {
162 pCurrBSS = &(pMgmt->sBSSList[ii]);
163
164 //2008-0718-01<Add>by MikeLiu
165 pCurrBSS->bSelected = FALSE;
166
167 if ((pCurrBSS->bActive) &&
168 (pCurrBSS->bSelected == FALSE)) {
169 if (IS_ETH_ADDRESS_EQUAL(pCurrBSS->abyBSSID, pbyBSSID)) {
170 if (pSSID != NULL) {
171 // compare ssid
172 if ( !memcmp(pSSID->abySSID,
173 ((PWLAN_IE_SSID)pCurrBSS->abySSID)->abySSID,
174 pSSID->len)) {
175 if ((pMgmt->eConfigMode == WMAC_CONFIG_AUTO) ||
176 ((pMgmt->eConfigMode == WMAC_CONFIG_IBSS_STA) && WLAN_GET_CAP_INFO_IBSS(pCurrBSS->wCapInfo)) ||
177 ((pMgmt->eConfigMode == WMAC_CONFIG_ESS_STA) && WLAN_GET_CAP_INFO_ESS(pCurrBSS->wCapInfo))
178 ) {
179 pCurrBSS->bSelected = TRUE;
180 return(pCurrBSS);
181 }
182 }
183 } else {
184 if ((pMgmt->eConfigMode == WMAC_CONFIG_AUTO) ||
185 ((pMgmt->eConfigMode == WMAC_CONFIG_IBSS_STA) && WLAN_GET_CAP_INFO_IBSS(pCurrBSS->wCapInfo)) ||
186 ((pMgmt->eConfigMode == WMAC_CONFIG_ESS_STA) && WLAN_GET_CAP_INFO_ESS(pCurrBSS->wCapInfo))
187 ) {
188 pCurrBSS->bSelected = TRUE;
189 return(pCurrBSS);
190 }
191 }
192 }
193 }
194 }
195 } else {
196 // ignore BSSID
197 for (ii = 0; ii <MAX_BSS_NUM; ii++) {
198 pCurrBSS = &(pMgmt->sBSSList[ii]);
199
200 //2007-0721-01<Mark>by MikeLiu
201 // if ((pCurrBSS->bActive) &&
202 // (pCurrBSS->bSelected == FALSE)) {
203
204 //2007-0721-01<Add>by MikeLiu
205 pCurrBSS->bSelected = FALSE;
206 if (pCurrBSS->bActive) {
207
208 if (pSSID != NULL) {
209 // matched SSID
210 if (memcmp(pSSID->abySSID,
211 ((PWLAN_IE_SSID)pCurrBSS->abySSID)->abySSID,
212 pSSID->len) ||
213 (pSSID->len != ((PWLAN_IE_SSID)pCurrBSS->abySSID)->len)) {
214 // SSID not match skip this BSS
215 continue;
216 }
217 }
218 if (((pMgmt->eConfigMode == WMAC_CONFIG_IBSS_STA) && WLAN_GET_CAP_INFO_ESS(pCurrBSS->wCapInfo)) ||
219 ((pMgmt->eConfigMode == WMAC_CONFIG_ESS_STA) && WLAN_GET_CAP_INFO_IBSS(pCurrBSS->wCapInfo))
220 ){
221 // Type not match skip this BSS
222 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"BSS type mismatch.... Config[%d] BSS[0x%04x]\n", pMgmt->eConfigMode, pCurrBSS->wCapInfo);
223 continue;
224 }
225
226 if (ePhyType != PHY_TYPE_AUTO) {
227 if (((ePhyType == PHY_TYPE_11A) && (PHY_TYPE_11A != pCurrBSS->eNetworkTypeInUse)) ||
228 ((ePhyType != PHY_TYPE_11A) && (PHY_TYPE_11A == pCurrBSS->eNetworkTypeInUse))) {
229 // PhyType not match skip this BSS
230 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Physical type mismatch.... ePhyType[%d] BSS[%d]\n", ePhyType, pCurrBSS->eNetworkTypeInUse);
231 continue;
232 }
233 }
234 /*
235 if (pMgmt->eAuthenMode < WMAC_AUTH_WPA) {
236 if (pCurrBSS->bWPAValid == TRUE) {
237 // WPA AP will reject connection of station without WPA enable.
238 continue;
239 }
240 } else if ((pMgmt->eAuthenMode == WMAC_AUTH_WPA) ||
241 (pMgmt->eAuthenMode == WMAC_AUTH_WPAPSK)) {
242 if (pCurrBSS->bWPAValid == FALSE) {
243 // station with WPA enable can't join NonWPA AP.
244 continue;
245 }
246 } else if ((pMgmt->eAuthenMode == WMAC_AUTH_WPA2) ||
247 (pMgmt->eAuthenMode == WMAC_AUTH_WPA2PSK)) {
248 if (pCurrBSS->bWPA2Valid == FALSE) {
249 // station with WPA2 enable can't join NonWPA2 AP.
250 continue;
251 }
252 }
253 */
254 //DavidWang
255 pMgmt->pSameBSS[jj].uChannel = pCurrBSS->uChannel;
256 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"BSSpSearchBSSList pSelect1[%02X %02X %02X-%02X %02X %02X]\n",*pCurrBSS->abyBSSID,*(pCurrBSS->abyBSSID+1),*(pCurrBSS->abyBSSID+2),*(pCurrBSS->abyBSSID+3),*(pCurrBSS->abyBSSID+4),*(pCurrBSS->abyBSSID+5));
257 jj++;
258
259 //DavidWang
260 if (pSelect == NULL) {
261 pSelect = pCurrBSS;
262 } else {
263 // compare RSSI, select signal strong one
264 if (pCurrBSS->uRSSI < pSelect->uRSSI) {
265 pSelect = pCurrBSS;
266 }
267 }
268 }
269 }
270 //DavidWang
271 pDevice->bSameBSSMaxNum = jj;
272 //DavidWang
273 if (pSelect != NULL) {
274 pSelect->bSelected = TRUE;
275 if (pDevice->bRoaming == FALSE) {
276 // Einsn Add @20070907
277 memset(pbyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
278 memcpy(pbyDesireSSID,pCurrBSS->abySSID,WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1) ;
279 }
280
281 return(pSelect);
282 }
283 }
284 return(NULL);
285
286 }
287
288
289 /*+
290 *
291 * Routine Description:
292 * Clear BSS List
293 *
294 * Return Value:
295 * None.
296 *
297 -*/
298
299
300 VOID
301 BSSvClearBSSList(
302 IN HANDLE hDeviceContext,
303 IN BOOL bKeepCurrBSSID
304 )
305 {
306 PSDevice pDevice = (PSDevice)hDeviceContext;
307 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
308 UINT ii;
309
310 for (ii = 0; ii < MAX_BSS_NUM; ii++) {
311 if (bKeepCurrBSSID) {
312 if (pMgmt->sBSSList[ii].bActive &&
313 IS_ETH_ADDRESS_EQUAL(pMgmt->sBSSList[ii].abyBSSID, pMgmt->abyCurrBSSID)) {
314 //mike mark: there are two same BSSID in list if that AP is in hidden ssid mode,one 's SSID is null,
315 // but other's is obvious, so if it acssociate with your STA exactly,you must keep two
316 // of them!!!!!!!!!
317 // bKeepCurrBSSID = FALSE;
318 continue;
319 }
320 }
321 /*
322 if ((pMgmt->sBSSList[ii].bActive) && (pMgmt->sBSSList[ii].uClearCount < BSS_CLEAR_COUNT)) {
323 pMgmt->sBSSList[ii].uClearCount ++;
324 continue;
325 }
326 */
327 pMgmt->sBSSList[ii].bActive = FALSE;
328 memset(&pMgmt->sBSSList[ii], 0, sizeof(KnownBSS));
329 }
330 BSSvClearAnyBSSJoinRecord(pDevice);
331
332 return;
333 }
334
335
336
337 /*+
338 *
339 * Routine Description:
340 * search BSS list by BSSID & SSID if matched
341 *
342 * Return Value:
343 * TRUE if found.
344 *
345 -*/
346 PKnownBSS
347 BSSpAddrIsInBSSList(
348 IN HANDLE hDeviceContext,
349 IN PBYTE abyBSSID,
350 IN PWLAN_IE_SSID pSSID
351 )
352 {
353 PSDevice pDevice = (PSDevice)hDeviceContext;
354 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
355 PKnownBSS pBSSList = NULL;
356 UINT ii;
357
358 for (ii = 0; ii < MAX_BSS_NUM; ii++) {
359 pBSSList = &(pMgmt->sBSSList[ii]);
360 if (pBSSList->bActive) {
361 if (IS_ETH_ADDRESS_EQUAL(pBSSList->abyBSSID, abyBSSID)) {
362 if (pSSID->len == ((PWLAN_IE_SSID)pBSSList->abySSID)->len){
363 if (memcmp(pSSID->abySSID,
364 ((PWLAN_IE_SSID)pBSSList->abySSID)->abySSID,
365 pSSID->len) == 0)
366 return pBSSList;
367 }
368 }
369 }
370 }
371
372 return NULL;
373 };
374
375
376
377 /*+
378 *
379 * Routine Description:
380 * Insert a BSS set into known BSS list
381 *
382 * Return Value:
383 * TRUE if success.
384 *
385 -*/
386
387 BOOL
388 BSSbInsertToBSSList (
389 IN HANDLE hDeviceContext,
390 IN PBYTE abyBSSIDAddr,
391 IN QWORD qwTimestamp,
392 IN WORD wBeaconInterval,
393 IN WORD wCapInfo,
394 IN BYTE byCurrChannel,
395 IN PWLAN_IE_SSID pSSID,
396 IN PWLAN_IE_SUPP_RATES pSuppRates,
397 IN PWLAN_IE_SUPP_RATES pExtSuppRates,
398 IN PERPObject psERP,
399 IN PWLAN_IE_RSN pRSN,
400 IN PWLAN_IE_RSN_EXT pRSNWPA,
401 IN PWLAN_IE_COUNTRY pIE_Country,
402 IN PWLAN_IE_QUIET pIE_Quiet,
403 IN UINT uIELength,
404 IN PBYTE pbyIEs,
405 IN HANDLE pRxPacketContext
406 )
407 {
408
409 PSDevice pDevice = (PSDevice)hDeviceContext;
410 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
411 PSRxMgmtPacket pRxPacket = (PSRxMgmtPacket)pRxPacketContext;
412 PKnownBSS pBSSList = NULL;
413 UINT ii;
414 BOOL bParsingQuiet = FALSE;
415
416
417
418 pBSSList = (PKnownBSS)&(pMgmt->sBSSList[0]);
419
420 for (ii = 0; ii < MAX_BSS_NUM; ii++) {
421 pBSSList = (PKnownBSS)&(pMgmt->sBSSList[ii]);
422 if (!pBSSList->bActive)
423 break;
424 }
425
426 if (ii == MAX_BSS_NUM){
427 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Get free KnowBSS node failed.\n");
428 return FALSE;
429 }
430 // save the BSS info
431 pBSSList->bActive = TRUE;
432 memcpy( pBSSList->abyBSSID, abyBSSIDAddr, WLAN_BSSID_LEN);
433 HIDWORD(pBSSList->qwBSSTimestamp) = cpu_to_le32(HIDWORD(qwTimestamp));
434 LODWORD(pBSSList->qwBSSTimestamp) = cpu_to_le32(LODWORD(qwTimestamp));
435 pBSSList->wBeaconInterval = cpu_to_le16(wBeaconInterval);
436 pBSSList->wCapInfo = cpu_to_le16(wCapInfo);
437 pBSSList->uClearCount = 0;
438
439 if (pSSID->len > WLAN_SSID_MAXLEN)
440 pSSID->len = WLAN_SSID_MAXLEN;
441 memcpy( pBSSList->abySSID, pSSID, pSSID->len + WLAN_IEHDR_LEN);
442
443 pBSSList->uChannel = byCurrChannel;
444
445 if (pSuppRates->len > WLAN_RATES_MAXLEN)
446 pSuppRates->len = WLAN_RATES_MAXLEN;
447 memcpy( pBSSList->abySuppRates, pSuppRates, pSuppRates->len + WLAN_IEHDR_LEN);
448
449 if (pExtSuppRates != NULL) {
450 if (pExtSuppRates->len > WLAN_RATES_MAXLEN)
451 pExtSuppRates->len = WLAN_RATES_MAXLEN;
452 memcpy(pBSSList->abyExtSuppRates, pExtSuppRates, pExtSuppRates->len + WLAN_IEHDR_LEN);
453 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"BSSbInsertToBSSList: pExtSuppRates->len = %d\n", pExtSuppRates->len);
454
455 } else {
456 memset(pBSSList->abyExtSuppRates, 0, WLAN_IEHDR_LEN + WLAN_RATES_MAXLEN + 1);
457 }
458 pBSSList->sERP.byERP = psERP->byERP;
459 pBSSList->sERP.bERPExist = psERP->bERPExist;
460
461 // Check if BSS is 802.11a/b/g
462 if (pBSSList->uChannel > CB_MAX_CHANNEL_24G) {
463 pBSSList->eNetworkTypeInUse = PHY_TYPE_11A;
464 } else {
465 if (pBSSList->sERP.bERPExist == TRUE) {
466 pBSSList->eNetworkTypeInUse = PHY_TYPE_11G;
467 } else {
468 pBSSList->eNetworkTypeInUse = PHY_TYPE_11B;
469 }
470 }
471
472 pBSSList->byRxRate = pRxPacket->byRxRate;
473 pBSSList->qwLocalTSF = pRxPacket->qwLocalTSF;
474 pBSSList->uRSSI = pRxPacket->uRSSI;
475 pBSSList->bySQ = pRxPacket->bySQ;
476
477 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_STA) &&
478 (pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
479 // assoc with BSS
480 if (pBSSList == pMgmt->pCurrBSS) {
481 bParsingQuiet = TRUE;
482 }
483 }
484
485 WPA_ClearRSN(pBSSList);
486
487 if (pRSNWPA != NULL) {
488 UINT uLen = pRSNWPA->len + 2;
489
490 if (uLen <= (uIELength - (UINT)(ULONG_PTR)((PBYTE)pRSNWPA - pbyIEs))) {
491 pBSSList->wWPALen = uLen;
492 memcpy(pBSSList->byWPAIE, pRSNWPA, uLen);
493 WPA_ParseRSN(pBSSList, pRSNWPA);
494 }
495 }
496
497 WPA2_ClearRSN(pBSSList);
498
499 if (pRSN != NULL) {
500 UINT uLen = pRSN->len + 2;
501 if (uLen <= (uIELength - (UINT)(ULONG_PTR)((PBYTE)pRSN - pbyIEs))) {
502 pBSSList->wRSNLen = uLen;
503 memcpy(pBSSList->byRSNIE, pRSN, uLen);
504 WPA2vParseRSN(pBSSList, pRSN);
505 }
506 }
507
508 if ((pMgmt->eAuthenMode == WMAC_AUTH_WPA2) || (pBSSList->bWPA2Valid == TRUE)) {
509
510 PSKeyItem pTransmitKey = NULL;
511 BOOL bIs802_1x = FALSE;
512
513 for (ii = 0; ii < pBSSList->wAKMSSAuthCount; ii ++) {
514 if (pBSSList->abyAKMSSAuthType[ii] == WLAN_11i_AKMSS_802_1X) {
515 bIs802_1x = TRUE;
516 break;
517 }
518 }
519 if ((bIs802_1x == TRUE) && (pSSID->len == ((PWLAN_IE_SSID)pMgmt->abyDesireSSID)->len) &&
520 ( !memcmp(pSSID->abySSID, ((PWLAN_IE_SSID)pMgmt->abyDesireSSID)->abySSID, pSSID->len))) {
521
522 bAdd_PMKID_Candidate((HANDLE)pDevice, pBSSList->abyBSSID, &pBSSList->sRSNCapObj);
523
524 if ((pDevice->bLinkPass == TRUE) && (pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
525 if ((KeybGetTransmitKey(&(pDevice->sKey), pDevice->abyBSSID, PAIRWISE_KEY, &pTransmitKey) == TRUE) ||
526 (KeybGetTransmitKey(&(pDevice->sKey), pDevice->abyBSSID, GROUP_KEY, &pTransmitKey) == TRUE)) {
527 pDevice->gsPMKIDCandidate.StatusType = Ndis802_11StatusType_PMKID_CandidateList;
528 pDevice->gsPMKIDCandidate.Version = 1;
529
530 }
531
532 }
533 }
534 }
535
536 if (pDevice->bUpdateBBVGA) {
537 // Moniter if RSSI is too strong.
538 pBSSList->byRSSIStatCnt = 0;
539 RFvRSSITodBm(pDevice, (BYTE)(pRxPacket->uRSSI), &pBSSList->ldBmMAX);
540 pBSSList->ldBmAverage[0] = pBSSList->ldBmMAX;
541 pBSSList->ldBmAverRange = pBSSList->ldBmMAX;
542 for (ii = 1; ii < RSSI_STAT_COUNT; ii++)
543 pBSSList->ldBmAverage[ii] = 0;
544 }
545
546 /*
547 if ((pIE_Country != NULL) &&
548 (pMgmt->b11hEnable == TRUE)) {
549 CARDvSetCountryInfo(pMgmt->pAdapter,
550 pBSSList->eNetworkTypeInUse,
551 pIE_Country);
552 }
553
554 if ((bParsingQuiet == TRUE) && (pIE_Quiet != NULL)) {
555 if ((((PWLAN_IE_QUIET)pIE_Quiet)->len == 8) &&
556 (((PWLAN_IE_QUIET)pIE_Quiet)->byQuietCount != 0)) {
557 // valid EID
558 if (pQuiet == NULL) {
559 pQuiet = (PWLAN_IE_QUIET)pIE_Quiet;
560 CARDbSetQuiet( pMgmt->pAdapter,
561 TRUE,
562 pQuiet->byQuietCount,
563 pQuiet->byQuietPeriod,
564 *((PWORD)pQuiet->abyQuietDuration),
565 *((PWORD)pQuiet->abyQuietOffset)
566 );
567 } else {
568 pQuiet = (PWLAN_IE_QUIET)pIE_Quiet;
569 CARDbSetQuiet( pMgmt->pAdapter,
570 FALSE,
571 pQuiet->byQuietCount,
572 pQuiet->byQuietPeriod,
573 *((PWORD)pQuiet->abyQuietDuration),
574 *((PWORD)pQuiet->abyQuietOffset)
575 );
576 }
577 }
578 }
579
580 if ((bParsingQuiet == TRUE) &&
581 (pQuiet != NULL)) {
582 CARDbStartQuiet(pMgmt->pAdapter);
583 }
584 */
585
586 pBSSList->uIELength = uIELength;
587 if (pBSSList->uIELength > WLAN_BEACON_FR_MAXLEN)
588 pBSSList->uIELength = WLAN_BEACON_FR_MAXLEN;
589 memcpy(pBSSList->abyIEs, pbyIEs, pBSSList->uIELength);
590
591 return TRUE;
592 }
593
594
595 /*+
596 *
597 * Routine Description:
598 * Update BSS set in known BSS list
599 *
600 * Return Value:
601 * TRUE if success.
602 *
603 -*/
604 // TODO: input structure modify
605
606 BOOL
607 BSSbUpdateToBSSList (
608 IN HANDLE hDeviceContext,
609 IN QWORD qwTimestamp,
610 IN WORD wBeaconInterval,
611 IN WORD wCapInfo,
612 IN BYTE byCurrChannel,
613 IN BOOL bChannelHit,
614 IN PWLAN_IE_SSID pSSID,
615 IN PWLAN_IE_SUPP_RATES pSuppRates,
616 IN PWLAN_IE_SUPP_RATES pExtSuppRates,
617 IN PERPObject psERP,
618 IN PWLAN_IE_RSN pRSN,
619 IN PWLAN_IE_RSN_EXT pRSNWPA,
620 IN PWLAN_IE_COUNTRY pIE_Country,
621 IN PWLAN_IE_QUIET pIE_Quiet,
622 IN PKnownBSS pBSSList,
623 IN UINT uIELength,
624 IN PBYTE pbyIEs,
625 IN HANDLE pRxPacketContext
626 )
627 {
628 int ii, jj;
629 PSDevice pDevice = (PSDevice)hDeviceContext;
630 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
631 PSRxMgmtPacket pRxPacket = (PSRxMgmtPacket)pRxPacketContext;
632 LONG ldBm, ldBmSum;
633 BOOL bParsingQuiet = FALSE;
634 // BYTE abyTmpSSID[WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1];
635
636
637 if (pBSSList == NULL)
638 return FALSE;
639
640
641 HIDWORD(pBSSList->qwBSSTimestamp) = cpu_to_le32(HIDWORD(qwTimestamp));
642 LODWORD(pBSSList->qwBSSTimestamp) = cpu_to_le32(LODWORD(qwTimestamp));
643 pBSSList->wBeaconInterval = cpu_to_le16(wBeaconInterval);
644 pBSSList->wCapInfo = cpu_to_le16(wCapInfo);
645 pBSSList->uClearCount = 0;
646 pBSSList->uChannel = byCurrChannel;
647 // DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"BSSbUpdateToBSSList: pBSSList->uChannel: %d\n", pBSSList->uChannel);
648
649 if (pSSID->len > WLAN_SSID_MAXLEN)
650 pSSID->len = WLAN_SSID_MAXLEN;
651
652 if ((pSSID->len != 0) && (pSSID->abySSID[0] != 0))
653 memcpy(pBSSList->abySSID, pSSID, pSSID->len + WLAN_IEHDR_LEN);
654 memcpy(pBSSList->abySuppRates, pSuppRates,pSuppRates->len + WLAN_IEHDR_LEN);
655
656 if (pExtSuppRates != NULL) {
657 memcpy(pBSSList->abyExtSuppRates, pExtSuppRates,pExtSuppRates->len + WLAN_IEHDR_LEN);
658 } else {
659 memset(pBSSList->abyExtSuppRates, 0, WLAN_IEHDR_LEN + WLAN_RATES_MAXLEN + 1);
660 }
661 pBSSList->sERP.byERP = psERP->byERP;
662 pBSSList->sERP.bERPExist = psERP->bERPExist;
663
664 // Check if BSS is 802.11a/b/g
665 if (pBSSList->uChannel > CB_MAX_CHANNEL_24G) {
666 pBSSList->eNetworkTypeInUse = PHY_TYPE_11A;
667 } else {
668 if (pBSSList->sERP.bERPExist == TRUE) {
669 pBSSList->eNetworkTypeInUse = PHY_TYPE_11G;
670 } else {
671 pBSSList->eNetworkTypeInUse = PHY_TYPE_11B;
672 }
673 }
674
675 pBSSList->byRxRate = pRxPacket->byRxRate;
676 pBSSList->qwLocalTSF = pRxPacket->qwLocalTSF;
677 if(bChannelHit)
678 pBSSList->uRSSI = pRxPacket->uRSSI;
679 pBSSList->bySQ = pRxPacket->bySQ;
680
681 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_STA) &&
682 (pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
683 // assoc with BSS
684 if (pBSSList == pMgmt->pCurrBSS) {
685 bParsingQuiet = TRUE;
686 }
687 }
688
689 WPA_ClearRSN(pBSSList); //mike update
690
691 if (pRSNWPA != NULL) {
692 UINT uLen = pRSNWPA->len + 2;
693 if (uLen <= (uIELength - (UINT)(ULONG_PTR)((PBYTE)pRSNWPA - pbyIEs))) {
694 pBSSList->wWPALen = uLen;
695 memcpy(pBSSList->byWPAIE, pRSNWPA, uLen);
696 WPA_ParseRSN(pBSSList, pRSNWPA);
697 }
698 }
699
700 WPA2_ClearRSN(pBSSList); //mike update
701
702 if (pRSN != NULL) {
703 UINT uLen = pRSN->len + 2;
704 if (uLen <= (uIELength - (UINT)(ULONG_PTR)((PBYTE)pRSN - pbyIEs))) {
705 pBSSList->wRSNLen = uLen;
706 memcpy(pBSSList->byRSNIE, pRSN, uLen);
707 WPA2vParseRSN(pBSSList, pRSN);
708 }
709 }
710
711 if (pRxPacket->uRSSI != 0) {
712 RFvRSSITodBm(pDevice, (BYTE)(pRxPacket->uRSSI), &ldBm);
713 // Moniter if RSSI is too strong.
714 pBSSList->byRSSIStatCnt++;
715 pBSSList->byRSSIStatCnt %= RSSI_STAT_COUNT;
716 pBSSList->ldBmAverage[pBSSList->byRSSIStatCnt] = ldBm;
717 ldBmSum = 0;
718 for(ii=0, jj=0;ii<RSSI_STAT_COUNT;ii++) {
719 if (pBSSList->ldBmAverage[ii] != 0) {
720 pBSSList->ldBmMAX = max(pBSSList->ldBmAverage[ii], ldBm);
721 ldBmSum += pBSSList->ldBmAverage[ii];
722 jj++;
723 }
724 }
725 pBSSList->ldBmAverRange = ldBmSum /jj;
726 }
727
728 pBSSList->uIELength = uIELength;
729 if (pBSSList->uIELength > WLAN_BEACON_FR_MAXLEN)
730 pBSSList->uIELength = WLAN_BEACON_FR_MAXLEN;
731 memcpy(pBSSList->abyIEs, pbyIEs, pBSSList->uIELength);
732
733 //mike add: if the AP in this pBSSList is hidden ssid and we can find two of them,
734 // you need upgrade the other related pBSSList of which ssid is obvious,
735 // for these two AP is the same one!!!!
736 /********judge by:BSSID is the same,but ssid is different!*****************/
737 #if 0
738 for (ii = 0; ii < MAX_BSS_NUM; ii++) {
739 if (IS_ETH_ADDRESS_EQUAL(pMgmt->sBSSList[ii].abyBSSID, pBSSList->abyBSSID)) { //BSSID is the same!
740 if (memcmp(((PWLAN_IE_SSID)pMgmt->sBSSList[ii].abySSID)->abySSID, //ssid is different??
741 ((PWLAN_IE_SSID)pBSSList->abySSID)->abySSID,
742 ((PWLAN_IE_SSID)pBSSList->abySSID)->len) != 0) {
743 //reserve temp
744 memset(abyTmpSSID,0,sizeof(abyTmpSSID));
745 memcpy(abyTmpSSID,pMgmt->sBSSList[ii].abySSID,sizeof(abyTmpSSID));
746 //upgrade the other one pBSSList
747 memcpy(&(pMgmt->sBSSList[ii]),pBSSList,sizeof(KnownBSS));
748 //recover ssid info
749 memcpy(pMgmt->sBSSList[ii].abySSID,abyTmpSSID,sizeof(abyTmpSSID));
750 }
751 }
752 }
753 #endif
754
755 return TRUE;
756 }
757
758
759
760
761
762 /*+
763 *
764 * Routine Description:
765 * Search Node DB table to find the index of matched DstAddr
766 *
767 * Return Value:
768 * None
769 *
770 -*/
771
772 BOOL
773 BSSbIsSTAInNodeDB(
774 IN HANDLE hDeviceContext,
775 IN PBYTE abyDstAddr,
776 OUT PUINT puNodeIndex
777 )
778 {
779 PSDevice pDevice = (PSDevice)hDeviceContext;
780 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
781 UINT ii;
782
783 // Index = 0 reserved for AP Node
784 for (ii = 1; ii < (MAX_NODE_NUM + 1); ii++) {
785 if (pMgmt->sNodeDBTable[ii].bActive) {
786 if (IS_ETH_ADDRESS_EQUAL(abyDstAddr, pMgmt->sNodeDBTable[ii].abyMACAddr)) {
787 *puNodeIndex = ii;
788 return TRUE;
789 }
790 }
791 }
792
793 return FALSE;
794 };
795
796
797
798 /*+
799 *
800 * Routine Description:
801 * Find an empty node and allocated; if no empty found,
802 * instand used of most inactive one.
803 *
804 * Return Value:
805 * None
806 *
807 -*/
808 VOID
809 BSSvCreateOneNode(
810 IN HANDLE hDeviceContext,
811 OUT PUINT puNodeIndex
812 )
813 {
814
815 PSDevice pDevice = (PSDevice)hDeviceContext;
816 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
817 UINT ii;
818 UINT BigestCount = 0;
819 UINT SelectIndex;
820 struct sk_buff *skb;
821 // Index = 0 reserved for AP Node (In STA mode)
822 // Index = 0 reserved for Broadcast/MultiCast (In AP mode)
823 SelectIndex = 1;
824 for (ii = 1; ii < (MAX_NODE_NUM + 1); ii++) {
825 if (pMgmt->sNodeDBTable[ii].bActive) {
826 if (pMgmt->sNodeDBTable[ii].uInActiveCount > BigestCount) {
827 BigestCount = pMgmt->sNodeDBTable[ii].uInActiveCount;
828 SelectIndex = ii;
829 }
830 }
831 else {
832 break;
833 }
834 }
835
836 // if not found replace uInActiveCount is largest one.
837 if ( ii == (MAX_NODE_NUM + 1)) {
838 *puNodeIndex = SelectIndex;
839 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Replace inactive node = %d\n", SelectIndex);
840 // clear ps buffer
841 if (pMgmt->sNodeDBTable[*puNodeIndex].sTxPSQueue.next != NULL) {
842 while ((skb = skb_dequeue(&pMgmt->sNodeDBTable[*puNodeIndex].sTxPSQueue)) != NULL)
843 dev_kfree_skb(skb);
844 }
845 }
846 else {
847 *puNodeIndex = ii;
848 }
849
850 memset(&pMgmt->sNodeDBTable[*puNodeIndex], 0, sizeof(KnownNodeDB));
851 pMgmt->sNodeDBTable[*puNodeIndex].bActive = TRUE;
852 pMgmt->sNodeDBTable[*puNodeIndex].uRatePollTimeout = FALLBACK_POLL_SECOND;
853 // for AP mode PS queue
854 skb_queue_head_init(&pMgmt->sNodeDBTable[*puNodeIndex].sTxPSQueue);
855 pMgmt->sNodeDBTable[*puNodeIndex].byAuthSequence = 0;
856 pMgmt->sNodeDBTable[*puNodeIndex].wEnQueueCnt = 0;
857 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Create node index = %d\n", ii);
858 return;
859 };
860
861
862
863 /*+
864 *
865 * Routine Description:
866 * Remove Node by NodeIndex
867 *
868 *
869 * Return Value:
870 * None
871 *
872 -*/
873 VOID
874 BSSvRemoveOneNode(
875 IN HANDLE hDeviceContext,
876 IN UINT uNodeIndex
877 )
878 {
879
880 PSDevice pDevice = (PSDevice)hDeviceContext;
881 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
882 BYTE byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
883 struct sk_buff *skb;
884
885
886 while ((skb = skb_dequeue(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue)) != NULL)
887 dev_kfree_skb(skb);
888 // clear context
889 memset(&pMgmt->sNodeDBTable[uNodeIndex], 0, sizeof(KnownNodeDB));
890 // clear tx bit map
891 pMgmt->abyPSTxMap[pMgmt->sNodeDBTable[uNodeIndex].wAID >> 3] &= ~byMask[pMgmt->sNodeDBTable[uNodeIndex].wAID & 7];
892
893 return;
894 };
895 /*+
896 *
897 * Routine Description:
898 * Update AP Node content in Index 0 of KnownNodeDB
899 *
900 *
901 * Return Value:
902 * None
903 *
904 -*/
905
906 VOID
907 BSSvUpdateAPNode(
908 IN HANDLE hDeviceContext,
909 IN PWORD pwCapInfo,
910 IN PWLAN_IE_SUPP_RATES pSuppRates,
911 IN PWLAN_IE_SUPP_RATES pExtSuppRates
912 )
913 {
914 PSDevice pDevice = (PSDevice)hDeviceContext;
915 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
916 UINT uRateLen = WLAN_RATES_MAXLEN;
917
918 memset(&pMgmt->sNodeDBTable[0], 0, sizeof(KnownNodeDB));
919
920 pMgmt->sNodeDBTable[0].bActive = TRUE;
921 if (pDevice->byBBType == BB_TYPE_11B) {
922 uRateLen = WLAN_RATES_MAXLEN_11B;
923 }
924 pMgmt->abyCurrSuppRates[1] = RATEuSetIE((PWLAN_IE_SUPP_RATES)pSuppRates,
925 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
926 uRateLen);
927 pMgmt->abyCurrExtSuppRates[1] = RATEuSetIE((PWLAN_IE_SUPP_RATES)pExtSuppRates,
928 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates,
929 uRateLen);
930 RATEvParseMaxRate((PVOID) pDevice,
931 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
932 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates,
933 TRUE,
934 &(pMgmt->sNodeDBTable[0].wMaxBasicRate),
935 &(pMgmt->sNodeDBTable[0].wMaxSuppRate),
936 &(pMgmt->sNodeDBTable[0].wSuppRate),
937 &(pMgmt->sNodeDBTable[0].byTopCCKBasicRate),
938 &(pMgmt->sNodeDBTable[0].byTopOFDMBasicRate)
939 );
940 memcpy(pMgmt->sNodeDBTable[0].abyMACAddr, pMgmt->abyCurrBSSID, WLAN_ADDR_LEN);
941 pMgmt->sNodeDBTable[0].wTxDataRate = pMgmt->sNodeDBTable[0].wMaxSuppRate;
942 pMgmt->sNodeDBTable[0].bShortPreamble = WLAN_GET_CAP_INFO_SHORTPREAMBLE(*pwCapInfo);
943 pMgmt->sNodeDBTable[0].uRatePollTimeout = FALLBACK_POLL_SECOND;
944 // Auto rate fallback function initiation.
945 // RATEbInit(pDevice);
946 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pMgmt->sNodeDBTable[0].wTxDataRate = %d \n", pMgmt->sNodeDBTable[0].wTxDataRate);
947
948 };
949
950
951
952
953
954 /*+
955 *
956 * Routine Description:
957 * Add Multicast Node content in Index 0 of KnownNodeDB
958 *
959 *
960 * Return Value:
961 * None
962 *
963 -*/
964
965
966 VOID
967 BSSvAddMulticastNode(
968 IN HANDLE hDeviceContext
969 )
970 {
971 PSDevice pDevice = (PSDevice)hDeviceContext;
972 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
973
974 if (!pDevice->bEnableHostWEP)
975 memset(&pMgmt->sNodeDBTable[0], 0, sizeof(KnownNodeDB));
976 memset(pMgmt->sNodeDBTable[0].abyMACAddr, 0xff, WLAN_ADDR_LEN);
977 pMgmt->sNodeDBTable[0].bActive = TRUE;
978 pMgmt->sNodeDBTable[0].bPSEnable = FALSE;
979 skb_queue_head_init(&pMgmt->sNodeDBTable[0].sTxPSQueue);
980 RATEvParseMaxRate((PVOID) pDevice,
981 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
982 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates,
983 TRUE,
984 &(pMgmt->sNodeDBTable[0].wMaxBasicRate),
985 &(pMgmt->sNodeDBTable[0].wMaxSuppRate),
986 &(pMgmt->sNodeDBTable[0].wSuppRate),
987 &(pMgmt->sNodeDBTable[0].byTopCCKBasicRate),
988 &(pMgmt->sNodeDBTable[0].byTopOFDMBasicRate)
989 );
990 pMgmt->sNodeDBTable[0].wTxDataRate = pMgmt->sNodeDBTable[0].wMaxBasicRate;
991 pMgmt->sNodeDBTable[0].uRatePollTimeout = FALLBACK_POLL_SECOND;
992
993 };
994
995
996
997
998
999 /*+
1000 *
1001 * Routine Description:
1002 *
1003 *
1004 * Second call back function to update Node DB info & AP link status
1005 *
1006 *
1007 * Return Value:
1008 * none.
1009 *
1010 -*/
1011
1012
1013 VOID
1014 BSSvSecondCallBack(
1015 IN HANDLE hDeviceContext
1016 )
1017 {
1018 PSDevice pDevice = (PSDevice)hDeviceContext;
1019 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1020 UINT ii;
1021 PWLAN_IE_SSID pItemSSID, pCurrSSID;
1022 UINT uSleepySTACnt = 0;
1023 UINT uNonShortSlotSTACnt = 0;
1024 UINT uLongPreambleSTACnt = 0;
1025 viawget_wpa_header *wpahdr; //DavidWang
1026
1027 spin_lock_irq(&pDevice->lock);
1028
1029 pDevice->uAssocCount = 0;
1030
1031 //Power Saving Mode Tx Burst
1032 if ( pDevice->bEnablePSMode == TRUE ) {
1033 pDevice->ulPSModeWaitTx++;
1034 if ( pDevice->ulPSModeWaitTx >= 2 ) {
1035 pDevice->ulPSModeWaitTx = 0;
1036 pDevice->bPSModeTxBurst = FALSE;
1037 }
1038 }
1039
1040 pDevice->byERPFlag &=
1041 ~(WLAN_SET_ERP_BARKER_MODE(1) | WLAN_SET_ERP_NONERP_PRESENT(1));
1042
1043 if (pDevice->wUseProtectCntDown > 0) {
1044 pDevice->wUseProtectCntDown --;
1045 }
1046 else {
1047 // disable protect mode
1048 pDevice->byERPFlag &= ~(WLAN_SET_ERP_USE_PROTECTION(1));
1049 }
1050
1051 if(pDevice->byReAssocCount > 0) {
1052 pDevice->byReAssocCount++;
1053 if((pDevice->byReAssocCount > 10) && (pDevice->bLinkPass != TRUE)) { //10 sec timeout
1054 printk("Re-association timeout!!!\n");
1055 pDevice->byReAssocCount = 0;
1056 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1057 // if(pDevice->bWPASuppWextEnabled == TRUE)
1058 {
1059 union iwreq_data wrqu;
1060 memset(&wrqu, 0, sizeof (wrqu));
1061 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1062 PRINT_K("wireless_send_event--->SIOCGIWAP(disassociated)\n");
1063 wireless_send_event(pDevice->dev, SIOCGIWAP, &wrqu, NULL);
1064 }
1065 #endif
1066 }
1067 else if(pDevice->bLinkPass == TRUE)
1068 pDevice->byReAssocCount = 0;
1069 }
1070
1071 #ifdef SndEvt_ToAPI
1072 if((pMgmt->eCurrState!=WMAC_STATE_ASSOC) &&
1073 (pMgmt->eLastState==WMAC_STATE_ASSOC))
1074 {
1075 union iwreq_data wrqu;
1076 memset(&wrqu, 0, sizeof(wrqu));
1077 wrqu.data.flags = RT_DISCONNECTED_EVENT_FLAG;
1078 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1079 }
1080 pMgmt->eLastState = pMgmt->eCurrState ;
1081 #endif
1082
1083 #ifdef Calcu_LinkQual
1084 s_uCalculateLinkQual((HANDLE)pDevice);
1085 #endif
1086
1087 for (ii = 0; ii < (MAX_NODE_NUM + 1); ii++) {
1088
1089 if (pMgmt->sNodeDBTable[ii].bActive) {
1090 // Increase in-activity counter
1091 pMgmt->sNodeDBTable[ii].uInActiveCount++;
1092
1093 if (ii > 0) {
1094 if (pMgmt->sNodeDBTable[ii].uInActiveCount > MAX_INACTIVE_COUNT) {
1095 BSSvRemoveOneNode(pDevice, ii);
1096 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO
1097 "Inactive timeout [%d] sec, STA index = [%d] remove\n", MAX_INACTIVE_COUNT, ii);
1098 continue;
1099 }
1100
1101 if (pMgmt->sNodeDBTable[ii].eNodeState >= NODE_ASSOC) {
1102
1103 pDevice->uAssocCount++;
1104
1105 // check if Non ERP exist
1106 if (pMgmt->sNodeDBTable[ii].uInActiveCount < ERP_RECOVER_COUNT) {
1107 if (!pMgmt->sNodeDBTable[ii].bShortPreamble) {
1108 pDevice->byERPFlag |= WLAN_SET_ERP_BARKER_MODE(1);
1109 uLongPreambleSTACnt ++;
1110 }
1111 if (!pMgmt->sNodeDBTable[ii].bERPExist) {
1112 pDevice->byERPFlag |= WLAN_SET_ERP_NONERP_PRESENT(1);
1113 pDevice->byERPFlag |= WLAN_SET_ERP_USE_PROTECTION(1);
1114 }
1115 if (!pMgmt->sNodeDBTable[ii].bShortSlotTime)
1116 uNonShortSlotSTACnt++;
1117 }
1118 }
1119
1120 // check if any STA in PS mode
1121 if (pMgmt->sNodeDBTable[ii].bPSEnable)
1122 uSleepySTACnt++;
1123
1124
1125 }
1126
1127 // Rate fallback check
1128 if (!pDevice->bFixRate) {
1129 /*
1130 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_STA) && (ii == 0))
1131 RATEvTxRateFallBack(pDevice, &(pMgmt->sNodeDBTable[ii]));
1132 */
1133 if (ii > 0) {
1134 // ii = 0 for multicast node (AP & Adhoc)
1135 RATEvTxRateFallBack((PVOID)pDevice, &(pMgmt->sNodeDBTable[ii]));
1136 }
1137 else {
1138 // ii = 0 reserved for unicast AP node (Infra STA)
1139 if (pMgmt->eCurrMode == WMAC_MODE_ESS_STA)
1140 RATEvTxRateFallBack((PVOID)pDevice, &(pMgmt->sNodeDBTable[ii]));
1141 }
1142
1143 }
1144
1145 // check if pending PS queue
1146 if (pMgmt->sNodeDBTable[ii].wEnQueueCnt != 0) {
1147 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Index= %d, Queue = %d pending \n",
1148 ii, pMgmt->sNodeDBTable[ii].wEnQueueCnt);
1149 if ((ii >0) && (pMgmt->sNodeDBTable[ii].wEnQueueCnt > 15)) {
1150 BSSvRemoveOneNode(pDevice, ii);
1151 DBG_PRT(MSG_LEVEL_NOTICE, KERN_INFO "Pending many queues PS STA Index = %d remove \n", ii);
1152 continue;
1153 }
1154 }
1155 }
1156
1157 }
1158
1159
1160 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_AP) && (pDevice->byBBType == BB_TYPE_11G)) {
1161
1162 // on/off protect mode
1163 if (WLAN_GET_ERP_USE_PROTECTION(pDevice->byERPFlag)) {
1164 if (!pDevice->bProtectMode) {
1165 MACvEnableProtectMD(pDevice);
1166 pDevice->bProtectMode = TRUE;
1167 }
1168 }
1169 else {
1170 if (pDevice->bProtectMode) {
1171 MACvDisableProtectMD(pDevice);
1172 pDevice->bProtectMode = FALSE;
1173 }
1174 }
1175 // on/off short slot time
1176
1177 if (uNonShortSlotSTACnt > 0) {
1178 if (pDevice->bShortSlotTime) {
1179 pDevice->bShortSlotTime = FALSE;
1180 BBvSetShortSlotTime(pDevice);
1181 vUpdateIFS((PVOID)pDevice);
1182 }
1183 }
1184 else {
1185 if (!pDevice->bShortSlotTime) {
1186 pDevice->bShortSlotTime = TRUE;
1187 BBvSetShortSlotTime(pDevice);
1188 vUpdateIFS((PVOID)pDevice);
1189 }
1190 }
1191
1192 // on/off barker long preamble mode
1193
1194 if (uLongPreambleSTACnt > 0) {
1195 if (!pDevice->bBarkerPreambleMd) {
1196 MACvEnableBarkerPreambleMd(pDevice);
1197 pDevice->bBarkerPreambleMd = TRUE;
1198 }
1199 }
1200 else {
1201 if (pDevice->bBarkerPreambleMd) {
1202 MACvDisableBarkerPreambleMd(pDevice);
1203 pDevice->bBarkerPreambleMd = FALSE;
1204 }
1205 }
1206
1207 }
1208
1209
1210 // Check if any STA in PS mode, enable DTIM multicast deliver
1211 if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
1212 if (uSleepySTACnt > 0)
1213 pMgmt->sNodeDBTable[0].bPSEnable = TRUE;
1214 else
1215 pMgmt->sNodeDBTable[0].bPSEnable = FALSE;
1216 }
1217
1218 pItemSSID = (PWLAN_IE_SSID)pMgmt->abyDesireSSID;
1219 pCurrSSID = (PWLAN_IE_SSID)pMgmt->abyCurrSSID;
1220
1221 if ((pMgmt->eCurrMode == WMAC_MODE_STANDBY) ||
1222 (pMgmt->eCurrMode == WMAC_MODE_ESS_STA)) {
1223
1224 if (pMgmt->sNodeDBTable[0].bActive) { // Assoc with BSS
1225 // DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "Callback inactive Count = [%d]\n", pMgmt->sNodeDBTable[0].uInActiveCount);
1226
1227 if (pDevice->bUpdateBBVGA) {
1228 // s_vCheckSensitivity((HANDLE) pDevice);
1229 s_vCheckPreEDThreshold((HANDLE)pDevice);
1230 }
1231
1232 if ((pMgmt->sNodeDBTable[0].uInActiveCount >= (LOST_BEACON_COUNT/2)) &&
1233 (pDevice->byBBVGACurrent != pDevice->abyBBVGA[0]) ) {
1234 pDevice->byBBVGANew = pDevice->abyBBVGA[0];
1235 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_CHANGE_BBSENSITIVITY, NULL);
1236 }
1237
1238 if (pMgmt->sNodeDBTable[0].uInActiveCount >= LOST_BEACON_COUNT) {
1239 pMgmt->sNodeDBTable[0].bActive = FALSE;
1240 pMgmt->eCurrMode = WMAC_MODE_STANDBY;
1241 pMgmt->eCurrState = WMAC_STATE_IDLE;
1242 netif_stop_queue(pDevice->dev);
1243 pDevice->bLinkPass = FALSE;
1244 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
1245 pDevice->bRoaming = TRUE;
1246 pDevice->bIsRoaming = FALSE;
1247
1248 DBG_PRT(MSG_LEVEL_NOTICE, KERN_INFO "Lost AP beacon [%d] sec, disconnected !\n", pMgmt->sNodeDBTable[0].uInActiveCount);
1249 //let wpa supplicant know AP may disconnect.//20080717-01,<Add> by James Li
1250 if ((pDevice->bWPADEVUp) && (pDevice->skb != NULL)) {
1251 wpahdr = (viawget_wpa_header *)pDevice->skb->data;
1252 wpahdr->type = VIAWGET_DISASSOC_MSG;
1253 wpahdr->resp_ie_len = 0;
1254 wpahdr->req_ie_len = 0;
1255 skb_put(pDevice->skb, sizeof(viawget_wpa_header));
1256 pDevice->skb->dev = pDevice->wpadev;
1257 skb_reset_mac_header(pDevice->skb);
1258 pDevice->skb->pkt_type = PACKET_HOST;
1259 pDevice->skb->protocol = htons(ETH_P_802_2);
1260 memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb));
1261 netif_rx(pDevice->skb);
1262 pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1263 };
1264 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1265 // if(pDevice->bWPASuppWextEnabled == TRUE)
1266 {
1267 union iwreq_data wrqu;
1268 memset(&wrqu, 0, sizeof (wrqu));
1269 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1270 PRINT_K("wireless_send_event--->SIOCGIWAP(disassociated)\n");
1271 wireless_send_event(pDevice->dev, SIOCGIWAP, &wrqu, NULL);
1272 }
1273 #endif
1274 }
1275 }
1276 else if (pItemSSID->len != 0) {
1277 //Davidwang
1278 if ((pDevice->bEnableRoaming == TRUE)&&(!(pMgmt->Cisco_cckm))) {
1279 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "bRoaming %d, !\n", pDevice->bRoaming );
1280 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "bIsRoaming %d, !\n", pDevice->bIsRoaming );
1281 if ((pDevice->bRoaming == TRUE)&&(pDevice->bIsRoaming == TRUE)){
1282 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Fast Roaming ...\n");
1283 BSSvClearBSSList((HANDLE)pDevice, pDevice->bLinkPass);
1284 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_BSSID_SCAN, pMgmt->abyDesireSSID);
1285 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_SSID, pMgmt->abyDesireSSID);
1286 pDevice->uAutoReConnectTime = 0;
1287 pDevice->uIsroamingTime = 0;
1288 pDevice->bRoaming = FALSE;
1289
1290 // if ((pDevice->bWPADEVUp) && (pDevice->skb != NULL)) {
1291 wpahdr = (viawget_wpa_header *)pDevice->skb->data;
1292 wpahdr->type = VIAWGET_CCKM_ROAM_MSG;
1293 wpahdr->resp_ie_len = 0;
1294 wpahdr->req_ie_len = 0;
1295 skb_put(pDevice->skb, sizeof(viawget_wpa_header));
1296 pDevice->skb->dev = pDevice->wpadev;
1297 skb_reset_mac_header(pDevice->skb);
1298 pDevice->skb->pkt_type = PACKET_HOST;
1299 pDevice->skb->protocol = htons(ETH_P_802_2);
1300 memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb));
1301 netif_rx(pDevice->skb);
1302 pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1303
1304 // }
1305 }
1306 else if ((pDevice->bRoaming == FALSE)&&(pDevice->bIsRoaming == TRUE)) {
1307 pDevice->uIsroamingTime++;
1308 if (pDevice->uIsroamingTime >= 20)
1309 pDevice->bIsRoaming = FALSE;
1310 }
1311
1312 }
1313 else {
1314 if (pDevice->uAutoReConnectTime < 10) {
1315 pDevice->uAutoReConnectTime++;
1316 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1317 //network manager support need not do Roaming scan???
1318 if(pDevice->bWPASuppWextEnabled ==TRUE)
1319 pDevice->uAutoReConnectTime = 0;
1320 #endif
1321 }
1322 else {
1323 //mike use old encryption status for wpa reauthen
1324 if(pDevice->bWPADEVUp)
1325 pDevice->eEncryptionStatus = pDevice->eOldEncryptionStatus;
1326
1327 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Roaming ...\n");
1328 BSSvClearBSSList((HANDLE)pDevice, pDevice->bLinkPass);
1329 pMgmt->eScanType = WMAC_SCAN_ACTIVE;
1330 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_BSSID_SCAN, pMgmt->abyDesireSSID);
1331 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_SSID, pMgmt->abyDesireSSID);
1332 pDevice->uAutoReConnectTime = 0;
1333 }
1334 }
1335 }
1336 }
1337
1338 if (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
1339 // if adhoc started which essid is NULL string, rescaning.
1340 if ((pMgmt->eCurrState == WMAC_STATE_STARTED) && (pCurrSSID->len == 0)) {
1341 if (pDevice->uAutoReConnectTime < 10) {
1342 pDevice->uAutoReConnectTime++;
1343 }
1344 else {
1345 DBG_PRT(MSG_LEVEL_NOTICE, KERN_INFO "Adhoc re-scaning ...\n");
1346 pMgmt->eScanType = WMAC_SCAN_ACTIVE;
1347 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1348 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_SSID, NULL);
1349 pDevice->uAutoReConnectTime = 0;
1350 };
1351 }
1352 if (pMgmt->eCurrState == WMAC_STATE_JOINTED) {
1353
1354 if (pDevice->bUpdateBBVGA) {
1355 //s_vCheckSensitivity((HANDLE) pDevice);
1356 s_vCheckPreEDThreshold((HANDLE)pDevice);
1357 }
1358 if (pMgmt->sNodeDBTable[0].uInActiveCount >=ADHOC_LOST_BEACON_COUNT) {
1359 DBG_PRT(MSG_LEVEL_NOTICE, KERN_INFO "Lost other STA beacon [%d] sec, started !\n", pMgmt->sNodeDBTable[0].uInActiveCount);
1360 pMgmt->sNodeDBTable[0].uInActiveCount = 0;
1361 pMgmt->eCurrState = WMAC_STATE_STARTED;
1362 netif_stop_queue(pDevice->dev);
1363 pDevice->bLinkPass = FALSE;
1364 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
1365 }
1366 }
1367 }
1368
1369 if (pDevice->bLinkPass == TRUE) {
1370 if (netif_queue_stopped(pDevice->dev))
1371 netif_wake_queue(pDevice->dev);
1372 }
1373
1374 spin_unlock_irq(&pDevice->lock);
1375
1376 pMgmt->sTimerSecondCallback.expires = RUN_AT(HZ);
1377 add_timer(&pMgmt->sTimerSecondCallback);
1378 return;
1379 }
1380
1381
1382
1383
1384 /*+
1385 *
1386 * Routine Description:
1387 *
1388 *
1389 * Update Tx attemps, Tx failure counter in Node DB
1390 *
1391 *
1392 * Return Value:
1393 * none.
1394 *
1395 -*/
1396
1397
1398
1399 VOID
1400 BSSvUpdateNodeTxCounter(
1401 IN HANDLE hDeviceContext,
1402 IN PSStatCounter pStatistic,
1403 IN BYTE byTSR,
1404 IN BYTE byPktNO
1405 )
1406 {
1407 PSDevice pDevice = (PSDevice)hDeviceContext;
1408 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1409 UINT uNodeIndex = 0;
1410 BYTE byTxRetry;
1411 WORD wRate;
1412 WORD wFallBackRate = RATE_1M;
1413 BYTE byFallBack;
1414 UINT ii;
1415 PBYTE pbyDestAddr;
1416 BYTE byPktNum;
1417 WORD wFIFOCtl;
1418
1419
1420
1421 byPktNum = (byPktNO & 0x0F) >> 4;
1422 byTxRetry = (byTSR & 0xF0) >> 4;
1423 wRate = (WORD) (byPktNO & 0xF0) >> 4;
1424 wFIFOCtl = pStatistic->abyTxPktInfo[byPktNum].wFIFOCtl;
1425 pbyDestAddr = (PBYTE) &( pStatistic->abyTxPktInfo[byPktNum].abyDestAddr[0]);
1426
1427 if (wFIFOCtl & FIFOCTL_AUTO_FB_0) {
1428 byFallBack = AUTO_FB_0;
1429 } else if (wFIFOCtl & FIFOCTL_AUTO_FB_1) {
1430 byFallBack = AUTO_FB_1;
1431 } else {
1432 byFallBack = AUTO_FB_NONE;
1433 }
1434
1435 // Only Unicast using support rates
1436 if (wFIFOCtl & FIFOCTL_NEEDACK) {
1437 //DBG_PRN_GRP21(("Device %08X, wRate %04X, byTSR %02X\n", hDeviceContext, wRate, byTSR));
1438 if (pMgmt->eCurrMode == WMAC_MODE_ESS_STA) {
1439 pMgmt->sNodeDBTable[0].uTxAttempts += 1;
1440 if (BITbIsAllBitsOff(byTSR, (TSR_TMO | TSR_RETRYTMO))) {
1441 // transmit success, TxAttempts at least plus one
1442 pMgmt->sNodeDBTable[0].uTxOk[MAX_RATE]++;
1443 if ( (byFallBack == AUTO_FB_NONE) ||
1444 (wRate < RATE_18M) ) {
1445 wFallBackRate = wRate;
1446 } else if (byFallBack == AUTO_FB_0) {
1447 if (byTxRetry < 5)
1448 wFallBackRate = awHWRetry0[wRate-RATE_18M][byTxRetry];
1449 else
1450 wFallBackRate = awHWRetry0[wRate-RATE_18M][4];
1451 } else if (byFallBack == AUTO_FB_1) {
1452 if (byTxRetry < 5)
1453 wFallBackRate = awHWRetry1[wRate-RATE_18M][byTxRetry];
1454 else
1455 wFallBackRate = awHWRetry1[wRate-RATE_18M][4];
1456 }
1457 pMgmt->sNodeDBTable[0].uTxOk[wFallBackRate]++;
1458 } else {
1459 pMgmt->sNodeDBTable[0].uTxFailures ++;
1460 }
1461 pMgmt->sNodeDBTable[0].uTxRetry += byTxRetry;
1462 if (byTxRetry != 0) {
1463 pMgmt->sNodeDBTable[0].uTxFail[MAX_RATE]+=byTxRetry;
1464 if ( (byFallBack == AUTO_FB_NONE) ||
1465 (wRate < RATE_18M) ) {
1466 pMgmt->sNodeDBTable[0].uTxFail[wRate]+=byTxRetry;
1467 } else if (byFallBack == AUTO_FB_0) {
1468 for(ii=0;ii<byTxRetry;ii++) {
1469 if (ii < 5)
1470 wFallBackRate = awHWRetry0[wRate-RATE_18M][ii];
1471 else
1472 wFallBackRate = awHWRetry0[wRate-RATE_18M][4];
1473 pMgmt->sNodeDBTable[0].uTxFail[wFallBackRate]++;
1474 }
1475 } else if (byFallBack == AUTO_FB_1) {
1476 for(ii=0;ii<byTxRetry;ii++) {
1477 if (ii < 5)
1478 wFallBackRate = awHWRetry1[wRate-RATE_18M][ii];
1479 else
1480 wFallBackRate = awHWRetry1[wRate-RATE_18M][4];
1481 pMgmt->sNodeDBTable[0].uTxFail[wFallBackRate]++;
1482 }
1483 }
1484 }
1485 };
1486
1487 if ((pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) ||
1488 (pMgmt->eCurrMode == WMAC_MODE_ESS_AP)) {
1489
1490 if (BSSbIsSTAInNodeDB((HANDLE)pDevice, pbyDestAddr, &uNodeIndex)){
1491 pMgmt->sNodeDBTable[uNodeIndex].uTxAttempts += 1;
1492 if (BITbIsAllBitsOff(byTSR, (TSR_TMO | TSR_RETRYTMO))) {
1493 // transmit success, TxAttempts at least plus one
1494 pMgmt->sNodeDBTable[uNodeIndex].uTxOk[MAX_RATE]++;
1495 if ( (byFallBack == AUTO_FB_NONE) ||
1496 (wRate < RATE_18M) ) {
1497 wFallBackRate = wRate;
1498 } else if (byFallBack == AUTO_FB_0) {
1499 if (byTxRetry < 5)
1500 wFallBackRate = awHWRetry0[wRate-RATE_18M][byTxRetry];
1501 else
1502 wFallBackRate = awHWRetry0[wRate-RATE_18M][4];
1503 } else if (byFallBack == AUTO_FB_1) {
1504 if (byTxRetry < 5)
1505 wFallBackRate = awHWRetry1[wRate-RATE_18M][byTxRetry];
1506 else
1507 wFallBackRate = awHWRetry1[wRate-RATE_18M][4];
1508 }
1509 pMgmt->sNodeDBTable[uNodeIndex].uTxOk[wFallBackRate]++;
1510 } else {
1511 pMgmt->sNodeDBTable[uNodeIndex].uTxFailures ++;
1512 }
1513 pMgmt->sNodeDBTable[uNodeIndex].uTxRetry += byTxRetry;
1514 if (byTxRetry != 0) {
1515 pMgmt->sNodeDBTable[uNodeIndex].uTxFail[MAX_RATE]+=byTxRetry;
1516 if ( (byFallBack == AUTO_FB_NONE) ||
1517 (wRate < RATE_18M) ) {
1518 pMgmt->sNodeDBTable[uNodeIndex].uTxFail[wRate]+=byTxRetry;
1519 } else if (byFallBack == AUTO_FB_0) {
1520 for(ii=0;ii<byTxRetry;ii++) {
1521 if (ii < 5)
1522 wFallBackRate = awHWRetry0[wRate-RATE_18M][ii];
1523 else
1524 wFallBackRate = awHWRetry0[wRate-RATE_18M][4];
1525 pMgmt->sNodeDBTable[uNodeIndex].uTxFail[wFallBackRate]++;
1526 }
1527 } else if (byFallBack == AUTO_FB_1) {
1528 for(ii=0;ii<byTxRetry;ii++) {
1529 if (ii < 5)
1530 wFallBackRate = awHWRetry1[wRate-RATE_18M][ii];
1531 else
1532 wFallBackRate = awHWRetry1[wRate-RATE_18M][4];
1533 pMgmt->sNodeDBTable[uNodeIndex].uTxFail[wFallBackRate]++;
1534 }
1535 }
1536 }
1537 };
1538 }
1539 };
1540
1541 return;
1542
1543
1544 }
1545
1546
1547
1548
1549 /*+
1550 *
1551 * Routine Description:
1552 * Clear Nodes & skb in DB Table
1553 *
1554 *
1555 * Parameters:
1556 * In:
1557 * hDeviceContext - The adapter context.
1558 * uStartIndex - starting index
1559 * Out:
1560 * none
1561 *
1562 * Return Value:
1563 * None.
1564 *
1565 -*/
1566
1567
1568 VOID
1569 BSSvClearNodeDBTable(
1570 IN HANDLE hDeviceContext,
1571 IN UINT uStartIndex
1572 )
1573
1574 {
1575 PSDevice pDevice = (PSDevice)hDeviceContext;
1576 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1577 struct sk_buff *skb;
1578 UINT ii;
1579
1580 for (ii = uStartIndex; ii < (MAX_NODE_NUM + 1); ii++) {
1581 if (pMgmt->sNodeDBTable[ii].bActive) {
1582 // check if sTxPSQueue has been initial
1583 if (pMgmt->sNodeDBTable[ii].sTxPSQueue.next != NULL) {
1584 while ((skb = skb_dequeue(&pMgmt->sNodeDBTable[ii].sTxPSQueue)) != NULL){
1585 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "PS skb != NULL %d\n", ii);
1586 dev_kfree_skb(skb);
1587 }
1588 }
1589 memset(&pMgmt->sNodeDBTable[ii], 0, sizeof(KnownNodeDB));
1590 }
1591 }
1592
1593 return;
1594 };
1595
1596
1597 VOID s_vCheckSensitivity(
1598 IN HANDLE hDeviceContext
1599 )
1600 {
1601 PSDevice pDevice = (PSDevice)hDeviceContext;
1602 PKnownBSS pBSSList = NULL;
1603 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1604 int ii;
1605
1606 if ((pMgmt->eCurrState == WMAC_STATE_ASSOC) ||
1607 ((pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) && (pMgmt->eCurrState == WMAC_STATE_JOINTED))) {
1608 pBSSList = BSSpAddrIsInBSSList(pDevice, pMgmt->abyCurrBSSID, (PWLAN_IE_SSID)pMgmt->abyCurrSSID);
1609 if (pBSSList != NULL) {
1610 // Updata BB Reg if RSSI is too strong.
1611 LONG LocalldBmAverage = 0;
1612 LONG uNumofdBm = 0;
1613 for (ii = 0; ii < RSSI_STAT_COUNT; ii++) {
1614 if (pBSSList->ldBmAverage[ii] != 0) {
1615 uNumofdBm ++;
1616 LocalldBmAverage += pBSSList->ldBmAverage[ii];
1617 }
1618 }
1619 if (uNumofdBm > 0) {
1620 LocalldBmAverage = LocalldBmAverage/uNumofdBm;
1621 for (ii=0;ii<BB_VGA_LEVEL;ii++) {
1622 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"LocalldBmAverage:%ld, %ld %02x\n", LocalldBmAverage, pDevice->ldBmThreshold[ii], pDevice->abyBBVGA[ii]);
1623 if (LocalldBmAverage < pDevice->ldBmThreshold[ii]) {
1624 pDevice->byBBVGANew = pDevice->abyBBVGA[ii];
1625 break;
1626 }
1627 }
1628 if (pDevice->byBBVGANew != pDevice->byBBVGACurrent) {
1629 pDevice->uBBVGADiffCount++;
1630 if (pDevice->uBBVGADiffCount >= BB_VGA_CHANGE_THRESHOLD)
1631 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_CHANGE_BBSENSITIVITY, NULL);
1632 } else {
1633 pDevice->uBBVGADiffCount = 0;
1634 }
1635 }
1636 }
1637 }
1638 }
1639
1640 #ifdef Calcu_LinkQual
1641 VOID s_uCalculateLinkQual(
1642 IN HANDLE hDeviceContext
1643 )
1644 {
1645 PSDevice pDevice = (PSDevice)hDeviceContext;
1646 ULONG TxOkRatio, TxCnt;
1647 ULONG RxOkRatio,RxCnt;
1648 ULONG RssiRatio;
1649 long ldBm;
1650
1651 TxCnt = pDevice->scStatistic.TxNoRetryOkCount +
1652 pDevice->scStatistic.TxRetryOkCount +
1653 pDevice->scStatistic.TxFailCount;
1654 RxCnt = pDevice->scStatistic.RxFcsErrCnt +
1655 pDevice->scStatistic.RxOkCnt;
1656 TxOkRatio = (TxCnt < 6) ? 4000:((pDevice->scStatistic.TxNoRetryOkCount * 4000) / TxCnt);
1657 RxOkRatio = (RxCnt < 6) ? 2000:((pDevice->scStatistic.RxOkCnt * 2000) / RxCnt);
1658 //decide link quality
1659 if(pDevice->bLinkPass !=TRUE)
1660 {
1661 // printk("s_uCalculateLinkQual-->Link disconnect and Poor quality**\n");
1662 pDevice->scStatistic.LinkQuality = 0;
1663 pDevice->scStatistic.SignalStren = 0;
1664 }
1665 else
1666 {
1667 RFvRSSITodBm(pDevice, (BYTE)(pDevice->uCurrRSSI), &ldBm);
1668 if(-ldBm < 50) {
1669 RssiRatio = 4000;
1670 }
1671 else if(-ldBm > 90) {
1672 RssiRatio = 0;
1673 }
1674 else {
1675 RssiRatio = (40-(-ldBm-50))*4000/40;
1676 }
1677 pDevice->scStatistic.SignalStren = RssiRatio/40;
1678 pDevice->scStatistic.LinkQuality = (RssiRatio+TxOkRatio+RxOkRatio)/100;
1679 }
1680 pDevice->scStatistic.RxFcsErrCnt = 0;
1681 pDevice->scStatistic.RxOkCnt = 0;
1682 pDevice->scStatistic.TxFailCount = 0;
1683 pDevice->scStatistic.TxNoRetryOkCount = 0;
1684 pDevice->scStatistic.TxRetryOkCount = 0;
1685 return;
1686 }
1687 #endif
1688
1689 VOID
1690 BSSvClearAnyBSSJoinRecord (
1691 IN HANDLE hDeviceContext
1692 )
1693 {
1694 PSDevice pDevice = (PSDevice)hDeviceContext;
1695 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1696 UINT ii;
1697
1698 for (ii = 0; ii < MAX_BSS_NUM; ii++) {
1699 pMgmt->sBSSList[ii].bSelected = FALSE;
1700 }
1701 return;
1702 }
1703
1704 VOID s_vCheckPreEDThreshold(
1705 IN HANDLE hDeviceContext
1706 )
1707 {
1708 PSDevice pDevice = (PSDevice)hDeviceContext;
1709 PKnownBSS pBSSList = NULL;
1710 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1711
1712 if ((pMgmt->eCurrState == WMAC_STATE_ASSOC) ||
1713 ((pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) && (pMgmt->eCurrState == WMAC_STATE_JOINTED))) {
1714 pBSSList = BSSpAddrIsInBSSList(pDevice, pMgmt->abyCurrBSSID, (PWLAN_IE_SSID)pMgmt->abyCurrSSID);
1715 if (pBSSList != NULL) {
1716 pDevice->byBBPreEDRSSI = (BYTE) (~(pBSSList->ldBmAverRange) + 1);
1717 BBvUpdatePreEDThreshold(pDevice, FALSE);
1718 }
1719 }
1720 return;
1721 }
1722
Linux kernel - Deliverables
This page took 0.065536 seconds and 4 git commands to generate.