Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-06 06:12:59 +00:00
Code Issues Projects Releases Packages Wiki Activity

patch submitted by Vizzini (tested by myself) - implemented Ndis configuration api, adapted ne2000 to use it to get configuration, fixed up registry support for ne2000 driver, other supporting changes

Browse source 
svn path=/trunk/; revision=5337
This commit is contained in:
Royce Mitchell III 2003-07-30 22:11:20 +00:00
parent e5f5b27064
commit eab39eae46
12 changed files with 615 additions and 309 deletions
Download patch file Download diff file Expand all files Collapse all files

27
reactos/bootdata/hivesys.inf
View file

@ -208,12 +208,39 @@ HKLM,"SYSTEM\CurrentControlSet\Services\Ndis","ImagePath",0x00020000,"system32\d
HKLM,"SYSTEM\CurrentControlSet\Services\Ndis","Start",0x00010001,0x00000001 HKLM,"SYSTEM\CurrentControlSet\Services\Ndis","Start",0x00010001,0x00000001
HKLM,"SYSTEM\CurrentControlSet\Services\Ndis","Type",0x00010001,0x00000001 HKLM,"SYSTEM\CurrentControlSet\Services\Ndis","Type",0x00010001,0x00000001
; NIC drivers are like any other drivers - but no card-specific info here. bind/route/export
; should have one entry per child device object
; NE2000 NIC driver ; NE2000 NIC driver
HKLM,"SYSTEM\CurrentControlSet\Services\Ne2000","ErrorControl",0x00010001,0x00000001 HKLM,"SYSTEM\CurrentControlSet\Services\Ne2000","ErrorControl",0x00010001,0x00000001
HKLM,"SYSTEM\CurrentControlSet\Services\Ne2000","Group",0x00000000,"NDIS" HKLM,"SYSTEM\CurrentControlSet\Services\Ne2000","Group",0x00000000,"NDIS"
HKLM,"SYSTEM\CurrentControlSet\Services\Ne2000","ImagePath",0x00020000,"system32\drivers\ne2000.sys" HKLM,"SYSTEM\CurrentControlSet\Services\Ne2000","ImagePath",0x00020000,"system32\drivers\ne2000.sys"
HKLM,"SYSTEM\CurrentControlSet\Services\Ne2000","Start",0x00010001,0x00000001 HKLM,"SYSTEM\CurrentControlSet\Services\Ne2000","Start",0x00010001,0x00000001
HKLM,"SYSTEM\CurrentControlSet\Services\Ne2000","Type",0x00010001,0x00000001 HKLM,"SYSTEM\CurrentControlSet\Services\Ne2000","Type",0x00010001,0x00000001
HKLM,"SYSTEM\CurrentControlSet\Services\Ne2000","Test",0x00010001,0xbaadf00d
HKLM,"SYSTEM\CurrentControlSet\Services\Ne2000","Route",0x00000000,"NE20001"
HKLM,"SYSTEM\CurrentControlSet\Services\Ne2000\Linkage","Bind",0x00000000,"\Device\NE20001"
HKLM,"SYSTEM\CurrentControlSet\Services\Ne2000\Linkage","Export",0x00000000,"\Device\NE20001"
HKLM,"SYSTEM\CurrentControlSet\Services\Ne2000\Linkage","Route",0x00000000,"NE20001"
; Each adapter in the system gets its own SCM entry where its parameters and protocol info are stored.
; NOTE - service type is 0x4 (SERVICE_ADAPTER) and start is 0x3 (manual start). These drivers are named
; for the parent driver plus a globally-increasing serial number (i.e. across all ndis miniports)
; TODO: create this with NDI
; NE2000 Adapter 1
HKLM,"SYSTEM\CurrentControlSet\Services\Ne20001","ErrorControl",0x00010001,0x00000001
HKLM,"SYSTEM\CurrentControlSet\Services\Ne20001","Start",0x00010001,0x00000003
HKLM,"SYSTEM\CurrentControlSet\Services\Ne20001","Type",0x00010001,0x00000004
HKLM,"SYSTEM\CurrentControlSet\Services\Ne20001\Linkage","Bind",0x00010000,"\Device\NE20001"
HKLM,"SYSTEM\CurrentControlSet\Services\Ne20001\Linkage","Export",0x00010000,"\Device\NE20001"
HKLM,"SYSTEM\CurrentControlSet\Services\Ne20001\Linkage","Route",0x00010000,"NE20001"
HKLM,"SYSTEM\CurrentControlSet\Services\Ne20001\Parameters","Port",0x00010001,0x00000280
HKLM,"SYSTEM\CurrentControlSet\Services\Ne20001\Parameters","Irq",0x00010001,0x00000009
HKLM,"SYSTEM\CurrentControlSet\Services\Ne20001\Parameters","DwordTest",0x00010001,0xbaadf00d
HKLM,"SYSTEM\CurrentControlSet\Services\Ne20001\Parameters","StringTest",0x00000000,"StringTest"
HKLM,"SYSTEM\CurrentControlSet\Services\Ne20001\Parameters","NetworkAddress",0x00000000,"001122334455"
HKLM,"SYSTEM\CurrentControlSet\Services\Ne20001\Parameters\Tcpip","DefaultGateway",0x00010000,"10.0.0.1"
HKLM,"SYSTEM\CurrentControlSet\Services\Ne20001\Parameters\Tcpip","IPAddress",0x00010000,"10.0.0.100"
HKLM,"SYSTEM\CurrentControlSet\Services\Ne20001\Parameters\Tcpip","SubnetMask",0x00010001,"255.255.255.0"
; Named Pipe filesystem driver ; Named Pipe filesystem driver
HKLM,"SYSTEM\CurrentControlSet\Services\Npfs","ErrorControl",0x00010001,0x00000000 HKLM,"SYSTEM\CurrentControlSet\Services\Npfs","ErrorControl",0x00010001,0x00000000

4
reactos/drivers/net/dd/ne2000/include/debug.h
View file

@ -43,7 +43,7 @@ extern ULONG DebugTraceLevel;
#endif /* _MSC_VER */ #endif /* _MSC_VER */
/* Assert and kin are defined in rtl.h */ /* Assert is defined in ndis.h */
#if 0 #if 0
#ifdef ASSERT #ifdef ASSERT
#undef ASSERT #undef ASSERT
@ -62,7 +62,7 @@ extern ULONG DebugTraceLevel;
#define NDIS_DbgPrint(_t_, _x_) #define NDIS_DbgPrint(_t_, _x_)
#define ASSERT_IRQL(x) #define ASSERT_IRQL(x)
/* #define ASSERT(x) */ /* rtl.h */ /* #define ASSERT(x) */ /* ndis.h */
#endif /* DBG */ #endif /* DBG */

4
reactos/drivers/net/dd/ne2000/include/ne2000.h
View file

@ -33,8 +33,8 @@
#define DRIVER_NDIS_MAJOR_VERSION 3 #define DRIVER_NDIS_MAJOR_VERSION 3
#define DRIVER_NDIS_MINOR_VERSION 0 #define DRIVER_NDIS_MINOR_VERSION 0
#define DRIVER_DEFAULT_IO_BASE_ADDRESS 0x300 #define DRIVER_DEFAULT_IO_BASE_ADDRESS 0x280 /* bochs default */
#define DRIVER_DEFAULT_INTERRUPT_NUMBER 10 #define DRIVER_DEFAULT_INTERRUPT_NUMBER 9 /* bochs default */
#define DRIVER_MAX_MULTICAST_LIST_SIZE 8 #define DRIVER_MAX_MULTICAST_LIST_SIZE 8

93
reactos/drivers/net/dd/ne2000/ne2000/8390.c
View file

