windows-server-2003/drivers/storage/sbp2port/sbp2port.c

/*++


Copyright (C) Microsoft Corporation, 1997 - 2001

Module Name:

    sbp2port.c

Abstract:

    Main module for the SBP-2 port driver

    Author:

    George Chrysanthakopoulos January-1997

Environment:

    Kernel mode

Revision History :

--*/

#include "sbp2port.h"
#include "stdarg.h"
#include "stdio.h"
#include "stdlib.h"
#include "string.h"


#if DBG
ULONG Sbp2DebugLevel = 0;

ULONG NewSbp2DebugLevel = DEFAULT_DEBUG_LEVEL;
ULONG Sbp2TrapLevel = FALSE;
#endif

BOOLEAN SystemIsNT;


NTSTATUS
DriverEntry(
    IN  PDRIVER_OBJECT  DriverObject,
    IN  PUNICODE_STRING RegistryPath
    );

NTSTATUS
Sbp2AddDevice(
    PDRIVER_OBJECT  DriverObject,
    PDEVICE_OBJECT  Pdo
    );

NTSTATUS
Sbp2StartDevice(
    IN PDEVICE_OBJECT DeviceObject
);

NTSTATUS
Sbp2CreateDeviceRelations(
    IN PFDO_DEVICE_EXTENSION FdoExtension,
    IN PDEVICE_RELATIONS DeviceRelations
    );

NTSTATUS
Sbp2CreateDevObject(
    IN PDRIVER_OBJECT           DriverObject,
    IN PDEVICE_OBJECT           Pdo
    );

NTSTATUS
Sbp2DeviceControl(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    );

NTSTATUS
Sbp2CreateClose(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    );

NTSTATUS
Sbp2PnpDeviceControl(
    PDEVICE_OBJECT DeviceObject,
    PIRP Irp
    );

NTSTATUS
Sbp2FDOPnpDeviceControl(
    PDEVICE_OBJECT DeviceObject,
    PIRP Irp
    );

NTSTATUS
Sbp2CreatePdo(
    IN PFDO_DEVICE_EXTENSION FdoExtension,
    IN PDEVICE_INFORMATION DeviceInfo,
    ULONG instanceNum
    );

NTSTATUS
Sbp2PowerControl(
    PDEVICE_OBJECT DeviceObject,
    PIRP Irp
    );

NTSTATUS
Sbp2SystemControl(
    PDEVICE_OBJECT DeviceObject,
    PIRP Irp
    );

NTSTATUS
Sbp2FdoRequestCompletionRoutine(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PKEVENT Event
    );


VOID
Sbp2Unload(
    IN PDRIVER_OBJECT DriverObject
    );

NTSTATUS
Sbp2_BuildDeviceId(
    IN PDEVICE_INFORMATION  DeviceInfo,
    IN OUT PUNICODE_STRING  uniDeviceId
    );

NTSTATUS
Sbp2_BuildHardwareIds(
    IN PDEVICE_INFORMATION  DeviceInfo,
    IN OUT PUNICODE_STRING  uniHardwareIds
    );

NTSTATUS
Sbp2_BuildCompatIds(
    IN PDEVICE_INFORMATION  DeviceInfo,
    IN OUT PUNICODE_STRING  uniCompatIds
    );

NTSTATUS
Sbp2_BuildInstanceId(
    IN PDEVICE_INFORMATION  DeviceInfo,
    IN OUT PUNICODE_STRING  uniInstanceId
    );

NTSTATUS
Sbp2_BuildDeviceText(
    IN DEVICE_TEXT_TYPE     TextType,
    IN PDEVICE_INFORMATION  DeviceInfo,
    IN OUT PUNICODE_STRING  uniDeviceText
    );

NTSTATUS
Sbp2ForwardIrpSynchronous(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp
    );

NTSTATUS
Sbp2PortForwardIrpSynchronousCompletionRoutine(
    IN PDEVICE_OBJECT       DeviceObject,
    IN PIRP                 Irp,
    IN PVOID                Context
    );

#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, DriverEntry)
#pragma alloc_text(PAGE, Sbp2AddDevice)
#pragma alloc_text(PAGE, Sbp2StartDevice)
#pragma alloc_text(PAGE, Sbp2CreateDeviceRelations)
#pragma alloc_text(PAGE, Sbp2CreatePdo)
#pragma alloc_text(PAGE, Sbp2CreateDevObject)
#pragma alloc_text(PAGE, Sbp2DeviceControl)
#pragma alloc_text(PAGE, Sbp2SystemControl)
#pragma alloc_text(PAGE, Sbp2CreateClose)
#pragma alloc_text(PAGE, Sbp2ForwardIrpSynchronous)

#endif


NTSTATUS
DriverEntry(
    IN  PDRIVER_OBJECT  DriverObject,
    IN  PUNICODE_STRING RegistryPath
    )
/*++

Routine Description:

    This routine is called at system initialization time so we can fill in the basic dispatch points

Arguments:

    DriverObject    - Supplies the driver object.

    RegistryPath    - Supplies the registry path for this driver.

Return Value:

    STATUS_SUCCESS

--*/

{
    //
    // Initialize the Driver Object with driver's entry points
    //

    DEBUGPRINT2(("Sbp2Port: DriverEntry: %s %s\n", __DATE__, __TIME__));

    DriverObject->MajorFunction[IRP_MJ_CREATE] = Sbp2CreateClose;
    DriverObject->MajorFunction[IRP_MJ_CLOSE] = Sbp2CreateClose;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = Sbp2DeviceControl;

    DriverObject->MajorFunction[IRP_MJ_SCSI] = Sbp2ScsiRequests;

    DriverObject->DriverExtension->AddDevice = Sbp2AddDevice;
    DriverObject->MajorFunction[IRP_MJ_PNP] = Sbp2PnpDeviceControl;
    DriverObject->MajorFunction[IRP_MJ_PNP_POWER] = Sbp2PnpDeviceControl;
    DriverObject->MajorFunction[IRP_MJ_POWER] = Sbp2PowerControl;

    DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = Sbp2SystemControl;

    DriverObject->DriverStartIo = Sbp2StartIo;
    DriverObject->DriverUnload = Sbp2Unload;

    SystemIsNT = IoIsWdmVersionAvailable ((UCHAR)0x01, (UCHAR)0x10);

    return STATUS_SUCCESS;
}


NTSTATUS
Sbp2AddDevice(
    PDRIVER_OBJECT  DriverObject,
    PDEVICE_OBJECT  Pdo
    )

/*++

Routine Description:

    This is our PNP AddDevice called with the PDO ejected from the bus driver

Arguments:

    Argument1          - Driver Object.
    Argument2          - PDO.


Return Value:

    A valid return code for a DriverEntry routine.

--*/

{
    return (Sbp2CreateDevObject (DriverObject,Pdo));
}


NTSTATUS
Sbp2CreateDevObject(
    IN PDRIVER_OBJECT           DriverObject,
    IN PDEVICE_OBJECT           Pdo
    )
/*++

Routine Description:

    This routine creates an object for the physical device specified and
    sets up the deviceExtension.

Arguments:

    DriverObject - Pointer to driver object created by system.

    PhysicalDeviceObject = PDO we should attach to.


Return Value:

    NTSTATUS

--*/
{
    PFDO_DEVICE_EXTENSION deviceExtension;
    NTSTATUS       status;
    PDEVICE_OBJECT deviceObject = NULL;

    UNICODE_STRING uniDeviceName;

    WCHAR buffer[64];
    UNICODE_STRING unicodeDirectoryName;
    HANDLE handle;
    OBJECT_ATTRIBUTES objectAttributes;

    ULONG NextId = 0;

    //
    // This is the sbp2 filter device object and name
    //

    do {

        swprintf (buffer, L"\\Device\\Sbp2Port%x", NextId);

        RtlInitUnicodeString (&uniDeviceName, buffer);

        status = IoCreateDevice(DriverObject,
                                sizeof(FDO_DEVICE_EXTENSION),
                                &uniDeviceName,
                                FILE_DEVICE_BUS_EXTENDER,
                                FILE_DEVICE_SECURE_OPEN,
                                FALSE,
                                &deviceObject);

        NextId++;

    } while (status == STATUS_OBJECT_NAME_COLLISION);

    if (!NT_SUCCESS(status)) {

        return status;
    }


    deviceExtension = deviceObject->DeviceExtension;
    RtlZeroMemory(deviceExtension,sizeof(FDO_DEVICE_EXTENSION));

    if (Pdo != NULL) {

        if ((deviceExtension->LowerDeviceObject =
            IoAttachDeviceToDeviceStack(deviceObject,Pdo))==NULL){

            IoDeleteDevice(deviceObject);
            return status;
        }
    }

    deviceExtension->Type = SBP2_FDO;
    deviceExtension->DeviceFlags = 0;
    deviceExtension->DeviceObject = deviceObject;
    deviceExtension->Pdo = Pdo;
    KeInitializeSpinLock(&deviceExtension->DeviceListLock);
    KeInitializeMutex (&deviceExtension->EnableBusResetNotificationMutex, 0);

    //
    // create a directory object for Sbp2 children devices
    //

    swprintf(buffer, L"\\Device\\Sbp2");

    RtlInitUnicodeString(&unicodeDirectoryName, buffer);

    InitializeObjectAttributes(&objectAttributes,
                               &unicodeDirectoryName,
                               OBJ_CASE_INSENSITIVE | OBJ_PERMANENT | OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);

    status = ZwCreateDirectoryObject(&handle,
                                     DIRECTORY_ALL_ACCESS,
                                     &objectAttributes);


    if (NT_SUCCESS(status)) {

        deviceExtension->Sbp2ObjectDirectory = handle;

    } else {

        //
        // the directory is already created by another instance of this driver..
        //

        status = STATUS_SUCCESS;
    }

    ExInitializeFastMutex(&deviceExtension->ResetMutex);

    IoInitializeRemoveLock( &deviceExtension->RemoveLock,
                            '2pbS',
                            REMLOCK_TIMEOUT,
                            REMLOCK_HIGH_WATERMARK
                            );

#if DBG
    deviceExtension->ulWorkItemCount = 0;
    deviceExtension->ulBusResetMutexCount = 0;
#endif

    deviceObject->Flags |= DO_DIRECT_IO;
    deviceObject->Flags &=~DO_DEVICE_INITIALIZING;

    return status;
}


NTSTATUS
Sbp2CreatePdo(
    IN PFDO_DEVICE_EXTENSION FdoExtension,
    IN PDEVICE_INFORMATION DeviceInfo,
    ULONG InstanceNumber
    )
{
    PDEVICE_EXTENSION pdoExtension;
    DEVICE_TYPE devType;
    WCHAR *buffer;
    UNICODE_STRING uniDeviceName;
    NTSTATUS status;
    ULONG byteSwappedData;

    PAGED_CODE();

    switch (DeviceInfo->CmdSetId.QuadPart) {

    case 0x10483:
    case SCSI_COMMAND_SET_ID:

       switch ((DeviceInfo->Lun.u.HighPart & 0x001F)) {

       case PRINTER_DEVICE:

           devType = FILE_DEVICE_PRINTER;
           break;

       case SCANNER_DEVICE:

           devType = FILE_DEVICE_SCANNER;
           break;

       case READ_ONLY_DIRECT_ACCESS_DEVICE:
       case RBC_DEVICE:
       case DIRECT_ACCESS_DEVICE:
       default:

           devType = FILE_DEVICE_MASS_STORAGE;
           break;
       }

       break;

    default:

        devType = FILE_DEVICE_UNKNOWN;
        break;
    }

    buffer = ExAllocatePool(PagedPool,
                            5 * SBP2_MAX_TEXT_LEAF_LENGTH * sizeof (WCHAR)
                            );

    if (buffer == NULL) {

        return STATUS_INSUFFICIENT_RESOURCES;
    }

    if (DeviceInfo->uniVendorId.Buffer && DeviceInfo->uniModelId.Buffer) {

        swprintf( buffer,
                  L"\\Device\\Sbp2\\%ws&%ws&%x&%08x_%08x_Instance%02d",
                  DeviceInfo->uniVendorId.Buffer,
                  DeviceInfo->uniModelId.Buffer,
                  DeviceInfo->Lun.u.LowPart,
                  bswap(FdoExtension->ConfigRom.CR_Node_UniqueID[0]),
                  bswap(FdoExtension->ConfigRom.CR_Node_UniqueID[1]),
                  InstanceNumber
                  );
    }
    else {

        swprintf( buffer,
                  L"\\Device\\Sbp2\\UNKNOWN_VENDOR&UNKNOWN_MODEL&%x&%08x_%08x_Instance%02d",
                  DeviceInfo->Lun.u.LowPart,
                  bswap(FdoExtension->ConfigRom.CR_Node_UniqueID[0]),
                  bswap(FdoExtension->ConfigRom.CR_Node_UniqueID[1]),
                  InstanceNumber
                  );
    }

    RtlInitUnicodeString (&uniDeviceName, buffer);

    //
    // Need to create a device object for this device
    //

    status = IoCreateDevice(
                FdoExtension->DeviceObject->DriverObject,
                sizeof(DEVICE_EXTENSION),
                &uniDeviceName,
                devType,
                0,
                FALSE,
                &DeviceInfo->DeviceObject
                );

    if (!NT_SUCCESS(status)) {

        ExFreePool (buffer);
        return status;
    }

    // only set alignment if it's less than we require
    if (DeviceInfo->DeviceObject->AlignmentRequirement < SBP2_ALIGNMENT_MASK)
        DeviceInfo->DeviceObject->AlignmentRequirement = SBP2_ALIGNMENT_MASK;

    pdoExtension = (PDEVICE_EXTENSION)DeviceInfo->DeviceObject->DeviceExtension;

    RtlZeroMemory(pdoExtension,sizeof(DEVICE_EXTENSION));

    pdoExtension->LowerDeviceObject = FdoExtension->LowerDeviceObject;
    pdoExtension->DeviceObject = DeviceInfo->DeviceObject;
    pdoExtension->Type = SBP2_PDO;
    pdoExtension->DeviceInfo = DeviceInfo;
    pdoExtension->DeviceInfo->MaxClassTransferSize = FdoExtension->MaxClassTransferSize;
    pdoExtension->BusFdo = FdoExtension->DeviceObject;

#if DBG
    pdoExtension->ulPendingEvents = 0;
    pdoExtension->ulInternalEventCount = 0;
#endif

    KeInitializeSpinLock (&pdoExtension->ExtensionDataSpinLock);

    IoInitializeRemoveLock(
        &pdoExtension->RemoveLock,
        '2pbS',
        REMLOCK_TIMEOUT,
        REMLOCK_HIGH_WATERMARK
        );

    switch (DeviceInfo->CmdSetId.QuadPart) {

    case 0x10483:
    case SCSI_COMMAND_SET_ID:

        //
        // intepret device type only for scsi-variant command sets
        //
        // NOTE: sbp2port.h #define's MAX_GENERIC_NAME_LENGTH as 16
        //

        DeviceInfo->uniGenericName.Length = 0;
        DeviceInfo->uniGenericName.MaximumLength = MAX_GENERIC_NAME_LENGTH;
        DeviceInfo->uniGenericName.Buffer = ExAllocatePool(PagedPool, DeviceInfo->uniGenericName.MaximumLength);

        if (!DeviceInfo->uniGenericName.Buffer) {

            TRACE(TL_PNP_ERROR, ("Failed to allocate uniGenericName.Buffer!"));
            status = STATUS_INSUFFICIENT_RESOURCES;
            break;
        }
        RtlZeroMemory(DeviceInfo->uniGenericName.Buffer, DeviceInfo->uniGenericName.MaximumLength);

        switch ((DeviceInfo->Lun.u.HighPart & 0x001F)) {

        case RBC_DEVICE:
        case DIRECT_ACCESS_DEVICE:

            RtlAppendUnicodeToString(&DeviceInfo->uniGenericName, L"GenDisk");
            break;

        case SEQUENTIAL_ACCESS_DEVICE:

            RtlAppendUnicodeToString(&DeviceInfo->uniGenericName, L"GenSequential");
            break;

        case PRINTER_DEVICE:

            RtlAppendUnicodeToString(&DeviceInfo->uniGenericName, L"GenPrinter");
            break;

        case WRITE_ONCE_READ_MULTIPLE_DEVICE:

            RtlAppendUnicodeToString(&DeviceInfo->uniGenericName, L"GenWorm");
            break;

        case READ_ONLY_DIRECT_ACCESS_DEVICE:

            RtlAppendUnicodeToString(&DeviceInfo->uniGenericName, L"GenCdRom");
            break;

        case SCANNER_DEVICE:

            RtlAppendUnicodeToString(&DeviceInfo->uniGenericName, L"GenScanner");
            break;

        case OPTICAL_DEVICE:

            RtlAppendUnicodeToString(&DeviceInfo->uniGenericName, L"GenOptical");
            break;

        case MEDIUM_CHANGER:

            RtlAppendUnicodeToString(&DeviceInfo->uniGenericName, L"GenChanger");
            break;

        default:

            RtlAppendUnicodeToString(&DeviceInfo->uniGenericName, L"GenSbp2Device");
            break;
        }

        break;

    default:

        RtlAppendUnicodeToString(&DeviceInfo->uniGenericName, L"GenSbp2Device");
        break;
    }

    TRACE(TL_PNP_INFO, ("GenericName = %ws", DeviceInfo->uniGenericName.Buffer));

    DeviceInfo->DeviceObject->Flags |= DO_DIRECT_IO;

    status = Sbp2PreAllocateLists (pdoExtension);

    if (!NT_SUCCESS(status)) {

        IoDeleteDevice (pdoExtension->DeviceObject);
        DeviceInfo->DeviceObject = NULL;

    } else {

        PWCHAR symlinkBuffer;

        symlinkBuffer = ExAllocatePool(PagedPool,
                                3 * SBP2_MAX_TEXT_LEAF_LENGTH * sizeof (WCHAR)
                                );

        if (symlinkBuffer) {

            swprintf(
                symlinkBuffer,
                L"\\DosDevices\\Sbp2&LUN%x&%08x%08x&Instance%02d",
                DeviceInfo->Lun.u.LowPart,
                bswap(FdoExtension->ConfigRom.CR_Node_UniqueID[0]),
                bswap(FdoExtension->ConfigRom.CR_Node_UniqueID[1]),
                InstanceNumber
                );

            RtlInitUnicodeString (&pdoExtension->UniSymLinkName,symlinkBuffer);

            status = IoCreateUnprotectedSymbolicLink(
                &pdoExtension->UniSymLinkName,
                &uniDeviceName
                );

            if (NT_SUCCESS (status)) {

                DEBUGPRINT2((
                    "Sbp2Port: CreatePdo: symLink=%ws\n",
                    symlinkBuffer
                    ));

            } else {

                DEBUGPRINT1((
                    "\nSbp2Port: CreatePdo: createSymLink err=x%x\n",
                    status
                    ));
            }

        } else {

            DEBUGPRINT1(("\n Sbp2CreatePdo: failed to alloc sym link buf\n"));
        }

        //
        // if sym link fails its not critical
        //

        status = STATUS_SUCCESS;
    }

    ExFreePool (buffer);

    DeviceInfo->DeviceObject->Flags &=~DO_DEVICE_INITIALIZING;
    return status;
}


NTSTATUS
Sbp2StartDevice(
    IN PDEVICE_OBJECT DeviceObject
    )
