Merge branches 'arm/rockchip', 'arm/exynos', 'arm/smmu', 'x86/vt-d', 'x86/amd', ...
[sfrench/cifs-2.6.git] / drivers / staging / vt6655 / 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  *      CARDvUpdateBasicTopRate - Update BasicTopRate
25  *      CARDbAddBasicRate - Add to BasicRateSet
26  *      CARDbIsOFDMinBasicRate - Check if any OFDM rate is in BasicRateSet
27  *      CARDvSetLoopbackMode - Set Loopback mode
28  *      CARDbSoftwareReset - Sortware reset NIC
29  *      CARDqGetTSFOffset - Calculate TSFOffset
30  *      CARDbGetCurrentTSF - Read Current NIC TSF counter
31  *      CARDqGetNextTBTT - Calculate Next Beacon TSF counter
32  *      CARDvSetFirstNextTBTT - Set NIC Beacon time
33  *      CARDvUpdateNextTBTT - Sync. NIC Beacon time
34  *      CARDbRadioPowerOff - Turn Off NIC Radio Power
35  *      CARDbRadioPowerOn - Turn On NIC Radio Power
36  *
37  * Revision History:
38  *      06-10-2003 Bryan YC Fan:  Re-write codes to support VT3253 spec.
39  *      08-26-2003 Kyle Hsu:      Modify the defination type of dwIoBase.
40  *      09-01-2003 Bryan YC Fan:  Add vUpdateIFS().
41  *
42  */
43
44 #include "tmacro.h"
45 #include "card.h"
46 #include "baseband.h"
47 #include "mac.h"
48 #include "desc.h"
49 #include "rf.h"
50 #include "power.h"
51
52 /*---------------------  Static Definitions -------------------------*/
53
54 #define C_SIFS_A        16      /* micro sec. */
55 #define C_SIFS_BG       10
56
57 #define C_EIFS          80      /* micro sec. */
58
59 #define C_SLOT_SHORT    9       /* micro sec. */
60 #define C_SLOT_LONG     20
61
62 #define C_CWMIN_A       15      /* slot time */
63 #define C_CWMIN_B       31
64
65 #define C_CWMAX         1023    /* slot time */
66
67 #define WAIT_BEACON_TX_DOWN_TMO         3    /* Times */
68
69 /*---------------------  Static Variables  --------------------------*/
70
71 static const unsigned short cwRXBCNTSFOff[MAX_RATE] = {
72         17, 17, 17, 17, 34, 23, 17, 11, 8, 5, 4, 3};
73
74 /*---------------------  Static Functions  --------------------------*/
75
76 static
77 void
78 s_vCalculateOFDMRParameter(
79         unsigned char byRate,
80         u8 bb_type,
81         unsigned char *pbyTxRate,
82         unsigned char *pbyRsvTime
83 );
84
85 /*---------------------  Export Functions  --------------------------*/
86
87 /*
88  * Description: Calculate TxRate and RsvTime fields for RSPINF in OFDM mode.
89  *
90  * Parameters:
91  *  In:
92  *      wRate           - Tx Rate
93  *      byPktType       - Tx Packet type
94  *  Out:
95  *      pbyTxRate       - pointer to RSPINF TxRate field
96  *      pbyRsvTime      - pointer to RSPINF RsvTime field
97  *
98  * Return Value: none
99  */
100 static
101 void
102 s_vCalculateOFDMRParameter(
103         unsigned char byRate,
104         u8 bb_type,
105         unsigned char *pbyTxRate,
106         unsigned char *pbyRsvTime
107 )
108 {
109         switch (byRate) {
110         case RATE_6M:
111                 if (bb_type == BB_TYPE_11A) { /* 5GHZ */
112                         *pbyTxRate = 0x9B;
113                         *pbyRsvTime = 44;
114                 } else {
115                         *pbyTxRate = 0x8B;
116                         *pbyRsvTime = 50;
117                 }
118                 break;
119
120         case RATE_9M:
121                 if (bb_type == BB_TYPE_11A) { /* 5GHZ */
122                         *pbyTxRate = 0x9F;
123                         *pbyRsvTime = 36;
124                 } else {
125                         *pbyTxRate = 0x8F;
126                         *pbyRsvTime = 42;
127                 }
128                 break;
129
130         case RATE_12M:
131                 if (bb_type == BB_TYPE_11A) { /* 5GHZ */
132                         *pbyTxRate = 0x9A;
133                         *pbyRsvTime = 32;
134                 } else {
135                         *pbyTxRate = 0x8A;
136                         *pbyRsvTime = 38;
137                 }
138                 break;
139
140         case RATE_18M:
141                 if (bb_type == BB_TYPE_11A) { /* 5GHZ */
142                         *pbyTxRate = 0x9E;
143                         *pbyRsvTime = 28;
144                 } else {
145                         *pbyTxRate = 0x8E;
146                         *pbyRsvTime = 34;
147                 }
148                 break;
149
150         case RATE_36M:
151                 if (bb_type == BB_TYPE_11A) { /* 5GHZ */
152                         *pbyTxRate = 0x9D;
153                         *pbyRsvTime = 24;
154                 } else {
155                         *pbyTxRate = 0x8D;
156                         *pbyRsvTime = 30;
157                 }
158                 break;
159
160         case RATE_48M:
161                 if (bb_type == BB_TYPE_11A) { /* 5GHZ */
162                         *pbyTxRate = 0x98;
163                         *pbyRsvTime = 24;
164                 } else {
165                         *pbyTxRate = 0x88;
166                         *pbyRsvTime = 30;
167                 }
168                 break;
169
170         case RATE_54M:
171                 if (bb_type == BB_TYPE_11A) { /* 5GHZ */
172                         *pbyTxRate = 0x9C;
173                         *pbyRsvTime = 24;
174                 } else {
175                         *pbyTxRate = 0x8C;
176                         *pbyRsvTime = 30;
177                 }
178                 break;
179
180         case RATE_24M:
181         default:
182                 if (bb_type == BB_TYPE_11A) { /* 5GHZ */
183                         *pbyTxRate = 0x99;
184                         *pbyRsvTime = 28;
185                 } else {
186                         *pbyTxRate = 0x89;
187                         *pbyRsvTime = 34;
188                 }
189                 break;
190         }
191 }
192
193 /*---------------------  Export Functions  --------------------------*/
194
195 /*
196  * Description: Update IFS
197  *
198  * Parameters:
199  *  In:
200  *      pDevice             - The adapter to be set
201  *  Out:
202  *      none
203  *
204  * Return Value: None.
205  */
206 bool CARDbSetPhyParameter(struct vnt_private *pDevice, u8 bb_type)
207 {
208         unsigned char byCWMaxMin = 0;
209         unsigned char bySlot = 0;
210         unsigned char bySIFS = 0;
211         unsigned char byDIFS = 0;
212         unsigned char byData;
213         int i;
214
215         /* Set SIFS, DIFS, EIFS, SlotTime, CwMin */
216         if (bb_type == BB_TYPE_11A) {
217                 if (pDevice->byRFType == RF_AIROHA7230) {
218                         /* AL7230 use single PAPE and connect to PAPE_2.4G */
219                         MACvSetBBType(pDevice->PortOffset, BB_TYPE_11G);
220                         pDevice->abyBBVGA[0] = 0x20;
221                         pDevice->abyBBVGA[2] = 0x10;
222                         pDevice->abyBBVGA[3] = 0x10;
223                         BBbReadEmbedded(pDevice, 0xE7, &byData);
224                         if (byData == 0x1C)
225                                 BBbWriteEmbedded(pDevice, 0xE7, pDevice->abyBBVGA[0]);
226
227                 } else if (pDevice->byRFType == RF_UW2452) {
228                         MACvSetBBType(pDevice->PortOffset, BB_TYPE_11A);
229                         pDevice->abyBBVGA[0] = 0x18;
230                         BBbReadEmbedded(pDevice, 0xE7, &byData);
231                         if (byData == 0x14) {
232                                 BBbWriteEmbedded(pDevice, 0xE7, pDevice->abyBBVGA[0]);
233                                 BBbWriteEmbedded(pDevice, 0xE1, 0x57);
234                         }
235                 } else {
236                         MACvSetBBType(pDevice->PortOffset, BB_TYPE_11A);
237                 }
238                 BBbWriteEmbedded(pDevice, 0x88, 0x03);
239                 bySlot = C_SLOT_SHORT;
240                 bySIFS = C_SIFS_A;
241                 byDIFS = C_SIFS_A + 2*C_SLOT_SHORT;
242                 byCWMaxMin = 0xA4;
243         } else if (bb_type == BB_TYPE_11B) {
244                 MACvSetBBType(pDevice->PortOffset, BB_TYPE_11B);
245                 if (pDevice->byRFType == RF_AIROHA7230) {
246                         pDevice->abyBBVGA[0] = 0x1C;
247                         pDevice->abyBBVGA[2] = 0x00;
248                         pDevice->abyBBVGA[3] = 0x00;
249                         BBbReadEmbedded(pDevice, 0xE7, &byData);
250                         if (byData == 0x20)
251                                 BBbWriteEmbedded(pDevice, 0xE7, pDevice->abyBBVGA[0]);
252
253                 } else if (pDevice->byRFType == RF_UW2452) {
254                         pDevice->abyBBVGA[0] = 0x14;
255                         BBbReadEmbedded(pDevice, 0xE7, &byData);
256                         if (byData == 0x18) {
257                                 BBbWriteEmbedded(pDevice, 0xE7, pDevice->abyBBVGA[0]);
258                                 BBbWriteEmbedded(pDevice, 0xE1, 0xD3);
259                         }
260                 }
261                 BBbWriteEmbedded(pDevice, 0x88, 0x02);
262                 bySlot = C_SLOT_LONG;
263                 bySIFS = C_SIFS_BG;
264                 byDIFS = C_SIFS_BG + 2*C_SLOT_LONG;
265                 byCWMaxMin = 0xA5;
266         } else { /* PK_TYPE_11GA & PK_TYPE_11GB */
267                 MACvSetBBType(pDevice->PortOffset, BB_TYPE_11G);
268                 if (pDevice->byRFType == RF_AIROHA7230) {
269                         pDevice->abyBBVGA[0] = 0x1C;
270                         pDevice->abyBBVGA[2] = 0x00;
271                         pDevice->abyBBVGA[3] = 0x00;
272                         BBbReadEmbedded(pDevice, 0xE7, &byData);
273                         if (byData == 0x20)
274                                 BBbWriteEmbedded(pDevice, 0xE7, pDevice->abyBBVGA[0]);
275
276                 } else if (pDevice->byRFType == RF_UW2452) {
277                         pDevice->abyBBVGA[0] = 0x14;
278                         BBbReadEmbedded(pDevice, 0xE7, &byData);
279                         if (byData == 0x18) {
280                                 BBbWriteEmbedded(pDevice, 0xE7, pDevice->abyBBVGA[0]);
281                                 BBbWriteEmbedded(pDevice, 0xE1, 0xD3);
282                         }
283                 }
284                 BBbWriteEmbedded(pDevice, 0x88, 0x08);
285                 bySIFS = C_SIFS_BG;
286
287                 if (pDevice->bShortSlotTime) {
288                         bySlot = C_SLOT_SHORT;
289                         byDIFS = C_SIFS_BG + 2*C_SLOT_SHORT;
290                 } else {
291                         bySlot = C_SLOT_LONG;
292                         byDIFS = C_SIFS_BG + 2*C_SLOT_LONG;
293                 }
294
295                 byCWMaxMin = 0xa4;
296
297                 for (i = RATE_54M; i >= RATE_6M; i--) {
298                         if (pDevice->basic_rates & ((u32)(0x1 << i))) {
299                                 byCWMaxMin |= 0x1;
300                                 break;
301                         }
302                 }
303         }
304
305         if (pDevice->byRFType == RF_RFMD2959) {
306                 /*
307                  * bcs TX_PE will reserve 3 us hardware's processing
308                  * time here is 2 us.
309                  */
310                 bySIFS -= 3;
311                 byDIFS -= 3;
312                 /*
313                  * TX_PE will reserve 3 us for MAX2829 A mode only, it is for
314                  * better TX throughput; MAC will need 2 us to process, so the
315                  * SIFS, DIFS can be shorter by 2 us.
316                  */
317         }
318
319         if (pDevice->bySIFS != bySIFS) {
320                 pDevice->bySIFS = bySIFS;
321                 VNSvOutPortB(pDevice->PortOffset + MAC_REG_SIFS, pDevice->bySIFS);
322         }
323         if (pDevice->byDIFS != byDIFS) {
324                 pDevice->byDIFS = byDIFS;
325                 VNSvOutPortB(pDevice->PortOffset + MAC_REG_DIFS, pDevice->byDIFS);
326         }
327         if (pDevice->byEIFS != C_EIFS) {
328                 pDevice->byEIFS = C_EIFS;
329                 VNSvOutPortB(pDevice->PortOffset + MAC_REG_EIFS, pDevice->byEIFS);
330         }
331         if (pDevice->bySlot != bySlot) {
332                 pDevice->bySlot = bySlot;
333                 VNSvOutPortB(pDevice->PortOffset + MAC_REG_SLOT, pDevice->bySlot);
334
335                 BBvSetShortSlotTime(pDevice);
336         }
337         if (pDevice->byCWMaxMin != byCWMaxMin) {
338                 pDevice->byCWMaxMin = byCWMaxMin;
339                 VNSvOutPortB(pDevice->PortOffset + MAC_REG_CWMAXMIN0, pDevice->byCWMaxMin);
340         }
341
342         pDevice->byPacketType = CARDbyGetPktType(pDevice);
343
344         CARDvSetRSPINF(pDevice, bb_type);
345
346         return true;
347 }
348
349 /*
350  * Description: Sync. TSF counter to BSS
351  *              Get TSF offset and write to HW
352  *
353  * Parameters:
354  *  In:
355  *      pDevice         - The adapter to be sync.
356  *      byRxRate        - data rate of receive beacon
357  *      qwBSSTimestamp  - Rx BCN's TSF
358  *      qwLocalTSF      - Local TSF
359  *  Out:
360  *      none
361  *
362  * Return Value: none
363  */
364 bool CARDbUpdateTSF(struct vnt_private *pDevice, unsigned char byRxRate,
365                     u64 qwBSSTimestamp)
366 {
367         u64 local_tsf;
368         u64 qwTSFOffset = 0;
369
370         CARDbGetCurrentTSF(pDevice, &local_tsf);
371
372         if (qwBSSTimestamp != local_tsf) {
373                 qwTSFOffset = CARDqGetTSFOffset(byRxRate, qwBSSTimestamp,
374                                                 local_tsf);
375                 /* adjust TSF, HW's TSF add TSF Offset reg */
376                 VNSvOutPortD(pDevice->PortOffset + MAC_REG_TSFOFST, (u32)qwTSFOffset);
377                 VNSvOutPortD(pDevice->PortOffset + MAC_REG_TSFOFST + 4, (u32)(qwTSFOffset >> 32));
378                 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_TFTCTL, TFTCTL_TSFSYNCEN);
379         }
380         return true;
381 }
382
383 /*
384  * Description: Set NIC TSF counter for first Beacon time
385  *              Get NEXTTBTT from adjusted TSF and Beacon Interval
386  *
387  * Parameters:
388  *  In:
389  *      pDevice         - The adapter to be set.
390  *      wBeaconInterval - Beacon Interval
391  *  Out:
392  *      none
393  *
394  * Return Value: true if succeed; otherwise false
395  */
396 bool CARDbSetBeaconPeriod(struct vnt_private *pDevice,
397                           unsigned short wBeaconInterval)
398 {
399         u64 qwNextTBTT = 0;
400
401         CARDbGetCurrentTSF(pDevice, &qwNextTBTT); /* Get Local TSF counter */
402
403         qwNextTBTT = CARDqGetNextTBTT(qwNextTBTT, wBeaconInterval);
404
405         /* set HW beacon interval */
406         VNSvOutPortW(pDevice->PortOffset + MAC_REG_BI, wBeaconInterval);
407         pDevice->wBeaconInterval = wBeaconInterval;
408         /* Set NextTBTT */
409         VNSvOutPortD(pDevice->PortOffset + MAC_REG_NEXTTBTT, (u32)qwNextTBTT);
410         VNSvOutPortD(pDevice->PortOffset + MAC_REG_NEXTTBTT + 4, (u32)(qwNextTBTT >> 32));
411         MACvRegBitsOn(pDevice->PortOffset, MAC_REG_TFTCTL, TFTCTL_TBTTSYNCEN);
412
413         return true;
414 }
415
416 /*
417  * Description: Turn off Radio power
418  *
419  * Parameters:
420  *  In:
421  *      pDevice         - The adapter to be turned off
422  *  Out:
423  *      none
424  *
425  * Return Value: true if success; otherwise false
426  */
427 bool CARDbRadioPowerOff(struct vnt_private *pDevice)
428 {
429         bool bResult = true;
430
431         if (pDevice->bRadioOff == true)
432                 return true;
433
434         switch (pDevice->byRFType) {
435         case RF_RFMD2959:
436                 MACvWordRegBitsOff(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_TXPEINV);
437                 MACvWordRegBitsOn(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPE1);
438                 break;
439
440         case RF_AIROHA:
441         case RF_AL2230S:
442         case RF_AIROHA7230:
443                 MACvWordRegBitsOff(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPE2);
444                 MACvWordRegBitsOff(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPE3);
445                 break;
446
447         }
448
449         MACvRegBitsOff(pDevice->PortOffset, MAC_REG_HOSTCR, HOSTCR_RXON);
450
451         BBvSetDeepSleep(pDevice, pDevice->byLocalID);
452
453         pDevice->bRadioOff = true;
454         pr_debug("chester power off\n");
455         MACvRegBitsOn(pDevice->PortOffset, MAC_REG_GPIOCTL0, LED_ACTSET);  /* LED issue */
456         return bResult;
457 }
458
459 /*
460  * Description: Turn on Radio power
461  *
462  * Parameters:
463  *  In:
464  *      pDevice         - The adapter to be turned on
465  *  Out:
466  *      none
467  *
468  * Return Value: true if success; otherwise false
469  */
470 bool CARDbRadioPowerOn(struct vnt_private *pDevice)
471 {
472         bool bResult = true;
473
474         pr_debug("chester power on\n");
475         if (pDevice->bRadioControlOff == true) {
476                 if (pDevice->bHWRadioOff == true)
477                         pr_debug("chester bHWRadioOff\n");
478                 if (pDevice->bRadioControlOff == true)
479                         pr_debug("chester bRadioControlOff\n");
480                 return false; }
481
482         if (pDevice->bRadioOff == false) {
483                 pr_debug("chester pbRadioOff\n");
484                 return true; }
485
486         BBvExitDeepSleep(pDevice, pDevice->byLocalID);
487
488         MACvRegBitsOn(pDevice->PortOffset, MAC_REG_HOSTCR, HOSTCR_RXON);
489
490         switch (pDevice->byRFType) {
491         case RF_RFMD2959:
492                 MACvWordRegBitsOn(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_TXPEINV);
493                 MACvWordRegBitsOff(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPE1);
494                 break;
495
496         case RF_AIROHA:
497         case RF_AL2230S:
498         case RF_AIROHA7230:
499                 MACvWordRegBitsOn(pDevice->PortOffset, MAC_REG_SOFTPWRCTL, (SOFTPWRCTL_SWPE2 |
500                                                                             SOFTPWRCTL_SWPE3));
501                 break;
502
503         }
504
505         pDevice->bRadioOff = false;
506         pr_debug("chester power on\n");
507         MACvRegBitsOff(pDevice->PortOffset, MAC_REG_GPIOCTL0, LED_ACTSET); /* LED issue */
508         return bResult;
509 }
510
511 void
512 CARDvSafeResetTx(
513         struct vnt_private *pDevice
514 )
515 {
516         unsigned int uu;
517         PSTxDesc    pCurrTD;
518
519         /* initialize TD index */
520         pDevice->apTailTD[0] = pDevice->apCurrTD[0] = &(pDevice->apTD0Rings[0]);
521         pDevice->apTailTD[1] = pDevice->apCurrTD[1] = &(pDevice->apTD1Rings[0]);
522
523         for (uu = 0; uu < TYPE_MAXTD; uu++)
524                 pDevice->iTDUsed[uu] = 0;
525
526         for (uu = 0; uu < pDevice->sOpts.nTxDescs[0]; uu++) {
527                 pCurrTD = &(pDevice->apTD0Rings[uu]);
528                 pCurrTD->m_td0TD0.f1Owner = OWNED_BY_HOST;
529                 /* init all Tx Packet pointer to NULL */
530         }
531         for (uu = 0; uu < pDevice->sOpts.nTxDescs[1]; uu++) {
532                 pCurrTD = &(pDevice->apTD1Rings[uu]);
533                 pCurrTD->m_td0TD0.f1Owner = OWNED_BY_HOST;
534                 /* init all Tx Packet pointer to NULL */
535         }
536
537         /* set MAC TD pointer */
538         MACvSetCurrTXDescAddr(TYPE_TXDMA0, pDevice->PortOffset,
539                               (pDevice->td0_pool_dma));
540
541         MACvSetCurrTXDescAddr(TYPE_AC0DMA, pDevice->PortOffset,
542                               (pDevice->td1_pool_dma));
543
544         /* set MAC Beacon TX pointer */
545         MACvSetCurrBCNTxDescAddr(pDevice->PortOffset,
546                                  (pDevice->tx_beacon_dma));
547 }
548
549 /*
550  * Description:
551  *      Reset Rx
552  *
553  * Parameters:
554  *  In:
555  *      pDevice     - Pointer to the adapter
556  *  Out:
557  *      none
558  *
559  * Return Value: none
560  */
561 void
562 CARDvSafeResetRx(
563         struct vnt_private *pDevice
564 )
565 {
566         unsigned int uu;
567         PSRxDesc    pDesc;
568
569         /* initialize RD index */
570         pDevice->pCurrRD[0] = &(pDevice->aRD0Ring[0]);
571         pDevice->pCurrRD[1] = &(pDevice->aRD1Ring[0]);
572
573         /* init state, all RD is chip's */
574         for (uu = 0; uu < pDevice->sOpts.nRxDescs0; uu++) {
575                 pDesc = &(pDevice->aRD0Ring[uu]);
576                 pDesc->m_rd0RD0.wResCount = (unsigned short)(pDevice->rx_buf_sz);
577                 pDesc->m_rd0RD0.f1Owner = OWNED_BY_NIC;
578                 pDesc->m_rd1RD1.wReqCount = (unsigned short)(pDevice->rx_buf_sz);
579         }
580
581         /* init state, all RD is chip's */
582         for (uu = 0; uu < pDevice->sOpts.nRxDescs1; uu++) {
583                 pDesc = &(pDevice->aRD1Ring[uu]);
584                 pDesc->m_rd0RD0.wResCount = (unsigned short)(pDevice->rx_buf_sz);
585                 pDesc->m_rd0RD0.f1Owner = OWNED_BY_NIC;
586                 pDesc->m_rd1RD1.wReqCount = (unsigned short)(pDevice->rx_buf_sz);
587         }
588
589         /* set perPkt mode */
590         MACvRx0PerPktMode(pDevice->PortOffset);
591         MACvRx1PerPktMode(pDevice->PortOffset);
592         /* set MAC RD pointer */
593         MACvSetCurrRx0DescAddr(pDevice->PortOffset,
594                                pDevice->rd0_pool_dma);
595
596         MACvSetCurrRx1DescAddr(pDevice->PortOffset,
597                                pDevice->rd1_pool_dma);
598 }
599
600 /*
601  * Description: Get response Control frame rate in CCK mode
602  *
603  * Parameters:
604  *  In:
605  *      pDevice             - The adapter to be set
606  *      wRateIdx            - Receiving data rate
607  *  Out:
608  *      none
609  *
610  * Return Value: response Control frame rate
611  */
612 static unsigned short CARDwGetCCKControlRate(struct vnt_private *pDevice,
613                                              unsigned short wRateIdx)
614 {
615         unsigned int ui = (unsigned int) wRateIdx;
616
617         while (ui > RATE_1M) {
618                 if (pDevice->basic_rates & ((u32)0x1 << ui))
619                         return (unsigned short)ui;
620
621                 ui--;
622         }
623         return (unsigned short)RATE_1M;
624 }
625
626 /*
627  * Description: Get response Control frame rate in OFDM mode
628  *
629  * Parameters:
630  *  In:
631  *      pDevice             - The adapter to be set
632  *      wRateIdx            - Receiving data rate
633  *  Out:
634  *      none
635  *
636  * Return Value: response Control frame rate
637  */
638 static unsigned short CARDwGetOFDMControlRate(struct vnt_private *pDevice,
639                                               unsigned short wRateIdx)
640 {
641         unsigned int ui = (unsigned int) wRateIdx;
642
643         pr_debug("BASIC RATE: %X\n", pDevice->basic_rates);
644
645         if (!CARDbIsOFDMinBasicRate((void *)pDevice)) {
646                 pr_debug("CARDwGetOFDMControlRate:(NO OFDM) %d\n", wRateIdx);
647                 if (wRateIdx > RATE_24M)
648                         wRateIdx = RATE_24M;
649                 return wRateIdx;
650         }
651         while (ui > RATE_11M) {
652                 if (pDevice->basic_rates & ((u32)0x1 << ui)) {
653                         pr_debug("CARDwGetOFDMControlRate : %d\n", ui);
654                         return (unsigned short)ui;
655                 }
656                 ui--;
657         }
658         pr_debug("CARDwGetOFDMControlRate: 6M\n");
659         return (unsigned short)RATE_24M;
660 }
661
662 /*
663  * Description: Set RSPINF
664  *
665  * Parameters:
666  *  In:
667  *      pDevice             - The adapter to be set
668  *  Out:
669  *      none
670  *
671  * Return Value: None.
672  */
673 void CARDvSetRSPINF(struct vnt_private *pDevice, u8 bb_type)
674 {
675         union vnt_phy_field_swap phy;
676         unsigned char byTxRate, byRsvTime;      /* For OFDM */
677         unsigned long flags;
678
679         spin_lock_irqsave(&pDevice->lock, flags);
680
681         /* Set to Page1 */
682         MACvSelectPage1(pDevice->PortOffset);
683
684         /* RSPINF_b_1 */
685         vnt_get_phy_field(pDevice, 14,
686                           CARDwGetCCKControlRate(pDevice, RATE_1M),
687                           PK_TYPE_11B, &phy.field_read);
688
689          /* swap over to get correct write order */
690         swap(phy.swap[0], phy.swap[1]);
691
692         VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_1, phy.field_write);
693
694         /* RSPINF_b_2 */
695         vnt_get_phy_field(pDevice, 14,
696                           CARDwGetCCKControlRate(pDevice, RATE_2M),
697                           PK_TYPE_11B, &phy.field_read);
698
699         swap(phy.swap[0], phy.swap[1]);
700
701         VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_2, phy.field_write);
702
703         /* RSPINF_b_5 */
704         vnt_get_phy_field(pDevice, 14,
705                           CARDwGetCCKControlRate(pDevice, RATE_5M),
706                           PK_TYPE_11B, &phy.field_read);
707
708         swap(phy.swap[0], phy.swap[1]);
709
710         VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_5, phy.field_write);
711
712         /* RSPINF_b_11 */
713         vnt_get_phy_field(pDevice, 14,
714                           CARDwGetCCKControlRate(pDevice, RATE_11M),
715                           PK_TYPE_11B, &phy.field_read);
716
717         swap(phy.swap[0], phy.swap[1]);
718
719         VNSvOutPortD(pDevice->PortOffset + MAC_REG_RSPINF_B_11, phy.field_write);
720
721         /* RSPINF_a_6 */
722         s_vCalculateOFDMRParameter(RATE_6M,
723                                    bb_type,
724                                    &byTxRate,
725                                    &byRsvTime);
726         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_6, MAKEWORD(byTxRate, byRsvTime));
727         /* RSPINF_a_9 */
728         s_vCalculateOFDMRParameter(RATE_9M,
729                                    bb_type,
730                                    &byTxRate,
731                                    &byRsvTime);
732         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_9, MAKEWORD(byTxRate, byRsvTime));
733         /* RSPINF_a_12 */
734         s_vCalculateOFDMRParameter(RATE_12M,
735                                    bb_type,
736                                    &byTxRate,
737                                    &byRsvTime);
738         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_12, MAKEWORD(byTxRate, byRsvTime));
739         /* RSPINF_a_18 */
740         s_vCalculateOFDMRParameter(RATE_18M,
741                                    bb_type,
742                                    &byTxRate,
743                                    &byRsvTime);
744         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_18, MAKEWORD(byTxRate, byRsvTime));
745         /* RSPINF_a_24 */
746         s_vCalculateOFDMRParameter(RATE_24M,
747                                    bb_type,
748                                    &byTxRate,
749                                    &byRsvTime);
750         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_24, MAKEWORD(byTxRate, byRsvTime));
751         /* RSPINF_a_36 */
752         s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate((void *)pDevice, RATE_36M),
753                                    bb_type,
754                                    &byTxRate,
755                                    &byRsvTime);
756         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_36, MAKEWORD(byTxRate, byRsvTime));
757         /* RSPINF_a_48 */
758         s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate((void *)pDevice, RATE_48M),
759                                    bb_type,
760                                    &byTxRate,
761                                    &byRsvTime);
762         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_48, MAKEWORD(byTxRate, byRsvTime));
763         /* RSPINF_a_54 */
764         s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate((void *)pDevice, RATE_54M),
765                                    bb_type,
766                                    &byTxRate,
767                                    &byRsvTime);
768         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_54, MAKEWORD(byTxRate, byRsvTime));
769         /* RSPINF_a_72 */
770         s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate((void *)pDevice, RATE_54M),
771                                    bb_type,
772                                    &byTxRate,
773                                    &byRsvTime);
774         VNSvOutPortW(pDevice->PortOffset + MAC_REG_RSPINF_A_72, MAKEWORD(byTxRate, byRsvTime));
775         /* Set to Page0 */
776         MACvSelectPage0(pDevice->PortOffset);
777
778         spin_unlock_irqrestore(&pDevice->lock, flags);
779 }
780
781 void CARDvUpdateBasicTopRate(struct vnt_private *pDevice)
782 {
783         unsigned char byTopOFDM = RATE_24M, byTopCCK = RATE_1M;
784         unsigned char ii;
785
786         /* Determines the highest basic rate. */
787         for (ii = RATE_54M; ii >= RATE_6M; ii--) {
788                 if ((pDevice->basic_rates) & ((u32)(1 << ii))) {
789                         byTopOFDM = ii;
790                         break;
791                 }
792         }
793         pDevice->byTopOFDMBasicRate = byTopOFDM;
794
795         for (ii = RATE_11M;; ii--) {
796                 if ((pDevice->basic_rates) & ((u32)(1 << ii))) {
797                         byTopCCK = ii;
798                         break;
799                 }
800                 if (ii == RATE_1M)
801                         break;
802         }
803         pDevice->byTopCCKBasicRate = byTopCCK;
804 }
805
806 bool CARDbIsOFDMinBasicRate(struct vnt_private *pDevice)
807 {
808         int ii;
809
810         for (ii = RATE_54M; ii >= RATE_6M; ii--) {
811                 if ((pDevice->basic_rates) & ((u32)(1 << ii)))
812                         return true;
813         }
814         return false;
815 }
816
817 unsigned char CARDbyGetPktType(struct vnt_private *pDevice)
818 {
819
820         if (pDevice->byBBType == BB_TYPE_11A || pDevice->byBBType == BB_TYPE_11B)
821                 return (unsigned char)pDevice->byBBType;
822         else if (CARDbIsOFDMinBasicRate((void *)pDevice))
823                 return PK_TYPE_11GA;
824         else
825                 return PK_TYPE_11GB;
826 }
827
828 /*
829  * Description: Set NIC Loopback mode
830  *
831  * Parameters:
832  *  In:
833  *      pDevice         - The adapter to be set
834  *      wLoopbackMode   - Loopback mode to be set
835  *  Out:
836  *      none
837  *
838  * Return Value: none
839  */
840 void CARDvSetLoopbackMode(struct vnt_private *priv, unsigned short wLoopbackMode)
841 {
842         void __iomem *dwIoBase = priv->PortOffset;
843
844         switch (wLoopbackMode) {
845         case CARD_LB_NONE:
846         case CARD_LB_MAC:
847         case CARD_LB_PHY:
848                 break;
849         default:
850                 ASSERT(false);
851                 break;
852         }
853         /* set MAC loopback */
854         MACvSetLoopbackMode(dwIoBase, LOBYTE(wLoopbackMode));
855         /* set Baseband loopback */
856 }
857
858 /*
859  * Description: Software Reset NIC
860  *
861  * Parameters:
862  *  In:
863  *      pDevice         - The adapter to be reset
864  *  Out:
865  *      none
866  *
867  * Return Value: none
868  */
869 bool CARDbSoftwareReset(struct vnt_private *pDevice)
870 {
871
872         /* reset MAC */
873         if (!MACbSafeSoftwareReset(pDevice->PortOffset))
874                 return false;
875
876         return true;
877 }
878
879 /*
880  * Description: Calculate TSF offset of two TSF input
881  *              Get TSF Offset from RxBCN's TSF and local TSF
882  *
883  * Parameters:
884  *  In:
885  *      pDevice         - The adapter to be sync.
886  *      qwTSF1          - Rx BCN's TSF
887  *      qwTSF2          - Local TSF
888  *  Out:
889  *      none
890  *
891  * Return Value: TSF Offset value
892  */
893 u64 CARDqGetTSFOffset(unsigned char byRxRate, u64 qwTSF1, u64 qwTSF2)
894 {
895         u64 qwTSFOffset = 0;
896         unsigned short wRxBcnTSFOffst = 0;
897
898         wRxBcnTSFOffst = cwRXBCNTSFOff[byRxRate%MAX_RATE];
899
900         qwTSF2 += (u64)wRxBcnTSFOffst;
901
902         qwTSFOffset = qwTSF1 - qwTSF2;
903
904         return qwTSFOffset;
905 }
906
907 /*
908  * Description: Read NIC TSF counter
909  *              Get local TSF counter
910  *
911  * Parameters:
912  *  In:
913  *      pDevice         - The adapter to be read
914  *  Out:
915  *      qwCurrTSF       - Current TSF counter
916  *
917  * Return Value: true if success; otherwise false
918  */
919 bool CARDbGetCurrentTSF(struct vnt_private *priv, u64 *pqwCurrTSF)
920 {
921         void __iomem *dwIoBase = priv->PortOffset;
922         unsigned short ww;
923         unsigned char byData;
924
925         MACvRegBitsOn(dwIoBase, MAC_REG_TFTCTL, TFTCTL_TSFCNTRRD);
926         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
927                 VNSvInPortB(dwIoBase + MAC_REG_TFTCTL, &byData);
928                 if (!(byData & TFTCTL_TSFCNTRRD))
929                         break;
930         }
931         if (ww == W_MAX_TIMEOUT)
932                 return false;
933         VNSvInPortD(dwIoBase + MAC_REG_TSFCNTR, (u32 *)pqwCurrTSF);
934         VNSvInPortD(dwIoBase + MAC_REG_TSFCNTR + 4, (u32 *)pqwCurrTSF + 1);
935
936         return true;
937 }
938
939 /*
940  * Description: Read NIC TSF counter
941  *              Get NEXTTBTT from adjusted TSF and Beacon Interval
942  *
943  * Parameters:
944  *  In:
945  *      qwTSF           - Current TSF counter
946  *      wbeaconInterval - Beacon Interval
947  *  Out:
948  *      qwCurrTSF       - Current TSF counter
949  *
950  * Return Value: TSF value of next Beacon
951  */
952 u64 CARDqGetNextTBTT(u64 qwTSF, unsigned short wBeaconInterval)
953 {
954         u32 beacon_int;
955
956         beacon_int = wBeaconInterval * 1024;
957         if (beacon_int) {
958                 do_div(qwTSF, beacon_int);
959                 qwTSF += 1;
960                 qwTSF *= beacon_int;
961         }
962
963         return qwTSF;
964 }
965
966 /*
967  * Description: Set NIC TSF counter for first Beacon time
968  *              Get NEXTTBTT from adjusted TSF and Beacon Interval
969  *
970  * Parameters:
971  *  In:
972  *      dwIoBase        - IO Base
973  *      wBeaconInterval - Beacon Interval
974  *  Out:
975  *      none
976  *
977  * Return Value: none
978  */
979 void CARDvSetFirstNextTBTT(struct vnt_private *priv, unsigned short wBeaconInterval)
980 {
981         void __iomem *dwIoBase = priv->PortOffset;
982         u64 qwNextTBTT = 0;
983
984         CARDbGetCurrentTSF(priv, &qwNextTBTT); /* Get Local TSF counter */
985
986         qwNextTBTT = CARDqGetNextTBTT(qwNextTBTT, wBeaconInterval);
987         /* Set NextTBTT */
988         VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT, (u32)qwNextTBTT);
989         VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT + 4, (u32)(qwNextTBTT >> 32));
990         MACvRegBitsOn(dwIoBase, MAC_REG_TFTCTL, TFTCTL_TBTTSYNCEN);
991 }
992
993 /*
994  * Description: Sync NIC TSF counter for Beacon time
995  *              Get NEXTTBTT and write to HW
996  *
997  * Parameters:
998  *  In:
999  *      pDevice         - The adapter to be set
1000  *      qwTSF           - Current TSF counter
1001  *      wBeaconInterval - Beacon Interval
1002  *  Out:
1003  *      none
1004  *
1005  * Return Value: none
1006  */
1007 void CARDvUpdateNextTBTT(struct vnt_private *priv, u64 qwTSF, unsigned short wBeaconInterval)
1008 {
1009         void __iomem *dwIoBase = priv->PortOffset;
1010
1011         qwTSF = CARDqGetNextTBTT(qwTSF, wBeaconInterval);
1012         /* Set NextTBTT */
1013         VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT, (u32)qwTSF);
1014         VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT + 4, (u32)(qwTSF >> 32));
1015         MACvRegBitsOn(dwIoBase, MAC_REG_TFTCTL, TFTCTL_TBTTSYNCEN);
1016         pr_debug("Card:Update Next TBTT[%8llx]\n", qwTSF);
1017 }