mac.h

VIA VT6655 x86下的Linux Source Code

    VNSvInPortB(dwIoBase + MAC_REG_BSSID0 + 3,              \
                pbyEtherAddr + 3);                          \
    VNSvInPortB(dwIoBase + MAC_REG_BSSID0 + 4,              \
                pbyEtherAddr + 4);                          \
    VNSvInPortB(dwIoBase + MAC_REG_BSSID0 + 5,              \
                pbyEtherAddr + 5);                          \
    VNSvOutPortB(dwIoBase + MAC_REG_PAGE1SEL, 0);           \
}

#define MACvWriteBSSIDAddress(dwIoBase, pbyEtherAddr)       \
{                                                           \
    VNSvOutPortB(dwIoBase + MAC_REG_PAGE1SEL, 1);           \
    VNSvOutPortB(dwIoBase + MAC_REG_BSSID0,                 \
                *(pbyEtherAddr));                           \
    VNSvOutPortB(dwIoBase + MAC_REG_BSSID0 + 1,             \
                *(pbyEtherAddr + 1));                       \
    VNSvOutPortB(dwIoBase + MAC_REG_BSSID0 + 2,             \
                *(pbyEtherAddr + 2));                       \
    VNSvOutPortB(dwIoBase + MAC_REG_BSSID0 + 3,             \
                *(pbyEtherAddr + 3));                       \
    VNSvOutPortB(dwIoBase + MAC_REG_BSSID0 + 4,             \
                *(pbyEtherAddr + 4));                       \
    VNSvOutPortB(dwIoBase + MAC_REG_BSSID0 + 5,             \
                *(pbyEtherAddr + 5));                       \
    VNSvOutPortB(dwIoBase + MAC_REG_PAGE1SEL, 0);           \
}                                                            

#define MACvReadEtherAddress(dwIoBase, pbyEtherAddr)        \
{                                                           \
    VNSvOutPortB(dwIoBase + MAC_REG_PAGE1SEL, 1);           \
    VNSvInPortB(dwIoBase + MAC_REG_PAR0,                    \
                (PBYTE)pbyEtherAddr);                       \
    VNSvInPortB(dwIoBase + MAC_REG_PAR0 + 1,                \
                pbyEtherAddr + 1);                          \
    VNSvInPortB(dwIoBase + MAC_REG_PAR0 + 2,                \
                pbyEtherAddr + 2);                          \
    VNSvInPortB(dwIoBase + MAC_REG_PAR0 + 3,                \
                pbyEtherAddr + 3);                          \
    VNSvInPortB(dwIoBase + MAC_REG_PAR0 + 4,                \
                pbyEtherAddr + 4);                          \
    VNSvInPortB(dwIoBase + MAC_REG_PAR0 + 5,                \
                pbyEtherAddr + 5);                          \
    VNSvOutPortB(dwIoBase + MAC_REG_PAGE1SEL, 0);           \
}


#define MACvWriteEtherAddress(dwIoBase, pbyEtherAddr)       \
{                                                           \
    VNSvOutPortB(dwIoBase + MAC_REG_PAGE1SEL, 1);           \
    VNSvOutPortB(dwIoBase + MAC_REG_PAR0,                   \
                *pbyEtherAddr);                             \
    VNSvOutPortB(dwIoBase + MAC_REG_PAR0 + 1,               \
                *(pbyEtherAddr + 1));                       \
    VNSvOutPortB(dwIoBase + MAC_REG_PAR0 + 2,               \
                *(pbyEtherAddr + 2));                       \
    VNSvOutPortB(dwIoBase + MAC_REG_PAR0 + 3,               \
                *(pbyEtherAddr + 3));                       \
    VNSvOutPortB(dwIoBase + MAC_REG_PAR0 + 4,               \
                *(pbyEtherAddr + 4));                       \
    VNSvOutPortB(dwIoBase + MAC_REG_PAR0 + 5,               \
                *(pbyEtherAddr + 5));                       \
    VNSvOutPortB(dwIoBase + MAC_REG_PAGE1SEL, 0);           \
}


#define MACvClearISR(dwIoBase)                              \
{                                                           \
    VNSvOutPortD(dwIoBase + MAC_REG_ISR, IMR_MASK_VALUE);   \
}