/*++

Routine Description:

    This is our START_DEVICE, called when we get an IPR_MN_START_DEVICE. Initializes the driver and
    retrieves physical device information and 1394 bus information required for accessing the device.

Arguments:

    DeviceObject = Sbp2 driver's device object

Return Value:

    NTSTATUS

--*/
{
    PDEVICE_EXTENSION   deviceExtension=DeviceObject->DeviceExtension;
    PFDO_DEVICE_EXTENSION   fdoExtension = DeviceObject->DeviceExtension;
    NTSTATUS status;
    ULONG temp;
    BOOLEAN enabledBusResetNotification = FALSE;

    if (deviceExtension->Type == SBP2_PDO) {

#if PASSWORD_SUPPORT

        Sbp2GetExclusiveValue(DeviceObject, &deviceExtension->Exclusive);

#endif

        if (!TEST_FLAG(deviceExtension->DeviceFlags,DEVICE_FLAG_INITIALIZED)){

            //
            // initialize our device state flags
            //

            deviceExtension->DevicePowerState = PowerDeviceD0;
            deviceExtension->SystemPowerState = PowerSystemWorking;

            deviceExtension->MaxOrbListDepth = MAX_ORB_LIST_DEPTH;
        }

        deviceExtension->DeviceFlags = DEVICE_FLAG_PNP_STOPPED |
            DEVICE_FLAG_STOPPED | DEVICE_FLAG_INITIALIZING;

        //
        // Initiliaze the Timer and timeout DPC used for resets, reconnects and TASK functions
        //

        KeInitializeDpc(
            &deviceExtension->DeviceManagementTimeoutDpc,
            Sbp2DeviceManagementTimeoutDpc,
            deviceExtension
            );

        KeInitializeTimer(&deviceExtension->DeviceManagementTimer);

        KeInitializeSpinLock(&deviceExtension->OrbListSpinLock);
        KeInitializeSpinLock(&deviceExtension->ExtensionDataSpinLock);

        KeInitializeSpinLock(&deviceExtension->StatusFifoLock);
        KeInitializeSpinLock(&deviceExtension->FreeContextLock);
        KeInitializeSpinLock(&deviceExtension->BusRequestLock);

        ASSERT(!deviceExtension->ulPendingEvents);
        ASSERT(!deviceExtension->ulInternalEventCount);

#if DBG
        deviceExtension->ulPendingEvents = 0;
        deviceExtension->ulInternalEventCount = 0;
#endif

        //
        // Initialize our device Extension ORB's, status blocks, Irp and Irb's
        // Also allocate 1394 addresses for extension-held sbp2 ORB's
        //

        status = Sbp2InitializeDeviceExtension(deviceExtension);

        if (!NT_SUCCESS(status)) {

            goto exitStartDevice;
        }

        DEBUGPRINT2(("\nSbp2Port: StartDev: cmd set id=x%x\n", deviceExtension->DeviceInfo->CmdSetId.QuadPart));

        switch (deviceExtension->DeviceInfo->CmdSetId.QuadPart) {

        case 0x0:
        case 0x10483:
        case SCSI_COMMAND_SET_ID:

            SET_FLAG(deviceExtension->DeviceFlags, DEVICE_FLAG_SPC_CMD_SET);

            DEBUGPRINT2(("Sbp2Port: StartDev: enabling SPC cmd set\n"));

            break;
        }

        //
        // login
        //

        status = Sbp2ManagementTransaction(deviceExtension,TRANSACTION_LOGIN);

        if (!NT_SUCCESS(status)) {

            DEBUGPRINT1(("\nSbp2StartDev: Login failed with %x, retrying\n",status));

            if (status == STATUS_ACCESS_DENIED) {

                //
                // retry the login. By now we should have access since our bus reset forced a logout
                //

                Sbp2ManagementTransaction(deviceExtension,TRANSACTION_QUERY_LOGINS);
            }

            temp = 0;

            do {

                //
                // Give things time (one second) to settle...
                //

                LARGE_INTEGER waitValue;

                ASSERT(InterlockedIncrement(&deviceExtension->ulPendingEvents) == 1);

                KeInitializeEvent(&deviceExtension->ManagementEvent, NotificationEvent, FALSE);

                waitValue.QuadPart = -1 * 1000 * 1000 * 10;

                KeWaitForSingleObject(&deviceExtension->ManagementEvent,Executive,KernelMode,FALSE,&waitValue);

                ASSERT(InterlockedDecrement(&deviceExtension->ulPendingEvents) == 0);

                //
                // all the resident 1394 memory addresses's that we have, are
                // now invalidated... So we need to free them and re-allocate
                // them

                Sbp2CleanDeviceExtension (deviceExtension->DeviceObject,FALSE);

                Sbp2InitializeDeviceExtension(deviceExtension);

                status = Sbp2ManagementTransaction(deviceExtension,TRANSACTION_LOGIN);

                temp ++;

                //
                // Note: We get STATUS_REQUEST_ABORTED rather than
                //       STATUS_INVALID_GENERATION at passive level,
                //       so check for that instead
                //

            } while ((status == STATUS_REQUEST_ABORTED) &&
                     (temp <= 3));

            if (!NT_SUCCESS(status)) {

                goto exitStartDevice;
            }
        }

#if PASSWORD_SUPPORT

        if (deviceExtension->Exclusive & EXCLUSIVE_FLAG_ENABLE) {

            status = Sbp2SetPasswordTransaction(
                deviceExtension,
                SBP2REQ_SET_PASSWORD_EXCLUSIVE
                );

            if (NT_SUCCESS(status)) {

                deviceExtension->Exclusive = EXCLUSIVE_FLAG_SET;

            } else {

                deviceExtension->Exclusive = EXCLUSIVE_FLAG_CLEAR;
            }

            Sbp2SetExclusiveValue(
                deviceExtension->DeviceObject,
                &deviceExtension->Exclusive
                );
        }

#endif

        //
        // We are ready to receive and pass down requests, init the target's
        // fetch agent. The value we write to it is not important
        //

        Sbp2AccessRegister(deviceExtension,&deviceExtension->Reserved,AGENT_RESET_REG | REG_WRITE_SYNC);

        //
        // enable unsolicited status reg
        //

        Sbp2AccessRegister(deviceExtension,&deviceExtension->Reserved,UNSOLICITED_STATUS_REG | REG_WRITE_SYNC);

        CLEAR_FLAG(
            deviceExtension->DeviceFlags,
            (DEVICE_FLAG_PNP_STOPPED | DEVICE_FLAG_STOPPED)
            );

        //
        // register for idle detection
        //

        deviceExtension->IdleCounter = PoRegisterDeviceForIdleDetection(DeviceObject,
                                                                        -1,
                                                                        -1,
                                                                        PowerDeviceD3);

        CLEAR_FLAG(deviceExtension->DeviceFlags,DEVICE_FLAG_INITIALIZING );
        SET_FLAG(deviceExtension->DeviceFlags,DEVICE_FLAG_INITIALIZED);

        //
        // OK to register for bus reset notifications now
        //

        if (!Sbp2EnableBusResetNotification (deviceExtension, TRUE)) {

            SET_FLAG (deviceExtension->DeviceFlags, DEVICE_FLAG_STOPPED);
            CleanupOrbList (deviceExtension, STATUS_REQUEST_ABORTED);
            Sbp2ManagementTransaction (deviceExtension, TRANSACTION_LOGOUT);
            status = STATUS_INSUFFICIENT_RESOURCES;
            goto exitStartDevice;
        }

        enabledBusResetNotification = TRUE;


        if (TEST_FLAG(deviceExtension->DeviceFlags, DEVICE_FLAG_SPC_CMD_SET)) {

            //
            // issue an Inquiry to the target...
            //

            status = Sbp2IssueInternalCommand (deviceExtension,SCSIOP_INQUIRY);

            if (NT_SUCCESS(status)) {

                DEBUGPRINT2((
                    "Sbp2Port: StartDev: cfgRom devType=x%x, inq devType=x%x\n",
                    (deviceExtension->DeviceInfo->Lun.u.HighPart & 0x001F),
                    deviceExtension->InquiryData.DeviceType
                    ));

            } else if ((status == STATUS_DEVICE_DOES_NOT_EXIST) ||
                       (status == STATUS_DEVICE_BUSY)) {

                //
                // In win2k if the inquiry failed we'd just turn off the
                // SPC_CMD_SET flag and trundle on like nothing happened.
                //
                // However, we found some devices would allow logins but
                // nothing else, like a powered-down mactell hd which would
                // allow us to login but fail all other requests.  This
                // really caused problems in win9x because Ntmap would
                // get loaded, but not init'd correctly, and on subsequent
                // re-plugs of any device we'd see trap 14's and the like.
                // So, it really makes alot more sense to just nip this
                // in the bud and fail the start if we get an error back
                // from the inquiry that tells us (per Sbp2ScsiRequests())
                // that the device has been removed or it timed out the 1st
                // inquiry .  DanKn, 7 Apr 2000
                //

                DEBUGPRINT1((
                    "\nSbp2Port: StartDev: ext=x%p, fatal INQUIRY err=x%x, " \
                        "log out\n",
                    deviceExtension,
                    status
                    ));

                Sbp2ManagementTransaction(deviceExtension,TRANSACTION_LOGOUT);
                status = STATUS_IO_DEVICE_ERROR;
                goto exitStartDevice;

            } else {

                CLEAR_FLAG(
                    deviceExtension->DeviceFlags,
                    DEVICE_FLAG_SPC_CMD_SET
                    );

                DEBUGPRINT1((
                    "\nSbp2Port: StartDev: ext=x%p, non-fatal INQUIRY err=x%x\n",
                    deviceExtension,
                    status
                    ));

                status = STATUS_SUCCESS;
            }
        }

        if (deviceExtension->InquiryData.DeviceType != (deviceExtension->DeviceInfo->Lun.u.HighPart & 0x001F)){

            deviceExtension->InquiryData.DeviceType = (deviceExtension->DeviceInfo->Lun.u.HighPart & 0x001F);
            DEBUGPRINT1(("\nSbp2StartDev: DeviceType mismatch, using one in ConfigRom %x\n",
                           (deviceExtension->DeviceInfo->Lun.u.HighPart & 0x001F)));
        }

        //
        // if this is a scanner or a printer we dont need to remain logged on..
        //

        if ((deviceExtension->InquiryData.DeviceType == PRINTER_DEVICE) ||
            (deviceExtension->InquiryData.DeviceType == SCANNER_DEVICE)){

            if (NT_SUCCESS(status)) {

                SET_FLAG(deviceExtension->DeviceFlags, DEVICE_FLAG_STOPPED);
                CleanupOrbList(deviceExtension,STATUS_REQUEST_ABORTED);

                Sbp2ManagementTransaction(deviceExtension,TRANSACTION_LOGOUT);
            }

        } else if (deviceExtension->InquiryData.DeviceType == RBC_DEVICE) {

            if (NT_SUCCESS(status)) {

                //
                // retrieve the RBC device mode page
                //

                status = Sbp2IssueInternalCommand(deviceExtension,SCSIOP_MODE_SENSE);

                if (!NT_SUCCESS(status)) {

                    DEBUGPRINT1(("\nSbp2StartDev: Failed to retrieve RBC mode page\n"));
                    goto exitStartDevice;

                }
            }
        }

exitStartDevice:

        if (!NT_SUCCESS(status)) {

            PIO_ERROR_LOG_PACKET errorLogEntry;
            ULONG errorId = __LINE__ ;


            errorLogEntry = (PIO_ERROR_LOG_PACKET) IoAllocateErrorLogEntry(DeviceObject,sizeof(IO_ERROR_LOG_PACKET));

            if(errorLogEntry != NULL) {

                errorLogEntry->ErrorCode = IO_ERR_DRIVER_ERROR;
                errorLogEntry->UniqueErrorValue = errorId;
                errorLogEntry->FinalStatus = status;
                errorLogEntry->DumpDataSize = 0;
                IoWriteErrorLogEntry(errorLogEntry);
            }

            DEBUGPRINT1((
                "Sbp2Port: StartDev: FAILED, status=x%x\n",
                status
                ));

            SET_FLAG(
                deviceExtension->DeviceFlags,
                (DEVICE_FLAG_PNP_STOPPED | DEVICE_FLAG_DEVICE_FAILED)
                );

            if (enabledBusResetNotification) {

                Sbp2EnableBusResetNotification (deviceExtension, FALSE);
            }

        } else {

            if (!SystemIsNT) {

                DeviceObject->Flags |= DO_POWER_PAGABLE;

            } else {

                DeviceObject->Flags &= ~DO_POWER_PAGABLE;
            }
        }

    } else if (deviceExtension->Type == SBP2_FDO){

        //
        // Bus driver FDO start device
        // retrieve parameters from the registry, if present
        //

        fdoExtension->MaxClassTransferSize = SBP2_MAX_TRANSFER_SIZE;
        DEBUGPRINT2(("Sbp2Port: StartDev: maxXferSize=x%x\n", fdoExtension->MaxClassTransferSize ));

        fdoExtension->DevicePowerState = PowerDeviceD0;
        fdoExtension->SystemPowerState = PowerSystemWorking;

        deviceExtension->DeviceFlags=DEVICE_FLAG_INITIALIZED;
        status = STATUS_SUCCESS;

    } else {

        status = STATUS_NO_SUCH_DEVICE;
    }

    return status;
}


NTSTATUS
Sbp2PreAllocateLists(
    IN PDEVICE_EXTENSION DeviceExtension
    )
/*++

Routine Description:

    Initializes all the single linked workhorse lists plus lookasides. Only called from AddDevice or after
    a REMOVE -> START

Arguments:

    DeviceExtension = Sbp2 driver's extension

Return Value:

    NTSTATUS

--*/
{
    ULONG                   cnt ;
    PIRBIRP                 packet;
    NTSTATUS                status;
    PADDRESS_FIFO           statusFifoElement ;
    PSTATUS_FIFO_BLOCK      statusFifo;
    PASYNC_REQUEST_CONTEXT  context;


    //
    // initialize all interlocked lists
    //

    SET_FLAG(
        DeviceExtension->DeviceFlags,
        (DEVICE_FLAG_INITIALIZING | DEVICE_FLAG_STOPPED |
            DEVICE_FLAG_PNP_STOPPED)
        );

    InitializeListHead(&DeviceExtension->PendingOrbList);

    // BUGBUG: Some of these should be changed to lookaside lists
    ExInitializeSListHead(&DeviceExtension->FreeContextListHead);
    ExInitializeSListHead(&DeviceExtension->BusRequestIrpIrbListHead);
    ExInitializeSListHead(&DeviceExtension->StatusFifoListHead);

    // init bus request context pool
    ExInitializeNPagedLookasideList( &DeviceExtension->BusRequestContextPool,
                                     NULL,
                                     NULL,
                                     0,
                                     sizeof(REQUEST_CONTEXT),
                                     '2pbs',
                                     0
                                     );

    KeInitializeSpinLock(&DeviceExtension->OrbListSpinLock);
    KeInitializeSpinLock(&DeviceExtension->ExtensionDataSpinLock);

    KeInitializeSpinLock(&DeviceExtension->StatusFifoLock);
    KeInitializeSpinLock(&DeviceExtension->FreeContextLock);
    KeInitializeSpinLock(&DeviceExtension->BusRequestLock);


    //
    // alloc the irb/irp and context slists
    //

    for (cnt = 0; cnt < MAX_ORB_LIST_DEPTH; cnt++) {

        packet = ExAllocatePoolWithTag (NonPagedPool,sizeof(IRBIRP),'2pbs');

        if (!packet) {

            goto Sbp2PreAllocateLists_error;
        }

        packet->Irb = ExAllocatePoolWithTag (NonPagedPool,sizeof(IRB),'2pbs');

        if (!packet->Irb) {

            ExFreePool(packet);

            goto Sbp2PreAllocateLists_error;
        }

        packet->Irp = IoAllocateIrp (DeviceExtension->LowerDeviceObject->StackSize,FALSE);

        if (!packet->Irp) {

            ExFreePool(packet->Irb);
            ExFreePool(packet);

            goto Sbp2PreAllocateLists_error;
        }

        ExInterlockedPushEntrySList (&DeviceExtension->BusRequestIrpIrbListHead,
                                     &packet->ListPointer,
                                     &DeviceExtension->BusRequestLock);
    }

    //
    // status FIFO list
    //

    cnt = (sizeof(ADDRESS_FIFO)+sizeof(STATUS_FIFO_BLOCK))*NUM_PREALLOCATED_STATUS_FIFO_ELEMENTS;

    DeviceExtension->StatusFifoBase = \
        (PASYNC_REQUEST_CONTEXT) ExAllocatePoolWithTag(NonPagedPool,cnt,'2pbs');

    if (DeviceExtension->StatusFifoBase == NULL) {

        goto Sbp2PreAllocateLists_error;
    }

    for (cnt = 0; cnt < (NUM_PREALLOCATED_STATUS_FIFO_ELEMENTS - 1); cnt++) {

        statusFifoElement = (PADDRESS_FIFO) ((PUCHAR)DeviceExtension->StatusFifoBase + \
            cnt * (sizeof(ADDRESS_FIFO)+sizeof(STATUS_FIFO_BLOCK)));

        statusFifo = (PSTATUS_FIFO_BLOCK) ((PUCHAR)statusFifoElement + sizeof(ADDRESS_FIFO));

        //
        // make Mdl for this status fifo Element
        //

        statusFifoElement->FifoMdl = IoAllocateMdl(statusFifo,sizeof(STATUS_FIFO_BLOCK),FALSE,FALSE,NULL);

        if (statusFifoElement->FifoMdl == NULL) {

            goto Sbp2PreAllocateLists_error;
        }

        MmBuildMdlForNonPagedPool (statusFifoElement->FifoMdl);

        ExInterlockedPushEntrySList(&DeviceExtension->StatusFifoListHead,
                                    &statusFifoElement->FifoList,
                                    &DeviceExtension->StatusFifoLock);
    }


    //
    // Initialize the async request contexts (including page tables)
    //

    cnt = sizeof (ASYNC_REQUEST_CONTEXT) * MAX_ORB_LIST_DEPTH;

    DeviceExtension->AsyncContextBase = (PASYNC_REQUEST_CONTEXT)
        ExAllocatePoolWithTag (NonPagedPool, cnt, '2pbs');

    if (DeviceExtension->AsyncContextBase == NULL) {

        goto Sbp2PreAllocateLists_error;
    }

    RtlZeroMemory (DeviceExtension->AsyncContextBase, cnt);

    AllocateIrpAndIrb (DeviceExtension, &packet);

    if (!packet) {

        goto Sbp2PreAllocateLists_error;
    }

    for (cnt = 0; cnt < MAX_ORB_LIST_DEPTH; cnt++) {

        context = DeviceExtension->AsyncContextBase + cnt;

        context->Tag = SBP2_ASYNC_CONTEXT_TAG;

        //
        // Initialize the timeout DPC and timer
        //

        KeInitializeDpc(
            &context->TimerDpc,
            Sbp2RequestTimeoutDpc,
            DeviceExtension
            );

        KeInitializeTimer (&context->Timer);


        //
        // Alloc and/or map a page table
        //

        packet->Irb->FunctionNumber = REQUEST_ALLOCATE_ADDRESS_RANGE;

        packet->Irb->u.AllocateAddressRange.nLength = PAGE_SIZE;
        packet->Irb->u.AllocateAddressRange.fulNotificationOptions =
            NOTIFY_FLAGS_NEVER;
        packet->Irb->u.AllocateAddressRange.fulAccessType =
            ACCESS_FLAGS_TYPE_READ;

        packet->Irb->u.AllocateAddressRange.fulFlags =
            ALLOCATE_ADDRESS_FLAGS_USE_COMMON_BUFFER;

        packet->Irb->u.AllocateAddressRange.Callback = NULL;
        packet->Irb->u.AllocateAddressRange.Context = NULL;

        packet->Irb->u.AllocateAddressRange.Required1394Offset.Off_High = 0;
        packet->Irb->u.AllocateAddressRange.Required1394Offset.Off_Low = 0;

        packet->Irb->u.AllocateAddressRange.FifoSListHead = NULL;
        packet->Irb->u.AllocateAddressRange.FifoSpinLock = NULL;

        packet->Irb->u.AllocateAddressRange.AddressesReturned = 0;
        packet->Irb->u.AllocateAddressRange.DeviceExtension = DeviceExtension;

        packet->Irb->u.AllocateAddressRange.Mdl =
            context->PageTableContext.AddressContext.RequestMdl;

        packet->Irb->u.AllocateAddressRange.MaxSegmentSize =
            (SBP2_MAX_DIRECT_BUFFER_SIZE) / 2;

        packet->Irb->u.AllocateAddressRange.p1394AddressRange =(PADDRESS_RANGE)
            &context->PageTableContext.AddressContext.Address;

        status = Sbp2SendRequest (DeviceExtension, packet, SYNC_1394_REQUEST);

        if (!NT_SUCCESS (status)) {

            DeAllocateIrpAndIrb (DeviceExtension, packet);
            goto Sbp2PreAllocateLists_error;
        }


        //
        // Common buffer allocations get an mdl *back* from the
        // bus/port driver, need to retrieve a corresponding VA
        //

        context->PageTableContext.AddressContext.RequestMdl =
            packet->Irb->u.AllocateAddressRange.Mdl;

        context->PageTableContext.PageTable = MmGetMdlVirtualAddress(
            packet->Irb->u.AllocateAddressRange.Mdl
            );

        context->PageTableContext.AddressContext.AddressHandle =
            packet->Irb->u.AllocateAddressRange.hAddressRange;
        context->PageTableContext.AddressContext.Address.BusAddress.NodeId =
            DeviceExtension->InitiatorAddressId;

        context->PageTableContext.MaxPages = SBP2_NUM_PAGE_TABLE_ENTRIES;


        //
        // add this context to the linked list
        //

        ExInterlockedPushEntrySList(
            &DeviceExtension->FreeContextListHead,
            &context->LookasideList,
            &DeviceExtension->FreeContextLock
            );
    }

    DeAllocateIrpAndIrb (DeviceExtension, packet);


    //
    // initialize the mdl used for quadlet requests to the port driver..
    //

    DeviceExtension->ReservedMdl = IoAllocateMdl(
        &DeviceExtension->Reserved,
        sizeof(QUADLET),
        FALSE,
        FALSE,
        NULL
        );

    if (!DeviceExtension->ReservedMdl) {

        goto Sbp2PreAllocateLists_error;
    }

    MmBuildMdlForNonPagedPool (DeviceExtension->ReservedMdl);

    return STATUS_SUCCESS;


Sbp2PreAllocateLists_error:

    Sbp2CleanDeviceExtension (DeviceExtension->DeviceObject, TRUE);

    return STATUS_INSUFFICIENT_RESOURCES;
}


NTSTATUS
Sbp2InitializeDeviceExtension(
    IN PDEVICE_EXTENSION DeviceExtension
    )
/*++

Routine Description:

    Initializes all the data structures in our device extension, allocates appropriate 1394 addresses and workhorse
    Irps. It also creates a FreeList with pre-allocated contexts and command ORBs.

Arguments:

    DeviceExtension = Sbp2 driver's extension

Return Value:

    NTSTATUS

--*/

