card.c revision 6f8c13c7dbe0d51e62bdb1aa11c1c38a8f8e3133 
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
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#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 */
98BOOL CARDbSetMediaChannel(void *pDeviceHandler, UINT uConnectionChannel)
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 */
159static WORD swGetCCKControlRate(void *pDeviceHandler, WORD wRateIdx)
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 */
185static WORD swGetOFDMControlRate(void *pDeviceHandler, WORD wRateIdx)
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 */
223void
224CARDvCaculateOFDMRParameter (
225      WORD wRate,
226      BYTE byBBType,
227     PBYTE pbyTxRate,
228     PBYTE pbyRsvTime
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 */
335void CARDvSetRSPINF(void *pDeviceHandler, BYTE byBBType)
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 */
487void vUpdateIFS(void *pDeviceHandler)
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
572void CARDvUpdateBasicTopRate(void *pDeviceHandler)
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 */
611BOOL CARDbAddBasicRate(void *pDeviceHandler, WORD wRateIdx)
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
624BOOL CARDbIsOFDMinBasicRate(void *pDeviceHandler)
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
636BYTE CARDbyGetPktType(void *pDeviceHandler)
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 */
708void CARDvAdjustTSF(void *pDeviceHandler, BYTE byRxRate,
709		    QWORD qwBSSTimestamp, QWORD qwLocalTSF)
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 */
758BOOL CARDbGetCurrentTSF(void *pDeviceHandler, PQWORD pqwCurrTSF)
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 */
780BOOL CARDbClearCurrentTSF(void *pDeviceHandler)
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 */
846void CARDvSetFirstNextTBTT(void *pDeviceHandler, WORD wBeaconInterval)
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 */
900void CARDvUpdateNextTBTT(void *pDeviceHandler, QWORD qwTSF,
901			 WORD wBeaconInterval)
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 */
948BOOL CARDbRadioPowerOff(void *pDeviceHandler)
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 */
989BOOL CARDbRadioPowerOn(void *pDeviceHandler)
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
1022void CARDvSetBSSMode(void *pDeviceHandler)
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 (
1083     void *pDeviceHandler,
1084     BYTE             byMode,
1085     BYTE             byNewChannel,
1086     BYTE             byCount
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
1114