Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-02-23 17:05:46 +00:00
Code Issues Projects Releases Packages Wiki Activity

Basic NDIS 3.0 support

Browse source 
svn path=/trunk/; revision=1318
This commit is contained in:
Casper Hornstrup 2000-08-27 16:31:41 +00:00
parent abd30f9819
commit 33252ab449
13 changed files with 3225 additions and 927 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

26
reactos/drivers/net/ndis/include/buffer.h
View file

@ -25,6 +25,32 @@ typedef struct _NDIS_BUFFER_POOL
NETWORK_HEADER Buffers[0];
} NDIS_BUFFER_POOL, *PNDIS_BUFFER_POOL;
UINT CopyBufferToBufferChain(
PNDIS_BUFFER DstBuffer,
UINT DstOffset,
PUCHAR SrcData,
UINT Length);
UINT CopyBufferChainToBuffer(
PUCHAR DstData,
PNDIS_BUFFER SrcBuffer,
UINT SrcOffset,
UINT Length);
UINT CopyPacketToBuffer(
PUCHAR DstData,
PNDIS_PACKET SrcPacket,
UINT SrcOffset,
UINT Length);
UINT CopyPacketToBufferChain(
PNDIS_BUFFER DstBuffer,
UINT DstOffset,
PNDIS_PACKET SrcPacket,
UINT SrcOffset,
UINT Length);
#endif /* __BUFFER_H */
/* EOF */

5
reactos/drivers/net/ndis/include/debug.h
View file

@ -18,6 +18,7 @@
#define DEBUG_REFCOUNT 0x00000100
#define DEBUG_MINIPORT 0x00000200
#define DEBUG_PROTOCOL 0x00000400
#define DEBUG_PACKET 0x00000800
#define DEBUG_ULTRA 0xFFFFFFFF
#ifdef DBG
@ -74,7 +75,7 @@ extern DWORD DebugTraceLevel;
#ifdef _MSC_VER
#define UNIMPLEMENTED \
NDIS_DbgPrint(MIN_TRACE, ("The function at %s:%d is unimplemented.\n", __FILE__, __LINE__));
NDIS_DbgPrint(MIN_TRACE, ("The function at (%s:%d) is unimplemented.\n", __FILE__, __LINE__));
#else /* _MSC_VER */
@ -85,7 +86,7 @@ extern DWORD DebugTraceLevel;
#define CHECKPOINT \
do { NDIS_DbgPrint(MIN_TRACE, ("%s:%d\n", __FILE__, __LINE__)); } while(0);
do { NDIS_DbgPrint(MIN_TRACE, ("(%s:%d)\n", __FILE__, __LINE__)); } while(0);
#endif /* __DEBUG_H */

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