{
    ULONG                   i;
    KIRQL                   cIrql;
    NTSTATUS                status;
    PDEVICE_OBJECT          deviceObject = DeviceExtension->DeviceObject;
    PASYNC_REQUEST_CONTEXT  context, oldContext;



    if (DeviceExtension->DeviceFlags & DEVICE_FLAG_REMOVED) {

        return STATUS_SUCCESS;
    }

    InitializeListHead(&DeviceExtension->PendingOrbList);

    DeviceExtension->NextContextToFree = NULL;

    DeviceExtension->OrbListDepth = 0;
    DeviceExtension->CurrentKey = 0;

    //
    // Get information volatile between bus resets
    //

    status = Sbp2UpdateNodeInformation (DeviceExtension);

    if (!NT_SUCCESS(status)) {

        goto exitInit;
    }


    //
    // get 1394 data transfer information
    //

    status = Sbp2GetControllerInfo (DeviceExtension);

    if (!NT_SUCCESS(status)) {

        goto exitInit;
    }


    //
    //
    // allocate a status block for the task ORB and a Management ORB
    //

    if (DeviceExtension->TaskOrbStatusContext.AddressHandle == NULL) {

        status = AllocateAddressForStatus(deviceObject,
                                          &DeviceExtension->TaskOrbStatusContext,
                                          TASK_STATUS_BLOCK);

        if (!NT_SUCCESS(status)) {

            goto exitInit;
        }
    }

    if (DeviceExtension->ManagementOrbStatusContext.AddressHandle == NULL) {

        status = AllocateAddressForStatus(deviceObject,
                                      &DeviceExtension->ManagementOrbStatusContext,
                                      MANAGEMENT_STATUS_BLOCK);

        if (!NT_SUCCESS(status)) {

            goto exitInit;
        }
    }

    if (DeviceExtension->GlobalStatusContext.AddressHandle == NULL) {

        //
        // setup the status FIFO list with the bus driver
        //

        status = AllocateAddressForStatus(deviceObject,
                                          &DeviceExtension->GlobalStatusContext,
                                          CMD_ORB_STATUS_BLOCK);
        if (!NT_SUCCESS(status)) {

            goto exitInit;
        }
    }

#if PASSWORD_SUPPORT

    if (DeviceExtension->PasswordOrbStatusContext.AddressHandle == NULL) {

        status = AllocateAddressForStatus( deviceObject,
                                           &DeviceExtension->PasswordOrbStatusContext,
                                           PASSWORD_STATUS_BLOCK
                                           );

        if (!NT_SUCCESS(status)) {

            goto exitInit;
        }
    }

    DeviceExtension->PasswordOrbContext.DeviceObject = deviceObject;

#endif

    //
    // Allocate a dummy,task, management ORBs and a login response ,which are going to be reused through out the drivers life...
    //

    DeviceExtension->TaskOrbContext.DeviceObject = deviceObject;
    DeviceExtension->ManagementOrbContext.DeviceObject = deviceObject;
    DeviceExtension->LoginRespContext.DeviceObject = deviceObject;
    DeviceExtension->QueryLoginRespContext.DeviceObject = deviceObject;

    KeInitializeEvent(&DeviceExtension->ManagementEvent,SynchronizationEvent, FALSE);

#if PASSWORD_SUPPORT

    // kevent for password orb context
    KeInitializeEvent(
        &DeviceExtension->PasswordEvent,
        SynchronizationEvent,
        FALSE
        );

#endif

    if (DeviceExtension->CommonBufferContext.AddressHandle == NULL) {

        status = AllocateSingle1394Address(
            deviceObject,
            NULL,
            sizeof (*DeviceExtension->CommonBuffer),
            ACCESS_FLAGS_TYPE_READ | ACCESS_FLAGS_TYPE_WRITE,
            &DeviceExtension->CommonBufferContext
            );

        if (!NT_SUCCESS(status)) {

            goto exitInit;
        }

        (PVOID) DeviceExtension->CommonBuffer =
            DeviceExtension->CommonBufferContext.Reserved;


        DeviceExtension->TaskOrb = &DeviceExtension->CommonBuffer->TaskOrb;

        DeviceExtension->TaskOrbContext.Address.BusAddress =
            DeviceExtension->CommonBufferContext.Address.BusAddress;


        DeviceExtension->ManagementOrb =
            &DeviceExtension->CommonBuffer->ManagementOrb;

        DeviceExtension->ManagementOrbContext.Address.BusAddress =
            DeviceExtension->CommonBufferContext.Address.BusAddress;

        DeviceExtension->ManagementOrbContext.Address.BusAddress.Off_Low +=
            (ULONG) ((PUCHAR) DeviceExtension->ManagementOrb -
                (PUCHAR) DeviceExtension->CommonBuffer);


        DeviceExtension->LoginResponse =
            &DeviceExtension->CommonBuffer->LoginResponse;

        DeviceExtension->LoginRespContext.Address.BusAddress =
            DeviceExtension->CommonBufferContext.Address.BusAddress;

        DeviceExtension->LoginRespContext.Address.BusAddress.Off_Low +=
            (ULONG) ((PUCHAR) DeviceExtension->LoginResponse -
                (PUCHAR) DeviceExtension->CommonBuffer);


        DeviceExtension->QueryLoginResponse =
            &DeviceExtension->CommonBuffer->QueryLoginResponse;

        DeviceExtension->QueryLoginRespContext.Address.BusAddress =
            DeviceExtension->CommonBufferContext.Address.BusAddress;

        DeviceExtension->QueryLoginRespContext.Address.BusAddress.Off_Low +=
            (ULONG) ((PUCHAR) DeviceExtension->QueryLoginResponse -
                (PUCHAR) DeviceExtension->CommonBuffer);


#if PASSWORD_SUPPORT

        DeviceExtension->PasswordOrb =
            &DeviceExtension->CommonBuffer->PasswordOrb;

        DeviceExtension->PasswordOrbContext.Address.BusAddress =
            DeviceExtension->CommonBufferContext.Address.BusAddress;

        DeviceExtension->PasswordOrbContext.Address.BusAddress.Off_Low +=
            (ULONG) ((PUCHAR) DeviceExtension->PasswordOrb -
                (PUCHAR) DeviceExtension->CommonBuffer);

#endif

        DeviceExtension->OrbPoolContext.Reserved =
            DeviceExtension->CommonBuffer->CmdOrbs;

        DeviceExtension->OrbPoolContext.Address.BusAddress =
            DeviceExtension->CommonBufferContext.Address.BusAddress;

        DeviceExtension->OrbPoolContext.Address.BusAddress.Off_Low +=
            (ULONG) ((PUCHAR) DeviceExtension->OrbPoolContext.Reserved -
                (PUCHAR) DeviceExtension->CommonBuffer);


        KeAcquireSpinLock (&DeviceExtension->OrbListSpinLock, &cIrql);

        //
        // Initialize our pool of contexts
        //

        for (i = 0, context = NULL; i < MAX_ORB_LIST_DEPTH; i++) {

            //
            // Mark this unused context as completed so if we had to
            // free our freelist now (because we got a remove) we wouldn't
            // try to complete its request
            //

            oldContext = context;

            context = (PVOID) ExInterlockedPopEntrySList (&DeviceExtension->FreeContextListHead,
                                                          &DeviceExtension->FreeContextLock);

            context = RETRIEVE_CONTEXT (context,LookasideList);

            context->Flags |= ASYNC_CONTEXT_FLAG_COMPLETED;

            //
            // Create a linked list so we push all the entries later
            //

            context->OrbList.Blink = (PLIST_ENTRY) oldContext;

            //
            // Each command ORB gets a small piece of our continuous pool
            // mapped into the 1394 memory space.  The sizeof(PVOID) bytes
            // before the cmdorb buffer are the pointer to its context.
            //

            context->CmdOrb = &DeviceExtension->CommonBuffer->CmdOrbs[i].Orb;

            DeviceExtension->CommonBuffer->CmdOrbs[i].AsyncReqCtx = context;

            context->CmdOrbAddress.BusAddress.Off_Low = \
                DeviceExtension->OrbPoolContext.Address.BusAddress.Off_Low +
                (i * sizeof (ARCP_ORB)) + FIELD_OFFSET (ARCP_ORB, Orb);

            context->CmdOrbAddress.BusAddress.Off_High = \
                DeviceExtension->OrbPoolContext.Address.BusAddress.Off_High;

            context->CmdOrbAddress.BusAddress.NodeId = \
                DeviceExtension->InitiatorAddressId;
        }

        //
        // re-create the free list
        //

        while (context) {

            oldContext = context;

            ExInterlockedPushEntrySList(&DeviceExtension->FreeContextListHead,
                                        &context->LookasideList,
                                        &DeviceExtension->FreeContextLock);

            context = (PASYNC_REQUEST_CONTEXT) oldContext->OrbList.Blink;

            oldContext->OrbList.Blink = NULL;
        }


        KeReleaseSpinLock (&DeviceExtension->OrbListSpinLock,cIrql);
    }

    //
    // Update the NodeId portion of the page table addr for each
    // ASYNC_REQUEST_CONTEXT and for the login/queryLogin responses
    //

    for (i = 0; i < MAX_ORB_LIST_DEPTH; i++) {

        context = DeviceExtension->AsyncContextBase + i;

        context->PageTableContext.AddressContext.Address.BusAddress.NodeId =
            DeviceExtension->InitiatorAddressId;
    }

    DeviceExtension->LoginRespContext.Address.BusAddress.NodeId =
        DeviceExtension->InitiatorAddressId;

    DeviceExtension->QueryLoginRespContext.Address.BusAddress.NodeId =
        DeviceExtension->InitiatorAddressId;


    //
    // Finally, allocate a dummy addr that we can easily free & realloc
    // to re-enable phyical addr filters after bus resets
    //

    if (DeviceExtension->DummyContext.AddressHandle == NULL) {

            status = AllocateSingle1394Address(
                deviceObject,
                &DeviceExtension->Dummy,
                sizeof(DeviceExtension->Dummy),
                ACCESS_FLAGS_TYPE_READ | ACCESS_FLAGS_TYPE_WRITE,
                &DeviceExtension->DummyContext
                );

        if (!NT_SUCCESS(status)) {

            goto exitInit;
        }
    }

    //
    // Done
    //

    DEBUGPRINT2(("Sbp2Port: InitDevExt: ext=x%p\n", DeviceExtension));

exitInit:

    return status;
}


BOOLEAN
Sbp2CleanDeviceExtension(
    IN PDEVICE_OBJECT DeviceObject,
    BOOLEAN FreeLists
    )
/*++

Routine Description:

    Called when we get a remove, so it will free all used pool and all the resident Irps.
    It wil also free our FreeList of contexts and any complete any pending IO requests

Arguments:

    DeviceExtension = Sbp2 driver's extension
    FreeLists - TRUE means we cleanup EVERYTHING including our lookaside lists

Return Value:

    NTSTATUS

--*/
{
    PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
    PFDO_DEVICE_EXTENSION fdoExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    KIRQL cIrql;
    PADDRESS_FIFO statusFifoElement;
    ULONG i;
    BOOLEAN valid = FALSE;
    PIRBIRP packet;

    //
    // there are two types of cleanups. One for the PDO and one for the FDO(alot simpler)
    //

    if (deviceExtension->Type == SBP2_PDO) {

        //
        // make sure that this PDO is something in our list and that we have NOT deleted
        // it already....
        //

        fdoExtension = (PFDO_DEVICE_EXTENSION) deviceExtension->BusFdo->DeviceExtension;

        for (i = 0; i < fdoExtension->DeviceListSize; i++) {

            if (fdoExtension->DeviceList[i].DeviceObject == DeviceObject) {

                valid = TRUE;
            }
        }

        if (!valid) {

            return FALSE;
        }

        if (TEST_FLAG(deviceExtension->DeviceFlags,DEVICE_FLAG_INITIALIZED) ){

            //
            // stop the timer for any pending management requests
            //

            KeCancelTimer (&deviceExtension->DeviceManagementTimer);

            //
            // We have a list of requests pending, clean it up
            // The reset/logout has automatically made the target to discard any requests
            //

            CleanupOrbList (deviceExtension, STATUS_REQUEST_ABORTED);
        }

        //
        // after a bus reset we must reallocate at least one physical address to allow
        // the ohci driver to re-enable the physical address filters
        //

        if (deviceExtension->DummyContext.AddressHandle != NULL) {

            FreeAddressRange (deviceExtension,&deviceExtension->DummyContext);
        }

        if (FreeLists){

            if (TEST_FLAG(deviceExtension->DeviceFlags, DEVICE_FLAG_INITIALIZED) ||
                TEST_FLAG(deviceExtension->DeviceFlags, DEVICE_FLAG_INITIALIZING)){

                FreeAddressRange(deviceExtension,&deviceExtension->TaskOrbStatusContext);
                FreeAddressRange(deviceExtension,&deviceExtension->GlobalStatusContext);
#if PASSWORD_SUPPORT
                FreeAddressRange(deviceExtension,&deviceExtension->PasswordOrbStatusContext);
#endif
                FreeAddressRange(deviceExtension,&deviceExtension->ManagementOrbStatusContext);

                if (deviceExtension->PowerDeferredIrp) {

                    deviceExtension->PowerDeferredIrp->IoStatus.Status = STATUS_NO_SUCH_DEVICE;
                    IoReleaseRemoveLock (&deviceExtension->RemoveLock, NULL);
                    IoCompleteRequest (deviceExtension->PowerDeferredIrp, IO_NO_INCREMENT);
                    deviceExtension->PowerDeferredIrp = NULL;
                }

                if (deviceExtension->DeferredPowerRequest) {

                    deviceExtension->DeferredPowerRequest->IoStatus.Status = STATUS_NO_SUCH_DEVICE;
                    IoReleaseRemoveLock (&deviceExtension->RemoveLock, NULL);
                    IoCompleteRequest(deviceExtension->DeferredPowerRequest, IO_NO_INCREMENT);
                    deviceExtension->DeferredPowerRequest = NULL;
                }

                if (deviceExtension->UniSymLinkName.Buffer) {

                    IoDeleteSymbolicLink(&deviceExtension->UniSymLinkName);
                    RtlFreeUnicodeString(&deviceExtension->UniSymLinkName);
                    deviceExtension->UniSymLinkName.Buffer = NULL;
                }

                //
                // before we go any further, check if the device is physically removed
                //

                if (!TEST_FLAG(deviceExtension->DeviceFlags, DEVICE_FLAG_REMOVED)) {

                    DEBUGPRINT2(("Sbp2Port: Cleanup: ext=x%p, not freeing ALL wkg sets, dev present\n", deviceExtension));
                    return TRUE;

                } else {

                    DEBUGPRINT2(("Sbp2Port: Cleanup: ext=x%p, freeing ALL wkg sets\n", deviceExtension));
                }

                CLEAR_FLAG(deviceExtension->DeviceFlags, (DEVICE_FLAG_INITIALIZED | DEVICE_FLAG_INITIALIZING));

                //
                // OK to free common buffer if device is going away
                //

                FreeAddressRange(deviceExtension,&deviceExtension->CommonBufferContext);

                deviceExtension->OrbPoolContext.Reserved = NULL;

                //
                // Free all the page tables & async context buffer
                //

                if (deviceExtension->AsyncContextBase != NULL) {

                    for (i = 0; i < MAX_ORB_LIST_DEPTH; i++) {

                        PASYNC_REQUEST_CONTEXT context;


                        context = deviceExtension->AsyncContextBase + i;

                        if (context->PageTableContext.PageTable != NULL) {

                            //
                            // Common buffer, we didn't alloc the mdl,
                            // so zero the field to prevent our free'ing it
                            //

                            context->PageTableContext.AddressContext.
                                RequestMdl = NULL;

                            FreeAddressRange(
                                deviceExtension,
                                &context->PageTableContext.AddressContext
                                );
                        }
                    }

                    ExFreePool (deviceExtension->AsyncContextBase);
                    deviceExtension->AsyncContextBase = NULL;
                }

                //
                // free pool for status fifo list
                //

                if (deviceExtension->StatusFifoBase !=NULL ) {

                    statusFifoElement = (PVOID) ExInterlockedPopEntrySList (&deviceExtension->StatusFifoListHead,
                                                                  &deviceExtension->StatusFifoLock);
                    while (statusFifoElement){

                        DEBUGPRINT3(("Sbp2Port: Cleanup: freeing statusFifo=x%p, fifoBase=x%p\n",
                                    statusFifoElement,deviceExtension->StatusFifoBase));

                        IoFreeMdl (statusFifoElement->FifoMdl);
                        statusFifoElement = (PVOID) ExInterlockedPopEntrySList (&deviceExtension->StatusFifoListHead,
                                                                  &deviceExtension->StatusFifoLock);
                    };

                    ExFreePool (deviceExtension->StatusFifoBase);
                    deviceExtension->StatusFifoBase = NULL;
                }

                //
                // free the irb/irp and context slists
                //

                packet = (PIRBIRP) ExInterlockedPopEntrySList (&deviceExtension->BusRequestIrpIrbListHead,
                                                               &deviceExtension->BusRequestLock);
                while (packet) {

                    ExFreePool(packet->Irb);

                    if (packet->Irp->Type == IO_TYPE_IRP) {

                        IoFreeIrp(packet->Irp);
                    }

                    ExFreePool(packet);

                    packet = (PIRBIRP) ExInterlockedPopEntrySList (&deviceExtension->BusRequestIrpIrbListHead,
                                                                   &deviceExtension->BusRequestLock);
                };


                // delete our bus request context lookaside list
                ExDeleteNPagedLookasideList(&deviceExtension->BusRequestContextPool);

                if (deviceExtension->ReservedMdl) {

                    IoFreeMdl (deviceExtension->ReservedMdl);
                    deviceExtension->ReservedMdl = NULL;
                }

                // free the vendor id
                if (deviceExtension->DeviceInfo->uniVendorId.Buffer) {

                    ExFreePool(deviceExtension->DeviceInfo->uniVendorId.Buffer);
                    deviceExtension->DeviceInfo->uniVendorId.Length = 0;
                    deviceExtension->DeviceInfo->uniVendorId.Buffer = NULL;
                }

                // free the model id
                if (deviceExtension->DeviceInfo->uniModelId.Buffer) {

                    ExFreePool(deviceExtension->DeviceInfo->uniModelId.Buffer);
                    deviceExtension->DeviceInfo->uniModelId.Length = 0;
                    deviceExtension->DeviceInfo->uniModelId.Buffer = NULL;
                }

                // free the generic name
                if (deviceExtension->DeviceInfo->uniGenericName.Buffer) {

                    ExFreePool(deviceExtension->DeviceInfo->uniGenericName.Buffer);
                    deviceExtension->DeviceInfo->uniGenericName.Length = 0;
                    deviceExtension->DeviceInfo->uniGenericName.Buffer = NULL;
                }
            }
        }

    } else {

        fdoExtension = (PFDO_DEVICE_EXTENSION) deviceExtension;

        if (fdoExtension->Sbp2ObjectDirectory != NULL) {

            ZwMakeTemporaryObject (fdoExtension->Sbp2ObjectDirectory);
            ZwClose (fdoExtension->Sbp2ObjectDirectory);
            fdoExtension->Sbp2ObjectDirectory = NULL;
        }

        if (TEST_FLAG(fdoExtension->DeviceFlags,DEVICE_FLAG_REMOVED)) {

            return FALSE;

        } else {

            SET_FLAG (fdoExtension->DeviceFlags, DEVICE_FLAG_REMOVED);
        }

        if (fdoExtension->DeviceListSize != 0) {

            //
            // Disable bus reset notifications
            //

            AllocateIrpAndIrb ((PDEVICE_EXTENSION) fdoExtension, &packet);

            if (packet) {

                packet->Irb->FunctionNumber = REQUEST_BUS_RESET_NOTIFICATION;
                packet->Irb->Flags = 0;
                packet->Irb->u.BusResetNotification.fulFlags =
                    DEREGISTER_NOTIFICATION_ROUTINE;

                Sbp2SendRequest(
                    (PDEVICE_EXTENSION) fdoExtension,
                    packet,
                    SYNC_1394_REQUEST
                    );

                DeAllocateIrpAndIrb ((PDEVICE_EXTENSION) fdoExtension, packet);
            }
        }

        //
        // Clean up any remaining PDO's
        //

        KeAcquireSpinLock (&fdoExtension->DeviceListLock,&cIrql);

        for (; fdoExtension->DeviceListSize > 0; fdoExtension->DeviceListSize--) {

            i = fdoExtension->DeviceListSize - 1;

            if (fdoExtension->DeviceList[i].DeviceObject) {

                deviceExtension =
                    fdoExtension->DeviceList[i].DeviceObject->DeviceExtension;

                SET_FLAG (deviceExtension->DeviceFlags, DEVICE_FLAG_REMOVED);

                DeviceObject = fdoExtension->DeviceList[i].DeviceObject;

                KeReleaseSpinLock (&fdoExtension->DeviceListLock, cIrql);

                if (Sbp2CleanDeviceExtension (DeviceObject, TRUE)) {

                    //
                    // Acquire the pdo's remove lock, start the queue
                    // cleanup, and and wait for io to complete.  Then
                    // delete the device & continue.
                    //

                    IoAcquireRemoveLock (&deviceExtension->RemoveLock, NULL);

                    KeRaiseIrql (DISPATCH_LEVEL, &cIrql);

                    Sbp2StartNextPacketByKey (DeviceObject, 0);

                    KeLowerIrql (cIrql);

                    DEBUGPRINT2((
                        "Sbp2Port: CleanDevExt: walking fdo, wait for " \
                            "io compl pdo=x%p...\n",
                        DeviceObject
                        ));

                    IoReleaseRemoveLockAndWait(
                        &deviceExtension->RemoveLock,
                        NULL
                        );

                    deviceExtension->Type = SBP2_PDO_DELETED;

                    KeCancelTimer(&deviceExtension->DeviceManagementTimer);

                    IoDeleteDevice (DeviceObject);

                    DEBUGPRINT2((
                        "Sbp2Port: CleanDevExt: ............ io compl," \
                            " deleted pdo=x%p\n",
                        DeviceObject
                        ));

                    KeAcquireSpinLock (&fdoExtension->DeviceListLock, &cIrql);

                    fdoExtension->DeviceList[i].DeviceObject = NULL;

                } else {

                    KeAcquireSpinLock (&fdoExtension->DeviceListLock, &cIrql);
                }
            }

            if (fdoExtension->DeviceList[i].uniVendorId.Buffer) {

                ExFreePool(fdoExtension->DeviceList[i].uniVendorId.Buffer);
                fdoExtension->DeviceList[i].uniVendorId.Length = 0;
                fdoExtension->DeviceList[i].uniVendorId.Buffer = NULL;
            }

            if (fdoExtension->DeviceList[i].uniModelId.Buffer) {

                ExFreePool(fdoExtension->DeviceList[i].uniModelId.Buffer);
                fdoExtension->DeviceList[i].uniModelId.Length = 0;
                fdoExtension->DeviceList[i].uniModelId.Buffer = NULL;
            }

            if (fdoExtension->DeviceList[i].uniGenericName.Buffer) {

                ExFreePool(fdoExtension->DeviceList[i].uniGenericName.Buffer);
                fdoExtension->DeviceList[i].uniGenericName.Length = 0;
                fdoExtension->DeviceList[i].uniGenericName.Buffer = NULL;
            }

        }

        KeReleaseSpinLock (&fdoExtension->DeviceListLock, cIrql);
    }

    return TRUE;
}


