Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
card.c
Go to the documentation of this file.
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
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 
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 
Generated on Thu Jan 10 2013 14:15:48 for Linux Kernel by   doxygen 1.8.2