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