projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
staging: tidspbridge: ioremap dsp sync addr
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / vt6656 / card.c
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;
65 static 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
76 const 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 */
94 void CARDbSetMediaChannel(void *pDeviceHandler, unsigned int uConnectionChannel)
95 {
96 PSDevice 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 */
152 static 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 */
178 static 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 */
216 void
217 CARDvCalculateOFDMRParameter (
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 */
328 void 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 */
479 void 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
564 void CARDvUpdateBasicTopRate(void *pDeviceHandler)
565 {
566 PSDevice pDevice = (PSDevice) pDeviceHandler;
567 BYTE byTopOFDM = RATE_24M, byTopCCK = RATE_1M;
568 BYTE 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 */
603 void CARDbAddBasicRate(void *pDeviceHandler, WORD wRateIdx)
604 {
605 PSDevice pDevice = (PSDevice) pDeviceHandler;
606 WORD wRate = (WORD)(1<<wRateIdx);
607
608 pDevice->wBasicRate |= wRate;
609
610 //Determines the highest basic rate.
611 CARDvUpdateBasicTopRate(pDevice);
612 }
613
614 BOOL CARDbIsOFDMinBasicRate(void *pDeviceHandler)
615 {
616 PSDevice pDevice = (PSDevice) pDeviceHandler;
617 int 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
626 BYTE 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 */
657 QWORD 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 */
698 void 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 */
748 BOOL 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 */
770 BOOL 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 */
796 QWORD 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 */
836 void 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 */
890 void 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 */
938 BOOL CARDbRadioPowerOff(void *pDeviceHandler)
939 {
940 PSDevice pDevice = (PSDevice) pDeviceHandler;
941 BOOL 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 */
979 BOOL CARDbRadioPowerOn(void *pDeviceHandler)
980 {
981 PSDevice pDevice = (PSDevice) pDeviceHandler;
982 BOOL 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
1012 void 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 -*/
1071 BOOL
1072 CARDbChannelSwitch (
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
kernel source for telekom puls (alcatel/mediatek)