VOID
Sbp2Unload(
    IN PDRIVER_OBJECT DriverObject
    )
/*++

Routine Description:

    Does nothing really...

Arguments:

    DriverObject - the driver being unloaded

Return Value:

    none

--*/
{
    DEBUGPRINT1(("Sbp2Port: unloading\n\n"));

    return;
}


VOID
Sbp2DeviceManagementTimeoutDpc(
    IN PKDPC Dpc,
    IN PDEVICE_EXTENSION DeviceExtension,
    IN PVOID SystemArgument1,
    IN PVOID SystemArgument2
    )
{
    ULONG                   i;
    PDEVICE_EXTENSION       pdoExtension;
    PFDO_DEVICE_EXTENSION   fdoExtension;


    if (Dpc != &DeviceExtension->DeviceManagementTimeoutDpc) {

        return;
    }

    if (TEST_FLAG(DeviceExtension->DeviceFlags, DEVICE_FLAG_REMOVED)) {

        return;
    }

    if (TEST_FLAG(DeviceExtension->DeviceFlags,DEVICE_FLAG_RECONNECT)) {

        //
        // The flag indicates that a bus reset occured, and a reconnect never happened...
        // OR that the device is realy hose so we reset it and we need to re-login
        //

        DEBUGPRINT1((
            "Sbp2Port: RECONNECT timeout, Ext=x%p, Flags=x%x, doing re-login\n",
            DeviceExtension,
            DeviceExtension->DeviceFlags
            ));

        //
        // all the resident 1394 memory addresses's that we have, are
        // now invalidated... So we need to free them and re-allocate
        // them

        KeAcquireSpinLockAtDpcLevel(&DeviceExtension->ExtensionDataSpinLock);
        CLEAR_FLAG(DeviceExtension->DeviceFlags,DEVICE_FLAG_RECONNECT);
        KeReleaseSpinLockFromDpcLevel(&DeviceExtension->ExtensionDataSpinLock);

        //
        // If device is marked STOPPED then a target reset was
        // done and that affected all LUNs (spec sect 10.4.4).
        // So if this is a multilun device try logins on each
        // pdo as appropriate.
        //

        fdoExtension = (PFDO_DEVICE_EXTENSION)
            DeviceExtension->BusFdo->DeviceExtension;

        if ((fdoExtension->DeviceListSize > 1)  &&

            TEST_FLAG (DeviceExtension->DeviceFlags, DEVICE_FLAG_STOPPED)) {

            for (i = 0; i < fdoExtension->DeviceListSize; i++) {

                pdoExtension = (PDEVICE_EXTENSION)
                    fdoExtension->DeviceList[i].DeviceObject->DeviceExtension;

                if (pdoExtension->DeviceObject ==
                        DeviceExtension->DeviceObject) {

                    // No need to update node info since no bus reset done

                    Sbp2ManagementTransaction(
                        pdoExtension,
                        TRANSACTION_LOGIN
                        );

                    continue;
                }

                KeAcquireSpinLockAtDpcLevel(
                    &pdoExtension->ExtensionDataSpinLock
                    );

                if (TEST_FLAG(
                        pdoExtension->DeviceFlags,
                        DEVICE_FLAG_INITIALIZED
                        )  &&

                    !TEST_FLAG(
                        pdoExtension->DeviceFlags,
                        DEVICE_FLAG_STOPPED | DEVICE_FLAG_RESET_IN_PROGRESS |
                        DEVICE_FLAG_REMOVED | DEVICE_FLAG_LOGIN_IN_PROGRESS |
                        DEVICE_FLAG_RECONNECT | DEVICE_FLAG_DEVICE_FAILED |
                        DEVICE_FLAG_SURPRISE_REMOVED
                        )) {

                    SET_FLAG(
                        pdoExtension->DeviceFlags,
                        (DEVICE_FLAG_STOPPED | DEVICE_FLAG_RESET_IN_PROGRESS)
                        );

                    KeReleaseSpinLockFromDpcLevel(
                        &pdoExtension->ExtensionDataSpinLock
                        );

                    CleanupOrbList (pdoExtension, STATUS_REQUEST_ABORTED);

                    // No need to update node info since no bus reset done

                    Sbp2ManagementTransaction(
                        pdoExtension,
                        TRANSACTION_LOGIN
                        );

                } else {

                    KeReleaseSpinLockFromDpcLevel(
                        &pdoExtension->ExtensionDataSpinLock
                        );
                }
            }

        } else {

            Sbp2UpdateNodeInformation (DeviceExtension);
            Sbp2ManagementTransaction (DeviceExtension, TRANSACTION_LOGIN);
        }

        return ;
    }


    if (TEST_FLAG(DeviceExtension->DeviceFlags, DEVICE_FLAG_LOGIN_IN_PROGRESS)) {

        ULONG flags;


        //
        // the asynchronous login attempt timed out. This is bad news and means the
        // device is not responding
        //

        KeAcquireSpinLockAtDpcLevel(&DeviceExtension->ExtensionDataSpinLock);

        flags = DeviceExtension->DeviceFlags;

        CLEAR_FLAG(DeviceExtension->DeviceFlags,(DEVICE_FLAG_LOGIN_IN_PROGRESS | DEVICE_FLAG_RESET_IN_PROGRESS));
        SET_FLAG(DeviceExtension->DeviceFlags, (DEVICE_FLAG_STOPPED | DEVICE_FLAG_DEVICE_FAILED));

        KeReleaseSpinLockFromDpcLevel(&DeviceExtension->ExtensionDataSpinLock);

        //
        // check if we had a power irp deferred.. If we did call startio to abort it..
        //

        if (DeviceExtension->DeferredPowerRequest) {

            Sbp2StartIo(DeviceExtension->DeviceObject,DeviceExtension->DeferredPowerRequest);
            DeviceExtension->DeferredPowerRequest = NULL;
        }

        DEBUGPRINT1((
            "Sbp2Port: LOGIN timeout, Ext=x%p, Flags=x%x, device stopped\n",
            DeviceExtension,
            flags
            ));

        Sbp2StartNextPacketByKey (DeviceExtension->DeviceObject, 0);

        IoInvalidateDeviceState(DeviceExtension->DeviceObject);
        return;
    }


    if (TEST_FLAG(DeviceExtension->DeviceFlags, DEVICE_FLAG_RESET_IN_PROGRESS)) {

        //
        // the reset attempt has timed out
        //

        DEBUGPRINT1((
            "Sbp2Port: RESET timeout, Ext=x%p, Flags=x%x, ",
            DeviceExtension,
            DeviceExtension->DeviceFlags
            ));

        if (!TEST_FLAG(DeviceExtension->DeviceFlags, DEVICE_FLAG_STOPPED)) {

            //
            // Second level of recovery, do a TARGET_RESET task function
            //

            DEBUGPRINT1(("doing target reset\n"));

            KeAcquireSpinLockAtDpcLevel(&DeviceExtension->ExtensionDataSpinLock);

            SET_FLAG(DeviceExtension->DeviceFlags, DEVICE_FLAG_STOPPED);
            DeviceExtension->MaxOrbListDepth = max(MIN_ORB_LIST_DEPTH,DeviceExtension->MaxOrbListDepth/2);

            KeReleaseSpinLockFromDpcLevel(&DeviceExtension->ExtensionDataSpinLock);

            CleanupOrbList(DeviceExtension,STATUS_REQUEST_ABORTED);

            //
            // we are close to timing out a reset, try a hard reset
            //

            Sbp2Reset (DeviceExtension->DeviceObject, TRUE);
            return;

        } else {

            //
            // Third level of recovery. Do a hardware node reset
            //

            DEBUGPRINT1(("doing CMD_RESET and relogin.\n"));

            KeAcquireSpinLockAtDpcLevel(&DeviceExtension->ExtensionDataSpinLock);

            DeviceExtension->Reserved = 0;
            SET_FLAG(DeviceExtension->DeviceFlags, (DEVICE_FLAG_RESET_IN_PROGRESS | DEVICE_FLAG_RECONNECT | DEVICE_FLAG_STOPPED));

            DeviceExtension->DueTime.HighPart = -1;
            DeviceExtension->DueTime.LowPart = SBP2_RELOGIN_DELAY;
            KeSetTimer(&DeviceExtension->DeviceManagementTimer,DeviceExtension->DueTime, &DeviceExtension->DeviceManagementTimeoutDpc);

            KeReleaseSpinLockFromDpcLevel(&DeviceExtension->ExtensionDataSpinLock);
            Sbp2AccessRegister(DeviceExtension,&DeviceExtension->Reserved,CORE_RESET_REG | REG_WRITE_ASYNC);

            return;
        }
    }
}


VOID
Sbp2RequestTimeoutDpc(
    IN PKDPC Dpc,
    IN PDEVICE_EXTENSION DeviceExtension,
    IN PVOID SystemArgument1,
    IN PVOID SystemArgument2
    )
/*++

Routine Description:


Arguments:

    DeviceObject - Our Device object
    Context - DeviceExtension

Return Value:
    NTSTATUS

--*/
{
    PIRP requestIrp = NULL;
    PASYNC_REQUEST_CONTEXT current = NULL;
    PASYNC_REQUEST_CONTEXT next = NULL;
    LARGE_INTEGER Time;

#if DBG

    ULONG xferLen;
    UCHAR cdb[6];

#endif

    //
    // return if device is stopped, but since reset can occur while device is stopped
    // thats why this check is ater the reset timing code
    //

    if (IsListEmpty (&DeviceExtension->PendingOrbList)) {

        return ;
    }

    //
    // search the linked list of contexts, to see which guy timed out
    //

    KeAcquireSpinLockAtDpcLevel(&DeviceExtension->OrbListSpinLock);

    next = RETRIEVE_CONTEXT(DeviceExtension->PendingOrbList.Flink,OrbList);

    // see if the last status has the suspended state bit set...
    if ((DeviceExtension->LastStatusBlock.AddressAndStatus.u.HighQuad.u.HighPart & STATUS_BLOCK_ENDOFLIST_BIT_MASK) &&
        (next->Flags & ASYNC_CONTEXT_FLAG_TIMER_STARTED) &&
        !(next->Flags & ASYNC_CONTEXT_FLAG_RANG_DOORBELL)) {

        TRACE(TL_1394_INFO, ("GC: Pending Orb - Ring Doorbell."));

        // set the flag...
        SET_FLAG(next->Flags, ASYNC_CONTEXT_FLAG_RANG_DOORBELL);

        Time.QuadPart = (-5*10*1000*1000); // 5 seconds
        KeSetTimer(&next->Timer, Time, &next->TimerDpc);

        KeReleaseSpinLockFromDpcLevel(&DeviceExtension->OrbListSpinLock);

        // reset the timer to track this request...
        // we still have a pending orb, but the device thinks its done.
        // ring the doorbell...
        Sbp2AccessRegister( DeviceExtension,
                            &DeviceExtension->Reserved,
                            DOORBELL_REG | REG_WRITE_ASYNC
                            );

        return;
    }

    if (next->Flags & ASYNC_CONTEXT_FLAG_RANG_DOORBELL) {

        CLEAR_FLAG(next->Flags, ASYNC_CONTEXT_FLAG_RANG_DOORBELL);
        TRACE(TL_1394_INFO, ("Rang Doorbell - didn't work."));
    }

    do {

        current = next;
        if ((&current->TimerDpc == Dpc) && (current->Flags & ASYNC_CONTEXT_FLAG_TIMER_STARTED)) {

            if (TEST_FLAG(current->Flags,ASYNC_CONTEXT_FLAG_COMPLETED)) {

                DEBUGPRINT1(("Sbp2Port: ReqTimeoutDpc: timeout, but req already compl!!\n" ));
                KeReleaseSpinLockFromDpcLevel(&DeviceExtension->OrbListSpinLock);
                return;
            }

            //
            // this is the timed out request
            // do an abort Task Set
            //

            CLEAR_FLAG(current->Flags,ASYNC_CONTEXT_FLAG_TIMER_STARTED);

            KeCancelTimer(&current->Timer);

#if DBG
            xferLen = current->Srb->DataTransferLength;
            cdb[0] = current->Srb->Cdb[0];
            cdb[1] = current->Srb->Cdb[1];
            cdb[2] = current->Srb->Cdb[2];
            cdb[3] = current->Srb->Cdb[3];
            cdb[4] = current->Srb->Cdb[4];
            cdb[5] = current->Srb->Cdb[5];
#endif

            KeReleaseSpinLockFromDpcLevel(&DeviceExtension->OrbListSpinLock);

            Sbp2CreateRequestErrorLog(DeviceExtension->DeviceObject,current,STATUS_TIMEOUT);

            if (!TEST_FLAG(DeviceExtension->DeviceFlags,DEVICE_FLAG_RESET_IN_PROGRESS)){

                DEBUGPRINT1((
                    "Sbp2Port: ReqTimeoutDpc: cdb=x%02x %02x %02x %02x %02x " \
                        "%02x, len=x%x\n",
                    cdb[0],
                    cdb[1],
                    cdb[2],
                    cdb[3],
                    cdb[4],
                    cdb[5],
                    xferLen
                    ));

                Sbp2Reset (DeviceExtension->DeviceObject, FALSE);
            }

            return;
        }

        next = (PASYNC_REQUEST_CONTEXT) current->OrbList.Flink;

    } while ( current != RETRIEVE_CONTEXT(DeviceExtension->PendingOrbList.Blink,OrbList));

    KeReleaseSpinLockFromDpcLevel(&DeviceExtension->OrbListSpinLock);

    return;
}


VOID
Sbp2Reset(
    PDEVICE_OBJECT DeviceObject,
    BOOLEAN HardReset
    )
/*++

Routine Description:

    Used to implement SBP2 high level recovery mechanisms. It will issue an ABORT_TASK_SET if HardReset == FALSE
    otherswise it will issue a RESET_TARGET. Its all done asynchronously and out timer DPC will track the requests
    to check if they timed out...

Arguments:

    DeviceObject= Sbp2 driver's device object
    HardReset = Type of recovery to perform, TRUE is a target reset, FALSE is an abort task set

Return Value:

    NTSTATUS

--*/
{
    PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
    KIRQL oldIrql;
    NTSTATUS status;
#if DBG
    ULONG generation;
#endif


    if ((deviceExtension->DeviceFlags & DEVICE_FLAG_REMOVED) ||
        (deviceExtension->DeviceFlags & DEVICE_FLAG_RECONNECT)) {

        return;
    }

    if (HardReset == TRUE) {

        DEBUGPRINT2(("Sbp2Port: Reset: ext=x%p, do target reset\n", deviceExtension ));

        //
        // Do a target reset
        //

        KeAcquireSpinLock (&deviceExtension->ExtensionDataSpinLock,&oldIrql);

        deviceExtension->TaskOrbContext.TransactionType = TRANSACTION_TARGET_RESET;
        deviceExtension->TaskOrb->OrbInfo.QuadPart = 0;
        deviceExtension->TaskOrb->OrbInfo.u.HighPart |= ORB_NOTIFY_BIT_MASK;
        deviceExtension->TaskOrb->OrbInfo.u.HighPart |= 0x00FF & TRANSACTION_TARGET_RESET;

        deviceExtension->TaskOrb->OrbInfo.u.LowPart =
            deviceExtension->LoginResponse->LengthAndLoginId.u.LowPart; // LOGIN ID

        deviceExtension->TaskOrb->StatusBlockAddress.BusAddress =
            deviceExtension->TaskOrbStatusContext.Address.BusAddress;

        //
        // endian conversion
        //

        octbswap (deviceExtension->TaskOrb->StatusBlockAddress);

        deviceExtension->TaskOrb->OrbInfo.QuadPart =
            bswap(deviceExtension->TaskOrb->OrbInfo.QuadPart);

        //
        // send the task ORB , mark start of reset/abort
        //

        deviceExtension->DeviceFlags |= DEVICE_FLAG_RESET_IN_PROGRESS;

        //
        // now set the timer to track this request
        //

        deviceExtension->DueTime.HighPart = -1;
        deviceExtension->DueTime.LowPart = SBP2_HARD_RESET_TIMEOUT;
        KeSetTimer(&deviceExtension->DeviceManagementTimer,deviceExtension->DueTime,&deviceExtension->DeviceManagementTimeoutDpc);

        KeReleaseSpinLock(&deviceExtension->ExtensionDataSpinLock,oldIrql);

        status = Sbp2AccessRegister(deviceExtension, &deviceExtension->TaskOrbContext.Address, MANAGEMENT_AGENT_REG | REG_WRITE_ASYNC);

        if (status == STATUS_INVALID_GENERATION) {

            KeCancelTimer(&deviceExtension->DeviceManagementTimer);
#if DBG
            //
            // Check to see if perhaps we didn't get the reset
            // notification we were expecting
            //

            generation = deviceExtension->CurrentGeneration;

            status = Sbp2UpdateNodeInformation (deviceExtension);

            DEBUGPRINT1((
                "Sbp2Port: Reset:  target reset error, sts=x%x, extGen=x%x, " \
                    "curGen=x%x\n",
                status,
                generation,
                deviceExtension->CurrentGeneration
                ));
#endif
            KeAcquireSpinLock(&deviceExtension->ExtensionDataSpinLock,&oldIrql);

            SET_FLAG(deviceExtension->DeviceFlags, (DEVICE_FLAG_STOPPED | DEVICE_FLAG_DEVICE_FAILED));

            KeReleaseSpinLock(&deviceExtension->ExtensionDataSpinLock,oldIrql);

            //
            // check if we had a power irp deferred.. If we did call startio to abort it..
            //

            if (deviceExtension->DeferredPowerRequest) {

                Sbp2StartIo(deviceExtension->DeviceObject,deviceExtension->DeferredPowerRequest);
                deviceExtension->DeferredPowerRequest = NULL;
            }

            Sbp2StartNextPacketByKey (deviceExtension->DeviceObject, 0);

            return;
        }

    } else {

        DEBUGPRINT2(("Sbp2Port: Reset: ext=x%p, do abort task set\n", deviceExtension ));

        //
        // Do an abort task set
        //

        KeAcquireSpinLock (&deviceExtension->ExtensionDataSpinLock,&oldIrql);

        deviceExtension->TaskOrbContext.TransactionType = TRANSACTION_ABORT_TASK_SET;
        deviceExtension->TaskOrb->OrbInfo.QuadPart = 0;
        deviceExtension->TaskOrb->OrbInfo.u.HighPart |= ORB_NOTIFY_BIT_MASK;
        deviceExtension->TaskOrb->OrbInfo.u.HighPart |= 0x00FF & TRANSACTION_ABORT_TASK_SET;

        deviceExtension->TaskOrb->OrbInfo.u.LowPart =
            deviceExtension->LoginResponse->LengthAndLoginId.u.LowPart; // LOGIN ID

        deviceExtension->TaskOrb->StatusBlockAddress.BusAddress =
            deviceExtension->TaskOrbStatusContext.Address.BusAddress;

        //
        // endian conversion
        //

        octbswap (deviceExtension->TaskOrb->StatusBlockAddress);

        deviceExtension->TaskOrb->OrbInfo.QuadPart =
            bswap (deviceExtension->TaskOrb->OrbInfo.QuadPart);

        //
        // send the task ORB , mark start of reset/abort
        //

        deviceExtension->DeviceFlags |= DEVICE_FLAG_RESET_IN_PROGRESS;

        //
        // now set the timer to track this request
        //

        deviceExtension->DueTime.HighPart = -1;
        deviceExtension->DueTime.LowPart = SBP2_RESET_TIMEOUT;
        KeSetTimer(&deviceExtension->DeviceManagementTimer,deviceExtension->DueTime,&deviceExtension->DeviceManagementTimeoutDpc);

        KeReleaseSpinLock(&deviceExtension->ExtensionDataSpinLock,oldIrql);

        Sbp2AccessRegister(deviceExtension, &deviceExtension->TaskOrbContext.Address, MANAGEMENT_AGENT_REG | REG_WRITE_ASYNC);
    }
}


