1350 lines
25 KiB
C
1350 lines
25 KiB
C
/*++
|
|
|
|
Copyright (c) 1997 FORE Systems, Inc.
|
|
Copyright (c) 1997 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
macros.h
|
|
|
|
Abstract:
|
|
|
|
Macros for the ATMLANE module
|
|
|
|
Author:
|
|
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
#ifndef __ATMLANE_MACROS_H
|
|
#define __ATMLANE_MACROS_H
|
|
|
|
#include "atmlane.h"
|
|
|
|
#ifndef LOCKIN
|
|
#define LOCKIN
|
|
#endif
|
|
|
|
#ifndef NOLOCKOUT
|
|
#define NOLOCKOUT
|
|
#endif
|
|
|
|
#define NULL_NDIS_HANDLE ((NDIS_HANDLE)NULL)
|
|
|
|
#ifndef MAX
|
|
|
|
/*++
|
|
OPAQUE
|
|
MAX(
|
|
IN OPAQUE Fred,
|
|
IN OPAQUE Shred
|
|
)
|
|
--*/
|
|
#define MAX(Fred, Shred) (((Fred) > (Shred)) ? (Fred) : (Shred))
|
|
|
|
#endif // MAX
|
|
|
|
|
|
#ifndef MIN
|
|
|
|
/*++
|
|
OPAQUE
|
|
MIN(
|
|
IN OPAQUE Fred,
|
|
IN OPAQUE Shred
|
|
)
|
|
--*/
|
|
#define MIN(Fred, Shred) (((Fred) < (Shred)) ? (Fred) : (Shred))
|
|
|
|
#endif // MIN
|
|
|
|
#define ROUND_OFF(_size) (((_size) + 7) & ~0x7)
|
|
|
|
/*++
|
|
ULONG
|
|
ATMLANE_HASH(
|
|
IN PMAC_ADDRESS pMacAddress
|
|
)
|
|
--*/
|
|
#define ATMLANE_HASH(pMacAddress) \
|
|
((ULONG)(pMacAddress)->Byte[4])
|
|
|
|
/*++
|
|
BOOLEAN
|
|
MAC_ADDR_EQUAL(
|
|
IN PMAC_ADDRESS pMacAddr1,
|
|
IN PMAC_ADDRESS pMacAddr2
|
|
)
|
|
--*/
|
|
#define MAC_ADDR_EQUAL(_pMac1, _pMac2) \
|
|
((*(ULONG UNALIGNED *)&((PUCHAR)(_pMac1))[2] == \
|
|
*(ULONG UNALIGNED *)&((PUCHAR)(_pMac2))[2]) && \
|
|
(*(USHORT UNALIGNED *)(_pMac1) == \
|
|
*(USHORT UNALIGNED *)(_pMac2)))
|
|
|
|
/*++
|
|
VOID
|
|
SET_FLAG(
|
|
IN ULONG Flags,
|
|
IN ULONG Mask,
|
|
IN ULONG Val
|
|
)
|
|
--*/
|
|
#define SET_FLAG(Flags, Mask, Val) \
|
|
(Flags) = ((Flags) & ~(Mask)) | (Val)
|
|
|
|
|
|
/*++
|
|
BOOLEAN
|
|
IS_FLAG_SET(
|
|
IN ULONG Flags,
|
|
IN ULONG Mask,
|
|
IN ULONG Val
|
|
)
|
|
--*/
|
|
#define IS_FLAG_SET(Flags, Mask, Val) \
|
|
(((Flags) & (Mask)) == (Val))
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/*++
|
|
VOID
|
|
INIT_BLOCK_STRUCT(
|
|
IN ATMLANE_BLOCK *pBlock
|
|
)
|
|
--*/
|
|
#define INIT_BLOCK_STRUCT(pBlock) NdisInitializeEvent(&((pBlock)->Event))
|
|
|
|
|
|
/*++
|
|
NDIS_STATUS
|
|
WAIT_ON_BLOCK_STRUCT(
|
|
IN ATMLANE_BLOCK *pBlock
|
|
)
|
|
--*/
|
|
#define WAIT_ON_BLOCK_STRUCT(pBlock) \
|
|
(NdisWaitEvent(&((pBlock)->Event), 0), (pBlock)->Status)
|
|
|
|
|
|
/*++
|
|
VOID
|
|
SIGNAL_BLOCK_STRUCT(
|
|
IN ATMLANE_BLOCK *pBlock,
|
|
IN UINT Status
|
|
)
|
|
--*/
|
|
#define SIGNAL_BLOCK_STRUCT(pBlock, _Status) \
|
|
{ (pBlock)->Status = _Status; NdisSetEvent(&((pBlock)->Event)); }
|
|
|
|
|
|
/*++
|
|
VOID
|
|
FREE_BLOCK_STRUCT(
|
|
IN ATMLANE_BLOCK *pBlock
|
|
)
|
|
--*/
|
|
#define FREE_BLOCK_STRUCT(pBlock) // Nothing to be done here
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/*++
|
|
VOID
|
|
INIT_LOCK(
|
|
IN PNDIS_SPIN_LOCK pLock
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define INIT_LOCK(pLock, Str) \
|
|
AtmLaneAllocateSpinLock(pLock, Str, __FILE__, __LINE__)
|
|
#else
|
|
#define INIT_LOCK(pLock) \
|
|
NdisAllocateSpinLock(pLock)
|
|
#endif // DEBUG_SPIN_LOCK
|
|
|
|
|
|
/*++
|
|
VOID
|
|
ACQUIRE_LOCK(
|
|
IN PNDIS_SPIN_LOCK pLock,
|
|
IN PUCHAR Str
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define ACQUIRE_LOCK(pLock, Str) \
|
|
AtmLaneAcquireSpinLock(pLock, Str, __FILE__, __LINE__)
|
|
#else
|
|
#define ACQUIRE_LOCK(pLock) \
|
|
NdisAcquireSpinLock(pLock)
|
|
#endif // DEBUG_SPIN_LOCK
|
|
|
|
|
|
/*++
|
|
VOID
|
|
ACQUIRE_LOCK_DPC(
|
|
IN PNDIS_SPIN_LOCK pLock
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define ACQUIRE_LOCK_DPC(pLock, Str) \
|
|
AtmLaneAcquireSpinLock(pLock, Str"-dpc", __FILE__, __LINE__)
|
|
#else
|
|
#define ACQUIRE_LOCK_DPC(pLock) \
|
|
NdisDprAcquireSpinLock(pLock)
|
|
#endif // DEBUG_SPIN_LOCK
|
|
|
|
|
|
/*++
|
|
VOID
|
|
RELEASE_LOCK(
|
|
IN PNDIS_SPIN_LOCK pLock,
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define RELEASE_LOCK(pLock, Str) \
|
|
AtmLaneReleaseSpinLock(pLock, Str, __FILE__, __LINE__)
|
|
#else
|
|
#define RELEASE_LOCK(pLock) \
|
|
NdisReleaseSpinLock(pLock)
|
|
#endif // DEBUG_SPIN_LOCK
|
|
|
|
|
|
/*++
|
|
VOID
|
|
RELEASE_LOCK_DPC(
|
|
IN PNDIS_SPIN_LOCK pLock
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define RELEASE_LOCK_DPC(pLock, Str) \
|
|
AtmLaneReleaseSpinLock(pLock, Str"-dpc", __FILE__, __LINE__)
|
|
#else
|
|
#define RELEASE_LOCK_DPC(pLock) \
|
|
NdisDprReleaseSpinLock(pLock)
|
|
#endif // DEBUG_SPIN_LOCK
|
|
|
|
|
|
/*++
|
|
VOID
|
|
FREE_LOCK(
|
|
IN PNDIS_SPIN_LOCK pLock
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define FREE_LOCK(pLock, Str) \
|
|
AtmLaneFreeSpinLock(pLock, Str, __FILE__, __LINE__)
|
|
#else
|
|
#define FREE_LOCK(pLock) \
|
|
NdisFreeSpinLock(pLock)
|
|
#endif
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/*++
|
|
VOID
|
|
INIT_ADAPTER_LOCK(
|
|
IN PATMLANE_ADAPTER pAdapter
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define INIT_ADAPTER_LOCK(pAdapter) \
|
|
INIT_LOCK(&((pAdapter)->AdapterLock), "adapter")
|
|
#else
|
|
#define INIT_ADAPTER_LOCK(pAdapter) \
|
|
INIT_LOCK(&((pAdapter)->AdapterLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
ACQUIRE_ADAPTER_LOCK(
|
|
IN PATMLANE_ELAN pAdapter
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define ACQUIRE_ADAPTER_LOCK(pAdapter) \
|
|
ACQUIRE_LOCK(&((pAdapter)->AdapterLock), "adapter")
|
|
#else
|
|
#define ACQUIRE_ADAPTER_LOCK(pAdapter) \
|
|
ACQUIRE_LOCK(&((pAdapter)->AdapterLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
ACQUIRE_ADAPTER_LOCK_DPC(
|
|
IN PATMLANE_ELAN pAdapter
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define ACQUIRE_ADAPTER_LOCK_DPC(pAdapter) \
|
|
ACQUIRE_LOCK_DPC(&((pAdapter)->AdapterLock), "adapter")
|
|
#else
|
|
#define ACQUIRE_ADAPTER_LOCK_DPC(pAdapter) \
|
|
ACQUIRE_LOCK_DPC(&((pAdapter)->AdapterLock))
|
|
#endif
|
|
|
|
|
|
/*++
|
|
VOID
|
|
RELEASE_ADAPTER_LOCK(
|
|
IN PATMLANE_ELAN pAdapter
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define RELEASE_ADAPTER_LOCK(pAdapter) \
|
|
RELEASE_LOCK(&((pAdapter)->AdapterLock), "adapter")
|
|
#else
|
|
#define RELEASE_ADAPTER_LOCK(pAdapter) \
|
|
RELEASE_LOCK(&((pAdapter)->AdapterLock))
|
|
#endif
|
|
|
|
|
|
/*++
|
|
VOID
|
|
RELEASE_ADAPTER_LOCK_DPC(
|
|
IN PATMLANE_ELAN pAdapter
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define RELEASE_ADAPTER_LOCK_DPC(pAdapter) \
|
|
RELEASE_LOCK_DPC(&((pAdapter)->AdapterLock), "adapter")
|
|
#else
|
|
#define RELEASE_ADAPTER_LOCK_DPC(pAdapter) \
|
|
RELEASE_LOCK_DPC(&((pAdapter)->AdapterLock))
|
|
#endif
|
|
|
|
|
|
/*++
|
|
VOID
|
|
FREE_ADAPTER_LOCK(
|
|
IN PATMLANE_ELAN pAdapter
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define FREE_ADAPTER_LOCK(pAdapter) \
|
|
FREE_LOCK(&((pAdapter)->AdapterLock), "adapter")
|
|
#else
|
|
#define FREE_ADAPTER_LOCK(pAdapter) \
|
|
FREE_LOCK(&((pAdapter)->AdapterLock))
|
|
#endif
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/*++
|
|
VOID
|
|
INIT_ELAN_LOCK(
|
|
IN PATMLANE_ELAN pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define INIT_ELAN_LOCK(pElan) \
|
|
INIT_LOCK(&((pElan)->ElanLock), "elan")
|
|
#else
|
|
#define INIT_ELAN_LOCK(pElan) \
|
|
INIT_LOCK(&((pElan)->ElanLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
ACQUIRE_ELAN_LOCK(
|
|
IN PATMLANE_ELAN pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define ACQUIRE_ELAN_LOCK(pElan) \
|
|
ACQUIRE_LOCK(&((pElan)->ElanLock), "elan")
|
|
#else
|
|
#define ACQUIRE_ELAN_LOCK(pElan) \
|
|
ACQUIRE_LOCK(&((pElan)->ElanLock))
|
|
#endif
|
|
|
|
|
|
/*++
|
|
VOID
|
|
ACQUIRE_ELAN_LOCK_DPC(
|
|
IN PATMLANE_ELAN pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define ACQUIRE_ELAN_LOCK_DPC(pElan) \
|
|
ACQUIRE_LOCK_DPC(&((pElan)->ElanLock), "elan")
|
|
#else
|
|
#define ACQUIRE_ELAN_LOCK_DPC(pElan) \
|
|
ACQUIRE_LOCK_DPC(&((pElan)->ElanLock))
|
|
#endif
|
|
|
|
|
|
/*++
|
|
VOID
|
|
RELEASE_ELAN_LOCK(
|
|
IN PATMLANE_ELAN pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define RELEASE_ELAN_LOCK(pElan) \
|
|
RELEASE_LOCK(&((pElan)->ElanLock), "elan")
|
|
#else
|
|
#define RELEASE_ELAN_LOCK(pElan) \
|
|
RELEASE_LOCK(&((pElan)->ElanLock))
|
|
#endif
|
|
|
|
|
|
/*++
|
|
VOID
|
|
RELEASE_ELAN_LOCK_DPC(
|
|
IN PATMLANE_ELAN pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define RELEASE_ELAN_LOCK_DPC(pElan) \
|
|
RELEASE_LOCK_DPC(&((pElan)->ElanLock), "elan")
|
|
#else
|
|
#define RELEASE_ELAN_LOCK_DPC(pElan) \
|
|
RELEASE_LOCK_DPC(&((pElan)->ElanLock))
|
|
#endif
|
|
|
|
|
|
/*++
|
|
VOID
|
|
FREE_ELAN_LOCK(
|
|
IN PATMLANE_ELAN pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define FREE_ELAN_LOCK(pElan) \
|
|
FREE_LOCK(&((pElan)->ElanLock), "elan")
|
|
#else
|
|
#define FREE_ELAN_LOCK(pElan) \
|
|
FREE_LOCK(&((pElan)->ElanLock))
|
|
#endif
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/*++
|
|
VOID
|
|
INIT_HEADER_LOCK(
|
|
IN PATMLANE_ELAN pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define INIT_HEADER_LOCK(pElan) \
|
|
INIT_LOCK(&((pElan)->HeaderBufferLock), "header")
|
|
#else
|
|
#define INIT_HEADER_LOCK(pElan) \
|
|
INIT_LOCK(&((pElan)->HeaderBufferLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
ACQUIRE_HEADER_LOCK(
|
|
IN PATMLANE_ELAN pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define ACQUIRE_HEADER_LOCK(pElan) \
|
|
ACQUIRE_LOCK(&((pElan)->HeaderBufferLock), "header")
|
|
#else
|
|
#define ACQUIRE_HEADER_LOCK(pElan) \
|
|
ACQUIRE_LOCK(&((pElan)->HeaderBufferLock))
|
|
#endif
|
|
|
|
|
|
/*++
|
|
VOID
|
|
ACQUIRE_HEADER_LOCK_DPC(
|
|
IN PATMLANE_ELAN pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define ACQUIRE_HEADER_LOCK_DPC(pElan) \
|
|
ACQUIRE_LOCK_DPC(&((pElan)->HeaderBufferLock), "header")
|
|
#else
|
|
#define ACQUIRE_HEADER_LOCK_DPC(pElan) \
|
|
ACQUIRE_LOCK_DPC(&((pElan)->HeaderBufferLock))
|
|
#endif
|
|
|
|
|
|
/*++
|
|
VOID
|
|
RELEASE_HEADER_LOCK(
|
|
IN PATMLANE_ELAN pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define RELEASE_HEADER_LOCK(pElan) \
|
|
RELEASE_LOCK(&((pElan)->HeaderBufferLock), "header")
|
|
#else
|
|
#define RELEASE_HEADER_LOCK(pElan) \
|
|
RELEASE_LOCK(&((pElan)->HeaderBufferLock))
|
|
#endif
|
|
|
|
|
|
/*++
|
|
VOID
|
|
RELEASE_HEADER_LOCK_DPC(
|
|
IN PATMLANE_ELAN pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define RELEASE_HEADER_LOCK_DPC(pElan) \
|
|
RELEASE_LOCK_DPC(&((pElan)->HeaderBufferLock), "header")
|
|
#else
|
|
#define RELEASE_HEADER_LOCK_DPC(pElan) \
|
|
RELEASE_LOCK_DPC(&((pElan)->HeaderBufferLock))
|
|
#endif
|
|
|
|
|
|
/*++
|
|
VOID
|
|
FREE_HEADER_LOCK(
|
|
IN PATMLANE_ELAN pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define FREE_HEADER_LOCK(pElan) \
|
|
FREE_LOCK(&((pElan)->HeaderBufferLock), "header")
|
|
#else
|
|
#define FREE_HEADER_LOCK(pElan) \
|
|
FREE_LOCK(&((pElan)->HeaderBufferLock))
|
|
#endif
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/*++
|
|
VOID
|
|
INIT_ELAN_TIMER_LOCK(
|
|
IN PATMLANE_ELAN pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define INIT_ELAN_TIMER_LOCK(pElan) \
|
|
INIT_LOCK(&((pElan)->TimerLock), "timer")
|
|
#else
|
|
#define INIT_ELAN_TIMER_LOCK(pElan) \
|
|
INIT_LOCK(&((pElan)->TimerLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
ACQUIRE_ELAN_TIMER_LOCK(
|
|
IN PATMLANE_ELAN pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define ACQUIRE_ELAN_TIMER_LOCK(pElan) \
|
|
ACQUIRE_LOCK(&((pElan)->TimerLock), "timer")
|
|
#else
|
|
#define ACQUIRE_ELAN_TIMER_LOCK(pElan) \
|
|
ACQUIRE_LOCK(&((pElan)->TimerLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
ACQUIRE_ELAN_TIMER_LOCK_DPC(
|
|
IN PATMLANE_ELAN pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define ACQUIRE_ELAN_TIMER_LOCK_DPC(pElan) \
|
|
ACQUIRE_LOCK_DPC(&((pElan)->TimerLock), "timer")
|
|
#else
|
|
#define ACQUIRE_ELAN_TIMER_LOCK_DPC(pElan) \
|
|
ACQUIRE_LOCK_DPC(&((pElan)->TimerLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
RELEASE_ELAN_TIMER_LOCK(
|
|
IN PATMLANE_ELAN pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define RELEASE_ELAN_TIMER_LOCK(pElan) \
|
|
RELEASE_LOCK(&((pElan)->TimerLock), "timer")
|
|
#else
|
|
#define RELEASE_ELAN_TIMER_LOCK(pElan) \
|
|
RELEASE_LOCK(&((pElan)->TimerLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
RELEASE_ELAN_TIMER_LOCK_DPC(
|
|
IN PATMLANE_ELAN pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define RELEASE_ELAN_TIMER_LOCK_DPC(pElan) \
|
|
RELEASE_LOCK_DPC(&((pElan)->TimerLock), "timer")
|
|
#else
|
|
#define RELEASE_ELAN_TIMER_LOCK_DPC(pElan) \
|
|
RELEASE_LOCK_DPC(&((pElan)->TimerLock))
|
|
#endif
|
|
|
|
|
|
/*++
|
|
VOID
|
|
FREE_ELAN_TIMER_LOCK(
|
|
IN PATMLANE_ELAN pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define FREE_ELAN_TIMER_LOCK(pElan) \
|
|
FREE_LOCK(&((pElan)->TimerLock), "timer")
|
|
#else
|
|
#define FREE_ELAN_TIMER_LOCK(pElan) \
|
|
FREE_LOCK(&((pElan)->TimerLock))
|
|
#endif
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/*++
|
|
VOID
|
|
INIT_ATM_ENTRY_LOCK(
|
|
IN PATMLANE_ATM_ENTRY pAe
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define INIT_ATM_ENTRY_LOCK(pAe) \
|
|
INIT_LOCK(&((pAe)->AeLock), "atmentry")
|
|
#else
|
|
#define INIT_ATM_ENTRY_LOCK(pAe) \
|
|
INIT_LOCK(&((pAe)->AeLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
ACQUIRE_ATM_ENTRY_LOCK(
|
|
IN PATMLANE_ATM_ENTRY pAe
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define ACQUIRE_ATM_ENTRY_LOCK(pAe) \
|
|
ACQUIRE_LOCK(&((pAe)->AeLock), "atmentry")
|
|
#else
|
|
#define ACQUIRE_ATM_ENTRY_LOCK(pAe) \
|
|
ACQUIRE_LOCK(&((pAe)->AeLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
ACQUIRE_ATM_ENTRY_LOCK_DPC(
|
|
IN PATMLANE_ATM_ENTRY pAe
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define ACQUIRE_ATM_ENTRY_LOCK_DPC(pAe) \
|
|
ACQUIRE_LOCK_DPC(&((pAe)->AeLock), "atmentry")
|
|
#else
|
|
#define ACQUIRE_ATM_ENTRY_LOCK_DPC(pAe) \
|
|
ACQUIRE_LOCK_DPC(&((pAe)->AeLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
RELEASE_ATM_ENTRY_LOCK(
|
|
IN PATMLANE_ATM_ENTRY pAe
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define RELEASE_ATM_ENTRY_LOCK(pAe) \
|
|
RELEASE_LOCK(&((pAe)->AeLock), "atmentry")
|
|
#else
|
|
#define RELEASE_ATM_ENTRY_LOCK(pAe) \
|
|
RELEASE_LOCK(&((pAe)->AeLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
RELEASE_ATM_ENTRY_LOCK_DPC(
|
|
IN PATMLANE_ATM_ENTRY pAe
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define RELEASE_ATM_ENTRY_LOCK_DPC(pAe) \
|
|
RELEASE_LOCK_DPC(&((pAe)->AeLock), "atmentry")
|
|
#else
|
|
#define RELEASE_ATM_ENTRY_LOCK_DPC(pAe) \
|
|
RELEASE_LOCK_DPC(&((pAe)->AeLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
FREE_ATM_ENTRY_LOCK(
|
|
IN PATMLANE_ATM_ENTRY pAe
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define FREE_ATM_ENTRY_LOCK(pAe) \
|
|
FREE_LOCK(&((pAe)->AeLock), "atmentry")
|
|
#else
|
|
#define FREE_ATM_ENTRY_LOCK(pAe) \
|
|
FREE_LOCK(&((pAe)->AeLock))
|
|
#endif
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/*++
|
|
VOID
|
|
INIT_MAC_ENTRY_LOCK(
|
|
IN PATMLANE_ATM_ENTRY pMe
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define INIT_MAC_ENTRY_LOCK(pMe) \
|
|
INIT_LOCK(&((pMe)->MeLock), "macentry")
|
|
#else
|
|
#define INIT_MAC_ENTRY_LOCK(pMe) \
|
|
INIT_LOCK(&((pMe)->MeLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
ACQUIRE_MAC_ENTRY_LOCK(
|
|
IN PATMLANE_ATM_ENTRY pMe
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define ACQUIRE_MAC_ENTRY_LOCK(pMe) \
|
|
ACQUIRE_LOCK(&((pMe)->MeLock), "macentry")
|
|
#else
|
|
#define ACQUIRE_MAC_ENTRY_LOCK(pMe) \
|
|
ACQUIRE_LOCK(&((pMe)->MeLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
ACQUIRE_MAC_ENTRY_LOCK_DPC(
|
|
IN PATMLANE_ATM_ENTRY pMe
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define ACQUIRE_MAC_ENTRY_LOCK_DPC(pMe) \
|
|
ACQUIRE_LOCK_DPC(&((pMe)->MeLock), "macentry")
|
|
#else
|
|
#define ACQUIRE_MAC_ENTRY_LOCK_DPC(pMe) \
|
|
ACQUIRE_LOCK_DPC(&((pMe)->MeLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
RELEASE_MAC_ENTRY_LOCK(
|
|
IN PATMLANE_ATM_ENTRY pMe
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define RELEASE_MAC_ENTRY_LOCK(pMe) \
|
|
RELEASE_LOCK(&((pMe)->MeLock), "macentry")
|
|
#else
|
|
#define RELEASE_MAC_ENTRY_LOCK(pMe) \
|
|
RELEASE_LOCK(&((pMe)->MeLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
RELEASE_MAC_ENTRY_LOCK_DPC(
|
|
IN PATMLANE_ATM_ENTRY pMe
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define RELEASE_MAC_ENTRY_LOCK_DPC(pMe) \
|
|
RELEASE_LOCK_DPC(&((pMe)->MeLock), "macentry")
|
|
#else
|
|
#define RELEASE_MAC_ENTRY_LOCK_DPC(pMe) \
|
|
RELEASE_LOCK_DPC(&((pMe)->MeLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
FREE_MAC_ENTRY_LOCK(
|
|
IN PATMLANE_ATM_ENTRY pMe
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define FREE_MAC_ENTRY_LOCK(pMe) \
|
|
FREE_LOCK(&((pMe)->MeLock), "macentry")
|
|
#else
|
|
#define FREE_MAC_ENTRY_LOCK(pMe) \
|
|
FREE_LOCK(&((pMe)->MeLock))
|
|
#endif
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/*++
|
|
VOID
|
|
INIT_ELAN_ATM_LIST_LOCK(
|
|
IN PATMARP_INTERFACE pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define INIT_ELAN_ATM_LIST_LOCK(pElan) \
|
|
INIT_LOCK(&((pElan)->AtmEntryListLock), "atmlist")
|
|
#else
|
|
#define INIT_ELAN_ATM_LIST_LOCK(pElan) \
|
|
INIT_LOCK(&((pElan)->AtmEntryListLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
ACQUIRE_ELAN_ATM_LIST_LOCK(
|
|
IN PATMARP_INTERFACE pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define ACQUIRE_ELAN_ATM_LIST_LOCK(pElan) \
|
|
ACQUIRE_LOCK(&((pElan)->AtmEntryListLock), "atmlist")
|
|
#else
|
|
#define ACQUIRE_ELAN_ATM_LIST_LOCK(pElan) \
|
|
ACQUIRE_LOCK(&((pElan)->AtmEntryListLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
ACQUIRE_ELAN_ATM_LIST_LOCK_DPC(
|
|
IN PATMARP_INTERFACE pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define ACQUIRE_ELAN_ATM_LIST_LOCK_DPC(pElan) \
|
|
ACQUIRE_LOCK_DPC(&((pElan)->AtmEntryListLock), "atmlist")
|
|
#else
|
|
#define ACQUIRE_ELAN_ATM_LIST_LOCK_DPC(pElan) \
|
|
ACQUIRE_LOCK_DPC(&((pElan)->AtmEntryListLock))
|
|
#endif
|
|
|
|
|
|
/*++
|
|
VOID
|
|
RELEASE_ELAN_ATM_LIST_LOCK(
|
|
IN PATMARP_INTERFACE pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define RELEASE_ELAN_ATM_LIST_LOCK(pElan) \
|
|
RELEASE_LOCK(&((pElan)->AtmEntryListLock), "atmlist")
|
|
#else
|
|
#define RELEASE_ELAN_ATM_LIST_LOCK(pElan) \
|
|
RELEASE_LOCK(&((pElan)->AtmEntryListLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
RELEASE_ELAN_ATM_LIST_LOCK_DPC(
|
|
IN PATMARP_INTERFACE pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define RELEASE_ELAN_ATM_LIST_LOCK_DPC(pElan) \
|
|
RELEASE_LOCK_DPC(&((pElan)->AtmEntryListLock), "atmlist")
|
|
#else
|
|
#define RELEASE_ELAN_ATM_LIST_LOCK_DPC(pElan) \
|
|
RELEASE_LOCK_DPC(&((pElan)->AtmEntryListLock))
|
|
#endif
|
|
|
|
|
|
/*++
|
|
VOID
|
|
FREE_ELAN_ATM_LIST_LOCK(
|
|
IN PATMARP_INTERFACE pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define FREE_ELAN_ATM_LIST_LOCK(pElan) \
|
|
FREE_LOCK(&((pElan)->AtmEntryListLock), "atmlist")
|
|
#else
|
|
#define FREE_ELAN_ATM_LIST_LOCK(pElan) \
|
|
FREE_LOCK(&((pElan)->AtmEntryListLock))
|
|
#endif
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/*++
|
|
VOID
|
|
INIT_ELAN_MAC_TABLE_LOCK(
|
|
IN PATMLANE_ELAN pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define INIT_ELAN_MAC_TABLE_LOCK(pElan) \
|
|
INIT_LOCK(&((pElan)->MacTableLock), "mactable")
|
|
#else
|
|
#define INIT_ELAN_MAC_TABLE_LOCK(pElan) \
|
|
INIT_LOCK(&((pElan)->MacTableLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
ACQUIRE_ELAN_MAC_TABLE_LOCK(
|
|
IN PATMLANE_ELAN pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define ACQUIRE_ELAN_MAC_TABLE_LOCK(pElan) \
|
|
ACQUIRE_LOCK(&((pElan)->MacTableLock), "mactable")
|
|
#else
|
|
#define ACQUIRE_ELAN_MAC_TABLE_LOCK(pElan) \
|
|
ACQUIRE_LOCK(&((pElan)->MacTableLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
ACQUIRE_ELAN_MAC_TABLE_LOCK_DPC(
|
|
IN PATMLANE_ELAN pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define ACQUIRE_ELAN_MAC_TABLE_LOCK_DPC(pElan) \
|
|
ACQUIRE_LOCK_DPC(&((pElan)->MacTableLock), "mactable")
|
|
#else
|
|
#define ACQUIRE_ELAN_MAC_TABLE_LOCK_DPC(pElan) \
|
|
ACQUIRE_LOCK_DPC(&((pElan)->MacTableLock))
|
|
#endif
|
|
|
|
|
|
/*++
|
|
VOID
|
|
RELEASE_ELAN_MAC_TABLE_LOCK(
|
|
IN PATMLANE_ELAN pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define RELEASE_ELAN_MAC_TABLE_LOCK(pElan) \
|
|
RELEASE_LOCK(&((pElan)->MacTableLock), "mactable")
|
|
#else
|
|
#define RELEASE_ELAN_MAC_TABLE_LOCK(pElan) \
|
|
RELEASE_LOCK(&((pElan)->MacTableLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
RELEASE_ELAN_MAC_TABLE_LOCK_DPC(
|
|
IN PATMLANE_ELAN pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define RELEASE_ELAN_MAC_TABLE_LOCK_DPC(pElan) \
|
|
RELEASE_LOCK_DPC(&((pElan)->MacTableLock), "mactable")
|
|
#else
|
|
#define RELEASE_ELAN_MAC_TABLE_LOCK_DPC(pElan) \
|
|
RELEASE_LOCK_DPC(&((pElan)->MacTableLock))
|
|
#endif
|
|
|
|
|
|
/*++
|
|
VOID
|
|
FREE_ELAN_MAC_TABLE_LOCK(
|
|
IN PATMLANE_ELAN pElan
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define FREE_ELAN_MAC_TABLE_LOCK(pElan) \
|
|
FREE_LOCK(&((pElan)->MacTableLock), "mactable")
|
|
#else
|
|
#define FREE_ELAN_MAC_TABLE_LOCK(pElan) \
|
|
FREE_LOCK(&((pElan)->MacTableLock))
|
|
#endif
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/*++
|
|
VOID
|
|
INIT_VC_LOCK(
|
|
IN PATMLANE_VC pVc
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define INIT_VC_LOCK(pVc) \
|
|
INIT_LOCK(&((pVc)->VcLock), "vc")
|
|
#else
|
|
#define INIT_VC_LOCK(pVc) \
|
|
INIT_LOCK(&((pVc)->VcLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
ACQUIRE_VC_LOCK(
|
|
IN PATMLANE_VC pVc
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define ACQUIRE_VC_LOCK(pVc) \
|
|
ACQUIRE_LOCK(&((pVc)->VcLock), "vc")
|
|
#else
|
|
#define ACQUIRE_VC_LOCK(pVc) \
|
|
ACQUIRE_LOCK(&((pVc)->VcLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
ACQUIRE_VC_LOCK_DPC(
|
|
IN PATMLANE_VC pVc
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define ACQUIRE_VC_LOCK_DPC(pVc) \
|
|
ACQUIRE_LOCK_DPC(&((pVc)->VcLock), "vc")
|
|
#else
|
|
#define ACQUIRE_VC_LOCK_DPC(pVc) \
|
|
ACQUIRE_LOCK_DPC(&((pVc)->VcLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
RELEASE_VC_LOCK(
|
|
IN PATMLANE_VC pVc
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define RELEASE_VC_LOCK(pVc) \
|
|
RELEASE_LOCK(&((pVc)->VcLock), "vc")
|
|
#else
|
|
#define RELEASE_VC_LOCK(pVc) \
|
|
RELEASE_LOCK(&((pVc)->VcLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
RELEASE_VC_LOCK_DPC(
|
|
IN PATMLANE_VC pVc
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define RELEASE_VC_LOCK_DPC(pVc) \
|
|
RELEASE_LOCK_DPC(&((pVc)->VcLock), "vc")
|
|
#else
|
|
#define RELEASE_VC_LOCK_DPC(pVc) \
|
|
RELEASE_LOCK_DPC(&((pVc)->VcLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
FREE_VC_LOCK(
|
|
IN PATMLANE_VC pVc
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define FREE_VC_LOCK(pVc) \
|
|
FREE_LOCK(&((pVc)->VcLock), "vc")
|
|
#else
|
|
#define FREE_VC_LOCK(pVc) \
|
|
FREE_LOCK(&((pVc)->VcLock))
|
|
#endif
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/*++
|
|
VOID
|
|
INIT_SENDPACKET_LOCK(
|
|
IN PNDIS_PACKET pPkt
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define INIT_SENDPACKET_LOCK(pPkt) \
|
|
INIT_LOCK(&(PSEND_RSVD(pPkt)->Lock), "packet")
|
|
#else
|
|
#define INIT_SENDPACKET_LOCK(pPkt) \
|
|
INIT_LOCK(&(PSEND_RSVD(pPkt)->Lock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
ACQUIRE_SENDPACKET_LOCK(
|
|
IN PNDIS_PACKET pPkt
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define ACQUIRE_SENDPACKET_LOCK(pPkt) \
|
|
ACQUIRE_LOCK(&(PSEND_RSVD(pPkt)->Lock), "packet")
|
|
#else
|
|
#define ACQUIRE_SENDPACKET_LOCK(pPkt) \
|
|
ACQUIRE_LOCK(&(PSEND_RSVD(pPkt)->Lock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
RELEASE_SENDPACKET_LOCK(
|
|
IN PNDIS_PACKET pPkt
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define RELEASE_SENDPACKET_LOCK(pPkt) \
|
|
RELEASE_LOCK(&(PSEND_RSVD(pPkt)->Lock), "packet")
|
|
#else
|
|
#define RELEASE_SENDPACKET_LOCK(pPkt) \
|
|
RELEASE_LOCK(&(PSEND_RSVD(pPkt)->Lock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
FREE_SENDPACKET_LOCK(
|
|
IN PNDIS_PACKET pPkt
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define FREE_SENDPACKET_LOCK(pPkt) \
|
|
FREE_LOCK(&(PSEND_RSVD(pPkt)->Lock), "packet")
|
|
#else
|
|
#define FREE_SENDPACKET_LOCK(pPkt) \
|
|
FREE_LOCK(&(PSEND_RSVD(pPkt)->Lock))
|
|
#endif
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/*++
|
|
VOID
|
|
INIT_GLOBAL_LOCK(
|
|
IN PATMLANE_GLOBALS pGlob
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define INIT_GLOBAL_LOCK(pGlob) \
|
|
INIT_LOCK(&((pGlob)->GlobalLock), "global")
|
|
#else
|
|
#define INIT_GLOBAL_LOCK(pGlob) \
|
|
INIT_LOCK(&((pGlob)->GlobalLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
ACQUIRE_GLOBAL_LOCK(
|
|
IN PATMLANE_GLOBALS pGlob
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define ACQUIRE_GLOBAL_LOCK(pGlob) \
|
|
ACQUIRE_LOCK(&((pGlob)->GlobalLock), "global")
|
|
#else
|
|
#define ACQUIRE_GLOBAL_LOCK(pGlob) \
|
|
ACQUIRE_LOCK(&((pGlob)->GlobalLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
RELEASE_GLOBAL_LOCK(
|
|
IN PATMLANE_GLOBALS pGlob
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define RELEASE_GLOBAL_LOCK(pGlob) \
|
|
RELEASE_LOCK(&((pGlob)->GlobalLock), "global")
|
|
#else
|
|
#define RELEASE_GLOBAL_LOCK(pGlob) \
|
|
RELEASE_LOCK(&((pGlob)->GlobalLock))
|
|
#endif
|
|
|
|
/*++
|
|
VOID
|
|
FREE_GLOBAL_LOCK(
|
|
IN PATMLANE_GLOBALS pGlob
|
|
)
|
|
--*/
|
|
#if DEBUG_SPIN_LOCK
|
|
#define FREE_GLOBAL_LOCK(pGlob) \
|
|
FREE_LOCK(&((pGlob)->GlobalLock), "global")
|
|
#else
|
|
#define FREE_GLOBAL_LOCK(pGlob) \
|
|
FREE_LOCK(&((pGlob)->GlobalLock))
|
|
#endif
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/*++
|
|
VOID *
|
|
ALLOC_MEM(
|
|
OUT PVOID * pPtr,
|
|
IN ULONG SizeInBytes
|
|
)
|
|
--*/
|
|
#if DEBUG_MEMORY_ALLOC
|
|
#define ALLOC_MEM(pPtr, SizeInBytes) \
|
|
AaAuditAllocMem(pPtr,(ULONG)(SizeInBytes),__FILE__,__LINE__)
|
|
#else
|
|
#define ALLOC_MEM(pPtr, SizeInBytes) \
|
|
NdisAllocateMemoryWithTag((pPtr), (SizeInBytes), (ULONG)'ENAL')
|
|
#endif // DBG
|
|
|
|
|
|
/*++
|
|
VOID
|
|
FREE_MEM(
|
|
IN POPAQUE pMem
|
|
)
|
|
--*/
|
|
#if DEBUG_MEMORY_ALLOC
|
|
#define FREE_MEM(pMem) AaAuditFreeMem((PVOID)(pMem));
|
|
#else
|
|
#define FREE_MEM(pMem) NdisFreeMemory((PVOID)(pMem), 0, 0);
|
|
#endif // DBG
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/*++
|
|
VOID
|
|
INIT_SYSTEM_TIMER(
|
|
IN PNDIS_TIMER pTimer,
|
|
IN PNDIS_TIMER_FUNCTON pFunc,
|
|
IN PVOID Context
|
|
)
|
|
--*/
|
|
#define INIT_SYSTEM_TIMER(pTimer, pFunc, Context) \
|
|
NdisInitializeTimer(pTimer, (PNDIS_TIMER_FUNCTION)(pFunc), (PVOID)Context)
|
|
|
|
|
|
|
|
/*++
|
|
VOID
|
|
START_SYSTEM_TIMER(
|
|
IN PNDIS_TIMER pTimer,
|
|
IN UINT PeriodInSeconds
|
|
)
|
|
--*/
|
|
#define START_SYSTEM_TIMER(pTimer, PeriodInSeconds) \
|
|
NdisSetTimer(pTimer, (UINT)(PeriodInSeconds * 1000))
|
|
|
|
|
|
/*++
|
|
VOID
|
|
STOP_SYSTEM_TIMER(
|
|
IN PNDIS_TIMER pTimer
|
|
)
|
|
--*/
|
|
#define STOP_SYSTEM_TIMER(pTimer) \
|
|
{ \
|
|
BOOLEAN WasCancelled; \
|
|
NdisCancelTimer(pTimer, &WasCancelled); \
|
|
}
|
|
|
|
/*++
|
|
BOOLEAN
|
|
IS_TIMER_ACTIVE(
|
|
IN PATMLANE_TIMER pArpTimer
|
|
)
|
|
--*/
|
|
#define IS_TIMER_ACTIVE(pTmr) ((pTmr)->pTimerList != (PATMLANE_TIMER_LIST)NULL)
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
|
|
/*++
|
|
ULONG
|
|
SECONDS_TO_LONG_TICKS(
|
|
IN ULONG Seconds
|
|
)
|
|
Convert from seconds to "long duration timer ticks"
|
|
--*/
|
|
#define SECONDS_TO_LONG_TICKS(Seconds) ((Seconds)/10)
|
|
|
|
|
|
/*++
|
|
ULONG
|
|
SECONDS_TO_SHORT_TICKS(
|
|
IN ULONG Seconds
|
|
)
|
|
Convert from seconds to "short duration timer ticks"
|
|
--*/
|
|
#define SECONDS_TO_SHORT_TICKS(Seconds) (Seconds)
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/*++
|
|
VOID
|
|
SET_NEXT_PACKET(
|
|
IN PNDIS_PACKET pNdisPacket,
|
|
IN PNDIS_PACKET pNextPacket
|
|
)
|
|
--*/
|
|
#define SET_NEXT_PACKET(pPkt, pNext) \
|
|
((PSEND_PACKET_RESERVED)((pPkt)->ProtocolReserved))->pNextNdisPacket = pNext;
|
|
|
|
/*++
|
|
PNDIS_PACKET
|
|
GET_NEXT_PACKET(
|
|
IN PNDIS_PACKET pNdisPacket
|
|
)
|
|
--*/
|
|
#define GET_NEXT_PACKET(pPkt) \
|
|
((PSEND_PACKET_RESERVED)((pPkt)->ProtocolReserved))->pNextNdisPacket
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/*++
|
|
ULONG
|
|
CELLS_TO_BYTES(
|
|
IN ULONG NumberOfCells
|
|
)
|
|
Convert from cell count to byte count
|
|
--*/
|
|
#define CELLS_TO_BYTES(NumberOfCells) ((NumberOfCells) * 48)
|
|
|
|
|
|
/*++
|
|
ULONG
|
|
BYTES_TO_CELLS(
|
|
IN ULONG ByteCount
|
|
)
|
|
Convert from byte count to cell count
|
|
--*/
|
|
#define BYTES_TO_CELLS(ByteCount) ((ByteCount) / 48)
|
|
|
|
|
|
/*++
|
|
ULONG
|
|
LINKSPEED_TO_CPS(
|
|
IN ULONG LinkSpeed
|
|
)
|
|
Convert from NDIS "Link Speed" to cells per second
|
|
--*/
|
|
#define LINKSPEED_TO_CPS(_LinkSpeed) (((_LinkSpeed)*100)/(48*8))
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/*++
|
|
ULONG
|
|
SWAPULONG(
|
|
IN ULONG Val
|
|
)
|
|
--*/
|
|
#define SWAPULONG(Val) \
|
|
((((Val)&0xff)<<24)|(((Val)&0xff00)<<8)| \
|
|
(((Val)&0xff0000)>>8)|(((Val)&0xff000000)>>24))
|
|
|
|
/*++
|
|
USHORT
|
|
SWAPUSHORT(
|
|
IN USHORT Val
|
|
)
|
|
--*/
|
|
#define SWAPUSHORT(Val) \
|
|
((((Val) & 0xff) << 8) | (((Val) & 0xff00) >> 8))
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/*++
|
|
BOOLEAN
|
|
ATM_ADDR_EQUAL(
|
|
IN PUCHAR Addr1,
|
|
IN PUCHAR Addr2
|
|
)
|
|
--*/
|
|
#define ATM_ADDR_EQUAL(_Addr1, _Addr2) \
|
|
NdisEqualMemory((_Addr1), (_Addr2), ATM_ADDRESS_LENGTH)
|
|
|
|
/*++
|
|
BOOLEAN
|
|
ETH_ADDR_MULTICAST(
|
|
IN PUCHAR Addr,
|
|
)
|
|
--*/
|
|
#define ETH_ADDR_MULTICAST(_Addr) ((_Addr)[0]&1)
|
|
|
|
/*++
|
|
BOOLEAN
|
|
TR_ADDR_MULTICAST(
|
|
IN PUCHAR Addr,
|
|
)
|
|
--*/
|
|
#define TR_ADDR_MULTICAST(_Addr) ((_Addr)[0]&0x80)
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#endif // __ATMLANE_MACROS_H
|
|
|