#define MACvStart(dwIoBase)                                      \
{                                                                \
    VNSvOutPortB(dwIoBase + MAC_REG_HOSTCR,                      \
                    (HOSTCR_MACEN | HOSTCR_RXON | HOSTCR_TXON)); \
}

#define MACvRx0PerPktMode(dwIoBase)                         \
{                                                           \
    VNSvOutPortD(dwIoBase + MAC_REG_RXDMACTL0, RX_PERPKT);  \
}

#define MACvRx0BufferFillMode(dwIoBase)                         \
{                                                               \
    VNSvOutPortD(dwIoBase + MAC_REG_RXDMACTL0, RX_PERPKTCLR);   \
}

#define MACvRx1PerPktMode(dwIoBase)                         \
{                                                           \
    VNSvOutPortD(dwIoBase + MAC_REG_RXDMACTL1, RX_PERPKT);  \
}

#define MACvRx1BufferFillMode(dwIoBase)                         \
{                                                               \
    VNSvOutPortD(dwIoBase + MAC_REG_RXDMACTL1, RX_PERPKTCLR);   \
}

#define MACvRxOn(dwIoBase)                                      \
{                                                               \
    MACvRegBitsOn(dwIoBase, MAC_REG_HOSTCR, HOSTCR_RXON);       \
}

#define MACvReceive0(dwIoBase)                                  \
{                                                               \
    DWORD dwData;                                               \
    VNSvInPortD(dwIoBase + MAC_REG_RXDMACTL0, &dwData);         \
    if (dwData & DMACTL_RUN) {                                  \
        VNSvOutPortD(dwIoBase + MAC_REG_RXDMACTL0, DMACTL_WAKE);\
    }                                                           \
    else {                                                      \
        VNSvOutPortD(dwIoBase + MAC_REG_RXDMACTL0, DMACTL_RUN); \
    }                                                           \
}

#define MACvReceive1(dwIoBase)                                  \
{                                                               \
    DWORD dwData;                                                \
    VNSvInPortD(dwIoBase + MAC_REG_RXDMACTL1, &dwData);         \
    if (dwData & DMACTL_RUN) {                                  \
        VNSvOutPortD(dwIoBase + MAC_REG_RXDMACTL1, DMACTL_WAKE);\
    }                                                           \
    else {                                                      \
        VNSvOutPortD(dwIoBase + MAC_REG_RXDMACTL1, DMACTL_RUN); \
    }                                                           \
}

#define MACvTxOn(dwIoBase)                                      \
{                                                               \
    MACvRegBitsOn(dwIoBase, MAC_REG_HOSTCR, HOSTCR_TXON);       \
}

#define MACvTransmit0(dwIoBase)                                 \
{                                                               \
    DWORD dwData;                                                \
    VNSvInPortD(dwIoBase + MAC_REG_TXDMACTL0, &dwData);         \
    if (dwData & DMACTL_RUN) {                                  \
        VNSvOutPortD(dwIoBase + MAC_REG_TXDMACTL0, DMACTL_WAKE);\
    }                                                           \
    else {                                                      \
        VNSvOutPortD(dwIoBase + MAC_REG_TXDMACTL0, DMACTL_RUN); \
    }                                                           \
}

#define MACvTransmitAC0(dwIoBase)                               \
{                                                               \
    DWORD dwData;                                                \
    VNSvInPortD(dwIoBase + MAC_REG_AC0DMACTL, &dwData);         \
    if (dwData & DMACTL_RUN) {                                  \
        VNSvOutPortD(dwIoBase + MAC_REG_AC0DMACTL, DMACTL_WAKE);\
    }                                                           \
    else {                                                      \
        VNSvOutPortD(dwIoBase + MAC_REG_AC0DMACTL, DMACTL_RUN); \
    }                                                           \
}

#define MACvTransmitSYNC(dwIoBase)                               \
{                                                                \
    DWORD dwData;                                                 \
    VNSvInPortD(dwIoBase + MAC_REG_SYNCDMACTL, &dwData);         \
    if (dwData & DMACTL_RUN) {                                   \
        VNSvOutPortD(dwIoBase + MAC_REG_SYNCDMACTL, DMACTL_WAKE);\
    }                                                            \
    else {                                                       \
        VNSvOutPortD(dwIoBase + MAC_REG_SYNCDMACTL, DMACTL_RUN); \
    }                                                            \
}

