projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'trace-v4.7-3' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt...
[deliverable/linux.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 * priv - The adapter to be set
201 * Out:
202 * none
203 *
204 * Return Value: None.
205 */
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,
340 priv->byCWMaxMin);
341 }
342
343 priv->byPacketType = CARDbyGetPktType(priv);
344
345 CARDvSetRSPINF(priv, bb_type);
346
347 return true;
348 }
349
350 /*
351 * Description: Sync. TSF counter to BSS
352 * Get TSF offset and write to HW
353 *
354 * Parameters:
355 * In:
356 * priv - The adapter to be sync.
357 * byRxRate - data rate of receive beacon
358 * qwBSSTimestamp - Rx BCN's TSF
359 * qwLocalTSF - Local TSF
360 * Out:
361 * none
362 *
363 * Return Value: none
364 */
365 bool CARDbUpdateTSF(struct vnt_private *priv, unsigned char byRxRate,
366 u64 qwBSSTimestamp)
367 {
368 u64 local_tsf;
369 u64 qwTSFOffset = 0;
370
371 CARDbGetCurrentTSF(priv, &local_tsf);
372
373 if (qwBSSTimestamp != local_tsf) {
374 qwTSFOffset = CARDqGetTSFOffset(byRxRate, qwBSSTimestamp,
375 local_tsf);
376 /* adjust TSF, HW's TSF add TSF Offset reg */
377 VNSvOutPortD(priv->PortOffset + MAC_REG_TSFOFST,
378 (u32)qwTSFOffset);
379 VNSvOutPortD(priv->PortOffset + MAC_REG_TSFOFST + 4,
380 (u32)(qwTSFOffset >> 32));
381 MACvRegBitsOn(priv->PortOffset, MAC_REG_TFTCTL,
382 TFTCTL_TSFSYNCEN);
383 }
384 return true;
385 }
386
387 /*
388 * Description: Set NIC TSF counter for first Beacon time
389 * Get NEXTTBTT from adjusted TSF and Beacon Interval
390 *
391 * Parameters:
392 * In:
393 * priv - The adapter to be set.
394 * wBeaconInterval - Beacon Interval
395 * Out:
396 * none
397 *
398 * Return Value: true if succeed; otherwise false
399 */
400 bool CARDbSetBeaconPeriod(struct vnt_private *priv,
401 unsigned short wBeaconInterval)
402 {
403 u64 qwNextTBTT = 0;
404
405 CARDbGetCurrentTSF(priv, &qwNextTBTT); /* Get Local TSF counter */
406
407 qwNextTBTT = CARDqGetNextTBTT(qwNextTBTT, wBeaconInterval);
408
409 /* set HW beacon interval */
410 VNSvOutPortW(priv->PortOffset + MAC_REG_BI, wBeaconInterval);
411 priv->wBeaconInterval = wBeaconInterval;
412 /* Set NextTBTT */
413 VNSvOutPortD(priv->PortOffset + MAC_REG_NEXTTBTT, (u32)qwNextTBTT);
414 VNSvOutPortD(priv->PortOffset + MAC_REG_NEXTTBTT + 4,
415 (u32)(qwNextTBTT >> 32));
416 MACvRegBitsOn(priv->PortOffset, MAC_REG_TFTCTL, TFTCTL_TBTTSYNCEN);
417
418 return true;
419 }
420
421 /*
422 * Description: Turn off Radio power
423 *
424 * Parameters:
425 * In:
426 * priv - The adapter to be turned off
427 * Out:
428 * none
429 *
430 * Return Value: true if success; otherwise false
431 */
432 bool CARDbRadioPowerOff(struct vnt_private *priv)
433 {
434 bool bResult = true;
435
436 if (priv->bRadioOff)
437 return true;
438
439 switch (priv->byRFType) {
440 case RF_RFMD2959:
441 MACvWordRegBitsOff(priv->PortOffset, MAC_REG_SOFTPWRCTL,
442 SOFTPWRCTL_TXPEINV);
443 MACvWordRegBitsOn(priv->PortOffset, MAC_REG_SOFTPWRCTL,
444 SOFTPWRCTL_SWPE1);
445 break;
446
447 case RF_AIROHA:
448 case RF_AL2230S:
449 case RF_AIROHA7230:
450 MACvWordRegBitsOff(priv->PortOffset, MAC_REG_SOFTPWRCTL,
451 SOFTPWRCTL_SWPE2);
452 MACvWordRegBitsOff(priv->PortOffset, MAC_REG_SOFTPWRCTL,
453 SOFTPWRCTL_SWPE3);
454 break;
455 }
456
457 MACvRegBitsOff(priv->PortOffset, MAC_REG_HOSTCR, HOSTCR_RXON);
458
459 BBvSetDeepSleep(priv, priv->byLocalID);
460
461 priv->bRadioOff = true;
462 pr_debug("chester power off\n");
463 MACvRegBitsOn(priv->PortOffset, MAC_REG_GPIOCTL0,
464 LED_ACTSET); /* LED issue */
465 return bResult;
466 }
467
468 /*
469 * Description: Turn on Radio power
470 *
471 * Parameters:
472 * In:
473 * priv - The adapter to be turned on
474 * Out:
475 * none
476 *
477 * Return Value: true if success; otherwise false
478 */
479 bool CARDbRadioPowerOn(struct vnt_private *priv)
480 {
481 bool bResult = true;
482
483 pr_debug("chester power on\n");
484 if (priv->bRadioControlOff) {
485 if (priv->bHWRadioOff)
486 pr_debug("chester bHWRadioOff\n");
487 if (priv->bRadioControlOff)
488 pr_debug("chester bRadioControlOff\n");
489 return false; }
490
491 if (!priv->bRadioOff) {
492 pr_debug("chester pbRadioOff\n");
493 return true; }
494
495 BBvExitDeepSleep(priv, priv->byLocalID);
496
497 MACvRegBitsOn(priv->PortOffset, MAC_REG_HOSTCR, HOSTCR_RXON);
498
499 switch (priv->byRFType) {
500 case RF_RFMD2959:
501 MACvWordRegBitsOn(priv->PortOffset, MAC_REG_SOFTPWRCTL,
502 SOFTPWRCTL_TXPEINV);
503 MACvWordRegBitsOff(priv->PortOffset, MAC_REG_SOFTPWRCTL,
504 SOFTPWRCTL_SWPE1);
505 break;
506
507 case RF_AIROHA:
508 case RF_AL2230S:
509 case RF_AIROHA7230:
510 MACvWordRegBitsOn(priv->PortOffset, MAC_REG_SOFTPWRCTL,
511 (SOFTPWRCTL_SWPE2 | SOFTPWRCTL_SWPE3));
512 break;
513 }
514
515 priv->bRadioOff = false;
516 pr_debug("chester power on\n");
517 MACvRegBitsOff(priv->PortOffset, MAC_REG_GPIOCTL0,
518 LED_ACTSET); /* LED issue */
519 return bResult;
520 }
521
522 void
523 CARDvSafeResetTx(
524 struct vnt_private *priv
525 )
526 {
527 unsigned int uu;
528 struct vnt_tx_desc *pCurrTD;
529
530 /* initialize TD index */
531 priv->apTailTD[0] = priv->apCurrTD[0] = &(priv->apTD0Rings[0]);
532 priv->apTailTD[1] = priv->apCurrTD[1] = &(priv->apTD1Rings[0]);
533
534 for (uu = 0; uu < TYPE_MAXTD; uu++)
535 priv->iTDUsed[uu] = 0;
536
537 for (uu = 0; uu < priv->opts.tx_descs[0]; uu++) {
538 pCurrTD = &(priv->apTD0Rings[uu]);
539 pCurrTD->td0.owner = OWNED_BY_HOST;
540 /* init all Tx Packet pointer to NULL */
541 }
542 for (uu = 0; uu < priv->opts.tx_descs[1]; uu++) {
543 pCurrTD = &(priv->apTD1Rings[uu]);
544 pCurrTD->td0.owner = OWNED_BY_HOST;
545 /* init all Tx Packet pointer to NULL */
546 }
547
548 /* set MAC TD pointer */
549 MACvSetCurrTXDescAddr(TYPE_TXDMA0, priv, priv->td0_pool_dma);
550
551 MACvSetCurrTXDescAddr(TYPE_AC0DMA, priv, priv->td1_pool_dma);
552
553 /* set MAC Beacon TX pointer */
554 MACvSetCurrBCNTxDescAddr(priv->PortOffset,
555 (priv->tx_beacon_dma));
556 }
557
558 /*
559 * Description:
560 * Reset Rx
561 *
562 * Parameters:
563 * In:
564 * priv - Pointer to the adapter
565 * Out:
566 * none
567 *
568 * Return Value: none
569 */
570 void
571 CARDvSafeResetRx(
572 struct vnt_private *priv
573 )
574 {
575 unsigned int uu;
576 struct vnt_rx_desc *pDesc;
577
578 /* initialize RD index */
579 priv->pCurrRD[0] = &(priv->aRD0Ring[0]);
580 priv->pCurrRD[1] = &(priv->aRD1Ring[0]);
581
582 /* init state, all RD is chip's */
583 for (uu = 0; uu < priv->opts.rx_descs0; uu++) {
584 pDesc = &(priv->aRD0Ring[uu]);
585 pDesc->rd0.res_count = cpu_to_le16(priv->rx_buf_sz);
586 pDesc->rd0.owner = OWNED_BY_NIC;
587 pDesc->rd1.req_count = cpu_to_le16(priv->rx_buf_sz);
588 }
589
590 /* init state, all RD is chip's */
591 for (uu = 0; uu < priv->opts.rx_descs1; uu++) {
592 pDesc = &(priv->aRD1Ring[uu]);
593 pDesc->rd0.res_count = cpu_to_le16(priv->rx_buf_sz);
594 pDesc->rd0.owner = OWNED_BY_NIC;
595 pDesc->rd1.req_count = cpu_to_le16(priv->rx_buf_sz);
596 }
597
598 /* set perPkt mode */
599 MACvRx0PerPktMode(priv->PortOffset);
600 MACvRx1PerPktMode(priv->PortOffset);
601 /* set MAC RD pointer */
602 MACvSetCurrRx0DescAddr(priv, priv->rd0_pool_dma);
603
604 MACvSetCurrRx1DescAddr(priv, priv->rd1_pool_dma);
605 }
606
607 /*
608 * Description: Get response Control frame rate in CCK mode
609 *
610 * Parameters:
611 * In:
612 * priv - The adapter to be set
613 * wRateIdx - Receiving data rate
614 * Out:
615 * none
616 *
617 * Return Value: response Control frame rate
618 */
619 static unsigned short CARDwGetCCKControlRate(struct vnt_private *priv,
620 unsigned short wRateIdx)
621 {
622 unsigned int ui = (unsigned int) wRateIdx;
623
624 while (ui > RATE_1M) {
625 if (priv->basic_rates & ((u32)0x1 << ui))
626 return (unsigned short)ui;
627
628 ui--;
629 }
630 return (unsigned short)RATE_1M;
631 }
632
633 /*
634 * Description: Get response Control frame rate in OFDM mode
635 *
636 * Parameters:
637 * In:
638 * priv - The adapter to be set
639 * wRateIdx - Receiving data rate
640 * Out:
641 * none
642 *
643 * Return Value: response Control frame rate
644 */
645 static unsigned short CARDwGetOFDMControlRate(struct vnt_private *priv,
646 unsigned short wRateIdx)
647 {
648 unsigned int ui = (unsigned int) wRateIdx;
649
650 pr_debug("BASIC RATE: %X\n", priv->basic_rates);
651
652 if (!CARDbIsOFDMinBasicRate((void *)priv)) {
653 pr_debug("CARDwGetOFDMControlRate:(NO OFDM) %d\n", wRateIdx);
654 if (wRateIdx > RATE_24M)
655 wRateIdx = RATE_24M;
656 return wRateIdx;
657 }
658 while (ui > RATE_11M) {
659 if (priv->basic_rates & ((u32)0x1 << ui)) {
660 pr_debug("CARDwGetOFDMControlRate : %d\n", ui);
661 return (unsigned short)ui;
662 }
663 ui--;
664 }
665 pr_debug("CARDwGetOFDMControlRate: 6M\n");
666 return (unsigned short)RATE_24M;
667 }
668
669 /*
670 * Description: Set RSPINF
671 *
672 * Parameters:
673 * In:
674 * priv - The adapter to be set
675 * Out:
676 * none
677 *
678 * Return Value: None.
679 */
680 void CARDvSetRSPINF(struct vnt_private *priv, u8 bb_type)
681 {
682 union vnt_phy_field_swap phy;
683 unsigned char byTxRate, byRsvTime; /* For OFDM */
684 unsigned long flags;
685
686 spin_lock_irqsave(&priv->lock, flags);
687
688 /* Set to Page1 */
689 MACvSelectPage1(priv->PortOffset);
690
691 /* RSPINF_b_1 */
692 vnt_get_phy_field(priv, 14,
693 CARDwGetCCKControlRate(priv, RATE_1M),
694 PK_TYPE_11B, &phy.field_read);
695
696 /* swap over to get correct write order */
697 swap(phy.swap[0], phy.swap[1]);
698
699 VNSvOutPortD(priv->PortOffset + MAC_REG_RSPINF_B_1, phy.field_write);
700
701 /* RSPINF_b_2 */
702 vnt_get_phy_field(priv, 14,
703 CARDwGetCCKControlRate(priv, RATE_2M),
704 PK_TYPE_11B, &phy.field_read);
705
706 swap(phy.swap[0], phy.swap[1]);
707
708 VNSvOutPortD(priv->PortOffset + MAC_REG_RSPINF_B_2, phy.field_write);
709
710 /* RSPINF_b_5 */
711 vnt_get_phy_field(priv, 14,
712 CARDwGetCCKControlRate(priv, RATE_5M),
713 PK_TYPE_11B, &phy.field_read);
714
715 swap(phy.swap[0], phy.swap[1]);
716
717 VNSvOutPortD(priv->PortOffset + MAC_REG_RSPINF_B_5, phy.field_write);
718
719 /* RSPINF_b_11 */
720 vnt_get_phy_field(priv, 14,
721 CARDwGetCCKControlRate(priv, RATE_11M),
722 PK_TYPE_11B, &phy.field_read);
723
724 swap(phy.swap[0], phy.swap[1]);
725
726 VNSvOutPortD(priv->PortOffset + MAC_REG_RSPINF_B_11, phy.field_write);
727
728 /* RSPINF_a_6 */
729 s_vCalculateOFDMRParameter(RATE_6M,
730 bb_type,
731 &byTxRate,
732 &byRsvTime);
733 VNSvOutPortW(priv->PortOffset + MAC_REG_RSPINF_A_6,
734 MAKEWORD(byTxRate, byRsvTime));
735 /* RSPINF_a_9 */
736 s_vCalculateOFDMRParameter(RATE_9M,
737 bb_type,
738 &byTxRate,
739 &byRsvTime);
740 VNSvOutPortW(priv->PortOffset + MAC_REG_RSPINF_A_9,
741 MAKEWORD(byTxRate, byRsvTime));
742 /* RSPINF_a_12 */
743 s_vCalculateOFDMRParameter(RATE_12M,
744 bb_type,
745 &byTxRate,
746 &byRsvTime);
747 VNSvOutPortW(priv->PortOffset + MAC_REG_RSPINF_A_12,
748 MAKEWORD(byTxRate, byRsvTime));
749 /* RSPINF_a_18 */
750 s_vCalculateOFDMRParameter(RATE_18M,
751 bb_type,
752 &byTxRate,
753 &byRsvTime);
754 VNSvOutPortW(priv->PortOffset + MAC_REG_RSPINF_A_18,
755 MAKEWORD(byTxRate, byRsvTime));
756 /* RSPINF_a_24 */
757 s_vCalculateOFDMRParameter(RATE_24M,
758 bb_type,
759 &byTxRate,
760 &byRsvTime);
761 VNSvOutPortW(priv->PortOffset + MAC_REG_RSPINF_A_24,
762 MAKEWORD(byTxRate, byRsvTime));
763 /* RSPINF_a_36 */
764 s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate(
765 (void *)priv,
766 RATE_36M),
767 bb_type,
768 &byTxRate,
769 &byRsvTime);
770 VNSvOutPortW(priv->PortOffset + MAC_REG_RSPINF_A_36,
771 MAKEWORD(byTxRate, byRsvTime));
772 /* RSPINF_a_48 */
773 s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate(
774 (void *)priv,
775 RATE_48M),
776 bb_type,
777 &byTxRate,
778 &byRsvTime);
779 VNSvOutPortW(priv->PortOffset + MAC_REG_RSPINF_A_48,
780 MAKEWORD(byTxRate, byRsvTime));
781 /* RSPINF_a_54 */
782 s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate(
783 (void *)priv,
784 RATE_54M),
785 bb_type,
786 &byTxRate,
787 &byRsvTime);
788 VNSvOutPortW(priv->PortOffset + MAC_REG_RSPINF_A_54,
789 MAKEWORD(byTxRate, byRsvTime));
790 /* RSPINF_a_72 */
791 s_vCalculateOFDMRParameter(CARDwGetOFDMControlRate(
792 (void *)priv,
793 RATE_54M),
794 bb_type,
795 &byTxRate,
796 &byRsvTime);
797 VNSvOutPortW(priv->PortOffset + MAC_REG_RSPINF_A_72,
798 MAKEWORD(byTxRate, byRsvTime));
799 /* Set to Page0 */
800 MACvSelectPage0(priv->PortOffset);
801
802 spin_unlock_irqrestore(&priv->lock, flags);
803 }
804
805 void CARDvUpdateBasicTopRate(struct vnt_private *priv)
806 {
807 unsigned char byTopOFDM = RATE_24M, byTopCCK = RATE_1M;
808 unsigned char ii;
809
810 /* Determines the highest basic rate. */
811 for (ii = RATE_54M; ii >= RATE_6M; ii--) {
812 if ((priv->basic_rates) & ((u32)(1 << ii))) {
813 byTopOFDM = ii;
814 break;
815 }
816 }
817 priv->byTopOFDMBasicRate = byTopOFDM;
818
819 for (ii = RATE_11M;; ii--) {
820 if ((priv->basic_rates) & ((u32)(1 << ii))) {
821 byTopCCK = ii;
822 break;
823 }
824 if (ii == RATE_1M)
825 break;
826 }
827 priv->byTopCCKBasicRate = byTopCCK;
828 }
829
830 bool CARDbIsOFDMinBasicRate(struct vnt_private *priv)
831 {
832 int ii;
833
834 for (ii = RATE_54M; ii >= RATE_6M; ii--) {
835 if ((priv->basic_rates) & ((u32)BIT(ii)))
836 return true;
837 }
838 return false;
839 }
840
841 unsigned char CARDbyGetPktType(struct vnt_private *priv)
842 {
843 if (priv->byBBType == BB_TYPE_11A || priv->byBBType == BB_TYPE_11B)
844 return (unsigned char)priv->byBBType;
845 else if (CARDbIsOFDMinBasicRate((void *)priv))
846 return PK_TYPE_11GA;
847 else
848 return PK_TYPE_11GB;
849 }
850
851 /*
852 * Description: Set NIC Loopback mode
853 *
854 * Parameters:
855 * In:
856 * priv - The adapter to be set
857 * wLoopbackMode - Loopback mode to be set
858 * Out:
859 * none
860 *
861 * Return Value: none
862 */
863 void CARDvSetLoopbackMode(struct vnt_private *priv,
864 unsigned short wLoopbackMode)
865 {
866 switch (wLoopbackMode) {
867 case CARD_LB_NONE:
868 case CARD_LB_MAC:
869 case CARD_LB_PHY:
870 break;
871 default:
872 break;
873 }
874 /* set MAC loopback */
875 MACvSetLoopbackMode(priv, LOBYTE(wLoopbackMode));
876 /* set Baseband loopback */
877 }
878
879 /*
880 * Description: Software Reset NIC
881 *
882 * Parameters:
883 * In:
884 * priv - The adapter to be reset
885 * Out:
886 * none
887 *
888 * Return Value: none
889 */
890 bool CARDbSoftwareReset(struct vnt_private *priv)
891 {
892 /* reset MAC */
893 if (!MACbSafeSoftwareReset(priv))
894 return false;
895
896 return true;
897 }
898
899 /*
900 * Description: Calculate TSF offset of two TSF input
901 * Get TSF Offset from RxBCN's TSF and local TSF
902 *
903 * Parameters:
904 * In:
905 * priv - The adapter to be sync.
906 * qwTSF1 - Rx BCN's TSF
907 * qwTSF2 - Local TSF
908 * Out:
909 * none
910 *
911 * Return Value: TSF Offset value
912 */
913 u64 CARDqGetTSFOffset(unsigned char byRxRate, u64 qwTSF1, u64 qwTSF2)
914 {
915 u64 qwTSFOffset = 0;
916 unsigned short wRxBcnTSFOffst;
917
918 wRxBcnTSFOffst = cwRXBCNTSFOff[byRxRate%MAX_RATE];
919
920 qwTSF2 += (u64)wRxBcnTSFOffst;
921
922 qwTSFOffset = qwTSF1 - qwTSF2;
923
924 return qwTSFOffset;
925 }
926
927 /*
928 * Description: Read NIC TSF counter
929 * Get local TSF counter
930 *
931 * Parameters:
932 * In:
933 * priv - The adapter to be read
934 * Out:
935 * qwCurrTSF - Current TSF counter
936 *
937 * Return Value: true if success; otherwise false
938 */
939 bool CARDbGetCurrentTSF(struct vnt_private *priv, u64 *pqwCurrTSF)
940 {
941 void __iomem *dwIoBase = priv->PortOffset;
942 unsigned short ww;
943 unsigned char byData;
944
945 MACvRegBitsOn(dwIoBase, MAC_REG_TFTCTL, TFTCTL_TSFCNTRRD);
946 for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
947 VNSvInPortB(dwIoBase + MAC_REG_TFTCTL, &byData);
948 if (!(byData & TFTCTL_TSFCNTRRD))
949 break;
950 }
951 if (ww == W_MAX_TIMEOUT)
952 return false;
953 VNSvInPortD(dwIoBase + MAC_REG_TSFCNTR, (u32 *)pqwCurrTSF);
954 VNSvInPortD(dwIoBase + MAC_REG_TSFCNTR + 4, (u32 *)pqwCurrTSF + 1);
955
956 return true;
957 }
958
959 /*
960 * Description: Read NIC TSF counter
961 * Get NEXTTBTT from adjusted TSF and Beacon Interval
962 *
963 * Parameters:
964 * In:
965 * qwTSF - Current TSF counter
966 * wbeaconInterval - Beacon Interval
967 * Out:
968 * qwCurrTSF - Current TSF counter
969 *
970 * Return Value: TSF value of next Beacon
971 */
972 u64 CARDqGetNextTBTT(u64 qwTSF, unsigned short wBeaconInterval)
973 {
974 u32 beacon_int;
975
976 beacon_int = wBeaconInterval * 1024;
977 if (beacon_int) {
978 do_div(qwTSF, beacon_int);
979 qwTSF += 1;
980 qwTSF *= beacon_int;
981 }
982
983 return qwTSF;
984 }
985
986 /*
987 * Description: Set NIC TSF counter for first Beacon time
988 * Get NEXTTBTT from adjusted TSF and Beacon Interval
989 *
990 * Parameters:
991 * In:
992 * dwIoBase - IO Base
993 * wBeaconInterval - Beacon Interval
994 * Out:
995 * none
996 *
997 * Return Value: none
998 */
999 void CARDvSetFirstNextTBTT(struct vnt_private *priv,
1000 unsigned short wBeaconInterval)
1001 {
1002 void __iomem *dwIoBase = priv->PortOffset;
1003 u64 qwNextTBTT = 0;
1004
1005 CARDbGetCurrentTSF(priv, &qwNextTBTT); /* Get Local TSF counter */
1006
1007 qwNextTBTT = CARDqGetNextTBTT(qwNextTBTT, wBeaconInterval);
1008 /* Set NextTBTT */
1009 VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT, (u32)qwNextTBTT);
1010 VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT + 4, (u32)(qwNextTBTT >> 32));
1011 MACvRegBitsOn(dwIoBase, MAC_REG_TFTCTL, TFTCTL_TBTTSYNCEN);
1012 }
1013
1014 /*
1015 * Description: Sync NIC TSF counter for Beacon time
1016 * Get NEXTTBTT and write to HW
1017 *
1018 * Parameters:
1019 * In:
1020 * priv - The adapter to be set
1021 * qwTSF - Current TSF counter
1022 * wBeaconInterval - Beacon Interval
1023 * Out:
1024 * none
1025 *
1026 * Return Value: none
1027 */
1028 void CARDvUpdateNextTBTT(struct vnt_private *priv, u64 qwTSF,
1029 unsigned short wBeaconInterval)
1030 {
1031 void __iomem *dwIoBase = priv->PortOffset;
1032
1033 qwTSF = CARDqGetNextTBTT(qwTSF, wBeaconInterval);
1034 /* Set NextTBTT */
1035 VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT, (u32)qwTSF);
1036 VNSvOutPortD(dwIoBase + MAC_REG_NEXTTBTT + 4, (u32)(qwTSF >> 32));
1037 MACvRegBitsOn(dwIoBase, MAC_REG_TFTCTL, TFTCTL_TBTTSYNCEN);
1038 pr_debug("Card:Update Next TBTT[%8llx]\n", qwTSF);
1039 }
Linux kernel - Deliverables
This page took 0.079842 seconds and 6 git commands to generate.