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