/* set connection state */
mtl_set_conn_state(
VOID *mtl_1,
USHORT NumberOfChannels,
BOOL is_conn)
{
MTL *mtl = (MTL*)mtl_1;
ADAPTER *Adapter = mtl->Adapter;
NDIS_PHYSICAL_ADDRESS pa = NDIS_PHYSICAL_ADDRESS_CONST(0xffffffff, 0xffffffff);
D_LOG(D_ENTRY, ("mtl_set_conn_state: entry, is_conn: %d\n", is_conn));
/* get lock, set, release & return */
NdisAcquireSpinLock(&mtl->lock);
mtl->is_conn = is_conn;
//
// if we are being notified of a new connection we need to do some stuff
//
if (is_conn)
{
mtl->FramesXmitted = 0;
mtl->FramesReceived = 0;
mtl->BytesXmitted = 0;
mtl->BytesReceived = 0;
mtl->RecvFramingBits = 0;
mtl->tx_tbl.NextFree = 0;
mtl->rx_tbl.NextFree = 0;
}
NdisReleaseSpinLock(&mtl->lock);
return(MTL_E_SUCC);
}
NDIS_STATUS PolicyManagerInitialize(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath,
OUT PNDIS_HANDLE PolicyManagerHandle
)
{
DBG_FUNC("PolicyManagerInitialize")
NDIS_STATUS status;
PGPnetPMContext *pContext = 0;
PGPError err = kPGPError_NoErr;
NDIS_PHYSICAL_ADDRESS HighestAcceptableAddress = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1);
#ifdef PM_EMULATION
PDummySA dummySA;
#endif
DBG_ENTER();
status = NdisAllocateMemory(PolicyManagerHandle,
sizeof(PGPnetPMContext),
0,
HighestAcceptableAddress
);
#ifndef PM_EMULATION
if (status != NDIS_STATUS_SUCCESS)
{
DBG_PRINT(("!!!!! NdisAllocateMemory failed status=%Xh\n", status););
/* initialize cm class */
INT
cm_init(VOID)
{
NDIS_PHYSICAL_ADDRESS pa = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1);
D_LOG(D_ENTRY, ("cm_init: entry"));
NdisZeroMemory(cm_tbl, sizeof(cm_tbl));
NdisZeroMemory(cm_used, sizeof(cm_used));
ChannelInit();
return(CM_E_SUCC);
}
//
// Allocate free channel pool
//
VOID
ChannelInit(VOID)
{
NDIS_PHYSICAL_ADDRESS pa = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1);
/* allocate memory object */
NdisAllocateMemory((PVOID*)&chan_tbl, sizeof(CM_CHAN) * MAX_CHAN_IN_SYSTEM, 0, pa);
if ( chan_tbl == NULL )
{
D_LOG(D_ALWAYS, ("ChannelInit: memory allocate failed!"));
return;
}
D_LOG(D_ALWAYS, ("ChannelInit: chan_tbl: 0x%x", chan_tbl));
NdisZeroMemory (chan_tbl, sizeof(CM_CHAN) * MAX_CHAN_IN_SYSTEM);
NdisZeroMemory (chan_used, sizeof(chan_used));
}
/* initialize support */
INT
res_init(VOID)
{
NDIS_PHYSICAL_ADDRESS pa = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1);
/* allocate memory object */
NdisAllocateMemory((PVOID*)&res__tbl, (sizeof(RES) * MAX_RES), 0, pa);
if ( !res__tbl )
{
D_LOG(D_ALWAYS, ("res_init: memory allocate failed!"));
return(RES_E_NOMEM);
}
D_LOG(D_ALWAYS, ("res_init: res__tbl: 0x%lx", res__tbl));
NdisZeroMemory (res__tbl, sizeof(RES) * MAX_RES);
// NdisAllocateSpinLock(&res__lock);
return(RES_E_SUCC);
}
/* create a new cm object */
cm_create(VOID **ret_cm, NDIS_HANDLE AdapterHandle)
{
NDIS_PHYSICAL_ADDRESS pa = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1);
INT n;
D_LOG(D_ENTRY, ("cm_create: entry, ret_cm: 0x%p", ret_cm));
/* allocate memory object */
NdisAllocateMemory((PVOID*)ret_cm, sizeof(CM), 0, pa);
if ( *ret_cm == NULL )
{
D_LOG(D_ALWAYS, ("cm_create: memory allocate failed!"));
NdisWriteErrorLogEntry (AdapterHandle,
NDIS_ERROR_CODE_OUT_OF_RESOURCES,
0);
return(CM_E_NOMEM);
}
D_LOG(D_ALWAYS, ("cm_create: cm: 0x%x", *ret_cm));
NdisZeroMemory(*ret_cm, sizeof(CM));
/* allocate connection out of local table */
for ( n = 0 ; n < MAX_CM_IN_SYSTEM ; n++ )
if ( !cm_used[n] )
break;
if ( n >= MAX_CM_IN_SYSTEM )
{
/* free memory */
NdisFreeMemory(*ret_cm, sizeof(CM), 0);
return(CM_E_NOSLOT);
}
/* initialize */
cm_used[n] = 1;
cm_tbl[n] = *ret_cm;
((CM*)*ret_cm)->local_conn_index = n;
/* return */
return(CM_E_SUCC);
}
/* create a trace object */
INT
trc_create(VOID **trc_1, ULONG depth)
{
TRC **ret_trc = (TRC**)trc_1;
NDIS_PHYSICAL_ADDRESS pa = NDIS_PHYSICAL_ADDRESS_CONST(0xffffffff, 0xffffffff);
TRC *trc;
D_LOG(D_ENTRY, ("trc_create: entry, ret_trc: 0x%lx, depth: %ld", ret_trc, depth));
/* allocate memory object */
NdisAllocateMemory((PVOID*)&trc, sizeof(*trc), 0, pa);
if ( !trc )
{
mem_alloc_failed:
D_LOG(D_ALWAYS, ("trc_create: memory allocate failed!"));
return(TRC_E_NOMEM);
}
D_LOG(D_ALWAYS, ("trc_create: trc: 0x%lx", trc));
NdisZeroMemory(trc, sizeof(*trc));
/* allocate buffer memory */
NdisAllocateMemory((PVOID*)&trc->ent_tbl, sizeof(TRC_ENTRY) * depth,
0, pa);
if ( !trc->ent_tbl )
goto mem_alloc_failed;
D_LOG(D_ALWAYS, ("trc_create: trc->ent_tbl: 0x%lx", trc->ent_tbl));
NdisZeroMemory(trc->ent_tbl, sizeof(TRC_ENTRY) * depth);
/* setup initial field values */
trc->stat.state = TRC_ST_STOP;
trc->stat.filter = TRC_FT_NONE;
trc->stat.depth = depth;
/* return succ */
*ret_trc = trc;
return(TRC_E_SUCC);
}
#include <precomp.h>
#pragma hdrstop
#if DBG
UINT AfilterDebugFlag = 0;
#endif
//
// This constant is used for places where NdisAllocateMemory
// needs to be called and the HighestAcceptableAddress does
// not matter.
//
static const NDIS_PHYSICAL_ADDRESS HighestAcceptableMax =
NDIS_PHYSICAL_ADDRESS_CONST(-1,-1);
//
// A set of macros to manipulate bitmasks.
//
//VOID
//CLEAR_BIT_IN_MASK(
// IN UINT Offset,
// IN OUT PMASK MaskToClear
// )
//
///*++
//
//Routine Description:
//
#include "Neo6.h"
static UINT64 max_speed = NEO_MAX_SPEED_DEFAULT;
static bool keep_link = false;
BOOLEAN
PsGetVersion(
PULONG MajorVersion OPTIONAL,
PULONG MinorVersion OPTIONAL,
PULONG BuildNumber OPTIONAL,
PUNICODE_STRING CSDVersion OPTIONAL
);
// Memory related
static NDIS_PHYSICAL_ADDRESS HighestAcceptableMax = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1);
NDIS_HANDLE ndis_miniport_driver_handle = NULL;
// Flag for whether Windows 8
bool g_is_win8 = false;
// Win32 driver entry point
NDIS_STATUS DriverEntry(DRIVER_OBJECT *DriverObject, UNICODE_STRING *RegistryPath)
{
NDIS_MINIPORT_DRIVER_CHARACTERISTICS miniport;
ULONG os_major_ver = 0, os_minor_ver = 0;
NDIS_STATUS ret;
// Initialize the Neo library
if (NeoInit() == FALSE)
{
// The debugging longword, containing a bitmask as defined in common.h
// If a bit is set, then debugging is turned on for that component.
//
#if DBG
ULONG TpDebug = TP_DEBUG_NDIS_CALLS|TP_DEBUG_NDIS_ERROR|TP_DEBUG_STATISTICS|
TP_DEBUG_DATA|TP_DEBUG_DISPATCH|TP_DEBUG_IOCTL_ARGS|
TP_DEBUG_NT_STATUS|TP_DEBUG_DPC|TP_DEBUG_INITIALIZE|
TP_DEBUG_RESOURCES|TP_DEBUG_BREAKPOINT|TP_DEBUG_INFOLEVEL_1;
BOOLEAN TpAssert = TRUE;
#endif // DBG
NDIS_PHYSICAL_ADDRESS HighestAddress = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1);
//
// Driver Entry function
//
NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
// ----------
//
// Routine Description:
