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
s_vCalculateOFDMRParameter(unsigned char byRate,u8 bb_type,unsigned char * pbyTxRate,unsigned char * pbyRsvTime)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 * priv - The adapter to be set
201 * Out:
202 * none
203 *
204 * Return Value: None.
205 */
CARDbSetPhyParameter(struct vnt_private * priv,u8 bb_type)206 bool CARDbSetPhyParameter(struct vnt_private *priv, 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 (priv->byRFType == RF_AIROHA7230) {
218 /* AL7230 use single PAPE and connect to PAPE_2.4G */
219 MACvSetBBType(priv->PortOffset, BB_TYPE_11G);
220 priv->abyBBVGA[0] = 0x20;
221 priv->abyBBVGA[2] = 0x10;
222 priv->abyBBVGA[3] = 0x10;
223 BBbReadEmbedded(priv, 0xE7, &byData);
224 if (byData == 0x1C)
225 BBbWriteEmbedded(priv, 0xE7, priv->abyBBVGA[0]);
226
227 } else if (priv->byRFType == RF_UW2452) {
228 MACvSetBBType(priv->PortOffset, BB_TYPE_11A);
229 priv->abyBBVGA[0] = 0x18;
230 BBbReadEmbedded(priv, 0xE7, &byData);
231 if (byData == 0x14) {
232 BBbWriteEmbedded(priv, 0xE7, priv->abyBBVGA[0]);
233 BBbWriteEmbedded(priv, 0xE1, 0x57);
234 }
235 } else {
236 MACvSetBBType(priv->PortOffset, BB_TYPE_11A);
237 }
238 BBbWriteEmbedded(priv, 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(priv->PortOffset, BB_TYPE_11B);
245 if (priv->byRFType == RF_AIROHA7230) {
246 priv->abyBBVGA[0] = 0x1C;
247 priv->abyBBVGA[2] = 0x00;
248 priv->abyBBVGA[3] = 0x00;
249 BBbReadEmbedded(priv, 0xE7, &byData);
250 if (byData == 0x20)
251 BBbWriteEmbedded(priv, 0xE7, priv->abyBBVGA[0]);
252
253 } else if (priv->byRFType == RF_UW2452) {
254 priv->abyBBVGA[0] = 0x14;
255 BBbReadEmbedded(priv, 0xE7, &byData);
256 if (byData == 0x18) {
257 BBbWriteEmbedded(priv, 0xE7, priv->abyBBVGA[0]);
258 BBbWriteEmbedded(priv, 0xE1, 0xD3);
259 }
260 }
261 BBbWriteEmbedded(priv, 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(priv->PortOffset, BB_TYPE_11G);
268 if (priv->byRFType == RF_AIROHA7230) {
269 priv->abyBBVGA[0] = 0x1C;
270 priv->abyBBVGA[2] = 0x00;
271 priv->abyBBVGA[3] = 0x00;
272 BBbReadEmbedded(priv, 0xE7, &byData);
273 if (byData == 0x20)
274 BBbWriteEmbedded(priv, 0xE7, priv->abyBBVGA[0]);
275
276 } else if (priv->byRFType == RF_UW2452) {
277 priv->abyBBVGA[0] = 0x14;
278 BBbReadEmbedded(priv, 0xE7, &byData);
279 if (byData == 0x18) {
280 BBbWriteEmbedded(priv, 0xE7, priv->abyBBVGA[0]);
281 BBbWriteEmbedded(priv, 0xE1, 0xD3);
282 }
283 }
284 BBbWriteEmbedded(priv, 0x88, 0x08);
285 bySIFS = C_SIFS_BG;
286
287 if (priv->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 (priv->basic_rates & ((u32)(0x1 << i))) {
299 byCWMaxMin |= 0x1;
300 break;
301 }
302 }
303 }
304
305 if (priv->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 (priv->bySIFS != bySIFS) {
320 priv->bySIFS = bySIFS;
321 VNSvOutPortB(priv->PortOffset + MAC_REG_SIFS, priv->bySIFS);
322 }
323 if (priv->byDIFS != byDIFS) {
324 priv->byDIFS = byDIFS;
325 VNSvOutPortB(priv->PortOffset + MAC_REG_DIFS, priv->byDIFS);
326 }
327 if (priv->byEIFS != C_EIFS) {
328 priv->byEIFS = C_EIFS;
329 VNSvOutPortB(priv->PortOffset + MAC_REG_EIFS, priv->byEIFS);
330 }
331 if (priv->bySlot != bySlot) {
332 priv->bySlot = bySlot;
333 VNSvOutPortB(priv->PortOffset + MAC_REG_SLOT, priv->bySlot);
334
335 BBvSetShortSlotTime(priv);
336 }
337 if (priv->byCWMaxMin != byCWMaxMin) {
338 priv->byCWMaxMin = byCWMaxMin;
339 VNSvOutPortB(priv->PortOffset + MAC_REG_CWMAXMIN0, priv->byCWMaxMin);
340 }
341
342 priv->byPacketType = CARDbyGetPktType(priv);
343
344 CARDvSetRSPINF(priv, 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 * priv - 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 */
CARDbUpdateTSF(struct vnt_private * priv,unsigned char byRxRate,u64 qwBSSTimestamp)364 bool CARDbUpdateTSF(struct vnt_private *priv, unsigned char byRxRate,
365 u64 qwBSSTimestamp)
366 {
367 u64 local_tsf;
368 u64 qwTSFOffset = 0;
369
370 CARDbGetCurrentTSF(priv, &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(priv->PortOffset + MAC_REG_TSFOFST, (u32)qwTSFOffset);
377 VNSvOutPortD(priv->PortOffset + MAC_REG_TSFOFST + 4, (u32)(qwTSFOffset >> 32));
378 MACvRegBitsOn(priv->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 * priv - The adapter to be set.
390 * wBeaconInterval - Beacon Interval
391 * Out:
392 * none
393 *
394 * Return Value: true if succeed; otherwise false
395 */
CARDbSetBeaconPeriod(struct vnt_private * priv,unsigned short wBeaconInterval)396 bool CARDbSetBeaconPeriod(struct vnt_private *priv,
397 unsigned short wBeaconInterval)
398 {
399 u64 qwNextTBTT = 0;
400
401 CARDbGetCurrentTSF(priv, &qwNextTBTT); /* Get Local TSF counter */
402
403 qwNextTBTT = CARDqGetNextTBTT(qwNextTBTT, wBeaconInterval);
404
405 /* set HW beacon interval */
406 VNSvOutPortW(priv->PortOffset + MAC_REG_BI, wBeaconInterval);
407 priv->wBeaconInterval = wBeaconInterval;
408 /* Set NextTBTT */
409 VNSvOutPortD(priv->PortOffset + MAC_REG_NEXTTBTT, (u32)qwNextTBTT);
410 VNSvOutPortD(priv->PortOffset + MAC_REG_NEXTTBTT + 4, (u32)(qwNextTBTT >> 32));
411 MACvRegBitsOn(priv->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 * priv - The adapter to be turned off
422 * Out:
423 * none
424 *
425 * Return Value: true if success; otherwise false
426 */
CARDbRadioPowerOff(struct vnt_private * priv)427 bool CARDbRadioPowerOff(struct vnt_private *priv)
428 {
429 bool bResult = true;
430
431 if (priv->bRadioOff)
432 return true;
433
434 switch (priv->byRFType) {
435 case RF_RFMD2959:
436 MACvWordRegBitsOff(priv->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_TXPEINV);
437 MACvWordRegBitsOn(priv->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPE1);
438 break;
439
440 case RF_AIROHA:
441 case RF_AL2230S:
442 case RF_AIROHA7230:
443 MACvWordRegBitsOff(priv->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPE2);
444 MACvWordRegBitsOff(priv->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPE3);
445 break;
446
447 }
448
449 MACvRegBitsOff(priv->PortOffset, MAC_REG_HOSTCR, HOSTCR_RXON);
450
451 BBvSetDeepSleep(priv, priv->byLocalID);
452
453 priv->bRadioOff = true;
454 pr_debug("chester power off\n");
455 MACvRegBitsOn(priv->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 * priv - The adapter to be turned on
465 * Out:
466 * none
467 *
468 * Return Value: true if success; otherwise false
469 */
CARDbRadioPowerOn(struct vnt_private * priv)470 bool CARDbRadioPowerOn(struct vnt_private *priv)
471 {
472 bool bResult = true;
473
474 pr_debug("chester power on\n");
475 if (priv->bRadioControlOff) {
476 if (priv->bHWRadioOff)
477 pr_debug("chester bHWRadioOff\n");
478 if (priv->bRadioControlOff)
479 pr_debug("chester bRadioControlOff\n");
480 return false; }
481
482 if (!priv->bRadioOff) {
483 pr_debug("chester pbRadioOff\n");
484 return true; }
485
486 BBvExitDeepSleep(priv, priv->byLocalID);
487
488 MACvRegBitsOn(priv->PortOffset, MAC_REG_HOSTCR, HOSTCR_RXON);
489
490 switch (priv->byRFType) {
491 case RF_RFMD2959:
492 MACvWordRegBitsOn(priv->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_TXPEINV);
493 MACvWordRegBitsOff(priv->PortOffset, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPE1);
494 break;
495
496 case RF_AIROHA:
497 case RF_AL2230S:
498 case RF_AIROHA7230:
499 MACvWordRegBitsOn(priv->PortOffset, MAC_REG_SOFTPWRCTL, (SOFTPWRCTL_SWPE2 |
500 SOFTPWRCTL_SWPE3));
501 break;
502
503 }
504
505 priv->bRadioOff = false;
506 pr_debug("chester power on\n");
507 MACvRegBitsOff(priv->PortOffset, MAC_REG_GPIOCTL0, LED_ACTSET); /* LED issue */
508 return bResult;
509 }
510
511 void
CARDvSafeResetTx(struct vnt_private * priv)512 CARDvSafeResetTx(
513 struct vnt_private *priv
514 )
515 {
516 unsigned int uu;
517 struct vnt_tx_desc *pCurrTD;
518
519 /* initialize TD index */
520 priv->apTailTD[0] = priv->apCurrTD[0] = &(priv->apTD0Rings[0]);
521 priv->apTailTD[1] = priv->apCurrTD[1] = &(priv->apTD1Rings[0]);
522
523 for (uu = 0; uu < TYPE_MAXTD; uu++)
524 priv->iTDUsed[uu] = 0;
525
526 for (uu = 0; uu < priv->opts.tx_descs[0]; uu++) {
527 pCurrTD = &(priv->apTD0Rings[uu]);
528 pCurrTD->td0.owner = OWNED_BY_HOST;
529 /* init all Tx Packet pointer to NULL */
530 }
531 for (uu = 0; uu < priv->opts.tx_descs[1]; uu++) {
532 pCurrTD = &(priv->apTD1Rings[uu]);
533 pCurrTD->td0.owner = OWNED_BY_HOST;
534 /* init all Tx Packet pointer to NULL */
535 }
536
537 /* set MAC TD pointer */
538 MACvSetCurrTXDescAddr(TYPE_TXDMA0, priv->PortOffset,
539 (priv->td0_pool_dma));
540
541 MACvSetCurrTXDescAddr(TYPE_AC0DMA, priv->PortOffset,
542 (priv->td1_pool_dma));
543
544 /* set MAC Beacon TX pointer */
545 MACvSetCurrBCNTxDescAddr(priv->PortOffset,
546 (priv->tx_beacon_dma));
547 }
548
549 /*
550 * Description:
551 * Reset Rx
552 *
553 * Parameters:
554 * In:
555 * priv - Pointer to the adapter
556 * Out:
557 * none
558 *
559 * Return Value: none
560 */
561 void
CARDvSafeResetRx(struct vnt_private * priv)562 CARDvSafeResetRx(
563 struct vnt_private *priv
564 )
565 {
566 unsigned int uu;
567 struct vnt_rx_desc *pDesc;
568
569 /* initialize RD index */
570 priv->pCurrRD[0] = &(priv->aRD0Ring[0]);
571 priv->pCurrRD[1] = &(priv->aRD1Ring[0]);
572
573 /* init state, all RD is chip's */
574 for (uu = 0; uu < priv->opts.rx_descs0; uu++) {
575 pDesc = &(priv->aRD0Ring[uu]);
576 pDesc->rd0.res_count = cpu_to_le16(priv->rx_buf_sz);
577 pDesc->rd0.owner = OWNED_BY_NIC;
578 pDesc->rd1.req_count = cpu_to_le16(priv->rx_buf_sz);
579 }
580
581 /* init state, all RD is chip's */
582 for (uu = 0; uu < priv->opts.rx_descs1; uu++) {
583 pDesc = &(priv->aRD1Ring[uu]);
584 pDesc->rd0.res_count = cpu_to_le16(priv->rx_buf_sz);
585 pDesc->rd0.owner = OWNED_BY_NIC;
586 pDesc->rd1.req_count = cpu_to_le16(priv->rx_buf_sz);
587 }
588
589 /* set perPkt mode */
590 MACvRx0PerPktMode(priv->PortOffset);
591 MACvRx1PerPktMode(priv->PortOffset);
592 /* set MAC RD pointer */
593 MACvSetCurrRx0DescAddr(priv->PortOffset,
594 priv->rd0_pool_dma);
595
596 MACvSetCurrRx1DescAddr(priv->PortOffset,
597 priv->rd1_pool_dma);
598 }
599
600 /*
601 * Description: Get response Control frame rate in CCK mode
602 *
603 * Parameters:
604 * In:
605 * priv - The adapter to be set
606 * wRateIdx - Receiving data rate
607 * Out:
608 * none
609 *
610 * Return Value: response Control frame rate
611 */
CARDwGetCCKControlRate(struct vnt_private * priv,unsigned short wRateIdx)612 static unsigned short CARDwGetCCKControlRate(struct vnt_private *priv,
613 unsigned short wRateIdx)
614 {
615 unsigned int ui = (unsigned int) wRateIdx;
616
617 while (ui > RATE_1M) {
618 if (priv->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 * priv - The adapter to be set
632 * wRateIdx - Receiving data rate
633 * Out:
634 * none
635 *
636 * Return Value: response Control frame rate
637 */
CARDwGetOFDMControlRate(struct vnt_private * priv,unsigned short wRateIdx)638 static unsigned short CARDwGetOFDMControlRate(struct vnt_private *priv,
639 unsigned short wRateIdx)
640 {
641 unsigned int ui = (unsigned int) wRateIdx;
642
643 pr_debug("BASIC RATE: %X\n", priv->basic_rates);
644
645 if (!CARDbIsOFDMinBasicRate((void *)priv)) {
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 (priv->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 * priv - The adapter to be set
668 * Out:
669 * none
670 *
671 * Return Value: None.
672 */
CARDvSetRSPINF(struct vnt_private * priv,u8 bb_type)673 void CARDvSetRSPINF(struct vnt_private *priv, 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(&priv->lock, flags);
680
681 /* Set to Page1 */
682 MACvSelectPage1(priv->PortOffset);
683
684 /* RSPINF_b_1 */
685 vnt_get_phy_field(priv, 14,
686 CARDwGetCCKControlRate(priv, 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(priv->PortOffset + MAC_REG_RSPINF_B_1, phy.field_write);
693
694 /* RSPINF_b_2 */
695 vnt_get_phy_field(priv, 14,
696 CARDwGetCCKControlRate(priv, RATE_2M),
697 PK_TYPE_11B, &phy.field_read);
698
699 swap(phy.swap[0], phy.swap[1]);
700
701 VNSvOutPortD(priv->PortOffset + MAC_REG_RSPINF_B_2, phy.field_write);
702
703 /* RSPINF_b_5 */
704 vnt_get_phy_field(priv, 14,
705 CARDwGetCCKControlRate(priv, RATE_5M),
706 PK_TYPE_11B, &phy.field_read);
707
708 swap(phy.swap[0], phy.swap[1]);
709
710 VNSvOutPortD(priv->PortOffset + MAC_REG_RSPINF_B_5, phy.field_write);
711
712 /* RSPINF_b_11 */
713 vnt_get_phy_field(priv, 14,
714 CARDwGetCCKControlRate(priv, RATE_11M),
715 PK_TYPE_11B, &phy.field_read);
716
717 swap(phy.swap[0], phy.swap[1]);
718
719 VNSvOutPortD(priv->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(priv->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(priv->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(priv->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(priv->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(priv->PortOffset + MAC_REG_RSPINF_A_24, MAKEWORD(byTxRate, byRsvTime));
751 /* RSPINF_a_36 */
752 s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate((void *)priv, RATE_36M),
753 bb_type,
754 &byTxRate,
755 &byRsvTime);
756 VNSvOutPortW(priv->PortOffset + MAC_REG_RSPINF_A_36, MAKEWORD(byTxRate, byRsvTime));
757 /* RSPINF_a_48 */
758 s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate((void *)priv, RATE_48M),
759 bb_type,
760 &byTxRate,
761 &byRsvTime);
762 VNSvOutPortW(priv->PortOffset + MAC_REG_RSPINF_A_48, MAKEWORD(byTxRate, byRsvTime));
763 /* RSPINF_a_54 */
764 s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate((void *)priv, RATE_54M),
765 bb_type,
766 &byTxRate,
767 &byRsvTime);
768 VNSvOutPortW(priv->PortOffset + MAC_REG_RSPINF_A_54, MAKEWORD(byTxRate, byRsvTime));
769 /* RSPINF_a_72 */
770 s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate((void *)priv, RATE_54M),
771 bb_type,
772 &byTxRate,
773 &byRsvTime);
774 VNSvOutPortW(priv->PortOffset + MAC_REG_RSPINF_A_72, MAKEWORD(byTxRate, byRsvTime));
775 /* Set to Page0 */
776 MACvSelectPage0(priv->PortOffset);
777
778 spin_unlock_irqrestore(&priv->lock, flags);
779 }
780
CARDvUpdateBasicTopRate(struct vnt_private * priv)781 void CARDvUpdateBasicTopRate(struct vnt_private *priv)
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 ((priv->basic_rates) & ((u32)(1 << ii))) {
789 byTopOFDM = ii;
790 break;
791 }
792 }
793 priv->byTopOFDMBasicRate = byTopOFDM;
794
795 for (ii = RATE_11M;; ii--) {
796 if ((priv->basic_rates) & ((u32)(1 << ii))) {
797 byTopCCK = ii;
798 break;
799 }
800 if (ii == RATE_1M)
801 break;
802 }
803 priv->byTopCCKBasicRate = byTopCCK;
804 }
805
CARDbIsOFDMinBasicRate(struct vnt_private * priv)806 bool CARDbIsOFDMinBasicRate(struct vnt_private *priv)
807 {
808 int ii;
809
810 for (ii = RATE_54M; ii >= RATE_6M; ii--) {
811 if ((priv->basic_rates) & ((u32)BIT(ii)))
812 return true;
813 }
814 return false;
815 }
816
CARDbyGetPktType(struct vnt_private * priv)817 unsigned char CARDbyGetPktType(struct vnt_private *priv)
818 {
819
820 if (priv->byBBType == BB_TYPE_11A || priv->byBBType == BB_TYPE_11B)
821 return (unsigned char)priv->byBBType;
822 else if (CARDbIsOFDMinBasicRate((void *)priv))
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 * priv - The adapter to be set
834 * wLoopbackMode - Loopback mode to be set
835 * Out:
836 * none
837 *
838 * Return Value: none
839 */
CARDvSetLoopbackMode(struct vnt_private * priv,unsigned short wLoopbackMode)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 break;
851 }
852 /* set MAC loopback */
853 MACvSetLoopbackMode(dwIoBase, LOBYTE(wLoopbackMode));
854 /* set Baseband loopback */
855 }
856
857 /*
858 * Description: Software Reset NIC
859 *
860 * Parameters:
861 * In:
862 * priv - The adapter to be reset
863 * Out:
864 * none
865 *
866 * Return Value: none
867 */
CARDbSoftwareReset(struct vnt_private * priv)868 bool CARDbSoftwareReset(struct vnt_private *priv)
869 {
870
871 /* reset MAC */
872 if (!MACbSafeSoftwareReset(priv->PortOffset))
873 return false;
874
875 return true;
876 }
877
878 /*
879 * Description: Calculate TSF offset of two TSF input
880 * Get TSF Offset from RxBCN's TSF and local TSF
881 *
882 * Parameters:
883 * In:
884 * priv - The adapter to be sync.
885 * qwTSF1 - Rx BCN's TSF
886 * qwTSF2 - Local TSF
887 * Out:
888 * none
889 *
890 * Return Value: TSF Offset value
891 */
CARDqGetTSFOffset(unsigned char byRxRate,u64 qwTSF1,u64 qwTSF2)892 u64 CARDqGetTSFOffset(unsigned char byRxRate, u64 qwTSF1, u64 qwTSF2)
893 {
894 u64 qwTSFOffset = 0;
895 unsigned short wRxBcnTSFOffst;
896
897 wRxBcnTSFOffst = cwRXBCNTSFOff[byRxRate%MAX_RATE];
898
899 qwTSF2 += (u64)wRxBcnTSFOffst;
900
901 qwTSFOffset = qwTSF1 - qwTSF2;
902
903 return qwTSFOffset;
904 }
905
906 /*
907 * Description: Read NIC TSF counter
908 * Get local TSF counter
909 *
910 * Parameters:
911 * In:
912 * priv - The adapter to be read
913 * Out:
914 * qwCurrTSF - Current TSF counter
915 *
916 * Return Value: true if success; otherwise false
917 */
CARDbGetCurrentTSF(struct vnt_private * priv,u64 * pqwCurrTSF)918 bool CARDbGetCurrentTSF(struct vnt_private *priv, u64 *pqwCurrTSF)
919 {
920 void __iomem *dwIoBase = priv->PortOffset;
921 unsigned short ww;
922 unsigned char byData;
923
924 MACvRegBitsOn(dwIoBase, MAC_REG_TFTCTL, TFTCTL_TSFCNTRRD);
925 for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
926 VNSvInPortB(dwIoBase + MAC_REG_TFTCTL, &byData);
927 if (!(byData & TFTCTL_TSFCNTRRD))
928 break;
929 }
930 if (ww == W_MAX_TIMEOUT)
931 return false;
932 VNSvInPortD(dwIoBase + MAC_REG_TSFCNTR, (u32 *)pqwCurrTSF);
933 VNSvInPortD(dwIoBase + MAC_REG_TSFCNTR + 4, (u32 *)pqwCurrTSF + 1);
934
935 return true;
936 }
937
938 /*
939 * Description: Read NIC TSF counter
940 * Get NEXTTBTT from adjusted TSF and Beacon Interval
941 *
942 * Parameters:
943 * In:
944 * qwTSF - Current TSF counter
945 * wbeaconInterval - Beacon Interval
946 * Out:
947 * qwCurrTSF - Current TSF counter
948 *
949 * Return Value: TSF value of next Beacon
950 */
CARDqGetNextTBTT(u64 qwTSF,unsigned short wBeaconInterval)951 u64 CARDqGetNextTBTT(u64 qwTSF, unsigned short wBeaconInterval)
952 {
953 u32 beacon_int;
954
955 beacon_int = wBeaconInterval * 1024;
956 if (beacon_int) {
957 do_div(qwTSF, beacon_int);
958 qwTSF += 1;
959 qwTSF *= beacon_int;
960 }
961
962 return qwTSF;
963 }
964
965 /*
966 * Description: Set NIC TSF counter for first Beacon time
967 * Get NEXTTBTT from adjusted TSF and Beacon Interval
968 *
969 * Parameters:
970 * In:
971 * dwIoBase - IO Base
972 * wBeaconInterval - Beacon Interval
973 * Out:
974 * none
975 *
976 * Return Value: none
977 */
CARDvSetFirstNextTBTT(struct vnt_private * priv,unsigned short wBeaconInterval)978 void CARDvSetFirstNextTBTT(struct vnt_private *priv, unsigned short wBeaconInterval)
979 {
980 void __iomem *dwIoBase = priv->PortOffset;
981 u64 qwNextTBTT = 0;
982
983 CARDbGetCurrentTSF(priv, &qwNextTBTT); /* Get Local TSF counter */
984
985 qwNextTBTT = CARDqGetNextTBTT(qwNextTBTT, wBeaconInterval);
986 /* Set NextTBTT */
987 VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT, (u32)qwNextTBTT);
988 VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT + 4, (u32)(qwNextTBTT >> 32));
989 MACvRegBitsOn(dwIoBase, MAC_REG_TFTCTL, TFTCTL_TBTTSYNCEN);
990 }
991
992 /*
993 * Description: Sync NIC TSF counter for Beacon time
994 * Get NEXTTBTT and write to HW
995 *
996 * Parameters:
997 * In:
998 * priv - The adapter to be set
999 * qwTSF - Current TSF counter
1000 * wBeaconInterval - Beacon Interval
1001 * Out:
1002 * none
1003 *
1004 * Return Value: none
1005 */
CARDvUpdateNextTBTT(struct vnt_private * priv,u64 qwTSF,unsigned short wBeaconInterval)1006 void CARDvUpdateNextTBTT(struct vnt_private *priv, u64 qwTSF, unsigned short wBeaconInterval)
1007 {
1008 void __iomem *dwIoBase = priv->PortOffset;
1009
1010 qwTSF = CARDqGetNextTBTT(qwTSF, wBeaconInterval);
1011 /* Set NextTBTT */
1012 VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT, (u32)qwTSF);
1013 VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT + 4, (u32)(qwTSF >> 32));
1014 MACvRegBitsOn(dwIoBase, MAC_REG_TFTCTL, TFTCTL_TBTTSYNCEN);
1015 pr_debug("Card:Update Next TBTT[%8llx]\n", qwTSF);
1016 }
1017