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