root/drivers/staging/vt6655/card.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

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