]>
Commit | Line | Data |
---|---|---|
5449c685 FB |
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: card.c | |
20 | * Purpose: Provide functions to setup NIC operation mode | |
21 | * Functions: | |
22 | * s_vSafeResetTx - Rest Tx | |
23 | * CARDvSetRSPINF - Set RSPINF | |
24 | * vUpdateIFS - Update slotTime,SIFS,DIFS, and EIFS | |
25 | * CARDvUpdateBasicTopRate - Update BasicTopRate | |
26 | * CARDbAddBasicRate - Add to BasicRateSet | |
27 | * CARDbSetBasicRate - Set Basic Tx Rate | |
28 | * CARDbIsOFDMinBasicRate - Check if any OFDM rate is in BasicRateSet | |
29 | * CARDvSetLoopbackMode - Set Loopback mode | |
30 | * CARDbSoftwareReset - Sortware reset NIC | |
31 | * CARDqGetTSFOffset - Caculate TSFOffset | |
32 | * CARDbGetCurrentTSF - Read Current NIC TSF counter | |
33 | * CARDqGetNextTBTT - Caculate Next Beacon TSF counter | |
34 | * CARDvSetFirstNextTBTT - Set NIC Beacon time | |
35 | * CARDvUpdateNextTBTT - Sync. NIC Beacon time | |
36 | * CARDbRadioPowerOff - Turn Off NIC Radio Power | |
37 | * CARDbRadioPowerOn - Turn On NIC Radio Power | |
38 | * CARDbSetWEPMode - Set NIC Wep mode | |
39 | * CARDbSetTxPower - Set NIC tx power | |
40 | * | |
41 | * Revision History: | |
42 | * 06-10-2003 Bryan YC Fan: Re-write codes to support VT3253 spec. | |
43 | * 08-26-2003 Kyle Hsu: Modify the defination type of dwIoBase. | |
44 | * 09-01-2003 Bryan YC Fan: Add vUpdateIFS(). | |
45 | * | |
46 | */ | |
47 | ||
5449c685 | 48 | #include "tmacro.h" |
5449c685 | 49 | #include "card.h" |
5449c685 | 50 | #include "baseband.h" |
5449c685 | 51 | #include "mac.h" |
5449c685 | 52 | #include "desc.h" |
5449c685 | 53 | #include "rf.h" |
5449c685 | 54 | #include "vntwifi.h" |
5449c685 | 55 | #include "power.h" |
5449c685 | 56 | #include "key.h" |
5449c685 | 57 | #include "rc4.h" |
5449c685 | 58 | #include "country.h" |
79566eb2 | 59 | #include "channel.h" |
5449c685 FB |
60 | |
61 | /*--------------------- Static Definitions -------------------------*/ | |
62 | ||
63 | //static int msglevel =MSG_LEVEL_DEBUG; | |
64 | static int msglevel =MSG_LEVEL_INFO; | |
65 | ||
66 | #define C_SIFS_A 16 // micro sec. | |
67 | #define C_SIFS_BG 10 | |
68 | ||
69 | #define C_EIFS 80 // micro sec. | |
70 | ||
71 | ||
72 | #define C_SLOT_SHORT 9 // micro sec. | |
73 | #define C_SLOT_LONG 20 | |
74 | ||
75 | #define C_CWMIN_A 15 // slot time | |
76 | #define C_CWMIN_B 31 | |
77 | ||
78 | #define C_CWMAX 1023 // slot time | |
79 | ||
5449c685 FB |
80 | #define WAIT_BEACON_TX_DOWN_TMO 3 // Times |
81 | ||
5449c685 | 82 | //1M, 2M, 5M, 11M, 18M, 24M, 36M, 54M |
3fc9b584 | 83 | static unsigned char abyDefaultSuppRatesG[] = {WLAN_EID_SUPP_RATES, 8, 0x02, 0x04, 0x0B, 0x16, 0x24, 0x30, 0x48, 0x6C}; |
5449c685 | 84 | //6M, 9M, 12M, 48M |
3fc9b584 | 85 | static unsigned char abyDefaultExtSuppRatesG[] = {WLAN_EID_EXTSUPP_RATES, 4, 0x0C, 0x12, 0x18, 0x60}; |
5449c685 | 86 | //6M, 9M, 12M, 18M, 24M, 36M, 48M, 54M |
3fc9b584 | 87 | static unsigned char abyDefaultSuppRatesA[] = {WLAN_EID_SUPP_RATES, 8, 0x0C, 0x12, 0x18, 0x24, 0x30, 0x48, 0x60, 0x6C}; |
5449c685 | 88 | //1M, 2M, 5M, 11M, |
3fc9b584 | 89 | static unsigned char abyDefaultSuppRatesB[] = {WLAN_EID_SUPP_RATES, 4, 0x02, 0x04, 0x0B, 0x16}; |
5449c685 FB |
90 | |
91 | ||
5449c685 FB |
92 | /*--------------------- Static Variables --------------------------*/ |
93 | ||
94 | ||
2986db5f | 95 | const unsigned short cwRXBCNTSFOff[MAX_RATE] = |
5449c685 FB |
96 | {17, 17, 17, 17, 34, 23, 17, 11, 8, 5, 4, 3}; |
97 | ||
5449c685 FB |
98 | |
99 | /*--------------------- Static Functions --------------------------*/ | |
100 | ||
101 | static | |
6b35b7b3 | 102 | void |
5449c685 | 103 | s_vCaculateOFDMRParameter( |
3fc9b584 | 104 | unsigned char byRate, |
3a215e0f | 105 | CARD_PHY_TYPE ePHYType, |
2989e96f CC |
106 | unsigned char *pbyTxRate, |
107 | unsigned char *pbyRsvTime | |
5449c685 FB |
108 | ); |
109 | ||
110 | ||
5449c685 FB |
111 | /*--------------------- Export Functions --------------------------*/ |
112 | ||
5449c685 FB |
113 | /* |
114 | * Description: Caculate TxRate and RsvTime fields for RSPINF in OFDM mode. | |
115 | * | |
116 | * Parameters: | |
117 | * In: | |
118 | * wRate - Tx Rate | |
119 | * byPktType - Tx Packet type | |
120 | * Out: | |
121 | * pbyTxRate - pointer to RSPINF TxRate field | |
122 | * pbyRsvTime - pointer to RSPINF RsvTime field | |
123 | * | |
124 | * Return Value: none | |
125 | * | |
126 | */ | |
127 | static | |
6b35b7b3 | 128 | void |
5449c685 | 129 | s_vCaculateOFDMRParameter ( |
3fc9b584 | 130 | unsigned char byRate, |
3a215e0f | 131 | CARD_PHY_TYPE ePHYType, |
2989e96f CC |
132 | unsigned char *pbyTxRate, |
133 | unsigned char *pbyRsvTime | |
5449c685 FB |
134 | ) |
135 | { | |
136 | switch (byRate) { | |
137 | case RATE_6M : | |
138 | if (ePHYType == PHY_TYPE_11A) {//5GHZ | |
139 | *pbyTxRate = 0x9B; | |
140 | *pbyRsvTime = 44; | |
141 | } | |
142 | else { | |
143 | *pbyTxRate = 0x8B; | |
144 | *pbyRsvTime = 50; | |
145 | } | |
146 | break; | |
147 | ||
148 | case RATE_9M : | |
149 | if (ePHYType == PHY_TYPE_11A) {//5GHZ | |
150 | *pbyTxRate = 0x9F; | |
151 | *pbyRsvTime = 36; | |
152 | } | |
153 | else { | |
154 | *pbyTxRate = 0x8F; | |
155 | *pbyRsvTime = 42; | |
156 | } | |
157 | break; | |
158 | ||
159 | case RATE_12M : | |
160 | if (ePHYType == PHY_TYPE_11A) {//5GHZ | |
161 | *pbyTxRate = 0x9A; | |
162 | *pbyRsvTime = 32; | |
163 | } | |
164 | else { | |
165 | *pbyTxRate = 0x8A; | |
166 | *pbyRsvTime = 38; | |
167 | } | |
168 | break; | |
169 | ||
170 | case RATE_18M : | |
171 | if (ePHYType == PHY_TYPE_11A) {//5GHZ | |
172 | *pbyTxRate = 0x9E; | |
173 | *pbyRsvTime = 28; | |
174 | } | |
175 | else { | |
176 | *pbyTxRate = 0x8E; | |
177 | *pbyRsvTime = 34; | |
178 | } | |
179 | break; | |
180 | ||
181 | case RATE_36M : | |
182 | if (ePHYType == PHY_TYPE_11A) {//5GHZ | |
183 | *pbyTxRate = 0x9D; | |
184 | *pbyRsvTime = 24; | |
185 | } | |
186 | else { | |
187 | *pbyTxRate = 0x8D; | |
188 | *pbyRsvTime = 30; | |
189 | } | |
190 | break; | |
191 | ||
192 | case RATE_48M : | |
193 | if (ePHYType == PHY_TYPE_11A) {//5GHZ | |
194 | *pbyTxRate = 0x98; | |
195 | *pbyRsvTime = 24; | |
196 | } | |
197 | else { | |
198 | *pbyTxRate = 0x88; | |
199 | *pbyRsvTime = 30; | |
200 | } | |
201 | break; | |
202 | ||
203 | case RATE_54M : | |
204 | if (ePHYType == PHY_TYPE_11A) {//5GHZ | |
205 | *pbyTxRate = 0x9C; | |
206 | *pbyRsvTime = 24; | |
207 | } | |
208 | else { | |
209 | *pbyTxRate = 0x8C; | |
210 | *pbyRsvTime = 30; | |
211 | } | |
212 | break; | |
213 | ||
214 | case RATE_24M : | |
215 | default : | |
216 | if (ePHYType == PHY_TYPE_11A) {//5GHZ | |
217 | *pbyTxRate = 0x99; | |
218 | *pbyRsvTime = 28; | |
219 | } | |
220 | else { | |
221 | *pbyTxRate = 0x89; | |
222 | *pbyRsvTime = 34; | |
223 | } | |
224 | break; | |
225 | } | |
226 | } | |
227 | ||
228 | ||
229 | ||
230 | /* | |
231 | * Description: Set RSPINF | |
232 | * | |
233 | * Parameters: | |
234 | * In: | |
235 | * pDevice - The adapter to be set | |
236 | * Out: | |
237 | * none | |
238 | * | |
239 | * Return Value: None. | |
240 | * | |
241 | */ | |
242 | static | |
6b35b7b3 | 243 | void |
830a619c | 244 | s_vSetRSPINF (PSDevice pDevice, CARD_PHY_TYPE ePHYType, void *pvSupportRateIEs, void *pvExtSupportRateIEs) |
5449c685 | 245 | { |
3fc9b584 | 246 | unsigned char byServ = 0, bySignal = 0; // For CCK |
2986db5f | 247 | unsigned short wLen = 0; |
3fc9b584 | 248 | unsigned char byTxRate = 0, byRsvTime = 0; // For OFDM |
5449c685 FB |
249 | |
250 | //Set to Page1 | |
251 | MACvSelectPage1(pDevice->PortOffset); | |
252 | ||
253 | //RSPINF_b_1 | |
254 | BBvCaculateParameter(pDevice, | |
255 | 14, | |
256 | VNTWIFIbyGetACKTxRate(RATE_1M, pvSupportRateIEs, pvExtSupportRateIEs), | |
257 | PK_TYPE_11B, | |
258 | &wLen, | |
259 | &byServ, | |
260 | &bySignal | |
261 | ); | |
262 | ||
263 | VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_1, MAKEDWORD(wLen,MAKEWORD(bySignal,byServ))); | |
264 | ///RSPINF_b_2 | |
265 | BBvCaculateParameter(pDevice, | |
266 | 14, | |
267 | VNTWIFIbyGetACKTxRate(RATE_2M, pvSupportRateIEs, pvExtSupportRateIEs), | |
268 | PK_TYPE_11B, | |
269 | &wLen, | |
270 | &byServ, | |
271 | &bySignal | |
272 | ); | |
273 | ||
274 | VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_2, MAKEDWORD(wLen,MAKEWORD(bySignal,byServ))); | |
275 | //RSPINF_b_5 | |
276 | BBvCaculateParameter(pDevice, | |
277 | 14, | |
278 | VNTWIFIbyGetACKTxRate(RATE_5M, pvSupportRateIEs, pvExtSupportRateIEs), | |
279 | PK_TYPE_11B, | |
280 | &wLen, | |
281 | &byServ, | |
282 | &bySignal | |
283 | ); | |
284 | ||
285 | VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_5, MAKEDWORD(wLen,MAKEWORD(bySignal,byServ))); | |
286 | //RSPINF_b_11 | |
287 | BBvCaculateParameter(pDevice, | |
288 | 14, | |
289 | VNTWIFIbyGetACKTxRate(RATE_11M, pvSupportRateIEs, pvExtSupportRateIEs), | |
290 | PK_TYPE_11B, | |
291 | &wLen, | |
292 | &byServ, | |
293 | &bySignal | |
294 | ); | |
295 | ||
296 | VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_11, MAKEDWORD(wLen,MAKEWORD(bySignal,byServ))); | |
297 | //RSPINF_a_6 | |
298 | s_vCaculateOFDMRParameter(RATE_6M, | |
299 | ePHYType, | |
300 | &byTxRate, | |
301 | &byRsvTime); | |
302 | VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_6, MAKEWORD(byTxRate,byRsvTime)); | |
303 | //RSPINF_a_9 | |
304 | s_vCaculateOFDMRParameter(RATE_9M, | |
305 | ePHYType, | |
306 | &byTxRate, | |
307 | &byRsvTime); | |
308 | VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_9, MAKEWORD(byTxRate,byRsvTime)); | |
309 | //RSPINF_a_12 | |
310 | s_vCaculateOFDMRParameter(RATE_12M, | |
311 | ePHYType, | |
312 | &byTxRate, | |
313 | &byRsvTime); | |
314 | VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_12, MAKEWORD(byTxRate,byRsvTime)); | |
315 | //RSPINF_a_18 | |
316 | s_vCaculateOFDMRParameter(RATE_18M, | |
317 | ePHYType, | |
318 | &byTxRate, | |
319 | &byRsvTime); | |
320 | VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_18, MAKEWORD(byTxRate,byRsvTime)); | |
321 | //RSPINF_a_24 | |
322 | s_vCaculateOFDMRParameter(RATE_24M, | |
323 | ePHYType, | |
324 | &byTxRate, | |
325 | &byRsvTime); | |
326 | VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_24, MAKEWORD(byTxRate,byRsvTime)); | |
327 | //RSPINF_a_36 | |
328 | s_vCaculateOFDMRParameter( | |
329 | VNTWIFIbyGetACKTxRate(RATE_36M, pvSupportRateIEs, pvExtSupportRateIEs), | |
330 | ePHYType, | |
331 | &byTxRate, | |
332 | &byRsvTime); | |
333 | VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_36, MAKEWORD(byTxRate,byRsvTime)); | |
334 | //RSPINF_a_48 | |
335 | s_vCaculateOFDMRParameter( | |
336 | VNTWIFIbyGetACKTxRate(RATE_48M, pvSupportRateIEs, pvExtSupportRateIEs), | |
337 | ePHYType, | |
338 | &byTxRate, | |
339 | &byRsvTime); | |
340 | VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_48, MAKEWORD(byTxRate,byRsvTime)); | |
341 | //RSPINF_a_54 | |
342 | s_vCaculateOFDMRParameter( | |
343 | VNTWIFIbyGetACKTxRate(RATE_54M, pvSupportRateIEs, pvExtSupportRateIEs), | |
344 | ePHYType, | |
345 | &byTxRate, | |
346 | &byRsvTime); | |
347 | VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_54, MAKEWORD(byTxRate,byRsvTime)); | |
348 | //RSPINF_a_72 | |
349 | VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_72, MAKEWORD(byTxRate,byRsvTime)); | |
350 | //Set to Page0 | |
351 | MACvSelectPage0(pDevice->PortOffset); | |
352 | } | |
353 | ||
5449c685 | 354 | /*--------------------- Export Functions --------------------------*/ |
5449c685 FB |
355 | |
356 | /* | |
357 | * Description: Card Send packet function | |
358 | * | |
359 | * Parameters: | |
360 | * In: | |
361 | * pDeviceHandler - The adapter to be set | |
362 | * pPacket - Packet buffer pointer | |
363 | * ePktType - Packet type | |
364 | * uLength - Packet length | |
365 | * Out: | |
366 | * none | |
367 | * | |
5a5a2a6a | 368 | * Return Value: true if succeeded; false if failed. |
5449c685 FB |
369 | * |
370 | */ | |
371 | /* | |
7b6a0013 | 372 | bool CARDbSendPacket (void *pDeviceHandler, void *pPacket, CARD_PKT_TYPE ePktType, unsigned int uLength) |
5449c685 FB |
373 | { |
374 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
375 | if (ePktType == PKT_TYPE_802_11_MNG) { | |
376 | return TXbTD0Send(pDevice, pPacket, uLength); | |
377 | } else if (ePktType == PKT_TYPE_802_11_BCN) { | |
378 | return TXbBeaconSend(pDevice, pPacket, uLength); | |
379 | } if (ePktType == PKT_TYPE_802_11_DATA) { | |
380 | return TXbTD1Send(pDevice, pPacket, uLength); | |
381 | } | |
382 | ||
1b12068a | 383 | return (true); |
5449c685 FB |
384 | } |
385 | */ | |
386 | ||
387 | ||
388 | /* | |
389 | * Description: Get Card short preamble option value | |
390 | * | |
391 | * Parameters: | |
392 | * In: | |
393 | * pDevice - The adapter to be set | |
394 | * Out: | |
395 | * none | |
396 | * | |
5a5a2a6a | 397 | * Return Value: true if short preamble; otherwise false |
5449c685 FB |
398 | * |
399 | */ | |
7b6a0013 | 400 | bool CARDbIsShortPreamble (void *pDeviceHandler) |
5449c685 FB |
401 | { |
402 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
403 | if (pDevice->byPreambleType == 0) { | |
5a5a2a6a | 404 | return(false); |
5449c685 | 405 | } |
1b12068a | 406 | return(true); |
5449c685 FB |
407 | } |
408 | ||
409 | /* | |
410 | * Description: Get Card short slot time option value | |
411 | * | |
412 | * Parameters: | |
413 | * In: | |
414 | * pDevice - The adapter to be set | |
415 | * Out: | |
416 | * none | |
417 | * | |
5a5a2a6a | 418 | * Return Value: true if short slot time; otherwise false |
5449c685 FB |
419 | * |
420 | */ | |
7b6a0013 | 421 | bool CARDbIsShorSlotTime (void *pDeviceHandler) |
5449c685 FB |
422 | { |
423 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
424 | return(pDevice->bShortSlotTime); | |
425 | } | |
426 | ||
427 | ||
428 | /* | |
429 | * Description: Update IFS | |
430 | * | |
431 | * Parameters: | |
432 | * In: | |
433 | * pDevice - The adapter to be set | |
434 | * Out: | |
435 | * none | |
436 | * | |
437 | * Return Value: None. | |
438 | * | |
439 | */ | |
7b6a0013 | 440 | bool CARDbSetPhyParameter (void *pDeviceHandler, CARD_PHY_TYPE ePHYType, unsigned short wCapInfo, unsigned char byERPField, void *pvSupportRateIEs, void *pvExtSupportRateIEs) |
5449c685 FB |
441 | { |
442 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
3fc9b584 CC |
443 | unsigned char byCWMaxMin = 0; |
444 | unsigned char bySlot = 0; | |
445 | unsigned char bySIFS = 0; | |
446 | unsigned char byDIFS = 0; | |
447 | unsigned char byData; | |
5449c685 FB |
448 | // PWLAN_IE_SUPP_RATES pRates = NULL; |
449 | PWLAN_IE_SUPP_RATES pSupportRates = (PWLAN_IE_SUPP_RATES) pvSupportRateIEs; | |
450 | PWLAN_IE_SUPP_RATES pExtSupportRates = (PWLAN_IE_SUPP_RATES) pvExtSupportRateIEs; | |
451 | ||
452 | ||
453 | //Set SIFS, DIFS, EIFS, SlotTime, CwMin | |
454 | if (ePHYType == PHY_TYPE_11A) { | |
455 | if (pSupportRates == NULL) { | |
456 | pSupportRates = (PWLAN_IE_SUPP_RATES) abyDefaultSuppRatesA; | |
457 | } | |
458 | if (pDevice->byRFType == RF_AIROHA7230) { | |
459 | // AL7230 use single PAPE and connect to PAPE_2.4G | |
460 | MACvSetBBType(pDevice->PortOffset, BB_TYPE_11G); | |
461 | pDevice->abyBBVGA[0] = 0x20; | |
462 | pDevice->abyBBVGA[2] = 0x10; | |
463 | pDevice->abyBBVGA[3] = 0x10; | |
464 | BBbReadEmbeded(pDevice->PortOffset, 0xE7, &byData); | |
465 | if (byData == 0x1C) { | |
466 | BBbWriteEmbeded(pDevice->PortOffset, 0xE7, pDevice->abyBBVGA[0]); | |
467 | } | |
468 | } else if (pDevice->byRFType == RF_UW2452) { | |
469 | MACvSetBBType(pDevice->PortOffset, BB_TYPE_11A); | |
470 | pDevice->abyBBVGA[0] = 0x18; | |
471 | BBbReadEmbeded(pDevice->PortOffset, 0xE7, &byData); | |
472 | if (byData == 0x14) { | |
473 | BBbWriteEmbeded(pDevice->PortOffset, 0xE7, pDevice->abyBBVGA[0]); | |
474 | BBbWriteEmbeded(pDevice->PortOffset, 0xE1, 0x57); | |
475 | } | |
476 | } else { | |
477 | MACvSetBBType(pDevice->PortOffset, BB_TYPE_11A); | |
478 | } | |
479 | BBbWriteEmbeded(pDevice->PortOffset, 0x88, 0x03); | |
480 | bySlot = C_SLOT_SHORT; | |
481 | bySIFS = C_SIFS_A; | |
482 | byDIFS = C_SIFS_A + 2*C_SLOT_SHORT; | |
483 | byCWMaxMin = 0xA4; | |
484 | } else if (ePHYType == PHY_TYPE_11B) { | |
485 | if (pSupportRates == NULL) { | |
486 | pSupportRates = (PWLAN_IE_SUPP_RATES) abyDefaultSuppRatesB; | |
487 | } | |
488 | MACvSetBBType(pDevice->PortOffset, BB_TYPE_11B); | |
489 | if (pDevice->byRFType == RF_AIROHA7230) { | |
490 | pDevice->abyBBVGA[0] = 0x1C; | |
491 | pDevice->abyBBVGA[2] = 0x00; | |
492 | pDevice->abyBBVGA[3] = 0x00; | |
493 | BBbReadEmbeded(pDevice->PortOffset, 0xE7, &byData); | |
494 | if (byData == 0x20) { | |
495 | BBbWriteEmbeded(pDevice->PortOffset, 0xE7, pDevice->abyBBVGA[0]); | |
496 | } | |
497 | } else if (pDevice->byRFType == RF_UW2452) { | |
498 | pDevice->abyBBVGA[0] = 0x14; | |
499 | BBbReadEmbeded(pDevice->PortOffset, 0xE7, &byData); | |
500 | if (byData == 0x18) { | |
501 | BBbWriteEmbeded(pDevice->PortOffset, 0xE7, pDevice->abyBBVGA[0]); | |
502 | BBbWriteEmbeded(pDevice->PortOffset, 0xE1, 0xD3); | |
503 | } | |
504 | } | |
505 | BBbWriteEmbeded(pDevice->PortOffset, 0x88, 0x02); | |
506 | bySlot = C_SLOT_LONG; | |
507 | bySIFS = C_SIFS_BG; | |
508 | byDIFS = C_SIFS_BG + 2*C_SLOT_LONG; | |
509 | byCWMaxMin = 0xA5; | |
510 | } else {// PK_TYPE_11GA & PK_TYPE_11GB | |
511 | if (pSupportRates == NULL) { | |
512 | pSupportRates = (PWLAN_IE_SUPP_RATES) abyDefaultSuppRatesG; | |
513 | pExtSupportRates = (PWLAN_IE_SUPP_RATES) abyDefaultExtSuppRatesG; | |
514 | } | |
515 | MACvSetBBType(pDevice->PortOffset, BB_TYPE_11G); | |
516 | if (pDevice->byRFType == RF_AIROHA7230) { | |
517 | pDevice->abyBBVGA[0] = 0x1C; | |
518 | pDevice->abyBBVGA[2] = 0x00; | |
519 | pDevice->abyBBVGA[3] = 0x00; | |
520 | BBbReadEmbeded(pDevice->PortOffset, 0xE7, &byData); | |
521 | if (byData == 0x20) { | |
522 | BBbWriteEmbeded(pDevice->PortOffset, 0xE7, pDevice->abyBBVGA[0]); | |
523 | } | |
524 | } else if (pDevice->byRFType == RF_UW2452) { | |
525 | pDevice->abyBBVGA[0] = 0x14; | |
526 | BBbReadEmbeded(pDevice->PortOffset, 0xE7, &byData); | |
527 | if (byData == 0x18) { | |
528 | BBbWriteEmbeded(pDevice->PortOffset, 0xE7, pDevice->abyBBVGA[0]); | |
529 | BBbWriteEmbeded(pDevice->PortOffset, 0xE1, 0xD3); | |
530 | } | |
531 | } | |
532 | BBbWriteEmbeded(pDevice->PortOffset, 0x88, 0x08); | |
533 | bySIFS = C_SIFS_BG; | |
534 | if(VNTWIFIbIsShortSlotTime(wCapInfo)) { | |
535 | bySlot = C_SLOT_SHORT; | |
536 | byDIFS = C_SIFS_BG + 2*C_SLOT_SHORT; | |
537 | } else { | |
538 | bySlot = C_SLOT_LONG; | |
539 | byDIFS = C_SIFS_BG + 2*C_SLOT_LONG; | |
540 | } | |
541 | if (VNTWIFIbyGetMaxSupportRate(pSupportRates, pExtSupportRates) > RATE_11M) { | |
542 | byCWMaxMin = 0xA4; | |
543 | } else { | |
544 | byCWMaxMin = 0xA5; | |
545 | } | |
546 | if (pDevice->bProtectMode != VNTWIFIbIsProtectMode(byERPField)) { | |
547 | pDevice->bProtectMode = VNTWIFIbIsProtectMode(byERPField); | |
548 | if (pDevice->bProtectMode) { | |
549 | MACvEnableProtectMD(pDevice->PortOffset); | |
550 | } else { | |
551 | MACvDisableProtectMD(pDevice->PortOffset); | |
552 | } | |
553 | } | |
554 | if (pDevice->bBarkerPreambleMd != VNTWIFIbIsBarkerMode(byERPField)) { | |
555 | pDevice->bBarkerPreambleMd = VNTWIFIbIsBarkerMode(byERPField); | |
556 | if (pDevice->bBarkerPreambleMd) { | |
557 | MACvEnableBarkerPreambleMd(pDevice->PortOffset); | |
558 | } else { | |
559 | MACvDisableBarkerPreambleMd(pDevice->PortOffset); | |
560 | } | |
561 | } | |
562 | } | |
563 | ||
564 | if (pDevice->byRFType == RF_RFMD2959) { | |
565 | // bcs TX_PE will reserve 3 us | |
566 | // hardware's processing time here is 2 us. | |
567 | bySIFS -= 3; | |
568 | byDIFS -= 3; | |
569 | //{{ RobertYu: 20041202 | |
570 | //// TX_PE will reserve 3 us for MAX2829 A mode only, it is for better TX throughput | |
571 | //// MAC will need 2 us to process, so the SIFS, DIFS can be shorter by 2 us. | |
572 | } | |
573 | ||
574 | if (pDevice->bySIFS != bySIFS) { | |
575 | pDevice->bySIFS = bySIFS; | |
576 | VNSvOutPortB(pDevice->PortOffset + MAC_REG_SIFS, pDevice->bySIFS); | |
577 | } | |
578 | if (pDevice->byDIFS != byDIFS) { | |
579 | pDevice->byDIFS = byDIFS; | |
580 | VNSvOutPortB(pDevice->PortOffset + MAC_REG_DIFS, pDevice->byDIFS); | |
581 | } | |
582 | if (pDevice->byEIFS != C_EIFS) { | |
583 | pDevice->byEIFS = C_EIFS; | |
584 | VNSvOutPortB(pDevice->PortOffset + MAC_REG_EIFS, pDevice->byEIFS); | |
585 | } | |
586 | if (pDevice->bySlot != bySlot) { | |
587 | pDevice->bySlot = bySlot; | |
588 | VNSvOutPortB(pDevice->PortOffset + MAC_REG_SLOT, pDevice->bySlot); | |
589 | if (pDevice->bySlot == C_SLOT_SHORT) { | |
1b12068a | 590 | pDevice->bShortSlotTime = true; |
5449c685 | 591 | } else { |
5a5a2a6a | 592 | pDevice->bShortSlotTime = false; |
5449c685 FB |
593 | } |
594 | BBvSetShortSlotTime(pDevice); | |
595 | } | |
596 | if (pDevice->byCWMaxMin != byCWMaxMin) { | |
597 | pDevice->byCWMaxMin = byCWMaxMin; | |
598 | VNSvOutPortB(pDevice->PortOffset + MAC_REG_CWMAXMIN0, pDevice->byCWMaxMin); | |
599 | } | |
600 | if (VNTWIFIbIsShortPreamble(wCapInfo)) { | |
601 | pDevice->byPreambleType = pDevice->byShortPreamble; | |
602 | } else { | |
603 | pDevice->byPreambleType = 0; | |
604 | } | |
605 | s_vSetRSPINF(pDevice, ePHYType, pSupportRates, pExtSupportRates); | |
606 | pDevice->eCurrentPHYType = ePHYType; | |
607 | // set for NDIS OID_802_11SUPPORTED_RATES | |
1b12068a | 608 | return (true); |
5449c685 FB |
609 | } |
610 | ||
611 | /* | |
612 | * Description: Sync. TSF counter to BSS | |
613 | * Get TSF offset and write to HW | |
614 | * | |
615 | * Parameters: | |
616 | * In: | |
617 | * pDevice - The adapter to be sync. | |
618 | * byRxRate - data rate of receive beacon | |
619 | * qwBSSTimestamp - Rx BCN's TSF | |
620 | * qwLocalTSF - Local TSF | |
621 | * Out: | |
622 | * none | |
623 | * | |
624 | * Return Value: none | |
625 | * | |
626 | */ | |
7b6a0013 | 627 | bool CARDbUpdateTSF (void *pDeviceHandler, unsigned char byRxRate, QWORD qwBSSTimestamp, QWORD qwLocalTSF) |
5449c685 FB |
628 | { |
629 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
630 | QWORD qwTSFOffset; | |
631 | ||
632 | HIDWORD(qwTSFOffset) = 0; | |
633 | LODWORD(qwTSFOffset) = 0; | |
634 | ||
635 | if ((HIDWORD(qwBSSTimestamp) != HIDWORD(qwLocalTSF)) || | |
636 | (LODWORD(qwBSSTimestamp) != LODWORD(qwLocalTSF))) { | |
637 | qwTSFOffset = CARDqGetTSFOffset(byRxRate, qwBSSTimestamp, qwLocalTSF); | |
638 | // adjust TSF | |
639 | // HW's TSF add TSF Offset reg | |
640 | VNSvOutPortD(pDevice->PortOffset + MAC_REG_TSFOFST, LODWORD(qwTSFOffset)); | |
641 | VNSvOutPortD(pDevice->PortOffset + MAC_REG_TSFOFST + 4, HIDWORD(qwTSFOffset)); | |
642 | MACvRegBitsOn(pDevice->PortOffset, MAC_REG_TFTCTL, TFTCTL_TSFSYNCEN); | |
643 | } | |
1b12068a | 644 | return(true); |
5449c685 FB |
645 | } |
646 | ||
647 | ||
648 | /* | |
649 | * Description: Set NIC TSF counter for first Beacon time | |
650 | * Get NEXTTBTT from adjusted TSF and Beacon Interval | |
651 | * | |
652 | * Parameters: | |
653 | * In: | |
654 | * pDevice - The adapter to be set. | |
655 | * wBeaconInterval - Beacon Interval | |
656 | * Out: | |
657 | * none | |
658 | * | |
5a5a2a6a | 659 | * Return Value: true if succeed; otherwise false |
5449c685 FB |
660 | * |
661 | */ | |
7b6a0013 | 662 | bool CARDbSetBeaconPeriod (void *pDeviceHandler, unsigned short wBeaconInterval) |
5449c685 FB |
663 | { |
664 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
b6e95cd5 CC |
665 | unsigned int uBeaconInterval = 0; |
666 | unsigned int uLowNextTBTT = 0; | |
667 | unsigned int uHighRemain = 0; | |
668 | unsigned int uLowRemain = 0; | |
5449c685 FB |
669 | QWORD qwNextTBTT; |
670 | ||
671 | HIDWORD(qwNextTBTT) = 0; | |
672 | LODWORD(qwNextTBTT) = 0; | |
673 | CARDbGetCurrentTSF(pDevice->PortOffset, &qwNextTBTT); //Get Local TSF counter | |
674 | uBeaconInterval = wBeaconInterval * 1024; | |
675 | // Next TBTT = ((local_current_TSF / beacon_interval) + 1 ) * beacon_interval | |
676 | uLowNextTBTT = (LODWORD(qwNextTBTT) >> 10) << 10; | |
677 | uLowRemain = (uLowNextTBTT) % uBeaconInterval; | |
678 | // high dword (mod) bcn | |
679 | uHighRemain = (((0xffffffff % uBeaconInterval) + 1) * HIDWORD(qwNextTBTT)) | |
680 | % uBeaconInterval; | |
681 | uLowRemain = (uHighRemain + uLowRemain) % uBeaconInterval; | |
682 | uLowRemain = uBeaconInterval - uLowRemain; | |
683 | ||
684 | // check if carry when add one beacon interval | |
685 | if ((~uLowNextTBTT) < uLowRemain) { | |
686 | HIDWORD(qwNextTBTT) ++ ; | |
687 | } | |
688 | LODWORD(qwNextTBTT) = uLowNextTBTT + uLowRemain; | |
689 | ||
690 | // set HW beacon interval | |
691 | VNSvOutPortW(pDevice->PortOffset + MAC_REG_BI, wBeaconInterval); | |
692 | pDevice->wBeaconInterval = wBeaconInterval; | |
693 | // Set NextTBTT | |
694 | VNSvOutPortD(pDevice->PortOffset + MAC_REG_NEXTTBTT, LODWORD(qwNextTBTT)); | |
695 | VNSvOutPortD(pDevice->PortOffset + MAC_REG_NEXTTBTT + 4, HIDWORD(qwNextTBTT)); | |
696 | MACvRegBitsOn(pDevice->PortOffset, MAC_REG_TFTCTL, TFTCTL_TBTTSYNCEN); | |
697 | ||
1b12068a | 698 | return(true); |
5449c685 FB |
699 | } |
700 | ||
701 | ||
702 | ||
703 | /* | |
704 | * Description: Card Stop Hardware Tx | |
705 | * | |
706 | * Parameters: | |
707 | * In: | |
708 | * pDeviceHandler - The adapter to be set | |
709 | * ePktType - Packet type to stop | |
710 | * Out: | |
711 | * none | |
712 | * | |
5a5a2a6a | 713 | * Return Value: true if all data packet complete; otherwise false. |
5449c685 FB |
714 | * |
715 | */ | |
7b6a0013 | 716 | bool CARDbStopTxPacket (void *pDeviceHandler, CARD_PKT_TYPE ePktType) |
5449c685 FB |
717 | { |
718 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
719 | ||
720 | ||
721 | if (ePktType == PKT_TYPE_802_11_ALL) { | |
1b12068a CC |
722 | pDevice->bStopBeacon = true; |
723 | pDevice->bStopTx0Pkt = true; | |
724 | pDevice->bStopDataPkt = true; | |
5449c685 | 725 | } else if (ePktType == PKT_TYPE_802_11_BCN) { |
1b12068a | 726 | pDevice->bStopBeacon = true; |
5449c685 | 727 | } else if (ePktType == PKT_TYPE_802_11_MNG) { |
1b12068a | 728 | pDevice->bStopTx0Pkt = true; |
5449c685 | 729 | } else if (ePktType == PKT_TYPE_802_11_DATA) { |
1b12068a | 730 | pDevice->bStopDataPkt = true; |
5449c685 FB |
731 | } |
732 | ||
1b12068a CC |
733 | if (pDevice->bStopBeacon == true) { |
734 | if (pDevice->bIsBeaconBufReadySet == true) { | |
5449c685 FB |
735 | if (pDevice->cbBeaconBufReadySetCnt < WAIT_BEACON_TX_DOWN_TMO) { |
736 | pDevice->cbBeaconBufReadySetCnt ++; | |
5a5a2a6a | 737 | return(false); |
5449c685 FB |
738 | } |
739 | } | |
5a5a2a6a | 740 | pDevice->bIsBeaconBufReadySet = false; |
5449c685 FB |
741 | pDevice->cbBeaconBufReadySetCnt = 0; |
742 | MACvRegBitsOff(pDevice->PortOffset, MAC_REG_TCR, TCR_AUTOBCNTX); | |
743 | } | |
744 | // wait all TD0 complete | |
1b12068a | 745 | if (pDevice->bStopTx0Pkt == true) { |
5449c685 | 746 | if (pDevice->iTDUsed[TYPE_TXDMA0] != 0){ |
5a5a2a6a | 747 | return(false); |
5449c685 FB |
748 | } |
749 | } | |
750 | // wait all Data TD complete | |
1b12068a | 751 | if (pDevice->bStopDataPkt == true) { |
5449c685 | 752 | if (pDevice->iTDUsed[TYPE_AC0DMA] != 0){ |
5a5a2a6a | 753 | return(false); |
5449c685 FB |
754 | } |
755 | } | |
756 | ||
1b12068a | 757 | return(true); |
5449c685 FB |
758 | } |
759 | ||
760 | ||
761 | /* | |
762 | * Description: Card Start Hardware Tx | |
763 | * | |
764 | * Parameters: | |
765 | * In: | |
766 | * pDeviceHandler - The adapter to be set | |
767 | * ePktType - Packet type to start | |
768 | * Out: | |
769 | * none | |
770 | * | |
5a5a2a6a | 771 | * Return Value: true if success; false if failed. |
5449c685 FB |
772 | * |
773 | */ | |
7b6a0013 | 774 | bool CARDbStartTxPacket (void *pDeviceHandler, CARD_PKT_TYPE ePktType) |
5449c685 FB |
775 | { |
776 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
777 | ||
778 | ||
779 | if (ePktType == PKT_TYPE_802_11_ALL) { | |
5a5a2a6a CC |
780 | pDevice->bStopBeacon = false; |
781 | pDevice->bStopTx0Pkt = false; | |
782 | pDevice->bStopDataPkt = false; | |
5449c685 | 783 | } else if (ePktType == PKT_TYPE_802_11_BCN) { |
5a5a2a6a | 784 | pDevice->bStopBeacon = false; |
5449c685 | 785 | } else if (ePktType == PKT_TYPE_802_11_MNG) { |
5a5a2a6a | 786 | pDevice->bStopTx0Pkt = false; |
5449c685 | 787 | } else if (ePktType == PKT_TYPE_802_11_DATA) { |
5a5a2a6a | 788 | pDevice->bStopDataPkt = false; |
5449c685 FB |
789 | } |
790 | ||
5a5a2a6a | 791 | if ((pDevice->bStopBeacon == false) && |
1b12068a | 792 | (pDevice->bBeaconBufReady == true) && |
5449c685 FB |
793 | (pDevice->eOPMode == OP_MODE_ADHOC)) { |
794 | MACvRegBitsOn(pDevice->PortOffset, MAC_REG_TCR, TCR_AUTOBCNTX); | |
795 | } | |
796 | ||
1b12068a | 797 | return(true); |
5449c685 FB |
798 | } |
799 | ||
800 | ||
801 | ||
802 | /* | |
803 | * Description: Card Set BSSID value | |
804 | * | |
805 | * Parameters: | |
806 | * In: | |
807 | * pDeviceHandler - The adapter to be set | |
808 | * pbyBSSID - pointer to BSSID field | |
809 | * bAdhoc - flag to indicate IBSS | |
810 | * Out: | |
811 | * none | |
812 | * | |
5a5a2a6a | 813 | * Return Value: true if success; false if failed. |
5449c685 FB |
814 | * |
815 | */ | |
7b6a0013 | 816 | bool CARDbSetBSSID(void *pDeviceHandler, unsigned char *pbyBSSID, CARD_OP_MODE eOPMode) |
5449c685 FB |
817 | { |
818 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
819 | ||
820 | MACvWriteBSSIDAddress(pDevice->PortOffset, pbyBSSID); | |
51b6d9c2 | 821 | memcpy(pDevice->abyBSSID, pbyBSSID, WLAN_BSSID_LEN); |
5449c685 FB |
822 | if (eOPMode == OP_MODE_ADHOC) { |
823 | MACvRegBitsOn(pDevice->PortOffset, MAC_REG_HOSTCR, HOSTCR_ADHOC); | |
824 | } else { | |
825 | MACvRegBitsOff(pDevice->PortOffset, MAC_REG_HOSTCR, HOSTCR_ADHOC); | |
826 | } | |
827 | if (eOPMode == OP_MODE_AP) { | |
828 | MACvRegBitsOn(pDevice->PortOffset, MAC_REG_HOSTCR, HOSTCR_AP); | |
829 | } else { | |
830 | MACvRegBitsOff(pDevice->PortOffset, MAC_REG_HOSTCR, HOSTCR_AP); | |
831 | } | |
832 | if (eOPMode == OP_MODE_UNKNOWN) { | |
833 | MACvRegBitsOff(pDevice->PortOffset, MAC_REG_RCR, RCR_BSSID); | |
5a5a2a6a | 834 | pDevice->bBSSIDFilter = false; |
5449c685 | 835 | pDevice->byRxMode &= ~RCR_BSSID; |
7e809a9b | 836 | DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "wcmd: rx_mode = %x\n", pDevice->byRxMode ); |
5449c685 | 837 | } else { |
5a5a2a6a | 838 | if (is_zero_ether_addr(pDevice->abyBSSID) == false) { |
5449c685 | 839 | MACvRegBitsOn(pDevice->PortOffset, MAC_REG_RCR, RCR_BSSID); |
1b12068a | 840 | pDevice->bBSSIDFilter = true; |
5449c685 FB |
841 | pDevice->byRxMode |= RCR_BSSID; |
842 | } | |
7e809a9b | 843 | DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "wmgr: rx_mode = %x\n", pDevice->byRxMode ); |
5449c685 FB |
844 | } |
845 | // Adopt BSS state in Adapter Device Object | |
846 | pDevice->eOPMode = eOPMode; | |
1b12068a | 847 | return(true); |
5449c685 FB |
848 | } |
849 | ||
850 | ||
851 | /* | |
852 | * Description: Card indicate status | |
853 | * | |
854 | * Parameters: | |
855 | * In: | |
856 | * pDeviceHandler - The adapter to be set | |
857 | * eStatus - Status | |
858 | * Out: | |
859 | * none | |
860 | * | |
5a5a2a6a | 861 | * Return Value: true if success; false if failed. |
5449c685 FB |
862 | * |
863 | */ | |
864 | ||
865 | ||
866 | ||
867 | ||
868 | /* | |
869 | * Description: Save Assoc info. contain in assoc. response frame | |
870 | * | |
871 | * Parameters: | |
872 | * In: | |
873 | * pDevice - The adapter to be set | |
874 | * wCapabilityInfo - Capability information | |
875 | * wStatus - Status code | |
876 | * wAID - Assoc. ID | |
877 | * uLen - Length of IEs | |
878 | * pbyIEs - pointer to IEs | |
879 | * Out: | |
880 | * none | |
881 | * | |
5a5a2a6a | 882 | * Return Value: true if succeed; otherwise false |
5449c685 FB |
883 | * |
884 | */ | |
7b6a0013 | 885 | bool CARDbSetTxDataRate( |
830a619c | 886 | void *pDeviceHandler, |
2986db5f | 887 | unsigned short wDataRate |
5449c685 FB |
888 | ) |
889 | { | |
890 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
891 | ||
892 | pDevice->wCurrentRate = wDataRate; | |
1b12068a | 893 | return(true); |
5449c685 FB |
894 | } |
895 | ||
896 | /*+ | |
897 | * | |
898 | * Routine Description: | |
899 | * Consider to power down when no more packets to tx or rx. | |
900 | * | |
901 | * Parameters: | |
902 | * In: | |
903 | * pDevice - The adapter to be set | |
904 | * Out: | |
905 | * none | |
906 | * | |
5a5a2a6a | 907 | * Return Value: true if power down success; otherwise false |
5449c685 FB |
908 | * |
909 | -*/ | |
7b6a0013 | 910 | bool |
5449c685 | 911 | CARDbPowerDown( |
830a619c | 912 | void *pDeviceHandler |
5449c685 FB |
913 | ) |
914 | { | |
915 | PSDevice pDevice = (PSDevice)pDeviceHandler; | |
b6e95cd5 | 916 | unsigned int uIdx; |
5449c685 FB |
917 | |
918 | // check if already in Doze mode | |
919 | if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) | |
1b12068a | 920 | return true; |
5449c685 FB |
921 | |
922 | // Froce PSEN on | |
923 | MACvRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PSEN); | |
924 | ||
925 | // check if all TD are empty, | |
926 | ||
927 | for (uIdx = 0; uIdx < TYPE_MAXTD; uIdx ++) { | |
928 | if (pDevice->iTDUsed[uIdx] != 0) | |
5a5a2a6a | 929 | return false; |
5449c685 FB |
930 | } |
931 | ||
932 | MACvRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_GO2DOZE); | |
7e809a9b | 933 | DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Go to Doze ZZZZZZZZZZZZZZZ\n"); |
1b12068a | 934 | return true; |
5449c685 FB |
935 | } |
936 | ||
937 | /* | |
938 | * Description: Turn off Radio power | |
939 | * | |
940 | * Parameters: | |
941 | * In: | |
942 | * pDevice - The adapter to be turned off | |
943 | * Out: | |
944 | * none | |
945 | * | |
5a5a2a6a | 946 | * Return Value: true if success; otherwise false |
5449c685 FB |
947 | * |
948 | */ | |
7b6a0013 | 949 | bool CARDbRadioPowerOff (void *pDeviceHandler) |
5449c685 FB |
950 | { |
951 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
7b6a0013 | 952 | bool bResult = true; |
5449c685 | 953 | |
1b12068a CC |
954 | if (pDevice->bRadioOff == true) |
955 | return true; | |
5449c685 FB |
956 | |
957 | ||
958 | switch (pDevice->byRFType) { | |
959 | ||
960 | case RF_RFMD2959: | |
961 | MACvWordRegBitsOff(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_TXPEINV); | |
962 | MACvWordRegBitsOn(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPE1); | |
963 | break; | |
964 | ||
965 | case RF_AIROHA: | |
966 | case RF_AL2230S: | |
967 | case RF_AIROHA7230: //RobertYu:20050104 | |
968 | MACvWordRegBitsOff(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPE2); | |
969 | MACvWordRegBitsOff(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPE3); | |
970 | break; | |
971 | ||
972 | } | |
973 | ||
974 | MACvRegBitsOff(pDevice->PortOffset, MAC_REG_HOSTCR, HOSTCR_RXON); | |
975 | ||
976 | BBvSetDeepSleep(pDevice->PortOffset, pDevice->byLocalID); | |
977 | ||
1b12068a | 978 | pDevice->bRadioOff = true; |
5449c685 FB |
979 | //2007-0409-03,<Add> by chester |
980 | printk("chester power off\n"); | |
981 | MACvRegBitsOn(pDevice->PortOffset, MAC_REG_GPIOCTL0, LED_ACTSET); //LED issue | |
982 | return bResult; | |
983 | } | |
984 | ||
985 | ||
986 | /* | |
987 | * Description: Turn on Radio power | |
988 | * | |
989 | * Parameters: | |
990 | * In: | |
991 | * pDevice - The adapter to be turned on | |
992 | * Out: | |
993 | * none | |
994 | * | |
5a5a2a6a | 995 | * Return Value: true if success; otherwise false |
5449c685 FB |
996 | * |
997 | */ | |
7b6a0013 | 998 | bool CARDbRadioPowerOn (void *pDeviceHandler) |
5449c685 FB |
999 | { |
1000 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
7b6a0013 | 1001 | bool bResult = true; |
5449c685 | 1002 | printk("chester power on\n"); |
1b12068a CC |
1003 | if (pDevice->bRadioControlOff == true){ |
1004 | if (pDevice->bHWRadioOff == true) printk("chester bHWRadioOff\n"); | |
1005 | if (pDevice->bRadioControlOff == true) printk("chester bRadioControlOff\n"); | |
5a5a2a6a | 1006 | return false;} |
5449c685 | 1007 | |
5a5a2a6a | 1008 | if (pDevice->bRadioOff == false) |
5449c685 FB |
1009 | { |
1010 | printk("chester pbRadioOff\n"); | |
1b12068a | 1011 | return true;} |
5449c685 FB |
1012 | |
1013 | BBvExitDeepSleep(pDevice->PortOffset, pDevice->byLocalID); | |
1014 | ||
1015 | MACvRegBitsOn(pDevice->PortOffset, MAC_REG_HOSTCR, HOSTCR_RXON); | |
1016 | ||
1017 | switch (pDevice->byRFType) { | |
1018 | ||
1019 | case RF_RFMD2959: | |
1020 | MACvWordRegBitsOn(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_TXPEINV); | |
1021 | MACvWordRegBitsOff(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPE1); | |
1022 | break; | |
1023 | ||
1024 | case RF_AIROHA: | |
1025 | case RF_AL2230S: | |
1026 | case RF_AIROHA7230: //RobertYu:20050104 | |
1027 | MACvWordRegBitsOn(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, (SOFTPWRCTL_SWPE2 | | |
1028 | SOFTPWRCTL_SWPE3)); | |
1029 | break; | |
1030 | ||
1031 | } | |
1032 | ||
5a5a2a6a | 1033 | pDevice->bRadioOff = false; |
5449c685 FB |
1034 | // 2007-0409-03,<Add> by chester |
1035 | printk("chester power on\n"); | |
1036 | MACvRegBitsOff(pDevice->PortOffset, MAC_REG_GPIOCTL0, LED_ACTSET); //LED issue | |
1037 | return bResult; | |
1038 | } | |
1039 | ||
1040 | ||
1041 | ||
7b6a0013 | 1042 | bool CARDbRemoveKey (void *pDeviceHandler, unsigned char *pbyBSSID) |
5449c685 FB |
1043 | { |
1044 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
1045 | ||
1046 | KeybRemoveAllKey(&(pDevice->sKey), pbyBSSID, pDevice->PortOffset); | |
1b12068a | 1047 | return (true); |
5449c685 FB |
1048 | } |
1049 | ||
1050 | ||
1051 | /* | |
1052 | * | |
1053 | * Description: | |
1054 | * Add BSSID in PMKID Candidate list. | |
1055 | * | |
1056 | * Parameters: | |
1057 | * In: | |
1058 | * hDeviceContext - device structure point | |
1059 | * pbyBSSID - BSSID address for adding | |
1060 | * wRSNCap - BSS's RSN capability | |
1061 | * Out: | |
1062 | * none | |
1063 | * | |
1064 | * Return Value: none. | |
1065 | * | |
1066 | -*/ | |
7b6a0013 | 1067 | bool |
5449c685 | 1068 | CARDbAdd_PMKID_Candidate ( |
3a215e0f | 1069 | void *pDeviceHandler, |
2989e96f | 1070 | unsigned char *pbyBSSID, |
7b6a0013 | 1071 | bool bRSNCapExist, |
2986db5f | 1072 | unsigned short wRSNCap |
5449c685 FB |
1073 | ) |
1074 | { | |
1075 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
1076 | PPMKID_CANDIDATE pCandidateList; | |
b6e95cd5 | 1077 | unsigned int ii = 0; |
5449c685 | 1078 | |
7e809a9b | 1079 | DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"bAdd_PMKID_Candidate START: (%d)\n", (int)pDevice->gsPMKIDCandidate.NumCandidates); |
5449c685 FB |
1080 | |
1081 | if (pDevice->gsPMKIDCandidate.NumCandidates >= MAX_PMKIDLIST) { | |
7e809a9b | 1082 | DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"vFlush_PMKID_Candidate: 3\n"); |
51b6d9c2 | 1083 | memset(&pDevice->gsPMKIDCandidate, 0, sizeof(SPMKIDCandidateEvent)); |
5449c685 FB |
1084 | } |
1085 | ||
1086 | for (ii = 0; ii < 6; ii++) { | |
7e809a9b | 1087 | DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"%02X ", *(pbyBSSID + ii)); |
5449c685 | 1088 | } |
7e809a9b | 1089 | DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"\n"); |
5449c685 FB |
1090 | |
1091 | ||
1092 | // Update Old Candidate | |
1093 | for (ii = 0; ii < pDevice->gsPMKIDCandidate.NumCandidates; ii++) { | |
1094 | pCandidateList = &pDevice->gsPMKIDCandidate.CandidateList[ii]; | |
078b078f | 1095 | if ( !memcmp(pCandidateList->BSSID, pbyBSSID, ETH_ALEN)) { |
1b12068a | 1096 | if ((bRSNCapExist == true) && (wRSNCap & BIT0)) { |
5449c685 FB |
1097 | pCandidateList->Flags |= NDIS_802_11_PMKID_CANDIDATE_PREAUTH_ENABLED; |
1098 | } else { | |
1099 | pCandidateList->Flags &= ~(NDIS_802_11_PMKID_CANDIDATE_PREAUTH_ENABLED); | |
1100 | } | |
1b12068a | 1101 | return true; |
5449c685 FB |
1102 | } |
1103 | } | |
1104 | ||
1105 | // New Candidate | |
1106 | pCandidateList = &pDevice->gsPMKIDCandidate.CandidateList[pDevice->gsPMKIDCandidate.NumCandidates]; | |
1b12068a | 1107 | if ((bRSNCapExist == true) && (wRSNCap & BIT0)) { |
5449c685 FB |
1108 | pCandidateList->Flags |= NDIS_802_11_PMKID_CANDIDATE_PREAUTH_ENABLED; |
1109 | } else { | |
1110 | pCandidateList->Flags &= ~(NDIS_802_11_PMKID_CANDIDATE_PREAUTH_ENABLED); | |
1111 | } | |
078b078f | 1112 | memcpy(pCandidateList->BSSID, pbyBSSID, ETH_ALEN); |
5449c685 | 1113 | pDevice->gsPMKIDCandidate.NumCandidates++; |
7e809a9b | 1114 | DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"NumCandidates:%d\n", (int)pDevice->gsPMKIDCandidate.NumCandidates); |
1b12068a | 1115 | return true; |
5449c685 FB |
1116 | } |
1117 | ||
830a619c | 1118 | void * |
5449c685 | 1119 | CARDpGetCurrentAddress ( |
3a215e0f | 1120 | void *pDeviceHandler |
5449c685 FB |
1121 | ) |
1122 | { | |
1123 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
1124 | ||
1125 | return (pDevice->abyCurrentNetAddr); | |
1126 | } | |
1127 | ||
5449c685 FB |
1128 | /* |
1129 | * | |
1130 | * Description: | |
1131 | * Start Spectrum Measure defined in 802.11h | |
1132 | * | |
1133 | * Parameters: | |
1134 | * In: | |
1135 | * hDeviceContext - device structure point | |
1136 | * Out: | |
1137 | * none | |
1138 | * | |
1139 | * Return Value: none. | |
1140 | * | |
1141 | -*/ | |
7b6a0013 | 1142 | bool |
5449c685 | 1143 | CARDbStartMeasure ( |
3a215e0f CC |
1144 | void *pDeviceHandler, |
1145 | void *pvMeasureEIDs, | |
b6e95cd5 | 1146 | unsigned int uNumOfMeasureEIDs |
5449c685 FB |
1147 | ) |
1148 | { | |
1149 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
1150 | PWLAN_IE_MEASURE_REQ pEID = (PWLAN_IE_MEASURE_REQ) pvMeasureEIDs; | |
1151 | QWORD qwCurrTSF; | |
1152 | QWORD qwStartTSF; | |
7b6a0013 | 1153 | bool bExpired = true; |
2986db5f | 1154 | unsigned short wDuration = 0; |
5449c685 FB |
1155 | |
1156 | if ((pEID == NULL) || | |
1157 | (uNumOfMeasureEIDs == 0)) { | |
1b12068a | 1158 | return (true); |
5449c685 FB |
1159 | } |
1160 | CARDbGetCurrentTSF(pDevice->PortOffset, &qwCurrTSF); | |
1b12068a | 1161 | if (pDevice->bMeasureInProgress == true) { |
5a5a2a6a | 1162 | pDevice->bMeasureInProgress = false; |
5449c685 FB |
1163 | VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, pDevice->byOrgRCR); |
1164 | MACvSelectPage1(pDevice->PortOffset); | |
1165 | VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, pDevice->dwOrgMAR0); | |
1166 | VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR4, pDevice->dwOrgMAR4); | |
1167 | // clear measure control | |
1168 | MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_EN); | |
1169 | MACvSelectPage0(pDevice->PortOffset); | |
79566eb2 | 1170 | set_channel(pDevice, pDevice->byOrgChannel); |
5449c685 FB |
1171 | MACvSelectPage1(pDevice->PortOffset); |
1172 | MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE); | |
1173 | MACvSelectPage0(pDevice->PortOffset); | |
1174 | } | |
1175 | pDevice->uNumOfMeasureEIDs = uNumOfMeasureEIDs; | |
1176 | ||
1177 | do { | |
1178 | pDevice->pCurrMeasureEID = pEID; | |
1179 | pEID++; | |
1180 | pDevice->uNumOfMeasureEIDs--; | |
1181 | ||
1182 | if (pDevice->byLocalID > REV_ID_VT3253_B1) { | |
1183 | HIDWORD(qwStartTSF) = HIDWORD(*((PQWORD) (pDevice->pCurrMeasureEID->sReq.abyStartTime))); | |
1184 | LODWORD(qwStartTSF) = LODWORD(*((PQWORD) (pDevice->pCurrMeasureEID->sReq.abyStartTime))); | |
15df6c2b | 1185 | wDuration = *((unsigned short *) (pDevice->pCurrMeasureEID->sReq.abyDuration)); |
5449c685 FB |
1186 | wDuration += 1; // 1 TU for channel switching |
1187 | ||
1188 | if ((LODWORD(qwStartTSF) == 0) && (HIDWORD(qwStartTSF) == 0)) { | |
25985edc | 1189 | // start immediately by setting start TSF == current TSF + 2 TU |
5449c685 FB |
1190 | LODWORD(qwStartTSF) = LODWORD(qwCurrTSF) + 2048; |
1191 | HIDWORD(qwStartTSF) = HIDWORD(qwCurrTSF); | |
1192 | if (LODWORD(qwCurrTSF) > LODWORD(qwStartTSF)) { | |
1193 | HIDWORD(qwStartTSF)++; | |
1194 | } | |
5a5a2a6a | 1195 | bExpired = false; |
5449c685 FB |
1196 | break; |
1197 | } else { | |
1198 | // start at setting start TSF - 1TU(for channel switching) | |
1199 | if (LODWORD(qwStartTSF) < 1024) { | |
1200 | HIDWORD(qwStartTSF)--; | |
1201 | } | |
1202 | LODWORD(qwStartTSF) -= 1024; | |
1203 | } | |
1204 | ||
1205 | if ((HIDWORD(qwCurrTSF) < HIDWORD(qwStartTSF)) || | |
1206 | ((HIDWORD(qwCurrTSF) == HIDWORD(qwStartTSF)) && | |
1207 | (LODWORD(qwCurrTSF) < LODWORD(qwStartTSF))) | |
1208 | ) { | |
5a5a2a6a | 1209 | bExpired = false; |
5449c685 FB |
1210 | break; |
1211 | } | |
1212 | VNTWIFIbMeasureReport( pDevice->pMgmt, | |
5a5a2a6a | 1213 | false, |
5449c685 FB |
1214 | pDevice->pCurrMeasureEID, |
1215 | MEASURE_MODE_LATE, | |
1216 | pDevice->byBasicMap, | |
1217 | pDevice->byCCAFraction, | |
1218 | pDevice->abyRPIs | |
1219 | ); | |
1220 | } else { | |
1221 | // hardware do not support measure | |
1222 | VNTWIFIbMeasureReport( pDevice->pMgmt, | |
5a5a2a6a | 1223 | false, |
5449c685 FB |
1224 | pDevice->pCurrMeasureEID, |
1225 | MEASURE_MODE_INCAPABLE, | |
1226 | pDevice->byBasicMap, | |
1227 | pDevice->byCCAFraction, | |
1228 | pDevice->abyRPIs | |
1229 | ); | |
1230 | } | |
1231 | } while (pDevice->uNumOfMeasureEIDs != 0); | |
1232 | ||
5a5a2a6a | 1233 | if (bExpired == false) { |
5449c685 FB |
1234 | MACvSelectPage1(pDevice->PortOffset); |
1235 | VNSvOutPortD(pDevice->PortOffset + MAC_REG_MSRSTART, LODWORD(qwStartTSF)); | |
1236 | VNSvOutPortD(pDevice->PortOffset + MAC_REG_MSRSTART + 4, HIDWORD(qwStartTSF)); | |
1237 | VNSvOutPortW(pDevice->PortOffset + MAC_REG_MSRDURATION, wDuration); | |
1238 | MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_EN); | |
1239 | MACvSelectPage0(pDevice->PortOffset); | |
1240 | } else { | |
1241 | // all measure start time expired we should complete action | |
1242 | VNTWIFIbMeasureReport( pDevice->pMgmt, | |
1b12068a | 1243 | true, |
5449c685 FB |
1244 | NULL, |
1245 | 0, | |
1246 | pDevice->byBasicMap, | |
1247 | pDevice->byCCAFraction, | |
1248 | pDevice->abyRPIs | |
1249 | ); | |
1250 | } | |
1b12068a | 1251 | return (true); |
5449c685 FB |
1252 | } |
1253 | ||
1254 | ||
1255 | /* | |
1256 | * | |
1257 | * Description: | |
1258 | * Do Channel Switch defined in 802.11h | |
1259 | * | |
1260 | * Parameters: | |
1261 | * In: | |
1262 | * hDeviceContext - device structure point | |
1263 | * Out: | |
1264 | * none | |
1265 | * | |
1266 | * Return Value: none. | |
1267 | * | |
1268 | -*/ | |
7b6a0013 | 1269 | bool |
5449c685 | 1270 | CARDbChannelSwitch ( |
3a215e0f | 1271 | void *pDeviceHandler, |
3fc9b584 CC |
1272 | unsigned char byMode, |
1273 | unsigned char byNewChannel, | |
1274 | unsigned char byCount | |
5449c685 FB |
1275 | ) |
1276 | { | |
1277 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
7b6a0013 | 1278 | bool bResult = true; |
5449c685 FB |
1279 | |
1280 | if (byCount == 0) { | |
79566eb2 | 1281 | bResult = set_channel(pDevice, byNewChannel); |
5449c685 FB |
1282 | VNTWIFIbChannelSwitch(pDevice->pMgmt, byNewChannel); |
1283 | MACvSelectPage1(pDevice->PortOffset); | |
1284 | MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE); | |
1285 | MACvSelectPage0(pDevice->PortOffset); | |
1286 | return(bResult); | |
1287 | } | |
1288 | pDevice->byChannelSwitchCount = byCount; | |
1289 | pDevice->byNewChannel = byNewChannel; | |
1b12068a | 1290 | pDevice->bChannelSwitch = true; |
5449c685 FB |
1291 | if (byMode == 1) { |
1292 | bResult=CARDbStopTxPacket(pDevice, PKT_TYPE_802_11_ALL); | |
1293 | } | |
1294 | return (bResult); | |
1295 | } | |
1296 | ||
1297 | ||
1298 | /* | |
1299 | * | |
1300 | * Description: | |
1301 | * Handle Quiet EID defined in 802.11h | |
1302 | * | |
1303 | * Parameters: | |
1304 | * In: | |
1305 | * hDeviceContext - device structure point | |
1306 | * Out: | |
1307 | * none | |
1308 | * | |
1309 | * Return Value: none. | |
1310 | * | |
1311 | -*/ | |
7b6a0013 | 1312 | bool |
5449c685 | 1313 | CARDbSetQuiet ( |
3a215e0f | 1314 | void *pDeviceHandler, |
7b6a0013 | 1315 | bool bResetQuiet, |
3fc9b584 CC |
1316 | unsigned char byQuietCount, |
1317 | unsigned char byQuietPeriod, | |
2986db5f CC |
1318 | unsigned short wQuietDuration, |
1319 | unsigned short wQuietOffset | |
5449c685 FB |
1320 | ) |
1321 | { | |
1322 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
b6e95cd5 | 1323 | unsigned int ii = 0; |
5449c685 | 1324 | |
1b12068a | 1325 | if (bResetQuiet == true) { |
5449c685 FB |
1326 | MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, (MSRCTL_QUIETTXCHK | MSRCTL_QUIETEN)); |
1327 | for(ii=0;ii<MAX_QUIET_COUNT;ii++) { | |
5a5a2a6a | 1328 | pDevice->sQuiet[ii].bEnable = false; |
5449c685 FB |
1329 | } |
1330 | pDevice->uQuietEnqueue = 0; | |
5a5a2a6a CC |
1331 | pDevice->bEnableFirstQuiet = false; |
1332 | pDevice->bQuietEnable = false; | |
5449c685 FB |
1333 | pDevice->byQuietStartCount = byQuietCount; |
1334 | } | |
5a5a2a6a | 1335 | if (pDevice->sQuiet[pDevice->uQuietEnqueue].bEnable == false) { |
1b12068a | 1336 | pDevice->sQuiet[pDevice->uQuietEnqueue].bEnable = true; |
5449c685 FB |
1337 | pDevice->sQuiet[pDevice->uQuietEnqueue].byPeriod = byQuietPeriod; |
1338 | pDevice->sQuiet[pDevice->uQuietEnqueue].wDuration = wQuietDuration; | |
0f4c60d6 | 1339 | pDevice->sQuiet[pDevice->uQuietEnqueue].dwStartTime = (unsigned long) byQuietCount; |
5449c685 FB |
1340 | pDevice->sQuiet[pDevice->uQuietEnqueue].dwStartTime *= pDevice->wBeaconInterval; |
1341 | pDevice->sQuiet[pDevice->uQuietEnqueue].dwStartTime += wQuietOffset; | |
1342 | pDevice->uQuietEnqueue++; | |
1343 | pDevice->uQuietEnqueue %= MAX_QUIET_COUNT; | |
1344 | if (pDevice->byQuietStartCount < byQuietCount) { | |
1345 | pDevice->byQuietStartCount = byQuietCount; | |
1346 | } | |
1347 | } else { | |
1348 | // we can not handle Quiet EID more | |
1349 | } | |
1b12068a | 1350 | return (true); |
5449c685 FB |
1351 | } |
1352 | ||
1353 | ||
1354 | /* | |
1355 | * | |
1356 | * Description: | |
1357 | * Do Quiet, It will called by either ISR (after start) or VNTWIFI (before start) so do not need SPINLOCK | |
1358 | * | |
1359 | * Parameters: | |
1360 | * In: | |
1361 | * hDeviceContext - device structure point | |
1362 | * Out: | |
1363 | * none | |
1364 | * | |
1365 | * Return Value: none. | |
1366 | * | |
1367 | -*/ | |
7b6a0013 | 1368 | bool |
5449c685 | 1369 | CARDbStartQuiet ( |
3a215e0f | 1370 | void *pDeviceHandler |
5449c685 FB |
1371 | ) |
1372 | { | |
1373 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
b6e95cd5 | 1374 | unsigned int ii = 0; |
0f4c60d6 | 1375 | unsigned long dwStartTime = 0xFFFFFFFF; |
b6e95cd5 | 1376 | unsigned int uCurrentQuietIndex = 0; |
0f4c60d6 CC |
1377 | unsigned long dwNextTime = 0; |
1378 | unsigned long dwGap = 0; | |
1379 | unsigned long dwDuration = 0; | |
5449c685 FB |
1380 | |
1381 | for(ii=0;ii<MAX_QUIET_COUNT;ii++) { | |
1b12068a | 1382 | if ((pDevice->sQuiet[ii].bEnable == true) && |
5449c685 FB |
1383 | (dwStartTime > pDevice->sQuiet[ii].dwStartTime)) { |
1384 | dwStartTime = pDevice->sQuiet[ii].dwStartTime; | |
1385 | uCurrentQuietIndex = ii; | |
1386 | } | |
1387 | } | |
1388 | if (dwStartTime == 0xFFFFFFFF) { | |
1389 | // no more quiet | |
5a5a2a6a | 1390 | pDevice->bQuietEnable = false; |
5449c685 FB |
1391 | MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, (MSRCTL_QUIETTXCHK | MSRCTL_QUIETEN)); |
1392 | } else { | |
5a5a2a6a | 1393 | if (pDevice->bQuietEnable == false) { |
5449c685 FB |
1394 | // first quiet |
1395 | pDevice->byQuietStartCount--; | |
1396 | dwNextTime = pDevice->sQuiet[uCurrentQuietIndex].dwStartTime; | |
1397 | dwNextTime %= pDevice->wBeaconInterval; | |
1398 | MACvSelectPage1(pDevice->PortOffset); | |
2986db5f CC |
1399 | VNSvOutPortW(pDevice->PortOffset + MAC_REG_QUIETINIT, (unsigned short) dwNextTime); |
1400 | VNSvOutPortW(pDevice->PortOffset + MAC_REG_QUIETDUR, (unsigned short) pDevice->sQuiet[uCurrentQuietIndex].wDuration); | |
5449c685 | 1401 | if (pDevice->byQuietStartCount == 0) { |
5a5a2a6a | 1402 | pDevice->bEnableFirstQuiet = false; |
5449c685 FB |
1403 | MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, (MSRCTL_QUIETTXCHK | MSRCTL_QUIETEN)); |
1404 | } else { | |
1b12068a | 1405 | pDevice->bEnableFirstQuiet = true; |
5449c685 FB |
1406 | } |
1407 | MACvSelectPage0(pDevice->PortOffset); | |
1408 | } else { | |
1409 | if (pDevice->dwCurrentQuietEndTime > pDevice->sQuiet[uCurrentQuietIndex].dwStartTime) { | |
1410 | // overlap with previous Quiet | |
1411 | dwGap = pDevice->dwCurrentQuietEndTime - pDevice->sQuiet[uCurrentQuietIndex].dwStartTime; | |
1412 | if (dwGap >= pDevice->sQuiet[uCurrentQuietIndex].wDuration) { | |
5a5a2a6a CC |
1413 | // return false to indicate next quiet expired, should call this function again |
1414 | return (false); | |
5449c685 FB |
1415 | } |
1416 | dwDuration = pDevice->sQuiet[uCurrentQuietIndex].wDuration - dwGap; | |
1417 | dwGap = 0; | |
1418 | } else { | |
1419 | dwGap = pDevice->sQuiet[uCurrentQuietIndex].dwStartTime - pDevice->dwCurrentQuietEndTime; | |
1420 | dwDuration = pDevice->sQuiet[uCurrentQuietIndex].wDuration; | |
1421 | } | |
1422 | // set GAP and Next duration | |
1423 | MACvSelectPage1(pDevice->PortOffset); | |
2986db5f CC |
1424 | VNSvOutPortW(pDevice->PortOffset + MAC_REG_QUIETGAP, (unsigned short) dwGap); |
1425 | VNSvOutPortW(pDevice->PortOffset + MAC_REG_QUIETDUR, (unsigned short) dwDuration); | |
5449c685 FB |
1426 | MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_QUIETRPT); |
1427 | MACvSelectPage0(pDevice->PortOffset); | |
1428 | } | |
1b12068a | 1429 | pDevice->bQuietEnable = true; |
5449c685 FB |
1430 | pDevice->dwCurrentQuietEndTime = pDevice->sQuiet[uCurrentQuietIndex].dwStartTime; |
1431 | pDevice->dwCurrentQuietEndTime += pDevice->sQuiet[uCurrentQuietIndex].wDuration; | |
1432 | if (pDevice->sQuiet[uCurrentQuietIndex].byPeriod == 0) { | |
1433 | // not period disable current quiet element | |
5a5a2a6a | 1434 | pDevice->sQuiet[uCurrentQuietIndex].bEnable = false; |
5449c685 FB |
1435 | } else { |
1436 | // set next period start time | |
0f4c60d6 | 1437 | dwNextTime = (unsigned long) pDevice->sQuiet[uCurrentQuietIndex].byPeriod; |
5449c685 FB |
1438 | dwNextTime *= pDevice->wBeaconInterval; |
1439 | pDevice->sQuiet[uCurrentQuietIndex].dwStartTime = dwNextTime; | |
1440 | } | |
1441 | if (pDevice->dwCurrentQuietEndTime > 0x80010000) { | |
1442 | // decreament all time to avoid wrap around | |
1443 | for(ii=0;ii<MAX_QUIET_COUNT;ii++) { | |
1b12068a | 1444 | if (pDevice->sQuiet[ii].bEnable == true) { |
5449c685 FB |
1445 | pDevice->sQuiet[ii].dwStartTime -= 0x80000000; |
1446 | } | |
1447 | } | |
1448 | pDevice->dwCurrentQuietEndTime -= 0x80000000; | |
1449 | } | |
1450 | } | |
1b12068a | 1451 | return (true); |
5449c685 FB |
1452 | } |
1453 | ||
5449c685 FB |
1454 | /* |
1455 | * | |
1456 | * Description: | |
1457 | * Set Local Power Constraint | |
1458 | * | |
1459 | * Parameters: | |
1460 | * In: | |
1461 | * hDeviceContext - device structure point | |
1462 | * Out: | |
1463 | * none | |
1464 | * | |
1465 | * Return Value: none. | |
1466 | * | |
1467 | -*/ | |
6b35b7b3 | 1468 | void |
5449c685 | 1469 | CARDvSetPowerConstraint ( |
3a215e0f | 1470 | void *pDeviceHandler, |
3fc9b584 | 1471 | unsigned char byChannel, |
ec28c7fa | 1472 | char byPower |
5449c685 FB |
1473 | ) |
1474 | { | |
1475 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
1476 | ||
1477 | if (byChannel > CB_MAX_CHANNEL_24G) { | |
1b12068a | 1478 | if (pDevice->bCountryInfo5G == true) { |
5449c685 FB |
1479 | pDevice->abyLocalPwr[byChannel] = pDevice->abyRegPwr[byChannel] - byPower; |
1480 | } | |
1481 | } else { | |
1b12068a | 1482 | if (pDevice->bCountryInfo24G == true) { |
5449c685 FB |
1483 | pDevice->abyLocalPwr[byChannel] = pDevice->abyRegPwr[byChannel] - byPower; |
1484 | } | |
1485 | } | |
1486 | } | |
1487 | ||
1488 | ||
1489 | /* | |
1490 | * | |
1491 | * Description: | |
1492 | * Set Local Power Constraint | |
1493 | * | |
1494 | * Parameters: | |
1495 | * In: | |
1496 | * hDeviceContext - device structure point | |
1497 | * Out: | |
1498 | * none | |
1499 | * | |
1500 | * Return Value: none. | |
1501 | * | |
1502 | -*/ | |
6b35b7b3 | 1503 | void |
5449c685 | 1504 | CARDvGetPowerCapability ( |
3a215e0f | 1505 | void *pDeviceHandler, |
2989e96f CC |
1506 | unsigned char *pbyMinPower, |
1507 | unsigned char *pbyMaxPower | |
5449c685 FB |
1508 | ) |
1509 | { | |
1510 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
3fc9b584 | 1511 | unsigned char byDec = 0; |
5449c685 FB |
1512 | |
1513 | *pbyMaxPower = pDevice->abyOFDMDefaultPwr[pDevice->byCurrentCh]; | |
1514 | byDec = pDevice->abyOFDMPwrTbl[pDevice->byCurrentCh]; | |
1515 | if (pDevice->byRFType == RF_UW2452) { | |
1516 | byDec *= 3; | |
1517 | byDec >>= 1; | |
1518 | } else { | |
1519 | byDec <<= 1; | |
1520 | } | |
1521 | *pbyMinPower = pDevice->abyOFDMDefaultPwr[pDevice->byCurrentCh] - byDec; | |
1522 | } | |
1523 | ||
5449c685 FB |
1524 | /* |
1525 | * | |
1526 | * Description: | |
1527 | * Get Current Tx Power | |
1528 | * | |
1529 | * Parameters: | |
1530 | * In: | |
1531 | * hDeviceContext - device structure point | |
1532 | * Out: | |
1533 | * none | |
1534 | * | |
1535 | * Return Value: none. | |
1536 | * | |
79566eb2 | 1537 | */ |
ec28c7fa | 1538 | char |
5449c685 | 1539 | CARDbyGetTransmitPower ( |
3a215e0f | 1540 | void *pDeviceHandler |
5449c685 FB |
1541 | ) |
1542 | { | |
1543 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
1544 | ||
1545 | return (pDevice->byCurPwrdBm); | |
1546 | } | |
1547 | ||
5449c685 | 1548 | //xxx |
6b35b7b3 | 1549 | void |
5449c685 | 1550 | CARDvSafeResetTx ( |
3a215e0f | 1551 | void *pDeviceHandler |
5449c685 FB |
1552 | ) |
1553 | { | |
1554 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
b6e95cd5 | 1555 | unsigned int uu; |
5449c685 FB |
1556 | PSTxDesc pCurrTD; |
1557 | ||
1558 | // initialize TD index | |
1559 | pDevice->apTailTD[0] = pDevice->apCurrTD[0] = &(pDevice->apTD0Rings[0]); | |
1560 | pDevice->apTailTD[1] = pDevice->apCurrTD[1] = &(pDevice->apTD1Rings[0]); | |
1561 | ||
1562 | for (uu = 0; uu < TYPE_MAXTD; uu ++) | |
1563 | pDevice->iTDUsed[uu] = 0; | |
1564 | ||
1565 | for (uu = 0; uu < pDevice->sOpts.nTxDescs[0]; uu++) { | |
1566 | pCurrTD = &(pDevice->apTD0Rings[uu]); | |
1567 | pCurrTD->m_td0TD0.f1Owner = OWNED_BY_HOST; | |
1568 | // init all Tx Packet pointer to NULL | |
1569 | } | |
1570 | for (uu = 0; uu < pDevice->sOpts.nTxDescs[1]; uu++) { | |
1571 | pCurrTD = &(pDevice->apTD1Rings[uu]); | |
1572 | pCurrTD->m_td0TD0.f1Owner = OWNED_BY_HOST; | |
1573 | // init all Tx Packet pointer to NULL | |
1574 | } | |
1575 | ||
1576 | // set MAC TD pointer | |
1577 | MACvSetCurrTXDescAddr(TYPE_TXDMA0, pDevice->PortOffset, | |
1578 | (pDevice->td0_pool_dma)); | |
1579 | ||
1580 | MACvSetCurrTXDescAddr(TYPE_AC0DMA, pDevice->PortOffset, | |
1581 | (pDevice->td1_pool_dma)); | |
1582 | ||
1583 | // set MAC Beacon TX pointer | |
1584 | MACvSetCurrBCNTxDescAddr(pDevice->PortOffset, | |
1585 | (pDevice->tx_beacon_dma)); | |
1586 | ||
1587 | } | |
1588 | ||
1589 | ||
1590 | ||
1591 | /*+ | |
1592 | * | |
1593 | * Description: | |
1594 | * Reset Rx | |
1595 | * | |
1596 | * Parameters: | |
1597 | * In: | |
1598 | * pDevice - Pointer to the adapter | |
1599 | * Out: | |
1600 | * none | |
1601 | * | |
1602 | * Return Value: none | |
1603 | * | |
1604 | -*/ | |
6b35b7b3 | 1605 | void |
5449c685 | 1606 | CARDvSafeResetRx ( |
3a215e0f | 1607 | void *pDeviceHandler |
5449c685 FB |
1608 | ) |
1609 | { | |
1610 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
b6e95cd5 | 1611 | unsigned int uu; |
5449c685 FB |
1612 | PSRxDesc pDesc; |
1613 | ||
1614 | ||
1615 | ||
1616 | // initialize RD index | |
1617 | pDevice->pCurrRD[0]=&(pDevice->aRD0Ring[0]); | |
1618 | pDevice->pCurrRD[1]=&(pDevice->aRD1Ring[0]); | |
1619 | ||
1620 | // init state, all RD is chip's | |
1621 | for (uu = 0; uu < pDevice->sOpts.nRxDescs0; uu++) { | |
1622 | pDesc =&(pDevice->aRD0Ring[uu]); | |
2986db5f | 1623 | pDesc->m_rd0RD0.wResCount = (unsigned short)(pDevice->rx_buf_sz); |
5449c685 | 1624 | pDesc->m_rd0RD0.f1Owner=OWNED_BY_NIC; |
2986db5f | 1625 | pDesc->m_rd1RD1.wReqCount = (unsigned short)(pDevice->rx_buf_sz); |
5449c685 FB |
1626 | } |
1627 | ||
1628 | // init state, all RD is chip's | |
1629 | for (uu = 0; uu < pDevice->sOpts.nRxDescs1; uu++) { | |
1630 | pDesc =&(pDevice->aRD1Ring[uu]); | |
2986db5f | 1631 | pDesc->m_rd0RD0.wResCount = (unsigned short)(pDevice->rx_buf_sz); |
5449c685 | 1632 | pDesc->m_rd0RD0.f1Owner=OWNED_BY_NIC; |
2986db5f | 1633 | pDesc->m_rd1RD1.wReqCount = (unsigned short)(pDevice->rx_buf_sz); |
5449c685 FB |
1634 | } |
1635 | ||
1636 | pDevice->cbDFCB = CB_MAX_RX_FRAG; | |
1637 | pDevice->cbFreeDFCB = pDevice->cbDFCB; | |
1638 | ||
1639 | // set perPkt mode | |
1640 | MACvRx0PerPktMode(pDevice->PortOffset); | |
1641 | MACvRx1PerPktMode(pDevice->PortOffset); | |
1642 | // set MAC RD pointer | |
1643 | MACvSetCurrRx0DescAddr(pDevice->PortOffset, | |
1644 | pDevice->rd0_pool_dma); | |
1645 | ||
1646 | MACvSetCurrRx1DescAddr(pDevice->PortOffset, | |
1647 | pDevice->rd1_pool_dma); | |
1648 | } | |
1649 | ||
1650 | ||
1651 | ||
1652 | ||
1653 | /* | |
1654 | * Description: Get response Control frame rate in CCK mode | |
1655 | * | |
1656 | * Parameters: | |
1657 | * In: | |
1658 | * pDevice - The adapter to be set | |
1659 | * wRateIdx - Receiving data rate | |
1660 | * Out: | |
1661 | * none | |
1662 | * | |
1663 | * Return Value: response Control frame rate | |
1664 | * | |
1665 | */ | |
2986db5f | 1666 | unsigned short CARDwGetCCKControlRate(void *pDeviceHandler, unsigned short wRateIdx) |
5449c685 FB |
1667 | { |
1668 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
b6e95cd5 | 1669 | unsigned int ui = (unsigned int) wRateIdx; |
5449c685 FB |
1670 | |
1671 | while (ui > RATE_1M) { | |
2986db5f CC |
1672 | if (pDevice->wBasicRate & ((unsigned short)1 << ui)) { |
1673 | return (unsigned short)ui; | |
5449c685 FB |
1674 | } |
1675 | ui --; | |
1676 | } | |
2986db5f | 1677 | return (unsigned short)RATE_1M; |
5449c685 FB |
1678 | } |
1679 | ||
1680 | /* | |
1681 | * Description: Get response Control frame rate in OFDM mode | |
1682 | * | |
1683 | * Parameters: | |
1684 | * In: | |
1685 | * pDevice - The adapter to be set | |
1686 | * wRateIdx - Receiving data rate | |
1687 | * Out: | |
1688 | * none | |
1689 | * | |
1690 | * Return Value: response Control frame rate | |
1691 | * | |
1692 | */ | |
2986db5f | 1693 | unsigned short CARDwGetOFDMControlRate (void *pDeviceHandler, unsigned short wRateIdx) |
5449c685 FB |
1694 | { |
1695 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
b6e95cd5 | 1696 | unsigned int ui = (unsigned int) wRateIdx; |
5449c685 | 1697 | |
7e809a9b | 1698 | DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"BASIC RATE: %X\n", pDevice->wBasicRate); |
5449c685 | 1699 | |
830a619c | 1700 | if (!CARDbIsOFDMinBasicRate((void *)pDevice)) { |
7e809a9b | 1701 | DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"CARDwGetOFDMControlRate:(NO OFDM) %d\n", wRateIdx); |
5449c685 FB |
1702 | if (wRateIdx > RATE_24M) |
1703 | wRateIdx = RATE_24M; | |
1704 | return wRateIdx; | |
1705 | } | |
1706 | while (ui > RATE_11M) { | |
2986db5f | 1707 | if (pDevice->wBasicRate & ((unsigned short)1 << ui)) { |
7e809a9b | 1708 | DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"CARDwGetOFDMControlRate : %d\n", ui); |
2986db5f | 1709 | return (unsigned short)ui; |
5449c685 FB |
1710 | } |
1711 | ui --; | |
1712 | } | |
7e809a9b | 1713 | DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"CARDwGetOFDMControlRate: 6M\n"); |
2986db5f | 1714 | return (unsigned short)RATE_24M; |
5449c685 FB |
1715 | } |
1716 | ||
1717 | ||
1718 | /* | |
1719 | * Description: Set RSPINF | |
1720 | * | |
1721 | * Parameters: | |
1722 | * In: | |
1723 | * pDevice - The adapter to be set | |
1724 | * Out: | |
1725 | * none | |
1726 | * | |
1727 | * Return Value: None. | |
1728 | * | |
1729 | */ | |
830a619c | 1730 | void CARDvSetRSPINF (void *pDeviceHandler, CARD_PHY_TYPE ePHYType) |
5449c685 FB |
1731 | { |
1732 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
3fc9b584 | 1733 | unsigned char byServ = 0x00, bySignal = 0x00; //For CCK |
2986db5f | 1734 | unsigned short wLen = 0x0000; |
3fc9b584 | 1735 | unsigned char byTxRate, byRsvTime; //For OFDM |
5449c685 FB |
1736 | |
1737 | //Set to Page1 | |
1738 | MACvSelectPage1(pDevice->PortOffset); | |
1739 | ||
1740 | //RSPINF_b_1 | |
1741 | BBvCaculateParameter(pDevice, | |
1742 | 14, | |
830a619c | 1743 | CARDwGetCCKControlRate((void *)pDevice, RATE_1M), |
5449c685 FB |
1744 | PK_TYPE_11B, |
1745 | &wLen, | |
1746 | &byServ, | |
1747 | &bySignal | |
1748 | ); | |
1749 | ||
1750 | VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_1, MAKEDWORD(wLen,MAKEWORD(bySignal,byServ))); | |
1751 | ///RSPINF_b_2 | |
1752 | BBvCaculateParameter(pDevice, | |
1753 | 14, | |
830a619c | 1754 | CARDwGetCCKControlRate((void *)pDevice, RATE_2M), |
5449c685 FB |
1755 | PK_TYPE_11B, |
1756 | &wLen, | |
1757 | &byServ, | |
1758 | &bySignal | |
1759 | ); | |
1760 | ||
1761 | VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_2, MAKEDWORD(wLen,MAKEWORD(bySignal,byServ))); | |
1762 | //RSPINF_b_5 | |
1763 | BBvCaculateParameter(pDevice, | |
1764 | 14, | |
830a619c | 1765 | CARDwGetCCKControlRate((void *)pDevice, RATE_5M), |
5449c685 FB |
1766 | PK_TYPE_11B, |
1767 | &wLen, | |
1768 | &byServ, | |
1769 | &bySignal | |
1770 | ); | |
1771 | ||
1772 | VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_5, MAKEDWORD(wLen,MAKEWORD(bySignal,byServ))); | |
1773 | //RSPINF_b_11 | |
1774 | BBvCaculateParameter(pDevice, | |
1775 | 14, | |
830a619c | 1776 | CARDwGetCCKControlRate((void *)pDevice, RATE_11M), |
5449c685 FB |
1777 | PK_TYPE_11B, |
1778 | &wLen, | |
1779 | &byServ, | |
1780 | &bySignal | |
1781 | ); | |
1782 | ||
1783 | VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_11, MAKEDWORD(wLen,MAKEWORD(bySignal,byServ))); | |
1784 | //RSPINF_a_6 | |
1785 | s_vCaculateOFDMRParameter(RATE_6M, | |
1786 | ePHYType, | |
1787 | &byTxRate, | |
1788 | &byRsvTime); | |
1789 | VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_6, MAKEWORD(byTxRate,byRsvTime)); | |
1790 | //RSPINF_a_9 | |
1791 | s_vCaculateOFDMRParameter(RATE_9M, | |
1792 | ePHYType, | |
1793 | &byTxRate, | |
1794 | &byRsvTime); | |
1795 | VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_9, MAKEWORD(byTxRate,byRsvTime)); | |
1796 | //RSPINF_a_12 | |
1797 | s_vCaculateOFDMRParameter(RATE_12M, | |
1798 | ePHYType, | |
1799 | &byTxRate, | |
1800 | &byRsvTime); | |
1801 | VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_12, MAKEWORD(byTxRate,byRsvTime)); | |
1802 | //RSPINF_a_18 | |
1803 | s_vCaculateOFDMRParameter(RATE_18M, | |
1804 | ePHYType, | |
1805 | &byTxRate, | |
1806 | &byRsvTime); | |
1807 | VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_18, MAKEWORD(byTxRate,byRsvTime)); | |
1808 | //RSPINF_a_24 | |
1809 | s_vCaculateOFDMRParameter(RATE_24M, | |
1810 | ePHYType, | |
1811 | &byTxRate, | |
1812 | &byRsvTime); | |
1813 | VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_24, MAKEWORD(byTxRate,byRsvTime)); | |
1814 | //RSPINF_a_36 | |
830a619c | 1815 | s_vCaculateOFDMRParameter(CARDwGetOFDMControlRate((void *)pDevice, RATE_36M), |
5449c685 FB |
1816 | ePHYType, |
1817 | &byTxRate, | |
1818 | &byRsvTime); | |
1819 | VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_36, MAKEWORD(byTxRate,byRsvTime)); | |
1820 | //RSPINF_a_48 | |
830a619c | 1821 | s_vCaculateOFDMRParameter(CARDwGetOFDMControlRate((void *)pDevice, RATE_48M), |
5449c685 FB |
1822 | ePHYType, |
1823 | &byTxRate, | |
1824 | &byRsvTime); | |
1825 | VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_48, MAKEWORD(byTxRate,byRsvTime)); | |
1826 | //RSPINF_a_54 | |
830a619c | 1827 | s_vCaculateOFDMRParameter(CARDwGetOFDMControlRate((void *)pDevice, RATE_54M), |
5449c685 FB |
1828 | ePHYType, |
1829 | &byTxRate, | |
1830 | &byRsvTime); | |
1831 | VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_54, MAKEWORD(byTxRate,byRsvTime)); | |
1832 | ||
1833 | //RSPINF_a_72 | |
830a619c | 1834 | s_vCaculateOFDMRParameter(CARDwGetOFDMControlRate((void *)pDevice, RATE_54M), |
5449c685 FB |
1835 | ePHYType, |
1836 | &byTxRate, | |
1837 | &byRsvTime); | |
1838 | VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_72, MAKEWORD(byTxRate,byRsvTime)); | |
1839 | //Set to Page0 | |
1840 | MACvSelectPage0(pDevice->PortOffset); | |
1841 | } | |
1842 | ||
1843 | /* | |
1844 | * Description: Update IFS | |
1845 | * | |
1846 | * Parameters: | |
1847 | * In: | |
1848 | * pDevice - The adapter to be set | |
1849 | * Out: | |
1850 | * none | |
1851 | * | |
1852 | * Return Value: None. | |
1853 | * | |
1854 | */ | |
830a619c | 1855 | void vUpdateIFS (void *pDeviceHandler) |
5449c685 FB |
1856 | { |
1857 | //Set SIFS, DIFS, EIFS, SlotTime, CwMin | |
1858 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
1859 | ||
3fc9b584 | 1860 | unsigned char byMaxMin = 0; |
5449c685 FB |
1861 | if (pDevice->byPacketType==PK_TYPE_11A) {//0000 0000 0000 0000,11a |
1862 | pDevice->uSlot = C_SLOT_SHORT; | |
1863 | pDevice->uSIFS = C_SIFS_A; | |
1864 | pDevice->uDIFS = C_SIFS_A + 2*C_SLOT_SHORT; | |
1865 | pDevice->uCwMin = C_CWMIN_A; | |
1866 | byMaxMin = 4; | |
1867 | } | |
1868 | else if (pDevice->byPacketType==PK_TYPE_11B) {//0000 0001 0000 0000,11b | |
1869 | pDevice->uSlot = C_SLOT_LONG; | |
1870 | pDevice->uSIFS = C_SIFS_BG; | |
1871 | pDevice->uDIFS = C_SIFS_BG + 2*C_SLOT_LONG; | |
1872 | pDevice->uCwMin = C_CWMIN_B; | |
1873 | byMaxMin = 5; | |
1874 | } | |
1875 | else { // PK_TYPE_11GA & PK_TYPE_11GB | |
1876 | pDevice->uSIFS = C_SIFS_BG; | |
1877 | if (pDevice->bShortSlotTime) { | |
1878 | pDevice->uSlot = C_SLOT_SHORT; | |
1879 | } else { | |
1880 | pDevice->uSlot = C_SLOT_LONG; | |
1881 | } | |
1882 | pDevice->uDIFS = C_SIFS_BG + 2*pDevice->uSlot; | |
1883 | if (pDevice->wBasicRate & 0x0150) { //0000 0001 0101 0000,24M,12M,6M | |
1884 | pDevice->uCwMin = C_CWMIN_A; | |
1885 | byMaxMin = 4; | |
1886 | } | |
1887 | else { | |
1888 | pDevice->uCwMin = C_CWMIN_B; | |
1889 | byMaxMin = 5; | |
1890 | } | |
1891 | } | |
1892 | ||
1893 | pDevice->uCwMax = C_CWMAX; | |
1894 | pDevice->uEIFS = C_EIFS; | |
1895 | if (pDevice->byRFType == RF_RFMD2959) { | |
1896 | // bcs TX_PE will reserve 3 us | |
3fc9b584 CC |
1897 | VNSvOutPortB(pDevice->PortOffset + MAC_REG_SIFS, (unsigned char)(pDevice->uSIFS - 3)); |
1898 | VNSvOutPortB(pDevice->PortOffset + MAC_REG_DIFS, (unsigned char)(pDevice->uDIFS - 3)); | |
5449c685 | 1899 | } else { |
3fc9b584 CC |
1900 | VNSvOutPortB(pDevice->PortOffset + MAC_REG_SIFS, (unsigned char)pDevice->uSIFS); |
1901 | VNSvOutPortB(pDevice->PortOffset + MAC_REG_DIFS, (unsigned char)pDevice->uDIFS); | |
5449c685 | 1902 | } |
3fc9b584 CC |
1903 | VNSvOutPortB(pDevice->PortOffset + MAC_REG_EIFS, (unsigned char)pDevice->uEIFS); |
1904 | VNSvOutPortB(pDevice->PortOffset + MAC_REG_SLOT, (unsigned char)pDevice->uSlot); | |
5449c685 | 1905 | byMaxMin |= 0xA0;//1010 1111,C_CWMAX = 1023 |
3fc9b584 | 1906 | VNSvOutPortB(pDevice->PortOffset + MAC_REG_CWMAXMIN0, (unsigned char)byMaxMin); |
5449c685 FB |
1907 | } |
1908 | ||
830a619c | 1909 | void CARDvUpdateBasicTopRate (void *pDeviceHandler) |
5449c685 FB |
1910 | { |
1911 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
3fc9b584 CC |
1912 | unsigned char byTopOFDM = RATE_24M, byTopCCK = RATE_1M; |
1913 | unsigned char ii; | |
5449c685 FB |
1914 | |
1915 | //Determines the highest basic rate. | |
1916 | for (ii = RATE_54M; ii >= RATE_6M; ii --) { | |
2986db5f | 1917 | if ( (pDevice->wBasicRate) & ((unsigned short)(1<<ii)) ) { |
5449c685 FB |
1918 | byTopOFDM = ii; |
1919 | break; | |
cd9d25ba | 1920 | } |
5449c685 FB |
1921 | } |
1922 | pDevice->byTopOFDMBasicRate = byTopOFDM; | |
1923 | ||
1924 | for (ii = RATE_11M;; ii --) { | |
2986db5f | 1925 | if ( (pDevice->wBasicRate) & ((unsigned short)(1<<ii)) ) { |
5449c685 FB |
1926 | byTopCCK = ii; |
1927 | break; | |
cd9d25ba | 1928 | } |
5449c685 FB |
1929 | if (ii == RATE_1M) |
1930 | break; | |
1931 | } | |
1932 | pDevice->byTopCCKBasicRate = byTopCCK; | |
1933 | } | |
1934 | ||
1935 | ||
1936 | /* | |
1937 | * Description: Set NIC Tx Basic Rate | |
1938 | * | |
1939 | * Parameters: | |
1940 | * In: | |
1941 | * pDevice - The adapter to be set | |
1942 | * wBasicRate - Basic Rate to be set | |
1943 | * Out: | |
1944 | * none | |
1945 | * | |
5a5a2a6a | 1946 | * Return Value: true if succeeded; false if failed. |
5449c685 FB |
1947 | * |
1948 | */ | |
7b6a0013 | 1949 | bool CARDbAddBasicRate (void *pDeviceHandler, unsigned short wRateIdx) |
5449c685 FB |
1950 | { |
1951 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
2986db5f | 1952 | unsigned short wRate = (unsigned short)(1<<wRateIdx); |
5449c685 FB |
1953 | |
1954 | pDevice->wBasicRate |= wRate; | |
1955 | ||
1956 | //Determines the highest basic rate. | |
830a619c | 1957 | CARDvUpdateBasicTopRate((void *)pDevice); |
5449c685 | 1958 | |
1b12068a | 1959 | return(true); |
5449c685 FB |
1960 | } |
1961 | ||
7b6a0013 | 1962 | bool CARDbIsOFDMinBasicRate (void *pDeviceHandler) |
5449c685 FB |
1963 | { |
1964 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
1965 | int ii; | |
1966 | ||
1967 | for (ii = RATE_54M; ii >= RATE_6M; ii --) { | |
2986db5f | 1968 | if ((pDevice->wBasicRate) & ((unsigned short)(1<<ii))) |
1b12068a | 1969 | return true; |
5449c685 | 1970 | } |
5a5a2a6a | 1971 | return false; |
5449c685 FB |
1972 | } |
1973 | ||
3fc9b584 | 1974 | unsigned char CARDbyGetPktType (void *pDeviceHandler) |
5449c685 FB |
1975 | { |
1976 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
1977 | ||
1978 | if (pDevice->byBBType == BB_TYPE_11A || pDevice->byBBType == BB_TYPE_11B) { | |
3fc9b584 | 1979 | return (unsigned char)pDevice->byBBType; |
5449c685 | 1980 | } |
830a619c | 1981 | else if (CARDbIsOFDMinBasicRate((void *)pDevice)) { |
5449c685 FB |
1982 | return PK_TYPE_11GA; |
1983 | } | |
1984 | else { | |
1985 | return PK_TYPE_11GB; | |
1986 | } | |
1987 | } | |
1988 | ||
1989 | /* | |
1990 | * Description: Set NIC Loopback mode | |
1991 | * | |
1992 | * Parameters: | |
1993 | * In: | |
1994 | * pDevice - The adapter to be set | |
1995 | * wLoopbackMode - Loopback mode to be set | |
1996 | * Out: | |
1997 | * none | |
1998 | * | |
1999 | * Return Value: none | |
2000 | * | |
2001 | */ | |
2986db5f | 2002 | void CARDvSetLoopbackMode (unsigned long dwIoBase, unsigned short wLoopbackMode) |
5449c685 FB |
2003 | { |
2004 | switch(wLoopbackMode) { | |
2005 | case CARD_LB_NONE: | |
2006 | case CARD_LB_MAC: | |
2007 | case CARD_LB_PHY: | |
2008 | break; | |
2009 | default: | |
5a5a2a6a | 2010 | ASSERT(false); |
5449c685 FB |
2011 | break; |
2012 | } | |
2013 | // set MAC loopback | |
2014 | MACvSetLoopbackMode(dwIoBase, LOBYTE(wLoopbackMode)); | |
2015 | // set Baseband loopback | |
2016 | } | |
2017 | ||
2018 | ||
2019 | /* | |
2020 | * Description: Software Reset NIC | |
2021 | * | |
2022 | * Parameters: | |
2023 | * In: | |
2024 | * pDevice - The adapter to be reset | |
2025 | * Out: | |
2026 | * none | |
2027 | * | |
2028 | * Return Value: none | |
2029 | * | |
2030 | */ | |
7b6a0013 | 2031 | bool CARDbSoftwareReset (void *pDeviceHandler) |
5449c685 FB |
2032 | { |
2033 | PSDevice pDevice = (PSDevice) pDeviceHandler; | |
2034 | ||
2035 | // reset MAC | |
2036 | if (!MACbSafeSoftwareReset(pDevice->PortOffset)) | |
5a5a2a6a | 2037 | return false; |
5449c685 | 2038 | |
1b12068a | 2039 | return true; |
5449c685 FB |
2040 | } |
2041 | ||
2042 | ||
2043 | /* | |
2044 | * Description: Caculate TSF offset of two TSF input | |
2045 | * Get TSF Offset from RxBCN's TSF and local TSF | |
2046 | * | |
2047 | * Parameters: | |
2048 | * In: | |
2049 | * pDevice - The adapter to be sync. | |
2050 | * qwTSF1 - Rx BCN's TSF | |
2051 | * qwTSF2 - Local TSF | |
2052 | * Out: | |
2053 | * none | |
2054 | * | |
2055 | * Return Value: TSF Offset value | |
2056 | * | |
2057 | */ | |
3fc9b584 | 2058 | QWORD CARDqGetTSFOffset (unsigned char byRxRate, QWORD qwTSF1, QWORD qwTSF2) |
5449c685 FB |
2059 | { |
2060 | QWORD qwTSFOffset; | |
859171ca | 2061 | unsigned short wRxBcnTSFOffst= 0; |
5449c685 FB |
2062 | |
2063 | HIDWORD(qwTSFOffset) = 0; | |
2064 | LODWORD(qwTSFOffset) = 0; | |
2065 | wRxBcnTSFOffst = cwRXBCNTSFOff[byRxRate%MAX_RATE]; | |
0f4c60d6 CC |
2066 | (qwTSF2).u.dwLowDword += (unsigned long)(wRxBcnTSFOffst); |
2067 | if ((qwTSF2).u.dwLowDword < (unsigned long)(wRxBcnTSFOffst)) { | |
5449c685 FB |
2068 | (qwTSF2).u.dwHighDword++; |
2069 | } | |
2070 | LODWORD(qwTSFOffset) = LODWORD(qwTSF1) - LODWORD(qwTSF2); | |
2071 | if (LODWORD(qwTSF1) < LODWORD(qwTSF2)) { | |
2072 | // if borrow needed | |
2073 | HIDWORD(qwTSFOffset) = HIDWORD(qwTSF1) - HIDWORD(qwTSF2) - 1 ; | |
2074 | } | |
2075 | else { | |
2076 | HIDWORD(qwTSFOffset) = HIDWORD(qwTSF1) - HIDWORD(qwTSF2); | |
2077 | }; | |
2078 | return (qwTSFOffset); | |
2079 | } | |
2080 | ||
2081 | ||
2082 | /* | |
2083 | * Description: Read NIC TSF counter | |
2084 | * Get local TSF counter | |
2085 | * | |
2086 | * Parameters: | |
2087 | * In: | |
2088 | * pDevice - The adapter to be read | |
2089 | * Out: | |
2090 | * qwCurrTSF - Current TSF counter | |
2091 | * | |
5a5a2a6a | 2092 | * Return Value: true if success; otherwise false |
5449c685 FB |
2093 | * |
2094 | */ | |
7b6a0013 | 2095 | bool CARDbGetCurrentTSF (unsigned long dwIoBase, PQWORD pqwCurrTSF) |
5449c685 | 2096 | { |
2986db5f | 2097 | unsigned short ww; |
3fc9b584 | 2098 | unsigned char byData; |
5449c685 FB |
2099 | |
2100 | MACvRegBitsOn(dwIoBase, MAC_REG_TFTCTL, TFTCTL_TSFCNTRRD); | |
2101 | for (ww = 0; ww < W_MAX_TIMEOUT; ww++) { | |
2102 | VNSvInPortB(dwIoBase + MAC_REG_TFTCTL, &byData); | |
256a816b | 2103 | if ( !(byData & TFTCTL_TSFCNTRRD)) |
5449c685 FB |
2104 | break; |
2105 | } | |
2106 | if (ww == W_MAX_TIMEOUT) | |
5a5a2a6a | 2107 | return(false); |
5449c685 FB |
2108 | VNSvInPortD(dwIoBase + MAC_REG_TSFCNTR, &LODWORD(*pqwCurrTSF)); |
2109 | VNSvInPortD(dwIoBase + MAC_REG_TSFCNTR + 4, &HIDWORD(*pqwCurrTSF)); | |
2110 | ||
1b12068a | 2111 | return(true); |
5449c685 FB |
2112 | } |
2113 | ||
2114 | ||
2115 | /* | |
2116 | * Description: Read NIC TSF counter | |
2117 | * Get NEXTTBTT from adjusted TSF and Beacon Interval | |
2118 | * | |
2119 | * Parameters: | |
2120 | * In: | |
2121 | * qwTSF - Current TSF counter | |
2122 | * wbeaconInterval - Beacon Interval | |
2123 | * Out: | |
2124 | * qwCurrTSF - Current TSF counter | |
2125 | * | |
2126 | * Return Value: TSF value of next Beacon | |
2127 | * | |
2128 | */ | |
2986db5f | 2129 | QWORD CARDqGetNextTBTT (QWORD qwTSF, unsigned short wBeaconInterval) |
5449c685 FB |
2130 | { |
2131 | ||
b6e95cd5 CC |
2132 | unsigned int uLowNextTBTT; |
2133 | unsigned int uHighRemain, uLowRemain; | |
2134 | unsigned int uBeaconInterval; | |
5449c685 FB |
2135 | |
2136 | uBeaconInterval = wBeaconInterval * 1024; | |
2137 | // Next TBTT = ((local_current_TSF / beacon_interval) + 1 ) * beacon_interval | |
2138 | uLowNextTBTT = (LODWORD(qwTSF) >> 10) << 10; | |
2139 | // low dword (mod) bcn | |
2140 | uLowRemain = (uLowNextTBTT) % uBeaconInterval; | |
2141 | // uHighRemain = ((0x80000000 % uBeaconInterval)* 2 * HIDWORD(qwTSF)) | |
2142 | // % uBeaconInterval; | |
2143 | // high dword (mod) bcn | |
2144 | uHighRemain = (((0xffffffff % uBeaconInterval) + 1) * HIDWORD(qwTSF)) | |
2145 | % uBeaconInterval; | |
2146 | uLowRemain = (uHighRemain + uLowRemain) % uBeaconInterval; | |
2147 | uLowRemain = uBeaconInterval - uLowRemain; | |
2148 | ||
2149 | // check if carry when add one beacon interval | |
2150 | if ((~uLowNextTBTT) < uLowRemain) | |
2151 | HIDWORD(qwTSF) ++ ; | |
2152 | ||
2153 | LODWORD(qwTSF) = uLowNextTBTT + uLowRemain; | |
2154 | ||
2155 | return (qwTSF); | |
2156 | } | |
2157 | ||
2158 | ||
2159 | /* | |
2160 | * Description: Set NIC TSF counter for first Beacon time | |
2161 | * Get NEXTTBTT from adjusted TSF and Beacon Interval | |
2162 | * | |
2163 | * Parameters: | |
2164 | * In: | |
2165 | * dwIoBase - IO Base | |
2166 | * wBeaconInterval - Beacon Interval | |
2167 | * Out: | |
2168 | * none | |
2169 | * | |
2170 | * Return Value: none | |
2171 | * | |
2172 | */ | |
2986db5f | 2173 | void CARDvSetFirstNextTBTT (unsigned long dwIoBase, unsigned short wBeaconInterval) |
5449c685 FB |
2174 | { |
2175 | ||
2176 | QWORD qwNextTBTT; | |
2177 | ||
2178 | HIDWORD(qwNextTBTT) = 0; | |
2179 | LODWORD(qwNextTBTT) = 0; | |
2180 | CARDbGetCurrentTSF(dwIoBase, &qwNextTBTT); //Get Local TSF counter | |
2181 | qwNextTBTT = CARDqGetNextTBTT(qwNextTBTT, wBeaconInterval); | |
2182 | // Set NextTBTT | |
2183 | VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT, LODWORD(qwNextTBTT)); | |
2184 | VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT + 4, HIDWORD(qwNextTBTT)); | |
2185 | MACvRegBitsOn(dwIoBase, MAC_REG_TFTCTL, TFTCTL_TBTTSYNCEN); | |
7e809a9b | 2186 | //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Card:First Next TBTT[%8xh:%8xh] \n", HIDWORD(qwNextTBTT), LODWORD(qwNextTBTT)); |
5449c685 FB |
2187 | return; |
2188 | } | |
2189 | ||
2190 | ||
2191 | /* | |
2192 | * Description: Sync NIC TSF counter for Beacon time | |
2193 | * Get NEXTTBTT and write to HW | |
2194 | * | |
2195 | * Parameters: | |
2196 | * In: | |
2197 | * pDevice - The adapter to be set | |
2198 | * qwTSF - Current TSF counter | |
2199 | * wBeaconInterval - Beacon Interval | |
2200 | * Out: | |
2201 | * none | |
2202 | * | |
2203 | * Return Value: none | |
2204 | * | |
2205 | */ | |
2986db5f | 2206 | void CARDvUpdateNextTBTT (unsigned long dwIoBase, QWORD qwTSF, unsigned short wBeaconInterval) |
5449c685 FB |
2207 | { |
2208 | ||
2209 | qwTSF = CARDqGetNextTBTT(qwTSF, wBeaconInterval); | |
2210 | // Set NextTBTT | |
2211 | VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT, LODWORD(qwTSF)); | |
2212 | VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT + 4, HIDWORD(qwTSF)); | |
2213 | MACvRegBitsOn(dwIoBase, MAC_REG_TFTCTL, TFTCTL_TBTTSYNCEN); | |
b6e95cd5 CC |
2214 | DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Card:Update Next TBTT[%8xh:%8xh] \n", |
2215 | (unsigned int) HIDWORD(qwTSF), (unsigned int) LODWORD(qwTSF)); | |
5449c685 FB |
2216 | |
2217 | return; | |
2218 | } | |
2219 | ||
2220 | ||
2221 | ||
2222 | ||
2223 | ||
2224 | ||
2225 |