NTSTATUS
Sbp2DeviceControl(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )
/*++

Routine Description:

    This routine is the device control dispatcher.

Arguments:

    DeviceObject
    Irp

Return Value:


    NTSTATUS

--*/
{
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
    NTSTATUS status;
    ULONG requiredSize;

    if (deviceExtension->Type == SBP2_PDO) {

        switch (irpStack->Parameters.DeviceIoControl.IoControlCode) {

        case IOCTL_STORAGE_QUERY_PROPERTY: {
            //
            // Validate the query
            //

            PSTORAGE_PROPERTY_QUERY query = Irp->AssociatedIrp.SystemBuffer;

            if(irpStack->Parameters.DeviceIoControl.InputBufferLength <
               sizeof(STORAGE_PROPERTY_QUERY)) {

                status = STATUS_INVALID_PARAMETER;
                break;
            }

            status = Sbp2QueryProperty(DeviceObject, Irp);


            break;
        }

        case IOCTL_SCSI_PASS_THROUGH:

            status = Sbp2_ScsiPassThrough(DeviceObject, Irp, FALSE);
            break;

        case IOCTL_SCSI_PASS_THROUGH_DIRECT:

            status = Sbp2_ScsiPassThrough(DeviceObject, Irp, TRUE);
            break;

        case IOCTL_SBP2_REQUEST:

            status = Sbp2HandleApiRequest(deviceExtension, Irp);

            break;

        default:

            DEBUGPRINT3(("Sbp2Port: Sbp2DeviceControl: Irp Not Handled.\n" ));
            status = STATUS_NOT_SUPPORTED;
            Irp->IoStatus.Status =status;
            Irp->IoStatus.Information = 0;
            IoCompleteRequest(Irp,IO_NO_INCREMENT);

            break;
        }

    } else {

        status = STATUS_NOT_SUPPORTED;
        Irp->IoStatus.Status =status;
        Irp->IoStatus.Information = 0;
        IoCompleteRequest(Irp,IO_NO_INCREMENT);
    }

    return status;
}


NTSTATUS
Sbp2HandleApiRequest(
    IN PDEVICE_EXTENSION DeviceExtension,
    IN PIRP Irp
    )
{
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PSBP2_REQUEST sbp2Req;
    NTSTATUS status;


    status = IoAcquireRemoveLock (&DeviceExtension->RemoveLock, NULL);

    if (!NT_SUCCESS (status)) {

        Irp->IoStatus.Status = status;
        IoCompleteRequest(Irp,IO_NO_INCREMENT);
        return status;
    }

    if (Irp->RequestorMode == KernelMode) {

        sbp2Req = irpStack->Parameters.Others.Argument1;

    } else { // UserMode

        sbp2Req = Irp->AssociatedIrp.SystemBuffer;
    }

    if (sbp2Req == NULL) {

        DEBUGPRINT1(("Sbp2Port: HandleApiReq: Invalid sbp2Req!"));
        status = STATUS_INVALID_PARAMETER;
        goto Exit_Sbp2HandleApiRequest;
    }

    status = STATUS_NOT_IMPLEMENTED;

    switch (sbp2Req->RequestNumber) {

    case SBP2_REQUEST_RETRIEVE_TEXT_LEAFS:

        //
        // Only allow kernel-mode requests of this type, since the
        // RetrieveTextLeaf definition currently has us passing
        // back a buf alloc'd via ExAllocPool - not something we
        // want to hand back to user-mode.
        //

        if (Irp->RequestorMode == KernelMode) {

            status = Sbp2Get1394ConfigInfo(
                (PFDO_DEVICE_EXTENSION)
                    DeviceExtension->BusFdo->DeviceExtension,
                sbp2Req
                );
        }

        break;

#if PASSWORD_SUPPORT

    case SBP2_REQUEST_SET_PASSWORD:

        if (sbp2Req->u.SetPassword.fulFlags == SBP2REQ_SET_PASSWORD_CLEAR) {

            DEBUGPRINT1(("Sbp2Port: Setting Password to Clear\n"));

            status = Sbp2SetPasswordTransaction(
                DeviceExtension,
                SBP2REQ_SET_PASSWORD_CLEAR
                );

            if (NT_SUCCESS(status)) {

                DeviceExtension->Exclusive = EXCLUSIVE_FLAG_CLEAR;
            }

        } else if (sbp2Req->u.SetPassword.fulFlags ==
                        SBP2REQ_SET_PASSWORD_EXCLUSIVE) {

            DEBUGPRINT1 (("Sbp2Port: HandleApiReq: set passwd to excl\n"));

            status = Sbp2SetPasswordTransaction(
                DeviceExtension,
                SBP2REQ_SET_PASSWORD_EXCLUSIVE
                );

            if (NT_SUCCESS(status)) {

                DeviceExtension->Exclusive = EXCLUSIVE_FLAG_SET;
            }

        } else {

            DEBUGPRINT1((
                "Sbp2Port: HandleApiReq: set passwd, inval fl=x%x\n",
                sbp2Req->u.SetPassword.fulFlags
                ));

            status = STATUS_INVALID_PARAMETER;
            goto Exit_Sbp2HandleApiRequest;
        }

        Sbp2SetExclusiveValue(
             DeviceExtension->DeviceObject,
             &DeviceExtension->Exclusive
             );

        DEBUGPRINT1((
            "Sbp2Port: HandleApiReq: set passwd sts=x%x\n",
            status
            ));

        break;

#endif

    default:

        status = STATUS_INVALID_PARAMETER;
        break;
    }

Exit_Sbp2HandleApiRequest:

    Irp->IoStatus.Status = status;
    IoReleaseRemoveLock (&DeviceExtension->RemoveLock, NULL);
    IoCompleteRequest(Irp,IO_NO_INCREMENT);

    return status;
}


NTSTATUS
Sbp2CreateClose(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )
/*++

Routine Description:

    create and close routine.  This is called by the I/O system
    when the device is opened or closed. The sbp2 driver will do login and logout on
    create/close respectively

Arguments:

    DeviceObject - Pointer to device object for this miniport

    Irp - IRP involved.

Return Value:

    STATUS_SUCCESS.

--*/
{
    NTSTATUS status = STATUS_SUCCESS;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;


    if (deviceExtension->Type == SBP2_PDO) {

        if ((deviceExtension->InquiryData.DeviceType == PRINTER_DEVICE) ||
            (deviceExtension->InquiryData.DeviceType == SCANNER_DEVICE)){

            if (!(deviceExtension->DeviceFlags & DEVICE_FLAG_INITIALIZING)) {

                status = IoAcquireRemoveLock(
                    &deviceExtension->RemoveLock,
                    NULL
                    );

                if (!NT_SUCCESS (status)) {

                    goto Sbp2CreateClose_CompleteReq;
                }

                switch (irpStack->MajorFunction) {

                case IRP_MJ_CREATE:

                    DEBUGPRINT2(("Sbp2Port: Sbp2CreateClose: OPEN_REQUEST, handle cound %d.\n", deviceExtension->HandleCount));

                    if (deviceExtension->DeviceFlags & DEVICE_FLAG_STOPPED) {

                        //
                        // do a login.
                        //

                        DEBUGPRINT2(("Sbp2Port: Sbp2CreateClose: LOGIN.\n" ));
                        status = Sbp2ManagementTransaction(deviceExtension,TRANSACTION_LOGIN);

                        if (status == STATUS_SUCCESS) {

                            //
                            // make retry limit high for busy transactions
                            //

                            deviceExtension->Reserved = BUSY_TIMEOUT_SETTING;
                            Sbp2AccessRegister(deviceExtension,&deviceExtension->Reserved,CORE_BUSY_TIMEOUT_REG | REG_WRITE_SYNC);

                            //
                            // We are ready to receive and pass down requests, init the target's
                            // fetch agent.
                            //

                            Sbp2AccessRegister(deviceExtension,&deviceExtension->Reserved,AGENT_RESET_REG | REG_WRITE_ASYNC);

                            deviceExtension->DeviceFlags &= ~DEVICE_FLAG_STOPPED;

                            InterlockedIncrement(&deviceExtension->HandleCount);
                        }

                    } else {

                        InterlockedIncrement(&deviceExtension->HandleCount);
                    }

                    break;

                case IRP_MJ_CLOSE:

                    if (deviceExtension->HandleCount) {

                        InterlockedDecrement(&deviceExtension->HandleCount);
                    }

                    DEBUGPRINT2(("Sbp2Port: Sbp2CreateClose: CLOSE_REQUEST, handle cound %d.\n", deviceExtension->HandleCount));

                    if (!(deviceExtension->DeviceFlags & (DEVICE_FLAG_REMOVED | DEVICE_FLAG_STOPPED)) &&
                        !deviceExtension->HandleCount) {

                        //
                        // Logout
                        //

                        DEBUGPRINT2(("Sbp2Port: Sbp2CreateClose: LOGIN OUT.\n" ));

                        deviceExtension->DeviceFlags |= DEVICE_FLAG_STOPPED;

                        Sbp2ManagementTransaction(deviceExtension,TRANSACTION_LOGOUT);

                        CleanupOrbList(deviceExtension,STATUS_REQUEST_ABORTED);
                    }

                    break;
                }

                IoReleaseRemoveLock (&deviceExtension->RemoveLock, NULL);
            }
        } // device type check

    } else if (deviceExtension->Type != SBP2_FDO) {

        status = STATUS_NO_SUCH_DEVICE;
    }

Sbp2CreateClose_CompleteReq:

    Irp->IoStatus.Status = status;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, 0);
    return status;
}


NTSTATUS
Sbp2PnpDeviceControl(
    PDEVICE_OBJECT DeviceObject,
    PIRP Irp
    )
