projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Staging: vt6656: code cleanup, removed OUT definition
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / vt6656 / card.c
CommitLineData
92b96797
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
92b96797 48#include "tmacro.h"
92b96797 49#include "card.h"
92b96797 50#include "baseband.h"
92b96797 51#include "mac.h"
92b96797 52#include "desc.h"
92b96797 53#include "rf.h"
92b96797 54#include "power.h"
92b96797 55#include "key.h"
92b96797 56#include "rc4.h"
92b96797 57#include "country.h"
92b96797 58#include "datarate.h"
92b96797 59#include "rndis.h"
92b96797 60#include "control.h"
92b96797
FB		 61
62/*--------------------- Static Definitions -------------------------*/
63
64//static int msglevel =MSG_LEVEL_DEBUG;
65static int msglevel =MSG_LEVEL_INFO;
66
67
68/*--------------------- Static Definitions -------------------------*/
69#define CB_TXPOWER_LEVEL 6
70
71/*--------------------- Static Classes ----------------------------*/
72
73/*--------------------- Static Variables --------------------------*/
74//const WORD cwRXBCNTSFOff[MAX_RATE] =
75//{17, 34, 96, 192, 34, 23, 17, 11, 8, 5, 4, 3};
76
77const WORD cwRXBCNTSFOff[MAX_RATE] =
78{192, 96, 34, 17, 34, 23, 17, 11, 8, 5, 4, 3};
79
80/*--------------------- Static Functions --------------------------*/
81
82/*--------------------- Export Variables --------------------------*/
83
84/*--------------------- Export Functions --------------------------*/
85/*
86 * Description: Set NIC media channel
87 *
88 * Parameters:
89 * In:
90 * pDevice - The adapter to be set
91 * uConnectionChannel - Channel to be set
92 * Out:
93 * none
94 *
95 * Return Value: TRUE if succeeded; FALSE if failed.
96 *
97 */
8611a29a 98BOOL CARDbSetMediaChannel(void *pDeviceHandler, UINT uConnectionChannel)
92b96797
FB		 99{
100PSDevice pDevice = (PSDevice) pDeviceHandler;
101BOOL bResult = TRUE;
102
103
104 if (pDevice->byBBType == BB_TYPE_11A) { // 15 ~ 38
105 if ((uConnectionChannel < (CB_MAX_CHANNEL_24G+1)) || (uConnectionChannel > CB_MAX_CHANNEL))
106 uConnectionChannel = (CB_MAX_CHANNEL_24G+1);
107 } else {
108 if ((uConnectionChannel > CB_MAX_CHANNEL_24G) || (uConnectionChannel == 0)) // 1 ~ 14
109 uConnectionChannel = 1;
110 }
111
112 // clear NAV
113 MACvRegBitsOn(pDevice, MAC_REG_MACCR, MACCR_CLRNAV);
114
115 // Set Channel[7] = 0 to tell H/W channel is changing now.
116 MACvRegBitsOff(pDevice, MAC_REG_CHANNEL, 0x80);
117
118 //if (pMgmt->uCurrChannel == uConnectionChannel)
119 // return bResult;
120
121 CONTROLnsRequestOut(pDevice,
122 MESSAGE_TYPE_SELECT_CHANNLE,
123 (WORD) uConnectionChannel,
124 0,
125 0,
126 NULL
127 );
128
129 //{{ RobertYu: 20041202
130 //// TX_PE will reserve 3 us for MAX2829 A mode only, it is for better TX throughput
131
132 if (pDevice->byBBType == BB_TYPE_11A) {
133 pDevice->byCurPwr = 0xFF;
134 RFbRawSetPower(pDevice, pDevice->abyOFDMAPwrTbl[uConnectionChannel-15], RATE_54M);
135 } else if (pDevice->byBBType == BB_TYPE_11G) {
136 pDevice->byCurPwr = 0xFF;
137 RFbRawSetPower(pDevice, pDevice->abyOFDMPwrTbl[uConnectionChannel-1], RATE_54M);
138 } else {
139 pDevice->byCurPwr = 0xFF;
140 RFbRawSetPower(pDevice, pDevice->abyCCKPwrTbl[uConnectionChannel-1], RATE_1M);
141 }
142 ControlvWriteByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_CHANNEL,(BYTE)(uConnectionChannel|0x80));
143 return(bResult);
144}
145
146/*
147 * Description: Get CCK mode basic rate
148 *
149 * Parameters:
150 * In:
151 * pDevice - The adapter to be set
152 * wRateIdx - Receiving data rate
153 * Out:
154 * none
155 *
156 * Return Value: response Control frame rate
157 *
158 */
8611a29a 159static WORD swGetCCKControlRate(void *pDeviceHandler, WORD wRateIdx)
92b96797
FB		 160{
161 PSDevice pDevice = (PSDevice) pDeviceHandler;
162 UINT ui = (UINT)wRateIdx;
163 while (ui > RATE_1M) {
164 if (pDevice->wBasicRate & ((WORD)1 << ui)) {
165 return (WORD)ui;
166 }
167 ui --;
168 }
169 return (WORD)RATE_1M;
170}
171
172/*
173 * Description: Get OFDM mode basic rate
174 *
175 * Parameters:
176 * In:
177 * pDevice - The adapter to be set
178 * wRateIdx - Receiving data rate
179 * Out:
180 * none
181 *
182 * Return Value: response Control frame rate
183 *
184 */
8611a29a 185static WORD swGetOFDMControlRate(void *pDeviceHandler, WORD wRateIdx)
92b96797
FB		 186{
187 PSDevice pDevice = (PSDevice) pDeviceHandler;
188 UINT ui = (UINT)wRateIdx;
189
190 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"BASIC RATE: %X\n", pDevice->wBasicRate);
191
192 if (!CARDbIsOFDMinBasicRate(pDevice)) {
193 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"swGetOFDMControlRate:(NO OFDM) %d\n", wRateIdx);
194 if (wRateIdx > RATE_24M)
195 wRateIdx = RATE_24M;
196 return wRateIdx;
197 }
198 while (ui > RATE_11M) {
199 if (pDevice->wBasicRate & ((WORD)1 << ui)) {
200 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"swGetOFDMControlRate : %d\n", ui);
201 return (WORD)ui;
202 }
203 ui --;
204 }
205 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"swGetOFDMControlRate: 6M\n");
206 return (WORD)RATE_24M;
207}
208
209/*
210 * Description: Caculate TxRate and RsvTime fields for RSPINF in OFDM mode.
211 *
212 * Parameters:
213 * In:
214 * wRate - Tx Rate
215 * byPktType - Tx Packet type
216 * Out:
217 * pbyTxRate - pointer to RSPINF TxRate field
218 * pbyRsvTime - pointer to RSPINF RsvTime field
219 *
220 * Return Value: none
221 *
222 */
8611a29a 223void
92b96797 224CARDvCaculateOFDMRParameter (
592ccfeb
AM		 225 WORD wRate,
226 BYTE byBBType,
6f8c13c7
AM		 227 PBYTE pbyTxRate,
228 PBYTE pbyRsvTime
92b96797
FB		 229 )
230{
231 switch (wRate) {
232 case RATE_6M :
233 if (byBBType == BB_TYPE_11A) {//5GHZ
234 *pbyTxRate = 0x9B;
235 *pbyRsvTime = 24;
236 }
237 else {
238 *pbyTxRate = 0x8B;
239 *pbyRsvTime = 30;
240 }
241 break;
242
243 case RATE_9M :
244 if (byBBType == BB_TYPE_11A) {//5GHZ
245 *pbyTxRate = 0x9F;
246 *pbyRsvTime = 16;
247 }
248 else {
249 *pbyTxRate = 0x8F;
250 *pbyRsvTime = 22;
251 }
252 break;
253
254 case RATE_12M :
255 if (byBBType == BB_TYPE_11A) {//5GHZ
256 *pbyTxRate = 0x9A;
257 *pbyRsvTime = 12;
258 }
259 else {
260 *pbyTxRate = 0x8A;
261 *pbyRsvTime = 18;
262 }
263 break;
264
265 case RATE_18M :
266 if (byBBType == BB_TYPE_11A) {//5GHZ
267 *pbyTxRate = 0x9E;
268 *pbyRsvTime = 8;
269 }
270 else {
271 *pbyTxRate = 0x8E;
272 *pbyRsvTime = 14;
273 }
274 break;
275
276 case RATE_36M :
277 if (byBBType == BB_TYPE_11A) {//5GHZ
278 *pbyTxRate = 0x9D;
279 *pbyRsvTime = 4;
280 }
281 else {
282 *pbyTxRate = 0x8D;
283 *pbyRsvTime = 10;
284 }
285 break;
286
287 case RATE_48M :
288 if (byBBType == BB_TYPE_11A) {//5GHZ
289 *pbyTxRate = 0x98;
290 *pbyRsvTime = 4;
291 }
292 else {
293 *pbyTxRate = 0x88;
294 *pbyRsvTime = 10;
295 }
296 break;
297
298 case RATE_54M :
299 if (byBBType == BB_TYPE_11A) {//5GHZ
300 *pbyTxRate = 0x9C;
301 *pbyRsvTime = 4;
302 }
303 else {
304 *pbyTxRate = 0x8C;
305 *pbyRsvTime = 10;
306 }
307 break;
308
309 case RATE_24M :
310 default :
311 if (byBBType == BB_TYPE_11A) {//5GHZ
312 *pbyTxRate = 0x99;
313 *pbyRsvTime = 8;
314 }
315 else {
316 *pbyTxRate = 0x89;
317 *pbyRsvTime = 14;
318 }
319 break;
320 }
321}
322
323/*
324 * Description: Set RSPINF
325 *
326 * Parameters:
327 * In:
328 * pDevice - The adapter to be set
329 * Out:
330 * none
331 *
332 * Return Value: None.
333 *
334 */
8611a29a 335void CARDvSetRSPINF(void *pDeviceHandler, BYTE byBBType)
92b96797
FB		 336{
337 PSDevice pDevice = (PSDevice) pDeviceHandler;
338 BYTE abyServ[4] = {0,0,0,0}; // For CCK
339 BYTE abySignal[4] = {0,0,0,0};
340 WORD awLen[4] = {0,0,0,0};
341 BYTE abyTxRate[9] = {0,0,0,0,0,0,0,0,0}; // For OFDM
342 BYTE abyRsvTime[9] = {0,0,0,0,0,0,0,0,0};
343 BYTE abyData[34];
344 int i;
345
346 //RSPINF_b_1
347 BBvCaculateParameter(pDevice,
348 14,
349 swGetCCKControlRate(pDevice, RATE_1M),
350 PK_TYPE_11B,
351 &awLen[0],
352 &abyServ[0],
353 &abySignal[0]
354 );
355
356 ///RSPINF_b_2
357 BBvCaculateParameter(pDevice,
358 14,
359 swGetCCKControlRate(pDevice, RATE_2M),
360 PK_TYPE_11B,
361 &awLen[1],
362 &abyServ[1],
363 &abySignal[1]
364 );
365
366 //RSPINF_b_5
367 BBvCaculateParameter(pDevice,
368 14,
369 swGetCCKControlRate(pDevice, RATE_5M),
370 PK_TYPE_11B,
371 &awLen[2],
372 &abyServ[2],
373 &abySignal[2]
374 );
375
376 //RSPINF_b_11
377 BBvCaculateParameter(pDevice,
378 14,
379 swGetCCKControlRate(pDevice, RATE_11M),
380 PK_TYPE_11B,
381 &awLen[3],
382 &abyServ[3],
383 &abySignal[3]
384 );
385
386 //RSPINF_a_6
387 CARDvCaculateOFDMRParameter (RATE_6M,
388 byBBType,
389 &abyTxRate[0],
390 &abyRsvTime[0]);
391
392 //RSPINF_a_9
393 CARDvCaculateOFDMRParameter (RATE_9M,
394 byBBType,
395 &abyTxRate[1],
396 &abyRsvTime[1]);
397
398 //RSPINF_a_12
399 CARDvCaculateOFDMRParameter (RATE_12M,
400 byBBType,
401 &abyTxRate[2],
402 &abyRsvTime[2]);
403
404 //RSPINF_a_18
405 CARDvCaculateOFDMRParameter (RATE_18M,
406 byBBType,
407 &abyTxRate[3],
408 &abyRsvTime[3]);
409
410 //RSPINF_a_24
411 CARDvCaculateOFDMRParameter (RATE_24M,
412 byBBType,
413 &abyTxRate[4],
414 &abyRsvTime[4]);
415
416 //RSPINF_a_36
417 CARDvCaculateOFDMRParameter (swGetOFDMControlRate(pDevice, RATE_36M),
418 byBBType,
419 &abyTxRate[5],
420 &abyRsvTime[5]);
421
422 //RSPINF_a_48
423 CARDvCaculateOFDMRParameter (swGetOFDMControlRate(pDevice, RATE_48M),
424 byBBType,
425 &abyTxRate[6],
426 &abyRsvTime[6]);
427
428 //RSPINF_a_54
429 CARDvCaculateOFDMRParameter (swGetOFDMControlRate(pDevice, RATE_54M),
430 byBBType,
431 &abyTxRate[7],
432 &abyRsvTime[7]);
433
434 //RSPINF_a_72
435 CARDvCaculateOFDMRParameter (swGetOFDMControlRate(pDevice, RATE_54M),
436 byBBType,
437 &abyTxRate[8],
438 &abyRsvTime[8]);
439
440 abyData[0] = (BYTE)(awLen[0]&0xFF);
441 abyData[1] = (BYTE)(awLen[0]>>8);
442 abyData[2] = abySignal[0];
443 abyData[3] = abyServ[0];
444
445 abyData[4] = (BYTE)(awLen[1]&0xFF);
446 abyData[5] = (BYTE)(awLen[1]>>8);
447 abyData[6] = abySignal[1];
448 abyData[7] = abyServ[1];
449
450 abyData[8] = (BYTE)(awLen[2]&0xFF);
451 abyData[9] = (BYTE)(awLen[2]>>8);
452 abyData[10] = abySignal[2];
453 abyData[11] = abyServ[2];
454
455 abyData[12] = (BYTE)(awLen[3]&0xFF);
456 abyData[13] = (BYTE)(awLen[3]>>8);
457 abyData[14] = abySignal[3];
458 abyData[15] = abyServ[3];
459
460 for(i=0;i<9;i++) {
461 abyData[16+i*2] = abyTxRate[i];
462 abyData[16+i*2+1] = abyRsvTime[i];
463 }
464
465
466 CONTROLnsRequestOut(pDevice,
467 MESSAGE_TYPE_WRITE,
468 MAC_REG_RSPINF_B_1,
469 MESSAGE_REQUEST_MACREG,
470 34,
471 &abyData[0]);
472
473}
474
475/*
476 * Description: Update IFS
477 *
478 * Parameters:
479 * In:
480 * pDevice - The adapter to be set
481 * Out:
482 * none
483 *
484 * Return Value: None.
485 *
486 */
8611a29a 487void vUpdateIFS(void *pDeviceHandler)
92b96797
FB		 488{
489 PSDevice pDevice = (PSDevice) pDeviceHandler;
490 //Set SIFS, DIFS, EIFS, SlotTime, CwMin
491 BYTE byMaxMin = 0;
492 BYTE byData[4];
493
494 if (pDevice->byPacketType==PK_TYPE_11A) {//0000 0000 0000 0000,11a
495 pDevice->uSlot = C_SLOT_SHORT;
496 pDevice->uSIFS = C_SIFS_A;
497 pDevice->uDIFS = C_SIFS_A + 2*C_SLOT_SHORT;
498 pDevice->uCwMin = C_CWMIN_A;
499 byMaxMin = 4;
500 }
501 else if (pDevice->byPacketType==PK_TYPE_11B) {//0000 0001 0000 0000,11b
502 pDevice->uSlot = C_SLOT_LONG;
503 pDevice->uSIFS = C_SIFS_BG;
504 pDevice->uDIFS = C_SIFS_BG + 2*C_SLOT_LONG;
505 pDevice->uCwMin = C_CWMIN_B;
506 byMaxMin = 5;
507 }
508 else {// PK_TYPE_11GA & PK_TYPE_11GB
509 BYTE byRate = 0;
510 BOOL bOFDMRate = FALSE;
511 UINT ii = 0;
512 PWLAN_IE_SUPP_RATES pItemRates = NULL;
513
514 pDevice->uSIFS = C_SIFS_BG;
515 if (pDevice->bShortSlotTime) {
516 pDevice->uSlot = C_SLOT_SHORT;
517 } else {
518 pDevice->uSlot = C_SLOT_LONG;
519 }
520 pDevice->uDIFS = C_SIFS_BG + 2*pDevice->uSlot;
521
522 pItemRates = (PWLAN_IE_SUPP_RATES)pDevice->sMgmtObj.abyCurrSuppRates;
523 for (ii = 0; ii < pItemRates->len; ii++) {
524 byRate = (BYTE)(pItemRates->abyRates[ii]&0x7F);
525 if (RATEwGetRateIdx(byRate) > RATE_11M) {
526 bOFDMRate = TRUE;
527 break;
528 }
529 }
530 if (bOFDMRate == FALSE) {
531 pItemRates = (PWLAN_IE_SUPP_RATES)pDevice->sMgmtObj.abyCurrExtSuppRates;
532 for (ii = 0; ii < pItemRates->len; ii++) {
533 byRate = (BYTE)(pItemRates->abyRates[ii]&0x7F);
534 if (RATEwGetRateIdx(byRate) > RATE_11M) {
535 bOFDMRate = TRUE;
536 break;
537 }
538 }
539 }
540 if (bOFDMRate == TRUE) {
541 pDevice->uCwMin = C_CWMIN_A;
542 byMaxMin = 4;
543 } else {
544 pDevice->uCwMin = C_CWMIN_B;
545 byMaxMin = 5;
546 }
547 }
548
549 pDevice->uCwMax = C_CWMAX;
550 pDevice->uEIFS = C_EIFS;
551
552 byData[0] = (BYTE)pDevice->uSIFS;
553 byData[1] = (BYTE)pDevice->uDIFS;
554 byData[2] = (BYTE)pDevice->uEIFS;
555 byData[3] = (BYTE)pDevice->uSlot;
556 CONTROLnsRequestOut(pDevice,
557 MESSAGE_TYPE_WRITE,
558 MAC_REG_SIFS,
559 MESSAGE_REQUEST_MACREG,
560 4,
561 &byData[0]);
562
563 byMaxMin |= 0xA0;//1010 1111,C_CWMAX = 1023
564 CONTROLnsRequestOut(pDevice,
565 MESSAGE_TYPE_WRITE,
566 MAC_REG_CWMAXMIN0,
567 MESSAGE_REQUEST_MACREG,
568 1,
569 &byMaxMin);
570}
571
8611a29a 572void CARDvUpdateBasicTopRate(void *pDeviceHandler)
92b96797
FB		 573{
574PSDevice pDevice = (PSDevice) pDeviceHandler;
575BYTE byTopOFDM = RATE_24M, byTopCCK = RATE_1M;
576BYTE ii;
577
578 //Determines the highest basic rate.
579 for (ii = RATE_54M; ii >= RATE_6M; ii --) {
580 if ( (pDevice->wBasicRate) & ((WORD)(1<<ii)) ) {
581 byTopOFDM = ii;
582 break;
583 }
584 }
585 pDevice->byTopOFDMBasicRate = byTopOFDM;
586
587 for (ii = RATE_11M;; ii --) {
588 if ( (pDevice->wBasicRate) & ((WORD)(1<<ii)) ) {
589 byTopCCK = ii;
590 break;
591 }
592 if (ii == RATE_1M)
593 break;
594 }
595 pDevice->byTopCCKBasicRate = byTopCCK;
596 }
597
598/*
599 * Description: Set NIC Tx Basic Rate
600 *
601 * Parameters:
602 * In:
603 * pDevice - The adapter to be set
604 * wBasicRate - Basic Rate to be set
605 * Out:
606 * none
607 *
608 * Return Value: TRUE if succeeded; FALSE if failed.
609 *
610 */
8611a29a 611BOOL CARDbAddBasicRate(void *pDeviceHandler, WORD wRateIdx)
92b96797
FB		 612{
613PSDevice pDevice = (PSDevice) pDeviceHandler;
614WORD wRate = (WORD)(1<<wRateIdx);
615
616 pDevice->wBasicRate |= wRate;
617
618 //Determines the highest basic rate.
619 CARDvUpdateBasicTopRate(pDevice);
620
621 return(TRUE);
622}
623
8611a29a 624BOOL CARDbIsOFDMinBasicRate(void *pDeviceHandler)
92b96797
FB		 625{
626PSDevice pDevice = (PSDevice) pDeviceHandler;
627int ii;
628
629 for (ii = RATE_54M; ii >= RATE_6M; ii --) {
630 if ((pDevice->wBasicRate) & ((WORD)(1<<ii)))
631 return TRUE;
632 }
633 return FALSE;
634}
635
8611a29a 636BYTE CARDbyGetPktType(void *pDeviceHandler)
92b96797
FB		 637{
638 PSDevice pDevice = (PSDevice) pDeviceHandler;
639
640 if (pDevice->byBBType == BB_TYPE_11A || pDevice->byBBType == BB_TYPE_11B) {
641 return (BYTE)pDevice->byBBType;
642 }
643 else if (CARDbIsOFDMinBasicRate(pDevice)) {
644 return PK_TYPE_11GA;
645 }
646 else {
647 return PK_TYPE_11GB;
648 }
649}
650
651
652/*
653 * Description: Caculate TSF offset of two TSF input
654 * Get TSF Offset from RxBCN's TSF and local TSF
655 *
656 * Parameters:
657 * In:
658 * pDevice - The adapter to be sync.
659 * qwTSF1 - Rx BCN's TSF
660 * qwTSF2 - Local TSF
661 * Out:
662 * none
663 *
664 * Return Value: TSF Offset value
665 *
666 */
667QWORD CARDqGetTSFOffset (BYTE byRxRate, QWORD qwTSF1, QWORD qwTSF2)
668{
669 QWORD qwTSFOffset;
670 WORD wRxBcnTSFOffst = 0;
671
672 HIDWORD(qwTSFOffset) = 0;
673 LODWORD(qwTSFOffset) = 0;
674
675 wRxBcnTSFOffst = cwRXBCNTSFOff[byRxRate%MAX_RATE];
676 (qwTSF2).u.dwLowDword += (DWORD)(wRxBcnTSFOffst);
677 if ((qwTSF2).u.dwLowDword < (DWORD)(wRxBcnTSFOffst)) {
678 (qwTSF2).u.dwHighDword++;
679 }
680 LODWORD(qwTSFOffset) = LODWORD(qwTSF1) - LODWORD(qwTSF2);
681 if (LODWORD(qwTSF1) < LODWORD(qwTSF2)) {
682 // if borrow needed
683 HIDWORD(qwTSFOffset) = HIDWORD(qwTSF1) - HIDWORD(qwTSF2) - 1 ;
684 }
685 else {
686 HIDWORD(qwTSFOffset) = HIDWORD(qwTSF1) - HIDWORD(qwTSF2);
687 };
688 return (qwTSFOffset);
689}
690
691
692
693/*
694 * Description: Sync. TSF counter to BSS
695 * Get TSF offset and write to HW
696 *
697 * Parameters:
698 * In:
699 * pDevice - The adapter to be sync.
700 * qwBSSTimestamp - Rx BCN's TSF
701 * qwLocalTSF - Local TSF
702 * Out:
703 * none
704 *
705 * Return Value: none
706 *
707 */
8611a29a
AM		 708void CARDvAdjustTSF(void *pDeviceHandler, BYTE byRxRate,
709 QWORD qwBSSTimestamp, QWORD qwLocalTSF)
92b96797
FB		 710{
711
712 PSDevice pDevice = (PSDevice) pDeviceHandler;
713 QWORD qwTSFOffset;
714 DWORD dwTSFOffset1,dwTSFOffset2;
715 BYTE pbyData[8];
716
717 HIDWORD(qwTSFOffset) = 0;
718 LODWORD(qwTSFOffset) = 0;
719
720 qwTSFOffset = CARDqGetTSFOffset(byRxRate, qwBSSTimestamp, qwLocalTSF);
721 // adjust TSF
722 // HW's TSF add TSF Offset reg
723 dwTSFOffset1 = LODWORD(qwTSFOffset);
724 dwTSFOffset2 = HIDWORD(qwTSFOffset);
725
726
727 pbyData[0] = (BYTE)dwTSFOffset1;
728 pbyData[1] = (BYTE)(dwTSFOffset1>>8);
729 pbyData[2] = (BYTE)(dwTSFOffset1>>16);
730 pbyData[3] = (BYTE)(dwTSFOffset1>>24);
731 pbyData[4] = (BYTE)dwTSFOffset2;
732 pbyData[5] = (BYTE)(dwTSFOffset2>>8);
733 pbyData[6] = (BYTE)(dwTSFOffset2>>16);
734 pbyData[7] = (BYTE)(dwTSFOffset2>>24);
735
736 CONTROLnsRequestOut(pDevice,
737 MESSAGE_TYPE_SET_TSFTBTT,
738 MESSAGE_REQUEST_TSF,
739 0,
740 8,
741 pbyData
742 );
743
744}
745/*
746 * Description: Read NIC TSF counter
747 * Get local TSF counter
748 *
749 * Parameters:
750 * In:
751 * pDevice - The adapter to be read
752 * Out:
753 * qwCurrTSF - Current TSF counter
754 *
755 * Return Value: TRUE if success; otherwise FALSE
756 *
757 */
8611a29a 758BOOL CARDbGetCurrentTSF(void *pDeviceHandler, PQWORD pqwCurrTSF)
92b96797
FB		 759{
760 PSDevice pDevice = (PSDevice) pDeviceHandler;
761
762 LODWORD(*pqwCurrTSF) = LODWORD(pDevice->qwCurrTSF);
763 HIDWORD(*pqwCurrTSF) = HIDWORD(pDevice->qwCurrTSF);
764
765 return(TRUE);
766}
767
768
769/*
770 * Description: Clear NIC TSF counter
771 * Clear local TSF counter
772 *
773 * Parameters:
774 * In:
775 * pDevice - The adapter to be read
776 *
777 * Return Value: TRUE if success; otherwise FALSE
778 *
779 */
8611a29a 780BOOL CARDbClearCurrentTSF(void *pDeviceHandler)
92b96797
FB		 781{
782 PSDevice pDevice = (PSDevice) pDeviceHandler;
783
784 MACvRegBitsOn(pDevice,MAC_REG_TFTCTL,TFTCTL_TSFCNTRST);
785
786 LODWORD(pDevice->qwCurrTSF) = 0;
787 HIDWORD(pDevice->qwCurrTSF) = 0;
788
789 return(TRUE);
790}
791
792/*
793 * Description: Read NIC TSF counter
794 * Get NEXTTBTT from adjusted TSF and Beacon Interval
795 *
796 * Parameters:
797 * In:
798 * qwTSF - Current TSF counter
799 * wbeaconInterval - Beacon Interval
800 * Out:
801 * qwCurrTSF - Current TSF counter
802 *
803 * Return Value: TSF value of next Beacon
804 *
805 */
806QWORD CARDqGetNextTBTT (QWORD qwTSF, WORD wBeaconInterval)
807{
808
809 UINT uLowNextTBTT;
810 UINT uHighRemain, uLowRemain;
811 UINT uBeaconInterval;
812
813 uBeaconInterval = wBeaconInterval * 1024;
814 // Next TBTT = ((local_current_TSF / beacon_interval) + 1 ) * beacon_interval
815 uLowNextTBTT = (LODWORD(qwTSF) >> 10) << 10;
816 uLowRemain = (uLowNextTBTT) % uBeaconInterval;
817 uHighRemain = ((0x80000000 % uBeaconInterval)* 2 * HIDWORD(qwTSF))
818 % uBeaconInterval;
819 uLowRemain = (uHighRemain + uLowRemain) % uBeaconInterval;
820 uLowRemain = uBeaconInterval - uLowRemain;
821
822 // check if carry when add one beacon interval
823 if ((~uLowNextTBTT) < uLowRemain)
824 HIDWORD(qwTSF) ++ ;
825
826 LODWORD(qwTSF) = uLowNextTBTT + uLowRemain;
827
828 return (qwTSF);
829}
830
831
832/*
833 * Description: Set NIC TSF counter for first Beacon time
834 * Get NEXTTBTT from adjusted TSF and Beacon Interval
835 *
836 * Parameters:
837 * In:
838 * dwIoBase - IO Base
839 * wBeaconInterval - Beacon Interval
840 * Out:
841 * none
842 *
843 * Return Value: none
844 *
845 */
8611a29a 846void CARDvSetFirstNextTBTT(void *pDeviceHandler, WORD wBeaconInterval)
92b96797
FB		 847{
848
849 PSDevice pDevice = (PSDevice) pDeviceHandler;
850 QWORD qwNextTBTT;
851 DWORD dwLoTBTT,dwHiTBTT;
852 BYTE pbyData[8];
853
854 HIDWORD(qwNextTBTT) = 0;
855 LODWORD(qwNextTBTT) = 0;
856 CARDbClearCurrentTSF(pDevice);
857 //CARDbGetCurrentTSF(pDevice, &qwNextTBTT); //Get Local TSF counter
858 qwNextTBTT = CARDqGetNextTBTT(qwNextTBTT, wBeaconInterval);
859 // Set NextTBTT
860
861 dwLoTBTT = LODWORD(qwNextTBTT);
862 dwHiTBTT = HIDWORD(qwNextTBTT);
863
864 pbyData[0] = (BYTE)dwLoTBTT;
865 pbyData[1] = (BYTE)(dwLoTBTT>>8);
866 pbyData[2] = (BYTE)(dwLoTBTT>>16);
867 pbyData[3] = (BYTE)(dwLoTBTT>>24);
868 pbyData[4] = (BYTE)dwHiTBTT;
869 pbyData[5] = (BYTE)(dwHiTBTT>>8);
870 pbyData[6] = (BYTE)(dwHiTBTT>>16);
871 pbyData[7] = (BYTE)(dwHiTBTT>>24);
872
873 CONTROLnsRequestOut(pDevice,
874 MESSAGE_TYPE_SET_TSFTBTT,
875 MESSAGE_REQUEST_TBTT,
876 0,
877 8,
878 pbyData
879 );
880
881 return;
882}
883
884
885/*
886 * Description: Sync NIC TSF counter for Beacon time
887 * Get NEXTTBTT and write to HW
888 *
889 * Parameters:
890 * In:
891 * pDevice - The adapter to be set
892 * qwTSF - Current TSF counter
893 * wBeaconInterval - Beacon Interval
894 * Out:
895 * none
896 *
897 * Return Value: none
898 *
899 */
8611a29a
AM		 900void CARDvUpdateNextTBTT(void *pDeviceHandler, QWORD qwTSF,
901 WORD wBeaconInterval)
92b96797
FB		 902{
903 PSDevice pDevice = (PSDevice) pDeviceHandler;
904 DWORD dwLoTBTT,dwHiTBTT;
905 BYTE pbyData[8];
906
907 qwTSF = CARDqGetNextTBTT(qwTSF, wBeaconInterval);
908
909 // Set NextTBTT
910 dwLoTBTT = LODWORD(qwTSF);
911 dwHiTBTT = HIDWORD(qwTSF);
912
913 pbyData[0] = (BYTE)dwLoTBTT;
914 pbyData[1] = (BYTE)(dwLoTBTT>>8);
915 pbyData[2] = (BYTE)(dwLoTBTT>>16);
916 pbyData[3] = (BYTE)(dwLoTBTT>>24);
917 pbyData[4] = (BYTE)dwHiTBTT;
918 pbyData[5] = (BYTE)(dwHiTBTT>>8);
919 pbyData[6] = (BYTE)(dwHiTBTT>>16);
920 pbyData[7] = (BYTE)(dwHiTBTT>>24);
921
922 CONTROLnsRequestOut(pDevice,
923 MESSAGE_TYPE_SET_TSFTBTT,
924 MESSAGE_REQUEST_TBTT,
925 0,
926 8,
927 pbyData
928 );
929
930
931 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Card:Update Next TBTT[%8xh:%8xh] \n",(int)HIDWORD(qwTSF), (int)LODWORD(qwTSF));
932
933 return;
934}
935
936/*
937 * Description: Turn off Radio power
938 *
939 * Parameters:
940 * In:
941 * pDevice - The adapter to be turned off
942 * Out:
943 * none
944 *
945 * Return Value: TRUE if success; otherwise FALSE
946 *
947 */
8611a29a 948BOOL CARDbRadioPowerOff(void *pDeviceHandler)
92b96797
FB		 949{
950PSDevice pDevice = (PSDevice) pDeviceHandler;
951BOOL bResult = TRUE;
952
953 //if (pDevice->bRadioOff == TRUE)
954 // return TRUE;
955
956 pDevice->bRadioOff = TRUE;
957
958 switch (pDevice->byRFType) {
959 case RF_AL2230:
960 case RF_AL2230S:
961 case RF_AIROHA7230:
962 case RF_VT3226: //RobertYu:20051111
963 case RF_VT3226D0:
964 case RF_VT3342A0: //RobertYu:20060609
965 MACvRegBitsOff(pDevice, MAC_REG_SOFTPWRCTL, (SOFTPWRCTL_SWPE2 | SOFTPWRCTL_SWPE3));
966 break;
967 }
968
969 MACvRegBitsOff(pDevice, MAC_REG_HOSTCR, HOSTCR_RXON);
970
971 BBvSetDeepSleep(pDevice);
972
973 return bResult;
974}
975
976
977/*
978 * Description: Turn on Radio power
979 *
980 * Parameters:
981 * In:
982 * pDevice - The adapter to be turned on
983 * Out:
984 * none
985 *
986 * Return Value: TRUE if success; otherwise FALSE
987 *
988 */
8611a29a 989BOOL CARDbRadioPowerOn(void *pDeviceHandler)
92b96797
FB		 990{
991PSDevice pDevice = (PSDevice) pDeviceHandler;
992BOOL bResult = TRUE;
993
994
995 if ((pDevice->bHWRadioOff == TRUE) || (pDevice->bRadioControlOff == TRUE)) {
996 return FALSE;
997 }
998
999 //if (pDevice->bRadioOff == FALSE)
1000 // return TRUE;
1001
1002 pDevice->bRadioOff = FALSE;
1003
1004 BBvExitDeepSleep(pDevice);
1005
1006 MACvRegBitsOn(pDevice, MAC_REG_HOSTCR, HOSTCR_RXON);
1007
1008 switch (pDevice->byRFType) {
1009 case RF_AL2230:
1010 case RF_AL2230S:
1011 case RF_AIROHA7230:
1012 case RF_VT3226: //RobertYu:20051111
1013 case RF_VT3226D0:
1014 case RF_VT3342A0: //RobertYu:20060609
1015 MACvRegBitsOn(pDevice, MAC_REG_SOFTPWRCTL, (SOFTPWRCTL_SWPE2 | SOFTPWRCTL_SWPE3));
1016 break;
1017 }
1018
1019 return bResult;
1020}
1021
8611a29a 1022void CARDvSetBSSMode(void *pDeviceHandler)
92b96797
FB		 1023{
1024 PSDevice pDevice = (PSDevice) pDeviceHandler;
1025 // Set BB and packet type at the same time.//{{RobertYu:20050222, AL7230 have two TX PA output, only connet to b/g now
1026 // so in 11a mode need to set the MAC Reg0x4C to 11b/g mode to turn on PA
1027 if( (pDevice->byRFType == RF_AIROHA7230 ) && (pDevice->byBBType == BB_TYPE_11A) )
1028 {
1029 MACvSetBBType(pDevice, BB_TYPE_11G);
1030 }
1031 else
1032 {
1033 MACvSetBBType(pDevice, pDevice->byBBType);
1034 }
1035 pDevice->byPacketType = CARDbyGetPktType(pDevice);
1036
1037 if (pDevice->byBBType == BB_TYPE_11A) {
1038 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0x88, 0x03);
1039 } else if (pDevice->byBBType == BB_TYPE_11B) {
1040 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0x88, 0x02);
1041 } else if (pDevice->byBBType == BB_TYPE_11G) {
1042 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0x88, 0x08);
1043 }
1044
1045 vUpdateIFS(pDevice);
1046 CARDvSetRSPINF(pDevice, (BYTE)pDevice->byBBType);
1047
1048 if ( pDevice->byBBType == BB_TYPE_11A ) {
1049 //request by Jack 2005-04-26
1050 if (pDevice->byRFType == RF_AIROHA7230) {
1051 pDevice->abyBBVGA[0] = 0x20;
1052 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xE7, pDevice->abyBBVGA[0]);
1053 }
1054 pDevice->abyBBVGA[2] = 0x10;
1055 pDevice->abyBBVGA[3] = 0x10;
1056 } else {
1057 //request by Jack 2005-04-26
1058 if (pDevice->byRFType == RF_AIROHA7230) {
1059 pDevice->abyBBVGA[0] = 0x1C;
1060 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xE7, pDevice->abyBBVGA[0]);
1061 }
1062 pDevice->abyBBVGA[2] = 0x0;
1063 pDevice->abyBBVGA[3] = 0x0;
1064 }
1065}
1066
1067/*
1068 *
1069 * Description:
1070 * Do Channel Switch defined in 802.11h
1071 *
1072 * Parameters:
1073 * In:
1074 * hDeviceContext - device structure point
1075 * Out:
1076 * none
1077 *
1078 * Return Value: none.
1079 *
1080-*/
1081BOOL
1082CARDbChannelSwitch (
8611a29a 1083 void *pDeviceHandler,
592ccfeb
AM		 1084 BYTE byMode,
1085 BYTE byNewChannel,
1086 BYTE byCount
92b96797
FB		 1087 )
1088{
1089 PSDevice pDevice = (PSDevice) pDeviceHandler;
1090 BOOL bResult = TRUE;
1091
1092 if (byCount == 0) {
1093 pDevice->sMgmtObj.uCurrChannel = byNewChannel;
1094 bResult = CARDbSetMediaChannel(pDevice, byNewChannel);
1095
1096 return(bResult);
1097 }
1098 pDevice->byChannelSwitchCount = byCount;
1099 pDevice->byNewChannel = byNewChannel;
1100 pDevice->bChannelSwitch = TRUE;
1101
1102 if (byMode == 1) {
1103 //bResult=CARDbStopTxPacket(pDevice, PKT_TYPE_802_11_ALL);
1104 pDevice->bStopDataPkt = TRUE;
1105 }
1106 return (bResult);
1107}
1108
1109
1110
1111
1112
1113
kernel source for telekom puls (alcatel/mediatek)