@ -9,6 +9,45 @@
*/ */
#include <ne2000.h> #include <ne2000.h>
/* Null-terminated array of ports to probe. This is "semi-risky" (Don Becker). */
ULONG ProbeAddressList[] = { 0x280, 0x300, 0x320, 0x340, 0x360, 0x380, 0 };
BOOLEAN ProbeAddressForNIC(
ULONG address)
/*
* FUNCTION: Probes an address for a NIC
* ARGUMENTS:
* address = Base address to probe
* RETURNS:
* TRUE if an NIC is found at the address
* FALSE otherwise
* NOTES:
* If the adapter responds correctly to a
* stop command we assume it is present
*/
{
UCHAR Tmp;
NDIS_DbgPrint(MID_TRACE, ("Probing address 0x%x\n", address));
/* Disable interrupts */
NdisRawWritePortUchar(address + PG0_IMR, 0);
/* Stop the NIC */
NdisRawWritePortUchar(address + PG0_CR, CR_STP | CR_RD2);
/* Pause for 1.6ms */
NdisStallExecution(1600);
/* Read NIC response */
NdisRawReadPortUchar(address + PG0_CR, &Tmp);
if ((Tmp == (CR_RD2 | CR_STP)) || (Tmp == (CR_RD2 | CR_STP | CR_STA)))
return TRUE;
else
return FALSE;
}
BOOLEAN NICCheck( BOOLEAN NICCheck(
PNIC_ADAPTER Adapter) PNIC_ADAPTER Adapter)
@ -18,29 +57,32 @@ BOOLEAN NICCheck(
* Adapter = Pointer to adapter information * Adapter = Pointer to adapter information
* RETURNS: * RETURNS:
* TRUE if NIC is believed to be present, FALSE if not * TRUE if NIC is believed to be present, FALSE if not
* NOTES:
* If the adapter responds correctly to a
* stop command we assume it is present
*/ */
{ {
UCHAR Tmp; int i;
/* Disable interrupts */ NDIS_DbgPrint(MAX_TRACE, ("Called\n"));
NdisRawWritePortUchar(Adapter->IOBase + PG0_IMR, 0);
/* Stop the NIC */ /* first try the supplied value */
NdisRawWritePortUchar(Adapter->IOBase + PG0_CR, CR_STP | CR_RD2); if(ProbeAddressForNIC(Adapter->IoBaseAddress))
{
/* Pause for 1.6ms */ NDIS_DbgPrint(MIN_TRACE, ("Found adapter at 0x%x\n", Adapter->IoBaseAddress));
NdisStallExecution(1600);
/* Read NIC response */
NdisRawReadPortUchar(Adapter->IOBase + PG0_CR, &Tmp);
if ((Tmp == (CR_RD2 | CR_STP)) || (Tmp == (CR_RD2 | CR_STP | CR_STA)))
return TRUE; return TRUE;
else }
return FALSE;
/* ok, no dice, time to probe */
for(i = 0; ProbeAddressList[i]; i++)
{
if(ProbeAddressForNIC(ProbeAddressList[i]))
{
NDIS_DbgPrint(MIN_TRACE, ("Found adapter at address 0x%x\n", ProbeAddressList[i]));
Adapter->IoBaseAddress = ProbeAddressList[i];
return TRUE;
}
}
NDIS_DbgPrint(MIN_TRACE,("Adapter NOT found!\n"));
return FALSE;
} }
@ -215,7 +257,7 @@ BOOLEAN NICReadSAPROM(
/* If WordLength is 2 the data read before was doubled. We must compensate for this */ /* If WordLength is 2 the data read before was doubled. We must compensate for this */
if (WordLength == 2) { if (WordLength == 2) {
DbgPrint("NE2000 or compatible network adapter found.\n"); NDIS_DbgPrint(MAX_TRACE,("NE2000 or compatible network adapter found.\n"));
Adapter->WordMode = TRUE; Adapter->WordMode = TRUE;
@ -234,7 +276,7 @@ BOOLEAN NICReadSAPROM(
return TRUE; return TRUE;
} else { } else {
DbgPrint("NE1000 or compatible network adapter found.\n"); NDIS_DbgPrint(MAX_TRACE, ("NE1000 or compatible network adapter found.\n"));
Adapter->WordMode = FALSE; Adapter->WordMode = FALSE;
@ -257,13 +299,7 @@ NDIS_STATUS NICInitialize(
{ {
UCHAR Tmp; UCHAR Tmp;
NDIS_DbgPrint(MAX_TRACE, ("Called.\n")); NDIS_DbgPrint(MID_TRACE, ("Called.\n"));
if (!NICCheck(Adapter)) {
NDIS_DbgPrint(MID_TRACE, ("No adapter found at (0x%X).\n", Adapter->IOBase));
return NDIS_STATUS_ADAPTER_NOT_FOUND;
} else
NDIS_DbgPrint(MID_TRACE, ("Adapter found at (0x%X).\n", Adapter->IOBase));
/* Reset the NIC */ /* Reset the NIC */
NdisRawReadPortUchar(Adapter->IOBase + NIC_RESET, &Tmp); NdisRawReadPortUchar(Adapter->IOBase + NIC_RESET, &Tmp);
@ -867,6 +903,7 @@ VOID NICIndicatePacket(
IndicateLength + DRIVER_HEADER_SIZE); IndicateLength + DRIVER_HEADER_SIZE);
NDIS_DbgPrint(MID_TRACE, ("Indicating (%d) bytes.\n", IndicateLength)); NDIS_DbgPrint(MID_TRACE, ("Indicating (%d) bytes.\n", IndicateLength));
DbgPrint("ne2000!NICIndicatePacket: Indicating (%d) bytes.\n", IndicateLength);
#if 0 #if 0
NDIS_DbgPrint(MAX_TRACE, ("FRAME:\n")); NDIS_DbgPrint(MAX_TRACE, ("FRAME:\n"));
@ -927,7 +964,7 @@ VOID NICReadPacket(
NDIS_DbgPrint(MAX_TRACE, ("HEADER: (PacketLength) (0x%X)\n", Adapter->PacketHeader.PacketLength)); NDIS_DbgPrint(MAX_TRACE, ("HEADER: (PacketLength) (0x%X)\n", Adapter->PacketHeader.PacketLength));
if (Adapter->PacketHeader.PacketLength < 64 || if (Adapter->PacketHeader.PacketLength < 64 ||
Adapter->PacketHeader.PacketLength > 1518) { Adapter->PacketHeader.PacketLength > 1518) { /* XXX I don't think the CRC will show up... should be 1514 */
NDIS_DbgPrint(MAX_TRACE, ("Bogus packet size (%d).\n", NDIS_DbgPrint(MAX_TRACE, ("Bogus packet size (%d).\n",
Adapter->PacketHeader.PacketLength)); Adapter->PacketHeader.PacketLength));
SkipPacket = TRUE; SkipPacket = TRUE;

141
reactos/drivers/net/dd/ne2000/ne2000/main.c
View file

@ -13,7 +13,6 @@
#ifdef DBG #ifdef DBG
/* See debug.h for debug/trace constants */ /* See debug.h for debug/trace constants */
//DWORD DebugTraceLevel = MID_TRACE;
ULONG DebugTraceLevel = MIN_TRACE; ULONG DebugTraceLevel = MIN_TRACE;
#endif /* DBG */ #endif /* DBG */
@ -173,7 +172,7 @@ NDIS_STATUS MiniportInitialize(
} }
if (i == MediumArraySize) { if (i == MediumArraySize) {
NDIS_DbgPrint(MIN_TRACE, ("No supported medias.\n")); NDIS_DbgPrint(MIN_TRACE, ("No supported media.\n"));
return NDIS_STATUS_UNSUPPORTED_MEDIA; return NDIS_STATUS_UNSUPPORTED_MEDIA;
} }
@ -196,6 +195,63 @@ NDIS_STATUS MiniportInitialize(
Adapter->InterruptMask = DRIVER_INTERRUPT_MASK; Adapter->InterruptMask = DRIVER_INTERRUPT_MASK;
Adapter->LookaheadSize = DRIVER_MAXIMUM_LOOKAHEAD; Adapter->LookaheadSize = DRIVER_MAXIMUM_LOOKAHEAD;
/* get the port, irq, and MAC address from registry */
do
{
PNDIS_CONFIGURATION_PARAMETER ConfigurationParameter;
NDIS_HANDLE ConfigurationHandle;
UNICODE_STRING Keyword;
UINT *RegNetworkAddress = 0;
UINT RegNetworkAddressLength = 0;
NdisOpenConfiguration(&Status, &ConfigurationHandle, WrapperConfigurationContext);
if(Status != NDIS_STATUS_SUCCESS)
{
NDIS_DbgPrint(MIN_TRACE,("NdisOpenConfiguration returned error 0x%x\n", Status));
break;
}
NdisInitUnicodeString(&Keyword, L"Irq");
NdisReadConfiguration(&Status, &ConfigurationParameter, ConfigurationHandle, &Keyword, NdisParameterInteger);
if(Status == NDIS_STATUS_SUCCESS)
{
NDIS_DbgPrint(MID_TRACE,("NdisReadConfiguration for Irq returned successfully, irq 0x%x\n",
ConfigurationParameter->ParameterData.IntegerData));
Adapter->InterruptNumber = ConfigurationParameter->ParameterData.IntegerData;
}
NdisInitUnicodeString(&Keyword, L"Port");
NdisReadConfiguration(&Status, &ConfigurationParameter, ConfigurationHandle, &Keyword, NdisParameterInteger);
if(Status == NDIS_STATUS_SUCCESS)
{
NDIS_DbgPrint(MID_TRACE,("NdisReadConfiguration for Port returned successfully, port 0x%x\n",
ConfigurationParameter->ParameterData.IntegerData));
Adapter->IoBaseAddress = ConfigurationParameter->ParameterData.IntegerData;
}
/* the returned copy of the data is owned by NDIS and will be released on NdisCloseConfiguration */
NdisReadNetworkAddress(&Status, (PVOID *)&RegNetworkAddress, &RegNetworkAddressLength, ConfigurationHandle);
if(Status == NDIS_STATUS_SUCCESS && RegNetworkAddressLength == DRIVER_LENGTH_OF_ADDRESS)
{
int i;
NDIS_DbgPrint(MID_TRACE,("NdisReadNetworkAddress returned successfully, address %x:%x:%x:%x:%x:%x\n",
RegNetworkAddress[0], RegNetworkAddress[1], RegNetworkAddress[2], RegNetworkAddress[3],
RegNetworkAddress[4], RegNetworkAddress[5]));
for(i = 0; i < DRIVER_LENGTH_OF_ADDRESS; i++)
Adapter->StationAddress[i] = RegNetworkAddress[i];
}
NdisCloseConfiguration(ConfigurationHandle);
} while(0);
/* find the nic */
if (!NICCheck(Adapter)) {
NDIS_DbgPrint(MID_TRACE, ("No adapter found at (0x%X).\n", Adapter->IOBase));
return NDIS_STATUS_ADAPTER_NOT_FOUND;
} else
NDIS_DbgPrint(MID_TRACE, ("Adapter found at (0x%X).\n", Adapter->IOBase));
NdisMSetAttributes( NdisMSetAttributes(
MiniportAdapterHandle, MiniportAdapterHandle,
(NDIS_HANDLE)Adapter, (NDIS_HANDLE)Adapter,
@ -220,8 +276,8 @@ NDIS_STATUS MiniportInitialize(
#ifndef NOCARD #ifndef NOCARD
Status = NICInitialize(Adapter); Status = NICInitialize(Adapter);
if (Status != NDIS_STATUS_SUCCESS) { if (Status != NDIS_STATUS_SUCCESS) {
DbgPrint("No NE2000 or compatible network adapter found at address 0x%X.\n", NDIS_DbgPrint(MIN_TRACE,("No NE2000 or compatible network adapter found at address 0x%X.\n",
Adapter->IOBase); Adapter->IOBase));
NDIS_DbgPrint(MID_TRACE, ("Status (0x%X).\n", Status)); NDIS_DbgPrint(MID_TRACE, ("Status (0x%X).\n", Status));
MiniportHalt((NDIS_HANDLE)Adapter); MiniportHalt((NDIS_HANDLE)Adapter);
@ -809,4 +865,81 @@ DriverEntry(
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
#if 0
/* while i'm here - some basic registry sanity checks */
{
/* write tests */
NDIS_CONFIGURATION_PARAMETER ParameterValue;
ParameterValue.ParameterType = NdisParameterInteger;
ParameterValue.ParameterData.IntegerData = 0x12345678;
NdisInitUnicodeString(&Keyword, L"DwordTest");
NdisWriteConfiguration(&Status, ConfigurationHandle, &Keyword, &ParameterValue);
if(Status != NDIS_STATUS_SUCCESS)
{
DbgPrint("ne2000!MiniportInitialize: failed to set DwordTest: 0x%x\n", Status);
KeBugCheck(0);
}
DbgPrint("ne2000!MiniportInitialize: DwordTest successfully set\n");
NdisInitUnicodeString(&Keyword, L"StringTest");
ParameterValue.ParameterType = NdisParameterString;
NdisInitUnicodeString(&ParameterValue.ParameterData.StringData, L"Testing123");
NdisWriteConfiguration(&Status, ConfigurationHandle, &Keyword, &ParameterValue);
if(Status != NDIS_STATUS_SUCCESS)
{
DbgPrint("ne2000!MiniportInitialize: failed to set StringTest: 0x%x\n", Status);
KeBugCheck(0);
}
DbgPrint("ne2000!MiniportInitialize: StringTest successfully set\n");
}
{
/* read back the test values */
NDIS_CONFIGURATION_PARAMETER *ParameterValue = 0;
NdisInitUnicodeString(&Keyword, L"DwordTest");
NdisReadConfiguration(&Status, &ParameterValue, ConfigurationHandle, &Keyword, NdisParameterInteger);
if(Status != NDIS_STATUS_SUCCESS)
{
DbgPrint("ne2000!MiniportInitialize: failed to read DwordTest: 0x%x\n", Status);
KeBugCheck(0);
}
if(ParameterValue->ParameterData.IntegerData != 0x12345678)
{
DbgPrint("ne2000!MiniportInitialize: DwordTest value is wrong: 0x%x\n",
ParameterValue->ParameterData.IntegerData);
KeBugCheck(0);
}
DbgPrint("ne2000!MiniportInitialize: DwordTest value was correctly read\n");
NdisInitUnicodeString(&Keyword, L"StringTest");
NdisReadConfiguration(&Status, &ParameterValue, ConfigurationHandle, &Keyword, NdisParameterString);
if(Status != NDIS_STATUS_SUCCESS)
{
DbgPrint("ne2000!MiniportInitialize: failed to read StringTest: 0x%x\n", Status);
KeBugCheck(0);
}
if(wcsncmp(ParameterValue->ParameterData.StringData.Buffer, L"Testing123",
wcslen(L"Testing123")))
{
DbgPrint("ne2000!MiniportInitialize: StringTest value is wrong: %wZ\n",
&ParameterValue->ParameterData.StringData);
KeBugCheck(0);
}
DbgPrint("ne2000!MiniportInitialize: StringTest value was correctly read\n");
}
#endif
/* EOF */ /* EOF */

5
reactos/drivers/net/ndis/Makefile
View file

@ -1,4 +1,4 @@
# $Id: Makefile,v 1.15 2002/09/08 10:22:16 chorns Exp $ # $Id: Makefile,v 1.16 2003/07/30 22:11:20 royce Exp $
PATH_TO_TOP = ../../.. PATH_TO_TOP = ../../..
@ -6,7 +6,7 @@ TARGET_TYPE = export_driver
TARGET_NAME = ndis TARGET_NAME = ndis
TARGET_CFLAGS = -I./include -DNDIS_WRAPPER -DBINARY_COMPATIBLE=1 TARGET_CFLAGS = -I./include -DNDIS_WRAPPER
TARGET_OBJECTS = \ TARGET_OBJECTS = \
ndis/main.o \ ndis/main.o \
@ -16,6 +16,7 @@ TARGET_OBJECTS = \
ndis/cl.o \ ndis/cl.o \
ndis/cm.o \ ndis/cm.o \
ndis/co.o \ ndis/co.o \
ndis/config.o \
ndis/control.o \ ndis/control.o \
ndis/hardware.o \ ndis/hardware.o \
ndis/io.o \ ndis/io.o \

16
reactos/drivers/net/ndis/include/miniport.h
View file

@ -26,8 +26,24 @@ typedef struct _MINIPORT_DRIVER {
WORK_QUEUE_ITEM WorkItem; /* Work item */ WORK_QUEUE_ITEM WorkItem; /* Work item */
PDRIVER_OBJECT DriverObject; /* Driver object of miniport */ PDRIVER_OBJECT DriverObject; /* Driver object of miniport */
LIST_ENTRY AdapterListHead; /* Adapters created by miniport */ LIST_ENTRY AdapterListHead; /* Adapters created by miniport */
PUNICODE_STRING RegistryPath; /* SCM Registry key */
} MINIPORT_DRIVER, *PMINIPORT_DRIVER; } MINIPORT_DRIVER, *PMINIPORT_DRIVER;
/* resources allocated on behalf on the miniport */
#define MINIPORT_RESOURCE_TYPE_MEMORY 0
typedef struct _MINIPORT_RESOURCE {
LIST_ENTRY ListEntry;
ULONG ResourceType;
PVOID Resource;
} MINIPORT_RESOURCE, *PMINIPORT_RESOURCE;
/* Configuration context */
typedef struct _MINIPORT_CONFIGURATION_CONTEXT {
NDIS_HANDLE Handle;
LIST_ENTRY ResourceListHead;
KSPIN_LOCK ResourceLock;
} MINIPORT_CONFIGURATION_CONTEXT, *PMINIPORT_CONFIGURATION_CONTEXT;
#define GET_MINIPORT_DRIVER(Handle)((PMINIPORT_DRIVER)Handle) #define GET_MINIPORT_DRIVER(Handle)((PMINIPORT_DRIVER)Handle)
/* Information about a logical adapter */ /* Information about a logical adapter */

357
reactos/drivers/net/ndis/ndis/miniport.c
View file

@ -20,6 +20,10 @@
ULONG DebugTraceLevel = (MAX_TRACE + DEBUG_MINIPORT); ULONG DebugTraceLevel = (MAX_TRACE + DEBUG_MINIPORT);
#endif /* DBG */ #endif /* DBG */
#define SERVICES_ROOT L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\"
#define DEVICE_ROOT L"\\Device\\"
#define ROUTE_DATA_SIZE 256 /* adjust as necessary */
/* Number of media we know */ /* Number of media we know */
#define MEDIA_ARRAY_SIZE 15 #define MEDIA_ARRAY_SIZE 15
@ -54,9 +58,9 @@ VOID
MiniDisplayPacket( MiniDisplayPacket(
PNDIS_PACKET Packet) PNDIS_PACKET Packet)
{ {
#if 0
ULONG i, Length; ULONG i, Length;
UCHAR Buffer[64]; UCHAR Buffer[64];
#if 0
if ((DebugTraceLevel | DEBUG_PACKET) > 0) { if ((DebugTraceLevel | DEBUG_PACKET) > 0) {
Length = CopyPacketToBuffer( Length = CopyPacketToBuffer(
(PUCHAR)&Buffer, (PUCHAR)&Buffer,
@ -817,9 +821,14 @@ NdisInitializeWrapper(
* SystemSpecific1 = Pointer to the driver's driver object * SystemSpecific1 = Pointer to the driver's driver object
* SystemSpecific2 = Pointer to the driver's registry path * SystemSpecific2 = Pointer to the driver's registry path
* SystemSpecific3 = Always NULL * SystemSpecific3 = Always NULL
* NOTES:
* - SystemSpecific2 goes invalid so we copy it
* - Registry key is 0-terminated for safety
*/ */
{ {
PMINIPORT_DRIVER Miniport; PMINIPORT_DRIVER Miniport;
PUNICODE_STRING RegistryPath;
WCHAR *RegistryBuffer;
NDIS_DbgPrint(MAX_TRACE, ("Called.\n")); NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
@ -838,6 +847,30 @@ NdisInitializeWrapper(
Miniport->DriverObject = (PDRIVER_OBJECT)SystemSpecific1; Miniport->DriverObject = (PDRIVER_OBJECT)SystemSpecific1;
/* set the miniport's driver registry path */
RegistryPath = ExAllocatePool(PagedPool, sizeof(UNICODE_STRING));
if(!RegistryPath)
{
NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
return;
}
RegistryPath->Length = ((PUNICODE_STRING)SystemSpecific2)->Length;
RegistryPath->MaximumLength = RegistryPath->Length + 1; /* room for 0-term */
RegistryBuffer = ExAllocatePool(PagedPool, RegistryPath->Length + sizeof(WCHAR));
if(!RegistryBuffer)
{
NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
return;
}
RtlCopyMemory(RegistryBuffer, ((PUNICODE_STRING)SystemSpecific2)->Buffer, RegistryPath->Length);
RegistryBuffer[RegistryPath->Length] = 0;
RegistryPath->Buffer = RegistryBuffer;
Miniport->RegistryPath = RegistryPath;
InitializeListHead(&Miniport->AdapterListHead); InitializeListHead(&Miniport->AdapterListHead);
/* Put miniport in global miniport list */ /* Put miniport in global miniport list */
@ -997,6 +1030,12 @@ NdisMRegisterMiniport(
* CharacteristicsLength = Number of bytes in characteristics buffer * CharacteristicsLength = Number of bytes in characteristics buffer
* RETURNS: * RETURNS:
* Status of operation * Status of operation
* NOTES:
* - To create device objects for the miniport, the Route value under Linkage is
* parsed. I don't know if this is the way Microsoft does it or not.
* TODO:
* verify this algorithm by playing with nt
* break this function up
*/ */
{ {
UINT MinSize; UINT MinSize;
@ -1009,6 +1048,15 @@ NdisMRegisterMiniport(
NDIS_OID AddressOID; NDIS_OID AddressOID;
BOOLEAN MemError = FALSE; BOOLEAN MemError = FALSE;
PMINIPORT_DRIVER Miniport = GET_MINIPORT_DRIVER(NdisWrapperHandle); PMINIPORT_DRIVER Miniport = GET_MINIPORT_DRIVER(NdisWrapperHandle);
OBJECT_ATTRIBUTES DeviceKeyAttributes;
OBJECT_ATTRIBUTES LinkageKeyAttributes;
HANDLE DeviceKeyHandle;
HANDLE LinkageKeyHandle;
UNICODE_STRING RouteVal;
UNICODE_STRING LinkageKeyName;
KEY_VALUE_PARTIAL_INFORMATION *RouteData;
ULONG RouteDataLength;
UINT NextRouteOffset = 0;
NDIS_DbgPrint(MAX_TRACE, ("Called.\n")); NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
@ -1061,125 +1109,204 @@ NdisMRegisterMiniport(
RtlCopyMemory(&Miniport->Chars, MiniportCharacteristics, MinSize); RtlCopyMemory(&Miniport->Chars, MiniportCharacteristics, MinSize);
Adapter = ExAllocatePool(NonPagedPool, sizeof(LOGICAL_ADAPTER)); /* Read the miniport config from the registry */
if (!Adapter) { InitializeObjectAttributes(&DeviceKeyAttributes, Miniport->RegistryPath, OBJ_CASE_INSENSITIVE, NULL, NULL);
NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
Status = ZwOpenKey(&DeviceKeyHandle, KEY_READ, &DeviceKeyAttributes);
if(!NT_SUCCESS(Status))
{
NDIS_DbgPrint(MIN_TRACE,("Failed to open driver key: 0x%x\n", Status));
return NDIS_STATUS_FAILURE;
}
RtlInitUnicodeString(&LinkageKeyName, L"Linkage");
InitializeObjectAttributes(&LinkageKeyAttributes, &LinkageKeyName, OBJ_CASE_INSENSITIVE, DeviceKeyHandle, NULL);
Status = ZwOpenKey(&LinkageKeyHandle, KEY_READ, &LinkageKeyAttributes);
if(!NT_SUCCESS(Status))
{
NDIS_DbgPrint(MIN_TRACE,("Failed to open Linkage key: 0x%x\n", Status));
ZwClose(DeviceKeyHandle);
return NDIS_STATUS_FAILURE;
}
RouteData = ExAllocatePool(PagedPool, ROUTE_DATA_SIZE);
if(!RouteData)
{
NDIS_DbgPrint(MIN_TRACE,("Insufficient resources\n"));
ZwClose(LinkageKeyHandle);
ZwClose(DeviceKeyHandle);
return NDIS_STATUS_RESOURCES; return NDIS_STATUS_RESOURCES;
} }
/* This is very important */ RtlInitUnicodeString(&RouteVal, L"Route");
RtlZeroMemory(Adapter, sizeof(LOGICAL_ADAPTER));
/* Create the device object for this adapter */ Status = ZwQueryValueKey(LinkageKeyHandle, &RouteVal, KeyValuePartialInformation, RouteData, ROUTE_DATA_SIZE, &RouteDataLength);
/* FIXME: Use GUIDs */ if(!NT_SUCCESS(Status))
RtlInitUnicodeStringFromLiteral(&Adapter->DeviceName, L"\\Device\\ne2000"); {
Status = IoCreateDevice(Miniport->DriverObject, NDIS_DbgPrint(MIN_TRACE,("Failed to query Route value\n"));
0, ZwClose(LinkageKeyHandle);
&Adapter->DeviceName, ZwClose(DeviceKeyHandle);
FILE_DEVICE_PHYSICAL_NETCARD, ExFreePool(RouteData);
0,
FALSE,
&Adapter->NdisMiniportBlock.DeviceObject);
if (!NT_SUCCESS(Status)) {
NDIS_DbgPrint(MIN_TRACE, ("Could not create device object.\n"));
ExFreePool(Adapter);
return NDIS_STATUS_FAILURE; return NDIS_STATUS_FAILURE;
} }
/* Initialize adapter object */ ZwClose(LinkageKeyHandle);
ZwClose(DeviceKeyHandle);
KeInitializeSpinLock(&Adapter->NdisMiniportBlock.Lock); /* route is a REG_MULTI_SZ with each nic object created by NDI - create an adapter for each */
while((RouteData->Data)[NextRouteOffset])
{
WCHAR *DeviceName;
HANDLE RegKeyHandle;
WCHAR *RegKeyPath;
UNICODE_STRING RegKeyPathU;
OBJECT_ATTRIBUTES RegKeyAttributes;
InitializeListHead(&Adapter->ProtocolListHead); Adapter = ExAllocatePool(NonPagedPool, sizeof(LOGICAL_ADAPTER));
if (!Adapter) {
NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
ExFreePool(RouteData);
return NDIS_STATUS_RESOURCES;
}
Adapter->RefCount = 1; /* This is very important */
RtlZeroMemory(Adapter, sizeof(LOGICAL_ADAPTER));
Adapter->Miniport = Miniport; DeviceName = ExAllocatePool(NonPagedPool, sizeof(DEVICE_ROOT) + RouteData->DataLength);
if(!DeviceName)
{
NDIS_DbgPrint(MIN_TRACE,("Insufficient memory\n"));
ExFreePool(Adapter);
ExFreePool(RouteData);
return NDIS_STATUS_RESOURCES;
}
/* Set handlers (some NDIS macros require these) */ wcscpy(DeviceName, DEVICE_ROOT);
wcsncat(DeviceName, (WCHAR *)RouteData->Data, RouteData->DataLength); /* reg_sz is 0-term by def */
RtlInitUnicodeString(&Adapter->DeviceName, DeviceName);
Adapter->NdisMiniportBlock.EthRxCompleteHandler = MiniEthReceiveComplete; NDIS_DbgPrint(MAX_TRACE, ("creating device %ws\n", DeviceName));
Adapter->NdisMiniportBlock.EthRxIndicateHandler = MiniEthReceiveIndication;
Adapter->NdisMiniportBlock.SendCompleteHandler = MiniSendComplete; Status = IoCreateDevice(Miniport->DriverObject, 0, &Adapter->DeviceName, FILE_DEVICE_PHYSICAL_NETCARD,
Adapter->NdisMiniportBlock.SendResourcesHandler = MiniSendResourcesAvailable; 0, FALSE, &Adapter->NdisMiniportBlock.DeviceObject);
Adapter->NdisMiniportBlock.ResetCompleteHandler = MiniResetComplete; if (!NT_SUCCESS(Status)) {
Adapter->NdisMiniportBlock.TDCompleteHandler = MiniTransferDataComplete; NDIS_DbgPrint(MIN_TRACE, ("Could not create device object.\n"));
ExFreePool(Adapter);
ExFreePool(RouteData);
KeInitializeDpc(&Adapter->MiniportDpc, MiniportDpc, (PVOID)Adapter);
/* Put adapter in adapter list for this miniport */
ExInterlockedInsertTailList(&Miniport->AdapterListHead,
&Adapter->MiniportListEntry,
&Miniport->Lock);
/* Put adapter in global adapter list */
ExInterlockedInsertTailList(&AdapterListHead,
&Adapter->ListEntry,
&AdapterListLock);
/* Call MiniportInitialize */
NdisStatus = (*Miniport->Chars.InitializeHandler)(
&OpenErrorStatus,
&SelectedMediumIndex,
&MediaArray[0],
MEDIA_ARRAY_SIZE,
Adapter,
NULL /* FIXME: WrapperConfigurationContext */);
if ((NdisStatus == NDIS_STATUS_SUCCESS) &&
(SelectedMediumIndex < MEDIA_ARRAY_SIZE)) {
Adapter->NdisMiniportBlock.MediaType = MediaArray[SelectedMediumIndex];
switch (Adapter->NdisMiniportBlock.MediaType) {
case NdisMedium802_3:
Adapter->MediumHeaderSize = 14;
AddressOID = OID_802_3_CURRENT_ADDRESS;
Adapter->AddressLength = ETH_LENGTH_OF_ADDRESS;
Adapter->NdisMiniportBlock.FilterDbs.u.EthDB = ExAllocatePool(NonPagedPool,
sizeof(ETH_FILTER));
if (Adapter->NdisMiniportBlock.FilterDbs.u.EthDB) {
RtlZeroMemory(Adapter->NdisMiniportBlock.FilterDbs.u.EthDB, sizeof(ETH_FILTER));
Adapter->NdisMiniportBlock.FilterDbs.u.EthDB->Miniport = (PNDIS_MINIPORT_BLOCK)Adapter;
} else
MemError = TRUE;
break;
default:
/* FIXME: Support other types of medias */
ASSERT(FALSE);
return NDIS_STATUS_FAILURE; return NDIS_STATUS_FAILURE;
} }
NdisStatus = DoQueries(Adapter, AddressOID); RegKeyPath = ExAllocatePool(PagedPool, sizeof(SERVICES_ROOT)+RouteData->DataLength); /* includes room for a 0-term */
} if(!RegKeyPath)
{
NDIS_DbgPrint(MIN_TRACE,("Insufficient resources\n"));
ExFreePool(Adapter);
ExFreePool(RouteData);
return NDIS_STATUS_FAILURE;
}
if ((MemError) || wcscpy(RegKeyPath, SERVICES_ROOT);
(NdisStatus != NDIS_STATUS_SUCCESS) || wcsncat(RegKeyPath, (WCHAR *)RouteData->Data, RouteData->DataLength);
(SelectedMediumIndex >= MEDIA_ARRAY_SIZE)) { RegKeyPath[sizeof(SERVICES_ROOT)+RouteData->DataLength-1] = 0;
/* Remove adapter from adapter list for this miniport */ RtlInitUnicodeString(&RegKeyPathU, RegKeyPath);
KeAcquireSpinLock(&Miniport->Lock, &OldIrql); InitializeObjectAttributes(&RegKeyAttributes, &RegKeyPathU, OBJ_CASE_INSENSITIVE, NULL, NULL);
RemoveEntryList(&Adapter->MiniportListEntry);
KeReleaseSpinLock(&Miniport->Lock, OldIrql);
/* Remove adapter from global adapter list */ Status = ZwOpenKey(&RegKeyHandle, KEY_ALL_ACCESS, &RegKeyAttributes);
KeAcquireSpinLock(&AdapterListLock, &OldIrql); if(Status != STATUS_SUCCESS)
RemoveEntryList(&Adapter->ListEntry); {
KeReleaseSpinLock(&AdapterListLock, OldIrql); NDIS_DbgPrint(MIN_TRACE,("ndis!NdisMRegisterMiniport: failed to open adapter-specific reg key %ws\n", RegKeyPath));
ExFreePool(Adapter);
ExFreePool(RouteData);
return NDIS_STATUS_FAILURE;
}
if (Adapter->LookaheadBuffer) KeInitializeSpinLock(&Adapter->NdisMiniportBlock.Lock);
InitializeListHead(&Adapter->ProtocolListHead);
Adapter->RefCount = 1;
Adapter->Miniport = Miniport;
/* Set handlers (some NDIS macros require these) */
Adapter->NdisMiniportBlock.EthRxCompleteHandler = MiniEthReceiveComplete;
Adapter->NdisMiniportBlock.EthRxIndicateHandler = MiniEthReceiveIndication;
Adapter->NdisMiniportBlock.SendCompleteHandler = MiniSendComplete;
Adapter->NdisMiniportBlock.SendResourcesHandler = MiniSendResourcesAvailable;
Adapter->NdisMiniportBlock.ResetCompleteHandler = MiniResetComplete;
Adapter->NdisMiniportBlock.TDCompleteHandler = MiniTransferDataComplete;
KeInitializeDpc(&Adapter->MiniportDpc, MiniportDpc, (PVOID)Adapter);
/* Put adapter in adapter list for this miniport */
ExInterlockedInsertTailList(&Miniport->AdapterListHead, &Adapter->MiniportListEntry, &Miniport->Lock);
/* Put adapter in global adapter list */
ExInterlockedInsertTailList(&AdapterListHead, &Adapter->ListEntry, &AdapterListLock);
/* Call MiniportInitialize */
NDIS_DbgPrint(MID_TRACE, ("calling MiniportInitialize\n"));
NdisStatus = (*Miniport->Chars.InitializeHandler)( &OpenErrorStatus, &SelectedMediumIndex, &MediaArray[0],
MEDIA_ARRAY_SIZE, Adapter, RegKeyHandle);
ZwClose(RegKeyHandle);
if ((NdisStatus == NDIS_STATUS_SUCCESS) && (SelectedMediumIndex < MEDIA_ARRAY_SIZE)) {
NDIS_DbgPrint(MID_TRACE,("successful return from MiniportInitialize\n"));
Adapter->NdisMiniportBlock.MediaType = MediaArray[SelectedMediumIndex];
switch (Adapter->NdisMiniportBlock.MediaType) {
case NdisMedium802_3:
Adapter->MediumHeaderSize = 14;
AddressOID = OID_802_3_CURRENT_ADDRESS;
Adapter->AddressLength = ETH_LENGTH_OF_ADDRESS;
Adapter->NdisMiniportBlock.FilterDbs.u.EthDB = ExAllocatePool(NonPagedPool, sizeof(ETH_FILTER));
if (Adapter->NdisMiniportBlock.FilterDbs.u.EthDB) {
RtlZeroMemory(Adapter->NdisMiniportBlock.FilterDbs.u.EthDB, sizeof(ETH_FILTER));
Adapter->NdisMiniportBlock.FilterDbs.u.EthDB->Miniport = (PNDIS_MINIPORT_BLOCK)Adapter;
} else
MemError = TRUE;
break;
default:
/* FIXME: Support other types of media */
ExFreePool(Adapter);
ExFreePool(RouteData);
ASSERT(FALSE);
return NDIS_STATUS_FAILURE;
}
NdisStatus = DoQueries(Adapter, AddressOID);
}
if ((MemError) || (NdisStatus != NDIS_STATUS_SUCCESS) || (SelectedMediumIndex >= MEDIA_ARRAY_SIZE)) {
/* Remove adapter from adapter list for this miniport */
KeAcquireSpinLock(&Miniport->Lock, &OldIrql);
RemoveEntryList(&Adapter->MiniportListEntry);
KeReleaseSpinLock(&Miniport->Lock, OldIrql);
/* Remove adapter from global adapter list */
KeAcquireSpinLock(&AdapterListLock, &OldIrql);
RemoveEntryList(&Adapter->ListEntry);
KeReleaseSpinLock(&AdapterListLock, OldIrql);
if (Adapter->LookaheadBuffer)
ExFreePool(Adapter->LookaheadBuffer); ExFreePool(Adapter->LookaheadBuffer);
IoDeleteDevice(Adapter->NdisMiniportBlock.DeviceObject); IoDeleteDevice(Adapter->NdisMiniportBlock.DeviceObject);
ExFreePool(Adapter); ExFreePool(Adapter);
NDIS_DbgPrint(MIN_TRACE, ("MiniportInitialize() failed.\n")); NDIS_DbgPrint(MIN_TRACE, ("MiniportInitialize() failed for an adapter.\n"));
return NDIS_STATUS_FAILURE; }
/* NextRouteOffset += wcslen((WCHAR *)RouteData->Data); */
RouteData->Data[NextRouteOffset] = 0; /* will cause the while to break */
} }
ExFreePool(RouteData);
return NDIS_STATUS_SUCCESS; return NDIS_STATUS_SUCCESS;
} }
@ -1404,7 +1531,47 @@ NdisTerminateWrapper(
NDIS_DbgPrint(MAX_TRACE, ("Called.\n")); NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
ExFreePool(Miniport->RegistryPath->Buffer);
ExFreePool(Miniport->RegistryPath);
ExFreePool(Miniport); ExFreePool(Miniport);
} }
/* EOF */ /* EOF */
/* enum test */
/*
{
ULONG KeyInformationSize;
KEY_BASIC_INFORMATION *KeyInformation;
int i;
KeyInformation = ExAllocatePool(PagedPool, 1024);
ASSERT(KeyInformation);
RtlInitUnicodeString(&LinkageKeyName, L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\NE2000");
InitializeObjectAttributes(&LinkageKeyAttributes, &LinkageKeyName, OBJ_CASE_INSENSITIVE|OBJ_KERNEL_HANDLE, NULL, NULL);
Status = ZwOpenKey(&LinkageKeyHandle, KEY_READ, &LinkageKeyAttributes);
if(!NT_SUCCESS(Status))
{
DbgPrint("ndis!NdisMRegisterMiniport: Failed to open Linkage key: 0x%x\n", Status);
ASSERT(0);
KeBugCheck(0);
}
for(i=0;i<5;i++)
{
Status = ZwEnumerateKey(LinkageKeyHandle, i, KeyBasicInformation, KeyInformation, 1024, &KeyInformationSize);
if(!NT_SUCCESS(Status))
{
DbgPrint("ndis!NdisMRegisterMiniport: Failed to enumerate: 0x%x\n", Status);
break;
}
KeyInformation->Name[KeyInformation->NameLength] = 0;
DbgPrint("ndis!NdisMRegisterMiniport: enumerated key %ws\n", KeyInformation->Name);
}
ExFreePool(KeyInformation);
KeBugCheck(0);
}
*/

136
reactos/drivers/net/ndis/ndis/stubs.c
View file

@ -9,7 +9,6 @@
*/ */
#include <ndissys.h> #include <ndissys.h>
/* /*
* @unimplemented * @unimplemented
*/ */
@ -164,22 +163,6 @@ NdisMapFile(
UNIMPLEMENTED UNIMPLEMENTED
} }
/*
* @unimplemented
*/
VOID
EXPORT
NdisWriteConfiguration(
OUT PNDIS_STATUS Status,
IN NDIS_HANDLE WrapperConfigurationContext,
IN PNDIS_STRING Keyword,
IN PNDIS_CONFIGURATION_PARAMETER * ParameterValue)
{
UNIMPLEMENTED
}
/* /*
* @unimplemented * @unimplemented
*/ */
@ -198,18 +181,6 @@ NdisWriteErrorLogEntry(
} }
/*
* @unimplemented
*/
VOID
EXPORT
NdisCloseConfiguration(
IN NDIS_HANDLE ConfigurationHandle)
{
UNIMPLEMENTED
}
/* /*
* @unimplemented * @unimplemented
*/ */
@ -310,26 +281,6 @@ NdisMWanSendComplete(
} }
/*
* @unimplemented
*/
VOID
EXPORT
NdisOpenConfiguration(
OUT PNDIS_STATUS Status,
OUT PNDIS_HANDLE ConfigurationHandle,
IN NDIS_HANDLE WrapperConfigurationContext)
{
UNIMPLEMENTED
}
/*
NdisOpenConfigurationKeyByIndex
NdisOpenConfigurationKeyByName
*/
/* /*
* @unimplemented * @unimplemented
*/ */
@ -350,51 +301,6 @@ NdisOpenFile(
NdisOpenGlobalConfiguration NdisOpenGlobalConfiguration
*/ */
/*
* @unimplemented
*/
VOID
EXPORT
NdisOpenProtocolConfiguration(
OUT PNDIS_STATUS Status,
OUT PNDIS_HANDLE ConfigurationHandle,
IN PNDIS_STRING ProtocolSection)
{
UNIMPLEMENTED
}
/*
* @unimplemented
*/
VOID
EXPORT
NdisReadConfiguration(
OUT PNDIS_STATUS Status,
OUT PNDIS_CONFIGURATION_PARAMETER * ParameterValue,
IN NDIS_HANDLE ConfigurationHandle,
IN PNDIS_STRING Keyword,
IN NDIS_PARAMETER_TYPE ParameterType)
{
UNIMPLEMENTED
}
/*
* @unimplemented
*/
VOID
EXPORT
NdisReadNetworkAddress(
OUT PNDIS_STATUS Status,
OUT PVOID * NetworkAddress,
OUT PUINT NetworkAddressLength,
IN NDIS_HANDLE ConfigurationHandle)
{
UNIMPLEMENTED
}
#if 0 #if 0
VOID VOID
EXPORT EXPORT
@ -877,48 +783,6 @@ NdisMSetMiniportSecondary(
} }
/*
* @unimplemented
*/
VOID
EXPORT
NdisOpenConfigurationKeyByIndex(
OUT PNDIS_STATUS Status,
IN NDIS_HANDLE ConfigurationHandle,
IN ULONG Index,
OUT PNDIS_STRING KeyName,
OUT PNDIS_HANDLE KeyHandle)
/*
* FUNCTION:
* ARGUMENTS:
* NOTES:
* NDIS 5.0
*/
{
UNIMPLEMENTED
}
/*
* @unimplemented
*/
VOID
EXPORT
NdisOpenConfigurationKeyByName(
OUT PNDIS_STATUS Status,
IN NDIS_HANDLE ConfigurationHandle,
IN PNDIS_STRING SubKeyName,
OUT PNDIS_HANDLE SubKeyHandle)
/*
* FUNCTION:
* ARGUMENTS:
* NOTES:
* NDIS 5.0
*/
{
UNIMPLEMENTED
}
/* /*
* @unimplemented * @unimplemented

2
reactos/drivers/net/tditest/include/debug.h
View file

@ -41,7 +41,7 @@ extern DWORD DebugTraceLevel;
#endif /* _MSC_VER */ #endif /* _MSC_VER */
/* in rtl.h now */ /* in ndis.h now */
#if 0 #if 0
#ifdef ASSERT #ifdef ASSERT
#undef ASSERT #undef ASSERT

2
reactos/drivers/net/wshtcpip/debug.h
View file

@ -28,7 +28,7 @@ extern DWORD DebugTraceLevel;
DbgPrint _x_; \ DbgPrint _x_; \
} }
/* this belongs in rtl */ /* this belongs in ndis.h */
#if 0 #if 0
#ifdef ASSERT #ifdef ASSERT
#undef ASSERT #undef ASSERT

135
reactos/include/net/ndis.h
View file

@ -427,7 +427,6 @@ NdisSetTimer(
IN PNDIS_TIMER Timer, IN PNDIS_TIMER Timer,
IN UINT MillisecondsToDelay); IN UINT MillisecondsToDelay);
/* Hardware */ /* Hardware */
typedef CM_MCA_POS_DATA NDIS_MCA_POS_DATA, *PNDIS_MCA_POS_DATA; typedef CM_MCA_POS_DATA NDIS_MCA_POS_DATA, *PNDIS_MCA_POS_DATA;
@ -717,15 +716,35 @@ typedef enum _NDIS_INTERFACE_TYPE
#define NdisInterruptLatched Latched #define NdisInterruptLatched Latched
typedef KINTERRUPT_MODE NDIS_INTERRUPT_MODE, *PNDIS_INTERRUPT_MODE; typedef KINTERRUPT_MODE NDIS_INTERRUPT_MODE, *PNDIS_INTERRUPT_MODE;
typedef enum _NDIS_PROCESSOR_TYPE
{
NdisProcessorX86,
NdisProcessorMips,
NdisProcessorAlpha,
NdisProcessorPpc
} NDIS_PROCESSOR_TYPE, *PNDIS_PROCESSOR_TYPE;
typedef enum _NDIS_ENVIRONMENT_TYPE
{
NdisEnvironmentWindows,
NdisEnvironmentWindowsNt
} NDIS_ENVIRONMENT_TYPE, *PNDIS_ENVIRONMENT_TYPE;
typedef enum _NDIS_PARAMETER_TYPE typedef enum _NDIS_PARAMETER_TYPE
{ {
NdisParameterInteger, NdisParameterInteger,
NdisParameterHexInteger, NdisParameterHexInteger,
NdisParameterString, NdisParameterString,
NdisParameterMultiString NdisParameterMultiString,
NdisParameterBinary
} NDIS_PARAMETER_TYPE, *PNDIS_PARAMETER_TYPE; } NDIS_PARAMETER_TYPE, *PNDIS_PARAMETER_TYPE;
typedef struct
{
USHORT Length;
PVOID Buffer;
} BINARY_DATA;
typedef struct _NDIS_CONFIGURATION_PARAMETER typedef struct _NDIS_CONFIGURATION_PARAMETER
{ {
NDIS_PARAMETER_TYPE ParameterType; NDIS_PARAMETER_TYPE ParameterType;
@ -733,6 +752,7 @@ typedef struct _NDIS_CONFIGURATION_PARAMETER
{ {
ULONG IntegerData; ULONG IntegerData;
NDIS_STRING StringData; NDIS_STRING StringData;
BINARY_DATA BinaryData;
} ParameterData; } ParameterData;
} NDIS_CONFIGURATION_PARAMETER, *PNDIS_CONFIGURATION_PARAMETER; } NDIS_CONFIGURATION_PARAMETER, *PNDIS_CONFIGURATION_PARAMETER;
@ -2521,13 +2541,45 @@ NdisReadConfiguration(
IN PNDIS_STRING Keyword, IN PNDIS_STRING Keyword,
IN NDIS_PARAMETER_TYPE ParameterType); IN NDIS_PARAMETER_TYPE ParameterType);
VOID
EXPIMP
NdisReadNetworkAddress(
OUT PNDIS_STATUS Status,
OUT PVOID *NetworkAddress,
OUT PUINT NetworkAddressLength,
IN NDIS_HANDLE ConfigurationHandle);
VOID VOID
EXPIMP EXPIMP
NdisWriteConfiguration( NdisWriteConfiguration(
OUT PNDIS_STATUS Status, OUT PNDIS_STATUS Status,
IN NDIS_HANDLE WrapperConfigurationContext, IN NDIS_HANDLE ConfigurationHandle,
IN PNDIS_STRING Keyword, IN PNDIS_STRING Keyword,
IN PNDIS_CONFIGURATION_PARAMETER *ParameterValue); IN PNDIS_CONFIGURATION_PARAMETER ParameterValue);
VOID
EXPIMP
NdisOpenConfiguration(
OUT PNDIS_STATUS Status,
OUT PNDIS_HANDLE ConfigurationHandle,
IN NDIS_HANDLE WrapperConfigurationContext);
VOID
EXPIMP
NdisOpenConfigurationKeyByIndex(
OUT PNDIS_STATUS Status,
IN NDIS_HANDLE ConfigurationHandle,
IN ULONG Index,
OUT PNDIS_STRING KeyName,
OUT PNDIS_HANDLE KeyHandle);
VOID
EXPIMP
NdisOpenConfigurationKeyByName(
OUT PNDIS_STATUS Status,
IN NDIS_HANDLE ConfigurationHandle,
IN PNDIS_STRING SubKeyName,
OUT PNDIS_HANDLE SubKeyHandle);
VOID VOID
@ -2901,23 +2953,6 @@ NdisMSetMiniportSecondary(
IN NDIS_HANDLE MiniportAdapterHandle, IN NDIS_HANDLE MiniportAdapterHandle,
IN NDIS_HANDLE PrimaryMiniportAdapterHandle); IN NDIS_HANDLE PrimaryMiniportAdapterHandle);
VOID
EXPIMP
NdisOpenConfigurationKeyByIndex(
OUT PNDIS_STATUS Status,
IN NDIS_HANDLE ConfigurationHandle,
IN ULONG Index,
OUT PNDIS_STRING KeyName,
OUT PNDIS_HANDLE KeyHandle);
VOID
EXPIMP
NdisOpenConfigurationKeyByName(
OUT PNDIS_STATUS Status,
IN NDIS_HANDLE ConfigurationHandle,
IN PNDIS_STRING SubKeyName,
OUT PNDIS_HANDLE SubKeyHandle);
UINT UINT
EXPIMP EXPIMP
NdisPacketPoolUsage( NdisPacketPoolUsage(
@ -4815,6 +4850,22 @@ struct _NDIS_OPEN_BLOCK
/* Routines for NDIS miniport drivers */ /* Routines for NDIS miniport drivers */
/*
* VOID NdisMInitializeWrapper(
* OUT PNDIS_HANDLE NdisWrapperHandle,
* IN PVOID SystemSpecific1,
* IN PVOID SystemSpecific2,
* IN PVOID SystemSpecific3);
*/
#define NdisMInitializeWrapper(NdisWrapperHandle, \
SystemSpecific1, \
SystemSpecific2, \
SystemSpecific3) \
NdisInitializeWrapper((NdisWrapperHandle), \
(SystemSpecific1), \
(SystemSpecific2), \
(SystemSpecific3))
VOID VOID
EXPIMP EXPIMP
NdisInitializeWrapper( NdisInitializeWrapper(
@ -4995,22 +5046,6 @@ EXPIMP
NdisMIndicateStatusComplete( NdisMIndicateStatusComplete(
IN NDIS_HANDLE MiniportAdapterHandle); IN NDIS_HANDLE MiniportAdapterHandle);
/*
* VOID NdisMInitializeWrapper(
* OUT PNDIS_HANDLE NdisWrapperHandle,
* IN PVOID SystemSpecific1,
* IN PVOID SystemSpecific2,
* IN PVOID SystemSpecific3);
*/
#define NdisMInitializeWrapper(NdisWrapperHandle, \
SystemSpecific1, \
SystemSpecific2, \
SystemSpecific3) \
NdisInitializeWrapper((NdisWrapperHandle), \
(SystemSpecific1), \
(SystemSpecific2), \
(SystemSpecific3))
NDIS_STATUS NDIS_STATUS
EXPIMP EXPIMP
NdisMMapIoSpace( NdisMMapIoSpace(
@ -5058,6 +5093,32 @@ NdisMRegisterMiniport(
IN PNDIS_MINIPORT_CHARACTERISTICS MiniportCharacteristics, IN PNDIS_MINIPORT_CHARACTERISTICS MiniportCharacteristics,
IN UINT CharacteristicsLength); IN UINT CharacteristicsLength);
VOID
EXPIMP
NdisMSetTimer(
IN PNDIS_MINIPORT_TIMER Timer,
IN UINT MillisecondsToDelay);
VOID
EXPIMP
NdisMInitializeTimer(
IN OUT PNDIS_MINIPORT_TIMER Timer,
IN NDIS_HANDLE MiniportAdapterHandle,
IN PNDIS_TIMER_FUNCTION TimerFunction,
IN PVOID FunctionContext);
VOID
EXPIMP
NdisMSetPeriodicTimer(
IN PNDIS_MINIPORT_TIMER Timer,
IN UINT MillisecondPeriod);
VOID
EXPIMP
NdisMCancelTimer(
IN PNDIS_MINIPORT_TIMER Timer,
OUT PBOOLEAN TimerCancelled);
#ifndef NDIS_WRAPPER #ifndef NDIS_WRAPPER