/*++

Routine Description:

    This routine handles the PNP requests (primarily for PDO's)

Arguments:

    DeviceObject - Supplies a pointer to the device object for this request.

    Irp - Supplies the Irp making the request.

Return Value:

   NTSTATUS

--*/
{
    KIRQL                   cIrql;
    PULONG                  count;
    NTSTATUS                status;
    UNICODE_STRING          unicodeIdString;
    PDEVICE_EXTENSION       deviceExtension = DeviceObject->DeviceExtension;
    PDEVICE_RELATIONS       deviceRelations;
    PIO_STACK_LOCATION      irpStack = IoGetCurrentIrpStackLocation (Irp);
    PDEVICE_CAPABILITIES    deviceCapabilities;
    PFDO_DEVICE_EXTENSION   fdoExtension;

#if DBG

    const char * minorFuncs[] =
    {
        "START_DEV,           ",
        "QUERY_REMOVE_DEV,    ",
        "REMOVE_DEV,          ",
        "CANCEL_REMOVE_DEV,   ",
        "STOP_DEV,            ",
        "QUERY_STOP_DEV,      ",
        "CANCEL_STOP_DEV,     ",
        "QUERY_DEV_RELATIONS, ",
        "QUERY_INTERFACE,     ",
        "QUERY_CAPABILITIES,  ",
        "QUERY_RESOURCES,     ",
        "QUERY_RESOURCE_REQS, ",
        "QUERY_DEV_TEXT,      ",
        "FILTER_RESOURCE_REQS,",
        "??,                  ",    // 0xd (14)
        "READ_CFG,            ",
        "WRITE_CFG,           ",
        "EJECT,               ",
        "SET_LOCK,            ",
        "QUERY_ID,            ",
        "QUERY_PNP_DEV_STATE, ",
        "QUERY_BUS_INFO,      ",
        "DEV_USAGE_NOTIF,     ",
        "SURPRISE_REMOVAL,    ",
        "QUERY_LEG_BUS_INFO,  "     // 0x18
    };

    DEBUGPRINT2((
        "Sbp2Port: Pnp: [x%02x] %s %sdoX=x%p, fl=x%x\n",
        irpStack->MinorFunction,
        (irpStack->MinorFunction <= 0x18 ?
            minorFuncs[irpStack->MinorFunction] : minorFuncs[14]),
        (deviceExtension->Type == SBP2_PDO ? "p" :
            (deviceExtension->Type == SBP2_FDO ? "f" : "???")),
        deviceExtension,
        deviceExtension->DeviceFlags
        ));

#endif

    //
    // We may receive an IRP_MN_BUS_RESET before our AddDevice
    // has completed. Check to make sure our DeviceObject is
    // initialized before we allow processing of PNP Irps.
    //
    if (DeviceObject->Flags & DO_DEVICE_INITIALIZING) {

        Irp->IoStatus.Status = STATUS_NO_SUCH_DEVICE;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return(STATUS_NO_SUCH_DEVICE);
    }

    switch (deviceExtension->Type) {

    case SBP2_PDO:

        break;

    case SBP2_FDO:

        return Sbp2FDOPnpDeviceControl (DeviceObject, Irp);

    default:

        Irp->IoStatus.Status = STATUS_NO_SUCH_DEVICE;
        IoCompleteRequest (Irp,IO_NO_INCREMENT);
        return STATUS_NO_SUCH_DEVICE;
    }

    status = IoAcquireRemoveLock (&deviceExtension->RemoveLock, NULL);

    if (!NT_SUCCESS (status)) {

        Irp->IoStatus.Status = status;
        IoCompleteRequest (Irp,IO_NO_INCREMENT);
        return status;
    }

    switch (irpStack->MinorFunction) {

    case IRP_MN_QUERY_DEVICE_RELATIONS:

        DEBUGPRINT3((
            "Sbp2Port: Pnp: ... Type = %x\n",
            irpStack->Parameters.QueryDeviceRelations.Type
            ));

        //
        // Fill in the DeviceRelations array with this PDO,
        // reference it, and return.
        //

        if (irpStack->Parameters.QueryDeviceRelations.Type !=
                TargetDeviceRelation) {

            status = Irp->IoStatus.Status;

            break;
        }

        if (Irp->IoStatus.Information) {

            deviceRelations = (PDEVICE_RELATIONS)Irp->IoStatus.Information;

        } else {

            deviceRelations = ExAllocatePool(
                PagedPool,
                sizeof (*deviceRelations)
                );

            if (!deviceRelations) {

                Irp->IoStatus.Status = status = STATUS_INSUFFICIENT_RESOURCES;
                Irp->IoStatus.Information = 0;

                break;
            }

            deviceRelations->Count = 0;
        }

        deviceRelations->Objects[deviceRelations->Count] = DeviceObject;
        deviceRelations->Count++;

        ObReferenceObject (DeviceObject);

        status = Irp->IoStatus.Status = STATUS_SUCCESS;
        Irp->IoStatus.Information = (ULONG_PTR) deviceRelations;

        break;

    case IRP_MN_QUERY_DEVICE_TEXT:
        {
            PDEVICE_INFORMATION DeviceInfo = deviceExtension->DeviceInfo;
            UNICODE_STRING      uniRetString;

            // assume success
            status = STATUS_SUCCESS;

            if ((irpStack->Parameters.QueryDeviceText.DeviceTextType == DeviceTextDescription) ||
                (irpStack->Parameters.QueryDeviceText.DeviceTextType == DeviceTextLocationInformation)) {

                status = Sbp2_BuildDeviceText( irpStack->Parameters.QueryDeviceText.DeviceTextType,
                                               DeviceInfo,
                                               &uniRetString
                                               );

                Irp->IoStatus.Information = (ULONG_PTR)uniRetString.Buffer;
                TRACE(TL_PNP_INFO, ("DeviceText = %ws", uniRetString.Buffer));
            }
            else {

                status = STATUS_NOT_SUPPORTED;
            }

            Irp->IoStatus.Status = status;
        }
        break;

        case IRP_MN_QUERY_ID:
            {
                PDEVICE_INFORMATION DeviceInfo = deviceExtension->DeviceInfo;
                UNICODE_STRING      uniRetString;

                TRACE(TL_PNP_TRACE, ("PDO: IRP_MN_QUERY_ID"));

                // assume success
                status = STATUS_SUCCESS;
                Irp->IoStatus.Information = (ULONG_PTR)NULL;

                switch (irpStack->Parameters.QueryId.IdType) {

                    case BusQueryDeviceID:
                        TRACE(TL_PNP_TRACE, ("BusQueryDeviceID"));

                        // build our DeviceId
                        status = Sbp2_BuildDeviceId(DeviceInfo, &uniRetString);

                        if (!NT_SUCCESS(status)) {

                            TRACE(TL_PNP_ERROR, ("Failed to build DeviceId! = 0x%x", status));
                        }
                        else {

                            Irp->IoStatus.Information = (ULONG_PTR)uniRetString.Buffer;
                            TRACE(TL_PNP_TRACE, ("DeviceID = %ws", uniRetString.Buffer));
                        }
                        break; // BusQueryDeviceID

                    case BusQueryHardwareIDs:
                        TRACE(TL_PNP_TRACE, ("BusQueryHardwareIDs"));

                        // build our HardwareIds
                        status = Sbp2_BuildHardwareIds(DeviceInfo, &uniRetString);

                        if (!NT_SUCCESS(status)) {

                            TRACE(TL_PNP_ERROR, ("Failed to build HardwareIds! = 0x%x", status));
                        }
                        else {

                            Irp->IoStatus.Information = (ULONG_PTR)uniRetString.Buffer;
                            TRACE(TL_PNP_TRACE, ("HardwareIds = %ws", uniRetString.Buffer));
                        }
                        break; // BusQueryHardwareIDs

                    case BusQueryCompatibleIDs:
                        TRACE(TL_PNP_TRACE, ("BusQueryCompatibleIDs"));

                        // build our CompatIds
                        status = Sbp2_BuildCompatIds(DeviceInfo, &uniRetString);

                        if (!NT_SUCCESS(status)) {

                            TRACE(TL_1394_ERROR, ("Failed to build CompatIds! = 0x%x", status));
                        }
                        else {

                            Irp->IoStatus.Information = (ULONG_PTR)uniRetString.Buffer;
                            TRACE(TL_PNP_TRACE, ("CompatIds = %ws", uniRetString.Buffer));
                        }
                        break; // BusQueryCompatibleIDs

                    case BusQueryInstanceID:

//                        if (BusExtension->Tag == BUS_DEVICE_TAG) {

                            TRACE(TL_PNP_TRACE, ("BusQueryInstanceID"));

                            // build our InstanceId
                            status = Sbp2_BuildInstanceId(DeviceInfo, &uniRetString);

                            if (!NT_SUCCESS(status)) {

                                TRACE(TL_1394_ERROR, ("Failed to build InstanceId! = 0x%x", status));
                            }
                            else {

                                Irp->IoStatus.Information = (ULONG_PTR)uniRetString.Buffer;
                                TRACE(TL_PNP_TRACE, ("InstanceID = %ws", uniRetString.Buffer));
                            }
//                        }
//                        else {
//
//                            // let 1394bus deal with it...
//                            IoSkipCurrentIrpStackLocation(Irp);
//                            status = IoCallDriver(BusExtension->ParentDeviceObject, Irp);
//                            return(status); // default
//                        }
                        break; // BusQueryCompatibleIDs

                    default:
                        TRACE(TL_PNP_WARNING, ("Unsupported IRP_MN_QUERY_ID"));

                        // set status to avoid changing the current IoStatus
                        status = Irp->IoStatus.Status;
                        break; // default
                } // switch
            }

            Irp->IoStatus.Status = status;
            break; // IRP_MN_QUERY_ID

    case IRP_MN_QUERY_CAPABILITIES:

        deviceCapabilities =
            irpStack->Parameters.DeviceCapabilities.Capabilities;

        //
        // Settings consistent across all 1394 devices
        //

        deviceCapabilities->Removable = TRUE;
        deviceCapabilities->UniqueID = TRUE;
        deviceCapabilities->SilentInstall = TRUE;

        //
        // Settings for different types of devices.  We are very
        // familar with SCSI-variant devices and can make some
        // good choices here, but for other devices we'll leave
        // these choices up to the higher-level driver(s).
        //

        switch (deviceExtension->DeviceInfo->CmdSetId.QuadPart) {

        case 0x10483:
        case SCSI_COMMAND_SET_ID:

            switch ((deviceExtension->DeviceInfo->Lun.u.HighPart & 0x001F)) {

            case PRINTER_DEVICE:
            case SCANNER_DEVICE:

                deviceCapabilities->RawDeviceOK = FALSE;
                deviceCapabilities->SurpriseRemovalOK = TRUE;
                break;

            default:

                deviceCapabilities->RawDeviceOK = TRUE;
                break;
            }

            break;

        default:

            break;
        }

        deviceCapabilities->DeviceState[PowerSystemWorking] = PowerDeviceD0;
        deviceCapabilities->DeviceState[PowerSystemSleeping1] = PowerDeviceD3;
        deviceCapabilities->DeviceState[PowerSystemSleeping2] = PowerDeviceD3;
        deviceCapabilities->DeviceState[PowerSystemSleeping3] = PowerDeviceD3;
        deviceCapabilities->DeviceState[PowerSystemHibernate] = PowerDeviceD3;
        deviceCapabilities->DeviceState[PowerSystemShutdown] = PowerDeviceD3;

        deviceCapabilities->SystemWake = PowerSystemUnspecified;
        deviceCapabilities->DeviceWake = PowerDeviceUnspecified;
        deviceCapabilities->D1Latency  = 1 * (1000 * 10);     // 1 sec
        deviceCapabilities->D2Latency  = 1 * (1000 * 10);     // 1
        deviceCapabilities->D3Latency  = 1 * (1000 * 10);     // 1

        status = Irp->IoStatus.Status = STATUS_SUCCESS;
        Irp->IoStatus.Information = 0;

        break;

    case IRP_MN_START_DEVICE:

        status = Sbp2StartDevice (DeviceObject);

        Irp->IoStatus.Status = status;

        break;

    case IRP_MN_CANCEL_STOP_DEVICE:
    case IRP_MN_QUERY_STOP_DEVICE:

        status = Irp->IoStatus.Status = STATUS_SUCCESS;

        break;

    case IRP_MN_STOP_DEVICE:

        //
        // Disable bus reset notifications
        //

        Sbp2EnableBusResetNotification (deviceExtension, FALSE);


        //
        // disable idle detection
        //

        PoRegisterDeviceForIdleDetection (DeviceObject, 0L, 0L, PowerDeviceD3);

        //
        // Cleanup
        //

        KeAcquireSpinLock (&deviceExtension->ExtensionDataSpinLock, &cIrql);

        if (!TEST_FLAG(deviceExtension->DeviceFlags, DEVICE_FLAG_STOPPED)) {

            SET_FLAG(
                deviceExtension->DeviceFlags,
                (DEVICE_FLAG_PNP_STOPPED | DEVICE_FLAG_STOPPED)
                );

            KeReleaseSpinLock (&deviceExtension->ExtensionDataSpinLock, cIrql);

            fdoExtension = (PFDO_DEVICE_EXTENSION)
                deviceExtension->BusFdo->DeviceExtension;

            ASSERT(!fdoExtension->ulWorkItemCount);

            ExAcquireFastMutex(&fdoExtension->ResetMutex);
            Sbp2ManagementTransaction (deviceExtension,TRANSACTION_LOGOUT);
            ExReleaseFastMutex(&fdoExtension->ResetMutex);

            Sbp2CleanDeviceExtension (DeviceObject,FALSE);

        } else {

            SET_FLAG (deviceExtension->DeviceFlags, DEVICE_FLAG_PNP_STOPPED);

            KeReleaseSpinLock (&deviceExtension->ExtensionDataSpinLock, cIrql);
        }

        Irp->IoStatus.Status = status = STATUS_SUCCESS;

        ASSERT(!deviceExtension->ulPendingEvents);
        ASSERT(!deviceExtension->ulInternalEventCount);
        break;

    case IRP_MN_BUS_RESET:

        //
        // Start of a PHY reset. We will re-connect asynchronously to the
        // target when our callback is called, so this is ignored..
        //
        // After a bus reset is complete, the bus driver should call our
        // BusResetNotification callback. When it does, we will attempt
        // to reconnect. If the reconnect completion status callback,
        // never fires, it means the following things:
        //
        // 1) The device never completed the RECONNECT, or
        // 2) The device completed the reconnect but because our
        //    controlller was BUSY or hosed we didnt get it
        //
        // If 1 or 2 happens, the timeout DPC queued in our bus reset
        // notification, should fire and attempt a relogin...
        //

        Irp->IoStatus.Status = status = STATUS_SUCCESS;

        break;

    case IRP_MN_QUERY_PNP_DEVICE_STATE:

        if (TEST_FLAG(
                deviceExtension->DeviceFlags,
                (DEVICE_FLAG_REMOVED | DEVICE_FLAG_DEVICE_FAILED)
                ) &&

            !TEST_FLAG(
                deviceExtension->DeviceFlags,
                DEVICE_FLAG_RESET_IN_PROGRESS
                )){

            //
            // Set DEVICE_FLAG_REPORTED_FAILED so the SURPRISE_REMOVE
            // handler knows it didn't get called because of physical
            // hardware removal
            //

            KeAcquireSpinLock (&deviceExtension->ExtensionDataSpinLock,&cIrql);

            SET_FLAG(
                deviceExtension->DeviceFlags,
                DEVICE_FLAG_REPORTED_FAILED
                );

            KeReleaseSpinLock (&deviceExtension->ExtensionDataSpinLock, cIrql);

            //
            // indicate our device is disabled due to a failure..
            //

            Irp->IoStatus.Information |= PNP_DEVICE_FAILED;

            DEBUGPRINT2((
                "Sbp2Port: Pnp: QUERY_DEVICE_STATE, device FAILED!!!\n"
                ));
        }

        status = Irp->IoStatus.Status = STATUS_SUCCESS;

        break;

    case IRP_MN_DEVICE_USAGE_NOTIFICATION:

        switch (irpStack->Parameters.UsageNotification.Type) {

        case DeviceUsageTypePaging:

            count = &deviceExtension->PagingPathCount;
            break;

        case DeviceUsageTypeHibernation:

            count = &deviceExtension->HibernateCount;
            break;

        default:

            count = NULL;
            break;
        }

        if (count) {

            //
            // Send the irp down to see what everyone else thinks
            //

            status = Sbp2ForwardIrpSynchronous(deviceExtension->LowerDeviceObject, Irp);

            if (NT_SUCCESS(status)) {

                IoAdjustPagingPathCount(count, irpStack->Parameters.UsageNotification.InPath);

            }

        } else {

            status = STATUS_NOT_SUPPORTED;

        }

        Irp->IoStatus.Status = status;

        break;

    case IRP_MN_QUERY_REMOVE_DEVICE:

        if (deviceExtension->PagingPathCount ||
            deviceExtension->HibernateCount  ||
            deviceExtension->CrashDumpCount) {

            status = Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;

        } else {

            KeAcquireSpinLock(&deviceExtension->ExtensionDataSpinLock,&cIrql);
            SET_FLAG(deviceExtension->DeviceFlags,DEVICE_FLAG_REMOVE_PENDING);
            KeReleaseSpinLock(&deviceExtension->ExtensionDataSpinLock,cIrql);
            status = Irp->IoStatus.Status = STATUS_SUCCESS;
        }

        break;

    case IRP_MN_CANCEL_REMOVE_DEVICE:

        KeAcquireSpinLock(&deviceExtension->ExtensionDataSpinLock,&cIrql);
        CLEAR_FLAG(deviceExtension->DeviceFlags,DEVICE_FLAG_REMOVE_PENDING);
        KeReleaseSpinLock(&deviceExtension->ExtensionDataSpinLock,cIrql);

        status = Irp->IoStatus.Status = STATUS_SUCCESS;

        break;

    case IRP_MN_REMOVE_DEVICE:

        status = STATUS_SUCCESS;

        KeAcquireSpinLock(&deviceExtension->ExtensionDataSpinLock,&cIrql);

        SET_FLAG (deviceExtension->DeviceFlags, DEVICE_FLAG_PNP_STOPPED);

        if (TEST_FLAG(
                deviceExtension->DeviceFlags,
                DEVICE_FLAG_SURPRISE_REMOVED
                )) {

            //
            // We already cleaned up in SURPRISE_REMOVAL handler.
            // Empty out the queue, wait for io to complete, then
            // delete the device, complete the request, & return.
            //

            KeReleaseSpinLock(
                &deviceExtension->ExtensionDataSpinLock,
                cIrql
                );

            KeRaiseIrql (DISPATCH_LEVEL, &cIrql);

            Sbp2StartNextPacketByKey (DeviceObject, 0);

            KeLowerIrql (cIrql);

            DEBUGPRINT2((
                "Sbp2Port: Pnp: wait for io compl pdo=x%p...\n",
                DeviceObject
                ));

            IoReleaseRemoveLockAndWait (&deviceExtension->RemoveLock, NULL);

            deviceExtension->Type = SBP2_PDO_DELETED;

            KeCancelTimer(&deviceExtension->DeviceManagementTimer);

            IoDeleteDevice (DeviceObject);

            DEBUGPRINT2((
                "Sbp2Port: Pnp: ......... deleted pdo=x%p\n", DeviceObject
                ));

            Irp->IoStatus.Status = status;
            IoCompleteRequest (Irp, IO_NO_INCREMENT);

            return status;
        }

        if (TEST_FLAG(
                deviceExtension->DeviceFlags,
                DEVICE_FLAG_REMOVE_PENDING
                )) {

            KeReleaseSpinLock (&deviceExtension->ExtensionDataSpinLock, cIrql);

            //
            // If device is initialized & MgmtOrbCtx event is still around
            // then do a log out
            //

            if (TEST_FLAG(
                    deviceExtension->DeviceFlags,
                    DEVICE_FLAG_INITIALIZED
                    )) {

                DEBUGPRINT1((
                    "Sbp2Port: Pnp: LOG OUT, since QUERY preceded RMV\n"
                    ));

                fdoExtension = (PFDO_DEVICE_EXTENSION)
                    deviceExtension->BusFdo->DeviceExtension;

                ExAcquireFastMutex(&fdoExtension->ResetMutex);
                Sbp2ManagementTransaction(deviceExtension,TRANSACTION_LOGOUT);
                ExReleaseFastMutex(&fdoExtension->ResetMutex);
            }

            KeAcquireSpinLock(&deviceExtension->ExtensionDataSpinLock,&cIrql);

            CLEAR_FLAG(
                deviceExtension->DeviceFlags,
                DEVICE_FLAG_REMOVE_PENDING
                );

            SET_FLAG (deviceExtension->DeviceFlags, DEVICE_FLAG_STOPPED);

        } else if (!TEST_FLAG(
                        deviceExtension->DeviceFlags,
                        (DEVICE_FLAG_REMOVED | DEVICE_FLAG_DEVICE_FAILED)
                        )){

            //
            // If no query has preceded and NO SUPRISE_REMOVAL has preceded
            // this means we are running under win98, where physical device
            // removals are only indicated by only MN_REMOVES being sent,
            // with no QUERY_REMOVE prior to the remove.
            //

            if (deviceExtension->DeviceFlags ==
                    (DEVICE_FLAG_INITIALIZING | DEVICE_FLAG_STOPPED)  &&
                !SystemIsNT) {

                DEBUGPRINT1((
                    "Sbp2Port: Pnp: 9x REMOVE, don't delete dev\n"
                    ));

                deviceExtension->DeviceFlags =
                    DEVICE_FLAG_UNSTARTED_AND_REMOVED;

            } else {

                SET_FLAG (deviceExtension->DeviceFlags, DEVICE_FLAG_REMOVED);

                CLEAR_FLAG(
                    deviceExtension->DeviceFlags,
                    DEVICE_FLAG_RESET_IN_PROGRESS | DEVICE_FLAG_RECONNECT |
                        DEVICE_FLAG_LOGIN_IN_PROGRESS
                    );

                DEBUGPRINT1((
                    "Sbp2Port: Pnp: Suprise removal, since QUERY " \
                        "did not precede REMOVE.\n"
                    ));
            }
        }

        CLEAR_FLAG (deviceExtension->DeviceFlags, DEVICE_FLAG_CLAIMED);

        KeReleaseSpinLock (&deviceExtension->ExtensionDataSpinLock, cIrql);

        if (!Sbp2CleanDeviceExtension (DeviceObject, TRUE)) {

            DEBUGPRINT1(("Sbp2Port: Pnp: Double remove\n"));
        }

        //
        // In all cases other than surprise removals, pdo's will get
        // deleted by the fdo remove handler
        //

        Irp->IoStatus.Status = status;

        break;

    case IRP_MN_SURPRISE_REMOVAL: {

        //
        // If device was reported failed (due to async login failure &
        // IoInvalidateDeviceState) then just set REMOVED & PNP_STOPPED
        // flags and clean up the device extension - we don't want to
        // delete the pdo at this point.
        //
        // Otherwise, assume physical device removal occured, in which
        // case we need to do our own cleanup & teardown right here
        // because the dev stack will start disintegrating.
        //
        // ISSUE: Per AdriaO, another case where we can get a
        //        SURPRISE_REMOVAL is if a START fails *after* a STOP
        //        - at any point in this pdo's stack!  Not sure how to
        //        tell whether or not this is the case if it's not
        //        SBP2PORT that failed the START, so leaving that case
        //        as is for now.  DanKn, 04-Jun-2001
        //

        BOOLEAN reportedMissing;

        KeAcquireSpinLock (&deviceExtension->ExtensionDataSpinLock, &cIrql);

        if (TEST_FLAG(
                deviceExtension->DeviceFlags,
                DEVICE_FLAG_REPORTED_FAILED
                )) {

            SET_FLAG(
                deviceExtension->DeviceFlags,
                (DEVICE_FLAG_REMOVED | DEVICE_FLAG_PNP_STOPPED)
                );

            reportedMissing = FALSE;

        } else {

            SET_FLAG(
                deviceExtension->DeviceFlags,
                (DEVICE_FLAG_REMOVED | DEVICE_FLAG_SURPRISE_REMOVED |
                    DEVICE_FLAG_PNP_STOPPED)
                );

            reportedMissing = TRUE;
        }

        CLEAR_FLAG(
            deviceExtension->DeviceFlags,
            (DEVICE_FLAG_RESET_IN_PROGRESS | DEVICE_FLAG_RECONNECT |
                DEVICE_FLAG_LOGIN_IN_PROGRESS | DEVICE_FLAG_REPORTED_FAILED)
            );

        KeReleaseSpinLock (&deviceExtension->ExtensionDataSpinLock, cIrql);

        Sbp2CleanDeviceExtension (DeviceObject, TRUE);

        if (reportedMissing) {

            Sbp2HandleRemove (DeviceObject);
        }

        Irp->IoStatus.Status = STATUS_SUCCESS;

        break;
    }
    case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:

        //
        // PnP walks up the device tree looking for the FILE_CHAR flags,
        // and stops when it finds a node marked Removable. Since our pdo's
        // are marked Removable, PnP won't make it to a BUS1394 PDO, so we
        // need to propagate the FILE_CHAR flags here.
        //

        fdoExtension = (PFDO_DEVICE_EXTENSION)
            deviceExtension->BusFdo->DeviceExtension;

        DeviceObject->Characteristics |=
            (FILE_CHARACTERISTICS_REMOVAL_POLICY_MASK &
            fdoExtension->Pdo->Characteristics);

        status = Irp->IoStatus.Status;

        break;

    default:

        status = Irp->IoStatus.Status;

        break;
    }

    //
    // This is the bottom of the stack, complete the request
    //

    IoReleaseRemoveLock (&deviceExtension->RemoveLock, NULL);
    IoCompleteRequest (Irp, IO_NO_INCREMENT);

    return status;
}


NTSTATUS
Sbp2FDOPnpDeviceControl(
    PDEVICE_OBJECT DeviceObject,
    PIRP Irp
    )
/*++

Routine Description:

    This routine handles the PNP requests for FDO's

Arguments:

    DeviceObject - Supplies a pointer to the device object for this request.

    Irp - Supplies the Irp making the request.

Return Value:

   NTSTATUS

--*/
{
    KEVENT                  event;
    NTSTATUS                status;
    PDEVICE_RELATIONS       deviceRelations;
    PIO_STACK_LOCATION      irpStack = IoGetCurrentIrpStackLocation(Irp);
    PDEVICE_CAPABILITIES    deviceCapabilities;
    PFDO_DEVICE_EXTENSION   fdoExtension = DeviceObject->DeviceExtension;

    status = IoAcquireRemoveLock(&fdoExtension->RemoveLock, NULL);

    if (!NT_SUCCESS(status)) {

        Irp->IoStatus.Status = status;
        IoCompleteRequest (Irp,IO_NO_INCREMENT);
        return status;
    }

    switch (irpStack->MinorFunction) {

    case IRP_MN_QUERY_DEVICE_RELATIONS:

        DEBUGPRINT3((
            "Sbp2Port: Pnp: ... Type = %x\n",
            irpStack->Parameters.QueryDeviceRelations.Type
            ));

        if (irpStack->Parameters.QueryDeviceRelations.Type != BusRelations) {

            break;
        }

        deviceRelations = ExAllocatePool(
            PagedPool,
            sizeof (*deviceRelations) +
                (SBP2_MAX_LUNS_PER_NODE * sizeof (PDEVICE_OBJECT))
            );

        if (!deviceRelations) {

            DEBUGPRINT1 (("Sbp2Port: Pnp: devRels alloc failed!!\n"));

            Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
            Irp->IoStatus.Information = 0;

            IoCompleteRequest (Irp, IO_NO_INCREMENT);
            return (STATUS_INSUFFICIENT_RESOURCES);
        }

        status = Sbp2CreateDeviceRelations (fdoExtension, deviceRelations);
        Irp->IoStatus.Status = status;

        if (NT_SUCCESS(status)) {

            Irp->IoStatus.Information = (ULONG_PTR) deviceRelations;

        } else {

            Irp->IoStatus.Information = 0;

            IoCompleteRequest (Irp, IO_NO_INCREMENT);
            return status;
        }

        break;

    case IRP_MN_QUERY_CAPABILITIES:

        deviceCapabilities =
            irpStack->Parameters.DeviceCapabilities.Capabilities;

        deviceCapabilities->SurpriseRemovalOK = TRUE;

        break;

    case IRP_MN_START_DEVICE:

        KeInitializeEvent (&event, SynchronizationEvent, FALSE);

        IoCopyCurrentIrpStackLocationToNext (Irp);

        IoSetCompletionRoutine(
            Irp,
            Sbp2FdoRequestCompletionRoutine,
            (PVOID) &event,
            TRUE,
            TRUE,
            TRUE
            );

        status = IoCallDriver (fdoExtension->LowerDeviceObject, Irp);

        if(!NT_SUCCESS(Irp->IoStatus.Status) && (status != STATUS_PENDING)) {

            status = Irp->IoStatus.Status;

        } else {

            KeWaitForSingleObject (&event, Executive, KernelMode, FALSE, NULL);

            status = Sbp2StartDevice (DeviceObject);
        }

        IoReleaseRemoveLock(&fdoExtension->RemoveLock, NULL);

        Irp->IoStatus.Status = status;
        IoCompleteRequest (Irp, IO_NO_INCREMENT);

        return status;

    case IRP_MN_REMOVE_DEVICE:

        KeInitializeEvent (&event, SynchronizationEvent, FALSE);

        IoCopyCurrentIrpStackLocationToNext(Irp);

        IoSetCompletionRoutine(
            Irp,
            Sbp2FdoRequestCompletionRoutine,
            (PVOID) &event,
            TRUE,
            TRUE,
            TRUE
            );

        status = IoCallDriver (fdoExtension->LowerDeviceObject, Irp);

        if (!NT_SUCCESS (Irp->IoStatus.Status) && status != STATUS_PENDING) {

            status = Irp->IoStatus.Status;

        } else {

            KeWaitForSingleObject (&event, Executive, KernelMode, FALSE, NULL);

            //
            // do FDO cleanup..
            //

            IoReleaseRemoveLockAndWait(&fdoExtension->RemoveLock, NULL);

            if (Sbp2CleanDeviceExtension (DeviceObject, TRUE)) {

                ASSERT(!fdoExtension->ulBusResetMutexCount);
                ASSERT(!fdoExtension->ulWorkItemCount);

                IoDetachDevice (fdoExtension->LowerDeviceObject);
                IoDeleteDevice (DeviceObject);
            }

            status = STATUS_SUCCESS;
        }

        Irp->IoStatus.Status = status;
        IoCompleteRequest (Irp,IO_NO_INCREMENT);

        return status;

    case IRP_MN_QUERY_PNP_DEVICE_STATE:

        Irp->IoStatus.Information |= PNP_DEVICE_DONT_DISPLAY_IN_UI;

        break;

    default:

        break;
    }

    IoReleaseRemoveLock(&fdoExtension->RemoveLock, NULL);

    //
    // Pass the irp down the stack
    //

    IoCopyCurrentIrpStackLocationToNext (Irp);

    status = IoCallDriver (fdoExtension->LowerDeviceObject, Irp);

    return status;
}


