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););
NTSTATUS NDIS_API DriverEntry(IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
{
// initialiae the driver
NDIS_PROTOCOL_CHARACTERISTICS ProtocolChar;
NDIS_STRING ProtoName = NDIS_STRING_CONST("EPACKET");
NDIS_STATUS Status;
// Because the driver can be loaded once for each Netcard on the system,
// and because DriverEntry is called each time, we must ensure that
// initialization is performed only once.
if (GlobalDeviceExtension != NULL)
return NDIS_STATUS_SUCCESS;
NdisAllocateMemory((PVOID *)&GlobalDeviceExtension, sizeof(DEVICE_EXTENSION), 0, -1 );
if (GlobalDeviceExtension == NULL)
return NDIS_STATUS_RESOURCES;
NdisZeroMemory((UCHAR*)GlobalDeviceExtension, sizeof(DEVICE_EXTENSION));
NdisZeroMemory((UCHAR*)&ProtocolChar, sizeof(NDIS_PROTOCOL_CHARACTERISTICS));
ProtocolChar.MajorNdisVersion = 0x03;
ProtocolChar.MinorNdisVersion = 0x0a;
ProtocolChar.Reserved = 0;
ProtocolChar.OpenAdapterCompleteHandler = PacketBindAdapterComplete;
ProtocolChar.CloseAdapterCompleteHandler = PacketUnbindAdapterComplete;
ProtocolChar.SendCompleteHandler = PacketSendComplete;
ProtocolChar.TransferDataCompleteHandler = PacketTransferDataComplete;
ProtocolChar.ResetCompleteHandler = PacketResetComplete;
ProtocolChar.RequestCompleteHandler = PacketRequestComplete;
ProtocolChar.ReceiveHandler = PacketReceiveIndicate;
ProtocolChar.ReceiveCompleteHandler = PacketReceiveComplete;
ProtocolChar.StatusHandler = PacketStatus;
ProtocolChar.StatusCompleteHandler = PacketStatusComplete;
ProtocolChar.BindAdapterHandler = PacketBindAdapter;
ProtocolChar.UnbindAdapterHandler = PacketUnbindAdapter;
ProtocolChar.UnloadProtocolHandler = PacketUnload;
ProtocolChar.Name = ProtoName;
NdisRegisterProtocol(&Status,
&GlobalDeviceExtension->NdisProtocolHandle,
&ProtocolChar,
sizeof(NDIS_PROTOCOL_CHARACTERISTICS));
if (Status != NDIS_STATUS_SUCCESS) {
NdisFreeMemory(GlobalDeviceExtension, sizeof(DEVICE_EXTENSION), 0);
return Status;
}
// initialize open list
InitializeListHead(&GlobalDeviceExtension->OpenList);
// initialize global device extension
GlobalDeviceExtension->DriverObject = DriverObject;
return Status;
}
NDIS_STATUS
ArcAllocatePackets(
IN PARC_FILTER Filter
)
/*++
Routine Description:
This routine allocates Receive packets for the filter database.
Arguments:
Filter - The filter db to allocate for.
Returns:
NDIS_STATUS_SUCCESS if any packet was allocated.
--*/
{
ULONG i;
PARC_PACKET Packet;
for (i = ARC_PACKET_ALLOCATION_UNIT; i != 0 ; i--) {
NdisAllocateMemory((PVOID)&Packet,
sizeof(ARC_PACKET),
0,
HighestAcceptableMax
);
if (Packet == NULL) {
if (i == ARC_BUFFER_ALLOCATION_UNIT) {
return(NDIS_STATUS_FAILURE);
}
return(NDIS_STATUS_SUCCESS);
}
NdisZeroMemory(Packet, sizeof(ARC_PACKET));
NdisReinitializePacket(&(Packet->TmpNdisPacket));
Packet->Next = Filter->FreePackets;
Filter->FreePackets = Packet;
}
return(NDIS_STATUS_SUCCESS);
}
/* 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);
}
VOID
NdisOpenConfiguration(
OUT PNDIS_STATUS Status,
OUT PNDIS_HANDLE ConfigurationHandle,
IN NDIS_HANDLE WrapperConfigurationContext
)
/*++
Routine Description:
This routine is used to open the parameter subkey of the
adapter registry tree.
Arguments:
Status - Returns the status of the request.
ConfigurationHandle - Returns a handle which is used in calls to
NdisReadConfiguration and NdisCloseConfiguration.
WrapperConfigurationContext - a handle pointing to an RTL_QUERY_REGISTRY_TABLE
that is set up for this driver's parameters.
Return Value:
None.
--*/
{
//
// Handle to be returned
//
PNDIS_CONFIGURATION_HANDLE HandleToReturn;
//
// Allocate the configuration handle
//
*Status = NdisAllocateMemory((PVOID*)&HandleToReturn,
sizeof(NDIS_CONFIGURATION_HANDLE),
0,
HighestAcceptableMax);
if (*Status == NDIS_STATUS_SUCCESS)
{
HandleToReturn->KeyQueryTable = ((PNDIS_WRAPPER_CONFIGURATION_HANDLE)WrapperConfigurationContext)->ParametersQueryTable;
HandleToReturn->ParameterList = NULL;
*ConfigurationHandle = (NDIS_HANDLE)HandleToReturn;
}
}
//
// 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));
}
PVOID
CMiniport::MemoryAllocate(
IN UINT cbMemory)
//
// Allocate a block of memory Length bytes long.
//
{
PVOID pMemory = NULL;
NDIS_STATUS Status;
Status = NdisAllocateMemory(&pMemory, cbMemory, 0, g_HighestAcceptableAddress);
if (Status == NDIS_STATUS_FAILURE) {
NDIS_DEBUG_PRINTF(ATH_LOG_ERR, "AR6K: ERROR - NdisAllocateMemory for %d bytes failed error = %x\n", cbMemory, Status);
}
return pMemory;
}
/* 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);
}
VOID
NdisMFreeSharedMemory(
IN NDIS_HANDLE MiniportAdapterHandle,
IN ULONG Length,
IN BOOLEAN Cached,
IN PVOID VirtualAddress,
IN NDIS_PHYSICAL_ADDRESS PhysicalAddress
)
{
PNDIS_MINIPORT_BLOCK Miniport = (PNDIS_MINIPORT_BLOCK)MiniportAdapterHandle;
if (CURRENT_IRQL < DISPATCH_LEVEL)
{
NdisFreeSharedMemory(MiniportAdapterHandle,
Length,
Cached,
VirtualAddress,
PhysicalAddress);
}
else if (ndisReferenceMiniport(Miniport))
{
PASYNC_WORKITEM pWorkItem = NULL;
// Allocate a work-item and queue it up to a worker thread
NdisAllocateMemory(&pWorkItem,
sizeof(ASYNC_WORKITEM),
0,
HighestAcceptableMax);
if (pWorkItem != NULL)
{
// Initialize the workitem and queue it up to a worker thread
pWorkItem->Miniport = Miniport;
pWorkItem->Length = Length;
pWorkItem->Cached = Cached;
pWorkItem->VAddr = VirtualAddress;
pWorkItem->PhyAddr = PhysicalAddress;
INITIALIZE_WORK_ITEM(&pWorkItem->ExWorkItem, ndisMQueuedFreeSharedHandler, pWorkItem);
QUEUE_WORK_ITEM(&pWorkItem->ExWorkItem, CriticalWorkQueue);
}
// What do we do now ?
}
}
PVOID
CMiniport::MemoryAllocate(
IN UINT cbMemory)
//
// Allocate a block of memory Length bytes long.
//
{
PVOID pMemory = NULL;
NDIS_STATUS Status;
Status = NdisAllocateMemory(&pMemory, cbMemory, 0, g_HighestAcceptableAddress);
if (Status == NDIS_STATUS_FAILURE) {
NDIS_DEBUG_PRINTF(ATH_LOG_ERR, "AR6K: ERROR - NdisAllocateMemory for %d bytes failed error = %x\n", cbMemory, Status);
logPrintf( (debugFileLog && debugErrorLog), "NdisAllocateMemory for %d bytes failed\r\n", cbMemory );
}
//RETAILMSG(1, (TEXT("builderd:ar6k2:MemoryAllocate = %x, %d\r\n"), (A_UINT32)pMemory, cbMemory));
return pMemory;
}
NDIS_STATUS
NdisMAllocateSharedMemoryAsync(
IN NDIS_HANDLE MiniportAdapterHandle,
IN ULONG Length,
IN BOOLEAN Cached,
IN PVOID Context
)
{
//
// Convert the handle to our internal structure.
//
PNDIS_MINIPORT_BLOCK Miniport = (PNDIS_MINIPORT_BLOCK) MiniportAdapterHandle;
PASYNC_WORKITEM pWorkItem = NULL;
// Allocate a workitem
if ((Miniport->SystemAdapterObject != NULL) &&
(Miniport->DriverHandle->MiniportCharacteristics.AllocateCompleteHandler != NULL))
{
NdisAllocateMemory(&pWorkItem,
sizeof(ASYNC_WORKITEM),
0,
HighestAcceptableMax);
}
if ((pWorkItem == NULL) ||
!ndisReferenceMiniport(Miniport))
{
if (pWorkItem != NULL)
NdisFreeMemory(pWorkItem, sizeof(ASYNC_WORKITEM), 0);
return NDIS_STATUS_FAILURE;
}
// Initialize the workitem and queue it up to a worker thread
pWorkItem->Miniport = Miniport;
pWorkItem->Length = Length;
pWorkItem->Cached = Cached;
pWorkItem->Context = Context;
INITIALIZE_WORK_ITEM(&pWorkItem->ExWorkItem, ndisMQueuedAllocateSharedHandler, pWorkItem);
QUEUE_WORK_ITEM(&pWorkItem->ExWorkItem, CriticalWorkQueue);
return NDIS_STATUS_PENDING;
}
PGPError
PMAddConfig(NDIS_HANDLE handle, PGPnetKernelConfig *pConfig)
{
PGPnetPMContext *pContext = (PGPnetPMContext*) handle;
NDIS_STATUS status;
DBG_FUNC("PMAddConfig")
DBG_ENTER();
/* if config doesn't exist, create memory for it */
if (!pContext->pConfig) {
#ifndef USERLAND_TEST
status = NdisAllocateMemory(&(pContext->pConfig),
sizeof(PGPnetKernelConfig),
0,
HighestAcceptableAddress);
if (status != NDIS_STATUS_SUCCESS)
return kPGPError_OutOfMemory;
#else
pContext->pConfig = malloc(sizeof(PGPnetKernelConfig));
if (!pContext->pConfig)
return kPGPError_OutOfMemory;
#endif /* USERLAND_TEST */
}
/* clear out anything there */
pgpClearMemory(pContext->pConfig, sizeof(PGPnetKernelConfig));
/* copy configuration values */
pContext->pConfig->bPGPnetEnabled = pConfig->bPGPnetEnabled;
pContext->pConfig->bAllowUnconfigHost = pConfig->bAllowUnconfigHost;
pContext->pConfig->bAttemptUnconfigHost = pConfig->bAttemptUnconfigHost;
DBG_LEAVE(kPGPError_NoErr);
return kPGPError_NoErr;
}
/* 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);
}
BOOLEAN
ArcCreateFilter(
IN PNDIS_MINIPORT_BLOCK Miniport,
IN ARC_FILTER_CHANGE FilterChangeAction,
IN ARC_DEFERRED_CLOSE CloseAction,
UCHAR AdapterAddress,
IN PNDIS_SPIN_LOCK Lock,
OUT PARC_FILTER *Filter
)
/*++
Routine Description:
This routine is used to create and initialize the Arcnet filter database.
Arguments:
Miniport - Pointer to the mini-port object.
ChangeAction - Action routine to call when a binding sets or clears
a particular filter class and it is the first or only binding using
the filter class.
CloseAction - This routine is called if a binding closes while
it is being indicated to via NdisIndicateReceive. It will be
called upon return from NdisIndicateReceive.
AdapterAddress - the address of the adapter associated with this filter
database.
Lock - Pointer to the lock that should be held when mutual exclusion
is required.
Filter - A pointer to an ARC_FILTER. This is what is allocated and
created by this routine.
Return Value:
If the function returns false then one of the parameters exceeded
what the filter was willing to support.
--*/
{
PARC_FILTER LocalFilter;
NDIS_STATUS AllocStatus;
//
// Allocate the database and it's associated arrays.
//
AllocStatus = NdisAllocateMemory(&LocalFilter, sizeof(ARC_FILTER), 0, HighestAcceptableMax);
*Filter = LocalFilter;
if (AllocStatus != NDIS_STATUS_SUCCESS) {
return FALSE;
}
NdisZeroMemory(
LocalFilter,
sizeof(ARC_FILTER)
);
LocalFilter->Miniport = Miniport;
LocalFilter->FreeBindingMask = (ULONG)(-1);
LocalFilter->OpenList = NULL;
LocalFilter->AdapterAddress = AdapterAddress ;
LocalFilter->Lock = Lock;
LocalFilter->FilterChangeAction = FilterChangeAction;
LocalFilter->CloseAction = CloseAction;
NdisAllocateBufferPool(
&AllocStatus,
(PNDIS_HANDLE)(&LocalFilter->ReceiveBufferPool),
ARC_RECEIVE_BUFFERS
);
if (AllocStatus != NDIS_STATUS_SUCCESS) {
NdisFreeMemory(LocalFilter, sizeof(ARC_FILTER), 0);
return(FALSE);
}
ArcReferencePackage();
return TRUE;
}
NTSTATUS
PacketAllocate(
IN PSERVICE_POINT ServicePoint,
IN ULONG PacketLength,
IN PDEVICE_CONTEXT DeviceContext,
IN UCHAR Type,
IN PUCHAR CopyData,
IN ULONG CopyDataLength,
IN PIO_STACK_LOCATION IrpSp,
OUT PNDIS_PACKET *Packet
)
{
NTSTATUS status;
PUCHAR packetData;
PNDIS_BUFFER pNdisBuffer;
PNDIS_BUFFER pNdisBufferData;
PNDIS_PACKET packet;
USHORT port;
DebugPrint(3, ("PacketAllocate, PacketLength = %d, Numberofpackets = %d\n", PacketLength, NumberOfPackets));
// if(ServicePoint && ServicePoint->SmpState == SMP_SYN_RECV)
// return STATUS_INSUFFICIENT_RESOURCES;
if(DeviceContext == NULL) {
DebugPrint(1, ("[LPX]PacketAllocate: DeviceContext is NULL!!!\n"));
return STATUS_INVALID_PARAMETER;
}
if(DeviceContext->LpxPacketPool == NULL) {
DebugPrint(1, ("[LPX]PacketAllocate: DeviceContext->LpxPacketPool is NULL!!!\n"));
return STATUS_INVALID_PARAMETER;
}
NdisAllocatePacket(&status, &packet, DeviceContext->LpxPacketPool);
if(status != NDIS_STATUS_SUCCESS) {
DebugPrint(1, ("[LPX]PacketAllocate: NdisAllocatePacket Failed!!!\n"));
return STATUS_INSUFFICIENT_RESOURCES;
}
status = NdisAllocateMemory(
&packetData,
PacketLength
);
if(status != NDIS_STATUS_SUCCESS) {
DebugPrint(1, ("[LpxSmp]PacketAllocate: Can't Allocate Memory packet.\n"));
NdisFreePacket(packet);
*Packet = NULL;
return status;
}
NdisAllocateBuffer(
&status,
&pNdisBuffer,
DeviceContext->LpxBufferPool,
packetData,
PacketLength
);
if(!NT_SUCCESS(status)) {
NdisFreePacket(packet);
*Packet = NULL;
NdisFreeMemory(packetData);
DebugPrint(1, ("[LPX]PacketAllocate: Can't Allocate Buffer!!!\n"));
return status;
}
switch(Type) {
case SEND_TYPE:
if(ServicePoint && &ServicePoint->SmpContext) {
RtlCopyMemory(&packetData[0],
ServicePoint->DestinationAddress.Node,
ETHERNET_ADDRESS_LENGTH
);
RtlCopyMemory(&packetData[ETHERNET_ADDRESS_LENGTH],
ServicePoint->SourceAddress.Node,
ETHERNET_ADDRESS_LENGTH
);
port = HTONS(ETH_P_LPX);
RtlCopyMemory(&packetData[ETHERNET_ADDRESS_LENGTH*2],
&port, //&ServicePoint->DestinationAddress.Port,
2
);
}
if(CopyDataLength) {
NdisAllocateBuffer(
&status,
&pNdisBufferData,
DeviceContext->LpxBufferPool,
CopyData,
CopyDataLength
);
if(!NT_SUCCESS(status)) {
NdisFreePacket(packet);
*Packet = NULL;
NdisFreeMemory(packetData);
DebugPrint(1, ("[LPX]PacketAllocate: Can't Allocate Buffer For CopyData!!!\n"));
return status;
}
NdisChainBufferAtFront(packet, pNdisBufferData);
}
break;
case RECEIVE_TYPE:
NdisMoveMappedMemory(
packetData,
CopyData,
CopyDataLength
);
break;
}
// RESERVED(packet)->ServicePoint = ServicePoint;
RESERVED(packet)->Cloned = 0;
RESERVED(packet)->IrpSp = IrpSp;
RESERVED(packet)->Type = Type;
RESERVED(packet)->LpxSmpHeader = NULL;
if(IrpSp == NULL) {
DebugPrint(2, ("[LPX] PacketAllocate: No IrpSp\n")) ;
}
NdisChainBufferAtFront(packet, pNdisBuffer);
InterlockedIncrement(&NumberOfPackets);
*Packet = packet;
return STATUS_SUCCESS;
}
/*
* This function add the adapter names to the list
*
*/
NDIS_STATUS PKTBindNames ()
{
HKEY hKeyComm;
HKEY hKeyAdap;
HKEY hKeyLink;
DWORD dwCnt = 0;
DWORD dwIndex = 0;
WCHAR chName[512];
DWORD dwName = 512;
PADAPTER_NAME pADName;
// open the comm key
if (ERROR_SUCCESS != RegOpenKeyEx (HKEY_LOCAL_MACHINE, L"Comm", 0,
0, &hKeyComm)) {
return NDIS_STATUS_FAILURE;
}
// enumerate all the sub keys in the comm
while (ERROR_SUCCESS == RegEnumKeyEx (hKeyComm, dwIndex++, chName,
&dwName, NULL, NULL, NULL, NULL)) {
// open the adapter key
if (ERROR_SUCCESS == RegOpenKeyEx (hKeyComm, chName, 0,
0, &hKeyAdap)) {
// open the linkage key
if (ERROR_SUCCESS == RegOpenKeyEx (hKeyAdap, L"Linkage", 0,
0, &hKeyLink))
{
dwName = 512;
// query the route value
if (ERROR_SUCCESS == RegQueryValueEx (hKeyLink, L"Route", NULL,
NULL, (LPBYTE) chName, &dwName))
{
// store the name in the list
// we can also get the detailed name here
// may be in next version
// allocate the memory that describes the adapter
NdisAllocateMemory ((PVOID*) &pADName, sizeof (ADAPTER_NAME), 0 , NDIS_ADDR_M1);
if (pADName == NULL) {
return NDIS_STATUS_FAILURE;
}
// copy the device name in the adapter name structure
pADName->ndstrDeviceName.Length = wcslen (chName) * 2;
pADName->ndstrDeviceName.MaximumLength = wcslen (chName) * 2 + 2;
pADName->ndstrDeviceName.Buffer = pADName->chDeviceName;
wcsncpy (pADName->chDeviceName, chName, 32);
// insert the adapter name in the global data structure
InsertTailList (&g_pDeviceExtension->listAdapterNames, &pADName->ListElement);
dwCnt++;
}
// close linkage
RegCloseKey (hKeyLink);
}
// close the adapter key
RegCloseKey (hKeyAdap);
}
dwName = 512;
}
// close the comms key
RegCloseKey (hKeyComm);
if (dwCnt == 0) {
SetLastError (ERROR_BAD_NET_NAME);
return NDIS_STATUS_FAILURE;
}
return NDIS_STATUS_SUCCESS;
}
BOOL PKT_IOControl (DWORD dwContext, DWORD dwCode, PBYTE pBufIn,
DWORD dwLenIn, PBYTE pBufOut, DWORD dwLenOut, PDWORD pdwActualOut)
{
BOOL bRet = TRUE;
PWCHAR bpf_prog;
PNDIS_STRING pstrAName;
POPEN_INSTANCE pOpenInst = NULL;
PUCHAR pTempBuf;
ULONG nValue;
// if the context is different then return false
if (dwContext != PKT_FILE_HANDLE) {
SAFE_SET (pdwActualOut, 0);
return FALSE;
}
// if the code is not to open the adapter then there
// should be an open instance of the adapter
if (dwCode != PIOC_OPEN_ADAPTER &&
dwCode != PIOC_GET_MACNAME) {
// get the open instance handle
pOpenInst = g_pDeviceExtension->pOpenInstance;
if (pOpenInst == NULL) {
return FALSE;
}
}
switch (dwCode) {
// open the adapter message
case PIOC_OPEN_ADAPTER:
// get the adapter NDIS name
pstrAName = PKTGetNDISAdapterName ((PWCHAR)pBufIn, dwLenIn);
if (pstrAName == NULL) {
return FALSE;
}
// open the adapter
if (! PKTOpenAdapter (pstrAName)) {
bRet = FALSE;
}
break;
// close the adapter message
case PIOC_CLOSE_ADAPTER:
bRet = PKTCloseAdapter (pOpenInst);
break;
// function to set new bpf filter
case PIOC_SETF:
// free the previous buffer if selected
if (pOpenInst->bpfprogram != NULL) {
NdisFreeMemory (pOpenInst->bpfprogram, pOpenInst->bpfprogramlen, 0);
pOpenInst->bpfprogram = NULL;
pOpenInst->bpfprogramlen = 0;
}
// get the pointer to the new program
bpf_prog = (PWCHAR) pBufIn;
// before accepting the program we must check that it's valid
// otherwise, a bogus program could easily crash the driver
pOpenInst->bpfprogramlen = dwLenIn;
if (bpf_validate ((struct bpf_insn*)bpf_prog,
pOpenInst->bpfprogramlen/sizeof(struct bpf_insn)) == 0) {
pOpenInst->bpfprogramlen = 0;
pOpenInst->bpfprogram = NULL;
return FALSE; // filter not accepted
}
// allocate the memory to contain the new filter program*/
if (NdisAllocateMemory(&pOpenInst->bpfprogram, pOpenInst->bpfprogramlen,
0, NDIS_ADDR_M1) == NDIS_STATUS_FAILURE) {
pOpenInst->bpfprogramlen = 0;
pOpenInst->bpfprogram = NULL;
return FALSE;
}
// copy the program in the new buffer
NdisMoveMemory (pOpenInst->bpfprogram, bpf_prog, pOpenInst->bpfprogramlen);
// reset the buffer that could contain packets that don't match the filter
pOpenInst->Bhead = 0;
pOpenInst->Btail = 0;
pOpenInst->BLastByte= 0;
// return the accepted buffer len
SAFE_SET(pdwActualOut, pOpenInst->bpfprogramlen);
break;
// function to set the internal buffer size
case PIOC_SET_BUFFER_SIZE:
// get the size to allocate
nValue = ((PULONG)pBufIn)[0];
// free the old buffer
if (pOpenInst->Buffer != NULL) {
NdisFreeMemory (pOpenInst->Buffer, pOpenInst->BufSize, 0);
}
pOpenInst->Buffer = NULL;
// allocate the new buffer
if (nValue > 0) {
NdisAllocateMemory ((PVOID*)&pTempBuf, nValue, 0, NDIS_ADDR_M1);
if (pTempBuf == NULL) {
pOpenInst->BufSize = 0;
return FALSE;
}
pOpenInst->Buffer = pTempBuf;
}
pOpenInst->Bhead = 0;
pOpenInst->Btail = 0;
pOpenInst->BLastByte= 0;
pOpenInst->BufSize = (UINT)nValue;
SAFE_SET(pdwActualOut, nValue);
break;
// for sharing the event from the user
case PIOC_EVNAME:
if (pBufOut == NULL || dwLenOut < 32) {
SAFE_SET(pdwActualOut, 0);
bRet = FALSE;
} else {
wcscpy ((PWCHAR)pBufOut, SH_EVENT_NAME);
SAFE_SET (pdwActualOut, wcslen (SH_EVENT_NAME));
}
break;
// set read timeout function
case PIOC_SRTIMEOUT:
pOpenInst->TimeOut = ((PULONG)pBufIn)[0];
SAFE_SET(pdwActualOut, pOpenInst->TimeOut);
break;
// resets the adapter instance
case PIOC_RESET:
bRet = PKTReset (pOpenInst);
break;
// requests of different type
case PIOC_SETOID:
case PIOC_QUERYOID:
return PKTRequest (pOpenInst, dwCode, pBufIn, dwLenIn, pBufOut, dwLenOut, pdwActualOut);
break;
// read packets
case PIOC_READ_PACKET:
return PKTRead (pOpenInst, pBufOut, dwLenOut, pdwActualOut);
break;
// write packets
case PIOC_WRITE_PACKET:
return PKTWrite (pOpenInst, pBufIn, dwLenIn, pdwActualOut);
break;
// read mac name
case PIOC_GET_MACNAME:
*pdwActualOut = PKTGetMacNameList ((PWCHAR)pBufOut, dwLenOut);
break;
// minimum number of bytes to copy
case PIOC_SMINTOCOPY:
pOpenInst->MinToCopy = ((PULONG)pBufIn)[0];
SAFE_SET(pdwActualOut, 0);
break;
// unknown function code. set out length to 0 and return true
default:
bRet = FALSE;
SAFE_SET(pdwActualOut, 0);
break;
}
return bRet;
}
/*
* This routine initializes the packet driver. The function is called by the
* driver manager automatically when RegisterDevice function is called.
*
* Arguments
* dwContext - Specifies a pointer to a string containing the
* registry path to the active key for the stream
* interface driver.
*
* Return Value
* The function return the device context to be called with other stream
* function like _Open, _Close, etc. If the initialization fails then the
* function returns NULL. If the function returns 0 then the driver is not
* loaded by the device manager.
*
*/
DWORD PKT_Init(DWORD dwContext)
{
NDIS_PROTOCOL_CHARACTERISTICS ProtocolChar;
NDIS_STRING ProtoName = PROTOCOL_NAME;
NDIS_STATUS Status;
// Allocate memory for the global device extension
NdisAllocateMemory ((PVOID*) &g_pDeviceExtension, sizeof (DEVICE_EXTENSION),
0, NDIS_ADDR_M1);
if (g_pDeviceExtension == NULL) {
return 0;
}
// reset the global device extension object
NdisZeroMemory (g_pDeviceExtension, sizeof (DEVICE_EXTENSION));
// reset the protocol characteristics object
NdisZeroMemory (&ProtocolChar, sizeof (NDIS_PROTOCOL_CHARACTERISTICS));
// Initialize the protocol char structure
ProtocolChar.MajorNdisVersion = 0x03;
ProtocolChar.MinorNdisVersion = 0x00;
ProtocolChar.Reserved = 0;
ProtocolChar.Name = ProtoName;
ProtocolChar.BindAdapterHandler = PacketBindAdapter;
ProtocolChar.CloseAdapterCompleteHandler = PacketCloseAdapterComplete;
ProtocolChar.OpenAdapterCompleteHandler = PacketOpenAdapterComplete;
ProtocolChar.ReceiveHandler = PacketReceive;
ProtocolChar.ReceiveCompleteHandler = PacketReceiveComplete;
ProtocolChar.RequestCompleteHandler = PacketRequestComplete;
ProtocolChar.ResetCompleteHandler = PacketResetComplete;
ProtocolChar.StatusHandler = PacketStatus;
ProtocolChar.StatusCompleteHandler = PacketStatusComplete;
ProtocolChar.TransferDataCompleteHandler = PacketTransferDataComplete;
ProtocolChar.UnbindAdapterHandler = PacketUnbindAdapter;
ProtocolChar.SendCompleteHandler = PacketWriteComplete;
// Registed the protocol handler
NdisRegisterProtocol (&Status, &g_pDeviceExtension->NdisProtocolHandle,
&ProtocolChar, sizeof(NDIS_PROTOCOL_CHARACTERISTICS));
// Check the return value
if (Status != NDIS_STATUS_SUCCESS) {
NdisFreeMemory (g_pDeviceExtension, sizeof (DEVICE_EXTENSION), 0);
return 0;
}
// Initialize the list headers
InitializeListHead (&g_pDeviceExtension->listAdapterNames);
// Initialize the open instance pointer
g_pDeviceExtension->pOpenInstance = NULL;
// Check for the available adapters to bind with
// not reqd for win ce. the os call packet bind adapter for
// every adapters installed in the system
if (PKTBindNames () != NDIS_STATUS_SUCCESS) {
NdisFreeMemory (g_pDeviceExtension, sizeof (DEVICE_EXTENSION), 0);
g_pDeviceExtension = NULL;
return 0;
}
// Status is generally succes`s over here
return PKT_DEVICE_CONTEXT;
}
VOID NDIS_API PacketBindAdapter(OUT PNDIS_STATUS pStatus,
IN NDIS_HANDLE BindAdapterContext,
IN PNDIS_STRING pAdapterName,
IN PVOID SystemSpecific1,
IN PVOID SystemSpecific2)
{
// bind this driver to a NIC
POPEN_INSTANCE oiNew;
NDIS_STATUS ErrorStatus, AllocStatus;
UINT Medium;
NDIS_MEDIUM MediumArray = NdisMedium802_3;
UINT i;
// allocate some memory for the open structure
NdisAllocateMemory((PVOID *)&oiNew, sizeof(OPEN_INSTANCE), 0, -1);
if (oiNew == NULL) { // not enough memory
*pStatus = NDIS_STATUS_RESOURCES;
return;
}
NdisZeroMemory((PVOID)oiNew, sizeof(OPEN_INSTANCE));
// Save Binding Context
oiNew->BindAdapterContext = BindAdapterContext;
// Save the device handle
oiNew->hDevice = (DWORD)SystemSpecific1;
// Allocate a packet pool for our xmit and receive packets
NdisAllocatePacketPool(&AllocStatus,
&(oiNew->PacketPool),
TRANSMIT_PACKETS,
sizeof(PACKET_RESERVED));
if (AllocStatus != NDIS_STATUS_SUCCESS) { // not enough memory
NdisFreeMemory(oiNew, sizeof(OPEN_INSTANCE), 0);
*pStatus = NDIS_STATUS_RESOURCES;
return;
}
// Allocate a buffer pool for our xmit and receive buffers
NdisAllocateBufferPool(&AllocStatus, &(oiNew->BufferPool), TRANSMIT_PACKETS);
if (AllocStatus != NDIS_STATUS_SUCCESS) { // not enough memory
NdisFreeMemory(oiNew, sizeof(OPEN_INSTANCE), 0);
*pStatus = NDIS_STATUS_RESOURCES;
return;
}
// list to hold irp's that want to reset the adapter
NdisAllocateSpinLock(&oiNew->ResetSpinLock);
InitializeListHead(&oiNew->ResetIrpList);
// Initialize list for holding pending read requests
NdisAllocateSpinLock(&oiNew->RcvQSpinLock);
InitializeListHead(&oiNew->RcvList);
// Initialize the request list
NdisAllocateSpinLock(&oiNew->RequestSpinLock);
InitializeListHead(&oiNew->RequestList);
// link up the request stored in our open block
for (i = 0; i < MAX_REQUESTS; i++) {
// Braces are required as InsertTailList macro has multiple statements in it
InsertTailList(&oiNew->RequestList, &oiNew->Requests[i].Reserved.ListElement);
}
// Try to open the MAC
NdisOpenAdapter(pStatus, &ErrorStatus, &oiNew->AdapterHandle, &Medium, &MediumArray, 1,
GlobalDeviceExtension->NdisProtocolHandle, oiNew, pAdapterName, 0, NULL);
// Save the status returned by NdisOpenAdapter for completion routine
oiNew->Status = *pStatus;
switch (*pStatus) {
case NDIS_STATUS_PENDING:
break;
case NDIS_STATUS_SUCCESS:
ErrorStatus = NDIS_STATUS_SUCCESS;
// fall through to completion routine with oiNew->Status
// set to !NDIS_STATUS_PENDING
default:
PacketBindAdapterComplete(oiNew, *pStatus, ErrorStatus);
break;
}
}
/*
Function Name : LPC3xxx_MiniportInitialize
Description :
Called by the NDIS Wrapper to initialize the adapter.
0. Verify the Adapter v/s the driver
1. Create and initilize the adapter structure
2. Read and load the registry settings
3. Initialize the chip
4. Establish the link
Parameters :
PNDIS_STATUS OpenErrorStatus - Additional error status, if return value is error
PUINT MediumIndex - specifies the medium type the driver or its network adapter uses
PNDIS_MEDIUM MediumArray - Specifies an array of NdisMediumXXX values from which
MiniportInitialize selects one that its network adapter supports
or that the driver supports as an interface to higher-level drivers.
UINT MediumArraySize - Specifies the number of elements at MediumArray
NDIS_HANDLE AdapterHandle - Specifies a handle identifying the miniport’s network adapter,
which is assigned by the NDIS library
NDIS_HANDLE ConfigurationContext - Specifies a handle used only during initialization for
calls to NdisXXX configuration and initialization functions
Return Value :
NDIS_STATUS Status
*/
NDIS_STATUS LPC3xxx_MiniportInitialize( PNDIS_STATUS pOpenErrorStatus,
PUINT pMediumIndex,
PNDIS_MEDIUM pMediumArray,
UINT nMediumArraySize,
NDIS_HANDLE hAdapterHandle,
NDIS_HANDLE hConfigurationContext)
{
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
UINT nArrayIndex;
PMINIPORT_ADAPTER pAdapter;
PHYSICAL_ADDRESS pa;
DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS ==> MiniportInitialize\r\n")));
//Check for the supported 802.3 media
for(nArrayIndex = 0; nArrayIndex < nMediumArraySize; nArrayIndex++)
{
if(NdisMedium802_3 == pMediumArray[nArrayIndex])
break;
}
if(nArrayIndex == nMediumArraySize)
{
DEBUGMSG(ZONE_INIT | ZONE_ERROR, (TEXT("LPC3xxx NDIS : ERROR - No Supported Media types \r\n")));
DEBUGMSG(ZONE_INIT | ZONE_ERROR, (TEXT("LPC3xxx NDIS <== MiniportInitialize \r\n")));
return(NDIS_STATUS_UNSUPPORTED_MEDIA);
}
*pMediumIndex = nArrayIndex;
//Allocate memory for the adapter structure
Status = NdisAllocateMemory((PVOID *) &pAdapter, MINIPORT_ADAPTER_SIZE, 0, HighestAcceptedMax);
if(Status != NDIS_STATUS_SUCCESS)
{
DEBUGMSG(ZONE_INIT | ZONE_ERROR, (TEXT("LPC3xxx NDIS: ERROR - No Memory for Adapter Structure!\r\n")));
DEBUGMSG(ZONE_INIT | ZONE_ERROR, (TEXT("LPC3xxx NDIS <== MiniPort Initialize\r\n")));
return(NDIS_STATUS_RESOURCES);
}
NdisZeroMemory(pAdapter, MINIPORT_ADAPTER_SIZE); //Clean it up
//Set up the default values
pAdapter->hAdapter = hAdapterHandle;
pAdapter->eState = INITIALIZING_STATE;
pAdapter->IsInterruptSet = FALSE;
pAdapter->IsPortRegistered = FALSE;
pAdapter->dwIRQNumber = -1;
pAdapter->bMediaConnected = FALSE;
pAdapter->bAutoNeg = TRUE; // Autoneg per default (overriden by registry settings)
pAdapter->bFullDuplex = TRUE; // Full duplex per default
pAdapter->b100Mbps = TRUE; // 100 Mbps per default
pAdapter->bRMII = TRUE; // RMII interface per default
//Setup Receive control Register
pAdapter->bPerfectMatch = TRUE; // We want to receive the frames for this station
pAdapter->bPromiscuous = FALSE; // Not in Promescuous mode per default
pAdapter->bRxBroadcast = TRUE; // We do forward the broadcasted frames (DHCP required at least)
pAdapter->bRxMulticastHash = TRUE; // We forward matched multicast frames
pAdapter->bRxMulticastAll = FALSE; // We do not forward all multicast frames
pAdapter->bRxUnicastHash = TRUE; // We do not forward matched unicast frames
pAdapter->bRxUnicastAll = TRUE; // We do not forward all unicast frames
pAdapter->dwBufferPhyAddr = 0;
pAdapter->dwTxStrides = 0;
pAdapter->dwRxStrides = 0;
pAdapter->dwControllerAddress = 0;
pAdapter->pEMACRegs = NULL;
pAdapter->dwEMACBuffersSize = 0;
pAdapter->pPATXDesc = 0;
pAdapter->pPARXDesc = 0;
pAdapter->pPATXBuffer = 0;
pAdapter->pPARXBuffer = 0;
pAdapter->pPATXStatus = 0;
pAdapter->pPARXStatus = 0;
pAdapter->pVAEMACBuffers= NULL;
pAdapter->pVATXDesc = NULL;
pAdapter->pVARXDesc = NULL;
pAdapter->pVATXStatus = NULL;
pAdapter->pVARXStatus = NULL;
//Allocate memory for the LookAhead buffer
pAdapter->dwLookAheadBufferSize = MAX_FRAME_SIZE;
Status = NdisAllocateMemory((PVOID *) &pAdapter->pVALookAheadBuffer, pAdapter->dwLookAheadBufferSize, 0, HighestAcceptedMax);
if(Status != NDIS_STATUS_SUCCESS)
{
DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS: ERROR - No Memory for LookAhead buffer!\r\n")));
DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS <== MiniPort Initialize\r\n")));
BackOut(pAdapter);
return(NDIS_STATUS_RESOURCES);
}
NdisZeroMemory(pAdapter->pVALookAheadBuffer, pAdapter->dwLookAheadBufferSize); //Clean it up
pAdapter->MACAddress[0] = 0x02;
pAdapter->MACAddress[1] = 0x03;
pAdapter->MACAddress[2] = 0x04;
pAdapter->MACAddress[3] = 0x06;
pAdapter->MACAddress[4] = 0x06;
pAdapter->MACAddress[5] = 0x08;
//Get the adapter information from the registry
Status = GetRegistrySettings(pAdapter, hConfigurationContext);
if(Status != NDIS_STATUS_SUCCESS)
{
DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS: ERROR - Configure Adapter failed!\r\n")));
DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS <== MiniPort Initialize\r\n")));
BackOut(pAdapter);
return(NDIS_STATUS_FAILURE);
}
// Allocate the memory for Buffers
// Computing required space
pAdapter->dwEMACBuffersSize = pAdapter->dwRxStrides * ( sizeof(LPCS_ETH_DESC)
+ sizeof(LPCS_ETH_RX_STATUS)
+ MAX_FRAME_SIZE)
+ pAdapter->dwTxStrides * ( sizeof(LPCS_ETH_DESC)
+ sizeof(LPCS_ETH_TX_STATUS)
+ MAX_FRAME_SIZE);
// Allocating space
pAdapter->pVAEMACBuffers = MapRegisters (pAdapter->dwBufferPhyAddr,
pAdapter->dwEMACBuffersSize);
if(pAdapter->pVAEMACBuffers == NULL)
{
RETAILMSG(1, (TEXT("LPC3xxx NDIS:ERROR : Can't Allocate Buffer!\r\n")));
BackOut(pAdapter);
DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS:<== MiniPort Initialize FAILED !!\r\n")));
return(NDIS_STATUS_RESOURCES);
}
DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS:Allocated DMA Buffers Successfully!\r\n")));
// Splitting allocated buffers into smaller areas
// Physical Addresses
pAdapter->pPARXDesc = pAdapter->dwBufferPhyAddr;
pAdapter->pPARXStatus = pAdapter->pPARXDesc + pAdapter->dwRxStrides * sizeof(LPCS_ETH_DESC);
pAdapter->pPATXDesc = pAdapter->pPARXStatus + pAdapter->dwRxStrides * sizeof(LPCS_ETH_RX_STATUS);
pAdapter->pPATXStatus = pAdapter->pPATXDesc + pAdapter->dwTxStrides * sizeof(LPCS_ETH_DESC);
pAdapter->pPARXBuffer = pAdapter->pPATXStatus + pAdapter->dwTxStrides * sizeof(LPCS_ETH_TX_STATUS);
pAdapter->pPATXBuffer = pAdapter->pPARXBuffer + pAdapter->dwRxStrides * MAX_FRAME_SIZE;
// Virtual Addresses
pAdapter->pVARXDesc = pAdapter->pVAEMACBuffers;
pAdapter->pVARXStatus = (PVOID)((DWORD)pAdapter->pVARXDesc + pAdapter->dwRxStrides * sizeof(LPCS_ETH_DESC));
pAdapter->pVATXDesc = (PVOID)((DWORD)pAdapter->pVARXStatus + pAdapter->dwRxStrides * sizeof(LPCS_ETH_RX_STATUS));
pAdapter->pVATXStatus = (PVOID)((DWORD)pAdapter->pVATXDesc + pAdapter->dwTxStrides * sizeof(LPCS_ETH_DESC));
pAdapter->pVARXBuffer = (PVOID)((DWORD)pAdapter->pVATXStatus + pAdapter->dwTxStrides * sizeof(LPCS_ETH_TX_STATUS));
pAdapter->pVATXBuffer = (PVOID)((DWORD)pAdapter->pVARXBuffer + pAdapter->dwRxStrides * MAX_FRAME_SIZE);
// Allocating the TX Packet buffer
Status = NdisAllocateMemory((PVOID *) &pAdapter->pTXPackets, sizeof(TX_PACKET) * pAdapter->dwTxStrides, 0, HighestAcceptedMax);
if(Status != NDIS_STATUS_SUCCESS)
{
DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS: ERROR - No Memory for TXBuffers buffer!\r\n")));
DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS <== MiniPort Initialize\r\n")));
BackOut(pAdapter);
return(NDIS_STATUS_RESOURCES);
}
NdisZeroMemory(pAdapter->pTXPackets, sizeof(TX_PACKET) * pAdapter->dwTxStrides); //Clean it up
//Register the interrupt
NdisMSetAttributes(pAdapter->hAdapter, (NDIS_HANDLE) pAdapter, TRUE, NdisInterfaceInternal);
Status = NdisMRegisterInterrupt(&pAdapter->InterruptInfo,
pAdapter->hAdapter,
pAdapter->dwIRQNumber,
0,
TRUE,
FALSE,
NdisInterruptLatched);
if(Status != NDIS_STATUS_SUCCESS)
{
DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS : ERROR - Can't Attach to Interrupt!\r\n")));
BackOut(pAdapter);
DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS:<== MiniPort Initialize\r\n")));
return(Status);
}
else
DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS: Interrupt Registered !!! \r\n")));
pAdapter->IsInterruptSet = TRUE;
//Register the IOBase address. Modify this code according to the platform
Status = NdisMRegisterIoPortRange((PVOID *) &(pAdapter->pEMACRegs),
pAdapter->hAdapter,
pAdapter->dwControllerAddress,
sizeof(ETHERNET_REGS_T));
if(Status != NDIS_STATUS_SUCCESS)
{
RETAILMSG(1, (TEXT("LAN91C9111 : ERROR - Can't Register I/O Port Range!\r\n")));
DEBUGMSG(ZONE_INIT, (TEXT("LAN91C9111 <== MiniPort Initialize\r\n")));
BackOut(pAdapter);
return(NDIS_STATUS_RESOURCES);
}
pAdapter->IsPortRegistered = TRUE;
//EnablePeriphClock(ETHERNET);
pa.QuadPart = CLK_PM_BASE;
n_pCLKPWRRegs = (CLKPWR_REGS_T *)
MmMapIoSpace(pa, sizeof (CLKPWR_REGS_T), FALSE);
if (n_pCLKPWRRegs == NULL)
{
RETAILMSG(1, (_T("LCD: lpc32xx_hw_init: Critcal error: cannot map registers!\r\n")));
MmUnmapIoSpace(n_pCLKPWRRegs, sizeof(CLKPWR_REGS_T));
return;
}
n_pCLKPWRRegs->clkpwr_macclk_ctrl = CLKPWR_MACCTRL_HRCCLK_EN|
CLKPWR_MACCTRL_MMIOCLK_EN|
CLKPWR_MACCTRL_DMACLK_EN|
CLKPWR_MACCTRL_USE_RMII_PINS;
// // Initialize Tx and Rx DMA Descriptors
//DEBUGMSG(ZONE_INIT, (L"LPC_EthInit: Initializing Descriptor engine\r\n"));
//EMAC_InitEngine(pAdapter);
if(!HardReset(pAdapter))
{
return NDIS_STATUS_FAILURE;
}
DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS <== MiniportInitialize \r\n")));
//Ready
return NDIS_STATUS_SUCCESS;
}
NDIS_STATUS
LtInitOpenAdapter(
OUT PNDIS_STATUS OperErrorStatus,
OUT NDIS_HANDLE *MacBindingHandle,
OUT PUINT SelectedMediumIndex,
IN PNDIS_MEDIUM MediumArray,
IN UINT MediumArraySize,
IN NDIS_HANDLE NdisBindingContext,
IN NDIS_HANDLE MacAdapterContext,
IN UINT OpenOptions,
IN PSTRING AddressingInformation
)
/*++
Routine Description:
Called by ndis when a protocol attempts to bind to us.
Arguments:
As described in the NDIS 3.0 Spec.
Return Value:
NDIS_STATUS_SUCCESSFUL : If ok, error otherwise
--*/
{
UINT i;
PLT_OPEN NewOpen;
PLT_ADAPTER Adapter = (PLT_ADAPTER)MacAdapterContext;
NDIS_STATUS StatusToReturn = NDIS_STATUS_SUCCESS;
// if the adapter is being closed, then do not allow the open
LtReferenceAdapter(Adapter, &StatusToReturn);
if (StatusToReturn != NDIS_STATUS_SUCCESS)
{
ASSERTMSG("LtInitOpenAdapter: Adapter is closing down!\n", 0);
return(StatusToReturn);
}
do
{
DBGPRINT(DBG_COMP_INIT, DBG_LEVEL_INFO,
("LtInitOpenAdapter Entered:\n"));
// Search thru the supplied MediumArray for NdisMediumLocalTalk
for (i = 0; i < MediumArraySize; i++)
{
if (MediumArray[i] == NdisMediumLocalTalk)
{
break;
}
}
if (i == MediumArraySize)
{
StatusToReturn = NDIS_STATUS_UNSUPPORTED_MEDIA;
break;
}
*SelectedMediumIndex = i;
// Allocate some space for the open binding.
NdisAllocateMemory(
(PVOID)&NewOpen,
(UINT)sizeof(LT_OPEN),
(UINT)0,
LtNdisPhyAddr);
if (NewOpen == NULL)
{
StatusToReturn = NDIS_STATUS_RESOURCES;
// NdisWriteErrorLogEntry();
TMPLOGERR();
break;
}
NdisZeroMemory(
NewOpen,
sizeof(LT_OPEN));
*MacBindingHandle = (NDIS_HANDLE)NewOpen;
NewOpen->NdisBindingContext = NdisBindingContext;
NewOpen->Flags |= BINDING_OPEN;
NewOpen->LtAdapter = Adapter;
// Set the creation reference
NewOpen->RefCount = 1;
InitializeListHead(&NewOpen->Linkage);
// Insert into adapter list and increment adapter open count.
NdisAcquireSpinLock(&Adapter->Lock);
InsertTailList(&Adapter->OpenBindings, &NewOpen->Linkage);
Adapter->OpenCount++;
NdisReleaseSpinLock(&Adapter->Lock);
} while (FALSE);
if (StatusToReturn != NDIS_STATUS_SUCCESS)
{
LtDeReferenceAdapter(Adapter);
}
return StatusToReturn;
}
NDIS_STATUS
LtInitRegisterAdapter(
IN NDIS_HANDLE LtMacHandle,
IN NDIS_HANDLE WrapperConfigurationContext,
IN PNDIS_STRING AdapterName,
IN NDIS_INTERFACE_TYPE BusType,
IN UCHAR SuggestedNodeId,
IN UINT IoBaseAddress,
IN UINT MaxAdapters,
IN NDIS_STATUS ConfigError
)
/*++
Routine Description:
This routine (and its interface) are not portable. They are
defined by the OS, the architecture, and the particular Lt
implementation.
This routine is responsible for the allocation of the datastructures
for the driver as well as any hardware specific details necessary
to talk with the device.
Arguments:
LtMacHandle : The handle given back to the mac from ndis when
the mac registered itself.
WrapperConfigurationContext
: configuration context passed in by NDIS in the AddAdapter
call.
AdapterName : The string containing the name to give to the device adapter.
BusType : The type of bus in use. (MCA, ISA, EISA ...)
IoBaseAddress : The base IO address of the card.
MaxAdapters : The maximum number of opens at any one time.
ConfigError : Error with the Config parameters if any.
Return Value:
NDIS_STATUS_SUCCESS : If successful, error otherwise.
--*/
{
// Pointer for the adapter root.
PLT_ADAPTER Adapter;
NDIS_STATUS Status, RefStatus;
NDIS_ERROR_CODE LogErrorCode;
// Holds information needed when registering the adapter.
NDIS_ADAPTER_INFORMATION AdapterInformation;
// Allocate the Adapter block.
NdisAllocateMemory(
(PVOID)&Adapter,
sizeof(LT_ADAPTER),
0,
LtNdisPhyAddr);
if (Adapter == NULL)
{
return(NDIS_STATUS_RESOURCES);
}
NdisZeroMemory(
Adapter,
sizeof(LT_ADAPTER));
Adapter->NdisMacHandle = LtMacHandle;
// Set up the AdapterInformation structure.
NdisZeroMemory (&AdapterInformation, sizeof(NDIS_ADAPTER_INFORMATION));
AdapterInformation.DmaChannel = 0;
AdapterInformation.Master = FALSE ;
AdapterInformation.Dma32BitAddresses = FALSE ;
AdapterInformation.AdapterType = BusType ;
AdapterInformation.PhysicalMapRegistersNeeded = 0;
AdapterInformation.MaximumPhysicalMapping = 0;
AdapterInformation.NumberOfPortDescriptors = 1 ;
AdapterInformation.PortDescriptors[0].InitialPort = IoBaseAddress;
AdapterInformation.PortDescriptors[0].NumberOfPorts = 4;
AdapterInformation.PortDescriptors[0].PortOffset = (PVOID *)(&(Adapter->MappedIoBaseAddr));
DBGPRINT(DBG_COMP_INIT, DBG_LEVEL_ERR,
("LtInitRegisterAdapter: IoBaseAddr %lx\n", IoBaseAddress));
// Register the adapter with NDIS.
if ((Status = NdisRegisterAdapter(
&Adapter->NdisAdapterHandle,
Adapter->NdisMacHandle,
Adapter,
WrapperConfigurationContext,
AdapterName,
&AdapterInformation)) != NDIS_STATUS_SUCCESS)
{
// Could not register the adapter, so we cannot log any errors
// either.
DBGPRINT(DBG_COMP_INIT, DBG_LEVEL_FATAL,
("LtInitRegisterAdapter: Failed %lx\n", Status));
// Free up the memory allocated.
NdisFreeMemory(
Adapter,
sizeof(LT_ADAPTER),
0);
return(Status);
}
DBGPRINT(DBG_COMP_INIT, DBG_LEVEL_ERR,
("LtInitRegisterAdapter: MappedIoBaseAddr %lx\n", Adapter->MappedIoBaseAddr));
do
{
// Ok. We are all set.
Adapter->BusType = BusType;
InitializeListHead(&Adapter->Request);
InitializeListHead(&Adapter->OpenBindings);
InitializeListHead(&Adapter->LoopBack);
InitializeListHead(&Adapter->Transmit);
InitializeListHead(&Adapter->Receive);
NdisAllocateSpinLock(&Adapter->Lock);
Adapter->OpenCount = 0;
// Set refcount to 1 - creation
Adapter->RefCount = 1;
NdisInitializeTimer(
&Adapter->PollingTimer,
LtTimerPoll,
(PVOID)Adapter);
// If there were no configuration errors, then go ahead with the
// initialize.
if (ConfigError == NDIS_STATUS_SUCCESS)
{
// Start the card up. This writes an error
// log entry if it fails.
if (LtFirmInitialize(Adapter, SuggestedNodeId))
{
// Ok, the firmware code has been downloaded to the card.
// Start the poll timer. We should do this before we call
// GetAddress. Add a reference for the timer.
NdisAcquireSpinLock(&Adapter->Lock);
LtReferenceAdapterNonInterlock(Adapter, &RefStatus);
ASSERTMSG("LtInitRegisterAdapter: RefAdater Failed!\n",
(RefStatus == NDIS_STATUS_SUCCESS));
Adapter->Flags |= ADAPTER_TIMER_QUEUED;
NdisSetTimer(&Adapter->PollingTimer, LT_POLLING_TIME);
NdisReleaseSpinLock(&Adapter->Lock);
break;
}
LogErrorCode = NDIS_ERROR_CODE_HARDWARE_FAILURE;
}
else
{
LogErrorCode = NDIS_ERROR_CODE_MISSING_CONFIGURATION_PARAMETER;
}
// We either could not initialize the hardware or get the node
// address. OR there was a config error. Log it and deregister
// the adapter.
LOGERROR(Adapter->NdisAdapterHandle, LogErrorCode);
// Deregister the adapter. This calls LtInitRemoveAdapter which
// will do all necessary cleanup.
NdisDeregisterAdapter(Adapter->NdisAdapterHandle);
Status = NDIS_STATUS_FAILURE;
break;
} while (FALSE);
return(Status);
}
BOOLEAN
ArcNoteFilterOpenAdapter(
IN PARC_FILTER Filter,
IN NDIS_HANDLE MacBindingHandle,
IN NDIS_HANDLE NdisBindingContext,
OUT PNDIS_HANDLE NdisFilterHandle
)
/*++
Routine Description:
This routine is used to add a new binding to the filter database.
NOTE: THIS ROUTINE ASSUMES THAT THE DATABASE IS LOCKED WHEN
IT IS CALLED.
Arguments:
Filter - A pointer to the previously created and initialized filter
database.
MacBindingHandle - The MAC supplied value to the protocol in response
to a call to NdisOpenAdapter.
NdisBindingContext - An NDIS supplied value to the call to NdisOpenAdapter.
NdisFilterHandle - A pointer to this open.
Return Value:
Will return false if creating a new filter index will cause the maximum
number of filter indexes to be exceeded.
--*/
{
//
// Will hold the value of the filter index so that we
// need not indirectly address through pointer parameter.
//
UINT LocalIndex;
NDIS_STATUS AllocStatus;
//
// Pointer to new open block.
//
PARC_BINDING_INFO LocalOpen;
//
// Get the first free binding slot and remove that slot from
// the free list. We check to see if the list is empty.
//
if (Filter->FreeBindingMask == 0) {
return FALSE;
}
AllocStatus = NdisAllocateMemory(
&LocalOpen,
sizeof(ARC_BINDING_INFO),
0,
HighestAcceptableMax
);
if (AllocStatus != NDIS_STATUS_SUCCESS) {
return FALSE;
}
//
// Get place for the open and insert it.
//
ARC_FILTER_ALLOC_OPEN(Filter, &LocalIndex);
LocalOpen->NextOpen = Filter->OpenList;
if (Filter->OpenList != NULL) {
Filter->OpenList->PrevOpen = LocalOpen;
}
LocalOpen->PrevOpen = NULL;
Filter->OpenList = LocalOpen;
LocalOpen->FilterIndex = (UCHAR)LocalIndex;
LocalOpen->References = 1;
LocalOpen->MacBindingHandle = MacBindingHandle;
LocalOpen->NdisBindingContext = NdisBindingContext;
LocalOpen->PacketFilters = 0;
LocalOpen->ReceivedAPacket = FALSE;
*NdisFilterHandle = (NDIS_HANDLE)LocalOpen;
return TRUE;
}
VOID
NdisOpenGlobalConfiguration(
OUT PNDIS_STATUS Status,
IN PNDIS_HANDLE NdisWrapperHandle,
OUT PNDIS_HANDLE ConfigurationHandle
)
/*++
Routine Description:
This routine is used to open global (as opposed to per-adapter) configuration key for an adapter.
Arguments:
Status - Returns the status of the request.
WrapperHandle - Handle returned by NdisInitializeWrapper.
ConfigurationHandle - Handle returned. Points to the global parameter subkey.
Return Value:
None.
--*/
{
PNDIS_WRAPPER_HANDLE WrapperHandle = (PNDIS_WRAPPER_HANDLE)NdisWrapperHandle;
PNDIS_CONFIGURATION_HANDLE HandleToReturn;
PNDIS_WRAPPER_CONFIGURATION_HANDLE ConfigHandle;
UNICODE_STRING Us, Params;
PWSTR pWch;
USHORT i;
//
// Extract the base name from the reg path and setup for open config handle
//
Us = *(PUNICODE_STRING)(WrapperHandle->NdisWrapperConfigurationHandle);
RtlInitUnicodeString(&Params, L"\\Parameters");
for (i = Us.Length/sizeof(WCHAR), pWch = Us.Buffer + i - 1;
i > 0;
pWch --, i--)
{
if (*pWch == L'\\')
{
Us.Buffer = pWch + 1;
Us.Length -= i*sizeof(WCHAR);
Us.MaximumLength = Us.Length + Params.Length + sizeof(WCHAR);
break;
}
}
//
// Allocate the configuration handle
//
*Status = NdisAllocateMemory((PVOID *)&HandleToReturn,
sizeof(NDIS_CONFIGURATION_HANDLE) +
sizeof(NDIS_WRAPPER_CONFIGURATION_HANDLE) +
Us.MaximumLength,
0,
HighestAcceptableMax);
if (*Status == NDIS_STATUS_SUCCESS)
{
#define PQueryTable ConfigHandle->ParametersQueryTable
NdisZeroMemory(HandleToReturn,
sizeof(NDIS_CONFIGURATION_HANDLE) + sizeof(NDIS_WRAPPER_CONFIGURATION_HANDLE) + Us.MaximumLength);
ConfigHandle = (PNDIS_WRAPPER_CONFIGURATION_HANDLE)((PUCHAR)HandleToReturn + sizeof(NDIS_CONFIGURATION_HANDLE));
pWch = (PWSTR)((PUCHAR)ConfigHandle + sizeof(NDIS_WRAPPER_CONFIGURATION_HANDLE));
NdisMoveMemory(pWch, Us.Buffer, Us.Length);
Us.Buffer = pWch;
RtlAppendUnicodeStringToString(&Us, &Params);
HandleToReturn->KeyQueryTable = ConfigHandle->ParametersQueryTable;
HandleToReturn->ParameterList = NULL;
//
// Setup the query-table appropriately
//
PQueryTable[0].QueryRoutine = ndisSaveParameters;
PQueryTable[0].Flags = RTL_QUERY_REGISTRY_REQUIRED | RTL_QUERY_REGISTRY_NOEXPAND;
PQueryTable[0].DefaultType = REG_NONE;
//
// The following fields are filled in during NdisReadConfiguration
//
// PQueryTable[0].Name = KeywordBuffer;
// PQueryTable[0].EntryContext = ParameterValue;
//
// NOTE: Some fields in ParametersQueryTable[3 & 4] are used to
// store information for later retrieval.
//
PQueryTable[3].Name = pWch;
*ConfigurationHandle = (NDIS_HANDLE)HandleToReturn;
#undef PQueryTable
}
}
NTSTATUS
ndisSaveParameters(
IN PWSTR ValueName,
IN ULONG ValueType,
IN PVOID ValueData,
IN ULONG ValueLength,
IN PVOID Context,
IN PVOID EntryContext
)
/*++
Routine Description:
This routine is a callback routine for RtlQueryRegistryValues
It is called with the value for a specified parameter. It allocates
memory to hold the data and copies it over.
Arguments:
ValueName - The name of the value (ignored).
ValueType - The type of the value.
ValueData - The null-terminated data for the value.
ValueLength - The length of ValueData.
Context - Points to the head of the parameter chain.
EntryContext - A pointer to
Return Value:
STATUS_SUCCESS
--*/
{
NDIS_STATUS Status;
//
// Obtain the actual configuration handle structure
//
PNDIS_CONFIGURATION_HANDLE NdisConfigHandle = (PNDIS_CONFIGURATION_HANDLE)Context;
//
// Where the user wants a pointer returned to the data.
//
PNDIS_CONFIGURATION_PARAMETER *ParameterValue = (PNDIS_CONFIGURATION_PARAMETER *)EntryContext;
//
// Use this to link parameters allocated to this open
//
PNDIS_CONFIGURATION_PARAMETER_QUEUE ParameterNode;
//
// Size of memory to allocate for parameter node
//
UINT Size;
//
// Allocate our parameter node
//
Size = sizeof(NDIS_CONFIGURATION_PARAMETER_QUEUE);
if ((ValueType == REG_SZ) || (ValueType == REG_MULTI_SZ) || (ValueType == REG_BINARY))
{
Size += ValueLength;
}
Status = NdisAllocateMemory((PVOID*)&ParameterNode,
Size,
0,
HighestAcceptableMax);
if (Status != NDIS_STATUS_SUCCESS)
{
return (NTSTATUS)Status;
}
*ParameterValue = &ParameterNode->Parameter;
//
// Map registry datatypes to ndis data types
//
if (ValueType == REG_DWORD)
{
//
// The registry says that the data is in a dword boundary.
//
(*ParameterValue)->ParameterType = NdisParameterInteger;
(*ParameterValue)->ParameterData.IntegerData = *((PULONG) ValueData);
}
else if ((ValueType == REG_SZ) || (ValueType == REG_MULTI_SZ))
{
(*ParameterValue)->ParameterType =
(ValueType == REG_SZ) ? NdisParameterString : NdisParameterMultiString;
(*ParameterValue)->ParameterData.StringData.Buffer = (PWSTR)((PUCHAR)ParameterNode + sizeof(NDIS_CONFIGURATION_PARAMETER_QUEUE));
CopyMemory((*ParameterValue)->ParameterData.StringData.Buffer,
ValueData,
ValueLength);
(*ParameterValue)->ParameterData.StringData.Length = (USHORT)ValueLength;
(*ParameterValue)->ParameterData.StringData.MaximumLength = (USHORT)ValueLength;
//
// Special fix; if a string ends in a NULL and that is included
// in the length, remove it.
//
if (ValueType == REG_SZ)
{
if ((((PUCHAR)ValueData)[ValueLength-1] == 0) &&
(((PUCHAR)ValueData)[ValueLength-2] == 0))
{
(*ParameterValue)->ParameterData.StringData.Length -= 2;
}
}
}
else if (ValueType == REG_BINARY)
{
(*ParameterValue)->ParameterType = NdisParameterBinary;
(*ParameterValue)->ParameterData.BinaryData.Buffer = ValueData;
(*ParameterValue)->ParameterData.BinaryData.Length = (USHORT)ValueLength;
}
else
{
NdisFreeMemory(ParameterNode,
sizeof(NDIS_CONFIGURATION_PARAMETER_QUEUE),
0);
return STATUS_OBJECT_NAME_NOT_FOUND;
}
//
// Queue this parameter node
//
ParameterNode->Next = NdisConfigHandle->ParameterList;
NdisConfigHandle->ParameterList = ParameterNode;
return STATUS_SUCCESS;
}
VOID
NdisReadBindingInformation(
OUT PNDIS_STATUS Status,
OUT PNDIS_STRING * Binding,
IN NDIS_HANDLE ConfigurationHandle
)
/*++
Routine Description:
This routine is used to read the binding information for
this adapter from the configuration database. The value
returned is a pointer to a string containing the bind
that matches the export for the current AddAdapter call.
This function is meant for NDIS drivers that are layered
on top of other NDIS drivers. Binding would be passed to
NdisOpenAdapter as the AdapterName.
Arguments:
Status - Returns the status of the request.
Binding - Returns the binding data.
ConfigurationHandle - Handle returned by NdisOpenConfiguration. Points
to the parameter subkey.
Return Value:
None.
--*/
{
//
// Convert the handle to its real value
//
PNDIS_CONFIGURATION_HANDLE NdisConfigHandle = (PNDIS_CONFIGURATION_HANDLE)ConfigurationHandle;
//
// Use this to link parameters allocated to this open
//
PNDIS_CONFIGURATION_PARAMETER_QUEUE ParameterNode;
//
// For layered drivers, this points to the binding. For
// non-layered drivers, it is NULL. This is set up before
// the call to AddAdapter.
//
do
{
if (NdisConfigHandle->KeyQueryTable[3].EntryContext == NULL)
{
*Status = NDIS_STATUS_FAILURE;
break;
}
//
// Allocate our parameter node
//
*Status = NdisAllocateMemory((PVOID*)&ParameterNode,
sizeof(NDIS_CONFIGURATION_PARAMETER_QUEUE),
0,
HighestAcceptableMax);
if (*Status != NDIS_STATUS_SUCCESS)
{
break;
}
//
// We set this to Integer because if we set it to String
// then CloseConfiguration would try to free the string,
// which we don't want.
//
ParameterNode->Parameter.ParameterType = NdisParameterInteger;
RtlInitUnicodeString(&ParameterNode->Parameter.ParameterData.StringData,
NdisConfigHandle->KeyQueryTable[3].EntryContext);
//
// Queue this parameter node
//
ParameterNode->Next = NdisConfigHandle->ParameterList;
NdisConfigHandle->ParameterList = ParameterNode;
*Binding = &ParameterNode->Parameter.ParameterData.StringData;
*Status = NDIS_STATUS_SUCCESS;
} while (FALSE);
}
NDIS_STATUS
ArcAllocateBuffers(
IN PARC_FILTER Filter
)
/*++
Routine Description:
This routine allocates Receive buffers for the filter database.
Arguments:
Filter - The filter db to allocate for.
Returns:
NDIS_STATUS_SUCCESS if any buffer was allocated.
--*/
{
ULONG i;
PARC_BUFFER_LIST Buffer;
PVOID DataBuffer;
for (i = ARC_BUFFER_ALLOCATION_UNIT; i != 0 ; i--) {
NdisAllocateMemory((PVOID)&Buffer,
sizeof(ARC_BUFFER_LIST),
0,
HighestAcceptableMax
);
if (Buffer == NULL) {
if (i == ARC_BUFFER_ALLOCATION_UNIT) {
return(NDIS_STATUS_FAILURE);
}
return(NDIS_STATUS_SUCCESS);
}
NdisAllocateMemory((PVOID)&DataBuffer,
ARC_BUFFER_SIZE,
0,
HighestAcceptableMax
);
if (DataBuffer == NULL) {
NdisFreeMemory(Buffer, sizeof(ARC_BUFFER_LIST), 0);
if (i == ARC_BUFFER_ALLOCATION_UNIT) {
return(NDIS_STATUS_FAILURE);
}
//
// We allocated some packets, that is good enough for now
//
return(NDIS_STATUS_SUCCESS);
}
Buffer->BytesLeft = Buffer->Size = ARC_BUFFER_SIZE;
Buffer->Buffer = DataBuffer;
Buffer->Next = Filter->FreeBufferList;
Filter->FreeBufferList = Buffer;
}
return(NDIS_STATUS_SUCCESS);
}
VOID
NdisOpenConfigurationKeyByName(
OUT PNDIS_STATUS Status,
IN PNDIS_HANDLE ConfigurationHandle,
IN PNDIS_STRING KeyName,
OUT PNDIS_HANDLE KeyHandle
)
/*++
Routine Description:
This routine is used to open a subkey relative to the configuration handle.
Arguments:
Status - Returns the status of the request.
ConfigurationHandle - Handle to an already open section of the registry
KeyName - Name of the subkey to open
KeyHandle - Placeholder for the handle to the sub-key.
Return Value:
None.
--*/
{
//
// Handle to be returned
//
PNDIS_CONFIGURATION_HANDLE SKHandle, ConfigHandle = (PNDIS_CONFIGURATION_HANDLE)ConfigurationHandle;
PNDIS_WRAPPER_CONFIGURATION_HANDLE WConfigHandle;
UNICODE_STRING Parent, Child, Sep;
#define PQueryTable WConfigHandle->ParametersQueryTable
ASSERT (KeGetCurrentIrql() < DISPATCH_LEVEL);
//
// Allocate the configuration handle
//
RtlInitUnicodeString(&Parent, ConfigHandle->KeyQueryTable[3].Name);
RtlInitUnicodeString(&Sep, L"\\");
Child.Length = 0;
Child.MaximumLength = KeyName->Length + Parent.Length + Sep.Length + sizeof(WCHAR);
*Status = NdisAllocateMemory((PVOID*)&SKHandle,
sizeof(NDIS_CONFIGURATION_HANDLE) +
sizeof(NDIS_WRAPPER_CONFIGURATION_HANDLE) +
Child.MaximumLength,
0,
HighestAcceptableMax);
if (*Status != NDIS_STATUS_SUCCESS)
{
*KeyHandle = (NDIS_HANDLE)NULL;
return;
}
WConfigHandle = (PNDIS_WRAPPER_CONFIGURATION_HANDLE)((PUCHAR)SKHandle + sizeof(NDIS_CONFIGURATION_HANDLE));
Child.Buffer = (PWSTR)((PUCHAR)WConfigHandle + sizeof(NDIS_WRAPPER_CONFIGURATION_HANDLE));
RtlCopyUnicodeString(&Child, &Parent);
RtlAppendUnicodeStringToString(&Child, &Sep);
RtlAppendUnicodeStringToString(&Child, KeyName);
SKHandle->KeyQueryTable = WConfigHandle->ParametersQueryTable;
//
// 1.
// Call ndisSaveParameter for a parameter, which will allocate storage for it.
//
PQueryTable[0].QueryRoutine = ndisSaveParameters;
PQueryTable[0].Flags = RTL_QUERY_REGISTRY_REQUIRED | RTL_QUERY_REGISTRY_NOEXPAND;
PQueryTable[0].DefaultType = REG_NONE;
//
// PQueryTable[0].Name and PQueryTable[0].EntryContext
// are filled in inside ReadConfiguration, in preparation
// for the callback.
//
// PQueryTable[0].Name = KeywordBuffer;
// PQueryTable[0].EntryContext = ParameterValue;
//
// 2.
// Stop
//
PQueryTable[1].QueryRoutine = NULL;
PQueryTable[1].Flags = 0;
PQueryTable[1].Name = NULL;
//
// NOTE: Some fields in ParametersQueryTable[3] are used to store information for later retrieval.
//
PQueryTable[3].QueryRoutine = NULL;
PQueryTable[3].Name = Child.Buffer;
PQueryTable[3].EntryContext = NULL;
PQueryTable[3].DefaultData = NULL;
SKHandle->ParameterList = NULL;
*KeyHandle = (NDIS_HANDLE)SKHandle;
#undef PQueryTable
}
/*
* Allocate mem.
*
* Debug version?
*/
STDCALL unsigned int NdisAllocateMemoryWithTag(void **dest,
unsigned int length,
unsigned int tag)
{
return NdisAllocateMemory(dest, length, 0, 0);
}
DWORD PacketOpen(PNDIS_STRING AdapterName,DWORD dwDDB,DWORD hDevice,PDIOCPARAMETERS pDiocParms)
{
LARGE_INTEGER SystemTime;
__int64 ltime1;
PDEVICE_EXTENSION pde;
POPEN_INSTANCE oiNew;
NDIS_STATUS nsErrorStatus, nsOpenStatus;
UINT i;
UINT uiMedium;
NDIS_STRING NameStr;
NDIS_STATUS Status;
pde = GlobalDeviceExtension;
/*Allocate an element that describe an adapter*/
NdisAllocateMemory( (PVOID *)&oiNew, sizeof( OPEN_INSTANCE ), 0, -1 );
if ( oiNew == NULL )
{
return NDIS_STATUS_FAILURE;
}
NdisZeroMemory( (PVOID)oiNew, sizeof( OPEN_INSTANCE ) );
/*allocate a pool for the packet headers*/
NdisAllocatePacketPool( &nsErrorStatus,
&(oiNew->PacketPool),
TRANSMIT_PACKETS,
sizeof(PACKET_RESERVED) );
IF_TRACE_MSG( "PACKET_RESERVED_a :%lx",sizeof(PACKET_RESERVED));
if ( nsErrorStatus != NDIS_STATUS_SUCCESS )
{
IF_TRACE_MSG( "Failed to allocate packet pool AllocStatus=%x", nsErrorStatus );
NdisFreeMemory( oiNew, sizeof( OPEN_INSTANCE ) , 0 );
TRACE_LEAVE( "BindAdapter" );
return NDIS_STATUS_FAILURE;
}
/*allocate a buffer pool for the packet data*/
NdisAllocateBufferPool( &nsErrorStatus,
&(oiNew->BufferPool),
TRANSMIT_PACKETS );
if ( nsErrorStatus != NDIS_STATUS_SUCCESS )
{
IF_TRACE_MSG( "Failed to allocate packet pool AllocStatus=%x", nsErrorStatus );
NdisFreePacketPool( oiNew->PacketPool );
NdisFreeMemory( oiNew, sizeof( OPEN_INSTANCE ) , 0 );
TRACE_LEAVE( "BindAdapter" );
return NDIS_STATUS_FAILURE;
}
NdisAllocateSpinLock( &(oiNew->ResetSpinLock) );
InitializeListHead( &(oiNew->ResetIrpList) );
NdisAllocateSpinLock( &(oiNew->RcvQSpinLock) );
InitializeListHead( &(oiNew->RcvList) );
NdisAllocateSpinLock( &(oiNew->RequestSpinLock) );
InitializeListHead( &(oiNew->RequestList) );
for ( i=0; i<MAX_REQUESTS; i++ )
{
InsertTailList( &(oiNew->RequestList), &(oiNew->Requests[i].Reserved.ListElement) );
}
oiNew->Status = NDIS_STATUS_PENDING;
/*initialize the timer variables for this session*/
SystemTime=GetDate();
ltime1=((__int64)SystemTime.HighPart*86400);
ltime1+=(__int64)(SystemTime.LowPart/1000); //current time from 1980 in seconds
ltime1+=(__int64)315532800; //current time from 1970 (Unix format) in seconds
ltime1*=1193182;
ltime1+=(SystemTime.LowPart%1000)*1193182/1000; //current time from 1970 in ticks
ltime1-=QuerySystemTime(); //boot time from 1970 in ticks
oiNew->StartTime=ltime1;
oiNew->Dropped=0; //reset the dropped packets counter
oiNew->Received=0; //reset the received packets counter
oiNew->bpfprogram=NULL; //set an accept-all filter
oiNew->bpfprogramlen=0;
oiNew->BufSize=0; //set an empty buffer
oiNew->Buffer=NULL; //reset the buffer
oiNew->Bhead=0;
oiNew->Btail=0;
oiNew->BLastByte=0;
oiNew->TimeOut=0; //reset the timeouts
oiNew->ReadTimeoutTimer=0;
oiNew->mode=0; //set capture mode
oiNew->Nbytes=0; //reset the counters
oiNew->Npackets=0;
oiNew->hDevice=hDevice;
oiNew->tagProcess=pDiocParms->tagProcess;
oiNew->ReadEvent=0; //reset the read event
NdisAllocateSpinLock( &(oiNew->CountersLock) );
/*open the MAC driver calling NDIS*/
NdisOpenAdapter( &nsOpenStatus,
&nsErrorStatus,
&oiNew->AdapterHandle,
&uiMedium,
MediumArray,
NUM_NDIS_MEDIA,
pde->NdisProtocolHandle,
oiNew,
AdapterName,
0,
NULL );
IF_TRACE_MSG( "Open Status : %lx", nsOpenStatus );
IF_TRACE_MSG( "Error Status : %lx", nsErrorStatus );
IF_TRACE_MSG( "Completion Status : %lx", oiNew->Status );
if ( nsOpenStatus == NDIS_STATUS_PENDING )
{
while ( oiNew->Status == NDIS_STATUS_PENDING )
YieldExecution();
}
else
{
PacketOpenAdapterComplete( oiNew, nsOpenStatus, nsErrorStatus );
}
Status = oiNew->Status;
if ( Status != NDIS_STATUS_SUCCESS )
{
NdisFreeMemory( oiNew, sizeof( OPEN_INSTANCE ) , 0 );
return NDIS_STATUS_FAILURE;
}
else
{
}
TRACE_LEAVE( "BindAdapter" );
/*return succesfully*/
return STATUS_SUCCESS;
}