#define MACvTransmitATIM(dwIoBase)                               \
{                                                                \
    DWORD dwData;                                                 \
    VNSvInPortD(dwIoBase + MAC_REG_ATIMDMACTL, &dwData);         \
    if (dwData & DMACTL_RUN) {                                   \
        VNSvOutPortD(dwIoBase + MAC_REG_ATIMDMACTL, DMACTL_WAKE);\
    }                                                            \
    else {                                                       \
        VNSvOutPortD(dwIoBase + MAC_REG_ATIMDMACTL, DMACTL_RUN); \
    }                                                            \
}

#define MACvTransmitBCN(dwIoBase)                               \
{                                                               \
    VNSvOutPortB(dwIoBase + MAC_REG_BCNDMACTL, BEACON_READY);   \
}

#define MACvClearStckDS(dwIoBase)                           \
{                                                           \
    BYTE byOrgValue;                                        \
    VNSvInPortB(dwIoBase + MAC_REG_STICKHW, &byOrgValue);   \
    byOrgValue = byOrgValue & 0xFC;                         \
    VNSvOutPortB(dwIoBase + MAC_REG_STICKHW, byOrgValue);   \
}

#define MACvReadISR(dwIoBase, pdwValue)             \
{                                                   \
    VNSvInPortD(dwIoBase + MAC_REG_ISR, pdwValue);  \
}

#define MACvWriteISR(dwIoBase, dwValue)             \
{                                                   \
    VNSvOutPortD(dwIoBase + MAC_REG_ISR, dwValue);  \
}

#define MACvIntEnable(dwIoBase, dwMask)             \
{                                                   \
    VNSvOutPortD(dwIoBase + MAC_REG_IMR, dwMask);   \
}

#define MACvIntDisable(dwIoBase)                    \
{                                                   \
    VNSvOutPortD(dwIoBase + MAC_REG_IMR, 0);        \
}

#define MACvSelectPage0(dwIoBase)                   \
{                                                   \
    VNSvOutPortB(dwIoBase + MAC_REG_PAGE1SEL, 0);   \
}
#define MACvSelectPage1(dwIoBase)                   \
{                                                   \
    VNSvOutPortB(dwIoBase + MAC_REG_PAGE1SEL, 1);   \
}

#define MACvReadMIBCounter(dwIoBase, pdwCounter)            \
{                                                           \
    VNSvInPortD(dwIoBase + MAC_REG_MIBCNTR , pdwCounter);   \
}

#define MACvPwrEvntDisable(dwIoBase)                    \
{                                                       \
    VNSvOutPortW(dwIoBase + MAC_REG_WAKEUPEN0, 0x0000); \
}

#define MACvEnableProtectMD(dwIoBase)                    \
{                                                        \
    DWORD dwOrgValue;                                    \
    VNSvInPortD(dwIoBase + MAC_REG_ENCFG , &dwOrgValue); \
    dwOrgValue = dwOrgValue | EnCFG_ProtectMd;           \
    VNSvOutPortD(dwIoBase + MAC_REG_ENCFG, dwOrgValue);  \
}

#define MACvDisableProtectMD(dwIoBase)                   \
{                                                        \
    DWORD dwOrgValue;                                     \
    VNSvInPortD(dwIoBase + MAC_REG_ENCFG , &dwOrgValue); \
    dwOrgValue = dwOrgValue & ~EnCFG_ProtectMd;          \
    VNSvOutPortD(dwIoBase + MAC_REG_ENCFG, dwOrgValue);  \
}

#define MACvEnableBarkerPreambleMd(dwIoBase)             \
{                                                        \
    DWORD dwOrgValue;                                    \
    VNSvInPortD(dwIoBase + MAC_REG_ENCFG , &dwOrgValue); \
    dwOrgValue = dwOrgValue | EnCFG_BarkerPream;         \
    VNSvOutPortD(dwIoBase + MAC_REG_ENCFG, dwOrgValue);  \
}

#define MACvDisableBarkerPreambleMd(dwIoBase)            \
{                                                        \
    DWORD dwOrgValue;                                    \
    VNSvInPortD(dwIoBase + MAC_REG_ENCFG , &dwOrgValue); \
    dwOrgValue = dwOrgValue & ~EnCFG_BarkerPream;        \
    VNSvOutPortD(dwIoBase + MAC_REG_ENCFG, dwOrgValue);  \
}

#define MACvSetBBType(dwIoBase, byTyp)                   \
{                                                        \
    DWORD dwOrgValue;                                    \
    VNSvInPortD(dwIoBase + MAC_REG_ENCFG , &dwOrgValue); \
    dwOrgValue = dwOrgValue & ~EnCFG_BBType_MASK;        \
    dwOrgValue = dwOrgValue | (DWORD) byTyp;             \
    VNSvOutPortD(dwIoBase + MAC_REG_ENCFG, dwOrgValue);  \
}

#define MACvReadATIMW(dwIoBase, pwCounter)                 \
{                                                          \
    VNSvInPortW(dwIoBase + MAC_REG_AIDATIM , pwCounter);   \
}

#define MACvWriteATIMW(dwIoBase, wCounter)                 \
{                                                          \
    VNSvOutPortW(dwIoBase + MAC_REG_AIDATIM , wCounter);   \
}

#define MACvWriteCRC16_128(dwIoBase, byRegOfs, wCRC)       \
{                                                          \
    VNSvOutPortB(dwIoBase + MAC_REG_PAGE1SEL, 1);          \
    VNSvOutPortW(dwIoBase + byRegOfs, wCRC);               \
    VNSvOutPortB(dwIoBase + MAC_REG_PAGE1SEL, 0);          \
}

#define MACvGPIOIn(dwIoBase, pbyValue)                      \
{                                                           \
    VNSvInPortB(dwIoBase + MAC_REG_GPIOCTL1, pbyValue);     \
}

#define MACvSetRFLE_LatchBase(dwIoBase)                                 \
{                                                                        \
    MACvWordRegBitsOn(dwIoBase, MAC_REG_SOFTPWRCTL, SOFTPWRCTL_RFLEOPT); \
}
                                                             
/*---------------------  Export Classes  ----------------------------*/

/*---------------------  Export Variables  --------------------------*/

