able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/ndis/sys/initpnp.c

1763 lines
57 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1990-1995 Microsoft Corporation
Module Name:
initpnp.c
Abstract:
NDIS wrapper functions initializing drivers.
Author:
Jameel Hyder (jameelh) 11-Aug-1995
Environment:
Kernel mode, FSD
Revision History:
--*/
#include <precomp.h>
#pragma hdrstop
#include <stdarg.h>
//
// Define the module number for debug code.
//
#define MODULE_NUMBER MODULE_INITPNP
NDIS_STATUS
ndisInitializeConfiguration(
OUT PNDIS_WRAPPER_CONFIGURATION_HANDLE pConfigurationHandle,
IN PNDIS_MINIPORT_BLOCK Miniport,
OUT PUNICODE_STRING pExportName OPTIONAL
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
#define PQueryTable pConfigurationHandle->ParametersQueryTable
#define LQueryTable pConfigurationHandle->ParametersQueryTable
NDIS_STATUS NdisStatus;
PWSTR Export = NULL;
NTSTATUS RegistryStatus;
PNDIS_CONFIGURATION_PARAMETER ReturnedValue;
NDIS_CONFIGURATION_HANDLE CnfgHandle;
NDIS_STRING BusNumberStr = NDIS_STRING_CONST("BusNumber");
NDIS_STRING SlotNumberStr = NDIS_STRING_CONST("SlotNumber");
NDIS_STRING BusTypeStr = NDIS_STRING_CONST("BusType");
NDIS_STRING PciIdStr = NDIS_STRING_CONST("AdapterCFID");
NDIS_STRING PnPCapsStr = NDIS_STRING_CONST("PnPCapabilities");
NDIS_STRING CharsStr = NDIS_STRING_CONST("Characteristics");
NDIS_STRING RemoteBootStr = NDIS_STRING_CONST("RemoteBootCard");
NDIS_STRING MediaDisconnectTimeOutStr = NDIS_STRING_CONST("MediaDisconnectToSleepTimeOut");
NDIS_STRING PollMediaConnectivityStr = NDIS_STRING_CONST("RequiresMediaStatePoll");
NDIS_STRING NdisDriverVerifyFlagsStr = NDIS_STRING_CONST("NdisDriverVerifyFlags");
NDIS_STRING SGMapRegistersNeededStr = NDIS_STRING_CONST("SGMapRegistersNeeded");
ULONG MediaDisconnectTimeOut;
HANDLE Handle;
PDEVICE_OBJECT PhysicalDeviceObject;
NDIS_INTERFACE_TYPE BusType = Isa;
UINT BusNumber = 0;
ULONG ResultLength;
PNDIS_CONFIGURATION_PARAMETER_QUEUE ParameterNode;
GUID BusTypeGuid;
DBGPRINT_RAW(DBG_COMP_PNP, DBG_LEVEL_INFO,
("==>ndisInitializeConfiguration: Miniport %p\n", Miniport));
CnfgHandle.ParameterList = NULL;
do
{
PhysicalDeviceObject = Miniport->PhysicalDeviceObject;
if (Miniport->BindPaths == NULL)
{
NdisStatus = ndisReadBindPaths(Miniport, LQueryTable);
if (NdisStatus != NDIS_STATUS_SUCCESS)
{
break;
}
}
if (pExportName != NULL)
{
//
// get a handle to "driver" section for PDO
//
#if NDIS_TEST_REG_FAILURE
RegistryStatus = STATUS_UNSUCCESSFUL;
Handle = NULL;
#else
RegistryStatus = IoOpenDeviceRegistryKey(PhysicalDeviceObject,
PLUGPLAY_REGKEY_DRIVER,
GENERIC_READ | MAXIMUM_ALLOWED,
&Handle);
#endif
#if !NDIS_NO_REGISTRY
if (!NT_SUCCESS(RegistryStatus))
{
NdisStatus = NDIS_STATUS_FAILURE;
break;
}
//
// Set up LQueryTable to do the following:
//
//
// 1. Switch to the Linkage key below this driver instance key
//
LQueryTable[0].QueryRoutine = NULL;
LQueryTable[0].Flags = RTL_QUERY_REGISTRY_SUBKEY;
LQueryTable[0].Name = L"Linkage";
//
// 2. Call ndisReadParameter for "Export" (as a single multi-string)
// which will allocate storage and save the data in Export.
//
LQueryTable[1].QueryRoutine = ndisReadParameter;
LQueryTable[1].Flags = RTL_QUERY_REGISTRY_REQUIRED | RTL_QUERY_REGISTRY_NOEXPAND;
LQueryTable[1].Name = L"Export";
LQueryTable[1].EntryContext = (PVOID)&Export;
LQueryTable[1].DefaultType = REG_NONE;
//
// 3. Stop
//
LQueryTable[2].QueryRoutine = NULL;
LQueryTable[2].Flags = 0;
LQueryTable[2].Name = NULL;
RegistryStatus = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE,
Handle,
LQueryTable,
(PVOID)NULL, // no context needed
NULL);
ZwClose(Handle);
if (!NT_SUCCESS(RegistryStatus))
{
DBGPRINT(DBG_COMP_INIT, DBG_LEVEL_ERR,
("ndisInitializeConfiguration: Could not read Bind/Export for %Z: %lx\n",
&Miniport->BaseName,
RegistryStatus));
NdisStatus = NDIS_STATUS_FAILURE;
break;
}
#else
if (NT_SUCCESS(RegistryStatus))
{
//
// Set up LQueryTable to do the following:
//
//
// 1. Switch to the Linkage key below this driver instance key
//
LQueryTable[0].QueryRoutine = NULL;
LQueryTable[0].Flags = RTL_QUERY_REGISTRY_SUBKEY;
LQueryTable[0].Name = L"Linkage";
//
// 2. Call ndisReadParameter for "Export" (as a single multi-string)
// which will allocate storage and save the data in Export.
//
LQueryTable[1].QueryRoutine = ndisReadParameter;
LQueryTable[1].Flags = RTL_QUERY_REGISTRY_REQUIRED | RTL_QUERY_REGISTRY_NOEXPAND;
LQueryTable[1].Name = L"Export";
LQueryTable[1].EntryContext = (PVOID)&Export;
LQueryTable[1].DefaultType = REG_NONE;
//
// 3. Stop
//
LQueryTable[2].QueryRoutine = NULL;
LQueryTable[2].Flags = 0;
LQueryTable[2].Name = NULL;
RegistryStatus = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE,
Handle,
LQueryTable,
(PVOID)NULL, // no context needed
NULL);
ZwClose(Handle);
if (!NT_SUCCESS(RegistryStatus))
{
DBGPRINT(DBG_COMP_INIT, DBG_LEVEL_ERR,
("ndisInitializeConfiguration: Could not read Bind/Export for %Z: %lx\n",
&Miniport->BaseName,
RegistryStatus));
NdisStatus = NDIS_STATUS_FAILURE;
break;
}
}
else
{
//
// we have to allocate space for default export name because the
// caller will attempt to free it
//
Export = (PWSTR)ALLOC_FROM_POOL(sizeof(NDIS_DEFAULT_EXPORT_NAME),
NDIS_TAG_NAME_BUF);
if (Export == NULL)
{
NdisStatus = STATUS_INSUFFICIENT_RESOURCES;
break;
}
RtlCopyMemory(Export, ndisDefaultExportName, sizeof(NDIS_DEFAULT_EXPORT_NAME));
}
#endif
RtlInitUnicodeString(pExportName, Export);
}
//
// NdisReadConfiguration assumes that ParametersQueryTable[3].Name is
// a key below the services key where the Parameters should be read,
// for layered drivers we store the last piece of Configuration
// Path there, leading to the desired effect.
//
// I.e, ConfigurationPath == "...\Services\Driver".
//
//
// 1) Call ndisSaveParameter for a parameter, which will allocate storage for it.
//
PQueryTable[0].QueryRoutine = NULL;
PQueryTable[0].Flags = RTL_QUERY_REGISTRY_SUBKEY;
PQueryTable[0].Name = L"";
//
// The following fields are filled in during NdisReadConfiguration
//
// PQueryTable[1].Name = KeywordBuffer;
// PQueryTable[1].EntryContext = ParameterValue;
PQueryTable[1].QueryRoutine = ndisSaveParameters;
PQueryTable[1].Flags = RTL_QUERY_REGISTRY_REQUIRED | RTL_QUERY_REGISTRY_NOEXPAND;
PQueryTable[1].DefaultType = REG_NONE;
//
// 2. Stop
//
PQueryTable[2].QueryRoutine = NULL;
PQueryTable[2].Flags = 0;
PQueryTable[2].Name = NULL;
//
// NOTE: Some fields in ParametersQueryTable[3 & 4] are used to
// store information for later retrieval.
// Save Adapter/Miniport block here. Later on, Adapter's PDO
// will be used to open the appropiate registry key
//
(PVOID)PQueryTable[3].QueryRoutine = (PVOID)Miniport;
PQueryTable[3].Name = L"";
PQueryTable[3].EntryContext = NULL;
PQueryTable[3].DefaultData = NULL;
// Now read bustype/busnumber for this adapter and save it
CnfgHandle.KeyQueryTable = PQueryTable;
RegistryStatus = IoGetDeviceProperty(PhysicalDeviceObject,
DevicePropertyBusTypeGuid,
sizeof(GUID),
(PVOID)&BusTypeGuid,
&ResultLength);
//
// try to get the -real- bus type by first querying the bustype guid
// if we couldn't get the guid, try to get a legacy bustype. because
// some bus drivers like pcmcia do not report the real bus type, we
// have to query the bus type guid first.
//
if (NT_SUCCESS(RegistryStatus))
{
if (!memcmp(&BusTypeGuid, &GUID_BUS_TYPE_INTERNAL, sizeof(GUID)))
BusType = Internal;
else if (!memcmp(&BusTypeGuid, &GUID_BUS_TYPE_PCMCIA, sizeof(GUID)))
BusType = PCMCIABus;
else if (!memcmp(&BusTypeGuid, &GUID_BUS_TYPE_PCI, sizeof(GUID)))
BusType = PCIBus;
else if (!memcmp(&BusTypeGuid, &GUID_BUS_TYPE_ISAPNP, sizeof(GUID)))
BusType = PNPISABus;
else if (!memcmp(&BusTypeGuid, &GUID_BUS_TYPE_EISA, sizeof(GUID)))
{
BusType = Eisa;
ASSERT(BusType != Eisa);
}
else
BusType = Isa;
}
if (BusType == Isa)
{
//
// either the call to get BusTypeGuid failed or the returned guid
// does not match any that we know of
//
RegistryStatus = IoGetDeviceProperty(PhysicalDeviceObject,
DevicePropertyLegacyBusType,
sizeof(UINT),
(PVOID)&BusType,
&ResultLength);
}
if (!NT_SUCCESS(RegistryStatus)
|| (BusType == Isa)
|| (BusType == PCMCIABus))
{
if (NT_SUCCESS(RegistryStatus))
{
ASSERT(BusType != Isa);
}
//
// if the call was unsuccessful or BusType is ISA or PCMCIABus
// read BusType from registry
//
NdisReadConfiguration(&NdisStatus,
&ReturnedValue,
&CnfgHandle,
&BusTypeStr,
NdisParameterInteger);
if (NdisStatus == NDIS_STATUS_SUCCESS)
{
BusType = (NDIS_INTERFACE_TYPE)(ReturnedValue->ParameterData.IntegerData);
}
}
if ((BusType == PCIBus) ||
(BusType == PCMCIABus))
{
ASSERT(CURRENT_IRQL < DISPATCH_LEVEL);
NdisStatus = ndisQueryBusInterface(Miniport);
if (NdisStatus != NDIS_STATUS_SUCCESS)
{
ASSERT(FALSE);
break;
}
}
if ((BusType == Eisa) ||
(BusType == MicroChannel))
{
NdisStatus = NDIS_STATUS_NOT_SUPPORTED;
break;
}
Miniport->BusType = BusType;
//
// Read PnP capabilities. By default the WOL feature should be disabled
//
//
NdisReadConfiguration(&NdisStatus,
&ReturnedValue,
&CnfgHandle,
&PnPCapsStr,
NdisParameterInteger);
if (NdisStatus == NDIS_STATUS_SUCCESS)
{
Miniport->PnPCapabilities = ReturnedValue->ParameterData.IntegerData;
}
else
{
Miniport->PnPCapabilities = NDIS_DEVICE_DISABLE_WAKE_UP;
}
//
// try to get the bus number from PnP and if it fails
// try reading it from registry
//
RegistryStatus = IoGetDeviceProperty(PhysicalDeviceObject,
DevicePropertyBusNumber,
sizeof(UINT),
(PVOID)&BusNumber,
&ResultLength);
if (!NT_SUCCESS(RegistryStatus))
{
//
// if the call was unsuccessful
// Read Bus Number from registry
//
NdisReadConfiguration(&NdisStatus,
&ReturnedValue,
&CnfgHandle,
&BusNumberStr,
NdisParameterInteger);
if (NdisStatus == NDIS_STATUS_SUCCESS)
{
BusNumber = ReturnedValue->ParameterData.IntegerData;
}
}
Miniport->BusNumber = BusNumber;
//
// Read Slot Number
//
NdisReadConfiguration(&NdisStatus,
&ReturnedValue,
&CnfgHandle,
&SlotNumberStr,
NdisParameterInteger);
if (NdisStatus == NDIS_STATUS_SUCCESS)
{
Miniport->SlotNumber = ReturnedValue->ParameterData.IntegerData;
}
else
{
Miniport->SlotNumber = -1;
}
NdisReadConfiguration(&NdisStatus,
&ReturnedValue,
&CnfgHandle,
&RemoteBootStr,
NdisParameterHexInteger);
if (NdisStatus == NDIS_STATUS_SUCCESS)
{
if (ReturnedValue->ParameterData.IntegerData != 0)
{
MINIPORT_SET_FLAG(Miniport, fMINIPORT_NETBOOT_CARD);
Miniport->InfoFlags |= NDIS_MINIPORT_NETBOOT_CARD;
}
}
//
// read the value for media disconnect timer, set to 20 seconds if not present
// default=disable pm when cable is disconnected
//
MediaDisconnectTimeOut = -1;
NdisReadConfiguration(&NdisStatus,
&ReturnedValue,
&CnfgHandle,
&MediaDisconnectTimeOutStr,
NdisParameterHexInteger);
if (NdisStatus == NDIS_STATUS_SUCCESS)
{
MediaDisconnectTimeOut = ReturnedValue->ParameterData.IntegerData;
if (MediaDisconnectTimeOut == 0)
{
MediaDisconnectTimeOut = 1;
}
}
Miniport->MediaDisconnectTimeOut = (USHORT)MediaDisconnectTimeOut;
if (MediaDisconnectTimeOut == (ULONG)(-1))
{
Miniport->PnPCapabilities |= NDIS_DEVICE_DISABLE_WAKE_ON_RECONNECT;
}
NdisReadConfiguration(&NdisStatus,
&ReturnedValue,
&CnfgHandle,
&PollMediaConnectivityStr,
NdisParameterInteger);
if (NdisStatus == NDIS_STATUS_SUCCESS)
{
//
// This miniport wants Ndis to poll it regularly for media connectivity.
// Default value is FALSE for this flag. This flag will be cleared if miniport
// can indicate media status or does not support media query
//
if (ReturnedValue->ParameterData.IntegerData == 1)
{
MINIPORT_SET_FLAG(Miniport, fMINIPORT_REQUIRES_MEDIA_POLLING);
}
}
NdisReadConfiguration(&NdisStatus,
&ReturnedValue,
&CnfgHandle,
&SGMapRegistersNeededStr,
NdisParameterInteger);
if (NdisStatus == NDIS_STATUS_SUCCESS)
{
Miniport->SGMapRegistersNeeded = (USHORT)ReturnedValue->ParameterData.IntegerData;
}
else
{
Miniport->SGMapRegistersNeeded = NDIS_MAXIMUM_SCATTER_GATHER_SEGMENTS;
}
NdisReadConfiguration(&NdisStatus,
&ReturnedValue,
&CnfgHandle,
&NdisDriverVerifyFlagsStr,
NdisParameterHexInteger);
if (NdisStatus == NDIS_STATUS_SUCCESS)
{
Miniport->DriverVerifyFlags = ReturnedValue->ParameterData.IntegerData;
}
PQueryTable[3].DefaultData = NULL;
PQueryTable[3].Flags = 0;
NdisStatus = NDIS_STATUS_SUCCESS;
} while (FALSE);
//
// free NDIS_CONFIGURATION_PARAMETER_QUEUE nodes hanging from CnfgHandle
//
ParameterNode = CnfgHandle.ParameterList;
while (ParameterNode != NULL)
{
CnfgHandle.ParameterList = ParameterNode->Next;
FREE_POOL(ParameterNode);
ParameterNode = CnfgHandle.ParameterList;
}
#undef PQueryTable
#undef LQueryTable
DBGPRINT_RAW(DBG_COMP_PNP, DBG_LEVEL_INFO,
("<==ndisInitializeConfiguration: Miniport %p\n", Miniport));
return(NdisStatus);
}
NTSTATUS
ndisReadBindPaths(
IN PNDIS_MINIPORT_BLOCK Miniport,
IN PRTL_QUERY_REGISTRY_TABLE LQueryTable
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
NTSTATUS NtStatus;
HANDLE Handle = NULL;
PWSTR pPath, p, BindPathData = NULL;
UINT i, Len, NumComponents;
BOOLEAN FreeBindPathData = FALSE;
DBGPRINT_RAW(DBG_COMP_PNP, DBG_LEVEL_INFO,
("==>ndisReadBindPaths: Miniport %p\n", Miniport));
do
{
#if NDIS_TEST_REG_FAILURE
NtStatus = STATUS_UNSUCCESSFUL;
#else
NtStatus = IoOpenDeviceRegistryKey(Miniport->PhysicalDeviceObject,
PLUGPLAY_REGKEY_DRIVER,
GENERIC_READ | MAXIMUM_ALLOWED,
&Handle);
#endif
#if !NDIS_NO_REGISTRY
if (!NT_SUCCESS(NtStatus))
break;
//
// 1.
// Switch to the Linkage key below this driver instance key
//
LQueryTable[0].QueryRoutine = NULL;
LQueryTable[0].Flags = RTL_QUERY_REGISTRY_SUBKEY;
LQueryTable[0].Name = L"Linkage";
//
// 2.
// Read the RootDevice keywords
//
LQueryTable[1].QueryRoutine = ndisReadParameter;
LQueryTable[1].Flags = RTL_QUERY_REGISTRY_NOEXPAND;
LQueryTable[1].Name = L"RootDevice";
LQueryTable[1].EntryContext = (PVOID)&BindPathData;
LQueryTable[1].DefaultType = REG_NONE;
LQueryTable[2].QueryRoutine = NULL;
LQueryTable[2].Flags = 0;
LQueryTable[2].Name = NULL;
NtStatus = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE,
Handle,
LQueryTable,
NULL,
NULL);
ZwClose(Handle);
if (!NT_SUCCESS(NtStatus))
break;
#else
if (NT_SUCCESS(NtStatus))
{
//
// 1.
// Switch to the Linkage key below this driver instance key
//
LQueryTable[0].QueryRoutine = NULL;
LQueryTable[0].Flags = RTL_QUERY_REGISTRY_SUBKEY;
LQueryTable[0].Name = L"Linkage";
//
// 2.
// Read the RootDevice keywords
//
LQueryTable[1].QueryRoutine = ndisReadParameter;
LQueryTable[1].Flags = RTL_QUERY_REGISTRY_NOEXPAND;
LQueryTable[1].Name = L"RootDevice";
LQueryTable[1].EntryContext = (PVOID)&BindPathData;
LQueryTable[1].DefaultType = REG_NONE;
LQueryTable[2].QueryRoutine = NULL;
LQueryTable[2].Flags = 0;
LQueryTable[2].Name = NULL;
NtStatus = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE,
Handle,
LQueryTable,
NULL,
NULL);
ZwClose(Handle);
if (!NT_SUCCESS(NtStatus))
break;
}
else
{
NtStatus = STATUS_SUCCESS;
}
#endif
//
// BindPath is a MULTI-SZ which starts at the top of the filter chain
// and goes down to the miniport. It is of the form
//
// {FN} {FN-1} ... {F1} {Adapter}
//
// Where spaces are actually nulls and each of {Fn} is a filter instance.
//
if (BindPathData == NULL)
{
BindPathData = Miniport->BaseName.Buffer;
}
else
{
FreeBindPathData = TRUE;
}
//
// Split bindpath into individual components. Start by determining how much
// space we need.
//
Len = sizeof(NDIS_BIND_PATHS);
for (pPath = BindPathData, NumComponents = 0; *pPath != 0; NOTHING)
{
NDIS_STRING us;
RtlInitUnicodeString(&us, pPath);
NumComponents++;
Len += sizeof(NDIS_STRING) + us.Length + ndisDeviceStr.Length + sizeof(WCHAR);
(PUCHAR)pPath += (us.Length + sizeof(WCHAR));
}
//
// Allocate space for bindpaths. We have NumComponents paths
// which consume Len bytes of space. We could be re-initialzing
// so free any previous buffer allcoated for this.
//
if (Miniport->BindPaths != NULL)
{
FREE_POOL(Miniport->BindPaths);
}
Miniport->BindPaths = (PNDIS_BIND_PATHS)ALLOC_FROM_POOL(Len,
NDIS_TAG_NAME_BUF);
if (Miniport->BindPaths == NULL)
{
NtStatus = STATUS_INSUFFICIENT_RESOURCES;
break;
}
ZeroMemory(Miniport->BindPaths, Len);
Miniport->BindPaths->Number = NumComponents;
if (NumComponents > 1)
{
MINIPORT_PNP_SET_FLAG(Miniport, fMINIPORT_FILTER_IM);
}
//
// Create an array in reverse order of device-names in the filter path.
//
p = (PWSTR)((PUCHAR)Miniport->BindPaths +
sizeof(NDIS_BIND_PATHS) +
NumComponents*sizeof(NDIS_STRING));
for (pPath = BindPathData, i = (NumComponents-1);
*pPath != 0;
i --)
{
NDIS_STRING Str, SubStr, *Bp;
RtlInitUnicodeString(&Str, pPath);
(PUCHAR)pPath += (Str.Length + sizeof(WCHAR));
Bp = &Miniport->BindPaths->Paths[i];
Bp->Buffer = p;
Bp->Length = 0;
Bp->MaximumLength = Str.Length + ndisDeviceStr.Length + sizeof(WCHAR);
SubStr.Buffer = (PWSTR)((PUCHAR)p + ndisDeviceStr.Length);
SubStr.MaximumLength = Str.Length + sizeof(WCHAR);
SubStr.Length = 0;
RtlCopyUnicodeString(Bp, &ndisDeviceStr);
RtlUpcaseUnicodeString(&SubStr,
&Str,
FALSE);
Bp->Length += SubStr.Length;
(PUCHAR)p += Bp->MaximumLength;
}
} while (FALSE);
if (FreeBindPathData)
FREE_POOL(BindPathData);
;
DBGPRINT_RAW(DBG_COMP_PNP, DBG_LEVEL_INFO,
("<==ndisReadBindPaths: Miniport %p\n", Miniport));
return NtStatus;
}
NTSTATUS
ndisCreateAdapterInstanceName(
OUT PUNICODE_STRING * pAdapterInstanceName,
IN PDEVICE_OBJECT PhysicalDeviceObject
)
{
NTSTATUS NtStatus, SlotQueryStatus;
DEVICE_REGISTRY_PROPERTY Property;
PWCHAR pValueInfo = NULL;
ULONG ResultLength = 0;
PUNICODE_STRING AdapterInstanceName = NULL;
ULONG SlotNumber;
DBGPRINT(DBG_COMP_PNP, DBG_LEVEL_INFO,
("==>ndisCreateAdapterInstanceName: PDO %p\n", PhysicalDeviceObject));
do
{
*pAdapterInstanceName = NULL;
Property = DevicePropertyFriendlyName;
NtStatus = IoGetDeviceProperty(PhysicalDeviceObject,
Property,
0,
NULL,
&ResultLength);
if ((NtStatus != STATUS_BUFFER_TOO_SMALL) && !NT_SUCCESS(NtStatus))
{
Property = DevicePropertyDeviceDescription;
NtStatus = IoGetDeviceProperty(PhysicalDeviceObject,
Property,
0,
NULL,
&ResultLength);
if ((NtStatus != STATUS_BUFFER_TOO_SMALL) && !NT_SUCCESS(NtStatus))
{
DBGPRINT(DBG_COMP_PNP, DBG_LEVEL_ERR,
("ndisCreateAdapterInstanceName: PDO %p, Failed to query the adapter description\n", PhysicalDeviceObject));
break;
}
}
//
// Allocate space to hold the partial value information.
//
pValueInfo = ALLOC_FROM_POOL(ResultLength, NDIS_TAG_DEFAULT);
if (NULL == pValueInfo)
{
NtStatus = STATUS_INSUFFICIENT_RESOURCES;
DBGPRINT(DBG_COMP_PNP, DBG_LEVEL_ERR,
("ndisCreateAdapterInstanceName: PDO %p, Failed to allocate storage for the adapter description\n", PhysicalDeviceObject));
break;
}
RtlZeroMemory(pValueInfo, ResultLength);
NtStatus = IoGetDeviceProperty(PhysicalDeviceObject,
Property,
ResultLength,
pValueInfo,
&ResultLength);
if (!NT_SUCCESS(NtStatus))
{
DBGPRINT(DBG_COMP_PNP, DBG_LEVEL_ERR,
("ndisCreateAdapterInstanceName: PDO %p, Failed to query the adapter description\n", PhysicalDeviceObject));
break;
}
//
// Determine the size of the instance name buffer. This is a UNICODE_STRING
// and it's associated buffer.
//
ResultLength += sizeof(UNICODE_STRING);
//
// Allocate the buffer.
//
AdapterInstanceName = ALLOC_FROM_POOL(ResultLength, NDIS_TAG_NAME_BUF);
if (NULL == AdapterInstanceName)
{
NtStatus = STATUS_INSUFFICIENT_RESOURCES;
DBGPRINT(DBG_COMP_PNP, DBG_LEVEL_ERR,
("ndisCreateAdapterInstanceName: PDO %p, Failed to allocate storage for the adapter instance name\n", PhysicalDeviceObject));
break;
}
//
// Initialize the buffer.
//
RtlZeroMemory(AdapterInstanceName, ResultLength);
//
// Initialize the UNICODE_STRING for the instance name.
//
AdapterInstanceName->Buffer = (PWSTR)((PUCHAR)AdapterInstanceName + sizeof(UNICODE_STRING));
AdapterInstanceName->Length = 0;
AdapterInstanceName->MaximumLength = (USHORT)(ResultLength - sizeof(UNICODE_STRING));
RtlAppendUnicodeToString(AdapterInstanceName, pValueInfo);
DBGPRINT(DBG_COMP_PNP, DBG_LEVEL_INFO,
("ndisCreateAdapterInstanceName: %ws\n", AdapterInstanceName->Buffer));
//
// Return the instance name.
//
*pAdapterInstanceName = AdapterInstanceName;
//
// get the slot number
//
Property = DevicePropertyUINumber;
SlotQueryStatus = IoGetDeviceProperty(PhysicalDeviceObject,
Property,
sizeof (ULONG),
&SlotNumber,
&ResultLength);
if (NT_SUCCESS(SlotQueryStatus))
{
DBGPRINT(DBG_COMP_PNP, DBG_LEVEL_INFO,
("ndisCreateAdapterInstanceName: %ws, Slot Number: %ld\n",
AdapterInstanceName->Buffer,
SlotNumber));
}
else
{
DBGPRINT(DBG_COMP_PNP, DBG_LEVEL_INFO,
("ndisCreateAdapterInstanceName: couldn't get SlotNumber for %ws\n",
AdapterInstanceName->Buffer));
}
} while (FALSE);
if (NULL != pValueInfo)
FREE_POOL(pValueInfo);
DBGPRINT(DBG_COMP_PNP, DBG_LEVEL_INFO,
("<==ndisCreateAdapterInstanceName: PDO %p, Status 0x%x\n", PhysicalDeviceObject, NtStatus));
return(NtStatus);
}
NDIS_STATUS
ndisInitializeAdapter(
IN PNDIS_M_DRIVER_BLOCK pMiniBlock,
IN PDEVICE_OBJECT DeviceObject,
IN PUNICODE_STRING InstanceName,
IN NDIS_HANDLE DeviceContext OPTIONAL
)
{
NDIS_WRAPPER_CONFIGURATION_HANDLE ConfigurationHandle;
NDIS_STATUS NdisStatus;
UNICODE_STRING ExportName;
NDIS_CONFIGURATION_HANDLE TmpConfigHandle;
PNDIS_MINIPORT_BLOCK Miniport= (PNDIS_MINIPORT_BLOCK)((PNDIS_WRAPPER_CONTEXT)DeviceObject->DeviceExtension + 1);
TIME TS, TE, TD;
#define PQueryTable ConfigurationHandle.ParametersQueryTable
#define Db ConfigurationHandle.Db
DBGPRINT_RAW(DBG_COMP_PNP, DBG_LEVEL_INFO,
("==>ndisInitializeAdapter: Miniport/Adapter %p\n", Miniport));
do
{
ZeroMemory(&ConfigurationHandle, sizeof(NDIS_WRAPPER_CONFIGURATION_HANDLE));
ExportName.Buffer = NULL;
//
// Build the configuration handle.
//
NdisStatus = ndisInitializeConfiguration(&ConfigurationHandle,
Miniport,
&ExportName);
if (NdisStatus != NDIS_STATUS_SUCCESS)
{
break;
}
//
// OK, Now lock down all the filter packages. If a MAC or
// Miniport driver uses any of these, then the filter package
// will reference itself, to keep the image in memory.
//
#if ARCNET
ArcReferencePackage();
#endif
EthReferencePackage();
FddiReferencePackage();
TrReferencePackage();
MiniportReferencePackage();
CoReferencePackage();
ConfigurationHandle.DeviceObject = DeviceObject;
ConfigurationHandle.DriverBaseName = InstanceName;
KeQuerySystemTime(&TS);
//
// Save the Driver Object with the configuration handle.
//
ConfigurationHandle.DriverObject = pMiniBlock->NdisDriverInfo->DriverObject;
NdisStatus = ndisMInitializeAdapter(pMiniBlock,
&ConfigurationHandle,
&ExportName,
DeviceContext);
KeQuerySystemTime(&TE);
TD.QuadPart = TE.QuadPart - TS.QuadPart;
TD.QuadPart /= 10000; // Convert to ms
Miniport = (PNDIS_MINIPORT_BLOCK)((PNDIS_WRAPPER_CONTEXT)(ConfigurationHandle.DeviceObject->DeviceExtension) + 1);
Miniport->InitTimeMs = TD.LowPart;
if (ndisFlags & NDIS_GFLAG_INIT_TIME)
{
DbgPrint("NDIS: Init time (%Z) %ld ms\n", Miniport->pAdapterInstanceName, Miniport->InitTimeMs);
}
if (NdisStatus != NDIS_STATUS_SUCCESS)
{
ndisCloseULongRef(&Miniport->Ref);
}
//
// OK, Now dereference all the filter packages. If a MAC or
// Miniport driver uses any of these, then the filter package
// will reference itself, to keep the image in memory.
//
#if ARCNET
ArcDereferencePackage();
#endif
EthDereferencePackage();
FddiDereferencePackage();
TrDereferencePackage();
MiniportDereferencePackage();
CoDereferencePackage();
} while (FALSE);
if (ExportName.Buffer)
FREE_POOL(ExportName.Buffer);
//
// free "Bind" data
//
if (PQueryTable[3].EntryContext != NULL)
FREE_POOL(PQueryTable[3].EntryContext);
#undef PQueryTable
#undef Db
DBGPRINT_RAW(DBG_COMP_PNP, DBG_LEVEL_INFO,
("<==ndisInitializeAdapter: Miniport/Adapter %p\n", Miniport));
return(NdisStatus);
}
VOID
FASTCALL
ndisCheckAdapterBindings(
IN PNDIS_MINIPORT_BLOCK Miniport,
IN PNDIS_PROTOCOL_BLOCK Protocol OPTIONAL
)
/*+++
Routine Description:
This function, reads the registry to get all the protocols that are supposed
to bind to this adapter and for each protocol, calls ndisInitializeBinding
Arguments:
Adapter Pointer to ndis Adpater or Miniport block
Protocol Optionally if a protocol is specified, initiate binding to only
that protocol
Return Value:
None
---*/
{
RTL_QUERY_REGISTRY_TABLE LinkQueryTable[3];
NTSTATUS RegistryStatus;
PWSTR UpperBind = NULL;
HANDLE Handle;
PDEVICE_OBJECT PhysicalDeviceObject;
UNICODE_STRING Us;
PWSTR CurProtocolName;
PNDIS_PROTOCOL_BLOCK CurProtocol;
NTSTATUS NtStatus;
KIRQL OldIrql;
DBGPRINT_RAW(DBG_COMP_PNP, DBG_LEVEL_INFO,
("==>ndisCheckAdapterBindings: Miniport %p, Protocol %p\n", Miniport, Protocol));
do
{
//
// get a handle to driver section in registry
//
PhysicalDeviceObject = Miniport->PhysicalDeviceObject;
if (MINIPORT_TEST_FLAG(Miniport, fMINIPORT_SECONDARY))
{
//
// Skip bind notifications for a secondary miniport
//
break;
}
#if NDIS_TEST_REG_FAILURE
RegistryStatus = STATUS_UNSUCCESSFUL;
Handle = NULL;
#else
RegistryStatus = IoOpenDeviceRegistryKey(PhysicalDeviceObject,
PLUGPLAY_REGKEY_DRIVER,
GENERIC_READ | MAXIMUM_ALLOWED,
&Handle);
#endif
#if NDIS_NO_REGISTRY
if (!NT_SUCCESS(RegistryStatus))
{
if (ARGUMENT_PRESENT(Protocol))
{
ndisInitializeBinding(Miniport, Protocol);
break;
}
else
{
for (CurProtocol = ndisProtocolList;
CurProtocol != NULL;
CurProtocol = CurProtocol->NextProtocol)
{
ndisInitializeBinding(Miniport, CurProtocol);
}
}
break;
}
#else
if (!NT_SUCCESS(RegistryStatus))
{
break;
}
#endif
//
// Set up LinkQueryTable to do the following:
//
//
// 1) Switch to the Linkage key below the xports registry key
//
LinkQueryTable[0].QueryRoutine = NULL;
LinkQueryTable[0].Flags = RTL_QUERY_REGISTRY_SUBKEY;
LinkQueryTable[0].Name = L"Linkage";
//
// 2) Call ndisReadParameter for "UpperBind" (as a single multi-string),
// which will allocate storage and save the data in UpperBind.
//
LinkQueryTable[1].QueryRoutine = ndisReadParameter;
LinkQueryTable[1].Flags = RTL_QUERY_REGISTRY_REQUIRED | RTL_QUERY_REGISTRY_NOEXPAND;
LinkQueryTable[1].Name = L"UpperBind";
LinkQueryTable[1].EntryContext = (PVOID)&UpperBind;
LinkQueryTable[1].DefaultType = REG_NONE;
//
// 3) Stop
//
LinkQueryTable[2].QueryRoutine = NULL;
LinkQueryTable[2].Flags = 0;
LinkQueryTable[2].Name = NULL;
RegistryStatus = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE,
Handle,
LinkQueryTable,
(PVOID)NULL, // no context needed
NULL);
ZwClose(Handle);
if (NT_SUCCESS(RegistryStatus))
{
for (CurProtocolName = UpperBind;
*CurProtocolName != 0;
CurProtocolName = (PWCHAR)((PUCHAR)CurProtocolName + Us.MaximumLength))
{
RtlInitUnicodeString (&Us, CurProtocolName);
if (ARGUMENT_PRESENT(Protocol))
{
if (RtlEqualUnicodeString(&Us, &Protocol->ProtocolCharacteristics.Name, TRUE))
{
ndisInitializeBinding(Miniport, Protocol);
break;
}
}
else
{
for (CurProtocol = ndisProtocolList;
CurProtocol != NULL;
CurProtocol = CurProtocol->NextProtocol)
{
if (RtlEqualUnicodeString(&Us, &CurProtocol->ProtocolCharacteristics.Name, TRUE))
{
ndisInitializeBinding(Miniport, CurProtocol);
break;
}
}
}
}
}
//
// Handle proxy and rca filters.
//
if ((Miniport != NULL) &&
!ndisMediaTypeCl[Miniport->MediaType] &&
MINIPORT_TEST_FLAG(Miniport, fMINIPORT_IS_CO))
{
if (ARGUMENT_PRESENT(Protocol))
{
if (Protocol->ProtocolCharacteristics.Flags & NDIS_PROTOCOL_BIND_ALL_CO)
{
ndisInitializeBinding(Miniport, Protocol);
}
}
else
{
for (CurProtocol = ndisProtocolList;
CurProtocol != NULL;
CurProtocol = CurProtocol->NextProtocol)
{
if (CurProtocol->ProtocolCharacteristics.Flags & NDIS_PROTOCOL_BIND_ALL_CO)
{
ndisInitializeBinding(Miniport, CurProtocol);
}
}
}
}
} while (FALSE);
if (UpperBind != NULL)
FREE_POOL(UpperBind);
DBGPRINT_RAW(DBG_COMP_PNP, DBG_LEVEL_INFO,
("<==ndisCheckAdapterBindings: Miniport %p, Protocol %p\n", Miniport, Protocol));
}
BOOLEAN
FASTCALL
ndisProtocolAlreadyBound(
IN PNDIS_PROTOCOL_BLOCK Protocol,
IN PNDIS_MINIPORT_BLOCK Miniport
)
{
PNDIS_OPEN_BLOCK pOpen;
BOOLEAN rc = FALSE;
KIRQL OldIrql;
DBGPRINT_RAW(DBG_COMP_BIND, DBG_LEVEL_INFO,
("==>ndisProtocolAlreadyBound: Protocol %p, Miniport %p\n", Protocol, Miniport));
PnPReferencePackage();
ACQUIRE_SPIN_LOCK(&Protocol->Ref.SpinLock, &OldIrql);
for (pOpen = Protocol->OpenQueue;
pOpen != NULL;
pOpen = pOpen->ProtocolNextOpen)
{
if (pOpen->MiniportHandle == Miniport)
{
rc = TRUE;
break;
}
}
RELEASE_SPIN_LOCK(&Protocol->Ref.SpinLock, OldIrql);
PnPDereferencePackage();
DBGPRINT_RAW(DBG_COMP_BIND, DBG_LEVEL_INFO,
("<==ndisProtocolAlreadyBound: Protocol %p, Miniport %p\n", Protocol, Miniport));
return rc;
}
NDIS_STATUS
NdisIMInitializeDeviceInstance(
IN NDIS_HANDLE DriverHandle,
IN PNDIS_STRING DeviceInstance
)
/*++
Routine Description:
Initialize an instance of a miniport device.
Arguments:
DriverHandle - Handle returned by NdisMRegisterLayeredMiniport.
It is a pointer to NDIS_M_DRIVER_BLOCK.
DeviceInstance -Points to the instance of the driver that must now
be initialized.
Return Value:
--*/
{
NDIS_STATUS Status;
DBGPRINT_RAW(DBG_COMP_INIT, DBG_LEVEL_INFO,
("==>NdisIMInitializeDeviceInstance: Driver %p, DeviceInstance %p\n", DriverHandle, DeviceInstance));
Status = NdisIMInitializeDeviceInstanceEx(DriverHandle, DeviceInstance, NULL);
DBGPRINT_RAW(DBG_COMP_INIT, DBG_LEVEL_INFO,
("<==NdisIMInitializeDeviceInstance: Driver %p, DeviceInstance %p\n", DriverHandle, DeviceInstance));
return Status;
}
NDIS_STATUS
NdisIMInitializeDeviceInstanceEx(
IN NDIS_HANDLE DriverHandle,
IN PNDIS_STRING DeviceInstance,
IN NDIS_HANDLE DeviceContext
)
/*++
Routine Description:
Initialize an instance of a miniport device. Incarnation of NdisIMInitializeDeviceInstance.
Arguments:
DriverHandle Handle returned by NdisMRegisterLayeredMiniport.
It is a pointer to NDIS_M_DRIVER_BLOCK.
DeviceInstance Points to the instance of the driver that must now
be initialized.
DeviceContext Context to associate with the device. Retrieved via NdisIMGetDeviceContext.
Return Value:
--*/
{
NDIS_STATUS Status;
PNDIS_M_DRIVER_BLOCK MiniBlock = (PNDIS_M_DRIVER_BLOCK)DriverHandle;
KIRQL OldIrql;
PNDIS_MINIPORT_BLOCK Miniport;
DBGPRINT_RAW(DBG_COMP_INIT, DBG_LEVEL_INFO,
("==>NdisIMInitializeDeviceInstanceEx: Driver %p, Instance %p, Context %p\n",
DriverHandle, DeviceInstance, DeviceContext));
PnPReferencePackage();
WAIT_FOR_OBJECT(&MiniBlock->IMStartRemoveMutex, NULL);
do
{
Miniport = ndisFindMiniportOnGlobalList(DeviceInstance);
if (Miniport != NULL)
{
if (MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_RECEIVED_START) &&
!MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_REMOVE_IN_PROGRESS | fMINIPORT_PM_HALTED))
{
DBGPRINT_RAW(DBG_COMP_INIT, DBG_LEVEL_INFO,
("NdisIMInitializeDeviceInstanceEx: we have already received START_IRP for Miniport %p\n",
Miniport));
//
// check to make sure the miniport has not been initialized already
// i.e. we are not getting duplicate NdisIMInitializeDeviceInstance
// a device that has already been initialized
//
if (ndisIsMiniportStarted(Miniport))
{
DBGPRINT_RAW(DBG_COMP_INIT, DBG_LEVEL_ERR,
("NdisIMInitializeDeviceInstanceEx: we have already initialized this device. Miniport %p\n",
Miniport));
Status = NDIS_STATUS_NOT_ACCEPTED;
break;
}
Status = ndisIMInitializeDeviceInstance(Miniport,
DeviceContext,
FALSE);
if (Status != NDIS_STATUS_SUCCESS)
{
//
// since we have already succeeded the START_IRP, signal PnP to remove this device
// by tagging the device as failed and requesting a QUERY_PNP_DEVICE_STATE IRP
//
MINIPORT_PNP_SET_FLAG(Miniport, fMINIPORT_DEVICE_FAILED);
IoInvalidateDeviceState(Miniport->PhysicalDeviceObject);
}
break;
}
}
//
// device is not started or not added yet.
//
Status = ndisIMQueueDeviceInstance(DriverHandle,
DeviceInstance,
DeviceContext);
} while (FALSE);
RELEASE_MUTEX(&MiniBlock->IMStartRemoveMutex);
PnPDereferencePackage();
DBGPRINT_RAW(DBG_COMP_INIT, DBG_LEVEL_INFO,
("<==NdisIMInitializeDeviceInstanceEx: Driver %p, Instance %p, Context %p, Status %lx\n",
DriverHandle, DeviceInstance, DeviceContext, Status));
return Status;
}
NDIS_STATUS
ndisIMInitializeDeviceInstance(
IN PNDIS_MINIPORT_BLOCK Miniport,
IN NDIS_HANDLE DeviceContext,
IN BOOLEAN fStartIrp
)
/*++
Routine Description:
This routine is called when we have received NdisIMInitializeDeviceInstance
-AND- START IRP for an IM miniport.
Initialize an instance of a miniport device.
Arguments:
Miniport Handle to NDIS_MINIPORT_BLOCK
DeviceContext Context to associate with the device. Retrieved via NdisIMGetDeviceContext.
fStartIrp flag to signal if we are in the context of handling START IRP
Return Value:
--*/
{
NDIS_STATUS Status;
NTSTATUS NtStatus;
DBGPRINT_RAW(DBG_COMP_INIT, DBG_LEVEL_INFO,
("==>ndisIMInitializeDeviceInstance: Miniport %p, Context %p, fStartIrp %lx\n", Miniport, DeviceContext, fStartIrp));
//
// it is quite possible we are dealing with a miniport block that has been "used"
// several times. inother words, it has been started and DeviceInitialized, then
// Device-De-Initialized and then has received a few query_stop and cancel_stop.
// in this case the miniport block has to be cleaned up. otherwise, ndisPnPStartDevice
// is not going to detect that miniport block needs re-initalization
//
ndisReinitializeMiniportBlock(Miniport);
Miniport->DeviceContext = DeviceContext;
Status = ndisPnPStartDevice(Miniport->DeviceObject, NULL); // no Irp
if (Status == NDIS_STATUS_SUCCESS)
{
//
// if we are in the context of start IRP, queue a workitem to initialize
// the bindings on this adapter to avoid the delay
//
if (!fStartIrp)
{
//
// Now set the device class association so that people can reference this.
//
NtStatus = IoSetDeviceInterfaceState(&Miniport->SymbolicLinkName, TRUE);
if (NT_SUCCESS(NtStatus))
{
//
// Do protocol notifications
//
ndisCheckAdapterBindings(Miniport, NULL);
}
else
{
DBGPRINT(DBG_COMP_PNP, DBG_LEVEL_ERR,
("ndisCheckAdapterBindings: IoSetDeviceInterfaceState failed: Miniport %p, Status %lx\n", Miniport, NtStatus));
Status = NDIS_STATUS_FAILURE;
}
}
else
{
Status = ndisQueueBindWorkitem(Miniport);
}
}
else
{
//
// ndisPnPStartDevice can return an internal Error Code if the call
// to ndisMInitializeAdapter fails. convert this to NDIS_STATUS
//
Status = NDIS_STATUS_FAILURE;
}
DBGPRINT_RAW(DBG_COMP_INIT, DBG_LEVEL_INFO,
("<==ndisIMInitializeDeviceInstance: Miniport %p, Context %p, Status %lx\n", Miniport, DeviceContext, Status));
return Status;
}
NDIS_STATUS
ndisIMQueueDeviceInstance(
IN PNDIS_M_DRIVER_BLOCK MiniBlock,
IN PNDIS_STRING DeviceInstance,
IN NDIS_HANDLE DeviceContext
)
{
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
PNDIS_PENDING_IM_INSTANCE NewImInstance, pTemp;
KIRQL OldIrql;
DBGPRINT_RAW(DBG_COMP_INIT, DBG_LEVEL_INFO,
("==>ndisIMQueueDeviceInstance: Driver %p, Instance %p, Context %p\n",
MiniBlock, DeviceInstance, DeviceContext));
do
{
//
// Queue the device name for which we have received an InitializeDeviceInstance
// from an IM driver. Check for duplicates.
//
NewImInstance = (PNDIS_PENDING_IM_INSTANCE)ALLOC_FROM_POOL(sizeof(NDIS_PENDING_IM_INSTANCE) +
DeviceInstance->Length +
sizeof(WCHAR),
NDIS_TAG_IM_DEVICE_INSTANCE);
if (NULL == NewImInstance)
{
Status = NDIS_STATUS_RESOURCES;
break;
}
NewImInstance->Context = DeviceContext;
NewImInstance->Name.MaximumLength = DeviceInstance->Length + sizeof(WCHAR);
NewImInstance->Name.Length = 0;
NewImInstance->Name.Buffer = (PWSTR)((PUCHAR)NewImInstance + sizeof(NDIS_PENDING_IM_INSTANCE));
RtlUpcaseUnicodeString(&NewImInstance->Name,
DeviceInstance,
FALSE);
ACQUIRE_SPIN_LOCK(&MiniBlock->Ref.SpinLock, &OldIrql);
for (pTemp = MiniBlock->PendingDeviceList;
pTemp != NULL;
pTemp = pTemp->Next)
{
if (NDIS_EQUAL_UNICODE_STRING(&NewImInstance->Name,
&pTemp->Name))
{
FREE_POOL(NewImInstance);
Status = NDIS_STATUS_NOT_ACCEPTED;
break;
}
}
if (Status == NDIS_STATUS_SUCCESS)
{
NewImInstance->Next = MiniBlock->PendingDeviceList;
MiniBlock->PendingDeviceList = NewImInstance;
}
RELEASE_SPIN_LOCK(&MiniBlock->Ref.SpinLock, OldIrql);
} while (FALSE);
DBGPRINT_RAW(DBG_COMP_INIT, DBG_LEVEL_INFO,
("<==ndisIMQueueDeviceInstance: Driver %p, Instance %p, Context %p, Status %lx\n",
MiniBlock, DeviceInstance, DeviceContext, Status));
return Status;
}
BOOLEAN
ndisIMCheckDeviceInstance(
IN PNDIS_M_DRIVER_BLOCK MiniBlock,
IN PUNICODE_STRING DeviceInstanceName,
OUT PNDIS_HANDLE DeviceContext OPTIONAL
)
{
PNDIS_PENDING_IM_INSTANCE pDI, *ppDI;
PNDIS_PROTOCOL_BLOCK Protocol = MiniBlock->AssociatedProtocol;
KIRQL OldIrql;
BOOLEAN rc = FALSE;
DBGPRINT_RAW(DBG_COMP_INIT, DBG_LEVEL_INFO,
("==>ndisIMCheckDeviceInstance: Driver %p, DeviceInstanceName %p\n",
MiniBlock, DeviceInstanceName));
PnPReferencePackage();
ACQUIRE_SPIN_LOCK(&MiniBlock->Ref.SpinLock, &OldIrql);
for (ppDI = &MiniBlock->PendingDeviceList;
(pDI = *ppDI) != NULL;
ppDI = &pDI->Next)
{
if (NDIS_EQUAL_UNICODE_STRING(&pDI->Name,
DeviceInstanceName))
{
if (ARGUMENT_PRESENT(DeviceContext))
{
*DeviceContext = pDI->Context;
}
*ppDI = pDI->Next;
FREE_POOL(pDI);
rc = TRUE;
break;
}
}
RELEASE_SPIN_LOCK(&MiniBlock->Ref.SpinLock, OldIrql);
PnPDereferencePackage();
DBGPRINT_RAW(DBG_COMP_INIT, DBG_LEVEL_INFO,
("<==ndisIMCheckDeviceInstance: Driver %p, Name %p, Context %p\n",
MiniBlock, DeviceInstanceName, DeviceContext));
if (!rc && ARGUMENT_PRESENT(DeviceContext))
{
//
// Send a reconfig notification to the protocol associated with this IM
// so it can re-initialize any device(s) it wants to
//
if (((Protocol = MiniBlock->AssociatedProtocol) != NULL) &&
(Protocol->ProtocolCharacteristics.PnPEventHandler != NULL))
{
//
// We got a start device for an IM. Make sure its protocol
// half has all the requisite bindings. This can happen
// if an IM is disconnected and reconnected, for example.
// Also give it a NULL reconfig event. ATMLANE uses that
//
NET_PNP_EVENT NetPnpEvent;
KEVENT Event;
NDIS_STATUS Status;
NdisZeroMemory(&NetPnpEvent, sizeof(NetPnpEvent));
INITIALIZE_EVENT(&Event);
NetPnpEvent.NetEvent = NetEventReconfigure;
PNDIS_PNP_EVENT_RESERVED_FROM_NET_PNP_EVENT(&NetPnpEvent)->pEvent = &Event;
WAIT_FOR_PROTO_MUTEX(Protocol);
Status = (Protocol->ProtocolCharacteristics.PnPEventHandler)(NULL, &NetPnpEvent);
if (NDIS_STATUS_PENDING == Status)
{
//
// Wait for completion.
//
WAIT_FOR_PROTOCOL(Protocol, &Event);
}
RELEASE_PROT_MUTEX(Protocol);
}
}
return rc;
}
NDIS_STATUS
NdisIMCancelInitializeDeviceInstance(
IN NDIS_HANDLE DriverHandle,
IN PNDIS_STRING DeviceInstance
)
{
NDIS_STATUS Status;
UNICODE_STRING UpcaseDevice;
DBGPRINT_RAW(DBG_COMP_INIT, DBG_LEVEL_INFO,
("==>NdisIMCancelInitializeDeviceInstance: Driver %p, DeviceInstance %p\n", DriverHandle, DeviceInstance));
//
// change to upper case
//
UpcaseDevice.Length = DeviceInstance->Length;
UpcaseDevice.MaximumLength = DeviceInstance->Length + sizeof(WCHAR);
UpcaseDevice.Buffer = ALLOC_FROM_POOL(UpcaseDevice.MaximumLength, NDIS_TAG_STRING);
if (UpcaseDevice.Buffer == NULL)
{
return NDIS_STATUS_RESOURCES;
}
Status = RtlUpcaseUnicodeString(&UpcaseDevice, (PUNICODE_STRING)DeviceInstance, FALSE);
ASSERT (NT_SUCCESS(Status));
Status = (ndisIMCheckDeviceInstance((PNDIS_M_DRIVER_BLOCK)DriverHandle,
&UpcaseDevice,
NULL) == TRUE) ? NDIS_STATUS_SUCCESS : NDIS_STATUS_FAILURE;
DBGPRINT_RAW(DBG_COMP_INIT, DBG_LEVEL_INFO,
("<==NdisIMCancelInitializeDeviceInstance: Driver %p, DeviceInstance %p, Status %lx\n",
DriverHandle, DeviceInstance, Status));
FREE_POOL(UpcaseDevice.Buffer);
return Status;
}
NDIS_HANDLE
NdisIMGetDeviceContext(
IN NDIS_HANDLE MiniportAdapterHandle
)
{
PNDIS_MINIPORT_BLOCK Miniport = (PNDIS_MINIPORT_BLOCK)MiniportAdapterHandle;
DBGPRINT_RAW(DBG_COMP_INIT, DBG_LEVEL_INFO,
("==>NdisIMGetDeviceContext: Miniport %p\n", Miniport));
DBGPRINT_RAW(DBG_COMP_INIT, DBG_LEVEL_INFO,
("<==NdisIMGetDeviceContext: Miniport %p\n", Miniport));
return(Miniport->DeviceContext);
}
NDIS_HANDLE
NdisIMGetBindingContext(
IN NDIS_HANDLE ProtocolBindingContext
)
{
PNDIS_OPEN_BLOCK Open = (PNDIS_OPEN_BLOCK)ProtocolBindingContext;
PNDIS_MINIPORT_BLOCK Miniport = Open->MiniportHandle;
DBGPRINT_RAW(DBG_COMP_INIT, DBG_LEVEL_INFO,
("==>NdisIMGetBindingContext: Open %p\n", Open));
DBGPRINT_RAW(DBG_COMP_INIT, DBG_LEVEL_INFO,
("<==NdisIMGetBindingContext: Open %p\n", Open));
return(Miniport->DeviceContext);
}
Reference in a new issue Copy permalink