windows-xp/Source/XPSP1/NT/net/ndis/sys/initpnp.c

/*++

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);
}