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