Staging: Add pristine upstream vt6655 driver sources

Add pristine upstream vt6655 driver sources to drivers/staging/vt6655.  These
files were literally copied from the driver directory in the upstream source
archive, available here:

  http://www.viaarena.com/Driver/vt6655_linux_src_v1.19.12_x86.zip

Signed-off-by: Forest Bond <forest@alittletooquiet.net>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

1 files changed, 1752 insertions, 0 deletions

diff --git a/drivers/staging/vt6655/mac.c b/drivers/staging/vt6655/mac.c
new file mode 100644
index 0000000..0283ed3
--- /dev/null
+++ b/drivers/staging/vt6655/mac.c
@@ -0,0 +1,1752 @@
+/*
+ * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * File: mac.c
+ *
+ * Purpose:  MAC routines
+ *
+ * Author: Tevin Chen
+ *
+ * Date: May 21, 1996
+ *
+ * Functions:
+ *      MACvReadAllRegs - Read All MAC Registers to buffer
+ *      MACbIsRegBitsOn - Test if All test Bits On
+ *      MACbIsRegBitsOff - Test if All test Bits Off
+ *      MACbIsIntDisable - Test if MAC interrupt disable
+ *      MACbyReadMultiAddr - Read Multicast Address Mask Pattern
+ *      MACvWriteMultiAddr - Write Multicast Address Mask Pattern
+ *      MACvSetMultiAddrByHash - Set Multicast Address Mask by Hash value
+ *      MACvResetMultiAddrByHash - Clear Multicast Address Mask by Hash value
+ *      MACvSetRxThreshold - Set Rx Threshold value
+ *      MACvGetRxThreshold - Get Rx Threshold value
+ *      MACvSetTxThreshold - Set Tx Threshold value
+ *      MACvGetTxThreshold - Get Tx Threshold value
+ *      MACvSetDmaLength - Set Dma Length value
+ *      MACvGetDmaLength - Get Dma Length value
+ *      MACvSetShortRetryLimit - Set 802.11 Short Retry limit
+ *      MACvGetShortRetryLimit - Get 802.11 Short Retry limit
+ *      MACvSetLongRetryLimit - Set 802.11 Long Retry limit
+ *      MACvGetLongRetryLimit - Get 802.11 Long Retry limit
+ *      MACvSetLoopbackMode - Set MAC Loopback Mode
+ *      MACbIsInLoopbackMode - Test if MAC in Loopback mode
+ *      MACvSetPacketFilter - Set MAC Address Filter
+ *      MACvSaveContext - Save Context of MAC Registers
+ *      MACvRestoreContext - Restore Context of MAC Registers
+ *      MACbCompareContext - Compare if values of MAC Registers same as Context
+ *      MACbSoftwareReset - Software Reset MAC
+ *      MACbSafeRxOff - Turn Off MAC Rx
+ *      MACbSafeTxOff - Turn Off MAC Tx
+ *      MACbSafeStop - Stop MAC function
+ *      MACbShutdown - Shut down MAC
+ *      MACvInitialize - Initialize MAC
+ *      MACvSetCurrRxDescAddr - Set Rx Descriptos Address
+ *      MACvSetCurrTx0DescAddr - Set Tx0 Descriptos Address
+ *      MACvSetCurrTx1DescAddr - Set Tx1 Descriptos Address
+ *      MACvTimer0MicroSDelay - Micro Second Delay Loop by MAC
+ *
+ * Revision History:
+ *      08-22-2003 Kyle Hsu     :  Porting MAC functions from sim53
+ *      09-03-2003 Bryan YC Fan :  Add MACvClearBusSusInd()& MACvEnableBusSusEn()
+ *      09-18-2003 Jerry Chen   :  Add MACvSetKeyEntry & MACvDisableKeyEntry
+ *
+ */
+
+#if !defined(__TMACRO_H__)
+#include "tmacro.h"
+#endif
+#if !defined(__TBIT_H__)
+#include "tbit.h"
+#endif
+#if !defined(__TETHER_H__)
+#include "tether.h"
+#endif
+#if !defined(__MAC_H__)
+#include "mac.h"
+#endif
+
+
+WORD TxRate_iwconfig;//2008-5-8 <add> by chester
+/*---------------------  Static Definitions -------------------------*/
+//static int          msglevel                =MSG_LEVEL_DEBUG;
+static int          msglevel                =MSG_LEVEL_INFO;
+/*---------------------  Static Classes  ----------------------------*/
+
+/*---------------------  Static Variables  --------------------------*/
+
+/*---------------------  Static Functions  --------------------------*/
+
+/*---------------------  Export Variables  --------------------------*/
+
+/*---------------------  Export Functions  --------------------------*/
+
+/*
+ * Description:
+ *      Read All MAC Registers to buffer
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *  Out:
+ *      pbyMacRegs  - buffer to read
+ *
+ * Return Value: none
+ *
+ */
+VOID MACvReadAllRegs (DWORD_PTR dwIoBase, PBYTE pbyMacRegs)
+{
+    int ii;
+
+    // read page0 register
+    for (ii = 0; ii < MAC_MAX_CONTEXT_SIZE_PAGE0; ii++) {
+        VNSvInPortB(dwIoBase + ii, pbyMacRegs);
+        pbyMacRegs++;
+    }
+
+    MACvSelectPage1(dwIoBase);
+
+    // read page1 register
+    for (ii = 0; ii < MAC_MAX_CONTEXT_SIZE_PAGE1; ii++) {
+        VNSvInPortB(dwIoBase + ii, pbyMacRegs);
+        pbyMacRegs++;
+    }
+
+    MACvSelectPage0(dwIoBase);
+
+}
+
+/*
+ * Description:
+ *      Test if all test bits on
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *      byRegOfs    - Offset of MAC Register
+ *      byTestBits  - Test bits
+ *  Out:
+ *      none
+ *
+ * Return Value: TRUE if all test bits On; otherwise FALSE
+ *
+ */
+BOOL MACbIsRegBitsOn (DWORD_PTR dwIoBase, BYTE byRegOfs, BYTE byTestBits)
+{
+    BYTE byData;
+
+    VNSvInPortB(dwIoBase + byRegOfs, &byData);
+    return BITbIsAllBitsOn(byData, byTestBits);
+}
+
+/*
+ * Description:
+ *      Test if all test bits off
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *      byRegOfs    - Offset of MAC Register
+ *      byTestBits  - Test bits
+ *  Out:
+ *      none
+ *
+ * Return Value: TRUE if all test bits Off; otherwise FALSE
+ *
+ */
+BOOL MACbIsRegBitsOff (DWORD_PTR dwIoBase, BYTE byRegOfs, BYTE byTestBits)
+{
+    BYTE byData;
+
+    VNSvInPortB(dwIoBase + byRegOfs, &byData);
+    return BITbIsAllBitsOff(byData, byTestBits);
+}
+
+/*
+ * Description:
+ *      Test if MAC interrupt disable
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *  Out:
+ *      none
+ *
+ * Return Value: TRUE if interrupt is disable; otherwise FALSE
+ *
+ */
+BOOL MACbIsIntDisable (DWORD_PTR dwIoBase)
+{
+    DWORD dwData;
+
+    VNSvInPortD(dwIoBase + MAC_REG_IMR, &dwData);
+    if (dwData != 0)
+        return FALSE;
+
+    return TRUE;
+}
+
+/*
+ * Description:
+ *      Read MAC Multicast Address Mask
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *      uByteidx    - Index of Mask
+ *  Out:
+ *      none
+ *
+ * Return Value: Mask Value read
+ *
+ */
+BYTE MACbyReadMultiAddr (DWORD_PTR dwIoBase, UINT uByteIdx)
+{
+    BYTE byData;
+
+    MACvSelectPage1(dwIoBase);
+    VNSvInPortB(dwIoBase + MAC_REG_MAR0 + uByteIdx, &byData);
+    MACvSelectPage0(dwIoBase);
+    return byData;
+}
+
+/*
+ * Description:
+ *      Write MAC Multicast Address Mask
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *      uByteidx    - Index of Mask
+ *      byData      - Mask Value to write
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+VOID MACvWriteMultiAddr (DWORD_PTR dwIoBase, UINT uByteIdx, BYTE byData)
+{
+    MACvSelectPage1(dwIoBase);
+    VNSvOutPortB(dwIoBase + MAC_REG_MAR0 + uByteIdx, byData);
+    MACvSelectPage0(dwIoBase);
+}
+
+/*
+ * Description:
+ *      Set this hash index into multicast address register bit
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *      byHashIdx   - Hash index to set
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+void MACvSetMultiAddrByHash (DWORD_PTR dwIoBase, BYTE byHashIdx)
+{
+    UINT uByteIdx;
+    BYTE byBitMask;
+    BYTE byOrgValue;
+
+    // calculate byte position
+    uByteIdx = byHashIdx / 8;
+    ASSERT(uByteIdx < 8);
+    // calculate bit position
+    byBitMask = 1;
+    byBitMask <<= (byHashIdx % 8);
+    // turn on the bit
+    byOrgValue = MACbyReadMultiAddr(dwIoBase, uByteIdx);
+    MACvWriteMultiAddr(dwIoBase, uByteIdx, (BYTE)(byOrgValue | byBitMask));
+}
+
+/*
+ * Description:
+ *      Reset this hash index into multicast address register bit
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *      byHashIdx   - Hash index to clear
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+void MACvResetMultiAddrByHash (DWORD_PTR dwIoBase, BYTE byHashIdx)
+{
+    UINT uByteIdx;
+    BYTE byBitMask;
+    BYTE byOrgValue;
+
+    // calculate byte position
+    uByteIdx = byHashIdx / 8;
+    ASSERT(uByteIdx < 8);
+    // calculate bit position
+    byBitMask = 1;
+    byBitMask <<= (byHashIdx % 8);
+    // turn off the bit
+    byOrgValue = MACbyReadMultiAddr(dwIoBase, uByteIdx);
+    MACvWriteMultiAddr(dwIoBase, uByteIdx, (BYTE)(byOrgValue & (~byBitMask)));
+}
+
+/*
+ * Description:
+ *      Set Rx Threshold
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *      byThreshold - Threshold Value
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+void MACvSetRxThreshold (DWORD_PTR dwIoBase, BYTE byThreshold)
+{
+    BYTE byOrgValue;
+
+    ASSERT(byThreshold < 4);
+
+    // set FCR0
+    VNSvInPortB(dwIoBase + MAC_REG_FCR0, &byOrgValue);
+    byOrgValue = (byOrgValue & 0xCF) | (byThreshold << 4);
+    VNSvOutPortB(dwIoBase + MAC_REG_FCR0, byOrgValue);
+}
+
+/*
+ * Description:
+ *      Get Rx Threshold
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *  Out:
+ *      pbyThreshold- Threshold Value Get
+ *
+ * Return Value: none
+ *
+ */
+void MACvGetRxThreshold (DWORD_PTR dwIoBase, PBYTE pbyThreshold)
+{
+    // get FCR0
+    VNSvInPortB(dwIoBase + MAC_REG_FCR0, pbyThreshold);
+    *pbyThreshold = (*pbyThreshold >> 4) & 0x03;
+}
+
+/*
+ * Description:
+ *      Set Tx Threshold
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *      byThreshold - Threshold Value
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+void MACvSetTxThreshold (DWORD_PTR dwIoBase, BYTE byThreshold)
+{
+    BYTE byOrgValue;
+
+    ASSERT(byThreshold < 4);
+
+    // set FCR0
+    VNSvInPortB(dwIoBase + MAC_REG_FCR0, &byOrgValue);
+    byOrgValue = (byOrgValue & 0xF3) | (byThreshold << 2);
+    VNSvOutPortB(dwIoBase + MAC_REG_FCR0, byOrgValue);
+}
+
+/*
+ * Description:
+ *      Get Tx Threshold
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *  Out:
+ *      pbyThreshold- Threshold Value Get
+ *
+ * Return Value: none
+ *
+ */
+void MACvGetTxThreshold (DWORD_PTR dwIoBase, PBYTE pbyThreshold)
+{
+    // get FCR0
+    VNSvInPortB(dwIoBase + MAC_REG_FCR0, pbyThreshold);
+    *pbyThreshold = (*pbyThreshold >> 2) & 0x03;
+}
+
+/*
+ * Description:
+ *      Set Dma Length
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *      byDmaLength - Dma Length Value
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+void MACvSetDmaLength (DWORD_PTR dwIoBase, BYTE byDmaLength)
+{
+    BYTE byOrgValue;
+
+    ASSERT(byDmaLength < 4);
+
+    // set FCR0
+    VNSvInPortB(dwIoBase + MAC_REG_FCR0, &byOrgValue);
+    byOrgValue = (byOrgValue & 0xFC) | byDmaLength;
+    VNSvOutPortB(dwIoBase + MAC_REG_FCR0, byOrgValue);
+}
+
+/*
+ * Description:
+ *      Get Dma Length
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *  Out:
+ *      pbyDmaLength- Dma Length Value Get
+ *
+ * Return Value: none
+ *
+ */
+void MACvGetDmaLength (DWORD_PTR dwIoBase, PBYTE pbyDmaLength)
+{
+    // get FCR0
+    VNSvInPortB(dwIoBase + MAC_REG_FCR0, pbyDmaLength);
+    *pbyDmaLength &= 0x03;
+}
+
+/*
+ * Description:
+ *      Set 802.11 Short Retry Limit
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *      byRetryLimit- Retry Limit
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+void MACvSetShortRetryLimit (DWORD_PTR dwIoBase, BYTE byRetryLimit)
+{
+    // set SRT
+    VNSvOutPortB(dwIoBase + MAC_REG_SRT, byRetryLimit);
+}
+
+/*
+ * Description:
+ *      Get 802.11 Short Retry Limit
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase        - Base Address for MAC
+ *  Out:
+ *      pbyRetryLimit   - Retry Limit Get
+ *
+ * Return Value: none
+ *
+ */
+void MACvGetShortRetryLimit (DWORD_PTR dwIoBase, PBYTE pbyRetryLimit)
+{
+    // get SRT
+    VNSvInPortB(dwIoBase + MAC_REG_SRT, pbyRetryLimit);
+}
+
+/*
+ * Description:
+ *      Set 802.11 Long Retry Limit
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *      byRetryLimit- Retry Limit
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+void MACvSetLongRetryLimit (DWORD_PTR dwIoBase, BYTE byRetryLimit)
+{
+    // set LRT
+    VNSvOutPortB(dwIoBase + MAC_REG_LRT, byRetryLimit);
+}
+
+/*
+ * Description:
+ *      Get 802.11 Long Retry Limit
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase        - Base Address for MAC
+ *  Out:
+ *      pbyRetryLimit   - Retry Limit Get
+ *
+ * Return Value: none
+ *
+ */
+void MACvGetLongRetryLimit (DWORD_PTR dwIoBase, PBYTE pbyRetryLimit)
+{
+    // get LRT
+    VNSvInPortB(dwIoBase + MAC_REG_LRT, pbyRetryLimit);
+}
+
+/*
+ * Description:
+ *      Set MAC Loopback mode
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase        - Base Address for MAC
+ *      byLoopbackMode  - Loopback Mode
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+void MACvSetLoopbackMode (DWORD_PTR dwIoBase, BYTE byLoopbackMode)
+{
+    BYTE byOrgValue;
+
+    ASSERT(byLoopbackMode < 3);
+    byLoopbackMode <<= 6;
+    // set TCR
+    VNSvInPortB(dwIoBase + MAC_REG_TEST, &byOrgValue);
+    byOrgValue = byOrgValue & 0x3F;
+    byOrgValue = byOrgValue | byLoopbackMode;
+    VNSvOutPortB(dwIoBase + MAC_REG_TEST, byOrgValue);
+}
+
+/*
+ * Description:
+ *      Test if MAC in Loopback mode
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase        - Base Address for MAC
+ *  Out:
+ *      none
+ *
+ * Return Value: TRUE if in Loopback mode; otherwise FALSE
+ *
+ */
+BOOL MACbIsInLoopbackMode (DWORD_PTR dwIoBase)
+{
+    BYTE byOrgValue;
+
+    VNSvInPortB(dwIoBase + MAC_REG_TEST, &byOrgValue);
+    if (BITbIsAnyBitsOn(byOrgValue, (TEST_LBINT | TEST_LBEXT)))
+        return TRUE;
+    return FALSE;
+}
+
+/*
+ * Description:
+ *      Set MAC Address filter
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase        - Base Address for MAC
+ *      wFilterType     - Filter Type
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+void MACvSetPacketFilter (DWORD_PTR dwIoBase, WORD wFilterType)
+{
+    BYTE    byOldRCR;
+    BYTE    byNewRCR = 0;
+
+    // if only in DIRECTED mode, multicast-address will set to zero,
+    // but if other mode exist (e.g. PROMISCUOUS), multicast-address
+    // will be open
+    if (BITbIsBitOn(wFilterType, PKT_TYPE_DIRECTED)) {
+        // set multicast address to accept none
+        MACvSelectPage1(dwIoBase);
+        VNSvOutPortD(dwIoBase + MAC_REG_MAR0, 0L);
+        VNSvOutPortD(dwIoBase + MAC_REG_MAR0 + sizeof(DWORD), 0L);
+        MACvSelectPage0(dwIoBase);
+    }
+
+    if (BITbIsAnyBitsOn(wFilterType, PKT_TYPE_PROMISCUOUS | PKT_TYPE_ALL_MULTICAST)) {
+        // set multicast address to accept all
+        MACvSelectPage1(dwIoBase);
+        VNSvOutPortD(dwIoBase + MAC_REG_MAR0, 0xFFFFFFFFL);
+        VNSvOutPortD(dwIoBase + MAC_REG_MAR0 + sizeof(DWORD), 0xFFFFFFFFL);
+        MACvSelectPage0(dwIoBase);
+    }
+
+    if (BITbIsBitOn(wFilterType, PKT_TYPE_PROMISCUOUS)) {
+
+        byNewRCR |= (RCR_RXALLTYPE | RCR_UNICAST | RCR_MULTICAST | RCR_BROADCAST);
+
+        byNewRCR &= ~RCR_BSSID;
+    }
+
+    if (BITbIsAnyBitsOn(wFilterType, (PKT_TYPE_ALL_MULTICAST | PKT_TYPE_MULTICAST)))
+        byNewRCR |= RCR_MULTICAST;
+
+    if (BITbIsBitOn(wFilterType, PKT_TYPE_BROADCAST))
+        byNewRCR |= RCR_BROADCAST;
+
+    if (BITbIsBitOn(wFilterType, PKT_TYPE_ERROR_CRC))
+        byNewRCR |= RCR_ERRCRC;
+
+    VNSvInPortB(dwIoBase + MAC_REG_RCR,  &byOldRCR);
+    if (byNewRCR != byOldRCR) {
+        // Modify the Receive Command Register
+        VNSvOutPortB(dwIoBase + MAC_REG_RCR, byNewRCR);
+    }
+}
+
+/*
+ * Description:
+ *      Save MAC registers to context buffer
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *  Out:
+ *      pbyCxtBuf   - Context buffer
+ *
+ * Return Value: none
+ *
+ */
+void MACvSaveContext (DWORD_PTR dwIoBase, PBYTE pbyCxtBuf)
+{
+    int         ii;
+
+    // read page0 register
+    for (ii = 0; ii < MAC_MAX_CONTEXT_SIZE_PAGE0; ii++) {
+        VNSvInPortB((dwIoBase + ii), (pbyCxtBuf + ii));
+    }
+
+    MACvSelectPage1(dwIoBase);
+
+    // read page1 register
+    for (ii = 0; ii < MAC_MAX_CONTEXT_SIZE_PAGE1; ii++) {
+        VNSvInPortB((dwIoBase + ii), (pbyCxtBuf + MAC_MAX_CONTEXT_SIZE_PAGE0 + ii));
+    }
+
+    MACvSelectPage0(dwIoBase);
+}
+
+/*
+ * Description:
+ *      Restore MAC registers from context buffer
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *      pbyCxtBuf   - Context buffer
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+VOID MACvRestoreContext (DWORD_PTR dwIoBase, PBYTE pbyCxtBuf)
+{
+    int         ii;
+
+    MACvSelectPage1(dwIoBase);
+    // restore page1
+    for (ii = 0; ii < MAC_MAX_CONTEXT_SIZE_PAGE1; ii++) {
+        VNSvOutPortB((dwIoBase + ii), *(pbyCxtBuf + MAC_MAX_CONTEXT_SIZE_PAGE0 + ii));
+    }
+    MACvSelectPage0(dwIoBase);
+
+    // restore RCR,TCR,IMR...
+    for (ii = MAC_REG_RCR; ii < MAC_REG_ISR; ii++) {
+        VNSvOutPortB(dwIoBase + ii, *(pbyCxtBuf + ii));
+    }
+    // restore MAC Config.
+    for (ii = MAC_REG_LRT; ii < MAC_REG_PAGE1SEL; ii++) {
+        VNSvOutPortB(dwIoBase + ii, *(pbyCxtBuf + ii));
+    }
+    VNSvOutPortB(dwIoBase + MAC_REG_CFG, *(pbyCxtBuf + MAC_REG_CFG));
+
+    // restore PS Config.
+    for (ii = MAC_REG_PSCFG; ii < MAC_REG_BBREGCTL; ii++) {
+        VNSvOutPortB(dwIoBase + ii, *(pbyCxtBuf + ii));
+    }
+
+    // restore CURR_RX_DESC_ADDR, CURR_TX_DESC_ADDR
+    VNSvOutPortD(dwIoBase + MAC_REG_TXDMAPTR0, *(PDWORD)(pbyCxtBuf + MAC_REG_TXDMAPTR0));
+    VNSvOutPortD(dwIoBase + MAC_REG_AC0DMAPTR, *(PDWORD)(pbyCxtBuf + MAC_REG_AC0DMAPTR));
+    VNSvOutPortD(dwIoBase + MAC_REG_BCNDMAPTR, *(PDWORD)(pbyCxtBuf + MAC_REG_BCNDMAPTR));
+
+
+    VNSvOutPortD(dwIoBase + MAC_REG_RXDMAPTR0, *(PDWORD)(pbyCxtBuf + MAC_REG_RXDMAPTR0));
+
+    VNSvOutPortD(dwIoBase + MAC_REG_RXDMAPTR1, *(PDWORD)(pbyCxtBuf + MAC_REG_RXDMAPTR1));
+
+}
+
+/*
+ * Description:
+ *      Compare if MAC registers same as context buffer
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *      pbyCxtBuf   - Context buffer
+ *  Out:
+ *      none
+ *
+ * Return Value: TRUE if all values are the same; otherwise FALSE
+ *
+ */
+BOOL MACbCompareContext (DWORD_PTR dwIoBase, PBYTE pbyCxtBuf)
+{
+    DWORD       dwData;
+
+    // compare MAC context to determine if this is a power lost init,
+    // return TRUE for power remaining init, return FALSE for power lost init
+
+    // compare CURR_RX_DESC_ADDR, CURR_TX_DESC_ADDR
+    VNSvInPortD(dwIoBase + MAC_REG_TXDMAPTR0, &dwData);
+    if (dwData != *(PDWORD)(pbyCxtBuf + MAC_REG_TXDMAPTR0)) {
+        return FALSE;
+    }
+
+    VNSvInPortD(dwIoBase + MAC_REG_AC0DMAPTR, &dwData);
+    if (dwData != *(PDWORD)(pbyCxtBuf + MAC_REG_AC0DMAPTR)) {
+        return FALSE;
+    }
+
+    VNSvInPortD(dwIoBase + MAC_REG_RXDMAPTR0, &dwData);
+    if (dwData != *(PDWORD)(pbyCxtBuf + MAC_REG_RXDMAPTR0)) {
+        return FALSE;
+    }
+
+    VNSvInPortD(dwIoBase + MAC_REG_RXDMAPTR1, &dwData);
+    if (dwData != *(PDWORD)(pbyCxtBuf + MAC_REG_RXDMAPTR1)) {
+        return FALSE;
+    }
+
+
+    return TRUE;
+}
+
+/*
+ * Description:
+ *      Software Reset MAC
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *  Out:
+ *      none
+ *
+ * Return Value: TRUE if Reset Success; otherwise FALSE
+ *
+ */
+BOOL MACbSoftwareReset (DWORD_PTR dwIoBase)
+{
+    BYTE    byData;
+    WORD    ww;
+
+    // turn on HOSTCR_SOFTRST, just write 0x01 to reset
+    //MACvRegBitsOn(dwIoBase, MAC_REG_HOSTCR, HOSTCR_SOFTRST);
+    VNSvOutPortB(dwIoBase+ MAC_REG_HOSTCR, 0x01);
+
+    for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
+        VNSvInPortB(dwIoBase + MAC_REG_HOSTCR, &byData);
+        if (BITbIsBitOff(byData, HOSTCR_SOFTRST))
+            break;
+    }
+    if (ww == W_MAX_TIMEOUT)
+        return FALSE;
+    return TRUE;
+
+}
+
+/*
+ * Description:
+ *      save some important register's value, then do reset, then restore register's value
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *  Out:
+ *      none
+ *
+ * Return Value: TRUE if success; otherwise FALSE
+ *
+ */
+BOOL MACbSafeSoftwareReset (DWORD_PTR dwIoBase)
+{
+    BYTE    abyTmpRegData[MAC_MAX_CONTEXT_SIZE_PAGE0+MAC_MAX_CONTEXT_SIZE_PAGE1];
+    BOOL    bRetVal;
+
+    // PATCH....
+    // save some important register's value, then do
+    // reset, then restore register's value
+
+    // save MAC context
+    MACvSaveContext(dwIoBase, abyTmpRegData);
+    // do reset
+    bRetVal = MACbSoftwareReset(dwIoBase);
+    //BBvSoftwareReset(pDevice->PortOffset);
+    // restore MAC context, except CR0
+    MACvRestoreContext(dwIoBase, abyTmpRegData);
+
+    return bRetVal;
+}
+
+/*
+ * Description:
+ *      Trun Off MAC Rx
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *  Out:
+ *      none
+ *
+ * Return Value: TRUE if success; otherwise FALSE
+ *
+ */
+BOOL MACbSafeRxOff (DWORD_PTR dwIoBase)
+{
+    WORD    ww;
+    DWORD   dwData;
+    BYTE    byData;
+
+    // turn off wow temp for turn off Rx safely
+
+    // Clear RX DMA0,1
+    VNSvOutPortD(dwIoBase + MAC_REG_RXDMACTL0, DMACTL_CLRRUN);
+    VNSvOutPortD(dwIoBase + MAC_REG_RXDMACTL1, DMACTL_CLRRUN);
+    for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
+        VNSvInPortD(dwIoBase + MAC_REG_RXDMACTL0, &dwData);
+        if (BITbIsAllBitsOff(dwData, DMACTL_RUN))
+            break;
+    }
+    if (ww == W_MAX_TIMEOUT) {
+        DBG_PORT80(0x10);
+        DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" DBG_PORT80(0x10)\n");
+        return(FALSE);
+    }
+    for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
+        VNSvInPortD(dwIoBase + MAC_REG_RXDMACTL1, &dwData);
+        if (BITbIsAllBitsOff(dwData, DMACTL_RUN))
+            break;
+    }
+    if (ww == W_MAX_TIMEOUT) {
+        DBG_PORT80(0x11);
+        DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" DBG_PORT80(0x11)\n");
+        return(FALSE);
+    }
+
+    // try to safe shutdown RX
+    MACvRegBitsOff(dwIoBase, MAC_REG_HOSTCR, HOSTCR_RXON);
+    // W_MAX_TIMEOUT is the timeout period
+    for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
+        VNSvInPortB(dwIoBase + MAC_REG_HOSTCR, &byData);
+        if (BITbIsAllBitsOff(byData, HOSTCR_RXONST))
+            break;
+    }
+    if (ww == W_MAX_TIMEOUT) {
+        DBG_PORT80(0x12);
+        DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" DBG_PORT80(0x12)\n");
+        return(FALSE);
+    }
+    return TRUE;
+}
+
+/*
+ * Description:
+ *      Trun Off MAC Tx
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *  Out:
+ *      none
+ *
+ * Return Value: TRUE if success; otherwise FALSE
+ *
+ */
+BOOL MACbSafeTxOff (DWORD_PTR dwIoBase)
+{
+    WORD    ww;
+    DWORD   dwData;
+    BYTE    byData;
+
+    // Clear TX DMA
+    //Tx0
+    VNSvOutPortD(dwIoBase + MAC_REG_TXDMACTL0, DMACTL_CLRRUN);
+    //AC0
+    VNSvOutPortD(dwIoBase + MAC_REG_AC0DMACTL, DMACTL_CLRRUN);
+
+
+    for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
+        VNSvInPortD(dwIoBase + MAC_REG_TXDMACTL0, &dwData);
+        if (BITbIsAllBitsOff(dwData, DMACTL_RUN))
+            break;
+    }
+    if (ww == W_MAX_TIMEOUT) {
+        DBG_PORT80(0x20);
+        DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" DBG_PORT80(0x20)\n");
+        return(FALSE);
+    }
+    for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
+        VNSvInPortD(dwIoBase + MAC_REG_AC0DMACTL, &dwData);
+        if (BITbIsAllBitsOff(dwData, DMACTL_RUN))
+            break;
+    }
+    if (ww == W_MAX_TIMEOUT) {
+        DBG_PORT80(0x21);
+        DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" DBG_PORT80(0x21)\n");
+        return(FALSE);
+    }
+
+    // try to safe shutdown TX
+    MACvRegBitsOff(dwIoBase, MAC_REG_HOSTCR, HOSTCR_TXON);
+
+    // W_MAX_TIMEOUT is the timeout period
+    for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
+        VNSvInPortB(dwIoBase + MAC_REG_HOSTCR, &byData);
+        if (BITbIsAllBitsOff(byData, HOSTCR_TXONST))
+            break;
+    }
+    if (ww == W_MAX_TIMEOUT) {
+        DBG_PORT80(0x24);
+        DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" DBG_PORT80(0x24)\n");
+        return(FALSE);
+    }
+    return TRUE;
+}
+
+/*
+ * Description:
+ *      Stop MAC function
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *  Out:
+ *      none
+ *
+ * Return Value: TRUE if success; otherwise FALSE
+ *
+ */
+BOOL MACbSafeStop (DWORD_PTR dwIoBase)
+{
+    MACvRegBitsOff(dwIoBase, MAC_REG_TCR, TCR_AUTOBCNTX);
+
+    if (MACbSafeRxOff(dwIoBase) == FALSE) {
+        DBG_PORT80(0xA1);
+        DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" MACbSafeRxOff == FALSE)\n");
+        MACbSafeSoftwareReset(dwIoBase);
+        return FALSE;
+    }
+    if (MACbSafeTxOff(dwIoBase) == FALSE) {
+        DBG_PORT80(0xA2);
+        DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" MACbSafeTxOff == FALSE)\n");
+        MACbSafeSoftwareReset(dwIoBase);
+        return FALSE;
+    }
+
+    MACvRegBitsOff(dwIoBase, MAC_REG_HOSTCR, HOSTCR_MACEN);
+
+    return TRUE;
+}
+
+/*
+ * Description:
+ *      Shut Down MAC
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *  Out:
+ *      none
+ *
+ * Return Value: TRUE if success; otherwise FALSE
+ *
+ */
+BOOL MACbShutdown (DWORD_PTR dwIoBase)
+{
+    // disable MAC IMR
+    MACvIntDisable(dwIoBase);
+    MACvSetLoopbackMode(dwIoBase, MAC_LB_INTERNAL);
+    // stop the adapter
+    if (!MACbSafeStop(dwIoBase)) {
+        MACvSetLoopbackMode(dwIoBase, MAC_LB_NONE);
+        return FALSE;
+    }
+    MACvSetLoopbackMode(dwIoBase, MAC_LB_NONE);
+    return TRUE;
+}
+
+/*
+ * Description:
+ *      Initialize MAC
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+void MACvInitialize (DWORD_PTR dwIoBase)
+{
+    // clear sticky bits
+    MACvClearStckDS(dwIoBase);
+    // disable force PME-enable
+    VNSvOutPortB(dwIoBase + MAC_REG_PMC1, PME_OVR);
+    // only 3253 A
+    /*
+    MACvPwrEvntDisable(dwIoBase);
+    // clear power status
+    VNSvOutPortW(dwIoBase + MAC_REG_WAKEUPSR0, 0x0F0F);
+    */
+
+    // do reset
+    MACbSoftwareReset(dwIoBase);
+
+    // issue AUTOLD in EECSR to reload eeprom
+    //MACvRegBitsOn(dwIoBase, MAC_REG_I2MCSR, I2MCSR_AUTOLD);
+    // wait until EEPROM loading complete
+    //while (TRUE) {
+    //    U8 u8Data;
+    //    VNSvInPortB(dwIoBase + MAC_REG_I2MCSR, &u8Data);
+    //    if (BITbIsBitOff(u8Data, I2MCSR_AUTOLD))
+    //        break;
+    //}
+
+    // reset TSF counter
+    VNSvOutPortB(dwIoBase + MAC_REG_TFTCTL, TFTCTL_TSFCNTRST);
+    // enable TSF counter
+    VNSvOutPortB(dwIoBase + MAC_REG_TFTCTL, TFTCTL_TSFCNTREN);
+
+
+    // set packet filter
+    // receive directed and broadcast address
+
+    MACvSetPacketFilter(dwIoBase, PKT_TYPE_DIRECTED | PKT_TYPE_BROADCAST);
+
+}
+
+/*
+ * Description:
+ *      Set the chip with current rx descriptor address
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase        - Base Address for MAC
+ *      dwCurrDescAddr  - Descriptor Address
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+void MACvSetCurrRx0DescAddr (DWORD_PTR dwIoBase, DWORD dwCurrDescAddr)
+{
+WORD    ww;
+BYTE    byData;
+BYTE    byOrgDMACtl;
+
+    VNSvInPortB(dwIoBase + MAC_REG_RXDMACTL0, &byOrgDMACtl);
+    if (BITbIsAllBitsOn(byOrgDMACtl, DMACTL_RUN)) {
+        VNSvOutPortB(dwIoBase + MAC_REG_RXDMACTL0+2, DMACTL_RUN);
+    }
+    for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
+        VNSvInPortB(dwIoBase + MAC_REG_RXDMACTL0, &byData);
+        if (BITbIsAllBitsOff(byData, DMACTL_RUN))
+            break;
+    }
+    if (ww == W_MAX_TIMEOUT) {
+        DBG_PORT80(0x13);
+    }
+    VNSvOutPortD(dwIoBase + MAC_REG_RXDMAPTR0, dwCurrDescAddr);
+    if (BITbIsAllBitsOn(byOrgDMACtl, DMACTL_RUN)) {
+        VNSvOutPortB(dwIoBase + MAC_REG_RXDMACTL0, DMACTL_RUN);
+    }
+}
+
+/*
+ * Description:
+ *      Set the chip with current rx descriptor address
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase        - Base Address for MAC
+ *      dwCurrDescAddr  - Descriptor Address
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+void MACvSetCurrRx1DescAddr (DWORD_PTR dwIoBase, DWORD dwCurrDescAddr)
+{
+WORD    ww;
+BYTE    byData;
+BYTE    byOrgDMACtl;
+
+    VNSvInPortB(dwIoBase + MAC_REG_RXDMACTL1, &byOrgDMACtl);
+    if (BITbIsAllBitsOn(byOrgDMACtl, DMACTL_RUN)) {
+        VNSvOutPortB(dwIoBase + MAC_REG_RXDMACTL1+2, DMACTL_RUN);
+    }
+    for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
+        VNSvInPortB(dwIoBase + MAC_REG_RXDMACTL1, &byData);
+        if (BITbIsAllBitsOff(byData, DMACTL_RUN))
+            break;
+    }
+    if (ww == W_MAX_TIMEOUT) {
+        DBG_PORT80(0x14);
+    }
+    VNSvOutPortD(dwIoBase + MAC_REG_RXDMAPTR1, dwCurrDescAddr);
+    if (BITbIsAllBitsOn(byOrgDMACtl, DMACTL_RUN)) {
+        VNSvOutPortB(dwIoBase + MAC_REG_RXDMACTL1, DMACTL_RUN);
+    }
+}
+
+/*
+ * Description:
+ *      Set the chip with current tx0 descriptor address
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase        - Base Address for MAC
+ *      dwCurrDescAddr  - Descriptor Address
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+void MACvSetCurrTx0DescAddrEx (DWORD_PTR dwIoBase, DWORD dwCurrDescAddr)
+{
+WORD    ww;
+BYTE    byData;
+BYTE    byOrgDMACtl;
+
+    VNSvInPortB(dwIoBase + MAC_REG_TXDMACTL0, &byOrgDMACtl);
+    if (BITbIsAllBitsOn(byOrgDMACtl, DMACTL_RUN)) {
+        VNSvOutPortB(dwIoBase + MAC_REG_TXDMACTL0+2, DMACTL_RUN);
+    }
+    for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
+        VNSvInPortB(dwIoBase + MAC_REG_TXDMACTL0, &byData);
+        if (BITbIsAllBitsOff(byData, DMACTL_RUN))
+            break;
+    }
+    if (ww == W_MAX_TIMEOUT) {
+        DBG_PORT80(0x25);
+    }
+    VNSvOutPortD(dwIoBase + MAC_REG_TXDMAPTR0, dwCurrDescAddr);
+    if (BITbIsAllBitsOn(byOrgDMACtl, DMACTL_RUN)) {
+        VNSvOutPortB(dwIoBase + MAC_REG_TXDMACTL0, DMACTL_RUN);
+    }
+}
+
+/*
+ * Description:
+ *      Set the chip with current AC0 descriptor address
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase        - Base Address for MAC
+ *      dwCurrDescAddr  - Descriptor Address
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+ //TxDMA1 = AC0DMA
+void MACvSetCurrAC0DescAddrEx (DWORD_PTR dwIoBase, DWORD dwCurrDescAddr)
+{
+WORD    ww;
+BYTE    byData;
+BYTE    byOrgDMACtl;
+
+    VNSvInPortB(dwIoBase + MAC_REG_AC0DMACTL, &byOrgDMACtl);
+    if (BITbIsAllBitsOn(byOrgDMACtl, DMACTL_RUN)) {
+        VNSvOutPortB(dwIoBase + MAC_REG_AC0DMACTL+2, DMACTL_RUN);
+    }
+    for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
+        VNSvInPortB(dwIoBase + MAC_REG_AC0DMACTL, &byData);
+        if (BITbIsAllBitsOff(byData, DMACTL_RUN))
+            break;
+    }
+    if (ww == W_MAX_TIMEOUT) {
+        DBG_PORT80(0x26);
+        DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" DBG_PORT80(0x26)\n");
+    }
+    VNSvOutPortD(dwIoBase + MAC_REG_AC0DMAPTR, dwCurrDescAddr);
+    if (BITbIsAllBitsOn(byOrgDMACtl, DMACTL_RUN)) {
+        VNSvOutPortB(dwIoBase + MAC_REG_AC0DMACTL, DMACTL_RUN);
+    }
+}
+
+
+
+void MACvSetCurrTXDescAddr (int iTxType, DWORD_PTR dwIoBase, DWORD dwCurrDescAddr)
+{
+    if(iTxType == TYPE_AC0DMA){
+        MACvSetCurrAC0DescAddrEx(dwIoBase, dwCurrDescAddr);
+    }else if(iTxType == TYPE_TXDMA0){
+        MACvSetCurrTx0DescAddrEx(dwIoBase, dwCurrDescAddr);
+    }
+}
+
+/*
+ * Description:
+ *      Micro Second Delay via MAC
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *      uDelay      - Delay time (timer resolution is 4 us)
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+VOID MACvTimer0MicroSDelay (DWORD_PTR dwIoBase, UINT uDelay)
+{
+BYTE byValue;
+UINT uu,ii;
+
+    VNSvOutPortB(dwIoBase + MAC_REG_TMCTL0, 0);
+    VNSvOutPortD(dwIoBase + MAC_REG_TMDATA0, uDelay);
+    VNSvOutPortB(dwIoBase + MAC_REG_TMCTL0, (TMCTL_TMD | TMCTL_TE));
+    for(ii=0;ii<66;ii++) {  // assume max PCI clock is 66Mhz
+        for (uu = 0; uu < uDelay; uu++) {
+            VNSvInPortB(dwIoBase + MAC_REG_TMCTL0, &byValue);
+            if ((byValue == 0) ||
+                (BITbIsAllBitsOn(byValue, TMCTL_TSUSP))) {
+                VNSvOutPortB(dwIoBase + MAC_REG_TMCTL0, 0);
+                return;
+            }
+        }
+    }
+    VNSvOutPortB(dwIoBase + MAC_REG_TMCTL0, 0);
+
+}
+
+/*
+ * Description:
+ *      Micro Second One shot timer via MAC
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *      uDelay      - Delay time
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+void MACvOneShotTimer0MicroSec (DWORD_PTR dwIoBase, UINT uDelayTime)
+{
+    VNSvOutPortB(dwIoBase + MAC_REG_TMCTL0, 0);
+    VNSvOutPortD(dwIoBase + MAC_REG_TMDATA0, uDelayTime);
+    VNSvOutPortB(dwIoBase + MAC_REG_TMCTL0, (TMCTL_TMD | TMCTL_TE));
+}
+
+/*
+ * Description:
+ *      Micro Second One shot timer via MAC
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase    - Base Address for MAC
+ *      uDelay      - Delay time
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+void MACvOneShotTimer1MicroSec (DWORD_PTR dwIoBase, UINT uDelayTime)
+{
+    VNSvOutPortB(dwIoBase + MAC_REG_TMCTL1, 0);
+    VNSvOutPortD(dwIoBase + MAC_REG_TMDATA1, uDelayTime);
+    VNSvOutPortB(dwIoBase + MAC_REG_TMCTL1, (TMCTL_TMD | TMCTL_TE));
+}
+
+
+void MACvSetMISCFifo (DWORD_PTR dwIoBase, WORD wOffset, DWORD dwData)
+{
+    if (wOffset > 273)
+        return;
+    VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
+    VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
+    VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
+}
+
+
+BOOL MACbTxDMAOff (DWORD_PTR dwIoBase, UINT idx)
+{
+BYTE byData;
+UINT ww = 0;
+
+    if (idx == TYPE_TXDMA0) {
+        VNSvOutPortB(dwIoBase + MAC_REG_TXDMACTL0+2, DMACTL_RUN);
+        for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
+            VNSvInPortB(dwIoBase + MAC_REG_TXDMACTL0, &byData);
+            if (BITbIsAllBitsOff(byData, DMACTL_RUN))
+                break;
+        }
+    } else if (idx == TYPE_AC0DMA) {
+        VNSvOutPortB(dwIoBase + MAC_REG_AC0DMACTL+2, DMACTL_RUN);
+        for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
+            VNSvInPortB(dwIoBase + MAC_REG_AC0DMACTL, &byData);
+            if (BITbIsAllBitsOff(byData, DMACTL_RUN))
+                break;
+        }
+    }
+    if (ww == W_MAX_TIMEOUT) {
+        DBG_PORT80(0x29);
+        DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" DBG_PORT80(0x29)\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+void MACvClearBusSusInd (DWORD_PTR dwIoBase)
+{
+    DWORD dwOrgValue;
+    UINT ww;
+    // check if BcnSusInd enabled
+    VNSvInPortD(dwIoBase + MAC_REG_ENCFG , &dwOrgValue);
+    if(BITbIsBitOff(dwOrgValue, EnCFG_BcnSusInd))
+        return;
+    //Set BcnSusClr
+    dwOrgValue = dwOrgValue | EnCFG_BcnSusClr;
+    VNSvOutPortD(dwIoBase + MAC_REG_ENCFG, dwOrgValue);
+    for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
+        VNSvInPortD(dwIoBase + MAC_REG_ENCFG , &dwOrgValue);
+        if(BITbIsBitOff(dwOrgValue, EnCFG_BcnSusInd))
+            break;
+    }
+    if (ww == W_MAX_TIMEOUT) {
+        DBG_PORT80(0x33);
+        DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" DBG_PORT80(0x33)\n");
+    }
+}
+
+void MACvEnableBusSusEn (DWORD_PTR dwIoBase)
+{
+    BYTE  byOrgValue;
+    DWORD dwOrgValue;
+    UINT ww;
+    // check if BcnSusInd enabled
+    VNSvInPortB(dwIoBase + MAC_REG_CFG , &byOrgValue);
+
+    //Set BcnSusEn
+    byOrgValue = byOrgValue | CFG_BCNSUSEN;
+    VNSvOutPortB(dwIoBase + MAC_REG_ENCFG, byOrgValue);
+    for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
+        VNSvInPortD(dwIoBase + MAC_REG_ENCFG , &dwOrgValue);
+        if(BITbIsBitOn(dwOrgValue, EnCFG_BcnSusInd))
+            break;
+    }
+    if (ww == W_MAX_TIMEOUT) {
+        DBG_PORT80(0x34);
+        DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" DBG_PORT80(0x34)\n");
+    }
+}
+
+BOOL MACbFlushSYNCFifo (DWORD_PTR dwIoBase)
+{
+    BYTE  byOrgValue;
+    UINT ww;
+    // Read MACCR
+    VNSvInPortB(dwIoBase + MAC_REG_MACCR , &byOrgValue);
+
+    // Set SYNCFLUSH
+    byOrgValue = byOrgValue | MACCR_SYNCFLUSH;
+    VNSvOutPortB(dwIoBase + MAC_REG_MACCR, byOrgValue);
+
+    // Check if SyncFlushOK
+    for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
+        VNSvInPortB(dwIoBase + MAC_REG_MACCR , &byOrgValue);
+        if(BITbIsBitOn(byOrgValue, MACCR_SYNCFLUSHOK))
+            break;
+    }
+    if (ww == W_MAX_TIMEOUT) {
+        DBG_PORT80(0x35);
+        DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" DBG_PORT80(0x33)\n");
+    }
+    return TRUE;
+}
+
+BOOL MACbPSWakeup (DWORD_PTR dwIoBase)
+{
+    BYTE  byOrgValue;
+    UINT ww;
+    // Read PSCTL
+    if (MACbIsRegBitsOff(dwIoBase, MAC_REG_PSCTL, PSCTL_PS)) {
+        return TRUE;
+    }
+    // Disable PS
+    MACvRegBitsOff(dwIoBase, MAC_REG_PSCTL, PSCTL_PSEN);
+
+    // Check if SyncFlushOK
+    for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
+        VNSvInPortB(dwIoBase + MAC_REG_PSCTL , &byOrgValue);
+        if(BITbIsBitOn(byOrgValue, PSCTL_WAKEDONE))
+            break;
+    }
+    if (ww == W_MAX_TIMEOUT) {
+        DBG_PORT80(0x36);
+        DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" DBG_PORT80(0x33)\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+/*
+ * Description:
+ *      Set the Key by MISCFIFO
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase        - Base Address for MAC
+ *
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+
+void MACvSetKeyEntry (DWORD_PTR dwIoBase, WORD wKeyCtl, UINT uEntryIdx, UINT uKeyIdx, PBYTE pbyAddr, PDWORD pdwKey, BYTE byLocalID)
+{
+WORD    wOffset;
+DWORD   dwData;
+int     ii;
+
+    if (byLocalID <= 1)
+        return;
+
+
+    DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MACvSetKeyEntry\n");
+    wOffset = MISCFIFO_KEYETRY0;
+    wOffset += (uEntryIdx * MISCFIFO_KEYENTRYSIZE);
+
+    dwData = 0;
+    dwData |= wKeyCtl;
+    dwData <<= 16;
+    dwData |= MAKEWORD(*(pbyAddr+4), *(pbyAddr+5));
+    DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"1. wOffset: %d, Data: %lX, KeyCtl:%X\n", wOffset, dwData, wKeyCtl);
+
+    VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
+    VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
+    VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
+    wOffset++;
+
+    dwData = 0;
+    dwData |= *(pbyAddr+3);
+    dwData <<= 8;
+    dwData |= *(pbyAddr+2);
+    dwData <<= 8;
+    dwData |= *(pbyAddr+1);
+    dwData <<= 8;
+    dwData |= *(pbyAddr+0);
+    DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"2. wOffset: %d, Data: %lX\n", wOffset, dwData);
+
+    VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
+    VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
+    VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
+    wOffset++;
+
+    wOffset += (uKeyIdx * 4);
+    for (ii=0;ii<4;ii++) {
+        // alway push 128 bits
+        DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"3.(%d) wOffset: %d, Data: %lX\n", ii, wOffset+ii, *pdwKey);
+        VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset+ii);
+        VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, *pdwKey++);
+        VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
+    }
+}
+
+
+
+/*
+ * Description:
+ *      Disable the Key Entry by MISCFIFO
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase        - Base Address for MAC
+ *
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+void MACvDisableKeyEntry (DWORD_PTR dwIoBase, UINT uEntryIdx)
+{
+WORD    wOffset;
+
+    wOffset = MISCFIFO_KEYETRY0;
+    wOffset += (uEntryIdx * MISCFIFO_KEYENTRYSIZE);
+
+    VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
+    VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, 0);
+    VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
+}
+
+
+/*
+ * Description:
+ *      Set the default Key (KeyEntry[10]) by MISCFIFO
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase        - Base Address for MAC
+ *
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+
+void MACvSetDefaultKeyEntry (DWORD_PTR dwIoBase, UINT uKeyLen, UINT uKeyIdx, PDWORD pdwKey, BYTE byLocalID)
+{
+WORD    wOffset;
+DWORD   dwData;
+int     ii;
+
+    if (byLocalID <= 1)
+        return;
+
+    DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MACvSetDefaultKeyEntry\n");
+    wOffset = MISCFIFO_KEYETRY0;
+    wOffset += (10 * MISCFIFO_KEYENTRYSIZE);
+
+    wOffset++;
+    wOffset++;
+    wOffset += (uKeyIdx * 4);
+    // alway push 128 bits
+    for (ii=0; ii<3; ii++) {
+        DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"(%d) wOffset: %d, Data: %lX\n", ii, wOffset+ii, *pdwKey);
+        VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset+ii);
+        VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, *pdwKey++);
+        VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
+    }
+    dwData = *pdwKey;
+    if (uKeyLen == WLAN_WEP104_KEYLEN) {
+        dwData |= 0x80000000;
+    }
+    VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset+3);
+    VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
+    VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
+    DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"End. wOffset: %d, Data: %lX\n", wOffset+3, dwData);
+
+}
+
+
+/*
+ * Description:
+ *      Enable default Key (KeyEntry[10]) by MISCFIFO
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase        - Base Address for MAC
+ *
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+/*
+void MACvEnableDefaultKey (DWORD_PTR dwIoBase, BYTE byLocalID)
+{
+WORD    wOffset;
+DWORD   dwData;
+
+
+    if (byLocalID <= 1)
+        return;
+
+    wOffset = MISCFIFO_KEYETRY0;
+    wOffset += (10 * MISCFIFO_KEYENTRYSIZE);
+
+    dwData = 0xC0440000;
+    VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
+    VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
+    VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
+    DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MACvEnableDefaultKey: wOffset: %d, Data: %lX\n", wOffset, dwData);
+
+}
+*/
+
+/*
+ * Description:
+ *      Disable default Key (KeyEntry[10]) by MISCFIFO
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase        - Base Address for MAC
+ *
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+void MACvDisableDefaultKey (DWORD_PTR dwIoBase)
+{
+WORD    wOffset;
+DWORD   dwData;
+
+
+    wOffset = MISCFIFO_KEYETRY0;
+    wOffset += (10 * MISCFIFO_KEYENTRYSIZE);
+
+    dwData = 0x0;
+    VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
+    VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
+    VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
+    DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MACvDisableDefaultKey: wOffset: %d, Data: %lX\n", wOffset, dwData);
+}
+
+/*
+ * Description:
+ *      Set the default TKIP Group Key (KeyEntry[10]) by MISCFIFO
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase        - Base Address for MAC
+ *
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+void MACvSetDefaultTKIPKeyEntry (DWORD_PTR dwIoBase, UINT uKeyLen, UINT uKeyIdx, PDWORD pdwKey, BYTE byLocalID)
+{
+WORD    wOffset;
+DWORD   dwData;
+int     ii;
+
+    if (byLocalID <= 1)
+        return;
+
+
+    DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MACvSetDefaultTKIPKeyEntry\n");
+    wOffset = MISCFIFO_KEYETRY0;
+    // Kyle test : change offset from 10 -> 0
+    wOffset += (10 * MISCFIFO_KEYENTRYSIZE);
+
+    dwData = 0xC0660000;
+    VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
+    VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
+    VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
+    wOffset++;
+
+    dwData = 0;
+    VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
+    VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
+    VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
+    wOffset++;
+
+    wOffset += (uKeyIdx * 4);
+    DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"1. wOffset: %d, Data: %lX, idx:%d\n", wOffset, *pdwKey, uKeyIdx);
+    // alway push 128 bits
+    for (ii=0; ii<4; ii++) {
+        DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"2.(%d) wOffset: %d, Data: %lX\n", ii, wOffset+ii, *pdwKey);
+        VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset+ii);
+        VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, *pdwKey++);
+        VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
+    }
+
+}
+
+
+
+/*
+ * Description:
+ *      Set the Key Control by MISCFIFO
+ *
+ * Parameters:
+ *  In:
+ *      dwIoBase        - Base Address for MAC
+ *
+ *  Out:
+ *      none
+ *
+ * Return Value: none
+ *
+ */
+
+void MACvSetDefaultKeyCtl (DWORD_PTR dwIoBase, WORD wKeyCtl, UINT uEntryIdx, BYTE byLocalID)
+{
+WORD    wOffset;
+DWORD   dwData;
+
+    if (byLocalID <= 1)
+        return;
+
+
+    DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MACvSetKeyEntry\n");
+    wOffset = MISCFIFO_KEYETRY0;
+    wOffset += (uEntryIdx * MISCFIFO_KEYENTRYSIZE);
+
+    dwData = 0;
+    dwData |= wKeyCtl;
+    dwData <<= 16;
+    dwData |= 0xffff;
+    DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"1. wOffset: %d, Data: %lX, KeyCtl:%X\n", wOffset, dwData, wKeyCtl);
+
+    VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
+    VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
+    VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
+
+}
+