VOID
Sbp2HandleRemove(
    IN PDEVICE_OBJECT DeviceObject
    )
{
    PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
    PFDO_DEVICE_EXTENSION fdoExtension;
    KIRQL cIrql;
    ULONG i,j;
    PIRBIRP packet;

    fdoExtension = (PFDO_DEVICE_EXTENSION) deviceExtension->BusFdo->DeviceExtension;

    if (!TEST_FLAG (deviceExtension->DeviceFlags,DEVICE_FLAG_REMOVED)) {

        return;
    }

    //
    // now we need to remove ourselves from the DeviceList, the sbp2 FDO keeps of its
    // children...
    // then we re-condense the list..
    //

    KeAcquireSpinLock (&fdoExtension->DeviceListLock,&cIrql);

    if (fdoExtension->DeviceListSize > 1) {

        DEBUGPRINT1(("\'Sbp2Cleanup, condensing PDO list\n"));

        for (i = 0; i < fdoExtension->DeviceListSize; i++) {

            if (fdoExtension->DeviceList[i].DeviceObject == DeviceObject) {

                //
                // free the model descriptor only if its not the same as the FDOs
                // this only happens in the multi-lu case
                //

                if (fdoExtension->DeviceList[i].uniVendorId.Buffer) {

                    ExFreePool(fdoExtension->DeviceList[i].uniVendorId.Buffer);
                    fdoExtension->DeviceList[i].uniVendorId.Length = 0;
                    fdoExtension->DeviceList[i].uniVendorId.Buffer = NULL;
                }

                if (fdoExtension->DeviceList[i].uniModelId.Buffer) {

                    ExFreePool(fdoExtension->DeviceList[i].uniModelId.Buffer);
                    fdoExtension->DeviceList[i].uniModelId.Length = 0;
                    fdoExtension->DeviceList[i].uniModelId.Buffer = NULL;
                }

                if (fdoExtension->DeviceList[i].uniGenericName.Buffer) {

                    ExFreePool(fdoExtension->DeviceList[i].uniGenericName.Buffer);
                    fdoExtension->DeviceList[i].uniGenericName.Length = 0;
                    fdoExtension->DeviceList[i].uniGenericName.Buffer = NULL;
                }

                //
                // we found our place in the list. Remove us and re-condense the list
                //

                for (j = i; j < fdoExtension->DeviceListSize; j++) {

                    if ((j + 1) < fdoExtension->DeviceListSize) {

                        fdoExtension->DeviceList[j] = fdoExtension->DeviceList[j+1];

                        //
                        // Change the (pdo)DevExt->DeviceInfo to point at
                        // the next postion in the device list
                        //

                        deviceExtension = fdoExtension->DeviceList[j].
                            DeviceObject->DeviceExtension;

                        deviceExtension->DeviceInfo =
                            &fdoExtension->DeviceList[j];
                    }
                }

                fdoExtension->DeviceListSize--;
            }
        }

    } else {

        if (fdoExtension->DeviceList[0].DeviceObject == DeviceObject) {

            if (fdoExtension->DeviceList[0].uniVendorId.Buffer) {

                ExFreePool(fdoExtension->DeviceList[0].uniVendorId.Buffer);
                fdoExtension->DeviceList[0].uniVendorId.Length = 0;
                fdoExtension->DeviceList[0].uniVendorId.Buffer = NULL;
            }

            if (fdoExtension->DeviceList[0].uniModelId.Buffer) {

                ExFreePool(fdoExtension->DeviceList[0].uniModelId.Buffer);
                fdoExtension->DeviceList[0].uniModelId.Length = 0;
                fdoExtension->DeviceList[0].uniModelId.Buffer = NULL;
            }

            if (fdoExtension->DeviceList[0].uniGenericName.Buffer) {

                ExFreePool(fdoExtension->DeviceList[0].uniGenericName.Buffer);
                fdoExtension->DeviceList[0].uniGenericName.Length = 0;
                fdoExtension->DeviceList[0].uniGenericName.Buffer = NULL;
            }
        }

        fdoExtension->DeviceList[0].DeviceObject = NULL;
        fdoExtension->DeviceListSize = 0;

        CLEAR_FLAG(deviceExtension->DeviceFlags,DEVICE_FLAG_INITIALIZED);
    }

    if (fdoExtension->DeviceListSize == 0) {

        //
        // all our children have been deleted, set our FDO to be inactive
        // so it can not re create  PDOs qhen it receives a QDR.
        // The reaosn is that if our PDOS are all removed, we dont support
        // dynamic changes ot the crom, which would then warrant us being
        //  able to eject PDOs again.
        //

        SET_FLAG(fdoExtension->DeviceFlags, DEVICE_FLAG_STOPPED);

        KeReleaseSpinLock (&fdoExtension->DeviceListLock, cIrql);

        //
        // Disable bus reset notifications
        //

        AllocateIrpAndIrb ((PDEVICE_EXTENSION) fdoExtension, &packet);

        if (packet) {

            packet->Irb->FunctionNumber = REQUEST_BUS_RESET_NOTIFICATION;
            packet->Irb->Flags = 0;
            packet->Irb->u.BusResetNotification.fulFlags = DEREGISTER_NOTIFICATION_ROUTINE;

            Sbp2SendRequest(
                (PDEVICE_EXTENSION) fdoExtension,
                packet,
                SYNC_1394_REQUEST
                );

            DeAllocateIrpAndIrb((PDEVICE_EXTENSION)fdoExtension,packet);
        }

        fdoExtension->NumPDOsStarted = 0;

    } else {

        KeReleaseSpinLock (&fdoExtension->DeviceListLock, cIrql);
    }

}


NTSTATUS
Sbp2FdoRequestCompletionRoutine(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PKEVENT Event
    )

{
    KeSetEvent(Event, IO_NO_INCREMENT, FALSE);
    return STATUS_MORE_PROCESSING_REQUIRED;
}


NTSTATUS
Sbp2CreateDeviceRelations(
    IN PFDO_DEVICE_EXTENSION FdoExtension,
    IN PDEVICE_RELATIONS DeviceRelations
    )
{
    ULONG i;
    NTSTATUS status;
    ULONG instanceNum;

    PAGED_CODE();

    //
    // LUNS are static in the Config Rom. so if our DeviceListSize >0, that objetc
    // has been seen before
    //

    DeviceRelations->Count = 0;

    status = Sbp2Get1394ConfigInfo (FdoExtension, NULL);

    if (!NT_SUCCESS(status)) {

        ExFreePool (DeviceRelations);
        return status;
    }

    if (TEST_FLAG (FdoExtension->DeviceFlags,DEVICE_FLAG_STOPPED)) {

        ExFreePool(DeviceRelations);
        return STATUS_UNSUCCESSFUL;
    }

    for (i = 0; i < FdoExtension->DeviceListSize; i++) {

        if (!FdoExtension->DeviceList[i].DeviceObject) {

            instanceNum = 0;

            do {

                status = Sbp2CreatePdo (FdoExtension,&FdoExtension->DeviceList[i],instanceNum++);

            } while (status == STATUS_OBJECT_NAME_COLLISION);

            if (!NT_SUCCESS(status)) {

                DEBUGPRINT1(("\'Sbp2CreateDeviceRelations, Failed to create PDO \n"));

                ExFreePool (DeviceRelations);
                return status;
            }

            DeviceRelations->Objects[DeviceRelations->Count] = FdoExtension->DeviceList[i].DeviceObject;
            DeviceRelations->Count++;
            ObReferenceObject (FdoExtension->DeviceList[i].DeviceObject);

        } else {

            //
            // On NT we always add existing pdo's to the dev relations list.
            //
            // On 9x, we only add pdo's to the list whose DevFlags field
            // is non-zero. If we see a pdo with a zero DevFlags field
            // then that means it was never started (likely for lack of
            // a driver), and we don't want to re-indicate it to the caller.
            // The pdo will eventually get deleted when cleaning up the fdo.
            //

            if (!SystemIsNT) {

                PDEVICE_EXTENSION   pdoExtension;


                pdoExtension = (PDEVICE_EXTENSION)
                    FdoExtension->DeviceList[i].DeviceObject->DeviceExtension;

                if (pdoExtension->DeviceFlags &
                        DEVICE_FLAG_UNSTARTED_AND_REMOVED) {

                    ASSERT(pdoExtension->DeviceFlags == DEVICE_FLAG_UNSTARTED_AND_REMOVED);

                    DEBUGPRINT2((
                        "Sbp2Port: CreateDevRelations: excluding ext=x%x\n",
                        pdoExtension
                        ));

                    continue;
                }
            }

            DeviceRelations->Objects[DeviceRelations->Count] =
                FdoExtension->DeviceList[i].DeviceObject;
            DeviceRelations->Count++;
            ObReferenceObject (FdoExtension->DeviceList[i].DeviceObject);
        }
    }

    return STATUS_SUCCESS;
}

//
// code below ported from scsiport
//

NTSTATUS
Sbp2SystemControl(
    PDEVICE_OBJECT DeviceObject,
    PIRP Irp
    )
/*++

Routine Description:

    This routine handles only the WMI related requests. It mostly passes everything down

Arguments:

    DeviceObject - Supplies a pointer to the device object for this request.

    Irp - Supplies the Irp making the request.

Return Value:

   NTSTATUS

--*/
{
    NTSTATUS            status;
    PDEVICE_EXTENSION   deviceExtension = DeviceObject->DeviceExtension;


    if (deviceExtension->Type == SBP2_FDO) {

        DEBUGPRINT2(("Sbp2Port: WmiCtl: irp=x%p not handled, passing it down\n", Irp));

        IoCopyCurrentIrpStackLocationToNext(Irp);
        return (IoCallDriver(deviceExtension->LowerDeviceObject, Irp));

    } else {

        status = Irp->IoStatus.Status;
        IoCompleteRequest (Irp, IO_NO_INCREMENT);
        return status;
    }
}

/* ******************************* POWER MANAGEMENT ********************************/


NTSTATUS
Sbp2PowerControl(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )
/*++

Routine Description:

    This routine receives the various Power messages

Arguments:

    DeviceObject - Pointer to class device object.

    Irp - Pointer to the request packet.

Return Value:

    Status is returned.

--*/
{
    PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
    PFDO_DEVICE_EXTENSION   fdoExtension;
    PIO_STACK_LOCATION irpStack;
    PIO_COMPLETION_ROUTINE complRoutine;
    KIRQL cIrql;
    NTSTATUS status;
    POWER_STATE State;
    UCHAR minorFunction;


    irpStack = IoGetCurrentIrpStackLocation(Irp);
    ASSERT(irpStack->MajorFunction == IRP_MJ_POWER);

    DEBUGPRINT2((
        "Sbp2Port: Power: %sExt=x%p, irp=x%p, minor=x%x\n",
        (deviceExtension->Type == SBP2_FDO ? "fdo" : "pdo"),
        deviceExtension,
        Irp,
        irpStack->MinorFunction
        ));

    switch (deviceExtension->Type) {

    case SBP2_PDO:

        status = IoAcquireRemoveLock (&deviceExtension->RemoveLock, NULL);

        if (!NT_SUCCESS (status)) {

            DEBUGPRINT2((
                "Sbp2Port: Power:   pdoExt=x%p REMOVED!\n",
                deviceExtension
                ));

            Irp->IoStatus.Status = status;
            PoStartNextPowerIrp (Irp);
            IoCompleteRequest (Irp, IO_NO_INCREMENT);
            return status;
        }

        switch ((minorFunction = irpStack->MinorFunction)) {

        case IRP_MN_SET_POWER:

            DEBUGPRINT2(("Sbp2Port: Power:   Type = %d, State = %d\n",
                irpStack->Parameters.Power.Type,irpStack->Parameters.Power.State.DeviceState));

            State = irpStack->Parameters.Power.State;

            if (irpStack->Parameters.Power.Type == SystemPowerState) {

                BOOLEAN sendDIrp = FALSE;


                //
                // make up a device state to correspond to a system state
                //

                DEBUGPRINT2(("Sbp2Port: Power:   sys power chg from %x to %x\n",deviceExtension->SystemPowerState,State));

                status = STATUS_SUCCESS;

                KeAcquireSpinLock(&deviceExtension->ExtensionDataSpinLock,&cIrql);

                if (State.SystemState >= PowerSystemShutdown) {

                    //
                    // dont do anything for shutdown
                    //

                    DEBUGPRINT2(("Sbp2Port: Power:   sys shutdown, ignoring\n"));
                    deviceExtension->SystemPowerState = State.SystemState;

                } else if ((deviceExtension->SystemPowerState == PowerSystemWorking) &&
                    (State.SystemState != PowerSystemWorking)){

                    deviceExtension->SystemPowerState = State.SystemState;

                    if (deviceExtension->DevicePowerState != PowerDeviceD3) {

                        //
                        // Powering down
                        //

                        State.DeviceState = PowerDeviceD3;
                        sendDIrp = TRUE;
                    }

                } else if (State.SystemState == PowerSystemWorking) {

                    deviceExtension->SystemPowerState = State.SystemState;

                    if (deviceExtension->DevicePowerState != PowerDeviceD0) {

                        //
                        // Powering up - check for an absent fdo
                        //

                        fdoExtension =
                            deviceExtension->BusFdo->DeviceExtension;

                        if (TEST_FLAG(
                                fdoExtension->DeviceFlags,
                                DEVICE_FLAG_ABSENT_ON_POWER_UP
                                )) {

                            SET_FLAG(
                                deviceExtension->DeviceFlags,
                                DEVICE_FLAG_ABSENT_ON_POWER_UP
                                );

                            DEBUGPRINT1((
                                "Sbp2Port: Power:   dev absent, failing\n"
                                ));

                            status = STATUS_NO_SUCH_DEVICE;

                        } else {

                            State.DeviceState = PowerDeviceD0;
                            sendDIrp = TRUE;
                        }
                    }
                }

                KeReleaseSpinLock(&deviceExtension->ExtensionDataSpinLock,cIrql);

                if (sendDIrp) {

                    DEBUGPRINT2((
                        "Sbp2Port: Power:   ext=x%p send D irp for state %d\n",
                        deviceExtension,
                        State
                        ));

                    IoMarkIrpPending (Irp);

                    status = PoRequestPowerIrp(
                            DeviceObject,
                            IRP_MN_SET_POWER,
                            State,
                            Sbp2PdoDIrpCompletion,
                            Irp,
                            NULL);

                    if (NT_SUCCESS (status)) {

                        return STATUS_PENDING;
                    }

                    irpStack->Control &= ~SL_PENDING_RETURNED;

                    DEBUGPRINT1((
                        "Sbp2Port: Power: ext=x%p PoReqPowerIrp err=x%x\n",
                        deviceExtension,
                        status
                        ));
                }

                Irp->IoStatus.Status = status;
                PoStartNextPowerIrp (Irp);
                IoReleaseRemoveLock (&deviceExtension->RemoveLock, NULL);
                IoCompleteRequest(Irp,IO_NO_INCREMENT);
                return status;

            } else {

                DEBUGPRINT2(("Sbp2Port: Power:   dev power chg from %x to %x\n",deviceExtension->DevicePowerState,State));
                KeAcquireSpinLock(&deviceExtension->ExtensionDataSpinLock,&cIrql);
                deviceExtension->DevicePowerState = State.DeviceState;
                KeReleaseSpinLock(&deviceExtension->ExtensionDataSpinLock,cIrql);
            }

            status = STATUS_SUCCESS;
            break;

        case IRP_MN_WAIT_WAKE:
        case IRP_MN_POWER_SEQUENCE:
        case IRP_MN_QUERY_POWER:

            status = STATUS_SUCCESS;
            break;

        default:

            status = Irp->IoStatus.Status;
            break;
        }

        Irp->IoStatus.Status = status;
        PoStartNextPowerIrp (Irp);
        IoCompleteRequest (Irp, IO_NO_INCREMENT);

        if ((minorFunction == IRP_MN_SET_POWER) &&
            (State.DeviceState == PowerDeviceD0)) {

            //
            // restart our queue if we had to queue something while powering up
            //
            // ISSUE: This may be bad - there is already some logic in
            //        SBP2SCSI.C to restart the queue on power up, i.e.
            //        the UNLOCK_QUEUE handler. For now i am at least
            //        limiting this to SET_POWER irps when state is D0
            //        DanKn 02-Jun-2001
            //

            KeRaiseIrql (DISPATCH_LEVEL, &cIrql);

            Sbp2StartNextPacketByKey(
                DeviceObject,
                deviceExtension->CurrentKey
                );

            KeLowerIrql (cIrql);
        }

        IoReleaseRemoveLock (&deviceExtension->RemoveLock, NULL);

        return (status);

    case SBP2_FDO:

        fdoExtension = (PFDO_DEVICE_EXTENSION) deviceExtension;

        complRoutine = NULL;

        if (irpStack->MinorFunction == IRP_MN_SET_POWER) {

            DEBUGPRINT2((
                "Sbp2Port: Power:   Type = %d, State = %d\n",
                irpStack->Parameters.Power.Type,
                irpStack->Parameters.Power.State.DeviceState
                ));

            if (irpStack->Parameters.Power.Type == SystemPowerState) {

                State = irpStack->Parameters.Power.State;

                DEBUGPRINT2((
                    "Sbp2Port: Power:   sys power chg from %x to %x\n",
                    fdoExtension->SystemPowerState,
                    State
                    ));

                if (State.SystemState >= PowerSystemShutdown) {

                    //
                    // Shutdown  (setting state here, the assumption being
                    // that we're shutting down regardless of the
                    // completion status of this request)
                    //

                    fdoExtension->SystemPowerState = State.SystemState;

                } else if ((fdoExtension->SystemPowerState ==
                                PowerSystemWorking) &&

                           (State.SystemState != PowerSystemWorking)) {

                    //
                    // Power down.  If DevPowerState != D3 then send
                    // a D irp first (when that completes successfully
                    // we'll continue with the S irp), else just
                    // set the completion routine so we can update
                    // the system state field in our extension on
                    // successful completion of this S irp.
                    //

                    if (fdoExtension->DevicePowerState != PowerDeviceD3) {

                        //
                        // Power down, send a D irp first
                        //

                        IoMarkIrpPending (Irp);

                        fdoExtension->SystemPowerIrp = Irp;

                        State.DeviceState = PowerDeviceD3;

                        DEBUGPRINT2((
                            "Sbp2Port: Power:   ext=x%p sending D irp for state %x\n",
                            deviceExtension,
                            State
                            ));

                        status = PoRequestPowerIrp(
                            fdoExtension->Pdo,
                            IRP_MN_SET_POWER,
                            State,
                            Sbp2FdoDIrpCompletion,
                            fdoExtension,
                            NULL
                            );

                        if (!NT_SUCCESS (status)) {

                            DEBUGPRINT1((
                                "Sbp2Port: Power: ext=x%p PoReqPowerIrp err=x%x\n",
                                fdoExtension,
                                status
                                ));

                            irpStack->Control &= ~SL_PENDING_RETURNED;
                            Irp->IoStatus.Status = status;
                            PoStartNextPowerIrp (Irp);
                            IoCompleteRequest (Irp,IO_NO_INCREMENT);
                        }

                        return status;

                    } else {

                        complRoutine = Sbp2FdoSIrpCompletion;
                    }

                } else if (State.SystemState == PowerSystemWorking) {

                    //
                    // Power up.  Set the completion routine so we
                    // follow up with a D irp or update the system
                    // state field in our extension on successful
                    // completion of this S irp.
                    //

                    complRoutine = Sbp2FdoSIrpCompletion;
                }
            }
        }

        PoStartNextPowerIrp (Irp);
        IoCopyCurrentIrpStackLocationToNext (Irp);

        if (complRoutine) {

            IoSetCompletionRoutine(
                Irp,
                Sbp2FdoSIrpCompletion,
                NULL,
                TRUE,
                TRUE,
                TRUE
                );
        }

        return (PoCallDriver (deviceExtension->LowerDeviceObject, Irp));

    default:

        break;
    }

    Irp->IoStatus.Status = STATUS_NO_SUCH_DEVICE;
    PoStartNextPowerIrp (Irp);
    IoCompleteRequest (Irp,IO_NO_INCREMENT);
    return STATUS_NO_SUCH_DEVICE;
}


VOID
Sbp2PdoDIrpCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN UCHAR MinorFunction,
    IN POWER_STATE PowerState,
    IN PIRP SIrp,
    IN PIO_STATUS_BLOCK IoStatus
    )
{
    PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;

    ASSERT(deviceExtension->Type == SBP2_PDO);

    if (SIrp) {

        PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation (SIrp);
        SYSTEM_POWER_STATE state = irpStack->Parameters.Power.State.SystemState;

        DEBUGPRINT1((
            "Sbp2Port: PdoDIrpCompl: ext=x%p, sIrp=x%p, state=%d, status=x%x\n",
            deviceExtension,
            SIrp,
            PowerState.DeviceState,
            IoStatus->Status
            ));

        SIrp->IoStatus.Status = STATUS_SUCCESS;

        PoStartNextPowerIrp (SIrp);
        IoReleaseRemoveLock (&deviceExtension->RemoveLock, NULL);
        IoCompleteRequest (SIrp, IO_NO_INCREMENT);
    }
}


