drivers/staging/vt6655/mac.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  *
  20  * File: mac.c
  21  *
  22  * Purpose:  MAC routines
  23  *
  24  * Author: Tevin Chen
  25  *
  26  * Date: May 21, 1996
  27  *
  28  * Functions:
  29  *      MACvReadAllRegs - Read All MAC Registers to buffer
  30  *      MACbIsRegBitsOn - Test if All test Bits On
  31  *      MACbIsRegBitsOff - Test if All test Bits Off
  32  *      MACbIsIntDisable - Test if MAC interrupt disable
  33  *      MACbyReadMultiAddr - Read Multicast Address Mask Pattern
  34  *      MACvWriteMultiAddr - Write Multicast Address Mask Pattern
  35  *      MACvSetMultiAddrByHash - Set Multicast Address Mask by Hash value
  36  *      MACvResetMultiAddrByHash - Clear Multicast Address Mask by Hash value
  37  *      MACvSetRxThreshold - Set Rx Threshold value
  38  *      MACvGetRxThreshold - Get Rx Threshold value
  39  *      MACvSetTxThreshold - Set Tx Threshold value
  40  *      MACvGetTxThreshold - Get Tx Threshold value
  41  *      MACvSetDmaLength - Set Dma Length value
  42  *      MACvGetDmaLength - Get Dma Length value
  43  *      MACvSetShortRetryLimit - Set 802.11 Short Retry limit
  44  *      MACvGetShortRetryLimit - Get 802.11 Short Retry limit
  45  *      MACvSetLongRetryLimit - Set 802.11 Long Retry limit
  46  *      MACvGetLongRetryLimit - Get 802.11 Long Retry limit
  47  *      MACvSetLoopbackMode - Set MAC Loopback Mode
  48  *      MACbIsInLoopbackMode - Test if MAC in Loopback mode
  49  *      MACvSetPacketFilter - Set MAC Address Filter
  50  *      MACvSaveContext - Save Context of MAC Registers
  51  *      MACvRestoreContext - Restore Context of MAC Registers
  52  *      MACbCompareContext - Compare if values of MAC Registers same as Context
  53  *      MACbSoftwareReset - Software Reset MAC
  54  *      MACbSafeRxOff - Turn Off MAC Rx
  55  *      MACbSafeTxOff - Turn Off MAC Tx
  56  *      MACbSafeStop - Stop MAC function
  57  *      MACbShutdown - Shut down MAC
  58  *      MACvInitialize - Initialize MAC
  59  *      MACvSetCurrRxDescAddr - Set Rx Descriptors Address
  60  *      MACvSetCurrTx0DescAddr - Set Tx0 Descriptors Address
  61  *      MACvSetCurrTx1DescAddr - Set Tx1 Descriptors Address
  62  *      MACvTimer0MicroSDelay - Micro Second Delay Loop by MAC
  63  *
  64  * Revision History:
  65  *      08-22-2003 Kyle Hsu     :  Porting MAC functions from sim53
  66  *      09-03-2003 Bryan YC Fan :  Add MACvClearBusSusInd()& MACvEnableBusSusEn()
  67  *      09-18-2003 Jerry Chen   :  Add MACvSetKeyEntry & MACvDisableKeyEntry
  68  *
  69  */
  70
  71 #include "tmacro.h"
  72 #include "tether.h"
  73 #include "mac.h"
  74
  75 unsigned short TxRate_iwconfig;//2008-5-8 <add> by chester
  76 /*---------------------  Static Definitions -------------------------*/
  77 //static int          msglevel                =MSG_LEVEL_DEBUG;
  78 static int msglevel = MSG_LEVEL_INFO;
  79 /*---------------------  Static Classes  ----------------------------*/
  80
  81 /*---------------------  Static Variables  --------------------------*/
  82
  83 /*---------------------  Static Functions  --------------------------*/
  84
  85 /*---------------------  Export Variables  --------------------------*/
  86
  87 /*---------------------  Export Functions  --------------------------*/
  88
  89
  90
  91
  92
  93 /*
  94  * Description:
  95  *      Read All MAC Registers to buffer
  96  *
  97  * Parameters:
  98  *  In:
  99  *      dwIoBase    - Base Address for MAC
 100  *  Out:
 101  *      pbyMacRegs  - buffer to read
 102  *
 103  * Return Value: none
 104  *
 105  */
 106 void MACvReadAllRegs(unsigned long dwIoBase, unsigned char *pbyMacRegs)
 107 {
 108         int ii;
 109
 110         // read page0 register
 111         for (ii = 0; ii < MAC_MAX_CONTEXT_SIZE_PAGE0; ii++) {
 112                 VNSvInPortB(dwIoBase + ii, pbyMacRegs);
 113                 pbyMacRegs++;
 114         }
 115
 116         MACvSelectPage1(dwIoBase);
 117
 118         // read page1 register
 119         for (ii = 0; ii < MAC_MAX_CONTEXT_SIZE_PAGE1; ii++) {
 120                 VNSvInPortB(dwIoBase + ii, pbyMacRegs);
 121                 pbyMacRegs++;
 122         }
 123
 124         MACvSelectPage0(dwIoBase);
 125
 126 }
 127
 128 /*
 129  * Description:
 130  *      Test if all test bits on
 131  *
 132  * Parameters:
 133  *  In:
 134  *      dwIoBase    - Base Address for MAC
 135  *      byRegOfs    - Offset of MAC Register
 136  *      byTestBits  - Test bits
 137  *  Out:
 138  *      none
 139  *
 140  * Return Value: true if all test bits On; otherwise false
 141  *
 142  */
 143 bool MACbIsRegBitsOn(unsigned long dwIoBase, unsigned char byRegOfs, unsigned char byTestBits)
 144 {
 145         unsigned char byData;
 146
 147         VNSvInPortB(dwIoBase + byRegOfs, &byData);
 148         return (byData & byTestBits) == byTestBits;
 149 }
 150
 151 /*
 152  * Description:
 153  *      Test if all test bits off
 154  *
 155  * Parameters:
 156  *  In:
 157  *      dwIoBase    - Base Address for MAC
 158  *      byRegOfs    - Offset of MAC Register
 159  *      byTestBits  - Test bits
 160  *  Out:
 161  *      none
 162  *
 163  * Return Value: true if all test bits Off; otherwise false
 164  *
 165  */
 166 bool MACbIsRegBitsOff(unsigned long dwIoBase, unsigned char byRegOfs, unsigned char byTestBits)
 167 {
 168         unsigned char byData;
 169
 170         VNSvInPortB(dwIoBase + byRegOfs, &byData);
 171         return !(byData & byTestBits);
 172 }
 173
 174 /*
 175  * Description:
 176  *      Test if MAC interrupt disable
 177  *
 178  * Parameters:
 179  *  In:
 180  *      dwIoBase    - Base Address for MAC
 181  *  Out:
 182  *      none
 183  *
 184  * Return Value: true if interrupt is disable; otherwise false
 185  *
 186  */
 187 bool MACbIsIntDisable(unsigned long dwIoBase)
 188 {
 189         unsigned long dwData;
 190
 191         VNSvInPortD(dwIoBase + MAC_REG_IMR, &dwData);
 192         if (dwData != 0)
 193                 return false;
 194
 195         return true;
 196 }
 197
 198 /*
 199  * Description:
 200  *      Read MAC Multicast Address Mask
 201  *
 202  * Parameters:
 203  *  In:
 204  *      dwIoBase    - Base Address for MAC
 205  *      uByteidx    - Index of Mask
 206  *  Out:
 207  *      none
 208  *
 209  * Return Value: Mask Value read
 210  *
 211  */
 212 unsigned char MACbyReadMultiAddr(unsigned long dwIoBase, unsigned int uByteIdx)
 213 {
 214         unsigned char byData;
 215
 216         MACvSelectPage1(dwIoBase);
 217         VNSvInPortB(dwIoBase + MAC_REG_MAR0 + uByteIdx, &byData);
 218         MACvSelectPage0(dwIoBase);
 219         return byData;
 220 }
 221
 222 /*
 223  * Description:
 224  *      Write MAC Multicast Address Mask
 225  *
 226  * Parameters:
 227  *  In:
 228  *      dwIoBase    - Base Address for MAC
 229  *      uByteidx    - Index of Mask
 230  *      byData      - Mask Value to write
 231  *  Out:
 232  *      none
 233  *
 234  * Return Value: none
 235  *
 236  */
 237 void MACvWriteMultiAddr(unsigned long dwIoBase, unsigned int uByteIdx, unsigned char byData)
 238 {
 239         MACvSelectPage1(dwIoBase);
 240         VNSvOutPortB(dwIoBase + MAC_REG_MAR0 + uByteIdx, byData);
 241         MACvSelectPage0(dwIoBase);
 242 }
 243
 244 /*
 245  * Description:
 246  *      Set this hash index into multicast address register bit
 247  *
 248  * Parameters:
 249  *  In:
 250  *      dwIoBase    - Base Address for MAC
 251  *      byHashIdx   - Hash index to set
 252  *  Out:
 253  *      none
 254  *
 255  * Return Value: none
 256  *
 257  */
 258 void MACvSetMultiAddrByHash(unsigned long dwIoBase, unsigned char byHashIdx)
 259 {
 260         unsigned int uByteIdx;
 261         unsigned char byBitMask;
 262         unsigned char byOrgValue;
 263
 264         // calculate byte position
 265         uByteIdx = byHashIdx / 8;
 266         ASSERT(uByteIdx < 8);
 267         // calculate bit position
 268         byBitMask = 1;
 269         byBitMask <<= (byHashIdx % 8);
 270         // turn on the bit
 271         byOrgValue = MACbyReadMultiAddr(dwIoBase, uByteIdx);
 272         MACvWriteMultiAddr(dwIoBase, uByteIdx, (unsigned char)(byOrgValue | byBitMask));
 273 }
 274
 275 /*
 276  * Description:
 277  *      Reset this hash index into multicast address register bit
 278  *
 279  * Parameters:
 280  *  In:
 281  *      dwIoBase    - Base Address for MAC
 282  *      byHashIdx   - Hash index to clear
 283  *  Out:
 284  *      none
 285  *
 286  * Return Value: none
 287  *
 288  */
 289 void MACvResetMultiAddrByHash(unsigned long dwIoBase, unsigned char byHashIdx)
 290 {
 291         unsigned int uByteIdx;
 292         unsigned char byBitMask;
 293         unsigned char byOrgValue;
 294
 295         // calculate byte position
 296         uByteIdx = byHashIdx / 8;
 297         ASSERT(uByteIdx < 8);
 298         // calculate bit position
 299         byBitMask = 1;
 300         byBitMask <<= (byHashIdx % 8);
 301         // turn off the bit
 302         byOrgValue = MACbyReadMultiAddr(dwIoBase, uByteIdx);
 303         MACvWriteMultiAddr(dwIoBase, uByteIdx, (unsigned char)(byOrgValue & (~byBitMask)));
 304 }
 305
 306 /*
 307  * Description:
 308  *      Set Rx Threshold
 309  *
 310  * Parameters:
 311  *  In:
 312  *      dwIoBase    - Base Address for MAC
 313  *      byThreshold - Threshold Value
 314  *  Out:
 315  *      none
 316  *
 317  * Return Value: none
 318  *
 319  */
 320 void MACvSetRxThreshold(unsigned long dwIoBase, unsigned char byThreshold)
 321 {
 322         unsigned char byOrgValue;
 323
 324         ASSERT(byThreshold < 4);
 325
 326         // set FCR0
 327         VNSvInPortB(dwIoBase + MAC_REG_FCR0, &byOrgValue);
 328         byOrgValue = (byOrgValue & 0xCF) | (byThreshold << 4);
 329         VNSvOutPortB(dwIoBase + MAC_REG_FCR0, byOrgValue);
 330 }
 331
 332 /*
 333  * Description:
 334  *      Get Rx Threshold
 335  *
 336  * Parameters:
 337  *  In:
 338  *      dwIoBase    - Base Address for MAC
 339  *  Out:
 340  *      pbyThreshold- Threshold Value Get
 341  *
 342  * Return Value: none
 343  *
 344  */
 345 void MACvGetRxThreshold(unsigned long dwIoBase, unsigned char *pbyThreshold)
 346 {
 347         // get FCR0
 348         VNSvInPortB(dwIoBase + MAC_REG_FCR0, pbyThreshold);
 349         *pbyThreshold = (*pbyThreshold >> 4) & 0x03;
 350 }
 351
 352 /*
 353  * Description:
 354  *      Set Tx Threshold
 355  *
 356  * Parameters:
 357  *  In:
 358  *      dwIoBase    - Base Address for MAC
 359  *      byThreshold - Threshold Value
 360  *  Out:
 361  *      none
 362  *
 363  * Return Value: none
 364  *
 365  */
 366 void MACvSetTxThreshold(unsigned long dwIoBase, unsigned char byThreshold)
 367 {
 368         unsigned char byOrgValue;
 369
 370         ASSERT(byThreshold < 4);
 371
 372         // set FCR0
 373         VNSvInPortB(dwIoBase + MAC_REG_FCR0, &byOrgValue);
 374         byOrgValue = (byOrgValue & 0xF3) | (byThreshold << 2);
 375         VNSvOutPortB(dwIoBase + MAC_REG_FCR0, byOrgValue);
 376 }
 377
 378 /*
 379  * Description:
 380  *      Get Tx Threshold
 381  *
 382  * Parameters:
 383  *  In:
 384  *      dwIoBase    - Base Address for MAC
 385  *  Out:
 386  *      pbyThreshold- Threshold Value Get
 387  *
 388  * Return Value: none
 389  *
 390  */
 391 void MACvGetTxThreshold(unsigned long dwIoBase, unsigned char *pbyThreshold)
 392 {
 393         // get FCR0
 394         VNSvInPortB(dwIoBase + MAC_REG_FCR0, pbyThreshold);
 395         *pbyThreshold = (*pbyThreshold >> 2) & 0x03;
 396 }
 397
 398 /*
 399  * Description:
 400  *      Set Dma Length
 401  *
 402  * Parameters:
 403  *  In:
 404  *      dwIoBase    - Base Address for MAC
 405  *      byDmaLength - Dma Length Value
 406  *  Out:
 407  *      none
 408  *
 409  * Return Value: none
 410  *
 411  */
 412 void MACvSetDmaLength(unsigned long dwIoBase, unsigned char byDmaLength)
 413 {
 414         unsigned char byOrgValue;
 415
 416         ASSERT(byDmaLength < 4);
 417
 418         // set FCR0
 419         VNSvInPortB(dwIoBase + MAC_REG_FCR0, &byOrgValue);
 420         byOrgValue = (byOrgValue & 0xFC) | byDmaLength;
 421         VNSvOutPortB(dwIoBase + MAC_REG_FCR0, byOrgValue);
 422 }
 423
 424 /*
 425  * Description:
 426  *      Get Dma Length
 427  *
 428  * Parameters:
 429  *  In:
 430  *      dwIoBase    - Base Address for MAC
 431  *  Out:
 432  *      pbyDmaLength- Dma Length Value Get
 433  *
 434  * Return Value: none
 435  *
 436  */
 437 void MACvGetDmaLength(unsigned long dwIoBase, unsigned char *pbyDmaLength)
 438 {
 439         // get FCR0
 440         VNSvInPortB(dwIoBase + MAC_REG_FCR0, pbyDmaLength);
 441         *pbyDmaLength &= 0x03;
 442 }
 443
 444 /*
 445  * Description:
 446  *      Set 802.11 Short Retry Limit
 447  *
 448  * Parameters:
 449  *  In:
 450  *      dwIoBase    - Base Address for MAC
 451  *      byRetryLimit- Retry Limit
 452  *  Out:
 453  *      none
 454  *
 455  * Return Value: none
 456  *
 457  */
 458 void MACvSetShortRetryLimit(unsigned long dwIoBase, unsigned char byRetryLimit)
 459 {
 460         // set SRT
 461         VNSvOutPortB(dwIoBase + MAC_REG_SRT, byRetryLimit);
 462 }
 463
 464 /*
 465  * Description:
 466  *      Get 802.11 Short Retry Limit
 467  *
 468  * Parameters:
 469  *  In:
 470  *      dwIoBase        - Base Address for MAC
 471  *  Out:
 472  *      pbyRetryLimit   - Retry Limit Get
 473  *
 474  * Return Value: none
 475  *
 476  */
 477 void MACvGetShortRetryLimit(unsigned long dwIoBase, unsigned char *pbyRetryLimit)
 478 {
 479         // get SRT
 480         VNSvInPortB(dwIoBase + MAC_REG_SRT, pbyRetryLimit);
 481 }
 482
 483 /*
 484  * Description:
 485  *      Set 802.11 Long Retry Limit
 486  *
 487  * Parameters:
 488  *  In:
 489  *      dwIoBase    - Base Address for MAC
 490  *      byRetryLimit- Retry Limit
 491  *  Out:
 492  *      none
 493  *
 494  * Return Value: none
 495  *
 496  */
 497 void MACvSetLongRetryLimit(unsigned long dwIoBase, unsigned char byRetryLimit)
 498 {
 499         // set LRT
 500         VNSvOutPortB(dwIoBase + MAC_REG_LRT, byRetryLimit);
 501 }
 502
 503 /*
 504  * Description:
 505  *      Get 802.11 Long Retry Limit
 506  *
 507  * Parameters:
 508  *  In:
 509  *      dwIoBase        - Base Address for MAC
 510  *  Out:
 511  *      pbyRetryLimit   - Retry Limit Get
 512  *
 513  * Return Value: none
 514  *
 515  */
 516 void MACvGetLongRetryLimit(unsigned long dwIoBase, unsigned char *pbyRetryLimit)
 517 {
 518         // get LRT
 519         VNSvInPortB(dwIoBase + MAC_REG_LRT, pbyRetryLimit);
 520 }
 521
 522 /*
 523  * Description:
 524  *      Set MAC Loopback mode
 525  *
 526  * Parameters:
 527  *  In:
 528  *      dwIoBase        - Base Address for MAC
 529  *      byLoopbackMode  - Loopback Mode
 530  *  Out:
 531  *      none
 532  *
 533  * Return Value: none
 534  *
 535  */
 536 void MACvSetLoopbackMode(unsigned long dwIoBase, unsigned char byLoopbackMode)
 537 {
 538         unsigned char byOrgValue;
 539
 540         ASSERT(byLoopbackMode < 3);
 541         byLoopbackMode <<= 6;
 542         // set TCR
 543         VNSvInPortB(dwIoBase + MAC_REG_TEST, &byOrgValue);
 544         byOrgValue = byOrgValue & 0x3F;
 545         byOrgValue = byOrgValue | byLoopbackMode;
 546         VNSvOutPortB(dwIoBase + MAC_REG_TEST, byOrgValue);
 547 }
 548
 549 /*
 550  * Description:
 551  *      Test if MAC in Loopback mode
 552  *
 553  * Parameters:
 554  *  In:
 555  *      dwIoBase        - Base Address for MAC
 556  *  Out:
 557  *      none
 558  *
 559  * Return Value: true if in Loopback mode; otherwise false
 560  *
 561  */
 562 bool MACbIsInLoopbackMode(unsigned long dwIoBase)
 563 {
 564         unsigned char byOrgValue;
 565
 566         VNSvInPortB(dwIoBase + MAC_REG_TEST, &byOrgValue);
 567         if (byOrgValue & (TEST_LBINT | TEST_LBEXT))
 568                 return true;
 569         return false;
 570 }
 571
 572 /*
 573  * Description:
 574  *      Set MAC Address filter
 575  *
 576  * Parameters:
 577  *  In:
 578  *      dwIoBase        - Base Address for MAC
 579  *      wFilterType     - Filter Type
 580  *  Out:
 581  *      none
 582  *
 583  * Return Value: none
 584  *
 585  */
 586 void MACvSetPacketFilter(unsigned long dwIoBase, unsigned short wFilterType)
 587 {
 588         unsigned char byOldRCR;
 589         unsigned char byNewRCR = 0;
 590
 591         // if only in DIRECTED mode, multicast-address will set to zero,
 592         // but if other mode exist (e.g. PROMISCUOUS), multicast-address
 593         // will be open
 594         if (wFilterType & PKT_TYPE_DIRECTED) {
 595                 // set multicast address to accept none
 596                 MACvSelectPage1(dwIoBase);
 597                 VNSvOutPortD(dwIoBase + MAC_REG_MAR0, 0L);
 598                 VNSvOutPortD(dwIoBase + MAC_REG_MAR0 + sizeof(unsigned long), 0L);
 599                 MACvSelectPage0(dwIoBase);
 600         }
 601
 602         if (wFilterType & (PKT_TYPE_PROMISCUOUS | PKT_TYPE_ALL_MULTICAST)) {
 603                 // set multicast address to accept all
 604                 MACvSelectPage1(dwIoBase);
 605                 VNSvOutPortD(dwIoBase + MAC_REG_MAR0, 0xFFFFFFFFL);
 606                 VNSvOutPortD(dwIoBase + MAC_REG_MAR0 + sizeof(unsigned long), 0xFFFFFFFFL);
 607                 MACvSelectPage0(dwIoBase);
 608         }
 609
 610         if (wFilterType & PKT_TYPE_PROMISCUOUS) {
 611
 612                 byNewRCR |= (RCR_RXALLTYPE | RCR_UNICAST | RCR_MULTICAST | RCR_BROADCAST);
 613
 614                 byNewRCR &= ~RCR_BSSID;
 615         }
 616
 617         if (wFilterType & (PKT_TYPE_ALL_MULTICAST | PKT_TYPE_MULTICAST))
 618                 byNewRCR |= RCR_MULTICAST;
 619
 620         if (wFilterType & PKT_TYPE_BROADCAST)
 621                 byNewRCR |= RCR_BROADCAST;
 622
 623         if (wFilterType & PKT_TYPE_ERROR_CRC)
 624                 byNewRCR |= RCR_ERRCRC;
 625
 626         VNSvInPortB(dwIoBase + MAC_REG_RCR,  &byOldRCR);
 627         if (byNewRCR != byOldRCR) {
 628                 // Modify the Receive Command Register
 629                 VNSvOutPortB(dwIoBase + MAC_REG_RCR, byNewRCR);
 630         }
 631 }
 632
 633 /*
 634  * Description:
 635  *      Save MAC registers to context buffer
 636  *
 637  * Parameters:
 638  *  In:
 639  *      dwIoBase    - Base Address for MAC
 640  *  Out:
 641  *      pbyCxtBuf   - Context buffer
 642  *
 643  * Return Value: none
 644  *
 645  */
 646 void MACvSaveContext(unsigned long dwIoBase, unsigned char *pbyCxtBuf)
 647 {
 648         int         ii;
 649
 650         // read page0 register
 651         for (ii = 0; ii < MAC_MAX_CONTEXT_SIZE_PAGE0; ii++) {
 652                 VNSvInPortB((dwIoBase + ii), (pbyCxtBuf + ii));
 653         }
 654
 655         MACvSelectPage1(dwIoBase);
 656
 657         // read page1 register
 658         for (ii = 0; ii < MAC_MAX_CONTEXT_SIZE_PAGE1; ii++) {
 659                 VNSvInPortB((dwIoBase + ii), (pbyCxtBuf + MAC_MAX_CONTEXT_SIZE_PAGE0 + ii));
 660         }
 661
 662         MACvSelectPage0(dwIoBase);
 663 }
 664
 665 /*
 666  * Description:
 667  *      Restore MAC registers from context buffer
 668  *
 669  * Parameters:
 670  *  In:
 671  *      dwIoBase    - Base Address for MAC
 672  *      pbyCxtBuf   - Context buffer
 673  *  Out:
 674  *      none
 675  *
 676  * Return Value: none
 677  *
 678  */
 679 void MACvRestoreContext(unsigned long dwIoBase, unsigned char *pbyCxtBuf)
 680 {
 681         int         ii;
 682
 683         MACvSelectPage1(dwIoBase);
 684         // restore page1
 685         for (ii = 0; ii < MAC_MAX_CONTEXT_SIZE_PAGE1; ii++) {
 686                 VNSvOutPortB((dwIoBase + ii), *(pbyCxtBuf + MAC_MAX_CONTEXT_SIZE_PAGE0 + ii));
 687         }
 688         MACvSelectPage0(dwIoBase);
 689
 690         // restore RCR,TCR,IMR...
 691         for (ii = MAC_REG_RCR; ii < MAC_REG_ISR; ii++) {
 692                 VNSvOutPortB(dwIoBase + ii, *(pbyCxtBuf + ii));
 693         }
 694         // restore MAC Config.
 695         for (ii = MAC_REG_LRT; ii < MAC_REG_PAGE1SEL; ii++) {
 696                 VNSvOutPortB(dwIoBase + ii, *(pbyCxtBuf + ii));
 697         }
 698         VNSvOutPortB(dwIoBase + MAC_REG_CFG, *(pbyCxtBuf + MAC_REG_CFG));
 699
 700         // restore PS Config.
 701         for (ii = MAC_REG_PSCFG; ii < MAC_REG_BBREGCTL; ii++) {
 702                 VNSvOutPortB(dwIoBase + ii, *(pbyCxtBuf + ii));
 703         }
 704
 705         // restore CURR_RX_DESC_ADDR, CURR_TX_DESC_ADDR
 706         VNSvOutPortD(dwIoBase + MAC_REG_TXDMAPTR0, *(unsigned long *)(pbyCxtBuf + MAC_REG_TXDMAPTR0));
 707         VNSvOutPortD(dwIoBase + MAC_REG_AC0DMAPTR, *(unsigned long *)(pbyCxtBuf + MAC_REG_AC0DMAPTR));
 708         VNSvOutPortD(dwIoBase + MAC_REG_BCNDMAPTR, *(unsigned long *)(pbyCxtBuf + MAC_REG_BCNDMAPTR));
 709
 710
 711         VNSvOutPortD(dwIoBase + MAC_REG_RXDMAPTR0, *(unsigned long *)(pbyCxtBuf + MAC_REG_RXDMAPTR0));
 712
 713         VNSvOutPortD(dwIoBase + MAC_REG_RXDMAPTR1, *(unsigned long *)(pbyCxtBuf + MAC_REG_RXDMAPTR1));
 714
 715 }
 716
 717 /*
 718  * Description:
 719  *      Compare if MAC registers same as context buffer
 720  *
 721  * Parameters:
 722  *  In:
 723  *      dwIoBase    - Base Address for MAC
 724  *      pbyCxtBuf   - Context buffer
 725  *  Out:
 726  *      none
 727  *
 728  * Return Value: true if all values are the same; otherwise false
 729  *
 730  */
 731 bool MACbCompareContext(unsigned long dwIoBase, unsigned char *pbyCxtBuf)
 732 {
 733         unsigned long dwData;
 734
 735         // compare MAC context to determine if this is a power lost init,
 736         // return true for power remaining init, return false for power lost init
 737
 738         // compare CURR_RX_DESC_ADDR, CURR_TX_DESC_ADDR
 739         VNSvInPortD(dwIoBase + MAC_REG_TXDMAPTR0, &dwData);
 740         if (dwData != *(unsigned long *)(pbyCxtBuf + MAC_REG_TXDMAPTR0)) {
 741                 return false;
 742         }
 743
 744         VNSvInPortD(dwIoBase + MAC_REG_AC0DMAPTR, &dwData);
 745         if (dwData != *(unsigned long *)(pbyCxtBuf + MAC_REG_AC0DMAPTR)) {
 746                 return false;
 747         }
 748
 749         VNSvInPortD(dwIoBase + MAC_REG_RXDMAPTR0, &dwData);
 750         if (dwData != *(unsigned long *)(pbyCxtBuf + MAC_REG_RXDMAPTR0)) {
 751                 return false;
 752         }
 753
 754         VNSvInPortD(dwIoBase + MAC_REG_RXDMAPTR1, &dwData);
 755         if (dwData != *(unsigned long *)(pbyCxtBuf + MAC_REG_RXDMAPTR1)) {
 756                 return false;
 757         }
 758
 759
 760         return true;
 761 }
 762
 763 /*
 764  * Description:
 765  *      Software Reset MAC
 766  *
 767  * Parameters:
 768  *  In:
 769  *      dwIoBase    - Base Address for MAC
 770  *  Out:
 771  *      none
 772  *
 773  * Return Value: true if Reset Success; otherwise false
 774  *
 775  */
 776 bool MACbSoftwareReset(unsigned long dwIoBase)
 777 {
 778         unsigned char byData;
 779         unsigned short ww;
 780
 781         // turn on HOSTCR_SOFTRST, just write 0x01 to reset
 782         //MACvRegBitsOn(dwIoBase, MAC_REG_HOSTCR, HOSTCR_SOFTRST);
 783         VNSvOutPortB(dwIoBase + MAC_REG_HOSTCR, 0x01);
 784
 785         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
 786                 VNSvInPortB(dwIoBase + MAC_REG_HOSTCR, &byData);
 787                 if (!(byData & HOSTCR_SOFTRST))
 788                         break;
 789         }
 790         if (ww == W_MAX_TIMEOUT)
 791                 return false;
 792         return true;
 793
 794 }
 795
 796 /*
 797  * Description:
 798  *      save some important register's value, then do reset, then restore register's value
 799  *
 800  * Parameters:
 801  *  In:
 802  *      dwIoBase    - Base Address for MAC
 803  *  Out:
 804  *      none
 805  *
 806  * Return Value: true if success; otherwise false
 807  *
 808  */
 809 bool MACbSafeSoftwareReset(unsigned long dwIoBase)
 810 {
 811         unsigned char abyTmpRegData[MAC_MAX_CONTEXT_SIZE_PAGE0+MAC_MAX_CONTEXT_SIZE_PAGE1];
 812         bool bRetVal;
 813
 814         // PATCH....
 815         // save some important register's value, then do
 816         // reset, then restore register's value
 817
 818         // save MAC context
 819         MACvSaveContext(dwIoBase, abyTmpRegData);
 820         // do reset
 821         bRetVal = MACbSoftwareReset(dwIoBase);
 822         //BBvSoftwareReset(pDevice->PortOffset);
 823         // restore MAC context, except CR0
 824         MACvRestoreContext(dwIoBase, abyTmpRegData);
 825
 826         return bRetVal;
 827 }
 828
 829 /*
 830  * Description:
 831  *      Trun Off MAC Rx
 832  *
 833  * Parameters:
 834  *  In:
 835  *      dwIoBase    - Base Address for MAC
 836  *  Out:
 837  *      none
 838  *
 839  * Return Value: true if success; otherwise false
 840  *
 841  */
 842 bool MACbSafeRxOff(unsigned long dwIoBase)
 843 {
 844         unsigned short ww;
 845         unsigned long dwData;
 846         unsigned char byData;
 847
 848         // turn off wow temp for turn off Rx safely
 849
 850         // Clear RX DMA0,1
 851         VNSvOutPortD(dwIoBase + MAC_REG_RXDMACTL0, DMACTL_CLRRUN);
 852         VNSvOutPortD(dwIoBase + MAC_REG_RXDMACTL1, DMACTL_CLRRUN);
 853         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
 854                 VNSvInPortD(dwIoBase + MAC_REG_RXDMACTL0, &dwData);
 855                 if (!(dwData & DMACTL_RUN))
 856                         break;
 857         }
 858         if (ww == W_MAX_TIMEOUT) {
 859                 DBG_PORT80(0x10);
 860                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " DBG_PORT80(0x10)\n");
 861                 return false;
 862         }
 863         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
 864                 VNSvInPortD(dwIoBase + MAC_REG_RXDMACTL1, &dwData);
 865                 if (!(dwData & DMACTL_RUN))
 866                         break;
 867         }
 868         if (ww == W_MAX_TIMEOUT) {
 869                 DBG_PORT80(0x11);
 870                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " DBG_PORT80(0x11)\n");
 871                 return false;
 872         }
 873
 874         // try to safe shutdown RX
 875         MACvRegBitsOff(dwIoBase, MAC_REG_HOSTCR, HOSTCR_RXON);
 876         // W_MAX_TIMEOUT is the timeout period
 877         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
 878                 VNSvInPortB(dwIoBase + MAC_REG_HOSTCR, &byData);
 879                 if (!(byData & HOSTCR_RXONST))
 880                         break;
 881         }
 882         if (ww == W_MAX_TIMEOUT) {
 883                 DBG_PORT80(0x12);
 884                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " DBG_PORT80(0x12)\n");
 885                 return false;
 886         }
 887         return true;
 888 }
 889
 890 /*
 891  * Description:
 892  *      Trun Off MAC Tx
 893  *
 894  * Parameters:
 895  *  In:
 896  *      dwIoBase    - Base Address for MAC
 897  *  Out:
 898  *      none
 899  *
 900  * Return Value: true if success; otherwise false
 901  *
 902  */
 903 bool MACbSafeTxOff(unsigned long dwIoBase)
 904 {
 905         unsigned short ww;
 906         unsigned long dwData;
 907         unsigned char byData;
 908
 909         // Clear TX DMA
 910         //Tx0
 911         VNSvOutPortD(dwIoBase + MAC_REG_TXDMACTL0, DMACTL_CLRRUN);
 912         //AC0
 913         VNSvOutPortD(dwIoBase + MAC_REG_AC0DMACTL, DMACTL_CLRRUN);
 914
 915
 916         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
 917                 VNSvInPortD(dwIoBase + MAC_REG_TXDMACTL0, &dwData);
 918                 if (!(dwData & DMACTL_RUN))
 919                         break;
 920         }
 921         if (ww == W_MAX_TIMEOUT) {
 922                 DBG_PORT80(0x20);
 923                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " DBG_PORT80(0x20)\n");
 924                 return false;
 925         }
 926         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
 927                 VNSvInPortD(dwIoBase + MAC_REG_AC0DMACTL, &dwData);
 928                 if (!(dwData & DMACTL_RUN))
 929                         break;
 930         }
 931         if (ww == W_MAX_TIMEOUT) {
 932                 DBG_PORT80(0x21);
 933                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " DBG_PORT80(0x21)\n");
 934                 return false;
 935         }
 936
 937         // try to safe shutdown TX
 938         MACvRegBitsOff(dwIoBase, MAC_REG_HOSTCR, HOSTCR_TXON);
 939
 940         // W_MAX_TIMEOUT is the timeout period
 941         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
 942                 VNSvInPortB(dwIoBase + MAC_REG_HOSTCR, &byData);
 943                 if (!(byData & HOSTCR_TXONST))
 944                         break;
 945         }
 946         if (ww == W_MAX_TIMEOUT) {
 947                 DBG_PORT80(0x24);
 948                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " DBG_PORT80(0x24)\n");
 949                 return false;
 950         }
 951         return true;
 952 }
 953
 954 /*
 955  * Description:
 956  *      Stop MAC function
 957  *
 958  * Parameters:
 959  *  In:
 960  *      dwIoBase    - Base Address for MAC
 961  *  Out:
 962  *      none
 963  *
 964  * Return Value: true if success; otherwise false
 965  *
 966  */
 967 bool MACbSafeStop(unsigned long dwIoBase)
 968 {
 969         MACvRegBitsOff(dwIoBase, MAC_REG_TCR, TCR_AUTOBCNTX);
 970
 971         if (MACbSafeRxOff(dwIoBase) == false) {
 972                 DBG_PORT80(0xA1);
 973                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " MACbSafeRxOff == false)\n");
 974                 MACbSafeSoftwareReset(dwIoBase);
 975                 return false;
 976         }
 977         if (MACbSafeTxOff(dwIoBase) == false) {
 978                 DBG_PORT80(0xA2);
 979                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " MACbSafeTxOff == false)\n");
 980                 MACbSafeSoftwareReset(dwIoBase);
 981                 return false;
 982         }
 983
 984         MACvRegBitsOff(dwIoBase, MAC_REG_HOSTCR, HOSTCR_MACEN);
 985
 986         return true;
 987 }
 988
 989 /*
 990  * Description:
 991  *      Shut Down MAC
 992  *
 993  * Parameters:
 994  *  In:
 995  *      dwIoBase    - Base Address for MAC
 996  *  Out:
 997  *      none
 998  *
 999  * Return Value: true if success; otherwise false
1000  *
1001  */
1002 bool MACbShutdown(unsigned long dwIoBase)
1003 {
1004         // disable MAC IMR
1005         MACvIntDisable(dwIoBase);
1006         MACvSetLoopbackMode(dwIoBase, MAC_LB_INTERNAL);
1007         // stop the adapter
1008         if (!MACbSafeStop(dwIoBase)) {
1009                 MACvSetLoopbackMode(dwIoBase, MAC_LB_NONE);
1010                 return false;
1011         }
1012         MACvSetLoopbackMode(dwIoBase, MAC_LB_NONE);
1013         return true;
1014 }
1015
1016 /*
1017  * Description:
1018  *      Initialize MAC
1019  *
1020  * Parameters:
1021  *  In:
1022  *      dwIoBase    - Base Address for MAC
1023  *  Out:
1024  *      none
1025  *
1026  * Return Value: none
1027  *
1028  */
1029 void MACvInitialize(unsigned long dwIoBase)
1030 {
1031         // clear sticky bits
1032         MACvClearStckDS(dwIoBase);
1033         // disable force PME-enable
1034         VNSvOutPortB(dwIoBase + MAC_REG_PMC1, PME_OVR);
1035         // only 3253 A
1036         /*
1037           MACvPwrEvntDisable(dwIoBase);
1038           // clear power status
1039           VNSvOutPortW(dwIoBase + MAC_REG_WAKEUPSR0, 0x0F0F);
1040         */
1041
1042         // do reset
1043         MACbSoftwareReset(dwIoBase);
1044
1045         // reset TSF counter
1046         VNSvOutPortB(dwIoBase + MAC_REG_TFTCTL, TFTCTL_TSFCNTRST);
1047         // enable TSF counter
1048         VNSvOutPortB(dwIoBase + MAC_REG_TFTCTL, TFTCTL_TSFCNTREN);
1049
1050
1051         // set packet filter
1052         // receive directed and broadcast address
1053
1054         MACvSetPacketFilter(dwIoBase, PKT_TYPE_DIRECTED | PKT_TYPE_BROADCAST);
1055
1056 }
1057
1058 /*
1059  * Description:
1060  *      Set the chip with current rx descriptor address
1061  *
1062  * Parameters:
1063  *  In:
1064  *      dwIoBase        - Base Address for MAC
1065  *      dwCurrDescAddr  - Descriptor Address
1066  *  Out:
1067  *      none
1068  *
1069  * Return Value: none
1070  *
1071  */
1072 void MACvSetCurrRx0DescAddr(unsigned long dwIoBase, unsigned long dwCurrDescAddr)
1073 {
1074         unsigned short ww;
1075         unsigned char byData;
1076         unsigned char byOrgDMACtl;
1077
1078         VNSvInPortB(dwIoBase + MAC_REG_RXDMACTL0, &byOrgDMACtl);
1079         if (byOrgDMACtl & DMACTL_RUN) {
1080                 VNSvOutPortB(dwIoBase + MAC_REG_RXDMACTL0+2, DMACTL_RUN);
1081         }
1082         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
1083                 VNSvInPortB(dwIoBase + MAC_REG_RXDMACTL0, &byData);
1084                 if (!(byData & DMACTL_RUN))
1085                         break;
1086         }
1087         if (ww == W_MAX_TIMEOUT) {
1088                 DBG_PORT80(0x13);
1089         }
1090         VNSvOutPortD(dwIoBase + MAC_REG_RXDMAPTR0, dwCurrDescAddr);
1091         if (byOrgDMACtl & DMACTL_RUN) {
1092                 VNSvOutPortB(dwIoBase + MAC_REG_RXDMACTL0, DMACTL_RUN);
1093         }
1094 }
1095
1096 /*
1097  * Description:
1098  *      Set the chip with current rx descriptor address
1099  *
1100  * Parameters:
1101  *  In:
1102  *      dwIoBase        - Base Address for MAC
1103  *      dwCurrDescAddr  - Descriptor Address
1104  *  Out:
1105  *      none
1106  *
1107  * Return Value: none
1108  *
1109  */
1110 void MACvSetCurrRx1DescAddr(unsigned long dwIoBase, unsigned long dwCurrDescAddr)
1111 {
1112         unsigned short ww;
1113         unsigned char byData;
1114         unsigned char byOrgDMACtl;
1115
1116         VNSvInPortB(dwIoBase + MAC_REG_RXDMACTL1, &byOrgDMACtl);
1117         if (byOrgDMACtl & DMACTL_RUN) {
1118                 VNSvOutPortB(dwIoBase + MAC_REG_RXDMACTL1+2, DMACTL_RUN);
1119         }
1120         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
1121                 VNSvInPortB(dwIoBase + MAC_REG_RXDMACTL1, &byData);
1122                 if (!(byData & DMACTL_RUN))
1123                         break;
1124         }
1125         if (ww == W_MAX_TIMEOUT) {
1126                 DBG_PORT80(0x14);
1127         }
1128         VNSvOutPortD(dwIoBase + MAC_REG_RXDMAPTR1, dwCurrDescAddr);
1129         if (byOrgDMACtl & DMACTL_RUN) {
1130                 VNSvOutPortB(dwIoBase + MAC_REG_RXDMACTL1, DMACTL_RUN);
1131         }
1132 }
1133
1134 /*
1135  * Description:
1136  *      Set the chip with current tx0 descriptor address
1137  *
1138  * Parameters:
1139  *  In:
1140  *      dwIoBase        - Base Address for MAC
1141  *      dwCurrDescAddr  - Descriptor Address
1142  *  Out:
1143  *      none
1144  *
1145  * Return Value: none
1146  *
1147  */
1148 void MACvSetCurrTx0DescAddrEx(unsigned long dwIoBase, unsigned long dwCurrDescAddr)
1149 {
1150         unsigned short ww;
1151         unsigned char byData;
1152         unsigned char byOrgDMACtl;
1153
1154         VNSvInPortB(dwIoBase + MAC_REG_TXDMACTL0, &byOrgDMACtl);
1155         if (byOrgDMACtl & DMACTL_RUN) {
1156                 VNSvOutPortB(dwIoBase + MAC_REG_TXDMACTL0+2, DMACTL_RUN);
1157         }
1158         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
1159                 VNSvInPortB(dwIoBase + MAC_REG_TXDMACTL0, &byData);
1160                 if (!(byData & DMACTL_RUN))
1161                         break;
1162         }
1163         if (ww == W_MAX_TIMEOUT) {
1164                 DBG_PORT80(0x25);
1165         }
1166         VNSvOutPortD(dwIoBase + MAC_REG_TXDMAPTR0, dwCurrDescAddr);
1167         if (byOrgDMACtl & DMACTL_RUN) {
1168                 VNSvOutPortB(dwIoBase + MAC_REG_TXDMACTL0, DMACTL_RUN);
1169         }
1170 }
1171
1172 /*
1173  * Description:
1174  *      Set the chip with current AC0 descriptor address
1175  *
1176  * Parameters:
1177  *  In:
1178  *      dwIoBase        - Base Address for MAC
1179  *      dwCurrDescAddr  - Descriptor Address
1180  *  Out:
1181  *      none
1182  *
1183  * Return Value: none
1184  *
1185  */
1186 //TxDMA1 = AC0DMA
1187 void MACvSetCurrAC0DescAddrEx(unsigned long dwIoBase, unsigned long dwCurrDescAddr)
1188 {
1189         unsigned short ww;
1190         unsigned char byData;
1191         unsigned char byOrgDMACtl;
1192
1193         VNSvInPortB(dwIoBase + MAC_REG_AC0DMACTL, &byOrgDMACtl);
1194         if (byOrgDMACtl & DMACTL_RUN) {
1195                 VNSvOutPortB(dwIoBase + MAC_REG_AC0DMACTL+2, DMACTL_RUN);
1196         }
1197         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
1198                 VNSvInPortB(dwIoBase + MAC_REG_AC0DMACTL, &byData);
1199                 if (!(byData & DMACTL_RUN))
1200                         break;
1201         }
1202         if (ww == W_MAX_TIMEOUT) {
1203                 DBG_PORT80(0x26);
1204                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " DBG_PORT80(0x26)\n");
1205         }
1206         VNSvOutPortD(dwIoBase + MAC_REG_AC0DMAPTR, dwCurrDescAddr);
1207         if (byOrgDMACtl & DMACTL_RUN) {
1208                 VNSvOutPortB(dwIoBase + MAC_REG_AC0DMACTL, DMACTL_RUN);
1209         }
1210 }
1211
1212
1213
1214 void MACvSetCurrTXDescAddr(int iTxType, unsigned long dwIoBase, unsigned long dwCurrDescAddr)
1215 {
1216         if (iTxType == TYPE_AC0DMA) {
1217                 MACvSetCurrAC0DescAddrEx(dwIoBase, dwCurrDescAddr);
1218         } else if (iTxType == TYPE_TXDMA0) {
1219                 MACvSetCurrTx0DescAddrEx(dwIoBase, dwCurrDescAddr);
1220         }
1221 }
1222
1223 /*
1224  * Description:
1225  *      Micro Second Delay via MAC
1226  *
1227  * Parameters:
1228  *  In:
1229  *      dwIoBase    - Base Address for MAC
1230  *      uDelay      - Delay time (timer resolution is 4 us)
1231  *  Out:
1232  *      none
1233  *
1234  * Return Value: none
1235  *
1236  */
1237 void MACvTimer0MicroSDelay(unsigned long dwIoBase, unsigned int uDelay)
1238 {
1239         unsigned char byValue;
1240         unsigned int uu, ii;
1241
1242         VNSvOutPortB(dwIoBase + MAC_REG_TMCTL0, 0);
1243         VNSvOutPortD(dwIoBase + MAC_REG_TMDATA0, uDelay);
1244         VNSvOutPortB(dwIoBase + MAC_REG_TMCTL0, (TMCTL_TMD | TMCTL_TE));
1245         for (ii = 0; ii < 66; ii++) {  // assume max PCI clock is 66Mhz
1246                 for (uu = 0; uu < uDelay; uu++) {
1247                         VNSvInPortB(dwIoBase + MAC_REG_TMCTL0, &byValue);
1248                         if ((byValue == 0) ||
1249                             (byValue & TMCTL_TSUSP)) {
1250                                 VNSvOutPortB(dwIoBase + MAC_REG_TMCTL0, 0);
1251                                 return;
1252                         }
1253                 }
1254         }
1255         VNSvOutPortB(dwIoBase + MAC_REG_TMCTL0, 0);
1256
1257 }
1258
1259 /*
1260  * Description:
1261  *      Micro Second One shot timer via MAC
1262  *
1263  * Parameters:
1264  *  In:
1265  *      dwIoBase    - Base Address for MAC
1266  *      uDelay      - Delay time
1267  *  Out:
1268  *      none
1269  *
1270  * Return Value: none
1271  *
1272  */
1273 void MACvOneShotTimer0MicroSec(unsigned long dwIoBase, unsigned int uDelayTime)
1274 {
1275         VNSvOutPortB(dwIoBase + MAC_REG_TMCTL0, 0);
1276         VNSvOutPortD(dwIoBase + MAC_REG_TMDATA0, uDelayTime);
1277         VNSvOutPortB(dwIoBase + MAC_REG_TMCTL0, (TMCTL_TMD | TMCTL_TE));
1278 }
1279
1280 /*
1281  * Description:
1282  *      Micro Second One shot timer via MAC
1283  *
1284  * Parameters:
1285  *  In:
1286  *      dwIoBase    - Base Address for MAC
1287  *      uDelay      - Delay time
1288  *  Out:
1289  *      none
1290  *
1291  * Return Value: none
1292  *
1293  */
1294 void MACvOneShotTimer1MicroSec(unsigned long dwIoBase, unsigned int uDelayTime)
1295 {
1296         VNSvOutPortB(dwIoBase + MAC_REG_TMCTL1, 0);
1297         VNSvOutPortD(dwIoBase + MAC_REG_TMDATA1, uDelayTime);
1298         VNSvOutPortB(dwIoBase + MAC_REG_TMCTL1, (TMCTL_TMD | TMCTL_TE));
1299 }
1300
1301
1302 void MACvSetMISCFifo(unsigned long dwIoBase, unsigned short wOffset, unsigned long dwData)
1303 {
1304         if (wOffset > 273)
1305                 return;
1306         VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
1307         VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
1308         VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
1309 }
1310
1311
1312 bool MACbTxDMAOff(unsigned long dwIoBase, unsigned int idx)
1313 {
1314         unsigned char byData;
1315         unsigned int ww = 0;
1316
1317         if (idx == TYPE_TXDMA0) {
1318                 VNSvOutPortB(dwIoBase + MAC_REG_TXDMACTL0+2, DMACTL_RUN);
1319                 for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
1320                         VNSvInPortB(dwIoBase + MAC_REG_TXDMACTL0, &byData);
1321                         if (!(byData & DMACTL_RUN))
1322                                 break;
1323                 }
1324         } else if (idx == TYPE_AC0DMA) {
1325                 VNSvOutPortB(dwIoBase + MAC_REG_AC0DMACTL+2, DMACTL_RUN);
1326                 for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
1327                         VNSvInPortB(dwIoBase + MAC_REG_AC0DMACTL, &byData);
1328                         if (!(byData & DMACTL_RUN))
1329                                 break;
1330                 }
1331         }
1332         if (ww == W_MAX_TIMEOUT) {
1333                 DBG_PORT80(0x29);
1334                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " DBG_PORT80(0x29)\n");
1335                 return false;
1336         }
1337         return true;
1338 }
1339
1340 void MACvClearBusSusInd(unsigned long dwIoBase)
1341 {
1342         unsigned long dwOrgValue;
1343         unsigned int ww;
1344         // check if BcnSusInd enabled
1345         VNSvInPortD(dwIoBase + MAC_REG_ENCFG , &dwOrgValue);
1346         if (!(dwOrgValue & EnCFG_BcnSusInd))
1347                 return;
1348         //Set BcnSusClr
1349         dwOrgValue = dwOrgValue | EnCFG_BcnSusClr;
1350         VNSvOutPortD(dwIoBase + MAC_REG_ENCFG, dwOrgValue);
1351         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
1352                 VNSvInPortD(dwIoBase + MAC_REG_ENCFG , &dwOrgValue);
1353                 if (!(dwOrgValue & EnCFG_BcnSusInd))
1354                         break;
1355         }
1356         if (ww == W_MAX_TIMEOUT) {
1357                 DBG_PORT80(0x33);
1358                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " DBG_PORT80(0x33)\n");
1359         }
1360 }
1361
1362 void MACvEnableBusSusEn(unsigned long dwIoBase)
1363 {
1364         unsigned char byOrgValue;
1365         unsigned long dwOrgValue;
1366         unsigned int ww;
1367         // check if BcnSusInd enabled
1368         VNSvInPortB(dwIoBase + MAC_REG_CFG , &byOrgValue);
1369
1370         //Set BcnSusEn
1371         byOrgValue = byOrgValue | CFG_BCNSUSEN;
1372         VNSvOutPortB(dwIoBase + MAC_REG_ENCFG, byOrgValue);
1373         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
1374                 VNSvInPortD(dwIoBase + MAC_REG_ENCFG , &dwOrgValue);
1375                 if (dwOrgValue & EnCFG_BcnSusInd)
1376                         break;
1377         }
1378         if (ww == W_MAX_TIMEOUT) {
1379                 DBG_PORT80(0x34);
1380                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " DBG_PORT80(0x34)\n");
1381         }
1382 }
1383
1384 bool MACbFlushSYNCFifo(unsigned long dwIoBase)
1385 {
1386         unsigned char byOrgValue;
1387         unsigned int ww;
1388         // Read MACCR
1389         VNSvInPortB(dwIoBase + MAC_REG_MACCR , &byOrgValue);
1390
1391         // Set SYNCFLUSH
1392         byOrgValue = byOrgValue | MACCR_SYNCFLUSH;
1393         VNSvOutPortB(dwIoBase + MAC_REG_MACCR, byOrgValue);
1394
1395         // Check if SyncFlushOK
1396         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
1397                 VNSvInPortB(dwIoBase + MAC_REG_MACCR , &byOrgValue);
1398                 if (byOrgValue & MACCR_SYNCFLUSHOK)
1399                         break;
1400         }
1401         if (ww == W_MAX_TIMEOUT) {
1402                 DBG_PORT80(0x35);
1403                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " DBG_PORT80(0x33)\n");
1404         }
1405         return true;
1406 }
1407
1408 bool MACbPSWakeup(unsigned long dwIoBase)
1409 {
1410         unsigned char byOrgValue;
1411         unsigned int ww;
1412         // Read PSCTL
1413         if (MACbIsRegBitsOff(dwIoBase, MAC_REG_PSCTL, PSCTL_PS)) {
1414                 return true;
1415         }
1416         // Disable PS
1417         MACvRegBitsOff(dwIoBase, MAC_REG_PSCTL, PSCTL_PSEN);
1418
1419         // Check if SyncFlushOK
1420         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
1421                 VNSvInPortB(dwIoBase + MAC_REG_PSCTL , &byOrgValue);
1422                 if (byOrgValue & PSCTL_WAKEDONE)
1423                         break;
1424         }
1425         if (ww == W_MAX_TIMEOUT) {
1426                 DBG_PORT80(0x36);
1427                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " DBG_PORT80(0x33)\n");
1428                 return false;
1429         }
1430         return true;
1431 }
1432
1433 /*
1434  * Description:
1435  *      Set the Key by MISCFIFO
1436  *
1437  * Parameters:
1438  *  In:
1439  *      dwIoBase        - Base Address for MAC
1440  *
1441  *  Out:
1442  *      none
1443  *
1444  * Return Value: none
1445  *
1446  */
1447
1448 void MACvSetKeyEntry(unsigned long dwIoBase, unsigned short wKeyCtl, unsigned int uEntryIdx,
1449                      unsigned int uKeyIdx, unsigned char *pbyAddr, unsigned long *pdwKey, unsigned char byLocalID)
1450 {
1451         unsigned short wOffset;
1452         unsigned long dwData;
1453         int     ii;
1454
1455         if (byLocalID <= 1)
1456                 return;
1457
1458
1459         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "MACvSetKeyEntry\n");
1460         wOffset = MISCFIFO_KEYETRY0;
1461         wOffset += (uEntryIdx * MISCFIFO_KEYENTRYSIZE);
1462
1463         dwData = 0;
1464         dwData |= wKeyCtl;
1465         dwData <<= 16;
1466         dwData |= MAKEWORD(*(pbyAddr+4), *(pbyAddr+5));
1467         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "1. wOffset: %d, Data: %lX, KeyCtl:%X\n", wOffset, dwData, wKeyCtl);
1468
1469         VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
1470         VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
1471         VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
1472         wOffset++;
1473
1474         dwData = 0;
1475         dwData |= *(pbyAddr+3);
1476         dwData <<= 8;
1477         dwData |= *(pbyAddr+2);
1478         dwData <<= 8;
1479         dwData |= *(pbyAddr+1);
1480         dwData <<= 8;
1481         dwData |= *(pbyAddr+0);
1482         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "2. wOffset: %d, Data: %lX\n", wOffset, dwData);
1483
1484         VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
1485         VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
1486         VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
1487         wOffset++;
1488
1489         wOffset += (uKeyIdx * 4);
1490         for (ii = 0; ii < 4; ii++) {
1491                 // always push 128 bits
1492                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "3.(%d) wOffset: %d, Data: %lX\n", ii, wOffset+ii, *pdwKey);
1493                 VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset+ii);
1494                 VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, *pdwKey++);
1495                 VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
1496         }
1497 }
1498
1499
1500
1501 /*
1502  * Description:
1503  *      Disable the Key Entry by MISCFIFO
1504  *
1505  * Parameters:
1506  *  In:
1507  *      dwIoBase        - Base Address for MAC
1508  *
1509  *  Out:
1510  *      none
1511  *
1512  * Return Value: none
1513  *
1514  */
1515 void MACvDisableKeyEntry(unsigned long dwIoBase, unsigned int uEntryIdx)
1516 {
1517         unsigned short wOffset;
1518
1519         wOffset = MISCFIFO_KEYETRY0;
1520         wOffset += (uEntryIdx * MISCFIFO_KEYENTRYSIZE);
1521
1522         VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
1523         VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, 0);
1524         VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
1525 }
1526
1527
1528 /*
1529  * Description:
1530  *      Set the default Key (KeyEntry[10]) by MISCFIFO
1531  *
1532  * Parameters:
1533  *  In:
1534  *      dwIoBase        - Base Address for MAC
1535  *
1536  *  Out:
1537  *      none
1538  *
1539  * Return Value: none
1540  *
1541  */
1542
1543 void MACvSetDefaultKeyEntry(unsigned long dwIoBase, unsigned int uKeyLen,
1544                             unsigned int uKeyIdx, unsigned long *pdwKey, unsigned char byLocalID)
1545 {
1546         unsigned short wOffset;
1547         unsigned long dwData;
1548         int     ii;
1549
1550         if (byLocalID <= 1)
1551                 return;
1552
1553         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "MACvSetDefaultKeyEntry\n");
1554         wOffset = MISCFIFO_KEYETRY0;
1555         wOffset += (10 * MISCFIFO_KEYENTRYSIZE);
1556
1557         wOffset++;
1558         wOffset++;
1559         wOffset += (uKeyIdx * 4);
1560         // always push 128 bits
1561         for (ii = 0; ii < 3; ii++) {
1562                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "(%d) wOffset: %d, Data: %lX\n", ii, wOffset+ii, *pdwKey);
1563                 VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset+ii);
1564                 VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, *pdwKey++);
1565                 VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
1566         }
1567         dwData = *pdwKey;
1568         if (uKeyLen == WLAN_WEP104_KEYLEN) {
1569                 dwData |= 0x80000000;
1570         }
1571         VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset+3);
1572         VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
1573         VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
1574         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "End. wOffset: %d, Data: %lX\n", wOffset+3, dwData);
1575
1576 }
1577
1578
1579 /*
1580  * Description:
1581  *      Enable default Key (KeyEntry[10]) by MISCFIFO
1582  *
1583  * Parameters:
1584  *  In:
1585  *      dwIoBase        - Base Address for MAC
1586  *
1587  *  Out:
1588  *      none
1589  *
1590  * Return Value: none
1591  *
1592  */
1593 /*
1594   void MACvEnableDefaultKey(unsigned long dwIoBase, unsigned char byLocalID)
1595   {
1596   unsigned short wOffset;
1597   unsigned long dwData;
1598
1599
1600   if (byLocalID <= 1)
1601   return;
1602
1603   wOffset = MISCFIFO_KEYETRY0;
1604   wOffset += (10 * MISCFIFO_KEYENTRYSIZE);
1605
1606   dwData = 0xC0440000;
1607   VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
1608   VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
1609   VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
1610   DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "MACvEnableDefaultKey: wOffset: %d, Data: %lX\n", wOffset, dwData);
1611
1612   }
1613 */
1614
1615 /*
1616  * Description:
1617  *      Disable default Key (KeyEntry[10]) by MISCFIFO
1618  *
1619  * Parameters:
1620  *  In:
1621  *      dwIoBase        - Base Address for MAC
1622  *
1623  *  Out:
1624  *      none
1625  *
1626  * Return Value: none
1627  *
1628  */
1629 void MACvDisableDefaultKey(unsigned long dwIoBase)
1630 {
1631         unsigned short wOffset;
1632         unsigned long dwData;
1633
1634
1635         wOffset = MISCFIFO_KEYETRY0;
1636         wOffset += (10 * MISCFIFO_KEYENTRYSIZE);
1637
1638         dwData = 0x0;
1639         VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
1640         VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
1641         VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
1642         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "MACvDisableDefaultKey: wOffset: %d, Data: %lX\n", wOffset, dwData);
1643 }
1644
1645 /*
1646  * Description:
1647  *      Set the default TKIP Group Key (KeyEntry[10]) by MISCFIFO
1648  *
1649  * Parameters:
1650  *  In:
1651  *      dwIoBase        - Base Address for MAC
1652  *
1653  *  Out:
1654  *      none
1655  *
1656  * Return Value: none
1657  *
1658  */
1659 void MACvSetDefaultTKIPKeyEntry(unsigned long dwIoBase, unsigned int uKeyLen,
1660                                 unsigned int uKeyIdx, unsigned long *pdwKey, unsigned char byLocalID)
1661 {
1662         unsigned short wOffset;
1663         unsigned long dwData;
1664         int     ii;
1665
1666         if (byLocalID <= 1)
1667                 return;
1668
1669
1670         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "MACvSetDefaultTKIPKeyEntry\n");
1671         wOffset = MISCFIFO_KEYETRY0;
1672         // Kyle test : change offset from 10 -> 0
1673         wOffset += (10 * MISCFIFO_KEYENTRYSIZE);
1674
1675         dwData = 0xC0660000;
1676         VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
1677         VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
1678         VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
1679         wOffset++;
1680
1681         dwData = 0;
1682         VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
1683         VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
1684         VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
1685         wOffset++;
1686
1687         wOffset += (uKeyIdx * 4);
1688         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "1. wOffset: %d, Data: %lX, idx:%d\n", wOffset, *pdwKey, uKeyIdx);
1689         // always push 128 bits
1690         for (ii = 0; ii < 4; ii++) {
1691                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "2.(%d) wOffset: %d, Data: %lX\n", ii, wOffset+ii, *pdwKey);
1692                 VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset+ii);
1693                 VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, *pdwKey++);
1694                 VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
1695         }
1696
1697 }
1698
1699
1700
1701 /*
1702  * Description:
1703  *      Set the Key Control by MISCFIFO
1704  *
1705  * Parameters:
1706  *  In:
1707  *      dwIoBase        - Base Address for MAC
1708  *
1709  *  Out:
1710  *      none
1711  *
1712  * Return Value: none
1713  *
1714  */
1715
1716 void MACvSetDefaultKeyCtl(unsigned long dwIoBase, unsigned short wKeyCtl, unsigned int uEntryIdx, unsigned char byLocalID)
1717 {
1718         unsigned short wOffset;
1719         unsigned long dwData;
1720
1721         if (byLocalID <= 1)
1722                 return;
1723
1724
1725         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "MACvSetKeyEntry\n");
1726         wOffset = MISCFIFO_KEYETRY0;
1727         wOffset += (uEntryIdx * MISCFIFO_KEYENTRYSIZE);
1728
1729         dwData = 0;
1730         dwData |= wKeyCtl;
1731         dwData <<= 16;
1732         dwData |= 0xffff;
1733         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "1. wOffset: %d, Data: %lX, KeyCtl:%X\n", wOffset, dwData, wKeyCtl);
1734
1735         VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
1736         VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
1737         VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
1738
1739 }
1740