/*---------------------  Export Functions  --------------------------*/
#ifdef __cplusplus
extern "C" {                            /* Assume C declarations for C++ */
#endif /* __cplusplus */


VOID MACvReadAllRegs(DWORD_PTR dwIoBase, PBYTE pbyMacRegs);

BOOL MACbIsRegBitsOn(DWORD_PTR dwIoBase, BYTE byRegOfs, BYTE byTestBits);
BOOL MACbIsRegBitsOff(DWORD_PTR dwIoBase, BYTE byRegOfs, BYTE byTestBits);

BOOL MACbIsIntDisable(DWORD_PTR dwIoBase);

BYTE MACbyReadMultiAddr(DWORD_PTR dwIoBase, UINT uByteIdx);
VOID MACvWriteMultiAddr(DWORD_PTR dwIoBase, UINT uByteIdx, BYTE byData);
VOID MACvSetMultiAddrByHash(DWORD_PTR dwIoBase, BYTE byHashIdx);
VOID MACvResetMultiAddrByHash(DWORD_PTR dwIoBase, BYTE byHashIdx);

VOID MACvSetRxThreshold(DWORD_PTR dwIoBase, BYTE byThreshold);
VOID MACvGetRxThreshold(DWORD_PTR dwIoBase, PBYTE pbyThreshold);

VOID MACvSetTxThreshold(DWORD_PTR dwIoBase, BYTE byThreshold);
VOID MACvGetTxThreshold(DWORD_PTR dwIoBase, PBYTE pbyThreshold);

VOID MACvSetDmaLength(DWORD_PTR dwIoBase, BYTE byDmaLength);
VOID MACvGetDmaLength(DWORD_PTR dwIoBase, PBYTE pbyDmaLength);

VOID MACvSetShortRetryLimit(DWORD_PTR dwIoBase, BYTE byRetryLimit);
VOID MACvGetShortRetryLimit(DWORD_PTR dwIoBase, PBYTE pbyRetryLimit);

VOID MACvSetLongRetryLimit(DWORD_PTR dwIoBase, BYTE byRetryLimit);
VOID MACvGetLongRetryLimit(DWORD_PTR dwIoBase, PBYTE pbyRetryLimit);

VOID MACvSetLoopbackMode(DWORD_PTR dwIoBase, BYTE byLoopbackMode);
BOOL MACbIsInLoopbackMode(DWORD_PTR dwIoBase);

VOID MACvSetPacketFilter(DWORD_PTR dwIoBase, WORD wFilterType);

VOID MACvSaveContext(DWORD_PTR dwIoBase, PBYTE pbyCxtBuf);
VOID MACvRestoreContext(DWORD_PTR dwIoBase, PBYTE pbyCxtBuf);
BOOL MACbCompareContext(DWORD_PTR dwIoBase, PBYTE pbyCxtBuf);

BOOL MACbSoftwareReset(DWORD_PTR dwIoBase);
BOOL MACbSafeSoftwareReset(DWORD_PTR dwIoBase);
BOOL MACbSafeRxOff(DWORD_PTR dwIoBase);
BOOL MACbSafeTxOff(DWORD_PTR dwIoBase);
BOOL MACbSafeStop(DWORD_PTR dwIoBase);
BOOL MACbShutdown(DWORD_PTR dwIoBase);
VOID MACvInitialize(DWORD_PTR dwIoBase);
VOID MACvSetCurrRx0DescAddr(DWORD_PTR dwIoBase, DWORD dwCurrDescAddr);
VOID MACvSetCurrRx1DescAddr(DWORD_PTR dwIoBase, DWORD dwCurrDescAddr);
VOID MACvSetCurrTXDescAddr(int iTxType, DWORD_PTR dwIoBase, DWORD dwCurrDescAddr);
VOID MACvSetCurrTx0DescAddrEx(DWORD_PTR dwIoBase, DWORD dwCurrDescAddr);
VOID MACvSetCurrAC0DescAddrEx(DWORD_PTR dwIoBase, DWORD dwCurrDescAddr);
VOID MACvSetCurrSyncDescAddrEx(DWORD_PTR dwIoBase, DWORD dwCurrDescAddr);
VOID MACvSetCurrATIMDescAddrEx(DWORD_PTR dwIoBase, DWORD dwCurrDescAddr);
void MACvTimer0MicroSDelay(DWORD_PTR dwIoBase, UINT uDelay);
void MACvOneShotTimer0MicroSec(DWORD_PTR dwIoBase, UINT uDelayTime);
void MACvOneShotTimer1MicroSec(DWORD_PTR dwIoBase, UINT uDelayTime);

void MACvSetMISCFifo(DWORD_PTR dwIoBase, WORD wOffset, DWORD dwData);

BOOL MACbTxDMAOff (DWORD_PTR dwIoBase, UINT idx);

void MACvClearBusSusInd(DWORD_PTR dwIoBase);
void MACvEnableBusSusEn(DWORD_PTR dwIoBase);

BOOL MACbFlushSYNCFifo(DWORD_PTR dwIoBase);
BOOL MACbPSWakeup(DWORD_PTR dwIoBase);

void MACvSetKeyEntry(DWORD_PTR dwIoBase, WORD wKeyCtl, UINT uEntryIdx, UINT uKeyIdx, PBYTE pbyAddr, PDWORD pdwKey, BYTE byLocalID);
void MACvDisableKeyEntry(DWORD_PTR dwIoBase, UINT uEntryIdx);
void MACvSetDefaultKeyEntry(DWORD_PTR dwIoBase, UINT uKeyLen, UINT uKeyIdx, PDWORD pdwKey, BYTE byLocalID);
//void MACvEnableDefaultKey(DWORD_PTR dwIoBase, BYTE byLocalID);
void MACvDisableDefaultKey(DWORD_PTR dwIoBase);
void MACvSetDefaultTKIPKeyEntry(DWORD_PTR dwIoBase, UINT uKeyLen, UINT uKeyIdx, PDWORD pdwKey, BYTE byLocalID);
void MACvSetDefaultKeyCtl(DWORD_PTR dwIoBase, WORD wKeyCtl, UINT uEntryIdx, BYTE byLocalID);

#ifdef __cplusplus
}                                       /* End of extern "C" { */
#endif /* __cplusplus */

#endif // __MAC_H__