@ -11,6 +11,12 @@
#include <ndissys.h>
typedef struct _HARDWARE_ADDRESS {
union {
UCHAR Medium802_3[ETH_LENGTH_OF_ADDRESS];
} Type;
} HARDWARE_ADDRESS, *PHARDWARE_ADDRESS;
/* Information about a miniport */
typedef struct _MINIPORT_DRIVER {
LIST_ENTRY ListEntry; /* Entry on global list */
@ -19,7 +25,6 @@ typedef struct _MINIPORT_DRIVER {
NDIS_MINIPORT_CHARACTERISTICS Chars; /* Miniport characteristics */
WORK_QUEUE_ITEM WorkItem; /* Work item */
PDRIVER_OBJECT DriverObject; /* Driver object of miniport */
NDIS_STRING RegistryPath; /* Registry path of miniport */
LIST_ENTRY AdapterListHead; /* Adapters created by miniport */
} MINIPORT_DRIVER, *PMINIPORT_DRIVER;
@ -27,40 +32,102 @@ typedef struct _MINIPORT_DRIVER {
/* Information about a logical adapter */
typedef struct _LOGICAL_ADAPTER {
NDIS_MINIPORT_BLOCK; /* NDIS defined fields */
KDPC MiniportDpc; /* DPC routine for adapter */
BOOLEAN MiniportBusy; /* A MiniportXxx routine is executing */
NDIS_HANDLE MiniportAdapterBinding; /* Binding handle for current caller */
ULONG WorkQueueLevel; /* Number of used work item buffers */
NDIS_MINIPORT_WORK_ITEM WorkQueue[NDIS_MINIPORT_WORK_QUEUE_SIZE];
PNDIS_MINIPORT_WORK_ITEM WorkQueueHead; /* Head of work queue */
PNDIS_MINIPORT_WORK_ITEM WorkQueueTail; /* Tail of work queue */
LIST_ENTRY ListEntry; /* Entry on global list */
LIST_ENTRY MiniportListEntry; /* Entry on miniport driver list */
KSPIN_LOCK Lock; /* Protecting spin lock */
LIST_ENTRY ProtocolListHead; /* List of bound protocols */
ULONG RefCount; /* Reference count */
PMINIPORT_DRIVER Miniport; /* Miniport owning this adapter */
UNICODE_STRING DeviceName; /* Device name of this adapter */
PDEVICE_OBJECT DeviceObject; /* Device object of adapter */
PVOID MiniportAdapterContext; /* Adapter context for miniport */
ULONG Attributes; /* Attributes of adapter */
NDIS_INTERFACE_TYPE AdapterType; /* Type of adapter interface */
/* TRUE if the miniport has called NdisSetAttributes(Ex) for this adapter */
BOOLEAN AttributesSet;
PNDIS_MINIPORT_INTERRUPT InterruptObject; /* Interrupt object for adapter */
PVOID QueryBuffer; /* Buffer to use for queries */
ULONG QueryBufferLength; /* Length of QueryBuffer */
ULONG MediumHeaderSize; /* Size of medium header */
HARDWARE_ADDRESS Address; /* Hardware address of adapter */
ULONG AddressLength; /* Length of hardware address */
PUCHAR LookaheadBuffer; /* Pointer to lookahead buffer */
ULONG LookaheadLength; /* Length of lookahead buffer */
ULONG CurLookaheadLength; /* Current (selected) length of lookahead buffer */
ULONG MaxLookaheadLength; /* Maximum length of lookahead buffer */
PNDIS_PACKET PacketQueueHead; /* Head of packet queue */
PNDIS_PACKET PacketQueueTail; /* Head of packet queue */
PNDIS_PACKET LoopPacket; /* Current packet beeing looped */
} LOGICAL_ADAPTER, *PLOGICAL_ADAPTER;
#define GET_LOGICAL_ADAPTER(Handle)((PLOGICAL_ADAPTER)Handle)
extern LIST_ENTRY MiniportListHead;
extern KSPIN_LOCK MiniportListLock;
extern LIST_ENTRY AdapterListHead;
extern KSPIN_LOCK AdapterListLock;
PLOGICAL_ADAPTER MiniLocateDevice(
#ifdef DBG
VOID
MiniDisplayPacket(
PNDIS_PACKET Packet);
#endif /* DBG */
VOID
MiniIndicateData(
PLOGICAL_ADAPTER Adapter,
NDIS_HANDLE MacReceiveContext,
PVOID HeaderBuffer,
UINT HeaderBufferSize,
PVOID LookaheadBuffer,
UINT LookaheadBufferSize,
UINT PacketSize);
BOOLEAN
MiniAdapterHasAddress(
PLOGICAL_ADAPTER Adapter,
PNDIS_PACKET Packet);
PLOGICAL_ADAPTER
MiniLocateDevice(
PNDIS_STRING AdapterName);
NDIS_STATUS MiniQueryInformation(
NDIS_STATUS
MiniQueryInformation(
PLOGICAL_ADAPTER Adapter,
NDIS_OID Oid,
ULONG Size,
PULONG BytesWritten);
NDIS_STATUS
FASTCALL
MiniQueueWorkItem(
PLOGICAL_ADAPTER Adapter,
NDIS_WORK_ITEM_TYPE WorkItemType,
PVOID WorkItemContext,
NDIS_HANDLE Initiator);
NDIS_STATUS
FASTCALL
MiniDequeueWorkItem(
PLOGICAL_ADAPTER Adapter,
NDIS_WORK_ITEM_TYPE *WorkItemType,
PVOID *WorkItemContext,
NDIS_HANDLE *Initiator);
NDIS_STATUS
MiniDoRequest(
PLOGICAL_ADAPTER Adapter,
PNDIS_REQUEST NdisRequest);
#endif /* __MINIPORT_H */
/* EOF */

7
reactos/drivers/net/ndis/include/ndissys.h
View file

@ -107,6 +107,13 @@
PoolFreeBuffer(Object); \
}
#define MIN(value1, value2) \
((value1 < value2)? value1 : value2)
#define MAX(value1, value2) \
((value1 > value2)? value1 : value2)
#endif /* __NDISSYS_H */
/* EOF */

20
reactos/drivers/net/ndis/include/protocol.h
View file

@ -25,11 +25,15 @@ typedef struct _PROTOCOL_BINDING {
typedef struct _ADAPTER_BINDING {
LIST_ENTRY ListEntry; /* Entry on global list */
LIST_ENTRY ProtocolListEntry; /* Entry on protocol binding adapter list */
KSPIN_LOCK Lock; /* Protecting spin lock */
ULONG RefCount; /* Reference count */
PLOGICAL_ADAPTER Adapter; /* Adapter opened by protocol */
NDIS_OPEN_BLOCK; /* NDIS defined fields */
LIST_ENTRY ListEntry; /* Entry on global list */
LIST_ENTRY ProtocolListEntry; /* Entry on protocol binding adapter list */
LIST_ENTRY AdapterListEntry; /* Entry on logical adapter list */
KSPIN_LOCK Lock; /* Protecting spin lock */
ULONG RefCount; /* Reference count */
PPROTOCOL_BINDING ProtocolBinding; /* Protocol that opened adapter */
PLOGICAL_ADAPTER Adapter; /* Adapter opened by protocol */
} ADAPTER_BINDING, *PADAPTER_BINDING;
#define GET_ADAPTER_BINDING(Handle)((PADAPTER_BINDING)Handle)
@ -38,6 +42,12 @@ typedef struct _ADAPTER_BINDING {
extern LIST_ENTRY ProtocolListHead;
extern KSPIN_LOCK ProtocolListLock;
NDIS_STATUS
ProIndicatePacket(
PLOGICAL_ADAPTER Adapter,
PNDIS_PACKET Packet);
#endif /* __PROTOCOL_H */
/* EOF */

375
reactos/drivers/net/ndis/ndis/buffer.c
View file

@ -10,6 +10,284 @@
#include <buffer.h>
__inline ULONG SkipToOffset(
PNDIS_BUFFER Buffer,
UINT Offset,
PUCHAR *Data,
PUINT Size)
/*
* FUNCTION: Skips Offset bytes into a buffer chain
* ARGUMENTS:
* Buffer = Pointer to NDIS buffer
* Offset = Number of bytes to skip
* Data = Address of a pointer that on return will contain the
* address of the offset in the buffer
* Size = Address of a pointer that on return will contain the
* size of the destination buffer
* RETURNS:
* Offset into buffer, -1 if buffer chain was smaller than Offset bytes
* NOTES:
* Buffer may be NULL
*/
{
for (;;) {
if (!Buffer)
return -1;
NdisQueryBuffer(Buffer, (PVOID)Data, Size);
if (Offset < *Size) {
((ULONG_PTR)*Data) += Offset;
*Size -= Offset;
break;
}
Offset -= *Size;
NdisGetNextBuffer(Buffer, &Buffer);
}
return Offset;
}
UINT CopyBufferToBufferChain(
PNDIS_BUFFER DstBuffer,
UINT DstOffset,
PUCHAR SrcData,
UINT Length)
/*
* FUNCTION: Copies data from a buffer to an NDIS buffer chain
* ARGUMENTS:
* DstBuffer = Pointer to destination NDIS buffer
* DstOffset = Destination start offset
* SrcData = Pointer to source buffer
* Length = Number of bytes to copy
* RETURNS:
* Number of bytes copied to destination buffer
* NOTES:
* The number of bytes copied may be limited by the destination
* buffer size
*/
{
UINT BytesCopied, BytesToCopy, DstSize;
PUCHAR DstData;
NDIS_DbgPrint(MAX_TRACE, ("DstBuffer (0x%X) DstOffset (0x%X) SrcData (0x%X) Length (%d)\n", DstBuffer, DstOffset, SrcData, Length));
/* Skip DstOffset bytes in the destination buffer chain */
if (SkipToOffset(DstBuffer, DstOffset, &DstData, &DstSize) == -1)
return 0;
/* Start copying the data */
BytesCopied = 0;
for (;;) {
BytesToCopy = MIN(DstSize, Length);
RtlCopyMemory((PVOID)DstData, (PVOID)SrcData, BytesToCopy);
BytesCopied += BytesToCopy;
(ULONG_PTR)SrcData += BytesToCopy;
Length -= BytesToCopy;
if (Length == 0)
break;
DstSize -= BytesToCopy;
if (DstSize == 0) {
/* No more bytes in desination buffer. Proceed to
the next buffer in the destination buffer chain */
NdisGetNextBuffer(DstBuffer, &DstBuffer);
if (!DstBuffer)
break;
NdisQueryBuffer(DstBuffer, (PVOID)&DstData, &DstSize);
}
}
return BytesCopied;
}
UINT CopyBufferChainToBuffer(
PUCHAR DstData,
PNDIS_BUFFER SrcBuffer,
UINT SrcOffset,
UINT Length)
/*
* FUNCTION: Copies data from an NDIS buffer chain to a buffer
* ARGUMENTS:
* DstData = Pointer to destination buffer
* SrcBuffer = Pointer to source NDIS buffer
* SrcOffset = Source start offset
* Length = Number of bytes to copy
* RETURNS:
* Number of bytes copied to destination buffer
* NOTES:
* The number of bytes copied may be limited by the source
* buffer size
*/
{
UINT BytesCopied, BytesToCopy, SrcSize;
PUCHAR SrcData;
NDIS_DbgPrint(MAX_TRACE, ("DstData 0x%X SrcBuffer 0x%X SrcOffset 0x%X Length %d\n",DstData,SrcBuffer, SrcOffset, Length));
/* Skip SrcOffset bytes in the source buffer chain */
if (SkipToOffset(SrcBuffer, SrcOffset, &SrcData, &SrcSize) == -1)
return 0;
/* Start copying the data */
BytesCopied = 0;
for (;;) {
BytesToCopy = MIN(SrcSize, Length);
NDIS_DbgPrint(MAX_TRACE, ("Copying (%d) bytes from 0x%X to 0x%X\n", BytesToCopy, SrcData, DstData));
RtlCopyMemory((PVOID)DstData, (PVOID)SrcData, BytesToCopy);
BytesCopied += BytesToCopy;
(ULONG_PTR)DstData += BytesToCopy;
Length -= BytesToCopy;
if (Length == 0)
break;
SrcSize -= BytesToCopy;
if (SrcSize == 0) {
/* No more bytes in source buffer. Proceed to
the next buffer in the source buffer chain */
NdisGetNextBuffer(SrcBuffer, &SrcBuffer);
if (!SrcBuffer)
break;
NdisQueryBuffer(SrcBuffer, (PVOID)&SrcData, &SrcSize);
}
}
return BytesCopied;
}
UINT CopyPacketToBuffer(
PUCHAR DstData,
PNDIS_PACKET SrcPacket,
UINT SrcOffset,
UINT Length)
/*
* FUNCTION: Copies data from an NDIS packet to a buffer
* ARGUMENTS:
* DstData = Pointer to destination buffer
* SrcPacket = Pointer to source NDIS packet
* SrcOffset = Source start offset
* Length = Number of bytes to copy
* RETURNS:
* Number of bytes copied to destination buffer
* NOTES:
* The number of bytes copied may be limited by the source
* buffer size
*/
{
PNDIS_BUFFER FirstBuffer;
PVOID Address;
UINT FirstLength;
UINT TotalLength;
NDIS_DbgPrint(MAX_TRACE, ("DstData (0x%X) SrcPacket (0x%X) SrcOffset (0x%X) Length (%d)\n", DstData, SrcPacket, SrcOffset, Length));
NdisGetFirstBufferFromPacket(SrcPacket,
&FirstBuffer,
&Address,
&FirstLength,
&TotalLength);
return CopyBufferChainToBuffer(DstData, FirstBuffer, SrcOffset, Length);
}
UINT CopyPacketToBufferChain(
PNDIS_BUFFER DstBuffer,
UINT DstOffset,
PNDIS_PACKET SrcPacket,
UINT SrcOffset,
UINT Length)
/*
* FUNCTION: Copies data from an NDIS packet to an NDIS buffer chain
* ARGUMENTS:
* DstBuffer = Pointer to destination NDIS buffer
* DstOffset = Destination start offset
* SrcPacket = Pointer to source NDIS packet
* SrcOffset = Source start offset
* Length = Number of bytes to copy
* RETURNS:
* Number of bytes copied to destination buffer
* NOTES:
* The number of bytes copied may be limited by the source and
* destination buffer sizes
*/
{
PNDIS_BUFFER SrcBuffer;
PUCHAR DstData, SrcData;
UINT DstSize, SrcSize;
UINT Count, Total;
NDIS_DbgPrint(MAX_TRACE, ("DstBuffer (0x%X) DstOffset (0x%X) SrcPacket (0x%X) SrcOffset (0x%X) Length (%d)\n", DstBuffer, DstOffset, SrcPacket, SrcOffset, Length));
/* Skip DstOffset bytes in the destination buffer chain */
NdisQueryBuffer(DstBuffer, (PVOID)&DstData, &DstSize);
if (SkipToOffset(DstBuffer, DstOffset, &DstData, &DstSize) == -1)
return 0;
/* Skip SrcOffset bytes in the source packet */
NdisGetFirstBufferFromPacket(SrcPacket, &SrcBuffer, (PVOID)&SrcData, &SrcSize, &Total);
if (SkipToOffset(SrcBuffer, SrcOffset, &SrcData, &SrcSize) == -1)
return 0;
/* Copy the data */
for (Total = 0;;) {
/* Find out how many bytes we can copy at one time */
if (Length < SrcSize)
Count = Length;
else
Count = SrcSize;
if (DstSize < Count)
Count = DstSize;
RtlCopyMemory((PVOID)DstData, (PVOID)SrcData, Count);
Total += Count;
Length -= Count;
if (Length == 0)
break;
DstSize -= Count;
if (DstSize == 0) {
/* No more bytes in destination buffer. Proceed to
the next buffer in the destination buffer chain */
NdisGetNextBuffer(DstBuffer, &DstBuffer);
if (!DstBuffer)
break;
NdisQueryBuffer(DstBuffer, (PVOID)&DstData, &DstSize);
}
SrcSize -= Count;
if (SrcSize == 0) {
/* No more bytes in source buffer. Proceed to
the next buffer in the source buffer chain */
NdisGetNextBuffer(SrcBuffer, &SrcBuffer);
if (!SrcBuffer)
break;
NdisQueryBuffer(SrcBuffer, (PVOID)&SrcData, &SrcSize);
}
}
return Total;
}
VOID
EXPORT
NdisAdjustBufferLength(
@ -276,15 +554,17 @@ EXPORT
NdisBufferLength(
IN PNDIS_BUFFER Buffer)
/*
* FUNCTION:
* FUNCTION: Modifies the length of an NDIS buffer
* ARGUMENTS:
* Buffer = Pointer to NDIS buffer descriptor
* Length = New size of buffer
* NOTES:
* NDIS 5.0
* RETURNS:
* Length of NDIS buffer
*/
{
UNIMPLEMENTED
return 0;
return Buffer->ByteCount;
}
@ -329,52 +609,6 @@ NdisCopyBuffer(
}
__inline ULONG SkipToOffset(
PNDIS_BUFFER Buffer,
UINT Offset,
PVOID *Data,
PUINT Size)
/*
* FUNCTION: Skips Offset bytes into a buffer chain
* ARGUMENTS:
* Buffer = Pointer to NDIS buffer
* Offset = Number of bytes to skip
* Data = Address of a pointer that on return will contain the
* address of the offset in the buffer
* Size = Address of a pointer that on return will contain the
* size of the destination buffer
* RETURNS:
* Offset into buffer, -1 if buffer chain was smaller than Offset bytes
* NOTES:
* Buffer may be NULL
*/
{
ULONG Address = 0;
for (;;) {
if (!Buffer)
return -1;
NdisQueryBuffer(Buffer, Data, Size);
if (Offset < *Size) {
Address += Offset;
*Size -= Offset;
break;
}
Offset -= *Size;
NdisGetNextBuffer(Buffer, &Buffer);
}
*Data = (PVOID)Address;
return Offset;
}
VOID
EXPORT
NdisCopyFromPacketToPacket(
@ -397,19 +631,19 @@ NdisCopyFromPacketToPacket(
{
PNDIS_BUFFER SrcBuffer;
PNDIS_BUFFER DstBuffer;
PVOID DstData, SrcData;
PUCHAR DstData, SrcData;
UINT DstSize, SrcSize;
UINT Count, Total;
*BytesCopied = 0;
/* Skip DestinationOffset bytes in the destination packet */
NdisGetFirstBufferFromPacket(Destination, &DstBuffer, &DstData, &DstSize, &Total);
NdisGetFirstBufferFromPacket(Destination, &DstBuffer, (PVOID)&DstData, &DstSize, &Total);
if (SkipToOffset(DstBuffer, DestinationOffset, &DstData, &DstSize) == -1)
return;
/* Skip SourceOffset bytes in the source packet */
NdisGetFirstBufferFromPacket(Source, &SrcBuffer, &SrcData, &SrcSize, &Total);
NdisGetFirstBufferFromPacket(Source, &SrcBuffer, (PVOID)&SrcData, &SrcSize, &Total);
if (SkipToOffset(SrcBuffer, SourceOffset, &SrcData, &SrcSize) == -1)
return;
@ -438,7 +672,7 @@ NdisCopyFromPacketToPacket(
if (!DstBuffer)
break;
NdisQueryBuffer(DstBuffer, &DstData, &DstSize);
NdisQueryBuffer(DstBuffer, (PVOID)&DstData, &DstSize);
}
SrcSize -= Count;
@ -449,7 +683,7 @@ NdisCopyFromPacketToPacket(
if (!SrcBuffer)
break;
NdisQueryBuffer(SrcBuffer, &SrcData, &SrcSize);
NdisQueryBuffer(SrcBuffer, (PVOID)&SrcData, &SrcSize);
}
}
@ -616,8 +850,34 @@ NdisGetFirstBufferFromPacket(
OUT PVOID *_FirstBufferVA,
OUT PUINT _FirstBufferLength,
OUT PUINT _TotalBufferLength)
/*
* FUNCTION: Retrieves information about an NDIS packet
* ARGUMENTS:
* _Packet = Pointer to NDIS packet
* _FirstBuffer = Address of buffer for pointer to first NDIS buffer
* _FirstBufferVA = Address of buffer for address of first NDIS buffer
* _FirstBufferLength = Address of buffer for length of first buffer
* _TotalBufferLength = Address of buffer for total length of packet
*/
{
UNIMPLEMENTED
PNDIS_BUFFER Buffer;
Buffer = _Packet->Private.Head;
*_FirstBuffer = Buffer;
*_FirstBufferVA = MmGetMdlVirtualAddress(Buffer);
if (Buffer != NULL) {
*_FirstBufferLength = MmGetMdlByteCount(Buffer);
Buffer = Buffer->Next;
} else
*_FirstBufferLength = 0;
*_TotalBufferLength = *_FirstBufferLength;
while (Buffer != NULL) {
*_TotalBufferLength += MmGetMdlByteCount(Buffer);
Buffer = Buffer->Next;
}
}
@ -683,7 +943,8 @@ NdisQueryBufferOffset(
OUT PUINT Offset,
OUT PUINT Length)
{
UNIMPLEMENTED
*((PUINT)Offset) = MmGetMdlByteOffset(Buffer);
*((PUINT)Length) = MmGetMdlByteCount(Buffer);
}

153
reactos/drivers/net/ndis/ndis/io.c
View file

@ -25,10 +25,33 @@ VOID HandleDeferredProcessing(
* SystemArgument2 = Unused
*/
{
BOOLEAN WasBusy;
PLOGICAL_ADAPTER Adapter = GET_LOGICAL_ADAPTER(DeferredContext);
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
KeAcquireSpinLockAtDpcLevel(&Adapter->Lock);
WasBusy = Adapter->MiniportBusy;
Adapter->MiniportBusy = TRUE;
KeReleaseSpinLockFromDpcLevel(&Adapter->Lock);
NDIS_DbgPrint(MAX_TRACE, ("Before HandleInterruptHandler.\n"));
/* Call the deferred interrupt service handler for this adapter */
(*Adapter->Miniport->Chars.HandleInterruptHandler)(Adapter);
(*Adapter->Miniport->Chars.HandleInterruptHandler)(
Adapter->MiniportAdapterContext);
NDIS_DbgPrint(MAX_TRACE, ("After HandleInterruptHandler.\n"));
KeAcquireSpinLockAtDpcLevel(&Adapter->Lock);
if ((!WasBusy) && (Adapter->WorkQueueHead)) {
KeInsertQueueDpc(&Adapter->MiniportDpc, NULL, NULL);
} else {
Adapter->MiniportBusy = WasBusy;
}
KeReleaseSpinLockFromDpcLevel(&Adapter->Lock);
NDIS_DbgPrint(MAX_TRACE, ("Leaving.\n"));
}
@ -41,23 +64,27 @@ BOOLEAN ServiceRoutine(
* Interrupt = Pointer to interrupt object
* ServiceContext = Pointer to context information (LOGICAL_ADAPTER)
* RETURNS
* TRUE if our device generated the interrupt
* TRUE if a miniport controlled device generated the interrupt
*/
{
BOOLEAN InterruptRecognized;
BOOLEAN QueueMiniportHandleInterrupt;
PLOGICAL_ADAPTER Adapter = GET_LOGICAL_ADAPTER(ServiceContext);
/* FIXME: Support shared interrupts */
NDIS_DbgPrint(MAX_TRACE, ("Called. Adapter (0x%X)\n", Adapter));
(*Adapter->Miniport->Chars.ISRHandler)(&InterruptRecognized,
&QueueMiniportHandleInterrupt, Adapter);
&QueueMiniportHandleInterrupt,
Adapter->MiniportAdapterContext);
if (QueueMiniportHandleInterrupt) {
KeInsertQueueDpc(&Adapter->InterruptObject->InterruptDpc, NULL, NULL);
NDIS_DbgPrint(MAX_TRACE, ("Queueing DPC.\n"));
KeInsertQueueDpc(&Adapter->Interrupt->InterruptDpc, NULL, NULL);
}
return TRUE;
NDIS_DbgPrint(MAX_TRACE, ("Leaving.\n"));
return InterruptRecognized;
}
@ -230,7 +257,9 @@ NdisMDeregisterIoPortRange(
* PortOffset = Pointer to mapped base port address
*/
{
UNIMPLEMENTED
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
/* Thank you */
}
@ -257,16 +286,6 @@ NdisMMapIoSpace(
}
VOID
EXPORT
NdisMQueryInformationComplete(
IN NDIS_HANDLE MiniportAdapterHandle,
IN NDIS_STATUS Status)
{
UNIMPLEMENTED
}
ULONG
EXPORT
NdisMReadDmaCounter(
@ -312,39 +331,70 @@ NdisMRegisterInterrupt(
* InterruptVector = Specifies bus-relative vector to register
* InterruptLevel = Specifies bus-relative DIRQL vector for interrupt
* RequestIsr = TRUE if MiniportISR should always be called
* SharedInterrupt = TRUE if other devices may use tha same interrupt
* SharedInterrupt = TRUE if other devices may use the same interrupt
* InterruptMode = Specifies type of interrupt
* RETURNS:
* Status of operation
*/
{
NTSTATUS NtStatus;
NTSTATUS Status;
ULONG MappedIRQ;
KIRQL DIrql;
KAFFINITY Affinity = 0xFFFFFFFF;
PLOGICAL_ADAPTER Adapter = GET_LOGICAL_ADAPTER(MiniportAdapterHandle);
KAFFINITY Affinity;
PLOGICAL_ADAPTER Adapter = GET_LOGICAL_ADAPTER(MiniportAdapterHandle);
NDIS_DbgPrint(MAX_TRACE, ("Called. InterruptVector (0x%X) InterruptLevel (0x%X) "
"SharedInterrupt (%d) InterruptMode (0x%X)\n",
InterruptVector, InterruptLevel, SharedInterrupt, InterruptMode));
RtlZeroMemory(Interrupt, sizeof(NDIS_MINIPORT_INTERRUPT));
KeInitializeSpinLock(&Interrupt->DpcCountLock);
KeInitializeDpc(&Interrupt->InterruptDpc, HandleDeferredProcessing, Adapter);
KeInitializeDpc(&Interrupt->InterruptDpc,
HandleDeferredProcessing,
Adapter);
KeInitializeEvent(&Interrupt->DpcsCompletedEvent,
NotificationEvent, FALSE);
NotificationEvent,
FALSE);
Interrupt->SharedInterrupt = SharedInterrupt;
Adapter->InterruptObject = Interrupt;
Adapter->Interrupt = Interrupt;
MappedIRQ = HalGetInterruptVector(Adapter->AdapterType, 0,
InterruptLevel, InterruptVector, &DIrql, &Affinity);
MappedIRQ = HalGetInterruptVector(Internal, /* Adapter->AdapterType, */
0,
InterruptLevel,
InterruptVector,
&DIrql,
&Affinity);
NtStatus = IoConnectInterrupt(&Interrupt->InterruptObject, ServiceRoutine, Adapter,
&Interrupt->DpcCountLock, MappedIRQ, DIrql, DIrql, InterruptMode,
SharedInterrupt, Affinity, FALSE);
NDIS_DbgPrint(MAX_TRACE, ("Connecting to interrupt vector (0x%X) Affinity (0x%X).\n", MappedIRQ, Affinity));
return NDIS_STATUS_SUCCESS;
Status = IoConnectInterrupt(&Interrupt->InterruptObject,
ServiceRoutine,
Adapter,
&Interrupt->DpcCountLock,
MappedIRQ,
DIrql,
DIrql,
InterruptMode,
SharedInterrupt,
Affinity,
FALSE);
NDIS_DbgPrint(MAX_TRACE, ("Leaving. Status (0x%X).\n", Status));
if (NT_SUCCESS(Status))
return NDIS_STATUS_SUCCESS;
if (Status == STATUS_INSUFFICIENT_RESOURCES) {
/* FIXME: Log error */
return NDIS_STATUS_RESOURCE_CONFLICT;
}
return NDIS_STATUS_FAILURE;
}
@ -367,22 +417,25 @@ NdisMRegisterIoPortRange(
*/
{
#if 0
NTSTATUS NtStatus;
NTSTATUS Status;
BOOLEAN ConflictDetected;
PLOGICAL_ADAPTER Adapter = GET_LOGICAL_ADAPTER(MiniportAdapterHandle);
PMINIPORT_DRIVER Miniport = Adapter->Miniport;
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
/* Non-PnP hardware. NT5 function */
NtStatus = IoReportResourceForDetection(
Miniport->DriverObject,
NULL,
0,
NULL,
NULL,
0,
&ConflictDetected);
Status = IoReportResourceForDetection(Miniport->DriverObject,
NULL,
0,
NULL,
NULL,
0,
&ConflictDetected);
return NDIS_STATUS_FAILURE;
#else
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
/* It's yours! */
*PortOffset = (PVOID)InitialPort;
@ -391,16 +444,6 @@ NdisMRegisterIoPortRange(
}
VOID
EXPORT
NdisMSetInformationComplete(
IN NDIS_HANDLE MiniportAdapterHandle,
IN NDIS_STATUS Status)
{
UNIMPLEMENTED
}
VOID
EXPORT
NdisMSetupDmaTransfer(
@ -415,18 +458,6 @@ NdisMSetupDmaTransfer(
}
VOID
EXPORT
NdisMTransferDataComplete(
IN NDIS_HANDLE MiniportAdapterHandle,
IN PNDIS_PACKET Packet,
IN NDIS_STATUS Status,
IN UINT BytesTransferred)
{
UNIMPLEMENTED
}
VOID
EXPORT
NdisMUnmapIoSpace(

14
reactos/drivers/net/ndis/ndis/main.c
View file

@ -8,10 +8,15 @@
* CSH 01/08-2000 Created
*/
#include <ndissys.h>
#include <protocol.h>
#include <miniport.h>
#ifdef DBG
/* See debug.h for debug/trace constants */
DWORD DebugTraceLevel = MIN_TRACE;
#endif /* DBG */
@ -45,6 +50,15 @@ DriverEntry(
{
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
InitializeListHead(&ProtocolListHead);
KeInitializeSpinLock(&ProtocolListLock);
InitializeListHead(&MiniportListHead);
KeInitializeSpinLock(&MiniportListLock);
InitializeListHead(&AdapterListHead);
KeInitializeSpinLock(&AdapterListLock);
#ifdef _MSC_VER
DriverObject->DriverUnload = MainUnload;
#else

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

File diff suppressed because it is too large Load diff

448
reactos/drivers/net/ndis/ndis/protocol.c
View file

@ -10,25 +10,291 @@
#include <ndissys.h>
#include <miniport.h>
#include <protocol.h>
#include <buffer.h>
LIST_ENTRY ProtocolListHead;
KSPIN_LOCK ProtocolListLock;
VOID ProtocolWorker(
PVOID Context)
NDIS_STATUS
ProIndicatePacket(
PLOGICAL_ADAPTER Adapter,
PNDIS_PACKET Packet)
/*
* FUNCTION: Worker function for ProtocolXxx functions
* FUNCTION: Indicates a packet to bound protocols
* ARGUMENTS:
* Context = Pointer to context information (PROTOCOL_BINDING)
* Adapter = Pointer to logical adapter
* Packet = Pointer to packet to indicate
* RETURNS:
* Status of operation
*/
{
KIRQL OldIrql;
UINT Length;
UINT Total;
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
#ifdef DBG
MiniDisplayPacket(Packet);
#endif
NdisQueryPacket(Packet, NULL, NULL, NULL, &Total);
KeAcquireSpinLock(&Adapter->Lock, &OldIrql);
Adapter->LoopPacket = Packet;
Length = CopyPacketToBuffer(
Adapter->LookaheadBuffer,
Packet,
0,
Adapter->CurLookaheadLength);
KeReleaseSpinLock(&Adapter->Lock, OldIrql);
if (Length > Adapter->MediumHeaderSize) {
MiniIndicateData(Adapter,
NULL,
Adapter->LookaheadBuffer,
Adapter->MediumHeaderSize,
&Adapter->LookaheadBuffer[Adapter->MediumHeaderSize],
Length - Adapter->MediumHeaderSize,
Total - Adapter->MediumHeaderSize);
} else {
MiniIndicateData(Adapter,
NULL,
Adapter->LookaheadBuffer,
Adapter->MediumHeaderSize,
NULL,
0,
0);
}
KeAcquireSpinLock(&Adapter->Lock, &OldIrql);
Adapter->LoopPacket = NULL;
KeReleaseSpinLock(&Adapter->Lock, OldIrql);
return STATUS_SUCCESS;
}
NDIS_STATUS
ProRequest(
IN NDIS_HANDLE MacBindingHandle,
IN PNDIS_REQUEST NdisRequest)
/*
* FUNCTION: Forwards a request to an NDIS miniport
* ARGUMENTS:
* MacBindingHandle = Adapter binding handle
* NdisRequest = Pointer to request to perform
* RETURNS:
* Status of operation
*/
{
KIRQL OldIrql;
BOOLEAN Queue;
NDIS_STATUS NdisStatus;
PADAPTER_BINDING AdapterBinding = GET_ADAPTER_BINDING(MacBindingHandle);
PLOGICAL_ADAPTER Adapter = AdapterBinding->Adapter;
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
KeAcquireSpinLock(&Adapter->Lock, &OldIrql);
Queue = Adapter->MiniportBusy;
if (Queue) {
MiniQueueWorkItem(Adapter,
NdisWorkItemRequest,
(PVOID)NdisRequest,
(NDIS_HANDLE)AdapterBinding);
} else {
Adapter->MiniportBusy = TRUE;
}
KeReleaseSpinLock(&Adapter->Lock, OldIrql);
if (!Queue) {
KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
NdisStatus = MiniDoRequest(Adapter, NdisRequest);
KeAcquireSpinLockAtDpcLevel(&Adapter->Lock);
Adapter->MiniportBusy = FALSE;
if (Adapter->WorkQueueHead)
KeInsertQueueDpc(&Adapter->MiniportDpc, NULL, NULL);
KeReleaseSpinLockFromDpcLevel(&Adapter->Lock);
KeLowerIrql(OldIrql);
} else {
NdisStatus = NDIS_STATUS_PENDING;
}
return NdisStatus;
}
NDIS_STATUS
ProReset(
IN NDIS_HANDLE MacBindingHandle)
{
UNIMPLEMENTED
return NDIS_STATUS_FAILURE;
}
NDIS_STATUS
ProSend(
IN NDIS_HANDLE MacBindingHandle,
IN PNDIS_PACKET Packet)
/*
* FUNCTION: Forwards a request to send a packet to an NDIS miniport
* ARGUMENTS:
* MacBindingHandle = Adapter binding handle
* Packet = Pointer to NDIS packet descriptor
*/
{
KIRQL OldIrql;
BOOLEAN Queue;
NDIS_STATUS NdisStatus;
PADAPTER_BINDING AdapterBinding = GET_ADAPTER_BINDING(MacBindingHandle);
PLOGICAL_ADAPTER Adapter = AdapterBinding->Adapter;
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
/* FIXME: Should queue packet if miniport returns NDIS_STATUS_RESOURCES */
Packet->Reserved[0] = (ULONG_PTR)MacBindingHandle;
KeAcquireSpinLock(&Adapter->Lock, &OldIrql);
Queue = Adapter->MiniportBusy;
/* We may have to loop this packet if miniport cannot */
if (Adapter->MacOptions & NDIS_MAC_OPTION_NO_LOOPBACK) {
if (MiniAdapterHasAddress(Adapter, Packet)) {
/* Do software loopback because miniport does not support it */
NDIS_DbgPrint(MIN_TRACE, ("Looping packet.\n"));
if (Queue) {
/* FIXME: Packets should properbly be queued directly on the adapter instead */
MiniQueueWorkItem(Adapter,
NdisWorkItemSendLoopback,
(PVOID)Packet,
(NDIS_HANDLE)AdapterBinding);
} else {
Adapter->MiniportBusy = TRUE;
}
KeReleaseSpinLock(&Adapter->Lock, OldIrql);
if (!Queue) {
KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
NdisStatus = ProIndicatePacket(Adapter, Packet);
KeAcquireSpinLockAtDpcLevel(&Adapter->Lock);
Adapter->MiniportBusy = FALSE;
if (Adapter->WorkQueueHead)
KeInsertQueueDpc(&Adapter->MiniportDpc, NULL, NULL);
KeReleaseSpinLockFromDpcLevel(&Adapter->Lock);
KeLowerIrql(OldIrql);
return NdisStatus;
} else {
return NDIS_STATUS_PENDING;
}
}
}
if (Queue) {
/* FIXME: Packets should properbly be queued directly on the adapter instead */
MiniQueueWorkItem(Adapter,
NdisWorkItemSend,
(PVOID)Packet,
(NDIS_HANDLE)AdapterBinding);
} else {
Adapter->MiniportBusy = TRUE;
}
KeReleaseSpinLock(&Adapter->Lock, OldIrql);
if (!Queue) {
KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
NdisStatus = (*Adapter->Miniport->Chars.u1.SendHandler)(
Adapter->MiniportAdapterContext,
Packet,
0);
KeAcquireSpinLockAtDpcLevel(&Adapter->Lock);
Adapter->MiniportBusy = FALSE;
if (Adapter->WorkQueueHead)
KeInsertQueueDpc(&Adapter->MiniportDpc, NULL, NULL);
KeReleaseSpinLockFromDpcLevel(&Adapter->Lock);
KeLowerIrql(OldIrql);
} else {
NdisStatus = NDIS_STATUS_PENDING;
}
return NdisStatus;
}
VOID
ProSendPackets(
IN NDIS_HANDLE NdisBindingHandle,
IN PPNDIS_PACKET PacketArray,
IN UINT NumberOfPackets)
{
UNIMPLEMENTED
}
NDIS_STATUS
ProTransferData(
IN NDIS_HANDLE MacBindingHandle,
IN NDIS_HANDLE MacReceiveContext,
IN UINT ByteOffset,
IN UINT BytesToTransfer,
IN OUT PNDIS_PACKET Packet,
OUT PUINT BytesTransferred)
/*
* FUNCTION: Forwards a request to copy received data into a protocol-supplied packet
* ARGUMENTS:
* MacBindingHandle = Adapter binding handle
* MacReceiveContext = MAC receive context
* ByteOffset = Offset in packet to place data
* BytesToTransfer = Number of bytes to copy into packet
* Packet = Pointer to NDIS packet descriptor
* BytesTransferred = Address of buffer to place number of bytes copied
*/
{
PADAPTER_BINDING AdapterBinding = GET_ADAPTER_BINDING(MacBindingHandle);
PLOGICAL_ADAPTER Adapter = AdapterBinding->Adapter;
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
/* FIXME: Interrupts must be disabled for adapter */
if (Packet == Adapter->LoopPacket) {
/* NDIS is responsible for looping this packet */
NdisCopyFromPacketToPacket(Packet,
ByteOffset,
BytesToTransfer,
Adapter->LoopPacket,
0,
BytesTransferred);
return NDIS_STATUS_SUCCESS;
}
return (*Adapter->Miniport->Chars.u2.TransferDataHandler)(
Packet,
BytesTransferred,
Adapter->MiniportAdapterContext,
MacReceiveContext,
ByteOffset,
BytesToTransfer);
}
VOID
EXPORT
STDCALL
NdisCloseAdapter(
OUT PNDIS_STATUS Status,
IN NDIS_HANDLE NdisBindingHandle)
@ -39,8 +305,21 @@ NdisCloseAdapter(
* NdisBindingHandle = Handle returned by NdisOpenAdapter
*/
{
KIRQL OldIrql;
PADAPTER_BINDING AdapterBinding = GET_ADAPTER_BINDING(NdisBindingHandle);
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
/* Remove from protocol's bound adapters list */
KeAcquireSpinLock(&AdapterBinding->ProtocolBinding->Lock, &OldIrql);
RemoveEntryList(&AdapterBinding->ProtocolListEntry);
KeReleaseSpinLock(&AdapterBinding->ProtocolBinding->Lock, OldIrql);
/* Remove protocol from adapter's bound protocols list */
KeAcquireSpinLock(&AdapterBinding->Adapter->Lock, &OldIrql);
RemoveEntryList(&AdapterBinding->AdapterListEntry);
KeReleaseSpinLock(&AdapterBinding->Adapter->Lock, OldIrql);
ExFreePool(AdapterBinding);
*Status = NDIS_STATUS_SUCCESS;
@ -59,7 +338,20 @@ NdisDeregisterProtocol(
* NdisProtocolHandle = Handle returned by NdisRegisterProtocol
*/
{
ExFreePool(NdisProtocolHandle);
KIRQL OldIrql;
PPROTOCOL_BINDING Protocol = GET_PROTOCOL_BINDING(NdisProtocolHandle);
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
/* FIXME: Make sure no adapter bindings exist */
/* Remove protocol from global list */
KeAcquireSpinLock(&ProtocolListLock, &OldIrql);
RemoveEntryList(&Protocol->ListEntry);
KeReleaseSpinLock(&ProtocolListLock, OldIrql);
ExFreePool(Protocol);
*Status = NDIS_STATUS_SUCCESS;
}
@ -94,60 +386,38 @@ NdisOpenAdapter(
* AddressingInformation = Optional pointer to buffer with NIC specific information
*/
{
PADAPTER_BINDING AdapterBinding;
PLOGICAL_ADAPTER Adapter;
NDIS_STATUS NdisStatus;
PNDIS_MEDIUM Medium1;
PNDIS_MEDIUM Medium2;
ULONG BytesWritten;
UINT i;
BOOLEAN Found;
UINT i, j;
PPROTOCOL_BINDING Protocol = GET_PROTOCOL_BINDING(ProtocolBindingContext);
PLOGICAL_ADAPTER Adapter;
PADAPTER_BINDING AdapterBinding;
PPROTOCOL_BINDING Protocol = GET_PROTOCOL_BINDING(NdisProtocolHandle);
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
Adapter = MiniLocateDevice(AdapterName);
if (!Adapter) {
NDIS_DbgPrint(MIN_TRACE, ("Adapter not found.\n"));
*Status = NDIS_STATUS_ADAPTER_NOT_FOUND;
return;
}
/* Query the miniport driver for it's supported medias and search the list
to find the first medium also supported by the protocol driver */
NdisStatus = MiniQueryInformation(Adapter, OID_GEN_MEDIA_SUPPORTED, 0, &BytesWritten);
/* FIXME: Handle this */
if (NdisStatus == NDIS_STATUS_PENDING) {
NDIS_DbgPrint(MIN_TRACE, ("NDIS_STATUS_PENDING returned!\n"));
}
if (!NT_SUCCESS(NdisStatus))
*Status = NdisStatus;
Medium1 = Adapter->QueryBuffer;
Medium2 = MediumArray;
Found = FALSE;
for (i = 0; i < BytesWritten / sizeof(NDIS_MEDIUM); i++) {
for (j = 0; j < MediumArraySize; j++) {
if (Medium2[j] == Medium1[i]) {
*SelectedMediumIndex = j;
Found = TRUE;
break;
}
}
if (Found)
/* Find the media type in the list provided by the protocol driver */
Found = FALSE;
for (i = 0; i < MediumArraySize; i++) {
if (Adapter->MediaType == MediumArray[i]) {
*SelectedMediumIndex = i;
Found = TRUE;
break;
}
}
if (!Found) {
NDIS_DbgPrint(MIN_TRACE, ("Media is not supported.\n"));
NDIS_DbgPrint(MIN_TRACE, ("Medium is not supported.\n"));
*Status = NDIS_STATUS_UNSUPPORTED_MEDIA;
return;
}
AdapterBinding = ExAllocatePool(NonPagedPool, sizeof(ADAPTER_BINDING));
if (!AdapterBinding) {
NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
*Status = NDIS_STATUS_RESOURCES;
@ -156,12 +426,32 @@ NdisOpenAdapter(
RtlZeroMemory(AdapterBinding, sizeof(ADAPTER_BINDING));
/* Put on protocol binding adapter list */
AdapterBinding->ProtocolBinding = Protocol;
AdapterBinding->Adapter = Adapter;
AdapterBinding->ProtocolBindingContext = ProtocolBindingContext;
/* Set fields required by some NDIS macros */
AdapterBinding->MacBindingHandle = (NDIS_HANDLE)AdapterBinding;
/* Set handlers (some NDIS macros require these) */
AdapterBinding->RequestHandler = ProRequest;
AdapterBinding->ResetHandler = ProReset;
AdapterBinding->u1.SendHandler = ProSend;
AdapterBinding->SendPacketsHandler = ProSendPackets;
AdapterBinding->TransferDataHandler = ProTransferData;
/* Put on protocol's bound adapters list */
ExInterlockedInsertTailList(&Protocol->AdapterListHead,
&AdapterBinding->ProtocolListEntry,
&Protocol->Lock);
*NdisBindingHandle = AdapterBinding;
/* Put protocol on adapter's bound protocols list */
ExInterlockedInsertTailList(&Adapter->ProtocolListHead,
&AdapterBinding->AdapterListEntry,
&Adapter->Lock);
*NdisBindingHandle = (NDIS_HANDLE)AdapterBinding;
*Status = NDIS_STATUS_SUCCESS;
}
@ -187,6 +477,8 @@ NdisRegisterProtocol(
NTSTATUS NtStatus;
UINT MinSize;
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
switch (ProtocolCharacteristics->MajorNdisVersion) {
case 0x03:
MinSize = sizeof(NDIS30_PROTOCOL_CHARACTERISTICS_S);
@ -221,10 +513,9 @@ NdisRegisterProtocol(
RtlZeroMemory(Protocol, sizeof(PROTOCOL_BINDING));
RtlCopyMemory(&Protocol->Chars, ProtocolCharacteristics, MinSize);
NtStatus = RtlUpcaseUnicodeString(
&Protocol->Chars.Name,
&ProtocolCharacteristics->Name,
TRUE);
NtStatus = RtlUpcaseUnicodeString(&Protocol->Chars.Name,
&ProtocolCharacteristics->Name,
TRUE);
if (!NT_SUCCESS(NtStatus)) {
NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
ExFreePool(Protocol);
@ -236,10 +527,13 @@ NdisRegisterProtocol(
Protocol->RefCount = 1;
ExInitializeWorkItem(&Protocol->WorkItem, ProtocolWorker, Protocol);
InitializeListHead(&Protocol->AdapterListHead);
/* Put protocol binding on global list */
ExInterlockedInsertTailList(&ProtocolListHead,
&Protocol->ListEntry,
&ProtocolListLock);
*NdisProtocolHandle = Protocol;
*Status = NDIS_STATUS_SUCCESS;
}
@ -251,8 +545,15 @@ NdisRequest(
OUT PNDIS_STATUS Status,
IN NDIS_HANDLE NdisBindingHandle,
IN PNDIS_REQUEST NdisRequest)
/*
* FUNCTION: Forwards a request to an NDIS driver
* ARGUMENTS:
* Status = Address of buffer for status information
* NdisBindingHandle = Adapter binding handle
* NdisRequest = Pointer to request to perform
*/
{
UNIMPLEMENTED
*Status = ProRequest(NdisBindingHandle, NdisRequest);
}
@ -262,7 +563,7 @@ NdisReset(
OUT PNDIS_STATUS Status,
IN NDIS_HANDLE NdisBindingHandle)
{
UNIMPLEMENTED
*Status = ProReset(NdisBindingHandle);
}
@ -272,8 +573,15 @@ NdisSend(
OUT PNDIS_STATUS Status,
IN NDIS_HANDLE NdisBindingHandle,
IN PNDIS_PACKET Packet)
/*
* FUNCTION: Forwards a request to send a packet
* ARGUMENTS:
* Status = Address of buffer for status information
* NdisBindingHandle = Adapter binding handle
* Packet = Pointer to NDIS packet descriptor
*/
{
UNIMPLEMENTED
*Status = ProSend(NdisBindingHandle, Packet);
}
@ -284,22 +592,38 @@ NdisSendPackets(
IN PPNDIS_PACKET PacketArray,
IN UINT NumberOfPackets)
{
UNIMPLEMENTED
ProSendPackets(NdisBindingHandle, PacketArray, NumberOfPackets);
}
VOID
EXPORT
NdisTransferData(
OUT PNDIS_STATUS Status,
IN NDIS_HANDLE NdisBindingHandle,
IN NDIS_HANDLE MacReceiveContext,
IN UINT ByteOffset,
IN UINT BytesToTransfer,
IN OUT PNDIS_PACKET Packet,
OUT PUINT BytesTransferred)
OUT PNDIS_STATUS Status,
IN NDIS_HANDLE NdisBindingHandle,
IN NDIS_HANDLE MacReceiveContext,
IN UINT ByteOffset,
IN UINT BytesToTransfer,
IN OUT PNDIS_PACKET Packet,
OUT PUINT BytesTransferred)
/*
* FUNCTION: Forwards a request to copy received data into a protocol-supplied packet
* ARGUMENTS:
* Status = Address of buffer for status information
* NdisBindingHandle = Adapter binding handle
* MacReceiveContext = MAC receive context
* ByteOffset = Offset in packet to place data
* BytesToTransfer = Number of bytes to copy into packet
* Packet = Pointer to NDIS packet descriptor
* BytesTransferred = Address of buffer to place number of bytes copied
*/
{
UNIMPLEMENTED
*Status = ProTransferData(NdisBindingHandle,
MacReceiveContext,
ByteOffset,
BytesToTransfer,
Packet,
BytesTransferred);
}
/* EOF */

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

@ -100,27 +100,6 @@ NdisInterlockedRemoveHeadList(
}
VOID
EXPORT
NdisMArcIndicateReceive(
IN NDIS_HANDLE MiniportAdapterHandle,
IN PUCHAR HeaderBuffer,
IN PUCHAR DataBuffer,
IN UINT Length)
{
UNIMPLEMENTED
}
VOID
EXPORT
NdisMArcIndicateReceiveComplete(
IN NDIS_HANDLE MiniportAdapterHandle)
{
UNIMPLEMENTED
}
VOID
EXPORT
NdisMCompleteBufferPhysicalMapping(
@ -131,54 +110,6 @@ NdisMCompleteBufferPhysicalMapping(
}
VOID
EXPORT
NdisMEthIndicateReceive (
IN NDIS_HANDLE MiniportAdapterHandle,
IN NDIS_HANDLE MiniportReceiveContext,
IN PVOID HeaderBuffer,
IN UINT HeaderBufferSize,
IN PVOID LookaheadBuffer,
IN UINT LookaheadBufferSize,
IN UINT PacketSize)
{
UNIMPLEMENTED
}
VOID
EXPORT
NdisMEthIndicateReceiveComplete(
IN NDIS_HANDLE MiniportAdapterHandle)
{
UNIMPLEMENTED
}
VOID
EXPORT
NdisMFddiIndicateReceive(
IN NDIS_HANDLE MiniportAdapterHandle,
IN NDIS_HANDLE MiniportReceiveContext,
IN PVOID HeaderBuffer,
IN UINT HeaderBufferSize,
IN PVOID LookaheadBuffer,
IN UINT LookaheadBufferSize,
IN UINT PacketSize)
{
UNIMPLEMENTED
}
VOID
EXPORT
NdisMFddiIndicateReceiveComplete(
IN NDIS_HANDLE MiniportAdapterHandle)
{
UNIMPLEMENTED
}
VOID
EXPORT
NdisMStartBufferPhysicalMapping(
@ -193,30 +124,6 @@ NdisMStartBufferPhysicalMapping(
}
VOID
EXPORT
NdisMTrIndicateReceive(
IN NDIS_HANDLE MiniportAdapterHandle,
IN NDIS_HANDLE MiniportReceiveContext,
IN PVOID HeaderBuffer,
IN UINT HeaderBufferSize,
IN PVOID LookaheadBuffer,
IN UINT LookaheadBufferSize,
IN UINT PacketSize)
{
UNIMPLEMENTED
}
VOID
EXPORT
NdisMTrIndicateReceiveComplete(
IN NDIS_HANDLE MiniportAdapterHandle)
{
UNIMPLEMENTED
}
VOID
EXPORT
NdisMapFile(

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

File diff suppressed because it is too large Load diff

35
reactos/include/net/ntddndis.h Normal file
View file

@ -0,0 +1,35 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS NDIS library
* FILE: include/net/ntddndis.h
* PURPOSE: Structures for accessing NDIS devices
*/
#ifndef __NTDDNDIS_H
#define __NIDDNDIS_H
typedef enum _NDIS_DEVICE_POWER_STATE
{
NdisDeviceStateUnspecified = 0,
NdisDeviceStateD0,
NdisDeviceStateD1,
NdisDeviceStateD2,
NdisDeviceStateD3,
NdisDeviceStateMaximum
} NDIS_DEVICE_POWER_STATE, *PNDIS_DEVICE_POWER_STATE;
typedef struct _NDIS_PM_WAKE_UP_CAPABILITIES
{
NDIS_DEVICE_POWER_STATE MinMagicPacketWakeUp;
NDIS_DEVICE_POWER_STATE MinPatternWakeUp;
NDIS_DEVICE_POWER_STATE MinLinkChangeWakeUp;
} NDIS_PM_WAKE_UP_CAPABILITIES, *PNDIS_PM_WAKE_UP_CAPABILITIES;
typedef struct _NDIS_PNP_CAPABILITIES
{
ULONG Flags;
NDIS_PM_WAKE_UP_CAPABILITIES WakeUpCapabilities;
} NDIS_PNP_CAPABILITIES, *PNDIS_PNP_CAPABILITIES;
#endif /* __NTDDNDIS_H */
/* EOF */