NTSTATUS
Sbp2FdoSIrpCompletion(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp,
    IN PVOID            Unused
    )
{
    KIRQL                   cIrql;
    NTSTATUS                status = Irp->IoStatus.Status;
    POWER_STATE             state;
    PIO_STACK_LOCATION      irpStack = IoGetCurrentIrpStackLocation (Irp);
    PFDO_DEVICE_EXTENSION   fdoExtension = DeviceObject->DeviceExtension;


    state = irpStack->Parameters.Power.State;

    DEBUGPRINT1((
        "Sbp2Port: FdoSIrpCompl: fdoExt=x%p, status=x%x, state=%d\n",
        fdoExtension,
        status,
        state
        ));

    if (!NT_SUCCESS (status)) {

        if ((status == STATUS_NO_SUCH_DEVICE)  &&
            (state.SystemState == PowerSystemWorking)) {

            //
            // Controller (i.e. pc card) was ejected while powered down
            //

            SET_FLAG(
                fdoExtension->DeviceFlags,
                DEVICE_FLAG_ABSENT_ON_POWER_UP
                );
        }

        PoStartNextPowerIrp (Irp);
        return STATUS_SUCCESS;
    }

    //
    // If we're completing a power up S irp then see if we have
    // to follow up with a power up D irp
    //

    if ((state.SystemState == PowerSystemWorking)  &&
        (fdoExtension->DevicePowerState != PowerDeviceD0)) {

        fdoExtension->SystemPowerIrp = Irp;

        state.DeviceState = PowerDeviceD0;

        DEBUGPRINT1(("Sbp2Port: FdoSIrpCompl: sending D irp...\n"));

        status = PoRequestPowerIrp(
            fdoExtension->Pdo,
            IRP_MN_SET_POWER,
            state,
            Sbp2FdoDIrpCompletion,
            fdoExtension,
            NULL
            );

        if (!NT_SUCCESS (status)) {

            DEBUGPRINT1((
                "Sbp2Port: FdoSIrpCompl: ERROR! fdoExt=x%p, D irp sts=x%x\n",
                fdoExtension,
                status
                ));

            Irp->IoStatus.Status = status;
            PoStartNextPowerIrp (Irp);
            return status;
        }

        return STATUS_MORE_PROCESSING_REQUIRED;
    }


    //
    // Update appropriate XxxPowerState extension fields
    //

    if ((fdoExtension->SystemPowerState == PowerSystemWorking)  &&
        (state.SystemState != PowerSystemWorking)) {

        //
        // Power down (might not have sent a D irp but it doesn't
        // hurt to overwrite the DevicePowerState field anyway)
        //

        fdoExtension->SystemPowerState = state.SystemState;
        fdoExtension->DevicePowerState = PowerDeviceD3;

    } else if (state.SystemState == PowerSystemWorking) {

        //
        // Power up
        //

        fdoExtension->SystemPowerState = PowerSystemWorking;
    }

    PoStartNextPowerIrp (Irp);

    return STATUS_SUCCESS;
}


VOID
Sbp2FdoDIrpCompletion(
    IN PDEVICE_OBJECT           TargetDeviceObject,
    IN UCHAR                    MinorFunction,
    IN POWER_STATE              PowerState,
    IN PFDO_DEVICE_EXTENSION    FdoExtension,
    IN PIO_STATUS_BLOCK         IoStatus
    )
{
    PIRP    sIrp = FdoExtension->SystemPowerIrp;


    DEBUGPRINT1((
        "Sbp2Port: FdoDIrpCompl: ext=x%p, status=x%x\n",
        FdoExtension,
        IoStatus->Status
        ));

    FdoExtension->SystemPowerIrp = NULL;

    if (NT_SUCCESS (IoStatus->Status)) {

        if (PowerState.DeviceState == PowerDeviceD0) {

            //
            // Power up, update the XxxPowerState extension fields &
            // complete the s irp
            //

            FdoExtension->SystemPowerState = PowerSystemWorking;
            FdoExtension->DevicePowerState = PowerDeviceD0;

        } else {

            //
            // Power down, forward the s irp
            //

            PoStartNextPowerIrp (sIrp);
            IoCopyCurrentIrpStackLocationToNext (sIrp);
            PoCallDriver (FdoExtension->LowerDeviceObject, sIrp);

            return;
        }

    } else {

        //
        // Propagate the error to the S irp & complete it
        //

        DEBUGPRINT1((
            "Sbp2Port: FdoDIrpCompl: ERROR! fdoExt=x%p, D irp status=x%x\n",
            FdoExtension,
            IoStatus->Status
            ));

        sIrp->IoStatus.Status = IoStatus->Status;
    }

    PoStartNextPowerIrp (sIrp);
    IoCompleteRequest (sIrp, IO_NO_INCREMENT);
}


BOOLEAN
Sbp2EnableBusResetNotification(
    PDEVICE_EXTENSION   DeviceExtension,
    BOOLEAN             Enable
    )
/*++

Routine Description:

    This routine serializes the enabling/disabling of the bus reset
    notification routine for a set of related PDOs (1 or more).
    Enables bus reset notifications for the first device to start, and
    disables bus reset notifications when the last started device stops.

Arguments:

    DeviceObject - Supplies a pointer to the device extension for this request.

    StartDevice - Whether we are processing a START_DEVICE or (implicitly)
                  a STOP_DEVICE request.

Return Value:

   BOOLEAN - yay or nay

--*/
{
    BOOLEAN                 result = TRUE;
    PIRBIRP                 packet;
    LARGE_INTEGER           waitValue;
    PFDO_DEVICE_EXTENSION   fdoExtension;


    fdoExtension = DeviceExtension->BusFdo->DeviceExtension;

    ASSERT(InterlockedIncrement(&fdoExtension->ulBusResetMutexCount) == 1);

    waitValue.QuadPart = -3 * 1000 * 1000 * 10; // 3 seconds

    KeWaitForSingleObject(
        &fdoExtension->EnableBusResetNotificationMutex,
        Executive,
        KernelMode,
        FALSE,
        &waitValue
        );

    ASSERT(InterlockedDecrement(&fdoExtension->ulBusResetMutexCount) == 0);

    if (Enable) {

        fdoExtension->NumPDOsStarted++;

        if (fdoExtension->NumPDOsStarted > 1) {

            goto releaseMutex;
        }

    } else {

        fdoExtension->NumPDOsStarted--;

        if (fdoExtension->NumPDOsStarted > 0) {

            goto releaseMutex;
        }
    }

    AllocateIrpAndIrb (DeviceExtension, &packet);

    if (packet) {

        packet->Irb->FunctionNumber = REQUEST_BUS_RESET_NOTIFICATION;
        packet->Irb->Flags = 0;

        if (Enable) {

            packet->Irb->u.BusResetNotification.fulFlags =
                REGISTER_NOTIFICATION_ROUTINE;
            packet->Irb->u.BusResetNotification.ResetRoutine =
                (PBUS_BUS_RESET_NOTIFICATION) Sbp2BusResetNotification;
            packet->Irb->u.BusResetNotification.ResetContext =
                fdoExtension;

        } else {

            packet->Irb->u.BusResetNotification.fulFlags =
                DEREGISTER_NOTIFICATION_ROUTINE;
        }

        Sbp2SendRequest (DeviceExtension, packet, SYNC_1394_REQUEST);

        DeAllocateIrpAndIrb (DeviceExtension,packet);

    } else {

        if (Enable) {

            fdoExtension->NumPDOsStarted--;
        }

        result = FALSE;
    }

releaseMutex:

    KeReleaseMutex (&fdoExtension->EnableBusResetNotificationMutex, FALSE);

    return result;
}

NTSTATUS
Sbp2_BuildDeviceId(
    IN PDEVICE_INFORMATION  DeviceInfo,
    IN OUT PUNICODE_STRING  uniDeviceId
    )
{
    NTSTATUS    ntStatus = STATUS_SUCCESS;

    PAGED_CODE();

    //
    // Create the DeviceId
    //
    uniDeviceId->Length = 0;
    uniDeviceId->MaximumLength = DEVICE_NAME_MAX_CHARS*3;
    uniDeviceId->Buffer = ExAllocatePool(PagedPool, uniDeviceId->MaximumLength);

    if (!uniDeviceId->Buffer) {

        TRACE(TL_PNP_ERROR, ("Failed to allocate uniDeviceId->Buffer"));

        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
        goto Exit_Sbp2_BuildDeviceId;
    }
    RtlZeroMemory(uniDeviceId->Buffer, uniDeviceId->MaximumLength);

    // Format: SBP2\\<VendorName>&<ModelName>&LUN<#>
    if ((DeviceInfo->uniVendorId.Buffer) && (DeviceInfo->uniModelId.Buffer)) {

        swprintf( uniDeviceId->Buffer,
                  L"SBP2\\%ws&%ws&LUN%x",
                  DeviceInfo->uniVendorId.Buffer,
                  DeviceInfo->uniModelId.Buffer,
                  DeviceInfo->Lun.u.LowPart
                  );
    }
    else {

        swprintf( uniDeviceId->Buffer,
                  L"SBP2\\UNKNOWN VENDOR&UNKNOWN MODEL&LUN%x",
                  DeviceInfo->Lun.u.LowPart
                  );
    }

Exit_Sbp2_BuildDeviceId:

    return(ntStatus);
} // Sbp2_BuildDeviceId

NTSTATUS
Sbp2_BuildHardwareIds(
    IN PDEVICE_INFORMATION  DeviceInfo,
    IN OUT PUNICODE_STRING  uniHardwareIds
    )
{
    NTSTATUS        ntStatus = STATUS_SUCCESS;

    UNICODE_STRING  uniLunNumber;
    UNICODE_STRING  uniCmdSetId;

    PAGED_CODE();

    // init our unicodes in case of error...
    uniLunNumber.Buffer  = NULL;
    uniCmdSetId.Buffer   = NULL;

    //
    // Create uniLunNumber
    //
    uniLunNumber.Length = 0;
    uniLunNumber.MaximumLength = DEVICE_NAME_MAX_CHARS;
    uniLunNumber.Buffer = ExAllocatePool(PagedPool, uniLunNumber.MaximumLength);

    if (!uniLunNumber.Buffer) {

        TRACE(TL_PNP_ERROR, ("Failed to allocate uniLunNumber.Buffer"));

        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
        goto Exit_Sbp2_BuildHardwareIds;
    }
    RtlZeroMemory(uniLunNumber.Buffer, uniLunNumber.MaximumLength);

    RtlIntegerToUnicodeString(DeviceInfo->Lun.u.LowPart, 16, &uniLunNumber);

    //
    // Create uniCmdSetId
    //
    uniCmdSetId.Length = 0;
    uniCmdSetId.MaximumLength = DEVICE_NAME_MAX_CHARS;
    uniCmdSetId.Buffer = ExAllocatePool(PagedPool, uniCmdSetId.MaximumLength);

    if (!uniCmdSetId.Buffer) {

        TRACE(TL_PNP_ERROR, ("Failed to allocate uniCmdSetId.Buffer"));

        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
        goto Exit_Sbp2_BuildHardwareIds;
    }
    RtlZeroMemory(uniCmdSetId.Buffer, uniCmdSetId.MaximumLength);

    RtlIntegerToUnicodeString(DeviceInfo->CmdSetId.QuadPart, 16, &uniCmdSetId);

    //
    // Create the HardwareIds
    //
    uniHardwareIds->Length = 0;
    uniHardwareIds->MaximumLength = DEVICE_NAME_MAX_CHARS*5;
    uniHardwareIds->Buffer = ExAllocatePool(PagedPool, uniHardwareIds->MaximumLength);

    if (!uniHardwareIds->Buffer) {

        TRACE(TL_PNP_ERROR, ("Failed to allocate uniHardwareIds->Buffer"));

        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
        goto Exit_Sbp2_BuildHardwareIds;
    }
    RtlZeroMemory(uniHardwareIds->Buffer, uniHardwareIds->MaximumLength);

    // 1. SBP2\<Vendor>&<Model>&CmdSetId<number,base16>&Gen<dev type, ie. Disk>

    // BASE: SBP2
    RtlAppendUnicodeToString(uniHardwareIds, BASE_SBP2_DEVICE_NAME);

    // VendorName and ModelName
    if ((DeviceInfo->uniVendorId.Buffer) && (DeviceInfo->uniModelId.Buffer)) {

        RtlAppendUnicodeStringToString(uniHardwareIds, &DeviceInfo->uniVendorId);
        RtlAppendUnicodeToString(uniHardwareIds, L"&");
        RtlAppendUnicodeStringToString(uniHardwareIds, &DeviceInfo->uniModelId);
    }
    else {

        RtlAppendUnicodeToString(uniHardwareIds, L"UNKNOWN VENDOR&UNKNOWN MODEL");
    }
    RtlAppendUnicodeToString(uniHardwareIds, L"&");

    // CmdSetId
    RtlAppendUnicodeToString(uniHardwareIds, L"CmdSetId");
    RtlAppendUnicodeStringToString(uniHardwareIds, &uniCmdSetId);
    RtlAppendUnicodeToString(uniHardwareIds, L"&");

    // GenericName
    RtlAppendUnicodeStringToString(uniHardwareIds, &DeviceInfo->uniGenericName);

    uniHardwareIds->Length += sizeof(WCHAR);

    // 2. SBP2\<Vendor>&<Model>&CmdSetId<number,base16>

    // BASE: SBP2
    RtlAppendUnicodeToString(uniHardwareIds, BASE_SBP2_DEVICE_NAME);

    // VendorName and ModelName
    if ((DeviceInfo->uniVendorId.Buffer) && (DeviceInfo->uniModelId.Buffer)) {

        RtlAppendUnicodeStringToString(uniHardwareIds, &DeviceInfo->uniVendorId);
        RtlAppendUnicodeToString(uniHardwareIds, L"&");
        RtlAppendUnicodeStringToString(uniHardwareIds, &DeviceInfo->uniModelId);
    }
    else {

        RtlAppendUnicodeToString(uniHardwareIds, L"UNKNOWN VENDOR&UNKNOWN MODEL");
    }
    RtlAppendUnicodeToString(uniHardwareIds, L"&");

    // CmdSetId
    RtlAppendUnicodeToString(uniHardwareIds, L"CmdSetId");
    RtlAppendUnicodeStringToString(uniHardwareIds, &uniCmdSetId);

    uniHardwareIds->Length += sizeof(WCHAR);

    // 3. SBP2\<Vendor>&<Model>&LUN<number,base16>

    // BASE: SBP2
    RtlAppendUnicodeToString(uniHardwareIds, BASE_SBP2_DEVICE_NAME);

    // VendorName and ModelName
    if ((DeviceInfo->uniVendorId.Buffer) && (DeviceInfo->uniModelId.Buffer)) {

        RtlAppendUnicodeStringToString(uniHardwareIds, &DeviceInfo->uniVendorId);
        RtlAppendUnicodeToString(uniHardwareIds, L"&");
        RtlAppendUnicodeStringToString(uniHardwareIds, &DeviceInfo->uniModelId);
    }
    else {

        RtlAppendUnicodeToString(uniHardwareIds, L"UNKNOWN VENDOR&UNKNOWN MODEL");
    }
    RtlAppendUnicodeToString(uniHardwareIds, L"&");

    // LunNumber
    RtlAppendUnicodeToString(uniHardwareIds, L"LUN");
    RtlAppendUnicodeStringToString(uniHardwareIds, &uniLunNumber);

    uniHardwareIds->Length += sizeof(WCHAR);

    // 4. SBP2\Gen<dev type, i.e. Disk>

    // BASE: SBP2
    RtlAppendUnicodeToString(uniHardwareIds, BASE_SBP2_DEVICE_NAME);

    // GenericName
    RtlAppendUnicodeStringToString(uniHardwareIds, &DeviceInfo->uniGenericName);

    uniHardwareIds->Length += sizeof(WCHAR);

    // 5. Gen<dev type, i.e Disk>

    // GenericName
    RtlAppendUnicodeStringToString(uniHardwareIds, &DeviceInfo->uniGenericName);

Exit_Sbp2_BuildHardwareIds:

    if (uniLunNumber.Buffer)
        ExFreePool(uniLunNumber.Buffer);

    if (uniCmdSetId.Buffer)
        ExFreePool(uniCmdSetId.Buffer);

    return(ntStatus);
} // Sbp2_BuildHardwareIds

NTSTATUS
Sbp2_BuildCompatIds(
    IN PDEVICE_INFORMATION  DeviceInfo,
    IN OUT PUNICODE_STRING  uniCompatIds
    )
{
    NTSTATUS    ntStatus = STATUS_SUCCESS;

    PAGED_CODE();

    //
    // Create the CompatIds
    //
    uniCompatIds->Length = 0;
    uniCompatIds->MaximumLength = DEVICE_NAME_MAX_CHARS;
    uniCompatIds->Buffer = ExAllocatePool(PagedPool, uniCompatIds->MaximumLength);

    if (!uniCompatIds->Buffer) {

        TRACE(TL_PNP_ERROR, ("Failed to allocate uniCompatIds->Buffer"));

        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
        goto Exit_Sbp2_BuildCompatIds;
    }
    RtlZeroMemory(uniCompatIds->Buffer, uniCompatIds->MaximumLength);

    // Format: SBP2\\<CmdSetSpecId,base10>&<CmdSetId,base10>&<Lun,base10>

    swprintf( uniCompatIds->Buffer,
              L"SBP2\\%d&%d&%d",
              DeviceInfo->CmdSetSpecId.QuadPart,
              DeviceInfo->CmdSetId.QuadPart,
              (ULONG)(DeviceInfo->Lun.u.HighPart & 0x001F) // huh?
              );

Exit_Sbp2_BuildCompatIds:

    return(ntStatus);
} // Sbp2_BuildCompatIds

NTSTATUS
Sbp2_BuildInstanceId(
    IN PDEVICE_INFORMATION  DeviceInfo,
    IN OUT PUNICODE_STRING  uniInstanceId
    )
{
    NTSTATUS    ntStatus = STATUS_SUCCESS;

    PAGED_CODE();

    //
    // Create the InstanceId
    //
    uniInstanceId->Length = 0;
    uniInstanceId->MaximumLength = UNIQUE_ID_MAX_CHARS;
    uniInstanceId->Buffer = ExAllocatePool(PagedPool, uniInstanceId->MaximumLength);

    if (!uniInstanceId->Buffer) {

        TRACE(TL_PNP_ERROR, ("Failed to allocate uniInstanceId->Buffer"));

        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
        goto Exit_Sbp2_BuildInstanceId;
    }
    RtlZeroMemory(uniInstanceId->Buffer, uniInstanceId->MaximumLength);

    swprintf( uniInstanceId->Buffer,
              L"%08x%08x",
              bswap(DeviceInfo->ConfigRom->CR_Node_UniqueID[0]),
              bswap(DeviceInfo->ConfigRom->CR_Node_UniqueID[1])
              );

Exit_Sbp2_BuildInstanceId:

    return(ntStatus);
} // Sbp2_BuildInstanceId

NTSTATUS
Sbp2_BuildDeviceText(
    IN DEVICE_TEXT_TYPE     TextType,
    IN PDEVICE_INFORMATION  DeviceInfo,
    IN OUT PUNICODE_STRING  uniDeviceText
    )
{
    NTSTATUS    ntStatus = STATUS_SUCCESS;

    PAGED_CODE();

    //
    // Create the DeviceText
    //
    uniDeviceText->Length = 0;
    uniDeviceText->MaximumLength = DEVICE_NAME_MAX_CHARS*3;
    uniDeviceText->Buffer = ExAllocatePool(PagedPool, uniDeviceText->MaximumLength);

    if (!uniDeviceText->Buffer) {

        TRACE(TL_PNP_ERROR, ("Failed to allocate uniDeviceText->Buffer"));

        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
        goto Exit_Sbp2_BuildDeviceText;
    }
    RtlZeroMemory(uniDeviceText->Buffer, uniDeviceText->MaximumLength);

    if (TextType == DeviceTextDescription) {

        if ((DeviceInfo->uniVendorId.Buffer) && (DeviceInfo->uniModelId.Buffer)) {

            swprintf( uniDeviceText->Buffer,
                      L"%ws %ws IEEE 1394 SBP2 Device",
                      DeviceInfo->uniVendorId.Buffer,
                      DeviceInfo->uniModelId.Buffer
                      );
        }
        else {

            swprintf( uniDeviceText->Buffer,
                      L"UNKNOWN VENDOR AND MODEL IEEE 1394 SBP2 Device"
                      );
        }
    }
    else if (TextType == DeviceTextLocationInformation) {

        swprintf( uniDeviceText->Buffer,
                  L"LUN %d",
                  DeviceInfo->Lun.u.LowPart
                  );
    }

Exit_Sbp2_BuildDeviceText:

    return(ntStatus);
} // Sbp2_BuildDeviceText


NTSTATUS
Sbp2ForwardIrpSynchronous(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp
    )
{
    NTSTATUS ntStatus = STATUS_SUCCESS;
    PIRP  newIrp;

    PAGED_CODE();

    ASSERT(DeviceObject);

    newIrp = IoAllocateIrp(DeviceObject->StackSize, FALSE);

    if (newIrp)
    {
        PIO_STACK_LOCATION currentIrpSp = IoGetCurrentIrpStackLocation(Irp);
        PIO_STACK_LOCATION newIrpSp = IoGetNextIrpStackLocation(newIrp);

        KEVENT event;

        RtlMoveMemory (newIrpSp, currentIrpSp, sizeof(IO_STACK_LOCATION));
        newIrp->IoStatus = Irp->IoStatus;

        KeInitializeEvent(&event, NotificationEvent, FALSE);

        IoSetCompletionRoutine(newIrp, Sbp2PortForwardIrpSynchronousCompletionRoutine, &event, TRUE, TRUE, TRUE);

        ntStatus = IoCallDriver (DeviceObject, newIrp);

        if (ntStatus == STATUS_PENDING)
        {
            KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
        }

        ntStatus = newIrp->IoStatus.Status;

        IoFreeIrp(newIrp);
    }
    else
    {
        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
    }

    return ntStatus;
}


NTSTATUS
Sbp2PortForwardIrpSynchronousCompletionRoutine(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp,
    IN PVOID            Context
    )
{
    PKEVENT event = Context;

    KeSetEvent(event, EVENT_INCREMENT, FALSE);

    return STATUS_MORE_PROCESSING_REQUIRED;
}